exiftool_vendored 10.31.0 → 10.40.0

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

@@ -0,0 +1,1960 @@
+#------------------------------------------------------------------------------
+# File:         FlashPix.pm
+#
+# Description:  Read FlashPix meta information
+#
+# Revisions:    05/29/2006 - P. Harvey Created
+#
+# References:   1) http://www.exif.org/Exif2-2.PDF
+#               2) http://www.graphcomp.com/info/specs/livepicture/fpx.pdf
+#               3) http://search.cpan.org/~jdb/libwin32/
+#               4) http://msdn.microsoft.com/en-us/library/aa380374.aspx
+#------------------------------------------------------------------------------
+
+package Image::ExifTool::FlashPix;
+
+use strict;
+use vars qw($VERSION);
+use Image::ExifTool qw(:DataAccess :Utils);
+use Image::ExifTool::Exif;
+use Image::ExifTool::ASF;   # for GetGUID()
+
+$VERSION = '1.28';
+
+sub ProcessFPX($$);
+sub ProcessFPXR($$$);
+sub ProcessProperties($$$);
+sub ReadFPXValue($$$$$;$$);
+sub ProcessHyperlinks($$);
+sub ProcessContents($$$);
+sub SetDocNum($$;$$$);
+
+# sector type constants
+sub HDR_SIZE           () { 512; }
+sub DIF_SECT           () { 0xfffffffc; }
+sub FAT_SECT           () { 0xfffffffd; }
+sub END_OF_CHAIN       () { 0xfffffffe; }
+sub FREE_SECT          () { 0xffffffff; }
+
+# format flags
+sub VT_VECTOR          () { 0x1000; }
+sub VT_ARRAY           () { 0x2000; }
+sub VT_BYREF           () { 0x4000; }
+sub VT_RESERVED        () { 0x8000; }
+
+# other constants
+sub VT_VARIANT         () { 12; }
+sub VT_LPSTR           () { 30; }
+
+# list of OLE format codes (unsupported codes commented out)
+my %oleFormat = (
+    0  => undef,        # VT_EMPTY
+    1  => undef,        # VT_NULL
+    2  => 'int16s',     # VT_I2
+    3  => 'int32s',     # VT_I4
+    4  => 'float',      # VT_R4
+    5  => 'double',     # VT_R8
+    6  => undef,        # VT_CY
+    7  => 'VT_DATE',    # VT_DATE (double, number of days since Dec 30, 1899)
+    8  => 'VT_BSTR',    # VT_BSTR (int32u count, followed by binary string)
+#   9  => 'VT_DISPATCH',
+    10 => 'int32s',     # VT_ERROR
+    11 => 'int16s',     # VT_BOOL
+    12 => 'VT_VARIANT', # VT_VARIANT
+#   13 => 'VT_UNKNOWN',
+#   14 => 'VT_DECIMAL',
+    16 => 'int8s',      # VT_I1
+    17 => 'int8u',      # VT_UI1
+    18 => 'int16u',     # VT_UI2
+    19 => 'int32u',     # VT_UI4
+    20 => 'int64s',     # VT_I8
+    21 => 'int64u',     # VT_UI8
+#   22 => 'VT_INT',
+#   23 => 'VT_UINT',
+#   24 => 'VT_VOID',
+#   25 => 'VT_HRESULT',
+#   26 => 'VT_PTR',
+#   27 => 'VT_SAFEARRAY',
+#   28 => 'VT_CARRAY',
+#   29 => 'VT_USERDEFINED',
+    30 => 'VT_LPSTR',   # VT_LPSTR (int32u count, followed by string)
+    31 => 'VT_LPWSTR',  # VT_LPWSTR (int32u word count, followed by Unicode string)
+    64 => 'VT_FILETIME',# VT_FILETIME (int64u, 100 ns increments since Jan 1, 1601)
+    65 => 'VT_BLOB',    # VT_BLOB
+#   66 => 'VT_STREAM',
+#   67 => 'VT_STORAGE',
+#   68 => 'VT_STREAMED_OBJECT',
+#   69 => 'VT_STORED_OBJECT',
+#   70 => 'VT_BLOB_OBJECT',
+    71 => 'VT_CF',      # VT_CF
+    72 => 'VT_CLSID',   # VT_CLSID
+);
+
+# OLE flag codes (high nibble of property type)
+my %oleFlags = (
+    0x1000 => 'VT_VECTOR',
+    0x2000 => 'VT_ARRAY',   # not yet supported
+    0x4000 => 'VT_BYREF',   # ditto
+    0x8000 => 'VT_RESERVED',
+);
+
+# byte sizes for supported VT_* format and flag types
+my %oleFormatSize = (
+    VT_DATE     => 8,
+    VT_BSTR     => 4,   # (+ string length)
+    VT_VARIANT  => 4,   # (+ data length)
+    VT_LPSTR    => 4,   # (+ string length)
+    VT_LPWSTR   => 4,   # (+ string character length)
+    VT_FILETIME => 8,
+    VT_BLOB     => 4,   # (+ data length)
+    VT_CF       => 4,   # (+ data length)
+    VT_CLSID    => 16,
+    VT_VECTOR   => 4,   # (+ vector elements)
+);
+
+# names for each type of directory entry
+my @dirEntryType = qw(INVALID STORAGE STREAM LOCKBYTES PROPERTY ROOT);
+
+# list of code pages used by Microsoft
+# (ref http://msdn.microsoft.com/en-us/library/dd317756(VS.85).aspx)
+my %codePage = (
+    037 => 'IBM EBCDIC US-Canada',
+    437 => 'DOS United States',
+    500 => 'IBM EBCDIC International',
+    708 => 'Arabic (ASMO 708)',
+    709 => 'Arabic (ASMO-449+, BCON V4)',
+    710 => 'Arabic - Transparent Arabic',
+    720 => 'DOS Arabic (Transparent ASMO)',
+    737 => 'DOS Greek (formerly 437G)',
+    775 => 'DOS Baltic',
+    850 => 'DOS Latin 1 (Western European)',
+    852 => 'DOS Latin 2 (Central European)',
+    855 => 'DOS Cyrillic (primarily Russian)',
+    857 => 'DOS Turkish',
+    858 => 'DOS Multilingual Latin 1 with Euro',
+    860 => 'DOS Portuguese',
+    861 => 'DOS Icelandic',
+    862 => 'DOS Hebrew',
+    863 => 'DOS French Canadian',
+    864 => 'DOS Arabic',
+    865 => 'DOS Nordic',
+    866 => 'DOS Russian (Cyrillic)',
+    869 => 'DOS Modern Greek',
+    870 => 'IBM EBCDIC Multilingual/ROECE (Latin 2)',
+    874 => 'Windows Thai (same as 28605, ISO 8859-15)',
+    875 => 'IBM EBCDIC Greek Modern',
+    932 => 'Windows Japanese (Shift-JIS)',
+    936 => 'Windows Simplified Chinese (PRC, Singapore)',
+    949 => 'Windows Korean (Unified Hangul Code)',
+    950 => 'Windows Traditional Chinese (Taiwan)',
+    1026 => 'IBM EBCDIC Turkish (Latin 5)',
+    1047 => 'IBM EBCDIC Latin 1/Open System',
+    1140 => 'IBM EBCDIC US-Canada with Euro',
+    1141 => 'IBM EBCDIC Germany with Euro',
+    1142 => 'IBM EBCDIC Denmark-Norway with Euro',
+    1143 => 'IBM EBCDIC Finland-Sweden with Euro',
+    1144 => 'IBM EBCDIC Italy with Euro',
+    1145 => 'IBM EBCDIC Latin America-Spain with Euro',
+    1146 => 'IBM EBCDIC United Kingdom with Euro',
+    1147 => 'IBM EBCDIC France with Euro',
+    1148 => 'IBM EBCDIC International with Euro',
+    1149 => 'IBM EBCDIC Icelandic with Euro',
+    1200 => 'Unicode UTF-16, little endian',
+    1201 => 'Unicode UTF-16, big endian',
+    1250 => 'Windows Latin 2 (Central European)',
+    1251 => 'Windows Cyrillic',
+    1252 => 'Windows Latin 1 (Western European)',
+    1253 => 'Windows Greek',
+    1254 => 'Windows Turkish',
+    1255 => 'Windows Hebrew',
+    1256 => 'Windows Arabic',
+    1257 => 'Windows Baltic',
+    1258 => 'Windows Vietnamese',
+    1361 => 'Korean (Johab)',
+    10000 => 'Mac Roman (Western European)',
+    10001 => 'Mac Japanese',
+    10002 => 'Mac Traditional Chinese',
+    10003 => 'Mac Korean',
+    10004 => 'Mac Arabic',
+    10005 => 'Mac Hebrew',
+    10006 => 'Mac Greek',
+    10007 => 'Mac Cyrillic',
+    10008 => 'Mac Simplified Chinese',
+    10010 => 'Mac Romanian',
+    10017 => 'Mac Ukrainian',
+    10021 => 'Mac Thai',
+    10029 => 'Mac Latin 2 (Central European)',
+    10079 => 'Mac Icelandic',
+    10081 => 'Mac Turkish',
+    10082 => 'Mac Croatian',
+    12000 => 'Unicode UTF-32, little endian',
+    12001 => 'Unicode UTF-32, big endian',
+    20000 => 'CNS Taiwan',
+    20001 => 'TCA Taiwan',
+    20002 => 'Eten Taiwan',
+    20003 => 'IBM5550 Taiwan',
+    20004 => 'TeleText Taiwan',
+    20005 => 'Wang Taiwan',
+    20105 => 'IA5 (IRV International Alphabet No. 5, 7-bit)',
+    20106 => 'IA5 German (7-bit)',
+    20107 => 'IA5 Swedish (7-bit)',
+    20108 => 'IA5 Norwegian (7-bit)',
+    20127 => 'US-ASCII (7-bit)',
+    20261 => 'T.61',
+    20269 => 'ISO 6937 Non-Spacing Accent',
+    20273 => 'IBM EBCDIC Germany',
+    20277 => 'IBM EBCDIC Denmark-Norway',
+    20278 => 'IBM EBCDIC Finland-Sweden',
+    20280 => 'IBM EBCDIC Italy',
+    20284 => 'IBM EBCDIC Latin America-Spain',
+    20285 => 'IBM EBCDIC United Kingdom',
+    20290 => 'IBM EBCDIC Japanese Katakana Extended',
+    20297 => 'IBM EBCDIC France',
+    20420 => 'IBM EBCDIC Arabic',
+    20423 => 'IBM EBCDIC Greek',
+    20424 => 'IBM EBCDIC Hebrew',
+    20833 => 'IBM EBCDIC Korean Extended',
+    20838 => 'IBM EBCDIC Thai',
+    20866 => 'Russian/Cyrillic (KOI8-R)',
+    20871 => 'IBM EBCDIC Icelandic',
+    20880 => 'IBM EBCDIC Cyrillic Russian',
+    20905 => 'IBM EBCDIC Turkish',
+    20924 => 'IBM EBCDIC Latin 1/Open System with Euro',
+    20932 => 'Japanese (JIS 0208-1990 and 0121-1990)',
+    20936 => 'Simplified Chinese (GB2312)',
+    20949 => 'Korean Wansung',
+    21025 => 'IBM EBCDIC Cyrillic Serbian-Bulgarian',
+    21027 => 'Extended Alpha Lowercase (deprecated)',
+    21866 => 'Ukrainian/Cyrillic (KOI8-U)',
+    28591 => 'ISO 8859-1 Latin 1 (Western European)',
+    28592 => 'ISO 8859-2 (Central European)',
+    28593 => 'ISO 8859-3 Latin 3',
+    28594 => 'ISO 8859-4 Baltic',
+    28595 => 'ISO 8859-5 Cyrillic',
+    28596 => 'ISO 8859-6 Arabic',
+    28597 => 'ISO 8859-7 Greek',
+    28598 => 'ISO 8859-8 Hebrew (Visual)',
+    28599 => 'ISO 8859-9 Turkish',
+    28603 => 'ISO 8859-13 Estonian',
+    28605 => 'ISO 8859-15 Latin 9',
+    29001 => 'Europa 3',
+    38598 => 'ISO 8859-8 Hebrew (Logical)',
+    50220 => 'ISO 2022 Japanese with no halfwidth Katakana (JIS)',
+    50221 => 'ISO 2022 Japanese with halfwidth Katakana (JIS-Allow 1 byte Kana)',
+    50222 => 'ISO 2022 Japanese JIS X 0201-1989 (JIS-Allow 1 byte Kana - SO/SI)',
+    50225 => 'ISO 2022 Korean',
+    50227 => 'ISO 2022 Simplified Chinese',
+    50229 => 'ISO 2022 Traditional Chinese',
+    50930 => 'EBCDIC Japanese (Katakana) Extended',
+    50931 => 'EBCDIC US-Canada and Japanese',
+    50933 => 'EBCDIC Korean Extended and Korean',
+    50935 => 'EBCDIC Simplified Chinese Extended and Simplified Chinese',
+    50936 => 'EBCDIC Simplified Chinese',
+    50937 => 'EBCDIC US-Canada and Traditional Chinese',
+    50939 => 'EBCDIC Japanese (Latin) Extended and Japanese',
+    51932 => 'EUC Japanese',
+    51936 => 'EUC Simplified Chinese',
+    51949 => 'EUC Korean',
+    51950 => 'EUC Traditional Chinese',
+    52936 => 'HZ-GB2312 Simplified Chinese',
+    54936 => 'Windows XP and later: GB18030 Simplified Chinese (4 byte)',
+    57002 => 'ISCII Devanagari',
+    57003 => 'ISCII Bengali',
+    57004 => 'ISCII Tamil',
+    57005 => 'ISCII Telugu',
+    57006 => 'ISCII Assamese',
+    57007 => 'ISCII Oriya',
+    57008 => 'ISCII Kannada',
+    57009 => 'ISCII Malayalam',
+    57010 => 'ISCII Gujarati',
+    57011 => 'ISCII Punjabi',
+    65000 => 'Unicode (UTF-7)',
+    65001 => 'Unicode (UTF-8)',
+);
+
+# test for file extensions which may be variants of the FPX format
+# (have seen one password-protected DOCX file that is FPX-like, so assume
+#  that all the rest could be as well)
+my %fpxFileType = (
+    DOC => 1,  DOCX => 1,  DOCM => 1,
+    DOT => 1,  DOTX => 1,  DOTM => 1,
+    POT => 1,  POTX => 1,  POTM => 1,
+    PPS => 1,  PPSX => 1,  PPSM => 1,
+    PPT => 1,  PPTX => 1,  PPTM => 1,  THMX => 1,
+    XLA => 1,  XLAM => 1,
+    XLS => 1,  XLSX => 1,  XLSM => 1,  XLSB => 1,
+    XLT => 1,  XLTX => 1,  XLTM => 1,
+    # non MSOffice types
+    FLA => 1,  VSD  => 1,
+);
+
+%Image::ExifTool::FlashPix::Main = (
+    PROCESS_PROC => \&ProcessFPXR,
+    GROUPS => { 2 => 'Image' },
+    NOTES => q{
+        The FlashPix file format, introduced in 1996, was developed by Kodak,
+        Hewlett-Packard and Microsoft.  Internally the FPX file structure mimics
+        that of an old DOS disk with fixed-sized "sectors" (usually 512 bytes) and a
+        "file allocation table" (FAT).  No wonder this image format never became
+        popular.  However, some of the structures used in FlashPix streams are part
+        of the EXIF specification, and are still being used in the APP2 FPXR segment
+        of JPEG images by some digital cameras from manufacturers such as FujiFilm,
+        Hewlett-Packard, Kodak and Sanyo.
+
+        ExifTool extracts FlashPix information from both FPX images and the APP2
+        FPXR segment of JPEG images.  As well, FlashPix information is extracted
+        from DOC, PPT, XLS (Microsoft Word, PowerPoint and Excel) documents, VSD
+        (Microsoft Visio) drawings, and FLA (Macromedia/Adobe Flash project) files
+        since these are based on the same file format as FlashPix (the Windows
+        Compound Binary File format).  See
+        L<http://graphcomp.com/info/specs/livepicture/fpx.pdf> for the FlashPix
+        specification.
+    },
+    "\x05SummaryInformation" => {
+        Name => 'SummaryInfo',
+        SubDirectory => {
+            TagTable => 'Image::ExifTool::FlashPix::SummaryInfo',
+        },
+    },
+    "\x05DocumentSummaryInformation" => {
+        Name => 'DocumentInfo',
+        Multi => 1, # flag to process UserDefined information after this
+        SubDirectory => {
+            TagTable => 'Image::ExifTool::FlashPix::DocumentInfo',
+        },
+    },
+    "\x01CompObj" => {
+        Name => 'CompObj',
+        SubDirectory => {
+            TagTable => 'Image::ExifTool::FlashPix::CompObj',
+            DirStart => 0x1c,   # skip stream header
+        },
+    },
+    "\x05Image Info" => {
+        Name => 'ImageInfo',
+        SubDirectory => {
+            TagTable => 'Image::ExifTool::FlashPix::ImageInfo',
+        },
+    },
+    "\x05Image Contents" => {
+        Name => 'Image',
+        SubDirectory => {
+            TagTable => 'Image::ExifTool::FlashPix::Image',
+        },
+    },
+    "Contents" => {
+        Name => 'Contents',
+        Notes => 'found in FLA files; may contain XMP',
+        SubDirectory => {
+            TagTable => 'Image::ExifTool::XMP::Main',
+            ProcessProc => \&ProcessContents,
+        },
+    },
+    "ICC Profile 0001" => {
+        Name => 'ICC_Profile',
+        SubDirectory => {
+            TagTable => 'Image::ExifTool::ICC_Profile::Main',
+            DirStart => 0x1c,   # skip stream header
+        },
+    },
+    "\x05Extension List" => {
+        Name => 'Extensions',
+        SubDirectory => {
+            TagTable => 'Image::ExifTool::FlashPix::Extensions',
+        },
+    },
+    'Subimage 0000 Header' => {
+        Name => 'SubimageHdr',
+        SubDirectory => {
+            TagTable => 'Image::ExifTool::FlashPix::SubimageHdr',
+            DirStart => 0x1c,   # skip stream header
+        },
+    },
+#   'Subimage 0000 Data'
+    "\x05Data Object" => {  # plus instance number (eg. " 000000")
+        Name => 'DataObject',
+        SubDirectory => {
+            TagTable => 'Image::ExifTool::FlashPix::DataObject',
+        },
+    },
+#   "\x05Data Object Store" => { # plus instance number (eg. " 000000")
+    "\x05Transform" => {    # plus instance number (eg. " 000000")
+        Name => 'Transform',
+        SubDirectory => {
+            TagTable => 'Image::ExifTool::FlashPix::Transform',
+        },
+    },
+    "\x05Operation" => {    # plus instance number (eg. " 000000")
+        Name => 'Operation',
+        SubDirectory => {
+            TagTable => 'Image::ExifTool::FlashPix::Operation',
+        },
+    },
+    "\x05Global Info" => {
+        Name => 'GlobalInfo',
+        SubDirectory => {
+            TagTable => 'Image::ExifTool::FlashPix::GlobalInfo',
+        },
+    },
+    "\x05Screen Nail" => { # plus class ID (eg. "_bd0100609719a180")
+        Name => 'ScreenNail',
+        Groups => { 2 => 'Other' },
+        # strip off stream header
+        ValueConv => 'length($val) > 0x1c and $val = substr($val, 0x1c); \$val',
+    },
+    "\x05Audio Info" => {
+        Name => 'AudioInfo',
+        SubDirectory => {
+            TagTable => 'Image::ExifTool::FlashPix::AudioInfo',
+        },
+    },
+    'Audio Stream' => { # plus instance number (eg. " 000000")
+        Name => 'AudioStream',
+        Groups => { 2 => 'Audio' },
+        # strip off stream header
+        ValueConv => 'length($val) > 0x1c and $val = substr($val, 0x1c); \$val',
+    },
+    'Current User' => { #PH
+        Name => 'CurrentUser',
+        # not sure what the rest of this data is, but extract ASCII name from it - PH
+        ValueConv => q{
+            return undef if length $val < 12;
+            my ($size,$pos) = unpack('x4VV', $val);
+            my $len = $size - $pos - 4;
+            return undef if $len < 0 or length $val < $size + 8;
+            return substr($val, 8 + $pos, $len);
+        },
+    },
+    Preview => {
+        Name => 'PreviewImage',
+        Groups => { 2 => 'Preview' },
+        Binary => 1,
+        Notes => 'written by some FujiFilm models',
+        # skip 47-byte Fuji header
+        RawConv => q{
+            return undef unless length $val > 47;
+            $val = substr($val, 47);
+            return $val =~ /^\xff\xd8\xff/ ? $val : undef;
+        },
+    },
+    Property => {
+        Name => 'PreviewInfo',
+        SubDirectory => {
+            TagTable => 'Image::ExifTool::FlashPix::PreviewInfo',
+            ByteOrder => 'BigEndian',
+        },
+    },
+);
+
+# Summary Information properties
+%Image::ExifTool::FlashPix::SummaryInfo = (
+    PROCESS_PROC => \&ProcessProperties,
+    GROUPS => { 2 => 'Document' },
+    NOTES => q{
+        The Dictionary, CodePage and LocalIndicator tags are common to all FlashPix
+        property tables, even though they are only listed in the SummaryInfo table.
+    },
+    0x00 => { Name => 'Dictionary',     Groups => { 2 => 'Other' }, Binary => 1 },
+    0x01 => {
+        Name => 'CodePage',
+        Groups => { 2 => 'Other' },
+        PrintConv => \%codePage,
+    },
+    0x02 => 'Title',
+    0x03 => 'Subject',
+    0x04 => { Name => 'Author',         Groups => { 2 => 'Author' } },
+    0x05 => 'Keywords',
+    0x06 => 'Comments',
+    0x07 => 'Template',
+    0x08 => { Name => 'LastModifiedBy', Groups => { 2 => 'Author' } },
+    0x09 => 'RevisionNumber',
+    0x0a => { Name => 'TotalEditTime',  PrintConv => 'ConvertTimeSpan($val)' }, # (in sec)
+    0x0b => { Name => 'LastPrinted',    Groups => { 2 => 'Time' } },
+    0x0c => {
+        Name => 'CreateDate',
+        Groups => { 2 => 'Time' },
+        PrintConv => '$self->ConvertDateTime($val)',
+    },
+    0x0d => {
+        Name => 'ModifyDate',
+        Groups => { 2 => 'Time' },
+        PrintConv => '$self->ConvertDateTime($val)',
+    },
+    0x0e => 'Pages',
+    0x0f => 'Words',
+    0x10 => 'Characters',
+    0x11 => {
+        Name => 'ThumbnailClip',
+        # (not a displayable format, so not in the "Preview" group)
+        Binary => 1,
+    },
+    0x12 => {
+        Name => 'Software',
+        RawConv => '$$self{Software} = $val', # (use to determine file type)
+    },
+    0x13 => {
+        Name => 'Security',
+        # see http://msdn.microsoft.com/en-us/library/aa379255(VS.85).aspx
+        PrintConv => {
+            0 => 'None',
+            BITMASK => {
+                0 => 'Password protected',
+                1 => 'Read-only recommended',
+                2 => 'Read-only enforced',
+                3 => 'Locked for annotations',
+            },
+        },
+    },
+    0x22 => { Name => 'CreatedBy', Groups => { 2 => 'Author' } }, #PH (guess) (MAX files)
+    0x23 => 'DocumentID', # PH (guess) (MAX files)
+  # 0x25 ? seen values 1.0-1.97 (MAX files)
+    0x80000000 => { Name => 'LocaleIndicator', Groups => { 2 => 'Other' } },
+);
+
+# Document Summary Information properties (ref 4)
+%Image::ExifTool::FlashPix::DocumentInfo = (
+    PROCESS_PROC => \&ProcessProperties,
+    GROUPS => { 2 => 'Document' },
+    NOTES => q{
+        The DocumentSummaryInformation property set includes a UserDefined property
+        set for which only the Hyperlinks and HyperlinkBase tags are pre-defined.
+        However, ExifTool will also extract any other information found in the
+        UserDefined properties.
+    },
+    0x02 => 'Category',
+    0x03 => 'PresentationTarget',
+    0x04 => 'Bytes',
+    0x05 => 'Lines',
+    0x06 => 'Paragraphs',
+    0x07 => 'Slides',
+    0x08 => 'Notes',
+    0x09 => 'HiddenSlides',
+    0x0a => 'MMClips',
+    0x0b => {
+        Name => 'ScaleCrop',
+        PrintConv => { 0 => 'No', 1 => 'Yes' },
+    },
+    0x0c => 'HeadingPairs',
+    0x0d => {
+        Name => 'TitleOfParts',
+        # look for "3ds Max" software name at beginning of TitleOfParts
+        RawConv => q{
+            (ref $val eq 'ARRAY' ? $$val[0] : $val) =~ /^(3ds Max)/ and $$self{Software} = $1;
+            return $val;
+        }
+    },
+    0x0e => 'Manager',
+    0x0f => 'Company',
+    0x10 => {
+        Name => 'LinksUpToDate',
+        PrintConv => { 0 => 'No', 1 => 'Yes' },
+    },
+    0x11 => 'CharCountWithSpaces',
+  # 0x12 ? seen -32.1850395202637,-386.220672607422,-9.8100004196167,-9810,...
+    0x13 => { #PH (unconfirmed)
+        Name => 'SharedDoc',
+        PrintConv => { 0 => 'No', 1 => 'Yes' },
+    },
+  # 0x14 ? seen -1
+  # 0x15 ? seen 1
+    0x16 => {
+        Name => 'HyperlinksChanged',
+        PrintConv => { 0 => 'No', 1 => 'Yes' },
+    },
+    0x17 => { #PH (unconfirmed handling of lower 16 bits, not valid for MAX files)
+        Name => 'AppVersion',
+        ValueConv => 'sprintf("%d.%.4d",$val >> 16, $val & 0xffff)',
+    },
+  # 0x18 ? seen -1
+  # 0x19 ? seen 0
+  # 0x1a ? seen 0
+  # 0x1b ? seen 0
+  # 0x1c ? seen 0,1
+  # 0x1d ? seen 1
+  # 0x1e ? seen 1
+  # 0x1f ? seen 1,5
+  # 0x20 ? seen 0,5
+  # 0x21 ? seen -1
+  # 0x22 ? seen 0
+   '_PID_LINKBASE' => {
+        Name => 'HyperlinkBase',
+        ValueConv => '$self->Decode($val, "UCS2","II")',
+    },
+   '_PID_HLINKS' => {
+        Name => 'Hyperlinks',
+        RawConv => \&ProcessHyperlinks,
+    },
+);
+
+# Image Information properties
+%Image::ExifTool::FlashPix::ImageInfo = (
+    PROCESS_PROC => \&ProcessProperties,
+    GROUPS => { 2 => 'Image' },
+    0x21000000 => {
+        Name => 'FileSource',
+        PrintConv => {
+            1 => 'Film Scanner',
+            2 => 'Reflection Print Scanner',
+            3 => 'Digital Camera',
+            4 => 'Video Capture',
+            5 => 'Computer Graphics',
+        },
+    },
+    0x21000001 => {
+        Name => 'SceneType',
+        PrintConv => {
+            1 => 'Original Scene',
+            2 => 'Second Generation Scene',
+            3 => 'Digital Scene Generation',
+        },
+    },
+    0x21000002 => 'CreationPathVector',
+    0x21000003 => 'SoftwareRelease',
+    0x21000004 => 'UserDefinedID',
+    0x21000005 => 'SharpnessApproximation',
+    0x22000000 => { Name => 'Copyright',                 Groups => { 2 => 'Author' } },
+    0x22000001 => { Name => 'OriginalImageBroker',       Groups => { 2 => 'Author' } },
+    0x22000002 => { Name => 'DigitalImageBroker',        Groups => { 2 => 'Author' } },
+    0x22000003 => { Name => 'Authorship',                Groups => { 2 => 'Author' } },
+    0x22000004 => { Name => 'IntellectualPropertyNotes', Groups => { 2 => 'Author' } },
+    0x23000000 => {
+        Name => 'TestTarget',
+        PrintConv => {
+            1 => 'Color Chart',
+            2 => 'Gray Card',
+            3 => 'Grayscale',
+            4 => 'Resolution Chart',
+            5 => 'Inch Scale',
+            6 => 'Centimeter Scale',
+            7 => 'Millimeter Scale',
+            8 => 'Micrometer Scale',
+        },
+    },
+    0x23000002 => 'GroupCaption',
+    0x23000003 => 'CaptionText',
+    0x23000004 => 'People',
+    0x23000007 => 'Things',
+    0x2300000A => {
+        Name => 'DateTimeOriginal',
+        Description => 'Date/Time Original',
+        Groups => { 2 => 'Time' },
+        PrintConv => '$self->ConvertDateTime($val)',
+    },
+    0x2300000B => 'Events',
+    0x2300000C => 'Places',
+    0x2300000F => 'ContentDescriptionNotes',
+    0x24000000 => { Name => 'Make',             Groups => { 2 => 'Camera' } },
+    0x24000001 => {
+        Name => 'Model',
+        Description => 'Camera Model Name',
+        Groups => { 2 => 'Camera' },
+    },
+    0x24000002 => { Name => 'SerialNumber',     Groups => { 2 => 'Camera' } },
+    0x25000000 => {
+        Name => 'CreateDate',
+        Groups => { 2 => 'Time' },
+        PrintConv => '$self->ConvertDateTime($val)',
+    },
+    0x25000001 => {
+        Name => 'ExposureTime',
+        PrintConv => 'Image::ExifTool::Exif::PrintExposureTime($val)',
+    },
+    0x25000002 => {
+        Name => 'FNumber',
+        PrintConv => 'sprintf("%.1f",$val)',
+    },
+    0x25000003 => {
+        Name => 'ExposureProgram',
+        Groups => { 2 => 'Camera' },
+        # use PrintConv of corresponding EXIF tag
+        PrintConv => $Image::ExifTool::Exif::Main{0x8822}->{PrintConv},
+    },
+    0x25000004 => 'BrightnessValue',
+    0x25000005 => 'ExposureCompensation',
+    0x25000006 => {
+        Name => 'SubjectDistance',
+        Groups => { 2 => 'Camera' },
+        PrintConv => 'sprintf("%.3f m", $val)',
+    },
+    0x25000007 => {
+        Name => 'MeteringMode',
+        Groups => { 2 => 'Camera' },
+        PrintConv => $Image::ExifTool::Exif::Main{0x9207}->{PrintConv},
+    },
+    0x25000008 => {
+        Name => 'LightSource',
+        Groups => { 2 => 'Camera' },
+        PrintConv => $Image::ExifTool::Exif::Main{0x9208}->{PrintConv},
+    },
+    0x25000009 => {
+        Name => 'FocalLength',
+        Groups => { 2 => 'Camera' },
+        PrintConv => 'sprintf("%.1f mm",$val)',
+    },
+    0x2500000A => {
+        Name => 'MaxApertureValue',
+        Groups => { 2 => 'Camera' },
+        ValueConv => '2 ** ($val / 2)',
+        PrintConv => 'sprintf("%.1f",$val)',
+    },
+    0x2500000B => {
+        Name => 'Flash',
+        Groups => { 2 => 'Camera' },
+        PrintConv => {
+            1 => 'No Flash',
+            2 => 'Flash Fired',
+        },
+    },
+    0x2500000C => {
+        Name => 'FlashEnergy',
+        Groups => { 2 => 'Camera' },
+    },
+    0x2500000D => {
+        Name => 'FlashReturn',
+        Groups => { 2 => 'Camera' },
+        PrintConv => {
+            1 => 'Subject Outside Flash Range',
+            2 => 'Subject Inside Flash Range',
+        },
+    },
+    0x2500000E => {
+        Name => 'BackLight',
+        PrintConv => {
+            1 => 'Front Lit',
+            2 => 'Back Lit 1',
+            3 => 'Back Lit 2',
+        },
+    },
+    0x2500000F => { Name => 'SubjectLocation', Groups => { 2 => 'Camera' } },
+    0x25000010 => 'ExposureIndex',
+    0x25000011 => {
+        Name => 'SpecialEffectsOpticalFilter',
+        PrintConv => {
+            1 => 'None',
+            2 => 'Colored',
+            3 => 'Diffusion',
+            4 => 'Multi-image',
+            5 => 'Polarizing',
+            6 => 'Split-field',
+            7 => 'Star',
+        },
+    },
+    0x25000012 => 'PerPictureNotes',
+    0x26000000 => {
+        Name => 'SensingMethod',
+        Groups => { 2 => 'Camera' },
+        PrintConv => $Image::ExifTool::Exif::Main{0x9217}->{PrintConv},
+    },
+    0x26000001 => { Name => 'FocalPlaneXResolution', Groups => { 2 => 'Camera' } },
+    0x26000002 => { Name => 'FocalPlaneYResolution', Groups => { 2 => 'Camera' } },
+    0x26000003 => {
+        Name => 'FocalPlaneResolutionUnit',
+        Groups => { 2 => 'Camera' },
+        PrintConv => $Image::ExifTool::Exif::Main{0xa210}->{PrintConv},
+    },
+    0x26000004 => 'SpatialFrequencyResponse',
+    0x26000005 => 'CFAPattern',
+    0x27000001 => {
+        Name => 'FilmCategory',
+        PrintConv => {
+            1 => 'Negative B&W',
+            2 => 'Negative Color',
+            3 => 'Reversal B&W',
+            4 => 'Reversal Color',
+            5 => 'Chromagenic',
+            6 => 'Internegative B&W',
+            7 => 'Internegative Color',
+        },
+    },
+    0x26000007 => 'ISO',
+    0x26000008 => 'Opto-ElectricConvFactor',
+    0x27000000 => 'FilmBrand',
+    0x27000001 => 'FilmCategory',
+    0x27000002 => 'FilmSize',
+    0x27000003 => 'FilmRollNumber',
+    0x27000004 => 'FilmFrameNumber',
+    0x29000000 => 'OriginalScannedImageSize',
+    0x29000001 => 'OriginalDocumentSize',
+    0x29000002 => {
+        Name => 'OriginalMedium',
+        PrintConv => {
+            1 => 'Continuous Tone Image',
+            2 => 'Halftone Image',
+            3 => 'Line Art',
+        },
+    },
+    0x29000003 => {
+        Name => 'TypeOfOriginal',
+        PrintConv => {
+            1 => 'B&W Print',
+            2 => 'Color Print',
+            3 => 'B&W Document',
+            4 => 'Color Document',
+        },
+    },
+    0x28000000 => 'ScannerMake',
+    0x28000001 => 'ScannerModel',
+    0x28000002 => 'ScannerSerialNumber',
+    0x28000003 => 'ScanSoftware',
+    0x28000004 => { Name => 'ScanSoftwareRevisionDate', Groups => { 2 => 'Time' } },
+    0x28000005 => 'ServiceOrganizationName',
+    0x28000006 => 'ScanOperatorID',
+    0x28000008 => {
+        Name => 'ScanDate',
+        Groups => { 2 => 'Time' },
+        PrintConv => '$self->ConvertDateTime($val)',
+    },
+    0x28000009 => {
+        Name => 'ModifyDate',
+        Groups => { 2 => 'Time' },
+        PrintConv => '$self->ConvertDateTime($val)',
+    },
+    0x2800000A => 'ScannerPixelSize',
+);
+
+# Image Contents properties
+%Image::ExifTool::FlashPix::Image = (
+    PROCESS_PROC => \&ProcessProperties,
+    GROUPS => { 2 => 'Image' },
+    # VARS storage is used as a hash lookup for tagID's which aren't constant.
+    # The key is a mask for significant bits of the tagID, and the value
+    # is a lookup for tagID's for which this mask is valid.
+    VARS => {
+        # ID's are different for each subimage
+        0xff00ffff => {
+            0x02000000=>1, 0x02000001=>1, 0x02000002=>1, 0x02000003=>1,
+            0x02000004=>1, 0x02000005=>1, 0x02000006=>1, 0x02000007=>1,
+            0x03000001=>1,
+        },
+    },
+    0x01000000 => 'NumberOfResolutions',
+    0x01000002 => 'ImageWidth',     # width of highest resolution image
+    0x01000003 => 'ImageHeight',
+    0x01000004 => 'DefaultDisplayHeight',
+    0x01000005 => 'DefaultDisplayWidth',
+    0x01000006 => {
+        Name => 'DisplayUnits',
+        PrintConv => {
+            0 => 'inches',
+            1 => 'meters',
+            2 => 'cm',
+            3 => 'mm',
+        },
+    },
+    0x02000000 => 'SubimageWidth',
+    0x02000001 => 'SubimageHeight',
+    0x02000002 => {
+        Name => 'SubimageColor',
+        # decode only component count and color space of first component
+        ValueConv => 'sprintf("%.2x %.4x", unpack("x4vx4v",$val))',
+        PrintConv => {
+            '01 0000' => 'Opacity Only',
+            '01 8000' => 'Opacity Only (uncalibrated)',
+            '01 0001' => 'Monochrome',
+            '01 8001' => 'Monochrome (uncalibrated)',
+            '03 0002' => 'YCbCr',
+            '03 8002' => 'YCbCr (uncalibrated)',
+            '03 0003' => 'RGB',
+            '03 8003' => 'RGB (uncalibrated)',
+            '04 0002' => 'YCbCr with Opacity',
+            '04 8002' => 'YCbCr with Opacity (uncalibrated)',
+            '04 0003' => 'RGB with Opacity',
+            '04 8003' => 'RGB with Opacity (uncalibrated)',
+        },
+    },
+    0x02000003 => {
+        Name => 'SubimageNumericalFormat',
+        PrintConv => {
+            17 => '8-bit, Unsigned',
+            18 => '16-bit, Unsigned',
+            19 => '32-bit, Unsigned',
+        },
+    },
+    0x02000004 => {
+        Name => 'DecimationMethod',
+        PrintConv => {
+            0 => 'None (Full-sized Image)',
+            8 => '8-point Prefilter',
+        },
+    },
+    0x02000005 => 'DecimationPrefilterWidth',
+    0x02000007 => 'SubimageICC_Profile',
+    0x03000001 => { Name => 'JPEGTables', Binary => 1 },
+    0x03000002 => 'MaxJPEGTableIndex',
+);
+
+# Extension List properties
+%Image::ExifTool::FlashPix::Extensions = (
+    PROCESS_PROC => \&ProcessProperties,
+    GROUPS => { 2 => 'Other' },
+    VARS => {
+        # ID's are different for each extension type
+        0x0000ffff => {
+            0x0001=>1, 0x0002=>1, 0x0003=>1, 0x0004=>1,
+            0x0005=>1, 0x0006=>1, 0x0007=>1, 0x1000=>1,
+            0x2000=>1, 0x2001=>1, 0x3000=>1, 0x4000=>1,
+        },
+        0x0000f00f => { 0x3001=>1, 0x3002=>1 },
+    },
+    0x10000000 => 'UsedExtensionNumbers',
+    0x0001 => 'ExtensionName',
+    0x0002 => 'ExtensionClassID',
+    0x0003 => {
+        Name => 'ExtensionPersistence',
+        PrintConv => {
+            0 => 'Always Valid',
+            1 => 'Invalidated By Modification',
+            2 => 'Potentially Invalidated By Modification',
+        },
+    },
+    0x0004 => { Name => 'ExtensionCreateDate', Groups => { 2 => 'Time' } },
+    0x0005 => { Name => 'ExtensionModifyDate', Groups => { 2 => 'Time' } },
+    0x0006 => 'CreatingApplication',
+    0x0007 => 'ExtensionDescription',
+    0x1000 => 'Storage-StreamPathname',
+    0x2000 => 'FlashPixStreamPathname',
+    0x2001 => 'FlashPixStreamFieldOffset',
+    0x3000 => 'PropertySetPathname',
+    0x3001 => 'PropertySetIDCodes',
+    0x3002 => 'PropertyVectorElements',
+    0x4000 => 'SubimageResolutions',
+);
+
+# Subimage Header tags
+%Image::ExifTool::FlashPix::SubimageHdr = (
+    PROCESS_PROC => \&Image::ExifTool::ProcessBinaryData,
+    FORMAT => 'int32u',
+#   0 => 'HeaderLength',
+    1 => 'SubimageWidth',
+    2 => 'SubimageHeight',
+    3 => 'SubimageTileCount',
+    4 => 'SubimageTileWidth',
+    5 => 'SubimageTileHeight',
+    6 => 'NumChannels',
+#   7 => 'TileHeaderOffset',
+#   8 => 'TileHeaderLength',
+    # ... followed by tile header table
+);
+
+# Data Object properties
+%Image::ExifTool::FlashPix::DataObject = (
+    PROCESS_PROC => \&ProcessProperties,
+    GROUPS => { 2 => 'Other' },
+    0x00010000 => 'DataObjectID',
+    0x00010002 => 'LockedPropertyList',
+    0x00010003 => 'DataObjectTitle',
+    0x00010004 => 'LastModifier',
+    0x00010005 => 'RevisionNumber',
+    0x00010006 => { Name => 'DataCreateDate', Groups => { 2 => 'Time' } },
+    0x00010007 => { Name => 'DataModifyDate', Groups => { 2 => 'Time' } },
+    0x00010008 => 'CreatingApplication',
+    0x00010100 => {
+        Name => 'DataObjectStatus',
+        PrintConv => q{
+            ($val & 0x0000ffff ? 'Exists' : 'Does Not Exist') .
+            ', ' . ($val & 0xffff0000 ? 'Not ' : '') . 'Purgeable'
+        },
+    },
+    0x00010101 => {
+        Name => 'CreatingTransform',
+        PrintConv => '$val ? $val :  "Source Image"',
+    },
+    0x00010102 => 'UsingTransforms',
+    0x10000000 => 'CachedImageHeight',
+    0x10000001 => 'CachedImageWidth',
+);
+
+# Transform properties
+%Image::ExifTool::FlashPix::Transform = (
+    PROCESS_PROC => \&ProcessProperties,
+    GROUPS => { 2 => 'Other' },
+    0x00010000 => 'TransformNodeID',
+    0x00010001 => 'OperationClassID',
+    0x00010002 => 'LockedPropertyList',
+    0x00010003 => 'TransformTitle',
+    0x00010004 => 'LastModifier',
+    0x00010005 => 'RevisionNumber',
+    0x00010006 => { Name => 'TransformCreateDate', Groups => { 2 => 'Time' } },
+    0x00010007 => { Name => 'TransformModifyDate', Groups => { 2 => 'Time' } },
+    0x00010008 => 'CreatingApplication',
+    0x00010100 => 'InputDataObjectList',
+    0x00010101 => 'OutputDataObjectList',
+    0x00010102 => 'OperationNumber',
+    0x10000000 => 'ResultAspectRatio',
+    0x10000001 => 'RectangleOfInterest',
+    0x10000002 => 'Filtering',
+    0x10000003 => 'SpatialOrientation',
+    0x10000004 => 'ColorTwistMatrix',
+    0x10000005 => 'ContrastAdjustment',
+);
+
+# Operation properties
+%Image::ExifTool::FlashPix::Operation = (
+    PROCESS_PROC => \&ProcessProperties,
+    0x00010000 => 'OperationID',
+);
+
+# Global Info properties
+%Image::ExifTool::FlashPix::GlobalInfo = (
+    PROCESS_PROC => \&ProcessProperties,
+    0x00010002 => 'LockedPropertyList',
+    0x00010003 => 'TransformedImageTitle',
+    0x00010004 => 'LastModifier',
+    0x00010100 => 'VisibleOutputs',
+    0x00010101 => 'MaximumImageIndex',
+    0x00010102 => 'MaximumTransformIndex',
+    0x00010103 => 'MaximumOperationIndex',
+);
+
+# Audio Info properties
+%Image::ExifTool::FlashPix::AudioInfo = (
+    PROCESS_PROC => \&ProcessProperties,
+    GROUPS => { 2 => 'Audio' },
+);
+
+# MacroMedia flash contents
+%Image::ExifTool::FlashPix::Contents = (
+    PROCESS_PROC => \&ProcessProperties,
+    GROUPS => { 2 => 'Image' },
+);
+
+# CompObj tags
+%Image::ExifTool::FlashPix::CompObj = (
+    PROCESS_PROC => \&Image::ExifTool::ProcessBinaryData,
+    GROUPS => { 2 => 'Other' },
+    FORMAT => 'int32u',
+    0 => { Name => 'CompObjUserTypeLen' },
+    1 => {
+        Name => 'CompObjUserType',
+        Format => 'string[$val{0}]',
+        RawConv => '$$self{CompObjUserType} = $val', # (use to determine file type)
+    },
+);
+
+# FujiFilm "Property" information (ref PH)
+%Image::ExifTool::FlashPix::PreviewInfo = (
+    PROCESS_PROC => \&Image::ExifTool::ProcessBinaryData,
+    GROUPS => { 2 => 'Image' },
+    NOTES => 'Preview information written by some FujiFilm models.',
+    FIRST_ENTRY => 0,
+    # values are all constant for for my samples except the two decoded tags
+    # 0x0000: 01 01 00 00 02 01 00 00 00 00 00 00 00 xx xx 01
+    # 0x0010: 01 00 00 00 00 00 00 xx xx 00 00 00 00 00 00 00
+    # 0x0020: 00 00 00 00 00
+    0x0d => {
+        Name => 'PreviewImageWidth',
+        Format => 'int16u',
+    },
+    0x17 => {
+        Name => 'PreviewImageHeight',
+        Format => 'int16u',
+    },
+);
+
+# composite FlashPix tags
+%Image::ExifTool::FlashPix::Composite = (
+    GROUPS => { 2 => 'Image' },
+    PreviewImage => {
+        Groups => { 2 => 'Preview' },
+        # extract JPEG preview from ScreenNail if possible
+        Require => {
+            0 => 'ScreenNail',
+        },
+        Binary => 1,
+        RawConv => q{
+            return undef unless $val[0] =~ /\xff\xd8\xff/g;
+            @grps = $self->GetGroup($$val{0});  # set groups from ScreenNail
+            return substr($val[0], pos($val[0])-3);
+        },
+    },
+);
+
+# add our composite tags
+Image::ExifTool::AddCompositeTags('Image::ExifTool::FlashPix');
+
+#------------------------------------------------------------------------------
+# Process hyperlinks from PID_HYPERLINKS array
+# (ref http://msdn.microsoft.com/archive/default.asp?url=/archive/en-us/dnaro97ta/html/msdn_hyper97.asp)
+# Inputs: 0) value, 1) ExifTool ref
+# Returns: list of hyperlinks
+sub ProcessHyperlinks($$)
+{
+    my ($val, $et) = @_;
+
+    # process as an array of VT_VARIANT's
+    my $dirEnd = length $val;
+    return undef if $dirEnd < 4;
+    my $num = Get32u(\$val, 0);
+    my $valPos = 4;
+    my ($i, @vals);
+    for ($i=0; $i<$num; ++$i) {
+        # read VT_BLOB entries as an array of VT_VARIANT's
+        my $value = ReadFPXValue($et, \$val, $valPos, VT_VARIANT, $dirEnd);
+        last unless defined $value;
+        push @vals, $value;
+    }
+    # filter values to extract only the links
+    my @links;
+    for ($i=0; $i<@vals; $i+=6) {
+        push @links, $vals[$i+4];    # get address
+        $links[-1] .= '#' . $vals[$i+5] if length $vals[$i+5]; # add subaddress
+    }
+    return \@links;
+}
+
+#------------------------------------------------------------------------------
+# Read FlashPix value
+# Inputs: 0) ExifTool ref, 1) data ref, 2) value offset, 3) FPX format number,
+#         4) end offset, 5) flag for no padding, 6) code page
+# Returns: converted value (or list of values in list context) and updates
+#          value offset to end of value if successful, or returns undef on error
+sub ReadFPXValue($$$$$;$$)
+{
+    my ($et, $dataPt, $valPos, $type, $dirEnd, $noPad, $codePage) = @_;
+    my @vals;
+
+    my $format = $oleFormat{$type & 0x0fff};
+    while ($format) {
+        my $count = 1;
+        # handle VT_VECTOR types
+        my $flags = $type & 0xf000;
+        if ($flags) {
+            if ($flags == VT_VECTOR) {
+                $noPad = 1;     # values don't seem to be padded inside vectors
+                my $size = $oleFormatSize{VT_VECTOR};
+                last if $valPos + $size > $dirEnd;
+                $count = Get32u($dataPt, $valPos);
+                push @vals, '' if $count == 0;  # allow zero-element vector
+                $valPos += 4;
+            } else {
+                # can't yet handle this property flag
+                last;
+            }
+        }
+        unless ($format =~ /^VT_/) {
+            my $size = Image::ExifTool::FormatSize($format) * $count;
+            last if $valPos + $size > $dirEnd;
+            @vals = ReadValue($dataPt, $valPos, $format, $count, $size);
+            # update position to end of value plus padding
+            $valPos += ($count * $size + 3) & 0xfffffffc;
+            last;
+        }
+        my $size = $oleFormatSize{$format};
+        my ($item, $val);
+        for ($item=0; $item<$count; ++$item) {
+            last if $valPos + $size > $dirEnd;
+            if ($format eq 'VT_VARIANT') {
+                my $subType = Get32u($dataPt, $valPos);
+                $valPos += $size;
+                $val = ReadFPXValue($et, $dataPt, $valPos, $subType, $dirEnd, $noPad, $codePage);
+                last unless defined $val;
+                push @vals, $val;
+                next;   # avoid adding $size to $valPos again
+            } elsif ($format eq 'VT_FILETIME') {
+                # convert from time in 100 ns increments to time in seconds
+                $val = 1e-7 * Image::ExifTool::Get64u($dataPt, $valPos);
+                # print as date/time if value is greater than one year (PH hack)
+                my $secDay = 24 * 3600;
+                if ($val > 365 * $secDay) {
+                    # shift from Jan 1, 1601 to Jan 1, 1970
+                    my $unixTimeZero = 134774 * $secDay;
+                    $val -= $unixTimeZero;
+                    # there are a lot of bad programmers out there...
+                    my $sec100yr = 100 * 365 * $secDay;
+                    if ($val < 0 || $val > $sec100yr) {
+                        # some software writes the wrong byte order (but the proper word order)
+                        my @w = unpack("x${valPos}NN", $$dataPt);
+                        my $v2 = ($w[0] + $w[1] * 4294967296) * 1e-7 - $unixTimeZero;
+                        if ($v2 > 0 && $v2 < $sec100yr) {
+                            $val = $v2;
+                        # also check for wrong time base
+                        } elsif ($val < 0 && $val + $unixTimeZero > 0) {
+                            $val += $unixTimeZero;
+                        }
+                    }
+                    $val = Image::ExifTool::ConvertUnixTime($val);
+                }
+            } elsif ($format eq 'VT_DATE') {
+                $val = Image::ExifTool::GetDouble($dataPt, $valPos);
+                # shift zero from Dec 30, 1899 to Jan 1, 1970 and convert to secs
+                $val = ($val - 25569) * 24 * 3600 if $val != 0;
+                $val = Image::ExifTool::ConvertUnixTime($val);
+            } elsif ($format =~ /STR$/) {
+                my $len = Get32u($dataPt, $valPos);
+                $len *= 2 if $format eq 'VT_LPWSTR';    # convert to byte count
+                last if $valPos + $len + 4 > $dirEnd;
+                $val = substr($$dataPt, $valPos + 4, $len);
+                if ($format eq 'VT_LPWSTR') {
+                    # convert wide string from Unicode
+                    $val = $et->Decode($val, 'UCS2');
+                } elsif ($codePage) {
+                    my $charset = $Image::ExifTool::charsetName{"cp$codePage"};
+                    if ($charset) {
+                        $val = $et->Decode($val, $charset);
+                    } elsif ($codePage eq 1200) {   # UTF-16, little endian
+                        $val = $et->Decode($val, 'UCS2', 'II');
+                    }
+                }
+                $val =~ s/\0.*//s;  # truncate at null terminator
+                # update position for string length
+                # (the spec states that strings should be padded to align
+                #  on even 32-bit boundaries, but this isn't always the case)
+                $valPos += $noPad ? $len : ($len + 3) & 0xfffffffc;
+            } elsif ($format eq 'VT_BLOB' or $format eq 'VT_CF') {
+                my $len = Get32u($dataPt, $valPos);
+                last if $valPos + $len + 4 > $dirEnd;
+                $val = substr($$dataPt, $valPos + 4, $len);
+                # update position for data length plus padding
+                # (does this padding disappear in arrays too?)
+                $valPos += ($len + 3) & 0xfffffffc;
+            } elsif ($format eq 'VT_CLSID') {
+                $val = Image::ExifTool::ASF::GetGUID(substr($$dataPt, $valPos, $size));
+            }
+            $valPos += $size;   # update value pointer to end of value
+            push @vals, $val;
+        }
+        # join VT_ values with commas unless we want an array
+        @vals = ( join $et->Options('ListSep'), @vals ) if @vals > 1 and not wantarray;
+        last;   # didn't really want to loop
+    }
+    $_[2] = $valPos;    # return updated value position
+
+    if (wantarray) {
+        return @vals;
+    } elsif (@vals > 1) {
+        return join(' ', @vals);
+    } else {
+        return $vals[0];
+    }
+}
+
+#------------------------------------------------------------------------------
+# Scan for XMP in FLA Contents (ref PH)
+# Inputs: 0) ExifTool object ref, 1) dirInfo ref, 2) tag table ref
+# Returns: 1 on success
+# Notes: FLA format is proprietary and I couldn't find any documentation,
+#        so this routine is entirely based on observations from sample files
+sub ProcessContents($$$)
+{
+    my ($et, $dirInfo, $tagTablePtr) = @_;
+    my $dataPt = $$dirInfo{DataPt};
+    my $isFLA;
+
+    # all of my FLA samples contain "Contents" data, and no other FPX-like samples have
+    # this, but check the data for a familiar pattern to be sure this is FLA: the
+    # Contents of all of my FLA samples start with two bytes (0x29,0x38,0x3f,0x43 or 0x47,
+    # then 0x01) followed by a number of zero bytes (from 0x18 to 0x26 of them, related
+    # somehow to the value of the first byte), followed by the string "DocumentPage"
+    $isFLA = 1 if $$dataPt =~ /^..\0+\xff\xff\x01\0\x0d\0CDocumentPage/s;
+
+    # do a brute-force scan of the "Contents" for UTF-16 XMP
+    # (this may always be little-endian, but allow for either endianness)
+    if ($$dataPt =~ /<\0\?\0x\0p\0a\0c\0k\0e\0t\0 \0b\0e\0g\0i\0n\0=\0['"](\0\xff\xfe|\xfe\xff)/g) {
+        $$dirInfo{DirStart} = pos($$dataPt) - 36;
+        if ($$dataPt =~ /<\0\?\0x\0p\0a\0c\0k\0e\0t\0 \0e\0n\0d\0=\0['"]\0[wr]\0['"]\0\?\0>\0?/g) {
+            $$dirInfo{DirLen} = pos($$dataPt) - $$dirInfo{DirStart};
+            Image::ExifTool::XMP::ProcessXMP($et, $dirInfo, $tagTablePtr);
+            # override format if not already FLA but XMP-dc:Format indicates it is
+            $isFLA = 1 if $$et{FILE_TYPE} ne 'FLA' and $$et{VALUE}{Format} and
+                          $$et{VALUE}{Format} eq 'application/vnd.adobe.fla';
+        }
+    }
+    $et->OverrideFileType('FLA') if $isFLA;
+    return 1;
+}
+
+#------------------------------------------------------------------------------
+# Check FPX byte order mark (BOM) and set byte order appropriately
+# Inputs: 0) data ref, 1) offset to BOM
+# Returns: true on success
+sub CheckBOM($$)
+{
+    my ($dataPt, $pos) = @_;
+    my $bom = Get16u($dataPt, $pos);
+    return 1 if $bom == 0xfffe;
+    return 0 unless $bom == 0xfeff;
+    ToggleByteOrder();
+    return 1;
+}
+
+#------------------------------------------------------------------------------
+# Process FlashPix properties
+# Inputs: 0) ExifTool object ref, 1) dirInfo ref, 2) tag table ref
+# Returns: 1 on success
+sub ProcessProperties($$$)
+{
+    my ($et, $dirInfo, $tagTablePtr) = @_;
+    my $dataPt = $$dirInfo{DataPt};
+    my $pos = $$dirInfo{DirStart} || 0;
+    my $dirLen = $$dirInfo{DirLen} || length($$dataPt) - $pos;
+    my $dirEnd = $pos + $dirLen;
+    my $verbose = $et->Options('Verbose');
+    my $n;
+
+    if ($dirLen < 48) {
+        $et->Warn('Truncated FPX properties');
+        return 0;
+    }
+    # check and set our byte order if necessary
+    unless (CheckBOM($dataPt, $pos)) {
+        $et->Warn('Bad FPX property byte order mark');
+        return 0;
+    }
+    # get position of start of section
+    $pos = Get32u($dataPt, $pos + 44);
+    if ($pos < 48) {
+        $et->Warn('Bad FPX property section offset');
+        return 0;
+    }
+    for ($n=0; $n<2; ++$n) {
+        my %dictionary;     # dictionary to translate user-defined properties
+        my $codePage;
+        last if $pos + 8 > $dirEnd;
+        # read property section header
+        my $size = Get32u($dataPt, $pos);
+        last unless $size;
+        my $numEntries = Get32u($dataPt, $pos + 4);
+        $verbose and $et->VerboseDir('Property Info', $numEntries, $size);
+        if ($pos + 8 + 8 * $numEntries > $dirEnd) {
+            $et->Warn('Truncated property list');
+            last;
+        }
+        my $index;
+        for ($index=0; $index<$numEntries; ++$index) {
+            my $entry = $pos + 8 + 8 * $index;
+            my $tag = Get32u($dataPt, $entry);
+            my $offset = Get32u($dataPt, $entry + 4);
+            my $valStart = $pos + 4 + $offset;
+            last if $valStart >= $dirEnd;
+            my $valPos = $valStart;
+            my $type = Get32u($dataPt, $pos + $offset);
+            if ($tag == 0) {
+                # read dictionary to get tag name lookup for this property set
+                my $i;
+                for ($i=0; $i<$type; ++$i) {
+                    last if $valPos + 8 > $dirEnd;
+                    $tag = Get32u($dataPt, $valPos);
+                    my $len = Get32u($dataPt, $valPos + 4);
+                    $valPos += 8 + $len;
+                    last if $valPos > $dirEnd;
+                    my $name = substr($$dataPt, $valPos - $len, $len);
+                    $name =~ s/\0.*//s;
+                    next unless length $name;
+                    $dictionary{$tag} = $name;
+                    next if $$tagTablePtr{$name};
+                    $tag = $name;
+                    $name =~ s/(^| )([a-z])/\U$2/g; # start with uppercase
+                    $name =~ tr/-_a-zA-Z0-9//dc;    # remove illegal characters
+                    next unless length $name;
+                    $et->VPrint(0, "$$et{INDENT}\[adding $name]\n") if $verbose;
+                    AddTagToTable($tagTablePtr, $tag, { Name => $name });
+                }
+                next;
+            }
+            # use tag name from dictionary if available
+            my ($custom, $val);
+            if (defined $dictionary{$tag}) {
+                $tag = $dictionary{$tag};
+                $custom = 1;
+            }
+            my @vals = ReadFPXValue($et, $dataPt, $valPos, $type, $dirEnd, undef, $codePage);
+            @vals or $et->Warn('Error reading property value');
+            $val = @vals > 1 ? \@vals : $vals[0];
+            my $format = $type & 0x0fff;
+            my $flags = $type & 0xf000;
+            my $formStr = $oleFormat{$format} || "Type $format";
+            $formStr .= '|' . ($oleFlags{$flags} || sprintf("0x%x",$flags)) if $flags;
+            my $tagInfo;
+            # check for common tag ID's: Dictionary, CodePage and LocaleIndicator
+            # (must be done before masking because masked tags may overlap these ID's)
+            if (not $custom and ($tag == 1 or $tag == 0x80000000)) {
+                # get tagInfo from SummaryInfo table
+                my $summaryTable = GetTagTable('Image::ExifTool::FlashPix::SummaryInfo');
+                $tagInfo = $et->GetTagInfo($summaryTable, $tag);
+                if ($tag == 1) {
+                    $val += 0x10000 if $val < 0; # (may be incorrectly stored as int16s)
+                    $codePage = $val;            # save code page for translating values
+                }
+            } elsif ($$tagTablePtr{$tag}) {
+                $tagInfo = $et->GetTagInfo($tagTablePtr, $tag);
+            } elsif ($$tagTablePtr{VARS} and not $custom) {
+                # mask off insignificant bits of tag ID if necessary
+                my $masked = $$tagTablePtr{VARS};
+                my $mask;
+                foreach $mask (keys %$masked) {
+                    if ($masked->{$mask}->{$tag & $mask}) {
+                        $tagInfo = $et->GetTagInfo($tagTablePtr, $tag & $mask);
+                        last;
+                    }
+                }
+            }
+            $et->HandleTag($tagTablePtr, $tag, $val,
+                DataPt  => $dataPt,
+                Start   => $valStart,
+                Size    => $valPos - $valStart,
+                Format  => $formStr,
+                Index   => $index,
+                TagInfo => $tagInfo,
+                Extra   => ", type=$type",
+            );
+        }
+        # issue warning if we hit end of property section prematurely
+        $et->Warn('Truncated property data') if $index < $numEntries;
+        last unless $$dirInfo{Multi};
+        $pos += $size;
+    }
+
+    return 1;
+}
+
+#------------------------------------------------------------------------------
+# Load chain of sectors from file
+# Inputs: 0) RAF ref, 1) first sector number, 2) FAT ref, 3) sector size, 4) header size
+sub LoadChain($$$$$)
+{
+    my ($raf, $sect, $fatPt, $sectSize, $hdrSize) = @_;
+    return undef unless $raf;
+    my $chain = '';
+    my ($buff, %loadedSect);
+    for (;;) {
+        last if $sect >= END_OF_CHAIN;
+        return undef if $loadedSect{$sect}; # avoid infinite loop
+        $loadedSect{$sect} = 1;
+        my $offset = $sect * $sectSize + $hdrSize;
+        return undef unless ($offset <= 0x7fffffff or $$raf{LargeFileSupport}) and
+                            $raf->Seek($offset, 0) and
+                            $raf->Read($buff, $sectSize) == $sectSize;
+        $chain .= $buff;
+        # step to next sector in chain
+        return undef if $sect * 4 > length($$fatPt) - 4;
+        $sect = Get32u($fatPt, $sect * 4);
+    }
+    return $chain;
+}
+
+#------------------------------------------------------------------------------
+# Extract information from a JPEG APP2 FPXR segment
+# Inputs: 0) ExifTool object ref, 1) dirInfo ref, 2) tag table ref
+# Returns: 1 on success
+sub ProcessFPXR($$$)
+{
+    my ($et, $dirInfo, $tagTablePtr) = @_;
+    my $dataPt = $$dirInfo{DataPt};
+    my $dirStart = $$dirInfo{DirStart};
+    my $dirLen = $$dirInfo{DirLen};
+    my $verbose = $et->Options('Verbose');
+
+    if ($dirLen < 13) {
+        $et->Warn('FPXR segment too small');
+        return 0;
+    }
+
+    # get version and segment type (version is 0 in all my samples)
+    my ($vers, $type) = unpack('x5C2', $$dataPt);
+
+    if ($type == 1) {   # a "Contents List" segment
+
+        $vers != 0 and $et->Warn("Untested FPXR version $vers");
+        if ($$et{FPXR}) {
+            $et->Warn('Multiple FPXR contents lists');
+            delete $$et{FPXR};
+        }
+        my $numEntries = unpack('x7n', $$dataPt);
+        my @contents;
+        $verbose and $et->VerboseDir('Contents List', $numEntries);
+        my $pos = 9;
+        my $entry;
+        for ($entry = 0; $entry < $numEntries; ++$entry) {
+            if ($pos + 4 > $dirLen) {
+                $et->Warn('Truncated FPXR contents');
+                return 0;
+            }
+            my ($size, $default) = unpack("x${pos}Na", $$dataPt);
+            pos($$dataPt) = $pos + 5;
+            # according to the spec, this string is little-endian
+            # (very odd, since the size word is big-endian),
+            # and the first char must be '/'
+            unless ($$dataPt =~ m{\G(/\0(..)*?)\0\0}sg) {
+                $et->Warn('Invalid FPXR stream name');
+                return 0;
+            }
+            # convert stream pathname to ascii
+            my $name = Image::ExifTool::Decode(undef, $1, 'UCS2', 'II', 'Latin');
+            if ($verbose) {
+                my $psize = ($size == 0xffffffff) ? 'storage' : "$size bytes";
+                $et->VPrint(0,"  |  $entry) Name: '$name' [$psize]\n");
+            }
+            # remove directory specification
+            $name =~ s{.*/}{}s;
+            # read storage class ID if necessary
+            my $classID;
+            if ($size == 0xffffffff) {
+                unless ($$dataPt =~ m{(.{16})}sg) {
+                    $et->Warn('Truncated FPXR storage class ID');
+                    return 0;
+                }
+                # unpack class ID in case we want to use it sometime
+                $classID = Image::ExifTool::ASF::GetGUID($1);
+            }
+            # find the tagInfo if available
+            my $tagInfo;
+            unless ($$tagTablePtr{$name}) {
+                # remove instance number or class ID from tag if necessary
+                $tagInfo = $et->GetTagInfo($tagTablePtr, $1) if
+                    ($name =~ /(.*) \d{6}$/s and $$tagTablePtr{$1}) or
+                    ($name =~ /(.*)_[0-9a-f]{16}$/s and $$tagTablePtr{$1});
+            }
+            # update position in list
+            $pos = pos($$dataPt);
+            # add to our contents list
+            push @contents, {
+                Name => $name,
+                Size => $size,
+                Default => $default,
+                ClassID => $classID,
+                TagInfo => $tagInfo,
+            };
+        }
+        # save contents list as $et member variable
+        # (must do this last so we don't save list on error)
+        $$et{FPXR} = \@contents;
+
+    } elsif ($type == 2) {  # a "Stream Data" segment
+
+        # get the contents list index and stream data offset
+        my ($index, $offset) = unpack('x7nN', $$dataPt);
+        my $fpxr = $$et{FPXR};
+        if ($fpxr and $$fpxr[$index]) {
+            my $obj = $$fpxr[$index];
+            # extract stream data (after 13-byte header)
+            if (not defined $$obj{Stream}) {
+                # ignore offset for first segment of this type
+                # (in my sample images, this isn't always zero as one would expect)
+                $$obj{Stream} = substr($$dataPt, $dirStart+13);
+            } else {
+                # add data at the proper offset to the stream
+                my $overlap = length($$obj{Stream}) - $offset;
+                my $start = $dirStart + 13;
+                if ($overlap < 0 or $dirLen - $overlap < 13) {
+                    $et->WarnOnce("Bad FPXR stream $index offset",1);
+                } else {
+                    # ignore any overlapping data in this segment
+                    # (this seems to be the convention)
+                    $start += $overlap;
+                }
+                # concatenate data with this stream
+                $$obj{Stream} .= substr($$dataPt, $start);
+            }
+            # save value for this tag if stream is complete
+            my $len = length $$obj{Stream};
+            if ($len >= $$obj{Size}) {
+                $et->VPrint(0, "  + [FPXR stream $index, $len bytes]\n") if $verbose;
+                if ($len > $$obj{Size}) {
+                    $et->Warn('Extra data in FPXR segment (truncated)');
+                    $$obj{Stream} = substr($$obj{Stream}, 0, $$obj{Size});
+                }
+                # handle this tag
+                $et->HandleTag($tagTablePtr, $$obj{Name}, $$obj{Stream},
+                    DataPt => \$$obj{Stream},
+                    TagInfo => $$obj{TagInfo},
+                );
+                delete $$obj{Stream}; # done with this stream
+            }
+        # hack for improperly stored FujiFilm PreviewImage (stored with no contents list)
+        } elsif ($index == 512 and $dirLen > 60 and ($$et{FujiPreview} or
+            ($dirLen > 64 and substr($$dataPt, $dirStart+60, 4) eq "\xff\xd8\xff\xdb")))
+        {
+            $$et{FujiPreview} = '' unless defined $$et{FujiPreview};
+            # recombine PreviewImage, skipping 13-byte FPXR header + 47-byte Fuji header
+            $$et{FujiPreview} .= substr($$dataPt, $dirStart+60);
+        } else {
+            # (Kodak uses index 255 for a free segment in images from some cameras)
+            $et->Warn("Unlisted FPXR segment (index $index)") if $index != 255;
+        }
+
+    } elsif ($type ne 3) {  # not a "Reserved" segment
+
+        $et->Warn("Unknown FPXR segment (type $type)");
+
+    }
+
+    # clean up if this was the last FPXR segment
+    if ($$dirInfo{LastFPXR}) {
+        if ($$et{FPXR}) {
+            my $obj;
+            foreach $obj (@{$$et{FPXR}}) {
+                next unless defined $$obj{Stream} and length $$obj{Stream};
+                # parse it even though it isn't the proper length
+                $et->HandleTag($tagTablePtr, $$obj{Name}, $$obj{Stream},
+                    DataPt => \$$obj{Stream},
+                    TagInfo => $$obj{TagInfo},
+                );
+            }
+            delete $$et{FPXR};    # delete our temporary variables
+        }
+        if ($$et{FujiPreview}) {
+            $et->FoundTag('PreviewImage', $$et{FujiPreview});
+            delete $$et{FujiPreview};
+        }
+    }
+    return 1;
+}
+
+#------------------------------------------------------------------------------
+# Set document number for objects
+# Inputs: 0) object hierarchy hash ref, 1) object index, 2) doc number list ref,
+#         3) doc numbers used at each level, 4) flag set for metadata levels
+sub SetDocNum($$;$$$)
+{
+    my ($hier, $index, $doc, $used, $meta) = @_;
+    my $obj = $$hier{$index} or return;
+    return if exists $$obj{DocNum};
+    $$obj{DocNum} = $doc;
+    SetDocNum($hier, $$obj{Left}, $doc, $used, $meta) if $$obj{Left};
+    SetDocNum($hier, $$obj{Right}, $doc, $used, $meta) if $$obj{Right};
+    if (defined $$obj{Child}) {
+        $used or $used = [ ];
+        my @subDoc;
+        push @subDoc, @$doc if $doc;
+        # we must dive down 2 levels for each sub-document, so use the
+        # $meta flag to add a sub-document level only for every 2nd generation
+        if ($meta) {
+            my $subNum = ($$used[scalar @subDoc] || 0);
+            $$used[scalar @subDoc] = $subNum;
+            push @subDoc, $subNum;
+        } elsif (@subDoc) {
+            $subDoc[-1] = ++$$used[$#subDoc];
+        }
+        SetDocNum($hier, $$obj{Child}, \@subDoc, $used, not $meta);
+    }
+}
+
+#------------------------------------------------------------------------------
+# Extract information from a FlashPix (FPX) file
+# Inputs: 0) ExifTool object ref, 1) dirInfo ref
+# Returns: 1 on success, 0 if this wasn't a valid FPX-format file
+sub ProcessFPX($$)
+{
+    my ($et, $dirInfo) = @_;
+    my $raf = $$dirInfo{RAF};
+    my ($buff, $out, %dumpParms, $oldIndent, $miniStreamBuff);
+    my ($tag, %hier, %objIndex);
+
+    # read header
+    return 0 unless $raf->Read($buff,HDR_SIZE) == HDR_SIZE;
+    # check signature
+    return 0 unless $buff =~ /^\xd0\xcf\x11\xe0\xa1\xb1\x1a\xe1/;
+
+    # set FileType initially based on file extension (we may override this later)
+    my $fileType = $$et{FILE_EXT};
+    $fileType = 'FPX' unless $fileType and $fpxFileType{$fileType};
+    $et->SetFileType($fileType);
+    SetByteOrder(substr($buff, 0x1c, 2) eq "\xff\xfe" ? 'MM' : 'II');
+    my $tagTablePtr = GetTagTable('Image::ExifTool::FlashPix::Main');
+    my $verbose = $et->Options('Verbose');
+    # copy LargeFileSupport option to RAF for use in LoadChain
+    $$raf{LargeFileSupport} = $et->Options('LargeFileSupport');
+
+    my $sectSize = 1 << Get16u(\$buff, 0x1e);
+    my $miniSize = 1 << Get16u(\$buff, 0x20);
+    my $fatCount   = Get32u(\$buff, 0x2c);  # number of FAT sectors
+    my $dirStart   = Get32u(\$buff, 0x30);  # first directory sector
+    my $miniCutoff = Get32u(\$buff, 0x38);  # minimum size for big-FAT streams
+    my $miniStart  = Get32u(\$buff, 0x3c);  # first sector of mini-FAT
+    my $miniCount  = Get32u(\$buff, 0x40);  # number of mini-FAT sectors
+    my $difStart   = Get32u(\$buff, 0x44);  # first sector of DIF chain
+    my $difCount   = Get32u(\$buff, 0x48);  # number of DIF sectors
+
+    if ($verbose) {
+        $out = $et->Options('TextOut');
+        $dumpParms{Out} = $out;
+        $dumpParms{MaxLen} = 96 if $verbose == 3;
+        print $out "  Sector size=$sectSize\n  FAT: Count=$fatCount\n";
+        print $out "  DIR: Start=$dirStart\n";
+        print $out "  MiniFAT: Mini-sector size=$miniSize Start=$miniStart Count=$miniCount Cutoff=$miniCutoff\n";
+        print $out "  DIF FAT: Start=$difStart Count=$difCount\n";
+    }
+#
+# load the FAT
+#
+    my $pos = 0x4c;
+    my $endPos = length($buff);
+    my $fat = '';
+    my $fatCountCheck = 0;
+    my $hdrSize = $sectSize > HDR_SIZE ? $sectSize : HDR_SIZE;
+    for (;;) {
+        while ($pos <= $endPos - 4) {
+            my $sect = Get32u(\$buff, $pos);
+            $pos += 4;
+            next if $sect == FREE_SECT;
+            my $offset = $sect * $sectSize + $hdrSize;
+            my $fatSect;
+            unless ($raf->Seek($offset, 0) and
+                    $raf->Read($fatSect, $sectSize) == $sectSize)
+            {
+                $et->Error("Error reading FAT from sector $sect");
+                return 1;
+            }
+            $fat .= $fatSect;
+            ++$fatCountCheck;
+        }
+        last if $difStart >= END_OF_CHAIN;
+        # read next DIF (Dual Indirect FAT) sector
+        my $offset = $difStart * $sectSize + $hdrSize;
+        unless ($raf->Seek($offset, 0) and $raf->Read($buff, $sectSize) == $sectSize) {
+            $et->Error("Error reading DIF sector $difStart");
+            return 1;
+        }
+        # set end of sector information in this DIF
+        $pos = 0;
+        $endPos = $sectSize - 4;
+        # next time around we want to read next DIF in chain
+        $difStart = Get32u(\$buff, $endPos);
+    }
+    if ($fatCountCheck != $fatCount) {
+        $et->Warn("Bad number of FAT sectors (expected $fatCount but found $fatCountCheck)");
+    }
+#
+# load the mini-FAT and the directory
+#
+    my $miniFat = LoadChain($raf, $miniStart, \$fat, $sectSize, $hdrSize);
+    my $dir = LoadChain($raf, $dirStart, \$fat, $sectSize, $hdrSize);
+    unless (defined $miniFat and defined $dir) {
+        $et->Error('Error reading mini-FAT or directory stream');
+        return 1;
+    }
+    if ($verbose) {
+        print $out "  FAT [",length($fat)," bytes]:\n";
+        HexDump(\$fat, undef, %dumpParms) if $verbose > 2;
+        print $out "  Mini-FAT [",length($miniFat)," bytes]:\n";
+        HexDump(\$miniFat, undef, %dumpParms) if $verbose > 2;
+        print $out "  Directory [",length($dir)," bytes]:\n";
+        HexDump(\$dir, undef, %dumpParms) if $verbose > 2;
+    }
+#
+# process the directory
+#
+    if ($verbose) {
+        $oldIndent = $$et{INDENT};
+        $$et{INDENT} .= '| ';
+        $et->VerboseDir('FPX', undef, length $dir);
+    }
+    my $miniStream;
+    $endPos = length($dir);
+    my $index = 0;
+
+    for ($pos=0; $pos<=$endPos-128; $pos+=128, ++$index) {
+
+        # get directory entry type
+        # (0=invalid, 1=storage, 2=stream, 3=lockbytes, 4=property, 5=root)
+        my $type = Get8u(\$dir, $pos + 0x42);
+        next if $type == 0; # skip invalid entries
+        if ($type > 5) {
+            $et->Warn("Invalid directory entry type $type");
+            last;   # rest of directory is probably garbage
+        }
+        # get entry name (note: this is supposed to be length in 2-byte
+        # characters but this isn't what is done in my sample FPX file, so
+        # be very tolerant of this count -- it's null terminated anyway)
+        my $len = Get16u(\$dir, $pos + 0x40);
+        $len > 32 and $len = 32;
+        $tag = Image::ExifTool::Decode(undef, substr($dir,$pos,$len*2), 'UCS2', 'II', 'Latin');
+        $tag =~ s/\0.*//s;  # truncate at null (in case length was wrong)
+
+        my $sect = Get32u(\$dir, $pos + 0x74);  # start sector number
+        my $size = Get32u(\$dir, $pos + 0x78);  # stream length
+
+        # load Ministream (referenced from first directory entry)
+        unless ($miniStream) {
+            $miniStreamBuff = LoadChain($raf, $sect, \$fat, $sectSize, $hdrSize);
+            unless (defined $miniStreamBuff) {
+                $et->Warn('Error loading Mini-FAT stream');
+                last;
+            }
+            $miniStream = new File::RandomAccess(\$miniStreamBuff);
+        }
+
+        my $tagInfo;
+        if ($$tagTablePtr{$tag}) {
+            $tagInfo = $et->GetTagInfo($tagTablePtr, $tag);
+        } else {
+            # remove instance number or class ID from tag if necessary
+            $tagInfo = $et->GetTagInfo($tagTablePtr, $1) if
+                ($tag =~ /(.*) \d{6}$/s and $$tagTablePtr{$1}) or
+                ($tag =~ /(.*)_[0-9a-f]{16}$/s and $$tagTablePtr{$1});
+        }
+
+        my $lSib = Get32u(\$dir, $pos + 0x44);  # left sibling
+        my $rSib = Get32u(\$dir, $pos + 0x48);  # right sibling
+        my $chld = Get32u(\$dir, $pos + 0x4c);  # child directory
+
+        # save information about object hierachy
+        my ($obj, $sub);
+        $obj = $hier{$index} or $obj = $hier{$index} = { };
+        $$obj{Left} = $lSib unless $lSib == FREE_SECT;
+        $$obj{Right} = $rSib unless $rSib == FREE_SECT;
+        unless ($chld == FREE_SECT) {
+            $$obj{Child} = $chld;
+            $sub = $hier{$chld} or $sub = $hier{$chld} = { };
+            $$sub{Parent} = $index;
+        }
+
+        next unless $tagInfo or $verbose;
+
+        # load the data for stream types
+        my $extra = '';
+        my $typeStr = $dirEntryType[$type] || $type;
+        if ($typeStr eq 'STREAM') {
+            if ($size >= $miniCutoff) {
+                # stream is in the main FAT
+                $buff = LoadChain($raf, $sect, \$fat, $sectSize, $hdrSize);
+            } elsif ($size) {
+                # stream is in the mini-FAT
+                $buff = LoadChain($miniStream, $sect, \$miniFat, $miniSize, 0);
+            } else {
+                $buff = ''; # an empty stream
+            }
+            unless (defined $buff) {
+                my $name = $tagInfo ? $$tagInfo{Name} : 'unknown';
+                $et->Warn("Error reading $name stream");
+                $buff = '';
+            }
+        } elsif ($typeStr eq 'ROOT') {
+            $buff = $miniStreamBuff;
+            $extra .= ' (Ministream)';
+        } else {
+            $buff = '';
+            undef $size;
+        }
+        if ($verbose) {
+            my $flags = Get8u(\$dir, $pos + 0x43);  # 0=red, 1=black
+            my $col = { 0 => 'Red', 1 => 'Black' }->{$flags} || $flags;
+            $extra .= " Type=$typeStr Flags=$col";
+            $extra .= " Left=$lSib" unless $lSib == FREE_SECT;
+            $extra .= " Right=$rSib" unless $rSib == FREE_SECT;
+            $extra .= " Child=$chld" unless $chld == FREE_SECT;
+            $et->VerboseInfo($tag, $tagInfo,
+                Index  => $index,
+                Value  => $buff,
+                DataPt => \$buff,
+                Extra  => $extra,
+                Size   => $size,
+            );
+        }
+        if ($tagInfo and $buff) {
+            my $num = $$et{NUM_FOUND};
+            my $subdir = $$tagInfo{SubDirectory};
+            if ($subdir) {
+                my %dirInfo = (
+                    DataPt   => \$buff,
+                    DirStart => $$subdir{DirStart},
+                    DirLen   => length $buff,
+                    Multi    => $$tagInfo{Multi},
+                );
+                my $subTablePtr = GetTagTable($$subdir{TagTable});
+                $et->ProcessDirectory(\%dirInfo, $subTablePtr,  $$subdir{ProcessProc});
+            } else {
+                $et->FoundTag($tagInfo, $buff);
+            }
+            # save object index number for all found tags
+            my $num2 = $$et{NUM_FOUND};
+            $objIndex{++$num} = $index while $num < $num2;
+        }
+    }
+    # set document numbers for tags extracted from embedded documents
+    unless ($$et{DOC_NUM}) {
+        # initialize document number for all objects, beginning at root (index 0)
+        SetDocNum(\%hier, 0);
+        # set family 3 group name for all tags in embedded documents
+        my $order = $$et{FILE_ORDER};
+        my (@pri, $copy, $member);
+        foreach $tag (keys %$order) {
+            my $num = $$order{$tag};
+            next unless defined $num and $objIndex{$num};
+            my $obj = $hier{$objIndex{$num}} or next;
+            my $docNums = $$obj{DocNum};
+            next unless $docNums and @$docNums;
+            $$et{TAG_EXTRA}{$tag}{G3} = join '-', @$docNums;
+            push @pri, $tag unless $tag =~ / /; # save keys for priority sub-doc tags
+        }
+        # swap priority sub-document tags with main document tags if they exist
+        foreach $tag (@pri) {
+            for ($copy=1; ;++$copy) {
+                my $key = "$tag ($copy)";
+                last unless defined $$et{VALUE}{$key};
+                my $extra = $$et{TAG_EXTRA}{$key};
+                next if $extra and $$extra{G3}; # not Main if family 3 group is set
+                foreach $member ('PRIORITY','VALUE','FILE_ORDER','TAG_INFO','TAG_EXTRA') {
+                    my $pHash = $$et{$member};
+                    my $t = $$pHash{$tag};
+                    $$pHash{$tag} = $$pHash{$key};
+                    $$pHash{$key} = $t;
+                }
+                last;
+            }
+        }
+    }
+    $$et{INDENT} = $oldIndent if $verbose;
+    # try to better identify the file type
+    if ($$et{VALUE}{FileType} eq 'FPX') {
+        my $val = $$et{CompObjUserType} || $$et{Software};
+        if ($val) {
+            my %type = ( '^3ds Max' => 'MAX', Word => 'DOC', PowerPoint => 'PPT', Excel => 'XLS' );
+            my $pat;
+            foreach $pat (sort keys %type) {
+                next unless $val =~ /$pat/;
+                $et->OverrideFileType($type{$pat});
+                last;
+            }
+        }
+    }
+    return 1;
+}
+
+1;  # end
+
+__END__
+
+=head1 NAME
+
+Image::ExifTool::FlashPix - Read FlashPix meta information
+
+=head1 SYNOPSIS
+
+This module is used by Image::ExifTool
+
+=head1 DESCRIPTION
+
+This module contains routines required by Image::ExifTool to extract
+FlashPix meta information from FPX images, and from the APP2 FPXR segment of
+JPEG images.
+
+=head1 AUTHOR
+
+Copyright 2003-2017, Phil Harvey (phil at owl.phy.queensu.ca)
+
+This library is free software; you can redistribute it and/or modify it
+under the same terms as Perl itself.
+
+=head1 REFERENCES
+
+=over 4
+
+=item L<http://www.exif.org/Exif2-2.PDF>
+
+=item L<http://www.graphcomp.com/info/specs/livepicture/fpx.pdf>
+
+=item L<http://search.cpan.org/~jdb/libwin32/>
+
+=item L<http://msdn.microsoft.com/en-us/library/aa380374.aspx>
+
+=back
+
+=head1 SEE ALSO
+
+L<Image::ExifTool::TagNames/FlashPix Tags>,
+L<Image::ExifTool::TagNames/OOXML Tags>,
+L<Image::ExifTool(3pm)|Image::ExifTool>
+
+=cut
+