exiftool_vendored 9.37.0 → 9.41.0

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

@@ -14,7 +14,7 @@ use strict;
 use vars qw($VERSION);
 use Image::ExifTool qw(:DataAccess :Utils);
 
-$VERSION = '1.01';
+$VERSION = '1.02';
 
 sub ReadBencode($$);
 sub ExtractTags($$$;$$@);
@@ -183,7 +183,7 @@ sub ReadBencode($$)
 # Returns: number of tags extracted
 sub ExtractTags($$$;$$@)
 {
-    my ($exifTool, $hashPtr, $tagTablePtr, $baseID, $baseName, @index) = @_;
+    my ($et, $hashPtr, $tagTablePtr, $baseID, $baseName, @index) = @_;
     my $count = 0;
     my $tag;
     foreach $tag (sort keys %$hashPtr) {
@@ -198,9 +198,9 @@ sub ExtractTags($$$;$$@)
                 $name = "Tag$name" if length($name) < 2 or $name !~ /^[A-Z]/;
                 $name = $baseName . $name if defined $baseName; # add base name if necessary
                 AddTagToTable($tagTablePtr, $id, { Name => $name });
-                $exifTool->VPrint(0, "  [adding $id '$name']\n");
+                $et->VPrint(0, "  [adding $id '$name']\n");
             }
-            my $tagInfo = $exifTool->GetTagInfo($tagTablePtr, $id) or next;
+            my $tagInfo = $et->GetTagInfo($tagTablePtr, $id) or next;
             if (ref $val eq 'ARRAY') {
                 if ($$tagInfo{JoinPath}) {
                     $val = join '/', @$val;
@@ -229,7 +229,7 @@ sub ExtractTags($$$;$$@)
                     }
                     AddTagToTable($tagTablePtr, $id, { %$tagInfo, Name => $name });
                 }
-                $tagInfo = $exifTool->GetTagInfo($tagTablePtr, $id) or next;
+                $tagInfo = $et->GetTagInfo($tagTablePtr, $id) or next;
             }
             if (ref $val eq 'HASH') {
                 # extract tags from this dictionary
@@ -242,10 +242,10 @@ sub ExtractTags($$$;$$@)
                     $rootID = $id;
                     $rootName = $$tagInfo{Name};
                 }
-                $count += ExtractTags($exifTool, $val, $table, $rootID, $rootName, @index);
+                $count += ExtractTags($et, $val, $table, $rootID, $rootName, @index);
             } else {
                 # handle this simple tag value
-                $exifTool->HandleTag($tagTablePtr, $id, $val);
+                $et->HandleTag($tagTablePtr, $id, $val);
                 ++$count;
             }
         }
@@ -260,18 +260,18 @@ sub ExtractTags($$$;$$@)
 # Returns: 1 on success, 0 if this wasn't a valid BitTorrent file
 sub ProcessTorrent($$)
 {
-    my ($exifTool, $dirInfo) = @_;
+    my ($et, $dirInfo) = @_;
     my $success = 0;
     my $raf = $$dirInfo{RAF};
     my $buff = '';
     pos($buff) = 0;
     my $dict = ReadBencode($raf, \$buff);
     my $err = $$raf{BencodeError};
-    $exifTool->Warn("Bencode error: $err") if $err;
+    $et->Warn("Bencode error: $err") if $err;
     if (ref $dict eq 'HASH' and $$dict{announce}) {
-        $exifTool->SetFileType('TORRENT');
+        $et->SetFileType('TORRENT');
         my $tagTablePtr = GetTagTable('Image::ExifTool::Torrent::Main');
-        ExtractTags($exifTool, $dict, $tagTablePtr) and $success = 1;
+        ExtractTags($et, $dict, $tagTablePtr) and $success = 1;
     }
     return $success;
 }

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

@@ -17,7 +17,7 @@ use strict;
 use vars qw($VERSION);
 use Image::ExifTool qw(:DataAccess :Utils);
 
-$VERSION = '1.06';
+$VERSION = '1.07';
 
 sub ProcessComments($$$);
 
@@ -139,7 +139,7 @@ Image::ExifTool::AddCompositeTags('Image::ExifTool::Vorbis');
 # Returns: 1 on success, otherwise returns 0 and sets a Warning
 sub ProcessComments($$$)
 {
-    my ($exifTool, $dirInfo, $tagTablePtr) = @_;
+    my ($et, $dirInfo, $tagTablePtr) = @_;
     my $dataPt = $$dirInfo{DataPt};
     my $dataPos = $$dirInfo{DataPos};
     my $pos = $$dirInfo{DirStart} || 0;
@@ -165,7 +165,7 @@ sub ProcessComments($$$)
             $tag = 'vendor';
             $val = $buff;
             $num = ($pos + 4 < $end) ? Get32u($dataPt, $pos) : 0;
-            $exifTool->VPrint(0, "  + [Vorbis comments with $num entries]\n");
+            $et->VPrint(0, "  + [Vorbis comments with $num entries]\n");
             $pos += 4;
         }
         # add tag to table unless it exists already
@@ -176,7 +176,7 @@ sub ProcessComments($$$)
             $name =~ s/([a-z0-9])_([a-z])/$1\U$2/g;
             AddTagToTable($tagTablePtr, $tag, { Name => $name });
         }
-        $exifTool->HandleTag($tagTablePtr, $tag, $exifTool->Decode($val, 'UTF8'),
+        $et->HandleTag($tagTablePtr, $tag, $et->Decode($val, 'UTF8'),
             Index   => $index,
             DataPt  => $dataPt,
             DataPos => $dataPos,
@@ -187,7 +187,7 @@ sub ProcessComments($$$)
         $num-- or return 1;
         $index = (defined $index) ? $index + 1 : 0;
     }
-    $exifTool->Warn('Format error in Vorbis comments');
+    $et->Warn('Format error in Vorbis comments');
     return 0;
 }
 

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

@@ -60,8 +60,8 @@ my %mapRotation = (
 # Inputs: 0) ExifTool object reference
 sub InitMakerNotes($)
 {
-    my $exifTool = shift;
-    $exifTool->{MAKER_NOTE_INFO} = {
+    my $et = shift;
+    $$et{MAKER_NOTE_INFO} = {
         Entries => { },     # directory entries keyed by tagID
         ValBuff => "\0\0\0\0", # value data buffer (start with zero nextIFD pointer)
         FixupTags => { },   # flags for tags with data in value buffer
@@ -76,7 +76,7 @@ sub InitMakerNotes($)
 # file, which isn't sequential (but Canon's version isn't sequential either...)
 sub BuildMakerNotes($$$$$$)
 {
-    my ($exifTool, $rawTag, $tagInfo, $valuePt, $formName, $count) = @_;
+    my ($et, $rawTag, $tagInfo, $valuePt, $formName, $count) = @_;
 
     my $tagID = $mapRawTag{$rawTag} || return;
     $formName or warn(sprintf "No format for tag 0x%x!\n",$rawTag), return;
@@ -100,7 +100,7 @@ sub BuildMakerNotes($$$$$$)
         $value = $$valuePt;
     }
     my $offsetVal;
-    my $makerInfo = $exifTool->{MAKER_NOTE_INFO};
+    my $makerInfo = $$et{MAKER_NOTE_INFO};
     if ($size > 4) {
         my $len = length $makerInfo->{ValBuff};
         $offsetVal = Set32u($len);
@@ -122,10 +122,10 @@ sub BuildMakerNotes($$$$$$)
 # Inputs: 0) ExifTool object reference
 sub SaveMakerNotes($)
 {
-    my $exifTool = shift;
+    my $et = shift;
     # save maker notes
-    my $makerInfo = $exifTool->{MAKER_NOTE_INFO};
-    delete $exifTool->{MAKER_NOTE_INFO};
+    my $makerInfo = $$et{MAKER_NOTE_INFO};
+    delete $$et{MAKER_NOTE_INFO};
     my $dirEntries = $makerInfo->{Entries};
     my $numEntries = scalar(keys %$dirEntries);
     my $fixup = new Image::ExifTool::Fixup;
@@ -142,24 +142,24 @@ sub SaveMakerNotes($)
     }
     # save position of maker notes for pointer fixups
     $fixup->{Shift} += length($makerNotes);
-    $exifTool->{MAKER_NOTE_FIXUP} = $fixup;
-    $exifTool->{MAKER_NOTE_BYTE_ORDER} = GetByteOrder();
+    $$et{MAKER_NOTE_FIXUP} = $fixup;
+    $$et{MAKER_NOTE_BYTE_ORDER} = GetByteOrder();
     # add value data
     $makerNotes .= $makerInfo->{ValBuff};
     # get MakerNotes tag info
     my $tagTablePtr = Image::ExifTool::GetTagTable('Image::ExifTool::Exif::Main');
-    my $tagInfo = $exifTool->GetTagInfo($tagTablePtr, 0x927c, \$makerNotes);
+    my $tagInfo = $et->GetTagInfo($tagTablePtr, 0x927c, \$makerNotes);
     # save the MakerNotes
-    $exifTool->FoundTag($tagInfo, $makerNotes);
+    $et->FoundTag($tagInfo, $makerNotes);
     # save the garbage collection some work later
     delete $makerInfo->{Entries};
     delete $makerInfo->{ValBuff};
     delete $makerInfo->{FixupTags};
     # also generate Orientation tag since Rotation isn't transferred from RAW info
-    my $rotation = $exifTool->GetValue('Rotation', 'ValueConv');
+    my $rotation = $et->GetValue('Rotation', 'ValueConv');
     if (defined $rotation and defined $mapRotation{$rotation}) {
-        $tagInfo = $exifTool->GetTagInfo($tagTablePtr, 0x112);
-        $exifTool->FoundTag($tagInfo, $mapRotation{$rotation});
+        $tagInfo = $et->GetTagInfo($tagTablePtr, 0x112);
+        $et->FoundTag($tagInfo, $mapRotation{$rotation});
     }
 }
 
@@ -170,10 +170,10 @@ sub SaveMakerNotes($)
 # Returns: error string or undef (and may change value) on success
 sub CheckCanonRaw($$$)
 {
-    my ($exifTool, $tagInfo, $valPtr) = @_;
+    my ($et, $tagInfo, $valPtr) = @_;
     my $tagName = $$tagInfo{Name};
     if ($tagName eq 'JpgFromRaw' or $tagName eq 'ThumbnailImage') {
-        unless ($$valPtr =~ /^\xff\xd8/ or $exifTool->Options('IgnoreMinorErrors')) {
+        unless ($$valPtr =~ /^\xff\xd8/ or $et->Options('IgnoreMinorErrors')) {
             return '[minor] Not a valid image';
         }
     } else {
@@ -195,7 +195,7 @@ sub CheckCanonRaw($$$)
 # Returns: true on success
 sub WriteCR2($$$)
 {
-    my ($exifTool, $dirInfo, $tagTablePtr) = @_;
+    my ($et, $dirInfo, $tagTablePtr) = @_;
     my $dataPt = $$dirInfo{DataPt} or return 0;
     my $outfile = $$dirInfo{OutFile} or return 0;
     $$dirInfo{RAF} or return 0;
@@ -211,15 +211,15 @@ sub WriteCR2($$$)
         } else {
             $msg = 'Unrecognized Canon RAW file';
         }
-        return 0 if $exifTool->Error($msg, $minor);
+        return 0 if $et->Error($msg, $minor);
     }
 
     # CR2 has a 16-byte header
     $$dirInfo{NewDataPos} = 16;
-    my $newData = $exifTool->WriteDirectory($dirInfo, $tagTablePtr);
+    my $newData = $et->WriteDirectory($dirInfo, $tagTablePtr);
     return 0 unless defined $newData;
     unless ($$dirInfo{LastIFD}) {
-        $exifTool->Error("CR2 image IFD may not be deleted");
+        $et->Error("CR2 image IFD may not be deleted");
         return 0;
     }
 
@@ -235,7 +235,7 @@ sub WriteCR2($$$)
 
         # copy over image data now if necessary
         if (ref $$dirInfo{ImageData}) {
-            $exifTool->CopyImageData($$dirInfo{ImageData}, $outfile) or return 0;
+            $et->CopyImageData($$dirInfo{ImageData}, $outfile) or return 0;
             delete $$dirInfo{ImageData};
         }
     }
@@ -255,16 +255,16 @@ sub WriteCR2($$$)
 # OutFile on the fly --> much faster, efficient, and less demanding on memory!
 sub WriteCanonRaw($$$)
 {
-    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
     my $blockStart = $$dirInfo{DirStart};
     my $blockSize = $$dirInfo{DirLen};
     my $raf = $$dirInfo{RAF} or return 0;
     my $outfile = $$dirInfo{OutFile} or return 0;
     my $outPos = $$dirInfo{OutPos} or return 0;
     my $outBase = $outPos;
-    my $verbose = $exifTool->Options('Verbose');
-    my $out = $exifTool->Options('TextOut');
+    my $verbose = $et->Options('Verbose');
+    my $out = $et->Options('TextOut');
     my ($buff, $tagInfo);
 
     # 4 bytes at end of block give directory position within block
@@ -279,7 +279,7 @@ sub WriteCanonRaw($$$)
     my $newDir = '';
 
     # get hash of new information keyed by tagID
-    my $newTags = $exifTool->GetNewTagInfoHash($tagTablePtr);
+    my $newTags = $et->GetNewTagInfoHash($tagTablePtr);
 
     # generate list of tags to add or delete (currently, we only allow JpgFromRaw
     # and ThumbnailImage, to be added or deleted from the root CanonRaw directory)
@@ -307,7 +307,7 @@ sub WriteCanonRaw($$$)
         if (@addTags and (not defined($tag) or $tag >= $addTags[0])) {
             my $addTag = shift @addTags;
             $tagInfo = $$newTags{$addTag};
-            my $newVal = $exifTool->GetNewValues($tagInfo);
+            my $newVal = $et->GetNewValues($tagInfo);
             if (defined $newVal) {
                 # pad value to an even length (Canon ImageBrowser and ZoomBrowser
                 # version 6.1.1 have problems with odd-sized embedded JPEG images
@@ -321,7 +321,7 @@ sub WriteCanonRaw($$$)
                 Write($outfile, $newVal) or return 0;
                 $outPos += length($newVal);     # update current position
                 $verbose > 1 and print $out "    + CanonRaw:$$tagInfo{Name}\n";
-                ++$exifTool->{CHANGED};
+                ++$$et{CHANGED};
             }
             # set flag to delete this tag if found later
             $delTag{$addTag} = 1;
@@ -332,7 +332,7 @@ sub WriteCanonRaw($$$)
         my $tagType = ($tag >> 8) & 0x38;   # get tag type
         my $valueInDir = ($tag & 0x4000);   # flag for value in directory
 
-        my $tagInfo = $exifTool->GetTagInfo($tagTablePtr,$tagID);
+        my $tagInfo = $et->GetTagInfo($tagTablePtr,$tagID);
         my $format = $crwTagFormat{$tagType};
         my ($count, $subdir);
         if ($tagInfo) {
@@ -363,7 +363,7 @@ sub WriteCanonRaw($$$)
                     OutFile  => $outfile,
                     OutPos   => $outPos,
                 );
-                my $result = $exifTool->WriteDirectory(\%subdirInfo, $tagTablePtr);
+                my $result = $et->WriteDirectory(\%subdirInfo, $tagTablePtr);
                 return 0 unless $result;
                 # set size and pointer for this new directory
                 $size = $subdirInfo{OutPos} - $outPos;
@@ -406,9 +406,9 @@ sub WriteCanonRaw($$$)
                 );
                 #### eval Validate ($dirData, $subdirStart, $size)
                 if (defined $$subdir{Validate} and not eval $$subdir{Validate}) {
-                    $exifTool->Warn("Invalid $name data");
+                    $et->Warn("Invalid $name data");
                 } else {
-                    $subdir = $exifTool->WriteDirectory(\%subdirInfo, $newTagTable);
+                    $subdir = $et->WriteDirectory(\%subdirInfo, $newTagTable);
                     if (defined $subdir and length $subdir) {
                         if ($subdirStart) {
                             # add header before data directory
@@ -421,7 +421,7 @@ sub WriteCanonRaw($$$)
             } elsif ($$newTags{$tagID}) {
                 if ($delTag{$tagID}) {
                     $verbose > 1 and print $out "    - CanonRaw:$$tagInfo{Name}\n";
-                    ++$exifTool->{CHANGED};
+                    ++$$et{CHANGED};
                     next;   # next since we already added this tag
                 }
                 my $oldVal;
@@ -430,9 +430,9 @@ sub WriteCanonRaw($$$)
                 } else {
                     $oldVal = $value;
                 }
-                my $nvHash = $exifTool->GetNewValueHash($tagInfo);
-                if ($exifTool->IsOverwriting($nvHash, $oldVal)) {
-                    my $newVal = $exifTool->GetNewValues($nvHash);
+                my $nvHash = $et->GetNewValueHash($tagInfo);
+                if ($et->IsOverwriting($nvHash, $oldVal)) {
+                    my $newVal = $et->GetNewValues($nvHash);
                     my $verboseVal;
                     $verboseVal = $newVal if $verbose > 1;
                     # convert to specified format if necessary
@@ -441,9 +441,9 @@ sub WriteCanonRaw($$$)
                     }
                     if (defined $newVal) {
                         $value = $newVal;
-                        ++$exifTool->{CHANGED};
-                        $exifTool->VerboseValue("- CanonRaw:$$tagInfo{Name}", $oldVal);
-                        $exifTool->VerboseValue("+ CanonRaw:$$tagInfo{Name}", $verboseVal);
+                        ++$$et{CHANGED};
+                        $et->VerboseValue("- CanonRaw:$$tagInfo{Name}", $oldVal);
+                        $et->VerboseValue("+ CanonRaw:$$tagInfo{Name}", $verboseVal);
                     }
                 }
             }
@@ -505,7 +505,7 @@ sub WriteCanonRaw($$$)
 #          or -1 if a write error occurred
 sub WriteCRW($$)
 {
-    my ($exifTool, $dirInfo) = @_;
+    my ($et, $dirInfo) = @_;
     my $outfile = $$dirInfo{OutFile};
     my $raf = $$dirInfo{RAF};
     my $rtnVal = 0;
@@ -519,18 +519,18 @@ sub WriteCRW($$)
     my $type = $1;
     my $hlen = Get32u(\$buff, 0);   # get header length
 
-    if ($exifTool->{DEL_GROUP}->{MakerNotes}) {
+    if ($$et{DEL_GROUP}{MakerNotes}) {
         if ($type eq 'CCDR') {
-            $exifTool->Error("Can't delete MakerNotes group in CRW file");
+            $et->Error("Can't delete MakerNotes group in CRW file");
             return 0;
         } else {
-            ++$exifTool->{CHANGED};
+            ++$$et{CHANGED};
             return 1;
         }
     }
     # make XMP the preferred group for CRW files
-    if ($$exifTool{FILE_TYPE} eq 'CRW') {
-        $exifTool->InitWriteDirs(\%crwMap, 'XMP');
+    if ($$et{FILE_TYPE} eq 'CRW') {
+        $et->InitWriteDirs(\%crwMap, 'XMP');
     }
 
     # write header
@@ -554,7 +554,7 @@ sub WriteCRW($$)
     );
     # process the raw directory
     my $tagTablePtr = Image::ExifTool::GetTagTable('Image::ExifTool::CanonRaw::Main');
-    my $success = $exifTool->WriteDirectory(\%dirInfo, $tagTablePtr);
+    my $success = $et->WriteDirectory(\%dirInfo, $tagTablePtr);
 
     my $trailPt;
     while ($success) {
@@ -563,7 +563,7 @@ sub WriteCRW($$)
         # rewrite the trailer(s)
         $buff = '';
         $$trailInfo{OutFile} = \$buff;
-        $success = $exifTool->ProcessTrailers($trailInfo) or last;
+        $success = $et->ProcessTrailers($trailInfo) or last;
         $trailPt = $$trailInfo{OutFile};
         # nothing to write if trailers were deleted
         undef $trailPt if length($$trailPt) < 4;
@@ -571,13 +571,13 @@ sub WriteCRW($$)
     }
     if ($success) {
         # add CanonVRD trailer if writing as a block
-        $trailPt = $exifTool->AddNewTrailers($trailPt,'CanonVRD');
-        if (not $trailPt and $$exifTool{ADD_DIRS}{CanonVRD}) {
+        $trailPt = $et->AddNewTrailers($trailPt,'CanonVRD');
+        if (not $trailPt and $$et{ADD_DIRS}{CanonVRD}) {
             # create CanonVRD from scratch if necessary
             my $outbuff = '';
             my $saveOrder = GetByteOrder();
             require Image::ExifTool::CanonVRD;
-            if (Image::ExifTool::CanonVRD::ProcessCanonVRD($exifTool, { OutFile => \$outbuff }) > 0) {
+            if (Image::ExifTool::CanonVRD::ProcessCanonVRD($et, { OutFile => \$outbuff }) > 0) {
                 $trailPt = \$outbuff;
             }
             SetByteOrder($saveOrder);
@@ -592,7 +592,7 @@ sub WriteCRW($$)
         }
         $rtnVal = $err ? -1 : 1;
     } else {
-        $exifTool->Error('Error rewriting CRW file');
+        $et->Error('Error rewriting CRW file');
     }
     return $rtnVal;
 }

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

@@ -1318,10 +1318,10 @@ sub GetCFAPattern($)
 # Returns: error string or undef (and possibly changes value) on success
 sub CheckExif($$$)
 {
-    my ($exifTool, $tagInfo, $valPtr) = @_;
-    my $format = $$tagInfo{Format} || $$tagInfo{Writable} || $tagInfo->{Table}{WRITABLE};
+    my ($et, $tagInfo, $valPtr) = @_;
+    my $format = $$tagInfo{Format} || $$tagInfo{Writable} || $$tagInfo{Table}{WRITABLE};
     if (not $format or $format eq '1') {
-        if ($tagInfo->{Groups}{0} eq 'MakerNotes') {
+        if ($$tagInfo{Groups}{0} eq 'MakerNotes') {
             return undef;   # OK to have no format for makernotes
         } else {
             return 'No writable format';
@@ -1337,11 +1337,11 @@ sub CheckExif($$$)
 # Note: MUST be called Raw conversion time so the EXIF byte order is known!
 sub EncodeExifText($$)
 {
-    my ($exifTool, $val) = @_;
+    my ($et, $val) = @_;
     # does the string contain special characters?
     if ($val =~ /[\x80-\xff]/) {
-        my $order = $exifTool->GetNewValues('ExifUnicodeByteOrder');
-        return "UNICODE\0" . $exifTool->Encode($val,'UTF16',$order);
+        my $order = $et->GetNewValues('ExifUnicodeByteOrder');
+        return "UNICODE\0" . $et->Encode($val,'UTF16',$order);
     } else {
         return "ASCII\0\0\0$val";
     }
@@ -1355,7 +1355,7 @@ sub InsertWritableProperties($$;$)
 {
     my ($tagTablePtr, $writeTablePtr, $checkProc) = @_;
     my $tag;
-    $checkProc and $tagTablePtr->{CHECK_PROC} = $checkProc;
+    $checkProc and $$tagTablePtr{CHECK_PROC} = $checkProc;
     foreach $tag (keys %$writeTablePtr) {
         my $writeInfo = $$writeTablePtr{$tag};
         my @infoList = GetTagInfoList($tagTablePtr, $tag);
@@ -1384,7 +1384,7 @@ sub InsertWritableProperties($$;$)
 # Returns: new maker note data (and creates MAKER_NOTE_FIXUP), or undef on error
 sub RebuildMakerNotes($$$)
 {
-    my ($exifTool, $tagTablePtr, $dirInfo) = @_;
+    my ($et, $tagTablePtr, $dirInfo) = @_;
     my $dirStart = $$dirInfo{DirStart};
     my $dirLen = $$dirInfo{DirLen};
     my $dataPt = $$dirInfo{DataPt};
@@ -1392,7 +1392,7 @@ sub RebuildMakerNotes($$$)
     my $rtnValue;
     my %subdirInfo = %$dirInfo;
 
-    delete $exifTool->{MAKER_NOTE_FIXUP};
+    delete $$et{MAKER_NOTE_FIXUP};
 
     # don't need to rebuild text, BinaryData or PreviewImage maker notes
     my $tagInfo = $$dirInfo{TagInfo};
@@ -1406,40 +1406,40 @@ sub RebuildMakerNotes($$$)
         return substr($$dataPt, $dirStart, $dirLen);
     }
     my $saveOrder = GetByteOrder();
-    my $loc = Image::ExifTool::MakerNotes::LocateIFD($exifTool,\%subdirInfo);
+    my $loc = Image::ExifTool::MakerNotes::LocateIFD($et,\%subdirInfo);
     if (defined $loc) {
         my $makerFixup = $subdirInfo{Fixup} = new Image::ExifTool::Fixup;
         # create new exiftool object to rewrite the directory without changing it
         my $newTool = new Image::ExifTool;
         $newTool->Options(
-            IgnoreMinorErrors => $$exifTool{OPTIONS}{IgnoreMinorErrors},
-            FixBase           => $$exifTool{OPTIONS}{FixBase},
+            IgnoreMinorErrors => $$et{OPTIONS}{IgnoreMinorErrors},
+            FixBase           => $$et{OPTIONS}{FixBase},
         );
         $newTool->Init();   # must do this before calling WriteDirectory()!
         # don't copy over preview image
         $newTool->SetNewValue(PreviewImage => '');
         # copy all transient members over in case they are used for writing
         # (Make, Model, etc)
-        foreach (grep /[a-z]/, keys %$exifTool) {
-            $$newTool{$_} = $$exifTool{$_};
+        foreach (grep /[a-z]/, keys %$et) {
+            $$newTool{$_} = $$et{$_};
         }
         # fix base offsets if specified
-        $newTool->Options(FixBase => $exifTool->Options('FixBase'));
+        $newTool->Options(FixBase => $et->Options('FixBase'));
         # set GENERATE_PREVIEW_INFO flag so PREVIEW_INFO will be generated
-        $newTool->{GENERATE_PREVIEW_INFO} = 1;
+        $$newTool{GENERATE_PREVIEW_INFO} = 1;
         # drop any large tags
-        $newTool->{DROP_TAGS} = 1;
+        $$newTool{DROP_TAGS} = 1;
         # initialize other necessary data members
-        $newTool->{FILE_TYPE} = $exifTool->{FILE_TYPE};
-        $newTool->{TIFF_TYPE} = $exifTool->{TIFF_TYPE};
+        $$newTool{FILE_TYPE} = $$et{FILE_TYPE};
+        $$newTool{TIFF_TYPE} = $$et{TIFF_TYPE};
         # rewrite maker notes
         $rtnValue = $newTool->WriteDirectory(\%subdirInfo, $tagTablePtr);
         if (defined $rtnValue and length $rtnValue) {
             # add the dummy/empty preview image if necessary
-            if ($newTool->{PREVIEW_INFO}) {
+            if ($$newTool{PREVIEW_INFO}) {
                 $makerFixup->SetMarkerPointers(\$rtnValue, 'PreviewImage', length($rtnValue));
-                $rtnValue .= $newTool->{PREVIEW_INFO}{Data};
-                delete $newTool->{PREVIEW_INFO};
+                $rtnValue .= $$newTool{PREVIEW_INFO}{Data};
+                delete $$newTool{PREVIEW_INFO};
             }
             # add makernote header
             if ($loc) {
@@ -1448,25 +1448,25 @@ sub RebuildMakerNotes($$$)
                 # (in JPEG, Pentax makernotes are absolute and start with "AOC\0")
                 if ($hdr =~ s/^(PENTAX |SAMSUNG)\0/AOC\0/) {
                     # save fixup so we will adjust to absolute offsets when writing
-                    $exifTool->{MAKER_NOTE_FIXUP} = $makerFixup;
+                    $$et{MAKER_NOTE_FIXUP} = $makerFixup;
                 }
                 $rtnValue = $hdr . $rtnValue;
                 # adjust fixup for shift in start position
-                $makerFixup->{Start} += length $hdr;
+                $$makerFixup{Start} += length $hdr;
             }
             # shift offsets according to original position of maker notes,
             # and relative to the makernotes Base
-            $makerFixup->{Shift} += $dataPos + $dirStart +
-                                    $$dirInfo{Base} - $subdirInfo{Base};
+            $$makerFixup{Shift} += $dataPos + $dirStart +
+                                   $$dirInfo{Base} - $subdirInfo{Base};
             # repair incorrect offsets if offsets were fixed
-            $makerFixup->{Shift} += $subdirInfo{FixedBy} || 0;
+            $$makerFixup{Shift} += $subdirInfo{FixedBy} || 0;
             # fix up pointers to the specified offset
             $makerFixup->ApplyFixup(\$rtnValue);
             # save fixup information unless offsets were relative
             unless ($subdirInfo{Relative}) {
                 # set shift so offsets are all relative to start of maker notes
-                $makerFixup->{Shift} -= $dataPos + $dirStart;
-                $exifTool->{MAKER_NOTE_FIXUP} = $makerFixup;    # save fixup for later
+                $$makerFixup{Shift} -= $dataPos + $dirStart;
+                $$et{MAKER_NOTE_FIXUP} = $makerFixup;    # save fixup for later
             }
         }
     }
@@ -1575,11 +1575,11 @@ sub GetOffList($$$$$)
 # Inputs: 0) ExifTool ref, 1) end of valid TIFF data
 sub UpdateTiffEnd($$)
 {
-    my ($exifTool, $end) = @_;
-    if (defined $exifTool->{TIFF_END} and
-        $exifTool->{TIFF_END} < $end)
+    my ($et, $end) = @_;
+    if (defined $$et{TIFF_END} and
+        $$et{TIFF_END} < $end)
     {
-        $exifTool->{TIFF_END} = $end;
+        $$et{TIFF_END} = $end;
     }
 }
 
@@ -1589,14 +1589,14 @@ sub UpdateTiffEnd($$)
 # Returns: undef on fatal error, or '' if minor error is ignored
 sub ExifErr($$$)
 {
-    my ($exifTool, $errStr, $tagTablePtr) = @_;
+    my ($et, $errStr, $tagTablePtr) = @_;
     # MakerNote errors are minor by default
-    my $minor = ($tagTablePtr->{GROUPS}{0} eq 'MakerNotes');
-    if ($tagTablePtr->{VARS} and $tagTablePtr->{VARS}{MINOR_ERRORS}) {
-        $exifTool->Warn("$errStr. IFD dropped.") and return '' if $minor;
+    my $minor = ($$tagTablePtr{GROUPS}{0} eq 'MakerNotes');
+    if ($$tagTablePtr{VARS} and $$tagTablePtr{VARS}{MINOR_ERRORS}) {
+        $et->Warn("$errStr. IFD dropped.") and return '' if $minor;
         $minor = 1;
     }
-    return undef if $exifTool->Error($errStr, $minor);
+    return undef if $et->Error($errStr, $minor);
     return '';
 }
 
@@ -1607,12 +1607,12 @@ sub ExifErr($$$)
 #          Writing: new data block or undef on error
 sub ProcessTiffIFD($$$)
 {
-    my ($exifTool, $dirInfo, $tagTablePtr) = @_;
-    $exifTool or return 1;    # allow dummy access
+    my ($et, $dirInfo, $tagTablePtr) = @_;
+    $et or return 1;    # allow dummy access
     my $raf = $$dirInfo{RAF};
     my $base = $$dirInfo{Base} || 0;
     my $dirName = $$dirInfo{DirName};
-    my $magic = $dirInfo->{Subdir}{Magic} || 0x002a;
+    my $magic = $$dirInfo{Subdir}{Magic} || 0x002a;
     my $buff;
 
     # structured with a TIFF-like header and relative offsets
@@ -1620,10 +1620,10 @@ sub ProcessTiffIFD($$$)
     unless (SetByteOrder(substr($buff,0,2)) and Get16u(\$buff, 2) == $magic) {
         my $msg = "Invalid $dirName header";
         if ($$dirInfo{IsWriting}) {
-            $exifTool->Error($msg);
+            $et->Error($msg);
             return undef;
         } else {
-            $exifTool->Warn($msg);
+            $et->Warn($msg);
             return 0;
         }
     }
@@ -1642,19 +1642,19 @@ sub ProcessTiffIFD($$$)
     );
     if ($$dirInfo{IsWriting}) {
         # rewrite the Camera Profile IFD
-        my $newDir = WriteExif($exifTool, \%dirInfo, $tagTablePtr);
+        my $newDir = WriteExif($et, \%dirInfo, $tagTablePtr);
         # don't add header if error writing directory ($newDir is undef)
         # or if directory is being deleted ($newDir is empty)
         return $newDir unless $newDir;
         # return directory with TIFF-like header
         return GetByteOrder() . Set16u($magic) . Set32u(8) . $newDir;
     }
-    if ($exifTool->{HTML_DUMP}) {
+    if ($$et{HTML_DUMP}) {
         my $tip = sprintf("Byte order: %s endian\nIdentifier: 0x%.4x\n%s offset: 0x%.4x",
                           (GetByteOrder() eq 'II') ? 'Little' : 'Big', $magic, $dirName, $offset);
-        $exifTool->HDump($base, 8, "$dirName header", $tip, 0);
+        $et->HDump($base, 8, "$dirName header", $tip, 0);
     }
-    return ProcessExif($exifTool, \%dirInfo, $tagTablePtr);
+    return ProcessExif($et, \%dirInfo, $tagTablePtr);
 }
 
 #------------------------------------------------------------------------------
@@ -1671,8 +1671,8 @@ sub ProcessTiffIFD($$$)
 #   5. Thumbnail and/or image data for each IFD, with IFD0 image last
 sub WriteExif($$$)
 {
-    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
     my $origDirInfo = $dirInfo; # save original dirInfo
     my $dataPt = $$dirInfo{DataPt};
     unless ($dataPt) {
@@ -1689,8 +1689,8 @@ sub WriteExif($$$)
     my $dirName = $$dirInfo{DirName} || 'unknown';
     my $fixup = $$dirInfo{Fixup} || new Image::ExifTool::Fixup;
     my $imageDataFlag = $$dirInfo{ImageData} || '';
-    my $verbose = $exifTool->Options('Verbose');
-    my $out = $exifTool->Options('TextOut');
+    my $verbose = $et->Options('Verbose');
+    my $out = $et->Options('TextOut');
     my ($nextIfdPos, %offsetData, $inMakerNotes);
     my (@offsetInfo, %xDelete, $strEnc);
     my $deleteAll = 0;
@@ -1700,11 +1700,11 @@ sub WriteExif($$$)
     $name = $dirName unless $name and $dirName eq 'MakerNotes' and $name !~ /^MakerNote/;
 
     # set encoding for strings
-    $strEnc = $exifTool->Options('CharsetEXIF') if $$tagTablePtr{GROUPS}{0} eq 'EXIF';
+    $strEnc = $et->Options('CharsetEXIF') if $$tagTablePtr{GROUPS}{0} eq 'EXIF';
 
     # allow multiple IFD's in IFD0-IFD1-IFD2... chain
     $$dirInfo{Multi} = 1 if $dirName =~ /^(IFD0|SubIFD)$/ and not defined $$dirInfo{Multi};
-    $inMakerNotes = 1 if $tagTablePtr->{GROUPS}{0} eq 'MakerNotes';
+    $inMakerNotes = 1 if $$tagTablePtr{GROUPS}{0} eq 'MakerNotes';
     my $ifd;
 #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 # loop through each IFD
@@ -1729,12 +1729,12 @@ sub WriteExif($$$)
                 my $offset = $dirStart + $dataPos;
                 my ($buff, $buf2);
                 unless ($raf->Seek($offset + $base, 0) and $raf->Read($buff,2) == 2) {
-                    return ExifErr($exifTool, "Bad IFD or truncated file in $name", $tagTablePtr);
+                    return ExifErr($et, "Bad IFD or truncated file in $name", $tagTablePtr);
                 }
                 my $len = 12 * Get16u(\$buff,0);
                 # (also read next IFD pointer if available)
                 unless ($raf->Read($buf2, $len+4) >= $len) {
-                    return ExifErr($exifTool, "Error reading $name", $tagTablePtr);
+                    return ExifErr($et, "Error reading $name", $tagTablePtr);
                 }
                 $buff .= $buf2;
                 # make copy of dirInfo since we're going to modify it
@@ -1748,12 +1748,12 @@ sub WriteExif($$$)
                 $dirLen = $$dirInfo{DirLen} = $dataLen;
                 # only account for nextIFD pointer if we are going to use it
                 $len += 4 if $dataLen==$len+6 and ($$dirInfo{Multi} or $buff =~ /\0{4}$/);
-                UpdateTiffEnd($exifTool, $offset+$base+2+$len);
+                UpdateTiffEnd($et, $offset+$base+2+$len);
             } elsif ($dirLen) {
                 # error if we can't load IFD (unless we are creating
                 # from scratch, in which case dirLen will be zero)
-                my $str = $exifTool->Options('IgnoreMinorErrors') ? 'Deleted bad' : 'Bad';
-                $exifTool->Error("$str $name directory", 1);
+                my $str = $et->Options('IgnoreMinorErrors') ? 'Deleted bad' : 'Bad';
+                $et->Error("$str $name directory", 1);
             }
         }
         my ($index, $dirEnd, $numEntries);
@@ -1761,7 +1761,7 @@ sub WriteExif($$$)
             $numEntries = Get16u($dataPt, $dirStart);
             $dirEnd = $dirStart + 2 + 12 * $numEntries;
             if ($dirEnd > $dataLen) {
-                return ExifErr($exifTool, "Truncated $name directory", $tagTablePtr);
+                return ExifErr($et, "Truncated $name directory", $tagTablePtr);
             }
             # sort entries if necessary (but not in maker notes IFDs)
             unless ($inMakerNotes) {
@@ -1771,7 +1771,7 @@ sub WriteExif($$$)
                     # check for proper sequence (but ignore null entries at end)
                     if ($tagID < $lastID and $tagID) {
                         SortIFD($dataPt, $dirStart, $numEntries);
-                        $exifTool->Warn("Entries in $name were out of sequence. Fixed.",1);
+                        $et->Warn("Entries in $name were out of sequence. Fixed.",1);
                         last;
                     }
                     $lastID = $tagID;
@@ -1785,14 +1785,14 @@ sub WriteExif($$$)
         # loop through new values and accumulate all information for this IFD
         my (%set, %mayDelete, $tagInfo);
         my $wrongDir = $crossDelete{$dirName};
-        foreach $tagInfo ($exifTool->GetNewTagInfoList($tagTablePtr)) {
+        foreach $tagInfo ($et->GetNewTagInfoList($tagTablePtr)) {
             my $tagID = $$tagInfo{TagID};
             # evaluate conditional lists now if necessary
-            if (ref $tagTablePtr->{$tagID} eq 'ARRAY' or $$tagInfo{Condition}) {
-                my $curInfo = $exifTool->GetTagInfo($tagTablePtr, $tagID);
+            if (ref $$tagTablePtr{$tagID} eq 'ARRAY' or $$tagInfo{Condition}) {
+                my $curInfo = $et->GetTagInfo($tagTablePtr, $tagID);
                 if (defined $curInfo and not $curInfo) {
                     # need value to evaluate the condition
-                    my ($val) = $exifTool->GetNewValues($tagInfo);
+                    my ($val) = $et->GetNewValues($tagInfo);
                     # must convert to binary for evaluating in Condition
                     if ($$tagInfo{Format} and defined $val) {
                         $val = WriteValue($val, $$tagInfo{Format}, $$tagInfo{Count});
@@ -1815,7 +1815,7 @@ sub WriteExif($$$)
                                 }
                             }
                         }
-                        $curInfo = $exifTool->GetTagInfo($tagTablePtr, $tagID, \$val, $fmt, $cnt);
+                        $curInfo = $et->GetTagInfo($tagTablePtr, $tagID, \$val, $fmt, $cnt);
                     } else {
                         # may want to delete this, but we need to see the value first
                         $mayDelete{$tagID} = 1;
@@ -1825,25 +1825,25 @@ sub WriteExif($$$)
                 next unless defined $curInfo and $curInfo eq $tagInfo;
             }
             if ($$tagInfo{WriteCondition}) {
-                my $self = $exifTool;   # set $self to be used in eval
+                my $self = $et;   # set $self to be used in eval
                 #### eval WriteCondition ($self)
                 unless (eval $$tagInfo{WriteCondition}) {
                     $@ and warn $@;
                     next;
                 }
             }
-            my $nvHash = $exifTool->GetNewValueHash($tagInfo, $dirName);
+            my $nvHash = $et->GetNewValueHash($tagInfo, $dirName);
             unless ($nvHash) {
                 next unless $wrongDir;
                 # delete stuff from the wrong directory if setting somewhere else
-                $nvHash = $exifTool->GetNewValueHash($tagInfo, $wrongDir);
+                $nvHash = $et->GetNewValueHash($tagInfo, $wrongDir);
                 # don't cross delete if not overwriting
-                next unless $exifTool->IsOverwriting($nvHash);
+                next unless $et->IsOverwriting($nvHash);
                 # don't cross delete if specifically deleting from the other directory
                 # (Note: don't call GetValue() here because it shouldn't be called
                 #  if IsOverwriting returns < 0 -- ie. when shifting)
-                next if not defined $$nvHash{Value} and $nvHash->{WantGroup} and
-                        lc($nvHash->{WantGroup}) eq lc($wrongDir);
+                next if not defined $$nvHash{Value} and $$nvHash{WantGroup} and
+                        lc($$nvHash{WantGroup}) eq lc($wrongDir);
                 # remove this tag if found in this IFD
                 $xDelete{$tagID} = 1;
             }
@@ -1856,7 +1856,7 @@ sub WriteExif($$$)
                 if ($tagID == 0x927c and $dirName =~ /^(ExifIFD|IFD0)$/) {
                     next if $$tagInfo{Name} eq 'PreviewImage';
                 } else {
-                    $exifTool->Warn(sprintf("Multiple new values for $name tag 0x%.4x",$tagID));
+                    $et->Warn(sprintf("Multiple new values for $name tag 0x%.4x",$tagID));
                 }
             }
             $set{$tagID} = $tagInfo;
@@ -1864,8 +1864,8 @@ sub WriteExif($$$)
         
         # fix base offsets (some cameras incorrectly write maker notes in IFD0)
         if ($dirName eq 'MakerNotes' and $$dirInfo{Parent} =~ /^(ExifIFD|IFD0)$/ and
-            $$exifTool{TIFF_TYPE} !~ /^(ARW|SR2)$/ and not $$exifTool{LeicaTrailerPos} and
-            Image::ExifTool::MakerNotes::FixBase($exifTool, $dirInfo))
+            $$et{TIFF_TYPE} !~ /^(ARW|SR2)$/ and not $$et{LeicaTrailerPos} and
+            Image::ExifTool::MakerNotes::FixBase($et, $dirInfo))
         {
             # update local variables from fixed values
             $base = $$dirInfo{Base};
@@ -1877,11 +1877,11 @@ sub WriteExif($$$)
         my ($allMandatory, $addMandatory);
         if ($mandatory) {
             # use X/Y resolution values from JFIF if available
-            if ($dirName eq 'IFD0' and defined $$exifTool{JFIFYResolution}) {
+            if ($dirName eq 'IFD0' and defined $$et{JFIFYResolution}) {
                 my %ifd0Vals = %$mandatory;
-                $ifd0Vals{0x011a} = $$exifTool{JFIFXResolution};
-                $ifd0Vals{0x011b} = $$exifTool{JFIFYResolution};
-                $ifd0Vals{0x0128} = $$exifTool{JFIFResolutionUnit} + 1;
+                $ifd0Vals{0x011a} = $$et{JFIFXResolution};
+                $ifd0Vals{0x011b} = $$et{JFIFYResolution};
+                $ifd0Vals{0x0128} = $$et{JFIFResolutionUnit} + 1;
                 $mandatory = \%ifd0Vals;
             }
             $allMandatory = $addMandatory = 0; # initialize to zero
@@ -1908,7 +1908,7 @@ sub WriteExif($$$)
             @newTags = sort { $a <=> $b } @newTags if @newTags > 1;
         } else {
             # get a hash of directories we will be writing in this one
-            $addDirs = $exifTool->GetAddDirHash($tagTablePtr, $dirName);
+            $addDirs = $et->GetAddDirHash($tagTablePtr, $dirName);
             # make a union of tags & dirs (can set whole dirs, like MakerNotes)
             my %allTags = ( %set, %$addDirs );
             # make sorted list of new tags to be added
@@ -1929,7 +1929,7 @@ sub WriteExif($$$)
         my $newID = -1;
 
         # patch for Canon EOS 40D firmware 1.0.4 bug (incorrect directory counts)
-        if ($inMakerNotes and $$exifTool{Model} eq 'Canon EOS 40D') {
+        if ($inMakerNotes and $$et{Model} eq 'Canon EOS 40D') {
             my $fmt = Get16u($dataPt, $dirStart + 2 + 12 * ($numEntries - 1) + 2);
             if ($fmt < 1 or $fmt > 13) {
                 # adjust the number of directory entries
@@ -1959,14 +1959,14 @@ Entry:  for (;;) {
                         # patch to preserve invalid directory entries in SubIFD3 of
                         # various Kodak Z-series cameras (Z812, Z1085IS, Z1275)
                         # and some Sony cameras such as the DSC-P10
-                        if ($dirName eq 'MakerNotes' and (($$exifTool{Make}=~/KODAK/i and
+                        if ($dirName eq 'MakerNotes' and (($$et{Make}=~/KODAK/i and
                             $$dirInfo{Name} and $$dirInfo{Name} eq 'SubIFD3') or
-                            ($numEntries == 12 and $$exifTool{Make} eq 'SONY' and $index >= 8)))
+                            ($numEntries == 12 and $$et{Make} eq 'SONY' and $index >= 8)))
                         {
                             $dirBuff .= substr($$dataPt, $entry, 12);
                             ++$index;
                             $newID = $oldID;    # we wrote this
-                            $exifTool->Warn($msg, 1);
+                            $et->Warn($msg, 1);
                             next;
                         }
                         # don't write out null directory entry
@@ -1978,7 +1978,7 @@ Entry:  for (;;) {
                             $newID = $oldID;    # pretend we wrote this
                             next;
                         }
-                        return ExifErr($exifTool, $msg, $tagTablePtr);
+                        return ExifErr($et, $msg, $tagTablePtr);
                     }
                     $readFormName = $oldFormName = $formatName[$oldFormat];
                     $valueDataPt = $dataPt;
@@ -1990,9 +1990,9 @@ Entry:  for (;;) {
                     if (ref $oldInfo ne 'HASH' or $$oldInfo{Condition}) {
                         # must get unknown tags too
                         # (necessary so we don't miss a tag we want to Drop)
-                        my $unk = $exifTool->Options(Unknown => 1);
-                        $oldInfo = $exifTool->GetTagInfo($tagTablePtr, $oldID);
-                        $exifTool->Options(Unknown => $unk);
+                        my $unk = $et->Options(Unknown => 1);
+                        $oldInfo = $et->GetTagInfo($tagTablePtr, $oldID);
+                        $et->Options(Unknown => $unk);
                     }
                     # patch incorrect count in Kodak SubIFD3 tags
                     if ($oldCount < 2 and $oldInfo and $$oldInfo{FixCount}) {
@@ -2015,9 +2015,9 @@ Entry:  for (;;) {
                             #### eval FixOffsets ($valuePtr, $valEnd, $size, $tagID, $wFlag)
                             eval $$dirInfo{FixOffsets};
                             unless (defined $valuePtr) {
-                                unless ($$exifTool{DROP_TAGS}) {
+                                unless ($$et{DROP_TAGS}) {
                                     my $tagStr = $oldInfo ? $$oldInfo{Name} : sprintf("tag 0x%.4x",$oldID);
-                                    return undef if $exifTool->Error("Bad $name offset for $tagStr", $inMakerNotes);
+                                    return undef if $et->Error("Bad $name offset for $tagStr", $inMakerNotes);
                                 }
                                 ++$index;  $oldID = $newID;  next;  # drop this tag
                             }
@@ -2026,7 +2026,7 @@ Entry:  for (;;) {
                         my $suspect = ($valuePtr < 8);
                         # convert offset to pointer in $$dataPt
                         if ($$dirInfo{EntryBased} or (ref $$tagTablePtr{$oldID} eq 'HASH' and
-                            $tagTablePtr->{$oldID}{EntryBased}))
+                            $$tagTablePtr{$oldID}{EntryBased}))
                         {
                             $valuePtr += $entry;
                         } else {
@@ -2041,7 +2041,7 @@ Entry:  for (;;) {
                                 $tagStr = $$oldInfo{Name};
                                 $leicaTrailer = $$oldInfo{LeicaTrailer};
                             } elsif (defined $oldInfo) {
-                                $tmpInfo = $exifTool->GetTagInfo($tagTablePtr, $oldID, \ '', $oldFormName, $oldCount);
+                                $tmpInfo = $et->GetTagInfo($tagTablePtr, $oldID, \ '', $oldFormName, $oldCount);
                                 if ($tmpInfo) {
                                     $tagStr = $$tmpInfo{Name};
                                     $leicaTrailer = $$tmpInfo{LeicaTrailer};
@@ -2051,7 +2051,7 @@ Entry:  for (;;) {
                             # allow PreviewImage to run outside EXIF segment in JPEG images
                             if (not $raf) {
                                 if ($tagStr eq 'PreviewImage') {
-                                    $raf = $exifTool->{RAF};
+                                    $raf = $$et{RAF};
                                     if ($raf) {
                                         $pos = $raf->Tell();
                                         if ($oldInfo and $$oldInfo{ChangeBase}) {
@@ -2065,7 +2065,7 @@ Entry:  for (;;) {
                                     }
                                 } elsif ($leicaTrailer) {
                                     # save information about Leica makernote trailer
-                                    $$exifTool{LeicaTrailer} = {
+                                    $$et{LeicaTrailer} = {
                                         TagInfo => $oldInfo || $tmpInfo,
                                         Offset  => $base + $valuePtr + $dataPos,
                                         Size    => $oldSize,
@@ -2103,16 +2103,16 @@ Entry:  for (;;) {
                                     }
                                 }
                                 unless ($success) {
-                                    return undef if $exifTool->Error("Error reading value for $name entry $index", $inMakerNotes);
+                                    return undef if $et->Error("Error reading value for $name entry $index", $inMakerNotes);
                                     ++$index;  $oldID = $newID;  next;  # drop this tag
                                 }
                             } elsif (not $invalidPreview) {
-                                return undef if $exifTool->Error("Bad $name offset for $tagStr", $inMakerNotes);
+                                return undef if $et->Error("Bad $name offset for $tagStr", $inMakerNotes);
                                 ++$index;  $oldID = $newID;  next;  # drop this tag
                             }
                             if ($invalidPreview) {
                                 # set value for invalid preview
-                                if ($exifTool->{FILE_TYPE} eq 'JPEG') {
+                                if ($$et{FILE_TYPE} eq 'JPEG') {
                                     # define dummy value for preview (or Leica MakerNote) to write later
                                     # (value must be larger than 4 bytes to generate PREVIEW_INFO,
                                     # and an even number of bytes so it won't be padded)
@@ -2123,7 +2123,7 @@ Entry:  for (;;) {
                                 }
                                 $valuePtr = 0;
                             } else {
-                                UpdateTiffEnd($exifTool, $base+$valuePtr+$dataPos+$oldSize);
+                                UpdateTiffEnd($et, $base+$valuePtr+$dataPos+$oldSize);
                             }
                             # update pointers for value just read from file
                             $valueDataPt = \$oldValue;
@@ -2136,9 +2136,9 @@ Entry:  for (;;) {
                             my $tagStr = $oldInfo ? $$oldInfo{Name} : sprintf('tag 0x%.4x', $oldID);
                             my $str = "Suspicious $name offset for $tagStr";
                             if ($inMakerNotes) {
-                                $exifTool->Warn($str, 1);
+                                $et->Warn($str, 1);
                             } else {
-                                return undef if $exifTool->Error($str, 1);
+                                return undef if $et->Error($str, 1);
                             }
                         }
                     }
@@ -2146,16 +2146,16 @@ Entry:  for (;;) {
                     $oldValue = substr($$valueDataPt, $valuePtr, $oldSize) unless $readFromFile;
                     # get tagInfo using value if necessary
                     if (defined $oldInfo and not $oldInfo) {
-                        my $unk = $exifTool->Options(Unknown => 1);
-                        $oldInfo = $exifTool->GetTagInfo($tagTablePtr, $oldID, \$oldValue, $oldFormName, $oldCount);
-                        $exifTool->Options(Unknown => $unk);
+                        my $unk = $et->Options(Unknown => 1);
+                        $oldInfo = $et->GetTagInfo($tagTablePtr, $oldID, \$oldValue, $oldFormName, $oldCount);
+                        $et->Options(Unknown => $unk);
                         # now that we have the value, we can resolve the Condition to finally
                         # determine whether we want to delete this tag or not
                         if ($mayDelete{$oldID} and $oldInfo and (not @newTags or $newTags[0] != $oldID)) {
-                            my $nvHash = $exifTool->GetNewValueHash($oldInfo, $dirName);
+                            my $nvHash = $et->GetNewValueHash($oldInfo, $dirName);
                             if (not $nvHash and $wrongDir) {
                                 # delete from wrong directory if necessary
-                                $nvHash = $exifTool->GetNewValueHash($oldInfo, $wrongDir);
+                                $nvHash = $et->GetNewValueHash($oldInfo, $wrongDir);
                                 $nvHash and $xDelete{$oldID} = 1;
                             }
                             if ($nvHash) {
@@ -2170,7 +2170,7 @@ Entry:  for (;;) {
                         (not $oldInfo or not $$oldInfo{SubIFD}))
                     {
                         my $str = sprintf('%s tag 0x%.4x IFD format not handled', $name, $oldID);
-                        $exifTool->Error($str, $inMakerNotes);
+                        $et->Error($str, $inMakerNotes);
                     }
                     # override format we use to read the value if specified
                     if ($oldInfo) {
@@ -2178,10 +2178,10 @@ Entry:  for (;;) {
                         if (($$oldInfo{IsOffset} or $$oldInfo{SubIFD}) and
                             not $intFormat{$oldFormName})
                         {
-                            $exifTool->Error("Invalid format ($oldFormName) for $name $$oldInfo{Name}", $inMakerNotes);
+                            $et->Error("Invalid format ($oldFormName) for $name $$oldInfo{Name}", $inMakerNotes);
                             ++$index;  $oldID = $newID;  next;  # drop this tag
                         }
-                        if ($$oldInfo{Drop} and $$exifTool{DROP_TAGS} and
+                        if ($$oldInfo{Drop} and $$et{DROP_TAGS} and
                             ($$oldInfo{Drop} == 1 or $$oldInfo{Drop} < $oldSize))
                         {
                             ++$index;  $oldID = $newID;  next;  # drop this tag
@@ -2201,9 +2201,9 @@ Entry:  for (;;) {
                     if ($oldID <= $lastTagID and not $inMakerNotes) {
                         my $str = $oldInfo ? "$$oldInfo{Name} tag" : sprintf('tag 0x%x',$oldID);
                         if ($oldID == $lastTagID) {
-                            $exifTool->Warn("Duplicate $str in $name");;
+                            $et->Warn("Duplicate $str in $name");;
                         } else {
-                            $exifTool->Warn("\u$str out of sequence in $name");
+                            $et->Warn("\u$str out of sequence in $name");
                         }
                     }
                     $lastTagID = $oldID;
@@ -2250,16 +2250,16 @@ Entry:  for (;;) {
                     $newInfo = $set{$newID};
                     $newCount = $$newInfo{Count};
                     my ($val, $newVal, $n);
-                    my $nvHash = $exifTool->GetNewValueHash($newInfo, $dirName);
+                    my $nvHash = $et->GetNewValueHash($newInfo, $dirName);
                     if ($isNew > 0) {
                         # don't create new entry unless requested
                         if ($nvHash) {
                             next unless $$nvHash{IsCreating};
                             if ($$newInfo{IsOverwriting}) {
                                 my $proc = $$newInfo{IsOverwriting};
-                                $isOverwriting = &$proc($exifTool, $nvHash, $val, \$newVal);
+                                $isOverwriting = &$proc($et, $nvHash, $val, \$newVal);
                             } else {
-                                $isOverwriting = $exifTool->IsOverwriting($nvHash);
+                                $isOverwriting = $et->IsOverwriting($nvHash);
                             }
                         } else {
                             next if $xDelete{$newID};       # don't create if cross deleting
@@ -2281,7 +2281,7 @@ Entry:  for (;;) {
                         $newFormat = $formatNumber{$newFormName};
                     } elsif ($nvHash or $xDelete{$newID}) {
                         unless ($nvHash) {
-                            $nvHash = $exifTool->GetNewValueHash($newInfo, $wrongDir);
+                            $nvHash = $et->GetNewValueHash($newInfo, $wrongDir);
                         }
                         # read value
                         if (length $oldValue >= $oldSize) {
@@ -2314,13 +2314,13 @@ Entry:  for (;;) {
                         }
                         if ($$newInfo{IsOverwriting}) {
                             my $proc = $$newInfo{IsOverwriting};
-                            $isOverwriting = &$proc($exifTool, $nvHash, $val, \$newVal);
+                            $isOverwriting = &$proc($et, $nvHash, $val, \$newVal);
                         } else {
-                            $isOverwriting = $exifTool->IsOverwriting($nvHash, $val);
+                            $isOverwriting = $et->IsOverwriting($nvHash, $val);
                         }
                     }
                     if ($isOverwriting) {
-                        $newVal = $exifTool->GetNewValues($nvHash) unless defined $newVal;
+                        $newVal = $et->GetNewValues($nvHash) unless defined $newVal;
                         # value undefined if deleting this tag
                         # (also delete tag if cross-deleting and this isn't a date/time shift)
                         if (not defined $newVal or ($xDelete{$newID} and not defined $$nvHash{Shift})) {
@@ -2329,8 +2329,8 @@ Entry:  for (;;) {
                                 goto NoOverwrite; # GOTO!
                             }
                             unless ($isNew) {
-                                ++$exifTool->{CHANGED};
-                                $exifTool->VerboseValue("- $dirName:$$newInfo{Name}", $val);
+                                ++$$et{CHANGED};
+                                $et->VerboseValue("- $dirName:$$newInfo{Name}", $val);
                             }
                             next;
                         }
@@ -2342,30 +2342,30 @@ Entry:  for (;;) {
                         # convert to binary format
                         $newValue = WriteValue($newVal, $newFormName, $newCount);
                         unless (defined $newValue) {
-                            $exifTool->Warn("Invalid value for $dirName:$$newInfo{Name}");
+                            $et->Warn("Invalid value for $dirName:$$newInfo{Name}");
                             goto NoOverwrite; # GOTO!
                         }
                         if (length $newValue) {
                             # limit maximum value length in JPEG images
                             # (max segment size is 65533 bytes and the min EXIF size is 96 incl an additional IFD entry)
-                            if ($$exifTool{FILE_TYPE} eq 'JPEG' and length($newValue) > 65436 and
+                            if ($$et{FILE_TYPE} eq 'JPEG' and length($newValue) > 65436 and
                                 $$newInfo{Name} ne 'PreviewImage')
                             {
                                 my $name = $$newInfo{MakerNotes} ? 'MakerNotes' : $$newInfo{Name};
-                                $exifTool->Warn("$name too large to write in JPEG segment");
+                                $et->Warn("$name too large to write in JPEG segment");
                                 goto NoOverwrite; # GOTO!
                             }
                             # re-code if necessary
                             if ($strEnc and $newFormName eq 'string') {
-                                $newValue = $exifTool->Encode($newValue, $strEnc);
+                                $newValue = $et->Encode($newValue, $strEnc);
                             }
                         } else {
-                            $exifTool->Warn("Can't write zero length $$newInfo{Name} in $tagTablePtr->{GROUPS}{1}");
+                            $et->Warn("Can't write zero length $$newInfo{Name} in $$tagTablePtr{GROUPS}{1}");
                             goto NoOverwrite; # GOTO!
                         }
                         if ($isNew >= 0) {
                             $newCount = length($newValue) / $formatSize[$newFormat];
-                            ++$exifTool->{CHANGED};
+                            ++$$et{CHANGED};
                             if (defined $allMandatory) {
                                 # not all mandatory if we are writing any tag specifically
                                 if ($nvHash) {
@@ -2376,9 +2376,9 @@ Entry:  for (;;) {
                                 }
                             }
                             if ($verbose > 1) {
-                                $exifTool->VerboseValue("- $dirName:$$newInfo{Name}", $val) unless $isNew;
+                                $et->VerboseValue("- $dirName:$$newInfo{Name}", $val) unless $isNew;
                                 my $str = $nvHash ? '' : ' (mandatory)';
-                                $exifTool->VerboseValue("+ $dirName:$$newInfo{Name}", $newVal, $str);
+                                $et->VerboseValue("+ $dirName:$$newInfo{Name}", $newVal, $str);
                             }
                         }
                     } else {
@@ -2402,8 +2402,8 @@ NoOverwrite:            next if $isNew > 0;
                     # or a SubIFD
                     next if $$newInfo{MakerNotes} or $$newInfo{Name} eq 'SubIFD';
                     my $subTable;
-                    if ($newInfo->{SubDirectory}{TagTable}) {
-                        $subTable = Image::ExifTool::GetTagTable($newInfo->{SubDirectory}{TagTable});
+                    if ($$newInfo{SubDirectory}{TagTable}) {
+                        $subTable = Image::ExifTool::GetTagTable($$newInfo{SubDirectory}{TagTable});
                     } else {
                         $subTable = $tagTablePtr;
                     }
@@ -2412,8 +2412,8 @@ NoOverwrite:            next if $isNew > 0;
                         Parent => $dirName,
                         Fixup => new Image::ExifTool::Fixup,
                     );
-                    $sourceDir{DirName} = $newInfo->{Groups}{1} if $$newInfo{SubIFD};
-                    $newValue = $exifTool->WriteDirectory(\%sourceDir, $subTable);
+                    $sourceDir{DirName} = $$newInfo{Groups}{1} if $$newInfo{SubIFD};
+                    $newValue = $et->WriteDirectory(\%sourceDir, $subTable);
                     # only add new directory if it isn't empty
                     next unless defined $newValue and length($newValue);
                     # set the fixup start location
@@ -2476,14 +2476,14 @@ NoOverwrite:            next if $isNew > 0;
                         # prefer tag from Composite table if it exists (otherwise
                         # PreviewImage data would be taken from Extra tag)
                         my $compInfo = $Image::ExifTool::Composite{$dataTag};
-                        $offsetData{$dataTag} = $exifTool->GetNewValues($compInfo || $dataTag);
+                        $offsetData{$dataTag} = $et->GetNewValues($compInfo || $dataTag);
                         my $err;
                         if (defined $offsetData{$dataTag}) {
                             my $len = length $offsetData{$dataTag};
                             if ($dataTag eq 'PreviewImage') {
                                 # must set DEL_PREVIEW flag now if preview fit into IFD
-                                $$exifTool{DEL_PREVIEW} = 1 if $len <= 4;
-                            } elsif ($exifTool->{FILE_TYPE} eq 'JPEG' and $len > 60000) {
+                                $$et{DEL_PREVIEW} = 1 if $len <= 4;
+                            } elsif ($$et{FILE_TYPE} eq 'JPEG' and $len > 60000) {
                                 delete $offsetData{$dataTag};
                                 $err = "$dataTag not written (too large for JPEG segment)";
                             }
@@ -2491,7 +2491,7 @@ NoOverwrite:            next if $isNew > 0;
                             $err = "$dataTag not found";
                         }
                         if ($err) {
-                            $exifTool->Warn($err) if $$newInfo{IsOffset};
+                            $et->Warn($err) if $$newInfo{IsOffset};
                             delete $set{$newID};    # remove from list of tags we are setting
                             next;
                         }
@@ -2502,11 +2502,11 @@ NoOverwrite:            next if $isNew > 0;
 #
                 if ($$newInfo{MakerNotes}) {
                     # don't write new makernotes if we are deleting this group
-                    if ($exifTool->{DEL_GROUP}{MakerNotes} and
-                       ($exifTool->{DEL_GROUP}{MakerNotes} != 2 or $isNew <= 0))
+                    if ($$et{DEL_GROUP}{MakerNotes} and
+                       ($$et{DEL_GROUP}{MakerNotes} != 2 or $isNew <= 0))
                     {
                         if ($isNew <= 0) {
-                            ++$exifTool->{CHANGED};
+                            ++$$et{CHANGED};
                             $verbose and print $out "  Deleting MakerNotes\n";
                         }
                         next;
@@ -2515,12 +2515,12 @@ NoOverwrite:            next if $isNew > 0;
                     if ($isNew >= 0 and $set{$newID}) {
                         # we are writing a whole new maker note block
                         # --> add fixup information if necessary
-                        my $nvHash = $exifTool->GetNewValueHash($newInfo, $dirName);
-                        if ($nvHash and $nvHash->{MAKER_NOTE_FIXUP}) {
+                        my $nvHash = $et->GetNewValueHash($newInfo, $dirName);
+                        if ($nvHash and $$nvHash{MAKER_NOTE_FIXUP}) {
                             # must clone fixup because we will be shifting it
-                            my $makerFixup = $nvHash->{MAKER_NOTE_FIXUP}->Clone();
+                            my $makerFixup = $$nvHash{MAKER_NOTE_FIXUP}->Clone();
                             my $valLen = length($valBuff);
-                            $makerFixup->{Start} += $valLen;
+                            $$makerFixup{Start} += $valLen;
                             push @valFixups, $makerFixup;
                         }
                     } else {
@@ -2554,7 +2554,7 @@ NoOverwrite:            next if $isNew > 0;
                             $writeProc = $$oldInfo{SubDirectory}{WriteProc};
                             $notIFD = $$oldInfo{NotIFD};
                         } else {
-                            $exifTool->Warn('Internal problem getting maker notes tag table');
+                            $et->Warn('Internal problem getting maker notes tag table');
                         }
                         $subTable or $subTable = $tagTablePtr;
                         if ($writeProc and
@@ -2564,15 +2564,15 @@ NoOverwrite:            next if $isNew > 0;
                             $loc = 0;
                         } elsif (not $notIFD) {
                             # look for IFD-style maker notes
-                            $loc = Image::ExifTool::MakerNotes::LocateIFD($exifTool,\%subdirInfo);
+                            $loc = Image::ExifTool::MakerNotes::LocateIFD($et,\%subdirInfo);
                         }
                         if (defined $loc) {
                             # we need fixup data for this subdirectory
                             $subdirInfo{Fixup} = new Image::ExifTool::Fixup;
                             # rewrite maker notes
-                            my $changed = $$exifTool{CHANGED};
-                            $subdir = $exifTool->WriteDirectory(\%subdirInfo, $subTable, $writeProc);
-                            if ($changed == $$exifTool{CHANGED} and $subdirInfo{Fixup}->IsEmpty()) {
+                            my $changed = $$et{CHANGED};
+                            $subdir = $et->WriteDirectory(\%subdirInfo, $subTable, $writeProc);
+                            if ($changed == $$et{CHANGED} and $subdirInfo{Fixup}->IsEmpty()) {
                                 # return original data if nothing changed and no fixups
                                 undef $subdir;
                             }
@@ -2590,13 +2590,13 @@ NoOverwrite:            next if $isNew > 0;
                                 $loc = 0;
                             }
                             # rewrite maker notes
-                            $subdir = $exifTool->WriteDirectory(\%subdirInfo, $subTable);
+                            $subdir = $et->WriteDirectory(\%subdirInfo, $subTable);
                         } elsif (not $notIFD) {
                             my $msg = 'Maker notes could not be parsed';
-                            if ($$exifTool{FILE_TYPE} eq 'JPEG') {
-                                $exifTool->Warn($msg, 1);
+                            if ($$et{FILE_TYPE} eq 'JPEG') {
+                                $et->Warn($msg, 1);
                             } else {
-                                $exifTool->Error($msg, 1);
+                                $et->Error($msg, 1);
                             }
                         }
                         if (defined $subdir) {
@@ -2606,27 +2606,27 @@ NoOverwrite:            next if $isNew > 0;
                             # maker notes for the old value
                             $newValue = substr($oldValue, 0, $loc) . $subdir;
                             my $makerFixup = $subdirInfo{Fixup};
-                            my $previewInfo = $exifTool->{PREVIEW_INFO};
+                            my $previewInfo = $$et{PREVIEW_INFO};
                             if ($subdirInfo{Relative}) {
                                 # apply a one-time fixup to $loc since offsets are relative
-                                $makerFixup->{Start} += $loc;
+                                $$makerFixup{Start} += $loc;
                                 # shift all offsets to be relative to new base
                                 my $baseShift = $valueDataPos + $valuePtr + $base - $subdirInfo{Base};
-                                $makerFixup->{Shift} += $baseShift;
+                                $$makerFixup{Shift} += $baseShift;
                                 $makerFixup->ApplyFixup(\$newValue);
                                 if ($previewInfo) {
                                     # remove all but PreviewImage fixup (since others shouldn't change)
-                                    foreach (keys %{$makerFixup->{Pointers}}) {
-                                        /_PreviewImage$/ or delete $makerFixup->{Pointers}{$_};
+                                    foreach (keys %{$$makerFixup{Pointers}}) {
+                                        /_PreviewImage$/ or delete $$makerFixup{Pointers}{$_};
                                     }
                                     # zero pointer so we can see how it gets shifted later
                                     $makerFixup->SetMarkerPointers(\$newValue, 'PreviewImage', 0);
                                     # set the pointer to the start of the EXIF information
                                     # add preview image fixup to list of value fixups
-                                    $makerFixup->{Start} += $valLen;
+                                    $$makerFixup{Start} += $valLen;
                                     push @valFixups, $makerFixup;
-                                    $previewInfo->{BaseShift} = $baseShift;
-                                    $previewInfo->{Relative} = 1;
+                                    $$previewInfo{BaseShift} = $baseShift;
+                                    $$previewInfo{Relative} = 1;
                                 }
                             # don't shift anything if relative flag set to zero (Pentax patch)
                             } elsif (not defined $subdirInfo{Relative}) {
@@ -2640,22 +2640,22 @@ NoOverwrite:            next if $isNew > 0;
                                     # allow negative base shift if offsets are bigger (PentaxOptioWP.jpg)
                                     (not $subdirInfo{MinOffset} or $subdirInfo{MinOffset} + $baseShift < 0))
                                 {
-                                    my $fixBase = $exifTool->Options('FixBase');
+                                    my $fixBase = $et->Options('FixBase');
                                     if (not defined $fixBase) {
-                                        my $str = $exifTool->Options('IgnoreMinorErrors') ? 'ignored' : 'fix or ignore?';
-                                        $exifTool->Error("MakerNotes offsets may be incorrect ($str)", 1);
+                                        my $str = $et->Options('IgnoreMinorErrors') ? 'ignored' : 'fix or ignore?';
+                                        $et->Error("MakerNotes offsets may be incorrect ($str)", 1);
                                     } elsif ($fixBase eq '') {
-                                        $exifTool->Warn('Fixed incorrect MakerNotes offsets');
+                                        $et->Warn('Fixed incorrect MakerNotes offsets');
                                         $baseShift = 0;
                                     }
                                 }
-                                $makerFixup->{Start} += $valLen + $loc;
-                                $makerFixup->{Shift} += $baseShift;
+                                $$makerFixup{Start} += $valLen + $loc;
+                                $$makerFixup{Shift} += $baseShift;
                                 # permanently fix makernote offset errors
-                                $makerFixup->{Shift} += $subdirInfo{FixedBy} || 0;
+                                $$makerFixup{Shift} += $subdirInfo{FixedBy} || 0;
                                 push @valFixups, $makerFixup;
-                                if ($previewInfo and not $previewInfo->{NoBaseShift}) {
-                                    $previewInfo->{BaseShift} = $baseShift;
+                                if ($previewInfo and not $$previewInfo{NoBaseShift}) {
+                                    $$previewInfo{BaseShift} = $baseShift;
                                 }
                             }
                             $newValuePt = \$newValue;   # write new value
@@ -2679,13 +2679,13 @@ NoOverwrite:            next if $isNew > 0;
                             $subTable = Image::ExifTool::GetTagTable($$subdir{TagTable});
                         }
                         # determine directory name for this IFD
-                        my $subdirName = $newInfo->{Groups}{1} || $$newInfo{Name};
+                        my $subdirName = $$newInfo{Groups}{1} || $$newInfo{Name};
                         # all makernotes directory names must be 'MakerNotes'
-                        $subdirName = 'MakerNotes' if $subTable->{GROUPS}{0} eq 'MakerNotes';
+                        $subdirName = 'MakerNotes' if $$subTable{GROUPS}{0} eq 'MakerNotes';
                         # must handle sub-IFD's specially since the values
                         # are actually offsets to subdirectories
                         unless ($readCount) {   # can't have zero count
-                            return undef if $exifTool->Error("$name entry $index has zero count", 2);
+                            return undef if $et->Error("$name entry $index has zero count", 2);
                             next;
                         }
                         my $writeCount = 0;
@@ -2736,18 +2736,18 @@ NoOverwrite:            next if $isNew > 0;
                                     $subdirInfo{DataLen} = 0;
                                 } else {
                                     my @err = ("Can't read $subdirName data", $inMakerNotes);
-                                    if ($$subTable{VARS} and $subTable->{VARS}{MINOR_ERRORS}) {
-                                        $exifTool->Warn($err[0] . '. Ignored.');
-                                    } elsif ($exifTool->Error(@err)) {
+                                    if ($$subTable{VARS} and $$subTable{VARS}{MINOR_ERRORS}) {
+                                        $et->Warn($err[0] . '. Ignored.');
+                                    } elsif ($et->Error(@err)) {
                                         return undef;
                                     }
                                     next Entry; # don't write this directory
                                 }
                             }
-                            my $subdirData = $exifTool->WriteDirectory(\%subdirInfo, $subTable, $$subdir{WriteProc});
+                            my $subdirData = $et->WriteDirectory(\%subdirInfo, $subTable, $$subdir{WriteProc});
                             unless (defined $subdirData) {
                                 # WriteDirectory should have issued an error, but check just in case
-                                $exifTool->Error("Error writing $subdirName") unless $$exifTool{VALUE}{Error};
+                                $et->Error("Error writing $subdirName") unless $$et{VALUE}{Error};
                                 return undef;
                             }
                             unless (length $subdirData) {
@@ -2844,13 +2844,13 @@ NoOverwrite:            next if $isNew > 0;
                         my $subTable = Image::ExifTool::GetTagTable($$subdir{TagTable});
                         my $oldOrder = GetByteOrder();
                         SetByteOrder($$subdir{ByteOrder}) if $$subdir{ByteOrder};
-                        $newValue = $exifTool->WriteDirectory(\%subdirInfo, $subTable, $$subdir{WriteProc});
+                        $newValue = $et->WriteDirectory(\%subdirInfo, $subTable, $$subdir{WriteProc});
                         SetByteOrder($oldOrder);
                         if (defined $newValue) {
                             my $hdrLen = $subdirStart - $valuePtr;
                             if ($hdrLen) {
                                 $newValue = substr($$valueDataPt, $valuePtr, $hdrLen) . $newValue;
-                                $subFixup->{Start} += $hdrLen;
+                                $$subFixup{Start} += $hdrLen;
                             }
                             $newValuePt = \$newValue;
                         } else {
@@ -2860,8 +2860,8 @@ NoOverwrite:            next if $isNew > 0;
                             # don't delete a previously empty makernote directory
                             next if $oldSize or not $inMakerNotes;
                         }
-                        if ($subFixup->{Pointers} and $subdirInfo{Base} == $base) {
-                            $subFixup->{Start} += length $valBuff;
+                        if ($$subFixup{Pointers} and $subdirInfo{Base} == $base) {
+                            $$subFixup{Start} += length $valBuff;
                             push @valFixups, $subFixup;
                         } else {
                             # apply fixup in case we added a header ($hdrLen above)
@@ -2877,11 +2877,11 @@ NoOverwrite:            next if $isNew > 0;
                     if ($dataTag eq 'CanonVRD') {
                         # must decide now if we will write CanonVRD information
                         my $hasVRD;
-                        if ($exifTool->{NEW_VALUE}{$Image::ExifTool::Extra{CanonVRD}}) {
+                        if ($$et{NEW_VALUE}{$Image::ExifTool::Extra{CanonVRD}}) {
                             # adding or deleting as a block
-                            $hasVRD = $exifTool->GetNewValues('CanonVRD') ? 1 : 0;
-                        } elsif ($exifTool->{DEL_GROUP}{CanonVRD} or
-                                 $exifTool->{DEL_GROUP}{Trailer})
+                            $hasVRD = $et->GetNewValues('CanonVRD') ? 1 : 0;
+                        } elsif ($$et{DEL_GROUP}{CanonVRD} or
+                                 $$et{DEL_GROUP}{Trailer})
                         {
                             $hasVRD = 0;    # deleting as a group
                         } else {
@@ -2901,29 +2901,29 @@ NoOverwrite:            next if $isNew > 0;
                         #   invalidated anyway by our edits
                         my $odd;
                         my $oddInfo = $Image::ExifTool::Composite{OriginalDecisionData};
-                        if ($oddInfo and $exifTool->{NEW_VALUE}{$oddInfo}) {
-                            $odd = $exifTool->GetNewValues($dataTag);
+                        if ($oddInfo and $$et{NEW_VALUE}{$oddInfo}) {
+                            $odd = $et->GetNewValues($dataTag);
                             if ($verbose > 1) {
                                 print $out "    - $dirName:$dataTag\n" if $$newValuePt ne "\0\0\0\0";
                                 print $out "    + $dirName:$dataTag\n" if $odd;
                             }
-                            ++$exifTool->{CHANGED};
+                            ++$$et{CHANGED};
                         } elsif ($$newValuePt ne "\0\0\0\0") {
                             if (length($$newValuePt) == 4) {
                                 require Image::ExifTool::Canon;
                                 my $offset = Get32u($newValuePt,0);
                                 # absolute offset in JPEG images only
-                                $offset += $base unless $$exifTool{FILE_TYPE} eq 'JPEG';
-                                $odd = Image::ExifTool::Canon::ReadODD($exifTool, $offset);
+                                $offset += $base unless $$et{FILE_TYPE} eq 'JPEG';
+                                $odd = Image::ExifTool::Canon::ReadODD($et, $offset);
                                 $odd = $$odd if ref $odd;
                             } else {
-                                $exifTool->Error("Invalid $$newInfo{Name}",1);
+                                $et->Error("Invalid $$newInfo{Name}",1);
                             }
                         }
                         if ($odd) {
                             my $newOffset = length($valBuff);
                             # (ODD offset is absolute in JPEG, so add base offset!)
-                            $newOffset += $base if $$exifTool{FILE_TYPE} eq 'JPEG';
+                            $newOffset += $base if $$et{FILE_TYPE} eq 'JPEG';
                             $newValue = Set32u($newOffset);
                             $dirFixup->AddFixup(length($dirBuff) + 8, $dataTag);
                             $valBuff .= $odd;   # add original decision data
@@ -2962,7 +2962,7 @@ NoOverwrite:            next if $isNew > 0;
                         my $ptr = $newStart + length($dirBuff) + 10;
                         $newCount or $newCount = 1; # make sure count is set for offsetInfo
                         # save value pointer and value count for each tag
-                        $offsetInfo->{$newID} = [$newInfo, $ptr, $newCount, \@vals, $newFormat];
+                        $$offsetInfo{$newID} = [$newInfo, $ptr, $newCount, \@vals, $newFormat];
                     }
 
                 } elsif ($$newInfo{DataMember}) {
@@ -2982,14 +2982,14 @@ NoOverwrite:            next if $isNew > 0;
                     if ($conv) {
                         # let the RawConv store the (possibly converted) data member
                         if (ref $conv eq 'CODE') {
-                            &$conv($val, $exifTool);
+                            &$conv($val, $et);
                         } else {
-                            my ($self, $tag, $taginfo) = ($exifTool, $$newInfo{Name}, $newInfo);
+                            my ($self, $tag, $taginfo) = ($et, $$newInfo{Name}, $newInfo);
                             #### eval RawConv ($self, $val, $tag, $tagInfo)
                             eval $conv;
                         }
                     } else {
-                        $$exifTool{$$newInfo{DataMember}} = $val;
+                        $$et{$$newInfo{DataMember}} = $val;
                     }
                 }
             }
@@ -3017,22 +3017,22 @@ NoOverwrite:            next if $isNew > 0;
                 my ($dataTag, $putFirst);
                 ($dataTag, $putFirst) = @$newInfo{'DataTag','PutFirst'} if $newInfo;
                 if ($dataTag) {
-                    if ($dataTag eq 'PreviewImage' and ($exifTool->{FILE_TYPE} eq 'JPEG' or
-                        $$exifTool{GENERATE_PREVIEW_INFO}))
+                    if ($dataTag eq 'PreviewImage' and ($$et{FILE_TYPE} eq 'JPEG' or
+                        $$et{GENERATE_PREVIEW_INFO}))
                     {
                         # hold onto the PreviewImage until we can determine if it fits
-                        $exifTool->{PREVIEW_INFO} or $exifTool->{PREVIEW_INFO} = {
+                        $$et{PREVIEW_INFO} or $$et{PREVIEW_INFO} = {
                             Data => $$newValuePt,
                             Fixup => new Image::ExifTool::Fixup,
                         };
-                        $exifTool->{PREVIEW_INFO}{ChangeBase} = 1 if $$newInfo{ChangeBase};
+                        $$et{PREVIEW_INFO}{ChangeBase} = 1 if $$newInfo{ChangeBase};
                         if ($$newInfo{IsOffset} and $$newInfo{IsOffset} eq '2') {
-                            $exifTool->{PREVIEW_INFO}{NoBaseShift} = 1;
+                            $$et{PREVIEW_INFO}{NoBaseShift} = 1;
                         }
                         # use original preview size if we will attempt to load it later
                         $newCount = $oldCount if $$newValuePt eq 'LOAD_PREVIEW';
                         $$newValuePt = '';
-                    } elsif ($dataTag eq 'LeicaTrailer' and $$exifTool{LeicaTrailer}) {
+                    } elsif ($dataTag eq 'LeicaTrailer' and $$et{LeicaTrailer}) {
                         $$newValuePt = '';
                     }
                 }
@@ -3077,11 +3077,11 @@ NoOverwrite:            next if $isNew > 0;
         if ($ignoreCount) {
             my $y = $ignoreCount > 1 ? 'ies' : 'y';
             my $verb = $$dirInfo{FixBase} ? 'Ignored' : 'Removed';
-            $exifTool->Warn("$verb $ignoreCount invalid entr$y from $name", 1);
+            $et->Warn("$verb $ignoreCount invalid entr$y from $name", 1);
         }
         if ($fixCount) {
             my $s = $fixCount > 1 ? 's' : '';
-            $exifTool->Warn("Fixed invalid count$s for $fixCount $name tag$s", 1);
+            $et->Warn("Fixed invalid count$s for $fixCount $name tag$s", 1);
         }
 #..............................................................................
 # write directory counts and nextIFD pointer and add value data to end of IFD
@@ -3096,8 +3096,8 @@ NoOverwrite:            next if $isNew > 0;
         my $isNextIFD = ($$dirInfo{Multi} and ($nextIfdOffset or
                         # account for the case where we will create the next IFD
                         # (IFD1 only, but not in TIFF-format images)
-                        ($dirName eq 'IFD0' and $$exifTool{ADD_DIRS}{'IFD1'} and
-                         $$exifTool{FILE_TYPE} ne 'TIFF')));
+                        ($dirName eq 'IFD0' and $$et{ADD_DIRS}{'IFD1'} and
+                         $$et{FILE_TYPE} ne 'TIFF')));
         # calculate number of entries in new directory
         my $newEntries = length($dirBuff) / 12;
         # delete entire directory if we deleted a tag and only mandatory tags remain or we
@@ -3109,7 +3109,7 @@ NoOverwrite:            next if $isNew > 0;
             undef $dirFixup;    # no fixups in this directory
             ++$deleteAll if defined $deleteAll;
             $verbose > 1 and print $out "    - $allMandatory mandatory tag(s)\n";
-            $exifTool->{CHANGED} -= $addMandatory;    # didn't change these after all
+            $$et{CHANGED} -= $addMandatory;    # didn't change these after all
         }
         if ($ifd and not $newEntries) {
             $verbose and print $out "  Deleting IFD1\n";
@@ -3117,7 +3117,7 @@ NoOverwrite:            next if $isNew > 0;
         }
         # apply one-time fixup for entry-based offsets
         if ($entryBasedFixup) {
-            $entryBasedFixup->{Shift} = length($dirBuff) + 4;
+            $$entryBasedFixup{Shift} = length($dirBuff) + 4;
             $entryBasedFixup->ApplyFixup(\$dirBuff);
             undef $entryBasedFixup;
         }
@@ -3173,7 +3173,7 @@ NoOverwrite:            next if $isNew > 0;
                 $offset += $newStart + 2;           # get offset in newData
                 # check to be sure we got the right offset
                 unless (Get32u(\$newData, $offset) == 0xfeedf00d) {
-                    $exifTool->Error("Internal error while rewriting $name");
+                    $et->Error("Internal error while rewriting $name");
                     return undef;
                 }
                 # set the offset to the subdirectory data
@@ -3184,14 +3184,14 @@ NoOverwrite:            next if $isNew > 0;
         # add fixup for all offsets in directory according to value data position
         # (which is at the end of this directory)
         if ($dirFixup) {
-            $dirFixup->{Start} = $newStart + 2;
-            $dirFixup->{Shift} = $valPos - $dirFixup->{Start};
+            $$dirFixup{Start} = $newStart + 2;
+            $$dirFixup{Shift} = $valPos - $$dirFixup{Start};
             $fixup->AddFixup($dirFixup);
         }
         # add valueData fixups, adjusting for position of value data
         my $valFixup;
         foreach $valFixup (@valFixups) {
-            $valFixup->{Start} += $valPos;
+            $$valFixup{Start} += $valPos;
             $fixup->AddFixup($valFixup);
         }
         # stop if no next IFD pointer
@@ -3212,32 +3212,32 @@ NoOverwrite:            next if $isNew > 0;
         $dirName .= $ifdNum + 1;
         $name =~ s/\d+$//;
         $name .= $ifdNum + 1;
-        $$exifTool{DIR_NAME} = $$exifTool{PATH}[-1] = $dirName;
+        $$et{DIR_NAME} = $$et{PATH}[-1] = $dirName;
         next unless $nextIfdOffset;
 
         # guard against writing the same directory twice
         my $addr = $nextIfdOffset + $base;
-        if ($exifTool->{PROCESSED}{$addr}) {
-            $exifTool->Error("$name pointer references previous $exifTool->{PROCESSED}{$addr} directory", 1);
+        if ($$et{PROCESSED}{$addr}) {
+            $et->Error("$name pointer references previous $$et{PROCESSED}{$addr} directory", 1);
             last;
         }
-        $exifTool->{PROCESSED}{$addr} = $name;
+        $$et{PROCESSED}{$addr} = $name;
 
         if ($dirName eq 'SubIFD1' and not ValidateIFD($dirInfo, $dirStart)) {
-            if ($exifTool->{TIFF_TYPE} eq 'TIFF') {
-                $exifTool->Error('Ignored bad IFD linked from SubIFD', 1);
+            if ($$et{TIFF_TYPE} eq 'TIFF') {
+                $et->Error('Ignored bad IFD linked from SubIFD', 1);
             } elsif ($verbose) {
-                $exifTool->Warn('Ignored bad IFD linked from SubIFD');
+                $et->Warn('Ignored bad IFD linked from SubIFD');
             }
             last;   # don't write bad IFD
         }
-        if ($exifTool->{DEL_GROUP}{$dirName}) {
+        if ($$et{DEL_GROUP}{$dirName}) {
             $verbose and print $out "  Deleting $dirName\n";
-            $raf and $exifTool->Error("Deleting $dirName also deletes subsequent" .
+            $raf and $et->Error("Deleting $dirName also deletes subsequent" .
                                       " IFD's and possibly image data", 1);
-            ++$exifTool->{CHANGED};
-            if ($exifTool->{DEL_GROUP}{$dirName} == 2 and
-                $exifTool->{ADD_DIRS}{$dirName})
+            ++$$et{CHANGED};
+            if ($$et{DEL_GROUP}{$dirName} == 2 and
+                $$et{ADD_DIRS}{$dirName})
             {
                 my $emptyIFD = "\0" x 2;    # start with empty IFD
                 $dataPt = \$emptyIFD;
@@ -3280,16 +3280,16 @@ NoOverwrite:            next if $isNew > 0;
                 if ($stripOffsets and $$stripOffsets[0]{PanasonicHack}) {
                     require Image::ExifTool::PanasonicRaw;
                     my $err = Image::ExifTool::PanasonicRaw::PatchRawDataOffset($offsetInfo, $raf, $ifd);
-                    $err and $exifTool->Error($err);
+                    $err and $et->Error($err);
                 }
                 my $tagID;
                 # loop through all tags in reverse order so we save thumbnail
                 # data before main image data if both exist in the same IFD
                 foreach $tagID (reverse sort keys %$offsetInfo) {
-                    my $tagInfo = $offsetInfo->{$tagID}[0];
+                    my $tagInfo = $$offsetInfo{$tagID}[0];
                     next unless $$tagInfo{IsOffset}; # handle byte counts with offsets
-                    my $sizeInfo = $offsetInfo->{$$tagInfo{OffsetPair}};
-                    $sizeInfo or $exifTool->Error("No size tag for $dirName:$$tagInfo{Name}"), next;
+                    my $sizeInfo = $$offsetInfo{$$tagInfo{OffsetPair}};
+                    $sizeInfo or $et->Error("No size tag for $dirName:$$tagInfo{Name}"), next;
                     my $dataTag = $$tagInfo{DataTag};
                     # write TIFF image data (strips or tiles) later if requested
                     if ($raf and defined $$origDirInfo{ImageData} and
@@ -3301,9 +3301,9 @@ NoOverwrite:            next if $isNew > 0;
                         # but don't defer writing if replacing with new value
                         (not defined $dataTag or not defined $offsetData{$dataTag}))
                     {
-                        push @writeLater, [ $offsetInfo->{$tagID}, $sizeInfo ];
+                        push @writeLater, [ $$offsetInfo{$tagID}, $sizeInfo ];
                     } else {
-                        push @offsetList, [ $offsetInfo->{$tagID}, $sizeInfo ];
+                        push @offsetList, [ $$offsetInfo{$tagID}, $sizeInfo ];
                     }
                 }
             } else {
@@ -3316,7 +3316,7 @@ NoOverwrite:            next if $isNew > 0;
                 my ($cntInfo, $byteCounts, $count2, $oldSize, $format) = @{$$offsetPair[1]};
                 # must be the same number of offset and byte count values
                 unless ($count == $count2) {
-                    $exifTool->Error("Offsets/ByteCounts disagree on count for $$tagInfo{Name}");
+                    $et->Error("Offsets/ByteCounts disagree on count for $$tagInfo{Name}");
                     return undef;
                 }
                 my $formatStr = $formatName[$format];
@@ -3325,7 +3325,7 @@ NoOverwrite:            next if $isNew > 0;
                 my $n = $count * $formatSize[$format];
                 $n > 4 and $byteCounts = Get32u(\$newData, $byteCounts);
                 if ($byteCounts < 0 or $byteCounts + $n > length($newData)) {
-                    $exifTool->Error("Error reading $$tagInfo{Name} byte counts");
+                    $et->Error("Error reading $$tagInfo{Name} byte counts");
                     return undef;
                 }
                 # get offset base and data pos (abnormal for some preview images)
@@ -3339,7 +3339,7 @@ NoOverwrite:            next if $isNew > 0;
                 }
                 # use different base if necessary for some offsets (Minolta A200)
                 if ($$tagInfo{WrongBase}) {
-                    my $self = $exifTool;
+                    my $self = $et;
                     #### eval WrongBase ($self)
                     $wrongBase = eval $$tagInfo{WrongBase} || 0;
                     $dbase += $wrongBase;
@@ -3358,7 +3358,7 @@ NoOverwrite:            next if $isNew > 0;
                         # calculate end offset of this block
                         $oldEnd = $$oldOffset[$n] + $$oldSize[$n];
                         # update TIFF_END as if we read this data from file
-                        UpdateTiffEnd($exifTool, $oldEnd + $dbase);
+                        UpdateTiffEnd($et, $oldEnd + $dbase);
                     }
                     my $offsetPos = $offsets + $n * 4;
                     my $byteCountPos = $byteCounts + $n * $formatSize[$format];
@@ -3373,7 +3373,7 @@ NoOverwrite:            next if $isNew > 0;
                     if (defined $offset) {
                         $offset -= $dpos;
                     } elsif ($size != 0xfeedfeed) {
-                        $exifTool->Error('Internal error (no offset)');
+                        $et->Error('Internal error (no offset)');
                         return undef;
                     }
                     my $newOffset = length($newData) - $wrongBase;
@@ -3381,20 +3381,20 @@ NoOverwrite:            next if $isNew > 0;
                     # look for 'feed' code to use our new data
                     if ($size == 0xfeedfeed) {
                         unless (defined $dataTag) {
-                            $exifTool->Error("No DataTag defined for $$tagInfo{Name}");
+                            $et->Error("No DataTag defined for $$tagInfo{Name}");
                             return undef;
                         }
                         unless (defined $offsetData{$dataTag}) {
-                            $exifTool->Error("Internal error (no $dataTag)");
+                            $et->Error("Internal error (no $dataTag)");
                             return undef;
                         }
                         if ($count > 1) {
-                            $exifTool->Error("Can't modify $$tagInfo{Name} with count $count");
+                            $et->Error("Can't modify $$tagInfo{Name} with count $count");
                             return undef;
                         }
                         $buff = $offsetData{$dataTag};
                         if ($formatSize[$format] != 4) {
-                            $exifTool->Error("$$cntInfo{Name} is not int32");
+                            $et->Error("$$cntInfo{Name} is not int32");
                             return undef;
                         }
                         # set the data size
@@ -3425,7 +3425,7 @@ NoOverwrite:            next if $isNew > 0;
                     } elsif ($offset >= 0 and $offset+$size <= $dataLen) {
                         # take data from old dir data buffer
                         $buff = substr($$dataPt, $offset, $size);
-                    } elsif ($$exifTool{TIFF_TYPE} eq 'MRW') {
+                    } elsif ($$et{TIFF_TYPE} eq 'MRW') {
                         # TTW segment must be an even 4 bytes long, so pad now if necessary
                         my $n = length $newData;
                         $buff = ($n & 0x03) ? "\0" x (4 - ($n & 0x03)) : '';
@@ -3438,8 +3438,8 @@ NoOverwrite:            next if $isNew > 0;
                     {
                         # (data was read OK)
                         # patch incorrect ThumbnailOffset in Sony A100 1.00 ARW images
-                        if ($$exifTool{TIFF_TYPE} eq 'ARW' and $$tagInfo{Name} eq 'ThumbnailOffset' and
-                            $$exifTool{Model} eq 'DSLR-A100' and $buff !~ /^\xff\xd8\xff/)
+                        if ($$et{TIFF_TYPE} eq 'ARW' and $$tagInfo{Name} eq 'ThumbnailOffset' and
+                            $$et{Model} eq 'DSLR-A100' and $buff !~ /^\xff\xd8\xff/)
                         {
                             my $pos = $offset + $dbase + $dpos;
                             my $try;
@@ -3447,15 +3447,15 @@ NoOverwrite:            next if $isNew > 0;
                                 $raf->Read($try,$size) == $size and $try =~ /^\xff\xd8\xff/)
                             {
                                 $buff = $try;
-                                $exifTool->Warn('Adjusted incorrect A100 ThumbnailOffset', 1);
+                                $et->Warn('Adjusted incorrect A100 ThumbnailOffset', 1);
                             } else {
-                                $exifTool->Error('Invalid ThumbnailImage');
+                                $et->Error('Invalid ThumbnailImage');
                             }
                         }
                     } elsif ($$tagInfo{Name} eq 'ThumbnailOffset' and $offset>=0 and $offset<$dataLen) {
                         # Grrr.  The Canon 350D writes the thumbnail with an incorrect byte count
                         my $diff = $offset + $size - $dataLen;
-                        $exifTool->Warn("ThumbnailImage runs outside EXIF data by $diff bytes (truncated)",1);
+                        $et->Warn("ThumbnailImage runs outside EXIF data by $diff bytes (truncated)",1);
                         # set the size to the available data
                         $size -= $diff;
                         unless (WriteValue($size, $formatStr, 1, \$newData, $byteCountPos)) {
@@ -3463,45 +3463,45 @@ NoOverwrite:            next if $isNew > 0;
                         }
                         # get the truncated image
                         $buff = substr($$dataPt, $offset, $size);
-                    } elsif ($$tagInfo{Name} eq 'PreviewImageStart' and $exifTool->{FILE_TYPE} eq 'JPEG') {
+                    } elsif ($$tagInfo{Name} eq 'PreviewImageStart' and $$et{FILE_TYPE} eq 'JPEG') {
                         # try to load the preview image using the specified offset
                         undef $buff;
-                        my $r = $exifTool->{RAF};
+                        my $r = $$et{RAF};
                         if ($r and not $raf) {
                             my $tell = $r->Tell();
                             # read and validate
                             undef $buff unless $r->Seek($offset+$base+$dataPos,0) and
                                                $r->Read($buff,$size) == $size and
                                                $buff =~ /^.\xd8\xff[\xc4\xdb\xe0-\xef]/s;
-                            $r->Seek($tell, 0) or $exifTool->Error('Seek error'), return undef;
+                            $r->Seek($tell, 0) or $et->Error('Seek error'), return undef;
                         }
                         # set flag if we must load PreviewImage
                         $buff = 'LOAD_PREVIEW' unless defined $buff;
                     } else {
                         my $dataName = $dataTag || $$tagInfo{Name};
-                        return undef if $exifTool->Error("Error reading $dataName data in $name", $inMakerNotes);
+                        return undef if $et->Error("Error reading $dataName data in $name", $inMakerNotes);
                         $buff = '';
                     }
                     if ($$tagInfo{Name} eq 'PreviewImageStart') {
-                        if ($$exifTool{FILE_TYPE} eq 'JPEG' and not $$tagInfo{MakerPreview}) {
+                        if ($$et{FILE_TYPE} eq 'JPEG' and not $$tagInfo{MakerPreview}) {
                             # hold onto the PreviewImage until we can determine if it fits
-                            $exifTool->{PREVIEW_INFO} or $exifTool->{PREVIEW_INFO} = {
+                            $$et{PREVIEW_INFO} or $$et{PREVIEW_INFO} = {
                                 Data => $buff,
                                 Fixup => new Image::ExifTool::Fixup,
                             };
                             if ($$tagInfo{IsOffset} and $$tagInfo{IsOffset} eq '2') {
-                                $exifTool->{PREVIEW_INFO}{NoBaseShift} = 1;
+                                $$et{PREVIEW_INFO}{NoBaseShift} = 1;
                             }
                             if ($offset >= 0 and $offset+$size <= $dataLen) {
                                 # set flag indicating this preview wasn't in a trailer
-                                $exifTool->{PREVIEW_INFO}{WasContained} = 1;
+                                $$et{PREVIEW_INFO}{WasContained} = 1;
                             }
                             $buff = '';
-                        } elsif ($$exifTool{TIFF_TYPE} eq 'ARW' and $$exifTool{Model}  eq 'DSLR-A100') {
+                        } elsif ($$et{TIFF_TYPE} eq 'ARW' and $$et{Model}  eq 'DSLR-A100') {
                             # the A100 double-references the same preview, so ignore the
                             # second one (the offset and size will be patched later)
-                            next if $$exifTool{A100PreviewLength};
-                            $$exifTool{A100PreviewLength} = length $buff if defined $buff;
+                            next if $$et{A100PreviewLength};
+                            $$et{A100PreviewLength} = length $buff if defined $buff;
                         }
                     }
                     # update offset accordingly and add to end of new data
@@ -3529,7 +3529,7 @@ NoOverwrite:            next if $isNew > 0;
         }
         # verify that nothing else got written after determining TTW length
         if (defined $ttwLen and $ttwLen != length($newData)) {
-            $exifTool->Error('Internal error writing MRW TTW');
+            $et->Error('Internal error writing MRW TTW');
         }
     }
 #
@@ -3541,7 +3541,7 @@ NoOverwrite:            next if $isNew > 0;
         if (defined $entry) {
             my $format = Get16u(\$newData, $entry + 2);
             if ($format < 1 or $format > 13) {
-                $exifTool->Error('Internal error copying huge value');
+                $et->Error('Internal error copying huge value');
                 last;
             } else {
                 # set count and offset in directory entry
@@ -3564,7 +3564,7 @@ NoOverwrite:            next if $isNew > 0;
             # our offset expects the data at the end of the SubIFD block (BlockLen + Start),
             # but it will actually be at length($newData) + $blockSize.  So adjust
             # accordingly (and subtract an extra Start because this shift is applied later)
-            $subFix->{Shift} += length($newData) - $$subFix{BlockLen} - 2 * $$subFix{Start} + $blockSize;
+            $$subFix{Shift} += length($newData) - $$subFix{BlockLen} - 2 * $$subFix{Start} + $blockSize;
             $subFix->ApplyFixup(\$newData);
         }
         $blockSize += $size + $pad;
@@ -3583,45 +3583,45 @@ NoOverwrite:            next if $isNew > 0;
         #  this when editing JPEG images anyway))
         $fixup->SetMarkerPointers(\$newData, 'CanonVRD', length($newData) + $blockSize);
         if ($newDataPos) {
-            $fixup->{Shift} += $newDataPos;
+            $$fixup{Shift} += $newDataPos;
             $fixup->ApplyFixup(\$newData);
         }
         # save fixup for adjusting Leica trailer offset if necessary
-        $$exifTool{LeicaTrailer}{Fixup}->AddFixup($fixup) if $$exifTool{LeicaTrailer};
+        $$et{LeicaTrailer}{Fixup}->AddFixup($fixup) if $$et{LeicaTrailer};
         # save fixup for PreviewImage in JPEG file if necessary
-        my $previewInfo = $exifTool->{PREVIEW_INFO};
+        my $previewInfo = $$et{PREVIEW_INFO};
         if ($previewInfo) {
-            my $pt = \$previewInfo->{Data}; # image data or 'LOAD_PREVIEW' flag
+            my $pt = \$$previewInfo{Data}; # image data or 'LOAD_PREVIEW' flag
             # now that we know the size of the EXIF data, first test to see if our new image fits
             # inside the EXIF segment (remember about the TIFF and EXIF headers: 8+6 bytes)
             if (($$pt ne 'LOAD_PREVIEW' and length($$pt) + length($newData) + 14 <= 0xfffd and
-                not $previewInfo->{IsTrailer}) or
-                $previewInfo->{IsShort}) # must fit in this segment if using short pointers
+                not $$previewInfo{IsTrailer}) or
+                $$previewInfo{IsShort}) # must fit in this segment if using short pointers
             {
                 # It fits! (or must exist in EXIF segment), so fixup the
                 # PreviewImage pointers and stuff the preview image in here
                 my $newPos = length($newData) + $newDataPos;
-                $newPos += ($previewInfo->{BaseShift} || 0);
-                if ($previewInfo->{Relative}) {
+                $newPos += ($$previewInfo{BaseShift} || 0);
+                if ($$previewInfo{Relative}) {
                     # calculate our base by looking at how far the pointer got shifted
                     $newPos -= ($fixup->GetMarkerPointers(\$newData, 'PreviewImage') || 0);
                 }
                 $fixup->SetMarkerPointers(\$newData, 'PreviewImage', $newPos);
                 $newData .= $$pt;
                 # set flag to delete old preview unless it was contained in the EXIF
-                $exifTool->{DEL_PREVIEW} = 1 unless $exifTool->{PREVIEW_INFO}{WasContained};       
-                delete $exifTool->{PREVIEW_INFO};   # done with our preview data
+                $$et{DEL_PREVIEW} = 1 unless $$et{PREVIEW_INFO}{WasContained};       
+                delete $$et{PREVIEW_INFO};   # done with our preview data
             } else {
                 # Doesn't fit, or we still don't know, so save fixup information
                 # and put the preview at the end of the file
-                $previewInfo->{Fixup} or $previewInfo->{Fixup} = new Image::ExifTool::Fixup;
-                $previewInfo->{Fixup}->AddFixup($fixup);
+                $$previewInfo{Fixup} or $$previewInfo{Fixup} = new Image::ExifTool::Fixup;
+                $$previewInfo{Fixup}->AddFixup($fixup);
             }
         } elsif (defined $newData and $deleteAll) {
             $newData = '';  # delete both IFD0 and IFD1 since only mandatory tags remain
-        } elsif ($$exifTool{A100PreviewLength}) {
+        } elsif ($$et{A100PreviewLength}) {
             # save preview image start for patching A100 quirks later
-            $$exifTool{A100PreviewStart} = $fixup->GetMarkerPointers(\$newData, 'PreviewImage');
+            $$et{A100PreviewStart} = $fixup->GetMarkerPointers(\$newData, 'PreviewImage');
         }
         # save location of last IFD for use in Canon RAW header
         if ($newDataPos == 16) {
@@ -3629,10 +3629,10 @@ NoOverwrite:            next if $isNew > 0;
             $$origDirInfo{LastIFD} = pop @ifdPos;
         }
         # recrypt SR2 SubIFD data if necessary
-        my $key = $$exifTool{SR2SubIFDKey};
+        my $key = $$et{SR2SubIFDKey};
         if ($key) {
             my $start = $fixup->GetMarkerPointers(\$newData, 'SR2SubIFDOffset');
-            my $len = $$exifTool{SR2SubIFDLength};
+            my $len = $$et{SR2SubIFDLength};
             # (must subtract 8 for size of TIFF header)
             if ($start and $start - 8 + $len <= length $newData) {
                 require Image::ExifTool::Sony;