exiftool_vendored 12.60.0 → 12.62.0

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

@@ -11,6 +11,7 @@
 #               4) http://DataCompression.info/ArchiveFormats/RAR202.txt
 #               5) https://jira.atlassian.com/browse/CONF-21706
 #               6) http://wwwimages.adobe.com/www.adobe.com/content/dam/Adobe/en/devnet/indesign/cs55-docs/IDML/idml-specification.pdf
+#               7) https://www.rarlab.com/technote.htm
 #------------------------------------------------------------------------------
 
 package Image::ExifTool::ZIP;
@@ -19,7 +20,7 @@ use strict;
 use vars qw($VERSION $warnString);
 use Image::ExifTool qw(:DataAccess :Utils);
 
-$VERSION = '1.28';
+$VERSION = '1.29';
 
 sub WarnProc($) { $warnString = $_[0]; }
 
@@ -191,7 +192,7 @@ my %iWorkType = (
     11 => 'Comment',
 );
 
-# RAR tags (ref 4)
+# RAR v4 tags (ref 4)
 %Image::ExifTool::ZIP::RAR = (
     PROCESS_PROC => \&Image::ExifTool::ProcessBinaryData,
     GROUPS => { 2 => 'Other' },
@@ -254,8 +255,45 @@ my %iWorkType = (
     },
 );
 
+# RAR v5 tags (ref 7, github#203)
+%Image::ExifTool::ZIP::RAR5 = (
+    GROUPS => { 2 => 'Other' },
+    VARS => { NO_ID => 1 },
+    NOTES => 'These tags are extracted from RAR v5 archive files.',
+    RARVersion      => { },
+    CompressedSize  => { },
+    ModifyDate => {
+        Groups => { 2 => 'Time' },
+        ValueConv => 'ConvertUnixTime($val,1)',
+        PrintConv => '$self->ConvertDateTime($val)',
+    },
+    UncompressedSize => { },
+    OperatingSystem => {
+        PrintConv => { 0 => 'Win32', 1 => 'Unix' },
+    },
+    ArchivedFileName => { },
+);
+
+#------------------------------------------------------------------------------
+# Read unsigned LEB (Little Endian Base) from file
+# Inputs: 0) RAF ref
+# Returns: integer value
+sub ReadULEB($)
+{
+    my $raf = shift;
+    my ($i, $buff);
+    my $rtnVal = 0;
+    for ($i=0; ; ++$i) {
+        $raf->Read($buff, 1) or last;
+        my $num = ord($buff);
+        $rtnVal += ($num & 0x7f) << ($i * 7);
+        $num & 0x80 or last;
+    }
+    return $rtnVal;
+}
+
 #------------------------------------------------------------------------------
-# Extract information from a RAR file (ref 4)
+# Extract information from a RAR file
 # Inputs: 0) ExifTool object reference, 1) dirInfo reference
 # Returns: 1 on success, 0 if this wasn't a valid RAR file
 sub ProcessRAR($$)
@@ -263,51 +301,129 @@ sub ProcessRAR($$)
     my ($et, $dirInfo) = @_;
     my $raf = $$dirInfo{RAF};
     my ($flags, $buff);
+    my $docNum = 0;
 
-    return 0 unless $raf->Read($buff, 7) and $buff eq "Rar!\x1a\x07\0";
+    return 0 unless $raf->Read($buff, 7) and $buff =~ "Rar!\x1a\x07[\0\x01]";
 
-    $et->SetFileType();
-    SetByteOrder('II');
-    my $tagTablePtr = GetTagTable('Image::ExifTool::ZIP::RAR');
-    my $docNum = 0;
+    if ($buff eq "Rar!\x1a\x07\0") { # RARv4 (ref 4)
 
-    for (;;) {
-        # read block header
-        $raf->Read($buff, 7) == 7 or last;
-        my ($type, $flags, $size) = unpack('xxCvv', $buff);
-        $size -= 7;
-        if ($flags & 0x8000) {
-            $raf->Read($buff, 4) == 4 or last;
-            $size += unpack('V',$buff) - 4;
-        }
-        last if $size < 0;
-        next unless $size;  # ignore blocks with no data
-        # don't try to read very large blocks unless LargeFileSupport is enabled
-        if ($size >= 0x80000000 and not $et->Options('LargeFileSupport')) {
-            $et->Warn('Large block encountered. Aborting.');
-            last;
+        $et->SetFileType();
+        SetByteOrder('II');
+        my $tagTablePtr = GetTagTable('Image::ExifTool::ZIP::RAR5');
+        $et->HandleTag($tagTablePtr, 'RARVersion', 4);
+        $tagTablePtr = GetTagTable('Image::ExifTool::ZIP::RAR');
+
+        for (;;) {
+            # read block header
+            $raf->Read($buff, 7) == 7 or last;
+            my ($type, $flags, $size) = unpack('xxCvv', $buff);
+            $size -= 7;
+            if ($flags & 0x8000) {
+                $raf->Read($buff, 4) == 4 or last;
+                $size += unpack('V',$buff) - 4;
+            }
+            last if $size < 0;
+            next unless $size;  # ignore blocks with no data
+            # don't try to read very large blocks unless LargeFileSupport is enabled
+            if ($size >= 0x80000000 and not $et->Options('LargeFileSupport')) {
+                $et->Warn('Large block encountered. Aborting.');
+                last;
+            }
+            # process the block
+            if ($type == 0x74) { # file block
+                # read maximum 4 KB from a file block
+                my $n = $size > 4096 ? 4096 : $size;
+                $raf->Read($buff, $n) == $n or last;
+                # add compressed size to start of data so we can extract it with the other tags
+                $buff = pack('V',$size) . $buff;
+                $$et{DOC_NUM} = ++$docNum;
+                $et->ProcessDirectory({ DataPt => \$buff }, $tagTablePtr);
+                $size -= $n;
+            } elsif ($type == 0x75 and $size > 6) { # comment block
+                $raf->Read($buff, $size) == $size or last;
+                # save comment, only if "Stored" (this is untested)
+                if (Get8u(\$buff, 3) == 0x30) {
+                    $et->FoundTag('Comment', substr($buff, 6));
+                }
+                next;
+            }
+            # seek to the start of the next block
+            $raf->Seek($size, 1) or last if $size;
         }
-        # process the block
-        if ($type == 0x74) { # file block
-            # read maximum 4 KB from a file block
-            my $n = $size > 4096 ? 4096 : $size;
-            $raf->Read($buff, $n) == $n or last;
-            # add compressed size to start of data so we can extract it with the other tags
-            $buff = pack('V',$size) . $buff;
-            $$et{DOC_NUM} = ++$docNum;
-            $et->ProcessDirectory({ DataPt => \$buff }, $tagTablePtr);
-            $size -= $n;
-        } elsif ($type == 0x75 and $size > 6) { # comment block
-            $raf->Read($buff, $size) == $size or last;
-            # save comment, only if "Stored" (this is untested)
-            if (Get8u(\$buff, 3) == 0x30) {
-                $et->FoundTag('Comment', substr($buff, 6));
+
+    } else { # RARv5 (ref 7, github#203)
+
+        return 0 unless $raf->Read($buff, 1) and $buff eq "\0";
+        $et->SetFileType();
+        my $tagTablePtr = GetTagTable('Image::ExifTool::ZIP::RAR5');
+        $et->HandleTag($tagTablePtr, 'RARVersion', 5);
+        $$et{INDENT} .= '| ';
+
+        # loop through header blocks
+        for (;;) {
+            $raf->Seek(4, 1);                   # skip header CRC
+            my $headSize = ReadULEB($raf);
+            last if $headSize == 0;
+            # read the header and create new RAF object for reading it
+            my $header;
+            $raf->Read($header, $headSize) == $headSize or last;
+            my $rafHdr = new File::RandomAccess(\$header);
+            my $headType = ReadULEB($rafHdr);   # get header type
+
+            if ($headType == 4) {  # encryption block
+                $et->Warn("File is encrypted.", 0);
+                last;
             }
-            next;
+            # skip over all headers except file or service header
+            next unless $headType == 2 or $headType == 3;
+            $et->VerboseDir('RAR5 file', undef, $headSize) if $headType == 2;
+            
+            my $headFlag = ReadULEB($rafHdr);
+            ReadULEB($rafHdr);                  # skip extraSize
+            my $dataSize;
+            if ($headFlag & 0x0002) {
+                $dataSize = ReadULEB($rafHdr);  # compressed data size
+                if ($headType == 2) {
+                    $et->HandleTag($tagTablePtr, 'CompressedSize', $dataSize);
+                } else {
+                    $raf->Seek($dataSize, 1);   # skip service data section
+                    next;
+                }
+            } else {
+                next if $headType == 3;         # all done with service header
+                $dataSize = 0;
+            }
+            my $fileFlag = ReadULEB($rafHdr);
+            my $uncompressedSize = ReadULEB($rafHdr);
+            $et->HandleTag($tagTablePtr, 'UncompressedSize', $uncompressedSize) unless $fileFlag & 0x0008;
+            ReadULEB($rafHdr);                  # skip file attributes
+            if ($fileFlag & 0x0002) {
+                $rafHdr->Read($buff, 4) == 4 or last;
+                # (untested)
+                $et->HandleTag($tagTablePtr, 'ModifyDate', unpack('V', $buff));
+            }
+            $rafHdr->Seek(4, 1) if $fileFlag & 0x0004;  # skip CRC if present
+
+            ReadULEB($rafHdr);                  # skip compressionInfo
+
+            # get operating system
+            my $os = ReadULEB($rafHdr);
+            $et->HandleTag($tagTablePtr, 'OperatingSystem', $os);
+
+            # get filename
+            $rafHdr->Read($buff, 1) == 1 or last;
+            my $nameLen = ord($buff);
+            $rafHdr->Read($buff, $nameLen) == $nameLen or last;
+            $buff =~ s/\0+$//;  # remove trailing nulls (if any)
+            $et->HandleTag($tagTablePtr, 'ArchivedFileName', $buff);
+
+            $$et{DOC_NUM} = ++$docNum;
+
+            $raf->Seek($dataSize, 1);           # skip data section
         }
-        # seek to the start of the next block
-        $raf->Seek($size, 1) or last if $size;
+        $$et{INDENT} = substr($$et{INDENT}, 0, -2);
     }
+
     $$et{DOC_NUM} = 0;
     if ($docNum > 1 and not $et->Options('Duplicates')) {
         $et->Warn("Use the Duplicates option to extract tags for all $docNum files", 1);
@@ -735,6 +851,8 @@ under the same terms as Perl itself.
 
 =item L<http://DataCompression.info/ArchiveFormats/RAR202.txt>
 
+=item L<https://www.rarlab.com/technote.htm>
+
 =back
 
 =head1 SEE ALSO

data/bin/lib/Image/ExifTool.pm

@@ -29,7 +29,7 @@ use vars qw($VERSION $RELEASE @ISA @EXPORT_OK %EXPORT_TAGS $AUTOLOAD @fileTypes
             %jpegMarker %specialTags %fileTypeLookup $testLen $exeDir
             %static_vars);
 
-$VERSION = '12.60';
+$VERSION = '12.62';
 $RELEASE = '';
 @ISA = qw(Exporter);
 %EXPORT_TAGS = (
@@ -142,8 +142,8 @@ sub ReadValue($$$;$$$);
 @loadAllTables = qw(
     PhotoMechanic Exif GeoTiff CanonRaw KyoceraRaw Lytro MinoltaRaw PanasonicRaw
     SigmaRaw JPEG GIMP Jpeg2000 GIF BMP BMP::OS2 BMP::Extra BPG BPG::Extensions
-    ICO PICT PNG MNG FLIF DjVu DPX OpenEXR ZISRAW MRC LIF MRC::FEI12 MIFF PCX
-    PGF PSP PhotoCD Radiance Other::PFM PDF PostScript Photoshop::Header
+    WPG ICO PICT PNG MNG FLIF DjVu DPX OpenEXR ZISRAW MRC LIF MRC::FEI12 MIFF
+    PCX PGF PSP PhotoCD Radiance Other::PFM PDF PostScript Photoshop::Header
     Photoshop::Layers Photoshop::ImageData FujiFilm::RAF FujiFilm::IFD
     Samsung::Trailer Sony::SRF2 Sony::SR2SubIFD Sony::PMP ITC ID3 ID3::Lyrics3
     FLAC Ogg Vorbis APE APE::NewHeader APE::OldHeader Audible MPC MPEG::Audio
@@ -152,8 +152,9 @@ sub ReadValue($$$;$$$);
     Real::Media Real::Audio Real::Metafile Red RIFF AIFF ASF WTV DICOM FITS MIE
     JSON HTML XMP::SVG Palm Palm::MOBI Palm::EXTH Torrent EXE EXE::PEVersion
     EXE::PEString EXE::MachO EXE::PEF EXE::ELF EXE::AR EXE::CHM LNK Font VCard
-    Text VCard::VCalendar VCard::VNote RSRC Rawzor ZIP ZIP::GZIP ZIP::RAR RTF
-    OOXML iWork ISO FLIR::AFF FLIR::FPF MacOS MacOS::MDItem FlashPix::DocTable
+    Text VCard::VCalendar VCard::VNote RSRC Rawzor ZIP ZIP::GZIP ZIP::RAR
+    ZIP::RAR5 RTF OOXML iWork ISO FLIR::AFF FLIR::FPF MacOS MacOS::MDItem
+    FlashPix::DocTable
 );
 
 # alphabetical list of current Lang modules
@@ -190,12 +191,12 @@ $defaultLang = 'en';    # default language
 # 3) PLIST must be in this list for the binary PLIST format, although it may
 #    cause a file to be checked twice for XML
 @fileTypes = qw(JPEG EXV CRW DR4 TIFF GIF MRW RAF X3F JP2 PNG MIE MIFF PS PDF
-                PSD XMP BMP BPG PPM RIFF AIFF ASF MOV MPEG Real SWF PSP FLV OGG
-                FLAC APE MPC MKV MXF DV PMP IND PGF ICC ITC FLIR FLIF FPF LFP
-                HTML VRD RTF FITS XCF DSS QTIF FPX PICT ZIP GZIP PLIST RAR BZ2
-                CZI TAR  EXE EXR HDR CHM LNK WMF AVC DEX DPX RAW Font RSRC M2TS
-                MacOS PHP PCX DCX DWF DWG DXF WTV Torrent VCard LRI R3D AA PDB
-                PFM2 MRC LIF JXL MOI ISO ALIAS JSON MP3 DICOM PCD ICO TXT);
+                PSD XMP BMP WPG BPG PPM RIFF AIFF ASF MOV MPEG Real SWF PSP FLV
+                OGG FLAC APE MPC MKV MXF DV PMP IND PGF ICC ITC FLIR FLIF FPF
+                LFP HTML VRD RTF FITS XCF DSS QTIF FPX PICT ZIP GZIP PLIST RAR
+                BZ2 CZI TAR  EXE EXR HDR CHM LNK WMF AVC DEX DPX RAW Font RSRC
+                M2TS MacOS PHP PCX DCX DWF DWG DXF WTV Torrent VCard LRI R3D AA
+                PDB PFM2 MRC LIF JXL MOI ISO ALIAS JSON MP3 DICOM PCD ICO TXT);
 
 # file types that we can write (edit)
 my @writeTypes = qw(JPEG TIFF GIF CRW MRW ORF RAF RAW PNG MIE PSD XMP PPM EPS
@@ -554,6 +555,7 @@ my %createTypes = map { $_ => 1 } qw(XMP ICC MIE VRD DR4 EXIF EXV);
     XMP  => ['XMP',  'Extensible Metadata Platform'],
     WOFF => ['Font', 'Web Open Font Format'],
     WOFF2=> ['Font', 'Web Open Font Format2'],
+    WPG  => ['WPG',  'WordPerfect Graphics'],
     WTV  => ['WTV',  'Windows recorded TV show'],
     ZIP  => ['ZIP',  'ZIP archive'],
 );
@@ -789,6 +791,7 @@ my %fileDescription = (
     WMA  => 'audio/x-ms-wma',
     WMF  => 'application/x-wmf',
     WMV  => 'video/x-ms-wmv',
+    WPG  => 'image/x-wpg',
     WTV  => 'video/x-ms-wtv',
     X3F  => 'image/x-sigma-x3f',
     XCF  => 'image/x-xcf',
@@ -970,7 +973,7 @@ $testLen = 1024;    # number of bytes to read when testing for magic number
     QTIF => '.{4}(idsc|idat|iicc)',
     R3D  => '\0\0..RED(1|2)',
     RAF  => 'FUJIFILM',
-    RAR  => 'Rar!\x1a\x07\0',
+    RAR  => 'Rar!\x1a\x07\x01?\0',
     RAW  => '(.{25}ARECOYK|II|MM)',
     Real => '(\.RMF|\.ra\xfd|pnm://|rtsp://|http://)',
     RIFF => '(RIFF|LA0[234]|OFR |LPAC|wvpk|RF64)', # RIFF plus other variants
@@ -984,6 +987,7 @@ $testLen = 1024;    # number of bytes to read when testing for magic number
     VCard=> '(?i)BEGIN:(VCARD|VCALENDAR|VNOTE)\r\n',
     VRD  => 'CANON OPTIONAL DATA\0',
     WMF  => '(\xd7\xcd\xc6\x9a\0\0|\x01\0\x09\0\0\x03)',
+    WPG  => '\xff\x57\x50\x43',
     WTV  => '\xb7\xd8\x00\x20\x37\x49\xda\x11\xa6\x4e\x00\x07\xe9\x5e\xad\x8d',
     X3F  => 'FOVb',
     XCF  => 'gimp xcf ',
@@ -1825,13 +1829,13 @@ my %systemTagsNotes = (
     },
     ImageDataMD5 => {
         Notes => q{
-            MD5 of image data. Generated only if specifically requested for JPEG and
-            TIFF-based images, PNG, CRW, CR3, MRW, RAF, X3F and AVIF images, MOV/MP4
-            videos, and some RIFF-based files.  The MD5 includes the main image data,
-            plus JpgFromRaw/OtherImage for some formats, but does not include
-            ThumbnailImage or PreviewImage.  Includes video and audio data for MOV/MP4. 
-            The L<XMP-et:OriginalImageMD5 tag|XMP.html#ExifTool> provides a place to
-            store these values in the file.
+            MD5 of image data. Generated only if specifically requested for JPEG, TIFF,
+            PNG, CRW, CR3, MRW, RAF, X3F, IIQ, JP2, JXL, HEIC and AVIF images, MOV/MP4
+            videos, and some RIFF-based files such as AVI, WAV and WEBP.  The MD5
+            includes the main image data, plus JpgFromRaw/OtherImage for some formats,
+            but does not include ThumbnailImage or PreviewImage.  Includes video and
+            audio data for MOV/MP4. The L<XMP-et:OriginalImageMD5 tag|XMP.html#ExifTool>
+            provides a place to store these values in the file.
         },
     },
 );
@@ -2125,8 +2129,10 @@ sub Options($$;@)
 
     while (@_) {
         my $param = shift;
+        my $plus;
         # fix parameter case if necessary
         unless (exists $$options{$param}) {
+            $plus = $param =~ s/\+$//;
             my ($fixed) = grep /^$param$/i, keys %$options;
             if ($fixed) {
                 $param = $fixed;
@@ -2291,6 +2297,23 @@ sub Options($$;@)
                 $compact{$p} = $val; # preserve most recent setting
             }
             $$options{Compact} = $$options{XMPShorthand} = \%compact;
+        } elsif ($param eq 'NoWarning') {
+            # validate regular expression
+            undef $evalWarning;
+            if (defined $newVal) {
+                local $SIG{'__WARN__'} = \&SetWarning;
+                eval { $param =~ /$newVal/ };
+                $@ and $evalWarning = $@;
+            }
+            if ($evalWarning) {
+                warn 'NoWarning: ' . CleanWarning() . "\n";
+                next;
+            }
+            # add to existing expression if specified
+            if ($plus and defined $oldVal) {
+                $newVal = defined $newVal ? "$oldVal|$newVal" : $oldVal;
+            }
+            $$options{$param} = $newVal;
         } else {
             if ($param eq 'Escape') {
                 # set ESCAPE_PROC
@@ -2385,6 +2408,7 @@ sub ClearOptions($)
         MissingTagValue =>undef,# value for missing tags when expanded in expressions
         NoMultiExif => undef,   # raise error when writing multi-segment EXIF
         NoPDFList   => undef,   # flag to avoid splitting PDF List-type tag values
+        NoWarning   => undef,   # regular expression for warnings to suppress
         Password    => undef,   # password for password-protected PDF documents
         PrintConv   => 1,       # flag to enable print conversion
         QuickTimeHandler => 1,  # flag to add mdir Handler to newly created Meta box
@@ -2503,23 +2527,6 @@ sub ExtractInfo($;@)
             }
         }
         ++$$self{FILE_SEQUENCE};        # count files read
-        # extract information from alternate files if necessary
-        my ($g8, $altExifTool);
-        foreach $g8 (keys %{$$self{ALT_EXIFTOOL}}) {
-            $altExifTool = $$self{ALT_EXIFTOOL}{$g8};
-            next if $$altExifTool{DID_EXTRACT}; # avoid extracting twice
-            $$altExifTool{OPTIONS} = $$self{OPTIONS};
-            $$altExifTool{GLOBAL_TIME_OFFSET} = $$self{GLOBAL_TIME_OFFSET};
-            $$altExifTool{REQ_TAG_LOOKUP} = $$self{REQ_TAG_LOOKUP};
-            $altExifTool->ExtractInfo($$altExifTool{ALT_FILE});
-            # set family 8 group name for all tags
-            foreach (keys %{$$altExifTool{VALUE}}) {
-                my $ex = $$altExifTool{TAG_EXTRA}{$_};
-                $ex or $ex = $$altExifTool{TAG_EXTRA}{$_} = { };
-                $$ex{G8} = $g8;
-            }
-            $$altExifTool{DID_EXTRACT} = 1;
-        }
     }
 
     my $filename = $$self{FILENAME};    # image file name ('' if already open)
@@ -2661,7 +2668,7 @@ sub ExtractInfo($;@)
         if ($isDir or (defined $stat[2] and ($stat[2] & 0170000) == 0040000)) {
             $self->FoundTag('FileType', 'DIR');
             $self->FoundTag('FileTypeExtension', '');
-            $self->BuildCompositeTags() if $$options{Composite};
+            $self->ExtractAltInfo();
             $raf->Close() if $raf;
             return 1;
         }
@@ -2679,7 +2686,7 @@ sub ExtractInfo($;@)
             } else {
                 $self->Error('Unknown file type');
             }
-            $self->BuildCompositeTags() if $fast == 4 and $$options{Composite};
+            $self->ExtractAltInfo();
             last;   # don't read the file
         }
         if (@fileTypeList) {
@@ -2845,8 +2852,7 @@ sub ExtractInfo($;@)
         }
         unless ($reEntry) {
             $$self{PATH} = [ ];     # reset PATH
-            # calculate Composite tags
-            $self->BuildCompositeTags() if $$options{Composite};
+            $self->ExtractAltInfo();
             # do our HTML dump if requested
             if ($$self{HTML_DUMP}) {
                 $raf->Seek(0, 2);   # seek to end of file
@@ -3648,14 +3654,15 @@ sub SetNewGroups($;@)
 
 #------------------------------------------------------------------------------
 # Build Composite tags from Require'd/Desire'd tags
-# Inputs: 0) ExifTool object reference
+# Inputs: 0) ExifTool object reference, 1) flag to build only tags that require
+#         tags from alternate files (without this, these tags are ignored)
 # Note: Tag values are calculated in alphabetical order unless a tag Require's
 #       or Desire's another Composite tag, in which case the calculation is
 #       deferred until after the other tag is calculated.
 sub BuildCompositeTags($)
 {
     local $_;
-    my $self = shift;
+    my ($self, $altOnly) = @_;
 
     $$self{BuildingComposite} = 1;
 
@@ -3684,7 +3691,7 @@ COMPOSITE_TAG:
             # loop through sub-documents if necessary
             my $docNum = 0;
             for (;;) {
-                my (%tagKey, $found, $index);
+                my (%tagKey, $found, $index, $requireAlt);
                 # save Require'd and Desire'd tag values in list
                 for ($index=0; ; ++$index) {
                     my $reqTag = $$require{$index} || $$desire{$index} || $$inhibit{$index};
@@ -3739,6 +3746,8 @@ COMPOSITE_TAG:
                         if ($reqTag =~ /\b(File\d+):/i and $$self{ALT_EXIFTOOL}{$1}) {
                             $et = $$self{ALT_EXIFTOOL}{$1};
                             $altFile = $1;
+                            # set flags indicating we require tags from alternate files
+                            $$self{DoAltComposite} = $requireAlt = 1;
                         }
                         # (CAREFUL! keys may not be sequential if one was deleted)
                         for ($key=$name, $i=$$et{DUPL_TAG}{$name} || 0; ; --$i) {
@@ -3770,6 +3779,8 @@ COMPOSITE_TAG:
                     }
                     $tagKey{$index} = $reqTag;
                 }
+                # stop now if this requires alternate tags and we aren't building them
+                last if $requireAlt xor $altOnly;
                 if ($docNum) {
                     if ($found) {
                         $$self{DOC_NUM} = $docNum;
@@ -4067,6 +4078,49 @@ sub CombineInfo($;@)
     return \%combinedInfo;
 }
 
+#------------------------------------------------------------------------------
+# Read metadata from alternate files and build composite tags
+# Inputs: 0) ExifTool ref
+# Notes: This is called after reading the main file so the tags are available
+#        for being used in the file name, but before building Composite tags
+#        so tags from the alternate files may be used in the Composite tags
+sub ExtractAltInfo($)
+{
+    my $self = shift;
+    # extract information from alternate files if necessary
+    my ($g8, $altExifTool);
+    my $opts = $$self{OPTIONS};
+    if ($$opts{Composite} and (not $$opts{FastScan} or $$opts{FastScan} < 5)) {
+        # build all composite tags except those requiring tags from alternate files
+        $self->BuildCompositeTags();
+    }
+    foreach $g8 (sort keys %{$$self{ALT_EXIFTOOL}}) {
+        $altExifTool = $$self{ALT_EXIFTOOL}{$g8};
+        next if $$altExifTool{DID_EXTRACT}; # avoid extracting twice
+        $$altExifTool{OPTIONS} = $$self{OPTIONS};
+        $$altExifTool{GLOBAL_TIME_OFFSET} = $$self{GLOBAL_TIME_OFFSET};
+        $$altExifTool{REQ_TAG_LOOKUP} = $$self{REQ_TAG_LOOKUP};
+        my $fileName = $$altExifTool{ALT_FILE};
+        # allow tags from the main file to be used in the alternate file names
+        # (eg. -file1 '$originalfilename')
+        if ($fileName =~ /\$/) {
+            my @tags = reverse sort keys %{$$self{VALUE}};
+            $fileName = $self->InsertTagValues(\@tags, $fileName, 'Warn');
+            next unless defined $fileName;
+        }
+        $altExifTool->ExtractInfo($fileName);
+        # set family 8 group name for all tags
+        foreach (keys %{$$altExifTool{VALUE}}) {
+            my $ex = $$altExifTool{TAG_EXTRA}{$_};
+            $ex or $ex = $$altExifTool{TAG_EXTRA}{$_} = { };
+            $$ex{G8} = $g8;
+        }
+        $$altExifTool{DID_EXTRACT} = 1;
+    }
+    # if necessary, build composite tags that rely on tags from alternate files
+    $self->BuildCompositeTags(1) if $$self{DoAltComposite};
+}
+
 #------------------------------------------------------------------------------
 # Get tag table name
 # Inputs: 0) ExifTool object reference, 1) tag key
@@ -4917,12 +4971,14 @@ sub AUTOLOAD
 sub Warn($$;$)
 {
     my ($self, $str, $ignorable) = @_;
+    my $noWarn = $self->Options('NoWarning');
     if ($ignorable) {
         return 0 if $$self{OPTIONS}{IgnoreMinorErrors};
         return 0 if $ignorable eq '3' and $$self{OPTIONS}{Validate};
+        return 1 if defined $noWarn and eval { $str =~ /$noWarn/ };
         $str = $ignorable eq '2' ? "[Minor] $str" : "[minor] $str";
     }
-    $self->FoundTag('Warning', $str);
+    $self->FoundTag('Warning', $str) unless defined $noWarn and eval { $str =~ /$noWarn/ };
     return 1;
 }
 
@@ -6432,12 +6488,12 @@ sub ProcessJPEG($$)
     my $htmlDump = $$self{HTML_DUMP};
     my %dumpParms = ( Out => $out );
     my ($ch, $s, $length, $md5, $md5size);
-    my ($success, $wantTrailer, $trailInfo, $foundSOS, %jumbfChunk);
+    my ($success, $wantTrailer, $trailInfo, $foundSOS, $gotSize, %jumbfChunk);
     my (@iccChunk, $iccChunkCount, $iccChunksTotal, @flirChunk, $flirCount, $flirTotal);
     my ($preview, $scalado, @dqt, $subSampling, $dumpEnd, %extendedXMP);
 
-    # get pointer to MD5 object if it exists and we are the top-level JPEG
-    if ($$self{FILE_TYPE} eq 'JPEG' and not $$self{DOC_NUM}) {
+    # get pointer to MD5 object if it exists and we are the top-level JPEG or JP2
+    if ($$self{FILE_TYPE} =~ /^(JPEG|JP2)$/ and not $$self{DOC_NUM}) {
         $md5 = $$self{ImageDataMD5};
         $md5size = 0;
     }
@@ -6561,7 +6617,8 @@ sub ProcessJPEG($$)
                 $self->HDump($segPos-4, $length+4, "[JPEG $markerName]", undef, 0x08);
                 $dumpEnd = $segPos + $length;
             }
-            next unless $length >= 6;
+            next if $length < 6 or $gotSize;
+            $gotSize = 1; # (ignore subsequent SOF segments in probably corrupted JPEG)
             # extract some useful information
             my ($p, $h, $w, $n) = unpack('Cn2C', $$segDataPt);
             my $sof = GetTagTable('Image::ExifTool::JPEG::SOF');
@@ -6751,6 +6808,11 @@ sub ProcessJPEG($$)
             pop @$path;
             $verbose and print $out "JPEG SOD\n";
             $success = 1;
+            if ($md5 and $$self{FILE_TYPE} eq 'JP2') {
+                my $pos = $raf->Tell();
+                $self->ImageDataMD5($raf, undef, 'SOD');
+                $raf->Seek($pos, 0);
+            }
             next if $verbose > 2 or $htmlDump;
             last;   # all done parsing file
         } elsif (defined $markerLenBytes{$marker}) {
@@ -7483,8 +7545,11 @@ sub ProcessJPEG($$)
             }
         } elsif ($marker == 0x51) {         # SIZ (J2C)
             my ($w, $h) = unpack('x2N2', $$segDataPt);
-            $self->FoundTag('ImageWidth', $w);
-            $self->FoundTag('ImageHeight', $h);
+            unless ($gotSize) {
+                $gotSize = 1;
+                $self->FoundTag('ImageWidth', $w);
+                $self->FoundTag('ImageHeight', $h);
+            }
         } elsif (($marker & 0xf0) != 0xe0) {
             $dumpType = "$markerName segment";
             $desc = "[JPEG $markerName]";   # (other known JPEG segments)
@@ -7824,6 +7889,9 @@ sub DoProcessTIFF($$;$)
         if ($$self{TIFF_TYPE} eq 'TIFF') {
             $self->FoundTag(PageCount => $$self{PageCount}) if $$self{MultiPage};
         }
+        if ($$self{ImageDataMD5} and $$self{A100DataOffset} and $raf->Seek($$self{A100DataOffset},0)) {
+            $self->ImageDataMD5($raf, undef, 'A100');
+        }
         return 1;
     }
 #