exiftool_vendored 10.31.0 → 10.40.0

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

@@ -0,0 +1,145 @@
+#------------------------------------------------------------------------------
+# File:         Theora.pm
+#
+# Description:  Read Theora video meta information
+#
+# Revisions:    2011/07/13 - P. Harvey Created
+#
+# References:   1) http://www.theora.org/doc/Theora.pdf
+#------------------------------------------------------------------------------
+
+package Image::ExifTool::Theora;
+
+use strict;
+use vars qw($VERSION);
+use Image::ExifTool qw(:DataAccess :Utils);
+
+$VERSION = '1.00';
+
+# Theora header types
+%Image::ExifTool::Theora::Main = (
+    NOTES => q{
+        Information extracted from Ogg Theora video files.  See
+        L<http://www.theora.org/doc/Theora.pdf> for the Theora specification.
+    },
+    0x80 => {
+        Name => 'Identification',
+        SubDirectory => {
+            TagTable => 'Image::ExifTool::Theora::Identification',
+            ByteOrder => 'BigEndian',
+        },
+    },
+    0x81 => {
+        Name => 'Comments',
+        SubDirectory => {
+            TagTable => 'Image::ExifTool::Vorbis::Comments',
+        },
+    },
+    # 0x82 - Setup
+);
+
+# tags extracted from Theora Idenfication header
+%Image::ExifTool::Theora::Identification = (
+    PROCESS_PROC => \&Image::ExifTool::ProcessBinaryData,
+    GROUPS => { 2 => 'Video' },
+    NOTES => 'Tags extracted from the Theora identification header.',
+    0 => {
+        Name => 'TheoraVersion',
+        Format => 'int8u[3]',
+        PrintConv => '$val =~ tr/ /./; $val',
+    },
+    7 => {
+        Name => 'ImageWidth',
+        Format => 'int32u',
+        ValueConv => '$val >> 8',
+    },
+    10 => {
+        Name => 'ImageHeight',
+        Format => 'int32u',
+        ValueConv => '$val >> 8',
+    },
+    13 => 'XOffset',
+    14 => 'YOffset',
+    15 => {
+        Name => 'FrameRate',
+        Format => 'rational64u',
+        PrintConv => 'int($val * 1000 + 0.5) / 1000',
+    },
+    23 => {
+        Name => 'PixelAspectRatio',
+        Format => 'int16u[3]',
+        ValueConv => 'my @a=split(" ",$val); (($a[0]<<8)+($a[1]>>8)) / ((($a[1]&0xff)<<8)+$a[2])',
+        PrintConv => 'int($val * 1000 + 0.5) / 1000',
+    },
+    29 => {
+        Name => 'ColorSpace',
+        PrintConv => {
+            0 => 'Undefined',
+            1 => 'Rec. 470M',
+            2 => 'Rec. 470BG',
+        },
+    },
+    30 => {
+        Name => 'NominalVideoBitrate',
+        Format => 'int32u',
+        ValueConv => '$val >> 8',
+        PrintConv => {
+            0 => 'Unspecified',
+            OTHER => \&Image::ExifTool::ConvertBitrate,
+        },
+    },
+    33 => {
+        Name => 'Quality',
+        ValueConv => '$val >> 2',
+    },
+    34 => {
+        Name => 'PixelFormat',
+        ValueConv => '($val >> 3) & 0x3',
+        PrintConv => {
+            0 => '4:2:0',
+            2 => '4:2:2',
+            3 => '4:4:4',
+        },
+    },
+);
+
+1;  # end
+
+__END__
+
+=head1 NAME
+
+Image::ExifTool::Theora - Read Theora video 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 Theora video streams.
+
+=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.theora.org/doc/Theora.pdf>
+
+=back
+
+=head1 SEE ALSO
+
+L<Image::ExifTool::TagNames/Theora Tags>,
+L<Image::ExifTool::TagNames/Ogg Tags>,
+L<Image::ExifTool(3pm)|Image::ExifTool>
+
+=cut
+

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

@@ -0,0 +1,317 @@
+#------------------------------------------------------------------------------
+# File:         Torrent.pm
+#
+# Description:  Read information from BitTorrent file
+#
+# Revisions:    2013/08/27 - P. Harvey Created
+#
+# References:   1) https://wiki.theory.org/BitTorrentSpecification
+#------------------------------------------------------------------------------
+
+package Image::ExifTool::Torrent;
+
+use strict;
+use vars qw($VERSION);
+use Image::ExifTool qw(:DataAccess :Utils);
+
+$VERSION = '1.03';
+
+sub ReadBencode($$);
+sub ExtractTags($$$;$$@);
+
+# tags extracted from BitTorrent files
+%Image::ExifTool::Torrent::Main = (
+    GROUPS => { 2 => 'Document' },
+    NOTES => q{
+        Below are tags commonly found in BitTorrent files.  As well as these tags,
+        any other existing tags will be extracted.  For convenience, list items are
+        expanded into individual tags with an index in the tag name, but only the
+        tags with index "1" are listed in the tables below.  See
+        L<https://wiki.theory.org/BitTorrentSpecification> for the BitTorrent
+        specification.
+    },
+    'announce'      => { },
+    'announce-list' => { Name => 'AnnounceList1' },
+    'comment'       => { },
+    'created by'    => { Name => 'Creator' }, # software used to create the torrent
+    'creation date' => {
+        Name => 'CreateDate',
+        Groups => { 2 => 'Time' },
+        ValueConv => 'ConvertUnixTime($val,1)',
+        PrintConv => '$self->ConvertDateTime($val)',
+    },
+    'encoding'      => { },
+    'info'          => { SubDirectory => { TagTable => 'Image::ExifTool::Torrent::Info' } },
+    'url-list'      => { Name => 'URLList1' },
+);
+
+%Image::ExifTool::Torrent::Info = (
+    GROUPS => { 2 => 'Document' },
+    'file-duration' => { Name => 'File1Duration' },
+    'file-media'    => { Name => 'File1Media' },
+    'files'         => { SubDirectory => { TagTable => 'Image::ExifTool::Torrent::Files' } },
+    'length'        => { },
+    'md5sum'        => { Name => 'MD5Sum' },
+    'name'          => { },
+    'name.utf-8'    => { Name => 'NameUTF-8' },
+    'piece length'  => { Name => 'PieceLength' },
+    'pieces'        => {
+        Name => 'Pieces',
+        Notes => 'concatenation of 20-byte SHA-1 digests for each piece',
+    },
+    'private'       => { },
+    'profiles'      => { SubDirectory => { TagTable => 'Image::ExifTool::Torrent::Profiles' } },
+);
+
+%Image::ExifTool::Torrent::Profiles = (
+    GROUPS => { 2 => 'Document' },
+    'width'         => { Name => 'Profile1Width' },
+    'height'        => { Name => 'Profile1Height' },
+    'acodec'        => { Name => 'Profile1AudioCodec' },
+    'vcodec'        => { Name => 'Profile1VideoCodec' },
+);
+
+%Image::ExifTool::Torrent::Files = (
+    GROUPS => { 2 => 'Document' },
+    'length'        => { Name => 'File1Length', PrintConv => 'ConvertFileSize($val)' },
+    'md5sum'        => { Name => 'File1MD5Sum'  },
+    'path'          => { Name => 'File1Path', JoinPath => 1 },
+    'path.utf-8'    => { Name => 'File1PathUTF-8', JoinPath => 1 },
+);
+
+#------------------------------------------------------------------------------
+# Read 64kB more data into buffer
+# Inputs: 0) RAF ref, 1) buffer ref
+# Returns: number of bytes read
+# Notes: Sets BencodeEOF element of RAF on end of file
+sub ReadMore($$)
+{
+    my ($raf, $dataPt) = @_;
+    my $buf2;
+    my $n = $raf->Read($buf2, 65536);
+    $$raf{BencodeEOF} = 1 if $n != 65536;
+    $$dataPt = substr($$dataPt, pos($$dataPt)) . $buf2 if $n;
+    return $n;
+}
+
+#------------------------------------------------------------------------------
+# Read bencoded value
+# Inputs: 0) input file, 1) buffer (pos must be set to current position)
+# Returns: HASH ref, ARRAY ref, SCALAR ref, SCALAR, or undef on error or end of data
+# Notes: Sets BencodeError element of RAF on any error
+sub ReadBencode($$)
+{
+    my ($raf, $dataPt) = @_;
+
+    # read more if necessary (keep a minimum of 64 bytes in the buffer)
+    my $pos = pos($$dataPt);
+    return undef unless defined $pos;
+    my $remaining = length($$dataPt) - $pos;
+    ReadMore($raf, $dataPt) if $remaining < 64 and not $$raf{BencodeEOF};
+
+    # read next token
+    $$dataPt =~ /(.)/sg or return undef;
+
+    my $val;
+    my $tok = $1;
+    if ($tok eq 'i') {      # integer
+        $$dataPt =~ /\G(-?\d+)e/g or return $val;
+        $val = $1;
+    } elsif ($tok eq 'd') { # dictionary
+        $val = { };
+        for (;;) {
+            my $k = ReadBencode($raf, $dataPt);
+            last unless defined $k;
+            # the key must be a byte string
+            if (ref $k) {
+                ref $k ne 'SCALAR' and $$raf{BencodeError} = 'Bad dictionary key', last;
+                $k = $$k;
+            }
+            my $v = ReadBencode($raf, $dataPt);
+            last unless defined $v;
+            $$val{$k} = $v;
+        }
+    } elsif ($tok eq 'l') { # list
+        $val = [ ];
+        for (;;) {
+            my $v = ReadBencode($raf, $dataPt);
+            last unless defined $v;
+            push @$val, $v;
+        }
+    } elsif ($tok eq 'e') { # end of dictionary or list
+        # return undef (no error)
+    } elsif ($tok =~ /^\d$/ and $$dataPt =~ /\G(\d*):/g) { # byte string
+        my $len = $tok . $1;
+        my $more = $len - (length($$dataPt) - pos($$dataPt));
+        my $value;
+        if ($more <= 0) {
+            $value = substr($$dataPt,pos($$dataPt),$len);
+            pos($$dataPt) = pos($$dataPt) + $len;
+        } elsif ($more > 10000000) {
+            # just skip over really long values
+            $val = \ "(Binary data $len bytes)" if $raf->Seek($more, 1);
+        } else {
+            # need to read more from file
+            my $buff;
+            my $n = $raf->Read($buff, $more);
+            if ($n == $more) {
+                $value = substr($$dataPt,pos($$dataPt)) . $buff;
+                $$dataPt = '';
+                pos($$dataPt) = 0;
+            }
+        }
+        if (defined $value) {
+            # return as binary data unless it is a reasonable-length ASCII string
+            if (length($value) > 256 or $value =~ /[^\t\x20-\x7e]/) {
+                $val = \$value;
+            } else {
+                $val = $value;
+            }
+        } elsif (not defined $val) {
+            $$raf{BencodeError} = 'Truncated byte string';
+        }
+    } else {
+        $$raf{BencodeError} = 'Bad format';
+    }
+    return $val;
+}
+
+#------------------------------------------------------------------------------
+# Extract tags from dictionary hash
+# Inputs: 0) ExifTool ref, 1) dictionary hash reference, 2) tag table ref,
+#         3) parent hash ID, 4) parent hash name, 5-N) list indices
+# Returns: number of tags extracted
+sub ExtractTags($$$;$$@)
+{
+    my ($et, $hashPtr, $tagTablePtr, $baseID, $baseName, @index) = @_;
+    my $count = 0;
+    my $tag;
+    foreach $tag (sort keys %$hashPtr) {
+        my $val = $$hashPtr{$tag};
+        my ($i, $j, @more);
+        for (; defined $val; $val = shift @more) {
+            my $id = defined $baseID ? "$baseID/$tag" : $tag;
+            unless ($$tagTablePtr{$id}) {
+                my $name = ucfirst $tag;
+                # capitalize all words in tag name and remove illegal characters
+                $name =~ s/[^-_a-zA-Z0-9]+(.?)/\U$1/g;
+                $name = "Tag$name" if length($name) < 2 or $name !~ /^[A-Z]/;
+                $name = $baseName . $name if defined $baseName; # add base name if necessary
+                AddTagToTable($tagTablePtr, $id, { Name => $name });
+                $et->VPrint(0, "  [adding $id '$name']\n");
+            }
+            my $tagInfo = $et->GetTagInfo($tagTablePtr, $id) or next;
+            if (ref $val eq 'ARRAY') {
+                if ($$tagInfo{JoinPath}) {
+                    $val = join '/', @$val;
+                } else {
+                    push @more, @$val;
+                    next if ref $more[0] eq 'ARRAY'; # continue expanding nested lists
+                    $val = shift @more;
+                    $i or $i = 0, push(@index, $i);
+                }
+            }
+            $index[-1] = ++$i if defined $i;
+            if (@index) {
+                $id .= join '_', @index;  # add instance number(s) to tag ID
+                unless ($$tagTablePtr{$id}) {
+                    my $name = $$tagInfo{Name};
+                    # embed indices at position of '1' in tag name
+                    my $n = ($name =~ tr/1/#/);
+                    for ($j=0; $j<$n; ++$j) {
+                        my $idx = $index[$j] || '';
+                        $name =~ s/#/$idx/;
+                    }
+                    # put remaining indices at end of tag name
+                    for (; $j<@index; ++$j) {
+                        $name .= '_' if $name =~ /\d$/;
+                        $name .= $index[$j];
+                    }
+                    AddTagToTable($tagTablePtr, $id, { %$tagInfo, Name => $name });
+                }
+                $tagInfo = $et->GetTagInfo($tagTablePtr, $id) or next;
+            }
+            if (ref $val eq 'HASH') {
+                # extract tags from this dictionary
+                my ($table, $rootID, $rootName);
+                if ($$tagInfo{SubDirectory}) {
+                    $table = GetTagTable($$tagInfo{SubDirectory}{TagTable});
+                } else {
+                    $table = $tagTablePtr;
+                    # use hash ID and Name as base for contained tags to avoid conflicts
+                    $rootID = $id;
+                    $rootName = $$tagInfo{Name};
+                }
+                $count += ExtractTags($et, $val, $table, $rootID, $rootName, @index);
+            } else {
+                # handle this simple tag value
+                $et->HandleTag($tagTablePtr, $id, $val);
+                ++$count;
+            }
+        }
+        pop @index if defined $i;
+    }
+    return $count;
+}
+
+#------------------------------------------------------------------------------
+# Process BitTorrent file
+# Inputs: 0) ExifTool object reference, 1) dirInfo reference (with RAF set)
+# Returns: 1 on success, 0 if this wasn't a valid BitTorrent file
+sub ProcessTorrent($$)
+{
+    my ($et, $dirInfo) = @_;
+    my $success = 0;
+    my $raf = $$dirInfo{RAF};
+    my $buff = '';
+    pos($buff) = 0;
+    my $dict = ReadBencode($raf, \$buff);
+    my $err = $$raf{BencodeError};
+    $et->Warn("Bencode error: $err") if $err;
+    if (ref $dict eq 'HASH' and $$dict{announce}) {
+        $et->SetFileType();
+        my $tagTablePtr = GetTagTable('Image::ExifTool::Torrent::Main');
+        ExtractTags($et, $dict, $tagTablePtr) and $success = 1;
+    }
+    return $success;
+}
+
+1;  # end
+
+__END__
+
+=head1 NAME
+
+Image::ExifTool::Torrent - Read information from BitTorrent file
+
+=head1 SYNOPSIS
+
+This module is used by Image::ExifTool
+
+=head1 DESCRIPTION
+
+This module contains definitions required by Image::ExifTool to read
+bencoded information from BitTorrent files.
+
+=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<https://wiki.theory.org/BitTorrentSpecification>
+
+=back
+
+=head1 SEE ALSO
+
+L<Image::ExifTool::TagNames/Torrent Tags>,
+L<Image::ExifTool(3pm)|Image::ExifTool>
+
+=cut
+