exiftool_vendored 9.37.0 → 9.41.0

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

@@ -15,7 +15,7 @@ use strict;
 use vars qw($VERSION);
 use Image::ExifTool qw(:DataAccess :Utils);
 
-$VERSION = '1.00';
+$VERSION = '1.01';
 
 # Radiance tags
 %Image::ExifTool::Radiance::Main = (
@@ -61,26 +61,26 @@ $VERSION = '1.00';
 # Returns: 1 on success, 0 if this wasn't a valid RGBE image
 sub ProcessHDR($$)
 {
-    my ($exifTool, $dirInfo) = @_;
+    my ($et, $dirInfo) = @_;
     my $raf = $$dirInfo{RAF};
     my $buff;
     local $/ = "\x0a";  # set newline character for reading
 
     # verify this is a valid RIFF file
     return 0 unless $raf->ReadLine($buff) and $buff =~ /^#\?(RADIANCE|RGBE)\x0a/s;
-    $exifTool->SetFileType();
+    $et->SetFileType();
     my $tagTablePtr = GetTagTable('Image::ExifTool::Radiance::Main');
 
     while ($raf->ReadLine($buff)) {
         chomp $buff;
         last unless length($buff) > 0 and length($buff) < 4096;
         unless ($buff =~ /^(.*)?\s*=\s*(.*)/) {
-            $exifTool->HandleTag($tagTablePtr, '_command', $buff);
+            $et->HandleTag($tagTablePtr, '_command', $buff);
             next;
         }
         # use lower-case tag names to avoid conflicts with reserved tag table entries
         my ($tag, $val) = (lc $1, $2);
-        my $tagInfo = $exifTool->GetTagInfo($tagTablePtr, $tag);
+        my $tagInfo = $et->GetTagInfo($tagTablePtr, $tag);
         unless ($tagInfo) {
             my $name = $tag;
             $name =~ tr/-_a-zA-Z0-9//dc;
@@ -89,13 +89,13 @@ sub ProcessHDR($$)
             $tagInfo = { Name => $name };
             AddTagToTable($tagTablePtr, $tag, $tagInfo);
         }
-        $exifTool->FoundTag($tagInfo, $val);
+        $et->FoundTag($tagInfo, $val);
     }
     # get image dimensions
     if ($raf->ReadLine($buff) and $buff =~ /([-+][XY])\s*(\d+)\s*([-+][XY])\s*(\d+)/) {
-        $exifTool->HandleTag($tagTablePtr, '_orient', "$1 $3");
-        $exifTool->FoundTag('ImageHeight', $2);
-        $exifTool->FoundTag('ImageWidth', $4);
+        $et->HandleTag($tagTablePtr, '_orient', "$1 $3");
+        $et->FoundTag('ImageHeight', $2);
+        $et->FoundTag('ImageWidth', $4);
     }
     return 1;
 }

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

@@ -14,7 +14,7 @@ use strict;
 use vars qw($VERSION);
 use Image::ExifTool qw(:DataAccess :Utils);
 
-$VERSION = '1.01';
+$VERSION = '1.02';
 
 # currently support this version Rawzor images
 my $implementedRawzorVersion = 199; # (up to version 1.99)
@@ -51,7 +51,7 @@ my $implementedRawzorVersion = 199; # (up to version 1.99)
 # Returns: 1 on success, 0 if this wasn't a valid Rawzor file
 sub ProcessRWZ($$)
 {
-    my ($exifTool, $dirInfo) = @_;
+    my ($et, $dirInfo) = @_;
     my $raf = $$dirInfo{RAF};
     my ($buff, $buf2);
 
@@ -71,23 +71,23 @@ sub ProcessRWZ($$)
     my $rwzSize = Get64u(\$buff, 10);
     my $origSize = Get64u(\$buff, 18);
     my $tagTablePtr = GetTagTable('Image::ExifTool::Rawzor::Main');
-    $exifTool->HandleTag($tagTablePtr, RawzorRequiredVersion => $reqVers);
-    $exifTool->HandleTag($tagTablePtr, RawzorCreatorVersion => $creatorVers);
-    $exifTool->HandleTag($tagTablePtr, OriginalFileSize => $origSize);
-    $exifTool->HandleTag($tagTablePtr, CompressionFactor => $origSize/$rwzSize) if $rwzSize;
+    $et->HandleTag($tagTablePtr, RawzorRequiredVersion => $reqVers);
+    $et->HandleTag($tagTablePtr, RawzorCreatorVersion => $creatorVers);
+    $et->HandleTag($tagTablePtr, OriginalFileSize => $origSize);
+    $et->HandleTag($tagTablePtr, CompressionFactor => $origSize/$rwzSize) if $rwzSize;
     # check version numbers
     if ($reqVers > $implementedRawzorVersion) {
-        $exifTool->Warn("Version $reqVers Rawzor images not yet supported");
+        $et->Warn("Version $reqVers Rawzor images not yet supported");
         return 1;
     }
     my $metaOffset = Get64u(\$buff, 38);
     if ($metaOffset > 0x7fffffff) {
-        $exifTool->Warn('Bad metadata offset');
+        $et->Warn('Bad metadata offset');
         return 1;
     }
     # check for the ability to uncompress the information
     unless (eval 'require IO::Uncompress::Bunzip2') {
-        $exifTool->Warn('Install IO::Compress::Bzip2 to decode Rawzor bzip2 compression');
+        $et->Warn('Install IO::Compress::Bzip2 to decode Rawzor bzip2 compression');
         return 1;
     }
     # read the metadata header:
@@ -99,7 +99,7 @@ sub ProcessRWZ($$)
     # 36 int32u - original metadata size
     # 40 int32u - compressed metadata size
     unless ($raf->Seek($metaOffset, 0) and $raf->Read($buff, 44) == 44) {
-        $exifTool->Warn('Error reading metadata header');
+        $et->Warn('Error reading metadata header');
         return 1;
     }
     my $metaSize = Get32u(\$buff, 36);
@@ -114,14 +114,14 @@ sub ProcessRWZ($$)
             $end0 + ($end1 - $pos1) + ($origSize - $pos2) == $metaSize and
             $end0 <= $pos1 and $pos1 <= $end1 and $end1 <= $pos2)
         {
-            $exifTool->Warn('Error reading image metadata');
+            $et->Warn('Error reading image metadata');
             return 1;
         }
         # uncompress the metadata
         unless (IO::Uncompress::Bunzip2::bunzip2(\$buff, \$buf2) and
             length($buf2) eq $metaSize)
         {
-            $exifTool->Warn('Error uncompressing image metadata');
+            $et->Warn('Error uncompressing image metadata');
             return 1;
         }
         # re-assemble the original file (sans image data)
@@ -132,19 +132,19 @@ sub ProcessRWZ($$)
         undef $buf2;
 
         # extract original information by calling ExtractInfo recursively
-        $exifTool->ExtractInfo(\$buff, { ReEntry => 1 });
+        $et->ExtractInfo(\$buff, { ReEntry => 1 });
         undef $buff;
     }
     # set OriginalFileType from FileType of original file
     # then change FileType and MIMEType to indicate a Rawzor image
-    my $origFileType = $exifTool->{VALUE}->{FileType};
+    my $origFileType = $$et{VALUE}{FileType};
     if ($origFileType) {
-        $exifTool->HandleTag($tagTablePtr, OriginalFileType => $origFileType);
-        $exifTool->{VALUE}->{FileType} = 'RWZ';
-        $exifTool->{VALUE}->{MIMEType} = 'image/x-rawzor';
+        $et->HandleTag($tagTablePtr, OriginalFileType => $origFileType);
+        $$et{VALUE}{FileType} = 'RWZ';
+        $$et{VALUE}{MIMEType} = 'image/x-rawzor';
     } else {
-        $exifTool->HandleTag($tagTablePtr, OriginalFileType => 'Unknown');
-        $exifTool->SetFileType();
+        $et->HandleTag($tagTablePtr, OriginalFileType => 'Unknown');
+        $et->SetFileType();
     }
     return 1;
 }

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

@@ -16,7 +16,7 @@ use vars qw($VERSION);
 use Image::ExifTool qw(:DataAccess :Utils);
 use Image::ExifTool::Canon;
 
-$VERSION = '1.04';
+$VERSION = '1.05';
 
 sub ProcessRealMeta($$$);
 sub ProcessRealProperties($$$);
@@ -355,13 +355,13 @@ my %metadataFlag = (
 # Returns: 1 on success
 sub ProcessRealProperties($$$)
 {
-    my ($exifTool, $dirInfo, $tagTablePtr) = @_;
+    my ($et, $dirInfo, $tagTablePtr) = @_;
     my $dataPt = $$dirInfo{DataPt};
     my $dirLen = $$dirInfo{DirLen};
     my $pos = $$dirInfo{DirStart};
-    my $verbose = $exifTool->Options('Verbose');
+    my $verbose = $et->Options('Verbose');
 
-    $verbose and $exifTool->VerboseDir('RealProperties', undef, $dirLen);
+    $verbose and $et->VerboseDir('RealProperties', undef, $dirLen);
 
     while ($pos + 6 <= $dirLen) {
 
@@ -390,7 +390,7 @@ sub ProcessRealProperties($$$)
         my $count = int($valLen / Image::ExifTool::FormatSize($format));
         my $val = ReadValue($dataPt, $pos, $format, $count, $dirLen-$pos);
 
-        my $tagInfo = $exifTool->GetTagInfo($tagTablePtr, $tag);
+        my $tagInfo = $et->GetTagInfo($tagTablePtr, $tag);
         unless ($tagInfo) {
             my $tagName;
             ($tagName = $tag) =~ s/\s+//g;
@@ -399,7 +399,7 @@ sub ProcessRealProperties($$$)
             AddTagToTable($tagTablePtr, $tag, $tagInfo);
         }
         if ($verbose) {
-            $exifTool->VerboseInfo($tag, $tagInfo,
+            $et->VerboseInfo($tag, $tagInfo,
                 Table  => $tagTablePtr,
                 Value  => $val,
                 DataPt => $dataPt,
@@ -410,7 +410,7 @@ sub ProcessRealProperties($$$)
                 Count  => $count,
             );
         }
-        $exifTool->FoundTag($tagInfo, $val);
+        $et->FoundTag($tagInfo, $val);
         $pos += $valLen;
     }
     return 1;
@@ -422,16 +422,16 @@ sub ProcessRealProperties($$$)
 # Returns: 1 on success
 sub ProcessRealMeta($$$)
 {
-    my ($exifTool, $dirInfo, $tagTablePtr) = @_;
+    my ($et, $dirInfo, $tagTablePtr) = @_;
     my $dataPt = $$dirInfo{DataPt};
     my $dataPos = $$dirInfo{DataPos};
     my $pos = $$dirInfo{DirStart};
     my $dirEnd = $pos + $$dirInfo{DirLen};
-    my $verbose = $exifTool->Options('Verbose');
+    my $verbose = $et->Options('Verbose');
     my $prefix = $$dirInfo{Prefix} || '';
     $prefix and $prefix .= '/';
 
-    $verbose and $exifTool->VerboseDir('RealMetadata', undef, $$dirInfo{DirLen});
+    $verbose and $et->VerboseDir('RealMetadata', undef, $$dirInfo{DirLen});
 
     for (;;) {
         last if $pos + 28 > $dirEnd;
@@ -454,7 +454,7 @@ sub ProcessRealMeta($$$)
         last if $valuePos + $valueLen > $dirEnd;
 
         my $format = $metadataFormat{$type};
-        my $tagInfo = $exifTool->GetTagInfo($tagTablePtr, $tag);
+        my $tagInfo = $et->GetTagInfo($tagTablePtr, $tag);
         unless ($tagInfo) {
             my $tagName = $tag;
             $tagName =~ tr/A-Za-z0-9//dc;
@@ -480,7 +480,7 @@ sub ProcessRealMeta($$$)
             }
             my $count = int($valueLen / Image::ExifTool::FormatSize($format));
             my $val = ReadValue($dataPt, $valuePos, $format, $count, $dirEnd-$valuePos);
-            $exifTool->HandleTag($tagTablePtr, $tag, $val,
+            $et->HandleTag($tagTablePtr, $tag, $val,
                 DataPt => $dataPt,
                 DataPos => $dataPos,
                 Start => $valuePos,
@@ -498,12 +498,12 @@ sub ProcessRealMeta($$$)
                 DirLen => $pos + $size - $dirStart,
                 Prefix => $tag,
             );
-            $exifTool->ProcessDirectory(\%dirInfo, $tagTablePtr);
+            $et->ProcessDirectory(\%dirInfo, $tagTablePtr);
         }
         $pos += $size;  # step to next Metadata structure
     }
     unless ($pos == $dirEnd) {
-        $exifTool->Warn('Format error in Real Metadata');
+        $et->Warn('Format error in Real Metadata');
         return 0;
     }
     return 1;
@@ -515,7 +515,7 @@ sub ProcessRealMeta($$$)
 # Returns: 1 on success, 0 if this wasn't a valid Real file
 sub ProcessReal($$)
 {
-    my ($exifTool, $dirInfo) = @_;
+    my ($et, $dirInfo) = @_;
     my $raf = $$dirInfo{RAF};
     my ($buff, $tag, $vers, $extra, @mimeTypes, %dirCount);
 
@@ -531,7 +531,7 @@ sub ProcessReal($$)
         $type = 'RA';
     } else {
         $tagTablePtr = GetTagTable('Image::ExifTool::Real::Metafile');
-        my $ext = $exifTool->{FILE_EXT};
+        my $ext = $$et{FILE_EXT};
         $type = ($ext and $ext eq 'RPM') ? 'RPM' : 'RAM';
         require Image::ExifTool::PostScript;
         local $/ = Image::ExifTool::PostScript::GetInputRecordSeparator($raf) || "\n";
@@ -543,19 +543,19 @@ sub ProcessReal($$)
             if ($type) {
                 # must be a Real file type if protocol is http
                 return 0 if $buff =~ /^http/ and $buff !~ /\.(ra|rm|rv|rmvb|smil)$/i;
-                $exifTool->SetFileType($type);
+                $et->SetFileType($type);
                 undef $type;
             }
             # save URL or Text from RAM file
             my $tag = $buff =~ m{^[a-z]{3,4}://} ? 'url' : 'txt';
-            $exifTool->HandleTag($tagTablePtr, $tag, $buff);
+            $et->HandleTag($tagTablePtr, $tag, $buff);
         }
         return 1;
     }
 
-    $exifTool->SetFileType($type);
+    $et->SetFileType($type);
     SetByteOrder('MM');
-    my $verbose = $exifTool->Options('Verbose');
+    my $verbose = $et->Options('Verbose');
 #
 # Process RealAudio file
 #
@@ -564,12 +564,12 @@ sub ProcessReal($$)
         $tag = ".ra$vers";
         my $fpos = $raf->Tell();
         unless ($raf->Read($buff, 512)) {
-            $exifTool->Warn('Error reading audio header');
+            $et->Warn('Error reading audio header');
             return 1;
         }
-        my $tagInfo = $exifTool->GetTagInfo($tagTablePtr, $tag);
+        my $tagInfo = $et->GetTagInfo($tagTablePtr, $tag);
         if ($verbose > 2) {
-            $exifTool->VerboseInfo($tag, $tagInfo, DataPt => \$buff, DataPos => $fpos);
+            $et->VerboseInfo($tag, $tagInfo, DataPt => \$buff, DataPos => $fpos);
         }
         if ($tagInfo) {
             my $subTablePtr = GetTagTable($tagInfo->{SubDirectory}->{TagTable});
@@ -579,9 +579,9 @@ sub ProcessReal($$)
                 DirLen   => length $buff,
                 DirStart => 0,
             );
-            $exifTool->ProcessDirectory(\%dirInfo, $subTablePtr);
+            $et->ProcessDirectory(\%dirInfo, $subTablePtr);
         } else {
-            $exifTool->Warn('Unsupported RealAudio version');
+            $et->Warn('Unsupported RealAudio version');
         }
         return 1;
     }
@@ -591,7 +591,7 @@ sub ProcessReal($$)
     # skip the rest of the RM header
     my $size = unpack('x4N', $buff);
     unless ($raf->Seek($size - 8, 1)) {
-        $exifTool->Warn('Error seeking in file');
+        $et->Warn('Error seeking in file');
         return 0;
     }
 
@@ -601,23 +601,23 @@ sub ProcessReal($$)
         ($tag, $size, $vers) = unpack('a4Nn', $buff);
         last if $tag eq "\0\0\0\0";
         if ($verbose) {
-            $exifTool->VPrint(0, "$tag chunk ($size bytes):\n");
+            $et->VPrint(0, "$tag chunk ($size bytes):\n");
         } else {
             last if $tag eq 'DATA'; # stop normal parsing at DATA tag
         }
         if ($size & 0x80000000) {
-            $exifTool->Warn('Bad chunk header');
+            $et->Warn('Bad chunk header');
             last;
         }
-        my $tagInfo = $exifTool->GetTagInfo($tagTablePtr, $tag);
+        my $tagInfo = $et->GetTagInfo($tagTablePtr, $tag);
         if ($tagInfo and $$tagInfo{SubDirectory}) {
             my $fpos = $raf->Tell();
             unless ($raf->Read($buff, $size-10) == $size-10) {
-                $exifTool->Warn("Error reading $tag chunk");
+                $et->Warn("Error reading $tag chunk");
                 last;
             }
             if ($verbose > 2) {
-                $exifTool->VerboseInfo($tag, $tagInfo, DataPt => \$buff, DataPos => $fpos);
+                $et->VerboseInfo($tag, $tagInfo, DataPt => \$buff, DataPos => $fpos);
             }
             my $subTablePtr = GetTagTable($tagInfo->{SubDirectory}->{TagTable});
             my %dirInfo = (
@@ -627,30 +627,30 @@ sub ProcessReal($$)
                 DirStart => 0,
             );
             if ($dirCount{$tag}) {
-                $exifTool->{SET_GROUP1} = '+' . ++$dirCount{$tag};
+                $$et{SET_GROUP1} = '+' . ++$dirCount{$tag};
             } else {
                 $dirCount{$tag} = 1;
             }
-            $exifTool->ProcessDirectory(\%dirInfo, $subTablePtr);
-            delete $exifTool->{SET_GROUP1};
+            $et->ProcessDirectory(\%dirInfo, $subTablePtr);
+            delete $$et{SET_GROUP1};
             # keep track of stream MIME types
-            my $mime = $exifTool->{RealStreamMime};
+            my $mime = $$et{RealStreamMime};
             if ($mime) {
-                delete $exifTool->{RealStreamMime};
+                delete $$et{RealStreamMime};
                 $mime =~ s/\0.*//s;
                 push @mimeTypes, $mime unless $mime =~ /^logical-/;
             }
         } else {
             unless ($raf->Seek($size-10, 1)) {
-                $exifTool->Warn('Error seeking in file');
+                $et->Warn('Error seeking in file');
                 last;
             }
         }
     }
     # override MIMEType with stream MIME type if we only have one stream
     if (@mimeTypes == 1 and length $mimeTypes[0]) {
-        $exifTool->{VALUE}->{MIMEType} = $mimeTypes[0];
-        $exifTool->VPrint(0, "  MIMEType = $mimeTypes[0]\n");
+        $$et{VALUE}{MIMEType} = $mimeTypes[0];
+        $et->VPrint(0, "  MIMEType = $mimeTypes[0]\n");
     }
 #
 # Process footer containing Real metadata and ID3 information
@@ -668,19 +668,19 @@ sub ProcessReal($$)
                 DirLen => length($buff) - 8,
             );
             my $tagTablePtr = GetTagTable('Image::ExifTool::Real::Metadata');
-            $exifTool->ProcessDirectory(\%dirInfo, $tagTablePtr);
+            $et->ProcessDirectory(\%dirInfo, $tagTablePtr);
         } else {
-            $exifTool->Warn('Bad metadata footer');
+            $et->Warn('Bad metadata footer');
         }
         if ($raf->Seek(-128, 2) and $raf->Read($buff, 128) == 128 and $buff =~ /^TAG/) {
-            $exifTool->VPrint(0, "ID3v1:\n");
+            $et->VPrint(0, "ID3v1:\n");
             my %dirInfo = (
                 DataPt => \$buff,
                 DirStart => 0,
                 DirLen => length($buff),
             );
             my $tagTablePtr = GetTagTable('Image::ExifTool::ID3::v1');
-            $exifTool->ProcessDirectory(\%dirInfo, $tagTablePtr);
+            $et->ProcessDirectory(\%dirInfo, $tagTablePtr);
         }
     }
     return 1;

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

@@ -17,7 +17,7 @@ use vars qw($VERSION);
 use Image::ExifTool qw(:DataAccess :Utils);
 use Image::ExifTool::Exif;
 
-$VERSION = '1.25';
+$VERSION = '1.26';
 
 sub ProcessRicohText($$$);
 sub ProcessRicohRMETA($$$);
@@ -841,32 +841,32 @@ Image::ExifTool::AddCompositeTags('Image::ExifTool::Ricoh');
 # Returns: 1 on success, otherwise returns 0 and sets a Warning
 sub ProcessRicohText($$$)
 {
-    my ($exifTool, $dirInfo, $tagTablePtr) = @_;
+    my ($et, $dirInfo, $tagTablePtr) = @_;
     my $dataPt = $$dirInfo{DataPt};
     my $dataLen = $$dirInfo{DataLen};
     my $dirStart = $$dirInfo{DirStart} || 0;
     my $dirLen = $$dirInfo{DirLen} || $dataLen - $dirStart;
-    my $verbose = $exifTool->Options('Verbose');
+    my $verbose = $et->Options('Verbose');
 
     my $data = substr($$dataPt, $dirStart, $dirLen);
     return 1 if $data =~ /^\0/;     # blank Ricoh maker notes
     # validate text maker notes
     unless ($data =~ /^(Rev|Rv)/) {
-        $exifTool->Warn('Bad Ricoh maker notes');
+        $et->Warn('Bad Ricoh maker notes');
         return 0;
     }
     while ($data =~ m/([A-Z][a-z]{1,2})([0-9A-F]+);/sg) {
         my $tag = $1;
         my $val = $2;
-        my $tagInfo = $exifTool->GetTagInfo($tagTablePtr, $tag);
+        my $tagInfo = $et->GetTagInfo($tagTablePtr, $tag);
         if ($verbose) {
-            $exifTool->VerboseInfo($tag, $tagInfo,
+            $et->VerboseInfo($tag, $tagInfo,
                 Table  => $tagTablePtr,
                 Value  => $val,
             );
         }
         unless ($tagInfo) {
-            next unless $exifTool->{OPTIONS}->{Unknown};
+            next unless $$et{OPTIONS}{Unknown};
             $tagInfo = {
                 Name => "Ricoh_Text_$tag",
                 Unknown => 1,
@@ -875,7 +875,7 @@ sub ProcessRicohText($$$)
             # add tag information to table
             AddTagToTable($tagTablePtr, $tag, $tagInfo);
         }
-        $exifTool->FoundTag($tagInfo, $val);
+        $et->FoundTag($tagInfo, $val);
     }
     return 1;
 }
@@ -886,33 +886,33 @@ sub ProcessRicohText($$$)
 # Returns: 1 on success, otherwise returns 0 and sets a Warning
 sub ProcessRicohRMETA($$$)
 {
-    my ($exifTool, $dirInfo, $tagTablePtr) = @_;
+    my ($et, $dirInfo, $tagTablePtr) = @_;
     my $dataPt = $$dirInfo{DataPt};
     my $dirStart = $$dirInfo{DirStart};
     my $dataLen = length($$dataPt);
     my $dirLen = $dataLen - $dirStart;
-    my $verbose = $exifTool->Options('Verbose');
+    my $verbose = $et->Options('Verbose');
 
-    $exifTool->VerboseDir('Ricoh RMETA') if $verbose;
-    $dirLen > 6 or $exifTool->Warn('Truncated Ricoh RMETA data', 1), return 0;
+    $et->VerboseDir('Ricoh RMETA') if $verbose;
+    $dirLen > 6 or $et->Warn('Truncated Ricoh RMETA data', 1), return 0;
     my $byteOrder = substr($$dataPt, $dirStart, 2);
-    SetByteOrder($byteOrder) or $exifTool->Warn('Bad Ricoh RMETA data', 1), return 0;
+    SetByteOrder($byteOrder) or $et->Warn('Bad Ricoh RMETA data', 1), return 0;
     my $rmetaNum = Get16u($dataPt, $dirStart+4);
     if ($rmetaNum != 0) {
         # not sure how to recognize audio, so do it by checking for "RIFF" header
         # and assume all subsequent RMETA segments are part of the audio data
         # (but it looks like the int16u at $dirStart+6 is the next block number
         # if the data is continued, or 0 for the last block)
-        $dirLen < 14 and $exifTool->Warn('Short Ricoh RMETA block', 1), return 0;
+        $dirLen < 14 and $et->Warn('Short Ricoh RMETA block', 1), return 0;
         my $audioLen = Get16u($dataPt, $dirStart+12);
-        $audioLen + 14 > $dirLen and $exifTool->Warn('Truncated Ricoh RMETA audio data', 1), return 0;
+        $audioLen + 14 > $dirLen and $et->Warn('Truncated Ricoh RMETA audio data', 1), return 0;
         my $buff = substr($$dataPt, $dirStart + 14, $audioLen);
         if ($audioLen >= 4 and substr($buff, 0, 4) eq 'RIFF') {
-            $exifTool->HandleTag($tagTablePtr, '_audio', \$buff);
-        } elsif ($$exifTool{VALUE}{SoundFile}) {
-            ${$$exifTool{VALUE}{SoundFile}} .= $buff;
+            $et->HandleTag($tagTablePtr, '_audio', \$buff);
+        } elsif ($$et{VALUE}{SoundFile}) {
+            ${$$et{VALUE}{SoundFile}} .= $buff;
         } else {
-            $exifTool->Warn('Unknown Ricoh RMETA type', 1);
+            $et->Warn('Unknown Ricoh RMETA type', 1);
             return 0;
         }
         return 1;
@@ -927,7 +927,7 @@ sub ProcessRicohRMETA($$$)
         $pos += 4;
         $size -= 2;
         if ($size < 0 or $pos + $size > $dataLen) {
-            $exifTool->Warn('Corrupted Ricoh RMETA data', 1);
+            $et->Warn('Corrupted Ricoh RMETA data', 1);
             last;
         }
         if ($type eq 1) {
@@ -953,7 +953,7 @@ sub ProcessRicohRMETA($$$)
     if (@tags or @vals) {
         if (@tags < @vals) {
             my ($nt, $nv) = (scalar(@tags), scalar(@vals));
-            $exifTool->Warn("Fewer tags ($nt) than values ($nv) in Ricoh RMETA", 1);
+            $et->Warn("Fewer tags ($nt) than values ($nv) in Ricoh RMETA", 1);
         }
         # find next tag in null-delimited list
         # unpack numerical values from block of int16u values
@@ -965,7 +965,7 @@ sub ProcessRicohRMETA($$$)
             $name =~ s/ (\w)/\U$1/g;                # remove special characters
             $name = 'RMETA_Unknown' unless length($name);
             my $num = shift @nums;
-            my $tagInfo = $exifTool->GetTagInfo($tagTablePtr, $tag);
+            my $tagInfo = $et->GetTagInfo($tagTablePtr, $tag);
             if ($tagInfo) {
                 # make sure print conversion is defined
                 $$tagInfo{PrintConv} = { } unless ref $$tagInfo{PrintConv} eq 'HASH';
@@ -979,7 +979,7 @@ sub ProcessRicohRMETA($$$)
             # add conversion for this value (replacing any existing entry)
             $tagInfo->{PrintConv}->{$num} = length $val ? $val : $num;
             if ($verbose) {
-                $exifTool->VerboseInfo($tag, $tagInfo,
+                $et->VerboseInfo($tag, $tagInfo,
                     Table   => $tagTablePtr,
                     Value   => $num,
                     DataPt  => $dataPt,
@@ -988,7 +988,7 @@ sub ProcessRicohRMETA($$$)
                     Size    => length($val),
                 );
             }
-            $exifTool->FoundTag($tagInfo, $num);
+            $et->FoundTag($tagInfo, $num);
             $valPos += length($val) + 1;
         }
     }