exiftool_vendored 9.37.0 → 9.41.0

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

@@ -0,0 +1,344 @@
+#------------------------------------------------------------------------------
+# File:         WriteQuickTime.pl
+#
+# Description:  Write XMP to QuickTime (MOV and MP4) files
+#
+# Revisions:    2013-10-29 - P. Harvey Created
+#------------------------------------------------------------------------------
+package Image::ExifTool::QuickTime;
+
+use strict;
+
+# map for adding directories to QuickTime-format files
+my %movMap = (
+    # MOV (no 'ftyp', or 'ftyp'='qt  ') -> 'moov'-'udta'-'XMP_'
+    XMP      => 'UserData',
+    UserData => 'Movie',
+    Movie    => 'MOV',
+);
+my %mp4Map = (
+    # MP4 ('ftyp' compatible brand 'mp41', 'mp42' or 'f4v ') -> top level 'uuid'
+   'UUID-XMP' => 'MOV',
+    XMP       => 'UUID-XMP',
+);
+my %dirMap = (
+    MOV => \%movMap,
+    MP4 => \%mp4Map,
+);
+
+#------------------------------------------------------------------------------
+# Check to see if path is current
+# Inputs: 0) ExifTool object ref, 1) directory name
+# Returns: true if current path is the root of the specified directory
+sub IsCurPath($$)
+{
+    local $_;
+    my ($et, $dir) = @_;
+    $dir = $$et{DirMap}{$dir} and $dir eq $_ or last foreach reverse @{$$et{PATH}}; 
+    return($dir and $dir eq 'MOV');    
+}
+
+#------------------------------------------------------------------------------
+# Write a series of QuickTime atoms from file or in memory
+# Inputs: 0) ExifTool ref, 1) dirInfo ref, 2) tag table ref
+# Returns: A) if dirInfo contains DataPt: new director data
+#          B) otherwise: true on success, 0 if a write error occurred
+#             (true but sets an Error on a file format error)
+sub WriteQuickTime($$$)
+{
+    my ($et, $dirInfo, $tagTablePtr) = @_;
+    my ($foundMDAT, @hold, $track);
+    my $outfile = $$dirInfo{OutFile} or return 0;
+    my $raf = $$dirInfo{RAF};
+    my $dataPt = $$dirInfo{DataPt};
+    my $dirName = $$dirInfo{DirName};
+    my $parent = $$dirInfo{Parent};
+    my $addDirs = $$et{ADD_DIRS};
+    my $rtnVal = 1;
+
+    if ($dataPt) {
+        $raf = new File::RandomAccess($dataPt);
+        my $outBuff = '';
+        $outfile = \$outBuff;
+    } else {
+        return 0 unless $raf;
+    }
+    for (;;) {
+        my ($hdr, $buff);
+        my $n = $raf->Read($hdr, 8);
+        unless ($n == 8) {
+            if ($n == 4 and $hdr eq "\0\0\0\0") {
+                # "for historical reasons" the udta is optionally terminated by 4 zeros (ref 1)
+                # --> hold this terminator to the end
+                push @hold, $hdr;
+            } elsif ($n != 0) {
+                $et->Error('File format error');
+            }
+            last;
+        }
+        my ($size, $tag) = unpack('Na4', $hdr);
+        if ($size >= 8) {
+            $size -= 8;
+        } elsif ($size == 1) {
+            # read the extended size
+            $raf->Read($buff, 8) == 8 or $et->Error('Truncated extended atom'), last;
+            $hdr .= $buff;
+            my ($hi, $lo) = unpack('NN', $buff);
+            $size = $hi * 4294967296 + $lo - 16;
+            $size < 0 and $et->Error('Invalid extended atom size'), last;
+        } elsif (not $size and not $dataPt) {
+            # size of zero is only valid for top-level atom, and
+            # indicates the atom extends to the end of file
+            if (not $raf->{FILE_PT}) {
+                # get file size from image in memory
+                $size = length ${$$raf{BUFF_PT}};
+            } else {
+                $size = -s $$raf{FILE_PT};
+            }
+            if ($size and ($size -= $raf->Tell()) >= 0 and $size <= 0x7fffffff) {
+                Set32u($size + 8, \$hdr, 0);
+            } elsif (@hold) {
+                $et->Error("Sorry, can't yet add tags to this type of QuickTime file");
+                return $rtnVal;
+            } else {
+                # blindly copy the rest of the file
+                Write($outfile, $hdr) or $rtnVal = 0;
+                while ($raf->Read($buff, 65536)) {
+                    Write($outfile, $buff) or $rtnVal = 0, last;
+                }
+                return $rtnVal;
+            }
+        } else {
+            $et->Error('Invalid atom size');
+            last;
+        }
+
+        # set flag if we have passed the 'mdat' atom
+        $foundMDAT = 1 if $tag eq 'mdat';
+
+        # rewrite this atom
+        my $tagInfo = $et->GetTagInfo($tagTablePtr, $tag);
+        if (defined $tagInfo and not $tagInfo) {
+            my $n = $size < 256 ? $size : 256;
+            unless ($raf->Read($buff, $n) == $n and $raf->Seek(-$n, 1)) {
+                $et->Error("Read/seek error in $tag atom");
+                last;
+            }
+            $tagInfo = $et->GetTagInfo($tagTablePtr, $tag, \$buff);
+        }
+        if ($tagInfo) {
+            if ($$tagInfo{Unknown}) {
+                undef $tagInfo;
+            } elsif ($size > 100000000) {
+                # limit maximum size of atom that we load into memory
+                my $mb = $size / 0x100000;
+                $et->Warn("Not editing metadata in $tag atom. $mb MB is too big");
+                undef $tagInfo;
+            }
+        }
+        if ($tagInfo) {
+            # read the atom data
+            $raf->Read($buff, $size) == $size or $et->Error("Error reading $tag data"), last;
+            my $subdir = $$tagInfo{SubDirectory};
+            my $newData;
+            if ($subdir) {
+                my $subName = $$subdir{DirName} || $$tagInfo{Name};
+                my $start = $$subdir{Start} || 0;
+                my $base = ($$dirInfo{Base} || 0) + $raf->Tell() - $size;
+                my $dPos = 0;
+                if ($$subdir{Base}) {
+                    $dPos -= eval $$subdir{Base};
+                    $base -= $dPos;
+                }
+                my %subdirInfo = (
+                    Parent   => $dirName,
+                    DirName  => $subName,
+                    DataPt   => \$buff,
+                    DataLen  => $size,
+                    DataPos  => $dPos,
+                    DirStart => $start,
+                    DirLen   => $size - $start,
+                    Base     => $base,
+                    HasData  => $$subdir{HasData},  # necessary?
+                    Multi    => $$subdir{Multi},    # necessary?
+                    OutFile  => $outfile,
+                );
+                SetByteOrder('II') if $$subdir{ByteOrder} and $$subdir{ByteOrder} =~ /^Little/;
+                my $oldWriteGroup = $$et{CUR_WRITE_GROUP};
+                if ($subName eq 'Track') {
+                    $track or $track = 0;
+                    $$et{CUR_WRITE_GROUP} = 'Track' . (++$track);
+                }
+                my $subTable = GetTagTable($$subdir{TagTable});
+                # demote non-QuickTime errors to warnings
+                $$et{DemoteErrors} = 1 unless $$subTable{GROUPS}{0} eq 'QuickTime';
+                $newData = $et->WriteDirectory(\%subdirInfo, $subTable);
+                if ($$et{DemoteErrors}) {
+                    # just copy existing subdirectory a non-quicktime error occurred
+                    undef $newData if $$et{DemoteErrors} > 1;
+                    delete $$et{DemoteErrors};
+                }
+                $$et{CUR_WRITE_GROUP} = $oldWriteGroup;
+                SetByteOrder('MM');
+                # add back header if necessary
+                if ($$subdir{Start} and defined $newData and length $newData) {
+                    $newData = substr($buff,0,$$subdir{Start}) . $newData;
+                }
+                # the directory exists, so we don't need to add it
+                delete $$addDirs{$subName} if IsCurPath($et, $subName);
+            } else {
+                # --> this is where individual QuickTime tags would be edited,
+                # (this is such a can of worms, so don't implement this for now)
+            }
+            if (defined $newData) {
+                my $len = length $newData or next;
+                $len > 0x7ffffff7 and $et->Error("$tag to large to write"), last;
+                if ($len == $size or $dataPt or $foundMDAT) {
+                    # write the updated directory now
+                    Write($outfile, Set32u($len+8), $tag, $newData) or $rtnVal = 0, last;
+                    next;
+                } else {
+                    # bad things happen if 'mdat' atom is moved (ie. Adobe Bridge crashes --
+                    # there must be some absolute offsets somewhere that point into mdat),
+                    # so hold this atom and write it out later
+                    push @hold, Set32u($len+8), $tag, $newData;
+                    $et->VPrint(0,"  Moving '$tag' atom to after 'mdat'");
+                    # write a 'free' atom here to keep 'mdat' at the same offset
+                    substr($hdr, 4, 4) = 'free';
+                    # could zero out old data if we wanted...
+                    # $buff = "\0" x length($buff);
+                }
+            }
+            # write out the existing atom (or 'free' padding)
+            Write($outfile, $hdr, $buff) or $rtnVal = 0, last;
+        } else {
+            # write the unknown/large atom header
+            Write($outfile, $hdr) or $rtnVal = 0, last;
+            next unless $size;
+            # copy the atom data
+            my $result = Image::ExifTool::CopyBlock($raf, $outfile, $size);
+            defined $result or $rtnVal = 0, last;
+            $result or $et->Error("Truncated $tag atom"), last;
+        }
+    }
+    # add new directories at this level if necessary
+    if (exists $$et{EDIT_DIRS}{$dirName}) {
+        # get a hash of tagInfo references to add to this directory
+        my $dirs = $et->GetAddDirHash($tagTablePtr, $dirName);
+        # make sorted list of new tags to be added
+        my @addTags = sort keys(%$dirs);
+        my $tag;
+        foreach $tag (@addTags) {
+            my $tagInfo = $$dirs{$tag};
+            my $subdir = $$tagInfo{SubDirectory} or next;
+            my $subName = $$subdir{DirName} || $$tagInfo{Name};
+            # QuickTime hierarchy is complex, so check full directory path before adding
+            next unless IsCurPath($et, $subName);
+            delete $$addDirs{$subName}; # add only once
+            my $buff = '';  # write from scratch
+            my %subdirInfo = (
+                Parent   => $dirName,
+                DirName  => $subName,
+                DataPt   => \$buff,
+                DirStart => 0,
+                OutFile  => $outfile,
+            );
+            my $subTable = GetTagTable($$subdir{TagTable});
+            my $newData = $et->WriteDirectory(\%subdirInfo, $subTable);
+            if ($newData and length($newData) <= 0x7ffffff7) {
+                my $uuid = '';
+                # add atom ID if necessary (obtain from Condition expression)
+                if ($$subdir{Start}) {
+                    my $cond = $$tagInfo{Condition};
+                    $uuid = eval qq("$1") if $cond and $cond =~ m{=~\s*\/\^(.*)/};
+                    length($uuid) == $$subdir{Start} or $et->Error('Internal UUID error');
+                }
+                my $newHdr = Set32u(8+length($newData)+length($uuid)) . $tag . $uuid;
+                Write($outfile, $newHdr, $newData) or $rtnVal = 0;
+            }
+        }
+    }
+    # write out any atoms that we are holding until the end
+    Write($outfile, @hold) or $rtnVal = 0 if @hold;
+
+    # issue minor error if we didn't find an 'mdat' atom
+    # (we could duplicate atoms indefinitely through repeated editing if we
+    #  held back some atoms here, so in this case it isn't a minor error)
+    $dataPt or $foundMDAT or $et->Error('No mdat atom found', @hold ? 0 : 1);
+
+    return $dataPt ? ($rtnVal ? $$outfile : undef) : $rtnVal;
+}
+
+#------------------------------------------------------------------------------
+# Write QuickTime-format MOV/MP4 file
+# Inputs: 0) ExifTool ref, 1) dirInfo ref
+# Returns: 1 on success, 0 if this wasn't a valid QuickTime file,
+#          or -1 if a write error occurred
+sub WriteMOV($$)
+{
+    my ($et, $dirInfo) = @_;
+    $et or return 1;
+    my $raf = $$dirInfo{RAF} or return 0;
+    my ($buff, $ftype);
+
+    # read the first atom header
+    return 0 unless $raf->Read($buff, 8) == 8;
+    my ($size, $tag) = unpack('Na4', $buff);
+    return 0 if $size < 8 and $size != 1;
+
+    # validate the file format
+    my $tagTablePtr = GetTagTable('Image::ExifTool::QuickTime::Main');
+    return 0 unless $$tagTablePtr{$tag};
+
+    # determine the file type
+    if ($tag eq 'ftyp' and $size >= 12 and $size < 100000 and
+        $raf->Read($buff, $size-8) == $size-8 and
+        $buff !~ /^(....)+(qt  )/s)
+    {
+        # file is MP4 format if 'ftyp' exists without 'qt  ' as a compatible brand
+        $ftype = 'MP4';
+    } else {
+        $ftype = 'MOV';
+    }
+    $et->SetFileType($ftype); # need to set "FileType" tag for a Condition
+    $et->InitWriteDirs($dirMap{$ftype}, 'XMP');
+    $$et{DirMap} = $dirMap{$ftype};     # need access to directory map when writing
+    SetByteOrder('MM');
+    $raf->Seek(0,0);
+
+    # write the file
+    $$dirInfo{Parent} = '';
+    $$dirInfo{DirName} = 'MOV';
+    return WriteQuickTime($et, $dirInfo, $tagTablePtr) ? 1 : -1;
+}
+
+1; # end
+
+__END__
+
+=head1 NAME
+
+Image::ExifTool::WriteQuickTime.pl - Write XMP to QuickTime (MOV and MP4) files
+
+=head1 SYNOPSIS
+
+These routines are autoloaded by Image::ExifTool::QuickTime.
+
+=head1 DESCRIPTION
+
+This file contains routines used by ExifTool to write XMP metadata to
+QuickTime-based file formats like MOV and MP4.
+
+=head1 AUTHOR
+
+Copyright 2003-2013, 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.
+
+=head1 SEE ALSO
+
+L<Image::ExifTool::QuickTime(3pm)|Image::ExifTool::QuickTime>,
+L<Image::ExifTool(3pm)|Image::ExifTool>
+
+=cut

data/bin/{Image-ExifTool-9.37 → Image-ExifTool-9.41}/lib/Image/ExifTool/WriteXMP.pl

@@ -52,13 +52,13 @@ my $pktCloseR =  "<?xpacket end='r'?>";
 # Returns: x:xmpmeta opening tag
 sub XMPOpen($)
 {
-    my $exifTool = shift;
-    my $nv = $exifTool->{NEW_VALUE}->{$Image::ExifTool::XMP::x{xmptk}};
+    my $et = shift;
+    my $nv = $$et{NEW_VALUE}{$Image::ExifTool::XMP::x{xmptk}};
     my $tk;
     if (defined $nv) {
-        $tk = $exifTool->GetNewValues($nv);
-        $exifTool->VerboseValue(($tk ? '+' : '-') . ' XMP-x:XMPToolkit', $tk);
-        ++$exifTool->{CHANGED};
+        $tk = $et->GetNewValues($nv);
+        $et->VerboseValue(($tk ? '+' : '-') . ' XMP-x:XMPToolkit', $tk);
+        ++$$et{CHANGED};
     } else {
         $tk = "Image::ExifTool $Image::ExifTool::VERSION";
     }
@@ -121,7 +121,7 @@ sub FormatXMPDate($)
 # Note: copies structured information to avoid conflicts with calling code
 sub CheckXMP($$$)
 {
-    my ($exifTool, $tagInfo, $valPtr) = @_;
+    my ($et, $tagInfo, $valPtr) = @_;
 
     if ($$tagInfo{Struct}) {
         require 'Image/ExifTool/XMPStruct.pl';
@@ -143,31 +143,31 @@ sub CheckXMP($$$)
                     $err = 'Improperly formed structure';
                     last;
                 }
-                ($item, $err) = CheckStruct($exifTool, $item, $$tagInfo{Struct});
+                ($item, $err) = CheckStruct($et, $item, $$tagInfo{Struct});
                 last if $err;
             }
         } else {
-            ($$valPtr, $err) = CheckStruct($exifTool, $$valPtr, $$tagInfo{Struct});
+            ($$valPtr, $err) = CheckStruct($et, $$valPtr, $$tagInfo{Struct});
         }
-        $warn and $$exifTool{CHECK_WARN} = $warn;
+        $warn and $$et{CHECK_WARN} = $warn;
         return $err;
     }
     my $format = $tagInfo->{Writable};
     # (if no format specified, value is a simple string)
     if (not $format or $format eq 'string' or $format eq 'lang-alt') {
         # convert value to UTF8 if necessary
-        if ($exifTool->{OPTIONS}->{Charset} ne 'UTF8') {
+        if ($$et{OPTIONS}{Charset} ne 'UTF8') {
             if ($$valPtr =~ /[\x80-\xff]/) {
                 # convert from Charset to UTF-8
-                $$valPtr = $exifTool->Encode($$valPtr,'UTF8');
+                $$valPtr = $et->Encode($$valPtr,'UTF8');
             }
         } else {
             # translate invalid XML characters to "."
             $$valPtr =~ tr/\0-\x08\x0b\x0c\x0e-\x1f/./;
             # fix any malformed UTF-8 characters
-            if (FixUTF8($valPtr) and not $$exifTool{WarnBadUTF8}) {
-                $exifTool->Warn('Malformed UTF-8 character(s)');
-                $$exifTool{WarnBadUTF8} = 1;
+            if (FixUTF8($valPtr) and not $$et{WarnBadUTF8}) {
+                $et->Warn('Malformed UTF-8 character(s)');
+                $$et{WarnBadUTF8} = 1;
             }
         }
         return undef;   # success
@@ -315,7 +315,7 @@ sub SetPropertyPath($$;$$$$)
 #         2) property value, 3) optional reference to hash of property attributes
 sub CaptureXMP($$$;$)
 {
-    my ($exifTool, $propList, $val, $attrs) = @_;
+    my ($et, $propList, $val, $attrs) = @_;
     return unless defined $val and @$propList > 2;
     if ($$propList[0] =~ /^x:x[ma]pmeta$/ and
         $$propList[1] eq 'rdf:RDF' and
@@ -325,14 +325,14 @@ sub CaptureXMP($$$;$)
         return unless @$propList > 3;
         # ignore empty list properties
         if ($$propList[-1] =~ /^rdf:(Bag|Seq|Alt)$/) {
-            $exifTool->Warn("Ignored empty $$propList[-1] list for $$propList[-2]", 1);
+            $et->Warn("Ignored empty $$propList[-1] list for $$propList[-2]", 1);
             return;
         }
         # save information about this property
-        my $capture = $exifTool->{XMP_CAPTURE};
+        my $capture = $$et{XMP_CAPTURE};
         my $path = join('/', @$propList[3..$#$propList]);
         if (defined $$capture{$path}) {
-            $exifTool->{XMP_ERROR} = "Duplicate XMP property: $path";
+            $$et{XMP_ERROR} = "Duplicate XMP property: $path";
         } else {
             $$capture{$path} = [$val, $attrs || { }];
         }
@@ -340,12 +340,12 @@ sub CaptureXMP($$$;$)
              $$propList[1] =~ /$rdfDesc( |$)/)
     {
         # set flag so we don't write x:xmpmeta element
-        $exifTool->{XMP_NO_XMPMETA} = 1;
+        $$et{XMP_NO_XMPMETA} = 1;
         # add missing x:xmpmeta element and try again
         unshift @$propList, 'x:xmpmeta';
-        CaptureXMP($exifTool, $propList, $val, $attrs);
+        CaptureXMP($et, $propList, $val, $attrs);
     } else {
-        $exifTool->{XMP_ERROR} = 'Improperly enclosed XMP property: ' . join('/',@$propList);
+        $$et{XMP_ERROR} = 'Improperly enclosed XMP property: ' . join('/',@$propList);
     }
 }
 
@@ -391,8 +391,8 @@ sub SaveBlankInfo($$$;$)
 #         2) blank node information hash ref, 3) flag set for writing
 sub ProcessBlankInfo($$$;$)
 {
-    my ($exifTool, $tagTablePtr, $blankInfo, $isWriting) = @_;
-    $exifTool->VPrint(1, "  [Elements with nodeID set:]\n") unless $isWriting;
+    my ($et, $tagTablePtr, $blankInfo, $isWriting) = @_;
+    $et->VPrint(1, "  [Elements with nodeID set:]\n") unless $isWriting;
     my ($id, $pre, $post);
     # handle each nodeID separately
     foreach $id (sort keys %{$$blankInfo{Prop}}) {
@@ -410,23 +410,23 @@ sub ProcessBlankInfo($$$;$)
                 my @propList = split m{/}, "$pre$post";
                 my ($val, $attrs) = @{$path->{Post}->{$post}};
                 if ($isWriting) {
-                    CaptureXMP($exifTool, \@propList, $val, $attrs);
+                    CaptureXMP($et, \@propList, $val, $attrs);
                 } else {
-                    FoundXMP($exifTool, $tagTablePtr, \@propList, $val);
+                    FoundXMP($et, $tagTablePtr, \@propList, $val);
                 }
                 delete $unused{$post};
             }
         }
         # save information from unused properties (if RDF is malformed like f-spot output)
         if (%unused) {
-            $exifTool->Options('Verbose') and $exifTool->Warn('An XMP resource is about nothing');
+            $et->Options('Verbose') and $et->Warn('An XMP resource is about nothing');
             foreach $post (sort keys %unused) {
                 my ($val, $attrs, $propPath) = @{$path->{Post}->{$post}};
                 my @propList = split m{/}, $propPath;
                 if ($isWriting) {
-                    CaptureXMP($exifTool, \@propList, $val, $attrs);
+                    CaptureXMP($et, \@propList, $val, $attrs);
                 } else {
-                    FoundXMP($exifTool, $tagTablePtr, \@propList, $val);
+                    FoundXMP($et, $tagTablePtr, \@propList, $val);
                 }
             }
         }
@@ -440,9 +440,9 @@ sub ProcessBlankInfo($$$;$)
 # Returns: conforming property path
 sub ConformPathToNamespace($$)
 {
-    my ($exifTool, $path) = @_;
+    my ($et, $path) = @_;
     my @propList = split('/',$path);
-    my $nsUsed = $exifTool->{XMP_NS};
+    my $nsUsed = $$et{XMP_NS};
     my $prop;
     foreach $prop (@propList) {
         my ($ns, $tag) = $prop =~ /(.+?):(.*)/;
@@ -470,7 +470,7 @@ sub ConformPathToNamespace($$)
 #            variable-namespace structures
 sub AddStructType($$$$;$)
 {
-    my ($exifTool, $tagTablePtr, $capture, $path, $basePath) = @_;
+    my ($et, $tagTablePtr, $capture, $path, $basePath) = @_;
     my @props = split '/', $path;
     my %doneID;
     for (;;) {
@@ -486,7 +486,7 @@ sub AddStructType($$$$;$)
             if ($type) {
                 my $pat = $$tagInfo{PropertyPath};
                 $pat or warn("Missing PropertyPath in AddStructType\n"), last;
-                $pat = ConformPathToNamespace($exifTool, $pat);
+                $pat = ConformPathToNamespace($et, $pat);
                 $pat =~  s/ \d+/ \\d\+/g;
                 $path =~ /^($pat)/ or warn("Wrong path in AddStructType\n"), last;
                 my $p = $1 . '/rdf:type';
@@ -550,7 +550,7 @@ sub TypeFirst
 # Returns: 0) extended XMP ref, 1) GUID and updates $$dataPt (or undef if no extended XMP)
 sub LimitXMPSize($$$$$$)
 {
-    my ($exifTool, $dataPt, $maxLen, $about, $startPt, $extStart) = @_;
+    my ($et, $dataPt, $maxLen, $about, $startPt, $extStart) = @_;
 
     # return straight away if it isn't too big
     return undef if length($$dataPt) < $maxLen;
@@ -571,7 +571,7 @@ sub LimitXMPSize($$$$$$)
     pop @$startPt;    # remove end offset
     # write the descriptions from smallest to largest, as many in main XMP as possible
     my @descStart = sort { $descSize{$a} <=> $descSize{$b} } @$startPt;
-    my $extData = XMPOpen($exifTool) . $rdfOpen;
+    my $extData = XMPOpen($et) . $rdfOpen;
     for ($i=0; $i<2; ++$i) {
       foreach $start (@descStart) {
         # write main XMP first (in order of size), then extended XMP afterwards (in order)
@@ -586,7 +586,7 @@ sub LimitXMPSize($$$$$$)
         $guid = uc unpack('H*', Digest::MD5::md5($extData));
         $newData =~ s/0{32}/$guid/;     # update GUID in main XMP segment
     }
-    $exifTool->VerboseValue('+ XMP-xmpNote:HasExtendedXMP', $guid);
+    $et->VerboseValue('+ XMP-xmpNote:HasExtendedXMP', $guid);
     $$dataPt = $newData;        # return main XMP block
     return (\$extData, $guid);  # return extended XMP and its GUID
 }
@@ -604,15 +604,15 @@ sub LimitXMPSize($$$$$$)
 #          and ExtendedGUID to be returned in dirInfo if extended XMP was required
 sub WriteXMP($$;$)
 {
-    my ($exifTool, $dirInfo, $tagTablePtr) = @_;
-    $exifTool or return 1;    # allow dummy access to autoload this package
+    my ($et, $dirInfo, $tagTablePtr) = @_;
+    $et or return 1;    # allow dummy access to autoload this package
     my $dataPt = $$dirInfo{DataPt};
     my (%capture, %nsUsed, $xmpErr, $tagInfo, $about);
     my $changed = 0;
     my $xmpFile = (not $tagTablePtr);   # this is an XMP data file if no $tagTablePtr
     # prefer XMP over other metadata formats in some types of files
-    my $preferred = $xmpFile || ($$exifTool{PreferredGroup} and $$exifTool{PreferredGroup} eq 'XMP');
-    my $verbose = $exifTool->Options('Verbose');
+    my $preferred = $xmpFile || ($$et{PreferredGroup} and $$et{PreferredGroup} eq 'XMP');
+    my $verbose = $et->Options('Verbose');
     my $dirLen = $$dirInfo{DirLen};
     $dirLen = length($$dataPt) if not defined $dirLen and $dataPt;
 #
@@ -624,55 +624,55 @@ sub WriteXMP($$;$)
     # The %capture hash is keyed on the complete property path beginning after
     # rdf:RDF/rdf:Description/.  The values are array references with the
     # following entries: 0) value, 1) attribute hash reference.
-    $exifTool->{XMP_CAPTURE} = \%capture;
-    $exifTool->{XMP_NS} = \%nsUsed;
-    delete $exifTool->{XMP_NO_XMPMETA};
-    delete $exifTool->{XMP_NO_XPACKET};
-    delete $exifTool->{XMP_IS_XML};
-    delete $exifTool->{XMP_IS_SVG};
+    $$et{XMP_CAPTURE} = \%capture;
+    $$et{XMP_NS} = \%nsUsed;
+    delete $$et{XMP_NO_XMPMETA};
+    delete $$et{XMP_NO_XPACKET};
+    delete $$et{XMP_IS_XML};
+    delete $$et{XMP_IS_SVG};
 
     if ($xmpFile or $dirLen) {
-        delete $exifTool->{XMP_ERROR};
-        delete $exifTool->{XMP_ABOUT};
+        delete $$et{XMP_ERROR};
+        delete $$et{XMP_ABOUT};
         # extract all existing XMP information (to the XMP_CAPTURE hash)
-        my $success = ProcessXMP($exifTool, $dirInfo, $tagTablePtr);
+        my $success = ProcessXMP($et, $dirInfo, $tagTablePtr);
         # don't continue if there is nothing to parse or if we had a parsing error
-        unless ($success and not $exifTool->{XMP_ERROR}) {
-            my $err = $exifTool->{XMP_ERROR} || 'Error parsing XMP';
+        unless ($success and not $$et{XMP_ERROR}) {
+            my $err = $$et{XMP_ERROR} || 'Error parsing XMP';
             # may ignore this error only if we were successful
             if ($xmpFile) {
                 my $raf = $$dirInfo{RAF};
                 # allow empty XMP data so we can create something from nothing
                 if ($success or not $raf->Seek(0,2) or $raf->Tell()) {
                     # no error message if not an XMP file
-                    return 0 unless $exifTool->{XMP_ERROR};
-                    if ($exifTool->Error($err, $success)) {
-                        delete $exifTool->{XMP_CAPTURE};
+                    return 0 unless $$et{XMP_ERROR};
+                    if ($et->Error($err, $success)) {
+                        delete $$et{XMP_CAPTURE};
                         return 0;
                     }
                 }
             } else {
-                if ($exifTool->Warn($err, $success)) {
-                    delete $exifTool->{XMP_CAPTURE};
+                if ($et->Warn($err, $success)) {
+                    delete $$et{XMP_CAPTURE};
                     return undef;
                 }
             }
         }
         $tagInfo = $Image::ExifTool::XMP::rdf{about};
-        if (defined $exifTool->{NEW_VALUE}->{$tagInfo}) {
-            $about = $exifTool->GetNewValues($exifTool->{NEW_VALUE}->{$tagInfo}) || '';
+        if (defined $$et{NEW_VALUE}{$tagInfo}) {
+            $about = $et->GetNewValues($$et{NEW_VALUE}{$tagInfo}) || '';
             if ($verbose > 1) {
-                my $wasAbout = $exifTool->{XMP_ABOUT};
-                $exifTool->VerboseValue('- XMP-rdf:About', UnescapeXML($wasAbout)) if defined $wasAbout;
-                $exifTool->VerboseValue('+ XMP-rdf:About', $about);
+                my $wasAbout = $$et{XMP_ABOUT};
+                $et->VerboseValue('- XMP-rdf:About', UnescapeXML($wasAbout)) if defined $wasAbout;
+                $et->VerboseValue('+ XMP-rdf:About', $about);
             }
             $about = EscapeXML($about); # must escape for XML
             ++$changed;
         } else {
-            $about = $exifTool->{XMP_ABOUT} || '';
+            $about = $$et{XMP_ABOUT} || '';
         }
-        delete $exifTool->{XMP_ERROR};
-        delete $exifTool->{XMP_ABOUT};
+        delete $$et{XMP_ERROR};
+        delete $$et{XMP_ABOUT};
     } else {
         $about = '';
     }
@@ -681,26 +681,26 @@ sub WriteXMP($$;$)
 #
     if ($xmpFile) {
         $tagInfo = $Image::ExifTool::Extra{XMP};
-        if ($tagInfo and $exifTool->{NEW_VALUE}->{$tagInfo}) {
+        if ($tagInfo and $$et{NEW_VALUE}{$tagInfo}) {
             my $rtnVal = 1;
-            my $newVal = $exifTool->GetNewValues($exifTool->{NEW_VALUE}->{$tagInfo});
+            my $newVal = $et->GetNewValues($$et{NEW_VALUE}{$tagInfo});
             if (defined $newVal and length $newVal) {
-                $exifTool->VPrint(0, "  Writing XMP as a block\n");
-                ++$exifTool->{CHANGED};
+                $et->VPrint(0, "  Writing XMP as a block\n");
+                ++$$et{CHANGED};
                 Write($$dirInfo{OutFile}, $newVal) or $rtnVal = -1;
             }
-            delete $exifTool->{XMP_CAPTURE};
+            delete $$et{XMP_CAPTURE};
             return $rtnVal;
         }
     }
 #
 # delete groups in family 1 if requested
 #
-    if (%{$exifTool->{DEL_GROUP}} and (grep /^XMP-.+$/, keys %{$exifTool->{DEL_GROUP}} or
+    if (%{$$et{DEL_GROUP}} and (grep /^XMP-.+$/, keys %{$$et{DEL_GROUP}} or
         # (logic is a bit more complex for group names in exiftool XML files)
         grep m{^http://ns.exiftool.ca/}, values %nsUsed))
     {
-        my $del = $exifTool->{DEL_GROUP};
+        my $del = $$et{DEL_GROUP};
         my $path;
         foreach $path (keys %capture) {
             my @propList = split('/',$path); # get property list
@@ -724,7 +724,7 @@ sub WriteXMP($$;$)
                 my $ucg = uc $grp;
                 next unless $$del{$ucg} or ($$del{'XMP-*'} and not $$del{"-$ucg"});
             }
-            $exifTool->VerboseValue("- $grp:$tag", $capture{$path}->[0]);
+            $et->VerboseValue("- $grp:$tag", $capture{$path}->[0]);
             delete $capture{$path};
             ++$changed;
         }
@@ -732,24 +732,24 @@ sub WriteXMP($$;$)
     # delete HasExtendedXMP tag (we create it as needed)
     my $hasExtTag = 'xmpNote:HasExtendedXMP';
     if ($capture{$hasExtTag}) {
-        $exifTool->VerboseValue("- XMP-$hasExtTag", $capture{$hasExtTag}->[0]);
+        $et->VerboseValue("- XMP-$hasExtTag", $capture{$hasExtTag}->[0]);
         delete $capture{$hasExtTag};
     }
     # set $xmpOpen now to to handle xmptk tag first
-    my $xmpOpen = $exifTool->{XMP_NO_XMPMETA} ? '' : XMPOpen($exifTool);
+    my $xmpOpen = $$et{XMP_NO_XMPMETA} ? '' : XMPOpen($et);
 #
 # add, delete or change information as specified
 #
     # get hash of all information we want to change
     # (sorted by tag name so alternate languages come last)
-    my @tagInfoList = sort ByTagName $exifTool->GetNewTagInfoList();
+    my @tagInfoList = sort ByTagName $et->GetNewTagInfoList();
     foreach $tagInfo (@tagInfoList) {
-        next unless $exifTool->GetGroup($tagInfo, 0) eq 'XMP';
+        next unless $et->GetGroup($tagInfo, 0) eq 'XMP';
         next if $$tagInfo{Name} eq 'XMP'; # (ignore full XMP block if we didn't write it already)
         my $tag = $$tagInfo{TagID};
         my $path = GetPropertyPath($tagInfo);
         unless ($path) {
-            $exifTool->Warn("Can't write XMP:$tag (namespace unknown)");
+            $et->Warn("Can't write XMP:$tag (namespace unknown)");
             next;
         }
         # skip tags that were handled specially
@@ -760,7 +760,7 @@ sub WriteXMP($$;$)
         my $isStruct = $$tagInfo{Struct};
         # change our property path namespace prefixes to conform
         # to the ones used in this file
-        $path = ConformPathToNamespace($exifTool, $path);
+        $path = ConformPathToNamespace($et, $path);
         # find existing property
         my $cap = $capture{$path}; 
         # MicrosoftPhoto screws up the case of some tags, and some other software,
@@ -805,10 +805,10 @@ sub WriteXMP($$;$)
                         push @fixed, $fixed;
                         $fixed{$fixed} = 1;
                     }
-                    my $tg = $exifTool->GetGroup($tagInfo, 1) . ':' . $$tagInfo{Name};
+                    my $tg = $et->GetGroup($tagInfo, 1) . ':' . $$tagInfo{Name};
                     my $wrn = lc($path) eq lc($matches[0]) ? 'tag ID case' : 'list type';
                     if ($err) {
-                        $exifTool->Warn("Incorrect $wrn for existing $tg (not changed)");
+                        $et->Warn("Incorrect $wrn for existing $tg (not changed)");
                     } else {
                         # fix the incorrect property paths for all values of this tag
                         foreach $match (@matches) {
@@ -819,20 +819,20 @@ sub WriteXMP($$;$)
                             delete $capture{$fixed}[1]{'xml:lang'} if $ok2 and $match !~ /^$ok2$/;
                         }
                         $cap = $capture{$path} || $capture{$fixed[0]};
-                        $exifTool->Warn("Fixed incorrect $wrn for $tg", 1);
+                        $et->Warn("Fixed incorrect $wrn for $tg", 1);
                     }
                 }
             }
         }
-        my $nvHash = $exifTool->GetNewValueHash($tagInfo);
-        my $overwrite = $exifTool->IsOverwriting($nvHash);
+        my $nvHash = $et->GetNewValueHash($tagInfo);
+        my $overwrite = $et->IsOverwriting($nvHash);
         my $writable = $$tagInfo{Writable} || '';
         my (%attrs, $deleted, $added, $existed);
         # delete existing entry if necessary
         if ($isStruct) {
             require 'Image/ExifTool/XMPStruct.pl';
-            ($deleted, $added, $existed) = DeleteStruct($exifTool, \%capture, \$path, $nvHash, \$changed);
-            next unless $deleted or $added or $exifTool->IsOverwriting($nvHash);
+            ($deleted, $added, $existed) = DeleteStruct($et, \%capture, \$path, $nvHash, \$changed);
+            next unless $deleted or $added or $et->IsOverwriting($nvHash);
             next if $existed and $$nvHash{CreateOnly};
         } elsif ($cap) {
             next if $$nvHash{CreateOnly};   # (necessary for List-type tags)
@@ -862,7 +862,7 @@ sub WriteXMP($$;$)
                             next unless $oldLang eq $newLang;
                             # only add new tag if we are overwriting this one
                             # (note: this won't match if original XML contains CDATA!)
-                            $addLang = $exifTool->IsOverwriting($nvHash, UnescapeXML($val));
+                            $addLang = $et->IsOverwriting($nvHash, UnescapeXML($val));
                             next unless $addLang;
                         }
                         # delete all if deleting "x-default" and writing with no LangCode
@@ -887,14 +887,14 @@ sub WriteXMP($$;$)
                             }
                         }
                         # (note: this won't match if original XML contains CDATA!)
-                        next unless $exifTool->IsOverwriting($nvHash, UnescapeXML($val));
+                        next unless $et->IsOverwriting($nvHash, UnescapeXML($val));
                     }
                     if ($verbose > 1) {
-                        my $grp = $exifTool->GetGroup($tagInfo, 1);
+                        my $grp = $et->GetGroup($tagInfo, 1);
                         my $tagName = $$tagInfo{Name};
                         $tagName =~ s/-$$tagInfo{LangCode}$// if $$tagInfo{LangCode};
                         $tagName .= '-' . $$attrs{'xml:lang'} if $$attrs{'xml:lang'};
-                        $exifTool->VerboseValue("- $grp:$tagName", $val);
+                        $et->VerboseValue("- $grp:$tagName", $val);
                     }
                     # save attributes and path from first deleted property
                     # so we can replace it exactly
@@ -979,7 +979,7 @@ sub WriteXMP($$;$)
             (not $cap and $isCreating);
 
         # get list of new values (all done if no new values specified)
-        my @newValues = $exifTool->GetNewValues($nvHash) or next;
+        my @newValues = $et->GetNewValues($nvHash) or next;
 
         # set language attribute for lang-alt lists
         $attrs{'xml:lang'} = $$tagInfo{LangCode} || 'x-default' if $writable eq 'lang-alt';
@@ -989,7 +989,7 @@ sub WriteXMP($$;$)
         for (;;) {
             my $newValue = shift @newValues;
             if ($isStruct) {
-                ++$changed if AddNewStruct($exifTool, $tagInfo, \%capture,
+                ++$changed if AddNewStruct($et, $tagInfo, \%capture,
                                            $path, $newValue, $$tagInfo{Struct});
             } else {
                 $newValue = EscapeXML($newValue);
@@ -1000,8 +1000,8 @@ sub WriteXMP($$;$)
                             $capture{$path} = [ '', { %attrs, 'rdf:resource' => $newValue } ];
                             last;
                         }
-                        my $grp = $exifTool->GetGroup($tagInfo, 1);
-                        $exifTool->Warn("$grp:$$tagInfo{Name} written as a literal because value is not a valid URI", 1);
+                        my $grp = $et->GetGroup($tagInfo, 1);
+                        $et->Warn("$grp:$$tagInfo{Name} written as a literal because value is not a valid URI", 1);
                         # fall through to write as a string literal
                     }
                     delete $attrs{'rdf:resource'};  # (remove existing resource if necessary)
@@ -1009,13 +1009,13 @@ sub WriteXMP($$;$)
                     last;
                 }
                 if ($verbose > 1) {
-                    my $grp = $exifTool->GetGroup($tagInfo, 1);
-                    $exifTool->VerboseValue("+ $grp:$$tagInfo{Name}", $newValue);
+                    my $grp = $et->GetGroup($tagInfo, 1);
+                    $et->VerboseValue("+ $grp:$$tagInfo{Name}", $newValue);
                 }
                 ++$changed;
                 # add rdf:type if necessary
                 if ($$tagInfo{StructType}) {
-                    AddStructType($exifTool, $$tagInfo{Table}, \%capture, $path);
+                    AddStructType($et, $$tagInfo{Table}, \%capture, $path);
                 }
             }
             last unless @newValues;
@@ -1043,14 +1043,14 @@ sub WriteXMP($$;$)
             while ($p =~ s/\/[^\/]+$//) {
                 next unless $capture{$p};
                 # it is an error if this property has a value
-                $exifTool->Error("Improperly structured XMP ($p)",1) if $capture{$p}[0] =~ /\S/;
+                $et->Error("Improperly structured XMP ($p)",1) if $capture{$p}[0] =~ /\S/;
                 delete $capture{$p};    # delete the (hopefully) empty structure
             }
         }
     }
     # remove the ExifTool members we created
-    delete $exifTool->{XMP_CAPTURE};
-    delete $exifTool->{XMP_NS};
+    delete $$et{XMP_CAPTURE};
+    delete $$et{XMP_NS};
 
     my $maxDataLen = $$dirInfo{MaxDataLen};
     # get DataPt again because it may have been set by ProcessXMP
@@ -1068,13 +1068,13 @@ sub WriteXMP($$;$)
 #
     # start writing the XMP data
     my $newData = '';
-    if ($$exifTool{XMP_NO_XPACKET}) {
+    if ($$et{XMP_NO_XPACKET}) {
         # write BOM if flag is set
-        $newData .= "\xef\xbb\xbf" if $$exifTool{XMP_NO_XPACKET} == 2;
+        $newData .= "\xef\xbb\xbf" if $$et{XMP_NO_XPACKET} == 2;
     } else {
         $newData .= $pktOpen;
     }
-    $newData .= $xmlOpen if $$exifTool{XMP_IS_XML};
+    $newData .= $xmlOpen if $$et{XMP_IS_XML};
     $newData .= $xmpOpen . $rdfOpen;
 
     # initialize current property path list
@@ -1222,12 +1222,12 @@ sub WriteXMP($$;$)
         $newData .= (' ' x scalar(@curPropList)) . " </$prop>\n";
     }
     # limit XMP length and re-arrange if necessary to fit inside specified size
-    my $compact = $$dirInfo{Compact} || $exifTool->Options('Compact');
+    my $compact = $$dirInfo{Compact} || $et->Options('Compact');
     if ($maxDataLen) {
         # adjust maxDataLen to allow room for closing elements
         $maxDataLen -= length($rdfClose) + length($xmpClose) + length($pktCloseW);
         $extStart or $extStart = length $newData;
-        my @rtn = LimitXMPSize($exifTool, \$newData, $maxDataLen, $about, \@descStart, $extStart);
+        my @rtn = LimitXMPSize($et, \$newData, $maxDataLen, $about, \@descStart, $extStart);
         # return extended XMP information in $dirInfo
         $$dirInfo{ExtendedXMP} = $rtn[0];
         $$dirInfo{ExtendedGUID} = $rtn[1];
@@ -1238,22 +1238,22 @@ sub WriteXMP($$;$)
 # close out the XMP, clean up, and return our data
 #
     $newData .= $rdfClose;
-    $newData .= $xmpClose unless $exifTool->{XMP_NO_XMPMETA};
+    $newData .= $xmpClose unless $$et{XMP_NO_XMPMETA};
 
     # remove the ExifTool members we created
-    delete $exifTool->{XMP_CAPTURE};
-    delete $exifTool->{XMP_NS};
-    delete $exifTool->{XMP_NO_XMPMETA};
+    delete $$et{XMP_CAPTURE};
+    delete $$et{XMP_NS};
+    delete $$et{XMP_NO_XMPMETA};
 
     # (the XMP standard recommends writing 2k-4k of white space before the
     # packet trailer, with a newline every 100 characters)
-    unless ($$exifTool{XMP_NO_XPACKET}) {
+    unless ($$et{XMP_NO_XPACKET}) {
         my $pad = (' ' x 100) . "\n";
         if ($$dirInfo{InPlace}) {
             # pad to specified DirLen
             my $len = length($newData) + length($pktCloseW);
             if ($len > $dirLen) {
-                $exifTool->Warn('Not enough room to edit XMP in place');
+                $et->Warn('Not enough room to edit XMP in place');
                 return undef;
             }
             my $num = int(($dirLen - $len) / length($pad));
@@ -1273,13 +1273,13 @@ sub WriteXMP($$;$)
     }
     if ($xmpErr) {
         if ($xmpFile) {
-            $exifTool->Error($xmpErr);
+            $et->Error($xmpErr);
             return -1;
         }
-        $exifTool->Warn($xmpErr);
+        $et->Warn($xmpErr);
         return undef;
     }
-    $exifTool->{CHANGED} += $changed;
+    $$et{CHANGED} += $changed;
     $debug > 1 and $newData and print $newData,"\n";
     return $newData unless $xmpFile;
     Write($$dirInfo{OutFile}, $newData) or return -1;