exiftool_vendored 10.65.0 → 11.41.0

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

@@ -25,6 +25,7 @@
 #               10) http://www.adobe.com/devnet/xmp/pdfs/XMPSpecificationPart2.pdf (Oct 2008)
 #               11) http://www.extensis.com/en/support/kb_article.jsp?articleNumber=6102211
 #               12) http://www.cipa.jp/std/documents/e/DC-010-2012_E.pdf
+#               13) http://www.cipa.jp/std/documents/e/DC-010-2017_E.pdf
 #
 # Notes:      - Property qualifiers are handled as if they were separate
 #               properties (with no associated namespace).
@@ -48,7 +49,7 @@ use Image::ExifTool::Exif;
 use Image::ExifTool::GPS;
 require Exporter;
 
-$VERSION = '3.07';
+$VERSION = '3.22';
 @ISA = qw(Exporter);
 @EXPORT_OK = qw(EscapeXML UnescapeXML);
 
@@ -61,7 +62,8 @@ sub EncodeBase64($;$);
 sub SaveBlankInfo($$$;$);
 sub ProcessBlankInfo($$$;$);
 sub ValidateXMP($;$);
-sub UnescapeChar($$);
+sub ValidateProperty($$);
+sub UnescapeChar($$;$);
 sub AddFlattenedTags($;$$);
 sub FormatXMPDate($);
 sub ConvertRational($);
@@ -173,8 +175,10 @@ my %xmpNS = (
     GPano     => 'http://ns.google.com/photos/1.0/panorama/',
     GSpherical=> 'http://ns.google.com/videos/1.0/spherical/',
     GDepth    => 'http://ns.google.com/photos/1.0/depthmap/',
+    GFocus    => 'http://ns.google.com/photos/1.0/focus/',
     dwc       => 'http://rs.tdwg.org/dwc/index.htm',
     GettyImagesGIFT => 'http://xmp.gettyimages.com/gift/1.0/',
+    LImage    => 'http://ns.leiainc.com/photos/1.0/image/',
 );
 
 # build reverse namespace lookup
@@ -203,6 +207,7 @@ my %uri2ns;
     # NOTE: Do NOT put "Groups" here because Groups hash must not be common!
     Writable => 'date',
     Shift => 'Time',
+    Validate => 'ValidateXMPDate($val)',
     PrintConv => '$self->ConvertDateTime($val)',
     PrintConvInv => '$self->InverseDateTime($val,undef,1)',
 );
@@ -737,6 +742,10 @@ my %sRetouchArea = (
         Name => 'GDepth',
         SubDirectory => { TagTable => 'Image::ExifTool::XMP::GDepth' },
     },
+    GFocus => {
+        Name => 'GFocus',
+        SubDirectory => { TagTable => 'Image::ExifTool::XMP::GFocus' },
+    },
     dwc => {
         Name => 'dwc',
         SubDirectory => { TagTable => 'Image::ExifTool::DarwinCore::Main' },
@@ -749,6 +758,10 @@ my %sRetouchArea = (
         Name => 'drone-dji',
         SubDirectory => { TagTable => 'Image::ExifTool::DJI::XMP' },
     },
+    LImage => {
+        Name => 'LImage',
+        SubDirectory => { TagTable => 'Image::ExifTool::XMP::LImage' },
+    },
 );
 
 # hack to allow XML containing Dublin Core metadata to be handled like XMP (eg. EPUB - see ZIP.pm)
@@ -1439,6 +1452,7 @@ my %sPantryItem = (
     PerspectiveX                        => { Writable => 'real' },
     PerspectiveY                        => { Writable => 'real' },
     UprightFourSegmentsCount            => { Writable => 'integer' },
+    AutoTone                            => { Writable => 'boolean' },
 );
 
 # Tiff namespace properties (tiff)
@@ -1450,7 +1464,7 @@ my %sPantryItem = (
     TABLE_DESC => 'XMP TIFF',
     NOTES => q{
         EXIF namespace for TIFF tags.  See
-        L<http://www.cipa.jp/std/documents/e/DC-010-2012_E.pdf> for the
+        L<http://www.cipa.jp/std/documents/e/DC-010-2017_E.pdf> for the
         specification.
     },
     ImageWidth    => { Writable => 'integer' },
@@ -1541,7 +1555,7 @@ my %sPantryItem = (
     PRIORITY => 0, # not as reliable as actual EXIF tags
     NOTES => q{
         EXIF namespace for EXIF tags.  See
-        L<http://www.cipa.jp/std/documents/e/DC-010-2012_E.pdf> for the
+        L<http://www.cipa.jp/std/documents/e/DC-010-2017_E.pdf> for the
         specification.
     },
     ExifVersion     => { },
@@ -1994,8 +2008,8 @@ my %sPantryItem = (
     NAMESPACE   => 'exifEX',
     PRIORITY => 0, # not as reliable as actual EXIF tags
     NOTES => q{
-        EXIF tags added by the EXIF 2.3 for XMP specification (see
-        L<http://www.cipa.jp/std/documents/e/DC-010-2012_E.pdf>).
+        EXIF tags added by the EXIF 2.31 for XMP specification (see
+        L<http://www.cipa.jp/std/documents/e/DC-010-2017_E.pdf>).
     },
     Gamma                       => { Writable => 'rational' },
     PhotographicSensitivity     => { Writable => 'integer' },
@@ -2063,6 +2077,13 @@ my %sPantryItem = (
             THM => 'THM - DCF thumbnail file',
         },
     },
+    # new in Exif 2.31
+    Temperature         => { Writable => 'rational', Name => 'AmbientTemperature' },
+    Humidity            => { Writable => 'rational' },
+    Pressure            => { Writable => 'rational' },
+    WaterDepth          => { Writable => 'rational' },
+    Acceleration        => { Writable => 'rational' },
+    CameraElevationAngle=> { Writable => 'rational' },
 );
 
 # Auxiliary namespace properties (aux) - not fully documented (ref PH)
@@ -2198,27 +2219,43 @@ my %sPantryItem = (
     # (used to set EXIF GPS position from XMP tags)
     GPSLatitudeRef => {
         Require => 'XMP:GPSLatitude',
+        Inhibit => 'GPSLatitudeRef',
         ValueConv => q{
             IsFloat($val[0]) and return $val[0] < 0 ? "S" : "N";
             $val[0] =~ /^.*([NS])/;
             return $1;
         },
-        PrintConv => {
-            N => 'North',
-            S => 'South',
-        },
+        PrintConv => { N => 'North', S => 'South' },
     },
     GPSLongitudeRef => {
         Require => 'XMP:GPSLongitude',
+        Inhibit => 'GPSLongitudeRef',
         ValueConv => q{
             IsFloat($val[0]) and return $val[0] < 0 ? "W" : "E";
             $val[0] =~ /^.*([EW])/;
             return $1;
         },
-        PrintConv => {
-            E => 'East',
-            W => 'West',
+        PrintConv => { E => 'East', W => 'West' },
+    },
+    GPSDestLatitudeRef => {
+        Require => 'XMP:GPSDestLatitude',
+        Inhibit => 'GPSDestLatitudeRef',
+        ValueConv => q{
+            IsFloat($val[0]) and return $val[0] < 0 ? "S" : "N";
+            $val[0] =~ /^.*([NS])/;
+            return $1;
+        },
+        PrintConv => { N => 'North', S => 'South' },
+    },
+    GPSDestLongitudeRef => {
+        Require => 'XMP:GPSDestLongitude',
+        Inhibit => 'GPSDestLongitudeRef',
+        ValueConv => q{
+            IsFloat($val[0]) and return $val[0] < 0 ? "W" : "E";
+            $val[0] =~ /^.*([EW])/;
+            return $1;
         },
+        PrintConv => { E => 'East', W => 'West' },
     },
     LensID => {
         Notes => 'attempt to convert numerical XMP-aux:LensID stored by Adobe applications',
@@ -2301,13 +2338,14 @@ sub EscapeXML($)
 # Unescape XML character references (entities and numerical)
 # Inputs: 0) string to be unescaped
 #         1) optional hash reference to convert entity names to numbers
+#         2) optional character encoding
 # Returns: unescaped string
 my %charNum = ('quot'=>34, 'amp'=>38, 'apos'=>39, 'lt'=>60, 'gt'=>62);
-sub UnescapeXML($;$)
+sub UnescapeXML($;$$)
 {
-    my ($str, $conv) = @_;
+    my ($str, $conv, $enc) = @_;
     $conv = \%charNum unless $conv;
-    $str =~ s/&(#?\w+);/UnescapeChar($1,$conv)/sge;
+    $str =~ s/&(#?\w+);/UnescapeChar($1,$conv,$enc)/sge;
     return $str;
 }
 
@@ -2345,10 +2383,11 @@ sub FullUnescapeXML($)
 # Convert XML character reference to UTF-8
 # Inputs: 0) XML character reference stripped of the '&' and ';' (eg. 'quot', '#34', '#x22')
 #         1) hash reference for looking up character numbers by name
+#         2) optional character encoding (default 'UTF8')
 # Returns: UTF-8 equivalent (or original character on conversion error)
-sub UnescapeChar($$)
+sub UnescapeChar($$;$)
 {
-    my ($ch, $conv) = @_;
+    my ($ch, $conv, $enc) = @_;
     my $val = $$conv{$ch};
     unless (defined $val) {
         if ($ch =~ /^#x([0-9a-fA-F]+)$/) {
@@ -2360,8 +2399,9 @@ sub UnescapeChar($$)
         }
     }
     return chr($val) if $val < 0x80;   # simple ASCII
-    return pack('C0U', $val) if $] >= 5.006001;
-    return Image::ExifTool::PackUTF8($val);
+    $val = $] >= 5.006001 ? pack('C0U', $val) : Image::ExifTool::PackUTF8($val);
+    $val = Image::ExifTool::Decode(undef, $val, 'UTF8', undef, $enc) if $enc and $enc ne 'UTF8';
+    return $val;
 }
 
 #------------------------------------------------------------------------------
@@ -2395,7 +2435,17 @@ sub IsUTF8($)
             # were required in the UTF-8 character
             $rtnVal = 2;
         }
-        return -1 unless $$strPt =~ /\G[\x80-\xbf]{$n}/g;
+        return -1 unless $$strPt =~ /\G([\x80-\xbf]{$n})/g;
+        # the following is ref https://www.cl.cam.ac.uk/%7Emgk25/ucs/utf8_check.c
+        if ($n == 2) {
+            return -1 if ($ch == 0xe0 and (ord($1) & 0xe0) == 0x80) or
+                         ($ch == 0xed and (ord($1) & 0xe0) == 0xa0) or
+                         ($ch == 0xef and ord($1) == 0xbf and
+                            (ord(substr $1, 1) & 0xfe) == 0xbe);
+        } else {
+            return -1 if ($ch == 0xf0 and (ord($1) & 0xf0) == 0x80) or
+                         ($ch == 0xf4 and ord($1) > 0x8f) or $ch > 0xf4;
+        }
         last unless $$strPt =~ /([\x80-\xff])/g;
     }
     return $rtnVal;
@@ -2418,7 +2468,18 @@ sub FixUTF8($;$)
         # (see comments in IsUTF8() above)
         if ($ch >= 0xc2 and $ch < 0xf8) {
             my $n = $ch < 0xe0 ? 1 : ($ch < 0xf0 ? 2 : 3);
-            next if $$strPt =~ /\G[\x80-\xbf]{$n}/g;
+            if ($$strPt =~ /\G([\x80-\xbf]{$n})/g) {
+                next if $n == 1;
+                if ($n == 2) {
+                    next unless ($ch == 0xe0 and (ord($1) & 0xe0) == 0x80) or
+                                ($ch == 0xed and (ord($1) & 0xe0) == 0xa0) or
+                                ($ch == 0xef and ord($1) == 0xbf and
+                                    (ord(substr $1, 1) & 0xfe) == 0xbe);
+                } else {
+                    next unless ($ch == 0xf0 and (ord($1) & 0xf0) == 0x80) or
+                                ($ch == 0xf4 and ord($1) > 0x8f) or $ch > 0xf4;
+                }
+            }
         }
         # replace bad character
         $bad = '?' unless defined $bad;
@@ -2480,6 +2541,7 @@ sub GetXMPTagID($;$$)
         my ($ns, $nm) = ($prop =~ /(.*?):(.*)/) ? ($1, $2) : ('', $prop);
         if ($ignoreNamespace{$ns} or $ignoreProp{$prop}) {
             # special case: don't ignore rdf numbered items
+            # (not technically allowed in XMP, but used in RDF/XML)
             unless ($prop =~ /^rdf:(_\d+)$/) {
                 # save list index if necessary for structures
                 if ($structProps and @$structProps and $prop =~ /^rdf:li (\d+)$/) {
@@ -2544,7 +2606,7 @@ sub RegisterNamespace($)
         while (@ns) {
             $ns = pop @ns;
             if ($nsURI{$ns} and $nsURI{$ns} ne $$nsRef{$ns}) {
-                warn "User-defined namespace prefix '$ns' conflicts with existing namespace\n";
+                warn "User-defined namespace prefix '${ns}' conflicts with existing namespace\n";
             }
             $nsURI{$ns} = $$nsRef{$ns};
             $uri2ns{$$nsRef{$ns}} = $ns;
@@ -3106,6 +3168,26 @@ NoLoop:
     my $key = $et->FoundTag($tagInfo, $val) or return 0;
     # save original components of rational numbers (used when copying)
     $$et{RATIONAL}{$key} = $rational if defined $rational;
+    # allow read-only subdirectories (eg. embedded base64 XMP/IPTC in NKSC files)
+    if ($$tagInfo{SubDirectory} and not $$et{IsWriting}) {
+        my $subdir = $$tagInfo{SubDirectory};
+        my $dataPt = ref $$et{VALUE}{$key} ? $$et{VALUE}{$key} : \$$et{VALUE}{$key};
+        # process subdirectory information
+        my %dirInfo = (
+            DirName  => $$subdir{DirName} || $$tagInfo{Name},
+            DataPt   => $dataPt,
+            DirLen   => length $$dataPt,
+            IsExtended => 1, # (hack to avoid Duplicate warning for embedded XMP)
+        );
+        my $oldOrder = GetByteOrder();
+        SetByteOrder($$subdir{ByteOrder}) if $$subdir{ByteOrder};
+        my $oldNS = $$et{definedNS};
+        delete $$et{definedNS};
+        my $subTablePtr = GetTagTable($$subdir{TagTable}) || $tagTablePtr;
+        $et->ProcessDirectory(\%dirInfo, $subTablePtr, $$subdir{ProcessProc});
+        SetByteOrder($oldOrder);
+        $$et{definedNS} = $oldNS;
+    }
     # save structure/list information if necessary
     if (@structProps and (@structProps > 1 or defined $structProps[0][1]) and
         not $$et{NO_STRUCT})
@@ -3137,11 +3219,13 @@ NoLoop:
 # Returns: Number of contained XMP elements
 sub ParseXMPElement($$$;$$$$)
 {
-    my ($et, $tagTablePtr, $dataPt, $start, $end, $propListPt, $blankInfo) = @_;
+    local $_;
+    my ($et, $tagTablePtr, $dataPt, $start, $end, $propList, $blankInfo) = @_;
     my ($count, $nItems) = (0, 0);
     my $isWriting = $$et{XMP_CAPTURE};
     my $isSVG = $$et{XMP_IS_SVG};
     my $saveNS;     # save xlatNS lookup if changed for the scope of this element
+    my (%definedNS, %usedNS);  # namespaces defined and used in this scope
 
     # get our parse procs
     my ($attrProc, $foundProc);
@@ -3153,7 +3237,7 @@ sub ParseXMPElement($$$;$$$$)
     }
     $start or $start = 0;
     $end or $end = length $$dataPt;
-    $propListPt or $propListPt = [ ];
+    $propList or $propList = [ ];
 
     my $processBlankInfo;
     # create empty blank node information hash if necessary
@@ -3225,6 +3309,8 @@ sub ParseXMPElement($$$;$$$$)
                 if ($1 eq 'xmlns') {
                     my $ns = substr($attr, 6);
                     my $stdNS = $uri2ns{$val};
+                    # keep track of namespace prefixes defined in this scope (for Validate)
+                    $$et{definedNS}{$ns} = $definedNS{$ns} = 1 unless $$et{definedNS}{$ns};
                     unless ($stdNS) {
                         my $try = $val;
                         # patch for Nikon NX2 URI bug for Microsoft PhotoInfo namespace
@@ -3280,26 +3366,36 @@ sub ParseXMPElement($$$;$$$$)
                             # use the new namespace prefix
                             $$xlatNS{$ns} = $newNS;
                             $attr = 'xmlns:' . $newNS;
+                            # must go through previous attributes and change prefixes if necessary
+                            foreach (@attrs) {
+                                next unless /(.*?):/ and $1 eq $ns and $1 ne $newNS;
+                                my $newAttr = $newNS . substr($_, length($ns));
+                                $attrs{$newAttr} = $attrs{$_};
+                                delete $attrs{$_};
+                                $_ = $newAttr;
+                            }
                         } else {
                             delete $$xlatNS{$ns};
                         }
                     }
-                } elsif ($$xlatNS{$1}) {
-                    $attr = $$xlatNS{$1} . substr($attr, length($1));
+                } else {
+                    $attr = $$xlatNS{$1} . substr($attr, length($1)) if $$xlatNS{$1};
+                    $usedNS{$1} = 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 =~ /(.*?):/) {
+            $usedNS{$1} = 1;
+            # tame wild namespace prefixes (patch for Microsoft stupidity)
+            $prop = $$xlatNS{$1} . substr($prop, length($1)) if $$xlatNS{$1};
         }
 
         if ($prop eq 'rdf:li') {
             # impose a reasonable maximum on the number of items in a list
             if ($nItems == 1000) {
-                my ($tg,$ns) = GetXMPTagID($propListPt);
+                my ($tg,$ns) = GetXMPTagID($propList);
                 if ($isWriting) {
                     $et->Warn("Excessive number of items for $ns:$tg. Processing may be slow", 1);
                 } elsif (not $$et{OPTIONS}{IgnoreMinorErrors}) {
@@ -3318,17 +3414,18 @@ sub ParseXMPElement($$$;$$$$)
             $prop .= ' ' . length($nItems) . $nItems;
             # reset LIST_TAGS at the start of the outtermost list
             # (avoids accumulating incorrectly-written elements in a correctly-written list)
-            if (not $nItems and not grep /^rdf:li /, @$propListPt) {
+            if (not $nItems and not grep /^rdf:li /, @$propList) {
                 $$et{LIST_TAGS} = { };
             }
             ++$nItems;
         } elsif ($prop eq 'rdf:Description') {
             # remove unnecessary rdf:Description elements since parseType='Resource'
             # is more efficient (also necessary to make property path consistent)
-            $parseResource = 1 if grep /^rdf:Description$/, @$propListPt;
+            $parseResource = 1 if grep /^rdf:Description$/, @$propList;
         } elsif ($prop eq 'xmp:xmpmeta') {
             # patch MicrosoftPhoto unconformity
             $prop = 'x:xmpmeta';
+            $et->Warn('Wrong namespace for xmpmeta') if $$et{XmpValidate};
         }
 
         # hook for special parsing of attributes
@@ -3350,19 +3447,19 @@ sub ParseXMPElement($$$;$$$$)
         }
 
         # push this property name onto our hierarchy list
-        push @$propListPt, $prop unless $parseResource;
+        push @$propList, $prop unless $parseResource;
 
         if ($isSVG) {
             # ignore everything but top level SVG tags and metadata unless Unknown set
             unless ($$et{OPTIONS}{Unknown} > 1 or $$et{OPTIONS}{Verbose}) {
-                if (@$propListPt > 1 and $$propListPt[1] !~ /\b(metadata|desc|title)$/) {
-                    pop @$propListPt;
+                if (@$propList > 1 and $$propList[1] !~ /\b(metadata|desc|title)$/) {
+                    pop @$propList;
                     next;
                 }
             }
             if ($prop eq 'svg' or $prop eq 'metadata') {
                 # add svg namespace prefix if missing to ignore these entries in the tag name
-                $$propListPt[-1] = "svg:$prop";
+                $$propList[-1] = "svg:$prop";
             }
         }
 
@@ -3387,6 +3484,21 @@ sub ParseXMPElement($$$;$$$$)
                 $ns = '';
                 $name = $propName;
             }
+            if ($propName eq 'rdf:about') {
+                if (not $$et{XmpAbout}) {
+                    $$et{XmpAbout} = $attrs{$shortName};
+                } elsif ($$et{XmpAbout} ne $attrs{$shortName}) {
+                    if ($isWriting) {
+                        my $str = "Different 'rdf:about' attributes not handled";
+                        unless ($$et{WARNED_ONCE}{$str}) {
+                            $et->Error($str, 1);
+                            $$et{WARNED_ONCE}{$str} = 1;
+                        }
+                    } elsif ($$et{XmpValidate}) {
+                        $et->WarnOnce("Different 'rdf:about' attributes");
+                    }
+                }
+            }
             if ($isWriting) {
                 # keep track of our namespaces when writing
                 if ($ns eq 'xmlns') {
@@ -3398,14 +3510,6 @@ sub ParseXMPElement($$$;$$$$)
                     delete $attrs{$shortName};  # (handled by namespace logic)
                     next;
                 } elsif ($recognizedAttrs{$propName}) {
-                    # save UUID to use same ID when writing
-                    if ($propName eq 'rdf:about') {
-                        if (not $$et{XMP_ABOUT}) {
-                            $$et{XMP_ABOUT} = $attrs{$shortName};
-                        } elsif ($$et{XMP_ABOUT} ne $attrs{$shortName}) {
-                            $et->Error("Different 'rdf:about' attributes not handled", 1);
-                        }
-                    }
                     next;
                 }
             }
@@ -3423,25 +3527,26 @@ sub ParseXMPElement($$$;$$$$)
                 next;
             }
             delete $attrs{$shortName};  # don't re-use this attribute
-            push @$propListPt, $propName;
+            push @$propList, $propName;
             # save this shorthand XMP property
             if (defined $nodeID) {
-                SaveBlankInfo($blankInfo, $propListPt, $shortVal);
+                SaveBlankInfo($blankInfo, $propList, $shortVal);
             } elsif ($isWriting) {
-                CaptureXMP($et, $propListPt, $shortVal);
+                CaptureXMP($et, $propList, $shortVal);
             } else {
-                &$foundProc($et, $tagTablePtr, $propListPt, $shortVal);
+                ValidateProperty($et, $propList) if $$et{XmpValidate};
+                &$foundProc($et, $tagTablePtr, $propList, $shortVal);
             }
-            pop @$propListPt;
+            pop @$propList;
             $shorthand = 1;
         }
         if ($isWriting) {
             if (ParseXMPElement($et, $tagTablePtr, $dataPt, $valStart, $valEnd,
-                                $propListPt, $blankInfo))
+                                $propList, $blankInfo))
             {
                 # (no value since we found more properties within this one)
                 # set an error on any ignored attributes here, because they will be lost
-                $$et{XMP_ERROR} = "Can't handle XMP attribute '$ignored'" if $ignored;
+                $$et{XMP_ERROR} = "Can't handle XMP attribute '${ignored}'" if $ignored;
             } elsif (not $shorthand or $valEnd != $valStart) {
                 $val = substr($$dataPt, $valStart, $valEnd - $valStart);
                 # remove comments and whitespace from rdf:Description only
@@ -3449,16 +3554,16 @@ sub ParseXMPElement($$$;$$$$)
                     $val =~ s/<!--.*?-->//g; $val =~ s/^\s+//; $val =~ s/\s+$//;
                 }
                 if (defined $nodeID) {
-                    SaveBlankInfo($blankInfo, $propListPt, $val, \%attrs);
+                    SaveBlankInfo($blankInfo, $propList, $val, \%attrs);
                 } else {
-                    CaptureXMP($et, $propListPt, $val, \%attrs);
+                    CaptureXMP($et, $propList, $val, \%attrs);
                 }
             }
         } else {
             # look for additional elements contained within this one
             if ($valStart == $valEnd or
                 !ParseXMPElement($et, $tagTablePtr, $dataPt, $valStart, $valEnd,
-                                 $propListPt, $blankInfo))
+                                 $propList, $blankInfo))
             {
                 my $wasEmpty;
                 unless (defined $val) {
@@ -3467,10 +3572,10 @@ sub ParseXMPElement($$$;$$$$)
                     if ($prop eq 'rdf:Description' and $val) {
                         $val =~ s/<!--.*?-->//g; $val =~ s/^\s+//; $val =~ s/\s+$//;
                     }
-                    # if element value is empty, take value from 'resource' attribute
-                    # (preferentially) or 'about' attribute (if no 'resource')
-                    if ($val eq '' and ($attrs =~ /\bresource=(['"])(.*?)\1/ or
-                                        $attrs =~ /\babout=(['"])(.*?)\1/))
+                    # if element value is empty, take value from RDF 'value' or 'resource' attribute
+                    # (preferentially) or 'about' attribute (if no 'value' or 'resource')
+                    if ($val eq '' and ($attrs =~ /\brdf:(?:value|resource)=(['"])(.*?)\1/ or
+                                        $attrs =~ /\brdf:about=(['"])(.*?)\1/))
                     {
                         $val = $2;
                         $wasEmpty = 1;
@@ -3479,22 +3584,41 @@ sub ParseXMPElement($$$;$$$$)
                 # there are no contained elements, so this must be a simple property value
                 # (unless we already extracted shorthand values from this element)
                 if (length $val or not $shorthand) {
-                    my $lastProp = $$propListPt[-1];
+                    my $lastProp = $$propList[-1];
                     if (defined $nodeID) {
-                        SaveBlankInfo($blankInfo, $propListPt, $val);
+                        SaveBlankInfo($blankInfo, $propList, $val);
                     } elsif ($lastProp eq 'rdf:type' and $wasEmpty) {
                         # do not extract empty structure types (for now)
                     } elsif ($lastProp =~ /^et:(desc|prt|val)$/ and ($count or $1 eq 'desc')) {
                         # ignore et:desc, and et:val if preceded by et:prt
                         --$count;
                     } else {
-                        &$foundProc($et, $tagTablePtr, $propListPt, $val, \%attrs);
+                        ValidateProperty($et, $propList) if $$et{XmpValidate};
+                        &$foundProc($et, $tagTablePtr, $propList, $val, \%attrs);
                     }
                 }
             }
         }
-        pop @$propListPt unless $parseResource;
+        pop @$propList unless $parseResource;
         ++$count;
+
+        # validate namespace prefixes used at this level if necessary
+        if ($$et{XmpValidate}) {
+            foreach (sort keys %usedNS) {
+                next if $$et{definedNS}{$_} or $_ eq 'xml';
+                if (defined $$et{definedNS}{$_}) {
+                    $et->Warn("XMP namespace $_ is used out of scope");
+                } else {
+                    $et->Warn("Undefined XMP namespace: $_");
+                }
+                $$et{definedNS}{$_} = -1;  # (don't warn again for this namespace)
+            }
+            # reset namespaces that went out of scope
+            $$et{definedNS}{$_} = 0 foreach keys %definedNS;
+            undef %usedNS;
+            undef %definedNS;
+        }
+
         last if $start >= $end;
         pos($$dataPt) = $start;
         $$dataPt =~ /\G\s+/gc;  # skip white space after closing token
@@ -3540,19 +3664,30 @@ sub ProcessXMP($$;$)
     $$et{curURI} = { };
     $$et{curNS}  = { };
     $$et{xlatNS} = { };
+    $$et{definedNS} = { };
+    delete $$et{XmpAbout};
+    delete $$et{XmpValidate};   # don't validate by default
 
     # ignore non-standard XMP while in strict MWG compatibility mode
-    if (($Image::ExifTool::MWG::strict or $et->Options('Validate')) and not $$et{XMP_CAPTURE} and
-        $$et{FILE_TYPE} =~ /^(JPEG|TIFF|PSD)$/)
+    if (($Image::ExifTool::MWG::strict or $$et{OPTIONS}{Validate}) and
+        not ($$et{XMP_CAPTURE} or $$et{DOC_NUM}) and
+        (($$dirInfo{DirName} || '') eq 'XMP' or $$et{FILE_TYPE} eq 'XMP'))
     {
+        $$et{XmpValidate} = { } if $$et{OPTIONS}{Validate};
         my $path = $et->MetadataPath();
-        unless ($path =~ /^(JPEG-APP1-XMP|TIFF-IFD0-XMP|PSD-XMP)$/) {
-            if ($Image::ExifTool::MWG::strict) {
-                $et->Warn("Ignored non-standard XMP at $path");
-                return 1;
-            } else {
-                $et->Warn("Non-standard XMP at $path", 1);
-            }
+        my $nonStd;
+        if ($$et{FILE_TYPE} =~ /^(JPEG|TIFF|PSD)$/ and $path !~ /^(JPEG-APP1-XMP|TIFF-IFD0-XMP|PSD-XMP)$/) {
+            $nonStd = 1;
+        }
+        if ($nonStd and $Image::ExifTool::MWG::strict) {
+            $et->Warn("Ignored non-standard XMP at $path");
+            return 1;
+        }
+        if ($nonStd) {
+            $et->Warn("Non-standard XMP at $path", 1);
+        } elsif (not $$dirInfo{IsExtended}) {
+            $et->Warn("Duplicate XMP at $path") if $$et{DIR_COUNT}{XMP};
+            $$et{DIR_COUNT}{XMP} = ($$et{DIR_COUNT}{XMP} || 0) + 1; # count standard XMP
         }
     }
     if ($dataPt) {
@@ -3563,7 +3698,7 @@ sub ProcessXMP($$;$)
         pos($$dataPt) = $dirStart;
         $double = $1 if $$dataPt =~ /\G((\0\0)?\xfe\xff|\xff\xfe(\0\0)?|\xef\xbb\xbf)\0*<\0*\?\0*x\0*p\0*a\0*c\0*k\0*e\0*t/g;
     } else {
-        my ($type, $buf2, $buf3);
+        my ($type, $mime, $buf2, $buf3);
         # read information from XMP file
         my $raf = $$dirInfo{RAF} or return 0;
         $raf->Read($buff, 256) or return 0;
@@ -3603,6 +3738,7 @@ sub ProcessXMP($$;$)
             $bom = 1 if $1;
             if ($2 eq '<?xml') {
                 if (defined $fmt and not $fmt and $buf2 =~ /^[^\n\r]*[\n\r]+<\?aid /s) {
+                    undef $$et{XmpValidate};    # don't validate INX
                     if ($$et{XMP_CAPTURE}) {
                         $et->Error("ExifTool does not yet support writing of INX files");
                         return 0;
@@ -3611,6 +3747,7 @@ sub ProcessXMP($$;$)
                 } elsif ($buf2 =~ /<x(mp)?:x[ma]pmeta/) {
                     $hasXMP = 1;
                 } else {
+                    undef $$et{XmpValidate};    # don't validate XML
                     # identify SVG images and PLIST files by DOCTYPE if available
                     if ($buf2 =~ /<!DOCTYPE\s+(\w+)/) {
                         if ($1 eq 'svg') {
@@ -3619,6 +3756,7 @@ sub ProcessXMP($$;$)
                             $type = 'PLIST';
                         } elsif ($1 eq 'REDXIF') {
                             $type = 'RMD';
+                            $mime = 'application/xml';
                         } else {
                             return 0;
                         }
@@ -3667,7 +3805,7 @@ sub ProcessXMP($$;$)
                 $type = $ext if $ext and $ext eq 'COS'; # recognize COS by extension
             }
         }
-        $et->SetFileType($type);
+        $et->SetFileType($type, $mime);
 
         my $fast = $et->Options('FastScan');
         return 1 if $fast and $fast == 3;
@@ -3739,7 +3877,8 @@ sub ProcessXMP($$;$)
     # extract XMP as a block if specified
     my $blockName = $$dirInfo{BlockInfo} ? $$dirInfo{BlockInfo}{Name} : 'XMP';
     if (($$et{REQ_TAG_LOOKUP}{lc $blockName} or ($$et{TAGS_FROM_FILE} and
-        not $$et{EXCL_TAG_LOOKUP}{lc $blockName})) and not $isSVG)
+        not $$et{EXCL_TAG_LOOKUP}{lc $blockName})) and
+        ($$dirInfo{DirName} and $$dirInfo{DirName} eq 'XMP'))
     {
         $et->FoundTag($$dirInfo{BlockInfo} || 'XMP', substr($$dataPt, $dirStart, $dirLen));
     }
@@ -3874,6 +4013,7 @@ sub ProcessXMP($$;$)
     delete $$et{curURI};
     delete $$et{curNS};
     delete $$et{xlatNS};
+    delete $$et{definedNS};
 
     return $rtnVal;
 }
@@ -3900,7 +4040,7 @@ information.
 
 =head1 AUTHOR
 
-Copyright 2003-2017, Phil Harvey (phil at owl.phy.queensu.ca)
+Copyright 2003-2019, Phil Harvey (phil at owl.phy.queensu.ca)
 
 This library is free software; you can redistribute it and/or modify it
 under the same terms as Perl itself.