exiftool_vendored 9.37.0 → 9.41.0

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

@@ -51,7 +51,7 @@ use vars qw($VERSION $AUTOLOAD @formatSize @formatName %formatNumber %intFormat
 use Image::ExifTool qw(:DataAccess :Utils);
 use Image::ExifTool::MakerNotes;
 
-$VERSION = '3.55';
+$VERSION = '3.57';
 
 sub ProcessExif($$$);
 sub WriteExif($$$);
@@ -3079,11 +3079,11 @@ sub AUTOLOAD
 # - sets TIFF_TYPE and FileType if identified
 sub IdentifyRawFile($$)
 {
-    my ($exifTool, $comp) = @_;
-    if ($$exifTool{FILE_TYPE} eq 'TIFF' and not $$exifTool{IdentifiedRawFile}) {
+    my ($et, $comp) = @_;
+    if ($$et{FILE_TYPE} eq 'TIFF' and not $$et{IdentifiedRawFile}) {
         if ($compression{$comp} and $compression{$comp} =~ /^\w+ ([A-Z]{3}) Compressed$/) {
-            $exifTool->OverrideFileType($$exifTool{TIFF_TYPE} = $1);
-            $$exifTool{IdentifiedRawFile} = 1;
+            $et->OverrideFileType($$et{TIFF_TYPE} = $1);
+            $$et{IdentifiedRawFile} = 1;
         }
     }
 }
@@ -3120,7 +3120,7 @@ sub CalculateLV($$$)
 # Returns: 35mm conversion factor (or undefined if it can't be calculated)
 sub CalcScaleFactor35efl
 {
-    my $exifTool = shift;
+    my $et = shift;
     my $res = $_[7];    # save resolution units (in case they have been converted to string)
     my $sensXY = $_[4];
     Image::ExifTool::ToFloat(@_);
@@ -3133,11 +3133,11 @@ sub CalcScaleFactor35efl
     my $diag = shift;
     my $sens = shift;
     # calculate Canon sensor size using a dedicated algorithm
-    if ($$exifTool{Make} eq 'Canon') {
+    if ($$et{Make} eq 'Canon') {
         require Image::ExifTool::Canon;
         my $canonDiag = Image::ExifTool::Canon::CalcSensorDiag(
-            $exifTool->{RATIONAL}{FocalPlaneXResolution},
-            $exifTool->{RATIONAL}{FocalPlaneYResolution},
+            $$et{RATIONAL}{FocalPlaneXResolution},
+            $$et{RATIONAL}{FocalPlaneYResolution},
         );
         $diag = $canonDiag if $canonDiag;
     }
@@ -3225,7 +3225,7 @@ sub ConvertFraction($)
 # Returns: text encoded according to Charset option (with trailing spaces removed)
 sub ConvertExifText($$;$)
 {
-    my ($exifTool, $val, $asciiFlex) = @_;
+    my ($et, $val, $asciiFlex) = @_;
     return $val if length($val) < 8;
     my $id = substr($val, 0, 8);
     my $str = substr($val, 8);
@@ -3237,8 +3237,8 @@ sub ConvertExifText($$;$)
         $str =~ s/\0.*//s;
         # allow ASCII text to contain any other specified encoding
         if ($asciiFlex) {
-            my $enc = $exifTool->Options('CharsetEXIF');
-            $str = $exifTool->Decode($str, $enc) if $enc;
+            my $enc = $et->Options('CharsetEXIF');
+            $str = $et->Decode($str, $enc) if $enc;
         }
     # by the EXIF spec, the following string should be "UNICODE\0", but
     # apparently Kodak sometimes uses "Unicode\0" in the APP3 "Meta" information.
@@ -3247,11 +3247,11 @@ sub ConvertExifText($$;$)
     } elsif ($id =~ /^UNICODE[\0 ]$/) {
         # MicrosoftPhoto writes as little-endian even in big-endian EXIF,
         # so we must guess at the true byte ordering
-        $str = $exifTool->Decode($str, 'UTF16', 'Unknown');
+        $str = $et->Decode($str, 'UTF16', 'Unknown');
     } elsif ($id =~ /^JIS[\0 ]{5}$/) {
-        $str = $exifTool->Decode($str, 'JIS', 'Unknown');
+        $str = $et->Decode($str, 'JIS', 'Unknown');
     } else {
-        $exifTool->Warn("Invalid EXIF text encoding");
+        $et->Warn("Invalid EXIF text encoding");
         $str = $id . $str;
     }
     $str =~ s/ +$//;    # trim trailing blanks
@@ -3484,13 +3484,13 @@ sub GetLensInfo($;$)
 #         10) LensModel, 11) LensFocalRange, 12) LensSpec
 sub PrintLensID($$@)
 {
-    my ($exifTool, $lensTypePrt, $printConv, $lensSpecPrt, $lensType, $focalLength,
+    my ($et, $lensTypePrt, $printConv, $lensSpecPrt, $lensType, $focalLength,
         $maxAperture, $maxApertureValue, $shortFocal, $longFocal, $lensModel,
         $lensFocalRange, $lensSpec) = @_;
     # the rest of the logic relies on the LensType lookup:
     return undef unless defined $lensType;
     # get print conversion hash if necessary
-    $printConv or $printConv = $exifTool->{TAG_INFO}{LensType}{PrintConv};
+    $printConv or $printConv = $$et{TAG_INFO}{LensType}{PrintConv};
     # just copy LensType PrintConv value if it was a lens name
     # (Olympus or Panasonic -- just exclude things like Nikon and Leaf LensType)
     unless (ref $printConv eq 'HASH') {
@@ -3509,7 +3509,17 @@ sub PrintLensID($$@)
     if ($lensFocalRange and $lensFocalRange =~ /^(\d+)(?: (?:to )?(\d+))?$/) {
         ($shortFocal, $longFocal) = ($1, $2 || $1);
     }
-    if ($shortFocal and $longFocal) {
+    if ($$et{Make} eq 'SONY') {
+        if (($lensType & 0xff00) == 0xef00) {
+            # patch for Metabones Canon adapter on a Sony camera (ref Jos Roost)
+            # (note: the adapter kills the high byte for 2-byte LensType values,
+            # so the reported lens will be incorrect for these, ref 12)
+            require Image::ExifTool::Canon;
+            $printConv = \%Image::ExifTool::Canon::canonLensTypes;
+            $lensType &= 0xff;
+            $lensTypePrt = $$printConv{$lensType} if $$printConv{$lensType};
+        }
+    } elsif ($shortFocal and $longFocal) {
         # Canon (and some other makes) include makernote information
         # which allows better lens identification
         require Image::ExifTool::Canon;
@@ -3652,34 +3662,34 @@ sub ExifTime($)
 #          Returns undef if there was an error loading the image
 sub ExtractImage($$$$)
 {
-    my ($exifTool, $offset, $len, $tag) = @_;
-    my $dataPt = \$exifTool->{EXIF_DATA};
-    my $dataPos = $exifTool->{EXIF_POS};
+    my ($et, $offset, $len, $tag) = @_;
+    my $dataPt = \$$et{EXIF_DATA};
+    my $dataPos = $$et{EXIF_POS};
     my $image;
 
     # no image if length is zero, and don't try to extract binary from XMP file
-    return undef if not $len or $$exifTool{FILE_TYPE} eq 'XMP';
+    return undef if not $len or $$et{FILE_TYPE} eq 'XMP';
 
     # take data from EXIF block if possible
     if (defined $dataPos and $offset>=$dataPos and $offset+$len<=$dataPos+length($$dataPt)) {
         $image = substr($$dataPt, $offset-$dataPos, $len);
     } else {
-        $image = $exifTool->ExtractBinary($offset, $len, $tag);
+        $image = $et->ExtractBinary($offset, $len, $tag);
         return undef unless defined $image;
         # patch for incorrect ThumbnailOffset in some Sony DSLR-A100 ARW images
-        if ($tag and $tag eq 'ThumbnailImage' and $$exifTool{TIFF_TYPE} eq 'ARW' and
-            $$exifTool{Model} eq 'DSLR-A100' and $offset < 0x10000 and
+        if ($tag and $tag eq 'ThumbnailImage' and $$et{TIFF_TYPE} eq 'ARW' and
+            $$et{Model} eq 'DSLR-A100' and $offset < 0x10000 and
             $image !~ /^(Binary data|\xff\xd8\xff)/)
         {
-            my $try = $exifTool->ExtractBinary($offset + 0x10000, $len, $tag);
+            my $try = $et->ExtractBinary($offset + 0x10000, $len, $tag);
             if (defined $try and $try =~ /^\xff\xd8\xff/) {
                 $image = $try;
-                $exifTool->{VALUE}->{ThumbnailOffset} += 0x10000;
-                $exifTool->Warn('Adjusted incorrect A100 ThumbnailOffset', 1);
+                $$et{VALUE}{ThumbnailOffset} += 0x10000;
+                $et->Warn('Adjusted incorrect A100 ThumbnailOffset', 1);
             }
         }
     }
-    return $exifTool->ValidateImage(\$image, $tag);
+    return $et->ValidateImage(\$image, $tag);
 }
 
 #------------------------------------------------------------------------------
@@ -3690,7 +3700,7 @@ sub ExtractImage($$$$)
 # Returns: 1 on success, otherwise returns 0 and sets a Warning
 sub ProcessExif($$$)
 {
-    my ($exifTool, $dirInfo, $tagTablePtr) = @_;
+    my ($et, $dirInfo, $tagTablePtr) = @_;
     my $dataPt = $$dirInfo{DataPt};
     my $dataPos = $$dirInfo{DataPos} || 0;
     my $dataLen = $$dirInfo{DataLen};
@@ -3700,23 +3710,23 @@ sub ProcessExif($$$)
     my $base = $$dirInfo{Base} || 0;
     my $firstBase = $base;
     my $raf = $$dirInfo{RAF};
-    my $verbose = $exifTool->Options('Verbose');
-    my $htmlDump = $exifTool->{HTML_DUMP};
+    my $verbose = $et->Options('Verbose');
+    my $htmlDump = $$et{HTML_DUMP};
     my $success = 1;
     my ($tagKey, $dirSize, $makerAddr, $strEnc);
-    my $inMakerNotes = $tagTablePtr->{GROUPS}{0} eq 'MakerNotes';
+    my $inMakerNotes = $$tagTablePtr{GROUPS}{0} eq 'MakerNotes';
 
     # set encoding to assume for strings
-    $strEnc = $exifTool->Options('CharsetEXIF') if $$tagTablePtr{GROUPS}{0} eq 'EXIF';
+    $strEnc = $et->Options('CharsetEXIF') if $$tagTablePtr{GROUPS}{0} eq 'EXIF';
 
     # ignore non-standard EXIF while in strict MWG compatibility mode
     if ($Image::ExifTool::MWG::strict and $dirName eq 'IFD0' and
         $tagTablePtr eq \%Image::ExifTool::Exif::Main and
-        $$exifTool{FILE_TYPE} =~ /^(JPEG|TIFF|PSD)$/)
+        $$et{FILE_TYPE} =~ /^(JPEG|TIFF|PSD)$/)
     {
-        my $path = $exifTool->MetadataPath();
+        my $path = $et->MetadataPath();
         unless ($path =~ /^(JPEG-APP1-IFD0|TIFF-IFD0|PSD-EXIFInfo-IFD0)$/) {
-            $exifTool->Warn("Ignored non-standard EXIF at $path");
+            $et->Warn("Ignored non-standard EXIF at $path");
             return 1;
         }
     }
@@ -3736,7 +3746,7 @@ sub ProcessExif($$$)
         if ($dirSize > $dirLen) {
             if ($verbose > 0 and not $$dirInfo{SubIFD}) {
                 my $short = $dirSize - $dirLen;
-                $exifTool->Warn("Short directory size (missing $short bytes)");
+                $et->Warn("Short directory size (missing $short bytes)");
             }
             undef $dirSize if $dirEnd > $dataLen; # read from file if necessary
         }
@@ -3767,18 +3777,18 @@ sub ProcessExif($$$)
             }
         }
         unless ($success) {
-            $exifTool->Warn("Bad $name directory");
+            $et->Warn("Bad $name directory");
             return 0;
         }
         $numEntries = Get16u($dataPt, $dirStart);
         $dirSize = 2 + 12 * $numEntries;
         $dirEnd = $dirStart + $dirSize;
     }
-    $verbose > 0 and $exifTool->VerboseDir($dirName, $numEntries);
+    $verbose > 0 and $et->VerboseDir($dirName, $numEntries);
     my $bytesFromEnd = $dataLen - $dirEnd;
     if ($bytesFromEnd < 4) {
         unless ($bytesFromEnd==2 or $bytesFromEnd==0) {
-            $exifTool->Warn("Illegal $name directory size ($numEntries entries)");
+            $et->Warn("Illegal $name directory size ($numEntries entries)");
             return 0;
         }
     }
@@ -3786,7 +3796,7 @@ sub ProcessExif($$$)
     if (defined $$dirInfo{MakerNoteAddr}) {
         $makerAddr = $$dirInfo{MakerNoteAddr};
         delete $$dirInfo{MakerNoteAddr};
-        if (Image::ExifTool::MakerNotes::FixBase($exifTool, $dirInfo)) {
+        if (Image::ExifTool::MakerNotes::FixBase($et, $dirInfo)) {
             $base = $$dirInfo{Base};
             $dataPos = $$dirInfo{DataPos};
         }
@@ -3795,28 +3805,28 @@ sub ProcessExif($$$)
         my $longName = $name eq 'MakerNotes' ? ($$dirInfo{Name} || $name) : $name;
         if (defined $makerAddr) {
             my $hdrLen = $dirStart + $dataPos + $base - $makerAddr;
-            $exifTool->HDump($makerAddr, $hdrLen, "MakerNotes header", $longName) if $hdrLen > 0;
+            $et->HDump($makerAddr, $hdrLen, "MakerNotes header", $longName) if $hdrLen > 0;
         }
         unless ($$dirInfo{NoDumpEntryCount}) {
-            $exifTool->HDump($dirStart + $dataPos + $base, 2, "$longName entries",
-                             "Entry count: $numEntries");
+            $et->HDump($dirStart + $dataPos + $base, 2, "$longName entries",
+                       "Entry count: $numEntries");
         }
         my $tip;
         if ($bytesFromEnd >= 4) {
             my $nxt = ($name =~ /^(.*?)(\d+)$/) ? $1 . ($2 + 1) : 'Next IFD';
             $tip = sprintf("$nxt offset: 0x%.4x", Get32u($dataPt, $dirEnd));
         }
-        $exifTool->HDump($dirEnd + $dataPos + $base, 4, "Next IFD", $tip, 0);
+        $et->HDump($dirEnd + $dataPos + $base, 4, "Next IFD", $tip, 0);
     }
 
     # patch for Canon EOS 40D firmware 1.0.4 bug (incorrect directory counts)
     # (must do this before parsing directory or CameraSettings offset will be suspicious)
-    if ($inMakerNotes and $$exifTool{Model} eq 'Canon EOS 40D') {
+    if ($inMakerNotes and $$et{Model} eq 'Canon EOS 40D') {
         my $entry = $dirStart + 2 + 12 * ($numEntries - 1);
         my $fmt = Get16u($dataPt, $entry + 2);
         if ($fmt < 1 or $fmt > 13) {
-            $exifTool->HDump($entry+$dataPos+$base,12,"[invalid IFD entry]",
-                     "Bad format type: $fmt", 1);
+            $et->HDump($entry+$dataPos+$base,12,"[invalid IFD entry]",
+                       "Bad format type: $fmt", 1);
             # adjust the number of directory entries
             --$numEntries;
             $dirEnd -= 12;
@@ -3828,18 +3838,18 @@ sub ProcessExif($$$)
     my $warnCount = 0;
     for ($index=0; $index<$numEntries; ++$index) {
         if ($warnCount > 10) {
-            $exifTool->Warn("Too many warnings -- $name parsing aborted", 2) and return 0;
+            $et->Warn("Too many warnings -- $name parsing aborted", 2) and return 0;
         }
         my $entry = $dirStart + 2 + 12 * $index;
         my $tagID = Get16u($dataPt, $entry);
         my $format = Get16u($dataPt, $entry+2);
         my $count = Get32u($dataPt, $entry+4);
         if ($format < 1 or $format > 13) {
-            $exifTool->HDump($entry+$dataPos+$base,12,"[invalid IFD entry]",
-                     "Bad format type: $format", 1);
+            $et->HDump($entry+$dataPos+$base,12,"[invalid IFD entry]",
+                       "Bad format type: $format", 1);
             # warn unless the IFD was just padded with zeros
             if ($format) {
-                $exifTool->Warn("Bad format ($format) for $name entry $index", $inMakerNotes);
+                $et->Warn("Bad format ($format) for $name entry $index", $inMakerNotes);
                 ++$warnCount;
             }
             return 0 unless $index; # assume corrupted IFD if this is our first entry
@@ -3850,7 +3860,7 @@ sub ProcessExif($$$)
         my $valueDataPos = $dataPos;
         my $valueDataLen = $dataLen;
         my $valuePtr = $entry + 8;      # pointer to value within $$dataPt
-        my $tagInfo = $exifTool->GetTagInfo($tagTablePtr, $tagID);
+        my $tagInfo = $et->GetTagInfo($tagTablePtr, $tagID);
         my ($origFormStr, $bad, $rational);
         # hack to patch incorrect count in Kodak SubIFD3 tags
         if ($count < 2 and ref $$tagTablePtr{$tagID} eq 'HASH' and $$tagTablePtr{$tagID}{FixCount}) {
@@ -3867,7 +3877,7 @@ sub ProcessExif($$$)
         my $readSize = $size;
         if ($size > 4) {
             if ($size > 0x7fffffff) {
-                $exifTool->Warn(sprintf("Invalid size (%u) for %s tag 0x%.4x", $size, $name, $tagID));
+                $et->Warn(sprintf("Invalid size (%u) for %s tag 0x%.4x", $size, $name, $tagID));
                 ++$warnCount;
                 next;
             }
@@ -3884,7 +3894,7 @@ sub ProcessExif($$$)
             $valuePtr < 8 and not $$dirInfo{ZeroOffsetOK} and $suspect = $warnCount;
             # convert offset to pointer in $$dataPt
             if ($$dirInfo{EntryBased} or (ref $$tagTablePtr{$tagID} eq 'HASH' and
-                $tagTablePtr->{$tagID}{EntryBased}))
+                $$tagTablePtr{$tagID}{EntryBased}))
             {
                 $valuePtr += $entry;
             } else {
@@ -3906,14 +3916,14 @@ sub ProcessExif($$$)
                             last unless $$tagInfo{Binary};      # must read non-binary data
                             last if $$tagInfo{SubDirectory};    # must read SubDirectory data
                             my $lcTag = lc($$tagInfo{Name});
-                            if ($exifTool->{OPTIONS}{Binary} and
-                                not $exifTool->{EXCL_TAG_LOOKUP}{$lcTag})
+                            if ($$et{OPTIONS}{Binary} and
+                                not $$et{EXCL_TAG_LOOKUP}{$lcTag})
                             {
                                 # read binary data if specified unless tagsFromFile won't use it
-                                last unless $$exifTool{TAGS_FROM_FILE} and $$tagInfo{Protected};
+                                last unless $$et{TAGS_FROM_FILE} and $$tagInfo{Protected};
                             }
                             # must read if tag is specified by name
-                            last if $exifTool->{REQ_TAG_LOOKUP}{$lcTag};
+                            last if $$et{REQ_TAG_LOOKUP}{$lcTag};
                         } else {
                             # must read value if needed for a condition
                             last if defined $tagInfo;
@@ -3930,7 +3940,7 @@ sub ProcessExif($$$)
                             ($raf->Seek($base + $valuePtr + $dataPos,0) and
                              $raf->Read($buff,$size) == $size))
                     {
-                        $exifTool->Warn("Error reading value for $name entry $index", $inMakerNotes);
+                        $et->Warn("Error reading value for $name entry $index", $inMakerNotes);
                         return 0 unless $inMakerNotes or $htmlDump;
                         ++$warnCount;
                         $buff = '' unless defined $buff;
@@ -3947,7 +3957,7 @@ sub ProcessExif($$$)
                         $tagStr = $$tagInfo{Name};
                         $leicaTrailer = $$tagInfo{LeicaTrailer};
                     } elsif (defined $tagInfo) {
-                        $tmpInfo = $exifTool->GetTagInfo($tagTablePtr, $tagID, \ '', $formatStr, $count);
+                        $tmpInfo = $et->GetTagInfo($tagTablePtr, $tagID, \ '', $formatStr, $count);
                         if ($tmpInfo) {
                             $tagStr = $$tmpInfo{Name};
                             $leicaTrailer = $$tmpInfo{LeicaTrailer};
@@ -3961,23 +3971,23 @@ sub ProcessExif($$$)
                     }
                     $tagStr or $tagStr = sprintf("tag 0x%.4x",$tagID);
                     # allow PreviewImage to run outside EXIF data
-                    if ($tagStr eq 'PreviewImage' and $exifTool->{RAF}) {
-                        my $pos = $exifTool->{RAF}->Tell();
-                        $buff = $exifTool->ExtractBinary($base + $valuePtr + $dataPos, $size, 'PreviewImage');
-                        $exifTool->{RAF}->Seek($pos, 0);
+                    if ($tagStr eq 'PreviewImage' and $$et{RAF}) {
+                        my $pos = $$et{RAF}->Tell();
+                        $buff = $et->ExtractBinary($base + $valuePtr + $dataPos, $size, 'PreviewImage');
+                        $$et{RAF}->Seek($pos, 0);
                         $valueDataPt = \$buff;
                         $valueDataPos = $valuePtr + $dataPos;
                         $valueDataLen = $size;
                         $valuePtr = 0;
-                    } elsif ($leicaTrailer and $exifTool->{RAF}) {
+                    } elsif ($leicaTrailer and $$et{RAF}) {
                         if ($verbose > 0) {
-                            $exifTool->VPrint(0, "$$exifTool{INDENT}$index) $tagStr --> (outside APP1 segment)\n");
+                            $et->VPrint(0, "$$et{INDENT}$index) $tagStr --> (outside APP1 segment)\n");
                         }
-                        if ($exifTool->Options('FastScan')) {
-                            $exifTool->Warn('Ignored Leica MakerNote trailer');
+                        if ($et->Options('FastScan')) {
+                            $et->Warn('Ignored Leica MakerNote trailer');
                         } else {
                             require Image::ExifTool::Fixup;
-                            $$exifTool{LeicaTrailer} = {
+                            $$et{LeicaTrailer} = {
                                 TagInfo => $tagInfo || $tmpInfo,
                                 Offset  => $base + $valuePtr + $dataPos,
                                 Size    => $size,
@@ -3985,7 +3995,7 @@ sub ProcessExif($$$)
                             };
                         }
                     } else {
-                        $exifTool->Warn("Bad $name offset for $tagStr");
+                        $et->Warn("Bad $name offset for $tagStr");
                         ++$warnCount;
                     }
                     unless (defined $buff) {
@@ -4000,7 +4010,7 @@ sub ProcessExif($$$)
             # warn about suspect offsets if they didn't already cause another warning
             if (defined $suspect and $suspect == $warnCount) {
                 my $tagStr = $tagInfo ? $$tagInfo{Name} : sprintf('tag 0x%.4x', $tagID);
-                if ($exifTool->Warn("Suspicious $name offset for $tagStr", $inMakerNotes)) {
+                if ($et->Warn("Suspicious $name offset for $tagStr", $inMakerNotes)) {
                     ++$warnCount;
                     next unless $verbose;
                 }
@@ -4044,14 +4054,14 @@ sub ProcessExif($$$)
                 # GetTagInfo() required the value for a Condition
                 my $tmpVal = substr($$valueDataPt, $valuePtr, $readSize < 128 ? $readSize : 128);
                 # (use original format name in this call -- $formatStr may have been changed to int8u)
-                $tagInfo = $exifTool->GetTagInfo($tagTablePtr, $tagID, \$tmpVal,
-                                                 $formatName[$format], $count);
+                $tagInfo = $et->GetTagInfo($tagTablePtr, $tagID, \$tmpVal,
+                                           $formatName[$format], $count);
             }
         }
         # make sure we are handling the 'ifd' format properly
         if (($format == 13 or $format == 18) and (not $tagInfo or not $$tagInfo{SubIFD})) {
             my $str = sprintf('%s tag 0x%.4x IFD format not handled', $dirName, $tagID);
-            $exifTool->Warn($str, $inMakerNotes);
+            $et->Warn($str, $inMakerNotes);
         }
         if (defined $tagInfo) {
             my $readFormat = $$tagInfo{Format};
@@ -4072,7 +4082,7 @@ sub ProcessExif($$$)
             }
             # verify that offset-type values are integral
             if (($$tagInfo{IsOffset} or $$tagInfo{SubIFD}) and not $intFormat{$formatStr}) {
-                $exifTool->Warn("Wrong format ($formatStr) for $name $$tagInfo{Name}");
+                $et->Warn("Wrong format ($formatStr) for $name $$tagInfo{Name}");
                 next unless $verbose;
                 $wrongFormat = 1;
             }
@@ -4085,13 +4095,13 @@ sub ProcessExif($$$)
             if ($count > 100000 and $formatStr !~ /^(undef|string|binary)$/) {
                 my $tagName = $tagInfo ? $$tagInfo{Name} : sprintf('tag 0x%.4x', $tagID);
                 my $minor = $count > 2000000 ? 0 : 2;
-                next if $exifTool->Warn("Ignoring $dirName $tagName with excessive count", $minor);
+                next if $et->Warn("Ignoring $dirName $tagName with excessive count", $minor);
             }
             # convert according to specified format
             $val = ReadValue($valueDataPt,$valuePtr,$formatStr,$count,$readSize,\$rational);
             # re-code if necessary
             if ($strEnc and $formatStr eq 'string' and defined $val) {
-                $val = $exifTool->Decode($val, $strEnc);
+                $val = $et->Decode($val, $strEnc);
             }
         }
 
@@ -4118,7 +4128,7 @@ sub ProcessExif($$$)
                           "Format: $fstr\nSize: $size bytes\n";
                 if ($size > 4) {
                     my $offPt = Get32u($dataPt,$entry+8);
-                    my $actPt = $valuePtr + $valueDataPos + $base - ($$exifTool{EXIF_POS} || 0);
+                    my $actPt = $valuePtr + $valueDataPos + $base - ($$et{EXIF_POS} || 0);
                     $tip .= sprintf("Value offset: 0x%.4x\n", $offPt);
                     # highlight tag name (red for bad size)
                     my $style = ($bad or not defined $tval) ? 'V' : 'H';
@@ -4144,7 +4154,7 @@ sub ProcessExif($$$)
                     } elsif ($tagInfo and Image::ExifTool::IsInt($tval)) {
                         if ($$tagInfo{IsOffset} or $$tagInfo{SubIFD}) {
                             $tval = sprintf('0x%.4x', $tval);
-                            my $actPt = $val + $base - ($$exifTool{EXIF_POS} || 0);
+                            my $actPt = $val + $base - ($$et{EXIF_POS} || 0);
                             if ($actPt != $val) {
                                 $tval .= sprintf("\nActual offset: 0x%.4x", $actPt);
                                 my $sign = $actPt < $val ? '-' : '';
@@ -4156,7 +4166,7 @@ sub ProcessExif($$$)
                     }
                 }
                 $tip .= "Value: $tval";
-                $exifTool->HDump($entry+$dataPos+$base, 12, "$dname $colName", $tip, 1);
+                $et->HDump($entry+$dataPos+$base, 12, "$dname $colName", $tip, 1);
                 next if $valueDataLen < 0;  # don't process bad pointer entry
                 if ($size > 4) {
                     my $exifDumpPos = $valuePtr + $valueDataPos + $base;
@@ -4169,12 +4179,12 @@ sub ProcessExif($$$)
                         }
                     }
                     # add value data block (underlining maker notes data)
-                    $exifTool->HDump($exifDumpPos,$size,"$tagName value",'SAME', $flag);
+                    $et->HDump($exifDumpPos,$size,"$tagName value",'SAME', $flag);
                 }
             } else {
                 my $fstr = $formatName[$format];
                 $fstr = "$origFormStr read as $fstr" if $origFormStr;
-                $exifTool->VerboseInfo($tagID, $tagInfo,
+                $et->VerboseInfo($tagID, $tagInfo,
                     Table   => $tagTablePtr,
                     Index   => $index,
                     Value   => $tval,
@@ -4196,7 +4206,7 @@ sub ProcessExif($$$)
             # don't process empty subdirectories
             unless ($size) {
                 unless ($$tagInfo{MakerNotes} or $inMakerNotes) {
-                    $exifTool->Warn("Empty $$tagInfo{Name} data", 1);
+                    $et->Warn("Empty $$tagInfo{Name} data", 1);
                 }
                 next;
             }
@@ -4207,7 +4217,7 @@ sub ProcessExif($$$)
                 # limit the number of subdirectories we parse
                 my $over = @values - $$subdir{MaxSubdirs};
                 if ($over > 0) {
-                    $exifTool->Warn("Ignoring $over $tagStr directories");
+                    $et->Warn("Ignoring $over $tagStr directories");
                     splice @values, $$subdir{MaxSubdirs};
                 }
                 $val = shift @values;
@@ -4231,7 +4241,7 @@ sub ProcessExif($$$)
                     #### eval Start ($valuePtr, $val)
                     my $newStart = eval($$subdir{Start});
                     unless (Image::ExifTool::IsInt($newStart)) {
-                        $exifTool->Warn("Bad value for $tagStr");
+                        $et->Warn("Bad value for $tagStr");
                         last;
                     }
                     # convert back to relative to $subdirDataPt
@@ -4283,7 +4293,7 @@ sub ProcessExif($$$)
                     #### eval OffsetPt ($valuePtr)
                     my $pos = eval $$subdir{OffsetPt};
                     if ($pos + 4 > $subdirDataLen) {
-                        $exifTool->Warn("Bad $tagStr OffsetPt");
+                        $et->Warn("Bad $tagStr OffsetPt");
                         last;
                     }
                     SetByteOrder($newByteOrder);
@@ -4307,7 +4317,7 @@ sub ProcessExif($$$)
                                 $msg .= " (directory end is $end but EXIF size is only $subdirDataLen)";
                             }
                         }
-                        $exifTool->Warn($msg);
+                        $et->Warn($msg);
                         last;
                     }
                 }
@@ -4337,7 +4347,7 @@ sub ProcessExif($$$)
                 # (remember: some cameras incorrectly write maker notes in IFD0)
                 if ($$tagInfo{MakerNotes}) {
                     # don't parse makernotes if FastScan > 1
-                    my $fast = $exifTool->Options('FastScan');
+                    my $fast = $et->Options('FastScan');
                     last if $fast and $fast > 1;
                     $subdirInfo{MakerNoteAddr} = $valuePtr + $valueDataPos + $base;
                     $subdirInfo{NoFixBase} = 1 if defined $$subdir{Base};
@@ -4346,7 +4356,7 @@ sub ProcessExif($$$)
                 # unless the tag is writable as a block in which case group 1 may
                 # have been set automatically
                 if ($$tagInfo{Groups} and not $$tagInfo{Writable}) {
-                    $subdirInfo{DirName} = $tagInfo->{Groups}{1};
+                    $subdirInfo{DirName} = $$tagInfo{Groups}{1};
                     # number multiple subdirectories
                     $subdirInfo{DirName} =~ s/\d*$/$dirNum/ if $dirNum;
                 }
@@ -4356,39 +4366,39 @@ sub ProcessExif($$$)
                 #### eval Validate ($val, $dirData, $subdirStart, $size)
                 my $ok = 0;
                 if (defined $$subdir{Validate} and not eval $$subdir{Validate}) {
-                    $exifTool->Warn("Invalid $tagStr data");
+                    $et->Warn("Invalid $tagStr data");
                     $invalid = 1;
                 } else {
                     if (not $subdirInfo{DirName} and $inMakerNotes) {
                         $subdirInfo{DirName} = $$tagInfo{Name};
                     }
                     # process the subdirectory
-                    $ok = $exifTool->ProcessDirectory(\%subdirInfo, $newTagTable, $$subdir{ProcessProc});
+                    $ok = $et->ProcessDirectory(\%subdirInfo, $newTagTable, $$subdir{ProcessProc});
                 }
                 # print debugging information if there were errors
                 if (not $ok and $verbose > 1 and $subdirStart != $valuePtr) {
-                    my $out = $exifTool->Options('TextOut');
-                    printf $out "%s    (SubDirectory start = 0x%x)\n", $exifTool->{INDENT}, $subdirStart;
+                    my $out = $et->Options('TextOut');
+                    printf $out "%s    (SubDirectory start = 0x%x)\n", $$et{INDENT}, $subdirStart;
                 }
                 SetByteOrder($oldByteOrder);    # restore original byte swapping
 
                 @values or last;
                 $val = shift @values;           # continue with next subdir
             }
-            my $doMaker = $exifTool->Options('MakerNotes');
-            next unless $doMaker or $exifTool->{REQ_TAG_LOOKUP}{lc($tagStr)} or
+            my $doMaker = $et->Options('MakerNotes');
+            next unless $doMaker or $$et{REQ_TAG_LOOKUP}{lc($tagStr)} or
                         $$tagInfo{BlockExtract};
             # extract as a block if specified
             if ($$tagInfo{MakerNotes}) {
                 # save maker note byte order (if it was significant and valid)
                 if ($$subdir{ByteOrder} and not $invalid) {
-                    $exifTool->{MAKER_NOTE_BYTE_ORDER} =
-                        defined ($exifTool->{UnknownByteOrder}) ?
-                                 $exifTool->{UnknownByteOrder} : $newByteOrder;
+                    $$et{MAKER_NOTE_BYTE_ORDER} =
+                        defined ($$et{UnknownByteOrder}) ?
+                                 $$et{UnknownByteOrder} : $newByteOrder;
                 }
                 if ($doMaker and $doMaker eq '2') {
                     # extract maker notes without rebuilding (no fixup information)
-                    delete $exifTool->{MAKER_NOTE_FIXUP};
+                    delete $$et{MAKER_NOTE_FIXUP};
                 } elsif (not $$tagInfo{NotIFD}) {
                     # this is a pain, but we must rebuild EXIF-typemaker notes to
                     # include all the value data if data was outside the maker notes
@@ -4407,12 +4417,12 @@ sub ProcessExif($$$)
                         TagInfo    => $tagInfo,
                     );
                     $makerDirInfo{FixBase} = 1 if $$subdir{FixBase};
-                    # rebuild maker notes (creates $exifTool->{MAKER_NOTE_FIXUP})
-                    my $val2 = RebuildMakerNotes($exifTool, $newTagTable, \%makerDirInfo);
+                    # rebuild maker notes (creates $$et{MAKER_NOTE_FIXUP})
+                    my $val2 = RebuildMakerNotes($et, $newTagTable, \%makerDirInfo);
                     if (defined $val2) {
                         $val = $val2;
                     } elsif ($size > 4) {
-                        $exifTool->Warn('Error rebuilding maker notes (may be corrupt)');
+                        $et->Warn('Error rebuilding maker notes (may be corrupt)');
                     }
                 }
             } else {
@@ -4422,13 +4432,13 @@ sub ProcessExif($$$)
         }
  #..............................................................................
         # convert to absolute offsets if this tag is an offset
-        #### eval IsOffset ($val, $exifTool)
+        #### eval IsOffset ($val, $et)
         if ($$tagInfo{IsOffset} and eval $$tagInfo{IsOffset}) {
             my $offsetBase = $$tagInfo{IsOffset} eq '2' ? $firstBase : $base;
-            $offsetBase += $$exifTool{BASE};
+            $offsetBase += $$et{BASE};
             # handle offsets which use a wrong base (Minolta A200)
             if ($$tagInfo{WrongBase}) {
-                my $self = $exifTool;
+                my $self = $et;
                 #### eval WrongBase ($self)
                 $offsetBase += eval $$tagInfo{WrongBase} || 0;
             }
@@ -4439,12 +4449,12 @@ sub ProcessExif($$$)
             $val = join(' ', @vals);
         }
         # save the value of this tag
-        $tagKey = $exifTool->FoundTag($tagInfo, $val);
+        $tagKey = $et->FoundTag($tagInfo, $val);
         if (defined $tagKey) {
             # set the group 1 name for tags in specified tables
-            $exifTool->SetGroup($tagKey, $dirName) if $$tagTablePtr{SET_GROUP1};
+            $et->SetGroup($tagKey, $dirName) if $$tagTablePtr{SET_GROUP1};
             # save original components of rational numbers (used when copying)
-            $$exifTool{RATIONAL}{$tagKey} = $rational if defined $rational;
+            $$et{RATIONAL}{$tagKey} = $rational if defined $rational;
         }
     }
 
@@ -4463,12 +4473,12 @@ sub ProcessExif($$$)
             $newDirInfo{DirName} .= $ifdNum + 1;
             # must validate SubIFD1 because the nextIFD pointer is invalid for some RAW formats
             if ($newDirInfo{DirName} ne 'SubIFD1' or ValidateIFD(\%newDirInfo)) {
-                $exifTool->{INDENT} =~ s/..$//; # keep indent the same
-                my $cur = pop @{$$exifTool{PATH}};
-                $exifTool->ProcessDirectory(\%newDirInfo, $tagTablePtr) or $success = 0;
-                push @{$$exifTool{PATH}}, $cur;
-            } elsif ($verbose or $exifTool->{TIFF_TYPE} eq 'TIFF') {
-                $exifTool->Warn('Ignored bad IFD linked from SubIFD');
+                $$et{INDENT} =~ s/..$//; # keep indent the same
+                my $cur = pop @{$$et{PATH}};
+                $et->ProcessDirectory(\%newDirInfo, $tagTablePtr) or $success = 0;
+                push @{$$et{PATH}}, $cur;
+            } elsif ($verbose or $$et{TIFF_TYPE} eq 'TIFF') {
+                $et->Warn('Ignored bad IFD linked from SubIFD');
             }
         }
     }