exiftool_vendored 9.37.0 → 9.41.0

data/bin/{Image-ExifTool-9.37 → Image-ExifTool-9.41}/lib/Image/ExifTool/XMP2.pl

@@ -1154,6 +1154,7 @@ my %sSubVersion = (
     },
     FaceID          => { Writable => 'integer' },
     AngleInfoRoll   => { Writable => 'integer' },
+    AngleInfoYaw    => { Writable => 'integer' },
     ConfidenceLevel => { Writable => 'integer' },
 );
 

data/bin/{Image-ExifTool-9.37 → Image-ExifTool-9.41}/lib/Image/ExifTool/XMPStruct.pl

@@ -176,7 +176,7 @@ sub DumpStruct($;$)
 # - un-escapes for XML or HTML as per Escape option setting
 sub CheckStruct($$$)
 {
-    my ($exifTool, $struct, $strTable) = @_;
+    my ($et, $struct, $strTable) = @_;
 
     my $strName = $$strTable{STRUCT_NAME} || ('XMP ' . RegisterNamespace($strTable));
     ref $struct eq 'HASH' or return wantarray ? (undef, "Expecting $strName structure") : undef;
@@ -211,7 +211,7 @@ Key:
                 my ($tagInfo, $priority, $ti, $g1);
                 # find best matching tag
                 foreach $ti (@matches) {
-                    my @grps = $exifTool->GetGroup($ti);
+                    my @grps = $et->GetGroup($ti);
                     next unless $grps[0] eq 'XMP';
                     next if $grp and $grp ne lc $grps[1];
                     # must be lang-alt tag if we are writing an alternate language
@@ -270,7 +270,7 @@ Key:
         if (ref $$struct{$key} eq 'HASH') {
             $$fieldInfo{Struct} or $warn = "$tag is not a structure in $strName", next Key;
             # recursively check this structure
-            ($val, $err) = CheckStruct($exifTool, $$struct{$key}, $$fieldInfo{Struct});
+            ($val, $err) = CheckStruct($et, $$struct{$key}, $$fieldInfo{Struct});
             $err and $warn = $err, next Key;
             $copy{$tag} = $val;
         } elsif (ref $$struct{$key} eq 'ARRAY') {
@@ -282,14 +282,14 @@ Key:
                 if (not ref $item) {
                     $item = '' unless defined $item; # use empty string for missing items
                     $$fieldInfo{Struct} and $warn = "$tag items are not valid structures", next Key;
-                    $exifTool->Sanitize(\$item);
-                    ($copy[$i],$err) = $exifTool->ConvInv($item,$fieldInfo,$tag,$strName,$type);
+                    $et->Sanitize(\$item);
+                    ($copy[$i],$err) = $et->ConvInv($item,$fieldInfo,$tag,$strName,$type);
                     $err and $warn = $err, next Key;
-                    $err = CheckXMP($exifTool, $fieldInfo, \$copy[$i]);
+                    $err = CheckXMP($et, $fieldInfo, \$copy[$i]);
                     $err and $warn = "$err in $strName $tag", next Key;
                 } elsif (ref $item eq 'HASH') {
                     $$fieldInfo{Struct} or $warn = "$tag is not a structure in $strName", next Key;
-                    ($copy[$i], $err) = CheckStruct($exifTool, $item, $$fieldInfo{Struct});
+                    ($copy[$i], $err) = CheckStruct($et, $item, $$fieldInfo{Struct});
                     $err and $warn = $err, next Key;
                 } else {
                     $warn = "Invalid value for $tag in $strName";
@@ -301,10 +301,10 @@ Key:
         } elsif ($$fieldInfo{Struct}) {
             $warn = "Improperly formed structure in $strName $tag";
         } else {
-            $exifTool->Sanitize(\$$struct{$key});
-            ($val,$err) = $exifTool->ConvInv($$struct{$key},$fieldInfo,$tag,$strName,$type);
+            $et->Sanitize(\$$struct{$key});
+            ($val,$err) = $et->ConvInv($$struct{$key},$fieldInfo,$tag,$strName,$type);
             $err and $warn = $err, next Key;
-            $err = CheckXMP($exifTool, $fieldInfo, \$val);
+            $err = CheckXMP($et, $fieldInfo, \$val);
             $err and $warn = "$err in $strName $tag", next Key;
             # turn this into a list if necessary
             $copy{$tag} = $$fieldInfo{List} ? [ $val ] : $val;
@@ -313,7 +313,7 @@ Key:
     if (%copy) {
         $rtnVal = \%copy;
         undef $err;
-        $$exifTool{CHECK_WARN} = $warn if $warn;
+        $$et{CHECK_WARN} = $warn if $warn;
     } else {
         $err = $warn || 'Structure has no fields';
     }
@@ -329,7 +329,7 @@ Key:
 # Notes: updates path to new base path for structure to be added
 sub DeleteStruct($$$$$)
 {
-    my ($exifTool, $capture, $pathPt, $nvHash, $changed) = @_;
+    my ($et, $capture, $pathPt, $nvHash, $changed) = @_;
     my ($deleted, $added, $existed, $p, $pp, $val, $delPath);
     my (@structPaths, @matchingPaths, @delPaths);
 
@@ -387,10 +387,10 @@ sub DeleteStruct($$$$$)
         $delPath = $1;
     }
     if (@delPaths) {
-        my $verbose = $exifTool->Options('Verbose');
+        my $verbose = $et->Options('Verbose');
         @delPaths = sort @delPaths if $verbose > 1;
         foreach $p (@delPaths) {
-            $exifTool->VerboseValue("- XMP-$p", $$capture{$p}[0]) if $verbose > 1;
+            $et->VerboseValue("- XMP-$p", $$capture{$p}[0]) if $verbose > 1;
             delete $$capture{$p};
             $deleted = 1;
             ++$$changed;
@@ -406,7 +406,7 @@ sub DeleteStruct($$$$$)
             if ($$capture{$path}) {
                 my $cap = $$capture{$path};
                 # an error unless this was an empty structure
-                $exifTool->Error("Improperly structured XMP ($path)",1) if ref $cap ne 'ARRAY' or $$cap[0];
+                $et->Error("Improperly structured XMP ($path)",1) if ref $cap ne 'ARRAY' or $$cap[0];
                 delete $$capture{$path};
             }
             # (match last index to put in same lang-alt list for Bag of lang-alt items)
@@ -431,7 +431,7 @@ sub DeleteStruct($$$$$)
 #         3) resource path, 4) value ref, 5) hash ref for last used index numbers
 sub AddNewTag($$$$$$)
 {
-    my ($exifTool, $tagInfo, $capture, $path, $valPtr, $langIdx) = @_;
+    my ($et, $tagInfo, $capture, $path, $valPtr, $langIdx) = @_;
     my $val = EscapeXML($$valPtr);
     my %attrs;
     # support writing RDF "resource" values
@@ -453,8 +453,8 @@ sub AddNewTag($$$$$$)
     }
     $$capture{$path} = [ $val, \%attrs ];
     # print verbose message
-    if ($exifTool and $exifTool->Options('Verbose') > 1) {
-        $exifTool->VerboseValue("+ XMP-$path", $val);
+    if ($et and $et->Options('Verbose') > 1) {
+        $et->VerboseValue("+ XMP-$path", $val);
     }
 }
 
@@ -467,8 +467,8 @@ sub AddNewTag($$$$$$)
 # Notes: Escapes values for XML
 sub AddNewStruct($$$$$$)
 {
-    my ($exifTool, $tagInfo, $capture, $basePath, $struct, $strTable) = @_;
-    my $verbose = $exifTool ? $exifTool->Options('Verbose') : 0;
+    my ($et, $tagInfo, $capture, $basePath, $struct, $strTable) = @_;
+    my $verbose = $et ? $et->Options('Verbose') : 0;
     my ($tag, %langIdx);
 
     my $ns = $$strTable{NAMESPACE} || '';
@@ -488,11 +488,11 @@ sub AddNewStruct($$$$$$)
             }
             $$fieldInfo{PropertyPath} = $propPath;  # save for next time
         }
-        my $path = $basePath . '/' . ConformPathToNamespace($exifTool, $propPath);
+        my $path = $basePath . '/' . ConformPathToNamespace($et, $propPath);
         my $addedTag;
         if (ref $val eq 'HASH') {
             my $subStruct = $$fieldInfo{Struct} or next;
-            $changed += AddNewStruct($exifTool, $tagInfo, $capture, $path, $val, $subStruct);
+            $changed += AddNewStruct($et, $tagInfo, $capture, $path, $val, $subStruct);
         } elsif (ref $val eq 'ARRAY') {
             next unless $$fieldInfo{List};
             my $i = 0;
@@ -501,7 +501,7 @@ sub AddNewStruct($$$$$$)
             foreach $item (@{$val}) {
                 if ($i) {
                     # update first index in field property (may be list of lang-alt lists)
-                    $p = ConformPathToNamespace($exifTool, $propPath);
+                    $p = ConformPathToNamespace($et, $propPath);
                     my $idx = length($i) . $i;
                     $p =~ s/ \d+/ $idx/;
                     $p = "$basePath/$p";
@@ -510,16 +510,16 @@ sub AddNewStruct($$$$$$)
                 }
                 if (ref $item eq 'HASH') {
                     my $subStruct = $$fieldInfo{Struct} or next;
-                    AddNewStruct($exifTool, $tagInfo, $capture, $p, $item, $subStruct) or next;
+                    AddNewStruct($et, $tagInfo, $capture, $p, $item, $subStruct) or next;
                 } elsif (length $item) { # don't write empty items in list
-                    AddNewTag($exifTool, $fieldInfo, $capture, $p, \$item, \%langIdx);
+                    AddNewTag($et, $fieldInfo, $capture, $p, \$item, \%langIdx);
                     $addedTag = 1;
                 }
                 ++$changed;
                 ++$i;
             }
         } else {
-            AddNewTag($exifTool, $fieldInfo, $capture, $path, \$val, \%langIdx);
+            AddNewTag($et, $fieldInfo, $capture, $path, \$val, \%langIdx);
             $addedTag = 1;
             ++$changed;
         }
@@ -527,15 +527,15 @@ sub AddNewStruct($$$$$$)
         # in the case that a whole hierarchy was added at once by writing a
         # flattened tag inside a variable-namespace structure
         if ($addedTag and $$fieldInfo{StructType} and $$fieldInfo{Table}) {
-            AddStructType($exifTool, $$fieldInfo{Table}, $capture, $propPath, $basePath);
+            AddStructType($et, $$fieldInfo{Table}, $capture, $propPath, $basePath);
         }
     }
     # add 'rdf:type' property if necessary
     if ($$strTable{TYPE} and $changed) {
-        my $path = $basePath . '/' . ConformPathToNamespace($exifTool, "rdf:type");
+        my $path = $basePath . '/' . ConformPathToNamespace($et, "rdf:type");
         unless ($$capture{$path}) {
             $$capture{$path} = [ '', { 'rdf:resource' => $$strTable{TYPE} } ];
-            $exifTool->VerboseValue("+ XMP-$path", $$strTable{TYPE}) if $verbose > 1;
+            $et->VerboseValue("+ XMP-$path", $$strTable{TYPE}) if $verbose > 1;
         }
     }
     return $changed;
@@ -549,7 +549,7 @@ sub AddNewStruct($$$$$$)
 # Notes: Makes a copy of the hash so any applied escapes won't affect raw values
 sub ConvertStruct($$$$;$)
 {
-    my ($exifTool, $tagInfo, $value, $type, $parentID) = @_;
+    my ($et, $tagInfo, $value, $type, $parentID) = @_;
     if (ref $value eq 'HASH') {
         my (%struct, $key);
         my $table = $$tagInfo{Table};
@@ -567,9 +567,9 @@ sub ConvertStruct($$$$;$)
             }
             my $v = $$value{$key};
             if (ref $v) {
-                $v = ConvertStruct($exifTool, $flatInfo, $v, $type, $tagID);
+                $v = ConvertStruct($et, $flatInfo, $v, $type, $tagID);
             } else {
-                $v = $exifTool->GetValue($flatInfo, $type, $v);
+                $v = $et->GetValue($flatInfo, $type, $v);
             }
             $struct{$key} = $v if defined $v;  # save the converted value
         }
@@ -577,12 +577,12 @@ sub ConvertStruct($$$$;$)
     } elsif (ref $value eq 'ARRAY') {
         my (@list, $val);
         foreach $val (@$value) {    
-            my $v = ConvertStruct($exifTool, $tagInfo, $val, $type, $parentID);
+            my $v = ConvertStruct($et, $tagInfo, $val, $type, $parentID);
             push @list, $v if defined $v;
         }
         return \@list;
     } else {
-        return $exifTool->GetValue($tagInfo, $type, $value);
+        return $et->GetValue($tagInfo, $type, $value);
     }
 }
 
@@ -593,16 +593,16 @@ sub ConvertStruct($$$$;$)
 sub RestoreStruct($;$)
 {
     local $_;
-    my ($exifTool, $keepFlat) = @_;
+    my ($et, $keepFlat) = @_;
     my ($key, %structs, %var, %lists, $si, %listKeys);
-    my $ex = $$exifTool{TAG_EXTRA};
-    my $valueHash = $$exifTool{VALUE};
-    my $tagExtra = $$exifTool{TAG_EXTRA};
-    foreach $key (keys %{$$exifTool{TAG_INFO}}) {
+    my $ex = $$et{TAG_EXTRA};
+    my $valueHash = $$et{VALUE};
+    my $tagExtra = $$et{TAG_EXTRA};
+    foreach $key (keys %{$$et{TAG_INFO}}) {
         $$ex{$key} or next;
-        my ($err, $i);
         my $structProps = $$ex{$key}{Struct} or next;
-        my $tagInfo = $$exifTool{TAG_INFO}{$key};   # tagInfo for flattened tag
+        delete $$ex{$key}{Struct}; # (don't re-use)
+        my $tagInfo = $$et{TAG_INFO}{$key};   # tagInfo for flattened tag
         my $table = $$tagInfo{Table};
         my $prop = shift @$structProps;
         my $tag = $$prop[0];
@@ -614,7 +614,7 @@ sub RestoreStruct($;$)
                 # this could happen for invalid XMP containing mixed lists
                 # (or for something like this -- what should we do here?:
                 # <meta:user-defined meta:name="License">test</meta:user-defined>)
-                $exifTool->Warn("$$strInfo{Name} is not a structure!");
+                $et->Warn("$$strInfo{Name} is not a structure!");
                 next;
             }
         } else {
@@ -651,6 +651,7 @@ sub RestoreStruct($;$)
         my $writable = $$tagInfo{Writable} || '';
         # walk through the stored structure property information
         # to rebuild this structure
+        my ($err, $i);
         for (;;) {
             my $index = $$prop[1];
             if ($index and not @$structProps) {
@@ -724,7 +725,7 @@ sub RestoreStruct($;$)
         if ($err) {
             # this may happen if we have a structural error in the XMP
             # (like an improperly contained list for example)
-            $exifTool->Warn("Error $err placing $$tagInfo{Name} in structure or list", 1);
+            $et->Warn("Error $err placing $$tagInfo{Name} in structure or list", 1);
             delete $structs{$strInfo} unless $oldStruct;
         } elsif ($tagInfo eq $strInfo) {
             # just a regular list tag
@@ -733,8 +734,8 @@ sub RestoreStruct($;$)
                 # "Tag (10)" is lt "Tag (2)", but at least "Tag" is lt
                 # everything else, and this is really what we care about)
                 my $k = $listKeys{$oldStruct};
-                $k lt $key and $exifTool->DeleteTag($key), next;
-                $exifTool->DeleteTag($k);   # remove tag with greater copy number
+                $k lt $key and $et->DeleteTag($key), next;
+                $et->DeleteTag($k);   # remove tag with greater copy number
             }
             # replace existing value with new list
             $$valueHash{$key} = $structs{$strInfo};
@@ -743,11 +744,11 @@ sub RestoreStruct($;$)
             # save strInfo ref and file order
             if ($var{$strInfo}) {
                 # set file order to just before the first associated flattened tag
-                if ($var{$strInfo}[1] > $$exifTool{FILE_ORDER}{$key}) {
-                    $var{$strInfo}[1] = $$exifTool{FILE_ORDER}{$key} - 0.5;
+                if ($var{$strInfo}[1] > $$et{FILE_ORDER}{$key}) {
+                    $var{$strInfo}[1] = $$et{FILE_ORDER}{$key} - 0.5;
                 }
             } else {
-                $var{$strInfo} = [ $strInfo, $$exifTool{FILE_ORDER}{$key} - 0.5 ];
+                $var{$strInfo} = [ $strInfo, $$et{FILE_ORDER}{$key} - 0.5 ];
             }
             # preserve original flattened tags if requested
             if ($keepFlat) {
@@ -758,10 +759,10 @@ sub RestoreStruct($;$)
                     delete $$extra{NoList};
                 } elsif ($$extra{NoListDel}) {
                     # delete this tag since its value was included another list
-                    $exifTool->DeleteTag($key);
+                    $et->DeleteTag($key);
                 }
             } else {
-                $exifTool->DeleteTag($key); # delete the flattened tag
+                $et->DeleteTag($key); # delete the flattened tag
             }
         }
     }
@@ -774,9 +775,9 @@ sub RestoreStruct($;$)
     # save new structure tags
     foreach $si (keys %structs) {
         next unless $var{$si};  # already handled regular lists
-        $key = $exifTool->FoundTag($var{$si}[0], '');
+        $key = $et->FoundTag($var{$si}[0], '');
         $$valueHash{$key} = $structs{$si};
-        $$exifTool{FILE_ORDER}{$key} = $var{$si}[1];
+        $$et{FILE_ORDER}{$key} = $var{$si}[1];
     }
 }
 

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

@@ -19,7 +19,7 @@ use strict;
 use vars qw($VERSION $warnString);
 use Image::ExifTool qw(:DataAccess :Utils);
 
-$VERSION = '1.11';
+$VERSION = '1.12';
 
 sub WarnProc($) { $warnString = $_[0]; }
 
@@ -243,13 +243,13 @@ my %openDocType = (
 # Returns: 1 on success, 0 if this wasn't a valid RAR file
 sub ProcessRAR($$)
 {
-    my ($exifTool, $dirInfo) = @_;
+    my ($et, $dirInfo) = @_;
     my $raf = $$dirInfo{RAF};
     my ($flags, $buff);
 
     return 0 unless $raf->Read($buff, 7) and $buff eq "Rar!\x1a\x07\0";
 
-    $exifTool->SetFileType();
+    $et->SetFileType();
     SetByteOrder('II');
     my $tagTablePtr = GetTagTable('Image::ExifTool::ZIP::RAR');
     my $docNum = 0;
@@ -266,8 +266,8 @@ sub ProcessRAR($$)
         last if $size < 0;
         next unless $size;  # ignore blocks with no data
         # don't try to read very large blocks unless LargeFileSupport is enabled
-        if ($size > 0x80000000 and not $exifTool->Options('LargeFileSupport')) {
-            $exifTool->Warn('Large block encountered. Aborting.');
+        if ($size > 0x80000000 and not $et->Options('LargeFileSupport')) {
+            $et->Warn('Large block encountered. Aborting.');
             last;
         }
         # process the block
@@ -277,21 +277,21 @@ sub ProcessRAR($$)
             $raf->Read($buff, $n) == $n or last;
             # add compressed size to start of data so we can extract it with the other tags
             $buff = pack('V',$size) . $buff;
-            $$exifTool{DOC_NUM} = ++$docNum;
-            $exifTool->ProcessDirectory({ DataPt => \$buff }, $tagTablePtr);
+            $$et{DOC_NUM} = ++$docNum;
+            $et->ProcessDirectory({ DataPt => \$buff }, $tagTablePtr);
             $size -= $n;
         } elsif ($type == 0x75 and $size > 6) { # comment block
             $raf->Read($buff, $size) == $size or last;
             # save comment, only if "Stored" (this is untested)
             if (Get8u(\$buff, 3) == 0x30) {
-                $exifTool->FoundTag('Comment', substr($buff, 6));
+                $et->FoundTag('Comment', substr($buff, 6));
             }
             next;
         }
         # seek to the start of the next block
         $raf->Seek($size, 1) or last if $size;
     }
-    $$exifTool{DOC_NUM} = 0;
+    $$et{DOC_NUM} = 0;
 
     return 1;
 }
@@ -302,21 +302,21 @@ sub ProcessRAR($$)
 # Returns: 1 on success, 0 if this wasn't a valid GZIP file
 sub ProcessGZIP($$)
 {
-    my ($exifTool, $dirInfo) = @_;
+    my ($et, $dirInfo) = @_;
     my $raf = $$dirInfo{RAF};
     my ($flags, $buff);
 
     return 0 unless $raf->Read($buff, 10) and $buff =~ /^\x1f\x8b\x08/;
 
-    $exifTool->SetFileType();
+    $et->SetFileType();
     SetByteOrder('II');
 
     my $tagTablePtr = GetTagTable('Image::ExifTool::ZIP::GZIP');
-    $exifTool->HandleTag($tagTablePtr, 2, Get8u(\$buff, 2));
-    $exifTool->HandleTag($tagTablePtr, 3, $flags = Get8u(\$buff, 3));
-    $exifTool->HandleTag($tagTablePtr, 4, Get32u(\$buff, 4));
-    $exifTool->HandleTag($tagTablePtr, 8, Get8u(\$buff, 8));
-    $exifTool->HandleTag($tagTablePtr, 9, Get8u(\$buff, 9));
+    $et->HandleTag($tagTablePtr, 2, Get8u(\$buff, 2));
+    $et->HandleTag($tagTablePtr, 3, $flags = Get8u(\$buff, 3));
+    $et->HandleTag($tagTablePtr, 4, Get32u(\$buff, 4));
+    $et->HandleTag($tagTablePtr, 8, Get8u(\$buff, 8));
+    $et->HandleTag($tagTablePtr, 9, Get8u(\$buff, 9));
 
     # extract file name and comment if they exist
     if ($flags & 0x18) {
@@ -338,7 +338,7 @@ sub ProcessGZIP($$)
             # but in OS X it seems to be UTF-8, so don't translate
             # it because I could just as easily screw it up)
             my $str = substr($buff, $pos, $end - $pos);
-            $exifTool->HandleTag($tagTablePtr, $tagID, $str);
+            $et->HandleTag($tagTablePtr, $tagID, $str);
             last if $end >= length $buff;
             $pos = $end + 1;
         }
@@ -351,16 +351,16 @@ sub ProcessGZIP($$)
 # Inputs: 0) ExifTool object ref, 1) member ref, 2) optional tag table ref
 sub HandleMember($$;$)
 {
-    my ($exifTool, $member, $tagTablePtr) = @_;
+    my ($et, $member, $tagTablePtr) = @_;
     $tagTablePtr or  $tagTablePtr = GetTagTable('Image::ExifTool::ZIP::Main');
-    $exifTool->HandleTag($tagTablePtr, 2, $member->versionNeededToExtract());
-    $exifTool->HandleTag($tagTablePtr, 3, $member->bitFlag());
-    $exifTool->HandleTag($tagTablePtr, 4, $member->compressionMethod());
-    $exifTool->HandleTag($tagTablePtr, 5, $member->lastModFileDateTime());
-    $exifTool->HandleTag($tagTablePtr, 7, $member->crc32());
-    $exifTool->HandleTag($tagTablePtr, 9, $member->compressedSize());
-    $exifTool->HandleTag($tagTablePtr, 11, $member->uncompressedSize());
-    $exifTool->HandleTag($tagTablePtr, 15, $member->fileName());
+    $et->HandleTag($tagTablePtr, 2, $member->versionNeededToExtract());
+    $et->HandleTag($tagTablePtr, 3, $member->bitFlag());
+    $et->HandleTag($tagTablePtr, 4, $member->compressionMethod());
+    $et->HandleTag($tagTablePtr, 5, $member->lastModFileDateTime());
+    $et->HandleTag($tagTablePtr, 7, $member->crc32());
+    $et->HandleTag($tagTablePtr, 9, $member->compressedSize());
+    $et->HandleTag($tagTablePtr, 11, $member->uncompressedSize());
+    $et->HandleTag($tagTablePtr, 15, $member->fileName());
 }
 
 #------------------------------------------------------------------------------
@@ -369,7 +369,7 @@ sub HandleMember($$;$)
 # Returns: 1 on success, 0 if this wasn't a valid ZIP file
 sub ProcessZIP($$)
 {
-    my ($exifTool, $dirInfo) = @_;
+    my ($et, $dirInfo) = @_;
     my $raf = $$dirInfo{RAF};
     my ($buff, $buf2, $zip, $docNum);
 
@@ -380,8 +380,8 @@ sub ProcessZIP($$)
     # use Archive::Zip if avilable
     for (;;) {
         unless (eval 'require Archive::Zip' and eval 'require IO::File') {
-            if ($$exifTool{FILE_EXT} and $$exifTool{FILE_EXT} ne 'ZIP') {
-                $exifTool->Warn("Install Archive::Zip to decode compressed ZIP information");
+            if ($$et{FILE_EXT} and $$et{FILE_EXT} ne 'ZIP') {
+                $et->Warn("Install Archive::Zip to decode compressed ZIP information");
             }
             last;
         }
@@ -390,7 +390,7 @@ sub ProcessZIP($$)
         if ($raf->{TESTED} >= 0) {
             unless (eval 'require IO::File') {
                 # (this shouldn't happen because IO::File is a prerequisite of Archive::Zip)
-                $exifTool->Warn("Install IO::File to decode compressed ZIP information");
+                $et->Warn("Install IO::File to decode compressed ZIP information");
                 last;
             }
             $raf->Seek(0,0);
@@ -402,10 +402,10 @@ sub ProcessZIP($$)
             $fh = new IO::String ${$raf->{BUFF_PT}};
         } else {
             my $type = $raf->{FILE_PT} ? 'pipe or socket' : 'scalar reference';
-            $exifTool->Warn("Install IO::String to decode compressed ZIP information from a $type");
+            $et->Warn("Install IO::String to decode compressed ZIP information from a $type");
             last;
         }
-        $exifTool->VPrint(1, "  --- using Archive::Zip ---\n");
+        $et->VPrint(1, "  --- using Archive::Zip ---\n");
         $zip = new Archive::Zip;
         # catch all warnings! (Archive::Zip is bad for this)
         local $SIG{'__WARN__'} = \&WarnProc;
@@ -425,7 +425,7 @@ sub ProcessZIP($$)
             undef $zip;
             my %err = ( 1=>'Stream end error', 3=>'Format error', 4=>'IO error' );
             my $err = $err{$status} || "Error $status";
-            $exifTool->Warn("$err reading ZIP file");
+            $et->Warn("$err reading ZIP file");
             last;
         }
         $$dirInfo{ZIP} = $zip;
@@ -445,7 +445,7 @@ sub ProcessZIP($$)
         if ($mime or @members) {
             $$dirInfo{MIME} = $mime;
             require Image::ExifTool::OOXML;
-            Image::ExifTool::OOXML::ProcessDOCX($exifTool, $dirInfo);
+            Image::ExifTool::OOXML::ProcessDOCX($et, $dirInfo);
             delete $$dirInfo{MIME};
             last;
         }
@@ -454,7 +454,7 @@ sub ProcessZIP($$)
         @members = $zip->membersMatching('^CaptureOne/.*\.(cos|COS)$');
         if (@members) {
             require Image::ExifTool::CaptureOne;
-            Image::ExifTool::CaptureOne::ProcessEIP($exifTool, $dirInfo);
+            Image::ExifTool::CaptureOne::ProcessEIP($et, $dirInfo);
             last;
         }
 
@@ -462,7 +462,7 @@ sub ProcessZIP($$)
         @members = $zip->membersMatching('^(index\.(xml|apxl)|QuickLook/Thumbnail\.jpg)$');
         if (@members) {
             require Image::ExifTool::iWork;
-            Image::ExifTool::iWork::Process_iWork($exifTool, $dirInfo);
+            Image::ExifTool::iWork::Process_iWork($et, $dirInfo);
             last;
         }
 
@@ -473,8 +473,8 @@ sub ProcessZIP($$)
             if (not $status and $mime =~ /([\x21-\xfe]+)/s) {
                 # clean up MIME type just in case (note that MIME is case insensitive)
                 $mime = lc $1;
-                $exifTool->SetFileType($openDocType{$mime} || 'ZIP', $mime);
-                $exifTool->Warn('Unrecognized MIMEType') unless $openDocType{$mime};
+                $et->SetFileType($openDocType{$mime} || 'ZIP', $mime);
+                $et->Warn('Unrecognized MIMEType') unless $openDocType{$mime};
                 # extract Open Document metadata from "meta.xml"
                 my $meta = $zip->memberNamed('meta.xml');
                 # IDML files have metadata in a different place (ref 6)
@@ -488,7 +488,7 @@ sub ProcessZIP($$)
                             DataLen => length $buff,
                         );
                         my $xmpTable = GetTagTable('Image::ExifTool::XMP::Main');
-                        $exifTool->ProcessDirectory(\%dirInfo, $xmpTable);
+                        $et->ProcessDirectory(\%dirInfo, $xmpTable);
                     }
                 }
                 if ($openDocType{$mime} or $meta) {
@@ -499,7 +499,7 @@ sub ProcessZIP($$)
                         my $thumb = $zip->memberNamed("Thumbnails/thumbnail.$type");
                         next unless $thumb;
                         ($buff, $status) = $zip->contents($thumb);
-                        $exifTool->FoundTag($tag{$type}, $buff) unless $status;
+                        $et->FoundTag($tag{$type}, $buff) unless $status;
                     }
                     last;   # all done since we recognized the MIME type or found metadata
                 }
@@ -508,29 +508,29 @@ sub ProcessZIP($$)
         }
 
         # otherwise just extract general ZIP information
-        $exifTool->SetFileType();
+        $et->SetFileType();
         @members = $zip->members();
         $docNum = 0;
         my $member;
         foreach $member (@members) {
-            $$exifTool{DOC_NUM} = ++$docNum;
-            HandleMember($exifTool, $member, $tagTablePtr);
+            $$et{DOC_NUM} = ++$docNum;
+            HandleMember($et, $member, $tagTablePtr);
         }
         last;
     }
     # all done if we processed this using Archive::Zip
     if ($zip) {
         delete $$dirInfo{ZIP};
-        delete $$exifTool{DOC_NUM};
+        delete $$et{DOC_NUM};
         return 1;
     }
 #
 # process the ZIP file by hand (funny, but this seems easier than using Archive::Zip)
 #
     $docNum = 0;
-    $exifTool->VPrint(1, "  -- processing as binary data --\n");
+    $et->VPrint(1, "  -- processing as binary data --\n");
     $raf->Seek(30, 0);
-    $exifTool->SetFileType();
+    $et->SetFileType();
     SetByteOrder('II');
 
     #  A.  Local file header:
@@ -549,7 +549,7 @@ sub ProcessZIP($$)
         my $len = Get16u(\$buff, 26) + Get16u(\$buff, 28);
         $raf->Read($buf2, $len) == $len or last;
 
-        $$exifTool{DOC_NUM} = ++$docNum;
+        $$et{DOC_NUM} = ++$docNum;
         $buff .= $buf2;
         my %dirInfo = (
             DataPt => \$buff,
@@ -558,21 +558,21 @@ sub ProcessZIP($$)
             DirStart => 0,
             DirLen => 30 + $len,
         );
-        $exifTool->ProcessDirectory(\%dirInfo, $tagTablePtr);
+        $et->ProcessDirectory(\%dirInfo, $tagTablePtr);
         my $flags = Get16u(\$buff, 6);
         if ($flags & 0x08) {
             # we don't yet support skipping stream mode data
             # (when this happens, the CRC, compressed size and uncompressed
             #  sizes are set to 0 in the header.  Instead, they are stored
             #  after the compressed data with an optional header of 0x08074b50)
-            $exifTool->Warn('Stream mode data encountered, file list may be incomplete');
+            $et->Warn('Stream mode data encountered, file list may be incomplete');
             last;
         }
         $len = Get32u(\$buff, 18);      # file data length
         $raf->Seek($len, 1) or last;    # skip file data
         $raf->Read($buff, 30) == 30 and $buff =~ /^PK\x03\x04/ or last;
     }
-    delete $$exifTool{DOC_NUM};
+    delete $$et{DOC_NUM};
     return 1;
 }