exiftool_vendored 12.25.0 → 12.32.0

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.34';
+$VERSION = '4.36';
 
 sub ProcessExif($$$);
 sub WriteExif($$$);
@@ -2581,7 +2581,7 @@ my %opcodeInfo = (
     0xa301 => {
         Name => 'SceneType',
         Writable => 'undef',
-        ValueConvInv => 'chr($val)',
+        ValueConvInv => 'chr($val & 0xff)',
         PrintConv => {
             1 => 'Directly photographed',
         },
@@ -5918,7 +5918,7 @@ sub ProcessExif($$$)
         my $size = $count * $formatSize[$format];
         my $readSize = $size;
         if ($size > 4) {
-            if ($size > 0x7fffffff) {
+            if ($size > 0x7fffffff and (not $tagInfo or not $$tagInfo{ReadFromRAF})) {
                 $et->Warn(sprintf("Invalid size (%u) for %s %s",$size,$dir,TagName($tagID,$tagInfo)), $inMakerNotes);
                 ++$warnCount;
                 next;
@@ -6171,18 +6171,23 @@ sub ProcessExif($$$)
         unless ($bad) {
             # limit maximum length of data to reformat
             # (avoids long delays when processing some corrupted files)
+            my $warned;
             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);
+                    if ($et->Warn("Ignoring $dirName $tagName with excessive count", $minor)) {
+                        next unless $$et{OPTIONS}{HtmlDump};
+                        $warned = 1;
+                    }
                 }
             }
             if ($count > 500 and $formatStr !~ /^(undef|string|binary)$/ and
-                (not $tagInfo or $$tagInfo{LongBinary}) and not $$et{OPTIONS}{IgnoreMinorErrors})
+                (not $tagInfo or $$tagInfo{LongBinary} or $warned) and not $$et{OPTIONS}{IgnoreMinorErrors})
             {
-                $et->WarnOnce('Not decoding some large array(s). Ignore minor errors to decode', 2);
+                $et->WarnOnce('Not decoding some large array(s). Ignore minor errors to decode', 2) unless $warned;
+                next if $$et{TAGS_FROM_FILE};   # don't generate bogus value when copying tags
                 $val = "(large array of $count $formatStr values)";
             } else {
                 # convert according to specified format

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

@@ -21,7 +21,7 @@ use Image::ExifTool qw(:DataAccess :Utils);
 use Image::ExifTool::Exif;
 use Image::ExifTool::ASF;   # for GetGUID()
 
-$VERSION = '1.38';
+$VERSION = '1.39';
 
 sub ProcessFPX($$);
 sub ProcessFPXR($$$);
@@ -1369,29 +1369,48 @@ sub ReadFPXValue($$$$$;$$)
         my $flags = $type & 0xf000;
         if ($flags) {
             if ($flags == VT_VECTOR) {
-                $noPad = 1;     # values don't seem to be padded inside vectors
+                $noPad = 1;     # values sometimes aren't padded inside vectors!!
                 my $size = $oleFormatSize{VT_VECTOR};
-                last if $valPos + $size > $dirEnd;
+                if ($valPos + $size > $dirEnd) {
+                    $et->WarnOnce('Incorrect FPX VT_VECTOR size');
+                    last;
+                }
                 $count = Get32u($dataPt, $valPos);
                 push @vals, '' if $count == 0;  # allow zero-element vector
                 $valPos += 4;
             } else {
                 # can't yet handle this property flag
+                $et->WarnOnce('Unknown FPX property');
                 last;
             }
         }
         unless ($format =~ /^VT_/) {
             my $size = Image::ExifTool::FormatSize($format) * $count;
-            last if $valPos + $size > $dirEnd;
+            if ($valPos + $size > $dirEnd) {
+                $et->WarnOnce("Incorrect FPX $format size");
+                last;
+            }
             @vals = ReadValue($dataPt, $valPos, $format, $count, $size);
             # update position to end of value plus padding
             $valPos += ($count * $size + 3) & 0xfffffffc;
             last;
         }
         my $size = $oleFormatSize{$format};
-        my ($item, $val);
+        my ($item, $val, $len);
         for ($item=0; $item<$count; ++$item) {
-            last if $valPos + $size > $dirEnd;
+            if ($valPos + $size > $dirEnd) {
+                $et->WarnOnce("Truncated FPX $format value");
+                last;
+            }
+            # sometimes VT_VECTOR items are padded to even 4-byte boundaries, and sometimes they aren't
+            if ($noPad and defined $len and $len & 0x03) {
+                my $pad = 4 - ($len & 0x03);
+                if ($valPos + $pad + $size <= $dirEnd) {
+                    # skip padding if all zeros
+                    $valPos += $pad if substr($$dataPt, $valPos, $pad) eq "\0" x $pad;
+                }
+            }
+            undef $len;
             if ($format eq 'VT_VARIANT') {
                 my $subType = Get32u($dataPt, $valPos);
                 $valPos += $size;
@@ -1429,9 +1448,12 @@ sub ReadFPXValue($$$$$;$$)
                 $val = ($val - 25569) * 24 * 3600 if $val != 0;
                 $val = Image::ExifTool::ConvertUnixTime($val);
             } elsif ($format =~ /STR$/) {
-                my $len = Get32u($dataPt, $valPos);
+                $len = Get32u($dataPt, $valPos);
                 $len *= 2 if $format eq 'VT_LPWSTR';    # convert to byte count
-                last if $valPos + $len + 4 > $dirEnd;
+                if ($valPos + $len + 4 > $dirEnd) {
+                    $et->WarnOnce("Truncated $format value");
+                    last;
+                }
                 $val = substr($$dataPt, $valPos + 4, $len);
                 if ($format eq 'VT_LPWSTR') {
                     # convert wide string from Unicode
@@ -1450,8 +1472,11 @@ sub ReadFPXValue($$$$$;$$)
                 #  on even 32-bit boundaries, but this isn't always the case)
                 $valPos += $noPad ? $len : ($len + 3) & 0xfffffffc;
             } elsif ($format eq 'VT_BLOB' or $format eq 'VT_CF') {
-                my $len = Get32u($dataPt, $valPos);
-                last if $valPos + $len + 4 > $dirEnd;
+                my $len = Get32u($dataPt, $valPos); # (use local $len because we always expect padding)
+                if ($valPos + $len + 4 > $dirEnd) {
+                    $et->WarnOnce("Truncated $format value");
+                    last;
+                }
                 $val = substr($$dataPt, $valPos + 4, $len);
                 # update position for data length plus padding
                 # (does this padding disappear in arrays too?)

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

@@ -489,6 +489,7 @@ my %faceCategories = (
             3 => 'Electronic Front Curtain', #10
         },
     },
+    # 0x1100 - This may not work well for newer cameras (ref forum12682)
     0x1100 => [{
         Name => 'AutoBracketing',
         Condition => '$$self{Model} eq "X-T3"',

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

@@ -28,7 +28,7 @@ use vars qw($VERSION);
 use Image::ExifTool qw(:Public);
 use Image::ExifTool::GPS;
 
-$VERSION = '1.64';
+$VERSION = '1.65';
 
 sub JITTER() { return 2 }       # maximum time jitter
 
@@ -262,8 +262,10 @@ sub LoadTrackLog($$;$)
                         $param = 'time';
                     } elsif (/^(Pos)?Lat/i) {
                         $param = 'lat';
+                        /ref$/i and $param .= 'ref';
                     } elsif (/^(Pos)?Lon/i) {
                         $param = 'lon';
+                        /ref$/i and $param .= 'ref';
                     } elsif (/^(Pos)?Alt/i) {
                         $param = 'alt';
                     } elsif (/^(Angle)?(Heading|Track)/i) {
@@ -453,7 +455,7 @@ DoneFix:    $isDate = 1;
 # (ExifTool enhancements allow for standard tag names or descriptions as the column headings,
 #  add support for time zones and flexible coordinates, and allow new DateTime and Shift columns)
 #
-            my ($param, $date, $secs);
+            my ($param, $date, $secs, %neg);
             foreach $param (@csvHeadings) {
                 my $val = shift @vals;
                 last unless defined $val;
@@ -479,6 +481,10 @@ DoneFix:    $isDate = 1;
                     }
                 } elsif ($param eq 'lat' or $param eq 'lon') {
                     $$fix{$param} = Image::ExifTool::GPS::ToDegrees($val, 1);
+                } elsif ($param eq 'latref') {
+                    $neg{lat} = 1 if $val =~ /^S/i;
+                } elsif ($param eq 'lonref') {
+                    $neg{lon} = 1 if $val =~ /^W/i;
                 } elsif ($param eq 'runtime') {
                     $date = $trackTime;
                     $secs = $val;
@@ -486,6 +492,11 @@ DoneFix:    $isDate = 1;
                     $$fix{$param} = $val;
                 }
             }
+            # make coordinate negative according to reference direction if necessary
+            foreach $param (keys %neg) {
+                next unless defined $$fix{$param};
+                $$fix{$param} = -abs($$fix{$param});
+            }
             if ($date and defined $secs and defined $$fix{lat} and defined $$fix{lon}) {
                 $time = $date + $secs;
                 $$has{alt} = 1 if defined $$fix{alt};

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

@@ -16,7 +16,7 @@ use vars qw($VERSION);
 use Image::ExifTool qw(:DataAccess :Utils);
 use Image::ExifTool::QuickTime;
 
-$VERSION = '1.06';
+$VERSION = '1.07';
 
 sub ProcessGoPro($$$);
 sub ProcessString($$$);
@@ -386,6 +386,21 @@ my %addUnits = (
         Binary => 1,
     },
   # ZFOV (APP6,GPMF) - seen: 148.34, 0 (fmt f, Hero8, Max)
+  # the following ref forum12825
+    MUID => {
+        Name => 'MediaUniqueID',
+        PrintConv => q{
+            my @a = split ' ', $val;
+            $_ = sprintf('%.8x',$_) foreach @a;
+            return join('', @a);
+        },
+    },
+    EXPT => 'MaximumShutterAngle',
+    MTRX => 'AccelerometerMatrix',
+    ORIN => 'InputOrientation',
+    ORIO => 'OutputOrientation',
+    UNIF => 'InputUniformity',
+    SROT => 'SensorReadoutTime',
 );
 
 # GoPro GPS5 tags (ref 2) (Hero5,Hero6)

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

@@ -18,11 +18,12 @@ use strict;
 use vars qw($VERSION);
 use Image::ExifTool qw(:DataAccess :Utils);
 
-$VERSION = '1.55';
+$VERSION = '1.57';
 
 sub ProcessID3v2($$$);
 sub ProcessPrivate($$$);
 sub ProcessSynText($$$);
+sub ProcessID3Dir($$$);
 sub ConvertID3v1Text($$);
 sub ConvertTimeStamp($);
 
@@ -69,9 +70,10 @@ my %dateTimeConv = (
 # This table is just for documentation purposes
 %Image::ExifTool::ID3::Main = (
     VARS => { NO_ID => 1 },
+    PROCESS_PROC => \&ProcessID3Dir, # (used to process 'id3 ' chunk in WAV files)
     NOTES => q{
-        ExifTool extracts ID3 and Lyrics3 information from MP3, MPEG, AIFF, OGG,
-        FLAC, APE, MPC and RealAudio files.  ID3v2 tags which support multiple
+        ExifTool extracts ID3 and Lyrics3 information from MP3, MPEG, WAV, AIFF,
+        OGG, FLAC, APE, MPC and RealAudio files.  ID3v2 tags which support multiple
         languages (eg. Comment and Lyrics) are extracted by specifying the tag name,
         followed by a dash ('-'), then a 3-character ISO 639-2 language code (eg.
         "Comment-spa"). See L<http://www.id3.org/> for the official ID3
@@ -1570,6 +1572,16 @@ sub ProcessID3($$)
     return $rtnVal;
 }
 
+#------------------------------------------------------------------------------
+# Process ID3 directory
+# Inputs: 0) ExifTool object reference, 1) dirInfo reference, 2) dummy tag table ref
+sub ProcessID3Dir($$$)
+{
+    my ($et, $dirInfo, $tagTablePtr) = @_;
+    $et->VerboseDir('ID3', undef, length ${$$dirInfo{DataPt}});
+    return ProcessID3($et, $dirInfo);
+}
+
 #------------------------------------------------------------------------------
 # Extract ID3 information from an MP3 audio file
 # Inputs: 0) ExifTool object reference, 1) dirInfo reference

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

@@ -11,7 +11,7 @@ use strict;
 use vars qw($VERSION);
 use Image::ExifTool qw(:DataAccess :Utils);
 
-$VERSION = '1.30';
+$VERSION = '1.32';
 
 sub ProcessOcad($$$);
 sub ProcessJPEG_HDR($$$);
@@ -96,6 +96,10 @@ sub ProcessJPEG_HDR($$$);
         Name => 'Stim',
         Condition => '$$valPt =~ /^Stim\0/',
         SubDirectory => { TagTable => 'Image::ExifTool::Stim::Main' },
+      }, {
+        Name => 'JPS',
+        Condition => '$$valPt =~ /^_JPSJPS_/',
+        SubDirectory => { TagTable => 'Image::ExifTool::JPEG::JPS' },
       }, {
         Name => 'ThermalData', # (written by DJI FLIR models)
         Condition => '$$self{Make} eq "DJI"',
@@ -287,6 +291,68 @@ sub ProcessJPEG_HDR($$$);
     }],
 );
 
+# JPS APP3 segment (ref http://paulbourke.net/stereographics/stereoimage/)
+%Image::ExifTool::JPEG::JPS = (
+    PROCESS_PROC => \&Image::ExifTool::ProcessBinaryData,
+    GROUPS => { 0 => 'APP3', 1 => 'JPS', 2 => 'Image' },
+    NOTES => 'Tags found in JPEG Stereo (JPS) images.',
+    0x0a => {
+        Name => 'JPSSeparation',
+        Format => 'int32u', # (just so we can look ahead to MediaType);
+        Notes => 'stereo only',
+        RawConv => q{
+            $$self{MediaType} = $val & 0xff;
+            return undef unless $$self{MediaType} == 1;
+            return(($val >> 24) & 0xff);
+        },
+    },
+    0x08 => {
+        Name => 'HdrLength',
+        Format => 'int16u',
+        Hidden => 1,
+        RawConv => '$$self{HdrLength} = $val; undef',
+    },
+    0x0b => {
+        Name => 'JPSFlags',
+        PrintConv => { BITMASK => {
+            0 => 'Half height',
+            1 => 'Half width',
+            2 => 'Left field first',
+        }},
+    },
+    0x0c => [{
+        Name => 'JPSLayout',
+        Condition => '$$self{MediaType} == 0',
+        Notes => 'mono',
+        PrintConv => {
+            0 => 'Both Eyes',
+            1 => 'Left Eye',
+            2 => 'Right Eye',
+        },
+    },{
+        Name => 'JPSLayout',
+        Condition => '$$self{MediaType} == 1',
+        Notes => 'stereo',
+        PrintConv => {
+            1 => 'Interleaved',
+            2 => 'Side By Side',
+            3 => 'Over Under',
+            4 => 'Anaglyph',
+        },
+    }],
+    0x0d => {
+        Name => 'JPSType',
+        Hook => '$varSize += $$self{HdrLength} - 4', # comment starts after header block
+        PrintConv => { 0 => 'Mono', 1 => 'Stereo' },
+    },
+    # 0x0e - in16u comment length (ignored -- assume the remainder is all comment)
+    #        (this is offset if we had a 4-byte JPS header block)
+    0x10 => {
+        Name => 'JPSComment',
+        Format => 'string',
+    },
+);
+
 # EPPIM APP6 (Toshiba PrintIM) segment (ref PH, from PDR-M700 samples)
 %Image::ExifTool::JPEG::EPPIM = (
     GROUPS => { 0 => 'APP6', 1 => 'EPPIM', 2 => 'Image' },
@@ -545,7 +611,7 @@ sub ProcessJPEG_HDR($$$);
     },
     2 => {
         Name => 'ImageFormat',
-        ValueConv => 'chr($val)',
+        ValueConv => 'chr($val & 0xff)',
         PrintConv => { B => 'IMode B' },
     },
     3 => {

data/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.03';
+$VERSION = '1.04';
 
 sub ProcessJSON($$);
 sub ProcessTag($$$$%);
@@ -83,7 +83,9 @@ sub ProcessTag($$$$%)
             FoundTag($et, $tagTablePtr, $tag, $val, %flags, Struct => 1);
             return unless $et->Options('Struct') > 1;
         }
-        foreach (sort keys %$val) {
+        # support hashes with ordered keys
+        my @keys = $$val{_ordered_keys_} ? @{$$val{_ordered_keys_}} : sort keys %$val;
+        foreach (@keys) {
             ProcessTag($et, $tagTablePtr, $tag . ucfirst, $$val{$_}, %flags, Flat => 1);
         }
     } elsif (ref $val eq 'ARRAY') {

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

@@ -16,7 +16,7 @@ use strict;
 use vars qw($VERSION);
 use Image::ExifTool qw(:DataAccess :Utils);
 
-$VERSION = '1.29';
+$VERSION = '1.31';
 
 sub ProcessJpeg2000Box($$$);
 sub ProcessJUMD($$$);
@@ -116,9 +116,6 @@ 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 = (
@@ -127,10 +124,13 @@ my %jumbfTypes = (
     WRITE_PROC => \&ProcessJpeg2000Box,
     PREFERRED => 1, # always add these tags when writing
     NOTES => q{
-        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.
+        The tags below are found in JPEG 2000 images and the JUMBF metadata in JPEG
+        images, but not all of these are extracted.  Note that ExifTool currently
+        writes only EXIF, IPTC and XMP tags in Jpeg2000 images.
     },
+#
+# NOTE: ONLY TAGS WITH "Format" DEFINED ARE EXTRACTED!
+#
    'jP  ' => 'JP2Signature', # (ref 1)
    "jP\x1a\x1a" => 'JP2Signature', # (ref 2)
     prfl => 'Profile',
@@ -344,6 +344,14 @@ my %jumbfTypes = (
             Format => 'undef',
             ValueConv => 'substr($val,16)',
         },
+        {
+            Name => 'UUID-C2PAClaimSignature',  # (seen in JUMB data of JPEG images)
+            Condition => '$$valPt=~/^c2cs\x00\x11\x00\x10\x80\x00\x00\xaa\x00\x38\x9b\x71/',
+            SubDirectory => {
+                TagTable => 'Image::ExifTool::CBOR::Main',
+                Start => '$valuePtr + 16',
+            },
+        },
         {
             Name => 'UUID-Unknown',
         },
@@ -386,6 +394,27 @@ my %jumbfTypes = (
         },
         SubDirectory => { TagTable => 'Image::ExifTool::JSON::Main' },
     },
+    cbor => {
+        Name => 'CBORData',
+        Flags => [ 'Binary', 'Protected' ],
+        SubDirectory => { TagTable => 'Image::ExifTool::CBOR::Main' },
+    },
+    bfdb => { # used in JUMBF (see  # (used when tag is renamed according to JUMDLabel)
+        Name => 'BinaryDataType',
+        Notes => 'JUMBF, MIME type and optional file name',
+        Format => 'undef',
+        # (ignore "toggles" byte and just extract MIME type and file name)
+        ValueConv => '$_=substr($val,1); s/\0+$//; s/\0/, /; $_',
+        JUMBF_Suffix => 'Type', # (used when tag is renamed according to JUMDLabel)
+    },
+    bidb => { # used in JUMBF
+        Name => 'BinaryData',
+        Notes => 'JUMBF',
+        Groups => { 2 => 'Preview' },
+        Format => 'undef',
+        Binary => 1,
+        JUMBF_Suffix => 'Data', # (used when tag is renamed according to JUMDLabel)
+    },
 #
 # stuff seen in JPEG XL images:
 #
@@ -607,23 +636,24 @@ my %jumbfTypes = (
     PROCESS_PROC => \&ProcessJUMD,
     GROUPS => { 0 => 'JUMBF', 1 => 'JUMBF', 2 => 'Image' },
     NOTES => 'Information extracted from the JUMBF description box.',
-    'jumd-type' => {
+    '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}$/;
+            $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',
+    'label' => { Name => 'JUMDLabel' },
+    'toggles' => {
+        Name => 'JUMDToggles',
+        Unknown => 1,
         PrintConv => { BITMASK => {
             0 => 'Requestable',
             1 => 'Label',
@@ -631,8 +661,8 @@ my %jumbfTypes = (
             3 => 'Signature',
         }},
     },
-    'jumd-id'    => { Name => 'JUMDID', Description => 'JUMD ID' },
-    'jumd-sig'   => { Name => 'JUMDSignature', PrintConv => 'unpack "H*", $val' },
+    'id'    => { Name => 'JUMDID', Description => 'JUMD ID' },
+    'sig'   => { Name => 'JUMDSignature', PrintConv => 'unpack "H*", $val' },
 );
 
 #------------------------------------------------------------------------------
@@ -675,20 +705,21 @@ sub ProcessJUMD($$$)
     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));
+    $et->HandleTag($tagTablePtr, 'type', substr($$dataPt, $pos, 16));
     $pos += 16;
     my $flags = Get8u($dataPt, $pos++);
-    $et->HandleTag($tagTablePtr, 'jumd-flags', $flags);
+    $et->HandleTag($tagTablePtr, 'toggles', $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);
+        $et->HandleTag($tagTablePtr, '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 =~ s/__/_/;               # collapse double underlines
             $name = ucfirst $name;          # capitalize first letter
             $name = "Tag$name" if length($name) < 2; # must at least 2 characters long
             $$et{JUMBFLabel} = $name;
@@ -696,12 +727,12 @@ sub ProcessJUMD($$$)
     }
     if ($flags & 0x04) {    # ID exists?
         $pos + 4 > $end and $et->Warn('Missing JUMD ID'), return 0;
-        $et->HandleTag($tagTablePtr, 'jumd-id', Get32u($dataPt, $pos));
+        $et->HandleTag($tagTablePtr, '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));
+        $et->HandleTag($tagTablePtr, 'sig', substr($$dataPt, $pos, 32));
         $pos += 32;
     }
     $pos == $end or $et->Warn('Extra data in JUMD box'." $pos $end", 1);
@@ -931,6 +962,14 @@ 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};
+            AddTagToTable($tagTablePtr, '_JUMBF_' . $$et{JUMBFLabel}, $tagInfo);
+            delete $$tagInfo{Protected}; # (must do this so -j -b returns JUMBF binary data)
+            $$tagInfo{TagID} = $boxID;
+        }
         if ($verbose) {
             $et->VerboseInfo($boxID, $tagInfo,
                 Table  => $tagTablePtr,
@@ -941,13 +980,6 @@ 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;