exiftool_vendored 9.37.0 → 9.41.0

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

@@ -85,7 +85,7 @@ sub PrintInvCodedCharset($)
     my $val = shift;
     my $code = $iptcCharsetInv{uc($val)};
     unless ($code) {
-        if (($code = $val) =~ s/ESC /\x1b/g) {  # translate ESC chars
+        if (($code = $val) =~ s/ESC */\x1b/ig) {  # translate ESC chars
             $code =~ s/, \x1b/\x1b/g;   # remove comma separators
             $code =~ tr/ //d;           # remove spaces
         } else {
@@ -101,7 +101,7 @@ sub PrintInvCodedCharset($)
 # Returns: error string or undef (and possibly changes value) on success
 sub CheckIPTC($$$)
 {
-    my ($exifTool, $tagInfo, $valPtr) = @_;
+    my ($et, $tagInfo, $valPtr) = @_;
     my $format = $$tagInfo{Format} || $tagInfo->{Table}->{FORMAT} || '';
     if ($format =~ /^int(\d+)/) {
         my $bytes = int(($1 || 0) / 8);
@@ -130,8 +130,8 @@ sub CheckIPTC($$$)
         if (defined $minlen) {
             $maxlen or $maxlen = $minlen;
             return "String too short (minlen is $minlen)" if $len < $minlen;
-            if ($len > $maxlen and not $exifTool->Options('IgnoreMinorErrors')) {
-                $$exifTool{CHECK_WARN} = "[minor] IPTC:$$tagInfo{Name} exceeds length limit (truncated)";
+            if ($len > $maxlen and not $et->Options('IgnoreMinorErrors')) {
+                $$et{CHECK_WARN} = "[minor] IPTC:$$tagInfo{Name} exceeds length limit (truncated)";
                 $$valPtr = substr($$valPtr, 0, $maxlen);
             }
         }
@@ -149,7 +149,7 @@ sub CheckIPTC($$$)
 #         4) record number, 5) flag set to read value (instead of write)
 sub FormatIPTC($$$$$;$)
 {
-    my ($exifTool, $tagInfo, $valPtr, $xlatPtr, $rec, $read) = @_;
+    my ($et, $tagInfo, $valPtr, $xlatPtr, $rec, $read) = @_;
     my $format = $$tagInfo{Format} || $$tagInfo{Table}{FORMAT};
     return unless $format;
     if ($format =~ /^int(\d+)/) {
@@ -176,10 +176,10 @@ sub FormatIPTC($$$$$;$)
     } elsif ($format =~ /^string/) {
         if ($rec == 1) {
             if ($$tagInfo{Name} eq 'CodedCharacterSet') {
-                $$xlatPtr = HandleCodedCharset($exifTool, $$valPtr);
+                $$xlatPtr = HandleCodedCharset($et, $$valPtr);
             }
         } elsif ($$xlatPtr and $rec < 7 and $$valPtr =~ /[\x80-\xff]/) {
-            TranslateCodedString($exifTool, $valPtr, $xlatPtr, $read);
+            TranslateCodedString($et, $valPtr, $xlatPtr, $read);
         }
     }
 }
@@ -302,19 +302,19 @@ sub InvConvertPictureNumber($)
 # Notes: Increments ExifTool CHANGED flag for each tag changed
 sub DoWriteIPTC($$$)
 {
-    my ($exifTool, $dirInfo, $tagTablePtr) = @_;
-    my $verbose = $exifTool->Options('Verbose');
-    my $out = $exifTool->Options('TextOut');
+    my ($et, $dirInfo, $tagTablePtr) = @_;
+    my $verbose = $et->Options('Verbose');
+    my $out = $et->Options('TextOut');
 
     # avoid editing IPTC directory unless necessary:
     # - improves speed
     # - avoids changing current MD5 digest unnecessarily
     # - avoids adding mandatory tags unless some other IPTC is changed
-    unless (exists $$exifTool{EDIT_DIRS}{$$dirInfo{DirName}} or
+    unless (exists $$et{EDIT_DIRS}{$$dirInfo{DirName}} or
         # standard IPTC tags in other locations should be edited too (ie. AFCP_IPTC)
-        ($tagTablePtr = \%Image::ExifTool::IPTC::Main and exists $$exifTool{EDIT_DIRS}{IPTC}))
+        ($tagTablePtr = \%Image::ExifTool::IPTC::Main and exists $$et{EDIT_DIRS}{IPTC}))
     {
-        print $out "$$exifTool{INDENT}  [nothing changed]\n" if $verbose;
+        print $out "$$et{INDENT}  [nothing changed]\n" if $verbose;
         return undef;
     }
     my $dataPt = $$dirInfo{DataPt};
@@ -327,8 +327,8 @@ sub DoWriteIPTC($$$)
     my ($tagInfo, %iptcInfo, $tag);
 
     # start by assuming default IPTC encoding
-    my $xlat = $exifTool->Options('CharsetIPTC');
-    undef $xlat if $xlat eq $exifTool->Options('Charset');
+    my $xlat = $et->Options('CharsetIPTC');
+    undef $xlat if $xlat eq $et->Options('Charset');
 
     # make sure our dataLen is defined (note: allow zero length directory)
     unless (defined $dirLen) {
@@ -340,7 +340,7 @@ sub DoWriteIPTC($$$)
     if ($dirLen >= 4 and substr($$dataPt, $start, 1) ne "\x1c" and
                          substr($$dataPt, $start + 3, 1) eq "\x1c")
     {
-        $exifTool->Warn('IPTC data was improperly byte-swapped');
+        $et->Warn('IPTC data was improperly byte-swapped');
         my $newData = pack('N*', unpack('V*', substr($$dataPt, $start, $dirLen) . "\0\0\0"));
         $dataPt = \$newData;
         $start = 0;
@@ -358,7 +358,7 @@ sub DoWriteIPTC($$$)
 
     # loop through new values and accumulate all IPTC information
     # into lists based on their IPTC record type
-    foreach $tagInfo ($exifTool->GetNewTagInfoList()) {
+    foreach $tagInfo ($et->GetNewTagInfoList()) {
         my $table = $$tagInfo{Table};
         my $record = $recordNum{$table};
         # ignore tags we aren't writing to this directory
@@ -402,12 +402,12 @@ sub DoWriteIPTC($$$)
             if ($id == 0x1c) {
                 if ($rec < $lastRec) {
                     if ($rec == 0) {
-                        return undef if $exifTool->Warn("IPTC record 0 encountered, subsequent records ignored", 2);
+                        return undef if $et->Warn("IPTC record 0 encountered, subsequent records ignored", 2);
                         undef $rec;
                         $pos = $dirEnd;
                         $len = 0;
                     } else {
-                        return undef if $exifTool->Warn("IPTC doesn't conform to spec: Records out of sequence", 2);
+                        return undef if $et->Warn("IPTC doesn't conform to spec: Records out of sequence", 2);
                     }
                 }
                 # handle extended IPTC entry if necessary
@@ -472,15 +472,15 @@ sub DoWriteIPTC($$$)
                                 }
                                 $tagInfo = $subTablePtr->{$mandTag} or warn("WriteIPTC: Internal error 2\n"), next;
                                 my $value = $mandatory->{$mandTag};
-                                $exifTool->VerboseValue("+ IPTC:$$tagInfo{Name}", $value, ' (mandatory)');
+                                $et->VerboseValue("+ IPTC:$$tagInfo{Name}", $value, ' (mandatory)');
                                 # apply necessary format conversions
-                                FormatIPTC($exifTool, $tagInfo, \$value, \$xlat, $lastRec);
+                                FormatIPTC($et, $tagInfo, \$value, \$xlat, $lastRec);
                                 $len = length $value;
                                 # generate our new entry
                                 my $entry = pack("CCCn", 0x1c, $lastRec, $mandTag, length($value));
                                 $newData .= $entry . $value;    # add entry to new IPTC data
                                 # (don't mark as changed if just mandatory tags changed)
-                                # ++$exifTool->{CHANGED};
+                                # ++$$et{CHANGED};
                             }
                         }
                     }
@@ -497,7 +497,7 @@ sub DoWriteIPTC($$$)
                     $tagInfo = ${$iptcInfo{$newRec}}[0];
                 }
                 my $newTag = $$tagInfo{TagID};
-                my $nvHash = $exifTool->GetNewValueHash($tagInfo);
+                my $nvHash = $et->GetNewValueHash($tagInfo);
                 # only add new values if...
                 my ($doSet, @values);
                 my $found = $foundRec{$newRec}->{$newTag} || 0;
@@ -512,19 +512,19 @@ sub DoWriteIPTC($$$)
                     $doSet = 1 if not $found and $$nvHash{IsCreating};
                 }
                 if ($doSet) {
-                    @values = $exifTool->GetNewValues($nvHash);
+                    @values = $et->GetNewValues($nvHash);
                     @values and $foundRec{$newRec}->{$newTag} = $found | 0x04;
                     # write tags for each value in list
                     my $value;
                     foreach $value (@values) {
-                        $exifTool->VerboseValue("+ IPTC:$$tagInfo{Name}", $value);
+                        $et->VerboseValue("+ IPTC:$$tagInfo{Name}", $value);
                         # reset allMandatory flag if a non-mandatory tag is written
                         if ($allMandatory) {
                             my $mandatory = $mandatory{$newRec};
                             $allMandatory = 0 unless $mandatory and $mandatory->{$newTag};
                         }
                         # apply necessary format conversions
-                        FormatIPTC($exifTool, $tagInfo, \$value, \$xlat, $newRec);
+                        FormatIPTC($et, $tagInfo, \$value, \$xlat, $newRec);
                         # (note: IPTC string values are NOT null terminated)
                         $len = length $value;
                         # generate our new entry
@@ -536,7 +536,7 @@ sub DoWriteIPTC($$$)
                             $entry .= pack("nN", 0x8004, $len);
                         }
                         $newData .= $entry . $value;    # add entry to new IPTC data
-                        ++$exifTool->{CHANGED};
+                        ++$$et{CHANGED};
                     }
                 }
                 # continue on with regular programming if done adding tag now
@@ -563,17 +563,17 @@ sub DoWriteIPTC($$$)
         # write out this record unless we are setting it with a new value
         $tagInfo = $set{$rec}->{$tag};
         if ($tagInfo) {
-            my $nvHash = $exifTool->GetNewValueHash($tagInfo);
+            my $nvHash = $et->GetNewValueHash($tagInfo);
             $len = $pos - $valuePtr;
             my $val = substr($$dataPt, $valuePtr, $len);
             # remove null terminator if it exists (written by braindead software like Picasa 2.0)
             $val =~ s/\0+$// if $$tagInfo{Format} and $$tagInfo{Format} =~ /^string/;
             my $oldXlat = $xlat;
-            FormatIPTC($exifTool, $tagInfo, \$val, \$xlat, $rec, 1);
-            if ($exifTool->IsOverwriting($nvHash, $val)) {
+            FormatIPTC($et, $tagInfo, \$val, \$xlat, $rec, 1);
+            if ($et->IsOverwriting($nvHash, $val)) {
                 $xlat = $oldXlat;   # don't change translation (not writing this value)
-                $exifTool->VerboseValue("- IPTC:$$tagInfo{Name}", $val);
-                ++$exifTool->{CHANGED};
+                $et->VerboseValue("- IPTC:$$tagInfo{Name}", $val);
+                ++$$et{CHANGED};
                 # set deleted flag to indicate we found and deleted this tag
                 $foundRec{$rec}->{$tag} |= 0x02;
                 # increment allMandatory flag to indicate a tag was removed
@@ -589,7 +589,7 @@ sub DoWriteIPTC($$$)
         } elsif ($rec == 1 and $tag == 90) {
             # handle CodedCharacterSet tag
             my $val = substr($$dataPt, $valuePtr, $pos - $valuePtr);
-            $xlat = HandleCodedCharset($exifTool, $val);
+            $xlat = HandleCodedCharset($et, $val);
         }
         # reset allMandatory flag if a non-mandatory tag is written
         if ($allMandatory) {
@@ -605,7 +605,7 @@ sub DoWriteIPTC($$$)
     if ($tail < $dirEnd) {
         my $trailer = substr($$dataPt, $tail, $dirEnd-$tail);
         if ($trailer =~ /[^\0]/) {
-            return undef if $exifTool->Warn('Unrecognized data in IPTC trailer', 2);
+            return undef if $et->Warn('Unrecognized data in IPTC trailer', 2);
         }
     }
     return $newData;
@@ -618,24 +618,24 @@ sub DoWriteIPTC($$$)
 # Notes: Increments ExifTool CHANGED flag for each tag changed
 sub WriteIPTC($$$)
 {
-    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 $newData = DoWriteIPTC($exifTool, $dirInfo, $tagTablePtr);
+    my $newData = DoWriteIPTC($et, $dirInfo, $tagTablePtr);
 
     # calculate standard IPTC digests only if we are writing or deleting
     # Photoshop:IPTCDigest with a value of 'new' or 'old'
     while ($Image::ExifTool::Photoshop::iptcDigestInfo) {
-        my $nvHash = $exifTool->{NEW_VALUE}{$Image::ExifTool::Photoshop::iptcDigestInfo};
+        my $nvHash = $$et{NEW_VALUE}{$Image::ExifTool::Photoshop::iptcDigestInfo};
         last unless defined $nvHash;
-        last unless IsStandardIPTC($exifTool->MetadataPath());
-        my @values = $exifTool->GetNewValues($nvHash);
+        last unless IsStandardIPTC($et->MetadataPath());
+        my @values = $et->GetNewValues($nvHash);
         push @values, @{$$nvHash{DelValue}} if $$nvHash{DelValue};
         my $new = grep /^new$/, @values;
         my $old = grep /^old$/, @values;
         last unless $new or $old;
         unless (eval 'require Digest::MD5') {
-            $exifTool->Warn('Digest::MD5 must be installed to calculate IPTC digest');
+            $et->Warn('Digest::MD5 must be installed to calculate IPTC digest');
             last;
         }
         my $dataPt;
@@ -650,18 +650,18 @@ sub WriteIPTC($$$)
                 }
             }
             # set NewIPTCDigest data member unless IPTC is being deleted
-            $$exifTool{NewIPTCDigest} = Digest::MD5::md5($$dataPt) if length $$dataPt;
+            $$et{NewIPTCDigest} = Digest::MD5::md5($$dataPt) if length $$dataPt;
         }
         if ($old) {
             if ($new and not defined $newData) {
-                $$exifTool{OldIPTCDigest} = $$exifTool{NewIPTCDigest};
+                $$et{OldIPTCDigest} = $$et{NewIPTCDigest};
             } elsif ($$dirInfo{DataPt}) { #(may be undef if creating new IPTC)
                 $dataPt = $$dirInfo{DataPt};
                 if ($$dirInfo{DirStart} or length($$dataPt) != $$dirInfo{DirLen}) {
                     my $buff = substr($$dataPt, $$dirInfo{DirStart}, $$dirInfo{DirLen});
                     $dataPt = \$buff;
                 }
-                $$exifTool{OldIPTCDigest} = Digest::MD5::md5($$dataPt) if length $$dataPt;
+                $$et{OldIPTCDigest} = Digest::MD5::md5($$dataPt) if length $$dataPt;
             }
         }
         last;

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

@@ -31,13 +31,18 @@ my %myDictTags = (
     _filtered => 1, _entry_size => 1, _table => 1,
 );
 
+# map for directories that we can add
+my %pdfMap = (
+    XMP => 'PDF',
+);
+
 #------------------------------------------------------------------------------
 # Validate raw PDF values for writing (string date integer real boolean name)
 # Inputs: 0) ExifTool object ref, 1) tagInfo hash ref, 2) raw value ref
 # Returns: error string or undef (and possibly changes value) on success
 sub CheckPDF($$$)
 {
-    my ($exifTool, $tagInfo, $valPtr) = @_;
+    my ($et, $tagInfo, $valPtr) = @_;
     my $format = $$tagInfo{Writable} || $tagInfo->{Table}->{WRITABLE};
     if (not $format) {
         return 'No writable format';
@@ -67,12 +72,12 @@ sub CheckPDF($$$)
 # Notes: Called at write time, so $pdfVer may be checked
 sub WritePDFValue($$$)
 {
-    my ($exifTool, $val, $format) = @_;
+    my ($et, $val, $format) = @_;
     if (not $format) {
         return undef;
     } elsif ($format eq 'string') {
         # encode as UCS2 if it contains any special characters
-        $val = "\xfe\xff" . $exifTool->Encode($val,'UCS2','MM') if $val =~ /[\x80-\xff]/;
+        $val = "\xfe\xff" . $et->Encode($val,'UCS2','MM') if $val =~ /[\x80-\xff]/;
         EncodeString(\$val);
     } elsif ($format eq 'date') {
         # convert date to "D:YYYYmmddHHMMSS+-HH'MM'" format
@@ -271,7 +276,7 @@ sub WriteObject($$)
 #                                      +--> Root --> Metadata
 sub WritePDF($$)
 {
-    my ($exifTool, $dirInfo) = @_;
+    my ($et, $dirInfo) = @_;
     my $raf = $$dirInfo{RAF};
     my $outfile = $$dirInfo{OutFile};
     my ($buff, %capture, %newXRef, %newObj, $objRef);
@@ -286,35 +291,36 @@ sub WritePDF($$)
     # create a new ExifTool object and use it to read PDF and XMP information
     my $newTool = new Image::ExifTool;
     $newTool->Options(List => 1);
-    $newTool->Options(Password => $exifTool->Options('Password'));
+    $newTool->Options(Password => $et->Options('Password'));
     $$newTool{PDF_CAPTURE} = \%capture;
     my $info = $newTool->ImageInfo($raf, 'XMP', 'PDF:*', 'Error', 'Warning');
     # not a valid PDF file unless we got a version number
     # (note: can't just check $$info{PDFVersion} due to possibility of XMP-pdf:PDFVersion)
     my $vers = $newTool->GetInfo('PDF:PDFVersion');
     ($pdfVer) = values %$vers;
-    $pdfVer or $exifTool->Error('Missing PDF:PDFVersion'), return 0;
+    $pdfVer or $et->Error('Missing PDF:PDFVersion'), return 0;
     # check version number
     if ($pdfVer > 1.7) {
         if ($pdfVer >= 2.0) {
-            $exifTool->Error("Can't yet write PDF version $pdfVer"); # (future major version changes)
+            $et->Error("Can't yet write PDF version $pdfVer"); # (future major version changes)
             return 1;
         }
-        $exifTool->Warn("ExifTool is untested with PDF version $pdfVer files", 1);
+        $et->Warn("ExifTool is untested with PDF version $pdfVer files", 1);
     }
     # fail if we had any serious errors while extracting information
     if ($capture{Error} or $$info{Error}) {
-        $exifTool->Error($capture{Error} || $$info{Error});
+        $et->Error($capture{Error} || $$info{Error});
         return 1;
     }
     # make sure we have everything we need to rewrite this file
     foreach $obj (qw(Main Root xref)) {
         next if $capture{$obj};
         # any warning we received may give a clue about why this object is missing
-        $exifTool->Error($$info{Warning}) if $$info{Warning};
-        $exifTool->Error("Can't find $obj object");
+        $et->Error($$info{Warning}) if $$info{Warning};
+        $et->Error("Can't find $obj object");
         return 1;
     }
+    $et->InitWriteDirs(\%pdfMap, 'XMP');
 
     # copy file up to start of previous exiftool update or end of file
     # (comment, startxref & EOF with 11-digit offsets and 2-byte newlines is 63 bytes)
@@ -328,17 +334,17 @@ sub WritePDF($$)
         Image::ExifTool::CopyBlock($raf, $outfile, $prevUpdate) or $rtn = -1;
         # verify that we are now at the start of an ExifTool update
         unless ($raf->Read($buff, length $beginComment) and $buff eq $beginComment) {
-            $exifTool->Error('Previous ExifTool update is corrupted');
+            $et->Error('Previous ExifTool update is corrupted');
             return $rtn;
         }
         $raf->Seek($prevUpdate, 0) or $rtn = -1;
-        if ($exifTool->{DEL_GROUP}->{'PDF-update'}) {
-            $exifTool->VPrint(0, "  Reverted previous ExifTool updates\n");
-            ++$$exifTool{CHANGED};
+        if ($$et{DEL_GROUP}{'PDF-update'}) {
+            $et->VPrint(0, "  Reverted previous ExifTool updates\n");
+            ++$$et{CHANGED};
             return $rtn;
         }
-    } elsif ($exifTool->{DEL_GROUP}->{'PDF-update'}) {
-        $exifTool->Error('File contains no previous ExifTool update');
+    } elsif ($$et{DEL_GROUP}{'PDF-update'}) {
+        $et->Error('File contains no previous ExifTool update');
         return $rtn;
     } else {
         # rewrite the whole file
@@ -346,7 +352,7 @@ sub WritePDF($$)
             Write($outfile, $buff) or $rtn = -1;
         }
     }
-    $out = $exifTool->Options('TextOut') if $exifTool->Options('Verbose');
+    $out = $et->Options('TextOut') if $et->Options('Verbose');
 #
 # create our new PDF objects to write
 #
@@ -360,7 +366,7 @@ sub WritePDF($$)
     my $prevInfoRef;
     if ($prevUpdate) {
         unless ($capture{Prev}) {
-            $exifTool->Error("Can't locate trailer dictionary prior to last edit");
+            $et->Error("Can't locate trailer dictionary prior to last edit");
             return $rtn;
         }
         $prevInfoRef = $capture{Prev}->{Info};
@@ -376,7 +382,7 @@ sub WritePDF($$)
 
     # delete entire PDF group if specified
     my $infoChanged = 0;
-    if ($exifTool->{DEL_GROUP}->{PDF} and $capture{Info}) {
+    if ($$et{DEL_GROUP}{PDF} and $capture{Info}) {
         delete $capture{Info};
         $info = { XMP => $$info{XMP} }; # remove extracted PDF tags
         print $out "  Deleting PDF Info dictionary\n" if $out;
@@ -398,11 +404,11 @@ sub WritePDF($$)
     local $/ = $capture{newline};
 
     # rewrite PDF Info tags
-    my $newTags = $exifTool->GetNewTagInfoHash(\%Image::ExifTool::PDF::Info);
+    my $newTags = $et->GetNewTagInfoHash(\%Image::ExifTool::PDF::Info);
     my $tagID;
     foreach $tagID (sort keys %$newTags) {
         my $tagInfo = $$newTags{$tagID};
-        my $nvHash = $exifTool->GetNewValueHash($tagInfo);
+        my $nvHash = $et->GetNewValueHash($tagInfo);
         my (@vals, $deleted);
         my $tag = $$tagInfo{Name};
         my $val = $$info{$tag};
@@ -419,9 +425,9 @@ sub WritePDF($$)
                 $val = shift @oldVals;
             }
             for (;;) {
-                if ($exifTool->IsOverwriting($nvHash, $val) > 0) {
+                if ($et->IsOverwriting($nvHash, $val) > 0) {
                     $deleted = 1;
-                    $exifTool->VerboseValue("- PDF:$tag", $val);
+                    $et->VerboseValue("- PDF:$tag", $val);
                     ++$infoChanged;
                 } else {
                     push @vals, $val;
@@ -439,13 +445,13 @@ sub WritePDF($$)
         next unless $deleted or $$tagInfo{List} or not exists $$infoDict{$tagID};
         
         # add new values to existing ones
-        my @newVals = $exifTool->GetNewValues($nvHash);
+        my @newVals = $et->GetNewValues($nvHash);
         if (@newVals) {
             push @vals, @newVals;
             ++$infoChanged;
             if ($out) {
                 foreach $val (@newVals) {
-                    $exifTool->VerboseValue("+ PDF:$tag", $val);
+                    $et->VerboseValue("+ PDF:$tag", $val);
                 }
             }
         }
@@ -457,25 +463,25 @@ sub WritePDF($$)
         # format value(s) for writing to PDF file
         my $writable = $$tagInfo{Writable} || $Image::ExifTool::PDF::Info{WRITABLE};
         if (not $$tagInfo{List}) {
-            $val = WritePDFValue($exifTool, shift(@vals), $writable);
+            $val = WritePDFValue($et, shift(@vals), $writable);
         } elsif ($$tagInfo{List} eq 'array') {
             foreach $val (@vals) {
-                $val = WritePDFValue($exifTool, $val, $writable);
+                $val = WritePDFValue($et, $val, $writable);
                 defined $val or undef(@vals), last;
             }
             $val = @vals ? \@vals : undef;
         } else {
-            $val = WritePDFValue($exifTool, join($exifTool->Options('ListSep'), @vals), $writable);
+            $val = WritePDFValue($et, join($et->Options('ListSep'), @vals), $writable);
         }
         if (defined $val) {
             $$infoDict{$tagID} = $val;
             ++$infoChanged;
         } else {
-            $exifTool->Warn("Error converting $$tagInfo{Name} value");
+            $et->Warn("Error converting $$tagInfo{Name} value");
         }
     }
     if ($infoChanged) {
-        $$exifTool{CHANGED} += $infoChanged;
+        $$et{CHANGED} += $infoChanged;
     } elsif ($prevUpdate) {
         # must still write Info dictionary if it was previously updated
         my $oldPos = LocateObject($xref, $$infoRef);
@@ -503,19 +509,19 @@ sub WritePDF($$)
         Parent => 'PDF',
     );
     my $xmpTable = Image::ExifTool::GetTagTable('Image::ExifTool::XMP::Main');
-    my $oldChanged = $$exifTool{CHANGED};
-    my $newXMP = $exifTool->WriteDirectory(\%xmpInfo, $xmpTable);
+    my $oldChanged = $$et{CHANGED};
+    my $newXMP = $et->WriteDirectory(\%xmpInfo, $xmpTable);
     $newXMP = $$info{XMP} ? ${$$info{XMP}} : '' unless defined $newXMP;
 
     # WriteDirectory() will increment CHANGED erroneously if non-existent
     # XMP is deleted as a block -- so check for this
     unless ($newXMP or $$info{XMP}) {
-        $$exifTool{CHANGED} = $oldChanged;
-        $exifTool->VPrint(0, "  (XMP not changed -- still empty)\n");
+        $$et{CHANGED} = $oldChanged;
+        $et->VPrint(0, "  (XMP not changed -- still empty)\n");
     }
     my ($metaChanged, $rootChanged);
 
-    if ($$exifTool{CHANGED} != $oldChanged and defined $newXMP) {
+    if ($$et{CHANGED} != $oldChanged and defined $newXMP) {
         $metaChanged = 1;
     } elsif ($prevUpdate and $capture{Root}->{Metadata}) {
         # must still write Metadata dictionary if it was previously updated
@@ -550,7 +556,7 @@ sub WritePDF($$)
     # add new Root dictionary if necessary
     my $rootRef = $$mainDict{Root};
     unless ($rootRef) {
-        $exifTool->Error("Can't find Root dictionary");
+        $et->Error("Can't find Root dictionary");
         return $rtn;
     }
     if (not $rootChanged and $prevUpdate) {
@@ -562,7 +568,7 @@ sub WritePDF($$)
 #
 # write incremental update if anything was changed
 #
-    if ($$exifTool{CHANGED}) {
+    if ($$et{CHANGED}) {
         # remember position of original EOF
         my $oldEOF = Tell($outfile);
         Write($outfile, $beginComment) or $rtn = -1;
@@ -655,7 +661,7 @@ sub WritePDF($$)
                     $id = shift @ids;
                     my ($pos, $gen, $type) = @{$newXRef{$id}};
                     if ($pos > 0xffffffff) {
-                        $exifTool->Error('Huge files not yet supported');
+                        $et->Error('Huge files not yet supported');
                         last;
                     }
                     $$mainDict{_stream} .= pack('CNn', $type eq 'f' ? 0 : 1, $pos, $gen);