mini_exiftool_vendored 8.9.7.v2 → 9.2.7.v1

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

@@ -1,296 +0,0 @@
-#------------------------------------------------------------------------------
-# File:         FLAC.pm
-#
-# Description:  Read Free Lossless Audio Codec information
-#
-# Revisions:    11/13/2006 - P. Harvey Created
-#
-# References:   1) http://flac.sourceforge.net/
-#------------------------------------------------------------------------------
-
-package Image::ExifTool::FLAC;
-
-use strict;
-use vars qw($VERSION);
-use Image::ExifTool qw(:DataAccess :Utils);
-
-$VERSION = '1.04';
-
-sub ProcessBitStream($$$);
-
-# FLAC metadata blocks
-%Image::ExifTool::FLAC::Main = (
-    NOTES => q{
-        Free Lossless Audio Codec (FLAC) meta information.  ExifTool also extracts
-        ID3 information from these files.
-    },
-    0 => {
-        Name => 'StreamInfo',
-        SubDirectory => { TagTable => 'Image::ExifTool::FLAC::StreamInfo' },
-    },
-    1 => { Name => 'Padding',     Binary => 1, Unknown => 1 },
-    2 => { Name => 'Application', Binary => 1, Unknown => 1 },
-    3 => { Name => 'SeekTable',   Binary => 1, Unknown => 1 },
-    4 => {
-        Name => 'VorbisComment',
-        SubDirectory => { TagTable => 'Image::ExifTool::Vorbis::Comments' },
-    },
-    5 => { Name => 'CueSheet',    Binary => 1, Unknown => 1 },
-    6 => {
-        Name => 'Picture',
-        SubDirectory => { TagTable => 'Image::ExifTool::FLAC::Picture' },
-    },
-    # 7-126 - Reserved
-    # 127 - Invalid
-);
-
-%Image::ExifTool::FLAC::StreamInfo = (
-    PROCESS_PROC => \&ProcessBitStream,
-    NOTES => 'FLAC is big-endian, so bit 0 is the high-order bit in this table.',
-    GROUPS => { 2 => 'Audio' },
-    'Bit000-015' => 'BlockSizeMin',
-    'Bit016-031' => 'BlockSizeMax',
-    'Bit032-055' => 'FrameSizeMin',
-    'Bit056-079' => 'FrameSizeMax',
-    'Bit080-099' => 'SampleRate',
-    'Bit100-102' => {
-        Name => 'Channels',
-        ValueConv => '$val + 1',
-    },
-    'Bit103-107' => {
-        Name => 'BitsPerSample',
-        ValueConv => '$val + 1',
-    },
-    'Bit108-143' => 'TotalSamples',
-);
-
-%Image::ExifTool::FLAC::Picture = (
-    PROCESS_PROC => \&Image::ExifTool::ProcessBinaryData,
-    GROUPS => { 2 => 'Image' },
-    FORMAT => 'int32u',
-    0 => {
-        Name => 'PictureType',
-        PrintConv => { # (Note: Duplicated in ID3, ASF and FLAC modules!)
-            0 => 'Other',
-            1 => '32x32 PNG Icon',
-            2 => 'Other Icon',
-            3 => 'Front Cover',
-            4 => 'Back Cover',
-            5 => 'Leaflet',
-            6 => 'Media',
-            7 => 'Lead Artist',
-            8 => 'Artist',
-            9 => 'Conductor',
-            10 => 'Band',
-            11 => 'Composer',
-            12 => 'Lyricist',
-            13 => 'Recording Studio or Location',
-            14 => 'Recording Session',
-            15 => 'Performance',
-            16 => 'Capture from Movie or Video',
-            17 => 'Bright(ly) Colored Fish',
-            18 => 'Illustration',
-            19 => 'Band Logo',
-            20 => 'Publisher Logo',
-        },
-    },
-    1 => {
-        Name => 'PictureMIMEType',
-        Format => 'var_pstr32',
-    },
-    2 => {
-        Name => 'PictureDescription',
-        Format => 'var_pstr32',
-        ValueConv => '$self->Decode($val, "UTF8")',
-    },
-    3 => 'PictureWidth',
-    4 => 'PictureHeight',
-    5 => 'PictureBitsPerPixel',
-    6 => 'PictureIndexedColors',
-    7 => 'PictureLength',
-    8 => {
-        Name => 'Picture',
-        Format => 'undef[$val{7}]',
-        Binary => 1,
-    },
-);
-
-# FLAC composite tags
-%Image::ExifTool::FLAC::Composite = (
-    Duration => {
-        Require => {
-            0 => 'FLAC:SampleRate',
-            1 => 'FLAC:TotalSamples',
-        },
-        ValueConv => '$val[0] and $val[1] ? $val[1] / $val[0] : undef',
-        PrintConv => 'ConvertDuration($val)',
-    },
-);
-
-# add our composite tags
-Image::ExifTool::AddCompositeTags('Image::ExifTool::FLAC');
-
-
-#------------------------------------------------------------------------------
-# Process information in a bit stream
-# Inputs: 0) ExifTool object ref, 1) dirInfo ref, 2) tag table ref
-# Notes: Byte order is used to determine the ordering of bits in the stream:
-# 'MM' = bit 0 is most significant, 'II' = bit 0 is least significant
-# - can handle arbitrarily wide values (ie. 8-byte or larger integers)
-sub ProcessBitStream($$$)
-{
-    my ($exifTool, $dirInfo, $tagTablePtr) = @_;
-    my $dataPt   = $$dirInfo{DataPt};
-    my $dataPos  = $$dirInfo{DataPos};
-    my $dirStart = $$dirInfo{DirStart} || 0;
-    my $dirLen   = $$dirInfo{DirLen} || (length($$dataPt) - $dirStart);
-    my $verbose  = $exifTool->Options('Verbose');
-    my $byteOrder = GetByteOrder();
-    my $tag;
-
-    if ($verbose) {
-        $exifTool->VPrint(0, "  + [BitStream directory, $dirLen bytes, '$byteOrder' order]\n");
-    }
-    foreach $tag (sort keys %$tagTablePtr) {
-        next unless $tag =~ /^Bit(\d+)-?(\d+)?/;
-        my ($b1, $b2) = ($1, $2 || $1);     # start/end bit numbers in stream
-        my ($i1, $i2) = (int($b1 / 8), int($b2 / 8)); # start/end byte numbers
-        my ($f1, $f2) = ($b1 % 8, $b2 % 8); # start/end bit numbers within each byte
-        last if $i2 >= $dirLen;
-        my $val = 0;
-        my ($i, $mask, $extra);
-        $extra = ', Mask=0x' if $verbose and ($f1 != 0 or $f2 != 7);
-        if ($byteOrder eq 'MM') {
-            # loop from high byte to low byte
-            for ($i=$i1; $i<=$i2; ++$i) {
-                $mask = 0xff;
-                if ($i == $i1 and $f1) {
-                    # mask off high bits in first word (0 is high bit)
-                    foreach ((8-$f1) .. 7) { $mask ^= (1 << $_) }
-                }
-                if ($i == $i2 and $f2 < 7) {
-                    # mask off low bits in last word (7 is low bit)
-                    foreach (0 .. (6-$f2)) { $mask ^= (1 << $_) }
-                }
-                $val = $val * 256 + ($mask & Get8u($dataPt, $i + $dirStart));
-                $extra .= sprintf('%.2x', $mask) if $extra;
-            }
-        } else {
-            # (FLAC is big-endian, but support little-endian bit streams
-            #  so this routine can be used by other modules)
-            # loop from high byte to low byte
-            for ($i=$i2; $i>=$i1; --$i) {
-                $mask = 0xff;
-                if ($i == $i1 and $f1) {
-                    # mask off low bits in first word (0 is low bit)
-                    foreach (0 .. ($f1-1)) { $mask ^= (1 << $_) }
-                }
-                if ($i == $i2 and $f2 < 7) {
-                    # mask off high bits in last word (7 is high bit)
-                    foreach (($f2+1) .. 7) { $mask ^= (1 << $_) }
-                }
-                $val = $val * 256 + ($mask & Get8u($dataPt, $i + $dirStart));
-                $extra .= sprintf('%.2x', $mask) if $extra;
-            }
-        }
-        # shift word down until low bit is in position 0
-        until ($mask & 0x01) {
-            $val /= 2;
-            $mask >>= 1;
-        }
-        $exifTool->HandleTag($tagTablePtr, $tag, $val,
-            DataPt  => $dataPt,
-            DataPos => $dataPos,
-            Start   => $dirStart + $i1,
-            Size    => $i2 - $i1 + 1,
-            Extra   => $extra,
-        );
-    }
-    return 1;
-}
-
-#------------------------------------------------------------------------------
-# Extract information from an Ogg FLAC file
-# Inputs: 0) ExifTool object reference, 1) dirInfo reference
-# Returns: 1 on success, 0 if this wasn't a valid Ogg FLAC file
-sub ProcessFLAC($$)
-{
-    my ($exifTool, $dirInfo) = @_;
-
-    # must first check for leading/trailing ID3 information
-    unless ($exifTool->{DoneID3}) {
-        require Image::ExifTool::ID3;
-        Image::ExifTool::ID3::ProcessID3($exifTool, $dirInfo) and return 1;
-    }
-    my $raf = $$dirInfo{RAF};
-    my $verbose = $exifTool->Options('Verbose');
-    my $out = $exifTool->Options('TextOut');
-    my ($buff, $err);
-
-    # check FLAC signature
-    $raf->Read($buff, 4) == 4 and $buff eq 'fLaC' or return 0;
-    $exifTool->SetFileType();
-    SetByteOrder('MM');
-    my $tagTablePtr = GetTagTable('Image::ExifTool::FLAC::Main');
-    for (;;) {
-        # read next metadata block header
-        $raf->Read($buff, 4) == 4 or last;
-        my $flag = unpack('C', $buff);
-        my $size = unpack('N', $buff) & 0x00ffffff;
-        $raf->Read($buff, $size) == $size or $err = 1, last;
-        my $last = $flag & 0x80;    # last-metadata-block flag
-        my $tag  = $flag & 0x7f;    # tag bits
-        if ($verbose) {
-            print $out "FLAC metadata block, type $tag:\n";
-            $exifTool->VerboseDump(\$buff, DataPos => $raf->Tell() - $size);
-        }
-        $exifTool->HandleTag($tagTablePtr, $tag, undef,
-            DataPt  => \$buff,
-            DataPos => $raf->Tell() - $size,
-        );
-        last if $last;   # all done if  is set
-    }
-    $err and $exifTool->Warn('Format error in FLAC file');
-    return 1;
-}
-
-1;  # end
-
-__END__
-
-=head1 NAME
-
-Image::ExifTool::FLAC - Read Free Lossless Audio Codec 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 Free Lossless Audio Codec (FLAC) audio files.
-
-=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://flac.sourceforge.net/>
-
-=back
-
-=head1 SEE ALSO
-
-L<Image::ExifTool::TagNames/FLAC Tags>,
-L<Image::ExifTool::TagNames/Ogg Tags>,
-L<Image::ExifTool(3pm)|Image::ExifTool>
-
-=cut
-

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

@@ -1,333 +0,0 @@
-#------------------------------------------------------------------------------
-# File:         Fixup.pm
-#
-# Description:  Utility to handle pointer fixups
-#
-# Revisions:    01/19/2005 - P. Harvey Created
-#               04/11/2005 - P. Harvey Allow fixups to be tagged with a marker,
-#                            and add new marker-related routines
-#               06/21/2006 - P. Harvey Patch to work with negative offsets
-#               07/07/2006 - P. Harvey Added support for 16-bit pointers
-#
-# Data Members:
-#
-#   Start     - Position in data where a zero pointer points to.
-#   Shift     - Amount to shift offsets (relative to Start).
-#   Fixups    - List of Fixup object references to to shift relative to this Fixup.
-#   Pointers  - Hash of references to fixup pointer arrays, keyed by ByteOrder
-#               string (with "2" added if pointer is 16-bit [default is 32-bit],
-#               plus "_$marker" suffix if tagged with a marker name).
-#------------------------------------------------------------------------------
-
-package Image::ExifTool::Fixup;
-
-use strict;
-use Image::ExifTool qw(GetByteOrder SetByteOrder Get32u Get32s Set32u
-                       Get16u Get16s Set16u);
-use vars qw($VERSION);
-
-$VERSION = '1.04';
-
-sub AddFixup($$;$$);
-sub ApplyFixup($$);
-sub Dump($;$);
-
-#------------------------------------------------------------------------------
-# New - create new Fixup object
-# Inputs: 0) reference to Fixup object or Fixup class name
-sub new
-{
-    local $_;
-    my $that = shift;
-    my $class = ref($that) || $that || 'Image::ExifTool::Fixup';
-    my $self = bless {}, $class;
-
-    # initialize required members
-    $self->{Start} = 0;
-    $self->{Shift} = 0;
-
-    return $self;
-}
-
-#------------------------------------------------------------------------------
-# Clone this object
-# Inputs: 0) reference to Fixup object or Fixup class name
-# Returns: reference to new Fixup object
-sub Clone($)
-{
-    my $self = shift;
-    my $clone = new Image::ExifTool::Fixup;
-    $clone->{Start} = $self->{Start};
-    $clone->{Shift} = $self->{Shift};
-    my $phash = $self->{Pointers};
-    if ($phash) {
-        $clone->{Pointers} = { };
-        my $byteOrder;
-        foreach $byteOrder (keys %$phash) {
-            my @pointers = @{$phash->{$byteOrder}};
-            $clone->{Pointers}->{$byteOrder} = \@pointers;
-        }
-    }
-    if ($self->{Fixups}) {
-        $clone->{Fixups} = [ ];
-        my $subFixup;
-        foreach $subFixup (@{$self->{Fixups}}) {
-            push @{$clone->{Fixups}}, $subFixup->Clone();
-        }
-    }
-    return $clone;
-}
-
-#------------------------------------------------------------------------------
-# Add fixup pointer or another fixup object below this one
-# Inputs: 0) Fixup object reference
-#         1) Scalar for pointer offset, or reference to Fixup object
-#         2) Optional marker name for the pointer
-#         3) Optional pointer format ('int16u' or 'int32u', defaults to 'int32u')
-# Notes: Byte ordering must be set properly for the pointer being added (must keep
-# track of the byte order of each offset since MakerNotes may have different byte order!)
-sub AddFixup($$;$$)
-{
-    my ($self, $pointer, $marker, $format) = @_;
-    if (ref $pointer) {
-        $self->{Fixups} or $self->{Fixups} = [ ];
-        push @{$self->{Fixups}}, $pointer;
-    } else {
-        my $byteOrder = GetByteOrder();
-        if (defined $format) {
-            if ($format eq 'int16u') {
-                $byteOrder .= '2';
-            } elsif ($format ne 'int32u') {
-                warn "Bad Fixup pointer format $format\n";
-            }
-        }
-        $byteOrder .= "_$marker" if defined $marker;
-        my $phash = $self->{Pointers};
-        $phash or $phash = $self->{Pointers} = { };
-        $phash->{$byteOrder} or $phash->{$byteOrder} = [ ];
-        push @{$phash->{$byteOrder}}, $pointer;
-    }
-}
-
-#------------------------------------------------------------------------------
-# fix up pointer offsets
-# Inputs: 0) Fixup object reference, 1) data reference
-# Outputs: Collapses fixup hierarchy into linear lists of fixup pointers
-sub ApplyFixup($$)
-{
-    my ($self, $dataPt) = @_;
-
-    my $start = $self->{Start};
-    my $shift = $self->{Shift} + $start;   # make shift relative to start
-    my $phash = $self->{Pointers};
-
-    # fix up pointers in this fixup
-    if ($phash and ($start or $shift)) {
-        my $saveOrder = GetByteOrder(); # save original byte ordering
-        my ($byteOrder, $ptr);
-        foreach $byteOrder (keys %$phash) {
-            SetByteOrder(substr($byteOrder,0,2));
-            # apply the fixup offset shift (must get as signed integer
-            # to avoid overflow in case it was negative before)
-            my ($get, $set) = ($byteOrder =~ /^(II2|MM2)/) ?
-                              (\&Get16s, \&Set16u) : (\&Get32s, \&Set32u);
-            foreach $ptr (@{$phash->{$byteOrder}}) {
-                $ptr += $start;         # update pointer to new start location
-                next unless $shift;
-                &$set(&$get($dataPt, $ptr) + $shift, $dataPt, $ptr);
-            }
-        }
-        SetByteOrder($saveOrder);       # restore original byte ordering
-    }
-    # recurse into contained fixups
-    if ($self->{Fixups}) {
-        # create our pointer hash if it doesn't exist
-        $phash or $phash = $self->{Pointers} = { };
-        # loop through all contained fixups
-        my $subFixup;
-        foreach $subFixup (@{$self->{Fixups}}) {
-            # adjust the subfixup start and shift
-            $subFixup->{Start} += $start;
-            $subFixup->{Shift} += $shift - $start;
-            # recursively apply contained fixups
-            ApplyFixup($subFixup, $dataPt);
-            my $shash = $subFixup->{Pointers} or next;
-            # add all pointers to our collapsed lists
-            my $byteOrder;
-            foreach $byteOrder (keys %$shash) {
-                $phash->{$byteOrder} or $phash->{$byteOrder} = [ ];
-                push @{$phash->{$byteOrder}}, @{$shash->{$byteOrder}};
-                delete $shash->{$byteOrder};
-            }
-            delete $subFixup->{Pointers};
-        }
-        delete $self->{Fixups};    # remove our contained fixups
-    }
-    # reset our Start/Shift for the collapsed fixup
-    $self->{Start} = $self->{Shift} = 0;
-}
-
-#------------------------------------------------------------------------------
-# Does specified marker exist?
-# Inputs: 0) Fixup object reference, 1) marker name
-# Returns: True if fixup contains specified marker name
-sub HasMarker($$)
-{
-    my ($self, $marker) = @_;
-    my $phash = $self->{Pointers};
-    return 0 unless $phash;
-    return 1 if grep /_$marker$/, keys %$phash;
-    return 0 unless $self->{Fixups};
-    my $subFixup;
-    foreach $subFixup (@{$self->{Fixups}}) {
-        return 1 if $subFixup->HasMarker($marker);
-    }
-    return 0;
-}
-
-#------------------------------------------------------------------------------
-# Set all marker pointers to specified value
-# Inputs: 0) Fixup object reference, 1) data reference
-#         2) marker name, 3) pointer value, 4) offset to start of data
-sub SetMarkerPointers($$$$;$)
-{
-    my ($self, $dataPt, $marker, $value, $startOffset) = @_;
-    my $start = $self->{Start} + ($startOffset || 0);
-    my $phash = $self->{Pointers};
-
-    if ($phash) {
-        my $saveOrder = GetByteOrder(); # save original byte ordering
-        my ($byteOrder, $ptr);
-        foreach $byteOrder (keys %$phash) {
-            next unless $byteOrder =~ /^(II|MM)(2?)_$marker$/;
-            SetByteOrder($1);
-            my $set = $2 ? \&Set16u : \&Set32u;
-            foreach $ptr (@{$phash->{$byteOrder}}) {
-                &$set($value, $dataPt, $ptr + $start);
-            }
-        }
-        SetByteOrder($saveOrder);       # restore original byte ordering
-    }
-    if ($self->{Fixups}) {
-        my $subFixup;
-        foreach $subFixup (@{$self->{Fixups}}) {
-            $subFixup->SetMarkerPointers($dataPt, $marker, $value, $start);
-        }
-    }
-}
-
-#------------------------------------------------------------------------------
-# Get pointer values for specified marker
-# Inputs: 0) Fixup object reference, 1) data reference,
-#         2) marker name, 3) offset to start of data
-# Returns: List of marker pointers in list context, or first marker pointer otherwise
-sub GetMarkerPointers($$$;$)
-{
-    my ($self, $dataPt, $marker, $startOffset) = @_;
-    my $start = $self->{Start} + ($startOffset || 0);
-    my $phash = $self->{Pointers};
-    my @pointers;
-
-    if ($phash) {
-        my $saveOrder = GetByteOrder();
-        my ($byteOrder, $ptr);
-        foreach $byteOrder (grep /_$marker$/, keys %$phash) {
-            SetByteOrder(substr($byteOrder,0,2));
-            my $get = ($byteOrder =~ /^(II2|MM2)/) ? \&Get16u : \&Get32u;
-            foreach $ptr (@{$phash->{$byteOrder}}) {
-                push @pointers, &$get($dataPt, $ptr + $start);
-            }
-        }
-        SetByteOrder($saveOrder);       # restore original byte ordering
-    }
-    if ($self->{Fixups}) {
-        my $subFixup;
-        foreach $subFixup (@{$self->{Fixups}}) {
-            push @pointers, $subFixup->GetMarkerPointers($dataPt, $marker, $start);
-        }
-    }
-    return @pointers if wantarray;
-    return $pointers[0];
-}
-
-#------------------------------------------------------------------------------
-# Dump fixup to console for debugging
-# Inputs: 0) Fixup object reference, 1) optional initial indent string
-sub Dump($;$)
-{
-    my ($self, $indent) = @_;
-    $indent or $indent = '';
-    printf "${indent}Fixup start=0x%x shift=0x%x\n", $self->{Start}, $self->{Shift};
-    my $phash = $self->{Pointers};
-    if ($phash) {
-        my $byteOrder;
-        foreach $byteOrder (sort keys %$phash) {
-            print "$indent  $byteOrder: ", join(' ',@{$phash->{$byteOrder}}),"\n";
-        }
-    }
-    if ($self->{Fixups}) {
-        my $subFixup;
-        foreach $subFixup (@{$self->{Fixups}}) {
-            Dump($subFixup, $indent . '  ');
-        }
-    }
-}
-
-
-1; # end
-
-__END__
-
-=head1 NAME
-
-Image::ExifTool::Fixup - Utility to handle pointer fixups
-
-=head1 SYNOPSIS
-
-    use Image::ExifTool::Fixup;
-
-    $fixup = new Image::ExifTool::Fixup;
-
-    # add a new fixup to a pointer at the specified offset in data
-    $fixup->AddFixup($offset);
-
-    # add a new Fixup object to the tree
-    $fixup->AddFixup($subFixup);
-
-    $fixup->{Start} += $shift1;   # shift pointer offsets and values
-
-    $fixup->{Shift} += $shift2;   # shift pointer values only
-
-    # recursively apply fixups to the specified data
-    $fixup->ApplyFixups(\$data);
-
-    $fixup->Dump();               # dump debugging information
-
-=head1 DESCRIPTION
-
-This module contains the code to keep track of pointers in memory and to
-shift these pointers as required.  It is used by ExifTool to maintain the
-pointers in image file directories (IFD's).
-
-=head1 NOTES
-
-Keeps track of pointers with different byte ordering, and relies on
-Image::ExifTool::GetByteOrder() to determine the current byte ordering
-when adding new pointers to a fixup.
-
-Maintains a hierarchical list of fixups so that the whole hierarchy can
-be shifted by a simple shift at the base.  Hierarchy is collapsed to a
-linear list when ApplyFixups() is called.
-
-=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 SEE ALSO
-
-L<Image::ExifTool(3pm)|Image::ExifTool>
-
-=cut