exiftool_vendored 10.31.0 → 10.40.0

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

@@ -0,0 +1,282 @@
+#------------------------------------------------------------------------------
+# 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.05';
+
+# 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' },
+);
+
+# APE Composite tags
+%Image::ExifTool::APE::Composite = (
+    GROUPS => { 2 => 'Audio' },
+    Duration => {
+        Require => {
+            0 => 'APE:SampleRate',
+            1 => 'APE:TotalFrames',
+            2 => 'APE:BlocksPerFrame',
+            3 => 'APE:FinalFrameBlocks',
+        },
+        RawConv => '($val[0] && $val[1]) ? (($val[1] - 1) * $val[2] + $val[3]) / $val[0]: undef',
+        PrintConv => 'ConvertDuration($val)',
+    },
+);
+
+# add our composite tags
+Image::ExifTool::AddCompositeTags('Image::ExifTool::APE');
+
+#------------------------------------------------------------------------------
+# 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;
+    my %tagInfo = ( Name => $name );
+    $tagInfo{Groups} = { 2 => 'Preview' } if $tag =~ /^Cover Art/ and $tag !~ /Desc$/;
+    AddTagToTable($tagTablePtr, $tag, \%tagInfo);
+}
+
+#------------------------------------------------------------------------------
+# 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-2017, 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-10.40/lib/Image/ExifTool/APP12.pm

@@ -0,0 +1,322 @@
+#------------------------------------------------------------------------------
+# 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.13';
+
+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->GetNewValue($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-2017, 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