exiftool_vendored 10.31.0 → 10.40.0

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

@@ -0,0 +1,297 @@
+#------------------------------------------------------------------------------
+# 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.07';
+
+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',
+        Groups => { 2 => 'Preview' },
+        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 (eg. 8-byte or larger integers)
+sub ProcessBitStream($$$)
+{
+    my ($et, $dirInfo, $tagTablePtr) = @_;
+    my $dataPt   = $$dirInfo{DataPt};
+    my $dataPos  = $$dirInfo{DataPos};
+    my $dirStart = $$dirInfo{DirStart} || 0;
+    my $dirLen   = $$dirInfo{DirLen} || (length($$dataPt) - $dirStart);
+    my $verbose  = $et->Options('Verbose');
+    my $byteOrder = GetByteOrder();
+    my $tag;
+
+    if ($verbose) {
+        $et->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;
+        }
+        $et->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 ($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 $out = $et->Options('TextOut');
+    my ($buff, $err);
+
+    # check FLAC signature
+    $raf->Read($buff, 4) == 4 and $buff eq 'fLaC' or return 0;
+    $et->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";
+            $et->VerboseDump(\$buff, DataPos => $raf->Tell() - $size);
+        }
+        $et->HandleTag($tagTablePtr, $tag, undef,
+            DataPt  => \$buff,
+            DataPos => $raf->Tell() - $size,
+        );
+        last if $last;   # all done if  is set
+    }
+    $err and $et->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-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://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/bin/Image-ExifTool-10.40/lib/Image/ExifTool/FLIF.pm

@@ -0,0 +1,353 @@
+#------------------------------------------------------------------------------
+# File:         FLIF.pm
+#
+# Description:  Read/write FLIF meta information
+#
+# Revisions:    2016/10/11 - P. Harvey Created
+#               2016/10/14 - PH Added write support
+#
+# References:   1) http://flif.info/
+#               2) https://github.com/FLIF-hub/FLIF/blob/master/doc/metadata
+#------------------------------------------------------------------------------
+
+package Image::ExifTool::FLIF;
+
+use strict;
+use vars qw($VERSION);
+use Image::ExifTool qw(:DataAccess :Utils);
+
+$VERSION = '1.02';
+
+my %flifMap = (
+    EXIF         => 'FLIF',
+    XMP          => 'FLIF',
+    ICC_Profile  => 'FLIF',
+    IFD0         => 'EXIF',
+    IFD1         => 'IFD0',
+    ExifIFD      => 'IFD0',
+    GPS          => 'IFD0',
+    SubIFD       => 'IFD0',
+    GlobParamIFD => 'IFD0',
+    PrintIM      => 'IFD0',
+    InteropIFD   => 'ExifIFD',
+    MakerNotes   => 'ExifIFD',
+);
+
+# FLIF tags
+%Image::ExifTool::FLIF::Main = (
+    GROUPS => { 0 => 'File', 1 => 'File', 2 => 'Image' },
+    VARS => { HEX_ID => 0 },
+    NOTES => q{
+        Information extracted from Free Lossless Image Format files.  See
+        L<http://flif.info/> for more information.
+    },
+#
+# header information
+#
+    0 => {
+        Name => 'ImageType',
+        PrintConv => {
+            '1' => 'Grayscale (non-interlaced)',
+            '3' => 'RGB (non-interlaced)',
+            '4' => 'RGBA (non-interlaced)',
+            'A' => 'Grayscale (interlaced)',
+            'C' => 'RGB (interlaced)',
+            'D' => 'RGBA (interlaced)',
+            'Q' => 'Grayscale Animation (non-interlaced)',
+            'S' => 'RGB Animation (non-interlaced)',
+            'T' => 'RGBA Animation (non-interlaced)',
+            'a' => 'Grayscale Animation (interlaced)',
+            'c' => 'RGB Animation (interlaced)',
+            'd' => 'RGBA Animation (interlaced)',
+        },
+    },
+    1 => {
+        Name => 'BitDepth',
+        PrintConv => {
+            '0' => 'Custom',
+            '1' => 8,
+            '2' => 16,
+        },
+    },
+    2 => 'ImageWidth',
+    3 => 'ImageHeight',
+    4 => 'AnimationFrames',
+    5 => {
+        Name => 'Encoding',
+        PrintConv => {
+            0 => 'FLIF16',
+        },
+    },
+#
+# metadata chunks
+#
+    iCCP => {
+        Name => 'ICC_Profile',
+        SubDirectory => {
+            TagTable => 'Image::ExifTool::ICC_Profile::Main',
+        },
+    },
+    eXif => {
+        Name => 'EXIF',
+        SubDirectory => {
+            TagTable => 'Image::ExifTool::Exif::Main',
+            ProcessProc => \&Image::ExifTool::ProcessTIFF,
+            WriteProc => \&Image::ExifTool::WriteTIFF,
+            Start => 6, # (skip "Exif\0\0" header)
+            Header => "Exif\0\0",
+        },
+    },
+    eXmp => {
+        Name => 'XMP',
+        SubDirectory => {
+            TagTable => 'Image::ExifTool::XMP::Main',
+        },
+    },
+    # tRko - list of truncation offsets
+    # \0 - FLIF16-format image data
+);
+
+#------------------------------------------------------------------------------
+# Read variable-length FLIF integer
+# Inputs: 0) raf reference, 1) number to add to returned value
+# Returns: integer, or undef on EOF
+sub GetVarInt($;$)
+{
+    my ($raf, $add) = @_;
+    my ($val, $buff);
+    for ($val=0; ; $val<<=7) {
+        $raf->Read($buff, 1) or return undef;
+        my $byte = ord($buff);
+        $val |= ($byte & 0x7f);
+        last unless $byte & 0x80;
+    }
+    return $val + ($add || 0);
+}
+
+#------------------------------------------------------------------------------
+# Construct variable-length FLIF integer
+# Inputs: 0) integer
+# Returns: FLIF variable-length integer byte stream
+sub SetVarInt($)
+{
+    my $val = shift;
+    my $buff = '';
+    my $high = 0;
+    for (;;) {
+        $buff = chr(($val & 0x7f) | $high) . $buff;
+        last unless $val >>= 7;
+        $high = 0x80;
+    }
+    return $buff;
+}
+
+#------------------------------------------------------------------------------
+# Read FLIF header
+# Inputs: 0) RAF ref
+# Returns: Scalar context: binary header block
+#          List context: header values (4 or 5 elements: type,depth,width,height[,frames])
+#          or undef if this isn't a valid FLIF file header
+sub ReadFLIFHeader($)
+{
+    my $raf = shift;
+    my ($buff, @vals);
+
+    # verify this is a valid FLIF file
+    return () unless $raf->Read($buff, 6) == 6 and $buff =~ /^FLIF([0-\x6f])([0-2])/;
+
+    # decode header information ("FLIF" chunk)
+    push @vals, $1, $2;                                 # type, depth
+    push @vals, GetVarInt($raf,+1), GetVarInt($raf,+1); # width, height (+1 each)
+    push @vals, GetVarInt($raf,+2) if $vals[0] gt 'H';  # frames (+2)
+
+    return () unless defined $vals[-1];
+    return @vals if wantarray;      # return the decoded header values
+
+    # return the binary header block
+    my $hdrLen = $raf->Tell();
+    return () unless $raf->Seek(0,0) and $raf->Read($buff, $hdrLen) == $hdrLen;
+    return $buff;
+}
+
+#------------------------------------------------------------------------------
+# WriteFLIF : Write FLIF image
+# Inputs: 0) ExifTool object reference, 1) dirInfo reference
+# Returns: 1 on success, 0 if this wasn't a valid FLIF file, or -1 if
+#          an output file was specified and a write error occurred
+sub WriteFLIF($$)
+{
+    my ($et, $dirInfo) = @_;
+    my $raf = $$dirInfo{RAF};
+    my ($buff, $soi, @addTags, %doneTag);
+
+    # verify FLIF header and copy it to the output file
+    $buff = ReadFLIFHeader($raf) or return 0;
+    my $outfile = $$dirInfo{OutFile};
+    Write($outfile, $buff) or return -1;
+
+    $et->InitWriteDirs(\%flifMap);
+    my $tagTablePtr = GetTagTable('Image::ExifTool::FLIF::Main');
+
+    # loop through the FLIF chunks
+    for (;;) {
+        my ($tag, $size, $inflated);
+        # read new tag (or soi) unless we already hit the soi (start of image)
+        if (not defined $soi) {
+            $raf->Read($buff, 4) == 4 or $et->Error('Unexpected EOF'), last;
+            if ($buff lt ' ') {
+                $soi = $buff;   # we have hit the start of image (no more metadata)
+                # make list of new tags to add
+                foreach $tag ('eXif', 'eXmp', 'iCCP') {
+                    push @addTags, $tag if $$et{ADD_DIRS}{$$tagTablePtr{$tag}{Name}} and not $doneTag{$tag};
+                }
+            }
+        }
+        if (not defined $soi) {
+            $tag = $buff;
+            $size = GetVarInt($raf);    # read the data size
+        } elsif (@addTags) {
+            $tag = shift @addTags;
+            ($buff, $size) = ('', 0);   # create metadata from scratch
+        } else {
+            # finish copying file (no more metadata to add)
+            Write($outfile, $soi) or return -1;
+            Write($outfile, $buff) or return -1 while $raf->Read($buff, 65536);
+            last;   # all done!
+        }
+        my $tagInfo = $et->GetTagInfo($tagTablePtr, $tag);
+        if ($tagInfo and $$tagInfo{SubDirectory} and $$et{EDIT_DIRS}{$$tagInfo{Name}}) {
+            $doneTag{$tag} = 1;         # prevent adding this back again later
+            unless (defined $soi) {
+                $raf->Read($buff, $size) == $size or $et->Error("Truncated FLIF $tag chunk"), last;
+            }
+            # rewrite the compressed data
+            if (eval { require IO::Uncompress::RawInflate } and eval { require IO::Compress::RawDeflate } ) {
+                if (length $buff == 0) {
+                    $inflated = $buff;  # (creating from scratch, so no need to inflate)
+                } elsif (not IO::Uncompress::RawInflate::rawinflate(\$buff => \$inflated)) {
+                    $et->Error("Error inflating FLIF $tag chunk"), last;
+                }
+                my $subdir = $$tagInfo{SubDirectory};
+                my %subdirInfo = (
+                    DirName  => $$tagInfo{Name},
+                    DataPt   => \$inflated,
+                    DirStart => length($inflated) ? $$subdir{Start} : undef,
+                    ReadOnly => 1,      # (used only by WriteXMP)
+                );
+                my $subTable = GetTagTable($$subdir{TagTable});
+                $inflated = $et->WriteDirectory(\%subdirInfo, $subTable, $$subdir{WriteProc});
+                if (defined $inflated) {
+                    next unless length $inflated; # (delete directory if length is zero)
+                    $inflated = $$subdir{Header} . $inflated if $$subdir{Header}; # (add back header if necessary)
+                    unless (IO::Compress::RawDeflate::rawdeflate(\$inflated => \$buff)) {
+                        $et->Error("Error deflating FLIF $tag chunk"), last;
+                    }
+                }
+            } else {
+                $et->WarnOnce('Install IO::Compress::RawDeflate to write FLIF metadata');
+            }
+            Write($outfile, $tag, SetVarInt(length $buff), $buff) or return -1;
+        } elsif (not defined $soi) {
+            Write($outfile, $tag, SetVarInt($size)) or return -1;
+            Image::ExifTool::CopyBlock($raf, $outfile, $size) or return -1;
+        }
+    }
+    return 1;
+}
+
+#------------------------------------------------------------------------------
+# Extract information from an FLIF file
+# Inputs: 0) ExifTool object reference, 1) DirInfo reference
+# Returns: 1 on success, 0 if this wasn't a valid FLIF file
+sub ProcessFLIF($$)
+{
+    my ($et, $dirInfo) = @_;
+    my $raf = $$dirInfo{RAF};
+    my ($buff, $tag, $inflated);
+
+    # verify this is a valid FLIF file and read the header
+    my @vals = ReadFLIFHeader($raf) or return 0;
+
+    $et->SetFileType();
+    my $tagTablePtr = GetTagTable('Image::ExifTool::FLIF::Main');
+    my $verbose = $et->Options('Verbose');
+
+    # save the header information
+    $et->VPrint(0, "FLIF header:\n") if $verbose;
+    for ($tag=0; defined $vals[$tag]; ++$tag) {
+        $et->HandleTag($tagTablePtr, $tag, $vals[$tag]);
+    }
+
+    # loop through the FLIF chunks
+    for (;;) {
+        $raf->Read($tag, 4) == 4 or $et->Warn('Unexpected EOF'), last;
+        my $byte = ord substr($tag, 0, 1);
+        # all done if we arrived at the image chunk
+        $byte < 32 and $et->HandleTag($tagTablePtr, 5, $byte), last;
+        my $size = GetVarInt($raf);
+        $et->VPrint(0, "FLIF $tag ($size bytes):\n") if $verbose;
+        if ($$tagTablePtr{$tag}) {
+            $raf->Read($buff, $size) == $size or $et->Warn("Truncated FLIF $tag chunk"), last;
+            $et->VerboseDump(\$buff, Addr => $raf->Tell() - $size) if $verbose > 2;
+            # inflate the compressed data
+            if (eval { require IO::Uncompress::RawInflate }) {
+                if (IO::Uncompress::RawInflate::rawinflate(\$buff => \$inflated)) {
+                    $et->HandleTag($tagTablePtr, $tag, $inflated,
+                        DataPt => \$inflated,
+                        Size => length $inflated,
+                        Extra => ' inflated',
+                    );
+                } else {
+                    $et->Warn("Error inflating FLIF $tag chunk");
+                }
+            } else {
+                $et->WarnOnce('Install IO::Uncompress::RawInflate to decode FLIF metadata');
+            }
+        } else {
+            $raf->Seek($size, 1) or $et->Warn('Seek error'), last;
+        }
+    }
+    return 1;
+}
+
+1;  # end
+
+__END__
+
+=head1 NAME
+
+Image::ExifTool::FLIF - Read/write FLIF meta information
+
+=head1 SYNOPSIS
+
+This module is used by Image::ExifTool
+
+=head1 DESCRIPTION
+
+This module contains routines required by Image::ExifTool to read and write
+meta information in FLIF (Free Lossless Image Format) images.
+
+=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://flif.info/>
+
+=item L<https://github.com/FLIF-hub/FLIF/blob/master/doc/metadata>
+
+=back
+
+=head1 SEE ALSO
+
+L<Image::ExifTool::TagNames/FLIF Tags>,
+L<Image::ExifTool(3pm)|Image::ExifTool>
+
+=cut
+