exiftool_vendored 9.37.0 → 9.41.0

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

@@ -16,7 +16,7 @@ use strict;
 use vars qw($VERSION);
 use Image::ExifTool qw(:DataAccess :Utils);
 
-$VERSION = '1.06';
+$VERSION = '1.07';
 
 #------------------------------------------------------------------------------
 # Read or write information in a PPM/PGM/PBM image
@@ -24,11 +24,11 @@ $VERSION = '1.06';
 # Returns: 1 on success, 0 if this wasn't a valid PPM file, -1 on write error
 sub ProcessPPM($$)
 {
-    my ($exifTool, $dirInfo) = @_;
+    my ($et, $dirInfo) = @_;
     my $raf = $$dirInfo{RAF};
     my $outfile = $$dirInfo{OutFile};
-    my $verbose = $exifTool->Options('Verbose');
-    my $out = $exifTool->Options('TextOut');
+    my $verbose = $et->Options('Verbose');
+    my $out = $et->Options('TextOut');
     my ($buff, $num, $type, %info);
 #
 # read as much of the image as necessary to extract the header and comments
@@ -78,19 +78,19 @@ sub ProcessPPM($$)
         $info{Comment} =~ s/^# ?//mg;   # remove "# " at the start of each line
         $info{Comment} =~ s/\n$//;      # remove trailing newline
     }
-    $exifTool->SetFileType($type);
+    $et->SetFileType($type);
     my $len = pos($buff);
 #
 # rewrite the file if requested
 #
     if ($outfile) {
         my $nvHash;
-        my $newComment = $exifTool->GetNewValues('Comment', \$nvHash);
+        my $newComment = $et->GetNewValues('Comment', \$nvHash);
         my $oldComment = $info{Comment};
-        if ($exifTool->IsOverwriting($nvHash, $oldComment)) {
-            ++$exifTool->{CHANGED};
-            $exifTool->VerboseValue('- Comment', $oldComment) if defined $oldComment;
-            $exifTool->VerboseValue('+ Comment', $newComment) if defined $newComment;
+        if ($et->IsOverwriting($nvHash, $oldComment)) {
+            ++$$et{CHANGED};
+            $et->VerboseValue('- Comment', $oldComment) if defined $oldComment;
+            $et->VerboseValue('+ Comment', $newComment) if defined $newComment;
         } else {
             $newComment = $oldComment;  # use existing comment
         }
@@ -118,7 +118,7 @@ sub ProcessPPM($$)
     }
     my $tag;
     foreach $tag (qw{Comment ImageWidth ImageHeight MaxVal}) {
-        $exifTool->FoundTag($tag, $info{$tag}) if defined $info{$tag};
+        $et->FoundTag($tag, $info{$tag}) if defined $info{$tag};
     }
     return 1;
 }

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

@@ -15,7 +15,7 @@ use vars qw($VERSION);
 use Image::ExifTool qw(:DataAccess :Utils);
 use Image::ExifTool::Exif;
 
-$VERSION = '1.03';
+$VERSION = '1.04';
 
 sub ProcessExtData($$$);
 
@@ -162,28 +162,28 @@ sub ProcessExtData($$$);
 # Returns: 1 on success
 sub ProcessExtData($$$)
 {
-    my ($exifTool, $dirInfo, $tagTablePtr) = @_;
+    my ($et, $dirInfo, $tagTablePtr) = @_;
     my $dataPt = $$dirInfo{DataPt};
     my $dirLen = $$dirInfo{DirLen};
     my $pos = 0;
     # loop through sub-blocks
     while ($pos + 10 < $dirLen) {
         unless (substr($$dataPt, $pos, 4) eq "~FL\0") {
-            $exifTool->Warn('Lost synchronization while reading sub blocks');
+            $et->Warn('Lost synchronization while reading sub blocks');
             last;
         }
         my $tag = Get16u($dataPt, $pos + 4);
         my $len = Get32u($dataPt, $pos + 6);
         $pos += 10 + $len;
         if ($pos > $dirLen) {
-            $exifTool->Warn("Truncated sub block ID=$tag len=$len");
+            $et->Warn("Truncated sub block ID=$tag len=$len");
             last;
         }
         next unless $$tagTablePtr{$tag};
-        my $tagInfo = $exifTool->GetTagInfo($tagTablePtr, $tag) or next;
+        my $tagInfo = $et->GetTagInfo($tagTablePtr, $tag) or next;
         my $start = $pos - $len;
         unless ($$tagInfo{Name} eq 'EXIFInfo') {
-            $exifTool->HandleTag($tagTablePtr, $tag, undef,
+            $et->HandleTag($tagTablePtr, $tag, undef,
                 TagInfo => $tagInfo,
                 DataPt  => $dataPt,
                 DataPos => $$dirInfo{DataPos},
@@ -212,7 +212,7 @@ sub ProcessExtData($$$)
             Multi    => 0,
         );
         my $exifTable = GetTagTable($$tagInfo{SubDirectory}{TagTable});
-        Image::ExifTool::Exif::ProcessExif($exifTool, \%dirInfo, $exifTable);
+        Image::ExifTool::Exif::ProcessExif($et, \%dirInfo, $exifTable);
         SetByteOrder('II');
     }
     return 1;
@@ -224,26 +224,26 @@ sub ProcessExtData($$$)
 # Returns: 1 on success, 0 if this wasn't a valid PSP file
 sub ProcessPSP($$)
 {
-    my ($exifTool, $dirInfo) = @_;
+    my ($et, $dirInfo) = @_;
     my $raf = $$dirInfo{RAF};
     my ($buff, $tag, $len, $err);
     return 0 unless $raf->Read($buff, 32) == 32 and
                     $buff eq "Paint Shop Pro Image File\x0a\x1a\0\0\0\0\0" and
                     $raf->Read($buff, 4) == 4;
-    $exifTool->SetFileType();
+    $et->SetFileType();
     SetByteOrder('II');
     my $tagTablePtr = GetTagTable('Image::ExifTool::PSP::Main');
     my @a = unpack('v*', $buff);
     # figure out block header length for this format PSP file
     my $hlen = $a[0] > 3 ? 10 : 14;
-    $$exifTool{PSPFileVersion} = $a[0]; # save for use in Condition
-    $exifTool->HandleTag($tagTablePtr, FileVersion => "@a");
+    $$et{PSPFileVersion} = $a[0]; # save for use in Condition
+    $et->HandleTag($tagTablePtr, FileVersion => "@a");
     # loop through blocks in file
     my $pos = 36;
     for (;;) {
         last unless $raf->Read($buff, $hlen) == $hlen;
         unless ($buff =~ /^~BK\0/) {
-            $exifTool->Warn('Lost synchronization while reading main PSP blocks');
+            $et->Warn('Lost synchronization while reading main PSP blocks');
             last;
         }
         $tag = Get16u(\$buff, 4);
@@ -254,13 +254,13 @@ sub ProcessPSP($$)
             next;
         }
         $raf->Read($buff, $len) == $len or $err=1, last;
-        $exifTool->HandleTag($tagTablePtr, $tag, $buff,
+        $et->HandleTag($tagTablePtr, $tag, $buff,
             DataPt  => \$buff,
             DataPos => $pos - $len,
             Size    => $len,
         );
     }
-    $err and $exifTool->Warn("Truncated main block ID=$tag len=$len");
+    $err and $et->Warn("Truncated main block ID=$tag len=$len");
     return 1;
 }
 

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

@@ -20,7 +20,7 @@
 #              15) Zdenek Mihula private communication (TZ8)
 #              16) Olaf Ulrich private communication
 #              17) http://u88.n24.queensu.ca/exiftool/forum/index.php/topic,4922.0.html
-#              18) Thomas private communication (G6)
+#              18) Thomas Modes private communication (G6)
 #              JD) Jens Duttke private communication (TZ3,FZ30,FZ50)
 #------------------------------------------------------------------------------
 
@@ -31,7 +31,7 @@ use vars qw($VERSION %leicaLensTypes);
 use Image::ExifTool qw(:DataAccess :Utils);
 use Image::ExifTool::Exif;
 
-$VERSION = '1.76';
+$VERSION = '1.78';
 
 sub ProcessPanasonicType2($$$);
 sub WhiteBalanceConv($;$$);
@@ -940,6 +940,11 @@ my %shootingMode = (
         },
     },
     # 0x7a,0x7b: 0
+    0x7c => { #18
+        Name => 'ClearRetouch',
+        Writable => 'int16u',
+        PrintConv => { 0 => 'Off', 1 => 'On' },
+    },
     0x86 => { #http://dev.exiv2.org/issues/825
         Name => 'ManometerPressure',
         Writable => 'int16u',
@@ -962,6 +967,40 @@ my %shootingMode = (
             6 => 'Portrait',
         },
     },
+    0x8c => {
+        Name => 'AccelerometerZ',
+        Writable => 'int16u',
+        Format => 'int16s',
+        Notes => 'positive is acceleration upwards',
+    },
+    0x8d => {
+        Name => 'AccelerometerX',
+        Writable => 'int16u',
+        Format => 'int16s',
+        Notes => 'positive is acceleration to the left',
+    },
+    0x8e => {
+        Name => 'AccelerometerY',
+        Writable => 'int16u',
+        Format => 'int16s',
+        Notes => 'positive is acceleration backwards',
+    },
+    0x90 => {
+        Name => 'RollAngle',
+        Writable => 'int16u',
+        Format => 'int16s',
+        Notes => 'degrees of clockwise camera rotation',
+        ValueConv => '$val / 10',
+        ValueConvInv => '$val * 10',
+    },
+    0x91 => {
+        Name => 'PitchAngle',
+        Writable => 'int16u',
+        Format => 'int16s',
+        Notes => 'degrees of upward camera tilt',
+        ValueConv => '-$val / 10',
+        ValueConvInv => '-$val * 10',
+    },
     0x96 => { #18
         Name => 'TimerRecording',
         Writable => 'int8u',
@@ -990,8 +1029,14 @@ my %shootingMode = (
         PrintConv => {
             0 => 'Mechanical',
             1 => 'Electronic',
+            2 => 'Hybrid', #PH (GM1, 1st curtain electronic, 2nd curtain mechanical)
         },
     },
+    0xa3 => { #18
+        Name => 'ClearRetouchValue',
+        Writable => 'rational64u',
+        # undef if ClearRetouch is off, 0 if it is on
+    },
     0xab => { #18
         Name => 'TouchAE',
         Writable => 'int16u',
@@ -1844,38 +1889,38 @@ sub WhiteBalanceConv($;$$)
 # - deletes LeicaTrailer member and sets LeicaTrailerPos when successful
 sub ProcessLeicaTrailer($;$)
 {
-    my ($exifTool, $newPos) = @_;
-    my $trail = $$exifTool{LeicaTrailer};
-    my $raf = $$exifTool{RAF};
+    my ($et, $newPos) = @_;
+    my $trail = $$et{LeicaTrailer};
+    my $raf = $$et{RAF};
     my $trailPos = $$trail{TrailPos};
     my $pos = $trailPos || $$trail{Offset};
     my $len = $$trail{TrailLen} || $$trail{Size};
     my ($buff, $result, %tagPtr);
 
-    delete $$exifTool{LeicaTrailer} if $trailPos;   # done after this
+    delete $$et{LeicaTrailer} if $trailPos;   # done after this
     unless ($len > 0) {
-        $exifTool->Warn('Missing Leica MakerNote trailer', 1) if $trailPos;
-        delete $$exifTool{LeicaTrailer};
+        $et->Warn('Missing Leica MakerNote trailer', 1) if $trailPos;
+        delete $$et{LeicaTrailer};
         return undef;
     }
     my $oldPos = $raf->Tell();
     my $ok = ($raf->Seek($pos, 0) and $raf->Read($buff, $len) == $len);
     $raf->Seek($oldPos, 0);
     unless ($ok) {
-        $exifTool->Warn('Error reading Leica MakerNote trailer', 1) if $trailPos;
+        $et->Warn('Error reading Leica MakerNote trailer', 1) if $trailPos;
         return undef;
     }
     # look for Leica MakerNote header (should be at start of
     # trailer, but allow up to 256 bytes of garbage just in case)
     if ($buff !~ /^(.{0,256})LEICA\0..../sg) {
         my $what = $trailPos ? 'trailer' : 'offset';
-        $exifTool->Warn("Invalid Leica MakerNote $what", 1);
+        $et->Warn("Invalid Leica MakerNote $what", 1);
         return undef;
     }
     my $junk = $1;
     my $start = pos($buff) - 10;
     if ($start and not $trailPos) {
-        $exifTool->Warn('Invalid Leica MakerNote offset', 1);
+        $et->Warn('Invalid Leica MakerNote offset', 1);
         return undef;
     }
 #
@@ -1884,17 +1929,17 @@ sub ProcessLeicaTrailer($;$)
     my $hdrLen = 8;
     my $dirStart = $start + $hdrLen;
     my $tagInfo = $$trail{TagInfo};
-    if ($$exifTool{HTML_DUMP}) {
+    if ($$et{HTML_DUMP}) {
         my $name = $$tagInfo{Name};
-        $exifTool->HDump($pos+$start, $len-$start, "$name value", 'Leica MakerNote trailer', 4);
-        $exifTool->HDump($pos+$start, $hdrLen, "MakerNotes header", $name);
-    } elsif ($exifTool->Options('Verbose')) {
+        $et->HDump($pos+$start, $len-$start, "$name value", 'Leica MakerNote trailer', 4);
+        $et->HDump($pos+$start, $hdrLen, "MakerNotes header", $name);
+    } elsif ($et->Options('Verbose')) {
         my $where = sprintf('at offset 0x%x', $pos);
-        $exifTool->VPrint(0, "Leica MakerNote trailer ($len bytes $where):\n");
+        $et->VPrint(0, "Leica MakerNote trailer ($len bytes $where):\n");
     }
     # delete LeicaTrailer member so we don't try to process it again
-    delete $$exifTool{LeicaTrailer};
-    $$exifTool{LeicaTrailerPos} = $pos + $start;    # return actual start position of Leica trailer
+    delete $$et{LeicaTrailer};
+    $$et{LeicaTrailerPos} = $pos + $start;    # return actual start position of Leica trailer
 
     my $oldOrder = GetByteOrder();
     my $num = Get16u(\$buff, $dirStart);            # get entry count
@@ -1916,7 +1961,7 @@ sub ProcessLeicaTrailer($;$)
             my $diff = $minPtr - ($valStart + $pos);
             pos($buff) = $valStart;
             my $expect;
-            if ($$exifTool{Model} eq 'S2') {
+            if ($$et{Model} eq 'S2') {
                 # scan value data for the first non-zero byte
                 if ($buff =~ /[^\0]/g) {
                     my $n = pos($buff) - 1 - $valStart; # number of zero bytes
@@ -1929,16 +1974,16 @@ sub ProcessLeicaTrailer($;$)
                     $expect = 114;
                 }
             }
-            my $fixBase = $exifTool->Options('FixBase');
+            my $fixBase = $et->Options('FixBase');
             if (not defined $expect) {
-                $exifTool->Warn('Unrecognized Leica trailer structure');
+                $et->Warn('Unrecognized Leica trailer structure');
             } elsif ($diff != $expect or defined $fixBase) {
                 $fix = $expect - $diff;
                 if (defined $fixBase) {
                     $fix = $fixBase if $fixBase ne '';
-                    $exifTool->Warn("Adjusted MakerNotes base by $fix",1);
+                    $et->Warn("Adjusted MakerNotes base by $fix",1);
                 } else {
-                    $exifTool->Warn("Possibly incorrect maker notes offsets (fixed by $fix)",1);
+                    $et->Warn("Possibly incorrect maker notes offsets (fixed by $fix)",1);
                 }
             }
         }
@@ -1958,16 +2003,16 @@ sub ProcessLeicaTrailer($;$)
     );
     my $tagTablePtr = GetTagTable($$tagInfo{SubDirectory}{TagTable});
     if ($newPos) { # are we writing?
-        if ($$exifTool{Model} ne 'S2') {
-            $exifTool->Warn('Leica MakerNote trailer too messed up to edit.  Copying as a block', 1);
+        if ($$et{Model} ne 'S2') {
+            $et->Warn('Leica MakerNote trailer too messed up to edit.  Copying as a block', 1);
             return $buff;
         }
         # set position of new MakerNote IFD (+ 8 for Leica MakerNote header)
         $dirInfo{NewDataPos} = $newPos + $start + 8;
-        $result = $exifTool->WriteDirectory(\%dirInfo, $tagTablePtr);
+        $result = $et->WriteDirectory(\%dirInfo, $tagTablePtr);
         # write preview image last if necessary and fix up the preview offsets
-        my $previewInfo = $$exifTool{PREVIEW_INFO};
-        delete $$exifTool{PREVIEW_INFO};
+        my $previewInfo = $$et{PREVIEW_INFO};
+        delete $$et{PREVIEW_INFO};
         if ($result) {
             if ($previewInfo) {
                 my $fixup = $previewInfo->{Fixup};
@@ -1979,23 +2024,23 @@ sub ProcessLeicaTrailer($;$)
         }
     } else {
         # extract information
-        $result = $exifTool->ProcessDirectory(\%dirInfo, $tagTablePtr);
+        $result = $et->ProcessDirectory(\%dirInfo, $tagTablePtr);
         # also extract as a block if necessary
-        if ($exifTool->Options('MakerNotes') or
-            $exifTool->{REQ_TAG_LOOKUP}{lc($$tagInfo{Name})})
+        if ($et->Options('MakerNotes') or
+            $$et{REQ_TAG_LOOKUP}{lc($$tagInfo{Name})})
         {
             # makernote header must be included in RebuildMakerNotes call
             $dirInfo{DirStart} -= 8;
             $dirInfo{DirLen} += 8;
-            $exifTool->{MAKER_NOTE_BYTE_ORDER} = GetByteOrder();
-            # rebuild maker notes (creates $exifTool->{MAKER_NOTE_FIXUP})
-            my $val = Image::ExifTool::Exif::RebuildMakerNotes($exifTool, $tagTablePtr, \%dirInfo);
+            $$et{MAKER_NOTE_BYTE_ORDER} = GetByteOrder();
+            # rebuild maker notes (creates $$et{MAKER_NOTE_FIXUP})
+            my $val = Image::ExifTool::Exif::RebuildMakerNotes($et, $tagTablePtr, \%dirInfo);
             unless (defined $val) {
-                $exifTool->Warn('Error rebuilding maker notes (may be corrupt)') if $len > 4;
+                $et->Warn('Error rebuilding maker notes (may be corrupt)') if $len > 4;
                 $val = $buff,
             }
-            my $key = $exifTool->FoundTag($tagInfo, $val);
-            $exifTool->SetGroup($key, 'ExifIFD');
+            my $key = $et->FoundTag($tagInfo, $val);
+            $et->SetGroup($key, 'ExifIFD');
         }
     }
     SetByteOrder($oldOrder);

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

@@ -19,7 +19,7 @@ use vars qw($VERSION);
 use Image::ExifTool qw(:DataAccess :Utils);
 use Image::ExifTool::Exif;
 
-$VERSION = '1.05';
+$VERSION = '1.06';
 
 sub ProcessJpgFromRaw($$$);
 sub WriteJpgFromRaw($$$);
@@ -159,7 +159,7 @@ my %jpgFromRawMap = (
     },
     0x118 => {
         Name => 'RawDataOffset', #PH (RW2/RWL)
-        IsOffset => '$$exifTool{TIFF_TYPE} =~ /^(RW2|RWL)$/', # (invalid in DNG-converted files)
+        IsOffset => '$$et{TIFF_TYPE} =~ /^(RW2|RWL)$/', # (invalid in DNG-converted files)
         PanasonicHack => 1,
         OffsetPair => 0x117, # (use StripByteCounts as the offset pair)
     },
@@ -314,7 +314,7 @@ sub Checksum($$$$)
 # Returns: 1 on success
 sub ProcessDistortionInfo($$$)
 {
-    my ($exifTool, $dirInfo, $tagTablePtr) = @_;
+    my ($et, $dirInfo, $tagTablePtr) = @_;
     my $dataPt = $$dirInfo{DataPt};
     my $start = $$dirInfo{DirStart} || 0;
     my $size = $$dirInfo{DataLen} || (length($$dataPt) - $start);
@@ -328,11 +328,11 @@ sub ProcessDistortionInfo($$$)
                   $csum2 ^ Get16u($dataPt, $start + 28) ^
                   $csum3 ^ Get16u($dataPt, $start + 0) ^
                   $csum4 ^ Get16u($dataPt, $start + 30);
-        $exifTool->Warn('Invalid DistortionInfo checksum',1) if $res;
+        $et->Warn('Invalid DistortionInfo checksum',1) if $res;
     } else {
-        $exifTool->Warn('Invalid DistortionInfo',1);
+        $et->Warn('Invalid DistortionInfo',1);
     }
-    return $exifTool->ProcessBinaryData($dirInfo, $tagTablePtr);
+    return $et->ProcessBinaryData($dirInfo, $tagTablePtr);
 }
 
 #------------------------------------------------------------------------------
@@ -341,9 +341,9 @@ sub ProcessDistortionInfo($$$)
 # Returns: updated distortion information or undef on error
 sub WriteDistortionInfo($$$)
 {
-    my ($exifTool, $dirInfo, $tagTablePtr) = @_;
-    $exifTool or return 1;  # (allow dummy access)
-    my $dat = $exifTool->WriteBinaryData($dirInfo, $tagTablePtr);
+    my ($et, $dirInfo, $tagTablePtr) = @_;
+    $et or return 1;  # (allow dummy access)
+    my $dat = $et->WriteBinaryData($dirInfo, $tagTablePtr);
     if (defined $dat and length($dat) == 32) {
         # fix checksums (ref 3)
         Set16u(Checksum(\$dat,  4, 12, 1), \$dat,  2);
@@ -351,7 +351,7 @@ sub WriteDistortionInfo($$$)
         Set16u(Checksum(\$dat,  2, 14, 2), \$dat,  0);
         Set16u(Checksum(\$dat,  3, 14, 2), \$dat, 30);
     } else {
-        $exifTool->Warn('Error wriing DistortionInfo',1);
+        $et->Warn('Error wriing DistortionInfo',1);
     }
     return $dat;
 }
@@ -412,10 +412,10 @@ sub PatchRawDataOffset($$$)
 # Returns: updated image data, or undef if nothing changed
 sub WriteJpgFromRaw($$$)
 {
-    my ($exifTool, $dirInfo, $tagTablePtr) = @_;
+    my ($et, $dirInfo, $tagTablePtr) = @_;
     my $dataPt = $$dirInfo{DataPt};
     my $byteOrder = GetByteOrder();
-    my $fileType = $$exifTool{FILE_TYPE};   # RAW, RW2 or RWL
+    my $fileType = $$et{FILE_TYPE};   # RAW, RW2 or RWL
     my $dirStart = $$dirInfo{DirStart};
     if ($dirStart) { # DirStart is non-zero in DNG-converted RW2/RWL
         my $dirLen = $$dirInfo{DirLen} | length($$dataPt) - $dirStart;
@@ -428,21 +428,21 @@ sub WriteJpgFromRaw($$$)
         RAF => $raf,
         OutFile => \$outbuff,
     );
-    $$exifTool{BASE} = $$dirInfo{DataPos};
-    $$exifTool{FILE_TYPE} = $$exifTool{TIFF_TYPE} = 'JPEG';
+    $$et{BASE} = $$dirInfo{DataPos};
+    $$et{FILE_TYPE} = $$et{TIFF_TYPE} = 'JPEG';
     # use a specialized map so we don't write XMP or IPTC (or other junk) into the JPEG
-    my $editDirs = $$exifTool{EDIT_DIRS};
-    my $addDirs = $$exifTool{ADD_DIRS};
-    $exifTool->InitWriteDirs(\%jpgFromRawMap);
+    my $editDirs = $$et{EDIT_DIRS};
+    my $addDirs = $$et{ADD_DIRS};
+    $et->InitWriteDirs(\%jpgFromRawMap);
     # don't add XMP segment (IPTC won't get added because it is in Photoshop record)
-    delete $$exifTool{ADD_DIRS}{XMP};
-    my $result = $exifTool->WriteJPEG(\%dirInfo);
+    delete $$et{ADD_DIRS}{XMP};
+    my $result = $et->WriteJPEG(\%dirInfo);
     # restore variables we changed
-    $$exifTool{BASE} = 0;
-    $$exifTool{FILE_TYPE} = 'TIFF';
-    $$exifTool{TIFF_TYPE} = $fileType;
-    $$exifTool{EDIT_DIRS} = $editDirs;
-    $$exifTool{ADD_DIRS} = $addDirs;
+    $$et{BASE} = 0;
+    $$et{FILE_TYPE} = 'TIFF';
+    $$et{TIFF_TYPE} = $fileType;
+    $$et{EDIT_DIRS} = $editDirs;
+    $$et{ADD_DIRS} = $addDirs;
     SetByteOrder($byteOrder);
     return $result > 0 ? $outbuff : $$dataPt;
 }
@@ -453,43 +453,43 @@ sub WriteJpgFromRaw($$$)
 # Returns: 1 on success, 0 if this wasn't a valid JpgFromRaw image
 sub ProcessJpgFromRaw($$$)
 {
-    my ($exifTool, $dirInfo, $tagTablePtr) = @_;
+    my ($et, $dirInfo, $tagTablePtr) = @_;
     my $dataPt = $$dirInfo{DataPt};
     my $byteOrder = GetByteOrder();
-    my $fileType = $$exifTool{FILE_TYPE};   # RAW, RW2 or RWL
+    my $fileType = $$et{FILE_TYPE};   # RAW, RW2 or RWL
     my $tagInfo = $$dirInfo{TagInfo};
-    my $verbose = $exifTool->Options('Verbose');
+    my $verbose = $et->Options('Verbose');
     my ($indent, $out);
-    $tagInfo or $exifTool->Warn('No tag info for Panasonic JpgFromRaw'), return 0;
+    $tagInfo or $et->Warn('No tag info for Panasonic JpgFromRaw'), return 0;
     my $dirStart = $$dirInfo{DirStart};
     if ($dirStart) { # DirStart is non-zero in DNG-converted RW2/RWL
         my $dirLen = $$dirInfo{DirLen} | length($$dataPt) - $dirStart;
         my $buff = substr($$dataPt, $dirStart, $dirLen);
         $dataPt = \$buff;
     }
-    $$exifTool{BASE} = $$dirInfo{DataPos} + ($dirStart || 0);
-    $$exifTool{FILE_TYPE} = $$exifTool{TIFF_TYPE} = 'JPEG';
-    $$exifTool{DOC_NUM} = 1;
+    $$et{BASE} = $$dirInfo{DataPos} + ($dirStart || 0);
+    $$et{FILE_TYPE} = $$et{TIFF_TYPE} = 'JPEG';
+    $$et{DOC_NUM} = 1;
     # extract information from embedded JPEG
     my %dirInfo = (
         Parent => 'RAF',
         RAF    => new File::RandomAccess($dataPt),
     );
     if ($verbose) {
-        my $indent = $$exifTool{INDENT};
-        $$exifTool{INDENT} = '  ';
-        $out = $exifTool->Options('TextOut');
+        my $indent = $$et{INDENT};
+        $$et{INDENT} = '  ';
+        $out = $et->Options('TextOut');
         print $out '--- DOC1:JpgFromRaw ',('-'x56),"\n";
     }
-    my $rtnVal = $exifTool->ProcessJPEG(\%dirInfo);
+    my $rtnVal = $et->ProcessJPEG(\%dirInfo);
     # restore necessary variables for continued RW2/RWL processing
-    $$exifTool{BASE} = 0;
-    $$exifTool{FILE_TYPE} = 'TIFF';
-    $$exifTool{TIFF_TYPE} = $fileType;
-    delete $$exifTool{DOC_NUM};
+    $$et{BASE} = 0;
+    $$et{FILE_TYPE} = 'TIFF';
+    $$et{TIFF_TYPE} = $fileType;
+    delete $$et{DOC_NUM};
     SetByteOrder($byteOrder);
     if ($verbose) {
-        $$exifTool{INDENT} = $indent;
+        $$et{INDENT} = $indent;
         print $out ('-'x76),"\n";
     }
     return $rtnVal;