Class: Cul::Image::Properties::Exif::EXIF_header

Inherits:
Object
  • Object
show all
Defined in:
lib/cul_image_props/image/properties/exif/types.rb

Overview

class that handles an EXIF header

Constant Summary collapse

X00 = 
[0x00].pack('C')

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(file, endian, offset, fake_exif, strict, detail = true) ⇒ EXIF_header

Returns a new instance of EXIF_header.



151
152
153
154
155
156
157
158
159
 
# File 'lib/cul_image_props/image/properties/exif/types.rb', line 151

def initialize(file, endian, offset, fake_exif, strict, detail=true)
    @file = file
    @endian = endian
    @offset = offset
    @fake_exif = fake_exif
    @strict = strict
    @detail = detail
    @tags = {}
end

Instance Attribute Details

#tags ⇒ Object

Returns the value of attribute tags.



150
151
152
 
# File 'lib/cul_image_props/image/properties/exif/types.rb', line 150

def tags
  @tags
end

Class Method Details

.s2n_intel(src) ⇒ Object

extract multibyte integer in Intel format (little endian)



176
177
178
179
180
181
182
183
184
185
186
187
188
 
# File 'lib/cul_image_props/image/properties/exif/types.rb', line 176

def self.s2n_intel(src)
  x = 0
  l = src.bytesize
  if l == 1
    return src.unpack('C')[0]
  elsif l == 2
    return src.unpack('v')[0]
  elsif l == 4 
    return src.unpack('V')[0]
  else
    raise "Unexpected packed Fixnum length: " + l.to_s
  end
end

.s2n_motorola(src) ⇒ Object

extract multibyte integer in Motorola format (big/network endian)



162
163
164
165
166
167
168
169
170
171
172
173
174
 
# File 'lib/cul_image_props/image/properties/exif/types.rb', line 162

def self.s2n_motorola(src)
  x = 0
  l = src.bytesize
  if l == 1
    return src.unpack('C')[0]
  elsif l == 2
    return src.unpack('n')[0]
  elsif l == 4
    return src.unpack('N')[0]
  else
    raise "Unexpected packed Fixnum length: " + l.to_s
  end
end

Instance Method Details

#canon_decode_tag(value, dict) ⇒ Object

decode Canon MakerNote tag based on offset within tag see http =>//www.burren.cx/david/canon.html by David Burren



518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
 
# File 'lib/cul_image_props/image/properties/exif/types.rb', line 518

def canon_decode_tag(value, dict)
    (1 ... len(value)).each { |i|
        x=dict.get(i, ['Unknown'])

        name=x[0]
        if len(x) > 1
            val=x[1].get(value[i], 'Unknown')
        else
            val=value[i]
        end
        # it's not a real IFD Tag but we fake one to make everybody
        # happy. this will have a "proprietary" type
        self.tags['MakerNote '+name]=IFD_Tag(str(val), None, 0, None,
                                             None, None)
    }
end

#decode_maker_note ⇒ Object

Note is the data that comprises this MakerNote. The MakerNote will likely have pointers in it that point to other parts of the file. We’ll use self.offset as the starting point for most of those pointers, since they are relative to the beginning of the file.

If the MakerNote is in a newer format, it may use relative addressing within the MakerNote. In that case we’ll use relative addresses for the pointers.

As an aside => it’s not just to be annoying that the manufacturers use relative offsets. It’s so that if the makernote has to be moved by the picture software all of the offsets don’t have to be adjusted. Overall, this is probably the right strategy for makernotes, though the spec is ambiguous. (The spec does not appear to imagine that makernotes would follow EXIF format internally. Once they did, it’s ambiguous whether the offsets should be from the header at the start of all the EXIF info, or from the header at the start of the makernote.)



437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
 
# File 'lib/cul_image_props/image/properties/exif/types.rb', line 437

def decode_maker_note()
    note = self.tags['EXIF MakerNote']
    
    # Some apps use MakerNote tags but do not use a format for which we
    # have a description, so just do a raw dump for these.

    make = self.tags['Image Make'].printable

    # Nikon
    # The maker note usually starts with the word Nikon, followed by the
    # type of the makernote (1 or 2, as a short).  If the word Nikon is
    # not at the start of the makernote, it's probably type 2, since some
    # cameras work that way.
    if make.include? 'NIKON'
        if note.values[0,7] == [78, 105, 107, 111, 110, 0, 1]
            self.dump_IFD(note.field_offset+8, 'MakerNote',
                          :dict=>MAKERNOTE_NIKON_OLDER_TAGS)
        elsif note.values[0, 7] == [78, 105, 107, 111, 110, 0, 2]
            if note.values[12,2] != [0, 42] and note.values[12,2] != [42, 0]
                raise "Missing marker tag '42' in MakerNote."
            end
            # skip the Makernote label and the TIFF header
            self.dump_IFD(note.field_offset+10+8, 'MakerNote',
                          :dict=>MAKERNOTE_NIKON_NEWER_TAGS, :relative=>true)
        else
            # E99x or D1
            self.dump_IFD(note.field_offset, 'MakerNote',
                          :dict=>MAKERNOTE_NIKON_NEWER_TAGS)
        end
        return
    end
    # Olympus
    if make.index('OLYMPUS') == 0
        self.dump_IFD(note.field_offset+8, 'MakerNote',
                      :dict=>MAKERNOTE_OLYMPUS_TAGS)
        return
    end
    # Casio
    if make.include? 'CASIO' or make.include? 'Casio'
        self.dump_IFD(note.field_offset, 'MakerNote',
                      :dict=>MAKERNOTE_CASIO_TAGS)
        return
    end
    # Fujifilm
    if make == 'FUJIFILM'
        # bug => everything else is "Motorola" endian, but the MakerNote
        # is "Intel" endian
        endian = self.endian
        self.endian = 'I'
        # bug => IFD offsets are from beginning of MakerNote, not
        # beginning of file header
        offset = self.offset
        self.offset += note.field_offset
        # process note with bogus values (note is actually at offset 12)
        self.dump_IFD(12, 'MakerNote', :dict=>MAKERNOTE_FUJIFILM_TAGS)
        # reset to correct values
        self.endian = endian
        self.offset = offset
        return
    end
    # Canon
    if make == 'Canon'
        self.dump_IFD(note.field_offset, 'MakerNote',
                      :dict=>MAKERNOTE_CANON_TAGS)
        [['MakerNote Tag 0x0001', MAKERNOTE_CANON_TAG_0x001],
                  ['MakerNote Tag 0x0004', MAKERNOTE_CANON_TAG_0x004]].each { |i|
            begin
              self.canon_decode_tag(self.tags[i[0]].values, i[1])  # gd added 
            rescue
            end
        }
        return
    end
end

#dump_IFD(ifd, ifd_name, opts) ⇒ Object

def dump_IFD(ifd, ifd_name, dict=EXIF_TAGS, relative=false, stop_tag=‘UNDEF’)



262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
 
# File 'lib/cul_image_props/image/properties/exif/types.rb', line 262

def dump_IFD(ifd, ifd_name, opts)
    opts = {:dict => EXIF_TAGS, :relative => false, :stop_tag => 'UNDEF'}.merge(opts)
    dict = opts[:dict]
    relative = opts[:relative]
    stop_tag = opts[:stop_tag]
    @file.seek(@offset + ifd)
    entries = unpack_number(@file.read(2))
    entries_ptr = ifd + 2
    puts ifd_name + " had zero entries!" if entries == 0
    (0 ... entries).each { |i|
        # entry is index of start of this IFD in the file
        entry = ifd + 2 + (12 * i)
        @file.seek(@offset + entry)
        tag_id = unpack_number(@file.read(2))

        # get tag name early to avoid errors, help debug
        tag_entry = dict[tag_id] || TagEntry.new('Tag 0x%04X' % tag_id)

        # ignore certain tags for faster processing
        if not (not @detail and IGNORE_TAGS.include? tag_id)
            # The 12 byte Tag format is ID (short) TYPE (short) COUNT (long) VALUE (long)
            # if actual values would exceed 4 bytes (long), VALUE
            # is instead a pointer to the actual values.
            field_type = unpack_number(@file.read(2))
            
            # unknown field type
            if 0 > field_type or field_type >= FIELD_TYPES.length
                if not @strict
                    next
                else
                    raise format("unknown type %d in tag 0x%04X", field_type, tag)
                end
            end
            typelen = FIELD_TYPES[field_type].length
            count = unpack_number(@file.read(4))

            # If the value exceeds 4 bytes, it is a pointer to values.
            if (count * typelen) > 4
                # Note that 'relative' is a fix for the Nikon type 3 makernote.
                field_offset = unpack_number(@file.read(4))
                if relative
                    field_offset = field_offset + ifd - 8
                    if @fake_exif
                        field_offset = field_offset + 18
                    end
                end
            else
              field_offset = entry + 8
            end

            if field_type == 2
                # special case => null-terminated ASCII string
                # XXX investigate
                # sometimes gets too big to fit in int value
                if count != 0 and count < (2**31)
                    @file.seek(@offset + field_offset)
                    values = @file.read(count) # ascii string of count bytes
                    #print values
                    # Drop any garbage after a null.
                    values = values.split(X00, 1)[0] # a null-terminated string
                else
                    values = ''
                end
            else
                values = []
                signed = [6, 8, 9, 10].include? field_type
                
                # @todo investigate
                # some entries get too big to handle could be malformed file
                if count < 1000 or tag_entry.name == 'MakerNote'
                    @file.seek(@offset + field_offset)
                    count.times {
                        if field_type == 5 or field_type == 10
                            # a ratio
                            value = Ratio.new(unpack_number(@file.read(4), signed),
                                          unpack_number(@file.read(4), signed) )
                        else
                            value = unpack_number(@file.read(typelen), signed)
                        end
                        values << value
                    }
                end
            end
            
            self.tags[ifd_name + ' ' + tag_entry.name] = IFD_Tag.new(tag_id,
                                                      field_type, tag_entry,
                                                      values, field_offset,
                                                      count)
        end
        if tag_entry.name == stop_tag
            break
        end
    }
end

#extract_TIFF_thumbnail(thumb_ifd) ⇒ Object

extract uncompressed TIFF thumbnail (like pulling teeth) we take advantage of the pre-existing layout in the thumbnail IFD as much as possible



360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
 
# File 'lib/cul_image_props/image/properties/exif/types.rb', line 360

def extract_TIFF_thumbnail(thumb_ifd)
    entries = self.s2n(thumb_ifd, 2)
    # this is header plus offset to IFD ...
    if @endian == 'M'
        tiff = "MM#{X00}*" + [0x00,0x00,0x00,0x00,0x08].pack('C*')
    else
        tiff = 'II*' + [0x00,0x08,0x00,0x00,0x00].pack('C*')
    end
    # ... plus thumbnail IFD data plus a null "next IFD" pointer
    self.file.seek(self.offset+thumb_ifd)
    tiff += self.file.read(entries*12+2)+[0x00,0x00,0x00,0x00].pack('C*')

    # fix up large value offset pointers into data area
    (0...entries).each { |i|
        entry = thumb_ifd + 2 + 12 * i
        tag = self.s2n(entry, 2)
        field_type = self.s2n(entry+2, 2)
        typelen = FIELD_TYPES[field_type].length
        count = self.s2n(entry+4, 4)
        oldoff = self.s2n(entry+8, 4)
        # start of the 4-byte pointer area in entry
        ptr = i * 12 + 18
        # remember strip offsets location
        if tag == 0x0111
            strip_off = ptr
            strip_len = count * typelen
        end
        # is it in the data area?
        if count * typelen > 4
            # update offset pointer (nasty "strings are immutable" crap)
            # should be able to say "tiff[ptr..ptr+4]=newoff"
            newoff = len(tiff)
            tiff = tiff[ 0..ptr] + self.n2s(newoff, 4) + tiff[ptr+4...tiff.length]
            # remember strip offsets location
            if tag == 0x0111
                strip_off = newoff
                strip_len = 4
            end
            # get original data and store it
            self.file.seek(self.offset + oldoff)
            tiff += self.file.read(count * typelen)
        end
    }
    # add pixel strips and update strip offset info
    old_offsets = self.tags['Thumbnail StripOffsets'].values
    old_counts = self.tags['Thumbnail StripByteCounts'].values
    (0...len(old_offsets)).each { |i|
        # update offset pointer (more nasty "strings are immutable" crap)
        offset = self.n2s(len(tiff), strip_len)
        tiff = tiff[ 0..strip_off] + offset + tiff[strip_off + strip_len ... tiff.length]
        strip_off += strip_len
        # add pixel strip to end
        self.file.seek(self.offset + old_offsets[i])
        tiff += self.file.read(old_counts[i])
    }
    self.tags['TIFFThumbnail'] = tiff
end

#first_IFD ⇒ Object

return first IFD



236
237
238
239
 
# File 'lib/cul_image_props/image/properties/exif/types.rb', line 236

def first_IFD()
    @file.seek(@offset + 4)
    return unpack_number(@file.read(4))
end

#list_IFDs ⇒ Object

return list of IFDs in header



250
251
252
253
254
255
256
257
258
 
# File 'lib/cul_image_props/image/properties/exif/types.rb', line 250

def list_IFDs()
    i=self.first_IFD()
    a=[]
    while i != 0
        a << i
        i=self.next_IFD(i)
    end
    return a
end

#n2s(offset, length) ⇒ Object

convert offset to string



222
223
224
225
226
227
228
229
230
231
232
233
 
# File 'lib/cul_image_props/image/properties/exif/types.rb', line 222

def n2s(offset, length)
    s = ''
    length.times {
        if @endian == 'I'
            s = s + chr(offset & 0xFF)
        else
            s = chr(offset & 0xFF) + s
        end
        offset = offset >> 8
    }
    return s
end

#next_IFD(ifd) ⇒ Object

return pointer to next IFD



242
243
244
245
246
247
 
# File 'lib/cul_image_props/image/properties/exif/types.rb', line 242

def next_IFD(ifd)
    @file.seek(@offset + ifd)
    entries = unpack_number(@file.read(2))
    @file.seek((12*entries), IO::SEEK_CUR)
    return unpack_number(@file.read(4))
end

#olympus_decode_tag(value, dict) ⇒ Object

XXX TODO decode Olympus MakerNote tag based on offset within tag



513
514
 
# File 'lib/cul_image_props/image/properties/exif/types.rb', line 513

def olympus_decode_tag(value, dict)
end

#s2n(offset, length, signed = false) ⇒ Object

convert slice to integer, based on sign and endian flags usually this offset is assumed to be relative to the beginning of the start of the EXIF information. For some cameras that use relative tags, this offset may be relative to some other starting point.



210
211
212
213
214
215
216
217
218
219
 
# File 'lib/cul_image_props/image/properties/exif/types.rb', line 210

def s2n(offset, length, signed=false)
    @file.seek(@offset+offset)
    if @file.eof? and length != 0
      # raise "Read past EOF"
      puts "Read past EOF"
      return 0
    end
    slice=@file.read(length)
    return unpack_number(slice,signed)
end

#unpack_number(src, signed = false) ⇒ Object 



190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
 
# File 'lib/cul_image_props/image/properties/exif/types.rb', line 190

def unpack_number(src, signed=false)
    if @endian == 'I'
        val = EXIF_header.s2n_intel(src)
    else
        val = EXIF_header.s2n_motorola(src)
    end
    # Sign extension ?
    if signed
        msb= 1 << (8*src.length-1)
        if val & msb
            val=val-(msb << 1)
        end
    end
    return val
end