Changeset 34921 for main/trunk/greenstone2/perllib/cpan/Image/ExifTool/FlashPix.pm

Timestamp:

2021-02-26T19:39:51+13:00 (3 years ago)

Author:

anupama

Message:

Committing the improvements to EmbeddedMetaPlugin's processing of Keywords vs other metadata fields. Keywords were literally stored as arrays of words rather than phrases in PDFs (at least in Diego's sample PDF), whereas other meta fields like Subjects and Creators stored them as arrays of phrases. To get both to work, Kathy updated EXIF to a newer version, to retrieve the actual EXIF values stored in the PDF. And Kathy and Dr Bainbridge came up with a new option that I added called apply_join_before_split_to_metafields that's a regex which can list the metadata fields to apply the join_before_split to and whcih previously always got applied to all metadata fields. Now it's applied to any *Keywords metafields by default, as that's the metafield we have experience of that behaves differently to the others, as it stores by word instead of phrases. Tested on Diego's sample PDF. Diego has double-checked it to works on his sample PDF too, setting the split char to ; and turning on the join_before_split and leaving apply_join_before_split_to_metafields at its default of .*Keywords. File changes are strings.properties for the tooltip, the plugin introducing the option and working with it and Kathy's EXIF updates affecting cpan/File and cpan/Image.

File:

• main/trunk/greenstone2/perllib/cpan/Image/ExifTool/FlashPix.pm (modified) (68 diffs)

main/trunk/greenstone2/perllib/cpan/Image/ExifTool/FlashPix.pm

@@ -10 +10 @@
 #               3) http://search.cpan.org/~jdb/libwin32/
 #               4) http://msdn.microsoft.com/en-us/library/aa380374.aspx
+#               5) http://www.cpan.org/modules/by-authors/id/H/HC/HCARVEY/File-MSWord-0.1.zip
+#               6) https://msdn.microsoft.com/en-us/library/cc313153(v=office.12).aspx
 #------------------------------------------------------------------------------
 
@@ -20 +22 @@
 use Image::ExifTool::ASF;   # for GetGUID()
 
-$VERSION = '1.19';
+$VERSION = '1.38';
 
 sub ProcessFPX($$);
@@ -28 +30 @@
 sub ProcessHyperlinks($$);
 sub ProcessContents($$$);
+sub ProcessWordDocument($$$);
+sub ProcessDocumentTable($);
+sub ProcessCommentBy($$$);
+sub ProcessLastSavedBy($$$);
 sub SetDocNum($$;$$$);
+sub ConvertDTTM($);
 
 # sector type constants
@@ -80 +87 @@
     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, number of nanoseconds since Jan 1, 1601)
+    64 => 'VT_FILETIME',# VT_FILETIME (int64u, 100 ns increments since Jan 1, 1601)
     65 => 'VT_BLOB',    # VT_BLOB
 #   66 => 'VT_STREAM',
@@ -119 +126 @@
 # (ref http://msdn.microsoft.com/en-us/library/dd317756(VS.85).aspx)
 my %codePage = (
-    037 => 'IBM EBCDIC US-Canada',
+     37 => 'IBM EBCDIC US-Canada',
     437 => 'DOS United States',
     500 => 'IBM EBCDIC International',
@@ -299 +306 @@
         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 Kodak and Hewlett-Packard digital cameras.
+        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
@@ -306 +314 @@
         (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
+        Compound Binary File format).  Note that ExifTool identifies any
+        unrecognized Windows Compound Binary file as a FlashPix (FPX) file.  See
         L<http://graphcomp.com/info/specs/livepicture/fpx.pdf> for the FlashPix
         specification.
@@ -371 +380 @@
     },
 #   'Subimage 0000 Data'
-    "\x05Data Object" => {  # plus instance number (ie. " 000000")
+    "\x05Data Object" => {  # plus instance number (eg. " 000000")
         Name => 'DataObject',
         SubDirectory => {
@@ -377 +386 @@
         },
     },
-#   "\x05Data Object Store" => { # plus instance number (ie. " 000000")
-    "\x05Transform" => {    # plus instance number (ie. " 000000")
+#   "\x05Data Object Store" => { # plus instance number (eg. " 000000")
+    "\x05Transform" => {    # plus instance number (eg. " 000000")
         Name => 'Transform',
         SubDirectory => {
@@ -384 +393 @@
         },
     },
-    "\x05Operation" => {    # plus instance number (ie. " 000000")
+    "\x05Operation" => {    # plus instance number (eg. " 000000")
         Name => 'Operation',
         SubDirectory => {
@@ -396 +405 @@
         },
     },
-    "\x05Screen Nail" => { # plus class ID (ie. "_bd0100609719a180")
+    "\x05Screen Nail" => { # plus class ID (eg. "_bd0100609719a180")
         Name => 'ScreenNail',
         Groups => { 2 => 'Other' },
@@ -408 +417 @@
         },
     },
-    'Audio Stream' => { # plus instance number (ie. " 000000")
+    'Audio Stream' => { # plus instance number (eg. " 000000")
         Name => 'AudioStream',
         Groups => { 2 => 'Audio' },
@@ -423 +432 @@
             return undef if $len < 0 or length $val < $size + 8;
             return substr($val, 8 + $pos, $len);
+        },
+    },
+    'WordDocument' => {
+        Name => 'WordDocument',
+        SubDirectory => { TagTable => 'Image::ExifTool::FlashPix::WordDocument' },
+    },
+    # save these tables until after the WordDocument was processed
+    '0Table' => {
+        Name => 'Table0',
+        Hidden => 1, # (used only as temporary storage until table is processed)
+        Binary => 1,
+    },
+    '1Table' => {
+        Name => 'Table1',
+        Hidden => 1, # (used only as temporary storage until table is processed)
+        Binary => 1,
+    },
+    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',
         },
     },
@@ -464 +507 @@
     0x0f => 'Words',
     0x10 => 'Characters',
-    0x11 => { Name => 'ThumbnailClip',  Binary => 1 },
+    0x11 => {
+        Name => 'ThumbnailClip',
+        # (not a displayable format, so not in the "Preview" group)
+        Binary => 1,
+    },
     0x12 => {
         Name => 'Software',
@@ -474 +521 @@
         PrintConv => {
             0 => 'None',
-            1 => 'Password protected',
-            2 => 'Read-only recommended',
-            4 => 'Read-only enforced',
-            8 => 'Locked for annotations',
-        },
-    },
+            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' } },
 );
@@ -507 +559 @@
     },
     0x0c => 'HeadingPairs',
-    0x0d => 'TitleOfParts',
+    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',
@@ -515 +574 @@
     },
     0x11 => 'CharCountWithSpaces',
-  # 0x12 ?
+  # 0x12 ? seen -32.1850395202637,-386.220672607422,-9.8100004196167,-9810,...
     0x13 => { #PH (unconfirmed)
         Name => 'SharedDoc',
         PrintConv => { 0 => 'No', 1 => 'Yes' },
     },
-  # 0x14 ?
-  # 0x15 ?
+  # 0x14 ? seen -1
+  # 0x15 ? seen 1
     0x16 => {
         Name => 'HyperlinksChanged',
         PrintConv => { 0 => 'No', 1 => 'Yes' },
     },
-    0x17 => { #PH (unconfirmed handling of lower 16 bits)
+    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',
@@ -985 +1055 @@
 );
 
+# decode Word document FIB header (ref [MS-DOC].pdf)
+%Image::ExifTool::FlashPix::WordDocument = (
+    PROCESS_PROC => \&ProcessWordDocument,
+    GROUPS => { 2 => 'Other' },
+    FORMAT => 'int16u',
+    NOTES => 'Tags extracted from the Microsoft Word document stream.',
+    0 => {
+        Name => 'Identification',
+        PrintHex => 1,
+        PrintConv => {
+            0x6a62 => 'MS Word 97',
+            0x626a => 'Word 98 Mac',
+            0xa5dc => 'Word 6.0/7.0',
+            0xa5ec => 'Word 8.0',
+        },
+    },
+    3 => {
+        Name => 'LanguageCode',
+        PrintHex => 1,
+        PrintConv => {
+            0x0400 => 'None',
+            0x0401 => 'Arabic',
+            0x0402 => 'Bulgarian',
+            0x0403 => 'Catalan',
+            0x0404 => 'Traditional Chinese',
+            0x0804 => 'Simplified Chinese',
+            0x0405 => 'Czech',
+            0x0406 => 'Danish',
+            0x0407 => 'German',
+            0x0807 => 'German (Swiss)',
+            0x0408 => 'Greek',
+            0x0409 => 'English (US)',
+            0x0809 => 'English (British)',
+            0x0c09 => 'English (Australian)',
+            0x040a => 'Spanish (Castilian)',
+            0x080a => 'Spanish (Mexican)',
+            0x040b => 'Finnish',
+            0x040c => 'French',
+            0x080c => 'French (Belgian)',
+            0x0c0c => 'French (Canadian)',
+            0x100c => 'French (Swiss)',
+            0x040d => 'Hebrew',
+            0x040e => 'Hungarian',
+            0x040f => 'Icelandic',
+            0x0410 => 'Italian',
+            0x0810 => 'Italian (Swiss)',
+            0x0411 => 'Japanese',
+            0x0412 => 'Korean',
+            0x0413 => 'Dutch',
+            0x0813 => 'Dutch (Belgian)',
+            0x0414 => 'Norwegian (Bokmal)',
+            0x0814 => 'Norwegian (Nynorsk)',
+            0x0415 => 'Polish',
+            0x0416 => 'Portuguese (Brazilian)',
+            0x0816 => 'Portuguese',
+            0x0417 => 'Rhaeto-Romanic',
+            0x0418 => 'Romanian',
+            0x0419 => 'Russian',
+            0x041a => 'Croato-Serbian (Latin)',
+            0x081a => 'Serbo-Croatian (Cyrillic)',
+            0x041b => 'Slovak',
+            0x041c => 'Albanian',
+            0x041d => 'Swedish',
+            0x041e => 'Thai',
+            0x041f => 'Turkish',
+            0x0420 => 'Urdu',
+            0x0421 => 'Bahasa',
+            0x0422 => 'Ukrainian',
+            0x0423 => 'Byelorussian',
+            0x0424 => 'Slovenian',
+            0x0425 => 'Estonian',
+            0x0426 => 'Latvian',
+            0x0427 => 'Lithuanian',
+            0x0429 => 'Farsi',
+            0x042d => 'Basque',
+            0x042f => 'Macedonian',
+            0x0436 => 'Afrikaans',
+            0x043e => 'Malaysian',
+        },
+    },
+    5 => {
+        Name => 'DocFlags',
+        Mask => 0xff0f, # ignore save count
+        RawConv => '$$self{DocFlags} = $val',
+        PrintConv => { BITMASK => {
+            0 => 'Template',
+            1 => 'AutoText only',
+            2 => 'Complex',
+            3 => 'Has picture',
+            # 4-7 = number of incremental saves
+            8 => 'Encrypted',
+            9 => '1Table',
+            10 => 'Read only',
+            11 => 'Passworded',
+            12 => 'ExtChar',
+            13 => 'Load override',
+            14 => 'Far east',
+            15 => 'Obfuscated',
+        }},
+    },
+    9.1 => {
+        Name => 'System',
+        Mask => 0x0001,
+        PrintConv => {
+            0x0000 => 'Windows',
+            0x0001 => 'Macintosh',
+        },
+    },
+    9.2 => {
+        Name => 'Word97',
+        Mask => 0x0010,
+        PrintConv => { 0 => 'No', 1 => 'Yes' },
+    },
+);
+
+# tags decoded from Word document table
+%Image::ExifTool::FlashPix::DocTable = (
+    GROUPS => { 1 => 'MS-DOC', 2 => 'Document' },
+    NOTES => 'Tags extracted from the Microsoft Word document table.',
+    VARS => { NO_ID => 1 },
+    CommentBy => {
+        Groups => { 2 => 'Author' },
+        Notes => 'enable L<Duplicates|../ExifTool.html#Duplicates> option to extract all entries',
+    },
+    LastSavedBy => {
+        Groups => { 2 => 'Author' },
+        Notes => 'enable L<Duplicates|../ExifTool.html#Duplicates> option to extract history of up to 10 entries',
+    },
+    DOP => { SubDirectory => { TagTable => 'Image::ExifTool::FlashPix::DOP' } },
+    ModifyDate => {
+        Groups => { 2 => 'Time' },
+        Format => 'int64u',
+        Priority => 0,
+        RawConv => q{
+            $val = $val * 1e-7 - 11644473600;   # convert to seconds since 1970
+            return $val > 0 ? $val : undef;
+        },
+        ValueConv => 'ConvertUnixTime($val)',
+        PrintConv => '$self->ConvertDateTime($val)',
+    },
+#
+# tags below are used internally in intermediate steps to extract the tags above
+#
+    TableOffsets => { Hidden => 1 }, # stores offsets to extract data from document table
+    CommentByBlock => {   # entire block of CommentBy entries
+        SubDirectory => {
+            TagTable => 'Image::ExifTool::FlashPix::DocTable',
+            ProcessProc => \&ProcessCommentBy,
+        },
+        Hidden => 1,
+    },
+    LastSavedByBlock => {   # entire block of LastSavedBy entries
+        SubDirectory => {
+            TagTable => 'Image::ExifTool::FlashPix::DocTable',
+            ProcessProc => \&ProcessLastSavedBy,
+        },
+        Hidden => 1,
+    },
+);
+
+# Microsoft Office Document Properties (ref [MS-DOC].pdf)
+%Image::ExifTool::FlashPix::DOP = (
+    PROCESS_PROC => \&Image::ExifTool::ProcessBinaryData,
+    GROUPS => { 1 => 'MS-DOC', 2 => 'Document' },
+    NOTES => 'Microsoft office document properties.',
+    20 => {
+        Name => 'CreateDate',
+        Format => 'int32u',
+        Groups => { 2 => 'Time' },
+        Priority => 0,
+        RawConv => \&ConvertDTTM,
+        PrintConv => '$self->ConvertDateTime($val)',
+    },
+    24 => {
+        Name => 'ModifyDate',
+        Format => 'int32u',
+        Groups => { 2 => 'Time' },
+        Priority => 0,
+        RawConv => \&ConvertDTTM,
+        PrintConv => '$self->ConvertDateTime($val)',
+    },
+    28 => {
+        Name => 'LastPrinted',
+        Format => 'int32u',
+        Groups => { 2 => 'Time' },
+        RawConv => \&ConvertDTTM,
+        PrintConv => '$self->ConvertDateTime($val)',
+    },
+    32 => { Name => 'RevisionNumber', Format => 'int16u' },
+    34 => {
+        Name => 'TotalEditTime',
+        Format => 'int32u',
+        PrintConv => 'ConvertTimeSpan($val,60)',
+    },
+    # (according to the MS-DOC specification, the following are accurate only if
+    # flag 'X' is set, and flag 'u' specifies whether the main or subdoc tags are
+    # used, but in my tests it seems that both are filled in with reasonable values,
+    # so just extract the main counts and ignore the subdoc counts for now - PH)
+    38 => { Name => 'Words',      Format => 'int32u' },
+    42 => { Name => 'Characters', Format => 'int32u' },
+    46 => { Name => 'Pages',      Format => 'int16u' },
+    48 => { Name => 'Paragraphs', Format => 'int32u' },
+    56 => { Name => 'Lines',      Format => 'int32u' },
+    #60 => { Name => 'WordsWithSubdocs',      Format => 'int32u' },
+    #64 => { Name => 'CharactersWithSubdocs', Format => 'int32u' },
+    #68 => { Name => 'PagesWithSubdocs',      Format => 'int16u' },
+    #70 => { Name => 'ParagraphsWithSubdocs', Format => 'int32u' },
+    #74 => { Name => 'LinesWithSubdocs',      Format => 'int32u' },
+);
+
+# 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 => {
@@ -996 +1297 @@
         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);
         },
@@ -1003 +1305 @@
 # add our composite tags
 Image::ExifTool::AddCompositeTags('Image::ExifTool::FlashPix');
+
+#------------------------------------------------------------------------------
+# Convert Microsoft DTTM structure to date/time
+# Inputs: 0) DTTM value
+# Returns: EXIF-format date/time string ("0000:00:00 00:00:00" for zero date/time)
+sub ConvertDTTM($)
+{
+    my $val = shift;
+    my $yr  = ($val >> 20) & 0x1ff;
+    my $mon = ($val >> 16) & 0x0f;
+    my $day = ($val >> 11) & 0x1f;
+    my $hr  = ($val >> 6)  & 0x1f;
+    my $min = ($val & 0x3f);
+    $yr += 1900 if $val;
+    return sprintf("%.4d:%.2d:%.2d %.2d:%.2d:00%s",$yr,$mon,$day,$hr,$min,$val ? 'Z' : '');
+}
 
 #------------------------------------------------------------------------------
@@ -1011 +1329 @@
 sub ProcessHyperlinks($$)
 {
-    my ($val, $exifTool) = @_;
+    my ($val, $et) = @_;
 
     # process as an array of VT_VARIANT's
@@ -1021 +1339 @@
     for ($i=0; $i<$num; ++$i) {
         # read VT_BLOB entries as an array of VT_VARIANT's
-        my $value = ReadFPXValue($exifTool, \$val, $valPos, VT_VARIANT, $dirEnd);
+        my $value = ReadFPXValue($et, \$val, $valPos, VT_VARIANT, $dirEnd);
         last unless defined $value;
         push @vals, $value;
@@ -1042 +1360 @@
 sub ReadFPXValue($$$$$;$$)
 {
-    my ($exifTool, $dataPt, $valPos, $type, $dirEnd, $noPad, $codePage) = @_;
+    my ($et, $dataPt, $valPos, $type, $dirEnd, $noPad, $codePage) = @_;
     my @vals;
 
@@ -1078 +1396 @@
                 my $subType = Get32u($dataPt, $valPos);
                 $valPos += $size;
-                $val = ReadFPXValue($exifTool, $dataPt, $valPos, $subType, $dirEnd, $noPad, $codePage);
+                $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') {
-                # get time in seconds
+                # 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)
-                if ($val > 365 * 24 * 3600) {
+                my $secDay = 24 * 3600;
+                if ($val > 365 * $secDay) {
                     # shift from Jan 1, 1601 to Jan 1, 1970
-                    $val -= 134774 * 24 * 3600 if $val != 0;
+                    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);
                 }
@@ -1103 +1436 @@
                 if ($format eq 'VT_LPWSTR') {
                     # convert wide string from Unicode
-                    $val = $exifTool->Decode($val, 'UCS2');
+                    $val = $et->Decode($val, 'UCS2');
                 } elsif ($codePage) {
                     my $charset = $Image::ExifTool::charsetName{"cp$codePage"};
                     if ($charset) {
-                        $val = $exifTool->Decode($val, $charset);
-                    } elsif ($codePage eq 1200) {   # UTF-16, little endian
-                        $val = $exifTool->Decode(undef, 'UCS2', 'II');
+                        $val = $et->Decode($val, $charset);
+                    } elsif ($codePage == 1200) {   # UTF-16, little endian
+                        $val = $et->Decode($val, 'UCS2', 'II');
                     }
                 }
@@ -1131 +1464 @@
         }
         # join VT_ values with commas unless we want an array
-        @vals = ( join $exifTool->Options('ListSep'), @vals ) if @vals > 1 and not wantarray;
+        @vals = ( join $et->Options('ListSep'), @vals ) if @vals > 1 and not wantarray;
         last;   # didn't really want to loop
     }
@@ -1153 +1486 @@
 sub ProcessContents($$$)
 {
-    my ($exifTool, $dirInfo, $tagTablePtr) = @_;
+    my ($et, $dirInfo, $tagTablePtr) = @_;
     my $dataPt = $$dirInfo{DataPt};
     my $isFLA;
 
-    # all of my FLA samples contain "Contents" data, an no other FPX-like samples have
+    # 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/;
-    
+    $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)
@@ -1170 +1503 @@
         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($exifTool, $dirInfo, $tagTablePtr);
+            Image::ExifTool::XMP::ProcessXMP($et, $dirInfo, $tagTablePtr);
             # override format if not already FLA but XMP-dc:Format indicates it is
-            $isFLA = 1 if $$exifTool{FILE_TYPE} ne 'FLA' and $$exifTool{VALUE}{Format} and
-                          $$exifTool{VALUE}{Format} eq 'application/vnd.adobe.fla';
-        }
-    }
-    $exifTool->OverrideFileType('FLA') if $isFLA;
+            $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;
+}
+
+#------------------------------------------------------------------------------
+# Process WordDocument stream of MSWord doc file (ref 6)
+# Inputs: 0) ExifTool object ref, 1) dirInfo ref, 2) tag table ref
+# Returns: 1 on success
+sub ProcessWordDocument($$$)
+{
+    my ($et, $dirInfo, $tagTablePtr) = @_;
+    my $dataPt = $$dirInfo{DataPt} or return 0;
+    my $dirLen = length $$dataPt;
+    # validate the FIB signature
+    unless ($dirLen > 2 and Get16u($dataPt,0) == 0xa5ec) {
+        $et->WarnOnce('Invalid FIB signature', 1);
+        return 0;
+    }
+    $et->ProcessBinaryData($dirInfo, $tagTablePtr); # process FIB
+    # continue parsing the WordDocument stream until we find the FibRgFcLcb
+    my $pos = 32;
+    return 0 if $pos + 2 > $dirLen;
+    my $n = Get16u($dataPt, $pos);  # read csw
+    $pos += 2 + $n * 2;             # skip fibRgW
+    return 0 if $pos + 2 > $dirLen;
+    $n = Get16u($dataPt, $pos);     # read cslw
+    $pos += 2 + $n * 4;             # skip fibRgLw
+    return 0 if $pos + 2 > $dirLen;
+    $n = Get16u($dataPt, $pos);     # read cbRgFcLcb
+    $pos += 2;  # point to start of fibRgFcLcbBlob
+    return 0 if $pos + $n * 8 > $dirLen;
+    my ($off, @tableOffsets);
+    # save necessary entries for later processing of document table
+    # (DOP, CommentBy, LastSavedBy)
+    foreach $off (0xf8, 0x120, 0x238) {
+        last if $off + 8 > $n * 8;
+        push @tableOffsets, Get32u($dataPt, $pos + $off);
+        push @tableOffsets, Get32u($dataPt, $pos + $off + 4);
+    }
+    my $tbl = GetTagTable('Image::ExifTool::FlashPix::DocTable');
+    # extract ModifyDate if it exists
+    $et->HandleTag($tbl, 'ModifyDate', undef,
+        DataPt => $dataPt,
+        Start  => $pos + 0x2b8,
+        Size   => 8,
+    );
+    $et->HandleTag($tbl, TableOffsets => \@tableOffsets);   # save for later
+    # $pos += $n * 8;                 # skip fibRgFcLcbBlob
+    # return 0 if $pos + 2 > $dirLen;
+    # $n = Get16u($dataPt, $pos);     # read cswNew
+    # return 0 if $pos + 2 + $n * 2 > $dirLen;
+    # my $nFib = Get16u($dataPt, 2 + ($n ? $pos : 0));
+    # $pos += 2 + $n * 2;             # skip fibRgCswNew
+    return 1;
+}
+
+#------------------------------------------------------------------------------
+# Process Microsoft Word Document Table
+# Inputs: 0) ExifTool object ref
+sub ProcessDocumentTable($)
+{
+    my $et = shift;
+    my $value = $$et{VALUE};
+    my $extra = $$et{TAG_EXTRA};
+    my ($i, $j, $tag);
+    # loop through TableOffsets for each sub-document
+    for ($i=0; ; ++$i) {
+        my $key = 'TableOffsets' . ($i ? " ($i)" : '');
+        my $offsets = $$value{$key};
+        last unless defined $offsets;
+        my $doc;
+        $doc = $$extra{$key}{G3} if $$extra{$key};
+        $doc = '' unless $doc;
+        # get DocFlags for this sub-document
+        my ($docFlags, $docTable);
+        for ($j=0; ; ++$j) {
+            my $key = 'DocFlags' . ($j ? " ($j)" : '');
+            last unless defined $$value{$key};
+            my $tmp;
+            $tmp = $$extra{$key}{G3} if $$extra{$key};
+            $tmp = '' unless $tmp;
+            if ($tmp eq $doc) {
+                $docFlags = $$value{$key};
+                last;
+            }
+        }
+        next unless defined $docFlags;
+        $tag = $docFlags & 0x200 ? 'Table1' : 'Table0';
+        # get table for this sub-document
+        for ($j=0; ; ++$j) {
+            my $key = $tag . ($j ? " ($j)" : '');
+            last unless defined $$value{$key};
+            my $tmp;
+            $tmp = $$extra{$key}{G3} if $$extra{$key};
+            $tmp = '' unless $tmp;
+            if ($tmp eq $doc) {
+                $docTable = \$$value{$key};
+                last;
+            }
+        }
+        next unless defined $docTable;
+        # extract DOP and LastSavedBy information from document table
+        $$et{DOC_NUM} = $doc;   # use same document number
+        my $tagTablePtr = GetTagTable('Image::ExifTool::FlashPix::DocTable');
+        foreach $tag (qw(DOP CommentByBlock LastSavedByBlock)) {
+            last unless @$offsets;
+            my $off = shift @$offsets;
+            my $len = shift @$offsets;
+            next unless $len and $off + $len <= length $$docTable;
+            $et->HandleTag($tagTablePtr, $tag, undef,
+                DataPt => $docTable,
+                Start  => $off,
+                Size   => $len,
+            );
+        }
+        delete $$et{DOC_NUM};
+    }
+    # delete intermediate tags
+    foreach $tag (qw(TableOffsets Table0 Table1)) {
+        for ($i=0; ; ++$i) {
+            my $key = $tag . ($i ? " ($i)" : '');
+            last unless defined $$value{$key};
+            $et->DeleteTag($key);
+        }
+    }
+}
+
+#------------------------------------------------------------------------------
+# Extract names of comment authors (ref 6)
+# Inputs: 0) ExifTool object ref, 1) dirInfo ref, 2) tag table ref
+# Returns: 1 on success
+sub ProcessCommentBy($$$)
+{
+    my ($et, $dirInfo, $tagTablePtr) = @_;
+    my $dataPt = $$dirInfo{DataPt};
+    my $pos = $$dirInfo{DirStart};
+    my $end = $$dirInfo{DirLen} + $pos;
+    $et->VerboseDir($$dirInfo{DirName});
+    while ($pos + 2 < $end) {
+        my $len = Get16u($dataPt, $pos);
+        $pos += 2;
+        last if $pos + $len * 2 > $end;
+        my $author = $et->Decode(substr($$dataPt, $pos, $len*2), 'UCS2');
+        $pos += $len * 2;
+        $et->HandleTag($tagTablePtr, CommentBy => $author);
+    }
+    return 1;
+}
+
+#------------------------------------------------------------------------------
+# Extract last-saved-by names (ref 5)
+# Inputs: 0) ExifTool object ref, 1) dirInfo ref, 2) tag table ref
+# Returns: 1 on success
+sub ProcessLastSavedBy($$$)
+{
+    my ($et, $dirInfo, $tagTablePtr) = @_;
+    my $dataPt = $$dirInfo{DataPt};
+    my $pos = $$dirInfo{DirStart};
+    my $end = $$dirInfo{DirLen} + $pos;
+    return 0 if $pos + 6 > $end;
+    $et->VerboseDir($$dirInfo{DirName});
+    my $num = Get16u($dataPt, $pos+2);
+    $pos += 6;
+    while ($num >= 2) {
+        last if $pos + 2 > $end;
+        my $len = Get16u($dataPt, $pos);
+        $pos += 2;
+        last if $pos + $len * 2 > $end;
+        my $author = $et->Decode(substr($$dataPt, $pos, $len*2), 'UCS2');
+        $pos += $len * 2;
+        last if $pos + 2 > $end;
+        $len = Get16u($dataPt, $pos);
+        $pos += 2;
+        last if $pos + $len * 2 > $end;
+        my $path = $et->Decode(substr($$dataPt, $pos, $len*2), 'UCS2');
+        $pos += $len * 2;
+        $et->HandleTag($tagTablePtr, LastSavedBy => "$author ($path)");
+        $num -= 2;
+    }
     return 1;
 }
@@ -1200 +1711 @@
 sub ProcessProperties($$$)
 {
-    my ($exifTool, $dirInfo, $tagTablePtr) = @_;
+    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 = $exifTool->Options('Verbose');
+    my $verbose = $et->Options('Verbose');
     my $n;
 
     if ($dirLen < 48) {
-        $exifTool->Warn('Truncated FPX properties');
+        $et->Warn('Truncated FPX properties');
         return 0;
     }
     # check and set our byte order if necessary
     unless (CheckBOM($dataPt, $pos)) {
-        $exifTool->Warn('Bad FPX property byte order mark');
+        $et->Warn('Bad FPX property byte order mark');
         return 0;
     }
@@ -1220 +1731 @@
     $pos = Get32u($dataPt, $pos + 44);
     if ($pos < 48) {
-        $exifTool->Warn('Bad FPX property section offset');
+        $et->Warn('Bad FPX property section offset');
         return 0;
     }
@@ -1231 +1742 @@
         last unless $size;
         my $numEntries = Get32u($dataPt, $pos + 4);
-        $verbose and $exifTool->VerboseDir('Property Info', $numEntries, $size);
+        $verbose and $et->VerboseDir('Property Info', $numEntries, $size);
         if ($pos + 8 + 8 * $numEntries > $dirEnd) {
-            $exifTool->Warn('Truncated property list');
+            $et->Warn('Truncated property list');
             last;
         }
@@ -1263 +1774 @@
                     $name =~ tr/-_a-zA-Z0-9//dc;    # remove illegal characters
                     next unless length $name;
-                    $exifTool->VPrint(0, "$$exifTool{INDENT}\[adding $name]\n") if $verbose;
-                    Image::ExifTool::AddTagToTable($tagTablePtr, $tag, { Name => $name });
+                    $et->VPrint(0, "$$et{INDENT}\[adding $name]\n") if $verbose;
+                    AddTagToTable($tagTablePtr, $tag, { Name => $name });
                 }
                 next;
@@ -1274 +1785 @@
                 $custom = 1;
             }
-            my @vals = ReadFPXValue($exifTool, $dataPt, $valPos, $type, $dirEnd, undef, $codePage);
-            @vals or $exifTool->Warn('Error reading property value');
+            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;
@@ -1287 +1798 @@
                 # get tagInfo from SummaryInfo table
                 my $summaryTable = GetTagTable('Image::ExifTool::FlashPix::SummaryInfo');
-                $tagInfo = $exifTool->GetTagInfo($summaryTable, $tag);
+                $tagInfo = $et->GetTagInfo($summaryTable, $tag);
                 if ($tag == 1) {
                     $val += 0x10000 if $val < 0; # (may be incorrectly stored as int16s)
@@ -1293 +1804 @@
                 }
             } elsif ($$tagTablePtr{$tag}) {
-                $tagInfo = $exifTool->GetTagInfo($tagTablePtr, $tag);
+                $tagInfo = $et->GetTagInfo($tagTablePtr, $tag);
             } elsif ($$tagTablePtr{VARS} and not $custom) {
                 # mask off insignificant bits of tag ID if necessary
@@ -1300 +1811 @@
                 foreach $mask (keys %$masked) {
                     if ($masked->{$mask}->{$tag & $mask}) {
-                        $tagInfo = $exifTool->GetTagInfo($tagTablePtr, $tag & $mask);
+                        $tagInfo = $et->GetTagInfo($tagTablePtr, $tag & $mask);
                         last;
                     }
                 }
             }
-            $exifTool->HandleTag($tagTablePtr, $tag, $val,
+            $et->HandleTag($tagTablePtr, $tag, $val,
                 DataPt  => $dataPt,
                 Start   => $valStart,
@@ -1316 +1827 @@
         }
         # issue warning if we hit end of property section prematurely
-        $exifTool->Warn('Truncated property data') if $index < $numEntries;
+        $et->Warn('Truncated property data') if $index < $numEntries;
         last unless $$dirInfo{Multi};
         $pos += $size;
@@ -1355 +1866 @@
 sub ProcessFPXR($$$)
 {
-    my ($exifTool, $dirInfo, $tagTablePtr) = @_;
+    my ($et, $dirInfo, $tagTablePtr) = @_;
     my $dataPt = $$dirInfo{DataPt};
     my $dirStart = $$dirInfo{DirStart};
     my $dirLen = $$dirInfo{DirLen};
-    my $verbose = $exifTool->Options('Verbose');
+    my $verbose = $et->Options('Verbose');
 
     if ($dirLen < 13) {
-        $exifTool->Warn('FPXR segment to small');
+        $et->Warn('FPXR segment too small');
         return 0;
     }
@@ -1371 +1882 @@
     if ($type == 1) {   # a "Contents List" segment
 
-        $vers != 0 and $exifTool->Warn("Untested FPXR version $vers");
-        if ($$exifTool{FPXR}) {
-            $exifTool->Warn('Multiple FPXR contents lists');
-            delete $$exifTool{FPXR};
+        $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 $exifTool->VerboseDir('Contents List', $numEntries);
+        $verbose and $et->VerboseDir('Contents List', $numEntries);
         my $pos = 9;
         my $entry;
         for ($entry = 0; $entry < $numEntries; ++$entry) {
             if ($pos + 4 > $dirLen) {
-                $exifTool->Warn('Truncated FPXR contents');
+                $et->Warn('Truncated FPXR contents');
                 return 0;
             }
@@ -1392 +1903 @@
             # and the first char must be '/'
             unless ($$dataPt =~ m{\G(/\0(..)*?)\0\0}sg) {
-                $exifTool->Warn('Invalid FPXR stream name');
+                $et->Warn('Invalid FPXR stream name');
                 return 0;
             }
@@ -1399 +1910 @@
             if ($verbose) {
                 my $psize = ($size == 0xffffffff) ? 'storage' : "$size bytes";
-                $exifTool->VPrint(0,"  |  $entry) Name: '$name' [$psize]\n");
+                $et->VPrint(0,"  |  $entry) Name: '${name}' [$psize]\n");
             }
             # remove directory specification
@@ -1407 +1918 @@
             if ($size == 0xffffffff) {
                 unless ($$dataPt =~ m{(.{16})}sg) {
-                    $exifTool->Warn('Truncated FPXR storage class ID');
+                    $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
@@ -1421 +1940 @@
                 Default => $default,
                 ClassID => $classID,
+                TagInfo => $tagInfo,
             };
         }
-        # save contents list as $exifTool member variable
+        # save contents list as $et member variable
         # (must do this last so we don't save list on error)
-        $$exifTool{FPXR} = \@contents;
+        $$et{FPXR} = \@contents;
 
     } elsif ($type == 2) {  # a "Stream Data" segment
@@ -1431 +1951 @@
         # get the contents list index and stream data offset
         my ($index, $offset) = unpack('x7nN', $$dataPt);
-        my $fpxr = $$exifTool{FPXR};
+        my $fpxr = $$et{FPXR};
         if ($fpxr and $$fpxr[$index]) {
             my $obj = $$fpxr[$index];
@@ -1440 +1960 @@
                 $$obj{Stream} = substr($$dataPt, $dirStart+13);
             } else {
-                # add data to the stream at the proper offset
-                my $pad = $offset - length($$obj{Stream});
-                if ($pad >= 0) {
-                    if ($pad) {
-                        if ($pad > 0x10000) {
-                            $exifTool->Warn("Bad FPXR stream offset ($offset)");
-                        } else {
-                            # pad with default value to specified offset
-                            $exifTool->Warn("Padding FPXR stream with $pad default bytes",1);
-                            $$obj{Stream} .= ($$obj{Default} x $pad);
-                        }
-                    }
-                    # concatenate data with this stream
-                    $$obj{Stream} .= substr($$dataPt, $dirStart+13);
+                # 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 {
-                    $exifTool->Warn("Duplicate FPXR stream data at offset $offset");
-                    substr($$obj{Stream}, $offset, -$pad) = substr($$dataPt, $dirStart+13);
+                    # 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}) {
-                if ($verbose) {
-                    $exifTool->VPrint(0, "  + [FPXR stream, Contents index $index, $len bytes]\n");
-                }
+                $et->VPrint(0, "  + [FPXR stream $index, $len bytes]\n") if $verbose;
                 if ($len > $$obj{Size}) {
-                    $exifTool->Warn('Extra data in FPXR segment (truncated)');
+                    $et->Warn('Extra data in FPXR segment (truncated)');
                     $$obj{Stream} = substr($$obj{Stream}, 0, $$obj{Size});
                 }
-                my $tag = $$obj{Name};
-                my $tagInfo;
-                unless ($$tagTablePtr{$tag}) {
-                    # remove instance number or class ID from tag if necessary
-                    $tagInfo = $exifTool->GetTagInfo($tagTablePtr, $1) if
-                        ($tag =~ /(.*) \d{6}$/s and $$tagTablePtr{$1}) or
-                        ($tag =~ /(.*)_[0-9a-f]{16}$/s and $$tagTablePtr{$1});
-                }
-                # save the data for this tag
-                $exifTool->HandleTag($tagTablePtr, $tag, $$obj{Stream},
+                # handle this tag
+                $et->HandleTag($tagTablePtr, $$obj{Name}, $$obj{Stream},
                     DataPt => \$$obj{Stream},
-                    TagInfo => $tagInfo,
+                    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 ($$exifTool{FujiPreview} or
+        } elsif ($index == 512 and $dirLen > 60 and ($$et{FujiPreview} or
             ($dirLen > 64 and substr($$dataPt, $dirStart+60, 4) eq "\xff\xd8\xff\xdb")))
         {
-            # recombine PreviewImage, skipping unknown 60 byte header
-            if ($$exifTool{FujiPreview}) {
-                $$exifTool{FujiPreview} .= substr($$dataPt, $dirStart+60);
-            } else {
-                $$exifTool{FujiPreview} = substr($$dataPt, $dirStart+60);
-            }
+            $$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)
-            $exifTool->Warn("Unlisted FPXR segment (index $index)") if $index != 255;
-        }
-
-    } elsif ($type ne 3) {  # not a "Reserved" segment
-
-        $exifTool->Warn("Unknown FPXR segment (type $type)");
+            $et->Warn("Unlisted FPXR segment (index $index)") if $index != 255;
+        }
+
+    } elsif ($type != 3) {  # not a "Reserved" segment
+
+        $et->Warn("Unknown FPXR segment (type $type)");
 
     }
@@ -1507 +2008 @@
     # clean up if this was the last FPXR segment
     if ($$dirInfo{LastFPXR}) {
-        if ($$exifTool{FPXR}) {
+        if ($$et{FPXR}) {
             my $obj;
-            my $i = 0;
-            foreach $obj (@{$$exifTool{FPXR}}) {
-                $exifTool->Warn("Missing stream for FPXR object $i") if defined $$obj{Stream};
-                ++$i;
+            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 $$exifTool{FPXR};    # delete our temporary variables
-        }
-        if ($$exifTool{FujiPreview}) {
-            $exifTool->FoundTag('PreviewImage', $$exifTool{FujiPreview});
-            delete $$exifTool{FujiPreview};
+            delete $$et{FPXR};    # delete our temporary variables
+        }
+        if ($$et{FujiPreview}) {
+            $et->FoundTag('PreviewImage', $$et{FujiPreview});
+            delete $$et{FujiPreview};
         }
     }
@@ -1549 +2053 @@
             $subDoc[-1] = ++$$used[$#subDoc];
         }
-        SetDocNum($hier, $$obj{Child}, \@subDoc, $used, not $meta) 
+        SetDocNum($hier, $$obj{Child}, \@subDoc, $used, not $meta);
     }
 }
@@ -1559 +2063 @@
 sub ProcessFPX($$)
 {
-    my ($exifTool, $dirInfo) = @_;
+    my ($et, $dirInfo) = @_;
     my $raf = $$dirInfo{RAF};
-    my ($buff, $out, %dumpParms, $oldIndent, $miniStreamBuff);
-    my ($tag, %hier, %objIndex);
+    my ($buff, $out, $oldIndent, $miniStreamBuff);
+    my ($tag, %hier, %objIndex, %loadedDifSect);
 
     # read header
@@ -1570 +2074 @@
 
     # set FileType initially based on file extension (we may override this later)
-    my $fileType = $exifTool->{FILE_EXT};
+    my $fileType = $$et{FILE_EXT};
     $fileType = 'FPX' unless $fileType and $fpxFileType{$fileType};
-    $exifTool->SetFileType($fileType);
+    $et->SetFileType($fileType);
     SetByteOrder(substr($buff, 0x1c, 2) eq "\xff\xfe" ? 'MM' : 'II');
     my $tagTablePtr = GetTagTable('Image::ExifTool::FlashPix::Main');
-    my $verbose = $exifTool->Options('Verbose');
+    my $verbose = $et->Options('Verbose');
     # copy LargeFileSupport option to RAF for use in LoadChain
-    $$raf{LargeFileSupport} = $exifTool->Options('LargeFileSupport');
+    $$raf{LargeFileSupport} = $et->Options('LargeFileSupport');
 
     my $sectSize = 1 << Get16u(\$buff, 0x1e);
@@ -1590 +2094 @@
 
     if ($verbose) {
-        $out = $exifTool->Options('TextOut');
-        $dumpParms{Out} = $out;
-        $dumpParms{MaxLen} = 96 if $verbose == 3;
+        $out = $et->Options('TextOut');
         print $out "  Sector size=$sectSize\n  FAT: Count=$fatCount\n";
         print $out "  DIR: Start=$dirStart\n";
@@ -1605 +2107 @@
     my $fat = '';
     my $fatCountCheck = 0;
+    my $difCountCheck = 0;
+    my $hdrSize = $sectSize > HDR_SIZE ? $sectSize : HDR_SIZE;
+
     for (;;) {
         while ($pos <= $endPos - 4) {
@@ -1610 +2115 @@
             $pos += 4;
             next if $sect == FREE_SECT;
-            my $offset = $sect * $sectSize + HDR_SIZE;
+            my $offset = $sect * $sectSize + $hdrSize;
             my $fatSect;
             unless ($raf->Seek($offset, 0) and
                     $raf->Read($fatSect, $sectSize) == $sectSize)
             {
-                $exifTool->Error("Error reading FAT from sector $sect");
+                $et->Error("Error reading FAT from sector $sect");
                 return 1;
             }
@@ -1623 +2128 @@
         last if $difStart >= END_OF_CHAIN;
         # read next DIF (Dual Indirect FAT) sector
-        my $offset = $difStart * $sectSize + HDR_SIZE;
+        if (++$difCountCheck > $difCount) {
+            $et->Warn('Unterminated DIF FAT');
+            last;
+        }
+        if ($loadedDifSect{$difStart}) {
+            $et->Warn('Cyclical reference in DIF FAT');
+            last;
+        }
+        my $offset = $difStart * $sectSize + $hdrSize;
         unless ($raf->Seek($offset, 0) and $raf->Read($buff, $sectSize) == $sectSize) {
-            $exifTool->Error("Error reading DIF sector $difStart");
+            $et->Error("Error reading DIF sector $difStart");
             return 1;
         }
+        $loadedDifSect{$difStart} = 1;
         # set end of sector information in this DIF
         $pos = 0;
@@ -1635 +2149 @@
     }
     if ($fatCountCheck != $fatCount) {
-        $exifTool->Warn("Bad number of FAT sectors (expected $fatCount but found $fatCountCheck)");
+        $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, HDR_SIZE);
-    my $dir = LoadChain($raf, $dirStart, \$fat, $sectSize, HDR_SIZE);
+    my $miniFat = LoadChain($raf, $miniStart, \$fat, $sectSize, $hdrSize);
+    my $dir = LoadChain($raf, $dirStart, \$fat, $sectSize, $hdrSize);
     unless (defined $miniFat and defined $dir) {
-        $exifTool->Error('Error reading mini-FAT or directory stream');
+        $et->Error('Error reading mini-FAT or directory stream');
         return 1;
     }
     if ($verbose) {
         print $out "  FAT [",length($fat)," bytes]:\n";
-        Image::ExifTool::HexDump(\$fat, undef, %dumpParms) if $verbose > 2;
+        $et->VerboseDump(\$fat);
         print $out "  Mini-FAT [",length($miniFat)," bytes]:\n";
-        Image::ExifTool::HexDump(\$miniFat, undef, %dumpParms) if $verbose > 2;
+        $et->VerboseDump(\$miniFat);
         print $out "  Directory [",length($dir)," bytes]:\n";
-        Image::ExifTool::HexDump(\$dir, undef, %dumpParms) if $verbose > 2;
+        $et->VerboseDump(\$dir);
     }
 #
@@ -1658 +2172 @@
 #
     if ($verbose) {
-        $oldIndent = $exifTool->{INDENT};
-        $exifTool->{INDENT} .= '| ';
-        $exifTool->VerboseDir('FPX', undef, length $dir);
+        $oldIndent = $$et{INDENT};
+        $$et{INDENT} .= '| ';
+        $et->VerboseDir('FPX', undef, length $dir);
     }
     my $miniStream;
@@ -1673 +2187 @@
         next if $type == 0; # skip invalid entries
         if ($type > 5) {
-            $exifTool->Warn("Invalid directory entry type $type");
+            $et->Warn("Invalid directory entry type $type");
             last;   # rest of directory is probably garbage
         }
@@ -1689 +2203 @@
         # load Ministream (referenced from first directory entry)
         unless ($miniStream) {
-            $miniStreamBuff = LoadChain($raf, $sect, \$fat, $sectSize, HDR_SIZE);
+            $miniStreamBuff = LoadChain($raf, $sect, \$fat, $sectSize, $hdrSize);
             unless (defined $miniStreamBuff) {
-                $exifTool->Warn('Error loading Mini-FAT stream');
+                $et->Warn('Error loading Mini-FAT stream');
                 last;
             }
@@ -1699 +2213 @@
         my $tagInfo;
         if ($$tagTablePtr{$tag}) {
-            $tagInfo = $exifTool->GetTagInfo($tagTablePtr, $tag);
+            $tagInfo = $et->GetTagInfo($tagTablePtr, $tag);
         } else {
             # remove instance number or class ID from tag if necessary
-            $tagInfo = $exifTool->GetTagInfo($tagTablePtr, $1) if
+            $tagInfo = $et->GetTagInfo($tagTablePtr, $1) if
                 ($tag =~ /(.*) \d{6}$/s and $$tagTablePtr{$1}) or
                 ($tag =~ /(.*)_[0-9a-f]{16}$/s and $$tagTablePtr{$1});
@@ -1711 +2225 @@
         my $chld = Get32u(\$dir, $pos + 0x4c);  # child directory
 
-        # save information about object hierachy
+        # save information about object hierarchy
         my ($obj, $sub);
         $obj = $hier{$index} or $obj = $hier{$index} = { };
@@ -1730 +2244 @@
             if ($size >= $miniCutoff) {
                 # stream is in the main FAT
-                $buff = LoadChain($raf, $sect, \$fat, $sectSize, HDR_SIZE);
+                $buff = LoadChain($raf, $sect, \$fat, $sectSize, $hdrSize);
             } elsif ($size) {
                 # stream is in the mini-FAT
@@ -1739 +2253 @@
             unless (defined $buff) {
                 my $name = $tagInfo ? $$tagInfo{Name} : 'unknown';
-                $exifTool->Warn("Error reading $name stream");
+                $et->Warn("Error reading $name stream");
                 $buff = '';
             }
@@ -1756 +2270 @@
             $extra .= " Right=$rSib" unless $rSib == FREE_SECT;
             $extra .= " Child=$chld" unless $chld == FREE_SECT;
-            $exifTool->VerboseInfo($tag, $tagInfo,
+            $et->VerboseInfo($tag, $tagInfo,
                 Index  => $index,
                 Value  => $buff,
@@ -1765 +2279 @@
         }
         if ($tagInfo and $buff) {
-            my $num = $$exifTool{NUM_FOUND};
+            my $num = $$et{NUM_FOUND};
             my $subdir = $$tagInfo{SubDirectory};
             if ($subdir) {
@@ -1775 +2289 @@
                 );
                 my $subTablePtr = GetTagTable($$subdir{TagTable});
-                $exifTool->ProcessDirectory(\%dirInfo, $subTablePtr,  $$subdir{ProcessProc});
+                $et->ProcessDirectory(\%dirInfo, $subTablePtr,  $$subdir{ProcessProc});
             } else {
-                $exifTool->FoundTag($tagInfo, $buff);
+                $et->FoundTag($tagInfo, $buff);
             }
             # save object index number for all found tags
-            my $num2 = $$exifTool{NUM_FOUND};
+            my $num2 = $$et{NUM_FOUND};
             $objIndex{++$num} = $index while $num < $num2;
         }
     }
     # set document numbers for tags extracted from embedded documents
-    unless ($$exifTool{DOC_NUM}) {
+    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 = $$exifTool{FILE_ORDER};
+        my $order = $$et{FILE_ORDER};
         my (@pri, $copy, $member);
         foreach $tag (keys %$order) {
@@ -1797 +2311 @@
             my $docNums = $$obj{DocNum};
             next unless $docNums and @$docNums;
-            $$exifTool{TAG_EXTRA}{$tag}{G3} = join '-', @$docNums;
+            $$et{TAG_EXTRA}{$tag}{G3} = join '-', @$docNums;
             push @pri, $tag unless $tag =~ / /; # save keys for priority sub-doc tags
         }
@@ -1804 +2318 @@
             for ($copy=1; ;++$copy) {
                 my $key = "$tag ($copy)";
-                last unless defined $$exifTool{VALUE}{$key};
-                my $extra = $$exifTool{TAG_EXTRA}{$key};
+                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 = $$exifTool{$member};
+                    my $pHash = $$et{$member};
                     my $t = $$pHash{$tag};
                     $$pHash{$tag} = $$pHash{$key};
@@ -1817 +2331 @@
         }
     }
-    $exifTool->{INDENT} = $oldIndent if $verbose;
+    $$et{INDENT} = $oldIndent if $verbose;
     # try to better identify the file type
-    if ($$exifTool{VALUE}{FileType} eq 'FPX') {
-        my $val = $$exifTool{CompObjUserType} || $$exifTool{Software};
+    if ($$et{VALUE}{FileType} eq 'FPX') {
+        my $val = $$et{CompObjUserType} || $$et{Software};
         if ($val) {
-            my %type = ( Word => 'DOC', PowerPoint => 'PPT', Excel => 'XLS' );
+            my %type = ( '^3ds Max' => 'MAX', Word => 'DOC', PowerPoint => 'PPT', Excel => 'XLS' );
             my $pat;
             foreach $pat (sort keys %type) {
                 next unless $val =~ /$pat/;
-                $exifTool->OverrideFileType($type{$pat});
+                $et->OverrideFileType($type{$pat});
                 last;
             }
         }
     }
+    # process Word document table
+    ProcessDocumentTable($et);
+
     return 1;
 }
@@ -1854 +2371 @@
 =head1 AUTHOR
 
-Copyright 2003-2011, Phil Harvey (phil at owl.phy.queensu.ca)
+Copyright 2003-2021, Phil Harvey (philharvey66 at gmail.com)
 
 This library is free software; you can redistribute it and/or modify it