exiftool_vendored 10.31.0 → 10.40.0

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

@@ -0,0 +1,143 @@
+#------------------------------------------------------------------------------
+# File:         PGF.pm
+#
+# Description:  Read Progressive Graphics File meta information
+#
+# Revisions:    2011/01/25 - P. Harvey Created
+#
+# References:   1) http://www.libpgf.org/
+#               2) http://www.exiv2.org/
+#------------------------------------------------------------------------------
+
+package Image::ExifTool::PGF;
+
+use strict;
+use vars qw($VERSION);
+use Image::ExifTool qw(:DataAccess :Utils);
+
+$VERSION = '1.02';
+
+# PGF header information
+%Image::ExifTool::PGF::Main = (
+    GROUPS => { 0 => 'File', 1 => 'File', 2 => 'Image' },
+    PROCESS_PROC => \&Image::ExifTool::ProcessBinaryData,
+    PRIORITY => 2,  # (to take precedence over PNG tags from embedded image)
+    NOTES => q{
+        The following table lists information extracted from the header of
+        Progressive Graphics File (PGF) images.  As well, information is extracted
+        from the embedded PNG metadata image if it exists.  See
+        L<http://www.libpgf.org/> for the PGF specification.
+    },
+    3  => {
+        Name => 'PGFVersion',
+        PrintConv => 'sprintf("0x%.2x", $val)',
+        # this is actually a bitmask (ref digikam PGFtypes.h):
+        # 0x02 - data structure PGFHeader of major version 2
+        # 0x04 - 32-bit values
+        # 0x08 - supports regions of interest
+        # 0x10 - new coding scheme since major version 5
+        # 0x20 - new HeaderSize: 32 bits instead of 16 bits
+    },
+    8  => { Name => 'ImageWidth',  Format => 'int32u' },
+    12 => { Name => 'ImageHeight', Format => 'int32u' },
+    16 => 'PyramidLevels',
+    17 => 'Quality',
+    18 => 'BitsPerPixel',
+    19 => 'ColorComponents',
+    20 => {
+        Name => 'ColorMode',
+        RawConv => '$$self{PGFColorMode} = $val',
+        PrintConvColumns => 2,
+        PrintConv => {
+            0 => 'Bitmap',
+            1 => 'Grayscale',
+            2 => 'Indexed',
+            3 => 'RGB',
+            4 => 'CMYK',
+            7 => 'Multichannel',
+            8 => 'Duotone',
+            9 => 'Lab',
+        },
+    },
+    21 => { Name => 'BackgroundColor', Format => 'int8u[3]' },
+);
+
+#------------------------------------------------------------------------------
+# Extract information from a PGF image
+# Inputs: 0) ExifTool object reference, 1) dirInfo reference
+# Returns: 1 on success, 0 if this wasn't a valid PGF file
+sub ProcessPGF($$)
+{
+    my ($et, $dirInfo) = @_;
+    my $raf = $$dirInfo{RAF};
+    my $buff;
+
+    # read header and check magic number
+    return 0 unless $raf->Read($buff, 24) == 24 and $buff =~ /^PGF(.)/s;
+    my $ver = ord $1;
+    $et->SetFileType();
+    SetByteOrder('II');
+
+    # currently support only version 0x36
+    unless ($ver == 0x36) {
+        $et->Error(sprintf('Unsupported PGF version 0x%.2x', $ver));
+        return 1;
+    }
+    # extract information from the PGF header
+    my $tagTablePtr = GetTagTable('Image::ExifTool::PGF::Main');
+    $et->ProcessDirectory({ DataPt => \$buff, DataPos => 0 }, $tagTablePtr);
+
+    my $len = Get32u(\$buff, 4) - 16; # length of post-header data
+
+    # skip colour table if necessary
+    $len -= $raf->Seek(1024, 1) ? 1024 : $len if $$et{PGFColorMode} == 2;
+
+    # extract information from the embedded metadata image (PNG format)
+    if ($len > 0 and $len < 0x1000000 and $raf->Read($buff, $len) == $len) {
+        $et->ExtractInfo(\$buff, { ReEntry => 1 });
+    }
+    return 1;
+}
+
+
+1;  # end
+
+__END__
+
+=head1 NAME
+
+Image::ExifTool::PGF - Read Progressive Graphics File meta information
+
+=head1 SYNOPSIS
+
+This module is used by Image::ExifTool
+
+=head1 DESCRIPTION
+
+This module contains definitions required by Image::ExifTool to extract meta
+information from Progressive Graphics File (PGF) images.
+
+=head1 AUTHOR
+
+Copyright 2003-2017, Phil Harvey (phil at owl.phy.queensu.ca)
+
+This library is free software; you can redistribute it and/or modify it
+under the same terms as Perl itself.
+
+=head1 REFERENCES
+
+=over 4
+
+=item L<http://www.libpgf.org/>
+
+=item L<http://www.exiv2.org/>
+
+=back
+
+=head1 SEE ALSO
+
+L<Image::ExifTool::TagNames/PGF Tags>,
+L<Image::ExifTool(3pm)|Image::ExifTool>
+
+=cut
+

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

@@ -0,0 +1,1260 @@
+#------------------------------------------------------------------------------
+# File:         PICT.pm
+#
+# Description:  Read PICT meta information
+#
+# Revisions:    10/10/2005 - P. Harvey Created
+#
+# Notes:        Extraction of PICT opcodes is still experimental
+#
+# - size difference in PixPat color table?? (imagemagick reads only 1 long per entry)
+# - other differences in the way imagemagick reads 16-bit images
+#
+# References:   1) http://developer.apple.com/documentation/mac/QuickDraw/QuickDraw-2.html
+#               2) http://developer.apple.com/documentation/QuickTime/INMAC/QT/iqImageCompMgr.a.htm
+#------------------------------------------------------------------------------
+
+package Image::ExifTool::PICT;
+
+use strict;
+use vars qw($VERSION);
+use Image::ExifTool qw(:DataAccess :Utils);
+
+$VERSION = '1.05';
+
+sub ReadPictValue($$$;$);
+
+my ($vers, $extended);  # PICT version number, and extended flag
+my ($verbose, $out, $indent); # used in verbose mode
+
+# ranges of reserved opcodes.
+# opcodes at the start of each range must be defined in the tag table
+my @reserved = (
+    0x0017 => 0x0019, 0x0024 => 0x0027, 0x0035 => 0x0037, 0x003d => 0x003f,
+    0x0045 => 0x0047, 0x004d => 0x004f, 0x0055 => 0x0057, 0x005d => 0x005f,
+    0x0065 => 0x0067, 0x006d => 0x006f, 0x0075 => 0x0077, 0x007d => 0x007f,
+    0x0085 => 0x0087, 0x008d => 0x008f, 0x0092 => 0x0097, 0x00a2 => 0x00af,
+    0x00b0 => 0x00cf, 0x00d0 => 0x00fe, 0x0100 => 0x01ff, 0x0300 => 0x0bfe,
+    0x0c01 => 0x7eff, 0x7f00 => 0x7fff, 0x8000 => 0x80ff, 0x8100 => 0x81ff,
+    0x8201 => 0xffff,
+);
+
+# Apple data structures in PICT images
+my %structs = (
+    Arc => [
+        rect => 'Rect',
+        startAng => 'int16s',
+        arcAng => 'int16s',
+    ],
+    BitMap => [
+        # (no baseAddr)
+        rowBytes => 'int16u',
+        bounds => 'Rect',
+    ],
+    # BitsRect data for PICT version 1
+    BitsRect1 => [
+        bitMap => 'BitMap',
+        srcRect => 'Rect',
+        dstRect => 'Rect',
+        mode => 'int16u',
+        dataSize => 'int16u',
+        bitData => 'binary[$val{dataSize}]',
+    ],
+    # BitsRect data for PICT version 2
+    BitsRect2 => [
+        pixMap => 'PixMap',
+        colorTable => 'ColorTable',
+        srcRect => 'Rect',
+        dstRect => 'Rect',
+        mode => 'int16u',
+        pixData => \ 'GetPixData($val{pixMap}, $raf)',
+    ],
+    # BitsRgn data for PICT version 1
+    BitsRgn1 => [
+        bitMap => 'BitMap',
+        srcRect => 'Rect',
+        dstRect => 'Rect',
+        mode => 'int16u',
+        maskRgn => 'Rgn',
+        dataSize => 'int16u',
+        bitData => 'binary[$val{dataSize}]',
+    ],
+    # BitsRgn data for PICT version 2
+    BitsRgn2 => [
+        pixMap => 'PixMap',
+        colorTable => 'ColorTable',
+        srcRect => 'Rect',
+        dstRect => 'Rect',
+        mode => 'int16u',
+        maskRgn => 'Rgn',
+        pixData => \ 'GetPixData($val{pixMap}, $raf)',
+    ],
+    ColorSpec => [
+        value => 'int16u',
+        rgb => 'RGBColor',
+    ],
+    ColorTable => [
+        ctSeed => 'int32u',
+        ctFlags => 'int16u',
+        ctSize => 'int16u',
+        ctTable => 'ColorSpec[$val{ctSize}+1]',
+    ],
+    # http://developer.apple.com/documentation/QuickTime/INMAC/QT/iqImageCompMgr.a.htm
+    CompressedQuickTime => [
+        size => 'int32u',   # size NOT including size word
+        version => 'int16u',
+        matrix => 'int32u[9]',
+        matteSize => 'int32u',
+        matteRect => 'Rect',
+        mode => 'int16u',
+        srcRect => 'Rect',
+        accuracy => 'int32u',
+        maskSize => 'int32u',
+        matteDescr => 'Int32uData[$val{matteSize} ? 1 : 0]',
+        matteData => 'int8u[$val{matteSize}]',
+        maskRgn => 'int8u[$val{maskSize}]',
+        imageDescr => 'ImageDescription',
+        # size should be $val{imageDescr}->{dataSize}, but this is unreliable
+        imageData => q{binary[$val{size} - 68 - $val{maskSize} - $val{imageDescr}->{size} -
+                    ($val{matteSize} ? $val{mattSize} + $val{matteDescr}->{size} : 0)]
+        },
+    ],
+    DirectBitsRect => [
+        baseAddr => 'int32u',
+        pixMap => 'PixMap',
+        srcRect => 'Rect',
+        dstRect => 'Rect',
+        mode => 'int16u',
+        pixData => \ 'GetPixData($val{pixMap}, $raf)',
+    ],
+    DirectBitsRgn => [
+        baseAddr => 'int32u',
+        pixMap => 'PixMap',
+        srcRect => 'Rect',
+        dstRect => 'Rect',
+        mode => 'int16u',
+        maskRgn => 'Rgn',
+        pixData => \ 'GetPixData($val{pixMap}, $raf)',
+    ],
+    # http://developer.apple.com/technotes/qd/qd_01.html
+    FontName => [
+        size => 'int16u',   # size NOT including size word
+        oldFontID => 'int16u',
+        nameLen => 'int8u',
+        fontName => 'string[$val{nameLen}]',
+        padding => 'binary[$val{size} - $val{nameLen} - 3]',
+    ],
+    # http://developer.apple.com/documentation/QuickTime/APIREF/imagedescription.htm
+    ImageDescription => [
+        size => 'int32u',   # size INCLUDING size word
+        cType => 'string[4]',
+        res1 => 'int32u',
+        res2 => 'int16u',
+        dataRefIndex => 'int16u',
+        version => 'int16u',
+        revision => 'int16u',
+        vendor => 'string[4]',
+        temporalQuality => 'int32u',
+        quality => 'int32u',
+        width => 'int16u',
+        height => 'int16u',
+        hRes => 'fixed32u',
+        vRes => 'fixed32u',
+        dataSize => 'int32u',
+        frameCount => 'int16u',
+        nameLen => 'int8u',
+        compressor => 'string[31]',
+        depth => 'int16u',
+        clutID => 'int16u',
+        clutData => 'binary[$val{size}-86]',
+    ],
+    Int8uText => [
+        val => 'int8u',
+        count => 'int8u',
+        text => 'string[$val{count}]',
+    ],
+    Int8u2Text => [
+        val => 'int8u[2]',
+        count => 'int8u',
+        text => 'string[$val{count}]',
+    ],
+    Int16Data => [
+        size => 'int16u',   # size NOT including size word
+        data => 'int8u[$val{size}]',
+    ],
+    Int32uData => [
+        size => 'int32u',   # size NOT including size word
+        data => 'int8u[$val{size}]',
+    ],
+    LongComment => [
+        kind => 'int16u',
+        size => 'int16u',   # size of data only
+        data => 'binary[$val{size}]',
+    ],
+    PixMap => [
+        # Note: does not contain baseAddr
+        # (except for DirectBits opcodes in which it is loaded separately)
+        rowBytes => 'int16u',
+        bounds => 'Rect',
+        pmVersion => 'int16u',
+        packType => 'int16u',
+        packSize => 'int32u',
+        hRes => 'fixed32s',
+        vRes => 'fixed32s',
+        pixelType => 'int16u',
+        pixelSize => 'int16u',
+        cmpCount => 'int16u',
+        cmpSize => 'int16u',
+        planeBytes => 'int32u',
+        pmTable => 'int32u',
+        pmReserved => 'int32u',
+    ],
+    PixPat => [
+        patType => 'int16u',    # 1 = non-dithered, 2 = dithered
+        pat1Data => 'int8u[8]',
+        # dithered PixPat has RGB entry
+        RGB => 'RGBColor[$val{patType} == 2 ? 1 : 0]',
+        # non-dithered PixPat has other stuff instead
+        nonDithered=> 'PixPatNonDithered[$val{patType} == 2 ? 0 : 1]',
+    ],
+    PixPatNonDithered => [
+        pixMap => 'PixMap',
+        colorTable => 'ColorTable',
+        pixData => \ 'GetPixData($val{pixMap}, $raf)',
+    ],
+    Point => [
+        v => 'int16s',
+        h => 'int16s',
+    ],
+    PointText => [
+        txLoc => 'Point',
+        count => 'int8u',
+        text => 'string[$val{count}]',
+    ],
+    Polygon => [
+        polySize => 'int16u',
+        polyBBox => 'Rect',
+        polyPoints => 'int16u[($val{polySize}-10)/2]',
+    ],
+    Rect => [
+        topLeft => 'Point',
+        botRight => 'Point',
+    ],
+    RGBColor => [
+        red => 'int16u',
+        green => 'int16u',
+        blue => 'int16u',
+    ],
+    Rgn => [
+        rgnSize => 'int16u',
+        rgnBBox => 'Rect',
+        data => 'int8u[$val{rgnSize}-10]',
+    ],
+    ShortLine => [
+        pnLoc => 'Point',
+        dh => 'int8s',
+        dv => 'int8s',
+    ],
+    # http://developer.apple.com/documentation/QuickTime/INMAC/QT/iqImageCompMgr.a.htm
+    UncompressedQuickTime => [
+        size => 'int32u',   # size NOT including size word
+        version => 'int16u',
+        matrix => 'int32u[9]',
+        matteSize => 'int32u',
+        matteRect => 'Rect',
+        matteDescr => 'Int32uData[$val{matteSize} ? 1 : 0]',
+        matteData => 'binary[$val{matteSize}]',
+        subOpcodeData => q{
+            binary[ $val{size} - 50 -
+                    ($val{matteSize} ? $val{mattSize} + $val{matteDescr}->{size} : 0)]
+        },
+    ],
+);
+
+# PICT image opcodes
+%Image::ExifTool::PICT::Main = (
+    VARS => { NO_LOOKUP => 1 }, # omit tags from lookup
+    NOTES => q{
+The PICT format contains no true meta information, except for the possible
+exception of the LongComment opcode.  By default, only ImageWidth,
+ImageHeight and X/YResolution are extracted from a PICT image.  Tags in the
+following table represent image opcodes.  Extraction of these tags is
+experimental, and is only enabled with the Verbose or Unknown options.
+    },
+    0x0000 => {
+        Name => 'Nop',
+        Description => 'No Operation',
+        Format => 'null',
+    },
+    0x0001 => {
+        Name => 'ClipRgn',
+        Description => 'Clipping Region',
+        Format => 'Rgn',
+    },
+    0x0002 => {
+        Name => 'BkPat',
+        Description => 'Background Pattern',
+        Format => 'int8u[8]',
+    },
+    0x0003 => {
+        Name => 'TxFont',
+        Description => 'Font Number',
+        Format => 'int16u',
+    },
+    0x0004 => {
+        Name => 'TxFace',
+        Description => 'Text Font Style',
+        Format => 'int8u',
+    },
+    0x0005 => {
+        Name => 'TxMode',
+        Description => 'Text Source Mode',
+        Format => 'int16u',
+    },
+    0x0006 => {
+        Name => 'SpExtra',
+        Description => 'Extra Space',
+        Format => 'fixed32s',
+    },
+    0x0007 => {
+        Name => 'PnSize',
+        Description => 'Pen Size',
+        Format => 'Point',
+    },
+    0x0008 => {
+        Name => 'PnMode',
+        Description => 'Pen Mode',
+        Format => 'int16u',
+    },
+    0x0009 => {
+        Name => 'PnPat',
+        Description => 'Pen Pattern',
+        Format => 'int8u[8]',
+    },
+    0x000a => {
+        Name => 'FillPat',
+        Description => 'Fill Pattern',
+        Format => 'int8u[8]',
+    },
+    0x000b => {
+        Name => 'OvSize',
+        Description => 'Oval Size',
+        Format => 'Point',
+    },
+    0x000c => {
+        Name => 'Origin',
+        Format => 'Point',
+    },
+    0x000d => {
+        Name => 'TxSize',
+        Description => 'Text Size',
+        Format => 'int16u',
+    },
+    0x000e => {
+        Name => 'FgColor',
+        Description => 'Foreground Color',
+        Format => 'int32u',
+    },
+    0x000f => {
+        Name => 'BkColor',
+        Description => 'Background Color',
+        Format => 'int32u',
+    },
+    0x0010 => {
+        Name => 'TxRatio',
+        Description => 'Text Ratio',
+        Format => 'Rect',
+    },
+    0x0011 => {
+        Name => 'VersionOp',
+        Description => 'Version',
+        Format => 'int8u',
+    },
+    0x0012 => {
+        Name => 'BkPixPat',
+        Description => 'Background Pixel Pattern',
+        Format => 'PixPat',
+    },
+    0x0013 => {
+        Name => 'PnPixPat',
+        Description => 'Pen Pixel Pattern',
+        Format => 'PixPat',
+    },
+    0x0014 => {
+        Name => 'FillPixPat',
+        Description => 'Fill Pixel Pattern',
+        Format => 'PixPat',
+    },
+    0x0015 => {
+        Name => 'PnLocHFrac',
+        Description => 'Fractional Pen Position',
+        Format => 'int16u',
+    },
+    0x0016 => {
+        Name => 'ChExtra',
+        Description => 'Added Width for NonSpace Characters',
+        Format => 'int16u',
+    },
+    0x0017 => {
+        Name => 'Reserved',
+        Format => 'Unknown',
+    },
+    0x001a => {
+        Name => 'RGBFgCol',
+        Description => 'Foreground Color',
+        Format => 'RGBColor',
+    },
+    0x001b => {
+        Name => 'RGBBkCol',
+        Description => 'Background Color',
+        Format => 'RGBColor',
+    },
+    0x001c => {
+        Name => 'HiliteMode',
+        Description => 'Highlight Mode Flag',
+        Format => 'null',
+    },
+    0x001d => {
+        Name => 'HiliteColor',
+        Description => 'Highlight Color',
+        Format => 'RGBColor',
+    },
+    0x001e => {
+        Name => 'DefHilite',
+        Description => 'Use Default Highlight Color',
+        Format => 'null',
+    },
+    0x001f => {
+        Name => 'OpColor',
+        Format => 'RGBColor',
+    },
+    0x0020 => {
+        Name => 'Line',
+        Format => 'Rect',
+    },
+    0x0021 => {
+        Name => 'LineFrom',
+        Format => 'Point',
+    },
+    0x0022 => {
+        Name => 'ShortLine',
+        Format => 'ShortLine',
+    },
+    0x0023 => {
+        Name => 'ShortLineFrom',
+        Format => 'int8u[2]',
+    },
+    0x0024 => {
+        Name => 'Reserved',
+        Format => 'Int16Data',
+    },
+    0x0028 => {
+        Name => 'LongText',
+        Format => 'PointText',
+    },
+    0x0029 => {
+        Name => 'DHText',
+        Format => 'Int8uText',
+    },
+    0x002a => {
+        Name => 'DVText',
+        Format => 'Int8uText',
+    },
+    0x002b => {
+        Name => 'DHDVText',
+        Format => 'Int8u2Text',
+    },
+    0x002c => {
+        Name => 'FontName',
+        Format => 'FontName',
+    },
+    0x002d => {
+        Name => 'LineJustify',
+        Format => 'int8u[10]',
+    },
+    0x002e => {
+        Name => 'GlyphState',
+        Format => 'int8u[8]',
+    },
+    0x002f => {
+        Name => 'Reserved',
+        Format => 'Int16Data',
+    },
+    0x0030 => {
+        Name => 'FrameRect',
+        Format => 'Rect',
+    },
+    0x0031 => {
+        Name => 'PaintRect',
+        Format => 'Rect',
+    },
+    0x0032 => {
+        Name => 'EraseRect',
+        Format => 'Rect',
+    },
+    0x0033 => {
+        Name => 'InvertRect',
+        Format => 'Rect',
+    },
+    0x0034 => {
+        Name => 'FillRect',
+        Format => 'Rect',
+    },
+    0x0035 => {
+        Name => 'Reserved',
+        Format => 'Rect',
+    },
+    0x0038 => {
+        Name => 'FrameSameRect',
+        Format => 'null',
+    },
+    0x0039 => {
+        Name => 'PaintSameRect',
+        Format => 'null',
+    },
+    0x003a => {
+        Name => 'EraseSameRect',
+        Format => 'null',
+    },
+    0x003b => {
+        Name => 'InvertSameRect',
+        Format => 'null',
+    },
+    0x003c => {
+        Name => 'FillSameRect',
+        Format => 'null',
+    },
+    0x003d => {
+        Name => 'Reserved',
+        Format => 'null',
+    },
+    0x0040 => {
+        Name => 'FrameRRect',
+        Format => 'Rect',
+    },
+    0x0041 => {
+        Name => 'PaintRRect',
+        Format => 'Rect',
+    },
+    0x0042 => {
+        Name => 'EraseRRect',
+        Format => 'Rect',
+    },
+    0x0043 => {
+        Name => 'InvertRRect',
+        Format => 'Rect',
+    },
+    0x0044 => {
+        Name => 'FillRRect',
+        Format => 'Rect',
+    },
+    0x0045 => {
+        Name => 'Reserved',
+        Format => 'Rect',
+    },
+    0x0048 => {
+        Name => 'FrameSameRRect',
+        Format => 'null',
+    },
+    0x0049 => {
+        Name => 'PaintSameRRect',
+        Format => 'null',
+    },
+    0x004a => {
+        Name => 'EraseSameRRect',
+        Format => 'null',
+    },
+    0x004b => {
+        Name => 'InvertSameRRect',
+        Format => 'null',
+    },
+    0x004c => {
+        Name => 'FillSameRRect',
+        Format => 'null',
+    },
+    0x004d => {
+        Name => 'Reserved',
+        Format => 'null',
+    },
+    0x0050 => {
+        Name => 'FrameOval',
+        Format => 'Rect',
+    },
+    0x0051 => {
+        Name => 'PaintOval',
+        Format => 'Rect',
+    },
+    0x0052 => {
+        Name => 'EraseOval',
+        Format => 'Rect',
+    },
+    0x0053 => {
+        Name => 'InvertOval',
+        Format => 'Rect',
+    },
+    0x0054 => {
+        Name => 'FillOval',
+        Format => 'Rect',
+    },
+    0x0055 => {
+        Name => 'Reserved',
+        Format => 'Rect',
+    },
+    0x0058 => {
+        Name => 'FrameSameOval',
+        Format => 'null',
+    },
+    0x0059 => {
+        Name => 'PaintSameOval',
+        Format => 'null',
+    },
+    0x005a => {
+        Name => 'EraseSameOval',
+        Format => 'null',
+    },
+    0x005b => {
+        Name => 'InvertSameOval',
+        Format => 'null',
+    },
+    0x005c => {
+        Name => 'FillSameOval',
+        Format => 'null',
+    },
+    0x005d => {
+        Name => 'Reserved',
+        Format => 'null',
+    },
+    0x0060 => {
+        Name => 'FrameArc',
+        Format => 'Arc',
+    },
+    0x0061 => {
+        Name => 'PaintArc',
+        Format => 'Arc',
+    },
+    0x0062 => {
+        Name => 'EraseArc',
+        Format => 'Arc',
+    },
+    0x0063 => {
+        Name => 'InvertArc',
+        Format => 'Arc',
+    },
+    0x0064 => {
+        Name => 'FillArc',
+        Format => 'Arc',
+    },
+    0x0065 => {
+        Name => 'Reserved',
+        Format => 'Arc',
+    },
+    0x0068 => {
+        Name => 'FrameSameArc',
+        Format => 'Point',
+    },
+    0x0069 => {
+        Name => 'PaintSameArc',
+        Format => 'Point',
+    },
+    0x006a => {
+        Name => 'EraseSameArc',
+        Format => 'Point',
+    },
+    0x006b => {
+        Name => 'InvertSameArc',
+        Format => 'Point',
+    },
+    0x006c => {
+        Name => 'FillSameArc',
+        Format => 'Point',
+    },
+    0x006d => {
+        Name => 'Reserved',
+        Format => 'int32u',
+    },
+    0x0070 => {
+        Name => 'FramePoly',
+        Format => 'Polygon',
+    },
+    0x0071 => {
+        Name => 'PaintPoly',
+        Format => 'Polygon',
+    },
+    0x0072 => {
+        Name => 'ErasePoly',
+        Format => 'Polygon',
+    },
+    0x0073 => {
+        Name => 'InvertPoly',
+        Format => 'Polygon',
+    },
+    0x0074 => {
+        Name => 'FillPoly',
+        Format => 'Polygon',
+    },
+    0x0075 => {
+        Name => 'Reserved',
+        Format => 'Polygon',
+    },
+    0x0078 => {
+        Name => 'FrameSamePoly',
+        Format => 'null',
+    },
+    0x0079 => {
+        Name => 'PaintSamePoly',
+        Format => 'null',
+    },
+    0x007a => {
+        Name => 'EraseSamePoly',
+        Format => 'null',
+    },
+    0x007b => {
+        Name => 'InvertSamePoly',
+        Format => 'null',
+    },
+    0x007c => {
+        Name => 'FillSamePoly',
+        Format => 'null',
+    },
+    0x007d => {
+        Name => 'Reserved',
+        Format => 'null',
+    },
+    0x0080 => {
+        Name => 'FrameRgn',
+        Format => 'Rgn',
+    },
+    0x0081 => {
+        Name => 'PaintRgn',
+        Format => 'Rgn',
+    },
+    0x0082 => {
+        Name => 'EraseRgn',
+        Format => 'Rgn',
+    },
+    0x0083 => {
+        Name => 'InvertRgn',
+        Format => 'Rgn',
+    },
+    0x0084 => {
+        Name => 'FillRgn',
+        Format => 'Rgn',
+    },
+    0x0085 => {
+        Name => 'Reserved',
+        Format => 'Rgn',
+    },
+    0x0088 => {
+        Name => 'FrameSameRgn',
+        Format => 'null',
+    },
+    0x0089 => {
+        Name => 'PaintSameRgn',
+        Format => 'null',
+    },
+    0x008a => {
+        Name => 'EraseSameRgn',
+        Format => 'null',
+    },
+    0x008b => {
+        Name => 'InvertSameRgn',
+        Format => 'null',
+    },
+    0x008c => {
+        Name => 'FillSameRgn',
+        Format => 'null',
+    },
+    0x008d => {
+        Name => 'Reserved',
+        Format => 'null',
+    },
+    0x0090 => {
+        Name => 'BitsRect',
+        Description => 'CopyBits with Clipped Rectangle',
+        Format => 'BitsRect#',  # (version-dependent format)
+    },
+    0x0091 => {
+        Name => 'BitsRgn',
+        Description => 'CopyBits with Clipped Region',
+        Format => 'BitsRgn#',   # (version-dependent format)
+    },
+    0x0092 => {
+        Name => 'Reserved',
+        Format => 'Int16Data',
+    },
+    0x0098 => {
+        Name => 'PackBitsRect',
+        Description => 'Packed CopyBits with Clipped Rectangle',
+        Format => 'BitsRect#',  # (version-dependent format)
+    },
+    0x0099 => {
+        Name => 'PackBitsRgn',
+        Description => 'Packed CopyBits with Clipped Region',
+        Format => 'BitsRgn#',   # (version-dependent format)
+    },
+    0x009a => {
+        Name => 'DirectBitsRect',
+        Format => 'DirectBitsRect',
+    },
+    0x009b => {
+        Name => 'DirectBitsRgn',
+        Format => 'DirectBitsRgn',
+    },
+    0x009c => {
+        Name => 'Reserved',
+        Format => 'Int16Data',
+    },
+    0x009d => {
+        Name => 'Reserved',
+        Format => 'Int16Data',
+    },
+    0x009e => {
+        Name => 'Reserved',
+        Format => 'Int16Data',
+    },
+    0x009f => {
+        Name => 'Reserved',
+        Format => 'Int16Data',
+    },
+    0x00a0 => {
+        Name => 'ShortComment',
+        Format => 'int16u',
+    },
+    0x00a1 => [
+        # this list for documentation only [currently not extracted]
+        {
+            # (not actually a full Photohop IRB record it appears, but it does start
+            #  with '8BIM', and does contain resolution information at offset 0x0a)
+            Name => 'LongComment',  # kind = 498
+            Format => 'LongComment',
+            SubDirectory => { TagTable => 'Image::ExifTool::Photoshop::Main' },
+        },
+        {
+            Name => 'LongComment',  # kind = 224
+            Format => 'LongComment',
+            SubDirectory => {
+                TagTable => 'Image::ExifTool::ICC_Profile::Main',
+                Start => '$valuePtr + 4',
+            },
+        },
+    ],
+    0x00a2 => {
+        Name => 'Reserved',
+        Format => 'Int16Data',
+    },
+    0x00b0 => {
+        Name => 'Reserved',
+        Format => 'null',
+    },
+    0x00d0 => {
+        Name => 'Reserved',
+        Format => 'Int32uData',
+    },
+    0x00ff => {
+        Name => 'OpEndPic',
+        Description => 'End of picture',
+        Format => 'null', # 2 for version 2!?
+    },
+    0x0100 => {
+        Name => 'Reserved',
+        Format => 'int16u',
+    },
+    0x0200 => {
+        Name => 'Reserved',
+        Format => 'int32u',
+    },
+    0x02ff => {
+        Name => 'Version',
+        Description => 'Version number of picture',
+        Format => 'int16u',
+    },
+    0x0300 => {
+        Name => 'Reserved',
+        Format => 'int16u',
+    },
+    0x0bff => {
+        Name => 'Reserved',
+        Format => 'int8u[22]',
+    },
+    0x0c00 => {
+        Name => 'HeaderOp',
+        Format => 'int16u[12]',
+    },
+    0x0c01 => {
+        Name => 'Reserved',
+        Format => 'int8u[24]',
+    },
+    0x7f00 => {
+        Name => 'Reserved',
+        Format => 'int8u[254]',
+    },
+    0x8000 => {
+        Name => 'Reserved',
+        Format => 'null',
+    },
+    0x8100 => {
+        Name => 'Reserved',
+        Format => 'Int32uData',
+    },
+    0x8200 => {
+        Name => 'CompressedQuickTime',
+        Format => 'CompressedQuickTime',
+    },
+    0x8201 => {
+        Name => 'UncompressedQuickTime',
+        Format => 'Int32uData',
+    },
+    0xffff => {
+        Name => 'Reserved',
+        Format => 'Int32uData',
+    },
+);
+
+# picture comment 'kind' codes
+# http://developer.apple.com/technotes/qd/qd_10.html
+my %commentKind = (
+    150 => 'TextBegin',
+    151 => 'TextEnd',
+    152 => 'StringBegin',
+    153 => 'StringEnd',
+    154 => 'TextCenter',
+    155 => 'LineLayoutOff',
+    156 => 'LineLayoutOn',
+    157 => 'ClientLineLayout',
+    160 => 'PolyBegin',
+    161 => 'PolyEnd',
+    163 => 'PolyIgnore',
+    164 => 'PolySmooth',
+    165 => 'PolyClose',
+    180 => 'DashedLine',
+    181 => 'DashedStop',
+    182 => 'SetLineWidth',
+    190 => 'PostScriptBegin',
+    191 => 'PostScriptEnd',
+    192 => 'PostScriptHandle',
+    193 => 'PostScriptFile',
+    194 => 'TextIsPostScript',
+    195 => 'ResourcePS',
+    196 => 'PSBeginNoSave',
+    197 => 'SetGrayLevel',
+    200 => 'RotateBegin',
+    201 => 'RotateEnd',
+    202 => 'RotateCenter',
+    210 => 'FormsPrinting',
+    211 => 'EndFormsPrinting',
+    224 => '<ICC Profile>',
+    498 => '<Photoshop Data>',
+    1000 => 'BitMapThinningOff',
+    1001 => 'BitMapThinningOn',
+);
+
+#------------------------------------------------------------------------------
+# Get PixData data
+# Inputs: 0) reference to PixMap, 1) RAF reference
+# Returns: reference to PixData or undef on error
+sub GetPixData($$)
+{
+    my ($pixMap, $raf) = @_;
+    my $packType = $pixMap->{packType};
+    my $rowBytes = $pixMap->{rowBytes} & 0x3fff;    # remove flags bits
+    my $height = $pixMap->{bounds}->{botRight}->{v} -
+                 $pixMap->{bounds}->{topLeft}->{v};
+    my ($data, $size, $buff, $i);
+
+    if ($packType == 1 or $rowBytes < 8) {  # unpacked data
+        $size = $rowBytes * $height;
+        return undef unless $raf->Read($data, $size) == $size;
+    } elsif ($packType == 2) {              # pad byte dropped
+        $size = int($rowBytes * $height * 3 / 4 + 0.5);
+        return undef unless $raf->Read($data, $size) == $size;
+    } else {
+        $data = '';
+        for ($i=0; $i<$height; ++$i) {
+            if ($rowBytes > 250) {
+                $raf->Read($buff,2) == 2 or return undef;
+                $size = unpack('n',$buff);
+            } else {
+                $raf->Read($buff,1) == 1 or return undef;
+                $size = unpack('C',$buff);
+            }
+            $data .= $buff;
+            $raf->Read($buff,$size) == $size or return undef;
+            $data .= $buff;
+        }
+    }
+    return \$data;
+}
+
+#------------------------------------------------------------------------------
+# Read value from PICT file
+# Inputs: 0) RAF reference, 1) tag, 2) format, 3) optional count
+# Returns: value, reference to structure hash, or undef on error
+sub ReadPictValue($$$;$)
+{
+    my ($raf, $tag, $format, $count) = @_;
+    return undef unless $format;
+    unless (defined $count) {
+        if ($format =~ /(.+)\[(.+)\]/s) {
+            $format = $1;
+            $count = $2;
+        } else {
+            $count = 1; # count undefined: assume 1
+        }
+    }
+    my $cntStr = ($count == 1) ? '' : "[$count]";
+    # no size if count is 0
+    my $size = $count ? Image::ExifTool::FormatSize($format) : 0;
+    if (defined $size or $format eq 'null') {
+        my $val;
+        if ($size) {
+            my $buff;
+            $size *= $count;
+            $raf->Read($buff, $size) == $size or return undef;
+            $val = ReadValue(\$buff, 0, $format, $count, $size);
+        } else {
+            $val = '';
+        }
+        if ($verbose) {
+            print $out "${indent}$tag ($format$cntStr)";
+            if ($size) {
+                if (not defined $val) {
+                    print $out " = <undef>\n";
+                } elsif ($format eq 'binary') {
+                    print $out " = <binary data>\n";
+                    if ($verbose > 2) {
+                        my %parms = ( Out => $out );
+                        $parms{MaxLen} = 96 if $verbose < 4;
+                        HexDump(\$val, undef, %parms);
+                    }
+                } else {
+                    print $out " = $val\n";
+                }
+            } else {
+                print $out "\n";
+            }
+        }
+        return \$val if $format eq 'binary' and defined $val;
+        return $val;
+    }
+    $verbose and print $out "${indent}$tag ($format$cntStr):\n";
+    my $struct = $structs{$format} or return undef;
+    my ($c, @vals);
+    for ($c=0; $c<$count; ++$c) {
+        my (%val, $i);
+        for ($i=0; ; $i+=2) {
+            my $tag = $$struct[$i] or last;
+            my $fmt = $$struct[$i+1];
+            my ($cnt, $val);
+            $indent .= '  ';
+            if (ref $fmt) {
+                $val = eval $$fmt;
+                $@ and warn $@;
+                if ($verbose and defined $val) {
+                    printf $out "${indent}$tag (binary[%d]) = <binary data>\n",length($$val);
+                    if ($verbose > 2) {
+                        my %parms = ( Out => $out );
+                        $parms{MaxLen} = 96 if $verbose < 4;
+                        HexDump($val, undef, %parms);
+                    }
+                }
+            } elsif ($fmt =~ /(.+)\[(.+)\]/s) {
+                $fmt = $1;
+                $cnt = eval $2;
+                $@ and warn $@;
+                $val = ReadPictValue($raf, $tag, $fmt, $cnt);
+            } else {
+                $val = ReadPictValue($raf, $tag, $fmt);
+            }
+            $indent = substr($indent, 2);
+            return undef unless defined $val;
+            $val{$tag} = $val;
+        }
+        return \%val if $count == 1;
+        push @vals, \%val;
+    }
+    return \@vals;
+}
+
+#------------------------------------------------------------------------------
+# Extract meta information from a PICT image
+# Inputs: 0) ExifTool object reference, 1) dirInfo reference
+# Returns: 1 on success, 0 if this wasn't a valid PICT image
+sub ProcessPICT($$)
+{
+    my ($et, $dirInfo) = @_;
+    my $raf = $$dirInfo{RAF};
+    $verbose = $et->Options('Verbose');
+    $out = $et->Options('TextOut');
+    $indent = '';
+    my ($buff, $tried, @hdr, $op, $hRes, $vRes);
+
+    # recognize both PICT files and PICT resources (PICT files have a
+    # 512-byte header that we ignore, but PICT resources do not)
+    for (;;) {
+        $raf->Read($buff, 12) == 12 or return 0;
+        @hdr = unpack('x2n5', $buff);
+        $op = pop @hdr;
+        # check for PICT version 1 format
+        if ($op eq 0x1101) {
+            $vers = 1;
+            undef $extended;
+            last;
+        }
+        # check for PICT version 2 format
+        if ($op eq 0x0011) {
+            $raf->Read($buff, 28) == 28 or return 0;
+            if ($buff =~ /^\x02\xff\x0c\x00\xff\xff/) {
+                $vers = 2;
+                undef $extended;
+                last;
+            }
+            if ($buff =~ /^\x02\xff\x0c\x00\xff\xfe/) {
+                $vers = 2;
+                $extended = 1;
+                ($hRes, $vRes) = unpack('x8N2', $buff);
+                last;
+            }
+        }
+        return 0 if $tried;
+        $tried = 1;
+        $raf->Seek(512, 0) or return 0;
+    }
+    # make the bounding rect signed
+    foreach (@hdr) {
+        $_ >= 0x8000 and $_ -= 0x10000;
+    }
+    my $w = $hdr[3] - $hdr[1];
+    my $h = $hdr[2] - $hdr[0];
+    return 0 unless $w > 0 and $h > 0;
+
+    SetByteOrder('MM');
+
+    if ($extended) {
+        # extended version 2 pictures contain resolution information
+        # and image bounds are in 72-dpi equivalent units
+        $hRes = GetFixed32s(\$buff, 8);
+        $vRes = GetFixed32s(\$buff, 12);
+        return 0 unless $hRes and $vRes;
+        $w = int($w * $hRes / 72 + 0.5);
+        $h = int($h * $vRes / 72 + 0.5);
+    }
+    $et->SetFileType();
+    $et->FoundTag('ImageWidth', $w);
+    $et->FoundTag('ImageHeight', $h);
+    $et->FoundTag('XResolution', $hRes) if $hRes;
+    $et->FoundTag('YResolution', $vRes) if $vRes;
+
+    # don't extract image opcodes unless verbose
+    return 1 unless $verbose or $et->Options('Unknown');
+
+    $verbose and printf $out "PICT version $vers%s\n", $extended ? ' extended' : '';
+
+    my $tagTablePtr = GetTagTable('Image::ExifTool::PICT::Main');
+
+    my $success;
+    for (;;) {
+        if ($vers == 1) {
+            $raf->Read($buff, 1) == 1 or last;
+            $op = ord($buff);
+        } else {
+            # must start version 2 opcode on an even byte
+            $raf->Read($buff, 1) if $raf->Tell() & 0x01;
+            $raf->Read($buff, 2) == 2 or last;
+            $op = unpack('n', $buff);
+        }
+        my $tagInfo = $et->GetTagInfo($tagTablePtr, $op);
+        unless ($tagInfo) {
+            my $i;
+            # search for reserved tag info
+            for ($i=0; $i<scalar(@reserved); $i+=2) {
+                next unless $op >= $reserved[$i];
+                last if $op > $reserved[$i+1];
+                $tagInfo = $et->GetTagInfo($tagTablePtr, $reserved[$i]);
+                last;
+            }
+            last unless $tagInfo;
+        }
+        if ($op eq 0xff) {
+            $verbose and print $out "End of picture\n";
+            $success = 1;
+            last;
+        }
+        my $format = $$tagInfo{Format};
+        unless ($format) {
+            $et->Warn("Missing format for $$tagInfo{Name}");
+            last;
+        }
+        # replace version number for version-dependent formats
+        $format =~ s/#$/$vers/;
+        my $wid = $vers * 2;
+        $verbose and printf $out "Tag 0x%.${wid}x, ", $op;
+        my $val = ReadPictValue($raf, $$tagInfo{Name}, $format);
+        unless (defined $val) {
+            $et->Warn("Error reading $$tagInfo{Name} information");
+            last;
+        }
+        if (ref $val eq 'HASH') {
+            # extract JPEG image from CompressedQuickTime imageData
+            if ($$tagInfo{Name} eq 'CompressedQuickTime' and
+                ref $val->{imageDescr} eq 'HASH' and
+                $val->{imageDescr}->{compressor} and
+                $val->{imageDescr}->{compressor} eq 'Photo - JPEG' and
+                ref $val->{imageData} eq 'SCALAR' and
+                $et->ValidateImage($val->{imageData}, 'PreviewImage'))
+            {
+                $et->FoundTag('PreviewImage', $val->{imageData});
+            }
+        } else {
+            # $et->FoundTag($tagInfo, $val);
+        }
+    }
+    $success or $et->Warn('End of picture not found');
+    return 1;
+}
+
+1;  # end
+
+__END__
+
+=head1 NAME
+
+Image::ExifTool::PICT - Read PICT meta information
+
+=head1 SYNOPSIS
+
+This module is used by Image::ExifTool
+
+=head1 DESCRIPTION
+
+This module contains routines required by Image::ExifTool to read PICT
+(Apple Picture) images.
+
+=head1 NOTES
+
+Extraction of PICT opcodes is experimental, and is only enabled with the
+Verbose or the Unknown option.
+
+=head1 AUTHOR
+
+Copyright 2003-2017, Phil Harvey (phil at owl.phy.queensu.ca)
+
+This library is free software; you can redistribute it and/or modify it
+under the same terms as Perl itself.
+
+=head1 REFERENCES
+
+=over 4
+
+=item L<http://developer.apple.com/documentation/mac/QuickDraw/QuickDraw-2.html>
+
+=item L<http://developer.apple.com/documentation/QuickTime/INMAC/QT/iqImageCompMgr.a.htm>
+
+=back
+
+=head1 SEE ALSO
+
+L<Image::ExifTool::TagNames/PICT Tags>,
+L<Image::ExifTool(3pm)|Image::ExifTool>
+
+=cut
+