src/jpeg_parser.c

   1 /*
   2  * Geeqie
   3  * (C) 2004 John Ellis
   4  * Copyright (C) 2008 - 2011 The Geeqie Team
   5  *
   6  * Author: Vladimir Nadvornik
   7  *
   8  * This software is released under the GNU General Public License (GNU GPL).
   9  * Please read the included file COPYING for more information.
  10  * This software comes with no warranty of any kind, use at your own risk!
  11  */
  12
  13 #include "main.h"
  14 #include "jpeg_parser.h"
  15
  16 gboolean jpeg_segment_find(guchar *data, guint size,
  17                             guchar app_marker, const gchar *magic, guint magic_len,
  18                             guint *seg_offset, guint *seg_length)
  19 {
  20         guchar marker = 0;
  21         guint offset = 0;
  22         guint length = 0;
  23
  24         while (marker != JPEG_MARKER_EOI)
  25                 {
  26                 offset += length;
  27                 length = 2;
  28
  29                 if (offset + 2 >= size ||
  30                     data[offset] != JPEG_MARKER) return FALSE;
  31
  32                 marker = data[offset + 1];
  33                 if (marker != JPEG_MARKER_SOI &&
  34                     marker != JPEG_MARKER_EOI)
  35                         {
  36                         if (offset + 4 >= size) return FALSE;
  37                         length += ((guint)data[offset + 2] << 8) + data[offset + 3];
  38
  39                         if (marker == app_marker &&
  40                             offset + length < size &&
  41                             length >= 4 + magic_len &&
  42                             memcmp(data + offset + 4, magic, magic_len) == 0)
  43                                 {
  44                                 *seg_offset = offset + 4;
  45                                 *seg_length = length - 4;
  46                                 return TRUE;
  47                                 }
  48                         }
  49                 }
  50         return FALSE;
  51 }
  52
  53
  54 typedef enum {
  55         TIFF_BYTE_ORDER_INTEL,
  56         TIFF_BYTE_ORDER_MOTOROLA
  57 } TiffByteOrder;
  58
  59 #define TIFF_TIFD_OFFSET_TAG 0
  60 #define TIFF_TIFD_OFFSET_FORMAT 2
  61 #define TIFF_TIFD_OFFSET_COUNT 4
  62 #define TIFF_TIFD_OFFSET_DATA 8
  63 #define TIFF_TIFD_SIZE 12
  64
  65
  66
  67 guint16 tiff_byte_get_int16(guchar *f, TiffByteOrder bo)
  68 {
  69         guint16 align_buf;
  70
  71         memcpy(&align_buf, f, sizeof(guint16));
  72
  73         if (bo == TIFF_BYTE_ORDER_INTEL)
  74                 return GUINT16_FROM_LE(align_buf);
  75         else
  76                 return GUINT16_FROM_BE(align_buf);
  77 }
  78
  79 guint32 tiff_byte_get_int32(guchar *f, TiffByteOrder bo)
  80 {
  81         guint32 align_buf;
  82
  83         memcpy(&align_buf, f, sizeof(guint32));
  84
  85         if (bo == TIFF_BYTE_ORDER_INTEL)
  86                 return GUINT32_FROM_LE(align_buf);
  87         else
  88                 return GUINT32_FROM_BE(align_buf);
  89 }
  90
  91 void tiff_byte_put_int16(guchar *f, guint16 n, TiffByteOrder bo)
  92 {
  93         guint16 align_buf;
  94
  95         if (bo == TIFF_BYTE_ORDER_INTEL)
  96                 {
  97                 align_buf = GUINT16_TO_LE(n);
  98                 }
  99         else
 100                 {
 101                 align_buf = GUINT16_TO_BE(n);
 102                 }
 103
 104         memcpy(f, &align_buf, sizeof(guint16));
 105 }
 106
 107 void tiff_byte_put_int32(guchar *f, guint32 n, TiffByteOrder bo)
 108 {
 109         guint32 align_buf;
 110
 111         if (bo == TIFF_BYTE_ORDER_INTEL)
 112                 {
 113                 align_buf = GUINT32_TO_LE(n);
 114                 }
 115         else
 116                 {
 117                 align_buf = GUINT32_TO_BE(n);
 118                 }
 119
 120         memcpy(f, &align_buf, sizeof(guint32));
 121 }
 122
 123 gint tiff_directory_offset(guchar *data, const guint len,
 124                                 guint *offset, TiffByteOrder *bo)
 125 {
 126         if (len < 8) return FALSE;
 127
 128         if (memcmp(data, "II", 2) == 0)
 129                 {
 130                 *bo = TIFF_BYTE_ORDER_INTEL;
 131                 }
 132         else if (memcmp(data, "MM", 2) == 0)
 133                 {
 134                 *bo = TIFF_BYTE_ORDER_MOTOROLA;
 135                 }
 136         else
 137                 {
 138                 return FALSE;
 139                 }
 140
 141         if (tiff_byte_get_int16(data + 2, *bo) != 0x002A)
 142                 {
 143                 return FALSE;
 144                 }
 145
 146         *offset = tiff_byte_get_int32(data + 4, *bo);
 147
 148         return (*offset < len);
 149 }
 150
 151 typedef gint (* FuncParseIFDEntry)(guchar *tiff, guint offset,
 152                                  guint size, TiffByteOrder bo,
 153                                  gpointer data);
 154
 155
 156 gint tiff_parse_IFD_table(guchar *tiff, guint offset,
 157                           guint size, TiffByteOrder bo,
 158                           guint *next_offset,
 159                           FuncParseIFDEntry parse_entry, gpointer data)
 160 {
 161         guint count;
 162         guint i;
 163         guint next;
 164
 165
 166         /* We should be able to read number of entries in IFD0) */
 167         if (size < offset + 2) return -1;
 168
 169         count = tiff_byte_get_int16(tiff + offset, bo);
 170         offset += 2;
 171 printf("count %d\n", count);
 172         /* Entries and next IFD offset must be readable */
 173         if (size < offset + count * TIFF_TIFD_SIZE + 4) return -1;
 174
 175         for (i = 0; i < count; i++)
 176                 {
 177                 parse_entry(tiff, offset + i * TIFF_TIFD_SIZE, size, bo, data);
 178                 }
 179
 180         next = tiff_byte_get_int32(tiff + offset + count * TIFF_TIFD_SIZE, bo);
 181 printf("next %d\n", next);
 182         if (next_offset) *next_offset = next;
 183
 184         return 0;
 185 }
 186
 187 static gint mpo_parse_Index_IFD_entry(guchar *tiff, guint offset,
 188                                  guint size, TiffByteOrder bo,
 189                                  gpointer data)
 190 {
 191         guint tag;
 192         guint format;
 193         guint count;
 194         guint data_val;
 195         guint data_offset;
 196         guint data_length;
 197
 198         MPOData *mpo = data;
 199
 200         tag = tiff_byte_get_int16(tiff + offset + TIFF_TIFD_OFFSET_TAG, bo);
 201         format = tiff_byte_get_int16(tiff + offset + TIFF_TIFD_OFFSET_FORMAT, bo);
 202         count = tiff_byte_get_int32(tiff + offset + TIFF_TIFD_OFFSET_COUNT, bo);
 203         data_val = tiff_byte_get_int32(tiff + offset + TIFF_TIFD_OFFSET_DATA, bo);
 204 printf("tag %x format %x count %x data_val %x\n", tag, format, count, data_val);
 205
 206         if (tag == 0xb000)
 207                 {
 208                 mpo->version = data_val;
 209                 }
 210         else if (tag == 0xb001)
 211                 {
 212                 mpo->num_images = data_val;
 213                 }
 214         else if (tag == 0xb002)
 215                 {
 216                 guint i;
 217                 data_offset = data_val;
 218                 data_length = count;
 219                 if (size < data_offset || size < data_offset + data_length)
 220                         {
 221                         return -1;
 222                         }
 223                 if (count != mpo->num_images * 16)
 224                         {
 225                         return -1;
 226                         }
 227
 228                 mpo->images = g_new0(MPOEntry, mpo->num_images);
 229
 230                 for (i = 0; i < mpo->num_images; i++) {
 231                         guint image_attr = tiff_byte_get_int32(tiff + data_offset + i * 16, bo);
 232                         mpo->images[i].type_code = image_attr & 0xffffff;
 233                         mpo->images[i].representative = !!(image_attr & 0x20000000);
 234                         mpo->images[i].dependent_child = !!(image_attr & 0x40000000);
 235                         mpo->images[i].dependent_parent = !!(image_attr & 0x80000000);
 236                         mpo->images[i].length = tiff_byte_get_int32(tiff + data_offset + i * 16 + 4, bo);
 237                         mpo->images[i].offset = tiff_byte_get_int32(tiff + data_offset + i * 16 + 8, bo);
 238                         mpo->images[i].dep1 = tiff_byte_get_int16(tiff + data_offset + i * 16 + 12, bo);
 239                         mpo->images[i].dep2 = tiff_byte_get_int16(tiff + data_offset + i * 16 + 14, bo);
 240
 241                         if (i == 0)
 242                                 {
 243                                 mpo->images[i].offset = 0;
 244                                 }
 245                         else
 246                                 {
 247                                 mpo->images[i].offset += mpo->mpo_offset;
 248                                 }
 249
 250                         printf("img %x %x %x\n", image_attr, mpo->images[i].length, mpo->images[i].offset);
 251                         }
 252                 }
 253
 254         return 0;
 255 }
 256
 257 MPOData *jpeg_get_mpo_data(guchar *data, guint size)
 258 {
 259         guint seg_offset;
 260         guint seg_size;
 261         if (jpeg_segment_find(data, size, JPEG_MARKER_APP2, "MPF\x00", 4, &seg_offset, &seg_size) && seg_size >16)
 262                 {
 263                 guint offset;
 264                 TiffByteOrder bo;
 265                 MPOData *mpo;
 266                 guint i;
 267
 268                 printf("mpo signature found at %x\n", seg_offset);
 269                 data += seg_offset + 4;
 270                 seg_size -= 4;
 271
 272                 if (!tiff_directory_offset(data, seg_size, &offset, &bo)) return NULL;
 273
 274                 mpo = g_new0(MPOData, 1);
 275                 mpo->mpo_offset = seg_offset + 4;
 276
 277                 tiff_parse_IFD_table(data,  offset , seg_size, bo, NULL, mpo_parse_Index_IFD_entry, (gpointer)mpo);
 278                 if (!mpo->images) mpo->num_images = 0;
 279
 280                 for (i = 0; i < mpo->num_images; i++)
 281                         {
 282                         if (mpo->images[i].offset + mpo->images[i].length > size)
 283                                 {
 284                                 mpo->num_images = i;
 285                                 DEBUG_1("MPO file truncated to %d valid images", i);
 286                                 break;
 287                                 }
 288                         }
 289                 return mpo;
 290                 }
 291         return NULL;
 292 }
 293
 294 void jpeg_mpo_data_free(MPOData *mpo)
 295 {
 296         if (mpo)
 297                 {
 298                 if (mpo->images) g_free(mpo->images);
 299                 g_free(mpo);
 300                 }
 301 }