exiftool_vendored 9.67.0 → 9.68.0

data/bin/{Image-ExifTool-9.67 → Image-ExifTool-9.68}/lib/Image/ExifTool/Exif.pm

@@ -51,7 +51,7 @@ use vars qw($VERSION $AUTOLOAD @formatSize @formatName %formatNumber %intFormat
 use Image::ExifTool qw(:DataAccess :Utils);
 use Image::ExifTool::MakerNotes;
 
-$VERSION = '3.64';
+$VERSION = '3.65';
 
 sub ProcessExif($$$);
 sub WriteExif($$$);
@@ -1556,6 +1556,7 @@ my %sampleFormat = (
         },
     },
     0x9102 => 'CompressedBitsPerPixel',
+    # 0x9103 - int16u: 1 (found in Pentax XG-1 samples)
     0x9201 => {
         Name => 'ShutterSpeedValue',
         Notes => 'displayed in seconds, but stored as an APEX value',
@@ -3199,7 +3200,7 @@ sub CalcScaleFactor35efl
             my %lkup = ( 3=>10, 4=>1, 5=>0.001 , cm=>10, mm=>1, um=>0.001 );
             my $units = $lkup{ shift() || $res || '' } || 25.4;
             my $x_res = shift || return undef;
-            my $y_res = shift || return undef;
+            my $y_res = shift || $x_res;
             Image::ExifTool::IsFloat($x_res) and $x_res != 0 or return undef;
             Image::ExifTool::IsFloat($y_res) and $y_res != 0 or return undef;
             my ($w, $h);

data/bin/{Image-ExifTool-9.67 → Image-ExifTool-9.68}/lib/Image/ExifTool/GE.pm

@@ -18,6 +18,7 @@ $VERSION = '1.00';
 sub ProcessGE2($$$);
 
 # GE type 1 maker notes (ref PH)
+# (similar to Kodak::Type11 and Ricoh::Type2)
 %Image::ExifTool::GE::Main = (
     WRITE_PROC => \&Image::ExifTool::Exif::WriteExif,
     CHECK_PROC => \&Image::ExifTool::Exif::CheckExif,

data/bin/{Image-ExifTool-9.67 → Image-ExifTool-9.68}/lib/Image/ExifTool/Geotag.pm

@@ -22,11 +22,12 @@ use strict;
 use vars qw($VERSION);
 use Image::ExifTool qw(:Public);
 
-$VERSION = '1.43';
+$VERSION = '1.44';
 
 sub JITTER() { return 2 }       # maximum time jitter
 
 sub SetGeoValues($$;$);
+sub PrintFixTime($);
 sub PrintFix($@);
 
 # XML tags that we recognize (keys are forced to lower case)
@@ -565,11 +566,11 @@ sub LoadTrackLog($$;$)
             my @lbl = ('start:', 'end:  ');
             # (fixes may be in reverse order in GPX files)
             @lbl = reverse @lbl if $fixTimes[0] > $fixTimes[-1];
-            print $out "  GPS track $lbl[0] " . Image::ExifTool::ConvertUnixTime($fixTimes[0]) . " UTC\n";
+            print $out "  GPS track $lbl[0] " . PrintFixTime($fixTimes[0]) . "\n";
             if ($verbose > 3) {
                 print $out PrintFix($points, $_) foreach @fixTimes;
             }
-            print $out "  GPS track $lbl[1] " . Image::ExifTool::ConvertUnixTime($fixTimes[-1]) . " UTC\n";
+            print $out "  GPS track $lbl[1] " . PrintFixTime($fixTimes[-1]) . "\n";
         }
     }
     if ($numPoints) {
@@ -763,18 +764,19 @@ sub SetGeoValues($$;$)
 
         if ($et->Options('Verbose') > 1 and not $secondTry) {
             my $out = $et->Options('TextOut');
-            my $str = "$fsec UTC";
+            my $str = '';
             $str .= sprintf(" (incl. Geosync offset of %+.3f sec)", $sync) if defined $sync;
             unless ($tz) {
                 my $tzs = Image::ExifTool::TimeZoneString([$sec,$min,$hr,$day,$mon-1,$year-1900],$time);
                 $str .= " (local timezone is $tzs)";
             }
-            print $out '  Geotime value:   ' . Image::ExifTool::ConvertUnixTime(int $time) . "$str\n";
+            print $out '  Geotime value:   ' . PrintFixTime($time) . "$str\n";
         }
         # interpolate GPS track at $time
         if ($time < $$times[0]) {
             if ($time < $$times[0] - $geoMaxExtSecs) {
                 $err or $err = 'Time is too far before track';
+                $et->VPrint(2, '  Track start:     ', PrintFixTime($$times[0]), "\n") if $verbose > 2;
             } else {
                 $fix = $$points{$$times[0]};
                 $iExt = 0;  $iDir = 1;
@@ -784,6 +786,7 @@ sub SetGeoValues($$;$)
         } elsif ($time > $$times[-1]) {
             if ($time > $$times[-1] + $geoMaxExtSecs) {
                 $err or $err = 'Time is too far beyond track';
+                $et->VPrint(2, '  Track end:       ', PrintFixTime($$times[-1]), "\n") if $verbose > 2;
             } else {
                 $fix = $$points{$$times[-1]};
                 $iExt = $#$times;  $iDir = -1;
@@ -820,6 +823,7 @@ sub SetGeoValues($$;$)
                 }
                 if (abs($time - $tn) > $geoMaxExtSecs) {
                     $err or $err = 'Time is too far from nearest GPS fix';
+                    $et->VPrint(2, '  Nearest fix:     ', PrintFixTime($tn), "\n") if $verbose > 2;
                 } else {
                     $fix = $$points{$tn};
                     $et->VPrint(2, "  Taking pos from fix:\n",
@@ -828,7 +832,7 @@ sub SetGeoValues($$;$)
             } else {
                 my $f0 = $t1 == $t0 ? 0 : ($time - $t0) / ($t1 - $t0);
                 my $p0 = $$points{$t0};
-                $et->VPrint(2, "  Interpolating pos between fixes (f=$f0):\n",
+                $et->VPrint(2, "  Interpolating between fixes (f=$f0):\n",
                     PrintFix($points, $t0, $t1)) if $verbose > 2;
                 $fix = { };
                 # loop through available fix information categories
@@ -1073,13 +1077,9 @@ sub ConvertGeosync($$)
             # print verbose output
             if ($et->Options('Verbose') > 1) {
                 # print GPS and image timestamps in UTC
-                my $gps = Image::ExifTool::ConvertUnixTime($gpsSecs);
-                my $img = Image::ExifTool::ConvertUnixTime($imgSecs);
-                $gps .= $1 if $gpsTime =~ /(\.\d+)/;
-                $img .= $1 if $imgTime =~ /(\.\d+)/;
                 $et->VPrint(1, "Added Geosync point:\n",
-                               "  GPS time stamp:  $gps UTC\n",
-                               "  Image date/time: $img UTC\n");
+                               '  GPS time stamp:  ', PrintFixTime($gpsSecs), "\n",
+                               '  Image date/time: ', PrintFixTime($imgSecs), "\n");
             }
             # save sorted list of image sync times if we have more than one
             my @times = keys %{$$sync{Points}};
@@ -1104,6 +1104,17 @@ sub ConvertGeosync($$)
     return $sync;
 }
 
+#------------------------------------------------------------------------------
+# Print fix time
+# Inputs: 0) time since the epoch
+# Returns: UTC time string with fractional seconds
+sub PrintFixTime($)
+{
+    my $time = $_[0] + 0.0005;  # round off to nearest ms
+    my $fsec = int(($time - int($time)) * 1000);
+    return sprintf('%s.%.3d UTC', Image::ExifTool::ConvertUnixTime($time), $fsec);
+}
+
 #------------------------------------------------------------------------------
 # Print fix information
 # Inputs: 0) lookup for all fix points, 1-n) list of fix times
@@ -1115,11 +1126,11 @@ sub PrintFix($@)
     my $str = '';
     while (@_) {
         my $time = shift;
-        $str .= '    ' . Image::ExifTool::ConvertUnixTime($time) . ' UTC -';
+        $str .= '    ' . PrintFixTime($time) . ' -';
         my $fix = $$points{$time};
         if ($fix) {
             foreach (sort keys %$fix) {
-                $str .= " $_=$$fix{$_}" unless $_ eq 'time';
+                $str .= " $_=$$fix{$_}" unless $_ eq 'time' or not defined $$fix{$_};
             }
         }
         $str .= "\n";

data/bin/{Image-ExifTool-9.67 → Image-ExifTool-9.68}/lib/Image/ExifTool/Import.pm

@@ -132,7 +132,7 @@ Tok: for (;;) {
             # read another 64kB and add to unparsed data
             my $offset = length($$buffPt) - $pos;
             $$buffPt = substr($$buffPt, $pos) if $offset;
-            read $fp, $$buffPt, 65536, $offset or $$buffPt = '', last;
+            ($fp and read $fp, $$buffPt, 65536, $offset) or $$buffPt = '', last;
             unless ($didBOM) {
                 $$buffPt =~ s/^\xef\xbb\xbf//;  # remove UTF-8 BOM if it exists
                 $didBOM = 1;

data/bin/{Image-ExifTool-9.67 → Image-ExifTool-9.68}/lib/Image/ExifTool/Kodak.pm

@@ -846,10 +846,9 @@ sub WriteKodakIFD($$$);
 );
 
 # Kodak PixPro S-1 maker notes (ref PH)
+# (similar to Ricoh::Type2 and GE::Main)
 %Image::ExifTool::Kodak::Type11 = (
     # (can't currently write these)
-    # WRITE_PROC => \&Image::ExifTool::Exif::WriteExif,
-    # CHECK_PROC => \&Image::ExifTool::Exif::CheckExif,
     GROUPS => { 0 => 'MakerNotes', 2 => 'Camera' },
     NOTES =>q{
         These tags are found in models such as the PixPro S-1.  They are not

data/bin/Image-ExifTool-9.68/lib/Image/ExifTool/Lytro.pm

@@ -0,0 +1,211 @@
+#------------------------------------------------------------------------------
+# File:         Lytro.pm
+#
+# Description:  Read Lytro LFP files
+#
+# Revisions:    2014-07-17 - P. Harvey Created
+#
+# References:   1) http://optics.miloush.net/lytro/TheFileFormat.aspx
+#------------------------------------------------------------------------------
+
+package Image::ExifTool::Lytro;
+
+use strict;
+use vars qw($VERSION);
+use Image::ExifTool qw(:DataAccess :Utils);
+use Image::ExifTool::Import;
+
+$VERSION = '1.00';
+
+sub ExtractTags($$$);
+
+# Lytro LFP tags (ref PH)
+%Image::ExifTool::Lytro::Main = (
+    GROUPS => { 2 => 'Camera' },
+    VARS => { NO_ID => 1 },
+    NOTES => q{
+        Tag definitions for Lytro Light Field Picture (LFP) files.  ExifTool
+        extracts the full JSON metadata blocks, as well as breaking them down into
+        individual tags.  All available tags are extracted from the JSON metadata,
+        even if they don't appear in the table below.
+    },
+    JSONMetadata => {
+        Notes => 'the full JSON-format metadata blocks',
+        Binary => 1,
+        List => 1,
+    },
+    EmbeddedImage => {
+        Notes => 'JPEG image embedded in LFP files written by Lytro Desktop',
+        Groups => { 2 => 'Image' },
+        Binary => 1,
+    },
+    Type                => { Name => 'CameraType' },
+    CameraMake          => { Name => 'Make' },
+    CameraModel         => { Name => 'Model', Description => 'Camera Model Name' },
+    CameraSerialNumber  => { Name => 'SerialNumber'},
+    CameraFirmware      => { Name => 'FirmwareVersion'},
+    DevicesAccelerometerSampleArrayTime => { Name => 'AccelerometerTime'},
+    DevicesAccelerometerSampleArrayX    => { Name => 'AccelerometerX'},
+    DevicesAccelerometerSampleArrayY    => { Name => 'AccelerometerY'},
+    DevicesAccelerometerSampleArrayZ    => { Name => 'AccelerometerZ'},
+    DevicesClockZuluTime => {
+        Name => 'DateTimeOriginal',
+        Groups => { 2 => 'Time' },
+        ValueConv => 'require Image::ExifTool::XMP; Image::ExifTool::XMP::ConvertXMPDate($val)',
+        PrintConv => '$self->ConvertDateTime($val)',
+    },
+    DevicesLensFNumber => {
+        Name => 'FNumber',
+        PrintConv => 'Image::ExifTool::Exif::PrintFNumber($val)',
+    },
+    DevicesLensFocalLength => {
+        Name => 'FocalLength',
+        ValueConv => '$val * 1000', # convert from metres to mm
+        PrintConv => 'sprintf("%.1f mm",$val)',
+    },
+    DevicesLensTemperature => {
+        Name => 'LensTemperature',
+        PrintConv => 'sprintf("%.1f C",$val)',
+    },
+    DevicesSocTemperature => {
+        Name => 'SocTemperature',
+        PrintConv => 'sprintf("%.1f C",$val)',
+    },
+    DevicesShutterFrameExposureDuration => {
+        Name => 'FrameExposureTime',
+        PrintConv => 'Image::ExifTool::Exif::PrintExposureTime($val)',
+    },
+    DevicesShutterPixelExposureDuration => {
+        Name => 'ExposureTime',
+        PrintConv => 'Image::ExifTool::Exif::PrintExposureTime($val)',
+    },
+    DevicesSensorPixelPitch => {
+        Name => 'FocalPlaneXResolution',
+        Notes => 'Y resolution is the same as X resolution',
+        ValueConv => '25.4 / $val / 1000',  # convert from metres to pixels/inch
+    },
+    DevicesSensorSensorSerial   => { Name => 'SensorSerialNumber'},
+    DevicesSensorIso            => { Name => 'ISO' },
+    ImageLimitExposureBias      => { Groups => { 2 => 'Image' }, PrintConv => 'sprintf("%+.1f", $val)' },
+    ImageModulationExposureBias => { Groups => { 2 => 'Image' }, PrintConv => 'sprintf("%+.1f", $val)' },
+    ImageOrientation => {
+        Name => 'Orientation',
+        Groups => { 2 => 'Image' },
+        PrintConv => {
+            1 => 'Horizontal (normal)',
+        },
+    },
+);
+
+#------------------------------------------------------------------------------
+# Extract tags from a parsed JSON hash
+# Inputs: 0) ExifTool ref, 1) tag hash ref, 2) base tag name
+sub ExtractTags($$$)
+{
+    my ($et, $meta, $parent) = @_;
+    ref $meta eq 'HASH' or $et->Warn('Invalid LFP metadata'), return;
+    my ($key, $val, $name, $tagTablePtr);
+    foreach $key (sort keys %$meta) {
+        my $tag = $parent . ucfirst($key);
+        foreach $val (ref $$meta{$key} eq 'ARRAY' ? @{$$meta{$key}} : $$meta{$key}) {
+            ref $val eq 'HASH' and ExtractTags($et, $val, $tag), next;
+            $tagTablePtr or $tagTablePtr = GetTagTable('Image::ExifTool::Lytro::Main');
+            unless ($$tagTablePtr{$tag}) {
+                ($name = $tag) =~ s/[^-_a-zA-Z0-9](.?)/\U$1/g;
+                $name =~ s/ParametersVendorContentComLytroTags//; 
+                my %tagInfo;
+                $tagInfo{Groups} = { 2 => 'Image' } unless $name =~ s/^Devices//;
+                $tagInfo{List} = 1 if ref $$meta{$key} eq 'ARRAY';
+                $tagInfo{Name} = $name;
+                $et->VPrint(0, "  [adding $tag as $name]\n");
+                Image::ExifTool::AddTagToTable($tagTablePtr, $tag, \%tagInfo);
+            }
+            $et->HandleTag($tagTablePtr, $tag, $val);
+        }
+    }
+}
+
+#------------------------------------------------------------------------------
+# Process segments from a Lytro LFP image
+# Inputs: 0) ExifTool object reference, 1) dirInfo reference
+# Returns: 1 on success, 0 if this wasn't a valid Lytro image
+sub ProcessLFP($$)
+{
+    my ($et, $dirInfo) = @_;
+    my $raf = $$dirInfo{RAF};
+    my $verbose = $et->Options('Verbose');
+    my ($buff, $id);
+
+    # validate the Lytro file header
+    return 0 unless $raf->Read($buff, 16) == 16 and $buff =~ /^\x89LFP\x0d\x0a\x1a\x0a/;
+    $et->SetFileType();   # set the FileType tag
+    SetByteOrder('MM');
+    my $tagTablePtr = GetTagTable('Image::ExifTool::Lytro::Main');
+    while ($raf->Read($buff, 16) == 16) {
+        $buff =~ /^\x89LF/ or $et->Warn('LFP format error'), last;
+        my $size = Get32u(\$buff, 12);
+        $size & 0x80000000 and $et->Warn('Invalid LFP segment size'), last;
+        $raf->Read($id, 80) == 80 or $et->Warn('Truncated LFP segment'), last;  # ignore the sha1
+        if ($verbose) {
+            $id =~ s/\0.*//s;
+            $et->VPrint(0, substr($buff,1,3), " segment ($size bytes, $id)\n");
+        }
+        if ($size > 20000000) {
+            $raf->Seek($size, 1) or $et->Warn('Seek error in LFP file'), last;
+        } else {
+            $raf->Read($buff,$size) == $size or $et->Warn('Truncated LFP data'), last;
+            if ($buff =~ /^\{\s+"/) { # JSON metadata?
+                pos($buff) = 0;
+                $et->HandleTag($tagTablePtr, 'JSONMetadata', $buff);
+                my $meta = Image::ExifTool::Import::ReadJSONObject(undef, \$buff);
+                ExtractTags($et, $meta, '');
+            } elsif ($buff =~ /^\xff\xd8\xff/) { # embedded JPEG image?
+                $et->HandleTag($tagTablePtr, 'EmbeddedImage', $buff);
+            }
+        }
+        # skip padding if necessary
+        my $pad = 16 - ($size % 16);
+        $raf->Seek($pad, 1) if $pad != 16;
+    }
+    return 1;
+}
+
+1;  # end
+
+__END__
+
+=head1 NAME
+
+Image::ExifTool::Lytro - Read Lytro LFP files
+
+=head1 SYNOPSIS
+
+This module is used by Image::ExifTool
+
+=head1 DESCRIPTION
+
+This module contains routines required by Image::ExifTool to read metadata
+from Lytro Light Field Picture (LFP) files.
+
+=head1 AUTHOR
+
+Copyright 2003-2014, 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://optics.miloush.net/lytro/TheFileFormat.aspx>
+
+=back
+
+=head1 SEE ALSO
+
+L<Image::ExifTool::TagNames/Lytro Tags>,
+L<Image::ExifTool(3pm)|Image::ExifTool>
+
+=cut
+