exiftool_vendored 13.16.0 → 13.17.0

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

@@ -0,0 +1,318 @@
+#------------------------------------------------------------------------------
+# File:         Trailer.pm
+#
+# Description:  Read JPEG trailer written by various makes of phone
+#
+# Revisions:    2025-01-27 - P. Harvey Created
+#------------------------------------------------------------------------------
+
+package Image::ExifTool::Trailer;
+
+use strict;
+use vars qw($VERSION);
+use Image::ExifTool qw(:DataAccess :Utils);
+
+$VERSION = '1.00';
+
+%Image::ExifTool::Trailer::Vivo = (
+    GROUPS => { 0 => 'Trailer', 1 => 'Vivo', 2 => 'Image' },
+    VARS => { NO_ID => 1 },
+    NOTES => 'Information written in JPEG trailer by some Vivo phones.',
+    # (don't know for sure what type of image this is, but it is in JPEG format)
+    HDRImage => {
+        Notes => 'highlights of HDR image',
+        Groups => { 2 => 'Preview' },
+        Binary => 1,
+    },
+    JSONInfo => { },
+    HiddenData => {
+        Notes => 'hidden in EXIF, not in trailer.  This data is lost if the file is edited',
+        Groups => { 0 => 'EXIF' },
+    },
+);
+
+%Image::ExifTool::Trailer::OnePlus = (
+    GROUPS => { 0 => 'Trailer', 1 => 'OnePlus', 2 => 'Image' },
+    NOTES => 'Information written in JPEG trailer by some OnePlus phones.',
+    JSONInfo => { },
+    'private.emptyspace' => { # length of the entire OnePlus trailer
+        Name => 'OnePlusTrailerLen',
+        ValueConv => 'length $val == 4 ? unpack("N", $val) : $val',
+        Unknown => 1,
+    },
+    'watermark.device' => {
+        Name => 'Device',
+        ValueConv => '"0x" . join(" ", unpack("H10Z*", $val))',
+        Format => 'string',
+    },
+);
+
+# Google and/or Android information in JPEG trailer
+%Image::ExifTool::Trailer::Google = (
+    GROUPS => { 0 => 'Trailer', 1 => 'Google', 2 => 'Image' },
+    NOTES => q{
+        Google-defined information written in the trailer of JPEG images by some
+        phones.  This information is referenced by DirectoryItem entries in the XMP.
+        Note that some of this information may also be referenced from other
+        metadata formats, and hence may be extracted twice.  For example,
+        MotionPhotoVideo may also exist within a Samsung trailer as
+        EmbbededVideoFile, or GainMapImage may also exist in an MPF trailer as
+        MPImage2.
+    },
+    MotionPhoto        => { Name => 'MotionPhotoVideo',  Groups => { 2 => 'Video' } },
+    GainMap            => { Name => 'GainMapImage',      Groups => { 2 => 'Preview' } },
+    Depth              => { Name => 'DepthMapImage',     Groups => { 2 => 'Preview' } },
+    Confidence         => { Name => 'ConfidenceMapImage',Groups => { 2 => 'Preview' } },
+    'android/depthmap' => { Name => 'DepthMapImage',     Groups => { 2 => 'Preview' } },
+    'android/confidencemap' => { Name => 'ConfidenceMapImage', Groups => { 2 => 'Preview' } },
+);
+
+#------------------------------------------------------------------------------
+# Process Vivo trailer
+# Inputs: 0) ExifTool object reference, 1) dirInfo reference
+# Returns: 1 on success, 0 on failure, -1 if we must scan for the start
+#          of the trailer to set the ExifTool TrailerStart member
+# - takes Offset as positive offset from end of trailer to end of file,
+#   and returns DataPos and DirLen, and updates OutFile when writing
+sub ProcessVivo($$)
+{
+    my ($et, $dirInfo) = @_;
+    my $raf = $$dirInfo{RAF};
+    my $buff;
+
+    # return now unless we are at a position to scan for the trailer
+    # (must scan because the trailer footer doesn't indicate the trailer length)
+    return -1 unless $$dirInfo{ScanForTrailer};
+
+    my $pos = $$et{TrailerStart} or return 0;
+    my $len = $$et{FileEnd} - $pos - $$dirInfo{Offset};
+    $raf->Seek($pos, 0) or return 0;
+    return 0 unless $len > 0 and $len < 1e7 and $raf->Read($buff, $len) == $len and
+        $buff =~ /\xff{4}\x1b\*9HWfu\x84\x93\xa2\xb1$/ and # validate footer
+        $buff =~ /(streamdata|vivo\{")/g;   # find start
+    my $start = pos($buff) - length($1);
+    if ($start) {
+        $pos += $start;
+        $len -= $start;
+        $buff = substr($buff, $start);
+    }
+    # set trailer position and length 
+    @$dirInfo{'DataPos','DirLen'} = ($pos, $len);
+
+    # let ProcessTrailers copy or delete this trailer
+    return -1 if $$dirInfo{OutFile};
+
+    $et->DumpTrailer($dirInfo) if $$et{OPTIONS}{Verbose} or $$et{HTML_DUMP};
+    my $tbl = GetTagTable('Image::ExifTool::Trailer::Vivo');
+    pos($buff) = 0; # rewind search to start of buffer
+    if ($buff =~ /^streamdata\xff\xd8\xff/ and $buff =~ /\xff\xd9stream(info|coun)/g) {
+        $et->HandleTag($tbl, HDRImage => substr($buff, 10, pos($buff)-20));
+    }
+    # continue looking for Vivo JSON data
+    if ($buff =~ /vivo\{"/g) {
+        my $jsonStart = pos($buff) - 2;
+        if ($buff =~ /\}\0/g) {
+            my $jsonLen = pos($buff) - 1 - $jsonStart;
+            $et->HandleTag($tbl, JSONInfo => substr($buff, $jsonStart, $jsonLen));
+        }
+    }
+    return 1;
+}
+
+#------------------------------------------------------------------------------
+# Process OnePlus trailer
+# Inputs: 0) ExifTool object reference, 1) dirInfo reference
+# Returns: 1 on success, 0 on failure, -1 if we must scan for the start
+#          of the trailer to set the ExifTool TrailerStart member
+# - takes Offset as positive offset from end of trailer to end of file,
+#   and returns DataPos and DirLen, and updates OutFile when writing
+sub ProcessOnePlus($$)
+{
+    my ($et, $dirInfo) = @_;
+    my $raf = $$dirInfo{RAF};
+    my ($buff, $buf2);
+
+    # return now unless we are at a position to scan for the trailer
+    # (must scan because the trailer footer doesn't indicate the entire trailer length)
+    return -1 unless $$dirInfo{ScanForTrailer};
+
+    # return -1 to let ProcessTrailers copy or delete the entire trailer
+    return -1 if $$dirInfo{OutFile};
+
+    my $start = $$et{TrailerStart} or return 0;
+    $raf->Seek(-8-$$dirInfo{Offset}, 2) and $raf->Read($buff, 8) == 8 or return 0;
+    my $end = $raf->Tell(); # (same as FileEnd - Offset)
+
+    my $dump = ($$et{OPTIONS}{Verbose} or $$et{HTML_DUMP});
+    my $tagTable = GetTagTable('Image::ExifTool::Trailer::OnePlus');
+    my $trailLen = 0;
+    if ($buff =~ /^jxrs...\0$/) {
+        my $jlen = unpack('x4V', $buff);
+        my $maxOff = 0;
+        if ($jlen < $end-$start and $jlen > 8 and $raf->Seek($end-$jlen) and
+            $raf->Read($buff, $jlen-8) == $jlen-8)
+        {
+            $buff =~ s/\0+$//;  # remove trailing null(s)
+            require Image::ExifTool::Import;
+            my $list = Image::ExifTool::Import::ReadJSONObject(undef, \$buff);
+            if (ref $list eq 'ARRAY') {
+                $$_{offset} and $$_{offset} > $maxOff and $maxOff = $$_{offset} foreach @$list;
+                $trailLen = $maxOff + $jlen;
+                if ($dump and $trailLen) {
+                    $et->DumpTrailer({
+                        RAF     => $raf,
+                        DirName => 'OnePlus',
+                        DataPos => $end-$trailLen,
+                        DirLen  => $trailLen,
+                    });
+                }
+                $et->HandleTag($tagTable, JSONInfo => $buff);
+                foreach (@$list) {
+                    my ($off, $name, $len) = @$_{qw(offset name length)};
+                    next unless $off and $name and $len;
+                    if ($raf->Seek($end-$jlen-$off) and $raf->Read($buf2, $len) == $len) {
+                        $et->HandleTag($tagTable, $name, $buf2, DataPos => $end-$jlen-$off, DataPt => \$buf2);
+                    }
+                }
+            } else {
+                $et->HandleTag($tagTable, JSONInfo => $buff);
+                $et->Warn('Error parsing OnePlus JSON information');
+            }
+        }
+    }
+    @$dirInfo{'DataPos','DirLen'} = ($end - $trailLen, $trailLen);
+
+    return 1;
+}
+
+#------------------------------------------------------------------------------
+# Process Google trailer
+# Inputs: 0) ExifTool object reference, 1) dirInfo reference
+# Returns: 1 on success, 0 on failure, -1 if we must scan for the start
+#          of the trailer to set the ExifTool TrailerStart member
+# - this trailer won't be identified when writing because XMP isn't extracted then
+sub ProcessGoogle($$)
+{
+    my ($et, $dirInfo) = @_;
+    my $raf = $$dirInfo{RAF};
+    my $info = $$et{VALUE};
+
+    my ($tag, $mime, $len, $pad) = @$info{qw(DirectoryItemSemantic DirectoryItemMime
+                                             DirectoryItemLength DirectoryItemPadding)};
+
+    unless (ref $tag eq 'ARRAY' and ref $mime eq 'ARRAY') {
+        undef $pad;
+        ($tag, $mime, $len) = @$info{qw(ContainerDirectoryItemDataURI
+            ContainerDirectoryItemMime ContainerDirectoryItemLength)};
+        unless (ref $mime eq 'ARRAY' and ref $tag eq 'ARRAY') {
+            delete $$et{ProcessGoogleTrailer};
+            return 0;
+        }
+    }
+    # we need to know TrailerStart to be able to read/write this trailer
+    return -1 unless $$dirInfo{ScanForTrailer};
+
+    delete $$et{ProcessGoogleTrailer};  # reset flag to process the Google trailer
+
+    return -1 if $$dirInfo{OutFile};
+
+    # sometimes DirectoryItemLength is missing the Primary entry
+    $len = [ $len ] unless ref $len eq 'ARRAY';
+    unshift @$len, 0 while @$len < @$mime;
+
+    my $start = $$et{TrailerStart} or return 0;
+    my $end = $$et{FileEnd}; # (ignore Offset for now because some entries may run into other trailers)
+
+    my $dump = ($$et{OPTIONS}{Verbose} or $$et{HTML_DUMP});
+    my $tagTable = GetTagTable('Image::ExifTool::Trailer::Google');
+
+    # (ignore first entry: "Primary" or "primary_image")
+    my ($i, $pos, $buff, $regex, $grp, $type);
+    for ($i=1, $pos=0; defined $$mime[$i]; ++$i) {
+        my $more = $end - $start - $pos;
+        last if $more < 16;
+        next unless $$len[$i] and defined $$tag[$i];
+        last if $$len[$i] > $more;
+        $raf->Seek($start+$pos) and $raf->Read($buff, 16) == 16 and $raf->Seek($start+$pos) or last;
+        if ($$mime[$i] eq 'image/jpeg') {
+            $regex = '\xff\xd8\xff[\xdb\xe0\xe1]';
+        } elsif ($$mime[$i] eq 'video/mp4') {
+            $regex = '\0\0\0.ftyp(mp42|isom)';
+        } else {
+            $et->Warn("Google trailer $$tag[$i] $$mime[$i] not handled");
+            next;
+        }
+        if ($buff =~ /^$regex/s) {
+            last unless $raf->Read($buff, $$len[$i]) == $$len[$i];
+        } else {
+            last if $pos; # don't skip unknown information again
+            last unless $raf->Read($buff, $more) == $more;
+            last unless $buff =~ /($regex)/sg;
+            $pos += pos($buff) - length($1);
+            $more = $end - $start - $pos;
+            last if $$len[$i] > $end - $start - $pos;
+            $buff = substr($buff, $pos, $$len[$i]);
+        }
+        unless ($$tagTable{$$tag[$i]}) {
+            my $name = $$tag[$i];
+            $name =~ s/([^A-Za-z])([a-z])/$1\u$2/g; # capitalize words
+            $name = Image::ExifTool::MakeTagName($$tag[$i]);
+            if ($$mime[$i] eq 'image/jpeg') {
+                ($type, $grp) = ('Image', 'Preview');
+            } else {
+                ($type, $grp) = ('Video', 'Video');
+            }
+            $et->VPrint(0, $$et{INDENT}, "[adding Google:$name]\n");
+            AddTagToTable($tagTable, $$tag[$i], { Name => "$name$type", Groups => { 2 => $grp } });
+        }
+        $dump and $et->DumpTrailer({
+            RAF     => $raf,
+            DirName => $$tag[$i],
+            DataPos => $start + $pos,
+            DirLen  => $$len[$i],
+        });
+        $et->HandleTag($tagTable, $$tag[$i], \$buff, { DataPos => $start + $pos, DataPt => \$buff });
+        # (haven't seen non-zero padding, but I assume this is how it works
+        $pos += $$len[$i] + (($pad and $$pad[$i]) ? $$pad[$i] : 0);
+    }
+    if (defined $$tag[$i] and defined $$mime[$i]) {
+        $et->Warn("Error reading $$tag[$i] $$mime[$i] from trailer", 1);
+    }
+    return 0 unless $pos;
+
+    @$dirInfo{'DataPos','DirLen'} = ($start, $pos);
+
+    return 1;
+}
+
+1;  # end
+
+__END__
+
+=head1 NAME
+
+Image::ExifTool::Trailer - Read JPEG trailer written by various phone makes
+
+=head1 SYNOPSIS
+
+This module is used by Image::ExifTool
+
+=head1 DESCRIPTION
+
+This module contains definitions required by Image::ExifTool to read
+metadata the trailer written by some Vivo, OnePlus and Google phones.
+
+=head1 AUTHOR
+
+Copyright 2003-2025, Phil Harvey (philharvey66 at gmail.com)
+
+This library is free software; you can redistribute it and/or modify it
+under the same terms as Perl itself.
+
+=head1 SEE ALSO
+
+L<Image::ExifTool::TagNames/Trailer Tags>,
+L<Image::ExifTool(3pm)|Image::ExifTool>
+
+=cut
+

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

@@ -1061,6 +1061,10 @@ sub WriteQuickTime($$$)
             $et->Error("Can't yet write compressed movie metadata");
             return $rtnVal;
         } elsif ($tag eq 'wide') {
+            if ($size) {
+                $et->Warn("Incorrect size for 'wide' atom ($size bytes)");
+                $raf->Seek($size, 1) or $et->Error('Truncated wide atom');
+            }
             next;   # drop 'wide' tag
         }
 

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

@@ -1995,7 +1995,8 @@ my %sACDSeeRegionStruct = (
                         Struct => {
                             STRUCT_NAME => 'DeviceItem',
                             NAMESPACE => { Item => 'http://ns.google.com/photos/dd/1.0/item/' },
-                            Mime    => { },
+                            # use this as a key to process Google trailer
+                            Mime    => { RawConv => '$$self{ProcessGoogleTrailer} = $val' },
                             Length  => { Writable => 'integer' },
                             Padding => { Writable => 'integer' },
                             DataURI => { },
@@ -2149,7 +2150,7 @@ my %sACDSeeRegionStruct = (
                     STRUCT_NAME => 'Item',
                     # (use 'GItem' to avoid conflict with Google Device Container Item)
                     NAMESPACE => { GItem => 'http://ns.google.com/photos/1.0/container/item/'},
-                    Mime     => { },
+                    Mime    => { RawConv => '$$self{ProcessGoogleTrailer} = $val' },
                     Semantic => { },
                     Length   => { Writable => 'integer' },
                     Label    => { },

data/bin/lib/Image/ExifTool.pm

@@ -29,7 +29,7 @@ use vars qw($VERSION $RELEASE @ISA @EXPORT_OK %EXPORT_TAGS $AUTOLOAD @fileTypes
             %jpegMarker %specialTags %fileTypeLookup $testLen $exeDir
             %static_vars $advFmtSelf);
 
-$VERSION = '13.16';
+$VERSION = '13.17';
 $RELEASE = '';
 @ISA = qw(Exporter);
 %EXPORT_TAGS = (
@@ -6898,6 +6898,8 @@ sub IdentifyTrailer($;$)
             $type = 'NikonApp';
         } elsif ($buff =~ /\xff{4}\x1b\*9HWfu\x84\x93\xa2\xb1$/) {
             $type = 'Vivo';
+        } elsif ($buff =~ /jxrs...\0$/s) {
+            $type = 'OnePlus';
         }
         last;
     }
@@ -6929,18 +6931,24 @@ sub ProcessTrailers($$)
     my $success = 1;
     my $path = $$self{PATH};
 
+    # get position of end of file
+    $raf->Seek(0,2);
+    $$self{FileEnd} = $raf->Tell();
+
     for (;;) { # loop through all trailers
+        $raf->Seek($pos);
         my ($proc, $outBuff);
-        if ($dirName eq 'Insta360') {
-            require 'Image/ExifTool/QuickTimeStream.pl';
-            $proc = 'Image::ExifTool::QuickTime::ProcessInsta360';
-        } elsif ($dirName eq 'NikonApp') {
-            require Image::ExifTool::Nikon;
-            $proc = 'Image::ExifTool::Nikon::ProcessNikonApp';
-        } else {
-            require "Image/ExifTool/$dirName.pm";
-            $proc = "Image::ExifTool::${dirName}::Process$dirName";
-        }
+        # trailer-processing procs residing in modules of a different name
+        my $module = {
+            Insta360 => 'QuickTimeStream.pl',
+            NikonApp => 'Nikon.pm',
+            Vivo     => 'Trailer.pm',
+            OnePlus  => 'Trailer.pm',
+            Google   => 'Trailer.pm',
+        }->{$dirName} || "$dirName.pm";
+        require "Image/ExifTool/$module";
+        $module =~ s/(Stream)?\..*//;   # remove extension and change QuickTimeStream to QuickTime
+        $proc = "Image::ExifTool::${module}::Process$dirName";
         if ($outfile) {
             # write to local buffer so we can add trailer in proper order later
             $$outfile and $$dirInfo{OutFile} = \$outBuff, $outBuff = '';
@@ -6953,11 +6961,38 @@ sub ProcessTrailers($$)
         $$dirInfo{Trailer} = 1;         # set Trailer flag in case proc cares
         # add trailer and DirName to SubDirectory PATH
         push @$path, 'Trailer', $dirName;
-
-        # read or write this trailer
-        # (proc takes Offset as positive offset from end of trailer to end of file,
-        #  and returns DataPos and DirLen, and Fixup if applicable, and updates
-        #  OutFile when writing.  Returns < 0 if we must scan for this trailer)
+#
+# Call proc to read or write this trailer
+#
+# Proc inputs:
+#   0) ExifTool ref, with FileEnd set, and TrailerStart possibly set (start of all trailers)
+#   1) DirInfo with the following elements:
+#        DirName - name of this trailer
+#        RAF     - RAF reference
+#        Offset  - positive offset from end of this trailer to the end of file
+#        OutFile - (write mode) scalar reference for output buffer consisting of an empty string
+#        Trailer - flag set so proc knows we are processing a trailer (if it cares)
+#        Fixup   - optional fixup for pointers in trailer
+#        ScanForTrailer - set if we should now scan for the trailer start.  For JPEG
+#           images the ExifTool TrailerStart member will also be set, but for TIFF
+#           images TrailerStart will only be set when writing, so the proc should
+#           scan from the current file position when reading in a TIFF image.
+# Proc returns in read mode (OutFile not set):
+#   1 = success
+#   0 = error processing trailer (no warning will be issued and remaining trailers will be ignored)
+#  -1 = must scan from TrailerStart since length can not be determined
+#       (in which case this routine will be called again later when TrailerStart is known)
+# Proc returns in write mode:
+#   1 = success (and proc updates OutFile with the trailer to write, or empty string to delete)
+#   0 = error processing trailer (will issue minor error)
+#  -1 = caller to copy or delete the trailer as-is (from TrailerStart if DataPos isn't set)
+#   - TrailerStart will always be set in write mode
+#   - the write routine will not be called if all trailers are being deleted
+# Proc sets the following elements of $dirInfo in both read and write mode:
+#   DataPos - file position for start of this trailer
+#   DirLen  - length of this trailer (subsequent trailers are not processed if this is not set)
+#   Fixup   - for any pointers in the trailer that need adjusting
+#
         no strict 'refs';
         my $result = &$proc($self, $dirInfo);
         use strict 'refs';
@@ -6965,8 +7000,27 @@ sub ProcessTrailers($$)
         # restore PATH (pop last 2 items)
         splice @$path, -2;
 
-        # check result
+        my ($dataPos, $dirLen) = @$dirInfo{'DataPos','DirLen'};
         if ($outfile) {
+            if ($result < 0) {
+                # copy or delete the trailer ourself
+                $result = 1;
+                if ($$self{TrailerStart}) {
+                    $dataPos or $dataPos = $$self{TrailerStart};
+                    $dirLen or $dirLen = $$self{FileEnd} - $offset - $dataPos;
+                }
+                if ($$self{DEL_GROUP}{Trailer} or $$self{DEL_GROUP}{$dirName}) {
+                    my $bytes = $dirLen ? " ($dirLen bytes)" : '';
+                    $self->VPrint(0, "Deleting $dirName trailer$bytes\n");
+                    ++$$self{CHANGED};
+                } elsif ($dataPos and $dirLen) {
+                    $self->VPrint(0, "Copying $dirName trailer ($dirLen bytes)\n");
+                    $result = 0 unless $raf->Seek($dataPos) and
+                        $raf->Read(${$$dirInfo{OutFile}}, $dirLen) == $dirLen;
+                } else {
+                    $result = 0;
+                }
+            }
             if ($result > 0) {
                 if ($outBuff) {
                     # write trailers to OutFile in original order
@@ -6994,15 +7048,20 @@ sub ProcessTrailers($$)
             $success = 0;
             last;
         }
-        last unless $result > 0 and $$dirInfo{DirLen};
+        last unless $result > 0 and $dirLen;
+        $offset += $dirLen;
+        last if $dataPos and $$self{TrailerStart} and $dataPos <= $$self{TrailerStart};
         # look for next trailer
-        $offset += $$dirInfo{DirLen};
-        my $nextTrail = IdentifyTrailer($raf, $offset) or last;
+        my $nextTrail = IdentifyTrailer($raf, $offset);
+        # process Google trailer after all others if necessary and not done already
+        unless ($nextTrail) {
+            last unless $$self{ProcessGoogleTrailer};
+            $nextTrail = { DirName => 'Google', RAF => $raf };
+        }
         $dirName = $$dirInfo{DirName} = $$nextTrail{DirName};
-        $raf->Seek($pos, 0);
     }
     SetByteOrder($byteOrder);       # restore original byte order
-    $raf->Seek($pos, 0);            # restore original file position
+    $raf->Seek($pos);               # restore original file position
     $$dirInfo{OutFile} = $outfile;  # restore original outfile
     $$dirInfo{Offset} = $offset;    # return offset from EOF to start of first trailer
     $$dirInfo{Fixup} = $fixup;      # return fixup information
@@ -7399,12 +7458,61 @@ sub ProcessJPEG($$;$)
             $foundSOS = 1;
             # all done with meta information unless we have a trailer
             $verbose and print $out "${indent}JPEG SOS\n";
+            # process extended XMP now if it existed
+            # (must do this before trailers because XMP is required to process Google trailer)
+            if (%extendedXMP) {
+                my $guid;
+                # GUID indicated by the last main XMP segment
+                my $goodGuid = $$self{VALUE}{HasExtendedXMP} || '';
+                # GUID of the extended XMP that we will process ('2' for all)
+                my $readGuid = $$options{ExtendedXMP} || 0;
+                $readGuid = $goodGuid if $readGuid eq '1';
+                foreach $guid (sort keys %extendedXMP) {
+                    next unless length $guid == 32;     # ignore other (internal) keys
+                    my $extXMP = $extendedXMP{$guid};
+                    my ($off, @offsets, $warn);
+                    # make sure we have all chunks, and create a list of sorted offsets
+                    for ($off=0; $off<$$extXMP{Size}; ) {
+                        last unless defined $$extXMP{$off};
+                        push @offsets, $off;
+                        $off += length $$extXMP{$off};
+                    }
+                    unless ($off == $$extXMP{Size}) {
+                        $self->Warn("Incomplete extended XMP (GUID $guid)");
+                        next;
+                    }
+                    if ($guid eq $readGuid or $readGuid eq '2') {
+                        $warn = 'Reading non-' if $guid ne $goodGuid;
+                        my $buff = '';
+                        # assemble XMP all together
+                        $buff .= $$extXMP{$_} foreach @offsets;
+                        my $tagTablePtr = GetTagTable('Image::ExifTool::XMP::Main');
+                        my %dirInfo = (
+                            DataPt      => \$buff,
+                            Parent      => 'APP1',
+                            IsExtended  => 1,
+                        );
+                        $$path[$pn] = 'APP1';
+                        $self->ProcessDirectory(\%dirInfo, $tagTablePtr);
+                        pop @$path;
+                    } else {
+                        $warn = 'Ignored ';
+                        $warn .= 'non-' if $guid ne $goodGuid;
+                    }
+                    $self->Warn("${warn}standard extended XMP (GUID $guid)") if $warn;
+                    delete $extendedXMP{$guid};
+                }
+            }
             unless ($fast) {
                 $trailInfo = IdentifyTrailer($raf);
+                # check for Google trailer information if specific XMP tags exist
+                if (not $trailInfo and $$self{ProcessGoogleTrailer}) {
+                    $trailInfo = { DirName => 'Google', RAF => $raf };
+                }
                 # process trailer now unless we are doing verbose dump
                 if ($trailInfo and $verbose < 3 and not $htmlDump) {
                     # process trailers (keep trailInfo to finish processing later
-                    # only if we can't finish without scanning from end of file)
+                    # only if we can't finish without scanning from JPEG EOF)
                     $self->ProcessTrailers($trailInfo) and undef $trailInfo;
                 }
                 if ($wantTrailer and $$self{PreviewImageStart}) {
@@ -7577,7 +7685,7 @@ sub ProcessJPEG($$;$)
                         my $n = length($1) + 1;
                         $self->HDump($segPos+pos($$dataPt)-$n, $n, '[Vivo HiddenData]', undef, 0x08);
                     }
-                    my $tbl = GetTagTable('Image::ExifTool::Vivo::Main');
+                    my $tbl = GetTagTable('Image::ExifTool::Trailer::Vivo');
                     $self->HandleTag($tbl, HiddenData => $1);
                 }
                 # avoid looking for preview unless necessary because it really slows
@@ -8237,50 +8345,6 @@ sub ProcessJPEG($$;$)
         }
         undef $$segDataPt;
     }
-    # process extended XMP now if it existed
-    if (%extendedXMP) {
-        my $guid;
-        # GUID indicated by the last main XMP segment
-        my $goodGuid = $$self{VALUE}{HasExtendedXMP} || '';
-        # GUID of the extended XMP that we will process ('2' for all)
-        my $readGuid = $$options{ExtendedXMP} || 0;
-        $readGuid = $goodGuid if $readGuid eq '1';
-        foreach $guid (sort keys %extendedXMP) {
-            next unless length $guid == 32;     # ignore other (internal) keys
-            my $extXMP = $extendedXMP{$guid};
-            my ($off, @offsets, $warn);
-            # make sure we have all chunks, and create a list of sorted offsets
-            for ($off=0; $off<$$extXMP{Size}; ) {
-                last unless defined $$extXMP{$off};
-                push @offsets, $off;
-                $off += length $$extXMP{$off};
-            }
-            unless ($off == $$extXMP{Size}) {
-                $self->Warn("Incomplete extended XMP (GUID $guid)");
-                next;
-            }
-            if ($guid eq $readGuid or $readGuid eq '2') {
-                $warn = 'Reading non-' if $guid ne $goodGuid;
-                my $buff = '';
-                # assemble XMP all together
-                $buff .= $$extXMP{$_} foreach @offsets;
-                my $tagTablePtr = GetTagTable('Image::ExifTool::XMP::Main');
-                my %dirInfo = (
-                    DataPt      => \$buff,
-                    Parent      => 'APP1',
-                    IsExtended  => 1,
-                );
-                $$path[$pn] = 'APP1';
-                $self->ProcessDirectory(\%dirInfo, $tagTablePtr);
-                pop @$path;
-            } else {
-                $warn = 'Ignored ';
-                $warn .= 'non-' if $guid ne $goodGuid;
-            }
-            $self->Warn("${warn}standard extended XMP (GUID $guid)") if $warn;
-            delete $extendedXMP{$guid};
-        }
-    }
     # print verbose hash message if necessary
     print $out "${indent}(ImageDataHash: $hashsize bytes of JPEG image data)\n" if $hashsize and $verbose;
     # calculate JPEGDigest if requested
@@ -8557,7 +8621,9 @@ sub DoProcessTIFF($$;$)
         if ($raf) {
             my $trailInfo = IdentifyTrailer($raf);
             if ($trailInfo) {
-                $$trailInfo{ScanForTrailer} = 1;   # scan to find AFCP if necessary
+                # scan to find AFCP if necessary (Note: we are scanning
+                # from a random file position in the TIFF)
+                $$trailInfo{ScanForTrailer} = 1;
                 $self->ProcessTrailers($trailInfo);
             }
             # dump any other known trailer (eg. A100 RAW Data)
@@ -8663,6 +8729,7 @@ sub DoProcessTIFF($$;$)
             my $tbuf = '';
             $$trailInfo{OutFile} = \$tbuf;  # rewrite trailer(s)
             $$trailInfo{ScanForTrailer} = 1;   # scan for AFCP if necessary
+            $$self{TrailerStart} = $tiffEnd;
             # rewrite all trailers to buffer
             unless ($self->ProcessTrailers($trailInfo)) {
                 undef $trailInfo;