exiftool-vendored.exe 12.56.0 → 12.62.0

package/bin/exiftool_files/lib/Image/ExifTool/Writer.pl

@@ -1302,6 +1302,7 @@ sub SetNewValuesFromFile($$;@)
         MDItemTags      => $$options{MDItemTags},
         MissingTagValue => $$options{MissingTagValue},
         NoPDFList       => $$options{NoPDFList},
+        NoWarning       => $$options{NoWarning},
         Password        => $$options{Password},
         PrintConv       => $$options{PrintConv},
         QuickTimeUTC    => $$options{QuickTimeUTC},
@@ -1321,6 +1322,7 @@ sub SetNewValuesFromFile($$;@)
         XMPAutoConv     => $$options{XMPAutoConv},
     );
     $$srcExifTool{GLOBAL_TIME_OFFSET} = $$self{GLOBAL_TIME_OFFSET};
+    $$srcExifTool{ALT_EXIFTOOL} = $$self{ALT_EXIFTOOL};
     foreach $tag (@setTags) {
         next if ref $tag;
         if ($tag =~ /^-(.*)/) {
@@ -1387,7 +1389,7 @@ sub SetNewValuesFromFile($$;@)
 # transfer specified tags in the proper order
 #
     # 1) loop through input list of tags to set, and build @setList
-    my (@setList, $set, %setMatches, $t);
+    my (@setList, $set, %setMatches, $t, %altFiles);
     foreach $t (@setTags) {
         if (ref $t eq 'HASH') {
             # update current options
@@ -1419,9 +1421,12 @@ sub SetNewValuesFromFile($$;@)
                     $tag =~ s/(.+?)\s*(>|<) ?//;
                     $$opts{EXPR} = 1; # flag this expression
                 } else {
+                    # (not sure why this is here because sign should be before '<')
+                    # (--> allows "<+" or "<-", which is an undocumented feature)
                     $opt = $1 if $tag =~ s/^([-+])\s*//;
                 }
             }
+            $$opts{Replace} = 0 if $dstTag =~ s/^\+//;
             # validate tag name(s)
             unless ($$opts{EXPR} or ValidTagName($tag)) {
                 $self->Warn("Invalid tag name '${tag}'. Use '=' not '<' to assign a tag value");
@@ -1438,6 +1443,8 @@ sub SetNewValuesFromFile($$;@)
             $$opts{Type} = 'ValueConv' if $dstTag =~ s/#$//;
             # replace tag name of 'all' with '*'
             $dstTag = '*' if $dstTag eq 'all';
+        } else {
+            $$opts{Replace} = 0 if $tag =~ s/^\+//;
         }
         unless ($$opts{EXPR}) {
             $isExclude = ($tag =~ s/^-//);
@@ -1447,7 +1454,17 @@ sub SetNewValuesFromFile($$;@)
                     # save family/groups in list (ignoring 'all' and '*')
                     next unless length($_) and /^(\d+)?(.*)/;
                     my ($f, $g) = ($1, $2);
-                    $f = 7 if $g =~ s/^ID-//i;
+                    $f = 7 if (not $f or $f eq '7') and $g =~ s/^ID-//i;
+                    if ($g =~ /^file\d+$/i and (not $f or $f eq '8')) {
+                        $f = 8;
+                        my $g8 = ucfirst $g;
+                        if ($$srcExifTool{ALT_EXIFTOOL}{$g8}) {
+                            $$opts{GROUP8} = $g8;
+                            $altFiles{$g8} or $altFiles{$g8} = [ ];
+                            # save list of requested tags for this alternate ExifTool object
+                            push @{$altFiles{$g8}}, "$grp:$tag";
+                        }
+                    }
                     push @fg, [ $f, $g ] unless $g eq '*' or $g eq 'all';
                 }
             }
@@ -1484,26 +1501,44 @@ sub SetNewValuesFromFile($$;@)
         # save in reverse order so we don't set tags before an exclude
         unshift @setList, [ \@fg, $tag, $dst, $opts ];
     }
+    # 1b) copy requested tags for each alternate ExifTool object
+    my $g8;
+    foreach $g8 (sort keys %altFiles) {
+        # request specific alternate tags to load them from the alternate ExifTool object
+        my $altInfo = $srcExifTool->GetInfo($altFiles{$g8});
+        # add to tags list after dummy entry to signify start of tags for this alt file
+        if (%$altInfo) {
+            push @tags, 'Warning DUMMY', reverse sort keys %$altInfo;
+            $$info{$_} = $$altInfo{$_} foreach keys %$altInfo;
+        }
+    }
     # 2) initialize lists of matching tags for each setTag
     foreach $set (@setList) {
         $$set[2] and $setMatches{$set} = [ ];
     }
     # 3) loop through all tags in source image and save tags matching each setTag
-    my %rtnInfo;
+    my (%rtnInfo, $isAlt);
     foreach $tag (@tags) {
         # don't try to set errors or warnings
         if ($tag =~ /^(Error|Warning)( |$)/) {
-            $rtnInfo{$tag} = $$info{$tag};
+            if ($tag eq 'Warning DUMMY') {
+                $isAlt = 1; # start of the alt tags
+            } else {
+                $rtnInfo{$tag} = $$info{$tag};
+            }
             next;
         }
         # only set specified tags
         my $lcTag = lc(GetTagName($tag));
         my (@grp, %grp);
 SET:    foreach $set (@setList) {
+            my $opts = $$set[3];
+            next if $$opts{EXPR};   # (expressions handled in step 4)
+            next if $$opts{GROUP8} xor $isAlt;
             # check first for matching tag
             unless ($$set[1] eq $lcTag or $$set[1] eq '*') {
                 # handle wildcards
-                next unless $$set[3]{WILD} and $lcTag =~ /^$$set[1]$/;
+                next unless $$opts{WILD} and $lcTag =~ /^$$set[1]$/;
             }
             # then check for matching group
             if (@{$$set[0]}) {
@@ -1535,10 +1570,17 @@ SET:    foreach $set (@setList) {
         # handle expressions
         if ($$opts{EXPR}) {
             my $val = $srcExifTool->InsertTagValues(\@tags, $$set[1], 'Error');
-            if ($$srcExifTool{VALUE}{Error}) {
-                # pass on any error as a warning
-                $tag = NextFreeTagKey(\%rtnInfo, 'Warning');
-                $rtnInfo{$tag} = $$srcExifTool{VALUE}{Error};
+            my $err = $$srcExifTool{VALUE}{Error};
+            if ($err) {
+                # pass on any error as a warning unless it is suppressed
+                my $noWarn = $$srcExifTool{OPTIONS}{NoWarning};
+                unless ($noWarn and (eval { $err =~ /$noWarn/ } or
+                    # (also apply expression to warning without "[minor] " prefix)
+                    ($err =~ s/^\[minor\] //i and eval { $err =~ /$noWarn/ })))
+                {
+                    $tag = NextFreeTagKey(\%rtnInfo, 'Warning');
+                    $rtnInfo{$tag} = $$srcExifTool{VALUE}{Error};
+                }
                 delete $$srcExifTool{VALUE}{Error};
                 next unless defined $val;
             }
@@ -1835,6 +1877,27 @@ sub RestoreNewValues($)
     $$self{DEL_GROUP} = \%delGrp;
 }
 
+#------------------------------------------------------------------------------
+# Set alternate file for extracting information
+# Inputs: 0) ExifTool ref, 1) family 8 group name (of the form "File#" where # is any number)
+#         2) alternate file name, or undef to reset
+# Returns: 1 on success, or 0 on invalid group name
+sub SetAlternateFile($$$)
+{
+    my ($self, $g8, $file) = @_;
+    $g8 = ucfirst lc $g8;
+    return 0 unless $g8 =~ /^File\d+$/;
+    # keep the same file if already initialized (possibly has metadata extracted)
+    if (not defined $file) {
+        delete $$self{ALT_EXIFTOOL}{$g8};
+    } elsif (not ($$self{ALT_EXIFTOOL}{$g8} and $$self{ALT_EXIFTOOL}{$g8}{ALT_FILE} eq $file)) {
+        my $altExifTool = Image::ExifTool->new;
+        $$altExifTool{ALT_FILE} = $file;
+        $$self{ALT_EXIFTOOL}{$g8} = $altExifTool;
+    }
+    return 1;
+}
+
 #------------------------------------------------------------------------------
 # Set filesystem time from from FileModifyDate or FileCreateDate tag
 # Inputs: 0) ExifTool object reference, 1) file name or file ref
@@ -2722,13 +2785,16 @@ sub GetAllGroups($;$)
     $family == 4 and return('Copy#');
     $family == 5 and return('[too many possibilities to list]');
     $family == 6 and return(@Image::ExifTool::Exif::formatName[1..$#Image::ExifTool::Exif::formatName]);
+    $family == 8 and return('File#');
 
     LoadAllTables();    # first load all our tables
 
     my @tableNames = keys %allTables;
 
-    # loop through all tag tables and get all group names
     my %allGroups;
+    # add family 1 groups not in tables
+    $family == 1 and map { $allGroups{$_} = 1 } qw(Garmin);
+    # loop through all tag tables and get all group names
     while (@tableNames) {
         my $table = GetTagTable(pop @tableNames);
         my ($grps, $grp, $tag, $tagInfo);
@@ -3159,42 +3225,46 @@ sub InsertTagValues($$$;$$$)
                     $tag = $docGrp . ':' . $tag;
                     $lcTag = lc $tag;
                 }
+                my $et = $self;
+                if ($tag =~ s/(\bfile\d+)://i) {
+                    $et = $$self{ALT_EXIFTOOL}{ucfirst lc $1} or $et=$self, $tag = 'no_alt_file';
+                }
                 if ($lcTag eq 'all') {
                     $val = 1;   # always some tag available
-                } elsif (defined $$self{OPTIONS}{UserParam}{$lcTag}) {
-                    $val = $$self{OPTIONS}{UserParam}{$lcTag};
+                } elsif (defined $$et{OPTIONS}{UserParam}{$lcTag}) {
+                    $val = $$et{OPTIONS}{UserParam}{$lcTag};
                 } elsif ($tag =~ /(.*):(.+)/) {
                     my $group;
                     ($group, $tag) = ($1, $2);
                     if (lc $tag eq 'all') {
                         # see if any tag from the specified group exists
-                        my $match = $self->GroupMatches($group, $foundTags);
+                        my $match = $et->GroupMatches($group, $foundTags);
                         $val = $match ? 1 : 0;
                     } else {
                         # find the specified tag
                         my @matches = grep /^$tag(\s|$)/i, @$foundTags;
-                        @matches = $self->GroupMatches($group, \@matches);
+                        @matches = $et->GroupMatches($group, \@matches);
                         foreach $tg (@matches) {
                             if (defined $val and $tg =~ / \((\d+)\)$/) {
                                 # take the most recently extracted tag
                                 my $tagNum = $1;
                                 next if $tag !~ / \((\d+)\)$/ or $1 > $tagNum;
                             }
-                            $val = $self->GetValue($tg, $type);
+                            $val = $et->GetValue($tg, $type);
                             $tag = $tg;
                             last unless $tag =~ / /;    # all done if we got our best match
                         }
                     }
                 } elsif ($tag eq 'self') {
-                    $val = $self; # ("$self{var}" or "$self->{var}" in string)
+                    $val = $et; # ("$self{var}" or "$file1:self{var}" in string)
                 } else {
                     # get the tag value
-                    $val = $self->GetValue($tag, $type);
+                    $val = $et->GetValue($tag, $type);
                     unless (defined $val) {
                         # check for tag name with different case
                         ($tg) = grep /^$tag$/i, @$foundTags;
                         if (defined $tg) {
-                            $val = $self->GetValue($tg, $type);
+                            $val = $et->GetValue($tg, $type);
                             $tag = $tg;
                         }
                     }
@@ -3262,15 +3332,19 @@ sub InsertTagValues($$$;$$$)
             undef $advFmtSelf;
             $didExpr = 1;   # set flag indicating an expression was evaluated
         }
-        unless (defined $val or ref $opt) {
+        unless (defined $val) {
             $val = $$self{OPTIONS}{MissingTagValue};
             unless (defined $val) {
                 my $g3 = ($docGrp and $var !~ /\b(main|doc\d+):/i) ? $docGrp . ':' : '';
                 my $msg = $didExpr ? "Advanced formatting expression returned undef for '$g3${var}'" :
                                      "Tag '$g3${var}' not defined";
-                no strict 'refs';
-                $opt and ($opt eq 'Silent' or &$opt($self, $msg, 2)) and return $$self{FMT_EXPR} = undef;
-                $val = '';
+                if (ref $opt) {
+                    $self->Warn($msg,2) or $val = '';
+                } elsif ($opt) {
+                    no strict 'refs';
+                    ($opt eq 'Silent' or &$opt($self, $msg, 2)) and return $$self{FMT_EXPR} = undef;
+                    $val = '';
+                }
             }
         }
         if (ref $opt eq 'HASH') {
@@ -4202,7 +4276,7 @@ sub WriteDirectory($$$;$)
             return '' unless $dataPt or $$dirInfo{RAF}; # nothing to do if block never existed
             # don't allow MakerNotes to be removed from RAW files
             if ($blockName eq 'MakerNotes' and $rawType{$$self{FileType}}) {
-                $self->Warn("Can't delete MakerNotes from $$self{VALUE}{FileType}",1);
+                $self->Warn("Can't delete MakerNotes from $$self{FileType}",1);
                 return undef;
             }
             $verb = 'Deleting';
@@ -4267,7 +4341,7 @@ sub WriteDirectory($$$;$)
     if ($out) {
         print $out "  Deleting $name\n" if defined $newData and not length $newData;
         if ($$self{CHANGED} == $oldChanged and $$self{OPTIONS}{Verbose} > 2) {
-            print $out "$$self{INDENT}  [nothing changed in $dirName]\n";
+            print $out "$$self{INDENT}  [nothing changed in $name]\n";
         }
     }
     return $newData;
@@ -5432,7 +5506,6 @@ sub WriteJPEG($$)
     my $verbose = $$self{OPTIONS}{Verbose};
     my $out = $$self{OPTIONS}{TextOut};
     my $rtnVal = 0;
-    my %dumpParms = ( Out => $out );
     my ($writeBuffer, $oldOutfile); # used to buffer writing until PreviewImage position is known
 
     # check to be sure this is a valid JPG or EXV file
@@ -5447,7 +5520,6 @@ sub WriteJPEG($$)
         Write($outfile,"\xff\x01") or $err = 1;
         $isEXV = 1;
     }
-    $dumpParms{MaxLen} = 128 unless $verbose > 3;
 
     delete $$self{PREVIEW_INFO};   # reset preview information
     delete $$self{DEL_PREVIEW};    # reset flag to delete preview
@@ -5506,7 +5578,7 @@ sub WriteJPEG($$)
                     $s =~ /^JFXX\0\x10/     and $dirName = 'JFXX';
                     $s =~ /^(II|MM).{4}HEAPJPGM/s and $dirName = 'CIFF';
                 } elsif ($marker == 0xe1) {
-                    if ($s =~ /^(.{0,4})$exifAPP1hdr(.{1,4})/is) {
+                    if ($s =~ /^(.{0,4})Exif\0.(.{1,4})/is) {
                         $dirName = 'IFD0';
                         my ($junk, $bytes) = ($1, $2);
                         # support multi-segment EXIF
@@ -6017,12 +6089,7 @@ sub WriteJPEG($$)
         #
         my $segDataPt = \$segData;
         $length = length($segData);
-        if ($verbose) {
-            print $out "JPEG $markerName ($length bytes):\n";
-            if ($verbose > 2 and $markerName =~ /^APP/) {
-                HexDump($segDataPt, undef, %dumpParms);
-            }
-        }
+        print $out "JPEG $markerName ($length bytes)\n" if $verbose;
         # group delete of APP segments
         if ($$delGroup{$dirName}) {
             $verbose and print $out "  Deleting $dirName segment\n";
@@ -6077,7 +6144,7 @@ sub WriteJPEG($$)
                 }
             } elsif ($marker == 0xe1) {         # APP1 (EXIF, XMP)
                 # check for EXIF data
-                if ($$segDataPt =~ /^(.{0,4})$exifAPP1hdr/is) {
+                if ($$segDataPt =~ /^(.{0,4})Exif\0./is) {
                     my $hdrLen = length $exifAPP1hdr;
                     if (length $1) {
                         $hdrLen += length $1;
@@ -6812,6 +6879,36 @@ sub SetFileTime($$;$$$$)
     return 1; # (nothing to do)
 }
 
+#------------------------------------------------------------------------------
+# Add data to MD5 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($$$;$$)
+{
+    my ($self, $raf, $size, $type, $noMsg) = @_;
+    my $md5 = $$self{ImageDataMD5} or return;
+    my ($bytesRead, $n) = (0, 65536);
+    my $buff;
+    for (;;) {
+        if (defined $size) {
+            last unless $size;
+            $n = $size > 65536 ? 65536 : $size;
+            $size -= $n;
+        }
+        unless ($raf->Read($buff, $n)) {
+            $self->Warn("Error reading $type data") if $type and defined $size;
+            last;
+        }
+        $md5->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");
+    }
+    return $bytesRead;
+}
+
 #------------------------------------------------------------------------------
 # Copy data block from RAF to output file in max 64kB chunks
 # Inputs: 0) RAF ref, 1) outfile ref, 2) block size
@@ -6870,6 +6967,7 @@ sub WriteBinaryData($$$)
 
     # get default format ('int8u' unless specified)
     my $dataPt = $$dirInfo{DataPt} or return undef;
+    my $dataLen = length $$dataPt;
     my $defaultFormat = $$tagTablePtr{FORMAT} || 'int8u';
     my $increment = FormatSize($defaultFormat);
     unless ($increment) {
@@ -6886,7 +6984,8 @@ sub WriteBinaryData($$$)
         delete $$dirInfo{VarFormatData};
     }
     my $dirStart = $$dirInfo{DirStart} || 0;
-    my $dirLen = $$dirInfo{DirLen} || length($$dataPt) - $dirStart;
+    my $dirLen = $$dirInfo{DirLen};
+    $dirLen = $dataLen - $dirStart if not defined $dirLen or $dirLen > $dataLen - $dirStart;
     my $newData = substr($$dataPt, $dirStart, $dirLen) or return undef;
     my $dirName = $$dirInfo{DirName};
     my $varSize = 0;
@@ -7022,11 +7121,34 @@ sub WriteBinaryData($$$)
                 $tagInfo = $self->GetTagInfo($tagTablePtr, $tagID, \$v);
                 next unless $tagInfo;
             }
-            next unless $$tagInfo{SubDirectory}; # (just to be safe)
-            my %subdirInfo = ( DataPt => \$newData, DirStart => $entry );
-            my $subTablePtr = GetTagTable($$tagInfo{SubDirectory}{TagTable});
-            my $dat = $self->WriteDirectory(\%subdirInfo, $subTablePtr);
-            substr($newData, $entry) = $dat if defined $dat and length $dat;
+            my $subdir = $$tagInfo{SubDirectory} or next;
+            my $start = $$subdir{Start};
+            my $len;
+            if (not $start) {
+                $start = $entry;
+                $len = $dirLen - $start;
+            } elsif ($start =~ /\$/) {
+                my $count = 1;
+                my $format = $$tagInfo{Format} || $defaultFormat;
+                $format =~ /(.*)\[(.*)\]/ and ($format, $count) = ($1, $2);
+                my $val = ReadValue($dataPt, $entry, $format, $count, $dirLen - $entry);
+                # ignore directories with a zero offset (ie. missing Nikon ShotInfo entries)
+                next unless $val;
+                my $dirStart = 0;
+                #### eval Start ($val, $dirStart)
+                $start = eval($start);
+                next if $start < $dirStart or $start > $dataLen;
+                $len = $$subdir{DirLen};
+                $len = $dataLen - $start unless $len and $len <= $dataLen - $start;
+            }
+            my %subdirInfo = (
+                DataPt   => \$newData,
+                DirStart => $start,
+                DirLen   => $len,
+                TagInfo  => $tagInfo,
+            );
+            my $dat = $self->WriteDirectory(\%subdirInfo, GetTagTable($$subdir{TagTable}));
+            substr($newData, $start, $len) = $dat if defined $dat and length $dat;
         }
     }
     return $newData;

package/bin/exiftool_files/lib/Image/ExifTool/XMP.pm

@@ -50,7 +50,7 @@ use Image::ExifTool::Exif;
 use Image::ExifTool::GPS;
 require Exporter;
 
-$VERSION = '3.56';
+$VERSION = '3.59';
 @ISA = qw(Exporter);
 @EXPORT_OK = qw(EscapeXML UnescapeXML);
 
@@ -248,7 +248,11 @@ my %boolConv = (
 
 # XMP namespaces which we don't want to contribute to generated EXIF tag names
 # (Note: namespaces with non-standard prefixes aren't currently ignored)
-my %ignoreNamespace = ( 'x'=>1, rdf=>1, xmlns=>1, xml=>1, svg=>1, et=>1, office=>1 );
+my %ignoreNamespace = ( 'x'=>1, rdf=>1, xmlns=>1, xml=>1, svg=>1, office=>1 );
+
+# ExifTool properties that don't generate tag names (et:tagid is historic)
+my %ignoreEtProp = ( 'et:desc'=>1, 'et:prt'=>1, 'et:val'=>1 , 'et:id'=>1, 'et:tagid'=>1,
+                     'et:toolkit'=>1, 'et:table'=>1, 'et:index'=>1 );
 
 # XMP properties to ignore (set dynamically via dirInfo IgnoreProp)
 my %ignoreProp;
@@ -753,6 +757,10 @@ my %sRangeMask = (
         Name => 'album',
         SubDirectory => { TagTable => 'Image::ExifTool::XMP::Album' },
     },
+    et => {
+        Name => 'et',
+        SubDirectory => { TagTable => 'Image::ExifTool::XMP::ExifTool' },
+    },
     prism => {
         Name => 'prism',
         SubDirectory => { TagTable => 'Image::ExifTool::XMP::prism' },
@@ -2481,6 +2489,9 @@ my %sPantryItem = (
     EnhanceSuperResolutionAlreadyApplied => { Writable => 'boolean' },
     EnhanceSuperResolutionVersion   => { }, # integer?
     EnhanceSuperResolutionScale     => { Writable => 'rational' },
+    EnhanceDenoiseAlreadyApplied    => { Writable => 'boolean' }, #forum14760
+    EnhanceDenoiseVersion           => { }, #forum14760 integer?
+    EnhanceDenoiseLumaAmount        => { }, #forum14760 integer?
 );
 
 # IPTC Core namespace properties (Iptc4xmpCore) (ref 4)
@@ -2550,6 +2561,14 @@ my %sPantryItem = (
     Notes => { },
 );
 
+# ExifTool namespace properties (et)
+%Image::ExifTool::XMP::ExifTool = (
+    %xmpTableDefaults,
+    GROUPS => { 1 => 'XMP-et', 2 => 'Image' },
+    NAMESPACE   => 'et',
+    OriginalImageMD5 => { Notes => 'used to store ExifTool ImageDataMD5 digest' },
+);
+
 # table to add tags in other namespaces
 %Image::ExifTool::XMP::other = (
     GROUPS => { 2 => 'Unknown' },
@@ -2838,7 +2857,7 @@ sub GetXMPTagID($;$$)
         # split name into namespace and property name
         # (Note: namespace can be '' for property qualifiers)
         my ($ns, $nm) = ($prop =~ /(.*?):(.*)/) ? ($1, $2) : ('', $prop);
-        if ($ignoreNamespace{$ns} or $ignoreProp{$prop}) {
+        if ($ignoreNamespace{$ns} or $ignoreProp{$prop} or $ignoreEtProp{$prop}) {
             # special case: don't ignore rdf numbered items
             # (not technically allowed in XMP, but used in RDF/XML)
             unless ($prop =~ /^rdf:(_\d+)$/) {
@@ -3097,7 +3116,7 @@ sub ScanForXMP($$)
             undef $buff;
         }
     }
-    unless ($$et{VALUE}{FileType}) {
+    unless ($$et{FileType}) {
         $$et{FILE_TYPE} = $$et{FILE_EXT};
         $et->SetFileType('<unknown file containing XMP>', undef, '');
     }
@@ -3408,7 +3427,10 @@ NoLoop:
             my %grps = ( 0 => $1, 1 => $2 );
             # apply a little magic to recover original group names
             # from this exiftool-written RDF/XML file
-            if ($grps{1} =~ /^\d/) {
+            if ($grps{1} eq 'System') {
+                $grps{1} = 'XML-System';
+                $grps{0} = 'XML';
+            } elsif ($grps{1} =~ /^\d/) {
                 # URI's with only family 0 are internal tags from the source file,
                 # so change the group name to avoid confusion with tags from this file
                 $grps{1} = "XML-$grps{0}";
@@ -3539,6 +3561,7 @@ NoLoop:
             DirLen   => length $$dataPt,
             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)
         );
         my $oldOrder = GetByteOrder();
         SetByteOrder($$subdir{ByteOrder}) if $$subdir{ByteOrder};
@@ -3875,7 +3898,9 @@ sub ParseXMPElement($$$;$$$$)
                 }
             }
             my $shortVal = $attrs{$shortName};
-            if ($ignoreNamespace{$ns} or $ignoreProp{$prop}) {
+            # Note: $prop is the containing property in this loop (not the shorthand property)
+            # so $ignoreProp ignores all attributes of the ignored property
+            if ($ignoreNamespace{$ns} or $ignoreProp{$prop} or $ignoreEtProp{$propName}) {
                 $ignored = $propName;
                 # handle special attributes (extract as tags only once if not empty)
                 if (ref $recognizedAttrs{$propName} and $shortVal) {
@@ -4375,8 +4400,10 @@ sub ProcessXMP($$;$)
 
     # restore structures if necessary
     if ($$et{IsStruct}) {
-        require 'Image/ExifTool/XMPStruct.pl';
-        RestoreStruct($et, $keepFlat);
+        unless ($$dirInfo{NoStruct}) {
+            require 'Image/ExifTool/XMPStruct.pl';
+            RestoreStruct($et, $keepFlat);
+        }
         delete $$et{IsStruct};
     }
     # reset NO_LIST flag (must do this _after_ RestoreStruct() above)

package/bin/exiftool_files/lib/Image/ExifTool/XMP2.pl

@@ -843,7 +843,8 @@ my %prismPublicationDate = (
     AVOID => 1,
     NOTES => q{
         Publishing Requirements for Industry Standard Metadata 3.0 namespace
-        tags.  (see L<http://www.prismstandard.org/>)
+        tags.  (see
+        L<https://www.w3.org/Submission/2020/SUBM-prism-20200910/prism-basic.html/>)
     },
     academicField   => { }, # (3.0)
     aggregateIssueNumber => { Writable => 'integer' }, # (3.0)