exiftool_vendored 10.25.0 → 10.31.0

data/bin/Image-ExifTool-10.31/lib/Image/ExifTool/FLIF.pm

@@ -0,0 +1,345 @@
+#------------------------------------------------------------------------------
+# 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.01';
+
+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',
+#
+# 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;
+        last if substr($tag, 0, 1) lt ' ';
+        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-2016, 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
+

data/bin/{Image-ExifTool-10.25 → Image-ExifTool-10.31}/lib/Image/ExifTool/FLIR.pm

@@ -414,18 +414,18 @@ my %float8g = ( Format => 'float', PrintConv => 'sprintf("%.8g",$val)' );
     0x070 => { Name => 'AtmosphericTransAlpha1', %float6f }, #1 (value: 0.006569)
     0x074 => { Name => 'AtmosphericTransAlpha2', %float6f }, #1 (value: 0.012620)
     0x078 => { Name => 'AtmosphericTransBeta1',  %float6f }, #1 (value: -0.002276)
-    0x07C => { Name => 'AtmosphericTransBeta2',  %float6f }, #1 (value: -0.006670)
+    0x07c => { Name => 'AtmosphericTransBeta2',  %float6f }, #1 (value: -0.006670)
     0x080 => { Name => 'AtmosphericTransX',      %float6f }, #1 (value: 1.900000)
     # 0x84,0x88: 0
     # 0x8c - float: 0,4,6
     0x90 => { Name => 'CameraTemperatureRangeMax', %floatKelvin },
     0x94 => { Name => 'CameraTemperatureRangeMin', %floatKelvin },
-    0x98 => { Name => 'UnknownTemperature1', %floatKelvin, Unknown => 1 }, # 50 degrees over camera max
-    0x9c => { Name => 'UnknownTemperature2', %floatKelvin, Unknown => 1 }, # usually 10 or 20 degrees below camera min
-    0xa0 => { Name => 'UnknownTemperature3', %floatKelvin, Unknown => 1 }, # same as camera max
-    0xa4 => { Name => 'UnknownTemperature4', %floatKelvin, Unknown => 1 }, # same as camera min
-    0xa8 => { Name => 'UnknownTemperature5', %floatKelvin, Unknown => 1 }, # usually 50 or 88 degrees over camera max
-    0xac => { Name => 'UnknownTemperature6', %floatKelvin, Unknown => 1 }, # usually 10, 20 or 40 degrees below camera min
+    0x98 => { Name => 'CameraTemperatureMaxClip', %floatKelvin }, # 50 degrees over camera max
+    0x9c => { Name => 'CameraTemperatureMinClip', %floatKelvin }, # usually 10 or 20 degrees below camera min
+    0xa0 => { Name => 'CameraTemperatureMaxWarn', %floatKelvin }, # same as camera max
+    0xa4 => { Name => 'CameraTemperatureMinWarn', %floatKelvin }, # same as camera min
+    0xa8 => { Name => 'CameraTemperatureMaxSaturated', %floatKelvin }, # usually 50 or 88 degrees over camera max
+    0xac => { Name => 'CameraTemperatureMinSaturated', %floatKelvin }, # usually 10, 20 or 40 degrees below camera min
     0xd4 => { Name => 'CameraModel',        Format => 'string[32]' },
     0xf4 => { Name => 'CameraPartNumber',   Format => 'string[16]' }, #1
     0x104 => { Name => 'CameraSerialNumber',Format => 'string[16]' }, #1

data/bin/{Image-ExifTool-10.25 → Image-ExifTool-10.31}/lib/Image/ExifTool/FujiFilm.pm

@@ -355,6 +355,12 @@ my %faceCategories = (
             32 => 'Soft',
         },
     },
+    0x1044 => { #forum7668
+        Name => 'DigitalZoom',
+        Writable => 'int32u',
+        ValueConv => '$val / 8',
+        ValueConvInv => '$val * 8',
+    },
     0x1050 => { #forum6109
         Name => 'ShutterType',
         Writable => 'int16u',
@@ -380,6 +386,20 @@ my %faceCategories = (
     # 0x1150 - Pro Low-light - val=1; Pro Focus - val=2 (ref 7)
     # 0x1151 - Pro Low-light - val=4 (number of pictures taken?); Pro Focus - val=2,3 (ref 7)
     # 0x1152 - Pro Low-light - val=1,3,4 (stacked pictures used?); Pro Focus - val=1,2 (ref 7)
+    0x1153 => { #forum7668
+        Name => 'PanoramaAngle',
+        Writable => 'int16u',
+    },
+    0x1154 => { #forum7668
+        Name => 'PanoramaDirection',
+        Writable => 'int16u',
+        PrintConv => {
+            1 => 'Right',
+            2 => 'Up',
+            3 => 'Left',
+            4 => 'Down',
+        },
+    },
     0x1201 => { #forum6109
         Name => 'AdvancedFilter',
         Writable => 'int32u',

data/bin/{Image-ExifTool-10.25 → Image-ExifTool-10.31}/lib/Image/ExifTool/Geotag.pm

@@ -24,10 +24,11 @@ use strict;
 use vars qw($VERSION);
 use Image::ExifTool qw(:Public);
 
-$VERSION = '1.49';
+$VERSION = '1.50';
 
 sub JITTER() { return 2 }       # maximum time jitter
 
+sub GetTime($);
 sub SetGeoValues($$;$);
 sub PrintFixTime($);
 sub PrintFix($@);
@@ -54,6 +55,8 @@ my %xmlTag = (
     when        => 'time',      # KML
     coordinates => 'coords',    # KML
     coord       => 'coords',    # KML, as written by Google Location History
+    begin       => 'begin',     # KML TimeSpan
+    end         => 'time',      # KML TimeSpan
     course      => 'dir',       # (written by Arduino)
     pitch       => 'pitch',     # (written by Arduino)
     roll        => 'roll',      # (written by Arduino)
@@ -183,6 +186,7 @@ sub LoadTrackLog($$;$)
     my $skipped = 0;
     my $lastSecs = 0;
     my $fix = { };
+    my (@saveFix, $timeSpan);
     for (;;) {
         $raf->ReadLine($_) or last;
         # determine file format
@@ -245,6 +249,7 @@ sub LoadTrackLog($$;$)
                         if (not $2) {
                             # opened: start a new fix
                             $lastFix = $fix = { };
+                            undef @saveFix;
                             next;
                         } elsif ($fix and $lastFix and %$fix) {
                             # closed: transfer additional tags from current fix
@@ -257,6 +262,10 @@ sub LoadTrackLog($$;$)
                     if (length $1) {
                         if ($tag) {
                             if ($tag eq 'coords') {
+                                # save other fixes if there are more than one
+                                if (defined $$fix{lon} and defined $$fix{lat} and defined $$fix{alt}) {
+                                    push @saveFix, [ @$fix{'lon','lat','alt'} ];
+                                }
                                 # read KML "Point" coordinates
                                 @$fix{'lon','lat','alt'} = split ',', $1;
                             } else {
@@ -274,29 +283,40 @@ sub LoadTrackLog($$;$)
                         $e0 or $et->VPrint(0, "Coordinate format error in $from\n"), $e0 = 1;
                         next;
                     }
-                    unless ($$fix{'time'} =~ /^(\d{4})-(\d+)-(\d+)T(\d+):(\d+):(\d+)(\.\d+)?(.*)/) {
+                    unless (defined($time = GetTime($$fix{'time'}))) {
                         $e1 or $et->VPrint(0, "Timestamp format error in $from\n"), $e1 = 1;
                         next;
                     }
-                    $time = Time::Local::timegm($6,$5,$4,$3,$2-1,$1-1900);
-                    $time += $7 if $7;  # add fractional seconds
-                    my $tz = $8;
-                    # adjust for time zone (otherwise assume UTC)
-                    # - allow timezone of +-HH:MM, +-H:MM, +-HHMM or +-HH since
-                    #   the spec is unclear about timezone format
-                    if ($tz =~ /^([-+])(\d+):(\d{2})\b/ or $tz =~ /^([-+])(\d{2})(\d{2})?\b/) {
-                        $tz = ($2 * 60 + ($3 || 0)) * 60;
-                        $tz *= -1 if $1 eq '+'; # opposite sign to change back to UTC
-                        $time += $tz;
-                    }
                     # validate altitude
                     undef $$fix{alt} if defined $$fix{alt} and $$fix{alt} !~ /^[+-]?\d+\.?\d*/;
                     $isDate = 1;
                     $canCut= 1 if defined $$fix{pdop} or defined $$fix{hdop} or defined $$fix{nsats};
                     $$has{alt} = 1 if $$fix{alt};   # set "has altitude" flag if appropriate
+                    # generate extra fixes assuming an equally spaced track
+                    if ($$fix{begin}) {
+                        my $begin = GetTime($$fix{begin});
+                        undef $$fix{begin};
+                        if (defined $begin and $begin < $time) {
+                            $$fix{span} = $timeSpan = ($timeSpan || 0) + 1;
+                            my $i;
+                            # duplicate the fix if there is only one so we will have
+                            # a fix and the start and end of the TimeSpan
+                            @saveFix or push @saveFix, [ @$fix{'lon','lat','alt'} ];
+                            for ($i=0; $i<@saveFix; ++$i) {
+                                my $t = $begin + ($time - $begin) * ($i / scalar(@saveFix));
+                                my %f;
+                                @f{'lon','lat','alt'} = @{$saveFix[$i]};
+                                $t += 0.001 if not $i and $$points{$t}; # (avoid dupicates)
+                                $f{span} = $timeSpan;
+                                $$points{$t} = \%f;
+                                push @fixTimes, $t;
+                            }
+                        }
+                    }
                     $$points{$time} = $fix;
                     push @fixTimes, $time;  # save times of all fixes in order
                     $fix = { };
+                    undef @saveFix;
                     ++$numPoints;
                 }
             }
@@ -617,6 +637,29 @@ DoneFix:    $isDate = 1;
     return "No track points found in GPS $from";
 }
 
+
+#------------------------------------------------------------------------------
+# Get floating point UTC time
+# Inputs: 0) XML time string
+# Returns: floating point time or undef on error
+sub GetTime($)
+{
+    my $timeStr = shift;
+    $timeStr =~ /^(\d{4})-(\d+)-(\d+)T(\d+):(\d+):(\d+)(\.\d+)?(.*)/ or return undef;
+    my $time = Time::Local::timegm($6,$5,$4,$3,$2-1,$1-1900);
+    $time += $7 if $7;  # add fractional seconds
+    my $tz = $8;
+    # adjust for time zone (otherwise assume UTC)
+    # - allow timezone of +-HH:MM, +-H:MM, +-HHMM or +-HH since
+    #   the spec is unclear about timezone format
+    if ($tz =~ /^([-+])(\d+):(\d{2})\b/ or $tz =~ /^([-+])(\d{2})(\d{2})?\b/) {
+        $tz = ($2 * 60 + ($3 || 0)) * 60;
+        $tz *= -1 if $1 eq '+'; # opposite sign to change back to UTC
+        $time += $tz;
+    }
+    return $time;
+}
+
 #------------------------------------------------------------------------------
 # Apply Geosync time correction
 # Inputs: 0) ExifTool ref, 1) Unix UTC time value
@@ -847,7 +890,10 @@ sub SetGeoValues($$;$)
             # check to see if we are extrapolating before the first entry in a track
             my $maxSecs = ($$p1{first} and $geoMaxIntSecs) ? $geoMaxExtSecs : $geoMaxIntSecs;
             # don't interpolate if fixes are too far apart
-            if ($t1 - $t0 > $maxSecs) {
+            # (but always interpolate fixes inside the same TimeSpan)
+            if ($t1 - $t0 > $maxSecs and (not $$p1{span} or not $$points{$t0}{span} or
+                $$p1{span} != $$points{$t0}{span}))
+            {
                 # treat as an extrapolation -- use nearest fix if close enough
                 my $tn;
                 if ($time - $t0 < $t1 - $time) {