exiftool_vendored 12.67.0 → 12.70.0

data/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 => {

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

@@ -17,7 +17,7 @@ package Image::ExifTool::Validate;
 use strict;
 use vars qw($VERSION %exifSpec);
 
-$VERSION = '1.21';
+$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)
@@ -142,20 +143,22 @@ my %stdFormat = (
         # GeoTiff tags:
         0x830e => 'double',     0x8482 => 'double',     0x87af => 'int16u',     0x87b1 => 'string',
         0x8480 => 'double',     0x85d8 => 'double',     0x87b0 => 'double',
-        # DNG tags:
-        0xc615 => '(string|int8u)',              0xc6d3 => '',
-        0xc61a => '(int16u|int32u|rational64u)', 0xc6f4 => '(string|int8u)',
-        0xc61d => 'int(16|32)u',                 0xc6f6 => '(string|int8u)',
-        0xc61f => '(int16u|int32u|rational64u)', 0xc6f8 => '(string|int8u)',
-        0xc620 => '(int16u|int32u|rational64u)', 0xc6fe => '(string|int8u)',
-        0xc628 => '(int16u|rational64u)',        0xc716 => '(string|int8u)',
-        0xc634 => 'int8u',                       0xc717 => '(string|int8u)',
-        0xc640 => '',                            0xc718 => '(string|int8u)',
-        0xc660 => '',                            0xc71e => 'int(16|32)u',
-        0xc68b => '(string|int8u)',              0xc71f => 'int(16|32)u',
-        0xc68d => 'int(16|32)u',                 0xc791 => 'int(16|32)u',
-        0xc68e => 'int(16|32)u',                 0xc792 => 'int(16|32)u',
-        0xc6d2 => '',                            0xc793 => '(int16u|int32u|rational64u)',
+        # DNG tags: (use '' for non-DNG tags in the range 0xc612-0xcd48)
+        0xc615 => '(string|int8u)',              0xc6f4 => '(string|int8u)',
+        0xc61a => '(int16u|int32u|rational64u)', 0xc6f6 => '(string|int8u)',
+        0xc61d => 'int(16|32)u',                 0xc6f8 => '(string|int8u)',
+        0xc61f => '(int16u|int32u|rational64u)', 0xc6fe => '(string|int8u)',
+        0xc620 => '(int16u|int32u|rational64u)', 0xc716 => '(string|int8u)',
+        0xc628 => '(int16u|rational64u)',        0xc717 => '(string|int8u)',
+        0xc634 => 'int8u',                       0xc718 => '(string|int8u)',
+        0xc640 => '',                            0xc71e => 'int(16|32)u',
+        0xc660 => '',                            0xc71f => 'int(16|32)u',
+        0xc68b => '(string|int8u)',              0xc791 => 'int(16|32)u',
+        0xc68d => 'int(16|32)u',                 0xc792 => 'int(16|32)u',
+        0xc68e => 'int(16|32)u',                 0xc793 => '(int16u|int32u|rational64u)',
+        0xc6d2 => '',                            0xcd43 => 'int(16|32)u',
+        0xc6d3 => '',                            0xcd48 => '(string|int8u)',
+
         # Exif 3.0 spec
         0x10e  => 'string|utf8',  0xa430 => 'string|utf8',  0xa439 => 'string|utf8',
         0x10f  => 'string|utf8',  0xa433 => 'string|utf8',  0xa43a => 'string|utf8',
@@ -430,7 +433,7 @@ sub ValidateExif($$$$$$$$)
         my $stdFmt = $stdFormat{$ifd} || $stdFormat{IFD};
         if (defined $$stdFmt{All} or ($tagTablePtr eq \%Image::ExifTool::Exif::Main and
             ($exifSpec{$tag} or $$stdFmt{$tag} or
-            ($tag >= 0xc612 and $tag <= 0xc7b5 and not defined $$stdFmt{$tag}))) or # (DNG tags)
+            ($tag >= 0xc612 and $tag <= 0xcd48 and not defined $$stdFmt{$tag}))) or # (DNG tags)
             $$tagTablePtr{SHORT_NAME} eq 'GPS::Main')
         {
             my $wgp = $$ti{WriteGroup} || $$tagTablePtr{WRITE_GROUP};
@@ -456,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
@@ -478,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};
     }
 }
 

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

@@ -142,7 +142,6 @@ sub SaveMakerNotes($)
     }
     # save position of maker notes for pointer fixups
     $fixup->{Shift} += length($makerNotes);
-    $$et{MAKER_NOTE_FIXUP} = $fixup;
     $$et{MAKER_NOTE_BYTE_ORDER} = GetByteOrder();
     # add value data
     $makerNotes .= $makerInfo->{ValBuff};
@@ -150,7 +149,8 @@ sub SaveMakerNotes($)
     my $tagTablePtr = Image::ExifTool::GetTagTable('Image::ExifTool::Exif::Main');
     my $tagInfo = $et->GetTagInfo($tagTablePtr, 0x927c, \$makerNotes);
     # save the MakerNotes
-    $et->FoundTag($tagInfo, $makerNotes);
+    my $key = $et->FoundTag($tagInfo, $makerNotes);
+    $$et{TAG_EXTRA}{$key}{Fixup} = $fixup;
     # save the garbage collection some work later
     delete $makerInfo->{Entries};
     delete $makerInfo->{ValBuff};

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

@@ -930,8 +930,16 @@ Entry:  for (;;) {
                                     }
                                 }
                                 unless ($success) {
-                                    return undef if $et->Error("Error reading value for $name entry $index", $inMakerNotes);
-                                    ++$index;  $oldID = $newID;  next;  # drop this tag
+                                    my $wrn = sprintf("Error reading value for $name entry $index, ID 0x%.4x", $oldID);
+                                    my $truncOK;
+                                    if ($oldInfo and not $$oldInfo{Unknown}) {
+                                        $wrn .= " $$oldInfo{Name}";
+                                        $truncOK = $$oldInfo{TruncateOK};
+                                    }
+                                    return undef if $et->Error($wrn, $inMakerNotes || $truncOK);
+                                    unless ($truncOK) {
+                                        ++$index;  $oldID = $newID;  next;  # drop this tag
+                                    }
                                 }
                             } elsif (not $invalidPreview) {
                                 return undef if $et->Error("Bad $name offset for $tagStr", $inMakerNotes);
@@ -1094,6 +1102,8 @@ Entry:  for (;;) {
                 # add, edit or delete this tag
                 shift @newTags; # remove from list
                 my $curInfo = $set{$newID};
+                # don't allow MakerNotes to be added to ExifIFD of CR3 file
+                next if $newID == 0x927c and $isNew > 0 and $$et{FileType} eq 'CR3';
                 unless ($curInfo or $$addDirs{$newID}) {
                     # we can finally get the specific tagInfo reference for this tag
                     # (because we can now evaluate the Condition statement since all
@@ -1429,8 +1439,8 @@ NoOverwrite:            next if $isNew > 0;
                     if ($$et{DEL_GROUP}{MakerNotes} and
                        ($$et{DEL_GROUP}{MakerNotes} != 2 or $isNew <= 0))
                     {
-                        if ($et->IsRawType()) {
-                            $et->WarnOnce("Can't delete MakerNotes from $$et{FileType}",1);
+                        if ($et->IsRawType() and not ($et->IsRawType() == 2 and $dirName eq 'ExifIFD')) {
+                            $et->Warn("Can't delete MakerNotes from $$et{FileType}",1);
                         } else {
                             if ($isNew <= 0) {
                                 ++$$et{CHANGED};

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

@@ -96,6 +96,8 @@ my %ctboID = (
     "\xbe\x7a\xcf\xcb\x97\xa9\x42\xe8\x9c\x71\x99\x94\x91\xe3\xaf\xac" => 1, # XMP
     "\xea\xf4\x2b\x5e\x1c\x98\x4b\x88\xb9\xfb\xb7\xdc\x40\x6e\x4d\x16" => 2, # PreviewImage
     # ID 3 is used for 'mdat' atom (not a uuid)
+    # (haven't seen ID 4 yet)
+    "\x57\x66\xb8\x29\xbb\x6a\x47\xc5\xbc\xfb\x8b\x9f\x22\x60\xd0\x6d" => 5, # something to do with burst-roll image
 );
 
 # mark UserData tags that don't have ItemList counterparts as Preferred
@@ -1054,6 +1056,7 @@ sub WriteQuickTime($$$)
                     Parent   => $dirName,
                     DirName  => $subName,
                     Name     => $$tagInfo{Name},
+                    TagInfo  => $tagInfo,
                     DirID    => $tag,
                     DataPt   => \$buff,
                     DataLen  => $size,

data/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',
@@ -66,6 +68,7 @@ sub WriteRIFF($$)
         $et->InitWriteDirs(\%webpMap);
         my $addDirs = $$et{ADD_DIRS};
         my $editDirs = $$et{EDIT_DIRS};
+        $$addDirs{IFD0} = 'EXIF' if $$addDirs{EXIF}; # set flag to add IFD0 if adding EXIF (don't ask)
         my ($createVP8X, $deleteVP8X);
 
         # write header
@@ -142,6 +145,17 @@ sub WriteRIFF($$)
             }
             # RIFF chunks are padded to an even number of bytes
             my $len2 = $len + ($len & 0x01);
+            # handle incorrect "XMP\0" chunk ID written by Google software
+            if ($tag eq "XMP\0") {
+                if ($$et{DEL_GROUP}{XMP}) {
+                    # just ignore this chunk if deleting XMP
+                    $raf->Seek($len2, 1) or $et->Error('Seek error'), last;
+                    ++$$et{CHANGED};
+                    next;
+                } else {
+                    $et->Warn('Incorrect XMP tag ID',1) if $pass;
+                }
+            }
             # edit/add/delete necessary metadata chunks (EXIF must come before XMP)
             if ($$editDirs{$tag} or $tag eq '' or ($tag eq 'XMP ' and $$addDirs{EXIF})) {
                 my $handledTag;
@@ -156,13 +170,12 @@ 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')));
-                    delete $$addDirs{$dir}; # (don't try to add again)
                     my $start;
                     unless ($pass) {
                         # write the EXIF and save the result for the next pass
@@ -170,8 +183,15 @@ sub WriteRIFF($$)
                         if ($tag eq 'EXIF') {
                             # (only need to set directory $start for EXIF)
                             if ($buff =~ /^Exif\0\0/) {
-                                $et->Warn('Improper EXIF header') unless $pass;
-                                $start = 6;
+                                if ($$et{DEL_GROUP}{EXIF}) {
+                                    # remove incorrect header if rewriting anyway
+                                    $buff = substr($buff, 6);
+                                    $len -= 6;
+                                    $len2 -= 6;
+                                } else {
+                                    $et->Warn('Improper EXIF header',1) unless $pass;
+                                    $start = 6;
+                                }
                             } else {
                                 $start = 0;
                             }
@@ -189,11 +209,16 @@ 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;
                         $dirDat{$dir} = $et->WriteDirectory(\%dirInfo, $tagTablePtr, $writeProc);
                     }
+                    delete $$addDirs{$dir}; # (don't try to add again)
                     if (defined $dirDat{$dir}) {
                         if ($dir eq $tag) {
                             $handledTag = 1;    # set flag indicating we edited this tag

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

@@ -122,9 +122,9 @@ my %writableType = (
     XMP => [ undef,         'WriteXMP' ],
 );
 
-# RAW file types
+# RAW file types (2 = raw file where we can delete maker notes from ExifIFD)
 my %rawType = (
-   '3FR'=> 1,  CR3 => 1,  IIQ => 1,  NEF => 1,  RW2 => 1,
+   '3FR'=> 1,  CR3 => 2,  IIQ => 1,  NEF => 1,  RW2 => 1,
     ARQ => 1,  CRW => 1,  K25 => 1,  NRW => 1,  RWL => 1,
     ARW => 1,  DCR => 1,  KDC => 1,  ORF => 1,  SR2 => 1,
     ARW => 1,  ERF => 1,  MEF => 1,  PEF => 1,  SRF => 1,
@@ -278,6 +278,7 @@ my %ignorePrintConv = map { $_ => 1 } qw(OTHER BITMASK Notes);
 #           ListOnly => [internal use] set only list or non-list tags
 #           SetTags => [internal use] hash ref to return tagInfo refs of set tags
 #           Sanitized => [internal use] set to avoid double-sanitizing the value
+#           Fixup => [internal use] fixup information when writing maker notes
 # Returns: number of tags set (plus error string in list context)
 # Notes: For tag lists (like Keywords), call repeatedly with the same tag name for
 #        each value in the list.  Internally, the new information is stored in
@@ -1002,10 +1003,8 @@ TAG: foreach $tagInfo (@matchingTags) {
             $$nvHash{NoReplace} = 1 if $$tagInfo{List} and not $options{Replace};
             $$nvHash{WantGroup} = $wantGroup;
             $$nvHash{EditOnly} = 1 if $editOnly;
-            # save maker note information if writing maker notes
-            if ($$tagInfo{MakerNotes}) {
-                $$nvHash{MAKER_NOTE_FIXUP} = $$self{MAKER_NOTE_FIXUP};
-            }
+            # save maker note fixup information if writing maker notes
+            $$nvHash{MAKER_NOTE_FIXUP} = $options{Fixup} if $$tagInfo{MakerNotes};
             if ($createOnly) {  # create only (never edit)
                 # empty item in DelValue list to never edit existing value
                 $$nvHash{DelValue} = [ '' ];
@@ -1272,6 +1271,7 @@ sub SetNewValuesFromFile($$;@)
     # +------------------------------------------+
     $srcExifTool->Options(
         Binary          => 1,
+        ByteUnit        => $$options{ByteUnit},
         Charset         => $$options{Charset},
         CharsetEXIF     => $$options{CharsetEXIF},
         CharsetFileName => $$options{CharsetFileName},
@@ -1372,8 +1372,8 @@ sub SetNewValuesFromFile($$;@)
 #
     unless (@setTags) {
         # transfer maker note information to this object
-        $$self{MAKER_NOTE_FIXUP} = $$srcExifTool{MAKER_NOTE_FIXUP};
         $$self{MAKER_NOTE_BYTE_ORDER} = $$srcExifTool{MAKER_NOTE_BYTE_ORDER};
+        my $tagExtra = $$srcExifTool{TAG_EXTRA};
         foreach $tag (@tags) {
             # don't try to set errors or warnings
             next if $tag =~ /^(Error|Warning)\b/;
@@ -1381,10 +1381,13 @@ sub SetNewValuesFromFile($$;@)
             if ($opts{SrcType} and $opts{SrcType} ne $srcType) {
                 $$info{$tag} = $srcExifTool->GetValue($tag, $opts{SrcType});
             }
+            my $fixup = $$tagExtra{$tag}{Fixup};
+            $opts{Fixup} = $fixup if $fixup;
             # set value for this tag
             my ($n, $e) = $self->SetNewValue($tag, $$info{$tag}, %opts);
             # delete this tag if we couldn't set it
             $n or delete $$info{$tag};
+            delete $opts{Fixup} if $fixup;
         }
         return $info;
     }
@@ -1617,7 +1620,7 @@ SET:    foreach $set (@setList) {
             }
             # transfer maker note information if setting this tag
             if ($$srcExifTool{TAG_INFO}{$tag}{MakerNotes}) {
-                $$self{MAKER_NOTE_FIXUP} = $$srcExifTool{MAKER_NOTE_FIXUP};
+                $$opts{Fixup} = $$srcExifTool{TAG_EXTRA}{$tag}{Fixup};
                 $$self{MAKER_NOTE_BYTE_ORDER} = $$srcExifTool{MAKER_NOTE_BYTE_ORDER};
             }
             if ($dstTag eq '*') {
@@ -1649,6 +1652,7 @@ SET:    foreach $set (@setList) {
                 $rtnInfo{NextFreeTagKey(\%rtnInfo, 'Warning')} = $wrn;
                 $noWarn = 1;
             }
+            delete $$opts{Fixup};
             $rtnInfo{$tag} = $val if $rtn;  # tag was set successfully
         }
     }
@@ -4176,6 +4180,7 @@ sub WriteDirectory($$$;$)
     $out = $$self{OPTIONS}{TextOut} if $$self{OPTIONS}{Verbose};
     # set directory name from default group0 name if not done already
     my $dirName = $$dirInfo{DirName};
+    my $parent = $$dirInfo{Parent} || '';
     my $dataPt = $$dirInfo{DataPt};
     my $grp0 = $$tagTablePtr{GROUPS}{0};
     $dirName or $dirName = $$dirInfo{DirName} = $grp0;
@@ -4183,14 +4188,19 @@ 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
                 $self->IsRawType() and
                 # allow non-permanent MakerNote directories to be deleted (ie. NikonCapture)
                 (not $$dirInfo{TagInfo} or not defined $$dirInfo{TagInfo}{Permanent} or
-                $$dirInfo{TagInfo}{Permanent}))
+                $$dirInfo{TagInfo}{Permanent}) and
+                # allow MakerNotes to be deleted from ExifIFD of CR3 file
+                not ($self->IsRawType() == 2 and $parent eq 'ExifIFD'))
             {
                 $self->WarnOnce("Can't delete $1 from $$self{FileType}",1);
                 undef $grp1;
@@ -4226,7 +4236,6 @@ sub WriteDirectory($$$;$)
                 if ($delFlag == 2 and $right) {
                     # also check grandparent because some routines create 2 levels in 1
                     my $right2 = $$self{ADD_DIRS}{$right} || '';
-                    my $parent = $$dirInfo{Parent};
                     if (not $parent or $parent eq $right or $parent eq $right2) {
                         # prevent duplicate directories from being recreated at the same path
                         my $path = join '-', @{$$self{PATH}}, $dirName;
@@ -4284,10 +4293,27 @@ 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 $rawType{$$self{FileType}}) {
+            if ($blockName eq 'MakerNotes' and $self->IsRawType() and
+                # but allow MakerNotes to be deleted from ExifIFD of CR3 image (shouldn't be there)
+                not ($self->IsRawType() == 2 and $parent eq 'ExifIFD'))
+            {
                 $self->Warn("Can't delete MakerNotes from $$self{FileType}",1);
                 return undef;
             }
@@ -7067,7 +7093,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);

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

@@ -0,0 +1,185 @@
+#------------------------------------------------------------------------------
+# File:         XISF.pm
+#
+# Description:  Read Extensible Image Serialization Format metadata
+#
+# Revisions:    2023-10-10 - P. Harvey Created
+#
+# References:   1) https://pixinsight.com/doc/docs/XISF-1.0-spec/XISF-1.0-spec.html
+#------------------------------------------------------------------------------
+
+package Image::ExifTool::XISF;
+
+use strict;
+use vars qw($VERSION);
+use Image::ExifTool qw(:DataAccess :Utils);
+use Image::ExifTool::XMP;
+
+$VERSION = '1.00';
+
+# XISF tags (ref 1)
+%Image::ExifTool::XISF::Main = (
+    GROUPS => { 0 => 'XML', 1 => 'XML', 2 => 'Image' },
+    VARS => { LONG_TAGS => 1 },
+    NOTES => q{
+        This table lists some standard Extensible Image Serialization Format (XISF)
+        tags, but ExifTool will extract any other tags found.  See
+        L<https://pixinsight.com/xisf/> for the specification.
+    },
+    ImageGeometry   => { },
+    ImageSampleFormat => { },
+    ImageBounds     => { },
+    ImageImageType  => { Name => 'ImageType' },
+    ImageColorSpace => { Name => 'ColorSpace' },
+    ImageLocation   => { },
+    ImageResolutionHorizontal => 'XResolution',
+    ImageResolutionVertical => 'YResolution',
+    ImageResolutionUnit => 'ResolutionUnit',
+    ImageICCProfile => {
+        Name => 'ICC_Profile',
+        ValueConv => 'Image::ExifTool::XMP::DecodeBase64($val)',
+        Binary => 1,
+    },
+    ImageICCProfileLocation => { Name => 'ICCProfileLocation' },
+    ImagePixelStorage => { },
+    ImageOffset      => { Name => 'ImagePixelOffset' },
+    ImageOrientation => { Name => 'Orientation' },
+    ImageId          => { Name => 'ImageID' },
+    ImageUuid        => { Name => 'UUID' },
+    ImageData        => { Binary => 1 },
+    'CreationTime' => {
+        Name => 'CreateDate',
+        Shift => 'Time',
+        Groups => { 2 => 'Time' },
+        ValueConv => 'Image::ExifTool::XMP::ConvertXMPDate($val)',
+        PrintConv => '$self->ConvertDateTime($val)',
+    },
+    CreatorApplication => { },
+    Abstract        => { },
+    AccessRights    => { },
+    Authors         => { Groups => { 2 => 'Author' } },
+    BibliographicReferences => { },
+    BriefDescription => { },
+    CompressionLevel => { },
+    CompressionCodecs => { },
+    Contributors    => { Groups => { 2 => 'Author' } },
+    Copyright       => { Groups => { 2 => 'Author' } },
+    CreatorModule   => { },
+    CreatorOS       => { },
+    Description     => { },
+    Keywords        => { },
+    Languages       => { },
+    License         => { },
+    OriginalCreationTime => {
+        Name => 'DateTimeOriginal',
+        Description => 'Date/Time Original',
+        Shift => 'Time',
+        Groups => { 2 => 'Time' },
+        ValueConv => 'Image::ExifTool::XMP::ConvertXMPDate($val)',
+        PrintConv => '$self->ConvertDateTime($val)',
+    },
+    RelatedResources => { },
+    Title            => { },
+);
+
+#------------------------------------------------------------------------------
+# Handle properties in XISF metadata structures
+# Inputs: 0) attribute list ref, 1) attr hash ref,
+#         2) property name ref, 3) property value ref
+# Returns: true if value was changed
+sub HandleXISFAttrs($$$$)
+{
+    my ($attrList, $attrs, $prop, $valPt) = @_;
+    return 0 unless defined $$attrs{id};
+    my ($changed, $a);
+    # use "id" as the tag name, "value" as the value, and ignore "type"
+    $$prop = $$attrs{id};
+    $$prop =~ s/^XISF://;   # remove XISF namespace
+    if (defined $$attrs{value}) {
+        $$valPt = $$attrs{value};
+        $changed = 1;
+    }
+    my @attrs = @$attrList;
+    @$attrList = ( );
+    foreach $a (@attrs) {
+        if ($a eq 'id' or $a eq 'value' or $a eq 'type') {
+            delete $$attrs{$a};
+        } else {
+            push @$attrList, $a;
+        }
+    }
+    return $changed;
+}
+
+#------------------------------------------------------------------------------
+# Read information in a XISF document
+# Inputs: 0) ExifTool ref, 1) dirInfo ref
+# Returns: 1 on success, 0 if this wasn't a valid XISF file
+sub ProcessXISF($$)
+{
+    my ($et, $dirInfo) = @_;
+    my $raf = $$dirInfo{RAF};
+    my $buff;
+
+    return 0 unless $raf->Read($buff, 16) == 16 and $buff =~ /^XISF0100/;
+    $et->SetFileType();
+    SetByteOrder('II');
+    my $tagTablePtr = GetTagTable('Image::ExifTool::XISF::Main');
+    my $hdrLen = Get32u(\$buff, 8);
+    $raf->Read($buff, $hdrLen) == $hdrLen or $et->Warn('Error reading XISF header'), return 1;
+    $et->FoundTag(XML => $buff);
+    my %dirInfo = (
+        DataPt => \$buff,
+        IgnoreProp => { xisf => 1, Metadata => 1, Property => 1 },
+        XMPParseOpts => { AttrProc => \&HandleXISFAttrs },
+    );
+    Image::ExifTool::XMP::ProcessXMP($et, \%dirInfo, $tagTablePtr);
+    my $geo = $$et{VALUE}{ImageGeometry};
+    if ($geo) {
+        my ($w, $h, $n) = split /:/, $geo;
+        $et->FoundTag(ImageWidth => $w);
+        $et->FoundTag(ImageHeight => $h);
+        $et->FoundTag(NumPlanes => $n);
+    }
+    return 1;
+}
+
+1;  # end
+
+__END__
+
+=head1 NAME
+
+Image::ExifTool::XISF - Read Extensible Image Serialization Format metadata
+
+=head1 SYNOPSIS
+
+This module is used by Image::ExifTool
+
+=head1 DESCRIPTION
+
+This module contains definitions required by Image::ExifTool to read meta
+information from XISF (Extensible Image Serialization Format) images.
+
+=head1 AUTHOR
+
+Copyright 2003-2023, Phil Harvey (philharvey66 at gmail.com)
+
+This library is free software; you can redistribute it and/or modify it
+under the same terms as Perl itself.
+
+=head1 REFERENCES
+
+=over 4
+
+=item L<https://pixinsight.com/doc/docs/XISF-1.0-spec/XISF-1.0-spec.html>
+
+=back
+
+=head1 SEE ALSO
+
+L<Image::ExifTool::TagNames/XISF Tags>,
+L<Image::ExifTool(3pm)|Image::ExifTool>
+
+=cut
+