exiftool_vendored 9.37.0 → 9.41.0

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

@@ -14,7 +14,7 @@ use strict;
 use vars qw($VERSION);
 use Image::ExifTool qw(:DataAccess :Utils);
 
-$VERSION = '1.02';
+$VERSION = '1.03';
 
 sub ProcessRAW($$);
 
@@ -111,7 +111,7 @@ sub ReverseString($) { pack('C*',reverse unpack('C*',shift)) }
 # Returns: 1 if this was a valid Kyocera RAW image
 sub ProcessRAW($$)
 {
-    my ($exifTool, $dirInfo) = @_;
+    my ($et, $dirInfo) = @_;
     my $raf = $$dirInfo{RAF};
     my $size = 156; # size of header
     my $buff;
@@ -119,7 +119,7 @@ sub ProcessRAW($$)
     $raf->Read($buff, $size) == $size or return 0;
     # validate Make string ('KYOCERA' reversed)
     substr($buff, 0x19, 7) eq 'ARECOYK' or return 0;
-    $exifTool->SetFileType();
+    $et->SetFileType();
     SetByteOrder('MM');
     my %dirInfo = (
         DataPt => \$buff,
@@ -129,7 +129,7 @@ sub ProcessRAW($$)
         DirLen => $size,
     );
     my $tagTablePtr = GetTagTable('Image::ExifTool::KyoceraRaw::Main');
-    $exifTool->ProcessDirectory(\%dirInfo, $tagTablePtr);
+    $et->ProcessDirectory(\%dirInfo, $tagTablePtr);
     return 1;
 }
 

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

@@ -15,7 +15,7 @@ use strict;
 use vars qw($VERSION);
 use Image::ExifTool qw(:DataAccess :Utils);
 
-$VERSION = '1.05';
+$VERSION = '1.06';
 
 sub ProcessItemID($$$);
 sub ProcessLinkInfo($$$);
@@ -460,7 +460,7 @@ sub GetString($$;$)
 # Returns: 1 on success
 sub ProcessItemID($$$)
 {
-    my ($exifTool, $dirInfo, $tagTablePtr) = @_;
+    my ($et, $dirInfo, $tagTablePtr) = @_;
     my $dataPt = $$dirInfo{DataPt};
     my $dataLen = length $$dataPt;
     my $pos = 0;
@@ -468,7 +468,7 @@ sub ProcessItemID($$$)
         DataPt  => $dataPt,
         DataPos => $$dirInfo{DataPos},
     );
-    $exifTool->VerboseDir('ItemID', undef, $dataLen);
+    $et->VerboseDir('ItemID', undef, $dataLen);
     for (;;) {
         last if $pos + 4 >= $dataLen;
         my $size = Get16u($dataPt, $pos);
@@ -478,7 +478,7 @@ sub ProcessItemID($$$)
             Name => sprintf('Item%.4x', $tag),
             SubDirectory => { TagTable => 'Image::ExifTool::LNK::UnknownData' },
         }) unless $$tagTablePtr{$tag};
-        $exifTool->HandleTag($tagTablePtr, $tag, undef, %opts, Start => $pos, Size => $size);
+        $et->HandleTag($tagTablePtr, $tag, undef, %opts, Start => $pos, Size => $size);
         $pos += $size;
     }
 }
@@ -489,7 +489,7 @@ sub ProcessItemID($$$)
 # Returns: 1 on success
 sub ProcessLinkInfo($$$)
 {
-    my ($exifTool, $dirInfo, $tagTablePtr) = @_;
+    my ($et, $dirInfo, $tagTablePtr) = @_;
     my $dataPt = $$dirInfo{DataPt};
     my $dataLen = length $$dataPt;
     return 0 if $dataLen < 0x20;
@@ -501,13 +501,13 @@ sub ProcessLinkInfo($$$)
         Size    => 4, # (typical value size)
     );
     my ($off, $unicode, $pos, $val, $size);
-    $exifTool->VerboseDir('LinkInfo', undef, $dataLen);
+    $et->VerboseDir('LinkInfo', undef, $dataLen);
     if ($lif & 0x01) {
         # read Volume ID
         $off = Get32u($dataPt, 0x0c);
         if ($off + 0x20 <= $dataLen) {
             # my $len = Get32u($dataPt, $off);
-            $exifTool->HandleTag($tagTablePtr, 'DriveType', undef, %opts, Start=>$off+4);
+            $et->HandleTag($tagTablePtr, 'DriveType', undef, %opts, Start=>$off+4);
             $pos = Get32u($dataPt, $off + 0x0c);
             if ($pos == 0x14) {
                 # use VolumeLabelOffsetUnicode instead
@@ -518,8 +518,8 @@ sub ProcessLinkInfo($$$)
             $val = GetString($dataPt, $pos, $unicode);
             if (defined $val) {
                 $size = length $val;
-                $val = $exifTool->Decode($val, 'UCS2') if $unicode;
-                $exifTool->HandleTag($tagTablePtr, 'VolumeLabel', $val, %opts, Start=>$pos, Size=>$size);
+                $val = $et->Decode($val, 'UCS2') if $unicode;
+                $et->HandleTag($tagTablePtr, 'VolumeLabel', $val, %opts, Start=>$pos, Size=>$size);
             }
         }
         # read local base path
@@ -533,8 +533,8 @@ sub ProcessLinkInfo($$$)
         $val = GetString($dataPt, $pos, $unicode);
         if (defined $val) {
             $size = length $val;
-            $val = $exifTool->Decode($val, 'UCS2') if $unicode;
-            $exifTool->HandleTag($tagTablePtr, 'LocalBasePath', $val, %opts, Start=>$pos, Size=>$size);
+            $val = $et->Decode($val, 'UCS2') if $unicode;
+            $et->HandleTag($tagTablePtr, 'LocalBasePath', $val, %opts, Start=>$pos, Size=>$size);
         }
     }
     if ($lif & 0x02) {
@@ -552,8 +552,8 @@ sub ProcessLinkInfo($$$)
             $val = GetString($dataPt, $pos, $unicode);
             if (defined $val) {
                 $size = length $val;
-                $val = $exifTool->Decode($val, 'UCS2') if $unicode;
-                $exifTool->HandleTag($tagTablePtr, 'NetName', $val, %opts, Start=>$pos, Size=>$size);
+                $val = $et->Decode($val, 'UCS2') if $unicode;
+                $et->HandleTag($tagTablePtr, 'NetName', $val, %opts, Start=>$pos, Size=>$size);
             }
             my $flg = Get32u($dataPt, $off + 0x04);
             if ($flg & 0x01) {
@@ -567,13 +567,13 @@ sub ProcessLinkInfo($$$)
                 $val = GetString($dataPt, $pos, $unicode);
                 if (defined $val) {
                     $size = length $val;
-                    $val = $exifTool->Decode($val, 'UCS2') if $unicode;
-                    $exifTool->HandleTag($tagTablePtr, 'DeviceName', $val, %opts, Start=>$pos, Size=>$size);
+                    $val = $et->Decode($val, 'UCS2') if $unicode;
+                    $et->HandleTag($tagTablePtr, 'DeviceName', $val, %opts, Start=>$pos, Size=>$size);
                 }
             }
             if ($flg & 0x02) {
                 $val = Get32u($dataPt, $off + 0x10);
-                $exifTool->HandleTag($tagTablePtr, 'NetProviderType', $val, %opts, Start=>$off + 0x10);
+                $et->HandleTag($tagTablePtr, 'NetProviderType', $val, %opts, Start=>$off + 0x10);
             }
         }
     }
@@ -586,7 +586,7 @@ sub ProcessLinkInfo($$$)
 # Returns: 1 on success, 0 if this wasn't a valid LNK file
 sub ProcessLNK($$)
 {
-    my ($exifTool, $dirInfo) = @_;
+    my ($et, $dirInfo) = @_;
     my $raf = $$dirInfo{RAF};
     my ($buff, $buf2, $len, $i);
 
@@ -599,7 +599,7 @@ sub ProcessLNK($$)
         $raf->Read($buf2, $len - 0x4c) == $len - 0x4c or return 0;
         $buff .= $buf2;
     }
-    $exifTool->SetFileType('Windows Shortcut');
+    $et->SetFileType('Windows Shortcut');
     SetByteOrder('II');
 
     my $tagTablePtr = GetTagTable('Image::ExifTool::LNK::Main');
@@ -609,7 +609,7 @@ sub ProcessLNK($$)
         DataLen => length $buff,
         DirLen => length $buff,
     );
-    $exifTool->ProcessDirectory(\%dirInfo, $tagTablePtr);
+    $et->ProcessDirectory(\%dirInfo, $tagTablePtr);
 
     my $flags = Get32u(\$buff, 0x14);
 
@@ -618,7 +618,7 @@ sub ProcessLNK($$)
         $raf->Read($buff, 2) or return 1;
         $len = unpack('v', $buff);
         $raf->Read($buff, $len) == $len or return 1;
-        $exifTool->HandleTag($tagTablePtr, 0x10000, undef,
+        $et->HandleTag($tagTablePtr, 0x10000, undef,
             DataPt  => \$buff,
             DataPos => $raf->Tell() - $len,
             Size    => $len,
@@ -632,7 +632,7 @@ sub ProcessLNK($$)
         return 1 if $len < 4;
         $raf->Read($buf2, $len - 4) == $len - 4 or return 1;
         $buff .= $buf2;
-        $exifTool->HandleTag($tagTablePtr, 0x20000, undef,
+        $et->HandleTag($tagTablePtr, 0x20000, undef,
             DataPt  => \$buff,
             DataPos => $raf->Tell() - $len,
             Size    => $len,
@@ -650,8 +650,8 @@ sub ProcessLNK($$)
         $len *= 2 if $flags & 0x80;  # characters are 2 bytes if Unicode flag is set   
         $raf->Read($buff, $len) or return 1;
         my $val;
-        $val = $exifTool->Decode($buff, 'UCS2') if $flags & 0x80;
-        $exifTool->HandleTag($tagTablePtr, 0x30000 | $mask, $val,
+        $val = $et->Decode($buff, 'UCS2') if $flags & 0x80;
+        $et->HandleTag($tagTablePtr, 0x30000 | $mask, $val,
             DataPt  => \$buff,
             DataPos => $raf->Tell() - $len,
             Size    => $len,
@@ -671,7 +671,7 @@ sub ProcessLNK($$)
         unless (ref $tagInfo eq 'HASH' and $$tagInfo{SubDirectory}) {
             $tagInfo = $$tagTablePtr{0xa0000000};
         }
-        $exifTool->HandleTag($tagTablePtr, $tag, undef,
+        $et->HandleTag($tagTablePtr, $tag, undef,
             DataPt  => \$buff,
             DataPos => $raf->Tell() - $len - 4,
             TagInfo => $tagInfo,

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

@@ -354,7 +354,7 @@ $VERSION = '1.21';
    'AIServoTrackingSensitivity' => {
       Description => 'Sensibili. de suivi AI Servo',
       PrintConv => {
-        'Fast' => 'Schnell',
+        'Fast' => 'Rapide',
         'Medium Fast' => 'Moyenne rapide',
         'Medium Slow' => 'Moyenne lent',
         'Moderately fast' => 'Moyennement rapide',

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

@@ -13,7 +13,7 @@ use vars qw($VERSION);
 use Image::ExifTool qw(:DataAccess :Utils);
 use Image::ExifTool::Exif;
 
-$VERSION = '1.04';
+$VERSION = '1.05';
 
 sub ProcessLeaf($$$);
 
@@ -394,17 +394,17 @@ sub ProcessLeaf($$$);
 # Returns: 1 on success, otherwise returns 0 and sets a Warning
 sub ProcessLeaf($$$)
 {
-    my ($exifTool, $dirInfo, $tagTablePtr) = @_;
+    my ($et, $dirInfo, $tagTablePtr) = @_;
     my $dataPt = $$dirInfo{DataPt};
     my $dirStart = $$dirInfo{DirStart} || 0;
     my $dirLen = $$dirInfo{DirLen} || $$dirInfo{DataLen} - $dirStart;
     my $dirEnd = $dirStart + $dirLen;
-    my $verbose = $exifTool->Options('Verbose');
+    my $verbose = $et->Options('Verbose');
     my $pos = $dirStart;
     my $hdrLen = 52;    # header length for PKTS information
     my $success;
 
-    $verbose and $exifTool->VerboseDir('Leaf');
+    $verbose and $et->VerboseDir('Leaf');
     for (;;) {
         last if $pos + $hdrLen > $dirEnd;
         my $header = substr($$dataPt, $pos, $hdrLen);
@@ -413,13 +413,13 @@ sub ProcessLeaf($$$)
         my $size = Get32u(\$header, 48);
         $pos += $hdrLen;
         if ($pos + $size > $dirEnd) {
-            $exifTool->Warn('Truncated Leaf data');
+            $et->Warn('Truncated Leaf data');
             last;
         }
         my $tag = substr($header, 8, 40);
         $tag =~ s/\0.*//s;
         next unless $tag;
-        my $tagInfo = $exifTool->GetTagInfo($tagTablePtr, $tag);
+        my $tagInfo = $et->GetTagInfo($tagTablePtr, $tag);
         # generate tag info for unknown tags
         my $val;
         if ($tagInfo and $$tagInfo{Format}) {
@@ -437,7 +437,7 @@ sub ProcessLeaf($$$)
                     SubDirectory => { TagTable => 'Image::ExifTool::Leaf::Unknown' },
                 };
             } elsif ($tagTablePtr ne \%Image::ExifTool::Leaf::Main or
-                     $exifTool->Options('Unknown'))
+                     $et->Options('Unknown'))
             {
                 $tagInfo = {
                     Name => $name,
@@ -450,7 +450,7 @@ sub ProcessLeaf($$$)
             $tagInfo and AddTagToTable($tagTablePtr, $tag, $tagInfo);
         }
         if ($verbose) {
-            $exifTool->VerboseInfo($tag, $tagInfo,
+            $et->VerboseInfo($tag, $tagInfo,
                 Table   => $tagTablePtr,
                 Value   => $val,
                 DataPt  => $dataPt,
@@ -469,16 +469,16 @@ sub ProcessLeaf($$$)
                     DirName => 'Leaf PKTS',
                 );
                 my $subTable = GetTagTable($tagInfo->{SubDirectory}->{TagTable});
-                $exifTool->ProcessDirectory(\%subdirInfo, $subTable);
+                $et->ProcessDirectory(\%subdirInfo, $subTable);
             } else {
                 $val =~ tr/\n/ /;   # translate newlines to spaces
                 $val =~ s/\0+$//;   # remove null terminators
-                $exifTool->FoundTag($tagInfo, $val);
+                $et->FoundTag($tagInfo, $val);
             }
         }
         $pos += $size;
     }
-    $success or $exifTool->Warn('Bad format Leaf data');
+    $success or $et->Warn('Bad format Leaf data');
     return $success;
 }
 

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

@@ -31,7 +31,7 @@ use strict;
 use vars qw($VERSION);
 use Image::ExifTool qw(:DataAccess :Utils);
 
-$VERSION = '1.09';
+$VERSION = '1.10';
 
 # program map table "stream_type" lookup (ref 6/1)
 my %streamType = (
@@ -233,11 +233,11 @@ my %noSyntax = (
 # Reference: http://www.atsc.org/standards/a_52b.pdf
 sub ParseAC3Audio($$)
 {
-    my ($exifTool, $dataPt) = @_;
+    my ($et, $dataPt) = @_;
     if ($$dataPt =~ /\x0b\x77..(.)/sg) {
         my $sampleRate = ord($1) >> 6;
         my $tagTablePtr = GetTagTable('Image::ExifTool::M2TS::AC3');
-        $exifTool->HandleTag($tagTablePtr, AudioSampleRate => $sampleRate);
+        $et->HandleTag($tagTablePtr, AudioSampleRate => $sampleRate);
     }
 }
 
@@ -249,14 +249,14 @@ sub ParseAC3Audio($$)
 #       is somewhat easier to extract it from the descriptor instead
 sub ParseAC3Descriptor($$)
 {
-    my ($exifTool, $dataPt) = @_;
+    my ($et, $dataPt) = @_;
     return if length $$dataPt < 3;
     my @v = unpack('C3', $$dataPt);
     my $tagTablePtr = GetTagTable('Image::ExifTool::M2TS::AC3');
-    # $exifTool->HandleTag($tagTablePtr, 'AudioSampleRate', $v[0] >> 5);
-    $exifTool->HandleTag($tagTablePtr, 'AudioBitrate', $v[1] >> 2);
-    $exifTool->HandleTag($tagTablePtr, 'SurroundMode', $v[1] & 0x03);
-    $exifTool->HandleTag($tagTablePtr, 'AudioChannels', ($v[2] >> 1) & 0x0f);
+    # $et->HandleTag($tagTablePtr, 'AudioSampleRate', $v[0] >> 5);
+    $et->HandleTag($tagTablePtr, 'AudioBitrate', $v[1] >> 2);
+    $et->HandleTag($tagTablePtr, 'SurroundMode', $v[1] & 0x03);
+    $et->HandleTag($tagTablePtr, 'AudioChannels', ($v[2] >> 1) & 0x0f);
     # don't (yet) decode any more (language codes, etc)
 }
 
@@ -268,12 +268,12 @@ sub ParseAC3Descriptor($$)
 #          -1=can't parse yet because we don't know the type
 sub ParsePID($$$$$)
 {
-    my ($exifTool, $pid, $type, $pidName, $dataPt) = @_;
+    my ($et, $pid, $type, $pidName, $dataPt) = @_;
     # can't parse until we know the type (Program Map Table may be later in the stream)
     return -1 unless defined $type;   
-    my $verbose = $exifTool->Options('Verbose');
+    my $verbose = $et->Options('Verbose');
     if ($verbose > 1) {
-        my $out = $exifTool->Options('TextOut');
+        my $out = $et->Options('TextOut');
         printf $out "Parsing stream 0x%.4x (%s)\n", $pid, $pidName;
         my %parms = ( Out => $out );
         $parms{MaxLen} = 96 if $verbose < 4;
@@ -283,20 +283,20 @@ sub ParsePID($$$$$)
     if ($type == 0x01 or $type == 0x02) {
         # MPEG-1/MPEG-2 Video
         require Image::ExifTool::MPEG;
-        Image::ExifTool::MPEG::ParseMPEGAudioVideo($exifTool, $dataPt);
+        Image::ExifTool::MPEG::ParseMPEGAudioVideo($et, $dataPt);
     } elsif ($type == 0x03 or $type == 0x04) {
         # MPEG-1/MPEG-2 Audio
         require Image::ExifTool::MPEG;
-        Image::ExifTool::MPEG::ParseMPEGAudio($exifTool, $dataPt);
+        Image::ExifTool::MPEG::ParseMPEGAudio($et, $dataPt);
     } elsif ($type == 0x1b) {
         # H.264 Video
         require Image::ExifTool::H264;
-        $more = Image::ExifTool::H264::ParseH264Video($exifTool, $dataPt);
+        $more = Image::ExifTool::H264::ParseH264Video($et, $dataPt);
         # force parsing additional H264 frames with ExtractEmbedded option
-        $more = 1 if $exifTool->Options('ExtractEmbedded');
+        $more = 1 if $et->Options('ExtractEmbedded');
     } elsif ($type == 0x81 or $type == 0x87 or $type == 0x91) {
         # AC-3 audio
-        ParseAC3Audio($exifTool, $dataPt);
+        ParseAC3Audio($et, $dataPt);
     }
     return $more;
 }
@@ -307,13 +307,13 @@ sub ParsePID($$$$$)
 # Returns: 1 on success, 0 if this wasn't a valid M2TS file
 sub ProcessM2TS($$)
 {
-    my ($exifTool, $dirInfo) = @_;
+    my ($et, $dirInfo) = @_;
     my $raf = $$dirInfo{RAF};
     my ($buff, $pLen, $upkPrefix, $j, $fileType, $eof);
     my (%pmt, %pidType, %data, %sectLen);
     my ($startTime, $endTime, $backScan, $maxBack);
-    my $verbose = $exifTool->Options('Verbose');
-    my $out = $exifTool->Options('TextOut');
+    my $verbose = $et->Options('Verbose');
+    my $out = $et->Options('TextOut');
 
     # read first packet
     return 0 unless $raf->Read($buff, 8) == 8;
@@ -327,7 +327,7 @@ sub ProcessM2TS($$)
         $pLen = 192; # 188-byte transport packet + leading 4-byte timecode (ref 4)
         $upkPrefix = 'x4N';
     }
-    $exifTool->SetFileType($fileType);
+    $et->SetFileType($fileType);
     SetByteOrder('MM');
     $raf->Seek(0,0);        # rewind to start
     my $tagTablePtr = GetTagTable('Image::ExifTool::M2TS::Main');
@@ -359,7 +359,7 @@ sub ProcessM2TS($$)
                 last if $backScan < $maxBack;
             } else {
                 undef $endTime;
-                last if $exifTool->Options('FastScan');
+                last if $et->Options('FastScan');
                 $verbose and print "[Starting backscan for last PCR]\n";
                 # calculate position of last complete packet
                 my $fwdPos = $raf->Tell();
@@ -385,7 +385,7 @@ sub ProcessM2TS($$)
         my $prefix = unpack("x${pos}N", $buff); # (use unpack instead of Get32u for speed)
         # validate sync byte
         unless (($prefix & 0xff000000) == 0x47000000) {
-            $exifTool->Warn('Synchronization error') unless defined $backScan;
+            $et->Warn('Synchronization error') unless defined $backScan;
             last;
         }
       # my $transport_error_indicator    = $prefix & 0x00800000;
@@ -412,7 +412,7 @@ sub ProcessM2TS($$)
         # handle adaptation field
         if ($adaptation_field_exists) {
             my $len = Get8u(\$buff, $pos++);
-            $pos + $len > $pEnd and $exifTool->Warn('Invalid adaptation field length'), last;
+            $pos + $len > $pEnd and $et->Warn('Invalid adaptation field length'), last;
             # read PCR value for calculation of Duration
             if ($len > 6) {
                 my $flags = Get8u(\$buff, $pos);
@@ -443,7 +443,7 @@ sub ProcessM2TS($$)
                 # skip to start of section
                 my $pointer_field = Get8u(\$buff, $pos);
                 $pos += 1 + $pointer_field;
-                $pos >= $pEnd and $exifTool->Warn('Bad pointer field'), last;
+                $pos >= $pEnd and $et->Warn('Bad pointer field'), last;
                 $buf2 = substr($buff, $pEnd-$pLen, $pLen);
                 $pos -= $pEnd - $pLen;
             } else {
@@ -461,7 +461,7 @@ sub ProcessM2TS($$)
                 delete $sectLen{$pid};
             }
             my $slen = length($buf2);   # section length
-            $pos + 8 > $slen and $exifTool->Warn("Truncated payload"), last;
+            $pos + 8 > $slen and $et->Warn("Truncated payload"), last;
             # validate table ID
             my $table_id = Get8u(\$buf2, $pos);
             my $name = ($tableID{$table_id} || sprintf('Unknown (0x%x)',$table_id)) . ' Table';
@@ -474,9 +474,9 @@ sub ProcessM2TS($$)
             }
             # validate section syntax indicator for parsed tables (PAT, PMT)
             my $section_syntax_indicator = Get8u(\$buf2, $pos + 1) & 0xc0;
-            $section_syntax_indicator == 0x80 or $exifTool->Warn("Bad $name"), last;
+            $section_syntax_indicator == 0x80 or $et->Warn("Bad $name"), last;
             my $section_length = Get16u(\$buf2, $pos + 1) & 0x0fff;
-            $section_length > 1021 and $exifTool->Warn("Invalid $name length"), last;
+            $section_length > 1021 and $et->Warn("Invalid $name length"), last;
             if ($slen < $section_length + 3) { # (3 bytes for table_id + section_length)
                 # must wait until we have the full section
                 $data{$pid} = substr($buf2, $pos);
@@ -511,7 +511,7 @@ sub ProcessM2TS($$)
                 }
             } else {
                 # decode PMT (Program Map Table)
-                $pos + 4 > $slen and $exifTool->Warn('Truncated PMT'), last;
+                $pos + 4 > $slen and $et->Warn('Truncated PMT'), last;
                 my $pcr_pid = Get16u(\$buf2, $pos) & 0x1fff;
                 my $program_info_length = Get16u(\$buf2, $pos + 2) & 0x0fff;
                 if (not $pidName{$pcr_pid} or $verbose > 1) {
@@ -520,7 +520,7 @@ sub ProcessM2TS($$)
                     $verbose and printf $out "  PID(0x%.4x) --> $str\n", $pcr_pid;
                 }
                 $pos += 4;
-                $pos + $program_info_length > $slen and $exifTool->Warn('Truncated program info'), last;
+                $pos + $program_info_length > $slen and $et->Warn('Truncated program info'), last;
                 # dump program information descriptors if verbose
                 if ($verbose > 1) { for ($j=0; $j<$program_info_length-2; ) {
                     my $descriptor_tag = Get8u(\$buf2, $pos + $j);
@@ -547,13 +547,13 @@ sub ProcessM2TS($$)
                         $pidType{$elementary_pid} = $stream_type;
                         $verbose and printf $out "  PID(0x%.4x) --> $str\n", $elementary_pid;
                         if ($str =~ /(Audio|Video)/) {
-                            $exifTool->HandleTag($tagTablePtr, $1 . 'StreamType', $stream_type);
+                            $et->HandleTag($tagTablePtr, $1 . 'StreamType', $stream_type);
                             # we want to parse all Audio and Video streams
                             $needPID{$elementary_pid} = 1 unless $didPID{$elementary_pid};
                         }
                     }
                     $pos += 5;
-                    $pos + $es_info_length > $slen and $exifTool->Warn('Trunacted ES info'), $pos = $end, last;
+                    $pos + $es_info_length > $slen and $et->Warn('Trunacted ES info'), $pos = $end, last;
                     # parse elementary stream descriptors
                     for ($j=0; $j<$es_info_length-2; ) {
                         my $descriptor_tag = Get8u(\$buf2, $pos + $j);
@@ -570,7 +570,7 @@ sub ProcessM2TS($$)
                         # parse type-specific descriptor information (once)
                         unless ($didPID{$pid}) {
                             if ($descriptor_tag == 0x81) {  # AC-3
-                                ParseAC3Descriptor($exifTool, \$desc);
+                                ParseAC3Descriptor($et, \$desc);
                             }
                         }
                     }
@@ -585,7 +585,7 @@ sub ProcessM2TS($$)
             if ($payload_unit_start_indicator) {
                 if (defined $data{$pid}) {
                     # we must have a whole section, so parse now
-                    my $more = ParsePID($exifTool, $pid, $pidType{$pid}, $pidName{$pid}, \$data{$pid});
+                    my $more = ParsePID($et, $pid, $pidType{$pid}, $pidName{$pid}, \$data{$pid});
                     # start fresh even if we couldn't process this PID yet
                     delete $data{$pid};
                     unless ($more) {
@@ -611,7 +611,7 @@ sub ProcessM2TS($$)
                     next if $pos + 3 > $pEnd;
                     # validate PES syntax
                     my $syntax = Get8u(\$buff, $pos) & 0xc0;
-                    $syntax == 0x80 or $exifTool->Warn('Bad PES syntax'), next;
+                    $syntax == 0x80 or $et->Warn('Bad PES syntax'), next;
                     # skip PES header
                     my $pes_header_data_length = Get8u(\$buff, $pos + 2);
                     $pos += 3 + $pes_header_data_length;
@@ -627,7 +627,7 @@ sub ProcessM2TS($$)
             # unknown or H.264 streams where we save 1 kB
             my $saveLen = (not $pidType{$pid} or $pidType{$pid} == 0x1b) ? 1024 : 256;
             if (length($data{$pid}) >= $saveLen) {
-                my $more = ParsePID($exifTool, $pid, $pidType{$pid}, $pidName{$pid}, \$data{$pid});
+                my $more = ParsePID($et, $pid, $pidType{$pid}, $pidName{$pid}, \$data{$pid});
                 next if $more < 0;  # wait for program map table (hopefully not too long)
                 delete $data{$pid};
                 $more and $needPID{$pid} = -1, next; # parse more of these
@@ -647,7 +647,7 @@ sub ProcessM2TS($$)
     # calculate Duration if available
     if (defined $startTime and defined $endTime and $startTime != $endTime) {
         $endTime += 0x80000000 * 1200 if $startTime > $endTime; # handle 33-bit wrap
-        $exifTool->HandleTag($tagTablePtr, 'Duration', $endTime - $startTime);
+        $et->HandleTag($tagTablePtr, 'Duration', $endTime - $startTime);
     }
 
     if ($verbose) {
@@ -667,7 +667,7 @@ sub ProcessM2TS($$)
     # parse any remaining partial PID streams
     my $pid;
     foreach $pid (sort keys %data) {
-        ParsePID($exifTool, $pid, $pidType{$pid}, $pidName{$pid}, \$data{$pid});
+        ParsePID($et, $pid, $pidType{$pid}, $pidName{$pid}, \$data{$pid});
         delete $data{$pid};
     }
     return 1;