add gpujpeg_decoder_get_image_info2

to be used instead of gpujpeg_decoder_get_image_info

Author: MartinPulec

CMakeLists.txt

@@ -1,6 +1,6 @@
 cmake_minimum_required(VERSION 3.10.0 FATAL_ERROR)
 # change version also in configure.ac
-project(gpujpeg VERSION 0.27.8 LANGUAGES C CUDA)
+project(gpujpeg VERSION 0.27.9 LANGUAGES C CUDA)
 
 # options
 set(BUILD_OPENGL OFF CACHE STRING "Build with OpenGL support, options are: AUTO ON OFF")

NEWS.md

@@ -1,3 +1,9 @@
+2025-10-20 - 0.27.9
+----------
+
+- add gpujpeg_decoder_get_image_info2 as a extensible replacement for
+gpujpeg_decoder_get_image_info
+
 2025-08-22 - 0.27.8
 ----------
 

configure.ac

@@ -1,6 +1,6 @@
 AC_PREREQ([2.65])
 # change version also in CMakeLists.txt
-AC_INIT([libgpujpeg],[0.27.8],[https://github.com/CESNET/GPUJPEG/issues],[libgpujpeg],[https://github.com/CESNET/GPUJPEG])
+AC_INIT([libgpujpeg],[0.27.9],[https://github.com/CESNET/GPUJPEG/issues],[libgpujpeg],[https://github.com/CESNET/GPUJPEG])
 AC_CONFIG_MACRO_DIR([m4])
 AC_CONFIG_SRCDIR([src/main.c])
 AC_CONFIG_AUX_DIR([.])

libgpujpeg/gpujpeg_common.h

@@ -142,6 +142,10 @@ gpujpeg_print_devices_info(void);
 /**
  * Init CUDA device
  *
+ * This call is not mandatory if you do not want to use other than default CUDA
+ * device (if not set with cudaSetDevice()) or to specify flags. The advantage is
+ * that this will check CUDA device operability early.
+ *
  * @param device_id  CUDA device id (starting at 0)
  * @param flags  @ref Flags, e.g. if device info should be printed out (@ref GPUJPEG_INIT_DEV_VERBOSE) or
  *               enable OpenGL interoperability (@ref GPUJPEG_OPENGL_INTEROPERABILITY)

libgpujpeg/gpujpeg_decoder.h

@@ -261,10 +261,27 @@ gpujpeg_decoder_set_output_format(struct gpujpeg_decoder* decoder,
                 enum gpujpeg_color_space color_space,
                 enum gpujpeg_pixel_format pixel_format);
 
+enum {
+    GPUJPEG_COUNT_SEG_COUNT_REQ = 1 << 0, ///< count up segment_count
+};
+struct gpujpeg_image_info {
+    union {
+        struct
+        {
+            struct gpujpeg_image_parameters param_image;
+            struct gpujpeg_parameters param;
+            int segment_count;
+        };
+        char reserved[128]; // for further extensions
+    };
+};
 /**
  * @copydoc gpujpeg_reader_get_image_info
  */
 GPUJPEG_API int
+gpujpeg_decoder_get_image_info2(uint8_t *image, size_t image_size, struct gpujpeg_image_info *info, int verbose, unsigned flags);
+/// use gpujpeg_decoder_get_image_info2()
+GPUJPEG_API int
 gpujpeg_decoder_get_image_info(uint8_t *image, size_t image_size, struct gpujpeg_image_parameters *param_image, struct gpujpeg_parameters *param, int *segment_count);
 
 /// use RLE when writing TGA with gpujpeg_image_save_to_file (default is true), 0 or 1 please note that the option is

src/gpujpeg_decoder.c

@@ -551,7 +551,27 @@ gpujpeg_decoder_destroy(struct gpujpeg_decoder* decoder)
 
 int
 gpujpeg_decoder_get_image_info(uint8_t *image, size_t image_size, struct gpujpeg_image_parameters *param_image, struct gpujpeg_parameters *param, int *segment_count) {
-    return gpujpeg_reader_get_image_info(image, image_size, param_image, param, segment_count);
+    struct gpujpeg_image_info info = { 0 };
+    const unsigned flags = segment_count == NULL ? 0 : GPUJPEG_COUNT_SEG_COUNT_REQ;
+    const int verbose = param->verbose;
+    const int rc = gpujpeg_reader_get_image_info(image, image_size, &info, verbose, flags);
+    if ( rc != GPUJPEG_NOERR ) {
+        return rc;
+    };
+    memcpy(param_image, &info.param_image, sizeof *param_image);
+    memcpy(param, &info.param, sizeof *param);
+    param->verbose = verbose;
+    if ( segment_count != NULL ) {
+        *segment_count = info.segment_count;
+    }
+    return GPUJPEG_NOERR;
+}
+
+GPUJPEG_API int
+gpujpeg_decoder_get_image_info2(uint8_t* image, size_t image_size, struct gpujpeg_image_info* info, int verbose,
+                                unsigned flags)
+{
+    return gpujpeg_reader_get_image_info(image, image_size, info, verbose, flags);
 }
 
 /* vi: set expandtab sw=4 : */

src/gpujpeg_reader.c

@@ -1664,8 +1664,10 @@ gcd(int a, int b)
 
 /* Documented at declaration */
 int
-gpujpeg_reader_get_image_info(uint8_t *image, size_t image_size, struct gpujpeg_image_parameters *param_image, struct gpujpeg_parameters *param, int *segment_count)
+gpujpeg_reader_get_image_info(uint8_t *image, size_t image_size, struct gpujpeg_image_info *info, int verbose, unsigned flags)
 {
+    // gpujpeg_reader_get_image_info(uint8_t *image, size_t image_size, struct gpujpeg_image_parameters *param_image,
+    // struct gpujpeg_parameters *param, int *segment_count)
     int segments = 0;
     int unused[4];
     uint8_t unused2[4];
@@ -1674,11 +1676,11 @@ gpujpeg_reader_get_image_info(uint8_t *image, size_t image_size, struct gpujpeg_
     uint8_t *image_end = image + image_size;
     struct gpujpeg_exif_parameters exif_metadata;
 
-    param->interleaved = 0;
-    param->restart_interval = 0;
+    info->param.interleaved = 0;
+    info->param.restart_interval = 0;
 
     // Check first SOI marker
-    int marker_soi = gpujpeg_reader_read_marker(&image, image_end, param->verbose);
+    int marker_soi = gpujpeg_reader_read_marker(&image, image_end, verbose);
     if (marker_soi != GPUJPEG_MARKER_SOI) {
         fprintf(stderr, "[GPUJPEG] [Error] JPEG data should begin with SOI marker, but marker %s was found!\n", gpujpeg_marker_name((enum gpujpeg_marker_code)marker_soi));
         return -1;
@@ -1688,15 +1690,15 @@ gpujpeg_reader_get_image_info(uint8_t *image, size_t image_size, struct gpujpeg_
     _Bool in_spiff = 0;
     while (eoi_presented == 0) {
         // Read marker
-        int marker = gpujpeg_reader_read_marker(&image, image_end, param->verbose);
+        int marker = gpujpeg_reader_read_marker(&image, image_end, verbose);
         if (marker == -1) {
             return -1;
         }
 
         // Read more info according to the marker
         int rc =
-            gpujpeg_reader_read_common_markers(&image, image_end, marker, param->verbose, false, &header_color_space,
-                                               &header_type, &param->restart_interval, &in_spiff, &exif_metadata);
+            gpujpeg_reader_read_common_markers(&image, image_end, marker, verbose, false, &header_color_space,
+                                               &header_type, &info->param.restart_interval, &in_spiff, &exif_metadata);
         if ( rc < 0 ) {
             return rc;
         }
@@ -1708,12 +1710,12 @@ gpujpeg_reader_get_image_info(uint8_t *image, size_t image_size, struct gpujpeg_
         case GPUJPEG_MARKER_SOF0: // Baseline
         case GPUJPEG_MARKER_SOF1: // Extended sequential with Huffman coder
         {
-            param->color_space_internal = header_color_space;
-            if ( gpujpeg_reader_read_sof0(param, param_image, header_color_space, header_type, unused, unused2, &image,
+            info->param.color_space_internal = header_color_space;
+            if ( gpujpeg_reader_read_sof0(&info->param, &info->param_image, header_color_space, header_type, unused, unused2, &image,
                                           image_end) != 0 ) {
                 return -1;
             }
-            param_image->color_space = param->color_space_internal;
+            info->param_image.color_space = info->param.color_space_internal;
             break;
         }
         case GPUJPEG_MARKER_RST0:
@@ -1738,9 +1740,9 @@ gpujpeg_reader_get_image_info(uint8_t *image, size_t image_size, struct gpujpeg_
                 assert(length > 3);
                 int comp_count = (int) gpujpeg_reader_read_byte(image); // comp count in the segment
                 if (comp_count > 1) {
-                    param->interleaved = 1;
+                    info->param.interleaved = 1;
                 }
-                if (segment_count == NULL) { // if not counting segments, we can skip the rest
+                if ( (flags & GPUJPEG_COUNT_SEG_COUNT_REQ) != 0 ) { // if not counting segments, we can skip the rest
                     eoi_presented = 1;
                 }
             }
@@ -1787,55 +1789,53 @@ gpujpeg_reader_get_image_info(uint8_t *image, size_t image_size, struct gpujpeg_
         }
     }
 
-    if (segment_count != NULL) {
-        *segment_count = segments;
-    }
+    info->segment_count = segments;
 
-    param_image->pixel_format = GPUJPEG_PIXFMT_NONE;
+    info->param_image.pixel_format = GPUJPEG_PIXFMT_NONE;
 
-    if ( param->comp_count == 1 ) {
-        param_image->pixel_format = GPUJPEG_U8;
+    if ( info->param.comp_count == 1 ) {
+        info->param_image.pixel_format = GPUJPEG_U8;
     }
-    if ( param->comp_count == 3 ) {
+    if ( info->param.comp_count == 3 ) {
         // reduce [2, 2; 1, 2; 1, 2] (FFmpeg) to [2, 1; 1, 1; 1, 1]
-        int horizontal_gcd = param->sampling_factor[0].horizontal;
-        int vertical_gcd = param->sampling_factor[0].vertical;
+        int horizontal_gcd = info->param.sampling_factor[0].horizontal;
+        int vertical_gcd = info->param.sampling_factor[0].vertical;
         for (int i = 1; i < 3; ++i) {
-            horizontal_gcd = gcd(horizontal_gcd, param->sampling_factor[i].horizontal);
-            vertical_gcd = gcd(vertical_gcd, param->sampling_factor[i].vertical);
+            horizontal_gcd = gcd(horizontal_gcd, info->param.sampling_factor[i].horizontal);
+            vertical_gcd = gcd(vertical_gcd, info->param.sampling_factor[i].vertical);
         }
         for (int i = 0; i < 3; ++i) {
-            param->sampling_factor[i].horizontal /= horizontal_gcd;
-            param->sampling_factor[i].vertical /= vertical_gcd;
+            info->param.sampling_factor[i].horizontal /= horizontal_gcd;
+            info->param.sampling_factor[i].vertical /= vertical_gcd;
         }
 
-        if (param->sampling_factor[1].horizontal == 1 && param->sampling_factor[1].vertical == 1
-                && param->sampling_factor[2].horizontal == 1 && param->sampling_factor[2].vertical == 1) {
-            int sum = param->interleaved << 16 | param->sampling_factor[0].horizontal << 8 |
-                      param->sampling_factor[0].vertical; // NOLINT
+        if (info->param.sampling_factor[1].horizontal == 1 && info->param.sampling_factor[1].vertical == 1
+                && info->param.sampling_factor[2].horizontal == 1 && info->param.sampling_factor[2].vertical == 1) {
+            int sum = info->param.interleaved << 16 | info->param.sampling_factor[0].horizontal << 8 |
+                      info->param.sampling_factor[0].vertical; // NOLINT
             switch (sum) {
-                case 1<<16 | 1<<8 | 1: param_image->pixel_format = GPUJPEG_444_U8_P012; break;   // NOLINT
-                case 0<<16 | 1<<8 | 1: param_image->pixel_format = GPUJPEG_444_U8_P0P1P2; break; // NOLINT
-                case 1<<16 | 2<<8 | 1: param_image->pixel_format = GPUJPEG_422_U8_P1020; break;  // NOLINT
-                case 0<<16 | 2<<8 | 1: param_image->pixel_format = GPUJPEG_422_U8_P0P1P2; break; // NOLINT
+                case 1<<16 | 1<<8 | 1: info->param_image.pixel_format = GPUJPEG_444_U8_P012; break;   // NOLINT
+                case 0<<16 | 1<<8 | 1: info->param_image.pixel_format = GPUJPEG_444_U8_P0P1P2; break; // NOLINT
+                case 1<<16 | 2<<8 | 1: info->param_image.pixel_format = GPUJPEG_422_U8_P1020; break;  // NOLINT
+                case 0<<16 | 2<<8 | 1: info->param_image.pixel_format = GPUJPEG_422_U8_P0P1P2; break; // NOLINT
                 case 1<<16 | 2<<8 | 2: // we have only one pixfmt for 420, so use for both          NOLINT
-                case 0<<16 | 2<<8 | 2: param_image->pixel_format = GPUJPEG_420_U8_P0P1P2; break; // NOLINT
+                case 0<<16 | 2<<8 | 2: info->param_image.pixel_format = GPUJPEG_420_U8_P0P1P2; break; // NOLINT
                 default: break;
             }
         }
     }
 
-    if ( param->comp_count == 4 ) {
+    if ( info->param.comp_count == 4 ) {
         _Bool subsampling_is4444 = 1;
         for (int i = 1; i < 4; ++i) {
-            if (param->sampling_factor[i].horizontal != param->sampling_factor[0].horizontal
-                    || param->sampling_factor[i].vertical != param->sampling_factor[0].vertical) {
+            if (info->param.sampling_factor[i].horizontal != info->param.sampling_factor[0].horizontal
+                    || info->param.sampling_factor[i].vertical != info->param.sampling_factor[0].vertical) {
                 subsampling_is4444 = 0;
                 break;
             }
         }
         if (subsampling_is4444) {
-            param_image->pixel_format = GPUJPEG_4444_U8_P0123;
+            info->param_image.pixel_format = GPUJPEG_4444_U8_P0123;
         }
     }
 

src/gpujpeg_reader.h

@@ -1,6 +1,6 @@
 /**
  * @file
- * Copyright (c) 2011-2023, CESNET z.s.p.o
+ * Copyright (c) 2011-2025, CESNET zájmové sdružení právnických osob
  * Copyright (c) 2011, Silicon Genome, LLC.
  *
  * All rights reserved.
@@ -32,13 +32,15 @@
 #define GPUJPEG_READER_H
 
 #include "../libgpujpeg/gpujpeg_common.h"
+#include <stddef.h>
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 /** JPEG decoder structure predeclaration */
 struct gpujpeg_decoder;
+struct gpujpeg_image_info; // declared in libgpujpeg/gpujpeg_decoder.h
 
 /**
  * Read JPEG image from data buffer
@@ -60,15 +62,14 @@ gpujpeg_reader_read_image(struct gpujpeg_decoder* decoder, uint8_t* image, size_
  *
  * @param image  Image data
  * @param image_size  Image data size
- * @param[out]    param_image   parameters obtained from image, must not be NULL
- * @param[in,out] param         parameters obtained from image (verbose parameter is used as an input param), non-NULL
- * @param[out]    segment_count number of segments (may be NULL if parameter segment_count is not needed)
+ * @param[out]    info parameters obtained from image, must not be NULL
+ * @param[in]     flags - 0 or GPUJPEG_COUNT_SEG_COUNT
  * @return 0 if succeeds, otherwise nonzero
  *
  * @todo refactorize common code with gpujpeg_reader_read_image()
  */
 int
-gpujpeg_reader_get_image_info(uint8_t *image, size_t image_size, struct gpujpeg_image_parameters *param_image, struct gpujpeg_parameters *param, int *segment_count);
+gpujpeg_reader_get_image_info(uint8_t *image, size_t image_size, struct gpujpeg_image_info *info, int verbose, unsigned flags);
 
 #ifdef __cplusplus
 }

src/main.c

@@ -200,17 +200,13 @@ static int print_image_info_jpeg(const char *filename, int verbose) {
         fprintf(stderr, "Cannot read image contents.\n");
         return 1;
     }
-    struct gpujpeg_image_parameters params_image = gpujpeg_default_image_parameters();
-    params_image.pixel_format = GPUJPEG_PIXFMT_NONE;
-    struct gpujpeg_parameters params =  gpujpeg_default_parameters();
-    params.verbose = verbose;
-    int segment_count = 0;
-    if (gpujpeg_decoder_get_image_info(jpeg, len, &params_image, &params, &segment_count) == 0) {
-        print_gpujpeg_image_parameters(params_image, false,
-                                       gpujpeg_subsampling_get_name(params.comp_count, params.sampling_factor));
-        printf("interleaved: %d\n", params.interleaved);
-        if ( segment_count ) {
-            printf("segment count: %d (DRI = %d)\n", segment_count, params.restart_interval);
+    struct gpujpeg_image_info info = { 0 };
+    if (gpujpeg_decoder_get_image_info2(jpeg, len, &info, verbose, GPUJPEG_COUNT_SEG_COUNT_REQ) == 0) {
+        print_gpujpeg_image_parameters(info.param_image, false,
+                                       gpujpeg_subsampling_get_name(info.param.comp_count, info.param.sampling_factor));
+        printf("interleaved: %d\n", info.param.interleaved);
+        if ( info.segment_count ) {
+            printf("segment count: %d (DRI = %d)\n", info.segment_count, info.param.restart_interval);
         }
     }
     free(jpeg);