exiftool_vendored 9.37.0 → 9.41.0

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

@@ -17,7 +17,7 @@ use Image::ExifTool qw(:DataAccess :Utils);
 use Image::ExifTool::XMP;
 use Image::ExifTool::ZIP;
 
-$VERSION = '1.03';
+$VERSION = '1.04';
 
 # CaptureOne COS XML tags
 # - tags are added dynamically when encountered
@@ -65,11 +65,11 @@ sub HandleCOSAttrs($$$$)
 # Returns: 1 if valid tag was found
 sub FoundCOS($$$$;$)
 {
-    my ($exifTool, $tagTablePtr, $props, $val, $attrs) = @_;
+    my ($et, $tagTablePtr, $props, $val, $attrs) = @_;
 
     my $tag = $$props[-1];
     unless ($$tagTablePtr{$tag}) {
-        $exifTool->VPrint(0, "  | [adding $tag]\n");
+        $et->VPrint(0, "  | [adding $tag]\n");
         my $name = ucfirst $tag;
         $name =~ tr/-_a-zA-Z0-9//dc;
         return 0 unless length $tag;
@@ -84,10 +84,10 @@ sub FoundCOS($$$$;$)
         AddTagToTable($tagTablePtr, $tag, \%tagInfo);
     }
     # convert from UTF8 to ExifTool Charset
-    $val = $exifTool->Decode($val, "UTF8");
+    $val = $et->Decode($val, "UTF8");
     # un-escape XML character entities
     $val = Image::ExifTool::XMP::UnescapeXML($val);
-    $exifTool->HandleTag($tagTablePtr, $tag, $val);
+    $et->HandleTag($tagTablePtr, $tag, $val);
     return 0;
 }
 
@@ -97,7 +97,7 @@ sub FoundCOS($$$$;$)
 # Returns: 1 on success, 0 if this wasn't a valid XML file
 sub ProcessCOS($$)
 {
-    my ($exifTool, $dirInfo) = @_;
+    my ($et, $dirInfo) = @_;
 
     # process using XMP module, but override handling of attributes and tags
     $$dirInfo{XMPParseOpts} = {
@@ -105,7 +105,7 @@ sub ProcessCOS($$)
         FoundProc => \&FoundCOS,
     };
     my $tagTablePtr = GetTagTable('Image::ExifTool::CaptureOne::Main');
-    my $success = $exifTool->ProcessDirectory($dirInfo, $tagTablePtr);
+    my $success = $et->ProcessDirectory($dirInfo, $tagTablePtr);
     delete $$dirInfo{XMLParseArgs};
     return $success;
 }
@@ -119,11 +119,11 @@ sub ProcessCOS($$)
 #   ZIP     - reference to Archive::Zip object for this file
 sub ProcessEIP($$)
 {
-    my ($exifTool, $dirInfo) = @_;
+    my ($et, $dirInfo) = @_;
     my $zip = $$dirInfo{ZIP};
     my ($file, $buff, $status, $member, %parseFile);
 
-    $exifTool->SetFileType('EIP');
+    $et->SetFileType('EIP');
 
     # must catch all Archive::Zip warnings
     local $SIG{'__WARN__'} = \&Image::ExifTool::ZIP::WarnProc;
@@ -159,10 +159,10 @@ sub ProcessEIP($$)
         # get filename of this ZIP member
         $file = $member->fileName();
         next unless defined $file;
-        $exifTool->VPrint(0, "File: $file\n");
+        $et->VPrint(0, "File: $file\n");
         # set the document number and extract ZIP tags
-        $$exifTool{DOC_NUM} = ++$docNum;
-        Image::ExifTool::ZIP::HandleMember($exifTool, $member);
+        $$et{DOC_NUM} = ++$docNum;
+        Image::ExifTool::ZIP::HandleMember($et, $member);
         if (%parseFile) {
             next unless $parseFile{$file};
         } else {
@@ -173,7 +173,7 @@ sub ProcessEIP($$)
         # extract the contents of the file
         # Note: this could use a LOT of memory here for RAW images...
         ($buff, $status) = $zip->contents($member);
-        $status and $exifTool->Warn("Error extracting $file"), next;
+        $status and $et->Warn("Error extracting $file"), next;
         if ($file =~ /\.cos$/i) {
             # process Capture One Settings files
             my %dirInfo = (
@@ -181,18 +181,18 @@ sub ProcessEIP($$)
                 DirLen => length $buff,
                 DataLen => length $buff,
             );
-            ProcessCOS($exifTool, \%dirInfo);
+            ProcessCOS($et, \%dirInfo);
         } else {
             # set HtmlDump error if necessary because it doesn't work with embedded files
-            if ($$exifTool{HTML_DUMP}) {
-                $$exifTool{HTML_DUMP}{Error} = "Sorry, can't dump images embedded in ZIP files";
+            if ($$et{HTML_DUMP}) {
+                $$et{HTML_DUMP}{Error} = "Sorry, can't dump images embedded in ZIP files";
             }
             # process IIQ, JPEG and TIFF images
-            $exifTool->ExtractInfo(\$buff, { ReEntry => 1 });
+            $et->ExtractInfo(\$buff, { ReEntry => 1 });
         }
         undef $buff;    # (free memory now)
     }
-    delete $$exifTool{DOC_NUM};
+    delete $$et{DOC_NUM};
     return 1;
 }
 

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

@@ -14,7 +14,7 @@ use strict;
 use vars qw($VERSION %csType);
 use Image::ExifTool qw(:DataAccess :Utils);
 
-$VERSION = '1.07';
+$VERSION = '1.08';
 
 my %charsetTable;   # character set tables we've loaded
 
@@ -117,7 +117,7 @@ sub LoadCharset($)
 sub Decompose($$$;$)
 {
     local $_;
-    my ($exifTool, $val, $charset) = @_; # ($byteOrder assigned later if required)
+    my ($et, $val, $charset) = @_; # ($byteOrder assigned later if required)
     my $type = $csType{$charset};
     my (@uni, $conv);
 
@@ -125,7 +125,7 @@ sub Decompose($$$;$)
         $conv = LoadCharset($charset);
         unless ($conv) {
             # (shouldn't happen)
-            $exifTool->Warn("Invalid character set $charset") if $exifTool;
+            $et->Warn("Invalid character set $charset") if $et;
             return \@uni;   # error!
         }
     } elsif ($type == 0x100) {
@@ -140,9 +140,9 @@ sub Decompose($$$;$)
             # (somehow the meaning of "U0" was reversed in Perl 5.10.0!)
             @uni = unpack($] < 5.010000 ? 'U0U*' : 'C0U*', $val);
             # issue warning if we had errors
-            if ($Image::ExifTool::evalWarning and $exifTool and not $$exifTool{WarnBadUTF8}) {
-                $exifTool->Warn('Malformed UTF-8 character(s)');
-                $$exifTool{WarnBadUTF8} = 1;
+            if ($Image::ExifTool::evalWarning and $et and not $$et{WarnBadUTF8}) {
+                $et->Warn('Malformed UTF-8 character(s)');
+                $$et{WarnBadUTF8} = 1;
             }
         }
         return \@uni;       # all done!
@@ -274,9 +274,9 @@ sub Decompose($$$;$)
 sub Recompose($$;$$)
 {
     local $_;
-    my ($exifTool, $uni, $charset) = @_; # ($byteOrder assigned later if required)
+    my ($et, $uni, $charset) = @_; # ($byteOrder assigned later if required)
     my ($outVal, $conv, $inv);
-    $charset or $charset = $$exifTool{OPTIONS}{Charset};
+    $charset or $charset = $$et{OPTIONS}{Charset};
     my $csType = $csType{$charset};
     if ($csType == 0x100) {     # UTF8 (also treat ASCII as UTF8)
         if ($] >= 5.006001) {
@@ -293,14 +293,14 @@ sub Recompose($$;$$)
     if ($csType & 0x801) {
         $conv = LoadCharset($charset);
         unless ($conv) {
-            $exifTool->Warn("Missing charset $charset") if $exifTool;
+            $et->Warn("Missing charset $charset") if $et;
             return '';
         }
         $inv = $unicode2byte{$charset};
         # generate inverse lookup if necessary
         unless ($inv) {
             if (not $csType or $csType & 0x802) {
-                $exifTool->Warn("Invalid destination charset $charset") if $exifTool;
+                $et->Warn("Invalid destination charset $charset") if $et;
                 return '';
             }
             # prepare table to convert from Unicode to 1-byte characters
@@ -321,9 +321,9 @@ sub Recompose($$;$$)
             # different character with this byte value
             next if $_ < 0x100 and not $$conv{$_};
             $_ = ord('?');  # set invalid characters to '?'
-            if ($exifTool and not $$exifTool{EncodingError}) {
-                $exifTool->Warn("Some character(s) could not be encoded in $charset");
-                $$exifTool{EncodingError} = 1;
+            if ($et and not $$et{EncodingError}) {
+                $et->Warn("Some character(s) could not be encoded in $charset");
+                $$et{EncodingError} = 1;
             }
         }
         # repack as an 8-bit string and truncate at null

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

@@ -20,7 +20,7 @@ use strict;
 use vars qw($VERSION %uid);
 use Image::ExifTool qw(:DataAccess :Utils);
 
-$VERSION = '1.16';
+$VERSION = '1.17';
 
 # DICOM VR (Value Representation) format conversions
 my %dicomFormat = (
@@ -3407,6 +3407,9 @@ my %implicitVR = (
     '1.2.840.10008.5.1.4.1.1.12.3' => 'X-Ray Angiographic Bi-Plane Image Storage ',
     '1.2.840.10008.5.1.4.1.1.13.1.1' => 'X-Ray 3D Angiographic Image Storage',
     '1.2.840.10008.5.1.4.1.1.13.1.2' => 'X-Ray 3D Craniofacial Image Storage',
+    '1.2.840.10008.5.1.4.1.1.13.1.3' => 'Breast Tomosynthesis Image Storage',
+    '1.2.840.10008.5.1.4.1.1.14.1' => 'Intravascular Optical Coherence Tomography Image Storage - For Presentation',
+    '1.2.840.10008.5.1.4.1.1.14.2' => 'Intravascular Optical Coherence Tomography Image Storage - For Processing',
     '1.2.840.10008.5.1.4.1.1.20' => 'Nuclear Medicine Image Storage',
     '1.2.840.10008.5.1.4.1.1.66' => 'Raw Data Storage',
     '1.2.840.10008.5.1.4.1.1.66.1' => 'Spatial Registration Storage',
@@ -3427,6 +3430,17 @@ my %implicitVR = (
     '1.2.840.10008.5.1.4.1.1.77.1.5.2' => 'Ophthalmic Photography 16 Bit Image Storage',
     '1.2.840.10008.5.1.4.1.1.77.1.5.3' => 'Stereometric Relationship Storage',
     '1.2.840.10008.5.1.4.1.1.77.1.5.4' => 'Ophthalmic Tomography Image Storage',
+    '1.2.840.10008.5.1.4.1.1.77.1.6' => 'VL Whole Slide Microscopy Image Storage',
+    '1.2.840.10008.5.1.4.1.1.78.1' => 'Lensometry Measurements Storage',
+    '1.2.840.10008.5.1.4.1.1.78.2' => 'Autorefraction Measurements Storage',
+    '1.2.840.10008.5.1.4.1.1.78.3' => 'Keratometry Measurements Storage',
+    '1.2.840.10008.5.1.4.1.1.78.4' => 'Subjective Refraction Measurements Storage',
+    '1.2.840.10008.5.1.4.1.1.78.5' => 'Visual Acuity Measurements Storage',
+    '1.2.840.10008.5.1.4.1.1.78.6' => 'Spectacle Prescription Report Storage',
+    '1.2.840.10008.5.1.4.1.1.78.7' => 'Ophthalmic Axial Measurements Storage',
+    '1.2.840.10008.5.1.4.1.1.78.8' => 'Intraocular Lens Calculations Storage',
+    '1.2.840.10008.5.1.4.1.1.79.1' => 'Macular Grid Thickness and Volume Report Storage SOP Class',
+    '1.2.840.10008.5.1.4.1.1.80.1' => 'Ophthalmic Visual Field Static Perimetry Measurements Storage',
     '1.2.840.10008.5.1.4.1.1.88.1' => 'Text SR Storage - Trial (Retired)',
     '1.2.840.10008.5.1.4.1.1.88.2' => 'Audio SR Storage - Trial (Retired)',
     '1.2.840.10008.5.1.4.1.1.88.3' => 'Detail SR Storage - Trial (Retired)',
@@ -3439,6 +3453,8 @@ my %implicitVR = (
     '1.2.840.10008.5.1.4.1.1.88.59' => 'Key Object Selection Document',
     '1.2.840.10008.5.1.4.1.1.88.65' => 'Chest CAD SR',
     '1.2.840.10008.5.1.4.1.1.88.67' => 'X-Ray Radiation Dose SR Storage',
+    '1.2.840.10008.5.1.4.1.1.88.69' => 'Colon CAD SR',
+    '1.2.840.10008.5.1.4.1.1.88.70' => 'Implantation Plan SR Document Storage',
     '1.2.840.10008.5.1.4.1.1.104.1' => 'Encapsulated PDF Storage',
     '1.2.840.10008.5.1.4.1.1.104.2' => 'Encapsulated CDA Storage',
     '1.2.840.10008.5.1.4.1.1.128' => 'Positron Emission Tomography Image Storage',
@@ -3476,14 +3492,37 @@ my %implicitVR = (
     '1.2.840.10008.5.1.4.34.4.3' => 'Unified Procedure Step - Pull SOP Class',
     '1.2.840.10008.5.1.4.34.4.4' => 'Unified Procedure Step - Event SOP Class',
     '1.2.840.10008.5.1.4.34.5' => 'Unified Worklist and Procedure Step SOP Instance',
+    '1.2.840.10008.5.1.4.34.6.1' => 'Unified Procedure Step - Push SOP Class',
+    '1.2.840.10008.5.1.4.34.6.2' => 'Unified Procedure Step - Watch SOP Class',
+    '1.2.840.10008.5.1.4.34.6.3' => 'Unified Procedure Step - Pull SOP Class',
+    '1.2.840.10008.5.1.4.34.6.4' => 'Unified Procedure Step - Event SOP Class',
+    '1.2.840.10008.5.1.4.34.7' => 'RT Beams Delivery Instruction Storage',
+    '1.2.840.10008.5.1.4.34.8' => 'RT Conventional Machine Verification',
+    '1.2.840.10008.5.1.4.34.9' => 'RT Ion Machine Verification',
     '1.2.840.10008.5.1.4.37.1' => 'General Relevant Patient Information Query',
     '1.2.840.10008.5.1.4.37.2' => 'Breast Imaging Relevant Patient Information Query',
     '1.2.840.10008.5.1.4.37.3' => 'Cardiac Relevant Patient Information Query',
     '1.2.840.10008.5.1.4.38.1' => 'Hanging Protocol Storage',
     '1.2.840.10008.5.1.4.38.2' => 'Hanging Protocol Information Model - FIND',
     '1.2.840.10008.5.1.4.38.3' => 'Hanging Protocol Information Model - MOVE',
+    '1.2.840.10008.5.1.4.39.1' => 'Color Palette Storage',
+    '1.2.840.10008.5.1.4.39.2' => 'Color Palette Information Model - FIND',
+    '1.2.840.10008.5.1.4.39.3' => 'Color Palette Information Model - MOVE',
+    '1.2.840.10008.5.1.4.39.4' => 'Color Palette Information Model - GET',
     '1.2.840.10008.5.1.4.41' => 'Product Characteristics Query SOP Class',
     '1.2.840.10008.5.1.4.42' => 'Substance Approval Query SOP Class',
+    '1.2.840.10008.5.1.4.43.1' => 'Generic Implant Template Storage',
+    '1.2.840.10008.5.1.4.43.2' => 'Generic Implant Template Information Model - FIND',
+    '1.2.840.10008.5.1.4.43.3' => 'Generic Implant Template Information Model - MOVE',
+    '1.2.840.10008.5.1.4.43.4' => 'Generic Implant Template Information Model - GET',
+    '1.2.840.10008.5.1.4.44.1' => 'Implant Assembly Template Storage',
+    '1.2.840.10008.5.1.4.44.2' => 'Implant Assembly Template Information Model - FIND',
+    '1.2.840.10008.5.1.4.44.3' => 'Implant Assembly Template Information Model - MOVE',
+    '1.2.840.10008.5.1.4.44.4' => 'Implant Assembly Template Information Model - GET',
+    '1.2.840.10008.5.1.4.45.1' => 'Implant Template Group Storage',
+    '1.2.840.10008.5.1.4.45.2' => 'Implant Template Group Information Model - FIND',
+    '1.2.840.10008.5.1.4.45.3' => 'Implant Template Group Information Model - MOVE',
+    '1.2.840.10008.5.1.4.45.4' => 'Implant Template Group Information Model - GET',
     '1.2.840.10008.15.0.3.1' => 'dicomDeviceName',
     '1.2.840.10008.15.0.3.2' => 'dicomDescription',
     '1.2.840.10008.15.0.3.3' => 'dicomManufacturer',
@@ -3531,10 +3570,10 @@ my %implicitVR = (
 # Returns: 1 on success, 0 if this wasn't a valid DICOM file
 sub ProcessDICM($$)
 {
-    my ($exifTool, $dirInfo) = @_;
+    my ($et, $dirInfo) = @_;
     my $raf = $$dirInfo{RAF};
-    my $unknown = $exifTool->Options('Unknown');
-    my $verbose = $exifTool->Options('Verbose');
+    my $unknown = $et->Options('Unknown');
+    my $verbose = $et->Options('Verbose');
     my ($hdr, $buff, $implicit, $vr, $len);
 #
 # identify the DICOM or ACR-NEMA file
@@ -3545,7 +3584,7 @@ sub ProcessDICM($$)
     if ($buff eq 'DICM') {
         # file meta information transfer syntax is explicit little endian
         SetByteOrder('II');
-        $exifTool->SetFileType('DICOM');
+        $et->SetFileType('DICOM');
     } else {
         # test for a RAW DCM image (ACR-NEMA format, ie. no header)
         foreach ('II','MM','') {
@@ -3575,7 +3614,7 @@ sub ProcessDICM($$)
             last;   # success!
         }
         $raf->Seek(0, 0) or return 0;   # rewind to start of file
-        $exifTool->SetFileType('ACR');
+        $et->SetFileType('ACR');
     }
 #
 # process the meta information
@@ -3597,7 +3636,7 @@ sub ProcessDICM($$)
             # 1.2.840.10008.1.2.x = explicit VR little endian
             # 1.2.840.10008.1.2.1.99 = deflated
             unless ($transferSyntax =~ /^1\.2\.840\.10008\.1\.2(\.\d+)?(\.\d+)?/) {
-                $exifTool->Warn("Unrecognized transfer syntax $transferSyntax");
+                $et->Warn("Unrecognized transfer syntax $transferSyntax");
                 last;
             }
             if (not $1) {
@@ -3623,7 +3662,7 @@ sub ProcessDICM($$)
                                 $data .= $buf;
                                 last if $stat == Compress::Zlib::Z_STREAM_END();
                             } else {
-                                $exifTool->Warn('Error inflating compressed data stream');
+                                $et->Warn('Error inflating compressed data stream');
                                 return 1;
                             }
                         }
@@ -3634,11 +3673,11 @@ sub ProcessDICM($$)
                         $raf->Read($buff, 8) == 8 or last;
                         $group = Get16u(\$buff, 0);
                     } else {
-                        $exifTool->Warn('Error initializing inflation');
+                        $et->Warn('Error initializing inflation');
                         return 1;
                     }
                 } else {
-                    $exifTool->Warn('Install Compress::Zlib to decode compressed data stream');
+                    $et->Warn('Install Compress::Zlib to decode compressed data stream');
                     return 1;
                 }
             }
@@ -3669,8 +3708,8 @@ sub ProcessDICM($$)
             $len = 0;   # don't read value if undefined length
             if ($verbose) {
                 # start list of items in verbose output
-                $exifTool->VPrint(0, "$exifTool->{INDENT}+ [List of items]\n");
-                $exifTool->{INDENT} .= '| ';
+                $et->VPrint(0, "$$et{INDENT}+ [List of items]\n");
+                $$et{INDENT} .= '| ';
             }
         }
         # read the element value
@@ -3724,8 +3763,8 @@ sub ProcessDICM($$)
             # treat large data elements as binary data
             my $binData;
             my $lcTag = $tagInfo ? lc($$tagInfo{Name}) : 'unknown';
-            if ($exifTool->{REQ_TAG_LOOKUP}{$lcTag} or
-                ($exifTool->{OPTIONS}{Binary} and not $exifTool->{EXCL_TAG_LOOKUP}{$lcTag}))
+            if ($$et{REQ_TAG_LOOKUP}{$lcTag} or
+                ($$et{OPTIONS}{Binary} and not $$et{EXCL_TAG_LOOKUP}{$lcTag}))
             {
                 $binData = $buff;   # must make a copy
             } else {
@@ -3763,7 +3802,7 @@ sub ProcessDICM($$)
         }
 
         # handle the new tag information
-        $exifTool->HandleTag($tagTablePtr, $tag, $val,
+        $et->HandleTag($tagTablePtr, $tag, $val,
             DataPt => \$buff,
             DataPos => $pos - $len,
             Format => $format,
@@ -3773,9 +3812,9 @@ sub ProcessDICM($$)
         );
 
         # stop indenting for list if we reached EndOfItems tag
-        $exifTool->{INDENT} =~ s/..$// if $verbose and $tag eq 'FFFE,E00D';
+        $$et{INDENT} =~ s/..$// if $verbose and $tag eq 'FFFE,E00D';
     }
-    $err and $exifTool->Warn('Error reading DICOM file (corrupted?)');
+    $err and $et->Warn('Error reading DICOM file (corrupted?)');
     return 1;
 }
 

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

@@ -17,7 +17,7 @@ use Image::ExifTool::Exif;
 use Image::ExifTool::MakerNotes;
 use Image::ExifTool::CanonRaw;
 
-$VERSION = '1.19';
+$VERSION = '1.20';
 
 sub ProcessOriginalRaw($$$);
 sub ProcessAdobeData($$$);
@@ -143,7 +143,7 @@ sub WriteAdobeStuff($$$);
 # Returns: 1 on success, otherwise returns 0 and sets a Warning
 sub ProcessOriginalRaw($$$)
 {
-    my ($exifTool, $dirInfo, $tagTablePtr) = @_;
+    my ($et, $dirInfo, $tagTablePtr) = @_;
     my $dataPt = $$dirInfo{DataPt};
     my $start = $$dirInfo{DirStart};
     my $end = $start + $$dirInfo{DirLen};
@@ -155,7 +155,7 @@ sub ProcessOriginalRaw($$$)
         last if $pos + 4 > $end;
         my $val = Get32u($dataPt, $pos);
         $val or $pos += 4, next; # ignore zero values
-        my $tagInfo = $exifTool->GetTagInfo($tagTablePtr, $index);
+        my $tagInfo = $et->GetTagInfo($tagTablePtr, $index);
         $tagInfo or $err = "Missing DNG tag $index", last;
         if ($index & 0x02) {
             # extract a simple file type (tags 2, 3, 6 and 7)
@@ -169,8 +169,8 @@ sub ProcessOriginalRaw($$$)
             my $tag = $$tagInfo{Name};
             # only extract this information if requested (because it takes time)
             my $lcTag = lc $tag;
-            if (($exifTool->{OPTIONS}{Binary} and not $exifTool->{EXCL_TAG_LOOKUP}{$lcTag}) or
-                $exifTool->{REQ_TAG_LOOKUP}{$lcTag})
+            if (($$et{OPTIONS}{Binary} and not $$et{EXCL_TAG_LOOKUP}{$lcTag}) or
+                $$et{REQ_TAG_LOOKUP}{$lcTag})
             {
                 unless (eval 'require Compress::Zlib') {
                     $err = 'Install Compress::Zlib to extract compressed images';
@@ -208,9 +208,9 @@ sub ProcessOriginalRaw($$$)
                 $pos += $len;   # skip over this block
             }
         }
-        $exifTool->FoundTag($tagInfo, $val);
+        $et->FoundTag($tagInfo, $val);
     }
-    $exifTool->Warn($err || 'Bad OriginalRawFileData') if defined $err;
+    $et->Warn($err || 'Bad OriginalRawFileData') if defined $err;
     return 1;
 }
 
@@ -220,23 +220,23 @@ sub ProcessOriginalRaw($$$)
 # Returns: 1 on success
 sub ProcessAdobeData($$$)
 {
-    my ($exifTool, $dirInfo, $tagTablePtr) = @_;
+    my ($et, $dirInfo, $tagTablePtr) = @_;
     my $dataPt = $$dirInfo{DataPt};
     my $dataPos = $$dirInfo{DataPos};
     my $pos = $$dirInfo{DirStart};
     my $end = $$dirInfo{DirLen} + $pos;
     my $outfile = $$dirInfo{OutFile};
-    my $verbose = $exifTool->Options('Verbose');
-    my $htmlDump = $exifTool->Options('HtmlDump');
+    my $verbose = $et->Options('Verbose');
+    my $htmlDump = $et->Options('HtmlDump');
 
     return 0 unless $$dataPt =~ /^Adobe\0/;
     unless ($outfile) {
-        $exifTool->VerboseDir($dirInfo);
+        $et->VerboseDir($dirInfo);
         # don't parse makernotes if FastScan > 1
-        my $fast = $exifTool->Options('FastScan');
+        my $fast = $et->Options('FastScan');
         return 1 if $fast and $fast > 1;
     }
-    $htmlDump and $exifTool->HDump($dataPos, 6, 'Adobe DNGPrivateData header');
+    $htmlDump and $et->HDump($dataPos, 6, 'Adobe DNGPrivateData header');
     SetByteOrder('MM'); # always big endian
     $pos += 6;
     while ($pos + 8 <= $end) {
@@ -247,15 +247,15 @@ sub ProcessAdobeData($$$)
         if ($htmlDump) {
             my $name = "Adobe$tag";
             $name =~ tr/ //d;
-            $exifTool->HDump($dataPos + $pos - 8, 8, "$name header", "Data Size: $size bytes");
+            $et->HDump($dataPos + $pos - 8, 8, "$name header", "Data Size: $size bytes");
             # dump non-EXIF format data
             unless ($tag =~ /^(MakN|SR2 )$/) {
-                $exifTool->HDump($dataPos + $pos, $size, "$name data");
+                $et->HDump($dataPos + $pos, $size, "$name data");
             }
         }
         if ($verbose and not $outfile) {
-            $tagInfo or $exifTool->VPrint(0, "$$exifTool{INDENT}Unsupported DNGAdobeData record: ($tag)\n");
-            $exifTool->VerboseInfo($tag,
+            $tagInfo or $et->VPrint(0, "$$et{INDENT}Unsupported DNGAdobeData record: ($tag)\n");
+            $et->VerboseInfo($tag,
                 ref $tagInfo eq 'HASH' ? $tagInfo : undef,
                 DataPt => $dataPt,
                 DataPos => $dataPos,
@@ -272,7 +272,7 @@ sub ProcessAdobeData($$$)
                         # copy value across to outfile
                         $value = substr($$dataPt, $pos, $size);
                     } else {
-                        $exifTool->HandleTag($tagTablePtr, $tag, substr($$dataPt, $pos, $size));
+                        $et->HandleTag($tagTablePtr, $tag, substr($$dataPt, $pos, $size));
                     }
                     last;
                 }
@@ -295,12 +295,12 @@ sub ProcessAdobeData($$$)
             );
             if ($outfile) {
                 $dirInfo{Proc} = $processProc;  # WriteAdobeStuff() calls this to do the actual writing
-                $value = $exifTool->WriteDirectory(\%dirInfo, $subTable, \&WriteAdobeStuff);
+                $value = $et->WriteDirectory(\%dirInfo, $subTable, \&WriteAdobeStuff);
                 # use old directory if an error occurred
                 defined $value or $value = substr($$dataPt, $pos, $size);
             } else {
                 # override process proc for MakN
-                $exifTool->ProcessDirectory(\%dirInfo, $subTable, $processProc);
+                $et->ProcessDirectory(\%dirInfo, $subTable, $processProc);
             }
             last;
         }
@@ -313,7 +313,7 @@ sub ProcessAdobeData($$$)
         $pos += $size;
         ++$pos if $size & 0x01; # (darn padding)
     }
-    $pos == $end or $exifTool->Warn("$pos $end Adobe private data is corrupt");
+    $pos == $end or $et->Warn("$pos $end Adobe private data is corrupt");
     return 1;
 }
 
@@ -326,12 +326,12 @@ sub ProcessAdobeData($$$)
 #   pulled the bonehead move of reformatting the CRW information
 sub ProcessAdobeCRW($$$)
 {
-    my ($exifTool, $dirInfo, $tagTablePtr) = @_;
+    my ($et, $dirInfo, $tagTablePtr) = @_;
     my $dataPt = $$dirInfo{DataPt};
     my $start = $$dirInfo{DirStart};
     my $end = $start + $$dirInfo{DirLen};
-    my $verbose = $exifTool->Options('Verbose');
-    my $buildMakerNotes = $exifTool->Options('MakerNotes');
+    my $verbose = $et->Options('Verbose');
+    my $buildMakerNotes = $et->Options('MakerNotes');
     my $outfile = $$dirInfo{OutFile};
     my ($newTags, $oldChanged);
 
@@ -341,16 +341,16 @@ sub ProcessAdobeCRW($$$)
     return 0 unless $byteOrder =~ /^(II|MM)$/;
 
     # initialize maker note data if building maker notes
-    $buildMakerNotes and Image::ExifTool::CanonRaw::InitMakerNotes($exifTool);
+    $buildMakerNotes and Image::ExifTool::CanonRaw::InitMakerNotes($et);
 
     my $entries = Get16u($dataPt, $start + 2);
     my $pos = $start + 4;
-    $exifTool->VerboseDir($dirInfo, $entries) unless $outfile;
+    $et->VerboseDir($dirInfo, $entries) unless $outfile;
     if ($outfile) {
         # get hash of new tags
-        $newTags = $exifTool->GetNewTagInfoHash($tagTablePtr);
+        $newTags = $et->GetNewTagInfoHash($tagTablePtr);
         $$outfile = substr($$dataPt, $start, 4);
-        $oldChanged = $exifTool->{CHANGED};
+        $oldChanged = $$et{CHANGED};
     }
     # loop through entries in Adobe CRW information
     my $index;
@@ -365,7 +365,7 @@ sub ProcessAdobeCRW($$$)
         my $tagType = ($tag >> 8) & 0x38;   # get tag type
         my $format = $Image::ExifTool::CanonRaw::crwTagFormat{$tagType};
         my $count;
-        my $tagInfo = $exifTool->GetTagInfo($tagTablePtr, $tagID, \$value);
+        my $tagInfo = $et->GetTagInfo($tagTablePtr, $tagID, \$value);
         if ($tagInfo) {
             $format = $$tagInfo{Format} if $$tagInfo{Format};
             $count = $$tagInfo{Count};
@@ -405,9 +405,9 @@ sub ProcessAdobeCRW($$$)
                     );
                     #### 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
@@ -418,9 +418,9 @@ sub ProcessAdobeCRW($$$)
                         }
                     }
                 } elsif ($$newTags{$tagID}) {
-                    my $nvHash = $exifTool->GetNewValueHash($tagInfo);
-                    if ($exifTool->IsOverwriting($nvHash, $val)) {
-                        my $newVal = $exifTool->GetNewValues($nvHash);
+                    my $nvHash = $et->GetNewValueHash($tagInfo);
+                    if ($et->IsOverwriting($nvHash, $val)) {
+                        my $newVal = $et->GetNewValues($nvHash);
                         my $verboseVal;
                         $verboseVal = $newVal if $verbose > 1;
                         # convert to specified format if necessary
@@ -428,10 +428,10 @@ sub ProcessAdobeCRW($$$)
                             $newVal = WriteValue($newVal, $format, $count);
                         }
                         if (defined $newVal) {
-                            $exifTool->VerboseValue("- CanonRaw:$$tagInfo{Name}", $value);
-                            $exifTool->VerboseValue("+ CanonRaw:$$tagInfo{Name}", $verboseVal);
+                            $et->VerboseValue("- CanonRaw:$$tagInfo{Name}", $value);
+                            $et->VerboseValue("+ CanonRaw:$$tagInfo{Name}", $verboseVal);
                             $value = $newVal;
-                            ++$exifTool->{CHANGED};
+                            ++$$et{CHANGED};
                         }
                     }
                 }
@@ -441,7 +441,7 @@ sub ProcessAdobeCRW($$$)
             # (verified that there is no padding here)
             $$outfile .= Set16u($tag) . Set32u(length($value)) . $value;
         } else {
-            $exifTool->HandleTag($tagTablePtr, $tagID, $val,
+            $et->HandleTag($tagTablePtr, $tagID, $val,
                 Index   => $index,
                 DataPt  => $dataPt,
                 DataPos => $$dirInfo{DataPos},
@@ -451,31 +451,31 @@ sub ProcessAdobeCRW($$$)
             );
             if ($buildMakerNotes) {
                 # build maker notes information if requested
-                Image::ExifTool::CanonRaw::BuildMakerNotes($exifTool, $tagID, $tagInfo,
+                Image::ExifTool::CanonRaw::BuildMakerNotes($et, $tagID, $tagInfo,
                                                            \$value, $format, $count);
             }
         }
         # (we lost the directory structure, but the second tag 0x0805
         # should be in the ImageDescription directory)
-        $exifTool->{DIR_NAME} = 'ImageDescription' if $tagID == 0x0805;
+        $$et{DIR_NAME} = 'ImageDescription' if $tagID == 0x0805;
         SetByteOrder('MM');
         $pos += $size;
     }
     if ($outfile and (not defined $$outfile or $index != $entries or
-        $exifTool->{CHANGED} ==  $oldChanged))
+        $$et{CHANGED} ==  $oldChanged))
     {
-        $exifTool->{CHANGED} = $oldChanged; # nothing changed
+        $$et{CHANGED} = $oldChanged; # nothing changed
         undef $$outfile;    # rewrite old directory
     }
     if ($index != $entries) {
-        $exifTool->Warn('Truncated CRW notes');
+        $et->Warn('Truncated CRW notes');
     } elsif ($pos < $end) {
-        $exifTool->Warn($end-$pos . ' extra bytes at end of CRW notes');
+        $et->Warn($end-$pos . ' extra bytes at end of CRW notes');
     }
     # finish building maker notes if necessary
     if ($buildMakerNotes) {
         SetByteOrder($byteOrder);
-        Image::ExifTool::CanonRaw::SaveMakerNotes($exifTool);
+        Image::ExifTool::CanonRaw::SaveMakerNotes($et);
     }
     return 1;
 }
@@ -487,7 +487,7 @@ sub ProcessAdobeCRW($$$)
 # Notes: data has 4 byte header (2 for byte order and 2 for entry count)
 sub ProcessAdobeMRW($$$)
 {
-    my ($exifTool, $dirInfo, $tagTablePtr) = @_;
+    my ($et, $dirInfo, $tagTablePtr) = @_;
     my $dataPt = $$dirInfo{DataPt};
     my $dirLen = $$dirInfo{DirLen};
     my $dirStart = $$dirInfo{DirStart};
@@ -499,7 +499,7 @@ sub ProcessAdobeMRW($$$)
     $buff .= substr($$dataPt, $dirStart + 4, $dirLen - 4);
     my $raf = new File::RandomAccess(\$buff);
     my %dirInfo = ( RAF => $raf, OutFile => $outfile );
-    my $rtnVal = Image::ExifTool::MinoltaRaw::ProcessMRW($exifTool, \%dirInfo);
+    my $rtnVal = Image::ExifTool::MinoltaRaw::ProcessMRW($et, \%dirInfo);
     if ($outfile and defined $$outfile and length $$outfile) {
         # remove MRW header and add Adobe header
         $$outfile = substr($$dataPt, $dirStart, 4) . substr($$outfile, 8);
@@ -513,7 +513,7 @@ sub ProcessAdobeMRW($$$)
 # Returns: 1 on success, otherwise returns 0 and sets a Warning
 sub ProcessAdobeRAF($$$)
 {
-    my ($exifTool, $dirInfo, $tagTablePtr) = @_;
+    my ($et, $dirInfo, $tagTablePtr) = @_;
     return 0 if $$dirInfo{OutFile}; # (can't write this yet)
     my $dataPt = $$dirInfo{DataPt};
     my $pos = $$dirInfo{DirStart};
@@ -524,10 +524,10 @@ sub ProcessAdobeRAF($$$)
     if ($pos + 2 <= $dirEnd and SetByteOrder(substr($$dataPt, $pos, 2))) {
         $pos += 2;
     } else {
-        $exifTool->Warn('Invalid DNG RAF data');
+        $et->Warn('Invalid DNG RAF data');
         return 0;
     }
-    $exifTool->VerboseDir($dirInfo);
+    $et->VerboseDir($dirInfo);
     # make fake RAF object for processing (same acronym, different meaning)
     my $raf = new File::RandomAccess($dataPt);
     my $num = '';
@@ -545,12 +545,12 @@ sub ProcessAdobeRAF($$$)
             RAF      => $raf,
             DirStart => $pos - $len,
         );
-        $$exifTool{SET_GROUP1} = "RAF$num";
-        $exifTool->ProcessDirectory(\%dirInfo, $tagTablePtr) or $warn = 1;
-        delete $$exifTool{SET_GROUP1};
+        $$et{SET_GROUP1} = "RAF$num";
+        $et->ProcessDirectory(\%dirInfo, $tagTablePtr) or $warn = 1;
+        delete $$et{SET_GROUP1};
         $num = ($num || 1) + 1;
     }
-    $warn and $exifTool->Warn('Possibly corrupt RAF information');
+    $warn and $et->Warn('Possibly corrupt RAF information');
     return 1;
 }
 
@@ -561,7 +561,7 @@ sub ProcessAdobeRAF($$$)
 # Notes: data has 6 byte header (2 for byte order and 4 for original offset)
 sub ProcessAdobeSR2($$$)
 {
-    my ($exifTool, $dirInfo, $tagTablePtr) = @_;
+    my ($et, $dirInfo, $tagTablePtr) = @_;
     return 0 if $$dirInfo{OutFile}; # (can't write this yet)
     my $dataPt = $$dirInfo{DataPt};
     my $start = $$dirInfo{DirStart};
@@ -572,7 +572,7 @@ sub ProcessAdobeSR2($$$)
     my $originalPos = Get32u($dataPt, $start + 2);
     return 0 unless SetByteOrder(substr($$dataPt, $start, 2));
 
-    $exifTool->VerboseDir($dirInfo);
+    $et->VerboseDir($dirInfo);
     my $dataPos = $$dirInfo{DataPos};
     my $dirStart = $start + 6;  # pointer to maker note directory
     my $dirLen = $len - 6;
@@ -589,11 +589,11 @@ sub ProcessAdobeSR2($$$)
         DirLen    => $dirLen,
         Parent    => $$dirInfo{DirName},
     );
-    if ($exifTool->Options('HtmlDump')) {
-        $exifTool->HDump($dataPos + $start, 6, 'Adobe SR2 data');
+    if ($et->Options('HtmlDump')) {
+        $et->HDump($dataPos + $start, 6, 'Adobe SR2 data');
     }
     # parse the SR2 directory
-    $exifTool->ProcessDirectory(\%subdirInfo, $tagTablePtr);
+    $et->ProcessDirectory(\%subdirInfo, $tagTablePtr);
     return 1;
 }
 
@@ -604,7 +604,7 @@ sub ProcessAdobeSR2($$$)
 # Notes: data has 2 byte header (byte order of the data)
 sub ProcessAdobeIFD($$$)
 {
-    my ($exifTool, $dirInfo, $tagTablePtr) = @_;
+    my ($et, $dirInfo, $tagTablePtr) = @_;
     return 0 if $$dirInfo{OutFile}; # (can't write this yet)
     my $dataPt = $$dirInfo{DataPt};
     my $pos = $$dirInfo{DirStart};
@@ -619,7 +619,7 @@ sub ProcessAdobeIFD($$$)
     # - byte order of IFD entires is always big-endian, but byte order of data changes
     SetByteOrder('MM');     # IFD structure is always big-endian
     my $entries = Get16u($dataPt, $pos + 2);
-    $exifTool->VerboseDir($dirInfo, $entries);
+    $et->VerboseDir($dirInfo, $entries);
     $pos += 4;
 
     my $end = $pos + $$dirInfo{DirLen};
@@ -632,7 +632,7 @@ sub ProcessAdobeIFD($$$)
         my $count = Get32u($dataPt, $pos+4);
         if ($format < 1 or $format > 13) {
             # warn unless the IFD was just padded with zeros
-            $format and $exifTool->Warn(
+            $format and $et->Warn(
                 sprintf("Unknown format ($format) for $$dirInfo{DirName} tag 0x%x",$tagID));
             return 0; # must be corrupted
         }
@@ -641,7 +641,7 @@ sub ProcessAdobeIFD($$$)
         my $formatStr = $Image::ExifTool::Exif::formatName[$format];
         SetByteOrder($dataOrder);   # data stored in native order
         my $val = ReadValue($dataPt, $pos + 8, $formatStr, $count, $size);
-        $exifTool->HandleTag($tagTablePtr, $tagID, $val,
+        $et->HandleTag($tagTablePtr, $tagID, $val,
             Index   => $index,
             DataPt  => $dataPt,
             DataPos => $dataPos,
@@ -651,7 +651,7 @@ sub ProcessAdobeIFD($$$)
         $pos += 8 + $size;
     }
     if ($index < $entries) {
-        $exifTool->Warn("Truncated $$dirInfo{DirName} directory");
+        $et->Warn("Truncated $$dirInfo{DirName} directory");
         return 0;
     }
     return 1;
@@ -664,7 +664,7 @@ sub ProcessAdobeIFD($$$)
 # Notes: data has 6 byte header (2 for byte order and 4 for original offset)
 sub ProcessAdobeMakN($$$)
 {
-    my ($exifTool, $dirInfo, $tagTablePtr) = @_;
+    my ($et, $dirInfo, $tagTablePtr) = @_;
     my $dataPt = $$dirInfo{DataPt};
     my $start = $$dirInfo{DirStart};
     my $len = $$dirInfo{DirLen};
@@ -675,13 +675,13 @@ sub ProcessAdobeMakN($$$)
     my $originalPos = Get32u($dataPt, $start + 2);
     return 0 unless SetByteOrder(substr($$dataPt, $start, 2));
 
-    $exifTool->VerboseDir($dirInfo) unless $outfile;
+    $et->VerboseDir($dirInfo) unless $outfile;
     my $dataPos = $$dirInfo{DataPos};
     my $dirStart = $start + 6;  # pointer to maker note directory
     my $dirLen = $len - 6;
 
     my $hdr = substr($$dataPt, $dirStart, $dirLen < 48 ? $dirLen : 48);
-    my $tagInfo = $exifTool->GetTagInfo($tagTablePtr, 'MakN', \$hdr);
+    my $tagInfo = $et->GetTagInfo($tagTablePtr, 'MakN', \$hdr);
     return 0 unless $tagInfo and $$tagInfo{SubDirectory};
     my $subdir = $$tagInfo{SubDirectory};
     my $subTable = GetTagTable($$subdir{TagTable});
@@ -701,14 +701,14 @@ sub ProcessAdobeMakN($$$)
         Parent    => $$dirInfo{DirName},
     );
     # look for start of maker notes IFD
-    my $loc = Image::ExifTool::MakerNotes::LocateIFD($exifTool,\%subdirInfo);
+    my $loc = Image::ExifTool::MakerNotes::LocateIFD($et,\%subdirInfo);
     unless (defined $loc) {
-        $exifTool->Warn('Maker notes could not be parsed');
+        $et->Warn('Maker notes could not be parsed');
         return 0;
     }
-    if ($exifTool->Options('HtmlDump')) {
-        $exifTool->HDump($dataPos + $start, 6, 'Adobe MakN data');
-        $exifTool->HDump($dataPos + $dirStart, $loc, "$$tagInfo{Name} header") if $loc;
+    if ($et->Options('HtmlDump')) {
+        $et->HDump($dataPos + $start, 6, 'Adobe MakN data');
+        $et->HDump($dataPos + $dirStart, $loc, "$$tagInfo{Name} header") if $loc;
     }
 
     my $fix = 0;
@@ -721,11 +721,11 @@ sub ProcessAdobeMakN($$$)
     if ($outfile) {
         # rewrite the maker notes directory
         my $fixup = $subdirInfo{Fixup} = new Image::ExifTool::Fixup;
-        my $oldChanged = $$exifTool{CHANGED};
-        my $buff = $exifTool->WriteDirectory(\%subdirInfo, $subTable);
+        my $oldChanged = $$et{CHANGED};
+        my $buff = $et->WriteDirectory(\%subdirInfo, $subTable);
         # nothing to do if error writing directory or nothing changed
-        unless (defined $buff and $exifTool->{CHANGED} != $oldChanged) {
-            $exifTool->{CHANGED} = $oldChanged;
+        unless (defined $buff and $$et{CHANGED} != $oldChanged) {
+            $$et{CHANGED} = $oldChanged;
             return 1;
         }
         # deleting maker notes if directory is empty
@@ -752,10 +752,10 @@ sub ProcessAdobeMakN($$$)
         $$outfile = $header . $buff;
     } else {
         # parse the maker notes directory
-        $exifTool->ProcessDirectory(\%subdirInfo, $subTable, $$subdir{ProcessProc});
+        $et->ProcessDirectory(\%subdirInfo, $subTable, $$subdir{ProcessProc});
         # extract maker notes as a block if specified
-        if ($exifTool->Options('MakerNotes') or
-            $exifTool->{REQ_TAG_LOOKUP}{lc($$tagInfo{Name})})
+        if ($et->Options('MakerNotes') or
+            $$et{REQ_TAG_LOOKUP}{lc($$tagInfo{Name})})
         {
             my $val;
             if ($$tagInfo{MakerNotes}) {
@@ -764,16 +764,16 @@ sub ProcessAdobeMakN($$$)
                 $subdirInfo{DirStart} = $dirStart;
                 $subdirInfo{DirLen}   = $dirLen;
                 # rebuild the maker notes to identify all offsets that require fixing up
-                $val = Image::ExifTool::Exif::RebuildMakerNotes($exifTool, $subTable, \%subdirInfo);
+                $val = Image::ExifTool::Exif::RebuildMakerNotes($et, $subTable, \%subdirInfo);
                 if (not defined $val and $dirLen > 4) {
-                    $exifTool->Warn('Error rebuilding maker notes (may be corrupt)');
+                    $et->Warn('Error rebuilding maker notes (may be corrupt)');
                 }
             } else {
                 # extract this directory as a block if specified
                 return 1 unless $$tagInfo{Writable};
             }
             $val = substr($$dataPt, 20) unless defined $val;
-            $exifTool->FoundTag($tagInfo, $val);
+            $et->FoundTag($tagInfo, $val);
         }
     }
     return 1;
@@ -785,12 +785,12 @@ sub ProcessAdobeMakN($$$)
 # Returns: new data block (may be empty if directory is deleted) or undef on error
 sub WriteAdobeStuff($$$)
 {
-    my ($exifTool, $dirInfo, $tagTablePtr) = @_;
-    $exifTool or return 1;    # allow dummy access
+    my ($et, $dirInfo, $tagTablePtr) = @_;
+    $et or return 1;    # allow dummy access
     my $proc = $$dirInfo{Proc} || \&ProcessAdobeData;
     my $buff;
     $$dirInfo{OutFile} = \$buff;
-    &$proc($exifTool, $dirInfo, $tagTablePtr) or undef $buff;
+    &$proc($et, $dirInfo, $tagTablePtr) or undef $buff;
     return $buff;
 }