mini_exiftool_vendored 8.9.7.v2 → 9.2.7.v1

data/vendor/Image-ExifTool-8.97/lib/Image/ExifTool/Radiance.pm

@@ -1,144 +0,0 @@
-#------------------------------------------------------------------------------
-# File:         Radiance.pm
-#
-# Description:  Read Radiance RGBE HDR meta information
-#
-# Revisions:    2011/12/10 - P. Harvey Created
-#
-# References:   1) http://www.graphics.cornell.edu/online/formats/rgbe/
-#               2) http://radsite.lbl.gov/radiance/refer/filefmts.pdf
-#------------------------------------------------------------------------------
-
-package Image::ExifTool::Radiance;
-
-use strict;
-use vars qw($VERSION);
-use Image::ExifTool qw(:DataAccess :Utils);
-
-$VERSION = '1.00';
-
-# Radiance tags
-%Image::ExifTool::Radiance::Main = (
-    GROUPS => { 2 => 'Image' },
-    NOTES => q{
-        Information extracted from Radiance RGBE HDR images.  Tag ID's are all
-        uppercase as stored in the file, but converted to lowercase by when
-        extracting to avoid conflicts with internal ExifTool variables.  See
-        L<http://radsite.lbl.gov/radiance/refer/filefmts.pdf> and
-        L<http://www.graphics.cornell.edu/online/formats/rgbe/> for the
-        specification.
-    },
-    _orient   => {
-        Name => 'Orientation',
-        PrintConv => {
-            '-Y +X' => 'Horizontal (normal)',
-            '-Y -X' => 'Mirror horizontal',
-            '+Y -X' => 'Rotate 180',
-            '+Y +X' => 'Mirror vertical',
-            '+X -Y' => 'Mirror horizontal and rotate 270 CW',
-            '+X +Y' => 'Rotate 90 CW',
-            '-X +Y' => 'Mirror horizontal and rotate 90 CW',
-            '-X -Y' => 'Rotate 270 CW',
-        },
-    },
-    _command  => 'Command',
-    software  => 'Software',
-    view      => 'View',
-   'format'   => 'Format', # <-- this is the one that caused the conflict when uppercase
-    exposure  => {
-        Name => 'Exposure',
-        Notes => 'divide pixel values by this to get watts/steradian/meter^2',
-    },
-    gamma     => 'Gamma',
-    colorcorr => 'ColorCorrection',
-    pixaspect => 'PixelAspectRatio',
-    primaries => 'ColorPrimaries',
-);
-
-#------------------------------------------------------------------------------
-# Extract information from a Radiance JDR file
-# Inputs: 0) ExifTool object reference, 1) DirInfo reference
-# Returns: 1 on success, 0 if this wasn't a valid RGBE image
-sub ProcessHDR($$)
-{
-    my ($exifTool, $dirInfo) = @_;
-    my $raf = $$dirInfo{RAF};
-    my $buff;
-    local $/ = "\x0a";  # set newline character for reading
-
-    # verify this is a valid RIFF file
-    return 0 unless $raf->ReadLine($buff) and $buff =~ /^#\?(RADIANCE|RGBE)\x0a/s;
-    $exifTool->SetFileType();
-    my $tagTablePtr = GetTagTable('Image::ExifTool::Radiance::Main');
-
-    while ($raf->ReadLine($buff)) {
-        chomp $buff;
-        last unless length($buff) > 0 and length($buff) < 4096;
-        unless ($buff =~ /^(.*)?\s*=\s*(.*)/) {
-            $exifTool->HandleTag($tagTablePtr, '_command', $buff);
-            next;
-        }
-        # use lower-case tag names to avoid conflicts with reserved tag table entries
-        my ($tag, $val) = (lc $1, $2);
-        my $tagInfo = $exifTool->GetTagInfo($tagTablePtr, $tag);
-        unless ($tagInfo) {
-            my $name = $tag;
-            $name =~ tr/-_a-zA-Z0-9//dc;
-            next unless length($name) > 1;
-            $name = ucfirst $name;
-            $tagInfo = { Name => $name };
-            AddTagToTable($tagTablePtr, $tag, $tagInfo);
-        }
-        $exifTool->FoundTag($tagInfo, $val);
-    }
-    # get image dimensions
-    if ($raf->ReadLine($buff) and $buff =~ /([-+][XY])\s*(\d+)\s*([-+][XY])\s*(\d+)/) {
-        $exifTool->HandleTag($tagTablePtr, '_orient', "$1 $3");
-        $exifTool->FoundTag('ImageHeight', $2);
-        $exifTool->FoundTag('ImageWidth', $4);
-    }
-    return 1;
-}
-
-1;  # end
-
-__END__
-
-=head1 NAME
-
-Image::ExifTool::Radiance - Read Radiance RGBE HDR 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 Radiance RGBE images.  RGBE (Red Green Blue Exponent)
-images are a type of high dynamic-range image.
-
-=head1 AUTHOR
-
-Copyright 2003-2012, 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://radsite.lbl.gov/radiance/refer/filefmts.pdf>
-
-=item L<http://www.graphics.cornell.edu/online/formats/rgbe/>
-
-=back
-
-=head1 SEE ALSO
-
-L<Image::ExifTool::TagNames/Radiance Tags>,
-L<Image::ExifTool(3pm)|Image::ExifTool>
-
-=cut
-

data/vendor/Image-ExifTool-8.97/lib/Image/ExifTool/Rawzor.pm

@@ -1,190 +0,0 @@
-#------------------------------------------------------------------------------
-# File:         Rawzor.pm
-#
-# Description:  Read meta information from Rawzor compressed images
-#
-# Revisions:    09/09/2008 - P. Harvey Created
-#
-# References:   1) http://www.rawzor.com/
-#------------------------------------------------------------------------------
-
-package Image::ExifTool::Rawzor;
-
-use strict;
-use vars qw($VERSION);
-use Image::ExifTool qw(:DataAccess :Utils);
-
-$VERSION = '1.01';
-
-# currently support this version Rawzor images
-my $implementedRawzorVersion = 199; # (up to version 1.99)
-
-# Rawzor-specific tags
-%Image::ExifTool::Rawzor::Main = (
-    GROUPS => { 2 => 'Other' },
-    VARS => { NO_ID => 1 },
-    NOTES => q{
-        Rawzor files store compressed images of other formats. As well as the
-        information listed below, exiftool uncompresses and extracts the meta
-        information from the original image.
-    },
-    OriginalFileType => { },
-    OriginalFileSize => {
-        PrintConv => $Image::ExifTool::Extra{FileSize}->{PrintConv},
-    },
-    RawzorRequiredVersion => {
-        ValueConv => '$val / 100',
-        PrintConv => 'sprintf("%.2f", $val)',
-    },
-    RawzorCreatorVersion => {
-        ValueConv => '$val / 100',
-        PrintConv => 'sprintf("%.2f", $val)',
-    },
-    # compression factor is originalSize/compressedSize (and compression
-    # ratio is the inverse - ref "Data Compression" by David Salomon)
-    CompressionFactor => { PrintConv => 'sprintf("%.2f", $val)' },
-);
-
-#------------------------------------------------------------------------------
-# Extract information from a Rawzor file
-# Inputs: 0) ExifTool object reference, 1) dirInfo reference
-# Returns: 1 on success, 0 if this wasn't a valid Rawzor file
-sub ProcessRWZ($$)
-{
-    my ($exifTool, $dirInfo) = @_;
-    my $raf = $$dirInfo{RAF};
-    my ($buff, $buf2);
-
-    # read the Rawzor file header:
-    #  0 string - "rawzor" signature
-    #  6 int16u - Required SDK version
-    #  8 int16u - Creator SDK version
-    # 10 int64u - RWZ file size
-    # 18 int64u - original raw file size
-    # 26 undef[12] - reserved
-    # 38 int64u - metadata offset
-    $raf->Read($buff, 46) == 46 and $buff =~ /^rawzor/ or return 0;
-
-    SetByteOrder('II');
-    my $reqVers = Get16u(\$buff, 6);
-    my $creatorVers = Get16u(\$buff, 8);
-    my $rwzSize = Get64u(\$buff, 10);
-    my $origSize = Get64u(\$buff, 18);
-    my $tagTablePtr = GetTagTable('Image::ExifTool::Rawzor::Main');
-    $exifTool->HandleTag($tagTablePtr, RawzorRequiredVersion => $reqVers);
-    $exifTool->HandleTag($tagTablePtr, RawzorCreatorVersion => $creatorVers);
-    $exifTool->HandleTag($tagTablePtr, OriginalFileSize => $origSize);
-    $exifTool->HandleTag($tagTablePtr, CompressionFactor => $origSize/$rwzSize) if $rwzSize;
-    # check version numbers
-    if ($reqVers > $implementedRawzorVersion) {
-        $exifTool->Warn("Version $reqVers Rawzor images not yet supported");
-        return 1;
-    }
-    my $metaOffset = Get64u(\$buff, 38);
-    if ($metaOffset > 0x7fffffff) {
-        $exifTool->Warn('Bad metadata offset');
-        return 1;
-    }
-    # check for the ability to uncompress the information
-    unless (eval 'require IO::Uncompress::Bunzip2') {
-        $exifTool->Warn('Install IO::Compress::Bzip2 to decode Rawzor bzip2 compression');
-        return 1;
-    }
-    # read the metadata header:
-    #  0 int64u - metadata section 0 end (offset in original file)
-    #  8 int64u - metadata section 1 start
-    # 16 int64u - metadata section 1 end
-    # 24 int64u - metadata section 2 start
-    # 32 undef[4] - reserved
-    # 36 int32u - original metadata size
-    # 40 int32u - compressed metadata size
-    unless ($raf->Seek($metaOffset, 0) and $raf->Read($buff, 44) == 44) {
-        $exifTool->Warn('Error reading metadata header');
-        return 1;
-    }
-    my $metaSize = Get32u(\$buff, 36);
-    if ($metaSize) {
-        # validate the metadata header and read the compressed metadata
-        my $end0 = Get64u(\$buff, 0);
-        my $pos1 = Get64u(\$buff, 8);
-        my $end1 = Get64u(\$buff, 16);
-        my $pos2 = Get64u(\$buff, 24);
-        my $len = Get32u(\$buff, 40);
-        unless ($raf->Read($buff, $len) == $len and
-            $end0 + ($end1 - $pos1) + ($origSize - $pos2) == $metaSize and
-            $end0 <= $pos1 and $pos1 <= $end1 and $end1 <= $pos2)
-        {
-            $exifTool->Warn('Error reading image metadata');
-            return 1;
-        }
-        # uncompress the metadata
-        unless (IO::Uncompress::Bunzip2::bunzip2(\$buff, \$buf2) and
-            length($buf2) eq $metaSize)
-        {
-            $exifTool->Warn('Error uncompressing image metadata');
-            return 1;
-        }
-        # re-assemble the original file (sans image data)
-        undef $buff; # (can't hurt to free memory as soon as possible)
-        $buff = substr($buf2, 0, $end0) . ("\0" x ($pos1 - $end0)) .
-                substr($buf2, $end0, $end1 - $pos1) . ("\0" x ($pos2 - $end1)) .
-                substr($buf2, $end0 + $end1 - $pos1, $origSize - $pos2);
-        undef $buf2;
-
-        # extract original information by calling ExtractInfo recursively
-        $exifTool->ExtractInfo(\$buff, { ReEntry => 1 });
-        undef $buff;
-    }
-    # set OriginalFileType from FileType of original file
-    # then change FileType and MIMEType to indicate a Rawzor image
-    my $origFileType = $exifTool->{VALUE}->{FileType};
-    if ($origFileType) {
-        $exifTool->HandleTag($tagTablePtr, OriginalFileType => $origFileType);
-        $exifTool->{VALUE}->{FileType} = 'RWZ';
-        $exifTool->{VALUE}->{MIMEType} = 'image/x-rawzor';
-    } else {
-        $exifTool->HandleTag($tagTablePtr, OriginalFileType => 'Unknown');
-        $exifTool->SetFileType();
-    }
-    return 1;
-}
-
-1;  # end
-
-__END__
-
-=head1 NAME
-
-Image::ExifTool::Rawzor - Read meta information from Rawzor compressed images
-
-=head1 SYNOPSIS
-
-This module is used by Image::ExifTool
-
-=head1 DESCRIPTION
-
-This module contains definitions required by Image::ExifTool to extract meta
-information from Rawzor compressed images.
-
-=head1 AUTHOR
-
-Copyright 2003-2012, 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.rawzor.com/>
-
-=back
-
-=head1 SEE ALSO
-
-L<Image::ExifTool::TagNames/Rawzor Tags>,
-L<Image::ExifTool(3pm)|Image::ExifTool>
-
-=cut
-

data/vendor/Image-ExifTool-8.97/lib/Image/ExifTool/Real.pm

@@ -1,736 +0,0 @@
-#------------------------------------------------------------------------------
-# File:         Real.pm
-#
-# Description:  Read Real audio/video meta information
-#
-# Revisions:    05/16/2006 - P. Harvey Created
-#
-# References:   1) http://www.getid3.org/
-#               2) https://common.helixcommunity.org/nonav/2003/HCS_SDK_r5/htmfiles/rmff.htm
-#------------------------------------------------------------------------------
-
-package Image::ExifTool::Real;
-
-use strict;
-use vars qw($VERSION);
-use Image::ExifTool qw(:DataAccess :Utils);
-use Image::ExifTool::Canon;
-
-$VERSION = '1.04';
-
-sub ProcessRealMeta($$$);
-sub ProcessRealProperties($$$);
-
-# Real property types (ref PH)
-my %propertyType = (
-    0 => 'int32u',
-    2 => 'string',
-);
-
-# Real Metadata property types
-my %metadataFormat = (
-    1 => 'string',  # text
-    2 => 'string',  # text list
-    3 => 'flag',    # 1 or 4 byte integer
-    4 => 'int32u',  # 4-byte integer
-    5 => 'undef',   # binary data
-    6 => 'string',  # URL
-    7 => 'string',  # date
-    8 => 'string',  # file name
-    9 =>  undef,    # grouping
-    10 => undef,    # reference
-);
-
-# Real Metadata property flag bit descriptions
-my %metadataFlag = (
-    0 => 'Read Only',
-    1 => 'Private',
-    2 => 'Type Descriptor',
-);
-
-
-# tags used in RealMedia (RM, RV and RMVB) files
-%Image::ExifTool::Real::Media = (
-    GROUPS => { 2 => 'Video' },
-    NOTES => q{
-        These B<Tag ID>'s are Chunk ID's used in RealMedia and RealVideo (RM, RV and
-        RMVB) files.
-    },
-    CONT => { SubDirectory => { TagTable => 'Image::ExifTool::Real::ContentDescr' } },
-    MDPR => { SubDirectory => { TagTable => 'Image::ExifTool::Real::MediaProps' } },
-    PROP => { SubDirectory => { TagTable => 'Image::ExifTool::Real::Properties' } },
-    RJMD => { SubDirectory => { TagTable => 'Image::ExifTool::Real::Metadata' } },
-);
-
-# pseudo-tags used in RealAudio (RA) files
-%Image::ExifTool::Real::Audio = (
-    GROUPS => { 2 => 'Audio' },
-    NOTES => q{
-        Tags in the following table reference information extracted from various
-        versions of RealAudio (RA) files.
-    },
-    '.ra3' => { Name => 'RA3', SubDirectory => { TagTable => 'Image::ExifTool::Real::AudioV3' } },
-    '.ra4' => { Name => 'RA4', SubDirectory => { TagTable => 'Image::ExifTool::Real::AudioV4' } },
-    '.ra5' => { Name => 'RA5', SubDirectory => { TagTable => 'Image::ExifTool::Real::AudioV5' } },
-);
-
-# pseudo-tags used in RealMedia Metafiles and RealMedia Plug-in Metafiles (RAM and RPM)
-%Image::ExifTool::Real::Metafile = (
-    GROUPS => { 2 => 'Video' },
-    NOTES => q{
-        Tags representing information extracted from Real Audio Metafile and
-        RealMedia Plug-in Metafile (RAM and RPM) files.
-    },
-    txt => 'Text',
-    url => 'URL',
-);
-
-%Image::ExifTool::Real::Properties = (
-    GROUPS => { 1 => 'Real-PROP', 2 => 'Video' },
-    PROCESS_PROC => \&Image::ExifTool::Canon::ProcessSerialData,
-    VARS => { ID_LABEL => 'Sequence' },
-    FORMAT => 'int32u',
-    0  => { Name => 'MaxBitrate', PrintConv => 'ConvertBitrate($val)' },
-    1  => { Name => 'AvgBitrate', PrintConv => 'ConvertBitrate($val)' },
-    2  => 'MaxPacketSize',
-    3  => 'AvgPacketSize',
-    4  => 'NumPackets',
-    5 => { Name => 'Duration',      ValueConv => '$val / 1000',  PrintConv => 'ConvertDuration($val)' },
-    6 => { Name => 'Preroll',       ValueConv => '$val / 1000',  PrintConv => 'ConvertDuration($val)' },
-    7 => { Name => 'IndexOffset',   Unknown => 1 },
-    8 => { Name => 'DataOffset',    Unknown => 1 },
-    9 => { Name => 'NumStreams',    Format => 'int16u' },
-    10 => {
-        Name => 'Flags',
-        Format => 'int16u',
-        PrintConv => { BITMASK => {
-            0 => 'Allow Recording',
-            1 => 'Perfect Play',
-            2 => 'Live',
-            3 => 'Allow Download', #PH (from rmeditor dump)
-        } },
-    },
-);
-
-%Image::ExifTool::Real::MediaProps = (
-    GROUPS => { 1 => 'Real-MDPR', 2 => 'Video' },
-    PROCESS_PROC => \&Image::ExifTool::Canon::ProcessSerialData,
-    VARS => { ID_LABEL => 'Sequence' },
-    FORMAT => 'int32u',
-    PRIORITY => 0,  # first stream takes priority
-    0  => { Name => 'StreamNumber',  Format => 'int16u' },
-    1  => { Name => 'StreamMaxBitrate', PrintConv => 'ConvertBitrate($val)' },
-    2  => { Name => 'StreamAvgBitrate', PrintConv => 'ConvertBitrate($val)' },
-    3  => { Name => 'StreamMaxPacketSize' },
-    4  => { Name => 'StreamAvgPacketSize' },
-    5  => { Name => 'StreamStartTime' },
-    6  => { Name => 'StreamPreroll', ValueConv => '$val / 1000',  PrintConv => 'ConvertDuration($val)' },
-    7  => { Name => 'StreamDuration',ValueConv => '$val / 1000',  PrintConv => 'ConvertDuration($val)' },
-    8  => { Name => 'StreamNameLen', Format => 'int8u', Unknown => 1 },
-    9  => { Name => 'StreamName',    Format => 'string[$val{8}]' },
-    10 => { Name => 'StreamMimeLen', Format => 'int8u', Unknown => 1 },
-    11 => {
-        Name => 'StreamMimeType',
-        Format => 'string[$val{10}]',
-        RawConv => '$self->{RealStreamMime} = $val',
-    },
-    12 => { Name => 'FileInfoLen', Unknown => 1 },
-    13 => {
-        Name => 'FileInfoLen2',
-        # if this condition fails, subsequent tags will not be processed
-        Condition => '$self->{RealStreamMime} eq "logical-fileinfo"',
-        Unknown => 1,
-    },
-    14 => {
-        Name => 'FileInfoVersion',
-        Format => 'int16u',
-    },
-    15 => {
-        Name => 'PhysicalStreams',
-        Format => 'int16u',
-        Unknown => 1,
-    },
-    16 => {
-        Name => 'PhysicalStreamNumbers',
-        Format => 'int16u[$val{15}]',
-        Unknown => 1,
-    },
-    17 => {
-        Name => 'DataOffsets',
-        Format => 'int32u[$val{15}]',
-        Unknown => 1,
-    },
-    18 => {
-        Name => 'NumRules',
-        Format => 'int16u',
-        Unknown => 1,
-    },
-    19 => {
-        Name => 'PhysicalStreamNumberMap',
-        Format => 'int16u[$val{18}]',
-        Unknown => 1,
-    },
-    20 => {
-        Name => 'NumProperties',
-        Format => 'int16u',
-        Unknown => 1,
-    },
-    21 => {
-        Name => 'FileInfoProperties',
-        Format => 'undef[$val{13}-$val{15}*6-$val{18}*2-12]',
-        SubDirectory => { TagTable => 'Image::ExifTool::Real::FileInfo' },
-    },
-);
-
-# Observed FileInfo properties (ref PH)
-%Image::ExifTool::Real::FileInfo = (
-    GROUPS => { 1 => 'Real-MDPR', 2 => 'Video' },
-    PROCESS_PROC => \&ProcessRealProperties,
-    NOTES => q{
-        The following tags have been observed in the FileInfo properties, but any
-        other existing information will also be extracted.
-    },
-    Indexable       => { PrintConv => { 0 => 'False', 1 => 'True' } },
-    Keywords        => { },
-    Description     => { },
-   'File ID'        => { Name => 'FileID' },
-   'Content Rating' => {
-        Name => 'ContentRating',
-        PrintConv => {
-            0 => 'No Rating',
-            1 => 'All Ages',
-            2 => 'Older Children',
-            3 => 'Younger Teens',
-            4 => 'Older Teens',
-            5 => 'Adult Supervision Recommended',
-            6 => 'Adults Only',
-        },
-    },
-    Audiences       => { },
-    audioMode       => { Name => 'AudioMode' },
-   'Creation Date'  => {
-        Name => 'CreateDate',
-        Groups => { 2 => 'Time' },
-        ValueConv => q{
-            $val =~ m{(\d+)/(\d+)/(\d+)\s+(\d+):(\d+):(\d+)} ?
-            sprintf("%.4d:%.2d:%.2d %.2d:%.2d:%.2d",$3,$2,$1,$4,$5,$6) : $val
-        },
-        PrintConv => '$self->ConvertDateTime($val)',
-    },
-   'Generated By'   => { Name => 'Software' },
-   'Modification Date' => {
-        Name => 'ModifyDate',
-        Groups => { 2 => 'Time' },
-        ValueConv => q{
-            $val =~ m{(\d+)/(\d+)/(\d+)\s+(\d+):(\d+):(\d+)} ?
-            sprintf("%.4d:%.2d:%.2d %.2d:%.2d:%.2d",$3,$2,$1,$4,$5,$6) : $val
-        },
-        PrintConv => '$self->ConvertDateTime($val)',
-    },
-   'Target Audiences' => { Name => 'TargetAudiences' },
-   'Audio Format'   => { Name => 'AudioFormat' },
-   'Video Quality'  => { Name => 'VideoQuality' },
-    videoMode       => { Name => 'VideoMode' },
-);
-
-%Image::ExifTool::Real::ContentDescr = (
-    GROUPS => { 1 => 'Real-CONT', 2 => 'Video' },
-    PROCESS_PROC => \&Image::ExifTool::Canon::ProcessSerialData,
-    VARS => { ID_LABEL => 'Sequence' },
-    FORMAT => 'int16u',
-    0 => { Name => 'TitleLen',      Unknown => 1 },
-    1 => { Name => 'Title',         Format => 'string[$val{0}]' },
-    2 => { Name => 'AuthorLen',     Unknown => 1 },
-    3 => { Name => 'Author',        Format => 'string[$val{2}]', Groups => { 2 => 'Author' } },
-    4 => { Name => 'CopyrightLen',  Unknown => 1 },
-    5 => { Name => 'Copyright',     Format => 'string[$val{4}]', Groups => { 2 => 'Author' } },
-    6 => { Name => 'CommentLen',    Unknown => 1 },
-    7 => { Name => 'Comment',       Format => 'string[$val{6}]' },
-);
-
-# Real RJMD meta information (ref PH)
-%Image::ExifTool::Real::Metadata = (
-    GROUPS => { 1 => 'Real-RJMD', 2 => 'Video' },
-    PROCESS_PROC => \&ProcessRealMeta,
-    NOTES => q{
-        The tags below represent information which has been observed in the Real
-        Metadata format, but ExifTool will extract any information it finds in this
-        format.  (As far as I can tell from the referenced documentation, string
-        values should be plain text, but this is not the case for the only sample
-        file I have been able to obtain containing this information.  These tags
-        could also be split into separate sub-directories, but this will wait until
-        I have better documentation or a more complete set of samples.)
-    },
-   'Album/Name'     => 'AlbumName',
-   'Track/Category' => 'TrackCategory',
-   'Track/Comments' => 'TrackComments',
-   'Track/Lyrics'   => 'TrackLyrics',
-);
-
-%Image::ExifTool::Real::AudioV3 = (
-    GROUPS => { 1 => 'Real-RA3', 2 => 'Audio' },
-    PROCESS_PROC => \&Image::ExifTool::Canon::ProcessSerialData,
-    VARS => { ID_LABEL => 'Sequence' },
-    FORMAT => 'int8u',
-    0  => { Name => 'Channels',       Format => 'int16u' },
-    1  => { Name => 'Unknown',        Format => 'int16u[3]', Unknown => 1 },
-    2  => { Name => 'BytesPerMinute', Format => 'int16u' },
-    3  => { Name => 'AudioBytes',     Format => 'int32u' },
-    4  => { Name => 'TitleLen',       Unknown => 1 },
-    5  => { Name => 'Title',          Format => 'string[$val{4}]' },
-    6  => { Name => 'ArtistLen',      Unknown => 1 },
-    7  => { Name => 'Artist',         Format => 'string[$val{6}]', Groups => { 2 => 'Author' } },
-    8  => { Name => 'CopyrightLen',   Unknown => 1 },
-    9  => { Name => 'Copyright',      Format => 'string[$val{8}]', Groups => { 2 => 'Author' } },
-    10 => { Name => 'CommentLen',     Unknown => 1 },
-    11 => { Name => 'Comment',        Format => 'string[$val{10}]' },
-);
-
-%Image::ExifTool::Real::AudioV4 = (
-    GROUPS => { 1 => 'Real-RA4', 2 => 'Audio' },
-    PROCESS_PROC => \&Image::ExifTool::Canon::ProcessSerialData,
-    VARS => { ID_LABEL => 'Sequence' },
-    FORMAT => 'int16u',
-    0  => { Name => 'FourCC1',        Format => 'undef[4]', Unknown => 1 },
-    1  => { Name => 'AudioFileSize',  Format => 'int32u',   Unknown => 1 },
-    2  => { Name => 'Version2',       Unknown => 1 },
-    3  => { Name => 'HeaderSize',     Format => 'int32u',   Unknown => 1 },
-    4  => { Name => 'CodecFlavorID',  Unknown => 1 },
-    5  => { Name => 'CodedFrameSize', Format => 'int32u',   Unknown => 1 },
-    6  => { Name => 'AudioBytes',     Format => 'int32u' },
-    7  => { Name => 'BytesPerMinute', Format => 'int32u' },
-    8  => { Name => 'Unknown',        Format => 'int32u',   Unknown => 1 },
-    9  => { Name => 'SubPacketH',     Unknown => 1 },
-    10 => 'AudioFrameSize',
-    11 => { Name => 'SubPacketSize',  Unknown => 1 },
-    12 => { Name => 'Unknown',        Unknown => 1 },
-    13 => 'SampleRate',
-    14 => { Name => 'Unknown',        Unknown => 1 },
-    15 => 'BitsPerSample',
-    16 => 'Channels',
-    17 => { Name => 'FourCC2Len',     Format => 'int8u',    Unknown => 1 },
-    18 => { Name => 'FourCC2',        Format => 'undef[4]', Unknown => 1 },
-    19 => { Name => 'FourCC3Len',     Format => 'int8u',    Unknown => 1 },
-    20 => { Name => 'FourCC3',        Format => 'undef[4]', Unknown => 1 },
-    21 => { Name => 'Unknown',        Format => 'int8u',    Unknown => 1 },
-    22 => { Name => 'Unknown',        Unknown => 1 },
-    23 => { Name => 'TitleLen',       Format => 'int8u',    Unknown => 1 },
-    24 => { Name => 'Title',          Format => 'string[$val{23}]' },
-    25 => { Name => 'ArtistLen',      Format => 'int8u',    Unknown => 1 },
-    26 => { Name => 'Artist',         Format => 'string[$val{25}]', Groups => { 2 => 'Author' } },
-    27 => { Name => 'CopyrightLen',   Format => 'int8u',    Unknown => 1 },
-    28 => { Name => 'Copyright',      Format => 'string[$val{27}]', Groups => { 2 => 'Author' } },
-    29 => { Name => 'CommentLen',     Format => 'int8u',    Unknown => 1 },
-    30 => { Name => 'Comment',        Format => 'string[$val{29}]' },
-);
-
-%Image::ExifTool::Real::AudioV5 = (
-    GROUPS => { 1 => 'Real-RA5', 2 => 'Audio' },
-    PROCESS_PROC => \&Image::ExifTool::Canon::ProcessSerialData,
-    VARS => { ID_LABEL => 'Sequence' },
-    FORMAT => 'int16u',
-    0  => { Name => 'FourCC1',        Format => 'undef[4]', Unknown => 1 },
-    1  => { Name => 'AudioFileSize',  Format => 'int32u',   Unknown => 1 },
-    2  => { Name => 'Version2',       Unknown => 1 },
-    3  => { Name => 'HeaderSize',     Format => 'int32u',   Unknown => 1 },
-    4  => { Name => 'CodecFlavorID',  Unknown => 1 },
-    5  => { Name => 'CodedFrameSize', Format => 'int32u',   Unknown => 1 },
-    6  => { Name => 'AudioBytes',     Format => 'int32u' },
-    7  => { Name => 'BytesPerMinute', Format => 'int32u' },
-    8  => { Name => 'Unknown',        Format => 'int32u',   Unknown => 1 },
-    9  => { Name => 'SubPacketH',     Unknown => 1 },
-    10 => { Name => 'FrameSize',      Unknown => 1 },
-    11 => { Name => 'SubPacketSize',  Unknown => 1 },
-    12 => 'SampleRate',
-    13 => { Name => 'SampleRate2',    Unknown => 1 },
-    14 => { Name => 'BitsPerSample',  Format => 'int32u' },
-    15 => 'Channels',
-    16 => { Name => 'Genr',           Format => 'int32u',   Unknown => 1 },
-    17 => { Name => 'FourCC3',        Format => 'undef[4]', Unknown => 1 },
-);
-
-#------------------------------------------------------------------------------
-# Process Real NameValueProperties
-# Inputs: 0) ExifTool object reference, 1) dirInfo ref, 2) tag table ref
-# Returns: 1 on success
-sub ProcessRealProperties($$$)
-{
-    my ($exifTool, $dirInfo, $tagTablePtr) = @_;
-    my $dataPt = $$dirInfo{DataPt};
-    my $dirLen = $$dirInfo{DirLen};
-    my $pos = $$dirInfo{DirStart};
-    my $verbose = $exifTool->Options('Verbose');
-
-    $verbose and $exifTool->VerboseDir('RealProperties', undef, $dirLen);
-
-    while ($pos + 6 <= $dirLen) {
-
-        # get property size and version
-        my ($size, $vers) = unpack("x${pos}Nn", $$dataPt);
-        last if $size < 6;
-        unless ($vers == 0) {
-            $pos += $size;
-            next;
-        }
-        $pos += 6;
-
-        my $tagLen = unpack("x${pos}C", $$dataPt);
-        ++$pos;
-
-        last if $pos + $tagLen > $dirLen;
-        my $tag = substr($$dataPt, $pos, $tagLen);
-        $pos += $tagLen;
-
-        last if $pos + 6 > $dirLen;
-        my ($type, $valLen) = unpack("x${pos}Nn", $$dataPt);
-        $pos += 6;
-
-        last if $pos + $valLen > $dirLen;
-        my $format = $propertyType{$type} || 'undef';
-        my $count = int($valLen / Image::ExifTool::FormatSize($format));
-        my $val = ReadValue($dataPt, $pos, $format, $count, $dirLen-$pos);
-
-        my $tagInfo = $exifTool->GetTagInfo($tagTablePtr, $tag);
-        unless ($tagInfo) {
-            my $tagName;
-            ($tagName = $tag) =~ s/\s+//g;
-            next unless $tagName =~ /^\w+$/;    # ignore crazy names
-            $tagInfo = { Name => ucfirst($tagName) };
-            AddTagToTable($tagTablePtr, $tag, $tagInfo);
-        }
-        if ($verbose) {
-            $exifTool->VerboseInfo($tag, $tagInfo,
-                Table  => $tagTablePtr,
-                Value  => $val,
-                DataPt => $dataPt,
-                Size   => $valLen,
-                Start  => $pos,
-                Addr   => $pos + $$dirInfo{DataPos},
-                Format => $format,
-                Count  => $count,
-            );
-        }
-        $exifTool->FoundTag($tagInfo, $val);
-        $pos += $valLen;
-    }
-    return 1;
-}
-
-#------------------------------------------------------------------------------
-# Process Real metadata properties
-# Inputs: 0) ExifTool object reference, 1) dirInfo ref, 2) tag table ref
-# Returns: 1 on success
-sub ProcessRealMeta($$$)
-{
-    my ($exifTool, $dirInfo, $tagTablePtr) = @_;
-    my $dataPt = $$dirInfo{DataPt};
-    my $dataPos = $$dirInfo{DataPos};
-    my $pos = $$dirInfo{DirStart};
-    my $dirEnd = $pos + $$dirInfo{DirLen};
-    my $verbose = $exifTool->Options('Verbose');
-    my $prefix = $$dirInfo{Prefix} || '';
-    $prefix and $prefix .= '/';
-
-    $verbose and $exifTool->VerboseDir('RealMetadata', undef, $$dirInfo{DirLen});
-
-    for (;;) {
-        last if $pos + 28 > $dirEnd;
-        # extract fixed-position metadata structure members
-        my ($size, $type, $flags, $valuePos, $subPropPos, $numSubProps, $nameLen)
-            = unpack("x${pos}N7", $$dataPt);
-        # make pointers relative to data start
-        $valuePos += $pos;
-        $subPropPos += $pos;
-        # validate what we have read so far
-        last if $pos + $size > $dirEnd;
-        last if $pos + 28 + $nameLen > $dirEnd;
-        last if $valuePos <  $pos + 28 + $nameLen;
-        last if $valuePos + 4 > $dirEnd;
-        my $tag = substr($$dataPt, $pos + 28, $nameLen);
-        $tag =~ s/\0.*//s;  # truncate at null
-        $tag = $prefix . $tag;
-        my $valueLen = unpack("x${valuePos}N", $$dataPt);
-        $valuePos += 4; # point at value itself
-        last if $valuePos + $valueLen > $dirEnd;
-
-        my $format = $metadataFormat{$type};
-        my $tagInfo = $exifTool->GetTagInfo($tagTablePtr, $tag);
-        unless ($tagInfo) {
-            my $tagName = $tag;
-            $tagName =~ tr/A-Za-z0-9//dc;
-            $tagInfo = { Name => ucfirst($tagName) };
-            AddTagToTable($tagTablePtr, $tag, $tagInfo);
-        }
-        if ($verbose) {
-            $format = 'undef' unless defined $format;
-            $flags = Image::ExifTool::DecodeBits($flags, \%metadataFlag);
-        }
-        if ($valueLen and $format) {
-            # (a flag can be 1 or 4 bytes)
-            if ($format eq 'flag') {
-                $format = ($valueLen == 4) ? 'int32u' : 'int8u';
-            } elsif ($type == 7 and $tagInfo) {
-                # add PrintConv and ValueConv for "date" type
-                $$tagInfo{ValueConv} or $$tagInfo{ValueConv} = q{
-                    $val =~ /^(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})/ ?
-                    sprintf("%.4d:%.2d:%.2d %.2d:%.2d:%.2d",$1,$2,$3,$4,$5,$6) :
-                    $val;
-                };
-                $$tagInfo{PrintConv} or $$tagInfo{PrintConv} = '$self->ConvertDateTime($val)';
-            }
-            my $count = int($valueLen / Image::ExifTool::FormatSize($format));
-            my $val = ReadValue($dataPt, $valuePos, $format, $count, $dirEnd-$valuePos);
-            $exifTool->HandleTag($tagTablePtr, $tag, $val,
-                DataPt => $dataPt,
-                DataPos => $dataPos,
-                Start => $valuePos,
-                Size => $valueLen,
-                Format => "type=$type, flags=$flags",
-            );
-        }
-        # extract sub-properties
-        if ($numSubProps) {
-            my $dirStart = $valuePos + $valueLen + $numSubProps * 8;
-            my %dirInfo = (
-                DataPt => $dataPt,
-                DataPos => $dataPos,
-                DirStart => $dirStart,
-                DirLen => $pos + $size - $dirStart,
-                Prefix => $tag,
-            );
-            $exifTool->ProcessDirectory(\%dirInfo, $tagTablePtr);
-        }
-        $pos += $size;  # step to next Metadata structure
-    }
-    unless ($pos == $dirEnd) {
-        $exifTool->Warn('Format error in Real Metadata');
-        return 0;
-    }
-    return 1;
-}
-
-#------------------------------------------------------------------------------
-# Read information frame a Real file
-# Inputs: 0) ExifTool object reference, 1) Directory information reference
-# Returns: 1 on success, 0 if this wasn't a valid Real file
-sub ProcessReal($$)
-{
-    my ($exifTool, $dirInfo) = @_;
-    my $raf = $$dirInfo{RAF};
-    my ($buff, $tag, $vers, $extra, @mimeTypes, %dirCount);
-
-    $raf->Read($buff, 8) == 8 or return 0;
-    $buff =~ m{^(\.RMF|\.ra\xfd|pnm://|rtsp://|http://)} or return 0;
-
-    my ($type, $tagTablePtr);
-    if ($1 eq '.RMF') {
-        $tagTablePtr = GetTagTable('Image::ExifTool::Real::Media');
-        $type = 'RM';
-    } elsif ($1 eq ".ra\xfd") {
-        $tagTablePtr = GetTagTable('Image::ExifTool::Real::Audio');
-        $type = 'RA';
-    } else {
-        $tagTablePtr = GetTagTable('Image::ExifTool::Real::Metafile');
-        my $ext = $exifTool->{FILE_EXT};
-        $type = ($ext and $ext eq 'RPM') ? 'RPM' : 'RAM';
-        require Image::ExifTool::PostScript;
-        local $/ = Image::ExifTool::PostScript::GetInputRecordSeparator($raf) || "\n";
-        $raf->Seek(0,0);
-        while ($raf->ReadLine($buff)) {
-            last if length $buff > 256;
-            next unless $buff ;
-            chomp $buff;
-            if ($type) {
-                # must be a Real file type if protocol is http
-                return 0 if $buff =~ /^http/ and $buff !~ /\.(ra|rm|rv|rmvb|smil)$/i;
-                $exifTool->SetFileType($type);
-                undef $type;
-            }
-            # save URL or Text from RAM file
-            my $tag = $buff =~ m{^[a-z]{3,4}://} ? 'url' : 'txt';
-            $exifTool->HandleTag($tagTablePtr, $tag, $buff);
-        }
-        return 1;
-    }
-
-    $exifTool->SetFileType($type);
-    SetByteOrder('MM');
-    my $verbose = $exifTool->Options('Verbose');
-#
-# Process RealAudio file
-#
-    if ($type eq 'RA') {
-        ($vers, $extra) = unpack('x4nn', $buff);
-        $tag = ".ra$vers";
-        my $fpos = $raf->Tell();
-        unless ($raf->Read($buff, 512)) {
-            $exifTool->Warn('Error reading audio header');
-            return 1;
-        }
-        my $tagInfo = $exifTool->GetTagInfo($tagTablePtr, $tag);
-        if ($verbose > 2) {
-            $exifTool->VerboseInfo($tag, $tagInfo, DataPt => \$buff, DataPos => $fpos);
-        }
-        if ($tagInfo) {
-            my $subTablePtr = GetTagTable($tagInfo->{SubDirectory}->{TagTable});
-            my %dirInfo = (
-                DataPt   => \$buff,
-                DataPos  => $fpos,
-                DirLen   => length $buff,
-                DirStart => 0,
-            );
-            $exifTool->ProcessDirectory(\%dirInfo, $subTablePtr);
-        } else {
-            $exifTool->Warn('Unsupported RealAudio version');
-        }
-        return 1;
-    }
-#
-# Process RealMedia file
-#
-    # skip the rest of the RM header
-    my $size = unpack('x4N', $buff);
-    unless ($raf->Seek($size - 8, 1)) {
-        $exifTool->Warn('Error seeking in file');
-        return 0;
-    }
-
-    # Process RealMedia chunks
-    for (;;) {
-        $raf->Read($buff, 10) == 10 or last;
-        ($tag, $size, $vers) = unpack('a4Nn', $buff);
-        last if $tag eq "\0\0\0\0";
-        if ($verbose) {
-            $exifTool->VPrint(0, "$tag chunk ($size bytes):\n");
-        } else {
-            last if $tag eq 'DATA'; # stop normal parsing at DATA tag
-        }
-        if ($size & 0x80000000) {
-            $exifTool->Warn('Bad chunk header');
-            last;
-        }
-        my $tagInfo = $exifTool->GetTagInfo($tagTablePtr, $tag);
-        if ($tagInfo and $$tagInfo{SubDirectory}) {
-            my $fpos = $raf->Tell();
-            unless ($raf->Read($buff, $size-10) == $size-10) {
-                $exifTool->Warn("Error reading $tag chunk");
-                last;
-            }
-            if ($verbose > 2) {
-                $exifTool->VerboseInfo($tag, $tagInfo, DataPt => \$buff, DataPos => $fpos);
-            }
-            my $subTablePtr = GetTagTable($tagInfo->{SubDirectory}->{TagTable});
-            my %dirInfo = (
-                DataPt   => \$buff,
-                DataPos  => $fpos,
-                DirLen   => length $buff,
-                DirStart => 0,
-            );
-            if ($dirCount{$tag}) {
-                $exifTool->{SET_GROUP1} = '+' . ++$dirCount{$tag};
-            } else {
-                $dirCount{$tag} = 1;
-            }
-            $exifTool->ProcessDirectory(\%dirInfo, $subTablePtr);
-            delete $exifTool->{SET_GROUP1};
-            # keep track of stream MIME types
-            my $mime = $exifTool->{RealStreamMime};
-            if ($mime) {
-                delete $exifTool->{RealStreamMime};
-                $mime =~ s/\0.*//s;
-                push @mimeTypes, $mime unless $mime =~ /^logical-/;
-            }
-        } else {
-            unless ($raf->Seek($size-10, 1)) {
-                $exifTool->Warn('Error seeking in file');
-                last;
-            }
-        }
-    }
-    # override MIMEType with stream MIME type if we only have one stream
-    if (@mimeTypes == 1 and length $mimeTypes[0]) {
-        $exifTool->{VALUE}->{MIMEType} = $mimeTypes[0];
-        $exifTool->VPrint(0, "  MIMEType = $mimeTypes[0]\n");
-    }
-#
-# Process footer containing Real metadata and ID3 information
-#
-    if ($raf->Seek(-140, 2) and $raf->Read($buff, 12) == 12 and $buff =~ /^RMJE/) {
-        my $metaSize = unpack('x8N', $buff);
-        if ($raf->Seek(-$metaSize-12, 1) and
-            $raf->Read($buff, $metaSize) == $metaSize and
-            $buff =~ /^RJMD/)
-        {
-            my %dirInfo = (
-                DataPt => \$buff,
-                DataPos => $raf->Tell() - $metaSize,
-                DirStart => 8,
-                DirLen => length($buff) - 8,
-            );
-            my $tagTablePtr = GetTagTable('Image::ExifTool::Real::Metadata');
-            $exifTool->ProcessDirectory(\%dirInfo, $tagTablePtr);
-        } else {
-            $exifTool->Warn('Bad metadata footer');
-        }
-        if ($raf->Seek(-128, 2) and $raf->Read($buff, 128) == 128 and $buff =~ /^TAG/) {
-            $exifTool->VPrint(0, "ID3v1:\n");
-            my %dirInfo = (
-                DataPt => \$buff,
-                DirStart => 0,
-                DirLen => length($buff),
-            );
-            my $tagTablePtr = GetTagTable('Image::ExifTool::ID3::v1');
-            $exifTool->ProcessDirectory(\%dirInfo, $tagTablePtr);
-        }
-    }
-    return 1;
-}
-
-1;  # end
-
-__END__
-
-=head1 NAME
-
-Image::ExifTool::Real - Read Real audio/video meta information
-
-=head1 SYNOPSIS
-
-This module is used by Image::ExifTool
-
-=head1 DESCRIPTION
-
-This module contains the routines required by Image::ExifTool to read meta
-information in RealAudio (RA), RealMedia (RM, RV and RMVB) and RealMedia
-Metafile (RAM and RPM) files.
-
-=head1 NOTES
-
-There must be a bug in the software that wrote the Metadata used in the test
-file t/images/Real.rm because the TrackLyricsDataSize word is written
-little-endian, but the Real format is big-endian.
-
-=head1 AUTHOR
-
-Copyright 2003-2012, 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.getid3.org/>
-
-=item L<https://common.helixcommunity.org/nonav/2003/HCS_SDK_r5/htmfiles/rmff.htm>
-
-=back
-
-=head1 SEE ALSO
-
-L<Image::ExifTool::TagNames/Real Tags>,
-L<Image::ExifTool(3pm)|Image::ExifTool>
-
-=cut
-