exiftool-vendored.pl 12.62.0 → 12.67.0

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

@@ -17,7 +17,7 @@ package Image::ExifTool::Validate;
 use strict;
 use vars qw($VERSION %exifSpec);
 
-$VERSION = '1.20';
+$VERSION = '1.21';
 
 use Image::ExifTool qw(:Utils);
 use Image::ExifTool::Exif;
@@ -56,6 +56,15 @@ use Image::ExifTool::Exif;
     0x212 => 1,  0x9204 => 1,   0xa210 => 1,   0xa500 => 221,
     0x213 => 1,  0x9205 => 1,   0xa214 => 1,
     0x214 => 1,  0x9206 => 1,   0xa215 => 1,
+
+    # new Exif 3.0 tags
+    0xa436 => 300,
+    0xa437 => 300,
+    0xa438 => 300,
+    0xa439 => 300,
+    0xa43a => 300,
+    0xa43b => 300,
+    0xa43c => 300,
 );
 
 # GPSVersionID numbers when each tag was introduced
@@ -147,6 +156,13 @@ my %stdFormat = (
         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)',
+        # Exif 3.0 spec
+        0x10e  => 'string|utf8',  0xa430 => 'string|utf8',  0xa439 => 'string|utf8',
+        0x10f  => 'string|utf8',  0xa433 => 'string|utf8',  0xa43a => 'string|utf8',
+        0x110  => 'string|utf8',  0xa434 => 'string|utf8',  0xa43b => 'string|utf8',
+        0x131  => 'string|utf8',  0xa436 => 'string|utf8',  0xa43c => 'string|utf8',
+        0x13b  => 'string|utf8',  0xa437 => 'string|utf8',  0xa43a => 'string|utf8',
+        0x8298 => 'string|utf8',  0xa438 => 'string|utf8',
     },
 );
 

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

@@ -420,15 +420,15 @@ sub ValidateImageData($$$;$)
 }
 
 #------------------------------------------------------------------------------
-# Add specified image data to ImageDataMD5 hash
+# Add specified image data to ImageDataHash hash
 # Inputs: 0) ExifTool ref, 1) dirInfo ref, 2) lookup for [tagInfo,value] based on tagID
-sub AddImageDataMD5($$$)
+sub AddImageDataHash($$$)
 {
     my ($et, $dirInfo, $offsetInfo) = @_;
     my ($tagID, $offset, $buff);
 
     my $verbose = $et->Options('Verbose');
-    my $md5 = $$et{ImageDataMD5};
+    my $hash = $$et{ImageDataHash};
     my $raf = $$dirInfo{RAF};
 
     foreach $tagID (sort keys %$offsetInfo) {
@@ -451,12 +451,12 @@ sub AddImageDataMD5($$$)
             my $size = shift @sizes;
             next unless $offset =~ /^\d+$/ and $size and $size =~ /^\d+$/ and $size;
             next unless $raf->Seek($offset, 0); # (offset is absolute)
-            $total += $et->ImageDataMD5($raf, $size);
+            $total += $et->ImageDataHash($raf, $size);
         }
         if ($verbose) {
             my $name = "$$dirInfo{DirName}:$$tagInfo{Name}";
             $name =~ s/Offsets?|Start$//;
-            $et->VPrint(0, "$$et{INDENT}(ImageDataMD5: $total bytes of $name data)\n");
+            $et->VPrint(0, "$$et{INDENT}(ImageDataHash: $total bytes of $name data)\n");
         }
     }
 }
@@ -780,7 +780,7 @@ Entry:  for (;;) {
                     $readFormat = $oldFormat = Get16u($dataPt, $entry+2);
                     $readCount = $oldCount = Get32u($dataPt, $entry+4);
                     undef $oldImageData;
-                    if ($oldFormat < 1 or $oldFormat > 13 and not ($oldFormat == 16 and $$et{Make} eq 'Apple' and $inMakerNotes)) {
+                    if (($oldFormat < 1 or $oldFormat > 13) and $oldFormat != 129 and not ($oldFormat == 16 and $$et{Make} eq 'Apple' and $inMakerNotes)) {
                         my $msg = "Bad format ($oldFormat) for $name entry $index";
                         # patch to preserve invalid directory entries in SubIFD3 of
                         # various Kodak Z-series cameras (Z812, Z1085IS, Z1275)
@@ -1277,7 +1277,9 @@ NoWrite:            next if $isNew > 0;
                                 $et->Warn("Writing large value for $name",1);
                             }
                             # re-code if necessary
-                            if ($strEnc and $newFormName eq 'string') {
+                            if ($newFormName eq 'utf8') {
+                                $newValue = $et->Encode($newValue, 'UTF8');
+                            } elsif ($strEnc and $newFormName eq 'string') {
                                 $newValue = $et->Encode($newValue, $strEnc);
                             }
                         } else {

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

@@ -973,16 +973,14 @@ sub WriteQuickTime($$$)
                 }
             } elsif ($tag eq 'CTBO' or $tag eq 'uuid') { # hack for updating CR3 CTBO offsets
                 push @{$$dirInfo{ChunkOffset}}, [ $tag, length($$outfile), length($hdr) + $size ];
-            } elsif (not $flg) {
-                my $grp = $$et{CUR_WRITE_GROUP} || $parent;
-                $et->Error("Can't locate data reference to update offsets for $grp");
-                return $rtnVal;
+            } elsif (not $flg or $flg == 1) {
+                # assume "1" if stsd is yet to be read
+                $flg or $$et{AssumedDataRef} = 1;
+                # must update offsets since the data is in this file
+                push @{$$dirInfo{ChunkOffset}}, [ $tag, length($$outfile) + length($hdr), $size ];
             } elsif ($flg == 3) {
                 $et->Error("Can't write files with mixed internal/external media data");
                 return $rtnVal;
-            } elsif ($flg == 1) {
-                # must update offsets since the data is in this file
-                push @{$$dirInfo{ChunkOffset}}, [ $tag, length($$outfile) + length($hdr), $size ];
             }
         }
 
@@ -1036,8 +1034,10 @@ sub WriteQuickTime($$$)
 
             if ($subdir) {  # process atoms in this container from a buffer in memory
 
-                undef $$et{HandlerType} if $tag eq 'trak';  # init handler type for this track
-
+                if ($tag eq 'trak') {
+                    undef $$et{HandlerType};  # init handler type for this track
+                    delete $$et{AssumedDataRef};
+                }
                 my $subName = $$subdir{DirName} || $$tagInfo{Name};
                 my $start = $$subdir{Start} || 0;
                 my $base = ($$dirInfo{Base} || 0) + $raf->Tell() - $size;
@@ -1103,6 +1103,11 @@ sub WriteQuickTime($$$)
                     $$et{CHANGED} = $oldChanged;
                     undef $newData;
                 }
+                if ($tag eq 'trak' and $$et{AssumedDataRef}) {
+                    my $grp = $$et{CUR_WRITE_GROUP} || $dirName;
+                    $et->Error("Can't locate data reference to update offsets for $grp");
+                    delete $$et{AssumedDataRef};
+                }
                 $$et{CUR_WRITE_GROUP} = $oldWriteGroup;
                 SetByteOrder('MM');
                 # add back header if necessary
@@ -1405,6 +1410,13 @@ sub WriteQuickTime($$$)
                 $flg = 1; # (this seems to be the case)
             }
             $$et{QtDataFlg} = $flg;
+            if ($$et{AssumedDataRef}) {
+                if ($flg != $$et{AssumedDataRef}) {
+                    my $grp = $$et{CUR_WRITE_GROUP} || $parent;
+                    $et->Error("Assumed incorrect data reference for $grp (was $flg)");
+                }
+                delete $$et{AssumedDataRef};
+            }
         }
         if ($tagInfo and $$tagInfo{WriteLast}) {
             $writeLast = ($writeLast || '') . $hdr . $buff;

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

@@ -176,7 +176,7 @@ sub CheckXMP($$$;$)
         require 'Image/ExifTool/XMPStruct.pl';
         my ($item, $err, $w, $warn);
         unless (ref $$valPtr) {
-            ($$valPtr, $warn) = InflateStruct($valPtr);
+            ($$valPtr, $warn) = InflateStruct($et, $valPtr);
             # expect a structure HASH ref or ARRAY of structures
             unless (ref $$valPtr) {
                 $$valPtr eq '' and $$valPtr = { }, return undef; # allow empty structures
@@ -189,7 +189,7 @@ sub CheckXMP($$$;$)
             $$valPtr = \@copy;          # return the copy
             foreach $item (@copy) {
                 unless (ref $item eq 'HASH') {
-                    ($item, $w) = InflateStruct(\$item); # deserialize structure
+                    ($item, $w) = InflateStruct($et, \$item); # deserialize structure
                     $w and $warn = $w;
                     next if ref $item eq 'HASH';
                     $err = 'Improperly formed structure';

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

@@ -139,7 +139,7 @@ my @delGroups = qw(
     Adobe AFCP APP0 APP1 APP2 APP3 APP4 APP5 APP6 APP7 APP8 APP9 APP10 APP11
     APP12 APP13 APP14 APP15 CanonVRD CIFF Ducky EXIF ExifIFD File FlashPix
     FotoStation GlobParamIFD GPS ICC_Profile IFD0 IFD1 Insta360 InteropIFD IPTC
-    ItemList JFIF Jpeg2000 Keys MakerNotes Meta MetaIFD Microsoft MIE MPF
+    ItemList JFIF Jpeg2000 JUMBF Keys MakerNotes Meta MetaIFD Microsoft MIE MPF
     NikonApp NikonCapture PDF PDF-update PhotoMechanic Photoshop PNG PNG-pHYs
     PrintIM QuickTime RMETA RSRC SubIFD Trailer UserData XML XML-* XMP XMP-*
 );
@@ -1028,7 +1028,7 @@ TAG: foreach $tagInfo (@matchingTags) {
                         foreach (@vals) {
                             if (ref $_ eq 'HASH') {
                                 require 'Image/ExifTool/XMPStruct.pl';
-                                $_ = Image::ExifTool::XMP::SerializeStruct($_);
+                                $_ = Image::ExifTool::XMP::SerializeStruct($self, $_);
                             }
                             print $out "$$self{INDENT2}$verb $wgrp1:$tag$fromList if value is '${_}'\n";
                         }
@@ -1293,6 +1293,7 @@ sub SetNewValuesFromFile($$;@)
         HexTagIDs       => $$options{HexTagIDs},
         IgnoreMinorErrors=>$$options{IgnoreMinorErrors},
         IgnoreTags      => $$options{IgnoreTags},
+        ImageHashType   => $$options{ImageHashType},
         Lang            => $$options{Lang},
         LargeFileSupport=> $$options{LargeFileSupport},
         List            => 1,
@@ -1313,11 +1314,13 @@ sub SetNewValuesFromFile($$;@)
         ScanForXMP      => $$options{ScanForXMP},
         StrictDate      => defined $$options{StrictDate} ? $$options{StrictDate} : 1,
         Struct          => $structOpt,
+        StructFormat    => $$options{StructFormat},
         SystemTags      => $$options{SystemTags},
         TimeZone        => $$options{TimeZone},
         Unknown         => $$options{Unknown},
         UserParam       => $$options{UserParam},
         Validate        => $$options{Validate},
+        WindowsWideFile => $$options{WindowsWideFile},
         XAttrTags       => $$options{XAttrTags},
         XMPAutoConv     => $$options{XMPAutoConv},
     );
@@ -1763,7 +1766,14 @@ GNV_TagInfo:    foreach $tagInfo (@tagInfoList) {
         }
     }
     # return our value(s)
-    return @$vals if wantarray;
+    if (wantarray) {
+        # remove duplicates if requested
+        if (@$vals > 1 and $self->Options('NoDups')) {
+            my %seen;
+            @$vals = grep { !$seen{$_}++ } @$vals;
+        }
+        return @$vals;
+    }
     return $$vals[0];
 }
 
@@ -2016,7 +2026,7 @@ sub SetFileName($$;$$$)
     # protect against empty file name
     length $newName or $self->Warn('New file name is empty'), return -1;
     # don't replace existing file
-    if ($self->Exists($newName) and (not defined $usedFlag or $usedFlag)) {
+    if ($self->Exists($newName, 1) and (not defined $usedFlag or $usedFlag)) {
         if ($file ne $newName or $opt =~ /Link$/) {
             # allow for case-insensitive filesystem
             if ($opt =~ /Link$/ or not $self->IsSameFile($file, $newName)) {
@@ -2395,7 +2405,7 @@ sub WriteInfo($$;$$)
         $outBuff = '';
         $outRef = \$outBuff;
         $outPos = 0;
-    } elsif ($self->Exists($outfile)) {
+    } elsif ($self->Exists($outfile, 1)) {
         $self->Error("File already exists: $outfile");
     } elsif ($self->Open(\*EXIFTOOL_OUTFILE, $outfile, '>')) {
         $outRef = \*EXIFTOOL_OUTFILE;
@@ -3283,7 +3293,7 @@ sub InsertTagValues($$$;$$$)
                 }
             } elsif (ref $val eq 'HASH') {
                 require 'Image/ExifTool/XMPStruct.pl';
-                $val = Image::ExifTool::XMP::SerializeStruct($val);
+                $val = Image::ExifTool::XMP::SerializeStruct($self, $val);
             } elsif (not defined $val) {
                 $val = $$self{OPTIONS}{MissingTagValue} if $asList;
             }
@@ -3767,6 +3777,8 @@ sub GetNewValueHash($$;$$$$)
         # this is a bit tricky:  we want to add to a protected nvHash only if we
         # are adding a conditional delete ($_[5] true or DelValue with no Shift)
         # or accumulating List items (NoReplace true)
+        # (NOTE: this should be looked into --> lists may be accumulated instead of being replaced
+        # as expected when copying to the same list from different dynamic -tagsFromFile source files)
         if ($protect and not ($opts{create} and ($$nvHash{NoReplace} or $_[5] or
             ($$nvHash{DelValue} and not defined $$nvHash{Shift}))))
         {
@@ -4908,6 +4920,11 @@ sub InverseDateTime($$;$$)
         my $fs = ($fmt =~ s/%f$// and $val =~ s/(\.\d+)\s*$//) ? $1 : '';
         my ($lib, $wrn, @a);
 TryLib: for ($lib=$strptimeLib; ; $lib='') {
+            # handle %s format ourself (not supported in Fedora, see forum15032)
+            if ($fmt eq '%s') {
+                $val = ConvertUnixTime($val, 1);
+                last;
+            }
             if (not $lib) {
                 last unless $$self{OPTIONS}{StrictDate};
                 warn $wrn || "Install POSIX::strptime or Time::Piece for inverse date/time conversions\n";
@@ -5598,6 +5615,8 @@ sub WriteJPEG($$)
                     $s =~ /^(Meta|META|Exif)\0\0/ and $dirName = 'Meta';
                 } elsif ($marker == 0xe5) {
                     $s =~ /^RMETA\0/        and $dirName = 'RMETA';
+                } elsif ($marker == 0xeb) {
+                    $s =~ /^JP/             and $dirName = 'JUMBF';
                 } elsif ($marker == 0xec) {
                     $s =~ /^Ducky/          and $dirName = 'Ducky';
                 } elsif ($marker == 0xed) {
@@ -6463,6 +6482,11 @@ sub WriteJPEG($$)
                     $segType = 'Ricoh RMETA';
                     $$delGroup{RMETA} and $del = 1;
                 }
+            } elsif ($marker == 0xeb) {         # APP10 (JUMBF)
+                if ($$segDataPt =~ /^JP/) {
+                    $segType = 'JUMBF';
+                    $$delGroup{JUMBF} and $del = 1;
+                }
             } elsif ($marker == 0xec) {         # APP12 (Ducky)
                 if ($$segDataPt =~ /^Ducky/) {
                     $segType = 'Ducky';
@@ -6880,14 +6904,14 @@ sub SetFileTime($$;$$$$)
 }
 
 #------------------------------------------------------------------------------
-# Add data to MD5 checksum
+# Add data to hash checksum
 # Inputs: 0) ExifTool ref, 1) RAF ref, 2) data size (or undef to read to end of file),
 #         3) data name (or undef for no warnings or messages), 4) flag for no verbose message
-# Returns: number of bytes read and MD5'd
-sub ImageDataMD5($$$;$$)
+# Returns: number of bytes read and hashed
+sub ImageDataHash($$$;$$)
 {
     my ($self, $raf, $size, $type, $noMsg) = @_;
-    my $md5 = $$self{ImageDataMD5} or return;
+    my $hash = $$self{ImageDataHash} or return;
     my ($bytesRead, $n) = (0, 65536);
     my $buff;
     for (;;) {
@@ -6900,11 +6924,11 @@ sub ImageDataMD5($$$;$$)
             $self->Warn("Error reading $type data") if $type and defined $size;
             last;
         }
-        $md5->add($buff);
+        $hash->add($buff);
         $bytesRead += length $buff;
     }
     if ($$self{OPTIONS}{Verbose} and $bytesRead and $type and not $noMsg) {
-        $self->VPrint(0, "$$self{INDENT}(ImageDataMD5: $bytesRead bytes of $type data)\n");
+        $self->VPrint(0, "$$self{INDENT}(ImageDataHash: $bytesRead bytes of $type data)\n");
     }
     return $bytesRead;
 }

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

@@ -50,7 +50,7 @@ use Image::ExifTool::Exif;
 use Image::ExifTool::GPS;
 require Exporter;
 
-$VERSION = '3.59';
+$VERSION = '3.60';
 @ISA = qw(Exporter);
 @EXPORT_OK = qw(EscapeXML UnescapeXML);
 
@@ -144,6 +144,7 @@ my %xmpNS = (
     xmpTPg    => 'http://ns.adobe.com/xap/1.0/t/pg/',
     xmpidq    => 'http://ns.adobe.com/xmp/Identifier/qual/1.0/',
     xmpPLUS   => 'http://ns.adobe.com/xap/1.0/PLUS/',
+    panorama  => 'http://ns.adobe.com/photoshop/1.0/panorama-profile',
     dex       => 'http://ns.optimasc.com/dex/1.0/',
     mediapro  => 'http://ns.iview-multimedia.com/mediapro/1.0/',
     expressionmedia => 'http://ns.microsoft.com/expressionmedia/1.0/',
@@ -199,6 +200,7 @@ my %xmpNS = (
     ast       => 'http://ns.nikon.com/asteroid/1.0/',
     nine      => 'http://ns.nikon.com/nine/1.0/',
     hdr_metadata => 'http://ns.adobe.com/hdr-metadata/1.0/',
+    hdrgm     => 'http://ns.adobe.com/hdr-gain-map/1.0/',
 );
 
 # build reverse namespace lookup
@@ -709,6 +711,10 @@ my %sRangeMask = (
         Name => 'xmpPLUS',
         SubDirectory => { TagTable => 'Image::ExifTool::XMP::xmpPLUS' },
     },
+    panorama => {
+        Name => 'panorama',
+        SubDirectory => { TagTable => 'Image::ExifTool::XMP::panorama' },
+    },
     plus => {
         Name => 'plus',
         SubDirectory => { TagTable => 'Image::ExifTool::PLUS::XMP' },
@@ -909,6 +915,10 @@ my %sRangeMask = (
         Name => 'hdr',
         SubDirectory => { TagTable => 'Image::ExifTool::XMP::hdr' },
     },
+    hdrgm => {
+        Name => 'hdrgm',
+        SubDirectory => { TagTable => 'Image::ExifTool::XMP::hdrgm' },
+    },
 );
 
 # hack to allow XML containing Dublin Core metadata to be handled like XMP (eg. EPUB - see ZIP.pm)
@@ -2566,7 +2576,9 @@ my %sPantryItem = (
     %xmpTableDefaults,
     GROUPS => { 1 => 'XMP-et', 2 => 'Image' },
     NAMESPACE   => 'et',
-    OriginalImageMD5 => { Notes => 'used to store ExifTool ImageDataMD5 digest' },
+    OriginalImageHash     => { Notes => 'used to store ExifTool ImageDataHash digest' },
+    OriginalImageHashType => { Notes => "ImageHashType API setting, default 'MD5'" },
+    OriginalImageMD5      => { Notes => 'deprecated' },
 );
 
 # table to add tags in other namespaces

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

@@ -1063,7 +1063,7 @@ my %prismPublicationDate = (
     NOTES => q{
         PRISM Rights Language 2.1 namespace tags.  These tags have been deprecated
         since the release of the PRISM Usage Rights 3.0. (see
-        L<http://www.prismstandard.org/>)
+        L<https://www.w3.org/submissions/2020/SUBM-prism-20200910/prism-image.html>)
     },
     geography       => { List => 'Bag' },
     industry        => { List => 'Bag' },
@@ -1388,6 +1388,17 @@ my %sSubVersion = (
     ReuseAllowed    => { Writable => 'boolean' },
 );
 
+%Image::ExifTool::XMP::panorama = (
+    %xmpTableDefaults,
+    GROUPS => { 1 => 'XMP-panorama', 2 => 'Image' },
+    NAMESPACE => 'panorama',
+    NOTES => 'Adobe Photoshop Panorama-profile tags.',
+    Transformation      => { },
+    VirtualFocalLength  => { Writable => 'real' },
+    VirtualImageXCenter => { Writable => 'real' },
+    VirtualImageYCenter => { Writable => 'real' },
+);
+
 # Creative Commons namespace properties (cc) (ref 5)
 %Image::ExifTool::XMP::cc = (
     %xmpTableDefaults,
@@ -2094,6 +2105,27 @@ my %sSubVersion = (
     scene_referred          => { Name => 'SceneReferred', Writable => 'boolean' },
 );
 
+# HDR Gain Map metadata namespace
+%Image::ExifTool::XMP::hdrgm = (
+    %xmpTableDefaults,
+    GROUPS => { 1 => 'XMP-hdrgm', 2 => 'Image' },
+    NAMESPACE   => 'hdrgm',
+    TABLE_DESC => 'XMP HDR Gain Map Metadata',
+    NOTES => 'Tags used in Adobe gain map images.',
+    Version             => { Avoid => 1 },
+    BaseRenditionIsHDR  => { Writable => 'boolean' },
+    # this is a pain in the ass: List items below may or may not be lists
+    # according to the Adobe specification -- I don't know how to handle tags
+    # with a variable format like this, so just make them lists here for now
+    OffsetSDR           => { Writable => 'real', List => 'Seq' },
+    OffsetHDR           => { Writable => 'real', List => 'Seq' },
+    HDRCapacityMin      => { Writable => 'real' },
+    HDRCapacityMax      => { Writable => 'real' },
+    GainMapMin          => { Writable => 'real', List => 'Seq' },
+    GainMapMax          => { Writable => 'real', List => 'Seq' },
+    Gamma               => { Writable => 'real', List => 'Seq', Avoid => 1 },
+);
+
 # SVG namespace properties (ref 9)
 %Image::ExifTool::XMP::SVG = (
     GROUPS => { 0 => 'SVG', 1 => 'SVG', 2 => 'Image' },

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

@@ -14,42 +14,55 @@ use vars qw(%specialStruct %stdXlatNS);
 use Image::ExifTool qw(:Utils);
 use Image::ExifTool::XMP;
 
-sub SerializeStruct($;$);
-sub InflateStruct($;$);
+sub SerializeStruct($$;$);
+sub InflateStruct($$;$);
 sub DumpStruct($;$);
 sub CheckStruct($$$);
 sub AddNewStruct($$$$$$);
 sub ConvertStruct($$$$;$);
+sub EscapeJSON($;$);
+
+# lookups for JSON characters that we escape specially
+my %jsonChar = ( '"'=>'"', '\\'=>'\\', "\b"=>'b', "\f"=>'f', "\n"=>'n', "\r"=>'r', "\t"=>'t' );
+my %jsonEsc  = ( '"'=>'"', '\\'=>'\\', 'b'=>"\b", 'f'=>"\f", 'n'=>"\n", 'r'=>"\r", 't'=>"\t" );
 
 #------------------------------------------------------------------------------
 # Serialize a structure (or other object) into a simple string
-# Inputs: 0) HASH ref, ARRAY ref, or SCALAR, 1) closing bracket (or undef)
-# Returns: serialized structure string
+# Inputs: 0) ExifTool ref, 1) HASH ref, ARRAY ref, or SCALAR, 2) closing bracket (or undef)
+# Returns: serialized structure string (in format specified by StructFormat option)
 # eg) "{field=text with {braces|}|, and a comma, field2=val2,field3={field4=[a,b]}}"
-sub SerializeStruct($;$)
+sub SerializeStruct($$;$)
 {
-    my ($obj, $ket) = @_;
+    my ($et, $obj, $ket) = @_;
     my ($key, $val, @vals, $rtnVal);
+    my $sfmt = $et->Options('StructFormat');
 
     if (ref $obj eq 'HASH') {
         # 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}, '}');
+            my $hdr = $sfmt ? EscapeJSON($key) . ':' : $key . '=';
+            push @vals, $hdr . SerializeStruct($et, $$obj{$key}, '}');
         }
         $rtnVal = '{' . join(',', @vals) . '}';
     } elsif (ref $obj eq 'ARRAY') {
         foreach $val (@$obj) {
-            push @vals, SerializeStruct($val, ']');
+            push @vals, SerializeStruct($et, $val, ']');
         }
         $rtnVal = '[' . join(',', @vals) . ']';
     } elsif (defined $obj) {
         $obj = $$obj if ref $obj eq 'SCALAR';
         # escape necessary characters in string (closing bracket plus "," and "|")
-        my $pat = $ket ? "\\$ket|,|\\|" : ',|\\|';
-        ($rtnVal = $obj) =~  s/($pat)/|$1/g;
-        # also must escape opening bracket or whitespace at start of string
-        $rtnVal =~ s/^([\s\[\{])/|$1/;
+        if ($sfmt) {
+            $rtnVal = EscapeJSON($obj, $sfmt eq 'JSONQ');
+        } else {
+            my $pat = $ket ? "\\$ket|,|\\|" : ',|\\|';
+            ($rtnVal = $obj) =~  s/($pat)/|$1/g;
+            # also must escape opening bracket or whitespace at start of string
+            $rtnVal =~ s/^([\s\[\{])/|$1/;
+        }
+    } elsif ($sfmt) {
+        $rtnVal = 'null';
     } else {
         $rtnVal = '';   # allow undefined list items
     }
@@ -58,21 +71,25 @@ sub SerializeStruct($;$)
 
 #------------------------------------------------------------------------------
 # Inflate structure (or other object) from a serialized string
-# Inputs: 0) reference to object in string form (serialized using the '|' escape)
-#         1) extra delimiter for scalar values delimiters
+# Inputs: 0) ExifTool ref, 1) reference to object in string form
+#           (serialized using the '|' escape, or JSON)
+#         2) extra delimiter for scalar values delimiters
 # Returns: 0) object as a SCALAR, HASH ref, or ARRAY ref (or undef on error),
 #          1) warning string (or undef)
 # Notes: modifies input string to remove parsed objects
-sub InflateStruct($;$)
+sub InflateStruct($$;$)
 {
-    my ($obj, $delim) = @_;
+    my ($et, $obj, $delim) = @_;
     my ($val, $warn, $part);
+    my $sfmt = $et->Options('StructFormat');
 
     if ($$obj =~ s/^\s*\{//) {
         my %struct;
-        while ($$obj =~ s/^\s*([-\w:]+#?)\s*=//s) {
+        for (;;) {
+            last unless $sfmt ? $$obj =~ s/^\s*"(.*?)"\s*://s :
+                                $$obj =~ s/^\s*([-\w:]+#?)\s*=//s;
             my $tag = $1;
-            my ($v, $w) = InflateStruct($obj, '}');
+            my ($v, $w) = InflateStruct($et, $obj, '}');
             $warn = $w if $w and not $warn;
             return(undef, $warn) unless defined $v;
             $struct{$tag} = $v;
@@ -94,7 +111,7 @@ sub InflateStruct($;$)
     } elsif ($$obj =~ s/^\s*\[//) {
         my @list;
         for (;;) {
-            my ($v, $w) = InflateStruct($obj, ']');
+            my ($v, $w) = InflateStruct($et, $obj, ']');
             $warn = $w if $w and not $warn;
             return(undef, $warn) unless defined $v;
             push @list, $v;
@@ -105,20 +122,71 @@ sub InflateStruct($;$)
         $val = \@list;
     } else {
         $$obj =~ s/^\s+//s; # remove leading whitespace
-        # read scalar up to specified delimiter (or "," if not defined)
-        $val = '';
-        $delim = $delim ? "\\$delim|,|\\||\$" : ',|\\||$';
-        for (;;) {
-            $$obj =~ s/^(.*?)($delim)//s or last;
-            $val .= $1;
-            last unless $2;
-            $2 eq '|' or $$obj = $2 . $$obj, last;
-            $$obj =~ s/^(.)//s and $val .= $1;  # add escaped character
+        if ($sfmt) {
+            if ($$obj =~ s/^"//) {
+                $val = '';
+                while ($$obj =~ s/(.*?)"//) {
+                    $val .= $1;
+                    last unless $val =~ /([\\]+)$/ and length($1) & 0x01;
+                    substr($val, -1, 1) = '"';  # (was an escaped quote)
+                }
+                if ($val =~ s/^base64://) {
+                    $val = DecodeBase64($val);
+                } else {
+                    # un-escape characters in JSON string
+                    $val =~ s/\\(.)/$jsonEsc{$1}||'\\'.$1/egs;
+                }
+            } elsif ($$obj =~ s/^(true|false)\b//) {
+                $val = '"' . ucfirst($1) . '"';
+            } elsif ($$obj =~ s/^([+-]?(?=\d|\.\d)\d*(\.\d*)?([Ee]([+-]?\d+))?)//) {
+                $val = $1;
+            } else {
+                $warn or $warn = 'Unknown JSON object';
+                $val = '""';
+            }
+        } else {
+            # read scalar up to specified delimiter (or "," if not defined)
+            $delim = $delim ? "\\$delim|,|\\||\$" : ',|\\||$';
+            $val = '';
+            for (;;) {
+                $$obj =~ s/^(.*?)($delim)//s or last;
+                $val .= $1;
+                last unless $2;
+                $2 eq '|' or $$obj = $2 . $$obj, last;
+                $$obj =~ s/^(.)//s and $val .= $1;  # add escaped character
+            }
         }
     }
     return($val, $warn);
 }
 
+#------------------------------------------------------------------------------
+# Escape string for JSON
+# Inputs: 0) string, 1) flag to force numbers to be quoted too
+# Returns: Escaped string (quoted if necessary)
+sub EscapeJSON($;$)
+{
+    my ($str, $quote) = @_;
+    unless ($quote) {
+        return 'null' unless defined $str;
+        # JSON boolean (true or false)
+        return lc($str) if $str =~ /^(true|false)$/i;
+        # JSON number (see json.org for numerical format)
+        # return $str if $str =~ /^-?(\d|[1-9]\d+)(\.\d+)?(e[-+]?\d+)?$/i;
+        # (these big numbers caused problems for some JSON parsers, so be more conservative)
+        return $str if $str =~ /^-?(\d|[1-9]\d{1,14})(\.\d{1,16})?(e[-+]?\d{1,3})?$/i;
+    }
+    return '""' unless defined $str;
+    # encode JSON string in base64 if necessary
+    return '"base64:' . EncodeBase64($str, 1) . '"' if Image::ExifTool::IsUTF8(\$str) < 0;
+    # escape special characters
+    $str =~ s/(["\t\n\r\\])/\\$jsonChar{$1}/sg;
+    $str =~ tr/\0//d;   # remove all nulls
+    # escape other control characters with \u
+    $str =~ s/([\0-\x1f])/sprintf("\\u%.4X",ord $1)/sge;
+    return '"' . $str . '"';    # return the quoted string
+}
+
 #------------------------------------------------------------------------------
 # Get XMP language code from tag name string
 # Inputs: 0) tag name string