exiftool_vendored 9.37.0 → 9.41.0

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

@@ -111,20 +111,54 @@ sub WriteProfile($$$;$)
 # Returns: true on success
 sub Add_iCCP($$)
 {
-    my ($exifTool, $outfile) = @_;
-    if ($exifTool->{ADD_DIRS}->{ICC_Profile}) {
+    my ($et, $outfile) = @_;
+    if ($$et{ADD_DIRS}{ICC_Profile}) {
         # write new ICC data
         my $tagTablePtr = Image::ExifTool::GetTagTable('Image::ExifTool::ICC_Profile::Main');
         my %dirInfo = ( Parent => 'PNG', DirName => 'ICC_Profile' );
-        my $buff = $exifTool->WriteDirectory(\%dirInfo, $tagTablePtr);
+        my $buff = $et->WriteDirectory(\%dirInfo, $tagTablePtr);
         if (defined $buff and length $buff and WriteProfile($outfile, 'icm', \$buff)) {
-            $exifTool->VPrint(0, "Created ICC profile\n");
-            delete $exifTool->{ADD_DIRS}->{ICC_Profile}; # don't add it again
+            $et->VPrint(0, "Created ICC profile\n");
+            delete $$et{ADD_DIRS}{ICC_Profile}; # don't add it again
+            $$et{PNGDoneDir}{ICC_Profile} = 2;
         }
     }
     return 1;
 }
 
+#------------------------------------------------------------------------------
+# This routine is called after we edit an existing directory
+# Inputs: 0) ExifTool ref, 1) dir name, 2) output data ref
+#         3) flag set if location is non-standard (to update, but not create from scratch)
+# - on return, $$outBuff is set to '' if the directory is to be deleted
+sub DoneDir($$$;$)
+{
+    my ($et, $dir, $outBuff, $nonStandard) = @_;
+    # don't add this directory again unless this is in a non-standard location
+    delete $$et{ADD_DIRS}{$dir} unless $nonStandard;
+    # handle problem with duplicate XMP when using PNGEarlyXMP option
+    return unless $dir eq 'XMP' and defined $$outBuff and length $$outBuff;
+    if ($nonStandard and $$et{DEL_GROUP}{$dir}) {
+        $et->VPrint(0,"  Deleting non-standard $dir\n");
+        $$outBuff = '';
+    } elsif (not $$et{PNGDoneDir}{$dir}) {
+        $$et{PNGDoneDir}{$dir} = 1;   # set flag indicating the directory exists
+    } elsif ($$et{OPTIONS}{PNGEarlyXMP}) {
+        if ($$et{PNGDoneDir}{$dir} == 2) {
+            if ($$et{OPTIONS}{IgnoreMinorErrors}) {
+                $et->Warn("Deleted existing $dir");
+            } else {
+                $et->Error("Duplicate $dir created. Ignore to delete existing $dir", 1);
+                return;
+            }
+        } elsif ($et->Warn("Duplicate $dir. Ignore to delete", 2)) {
+            return; # warning not ignored: don't delete the duplicate
+        }
+        $et->VPrint(0,"  Deleting duplicate $dir\n");
+        $$outBuff = '';
+    }
+}
+
 #------------------------------------------------------------------------------
 # Generate tEXt, zTXt or iTXt data for writing
 # Inputs: 0) ExifTool ref, 1) tagID, 2) tagInfo ref, 3) value string, 4) language code
@@ -132,7 +166,7 @@ sub Add_iCCP($$)
 # Notes: Sets ExifTool TextChunkType member to the type of chunk written
 sub BuildTextChunk($$$$$)
 {
-    my ($exifTool, $tag, $tagInfo, $val, $lang) = @_;
+    my ($et, $tag, $tagInfo, $val, $lang) = @_;
     my ($xtra, $compVal, $iTXt, $comp);
     if ($$tagInfo{SubDirectory}) {
         if ($$tagInfo{Name} eq 'XMP') {
@@ -143,11 +177,11 @@ sub BuildTextChunk($$$$$)
         }
     } else {
         # compress if specified
-        $comp = 1 if $exifTool->Options('Compress');
+        $comp = 1 if $et->Options('Compress');
         if ($lang) {
             $iTXt = 1;      # write as iTXt if it has a language code
             $tag =~ s/-$lang$//;    # remove language code from tagID
-        } elsif ($$exifTool{OPTIONS}{Charset} ne 'Latin' and $val =~  /[\x80-\xff]/) {
+        } elsif ($$et{OPTIONS}{Charset} ne 'Latin' and $val =~  /[\x80-\xff]/) {
             $iTXt = 1;      # write as iTXt if it contains non-Latin special characters
         }
     }
@@ -171,20 +205,20 @@ sub BuildTextChunk($$$$$)
         }
         # warn if any user-specified compression fails
         if ($warn and $comp == 1) {
-            $exifTool->Warn("PNG:$$tagInfo{Name} not compressed ($warn)", 1);
+            $et->Warn("PNG:$$tagInfo{Name} not compressed ($warn)", 1);
         }
     }
     # decide whether to write as iTXt, zTXt or tEXt
     if ($iTXt) {
-        $$exifTool{TextChunkType} = 'iTXt';
+        $$et{TextChunkType} = 'iTXt';
         $xtra = (defined $compVal ? "\x01\0" : "\0\0") . ($lang || '') . "\0\0";
         # iTXt is encoded as UTF-8 (but note that XMP is already UTF-8)
-        $val = $exifTool->Encode($val, 'UTF8') if $iTXt == 1;
+        $val = $et->Encode($val, 'UTF8') if $iTXt == 1;
     } elsif (defined $compVal) {
-        $$exifTool{TextChunkType} = 'zTXt';
+        $$et{TextChunkType} = 'zTXt';
         $xtra = "\0";
     } else {
-        $$exifTool{TextChunkType} = 'tEXt';
+        $$et{TextChunkType} = 'tEXt';
         $xtra = '';
     }
     return $tag . "\0" . $xtra . (defined $compVal ? $compVal : $val);
@@ -193,60 +227,68 @@ sub BuildTextChunk($$$$$)
 #------------------------------------------------------------------------------
 # Add any outstanding new chunks to the PNG image
 # Inputs: 0) ExifTool object ref, 1) output file or scalar ref
+#         2-N) dirs to add (empty to add all, including PNG tags)
 # Returns: true on success
-sub AddChunks($$)
+sub AddChunks($$;@)
 {
-    my ($exifTool, $outfile) = @_;
-    # write any outstanding PNG tags
-    my $addTags = $exifTool->{ADD_PNG};
-    delete $exifTool->{ADD_PNG};
-    my ($tag, $dir, $err, $tagTablePtr);
+    my ($et, $outfile, @add) = @_;
+    my ($addTags, $tag, $dir, $err, $tagTablePtr);
 
+    if (@add) {
+        $addTags = { }; # don't add any PNG tags
+    } else {
+        $addTags = $$et{ADD_PNG};    # add all PNG tags...
+        delete $$et{ADD_PNG};        # ...once
+        # add all directories
+        @add = sort keys %{$$et{ADD_DIRS}};
+    }
+    # write any outstanding PNG tags
     foreach $tag (sort keys %$addTags) {
         my $tagInfo = $$addTags{$tag};
-        my $nvHash = $exifTool->GetNewValueHash($tagInfo);
+        my $nvHash = $et->GetNewValueHash($tagInfo);
         # (native PNG information is always preferred, so don't check IsCreating)
-        next unless $exifTool->IsOverwriting($nvHash);
-        my $val = $exifTool->GetNewValues($nvHash);
+        next unless $et->IsOverwriting($nvHash);
+        my $val = $et->GetNewValues($nvHash);
         if (defined $val) {
             next if $$nvHash{EditOnly};
             my $data;
             if ($$tagInfo{Table} eq \%Image::ExifTool::PNG::TextualData) {
-                $data = BuildTextChunk($exifTool, $tag, $tagInfo, $val, $$tagInfo{LangCode});
-                $data = $$exifTool{TextChunkType} . $data;
-                delete $$exifTool{TextChunkType};
+                $data = BuildTextChunk($et, $tag, $tagInfo, $val, $$tagInfo{LangCode});
+                $data = $$et{TextChunkType} . $data;
+                delete $$et{TextChunkType};
             } else {
                 $data = "$tag$val";
             }
             my $hdr = pack('N', length($data) - 4);
             my $cbuf = pack('N', CalculateCRC(\$data, undef));
             Write($outfile, $hdr, $data, $cbuf) or $err = 1;
-            $exifTool->VerboseValue("+ PNG:$$tagInfo{Name}", $val);
-            ++$exifTool->{CHANGED};
+            $et->VerboseValue("+ PNG:$$tagInfo{Name}", $val);
+            $$et{PNGDoneTag}{$tag} = 1;   # set flag indicating this tag was added
+            ++$$et{CHANGED};
         }
     }
-    $addTags = { };     # prevent from adding tags again
     # create any necessary directories
-    foreach $dir (sort keys %{$exifTool->{ADD_DIRS}}) {
+    foreach $dir (@add) {
+        next unless $$et{ADD_DIRS}{$dir}; # make sure we want to add it first
         my $buff;
         my %dirInfo = (
             Parent => 'PNG',
             DirName => $dir,
         );
         if ($dir eq 'IFD0') {
-            $exifTool->VPrint(0, "Creating EXIF profile:\n");
-            $exifTool->{TIFF_TYPE} = 'APP1';
+            $et->VPrint(0, "Creating EXIF profile:\n");
+            $$et{TIFF_TYPE} = 'APP1';
             $tagTablePtr = Image::ExifTool::GetTagTable('Image::ExifTool::Exif::Main');
-            $buff = $exifTool->WriteDirectory(\%dirInfo, $tagTablePtr, \&Image::ExifTool::WriteTIFF);
+            $buff = $et->WriteDirectory(\%dirInfo, $tagTablePtr, \&Image::ExifTool::WriteTIFF);
             if (defined $buff and length $buff) {
                 $buff = $Image::ExifTool::exifAPP1hdr . $buff;
                 WriteProfile($outfile, 'APP1', \$buff, 'generic') or $err = 1;
             }
         } elsif ($dir eq 'XMP') {
-            $exifTool->VPrint(0, "Creating XMP iTXt chunk:\n");
+            $et->VPrint(0, "Creating XMP iTXt chunk:\n");
             $tagTablePtr = Image::ExifTool::GetTagTable('Image::ExifTool::XMP::Main');
             $dirInfo{ReadOnly} = 1;
-            $buff = $exifTool->WriteDirectory(\%dirInfo, $tagTablePtr);
+            $buff = $et->WriteDirectory(\%dirInfo, $tagTablePtr);
             if (defined $buff and length $buff and
                 # the packet is read-only (because of CRC)
                 Image::ExifTool::XMP::ValidateXMP(\$buff, 'r'))
@@ -261,26 +303,30 @@ sub AddChunks($$)
                 Write($outfile, $hdr, $buff, $cbuf) or $err = 1;
             }
         } elsif ($dir eq 'IPTC') {
-            $exifTool->VPrint(0, "Creating IPTC profile:\n");
+            $et->VPrint(0, "Creating IPTC profile:\n");
             # write new IPTC data (stored in a Photoshop directory)
             $dirInfo{DirName} = 'Photoshop';
             $tagTablePtr = Image::ExifTool::GetTagTable('Image::ExifTool::Photoshop::Main');
-            $buff = $exifTool->WriteDirectory(\%dirInfo, $tagTablePtr);
+            $buff = $et->WriteDirectory(\%dirInfo, $tagTablePtr);
             if (defined $buff and length $buff) {
                 WriteProfile($outfile, 'iptc', \$buff, 'IPTC') or $err = 1;
             }
         } elsif ($dir eq 'ICC_Profile') {
-            $exifTool->VPrint(0, "Creating ICC profile:\n");
+            $et->VPrint(0, "Creating ICC profile:\n");
             # write new ICC data (only done if we couldn't create iCCP chunk)
             $tagTablePtr = Image::ExifTool::GetTagTable('Image::ExifTool::ICC_Profile::Main');
-            $buff = $exifTool->WriteDirectory(\%dirInfo, $tagTablePtr);
+            $buff = $et->WriteDirectory(\%dirInfo, $tagTablePtr);
             if (defined $buff and length $buff) {
                 WriteProfile($outfile, 'icm', \$buff, 'ICC') or $err = 1;
-                $exifTool->Warn('Wrote ICC as a raw profile (no Compress::Zlib)');
+                $et->Warn('Wrote ICC as a raw profile (no Compress::Zlib)');
             }
+        } else {
+            next;
         }
+        delete $$et{ADD_DIRS}{$dir};  # don't add again
+        # keep track of the directories that we added
+        $$et{PNGDoneDir}{$dir} = 2 if defined $buff and length $buff;
     }
-    $exifTool->{ADD_DIRS} = { };    # prevent from adding dirs again
     return not $err;
 }
 

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

@@ -44,8 +44,8 @@ sub SetResourceName($$$)
 # Notes: Increments ExifTool CHANGED flag for each tag changed
 sub WritePhotoshop($$$)
 {
-    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};
     unless ($dataPt) {
         my $emptyData = '';
@@ -57,9 +57,9 @@ sub WritePhotoshop($$$)
     my $newData = '';
 
     # make a hash of new tag info, keyed on tagID
-    my $newTags = $exifTool->GetNewTagInfoHash($tagTablePtr);
+    my $newTags = $et->GetNewTagInfoHash($tagTablePtr);
 
-    my ($addDirs, $editDirs) = $exifTool->GetAddDirHash($tagTablePtr);
+    my ($addDirs, $editDirs) = $et->GetAddDirHash($tagTablePtr);
 
     SetByteOrder('MM');     # Photoshop is always big-endian
 #
@@ -77,7 +77,7 @@ sub WritePhotoshop($$$)
         ++$pos if ($pos ^ $start) & 0x01;
         my $type = substr($$dataPt, $pos, 4);
         if ($type !~ /^(8BIM|PHUT|DCSR|AgHg)$/) {
-            $exifTool->Error("Bad Photoshop IRB resource");
+            $et->Error("Bad Photoshop IRB resource");
             undef $newData;
             last;
         }
@@ -86,7 +86,7 @@ sub WritePhotoshop($$$)
         my $namelen = 1 + Get8u($dataPt, $pos + 6);
         ++$namelen if $namelen & 0x01;
         if ($pos + $namelen + 10 > $dirEnd) {
-            $exifTool->Error("Bad APP13 resource block");
+            $et->Error("Bad APP13 resource block");
             undef $newData;
             last;
         }
@@ -94,43 +94,43 @@ sub WritePhotoshop($$$)
         $size = Get32u($dataPt, $pos + 6 + $namelen);
         $pos += $namelen + 10;
         if ($size + $pos > $dirEnd) {
-            $exifTool->Error("Bad APP13 resource data size $size");
+            $et->Error("Bad APP13 resource data size $size");
             undef $newData;
             last;
         }
         if ($$newTags{$tagID} and $type eq '8BIM') {
             $tagInfo = $$newTags{$tagID};
             delete $$newTags{$tagID};
-            my $nvHash = $exifTool->GetNewValueHash($tagInfo);
+            my $nvHash = $et->GetNewValueHash($tagInfo);
             # check to see if we are overwriting this tag
             $value = substr($$dataPt, $pos, $size);
-            my $isOverwriting = $exifTool->IsOverwriting($nvHash, $value);
+            my $isOverwriting = $et->IsOverwriting($nvHash, $value);
             # handle special 'new' and 'old' values for IPTCDigest
             if (not $isOverwriting and $tagInfo eq $iptcDigestInfo) {
                 if (grep /^new$/, @{$$nvHash{DelValue}}) {
-                    $isOverwriting = 1 if $$exifTool{NewIPTCDigest} and
-                                          $$exifTool{NewIPTCDigest} eq $value;
+                    $isOverwriting = 1 if $$et{NewIPTCDigest} and
+                                          $$et{NewIPTCDigest} eq $value;
                 }
                 if (grep /^old$/, @{$$nvHash{DelValue}}) {
-                    $isOverwriting = 1 if $$exifTool{OldIPTCDigest} and
-                                          $$exifTool{OldIPTCDigest} eq $value;
+                    $isOverwriting = 1 if $$et{OldIPTCDigest} and
+                                          $$et{OldIPTCDigest} eq $value;
                 }
             }
             if ($isOverwriting) {
-                $exifTool->VerboseValue("- Photoshop:$$tagInfo{Name}", $value);
+                $et->VerboseValue("- Photoshop:$$tagInfo{Name}", $value);
                 # handle IPTCDigest specially because we want to write it last
                 # so the new IPTC digest will be known
                 if ($tagInfo eq $iptcDigestInfo) {
                     $$newTags{$tagID} = $tagInfo;   # add later
                     $value = undef;
                 } else {
-                    $value = $exifTool->GetNewValues($nvHash);
+                    $value = $et->GetNewValues($nvHash);
                 }
-                ++$exifTool->{CHANGED};
+                ++$$et{CHANGED};
                 next unless defined $value;     # next if tag is being deleted
                 # set resource name if necessary
                 SetResourceName($tagInfo, $name, \$value);
-                $exifTool->VerboseValue("+ Photoshop:$$tagInfo{Name}", $value);
+                $et->VerboseValue("+ Photoshop:$$tagInfo{Name}", $value);
             }
         } else {
             if ($type eq '8BIM') {
@@ -138,7 +138,7 @@ sub WritePhotoshop($$$)
                 unless ($tagInfo) {
                     # process subdirectory anyway if writable (except EXIF to avoid recursion)
                     # --> this allows IPTC to be processed if found here in TIFF images
-                    my $tmpInfo = $exifTool->GetTagInfo($tagTablePtr, $tagID);
+                    my $tmpInfo = $et->GetTagInfo($tagTablePtr, $tagID);
                     if ($tmpInfo and $$tmpInfo{SubDirectory} and
                         $tmpInfo->{SubDirectory}->{TagTable} ne 'Image::ExifTool::Exif::Main')
                     {
@@ -158,7 +158,7 @@ sub WritePhotoshop($$$)
                 );
                 my $subTable = Image::ExifTool::GetTagTable($tagInfo->{SubDirectory}->{TagTable});
                 my $writeProc = $tagInfo->{SubDirectory}->{WriteProc};
-                my $newValue = $exifTool->WriteDirectory(\%subdirInfo, $subTable, $writeProc);
+                my $newValue = $et->WriteDirectory(\%subdirInfo, $subTable, $writeProc);
                 if (defined $newValue) {
                     next unless length $newValue;   # remove subdirectory entry
                     $value = $newValue;
@@ -184,14 +184,14 @@ sub WritePhotoshop($$$)
         my $name = "\0\0";
         if ($$newTags{$tagID}) {
             $tagInfo = $$newTags{$tagID};
-            my $nvHash = $exifTool->GetNewValueHash($tagInfo);
-            $value = $exifTool->GetNewValues($nvHash);
+            my $nvHash = $et->GetNewValueHash($tagInfo);
+            $value = $et->GetNewValues($nvHash);
             # handle new IPTCDigest value specially
             if ($tagInfo eq $iptcDigestInfo and defined $value) {
                 if ($value eq 'new') {
-                    $value = $$exifTool{NewIPTCDigest};
+                    $value = $$et{NewIPTCDigest};
                 } elsif ($value eq 'old') {
-                    $value = $$exifTool{OldIPTCDigest};
+                    $value = $$et{OldIPTCDigest};
                 }
                 # (we already know we want to create this tag)
             } else {
@@ -199,8 +199,8 @@ sub WritePhotoshop($$$)
                 next unless $$nvHash{IsCreating};
             }
             next unless defined $value;     # next if tag is being deleted
-            $exifTool->VerboseValue("+ Photoshop:$$tagInfo{Name}", $value);
-            ++$exifTool->{CHANGED};
+            $et->VerboseValue("+ Photoshop:$$tagInfo{Name}", $value);
+            ++$$et{CHANGED};
         } else {
             $tagInfo = $$addDirs{$tagID};
             # create new directory
@@ -209,7 +209,7 @@ sub WritePhotoshop($$$)
             );
             my $subTable = Image::ExifTool::GetTagTable($tagInfo->{SubDirectory}->{TagTable});
             my $writeProc = $tagInfo->{SubDirectory}->{WriteProc};
-            $value = $exifTool->WriteDirectory(\%subdirInfo, $subTable, $writeProc);
+            $value = $et->WriteDirectory(\%subdirInfo, $subTable, $writeProc);
             next unless $value;
         }
         # set resource name if necessary
@@ -218,7 +218,7 @@ sub WritePhotoshop($$$)
         # write the new directory entry
         $newData .= '8BIM' . Set16u($tagID) . $name . Set32u($size) . $value;
         $newData .= "\0" if $size & 0x01;   # must null pad to even numbered byte
-        ++$exifTool->{CHANGED};
+        ++$$et{CHANGED};
     }
     return $newData;
 }

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

@@ -94,7 +94,7 @@ sub WriteXMPDir($$@)
 # Returns: 0=error, 1=nothing written, 2=dir written ok
 sub WritePSDirectory($$$$$)
 {
-    my ($exifTool, $outfile, $dirName, $dataPt, $flags) = @_;
+    my ($et, $outfile, $dirName, $dataPt, $flags) = @_;
     my $success = 2;
     my $len = $dataPt ? length($$dataPt) : 0;
     my $create = $len ? 0 : 1;
@@ -116,14 +116,14 @@ sub WritePSDirectory($$$$$)
         # isolate the XMP
         pos($$dataPt) = 0;
         unless ($$dataPt =~ /(.*)(<\?xpacket begin=.{7,13}W5M0MpCehiHzreSzNTczkc9d)/sg) {
-            $exifTool->Warn('No XMP packet start');
+            $et->Warn('No XMP packet start');
             return WriteXMPDir($outfile, $flags, $$dataPt);
         }
         $beforeXMP = $1;
         my $xmp = $2;
         my $p1 = pos($$dataPt);
         unless ($$dataPt =~ m{<\?xpacket end=.(w|r).\?>}sg) {
-            $exifTool->Warn('No XMP packet end');
+            $et->Warn('No XMP packet end');
             return WriteXMPDir($outfile, $flags, $$dataPt);
         }
         my $p2 = pos($$dataPt);
@@ -142,7 +142,7 @@ sub WritePSDirectory($$$$$)
         $dirInfo{DataPt} = \$xmp;
     }
     my $tagTablePtr = Image::ExifTool::GetTagTable("Image::ExifTool::${dirName}::Main");
-    my $val = $exifTool->WriteDirectory(\%dirInfo, $tagTablePtr);
+    my $val = $et->WriteDirectory(\%dirInfo, $tagTablePtr);
     if (defined $val) {
         $dataPt = \$val;    # use modified directory
         $len = length $val;
@@ -160,7 +160,7 @@ sub WritePSDirectory($$$$$)
 <x:xmpmeta xmlns:x='adobe:ns:meta/' x:xmptk='Image::ExifTool $Image::ExifTool::VERSION'>
 </x:xmpmeta>
 EMPTY_XMP
-        $val .= ((' ' x 100) . "\n") x 24 unless $exifTool->Options('Compact');
+        $val .= ((' ' x 100) . "\n") x 24 unless $et->Options('Compact');
         $val .= q{<?xpacket end='w'?>};
         $dataPt = \$val;
         $len = length $val;
@@ -238,7 +238,7 @@ PS_AFTER
         }
         Write($outfile, $endToken, $/) or $success = 0;
     } else {
-        $exifTool->Warn("Can't write PS directory $dirName");
+        $et->Warn("Can't write PS directory $dirName");
     }
     undef $val;
     return $success;
@@ -278,7 +278,7 @@ sub EncodeTag($$)
 # Returns: true on success
 sub WriteNewTags($$$)
 {
-    my ($exifTool, $outfile, $newTags) = @_;
+    my ($et, $outfile, $newTags) = @_;
     my $success = 1;
     my $tag;
 
@@ -288,12 +288,12 @@ sub WriteNewTags($$$)
 
     foreach $tag (sort keys %$newTags) {
         my $tagInfo = $$newTags{$tag};
-        my $nvHash = $exifTool->GetNewValueHash($tagInfo);
+        my $nvHash = $et->GetNewValueHash($tagInfo);
         next unless $$nvHash{IsCreating};
-        my $val = $exifTool->GetNewValues($nvHash);
-        $exifTool->VerboseValue("+ PostScript:$$tagInfo{Name}", $val);
+        my $val = $et->GetNewValues($nvHash);
+        $et->VerboseValue("+ PostScript:$$tagInfo{Name}", $val);
         Write($outfile, EncodeTag($tag, $val)) or $success = 0;
-        ++$exifTool->{CHANGED};
+        ++$$et{CHANGED};
     }
     # write XMP hint if necessary
     Write($outfile, "%ADO_ContainsXMP: MainFirst$/") or $success = 0 if $xmpHint;
@@ -357,13 +357,13 @@ sub SplitLine($$)
 #          or -1 if a write error occurred
 sub WritePS($$)
 {
-    my ($exifTool, $dirInfo) = @_;
-    $exifTool or return 1;    # allow dummy access to autoload this package
+    my ($et, $dirInfo) = @_;
+    $et or return 1;    # allow dummy access to autoload this package
     my $tagTablePtr = Image::ExifTool::GetTagTable('Image::ExifTool::PostScript::Main');
     my $raf = $$dirInfo{RAF};
     my $outfile = $$dirInfo{OutFile};
-    my $verbose = $exifTool->Options('Verbose');
-    my $out = $exifTool->Options('TextOut');
+    my $verbose = $et->Options('Verbose');
+    my $out = $et->Options('TextOut');
     my ($data, $buff, %flags, $err, $mode, $endToken);
     my ($dos, $psStart, $psEnd, $psNewStart, $xmpHint);
 
@@ -387,7 +387,7 @@ sub WritePS($$)
         unless ($raf->Seek($psStart, 0) and
                 $raf->Read($data, 4) == 4 and $data eq '%!PS')
         {
-            $exifTool->Error('Invalid PS header');
+            $et->Error('Invalid PS header');
             return 1;
         }
         $psEnd = $psStart + Get32u(\$dos, 8);
@@ -400,7 +400,7 @@ sub WritePS($$)
                 Base => $base,
                 NoTiffEnd => 1, # no end-of-TIFF check
             );
-            $buff = $exifTool->WriteTIFF(\%dirInfo);
+            $buff = $et->WriteTIFF(\%dirInfo);
             SetByteOrder('II'); # (WriteTIFF may change this)
             if ($buff) {
                 $buff = substr($buff, $base);   # remove header written by WriteTIFF()
@@ -408,10 +408,10 @@ sub WritePS($$)
                 # error rewriting TIFF, so just copy over original data
                 my $len = Get32u(\$dos, 24);
                 unless ($raf->Seek($base, 0) and $raf->Read($buff, $len) == $len) {
-                    $exifTool->Error('Error reading embedded TIFF');
+                    $et->Error('Error reading embedded TIFF');
                     return 1;
                 }
-                $exifTool->Warn('Bad embedded TIFF');
+                $et->Warn('Bad embedded TIFF');
             }
             Set32u(0, \$dos, 12);                   # zero metafile pointer
             Set32u(0, \$dos, 16);                   # zero metafile length
@@ -421,7 +421,7 @@ sub WritePS($$)
             # copy over metafile section
             my $len = Get32u(\$dos, 16);
             unless ($raf->Seek($base, 0) and $raf->Read($buff, $len) == $len) {
-                $exifTool->Error('Error reading metafile section');
+                $et->Error('Error reading metafile section');
                 return 1;
             }
             Set32u(length($dos), \$dos, 12);        # set metafile pointer
@@ -438,12 +438,12 @@ sub WritePS($$)
 #
     local $/ = GetInputRecordSeparator($raf);
     unless ($/ and $raf->ReadLine($buff)) {
-        $exifTool->Error('Invalid PostScript data');
+        $et->Error('Invalid PostScript data');
         return 1;
     }
     $data .= $buff;
     unless ($data =~ /^%!PS-Adobe-3\.(\d+)\b/ and $1 < 2) {
-        if ($exifTool->Error("Document does not conform to DSC spec. Metadata may be unreadable by other apps", 2)) {
+        if ($et->Error("Document does not conform to DSC spec. Metadata may be unreadable by other apps", 2)) {
             return 1;
         }
     }
@@ -452,17 +452,17 @@ sub WritePS($$)
     $flags{EPS} = 1 if $data =~ /EPSF/;
 
     # get hash of new information keyed by tagID and directories to add/edit
-    my $newTags = $exifTool->GetNewTagInfoHash($tagTablePtr);
+    my $newTags = $et->GetNewTagInfoHash($tagTablePtr);
 
     # figure out which directories we need to write (PostScript takes priority)
-    $exifTool->InitWriteDirs(\%psMap, 'PostScript');
-    my $addDirs = $exifTool->{ADD_DIRS};
-    my $editDirs = $exifTool->{EDIT_DIRS};
+    $et->InitWriteDirs(\%psMap, 'PostScript');
+    my $addDirs = $$et{ADD_DIRS};
+    my $editDirs = $$et{EDIT_DIRS};
     my %doneDir;
 
     # set XMP hint flag (1 for adding, 0 for deleting, undef for no change)
     $xmpHint = 1 if $$addDirs{XMP};
-    $xmpHint = 0 if $$exifTool{DEL_GROUP}{XMP};
+    $xmpHint = 0 if $$et{DEL_GROUP}{XMP};
     $$newTags{XMP_HINT} = $xmpHint if $xmpHint;  # add special tag to newTags list
 
     my (@lines, $changedNL);
@@ -499,9 +499,9 @@ sub WritePS($$)
                 undef $endToken;
                 # found end: process this information
                 if ($mode) {
-                    $doneDir{$mode} and $exifTool->Error("Multiple $mode directories", 1);
+                    $doneDir{$mode} and $et->Error("Multiple $mode directories", 1);
                     $doneDir{$mode} = 1;
-                    WritePSDirectory($exifTool, $outfile, $mode, \$buff, \%flags) or $err = 1;
+                    WritePSDirectory($et, $outfile, $mode, \$buff, \%flags) or $err = 1;
                     # write end token if we wrote the begin token
                     Write($outfile, $data) or $err = 1 if $flags{WROTE_BEGIN};
                     undef $buff;
@@ -531,7 +531,7 @@ sub WritePS($$)
             next;
         } elsif ($data =~ m{^(%{1,2})(Begin)(?!Object:)(.*?)[:\x0d\x0a]}i) {
             # comments section is over... write any new tags now
-            WriteNewTags($exifTool, $outfile, $newTags) or $err = 1 if %$newTags;
+            WriteNewTags($et, $outfile, $newTags) or $err = 1 if %$newTags;
             undef $xmpHint;
             # the beginning of a data block (can only write XMP and Photoshop)
             my %modeLookup = (
@@ -563,9 +563,9 @@ sub WritePS($$)
                 # (Illustrator 8 and older write PS-Adobe-3.0, newer write PS-Adobe-3.1)
                 if ($$editDirs{XMP} and $psRev == 0) {
                     if ($flags{EPS}) {
-                        $exifTool->Warn("Can't write XMP to Illustrator 8 or older EPS files");
+                        $et->Warn("Can't write XMP to Illustrator 8 or older EPS files");
                     } else {
-                        $exifTool->Warn("Can't write XMP to PS-format AI files");
+                        $et->Warn("Can't write XMP to PS-format AI files");
                     }
                     # pretend like we wrote it already so we won't try to add it later
                     $doneDir{XMP} = 1;
@@ -574,7 +574,7 @@ sub WritePS($$)
                 # (we need it to be able to recognize these files)
                 # --> find a better way to do this!
                 if ($$newTags{$tag}) {
-                    $exifTool->Warn("Can't change Postscript:Creator of Illustrator files");
+                    $et->Warn("Can't change Postscript:Creator of Illustrator files");
                     delete $$newTags{$tag};
                 }
             }
@@ -584,14 +584,14 @@ sub WritePS($$)
                 next unless ref $tagInfo;
                 # decode comment string (reading continuation lines if necessary)
                 $val = DecodeComment($val, $raf, \@lines, \$data);
-                $val = join $exifTool->Options('ListSep'), @$val if ref $val eq 'ARRAY';
-                my $nvHash = $exifTool->GetNewValueHash($tagInfo);
-                if ($exifTool->IsOverwriting($nvHash, $val)) {
-                    $exifTool->VerboseValue("- PostScript:$$tagInfo{Name}", $val);
-                    $val = $exifTool->GetNewValues($nvHash);
-                    ++$exifTool->{CHANGED};
+                $val = join $et->Options('ListSep'), @$val if ref $val eq 'ARRAY';
+                my $nvHash = $et->GetNewValueHash($tagInfo);
+                if ($et->IsOverwriting($nvHash, $val)) {
+                    $et->VerboseValue("- PostScript:$$tagInfo{Name}", $val);
+                    $val = $et->GetNewValues($nvHash);
+                    ++$$et{CHANGED};
                     next unless defined $val;   # next if tag is being deleted
-                    $exifTool->VerboseValue("+ PostScript:$$tagInfo{Name}", $val);
+                    $et->VerboseValue("+ PostScript:$$tagInfo{Name}", $val);
                     $data = EncodeTag($tag, $val);
                 }
             }
@@ -612,7 +612,7 @@ sub WritePS($$)
                 $data =~ /^%(%EndComments|%Page:|%PlateFile:|%BeginObject:|.*BeginLayer)/))
             {
                 # write new tags at end of comments section
-                WriteNewTags($exifTool, $outfile, $newTags) or $err = 1;
+                WriteNewTags($et, $outfile, $newTags) or $err = 1;
                 undef $xmpHint;
             }
             # look for start of drawing commands (AI uses "%AI5_BeginLayer",
@@ -629,12 +629,12 @@ sub WritePS($$)
                     next unless $$editDirs{$dir} and not $doneDir{$dir};
                     if ($plateFile) {
                         # PlateFile comments may contain offsets so we can't edit these files!
-                        $exifTool->Warn("Can only edit PostScript information DCS Plate files");
+                        $et->Warn("Can only edit PostScript information DCS Plate files");
                         last;
                     }
                     next unless $$addDirs{$dir} or $dir eq 'XMP';
                     $flags{WROTE_BEGIN} = 0;
-                    WritePSDirectory($exifTool, $outfile, $dir, undef, \%flags) or $err = 1;
+                    WritePSDirectory($et, $outfile, $dir, undef, \%flags) or $err = 1;
                     $doneDir{$dir} = 1;
                 }
                 # copy rest of file
@@ -684,7 +684,7 @@ sub WritePS($$)
                     print $outfile Set32u($pos - $psNewStart) and
                     seek($outfile, $pos, 0))
             {
-                $exifTool->Error("Can't write DOS-style PS files in non-seekable stream");
+                $et->Error("Can't write DOS-style PS files in non-seekable stream");
                 $err = 1;
             }
         }
@@ -696,11 +696,11 @@ sub WritePS($$)
         push @notDone, 'PostScript' if %$newTags;
         foreach $dir (qw{Photoshop ICC_Profile XMP}) {
             push @notDone, $dir if $$editDirs{$dir} and not $doneDir{$dir} and
-                                   not $$exifTool{DEL_GROUP}{$dir};
+                                   not $$et{DEL_GROUP}{$dir};
         }
-        @notDone and $exifTool->Warn("Couldn't write ".join('/',@notDone).' information');
+        @notDone and $et->Warn("Couldn't write ".join('/',@notDone).' information');
     }
-    $endToken and $exifTool->Error("File missing $endToken");
+    $endToken and $et->Error("File missing $endToken");
     return $err ? -1 : 1;
 }