exiftool_vendored 12.73.0 → 12.75.0

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

@@ -171,9 +171,9 @@ sub RebuildMakerNotes($$$)
     my $saveOrder = GetByteOrder();
     my $loc = Image::ExifTool::MakerNotes::LocateIFD($et,\%subdirInfo);
     if (defined $loc) {
-        my $makerFixup = $subdirInfo{Fixup} = new Image::ExifTool::Fixup;
+        my $makerFixup = $subdirInfo{Fixup} = Image::ExifTool::Fixup->new;
         # create new exiftool object to rewrite the directory without changing it
-        my $newTool = new Image::ExifTool;
+        my $newTool = Image::ExifTool->new;
         $newTool->Options(
             IgnoreMinorErrors => $$et{OPTIONS}{IgnoreMinorErrors},
             FixBase           => $$et{OPTIONS}{FixBase},
@@ -565,7 +565,7 @@ sub WriteExif($$$)
     my $firstBase = $base;
     my $raf = $$dirInfo{RAF};
     my $dirName = $$dirInfo{DirName} || 'unknown';
-    my $fixup = $$dirInfo{Fixup} || new Image::ExifTool::Fixup;
+    my $fixup = $$dirInfo{Fixup} || Image::ExifTool::Fixup->new;
     my $imageDataFlag = $$dirInfo{ImageData} || '';
     my $verbose = $et->Options('Verbose');
     my $out = $et->Options('TextOut');
@@ -745,7 +745,7 @@ sub WriteExif($$$)
         my $valBuff = '';   # buffer for value data
         my @valFixups;      # list of fixups for offsets in valBuff
         # fixup for offsets in dirBuff
-        my $dirFixup = new Image::ExifTool::Fixup;
+        my $dirFixup = Image::ExifTool::Fixup->new;
         my $entryBasedFixup;
         my $lastTagID = -1;
         my ($oldInfo, $oldFormat, $oldFormName, $oldCount, $oldSize, $oldValue, $oldImageData);
@@ -896,7 +896,7 @@ Entry:  for (;;) {
                                         TagInfo => $oldInfo || $tmpInfo,
                                         Offset  => $base + $valuePtr + $dataPos,
                                         Size    => $oldSize,
-                                        Fixup   => new Image::ExifTool::Fixup,
+                                        Fixup   => Image::ExifTool::Fixup->new,
                                     },
                                     $invalidPreview = 2;
                                     # remove SubDirectory to prevent processing (for now)
@@ -1348,7 +1348,7 @@ NoOverwrite:            next if $isNew > 0;
                     # create empty source directory
                     my %sourceDir = (
                         Parent => $dirName,
-                        Fixup => new Image::ExifTool::Fixup,
+                        Fixup => Image::ExifTool::Fixup->new,
                     );
                     $sourceDir{DirName} = $$newInfo{Groups}{1} if $$newInfo{SubIFD};
                     $newValue = $et->WriteDirectory(\%sourceDir, $subTable);
@@ -1509,7 +1509,7 @@ NoOverwrite:            next if $isNew > 0;
                         }
                         if (defined $loc) {
                             # we need fixup data for this subdirectory
-                            $subdirInfo{Fixup} = new Image::ExifTool::Fixup;
+                            $subdirInfo{Fixup} = Image::ExifTool::Fixup->new;
                             # rewrite maker notes
                             my $changed = $$et{CHANGED};
                             $subdir = $et->WriteDirectory(\%subdirInfo, $subTable, $writeProc);
@@ -1673,7 +1673,7 @@ NoOverwrite:            next if $isNew > 0;
                                 Name     => $$newInfo{Name},
                                 TagInfo  => $newInfo,
                                 Parent   => $dirName,
-                                Fixup    => new Image::ExifTool::Fixup,
+                                Fixup    => Image::ExifTool::Fixup->new,
                                 RAF      => $raf,
                                 Subdir   => $subdir,
                                 # set ImageData only for 1st level SubIFD's
@@ -1782,7 +1782,7 @@ NoOverwrite:            next if $isNew > 0;
                             #### eval Base ($start,$base)
                             $subdirBase += eval $$subdir{Base};
                         }
-                        my $subFixup = new Image::ExifTool::Fixup;
+                        my $subFixup = Image::ExifTool::Fixup->new;
                         my %subdirInfo = (
                             Base     => $subdirBase,
                             DataPt   => $valueDataPt,
@@ -1995,7 +1995,7 @@ NoOverwrite:            next if $isNew > 0;
                         # hold onto the PreviewImage until we can determine if it fits
                         $$et{PREVIEW_INFO} or $$et{PREVIEW_INFO} = {
                             Data => $$newValuePt,
-                            Fixup => new Image::ExifTool::Fixup,
+                            Fixup => Image::ExifTool::Fixup->new,
                         };
                         $$et{PREVIEW_INFO}{ChangeBase} = 1 if $$newInfo{ChangeBase};
                         if ($$newInfo{IsOffset} and $$newInfo{IsOffset} eq '2') {
@@ -2017,7 +2017,7 @@ NoOverwrite:            next if $isNew > 0;
                     $valBuff .= $$newValuePt;       # add value data to buffer
                     # must save a fixup pointer for every pointer in the directory
                     if ($entryBased) {
-                        $entryBasedFixup or $entryBasedFixup = new Image::ExifTool::Fixup;
+                        $entryBasedFixup or $entryBasedFixup = Image::ExifTool::Fixup->new;
                         $entryBasedFixup->AddFixup(length($dirBuff) + 8, $dataTag);
                     } else {
                         $dirFixup->AddFixup(length($dirBuff) + 8, $dataTag);
@@ -2277,14 +2277,17 @@ NoOverwrite:            next if $isNew > 0;
                         $$offsetInfo{0x117} and $$offsetInfo{0x145} and
                         $$offsetInfo{0x111}[2]==1) # (must be a single strip or the tile offsets could get out of sync)
                     {
-                        # some Sony ARW images contain double-referenced raw data stored as both strips
-                        # and tiles.  Copy the data using only the strip tags, but store the TileOffets
-                        # information for updating later (see PanasonicRaw:PatchRawDataOffset for a
-                        # description of offsetInfo elements)
-                        $$offsetInfo{0x111}[5] = $$offsetInfo{0x144}; # hack to save TileOffsets
-                        # delete tile information from offsetInfo because we will copy as strips
-                        delete $$offsetInfo{0x144};
-                        delete $$offsetInfo{0x145};
+                        # check the start offsets to see if they are the same
+                        if ($$offsetInfo{0x111}[3] == $$offsetInfo{0x144}[3]) {
+                            # some Sony ARW images contain double-referenced raw data stored as both strips
+                            # and tiles.  Copy the data using only the strip tags, but store the TileOffets
+                            # information for updating later (see PanasonicRaw:PatchRawDataOffset for a
+                            # description of offsetInfo elements)
+                            $$offsetInfo{0x111}[5] = $$offsetInfo{0x144}; # hack to save TileOffsets
+                            # delete tile information from offsetInfo because we will copy as strips
+                            delete $$offsetInfo{0x144};
+                            delete $$offsetInfo{0x145};
+                        }
                     } else {
                         $et->Error("TIFF $dirName contains both strip and tile data");
                     }
@@ -2451,7 +2454,7 @@ NoOverwrite:            next if $isNew > 0;
                         $newOffset += $blockSize;   # data comes after other deferred data
                         # create fixup for SubIFD ImageData
                         if ($imageDataFlag eq 'SubIFD' and not $subIfdDataFixup) {
-                            $subIfdDataFixup = new Image::ExifTool::Fixup;
+                            $subIfdDataFixup = Image::ExifTool::Fixup->new;
                             $imageData[-1][4] = $subIfdDataFixup;
                         }
                         $size += $pad; # account for pad byte if necessary
@@ -2522,7 +2525,7 @@ NoOverwrite:            next if $isNew > 0;
                             # hold onto the PreviewImage until we can determine if it fits
                             $$et{PREVIEW_INFO} or $$et{PREVIEW_INFO} = {
                                 Data => $buff,
-                                Fixup => new Image::ExifTool::Fixup,
+                                Fixup => Image::ExifTool::Fixup->new,
                             };
                             if ($$tagInfo{IsOffset} and $$tagInfo{IsOffset} eq '2') {
                                 $$et{PREVIEW_INFO}{NoBaseShift} = 1;
@@ -2603,7 +2606,7 @@ NoOverwrite:            next if $isNew > 0;
                 $fixup->AddFixup($entry + 8);
                 # create special fixup for SubIFD data
                 if ($imageDataFlag eq 'SubIFD') {
-                    my $subIfdDataFixup = new Image::ExifTool::Fixup;
+                    my $subIfdDataFixup = Image::ExifTool::Fixup->new;
                     $subIfdDataFixup->AddFixup($entry + 8);
                     # save fixup in imageData list
                     $$blockInfo[4] = $subIfdDataFixup;
@@ -2668,7 +2671,7 @@ NoOverwrite:            next if $isNew > 0;
             } else {
                 # Doesn't fit, or we still don't know, so save fixup information
                 # and put the preview at the end of the file
-                $$previewInfo{Fixup} or $$previewInfo{Fixup} = new Image::ExifTool::Fixup;
+                $$previewInfo{Fixup} or $$previewInfo{Fixup} = Image::ExifTool::Fixup->new;
                 $$previewInfo{Fixup}->AddFixup($fixup);
             }
         } elsif (defined $newData and $deleteAll) {

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

@@ -290,7 +290,7 @@ sub WritePDF($$)
     $raf->Seek($pos, 0);
 
     # create a new ExifTool object and use it to read PDF and XMP information
-    my $newTool = new Image::ExifTool;
+    my $newTool = Image::ExifTool->new;
     $newTool->Options(List => 1);
     $newTool->Options(Password => $et->Options('Password'));
     $newTool->Options(NoPDFList => $et->Options('NoPDFList'));

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

@@ -785,7 +785,7 @@ sub WriteQuickTime($$$)
     my ($rtnVal, $rtnErr) = $dataPt ? (undef, undef) : (1, 0);
 
     if ($dataPt) {
-        $raf = new File::RandomAccess($dataPt);
+        $raf = File::RandomAccess->new($dataPt);
     } else {
         return 0 unless $raf;
     }

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

@@ -1083,6 +1083,8 @@ sub WriteXMP($$;$)
             # delete all structure (or pseudo-structure) elements
             require 'Image/ExifTool/XMPStruct.pl';
             ($deleted, $added, $existed) = DeleteStruct($et, \%capture, \$path, $nvHash, \$changed);
+            # don't add if it didn't exist and not IsCreating and Avoid
+            undef $added if not $existed and not $$nvHash{IsCreating} and $$tagInfo{Avoid};
             next unless $deleted or $added or $et->IsOverwriting($nvHash);
             next if $existed and $$nvHash{CreateOnly};
         } elsif ($cap) {
@@ -1262,8 +1264,8 @@ sub WriteXMP($$;$)
         # check to see if we want to create this tag
         # (create non-avoided tags in XMP data files by default)
         my $isCreating = ($$nvHash{IsCreating} or (($isStruct or
-                          ($preferred and not $$tagInfo{Avoid} and
-                            not defined $$nvHash{Shift})) and not $$nvHash{EditOnly}));
+                          ($preferred and not defined $$nvHash{Shift})) and
+                          not $$tagInfo{Avoid} and not $$nvHash{EditOnly}));
 
         # don't add new values unless...
             # ...tag existed before and was deleted, or we added it to a list

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

@@ -26,6 +26,7 @@ sub RemoveNewValuesForGroup($$);
 sub GetWriteGroup1($$);
 sub Sanitize($$);
 sub ConvInv($$$$$;$$);
+sub PushValue($$$;$);
 
 my $loadedAllTables;    # flag indicating we loaded all tables
 my $advFmtSelf;         # ExifTool object during evaluation of advanced formatting expr
@@ -1260,7 +1261,7 @@ sub SetNewValuesFromFile($$;@)
     }
     # expand shortcuts
     @setTags and ExpandShortcuts(\@setTags);
-    my $srcExifTool = new Image::ExifTool;
+    my $srcExifTool = Image::ExifTool->new;
     # set flag to indicate we are being called from inside SetNewValuesFromFile()
     $$srcExifTool{TAGS_FROM_FILE} = 1;
     # synchronize and increment the file sequence number
@@ -1582,7 +1583,7 @@ SET:    foreach $set (@setList) {
         my $opts = $$set[3];
         # handle expressions
         if ($$opts{EXPR}) {
-            my $val = $srcExifTool->InsertTagValues(\@tags, $$set[1], 'Error');
+            my $val = $srcExifTool->InsertTagValues($$set[1], \@tags, 'Error');
             my $err = $$srcExifTool{VALUE}{Error};
             if ($err) {
                 # pass on any error as a warning unless it is suppressed
@@ -2432,7 +2433,7 @@ sub WriteInfo($$;$$)
 #
     until ($$self{VALUE}{Error}) {
         # create random access file object (disable seek test in case of straight copy)
-        $raf or $raf = new File::RandomAccess($inRef, 1);
+        $raf or $raf = File::RandomAccess->new($inRef, 1);
         $raf->BinMode();
         if ($numNew == $numPseudo) {
             $rtnVal = 1;
@@ -2703,7 +2704,7 @@ sub GetAllTags(;$)
     my (%allTags, @groups);
     @groups = split ':', $group if $group;
 
-    my $et = new Image::ExifTool;
+    my $et = Image::ExifTool->new;
     LoadAllTables();    # first load all our tables
     my @tableNames = keys %allTables;
 
@@ -2748,7 +2749,7 @@ sub GetWritableTags(;$)
     my (%writableTags, @groups);
     @groups = split ':', $group if $group;
 
-    my $et = new Image::ExifTool;
+    my $et = Image::ExifTool->new;
     LoadAllTables();
     my @tableNames = keys %allTables;
 
@@ -3124,11 +3125,37 @@ Conv: for (;;) {
     return($val, $err);
 }
 
+#------------------------------------------------------------------------------
+# Dereference value and push onto list
+# Inputs: 0) ExifTool ref, 1) value, 2) list ref, 3) flag to push MissingTagValue for undef value
+sub PushValue($$$;$)
+{
+    local $_;
+    my ($self, $val, $list, $missing) = @_;
+    if (ref $val eq 'ARRAY' and ref $$val[0] ne 'HASH') {
+        $self->PushValue($_, $list, $missing) foreach @$val;
+    } elsif (ref $val eq 'SCALAR') {
+        if ($$self{OPTIONS}{Binary} or $$val =~ /^Binary data/) {
+            push @$list, $$val;
+        } else {
+            push @$list, 'Binary data ' . length($$val) . ' bytes';
+        }
+    } elsif (ref $val eq 'HASH' or ref $val eq 'ARRAY') {
+        require 'Image/ExifTool/XMPStruct.pl';
+        push @$list, Image::ExifTool::XMP::SerializeStruct($self, $val);
+    } elsif (not defined $val) {
+        my $mval = $$self{OPTIONS}{MissingTagValue};
+        push @$list, $mval if $missing and defined $mval;
+    } else {
+        push @$list, $val;
+    }
+}
+
 #------------------------------------------------------------------------------
 # Convert tag names to values or variables in a string
 # (eg. '${EXIF:ISO}x $$' --> '100x $' without hash ref, or "$info{'EXIF:ISO'}x $" with)
-# Inputs: 0) ExifTool object ref, 1) reference to list of found tags
-#         2) string with embedded tag names, 3) Options:
+# Inputs: 0) ExifTool object ref, 1) string with embedded tag names,
+#         2) reference to list of found tags or undef to use FOUND_TAGS, 3) Options:
 #               undef    - set missing tags to ''
 #              'Error'   - issue minor error on missing tag (and return undef)
 #              'Warn'    - issue minor warning on missing tag (and return undef)
@@ -3145,20 +3172,22 @@ Conv: for (;;) {
 # - advanced feature allows Perl expressions inside braces (eg. '${model;tr/ //d}')
 # - an error/warning in an advanced expression ("${TAG;EXPR}") generates an error
 #   if option set to 'Error', or a warning otherwise
-sub InsertTagValues($$$;$$$)
+sub InsertTagValues($$;$$$$)
 {
     local $_;
-    my ($self, $foundTags, $line, $opt, $docGrp, $cache) = @_;
+    my ($self, $line, $foundTags, $opt, $docGrp, $cache) = @_;
     my $rtnStr = '';
     my ($docNum, $tag);
+
     if ($docGrp) {
         $docNum = $docGrp =~ /(\d+)$/ ? $1 : 0;
     } else {
         undef $cache;   # no cache if no document groups
     }
+    $foundTags or $foundTags = $$self{FOUND_TAGS} || [];
     while ($line =~ s/(.*?)\$(\{\s*)?([-\w]*\w|\$|\/)//s) {
         my ($pre, $bra, $var) = ($1, $2, $3);
-        my (@tags, $val, $tg, @val, $type, $expr, $didExpr, $level, $asList);
+        my (@tags, $tg, $val, @val, $type, $expr, $didExpr, $level, $asList);
         # "$$" represents a "$" symbol, and "$/" is a newline
         if ($var eq '$' or $var eq '/') {
             $line =~ s/^\s*\}// if $bra;
@@ -3261,15 +3290,24 @@ sub InsertTagValues($$$;$$$)
                 } elsif (defined $$et{OPTIONS}{UserParam}{$lcTag}) {
                     $val = $$et{OPTIONS}{UserParam}{$lcTag};
                 } elsif ($tag =~ /(.*):(.+)/) {
-                    my $group;
+                    my ($group, @matches);
                     ($group, $tag) = ($1, $2);
-                    if (lc $tag eq 'all') {
-                        # see if any tag from the specified group exists
-                        my $match = $et->GroupMatches($group, $fileTags);
-                        $val = $match ? 1 : 0;
+                    # join values of all matching tags if "All" group is used
+                    # (and remove "All" from group prefix)
+                    if ($group =~ s/(^|:)(all|\*)(:|$)/$1 and $3/ei) {
+                        if (lc $tag eq 'all') {
+                            @matches = $group ? $et->GroupMatches($group, $fileTags) : @$fileTags;
+                        } else {
+                            @matches = grep /^$tag(\s|$)/i, @$fileTags;
+                            @matches = $et->GroupMatches($group, \@matches) if $group;
+                        }
+                        $self->PushValue(scalar $et->GetValue($_, $type), \@val) foreach @matches;
+                    } elsif (lc $tag eq 'all') {
+                        # return "1" if any tag from the specified group exists
+                        $val = $et->GroupMatches($group, $fileTags) ? 1 : 0;
                     } else {
                         # find the specified tag
-                        my @matches = grep /^$tag(\s|$)/i, @$fileTags;
+                        @matches = grep /^$tag(\s|$)/i, @$fileTags;
                         @matches = $et->GroupMatches($group, \@matches);
                         foreach $tg (@matches) {
                             if (defined $val and $tg =~ / \((\d+)\)$/) {
@@ -3298,31 +3336,15 @@ sub InsertTagValues($$$;$$$)
                 }
             }
             $self->Options(ListJoin => $oldListJoin) if $asList;
-            if (ref $val eq 'ARRAY') {
-                push @val, @$val;
-                undef $val;
-                last unless @tags;
-            } elsif (ref $val eq 'SCALAR') {
-                if ($$self{OPTIONS}{Binary} or $$val =~ /^Binary data/) {
-                    $val = $$val;
-                } else {
-                    $val = 'Binary data ' . length($$val) . ' bytes';
-                }
-            } elsif (ref $val eq 'HASH') {
-                require 'Image/ExifTool/XMPStruct.pl';
-                $val = Image::ExifTool::XMP::SerializeStruct($self, $val);
-            } elsif (not defined $val) {
-                $val = $$self{OPTIONS}{MissingTagValue} if $asList;
-            }
-            last unless @tags;
-            push @val, $val if defined $val;
+            $self->PushValue($val, \@val, $asList);
             undef $val;
+            last unless @tags;
         }
         if (@val) {
-            push @val, $val if defined $val;
+            $self->PushValue($val, \@val) if defined $val;
             $val = join $$self{OPTIONS}{ListSep}, @val;
-        } else {
-            push @val, $val if defined $val; # (so the eval has access to @val if required)
+        } elsif (defined $val) {
+            $self->PushValue($val, \@val);  # (so the eval has access to @val if required)
         }
         # evaluate advanced formatting expression if given (eg. "${TAG;EXPR}")
         if (defined $expr and defined $val) {
@@ -3331,7 +3353,7 @@ sub InsertTagValues($$$;$$$)
             $advFmtSelf = $self;
             if ($asList) {
                 foreach (@val) {
-                    #### eval advanced formatting expression ($_, $self, @val, $advFmtSelf)
+                    #### eval advanced formatting expression ($_, $self, @val, $tag, $advFmtSelf)
                     eval $expr;
                     $@ and $evalWarning = $@;
                 }
@@ -3340,7 +3362,7 @@ sub InsertTagValues($$$;$$$)
                 $val = @val ? join $$self{OPTIONS}{ListSep}, @val : undef;
             } else {
                 $_ = $val;
-                #### eval advanced formatting expression ($_, $self, @val, $advFmtSelf)
+                #### eval advanced formatting expression ($_, $self, @val, $tag, $advFmtSelf)
                 eval $expr;
                 $@ and $evalWarning = $@;
                 $val = ref $_ eq 'ARRAY' ? join($$self{OPTIONS}{ListSep}, @$_): $_;
@@ -3395,6 +3417,7 @@ sub InsertTagValues($$$;$$$)
 #------------------------------------------------------------------------------
 # Reformat date/time value in $_ based on specified format string
 # Inputs: 0) date/time format string
+# Returns: Reformatted date/time string
 sub DateFmt($)
 {
     my $et = bless { OPTIONS => { DateFormat => shift, StrictDate => 1 } };
@@ -3406,6 +3429,7 @@ sub DateFmt($)
     $_ = $et->ConvertDateTime($_);
     defined $_ or warn "Error converting date/time\n";
     $$advFmtSelf{GLOBAL_TIME_OFFSET} = $$et{GLOBAL_TIME_OFFSET} if $shift;
+    return $_;
 }
 
 #------------------------------------------------------------------------------
@@ -3515,7 +3539,7 @@ sub CreateDirectory($$)
                     }
                     unless ($k32CreateDir) {
                         return -1 if defined $k32CreateDir;
-                        $k32CreateDir = new Win32::API('KERNEL32', 'CreateDirectoryW', 'PP', 'I');
+                        $k32CreateDir = Win32::API->new('KERNEL32', 'CreateDirectoryW', 'PP', 'I');
                         unless ($k32CreateDir) {
                             $self->Warn('Error calling Win32::API::CreateDirectoryW');
                             $k32CreateDir = 0;
@@ -6233,7 +6257,7 @@ sub WriteJPEG($$)
                     last unless $$editDirs{CIFF};
                     my $newData = '';
                     my %dirInfo = (
-                        RAF => new File::RandomAccess($segDataPt),
+                        RAF => File::RandomAccess->new($segDataPt),
                         OutFile => \$newData,
                     );
                     require Image::ExifTool::CanonRaw;
@@ -6952,7 +6976,7 @@ sub SetFileTime($$;$$$$)
             }
             unless ($k32SetFileTime) {
                 return 0 if defined $k32SetFileTime;
-                $k32SetFileTime = new Win32::API('KERNEL32', 'SetFileTime', 'NPPP', 'I');
+                $k32SetFileTime = Win32::API->new('KERNEL32', 'SetFileTime', 'NPPP', 'I');
                 unless ($k32SetFileTime) {
                     $self->Warn('Error calling Win32::API::SetFileTime');
                     $k32SetFileTime = 0;
@@ -7196,7 +7220,7 @@ sub WriteBinaryData($$$)
                 $$self{HiddenData} = {
                     Offset => $offset,
                     Size   => $size,
-                    Fixup  => new Image::ExifTool::Fixup,
+                    Fixup  => Image::ExifTool::Fixup->new,
                     Base   => $$dirInfo{Base},
                 };
                 next;
@@ -7205,7 +7229,7 @@ sub WriteBinaryData($$$)
             next unless $$tagInfo{DataTag} eq 'PreviewImage' and $$self{FILE_TYPE} eq 'JPEG';
             my $previewInfo = $$self{PREVIEW_INFO};
             $previewInfo or $previewInfo = $$self{PREVIEW_INFO} = {
-                Fixup => new Image::ExifTool::Fixup,
+                Fixup => Image::ExifTool::Fixup->new,
             };
             # set flag indicating we are using short pointers
             $$previewInfo{IsShort} = 1 unless $format eq 'int32u';

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

@@ -50,7 +50,7 @@ use Image::ExifTool::Exif;
 use Image::ExifTool::GPS;
 require Exporter;
 
-$VERSION = '3.62';
+$VERSION = '3.63';
 @ISA = qw(Exporter);
 @EXPORT_OK = qw(EscapeXML UnescapeXML);
 
@@ -3644,6 +3644,7 @@ NoLoop:
             IgnoreProp => $$subdir{IgnoreProp}, # (allow XML to ignore specified properties)
             IsExtended => 1, # (hack to avoid Duplicate warning for embedded XMP)
             NoStruct => 1,   # (don't try to build structures since this isn't true XMP)
+            NoBlockSave => 1,# (don't save as a block because we already did this)
         );
         my $oldOrder = GetByteOrder();
         SetByteOrder($$subdir{ByteOrder}) if $$subdir{ByteOrder};

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

@@ -2191,6 +2191,15 @@ my %sSubVersion = (
     GROUPS => { 0 => 'SVG', 2 => 'Unknown' },
     LANG_INFO => \&GetLangInfo,
     NAMESPACE => undef, # variable namespace
+    'c2pa:manifest' => {
+        Name => 'JUMBF',
+        Groups => { 0 => 'JUMBF' },
+        RawConv => 'Image::ExifTool::XMP::DecodeBase64($val)',
+        SubDirectory => {
+            TagTable => 'Image::ExifTool::Jpeg2000::Main',
+            ByteOrder => 'BigEndian',
+        },
+    },
 );
 
 #------------------------------------------------------------------------------

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.30';
+$VERSION = '1.31';
 
 sub WarnProc($) { $warnString = $_[0]; }
 
@@ -367,7 +367,7 @@ sub ProcessRAR($$)
             # read the header and create new RAF object for reading it
             my $header;
             $raf->Read($header, $headSize) == $headSize or last;
-            my $rafHdr = new File::RandomAccess(\$header);
+            my $rafHdr = File::RandomAccess->new(\$header);
             my $headType = ReadULEB($rafHdr);   # get header type
 
             if ($headType == 4) {  # encryption block
@@ -550,14 +550,14 @@ sub ProcessZIP($$)
         } elsif (eval { require IO::String }) {
             # read the whole file into memory (what else can I do?)
             $raf->Slurp();
-            $fh = new IO::String ${$raf->{BUFF_PT}};
+            $fh = IO::String->new(${$raf->{BUFF_PT}});
         } else {
             my $type = $raf->{FILE_PT} ? 'pipe or socket' : 'scalar reference';
             $et->Warn("Install IO::String to decode compressed ZIP information from a $type");
             last;
         }
         $et->VPrint(1, "  --- using Archive::Zip ---\n");
-        $zip = new Archive::Zip;
+        $zip = Archive::Zip->new;
         # catch all warnings! (Archive::Zip is bad for this)
         local $SIG{'__WARN__'} = \&WarnProc;
         my $status = $zip->readFromFileHandle($fh);
@@ -568,8 +568,8 @@ sub ProcessZIP($$)
             # a failed test with Perl 5.6.2 GNU/Linux 2.6.32-5-686 i686-linux-64int-ld
             $raf->Seek(0,0);
             $raf->Slurp();
-            $fh = new IO::String ${$raf->{BUFF_PT}};
-            $zip = new Archive::Zip;
+            $fh = IO::String->new(${$raf->{BUFF_PT}});
+            $zip = Archive::Zip->new;
             $status = $zip->readFromFileHandle($fh);
         }
         if ($status) {