exiftool_vendored 13.04.0 → 13.08.0

data/bin/lib/Image/ExifTool.pm

@@ -29,7 +29,7 @@ use vars qw($VERSION $RELEASE @ISA @EXPORT_OK %EXPORT_TAGS $AUTOLOAD @fileTypes
             %jpegMarker %specialTags %fileTypeLookup $testLen $exeDir
             %static_vars $advFmtSelf);
 
-$VERSION = '13.04';
+$VERSION = '13.08';
 $RELEASE = '';
 @ISA = qw(Exporter);
 %EXPORT_TAGS = (
@@ -1142,6 +1142,7 @@ my @availableOptions = (
     [ 'ListJoin',         ', ',   'join lists together with this separator' ],
     [ 'ListSep',          ', ',   '[deprecated, use ListSplit and ListJoin instead]', 1 ],
     [ 'ListSplit',        undef,  'regex for splitting list-type tag values when writing' ],
+    #  LigoGPSScale - undocumented scale for unfuzzing LIGO GPS: 1,2,3 for standard scales (1 default), or scale value
     [ 'MakerNotes',       undef,  'extract maker notes as a block' ],
     [ 'MDItemTags',       undef,  'extract MacOS metadata item tags' ],
     [ 'MissingTagValue',  undef,  'value for missing tags when expanded in expressions' ],
@@ -1173,7 +1174,7 @@ my @availableOptions = (
     [ 'UserParam',        { },    'user parameters for additional user-defined tag values' ],
     [ 'Validate',         undef,  'perform additional validation' ],
     [ 'Verbose',          0,      'print verbose messages (0-5, higher # = more verbose)' ],
-    [ 'WindowsLongPath',  undef,  'enable support for long pathnames (enables WindowsWideFile)' ],
+    [ 'WindowsLongPath',  1,      'enable support for long pathnames (enables WindowsWideFile)' ],
     [ 'WindowsWideFile',  undef,  'force the use of Windows wide-character file routines' ], # (see forum15208)
     [ 'WriteMode',        'wcg',  'enable all write modes by default' ],
     [ 'XAttrTags',        undef,  'extract MacOS extended attribute tags' ],
@@ -1265,7 +1266,9 @@ my %systemTagsNotes = (
             Use the -a or L<Duplicates|../ExifTool.html#Duplicates> option to see all warnings if more than one
             occurred. Minor warnings may be ignored with the -m or L<IgnoreMinorErrors|../ExifTool.html#IgnoreMinorErrors>
             option.  Minor warnings with a capital "M" in the "[Minor]" designation
-            indicate that the processing is affected by ignoring the warning
+            indicate that the processing is affected by ignoring the warning.  Multiple
+            identical warnings are indicated by a count after the warning message, eg.
+            "[x2]" if the same warning occurred twice
         },
     },
     Comment => {
@@ -2661,7 +2664,7 @@ sub ExtractInfo($;@)
     my $fast = $$options{FastScan} || 0;
     my $req = $$self{REQ_TAG_LOOKUP};
     my $reqAll = $$options{RequestAll} || 0;
-    my (%saveOptions, $reEntry, $rsize, $zid, $type, @startTime, $saveOrder, $isDir);
+    my (%saveOptions, $reEntry, $rsize, $zid, $type, @startTime, $saveOrder, $isDir, $i);
 
     # check for internal ReEntry option to allow recursive calls to ExtractInfo
     if (ref $_[1] eq 'HASH' and $_[1]{ReEntry} and
@@ -2718,7 +2721,7 @@ sub ExtractInfo($;@)
         if ($$req{processingtime} or $reqAll) {
             eval { require Time::HiRes; @startTime = Time::HiRes::gettimeofday() };
             if (not @startTime and $$req{processingtime}) {
-                $self->WarnOnce('Install Time::HiRes to generate ProcessingTime');
+                $self->Warn('Install Time::HiRes to generate ProcessingTime');
             }
         }
 
@@ -2729,12 +2732,12 @@ sub ExtractInfo($;@)
                 if (require Digest::SHA) {
                     $$self{ImageDataHash} = Digest::SHA->new($1);
                 } else {
-                    $self->WarnOnce("Install Digest::SHA to calculate image data SHA$1");
+                    $self->Warn("Install Digest::SHA to calculate image data SHA$1");
                 }
             } elsif (require Digest::MD5) {
                 $$self{ImageDataHash} = Digest::MD5->new;
             } else {
-                $self->WarnOnce('Install Digest::MD5 to calculate image data MD5');
+                $self->Warn('Install Digest::MD5 to calculate image data MD5');
             }
         }
         ++$$self{FILE_SEQUENCE};        # count files read
@@ -2763,12 +2766,18 @@ sub ExtractInfo($;@)
                 if ($$req{filepath} or
                    ($reqAll and not $$self{EXCL_TAG_LOOKUP}{filepath}))
                 {
+                    my $path;
                     local $SIG{'__WARN__'} = \&SetWarning;
-                    if (eval { require Cwd }) {
-                        my $path = eval { Cwd::abs_path($filename) };
-                        $self->FoundTag('FilePath', $path) if defined $path;
+                    if ($^O eq 'MSWin32' and $$options{WindowsLongPath}) {
+                        $path = $self->WindowsLongPath($filename);
+                    } elsif (eval { require Cwd }) {
+                        $path = eval { Cwd::abs_path($filename) };
+                    }
+                    if (defined $path) {
+                        $path =~ tr/\\/\// if $^O eq 'MSWin32'; # return forward slashes
+                        $self->FoundTag('FilePath', $path);
                     } elsif ($$req{filepath}) {
-                        $self->WarnOnce('The Perl Cwd module must be installed to use FilePath');
+                        $self->Warn('The Perl Cwd module must be installed to use FilePath');
                     }
                 }
                 # get size of resource fork on Mac OS
@@ -3107,6 +3116,15 @@ sub ExtractInfo($;@)
     # and as such it can't be used in user-defined Composite tags
     @startTime and $self->FoundTag('ProcessingTime', Time::HiRes::tv_interval(\@startTime));
 
+    # add numbers to warnings with multiple occurrences
+    if (%{$$self{WAS_WARNED}}) {
+        my ($tag, $val) = ( 'Warning', $$self{VALUE} );
+        for ($i=1; $$val{$tag}; ++$i) {
+            my $n = $$self{WAS_WARNED}{$$val{$tag}};
+            $$val{$tag} .= " [x$n]" if $n and $n > 1;
+            $tag = "Warning ($i)";
+        }
+    }
     # restore original options
     %saveOptions and $$self{OPTIONS} = \%saveOptions;
 
@@ -4246,7 +4264,7 @@ sub Init($)
     $$self{PROCESSED}  = { };       # hash of processed directory start positions
     $$self{DIR_COUNT}  = { };       # count various types of directories
     $$self{DUPL_TAG}   = { };       # last-used index for duplicate-tag keys
-    $$self{WARNED_ONCE}= { };       # WarnOnce() warnings already issued
+    $$self{WAS_WARNED} = { };       # number of times each warning was issued
     $$self{WRITTEN}    = { };       # list of tags written (selected tags only)
     $$self{FORCE_WRITE}= { };       # ForceWrite lookup (set from ForceWrite tag)
     $$self{FOUND_DIR}  = { };       # hash of directory names found in file
@@ -4620,21 +4638,21 @@ sub SplitFileName($)
 sub EncodeFileName($$;$)
 {
     my ($self, $file, $force) = @_;
+    return 0 if $file eq '-';   # special case for stdin pipe
     my $enc = $$self{OPTIONS}{CharsetFileName};
     my $hasSpecialChars;
     if ($file =~ /[\x80-\xff]/) {
         $hasSpecialChars = 1;
         if (not $enc and $^O eq 'MSWin32') {
             if (IsUTF8(\$file) < 0) {
-                $self->WarnOnce('FileName encoding must be specified') if not defined $enc;
+                $self->Warn('FileName encoding must be specified') if not defined $enc;
                 return 0;
             } else {
                 $enc = 'UTF8';  # assume UTF8
             }
         }
     }
-    $force = 1 if $$self{OPTIONS}{WindowsWideFile} or $$self{OPTIONS}{WindowsLongPath};
-    if ($hasSpecialChars or $force) {
+    if ($hasSpecialChars or $force or $$self{OPTIONS}{WindowsLongPath} or $$self{OPTIONS}{WindowsWideFile}) {
         $enc or $enc = 'UTF8';
         if ($^O eq 'MSWin32') {
             local $SIG{'__WARN__'} = \&SetWarning;
@@ -4644,7 +4662,7 @@ sub EncodeFileName($$;$)
                 $_[1] = $self->Decode($file, $enc, undef, 'UTF16', 'II') . "\0\0";
                 return 1;
             }
-            $self->WarnOnce('Install Win32API::File for Windows wide/long file name support');
+            $self->Warn('Install Win32API::File for Windows wide/long file name support');
         } elsif ($enc ne 'UTF8') {
             # recode as UTF-8 for other platforms if necessary
             $_[1] = $self->Decode($file, $enc, undef, 'UTF8');
@@ -4655,8 +4673,8 @@ sub EncodeFileName($$;$)
 
 #------------------------------------------------------------------------------
 # Rebuild a path as an absolute long path to be usable in Windows system calls
-# Inputs: 0) ExifTool ref, 1) path string
-# Returns: normalized long path
+# Inputs: 0) ExifTool ref, 1) path string (CharsetFileName)
+# Returns: normalized long path (CharsetFileName)
 # Note: this should only be called for Windows systems
 # References:
 # - https://learn.microsoft.com/en-us/dotnet/standard/io/file-path-formats
@@ -4675,17 +4693,30 @@ sub WindowsLongPath($$)
     my ($self, $path) = @_;
     my $debug = $$self{OPTIONS}{Debug};
     my $out = $$self{OPTIONS}{TextOut};
+    my $suffix = '';
+    my $longPath;
 
-    $debug and print $out "WindowsLongPath input : $path\n";
+    # remove common suffixes to make cache more effective
+    if ($path =~ s/(_original|_exiftool_tmp|:Zone\.Identifier)$//) {
+        $suffix = $1;
+        if (not length $path or $path =~ m([:./\\]$)) {
+            # don't remove suffix if it could be the whole file name
+            $path .= $suffix;
+            $suffix = '';
+        }
+    }
+    return $$self{LONG_PATH_OUT}.$suffix if defined $$self{LONG_PATH_IN} and $$self{LONG_PATH_IN} eq $path;
+
+    $debug and print $out "WindowsLongPath input : $path$suffix\n";
 
     for (;;) { # (cheap goto)
-        $path =~ tr(/)(\\); # convert slashes to backslashes    
-        last if $path =~ /^\\\\\?\\/;   # already a device path in the format we want
-    
+        ($longPath = $path) =~ tr(/)(\\); # convert slashes to backslashes
+        last if $longPath =~ /^\\\\\?\\/;   # already a device path in the format we want
+
         unless ($k32GetFullPathName) {  # need to import (once) GetFullPathNameW
             last if defined $k32GetFullPathName;
             unless (eval { require Win32::API }) {
-                $self->WarnOnce('Install Win32::API to use WindowsLongPath option');
+                $self->Warn('Install Win32::API to use WindowsLongPath option');
                 last;
             }
             $k32GetFullPathName = Win32::API->new('KERNEL32', 'GetFullPathNameW', 'PNPP', 'I');
@@ -4695,24 +4726,28 @@ sub WindowsLongPath($$)
                 last;
             }
         }
-        my $enc = $$self{OPTIONS}{CharsetFileName};
-        my $encPath = $self->Encode($path, 'UTF16', 'II', $enc);    # need to encode to UTF16
+        my $enc = $$self{OPTIONS}{CharsetFileName} || 'UTF8';
+        my $encPath = $self->Decode($longPath, $enc, undef, 'UTF16', 'II');# need to encode to UTF16
         my $lenReq = $k32GetFullPathName->Call($encPath,0,0,0) + 1; # first pass gets length required, +1 for safety (null?)
         my $fullPath = "\0" x $lenReq x 2;                          # create buffer to hold full path
         $k32GetFullPathName->Call($encPath, $lenReq, $fullPath, 0); # fullPath is UTF16 now
-        $path = $self->Decode($fullPath, 'UTF16', 'II', $enc);
-    
-        last if length($path) <= 247;
+        $longPath = $self->Decode($fullPath, 'UTF16', 'II', $enc);
 
-        if ($path =~ /^\\\\/) {
-            $path = '\\\\?\\UNC' . substr($path, 1);
+        last if length($longPath) <= 247 - length($suffix);
+
+        if ($longPath =~ /^\\\\/) {
+            $longPath = '\\\\?\\UNC' . substr($longPath, 1);
         } else {
-            $path = '\\\\?\\' . $path;
+            $longPath = '\\\\?\\' . $longPath;
         }
         last;
     }
-    $debug and print $out "WindowsLongPath return: $path\n";
-    return $path;
+    # this may be called repeatedly for the same file file (exists, stat, open),
+    # so cache the last return value (without any of the suffixes that we use)
+    $$self{LONG_PATH_IN} = $path;
+    $$self{LONG_PATH_OUT} = $longPath;
+    $debug and print $out "WindowsLongPath return: $longPath$suffix\n";
+    return $longPath . $suffix;
 }
 
 #------------------------------------------------------------------------------
@@ -4894,9 +4929,9 @@ sub GetFileTime($$)
     # on Windows, try to work around incorrect file times when daylight saving time is in effect
     if ($^O eq 'MSWin32') {
         if (not eval { require Win32::API }) {
-            $self->WarnOnce('Install Win32::API for proper handling of Windows file times', 1);
+            $self->Warn('Install Win32::API for proper handling of Windows file times', 1);
         } elsif (not eval { require Win32API::File }) {
-            $self->WarnOnce('Install Win32API::File for proper handling of Windows file times', 1);
+            $self->Warn('Install Win32API::File for proper handling of Windows file times', 1);
         } else {
             # get Win32 handle, needed for GetFileTime
             my $win32Handle = eval { Win32API::File::GetOsFHandle($file) };
@@ -5472,28 +5507,21 @@ sub AddCleanup($)
 sub Warn($$;$)
 {
     my ($self, $str, $ignorable) = @_;
-    my $noWarn = $self->Options('NoWarning');
+    my $noWarn = $$self{OPTIONS}{NoWarning};
     if ($ignorable) {
         return 0 if $$self{OPTIONS}{IgnoreMinorErrors};
         return 0 if $ignorable eq '3' and $$self{OPTIONS}{Validate};
         return 1 if defined $noWarn and eval { $str =~ /$noWarn/ };
         $str = $ignorable eq '2' ? "[Minor] $str" : "[minor] $str";
     }
-    $self->FoundTag('Warning', $str) unless defined $noWarn and eval { $str =~ /$noWarn/ };
-    return 1;
-}
-
-#------------------------------------------------------------------------------
-# Add warning tag only once per processed file
-# Inputs: 0) ExifTool object reference, 1) warning message, 2) true if minor
-# Returns: true if warning tag was added
-sub WarnOnce($$;$)
-{
-    my ($self, $str, $ignorable) = @_;
-    return 0 if $ignorable and $$self{OPTIONS}{IgnoreMinorErrors};
-    unless ($$self{WARNED_ONCE}{$str}) {
-        $self->Warn($str, $ignorable);
-        $$self{WARNED_ONCE}{$str} = 1;
+    unless (defined $noWarn and eval { $str =~ /$noWarn/ }) {
+        # add each warning only once but count number of occurrences
+        if ($$self{WAS_WARNED}{$str}) {
+            ++$$self{WAS_WARNED}{$str};
+        } else {
+            $self->FoundTag('Warning', $str);
+            $$self{WAS_WARNED}{$str} = 1;
+        }
     }
     return 1;
 }
@@ -6224,7 +6252,7 @@ sub Decode($$$;$$$)
 }
 
 #------------------------------------------------------------------------------
-# Encode string with specified encoding
+# Encode string (in Charset encoding) to specified encoding
 # Inputs: 0) ExifTool object ref, 1) string, 2) destination character set name,
 #         3) optional destination byte order (2-byte and 4-byte fixed-width sets only)
 # Returns: string in specified encoding
@@ -7433,7 +7461,7 @@ sub ProcessJPEG($$;$)
         }
         # handle all other markers
         my $dumpType = '';
-        my ($desc, $tip, $xtra);
+        my ($desc, $tip, $xtra, $useJpegMain);
         $length = length $$segDataPt;
         $appBytes += $length + 4 if ($marker & 0xf0) == 0xe0;  # total size of APP segments
         if ($verbose) {
@@ -7568,13 +7596,13 @@ sub ProcessJPEG($$;$)
                     my ($size, $off) = unpack('x67N2', $$segDataPt);
                     my $guid = substr($$segDataPt, 35, 32);
                     if ($guid =~ /[^A-Za-z0-9]/) { # (technically, should be uppercase)
-                        $self->WarnOnce($tip = 'Invalid extended XMP GUID');
+                        $self->Warn($tip = 'Invalid extended XMP GUID');
                     } else {
                         my $extXMP = $extendedXMP{$guid};
                         if (not $extXMP) {
                             $extXMP = $extendedXMP{$guid} = { };
                         } elsif ($size != $$extXMP{Size}) {
-                            $self->WarnOnce('Inconsistent extended XMP size');
+                            $self->Warn('Inconsistent extended XMP size');
                         }
                         $$extXMP{Size} = $size;
                         $$extXMP{$off} = substr($$segDataPt, 75);
@@ -7583,7 +7611,7 @@ sub ProcessJPEG($$;$)
                         # (delay processing extended XMP until after reading all segments)
                     }
                 } else {
-                    $self->WarnOnce($tip = 'Invalid extended XMP segment');
+                    $self->Warn($tip = 'Invalid extended XMP segment');
                 }
             } elsif ($$segDataPt =~ /^QVCI\0/) {
                 $dumpType = 'QVCI';
@@ -7606,7 +7634,7 @@ sub ProcessJPEG($$;$)
                 }
                 if (defined $flirCount) {
                     if (defined $flirChunk[$chunkNum]) {
-                        $self->WarnOnce('Duplicate FLIR chunk number(s)');
+                        $self->Warn('Duplicate FLIR chunk number(s)');
                         $flirChunk[$chunkNum] .= substr($$segDataPt, 8);
                     } else {
                         $flirChunk[$chunkNum] = substr($$segDataPt, 8);
@@ -7626,7 +7654,7 @@ sub ProcessJPEG($$;$)
                         undef $flirCount;   # prevent reprocessing
                     }
                 } else {
-                    $self->WarnOnce('Invalid or extraneous FLIR chunk(s)');
+                    $self->Warn('Invalid or extraneous FLIR chunk(s)');
                 }
             } elsif ($$segDataPt =~ /^PARROT\0(II\x2a\0|MM\0\x2a)/) {
                 # (don't know if this could span multiple segments)
@@ -7653,7 +7681,7 @@ sub ProcessJPEG($$;$)
                     $self->Warn("Ignored APP1 segment length $length (unknown header)");
                 }
             }
-        } elsif ($marker == 0xe2) {         # APP2 (ICC Profile, FPXR, MPF, InfiRay, PreviewImage)
+        } elsif ($marker == 0xe2) {         # APP2 (ICC Profile, FPXR, MPF, InfiRay, URN, PreviewImage)
             if ($$segDataPt =~ /^ICC_PROFILE\0/ and $length >= 14) {
                 $dumpType = 'ICC_Profile';
                 # must concatenate profile chunks (note: handle the case where
@@ -7671,7 +7699,7 @@ sub ProcessJPEG($$;$)
                 }
                 if (defined $iccChunkCount) {
                     if (defined $iccChunk[$chunkNum]) {
-                        $self->WarnOnce('Duplicate ICC_Profile chunk number(s)');
+                        $self->Warn('Duplicate ICC_Profile chunk number(s)');
                         $iccChunk[$chunkNum] .= substr($$segDataPt, 14);
                     } else {
                         $iccChunk[$chunkNum] = substr($$segDataPt, 14);
@@ -7694,7 +7722,7 @@ sub ProcessJPEG($$;$)
                         undef $iccChunkCount;     # prevent reprocessing
                     }
                 } else {
-                    $self->WarnOnce('Invalid or extraneous ICC_Profile chunk(s)');
+                    $self->Warn('Invalid or extraneous ICC_Profile chunk(s)');
                 }
             } elsif ($$segDataPt =~ /^FPXR\0/) {
                 next if $fast > 1;      # skip processing for very fast
@@ -7726,6 +7754,9 @@ sub ProcessJPEG($$;$)
                 # Digilife DDC-690/Rollei="BGTH"
                 $dumpType = 'Preview Image';
                 $preview = substr($$segDataPt, length($1));
+            } elsif ($$segDataPt =~ /^urn:/) {  # (found in Apple HDR images)
+                $dumpType = 'URN';
+                $useJpegMain = 1;
             } elsif ($preview) {
                 $dumpType = 'Preview Image';
                 $preview .= $$segDataPt;
@@ -7995,17 +8026,14 @@ sub ProcessJPEG($$;$)
                 DirStart(\%dirInfo, 5);
                 $self->ProcessDirectory(\%dirInfo, GetTagTable("Image::ExifTool::XMP::SEAL"));
             }
-        } elsif ($marker == 0xea) {         # APP10 (PhotoStudio Unicode comments)
+        } elsif ($marker == 0xea) {         # APP10 (PhotoStudio Unicode comments, HDR gain curve)
             if ($$segDataPt =~ /^UNICODE\0/) {
                 $dumpType = 'PhotoStudio';
                 my $comment = $self->Decode(substr($$segDataPt,8), 'UCS2', 'MM');
                 $self->FoundTag('Comment', $comment);
-            } elsif ($$segDataPt =~ /^AROT\0/ and $length > 10) {
-                # iPhone "AROT" segment containing integrated intensity per 16 scan lines
-                # (with number of elements N = ImageHeight / 16 - 1, ref PH/NealKrawetz)
-                # "Absolute ROTational difference between two frames"
-                # (see https://www.hackerfactor.com/blog/index.php?/archives/822-Apple-Rot.html)
-                $xtra = 'segment (N=' . unpack('x6N', $$segDataPt) . ')';
+            } elsif ($$segDataPt =~ /^AROT\0\0.{4}/s) {
+                $dumpType = 'AROT', # (HDR gain curve? PH guess)
+                $useJpegMain = 1;
             }
         } elsif ($marker == 0xeb) {         # APP11 (JPEG-HDR, JUMBF)
             if ($$segDataPt =~ /^HDR_RI /) {
@@ -8038,7 +8066,7 @@ sub ProcessJPEG($$;$)
                 my $type = substr($$segDataPt, 12, 4);
                 # a Microsoft bug writes $len and $type incorrectly as little-endian
                 if ($type eq 'bmuj') {
-                    $self->WarnOnce('Wrong byte order in C2PA APP11 JUMBF header');
+                    $self->Warn('Wrong byte order in C2PA APP11 JUMBF header');
                     $type = 'jumb';
                     $len = unpack('x8V', $$segDataPt);
                     # fix the header
@@ -8172,6 +8200,10 @@ sub ProcessJPEG($$;$)
             $desc = "[JPEG $markerName]";   # (other known JPEG segments)
         }
         if (defined $dumpType) {
+            if ($useJpegMain) {
+                my $tagTablePtr = GetTagTable('Image::ExifTool::JPEG::Main');
+                $self->HandleTag($tagTablePtr, $markerName, $$segDataPt);
+            }
             if (not $dumpType and ($$options{Unknown} or $$options{Validate})) {
                 my $str = ($$segDataPt =~ /^([\x20-\x7e]{1,20})\0/) ? " '${1}'" : '';
                 $xtra = 'segment' unless $xtra;
@@ -8711,23 +8743,18 @@ sub GetTagTable($)
             # try to load module for this table
             if ($tableName =~ /(.*)::/) {
                 my $module = $1;
-                if (eval "require $module") {
+                if (not eval "require $module") {
+                    $@ and warn $@;
+                } elsif (not %$tableName) {
                     # load additional modules if required
-                    if (not %$tableName) {
-                        if ($module eq 'Image::ExifTool::XMP') {
-                            require 'Image/ExifTool/XMP2.pl';
-                        } elsif ($tableName eq 'Image::ExifTool::QuickTime::Stream') {
-                            require 'Image/ExifTool/QuickTimeStream.pl';
-                        }
+                    if ($module eq 'Image::ExifTool::XMP') {
+                        require 'Image/ExifTool/XMP2.pl';
+                    } elsif ($tableName eq 'Image::ExifTool::QuickTime::Stream') {
+                        require 'Image/ExifTool/QuickTimeStream.pl';
                     }
-                } else {
-                    $@ and warn $@;
                 }
             }
-            unless (%$tableName) {
-                warn "Can't find table $tableName\n";
-                return undef;
-            }
+            %$tableName or warn("Can't find table $tableName\n"), return undef;
         }
         no strict 'refs';
         $table = \%$tableName;

data/bin/lib/Image/ExifTool.pod

@@ -1197,14 +1197,15 @@ on tag values and JPEG segment data respectively.
 =item WindowsLongPath
 
 Support long path names in Windows.  Enabling this option automatically
-enables the WindowsWideFile feature.
+enables the WindowsWideFile feature.  Default is 1.
 
 =item WindowsWideFile
 
 Force the use of wide-character Windows I/O functions.  This may be
 necessary when files are on a network drive and the current directory name
-contains Unicode characters. By default, the wide-character functions are
-used only if the specified file path contains Unicode characters.
+contains Unicode characters.  Without this option the wide-character
+functions are used only if the specified file path contains Unicode
+characters.
 
 =item WriteMode
 
@@ -2545,9 +2546,9 @@ GoPro, H264, HTML, ICC_Profile, ID3, IPTC, ISO, ITC, JFIF, JPEG, JSON,
 JUMBF, Jpeg2000, LNK, Leaf, Lytro, M2TS, MIE, MIFF, MISB, MNG, MOI, MPC,
 MPEG, MPF, MXF, MakerNotes, Matroska, Meta, Ogg, OpenEXR, Opus, PDF, PICT,
 PLIST, PNG, PSP, Palm, PanasonicRaw, Parrot, PhotoCD, PhotoMechanic,
-Photoshop, PostScript, PrintIM, QuickTime, RAF, RIFF, RSRC, RTF, Radiance,
-Rawzor, Real, Red, SVG, SigmaRaw, Sony, Stim, Theora, Torrent, Trailer,
-VCard, Vorbis, WTV, XML, XMP, ZIP
+Photoshop, PostScript, PrintIM, Protobuf, QuickTime, RAF, RIFF, RSRC, RTF,
+Radiance, Rawzor, Real, Red, SVG, SigmaRaw, Sony, Stim, Theora, Torrent,
+Trailer, VCard, Vorbis, WTV, XML, XMP, ZIP
 
 =item Family 1 (Specific Location):
 
@@ -2562,7 +2563,7 @@ ICC-chrm, ICC-clrt, ICC-header, ICC-meas, ICC-meta, ICC-view, ICC_Profile,
 ICC_Profile#, ID3, ID3v1, ID3v1_Enh, ID3v2_2, ID3v2_3, ID3v2_4, IFD0, IFD1,
 IPTC, IPTC#, ISO, ITC, InfiRay, Insta360, InteropIFD, ItemList, JFIF, JFXX,
 JPEG, JPEG-HDR, JPS, JSON, JUMBF, JVC, Jpeg2000, KDC_IFD, Keys, Kodak,
-KodakBordersIFD, KodakEffectsIFD, KodakIFD, KyoceraRaw, LNK, Leaf,
+KodakBordersIFD, KodakEffectsIFD, KodakIFD, KyoceraRaw, LIGO, LNK, Leaf,
 LeafSubIFD, Leica, Lyrics3, Lytro, M-RAW, M2TS, MAC, MIE-Audio, MIE-Camera,
 MIE-Canon, MIE-Doc, MIE-Extender, MIE-Flash, MIE-GPS, MIE-Geo, MIE-Image,
 MIE-Lens, MIE-Main, MIE-MakerNotes, MIE-Meta, MIE-Orient, MIE-Preview,

data/bin/perl-Image-ExifTool.spec

@@ -1,6 +1,6 @@
 Summary: perl module for image data extraction
 Name: perl-Image-ExifTool
-Version: 13.04
+Version: 13.08
 Release: 1
 License: Artistic/GPL
 Group: Development/Libraries/Perl

data/lib/exiftool_vendored/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ExiftoolVendored
-  VERSION = Gem::Version.new('13.04.0')
+  VERSION = Gem::Version.new('13.08.0')
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: exiftool_vendored
 version: !ruby/object:Gem::Version
-  version: 13.04.0
+  version: 13.08.0
 platform: ruby
 authors:
 - Matthew McEachen
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-11-27 00:00:00.000000000 Z
+date: 2024-12-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: exiftool
@@ -257,6 +257,7 @@ files:
 - bin/lib/Image/ExifTool/Photoshop.pm
 - bin/lib/Image/ExifTool/PostScript.pm
 - bin/lib/Image/ExifTool/PrintIM.pm
+- bin/lib/Image/ExifTool/Protobuf.pm
 - bin/lib/Image/ExifTool/Qualcomm.pm
 - bin/lib/Image/ExifTool/QuickTime.pm
 - bin/lib/Image/ExifTool/QuickTimeStream.pl