exiftool_vendored 9.45.0 → 9.46.0

data/bin/Image-ExifTool-9.45/lib/Image/ExifTool/OOXML.pm

@@ -1,409 +0,0 @@
-#------------------------------------------------------------------------------
-# 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.07';
-
-# 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 ($et, $tagTablePtr, $props, $val, $attrs) = @_;
-    return 0 unless @$props;
-    my $verbose = $et->Options('Verbose');
-
-    my $tag = $$props[-1];
-    $et->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 = $et->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)';
-            }
-            $et->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 {
-        $et->VPrint(0, "  [adding $tag]\n") if $verbose;
-        AddTagToTable($tagTablePtr, $tag, { Name => ucfirst $tag });
-    }
-    # save the tag
-    $et->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 ($et, $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 $$et{FILE_EXT} and $$et{FILE_EXT} eq 'THMX') {
-            $fileType = 'THMX';
-        }
-    } else {
-        $et->VPrint(0, "Unrecognized MIME type: $mime\n");
-        # get MIME type according to file extension
-        $fileType = $$et{FILE_EXT};
-        # default to 'DOCX' if this isn't a known OOXML extension
-        $fileType = 'DOCX' unless $fileType and $isOOXML{$fileType};
-    }
-    $et->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;
-        $et->VPrint(0, "File: $file\n");
-        # set the document number and extract ZIP tags
-        $$et{DOC_NUM} = ++$docNum;
-        Image::ExifTool::ZIP::HandleMember($et, $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 $et->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';
-            $et->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,
-            },
-        );
-        $et->ProcessDirectory(\%dirInfo, $tagTablePtr);
-        undef $buff;    # (free memory now)
-    }
-    delete $$et{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/bin/Image-ExifTool-9.45/lib/Image/ExifTool/Ogg.pm

@@ -1,237 +0,0 @@
-#------------------------------------------------------------------------------
-# 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.01';
-
-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 ($et, $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
-        $et->OverrideFileType('OGV') if $type eq 'Theora' and $$et{FILE_TYPE} eq 'OGG';
-        my $tagTablePtr = GetTagTable("Image::ExifTool::${type}::Main");
-        my $tagInfo = $et->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
-        $$et{SET_GROUP1} = $type if $type eq 'Theora';
-        SetByteOrder($$subdir{ByteOrder}) if $$subdir{ByteOrder};
-        $rtnVal = $et->ProcessDirectory(\%dirInfo, $table);
-        SetByteOrder('II');
-        delete $$et{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 ($et, $dirInfo) = @_;
-
-    # must first check for leading/trailing ID3 information
-    unless ($$et{DoneID3}) {
-        require Image::ExifTool::ID3;
-        Image::ExifTool::ID3::ProcessID3($et, $dirInfo) and return 1;
-    }
-    my $raf = $$dirInfo{RAF};
-    my $verbose = $et->Options('Verbose');
-    my $out = $et->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 $et->Warn('Lost synchronization');
-                last;
-            }
-            unless ($success) {
-                # set file type and initialize on first page
-                $success = 1;
-                $et->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($et, \$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 {
-                $et->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;
-            $et->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($et, \$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($et, \%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
-