#------------------------------------------------------------------------------
# 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.25';
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, number of nanoseconds 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',
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', 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',
1 => 'Password protected',
2 => 'Read-only recommended',
4 => 'Read-only enforced',
8 => 'Locked for annotations',
},
},
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 => 'TitleOfParts',
0x0e => 'Manager',
0x0f => 'Company',
0x10 => {
Name => 'LinksUpToDate',
PrintConv => { 0 => 'No', 1 => 'Yes' },
},
0x11 => 'CharCountWithSpaces',
# 0x12 ?
0x13 => { #PH (unconfirmed)
Name => 'SharedDoc',
PrintConv => { 0 => 'No', 1 => 'Yes' },
},
# 0x14 ?
# 0x15 ?
0x16 => {
Name => 'HyperlinksChanged',
PrintConv => { 0 => 'No', 1 => 'Yes' },
},
0x17 => { #PH (unconfirmed handling of lower 16 bits)
Name => 'AppVersion',
ValueConv => 'sprintf("%d.%.4d",$val >> 16, $val & 0xffff)',
},
'_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 => {
# extract JPEG preview from ScreenNail if possible
Require => {
0 => 'ScreenNail',
},
Binary => 1,
RawConv => q{
return undef unless $val[0] =~ /\xff\xd8\xff/g;
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(undef, '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, an 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;
for (;;) {
while ($pos <= $endPos - 4) {
my $sect = Get32u(\$buff, $pos);
$pos += 4;
next if $sect == FREE_SECT;
my $offset = $sect * $sectSize + HDR_SIZE;
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 + HDR_SIZE;
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, HDR_SIZE);
my $dir = LoadChain($raf, $dirStart, \$fat, $sectSize, HDR_SIZE);
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, HDR_SIZE);
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, HDR_SIZE);
} 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 = ( 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-2014, 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