exiftool-vendored.pl 12.69.0 → 12.72.0

package/bin/lib/Image/ExifTool/Text.pm

@@ -25,11 +25,10 @@ $VERSION = '1.04';
         Although basic text files contain no metadata, the following tags are
         determined from a simple analysis of the data in TXT and CSV files. 
         Statistics are generated only for 8-bit encodings, but the L<FastScan|../ExifTool.html#FastScan> (-fast)
-        option may be used to limit processing to the first 64 kB in which case some
-        tags are not produced.  To avoid long processing delays, ExifTool will issue
-        a minor warning and process only the first 64 kB of any file larger than 20
-        MB unless the L<IgnoreMinorErrors|../ExifTool.html#IgnoreMinorErrors> (-m)
-        option is used.
+        option may be used to limit processing to the first 64 KiB in which case
+        some tags are not produced.  To avoid long processing delays, ExifTool will
+        issue a minor warning and process only the first 64 KiB of any file larger
+        than 20 MiB unless the L<IgnoreMinorErrors|../ExifTool.html#IgnoreMinorErrors> (-m) option is used.
     },
     MIMEEncoding => { Groups => { 2 => 'Other' } },
     Newlines => {

package/bin/lib/Image/ExifTool/Validate.pm

@@ -17,7 +17,7 @@ package Image::ExifTool::Validate;
 use strict;
 use vars qw($VERSION %exifSpec);
 
-$VERSION = '1.22';
+$VERSION = '1.23';
 
 use Image::ExifTool qw(:Utils);
 use Image::ExifTool::Exif;
@@ -86,7 +86,7 @@ my %verCheck = (
     GPS        => { GPSVersionID => \%gpsVer },
 );
 
-# tags standard in various RAW file formats
+# tags standard in various RAW file formats or IFD's
 my %otherSpec = (
     CR2 => { 0xc5d8 => 1, 0xc5d9 => 1, 0xc5e0 => 1, 0xc640 => 1, 0xc6dc => 1, 0xc6dd => 1 },
     NEF => { 0x9216 => 1, 0x9217 => 1 },
@@ -103,6 +103,7 @@ my %otherSpec = (
     SRW => { 0xa010 => 1, 0xa011 => 1, 0xa101 => 1, 0xa102 => 1 },
     NRW => { 0x9216 => 1, 0x9217 => 1 },
     X3F => { 0xa500 => 1 },
+    CameraIFD => { All => 1 }, # (exists in JPG and DNG of Leica Q3 images)
 );
 
 # standard format for tags (not necessary for exifSpec or GPS tags where Writable is defined)
@@ -458,8 +459,8 @@ sub ValidateExif($$$$$$$$)
         } elsif (not $otherSpec{$$et{FileType}} or
             (not $otherSpec{$$et{FileType}}{$tag} and not $otherSpec{$$et{FileType}}{All}))
         {
-            if ($tagTablePtr eq \%Image::ExifTool::Exif::Main or $$tagInfo{Unknown}) {
-                $et->Warn(sprintf('Non-standard %s tag 0x%.4x %s', $ifd, $tag, $$ti{Name}), 1);
+            if ($tagTablePtr eq \%Image::ExifTool::Exif::Main or $$ti{Unknown}) {
+                $et->Warn(sprintf('Non-standard %s tag 0x%.4x %s', $ifd, $tag, $$ti{Name}), 1) unless $otherSpec{$ifd};
             }
         }
         # change expected count from read Format to Writable size
@@ -480,7 +481,7 @@ sub ValidateExif($$$$$$$$)
     } elsif (not $otherSpec{$$et{FileType}} or
         (not $otherSpec{$$et{FileType}}{$tag} and not $otherSpec{$$et{FileType}}{All}))
     {
-        $et->Warn(sprintf('Unknown %s tag 0x%.4x', $ifd, $tag), 1);
+        $et->Warn(sprintf('Unknown %s tag 0x%.4x', $ifd, $tag), 1) unless $otherSpec{$ifd};
     }
 }
 

package/bin/lib/Image/ExifTool/WriteExif.pl

@@ -569,6 +569,7 @@ sub WriteExif($$$)
     my $imageDataFlag = $$dirInfo{ImageData} || '';
     my $verbose = $et->Options('Verbose');
     my $out = $et->Options('TextOut');
+    my $noMandatory = $et->Options('NoMandatory');
     my ($nextIfdPos, %offsetData, $inMakerNotes);
     my (@offsetInfo, %validateInfo, %xDelete, $strEnc);
     my $deleteAll = 0;
@@ -698,8 +699,8 @@ sub WriteExif($$$)
         }
 
         # initialize variables to handle mandatory tags
-        my $mandatory = $mandatory{$dirName};
-        my ($allMandatory, $addMandatory);
+        my ($mandatory, $allMandatory, $addMandatory);
+        $mandatory = $mandatory{$dirName} unless $noMandatory;
         if ($mandatory) {
             # use X/Y resolution values from JFIF if available
             if ($dirName eq 'IFD0' and defined $$et{JFIFYResolution}) {
@@ -1152,7 +1153,7 @@ Entry:  for (;;) {
                     }
                     my $nvHash;
                     $nvHash = $et->GetNewValueHash($curInfo, $dirName) if $isNew >= 0;
-                    unless ($nvHash or defined $$mandatory{$newID}) {
+                    unless ($nvHash or (defined $$mandatory{$newID} and not $noMandatory)) {
                         goto NoWrite unless $wrongDir;  # GOTO !
                         # delete stuff from the wrong directory if setting somewhere else
                         $nvHash = $et->GetNewValueHash($curInfo, $wrongDir);
@@ -2235,6 +2236,19 @@ NoOverwrite:            next if $isNew > 0;
 
     # do our fixups now so we can more easily calculate offsets below
     $fixup->ApplyFixup(\$newData);
+    # write Sony HiddenData now if this is an ARW file
+    if ($$et{HiddenData} and not $$dirInfo{Fixup} and $$et{FILE_TYPE} eq 'TIFF') {
+        $fixup->SetMarkerPointers(\$newData, 'HiddenData', length($newData));
+        my $hbuf;
+        my $hd = $$et{HiddenData};
+        if ($raf->Seek($$hd{Offset}, 0) and $raf->Read($hbuf, $$hd{Size}) == $$hd{Size} and
+            $hbuf =~ /^\x55\x26\x11\x05\0/)
+        {
+            $newData .= $hbuf;
+        } else {
+            $et->Error('Error copying hidden data', 1);
+        }
+    }
 #
 # determine total block size for deferred data
 #
@@ -2625,8 +2639,9 @@ NoOverwrite:            next if $isNew > 0;
             $$fixup{Shift} += $newDataPos;
             $fixup->ApplyFixup(\$newData);
         }
-        # save fixup for adjusting Leica trailer offset if necessary
+        # save fixup for adjusting Leica trailer and Sony HiddenData offsets if necessary
         $$et{LeicaTrailer}{Fixup}->AddFixup($fixup) if $$et{LeicaTrailer};
+        $$et{HiddenData}{Fixup}->AddFixup($fixup) if $$et{HiddenData};
         # save fixup for PreviewImage in JPEG file if necessary
         my $previewInfo = $$et{PREVIEW_INFO};
         if ($previewInfo) {

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

@@ -1056,6 +1056,7 @@ sub WriteQuickTime($$$)
                     Parent   => $dirName,
                     DirName  => $subName,
                     Name     => $$tagInfo{Name},
+                    TagInfo  => $tagInfo,
                     DirID    => $tag,
                     DataPt   => \$buff,
                     DataLen  => $size,

package/bin/lib/Image/ExifTool/WriteRIFF.pl

@@ -19,6 +19,8 @@ my %webpMap = (
    'XMP '        => 'RIFF', # (the RIFF chunk name is 'XMP ')
     EXIF         => 'RIFF',
     ICCP         => 'RIFF',
+    C2PA         => 'RIFF',
+    JUMBF        => 'C2PA',
     XMP          => 'XMP ',
     IFD0         => 'EXIF',
     IFD1         => 'IFD0',
@@ -168,10 +170,10 @@ sub WriteRIFF($$)
 #
 # add/edit/delete EXIF/XMP/ICCP (note: EXIF must come before XMP, and ICCP is written elsewhere)
 #
-                my %dirName = ( EXIF => 'IFD0', 'XMP ' => 'XMP', ICCP => 'ICC_Profile' );
-                my %tblName = ( EXIF => 'Exif', 'XMP ' => 'XMP', ICCP => 'ICC_Profile' );
+                my %dirName = ( EXIF => 'IFD0', 'XMP ' => 'XMP', ICCP => 'ICC_Profile', C2PA => 'JUMBF' );
+                my %tblName = ( EXIF => 'Exif', 'XMP ' => 'XMP', ICCP => 'ICC_Profile', C2PA => 'Jpeg2000' );
                 my $dir;
-                foreach $dir ('EXIF', 'XMP ', 'ICCP' ) {
+                foreach $dir ('EXIF', 'XMP ', 'ICCP', 'C2PA' ) {
                     next unless $tag eq $dir or ($$addDirs{$dir} and
                         ($tag eq '' or ($tag eq 'XMP ' and $dir eq 'EXIF')));
                     my $start;
@@ -207,6 +209,10 @@ sub WriteRIFF($$)
                             Parent   => $dir,
                             DirName  => $dirName{$dir},
                         );
+                        # must pass the TagInfo to enable deletion of C2PA information
+                        if (ref $Image::ExifTool::RIFF::Main{$dir} eq 'HASH') {
+                            $dirInfo{TagInfo} = $Image::ExifTool::RIFF::Main{$dir};
+                        }
                         my $tagTablePtr = GetTagTable("Image::ExifTool::$tblName{$dir}::Main");
                         # (override writeProc for EXIF because it has the TIFF header)
                         my $writeProc = $dir eq 'EXIF' ? \&Image::ExifTool::WriteTIFF : undef;

package/bin/lib/Image/ExifTool/Writer.pl

@@ -690,6 +690,12 @@ TAG: foreach $tagInfo (@matchingTags) {
             $writeProc = $$src{WRITE_PROC} unless $writeProc;
         }
         {
+            # make sure module is loaded if the writeProc is a string
+            unless (ref $writeProc) {
+                my $module = $writeProc;
+                $module =~ s/::\w+$//;
+                eval "require $module";
+            }
             no strict 'refs';
             next unless $writeProc and &$writeProc();
         }
@@ -1271,6 +1277,7 @@ sub SetNewValuesFromFile($$;@)
     # +------------------------------------------+
     $srcExifTool->Options(
         Binary          => 1,
+        ByteUnit        => $$options{ByteUnit},
         Charset         => $$options{Charset},
         CharsetEXIF     => $$options{CharsetEXIF},
         CharsetFileName => $$options{CharsetFileName},
@@ -3238,9 +3245,15 @@ sub InsertTagValues($$$;$$$)
                     $tag = $docGrp . ':' . $tag;
                     $lcTag = lc $tag;
                 }
-                my $et = $self;
+                my ($et, $fileTags) = ($self, $foundTags);
                 if ($tag =~ s/(\bfile\d+)://i) {
-                    $et = $$self{ALT_EXIFTOOL}{ucfirst lc $1} or $et=$self, $tag = 'no_alt_file';
+                    $et = $$self{ALT_EXIFTOOL}{ucfirst lc $1};
+                    if ($et) {
+                        $fileTags = $$et{FoundTags};
+                    } else {
+                        $et = $self;
+                        $tag = 'no_alt_file';
+                    }
                 }
                 if ($lcTag eq 'all') {
                     $val = 1;   # always some tag available
@@ -3251,11 +3264,11 @@ sub InsertTagValues($$$;$$$)
                     ($group, $tag) = ($1, $2);
                     if (lc $tag eq 'all') {
                         # see if any tag from the specified group exists
-                        my $match = $et->GroupMatches($group, $foundTags);
+                        my $match = $et->GroupMatches($group, $fileTags);
                         $val = $match ? 1 : 0;
                     } else {
                         # find the specified tag
-                        my @matches = grep /^$tag(\s|$)/i, @$foundTags;
+                        my @matches = grep /^$tag(\s|$)/i, @$fileTags;
                         @matches = $et->GroupMatches($group, \@matches);
                         foreach $tg (@matches) {
                             if (defined $val and $tg =~ / \((\d+)\)$/) {
@@ -3275,7 +3288,7 @@ sub InsertTagValues($$$;$$$)
                     $val = $et->GetValue($tag, $type);
                     unless (defined $val) {
                         # check for tag name with different case
-                        ($tg) = grep /^$tag$/i, @$foundTags;
+                        ($tg) = grep /^$tag$/i, @$fileTags;
                         if (defined $tg) {
                             $val = $et->GetValue($tg, $type);
                             $tag = $tg;
@@ -3926,7 +3939,7 @@ sub RemoveNewValuesForGroup($$)
             my $wgrp = $$nvHash{WriteGroup};
             # use group1 if write group is not specific
             $wgrp = $grp1 if $wgrp eq $grp0;
-            if (grep /^($grp0|$wgrp)$/i, @groups) {
+            if ($grp0 eq '*' or $wgrp eq '*' or grep /^($grp0|$wgrp)$/i, @groups) {
                 $out and print $out "Removed new value for $wgrp:$$tagInfo{Name}\n";
                 # remove from linked list
                 $self->RemoveNewValueHash($nvHash, $tagInfo);
@@ -4187,7 +4200,10 @@ sub WriteDirectory($$$;$)
         my $delGroup = $$self{DEL_GROUP};
         # delete entire directory if specified
         my $grp1 = $dirName;
-        $delFlag = ($$delGroup{$grp0} or $$delGroup{$grp1}) unless $permanentDir{$grp0};
+        $delFlag = ($$delGroup{$grp0} or $$delGroup{$grp1});
+        if ($permanentDir{$grp0} and not ($$dirInfo{TagInfo} and $$dirInfo{TagInfo}{Deletable})) {
+            undef $delFlag;
+        }
         # (never delete an entire QuickTime group)
         if ($delFlag) {
             if (($grp0 =~ /^(MakerNotes)$/ or $grp1 =~ /^(IFD0|ExifIFD|MakerNotes)$/) and
@@ -4289,7 +4305,21 @@ sub WriteDirectory($$$;$)
         last unless $self->IsOverwriting($nvHash, $dataPt ? $$dataPt : '');
         my $verb = 'Writing';
         my $newVal = $self->GetNewValue($nvHash);
-        unless (defined $newVal and length $newVal) {
+        if (defined $newVal and length $newVal) {
+            # hack to add back TIFF header when writing MakerNoteCanon to CMT3 in CR3 images
+            if ($$tagInfo{Name} eq 'MakerNoteCanon') {
+                require Image::ExifTool::Canon;
+                if ($tagInfo eq $Image::ExifTool::Canon::uuid{CMT3}) {
+                    my $hdr;
+                    if (substr($newVal, 0, 1) eq "\0") {
+                        $hdr = "MM\0\x2a" . pack('N', 8);
+                    } else {
+                        $hdr = "II\x2a\0" . pack('V', 8);
+                    }
+                    $newVal = $hdr . $newVal;
+                }
+            }
+        } else {
             return '' unless $dataPt or $$dirInfo{RAF}; # nothing to do if block never existed
             # don't allow MakerNotes to be removed from RAW files
             if ($blockName eq 'MakerNotes' and $self->IsRawType() and
@@ -4645,9 +4675,18 @@ sub DumpUnknownTrailer($$)
     # account for preview/MPF image trailer
     my $prePos = $$self{VALUE}{PreviewImageStart} || $$self{PreviewImageStart};
     my $preLen = $$self{VALUE}{PreviewImageLength} || $$self{PreviewImageLength};
+    my $hidPos = $$self{VALUE}{HiddenDataOffset};
+    my $hidLen = $$self{VALUE}{HiddenDataLength};
     my $tag = 'PreviewImage';
     my $mpImageNum = 0;
     my (%image, $lastOne);
+    # add HiddenData to list of known trailer blocks
+    if ($hidPos and $hidLen) {
+        # call ReadHiddenData to validate hidden data and fix offset if necessary
+        require Image::ExifTool::Sony;
+        my $datPt = Image::ExifTool::Sony::ReadHiddenData($self, $hidPos, $hidLen);
+        $image{$hidPos} = ['HiddenData', $hidLen] if $datPt;
+    }
     for (;;) {
         # add to Preview block list if valid and in the trailer
         $image{$prePos} = [$tag, $preLen] if $prePos and $preLen and $prePos+$preLen > $pos;
@@ -5762,13 +5801,16 @@ sub WriteJPEG($$)
                         }
                     }
                     # switch to buffered output if required
-                    if (($$self{PREVIEW_INFO} or $$self{LeicaTrailer}) and not $oldOutfile) {
+                    if (($$self{PREVIEW_INFO} or $$self{LeicaTrailer} or $$self{HiddenData}) and
+                        not $oldOutfile)
+                    {
                         $writeBuffer = '';
                         $oldOutfile = $outfile;
                         $outfile = \$writeBuffer;
                         # account for segment, EXIF and TIFF headers
                         $$self{PREVIEW_INFO}{Fixup}{Start} += 18 if $$self{PREVIEW_INFO};
                         $$self{LeicaTrailer}{Fixup}{Start} += 18 if $$self{LeicaTrailer};
+                        $$self{HiddenData}{Fixup}{Start} += 18 if $$self{HiddenData};
                     }
                     # write as multi-segment
                     my $n = WriteMultiSegment($outfile, 0xe1, $exifAPP1hdr, \$buff, 'EXIF');
@@ -5914,7 +5956,9 @@ sub WriteJPEG($$)
             my $delPreview = $$self{DEL_PREVIEW};
             $trailInfo = IdentifyTrailer($raf) unless $$delGroup{Trailer};
             my $nvTrail = $self->GetNewValueHash($Image::ExifTool::Extra{Trailer});
-            unless ($oldOutfile or $delPreview or $trailInfo or $$delGroup{Trailer} or $nvTrail) {
+            unless ($oldOutfile or $delPreview or $trailInfo or $$delGroup{Trailer} or $nvTrail or
+                $$self{HiddenData})
+            {
                 # blindly copy the rest of the file
                 while ($raf->Read($buff, 65536)) {
                     Write($outfile, $buff) or $err = 1, last;
@@ -5944,7 +5988,7 @@ sub WriteJPEG($$)
                 $endedWithFF = substr($buff, 65535, 1) eq "\xff" ? 1 : 0;
             }
             # remember position of last data copied
-            $endPos = $raf->Tell() - length($buff);
+            $endPos = $$self{TrailerStart} = $raf->Tell() - length($buff);
             # write new trailer if specified
             if ($nvTrail) {
                 # access new value directly to avoid copying a potentially very large data block
@@ -5958,6 +6002,34 @@ sub WriteJPEG($$)
                 }
                 last;   # all done
             }
+            # copy HiddenData if necessary
+            if ($$self{HiddenData}) {
+                my $pad;
+                my $hd = $$self{HiddenData};
+                my $hdOff = $$hd{Offset} + $$hd{Base};
+                require Image::ExifTool::Sony;
+                # read HiddenData, updating $hdOff with actual offset if necessary
+                my $dataPt = Image::ExifTool::Sony::ReadHiddenData($self, $hdOff, $$hd{Size});
+                if ($dataPt) {
+                    # preserve padding to avoid invalidating MPF pointers (yuk!)
+                    my $padLen = $hdOff - $endPos;
+                    unless ($padLen >= 0 and $raf->Seek($endPos,0) and $raf->Read($pad,$padLen)==$padLen) {
+                        $self->Error('Error reading HiddenData padding',1);
+                        $pad = '';
+                    }
+                    $endPos += length($pad) + length($$dataPt); # update end position
+                } else {
+                    $$dataPt = $pad = '';
+                }
+                my $fixup = $$self{HiddenData}{Fixup};
+                # set MakerNote pointer and size (subtract 10 for segment and EXIF headers)
+                $fixup->SetMarkerPointers($outfile, 'HiddenData', length($$outfile) + length($pad) - 10);
+                # clean up and write the buffered data
+                $outfile = $oldOutfile;
+                undef $oldOutfile;
+                Write($outfile, $writeBuffer, $pad, $$dataPt) or $err = 1;
+                undef $writeBuffer;
+            }
             # rewrite existing trailers
             if ($trailInfo) {
                 my $tbuf = '';
@@ -6067,7 +6139,7 @@ sub WriteJPEG($$)
                     $delPreview = 1;    # remove old preview
                 }
             }
-            # copy over preview image if necessary
+            # copy over preview image (or other data) if necessary
             unless ($delPreview) {
                 my $extra;
                 if ($trailInfo) {
@@ -6234,13 +6306,16 @@ sub WriteJPEG($$)
                         }
                     }
                     # switch to buffered output if required
-                    if (($$self{PREVIEW_INFO} or $$self{LeicaTrailer}) and not $oldOutfile) {
+                    if (($$self{PREVIEW_INFO} or $$self{LeicaTrailer} or $$self{HiddenData}) and
+                        not $oldOutfile)
+                    {
                         $writeBuffer = '';
                         $oldOutfile = $outfile;
                         $outfile = \$writeBuffer;
                         # must account for segment, EXIF and TIFF headers
                         $$self{PREVIEW_INFO}{Fixup}{Start} += 18 if $$self{PREVIEW_INFO};
                         $$self{LeicaTrailer}{Fixup}{Start} += 18 if $$self{LeicaTrailer};
+                        $$self{HiddenData}{Fixup}{Start} += 18 if $$self{HiddenData};
                     }
                     # write as multi-segment
                     my $n = WriteMultiSegment($outfile, $marker, $exifAPP1hdr, $segDataPt, 'EXIF');
@@ -7075,7 +7150,7 @@ sub WriteBinaryData($$$)
             $newVal = length($data) if defined $data;
             my $format = $$tagInfo{Format} || $$tagTablePtr{FORMAT} || 'int32u';
             if ($format =~ /^int16/ and $newVal > 0xffff) {
-                $self->Error("$$tagInfo{DataTag} is too large (64 kB max. for this file)");
+                $self->Error("$$tagInfo{DataTag} is too large (64 KiB max. for this file)");
             }
         }
         my $rtnVal = WriteValue($newVal, $format, $count, $dataPt, $entry);
@@ -7105,14 +7180,24 @@ sub WriteBinaryData($$$)
             # ignore if offset is zero (eg. Ricoh DNG uses this to indicate no preview)
             next unless $offset;
             $fixup->AddFixup($entry, $$tagInfo{DataTag}, $format);
-            # handle the preview image now if this is a JPEG file
-            next unless $$self{FILE_TYPE} eq 'JPEG' and $$tagInfo{DataTag} and
-                $$tagInfo{DataTag} eq 'PreviewImage' and defined $$tagInfo{OffsetPair};
+            next unless $$tagInfo{DataTag} and defined $$tagInfo{OffsetPair};
             # NOTE: here we assume there are no var-sized tags between the
             # OffsetPair tags.  If this ever becomes possible we must recalculate
             # $varSize for the OffsetPair tag here!
             $entry = $$tagInfo{OffsetPair} * $increment + $varSize;
             my $size = ReadValue($dataPt, $entry, $format, 1, $dirLen-$entry);
+            next unless defined $size;
+            if ($$tagInfo{DataTag} eq 'HiddenData') {
+                $$self{HiddenData} = {
+                    Offset => $offset,
+                    Size   => $size,
+                    Fixup  => new Image::ExifTool::Fixup,
+                    Base   => $$dirInfo{Base},
+                };
+                next;
+            }
+            # handle the preview image now if this is a JPEG file
+            next unless $$tagInfo{DataTag} eq 'PreviewImage' and $$self{FILE_TYPE} eq 'JPEG';
             my $previewInfo = $$self{PREVIEW_INFO};
             $previewInfo or $previewInfo = $$self{PREVIEW_INFO} = {
                 Fixup => new Image::ExifTool::Fixup,
@@ -7194,39 +7279,6 @@ sub WriteTIFF($$$)
 {
     my ($self, $dirInfo, $tagTablePtr) = @_;
     $self or return 1;    # allow dummy access
-    # hack to allow MakeNoteCanon to be written as a block in CMT3 chunk of CR3 image
-    if ($$dirInfo{DirName} and $$dirInfo{DirName} eq 'MakerNoteCanon') {
-        require Image::ExifTool::Canon;
-        my $tagInfo = $Image::ExifTool::Canon::uuid{CMT3};
-        my $nvHash;
-        if ($tagInfo and ($nvHash = $$self{NEW_VALUE}{$tagInfo}) and
-            $self->IsOverwriting($nvHash) and not $$nvHash{CreateOnly})
-        {
-            my $newVal = $self->GetNewValue($nvHash);
-            if (defined $newVal and length $newVal) {
-                # fix up offsets
-                if ($$nvHash{MAKER_NOTE_FIXUP}) {
-                    # must clone fixup because we will be shifting it
-                    my $makerFixup = $$nvHash{MAKER_NOTE_FIXUP}->Clone();
-                    $$makerFixup{Shift} += 8;   # shift for TIFF header
-                    $makerFixup->ApplyFixup(\$newVal);
-                }
-                # add TIFF header
-                my $hdr;
-                if (substr($newVal, 0, 1) eq "\0") {
-                    $hdr = "MM\0\x2a" . pack('N', 8);
-                } else {
-                    $hdr = "II\x2a\0" . pack('V', 8);
-                }
-                $self->VPrint(0, "  Writing MakerNoteCanon as a block\n");
-                ++$$self{CHANGED};
-                return $hdr . $newVal;
-            } elsif ($$dirInfo{Parent} and $$dirInfo{Parent} eq 'UUID-Canon') {
-                $self->Warn("Can't delete CanonMakerNotes from $$dirInfo{Parent}");
-                return undef;
-            }
-        }
-    }
     my $buff = '';
     $$dirInfo{OutFile} = \$buff;
     return $buff if $self->ProcessTIFF($dirInfo, $tagTablePtr) > 0;