exiftool_vendored 9.37.0 → 9.41.0

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

@@ -17,7 +17,7 @@ use vars qw($VERSION);
 use Image::ExifTool qw(:DataAccess :Utils);
 use Image::ExifTool::Exif;
 
-$VERSION = '1.09';
+$VERSION = '1.10';
 
 sub ProcessNikonCapture($$$);
 
@@ -678,18 +678,18 @@ my %unsharpColor = (
 # Returns: 1 on success
 sub WriteNikonCapture($$$)
 {
-    my ($exifTool, $dirInfo, $tagTablePtr) = @_;
-    $exifTool or return 1;    # allow dummy access to autoload this package
+    my ($et, $dirInfo, $tagTablePtr) = @_;
+    $et or return 1;    # allow dummy access to autoload this package
 
     # no need to edit this information unless necessary
-    unless ($exifTool->{EDIT_DIRS}->{MakerNotes} or $exifTool->{EDIT_DIRS}->{IPTC}) {
+    unless ($$et{EDIT_DIRS}{MakerNotes} or $$et{EDIT_DIRS}{IPTC}) {
         return undef;
     }
     my $dataPt = $$dirInfo{DataPt};
     my $dirStart = $$dirInfo{DirStart};
     my $dirLen = $$dirInfo{DirLen};
     if ($dirLen < 22) {
-        $exifTool->Warn('Short Nikon Capture Data',1);
+        $et->Warn('Short Nikon Capture Data',1);
         return undef;
     }
     # make sure the capture data is properly contained
@@ -699,7 +699,7 @@ sub WriteNikonCapture($$$)
     my $size = Get32u($dataPt, $dirStart + 18);
     my $pad = $dirLen - $size - 18; 
     unless ($tagID == 0x7a86a940 and ($pad >= 0 or $pad == -18)) {
-        $exifTool->Warn('Unrecognized Nikon Capture Data header');
+        $et->Warn('Unrecognized Nikon Capture Data header');
         return undef;
     }
     # determine if there is any data after this block
@@ -711,7 +711,7 @@ sub WriteNikonCapture($$$)
     }
     my $outBuff = '';
     my $pos;
-    my $newTags = $exifTool->GetNewTagInfoHash($tagTablePtr);
+    my $newTags = $et->GetNewTagInfoHash($tagTablePtr);
     my $dirEnd = $dirStart + $dirLen;
 
     # loop through all entries in the Nikon Capture data
@@ -719,7 +719,7 @@ sub WriteNikonCapture($$$)
         $tagID = Get32u($dataPt, $pos);
         $size = Get32u($dataPt, $pos + 18) - 4;
         last if $size < 0 or $pos + 22 + $size > $dirEnd;
-        my $tagInfo = $exifTool->GetTagInfo($tagTablePtr, $tagID);
+        my $tagInfo = $et->GetTagInfo($tagTablePtr, $tagID);
         if ($tagInfo) {
             my $newVal;
             if ($$tagInfo{SubDirectory}) {
@@ -731,25 +731,25 @@ sub WriteNikonCapture($$$)
                 );
                 my $subTable = GetTagTable($tagInfo->{SubDirectory}->{TagTable});
                 # ignore minor errors in IPTC since there is typically trailing garbage
-                my $oldSetting = $exifTool->Options('IgnoreMinorErrors');
-                $$tagInfo{Name} =~ /IPTC/ and $exifTool->Options(IgnoreMinorErrors => 1);
+                my $oldSetting = $et->Options('IgnoreMinorErrors');
+                $$tagInfo{Name} =~ /IPTC/ and $et->Options(IgnoreMinorErrors => 1);
                 # rewrite the directory
-                $newVal = $exifTool->WriteDirectory(\%subdirInfo, $subTable);
+                $newVal = $et->WriteDirectory(\%subdirInfo, $subTable);
                 # restore our original options
-                $exifTool->Options(IgnoreMinorErrors => $oldSetting);
+                $et->Options(IgnoreMinorErrors => $oldSetting);
             } elsif ($$newTags{$tagID}) {
                 # get new value for this tag if we are writing it
                 my $format = $$tagInfo{Format} || $$tagInfo{Writable};
                 my $oldVal = ReadValue($dataPt,$pos+22,$format,1,$size);
-                my $nvHash = $exifTool->GetNewValueHash($tagInfo);
-                if ($exifTool->IsOverwriting($nvHash, $oldVal)) {
-                    my $val = $exifTool->GetNewValues($tagInfo);
+                my $nvHash = $et->GetNewValueHash($tagInfo);
+                if ($et->IsOverwriting($nvHash, $oldVal)) {
+                    my $val = $et->GetNewValues($tagInfo);
                     $newVal = WriteValue($val, $$tagInfo{Writable}) if defined $val;
                     if (defined $newVal and length $newVal) {
-                        ++$exifTool->{CHANGED};
+                        ++$$et{CHANGED};
                     } else {
                         undef $newVal;
-                        $exifTool->Warn("Can't delete $$tagInfo{Name}");
+                        $et->Warn("Can't delete $$tagInfo{Name}");
                     }
                 }
             }
@@ -771,7 +771,7 @@ sub WriteNikonCapture($$$)
             # (did they forget to include the size word?)
             $outBuff .= substr($$dataPt, $pos, 4);
         } else {
-            $exifTool->Warn('Nikon Capture Data improperly terminated',1);
+            $et->Warn('Nikon Capture Data improperly terminated',1);
             return undef;
         }
     }
@@ -787,17 +787,17 @@ sub WriteNikonCapture($$$)
 # Returns: 1 on success
 sub ProcessNikonCaptureEditVersions($$$)
 {
-    my ($exifTool, $dirInfo, $tagTablePtr) = @_;
+    my ($et, $dirInfo, $tagTablePtr) = @_;
     my $dataPt = $$dirInfo{DataPt};
     my $dirStart = $$dirInfo{DirStart};
     my $dirLen = $$dirInfo{DirLen};
     my $dirEnd = $dirStart + $dirLen;
-    my $verbose = $exifTool->Options('Verbose');
+    my $verbose = $et->Options('Verbose');
     SetByteOrder('II');
     return 0 unless $dirLen > 4;
     my $num = Get32u($dataPt, $dirStart);
     my $pos = $dirStart + 4;
-    $verbose and $exifTool->VerboseDir('NikonCaptureEditVersions', $num);
+    $verbose and $et->VerboseDir('NikonCaptureEditVersions', $num);
     while ($num) {
         last if $pos + 4 > $dirEnd;
         my $len = Get32u($dataPt, $pos);
@@ -809,12 +809,12 @@ sub ProcessNikonCaptureEditVersions($$$)
             DirStart => $pos + 4,
             DirLen   => $len,
         );
-        $$exifTool{DOC_NUM} = ++$$exifTool{DOC_COUNT};
-        $exifTool->ProcessDirectory(\%dirInfo, $tagTablePtr);
+        $$et{DOC_NUM} = ++$$et{DOC_COUNT};
+        $et->ProcessDirectory(\%dirInfo, $tagTablePtr);
         --$num;
         $pos += $len + 4;
     }
-    delete $$exifTool{DOC_NUM};
+    delete $$et{DOC_NUM};
     return 1;
 }
 
@@ -824,22 +824,22 @@ sub ProcessNikonCaptureEditVersions($$$)
 # Returns: 1 on success
 sub ProcessNikonCapture($$$)
 {
-    my ($exifTool, $dirInfo, $tagTablePtr) = @_;
+    my ($et, $dirInfo, $tagTablePtr) = @_;
     my $dataPt = $$dirInfo{DataPt};
     my $dirStart = $$dirInfo{DirStart};
     my $dirLen = $$dirInfo{DirLen};
     my $dirEnd = $dirStart + $dirLen;
-    my $verbose = $exifTool->Options('Verbose');
+    my $verbose = $et->Options('Verbose');
     my $success = 0;
     SetByteOrder('II');
-    $verbose and $exifTool->VerboseDir('NikonCapture', 0, $dirLen);
+    $verbose and $et->VerboseDir('NikonCapture', 0, $dirLen);
     my $pos;
     for ($pos=$dirStart+22; $pos+22<$dirEnd; ) {
         my $tagID = Get32u($dataPt, $pos);
         my $size = Get32u($dataPt, $pos + 18) - 4;
         $pos += 22;
         last if $size < 0 or $pos + $size > $dirEnd;
-        my $tagInfo = $exifTool->GetTagInfo($tagTablePtr, $tagID);
+        my $tagInfo = $et->GetTagInfo($tagTablePtr, $tagID);
         if ($tagInfo or $verbose) {
             my ($format, $value);
             # (note that Writable will be 0 for Unknown tags)
@@ -859,7 +859,7 @@ sub ProcessNikonCapture($$$)
             } elsif ($size == 1) {
                 $value = substr($$dataPt, $pos, $size);
             }
-            $exifTool->HandleTag($tagTablePtr, $tagID, $value,
+            $et->HandleTag($tagTablePtr, $tagID, $value,
                 DataPt => $dataPt,
                 Start  => $pos,
                 Size   => $size,

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

@@ -14,7 +14,7 @@ use Image::ExifTool qw(:DataAccess :Utils);
 use Image::ExifTool::XMP;
 use Image::ExifTool::ZIP;
 
-$VERSION = '1.06';
+$VERSION = '1.07';
 
 # test for recognized OOXML document extensions
 my %isOOXML = (
@@ -208,19 +208,19 @@ sub GetTagID($)
 # Returns: 1 if valid tag was found
 sub FoundTag($$$$;$)
 {
-    my ($exifTool, $tagTablePtr, $props, $val, $attrs) = @_;
+    my ($et, $tagTablePtr, $props, $val, $attrs) = @_;
     return 0 unless @$props;
-    my $verbose = $exifTool->Options('Verbose');
+    my $verbose = $et->Options('Verbose');
 
     my $tag = $$props[-1];
-    $exifTool->VPrint(0, "  | - Tag '", join('/',@$props), "'\n") if $verbose > 1;
+    $et->VPrint(0, "  | - Tag '", join('/',@$props), "'\n") if $verbose > 1;
 
     # un-escape XML character entities
     $val = Image::ExifTool::XMP::UnescapeXML($val);
     # convert OOXML-escaped characters (ie. "_x0000d_" is a newline)
     $val =~ s/_x([0-9a-f]{4})_/Image::ExifTool::PackUTF8(hex($1))/gie;
     # convert from UTF8 to ExifTool Charset
-    $val = $exifTool->Decode($val, 'UTF8');
+    $val = $et->Decode($val, 'UTF8');
     # queue this attribute for later if necessary
     if ($queueAttrs{$tag}) {
         $queuedAttrs{$tag} = $val;
@@ -246,7 +246,7 @@ sub FoundTag($$$$;$)
                 $tagInfo{Format} = 'date',
                 $tagInfo{PrintConv} = '$self->ConvertDateTime($val)';
             }
-            $exifTool->VPrint(0, "  | [adding $tag]\n") if $verbose;
+            $et->VPrint(0, "  | [adding $tag]\n") if $verbose;
             AddTagToTable($tagTablePtr, $tag, \%tagInfo);
         }
     } elsif ($tag eq 'xmlns') {
@@ -288,11 +288,11 @@ sub FoundTag($$$$;$)
             $val = Image::ExifTool::XMP::ConvertXMPDate($val) if $fmt eq 'date';
         }
     } else {
-        $exifTool->VPrint(0, "  [adding $tag]\n") if $verbose;
+        $et->VPrint(0, "  [adding $tag]\n") if $verbose;
         AddTagToTable($tagTablePtr, $tag, { Name => ucfirst $tag });
     }
     # save the tag
-    $exifTool->HandleTag($tagTablePtr, $tag, $val);
+    $et->HandleTag($tagTablePtr, $tag, $val);
 
     # start fresh for next tag
     undef $vectorCount;
@@ -311,7 +311,7 @@ sub FoundTag($$$$;$)
 #   ZIP     - reference to Archive::Zip object for this file
 sub ProcessDOCX($$)
 {
-    my ($exifTool, $dirInfo) = @_;
+    my ($et, $dirInfo) = @_;
     my $zip = $$dirInfo{ZIP};
     my $tagTablePtr = GetTagTable('Image::ExifTool::OOXML::Main');
     my $mime = $$dirInfo{MIME} || $Image::ExifTool::mimeType{DOCX};
@@ -320,17 +320,17 @@ sub ProcessDOCX($$)
     my $fileType = $fileType{$mime};
     if ($fileType) {
         # THMX is a special case because its contents.main MIME types is PPTX
-        if ($fileType eq 'PPTX' and $$exifTool{FILE_EXT} and $$exifTool{FILE_EXT} eq 'THMX') {
+        if ($fileType eq 'PPTX' and $$et{FILE_EXT} and $$et{FILE_EXT} eq 'THMX') {
             $fileType = 'THMX';
         }
     } else {
-        $exifTool->VPrint(0, "Unrecognized MIME type: $mime\n");
+        $et->VPrint(0, "Unrecognized MIME type: $mime\n");
         # get MIME type according to file extension
-        $fileType = $$exifTool{FILE_EXT};
+        $fileType = $$et{FILE_EXT};
         # default to 'DOCX' if this isn't a known OOXML extension
         $fileType = 'DOCX' unless $fileType and $isOOXML{$fileType};
     }
-    $exifTool->SetFileType($fileType);
+    $et->SetFileType($fileType);
 
     # must catch all Archive::Zip warnings
     local $SIG{'__WARN__'} = \&Image::ExifTool::ZIP::WarnProc;
@@ -342,19 +342,19 @@ sub ProcessDOCX($$)
         # get filename of this ZIP member
         my $file = $member->fileName();
         next unless defined $file;
-        $exifTool->VPrint(0, "File: $file\n");
+        $et->VPrint(0, "File: $file\n");
         # set the document number and extract ZIP tags
-        $$exifTool{DOC_NUM} = ++$docNum;
-        Image::ExifTool::ZIP::HandleMember($exifTool, $member);
+        $$et{DOC_NUM} = ++$docNum;
+        Image::ExifTool::ZIP::HandleMember($et, $member);
         # process only XML and JPEG/WMF thumbnail images in "docProps" directory
         next unless $file =~ m{^docProps/(.*\.xml|(thumbnail\.(jpe?g|wmf)))$}i;
         # get the file contents (CAREFUL! $buff MUST be local since we hand off a value ref)
         my ($buff, $status) = $zip->contents($member);
-        $status and $exifTool->Warn("Error extracting $file"), next;
+        $status and $et->Warn("Error extracting $file"), next;
         # extract docProps/thumbnail.(jpg|mwf) as PreviewImage|PreviewMWF
         if ($file =~ /\.(jpe?g|wmf)$/i) {
             my $tag = $file =~ /\.wmf$/i ? 'PreviewWMF' : 'PreviewImage';
-            $exifTool->FoundTag($tag, \$buff);
+            $et->FoundTag($tag, \$buff);
             next;
         }
         # process XML files (docProps/app.xml, docProps/core.xml, docProps/custom.xml)
@@ -366,10 +366,10 @@ sub ProcessDOCX($$)
                 FoundProc => \&FoundTag,
             },
         );
-        $exifTool->ProcessDirectory(\%dirInfo, $tagTablePtr);
+        $et->ProcessDirectory(\%dirInfo, $tagTablePtr);
         undef $buff;    # (free memory now)
     }
-    delete $$exifTool{DOC_NUM};
+    delete $$et{DOC_NUM};
     return 1;
 }
 

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

@@ -16,7 +16,7 @@ use strict;
 use vars qw($VERSION);
 use Image::ExifTool qw(:DataAccess :Utils);
 
-$VERSION = '1.00';
+$VERSION = '1.01';
 
 my $MAX_PACKETS = 2;    # maximum packets to scan from each stream at start of file
 
@@ -39,14 +39,14 @@ my $MAX_PACKETS = 2;    # maximum packets to scan from each stream at start of f
 # Returns: 1 on success
 sub ProcessPacket($$)
 {
-    my ($exifTool, $dataPt) = @_;
+    my ($et, $dataPt) = @_;
     my $rtnVal = 0;
     if ($$dataPt =~ /^(.)(vorbis|theora)/s) {
         my ($tag, $type) = (ord($1), ucfirst($2));
         # this is an OGV file if it contains Theora video
-        $exifTool->OverrideFileType('OGV') if $type eq 'Theora' and $$exifTool{FILE_TYPE} eq 'OGG';
+        $et->OverrideFileType('OGV') if $type eq 'Theora' and $$et{FILE_TYPE} eq 'OGG';
         my $tagTablePtr = GetTagTable("Image::ExifTool::${type}::Main");
-        my $tagInfo = $exifTool->GetTagInfo($tagTablePtr, $tag);
+        my $tagInfo = $et->GetTagInfo($tagTablePtr, $tag);
         return 0 unless $tagInfo and $$tagInfo{SubDirectory};
         my $subdir = $$tagInfo{SubDirectory};
         my %dirInfo = (
@@ -56,11 +56,11 @@ sub ProcessPacket($$)
         );
         my $table = GetTagTable($$subdir{TagTable});
         # set group1 so Theoris comments can be distinguised from Vorbis comments
-        $$exifTool{SET_GROUP1} = $type if $type eq 'Theora';
+        $$et{SET_GROUP1} = $type if $type eq 'Theora';
         SetByteOrder($$subdir{ByteOrder}) if $$subdir{ByteOrder};
-        $rtnVal = $exifTool->ProcessDirectory(\%dirInfo, $table);
+        $rtnVal = $et->ProcessDirectory(\%dirInfo, $table);
         SetByteOrder('II');
-        delete $$exifTool{SET_GROUP1};
+        delete $$et{SET_GROUP1};
     }
     return $rtnVal;
 }
@@ -71,16 +71,16 @@ sub ProcessPacket($$)
 # Returns: 1 on success, 0 if this wasn't a valid Ogg file
 sub ProcessOGG($$)
 {
-    my ($exifTool, $dirInfo) = @_;
+    my ($et, $dirInfo) = @_;
 
     # must first check for leading/trailing ID3 information
-    unless ($exifTool->{DoneID3}) {
+    unless ($$et{DoneID3}) {
         require Image::ExifTool::ID3;
-        Image::ExifTool::ID3::ProcessID3($exifTool, $dirInfo) and return 1;
+        Image::ExifTool::ID3::ProcessID3($et, $dirInfo) and return 1;
     }
     my $raf = $$dirInfo{RAF};
-    my $verbose = $exifTool->Options('Verbose');
-    my $out = $exifTool->Options('TextOut');
+    my $verbose = $et->Options('Verbose');
+    my $out = $et->Options('TextOut');
     my ($success, $page, $packets, $streams, $stream) = (0,0,0,0,'');
     my ($buff, $flag, %val, $numFlac, %streamPage);
 
@@ -91,13 +91,13 @@ sub ProcessOGG($$)
         if ($raf and $raf->Read($buff, 28) == 28) {
             # validate magic number
             unless ($buff =~ /^OggS/) {
-                $success and $exifTool->Warn('Lost synchronization');
+                $success and $et->Warn('Lost synchronization');
                 last;
             }
             unless ($success) {
                 # set file type and initialize on first page
                 $success = 1;
-                $exifTool->SetFileType();
+                $et->SetFileType();
                 SetByteOrder('II');
             }
             $flag = Get8u(\$buff, 5);       # page flag
@@ -125,7 +125,7 @@ sub ProcessOGG($$)
             # can finally process previous packet from this stream
             # unless this is a continuation page
             if (defined $val{$stream} and not $flag & 0x01) {
-                ProcessPacket($exifTool, \$val{$stream});
+                ProcessPacket($et, \$val{$stream});
                 delete $val{$stream};
                 # only read the first $MAX_PACKETS packets from each stream
                 if ($packets > $MAX_PACKETS * $streams or not defined $raf) {
@@ -151,7 +151,7 @@ sub ProcessOGG($$)
             if ($page == $pageNum) {
                 $streamPage{$stream} = ++$page;
             } else {
-                $exifTool->Warn('Missing page(s) in Ogg file');
+                $et->Warn('Missing page(s) in Ogg file');
                 undef $page;
                 delete $streamPage{$stream};
             }
@@ -161,7 +161,7 @@ sub ProcessOGG($$)
         if ($verbose > 1) {
             printf $out "Page %d, stream 0x%x, flag 0x%x (%d bytes)\n",
                    $pageNum, $stream, $flag, $dataLen;
-            $exifTool->VerboseDump(\$buff, DataPos => $raf->Tell() - $dataLen);
+            $et->VerboseDump(\$buff, DataPos => $raf->Tell() - $dataLen);
         }
         if (defined $val{$stream}) {
             $val{$stream} .= $buff;     # add this continuation page
@@ -179,7 +179,7 @@ sub ProcessOGG($$)
             last if $numFlac <= 0;
         } elsif (defined $val{$stream} and $flag & 0x04) {
             # process Ogg packet now if end-of-stream bit is set
-            ProcessPacket($exifTool, \$val{$stream});
+            ProcessPacket($et, \$val{$stream});
             delete $val{$stream};
         }
     }
@@ -187,7 +187,7 @@ sub ProcessOGG($$)
         # process FLAC headers as if it was a complete FLAC file
         require Image::ExifTool::FLAC;
         my %dirInfo = ( RAF => new File::RandomAccess(\$val{$stream}) );
-        Image::ExifTool::FLAC::ProcessFLAC($exifTool, \%dirInfo);
+        Image::ExifTool::FLAC::ProcessFLAC($et, \%dirInfo);
     }
     return $success;
 }

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

@@ -35,7 +35,7 @@ use vars qw($VERSION);
 use Image::ExifTool::Exif;
 use Image::ExifTool::APP12;
 
-$VERSION = '2.09';
+$VERSION = '2.10';
 
 sub PrintLensInfo($$$);
 
@@ -3545,8 +3545,8 @@ sub PrintAFAreas($)
 # Returns: 1 if this looked like a valid ORF file, 0 otherwise
 sub ProcessORF($$)
 {
-    my ($exifTool, $dirInfo) = @_;
-    return $exifTool->ProcessTIFF($dirInfo);
+    my ($et, $dirInfo) = @_;
+    return $et->ProcessTIFF($dirInfo);
 }
 
 1;  # end

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

@@ -14,7 +14,7 @@ use strict;
 use vars qw($VERSION);
 use Image::ExifTool qw(:DataAccess :Utils);
 
-$VERSION = '1.00';
+$VERSION = '1.01';
 
 # supported EXR value format types (other types are extracted as undef binary data)
 my %formatType = (
@@ -155,38 +155,38 @@ my %formatType = (
 # Returns: 1 on success, 0 if this wasn't a valid OpenEXR file
 sub ProcessEXR($$)
 {
-    my ($exifTool, $dirInfo) = @_;
+    my ($et, $dirInfo) = @_;
     my $raf = $$dirInfo{RAF};
-    my $verbose = $exifTool->Options('Verbose');
-    my $binary = $exifTool->Options('Binary') || $verbose;
+    my $verbose = $et->Options('Verbose');
+    my $binary = $et->Options('Binary') || $verbose;
     my ($buff, $buf2, $dim);
 
     # verify this is a valid RIFF file
     return 0 unless $raf->Read($buff, 8) == 8;
     return 0 unless $buff =~ /^\x76\x2f\x31\x01/s;
-    $exifTool->SetFileType();
+    $et->SetFileType();
     SetByteOrder('II');
     my $tagTablePtr = GetTagTable('Image::ExifTool::OpenEXR::Main');
 
     # extract information from header
     my $ver = unpack('x4V', $buff);
-    $exifTool->HandleTag($tagTablePtr, '_ver', $ver & 0xff);
-    $exifTool->HandleTag($tagTablePtr, '_lay', $ver & 0x200);
+    $et->HandleTag($tagTablePtr, '_ver', $ver & 0xff);
+    $et->HandleTag($tagTablePtr, '_lay', $ver & 0x200);
 
     # extract attributes
     for (;;) {
         $raf->Read($buff, 68) or last;
         last if $buff =~ /^\0/;
         unless ($buff =~ /^([^\0]{1,31})\0([^\0]{1,31})\0(.{4})/sg) {
-            $exifTool->Warn('EXR format error');
+            $et->Warn('EXR format error');
             last;
         }
         my ($tag, $type, $size) = ($1, $2, unpack('V', $3));
         unless ($raf->Seek(pos($buff) - length($buff), 1)) {
-            $exifTool->Warn('Seek error');
+            $et->Warn('Seek error');
             last;
         }
-        my $tagInfo = $exifTool->GetTagInfo($tagTablePtr, $tag);
+        my $tagInfo = $et->GetTagInfo($tagTablePtr, $tag);
         unless ($tagInfo) {
             my $name = ucfirst $tag;
             $name =~ tr/-_a-zA-Z0-9//dc;
@@ -199,7 +199,7 @@ sub ProcessEXR($$)
             }
             $tagInfo = { Name => $name, WasAdded => 1 };
             AddTagToTable($tagTablePtr, $tag, $tagInfo);
-            $exifTool->VPrint(0, $exifTool->{INDENT}, "[adding $tag]\n");
+            $et->VPrint(0, $$et{INDENT}, "[adding $tag]\n");
         }
         my ($val, $success);
         my $format = $formatType{$type};
@@ -252,7 +252,7 @@ sub ProcessEXR($$)
             $success = $raf->Seek($size, 1);
         }
         unless ($success) {
-            $exifTool->Warn('Truncated or corrupted EXR file');
+            $et->Warn('Truncated or corrupted EXR file');
             last;
         }
         $val = '<bad>' unless defined $val;
@@ -265,7 +265,7 @@ sub ProcessEXR($$)
         }
         if ($verbose) {
             my $dataPt = ref $val ? $val : \$val,
-            $exifTool->VerboseInfo($tag, $tagInfo,
+            $et->VerboseInfo($tag, $tagInfo,
                 Table   => $tagTablePtr,
                 Value   => $val,
                 Size    => $size,
@@ -274,11 +274,11 @@ sub ProcessEXR($$)
                 Addr    => $raf->Tell() - $size,
             );
         }
-        $exifTool->FoundTag($tagInfo, $val);
+        $et->FoundTag($tagInfo, $val);
     }
     if ($dim) {
-        $exifTool->FoundTag('ImageWidth', $$dim[0]);
-        $exifTool->FoundTag('ImageHeight', $$dim[1]);
+        $et->FoundTag('ImageWidth', $$dim[0]);
+        $et->FoundTag('ImageHeight', $$dim[1]);
     }
     return 1;
 }