exiftool_vendored 12.62.0 → 12.64.0

data/bin/lib/Image/ExifTool/Writer.pl

@@ -139,7 +139,7 @@ my @delGroups = qw(
     Adobe AFCP APP0 APP1 APP2 APP3 APP4 APP5 APP6 APP7 APP8 APP9 APP10 APP11
     APP12 APP13 APP14 APP15 CanonVRD CIFF Ducky EXIF ExifIFD File FlashPix
     FotoStation GlobParamIFD GPS ICC_Profile IFD0 IFD1 Insta360 InteropIFD IPTC
-    ItemList JFIF Jpeg2000 Keys MakerNotes Meta MetaIFD Microsoft MIE MPF
+    ItemList JFIF Jpeg2000 JUMBF Keys MakerNotes Meta MetaIFD Microsoft MIE MPF
     NikonApp NikonCapture PDF PDF-update PhotoMechanic Photoshop PNG PNG-pHYs
     PrintIM QuickTime RMETA RSRC SubIFD Trailer UserData XML XML-* XMP XMP-*
 );
@@ -1028,7 +1028,7 @@ TAG: foreach $tagInfo (@matchingTags) {
                         foreach (@vals) {
                             if (ref $_ eq 'HASH') {
                                 require 'Image/ExifTool/XMPStruct.pl';
-                                $_ = Image::ExifTool::XMP::SerializeStruct($_);
+                                $_ = Image::ExifTool::XMP::SerializeStruct($self, $_);
                             }
                             print $out "$$self{INDENT2}$verb $wgrp1:$tag$fromList if value is '${_}'\n";
                         }
@@ -1293,6 +1293,7 @@ sub SetNewValuesFromFile($$;@)
         HexTagIDs       => $$options{HexTagIDs},
         IgnoreMinorErrors=>$$options{IgnoreMinorErrors},
         IgnoreTags      => $$options{IgnoreTags},
+        ImageHashType   => $$options{ImageHashType},
         Lang            => $$options{Lang},
         LargeFileSupport=> $$options{LargeFileSupport},
         List            => 1,
@@ -1313,6 +1314,7 @@ sub SetNewValuesFromFile($$;@)
         ScanForXMP      => $$options{ScanForXMP},
         StrictDate      => defined $$options{StrictDate} ? $$options{StrictDate} : 1,
         Struct          => $structOpt,
+        StructFormat    => $$options{StructFormat},
         SystemTags      => $$options{SystemTags},
         TimeZone        => $$options{TimeZone},
         Unknown         => $$options{Unknown},
@@ -1763,7 +1765,14 @@ GNV_TagInfo:    foreach $tagInfo (@tagInfoList) {
         }
     }
     # return our value(s)
-    return @$vals if wantarray;
+    if (wantarray) {
+        # remove duplicates if requested
+        if (@$vals > 1 and $self->Options('NoDups')) {
+            my %seen;
+            @$vals = grep { !$seen{$_}++ } @$vals;
+        }
+        return @$vals;
+    }
     return $$vals[0];
 }
 
@@ -3283,7 +3292,7 @@ sub InsertTagValues($$$;$$$)
                 }
             } elsif (ref $val eq 'HASH') {
                 require 'Image/ExifTool/XMPStruct.pl';
-                $val = Image::ExifTool::XMP::SerializeStruct($val);
+                $val = Image::ExifTool::XMP::SerializeStruct($self, $val);
             } elsif (not defined $val) {
                 $val = $$self{OPTIONS}{MissingTagValue} if $asList;
             }
@@ -3767,6 +3776,8 @@ sub GetNewValueHash($$;$$$$)
         # this is a bit tricky:  we want to add to a protected nvHash only if we
         # are adding a conditional delete ($_[5] true or DelValue with no Shift)
         # or accumulating List items (NoReplace true)
+        # (NOTE: this should be looked into --> lists may be accumulated instead of being replaced
+        # as expected when copying to the same list from different dynamic -tagsFromFile source files)
         if ($protect and not ($opts{create} and ($$nvHash{NoReplace} or $_[5] or
             ($$nvHash{DelValue} and not defined $$nvHash{Shift}))))
         {
@@ -5598,6 +5609,8 @@ sub WriteJPEG($$)
                     $s =~ /^(Meta|META|Exif)\0\0/ and $dirName = 'Meta';
                 } elsif ($marker == 0xe5) {
                     $s =~ /^RMETA\0/        and $dirName = 'RMETA';
+                } elsif ($marker == 0xeb) {
+                    $s =~ /^JP/             and $dirName = 'JUMBF';
                 } elsif ($marker == 0xec) {
                     $s =~ /^Ducky/          and $dirName = 'Ducky';
                 } elsif ($marker == 0xed) {
@@ -6463,6 +6476,11 @@ sub WriteJPEG($$)
                     $segType = 'Ricoh RMETA';
                     $$delGroup{RMETA} and $del = 1;
                 }
+            } elsif ($marker == 0xeb) {         # APP10 (JUMBF)
+                if ($$segDataPt =~ /^JP/) {
+                    $segType = 'JUMBF';
+                    $$delGroup{JUMBF} and $del = 1;
+                }
             } elsif ($marker == 0xec) {         # APP12 (Ducky)
                 if ($$segDataPt =~ /^Ducky/) {
                     $segType = 'Ducky';
@@ -6880,14 +6898,14 @@ sub SetFileTime($$;$$$$)
 }
 
 #------------------------------------------------------------------------------
-# Add data to MD5 checksum
+# Add data to hash checksum
 # Inputs: 0) ExifTool ref, 1) RAF ref, 2) data size (or undef to read to end of file),
 #         3) data name (or undef for no warnings or messages), 4) flag for no verbose message
-# Returns: number of bytes read and MD5'd
-sub ImageDataMD5($$$;$$)
+# Returns: number of bytes read and hashed
+sub ImageDataHash($$$;$$)
 {
     my ($self, $raf, $size, $type, $noMsg) = @_;
-    my $md5 = $$self{ImageDataMD5} or return;
+    my $hash = $$self{ImageDataHash} or return;
     my ($bytesRead, $n) = (0, 65536);
     my $buff;
     for (;;) {
@@ -6900,11 +6918,11 @@ sub ImageDataMD5($$$;$$)
             $self->Warn("Error reading $type data") if $type and defined $size;
             last;
         }
-        $md5->add($buff);
+        $hash->add($buff);
         $bytesRead += length $buff;
     }
     if ($$self{OPTIONS}{Verbose} and $bytesRead and $type and not $noMsg) {
-        $self->VPrint(0, "$$self{INDENT}(ImageDataMD5: $bytesRead bytes of $type data)\n");
+        $self->VPrint(0, "$$self{INDENT}(ImageDataHash: $bytesRead bytes of $type data)\n");
     }
     return $bytesRead;
 }

data/bin/lib/Image/ExifTool/XMP.pm

@@ -50,7 +50,7 @@ use Image::ExifTool::Exif;
 use Image::ExifTool::GPS;
 require Exporter;
 
-$VERSION = '3.59';
+$VERSION = '3.60';
 @ISA = qw(Exporter);
 @EXPORT_OK = qw(EscapeXML UnescapeXML);
 
@@ -144,6 +144,7 @@ my %xmpNS = (
     xmpTPg    => 'http://ns.adobe.com/xap/1.0/t/pg/',
     xmpidq    => 'http://ns.adobe.com/xmp/Identifier/qual/1.0/',
     xmpPLUS   => 'http://ns.adobe.com/xap/1.0/PLUS/',
+    panorama  => 'http://ns.adobe.com/photoshop/1.0/panorama-profile',
     dex       => 'http://ns.optimasc.com/dex/1.0/',
     mediapro  => 'http://ns.iview-multimedia.com/mediapro/1.0/',
     expressionmedia => 'http://ns.microsoft.com/expressionmedia/1.0/',
@@ -199,6 +200,7 @@ my %xmpNS = (
     ast       => 'http://ns.nikon.com/asteroid/1.0/',
     nine      => 'http://ns.nikon.com/nine/1.0/',
     hdr_metadata => 'http://ns.adobe.com/hdr-metadata/1.0/',
+    hdrgm     => 'http://ns.adobe.com/hdr-gain-map/1.0/',
 );
 
 # build reverse namespace lookup
@@ -709,6 +711,10 @@ my %sRangeMask = (
         Name => 'xmpPLUS',
         SubDirectory => { TagTable => 'Image::ExifTool::XMP::xmpPLUS' },
     },
+    panorama => {
+        Name => 'panorama',
+        SubDirectory => { TagTable => 'Image::ExifTool::XMP::panorama' },
+    },
     plus => {
         Name => 'plus',
         SubDirectory => { TagTable => 'Image::ExifTool::PLUS::XMP' },
@@ -909,6 +915,10 @@ my %sRangeMask = (
         Name => 'hdr',
         SubDirectory => { TagTable => 'Image::ExifTool::XMP::hdr' },
     },
+    hdrgm => {
+        Name => 'hdrgm',
+        SubDirectory => { TagTable => 'Image::ExifTool::XMP::hdrgm' },
+    },
 );
 
 # hack to allow XML containing Dublin Core metadata to be handled like XMP (eg. EPUB - see ZIP.pm)
@@ -2566,7 +2576,9 @@ my %sPantryItem = (
     %xmpTableDefaults,
     GROUPS => { 1 => 'XMP-et', 2 => 'Image' },
     NAMESPACE   => 'et',
-    OriginalImageMD5 => { Notes => 'used to store ExifTool ImageDataMD5 digest' },
+    OriginalImageHash     => { Notes => 'used to store ExifTool ImageDataHash digest' },
+    OriginalImageHashType => { Notes => "ImageHashType API setting, default 'MD5'" },
+    OriginalImageMD5      => { Notes => 'deprecated' },
 );
 
 # table to add tags in other namespaces

data/bin/lib/Image/ExifTool/XMP2.pl

@@ -1388,6 +1388,17 @@ my %sSubVersion = (
     ReuseAllowed    => { Writable => 'boolean' },
 );
 
+%Image::ExifTool::XMP::panorama = (
+    %xmpTableDefaults,
+    GROUPS => { 1 => 'XMP-panorama', 2 => 'Image' },
+    NAMESPACE => 'panorama',
+    NOTES => 'Adobe Photoshop Panorama-profile tags.',
+    Transformation      => { },
+    VirtualFocalLength  => { Writable => 'real' },
+    VirtualImageXCenter => { Writable => 'real' },
+    VirtualImageYCenter => { Writable => 'real' },
+);
+
 # Creative Commons namespace properties (cc) (ref 5)
 %Image::ExifTool::XMP::cc = (
     %xmpTableDefaults,
@@ -2094,6 +2105,27 @@ my %sSubVersion = (
     scene_referred          => { Name => 'SceneReferred', Writable => 'boolean' },
 );
 
+# HDR Gain Map metadata namespace
+%Image::ExifTool::XMP::hdrgm = (
+    %xmpTableDefaults,
+    GROUPS => { 1 => 'XMP-hdrgm', 2 => 'Image' },
+    NAMESPACE   => 'hdrgm',
+    TABLE_DESC => 'XMP HDR Gain Map Metadata',
+    NOTES => 'Tags used in Adobe gain map images.',
+    Version             => { Avoid => 1 },
+    BaseRenditionIsHDR  => { Writable => 'boolean' },
+    # this is a pain in the ass: List items below may or may not be lists
+    # according to the Adobe specification -- I don't know how to handle tags
+    # with a variable format like this, so just make them lists here for now
+    OffsetSDR           => { Writable => 'real', List => 'Seq' },
+    OffsetHDR           => { Writable => 'real', List => 'Seq' },
+    HDRCapacityMin      => { Writable => 'real' },
+    HDRCapacityMax      => { Writable => 'real' },
+    GainMapMin          => { Writable => 'real', List => 'Seq' },
+    GainMapMax          => { Writable => 'real', List => 'Seq' },
+    Gamma               => { Writable => 'real', List => 'Seq', Avoid => 1 },
+);
+
 # SVG namespace properties (ref 9)
 %Image::ExifTool::XMP::SVG = (
     GROUPS => { 0 => 'SVG', 1 => 'SVG', 2 => 'Image' },

data/bin/lib/Image/ExifTool/XMPStruct.pl

@@ -14,42 +14,55 @@ use vars qw(%specialStruct %stdXlatNS);
 use Image::ExifTool qw(:Utils);
 use Image::ExifTool::XMP;
 
-sub SerializeStruct($;$);
-sub InflateStruct($;$);
+sub SerializeStruct($$;$);
+sub InflateStruct($$;$);
 sub DumpStruct($;$);
 sub CheckStruct($$$);
 sub AddNewStruct($$$$$$);
 sub ConvertStruct($$$$;$);
+sub EscapeJSON($;$);
+
+# lookups for JSON characters that we escape specially
+my %jsonChar = ( '"'=>'"', '\\'=>'\\', "\b"=>'b', "\f"=>'f', "\n"=>'n', "\r"=>'r', "\t"=>'t' );
+my %jsonEsc  = ( '"'=>'"', '\\'=>'\\', 'b'=>"\b", 'f'=>"\f", 'n'=>"\n", 'r'=>"\r", 't'=>"\t" );
 
 #------------------------------------------------------------------------------
 # Serialize a structure (or other object) into a simple string
-# Inputs: 0) HASH ref, ARRAY ref, or SCALAR, 1) closing bracket (or undef)
-# Returns: serialized structure string
+# Inputs: 0) ExifTool ref, 1) HASH ref, ARRAY ref, or SCALAR, 2) closing bracket (or undef)
+# Returns: serialized structure string (in format specified by StructFormat option)
 # eg) "{field=text with {braces|}|, and a comma, field2=val2,field3={field4=[a,b]}}"
-sub SerializeStruct($;$)
+sub SerializeStruct($$;$)
 {
-    my ($obj, $ket) = @_;
+    my ($et, $obj, $ket) = @_;
     my ($key, $val, @vals, $rtnVal);
+    my $sfmt = $et->Options('StructFormat');
 
     if (ref $obj eq 'HASH') {
         # support hashes with ordered keys
         my @keys = $$obj{_ordered_keys_} ? @{$$obj{_ordered_keys_}} : sort keys %$obj;
         foreach $key (@keys) {
-            push @vals, $key . '=' . SerializeStruct($$obj{$key}, '}');
+            my $hdr = $sfmt ? EscapeJSON($key) . ':' : $key . '=';
+            push @vals, $hdr . SerializeStruct($et, $$obj{$key}, '}');
         }
         $rtnVal = '{' . join(',', @vals) . '}';
     } elsif (ref $obj eq 'ARRAY') {
         foreach $val (@$obj) {
-            push @vals, SerializeStruct($val, ']');
+            push @vals, SerializeStruct($et, $val, ']');
         }
         $rtnVal = '[' . join(',', @vals) . ']';
     } elsif (defined $obj) {
         $obj = $$obj if ref $obj eq 'SCALAR';
         # escape necessary characters in string (closing bracket plus "," and "|")
-        my $pat = $ket ? "\\$ket|,|\\|" : ',|\\|';
-        ($rtnVal = $obj) =~  s/($pat)/|$1/g;
-        # also must escape opening bracket or whitespace at start of string
-        $rtnVal =~ s/^([\s\[\{])/|$1/;
+        if ($sfmt) {
+            $rtnVal = EscapeJSON($obj, $sfmt eq 'JSONQ');
+        } else {
+            my $pat = $ket ? "\\$ket|,|\\|" : ',|\\|';
+            ($rtnVal = $obj) =~  s/($pat)/|$1/g;
+            # also must escape opening bracket or whitespace at start of string
+            $rtnVal =~ s/^([\s\[\{])/|$1/;
+        }
+    } elsif ($sfmt) {
+        $rtnVal = 'null';
     } else {
         $rtnVal = '';   # allow undefined list items
     }
@@ -58,21 +71,25 @@ sub SerializeStruct($;$)
 
 #------------------------------------------------------------------------------
 # Inflate structure (or other object) from a serialized string
-# Inputs: 0) reference to object in string form (serialized using the '|' escape)
-#         1) extra delimiter for scalar values delimiters
+# Inputs: 0) ExifTool ref, 1) reference to object in string form
+#           (serialized using the '|' escape, or JSON)
+#         2) extra delimiter for scalar values delimiters
 # Returns: 0) object as a SCALAR, HASH ref, or ARRAY ref (or undef on error),
 #          1) warning string (or undef)
 # Notes: modifies input string to remove parsed objects
-sub InflateStruct($;$)
+sub InflateStruct($$;$)
 {
-    my ($obj, $delim) = @_;
+    my ($et, $obj, $delim) = @_;
     my ($val, $warn, $part);
+    my $sfmt = $et->Options('StructFormat');
 
     if ($$obj =~ s/^\s*\{//) {
         my %struct;
-        while ($$obj =~ s/^\s*([-\w:]+#?)\s*=//s) {
+        for (;;) {
+            last unless $sfmt ? $$obj =~ s/^\s*"(.*?)"\s*://s :
+                                $$obj =~ s/^\s*([-\w:]+#?)\s*=//s;
             my $tag = $1;
-            my ($v, $w) = InflateStruct($obj, '}');
+            my ($v, $w) = InflateStruct($et, $obj, '}');
             $warn = $w if $w and not $warn;
             return(undef, $warn) unless defined $v;
             $struct{$tag} = $v;
@@ -94,7 +111,7 @@ sub InflateStruct($;$)
     } elsif ($$obj =~ s/^\s*\[//) {
         my @list;
         for (;;) {
-            my ($v, $w) = InflateStruct($obj, ']');
+            my ($v, $w) = InflateStruct($et, $obj, ']');
             $warn = $w if $w and not $warn;
             return(undef, $warn) unless defined $v;
             push @list, $v;
@@ -105,20 +122,71 @@ sub InflateStruct($;$)
         $val = \@list;
     } else {
         $$obj =~ s/^\s+//s; # remove leading whitespace
-        # read scalar up to specified delimiter (or "," if not defined)
-        $val = '';
-        $delim = $delim ? "\\$delim|,|\\||\$" : ',|\\||$';
-        for (;;) {
-            $$obj =~ s/^(.*?)($delim)//s or last;
-            $val .= $1;
-            last unless $2;
-            $2 eq '|' or $$obj = $2 . $$obj, last;
-            $$obj =~ s/^(.)//s and $val .= $1;  # add escaped character
+        if ($sfmt) {
+            if ($$obj =~ s/^"//) {
+                $val = '';
+                while ($$obj =~ s/(.*?)"//) {
+                    $val .= $1;
+                    last unless $val =~ /([\\]+)$/ and length($1) & 0x01;
+                    substr($val, -1, 1) = '"';  # (was an escaped quote)
+                }
+                if ($val =~ s/^base64://) {
+                    $val = DecodeBase64($val);
+                } else {
+                    # un-escape characters in JSON string
+                    $val =~ s/\\(.)/$jsonEsc{$1}||'\\'.$1/egs;
+                }
+            } elsif ($$obj =~ s/^(true|false)\b//) {
+                $val = '"' . ucfirst($1) . '"';
+            } elsif ($$obj =~ s/^([+-]?(?=\d|\.\d)\d*(\.\d*)?([Ee]([+-]?\d+))?)//) {
+                $val = $1;
+            } else {
+                $warn or $warn = 'Unknown JSON object';
+                $val = '""';
+            }
+        } else {
+            # read scalar up to specified delimiter (or "," if not defined)
+            $delim = $delim ? "\\$delim|,|\\||\$" : ',|\\||$';
+            $val = '';
+            for (;;) {
+                $$obj =~ s/^(.*?)($delim)//s or last;
+                $val .= $1;
+                last unless $2;
+                $2 eq '|' or $$obj = $2 . $$obj, last;
+                $$obj =~ s/^(.)//s and $val .= $1;  # add escaped character
+            }
         }
     }
     return($val, $warn);
 }
 
+#------------------------------------------------------------------------------
+# Escape string for JSON
+# Inputs: 0) string, 1) flag to force numbers to be quoted too
+# Returns: Escaped string (quoted if necessary)
+sub EscapeJSON($;$)
+{
+    my ($str, $quote) = @_;
+    unless ($quote) {
+        return 'null' unless defined $str;
+        # JSON boolean (true or false)
+        return lc($str) if $str =~ /^(true|false)$/i;
+        # JSON number (see json.org for numerical format)
+        # return $str if $str =~ /^-?(\d|[1-9]\d+)(\.\d+)?(e[-+]?\d+)?$/i;
+        # (these big numbers caused problems for some JSON parsers, so be more conservative)
+        return $str if $str =~ /^-?(\d|[1-9]\d{1,14})(\.\d{1,16})?(e[-+]?\d{1,3})?$/i;
+    }
+    return '""' unless defined $str;
+    # encode JSON string in base64 if necessary
+    return '"base64:' . EncodeBase64($str, 1) . '"' if Image::ExifTool::IsUTF8(\$str) < 0;
+    # escape special characters
+    $str =~ s/(["\t\n\r\\])/\\$jsonChar{$1}/sg;
+    $str =~ tr/\0//d;   # remove all nulls
+    # escape other control characters with \u
+    $str =~ s/([\0-\x1f])/sprintf("\\u%.4X",ord $1)/sge;
+    return '"' . $str . '"';    # return the quoted string
+}
+
 #------------------------------------------------------------------------------
 # Get XMP language code from tag name string
 # Inputs: 0) tag name string

data/bin/lib/Image/ExifTool/ZIP.pm

@@ -20,7 +20,7 @@ use strict;
 use vars qw($VERSION $warnString);
 use Image::ExifTool qw(:DataAccess :Utils);
 
-$VERSION = '1.29';
+$VERSION = '1.30';
 
 sub WarnProc($) { $warnString = $_[0]; }
 
@@ -259,8 +259,8 @@ my %iWorkType = (
 %Image::ExifTool::ZIP::RAR5 = (
     GROUPS => { 2 => 'Other' },
     VARS => { NO_ID => 1 },
-    NOTES => 'These tags are extracted from RAR v5 archive files.',
-    RARVersion      => { },
+    NOTES => 'These tags are extracted from RAR v5 and 7z archive files.',
+    FileVersion     => { },
     CompressedSize  => { },
     ModifyDate => {
         Groups => { 2 => 'Time' },
@@ -310,7 +310,7 @@ sub ProcessRAR($$)
         $et->SetFileType();
         SetByteOrder('II');
         my $tagTablePtr = GetTagTable('Image::ExifTool::ZIP::RAR5');
-        $et->HandleTag($tagTablePtr, 'RARVersion', 4);
+        $et->HandleTag($tagTablePtr, 'FileVersion', 'RAR v4');
         $tagTablePtr = GetTagTable('Image::ExifTool::ZIP::RAR');
 
         for (;;) {
@@ -356,7 +356,7 @@ sub ProcessRAR($$)
         return 0 unless $raf->Read($buff, 1) and $buff eq "\0";
         $et->SetFileType();
         my $tagTablePtr = GetTagTable('Image::ExifTool::ZIP::RAR5');
-        $et->HandleTag($tagTablePtr, 'RARVersion', 5);
+        $et->HandleTag($tagTablePtr, 'FileVersion', 'RAR v5');
         $$et{INDENT} .= '| ';
 
         # loop through header blocks