gpujpeg_decoder_get_image_info2: add orientation

and more in general metadata (now just the orientation)

- print it with gpujpegtool
- add struct for that (value def/interpretation as in SPIFF)

Author: MartinPulec

libgpujpeg/gpujpeg_common.h

@@ -686,6 +686,9 @@ gpujpeg_pixel_format_is_planar(enum gpujpeg_pixel_format pixel_format);
 GPUJPEG_API void
 gpujpeg_device_reset(void);
 
+GPUJPEG_API const char*
+gpujpeg_orientation_get_name(struct gpujpeg_orientation orientation);
+
 #ifdef __cplusplus
 }
 #endif

libgpujpeg/gpujpeg_decoder.h

@@ -273,6 +273,7 @@ struct gpujpeg_image_info {
             int segment_count;
             enum gpujpeg_header_type header_type;
             const char* comment; ///< NULL-terminated COM marker, ptr to img buffer
+            struct gpujpeg_image_metadata metadata;
         };
         char reserved[512]; // for further extensions
     };

libgpujpeg/gpujpeg_type.h

@@ -142,6 +142,17 @@ struct gpujpeg_component_sampling_factor
     uint8_t vertical;
 };
 
+struct gpujpeg_orientation /// as defined in SPIFF
+{
+    unsigned rotation : 2; ///< in multiples of 90° clock-wise
+    unsigned flip : 1;     ///< 1 - left-to-right orientation flipped after rotation applied
+};
+
+struct gpujpeg_image_metadata
+{
+    struct gpujpeg_orientation orientation;
+};
+
 #ifdef __cplusplus
 }
 #endif

src/gpujpeg_common.c

@@ -2368,4 +2368,20 @@ gpujpeg_header_type_get_name(enum gpujpeg_header_type header_type) {
     abort();
 }
 
+GPUJPEG_API const char*
+gpujpeg_orientation_get_name(struct gpujpeg_orientation orientation)
+{
+    switch (orientation.rotation << 1 | orientation.flip) {
+        case 0<<1 | 0: return "normal";
+        case 0<<1 | 1: return "mirror horizontal";
+        case 1<<1 | 0: return "rotated CW 90 deg";
+        case 1<<1 | 1: return "rotated CW 90 and mirrored horizontal";
+        case 2<<1 | 0: return "rotated 180 deg";
+        case 2<<1 | 1: return "flipped vertical";
+        case 3<<1 | 0: return "rotated CW 270 deg";
+        case 3<<1 | 1: return "rotated CW 270 deg and mirrored horizontal";
+    }
+    abort();
+}
+
 /* vi: set expandtab sw=4 : */

src/gpujpeg_exif.c

@@ -144,6 +144,7 @@ const struct exif_tiff_tag_info_t {
 // misc constants
 enum {
     ETIFF_CENTER = 1,
+    ETIFF_ORIENTATION_VERTICAL = 1,
     ETIFF_SRGB = 1,
     ETIFF_INCHES = 2,
     NEXT_IFD_PTR_SZ = 4,
@@ -324,7 +325,7 @@ gpujpeg_write_0th(struct gpujpeg_writer* writer, const uint8_t* start,
     struct tm buf;
     (void) strftime(date_time, sizeof date_time, "%Y:%m:%d %H:%M:%S", localtime_s(&now, &buf));
     struct tag_value tags[] = {
-        {ETIFF_ORIENTATION,       {.uvalue = (uint32_t[]){EXIF_ORIENTATION_HORIZONTAL}}},
+        {ETIFF_ORIENTATION,       {.uvalue = (uint32_t[]){ETIFF_ORIENTATION_VERTICAL}}},
         {ETIFF_XRESOLUTION,       {.uvalue = (uint32_t[]){DPI_DEFAULT, 1}}             },
         {ETIFF_YRESOLUTION,       {.uvalue = (uint32_t[]){DPI_DEFAULT, 1}}             },
         {ETIFF_RESOLUTION_UNIT,   {.uvalue = (uint32_t[]){ETIFF_INCHES}}               },
@@ -611,9 +612,31 @@ read_4byte_le(uint8_t** image) {
     return ret;
 }
 
+static void
+exif_orieintation_to_metadata(unsigned val, struct gpujpeg_image_metadata* parsed)
+{
+    if (val == 0 || val > 8) {
+        WARN_MSG(MOD_NAME "Flawed orientation value %d! Should be 1-8...\n", val);
+        return;
+    }
+    // clang-format off
+    struct gpujpeg_orientation map[] = {
+        {0, 0}, // 1 = The 0th row is at the visual top of the image, and the 0th column is the visual left-hand side.
+        {0, 1}, // 2 = The 0th row is at the visual top of the image, and the 0th column is the visual right-hand side.
+        {2, 0}, // 3 = The 0th row is at the visual bottom of the image, and the 0th column is the visual right-hand side.
+        {2, 1}, // 4 = The 0th row is at the visual bottom of the image, and the 0th column is the visual left-hand side.
+        {1, 1}, // 5 = The 0th row is the visual left-hand side of the image, and the 0th column is the visual top.
+        {1, 0}, // 6 = The 0th row is the visual right-hand side of the image, and the 0th column is the visual top.
+        {3, 1}, // 7 = The 0th row is the visual right-hand side of the image, and the 0th column is the visual bottom.
+        {3, 0}, // 8 = The 0th row is the visual left-hand side of the image, and the 0th column is the visual bottom.
+    };
+    // clang-format on
+    parsed->orientation = map[val - 1];
+}
+
 static void
 read_0th_ifd(uint8_t** image, const uint8_t* image_end, int verbose, uint16_t (*read_2byte)(uint8_t**),
-             uint32_t (*read_4byte)(uint8_t**), struct gpujpeg_exif_parameters* parsed)
+             uint32_t (*read_4byte)(uint8_t**), struct gpujpeg_image_metadata* parsed)
 {
     if ( *image + 2 > image_end ) {
         WARN_MSG("Unexpected end of file!\n");
@@ -646,7 +669,7 @@ read_0th_ifd(uint8_t** image, const uint8_t* image_end, int verbose, uint16_t (*
         DEBUG_MSG(verbose, MOD_NAME "Found IFD0 tag %s (%#x) type %s: count=%u, %s=%#x\n", exif_tiff_tag_info[tag].name,
                   tag_id, type_name, count, count * size <= 4 ? "value" : "offset", val);
         if ( tag == ETIFF_ORIENTATION ) {
-            parsed->orientation = val;
+            exif_orieintation_to_metadata(val, parsed);
         }
     }
 
@@ -663,7 +686,7 @@ read_0th_ifd(uint8_t** image, const uint8_t* image_end, int verbose, uint16_t (*
  * JPEG Orientation is checked and of not horizontal, warning is issued.
  */
 void
-gpujpeg_exif_parse(uint8_t** image, const uint8_t* image_end, int verbose, struct gpujpeg_exif_parameters* parsed)
+gpujpeg_exif_parse(uint8_t** image, const uint8_t* image_end, int verbose, struct gpujpeg_image_metadata* metadata)
 {
 #define HANDLE_ERROR(...)                                                                                              \
     WARN_MSG(__VA_ARGS__);                                                                                             \
@@ -713,7 +736,7 @@ gpujpeg_exif_parse(uint8_t** image, const uint8_t* image_end, int verbose, struc
 
     uint32_t offset = read_4byte(image); // 0th IFD offset
     *image = base + offset;
-    read_0th_ifd(image, image_end, verbose, read_2byte, read_4byte, parsed);
+    read_0th_ifd(image, image_end, verbose, read_2byte, read_4byte, metadata);
 
     *image = image_start + length;
 #undef HANDLE_ERROR

src/gpujpeg_exif.h

@@ -34,14 +34,11 @@
 #include <stdint.h>
 
 struct gpujpeg_exif_tags;
+struct gpujpeg_image_metadata;
 struct gpujpeg_image_parameters;
 struct gpujpeg_parameters;
 struct gpujpeg_writer;
 
-enum {
-    EXIF_ORIENTATION_HORIZONTAL = 1, // normal
-};
-
 void
 gpujpeg_writer_write_exif(struct gpujpeg_writer* writer, const struct gpujpeg_parameters* param,
                           const struct gpujpeg_image_parameters* param_image,
@@ -52,12 +49,7 @@ gpujpeg_exif_add_tag(struct gpujpeg_exif_tags** exif_tags, const char *cfg);
 void
 gpujpeg_exif_tags_destroy(struct gpujpeg_exif_tags* exif_tags);
 
-struct gpujpeg_exif_parameters
-{
-    unsigned orientation; ///< EXIF_ORIENTATION_HORIZONTAL or a different value
-};
-
 void
-gpujpeg_exif_parse(uint8_t** image, const uint8_t* image_end, int verbose, struct gpujpeg_exif_parameters* parsed);
+gpujpeg_exif_parse(uint8_t** image, const uint8_t* image_end, int verbose, struct gpujpeg_image_metadata* metadata);
 
 #endif // defined GPUJPEG_EXIF_H_6755D546_2A90_46DF_9ECA_22F575C3E7E3

src/gpujpeg_reader.c

@@ -94,7 +94,7 @@ struct gpujpeg_reader
     enum gpujpeg_color_space header_color_space;
     enum gpujpeg_header_type header_type;
     bool in_spiff;
-    struct gpujpeg_exif_parameters exif_metadata;
+    struct gpujpeg_image_metadata metadata;
     const char *comment;
 };
 
@@ -309,31 +309,28 @@ gpujpeg_reader_read_app0(uint8_t** image, const uint8_t* image_end, enum gpujpeg
 }
 
 static void
-gpujpeg_reader_read_app1(uint8_t** image, const uint8_t* image_end, enum gpujpeg_header_type* header_type,
-                         enum gpujpeg_color_space* color_space, int verbose,
-                         struct gpujpeg_exif_parameters* exif_metadata)
+gpujpeg_reader_read_app1(uint8_t** image, struct gpujpeg_reader *reader)
 {
-    if ( image_end - *image < 2 ) {
+    if ( reader->image_end - *image < 2 ) {
         ERROR_MSG("Unexpected end of APP1 marker!\n");
         return;
     }
 
     uint8_t type_tag[50];
     unsigned i = 0;
     const uint8_t* ptr = *image + 2;
-    while ( *ptr != '\0' && ptr < image_end && i < sizeof type_tag  - 1 ) {
+    while ( *ptr != '\0' && ptr < reader->image_end && i < sizeof type_tag  - 1 ) {
         type_tag[i++] = *ptr++;
     }
     type_tag[i] = '\0';
     if ( strcmp((char *) type_tag, "Exif") == 0 ) {
-        *color_space = GPUJPEG_YCBCR_BT601_256LVLS;
-        *header_type = GPUJPEG_HEADER_EXIF;
-        memset(exif_metadata, 0, sizeof *exif_metadata);
-        gpujpeg_exif_parse(image, image_end, verbose, exif_metadata);
+        reader->header_color_space = GPUJPEG_YCBCR_BT601_256LVLS;
+        reader->header_type = GPUJPEG_HEADER_EXIF;
+        gpujpeg_exif_parse(image, reader->image_end, reader->param.verbose, &reader->metadata);
         return;
     }
     WARN_MSG("Skipping unsupported APP1 marker \"%s\"!\n", type_tag);
-    gpujpeg_reader_skip_marker_content(image, image_end);
+    gpujpeg_reader_skip_marker_content(image, reader->image_end);
 }
 
 /**
@@ -1386,8 +1383,7 @@ gpujpeg_reader_read_common_markers(uint8_t** image, int marker, struct gpujpeg_r
             }
             break;
         case GPUJPEG_MARKER_APP1:
-            gpujpeg_reader_read_app1(image, reader->image_end, &reader->header_type, &reader->header_color_space,
-                                     reader->param.verbose, &reader->exif_metadata);
+            gpujpeg_reader_read_app1(image, reader);
             break;
         case GPUJPEG_MARKER_APP8:
             if ( gpujpeg_reader_read_app8(image, reader->image_end, &reader->header_color_space, &reader->header_type,
@@ -1642,9 +1638,8 @@ gpujpeg_reader_read_image(struct gpujpeg_decoder* decoder, uint8_t* image, size_
         return -1;
     }
 
-    if ( reader.header_type == GPUJPEG_HEADER_EXIF &&
-         reader.exif_metadata.orientation != EXIF_ORIENTATION_HORIZONTAL ) {
-        WARN_MSG("Exif %d not handled!\n", reader.exif_metadata.orientation);
+    if ( reader.metadata.orientation.rotation != 0 || reader.metadata.orientation.flip != 0 ) {
+        WARN_MSG("Orientation %s not handled!\n", gpujpeg_orientation_get_name(reader.metadata.orientation));
     }
 
     return 0;
@@ -1793,6 +1788,7 @@ gpujpeg_reader_get_image_info(uint8_t *image, size_t image_size, struct gpujpeg_
     info->segment_count = segments;
     info->header_type = reader.header_type;
     info->comment = reader.comment;
+    info->metadata = reader.metadata;
 
     if ( info->param.comp_count == 1 ) {
         info->param_image.pixel_format = GPUJPEG_U8;

src/main.c

@@ -206,6 +206,7 @@ static int print_image_info_jpeg(const char *filename, int verbose) {
                                        gpujpeg_subsampling_get_name(info.param.comp_count, info.param.sampling_factor));
         printf("interleaved: %d\n", info.param.interleaved);
         printf("header type: %s\n", gpujpeg_header_type_get_name(info.header_type));
+        printf("orientation: %s\n", gpujpeg_orientation_get_name(info.metadata.orientation));
         if ( info.segment_count ) {
             printf("segment count: %d (DRI = %d)\n", info.segment_count, info.param.restart_interval);
         }