exiftool_vendored 10.65.0 → 11.41.0

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

@@ -15,7 +15,7 @@ use vars qw($VERSION);
 use Image::ExifTool qw(:DataAccess :Utils);
 use Image::ExifTool::Exif;
 
-$VERSION = '1.04';
+$VERSION = '1.06';
 
 sub WritePhaseOne($$$);
 sub ProcessPhaseOne($$$);
@@ -85,6 +85,7 @@ my @formatName = ( undef, 'string', 'int16s', undef, 'int32s' );
         Binary => 1,
         PutFirst => 1,
         Writable => 0,
+        Drop => 1, # don't copy to other file types
     },
     0x0110 => { #1
         Name => 'SensorCalibration',
@@ -259,6 +260,7 @@ my @formatName = ( undef, 'string', 'int16s', undef, 'int32s' );
     CHECK_PROC => \&Image::ExifTool::Exif::CheckExif,
     GROUPS => { 0 => 'MakerNotes', 2 => 'Camera' },
     TAG_PREFIX => 'SensorCalibration',
+    WRITE_GROUP => 'PhaseOne',
     VARS => { ENTRY_SIZE => 12 }, # (entries do not contain a format field)
     0x0400 => {
         Name => 'SensorDefects',
@@ -434,7 +436,7 @@ sub WritePhaseOne($$$)
 
     # nothing to do if we aren't changing any PhaseOne tags
     my $newTags = $et->GetNewTagInfoHash($tagTablePtr);
-    return undef unless %$newTags;
+    return undef unless %$newTags or $$et{DropTags} or $$et{EDIT_DIRS}{PhaseOne};
 
     my $dataPt = $$dirInfo{DataPt};
     my $dataPos = $$dirInfo{DataPos} || 0;
@@ -502,7 +504,8 @@ sub WritePhaseOne($$$)
             $valuePtr += $dirStart;
         }
         my $value = substr($$dataPt, $valuePtr, $size);
-        my $tagInfo = $$newTags{$tagID} || $et->GetTagInfo($tagTablePtr, $tagID);
+        my $tagInfo = $$newTags{$tagID} || $$tagTablePtr{$tagID};
+        $tagInfo = $et->GetTagInfo($tagTablePtr, $tagID) if $tagInfo and ref($tagInfo) ne 'HASH';
         if ($$newTags{$tagID}) {
             $formatStr = $$tagInfo{Format} if $$tagInfo{Format};
             my $count = int($size / Image::ExifTool::FormatSize($formatStr));
@@ -533,6 +536,10 @@ sub WritePhaseOne($$$)
                 $value = $newValue;
                 $size = length $newValue;
             }
+        } elsif ($$et{DropTags} and (($tagInfo and $$tagInfo{Drop}) or $size > 8192)) {
+            # decrease the number of entries in the directory
+            Set32u(Get32u(\$dirBuff, 0) - 1, \$dirBuff, 0);
+            next;   # drop this tag
         }
         # add the tagID, possibly format size, and size to this directory entry
         $dirBuff .= substr($$dataPt, $entry, $entrySize - 8) . Set32u($size);
@@ -571,7 +578,7 @@ sub ProcessPhaseOne($$$)
 {
     my ($et, $dirInfo, $tagTablePtr) = @_;
     my $dataPt = $$dirInfo{DataPt};
-    my $dataPos = $$dirInfo{DataPos} || 0;
+    my $dataPos = ($$dirInfo{DataPos} || 0) + ($$dirInfo{Base} || 0);
     my $dirStart = $$dirInfo{DirStart} || 0;
     my $dirLen = $$dirInfo{DirLen} || $$dirInfo{DataLen} - $dirStart;
     my $binary = $et->Options('Binary');
@@ -704,7 +711,7 @@ One maker notes.
 
 =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.

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

@@ -13,9 +13,8 @@ package Image::ExifTool::PhotoCD;
 use strict;
 use vars qw($VERSION);
 use Image::ExifTool qw(:DataAccess :Utils);
-use Image::ExifTool::Exif;  # (for Composite:ImageSize)
 
-$VERSION = '1.01';
+$VERSION = '1.03';
 
 sub ProcessExtData($$$);
 
@@ -411,22 +410,22 @@ sub ProcessExtData($$$);
     1538.1 => {
         Name => 'ImageWidth',
         Mask => 0x0c,
-        # 0x00=Base (768x512), 0x04=4Base (1536x1024), 0x08=16Base (3072x2048)
-        ValueConv => '($$self{Orient} & 0x01 ? 512 : 768) * (($val || 2) / 2)',
+        # 0=Base (768x512), 1=4Base (1536x1024), 2=16Base (3072x2048)
+        ValueConv => '($$self{Orient} & 0x01 ? 512 : 768) * ($val * 2 || 1)',
     },
     1538.2 => {
         Name => 'ImageHeight',
         Mask => 0x0c,
-        ValueConv => '($$self{Orient} & 0x01 ? 768 : 512) * (($val || 2) / 2)',
+        ValueConv => '($$self{Orient} & 0x01 ? 768 : 512) * ($val * 2 || 1)',
     },
     1538.3 => {
         Name => 'CompressionClass',
         Mask => 0x60,
         PrintConv => {
-            0x00 => 'Class 1 - 35mm film; Pictoral hard copy',
-            0x20 => 'Class 2 - Large format film',
-            0x40 => 'Class 3 - Text and graphics, high resolution',
-            0x60 => 'Class 4 - Text and graphics, high dynamic range',
+            0 => 'Class 1 - 35mm film; Pictoral hard copy',
+            1 => 'Class 2 - Large format film',
+            2 => 'Class 3 - Text and graphics, high resolution',
+            3 => 'Class 4 - Text and graphics, high dynamic range',
         },
     },
     #1544 => 'InterleaveRatio',
@@ -485,7 +484,7 @@ information from Kodak Photo CD Image Pac (PCD) files.
 
 =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.

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

@@ -236,7 +236,7 @@ write information written by the Camera Bits Photo Mechanic software.
 
 =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.

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

@@ -28,7 +28,7 @@ use strict;
 use vars qw($VERSION $AUTOLOAD $iptcDigestInfo);
 use Image::ExifTool qw(:DataAccess :Utils);
 
-$VERSION = '1.56';
+$VERSION = '1.63';
 
 sub ProcessPhotoshop($$$);
 sub WritePhotoshop($$$);
@@ -486,7 +486,13 @@ my %unicodeString = (
     # tags extracted from layer information
     # (tag ID's are for convenience only)
     _xcnt => { Name => 'LayerCount', Format => 'int16u' },
-    _xrct => { Name => 'LayerRectangles', List => 1, Format => 'int32u', Count => 4 },
+    _xrct => {
+        Name => 'LayerRectangles',
+        Format => 'int32u',
+        Count => 4,
+        List => 1,
+        Notes => 'top left bottom right',
+    },
     _xnam => { Name => 'LayerNames',
         Format => 'string',
         List => 1,
@@ -499,6 +505,7 @@ my %unicodeString = (
         Name => 'LayerBlendModes',
         Format => 'undef',
         List => 1,
+        RawConv => 'GetByteOrder() eq "II" ? pack "N*", unpack "V*", $val : $val',
         PrintConv => {
             pass => 'Pass Through',
             norm => 'Normal',
@@ -562,13 +569,27 @@ my %unicodeString = (
         Groups => { 2 => 'Time' },
         List => 1,
         RawConv => q{
-            return '' unless $val =~ /layerTimedoub(.{8})/s;
-            my $tmp = $1;
+            return '' unless $val =~ /layerTime(doub|buod)(.{8})/s;
+            my $tmp = $2;
             return GetDouble(\$tmp, 0);
         },
         ValueConv => 'length $val ? ConvertUnixTime($val,1) : ""',
         PrintConv => 'length $val ? $self->ConvertDateTime($val) : ""',
-    }
+    },
+);
+
+# tags extracted from ImageSourceData found in TIFF images (ref PH)
+%Image::ExifTool::Photoshop::DocumentData = (
+    PROCESS_PROC => \&ProcessDocumentData,
+    GROUPS => { 2 => 'Image' },
+    Layr => {
+        Name => 'Layers',
+        SubDirectory => { TagTable => 'Image::ExifTool::Photoshop::Layers' },
+    },
+    Lr16 => { # (NC)
+        Name => 'Layers',
+        SubDirectory => { TagTable => 'Image::ExifTool::Photoshop::Layers' },
+    },
 );
 
 # image data
@@ -626,16 +647,16 @@ sub ConvertPascalString($$)
 }
 
 #------------------------------------------------------------------------------
-# Process Photoshop layers and mask information
+# Process Photoshop layers and mask information section of PSD/PSB file
 # Inputs: 0) ExifTool ref, 1) DirInfo ref, 2) tag table ref
 # Returns: 1 on success (and seeks to the end of this section)
-sub ProcessLayers($$$)
+sub ProcessLayersAndMask($$$)
 {
     local $_;
     my ($et, $dirInfo, $tagTablePtr) = @_;
     my $raf = $$dirInfo{RAF};
     my $fileType = $$et{VALUE}{FileType};
-    my ($i, $data, $dat2, %count);
+    my $data;
 
     return 0 unless $fileType eq 'PSD' or $fileType eq 'PSB';   # (no layer section in CS1 files)
 
@@ -644,91 +665,222 @@ sub ProcessLayers($$$)
 
     # read the layer information header
     my $n = $psiz * 2 + 2;
-    my $dataPos = $raf->Tell();
     $raf->Read($data, $n) == $n or return 0;
-    my %dinfo = ( DataPt => \$data, DataPos => $dataPos );
     my $tot = $psb ? Get64u(\$data, 0) : Get32u(\$data, 0); # length of layer and mask info
-    my $len = $psb ? Get64u(\$data, $psiz) : Get32u(\$data, $psiz); # length of layer info section
-    my $num = Get16s(\$data, $psiz * 2);
+    return 1 if $tot == 0;
+    my $end = $raf->Tell() - $psiz - 2 + $tot;
+    $data = substr $data, $psiz;
+    my $len = $psb ? Get64u(\$data, 0) : Get32u(\$data, 0); # length of layer info section
+    my $num = Get16s(\$data, $psiz);
+    # check for Lr16 block if layers length is 0 (ref https://forums.adobe.com/thread/1540914)
+    if ($len == 0 and $num == 0) {
+        $raf->Read($data,10) == 10 or return 0;
+        if ($data =~/^..8BIMLr16/s) {
+            $raf->Read($data, $psiz+2) == $psiz+2 or return 0;
+            $len = $psb ? Get64u(\$data, 0) : Get32u(\$data, 0);
+        } else {
+            $raf->Seek(-10, 1) or return 0;
+        }
+    }
+    $len += 2;  # include layer count with layer info section
+    $raf->Seek(-2, 1) or return 0;
+    my %dinfo = (
+        RAF => $raf,
+        DirLen => $len,
+    );
+    $$et{IsPSB} = $psb; # set PSB flag
+    ProcessLayers($et, \%dinfo, $tagTablePtr);
+
+    # seek to the end of this section and return success flag
+    return $raf->Seek($end, 0) ? 1 : 0;
+}
+
+#------------------------------------------------------------------------------
+# Process Photoshop layers (beginning with layer count)
+# Inputs: 0) ExifTool ref, 1) DirInfo ref, 2) tag table ref
+# Returns: 1 on success
+# Notes: Uses ExifTool IsPSB member to determine whether file is PSB format
+sub ProcessLayers($$$)
+{
+    local $_;
+    my ($et, $dirInfo, $tagTablePtr) = @_;
+    my ($i, $n, %count, $buff, $buf2);
+    my $raf = $$dirInfo{RAF};
+    my $dirLen = $$dirInfo{DirLen};
+    my $verbose = $$et{OPTIONS}{Verbose};
+    my %dinfo = ( DataPt => \$buff, Base => $raf->Tell() );
+    my $pos = 0;
+    return 0 if $dirLen < 2;
+    $raf->Read($buff, 2) == 2 or return 0;
+    my $num = Get16s(\$buff, 0);
     $num = -$num if $num < 0;       # (first channel is transparency data if negative)
-    $et->HandleTag($tagTablePtr, '_xcnt', $num, Start => $psiz*2, Size => 2, %dinfo); # LayerCount
-    $et->VerboseDir('Layers', $num, $len);
-    $dataPos += $n; # point to start of layer information section
+    $et->VerboseDir('Layers', $num, $dirLen);
+    $et->HandleTag($tagTablePtr, '_xcnt', $num, Start => $pos, Size => 2, %dinfo); # LayerCount
     my $oldIndent = $$et{INDENT};
     $$et{INDENT} .= '| ';
 
-    my $pos = 0;
+    $pos += 2;
+    my $psb = $$et{IsPSB};  # is PSB format?
+    my $psiz = $psb ? 8 : 4;
     for ($i=0; $i<$num; ++$i) {
         $et->VPrint(0, $oldIndent.'+ [Layer '.($i+1)." of $num]\n");
-        last if $pos + 18 > $len;
-        # read the layer information data
-        $raf->Seek($dataPos + $pos, 0) and $raf->Read($data, 18) == 18 or last;
-        $dinfo{DataPos} = $dataPos + $pos;
+        last if $pos + 18 > $dirLen;
+        $raf->Read($buff, 18) == 18 or last;
+        $dinfo{DataPos} = $pos;
         # save the layer rectangle
-        $et->HandleTag($tagTablePtr, '_xrct', undef, Size => 16, %dinfo);
-        my $numChannels = Get16u(\$data, 16);
-        $pos += 18 + (2 + $psiz) * $numChannels;    # skip the channel information
-        last if $pos + 20 > $len;
-        $raf->Seek($dinfo{DataPos} = $dataPos + $pos, 0) or last;
-        $raf->Read($data, 20) == 20 and substr($data, 0, 4) eq '8BIM' or last; # verify signature
+        $et->HandleTag($tagTablePtr, '_xrct', undef, Start => 0, Size => 16, %dinfo);
+        my $numChannels = Get16u(\$buff, 16);
+        $n = (2 + $psiz) * $numChannels;    # size of channel information
+        $raf->Seek($n, 1) or last;
+        $pos += 18 + $n;
+        last if $pos + 20 > $dirLen;
+        $raf->Read($buff, 20) == 20 or last;
+        $dinfo{DataPos} = $pos;
+        my $sig = substr($buff, 0, 4);
+        $sig =~ /^(8BIM|MIB8)$/ or last;    # verify signature
         $et->HandleTag($tagTablePtr, '_xbnd', undef, Start => 4, Size => 4, %dinfo);
         $et->HandleTag($tagTablePtr, '_xopc', undef, Start => 8, Size => 1, %dinfo);
-        my $nxt = $pos + 16 + Get32u(\$data, 12);
-        $n = Get32u(\$data, 16);        # get size of layer mask data
+        my $nxt = $pos + 16 + Get32u(\$buff, 12);
+        $n = Get32u(\$buff, 16);        # get size of layer mask data
         $pos += 20 + $n;                # skip layer mask data
-        last if $pos + 4 > $len;
-        $raf->Seek($dataPos + $pos, 0) or last;
-        $raf->Read($data, 4) == 4 or last;
-        $n = Get32u(\$data, 0);         # get size of layer blending ranges
+        last if $pos + 4 > $dirLen;
+        $raf->Seek($n, 1) and $raf->Read($buff, 4) == 4 or last;
+        $n = Get32u(\$buff, 0);         # get size of layer blending ranges
         $pos += 4 + $n;                 # skip layer blending ranges data
-        last if $pos + 1 > $len;
-        $raf->Seek($dataPos + $pos, 0) or last;
-        $raf->Read($data, 1) == 1 or last;
-        $n = Get8u(\$data, 0);          # get length of layer name
-        last if $pos + 1 + $n > $len;
-        $raf->Read($data, $n) == $n or last;
-        $dinfo{DataPos} = $dataPos + $pos + 1;
-        $et->HandleTag($tagTablePtr, '_xnam', undef, Size => $n, %dinfo);
+        last if $pos + 1 > $dirLen;
+        $raf->Seek($n, 1) and $raf->Read($buff, 1) == 1 or last;
+        $n = Get8u(\$buff, 0);          # get length of layer name
+        last if $pos + 1 + $n > $dirLen;
+        $raf->Read($buff, $n) == $n or last;
+        $dinfo{DataPos} = $pos + 1;
+        $et->HandleTag($tagTablePtr, '_xnam', undef, Start => 0, Size => $n, %dinfo);
+        my $frag = ($n + 1) & 0x3;
+        $raf->Seek(4 - $frag, 1) or last if $frag;
         $n = ($n + 4) & 0xfffffffc;     # +1 for length byte then pad to multiple of 4 bytes
         $pos += $n;
         # process additional layer info
         while ($pos + 12 <= $nxt) {
-            $raf->Seek($dataPos + $pos, 0) and $raf->Read($data, 12) == 12 or last;
-            my $sig = substr($data, 0, 4);
+            $raf->Read($buff, 12) == 12 or last;
+            my $dat = substr($buff, 0, 8);
+            $dat = pack 'N*', unpack 'V*', $dat if GetByteOrder() eq 'II';
+            my $sig = substr($dat, 0, 4);
             last unless $sig eq '8BIM' or $sig eq '8B64';   # verify signature
-            my $tag = substr($data, 4, 4);
+            my $tag = substr($dat, 4, 4);
             # (some structures have an 8-byte size word [augh!]
             # --> it would be great if '8B64' indicated a 64-bit version, and this may well
             # be the case, but it is not mentioned in the Photoshop file format specification)
             if ($psb and $tag =~ /^(LMsk|Lr16|Lr32|Layr|Mt16|Mt32|Mtrn|Alph|FMsk|lnk2|FEid|FXid|PxSD)$/) {
                 last if $pos + 16 > $nxt;
-                $raf->Read($dat2, 4) == 4 or last;
-                $data .= $dat2;
-                $n = Get64u(\$data, 8);
+                $raf->Read($buf2, 4) == 4 or last;
+                $buff .= $buf2;
+                $n = Get64u(\$buff, 8);
                 $pos += 4;
             } else {
-                $n = Get32u(\$data, 8);
+                $n = Get32u(\$buff, 8);
             }
             $pos += 12;
             last if $pos + $n > $nxt;
-            $raf->Read($data, $n) == $n or last;
-            $dinfo{DataPos} = $dataPos + $pos;
-            # pad with empty entries if necessary to keep the same index for each item in the layer
-            $count{$tag} = 0 unless defined $count{$tag};
-            while ($count{$tag} < $i) {
-                $et->HandleTag($tagTablePtr, $tag, '');
+            $frag = $n & 0x3;
+            if ($$tagTablePtr{$tag} or $verbose) {
+                # pad with empty entries if necessary to keep the same index for each item in the layer
+                $count{$tag} = 0 unless defined $count{$tag};
+                $raf->Read($buff, $n) == $n or last;
+                $dinfo{DataPos} = $pos;
+                while ($count{$tag} < $i) {
+                    $et->HandleTag($tagTablePtr, $tag, '');
+                    ++$count{$tag};
+                }
+                $et->HandleTag($tagTablePtr, $tag, undef, Start => 0, Size => $n, %dinfo);
                 ++$count{$tag};
+                if ($frag) {
+                    $raf->Seek(4 - $frag, 1) or last;
+                    $n += 4 - $frag;    # pad to multiple of 4 bytes (PH NC)
+                }
+            } else {
+                $n += 4 - $frag if $frag;
+                $raf->Seek($n, 1) or last;
             }
-            $et->HandleTag($tagTablePtr, $tag, undef, %dinfo);
-            ++$count{$tag};
             $pos += $n; # step to start of next structure
         }
         $pos = $nxt;
     }
     $$et{INDENT} = $oldIndent;
-    # seek to the end of this section
-    return 0 unless $raf->Seek($dataPos - 2 - $psiz + $tot, 0);
-    return 1;   # success!
+    return 1;
+}
+
+#------------------------------------------------------------------------------
+# Process Photoshop ImageSourceData
+# Inputs: 0) ExifTool ref, 1) dirInfo ref, 2) tag table ref
+# Returns: 1 on success
+sub ProcessDocumentData($$$)
+{
+    my ($et, $dirInfo, $tagTablePtr) = @_;
+    my $verbose = $$et{OPTIONS}{Verbose};
+    my $raf = $$dirInfo{RAF};
+    my $dirLen = $$dirInfo{DirLen};
+    my $pos = 36;   # length of header
+    my $buff;
+
+    $et->VerboseDir('Photoshop Document Data', undef, $dirLen);
+    unless ($raf) {
+        my $dataPt = $$dirInfo{DataPt};
+        my $start = $$dirInfo{DirStart} || 0;
+        $raf = new File::RandomAccess($dataPt);
+        $raf->Seek($start, 0) if $start;
+        $dirLen = length $$dataPt - $start unless defined $dirLen;
+        $et->VerboseDump($dataPt, Start => $start, Len => $dirLen, Base => $$dirInfo{Base});
+    }
+    unless ($raf->Read($buff, $pos) == $pos and
+            $buff =~ /^Adobe Photoshop Document Data (Block|V0002)\0/)
+    {
+        $et->Warn('Invalid Photoshop Document Data');
+        return 0;
+    }
+    my $psb = ($1 eq 'V0002');
+    my %dinfo = ( DataPt => \$buff );
+    my ($n, $setOrder);
+    $$et{IsPSB} = $psb; # set PSB flag (needed when handling Layers directory)
+    while ($pos + 12 <= $dirLen) {
+        $raf->Read($buff, 8) == 8 or last;
+        # set byte order according to byte order of first signature
+        SetByteOrder($buff =~ /^(8BIM|8B64)/ ? 'MM' : 'II') if $pos == 36;
+        $buff = pack 'N*', unpack 'V*', $buff if GetByteOrder() eq 'II';
+        my $sig = substr($buff, 0, 4);
+        last unless $sig eq '8BIM' or $sig eq '8B64';   # verify signature
+        my $tag = substr($buff, 4, 4);
+        if ($psb and $tag =~ /^(LMsk|Lr16|Lr32|Layr|Mt16|Mt32|Mtrn|Alph|FMsk|lnk2|FEid|FXid|PxSD)$/) {
+            last if $pos + 16 > $dirLen;
+            $raf->Read($buff, 8) == 8 or last;
+            $n = Get64u(\$buff, 0);
+            $pos += 4;
+        } else {
+            $raf->Read($buff, 4) == 4 or last;
+            $n = Get32u(\$buff, 0);
+        }
+        $pos += 12;
+        last if $pos + $n > $dirLen;
+        my $pad = (4 - ($n & 3)) & 3;   # number of padding bytes
+        my $tagInfo = $$tagTablePtr{$tag};
+        if ($tagInfo or $verbose) {
+            if ($tagInfo and $$tagInfo{SubDirectory}) {
+                my $fpos = $raf->Tell() + $n + $pad;
+                my $subTable = GetTagTable($$tagInfo{SubDirectory}{TagTable});
+                $et->ProcessDirectory({ RAF => $raf, DirLen => $n }, $subTable);
+                $raf->Seek($fpos, 0) or last;
+            } else {
+                $dinfo{DataPos} = $raf->Tell();
+                $dinfo{Start} = 0;
+                $dinfo{Size} = $n;
+                $raf->Read($buff, $n) == $n or last;
+                $et->HandleTag($tagTablePtr, $tag, undef, %dinfo);
+                $raf->Seek($pad, 1) or last;
+            }
+        } else {
+            $raf->Seek($n + $pad, 1) or last;
+        }
+        $pos += $n + $pad;              # step to start of next structure
+    }
+    return 1;
 }
 
 #------------------------------------------------------------------------------
@@ -745,6 +897,23 @@ sub ProcessPhotoshop($$$)
     my $verbose = $et->Options('Verbose');
     my $success = 0;
 
+    # ignore non-standard XMP while in strict MWG compatibility mode
+    if (($Image::ExifTool::MWG::strict or $et->Options('Validate')) and
+        $$et{FILE_TYPE} =~ /^(JPEG|TIFF|PSD)$/)
+    {
+        my $path = $et->MetadataPath();
+        unless ($path =~ /^(JPEG-APP13-Photoshop|TIFF-IFD0-Photoshop|PSD)$/) {
+            if ($Image::ExifTool::MWG::strict) {
+                $et->Warn("Ignored non-standard Photoshop at $path");
+                return 1;
+            } else {
+                $et->Warn("Non-standard Photoshop at $path", 1);
+            }
+        }
+    }
+    if ($$et{FILE_TYPE} eq 'JPEG' and $$dirInfo{Parent} ne 'APP13') {
+        $$et{LOW_PRIORITY_DIR}{'*'} = 1;    # lower priority of all these tags
+    }
     SetByteOrder('MM');     # Photoshop is always big-endian
     $verbose and $et->VerboseDir('Photoshop', 0, $$dirInfo{DirLen});
 
@@ -809,6 +978,7 @@ sub ProcessPhotoshop($$$)
         $size += 1 if $size & 0x01; # size is padded to an even # bytes
         $pos += $size;
     }
+    delete $$et{LOW_PRIORITY_DIR}{'*'};
     return $success;
 }
 
@@ -905,7 +1075,7 @@ sub ProcessPSD($$)
         $tagTablePtr = GetTagTable('Image::ExifTool::Photoshop::Layers');
         my $oldIndent = $$et{INDENT};
         $$et{INDENT} .= '| ';
-        if (ProcessLayers($et, \%dirInfo, $tagTablePtr) and
+        if (ProcessLayersAndMask($et, \%dirInfo, $tagTablePtr) and
             # read compression mode from image data section
             $raf->Read($data,2) == 2)
         {
@@ -957,7 +1127,7 @@ be preserved when copying Photoshop information via user-defined tags.
 
 =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.