exiftool_vendored 9.37.0 → 9.41.0

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

@@ -19,7 +19,7 @@ use Image::ExifTool qw(:DataAccess);
 use Image::ExifTool::Canon;
 use Image::ExifTool::Exif;
 
-$VERSION = '1.45';
+$VERSION = '1.46';
 
 sub ProcessCanonCustom($$$);
 sub ProcessCanonCustom2($$$);
@@ -2285,27 +2285,27 @@ sub ConvertPfnInv($)
 # Returns: 1 on success
 sub ProcessCanonCustom2($$$)
 {
-    my ($exifTool, $dirInfo, $tagTablePtr) = @_;
+    my ($et, $dirInfo, $tagTablePtr) = @_;
     my $dataPt = $$dirInfo{DataPt};
     my $offset = $$dirInfo{DirStart};
     my $size = $$dirInfo{DirLen};
     my $write = $$dirInfo{Write};
-    my $verbose = $exifTool->Options('Verbose');
+    my $verbose = $et->Options('Verbose');
     my $newTags;
 
     # first entry in array must be the size
     my $len = Get16u($dataPt, $offset);
     unless ($len == $size and $len >= 8) {
-        $exifTool->Warn("Invalid CanonCustom2 data");
+        $et->Warn("Invalid CanonCustom2 data");
         return 0;
     }
     # get group count
     my $count = Get32u($dataPt, $offset + 4);
     if ($write) {
-        $newTags = $exifTool->GetNewTagInfoHash($tagTablePtr);
-        $exifTool->VPrint(0, "  Rewriting CanonCustom2\n");
+        $newTags = $et->GetNewTagInfoHash($tagTablePtr);
+        $et->VPrint(0, "  Rewriting CanonCustom2\n");
     } elsif ($verbose) {
-        $exifTool->VerboseDir('CanonCustom2', $count);
+        $et->VerboseDir('CanonCustom2', $count);
     }
     my $pos = $offset + 8;
     my $end = $offset + $size;
@@ -2320,7 +2320,7 @@ sub ProcessCanonCustom2($$$)
         my $recPos = $pos;
         my $recEnd = $pos + $recLen;
         if ($verbose and not $write) {
-            $exifTool->VerboseDir("CanonCustom2 group $recNum", $recCount);
+            $et->VerboseDir("CanonCustom2 group $recNum", $recCount);
         }
         my ($i, $num, $tag);
         for ($i=0; $recPos + 8 < $recEnd; ++$i, $recPos+=4*$num) {
@@ -2333,18 +2333,18 @@ sub ProcessCanonCustom2($$$)
                 # write new value
                 my $tagInfo = $$newTags{$tag};
                 next unless $tagInfo;
-                my $nvHash = $exifTool->GetNewValueHash($tagInfo);
-                next unless $exifTool->IsOverwriting($nvHash, $val);
-                my $newVal = $exifTool->GetNewValues($nvHash);
+                my $nvHash = $et->GetNewValueHash($tagInfo);
+                next unless $et->IsOverwriting($nvHash, $val);
+                my $newVal = $et->GetNewValues($nvHash);
                 next unless defined $newVal;    # can't delete from a custom table
                 WriteValue($newVal, 'int32s', $num, $dataPt, $recPos);
-                $exifTool->VerboseValue("- CanonCustom:$$tagInfo{Name}", $val);
-                $exifTool->VerboseValue("+ CanonCustom:$$tagInfo{Name}", $newVal);
-                ++$exifTool->{CHANGED};
+                $et->VerboseValue("- CanonCustom:$$tagInfo{Name}", $val);
+                $et->VerboseValue("+ CanonCustom:$$tagInfo{Name}", $newVal);
+                ++$$et{CHANGED};
             } else {
                 # save extracted tag
                 my $oldInfo = $$tagTablePtr{$tag};
-                $exifTool->HandleTag($tagTablePtr, $tag, $val,
+                $et->HandleTag($tagTablePtr, $tag, $val,
                     Index  => $i,
                     Format => 'int32u',
                     Count  => $num,
@@ -2361,7 +2361,7 @@ sub ProcessCanonCustom2($$$)
         $pos += $recLen - 8;
     }
     if ($pos != $end) {
-        $exifTool->Warn('Possibly corrupted CanonCustom2 data');
+        $et->Warn('Possibly corrupted CanonCustom2 data');
         return 0;
     }
     return 1;
@@ -2373,8 +2373,8 @@ sub ProcessCanonCustom2($$$)
 # Returns: New custom data block or undefined on error
 sub WriteCanonCustom2($$$)
 {
-    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 $dataPt = $$dirInfo{DataPt};
     # edit a copy of the custom function 2 data
     my $buff = substr($$dataPt, $$dirInfo{DirStart}, $$dirInfo{DirLen});
@@ -2384,7 +2384,7 @@ sub WriteCanonCustom2($$$)
         DirLen   => $$dirInfo{DirLen},
         Write    => 1,
     );
-    ProcessCanonCustom2($exifTool, \%dirInfo, $tagTablePtr) or return undef;
+    ProcessCanonCustom2($et, \%dirInfo, $tagTablePtr) or return undef;
     return $buff;
 }
 
@@ -2394,26 +2394,26 @@ sub WriteCanonCustom2($$$)
 # Returns: 1 on success
 sub ProcessCanonCustom($$$)
 {
-    my ($exifTool, $dirInfo, $tagTablePtr) = @_;
+    my ($et, $dirInfo, $tagTablePtr) = @_;
     my $dataPt = $$dirInfo{DataPt};
     my $offset = $$dirInfo{DirStart};
     my $size = $$dirInfo{DirLen};
-    my $verbose = $exifTool->Options('Verbose');
+    my $verbose = $et->Options('Verbose');
 
     # first entry in array must be the size
     my $len = Get16u($dataPt,$offset);
-    unless ($len == $size or ($$exifTool{Model}=~/\bD60\b/ and $len+2 == $size)) {
-        $exifTool->Warn("Invalid CanonCustom data");
+    unless ($len == $size or ($$et{Model}=~/\bD60\b/ and $len+2 == $size)) {
+        $et->Warn("Invalid CanonCustom data");
         return 0;
     }
-    $verbose and $exifTool->VerboseDir('CanonCustom', $size/2-1);
+    $verbose and $et->VerboseDir('CanonCustom', $size/2-1);
     my $pos;
     for ($pos=2; $pos<$size; $pos+=2) {
         # ($pos is position within custom directory)
         my $val = Get16u($dataPt,$offset+$pos);
         my $tag = ($val >> 8);
         $val = ($val & 0xff);
-        $exifTool->HandleTag($tagTablePtr, $tag, $val,
+        $et->HandleTag($tagTablePtr, $tag, $val,
             Index  => $pos/2-1,
             Format => 'int8u',
             Count  => 1,
@@ -2429,7 +2429,7 @@ sub ProcessCanonCustom($$$)
 # Returns: error string or undef (and may modify value) on success
 sub CheckCanonCustom($$$)
 {
-    my ($exifTool, $tagInfo, $valPtr) = @_;
+    my ($et, $tagInfo, $valPtr) = @_;
     return Image::ExifTool::CheckValue($valPtr, 'int8u');
 }
 
@@ -2439,8 +2439,8 @@ sub CheckCanonCustom($$$)
 # Returns: New custom data block or undefined on error
 sub WriteCanonCustom($$$)
 {
-    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 $dataPt = $$dirInfo{DataPt};
     my $dirStart = $$dirInfo{DirStart} || 0;
     my $dirLen = $$dirInfo{DirLen} || length($$dataPt) - $dirStart;
@@ -2450,26 +2450,26 @@ sub WriteCanonCustom($$$)
 
     # first entry in array must be the size
     my $len = Get16u($dataPt, 0);
-    unless ($len == $dirLen or ($$exifTool{Model}=~/\bD60\b/ and $len+2 == $dirLen)) {
-        $exifTool->Warn("Invalid CanonCustom data");
+    unless ($len == $dirLen or ($$et{Model}=~/\bD60\b/ and $len+2 == $dirLen)) {
+        $et->Warn("Invalid CanonCustom data");
         return undef;
     }
-    my $newTags = $exifTool->GetNewTagInfoHash($tagTablePtr);
+    my $newTags = $et->GetNewTagInfoHash($tagTablePtr);
     my $pos;
     for ($pos=2; $pos<$dirLen; $pos+=2) {
         my $val = Get16u($dataPt, $pos);
         my $tag = ($val >> 8);
         my $tagInfo = $$newTags{$tag};
         next unless $tagInfo;
-        my $nvHash = $exifTool->GetNewValueHash($tagInfo);
+        my $nvHash = $et->GetNewValueHash($tagInfo);
         $val = ($val & 0xff);
-        next unless $exifTool->IsOverwriting($nvHash, $val);
-        my $newVal = $exifTool->GetNewValues($nvHash);
+        next unless $et->IsOverwriting($nvHash, $val);
+        my $newVal = $et->GetNewValues($nvHash);
         next unless defined $newVal;    # can't delete from a custom table
         Set16u(($newVal & 0xff) + ($tag << 8), $dataPt, $pos);
-        $exifTool->VerboseValue("- $dirName:$$tagInfo{Name}", $val);
-        $exifTool->VerboseValue("+ $dirName:$$tagInfo{Name}", $newVal);
-        ++$exifTool->{CHANGED};
+        $et->VerboseValue("- $dirName:$$tagInfo{Name}", $val);
+        $et->VerboseValue("+ $dirName:$$tagInfo{Name}", $newVal);
+        ++$$et{CHANGED};
     }
     return $newData;
 }

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

@@ -21,7 +21,7 @@ use Image::ExifTool qw(:DataAccess :Utils);
 use Image::ExifTool::Exif;
 use Image::ExifTool::Canon;
 
-$VERSION = '1.55';
+$VERSION = '1.56';
 
 sub WriteCRW($$);
 sub ProcessCanonRaw($$$);
@@ -634,13 +634,13 @@ sub AUTOLOAD
 # Returns: 1 on success
 sub ProcessCanonRaw($$$)
 {
-    my ($exifTool, $dirInfo, $rawTagTable) = @_;
+    my ($et, $dirInfo, $rawTagTable) = @_;
     my $blockStart = $$dirInfo{DirStart};
     my $blockSize = $$dirInfo{DirLen};
     my $raf = $$dirInfo{RAF} or return 0;
     my $buff;
-    my $verbose = $exifTool->Options('Verbose');
-    my $buildMakerNotes = $exifTool->Options('MakerNotes');
+    my $verbose = $et->Options('Verbose');
+    my $buildMakerNotes = $et->Options('MakerNotes');
 
     # 4 bytes at end of block give directory position within block
     $raf->Seek($blockStart+$blockSize-4, 0) or return 0;
@@ -652,7 +652,7 @@ sub ProcessCanonRaw($$$)
     # read the directory (10 bytes per entry)
     $raf->Read($buff, 10 * $entries) == 10 * $entries or return 0;
 
-    $verbose and $exifTool->VerboseDir('CIFF', $entries);
+    $verbose and $et->VerboseDir('CIFF', $entries);
     my $index;
     for ($index=0; $index<$entries; ++$index) {
         my $pt = 10 * $index;
@@ -661,13 +661,13 @@ sub ProcessCanonRaw($$$)
         my $valuePtr = Get32u(\$buff, $pt+6);
         my $ptr = $valuePtr + $blockStart;  # all pointers relative to block start
         if ($tag & 0x8000) {
-            $exifTool->Warn('Bad CRW directory entry');
+            $et->Warn('Bad CRW directory entry');
             return 1;
         }
         my $tagID = $tag & 0x3fff;          # get tag ID
         my $tagType = ($tag >> 8) & 0x38;   # get tag type
         my $valueInDir = ($tag & 0x4000);   # flag for value in directory
-        my $tagInfo = $exifTool->GetTagInfo($rawTagTable, $tagID);
+        my $tagInfo = $et->GetTagInfo($rawTagTable, $tagID);
         if (($tagType==0x28 or $tagType==0x30) and not $valueInDir) {
             # this type of tag specifies a raw subdirectory
             my $name;
@@ -684,13 +684,13 @@ sub ProcessCanonRaw($$$)
             );
             if ($verbose) {
                 my $fakeInfo = { Name => $name, SubDirectory => { } };
-                $exifTool->VerboseInfo($tagID, $fakeInfo,
+                $et->VerboseInfo($tagID, $fakeInfo,
                     'Index'  => $index,
                     'Size'   => $size,
                     'Start'  => $ptr,
                 );
             }
-            $exifTool->ProcessDirectory(\%subdirInfo, $rawTagTable);
+            $et->ProcessDirectory(\%subdirInfo, $rawTagTable);
             next;
         }
         my ($valueDataPos, $count, $subdir);
@@ -714,21 +714,21 @@ sub ProcessCanonRaw($$$)
             $valueDataPos = $ptr;
             if ($size <= 512 or ($verbose > 2 and $size <= 65536)
                 or ($tagInfo and ($$tagInfo{SubDirectory}
-                or grep(/^$$tagInfo{Name}$/i, $exifTool->GetRequestedTags()) )))
+                or grep(/^$$tagInfo{Name}$/i, $et->GetRequestedTags()) )))
             {
                 # read value if size is small or specifically requested
                 # or if this is a SubDirectory
                 unless ($raf->Seek($ptr, 0) and $raf->Read($value, $size) == $size) {
-                    $exifTool->Warn(sprintf("Error reading %d bytes from 0x%x",$size,$ptr));
+                    $et->Warn(sprintf("Error reading %d bytes from 0x%x",$size,$ptr));
                     next;
                 }
             } else {
                 $value = "Binary data $size bytes";
                 if ($tagInfo) {
-                    if ($exifTool->Options('Binary') or $verbose) {
+                    if ($et->Options('Binary') or $verbose) {
                         # read the value anyway
                         unless ($raf->Seek($ptr, 0) and $raf->Read($value, $size) == $size) {
-                            $exifTool->Warn(sprintf("Error reading %d bytes from 0x%x",$size,$ptr));
+                            $et->Warn(sprintf("Error reading %d bytes from 0x%x",$size,$ptr));
                             next;
                         }
                     }
@@ -750,7 +750,7 @@ sub ProcessCanonRaw($$$)
         if ($verbose) {
             my $val = $value;
             $format and $val = ReadValue(\$val, 0, $format, $count, $size);
-            $exifTool->VerboseInfo($tagID, $tagInfo,
+            $et->VerboseInfo($tagID, $tagInfo,
                 Table   => $rawTagTable,
                 Index   => $index,
                 Value   => $val,
@@ -763,7 +763,7 @@ sub ProcessCanonRaw($$$)
         }
         if ($buildMakerNotes) {
             # build maker notes information if requested
-            BuildMakerNotes($exifTool, $tagID, $tagInfo, \$value, $format, $count);
+            BuildMakerNotes($et, $tagID, $tagInfo, \$value, $format, $count);
         }
         next unless defined $tagInfo;
 
@@ -798,15 +798,15 @@ sub ProcessCanonRaw($$$)
             );
             #### 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 {
-                $exifTool->ProcessDirectory(\%subdirInfo, $newTagTable, $$subdir{ProcessProc});
+                $et->ProcessDirectory(\%subdirInfo, $newTagTable, $$subdir{ProcessProc});
             }
         } else {
             # convert to specified format if necessary
             $format and $value = ReadValue(\$value, 0, $format, $count, $size);
             # save the information
-            $exifTool->FoundTag($tagInfo, $value);
+            $et->FoundTag($tagInfo, $value);
             delete $$tagInfo{RawConv} if $delRawConv;
         }
     }
@@ -819,10 +819,10 @@ sub ProcessCanonRaw($$$)
 # Returns: 1 if this was a valid Canon RAW file
 sub ProcessCRW($$)
 {
-    my ($exifTool, $dirInfo) = @_;
+    my ($et, $dirInfo) = @_;
     my ($buff, $sig);
     my $raf = $$dirInfo{RAF};
-    my $buildMakerNotes = $exifTool->Options('MakerNotes');
+    my $buildMakerNotes = $et->Options('MakerNotes');
 
     $raf->Read($buff,2) == 2      or return 0;
     SetByteOrder($buff)           or return 0;
@@ -835,10 +835,10 @@ sub ProcessCRW($$)
     my $filesize = $raf->Tell()   or return 0;
 
     # initialize maker note data if building maker notes
-    $buildMakerNotes and InitMakerNotes($exifTool);
+    $buildMakerNotes and InitMakerNotes($et);
 
     # set the FileType tag unless already done (ie. APP0 CIFF record in JPEG image)
-    $exifTool->SetFileType();
+    $et->SetFileType();
 
     # build directory information for main raw directory
     my %dirInfo = (
@@ -852,20 +852,20 @@ sub ProcessCRW($$)
 
     # process the raw directory
     my $rawTagTable = GetTagTable('Image::ExifTool::CanonRaw::Main');
-    my $oldIndent = $$exifTool{INDENT};
-    $$exifTool{INDENT} .= '| ';
-    unless (ProcessCanonRaw($exifTool, \%dirInfo, $rawTagTable)) {
-        $exifTool->Warn('CRW file format error');
+    my $oldIndent = $$et{INDENT};
+    $$et{INDENT} .= '| ';
+    unless (ProcessCanonRaw($et, \%dirInfo, $rawTagTable)) {
+        $et->Warn('CRW file format error');
     }
-    $$exifTool{INDENT} = $oldIndent;
+    $$et{INDENT} = $oldIndent;
 
     # finish building maker notes if necessary
-    $buildMakerNotes and SaveMakerNotes($exifTool);
+    $buildMakerNotes and SaveMakerNotes($et);
 
     # process trailers if they exist in CRW file (not in CIFF information!)
-    if ($$exifTool{FILE_TYPE} eq 'CRW') {
+    if ($$et{FILE_TYPE} eq 'CRW') {
         my $trailInfo = Image::ExifTool::IdentifyTrailer($raf);
-        $exifTool->ProcessTrailers($trailInfo) if $trailInfo;
+        $et->ProcessTrailers($trailInfo) if $trailInfo;
     }
 
     return 1;

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

@@ -20,7 +20,7 @@ use strict;
 use vars qw($VERSION);
 use Image::ExifTool qw(:DataAccess :Utils);
 
-$VERSION = '1.20';
+$VERSION = '1.21';
 
 sub ProcessCanonVRD($$;$);
 sub WriteCanonVRD($$;$);
@@ -998,19 +998,19 @@ sub ToneCurvePrintInv($)
 # Returns: Reading: 1 on success; Writing: modified edit data, or undef if nothing changed
 sub ProcessEditData($$$)
 {
-    my ($exifTool, $dirInfo, $tagTablePtr) = @_;
-    $exifTool or return 1;    # allow dummy access
+    my ($et, $dirInfo, $tagTablePtr) = @_;
+    $et or return 1;    # allow dummy access
     my $dataPt = $$dirInfo{DataPt};
     my $pos = $$dirInfo{DirStart};
     my $dataPos = $$dirInfo{DataPos};
     my $outfile = $$dirInfo{OutFile};
     my $dirLen = $$dirInfo{DirLen};
     my $dirEnd = $pos + $dirLen;
-    my $verbose = $exifTool->Options('Verbose');
-    my $out = $exifTool->Options('TextOut');
-    my $oldChanged = $$exifTool{CHANGED};
+    my $verbose = $et->Options('Verbose');
+    my $out = $et->Options('TextOut');
+    my $oldChanged = $$et{CHANGED};
 
-    $exifTool->VerboseDir('VRD Edit Data', 0, $dirLen) unless $outfile;
+    $et->VerboseDir('VRD Edit Data', 0, $dirLen) unless $outfile;
 
     # loop through all records in the edit data
     my ($recNum, $recLen, $err);
@@ -1023,19 +1023,19 @@ sub ProcessEditData($$$)
         }
         $pos += 4;          # move to start of record
         if ($pos + $recLen > $dirEnd) {
-            $exifTool->Warn('Possibly corrupt CanonVRD Edit record');
+            $et->Warn('Possibly corrupt CanonVRD Edit record');
             $err = 1;
             last;
         }
         if ($verbose > 1 and not $outfile) {
-            printf $out "$$exifTool{INDENT}CanonVRD Edit record ($recLen bytes at offset 0x%x)\n",
+            printf $out "$$et{INDENT}CanonVRD Edit record ($recLen bytes at offset 0x%x)\n",
                    $pos + $dataPos;
             if ($recNum and $verbose > 2) {
                 my %parms = (
                     Start  => $pos,
                     Addr   => $pos + $dataPos,
                     Out    => $out,
-                    Prefix => $$exifTool{INDENT},
+                    Prefix => $$et{INDENT},
                 );
                 $parms{MaxLen} = $verbose == 3 ? 96 : 2048 if $verbose < 5;
                 Image::ExifTool::HexDump($dataPt, $recLen, %parms);
@@ -1079,17 +1079,17 @@ sub ProcessEditData($$$)
                 if ($outfile) {
                     # rewrite this section of the VRD edit information
                     $verbose and print $out "  Rewriting Canon $subName\n";
-                    my $newVal = $exifTool->WriteDirectory(\%subdirInfo, $subTable);
+                    my $newVal = $et->WriteDirectory(\%subdirInfo, $subTable);
                     substr($$dataPt, $pos+$start, $dirLen) = $newVal if $newVal;
                 } else {
-                    $exifTool->VPrint(0, "$$exifTool{INDENT}$subName (SubDirectory) -->\n");
-                    $exifTool->VerboseDump(\$editData,
+                    $et->VPrint(0, "$$et{INDENT}$subName (SubDirectory) -->\n");
+                    $et->VerboseDump(\$editData,
                         Start => $start,
                         Addr  => $dataPos + $pos + $start,
                         Len   => $dirLen,
                     );
                     # extract tags from this section of the VRD edit information
-                    $exifTool->ProcessDirectory(\%subdirInfo, $subTable);
+                    $et->ProcessDirectory(\%subdirInfo, $subTable);
                 }
             }
             # next section starts at the end of this one
@@ -1097,7 +1097,7 @@ sub ProcessEditData($$$)
         }
     }
     if ($outfile) {
-        return undef if $oldChanged == $$exifTool{CHANGED};
+        return undef if $oldChanged == $$et{CHANGED};
         return substr($$dataPt, $$dirInfo{DirStart}, $dirLen);
     }
     return $err ? 0 : 1;
@@ -1109,31 +1109,31 @@ sub ProcessEditData($$$)
 # Returns: 1 on success
 sub ProcessIHL($$$)
 {
-    my ($exifTool, $dirInfo, $tagTablePtr) = @_;
+    my ($et, $dirInfo, $tagTablePtr) = @_;
     my $dataPt = $$dirInfo{DataPt};
     my $dataPos = $$dirInfo{DataPos};
     my $pos = $$dirInfo{DirStart};
     my $dirLen = $$dirInfo{DirLen};
     my $dirEnd = $pos + $dirLen;
 
-    $exifTool->VerboseDir('VRD IHL', 0, $dirLen);
+    $et->VerboseDir('VRD IHL', 0, $dirLen);
 
     SetByteOrder('II'); # (make up your mind, Canon!)
     while ($pos + 48 <= $dirEnd) {
         my $hdr = substr($$dataPt, $pos, 48);
         unless ($hdr =~ /^IHL Created Optional Item Data\0\0/) {
-            $exifTool->Warn('Possibly corrupted VRD IHL data');
+            $et->Warn('Possibly corrupted VRD IHL data');
             last;
         }
         my $tag  = Get32u($dataPt, $pos + 36);
         my $size = Get32u($dataPt, $pos + 40); # size of data in IHL record
         my $next = Get32u($dataPt, $pos + 44); # size of complete IHL record
         if ($size > $next or $pos + 48 + $next > $dirEnd) {
-            $exifTool->Warn(sprintf('Bad size for VRD IHL tag 0x%.4x', $tag));
+            $et->Warn(sprintf('Bad size for VRD IHL tag 0x%.4x', $tag));
             last;
         }
         $pos += 48;
-        $exifTool->HandleTag($tagTablePtr, $tag, substr($$dataPt, $pos, $size),
+        $et->HandleTag($tagTablePtr, $tag, substr($$dataPt, $pos, $size),
             DataPt  => $dataPt,
             DataPos => $dataPos,
             Start   => $pos,
@@ -1150,13 +1150,13 @@ sub ProcessIHL($$$)
 # Returns: 1 on success
 sub ProcessIHLExif($$$)
 {
-    my ($exifTool, $dirInfo, $tagTablePtr) = @_;
-    $$exifTool{DOC_NUM} = 1;
+    my ($et, $dirInfo, $tagTablePtr) = @_;
+    $$et{DOC_NUM} = 1;
     # the IHL-edited maker notes may look messed up, but the offsets should be OK
-    my $oldFix = $exifTool->Options(FixBase => 0);
-    my $rtnVal = $exifTool->ProcessTIFF($dirInfo, $tagTablePtr);
-    $exifTool->Options(FixBase => $oldFix);
-    delete $$exifTool{DOC_NUM};
+    my $oldFix = $et->Options(FixBase => 0);
+    my $rtnVal = $et->ProcessTIFF($dirInfo, $tagTablePtr);
+    $et->Options(FixBase => $oldFix);
+    delete $$et{DOC_NUM};
     return $rtnVal;
 }
 
@@ -1166,41 +1166,41 @@ sub ProcessIHLExif($$$)
 # Returns: 1 if this was a Canon VRD file, 0 otherwise, -1 on write error
 sub ProcessVRD($$)
 {
-    my ($exifTool, $dirInfo) = @_;
+    my ($et, $dirInfo) = @_;
     my $raf = $$dirInfo{RAF};
     my $buff;
     my $num = $raf->Read($buff, 0x1c);
 
     # initialize write directories if necessary
-    $exifTool->InitWriteDirs(\%vrdMap, 'XMP') if $$dirInfo{OutFile};
+    $et->InitWriteDirs(\%vrdMap, 'XMP') if $$dirInfo{OutFile};
 
     if (not $num and $$dirInfo{OutFile}) {
         # create new VRD file from scratch
-        my $newVal = $exifTool->GetNewValues('CanonVRD');
+        my $newVal = $et->GetNewValues('CanonVRD');
         if ($newVal) {
-            $exifTool->VPrint(0, "  Writing CanonVRD as a block\n");
+            $et->VPrint(0, "  Writing CanonVRD as a block\n");
             Write($$dirInfo{OutFile}, $newVal) or return -1;
-            ++$exifTool->{CHANGED};
+            ++$$et{CHANGED};
         } else {
             # allow VRD to be created from individual tags
-            if ($$exifTool{ADD_DIRS}{CanonVRD}) {
+            if ($$et{ADD_DIRS}{CanonVRD}) {
                 my $newVal = '';
-                if (ProcessCanonVRD($exifTool, { OutFile => \$newVal }) > 0) {
+                if (ProcessCanonVRD($et, { OutFile => \$newVal }) > 0) {
                     Write($$dirInfo{OutFile}, $newVal) or return -1;
-                    ++$exifTool->{CHANGED};
+                    ++$$et{CHANGED};
                     return 1;
                 }
             }
-            $exifTool->Error('No CanonVRD information to write');
+            $et->Error('No CanonVRD information to write');
         }
     } else {
         $num == 0x1c or return 0;
         $buff =~ /^CANON OPTIONAL DATA\0/ or return 0;
-        $exifTool->SetFileType();
+        $et->SetFileType();
         $$dirInfo{DirName} = 'CanonVRD';    # set directory name for verbose output
-        my $result = ProcessCanonVRD($exifTool, $dirInfo);
+        my $result = ProcessCanonVRD($et, $dirInfo);
         return $result if $result < 0;
-        $result or $exifTool->Warn('Format error in VRD file');
+        $result or $et->Warn('Format error in VRD file');
     }
     return 1;
 }
@@ -1212,13 +1212,13 @@ sub ProcessVRD($$)
 # Notes: Increments ExifTool CHANGED flag if changed
 sub WriteCanonVRD($$;$)
 {
-    my ($exifTool, $dirInfo, $tagTablePtr) = @_;
-    $exifTool or return 1;    # allow dummy access
-    my $nvHash = $exifTool->GetNewValueHash($Image::ExifTool::Extra{CanonVRD});
-    return undef unless $exifTool->IsOverwriting($nvHash);
-    my $val = $exifTool->GetNewValues($nvHash);
+    my ($et, $dirInfo, $tagTablePtr) = @_;
+    $et or return 1;    # allow dummy access
+    my $nvHash = $et->GetNewValueHash($Image::ExifTool::Extra{CanonVRD});
+    return undef unless $et->IsOverwriting($nvHash);
+    my $val = $et->GetNewValues($nvHash);
     $val = '' unless defined $val;
-    ++$exifTool->{CHANGED};
+    ++$$et{CHANGED};
     return $val;
 }
 
@@ -1230,12 +1230,12 @@ sub WriteCanonVRD($$;$)
 # - updates DirLen to trailer length
 sub ProcessCanonVRD($$;$)
 {
-    my ($exifTool, $dirInfo, $tagTablePtr) = @_;
+    my ($et, $dirInfo, $tagTablePtr) = @_;
     my $raf = $$dirInfo{RAF};
     my $offset = $$dirInfo{Offset} || 0;
     my $outfile = $$dirInfo{OutFile};
-    my $verbose = $exifTool->Options('Verbose');
-    my $out = $exifTool->Options('TextOut');
+    my $verbose = $et->Options('Verbose');
+    my $out = $et->Options('TextOut');
     my ($buff, $footer, $header, $created, $err);
     my ($blockLen, $blockType, $size, %didDir);
 
@@ -1266,14 +1266,14 @@ sub ProcessCanonVRD($$;$)
             $header =~ /^CANON OPTIONAL DATA\0/ and
             $raf->Read($buff, $size) == $size)
     {
-        $exifTool->Warn('Bad CanonVRD trailer');
+        $et->Warn('Bad CanonVRD trailer');
         return 0;
     }
     # extract CanonVRD block if copying tags, or if requested
-    if (($exifTool->{TAGS_FROM_FILE} and not $exifTool->{EXCL_TAG_LOOKUP}{canonvrd}) or
-        $exifTool->{REQ_TAG_LOOKUP}{canonvrd})
+    if (($$et{TAGS_FROM_FILE} and not $$et{EXCL_TAG_LOOKUP}{canonvrd}) or
+        $$et{REQ_TAG_LOOKUP}{canonvrd})
     {
-        $exifTool->FoundTag('CanonVRD', $header . $buff . $footer);
+        $et->FoundTag('CanonVRD', $header . $buff . $footer);
     }
     # set variables returned in dirInfo hash
     $$dirInfo{DataPos} = $raf->Tell() - $size - 0x1c;
@@ -1282,35 +1282,35 @@ sub ProcessCanonVRD($$;$)
     if ($outfile) {
         $verbose and not $created and printf $out "  Rewriting CanonVRD trailer\n";
         # delete CanonVRD information if specified
-        if ($exifTool->{DEL_GROUP}->{CanonVRD} or $exifTool->{DEL_GROUP}->{Trailer} or
+        if ($$et{DEL_GROUP}{CanonVRD} or $$et{DEL_GROUP}{Trailer} or
             # also delete if writing as a block (will get added back again later)
-            $exifTool->{NEW_VALUE}->{$Image::ExifTool::Extra{CanonVRD}})
+            $$et{NEW_VALUE}{$Image::ExifTool::Extra{CanonVRD}})
         {
-            if ($exifTool->{FILE_TYPE} eq 'VRD') {
-                my $newVal = $exifTool->GetNewValues('CanonVRD');
+            if ($$et{FILE_TYPE} eq 'VRD') {
+                my $newVal = $et->GetNewValues('CanonVRD');
                 if ($newVal) {
                     $verbose and printf $out "  Writing CanonVRD as a block\n";
                     Write($outfile, $newVal) or return -1;
-                    ++$exifTool->{CHANGED};
+                    ++$$et{CHANGED};
                 } else {
-                    $exifTool->Error("Can't delete all CanonVRD information from a VRD file");
+                    $et->Error("Can't delete all CanonVRD information from a VRD file");
                 }
             } else {
                 $verbose and printf $out "  Deleting CanonVRD trailer\n";
-                ++$exifTool->{CHANGED};
+                ++$$et{CHANGED};
             }
             return 1;
         }
         # write now and return if CanonVRD was set as a block
-        my $val = $exifTool->GetNewValues('CanonVRD');
+        my $val = $et->GetNewValues('CanonVRD');
         if ($val) {
             $verbose and print $out "  Writing CanonVRD as a block\n";
             Write($outfile, $val) or return -1;
-            ++$exifTool->{CHANGED};
+            ++$$et{CHANGED};
             return 1;
         }
-    } elsif ($verbose or $exifTool->{HTML_DUMP}) {
-        $exifTool->DumpTrailer($dirInfo) if $$dirInfo{RAF};
+    } elsif ($verbose or $$et{HTML_DUMP}) {
+        $et->DumpTrailer($dirInfo) if $$dirInfo{RAF};
     }
 
     $tagTablePtr = GetTagTable('Image::ExifTool::CanonVRD::Main');
@@ -1332,7 +1332,7 @@ sub ProcessCanonVRD($$;$)
         }
         $pos += 8;          # move to start of block
         if ($pos + $blockLen > $size) {
-            $exifTool->Warn('Possibly corrupt CanonVRD block');
+            $et->Warn('Possibly corrupt CanonVRD block');
             last;
         }
         if ($verbose > 1 and not $outfile) {
@@ -1343,7 +1343,7 @@ sub ProcessCanonVRD($$;$)
                     Start  => $pos,
                     Addr   => $pos + $vrdPos,
                     Out    => $out,
-                    Prefix => $$exifTool{INDENT},
+                    Prefix => $$et{INDENT},
                 );
                 $parms{MaxLen} = $verbose == 3 ? 96 : 2048 if $verbose < 5;
                 Image::ExifTool::HexDump($dataPt, $blockLen, %parms);
@@ -1351,7 +1351,7 @@ sub ProcessCanonVRD($$;$)
         }
         my $tagInfo = $$tagTablePtr{$blockType};
         unless ($tagInfo) {
-            unless ($exifTool->Options('Unknown')) {
+            unless ($et->Options('Unknown')) {
                 $pos += $blockLen;  # step to next block
                 next;
             }
@@ -1381,19 +1381,19 @@ sub ProcessCanonVRD($$;$)
                 # set flag indicating we did this directory
                 $didDir{$$tagInfo{Name}} = 1;
                 my $dat;
-                if ($$exifTool{NEW_VALUE}{$tagInfo}) {
+                if ($$et{NEW_VALUE}{$tagInfo}) {
                     # write as a block
-                    $exifTool->VPrint(0, "Writing $$tagInfo{Name} as a block\n");
-                    $dat = $exifTool->GetNewValues($tagInfo);
+                    $et->VPrint(0, "Writing $$tagInfo{Name} as a block\n");
+                    $dat = $et->GetNewValues($tagInfo);
                     $dat = '' unless defined $dat;
-                    ++$$exifTool{CHANGED};
+                    ++$$et{CHANGED};
                 } else {
-                    $dat = $exifTool->WriteDirectory(\%subdirInfo, $subTablePtr);
+                    $dat = $et->WriteDirectory(\%subdirInfo, $subTablePtr);
                 }
                 # update data with new directory
                 if (defined $dat) {
                     my $buf2;
-                    if (length $dat or $$exifTool{FILE_TYPE} !~ /^(CRW|VRD)$/) {
+                    if (length $dat or $$et{FILE_TYPE} !~ /^(CRW|VRD)$/) {
                         # replace with new block (updating the block length word)
                         $buf2 = substr($$dataPt, 0, $pos - 4) . Set32u(length $dat) . $dat;
                     } else {
@@ -1412,18 +1412,18 @@ sub ProcessCanonVRD($$;$)
                 }
             } else {
                 # extract as a block if requested
-                $exifTool->ProcessDirectory(\%subdirInfo, $subTablePtr);
+                $et->ProcessDirectory(\%subdirInfo, $subTablePtr);
             }
         } else {
-            $exifTool->HandleTag($tagTablePtr, $blockType, substr($$dataPt, $pos, $blockLen));
+            $et->HandleTag($tagTablePtr, $blockType, substr($$dataPt, $pos, $blockLen));
         }
         $pos += $blockLen;  # step to next block
     }
     if ($outfile) {
         # create XMP block if necessary (CRW/VRD files only)
-        if ($$exifTool{ADD_DIRS}{CanonVRD} and not $didDir{XMP}) {
+        if ($$et{ADD_DIRS}{CanonVRD} and not $didDir{XMP}) {
             my $subTablePtr = GetTagTable('Image::ExifTool::XMP::Main');
-            my $dat = $exifTool->WriteDirectory({ Parent => 'CanonVRD' }, $subTablePtr);
+            my $dat = $et->WriteDirectory({ Parent => 'CanonVRD' }, $subTablePtr);
             if ($dat) {
                 $$dataPt .= Set32u(0xffff00f6) . Set32u(length $dat) . $dat;
                 # update the new VRD length in the header/footer