exiftool_vendored 12.22.0 → 12.25.0

data/bin/lib/Image/ExifTool.pod

@@ -65,47 +65,47 @@ supported by ExifTool (r = read, w = write, c = create):
 
   File Types
   ------------+-------------+-------------+-------------+------------
-  360   r/w   | DPX   r     | ITC   r     | ODP   r     | RIFF  r
-  3FR   r     | DR4   r/w/c | J2C   r     | ODS   r     | RSRC  r
-  3G2   r/w   | DSS   r     | JNG   r/w   | ODT   r     | RTF   r
-  3GP   r/w   | DV    r     | JP2   r/w   | OFR   r     | RW2   r/w
-  A     r     | DVB   r/w   | JPEG  r/w   | OGG   r     | RWL   r/w
-  AA    r     | DVR-MS r    | JSON  r     | OGV   r     | RWZ   r
-  AAE   r     | DYLIB r     | K25   r     | ONP   r     | RM    r
-  AAX   r/w   | EIP   r     | KDC   r     | OPUS  r     | SEQ   r
-  ACR   r     | EPS   r/w   | KEY   r     | ORF   r/w   | SKETCH r
-  AFM   r     | EPUB  r     | LA    r     | OTF   r     | SO    r
-  AI    r/w   | ERF   r/w   | LFP   r     | PAC   r     | SR2   r/w
-  AIFF  r     | EXE   r     | LNK   r     | PAGES r     | SRF   r
-  APE   r     | EXIF  r/w/c | LRV   r/w   | PBM   r/w   | SRW   r/w
-  ARQ   r/w   | EXR   r     | M2TS  r     | PCD   r     | SVG   r
-  ARW   r/w   | EXV   r/w/c | M4A/V r/w   | PCX   r     | SWF   r
-  ASF   r     | F4A/V r/w   | MACOS r     | PDB   r     | THM   r/w
-  AVI   r     | FFF   r/w   | MAX   r     | PDF   r/w   | TIFF  r/w
-  AVIF  r/w   | FITS  r     | MEF   r/w   | PEF   r/w   | TORRENT r
-  AZW   r     | FLA   r     | MIE   r/w/c | PFA   r     | TTC   r
-  BMP   r     | FLAC  r     | MIFF  r     | PFB   r     | TTF   r
-  BPG   r     | FLIF  r/w   | MKA   r     | PFM   r     | TXT   r
-  BTF   r     | FLV   r     | MKS   r     | PGF   r     | VCF   r
-  CHM   r     | FPF   r     | MKV   r     | PGM   r/w   | VRD   r/w/c
-  COS   r     | FPX   r     | MNG   r/w   | PLIST r     | VSD   r
-  CR2   r/w   | GIF   r/w   | MOBI  r     | PICT  r     | WAV   r
-  CR3   r/w   | GPR   r/w   | MODD  r     | PMP   r     | WDP   r/w
-  CRM   r/w   | GZ    r     | MOI   r     | PNG   r/w   | WEBP  r
-  CRW   r/w   | HDP   r/w   | MOS   r/w   | PPM   r/w   | WEBM  r
-  CS1   r/w   | HDR   r     | MOV   r/w   | PPT   r     | WMA   r
-  CSV   r     | HEIC  r/w   | MP3   r     | PPTX  r     | WMV   r
-  CZI   r     | HEIF  r/w   | MP4   r/w   | PS    r/w   | WTV   r
-  DCM   r     | HTML  r     | MPC   r     | PSB   r/w   | WV    r
-  DCP   r/w   | ICC   r/w/c | MPG   r     | PSD   r/w   | X3F   r/w
-  DCR   r     | ICS   r     | MPO   r/w   | PSP   r     | XCF   r
-  DFONT r     | IDML  r     | MQV   r/w   | QTIF  r/w   | XLS   r
-  DIVX  r     | IIQ   r/w   | MRW   r/w   | R3D   r     | XLSX  r
-  DJVU  r     | IND   r/w   | MXF   r     | RA    r     | XMP   r/w/c
-  DLL   r     | INSP  r/w   | NEF   r/w   | RAF   r/w   | ZIP   r
-  DNG   r/w   | INSV  r     | NRW   r/w   | RAM   r     |
-  DOC   r     | INX   r     | NUMBERS r   | RAR   r     |
-  DOCX  r     | ISO   r     | O     r     | RAW   r/w   |
+  360   r/w   | DPX   r     | ITC   r     | NUMBERS r   | RAM   r
+  3FR   r     | DR4   r/w/c | J2C   r     | O     r     | RAR   r
+  3G2   r/w   | DSS   r     | JNG   r/w   | ODP   r     | RAW   r/w
+  3GP   r/w   | DV    r     | JP2   r/w   | ODS   r     | RIFF  r
+  A     r     | DVB   r/w   | JPEG  r/w   | ODT   r     | RSRC  r
+  AA    r     | DVR-MS r    | JSON  r     | OFR   r     | RTF   r
+  AAE   r     | DYLIB r     | JXL   r     | OGG   r     | RW2   r/w
+  AAX   r/w   | EIP   r     | K25   r     | OGV   r     | RWL   r/w
+  ACR   r     | EPS   r/w   | KDC   r     | ONP   r     | RWZ   r
+  AFM   r     | EPUB  r     | KEY   r     | OPUS  r     | RM    r
+  AI    r/w   | ERF   r/w   | LA    r     | ORF   r/w   | SEQ   r
+  AIFF  r     | EXE   r     | LFP   r     | ORI   r/w   | SKETCH r
+  APE   r     | EXIF  r/w/c | LNK   r     | OTF   r     | SO    r
+  ARQ   r/w   | EXR   r     | LRV   r/w   | PAC   r     | SR2   r/w
+  ARW   r/w   | EXV   r/w/c | M2TS  r     | PAGES r     | SRF   r
+  ASF   r     | F4A/V r/w   | M4A/V r/w   | PBM   r/w   | SRW   r/w
+  AVI   r     | FFF   r/w   | MACOS r     | PCD   r     | SVG   r
+  AVIF  r/w   | FITS  r     | MAX   r     | PCX   r     | SWF   r
+  AZW   r     | FLA   r     | MEF   r/w   | PDB   r     | THM   r/w
+  BMP   r     | FLAC  r     | MIE   r/w/c | PDF   r/w   | TIFF  r/w
+  BPG   r     | FLIF  r/w   | MIFF  r     | PEF   r/w   | TORRENT r
+  BTF   r     | FLV   r     | MKA   r     | PFA   r     | TTC   r
+  CHM   r     | FPF   r     | MKS   r     | PFB   r     | TTF   r
+  COS   r     | FPX   r     | MKV   r     | PFM   r     | TXT   r
+  CR2   r/w   | GIF   r/w   | MNG   r/w   | PGF   r     | VCF   r
+  CR3   r/w   | GPR   r/w   | MOBI  r     | PGM   r/w   | VRD   r/w/c
+  CRM   r/w   | GZ    r     | MODD  r     | PLIST r     | VSD   r
+  CRW   r/w   | HDP   r/w   | MOI   r     | PICT  r     | WAV   r
+  CS1   r/w   | HDR   r     | MOS   r/w   | PMP   r     | WDP   r/w
+  CSV   r     | HEIC  r/w   | MOV   r/w   | PNG   r/w   | WEBP  r
+  CZI   r     | HEIF  r/w   | MP3   r     | PPM   r/w   | WEBM  r
+  DCM   r     | HTML  r     | MP4   r/w   | PPT   r     | WMA   r
+  DCP   r/w   | ICC   r/w/c | MPC   r     | PPTX  r     | WMV   r
+  DCR   r     | ICS   r     | MPG   r     | PS    r/w   | WTV   r
+  DFONT r     | IDML  r     | MPO   r/w   | PSB   r/w   | WV    r
+  DIVX  r     | IIQ   r/w   | MQV   r/w   | PSD   r/w   | X3F   r/w
+  DJVU  r     | IND   r/w   | MRC   r     | PSP   r     | XCF   r
+  DLL   r     | INSP  r/w   | MRW   r/w   | QTIF  r/w   | XLS   r
+  DNG   r/w   | INSV  r     | MXF   r     | R3D   r     | XLSX  r
+  DOC   r     | INX   r     | NEF   r/w   | RA    r     | XMP   r/w/c
+  DOCX  r     | ISO   r     | NRW   r/w   | RAF   r/w   | ZIP   r
 
   Meta Information
   ----------------------+----------------------+---------------------
@@ -176,6 +176,9 @@ Creates a new ExifTool object.
 
     $exifTool = new Image::ExifTool;
 
+One ExifTool object may be used to process many files, so creating multiple
+ExifTool objects usually is not necessary.
+
 Note that ExifTool uses AUTOLOAD to load non-member methods, so any class
 using Image::ExifTool as a base class must define an AUTOLOAD which calls
 Image::ExifTool::DoAutoLoad().  eg)
@@ -386,7 +389,8 @@ to some functions.  Option names are not case sensitive.
 
 The default option values may be changed by defining a
 %Image::ExifTool::UserDefined::Options hash.  See the ExifTool_config file
-in the full ExifTool distribution for examples.
+in the full ExifTool distribution for examples.  A default of undef has the
+same behaviour as a value of 0 for numerical options.
 
     # exclude the 'OwnerName' tag from returned information
     $exifTool->Options(Exclude => 'OwnerName');
@@ -438,6 +442,13 @@ large binary data blocks (eg. ThumbnailImage) are not necessarily extracted
 unless this option is set or the tag is specifically requested by name.
 Default is undef.
 
+=item BlockExtract
+
+Flag to extract some directories (mentioned in the
+L<ExifTool tag name documentation|Image::ExifTool::TagNames>) as a block. 
+Setting this to a value of 2 also prevents parsing the block to extract tags
+contained within.
+
 =item ByteOrder
 
 The byte order for newly created EXIF segments when writing.  Note that if
@@ -2277,12 +2288,12 @@ AFCP, AIFF, APE, APP0, APP1, APP11, APP12, APP13, APP14, APP15, APP4, APP5,
 APP6, APP8, ASF, Audible, CanonVRD, Composite, DICOM, DNG, DV, DjVu, Ducky,
 EXE, EXIF, ExifTool, FITS, FLAC, FLIR, File, Flash, FlashPix, Font,
 FotoStation, GIF, GIMP, GeoTiff, GoPro, H264, HTML, ICC_Profile, ID3, IPTC,
-ISO, ITC, JFIF, JPEG, JSON, Jpeg2000, LNK, Leaf, Lytro, M2TS, MIE, MIFF,
-MNG, MOI, MPC, MPEG, MPF, MXF, MakerNotes, Matroska, Meta, Ogg, OpenEXR,
-Opus, PDF, PICT, PLIST, PNG, PSP, Palm, Parrot, PanasonicRaw, PhotoCD,
-PhotoMechanic, Photoshop, PostScript, PrintIM, QuickTime, RAF, RIFF, RSRC,
-RTF, Radiance, Rawzor, Real, Red, SVG, SigmaRaw, Stim, Theora, Torrent,
-Trailer, UserParam, VCard, Vorbis, WTV, XML, XMP, ZIP
+ISO, ITC, JFIF, JPEG, JSON, JUMBF, Jpeg2000, LNK, Leaf, Lytro, M2TS, MIE,
+MIFF, MNG, MOI, MPC, MPEG, MPF, MXF, MakerNotes, Matroska, Meta, Ogg,
+OpenEXR, Opus, PDF, PICT, PLIST, PNG, PSP, Palm, Parrot, PanasonicRaw,
+PhotoCD, PhotoMechanic, Photoshop, PostScript, PrintIM, QuickTime, RAF,
+RIFF, RSRC, RTF, Radiance, Rawzor, Real, Red, SVG, SigmaRaw, Stim, Theora,
+Torrent, Trailer, UserParam, VCard, Vorbis, WTV, XML, XMP, ZIP
 
 =item Family 1 (Specific Location):
 
@@ -2295,8 +2306,8 @@ GoPro, GraphConv, H264, HP, HTC, HTML, HTML-dc, HTML-ncc, HTML-office,
 HTML-prod, HTML-vw96, HTTP-equiv, ICC-chrm, ICC-clrt, ICC-header, ICC-meas,
 ICC-meta, ICC-view, ICC_Profile, ICC_Profile#, ID3, ID3v1, ID3v1_Enh,
 ID3v2_2, ID3v2_3, ID3v2_4, IFD0, IFD1, IPTC, IPTC#, ISO, ITC, Insta360,
-InteropIFD, ItemList, JFIF, JFXX, JPEG, JPEG-HDR, JSON, JVC, Jpeg2000,
-KDC_IFD, Keys, Kodak, KodakBordersIFD, KodakEffectsIFD, KodakIFD,
+InteropIFD, ItemList, JFIF, JFXX, JPEG, JPEG-HDR, JSON, JUMBF, JVC,
+Jpeg2000, KDC_IFD, Keys, Kodak, KodakBordersIFD, KodakEffectsIFD, KodakIFD,
 KyoceraRaw, LNK, Leaf, LeafSubIFD, Leica, Lyrics3, Lytro, M2TS, MAC,
 MIE-Audio, MIE-Camera, MIE-Canon, MIE-Doc, MIE-Extender, MIE-Flash, MIE-GPS,
 MIE-Geo, MIE-Image, MIE-Lens, MIE-Main, MIE-MakerNotes, MIE-Meta,

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

@@ -639,7 +639,7 @@ overlapping EXIF, IPTC and XMP tags to be reconciled when reading, and
 synchronized when writing.  The MWG Composite tags below are designed to aid
 in the implementation of these recommendations.  As well, the MWG defines
 new XMP tags which are listed in the subsequent tables below.  See
-L<https://web.archive.org/web/20181006115950/http://www.metadataworkinggroup.org/specs/>
+L<https://web.archive.org/web/20180919181934/http://www.metadataworkinggroup.org/pdf/mwg_guidance.pdf>
 for the official MWG specification.
 },
     MacOS => q{

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

@@ -88,7 +88,7 @@ sub ProcessCTMD($$$);
 sub ProcessExifInfo($$$);
 sub SwapWords($);
 
-$VERSION = '4.46';
+$VERSION = '4.47';
 
 # Note: Removed 'USM' from 'L' lenses since it is redundant - PH
 # (or is it?  Ref 32 shows 5 non-USM L-type lenses)
@@ -473,7 +473,8 @@ $VERSION = '4.46';
     253 => 'Canon EF 70-200mm f/2.8L IS II USM + 2x', #PH (NC)
     253.1 => 'Canon EF 70-200mm f/2.8L IS III USM + 2x', #PH (NC)
     # 253.2 => 'Tamron SP 70-200mm f/2.8 Di VC USD G2 (A025) + 2x', #forum9367
-    254 => 'Canon EF 100mm f/2.8L Macro IS USM', #42
+    254 => 'Canon EF 100mm f/2.8L Macro IS USM or Tamron Lens', #42
+    254.1 => 'Tamron SP 90mm f/2.8 Di VC USD 1:1 Macro (F017)', #PH
     255 => 'Sigma 24-105mm f/4 DG OS HSM | A or Other Lens', #50
     255.1 => 'Sigma 180mm f/2.8 EX DG OS HSM APO Macro', #50
     255.2 => 'Tamron SP 70-200mm f/2.8 Di VC USD', #exiv issue 1202 (A009)

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

@@ -18,7 +18,7 @@ use strict;
 use vars qw($VERSION);
 use Image::ExifTool qw(:DataAccess :Utils);
 
-$VERSION = '1.06';
+$VERSION = '1.07';
 
 sub ParseAnt($);
 sub ProcessAnt($$$);
@@ -227,10 +227,11 @@ Tok: for (;;) {
                 last unless $tok =~ /(\\+)$/ and length($1) & 0x01;
                 $tok .= '"';    # quote is part of the string
             }
-            # must protect unescaped "$" and "@" symbols, and "\" at end of string
-            $tok =~ s{\\(.)|([\$\@]|\\$)}{'\\'.($2 || $1)}sge;
-            # convert C escape sequences (allowed in quoted text)
-            $tok = eval qq{"$tok"};
+            # convert C escape sequences, allowed in quoted text
+            # (note: this only converts a few of them!)
+            my %esc = ( a => "\a", b => "\b", f => "\f", n => "\n",
+                        r => "\r", t => "\t", '"' => '"', '\\' => '\\' );
+            $tok =~ s/\\(.)/$esc{$1}||'\\'.$1/egs;
         } else {                # key name
             pos($$dataPt) = pos($$dataPt) - 1;
             # allow anything in key but whitespace, braces and double quotes

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

@@ -56,7 +56,7 @@ use vars qw($VERSION $AUTOLOAD @formatSize @formatName %formatNumber %intFormat
 use Image::ExifTool qw(:DataAccess :Utils);
 use Image::ExifTool::MakerNotes;
 
-$VERSION = '4.33';
+$VERSION = '4.34';
 
 sub ProcessExif($$$);
 sub WriteExif($$$);
@@ -321,6 +321,7 @@ my %utf8StringConv = (
 my %longBin = (
     ValueConv => 'length($val) > 64 ? \$val : $val',
     ValueConvInv => '$val',
+    LongBinary => 1,        # flag to avoid decoding values of a large array
 );
 
 # PrintConv for SampleFormat (0x153)
@@ -3618,11 +3619,11 @@ my %opcodeInfo = (
     },
     0xc6fc => {
         Name => 'ProfileToneCurve',
+        %longBin,
         Writable => 'float',
         WriteGroup => 'IFD0',
         Count => -1,
         Protected => 1,
-        Binary => 1,
     },
     0xc6fd => {
         Name => 'ProfileEmbedPolicy',
@@ -3747,11 +3748,11 @@ my %opcodeInfo = (
     },
     0xc726 => {
         Name => 'ProfileLookTableData',
+        %longBin,
         Writable => 'float',
         WriteGroup => 'IFD0',
         Count => -1,
         Protected => 1,
-        Binary => 1,
     },
     0xc740 => { Name => 'OpcodeList1', %opcodeInfo }, # DNG 1.3
     0xc741 => { Name => 'OpcodeList2', %opcodeInfo }, # DNG 1.3
@@ -6172,15 +6173,23 @@ sub ProcessExif($$$)
             # (avoids long delays when processing some corrupted files)
             if ($count > 100000 and $formatStr !~ /^(undef|string|binary)$/) {
                 my $tagName = $tagInfo ? $$tagInfo{Name} : sprintf('tag 0x%.4x', $tagID);
+                # (count of 196608 is typical for ColorMap)
                 if ($tagName ne 'TransferFunction' or $count != 196608) {
                     my $minor = $count > 2000000 ? 0 : 2;
                     next if $et->Warn("Ignoring $dirName $tagName with excessive count", $minor);
                 }
             }
-            # convert according to specified format
-            $val = ReadValue($valueDataPt,$valuePtr,$formatStr,$count,$readSize,\$rational);
-            # re-code if necessary
-            $val = $et->Decode($val, $strEnc) if $strEnc and $formatStr eq 'string' and defined $val;
+            if ($count > 500 and $formatStr !~ /^(undef|string|binary)$/ and
+                (not $tagInfo or $$tagInfo{LongBinary}) and not $$et{OPTIONS}{IgnoreMinorErrors})
+            {
+                $et->WarnOnce('Not decoding some large array(s). Ignore minor errors to decode', 2);
+                $val = "(large array of $count $formatStr values)";
+            } else {
+                # convert according to specified format
+                $val = ReadValue($valueDataPt,$valuePtr,$formatStr,$count,$readSize,\$rational);
+                # re-code if necessary
+                $val = $et->Decode($val, $strEnc) if $strEnc and $formatStr eq 'string' and defined $val;
+            }
         }
 
         if ($verbose) {

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

@@ -31,7 +31,7 @@ use vars qw($VERSION);
 use Image::ExifTool qw(:DataAccess :Utils);
 use Image::ExifTool::Exif;
 
-$VERSION = '1.79';
+$VERSION = '1.80';
 
 sub ProcessFujiDir($$$);
 sub ProcessFaceRec($$$);
@@ -507,6 +507,7 @@ my %faceCategories = (
             0 => 'Off',
             1 => 'On',
             2 => 'No flash & flash', #3
+            6 => 'Pixel Shift', #IB (GFX100S)
         },
     }],
     0x1101 => {
@@ -517,6 +518,8 @@ my %faceCategories = (
         Name => 'DriveSettings',
         SubDirectory => { TagTable => 'Image::ExifTool::FujiFilm::DriveSettings' },
     },
+    0x1105 => { Name => 'PixelShiftShots',  Writable => 'int16u' }, #IB
+    0x1106 => { Name => 'PixelShiftOffset', Writable => 'rational64s', Count => 2 }, #IB
     # (0x1150-0x1152 exist only for Pro Low-light and Pro Focus PictureModes)
     # 0x1150 - Pro Low-light - val=1; Pro Focus - val=2 (ref 7); HDR - val=128 (forum10799)
     # 0x1151 - Pro Low-light - val=4 (number of pictures taken?); Pro Focus - val=2,3 (ref 7); HDR - val=3 (forum10799)
@@ -915,15 +918,22 @@ my %faceCategories = (
     WRITABLE => 1,
     0.1 => {
         Name => 'FocusMode2',
-        Mask => 0x000000ff,
+        Mask => 0x0000000f,
         PrintConv => {
-            0x00 => 'AF-M',
-            0x01 => 'AF-S',
-            0x02 => 'AF-C',
-            0x11 => 'AF-S (Auto)',
+            0x0 => 'AF-M',
+            0x1 => 'AF-S',
+            0x2 => 'AF-C',
         },
     },
     0.2 => {
+        Name => 'PreAF',
+        Mask => 0x00f0,
+        PrintConv => {
+            0 => 'Off',
+            1 => 'On',
+        },
+    },
+    0.3 => {
         Name => 'AFAreaMode',
         Mask => 0x0f00,
         PrintConv => {
@@ -932,7 +942,7 @@ my %faceCategories = (
             2 => 'Wide/Tracking',
         },
     },
-    0.3 => {
+    0.4 => {
         Name => 'AFAreaPointSize',
         Mask => 0xf000,
         PrintConv => {
@@ -940,7 +950,7 @@ my %faceCategories = (
             OTHER => sub { return $_[0] },
         },
     },
-    0.4 => {
+    0.5 => {
         Name => 'AFAreaZoneSize',
         Mask => 0xf0000,
         PrintConv => {

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

@@ -193,11 +193,15 @@ sub ProcessJPEG_HDR($$$);
         Condition => '$$valPt =~ /^UNICODE\0/',
         Notes => 'PhotoStudio Unicode comment',
     },
-    APP11 => {
+    APP11 => [{
         Name => 'JPEG-HDR',
         Condition => '$$valPt =~ /^HDR_RI /',
         SubDirectory => { TagTable => 'Image::ExifTool::JPEG::HDR' },
-    },
+    },{
+        Name => 'JUMBF',
+        Condition => '$$valPt =~ /^JP/',
+        SubDirectory => { TagTable => 'Image::ExifTool::Jpeg2000::Main' },
+    }],
     APP12 => [{
         Name => 'PictureInfo',
         Condition => '$$valPt =~ /(\[picture info\]|Type=)/',

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

@@ -14,13 +14,15 @@ use vars qw($VERSION);
 use Image::ExifTool qw(:DataAccess :Utils);
 use Image::ExifTool::Import;
 
-$VERSION = '1.02';
+$VERSION = '1.03';
 
+sub ProcessJSON($$);
 sub ProcessTag($$$$%);
 
 %Image::ExifTool::JSON::Main = (
     GROUPS => { 0 => 'JSON', 1 => 'JSON', 2 => 'Other' },
     VARS => { NO_ID => 1 },
+    PROCESS_PROC => \&ProcessJSON,
     NOTES => q{
         Other than a few tags in the table below, JSON tags have not been
         pre-defined.  However, ExifTool will read any existing tags from basic
@@ -103,7 +105,26 @@ sub ProcessJSON($$)
     my ($et, $dirInfo) = @_;
     my $raf = $$dirInfo{RAF};
     my $structOpt = $et->Options('Struct');
-    my (%database, $key, $tag);
+    my (%database, $key, $tag, $dataPt);
+
+    unless ($raf) {
+        $dataPt = $$dirInfo{DataPt};
+        if ($$dirInfo{DirStart} or ($$dirInfo{DirLen} and $$dirInfo{DirLen} ne length($$dataPt))) {
+            my $buff = substr(${$$dirInfo{DataPt}}, $$dirInfo{DirStart}, $$dirInfo{DirLen});
+            $dataPt = \$buff;
+        }
+        $raf = new File::RandomAccess($dataPt);
+        # extract as a block if requested
+        my $blockName = $$dirInfo{BlockInfo} ? $$dirInfo{BlockInfo}{Name} : '';
+        my $blockExtract = $et->Options('BlockExtract');
+        if ($blockName and ($blockExtract or $$et{REQ_TAG_LOOKUP}{lc $blockName} or
+            ($$et{TAGS_FROM_FILE} and not $$et{EXCL_TAG_LOOKUP}{lc $blockName})))
+        {
+            $et->FoundTag($$dirInfo{BlockInfo}, $$dataPt);
+            return 1 if $blockExtract and $blockExtract > 1;
+        }
+        $et->VerboseDir('JSON');
+    }
 
     # read information from JSON file into database structure
     my $err = Image::ExifTool::Import::ReadJSON($raf, \%database,
@@ -111,7 +132,7 @@ sub ProcessJSON($$)
 
     return 0 if $err or not %database;
 
-    $et->SetFileType();
+    $et->SetFileType() unless $dataPt;
 
     my $tagTablePtr = GetTagTable('Image::ExifTool::JSON::Main');
 

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

@@ -16,9 +16,10 @@ use strict;
 use vars qw($VERSION);
 use Image::ExifTool qw(:DataAccess :Utils);
 
-$VERSION = '1.27';
+$VERSION = '1.29';
 
 sub ProcessJpeg2000Box($$$);
+sub ProcessJUMD($$$);
 
 my %resolutionUnit = (
     -3 => 'km',
@@ -54,6 +55,22 @@ my %jp2Map = (
     MakerNotes   => 'ExifIFD',
 );
 
+# map of where information is written in a JXL image
+my %jxlMap = (
+    IFD0         => 'Exif',
+    XMP          => 'XML',
+   'Exif'        => 'JP2',
+    IFD1         => 'IFD0',
+    EXIF         => 'IFD0', # to write EXIF as a block
+    ExifIFD      => 'IFD0',
+    GPS          => 'IFD0',
+    SubIFD       => 'IFD0',
+    GlobParamIFD => 'IFD0',
+    PrintIM      => 'IFD0',
+    InteropIFD   => 'ExifIFD',
+    MakerNotes   => 'ExifIFD',
+);
+
 # UUID's for writable UUID directories (by tag name)
 my %uuid = (
     'UUID-EXIF'   => 'JpgTiffExif->JP2',
@@ -99,6 +116,9 @@ my %j2cMarker = (
     0x76 => 'NLT', # non-linearity point transformation
 );
 
+my %jumbfTypes = (
+);
+
 # JPEG 2000 "box" (ie. atom) names
 # Note: only tags with a defined "Format" are extracted
 %Image::ExifTool::Jpeg2000::Main = (
@@ -107,8 +127,9 @@ my %j2cMarker = (
     WRITE_PROC => \&ProcessJpeg2000Box,
     PREFERRED => 1, # always add these tags when writing
     NOTES => q{
-        The tags below are extracted from JPEG 2000 images, however ExifTool
-        currently writes only EXIF, IPTC and XMP tags in these images.
+        The tags below are extracted from JPEG 2000 images and the JUMBF metadata in
+        JPEG images.  Note that ExifTool currently writes only EXIF, IPTC and XMP
+        tags in Jpeg2000 images.
     },
    'jP  ' => 'JP2Signature', # (ref 1)
    "jP\x1a\x1a" => 'JP2Signature', # (ref 2)
@@ -199,13 +220,22 @@ my %j2cMarker = (
     chck => 'DigitalSignature',
     mp7b => 'MPEG7Binary',
     free => 'Free',
-    jp2c => 'ContiguousCodestream',
+    jp2c => [{
+        Name => 'ContiguousCodestream',
+        Condition => 'not $$self{jumd_level}',
+    },{
+        Name => 'PreviewImage',
+        Groups => { 2 => 'Preview' },
+        Format => 'undef',
+        Binary => 1,
+    }],
     jp2i => {
         Name => 'IntellectualProperty',
         SubDirectory => { TagTable => 'Image::ExifTool::XMP::Main' },
     },
-   'xml '=> {
+   'xml '=> [{
         Name => 'XML',
+        Condition => 'not $$self{IsJXL}',
         Writable => 'undef',
         Flags => [ 'Binary', 'Protected', 'BlockExtract' ],
         List => 1,
@@ -213,12 +243,18 @@ my %j2cMarker = (
             by default, the XML data in this tag is parsed using the ExifTool XMP module
             to to allow individual tags to be accessed when reading, but it may also be
             extracted as a block via the "XML" tag, which is also how this tag is
-            written and copied.  This is a List-type tag because multiple XML blocks may
-            exist
+            written and copied.  It may also be extracted as a block by setting the API
+            BlockExtract option.  This is a List-type tag because multiple XML blocks
+            may exist
         },
         # (note: extracting as a block was broken in 11.04, and finally fixed in 12.14)
         SubDirectory => { TagTable => 'Image::ExifTool::XMP::XML' },
-    },
+    },{
+        Name => 'XMP',
+        Notes => 'used for XMP in JPEG XL files',
+        # NOTE: the hacked code relies on this being at index 1 of the tagInfo list!
+        SubDirectory => { TagTable => 'Image::ExifTool::XMP::Main' },
+    }],
     uuid => [
         {
             Name => 'UUID-EXIF',
@@ -302,6 +338,12 @@ my %j2cMarker = (
                 Start => '$valuePtr + 16',
             },
         },
+        {
+            Name => 'UUID-Signature',  # (seen in JUMB data of JPEG images)
+            Condition => '$$valPt=~/^casg\x00\x11\x00\x10\x80\x00\x00\xaa\x00\x38\x9b\x71/',
+            Format => 'undef',
+            ValueConv => 'substr($val,16)',
+        },
         {
             Name => 'UUID-Unknown',
         },
@@ -321,6 +363,52 @@ my %j2cMarker = (
             Name => 'URL',
             Format => 'string',
         },
+    # JUMBF boxes (ref https://github.com/thorfdbg/codestream-parser)
+    jumd => {
+        Name => 'JUMBFDescr',
+        SubDirectory => { TagTable => 'Image::ExifTool::Jpeg2000::JUMD' },
+    },
+    jumb => {
+        Name => 'JUMBFBox',
+        SubDirectory => {
+            TagTable => 'Image::ExifTool::Jpeg2000::Main',
+            ProcessProc => \&ProcessJUMB,
+        },
+    },
+    json => {
+        Name => 'JSONData',
+        Flags => [ 'Binary', 'Protected', 'BlockExtract' ],
+        Notes => q{
+            by default, data in this tag is parsed using the ExifTool JSON module to to
+            allow individual tags to be accessed when reading, but it may also be
+            extracted as a block via the "JSONData" tag or by setting the API
+            BlockExtract option
+        },
+        SubDirectory => { TagTable => 'Image::ExifTool::JSON::Main' },
+    },
+#
+# stuff seen in JPEG XL images:
+#
+  # jbrd - JPEG Bitstream Reconstruction Data (allows lossless conversion back to original JPG)
+    jxlc => {
+        Name => 'JXLCodestream',
+        Format => 'undef',
+        Notes => q{
+            Codestream in JPEG XL image.  Currently processed only to determine
+            ImageSize
+        },
+        RawConv => 'Image::ExifTool::Jpeg2000::ProcessJXLCodestream($self,\$val); undef',
+    },
+    Exif => {
+        Name => 'EXIF',
+        SubDirectory => {
+            TagTable => 'Image::ExifTool::Exif::Main',
+            ProcessProc => \&Image::ExifTool::ProcessTIFF,
+            WriteProc => \&Image::ExifTool::WriteTIFF,
+            DirName => 'EXIF',
+            Start => '$valuePtr + 4',
+        },
+    },
 );
 
 %Image::ExifTool::Jpeg2000::ImageHeader = (
@@ -375,6 +463,7 @@ my %j2cMarker = (
             'jp2 ' => 'JPEG 2000 Image (.JP2)',           # image/jp2
             'jpm ' => 'JPEG 2000 Compound Image (.JPM)',  # image/jpm
             'jpx ' => 'JPEG 2000 with extensions (.JPX)', # image/jpx
+            'jxl ' => 'JPEG XL Image (.JXL)',             # image/jxl
         },
     },
     1 => {
@@ -513,6 +602,112 @@ my %j2cMarker = (
     ],
 );
 
+# JUMBF description box
+%Image::ExifTool::Jpeg2000::JUMD = (
+    PROCESS_PROC => \&ProcessJUMD,
+    GROUPS => { 0 => 'JUMBF', 1 => 'JUMBF', 2 => 'Image' },
+    NOTES => 'Information extracted from the JUMBF description box.',
+    'jumd-type' => {
+        Name => 'JUMDType',
+        ValueConv => 'unpack "H*", $val',
+        PrintConv => q{
+            my @a = $val =~ /^(\w{8})(\w{4})(\w{4})(\w{16})$/;
+            return $val unless @a;
+            my $ascii = pack 'H*', $a[0];
+            $a[0] = $ascii if $ascii =~ /^[a-zA-Z0-9]{4}$/;
+            return join '-', @a;
+        },
+        # seen:
+        # cacb/cast/caas/cacl/casg/json-00110010800000aa00389b71
+        # 6579d6fbdba2446bb2ac1b82feeb89d1 - JPEG image
+    },
+    'jumd-label' => { Name => 'JUMDLabel' },
+    'jumd-flags' => {
+        Name => 'JUMDFlags',
+        PrintConv => { BITMASK => {
+            0 => 'Requestable',
+            1 => 'Label',
+            2 => 'ID',
+            3 => 'Signature',
+        }},
+    },
+    'jumd-id'    => { Name => 'JUMDID', Description => 'JUMD ID' },
+    'jumd-sig'   => { Name => 'JUMDSignature', PrintConv => 'unpack "H*", $val' },
+);
+
+#------------------------------------------------------------------------------
+# Read JUMBF box to keep track of sub-document numbers
+# Inputs: 0) ExifTool ref, 1) dirInfo ref, 2) tag table ref
+# Returns: 1 on success
+sub ProcessJUMB($$$)
+{
+    my ($et, $dirInfo, $tagTablePtr) = @_;
+    if ($$et{jumd_level}) {
+        ++$$et{jumd_level}[-1]; # increment current sub-document number
+    } else {
+        $$et{jumd_level} = [ ++$$et{DOC_COUNT} ]; # new top-level sub-document
+        $$et{SET_GROUP0} = 'JUMBF';
+    }
+    $$et{DOC_NUM} = join '-', @{$$et{jumd_level}};
+    push @{$$et{jumd_level}}, 0;
+    ProcessJpeg2000Box($et, $dirInfo, $tagTablePtr);
+    delete $$et{DOC_NUM};
+    delete $$et{JUMBFLabel};
+    pop @{$$et{jumd_level}};
+    if (@{$$et{jumd_level}} < 2) {
+        delete $$et{jumd_level};
+        delete $$et{SET_GROUP0};
+    }
+    return 1;
+}
+
+#------------------------------------------------------------------------------
+# Read JUMBF description box (ref https://github.com/thorfdbg/codestream-parser)
+# Inputs: 0) ExifTool ref, 1) dirInfo ref, 2) tag table ref
+# Returns: 1 on success
+sub ProcessJUMD($$$)
+{
+    my ($et, $dirInfo, $tagTablePtr) = @_;
+    my $dataPt = $$dirInfo{DataPt};
+    my $pos    = $$dirInfo{DirStart};
+    my $end    = $pos + $$dirInfo{DirLen};
+    $et->VerboseDir('JUMD', 0, $end-$pos);
+    delete $$et{JUMBFLabel};
+    $$dirInfo{DirLen} < 17 and $et->Warn('Truncated JUMD directory'), return 0;
+    my $type = substr($$dataPt, $pos, 4);
+    $et->HandleTag($tagTablePtr, 'jumd-type', substr($$dataPt, $pos, 16));
+    $pos += 16;
+    my $flags = Get8u($dataPt, $pos++);
+    $et->HandleTag($tagTablePtr, 'jumd-flags', $flags);
+    if ($flags & 0x02) {    # label exists?
+        pos($$dataPt) = $pos;
+        $$dataPt =~ /\0/g or $et->Warn('Missing JUMD label terminator'), return 0;
+        my $len = pos($$dataPt) - $pos;
+        my $name = substr($$dataPt, $pos, $len);
+        $et->HandleTag($tagTablePtr, 'jumd-label', $name);
+        $pos += $len;
+        if ($len) {
+            $name =~ s/[^-_a-zA-Z0-9]([a-z])/\U$1/g; # capitalize characters after illegal characters
+            $name =~ tr/-_a-zA-Z0-9//dc;    # remove other illegal characters
+            $name = ucfirst $name;          # capitalize first letter
+            $name = "Tag$name" if length($name) < 2; # must at least 2 characters long
+            $$et{JUMBFLabel} = $name;
+        }
+    }
+    if ($flags & 0x04) {    # ID exists?
+        $pos + 4 > $end and $et->Warn('Missing JUMD ID'), return 0;
+        $et->HandleTag($tagTablePtr, 'jumd-id', Get32u($dataPt, $pos));
+        $pos += 4;
+    }
+    if ($flags & 0x08) {    # signature exists?
+        $pos + 32 > $end and $et->Warn('Missing JUMD signature'), return 0;
+        $et->HandleTag($tagTablePtr, 'jumd-sig', substr($$dataPt, $pos, 32));
+        $pos += 32;
+    }
+    $pos == $end or $et->Warn('Extra data in JUMD box'." $pos $end", 1);
+    return 1;
+}
+
 #------------------------------------------------------------------------------
 # Create new JPEG 2000 boxes when writing
 # (Currently only supports adding top-level Writable JPEG2000 tags and certain UUID boxes)
@@ -542,8 +737,29 @@ sub CreateNewBoxes($$)
             $et->VerboseValue("+ Jpeg2000:$$tagInfo{Name}", $val);
         }
     }
-    # add UUID boxes
+    # add UUID boxes (and/or JXL Exif/XML boxes)
     foreach $dirName (sort keys %$addDirs) {
+        # handle JPEG XL XMP and EXIF
+        if ($dirName eq 'XML' or $dirName eq 'Exif') {
+            my ($tag, $dir) = $dirName eq 'XML' ? ('xml ', 'XMP') : ('Exif', 'EXIF');
+            my $tagInfo = $Image::ExifTool::Jpeg2000::Main{$tag};
+            $tagInfo = $$tagInfo[1] if ref $tagInfo eq 'ARRAY'; # (hack for stupid JXL XMP)
+            my $subdir = $$tagInfo{SubDirectory};
+            my $tagTable = GetTagTable($$subdir{TagTable});
+            $tagTable = GetTagTable('Image::ExifTool::XMP::Main') if $dir eq 'XMP';
+            my %dirInfo = (
+                DirName => $dir,
+                Parent => 'JP2',
+            );
+            my $newdir = $et->WriteDirectory(\%dirInfo, $tagTable, $$subdir{WriteProc});
+            if (defined $newdir and length $newdir) {
+                # not sure why, but EXIF box is padded with leading 0's in my sample
+                my $pad = $dirName eq 'Exif' ? "\0\0\0\0" : '';
+                my $boxhdr = pack('N', length($newdir) + length($pad) + 8) . $tag;
+                Write($outfile, $boxhdr, $pad, $newdir) or return 0;
+                next;
+            }
+        }
         next unless $uuid{$dirName};
         my $tagInfo;
         foreach $tagInfo (@{$Image::ExifTool::Jpeg2000::Main{uuid}}) {
@@ -725,6 +941,13 @@ sub ProcessJpeg2000Box($$$)
             );
             next unless $tagInfo;
         }
+        # create new tag for JUMBF data values with name corresponding to JUMBFLabel
+        if ($$et{JUMBFLabel} and (not $$tagInfo{SubDirectory} or $$tagInfo{BlockExtract})) {
+            $tagInfo = { %$tagInfo, Name => $$et{JUMBFLabel} };
+            AddTagToTable($tagTablePtr, '_JUMBF_' . $$et{JUMBFLabel}, $tagInfo);
+            delete $$tagInfo{Protected}; # (must do this so -j -b returns JUMBF binary data)
+            $$tagInfo{TagID} = $boxID;
+        }
         if ($$tagInfo{SubDirectory}) {
             my $subdir = $$tagInfo{SubDirectory};
             my $subdirStart = $valuePtr;
@@ -752,8 +975,8 @@ sub ProcessJpeg2000Box($$$)
                 # remove this directory from our create list
                 delete $$et{AddJp2Dirs}{$$tagInfo{Name}};
                 my $newdir;
-                # only edit writable UUID boxes
-                if ($uuid) {
+                # only edit writable UUID and Exif boxes
+                if ($uuid or $boxID eq 'Exif' or ($boxID eq 'xml ' and $$et{IsJXL})) {
                     $newdir = $et->WriteDirectory(\%subdirInfo, $subTable, $$subdir{WriteProc});
                     next if defined $newdir and not length $newdir; # next if deleting the box
                 } elsif (defined $uuid) {
@@ -803,6 +1026,68 @@ sub ProcessJpeg2000Box($$$)
     return 1;
 }
 
+#------------------------------------------------------------------------------
+# Return bits from a bitstream object
+# Inputs: 0) array ref, 1) number of bits
+# Returns: specified number of bits as an integer, and shifts input bitstream
+sub GetBits($$)
+{
+    my ($a, $n) = @_;
+    my $v = 0;
+    my $bit = 1;
+    my $i;
+    while ($n--) {
+        for ($i=0; $i<@$a; ++$i) {
+            # consume bits LSB first
+            my $set = $$a[$i] & 1;
+            $$a[$i] >>= 1;
+            if ($i) {
+                $$a[$i-1] |= 0x80 if $set;
+            } else {
+                $v |= $bit if $set;
+                $bit <<= 1;
+            }
+        }
+    }
+    return $v;
+}
+
+#------------------------------------------------------------------------------
+# Extract parameters from JPEG XL codestream [unverified!]
+# Inputs: 0) ExifTool ref, 1) codestream ref
+# Returns: 1
+sub ProcessJXLCodestream($$)
+{
+    my ($et, $dataPt) = @_;
+    # add padding if necessary to avoid unpacking past end of data
+    if (length $$dataPt < 14) {
+        my $tmp = $$dataPt . ("\0" x 14);
+        $dataPt = \$tmp;
+    }
+    my @a = unpack 'x2C12', $$dataPt;
+    my ($x, $y);
+    my $small = GetBits(\@a, 1);
+    if ($small) {
+        $y = (GetBits(\@a, 5) + 1) * 8;
+    } else {
+        $y = GetBits(\@a, [9, 13, 18, 30]->[GetBits(\@a, 2)]) + 1;
+    }
+    my $ratio = GetBits(\@a, 3);
+    if ($ratio == 0) {
+        if ($small) {
+            $x = (GetBits(\@a, 5) + 1) * 8;;
+        } else {
+            $x = GetBits(\@a, [9, 13, 18, 30]->[GetBits(\@a, 2)]) + 1;
+        }
+    } else {
+        my $r = [[1,1],[12,10],[4,3],[3,2],[16,9],[5,4],[2,1]]->[$ratio-1];
+        $x = int($y * $$r[0] / $$r[1]);
+    }
+    $et->FoundTag(ImageWidth => $x);
+    $et->FoundTag(ImageHeight => $y);
+    return 1;
+}
+
 #------------------------------------------------------------------------------
 # Read/write meta information from a JPEG 2000 image
 # Inputs: 0) ExifTool object reference, 1) dirInfo reference
@@ -817,8 +1102,9 @@ sub ProcessJP2($$)
 
     # check to be sure this is a valid JPG2000 file
     return 0 unless $raf->Read($hdr,12) == 12;
-    unless ($hdr eq "\x00\x00\x00\x0cjP  \x0d\x0a\x87\x0a" or     # (ref 1)
-            $hdr eq "\x00\x00\x00\x0cjP\x1a\x1a\x0d\x0a\x87\x0a") # (ref 2)
+    unless ($hdr eq "\0\0\0\x0cjP  \x0d\x0a\x87\x0a" or     # (ref 1)
+            $hdr eq "\0\0\0\x0cjP\x1a\x1a\x0d\x0a\x87\x0a" or # (ref 2)
+            $$et{IsJXL})
     {
         return 0 unless $hdr =~ /^\xff\x4f\xff\x51\0/;  # check for JP2 codestream format
         if ($outfile) {
@@ -835,17 +1121,23 @@ sub ProcessJP2($$)
     }
     if ($outfile) {
         Write($outfile, $hdr) or return -1;
-        $et->InitWriteDirs(\%jp2Map);
+        if ($$et{IsJXL}) {
+            $et->InitWriteDirs(\%jxlMap);
+            $$et{AddJp2Tags} = { }; # (don't add JP2 tags in JXL files)
+        } else {
+            $et->InitWriteDirs(\%jp2Map);
+            $$et{AddJp2Tags} = $et->GetNewTagInfoHash(\%Image::ExifTool::Jpeg2000::Main);
+        }
         # save list of directories to create
-        my %addDirs = %{$$et{ADD_DIRS}};
+        my %addDirs = %{$$et{ADD_DIRS}}; # (make a copy)
         $$et{AddJp2Dirs} = \%addDirs;
-        $$et{AddJp2Tags} = $et->GetNewTagInfoHash(\%Image::ExifTool::Jpeg2000::Main);
     } else {
         my ($buff, $fileType);
         # recognize JPX and JPM as unique types of JP2
         if ($raf->Read($buff, 12) == 12 and $buff =~ /^.{4}ftyp(.{4})/s) {
             $fileType = 'JPX' if $1 eq 'jpx ';
             $fileType = 'JPM' if $1 eq 'jpm ';
+            $fileType = 'JXL' if $1 eq 'jxl ';
         }
         $raf->Seek(-length($buff), 1) if defined $buff;
         $et->SetFileType($fileType);
@@ -860,6 +1152,59 @@ sub ProcessJP2($$)
     return $et->ProcessDirectory(\%dirInfo, $tagTablePtr);
 }
 
+#------------------------------------------------------------------------------
+# Read meta information from a JPEG XL image
+# Inputs: 0) ExifTool object reference, 1) dirInfo reference
+# Returns: 1 on success, 0 if this wasn't a valid JPEG XL file, -1 on write error
+sub ProcessJXL($$)
+{
+    my ($et, $dirInfo) = @_;
+    my $raf = $$dirInfo{RAF};
+    my $outfile = $$dirInfo{OutFile};
+    my ($hdr, $buff);
+
+    return 0 unless $raf->Read($hdr,12) == 12;
+    if ($hdr eq "\0\0\0\x0cJXL \x0d\x0a\x87\x0a") {
+        # JPEG XL in ISO BMFF container
+        $$et{IsJXL} = 1;
+    } elsif ($hdr =~ /^\xff\x0a/) {
+        # JPEG XL codestream
+        if ($outfile) {
+            if ($$et{OPTIONS}{IgnoreMinorErrors}) {
+                $et->Warn('Wrapped JXL codestream in ISO BMFF container');
+            } else {
+                $et->Error('Will wrap JXL codestream in ISO BMFF container for writing',1);
+                return 0;
+            }
+            $$et{IsJXL} = 2;
+            my $buff = "\0\0\0\x0cJXL \x0d\x0a\x87\x0a\0\0\0\x14ftypjxl \0\0\0\0jxl ";
+            # add metadata to empty ISO BMFF container
+            $$dirInfo{RAF} = new File::RandomAccess(\$buff);
+        } else {
+            $et->SetFileType('JXL Codestream','image/jxl', 'jxl');
+            return ProcessJXLCodestream($et, \$hdr);
+        }
+    } else {
+        return 0;
+    }
+    $raf->Seek(0,0) or $et->Error('Seek error'), return 0;
+
+    my $success = ProcessJP2($et, $dirInfo);
+
+    if ($outfile and $success > 0 and $$et{IsJXL} == 2) {
+        # attach the JXL codestream box to the ISO BMFF file
+        $raf->Seek(0,2) or return -1;
+        my $size = $raf->Tell();
+        $raf->Seek(0,0) or return -1;
+        SetByteOrder('MM');
+        Write($outfile, Set32u($size + 8), 'jxlc') or return -1;
+        while ($raf->Read($buff, 65536)) {
+            Write($outfile, $buff) or return -1;
+        }
+    }
+    return $success;
+}
+
 1;  # end
 
 __END__