exiftool_vendored 9.37.0 → 9.41.0

data/bin/Image-ExifTool-9.41/lib/Image/ExifTool/DPX.pm

@@ -0,0 +1,151 @@
+#------------------------------------------------------------------------------
+# File:         DPX.pm
+#
+# Description:  Read DPX meta information
+#
+# Revisions:    2013-09-19 - P. Harvey created
+#
+# References:   1) http://www.cineon.com/ff_draft.php
+#------------------------------------------------------------------------------
+
+package Image::ExifTool::DPX;
+
+use strict;
+use vars qw($VERSION);
+use Image::ExifTool qw(:DataAccess :Utils);
+
+$VERSION = '1.01';
+
+# DPX tags
+%Image::ExifTool::DPX::Main = (
+    PROCESS_PROC => \&Image::ExifTool::ProcessBinaryData,
+    GROUPS => { 0 => 'File', 1 => 'File', 2 => 'Image' },
+    NOTES => 'Tags extracted from DPX (Digital Picture Exchange) images.',
+    0   => { Name => 'ByteOrder',     Format => 'undef[4]', PrintConv => { SDPX => 'Big-endian', XPDS => 'Little-endian' } },
+    8   => { Name => 'HeaderVersion', Format => 'string[8]' },
+    # 24 => { Name => 'GenericHeaderSize', Format => 'int32u' }, # = 1664
+    # 28 => { Name => 'IndustryStandardHeaderSize', Format => 'int32u' }, # = 384
+    16  => { Name => 'DPXFileSize',   Format => 'int32u' },
+    20  => { Name => 'DittoKey',      Format => 'int32u', PrintConv => { 0 => 'Same', 1 => 'New' } },
+    36  => { Name => 'ImageFileName', Format => 'string[100]' },
+    136 => {
+        Name => 'CreateDate',
+        Format => 'string[24]',
+        Groups => { 2 => 'Time' },
+        ValueConv => '$val =~ s/(\d{4}:\d{2}:\d{2}):/$1 /; $val',
+        PrintConv => '$self->ConvertDateTime($val)',
+    },
+    160 => { Name => 'Creator',       Format => 'string[100]', Groups => { 2 => 'Author' } },
+    260 => { Name => 'Project',       Format => 'string[200]' },
+    460 => { Name => 'Copyright',     Format => 'string[200]', Groups => { 2 => 'Author' } },
+    660 => { Name => 'EncryptionKey', Format => 'int32u', PrintConv => 'sprintf("%.8x",$val)' },
+    768 => {
+        Name => 'Orientation',
+        Format => 'int16u',
+        PrintConv => {
+            0 => 'Horizontal (normal)',
+            1 => 'Mirror vertical',
+            2 => 'Mirror horizontal',
+            3 => 'Rotate 180',
+            4 => 'Mirror horizontal and rotate 270 CW',
+            5 => 'Rotate 90 CW',
+            6 => 'Rotate 270 CW',
+            7 => 'Mirror horizontal and rotate 90 CW',
+        },
+    },
+    770 => { Name => 'ImageElements', Format => 'int16u' },
+    772 => { Name => 'ImageWidth',    Format => 'int32u' },
+    776 => { Name => 'ImageHeight',   Format => 'int32u' },
+    780 => { Name => 'DataSign',      Format => 'int32u', PrintConv => { 0 => 'Unsigned', 1 => 'Signed' } },
+    803 => { Name => 'BitDepth',      Format => 'int8u' },
+    820 => { Name => 'ImageDescription',  Format => 'string[32]' },
+    892 => { Name => 'Image2Description', Format => 'string[32]', RawConv => '$val=~/[^\xff]/ ? $val : undef' },
+    964 => { Name => 'Image3Description', Format => 'string[32]', RawConv => '$val=~/[^\xff]/ ? $val : undef' },
+    1036=> { Name => 'Image4Description', Format => 'string[32]', RawConv => '$val=~/[^\xff]/ ? $val : undef' },
+    1108=> { Name => 'Image5Description', Format => 'string[32]', RawConv => '$val=~/[^\xff]/ ? $val : undef' },
+    1180=> { Name => 'Image6Description', Format => 'string[32]', RawConv => '$val=~/[^\xff]/ ? $val : undef' },
+    1252=> { Name => 'Image7Description', Format => 'string[32]', RawConv => '$val=~/[^\xff]/ ? $val : undef' },
+    1324=> { Name => 'Image8Description', Format => 'string[32]', RawConv => '$val=~/[^\xff]/ ? $val : undef' },
+    # 1408=> { Name => 'XOffset',           Format => 'int32u' },
+    # 1412=> { Name => 'YOffset',           Format => 'int32u' },
+    # 1416=> { Name => 'XCenter',           Format => 'float' },
+    # 1420=> { Name => 'YCenter',           Format => 'float' },
+    # 1424=> { Name => 'XOriginalSize',     Format => 'int32u' },
+    # 1428=> { Name => 'YOriginalSize',     Format => 'int32u' },
+    1432=> { Name => 'SourceFileName',    Format => 'string[100]' },
+    1532=> { Name => 'SourceCreateDate',  Format => 'string[24]' },
+    1556=> { Name => 'InputDeviceName',   Format => 'string[32]' },
+    1588=> { Name => 'InputDeviceSerialNumber', Format => 'string[32]' },
+    # 1620=> { Name => 'AspectRatio',       Format => 'int32u' },
+    1732 => { Name => 'FrameID',          Format => 'string[32]' },
+    1764 => { Name => 'SlateInformation', Format => 'string[100]' },
+    2048 => { Name => 'UserID',           Format => 'string[32]' },
+);
+
+#------------------------------------------------------------------------------
+# Extract EXIF information from a DPX image
+# Inputs: 0) ExifTool object reference, 1) dirInfo reference
+# Returns: 1 on success, 0 if this wasn't a valid DPX file
+sub ProcessDPX($$)
+{
+    my ($et, $dirInfo) = @_;
+    my $raf = $$dirInfo{RAF};
+    my $buff;
+
+    # verify this is a valid DPX file
+    return 0 unless $raf->Read($buff, 2080) == 2080;
+    return 0 unless $buff =~ /^(SDPX|XPDS)/;
+    SetByteOrder($1 eq 'SDPX' ? 'MM' : 'II');
+    $et->SetFileType();   # set the FileType tag
+    my $hdrLen = Get32u(\$buff,24) + Get32u(\$buff,28);
+    $hdrLen == 2048 or $et->Warn("Unexpected DPX header length ($hdrLen)");
+    my %dirInfo = (
+        DataPt => \$buff,
+        DirStart => 0,
+        DirLen => length($buff),
+    );
+    my $tagTablePtr = GetTagTable('Image::ExifTool::DPX::Main');
+    $et->ProcessDirectory(\%dirInfo, $tagTablePtr);
+
+    return 1;
+}
+
+1;  # end
+
+__END__
+
+=head1 NAME
+
+Image::ExifTool::DPX - Read DPX meta information
+
+=head1 SYNOPSIS
+
+This module is used by Image::ExifTool
+
+=head1 DESCRIPTION
+
+This module contains definitions required by Image::ExifTool to read
+metadata from DPX (Digital Picture Exchange) images.
+
+=head1 AUTHOR
+
+Copyright 2003-2013, Phil Harvey (phil at owl.phy.queensu.ca)
+
+This library is free software; you can redistribute it and/or modify it
+under the same terms as Perl itself.
+
+=head1 REFERENCES
+
+=over 4
+
+=item L<http://www.cineon.com/ff_draft.php>
+
+=back
+
+=head1 SEE ALSO
+
+L<Image::ExifTool::TagNames/DPX Tags>,
+L<Image::ExifTool(3pm)|Image::ExifTool>
+
+=cut
+

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

@@ -15,7 +15,7 @@ use strict;
 use vars qw($VERSION);
 use Image::ExifTool qw(:DataAccess :Utils);
 
-$VERSION = '1.00';
+$VERSION = '1.01';
 
 # DV profiles (ref 1)
 my @dvProfiles = (
@@ -159,7 +159,7 @@ my @dvTags = (
 # Returns: 1 on success, 0 if this wasn't a valid DV file
 sub ProcessDV($$)
 {
-    my ($exifTool, $dirInfo) = @_;
+    my ($et, $dirInfo) = @_;
     local $_;
     my $raf = $$dirInfo{RAF};
     my ($buff, $start, $profile, $tag, $i, $j);
@@ -179,7 +179,7 @@ sub ProcessDV($$)
     # must at least have a full DIF header
     return 0 if $start + 80 * 6 > $len;
 
-    $exifTool->SetFileType();
+    $et->SetFileType();
 
     my $pos = $start;
     my $dsf = Get8u(\$buff, $pos + 3) & 0x80 >> 7;
@@ -194,13 +194,13 @@ sub ProcessDV($$)
             $profile = $_;
             last;
         }
-        $profile or $exifTool->Warn("Unrecognized DV profile"), return 1;
+        $profile or $et->Warn("Unrecognized DV profile"), return 1;
     }
     my $tagTablePtr = GetTagTable('Image::ExifTool::DV::Main');
 
     # calculate total bit rate and duration
     my $byteRate = $$profile{FrameSize} * $$profile{FrameRate};
-    my $fileSize = $$exifTool{VALUE}{FileSize};
+    my $fileSize = $$et{VALUE}{FileSize};
     $$profile{TotalBitrate} = 8 * $byteRate;
     $$profile{Duration} = $fileSize / $byteRate if defined $fileSize;
 
@@ -270,7 +270,7 @@ sub ProcessDV($$)
     # save our metadata
     foreach $tag (@dvTags) {
         next unless defined $$profile{$tag};
-        $exifTool->HandleTag($tagTablePtr, $tag, $$profile{$tag});
+        $et->HandleTag($tagTablePtr, $tag, $$profile{$tag});
     }
 
     return 1;

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

@@ -18,7 +18,7 @@ use strict;
 use vars qw($VERSION);
 use Image::ExifTool qw(:DataAccess :Utils);
 
-$VERSION = '1.04';
+$VERSION = '1.05';
 
 sub ParseAnt($);
 sub ProcessAnt($$$);
@@ -249,7 +249,7 @@ Tok: for (;;) {
 # Returns: 1 on success
 sub ProcessAnt($$$)
 {
-    my ($exifTool, $dirInfo, $tagTablePtr) = @_;
+    my ($et, $dirInfo, $tagTablePtr) = @_;
     my $dataPt = $$dirInfo{DataPt};
 
     # quick pre-scan to check for metadata or XMP
@@ -267,10 +267,10 @@ sub ProcessAnt($$$)
         next if ref $tag or not defined $$tagTablePtr{$tag};
         if ($tag eq 'metadata') {
             # ProcessMeta() takes array reference
-            $exifTool->HandleTag($tagTablePtr, $tag, $ant);
+            $et->HandleTag($tagTablePtr, $tag, $ant);
         } else {
             next if ref $$ant[0];   # only process simple values
-            $exifTool->HandleTag($tagTablePtr, $tag, $$ant[0]);
+            $et->HandleTag($tagTablePtr, $tag, $$ant[0]);
         }
     }
     return 1;
@@ -283,10 +283,10 @@ sub ProcessAnt($$$)
 # Notes: input dirInfo DataPt is a reference to a list of pre-parsed metadata entries
 sub ProcessMeta($$$)
 {
-    my ($exifTool, $dirInfo, $tagTablePtr) = @_;
+    my ($et, $dirInfo, $tagTablePtr) = @_;
     my $dataPt = $$dirInfo{DataPt};
     return 0 unless ref $$dataPt eq 'ARRAY';
-    $exifTool->VerboseDir('Metadata', scalar @$$dataPt);
+    $et->VerboseDir('Metadata', scalar @$$dataPt);
     my ($item, $err);
     foreach $item (@$$dataPt) {
         # make sure item is a simple tag/value pair
@@ -299,9 +299,9 @@ sub ProcessMeta($$$)
             length $name or $err = 1, next;
             AddTagToTable($tagTablePtr, $$item[0], { Name => ucfirst($name) });
         }
-        $exifTool->HandleTag($tagTablePtr, $$item[0], $$item[1]);
+        $et->HandleTag($tagTablePtr, $$item[0], $$item[1]);
     }
-    $err and $exifTool->Warn('Ignored invalid metadata entry(s)');
+    $err and $et->Warn('Ignored invalid metadata entry(s)');
     return 1;
 }
 
@@ -311,24 +311,24 @@ sub ProcessMeta($$$)
 # Returns: 1 on success
 sub ProcessBZZ($$$)
 {
-    my ($exifTool, $dirInfo, $tagTablePtr) = @_;
+    my ($et, $dirInfo, $tagTablePtr) = @_;
     require Image::ExifTool::BZZ;
     my $buff = Image::ExifTool::BZZ::Decode($$dirInfo{DataPt});
     unless (defined $buff) {
-        $exifTool->Warn("Error decoding $$dirInfo{DirName}");
+        $et->Warn("Error decoding $$dirInfo{DirName}");
         return 0;
     }
-    my $verbose = $exifTool->Options('Verbose');
+    my $verbose = $et->Options('Verbose');
     if ($verbose >= 3) {
         # dump the decoded data in very verbose mode
-        $exifTool->VerboseDir("Decoded $$dirInfo{DirName}", 0, length $buff);
-        $exifTool->VerboseDump(\$buff);
+        $et->VerboseDir("Decoded $$dirInfo{DirName}", 0, length $buff);
+        $et->VerboseDump(\$buff);
     }
     $$dirInfo{DataPt} = \$buff;
     $$dirInfo{DataLen} = $$dirInfo{DirLen} = length $buff;
     # process the data using the default process proc for this table
     my $processProc = $$tagTablePtr{PROCESS_PROC} or return 0;
-    return &$processProc($exifTool, $dirInfo, $tagTablePtr);
+    return &$processProc($et, $dirInfo, $tagTablePtr);
 }
 
 1;  # end

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

@@ -21,7 +21,7 @@ use strict;
 use vars qw($VERSION);
 use Image::ExifTool qw(:DataAccess :Utils);
 
-$VERSION = '1.06';
+$VERSION = '1.07';
 
 sub ProcessPEResources($$);
 sub ProcessPEVersion($$);
@@ -726,16 +726,16 @@ my %languageCode = (
 # Returns: 1 on success, 0 if this wasn't a valid CHM file
 sub ProcessCHM($$)
 {
-    my ($exifTool, $dirInfo) = @_;
+    my ($et, $dirInfo) = @_;
     my $raf = $$dirInfo{RAF};
     my $buff;
 
     return 0 unless $raf->Read($buff, 56) == 56 and
         $buff =~ /^ITSF.{20}\x10\xfd\x01\x7c\xaa\x7b\xd0\x11\x9e\x0c\0\xa0\xc9\x22\xe6\xec/s;
     my $tagTablePtr = GetTagTable('Image::ExifTool::EXE::CHM');
-    $exifTool->SetFileType();
+    $et->SetFileType();
     SetByteOrder('II');
-    $exifTool->ProcessDirectory({ DataPt => \$buff }, $tagTablePtr);
+    $et->ProcessDirectory({ DataPt => \$buff }, $tagTablePtr);
     return 1;
 }
 
@@ -746,7 +746,7 @@ sub ProcessCHM($$)
 #          1) end pos (rounded up to nearest 4 bytes)
 sub ReadUnicodeStr($$;$)
 {
-    my ($dataPt, $pos, $exifTool) = @_;
+    my ($dataPt, $pos, $et) = @_;
     my $len = length $$dataPt;
     my $str = '';
     while ($pos + 2 <= $len) {
@@ -756,7 +756,7 @@ sub ReadUnicodeStr($$;$)
         $str .= $ch;
     }
     $pos += 2 if $pos & 0x03;
-    my $to = $exifTool ? $exifTool->Options('Charset') : 'UTF8';
+    my $to = $et ? $et->Options('Charset') : 'UTF8';
     return (Image::ExifTool::Decode(undef,$str,'UCS2','II',$to), $pos);
 }
 
@@ -766,7 +766,7 @@ sub ReadUnicodeStr($$;$)
 # Returns: true on success
 sub ProcessPEVersion($$)
 {
-    my ($exifTool, $dirInfo) = @_;
+    my ($et, $dirInfo) = @_;
     my $dataPt = $$dirInfo{DataPt};
     my $pos = $$dirInfo{DirStart};
     my $end = $pos + $$dirInfo{DirLen};
@@ -783,7 +783,7 @@ sub ProcessPEVersion($$)
         ($string, $strEnd) = ReadUnicodeStr($dataPt, $pos + 6);
         return 0 if $strEnd + $valLen > $end;
         unless ($index or $string eq 'VS_VERSION_INFO') {
-            $exifTool->Warn('Invalid Version Info block');
+            $et->Warn('Invalid Version Info block');
             return 0;
         }
         if ($string eq 'VS_VERSION_INFO') {
@@ -791,7 +791,7 @@ sub ProcessPEVersion($$)
             $$dirInfo{DirStart} = $strEnd;
             $$dirInfo{DirLen} = $valLen;
             my $subTablePtr = GetTagTable('Image::ExifTool::EXE::PEVersion');
-            $exifTool->ProcessDirectory($dirInfo, $subTablePtr);
+            $et->ProcessDirectory($dirInfo, $subTablePtr);
             $pos = $strEnd + $valLen;
         } elsif ($string eq 'StringFileInfo' and $valLen == 0) {
             $pos += $len;
@@ -814,8 +814,8 @@ sub ProcessPEVersion($$)
                         $char = substr($string, 4);
                         $string = substr($string, 0, 4);
                     }
-                    $exifTool->HandleTag($tagTablePtr, 'LanguageCode', uc $string);
-                    $exifTool->HandleTag($tagTablePtr, 'CharacterSet', uc $char) if $char;
+                    $et->HandleTag($tagTablePtr, 'LanguageCode', uc $string);
+                    $et->HandleTag($tagTablePtr, 'CharacterSet', uc $char) if $char;
                     next;
                 }
                 my $tag = $string;
@@ -828,11 +828,11 @@ sub ProcessPEVersion($$)
                 }
                 # get tag value (converted to current Charset)
                 if ($valLen) {
-                    ($string, $pt) = ReadUnicodeStr($dataPt, $pt, $exifTool);
+                    ($string, $pt) = ReadUnicodeStr($dataPt, $pt, $et);
                 } else {
                     $string = '';
                 }
-                $exifTool->HandleTag($tagTablePtr, $tag, $string);
+                $et->HandleTag($tagTablePtr, $tag, $string);
             }
         } else {
             $pos += $len + $valLen;
@@ -848,12 +848,12 @@ sub ProcessPEVersion($$)
 # Returns: true on success
 sub ProcessPEResources($$)
 {
-    my ($exifTool, $dirInfo) = @_;
+    my ($et, $dirInfo) = @_;
     my $raf = $$dirInfo{RAF};
     my $base = $$dirInfo{Base};
     my $dirStart = $$dirInfo{DirStart} + $base;
     my $level = $$dirInfo{Level} || 0;
-    my $verbose = $exifTool->Options('Verbose');
+    my $verbose = $et->Options('Verbose');
     my ($buff, $buf2, $item);
 
     return 0 if $level > 10;    # protect against deep recursion
@@ -873,7 +873,7 @@ sub ProcessPEResources($$)
             my $resType = $resourceType{$name} || sprintf('Unknown (0x%x)', $name);
             # ignore everything but the Version resource unless verbose
             if ($verbose) {
-                $exifTool->VPrint(0, "$resType resource:\n");
+                $et->VPrint(0, "$resType resource:\n");
             } else {
                 next unless $resType eq 'Version';
             }
@@ -883,7 +883,7 @@ sub ProcessPEResources($$)
             # descend into next directory level
             $$dirInfo{DirStart} = $entryPos & 0x7fffffff;
             $$dirInfo{Level} = $level + 1;
-            ProcessPEResources($exifTool, $dirInfo) or return 0;
+            ProcessPEResources($et, $dirInfo) or return 0;
             --$$dirInfo{Level};
         } elsif ($$dirInfo{ResType} eq 'Version' and $level == 2 and
             not $$dirInfo{GotVersion}) # (only process first Version resource)
@@ -903,12 +903,12 @@ sub ProcessPEResources($$)
             }
             return 0 unless $filePos;
             $raf->Seek($filePos, 0) and $raf->Read($buf2, $len) == $len or return 0;
-            ProcessPEVersion($exifTool, {
+            ProcessPEVersion($et, {
                 DataPt   => \$buf2,
                 DataLen  => $len,
                 DirStart => 0,
                 DirLen   => $len,
-            }) or $exifTool->Warn('Possibly corrupt Version resource');
+            }) or $et->Warn('Possibly corrupt Version resource');
             $$dirInfo{GotVersion} = 1;  # set flag so we don't do this again
         }
     }
@@ -921,7 +921,7 @@ sub ProcessPEResources($$)
 # Returns: true on success
 sub ProcessPEDict($$)
 {
-    my ($exifTool, $dirInfo) = @_;
+    my ($et, $dirInfo) = @_;
     my $raf = $$dirInfo{RAF};
     my $dataPt = $$dirInfo{DataPt};
     my $dirLen = length($$dataPt);
@@ -945,7 +945,7 @@ sub ProcessPEDict($$)
         ) if $name eq ".rsrc\0\0\0" and not %dirInfo;
     }
     # process the first resource section
-    ProcessPEResources($exifTool, \%dirInfo) or return 0 if %dirInfo;
+    ProcessPEResources($et, \%dirInfo) or return 0 if %dirInfo;
     return 1;
 }
 
@@ -955,7 +955,7 @@ sub ProcessPEDict($$)
 # Returns: 1 on success, 0 if this wasn't a valid EXE file
 sub ProcessEXE($$)
 {
-    my ($exifTool, $dirInfo) = @_;
+    my ($et, $dirInfo) = @_;
     my $raf = $$dirInfo{RAF};
     my ($buff, $buf2, $type, $tagTablePtr, %dirInfo);
 
@@ -1016,7 +1016,7 @@ sub ProcessEXE($$)
                     my $machine = $Image::ExifTool::EXE::Main{0}{PrintConv}{Get16u(\$buff, 4)} || '';
                     my $winType = $machine =~ /64/ ? 'Win64' : 'Win32';
                     my $flags = Get16u(\$buff, 22);
-                    $exifTool->SetFileType($winType . ' ' . ($flags & 0x2000 ? 'DLL' : 'EXE'));
+                    $et->SetFileType($winType . ' ' . ($flags & 0x2000 ? 'DLL' : 'EXE'));
                     # read the rest of the optional header if necessary
                     my $optSize = Get16u(\$buff, 20);
                     my $more = $optSize + 24 - $size;
@@ -1027,11 +1027,11 @@ sub ProcessEXE($$)
                             my $magic = Get16u(\$buff, 24);
                             # verify PE32/PE32+ magic number
                             unless ($magic == 0x10b or $magic == 0x20b) {
-                                $exifTool->Warn('Unknown PE magic number');
+                                $et->Warn('Unknown PE magic number');
                                 return 1;
                             }
                         } else {
-                            $exifTool->Warn('Error reading optional header');
+                            $et->Warn('Error reading optional header');
                         }
                     }
                     # process PE COFF file header
@@ -1043,7 +1043,7 @@ sub ProcessEXE($$)
                         DirStart => 4,
                         DirLen => $size,
                     );
-                    $exifTool->ProcessDirectory(\%dirInfo, $tagTablePtr);
+                    $et->ProcessDirectory(\%dirInfo, $tagTablePtr);
                     # process data dictionary
                     my $num = Get16u(\$buff, 6);    # NumberOfSections
                     if ($raf->Read($buff, 40 * $num) == 40 * $num) {
@@ -1051,7 +1051,7 @@ sub ProcessEXE($$)
                             RAF => $raf,
                             DataPt => \$buff,
                         );
-                        ProcessPEDict($exifTool, \%dirInfo) or $exifTool->Warn('Error processing PE data dictionary');
+                        ProcessPEDict($et, \%dirInfo) or $et->Warn('Error processing PE data dictionary');
                     }
                     return 1;
                 }
@@ -1070,24 +1070,24 @@ sub ProcessEXE($$)
         $tagTablePtr = GetTagTable('Image::ExifTool::EXE::MachO');
         if ($1 eq "\xca\xfe\xba\xbe") {
             SetByteOrder('MM');
-            $exifTool->SetFileType('Mach-O fat binary executable');
+            $et->SetFileType('Mach-O fat binary executable');
             my $count = Get32u(\$buff, 4);  # get architecture count
             my $more = $count * 20 - ($size - 8);
             if ($more > 0) {
                 unless ($raf->Read($buf2, $more) == $more) {
-                    $exifTool->Warn('Error reading fat-arch headers');
+                    $et->Warn('Error reading fat-arch headers');
                     return 1;
                 }
                 $buff .= $buf2;
                 $size += $more;
             }
-            $exifTool->HandleTag($tagTablePtr, 2, $count);
+            $et->HandleTag($tagTablePtr, 2, $count);
             my $i;
             for ($i=0; $i<$count; ++$i) {
                 my $cpuType = Get32s(\$buff, 8 + $i * 20);
                 my $cpuSubtype = Get32u(\$buff, 12 + $i * 20);
-                $exifTool->HandleTag($tagTablePtr, 3, $cpuType);
-                $exifTool->HandleTag($tagTablePtr, 4, "$cpuType $cpuSubtype");
+                $et->HandleTag($tagTablePtr, 3, $cpuType);
+                $et->HandleTag($tagTablePtr, 4, "$cpuType $cpuSubtype");
             }
             # load first Mach-O header to get the object file type
             my $offset = Get32u(\$buff, 16);
@@ -1095,18 +1095,18 @@ sub ProcessEXE($$)
                 if ($buf2 =~ /^(\xfe\xed\xfa(\xce|\xcf)|(\xce|\xcf)\xfa\xed\xfe)/) {
                     SetByteOrder($buf2 =~ /^\xfe\xed/ ? 'MM' : 'II');
                     my $objType = Get32s(\$buf2, 12);
-                    $exifTool->HandleTag($tagTablePtr, 5, $objType);
+                    $et->HandleTag($tagTablePtr, 5, $objType);
                 } elsif ($buf2 =~ /^!<arch>\x0a/) {
                     # .a libraries use this magic number
-                    $exifTool->HandleTag($tagTablePtr, 5, -1);
+                    $et->HandleTag($tagTablePtr, 5, -1);
                 } else {
-                    $exifTool->Warn('Unrecognized object file type');
+                    $et->Warn('Unrecognized object file type');
                 }
             } else {
-                $exifTool->Warn('Error reading file');
+                $et->Warn('Error reading file');
             }
        } elsif ($size >= 16) {
-            $exifTool->SetFileType('Mach-O executable');
+            $et->SetFileType('Mach-O executable');
             my $info = {
                 "\xfe\xed\xfa\xce" => ['32 bit', 'Big endian'],
                 "\xce\xfa\xed\xfe" => ['32 bit', 'Little endian'],
@@ -1118,11 +1118,11 @@ sub ProcessEXE($$)
             my $cpuType = Get32s(\$buff, 4);
             my $cpuSubtype = Get32s(\$buff, 8);
             my $objType = Get32s(\$buff, 12);
-            $exifTool->HandleTag($tagTablePtr, 0, $$info[0]);
-            $exifTool->HandleTag($tagTablePtr, 1, $$info[1]);
-            $exifTool->HandleTag($tagTablePtr, 3, $cpuType);
-            $exifTool->HandleTag($tagTablePtr, 4, "$cpuType $cpuSubtype");
-            $exifTool->HandleTag($tagTablePtr, 5, $objType);
+            $et->HandleTag($tagTablePtr, 0, $$info[0]);
+            $et->HandleTag($tagTablePtr, 1, $$info[1]);
+            $et->HandleTag($tagTablePtr, 3, $cpuType);
+            $et->HandleTag($tagTablePtr, 4, "$cpuType $cpuSubtype");
+            $et->HandleTag($tagTablePtr, 5, $objType);
         }
         return 1;
 #
@@ -1130,7 +1130,7 @@ sub ProcessEXE($$)
 #
     } elsif ($buff =~ /^Joy!peff/ and $size > 12) {
         # ref http://developer.apple.com/documentation/mac/pdf/MacOS_RT_Architectures.pdf
-        $exifTool->SetFileType('Classic MacOS executable');
+        $et->SetFileType('Classic MacOS executable');
         SetByteOrder('MM');
         $tagTablePtr = GetTagTable('Image::ExifTool::EXE::PEF');
         %dirInfo = (
@@ -1140,13 +1140,13 @@ sub ProcessEXE($$)
             DirStart => 0,
             DirLen => $size,
         );
-        $exifTool->ProcessDirectory(\%dirInfo, $tagTablePtr);
+        $et->ProcessDirectory(\%dirInfo, $tagTablePtr);
         return 1;
 #
 # ELF (Unix)
 #
     } elsif ($buff =~ /^\x7fELF/ and $size >= 16) {
-        $exifTool->SetFileType("ELF executable");
+        $et->SetFileType("ELF executable");
         SetByteOrder(Get8u(\$buff,5) == 1 ? 'II' : 'MM');
         $tagTablePtr = GetTagTable('Image::ExifTool::EXE::ELF');
         %dirInfo = (
@@ -1156,7 +1156,7 @@ sub ProcessEXE($$)
             DirStart => 0,
             DirLen => $size,
         );
-        $exifTool->ProcessDirectory(\%dirInfo, $tagTablePtr);
+        $et->ProcessDirectory(\%dirInfo, $tagTablePtr);
         return 1;
 #
 # various scripts (perl, sh, etc...)
@@ -1170,7 +1170,7 @@ sub ProcessEXE($$)
         $type = 'Static library',
     }
     return 0 unless $type;
-    $exifTool->SetFileType($type);
+    $et->SetFileType($type);
     return 1;
 }