mini_exiftool_vendored 8.9.7.v2 → 9.2.7.v1

data/vendor/Image-ExifTool-9.27/lib/Image/ExifTool/OOXML.pm

@@ -0,0 +1,409 @@
+#------------------------------------------------------------------------------
+# File:         OOXML.pm
+#
+# Description:  Read Office Open XML+ZIP files
+#
+# Revisions:    2009/10/31 - P. Harvey Created
+#------------------------------------------------------------------------------
+
+package Image::ExifTool::OOXML;
+
+use strict;
+use vars qw($VERSION);
+use Image::ExifTool qw(:DataAccess :Utils);
+use Image::ExifTool::XMP;
+use Image::ExifTool::ZIP;
+
+$VERSION = '1.06';
+
+# test for recognized OOXML document extensions
+my %isOOXML = (
+    DOCX => 1,  DOCM => 1,
+    DOTX => 1,  DOTM => 1,
+    POTX => 1,  POTM => 1,
+    PPSX => 1,  PPSM => 1,
+    PPTX => 1,  PPTM => 1,  THMX => 1,
+    XLAM => 1,
+    XLSX => 1,  XLSM => 1,  XLSB => 1,
+    XLTX => 1,  XLTM => 1,
+);
+
+# generate reverse lookup for file type based on MIME
+my %fileType;
+{
+    my $type;
+    foreach $type (keys %isOOXML) {
+        $fileType{$Image::ExifTool::mimeType{$type}} = $type;
+    }
+}
+
+# XML attributes to queue
+my %queuedAttrs;
+my %queueAttrs = (
+    fmtid => 1,
+    pid   => 1,
+    name  => 1,
+);
+
+# keep track of items in a vector (to accumulate as a list)
+my $vectorCount;
+my @vectorVals;
+
+# Office Open XML tags
+%Image::ExifTool::OOXML::Main = (
+    GROUPS => { 0 => 'XML', 1 => 'XML', 2 => 'Document' },
+    PROCESS_PROC => \&Image::ExifTool::XMP::ProcessXMP,
+    VARS => { NO_ID => 1 },
+    NOTES => q{
+        The Office Open XML (OOXML) format was introduced with Microsoft Office 2007
+        and is used by file types such as DOCX, PPTX and XLSX.  These are
+        essentially ZIP archives containing XML files.  The table below lists some
+        tags which have been observed in OOXML documents, but ExifTool will extract
+        any tags found from XML files of the OOXML document properties ("docProps")
+        directory.
+
+        B<Tips:>
+        
+        1) Structural ZIP tags may be ignored (if desired) with C<--ZIP:all> on the
+        command line.
+        
+        2) Tags may be grouped by their document number in the ZIP archive with the
+        C<-g3> or C<-G3> option.
+    },
+    # These tags all have 1:1 correspondence with FlashPix tags except for:
+    #   OOXML            FlashPix
+    #   ---------------  -------------
+    #   DocSecurity      Security
+    #   Application      Software
+    #   dc:Description   Comments
+    #   dc:Creator       Author
+    Application => { },
+    AppVersion  => { },
+    category    => { },
+    Characters  => { },
+    CharactersWithSpaces => { },
+    CheckedBy   => { },
+    Client      => { },
+    Company     => { },
+    created     => {
+        Name => 'CreateDate',
+        Groups => { 2 => 'Time' },
+        Format => 'date',
+        PrintConv => '$self->ConvertDateTime($val)',
+    },
+    createdType => { Hidden => 1, RawConv => 'undef' }, # ignore this XML type name
+    DateCompleted => {
+        Groups => { 2 => 'Time' },
+        Format => 'date',
+        PrintConv => '$self->ConvertDateTime($val)',
+    },
+    Department  => { },
+    Destination => { },
+    Disposition => { },
+    Division    => { },
+    DocSecurity => {
+        # (http://msdn.microsoft.com/en-us/library/documentformat.openxml.extendedproperties.documentsecurity.aspx)
+        PrintConv => {
+            0 => 'None',
+            1 => 'Password protected',
+            2 => 'Read-only recommended',
+            4 => 'Read-only enforced',
+            8 => 'Locked for annotations',
+        },
+    },
+    DocumentNumber=> { },
+    Editor      => { Groups => { 2 => 'Author'} },
+    ForwardTo   => { },
+    Group       => { },
+    HeadingPairs=> { },
+    HiddenSlides=> { },
+    HyperlinkBase=>{ },
+    HyperlinksChanged => { PrintConv => { 'false' => 'No', 'true' => 'Yes' } },
+    keywords    => { },
+    Language    => { },
+    lastModifiedBy => { Groups => { 2 => 'Author'} },
+    lastPrinted => {
+        Groups => { 2 => 'Time' },
+        Format => 'date',
+        PrintConv => '$self->ConvertDateTime($val)',
+    },
+    Lines       => { },
+    LinksUpToDate=>{ PrintConv => { 'false' => 'No', 'true' => 'Yes' } },
+    Mailstop    => { },
+    Manager     => { },
+    Matter      => { },
+    MMClips     => { },
+    modified    => {
+        Name => 'ModifyDate', 
+        Groups => { 2 => 'Time' },
+        Format => 'date',
+        PrintConv => '$self->ConvertDateTime($val)',
+    },
+    modifiedType=> { Hidden => 1, RawConv => 'undef' }, # ignore this XML type name
+    Notes       => { },
+    Office      => { },
+    Owner       => { Groups => { 2 => 'Author'} },
+    Pages       => { },
+    Paragraphs  => { },
+    PresentationFormat => { },
+    Project     => { },
+    Publisher   => { },
+    Purpose     => { },
+    ReceivedFrom=> { },
+    RecordedBy  => { },
+    RecordedDate=> {
+        Groups => { 2 => 'Time' },
+        Format => 'date',
+        PrintConv => '$self->ConvertDateTime($val)',
+    },
+    Reference   => { },
+    revision    => { Name => 'RevisionNumber' },
+    ScaleCrop   => { PrintConv => { 'false' => 'No', 'true' => 'Yes' } },
+    SharedDoc   => { PrintConv => { 'false' => 'No', 'true' => 'Yes' } },
+    Slides      => { },
+    Source      => { },
+    Status      => { },
+    TelephoneNumber => { },
+    Template    => { },
+    TitlesOfParts=>{ },
+    TotalTime   => {
+        Name => 'TotalEditTime',
+        PrintConv => 'ConvertTimeSpan($val, 60)',
+    },
+    Typist      => { },
+    Words       => { },
+);
+
+#------------------------------------------------------------------------------
+# Generate a tag ID for this XML tag
+# Inputs: 0) tag property name list ref
+# Returns: tagID and outtermost interesting namespace (or '' if no namespace)
+sub GetTagID($)
+{
+    my $props = shift;
+    my ($tag, $prop, $namespace);
+    foreach $prop (@$props) {
+        # split name into namespace and property name
+        # (Note: namespace can be '' for property qualifiers)
+        my ($ns, $nm) = ($prop =~ /(.*?):(.*)/) ? ($1, $2) : ('', $prop);
+        next if $ns eq 'vt';        # ignore 'vt' properties
+        if (defined $tag) {
+            $tag .= ucfirst($nm);   # add to tag name
+        } elsif ($prop ne 'Properties' and $prop ne 'cp:coreProperties' and
+                 $prop ne 'property')
+        {
+            $tag = $nm;
+            # save namespace of first property to contribute to tag name
+            $namespace = $ns unless $namespace;
+        }
+    }
+    return ($tag, $namespace || '');
+}
+
+#------------------------------------------------------------------------------
+# We found an XMP property name/value
+# Inputs: 0) ExifTool object ref, 1) tag table ref
+#         2) reference to array of XMP property names (last is current property)
+#         3) property value, 4) attribute hash ref (not used here)
+# Returns: 1 if valid tag was found
+sub FoundTag($$$$;$)
+{
+    my ($exifTool, $tagTablePtr, $props, $val, $attrs) = @_;
+    return 0 unless @$props;
+    my $verbose = $exifTool->Options('Verbose');
+
+    my $tag = $$props[-1];
+    $exifTool->VPrint(0, "  | - Tag '", join('/',@$props), "'\n") if $verbose > 1;
+
+    # un-escape XML character entities
+    $val = Image::ExifTool::XMP::UnescapeXML($val);
+    # convert OOXML-escaped characters (ie. "_x0000d_" is a newline)
+    $val =~ s/_x([0-9a-f]{4})_/Image::ExifTool::PackUTF8(hex($1))/gie;
+    # convert from UTF8 to ExifTool Charset
+    $val = $exifTool->Decode($val, 'UTF8');
+    # queue this attribute for later if necessary
+    if ($queueAttrs{$tag}) {
+        $queuedAttrs{$tag} = $val;
+        return 0;
+    }
+    my $ns;
+    ($tag, $ns) = GetTagID($props);
+    if (not $tag) {
+        # all properties are in ignored namespaces
+        # so 'name' from our queued attributes for the tag
+        my $name = $queuedAttrs{name} or return 0;
+        $name =~ s/(^| )([a-z])/$1\U$2/g;     # start words with uppercase
+        ($tag = $name) =~ tr/-_a-zA-Z0-9//dc;
+        return 0 unless length $tag;
+        unless ($$tagTablePtr{$tag}) {
+            my %tagInfo = (
+                Name => $tag,
+                Description => $name,
+            );
+            # format as a date/time value if type is 'vt:filetime'
+            if ($$props[-1] eq 'vt:filetime') {
+                $tagInfo{Groups} = { 2 => 'Time' },
+                $tagInfo{Format} = 'date',
+                $tagInfo{PrintConv} = '$self->ConvertDateTime($val)';
+            }
+            $exifTool->VPrint(0, "  | [adding $tag]\n") if $verbose;
+            AddTagToTable($tagTablePtr, $tag, \%tagInfo);
+        }
+    } elsif ($tag eq 'xmlns') {
+        # ignore namespaces (for now)
+        return 0;
+    } elsif (ref $Image::ExifTool::XMP::Main{$ns} eq 'HASH' and
+        $Image::ExifTool::XMP::Main{$ns}{SubDirectory})
+    {
+        # use standard XMP table if it exists
+        my $table = $Image::ExifTool::XMP::Main{$ns}{SubDirectory}{TagTable};
+        no strict 'refs';
+        if ($table and %$table) {
+            $tagTablePtr = Image::ExifTool::GetTagTable($table);
+        }
+    } elsif (@$props > 2 and grep /^vt:vector$/, @$props) {
+        # handle vector properties (accumulate as lists)
+        if ($$props[-1] eq 'vt:size') {
+            $vectorCount = $val;
+            undef @vectorVals;
+            return 0;
+        } elsif ($$props[-1] eq 'vt:baseType') {
+            return 0;   # ignore baseType
+        } elsif ($vectorCount) {
+            --$vectorCount;
+            if ($vectorCount) {
+                push @vectorVals, $val;
+                return 0;
+            }
+            $val = [ @vectorVals, $val ] if @vectorVals;
+            # Note: we will lose any improper-sized vector elements here
+        }
+    }
+    # add any unknown tags to table
+    if ($$tagTablePtr{$tag}) {
+        my $tagInfo = $$tagTablePtr{$tag};
+        if (ref $tagInfo eq 'HASH') {
+            # reformat date/time values
+            my $fmt = $$tagInfo{Format} || $$tagInfo{Writable} || '';
+            $val = Image::ExifTool::XMP::ConvertXMPDate($val) if $fmt eq 'date';
+        }
+    } else {
+        $exifTool->VPrint(0, "  [adding $tag]\n") if $verbose;
+        AddTagToTable($tagTablePtr, $tag, { Name => ucfirst $tag });
+    }
+    # save the tag
+    $exifTool->HandleTag($tagTablePtr, $tag, $val);
+
+    # start fresh for next tag
+    undef $vectorCount;
+    undef %queuedAttrs;
+
+    return 1;
+}
+
+#------------------------------------------------------------------------------
+# Extract information from an OOXML file
+# Inputs: 0) ExifTool object reference, 1) dirInfo reference
+# Returns: 1
+# Notes: Upon entry to this routine, the file type has already been verified
+# and the dirInfo hash contains 2 elements unique to this process proc:
+#   MIME    - mime type of main document from "[Content_Types].xml"
+#   ZIP     - reference to Archive::Zip object for this file
+sub ProcessDOCX($$)
+{
+    my ($exifTool, $dirInfo) = @_;
+    my $zip = $$dirInfo{ZIP};
+    my $tagTablePtr = GetTagTable('Image::ExifTool::OOXML::Main');
+    my $mime = $$dirInfo{MIME} || $Image::ExifTool::mimeType{DOCX};
+
+    # set the file type ('DOCX' by default)
+    my $fileType = $fileType{$mime};
+    if ($fileType) {
+        # THMX is a special case because its contents.main MIME types is PPTX
+        if ($fileType eq 'PPTX' and $$exifTool{FILE_EXT} and $$exifTool{FILE_EXT} eq 'THMX') {
+            $fileType = 'THMX';
+        }
+    } else {
+        $exifTool->VPrint(0, "Unrecognized MIME type: $mime\n");
+        # get MIME type according to file extension
+        $fileType = $$exifTool{FILE_EXT};
+        # default to 'DOCX' if this isn't a known OOXML extension
+        $fileType = 'DOCX' unless $fileType and $isOOXML{$fileType};
+    }
+    $exifTool->SetFileType($fileType);
+
+    # must catch all Archive::Zip warnings
+    local $SIG{'__WARN__'} = \&Image::ExifTool::ZIP::WarnProc;
+    # extract meta information from all files in ZIP "docProps" directory
+    my $docNum = 0;
+    my @members = $zip->members();
+    my $member;
+    foreach $member (@members) {
+        # get filename of this ZIP member
+        my $file = $member->fileName();
+        next unless defined $file;
+        $exifTool->VPrint(0, "File: $file\n");
+        # set the document number and extract ZIP tags
+        $$exifTool{DOC_NUM} = ++$docNum;
+        Image::ExifTool::ZIP::HandleMember($exifTool, $member);
+        # process only XML and JPEG/WMF thumbnail images in "docProps" directory
+        next unless $file =~ m{^docProps/(.*\.xml|(thumbnail\.(jpe?g|wmf)))$}i;
+        # get the file contents (CAREFUL! $buff MUST be local since we hand off a value ref)
+        my ($buff, $status) = $zip->contents($member);
+        $status and $exifTool->Warn("Error extracting $file"), next;
+        # extract docProps/thumbnail.(jpg|mwf) as PreviewImage|PreviewMWF
+        if ($file =~ /\.(jpe?g|wmf)$/i) {
+            my $tag = $file =~ /\.wmf$/i ? 'PreviewWMF' : 'PreviewImage';
+            $exifTool->FoundTag($tag, \$buff);
+            next;
+        }
+        # process XML files (docProps/app.xml, docProps/core.xml, docProps/custom.xml)
+        my %dirInfo = (
+            DataPt => \$buff,
+            DirLen => length $buff,
+            DataLen => length $buff,
+            XMPParseOpts => {
+                FoundProc => \&FoundTag,
+            },
+        );
+        $exifTool->ProcessDirectory(\%dirInfo, $tagTablePtr);
+        undef $buff;    # (free memory now)
+    }
+    delete $$exifTool{DOC_NUM};
+    return 1;
+}
+
+1;  # end
+
+__END__
+
+=head1 NAME
+
+Image::ExifTool::OOXML - Read Office Open XML+ZIP files
+
+=head1 SYNOPSIS
+
+This module is used by Image::ExifTool
+
+=head1 DESCRIPTION
+
+This module contains definitions required by Image::ExifTool to extract meta
+information from Office Open XML files.  This is the format of Word, Excel
+and PowerPoint files written by Microsoft Office 2007 -- essentially ZIP
+archives of XML files.
+
+=head1 AUTHOR
+
+Copyright 2003-2013, 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 SEE ALSO
+
+L<Image::ExifTool::TagNames/OOXML Tags>,
+L<Image::ExifTool::TagNames/FlashPix Tags>,
+L<Image::ExifTool(3pm)|Image::ExifTool>
+
+=cut
+

data/vendor/Image-ExifTool-9.27/lib/Image/ExifTool/Ogg.pm

@@ -0,0 +1,237 @@
+#------------------------------------------------------------------------------
+# File:         Ogg.pm
+#
+# Description:  Read Ogg meta information
+#
+# Revisions:    2011/07/13 - P. Harvey Created (split from Vorbis.pm)
+#
+# References:   1) http://www.xiph.org/vorbis/doc/
+#               2) http://flac.sourceforge.net/ogg_mapping.html
+#               3) http://www.theora.org/doc/Theora.pdf
+#------------------------------------------------------------------------------
+
+package Image::ExifTool::Ogg;
+
+use strict;
+use vars qw($VERSION);
+use Image::ExifTool qw(:DataAccess :Utils);
+
+$VERSION = '1.00';
+
+my $MAX_PACKETS = 2;    # maximum packets to scan from each stream at start of file
+
+# Information types recognizedi in Ogg files
+%Image::ExifTool::Ogg::Main = (
+    NOTES => q{
+        ExifTool extracts the following types of information from Ogg files.  See
+        L<http://www.xiph.org/vorbis/doc/> for the Ogg specification.
+    },
+    # (these are for documentation purposes only, and aren't used by the code below)
+    vorbis => { SubDirectory => { TagTable => 'Image::ExifTool::Vorbis::Main' } },
+    theora => { SubDirectory => { TagTable => 'Image::ExifTool::Theora::Main' } },
+    FLAC   => { SubDirectory => { TagTable => 'Image::ExifTool::FLAC::Main' } },
+    ID3    => { SubDirectory => { TagTable => 'Image::ExifTool::ID3::Main' } },
+);
+
+#------------------------------------------------------------------------------
+# Process Ogg packet
+# Inputs: 0) ExifTool object ref, 1) data ref
+# Returns: 1 on success
+sub ProcessPacket($$)
+{
+    my ($exifTool, $dataPt) = @_;
+    my $rtnVal = 0;
+    if ($$dataPt =~ /^(.)(vorbis|theora)/s) {
+        my ($tag, $type) = (ord($1), ucfirst($2));
+        # this is an OGV file if it contains Theora video
+        $exifTool->OverrideFileType('OGV') if $type eq 'Theora' and $$exifTool{FILE_TYPE} eq 'OGG';
+        my $tagTablePtr = GetTagTable("Image::ExifTool::${type}::Main");
+        my $tagInfo = $exifTool->GetTagInfo($tagTablePtr, $tag);
+        return 0 unless $tagInfo and $$tagInfo{SubDirectory};
+        my $subdir = $$tagInfo{SubDirectory};
+        my %dirInfo = (
+            DataPt => $dataPt,
+            DirName => $$tagInfo{Name},
+            DirStart => 7,
+        );
+        my $table = GetTagTable($$subdir{TagTable});
+        # set group1 so Theoris comments can be distinguised from Vorbis comments
+        $$exifTool{SET_GROUP1} = $type if $type eq 'Theora';
+        SetByteOrder($$subdir{ByteOrder}) if $$subdir{ByteOrder};
+        $rtnVal = $exifTool->ProcessDirectory(\%dirInfo, $table);
+        SetByteOrder('II');
+        delete $$exifTool{SET_GROUP1};
+    }
+    return $rtnVal;
+}
+
+#------------------------------------------------------------------------------
+# Extract information from an Ogg file
+# Inputs: 0) ExifTool object reference, 1) dirInfo reference
+# Returns: 1 on success, 0 if this wasn't a valid Ogg file
+sub ProcessOGG($$)
+{
+    my ($exifTool, $dirInfo) = @_;
+
+    # must first check for leading/trailing ID3 information
+    unless ($exifTool->{DoneID3}) {
+        require Image::ExifTool::ID3;
+        Image::ExifTool::ID3::ProcessID3($exifTool, $dirInfo) and return 1;
+    }
+    my $raf = $$dirInfo{RAF};
+    my $verbose = $exifTool->Options('Verbose');
+    my $out = $exifTool->Options('TextOut');
+    my ($success, $page, $packets, $streams, $stream) = (0,0,0,0,'');
+    my ($buff, $flag, %val, $numFlac, %streamPage);
+
+    for (;;) {
+        # must read ahead to next page to see if it is a continuation
+        # (this code would be a lot simpler if the continuation flag
+        #  was on the leading instead of the trailing page!)
+        if ($raf and $raf->Read($buff, 28) == 28) {
+            # validate magic number
+            unless ($buff =~ /^OggS/) {
+                $success and $exifTool->Warn('Lost synchronization');
+                last;
+            }
+            unless ($success) {
+                # set file type and initialize on first page
+                $success = 1;
+                $exifTool->SetFileType();
+                SetByteOrder('II');
+            }
+            $flag = Get8u(\$buff, 5);       # page flag
+            $stream = Get32u(\$buff, 14);   # stream serial number
+            if ($flag & 0x02) {
+                ++$streams;                 # count start-of-stream pages
+                $streamPage{$stream} = $page = 0;
+            } else {
+                $page = $streamPage{$stream};
+            }
+            ++$packets unless $flag & 0x01; # keep track of packet count
+        } else {
+            # all done unless we have to process our last packet
+            last unless %val;
+            ($stream) = sort keys %val;     # take a stream
+            $flag = 0;                      # no continuation
+            undef $raf;                     # flag for done reading
+        }
+
+        if (defined $numFlac) {
+            # stop to process FLAC headers if we hit the end of file
+            last unless $raf;
+            --$numFlac; # one less header packet to read
+        } else {
+            # can finally process previous packet from this stream
+            # unless this is a continuation page
+            if (defined $val{$stream} and not $flag & 0x01) {
+                ProcessPacket($exifTool, \$val{$stream});
+                delete $val{$stream};
+                # only read the first $MAX_PACKETS packets from each stream
+                if ($packets > $MAX_PACKETS * $streams or not defined $raf) {
+                    last unless %val;   # all done (success!)
+                }
+            }
+            # stop processing Ogg if we have scanned enough packets
+            last if $packets > $MAX_PACKETS * $streams and not %val;
+        }
+
+        # continue processing the current page
+        my $pageNum = Get32u(\$buff, 18);   # page sequence number
+        my $nseg = Get8u(\$buff, 26);       # number of segments
+        # calculate total data length
+        my $dataLen = Get8u(\$buff, 27);
+        if ($nseg) {
+            $raf->Read($buff, $nseg-1) == $nseg-1 or last;
+            my @segs = unpack('C*', $buff);
+            # could check that all these (but the last) are 255...
+            foreach (@segs) { $dataLen += $_ }
+        }
+        if (defined $page) {
+            if ($page == $pageNum) {
+                $streamPage{$stream} = ++$page;
+            } else {
+                $exifTool->Warn('Missing page(s) in Ogg file');
+                undef $page;
+                delete $streamPage{$stream};
+            }
+        }
+        # read page data
+        $raf->Read($buff, $dataLen) == $dataLen or last;
+        if ($verbose > 1) {
+            printf $out "Page %d, stream 0x%x, flag 0x%x (%d bytes)\n",
+                   $pageNum, $stream, $flag, $dataLen;
+            $exifTool->VerboseDump(\$buff, DataPos => $raf->Tell() - $dataLen);
+        }
+        if (defined $val{$stream}) {
+            $val{$stream} .= $buff;     # add this continuation page
+        } elsif (not $flag & 0x01) {    # ignore remaining pages of a continued packet
+            # ignore the first page of any packet we aren't parsing
+            if ($buff =~ /^(.)(vorbis|theora)/s) {
+                $val{$stream} = $buff;      # save this page
+            } elsif ($buff =~ /^\x7fFLAC..(..)/s) {
+                $numFlac = unpack('n',$1);
+                $val{$stream} = substr($buff, 9);
+            }
+        }
+        if (defined $numFlac) {
+            # stop to process FLAC headers if we have them all
+            last if $numFlac <= 0;
+        } elsif (defined $val{$stream} and $flag & 0x04) {
+            # process Ogg packet now if end-of-stream bit is set
+            ProcessPacket($exifTool, \$val{$stream});
+            delete $val{$stream};
+        }
+    }
+    if (defined $numFlac and defined $val{$stream}) {
+        # process FLAC headers as if it was a complete FLAC file
+        require Image::ExifTool::FLAC;
+        my %dirInfo = ( RAF => new File::RandomAccess(\$val{$stream}) );
+        Image::ExifTool::FLAC::ProcessFLAC($exifTool, \%dirInfo);
+    }
+    return $success;
+}
+
+1;  # end
+
+__END__
+
+=head1 NAME
+
+Image::ExifTool::Ogg - Read Ogg 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 Ogg bitstream container files.
+
+=head1 AUTHOR
+
+Copyright 2003-2013, 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.xiph.org/vorbis/doc/>
+
+=item L<http://flac.sourceforge.net/ogg_mapping.html>
+
+=item L<http://www.theora.org/doc/Theora.pdf>
+
+=back
+
+=head1 SEE ALSO
+
+L<Image::ExifTool::TagNames/Ogg Tags>,
+L<Image::ExifTool(3pm)|Image::ExifTool>
+
+=cut
+