exiftool-vendored.exe 12.67.0 → 12.70.0

package/bin/exiftool_files/lib/Image/ExifTool/EXE.pm

@@ -21,7 +21,7 @@ use strict;
 use vars qw($VERSION);
 use Image::ExifTool qw(:DataAccess :Utils);
 
-$VERSION = '1.18';
+$VERSION = '1.19';
 
 sub ProcessPEResources($$);
 sub ProcessPEVersion($$);
@@ -726,6 +726,7 @@ my %languageCode = (
         Name => 'CPUType',
         Format => 'int16u',
         # ref /usr/include/linux/elf-em.h
+        # ref https://en.wikipedia.org/wiki/Executable_and_Linkable_Format
         PrintConv => {
             0 => 'None',
             1 => 'AT&T WE 32100',
@@ -736,21 +737,68 @@ my %languageCode = (
             6 => 'i486',
             7 => 'i860',
             8 => 'MIPS R3000',
+            9 => 'IBM System/370',
             10 => 'MIPS R4000',
-            15 => 'HPPA',
+            15 => 'HP PA-RISC',
             18 => 'Sun v8plus',
+            19 => 'Intel 80960',
             20 => 'PowerPC',
             21 => 'PowerPC 64-bit',
             22 => 'IBM S/390',
             23 => 'Cell BE SPU',
+            36 => 'NEC V800',
+            37=> 'Fujitsu FR20',
+            38 => 'TRW RH-32',
+            39 => 'Motorola RCE',
+            40 => 'Arm (up to Armv7/AArch32)',
+            41 => 'Digital Alpha',
             42 => 'SuperH',
             43 => 'SPARC v9 64-bit',
+            44 => 'Siemens TriCore',
+            45 => 'Argonaut RISC Core',
             46 => 'Renesas H8/300,300H,H8S',
+            47 => 'Hitachi H8/300H',
+            48 => 'Hitachi H8S',
+            49 => 'Hitachi H8/500',
             50 => 'HP/Intel IA-64',
-            62 => 'AMD x86-64',
-            76 => 'Axis Communications 32-bit embedded processor',
-            87 => 'NEC v850',
-            88 => 'Renesas M32R',
+            0x33 => 'Stanford MIPS-X',
+            0x34 => 'Motorola ColdFire',
+            0x35 => 'Motorola M68HC12',
+            0x36 => 'Fujitsu MMA Multimedia Accelerator',
+            0x37 => 'Siemens PCP',
+            0x38 => 'Sony nCPU embedded RISC processor',
+            0x39 => 'Denso NDR1 microprocessor',
+            0x3a => 'Motorola Star*Core processor',
+            0x3b => 'Toyota ME16 processor',
+            0x3c => 'STMicroelectronics ST100 processor',
+            0x3d => 'Advanced Logic Corp. TinyJ embedded processor family',
+            0x3e => 'AMD x86-64',
+            0x3f => 'Sony DSP Processor',
+            0x40 => 'Digital Equipment Corp. PDP-10',
+            0x41 => 'Digital Equipment Corp. PDP-11',
+            0x42 => 'Siemens FX66 microcontroller',
+            0x43 => 'STMicroelectronics ST9+ 8/16 bit microcontroller',
+            0x44 => 'STMicroelectronics ST7 8-bit microcontroller',
+            0x45 => 'Motorola MC68HC16 Microcontroller',
+            0x46 => 'Motorola MC68HC11 Microcontroller',
+            0x47 => 'Motorola MC68HC08 Microcontroller',
+            0x48 => 'Motorola MC68HC05 Microcontroller',
+            0x49 => 'Silicon Graphics SVx',
+            0x4a => 'STMicroelectronics ST19 8-bit microcontroller',
+            0x4b => 'Digital VAX',
+            0x4c => 'Axis Communications 32-bit embedded processor',
+            0x4d => 'Infineon Technologies 32-bit embedded processor',
+            0x4e => 'Element 14 64-bit DSP Processor',
+            0x4f => 'LSI Logic 16-bit DSP Processor',
+            0x57 => 'NEC v850',
+            0x58 => 'Renesas M32R',
+            0x8c => 'TMS320C6000 Family',
+            0xaf => 'MCST Elbrus e2k',
+            0xb7 => 'Arm 64-bits (Armv8/AArch64)',
+            0xdc => 'Zilog Z80',
+            0xf3 => 'RISC-V',
+            0xf7 => 'Berkeley Packet Filter',
+            0x101 => 'WDC 65C816',
             0x5441 => 'Fujitsu FR-V',
             0x9026 => 'Alpha', # (interim value)
             0x9041 => 'm32r (old)',

package/bin/exiftool_files/lib/Image/ExifTool/Exif.pm

@@ -57,7 +57,7 @@ use vars qw($VERSION $AUTOLOAD @formatSize @formatName %formatNumber %intFormat
 use Image::ExifTool qw(:DataAccess :Utils);
 use Image::ExifTool::MakerNotes;
 
-$VERSION = '4.44';
+$VERSION = '4.46';
 
 sub ProcessExif($$$);
 sub WriteExif($$$);
@@ -250,6 +250,7 @@ $formatName[129] = 'utf8';  # (Exif 3.0)
     34927 => 'WebP', #LibTiff
     34933 => 'PNG', # (TIFF mail list)
     34934 => 'JPEG XR', # (TIFF mail list)
+    52546 => 'JPEG XL', # (DNG 1.7)
     65000 => 'Kodak DCR Compressed', #PH
     65535 => 'Pentax PEF Compressed', #Jens
 );
@@ -1004,7 +1005,7 @@ my %opcodeInfo = (
     },
     0x14d => 'InkNames', #3
     0x14e => 'NumberofInks', #3
-    0x150 => 'DotRange',
+    0x150 => 'DotRange', # (int8u or int16u)
     0x151 => {
         Name => 'TargetPrinter',
         Writable => 'string',
@@ -1491,6 +1492,75 @@ my %opcodeInfo = (
         WriteGroup => 'IFD0',
         Avoid => 1,
     },
+    # tags 0x5XXX are obscure tags defined by Microsoft:
+    # ref https://learn.microsoft.com/en-us/previous-versions/windows/embedded/ms932271(v=msdn.10)
+    # ref https://learn.microsoft.com/en-us/windows/win32/gdiplus/-gdiplus-constant-property-item-descriptions
+    0x5001 => { Name => 'ResolutionXUnit', Notes => "ID's from 0x5001 to 0x5113 are obscure tags defined by Microsoft" }, # (int16u)
+    0x5002 => 'ResolutionYUnit', # (int16u)
+    0x5003 => 'ResolutionXLengthUnit', # (int16u)
+    0x5004 => 'ResolutionYLengthUnit', # (int16u)
+    0x5005 => 'PrintFlags', # (string)
+    0x5006 => 'PrintFlagsVersion', # (int16u)
+    0x5007 => 'PrintFlagsCrop', # (int8u)
+    0x5008 => 'PrintFlagsBleedWidth', # (int32u)
+    0x5009 => 'PrintFlagsBleedWidthScale', # (int16u)
+    0x500a => 'HalftoneLPI', # (rational64u)
+    0x500b => 'HalftoneLPIUnit', # (int16u, 1=inch, 2=cm)
+    0x500c => 'HalftoneDegree', # (rational64u)
+    0x500d => 'HalftoneShape', # (int16u,0=round,1=Ellipse,2=Line,3=Square,4=Cross,5=Diamond)
+    0x500e => 'HalftoneMisc', # (int32u)
+    0x500f => 'HalftoneScreen', # (int8u)
+    0x5010 => 'JPEGQuality', # (int32u[N])
+    0x5011 => { Name => 'GridSize', Binary => 1 }, # (undef)
+    0x5012 => 'ThumbnailFormat', # (int32u,1=raw RGB,2=JPEG)
+    0x5013 => 'ThumbnailWidth', # (int32u)
+    0x5014 => 'ThumbnailHeight', # (int32u)
+    0x5015 => 'ThumbnailColorDepth', # (int16u)
+    0x5016 => 'ThumbnailPlanes', # (int16u)
+    0x5017 => 'ThumbnailRawBytes', # (int32u)
+    0x5018 => 'ThumbnailLength', # (int32u)
+    0x5019 => 'ThumbnailCompressedSize', # (int32u)
+    0x501a => { Name => 'ColorTransferFunction', Binary => 1 }, # (undef)
+    0x501b => { Name => 'ThumbnailData', Binary => 1, Format => 'undef' }, # (int8u)
+    0x5020 => 'ThumbnailImageWidth', # (int16u or int32u)
+    0x5021 => 'ThumbnailImageHeight', # (int16u or int32u)
+    0x5022 => 'ThumbnailBitsPerSample', # (int16u[N])
+    0x5023 => 'ThumbnailCompression', # (int16u)
+    0x5024 => 'ThumbnailPhotometricInterp', # (int16u)
+    0x5025 => 'ThumbnailDescription', # (string)
+    0x5026 => 'ThumbnailEquipMake', # (string)
+    0x5027 => 'ThumbnailEquipModel', # (string)
+    0x5028 => 'ThumbnailStripOffsets', # (int16u or int32u)
+    0x5029 => 'ThumbnailOrientation', # (int16u)
+    0x502a => 'ThumbnailSamplesPerPixel', # (int16u)
+    0x502b => 'ThumbnailRowsPerStrip', # (int16u or int32u)
+    0x502c => 'ThumbnailStripByteCounts', # (int16u or int32u)
+    0x502d => 'ThumbnailResolutionX',
+    0x502e => 'ThumbnailResolutionY',
+    0x502f => 'ThumbnailPlanarConfig', # (int16u)
+    0x5030 => 'ThumbnailResolutionUnit', # (int16u)
+    0x5031 => 'ThumbnailTransferFunction', # (int16u[N])
+    0x5032 => 'ThumbnailSoftware', # (string)
+    0x5033 => { Name => 'ThumbnailDateTime', Groups => { 2 => 'Time' } }, # (string)
+    0x5034 => 'ThumbnailArtist', # (string)
+    0x5035 => 'ThumbnailWhitePoint', # (rational64u[2])
+    0x5036 => 'ThumbnailPrimaryChromaticities', # (rational64u[6])
+    0x5037 => 'ThumbnailYCbCrCoefficients', # (rational64u[3])
+    0x5038 => 'ThumbnailYCbCrSubsampling', # (int16u)
+    0x5039 => 'ThumbnailYCbCrPositioning', # (int16u)
+    0x503a => 'ThumbnailRefBlackWhite', # (rational64u[6])
+    0x503b => 'ThumbnailCopyright', # (string)
+    0x5090 => 'LuminanceTable', # (int16u[64])
+    0x5091 => 'ChrominanceTable', # (int16u[64])
+    0x5100 => 'FrameDelay', # (int32u[N])
+    0x5101 => 'LoopCount', # (int16u)
+    0x5102 => 'GlobalPalette', # (int8u[N])
+    0x5103 => 'IndexBackground', # (int8u)
+    0x5104 => 'IndexTransparent', # (int8u)
+    0x5110 => 'PixelUnits', # (int8u)
+    0x5111 => 'PixelsPerUnitX', # (int32u)
+    0x5112 => 'PixelsPerUnitY', # (int32u)
+    0x5113 => 'PaletteHistogram', # (int8u[N])
     0x7000 => { #JR
         Name => 'SonyRawFileType',
         # (only valid if Sony:FileFormat >= ARW 2.0, ref IB)
@@ -3077,14 +3147,31 @@ my %opcodeInfo = (
         },
         PrintConvInv => '$val =~ /^PrintIM/ ? $val : undef',    # quick validation
     },
+    0xc519 => { # (Hasselblad X2D)
+        Name => 'HasselbladXML',
+        Format => 'undef',
+        TruncateOK => 1,    # (incorrect size written by X2D)
+        SubDirectory => {
+            DirName => 'XML',
+            TagTable => 'Image::ExifTool::PLIST::Main',
+            Start => '$valuePtr + 4',
+        },
+    },
     0xc51b => { # (Hasselblad H3D)
         Name => 'HasselbladExif',
         Format => 'undef',
-        RawConv => q{
-            $$self{DOC_NUM} = ++$$self{DOC_COUNT};
-            $self->ExtractInfo(\$val, { ReEntry => 1 });
-            $$self{DOC_NUM} = 0;
-            return undef;
+        SubDirectory => {
+            Start => '$valuePtr',
+            Base => '$start',
+            TagTable => 'Image::ExifTool::Exif::Main',
+            ProcessProc => \&Image::ExifTool::ProcessSubTIFF,
+            # Writing this is problematic due to the braindead Hasselblad programmers.
+            # One problem is that some values run outside the HasselbladExif data so they
+            # will be lost if we do a simple copy (which is what we are currently doing
+            # by returning undef from the WriteProc), but we can't rebuild this directory
+            # by writing it properly because there is an erroneous StripByteCounts value
+            # written by the X2D 100C that renders the data unreadable
+            WriteProc => sub { return undef },
         },
     },
     0xc573 => { #PH
@@ -3123,7 +3210,7 @@ my %opcodeInfo = (
     0xc612 => {
         Name => 'DNGVersion',
         Notes => q{
-            tags 0xc612-0xcd3b are defined by the DNG specification unless otherwise
+            tags 0xc612-0xcd48 are defined by the DNG specification unless otherwise
             noted.  See L<https://helpx.adobe.com/photoshop/digital-negative.html> for
             the specification
         },
@@ -3609,6 +3696,11 @@ my %opcodeInfo = (
         Writable => 'int16u',
         WriteGroup => 'IFD0',
         Protected => 1,
+        PrintConv => {
+            0 => 'Scene-referred',
+            1 => 'Output-referred (ICC Profile Dynamic Range)',
+            2 => 'Output-referred (High Dyanmic Range)', # DNG 1.7
+        },
     },
     0xc6c5 => { Name => 'SRawType', Description => 'SRaw Type', WriteGroup => 'IFD0' }, #exifprobe (CR2 proprietary)
     0xc6d2 => { #JD (Panasonic DMC-TZ5)
@@ -4133,7 +4225,7 @@ my %opcodeInfo = (
     0xcd2d => { # DNG 1.6
         Name => 'ProfileGainTableMap',
         Writable => 'undef',
-        WriteGroup => 'SubIFD',
+        WriteGroup => 'SubIFD', # (according to DNG 1.7 docs, this was an error and it should have been IFD0)
         Protected => 1,
         Binary => 1,
     },
@@ -4221,6 +4313,61 @@ my %opcodeInfo = (
         WriteGroup => 'IFD0',
         Protected => 1,
     },
+    0xcd40 => { # DNG 1.7
+        Name => 'ProfileGainTableMap2',
+        Writable => 'undef',
+        WriteGroup => 'IFD0',
+        Protected => 1,
+        Binary => 1,
+    },
+    0xcd41 => {
+        Name => 'JUMBF',
+        # (set Deletable flag so we can delete this because
+        #  Jpeg2000 directories are otherwise permanent)
+        Deletable => 1,
+        SubDirectory => {
+            TagTable => 'Image::ExifTool::Jpeg2000::Main',
+            ByteOrder => 'BigEndian',
+        },
+    },
+    0xcd43 => { # DNG 1.7
+        Name => 'ColumnInterleaveFactor',
+        Writable => 'int32u',
+        WriteGroup => 'SubIFD',
+        Protected => 1,
+    },
+    0xcd44 => { # DNG 1.7
+        Name => 'ImageSequenceInfo',
+        Writable => 'undef',
+        WriteGroup => 'IFD0',
+        SubDirectory => {
+            TagTable => 'Image::ExifTool::DNG::ImageSeq',
+            ByteOrder => 'BigEndian',
+        },
+    },
+    0xcd46 => { # DNG 1.7
+        Name => 'ImageStats',
+        Writable => 'undef',
+        WriteGroup => 'IFD0',
+        Binary => 1,
+        Protected => 1,
+    },
+    0xcd47 => { # DNG 1.7
+        Name => 'ProfileDynamicRange',
+        Writable => 'undef',
+        WriteGroup => 'IFD0',
+        SubDirectory => {
+            TagTable => 'Image::ExifTool::DNG::ProfileDynamicRange',
+            ByteOrder => 'BigEndian', # (not indicated in spec)
+        },
+    },
+    0xcd48 => { # DNG 1.7
+        Name => 'ProfileGroupName',
+        Writable => 'string',
+        Format => 'string',
+        WriteGroup => 'IFD0',
+        Protected => 1,
+    },
     0xea1c => { #13
         Name => 'Padding',
         Binary => 1,
@@ -5944,6 +6091,12 @@ sub ProcessExif($$$)
     my $inMakerNotes = $$tagTablePtr{GROUPS}{0} eq 'MakerNotes';
     my $isExif = ($tagTablePtr eq \%Image::ExifTool::Exif::Main);
 
+    # warn for incorrect maker notes in CR3 files
+    if ($$dirInfo{DirName} eq 'MakerNotes' and $$et{FileType} eq 'CR3' and
+        $$dirInfo{Parent} and $$dirInfo{Parent} eq 'ExifIFD')
+    {
+        $et->WarnOnce("MakerNotes shouldn't exist ExifIFD of CR3 image", 1);
+    }
     # set flag to calculate image data hash if requested
     $doHash = 1 if $$et{ImageDataHash} and (($$et{FILE_TYPE} eq 'TIFF' and not $base and not $inMakerNotes) or
         ($$et{FILE_TYPE} eq 'RAF' and $dirName eq 'FujiIFD'));
@@ -6219,7 +6372,7 @@ sub ProcessExif($$$)
                     }
                     # read from file if necessary
                     unless (defined $buff) {
-                        my $wrn;
+                        my ($wrn, $truncOK);
                         my $readFromRAF = ($tagInfo and $$tagInfo{ReadFromRAF});
                         if (not $raf->Seek($base + $valuePtr + $dataPos, 0)) {
                             $wrn = "Invalid offset for $dir entry $index";
@@ -6229,18 +6382,22 @@ sub ProcessExif($$$)
                             $buff = "$$tagInfo{Name} data $size bytes";
                             $readSize = length $buff;
                         } elsif ($raf->Read($buff,$size) != $size) {
-                            $wrn = "Error reading value for $dir entry $index";
+                            $wrn = sprintf("Error reading value for $dir entry $index, ID 0x%.4x", $tagID);
+                            if ($tagInfo and not $$tagInfo{Unknown}) {
+                                $wrn .= " $$tagInfo{Name}";
+                                $truncOK = $$tagInfo{TruncateOK};
+                            }
                         } elsif ($readFromRAF) {
                             # seek back to the start of the value
                             $raf->Seek($base + $valuePtr + $dataPos, 0);
                         }
                         if ($wrn) {
-                            $et->Warn($wrn, $inMakerNotes);
-                            return 0 unless $inMakerNotes or $htmlDump;
+                            $et->Warn($wrn, $inMakerNotes || $truncOK);
+                            return 0 unless $inMakerNotes or $htmlDump or $truncOK;
                             ++$warnCount;
                             $buff = '' unless defined $buff;
                             $readSize = length $buff;
-                            $bad = 1;
+                            $bad = 1 unless $truncOK;
                         }
                     }
                     $valueDataLen = length $buff;
@@ -6813,6 +6970,10 @@ sub ProcessExif($$$)
             # save original components of rational numbers (used when copying)
             $$et{RATIONAL}{$tagKey} = $rational if defined $rational;
             $$et{TAG_EXTRA}{$tagKey}{G6} = $saveFormat if $saveFormat;
+            if ($$et{MAKER_NOTE_FIXUP}) {
+                $$et{TAG_EXTRA}{$tagKey}{Fixup} = $$et{MAKER_NOTE_FIXUP};
+                delete $$et{MAKER_NOTE_FIXUP};
+            }
         }
     }
 

package/bin/exiftool_files/lib/Image/ExifTool/FujiFilm.pm

@@ -31,10 +31,11 @@ use vars qw($VERSION);
 use Image::ExifTool qw(:DataAccess :Utils);
 use Image::ExifTool::Exif;
 
-$VERSION = '1.89';
+$VERSION = '1.91';
 
 sub ProcessFujiDir($$$);
 sub ProcessFaceRec($$$);
+sub ProcessMRAW($$$);
 
 # the following RAF version numbers have been tested for writing:
 # (as of ExifTool 11.70, this lookup is no longer used if the version number is numerical)
@@ -42,11 +43,12 @@ my %testedRAF = (
     '0100' => 'E550, E900, F770, S5600, S6000fd, S6500fd, HS10/HS11, HS30, S200EXR, X100, XF1, X-Pro1, X-S1, XQ2 Ver1.00, X-T100, GFX 50R, XF10',
     '0101' => 'X-E1, X20 Ver1.01, X-T3',
     '0102' => 'S100FS, X10 Ver1.02',
-    '0103' => 'IS Pro Ver1.03',
+    '0103' => 'IS Pro and X-T5 Ver1.03',
     '0104' => 'S5Pro Ver1.04',
     '0106' => 'S5Pro Ver1.06',
     '0111' => 'S5Pro Ver1.11',
     '0114' => 'S9600 Ver1.00',
+    '0120' => 'X-T4 Ver1.20',
     '0132' => 'X-T2 Ver1.32',
     '0144' => 'X100T Ver1.44',
     '0159' => 'S2Pro Ver1.00',
@@ -428,6 +430,14 @@ my %faceCategories = (
         Name => 'ShadowTone',
         Writable => 'int32s',
         PrintConv => {
+            OTHER => sub {
+                my ($val, $inv) = @_;
+                if ($inv) {
+                    return int(-$val * 16);
+                } else {
+                    return -$val / 16;
+                }
+            },
             -64 => '+4 (hardest)',
             -48 => '+3 (very hard)',
             -32 => '+2 (hard)',
@@ -441,6 +451,14 @@ my %faceCategories = (
         Name => 'HighlightTone',
         Writable => 'int32s',
         PrintConv => {
+            OTHER => sub {
+                my ($val, $inv) = @_;
+                if ($inv) {
+                    return int(-$val * 16);
+                } else {
+                    return -$val / 16;
+                }
+            },
             -64 => '+4 (hardest)',
             -48 => '+3 (very hard)',
             -32 => '+2 (hard)',
@@ -1438,6 +1456,27 @@ my %faceCategories = (
     },
 );
 
+# tags in RAF M-RAW header (ref PH)
+%Image::ExifTool::FujiFilm::MRAW = (
+    PROCESS_PROC => \&ProcessMRAW,
+    GROUPS => { 0 => 'RAF', 1 => 'M-RAW', 2 => 'Image' },
+    FORMAT => 'int32u',
+    TAG_PREFIX => 'MRAW',
+    NOTES => q{
+        Tags extracted from the M-RAW header of multi-image RAF files.  The family 1
+        group name for these tags is "M-RAW".
+    },
+    1 => { Name => 'RawImageNumber', Format => 'int32u' },
+    # 3 - seen "0 100", "-300 100" and "300 100" for a sequence of 3 images
+    3 => { Name => 'MRAW_0x0003', Format => 'rational32s', Unknown => 1, Hidden => 1, PrintConv => 'sprintf("%+.2f",$val)' },
+    # 4 - (same value as 3 in all my samples)
+    4 => { Name => 'MRAW_0x0004', Format => 'rational32s', Unknown => 1, Hidden => 1, PrintConv => 'sprintf("%+.2f",$val)' },
+    # 5 - seen "10 1600", "10 6800", "10 200", "10 35000" etc
+    # 6 - seen "450 100", "400 100" (all images in RAF have same value)
+    # 7 - seen 200, 125, 250, 2000
+    # 8 - seen 0
+);
+
 #------------------------------------------------------------------------------
 # decode information from FujiFilm face recognition information
 # Inputs: 0) ExifTool object reference, 1) dirInfo reference, 2) tag table ref
@@ -1509,7 +1548,7 @@ sub ProcessFujiDir($$$)
     $raf->Read($buff, 4) or return 0;
     my $entries = unpack 'N', $buff;
     $entries < 256 or return 0;
-    $et->Options('Verbose') and $et->VerboseDir('Fuji', $entries);
+    $et->VerboseDir('Fuji', $entries);
     SetByteOrder('MM');
     my $pos = $offset + 4;
     for ($index=0; $index<$entries; ++$index) {
@@ -1541,6 +1580,51 @@ sub ProcessFujiDir($$$)
     return 1;
 }
 
+#------------------------------------------------------------------------------
+# get information from FujiFilm M-RAW header
+# Inputs: 0) ExifTool ref, 1) dirInfo ref, 2) tag table ref
+# Returns: 1 if this was a valid M-RAW headerx
+sub ProcessMRAW($$$)
+{
+    my ($et, $dirInfo, $tagTablePtr) = @_;
+    my $dataPt = $$dirInfo{DataPt};
+    my $dataPos = $$dirInfo{DataPos};
+    my $dataLen = length $$dataPt;
+    $dataLen < 44 and $et->Warn('Short M-RAW header'), return 0;
+    $$dataPt =~ /^FUJIFILMM-RAW  / or $et->Warn('Bad M-RAW header'), return 0;
+    my $ver = substr($$dataPt, 16, 4);
+    $et->VerboseDir("M-RAW $ver", undef, $dataLen);
+    SetByteOrder('MM');
+    my $size = Get16u($dataPt, 40); # (these are just a guess - PH)
+    my $num = Get16u($dataPt, 42);
+    my $pos = 44;
+    my ($i, $n);
+    for ($n=0; ; ++$n) {
+        $pos += 16;  # skip offset/size fields
+        my $end = $pos + $size;
+        last if $end > $dataLen;
+        $$et{DOC_NUM} = ++$$et{DOC_COUNT} if $pos > 60;
+        $et->VPrint(0, "$$et{INDENT}(Raw image $n parameters: $size bytes, $num entries)\n");
+        for ($i=0; $i<$num; ++$i) {
+            last if $pos + 4 > $end;
+            # (don't know what the byte at the current $pos is for, value = 0x20)
+            my $tag = Get8u($dataPt, $pos+1);
+            my $size = Get16u($dataPt, $pos+2);
+            $pos += 4;
+            last if $pos + $size > $end;
+            $et->HandleTag($tagTablePtr, $tag, undef,
+                DataPt  => $dataPt,
+                DataPos => $dataPos,
+                Start   => $pos,
+                Size    => $size,
+            );
+            $pos += $size;
+        }
+    }
+    delete $$et{DOC_NUM};
+    return 1;
+}
+
 #------------------------------------------------------------------------------
 # write information to FujiFilm RAW file (RAF)
 # Inputs: 0) ExifTool object reference, 1) dirInfo reference
@@ -1556,10 +1640,12 @@ sub WriteRAF($$)
     my $ver = substr($hdr, 0x3c, 4);
     $ver =~ /^\d{4}$/ or $testedRAF{$ver} or return 0;
 
+    # get position and size of M-RAW header
+    my ($mpos, $mlen) = unpack('x72NN', $hdr);
     # get the position and size of embedded JPEG
     my ($jpos, $jlen) = unpack('x84NN', $hdr);
     # check to be sure the JPEG starts in the expected location
-    if ($jpos > 0x94 or $jpos < 0x68 or $jpos & 0x03) {
+    if (($mpos > 0x94 or $jpos > 0x94 + $mlen) or $jpos < 0x68 or $jpos & 0x03) {
         $et->Error("Unsupported or corrupted RAF image (version $ver)");
         return 1;
     }
@@ -1573,6 +1659,27 @@ sub WriteRAF($$)
         $et->Error('Error reading RAF meta information');
         return 1;
     }
+    if ($mpos) {
+        if ($mlen != 0x11c) {
+            $et->Error('Unsupported M-RAW header (please submit sample for testing)');
+            return 1;
+        }
+        # read M-RAW header and add to file header
+        my $mraw;
+        unless ($raf->Seek($mpos, 0) and $raf->Read($mraw, $mlen) == $mlen) {
+            $et->Error('Error reading M-RAW header');
+            return 1;
+        }
+        $hdr .= $mraw;
+        # verify that the 1st raw image offset is zero, and that the 1st raw image
+        # length is the same as the 2nd raw image offset
+        unless (substr($hdr, 0xc0, 8) eq "\0\0\0\0\0\0\0\0" and
+                substr($hdr, 0xc8, 8) eq substr($hdr, 0x110, 8))
+        {
+            $et->Error('Unexpected layout of M-RAW header');
+            return 1;
+        }
+    }
     # use same write directories as JPEG
     $et->InitWriteDirs('JPEG');
     # rewrite the embedded JPEG in memory
@@ -1617,12 +1724,28 @@ sub WriteRAF($$)
     }
     # calculate offset difference due to change in JPEG size
     my $ptrDiff = length($outJpeg) + length($pad) - ($jlen + $oldPadLen);
-    # update necessary pointers in header
-    foreach $offset (0x5c, 0x64, 0x78, 0x80) {
+    # update necessary pointers in header (0xcc and higher in M-RAW header)
+    foreach $offset (0x5c, 0x64, 0x78, 0x80, 0xcc, 0x114, 0x164) {
         last if $offset >= $jpos;   # some versions have a short header
         my $oldPtr = Get32u(\$hdr, $offset);
         next unless $oldPtr;        # don't update if pointer is zero
-        Set32u($oldPtr + $ptrDiff, \$hdr, $offset);
+        my $newPtr = $oldPtr + $ptrDiff;
+        if ($newPtr < 0 or $newPtr > 0xffffffff) {
+            $offset < 0xcc and $et->Error('Invalid offset in RAF header'), return 1;
+            # assume values at 0xcc and greater are 8-byte integers (NC)
+            # and adjust high word if necessary
+            my $high = Get32u(\$hdr, $offset-4);
+            if ($newPtr < 0) {
+                $high -= 1;
+                $newPtr += 0xffffffff + 1;
+                $high < 0 and $et->Error('RAF header offset error'), return 1;
+            } else {
+                $high += 1;
+                $newPtr -= 0xffffffff + 1;
+            }
+            Set32u($high, \$hdr, $offset-4);
+        }
+        Set32u($newPtr, \$hdr, $offset);
     }
     # write the new header
     my $outfile = $$dirInfo{OutFile};
@@ -1652,11 +1775,14 @@ sub ProcessRAF($$)
     my $raf = $$dirInfo{RAF};
     $raf->Read($buff,0x5c) == 0x5c    or return 0;
     $buff =~ /^FUJIFILM/              or return 0;
+    # get position and size of M-RAW header and jpeg preview
+    my ($mpos, $mlen) = unpack('x72NN', $buff);
     my ($jpos, $jlen) = unpack('x84NN', $buff);
     $jpos & 0x8000                   and return 0;
-    $raf->Seek($jpos, 0)              or return 0;
-    $raf->Read($jpeg, $jlen) == $jlen or return 0;
-
+    if ($jpos) {
+        $raf->Seek($jpos, 0)              or return 0;
+        $raf->Read($jpeg, $jlen) == $jlen or return 0;
+    }
     $et->SetFileType();
     $et->FoundTag('RAFVersion', substr($buff, 0x3c, 4));
 
@@ -1665,15 +1791,16 @@ sub ProcessRAF($$)
         Parent => 'RAF',
         RAF    => new File::RandomAccess(\$jpeg),
     );
-    $$et{BASE} += $jpos;
-    my $rtnVal = $et->ProcessJPEG(\%dirInfo);
-    $$et{BASE} -= $jpos;
-    $et->FoundTag('PreviewImage', \$jpeg) if $rtnVal;
-
+    if ($jpos) {
+        $$et{BASE} += $jpos;
+        my $ok = $et->ProcessJPEG(\%dirInfo);
+        $$et{BASE} -= $jpos;
+        $et->FoundTag('PreviewImage', \$jpeg) if $ok;
+    }
     # extract information from Fuji RAF and TIFF directories
     my ($rafNum, $ifdNum) = ('','');
-    foreach $offset (0x5c, 0x64, 0x78, 0x80) {
-        last if $offset >= $jpos;
+    foreach $offset (0x48, 0x5c, 0x64, 0x78, 0x80) {
+        last if $jpos and $offset >= $jpos;
         unless ($raf->Seek($offset, 0) and $raf->Read($buff, 8)) {
             $warn = 1;
             last;
@@ -1695,6 +1822,14 @@ sub ProcessRAF($$)
             }
             delete $$et{SET_GROUP1};
             $ifdNum = ($ifdNum || 1) + 1;
+        } elsif ($offset == 0x48) {
+            $$et{VALUE}{FileType} .= ' (M-RAW)';
+            if ($raf->Seek($start, 0) and $raf->Read($buff, $mlen) == $mlen) {
+                my $tbl = GetTagTable('Image::ExifTool::FujiFilm::MRAW');
+                $et->ProcessDirectory({ DataPt => \$buff, DataPos => $start, DirName => 'M-RAW' }, $tbl);
+            } else {
+                $et->Warn('Error reading M-RAW header');
+            }
         } else {
             # parse RAF directory
             %dirInfo = (
@@ -1703,14 +1838,17 @@ sub ProcessRAF($$)
             );
             $$et{SET_GROUP1} = "RAF$rafNum";
             my $tagTablePtr = GetTagTable('Image::ExifTool::FujiFilm::RAF');
-            $et->ProcessDirectory(\%dirInfo, $tagTablePtr) or $warn = 1;
+            if ($et->ProcessDirectory(\%dirInfo, $tagTablePtr)) {
+                $rafNum = ($rafNum || 1) + 1;
+            } else {
+                $warn = 1;
+            }
             delete $$et{SET_GROUP1};
-            $rafNum = ($rafNum || 1) + 1;
         }
     }
     $warn and $et->Warn('Possibly corrupt RAF information');
 
-    return $rtnVal;
+    return 1;
 }
 
 1; # end