exiftool_vendored 11.71.0 → 11.75.0

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

@@ -828,7 +828,7 @@ sub ProcessDocumentData($$$)
     my $raf = $$dirInfo{RAF};
     my $dirLen = $$dirInfo{DirLen};
     my $pos = 36;   # length of header
-    my ($buff, $n);
+    my ($buff, $n, $err);
 
     $et->VerboseDir('Photoshop Document Data', undef, $dirLen);
     unless ($raf) {
@@ -849,24 +849,24 @@ sub ProcessDocumentData($$$)
     my %dinfo = ( DataPt => \$buff );
     $$et{IsPSB} = $psb; # set PSB flag (needed when handling Layers directory)
     while ($pos + 12 <= $dirLen) {
-        $raf->Read($buff, 8) == 8 or last;
+        $raf->Read($buff, 8) == 8 or $err = 'Error reading document data', last;
         # set byte order according to byte order of first signature
         SetByteOrder($buff =~ /^(8BIM|8B64)/ ? 'MM' : 'II') if $pos == 36;
         $buff = pack 'N*', unpack 'V*', $buff if GetByteOrder() eq 'II';
         my $sig = substr($buff, 0, 4);
-        last unless $sig eq '8BIM' or $sig eq '8B64';   # verify signature
+        $sig eq '8BIM' or $sig eq '8B64' or $err = 'Bad photoshop resource', last; # verify signature
         my $tag = substr($buff, 4, 4);
         if ($psb and $tag =~ /^(LMsk|Lr16|Lr32|Layr|Mt16|Mt32|Mtrn|Alph|FMsk|lnk2|FEid|FXid|PxSD)$/) {
-            last if $pos + 16 > $dirLen;
-            $raf->Read($buff, 8) == 8 or last;
+            $pos + 16 > $dirLen and $err = 'Short PSB resource', last;
+            $raf->Read($buff, 8) == 8 or $err = 'Error reading PSB resource', last;
             $n = Get64u(\$buff, 0);
             $pos += 4;
         } else {
-            $raf->Read($buff, 4) == 4 or last;
+            $raf->Read($buff, 4) == 4 or $err = 'Error reading PSD resource', last;
             $n = Get32u(\$buff, 0);
         }
         $pos += 12;
-        last if $pos + $n > $dirLen;
+        $pos + $n > $dirLen and $err = 'Truncated photoshop resource', last;
         my $pad = (4 - ($n & 3)) & 3;   # number of padding bytes
         my $tagInfo = $$tagTablePtr{$tag};
         if ($tagInfo or $verbose) {
@@ -874,20 +874,21 @@ sub ProcessDocumentData($$$)
                 my $fpos = $raf->Tell() + $n + $pad;
                 my $subTable = GetTagTable($$tagInfo{SubDirectory}{TagTable});
                 $et->ProcessDirectory({ RAF => $raf, DirLen => $n }, $subTable);
-                $raf->Seek($fpos, 0) or last;
+                $raf->Seek($fpos, 0) or $err = 'Seek error', last;
             } else {
                 $dinfo{DataPos} = $raf->Tell();
                 $dinfo{Start} = 0;
                 $dinfo{Size} = $n;
-                $raf->Read($buff, $n) == $n or last;
+                $raf->Read($buff, $n) == $n or $err = 'Error reading photoshop resource', last;
                 $et->HandleTag($tagTablePtr, $tag, undef, %dinfo);
-                $raf->Seek($pad, 1) or last;
+                $raf->Seek($pad, 1) or $err = 'Seek error', last;
             }
         } else {
-            $raf->Seek($n + $pad, 1) or last;
+            $raf->Seek($n + $pad, 1) or $err = 'Seek error', last;
         }
         $pos += $n + $pad;              # step to start of next structure
     }
+    $err and $et->Warn($err);
     return 1;
 }
 

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

@@ -44,7 +44,7 @@ use Image::ExifTool qw(:DataAccess :Utils);
 use Image::ExifTool::Exif;
 use Image::ExifTool::GPS;
 
-$VERSION = '2.37';
+$VERSION = '2.38';
 
 sub ProcessMOV($$;$);
 sub ProcessKeys($$$);
@@ -59,6 +59,7 @@ sub Process_mebx($$$);
 sub Process_3gf($$$);
 sub Process_gps0($$$);
 sub Process_gsen($$$);
+sub ProcessRIFFTrailer($$$);
 sub ProcessTTAD($$$);
 sub ProcessNMEA($$$);
 sub SaveMetaKeys($$$);
@@ -8293,7 +8294,7 @@ sub ProcessMOV($$;$)
                     my $str = $$dirInfo{DirName} . ' with ' . ($raf->Tell() - $pos) . ' bytes';
                     $et->VPrint(0,"$$et{INDENT}\[Terminator found in $str remaining]");
                 } else {
-                    my $t = PrintableTagID($tag);
+                    my $t = PrintableTagID($tag,2);
                     $et->VPrint(0,"$$et{INDENT}Tag '${t}' extends to end of file");
                 }
                 last;
@@ -8394,9 +8395,21 @@ sub ProcessMOV($$;$)
         }
         # load values only if associated with a tag (or verbose) and not too big
         if ($size > 0x2000000) {    # start to get worried above 32 MB
+            # check for RIFF trailer (written by Auto-Vox dashcam)
+            if ($buff =~ /^(gpsa|gps0|gsen|gsea)...\0/s) { # (yet seen only gpsa as first record)
+                $et->VPrint(0, "Found RIFF trailer");
+                if ($et->Options('ExtractEmbedded')) {
+                    $raf->Seek(-8, 1) or last;  # seek back to start of trailer
+                    my $tbl = GetTagTable('Image::ExifTool::QuickTime::Stream');
+                    ProcessRIFFTrailer($et, { RAF => $raf }, $tbl);
+                } else {
+                    EEWarn($et);
+                }
+                last;
+            }
             $ignore = 1;
             if ($tagInfo and not $$tagInfo{Unknown} and not $eeTag) {
-                my $t = PrintableTagID($tag);
+                my $t = PrintableTagID($tag,2);
                 if ($size > 0x8000000) {
                     $et->Warn("Skipping '${t}' atom > 128 MB", 1);
                 } else {
@@ -8444,7 +8457,7 @@ ItemID:         foreach $id (keys %$items) {
             my $val;
             my $missing = $size - $raf->Read($val, $size);
             if ($missing) {
-                my $t = PrintableTagID($tag);
+                my $t = PrintableTagID($tag,2);
                 $et->Warn("Truncated '${t}' data (missing $missing bytes)");
                 last;
             }
@@ -8721,7 +8734,7 @@ ItemID:         foreach $id (keys %$items) {
                 Extra => sprintf(' at offset 0x%.4x', $raf->Tell()),
             ) if $verbose;
             if ($size and (not $raf->Seek($size-1, 1) or $raf->Read($buff, 1) != 1)) {
-                my $t = PrintableTagID($tag);
+                my $t = PrintableTagID($tag,2);
                 $et->Warn("Truncated '${t}' data");
                 last;
             }

data/bin/lib/Image/ExifTool/QuickTimeStream.pl

@@ -89,20 +89,34 @@ my %insvLimit = (
         the ExtractEmbedded option is used.
     },
     VARS => { NO_ID => 1 },
-    GPSLatitude  => { PrintConv => 'Image::ExifTool::GPS::ToDMS($self, $val, 1, "N")' },
+    GPSLatitude  => { PrintConv => 'Image::ExifTool::GPS::ToDMS($self, $val, 1, "N")', RawConv => '$$self{FoundGPSLatitude} = 1; $val' },
     GPSLongitude => { PrintConv => 'Image::ExifTool::GPS::ToDMS($self, $val, 1, "E")' },
     GPSAltitude  => { PrintConv => '(sprintf("%.4f", $val) + 0) . " m"' }, # round to 4 decimals
     GPSSpeed     => { PrintConv => 'sprintf("%.4f", $val) + 0' },   # round to 4 decimals
     GPSSpeedRef  => { PrintConv => { K => 'km/h', M => 'mph', N => 'knots' } },
     GPSTrack     => { PrintConv => 'sprintf("%.4f", $val) + 0' },    # round to 4 decimals
     GPSTrackRef  => { PrintConv => { M => 'Magnetic North', T => 'True North' } },
-    GPSDateTime  => { PrintConv => '$self->ConvertDateTime($val)', Groups => { 2 => 'Time' } },
+    GPSDateTime  => {
+        Groups => { 2 => 'Time' },
+        Description => 'GPS Date/Time',
+        RawConv => '$$self{FoundGPSDateTime} = 1; $val',
+        PrintConv => '$self->ConvertDateTime($val)',
+    },
     GPSTimeStamp => { PrintConv => 'Image::ExifTool::GPS::PrintTimeStamp($val)', Groups => { 2 => 'Time' } },
     GPSSatellites=> { },
     GPSDOP       => { Description => 'GPS Dilution Of Precision' },
+    Distance     => { PrintConv => '"$val m"' },
+    VerticalSpeed=> { PrintConv => '"$val m/s"' },
+    FNumber      => { PrintConv => 'Image::ExifTool::Exif::PrintFNumber($val)', Groups => { 2 => 'Camera' } },
+    ExposureTime => { PrintConv => 'Image::ExifTool::Exif::PrintExposureTime($val)', Groups => { 2 => 'Camera' } },
+    ExposureCompensation => { PrintConv => 'Image::ExifTool::Exif::PrintFraction($val)', Groups => { 2 => 'Camera' } },
+    ISO          => { Groups => { 2 => 'Camera' } },
     CameraDateTime=>{ PrintConv => '$self->ConvertDateTime($val)', Groups => { 2 => 'Time' } },
-    Accelerometer=> { Notes => 'right/up/backward acceleration in units of g' },
+    Accelerometer=> { Notes => '3-axis acceleration in units of g' },
+    AccelerometerData => { },
     AngularVelocity => { },
+    GSensor      => { },
+    Car          => { },
     RawGSensor   => {
         # (same as GSensor, but offset by some unknown value)
         ValueConv => 'my @a=split " ",$val; $_/=1000 foreach @a; "@a"',
@@ -221,6 +235,10 @@ my %insvLimit = (
             ByteOrder => 'Little-Endian',
         },
     }],
+    mett => { # Parrot drones
+        Name => 'mett',
+        SubDirectory => { TagTable => 'Image::ExifTool::Parrot::mett' },
+    },
     JPEG => { # (in CR3 images) - [vide HandlerType with JPEG in SampleDescription, not MetaFormat]
         Name => 'JpgFromRaw',
         Groups => { 2 => 'Preview' },
@@ -319,6 +337,7 @@ my %insvLimit = (
     4 => {
         Name => 'GPSLatitude',
         Format => 'double',
+        RawConv => '$$self{FoundGPSLatitude} = 1; $val',
         ValueConv => 'Image::ExifTool::GPS::ToDegrees($val, 1)',
         PrintConv => 'Image::ExifTool::GPS::ToDMS($self, $val, 1, "N")',
     },
@@ -342,8 +361,10 @@ my %insvLimit = (
     FIRST_ENTRY => 0,
     0x04 => {
         Name => 'GPSDateTime',
+        Description => 'GPS Date/Time',
         Groups => { 2 => 'Time' },
         Format => 'double',
+        RawConv => '$$self{FoundGPSDateTime} = 1; $val',
         ValueConv => q{
             my $str = ConvertUnixTime($val);
             my $frac = $val - int($val);
@@ -369,6 +390,7 @@ my %insvLimit = (
     0x10 => {
         Name => 'GPSLatitude',
         Format => 'double',
+        RawConv => '$$self{FoundGPSLatitude} = 1; $val',
         ValueConv => 'Image::ExifTool::GPS::ToDegrees($val, 1)',
         PrintConv => 'Image::ExifTool::GPS::ToDMS($self, $val, 1, "N")',
     },
@@ -425,6 +447,7 @@ my %insvLimit = (
     4 => {
         Name => 'GPSLatitude',
         Format => 'int32s',
+        RawConv => '$$self{FoundGPSLatitude} = 1; $val',
         ValueConv => 'Image::ExifTool::GPS::ToDegrees($val/1e6, 1)',
         PrintConv => 'Image::ExifTool::GPS::ToDMS($self, $val, 1, "N")',
     },
@@ -470,6 +493,7 @@ my %insvLimit = (
     NOTES => 'Tags extracted from the tx3g sbtl timed metadata of Yuneec drones.',
     Lat => {
         Name => 'GPSLatitude',
+        RawConv => '$$self{FoundGPSLatitude} = 1; $val',
         PrintConv => 'Image::ExifTool::GPS::ToDMS($self, $val, 1, "N")',
     },
     Lon => {
@@ -571,7 +595,7 @@ sub SaveMetaKeys($$$)
                 } else {
                     $str = '';
                 }
-                $et->VPrint(1, $$et{INDENT}."- Tag '".PrintableTagID($tag)."' ($len bytes)$str\n");
+                $et->VPrint(1, $$et{INDENT}."- Tag '".PrintableTagID($tag,2)."' ($len bytes)$str\n");
                 $et->VerboseDump(\$val);
             }
         }
@@ -599,14 +623,53 @@ sub FoundSomething($$;$$)
 }
 
 #------------------------------------------------------------------------------
-# Parse textual metadata
-# Inputs: 0) ExifTool ref, 1) tag table ref, 2) data ref
-sub ParseText($$$)
+# Approximate GPSDateTime value from sample time and CreateDate
+# Inputs: 0) ExifTool ref, 1) tag table ptr, 2) sample time (ms)
+#         3) true if CreateDate is at end of video
+# Notes: Uses ExifTool CreateDateAtEnd as flag to subtract video duration
+sub SetGPSDateTime($$$)
+{
+    my ($et, $tagTbl, $sampleTime) = @_;
+    my $value = $$et{VALUE};
+    if (defined $sampleTime and $$value{CreateDate}) {
+        $sampleTime += $$value{CreateDate}; # adjust sample time to seconds since the epoch
+        if ($$et{CreateDateAtEnd}) {        # adjust if CreateDate is at end of video
+            return unless $$value{TimeScale} and $$value{Duration};
+            $sampleTime -= $$value{Duration} / $$value{TimeScale};
+            $et->WarnOnce('Approximating GPSDateTime as CreateDate - Duration + SampleTime', 1);
+        } else {
+            $et->WarnOnce('Approximating GPSDateTime as CreateDate + SampleTime', 1);
+        }
+        unless ($et->Options('QuickTimeUTC')) {
+            my $tzOff = $$et{tzOff};    # use previously calculated offset
+            unless (defined $tzOff) {
+                # adjust to UTC, assuming time is local
+                my @tm = localtime $$value{CreateDate};
+                my @gm = gmtime $$value{CreateDate};
+                $tzOff = $$et{tzOff} = Image::ExifTool::GetTimeZone(\@tm, \@gm) * 60;
+            }
+            $sampleTime -= $tzOff;  # shift from local time to UTC
+        }
+        $et->HandleTag($tagTbl, GPSDateTime => Image::ExifTool::ConvertUnixTime($sampleTime,0,3) . 'Z');
+    }
+}
+
+#------------------------------------------------------------------------------
+# Process subtitle 'text'
+# Inputs: 0) ExifTool ref, 1) tag table ref, 2) data ref, 3) optional sample time
+sub Process_text($$$)
 {
     my ($et, $tagTbl, $buffPt) = @_;
+    my ($found, $val, %tags, $tag);
+
+    return if $$et{NoMoreTextDecoding};
+
     while ($$buffPt =~ /\$(\w+)([^\$]*)/g) {
         my ($tag, $dat) = ($1, $2);
         if ($tag =~ /^[A-Z]{2}RMC$/ and $dat =~ /^,(\d{2})(\d{2})(\d+(\.\d*)?),A?,(\d*?)(\d{1,2}\.\d+),([NS]),(\d*?)(\d{1,2}\.\d+),([EW]),(\d*\.?\d*),(\d*\.?\d*),(\d{2})(\d{2})(\d+)/) {
+            my $year = $15 + ($15 >= 70 ? 1900 : 2000);
+            my $str = sprintf('%.4d:%.2d:%.2d %.2d:%.2d:%.2dZ', $year, $14, $13, $1, $2, $3);
+            $et->HandleTag($tagTbl, GPSDateTime  => $str);
             $et->HandleTag($tagTbl, GPSLatitude  => (($5 || 0) + $6/60) * ($7 eq 'N' ? 1 : -1));
             $et->HandleTag($tagTbl, GPSLongitude => (($8 || 0) + $9/60) * ($10 eq 'E' ? 1 : -1));
             if (length $11) {
@@ -617,23 +680,126 @@ sub ParseText($$$)
                 $et->HandleTag($tagTbl, GPSTrack => $11);
                 $et->HandleTag($tagTbl, GPSTrackRef => 'T');
             }
-            my $year = $15 + ($15 >= 70 ? 1900 : 2000);
-            my $str = sprintf('%.4d:%.2d:%.2d %.2d:%.2d:%.2dZ', $year, $14, $13, $1, $2, $3);
-            $et->HandleTag($tagTbl, GPSDateTime => $str);
+            $found = 1;
         } elsif ($tag eq 'BEGINGSENSOR' and $dat =~ /^:([-+]\d+\.\d+):([-+]\d+\.\d+):([-+]\d+\.\d+)/) {
             $et->HandleTag($tagTbl, Accelerometer => "$1 $2 $3");
+            $found = 1;
         } elsif ($tag eq 'TIME' and $dat =~ /^:(\d+)/) {
             $et->HandleTag($tagTbl, TimeCode => $1 / ($$et{MediaTS} || 1));
+            $found = 1;
         } elsif ($tag eq 'BEGIN') {
             $et->HandleTag($tagTbl, Text => $dat) if length $dat;
+            $found = 1;
         } elsif ($tag ne 'END') {
             $et->HandleTag($tagTbl, Text => "\$$tag$dat");
+            $found = 1;
+        }
+    }
+    return if $found;
+
+    # check for BlueSkySea enciphered binary GPS data
+    if ($$buffPt =~ /^\0\0..\xaa\xaa/s and length $$buffPt >= 282) {
+        $val = pack('C*', map { $_ ^ 0xaa } unpack('C*', substr($$buffPt, 8, 14)));
+        if ($val =~ /^(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})$/) {
+            $tags{GPSDateTime} = "$1:$2:$3 $4:$5:$6";
+            $val = pack('C*', map { $_ ^ 0xaa } unpack('C*', substr($$buffPt, 38, 9)));
+            if ($val =~ /^([NS])(\d{2})(\d+$)$/) {
+                $tags{GPSLatitude} = ($2 + $3 / 600000) * ($1 eq 'S' ? -1 : 1);
+            }
+            $val = pack('C*', map { $_ ^ 0xaa } unpack('C*', substr($$buffPt, 47, 10)));
+            if ($val =~ /^([EW])(\d{3})(\d+$)$/) {
+                $tags{GPSLongitude} = ($2 + $3 / 600000) * ($1 eq 'W' ? -1 : 1);
+            }
+            $val = pack('C*', map { $_ ^ 0xaa } unpack('C*', substr($$buffPt, 62, 3)));
+            $tags{GPSSpeed} = $val + 0 if $val =~ /^\d+$/;
+            $val = pack('C*', map { $_ ^ 0xaa } unpack('C*', substr($$buffPt, 0xad, 12)));
+            # the first X,Y,Z accelerometer readings from the AccelerometerData
+            if ($val =~ /^([-+]\d{3})([-+]\d{3})([-+]\d{3})$/) {
+                $tags{Accelerometer} = "$1 $2 $3";
+            }
+            $val = pack('C*', map { $_ ^ 0xaa } unpack('C*', substr($$buffPt, 0xba, 96)));
+            my $order = GetByteOrder();
+            SetByteOrder('II');
+            $val = ReadValue(\$val, 0, 'float');
+            SetByteOrder($order);
+            $tags{AccelerometerData} = $val;
+        }
+    }
+
+    # check for DJI telemetry data, eg:
+    # "F/3.5, SS 1000, ISO 100, EV 0, GPS (8.6499, 53.1665, 18), D 24.26m,
+    #  H 6.00m, H.S 2.10m/s, V.S 0.00m/s \n"
+    if (not %tags and $$buffPt =~ /GPS \(([-+]?\d*\.\d+),\s*([-+]?\d*\.\d+)/) {
+        $$et{CreateDateAtEnd} = 1;  # set flag indicating the file creation date is at the end
+        $tags{GPSLatitude} = $2;
+        $tags{GPSLongitude} = $1;
+        $tags{GPSAltitude} = $1 if $$buffPt =~ /,\s*H\s+([-+]?\d+\.?\d*)m/;
+        if ($$buffPt =~ /,\s*H.S\s+([-+]?\d+\.?\d*)/) {
+            $tags{GPSSpeed} = $1 * $mpsToKph;
+            $tags{GPSSpeedRef} = 'K';
+        }
+        $tags{Distance} = $1 * $mpsToKph if $$buffPt =~ /,\s*D\s+(\d+\.?\d*)m/;
+        $tags{VerticalSpeed} = $1 if $$buffPt =~ /,\s*V.S\s+([-+]?\d+\.?\d*)/;
+        $tags{FNumber} = $1 if $$buffPt =~ /\bF\/(\d+\.?\d*)/;
+        $tags{ExposureTime} = 1 / $1 if $$buffPt =~ /\bSS\s+(\d+\.?\d*)/;
+        $tags{ExposureCompensation} = ($1 / ($2 || 1)) if $$buffPt =~ /\bEV\s+([-+]?\d+\.?\d*)(\/\d+)?/;
+        $tags{ISO} = $1 if $$buffPt =~ /\bISO\s+(\d+\.?\d*)/;
+    }
+
+    # check for Mini 0806 dashcam GPS, eg:
+    # "A,270519,201555.000,3356.8925,N,08420.2071,W,000.0,331.0M,+01.84,-09.80,-00.61;\n"
+    if (not %tags and $$buffPt =~ /^A,(\d{2})(\d{2})(\d{2}),(\d{2})(\d{2})(\d{2}(\.\d+)?)/) {
+        $tags{GPSDateTime} = "20$3:$2:$1 $4:$5:$6Z";
+        if ($$buffPt =~ /^A,.*?,.*?,(\d{2})(\d+\.\d+),([NS])/) {
+            $tags{GPSLatitude} = ($1 + $2/60) * ($3 eq 'S' ? -1 : 1);
+        }
+        if ($$buffPt =~ /^A,.*?,.*?,.*?,.*?,(\d{3})(\d+\.\d+),([EW])/) {
+            $tags{GPSLongitude} = ($1 + $2/60) * ($3 eq 'W' ? -1 : 1);
         }
+        my @a = split ',', $$buffPt;
+        $tags{GPSAltitude} = $a[8] if $a[8] and $a[8] =~ s/M$//;
+        $tags{GPSSpeed} = $a[7] if $a[7] and $a[7] =~ /^\d+\.\d+$/; # (NC)
+        $tags{Accelerometer} = "$a[9] $a[10] $a[11]" if $a[11] and $a[11] =~ s/;\s*$//;
+    }
+
+    # check for Thinkware format, eg:
+    # "gsensori,4,512,-67,-12,100;GNRMC,161313.00,A,4529.87489,N,07337.01215,W,6.225,35.34,310819,,,A*52..;
+    #  CAR,0,0,0,0.0,0,0,0,0,0,0,0,0"
+    unless (%tags) {
+        if ($$buffPt =~ /[A-Z]{2}RMC,(\d{2})(\d{2})(\d+(\.\d*)?),A?,(\d*?)(\d{1,2}\.\d+),([NS]),(\d*?)(\d{1,2}\.\d+),([EW]),(\d*\.?\d*),(\d*\.?\d*),(\d{2})(\d{2})(\d+)/ and
+            # do some basic sanity checks on the date
+            $13 <= 31 and $14 <= 12 and $15 <= 99)
+        {
+            my $year = $15 + ($15 >= 70 ? 1900 : 2000);
+            $tags{GPSDateTime} = sprintf('%.4d:%.2d:%.2d %.2d:%.2d:%.2dZ', $year, $14, $13, $1, $2, $3);
+            $tags{GPSLatitude} = (($5 || 0) + $6/60) * ($7 eq 'N' ? 1 : -1);
+            $tags{GPSLongitude} = (($8 || 0) + $9/60) * ($10 eq 'E' ? 1 : -1);
+            if (length $11) {
+                $tags{GPSSpeed} = $11 * $knotsToKph;
+                $tags{GPSSpeedRef} = 'K';
+            }
+            if (length $12) {
+                $tags{GPSTrack} = $12;
+                $tags{GPSTrackRef} = 'T';
+            }
+        }
+        $tags{GSensor} = $1 if $$buffPt =~ /\bgsensori,(.*?)(;|$)/;
+        $tags{Car} = $1 if $$buffPt =~ /\bCAR,(.*?)(;|$)/;
+    }
+    if (%tags) {
+        foreach $tag (sort keys %tags) {
+            $et->HandleTag($tagTbl, $tag => $tags{$tag});
+        }
+        $$et{UnknownTextCount} = 0;
+    } else {
+        $$et{UnknownTextCount} = ($$et{UnknownTextCount} || 0) + 1;
+        # give up trying to decode useful information if we haven't found anything for a while
+        $$et{NoMoreTextDecoding} = 1 if $$et{UnknownTextCount} > 100;
     }
 }
 
 #------------------------------------------------------------------------------
-# Exract embedded metadata from media samples
+# Extract embedded metadata from media samples
 # Inputs: 0) ExifTool ref
 # Notes: Also accesses ExifTool RAF*, SET_GROUP1, HandlerType, MetaFormat,
 #        ee*, and avcC elements (* = must exist)
@@ -725,6 +891,10 @@ sub ProcessSamples($)
     # loop through all samples
     for ($i=0; $i<@$start and $i<@$size; ++$i) {
 
+        # initialize our flags for setting GPSDateTime
+        delete $$et{FoundGPSLatitude};
+        delete $$et{FoundGPSDateTime};
+
         # read the sample data
         my $size = $$size[$i];
         next unless $raf->Seek($$start[$i], 0) and $raf->Read($buff, $size) == $size;
@@ -782,14 +952,14 @@ sub ProcessSamples($)
                     $et->HandleTag($tagTbl, GPSLongitude => Get32s(\$buff, 16) * 180/0x80000000);
                     $et->HandleTag($tagTbl, GPSSpeed => Get16u(\$buff, 8));
                     $et->HandleTag($tagTbl, GPSSpeedRef => 'M');
-                    next;
+                    SetGPSDateTime($et, $tagTbl, $time[$i]);
+                    next; # all done (don't store/process as text)
                 }
                 unless (defined $val) {
                     $et->HandleTag($tagTbl, Text => $buff); # just store any other text
-                    next;
                 }
             }
-            ParseText($et, $tagTbl, \$buff);
+            Process_text($et, $tagTbl, \$buff);
 
         } elsif ($processByMetaFormat{$type}) {
 
@@ -800,6 +970,7 @@ sub ProcessSamples($)
                     $$et{ee} = $ee; # need ee information for 'keys'
                     $et->HandleTag($tagTbl, $metaFormat, undef,
                         DataPt  => \$buff,
+                        DataPos => $$start[$i],
                         Base    => $$start[$i],
                         TagInfo => $tagInfo,
                     );
@@ -809,7 +980,7 @@ sub ProcessSamples($)
                     # "X0000.0000Y0000.0000Z0000.0000G0000.0000$GPRMC,000125,V,,,,,000.0,,280908,002.1,N*71~, 794021  \x0a"
                     FoundSomething($et, $tagTbl, $time[$i], $dur[$i]);
                     $et->HandleTag($tagTbl, Accelerometer => "$1 $2 $3 $4") if $buff =~ /X(.*?)Y(.*?)Z(.*?)G(.*?)\$/;
-                    ParseText($et, $tagTbl, \$buff);
+                    Process_text($et, $tagTbl, \$buff);
                 }
             } elsif ($verbose) {
                 $et->VPrint(0, "Unknown meta format ($metaFormat)");
@@ -821,6 +992,7 @@ sub ProcessSamples($)
                 # decode "freeGPS " data (Novatek)
                 ProcessFreeGPS($et, {
                     DataPt => \$buff,
+                    DataPos => $$start[$i],
                     SampleTime => $time[$i],
                     SampleDuration => $dur[$i],
                 }, $tagTbl) ;
@@ -833,11 +1005,14 @@ sub ProcessSamples($)
                 FoundSomething($et, $tagTbl, $time[$i], $dur[$i]);
                 $et->HandleTag($tagTbl, $type, undef,
                     DataPt  => \$buff,
+                    DataPos => $$start[$i],
                     Base    => $$start[$i],
                     TagInfo => $tagInfo,
                 );
             }
         }
+        # generate approximate GPSDateTime if necessary
+        SetGPSDateTime($et, $tagTbl, $time[$i]) if $$et{FoundGPSLatitude} and not $$et{FoundGPSDateTime};
     }
     if ($verbose) {
         $$et{INDENT} = $oldIndent;
@@ -929,7 +1104,7 @@ sub ProcessFreeGPS($$$)
         SetByteOrder('II');
         $lat = GetFloat($dataPt, 0x2c);
         $lon = GetFloat($dataPt, 0x30);
-        $spd = GetFloat($dataPt, 0x34) * 1.852; # (convert knots to km/h)
+        $spd = GetFloat($dataPt, 0x34) * $knotsToKph; # (convert knots to km/h)
         $trk = GetFloat($dataPt, 0x38);
         SetByteOrder('MM');
 
@@ -1425,32 +1600,6 @@ sub Process_3gf($$$)
     return 1;
 }
 
-#------------------------------------------------------------------------------
-# Process DuDuBell M1 dashcam / VSYS M6L 'gsen' atom (ref PH)
-# Inputs: 0) ExifTool ref, 1) dirInfo ref, 2) tag table ref
-# Returns: 1 on success
-sub Process_gsen($$$)
-{
-    my ($et, $dirInfo, $tagTbl) = @_;
-    my $dataPt = $$dirInfo{DataPt};
-    my $dirLen = $$dirInfo{DirLen};
-    my $recLen = 3;     # 3-byte record length
-    $et->VerboseDir('gsen', undef, $dirLen);
-    if ($dirLen > $recLen and not $et->Options('ExtractEmbedded')) {
-        $dirLen = $recLen;
-        EEWarn($et);
-    }
-    my $pos;
-    for ($pos=0; $pos+$recLen<=$dirLen; $pos+=$recLen) {
-        $$et{DOC_NUM} = ++$$et{DOC_COUNT};
-        my @acc = map { $_ /= 16 } unpack "x${pos}c3", $$dataPt;
-        $et->HandleTag($tagTbl, Accelerometer => "@acc");
-        # (there are no associated timestamps, but these are sampled at 5 Hz in my test video)
-    }
-    delete $$et{DOC_NUM};
-    return 1;
-}
-
 #------------------------------------------------------------------------------
 # Process DuDuBell M1 dashcam / VSYS M6L 'gps0' atom (ref PH)
 # Inputs: 0) ExifTool ref, 1) dirInfo ref, 2) tag table ref
@@ -1479,7 +1628,7 @@ sub Process_gps0($$$)
         $lat = $deg + ($lat - $deg * 100) / 60;
         $deg = int($lon / 100);
         $lon = $deg + ($lon - $deg * 100) / 60;
-        my @a = unpack('C*', substr($$dataPt,$pos+22, 6));  # unpack date/time
+        my @a = unpack('C*', substr($$dataPt, $pos+22, 6)); # unpack date/time
         $a[0] += 2000;
         $et->HandleTag($tagTbl, GPSDateTime  => sprintf("%.4d:%.2d:%.2d %.2d:%.2d:%.2dZ", @a));
         $et->HandleTag($tagTbl, GPSLatitude  => $lat);
@@ -1497,6 +1646,129 @@ sub Process_gps0($$$)
     return 1;
 }
 
+#------------------------------------------------------------------------------
+# Process DuDuBell M1 dashcam / VSYS M6L 'gsen' atom (ref PH)
+# Inputs: 0) ExifTool ref, 1) dirInfo ref, 2) tag table ref
+# Returns: 1 on success
+sub Process_gsen($$$)
+{
+    my ($et, $dirInfo, $tagTbl) = @_;
+    my $dataPt = $$dirInfo{DataPt};
+    my $dirLen = $$dirInfo{DirLen};
+    my $recLen = 3;     # 3-byte record length
+    $et->VerboseDir('gsen', undef, $dirLen);
+    if ($dirLen > $recLen and not $et->Options('ExtractEmbedded')) {
+        $dirLen = $recLen;
+        EEWarn($et);
+    }
+    my $pos;
+    for ($pos=0; $pos+$recLen<=$dirLen; $pos+=$recLen) {
+        $$et{DOC_NUM} = ++$$et{DOC_COUNT};
+        my @acc = map { $_ /= 16 } unpack "x${pos}c3", $$dataPt;
+        $et->HandleTag($tagTbl, Accelerometer => "@acc");
+        # (there are no associated timestamps, but these are sampled at 5 Hz in my test video)
+    }
+    delete $$et{DOC_NUM};
+    return 1;
+}
+
+#------------------------------------------------------------------------------
+# Process RIFF-format trailer written by Auto-Vox dashcam (ref PH)
+# Inputs: 0) ExifTool ref, 1) dirInfo ref, 2) tag table ref
+# Returns: 1 on success
+# Note: This trailer is basically RIFF chunks added to a QuickTime-format file (augh!),
+#       but there are differences in the record formats so we can't just call
+#       ProcessRIFF to process the gps0 and gsen atoms using the routines above
+sub ProcessRIFFTrailer($$$)
+{
+    my ($et, $dirInfo, $tagTbl) = @_;
+    my $raf = $$dirInfo{RAF};
+    my $verbose = $et->Options('Verbose');
+    my ($buff, $pos);
+    SetByteOrder('II');
+    for (;;) {
+        last unless $raf->Read($buff, 8) == 8;
+        my ($tag, $len) = unpack('a4V', $buff);
+        last if $tag eq "\0\0\0\0";
+        unless ($tag =~ /^[\w ]{4}/ and $len < 0x2000000) {
+            $et->Warn('Bad RIFF trailer');
+            last;
+        }
+        $raf->Read($buff, $len) == $len or $et->Warn("Truncated $tag record in RIFF trailer"), last;
+        if ($verbose) {
+            $et->VPrint(0, "  - RIFF trailer '${tag}' ($len bytes)\n");
+            $et->VerboseDump(\$buff, Addr => $raf->Tell() - $len) if $verbose > 2;
+            $$et{INDENT} .= '| ';
+            $et->VerboseDir($tag, undef, $len) if $tag =~ /^(gps0|gsen)$/;
+        }
+        if ($tag eq 'gps0') {
+            # (similar to record decoded in Process_gps0, but with some differences)
+            # 0000: 41 49 54 47 74 46 94 f6 c6 c5 b4 40 34 a2 b4 37 [AITGtF.....@4..7]
+            # 0010: f8 7b 8a 40 ff ff 00 00 38 00 77 0a 1a 0c 12 28 [.{.@....8.w....(]
+            # 0020: 8d 01 02 40 29 07 00 00                         [...@)...]
+            # 0x00 - undef[4] 'AITG'
+            # 0x04 - double   latitude  (always positive)
+            # 0x0c - double   longitude (always positive)
+            # 0x14 - ?        seen hex "ff ff 00 00" (altitude in Process_gps0 record below)
+            # 0x18 - int16u   speed in knots (different than km/hr in Process_gps0)
+            # 0x1a - int8u[6] yr-1900,mon,day,hr,min,sec (different than -2000 in Process_gps0)
+            # 0x20 - int8u    direction in degrees / 2
+            # 0x21 - int8u    guessing that this is 1=N, 2=S - PH
+            # 0x22 - int8u    guessing that this is 1=E, 2=W - PH
+            # 0x23 - ?        seen hex "40"
+            # 0x24 - in32u    time since start of video (ms)
+            my $recLen = 0x28;
+            for ($pos=0; $pos+$recLen<$len; $pos+=$recLen) {
+                substr($buff, $pos, 4) eq 'AITG' or $et->Warn('Unrecognized gps0 record'), last;
+                $$et{DOC_NUM} = ++$$et{DOC_COUNT};
+                # lat/long are in DDDMM.MMMM format
+                my $lat = GetDouble(\$buff, $pos+4);
+                my $lon = GetDouble(\$buff, $pos+12);
+                $et->Warn('Bad gps0 record') and last if abs($lat) > 9000 or abs($lon) > 18000;
+                my $deg = int($lat / 100);
+                $lat = $deg + ($lat - $deg * 100) / 60;
+                $deg = int($lon / 100);
+                $lon = $deg + ($lon - $deg * 100) / 60;
+                $lat = -$lat if Get8u(\$buff, $pos+0x21) == 2;   # wild guess
+                $lon = -$lon if Get8u(\$buff, $pos+0x22) == 2;   # wild guess
+                my @a = unpack('C*', substr($buff, $pos+26, 6)); # unpack date/time
+                $a[0] += 1900; # (different than Proces_gps0)
+                $et->HandleTag($tagTbl, SampleTime => Get32u(\$buff, $pos + 0x24) / 1000);
+                $et->HandleTag($tagTbl, GPSDateTime  => sprintf("%.4d:%.2d:%.2d %.2d:%.2d:%.2dZ", @a));
+                $et->HandleTag($tagTbl, GPSLatitude  => $lat);
+                $et->HandleTag($tagTbl, GPSLongitude => $lon);
+                $et->HandleTag($tagTbl, GPSSpeed     => Get16u(\$buff, $pos+0x18) * $knotsToKph);
+                $et->HandleTag($tagTbl, GPSSpeedRef  => 'K');
+                $et->HandleTag($tagTbl, GPSTrack     => Get8u(\$buff, $pos+0x20) * 2);
+                $et->HandleTag($tagTbl, GPSTrackRef  => 'T');
+            }
+        } elsif ($tag eq 'gsen') {
+            # (similar to record decoded in Process_gsen)
+            # 0000: 41 49 54 53 1a 0d 05 ff c8 00 00 00 [AITS........]
+            # 0x00 - undef[4] 'AITS'
+            # 0x04 - int8s[3] accelerometer readings
+            # 0x07 - ?        seen hex "ff"
+            # 0x08 - in32u    time since start of video (ms)
+            my $recLen = 0x0c;
+            for ($pos=0; $pos+$recLen<$len; $pos+=$recLen) {
+                substr($buff, $pos, 4) eq 'AITS' or $et->Warn('Unrecognized gsen record'), last;
+                $$et{DOC_NUM} = ++$$et{DOC_COUNT};
+                my @acc = map { $_ /= 24 } unpack('x'.($pos+4).'c3', $buff);
+                $et->HandleTag($tagTbl, SampleTime => Get32u(\$buff, $pos + 8) / 1000);
+                # 0=+Up, 1=+Right, 3=+Forward (calibration of 24 counts/g is a wild guess - PH)
+                $et->HandleTag($tagTbl, Accelerometer => "@acc");
+            }
+        }
+        # also seen, but not decoded:
+        # gpsa (8 bytes): hex "01 20 00 00 08 03 02 08 "
+        # gsea (20 bytes): all zeros
+        $$et{INDENT} = substr($$et{INDENT}, 0, -2) if $verbose;
+    }
+    delete $$et{DOC_NUM};
+    SetByteOrder('MM');
+    return 1;
+}
+
 #------------------------------------------------------------------------------
 # Process 'gps ' atom containing NMEA from Pittasoft Blackvue dashcam (ref PH)
 # Inputs: 0) ExifTool object ref, 1) dirInfo ref, 2) tag table ref
@@ -1624,9 +1896,9 @@ sub ProcessTTAD($$$)
             FoundSomething($et, $tagTbl, $sampleTime / 1000);
             my $t = GetDouble($dataPt, $pos);
             $et->HandleTag($tagTbl, GPSDateTime  => Image::ExifTool::ConvertUnixTime($t,undef,3).'Z');
-            $et->HandleTag($tagTbl, GPSAltitude  => GetDouble($dataPt, $pos+0x14));
             $et->HandleTag($tagTbl, GPSLatitude  => GetDouble($dataPt, $pos+0x1c));
             $et->HandleTag($tagTbl, GPSLongitude => GetDouble($dataPt, $pos+0x24));
+            $et->HandleTag($tagTbl, GPSAltitude  => GetDouble($dataPt, $pos+0x14));
             $et->HandleTag($tagTbl, GPSSpeed     => GetDouble($dataPt, $pos+0x0c) * $mpsToKph);
             $et->HandleTag($tagTbl, GPSSpeedRef  => 'K');
             $et->HandleTag($tagTbl, GPSTrack     => GetDouble($dataPt, $pos+0x30));