exiftool_vendored 9.78.0 → 9.99.0

data/bin/Image-ExifTool-9.78/lib/Image/ExifTool/APE.pm

@@ -1,262 +0,0 @@
-#------------------------------------------------------------------------------
-# File:         APE.pm
-#
-# Description:  Read Monkey's Audio meta information
-#
-# Revisions:    11/13/2006 - P. Harvey Created
-#
-# References:   1) http://www.monkeysaudio.com/
-#               2) http://www.personal.uni-jena.de/~pfk/mpp/sv8/apetag.html
-#------------------------------------------------------------------------------
-
-package Image::ExifTool::APE;
-
-use strict;
-use vars qw($VERSION);
-use Image::ExifTool qw(:DataAccess :Utils);
-
-$VERSION = '1.03';
-
-# APE metadata blocks
-%Image::ExifTool::APE::Main = (
-    GROUPS => { 2 => 'Audio' },
-    NOTES => q{
-        Tags found in Monkey's Audio (APE) information.  Only a few common tags are
-        listed below, but ExifTool will extract any tag found.  ExifTool supports
-        APEv1 and APEv2 tags, as well as ID3 information in APE files, and will also
-        read APE metadata from MP3 and MPC files.
-    },
-    Album   => { },
-    Artist  => { },
-    Genre   => { },
-    Title   => { },
-    Track   => { },
-    Year    => { },
-    'Tool Version' => { Name => 'ToolVersion' },
-    'Tool Name'    => { Name => 'ToolName' },
-);
-
-# APE MAC header version 3.97 or earlier
-%Image::ExifTool::APE::OldHeader = (
-    PROCESS_PROC => \&Image::ExifTool::ProcessBinaryData,
-    GROUPS => { 1 => 'MAC', 2 => 'Audio' },
-    FORMAT => 'int16u',
-    NOTES => 'APE MAC audio header for version 3.97 or earlier.',
-    0 => {
-        Name => 'APEVersion',
-        ValueConv => '$val / 1000',
-    },
-    1 => 'CompressionLevel',
-  # 2 => 'FormatFlags',
-    3 => 'Channels',
-    4 => { Name => 'SampleRate', Format => 'int32u' },
-  # 6 => { Name => 'HeaderBytes', Format => 'int32u' }, # WAV header bytes
-  # 8 => { Name => 'TerminatingBytes', Format => 'int32u' },
-    10 => { Name => 'TotalFrames', Format => 'int32u' },
-    12 => { Name => 'FinalFrameBlocks', Format => 'int32u' },
-);
-
-# APE MAC header version 3.98 or later
-%Image::ExifTool::APE::NewHeader = (
-    PROCESS_PROC => \&Image::ExifTool::ProcessBinaryData,
-    GROUPS => { 1 => 'MAC', 2 => 'Audio' },
-    FORMAT => 'int16u',
-    NOTES => 'APE MAC audio header for version 3.98 or later.',
-    0 => 'CompressionLevel',
-  # 1 => 'FormatFlags',
-    2 => { Name => 'BlocksPerFrame',   Format => 'int32u' },
-    4 => { Name => 'FinalFrameBlocks', Format => 'int32u' },
-    6 => { Name => 'TotalFrames',      Format => 'int32u' },
-    8 => 'BitsPerSample',
-    9 => 'Channels',
-    10 => { Name => 'SampleRate',      Format => 'int32u' },
-);
-
-#------------------------------------------------------------------------------
-# Make tag info hash for specified tag
-# Inputs: 0) tag name, 1) tag table ref
-# - must only call if tag doesn't exist
-sub MakeTag($$)
-{
-    my ($tag, $tagTablePtr) = @_;
-    my $name = ucfirst(lc($tag));
-    # remove invalid characters in tag name and capitalize following letters
-    $name =~ s/[^\w-]+(.?)/\U$1/sg;
-    $name =~ s/([a-z0-9])_([a-z])/$1\U$2/g;
-    AddTagToTable($tagTablePtr, $tag, { Name => $name });
-}
-
-#------------------------------------------------------------------------------
-# Extract information from an APE file
-# Inputs: 0) ExifTool object reference, 1) dirInfo reference
-# - Just looks for APE trailer if FileType is already set
-# Returns: 1 on success, 0 if this wasn't a valid APE file
-sub ProcessAPE($$)
-{
-    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 ($buff, $i, $header, $tagTablePtr, $dataPos, $oldIndent);
-
-    $$et{DoneAPE} = 1;
-
-    # check APE signature and process audio information
-    # unless this is some other type of file
-    unless ($$et{VALUE}{FileType}) {
-        $raf->Read($buff, 32) == 32 or return 0;
-        $buff =~ /^(MAC |APETAGEX)/ or return 0;
-        $et->SetFileType();
-        SetByteOrder('II');
-
-        if ($buff =~ /^APETAGEX/) {
-            # we already read the APE header
-            $header = 1;
-        } else {
-            # process the MAC header
-            my $vers = Get16u(\$buff, 4);
-            my $table;
-            if ($vers <= 3970) {
-                $buff = substr($buff, 4);
-                $table = GetTagTable('Image::ExifTool::APE::OldHeader');
-            } else {
-                my $dlen = Get32u(\$buff, 8);
-                my $hlen = Get32u(\$buff, 12);
-                unless ($dlen & 0x80000000 or $hlen & 0x80000000) {
-                    if ($raf->Seek($dlen, 0) and $raf->Read($buff, $hlen) == $hlen) {
-                        $table = GetTagTable('Image::ExifTool::APE::NewHeader');
-                    }
-                }
-            }
-            $et->ProcessDirectory( { DataPt => \$buff }, $table) if $table;
-        }
-    }
-    # look for APE trailer unless we already found an APE header
-    unless ($header) {
-        # look for the APE trailer footer...
-        my $footPos = -32;
-        # (...but before the ID3v1 trailer if it exists)
-        $footPos -= 128 if $$et{DoneID3} == 2;
-        $raf->Seek($footPos, 2)     or return 1;
-        $raf->Read($buff, 32) == 32 or return 1;
-        $buff =~ /^APETAGEX/        or return 1;
-        SetByteOrder('II');
-    }
-#
-# Read the APE data (we have just read the APE header or footer into $buff)
-#
-    my ($version, $size, $count, $flags) = unpack('x8V4', $buff);
-    $version /= 1000;
-    $size -= 32;    # get size of data only
-    if (($size & 0x80000000) == 0 and
-        ($header or $raf->Seek(-$size-32, 1)) and
-        $raf->Read($buff, $size) == $size)
-    {
-        if ($verbose) {
-            $oldIndent = $$et{INDENT};
-            $$et{INDENT} .= '| ';
-            $et->VerboseDir("APEv$version", $count, $size);
-            $et->VerboseDump(\$buff, DataPos => $raf->Tell() - $size);
-        }
-        $tagTablePtr = GetTagTable('Image::ExifTool::APE::Main');
-        $dataPos = $raf->Tell() - $size;
-    } else {
-        $count = -1;
-    }
-#
-# Process the APE tags
-#
-    my $pos = 0;
-    for ($i=0; $i<$count; ++$i) {
-        # read next APE tag
-        last if $pos + 8 > $size;
-        my $len = Get32u(\$buff, $pos);
-        my $flags = Get32u(\$buff, $pos + 4);
-        pos($buff) = $pos + 8;
-        last unless $buff =~ /\G(.*?)\0/sg;
-        my $tag = $1;
-        # avoid conflicts with our special table entries
-        $tag .= '.' if $Image::ExifTool::specialTags{$tag};
-        $pos = pos($buff);
-        last if $pos + $len > $size;
-        my $val = substr($buff, $pos, $len);
-        MakeTag($tag, $tagTablePtr) unless $$tagTablePtr{$tag};
-        # handle binary-value tags
-        if (($flags & 0x06) == 0x02) {
-            my $buf2 = $val;
-            $val = \$buf2;
-            # extract cover art description separately (hackitty hack)
-            if ($tag =~ /^Cover Art/) {
-                $buf2 =~ s/^([\x20-\x7f]*)\0//;
-                if ($1) {
-                    my $t = "$tag Desc";
-                    my $v = $1;
-                    MakeTag($t, $tagTablePtr) unless $$tagTablePtr{$t};
-                    $et->HandleTag($tagTablePtr, $t, $v);
-                }
-            }
-        }
-        $et->HandleTag($tagTablePtr, $tag, $val,
-            Index => $i,
-            DataPt => \$buff,
-            DataPos => $dataPos,
-            Start => $pos,
-            Size => $len,
-        );
-        $pos += $len;
-    }
-    $i == $count or $et->Warn('Bad APE trailer');
-    $$et{INDENT} = $oldIndent if defined $oldIndent;
-    return 1;
-}
-
-1;  # end
-
-__END__
-
-=head1 NAME
-
-Image::ExifTool::APE - Read Monkey's Audio 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 Monkey's Audio (APE) audio files.
-
-=head1 BUGS
-
-Currently doesn't parse MAC header unless it is at the start of the file.
-
-=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://www.monkeysaudio.com/>
-
-=item L<http://www.personal.uni-jena.de/~pfk/mpp/sv8/apetag.html>
-
-=back
-
-=head1 SEE ALSO
-
-L<Image::ExifTool::TagNames/APE Tags>,
-L<Image::ExifTool(3pm)|Image::ExifTool>
-
-=cut
-

data/bin/Image-ExifTool-9.78/lib/Image/ExifTool/APP12.pm

@@ -1,322 +0,0 @@
-#------------------------------------------------------------------------------
-# File:         APP12.pm
-#
-# Description:  Read APP12 meta information
-#
-# Revisions:    10/18/2005 - P. Harvey Created
-#
-# References:   1) Heinrich Giesen private communication
-#------------------------------------------------------------------------------
-
-package Image::ExifTool::APP12;
-
-use strict;
-use vars qw($VERSION);
-use Image::ExifTool qw(:DataAccess :Utils);
-
-$VERSION = '1.12';
-
-sub ProcessAPP12($$$);
-sub ProcessDucky($$$);
-sub WriteDucky($$$);
-
-# APP12 tags (ref PH)
-%Image::ExifTool::APP12::PictureInfo = (
-    PROCESS_PROC => \&ProcessAPP12,
-    GROUPS => { 0 => 'APP12', 1 => 'PictureInfo', 2 => 'Image' },
-    PRIORITY => 0,
-    NOTES => q{
-        The JPEG APP12 "Picture Info" segment was used by some older cameras, and
-        contains ASCII-based meta information.  Below are some tags which have been
-        observed Agfa and Polaroid images, however ExifTool will extract information
-        from any tags found in this segment.
-    },
-    FNumber => {
-        ValueConv => '$val=~s/^[A-Za-z ]*//;$val',  # Agfa leads with an 'F'
-        PrintConv => 'sprintf("%.1f",$val)',
-    },
-    Aperture => {
-        PrintConv => 'sprintf("%.1f",$val)',
-    },
-    TimeDate => {
-        Name => 'DateTimeOriginal',
-        Description => 'Date/Time Original',
-        Groups => { 2 => 'Time' },
-        ValueConv => '$val=~/^\d+$/ ? ConvertUnixTime($val) : $val',
-        PrintConv => '$self->ConvertDateTime($val)',
-    },
-    Shutter => {
-        Name => 'ExposureTime',
-        ValueConv => '$val * 1e-6',
-        PrintConv => 'Image::ExifTool::Exif::PrintExposureTime($val)',
-    },
-    shtr => {
-        Name => 'ExposureTime',
-        ValueConv => '$val * 1e-6',
-        PrintConv => 'Image::ExifTool::Exif::PrintExposureTime($val)',
-    },
-   'Serial#'    => {
-        Name => 'SerialNumber',
-        Groups => { 2 => 'Camera' },
-    },
-    Flash       => { PrintConv => { 0 => 'Off', 1 => 'On' } },
-    Macro       => { PrintConv => { 0 => 'Off', 1 => 'On' } },
-    StrobeTime  => { },
-    Ytarget     => { Name => 'YTarget' },
-    ylevel      => { Name => 'YLevel' },
-    FocusPos    => { },
-    FocusMode   => { },
-    Quality     => { },
-    ExpBias     => 'ExposureCompensation',
-    FWare       => 'FirmwareVersion',
-    StrobeTime  => { },
-    Resolution  => { },
-    Protect     => { },
-    ConTake     => { },
-    ImageSize   => { PrintConv => '$val=~tr/-/x/;$val' },
-    ColorMode   => { },
-    Zoom        => { },
-    ZoomPos     => { },
-    LightS      => { },
-    Type        => {
-        Name => 'CameraType',
-        Groups => { 2 => 'Camera' },
-        DataMember => 'CameraType',
-        RawConv => '$self->{CameraType} = $val',
-    },
-    Version     => { Groups => { 2 => 'Camera' } },
-    ID          => { Groups => { 2 => 'Camera' } },
-);
-
-# APP12 segment written in Photoshop "Save For Web" images
-# (from tests with Photoshop 7 files - PH/1)
-%Image::ExifTool::APP12::Ducky = (
-    PROCESS_PROC => \&ProcessDucky,
-    WRITE_PROC => \&WriteDucky,
-    GROUPS => { 0 => 'Ducky', 1 => 'Ducky', 2 => 'Image' },
-    WRITABLE => 'string',
-    NOTES => q{
-        Photoshop uses the JPEG APP12 "Ducky" segment to store some information in
-        "Save for Web" images.
-    },
-    1 => { #PH
-        Name => 'Quality',
-        Priority => 0,
-        Avoid => 1,
-        Writable => 'int32u',
-        ValueConv => 'unpack("N",$val)',    # 4-byte integer
-        ValueConvInv => 'pack("N",$val)',
-        PrintConv => '"$val%"',
-        PrintConvInv => '$val=~/(\d+)/ ? $1 : undef',
-    },
-    2 => { #1
-        Name => 'Comment',
-        Priority => 0,
-        Avoid => 1,
-        # (ignore 4-byte character count at start of value)
-        ValueConv => '$self->Decode(substr($val,4),"UCS2","MM")',
-        ValueConvInv => 'pack("N",length $val) . $self->Encode($val,"UCS2","MM")',
-    },
-    3 => { #PH
-        Name => 'Copyright',
-        Priority => 0,
-        Avoid => 1,
-        Groups => { 2 => 'Author' },
-        # (ignore 4-byte character count at start of value)
-        ValueConv => '$self->Decode(substr($val,4),"UCS2","MM")',
-        ValueConvInv => 'pack("N",length $val) . $self->Encode($val,"UCS2","MM")',
-    },
-);
-
-#------------------------------------------------------------------------------
-# Write APP12 Ducky segment
-# Inputs: 0) ExifTool object ref, 1) dirInfo ref, 2) tag table ref
-# Returns: New directory data or undefined on error
-sub WriteDucky($$$)
-{
-    my ($et, $dirInfo, $tagTablePtr) = @_;
-    $et or return 1;    # allow dummy access to autoload this package
-    my $dataPt = $$dirInfo{DataPt};
-    my $pos = $$dirInfo{DirStart};
-    my $newTags = $et->GetNewTagInfoHash($tagTablePtr);
-    my @addTags = sort { $a <=> $b } keys(%$newTags);
-    my ($dirEnd, %doneTags);
-    if ($dataPt) {
-        $dirEnd = $pos + $$dirInfo{DirLen};
-    } else {
-        my $tmp = '';
-        $dataPt = \$tmp;
-        $pos = $dirEnd = 0;
-    }
-    my $newData = '';
-    SetByteOrder('MM');
-    # process all data blocks in Ducky segment
-    for (;;) {
-        my ($tag, $len, $val);
-        if ($pos + 4 <= $dirEnd) {
-            $tag = Get16u($dataPt, $pos);
-            $len = Get16u($dataPt, $pos + 2);
-            $pos += 4;
-            if ($pos + $len > $dirEnd) {
-                $et->Warn('Invalid Ducky block length');
-                return undef;
-            }
-            $val = substr($$dataPt, $pos, $len);
-            $pos += $len;
-        } else {
-            last unless @addTags;
-            $tag = pop @addTags;
-            next if $doneTags{$tag};
-        }
-        $doneTags{$tag} = 1;
-        my $tagInfo = $$newTags{$tag};
-        if ($tagInfo) {
-            my $nvHash = $et->GetNewValueHash($tagInfo);
-            my $isNew;
-            if (defined $val) {
-                if ($et->IsOverwriting($nvHash, $val)) {
-                    $et->VerboseValue("- Ducky:$$tagInfo{Name}", $val);
-                    $isNew = 1;
-                }
-            } else {
-                next unless $$nvHash{IsCreating};
-                $isNew = 1;
-            }
-            if ($isNew) {
-                $val = $et->GetNewValues($nvHash);
-                ++$$et{CHANGED};
-                next unless defined $val;   # next if tag is being deleted
-                $et->VerboseValue("+ Ducky:$$tagInfo{Name}", $val);
-            }
-        }
-        $newData .= pack('nn', $tag, length $val) . $val;
-    }
-    $newData .= "\0\0" if length $newData;
-    return $newData;
-}
-
-#------------------------------------------------------------------------------
-# Process APP12 Ducky segment (ref PH)
-# Inputs: 0) ExifTool object reference, 1) Directory information ref, 2) tag table ref
-# Returns: 1 on success, 0 if this wasn't a recognized Ducky segment
-# Notes: This segment has the following format:
-#   1) 5 bytes: "Ducky"
-#   2) multiple data blocks (all integers are big endian):
-#      a) 2 bytes: block type (0=end, 1=Quality, 2=Comment, 3=Copyright)
-#      b) 2 bytes: block length (N)
-#      c) N bytes: block data
-sub ProcessDucky($$$)
-{
-    my ($et, $dirInfo, $tagTablePtr) = @_;
-    my $dataPt = $$dirInfo{DataPt};
-    my $pos = $$dirInfo{DirStart};
-    my $dirEnd = $pos + $$dirInfo{DirLen};
-    SetByteOrder('MM');
-    # process all data blocks in Ducky segment
-    for (;;) {
-        last if $pos + 4 > $dirEnd;
-        my $tag = Get16u($dataPt, $pos);
-        my $len = Get16u($dataPt, $pos + 2);
-        $pos += 4;
-        if ($pos + $len > $dirEnd) {
-            $et->Warn('Invalid Ducky block length');
-            last;
-        }
-        my $val = substr($$dataPt, $pos, $len);
-        $et->HandleTag($tagTablePtr, $tag, $val,
-            DataPt => $dataPt,
-            DataPos => $$dirInfo{DataPos},
-            Start => $pos,
-            Size => $len,
-        );
-        $pos += $len;
-    }
-    return 1;
-}
-
-#------------------------------------------------------------------------------
-# Process APP12 Picture Info segment (ref PH)
-# Inputs: 0) ExifTool object reference, 1) Directory information ref, 2) tag table ref
-# Returns: 1 on success, 0 if this wasn't a recognized APP12
-sub ProcessAPP12($$$)
-{
-    my ($et, $dirInfo, $tagTablePtr) = @_;
-    my $dataPt = $$dirInfo{DataPt};
-    my $dirStart = $$dirInfo{DirStart} || 0;
-    my $dirLen = $$dirInfo{DirLen} || (length($$dataPt) - $dirStart);
-    if ($dirLen != $dirStart + length($$dataPt)) {
-        my $buff = substr($$dataPt, $dirStart, $dirLen);
-        $dataPt = \$buff;
-    } else {
-        pos($$dataPt) = $$dirInfo{DirStart};
-    }
-    my $verbose = $et->Options('Verbose');
-    my $success = 0;
-    my $section = '';
-    pos($$dataPt) = 0;
-
-    # this regular expression is a bit complex, but basically we are looking for
-    # section headers (eg. "[Camera Info]") and tag/value pairs (eg. "tag=value",
-    # where "value" may contain white space), separated by spaces or CR/LF.
-    # (APP12 uses CR/LF, but Olympus TextualInfo is similar and uses spaces)
-    while ($$dataPt =~ /(\[.*?\]|[\w#-]+=[\x20-\x7e]+?(?=\s*([\n\r\0]|[\w#-]+=|\[|$)))/g) {
-        my $token = $1;
-        # was this a section name?
-        if ($token =~ /^\[(.*)\]/) {
-            $et->VerboseDir($1) if $verbose;
-            $section = ($token =~ /\[(\S+) ?Info\]/i) ? $1 : '';
-            $success = 1;
-            next;
-        }
-        $et->VerboseDir($$dirInfo{DirName}) if $verbose and not $success;
-        $success = 1;
-        my ($tag, $val) = ($token =~ /(\S+)=(.+)/);
-        my $tagInfo = $et->GetTagInfo($tagTablePtr, $tag);
-        $verbose and $et->VerboseInfo($tag, $tagInfo, Value => $val);
-        unless ($tagInfo) {
-            # add new tag to table
-            $tagInfo = { Name => ucfirst $tag };
-            # put in Camera group if information in "Camera" section
-            $$tagInfo{Groups} = { 2 => 'Camera' } if $section =~ /camera/i;
-            AddTagToTable($tagTablePtr, $tag, $tagInfo);
-        }
-        $et->FoundTag($tagInfo, $val);
-    }
-    return $success;
-}
-
-
-1;  #end
-
-__END__
-
-=head1 NAME
-
-Image::ExifTool::APP12 - Read APP12 meta information
-
-=head1 SYNOPSIS
-
-This module is loaded automatically by Image::ExifTool when required.
-
-=head1 DESCRIPTION
-
-This module contains definitions required by Image::ExifTool to interpret
-APP12 meta information.
-
-=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 ACKNOWLEDGEMENTS
-
-Thanks to Heinrich Giesen for his help decoding APP12 "Ducky" information.
-
-=head1 SEE ALSO
-
-L<Image::ExifTool::TagNames/APP12 Tags>,
-L<Image::ExifTool(3pm)|Image::ExifTool>
-
-=cut