exiftool_vendored 9.71.0 → 9.78.0

data/bin/{Image-ExifTool-9.71 → Image-ExifTool-9.78}/lib/Image/ExifTool/Torrent.pm

@@ -14,7 +14,7 @@ use strict;
 use vars qw($VERSION);
 use Image::ExifTool qw(:DataAccess :Utils);
 
-$VERSION = '1.02';
+$VERSION = '1.03';
 
 sub ReadBencode($$);
 sub ExtractTags($$$;$$@);
@@ -269,7 +269,7 @@ sub ProcessTorrent($$)
     my $err = $$raf{BencodeError};
     $et->Warn("Bencode error: $err") if $err;
     if (ref $dict eq 'HASH' and $$dict{announce}) {
-        $et->SetFileType('TORRENT');
+        $et->SetFileType();
         my $tagTablePtr = GetTagTable('Image::ExifTool::Torrent::Main');
         ExtractTags($et, $dict, $tagTablePtr) and $success = 1;
     }

data/bin/{Image-ExifTool-9.71 → Image-ExifTool-9.78}/lib/Image/ExifTool/WriteExif.pl

@@ -1148,7 +1148,7 @@ my %writeTable = (
         Protected => 1,
     },
     0xc7a5 => {             # BaselineExposureOffset
-        Writable => 'rational64u',
+        Writable => 'rational64s', # (incorrectly "RATIONAL" in DNG 1.4 spec)
         WriteGroup => 'IFD0',
         Protected => 1,
     },
@@ -3180,9 +3180,15 @@ NoOverwrite:            next if $isNew > 0;
             $entryBasedFixup->ApplyFixup(\$dirBuff);
             undef $entryBasedFixup;
         }
+        # initialize next IFD pointer to zero
+        my $nextIFD = Set32u(0);
+        # some cameras use a different amount of padding after the makernote IFD
+        if ($dirName eq 'MakerNotes' and $$dirInfo{Parent} =~ /^(ExifIFD|IFD0)$/) {
+            my ($rel, $pad) = Image::ExifTool::MakerNotes::GetMakerNoteOffset($et);
+            $nextIFD = "\0" x $pad if defined $pad and ($pad==0 or ($pad>4 and $pad<=32));
+        }
         # add directory entry count to start of IFD and next IFD pointer to end
-        # (temporarily set next IFD pointer to zero)
-        $newData .= Set16u($newEntries) . $dirBuff . Set32u(0);
+        $newData .= Set16u($newEntries) . $dirBuff . $nextIFD;
         # get position of value data in newData
         my $valPos = length($newData);
         # go back now and set next IFD pointer if this isn't the first IFD
@@ -3192,7 +3198,7 @@ NoOverwrite:            next if $isNew > 0;
             $fixup->AddFixup($nextIfdPos,'NextIFD');    # add fixup for this offset in newData
         }
         # remember position of 'next IFD' pointer so we can set it next time around
-        $nextIfdPos = $valPos - 4;
+        $nextIfdPos = length($nextIFD) ? $valPos - length($nextIFD) : undef;
         # add value data after IFD
         $newData .= $valBuff;
 #

data/bin/{Image-ExifTool-9.71 → Image-ExifTool-9.78}/lib/Image/ExifTool/WriteQuickTime.pl

@@ -18,8 +18,7 @@ my %movMap = (
 );
 my %mp4Map = (
     # MP4 ('ftyp' compatible brand 'mp41', 'mp42' or 'f4v ') -> top level 'uuid'
-   'UUID-XMP' => 'MOV',
-    XMP       => 'UUID-XMP',
+    XMP => 'MOV',
 );
 my %dirMap = (
     MOV => \%movMap,
@@ -41,7 +40,7 @@ sub IsCurPath($$)
 #------------------------------------------------------------------------------
 # Write a series of QuickTime atoms from file or in memory
 # Inputs: 0) ExifTool ref, 1) dirInfo ref, 2) tag table ref
-# Returns: A) if dirInfo contains DataPt: new director data
+# Returns: A) if dirInfo contains DataPt: new directory data
 #          B) otherwise: true on success, 0 if a write error occurred
 #             (true but sets an Error on a file format error)
 sub WriteQuickTime($$$)
@@ -146,9 +145,13 @@ sub WriteQuickTime($$$)
                 my $start = $$subdir{Start} || 0;
                 my $base = ($$dirInfo{Base} || 0) + $raf->Tell() - $size;
                 my $dPos = 0;
+                my $hdrLen = $start;
                 if ($$subdir{Base}) {
-                    $dPos -= eval $$subdir{Base};
+                    my $localBase = eval $$subdir{Base};
+                    $dPos -= $localBase;
                     $base -= $dPos;
+                    # get length of header before base offset
+                    $hdrLen -= $localBase if $localBase <= $hdrLen;
                 }
                 my %subdirInfo = (
                     Parent   => $dirName,
@@ -163,6 +166,12 @@ sub WriteQuickTime($$$)
                     Multi    => $$subdir{Multi},    # necessary?
                     OutFile  => $outfile,
                 );
+                # pass the header pointer if necessary (for EXIF IFD's
+                # where the Base offset is at the end of the header)
+                if ($hdrLen and $hdrLen < $size) {
+                    my $header = substr($buff,0,$hdrLen);
+                    $subdirInfo{HeaderPtr} = \$header;
+                }
                 SetByteOrder('II') if $$subdir{ByteOrder} and $$subdir{ByteOrder} =~ /^Little/;
                 my $oldWriteGroup = $$et{CUR_WRITE_GROUP};
                 if ($subName eq 'Track') {
@@ -172,17 +181,19 @@ sub WriteQuickTime($$$)
                 my $subTable = GetTagTable($$subdir{TagTable});
                 # demote non-QuickTime errors to warnings
                 $$et{DemoteErrors} = 1 unless $$subTable{GROUPS}{0} eq 'QuickTime';
+                my $oldChanged = $$et{CHANGED};
                 $newData = $et->WriteDirectory(\%subdirInfo, $subTable);
                 if ($$et{DemoteErrors}) {
                     # just copy existing subdirectory a non-quicktime error occurred
-                    undef $newData if $$et{DemoteErrors} > 1;
+                    $$et{CHANGED} = $oldChanged if $$et{DemoteErrors} > 1;
                     delete $$et{DemoteErrors};
                 }
+                undef $newData if $$et{CHANGED} == $oldChanged; # don't change unless necessary
                 $$et{CUR_WRITE_GROUP} = $oldWriteGroup;
                 SetByteOrder('MM');
                 # add back header if necessary
-                if ($$subdir{Start} and defined $newData and length $newData) {
-                    $newData = substr($buff,0,$$subdir{Start}) . $newData;
+                if ($start and defined $newData and length $newData) {
+                    $newData = substr($buff,0,$start) . $newData;
                 }
                 # the directory exists, so we don't need to add it
                 delete $$addDirs{$subName} if IsCurPath($et, $subName);
@@ -191,7 +202,7 @@ sub WriteQuickTime($$$)
                 # (this is such a can of worms, so don't implement this for now)
             }
             if (defined $newData) {
-                my $len = length $newData or next;
+                my $len = length $newData;
                 $len > 0x7ffffff7 and $et->Error("$tag to large to write"), last;
                 if ($len == $size or $dataPt or $foundMDAT) {
                     # write the updated directory now
@@ -201,12 +212,15 @@ sub WriteQuickTime($$$)
                     # bad things happen if 'mdat' atom is moved (eg. Adobe Bridge crashes --
                     # there must be some absolute offsets somewhere that point into mdat),
                     # so hold this atom and write it out later
-                    push @hold, Set32u($len+8), $tag, $newData;
-                    $et->VPrint(0,"  Moving '$tag' atom to after 'mdat'");
+                    if ($len) {
+                        push @hold, Set32u($len+8), $tag, $newData;
+                        $et->VPrint(0,"  Moving '$tag' atom to after 'mdat'");
+                    } else {
+                        $et->VPrint(0,"  Freeing '$tag' atom (and zeroing data)");
+                    }
                     # write a 'free' atom here to keep 'mdat' at the same offset
                     substr($hdr, 4, 4) = 'free';
-                    # could zero out old data if we wanted...
-                    # $buff = "\0" x length($buff);
+                    $buff = "\0" x length($buff);   # zero out old data
                 }
             }
             # write out the existing atom (or 'free' padding)

data/bin/{Image-ExifTool-9.71 → Image-ExifTool-9.78}/lib/Image/ExifTool/WriteXMP.pl

@@ -743,11 +743,19 @@ sub WriteXMP($$;$)
 # add, delete or change information as specified
 #
     # get hash of all information we want to change
-    # (sorted by tag name so alternate languages come last)
-    my @tagInfoList = sort ByTagName $et->GetNewTagInfoList();
-    foreach $tagInfo (@tagInfoList) {
+    # (sorted by tag name so alternate languages come last, but with structures
+    # first so flattened tags may be used to override individual structure elements)
+    my @tagInfoList;
+    foreach $tagInfo (sort ByTagName $et->GetNewTagInfoList()) {
         next unless $et->GetGroup($tagInfo, 0) eq 'XMP';
         next if $$tagInfo{Name} eq 'XMP'; # (ignore full XMP block if we didn't write it already)
+        if ($$tagInfo{Struct}) {
+            unshift @tagInfoList, $tagInfo;
+        } else {
+            push @tagInfoList, $tagInfo;
+        }
+    }
+    foreach $tagInfo (@tagInfoList) {
         my $tag = $$tagInfo{TagID};
         my $path = GetPropertyPath($tagInfo);
         unless ($path) {

data/bin/{Image-ExifTool-9.71 → Image-ExifTool-9.78}/lib/Image/ExifTool/Writer.pl

@@ -1591,13 +1591,14 @@ sub RestoreNewValues($)
 #------------------------------------------------------------------------------
 # Set filesystem time from from FileModifyDate or FileCreateDate tag
 # Inputs: 0) ExifTool object reference, 1) file name or file ref
-#         2) modify time (-M) of original file (needed for time shift)
+#         2) time (-M or -C) of original file (used for shift; obtained from file if not given)
 #         3) tag name to write (undef for 'FileModifyDate')
+#         4) flag set if argument 2 has already been converted to Unix seconds
 # Returns: 1=time changed OK, 0=nothing done, -1=error setting time
 #          (and increments CHANGED flag if time was changed)
-sub SetFileModifyDate($$;$$)
+sub SetFileModifyDate($$;$$$)
 {
-    my ($self, $file, $originalTime, $tag) = @_;
+    my ($self, $file, $originalTime, $tag, $isUnixTime) = @_;
     my ($nvHash, $err);
     $tag = 'FileModifyDate' unless defined $tag;
     my $val = $self->GetNewValues($tag, \$nvHash);
@@ -1610,9 +1611,11 @@ sub SetFileModifyDate($$;$$)
         # use original time of this file if not specified
         unless (defined $originalTime) {
             $originalTime = ($tag eq 'FileCreateDate') ? -C $file : -M $file;
+            return 0 unless defined $originalTime;
+            undef $isUnixTime;
         }
-        return 0 unless defined $originalTime;
-        return 0 unless $self->IsOverwriting($nvHash, int($^T - $originalTime*(24*3600) + 0.5));
+        $originalTime = int($^T - $originalTime*(24*3600) + 0.5) unless $isUnixTime;
+        return 0 unless $self->IsOverwriting($nvHash, $originalTime);
         $val = $$nvHash{Value}[0]; # get shifted value
     }
     if ($tag eq 'FileCreateDate') {

data/bin/{Image-ExifTool-9.71 → Image-ExifTool-9.78}/lib/Image/ExifTool/XMP.pm

@@ -47,7 +47,7 @@ use Image::ExifTool qw(:Utils);
 use Image::ExifTool::Exif;
 require Exporter;
 
-$VERSION = '2.79';
+$VERSION = '2.81';
 @ISA = qw(Exporter);
 @EXPORT_OK = qw(EscapeXML UnescapeXML);
 
@@ -66,7 +66,9 @@ sub FormatXMPDate($);
 sub ConvertRational($);
 sub ConvertRationalList($);
 
-my %curNS;  # namespaces currently in effect while parsing the file
+# namespaces and prefixes currently in effect while parsing the file,
+# and lookup to translate brain-dead-Microsoft-Photo-software prefixes
+my (%curURI, %curNS, %xlatNS);
 
 # lookup for translating to ExifTool namespaces
 # Note: Use $xlatNamespace (only valid during processing) to do the translation
@@ -2218,9 +2220,10 @@ my %sPantryItem = (
             2 => 'LensInfo',
             3 => 'FocalLength',
             4 => 'LensModel',
+            5 => 'MaxApertureValue',
         },
         Inhibit => {
-            5 => 'Composite:LensID',    # don't override existing Composite:LensID
+            6 => 'Composite:LensID',    # don't override existing Composite:LensID
         },
         ValueConv => '$val',
         PrintConv => 'Image::ExifTool::XMP::PrintLensID($self, @val)',
@@ -2522,6 +2525,7 @@ sub RegisterNamespace($)
     if (ref $nsRef eq 'ARRAY') {
         $ns = $$nsRef[0];
         $nsURI{$ns} = $$nsRef[1];
+        $uri2ns{$$nsRef[1]} = $ns;
     } else { # must be a hash
         my @ns = sort keys %$nsRef; # allow multiple namespace definitions
         while (@ns) {
@@ -2530,6 +2534,7 @@ sub RegisterNamespace($)
                 warn "User-defined namespace prefix '$ns' conflicts with existing namespace\n";
             }
             $nsURI{$ns} = $$nsRef{$ns};
+            $uri2ns{$$nsRef{$ns}} = $ns;
         }
     }
     return $$table{NAMESPACE} = $ns;
@@ -2730,12 +2735,13 @@ sub ScanForXMP($$)
 
 #------------------------------------------------------------------------------
 # Print conversion for XMP-aux:LensID
-# Inputs: 0) ExifTool ref, 1) LensID, 2) Make, 3) LensInfo, 4) FocalLength, 5) LensModel
+# Inputs: 0) ExifTool ref, 1) LensID, 2) Make, 3) LensInfo, 4) FocalLength,
+#         5) LensModel, 6) MaxApertureValue
 # (yes, this is ugly -- blame Adobe)
 sub PrintLensID(@)
 {
     local $_;
-    my ($et, $id, $make, $info, $focalLength, $lensModel) = @_;
+    my ($et, $id, $make, $info, $focalLength, $lensModel, $maxAv) = @_;
     my ($mk, $printConv);
     my %alt = ( Pentax => 'Ricoh' );    # Pentax changed its name to Ricoh
     # missing: Olympus (no XMP:LensID written by Adobe)
@@ -2778,7 +2784,7 @@ sub PrintLensID(@)
             $printConv = \%newConv;
         }
         return Image::ExifTool::Exif::PrintLensID($et, $str, $printConv,
-                    undef, $id, $focalLength, $maxa, undef, $minf, $maxf, $lensModel);
+                    undef, $id, $focalLength, $maxa, $maxAv, $minf, $maxf, $lensModel);
     }
     return "Unknown ($id)";
 }
@@ -2984,7 +2990,7 @@ NoLoop:
 
         # add tag Namespace entry for tags in variable-namespace tables
         $$tagInfo{Namespace} = $xns if $xns;
-        if ($curNS{$ns} and $curNS{$ns} =~ m{^http://ns.exiftool.ca/(.*?)/(.*?)/}) {
+        if ($curURI{$ns} and $curURI{$ns} =~ m{^http://ns.exiftool.ca/(.*?)/(.*?)/}) {
             my %grps = ( 0 => $1, 1 => $2 );
             # apply a little magic to recover original group names
             # from this exiftool-written RDF/XML file
@@ -3164,7 +3170,65 @@ sub ParseXMPElement($$$;$$$$)
             $valEnd = $valStart;
         }
         $start = pos($$dataPt);         # start from here the next time around
-        my $parseResource;
+
+        # extract property attributes
+        my ($parseResource, %attrs, @attrs);
+        while ($attrs =~ m/(\S+?)\s*=\s*(['"])(.*?)\2/sg) {
+            my ($attr, $val) = ($1, $3);
+            # handle namespace prefixes (defined by xmlns:PREFIX, or used with PREFIX:tag)
+            if ($attr =~ /(.*?):/) {
+                if ($1 eq 'xmlns') {
+                    my $ns = substr($attr, 6);
+                    my $stdNS = $uri2ns{$val};
+                    unless ($stdNS) {
+                        my $try = $val;
+                        # patch for Nikon NX2 URI bug for Microsoft PhotoInfo namespace
+                        $try =~ s{/$}{} or $try .= '/';
+                        $stdNS = $uri2ns{$try};
+                        if ($stdNS) {
+                            $val = $try;
+                            $et->WarnOnce("Fixed incorrect URI for xmlns:$ns", 1);
+                        }
+                    }
+                    # tame wild namespace prefixes (patches Microsoft stupidity)
+                    if ($stdNS) {
+                        # use standard namespace prefix if pre-defined
+                        if ($stdNS ne $ns) {
+                            $xlatNS{$ns} = $stdNS;
+                            $attr = 'xmlns:' . $stdNS;
+                        }
+                    } elsif ($curNS{$val}) {
+                        # use a consistent prefix for a given namespace URI
+                        if ($curNS{$val} ne $ns) {
+                            $xlatNS{$ns} = $curNS{$val};
+                            $attr = 'xmlns:' . $xlatNS{$ns};
+                        }
+                    } else {
+                        # use unique prefixes for all namespaces
+                        if ($curURI{$ns} or $nsURI{$ns}) {
+                            # generate a temporary namespace prefix to resolve any conflict
+                            my $i = 0;
+                            ++$i while $curURI{"tmp$i"};
+                            $xlatNS{$ns} = "tmp$i";
+                            $attr = 'xmlns:' . $xlatNS{$ns};
+                            $ns = $xlatNS{$ns};
+                        }
+                        # keep track of the namespace prefixes and URI's used in this XMP
+                        $curNS{$val} = $ns;
+                        $curURI{$ns} = $val;
+                    }
+                } elsif ($xlatNS{$1}) {
+                    $attr = $xlatNS{$1} . substr($attr, length($1));
+                }
+            }
+            push @attrs, $attr;    # preserve order
+            $attrs{$attr} = $val;
+        }
+        # tame wild namespace prefixes (patch for Microsoft stupidity)
+        if ($prop =~ /(.*?):/ and $xlatNS{$1}) {
+            $prop = $xlatNS{$1} . substr($prop, length($1));
+        }
+
         if ($prop eq 'rdf:li') {
             # impose a reasonable maximum on the number of items in a list
             if ($nItems == 1000) {
@@ -3200,14 +3264,8 @@ sub ParseXMPElement($$$;$$$$)
             $prop = 'x:xmpmeta';
         }
 
-        # extract property attributes
-        my (%attrs, @attrs, $val);
-        while ($attrs =~ m/(\S+?)\s*=\s*(['"])(.*?)\2/sg) {
-            push @attrs, $1;    # preserve order
-            $attrs{$1} = $3;
-        }
-
         # hook for special parsing of attributes
+        my $val;
         if ($attrProc) {
             $val = substr($$dataPt, $valStart, $valEnd - $valStart);
             if (&$attrProc(\@attrs, \%attrs, \$prop, \$val)) {
@@ -3245,6 +3303,7 @@ sub ParseXMPElement($$$;$$$$)
         # (attributes take the form a:b='c' or a:b="c")
         my ($shortName, $shorthand, $ignored);
         foreach $shortName (@attrs) {
+            next unless defined $attrs{$shortName};
             my $propName = $shortName;
             my ($ns, $name);
             if ($propName =~ /(.*?):(.*)/) {
@@ -3261,29 +3320,6 @@ sub ParseXMPElement($$$;$$$$)
                 $ns = '';
                 $name = $propName;
             }
-            # keep track of the namespace prefixes used
-            if ($ns eq 'xmlns') {
-                my $uri = $attrs{$shortName};
-                next unless $uri; # (shouldn't happen)
-                my $stdNS = $uri2ns{$uri};
-                unless ($stdNS) {
-                    # patch for Nikon NX2 URI bug for Microsoft PhotoInfo namespace
-                    $uri =~ s{/$}{} or $uri .= '/';
-                    $stdNS = $uri2ns{$uri};
-                    if ($stdNS) {
-                        $attrs{$shortName} = $uri;
-                        $et->WarnOnce("Fixed incorrect URI for $shortName", 1);
-                    }
-                }
-                $curNS{$name} = $attrs{$shortName};
-                # translate namespace if non-standard (except 'x' and 'iX')
-                if ($stdNS and $name ne $stdNS and $stdNS ne 'x' and $stdNS ne 'iX') {
-                    # make a copy of the standard translations so we can modify it
-                    $xlatNamespace = { %stdXlatNS } if $xlatNamespace eq \%stdXlatNS;
-                    # translate this namespace prefix to the standard version
-                    $$xlatNamespace{$name} = $stdXlatNS{$stdNS} || $stdNS;
-                }
-            }
             if ($isWriting) {
                 # keep track of our namespaces when writing
                 if ($ns eq 'xmlns') {
@@ -3428,7 +3464,9 @@ sub ProcessXMP($$;$)
     my ($buff, $fmt, $hasXMP, $isXML, $isRDF, $isSVG);
     my $rtnVal = 0;
     my $bom = 0;
+    undef %curURI;
     undef %curNS;
+    undef %xlatNS;
 
     # ignore non-standard XMP while in strict MWG compatibility mode
     if ($Image::ExifTool::MWG::strict and not $$et{XMP_CAPTURE} and
@@ -3550,6 +3588,9 @@ sub ProcessXMP($$;$)
         }
         $et->SetFileType($type);
 
+        my $fast = $et->Options('FastScan');
+        return 1 if $fast and $fast == 3;
+
         if ($type and $type eq 'INX') {
             # brute force search for first XMP packet in INX file
             # start: '<![CDATA[<?xpacket begin' (24 bytes)
@@ -3746,7 +3787,9 @@ sub ProcessXMP($$;$)
     delete $$et{NO_LIST};
     delete $$et{XMPParseOpts};
 
+    undef %curURI;
     undef %curNS;
+    undef %xlatNS;
     return $rtnVal;
 }