exiftool_vendored 9.37.0 → 9.41.0

data/bin/{Image-ExifTool-9.37 → Image-ExifTool-9.41}/lib/Image/ExifTool/README

@@ -299,14 +299,16 @@ numerical.
                   'BlockExtract' - set for writable directories in EXIF
                   information which are extracted by default.  Otherwise
                   writable directories are only extracted as a block if
-                  specified explicitly.
+                  specified explicitly.  Also used for Jpeg2000 and QuickTime
+                  XMP-like tags to extract as a block with a name other than
+                  'XMP'.
 
                   'DataMember' - name of exiftool data member associated with
                   this tag if it should be stored as a special data member when
                   writing information.  Necessary only if the value of the tag
                   affects other written information.  Currently only used for
                   tags in EXIF tables where it triggers the execution of the
-                  RawConv to convert and stores the value as an ExifTool data
+                  RawConv to convert and store the value as an ExifTool data
                   member when writing.
 
                   'DataTag' - associated tag name containing data for offset or
@@ -343,7 +345,7 @@ numerical.
                   is used even if the base changes for the current directory
                   (only some maker notes are this messed up).  Set to 3 if
                   absolute file offsets are used.  May be set to an expression
-                  to be evaluated.  Expression may access $val and $exifTool,
+                  to be evaluated.  Expression may access $val and $et,
                   and is evaluated only when reading.
 
                   'List' - flag indicating that duplicate entries of this tag

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

@@ -26,7 +26,7 @@ use strict;
 use vars qw($VERSION);
 use Image::ExifTool qw(:DataAccess :Utils);
 
-$VERSION = '1.35';
+$VERSION = '1.37';
 
 sub ConvertTimecode($);
 
@@ -328,6 +328,14 @@ my %riffMimeType = (
         Name => 'Exif',
         SubDirectory => { TagTable => 'Image::ExifTool::RIFF::Exif' },
     },
+    EXIF => { # WEBP Exif tags
+        Name => 'EXIF',
+        Notes => 'EXIF extracted from WEBP images',
+        SubDirectory => {
+            TagTable => 'Image::ExifTool::Exif::Main',
+            ProcessProc => \&Image::ExifTool::ProcessTIFF,
+        },
+    },
     LIST_hdrl => { # AVI header LIST chunk
         Name => 'Hdrl',
         SubDirectory => { TagTable => 'Image::ExifTool::RIFF::Hdrl' },
@@ -1013,7 +1021,7 @@ sub ConvertTimecode($)
 # Notes: Sums duration of all sub-documents (concatenated AVI files)
 sub CalcDuration($@)
 {
-    my ($exifTool, @val) = @_;
+    my ($et, @val) = @_;
     my $totalDuration = 0;
     my $subDoc = 0;
     my @keyList;
@@ -1030,10 +1038,10 @@ sub CalcDuration($@)
             $dur1 = $dur2 if $rat > 1.9 and $rat < 3.1;
         }
         $totalDuration += $dur1 if defined $dur1;
-        last unless $subDoc++ < $$exifTool{DOC_COUNT};
+        last unless $subDoc++ < $$et{DOC_COUNT};
         # get tag values for next sub-document
         my @tags = qw(FrameRate FrameCount VideoFrameRate VideoFrameCount);
-        my $rawValue = $$exifTool{VALUE};
+        my $rawValue = $$et{VALUE};
         my ($i, $j, $key, $keys);
         for ($i=0; $i<@tags; ++$i) {
             if ($subDoc == 1) {
@@ -1051,7 +1059,7 @@ sub CalcDuration($@)
             # find key for tag in this sub-document
             my $grp = "Doc$subDoc";
             $grp .= ":RIFF" if $i < 2; # (tags 0 and 1 also in RIFF group)
-            $key = $exifTool->GroupMatches($grp, $keys);
+            $key = $et->GroupMatches($grp, $keys);
             $val[$i] = $key ? $$rawValue{$key} : undef;
         }
         last unless defined $val[0] and defined $val[1]; # (Require'd tags)
@@ -1065,18 +1073,18 @@ sub CalcDuration($@)
 # Returns: 1 on success
 sub ProcessStreamData($$$)
 {
-    my ($exifTool, $dirInfo, $tagTablePtr) = @_;
+    my ($et, $dirInfo, $tagTablePtr) = @_;
     my $dataPt = $$dirInfo{DataPt};
     my $start = $$dirInfo{DirStart};
     my $size = $$dirInfo{DirLen};
     return 0 if $size < 4;
-    if ($exifTool->Options('Verbose')) {
-        $exifTool->VerboseDir($$dirInfo{DirName}, 0, $size);
+    if ($et->Options('Verbose')) {
+        $et->VerboseDir($$dirInfo{DirName}, 0, $size);
     }
     my $tag = substr($$dataPt, $start, 4);
-    my $tagInfo = $exifTool->GetTagInfo($tagTablePtr, $tag);
+    my $tagInfo = $et->GetTagInfo($tagTablePtr, $tag);
     unless ($tagInfo) {
-        $tagInfo = $exifTool->GetTagInfo($tagTablePtr, 'unknown');
+        $tagInfo = $et->GetTagInfo($tagTablePtr, 'unknown');
         return 1 unless $tagInfo;
     }
     my $subdir = $$tagInfo{SubDirectory};
@@ -1096,14 +1104,14 @@ sub ProcessStreamData($$$)
         unless ($offset) {
             # allow processing of 2nd directory at the same address
             my $addr = $subdirInfo{DirStart} + $subdirInfo{DataPos} + $subdirInfo{Base};
-            delete $exifTool->{PROCESSED}->{$addr}
+            delete $$et{PROCESSED}{$addr}
         }
         # (we could set FIRST_EXIF_POS to $subdirInfo{Base} here to make
         #  htmlDump offsets relative to EXIF base if we wanted...)
         my $subTable = GetTagTable($$subdir{TagTable});
-        $exifTool->ProcessDirectory(\%subdirInfo, $subTable);
+        $et->ProcessDirectory(\%subdirInfo, $subTable);
     } else {
-        $exifTool->HandleTag($tagTablePtr, $tag, undef,
+        $et->HandleTag($tagTablePtr, $tag, undef,
             DataPt  => $dataPt,
             DataPos => $$dirInfo{DataPos},
             Start   => $start,
@@ -1121,22 +1129,22 @@ sub ProcessStreamData($$$)
 # Returns: 1 on success
 sub ProcessChunks($$$)
 {
-    my ($exifTool, $dirInfo, $tagTablePtr) = @_;
+    my ($et, $dirInfo, $tagTablePtr) = @_;
     my $dataPt = $$dirInfo{DataPt};
     my $start = $$dirInfo{DirStart};
     my $size = $$dirInfo{DirLen};
     my $end = $start + $size;
     my $base = $$dirInfo{Base};
 
-    if ($exifTool->Options('Verbose')) {
-        $exifTool->VerboseDir($$dirInfo{DirName}, 0, $size);
+    if ($et->Options('Verbose')) {
+        $et->VerboseDir($$dirInfo{DirName}, 0, $size);
     }
     while ($start + 8 < $end) {
         my $tag = substr($$dataPt, $start, 4);
         my $len = Get32u($dataPt, $start + 4);
         $start += 8;
         if ($start + $len > $end) {
-            $exifTool->Warn("Bad $tag chunk");
+            $et->Warn("Bad $tag chunk");
             return 0;
         }
         if ($tag eq 'LIST' and $len >= 4) {
@@ -1144,7 +1152,7 @@ sub ProcessChunks($$$)
             $len -= 4;
             $start += 4;
         }
-        my $tagInfo = $exifTool->GetTagInfo($tagTablePtr, $tag);
+        my $tagInfo = $et->GetTagInfo($tagTablePtr, $tag);
         my $baseShift = 0;
         my $val;
         if ($tagInfo) {
@@ -1165,7 +1173,7 @@ sub ProcessChunks($$$)
                 $val =~ s/\0+$//;   # remove trailing nulls from strings
             }
         }
-        $exifTool->HandleTag($tagTablePtr, $tag, $val,
+        $et->HandleTag($tagTablePtr, $tag, $val,
             DataPt  => $dataPt,
             DataPos => $$dirInfo{DataPos} - $baseShift,
             Start   => $start,
@@ -1185,10 +1193,10 @@ sub ProcessChunks($$$)
 # Returns: 1 on success, 0 if this wasn't a valid RIFF file
 sub ProcessRIFF($$)
 {
-    my ($exifTool, $dirInfo) = @_;
+    my ($et, $dirInfo) = @_;
     my $raf = $$dirInfo{RAF};
     my ($buff, $buf2, $type, $mime, $err);
-    my $verbose = $exifTool->Options('Verbose');
+    my $verbose = $et->Options('Verbose');
 
     # verify this is a valid RIFF file
     return 0 unless $raf->Read($buff, 12) == 12;
@@ -1202,8 +1210,8 @@ sub ProcessRIFF($$)
         return 0 unless $buff =~ /WAVE(.{4})?fmt /sg and $raf->Seek(pos($buff) - 4, 0);
     }
     $mime = $riffMimeType{$type} if $type;
-    $exifTool->SetFileType($type, $mime);
-    $$exifTool{RIFFStreamType} = '';    # initialize stream type
+    $et->SetFileType($type, $mime);
+    $$et{RIFFStreamType} = '';    # initialize stream type
     SetByteOrder('II');
     my $tagTablePtr = GetTagTable('Image::ExifTool::RIFF::Main');
     my $pos = 12;
@@ -1225,13 +1233,13 @@ sub ProcessRIFF($$)
             $tag .= "_$buff";
             $len -= 4;  # already read 4 bytes (the LIST type)
         }
-        $exifTool->VPrint(0, "RIFF '$tag' chunk ($len bytes of data):\n");
+        $et->VPrint(0, "RIFF '$tag' chunk ($len bytes of data):\n");
         if ($len <= 0) {
             if ($len < 0) {
-                $exifTool->Warn('Invalid chunk length');
+                $et->Warn('Invalid chunk length');
             } elsif ($tag eq "\0\0\0\0") {
                 # avoid reading through corupted files filled with nulls because it takes forever
-                $exifTool->Warn('Encountered empty null chunk. Processing aborted');
+                $et->Warn('Encountered empty null chunk. Processing aborted');
             } else {
                 next;
             }
@@ -1241,16 +1249,16 @@ sub ProcessRIFF($$)
         # --> no more because Adobe Bridge stores XMP after this!!
         # (so now we only do this on the FastScan option)
         if (($tag eq 'data' or $tag eq 'idx1' or $tag eq 'LIST_movi') and
-            $exifTool->Options('FastScan'))
+            $et->Options('FastScan'))
         {
-            $exifTool->VPrint(0, "(end of parsing)\n");
+            $et->VPrint(0, "(end of parsing)\n");
             last;
         }
         # RIFF chunks are padded to an even number of bytes
         my $len2 = $len + ($len & 0x01);
         if ($$tagTablePtr{$tag} or ($verbose and $tag !~ /^(data|idx1|LIST_movi|RIFF)$/)) {
             $raf->Read($buff, $len2) == $len2 or $err=1, last;
-            $exifTool->HandleTag($tagTablePtr, $tag, $buff,
+            $et->HandleTag($tagTablePtr, $tag, $buff,
                 DataPt  => \$buff,
                 DataPos => 0,   # (relative to Base)
                 Start   => 0,
@@ -1261,14 +1269,14 @@ sub ProcessRIFF($$)
             # don't read into RIFF chunk (ie. concatenated video file)
             $raf->Read($buff, 4) == 4 or $err=1, last;
             # extract information from remaining file as an embedded file
-            $$exifTool{DOC_NUM} = ++$$exifTool{DOC_COUNT}
+            $$et{DOC_NUM} = ++$$et{DOC_COUNT}
         } else {
             $raf->Seek($len2, 1) or $err=1, last;
         }
         $pos += $len2;
     }
-    delete $$exifTool{DOC_NUM};
-    $err and $exifTool->Warn('Error reading RIFF file (corrupted?)');
+    delete $$et{DOC_NUM};
+    $err and $et->Warn('Error reading RIFF file (corrupted?)');
     return 1;
 }
 

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

@@ -14,7 +14,7 @@ use strict;
 use vars qw($VERSION);
 use Image::ExifTool qw(:DataAccess :Utils);
 
-$VERSION = '1.07';
+$VERSION = '1.08';
 
 # Information decoded from Mac OS resources
 %Image::ExifTool::RSRC::Main = (
@@ -62,7 +62,7 @@ $VERSION = '1.07';
 # Returns: 1 on success, 0 if this wasn't a valid resource file
 sub ProcessRSRC($$)
 {
-    my ($exifTool, $dirInfo) = @_;
+    my ($et, $dirInfo) = @_;
     my $raf = $$dirInfo{RAF};
     my ($hdr, $map, $buff, $i, $j);
 
@@ -86,10 +86,10 @@ sub ProcessRSRC($$)
     # validate offsets in the resource map
     return 0 if $typeOff < 28 or $nameOff < 30;
 
-    $exifTool->SetFileType('RSRC') unless $$exifTool{IN_RESOURCE};
-    my $verbose = $exifTool->Options('Verbose');
+    $et->SetFileType('RSRC') unless $$et{IN_RESOURCE};
+    my $verbose = $et->Options('Verbose');
     my $tagTablePtr = GetTagTable('Image::ExifTool::RSRC::Main');
-    $exifTool->VerboseDir('RSRC', $numTypes+1);
+    $et->VerboseDir('RSRC', $numTypes+1);
 
     # parse resource type list
     for ($i=0; $i<=$numTypes; ++$i) {
@@ -120,7 +120,7 @@ sub ProcessRSRC($$)
                         ($valLen = unpack('N', $buff)) < 100000000 and # arbitrary size limit (100MB)
                         $raf->Read($val, $valLen) == $valLen)
                 {
-                    $exifTool->Warn("Error reading $resType resource");
+                    $et->Warn("Error reading $resType resource");
                     next;
                 }
             }
@@ -128,9 +128,9 @@ sub ProcessRSRC($$)
                 my ($resName, $nameLen);
                 $resName = '' unless $raf->Seek($resNameOff, 0) and $raf->Read($buff, 1) and
                     ($nameLen = ord $buff) != 0 and $raf->Read($resName, $nameLen) == $nameLen;
-                $exifTool->VPrint(0,sprintf("%s resource ID 0x%.4x (offset 0x%.4x, $valLen bytes, name='%s'):\n",
+                $et->VPrint(0,sprintf("%s resource ID 0x%.4x (offset 0x%.4x, $valLen bytes, name='%s'):\n",
                     $resType, $id, $resOff, $resName));
-                $exifTool->VerboseDump(\$val);
+                $et->VerboseDump(\$val);
             }
             next unless $tagInfo;
             if ($resType eq 'vers') {
@@ -142,21 +142,21 @@ sub ProcessRSRC($$)
                 my $vlen = Get8u(\$val, $p++);
                 next if $p + $vlen > $valLen;
                 my $tagTablePtr = GetTagTable('Image::ExifTool::RSRC::Main');
-                $val = $exifTool->Decode(substr($val, $p, $vlen), 'MacRoman');
+                $val = $et->Decode(substr($val, $p, $vlen), 'MacRoman');
             } elsif ($resType eq 'sfnt') {
                 # parse the OTF font block
                 $raf->Seek($resOff + 4, 0) or next;
                 $$dirInfo{Base} = $resOff + 4;
                 require Image::ExifTool::Font;
-                unless (Image::ExifTool::Font::ProcessOTF($exifTool, $dirInfo)) {
-                    $exifTool->Warn('Unrecognized sfnt resource format');
+                unless (Image::ExifTool::Font::ProcessOTF($et, $dirInfo)) {
+                    $et->Warn('Unrecognized sfnt resource format');
                 }
                 # assume this is a DFONT file unless processing the rsrc fork
-                $exifTool->OverrideFileType('DFONT') unless $$exifTool{DOC_NUM};
+                $et->OverrideFileType('DFONT') unless $$et{DOC_NUM};
                 next;
             } elsif ($resType eq '8BIM') {
                 my $ttPtr = GetTagTable('Image::ExifTool::Photoshop::Main');
-                $exifTool->HandleTag($ttPtr, $id, $val,
+                $et->HandleTag($ttPtr, $id, $val,
                     DataPt  => \$val,
                     DataPos => $resOff + 4,
                     Size    => $valLen,
@@ -189,12 +189,12 @@ sub ProcessRSRC($$)
                 $val = \@vals;
             } elsif ($resType eq 'POST') {
                 # assume this is a DFONT file unless processing the rsrc fork
-                $exifTool->OverrideFileType('DFONT') unless $$exifTool{DOC_NUM};
+                $et->OverrideFileType('DFONT') unless $$et{DOC_NUM};
                 $val = substr $val, 2;
             } elsif ($resType ne 'TEXT') {
                 next;
             }
-            $exifTool->HandleTag($tagTablePtr, $tag, $val);
+            $et->HandleTag($tagTablePtr, $tag, $val);
         }
     }
     return 1;

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

@@ -15,7 +15,7 @@ use strict;
 use vars qw($VERSION);
 use Image::ExifTool qw(:DataAccess :Utils);
 
-$VERSION = '1.01';
+$VERSION = '1.02';
 
 sub ProcessUserProps($$$);
 
@@ -146,7 +146,7 @@ sub ReadToNested($;$)
 # Returns: Unescaped text (in current ExifTool Charset)
 sub UnescapeRTF($$$)
 {
-    my ($exifTool, $val, $charset) = @_;
+    my ($et, $val, $charset) = @_;
 
     # return now unless we have a control sequence
     unless ($val =~ /\\/) {
@@ -180,7 +180,7 @@ sub UnescapeRTF($$$)
                 $skip = $2;
             } elsif ($1 eq 'u') {   # \uN
                 require Image::ExifTool::Charset;
-                $rtnVal .= Image::ExifTool::Charset::Recompose($exifTool, [$2]);
+                $rtnVal .= Image::ExifTool::Charset::Recompose($et, [$2]);
                 if ($skip) {
                     # must skip the specified number of characters
                     # (not simple because RTF control words count as a single character)
@@ -188,7 +188,7 @@ sub UnescapeRTF($$$)
                 }
             } elsif ($rtfEntity{$1}) {
                 require Image::ExifTool::Charset;
-                $rtnVal .= Image::ExifTool::Charset::Recompose($exifTool, [$rtfEntity{$1}]);
+                $rtnVal .= Image::ExifTool::Charset::Recompose($et, [$rtfEntity{$1}]);
             } # (else ignore the command)
         } else {
             my $ch = substr($val, $p1, 1);
@@ -198,7 +198,7 @@ sub UnescapeRTF($$$)
                 my $hex = substr($val, $p1 + 1, 2);
                 if ($hex =~ /^[0-9a-fA-F]{2}$/) {
                     require Image::ExifTool::Charset;
-                    $rtnVal .= $exifTool->Decode(chr(hex($hex)), $charset);
+                    $rtnVal .= $et->Decode(chr(hex($hex)), $charset);
                 }
                 pos($val) = $p1 + 3;    # skip to after the hex code
             } else {
@@ -220,13 +220,13 @@ sub UnescapeRTF($$$)
 # Returns: 1 on success, 0 if this wasn't a valid RTF file
 sub ProcessRTF($$)
 {
-    my ($exifTool, $dirInfo) = @_;
+    my ($et, $dirInfo) = @_;
     my $raf = $$dirInfo{RAF};
     my ($buff, $buf2, $cs);
     
     return 0 unless $raf->Read($buff, 64) and $raf->Seek(0,0);
     return 0 unless $buff =~ /^[\n\r]*\{[\n\r]*\\rtf[^a-zA-Z]/;
-    $exifTool->SetFileType();
+    $et->SetFileType();
 #
 # determine the RTF character set
 #
@@ -241,12 +241,12 @@ sub ProcessRTF($$)
         );
         $cs = $trans{$1};
     } else {
-        $exifTool->Warn('Unspecified RTF encoding. Will assume Latin');
+        $et->Warn('Unspecified RTF encoding. Will assume Latin');
         $cs = 'Latin';
     }
     my $charset = $Image::ExifTool::charsetName{lc $cs};
     unless ($charset) {
-        $exifTool->Warn("Unsupported RTF encoding $cs. Will assume Latin.");
+        $et->Warn("Unsupported RTF encoding $cs. Will assume Latin.");
         $charset = 'Latin';
     }
     my $tagTablePtr = GetTagTable('Image::ExifTool::RTF::Main');
@@ -267,7 +267,7 @@ sub ProcessRTF($$)
         pos($buff) = pos($buff) - 1 if $1 ne ' ';
         my $info = ReadToNested(\$buff, $raf);
         unless (defined $info) {
-            $exifTool->Warn('Unterminated information group');
+            $et->Warn('Unterminated information group');
             last;
         }
         # process info commands (ie. "\author", "\*\copyright");
@@ -288,13 +288,13 @@ sub ProcessRTF($$)
                 $val = sprintf("%.4d:%.2d:%.2d %.2d:%.2d:%.2d", @t);
             } else {
                 # unescape RTF string value
-                $val = UnescapeRTF($exifTool, $val, $charset);
+                $val = UnescapeRTF($et, $val, $charset);
             }
             # create tagInfo for unknown tags
             if (not $tagInfo) {
                 AddTagToTable($tagTablePtr, $tag, { Name => ucfirst($tag) });
             }
-            $exifTool->HandleTag($tagTablePtr, $tag, $val);
+            $et->HandleTag($tagTablePtr, $tag, $val);
         }
     }
     return 1 unless defined $buff;
@@ -309,7 +309,7 @@ sub ProcessRTF($$)
         my $props = ReadToNested(\$buff, $raf);
         $tagTablePtr = Image::ExifTool::GetTagTable('Image::ExifTool::RTF::UserProps');
         unless (defined $props) {
-            $exifTool->Warn('Unterminated user properties');
+            $et->Warn('Unterminated user properties');
             last;
         }
         # process user properties
@@ -319,7 +319,7 @@ sub ProcessRTF($$)
             my $t = $2;
             my $val = ReadToNested(\$props);
             last unless defined $val;
-            $val = UnescapeRTF($exifTool, $val, $charset);
+            $val = UnescapeRTF($et, $val, $charset);
             if ($t eq 'propname') {
                 $tag = $val;
                 next;
@@ -333,7 +333,7 @@ sub ProcessRTF($$)
             unless ($$tagTablePtr{$tag}) {
                 AddTagToTable($tagTablePtr, $tag, { Name => $tag });
             }
-            $exifTool->HandleTag($tagTablePtr, $tag, $val);
+            $et->HandleTag($tagTablePtr, $tag, $val);
         }
         last;   # (didn't really want to loop)
     }