exiftool_vendored 12.16.0 → 12.25.0

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

@@ -89,7 +89,7 @@ my $parsePictureTiming; # flag to enable parsing of picture timing information (
         Notes => 'hours:minutes:seconds:frames',
         ValueConv => 'sprintf("%.2x:%.2x:%.2x:%.2x",reverse unpack("C*",$val))',
     },
-    # 0x14 - TitleBinaryGroup
+    # 0x14 - TitleBinaryGroup - val: 0x00000000,0x14200130
     # 0x15 - TitleCassetteNo (ref 7)
     # 0x16-0x17 - TitleSoftID (ref 7)
     # (0x18,0x19 listed as TitleTextHeader/TitleText by ref 7)
@@ -134,8 +134,8 @@ my $parsePictureTiming; # flag to enable parsing of picture timing information (
         Name => 'Camera2',
         SubDirectory => { TagTable => 'Image::ExifTool::H264::Camera2' },
     },
-    # 0x73 Lens - val: 0x75ffffd3,0x0effffd3,0x59ffffd3,0x79ffffd3,0xffffffd3...
-    # 0x74 Gain
+    # 0x73 Lens - val: 0x04ffffd3,0x0effffd3,0x15ffffd3,0x41ffffd3,0x52ffffd3,0x59ffffd3,0x65ffffd3,0x71ffffd3,0x75ffffd3,0x79ffffd3,0x7fffffd3,0xffffffd3...
+    # 0x74 Gain - val: 0xb8ffff0f
     # 0x75 Pedestal
     # 0x76 Gamma
     # 0x77 Detail
@@ -376,34 +376,49 @@ my $parsePictureTiming; # flag to enable parsing of picture timing information (
         Notes => 'combined with tag 0xc8',
     },
     # 0xc9-0xcf - GPSOption
+    # 0xc9 - val: 0x001d0203
+    0xca => { #PH (Sony DSC-HX7V)
+        Name => 'GPSDateStamp',
+        Format => 'string',
+        Groups => { 1 => 'GPS', 2 => 'Time' },
+        Combine => 2,    # the next 2 tags contain the rest of the string
+        Notes => 'combined with tags 0xcb and 0xcc',
+        ValueConv => 'Image::ExifTool::Exif::ExifDate($val)',
+    },
     0xe0 => {
         Name => 'MakeModel',
         SubDirectory => { TagTable => 'Image::ExifTool::H264::MakeModel' },
     },
     # 0xe1-0xef - MakerOption
     # 0xe1 - val: 0x01000670,0x01000678,0x06ffffff,0x01ffffff,0x01000020,0x01000400...
-    # 0xe2-0xe8 - val: 0x00000000 in many samples
     0xe1 => { #6
         Name => 'RecInfo',
         Condition => '$$self{Make} eq "Canon"',
         Notes => 'Canon only',
         SubDirectory => { TagTable => 'Image::ExifTool::H264::RecInfo' },
     },
+    # 0xe2-0xe8 - val: 0x00000000 in many samples
+    # 0xe2 - val: 0x00000000,0x01000000,0x01010000,0x8080900c,0x8080a074
+    # 0xe3 - val: 0x00801f89,0x00801f8b,0x00c01f89,0xc9c01f80
     0xe4 => { #PH
         Name => 'Model',
         Condition => '$$self{Make} eq "Sony"', # (possibly also Canon models?)
         Description => 'Camera Model Name',
-        Notes => 'Sony cameras only, combined with tags 0xe5 and 0xe6',
+        Notes => 'Sony only, combined with tags 0xe5 and 0xe6',
         Format => 'string',
         Combine => 2, # (not sure about 0xe6, but include it just in case)
         RawConv => '$val eq "" ? undef : $val',
     },
+    # 0xeb - val: 0x008a0a00,0x0a300000,0x508a0a00,0x52880a00,0x528a0a00
+    # 0xec - val: 0x0b700000
+    # 0xed - val: 0x0ce0f819
     0xee => { #6 (HFS200)
         Name => 'FrameInfo',
         Condition => '$$self{Make} eq "Canon"',
         Notes => 'Canon only',
         SubDirectory => { TagTable => 'Image::ExifTool::H264::FrameInfo' },
     },
+    # 0xef - val: 0x01c00000,0x0e00000c
 );
 
 # ConsumerCamera1 information (ref PH)

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

@@ -24,7 +24,7 @@ use strict;
 use vars qw($VERSION);
 use Image::ExifTool qw(:DataAccess :Utils);
 
-$VERSION = '1.35';
+$VERSION = '1.36';
 
 sub ProcessICC($$);
 sub ProcessICC_Profile($$$);
@@ -1225,7 +1225,7 @@ sub ProcessICC_Profile($$$)
             my $type = substr($$dataPt, $valuePtr, 4);
             #### eval Validate ($type)
             if (defined $$subdir{Validate} and not eval $$subdir{Validate}) {
-                $et->Warn("Invalid $name data");
+                $et->Warn("Invalid ICC $name data");
             } else {
                 $et->ProcessDirectory(\%subdirInfo, $newTagTable, $$subdir{ProcessProc});
             }

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__