exiftool_vendored 13.06.0 → 13.08.0

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

@@ -94,6 +94,7 @@ my %insvDataLen = (
   # 0xb00 => 10,    # ? (Insta360 X3)
   # 0xd00 => 10,    # ? (Insta360 Ace Pro)
   # 0x1200 ?        # ? (Insta360 Ace Pro)
+  # 0x1600 ?        # ? (?)
 );
 
 # limit the default amount of data we read for some record types
@@ -109,7 +110,7 @@ my %insvLimit = (
         The tags below are extracted from timed metadata in QuickTime and other
         formats of video files when the ExtractEmbedded option is used.  Although
         most of these tags are combined into the single table below, ExifTool
-        currently reads 85 different formats of timed GPS metadata from video files.
+        currently reads 96 different types of timed GPS metadata from video files.
     },
     VARS => { NO_ID => 1 },
     GPSLatitude  => { PrintConv => 'Image::ExifTool::GPS::ToDMS($self, $val, 1, "N")', RawConv => '$$self{FoundGPSLatitude} = 1; $val' },
@@ -353,6 +354,8 @@ my %insvLimit = (
     Unknown01 => { Unknown => 1 },
     Unknown02 => { Unknown => 1 },
     Unknown03 => { Unknown => 1 },
+    M => { Name => 'Unknown_M', Unknown => 1 }, # (from LIGOGPSINFO)
+    H => { Name => 'Unknown_H', Unknown => 1 }, # (from LIGOGPSINFO)
 );
 
 # tags found in 'camm' type 0 timed metadata (ref 4)
@@ -911,9 +914,9 @@ sub SetGPSDateTime($$$;$)
         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);
+            $et->Warn('Approximating GPSDateTime as CreateDate - Duration + SampleTime', 1);
         } else {
-            $et->WarnOnce('Approximating GPSDateTime as CreateDate + SampleTime', 1);
+            $et->Warn('Approximating GPSDateTime as CreateDate + SampleTime', 1);
         }
         my $utc = $et->Options('QuickTimeUTC');
         $utc = $isUTC unless defined $utc;  # (allow QuickTimeUTC=0 to override $isUTC default)
@@ -1274,7 +1277,7 @@ sub ProcessSamples($)
                 ($startChunk, $samplesPerChunk, $descIdx) = @{shift @$stsc};
                 $nextChunk = $$stsc[0][0] if @$stsc;
             }
-            @$size < @$start + $samplesPerChunk and $et->WarnOnce('Sample size error'), last;
+            @$size < @$start + $samplesPerChunk and $et->Warn('Sample size error'), last;
             last unless defined $chunkStart and length $chunkStart;
             my $sampleStart = $chunkStart;
             my $chunkSize = 0;
@@ -1302,7 +1305,7 @@ Sample:     for ($i=0; ; ) {
             push @chunkSize, $chunkSize;
             ++$iChunk;
         }
-        @$start == @$size or $et->WarnOnce('Incorrect sample start/size count'), return;
+        @$start == @$size or $et->Warn('Incorrect sample start/size count'), return;
         # process as chunks if we are only interested in calculating hash
         if ($type eq 'soun' or $type eq 'vide') {
             $start = $stco;
@@ -1332,7 +1335,7 @@ Sample:     for ($i=0; ; ) {
         $hdrFmt = ($hdrLen == 4 ? 'N' : $hdrLen == 2 ? 'n' : 'C');
         require Image::ExifTool::H264;
     }
-    
+
     # loop through all samples
     for ($i=0; $i<@$start and $i<@$size; ++$i) {
 
@@ -1352,11 +1355,11 @@ Sample:     for ($i=0; ; ) {
             }
         }
         # read the sample data
-        $raf->Seek($$start[$i], 0) or $et->WarnOnce("Seek error in $type data"), next;
+        $raf->Seek($$start[$i], 0) or $et->Warn("Seek error in $type data"), next;
         my $buff;
         my $n = $raf->Read($buff, $size);
         unless ($n == $size) {
-            $et->WarnOnce("Error reading $type data");
+            $et->Warn("Error reading $type data");
             next unless $n;
             $size = $n;
         }
@@ -1560,7 +1563,7 @@ sub ProcessFreeGPS($$$)
     my ($et, $dirInfo, $tagTbl) = @_;
     my $dataPt = $$dirInfo{DataPt};
     my $dirLen = length $$dataPt;
-    my ($yr, $mon, $day, $hr, $min, $sec, $stat, $lbl, $ddd);
+    my ($yr, $mon, $day, $hr, $min, $sec, $ss, $stat, $lbl, $ddd, $done);
     my ($lat, $latRef, $lon, $lonRef, $spd, $trk, $alt, @acc, @xtra);
 
     return 0 if $dirLen < 82;
@@ -1699,7 +1702,7 @@ sub ProcessFreeGPS($$$)
                 ($sec,$min,$hr,$day,$mon,$yr) = gmtime($time);
                 $yr += 1900;
                 ++$mon;
-                $et->WarnOnce('Converting GPSDateTime to UTC based on local time zone',1);
+                $et->Warn('Converting GPSDateTime to UTC based on local time zone',1);
             }
             $lat = GetFloat($dataPt, 0x2c);
             $lon = GetFloat($dataPt, 0x30);
@@ -1744,36 +1747,69 @@ sub ProcessFreeGPS($$$)
                     ($lon = DecryptLucky($ln, $key)) =~ /^\d{1,5}\.\d+$/ or undef($lon), next;
                     last;
                 }
-                $lon or $et->WarnOnce('Unknown encryption for latitude/longitude');
+                $lon or $et->Warn('Unknown encryption for latitude/longitude');
             }
         }
 
-    } elsif ($$dataPt =~ /^.{21}\0\0\0A([NS])([EW])/s) {
+    } elsif ($$dataPt =~ /^(.{16}|.{48}|.{80})LIGOGPSINFO\0/s and length($$dataPt) >= length($1) + 0x84) {
 
         $debug and $et->FoundTag(GPSType => 5);
-        # also decode 'gpmd' chunk from Kingslim D4 dashcam videos
-        # 0000: 0a 00 00 00 0b 00 00 00 07 00 00 00 e5 07 00 00 [................]
-        # 0010: 06 00 00 00 03 00 00 00 41 4e 57 31 91 52 83 45 [........ANW1.R.E]
-        # 0020: 15 70 fe c5 29 5c c3 41 ae c7 af 42 00 00 d1 be [.p..)\.A...B....]
-        # 0030: 00 00 80 3b 00 00 2c 3e 00 00 00 00 00 00 00 00 [...;..,>........]
-        # 0040: 00 00 00 00 00 00 00 00 00 00 00 00 26 26 26 26 [............&&&&]
-        # 0050: 4c 49 47 4f 47 50 53 49 4e 46 4f 00 00 00 00 05 [LIGOGPSINFO.....]
-        # 0060: 01 00 00 00 23 23 23 23 75 00 00 00 c0 22 20 20 [....####u...."  ]
-        # 0070: 20 f0 12 10 12 21 e5 0e 10 12 2f 90 10 13 01 f2 [ ....!..../.....]
-        ($latRef, $lonRef) = ($1, $2);
-        ($hr,$min,$sec,$yr,$mon,$day) = unpack("V6", $$dataPt);
-        # lat/lon aren't decoded properly, but spd,trk,acc are
-        $lat = GetFloat($dataPt, 0x1c);
-        $lon = GetFloat($dataPt, 0x20);
-        $et->VPrint(0, sprintf("Raw lat/lon = %.9f %.9f\n", $lat, $lon));
-        $et->WarnOnce('GPSLatitude/Longitude encryption is not yet known, so these will be wrong');
-        $lat = abs $lat;
-        $lon = abs $lon;
-        $spd = GetFloat($dataPt, 0x24) * $knotsToKph; # (convert knots to km/h)
-        $trk = GetFloat($dataPt, 0x28);
-        $acc[0] = GetFloat($dataPt, 0x2c);
-        $acc[1] = GetFloat($dataPt, 0x30);
-        $acc[2] = GetFloat($dataPt, 0x34);
+        my $pos = length $1;
+        # iiway s1 dual dash cam
+        #  0000: 00 00 40 00 66 72 65 65 47 50 53 20 f0 03 00 00 [..@.freeGPS ....]
+        #  0010: 4c 49 47 4f 47 50 53 49 4e 46 4f 00 00 00 00 05 [LIGOGPSINFO.....]
+        #  0020: 0a 00 00 00 23 23 23 23 6a 00 00 00 c0 20 20 20 [....####j....   ]
+        #  0030: 20 f0 12 10 12 22 e1 0e 10 12 2f 90 10 13 02 f2 [ ...."..../.....]
+        # ABASK A8 4K Dashcam (different scaling factor)
+        #  0000: 00 00 40 00 66 72 65 65 47 50 53 20 f0 03 00 00 [..@.freeGPS ....]
+        #  0010: 4c 49 47 4f 47 50 53 49 4e 46 4f 00 00 00 00 05 [LIGOGPSINFO.....]
+        #  0020: 00 00 00 00 23 23 23 23 69 00 00 00 c0 20 20 20 [....####i....   ]
+        #  0030: 20 f0 12 10 12 23 e5 0e 10 12 2f 99 10 11 02 f2 [ ....#..../.....]
+        # XGODY 12" 4K Dashcam
+        #  0000: 00 00 00 a8 66 72 65 65 47 50 53 20 98 00 00 00 [....freeGPS ....]
+        #  0010: 4c 49 47 4f 47 50 53 49 4e 46 4f 00 00 00 00 05 [LIGOGPSINFO.....]
+        #  0020: cd 61 00 00 23 23 23 23 6d 00 00 00 c1 ec 41 20 [.a..####m.....A ]
+        #  0030: 20 f0 12 10 12 24 e5 0e 10 11 2f 92 10 12 00 f6 [ ....$..../.....]
+        # Rexing dashcam V1GW-4K
+        #  0000: 00 00 40 00 66 72 65 65 47 50 53 20 f0 03 00 00 [..@.freeGPS ....]
+        #  0010: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 [................]
+        #  0020: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 [................]
+        #  0030: 4c 49 47 4f 47 50 53 49 4e 46 4f 00 00 00 00 05 [LIGOGPSINFO.....]
+        #  0040: 01 00 00 00 23 23 23 23 73 00 00 00 c0 20 20 20 [....####s....   ]
+        #  0050: 20 f0 12 10 12 23 e5 0e 10 12 2f 95 10 12 01 f3 [ ....#..../.....]
+        #  0060: 16 18 10 26 b4 1a 10 04 f2 6e 18 12 20 f0 0e 11 [...&.....n.. ...]
+        #  0070: 13 22 b3 16 10 01 fb 76 18 10 24 fa 0e 11 10 22 [.".....v..$...."]
+        # Kingslim D4 dashcam
+        #  0000: 0a 00 00 00 0b 00 00 00 07 00 00 00 e5 07 00 00 [................]
+        #  0010: 06 00 00 00 03 00 00 00 41 4e 57 31 91 52 83 45 [........ANW1.R.E]
+        #  0020: 15 70 fe c5 29 5c c3 41 ae c7 af 42 00 00 d1 be [.p..)\.A...B....]
+        #  0030: 00 00 80 3b 00 00 2c 3e 00 00 00 00 00 00 00 00 [...;..,>........]
+        #  0040: 00 00 00 00 00 00 00 00 00 00 00 00 26 26 26 26 [............&&&&]
+        #  0050: 4c 49 47 4f 47 50 53 49 4e 46 4f 00 00 00 00 05 [LIGOGPSINFO.....]
+        #  0060: 01 00 00 00 23 23 23 23 75 00 00 00 c0 22 20 20 [....####u...."  ]
+        #  0070: 20 f0 12 10 12 21 e5 0e 10 12 2f 90 10 13 01 f2 [ ....!..../.....]
+        my %dirInfo = ( DataPt => $dataPt, DirStart => $pos, DirName => "LigoGPS_$pos" );
+        # (this is weak, but the only difference I could find between these 2 headers)
+        # (NOTE: ../testpics/gps_video/forum16229.mp4 uses this word for a counter!)
+        $$et{LigoGPSScale} = 3 if $pos == 16 and $$dataPt =~ /^.{12}\xf0\x03\0\0.{16}\0{4}/s;
+        ProcessLigoGPS($et, \%dirInfo, $tagTbl);
+        $done = 1;
+
+        # also... when offset is 0x50 (Kingslim), the GPS also exists in this format:
+        # ($latRef, $lonRef) = ($1, $2);
+        # ($hr,$min,$sec,$yr,$mon,$day) = unpack("V6", $$dataPt);
+        # # lat/lon aren't decoded properly, but spd,trk,acc are
+        # $lat = GetFloat($dataPt, 0x1c);
+        # $lon = GetFloat($dataPt, 0x20);
+        # $et->VPrint(0, sprintf("Raw lat/lon = %.9f %.9f\n", $lat, $lon));
+        # $et->Warn('GPSLatitude/Longitude encryption is not yet known, so these will be wrong');
+        # $lat = abs $lat;
+        # $lon = abs $lon;
+        # $spd = GetFloat($dataPt, 0x24) * $knotsToKph; # (convert knots to km/h)
+        # $trk = GetFloat($dataPt, 0x28);
+        # $acc[0] = GetFloat($dataPt, 0x2c);
+        # $acc[1] = GetFloat($dataPt, 0x30);
+        # $acc[2] = GetFloat($dataPt, 0x34);
 
     } elsif ($$dataPt =~ /^.{60}A\0{3}.{4}([NS])\0{3}.{4}([EW])\0{3}/s) {
 
@@ -1821,14 +1857,14 @@ sub ProcessFreeGPS($$$)
         # 0060: 42 3e 49 49 40 42 45 3c 55 3c 45 47 3e 45 43 41 [B>II@BE<U<EG>ECA]
         # decipher $GPRMC by subtracting 16 from each character value
         $_ = pack 'C*', map { $_>=16 and $_-=16 } unpack('x60C80', $$dataPt);
-        unless (/[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+)/) {
-            SetByteOrder($oldOrder);
-            return 0;
+        if (/[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+)/) {
+            ($yr,$mon,$day,$hr,$min,$sec,$lat,$latRef,$lon,$lonRef) = ($13,$12,$11,$1,$2,$3,$5,$6,$7,$8);
+            $yr += ($yr >= 70 ? 1900 : 2000);
+            $spd = $9 * $knotsToKph if length $9;
+            $trk = $10 if length $10;
+        } else {
+            $done = 1;
         }
-        ($yr,$mon,$day,$hr,$min,$sec,$lat,$latRef,$lon,$lonRef) = ($13,$12,$11,$1,$2,$3,$5,$6,$7,$8);
-        $yr += ($yr >= 70 ? 1900 : 2000);
-        $spd = $9 * $knotsToKph if length $9;
-        $trk = $10 if length $10;
 
     } elsif ($$dataPt =~ /^.{64}[\x01-\x0c]\0{3}[\x01-\x1f]\0{3}A[NS][EW]\0{5}/s) {
 
@@ -1857,7 +1893,7 @@ sub ProcessFreeGPS($$$)
         ($hr,$min,$sec,$yr,$mon,$day,$stat,$latRef,$lonRef) =
             unpack('x48V6a1a1a1x1', $$dataPt);
 
-        $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');
         # (see https://exiftool.org/forum/index.php?topic=11320.0)
 
         $spd = GetFloat($dataPt, 0x60);
@@ -1865,7 +1901,7 @@ sub ProcessFreeGPS($$$)
         $lat = GetDouble($dataPt, 0x50);    # latitude is here, but encrypted somehow
         $lon = GetDouble($dataPt, 0x58);    # longitude is here, but encrypted somehow
         $ddd = 1; # don't convert until we know what the format is
-        #my $serialNum = substr($$dataPt, 0x68, 20);
+        #my $serialNum = substr($$dataPt, 0x68, 20); # (confirmed)
 
     } elsif ($$dataPt =~ /^.{12}\xac\0\0\0.{44}(.{72})/s) {
 
@@ -1881,15 +1917,14 @@ sub ProcessFreeGPS($$$)
         #  0070: 43 41 3c 40 42 40 46 42 40 3c 3c 3c 51 3a 47 46 [CA<@B@FB@<<<Q:GF]
         #  0080: 00 2a 36 35 00 00 00 00 00 00 00 00 00 00 00 00 [.*65............]
 
-        $et->WarnOnce("Can't yet decrypt EACHPAI timed GPS", 1);
+        $et->Warn("Can't yet decrypt EACHPAI timed GPS", 1);
         # (see https://exiftool.org/forum/index.php?topic=5095.msg61266#msg61266)
-        SetByteOrder($oldOrder);
-        return 1;
+        $done = 1;
 
-        my $time = pack 'C*', map { $_ ^= 0 } unpack 'C*', $1;
-        # bytes 7-12 are the timestamp in ASCII HHMMSS after xor-ing with 0x70
-        substr($time,7,6) = pack 'C*', map { $_ ^= 0x70 } unpack 'C*', substr($time,7,6);
-        # (other values are currently unknown)
+      #  my $time = pack 'C*', map { $_ ^= 0 } unpack 'C*', $1;
+      #  # bytes 7-12 are the timestamp in ASCII HHMMSS after xor-ing with 0x70
+      #  substr($time,7,6) = pack 'C*', map { $_ ^= 0x70 } unpack 'C*', substr($time,7,6);
+      #  # (other values are currently unknown)
 
     } elsif ($$dataPt =~ /^.{64}A([NS])([EW])\0/s) {
 
@@ -1905,17 +1940,17 @@ sub ProcessFreeGPS($$$)
         #  0070: 05 00 00 00 7f 00 00 00 07 01 00 00 00 00 00 00 [................]
         ($latRef, $lonRef) = ($1, $2);
         ($yr,$mon,$day,$hr,$min,$sec,@acc) = unpack('x68V6x20V3', $$dataPt);
-        unless ($mon>=1 and $mon<=12 and $day>=1 and $day<=31) {
-            SetByteOrder($oldOrder);
-            return 0;
+        if ($mon>=1 and $mon<=12 and $day>=1 and $day<=31) {
+            # (not sure about acc scaling)
+            @acc = map { SignedInt32 / 1000 } @acc;
+            $lon = GetFloat($dataPt, 0x5c);
+            $lat = GetFloat($dataPt, 0x60);
+            $spd = GetFloat($dataPt, 0x64) * $knotsToKph;
+            $trk = GetFloat($dataPt, 0x68);
+            $alt = GetFloat($dataPt, 0x6c);
+        } else {
+            $done = 1;
         }
-        # (not sure about acc scaling)
-        @acc = map { SignedInt32 / 1000 } @acc;
-        $lon = GetFloat($dataPt, 0x5c);
-        $lat = GetFloat($dataPt, 0x60);
-        $spd = GetFloat($dataPt, 0x64) * $knotsToKph;
-        $trk = GetFloat($dataPt, 0x68);
-        $alt = GetFloat($dataPt, 0x6c);
 
     } elsif (substr($$dataPt,0x45,3) eq 'ATC') {
 
@@ -1960,7 +1995,7 @@ ATCRec: for ($recPos = 0x30; $recPos + 52 < $dirLen; $recPos += 52) {
             my $i;
             for ($i=0; $i<@dateMax; ++$i) {
                 next if $now[$i] <= $dateMax[$i];
-                $et->WarnOnce('Invalid GPS date/time');
+                $et->Warn('Invalid GPS date/time');
                 next ATCRec;    # ignore this record
             }
             # look for next ATC record in temporal sequence
@@ -2027,8 +2062,7 @@ ATCRec: for ($recPos = 0x30; $recPos + 52 < $dirLen; $recPos += 52) {
         }
         # save position of most recent record (needed when parsing the next freeGPS block)
         $$et{FreeGPS2}{RecentRecPos} = $lastRecPos;
-        SetByteOrder($oldOrder);
-        return 1;
+        $done = 1;
 
     } elsif ($$dataPt =~ /^.{60}A\0.{10}([NS])\0.{14}([EW])\0/s and $dirLen >= 0x88) {
 
@@ -2065,6 +2099,11 @@ ATCRec: for ($recPos = 0x30; $recPos + 52 < $dirLen; $recPos += 52) {
 
         $debug and $et->FoundTag(GPSType => 13);
         # INNOVV MP4 video (same format as INNOVV TS)
+        #  0000: 00 00 40 00 66 72 65 65 47 50 53 20 f0 03 00 00 [..@.freeGPS ....]
+        #  0010: 41 4e 45 00 e4 56 96 45 86 b1 ca 44 5c 8f e2 40 [ANE..V.E...D\..@]
+        #  0020: 33 33 58 43 c3 00 00 00 30 00 00 00 a0 fe ff ff [33XC....0.......]
+        #  0030: 41 4e 45 00 e3 56 96 45 82 b1 ca 44 5c 8f fa 40 [ANE..V.E...D\..@]
+        #  0040: c3 75 56 43 8c ff ff ff 8c 00 00 00 c3 fd ff ff [.uVC............]
         while ($$dataPt =~ /(A[NS][EW]\0.{28})/sg) {
             my $dat = $1;
             $lat = abs(GetFloat(\$dat, 4)); # (abs just to be safe)
@@ -2080,10 +2119,9 @@ ATCRec: for ($recPos = 0x30; $recPos + 52 < $dirLen; $recPos += 52) {
             $et->HandleTag($tagTbl, GPSTrack     => $trk);
             $et->HandleTag($tagTbl, Accelerometer => "@acc");
         }
-        SetByteOrder($oldOrder);
-        return 1;
+        $done = 1;
 
-    } elsif ($$dataPt =~ /^.{24}A([NS])([EW])/s) {
+    } elsif ($$dataPt =~ /^.{20}[\0-\x18][\0-\x3b]{2}[\0-\x09]A([NS])([EW])/s) {
 
         $debug and $et->FoundTag(GPSType => 14);
         # XBHT motorcycle dashcam Model XB702
@@ -2092,12 +2130,11 @@ ATCRec: for ($recPos = 0x30; $recPos + 52 < $dirLen; $recPos += 52) {
         #  0020: 44 3d c5 02 48 6d ff 07 df 03 00 00 6b 00 00 00 [D=..Hm......k...]
         #  0030: 00 00 00 00 00 17 05 11 0d 25 18 01 41 4e 45 64 [.........%..ANEd]
         #  0040: 8b 3f 00 00 30 3d c5 02 50 6d ff 07 df 03 00 00 [.?..0=..Pm......]
-        while ($$dataPt =~ /(.{8}A[NS][EW].{25})/sg) {
+        while ($$dataPt =~ /(.{7}[\0-\x09]A[NS][EW].{25})/sg) {
             my $dat = $1;
-            my ($yr,$mon,$day,$hr,$min,$sec,$ss,$latRef,$lonRef,$lat,$lon,$spd) =
+            ($yr,$mon,$day,$hr,$min,$sec,$ss,$latRef,$lonRef,$lat,$lon,$spd) =
                 unpack('xC7xCCx5VVx4v', $dat);
             $yr += 2000;  $lat /= 1e4;  $lon /= 1e4;
-            $ss = 0 if $ss > 9; # (just in case)
             ConvertLatLon($lat, $lon);
             $$et{DOC_NUM} = ++$$et{DOC_COUNT};
             my $time = sprintf('%.4d:%.2d:%.2d %.2d:%.2d:%.2d.%d',$yr,$mon,$day,$hr,$min,$sec,$ss);
@@ -2106,8 +2143,7 @@ ATCRec: for ($recPos = 0x30; $recPos + 52 < $dirLen; $recPos += 52) {
             $et->HandleTag($tagTbl, GPSLongitude => $lon * ($lonRef eq 'W' ? -1 : 1));
             $et->HandleTag($tagTbl, GPSSpeed     => $spd);
         }
-        SetByteOrder($oldOrder);
-        return 1;
+        $done = 1;
 
     } elsif ($$dataPt =~ /^.{28}A.{11}([NS]).{15}([EW])/s) {
 
@@ -2231,7 +2267,7 @@ ATCRec: for ($recPos = 0x30; $recPos + 52 < $dirLen; $recPos += 52) {
         }
 
     } elsif ($$dataPt =~ m/^.{30}A.{20}VV/) {
-    
+
         $debug and $et->FoundTag(GPSType => 19);
         # 70mai A810 dashcam (note: no timestamps in the samples I have)
         #  0000: 00 00 40 00 66 72 65 65 47 50 53 20 ed 01 00 00 [..@.freeGPS ....]
@@ -2295,14 +2331,14 @@ ATCRec: for ($recPos = 0x30; $recPos + 52 < $dirLen; $recPos += 52) {
             $et->HandleTag($tagTbl, GPSTrack     => $trk);
             last if $pos += 0x20 > length($$dataPt) - 0x1e;
         }
-        SetByteOrder($oldOrder);
-        return $$et{DOC_NUM} ? 1 : 0;   # return 0 if nothing extracted
+        $done = 1;
     }
+    SetByteOrder($oldOrder);
+    return $$et{DOC_NUM} ? 1 : 0 if $done;
+    return 0 if defined $yr and $mon < 1 or $mon > 12;  # quick sanity check
 #
 # save tag values extracted by above code
 #
-    SetByteOrder($oldOrder);
-    return 0 if defined $yr and $mon < 1 or $mon > 12;  # quick sanity check
     FoundSomething($et, $tagTbl, $$dirInfo{SampleTime}, $$dirInfo{SampleDuration});
     $sec = '0' . $sec unless $sec =~ /^\d{2}/;   # pad integer part of seconds to 2 digits
     if (defined $yr) {
@@ -2442,8 +2478,8 @@ sub Process_tx3g($$$)
     if ($text =~ /^HOME\(/) {
         # --- sample text from Autel Evo II drone ---
         # HOME(W: 109.318642, N: 40.769371) 2023-09-12 10:28:07
-        # GPS(W: 109.339287, N: 40.768574, 2371.76m) 
-        # HDR ISO:100 SHUTTER:1000 EV:-0.7 F-NUM:1.8 
+        # GPS(W: 109.339287, N: 40.768574, 2371.76m)
+        # HDR ISO:100 SHUTTER:1000 EV:-0.7 F-NUM:1.8
         # F.PRY (1.0\xc2\xb0, -3.7\xc2\xb0, -59.0\xc2\xb0), G.PRY (-51.1\xc2\xb0, 0.0\xc2\xb0, -58.9\xc2\xb0)
         my $line;
         foreach $line (split /\x0a/, $text) {
@@ -2520,7 +2556,7 @@ sub Process_mebx($$$)
                 Size   => $len - 8,
             );
         } else {
-            $et->WarnOnce('No key information for mebx ID ' . PrintableTagID($id,1));
+            $et->Warn('No key information for mebx ID ' . PrintableTagID($id,1));
         }
     }
     return 1;
@@ -2643,7 +2679,7 @@ sub Process_gdat($$$)
 {
     my ($et, $dirInfo, $tagTbl) = @_;
     unless ($$et{OPTIONS}{ExtractEmbedded}) {
-        $et->WarnOnce('Use the ExtractEmbedded option to extract timed GPSData',3);
+        $et->Warn('Use the ExtractEmbedded option to extract timed GPSData',3);
         return 0;
     }
     my $dataPt = $$dirInfo{DataPt};
@@ -2694,13 +2730,220 @@ sub Process_nbmt($$$)
         delete $$et{NoMoreTextDecoding};
         delete $$et{DOC_NUM};
     } else {
-        $et->WarnOnce('Use the ExtractEmbedded option to extract timed GPSData',3);
+        $et->Warn('Use the ExtractEmbedded option to extract timed GPSData',3);
+    }
+    return 1;
+}
+
+#------------------------------------------------------------------------------
+# Un-do LIGOGPS fuzzing
+# Inputs: 0) fuzzed latitude, 1) fuzzed longitude, 2) scale factor
+# Returns: 0) latitude, 1) longitude
+sub UnfuzzLigoGPS($$$)
+{
+    my ($lat, $lon, $scl) = @_;
+    my $lat2 = int($lat / 10) * 10;
+    my $lon2 = int($lon / 10) * 10;
+    return($lat2 + ($lon - $lon2) * $scl, $lon2 + ($lat - $lat2) * $scl);
+}
+
+#------------------------------------------------------------------------------
+# Decrypt LIGOGPSINFO record (starting with "####")
+# Inputs: 0) encrypted GPS record incuding 8-byte header
+# Returns: decrypted record including 4-byte uint32 header, or undef on error
+sub DecryptLigoGPS($)
+{
+    my $str = shift;
+    my $num = unpack('x4V',$str);
+    return undef if $num < 4;
+    $num = 0x84 if $num > 0x84; # (be safe)
+    my @in = unpack("x8C$num",$str);
+    my @out;
+    while (@in) {
+        my $b = shift @in;
+        my $steeringBits = $b & 0xe0;
+        if ($steeringBits >= 0xc0) {
+            return undef if @in < 4;
+            push @out, (shift(@in) | $b & 0x01) ^ 0x20,
+                       (shift(@in) | $b & 0x02) ^ 0x20,
+                       (shift(@in) | $b & 0x0c) ^ 0x20,
+                        shift(@in) ^ 0x20 | $b & 0x30;
+        } elsif ($steeringBits >= 0x40) {
+            return undef if @in < 3;
+            if ($steeringBits == 0x40) {
+                push @out, 0x20,
+                           (shift(@in) | $b & 0x01) ^ 0x20,
+                           (shift(@in) | $b & 0x06) ^ 0x20,
+                           (shift(@in) | $b & 0x18) ^ 0x20;
+            } elsif ($steeringBits == 0x60) {
+                push @out, (shift(@in) | $b & 0x03) ^ 0x20,
+                           0x20,
+                           (shift(@in) | $b & 0x04) ^ 0x20,
+                           (shift(@in) | $b & 0x18) ^ 0x20;
+            } elsif ($steeringBits == 0x80) {
+                push @out, (shift(@in) | $b & 0x03) ^ 0x20,
+                           (shift(@in) | $b & 0x0c) ^ 0x20,
+                           0x20,
+                           (shift(@in) | $b & 0x10) ^ 0x20;
+            } else {
+                push @out, (shift(@in) | $b & 0x01) ^ 0x20,
+                           (shift(@in) | $b & 0x06) ^ 0x20,
+                           (shift(@in) | $b & 0x18) ^ 0x20,
+                           0x20;
+            }
+        } elsif ($steeringBits == 0x00) {
+            return undef if @in < 1;
+            push @out, shift(@in) | $b & 0x13;
+        } else {
+            return undef;   # (shouldn't happen)
+        }
+    }
+    return pack 'C*', @out;
+}
+
+#------------------------------------------------------------------------------
+# Decipher and parse LIGOGPSINFO record (starting with "####")
+# Inputs: 0) ExifTool ref, 1) enciphered string, 2) tag table ref
+# Returns: true if this looked like an enciphered string
+# Notes: handles contained tags, but may defer handling until full cipher is known
+sub DecipherLigoGPS($$$)
+{
+    my ($et, $str, $tagTbl) = @_;
+
+    # (enciphered characters must be in the range 0x30-0x5f ('0' - '_'))
+    $str =~ m[^####.{4}([0-_])[0-_]{3}/[0-_]{2}/[0-_]{2} ..([0-_])..([0-_]).([0-_]) ]s or return undef;
+    return undef unless $2 eq $3;   # (colons in time string must be the same)
+
+    my $cipherInfo = $$et{LigoCipher};
+    $cipherInfo or $cipherInfo = $$et{LigoCipher} = { cache => [ ], secs => [ ], two => -1 };
+    my $decipher = $$cipherInfo{decipher};
+    my $cache = $$cipherInfo{cache};
+
+    # determine the cipher code table based on the advancing 1's digit of seconds
+    unless ($decipher) {
+        push @$cache, $str;     # cache records until we can decipher them
+        my ($millennium, $colon) = ($1, $2);
+        # determine the Caesar cipher lookup table
+        # (only characters in range 0x30-0x5f are encrypted)
+        my $secs = $$cipherInfo{secs};
+        push @$secs, $4 unless @$secs and $${secs}[-1] eq $4;
+        $$cipherInfo{two} = $#$secs if $4 eq $millennium; # save index of enciphered '2'
+        return 1 if @$secs < 10; # must cache the data until we know all 10 digits
+        my $two = $$cipherInfo{two};        # (index of '2' in the array)
+        my %decipher = ( $colon => ':' );   # (':' is the time separator)
+        foreach (0..9) {
+            my $ch = $$secs[($_ + $two - 2 + 10) % 10];
+            if ($two < 0 or defined $decipher{$ch}) { # (must be a unique code for each digit)
+                @$cipherInfo{'secs','two'} = ([ ], -1); # reset and try again
+                $et->Warn('Hiccup while deciphering LIGOGPSINFO');
+                return 1;
+            }
+            $decipher{$ch} = chr($_ + 0x30);
+        }
+        # also know the lat/lon quadrant from the signs of the coordinates
+        if ($str =~ / ([0-_])$colon(-?).*? ([0-_])$colon(-?)/) {
+            @decipher{$1,$3} = ($2 ? 'S' : 'N', $4 ? 'W' : 'E');
+        }
+        # fill in unknown entries with '?' (only chars 0x30-0x5f are enciphered)
+        defined $decipher{$_} or $decipher{$_} = '?' foreach map(chr, 0x30..0x5f);
+        $decipher = $$cipherInfo{decipher} = \%decipher;
+        $str = shift @$cache;   # start deciphering at oldest cache entry
+    }
+
+    # apply reverse Caesar cipher and extract GPS information
+    do {
+        my $pre = substr($str, 4, 4);        # save second 4 bytes of header
+        ($str = substr($str,8)) =~ s/\0+$//; # remove 8-byte header and null padding
+        $str =~ s/([0-_])/$$decipher{$1}/g;  # decipher
+        if ($$et{OPTIONS}{Verbose} > 1) {
+            $et->VPrint(1, "$$et{INDENT}\(Deciphered: ".unpack('H8',$pre)." $str)\n");
+        }
+        # add back leading 4 bytes (int16u counter plus 2 unknown bytes), and parse
+        # (not fuzzed in my only sample when found in standard 'skip' atom)
+        ParseLigoGPS($et, "$pre$str", $tagTbl, $$et{LigoType} eq 'LigoGPSInfo');
+    } while $str = shift @$cache;
+
+    return 1;
+}
+
+#------------------------------------------------------------------------------
+# Parse decrypted/deciphered (but not defuzzed) LIGOGPSINFO record
+# (record starts with 4-byte int32u counter followed by date/time, etc)
+# Inputs: 0) ExifTool ref, 1) GPS string, 2) tag table ref, 3) not fuzzed
+# Returns: nothing
+sub ParseLigoGPS($$$;$)
+{
+    my ($et, $str, $tagTbl, $noFuzz) = @_;
+
+    # example string input
+    # "....2022/09/19 12:45:24 N:31.285065 W:124.759483 46.93 km/h x:-0.000 y:-0.000 z:-0.000"
+    unless ($str=~ /^.{4}(\S+ \S+)\s+([NS?]):(-?)([.\d]+)\s+([EW?]):(-?)([\.\d]+)\s+([.\d]+)/s) {
+        $et->Warn('LIGOGPSINFO format error');
+        return;
+    }
+    my ($time,$latRef,$latNeg,$lat,$lonRef,$lonNeg,$lon,$spd) = ($1,$2,$3,$4,$5,$6,$7,$8);
+    my %gpsScl = ( 1 => 1.524855137, 2 => 1.456027985, 3 => 1.15368 );
+    my $spdScl = $noFuzz ? $knotsToKph : 1.85407333;
+    $$et{DOC_NUM} = ++$$et{DOC_COUNT};
+    $time =~ tr(/)(:);
+    # convert from DDMM.MMMMMM to DD.DDDDDD if necessary
+    # (speed wasn't scaled in my 1 sample with this format)
+    $lat =~ /^\d{3}/ and ConvertLatLon($lat,$lon), $spdScl = 1;
+    unless ($noFuzz) { # unfuzz the coordinates if necessary
+        my $scl = $$et{OPTIONS}{LigoGPSScale} || $$et{LigoGPSScale} || 1;
+        $scl = $gpsScl{$scl} if $gpsScl{$scl};
+        ($lat, $lon) = UnfuzzLigoGPS($lat, $lon, $scl);
+    }
+    # a final sanity check
+    ($lat > 90 or $lon > 180) and $et->Warn('LIGOGPSINFO coordinates out of range'), return;
+    $$et{SET_GROUP1} = 'LIGO';
+    $et->HandleTag($tagTbl, 'GPSDateTime',  $time);
+    # (ignore N/S/E/W if coordinate is signed)
+    $et->HandleTag($tagTbl, 'GPSLatitude',  $lat * (($latNeg or $latRef eq 'S') ? -1 : 1));
+    $et->HandleTag($tagTbl, 'GPSLongitude', $lon * (($lonNeg or $lonRef eq 'W') ? -1 : 1));
+    $et->HandleTag($tagTbl, 'GPSSpeed',     $spd * $spdScl);
+    $et->HandleTag($tagTbl, 'GPSTrack', $1) if $str =~ /\bA:(\S+)/;
+    # (have a sample where tab is used to separate acc components)
+    $et->HandleTag($tagTbl, 'Accelerometer',"$1 $2 $3") if $str =~ /x:(\S+)\sy:(\S+)\sz:(\S+)/;
+    $et->HandleTag($tagTbl, 'M', $1) if $str =~ /\bM:(\S+)/;
+    $et->HandleTag($tagTbl, 'H', $1) if $str =~ /\bH:(\S+)/;
+    delete $$et{SET_GROUP1};
+}
+
+#------------------------------------------------------------------------------
+# Process LIGOGPSINFO data (non-JSON format)
+# Inputs: 0) ExifTool object ref, 1) dirInfo ref, 2) tag table ref
+#         3) 1=LIGOGPS lat/lon/spd weren't fuzzed
+# Returns: 1 on success
+sub ProcessLigoGPS($$$;$)
+{
+    my ($et, $dirInfo, $tagTbl, $noFuzz) = @_;
+    my $dataPt = $$dirInfo{DataPt};
+    my $pos = ($$dirInfo{DirStart} || 0) + 0x14;
+    my $cipherInfo = $$et{LigoCipher};
+    return undef if $pos > length $$dataPt;
+    $$et{LigoType} = $$dirInfo{DirName} || 'LigoGPS';
+    push @{$$et{PATH}}, $$et{LigoType} unless $$dirInfo{DirID};
+    # not fuzzed if header is "LIGOGPSINFO\0\0\0\0\x01" (BlueSkySeaDV688)
+    $noFuzz = 1 if substr($$dataPt, $pos-8, 4) eq "\0\0\0\x01";
+    $et->VerboseDir($$et{LigoType});
+    for (; $pos + 0x84 <= length($$dataPt); $pos+=0x84) {
+        my $dat = substr($$dataPt, $pos, 0x84);
+        $dat =~ /^####/ or next; # (have seen blank records filled with zeros, so keep trying)
+        # decipher if we already know the encryption
+        $cipherInfo and $$cipherInfo{decipher} and DecipherLigoGPS($et, $dat, $tagTbl) and next;
+        my $str = DecryptLigoGPS($dat);
+        defined $str or DecipherLigoGPS($et, $dat, $tagTbl), next;   # try to decipher
+        $et->VPrint(1, "$$et{INDENT}\(Decrypted: ",unpack('V',$str),' ',substr($str,4),")\n") if $$et{OPTIONS}{Verbose} > 1;
+        ParseLigoGPS($et, $str, $tagTbl, $noFuzz);
     }
+    pop @{$$et{PATH}} unless $$dirInfo{DirID};
+    delete $$et{DOC_NUM};
     return 1;
 }
 
 #------------------------------------------------------------------------------
-# Process LIGOGPS JSON-format GPS from Yada RoadCam Pro 4K BT58189
+# Process LIGOGPSINFO JSON-format GPS (Yada RoadCam Pro 4K BT58189)
 # Inputs: 0) ExifTool ref, 1) dirInfo ref, 2) tag table ref
 # Returns: 1 on success
 # Sample data (chained 512-byte records starting like this):
@@ -2711,13 +2954,14 @@ sub Process_nbmt($$$)
 # 0040: 22 3a 20 22 32 30 32 33 22 2c 20 22 4d 6f 6e 74 [": "2023", "Mont]
 # 0050: 68 22 3a 20 22 31 32 22 2c 20 22 44 61 79 22 3a [h": "12", "Day":]
 # 0060: 20 22 32 38 22 2c 20 22 73 74 61 74 75 73 22 3a [ "28", "status":]
-sub ProcessLIGO_JSON($$$)
+sub ProcessLigoJSON($$$)
 {
     my ($et, $dirInfo, $tagTbl) = @_;
     my $dataPt = $$dirInfo{DataPt};
     my $dirLen = $$dirInfo{DirLen};
     require Image::ExifTool::Import;
     $et->VerboseDir('LIGO_JSON', undef, length($$dataPt));
+    $$et{SET_GROUP1} = 'LIGO';
     while ($$dataPt =~ /LIGOGPSINFO (\{.*?\})/g) {
         my $json = $1;
         my %dbase;
@@ -2767,11 +3011,12 @@ sub ProcessLIGO_JSON($$$)
             $et->HandleTag($tagTbl, GPSLongitude2 => $lon);
         }
         unless ($et->Options('ExtractEmbedded')) {
-            $et->WarnOnce('Use the ExtractEmbedded option to extract all timed GPS',3);
+            $et->Warn('Use the ExtractEmbedded option to extract all timed GPS',3);
             last;
         }
     }
     delete $$et{DOC_NUM};
+    delete $$et{SET_GROUP1};
     return 1;
 }
 
@@ -2814,7 +3059,7 @@ sub ProcessKenwood($$$)
         }
         $et->HandleTag($tagTbl, Accelerometer => "@acc") if @acc;
         unless ($et->Options('ExtractEmbedded')) {
-            $et->WarnOnce('Use the ExtractEmbedded option to extract all timed GPS',3);
+            $et->Warn('Use the ExtractEmbedded option to extract all timed GPS',3);
             last;
         }
     }
@@ -2937,7 +3182,7 @@ sub ProcessKenwoodTrailer($$$)
     $raf->Read($buff, 14) and $buff eq 'CCCCCCCCCCCCCC' or return 0;
     $et->VerboseDir('Kenwood trailer', undef, undef);
     unless ($$et{OPTIONS}{ExtractEmbedded}) {
-        $et->WarnOnce('Use the ExtractEmbedded option to extract timed GPSData from Kenwood trailer',3);
+        $et->Warn('Use the ExtractEmbedded option to extract timed GPSData from Kenwood trailer',3);
         return 1;
     }
     while ($raf->Read($buff, 121) and $buff =~ /^GPSDATA--(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})/) {
@@ -3160,7 +3405,7 @@ sub ProcessTTAD($$$)
                 $et->HandleTag($tagTbl, "Unknown0$type" => "@a");
             }
         } else {
-            $et->WarnOnce("Unknown TTAD record type $type",1);
+            $et->Warn("Unknown TTAD record type $type",1);
         }
         # without -ee, stop after we find types 0,3,5 (ie. bitmask 0x29)
         $eeOpt or ($found & 0x29) != 0x29 or EEWarn($et), last;
@@ -3212,7 +3457,7 @@ sub ProcessInsta360($;$)
     }
     unless ($et->Options('ExtractEmbedded')) {
         # can arrive here when reading Insta360 trailer on JPEG image (INSP file)
-        $et->WarnOnce('Use ExtractEmbedded option to extract timed metadata from Insta360 trailer',3);
+        $et->Warn('Use ExtractEmbedded option to extract timed metadata from Insta360 trailer',3);
         return 1;
     }
 
@@ -3409,8 +3654,8 @@ sub ProcessCAMM($$$)
     my $rtnVal = 0;
     while ($pos + 4 < $end) {
         my $type = Get16u($dataPt, $pos + 2);
-        my $size = $size{$type} or $et->WarnOnce("Unknown camm record type $type"), last;
-        $pos + $size > $end and $et->WarnOnce("Truncated camm record $type"), last;
+        my $size = $size{$type} or $et->Warn("Unknown camm record type $type"), last;
+        $pos + $size > $end and $et->Warn("Truncated camm record $type"), last;
         my $tagTbl = GetTagTable("Image::ExifTool::QuickTime::camm$type");
         $$dirInfo{DirStart} = $pos;
         $$dirInfo{DirLen} = $size;