exiftool_vendored 13.04.0 → 13.08.0

data/bin/lib/Image/ExifTool/Geolocation.pm

@@ -18,7 +18,8 @@
 #               specifying $Image::ExifTool::Geolocation::altDir.  This
 #               database and has entries in the same order as Geolocation.dat,
 #               and each entry is a newline-separated list of alternate names
-#               terminated by a null byte.
+#               terminated by a null byte.  These alternate names are used
+#               only when searching for a city by name (eg. "Big Apple").
 #
 #               Databases are based on data from geonames.org with a
 #               Creative Commons license, reformatted as follows in the

data/bin/lib/Image/ExifTool/GoPro.pm

@@ -16,7 +16,7 @@ use vars qw($VERSION);
 use Image::ExifTool qw(:DataAccess :Utils);
 use Image::ExifTool::QuickTime;
 
-$VERSION = '1.10';
+$VERSION = '1.11';
 
 sub ProcessGoPro($$$);
 sub ProcessString($$$);
@@ -423,7 +423,7 @@ my %addUnits = (
         },
     },
   # VLTA (GPMF) - seen: 78 ('N') (fmt B -- wrong format?)
-  # VFPS (GPMF) - seen: '24000 1001' (fmt L)
+    VFPS => { Name => 'VideoFrameRate', PrintConv => '$val=~s( )(/);$val' }, #PH (GPMF, fmt L)
     VFRH => { #PH (Karma)
         Name => 'VisualFlightRulesHUD',
         BinaryData => 1,
@@ -431,7 +431,7 @@ my %addUnits = (
         # TYPE=ffffsS
     },
   # VLTE (GPMF) - seen: 'Y','N' (fmt c)
-  # VRES (GPMF) - seen: '3840 3660' (fmt L)
+    VRES => { Name => 'VideoFrameSize', PrintConv => '$val=~s/ /x/;$val' }, #PH (GPMF, fmt L)
     WBAL => 'ColorTemperatures', #PH (gpmd)
     WRGB => { #PH (gpmd)
         Name => 'WhiteBalanceRGB',

data/bin/lib/Image/ExifTool/HP.pm

@@ -225,7 +225,7 @@ sub ProcessHP($$$)
     # scan for other tag ID's
     foreach $tagID (sort(TagTableKeys($tagTablePtr))) {
         next if $tagID eq 'PreviewImage';
-        next unless $$dataPt =~ /$tagID:\s*([\x20-\x7f]+)/i;
+        next unless $$dataPt =~ /$tagID:\s*([\x20-\x7e]+)/i;
         $et->HandleTag($tagTablePtr, $tagID, $1);
     }
     return 1;

data/bin/lib/Image/ExifTool/ID3.pm

@@ -1169,7 +1169,7 @@ sub ProcessID3v2($$$)
             }
             $tagInfo = $et->GetTagInfo($otherTable, $id) if $otherTable;
             if ($tagInfo) {
-                $et->WarnOnce("Frame '${id}' is not valid for this ID3 version", 1);
+                $et->Warn("Frame '${id}' is not valid for this ID3 version", 1);
             } else {
                 next unless $verbose or $et->Options('Unknown');
                 $id =~ tr/-A-Za-z0-9_//dc;
@@ -1198,7 +1198,7 @@ sub ProcessID3v2($$$)
             }
         }
         if ($flags{Encrypt}) {
-            $et->WarnOnce('Encrypted frames currently not supported');
+            $et->Warn('Encrypted frames currently not supported');
             next;
         }
         # extract the value
@@ -1232,7 +1232,7 @@ sub ProcessID3v2($$$)
                     next;
                 }
             } else {
-                $et->WarnOnce('Install Compress::Zlib to decode compressed frames');
+                $et->Warn('Install Compress::Zlib to decode compressed frames');
                 next;
             }
         }

data/bin/lib/Image/ExifTool/IPTC.pm

@@ -1025,7 +1025,7 @@ sub TranslateCodedString($$$$)
         $$valPtr = $et->Decode($$valPtr, $$xlatPtr);
     } else {
         # don't yet support reading ISO 2022 shifted character sets
-        $et->WarnOnce('Some IPTC characters not converted (ISO 2022 shifting not supported)');
+        $et->Warn('Some IPTC characters not converted (ISO 2022 shifting not supported)');
     }
 }
 
@@ -1164,7 +1164,7 @@ sub ProcessIPTC($$$)
             }
             my $tableInfo = $tagTablePtr->{$rec};
             unless ($tableInfo) {
-                $et->WarnOnce("Unrecognized IPTC record $rec (ignored)");
+                $et->Warn("Unrecognized IPTC record $rec (ignored)");
                 $pos += $len;
                 next;   # ignore this entry
             }

data/bin/lib/Image/ExifTool/InDesign.pm

@@ -78,7 +78,7 @@ sub ProcessIND($$)
             $err = 'InDesign files larger than 2 GB not supported (LargeFileSupport not set)';
             goto DONE;
         } elsif ($et->Options('LargeFileSupport') eq '2') {
-            $et->WarnOnce('Processing large file (LargeFileSupport is 2)');
+            $et->Warn('Processing large file (LargeFileSupport is 2)');
         }
     }
     if ($outfile) {

data/bin/lib/Image/ExifTool/JPEG.pm

@@ -11,7 +11,7 @@ use strict;
 use vars qw($VERSION);
 use Image::ExifTool qw(:DataAccess :Utils);
 
-$VERSION = '1.37';
+$VERSION = '1.38';
 
 sub ProcessOcad($$$);
 sub ProcessJPEG_HDR($$$);
@@ -87,6 +87,11 @@ sub ProcessJPEG_HDR($$$);
         Name => 'InfiRayVersion',
         Condition => '$$valPt =~ /^....IJPEG\0/s',
         SubDirectory => { TagTable => 'Image::ExifTool::InfiRay::Version' },
+      }, {
+        Name => 'UniformResourceName',
+        Groups => { 1 => 'APP2' },
+        Condition => '$$valPt =~ /^urn:/',
+        Notes => 'used in Apple HDR images',
       }, {
         Name => 'PreviewImage',
         Condition => '$$valPt =~ /^(|QVGA\0|BGTH)\xff\xd8\xff\xdb/',
@@ -246,16 +251,26 @@ sub ProcessJPEG_HDR($$$);
         Condition => '$$valPt =~ /^SEAL\0/',
         SubDirectory => { TagTable => 'Image::ExifTool::XMP::SEAL' },
     }],
-    APP10 => {
+    APP10 => [{
         Name => 'Comment',
         Condition => '$$valPt =~ /^UNICODE\0/',
         Notes => 'PhotoStudio Unicode comment',
-    },
+      }, {
+        Name => 'HDRGainCurve', #PH (NC)
+        Condition => '$$valPt =~ /^AROT\0\0.{4}/s',
+        Groups => { 1 => 'APP10', 2 => 'Image' },
+        ValueConv => q{
+            my $n = unpack('x6N', $val);
+            return '<truncated AROT data>' if length($val)-6 < $n * 4;
+            my $str = join ' ', unpack("x10V$n", $val);
+            return \$str;
+        },
+    }],
     APP11 => [{
         Name => 'JPEG-HDR',
         Condition => '$$valPt =~ /^HDR_RI /',
         SubDirectory => { TagTable => 'Image::ExifTool::JPEG::HDR' },
-    },{
+      }, {
         Name => 'JUMBF',
         Condition => '$$valPt =~ /^JP/',
         SubDirectory => { TagTable => 'Image::ExifTool::Jpeg2000::Main' },

data/bin/lib/Image/ExifTool/Jpeg2000.pm

@@ -866,8 +866,8 @@ sub BrotliWarn($$;$)
 {
     my ($et, $type, $uncompress) = @_;
     my ($enc, $mod) = $uncompress ? qw(decoding Uncompress) : qw(encoding Compress);
-    $et->WarnOnce("Error $enc '${type}' brob box");
-    $et->WarnOnce("Try updating to IO::${mod}::Brotli 0.004 or later");
+    $et->Warn("Error $enc '${type}' brob box");
+    $et->Warn("Try updating to IO::${mod}::Brotli 0.004 or later");
 }
 
 #------------------------------------------------------------------------------
@@ -933,7 +933,7 @@ sub CreateNewBoxes($$)
                             $tag = 'brob';
                         }
                     } else {
-                        $et->WarnOnce('Install IO::Compress::Brotli to create Brotli-compressed metadata');
+                        $et->Warn('Install IO::Compress::Brotli to create Brotli-compressed metadata');
                     }
                 }
                 my $boxhdr = pack('N', length($newdir) + length($pad) + 8) . $tag;
@@ -1285,7 +1285,7 @@ sub ProcessJpeg2000Box($$$)
                                     ++$$et{CHANGED};
                                 }
                             } else {
-                                $et->WarnOnce('Install IO::Compress::Brotli to write Brotli-compressed metadata');
+                                $et->Warn('Install IO::Compress::Brotli to write Brotli-compressed metadata');
                             }
                         } elsif (not $compress and $boxID eq 'brob') {
                             # (in this case, ProcessBrotli has returned uncompressed data,
@@ -1410,7 +1410,7 @@ sub ProcessBrotli($$$)
     }
     if (eval { require IO::Uncompress::Brotli }) {
         if ($isWriting and not eval { require IO::Compress::Brotli }) {
-            $et->WarnOnce('Install IO::Compress::Brotli to write Brotli-compressed metadata');
+            $et->Warn('Install IO::Compress::Brotli to write Brotli-compressed metadata');
             return undef;
         }
         my $compress = $et->Options('Compress');
@@ -1455,7 +1455,7 @@ sub ProcessBrotli($$$)
             return $type . $dat;
         }
     } else {
-        $et->WarnOnce('Install IO::Uncompress::Brotli to decode Brotli-compressed metadata');
+        $et->Warn('Install IO::Uncompress::Brotli to decode Brotli-compressed metadata');
         return undef if $isWriting;
     }
     return 1;

data/bin/lib/Image/ExifTool/M2TS.pm

@@ -32,7 +32,7 @@ use strict;
 use vars qw($VERSION);
 use Image::ExifTool qw(:DataAccess :Utils);
 
-$VERSION = '1.26';
+$VERSION = '1.28';
 
 # program map table "stream_type" lookup (ref 6/1/9)
 my %streamType = (
@@ -305,6 +305,15 @@ sub ParsePID($$$$$)
         # MPEG-1/MPEG-2 Audio
         require Image::ExifTool::MPEG;
         Image::ExifTool::MPEG::ParseMPEGAudio($et, $dataPt);
+    } elsif ($type == 6 and $pid == 0x0300) {
+        # LIGOGPSINFO from unknown dashcam (../testpics/gps_video/Wrong Way pass.ts)
+        if ($$dataPt =~ /^LIGOGPSINFO/s) {
+            my $tbl = GetTagTable('Image::ExifTool::QuickTime::Stream');
+            my %dirInfo = ( DataPt => $dataPt, DirName => 'Ligo0x0300' );
+            Image::ExifTool::QuickTime::ProcessLigoGPS($et, \%dirInfo, $tbl, 1);
+            $$et{FoundGoodGPS} = 1;
+            $more = 1;
+        }
     } elsif ($type == 0x1b) {
         # H.264 Video
         require Image::ExifTool::H264;
@@ -313,7 +322,7 @@ sub ParsePID($$$$$)
         if ($$et{OPTIONS}{ExtractEmbedded}) {
             $more = 1;
         } elsif (not $$et{OPTIONS}{Validate}) {
-            $et->WarnOnce('The ExtractEmbedded option may find more tags in the video data',3);
+            $et->Warn('The ExtractEmbedded option may find more tags in the video data',3);
         }
     } elsif ($type == 0x81 or $type == 0x87 or $type == 0x91) {
         # AC-3 audio
@@ -459,11 +468,11 @@ sub ParsePID($$$$$)
                     $bad = 1 if $_ < 0x30 or $_ > 0x39;
                 }
                 if ($bad) {
-                    $et->WarnOnce('Error decrypting GPS degrees');
+                    $et->Warn('Error decrypting GPS degrees');
                 } else {
                     my $la = pack('C*', @chars[0,1]);
                     my $lo = pack('C*', @chars[2,3,4]);
-                    $et->WarnOnce('Decryption of this GPS is highly experimental. More testing samples are required');
+                    $et->Warn('Decryption of this GPS is highly experimental. More testing samples are required');
                     $et->HandleTag($tagTbl, GPSLatitude  => (($la || 0) + (($6-85.95194)/2.43051724137931+42.2568)/60) * ($7 eq 'N' ? 1 : -1));
                     $et->HandleTag($tagTbl, GPSLongitude => (($lo || 0) + (($9-70.14674)/1.460987654320988+9.2028)/60) * ($10 eq 'E' ? 1 : -1));
                 }
@@ -476,7 +485,7 @@ sub ParsePID($$$$$)
             my $lon = abs(GetFloat($dataPt, 56)); # (abs just to be safe)
             my $spd = GetFloat($dataPt, 64);
             my $trk = GetFloat($dataPt, 68);
-            $et->WarnOnce('GPSLatitude/Longitude encryption is not yet known, so these will be wrong');
+            $et->Warn('GPSLatitude/Longitude encryption is not yet known, so these will be wrong');
             $$et{DOC_NUM} = ++$$et{DOC_COUNT};
             my @date = unpack('x32V3x28V3', $$dataPt);
             $date[3] += 2000;
@@ -514,9 +523,16 @@ sub ParsePID($$$$$)
                 $et->HandleTag($tagTbl, GPSTrack     => $a[2] / 100);
             }
             # Note: 10 bytes after last GPS record look like a single 3-axis accelerometer reading:
-            # eg. fd ff 00 00 ff ff 00 00 01 00 
+            # eg. fd ff 00 00 ff ff 00 00 01 00
             $$et{FoundGoodGPS} = 1; # so we skip over unrecognized packets
             $more = 1;
+        } elsif ($$dataPt =~ /^skip.{4}LIGOGPSINFO\0/s) {
+            # (this record contains 2 copies of the same 'skip' atom in my sample --
+            #  only extract data from the first one)
+            my $tbl = GetTagTable('Image::ExifTool::QuickTime::Stream');
+            my %dirInfo = ( DataPt => $dataPt, DirStart => 8, DirName => sprintf('Ligo0x%.4x',$pid));
+            Image::ExifTool::QuickTime::ProcessLigoGPS($et, \%dirInfo, $tbl, 1);
+            $$et{FoundGoodGPS} = 1;
         } elsif ($$et{FoundGoodGPS}) {
             $more = 1;
         }
@@ -694,7 +710,7 @@ sub ProcessM2TS($$)
         # or if we are just looking for the last timestamp
         next unless $payload_data_exists and not defined $backScan;
 
-        # decode payload data
+       # decode payload data
         if ($pid == 0 or            # program association table
             defined $pmt{$pid})     # program map table(s)
         {
@@ -787,7 +803,7 @@ sub ProcessM2TS($$)
                     last if $j + $descriptor_length > $program_info_length;
                     my $desc = substr($buf2, $pos+$j, $descriptor_length);
                     $j += $descriptor_length;
-                    $desc =~ s/([\x00-\x1f\x80-\xff])/sprintf("\\x%.2x",ord $1)/eg;
+                    $desc =~ s/([\x00-\x1f\x7f-\xff])/sprintf("\\x%.2x",ord $1)/eg;
                     printf $out "    Program Descriptor: Type=0x%.2x \"$desc\"\n", $descriptor_tag;
                 }}
                 $pos += $program_info_length; # skip descriptors (for now)
@@ -822,7 +838,7 @@ sub ProcessM2TS($$)
                         $j += $descriptor_length;
                         if ($verbose > 1) {
                             my $dstr = $desc;
-                            $dstr =~ s/([\x00-\x1f\x80-\xff])/sprintf("\\x%.2x",ord $1)/eg;
+                            $dstr =~ s/([\x00-\x1f\x7f-\xff])/sprintf("\\x%.2x",ord $1)/eg;
                             printf $out "    ES Descriptor: Type=0x%.2x \"$dstr\"\n", $descriptor_tag;
                         }
                         # parse type-specific descriptor information (once)
@@ -954,6 +970,20 @@ sub ProcessM2TS($$)
         ParsePID($et, $pid, $pidType{$pid}, $pidName{$pid}, \$data{$pid});
         delete $data{$pid};
     }
+
+    # look for LIGOGPSINFO trailer
+    if ($et->Options('ExtractEmbedded') and
+        $raf->Seek(-8, 2) and $raf->Read($buff, 8) == 8 and
+        $buff =~ /^&&&&/)
+    {
+        my $len = unpack('x4N', $buff);
+        if ($len < $raf->Tell() and $raf->Seek(-$len, 2) and $raf->Read($buff,$len) == $len) {
+            my $tbl = GetTagTable('Image::ExifTool::QuickTime::Stream');
+            my %dirInfo = ( DataPt => \$buff, DirStart => 8, DirName => 'LigoTrailer' );
+            Image::ExifTool::QuickTime::ProcessLigoGPS($et, \%dirInfo, $tbl);
+        }
+    }
+
     return 1;
 }
 

data/bin/lib/Image/ExifTool/MXF.pm

@@ -2525,7 +2525,7 @@ sub ReadMXFValue($$$)
     } elsif ($type =~ /(Array|Batch)/ and $len > 16) {
         my ($count, $size) = unpack('NN', $val);
         # validate data length
-        $len == 8 + $count * $size or $et->WarnOnce("Bad array or batch size");
+        $len == 8 + $count * $size or $et->Warn("Bad array or batch size");
         my ($i, @a);
         for ($i=0; $i<$count; ++$i) {
             my $pos = 8 + $i * $size;
@@ -2626,7 +2626,7 @@ sub ProcessLocalSet($$$)
             $extra = sprintf(', Local 0x%.4x', $loc);
         } else {
             $tag = $loc;
-          # $et->WarnOnce('Missing local key for at least one tag');
+          # $et->Warn('Missing local key for at least one tag');
             $extra = ', NOT IN PRIMER!';
         }
         my $tagInfo = $$tagTablePtr{$tag};

data/bin/lib/Image/ExifTool/Matroska.pm

@@ -1097,7 +1097,7 @@ sub ProcessMKV($$)
                 if ($more >= 0x80000000) {
                     last unless $et->Options('LargeFileSupport');
                     if ($et->Options('LargeFileSupport') eq '2') {
-                        $et->WarnOnce('Processing large block (LargeFileSupport is 2)');
+                        $et->Warn('Processing large block (LargeFileSupport is 2)');
                     }
                 }
                 $raf->Seek($more, 1) or last;

data/bin/lib/Image/ExifTool/Microsoft.pm

@@ -907,7 +907,7 @@ sub WriteXtraValue($$$)
                 $type = 72;
             }
         } else {
-            $et->WarnOnce("Error converting value for Microsoft:$$tagInfo{Name}");
+            $et->Warn("Error converting value for Microsoft:$$tagInfo{Name}");
         }
         SetByteOrder('MM');
         if (defined $type) {

data/bin/lib/Image/ExifTool/PDF.pm

@@ -1215,7 +1215,7 @@ sub DecodeStream($$)
     # be sure we can process all the filters before we take the time to do the decryption
     foreach $filter (@filters) {
         next if $supportedFilter{$filter};
-        $et->WarnOnce("Unsupported Filter $filter");
+        $et->Warn("Unsupported Filter $filter");
         return 0;
     }
     # apply decryption first if required (and if the default encryption
@@ -1244,7 +1244,7 @@ sub DecodeStream($$)
             if (ref $decodeParms eq 'HASH') {
                 $pre = $$decodeParms{Predictor};
                 if ($pre and $pre ne '1' and $pre ne '12') {
-                    $et->WarnOnce("FlateDecode Predictor $pre currently not supported");
+                    $et->Warn("FlateDecode Predictor $pre currently not supported");
                     return 0;
                 }
             }
@@ -1259,7 +1259,7 @@ sub DecodeStream($$)
                     return 0;
                 }
             } else {
-                $et->WarnOnce('Install Compress::Zlib to process filtered streams');
+                $et->Warn('Install Compress::Zlib to process filtered streams');
                 return 0;
             }
             next unless $pre and $pre eq '12';  # 12 = 'up' prediction
@@ -1268,7 +1268,7 @@ sub DecodeStream($$)
             my $cols = $$decodeParms{Columns};
             unless ($cols) {
                 # currently only support 'up' prediction
-                $et->WarnOnce('No Columns for decoding stream');
+                $et->Warn('No Columns for decoding stream');
                 return 0;
             }
             my @bytes = unpack('C*', $$dict{_stream});
@@ -1276,7 +1276,7 @@ sub DecodeStream($$)
             my $buff = '';
             while (@bytes > $cols) {
                 unless (($_ = shift @bytes) == 2) {
-                    $et->WarnOnce("Unsupported PNG filter $_"); # (yes, PNG)
+                    $et->Warn("Unsupported PNG filter $_"); # (yes, PNG)
                     return 0;
                 }
                 foreach (@pre) {
@@ -1296,11 +1296,11 @@ sub DecodeStream($$)
             my $name = $$decodeParms{Name};
             next unless defined $name or $name eq 'Identity';
             if ($name ne 'StdCF') {
-                $et->WarnOnce("Unsupported Crypt Filter $name");
+                $et->Warn("Unsupported Crypt Filter $name");
                 return 0;
             }
             unless ($cryptInfo) {
-                $et->WarnOnce('Missing Encrypt StdCF entry');
+                $et->Warn('Missing Encrypt StdCF entry');
                 return 0;
             }
             # decrypt the stream manually because we want to:
@@ -1318,15 +1318,15 @@ sub DecodeStream($$)
             # make sure we don't have any unsupported decoding parameters
             if (ref $decodeParms eq 'HASH') {
                 if ($$decodeParms{Predictor}) {
-                    $et->WarnOnce("LZWDecode Predictor $$decodeParms{Predictor} currently not supported");
+                    $et->Warn("LZWDecode Predictor $$decodeParms{Predictor} currently not supported");
                     return 0;
                 } elsif ($$decodeParms{EarlyChange}) {
-                    $et->WarnOnce("LZWDecode EarlyChange currently not supported");
+                    $et->Warn("LZWDecode EarlyChange currently not supported");
                     return 0;
                 }
             }
             unless (DecodeLZW(\$$dict{_stream})) {
-                $et->WarnOnce('LZW decompress error');
+                $et->Warn('LZW decompress error');
                 return 0;
             }
 
@@ -1362,7 +1362,7 @@ sub DecodeStream($$)
                 last if $_ eq '~';
                 # (both $n and $val are zero again now)
             }
-            $err and $et->WarnOnce("ASCII85Decode error $err");
+            $err and $et->Warn("ASCII85Decode error $err");
             $$dict{_stream} = pack('C*', @out);
         }
     }
@@ -1830,7 +1830,7 @@ sub ProcessDict($$$$;$$)
 
     $nesting = ($nesting || 0) + 1;
     if ($nesting > 50) {
-        $et->WarnOnce('Nesting too deep (directory ignored)');
+        $et->Warn('Nesting too deep (directory ignored)');
         return;
     }
     # save entire dictionary for rewriting if specified
@@ -1990,7 +1990,7 @@ sub ProcessDict($$$$;$$)
                     if ($$tagInfo{IgnoreDuplicates}) {
                         my $flag = "ProcessedPDF_$tag";
                         if ($$et{$flag}) {
-                            next if $et->WarnOnce("Ignored duplicate $tag dictionary", 2);
+                            next if $et->Warn("Ignored duplicate $tag dictionary", 2);
                         } else {
                             $$et{$flag} = 1;
                         }
@@ -2171,9 +2171,9 @@ sub ProcessDict($$$$;$$)
             my $type = $$dict{Type} || '';
             if ($type ne '/Metadata' or $$dict{Length} > 100000) {
                 if ($$et{OPTIONS}{IgnoreMinorErrors}) {
-                    $et->WarnOnce("Decrypting large $$tagInfo{Name} (will be slow)");
+                    $et->Warn("Decrypting large $$tagInfo{Name} (will be slow)");
                 } else {
-                    $et->WarnOnce("Skipping large AES-encrypted $$tagInfo{Name}", 2);
+                    $et->Warn("Skipping large AES-encrypted $$tagInfo{Name}", 2);
                     last;
                 }
             }

data/bin/lib/Image/ExifTool/PLIST.pm

@@ -269,7 +269,7 @@ sub ExtractObject($$;$)
             if ($type == 13) { # dict
                 # prevent infinite recursion
                 if (defined $parent and length $parent > 1000) {
-                    $et->WarnOnce('Possible deep recursion while parsing PLIST');
+                    $et->Warn('Possible deep recursion while parsing PLIST');
                     return undef;
                 }
                 my $tagTablePtr = $$plistInfo{TagTablePtr};

data/bin/lib/Image/ExifTool/PNG.pm

@@ -965,7 +965,7 @@ sub FoundPNG($$$$;$$$$)
         my $processed;
         if ($$tagInfo{SubDirectory}) {
             if ($$et{OPTIONS}{Validate} and $$tagInfo{NonStandard}) {
-                $et->WarnOnce("Non-standard $$tagInfo{NonStandard} in PNG $tag chunk", 1);
+                $et->Warn("Non-standard $$tagInfo{NonStandard} in PNG $tag chunk", 1);
             }
             my $subdir = $$tagInfo{SubDirectory};
             my $dirName = $$subdir{DirName} || $tagName;
@@ -1471,7 +1471,7 @@ sub ProcessPNG($$)
 
         if ($wasEnd) {
             last unless $n; # stop now if normal end of PNG
-            $et->WarnOnce("Trailer data after $fileType $endChunk chunk", 1);
+            $et->Warn("Trailer data after $fileType $endChunk chunk", 1);
             $wasTrailer = 1;
             last if $n < 8;
             $$et{SET_GROUP1} = 'Trailer';
@@ -1500,7 +1500,7 @@ sub ProcessPNG($$)
             } elsif ($hdrChunk eq 'IHDR' and $chunk eq 'CgBI') {
                 $et->Warn('Non-standard PNG image (Apple iPhone format)');
             } else {
-                $et->WarnOnce("$fileType image did not start with $hdrChunk");
+                $et->Warn("$fileType image did not start with $hdrChunk");
             }
         }
         if ($outfile and ($isDatChunk{$chunk} or $chunk eq $endChunk) and @txtOffset) {
@@ -1594,7 +1594,7 @@ sub ProcessPNG($$)
             } else {
                 $msg = 'fixed';
             }
-            $et->WarnOnce("Text/EXIF chunk(s) found after $$et{FileType} $wasDat ($msg)", 1);
+            $et->Warn("Text/EXIF chunk(s) found after $$et{FileType} $wasDat ($msg)", 1);
         }
         # read chunk data and CRC
         unless ($raf->Read($dbuf,$len)==$len and $raf->Read($cbuf, 4)==4) {

data/bin/lib/Image/ExifTool/Panasonic.pm

@@ -2802,7 +2802,7 @@ sub ProcessLeicaTrailer($;$)
                 }
             } else { # M (Type 240)
                 # scan for the lens type (M writes 114 bytes of garbage first)
-                if ($buff =~ /\G.{114}([\x20-\x7f]*\0*)/sg and length($1) >= 50) {
+                if ($buff =~ /\G.{114}([\x20-\x7e]*\0*)/sg and length($1) >= 50) {
                     $expect = 114;
                 }
             }

data/bin/lib/Image/ExifTool/PhaseOne.pm

@@ -450,7 +450,7 @@ sub WritePhaseOne($$$)
 
     return undef if $dirLen < 12;
     unless ($$tagTablePtr{VARS} and $$tagTablePtr{VARS}{ENTRY_SIZE}) {
-        $et->WarnOnce("No ENTRY_SIZE for $$tagTablePtr{TABLE_NAME}");
+        $et->Warn("No ENTRY_SIZE for $$tagTablePtr{TABLE_NAME}");
         return undef;
     }
     my $entrySize = $$tagTablePtr{VARS}{ENTRY_SIZE};
@@ -591,7 +591,7 @@ sub ProcessPhaseOne($$$)
 
     return 0 if $dirLen < 12;
     unless ($$tagTablePtr{VARS} and $$tagTablePtr{VARS}{ENTRY_SIZE}) {
-        $et->WarnOnce("No ENTRY_SIZE for $$tagTablePtr{TABLE_NAME}");
+        $et->Warn("No ENTRY_SIZE for $$tagTablePtr{TABLE_NAME}");
         return undef;
     }
     my $entrySize = $$tagTablePtr{VARS}{ENTRY_SIZE};
@@ -632,7 +632,7 @@ sub ProcessPhaseOne($$$)
             $formatSize = Get32u($dataPt, $entry+4);
             $formatStr = $formatName[$formatSize];
             unless ($formatStr) {
-                $et->WarnOnce("Unrecognized $ifdType format size $formatSize",1);
+                $et->Warn("Unrecognized $ifdType format size $formatSize",1);
                 $formatSize = 1;
                 $formatStr = 'undef';
             }