exiftool_vendored 9.45.0 → 9.46.0

data/bin/Image-ExifTool-9.46/lib/Image/ExifTool/RSRC.pm

@@ -0,0 +1,241 @@
+#------------------------------------------------------------------------------
+# File:         RSRC.pm
+#
+# Description:  Read Mac OS Resource information
+#
+# Revisions:    2010/03/17 - P. Harvey Created
+#
+# References:   1) http://developer.apple.com/legacy/mac/library/documentation/mac/MoreToolbox/MoreToolbox-99.html
+#------------------------------------------------------------------------------
+
+package Image::ExifTool::RSRC;
+
+use strict;
+use vars qw($VERSION);
+use Image::ExifTool qw(:DataAccess :Utils);
+
+$VERSION = '1.08';
+
+# Information decoded from Mac OS resources
+%Image::ExifTool::RSRC::Main = (
+    GROUPS => { 2 => 'Document' },
+    NOTES => q{
+        Tags extracted from Mac OS resource files and DFONT files.  These tags may
+        also be extracted from the resource fork of any file in OS X, either by
+        adding "/..namedfork/rsrc" to the filename to process the resource fork
+        alone, or by using the ExtractEmbedded (-ee) option to process the resource
+        fork as a sub-document of the main file.  When writing, ExifTool preserves
+        the Mac OS resource fork by default, but it may deleted with C<-rsrc:all=>
+        on the command line.
+    },
+    '8BIM' => {
+        Name => 'PhotoshopInfo',
+        SubDirectory => { TagTable => 'Image::ExifTool::Photoshop::Main' },
+    },
+    'sfnt' => {
+        Name => 'Font',
+        SubDirectory => { TagTable => 'Image::ExifTool::Font::Name' },
+    },
+    # my samples of postscript-type DFONT files have a POST resource
+    # with ID 0x1f5 and the same format as a PostScript file
+    'POST_0x01f5' => {
+        Name => 'PostscriptFont',
+        SubDirectory => { TagTable => 'Image::ExifTool::PostScript::Main' },
+    },
+    'usro_0x0000' => 'OpenWithApplication',
+    'vers_0x0001' => 'ApplicationVersion',
+    'STR _0xbff3' => 'ApplicationMissingMsg',
+    'STR _0xbff4' => 'CreatorApplication',
+    # the following written by Photoshop
+    # (ref http://www.adobe.ca/devnet/photoshop/psir/ps_image_resources.pdf)
+    'STR#_0x0080' => 'Keywords',
+    'TEXT_0x0080' => 'Description',
+    # don't extract PICT's because the clip region isn't set properly
+    # in the PICT resource for some reason.  Also, a dummy 512-byte
+    # header would have to be added to create a valid PICT file.
+    # 'PICT' => { Name => 'PreviewPICT', Binary => 1 },
+);
+
+#------------------------------------------------------------------------------
+# Read information from a Mac resource file (ref 1)
+# Inputs: 0) ExifTool ref, 1) dirInfo ref
+# Returns: 1 on success, 0 if this wasn't a valid resource file
+sub ProcessRSRC($$)
+{
+    my ($et, $dirInfo) = @_;
+    my $raf = $$dirInfo{RAF};
+    my ($hdr, $map, $buff, $i, $j);
+
+    # attempt to validate the format as thoroughly as practical
+    return 0 unless $raf->Read($hdr, 30) == 30;
+    my ($datOff, $mapOff, $datLen, $mapLen) = unpack('N*', $hdr);
+    return 0 unless $raf->Seek(0, 2);
+    my $fLen = $raf->Tell();
+    return 0 if $datOff < 0x10 or $datOff + $datLen > $fLen;
+    return 0 if $mapOff < 0x10 or $mapOff + $mapLen > $fLen or $mapLen < 30;
+    return 0 if $datOff < $mapOff and $datOff + $datLen > $mapOff;
+    return 0 if $mapOff < $datOff and $mapOff + $mapLen > $datOff;
+
+    # read the resource map
+    $raf->Seek($mapOff, 0) and $raf->Read($map, $mapLen) == $mapLen or return 0;
+    SetByteOrder('MM');
+    my $typeOff = Get16u(\$map, 24);
+    my $nameOff = Get16u(\$map, 26);
+    my $numTypes = Get16u(\$map, 28);
+
+    # validate offsets in the resource map
+    return 0 if $typeOff < 28 or $nameOff < 30;
+
+    $et->SetFileType('RSRC') unless $$et{IN_RESOURCE};
+    my $verbose = $et->Options('Verbose');
+    my $tagTablePtr = GetTagTable('Image::ExifTool::RSRC::Main');
+    $et->VerboseDir('RSRC', $numTypes+1);
+
+    # parse resource type list
+    for ($i=0; $i<=$numTypes; ++$i) {
+        my $off = $typeOff + 2 + 8 * $i;    # offset of entry in type list
+        last if $off + 8 > $mapLen;
+        my $resType = substr($map,$off,4);  # resource type
+        my $resNum = Get16u(\$map,$off+4);  # number of resources - 1
+        my $refOff = Get16u(\$map,$off+6) + $typeOff; # offset to first resource reference
+        # loop through all resources
+        for ($j=0; $j<=$resNum; ++$j) {
+            my $roff = $refOff + 12 * $j;
+            last if $roff + 12 > $mapLen;
+            # read only the 24-bit resource data offset
+            my $id = Get16u(\$map,$roff);
+            my $resOff = (Get32u(\$map,$roff+4) & 0x00ffffff) + $datOff;
+            my $resNameOff = Get16u(\$map,$roff+2) + $nameOff + $mapOff;
+            my ($tag, $val, $valLen);
+            my $tagInfo = $$tagTablePtr{$resType};
+            if ($tagInfo) {
+                $tag = $resType;
+            } else {
+                $tag = sprintf('%s_0x%.4x', $resType, $id);
+                $tagInfo = $$tagTablePtr{$tag};
+            }
+            # read the resource data if necessary
+            if ($tagInfo or $verbose) {
+                unless ($raf->Seek($resOff, 0) and $raf->Read($buff, 4) == 4 and
+                        ($valLen = unpack('N', $buff)) < 100000000 and # arbitrary size limit (100MB)
+                        $raf->Read($val, $valLen) == $valLen)
+                {
+                    $et->Warn("Error reading $resType resource");
+                    next;
+                }
+            }
+            if ($verbose) {
+                my ($resName, $nameLen);
+                $resName = '' unless $raf->Seek($resNameOff, 0) and $raf->Read($buff, 1) and
+                    ($nameLen = ord $buff) != 0 and $raf->Read($resName, $nameLen) == $nameLen;
+                $et->VPrint(0,sprintf("%s resource ID 0x%.4x (offset 0x%.4x, $valLen bytes, name='%s'):\n",
+                    $resType, $id, $resOff, $resName));
+                $et->VerboseDump(\$val);
+            }
+            next unless $tagInfo;
+            if ($resType eq 'vers') {
+                # parse the 'vers' resource to get the long version string
+                next unless $valLen > 8;
+                # long version string is after short version
+                my $p = 7 + Get8u(\$val, 6);
+                next if $p >= $valLen;
+                my $vlen = Get8u(\$val, $p++);
+                next if $p + $vlen > $valLen;
+                my $tagTablePtr = GetTagTable('Image::ExifTool::RSRC::Main');
+                $val = $et->Decode(substr($val, $p, $vlen), 'MacRoman');
+            } elsif ($resType eq 'sfnt') {
+                # parse the OTF font block
+                $raf->Seek($resOff + 4, 0) or next;
+                $$dirInfo{Base} = $resOff + 4;
+                require Image::ExifTool::Font;
+                unless (Image::ExifTool::Font::ProcessOTF($et, $dirInfo)) {
+                    $et->Warn('Unrecognized sfnt resource format');
+                }
+                # assume this is a DFONT file unless processing the rsrc fork
+                $et->OverrideFileType('DFONT') unless $$et{DOC_NUM};
+                next;
+            } elsif ($resType eq '8BIM') {
+                my $ttPtr = GetTagTable('Image::ExifTool::Photoshop::Main');
+                $et->HandleTag($ttPtr, $id, $val,
+                    DataPt  => \$val,
+                    DataPos => $resOff + 4,
+                    Size    => $valLen,
+                    Start   => 0,
+                    Parent  => 'RSRC',
+                );
+                next;
+            } elsif ($resType eq 'STR ' and $valLen > 1) {
+                # extract Pascal string
+                my $len = ord $val;
+                next unless $valLen >= $len + 1;
+                $val = substr($val, 1, $len);
+            } elsif ($resType eq 'usro' and $valLen > 4) {
+                my $len = unpack('N', $val);
+                next unless $valLen >= $len + 4;
+                ($val = substr($val, 4, $len)) =~ s/\0.*//g; # truncate at null
+            } elsif ($resType eq 'STR#' and $valLen > 2) {
+                # extract list of strings (ref http://simtech.sourceforge.net/tech/strings.html)
+                my $num = unpack('n', $val);
+                next if $num & 0xf000; # (ignore special-format STR# resources)
+                my ($i, @vals);
+                my $pos = 2;
+                for ($i=0; $i<$num; ++$i) {
+                    last if $pos >= $valLen;
+                    my $len = ord substr($val, $pos++, 1);
+                    last if $pos + $len > $valLen;
+                    push @vals, substr($val, $pos, $len);
+                    $pos += $len;
+                }
+                $val = \@vals;
+            } elsif ($resType eq 'POST') {
+                # assume this is a DFONT file unless processing the rsrc fork
+                $et->OverrideFileType('DFONT') unless $$et{DOC_NUM};
+                $val = substr $val, 2;
+            } elsif ($resType ne 'TEXT') {
+                next;
+            }
+            $et->HandleTag($tagTablePtr, $tag, $val);
+        }
+    }
+    return 1;
+}
+
+1;  # end
+
+__END__
+
+=head1 NAME
+
+Image::ExifTool::RSRC - Read Mac OS Resource information
+
+=head1 SYNOPSIS
+
+This module is used by Image::ExifTool
+
+=head1 DESCRIPTION
+
+This module contains routines required by Image::ExifTool to read Mac OS
+resource files.
+
+=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://developer.apple.com/legacy/mac/library/documentation/mac/MoreToolbox/MoreToolbox-99.html>
+
+=back
+
+=head1 SEE ALSO
+
+L<Image::ExifTool::TagNames/RSRC Tags>,
+L<Image::ExifTool(3pm)|Image::ExifTool>
+
+=cut
+

data/bin/Image-ExifTool-9.46/lib/Image/ExifTool/RTF.pm

@@ -0,0 +1,383 @@
+#------------------------------------------------------------------------------
+# File:         RTF.pm
+#
+# Description:  Read Rich Text Format meta information
+#
+# Revisions:    2010/06/17 - P. Harvey Created
+#
+# References:   1) http://download.microsoft.com/download/2/f/5/2f599e18-07ee-4ec5-a1e7-f4e6a9423592/Word2007RTFSpec9.doc
+#               2) http://search.cpan.org/dist/RTF-Writer/lib/RTF/Cookbook.pod
+#------------------------------------------------------------------------------
+
+package Image::ExifTool::RTF;
+
+use strict;
+use vars qw($VERSION);
+use Image::ExifTool qw(:DataAccess :Utils);
+
+$VERSION = '1.02';
+
+sub ProcessUserProps($$$);
+
+# supported RTF character entities
+my %rtfEntity = (
+    par       => 0x0a,
+    tab       => 0x09,
+    endash    => 0x2013,
+    emdash    => 0x2014,
+    lquote    => 0x2018,
+    rquote    => 0x2019,
+    ldblquote => 0x201c,
+    rdblquote => 0x201d,
+    bullet    => 0x2022,
+);
+
+# RTF tags (ref 1)
+%Image::ExifTool::RTF::Main = (
+    GROUPS => { 2 => 'Document' },
+    NOTES => q{
+        This table lists standard tags of the RTF information group, but ExifTool
+        will also extract any non-standard tags found in this group.  As well,
+        ExifTool will extract any custom properties that are found.  See
+        L<http://www.microsoft.com/en-ca/download/details.aspx?id=10725> for the
+        specification.
+    },
+    title    => { },
+    subject  => { },
+    author   => { Groups => { 2 => 'Author' } },
+    manager  => { },
+    company  => { },
+    copyright=> { Groups => { 2 => 'Author' } }, # (written by Apple TextEdit)
+    operator => { Name => 'LastModifiedBy' },
+    category => { },
+    keywords => { },
+    comment  => { },
+    doccomm  => { Name => 'Comments' },
+    hlinkbase=> { Name => 'HyperlinkBase' },
+    creatim  => {
+        Name => 'CreateDate',
+        Format => 'date',
+        Groups => { 2 => 'Time' },
+        PrintConv => '$self->ConvertDateTime($val)',
+    },
+    revtim   => {
+        Name => 'ModifyDate',
+        Format => 'date',
+        Groups => { 2 => 'Time' },
+        PrintConv => '$self->ConvertDateTime($val)',
+    },
+    printim  => {
+        Name => 'LastPrinted',
+        Format => 'date',
+        Groups => { 2 => 'Time' },
+        PrintConv => '$self->ConvertDateTime($val)',
+    },
+    buptim   => {
+        Name => 'BackupTime',
+        Format => 'date',
+        Groups => { 2 => 'Time' },
+        PrintConv => '$self->ConvertDateTime($val)',
+    },
+    edmins   => {
+        Name => 'TotalEditTime', # in minutes
+        PrintConv => 'ConvertTimeSpan($val, 60)',
+    },
+    nofpages => { Name => 'Pages' },
+    nofwords => { Name => 'Words' },
+    nofchars => { Name => 'Characters' },
+    nofcharsws=>{
+        Name => 'CharactersWithSpaces',
+        Notes => q{
+            according to the 2007 Microsoft RTF specification this is clearly the number
+            of characters NOT including spaces, but Microsoft Word writes this as the
+            number WITH spaces, so ExifTool names this tag according to the de facto
+            standard
+        },
+    },
+    id       => { Name => 'InternalIDNumber' },
+    version  => { Name => 'RevisionNumber' },
+    vern     => { Name => 'InternalVersionNumber' },
+);
+
+# lookup for user-defined properties
+# (none are pre-defined and this table doesn't appear in the docs)
+%Image::ExifTool::RTF::UserProps = (
+    GROUPS => { 2 => 'Document' },
+);
+
+#------------------------------------------------------------------------------
+# Read to nested closing curly bracket "}"
+# Inputs: 0) data ref, 1) optional RAF ref to read more data if available
+# Returns: text inside brackets, or undef on error
+# Notes: On entry the current position in the data must be set to immediately
+#        after the command that opens the bracket.  On return the current
+#        position is immediately following the closing brace if the return
+#        value is defined.
+sub ReadToNested($;$)
+{
+    my ($dataPt, $raf) = @_;
+    my $pos = pos $$dataPt;
+    my $level = 1;
+    for (;;) {
+        # look for the next bracket
+        unless ($$dataPt =~ /(\\*)([{}])/g) {
+            # must read some more data
+            my $p = length $$dataPt;
+            my $buff;
+            last unless $raf and $raf->Read($buff, 65536);
+            $$dataPt .= $buff;
+            # rewind position to include any leading backslashes
+            --$p while $p and substr($$dataPt, $p - 1, 1) eq '\\';
+            pos($$dataPt) = $p; # set position to continue search
+            next;
+        }
+        # bracket is escaped if preceded by an odd number of backslashes
+        next if $1 and length($1) & 0x01;
+        $2 eq '{' and ++$level, next;
+        next unless --$level <= 0;
+        return substr($$dataPt, $pos, pos($$dataPt) - $pos - 1);
+    }
+    return undef;
+}
+
+#------------------------------------------------------------------------------
+# Unescape RTF escape sequences
+# Inputs: 0) ExifTool ref, 1) RTF text, 2) RTF character set (for hex characters)
+# Returns: Unescaped text (in current ExifTool Charset)
+sub UnescapeRTF($$$)
+{
+    my ($et, $val, $charset) = @_;
+
+    # return now unless we have a control sequence
+    unless ($val =~ /\\/) {
+        $val =~ tr/\n\r//d; # ignore CR's and LF's
+        return $val;
+    }
+    # CR/LF is signficant if it terminates a control sequence (so change these to a space)
+    $val =~ s/(^|[^\\])((?:\\\\)*)(\\[a-zA-Z]+(?:-?\d+)?)[\n\r]/$1$2$3 /g;
+    # protect the newline control sequence by converting to a \par command
+    $val =~ s/(^|[^\\])((?:\\\\)*)(\\[\n\r])/$1$2\\par /g;
+    # all other CR/LF's are ignored (so delete them)
+    $val =~ tr/\n\r//d;
+
+    my $rtnVal = '';
+    my $len = length $val;
+    my $skip = 1;   # default Unicode skip count
+    my $p0 = 0;
+
+    for (;;) {
+        # find next backslash
+        my $p1 = ($val =~ /\\/g) ? pos($val) : $len + 1;
+        # add text up to start of this control sequence (or up to end)
+        my $n = $p1 - $p0 - 1;
+        $rtnVal .= substr($val, $p0, $n) if $n > 0;
+        # all done if at the end or if control sequence is empty
+        last if $p1 >= $len;
+        # look for an ASCII-letter control word or Unicode control
+        if ($val =~ /\G([a-zA-Z]+)(-?\d+)? ?/g) {
+            # interpret command if recognized
+            if ($1 eq 'uc') {       # \ucN
+                $skip = $2;
+            } elsif ($1 eq 'u') {   # \uN
+                require Image::ExifTool::Charset;
+                $rtnVal .= Image::ExifTool::Charset::Recompose($et, [$2]);
+                if ($skip) {
+                    # must skip the specified number of characters
+                    # (not simple because RTF control words count as a single character)
+                    last unless $val =~ /\G([^\\]|\\([a-zA-Z]+)(-?\d+)? ?|\\'.{2}|\\.){$skip}/g;
+                }
+            } elsif ($rtfEntity{$1}) {
+                require Image::ExifTool::Charset;
+                $rtnVal .= Image::ExifTool::Charset::Recompose($et, [$rtfEntity{$1}]);
+            } # (else ignore the command)
+        } else {
+            my $ch = substr($val, $p1, 1);
+            if ($ch eq "'") {
+                # hex character code
+                last if $p1 + 3 > $len;
+                my $hex = substr($val, $p1 + 1, 2);
+                if ($hex =~ /^[0-9a-fA-F]{2}$/) {
+                    require Image::ExifTool::Charset;
+                    $rtnVal .= $et->Decode(chr(hex($hex)), $charset);
+                }
+                pos($val) = $p1 + 3;    # skip to after the hex code
+            } else {
+                # assume a standard control symbol (\, {, }, etc)
+                # (note, this may not be valid for some uncommon
+                #  control symbols like \~ for non-breaking space)
+                $rtnVal .= $ch;
+                pos($val) = $p1 + 1;    # skip to after this character
+            }
+        }
+        $p0 = pos($val);
+    }
+    return $rtnVal;
+}
+
+#------------------------------------------------------------------------------
+# Read information in a RTF document
+# Inputs: 0) ExifTool ref, 1) dirInfo ref
+# Returns: 1 on success, 0 if this wasn't a valid RTF file
+sub ProcessRTF($$)
+{
+    my ($et, $dirInfo) = @_;
+    my $raf = $$dirInfo{RAF};
+    my ($buff, $buf2, $cs);
+    
+    return 0 unless $raf->Read($buff, 64) and $raf->Seek(0,0);
+    return 0 unless $buff =~ /^[\n\r]*\{[\n\r]*\\rtf[^a-zA-Z]/;
+    $et->SetFileType();
+#
+# determine the RTF character set
+#
+    if ($buff=~ /\\ansicpg(\d*)/) { 
+        $cs = "cp$1";
+    } elsif ($buff=~ /\\(ansi|mac|pc|pca)[^a-zA-Z]/) {
+        my %trans = (
+            ansi => 'Latin',
+            mac  => 'MacRoman',
+            pc   => 'cp437',
+            pca  => 'cp850',
+        );
+        $cs = $trans{$1};
+    } else {
+        $et->Warn('Unspecified RTF encoding. Will assume Latin');
+        $cs = 'Latin';
+    }
+    my $charset = $Image::ExifTool::charsetName{lc $cs};
+    unless ($charset) {
+        $et->Warn("Unsupported RTF encoding $cs. Will assume Latin.");
+        $charset = 'Latin';
+    }
+    my $tagTablePtr = GetTagTable('Image::ExifTool::RTF::Main');
+    undef $buff;
+#
+# scan for \info group
+#
+    for (;;) {
+        $raf->Read($buf2, 65536) or last;
+        if (defined $buff) {
+            # read more but leave some overlap for the match
+            $buff = substr($buff, -16) . $buf2;
+        } else {
+            $buff = $buf2;
+        }
+        next unless $buff =~ /[^\\]\{[\n\r]*\\info([^a-zA-Z])/g;
+        # anything but a space is included in the contents
+        pos($buff) = pos($buff) - 1 if $1 ne ' ';
+        my $info = ReadToNested(\$buff, $raf);
+        unless (defined $info) {
+            $et->Warn('Unterminated information group');
+            last;
+        }
+        # process info commands (ie. "\author", "\*\copyright");
+        while ($info =~ /\{[\n\r]*(\\\*[\n\r]*)?\\([a-zA-Z]+)([^a-zA-Z])/g) {
+            pos($info) = pos($info) - 1 if $3 ne ' ';
+            my $tag = $2;
+            my $val = ReadToNested(\$info);
+            last unless defined $val;
+            my $tagInfo = $$tagTablePtr{$tag};
+            if ($tagInfo and $$tagInfo{Format} and $$tagInfo{Format} eq 'date') {
+                # parse RTF date commands
+                my %idx = (yr=>0,mo=>1,dy=>2,hr=>3,min=>4,sec=>5);
+                my @t = (0) x 6;
+                while ($val =~ /\\([a-z]+)(\d+)/g) {
+                    next unless defined $idx{$1};
+                    $t[$idx{$1}] = $2;
+                }
+                $val = sprintf("%.4d:%.2d:%.2d %.2d:%.2d:%.2d", @t);
+            } else {
+                # unescape RTF string value
+                $val = UnescapeRTF($et, $val, $charset);
+            }
+            # create tagInfo for unknown tags
+            if (not $tagInfo) {
+                AddTagToTable($tagTablePtr, $tag, { Name => ucfirst($tag) });
+            }
+            $et->HandleTag($tagTablePtr, $tag, $val);
+        }
+    }
+    return 1 unless defined $buff;
+#
+# scan for \userprops (but don't read more from file to find the start of this command)
+#
+    pos($buff) = 0;
+    while ($buff =~ /[^\\]\{[\n\r]*\\\*[\n\r]*\\userprops([^a-zA-Z])/g) {
+        # Note: The RTF spec places brackets around each propinfo structure,
+        # but Microsoft Word doesn't write it this way, so tolerate either.
+        pos($buff) = pos($buff) - 1 if $1 ne ' ';
+        my $props = ReadToNested(\$buff, $raf);
+        $tagTablePtr = Image::ExifTool::GetTagTable('Image::ExifTool::RTF::UserProps');
+        unless (defined $props) {
+            $et->Warn('Unterminated user properties');
+            last;
+        }
+        # process user properties
+        my $tag;
+        while ($props =~ /\{[\n\r]*(\\\*[\n\r]*)?\\([a-zA-Z]+)([^a-zA-Z])/g) {
+            pos($props) = pos($props) - 1 if $3 ne ' ';
+            my $t = $2;
+            my $val = ReadToNested(\$props);
+            last unless defined $val;
+            $val = UnescapeRTF($et, $val, $charset);
+            if ($t eq 'propname') {
+                $tag = $val;
+                next;
+            } elsif ($t ne 'staticval' or not defined $tag) {
+                next;   # ignore \linkval and \proptype for now
+            }
+            $tag =~ s/\s(.)/\U$1/g;     # capitalize all words in tag name
+            $tag =~ tr/-_a-zA-Z0-9//dc; # remove illegal characters
+            next unless $tag;
+            # create tagInfo for unknown tags
+            unless ($$tagTablePtr{$tag}) {
+                AddTagToTable($tagTablePtr, $tag, { Name => $tag });
+            }
+            $et->HandleTag($tagTablePtr, $tag, $val);
+        }
+        last;   # (didn't really want to loop)
+    }
+    return 1;
+}
+
+1;  # end
+
+__END__
+
+=head1 NAME
+
+Image::ExifTool::RTF - Read Rich Text Format meta information
+
+=head1 SYNOPSIS
+
+This module is used by Image::ExifTool
+
+=head1 DESCRIPTION
+
+This module contains definitions required by Image::ExifTool to read meta
+information from RTF (Rich Text Format) documents.
+
+=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://download.microsoft.com/download/2/f/5/2f599e18-07ee-4ec5-a1e7-f4e6a9423592/Word2007RTFSpec9.doc>
+
+=item L<http://search.cpan.org/dist/RTF-Writer/lib/RTF/Cookbook.pod>
+
+=back
+
+=head1 SEE ALSO
+
+L<Image::ExifTool::TagNames/RTF Tags>,
+L<Image::ExifTool(3pm)|Image::ExifTool>
+
+=cut
+