exiftool-vendored.pl 12.60.0 → 12.65.0

package/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.65';
 $RELEASE = '';
 @ISA = qw(Exporter);
 %EXPORT_TAGS = (
@@ -114,7 +114,7 @@ sub WriteTIFF($$$);
 sub PackUTF8(@);
 sub UnpackUTF8($);
 sub SetPreferredByteOrder($;$);
-sub ImageDataMD5($$$;$$);
+sub ImageDataHash($$$;$$);
 sub CopyBlock($$$);
 sub CopyFileAttrs($$$);
 sub TimeNow(;$$);
@@ -126,7 +126,7 @@ sub MakeTiffHeader($$$$;$$);
 sub SplitFileName($);
 sub EncodeFileName($$;$);
 sub Open($*$;$);
-sub Exists($$);
+sub Exists($$;$);
 sub IsDirectory($$);
 sub Rename($$$);
 sub Unlink($@);
@@ -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
+                7Z 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
@@ -227,6 +228,7 @@ my %createTypes = map { $_ => 1 } qw(XMP ICC MIE VRD DR4 EXIF EXV);
    '3GP' => ['MOV',  '3rd Gen. Partnership Project audio/video'],
    '3GP2'=>  '3G2',
    '3GPP'=>  '3GP',
+   '7Z'  => ['7Z', '7z archive'],
     A    => ['EXE',  'Static library'],
     AA   => ['AA',   'Audible Audiobook'],
     AAE  => ['PLIST','Apple edit information'],
@@ -328,6 +330,7 @@ my %createTypes = map { $_ => 1 } qw(XMP ICC MIE VRD DR4 EXIF EXV);
     FPF  => ['FPF',  'FLIR Public image Format'],
     FPX  => ['FPX',  'FlashPix'],
     GIF  => ['GIF',  'Compuserve Graphics Interchange Format'],
+    GLV  => ['MOV',  'Garmin Low-resolution Video'],
     GPR  => ['TIFF', 'General Purpose RAW'], # https://gopro.github.io/gpr/
     GZ   =>  'GZIP',
     GZIP => ['GZIP', 'GNU ZIP compressed archive'],
@@ -554,6 +557,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'],
 );
@@ -588,6 +592,7 @@ my %fileDescription = (
 #  types may be specified by some modules, eg. QuickTime.pm and RIFF.pm)
 %mimeType = (
    '3FR' => 'image/x-hasselblad-3fr',
+   '7Z'  => 'application/x-7z-compressed',
     AA   => 'audio/audible',
     AAE  => 'application/vnd.apple.photos',
     AI   => 'application/vnd.adobe.illustrator',
@@ -789,6 +794,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 +976,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 +990,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 ',
@@ -1045,6 +1052,93 @@ my %xmpShorthandOpt = ( 0 => 'None', 1 => 'Shorthand', 2 => ['Shorthand','OneDes
     maccroatian => 'MacCroatian', cp10082 => 'MacCroatian',
 );
 
+# list of available options
+# +-----------------------------------------------------+
+# ! DON'T FORGET!!  When adding any new option, must    !
+# ! decide how it is handled in SetNewValuesFromFile()  !
+# +-----------------------------------------------------+
+# (Note: All options must exist in this lookup, even if undefined,
+# to facilitate case-insensitive options. 'Group#' is handled specially)
+my @availableOptions = (
+    [ 'Binary',           undef,  'flag to extract binary values even if tag not specified' ],
+    [ 'ByteOrder',        undef,  'default byte order when creating EXIF information' ],
+    [ 'Charset',          'UTF8', 'character set for converting Unicode characters' ],
+    [ 'CharsetEXIF',      undef,  'internal EXIF "ASCII" string encoding' ],
+    [ 'CharsetFileName',  undef,  'external encoding for file names' ],
+    [ 'CharsetID3',       'Latin','internal ID3v1 character set' ],
+    [ 'CharsetIPTC',      'Latin','fallback IPTC character set if no CodedCharacterSet' ],
+    [ 'CharsetPhotoshop', 'Latin','internal encoding for Photoshop resource names' ],
+    [ 'CharsetQuickTime', 'MacRoman', 'internal QuickTime string encoding' ],
+    [ 'CharsetRIFF',      0,      'internal RIFF string encoding (0=default to Latin)' ],
+    [ 'Compact',          { },    'write compact XMP' ],
+    [ 'Composite',        1,      'flag to calculate Composite tags' ],
+    [ 'Compress',         undef,  'flag to write new values as compressed if possible' ],
+    [ 'CoordFormat',      undef,  'GPS lat/long coordinate format' ],
+    [ 'DateFormat',       undef,  'format for date/time' ],
+    [ 'Duplicates',       1,      'flag to save duplicate tag values' ],
+    [ 'Escape',           undef,  'escape special characters' ],
+    [ 'Exclude',          undef,  'tags to exclude' ],
+    [ 'ExtendedXMP',      1,      'strategy for reading extended XMP' ],
+    [ 'ExtractEmbedded',  undef,  'flag to extract information from embedded documents' ],
+    [ 'FastScan',         undef,  'flag to avoid scanning for trailer' ],
+    [ 'Filter',           undef,  'output filter for all tag values' ],
+    [ 'FilterW',          undef,  'input filter when writing tag values' ],
+    [ 'FixBase',          undef,  'fix maker notes base offsets' ],
+    [ 'GeoMaxIntSecs',    1800,   'geotag maximum interpolation time (secs)' ],
+    [ 'GeoMaxExtSecs',    1800,   'geotag maximum extrapolation time (secs)' ],
+    [ 'GeoMaxHDOP',       undef,  'geotag maximum HDOP' ],
+    [ 'GeoMaxPDOP',       undef,  'geotag maximum PDOP' ],
+    [ 'GeoMinSats',       undef,  'geotag minimum satellites' ],
+    [ 'GeoSpeedRef',      undef,  'geotag GPSSpeedRef' ],
+    [ 'GlobalTimeShift',  undef,  'apply time shift to all extracted date/time values' ],
+    [ 'Group#',           undef,  'return tags for specified groups in family #' ],
+    [ 'HexTagIDs',        0,      'use hex tag ID\'s in family 7 group names' ],
+    [ 'HtmlDump',         0,      'HTML dump (0-3, higher # = bigger limit)' ],
+    [ 'HtmlDumpBase',     undef,  'base address for HTML dump' ],
+    [ 'IgnoreMinorErrors',undef,  'ignore minor errors when reading/writing' ],
+    [ 'IgnoreTags',       undef,  'list of tags to ignore when extracting' ],
+    [ 'ImageHashType',    'MD5',  'image hash algorithm' ],
+    [ 'Lang',       $defaultLang, 'localized language for descriptions etc' ],
+    [ 'LargeFileSupport', undef,  'flag indicating support of 64-bit file offsets' ],
+    [ 'List',             undef,  '[deprecated, use ListSplit and ListJoin instead]' ],
+    [ 'ListItem',         undef,  'used to return a specific item from lists' ],
+    [ 'ListJoin',         ', ',   'join lists together with this separator' ],
+    [ 'ListSep',          ', ',   '[deprecated, use ListSplit and ListJoin instead]' ],
+    [ 'ListSplit',        undef,  'regex for splitting list-type tag values when writing' ],
+    [ 'MakerNotes',       undef,  'extract maker notes as a block' ],
+    [ 'MDItemTags',       undef,  'extract MacOS metadata item tags' ],
+    [ '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' ],
+    [ 'QuickTimePad',     undef,  'flag to preserve padding of QuickTime CR3 tags' ],
+    [ 'QuickTimeUTC',     undef,  'assume that QuickTime date/time tags are stored as UTC' ],
+    [ 'RequestAll',       undef,  'extract all tags that must be specifically requested' ],
+    [ 'RequestTags',      undef,  'extra tags to request (on top of those in the tag list)' ],
+    [ 'SaveFormat',       undef,  'save family 6 tag TIFF format' ],
+    [ 'SavePath',         undef,  'save family 5 location path' ],
+    [ 'ScanForXMP',       undef,  'flag to scan for XMP information in all files' ],
+    [ 'Sort',             'Input','order to sort found tags (Input, File, Tag, Descr, Group#)' ],
+    [ 'Sort2',            'File', 'secondary sort order for tags in a group (File, Tag, Descr)' ],
+    [ 'StrictDate',       undef,  'flag to return undef for invalid date conversions' ],
+    [ 'Struct',           undef,  'return structures as hash references' ],
+    [ 'StructFormat',     undef,  'format for structure serialization when reading/writing' ],
+    [ 'SystemTags',       undef,  'extract additional File System tags' ],
+    [ 'TextOut',        \*STDOUT, 'file for Verbose/HtmlDump output' ],
+    [ 'TimeZone',         undef,  'local time zone' ],
+    [ 'Unknown',          0,      'flag to get values of unknown tags (0-2)' ],
+    [ 'UserParam',        { },    'user parameters for additional user-defined tag values' ],
+    [ 'Validate',         undef,  'perform additional validation' ],
+    [ 'Verbose',          0,      'print verbose messages (0-5, higher # = more verbose)' ],
+    [ 'WriteMode',        'wcg',  'enable all write modes by default' ],
+    [ 'XAttrTags',        undef,  'extract MacOS extended attribute tags' ],
+    [ 'XMPAutoConv',      1,      'automatic conversion of unknown XMP tag values' ],
+    [ 'XMPShorthand',     0,      '[deprecated, use Compact=Shorthand instead]' ],
+);
+
 # default family 0 group priority for writing
 # (NOTE: tags in groups not specified here will not be written unless
 #  overridden by the module or specified when writing)
@@ -1823,15 +1917,17 @@ my %systemTagsNotes = (
             if specifically requested
         },
     },
-    ImageDataMD5 => {
+    ImageDataHash => {
         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.
+            Hash 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 hash
+            algorithm is set by the API L<ImageHashType|../ExifTool.html#ImageHashType> option, and is 'MD5' by default.
+            The hash 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:OriginalImageHash and
+            XMP-et:OriginalImageHashType tags|XMP.html#ExifTool> provide a way to store
+            the this hash value and the hash type in the file.
         },
     },
 );
@@ -2125,8 +2221,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 +2389,35 @@ 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;
+        } elsif ($param eq 'ImageHashType') {
+            if (defined $newVal and $newVal =~ /^(MD5|SHA256|SHA512)$/i) {
+                $$options{$param} = uc($newVal);
+            } else {
+                warn("Invalid $param setting '${newVal}'\n"), return $oldVal;
+            }
+        } elsif ($param eq 'StructFormat') {
+            if (defined $newVal) {
+                $newVal =~ /^(JSON|JSONQ)$/i or warn("Invalid $param setting '${newVal}'\n"), return $oldVal;
+                $newVal = uc($newVal);
+            }
+            $$options{$param} = $newVal;
         } else {
             if ($param eq 'Escape') {
                 # set ESCAPE_PROC
@@ -2328,89 +2455,11 @@ sub ClearOptions($)
     local $_;
     my $self = shift;
 
-    # create options hash with default values
-    # +-----------------------------------------------------+
-    # ! DON'T FORGET!!  When adding any new option, must    !
-    # ! decide how it is handled in SetNewValuesFromFile()  !
-    # +-----------------------------------------------------+
-    # (Note: All options must exist in this lookup, even if undefined,
-    # to facilitate case-insensitive options. 'Group#' is handled specially)
-    $$self{OPTIONS} = {
-        Binary      => undef,   # flag to extract binary values even if tag not specified
-        ByteOrder   => undef,   # default byte order when creating EXIF information
-        Charset     => 'UTF8',  # character set for converting Unicode characters
-        CharsetEXIF => undef,   # internal EXIF "ASCII" string encoding
-        CharsetFileName => undef,   # external encoding for file names
-        CharsetID3  => 'Latin', # internal ID3v1 character set
-        CharsetIPTC => 'Latin', # fallback IPTC character set if no CodedCharacterSet
-        CharsetPhotoshop => 'Latin', # internal encoding for Photoshop resource names
-        CharsetQuickTime => 'MacRoman', # internal QuickTime string encoding
-        CharsetRIFF => 0,       # internal RIFF string encoding (0=default to Latin)
-        Compact     => { },     # write compact XMP
-        Composite   => 1,       # flag to calculate Composite tags
-        Compress    => undef,   # flag to write new values as compressed if possible
-        CoordFormat => undef,   # GPS lat/long coordinate format
-        DateFormat  => undef,   # format for date/time
-        Duplicates  => 1,       # flag to save duplicate tag values
-        Escape      => undef,   # escape special characters
-        Exclude     => undef,   # tags to exclude
-        ExtendedXMP => 1,       # strategy for reading extended XMP
-        ExtractEmbedded =>undef,# flag to extract information from embedded documents
-        FastScan    => undef,   # flag to avoid scanning for trailer
-        Filter      => undef,   # output filter for all tag values
-        FilterW     => undef,   # input filter when writing tag values
-        FixBase     => undef,   # fix maker notes base offsets
-        GeoMaxIntSecs => 1800,  # geotag maximum interpolation time (secs)
-        GeoMaxExtSecs => 1800,  # geotag maximum extrapolation time (secs)
-        GeoMaxHDOP  => undef,   # geotag maximum HDOP
-        GeoMaxPDOP  => undef,   # geotag maximum PDOP
-        GeoMinSats  => undef,   # geotag minimum satellites
-        GeoSpeedRef => undef,   # geotag GPSSpeedRef
-        GlobalTimeShift => undef,   # apply time shift to all extracted date/time values
-    #   Group#      => undef,   # return tags for specified groups in family #
-        HexTagIDs   => 0,       # use hex tag ID's in family 7 group names
-        HtmlDump    => 0,       # HTML dump (0-3, higher # = bigger limit)
-        HtmlDumpBase => undef,  # base address for HTML dump
-        IgnoreMinorErrors => undef, # ignore minor errors when reading/writing
-        IgnoreTags  => undef,   # list of tags to ignore when extracting
-        Lang        => $defaultLang,# localized language for descriptions etc
-        LargeFileSupport => undef,  # flag indicating support of 64-bit file offsets
-        List        => undef,   # extract lists of PrintConv values into arrays [no longer documented]
-        ListItem    => undef,   # used to return a specific item from lists
-        ListJoin    => ', ',    # join lists together with this separator
-        ListSep     => ', ',    # list item separator [no longer documented]
-        ListSplit   => undef,   # regex for splitting list-type tag values when writing
-        MakerNotes  => undef,   # extract maker notes as a block
-        MDItemTags  => undef,   # extract MacOS metadata item tags
-        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
-        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
-        QuickTimePad=> undef,   # flag to preserve padding of QuickTime CR3 tags
-        QuickTimeUTC=> undef,   # assume that QuickTime date/time tags are stored as UTC
-        RequestAll  => undef,   # extract all tags that must be specifically requested
-        RequestTags => undef,   # extra tags to request (on top of those in the tag list)
-        SaveFormat  => undef,   # save family 6 tag TIFF format
-        SavePath    => undef,   # save family 5 location path
-        ScanForXMP  => undef,   # flag to scan for XMP information in all files
-        Sort        => 'Input', # order to sort found tags (Input, File, Tag, Descr, Group#)
-        Sort2       => 'File',  # secondary sort order for tags in a group (File, Tag, Descr)
-        StrictDate  => undef,   # flag to return undef for invalid date conversions
-        Struct      => undef,   # return structures as hash references
-        SystemTags  => undef,   # extract additional File System tags
-        TextOut     => \*STDOUT,# file for Verbose/HtmlDump output
-        TimeZone    => undef,   # local time zone
-        Unknown     => 0,       # flag to get values of unknown tags (0-2)
-        UserParam   => { },     # user parameters for additional user-defined tag values
-        Validate    => undef,   # perform additional validation
-        Verbose     => 0,       # print verbose messages (0-5, higher # = more verbose)
-        WriteMode   => 'wcg',   # enable all write modes by default
-        XAttrTags   => undef,   # extract MacOS extended attribute tags
-        XMPAutoConv => 1,       # automatic conversion of unknown XMP tag values
-        XMPShorthand=> 0,       # (unused, but needed for backward compatibility)
-    };
+    $$self{OPTIONS} = { };  # clear all options
+
+    # load default options
+    $$self{OPTIONS}{$$_[0]} = $$_[1] foreach @availableOptions;
+
     # keep necessary member variables in sync with options
     delete $$self{CUR_LANG};
     delete $$self{ESCAPE_PROC};
@@ -2494,32 +2543,22 @@ sub ExtractInfo($;@)
             }
         }
         
-        # create MD5 object if ImageDataMD5 is requested
-        if ($$req{imagedatamd5} and not $$self{ImageDataMD5}) {
-            if (require Digest::MD5) {
-                $$self{ImageDataMD5} = Digest::MD5->new;
+        # create Hash object if ImageDataHash is requested
+        if ($$req{imagedatahash} and not $$self{ImageDataHash}) {
+            my $imageHashType = $self->Options('ImageHashType');
+            if ($imageHashType =~ /^SHA(256|512)$/i) {
+                if (require Digest::SHA) {
+                    $$self{ImageDataHash} = Digest::SHA->new($1);
+                } else {
+                    $self->WarnOnce("Install Digest::SHA to calculate image data SHA$1");
+                }
+            } elsif (require Digest::MD5) {
+                $$self{ImageDataHash} = Digest::MD5->new;
             } else {
                 $self->WarnOnce('Install Digest::MD5 to calculate image data MD5');
             }
         }
         ++$$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 +2700,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 +2718,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 +2884,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
@@ -2909,10 +2947,13 @@ sub ExtractInfo($;@)
         # restore necessary members when exiting re-entrant code
         $$self{$_} = $$reEntry{$_} foreach keys %$reEntry;
         SetByteOrder($saveOrder);
-    } elsif ($$self{ImageDataMD5}) {
-        my $digest = $$self{ImageDataMD5}->hexdigest;
+    } elsif ($$self{ImageDataHash}) {
+        my $digest = $$self{ImageDataHash}->hexdigest;
         # (don't store empty digest)
-        $self->FoundTag(ImageDataMD5 => $digest) unless $digest eq 'd41d8cd98f00b204e9800998ecf8427e';
+        $self->FoundTag(ImageDataHash => $digest) unless
+            $digest eq 'd41d8cd98f00b204e9800998ecf8427e' or
+            $digest eq 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855' or
+            $digest eq 'cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e';
     }
 
     # ($type may be undef without an Error when processing sub-documents)
@@ -3648,14 +3689,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 +3726,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 +3781,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 +3814,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;
@@ -3850,6 +3896,15 @@ sub GetCompositeTagInfo($)
     return $Image::ExifTool::Composite{$compositeID{$tag}[0]};
 }
 
+#------------------------------------------------------------------------------
+# Return List ExifTool API options
+# Returns: 0) reference to list of available options -- each entry is a list
+#            [0=option name, 1=default value, 2=description]
+sub AvailableOptions()
+{
+    return \@availableOptions;
+}
+
 #------------------------------------------------------------------------------
 # Get tag name (removes copy index)
 # Inputs: 0) Tag key
@@ -4067,6 +4122,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
@@ -4291,11 +4389,11 @@ sub Open($*$;$)
 
 #------------------------------------------------------------------------------
 # Check to see if a file exists (with Windows Unicode support)
-# Inputs: 0) ExifTool ref, 1) file name
+# Inputs: 0) ExifTool ref, 1) file name, 2) flag if we are writing this file
 # Returns: true if file exists
-sub Exists($$)
+sub Exists($$;$)
 {
-    my ($self, $file) = @_;
+    my ($self, $file, $writing) = @_;
 
     if ($self->EncodeFileName($file)) {
         local $SIG{'__WARN__'} = \&SetWarning;
@@ -4305,10 +4403,12 @@ sub Exists($$)
                         Win32API::File::OPEN_EXISTING(), 0, []) };
         return 0 unless $wh;
         eval { Win32API::File::CloseHandle($wh) };
-    } else {
+    } elsif ($writing) {
         # (named pipes already exist, but we pretend that they don't
         #  so we will be able to write them, so test with for pipe -p)
         return(-e $file and not -p $file);
+    } else {
+        return(-e $file);
     }
     return 1;
 }
@@ -4811,6 +4911,7 @@ sub SetFoundTags($)
                 $groupList = [ $$options{$groupOpt} ];
             }
             foreach (@$groupList) {
+                next unless defined $_;
                 # groups have priority in order they were specified
                 ++$wantOrder;
                 my ($groupName, $want);
@@ -4917,12 +5018,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;
 }
 
@@ -5526,6 +5629,7 @@ my %formatSize = (
     ifd => 4,
     ifd64 => 8,
     ue7 => 1,
+    utf8 => 1, # (Exif 3.0)
 );
 my %readValueProc = (
     int8s => \&Get8s,
@@ -5740,7 +5844,8 @@ sub MakeTagName($)
     my $name = shift;
     $name =~ tr/-_a-zA-Z0-9//dc;    # remove illegal characters
     $name = ucfirst $name;          # capitalize first letter
-    $name = "Tag$name" if length($name) < 2; # must at least 2 characters long
+    $name = "Tag$name" if length($name) < 2 or $name =~ /^[-0-9]/;
+    # must at least 2 characters long and not start with - or 0-9-
     return $name;
 }
 
@@ -6431,15 +6536,15 @@ sub ProcessJPEG($$)
     my $req = $$self{REQ_TAG_LOOKUP};
     my $htmlDump = $$self{HTML_DUMP};
     my %dumpParms = ( Out => $out );
-    my ($ch, $s, $length, $md5, $md5size);
-    my ($success, $wantTrailer, $trailInfo, $foundSOS, %jumbfChunk);
+    my ($ch, $s, $length, $hash, $hashsize);
+    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}) {
-        $md5 = $$self{ImageDataMD5};
-        $md5size = 0;
+    # get pointer to hash object if it exists and we are the top-level JPEG or JP2
+    if ($$self{FILE_TYPE} =~ /^(JPEG|JP2)$/ and not $$self{DOC_NUM}) {
+        $hash = $$self{ImageDataHash};
+        $hashsize = 0;
     }
 
     # check to be sure this is a valid JPG (or J2C, or EXV) file
@@ -6488,7 +6593,7 @@ sub ProcessJPEG($$)
 #
 # read ahead to the next segment unless we have reached EOI, SOS or SOD
 #
-        unless ($marker and ($marker==0xd9 or ($marker==0xda and not $wantTrailer and not $md5) or
+        unless ($marker and ($marker==0xd9 or ($marker==0xda and not $wantTrailer and not $hash) or
             $marker==0x93))
         {
             # read up to next marker (JPEG markers begin with 0xff)
@@ -6520,19 +6625,19 @@ sub ProcessJPEG($$)
                 $nextSegPos = $raf->Tell();
                 $len -= 4;  # subtract size of length word
                 last unless $raf->Seek($len, 1);
-            } elsif ($md5 and defined $marker and ($marker == 0x00 or $marker == 0xda or
+            } elsif ($hash and defined $marker and ($marker == 0x00 or $marker == 0xda or
                 ($marker >= 0xd0 and $marker <= 0xd7)))
             {
-                # calculate MD5 for image data (includes leading ff d9 but not trailing ff da)
-                $md5->add("\xff" . chr($marker));
+                # calculate hash for image data (includes leading ff d9 but not trailing ff da)
+                $hash->add("\xff" . chr($marker));
                 my $n = $skipped - (length($buff) - 1); # number of extra 0xff's
                 if (not $n) {
                     $buff = substr($buff, 0, -1);       # remove trailing 0xff
                 } elsif ($n > 1) {
                     $buff .= "\xff" x ($n - 1);         # add back extra 0xff's
                 }
-                $md5->add($buff);
-                $md5size += $skipped + 2;
+                $hash->add($buff);
+                $hashsize += $skipped + 2;
             }
             # read second segment too if this was the first
             next unless defined $marker;
@@ -6561,7 +6666,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');
@@ -6743,7 +6849,7 @@ sub ProcessJPEG($$)
                 next if $trailInfo or $wantTrailer or $verbose > 2 or $htmlDump;
             }
             # must scan to EOI if Validate or JpegCompressionFactor used
-            next if $$options{Validate} or $calcImageLen or $$req{trailer} or $md5;
+            next if $$options{Validate} or $calcImageLen or $$req{trailer} or $hash;
             # nothing interesting to parse after start of scan (SOS)
             $success = 1;
             last;   # all done parsing file
@@ -6751,6 +6857,11 @@ sub ProcessJPEG($$)
             pop @$path;
             $verbose and print $out "JPEG SOD\n";
             $success = 1;
+            if ($hash and $$self{FILE_TYPE} eq 'JP2') {
+                my $pos = $raf->Tell();
+                $self->ImageDataHash($raf, undef, 'SOD');
+                $raf->Seek($pos, 0);
+            }
             next if $verbose > 2 or $htmlDump;
             last;   # all done parsing file
         } elsif (defined $markerLenBytes{$marker}) {
@@ -6767,7 +6878,7 @@ sub ProcessJPEG($$)
             or ($$options{RequestAll} and $$options{RequestAll} > 2)))
         {
             my $num = unpack('C',$$segDataPt) & 0x0f;   # get table index
-            $dqt[$num] = $$segDataPt if $num < 4;       # save for MD5 calculation
+            $dqt[$num] = $$segDataPt if $num < 4;       # save for hash calculation
         }
         # handle all other markers
         my $dumpType = '';
@@ -7115,9 +7226,6 @@ sub ProcessJPEG($$)
                     $self->HandleTag($tagTablePtr, 'APP3', $$dataPt);
                     undef $combinedSegData;
                 }
-            } elsif ($$self{HasIJPEG}) {
-                $dumpType = 'InfiRay Data',
-                
             } elsif ($$segDataPt =~ /^\xff\xd8\xff\xdb/) {
                 $dumpType = 'PreviewImage'; # (Samsung, HP, BenQ)
                 $preview = $$segDataPt;
@@ -7483,8 +7591,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)
@@ -7547,8 +7658,8 @@ sub ProcessJPEG($$)
             delete $extendedXMP{$guid};
         }
     }
-    # print verbose MD5 message if necessary
-    print $out "$$self{INDENT}(ImageDataMD5: $md5size bytes of JPEG image data)\n" if $md5size and $verbose;
+    # print verbose hash message if necessary
+    print $out "$$self{INDENT}(ImageDataHash: $hashsize bytes of JPEG image data)\n" if $hashsize and $verbose;
     # calculate JPEGDigest if requested
     if (@dqt) {
         require Image::ExifTool::JPEGDigest;
@@ -7743,6 +7854,8 @@ sub DoProcessTIFF($$;$)
                     return 1;
                 }
             }
+        } elsif ($fileType eq 'ARW') {
+            $$self{LOW_PRIORITY_DIR}{IFD1} = 1; # lower priority of IFD1 tags in ARW files
         }
         # we have a valid TIFF (or whatever) file
         if ($fileType and not $$self{VALUE}{FileType}) {
@@ -7824,6 +7937,9 @@ sub DoProcessTIFF($$;$)
         if ($$self{TIFF_TYPE} eq 'TIFF') {
             $self->FoundTag(PageCount => $$self{PageCount}) if $$self{MultiPage};
         }
+        if ($$self{ImageDataHash} and $$self{A100DataOffset} and $raf->Seek($$self{A100DataOffset},0)) {
+            $self->ImageDataHash($raf, undef, 'A100');
+        }
         return 1;
     }
 #