exiftool_vendored 9.37.0 → 9.41.0

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

@@ -23,7 +23,7 @@ use strict;
 use vars qw($VERSION);
 use Image::ExifTool qw(:DataAccess :Utils);
 
-$VERSION = '1.26';
+$VERSION = '1.27';
 
 sub ProcessICC($$);
 sub ProcessICC_Profile($$$);
@@ -627,20 +627,20 @@ sub FormatICCTag($$$)
 # Returns: 1 on success
 sub ProcessMetadata($$$)
 {
-    my ($exifTool, $dirInfo, $tagTablePtr) = @_;
+    my ($et, $dirInfo, $tagTablePtr) = @_;
     my $dataPt = $$dirInfo{DataPt};
     my $dirStart = $$dirInfo{DirStart};
     my $dirLen = $$dirInfo{DirLen};
     my $dirEnd = $dirStart + $dirLen;
     
     if ($dirLen < 16 or substr($$dataPt, $dirStart, 4) ne 'dict') {
-        $exifTool->Warn('Invalid ICC meta dictionary');
+        $et->Warn('Invalid ICC meta dictionary');
         return 0;
     }
     my $num = Get32u($dataPt, $dirStart + 8);
-    $exifTool->VerboseDir('Metadata', $num);
+    $et->VerboseDir('Metadata', $num);
     my $size = Get32u($dataPt, $dirStart + 12);
-    $size < 16 and $exifTool->Warn('Invalid ICC meta record size'), return 0;
+    $size < 16 and $et->Warn('Invalid ICC meta record size'), return 0;
     # NOTE: In the example the minimum offset is 20,
     # but this doesn't jive with the table (both in ref 5)
     my $minPtr = 16 + $size * $num;
@@ -648,7 +648,7 @@ sub ProcessMetadata($$$)
     for ($index=0; $index<$num; ++$index) {
         my $entry = $dirStart + 16 + $size * $index;
         if ($entry + $size > $dirEnd) {
-            $exifTool->Warn('Truncated ICC meta dictionary');
+            $et->Warn('Truncated ICC meta dictionary');
             last;
         }
         my $namePtr = Get32u($dataPt, $entry);
@@ -659,13 +659,13 @@ sub ProcessMetadata($$$)
         if ($namePtr < $minPtr or $namePtr + $nameLen > $dirLen or
             $valuePtr < $minPtr or $valuePtr + $valueLen > $dirLen)
         {
-            $exifTool->Warn('Corrupted ICC meta dictionary');
+            $et->Warn('Corrupted ICC meta dictionary');
             last;
         }
         my $tag = substr($dataPt, $dirStart + $namePtr, $nameLen);
         my $val = substr($dataPt, $dirStart + $valuePtr, $valueLen);
-        $tag = $exifTool->Decode($tag, 'UTF16', 'MM', 'UTF8');
-        $val = $exifTool->Decode($val, 'UTF16', 'MM');
+        $tag = $et->Decode($tag, 'UTF16', 'MM', 'UTF8');
+        $val = $et->Decode($val, 'UTF16', 'MM');
         # generate tagInfo if it doesn't exist
         unless ($$tagTablePtr{$tag}) {
             my $name = ucfirst $tag;
@@ -674,7 +674,7 @@ sub ProcessMetadata($$$)
             next unless length $name;
             AddTagToTable($tagTablePtr, $tag, { Name => $name });
         }
-        $exifTool->HandleTag($tagTablePtr, $tag, $val);
+        $et->HandleTag($tagTablePtr, $tag, $val);
     }
     return 1;
 }
@@ -686,17 +686,17 @@ sub ProcessMetadata($$$)
 #          or -1 if a write error occurred
 sub WriteICC($$)
 {
-    my ($exifTool, $dirInfo) = @_;
+    my ($et, $dirInfo) = @_;
     # first make sure this is a valid ICC file (or no file at all)
     my $raf = $$dirInfo{RAF};
     my $buff;
     return 0 if $raf->Read($buff, 24) and ValidateICC(\$buff);
     # now write the new ICC
-    $buff = WriteICC_Profile($exifTool, $dirInfo);
+    $buff = WriteICC_Profile($et, $dirInfo);
     if (defined $buff and length $buff) {
         Write($$dirInfo{OutFile}, $buff) or return -1;
     } else {
-        $exifTool->Error('No ICC information to write');
+        $et->Error('No ICC information to write');
     }
     return 1;
 }
@@ -709,16 +709,16 @@ sub WriteICC($$)
 # Notes: Increments ExifTool CHANGED flag if changed
 sub WriteICC_Profile($$;$)
 {
-    my ($exifTool, $dirInfo, $tagTablePtr) = @_;
-    $exifTool or return 1;    # allow dummy access
+    my ($et, $dirInfo, $tagTablePtr) = @_;
+    $et or return 1;    # allow dummy access
     my $dirName = $$dirInfo{DirName} || 'ICC_Profile';
     # (don't write AsShotICCProfile or CurrentICCProfile here)
     return undef unless $dirName eq 'ICC_Profile';
-    my $nvHash = $exifTool->GetNewValueHash($Image::ExifTool::Extra{$dirName});
-    return undef unless $exifTool->IsOverwriting($nvHash);
-    my $val = $exifTool->GetNewValues($nvHash);
+    my $nvHash = $et->GetNewValueHash($Image::ExifTool::Extra{$dirName});
+    return undef unless $et->IsOverwriting($nvHash);
+    my $val = $et->GetNewValues($nvHash);
     $val = '' unless defined $val;
-    ++$exifTool->{CHANGED};
+    ++$$et{CHANGED};
     return $val;
 }
 
@@ -746,22 +746,22 @@ sub ValidateICC($)
 # Returns: 1 if this was an ICC file
 sub ProcessICC($$)
 {
-    my ($exifTool, $dirInfo) = @_;
+    my ($et, $dirInfo) = @_;
     my $raf = $$dirInfo{RAF};
     my $buff;
     $raf->Read($buff, 24) == 24 or return 0;
     # check to see if this is a valid ICC profile file
     return 0 if ValidateICC(\$buff);
-    $exifTool->SetFileType();
+    $et->SetFileType();
     # read the profile
     my $size = unpack('N', $buff);
     if ($size < 128 or $size & 0x80000000) {
-        $exifTool->Error("Bad ICC Profile length ($size)");
+        $et->Error("Bad ICC Profile length ($size)");
         return 1;
     }
     $raf->Seek(0, 0);
     unless ($raf->Read($buff, $size)) {
-        $exifTool->Error('Truncated ICC profile');
+        $et->Error('Truncated ICC profile');
         return 1;
     }
     my %dirInfo = (
@@ -771,7 +771,7 @@ sub ProcessICC($$)
         DirLen => $size,
     );
     my $tagTablePtr = GetTagTable('Image::ExifTool::ICC_Profile::Main');
-    return ProcessICC_Profile($exifTool, \%dirInfo, $tagTablePtr);
+    return ProcessICC_Profile($et, \%dirInfo, $tagTablePtr);
 }
 
 #------------------------------------------------------------------------------
@@ -781,21 +781,21 @@ sub ProcessICC($$)
 # Returns: 1 on success
 sub ProcessICC_Profile($$$)
 {
-    my ($exifTool, $dirInfo, $tagTablePtr) = @_;
+    my ($et, $dirInfo, $tagTablePtr) = @_;
     my $dataPt = $$dirInfo{DataPt};
     my $dirStart = $$dirInfo{DirStart} || 0;
     my $dirLen = $$dirInfo{DirLen};
-    my $verbose = $exifTool->Options('Verbose');
+    my $verbose = $et->Options('Verbose');
 
     return 0 if $dirLen < 4;
 
     # extract binary ICC_Profile data block if binary mode or requested
-    if ((($exifTool->{TAGS_FROM_FILE} and not $exifTool->{EXCL_TAG_LOOKUP}{icc_profile}) or
-        $exifTool->{REQ_TAG_LOOKUP}{icc_profile}) and
+    if ((($$et{TAGS_FROM_FILE} and not $$et{EXCL_TAG_LOOKUP}{icc_profile}) or
+        $$et{REQ_TAG_LOOKUP}{icc_profile}) and
         # (don't extract from AsShotICCProfile or CurrentICCProfile)
         (not $$dirInfo{Name} or $$dirInfo{Name} eq 'ICC_Profile'))
     {
-        $exifTool->FoundTag('ICC_Profile', substr($$dataPt, $dirStart, $dirLen));
+        $et->FoundTag('ICC_Profile', substr($$dataPt, $dirStart, $dirLen));
     }
 
     SetByteOrder('MM');     # ICC_Profile is always big-endian
@@ -803,7 +803,7 @@ sub ProcessICC_Profile($$$)
     # check length of table
     my $len = Get32u($dataPt, $dirStart);
     if ($len != $dirLen or $len < 128) {
-        $exifTool->Warn("Bad length ICC_Profile (length $len)");
+        $et->Warn("Bad length ICC_Profile (length $len)");
         return 0 if $len < 128 or $dirLen < $len;
     }
     my $pos = $dirStart + 128;  # position at start of table
@@ -811,18 +811,18 @@ sub ProcessICC_Profile($$$)
     if ($numEntries < 1 or $numEntries >= 0x100
         or $numEntries * 12 + 132 > $dirLen)
     {
-        $exifTool->Warn("Bad ICC_Profile table ($numEntries entries)");
+        $et->Warn("Bad ICC_Profile table ($numEntries entries)");
         return 0;
     }
 
     if ($verbose) {
-        $exifTool->VerboseDir('ICC_Profile', $numEntries, $dirLen);
+        $et->VerboseDir('ICC_Profile', $numEntries, $dirLen);
         my $fakeInfo = { Name=>'ProfileHeader', SubDirectory => { } };
-        $exifTool->VerboseInfo(undef, $fakeInfo);
+        $et->VerboseInfo(undef, $fakeInfo);
     }
     # increment ICC dir count
-    my $dirCount = $exifTool->{DIR_COUNT}->{ICC} = ($exifTool->{DIR_COUNT}->{ICC} || 0) + 1;
-    $exifTool->{SET_GROUP1} = '+' . $dirCount if $dirCount > 1;
+    my $dirCount = $$et{DIR_COUNT}{ICC} = ($$et{DIR_COUNT}{ICC} || 0) + 1;
+    $$et{SET_GROUP1} = '+' . $dirCount if $dirCount > 1;
     # process the header block
     my %subdirInfo = (
         Name     => 'ProfileHeader',
@@ -834,7 +834,7 @@ sub ProcessICC_Profile($$$)
         DirName  => 'Header',
     );
     my $newTagTable = GetTagTable('Image::ExifTool::ICC_Profile::Header');
-    $exifTool->ProcessDirectory(\%subdirInfo, $newTagTable);
+    $et->ProcessDirectory(\%subdirInfo, $newTagTable);
 
     $pos += 4;    # skip item count
     my $index;
@@ -843,17 +843,17 @@ sub ProcessICC_Profile($$$)
         my $offset = Get32u($dataPt, $pos + 4);
         my $size   = Get32u($dataPt, $pos + 8);
         $pos += 12;
-        my $tagInfo = $exifTool->GetTagInfo($tagTablePtr, $tagID);
+        my $tagInfo = $et->GetTagInfo($tagTablePtr, $tagID);
         # unknown tags aren't generated automatically by GetTagInfo()
         # if the tagID's aren't numeric, so we must do this manually:
-        if (not $tagInfo and $exifTool->{OPTIONS}->{Unknown}) {
+        if (not $tagInfo and $$et{OPTIONS}{Unknown}) {
             $tagInfo = { Unknown => 1 };
             AddTagToTable($tagTablePtr, $tagID, $tagInfo);
         }
         next unless defined $tagInfo;
 
         if ($offset + $size > $dirLen) {
-            $exifTool->Warn("Bad ICC_Profile table (truncated)");
+            $et->Warn("Bad ICC_Profile table (truncated)");
             last;
         }
         my $valuePtr = $dirStart + $offset;
@@ -883,8 +883,8 @@ sub ProcessICC_Profile($$$)
                     my $strPos = Get32u($dataPt, $recPos + 8);
                     last if $strPos + $strLen > $size; 
                     my $str = substr($$dataPt, $valuePtr + $strPos, $strLen);
-                    $str = $exifTool->Decode($str, 'UTF16');
-                    $exifTool->HandleTag($tagTablePtr, $tagID, $str,
+                    $str = $et->Decode($str, 'UTF16');
+                    $et->HandleTag($tagTablePtr, $tagID, $str,
                         TagInfo => $langInfo || $tagInfo,
                         Table  => $tagTablePtr,
                         Index  => $index,
@@ -895,14 +895,14 @@ sub ProcessICC_Profile($$$)
                         Format => "type '$fmt'",
                     );
                 }
-                $exifTool->Warn("Corrupted $$tagInfo{Name} data") if $i < $count;
+                $et->Warn("Corrupted $$tagInfo{Name} data") if $i < $count;
                 next;
             }
         } else {
             $fmt = 'err ';
         }
         $value = FormatICCTag($dataPt, $valuePtr, $size) unless $subdir;
-        $verbose and $exifTool->VerboseInfo($tagID, $tagInfo,
+        $verbose and $et->VerboseInfo($tagID, $tagInfo,
             Table  => $tagTablePtr,
             Index  => $index,
             Value  => $value,
@@ -937,20 +937,20 @@ sub ProcessICC_Profile($$$)
             my $type = substr($$dataPt, $valuePtr, 4);
             #### eval Validate ($type)
             if (defined $$subdir{Validate} and not eval $$subdir{Validate}) {
-                $exifTool->Warn("Invalid $name data");
+                $et->Warn("Invalid $name data");
             } else {
-                $exifTool->ProcessDirectory(\%subdirInfo, $newTagTable, $$subdir{ProcessProc});
+                $et->ProcessDirectory(\%subdirInfo, $newTagTable, $$subdir{ProcessProc});
             }
         } elsif (defined $value) {
-            $exifTool->FoundTag($tagInfo, $value);
+            $et->FoundTag($tagInfo, $value);
         } else {
             $value = substr($$dataPt, $valuePtr, $size);
             # treat unsupported formats as binary data
             $$tagInfo{ValueConv} = '\$val' unless defined $$tagInfo{ValueConv};
-            $exifTool->FoundTag($tagInfo, $value);
+            $et->FoundTag($tagInfo, $value);
         }
     }
-    delete $exifTool->{SET_GROUP1};
+    delete $$et{SET_GROUP1};
     return 1;
 }
 

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

@@ -16,7 +16,7 @@ use strict;
 use vars qw($VERSION);
 use Image::ExifTool qw(:DataAccess :Utils);
 
-$VERSION = '1.39';
+$VERSION = '1.40';
 
 sub ProcessID3v2($$$);
 sub ProcessPrivate($$$);
@@ -800,8 +800,8 @@ Image::ExifTool::AddCompositeTags('Image::ExifTool::ID3');
 # Returns: converted text
 sub ConvertID3v1Text($$)
 {
-    my ($exifTool, $val) = @_;
-    return $exifTool->Decode($val, $exifTool->Options('CharsetID3'));
+    my ($et, $val) = @_;
+    return $et->Decode($val, $et->Options('CharsetID3'));
 }
 
 #------------------------------------------------------------------------------
@@ -832,10 +832,10 @@ sub ConvertTimeStamp($)
 # Inputs: 0) ExifTool object ref, 1) dirInfo ref, 2) tag table ref
 sub ProcessSynText($$$)
 {
-    my ($exifTool, $dirInfo, $tagTablePtr) = @_;
+    my ($et, $dirInfo, $tagTablePtr) = @_;
     my $dataPt = $$dirInfo{DataPt};
 
-    $exifTool->VerboseDir('SynLyrics', 0, length $$dataPt);
+    $et->VerboseDir('SynLyrics', 0, length $$dataPt);
     return unless length $$dataPt > 6;
 
     my ($enc,$lang,$timeCode,$type) = unpack('Ca3CC', $$dataPt);
@@ -853,13 +853,13 @@ sub ProcessSynText($$$)
         $pat = '\0(....)';
     }
     my $desc = substr($$dataPt, 6, pos($$dataPt) - 6 - $termLen);
-    $desc = DecodeString($exifTool, $desc, $enc);
+    $desc = DecodeString($et, $desc, $enc);
 
-    my $tagInfo = $exifTool->GetTagInfo($tagTablePtr, 'desc');
+    my $tagInfo = $et->GetTagInfo($tagTablePtr, 'desc');
     $tagInfo = Image::ExifTool::GetLangInfo($tagInfo, $lang) if $lang;
-    $exifTool->HandleTag($tagTablePtr, 'type', $type);
-    $exifTool->HandleTag($tagTablePtr, 'desc', $desc, TagInfo => $tagInfo);
-    $tagInfo = $exifTool->GetTagInfo($tagTablePtr, 'text');
+    $et->HandleTag($tagTablePtr, 'type', $type);
+    $et->HandleTag($tagTablePtr, 'desc', $desc, TagInfo => $tagInfo);
+    $tagInfo = $et->GetTagInfo($tagTablePtr, 'text');
     $tagInfo = Image::ExifTool::GetLangInfo($tagInfo, $lang) if $lang;
 
     for (;;) {
@@ -867,7 +867,7 @@ sub ProcessSynText($$$)
         last unless $$dataPt =~ /$pat/sg;
         my $time = unpack('N', $1);
         my $text = substr($$dataPt, $pos, pos($$dataPt) - $pos - 4 - $termLen);
-        $text = DecodeString($exifTool, $text, $enc);
+        $text = DecodeString($et, $text, $enc);
         my $timeStr;
         if ($timeCode == 2) { # time in ms
             $timeStr = sprintf('%.3f', $time / 1000);
@@ -875,7 +875,7 @@ sub ProcessSynText($$$)
             $timeStr = sprintf('%.4d', $time);
             $timeStr .= '?' if $timeCode != 1;
         }
-        $exifTool->HandleTag($tagTablePtr, 'text', "[$timeStr]$text", TagInfo => $tagInfo);
+        $et->HandleTag($tagTablePtr, 'text', "[$timeStr]$text", TagInfo => $tagInfo);
     }
 }
 
@@ -884,10 +884,10 @@ sub ProcessSynText($$$)
 # Inputs: 0) ExifTool object ref, 1) dirInfo ref, 2) tag table ref
 sub ProcessPrivate($$$)
 {
-    my ($exifTool, $dirInfo, $tagTablePtr) = @_;
+    my ($et, $dirInfo, $tagTablePtr) = @_;
     my $dataPt = $$dirInfo{DataPt};
     my ($tag, $start);
-    $exifTool->VerboseDir('PRIV', 0, length $$dataPt);
+    $et->VerboseDir('PRIV', 0, length $$dataPt);
     if ($$dataPt =~ /^(.*?)\0/s) {
         $tag = $1;
         $start = length($tag) + 1;
@@ -903,13 +903,13 @@ sub ProcessPrivate($$$)
                 { Name => ucfirst($tag), Binary => 1 });
         }
     }
-    my $key = $exifTool->HandleTag($tagTablePtr, $tag, undef,
+    my $key = $et->HandleTag($tagTablePtr, $tag, undef,
         Size  => length($$dataPt) - $start,
         Start => $start,
         DataPt => $dataPt,
     );
     # set group1 name
-    $exifTool->SetGroup($key, $$exifTool{ID3_Ver}) if $key;
+    $et->SetGroup($key, $$et{ID3_Ver}) if $key;
 }
 
 #------------------------------------------------------------------------------
@@ -943,7 +943,7 @@ sub PrintGenre($)
 # Returns: Decoded string in scalar context, or list of strings in list context
 sub DecodeString($$;$)
 {
-    my ($exifTool, $val, $enc) = @_;
+    my ($et, $val, $enc) = @_;
     return '' unless length $val;
     unless (defined $enc) {
         $enc = unpack('C', $val);
@@ -955,7 +955,7 @@ sub DecodeString($$;$)
         # (must split before converting because conversion routines truncate at null)
         @vals = split "\0", $val;
         foreach $val (@vals) {
-            $val = $exifTool->Decode($val, $enc ? 'UTF8' : 'Latin');
+            $val = $et->Decode($val, $enc ? 'UTF8' : 'Latin');
         }
     } elsif ($enc == 1 or $enc == 2) {  # UTF-16 with BOM, or UTF-16BE
         my $bom = "\xfe\xff";
@@ -971,7 +971,7 @@ sub DecodeString($$;$)
                 $val = '';
             }
             $bom = $1 if $v =~ s/^(\xfe\xff|\xff\xfe)//;
-            push @vals, $exifTool->Decode($v, 'UCS2', $order{$bom});
+            push @vals, $et->Decode($v, 'UCS2', $order{$bom});
         }
     } else {
         $val =~ s/\0+$//;
@@ -1000,15 +1000,15 @@ sub UnSyncSafe($)
 # Inputs: 0) ExifTool object ref, 1) dirInfo ref, 2) tag table ref
 sub ProcessID3v2($$$)
 {
-    my ($exifTool, $dirInfo, $tagTablePtr) = @_;
+    my ($et, $dirInfo, $tagTablePtr) = @_;
     my $dataPt  = $$dirInfo{DataPt};
     my $offset  = $$dirInfo{DirStart};
     my $size    = $$dirInfo{DirLen};
     my $vers    = $$dirInfo{Version};
-    my $verbose = $exifTool->Options('Verbose');
+    my $verbose = $et->Options('Verbose');
     my $len;    # frame data length
 
-    $verbose and $exifTool->VerboseDir($tagTablePtr->{GROUPS}->{1}, 0, $size);
+    $verbose and $et->VerboseDir($tagTablePtr->{GROUPS}->{1}, 0, $size);
 
     for (;;$offset+=$len) {
         my ($id, $flags, $hi);
@@ -1032,7 +1032,7 @@ sub ProcessID3v2($$$)
                 my $oldLen = $len;
                 $len =  UnSyncSafe($len);
                 if (not defined $len or $offset + $len + 10 > $size) {
-                    $exifTool->Warn('Invalid ID3 frame size');
+                    $et->Warn('Invalid ID3 frame size');
                     last;
                 }
                 # check next ID to see if it makes sense
@@ -1046,9 +1046,9 @@ sub ProcessID3v2($$$)
             }
         }
         last if $offset + $len > $size;
-        my $tagInfo = $exifTool->GetTagInfo($tagTablePtr, $id);
+        my $tagInfo = $et->GetTagInfo($tagTablePtr, $id);
         unless ($tagInfo) {
-            next unless $verbose or $exifTool->Options('Unknown');
+            next unless $verbose or $et->Options('Unknown');
             $id =~ tr/-A-Za-z0-9_//dc;
             $id = 'unknown' unless length $id;
             unless ($$tagTablePtr{$id}) {
@@ -1074,7 +1074,7 @@ sub ProcessID3v2($$$)
             }
         }
         if ($flags{Encrypt}) {
-            $exifTool->WarnOnce('Encrypted frames currently not supported');
+            $et->WarnOnce('Encrypted frames currently not supported');
             next;
         }
         # extract the value
@@ -1085,13 +1085,13 @@ sub ProcessID3v2($$$)
 
         # read grouping identity
         if ($flags{GroupID}) {
-            length($val) >= 1 or $exifTool->Warn("Short $id frame"), next;
+            length($val) >= 1 or $et->Warn("Short $id frame"), next;
             $val = substr($val, 1); # (ignore it)
         }
         # read data length
         my $dataLen;
         if ($flags{DataLen} or $flags{Compress}) {
-            length($val) >= 4 or $exifTool->Warn("Short $id frame"), next;
+            length($val) >= 4 or $et->Warn("Short $id frame"), next;
             $dataLen = unpack('N', $val);   # save the data length word
             $val = substr($val, 4);
         }
@@ -1104,22 +1104,22 @@ sub ProcessID3v2($$$)
                 if ($inflate and $stat == Compress::Zlib::Z_STREAM_END()) {
                     $val = $buff;
                 } else {
-                    $exifTool->Warn("Error inflating $id frame");
+                    $et->Warn("Error inflating $id frame");
                     next;
                 }
             } else {
-                $exifTool->WarnOnce('Install Compress::Zlib to decode compressed frames');
+                $et->WarnOnce('Install Compress::Zlib to decode compressed frames');
                 next;
             }
         }
         # validate data length
         if (defined $dataLen) {
             $dataLen = UnSyncSafe($dataLen);
-            defined $dataLen or $exifTool->Warn("Invalid length for $id frame"), next;
-            $dataLen == length($val) or $exifTool->Warn("Wrong length for $id frame"), next;
+            defined $dataLen or $et->Warn("Invalid length for $id frame"), next;
+            $dataLen == length($val) or $et->Warn("Wrong length for $id frame"), next;
         }
         unless ($tagInfo) {
-            $verbose and $exifTool->VerboseInfo($id, $tagInfo,
+            $verbose and $et->VerboseInfo($id, $tagInfo,
                 Table   => $tagTablePtr,
                 Value   => $val,
                 DataPt  => $dataPt,
@@ -1137,11 +1137,11 @@ sub ProcessID3v2($$$)
         my $valLen = length($val);  # actual value length (after decompression, etc)
         if ($id =~ /^(TXX|TXXX)$/) {
             # two encoded strings separated by a null
-            my @vals = DecodeString($exifTool, $val);
+            my @vals = DecodeString($et, $val);
             foreach (0..1) { $vals[$_] = '' unless defined $vals[$_]; }
             ($val = "($vals[0]) $vals[1]") =~ s/^\(\) //;
         } elsif ($id =~ /^T/ or $id =~ /^(IPL|IPLS)$/) {
-            $val = DecodeString($exifTool, $val);
+            $val = DecodeString($et, $val);
         } elsif ($id =~ /^(WXX|WXXX)$/) {
             # one encoded string and one Latin string separated by a null
             my $enc = unpack('C', $val);
@@ -1152,31 +1152,31 @@ sub ProcessID3v2($$$)
                 ($val, $url) = ($val =~ /^(..*?)\0(.*)/s);
             }
             unless (defined $val and defined $url) {
-                $exifTool->Warn("Invalid $id frame value");
+                $et->Warn("Invalid $id frame value");
                 next;
             }
-            $val = DecodeString($exifTool, $val);
+            $val = DecodeString($et, $val);
             $url =~ s/\0.*//s;
             $val = length($val) ? "($val) $url" : $url;
         } elsif ($id =~ /^W/) {
             $val =~ s/\0.*//s;  # truncate at null
         } elsif ($id =~ /^(COM|COMM|ULT|USLT)$/) {
-            $valLen > 4 or $exifTool->Warn("Short $id frame"), next;
+            $valLen > 4 or $et->Warn("Short $id frame"), next;
             $lang = substr($val,1,3);
-            my @vals = DecodeString($exifTool, substr($val,4), Get8u(\$val,0));
+            my @vals = DecodeString($et, substr($val,4), Get8u(\$val,0));
             foreach (0..1) { $vals[$_] = '' unless defined $vals[$_]; }
             $val = length($vals[0]) ? "($vals[0]) $vals[1]" : $vals[1];
         } elsif ($id eq 'USER') {
-            $valLen > 4 or $exifTool->Warn("Short $id frame"), next;
+            $valLen > 4 or $et->Warn("Short $id frame"), next;
             $lang = substr($val,1,3);
-            $val = DecodeString($exifTool, substr($val,4), Get8u(\$val,0));
+            $val = DecodeString($et, substr($val,4), Get8u(\$val,0));
         } elsif ($id =~ /^(CNT|PCNT)$/) {
-            $valLen >= 4 or $exifTool->Warn("Short $id frame"), next;
+            $valLen >= 4 or $et->Warn("Short $id frame"), next;
             my ($cnt, @xtra) = unpack('NC*', $val);
             $cnt = ($cnt << 8) + $_ foreach @xtra;
             $val = $cnt;
         } elsif ($id =~ /^(PIC|APIC)$/) {
-            $valLen >= 4 or $exifTool->Warn("Short $id frame"), next;
+            $valLen >= 4 or $et->Warn("Short $id frame"), next;
             my ($hdr, $attr);
             my $enc = unpack('C', $val);
             if ($enc == 1 or $enc == 2) {
@@ -1185,20 +1185,20 @@ sub ProcessID3v2($$$)
                 $hdr = ($id eq 'PIC') ? ".(...)(.)(.*?)\0"        : ".(.*?)\0(.)(.*?)\0";
             }
             # remove header (encoding, image format or MIME type, picture type, description)
-            $val =~ s/^$hdr//s or $exifTool->Warn("Invalid $id frame"), next;
-            my @attrs = ($1, ord($2), DecodeString($exifTool, $3, $enc));
+            $val =~ s/^$hdr//s or $et->Warn("Invalid $id frame"), next;
+            my @attrs = ($1, ord($2), DecodeString($et, $3, $enc));
             my $i = 1;
             foreach $attr (@attrs) {
                 # must store descriptions even if they are empty to maintain
                 # sync between copy numbers when multiple images
-                $exifTool->HandleTag($tagTablePtr, "$id-$i", $attr);
+                $et->HandleTag($tagTablePtr, "$id-$i", $attr);
                 ++$i;
             }
         } elsif ($id eq 'POP' or $id eq 'POPM') {
             # _email, 00, rating(1), counter(4-N)
             my ($email, $dat) = ($val =~ /^([^\0]*)\0(.*)$/s);
             unless (defined $dat and length($dat)) {
-                $exifTool->Warn("Invalid $id frame");
+                $et->Warn("Invalid $id frame");
                 next;
             }
             my ($rating, @xtra) = unpack('C*', $dat);
@@ -1207,13 +1207,13 @@ sub ProcessID3v2($$$)
             $val = "$email $rating $cnt";
         } elsif ($id eq 'OWNE') {
             # enc(1), _price, 00, _date(8), Seller
-            my @strs = DecodeString($exifTool, $val);
+            my @strs = DecodeString($et, $val);
             $strs[1] =~ s/^(\d{4})(\d{2})(\d{2})/$1:$2:$3 /s if $strs[1]; # format date
             $val = "@strs";
         } elsif ($id eq 'RVA' or $id eq 'RVAD') {
             my @dat = unpack('C*', $val);
             my $flag = shift @dat;
-            my $bits = shift @dat or $exifTool->Warn("Short $id frame"), next;
+            my $bits = shift @dat or $et->Warn("Short $id frame"), next;
             my $bytes = int(($bits + 7) / 8);
             my @parse = (['Right',0,2,0x01],['Left',1,3,0x02],['Back-right',4,6,0x04],
                          ['Back-left',5,7,0x08],['Center',8,9,0x10],['Bass',10,11,0x20]);
@@ -1259,20 +1259,20 @@ sub ProcessID3v2($$$)
             $val .= " ($id)" if $id;
         } elsif ($id eq 'PRIV') {
             # save version number to set group1 name for tag later
-            $exifTool->{ID3_Ver} = $tagTablePtr->{GROUPS}->{1};
-            $exifTool->HandleTag($tagTablePtr, $id, $val);
+            $$et{ID3_Ver} = $$tagTablePtr{GROUPS}{1};
+            $et->HandleTag($tagTablePtr, $id, $val);
             next;
         } elsif ($$tagInfo{Format} or $$tagInfo{SubDirectory}) {
-            $exifTool->HandleTag($tagTablePtr, $id, undef, DataPt => \$val);
+            $et->HandleTag($tagTablePtr, $id, undef, DataPt => \$val);
             next;
         } elsif (not $$tagInfo{Binary}) {
-            $exifTool->Warn("Don't know how to handle $id frame");
+            $et->Warn("Don't know how to handle $id frame");
             next;
         }
         if ($lang and $lang =~ /^[a-z]{3}$/i and $lang ne 'eng') {
             $tagInfo = Image::ExifTool::GetLangInfo($tagInfo, lc $lang);
         }
-        $exifTool->HandleTag($tagTablePtr, $id, $val,
+        $et->HandleTag($tagTablePtr, $id, $val,
             TagInfo => $tagInfo,
             DataPt  => $dataPt,
             DataPos => $$dirInfo{DataPos},
@@ -1290,10 +1290,10 @@ sub ProcessID3v2($$$)
 # - sets ExifTool DoneID3 to 1 when called, or to 2 if an ID3v1 trailer exists
 sub ProcessID3($$)
 {
-    my ($exifTool, $dirInfo) = @_;
+    my ($et, $dirInfo) = @_;
 
-    return 0 if $exifTool->{DoneID3};  # avoid infinite recursion
-    $exifTool->{DoneID3} = 1;
+    return 0 if $$et{DoneID3};  # avoid infinite recursion
+    $$et{DoneID3} = 1;
 
     # allow this to be called with either RAF or DataPt
     my $raf = $$dirInfo{RAF} || new File::RandomAccess($$dirInfo{DataPt});
@@ -1310,17 +1310,17 @@ sub ProcessID3($$)
 #
     while ($buff =~ /^ID3/) {
         $rtnVal = 1;
-        $raf->Read($hBuff, 7) == 7 or $exifTool->Warn('Short ID3 header'), last;
+        $raf->Read($hBuff, 7) == 7 or $et->Warn('Short ID3 header'), last;
         my ($vers, $flags, $size) = unpack('nCN', $hBuff);
         $size = UnSyncSafe($size);
-        defined $size or $exifTool->Warn('Invalid ID3 header'), last;
+        defined $size or $et->Warn('Invalid ID3 header'), last;
         my $verStr = sprintf("2.%d.%d", $vers >> 8, $vers & 0xff);
         if ($vers >= 0x0500) {
-            $exifTool->Warn("Unsupported ID3 version: $verStr");
+            $et->Warn("Unsupported ID3 version: $verStr");
             last;
         }
         unless ($raf->Read($hBuff, $size) == $size) {
-            $exifTool->Warn('Truncated ID3 data');
+            $et->Warn('Truncated ID3 data');
             last;
         }
         # this flag only indicates use of unsynchronized frames in ID3v2.4
@@ -1331,10 +1331,10 @@ sub ProcessID3($$)
         my $pos = 10;
         if ($flags & 0x40) {
             # skip the extended header
-            $size >= 4 or $exifTool->Warn('Bad ID3 extended header'), last;
+            $size >= 4 or $et->Warn('Bad ID3 extended header'), last;
             my $len = unpack('N', $hBuff);
             if ($len > length($hBuff) - 4) {
-                $exifTool->Warn('Truncated ID3 extended header');
+                $et->Warn('Truncated ID3 extended header');
                 last;
             }
             $hBuff = substr($hBuff, $len + 4);
@@ -1367,7 +1367,7 @@ sub ProcessID3($$)
 # read ID3v1 trailer if it exists
 #
     if ($raf->Seek(-128, 2) and $raf->Read($tBuff, 128) == 128 and $tBuff =~ /^TAG/) {
-        $exifTool->{DoneID3} = 2;  # set to 2 as flag that trailer exists
+        $$et{DoneID3} = 2;  # set to 2 as flag that trailer exists
         %id3Trailer = (
             DataPt   => \$tBuff,
             DataPos  => $raf->Tell() - 128,
@@ -1387,7 +1387,7 @@ sub ProcessID3($$)
     if ($rtnVal) {
         # first process audio data if it exists
         if ($$dirInfo{RAF}) {
-            my $oldType = $exifTool->{FILE_TYPE};   # save file type
+            my $oldType = $$et{FILE_TYPE};   # save file type
             # check current file type first
             my @types = grep /^$oldType$/, @audioFormats;
             push @types, grep(!/^$oldType$/, @audioFormats);
@@ -1396,40 +1396,40 @@ sub ProcessID3($$)
                 # seek to end of ID3 header
                 $raf->Seek($hdrEnd, 0);
                 # set type for this file if we are successful
-                $exifTool->{FILE_TYPE} = $type;
+                $$et{FILE_TYPE} = $type;
                 my $module = $audioModule{$type} || $type;
                 require "Image/ExifTool/$module.pm" or next;
                 my $func = "Image::ExifTool::${module}::Process$type";
                 # process the file
                 no strict 'refs';
-                &$func($exifTool, $dirInfo) and last;
+                &$func($et, $dirInfo) and last;
                 use strict 'refs';
             }
-            $exifTool->{FILE_TYPE} = $oldType;      # restore original file type
+            $$et{FILE_TYPE} = $oldType;      # restore original file type
         }
         # set file type to MP3 if we didn't find audio data
-        $exifTool->SetFileType('MP3');
+        $et->SetFileType('MP3');
         # record the size of the ID3 metadata
-        $exifTool->FoundTag('ID3Size', $id3Len);
+        $et->FoundTag('ID3Size', $id3Len);
         # process ID3v2 header if it exists
         if (%id3Header) {
-            $exifTool->VPrint(0, "$id3Header{DirName}:\n");
-            $exifTool->ProcessDirectory(\%id3Header, $tagTablePtr);
+            $et->VPrint(0, "$id3Header{DirName}:\n");
+            $et->ProcessDirectory(\%id3Header, $tagTablePtr);
         }
         # process ID3v1 trailer if it exists
         if (%id3Trailer) {
-            $exifTool->VPrint(0, "ID3v1:\n");
+            $et->VPrint(0, "ID3v1:\n");
             SetByteOrder('MM');
             $tagTablePtr = GetTagTable('Image::ExifTool::ID3::v1');
-            $exifTool->ProcessDirectory(\%id3Trailer, $tagTablePtr);
+            $et->ProcessDirectory(\%id3Trailer, $tagTablePtr);
             # process "Enhanced TAG" information if available
             if ($id3Trailer{EnhancedTAG}) {
-                $exifTool->VPrint(0, "ID3v1 Enhanced TAG:\n");
+                $et->VPrint(0, "ID3v1 Enhanced TAG:\n");
                 $tagTablePtr = GetTagTable('Image::ExifTool::ID3::v1_Enh');
                 $id3Trailer{DataPt} = $id3Trailer{EnhancedTAG};
                 $id3Trailer{DataPos} -= 227; # (227 = length of Enhanced TAG block)
                 $id3Trailer{DirLen} = 227;
-                $exifTool->ProcessDirectory(\%id3Trailer, $tagTablePtr);
+                $et->ProcessDirectory(\%id3Trailer, $tagTablePtr);
             }
         }
     }
@@ -1444,13 +1444,13 @@ sub ProcessID3($$)
 # Returns: 1 on success, 0 if this wasn't a valid MP3 file
 sub ProcessMP3($$)
 {
-    my ($exifTool, $dirInfo) = @_;
+    my ($et, $dirInfo) = @_;
     my $rtnVal = 0;
 
     # must first check for leading/trailing ID3 information
     # (and process the rest of the file if found)
-    unless ($exifTool->{DoneID3}) {
-        $rtnVal = ProcessID3($exifTool, $dirInfo);
+    unless ($$et{DoneID3}) {
+        $rtnVal = ProcessID3($et, $dirInfo);
     }
 
     # check for MPEG A/V data if not already processed above
@@ -1462,26 +1462,26 @@ sub ProcessMP3($$)
 # (if found in the first $scanLen bytes)
 #
         # scan further into a file that should be an MP3
-        my $scanLen = ($$exifTool{FILE_EXT} and $$exifTool{FILE_EXT} eq 'MP3') ? 8192 : 256;
+        my $scanLen = ($$et{FILE_EXT} and $$et{FILE_EXT} eq 'MP3') ? 8192 : 256;
         if ($raf->Read($buff, $scanLen)) {
             require Image::ExifTool::MPEG;
             if ($buff =~ /\0\0\x01(\xb3|\xc0)/) {
                 # look for A/V headers in first 64kB
                 my $buf2;
                 $raf->Read($buf2, 0x10000 - $scanLen) and $buff .= $buf2;
-                $rtnVal = 1 if Image::ExifTool::MPEG::ParseMPEGAudioVideo($exifTool, \$buff);
+                $rtnVal = 1 if Image::ExifTool::MPEG::ParseMPEGAudioVideo($et, \$buff);
             } else {
                 # look for audio frame sync in first $scanLen bytes
                 # (set MP3 flag to 1 so this will fail unless layer 3 audio)
-                $rtnVal = 1 if Image::ExifTool::MPEG::ParseMPEGAudio($exifTool, \$buff, 1);
+                $rtnVal = 1 if Image::ExifTool::MPEG::ParseMPEGAudio($et, \$buff, 1);
             }
         }
     }
 
     # check for an APE trailer if this was a valid A/V file and we haven't already done it
-    if ($rtnVal and not $exifTool->{DoneAPE}) {
+    if ($rtnVal and not $$et{DoneAPE}) {
         require Image::ExifTool::APE;
-        Image::ExifTool::APE::ProcessAPE($exifTool, $dirInfo);
+        Image::ExifTool::APE::ProcessAPE($et, $dirInfo);
     }
     return $rtnVal;
 }