exiftool_vendored 12.25.0 → 12.35.0

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

@@ -13,10 +13,11 @@ package Image::ExifTool::Torrent;
 use strict;
 use vars qw($VERSION);
 use Image::ExifTool qw(:DataAccess :Utils);
+use Image::ExifTool::XMP;
 
-$VERSION = '1.04';
+$VERSION = '1.05';
 
-sub ReadBencode($$);
+sub ReadBencode($$$);
 sub ExtractTags($$$;$$@);
 
 # tags extracted from BitTorrent files
@@ -99,12 +100,12 @@ sub ReadMore($$)
 
 #------------------------------------------------------------------------------
 # Read bencoded value
-# Inputs: 0) input file, 1) buffer (pos must be set to current position)
+# Inputs: 0) ExifTool ref, 1) input file, 2) buffer (pos must be set to current position)
 # Returns: HASH ref, ARRAY ref, SCALAR ref, SCALAR, or undef on error or end of data
 # Notes: Sets BencodeError element of RAF on any error
-sub ReadBencode($$)
+sub ReadBencode($$$)
 {
-    my ($raf, $dataPt) = @_;
+    my ($et, $raf, $dataPt) = @_;
 
     # read more if necessary (keep a minimum of 64 bytes in the buffer)
     my $pos = pos($$dataPt);
@@ -123,21 +124,21 @@ sub ReadBencode($$)
     } elsif ($tok eq 'd') { # dictionary
         $val = { };
         for (;;) {
-            my $k = ReadBencode($raf, $dataPt);
+            my $k = ReadBencode($et, $raf, $dataPt);
             last unless defined $k;
             # the key must be a byte string
             if (ref $k) {
                 ref $k ne 'SCALAR' and $$raf{BencodeError} = 'Bad dictionary key', last;
                 $k = $$k;
             }
-            my $v = ReadBencode($raf, $dataPt);
+            my $v = ReadBencode($et, $raf, $dataPt);
             last unless defined $v;
             $$val{$k} = $v;
         }
     } elsif ($tok eq 'l') { # list
         $val = [ ];
         for (;;) {
-            my $v = ReadBencode($raf, $dataPt);
+            my $v = ReadBencode($et, $raf, $dataPt);
             last unless defined $v;
             push @$val, $v;
         }
@@ -165,8 +166,14 @@ sub ReadBencode($$)
         }
         if (defined $value) {
             # return as binary data unless it is a reasonable-length ASCII string
-            if (length($value) > 256 or $value =~ /[^\t\x20-\x7e]/) {
+            if (length($value) > 256) {
                 $val = \$value;
+            } elsif ($value =~ /[^\t\x20-\x7e]/) {
+                if (Image::ExifTool::XMP::IsUTF8(\$value) >= 0) {
+                    $val = $et->Decode($value, 'UTF8');
+                } else {
+                    $val = \$value;
+                }
             } else {
                 $val = $value;
             }
@@ -206,7 +213,7 @@ sub ExtractTags($$$;$$@)
             my $tagInfo = $et->GetTagInfo($tagTablePtr, $id) or next;
             if (ref $val eq 'ARRAY') {
                 if ($$tagInfo{JoinPath}) {
-                    $val = join '/', @$val;
+                    $val = join '/', map { ref $_ ? '(Binary data)' : $_ } @$val;
                 } else {
                     push @more, @$val;
                     next if ref $more[0] eq 'ARRAY'; # continue expanding nested lists
@@ -273,7 +280,7 @@ sub ProcessTorrent($$)
     my $raf = $$dirInfo{RAF};
     my $buff = '';
     pos($buff) = 0;
-    my $dict = ReadBencode($raf, \$buff);
+    my $dict = ReadBencode($et, $raf, \$buff);
     my $err = $$raf{BencodeError};
     $et->Warn("Bencode error: $err") if $err;
     if (ref $dict eq 'HASH' and ($$dict{announce} or $$dict{'created by'})) {

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

@@ -170,7 +170,7 @@ sub FormatIPTC($$$$$;$)
         } else {
             my $len = int(($1 || 0) / 8);
             if ($len == 1) {        # 1 byte
-                $$valPtr = chr($$valPtr);
+                $$valPtr = chr($$valPtr & 0xff);
             } elsif ($len == 2) {   # 2-byte integer
                 $$valPtr = pack('n', $$valPtr);
             } else {                # 4-byte integer

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

@@ -293,6 +293,7 @@ sub WritePDF($$)
     my $newTool = new Image::ExifTool;
     $newTool->Options(List => 1);
     $newTool->Options(Password => $et->Options('Password'));
+    $newTool->Options(NoPDFList => $et->Options('NoPDFList'));
     $$newTool{PDF_CAPTURE} = \%capture;
     my $info = $newTool->ImageInfo($raf, 'XMP', 'PDF:*', 'Error', 'Warning');
     # not a valid PDF file unless we got a version number

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

@@ -179,6 +179,8 @@ sub BuildTextChunk($$$$$)
             $tag =~ s/-$lang$//;    # remove language code from tagID
         } elsif ($$et{OPTIONS}{Charset} ne 'Latin' and $val =~  /[\x80-\xff]/) {
             $iTXt = 1;      # write as iTXt if it contains non-Latin special characters
+        } elsif ($$tagInfo{iTXt}) {
+            $iTXt = 1;      # write as iTXt if specified in user-defined tag
         }
     }
     if ($comp) {

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

@@ -163,6 +163,9 @@ sub ConvInvISO6709($)
         # latitude must have 2 digits before the decimal, and longitude 3,
         # and all values must start with a "+" or "-", and Google Photos
         # requires at least 3 digits after the decimal point
+        # (and as of Apr 2021, Google Photos doesn't accept coordinats
+        #  with more than 5 digits after the decimal place:
+        #  https://exiftool.org/forum/index.php?topic=11055.msg67171#msg67171 )
         my @fmt = ('%s%02d.%s%s','%s%03d.%s%s','%s%d.%s%s');
         foreach (@a) {
             return undef unless Image::ExifTool::IsFloat($_);
@@ -314,7 +317,7 @@ sub FormatQTValue($$;$$)
         if ($writable and $qtFormat{$writable}) {
             $flags = $qtFormat{$writable};
         } else {
-            $flags = $qtFormat{$format} || 0;
+            $flags = $qtFormat{$format || 0} || 0;
         }
     } elsif ($$valPt =~ /^\xff\xd8\xff/) {
         $flags = 0x0d;  # JPG
@@ -846,7 +849,7 @@ sub WriteQuickTime($$$)
                 # --> hold this terminator to the end
                 $term = $hdr;
             } elsif ($n != 0) {
-                $et->Error('File format error');
+                $et->Error("Unknown $n bytes at end of file", 1);
             }
             last;
         }
@@ -1064,6 +1067,9 @@ sub WriteQuickTime($$$)
                     #  3=optional base offset, 4=optional item ID)
                     ChunkOffset => \@chunkOffset,
                 );
+                # set InPlace flag so XMP will be padded properly when
+                # QuickTimePad is used if this is an XMP directory
+                $subdirInfo{InPlace} = 2 if $et->Options('QuickTimePad');
                 # pass the header pointer if necessary (for EXIF IFD's
                 # where the Base offset is at the end of the header)
                 if ($hdrLen and $hdrLen < $size) {
@@ -1086,7 +1092,9 @@ sub WriteQuickTime($$$)
                     $$et{CHANGED} = $oldChanged if $$et{DemoteErrors} > 1;
                     delete $$et{DemoteErrors};
                 }
-                if (defined $newData and not length $newData and $$tagTablePtr{PERMANENT}) {
+                if (defined $newData and not length $newData and ($$tagInfo{Permanent} or
+                    ($$tagTablePtr{PERMANENT} and not defined $$tagInfo{Permanent})))
+                {
                     # do nothing if trying to delete tag from a PERMANENT table
                     $$et{CHANGED} = $oldChanged;
                     undef $newData;
@@ -1094,7 +1102,9 @@ sub WriteQuickTime($$$)
                 $$et{CUR_WRITE_GROUP} = $oldWriteGroup;
                 SetByteOrder('MM');
                 # add back header if necessary
-                if ($start and defined $newData and length $newData) {
+                if ($start and defined $newData and (length $newData or
+                    (defined $$tagInfo{Permanent} and not $$tagInfo{Permanent})))
+                {
                     $newData = substr($buff,0,$start) . $newData;
                     $$_[1] += $start foreach @chunkOffset;
                 }
@@ -1324,6 +1334,13 @@ sub WriteQuickTime($$$)
             }
             # write the new atom if it was modified
             if (defined $newData) {
+                my $sizeDiff = length($buff) - length($newData);
+                if ($sizeDiff > 0 and $$tagInfo{PreservePadding} and $et->Options('QuickTimePad')) {
+                    $newData .= "\0" x $sizeDiff;
+                    $et->VPrint(1, "    ($$tagInfo{Name} padded to original size)");
+                } elsif ($sizeDiff) {
+                    $et->VPrint(1, "    ($$tagInfo{Name} changed size)");
+                }
                 my $len = length($newData) + 8;
                 $len > 0x7fffffff and $et->Error("$$tagInfo{Name} to large to write"), last;
                 # update size in ChunkOffset list for modified 'uuid' atom

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

@@ -1469,7 +1469,7 @@ sub WriteXMP($$;$)
             $long[-2] .= "$nl$sp<$prop rdf:about='${about}'";
             # generate et:toolkit attribute if this is an exiftool RDF/XML output file
             if (@ns and $nsCur{$ns[0]} =~ m{^http://ns.exiftool.(?:ca|org)/}) {
-                $long[-2] .= "\n$sp${sp}xmlns:et='http://ns.exiftool.ca/1.0/'" .
+                $long[-2] .= "\n$sp${sp}xmlns:et='http://ns.exiftool.org/1.0/'" .
                             " et:toolkit='Image::ExifTool $Image::ExifTool::VERSION'";
             }
             $long[-2] .= "\n$sp${sp}xmlns:$_='$nsCur{$_}'" foreach @ns;

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

@@ -574,6 +574,9 @@ sub SetNewValue($;$$%)
                     my $pre = $wantGroup ? $wantGroup . ':' : '';
                     $err = "Tag '$pre${origTag}' is not defined";
                     $err .= ' or has a bad language code' if $origTag =~ /-/;
+                    if (not $pre and uc($origTag) eq 'TAG') {
+                        $err .= " (specify a writable tag name, not '${origTag}' literally)"
+                    }
                 } else {
                     $err = "Invalid tag name '${tag}'";
                     $err .= " (remove the leading '\$')" if $tag =~ /^\$/;
@@ -2071,6 +2074,46 @@ sub SetSystemTags($$)
             last;
         }
     }
+    # delete Windows Zone.Identifier if specified
+    my $zhash = $self->GetNewValueHash($Image::ExifTool::Extra{ZoneIdentifier});
+    if ($zhash) {
+        my $res = -1;
+        if ($^O ne 'MSWin32') {
+            $self->Warn('ZoneIdentifer is a Windows-only tag');
+        } elsif (ref $file) {
+            $self->Warn('Writing ZoneIdentifer requires a file name');
+        } elsif (defined $self->GetNewValue('ZoneIdentifier', \$zhash)) {
+            $self->Warn('ZoneIndentifier may only be delted');
+        } elsif (not eval { require Win32API::File }) {
+            $self->Warn('Install Win32API::File to write ZoneIdentifier');
+        } else {
+            my ($wattr, $wide);
+            my $zfile = "${file}:Zone.Identifier";
+            if ($self->EncodeFileName($zfile)) {
+                $wide = 1;
+                $wattr = eval { Win32API::File::GetFileAttributesW($zfile) };
+            } else {
+                $wattr = eval { Win32API::File::GetFileAttributes($zfile) };
+            }
+            if ($wattr == Win32API::File::INVALID_FILE_ATTRIBUTES()) {
+                $res = 0; # file doesn't exist, nothing to do
+            } elsif ($wattr & Win32API::File::FILE_ATTRIBUTE_READONLY()) {
+                $self->Warn('Zone.Identifier stream is read-only');
+            } else {
+                if ($wide) {
+                    $res = 1 if eval { Win32API::File::DeleteFileW($zfile) };
+                } else {
+                    $res = 1 if eval { Win32API::File::DeleteFile($zfile) };
+                }
+                if ($res > 0) {
+                    $self->VPrint(0, "  Deleting Zone.Identifier stream\n");
+                } else {
+                    $self->Warn('Error deleting Zone.Identifier stream');
+                }
+            }
+        }
+        $result = $res if $res == 1 or not $result;
+    }
     return $result;
 }
 
@@ -4755,6 +4798,8 @@ sub InverseDateTime($$;$$)
                 $strptimeLib = '';
             }
         }
+        # handle factional seconds (%f), but only at the end of the string
+        my $fs = ($fmt =~ s/%f$// and $val =~ s/(\.\d+)\s*$//) ? $1 : '';
         my ($lib, $wrn, @a);
 TryLib: for ($lib=$strptimeLib; ; $lib='') {
             if (not $lib) {
@@ -4791,10 +4836,10 @@ TryLib: for ($lib=$strptimeLib; ; $lib='') {
                         next TryLib;
                     }
                 } elsif (length($a[$i]) < 2) {
-                    $$a[$i] = "0$a[$i]";# pad to 2 digits if necessary
+                    $a[$i] = "0$a[$i]"; # pad to 2 digits if necessary
                 }
             }
-            $val = join(':', @a[5,4,3]) . ' ' . join(':', @a[2,1,0]);
+            $val = join(':', @a[5,4,3]) . ' ' . join(':', @a[2,1,0]) . $fs;
             last;
         }
     }

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

@@ -50,7 +50,7 @@ use Image::ExifTool::Exif;
 use Image::ExifTool::GPS;
 require Exporter;
 
-$VERSION = '3.41';
+$VERSION = '3.47';
 @ISA = qw(Exporter);
 @EXPORT_OK = qw(EscapeXML UnescapeXML);
 
@@ -155,7 +155,7 @@ my %xmpNS = (
     DICOM     => 'http://ns.adobe.com/DICOM/',
    'drone-dji'=> 'http://www.dji.com/drone-dji/1.0/',
     svg       => 'http://www.w3.org/2000/svg',
-    et        => 'http://ns.exiftool.ca/1.0/',
+    et        => 'http://ns.exiftool.org/1.0/',
 #
 # namespaces defined in XMP2.pl:
 #
@@ -195,7 +195,7 @@ my %xmpNS = (
 );
 
 # build reverse namespace lookup
-my %uri2ns = ( 'http://ns.exiftool.org/1.0/' => 'et' ); # (allow exiftool.org as well as exiftool.ca)
+my %uri2ns = ( 'http://ns.exiftool.ca/1.0/' => 'et' ); # (allow exiftool.ca as well as exiftool.org)
 {
     my $ns;
     foreach $ns (keys %nsURI) {
@@ -1533,6 +1533,9 @@ my %sPantryItem = (
                     CameraProfile   => { },
                     LookTable       => { },
                     ToneCurvePV2012 => { List => 'Seq' },
+                    ToneCurvePV2012Red   => { List => 'Seq' },
+                    ToneCurvePV2012Green => { List => 'Seq' },
+                    ToneCurvePV2012Blue  => { List => 'Seq' },
                 },
             },
         }
@@ -2017,6 +2020,11 @@ my %sPantryItem = (
         Groups => { 2 => 'Location' },
         Writable => 'integer',
         PrintConv => {
+            OTHER => sub {
+                my ($val, $inv) = @_;
+                return undef unless $inv and $val =~ /^([-+0-9])/;
+                return($1 eq '-' ? 1 : 0);
+            },
             0 => 'Above Sea Level',
             1 => 'Below Sea Level',
         },
@@ -2134,8 +2142,8 @@ my %sPantryItem = (
     NAMESPACE   => 'exifEX',
     PRIORITY => 0, # not as reliable as actual EXIF tags
     NOTES => q{
-        EXIF tags added by the EXIF 2.31 for XMP specification (see
-        L<http://www.cipa.jp/std/documents/e/DC-X010-2017.pdf>).
+        EXIF tags added by the EXIF 2.32 for XMP specification (see
+        L<https://cipa.jp/std/documents/download_e.html?DC-010-2020_E>).
     },
     Gamma                       => { Writable => 'rational' },
     PhotographicSensitivity     => { Writable => 'integer' },
@@ -2341,6 +2349,9 @@ my %sPantryItem = (
     Scene               => { Groups => { 2 => 'Other' }, List => 'Bag' },
     SubjectCode         => { Groups => { 2 => 'Other' }, List => 'Bag' },
     # Copyright - have seen this in a sample (Jan 2021), but I think it is non-standard
+    # new IPTC Core 1.3 properties
+    AltTextAccessibility  => { Groups => { 2 => 'Other' }, Writable => 'lang-alt' },
+    ExtDescrAccessibility => { Groups => { 2 => 'Other' }, Writable => 'lang-alt' },
 );
 
 # Adobe Lightroom namespace properties (lr) (ref PH)
@@ -3258,8 +3269,14 @@ NoLoop:
             }
         }
         # generate a default tagInfo hash if necessary
-        $tagInfo or $tagInfo = { Name => $name, IsDefault => 1, Priority => 0 };
-
+        unless ($tagInfo) {
+            # shorten tag name if necessary
+            if ($$et{ShortenXmpTags}) {
+                my $shorten = $$et{ShortenXmpTags};
+                $name = &$shorten($name);
+            }
+            $tagInfo = { Name => $name, IsDefault => 1, Priority => 0 };
+        }
         # add tag Namespace entry for tags in variable-namespace tables
         $$tagInfo{Namespace} = $xns if $xns;
         if ($$et{curURI}{$ns} and $$et{curURI}{$ns} =~ m{^http://ns.exiftool.(?:ca|org)/(.*?)/(.*?)/}) {
@@ -3778,6 +3795,7 @@ sub ParseXMPElement($$$;$$$$)
                 # (unless we already extracted shorthand values from this element)
                 if (length $val or not $shorthand) {
                     my $lastProp = $$propList[-1];
+                    $lastProp = '' unless defined $lastProp;
                     if (defined $nodeID) {
                         SaveBlankInfo($blankInfo, $propList, $val);
                     } elsif ($lastProp eq 'rdf:type' and $wasEmpty) {
@@ -3948,7 +3966,7 @@ sub ProcessXMP($$;$)
                         } elsif ($1 eq 'REDXIF') {
                             $type = 'RMD';
                             $mime = 'application/xml';
-                        } else {
+                        } elsif ($1 ne 'fcpxml') { # Final Cut Pro XML
                             return 0;
                         }
                     } elsif ($buf2 =~ /<svg[\s>]/) {
@@ -3958,14 +3976,16 @@ sub ProcessXMP($$;$)
                     } elsif ($buf2 =~ /<plist[\s>]/) {
                         $type = 'PLIST';
                     }
-                    if ($isSVG and $$et{XMP_CAPTURE}) {
-                        $et->Error("ExifTool does not yet support writing of SVG images");
-                        return 0;
-                    }
                 }
                 $isXML = 1;
             } elsif ($2 eq '<rdf:RDF') {
                 $isRDF = 1;     # recognize XMP without x:xmpmeta element
+            } elsif ($2 eq '<svg') {
+                $isSVG = $isXML = 1;
+            }
+            if ($isSVG and $$et{XMP_CAPTURE}) {
+                $et->Error("ExifTool does not yet support writing of SVG images");
+                return 0;
             }
             if ($buff =~ /^\0\0/) {
                 $fmt = 'N';     # UTF-32 MM with or without BOM

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

@@ -537,9 +537,10 @@ my %sImageRegion = ( # new in 1.5
     NAMESPACE   => 'Iptc4xmpExt',
     TABLE_DESC => 'XMP IPTC Extension',
     NOTES => q{
-        This table contains tags defined by the IPTC Extension schema version 1.5. 
+        This table contains tags defined by the IPTC Extension schema version 1.6. 
         The actual namespace prefix is "Iptc4xmpExt", but ExifTool shortens this for
-        the family 1 group name. (see L<http://www.iptc.org/IPTC4XMP/>)
+        the family 1 group name. (see
+        L<http://www.iptc.org/standards/photo-metadata/iptc-standard/>)
     },
     AboutCvTerm => {
         Struct => \%sCVTermDetails,
@@ -796,6 +797,8 @@ my %sImageRegion = ( # new in 1.5
     audioBitsPerSample  => { Groups => { 2 => 'Audio' }, Writable => 'integer' },
     # new IPTC Extension schema 1.5 property
     ImageRegion => { Groups => { 2 => 'Image' }, List => 'Bag', Struct => \%sImageRegion },
+    # new Extension 1.6 property
+    EventId     => { Name => 'EventID', List => 'Bag' },
 );
 
 #------------------------------------------------------------------------------

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

@@ -32,7 +32,9 @@ sub SerializeStruct($;$)
     my ($key, $val, @vals, $rtnVal);
 
     if (ref $obj eq 'HASH') {
-        foreach $key (sort keys %$obj) {
+        # support hashes with ordered keys
+        my @keys = $$obj{_ordered_keys_} ? @{$$obj{_ordered_keys_}} : sort keys %$obj;
+        foreach $key (@keys) {
             push @vals, $key . '=' . SerializeStruct($$obj{$key}, '}');
         }
         $rtnVal = '{' . join(',', @vals) . '}';

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

@@ -14,7 +14,7 @@ use strict;
 use vars qw($VERSION);
 use Image::ExifTool qw(:DataAccess :Utils);
 
-$VERSION = '1.00';
+$VERSION = '1.01';
 
 %Image::ExifTool::ZISRAW::Main = (
     PROCESS_PROC => \&Image::ExifTool::ProcessBinaryData,
@@ -41,6 +41,123 @@ $VERSION = '1.00';
     },
 );
 
+#------------------------------------------------------------------------------
+# Shorten obscenely long CZI tag names
+# Inputs: Tag name
+# Returns: Shortened tag name
+sub ShortenTagNames($)
+{
+    local $_;
+    $_ = shift;
+    s/^HardwareSetting//;
+    s/^DevicesDevice/Device/;
+    s/LightPathNode//g;
+    s/Successors//g;
+    s/ExperimentExperiment/Experiment/g;
+    s/ObjectivesObjective/Objective/;
+    s/ChannelsChannel/Channel/;
+    s/TubeLensesTubeLens/TubeLens/;
+    s/^ExperimentHardwareSettingsPoolHardwareSetting/HardwareSetting/;
+    s/SharpnessMeasureSetSharpnessMeasure/Sharpness/;
+    s/FocusSetupAutofocusSetup/Autofocus/;
+    s/TracksTrack/Track/;
+    s/ChannelRefsChannelRef/ChannelRef/;
+    s/ChangerChanger/Changer/;
+    s/ElementsChangerElement/Changer/;
+    s/ChangerElements/Changer/;
+    s/ContrastChangerContrast/Contrast/;
+    s/KeyFunctionsKeyFunction/KeyFunction/;
+    s/ManagerContrastManager(Contrast)?/ManagerContrast/;
+    s/ObjectiveChangerObjective/ObjectiveChanger/;
+    s/ManagerLightManager/ManagerLight/;
+    s/WavelengthAreasWavelengthArea/WavelengthArea/;
+    s/ReflectorChangerReflector/ReflectorChanger/;
+    s/^StageStageAxesStageAxis/StageAxis/;
+    s/ShutterChangerShutter/ShutterChanger/;
+    s/OnOffChangerOnOff/OnOffChanger/;
+    s/UnsharpMaskStateUnsharpMask/UnsharpMask/;
+    s/Acquisition/Acq/;
+    s/Continuous/Cont/;
+    s/Resolution/Res/;
+    s/Experiment/Expt/g;
+    s/Threshold/Thresh/;
+    s/Reference/Ref/;
+    s/Magnification/Mag/;
+    s/Original/Orig/;
+    s/FocusSetupFocusStrategySetup/Focus/;
+    s/ParametersParameter/Parameter/;
+    s/IntervalInfo/Interval/;
+    s/ExptBlocksAcqBlock/AcqBlock/;
+    s/MicroscopesMicroscope/Microscope/;
+    s/TimeSeriesInterval/TimeSeries/;
+    s/Interval(.*Interval)/$1/;
+    s/SingleTileRegionsSingleTileRegion/SingleTileRegion/;
+    s/AcquisitionMode//;
+    s/DetectorsDetector/Detector/;
+    s/Setup//;
+    s/Setting//;
+    s/TrackTrack/Track/;
+    s/AnalogOutMaximumsAnalogOutMaximum/AnalogOutMaximum/;
+    s/AnalogOutMinimumsAnalogOutMinimum/AnalogOutMinimum/;
+    s/DigitalOutLabelsDigitalOutLabelLabel/DigitalOutLabelLabel/;
+    s/(VivaTomeOpticalSectionInformation)+VivaTomeOpticalSectionInformation/VivaTomeOpticalSectionInformation/;
+    s/FocusDefiniteFocus/FocusDefinite/;
+    s/ChangerChanger/Changer/;
+    s/Calibration/Cal/;
+    s/LightSwitchChangerRLTLSwitch/LightSwitchChangerRLTL/;
+    s/Parameters//;
+    s/Fluorescence/Fluor/;
+    s/CameraGeometryCameraGeometry/CameraGeometry/;
+    s/CameraCamera/Camera/;
+    s/DetectorsCamera/Camera/;
+    s/FilterChangerLeftChangerEmissionFilter/LeftChangerEmissionFilter/;
+    s/SwitchingStatesSwitchingState/SwitchingState/;
+    s/Information/Info/;
+    s/SubDimensions?//g;
+    s/Setups?//;
+    s/Parameters?//;
+    s/Calculate/Calc/;
+    s/Visibility/Vis/;
+    s/Orientation/Orient/;
+    s/ListItems/Items/;
+    s/Increment/Incr/;
+    s/Parameter/Param/;
+    s/(ParfocalParcentralValues)+ParfocalParcentralValue/Parcentral/;
+    s/ParcentralParcentral/Parcentral/;
+    s/CorrFocusCorrection/FocusCorr/;
+    s/(ApoTomeDepthInfo)+Element/ApoTomeDepth/;
+    s/(ApoTomeClickStopInfo)+Element/ApoTomeClickStop/;
+    s/DepthDepth/Depth/;
+    s/(Devices?)+Device/Device/;
+    s/(BeamPathNode)+/BeamPathNode/;
+    s/BeamPathsBeamPath/BeamPath/g;
+    s/BeamPathBeamPath/BeamPath/g;
+    s/Configuration/Config/;
+    s/StageAxesStageAxis/StageAxis/;
+    s/RangesRange/Range/;
+    s/DataGridDatasGridData(Grid)?/DataGrid/;
+    s/DataMicroscopeDatasMicroscopeData(Microscope)?/DataMicroscope/;
+    s/DataWegaDatasWegaData/DataWega/;
+    s/ClickStopPositionsClickStopPosition/ClickStopPosition/;
+    s/LightSourcess?LightSource(Settings)?(LightSource)?/LightSource/;
+    s/FilterSetsFilterSet/FilterSet/;
+    s/EmissionFiltersEmissionFilter/EmissionFilter/;
+    s/ExcitationFiltersExcitationFilter/ExcitationFilter/;
+    s/FiltersFilter/Filter/;
+    s/DichroicsDichroic/Dichronic/;
+    s/WavelengthsWavelength/Wavelength/;
+    s/MultiTrackSetup/MultiTrack/;
+    s/TrackTrack/Track/;
+    s/DataGrabberSetup/DataGrabber/;
+    s/CameraFrameSetup/CameraFrame/;
+    s/TimeSeries(TimeSeries|Setups)/TimeSeries/;
+    s/FocusFocus/Focus/;
+    s/FocusAutofocus/Autofocus/;
+    s/Focus(Hardware|Software)(Autofocus)+/Autofocus$1/;
+    s/AutofocusAutofocus/Autofocus/;
+    return $_;
+}
+
 #------------------------------------------------------------------------------
 # Extract metadata from a ZISRAW (CZI) image
 # Inputs: 0) ExifTool object reference, 1) dirInfo reference
@@ -76,7 +193,9 @@ sub ProcessCZI($$)
     $tagTablePtr = GetTagTable('Image::ExifTool::XMP::XML');
     $dirInfo{DirLen} = length $buff;
     # shorten tag names somewhat by removing 'ImageDocumentMetadata' prefix from all
-    $$et{XmpIgnoreProps} = [ 'ImageDocument', 'Metadata' ];
+    $$et{XmpIgnoreProps} = [ 'ImageDocument', 'Metadata', 'Information' ];
+    $$et{ShortenXmpTags} = \&ShortenTagNames;
+
     $et->ProcessDirectory(\%dirInfo, $tagTablePtr);
 
     return 1;