exiftool-vendored.pl 12.73.0 → 12.78.0

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

@@ -0,0 +1,237 @@
+#------------------------------------------------------------------------------
+# File:         Geolocation.pm
+#
+# Description:  Look up geolocation information based on a GPS position
+#
+# Revisions:    2024-03-03 - P. Harvey Created
+#
+# References:   https://download.geonames.org/export/
+#
+# Notes:        Set $Image::ExifTool::Geolocation::databaseFile to override
+#               default database file (lib/Image/ExifTool/Geolocation.dat)
+#
+#               Based on data from geonames.org Creative Commons databases,
+#               reformatted as follows in the Geolocation.dat file:
+#
+#   Header: GeolocationV.VV\tNNNN\n - V.VV=version, NNNN=num city entries
+#
+#   NNNN City entries:
+#       1. int16u[2] - longitude.latitude (converted to 0-64k range)
+#       2. int8u - low byte of time zone number
+#       3. int8u - 100's=time zone high bit, population: 10's=num zeros, 1's=sig digit
+#       4. UTF8 City name, terminated by tab
+#       5. 2-character country code
+#       6. Region code, terminated by newline
+#   End of section marker - "\0\0\0\0\x01"
+#   Country entries:
+#       1. 2-character country code
+#       2. Country name, terminated by newline
+#   End of section marker - "\0\0\0\0\x02"
+#   Region entries:
+#       1. 2-character country code
+#       2. Region code, terminated by tab
+#       3. Region name, terminated by newline
+#   End of section marker - "\0\0\0\0\x03"
+#   Time zone entries:
+#       1. Time zone name, terminated by newline
+#   End of file marker - "\0\0\0\0\0"
+#------------------------------------------------------------------------------
+
+package Image::ExifTool::Geolocation;
+
+use strict;
+use vars qw($VERSION $databaseFile);
+
+$VERSION = '1.00';
+
+my (@cityLookup, %countryLookup, %adminLookup, @timezoneLookup);
+
+# get path name for database file from lib/Image/ExifTool/Geolocation.dat by default,
+# or according to $Image::ExifTool::Geolocation::databaseFile if specified
+my $datfile = $databaseFile;
+unless ($datfile) {
+    $datfile = $INC{'Image/ExifTool/Geolocation.pm'};
+    $datfile or $datfile = 'Geolocation.pm', warn("Error getting Geolocation directory\n");
+    $datfile =~ s/\.pm$/\.dat/;
+}
+
+# open geolocation database and verify header
+open DATFILE, "<$datfile" or warn("Error reading $datfile\n"), return 0;
+binmode DATFILE;
+my $line = <DATFILE>;
+unless ($line =~ /^Geolocation(\d+\.\d+)\t(\d+)/) {
+    warn("Bad format Geolocation database\n");
+    close(DATFILE);
+    return 0;
+}
+my $ncity = $2;
+
+# read city database
+for (;;) {
+    $line = <DATFILE>;
+    last if length($line) == 6 and $line =~ /\0\0\0\0/;
+    $line .= <DATFILE> while length($line) < 7;
+    chomp $line;
+    push @cityLookup, $line;
+}
+@cityLookup == $ncity or warn("Bad number of entries in Geolocation database\n"), return 0;
+# read countries
+for (;;) {
+    $line = <DATFILE>;
+    last if length($line) == 6 and $line =~ /\0\0\0\0/;
+    chomp $line;
+    $countryLookup{substr($line,0,2)} = substr($line,2);
+}
+# read regions
+for (;;) {
+    $line = <DATFILE>;
+    last if length($line) == 6 and $line =~ /\0\0\0\0/;
+    chomp $line;
+    my ($code, $region) = split /\t/, $line;
+    $adminLookup{$code} = $region;
+}
+# read time zones
+for (;;) {
+    $line = <DATFILE>;
+    last if length($line) == 6 and $line =~ /\0\0\0\0/;
+    chomp $line;
+    push @timezoneLookup, $line;
+}
+close DATFILE;
+
+#------------------------------------------------------------------------------
+# Look up lat/lon in geolocation database
+# Inputs: 0) Latitude, 1) longitude, 2) optional min population,
+#         3) optional max distance (km)
+# Returns: 0) UTF8 city name (or undef if geolocation is unsuccessful),
+#          1) UTF8 state, province or region (or undef),
+#          2) country code, 3) country name (undef is possible),
+#          4) time zone name (empty string possible), 5) approx population,
+#          6) approx distance (km), 7) approximate compass bearing (or undef),
+#          8/9) approx lat/lon
+sub Geolocate($$;$$)
+{
+    my ($lat, $lon, $pop, $km) = @_;
+    my ($minPop, $maxDist2);
+    my $earthCirc = 40000;  # earth circumference in km
+
+    if ($pop) {
+        # convert population minimum to a 2-digit code
+        my $dig = substr($pop, 0, 1);
+        my $zer = length($pop) - 1;
+        # round up if necessary
+        if (length($pop) > 1 and substr($pop, 1, 1) >= 5) {
+            ++$dig > 9 and $dig = 1, ++$zer;
+        }
+        $minPop = $zer.$dig;
+    }
+    if ($km) {
+        # convert max distance to reduced coordinate units
+        my $tmp = $km * 2 * 65536 / $earthCirc;
+        $maxDist2 = $tmp * $tmp;
+    }
+    my $cos = cos($lat * 3.14159 / 180); # cosine factor for longitude distances
+    # reduce lat/lon to the range 0-65536
+    $lat = int(($lat + 90)  / 180 * 65536 + 0.5) & 0xffff;
+    $lon = int(($lon + 180) / 360 * 65536 + 0.5) & 0xffff;
+    my $coord = pack('n2',$lon,$lat);   # pack for comparison with binary database values
+    # binary search to find closest longitude
+    my ($n0, $n1) = (0, scalar(@cityLookup)-1);
+    while ($n1 - $n0 > 1) {
+        my $n = int(($n0 + $n1) / 2);
+        if ($coord lt $cityLookup[$n]) {
+            $n1 = $n;
+        } else {
+            $n0 = $n;
+        }
+    }
+    # step backward then forward through database to find nearest city
+    my ($minDist2, $minN, @dxy);
+    my ($inc, $end, $n) = (-1, -1, $n0+1);
+    for (;;) {
+        if (($n += $inc) == $end) {
+            last if $inc == 1;
+            ($inc, $end, $n) = (1, scalar(@cityLookup), $n1);
+        }
+        my ($x,$y) = unpack('n2', $cityLookup[$n]);
+        my ($dy,$dx) = ($y-$lat, $x-$lon);
+        $dx += 65536 if $dx < -32768;       # measure the short way around the world
+        $dx -= 65536 if $dx > 32768;
+        $dx = 2 * $cos * $dx;               # adjust for longitude spacing
+        my $dx2 = $dx * $dx;
+        my $dist2 = $dy * $dy + $dx2;
+        if (defined $minDist2) {
+            # searched far enough if longitude alone is further than best distance
+            $dx2 > $minDist2 and $n = $end - $inc, next;
+        } elsif (defined $maxDist2) {
+            $dx2 > $maxDist2 and $n = $end - $inc, next;
+            next if $dist2 > $maxDist2;   # ignore if distance is too great
+        }
+        # ignore if population is below threshold
+        next if $minPop and $minPop > unpack('x5C', $cityLookup[$n]) % 100;
+        if (not defined $minDist2 or $minDist2 > $dist2) {
+            $minDist2 = $dist2;
+            @dxy = ($dx, $dy);
+            $minN = $n;
+        }
+    }
+    return () unless defined $minN;
+
+    my ($ln,$lt,$tn,$pc) = unpack('n2C2', $cityLookup[$minN]);
+    my ($city, $code) = split /\t/, substr($cityLookup[$minN],6);
+    my $ctry = substr($code,0,2);
+    my $rgn = $adminLookup{$code};
+    my $po2 = substr($pc, -1) . (length($pc) > 1 ? '0' x substr($pc, -2, 1) : '');
+    $tn += 256 if $pc > 99;
+    my $be; # calculate bearing to geolocated city
+    if ($dxy[0] or $dxy[1]) {
+        $be = atan2($dxy[0],$dxy[1]) * 180 / 3.14159;
+        $be += 360 if $be < 0;
+        $be = int($be + 0.5);
+    }
+    $lt = sprintf('%.3f', $lt * 180 / 65536 - 90);
+    $ln = sprintf('%.3f', $ln * 360 / 65536 - 180);
+    $km = sprintf('%.1f', sqrt($minDist2) * $earthCirc / (2 * 65536));
+
+    return($city,$rgn,$ctry,$countryLookup{$ctry},$timezoneLookup[$tn],$po2,$km,$be,$lt,$ln);
+}
+
+__END__
+
+=head1 NAME
+
+Image::ExifTool::Geolocation - Look up geolocation based on GPS position
+
+=head1 SYNOPSIS
+
+This module is used by the Image::ExifTool Geolocation feature.
+
+=head1 DESCRIPTION
+
+This module contains the code to convert GPS coordinates to city, region,
+country, time zone, etc.  It uses a database derived from geonames.org,
+modified to reduce the size as much as possible.
+
+=head1 AUTHOR
+
+Copyright 2003-2024, Phil Harvey (philharvey66 at gmail.com)
+
+This library is free software; you can redistribute it and/or modify it
+under the same terms as Perl itself.  Geolocation.dat is based on data
+from geonames.org with a Creative Commons license.
+
+=head1 REFERENCES
+
+=over 4
+
+=item L<https://download.geonames.org/export/>
+
+=back
+
+=head1 SEE ALSO
+
+L<Image::ExifTool(3pm)|Image::ExifTool>
+
+=cut
+
+1; #end

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

@@ -29,7 +29,7 @@ use vars qw($VERSION);
 use Image::ExifTool qw(:Public);
 use Image::ExifTool::GPS;
 
-$VERSION = '1.73';
+$VERSION = '1.74';
 
 sub JITTER() { return 2 }       # maximum time jitter
 
@@ -174,7 +174,7 @@ sub LoadTrackLog($$;$)
         # $val is track file name
         if ($et->Open(\*EXIFTOOL_TRKFILE, $val)) {
             $trackFile = $val;
-            $raf = new File::RandomAccess(\*EXIFTOOL_TRKFILE);
+            $raf = File::RandomAccess->new(\*EXIFTOOL_TRKFILE);
             unless ($raf->Read($_, 256)) {
                 close EXIFTOOL_TRKFILE;
                 return "Empty track file '${val}'";
@@ -202,7 +202,7 @@ sub LoadTrackLog($$;$)
     }
     unless ($from) {
         # set up RAF for reading log file in memory
-        $raf = new File::RandomAccess(\$val);
+        $raf = File::RandomAccess->new(\$val);
         $from = 'data';
     }
 
@@ -1109,7 +1109,7 @@ sub SetGeoValues($$;$)
                     $iExt = $i1;
                 }
                 if (abs($time - $tn) > $geoMaxExtSecs) {
-                    $err or $err = 'Time is too far from nearest GPS fix'.' '.abs($time-$tn).' '.$geoMaxExtSecs;
+                    $err or $err = 'Time is too far from nearest GPS fix'.' '.abs($time-$tn).' > '.$geoMaxExtSecs;
                     $et->VPrint(2, '  Nearest fix:     ', PrintFixTime($tn), "\n") if $verbose > 2;
                     $fix = { } if $$geotag{DateTimeOnly};
                 } else {

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

@@ -13,7 +13,7 @@ use vars qw($VERSION);
 use Image::ExifTool;    # only for FinishTiffDump()
 use Image::ExifTool::HTML qw(EscapeHTML);
 
-$VERSION = '1.39';
+$VERSION = '1.42';
 
 sub DumpTable($$$;$$$$$$);
 sub Open($$$;@);
@@ -314,6 +314,8 @@ sub Print($$;$$$$$)
     $title = 'HtmlDump' unless $title;
     $level or $level = 0;
     my $tell = $raf->Tell();
+    $raf->Seek(0,2) or $$self{ERROR} = 'Seek error', return -1;
+    my $fileLen = $raf->Tell();
     my $pos = 0;
     my $dataEnd = $dataPos + ($dataPt ? length($$dataPt) : 0);
     # initialize member variables
@@ -352,6 +354,7 @@ sub Print($$;$$$$$)
         } else {
             last;
         }
+        $start = $fileLen if $start > $fileLen; # handle case of bad start offset
         my $len = $start - $pos;
         if ($len > 0 and not $wasUnused) {
             # we have a unused bytes before this data block
@@ -432,8 +435,7 @@ sub Print($$;$$$$$)
                             {
                                 $err = $msg;
                                 # reset $len to the actual length of available data
-                                $raf->Seek(0, 2);
-                                $len = $raf->Tell() - $start;
+                                $len = $fileLen - $start;
                                 $tip .= "<br>Error: Only $len bytes available!" if $tip;
                                 next;
                             }
@@ -767,6 +769,7 @@ sub FinishTiffDump($$$)
         PreviewImageStart => 'PreviewImageLength',
         JpgFromRawStart   => 'JpgFromRawLength',
         OtherImageStart   => 'OtherImageLength',
+        PreviewJXLStart   => 'PreviewJXLLength',
         ImageOffset       => 'ImageByteCount',
         AlphaOffset       => 'AlphaByteCount',
         MPImageStart      => 'MPImageLength',
@@ -894,7 +897,7 @@ Image::ExifTool::HtmlDump - Dump information in hex to HTML page
 =head1 SYNOPSIS
 
     use Image::ExifTool::HtmlDump;
-    my $dump = new Image::ExifTool::HtmlDump;
+    my $dump = Image::ExifTool::HtmlDump->new;
     $dump->Add($start, $size, $comment);
     $dump->Print($dumpInfo, $raf, $dataPt, $dataPos, $outfile);
 

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

@@ -18,7 +18,7 @@ use strict;
 use vars qw($VERSION);
 use Image::ExifTool qw(:DataAccess :Utils);
 
-$VERSION = '1.60';
+$VERSION = '1.61';
 
 sub ProcessID3v2($$$);
 sub ProcessPrivate($$$);
@@ -1408,7 +1408,7 @@ sub ProcessID3($$)
     $$et{DoneID3} = 1;
 
     # allow this to be called with either RAF or DataPt
-    my $raf = $$dirInfo{RAF} || new File::RandomAccess($$dirInfo{DataPt});
+    my $raf = $$dirInfo{RAF} || File::RandomAccess->new($$dirInfo{DataPt});
     my ($buff, %id3Header, %id3Trailer, $hBuff, $tBuff, $eBuff, $tagTablePtr);
     my $rtnVal = 0;
     my $hdrEnd = 0;

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

@@ -12,7 +12,7 @@ require Exporter;
 
 use vars qw($VERSION @ISA @EXPORT_OK);
 
-$VERSION = '1.10';
+$VERSION = '1.12';
 @ISA = qw(Exporter);
 @EXPORT_OK = qw(ReadCSV ReadJSON);
 
@@ -38,13 +38,13 @@ sub ReadCSV($$;$$)
         $raf = $file;
         $file = 'CSV file';
     } elsif (ref $file eq 'GLOB') {
-        $raf = new File::RandomAccess($file);
+        $raf = File::RandomAccess->new($file);
         $file = 'CSV file';
     } else {
         open CSVFILE, $file or return "Error opening CSV file '${file}'";
         binmode CSVFILE;
         $openedFile = 1;
-        $raf = new File::RandomAccess(\*CSVFILE);
+        $raf = File::RandomAccess->new(\*CSVFILE);
     }
     $delim = ',' unless defined $delim;
     # set input record separator by first newline found in the file
@@ -238,7 +238,7 @@ Tok: for (;;) {
 
 #------------------------------------------------------------------------------
 # Read JSON file
-# Inputs: 0) JSON file name, file ref or RAF ref, 1) database hash ref,
+# Inputs: 0) JSON file name, file ref, RAF ref or SCALAR ref, 1) database hash ref,
 #         2) flag to delete "-" tags, 3) character set
 # Returns: undef on success, or error string
 sub ReadJSON($$;$$)
@@ -253,13 +253,16 @@ sub ReadJSON($$;$$)
         $raf = $file;
         $file = 'JSON file';
     } elsif (ref $file eq 'GLOB') {
-        $raf = new File::RandomAccess($file);
+        $raf = File::RandomAccess->new($file);
         $file = 'JSON file';
+    } elsif (ref $file eq 'SCALAR') {
+        $raf = File::RandomAccess->new($file);
+        $file = 'in memory';
     } else {
         open JSONFILE, $file or return "Error opening JSON file '${file}'";
         binmode JSONFILE;
         $openedFile = 1;
-        $raf = new File::RandomAccess(\*JSONFILE);
+        $raf = File::RandomAccess->new(\*JSONFILE);
     }
     my $obj = ReadJSONObject($raf);
     close JSONFILE if $openedFile;

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

@@ -14,7 +14,7 @@ use vars qw($VERSION);
 use Image::ExifTool qw(:DataAccess :Utils);
 use Image::ExifTool::Import;
 
-$VERSION = '1.06';
+$VERSION = '1.07';
 
 sub ProcessJSON($$);
 sub ProcessTag($$$$%);
@@ -60,15 +60,15 @@ sub FoundTag($$$$%)
     # avoid conflict with special table entries
     $tag .= '!' if $Image::ExifTool::specialTags{$tag};
 
-    # use underline instead of colon if necessary in tag name
-    $tag =~ s/([A-Z]):([A-Z]{2})/${1}_$2/g;
-
-    AddTagToTable($tagTablePtr, $tag, {
-        Name => Image::ExifTool::MakeTagName($tag),
-        %flags,
-        Temporary => 1,
-    }) unless $$tagTablePtr{$tag};
-
+    unless ($$tagTablePtr{$tag}) {
+        my $name = $tag;
+        $name =~ tr/:/_/; # use underlines in place of colons in tag name
+        AddTagToTable($tagTablePtr, $tag, {
+            Name => Image::ExifTool::MakeTagName($name),
+            %flags,
+            Temporary => 1,
+        });
+    }
     $et->HandleTag($tagTablePtr, $tag, $val);
 }
 
@@ -120,7 +120,7 @@ sub ProcessJSON($$)
             my $buff = substr(${$$dirInfo{DataPt}}, $$dirInfo{DirStart}, $$dirInfo{DirLen});
             $dataPt = \$buff;
         }
-        $raf = new File::RandomAccess($dataPt);
+        $raf = File::RandomAccess->new($dataPt);
         # extract as a block if requested
         my $blockName = $$dirInfo{BlockInfo} ? $$dirInfo{BlockInfo}{Name} : '';
         my $blockExtract = $et->Options('BlockExtract');

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

@@ -16,7 +16,7 @@ use strict;
 use vars qw($VERSION);
 use Image::ExifTool qw(:DataAccess :Utils);
 
-$VERSION = '1.37';
+$VERSION = '1.39';
 
 sub ProcessJpeg2000Box($$$);
 sub ProcessJUMD($$$);
@@ -141,10 +141,13 @@ my %j2cMarker = (
         Authenticity Initiative) JUMBF (JPEG Universal Metadata Box Format) metdata
         is currently extracted from JPEG, PNG, TIFF-based (eg. TIFF, DNG),
         QuickTime-based (eg. MP4, MOV, HEIF, AVIF), RIFF-based (eg. WAV, AVI, WebP),
-        GIF files and ID3v2 metadata.  The suggested ExifTool command-line arguments
-        for reading C2PA metadata are C<-jumbf:all -G3 -b -j -u -struct>.  This
-        metadata may be deleted from writable JPEG, PNG, WebP, TIFF-based, and
-        QuickTime-based files by deleting the JUMBF group with C<-jumbf:all=>.
+        PDF, SVG and GIF files, and ID3v2 metadata.  The suggested ExifTool
+        command-line arguments for reading C2PA metadata are C<-jumbf:all -G3 -b -j
+        -u -struct>.  This metadata may be deleted from writable JPEG, PNG, WebP,
+        TIFF-based, and QuickTime-based files by deleting the JUMBF group with
+        C<-jumbf:all=>.  The C2PA JUMBF metadata may be extracted as a block via the
+        JUMBF tag.  See L<https://c2pa.org/specifications/> for the C2PA
+        specification.
     },
 #
 # NOTE: ONLY TAGS WITH "Format" DEFINED ARE EXTRACTED!
@@ -419,7 +422,7 @@ my %j2cMarker = (
         Flags => [ 'Binary', 'Protected' ],
         SubDirectory => { TagTable => 'Image::ExifTool::CBOR::Main' },
     },
-    bfdb => { # used in JUMBF (see  # (used when tag is renamed according to JUMDLabel)
+    bfdb => { # used in JUMBF
         Name => 'BinaryDataType',
         Notes => 'JUMBF, MIME type and optional file name',
         Format => 'undef',
@@ -748,6 +751,7 @@ my %j2cMarker = (
         },
         # seen:
         # cacb/cast/caas/cacl/casg/json-00110010800000aa00389b71
+        #   (also brob- but not yet tested)
         # 6579d6fbdba2446bb2ac1b82feeb89d1 - JPEG image
     },
     'label' => { Name => 'JUMDLabel' },
@@ -821,6 +825,7 @@ sub ProcessJUMD($$$)
             $name =~ tr/-_a-zA-Z0-9//dc;    # remove other illegal characters
             $name =~ s/__/_/;               # collapse double underlines
             $name = ucfirst $name;          # capitalize first letter
+            $name =~ s/C2pa/C2PA/;          # capitalize C2PA
             $name = "Tag$name" if length($name) < 2; # must at least 2 characters long
             $$et{JUMBFLabel} = $name;
         }
@@ -1017,11 +1022,23 @@ sub ProcessJpeg2000Box($$$)
     my $dirStart = $$dirInfo{DirStart} || 0;
     my $base = $$dirInfo{Base} || 0;
     my $outfile = $$dirInfo{OutFile};
+    my $dirName = $$dirInfo{DirName} || '';
     my $dirEnd = $dirStart + $dirLen;
     my ($err, $outBuff, $verbose, $doColour, $hash, $raf);
 
-    # read from RAF unless reading from buffer
-    $raf = $$dirInfo{RAF} unless $dataPt;
+    if ($dataPt) {
+        # save C2PA JUMBF as a block if requested
+        if ($dirName eq 'JUMBF' and $$et{REQ_TAG_LOOKUP}{jumbf} and not $$dirInfo{NoBlockSave}) {
+            if ($dirStart or $dirLen ne length($$dataPt)) {
+                my $dat = substr($$dataPt, $dirStart, $dirLen);
+                $et->FoundTag(JUMBF => \$dat);
+            } else {
+                $et->FoundTag(JUMBF => $dataPt);
+            }
+        }
+    } else {
+        $raf = $$dirInfo{RAF};  # read from RAF
+    }
 
     if ($outfile) {
         unless ($raf) {
@@ -1030,7 +1047,7 @@ sub ProcessJpeg2000Box($$$)
             $outfile = \$outBuff;
         }
         # determine if we will be writing colr box
-        if ($$dirInfo{DirName} and $$dirInfo{DirName} eq 'JP2Header') {
+        if ($dirName eq 'JP2Header') {
             $doColour = 2 if defined $et->GetNewValue('ColorSpecMethod') or $et->GetNewValue('ICC_Profile') or
                              defined $et->GetNewValue('ColorSpecPrecedence') or defined $et->GetNewValue('ColorSpace') or
                              defined $et->GetNewValue('ColorSpecApproximation') or defined $et->GetNewValue('ColorSpecData');
@@ -1038,7 +1055,7 @@ sub ProcessJpeg2000Box($$$)
     } else {
         # (must not set verbose flag when writing!)
         $verbose = $$et{OPTIONS}{Verbose};
-        $et->VerboseDir($$dirInfo{DirName}) if $verbose;
+        $et->VerboseDir($dirName) if $verbose;
         # do hash if requested, but only for top-level image data
         $hash = $$et{ImageDataHash} if $raf;
     }
@@ -1187,7 +1204,7 @@ sub ProcessJpeg2000Box($$$)
         # create new tag for JUMBF data values with name corresponding to JUMBFLabel
         if ($tagInfo and $$et{JUMBFLabel} and (not $$tagInfo{SubDirectory} or $$tagInfo{BlockExtract})) {
             $tagInfo = { %$tagInfo, Name => $$et{JUMBFLabel} . ($$tagInfo{JUMBF_Suffix} || '') };
-            delete $$tagInfo{Description};
+            ($$tagInfo{Description} = Image::ExifTool::MakeDescription($$tagInfo{Name})) =~ s/C2 PA/C2PA/;
             AddTagToTable($tagTablePtr, '_JUMBF_' . $$et{JUMBFLabel}, $tagInfo);
             delete $$tagInfo{Protected}; # (must do this so -j -b returns JUMBF binary data)
             $$tagInfo{TagID} = $boxID;
@@ -1491,6 +1508,28 @@ sub ProcessJXLCodestream($$)
     return 1;
 }
 
+#------------------------------------------------------------------------------
+# Read/write meta information from a C2PA/JUMBF file
+# Inputs: 0) ExifTool object reference, 1) dirInfo reference
+# Returns: 1 on success, 0 if this wasn't a valid JUMBF file
+sub ProcessJUMBF($$)
+{
+    my ($et, $dirInfo) = @_;
+    my $raf = $$dirInfo{RAF};
+    my $hdr;
+
+    # check to be sure this is a valid JPG2000 file
+    return 0 unless $raf->Read($hdr,20) == 20 and $raf->Seek(0,0);
+    return 0 unless $hdr =~ /^.{4}jumb\0.{3}jumd(.{4})/;
+    $et->SetFileType($1 eq 'c2pa' ? 'C2PA' : 'JUMBF');
+    my %dirInfo = (
+        RAF => $raf,
+        DirName => 'JUMBF',
+    );
+    my $tagTablePtr = GetTagTable('Image::ExifTool::Jpeg2000::Main');
+    return $et->ProcessDirectory(\%dirInfo, $tagTablePtr);
+}
+
 #------------------------------------------------------------------------------
 # Read/write meta information from a JPEG 2000 image
 # Inputs: 0) ExifTool object reference, 1) dirInfo reference
@@ -1583,7 +1622,7 @@ sub ProcessJXL($$)
             $$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);
+            $$dirInfo{RAF} = File::RandomAccess->new(\$buff);
         } else {
             $et->SetFileType('JXL Codestream','image/jxl', 'jxl');
             if ($$et{ImageDataHash} and $raf->Seek(0,0)) {

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

@@ -14,7 +14,7 @@ use Image::ExifTool qw(:DataAccess :Utils);
 use Image::ExifTool::Exif;
 use Image::ExifTool::GPS;
 
-$VERSION = '1.52';
+$VERSION = '1.54';
 
 sub ProcessMIE($$);
 sub ProcessMIEGroup($$$);
@@ -1077,7 +1077,7 @@ sub WriteMIEGroup($$$)
                         $newVal = '';
                         %subdirInfo = (
                             OutFile => \$newVal,
-                            RAF => new File::RandomAccess(\$oldVal),
+                            RAF => File::RandomAccess->new(\$oldVal),
                         );
                     } elsif ($optCompress and not $$dirInfo{IsCompressed}) {
                         # write to memory so we can compress the new MIE group
@@ -1585,7 +1585,7 @@ sub ProcessMIEGroup($$$)
                 WasCompressed => $wasCompressed,
             );
             # read from uncompressed data instead if necessary
-            $subdirInfo{RAF} = new File::RandomAccess(\$value) if $valLen;
+            $subdirInfo{RAF} = File::RandomAccess->new(\$value) if $valLen;
 
             my $oldOrder = GetByteOrder();
             SetByteOrder($format & 0x08 ? 'II' : 'MM');

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

@@ -441,6 +441,7 @@ my %sRegionStruct = (
         Writable => 'real',
         Notes => 'not part of MWG 2.0 spec',
     },
+    # Title - seen in sample XMP of MWG 2.0 specification, but not in spec itself
     seeAlso => { Namespace => 'rdfs', Resource => 1 },
 );
 my %sKeywordStruct;

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

@@ -12,7 +12,7 @@ use strict;
 use vars qw($VERSION);
 use Image::ExifTool qw(:DataAccess :Utils);
 
-$VERSION = '1.12';
+$VERSION = '1.13';
 
 sub MDItemLocalTime($);
 sub ProcessATTR($$$);
@@ -22,6 +22,11 @@ my %mdDateInfo = (
     PrintConv => '$self->ConvertDateTime($val)',
 );
 
+my %delXAttr = (
+    XAttrQuarantine => 'com.apple.quarantine',
+    XAttrMDItemWhereFroms => 'com.apple.metadata:kMDItemWhereFroms',
+);
+
 # Information decoded from Mac OS sidecar files
 %Image::ExifTool::MacOS::Main = (
     GROUPS => { 0 => 'File', 1 => 'MacOS' },
@@ -320,7 +325,17 @@ my %mdDateInfo = (
         Groups => { 2 => 'Time' },
     },
     'com.apple.metadata:kMDItemFinderComment'  => { Name => 'XAttrMDItemFinderComment' },
-    'com.apple.metadata:kMDItemWhereFroms'     => { Name => 'XAttrMDItemWhereFroms' },
+    'com.apple.metadata:kMDItemWhereFroms' => {
+        Name => 'XAttrMDItemWhereFroms',
+        Writable => 1,
+        WritePseudo => 1,
+        WriteCheck => '"May only delete this tag"',
+        Protected => 1,
+        Notes => q{
+            information about where the file came from.  May only be deleted when
+            writing
+        },
+    },
     'com.apple.metadata:kMDLabel'              => { Name => 'XAttrMDLabel', Binary => 1 },
     'com.apple.ResourceFork'                   => { Name => 'XAttrResourceFork', Binary => 1 },
     'com.apple.lastuseddate#PS'                => {
@@ -407,9 +422,9 @@ sub SetMacOSTags($$$)
                 $et->VPrint(1,"    - $tag = (all)\n") if $overwrite > 0;
                 undef $val if $val eq '';
             }
-        } elsif ($tag eq 'XAttrQuarantine') {
+        } elsif ($delXAttr{$tag}) {
             ($f = $file) =~ s/'/'\\''/g;
-            $cmd = "/usr/bin/xattr -d com.apple.quarantine '${f}'";
+            $cmd = "/usr/bin/xattr -d $delXAttr{$tag} '${f}'";
             $silentErr = 256;   # (will get this error if attribute doesn't exist)
         } else {
             ($f = $file) =~ s/(["\\])/\\$1/g;   # escape necessary characters for script