exiftool_vendored 9.37.0 → 9.41.0

data/bin/{Image-ExifTool-9.37 → Image-ExifTool-9.41}/lib/Image/ExifTool/MWG.pm

@@ -16,7 +16,7 @@ use Image::ExifTool qw(:DataAccess :Utils);
 use Image::ExifTool::Exif;
 use Image::ExifTool::XMP;
 
-$VERSION = '1.13';
+$VERSION = '1.14';
 
 sub RecoverTruncatedIPTC($$$);
 sub ListToString($);
@@ -575,7 +575,7 @@ sub ListToString($)
 # Notes: Sets Warning tag on error
 sub StringToList($$)
 {
-    my ($str, $exifTool) = @_;
+    my ($str, $et) = @_;
     my (@vals, $inQuotes);
     my @t = split '; ', $str, -1;
     foreach (@t) {
@@ -594,7 +594,7 @@ sub StringToList($$)
             push @vals, $_;
         }
     }
-    $exifTool->Warn('Incorrectly quoted MWG string-list value') if $inQuotes;
+    $et->Warn('Incorrectly quoted MWG string-list value') if $inQuotes;
     return @vals > 1 ? \@vals : $vals[0];
 }
 
@@ -606,11 +606,11 @@ sub StringToList($$)
 sub OverwriteStringList($$$$)
 {
     local $_;
-    my ($exifTool, $nvHash, $val, $newValuePt) = @_;
+    my ($et, $nvHash, $val, $newValuePt) = @_;
     my (@new, $delIndex);
     if ($$nvHash{DelValue} and defined $val) {
         # preserve specified old values
-        my $old = StringToList($val, $exifTool);
+        my $old = StringToList($val, $et);
         my @old = ref $old eq 'ARRAY' ? @$old : $old;
         if (@{$$nvHash{DelValue}}) {
             my %del;
@@ -646,17 +646,17 @@ sub OverwriteStringList($$$$)
 # Returns: empty string
 sub ReconcileIPTCDigest($)
 {
-    my $exifTool = shift;
+    my $et = shift;
 
     # set new value for IPTCDigest if not done already
     unless ($Image::ExifTool::Photoshop::iptcDigestInfo and
-            $exifTool->{NEW_VALUE}{$Image::ExifTool::Photoshop::iptcDigestInfo})
+            $$et{NEW_VALUE}{$Image::ExifTool::Photoshop::iptcDigestInfo})
     {
         # write new IPTCDigest only if it doesn't exist or
         # is the same as the digest of the original IPTC
         my @a; # (capture warning messages)
-        @a = $exifTool->SetNewValue('Photoshop:IPTCDigest', 'old', Protected => 1, DelValue => 1);
-        @a = $exifTool->SetNewValue('Photoshop:IPTCDigest', 'new', Protected => 1);
+        @a = $et->SetNewValue('Photoshop:IPTCDigest', 'old', Protected => 1, DelValue => 1);
+        @a = $et->SetNewValue('Photoshop:IPTCDigest', 'new', Protected => 1);
     }
     return '';
 }

data/bin/{Image-ExifTool-9.37 → Image-ExifTool-9.41}/lib/Image/ExifTool/MXF.pm

@@ -37,7 +37,7 @@ use strict;
 use vars qw($VERSION);
 use Image::ExifTool qw(:DataAccess :Utils);
 
-$VERSION = '1.05';
+$VERSION = '1.06';
 
 sub ProcessPrimer($$$);
 sub ProcessLocalSet($$$);
@@ -2477,12 +2477,12 @@ sub ConvLatLon($)
 # Note: All types recognized here should be defined in the %knownType lookup
 sub ReadMXFValue($$$)
 {
-    my ($exifTool, $val, $type) = @_;
+    my ($et, $val, $type) = @_;
     my $len = length($val);
     local $_;
 
     if ($type eq 'UTF-16') {
-        $val = $exifTool->Decode($val, 'UCS2'); # (until we handle UTF-16 properly)
+        $val = $et->Decode($val, 'UCS2'); # (until we handle UTF-16 properly)
     } elsif ($type eq 'ProductVersion') {
         my @a = unpack('n*', $val);
         push @a, 0 while @a < 5;
@@ -2526,7 +2526,7 @@ sub ReadMXFValue($$$)
     } elsif ($type =~ /(Array|Batch)/ and $len > 16) {
         my ($count, $size) = unpack('NN', $val);
         # validate data length
-        $len == 8 + $count * $size or $exifTool->WarnOnce("Bad array or batch size");
+        $len == 8 + $count * $size or $et->WarnOnce("Bad array or batch size");
         my ($i, @a);
         for ($i=0; $i<$count; ++$i) {
             my $pos = 8 + $i * $size;
@@ -2536,7 +2536,7 @@ sub ReadMXFValue($$$)
         if ($type =~ /^StrongReference/) {
             $_ = join('-', unpack('H8H4H4H4H12', $_)) foreach @a;
         } elsif ($type eq 'BatchOfUL' or $type =~ /^WeakReference/) {
-            $_ = ReadMXFValue($exifTool, $_, 'UL') foreach @a;
+            $_ = ReadMXFValue($et, $_, 'UL') foreach @a;
         }
         $val = \@a;
     } elsif ($len == 32) {
@@ -2569,16 +2569,16 @@ sub ReadMXFValue($$$)
 # Returns: 1 on success
 sub ProcessPrimer($$$)
 {
-    my ($exifTool, $dirInfo, $tagTablePtr) = @_;
+    my ($et, $dirInfo, $tagTablePtr) = @_;
     my $dataPt = $$dirInfo{DataPt};
     my $end = $$dirInfo{DirLen};
     return 0 unless $end > 8;
     my $count = Get32u($dataPt, 0);
     my $size = Get32u($dataPt, 4);
     return 0 unless $size >= 18;
-    $exifTool->VerboseDir('MXF Primer', $count);
-    my $verbose = $exifTool->Options('Verbose');
-    my $primer = $$exifTool{MXFInfo}{Primer};
+    $et->VerboseDir('MXF Primer', $count);
+    my $verbose = $et->Options('Verbose');
+    my $primer = $$et{MXFInfo}{Primer};
     my $pos = 8;
     my $i;
     for ($i=0; $i<$count; ++$i) {
@@ -2592,7 +2592,7 @@ sub ProcessPrimer($$$)
         next unless $verbose;
         my $indx = $i . ')';
         $indx .= ' ' if length($indx) < 3;
-        $exifTool->VPrint(0, sprintf("  | $indx 0x%.4x => '$global'\n", $local));
+        $et->VPrint(0, sprintf("  | $indx 0x%.4x => '$global'\n", $local));
     }
     return 1;
 }
@@ -2603,16 +2603,16 @@ sub ProcessPrimer($$$)
 # Returns: 1 on success
 sub ProcessLocalSet($$$)
 {
-    my ($exifTool, $dirInfo, $tagTablePtr) = @_;
+    my ($et, $dirInfo, $tagTablePtr) = @_;
     local $_;
     my $dataPt = $$dirInfo{DataPt};
     my $dataPos = $$dirInfo{DataPos};
     my $end = $$dirInfo{DirLen};
-    my $mxfInfo = $$exifTool{MXFInfo};
+    my $mxfInfo = $$et{MXFInfo};
     my $primer = $$mxfInfo{Primer};
     my (@strongRef, @groups, $instance, $editRate, $trackID, $langCode, $textLang);
 
-    $exifTool->VerboseDir('MXF LocalSet', undef, $end);
+    $et->VerboseDir('MXF LocalSet', undef, $end);
 
     # loop through all tags in this local set
     my $pos = 0;
@@ -2627,7 +2627,7 @@ sub ProcessLocalSet($$$)
             $extra = sprintf(', Local 0x%.4x', $loc);
         } else {
             $tag = $loc;
-          # $exifTool->WarnOnce('Missing local key for at least one tag');
+          # $et->WarnOnce('Missing local key for at least one tag');
             $extra = ', NOT IN PRIMER!';
         }
         my $tagInfo = $$tagTablePtr{$tag};
@@ -2635,7 +2635,7 @@ sub ProcessLocalSet($$$)
         if ($tagInfo) {
             $type = $$tagInfo{Type};
             if ($type and $knownType{$type}) {
-                $val = ReadMXFValue($exifTool, substr($$dataPt, $pos, $len), $type);
+                $val = ReadMXFValue($et, substr($$dataPt, $pos, $len), $type);
                 push @strongRef, (ref $val ? @$val : $val) if $type =~ /^StrongReference/;
                 # remember instance UID of this local set
                 if ($$tagInfo{Name} eq 'InstanceUID') {
@@ -2649,12 +2649,12 @@ sub ProcessLocalSet($$$)
             }
         }
         # get tagInfo ref the standard way to handle Unknown tags
-        $tagInfo = $langInfo || $exifTool->GetTagInfo($tagTablePtr, $tag);
+        $tagInfo = $langInfo || $et->GetTagInfo($tagTablePtr, $tag);
         # set Binary flag to extract all unknown-format tags as Binary data
         if ($tagInfo and $$tagInfo{Unknown} and not defined $$tagInfo{Binary}) {
             $$tagInfo{Binary} = not ($$tagInfo{Format} or ($type and $knownType{$type}));
         }
-        my $key = $exifTool->HandleTag($tagTablePtr, $tag, $val,
+        my $key = $et->HandleTag($tagTablePtr, $tag, $val,
             Extra       => $extra,
             TagInfo     => $tagInfo,
             DataPt      => $dataPt,
@@ -2668,17 +2668,17 @@ sub ProcessLocalSet($$$)
         # save information to allow later fixup of durations and group1 names
         # (necessary because we don't have all the information we need
         #  to do this on the fly when the file is parsed linearly)
-        push @groups, $$exifTool{TAG_EXTRA}{$key};
+        push @groups, $$et{TAG_EXTRA}{$key};
         next unless $tagInfo;
         my $name = $$tagInfo{Name};
         if ($$tagInfo{IsDuration}) {
             $$mxfInfo{FixDuration}{$key} = 1;
         } elsif ($$tagInfo{LanguageCode}) {
-            $langCode = $$exifTool{VALUE}{$key};
+            $langCode = $$et{VALUE}{$key};
         } elsif ($name eq 'EditRate') {
-            $editRate = $$exifTool{VALUE}{$key};
+            $editRate = $$et{VALUE}{$key};
         } elsif ($name =~ /TrackID$/) {
-            $trackID = $$exifTool{VALUE}{$key};
+            $trackID = $$et{VALUE}{$key};
             unless ($$mxfInfo{Group1}{$trackID}) {
                 # save lookup to convert TrackID to our group 1 name
                 $$mxfInfo{Group1}{$trackID} = 'Track' . ++$$mxfInfo{NumTracks};
@@ -2700,7 +2700,7 @@ sub ProcessLocalSet($$$)
         }
         # save instance UID's in groups hash (used to remove duplicates later)
         $$_{UID} = $instance foreach @groups;
-        $$objInfo{Name} = $$exifTool{DIR_NAME};
+        $$objInfo{Name} = $$et{DIR_NAME};
         $$objInfo{TrackID} = $trackID if defined $trackID;
         $$objInfo{EditRate} = $editRate if $editRate;
         if ($langCode) {
@@ -2718,7 +2718,7 @@ sub ProcessLocalSet($$$)
             }
         }
         # save instance UID's of Preface's
-        push @{$$mxfInfo{Preface}}, $instance if $$exifTool{DIR_NAME} eq 'Preface';
+        push @{$$mxfInfo{Preface}}, $instance if $$et{DIR_NAME} eq 'Preface';
     }
     return 1;
 }
@@ -2783,10 +2783,10 @@ sub SetGroups($$;$$)
 # Inputs: 0) ExifTool object ref, 1) MXF information hash ref
 sub ConvertDurations($$)
 {
-    my ($exifTool, $mxfInfo) = @_;
-    my $valueHash = $$exifTool{VALUE};
-    my $infoHash = $$exifTool{TAG_INFO};
-    my $tagExtra = $$exifTool{TAG_EXTRA};
+    my ($et, $mxfInfo) = @_;
+    my $valueHash = $$et{VALUE};
+    my $infoHash = $$et{TAG_INFO};
+    my $tagExtra = $$et{TAG_EXTRA};
     my $editHash = $$mxfInfo{EditRate};
     my ($tag, $key, $i);
     foreach $tag (keys %{$$mxfInfo{FixDuration}}) {
@@ -2807,10 +2807,10 @@ sub ConvertDurations($$)
 # Returns: 1 on success, 0 if this wasn't a valid MXF file
 sub ProcessMXF($$)
 {
-    my ($exifTool, $dirInfo) = @_;
+    my ($et, $dirInfo) = @_;
     my $raf = $$dirInfo{RAF};
-    my $verbose = $exifTool->Options('Verbose');
-    my $unknown = $exifTool->Options('Unknown');
+    my $verbose = $et->Options('Verbose');
+    my $unknown = $et->Options('Unknown');
     my ($buff, $preface, $n, $headerEnd, $footerPos);
 
     # read enough to allow skipping over run-in if it exists
@@ -2818,9 +2818,9 @@ sub ProcessMXF($$)
     $buff =~ /\x06\x0e\x2b\x34\x02\x05\x01\x01\x0d\x01\x02/g or return 0;
     my $start = pos($buff) - 11;
 
-    $exifTool->SetFileType();
+    $et->SetFileType();
     SetByteOrder('MM');
-    $raf->Seek($start, 0) or $exifTool->Warn('Seek error'), return 1;
+    $raf->Seek($start, 0) or $et->Warn('Seek error'), return 1;
     my $tagTablePtr = GetTagTable('Image::ExifTool::MXF::Main');
 
     # determine header length and type
@@ -2833,10 +2833,10 @@ sub ProcessMXF($$)
         FixDuration => { }, # names of all Duration tags that need fixing
         Preface => [ ],     # instance UID's for all Preface objects
     );
-    $$exifTool{MXFInfo} = \%mxfInfo;
+    $$et{MXFInfo} = \%mxfInfo;
 
     # set group 1 name for all tags (so we can overwrite with track number later)
-    $$exifTool{SET_GROUP1} = 'MXF';
+    $$et{SET_GROUP1} = 'MXF';
 
     for (;;) {
         my $pos = $raf->Tell();
@@ -2847,7 +2847,7 @@ sub ProcessMXF($$)
             undef $headerEnd;   # (only test this once)
             # skip directly to footer if possible
             if ($footerPos and $footerPos > $pos and (not $verbose or not $unknown)) {
-                $exifTool->VPrint(0, "[Skipping to footer. Use Unknown option to parse body partitions]\n");
+                $et->VPrint(0, "[Skipping to footer. Use Unknown option to parse body partitions]\n");
                 $raf->Seek($footerPos, 0) or last;
                 $pos = $footerPos;
             }
@@ -2893,7 +2893,7 @@ sub ProcessMXF($$)
             $raf->Read($buff, $len) == $len or last; # get KLV Value
             $dataPt = \$buff;
             my $type = $$tagInfo{Type};
-            $val = ReadMXFValue($exifTool, $buff, $type) if $type and $knownType{$type};
+            $val = ReadMXFValue($et, $buff, $type) if $type and $knownType{$type};
         } elsif (($tagInfo and (not $$tagInfo{Unknown} or $unknown)) or $verbose) {
             if ($tagInfo) {
                 # set Binary flag to extract all unknown-format tags as Binary data
@@ -2920,7 +2920,7 @@ sub ProcessMXF($$)
             $raf->Seek($len, 1) or last;    # skip this value
             next;
         }
-        $exifTool->HandleTag($tagTablePtr, $ul, $val,
+        $et->HandleTag($tagTablePtr, $ul, $val,
             TagInfo     => $tagInfo,
             DataPt      => $dataPt,
             DataPos     => $pos + 17 + $n,
@@ -2930,16 +2930,16 @@ sub ProcessMXF($$)
     }
     # walk entire MXF object tree to fix family 1 group names
     my ($pathInfo, $tag, %did, %bestDur);
-    $pathInfo = { Path => [ 'MXF' ] } if $exifTool->Options('SavePath');
+    $pathInfo = { Path => [ 'MXF' ] } if $et->Options('SavePath');
     foreach $preface (@{$mxfInfo{Preface}}) {
         SetGroups(\%mxfInfo, $preface, $pathInfo);
     }
     # convert Duration values to seconds based on the appropriate EditRate
-    ConvertDurations($exifTool, \%mxfInfo);
+    ConvertDurations($et, \%mxfInfo);
 
     # remove tags to keep only the one from the most recent instance of the object
-    my $tagExtra = $$exifTool{TAG_EXTRA};
-    my $fileOrder = $$exifTool{FILE_ORDER};
+    my $tagExtra = $$et{TAG_EXTRA};
+    my $fileOrder = $$et{FILE_ORDER};
     # also determine our best Duration value
     if ($mxfInfo{BestDuration}) {
         my $instance = $mxfInfo{BestDuration}{Source} || $mxfInfo{BestDuration}{Other};
@@ -2952,20 +2952,20 @@ sub ProcessMXF($$)
         $tag =~ /^(\S+)/;               # get tag name without index number
         my $utag = "$1 $instance";      # instance-specific tag name
         if ($did{$utag}) {
-            Image::ExifTool::DeleteTag($exifTool, $tag); # delete the duplicate
+            Image::ExifTool::DeleteTag($et, $tag); # delete the duplicate
         } else {
             $did{$utag} = 1;
             if ($bestDur{$utag}) {
                 # save best duration value
-                my $val = $$exifTool{VALUE}{$tag};
-                $exifTool->HandleTag($tagTablePtr, '060e2b34.0101.0102.07020201.01030000', $val);
+                my $val = $$et{VALUE}{$tag};
+                $et->HandleTag($tagTablePtr, '060e2b34.0101.0102.07020201.01030000', $val);
             }
         }
     }
 
     # clean up and return
-    delete $$exifTool{SET_GROUP1};
-    delete $$exifTool{MXFInfo};
+    delete $$et{SET_GROUP1};
+    delete $$et{MXFInfo};
     return 1;
 }
 

data/bin/{Image-ExifTool-9.37 → Image-ExifTool-9.41}/lib/Image/ExifTool/MakerNotes.pm

@@ -20,7 +20,7 @@ sub ProcessGE2($$$);
 sub WriteUnknownOrPreview($$$);
 sub FixLeicaBase($$;$);
 
-$VERSION = '1.85';
+$VERSION = '1.87';
 
 my $debug;          # set to 1 to enable debugging code
 
@@ -693,7 +693,9 @@ my $debug;          # set to 1 to enable debugging code
     {
         Name => 'MakerNoteRicoh',
         # (my test R50 image starts with "      \x02\x01" - PH)
-        Condition => '$$self{Make}=~/^(PENTAX )?RICOH/ and $$valPt=~/^(Ricoh|      )/i',
+        # (the HZ15 starts with "MM\0\x2a" but an extra 2 bytes of padding after
+        #  the IFD entry count prevents these from being processed as a standard IFD)
+        Condition => '$$self{Make}=~/^(PENTAX )?RICOH/ and $$valPt=~/^(Ricoh|      |MM\0\x2a|II\x2a\0)/i',
         SubDirectory => {
             TagTable => 'Image::ExifTool::Ricoh::Main',
             Start => '$valuePtr + 8',
@@ -901,10 +903,10 @@ foreach $tagInfo (@Image::ExifTool::MakerNotes::Main) {
 # Notes: Directory size should be validated before calling this routine
 sub GetMakerNoteOffset($)
 {
-    my $exifTool = shift;
+    my $et = shift;
     # figure out where we expect the value data based on camera type
-    my $make = $exifTool->{Make};
-    my $model = $exifTool->{Model};
+    my $make = $$et{Make};
+    my $model = $$et{Model};
     my ($relative, @offsets);
 
     # normally value data starts 4 bytes after end of directory, so this is the default.
@@ -921,7 +923,7 @@ sub GetMakerNoteOffset($)
         # Casio AVI and MOV images use no padding, and their JPEG's use 4,
         # except some models like the EX-S770,Z65,Z70,Z75 and Z700 which use 16,
         # and the EX-Z35 which uses 2 (grrrr...)
-        push @offsets, $$exifTool{FILE_TYPE} =~ /^(RIFF|MOV)$/ ? 0 : (4, 16, 2);
+        push @offsets, $$et{FILE_TYPE} =~ /^(RIFF|MOV)$/ ? 0 : (4, 16, 2);
     } elsif ($make =~ /^(General Imaging Co.|GEDSC IMAGING CORP.)/i) {
         push @offsets, 0;
     } elsif ($make =~ /^KYOCERA/) {
@@ -929,7 +931,7 @@ sub GetMakerNoteOffset($)
     } elsif ($make =~ /^Leica Camera AG/) {
         if ($model eq 'S2') {
             # lots of empty space before first value in S2 images
-            push @offsets, 4, ($$exifTool{FILE_TYPE} eq 'JPEG' ? 286 : 274);
+            push @offsets, 4, ($$et{FILE_TYPE} eq 'JPEG' ? 286 : 274);
         } elsif ($model eq 'LEICA M (Typ 240)') {
             push @offsets, 4, 118;
         } elsif ($model =~ /^(R8|R9|M8)\b/) {
@@ -949,7 +951,7 @@ sub GetMakerNoteOffset($)
     } elsif ($make =~ /^SONY/) {
         # earlier DSLR and "PREMI" models use an offset of 4
         if ($model =~ /^(DSLR-.*|SLT-A(33|35|55V)|NEX-(3|5|C3|VG10E))$/ or
-            $$exifTool{OlympusCAMER})
+            $$et{OlympusCAMER})
         {
             push @offsets, 4;
         } else {
@@ -1031,7 +1033,7 @@ sub GetValueBlocks($$;$)
 sub FixBase($$)
 {
     local $_;
-    my ($exifTool, $dirInfo) = @_;
+    my ($et, $dirInfo) = @_;
     # don't fix base if fixing offsets individually or if we don't want to fix them
     return 0 if $$dirInfo{FixOffsets} or $$dirInfo{NoFixBase};
 
@@ -1040,7 +1042,7 @@ sub FixBase($$)
     my $dirStart = $$dirInfo{DirStart} || 0;
     my $entryBased = $$dirInfo{EntryBased};
     my $dirName = $$dirInfo{DirName};
-    my $fixBase = $exifTool->Options('FixBase');
+    my $fixBase = $et->Options('FixBase');
     my $setBase = (defined $fixBase and $fixBase ne '') ? 1 : 0;
     my ($fix, $fixedBy, %tagPtr);
 
@@ -1052,7 +1054,7 @@ sub FixBase($$)
 #
 # handle special case of Canon maker notes with TIFF footer containing original offset
 #
-    if ($$exifTool{Make} =~ /^Canon/ and $$dirInfo{DirLen} > 8) {
+    if ($$et{Make} =~ /^Canon/ and $$dirInfo{DirLen} > 8) {
         my $footerPos = $dirStart + $$dirInfo{DirLen} - 8;
         my $footer = substr($$dataPt, $footerPos, 8);
         if ($footer =~ /^(II\x2a\0|MM\0\x2a)/ and  # check for TIFF footer
@@ -1074,11 +1076,11 @@ sub FixBase($$)
                 # ignore footer offset only if end difference is exactly correct
                 # (allow for possible padding byte, although I have never seen this)
                 if (not $endDiff or $endDiff == 1) {
-                    $exifTool->Warn('Canon maker note footer may be invalid (ignored)',1);
+                    $et->Warn('Canon maker note footer may be invalid (ignored)',1);
                     return 0;
                 }
             }
-            $exifTool->Warn("Adjusted $dirName base by $fix",1);
+            $et->Warn("Adjusted $dirName base by $fix",1);
             $$dirInfo{FixedBy} = $fix;
             $$dirInfo{Base} += $fix;
             $$dirInfo{DataPos} -= $fix;
@@ -1093,9 +1095,9 @@ sub FixBase($$)
     my $minPt = $$dirInfo{MinOffset} = $valPtrs[0]; # if life were simple, this would be it
     my $ifdLen = 2 + 12 * Get16u($$dirInfo{DataPt}, $dirStart);
     my $ifdEnd = $dirStart + $ifdLen;
-    my ($relative, @offsets) = GetMakerNoteOffset($exifTool);
+    my ($relative, @offsets) = GetMakerNoteOffset($et);
     my $makeDiff = $offsets[0];
-    my $verbose = $exifTool->Options('Verbose');
+    my $verbose = $et->Options('Verbose');
     my ($diff, $shift);
 
     # calculate expected minimum value offset
@@ -1136,14 +1138,14 @@ sub FixBase($$)
         # looks like these offsets are entry-based, so use the offsets
         # which have been correcting for individual entry position
         $entryBased = 1;
-        $verbose and $exifTool->Warn("$dirName offsets are entry-based",1);
+        $verbose and $et->Warn("$dirName offsets are entry-based",1);
     } else {
         # calculate offset difference from end of IFD to first value
         $diff = ($minPt - $dataPos) - $ifdEnd;
         $shift = 0;
-        $countOverlap and $exifTool->Warn("Overlapping $dirName values",1);
+        $countOverlap and $et->Warn("Overlapping $dirName values",1);
         if ($entryBased) {
-            $exifTool->Warn("$dirName offsets do NOT look entry-based",1);
+            $et->Warn("$dirName offsets do NOT look entry-based",1);
             undef $entryBased;
             undef $relative;
         }
@@ -1158,8 +1160,8 @@ sub FixBase($$)
             return 0 if $diff >=0 and $diff <= 24;
         }
         # ******** (used for testing to extract differences) ********
-        # $exifTool->FoundTag('Diff', $diff);
-        # $exifTool->FoundTag('MakeDiff',$makeDiff);
+        # $et->FoundTag('Diff', $diff);
+        # $et->FoundTag('MakeDiff',$makeDiff);
     }
 #
 # handle entry-based offsets
@@ -1218,13 +1220,13 @@ sub FixBase($$)
     } else {
         # print warning unless difference looks reasonable
         if ($diff < 0 or $diff > 16 or ($diff & 0x01)) {
-            $exifTool->Warn("Possibly incorrect maker notes offsets (fix by $fix?)",1);
+            $et->Warn("Possibly incorrect maker notes offsets (fix by $fix?)",1);
         }
         # don't do the fix (but we already adjusted base if entry-based)
         return $shift;
     }
     if (defined $fixedBy) {
-        $exifTool->Warn("Adjusted $dirName base by $fixedBy",1);
+        $et->Warn("Adjusted $dirName base by $fixedBy",1);
         $$dirInfo{FixedBy} = $fixedBy;
     }
     $$dirInfo{Base} += $fix;
@@ -1242,7 +1244,7 @@ sub FixBase($$)
 # Note: Changes byte ordering!
 sub LocateIFD($$)
 {
-    my ($exifTool, $dirInfo) = @_;
+    my ($et, $dirInfo) = @_;
     my $dataPt = $$dirInfo{DataPt};
     my $dirStart = $$dirInfo{DirStart} || 0;
     # (ignore MakerNotes DirLen since sometimes this is incorrect)
@@ -1291,7 +1293,7 @@ sub LocateIFD($$)
                     if ($$subdir{ProcessProc} and $$subdir{ProcessProc} eq \&FixLeicaBase) {
                         my $oldStart = $$dirInfo{DirStart};
                         $$dirInfo{DirStart} = $newStart;
-                        FixLeicaBase($exifTool, $dirInfo);
+                        FixLeicaBase($et, $dirInfo);
                         $$dirInfo{DirStart} = $oldStart;
                     }
                 }
@@ -1371,19 +1373,19 @@ IFD_TRY: for ($offset=$firstTry; $offset<=$lastTry; $offset+=2) {
                 my $count = Get32u($dataPt, $entry+4);
                 unless ($format) {
                     # patch for buggy Samsung NX200 JPEG MakerNotes entry count
-                    if ($num == 23 and $index == 21 and $$exifTool{Make} eq 'SAMSUNG') {
+                    if ($num == 23 and $index == 21 and $$et{Make} eq 'SAMSUNG') {
                         Set16u(21, $dataPt, $pos);  # really 21 IFD entries!
-                        $exifTool->Warn('Fixed incorrect Makernote entry count', 1);
+                        $et->Warn('Fixed incorrect Makernote entry count', 1);
                         last;
                     }
                     # allow everything to be zero if not first entry
                     # because some manufacturers pad with null entries
                     next unless $count or $index == 0;
                     # patch for Canon EOS 40D firmware 1.0.4 bug: allow zero format for last entry
-                    next if $index==$num-1 and $$exifTool{Model}=~/EOS 40D/;
+                    next if $index==$num-1 and $$et{Model}=~/EOS 40D/;
                 }
                 # patch for Sony cameras like the DSC-P10 that have invalid MakerNote entries
-                next if $num == 12 and $$exifTool{Make} eq 'SONY' and $index >= 8;
+                next if $num == 12 and $$et{Make} eq 'SONY' and $index >= 8;
                 # (would like to verify tag ID, but some manufactures don't
                 #  sort entries in order of tag ID so we don't have much of
                 #  a handle to verify this field)
@@ -1415,7 +1417,7 @@ IFD_TRY: for ($offset=$firstTry; $offset<=$lastTry; $offset+=2) {
 # Returns: 1 on success, and updates $dirInfo if necessary for new directory
 sub FixLeicaBase($$;$)
 {
-    my ($exifTool, $dirInfo, $tagTablePtr) = @_;
+    my ($et, $dirInfo, $tagTablePtr) = @_;
     my $dataPt = $$dirInfo{DataPt};
     my $dirStart = $$dirInfo{DirStart} || 0;
     # get hash of value block positions
@@ -1432,7 +1434,7 @@ sub FixLeicaBase($$;$)
     }
     my $success = 1;
     if ($tagTablePtr) {
-        $success = Image::ExifTool::Exif::ProcessExif($exifTool, $dirInfo, $tagTablePtr);
+        $success = Image::ExifTool::Exif::ProcessExif($et, $dirInfo, $tagTablePtr);
     }
     return $success;
 }
@@ -1443,10 +1445,10 @@ sub FixLeicaBase($$;$)
 # Returns: 1 on success
 sub ProcessCanon($$$)
 {
-    my ($exifTool, $dirInfo, $tagTablePtr) = @_;
+    my ($et, $dirInfo, $tagTablePtr) = @_;
     # identify Canon MakerNote footer in HtmlDump
     # (this code moved from FixBase so it also works for Adobe MakN in DNG images)
-    if ($$exifTool{HTML_DUMP} and $$dirInfo{DirLen} > 8) {
+    if ($$et{HTML_DUMP} and $$dirInfo{DirLen} > 8) {
         my $dataPos = $$dirInfo{DataPos};
         my $dirStart = $$dirInfo{DirStart} || 0;
         my $footerPos = $dirStart + $$dirInfo{DirLen} - 8;
@@ -1459,11 +1461,11 @@ sub ProcessCanon($$$)
                 $str .= sprintf("\nCurrent maker note offset: 0x%.4x", $newOffset);
             }
             my $filePos = ($$dirInfo{Base} || 0) + $dataPos + $footerPos;
-            $exifTool->HDump($filePos, 8, '[Canon MakerNotes footer]', $str);
+            $et->HDump($filePos, 8, '[Canon MakerNotes footer]', $str);
         }
     }
     # process as normal
-    return Image::ExifTool::Exif::ProcessExif($exifTool, $dirInfo, $tagTablePtr);
+    return Image::ExifTool::Exif::ProcessExif($et, $dirInfo, $tagTablePtr);
 }
 
 #------------------------------------------------------------------------------
@@ -1472,14 +1474,14 @@ sub ProcessCanon($$$)
 # Returns: 1 on success
 sub ProcessGE2($$$)
 {
-    my ($exifTool, $dirInfo, $tagTablePtr) = @_;
+    my ($et, $dirInfo, $tagTablePtr) = @_;
     my $dataPt = $$dirInfo{DataPt} or return 0;
     my $dirStart = $$dirInfo{DirStart} || 0;
 
     # these maker notes are missing the IFD entry count, but they
     # always have 25 entries, so write the entry count manually
     Set16u(25, $dataPt, $dirStart);
-    return Image::ExifTool::Exif::ProcessExif($exifTool, $dirInfo, $tagTablePtr);
+    return Image::ExifTool::Exif::ProcessExif($et, $dirInfo, $tagTablePtr);
 }
 
 #------------------------------------------------------------------------------
@@ -1488,21 +1490,21 @@ sub ProcessGE2($$$)
 # Returns: 1 on success, and updates $dirInfo if necessary for new directory
 sub ProcessUnknownOrPreview($$$)
 {
-    my ($exifTool, $dirInfo, $tagTablePtr) = @_;
+    my ($et, $dirInfo, $tagTablePtr) = @_;
     my $dataPt = $$dirInfo{DataPt};
     my $dirStart = $$dirInfo{DirStart};
     my $dirLen = $$dirInfo{DirLen};
     # check to see if this is a preview image
     if ($dirLen > 6 and substr($$dataPt, $dirStart, 3) eq "\xff\xd8\xff") {
-        $exifTool->VerboseDir('PreviewImage');
-        if ($$exifTool{HTML_DUMP}) {
+        $et->VerboseDir('PreviewImage');
+        if ($$et{HTML_DUMP}) {
             my $pos = $$dirInfo{DataPos} + $$dirInfo{Base} + $dirStart;
-            $exifTool->HDump($pos, $dirLen, '(MakerNotes:PreviewImage data)', "Size: $dirLen bytes")
+            $et->HDump($pos, $dirLen, '(MakerNotes:PreviewImage data)', "Size: $dirLen bytes")
         }
-        $exifTool->FoundTag('PreviewImage', substr($$dataPt, $dirStart, $dirLen));
+        $et->FoundTag('PreviewImage', substr($$dataPt, $dirStart, $dirLen));
         return 1;
     }
-    return ProcessUnknown($exifTool, $dirInfo, $tagTablePtr);
+    return ProcessUnknown($et, $dirInfo, $tagTablePtr);
 }
 
 #------------------------------------------------------------------------------
@@ -1511,27 +1513,27 @@ sub ProcessUnknownOrPreview($$$)
 # Returns: directory data, '' to delete, or undef on error
 sub WriteUnknownOrPreview($$$)
 {
-    my ($exifTool, $dirInfo, $tagTablePtr) = @_;
+    my ($et, $dirInfo, $tagTablePtr) = @_;
     my $dataPt = $$dirInfo{DataPt};
     my $dirStart = $$dirInfo{DirStart};
     my $dirLen = $$dirInfo{DirLen};
     my $newVal;
     # check to see if this is a preview image
     if ($dirLen > 6 and substr($$dataPt, $dirStart, 3) eq "\xff\xd8\xff") {
-        if ($$exifTool{NEW_VALUE}{$Image::ExifTool::Extra{PreviewImage}}) {
+        if ($$et{NEW_VALUE}{$Image::ExifTool::Extra{PreviewImage}}) {
             # write or delete new preview (if deleted, it can't currently be added back again)
-            $newVal = $exifTool->GetNewValues('PreviewImage') || '';
-            if ($exifTool->Options('Verbose') > 1) {
-                $exifTool->VerboseValue("- MakerNotes:PreviewImage", substr($$dataPt, $dirStart, $dirLen));
-                $exifTool->VerboseValue("+ MakerNotes:PreviewImage", $newVal) if $newVal;
+            $newVal = $et->GetNewValues('PreviewImage') || '';
+            if ($et->Options('Verbose') > 1) {
+                $et->VerboseValue("- MakerNotes:PreviewImage", substr($$dataPt, $dirStart, $dirLen));
+                $et->VerboseValue("+ MakerNotes:PreviewImage", $newVal) if $newVal;
             }
-            ++$$exifTool{CHANGED};
+            ++$$et{CHANGED};
         } else {
             $newVal = substr($$dataPt, $dirStart, $dirLen);
         }
     } else {
         # rewrite MakerNote IFD
-        $newVal = Image::ExifTool::Exif::WriteExif($exifTool, $dirInfo, $tagTablePtr);
+        $newVal = Image::ExifTool::Exif::WriteExif($et, $dirInfo, $tagTablePtr);
     }
     return $newVal;
 }
@@ -1542,23 +1544,23 @@ sub WriteUnknownOrPreview($$$)
 # Returns: 1 on success, and updates $dirInfo if necessary for new directory
 sub ProcessUnknown($$$)
 {
-    my ($exifTool, $dirInfo, $tagTablePtr) = @_;
+    my ($et, $dirInfo, $tagTablePtr) = @_;
     my $success = 0;
 
-    my $loc = LocateIFD($exifTool, $dirInfo);
+    my $loc = LocateIFD($et, $dirInfo);
     if (defined $loc) {
-        $exifTool->{UnknownByteOrder} = GetByteOrder();
-        if ($exifTool->Options('Verbose') > 1) {
-            my $out = $exifTool->Options('TextOut');
-            my $indent = $exifTool->{INDENT};
+        $$et{UnknownByteOrder} = GetByteOrder();
+        if ($et->Options('Verbose') > 1) {
+            my $out = $et->Options('TextOut');
+            my $indent = $$et{INDENT};
             $indent =~ s/\| $/  /;
             printf $out "${indent}Found IFD at offset 0x%.4x in maker notes:\n",
                     $$dirInfo{DirStart} + $$dirInfo{DataPos} + $$dirInfo{Base};
         }
-        $success = Image::ExifTool::Exif::ProcessExif($exifTool, $dirInfo, $tagTablePtr);
+        $success = Image::ExifTool::Exif::ProcessExif($et, $dirInfo, $tagTablePtr);
     } else {
-        $exifTool->{UnknownByteOrder} = ''; # indicates we tried but didn't set byte order
-        $exifTool->Warn("Unrecognized $$dirInfo{DirName}", 1);
+        $$et{UnknownByteOrder} = ''; # indicates we tried but didn't set byte order
+        $et->Warn("Unrecognized $$dirInfo{DirName}", 1);
     }
     return $success;
 }