exiftool_vendored 9.37.0 → 9.41.0

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

@@ -19,7 +19,7 @@ use strict;
 use vars qw($VERSION %ttLang);
 use Image::ExifTool qw(:DataAccess :Utils);
 
-$VERSION = '1.06';
+$VERSION = '1.07';
 
 sub ProcessOTF($$);
 
@@ -335,7 +335,7 @@ my %ttCharset = (
 # Returns: 1 on success, 0 if this wasn't a valid TrueType font collection
 sub ProcessTTC($$)
 {
-    my ($exifTool, $dirInfo) = @_;
+    my ($et, $dirInfo) = @_;
     my $raf = $$dirInfo{RAF};
     my ($buff, $i);
 
@@ -345,19 +345,19 @@ sub ProcessTTC($$)
     my $num = Get32u(\$buff, 8);
     # might as well put a limit on the number of fonts we will parse (< 256)
     return 0 unless $num < 0x100 and $raf->Read($buff, $num * 4) == $num * 4;
-    $exifTool->SetFileType('TTC');
+    $et->SetFileType('TTC');
     my $tagTablePtr = GetTagTable('Image::ExifTool::Font::Main');
-    $exifTool->HandleTag($tagTablePtr, 'numfonts', $num);
+    $et->HandleTag($tagTablePtr, 'numfonts', $num);
     # loop through all fonts in the collection
     for ($i=0; $i<$num; ++$i) {
         my $n = $i + 1;
-        $exifTool->VPrint(0, "Font $n:\n");
-        $$exifTool{SET_GROUP1} = "+$n";
+        $et->VPrint(0, "Font $n:\n");
+        $$et{SET_GROUP1} = "+$n";
         my $offset = Get32u(\$buff, $i * 4);
         $raf->Seek($offset, 0) or last;
-        ProcessOTF($exifTool, $dirInfo) or last;
+        ProcessOTF($et, $dirInfo) or last;
     }
-    delete $$exifTool{SET_GROUP1};
+    delete $$et{SET_GROUP1};
     return 1;
 }
 
@@ -367,7 +367,7 @@ sub ProcessTTC($$)
 # Returns: 1 on success, 0 if this wasn't a valid TrueType font file
 sub ProcessOTF($$)
 {
-    my ($exifTool, $dirInfo) = @_;
+    my ($et, $dirInfo) = @_;
     my $raf = $$dirInfo{RAF};
     my ($tbl, $buff, $pos, $i);
     my $base = $$dirInfo{Base} || 0;
@@ -375,17 +375,17 @@ sub ProcessOTF($$)
     return 0 unless $raf->Read($buff, 12) == 12;
     return 0 unless $buff =~ /^(\0\x01\0\0|OTTO|true|typ1|\xa5(kbd|lst))[\0\x01]/;
 
-    $exifTool->SetFileType($1 eq 'OTTO' ? 'OTF' : 'TTF');
+    $et->SetFileType($1 eq 'OTTO' ? 'OTF' : 'TTF');
     SetByteOrder('MM');
     my $numTables = Get16u(\$buff, 4);
     return 0 unless $numTables > 0 and $numTables < 0x200;
     my $len = $numTables * 16;
     return 0 unless $raf->Read($tbl, $len) == $len;
 
-    my $verbose = $exifTool->Options('Verbose');
-    my $oldIndent = $$exifTool{INDENT};
-    $$exifTool{INDENT} .= '| ';
-    $exifTool->VerboseDir('TrueType', $numTables) if $verbose;
+    my $verbose = $et->Options('Verbose');
+    my $oldIndent = $$et{INDENT};
+    $$et{INDENT} .= '| ';
+    $et->VerboseDir('TrueType', $numTables) if $verbose;
 
     for ($pos=0; $pos<$len; $pos+=16) {
         # look for 'name' table
@@ -394,27 +394,27 @@ sub ProcessOTF($$)
         my $offset = Get32u(\$tbl, $pos + 8);
         my $size   = Get32u(\$tbl, $pos + 12);
         unless ($raf->Seek($offset+$base, 0) and $raf->Read($buff, $size) == $size) {
-            $exifTool->Warn("Error reading '$tag' data");
+            $et->Warn("Error reading '$tag' data");
             next;
         }
         if ($verbose) {
             $tag =~ s/([\0-\x1f\x80-\xff])/sprintf('\x%.2x',ord $1)/ge;
             my $str = sprintf("%s%d) Tag '%s' (offset 0x%.4x, %d bytes)\n",
-                              $$exifTool{INDENT}, $pos/16, $tag, $offset, $size);
-            $exifTool->VPrint(0, $str);
-            $exifTool->VerboseDump(\$buff, Addr => $offset) if $verbose > 2;
+                              $$et{INDENT}, $pos/16, $tag, $offset, $size);
+            $et->VPrint(0, $str);
+            $et->VerboseDump(\$buff, Addr => $offset) if $verbose > 2;
             next unless $tag eq 'name';
         }
         next unless $size >= 8;
         my $entries = Get16u(\$buff, 2);
         my $recEnd = 6 + $entries * 12;
         if ($recEnd > $size) {
-            $exifTool->Warn('Truncated name record');
+            $et->Warn('Truncated name record');
             last;
         }
         my $strStart = Get16u(\$buff, 4);
         if ($strStart < $recEnd or $strStart > $size) {
-            $exifTool->Warn('Invalid string offset');
+            $et->Warn('Invalid string offset');
             last;
         }
         # parse language-tag record (in format 1 Naming table only) (ref 2)
@@ -430,15 +430,15 @@ sub ProcessOTF($$)
                     my $langPt = Get16u(\$buff, $pt + 2) + $strStart;
                     last if $langPt + $langLen > $size;
                     my $lang = substr($buff, $langPt, $langLen);
-                    $lang = $exifTool->Decode($lang,'UCS2','MM','UTF8');
+                    $lang = $et->Decode($lang,'UCS2','MM','UTF8');
                     $lang =~ tr/-_a-zA-Z0-9//dc;    # remove naughty characters
                     $langTag{$i + 0x8000} = $lang;
                 }
             }
         }
         my $tagTablePtr = GetTagTable('Image::ExifTool::Font::Name');
-        $$exifTool{INDENT} .= '| ';
-        $exifTool->VerboseDir('Name', $entries) if $verbose;
+        $$et{INDENT} .= '| ';
+        $et->VerboseDir('Name', $entries) if $verbose;
         for ($i=0; $i<$entries; ++$i) {
             my $pt = 6 + $i * 12;
             my $platform = Get16u(\$buff, $pt);
@@ -456,19 +456,19 @@ sub ProcessOTF($$)
                     $lang = $ttLang{$sys}{$langID} || $langTag{$langID};
                     $charset = $ttCharset{$sys}{$encoding};
                     if (not $charset) {
-                        if (not defined $charset and not $$exifTool{FontWarn}) {
-                            $exifTool->Warn("Unknown $sys character set ($encoding)");
-                            $$exifTool{FontWarn} = 1;
+                        if (not defined $charset and not $$et{FontWarn}) {
+                            $et->Warn("Unknown $sys character set ($encoding)");
+                            $$et{FontWarn} = 1;
                         }
                     } else {
                         # translate to ExifTool character set
-                        $val = $exifTool->Decode($val, $charset);
+                        $val = $et->Decode($val, $charset);
                     }
                 } else {
-                    $exifTool->Warn("Unknown platform ($platform) for name $nameID");
+                    $et->Warn("Unknown platform ($platform) for name $nameID");
                 }
                 # get the tagInfo for our specific language (use 'en' for default)
-                my $tagInfo = $exifTool->GetTagInfo($tagTablePtr, $nameID);
+                my $tagInfo = $et->GetTagInfo($tagTablePtr, $nameID);
                 if ($tagInfo and $lang and $lang ne 'en') {
                     my $langInfo = Image::ExifTool::GetLangInfo($tagInfo, $lang);
                     $tagInfo = $langInfo if $langInfo;
@@ -479,7 +479,7 @@ sub ProcessOTF($$)
                                "Enc=$encoding/" . ($charset || 'Unknown') . ', ' .
                                "Lang=$langID/" . ($lang || 'Unknown');
                 }
-                $exifTool->HandleTag($tagTablePtr, $nameID, $val,
+                $et->HandleTag($tagTablePtr, $nameID, $val,
                     TagInfo => $tagInfo,
                     DataPt  => \$buff,
                     DataPos => $offset,
@@ -490,10 +490,10 @@ sub ProcessOTF($$)
                 );
             }
         }
-        $$exifTool{INDENT} = $oldIndent . '| ';
+        $$et{INDENT} = $oldIndent . '| ';
         last unless $verbose;
     }
-    $$exifTool{INDENT} = $oldIndent;
+    $$et{INDENT} = $oldIndent;
     return 1;
 }
 
@@ -503,7 +503,7 @@ sub ProcessOTF($$)
 # Returns: 1 on success, 0 if this wasn't a recognized AFM-type file
 sub ProcessAFM($$)
 {
-    my ($exifTool, $dirInfo) = @_;
+    my ($et, $dirInfo) = @_;
     my $raf = $$dirInfo{RAF};
     my ($buff, $comment);
 
@@ -512,13 +512,13 @@ sub ProcessAFM($$)
     $raf->ReadLine($buff);
     return 0 unless $buff =~ /^Start(Comp|Master)?FontMetrics\s+\d+/;
     my $ftyp = $1 ? ($1 eq 'Comp' ? 'ACFM' : 'AMFM') : 'AFM';
-    $exifTool->SetFileType($ftyp, 'application/x-font-afm');
+    $et->SetFileType($ftyp, 'application/x-font-afm');
     my $tagTablePtr = GetTagTable('Image::ExifTool::Font::AFM');
 
     for (;;) {
         $raf->ReadLine($buff) or last;
         if (defined $comment and $buff !~ /^Comment\s/) {
-            $exifTool->FoundTag('Comment', $comment);
+            $et->FoundTag('Comment', $comment);
             undef $comment;
         }
         $buff =~ /^(\w+)\s+(.*?)[\x0d\x0a]/ or next;
@@ -532,7 +532,7 @@ sub ProcessAFM($$)
             $comment = defined($comment) ? "$comment\n$val" : $val;
             next;
         }
-        unless ($exifTool->HandleTag($tagTablePtr, $tag, $val)) {
+        unless ($et->HandleTag($tagTablePtr, $tag, $val)) {
             # end parsing if we start any subsection
             last if $tag =~ /^Start/ and $tag ne 'StartDirection';
         }
@@ -546,20 +546,20 @@ sub ProcessAFM($$)
 # Returns: 1 on success, 0 if this wasn't a recognized Font file
 sub ProcessFont($$)
 {
-    my ($exifTool, $dirInfo) = @_;
+    my ($et, $dirInfo) = @_;
     my $raf = $$dirInfo{RAF};
     my ($buff, $buf2, $rtnVal);
     return 0 unless $raf->Read($buff, 24) and $raf->Seek(0,0);
     if ($buff =~ /^(\0\x01\0\0|OTTO|true|typ1)[\0\x01]/) {        # OTF, TTF
-        $rtnVal = ProcessOTF($exifTool, $dirInfo);
+        $rtnVal = ProcessOTF($et, $dirInfo);
     } elsif ($buff =~ /^ttcf\0[\x01\x02]\0\0/) {                  # TTC
-        $rtnVal = ProcessTTC($exifTool, $dirInfo);
+        $rtnVal = ProcessTTC($et, $dirInfo);
     } elsif ($buff =~ /^Start(Comp|Master)?FontMetrics\s+\d+/s) { # AFM
-        $rtnVal = ProcessAFM($exifTool, $dirInfo);
+        $rtnVal = ProcessAFM($et, $dirInfo);
     } elsif ($buff =~ /^(.{6})?%!(PS-(AdobeFont-|Bitstream )|FontType1-)/s) {# PFA, PFB
-        $raf->Seek(6,0) and $exifTool->SetFileType('PFB') if $1;
+        $raf->Seek(6,0) and $et->SetFileType('PFB') if $1;
         require Image::ExifTool::PostScript;
-        $rtnVal = Image::ExifTool::PostScript::ProcessPS($exifTool, $dirInfo);
+        $rtnVal = Image::ExifTool::PostScript::ProcessPS($et, $dirInfo);
     } elsif ($buff =~ /^\0[\x01\x02]/ and $raf->Seek(0, 2) and    # PFM
              # validate file size
              $raf->Tell() > 117 and $raf->Tell() == unpack('x2V',$buff) and
@@ -571,18 +571,18 @@ sub ProcessFont($$)
              # incorrectly writes "Postscript\0", so ignore case
              $raf->Read($buf2, 11) == 11 and lc($buf2) eq "postscript\0")
     {
-        $exifTool->SetFileType('PFM');
+        $et->SetFileType('PFM');
         SetByteOrder('II');
         my $tagTablePtr = GetTagTable('Image::ExifTool::Font::Main');
         # process the PFM header
-        $exifTool->HandleTag($tagTablePtr, 'PFM', $buff);
+        $et->HandleTag($tagTablePtr, 'PFM', $buff);
         # extract the font names
         my $nameOff = Get32u(\$buff, 105);
         if ($raf->Seek($nameOff, 0) and $raf->Read($buff, 256) and
             $buff =~ /^([\x20-\xff]+)\0([\x20-\xff]+)\0/)
         {
-            $exifTool->HandleTag($tagTablePtr, 'fontname', $1);
-            $exifTool->HandleTag($tagTablePtr, 'postfont', $2);
+            $et->HandleTag($tagTablePtr, 'fontname', $1);
+            $et->HandleTag($tagTablePtr, 'postfont', $2);
         }
         $rtnVal = 1;
     } else {

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

@@ -12,7 +12,7 @@ use strict;
 use vars qw($VERSION);
 use Image::ExifTool qw(:DataAccess :Utils);
 
-$VERSION = '1.01';
+$VERSION = '1.02';
 
 sub ProcessFotoStation($$);
 
@@ -118,14 +118,14 @@ my %cropConv = (
 # - updates DirLen to trailer length
 sub ProcessFotoStation($$)
 {
-    my ($exifTool, $dirInfo) = @_;
-    $exifTool or return 1;    # allow dummy access to autoload this package
+    my ($et, $dirInfo) = @_;
+    $et or return 1;    # allow dummy access to autoload this package
     my ($buff, $footer, $dirBuff, $tagTablePtr);
     my $raf = $$dirInfo{RAF};
     my $outfile = $$dirInfo{OutFile};
     my $offset = $$dirInfo{Offset} || 0;
-    my $verbose = $exifTool->Options('Verbose');
-    my $out = $exifTool->Options('TextOut');
+    my $verbose = $et->Options('Verbose');
+    my $out = $et->Options('TextOut');
     my $rtnVal = 0;
 
     $$dirInfo{DirLen} = 0;      # initialize returned trailer length
@@ -151,8 +151,8 @@ sub ProcessFotoStation($$)
         }
         unless ($outfile) {
             # print verbose trailer information
-            if ($verbose or $exifTool->{HTML_DUMP}) {
-                $exifTool->DumpTrailer({
+            if ($verbose or $$et{HTML_DUMP}) {
+                $et->DumpTrailer({
                     RAF => $raf,
                     DataPos => $$dirInfo{DataPos},
                     DirLen => $size + 10,
@@ -160,21 +160,22 @@ sub ProcessFotoStation($$)
                 });
             }
             # extract information for this tag
-            $exifTool->HandleTag($tagTablePtr, $tag, $buff,
-                                 DataPt => \$buff,
-                                 Start => 0,
-                                 Size => $size,
-                                 DataPos => $$dirInfo{DataPos});
+            $et->HandleTag($tagTablePtr, $tag, $buff,
+                DataPt => \$buff,
+                Start => 0,
+                Size => $size,
+                DataPos => $$dirInfo{DataPos},
+            );
             next;
         }
-        if ($exifTool->{DEL_GROUP}->{FotoStation}) {
+        if ($$et{DEL_GROUP}{FotoStation}) {
             $verbose and printf $out "  Deleting FotoStation trailer\n";
             $verbose = 0;   # no more verbose messages after this
-            ++$exifTool->{CHANGED};
+            ++$$et{CHANGED};
             next;
         }
         # rewrite this information
-        my $tagInfo = $exifTool->GetTagInfo($tagTablePtr, $tag);
+        my $tagInfo = $et->GetTagInfo($tagTablePtr, $tag);
         if ($tagInfo) {
             my $newVal;
             my $tagName = $$tagInfo{Name};
@@ -188,18 +189,18 @@ sub ProcessFotoStation($$)
                     Parent => 'FotoStation',
                 );
                 my $subTable = GetTagTable($tagInfo->{SubDirectory}->{TagTable});
-                $newVal = $exifTool->WriteDirectory(\%subdirInfo, $subTable);
+                $newVal = $et->WriteDirectory(\%subdirInfo, $subTable);
             } else {
-                my $nvHash = $exifTool->GetNewValueHash($tagInfo);
-                if ($exifTool->IsOverwriting($nvHash) > 0) {
-                    $newVal = $exifTool->GetNewValues($nvHash);
+                my $nvHash = $et->GetNewValueHash($tagInfo);
+                if ($et->IsOverwriting($nvHash) > 0) {
+                    $newVal = $et->GetNewValues($nvHash);
                     $newVal = '' unless defined $newVal;
                     if ($verbose > 1) {
                         my $n = length $newVal;
                         print $out "    - FotoStation:$tagName ($size bytes)\n" if $size;
                         print $out "    + FotoStation:$tagName ($n bytes)\n" if $n;
                     }
-                    ++$exifTool->{CHANGED};
+                    ++$$et{CHANGED};
                 }
             }
             if (defined $newVal) {

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

@@ -15,6 +15,7 @@
 #                  and http://forum.photome.de/viewtopic.php?f=2&t=353&p=742#p740
 #               7) Kai Lappalainen private communication
 #               8) http://u88.n24.queensu.ca/exiftool/forum/index.php/topic,5223.0.html
+#               9) Iliah Borg private communication
 #               JD) Jens Duttke private communication
 #------------------------------------------------------------------------------
 
@@ -25,7 +26,7 @@ use vars qw($VERSION);
 use Image::ExifTool qw(:DataAccess :Utils);
 use Image::ExifTool::Exif;
 
-$VERSION = '1.42';
+$VERSION = '1.44';
 
 sub ProcessFujiDir($$$);
 sub ProcessFaceRec($$$);
@@ -711,8 +712,9 @@ my %faceCategories = (
         OffsetPair => 0xf007,  # point to associated offsets
     },
     # 0xf009 - values: 0, 3
-    # 0xf00a-0xf00c ?
-    # 0xf00d - similar to 0xf00e
+    # 0xf00a-0xf00b ?
+    0xf00c => 'WB_GRBLevelsStandard', #9 (GRBXGRBX; X=17 is standard illuminant A, X=21 is D65)
+    0xf00d => 'WB_GRBLevelsDaylight', #9
     0xf00e => 'WB_GRBLevels',
     # 0xf00f ?
 );
@@ -769,7 +771,7 @@ my %faceCategories = (
 # Returns: 1
 sub ProcessFaceRec($$$)
 {
-    my ($exifTool, $dirInfo, $tagTablePtr) = @_;
+    my ($et, $dirInfo, $tagTablePtr) = @_;
     my $dataPt = $$dirInfo{DataPt};
     my $dataPos = $$dirInfo{DataPos} + ($$dirInfo{Base} || 0);
     my $dirStart = $$dirInfo{DirStart};
@@ -777,7 +779,7 @@ sub ProcessFaceRec($$$)
     my $pos = $dirStart;
     my $end = $dirStart + $dirLen;
     my ($i, $n, $p, $val);
-    $exifTool->VerboseDir('FaceRecInfo');
+    $et->VerboseDir('FaceRecInfo');
     for ($i=1; ; ++$i) {
         last if $pos + 8 > $end;
         my $off = Get32u($dataPt, $pos) + $dirStart;
@@ -792,7 +794,7 @@ sub ProcessFaceRec($$$)
         $p = Get32u($dataPt, $off + 34) + $dirStart;
         last if $p < $dirStart or $p + $n > $end;
         $val = substr($$dataPt, $p, $n);
-        $exifTool->HandleTag($tagTablePtr, "Face${i}Name", $val,
+        $et->HandleTag($tagTablePtr, "Face${i}Name", $val,
             DataPt  => $dataPt,
             DataPos => $dataPos,
             Start   => $p,
@@ -803,13 +805,13 @@ sub ProcessFaceRec($$$)
         last if $p < $dirStart or $p + $n > $end;
         $val = substr($$dataPt, $p, $n);
         $val =~ s/(\d{4})(\d{2})(\d{2})/$1:$2:$2/;
-        $exifTool->HandleTag($tagTablePtr, "Face${i}Birthday", $val,
+        $et->HandleTag($tagTablePtr, "Face${i}Birthday", $val,
             DataPt  => $dataPt,
             DataPos => $dataPos,
             Start   => $p,
             Size    => $n,
         );
-        $exifTool->HandleTag($tagTablePtr, "Face${i}Category", undef,
+        $et->HandleTag($tagTablePtr, "Face${i}Category", undef,
             DataPt  => $dataPt,
             DataPos => $dataPos,
             Start   => $off + 46,
@@ -826,7 +828,7 @@ sub ProcessFaceRec($$$)
 # Returns: 1 if this was a valid FujiFilm directory
 sub ProcessFujiDir($$$)
 {
-    my ($exifTool, $dirInfo, $tagTablePtr) = @_;
+    my ($et, $dirInfo, $tagTablePtr) = @_;
     my $raf = $$dirInfo{RAF};
     my $offset = $$dirInfo{DirStart};
     $raf->Seek($offset, 0) or return 0;
@@ -834,7 +836,7 @@ sub ProcessFujiDir($$$)
     $raf->Read($buff, 4) or return 0;
     my $entries = unpack 'N', $buff;
     $entries < 256 or return 0;
-    $exifTool->Options('Verbose') and $exifTool->VerboseDir('Fuji', $entries);
+    $et->Options('Verbose') and $et->VerboseDir('Fuji', $entries);
     SetByteOrder('MM');
     my $pos = $offset + 4;
     for ($index=0; $index<$entries; ++$index) {
@@ -843,7 +845,7 @@ sub ProcessFujiDir($$$)
         my ($tag, $len) = unpack 'nn', $buff;
         my ($val, $vbuf);
         $raf->Read($vbuf, $len) or return 0;
-        my $tagInfo = $exifTool->GetTagInfo($tagTablePtr, $tag);
+        my $tagInfo = $et->GetTagInfo($tagTablePtr, $tag);
         if ($tagInfo and $$tagInfo{Format}) {
             $val = ReadValue(\$vbuf, 0, $$tagInfo{Format}, $$tagInfo{Count}, $len);
             next unless defined $val;
@@ -854,7 +856,7 @@ sub ProcessFujiDir($$$)
             # treat other unknown values as binary data
             $val = \$vbuf;
         }
-        $exifTool->HandleTag($tagTablePtr, $tag, $val,
+        $et->HandleTag($tagTablePtr, $tag, $val,
             Index   => $index,
             DataPt  => \$vbuf,
             DataPos => $pos,
@@ -872,7 +874,7 @@ sub ProcessFujiDir($$$)
 # Returns: 1 on success, 0 if this wasn't a valid RAF file, or -1 on write error
 sub WriteRAF($$)
 {
-    my ($exifTool, $dirInfo) = @_;
+    my ($et, $dirInfo) = @_;
     my $raf = $$dirInfo{RAF};
     my ($hdr, $jpeg, $outJpeg, $offset, $err, $buff);
 
@@ -885,31 +887,31 @@ sub WriteRAF($$)
     my ($jpos, $jlen) = unpack('x84NN', $hdr);
     # check to be sure the JPEG starts in the expected location
     if ($jpos > 0x94 or $jpos < 0x68 or $jpos & 0x03) {
-        $exifTool->Error("Unsupported or corrupted RAF image (version $ver)");
+        $et->Error("Unsupported or corrupted RAF image (version $ver)");
         return 1;
     }
     # check to make sure this version of RAF has been tested
     unless ($testedRAF{$ver}) {
-        $exifTool->Warn("RAF version $ver not yet tested", 1);
+        $et->Warn("RAF version $ver not yet tested", 1);
     }
     # read the embedded JPEG
     unless ($raf->Seek($jpos, 0) and $raf->Read($jpeg, $jlen) == $jlen) {
-        $exifTool->Error('Error reading RAF meta information');
+        $et->Error('Error reading RAF meta information');
         return 1;
     }
     # use same write directories as JPEG
-    $exifTool->InitWriteDirs('JPEG');
+    $et->InitWriteDirs('JPEG');
     # rewrite the embedded JPEG in memory
     my %jpegInfo = (
         Parent  => 'RAF',
         RAF     => new File::RandomAccess(\$jpeg),
         OutFile => \$outJpeg,
     );
-    $$exifTool{FILE_TYPE} = 'JPEG';
-    my $success = $exifTool->WriteJPEG(\%jpegInfo);
-    $$exifTool{FILE_TYPE} = 'RAF';
+    $$et{FILE_TYPE} = 'JPEG';
+    my $success = $et->WriteJPEG(\%jpegInfo);
+    $$et{FILE_TYPE} = 'RAF';
     unless ($success and $outJpeg) {
-        $exifTool->Error("Invalid RAF format");
+        $et->Error("Invalid RAF format");
         return 1;
     }
     return -1 if $success < 0;
@@ -930,13 +932,13 @@ sub WriteRAF($$)
             not $raf->Seek($jpos+$jlen, 0) or
             $raf->Read($buff, $oldPadLen) != $oldPadLen)
         {
-            $exifTool->Error('Bad RAF pointer at 0x5c');
+            $et->Error('Bad RAF pointer at 0x5c');
             return 1;
         }
         # make sure padding is only zero bytes (can be >100k for HS10)
         # (have seen non-null padding in X-Pro1)
         if ($buff =~ /[^\0]/) {
-            return 1 if $exifTool->Error('Non-null bytes found in padding', 2);
+            return 1 if $et->Error('Non-null bytes found in padding', 2);
         }
     }
     # calculate offset difference due to change in JPEG size
@@ -955,7 +957,7 @@ sub WriteRAF($$)
     Write($outfile, $outJpeg, $pad) or $err = 1;
     # copy over the rest of the RAF image
     unless ($raf->Seek($nextPtr, 0)) {
-        $exifTool->Error('Error reading RAF image');
+        $et->Error('Error reading RAF image');
         return 1;
     }
     while ($raf->Read($buff, 65536)) {
@@ -970,7 +972,7 @@ sub WriteRAF($$)
 # Returns: 1 if this was a valid RAF file
 sub ProcessRAF($$)
 {
-    my ($exifTool, $dirInfo) = @_;
+    my ($et, $dirInfo) = @_;
     my ($buff, $jpeg, $warn, $offset);
 
     my $raf = $$dirInfo{RAF};
@@ -981,18 +983,18 @@ sub ProcessRAF($$)
     $raf->Seek($jpos, 0)              or return 0;
     $raf->Read($jpeg, $jlen) == $jlen or return 0;
 
-    $exifTool->SetFileType();
-    $exifTool->FoundTag('RAFVersion', substr($buff, 0x3c, 4));
+    $et->SetFileType();
+    $et->FoundTag('RAFVersion', substr($buff, 0x3c, 4));
 
     # extract information from embedded JPEG
     my %dirInfo = (
         Parent => 'RAF',
         RAF    => new File::RandomAccess(\$jpeg),
     );
-    $$exifTool{BASE} += $jpos;
-    my $rtnVal = $exifTool->ProcessJPEG(\%dirInfo);
-    $$exifTool{BASE} -= $jpos;
-    $exifTool->FoundTag('PreviewImage', \$jpeg) if $rtnVal;
+    $$et{BASE} += $jpos;
+    my $rtnVal = $et->ProcessJPEG(\%dirInfo);
+    $$et{BASE} -= $jpos;
+    $et->FoundTag('PreviewImage', \$jpeg) if $rtnVal;
 
     # extract information from Fuji RAF and TIFF directories
     my ($rafNum, $ifdNum) = ('','');
@@ -1010,11 +1012,11 @@ sub ProcessRAF($$)
                 RAF  => $raf,
                 Base => $start,
             );
-            $$exifTool{SET_GROUP1} = "FujiIFD$ifdNum";
+            $$et{SET_GROUP1} = "FujiIFD$ifdNum";
             my $tagTablePtr = GetTagTable('Image::ExifTool::FujiFilm::IFD');
             # this is TIFF-format data only for some models, so no warning if it fails
-            $exifTool->ProcessTIFF(\%dirInfo, $tagTablePtr, \&Image::ExifTool::ProcessTIFF);
-            delete $$exifTool{SET_GROUP1};
+            $et->ProcessTIFF(\%dirInfo, $tagTablePtr, \&Image::ExifTool::ProcessTIFF);
+            delete $$et{SET_GROUP1};
             $ifdNum = ($ifdNum || 1) + 1;
         } else {
             # parse RAF directory
@@ -1022,14 +1024,14 @@ sub ProcessRAF($$)
                 RAF      => $raf,
                 DirStart => $start,
             );
-            $$exifTool{SET_GROUP1} = "RAF$rafNum";
+            $$et{SET_GROUP1} = "RAF$rafNum";
             my $tagTablePtr = GetTagTable('Image::ExifTool::FujiFilm::RAF');
-            $exifTool->ProcessDirectory(\%dirInfo, $tagTablePtr) or $warn = 1;
-            delete $$exifTool{SET_GROUP1};
+            $et->ProcessDirectory(\%dirInfo, $tagTablePtr) or $warn = 1;
+            delete $$et{SET_GROUP1};
             $rafNum = ($rafNum || 1) + 1;
         }
     }
-    $warn and $exifTool->Warn('Possibly corrupt RAF information');
+    $warn and $et->Warn('Possibly corrupt RAF information');
 
     return $rtnVal;
 }