exiftool-vendored.exe 12.99.0 → 13.16.0

package/bin/exiftool_files/lib/Image/ExifTool/Leaf.pm

@@ -504,7 +504,7 @@ Capture.
 
 =head1 AUTHOR
 
-Copyright 2003-2024, Phil Harvey (philharvey66 at gmail.com)
+Copyright 2003-2025, Phil Harvey (philharvey66 at gmail.com)
 
 This library is free software; you can redistribute it and/or modify it
 under the same terms as Perl itself.

package/bin/exiftool_files/lib/Image/ExifTool/LigoGPS.pm

@@ -0,0 +1,409 @@
+#------------------------------------------------------------------------------
+# File:         LigoGPS.pm
+#
+# Description:  Read LIGOGPSINFO timed GPS records
+#
+# Revisions:    2024-12-30 - P. Harvey Created
+#------------------------------------------------------------------------------
+package Image::ExifTool::LigoGPS;
+
+use strict;
+use vars qw($VERSION);
+use Image::ExifTool;
+
+$VERSION = '1.02';
+
+sub ProcessLigoGPS($$$;$);
+sub ProcessLigoJSON($$$);
+sub OrderCipherDigits($$$;$);
+
+my $knotsToKph = 1.852;     # knots --> km/h
+
+#------------------------------------------------------------------------------
+# Clean up cipher variables and print warning if deciphering was unsuccessful
+# Inputs: 0) ExifTool ref
+sub CleanupCipher($)
+{
+    my $et = shift;
+    if ($$et{LigoCipher} and $$et{LigoCipher}{'next'}) {
+        $et->Warn('Not enough GPS points to determine cipher for decoding LIGOGPSINFO');
+    }
+    delete $$et{LigoCipher};
+}
+
+#------------------------------------------------------------------------------
+# 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;  # get next byte in data
+        # upper 3 bits steer the decryption for this round
+        my $steeringBits = $b & 0xe0;
+        if ($steeringBits >= 0xc0) {
+            return undef if @in < 4;    # next 4 bytes are encrypted data
+            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;    # next 3 bytes are encrypted data
+            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;    # next byte is encrypted data
+            push @out, shift(@in) | $b & 0x13;
+        } else {
+            return undef;   # (shouldn't happen)
+        }
+    }
+    return pack 'C*', @out;
+}
+
+#------------------------------------------------------------------------------
+# Determine correct ordering of enciphered digits (unit digits of seconds)
+# Inputs: 0) starting character code, 1) lookup for next character(s) in sequence
+#         2) i/o list of ordered characters, 3) hash of used characters
+# Returns: true if a consistent ordering was found
+# - loops through all possible orders based on $next sequence until a complete
+#   cycle is established
+# - this complexity is necessary because GPS may skip some seconds
+sub OrderCipherDigits($$$;$)
+{
+    my ($ch, $next, $order, $did) = @_;
+    $did or $did = { };
+    while ($$next{$ch}) {
+        if (@$order < 10) {
+            last if $$did{$ch};
+        } else {
+            # success if we have cycled through all 10 digits and back to the first
+            return 1 if @$order == 10 and $ch eq $$order[0];
+            last;
+        }
+        push @$order, $ch;
+        $$did{$ch} = 1;
+        # continue with next character if there is only one possibility
+        @{$$next{$ch}} == 1 and $ch = $$next{$ch}[0], next;
+        # otherwise, test all possibilities
+        my $n = $#$order;
+        foreach (@{$$next{$ch}}) {
+            my %did = %$did;  # make a copy of the used-character lookup
+            return 1 if OrderCipherDigits($_, $next, $order, \%did);
+            $#$order = $n;    # restore order and try next possibility
+        }
+        last;
+    }
+    return 0; # failure
+}
+
+#------------------------------------------------------------------------------
+# Decipher and parse LIGOGPSINFO record (starting with "####")
+# Inputs: 0) ExifTool ref, 1) enciphered string, 2) tag table ref
+#         3) true if GPS coordinates don't need de-fuzzing
+# 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, $noFuzz) = @_;
+
+    # (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};
+    unless ($cipherInfo) {
+        $cipherInfo = $$et{LigoCipher} = { cache => [ ], 'next' => { } };
+        $et->AddCleanup(\&CleanupCipher);
+    };
+    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 $next = $$cipherInfo{next};
+        my ($millennium, $colon, $ch2) = ($1, $2, $4);
+        # determine the cipher lookup table
+        # (only characters in range 0x30-0x5f are encrypted)
+        my $ch1 = $$cipherInfo{ch1};
+        $$cipherInfo{ch1} = $ch2;
+        return 1 if not defined $ch1 or $ch1 eq $ch2; # ignore duplicate sequential digits
+        if ($$next{$ch1}) {
+            return 1 if grep /\Q$ch2\E/, @{$$next{$ch1}};   # don't add twice
+            push @{$$next{$ch1}}, $ch2;
+        } else {
+            $$next{$ch1} = [ $ch2 ];
+        }
+        # must wait until the lookup contains all 10 digits
+        scalar(keys %$next) < 10 and return 1;
+        # protect against trying to decipher bad data
+        scalar(keys %$next) > 10 and $$cipherInfo{'next'} = { }, return 1;
+        my (@order, $two);
+        return 1 unless OrderCipherDigits($ch1, $next, \@order);
+        # get index of enciphered "2" in ordered array
+        $order[$_] eq $millennium and $two = $_, last foreach 0..9;
+        defined $two or $et->Warn('Problem deciphering LIGOGPSINFO'), return 1;
+        delete $$cipherInfo{'next'};        # all done with 'next' lookup
+        my %decipher = ( $colon => ':' );   # (':' is the time separator)
+        foreach (0..9) {
+            my $ch = $order[($_ + $two - 2 + 10) % 10];
+            $decipher{$ch} = chr($_ + 0x30);
+        }
+        # may 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');
+            unless ($2 or $4) {
+                my ($ns, $ew) = ($1, $3);
+                if ($$et{OPTIONS}{GPSQuadrant} and $$et{OPTIONS}{GPSQuadrant} =~ /^([NS])([EW])$/i) {
+                    @decipher{$ns,$ew} = (uc($1), uc($2));
+                } else {
+                    $et->Warn('May need to set API GPSQuadrant option (eg. "NW")');
+                }
+            }
+        }
+        # 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 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
+        ParseLigoGPS($et, "$pre$str", $tagTbl, $noFuzz);
+    } 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 Image::ExifTool::QuickTime::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+)/;
+    $et->HandleTag($tagTbl, 'GPSAltitude', $1) if $str =~ /\bH:(\S+)/;
+    $et->HandleTag($tagTbl, 'MagneticVariation', $1) if $str =~ /\bM:(\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+)/;
+    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
+# Notes:  The directory data should start with the string "LIGOGPSINFO\0"
+sub ProcessLigoGPS($$$;$)
+{
+    my ($et, $dirInfo, $tagTbl, $noFuzz) = @_;
+    my $dataPt = $$dirInfo{DataPt};
+    my $pos = ($$dirInfo{DirStart} || 0) + 0x14;
+    return undef if $pos > length $$dataPt;
+    my $cipherInfo = $$et{LigoCipher};
+    my $dirName = $$dirInfo{DirName} || 'LigoGPS';
+    push @{$$et{PATH}}, $dirName unless $$dirInfo{DirID};
+    # not fuzzed if header =~ /LIGOGPSINFO\0\0\0\0[\x01\x14]/ (\x01=BlueSkySeaDV688)
+    $noFuzz = 1 if substr($$dataPt, $pos-8, 4) =~ /^\0\0\0[\x01\x14]/;
+    $et->VerboseDir($dirName);
+    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, $noFuzz) and next;
+        my $str = DecryptLigoGPS($dat);
+        defined $str or DecipherLigoGPS($et, $dat, $tagTbl, $noFuzz), 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 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):
+# 0000: 4c 49 47 4f 47 50 53 49 4e 46 4f 20 7b 22 48 6f [LIGOGPSINFO {"Ho]
+# 0010: 75 72 22 3a 20 22 32 33 22 2c 20 22 4d 69 6e 75 [ur": "23", "Minu]
+# 0020: 74 65 22 3a 20 22 31 30 22 2c 20 22 53 65 63 6f [te": "10", "Seco]
+# 0030: 6e 64 22 3a 20 22 32 32 22 2c 20 22 59 65 61 72 [nd": "22", "Year]
+# 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 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;
+        Image::ExifTool::Import::ReadJSON(\$json, \%dbase);
+        my $info = $dbase{'*'} or next;
+        # my sample contains the following JSON fields (in this order):
+        # Hour Minute Second Year Month Day (GPS UTC time)
+        # status NS EW Latitude Longitude Speed (speed in knots)
+        # GsensorX GsensorY GsensorZ (units? - only seen "000" for all)
+        # MHour MMinute MSecond MYear MMonth MDay (local dashcam clock time)
+        # OLatitude OLongitude (? same values as Latitude/Longitude)
+        next unless defined $$info{status} and $$info{status} eq 'A'; # only read if GPS is active
+        $$et{DOC_NUM} = ++$$et{DOC_COUNT};
+        my $num = 0;
+        defined $$info{$_} and ++$num foreach qw(Year Month Day Hour Minute Second);
+        if ($num == 6) {
+            # this is the GPS time in UTC
+            my $time = sprintf('%.4d:%.2d:%.2d %.2d:%.2d:%.2dZ',@$info{qw{Year Month Day Hour Minute Second}});
+            $et->HandleTag($tagTbl, GPSDateTime => $time);
+        }
+        if ($$info{Latitude} and $$info{Longitude}) {
+            my $lat = $$info{Latitude};
+            $lat = -$lat if $$info{NS} and $$info{NS} eq 'S';
+            my $lon = $$info{Longitude};
+            $lon = -$lon if $$info{EW} and $$info{EW} eq 'W';
+            $et->HandleTag($tagTbl, GPSLatitude => $lat);
+            $et->HandleTag($tagTbl, GPSLongitude => $lon);
+        }
+        $et->HandleTag($tagTbl, GPSSpeed => $$info{Speed} * $knotsToKph) if defined $$info{Speed};
+        if (defined $$info{GsensorX} and defined $$info{GsensorY} and defined $$info{GsensorZ}) {
+            # (don't know conversion factor for accel data, so leave it raw for now)
+            $et->HandleTag($tagTbl, Accelerometer => "$$info{GsensorX} $$info{GsensorY} $$info{GsensorZ}");
+        }
+        $num = 0;
+        defined $$info{$_} and ++$num foreach qw(MYear MMonth MDay MHour MMinute MSecond);
+        if ($num == 6) {
+            # this is the dashcam clock time (local time zone)
+            my $time = sprintf('%.4d:%.2d:%.2d %.2d:%.2d:%.2d',@$info{qw{MYear MMonth MDay MHour MMinute MSecond}});
+            $et->HandleTag($tagTbl, DateTimeOriginal => $time);
+        }
+        if (defined $$info{OLatitude} and defined $$info{OLongitude}) {
+            my $lat = $$info{OLatitude};
+            $lat = -$lat if $$info{NS} and $$info{NS} eq 'S';
+            my $lon = $$info{OLongitude};
+            $lon = -$lon if $$info{EW} and $$info{EW} eq 'W';
+            $et->HandleTag($tagTbl, GPSLatitude2 => $lat);
+            $et->HandleTag($tagTbl, GPSLongitude2 => $lon);
+        }
+        unless ($et->Options('ExtractEmbedded')) {
+            $et->Warn('Use the ExtractEmbedded option to extract all timed GPS',3);
+            last;
+        }
+    }
+    delete $$et{DOC_NUM};
+    delete $$et{SET_GROUP1};
+    return 1;
+}
+
+1; #end
+
+
+__END__
+
+=head1 NAME
+
+Image::ExifTool::LigoGPS - Read LIGOGPSINFO timed GPS records
+
+=head1 SYNOPSIS
+
+This module is loaded automatically by Image::ExifTool when required.
+
+=head1 DESCRIPTION
+
+This module decrypts, deciphers and decodes timed GPS metadata from
+LIGOGPSINFO records found in various locations of MP4 and M2TS videos from a
+variety of dashcam makes and models.
+
+=head1 AUTHOR
+
+Copyright 2003-2025, Phil Harvey (philharvey66 at gmail.com)
+
+This library is free software; you can redistribute it and/or modify it
+under the same terms as Perl itself.
+
+=head1 SEE ALSO
+
+L<Image::ExifTool::TagNames/QuickTime Stream Tags>,
+L<Image::ExifTool(3pm)|Image::ExifTool>
+
+=cut

package/bin/exiftool_files/lib/Image/ExifTool/Lytro.pm

@@ -192,7 +192,7 @@ from Lytro Light Field Picture (LFP) files.
 
 =head1 AUTHOR
 
-Copyright 2003-2024, Phil Harvey (philharvey66 at gmail.com)
+Copyright 2003-2025, Phil Harvey (philharvey66 at gmail.com)
 
 This library is free software; you can redistribute it and/or modify it
 under the same terms as Perl itself.

package/bin/exiftool_files/lib/Image/ExifTool/M2TS.pm

@@ -32,7 +32,7 @@ use strict;
 use vars qw($VERSION);
 use Image::ExifTool qw(:DataAccess :Utils);
 
-$VERSION = '1.25';
+$VERSION = '1.29';
 
 # program map table "stream_type" lookup (ref 6/1/9)
 my %streamType = (
@@ -82,7 +82,7 @@ my %streamType = (
     0x86 => 'DTS-HD Audio',
     0x87 => 'E-AC-3 Audio',
     0x8a => 'DTS Audio',
-    0x90 => 'PGS Audio', #https://www.avsforum.com/threads/bass-eq-for-filtered-movies.2995212/page-399
+    0x90 => 'Presentation Graphic Stream (subtitle)', #https://en.wikipedia.org/wiki/Program-specific_information
     0x91 => 'A52b/AC-3 Audio',
     0x92 => 'DVD_SPU vls Subtitle',
     0x94 => 'SDDS Audio',
@@ -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::LigoGPS::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
@@ -428,13 +437,16 @@ sub ParsePID($$$$$)
             $more = 1;
         } elsif ($$dataPt =~ /\$GPRMC,/) {
             # Jomise T860S-GM dashcam
-            # $GPRMC,hhmmss.ss,A,ddmm.mmmmm,N,dddmm.mmmmm,W,spd-kts,dir-dg,DDMMYY,,*cs
-            # $GPRMC,172255.00,A,:985.95194,N,17170.14674,W,029.678,170.68,240822,,,D*7B
-            # $GPRMC,172355.00,A,:984.76779,N,17170.00473,W,032.219,172.04,240822,,,D*7B
-            # ddmm.mmmm: from    4742.2568    12209.2028 (should be)
-            # to                 4741.7696    12209.1056
-            # stamped on video:  47.70428N, 122.15338W, 35mph (dd.ddddd)
-            # to                 47.69616N, 122.15176W, 37mph
+            # $GPRMC,hhmmss.ss,A,ddmm.mmmmm,N,dddmm.mmmmm,W,spd-kts,dir-dg,DDMMYY,,M*cs - lat,lon,spd from video
+            # $GPRMC,172255.00,A,:985.95194,N,17170.14674,W,029.678,170.68,240822,,,D*7B - N47.70428,W122.15338,35mph
+            # $GPRMC,192643.00,A,:987.94979,N,17171.07268,W,010.059,079.61,111122,,,A*73 - N47.71862,W122.16437,12mph
+            # $GPRMC,192743.00,A,:988.72110,N,17171.04873,W,017.477,001.03,111122,,,A*78 - N47.72421,W122.16408,20mph
+            # $GPRMC,192844.00,A,:989.43771,N,17171.03538,W,016.889,001.20,111122,,,A*7B - N47.72932,W122.16393,19mph
+            # $GPRMC,005241.00,A,:987.70873,N,17171.81293,W,000.284,354.78,141122,,,A*7F - N47.71687,W122.17318,0mph
+            # $GPRMC,005341.00,A,:987.90851,N,17171.85380,W,000.080,349.36,141122,,,A*7C - N47.71832,W122.17367,0mph
+            # $GPRMC,005441.00,A,:987.94538,N,17171.21783,W,029.686,091.09,141122,,,A*7A - N47.71859,W122.16630,35mph
+            # $GPRMC,002816.00,A,6820.67273,N,13424.26599,W,000.045,000.00,261122,,,A*79 - N29.52096,W95.55953,0mph (seattle)
+            # $GPRMC,035136.00,A,:981.47322,N,17170.14105,W,024.594,180.50,291122,,,D*79 - N47.67180,W122.15328,28mph
             my $tagTbl = GetTagTable('Image::ExifTool::QuickTime::Stream');
             while ($$dataPt =~ /\$[A-Z]{2}RMC,(\d{2})(\d{2})(\d+(\.\d*)?),A?,(.{2})(\d{2}\.\d+),([NS]),(.{3})(\d{2}\.\d+),([EW]),(\d*\.?\d*),(\d*\.?\d*),(\d{2})(\d{2})(\d+)/g and
                 # do some basic sanity checks on the date
@@ -459,15 +471,20 @@ 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));
                 }
             }
+        } elsif ($$dataPt =~ /\$GSENSORD,\s*(\d+),\s*(\d+),\s*(\d+),/) {
+            # Jomise T860S-GM dashcam
+            my $tagTbl = GetTagTable('Image::ExifTool::QuickTime::Stream');
+            $$et{DOC_NUM} = $$et{DOC_COUNT};
+            $et->HandleTag($tagTbl, Accelerometer => "$1 $2 $3"); # (NC - values range from 0 to 6)
         } elsif ($$dataPt =~ /^.{44}A\0{3}.{4}([NS])\0{3}.{4}([EW])\0{3}/s and length($$dataPt) >= 84) {
             #forum11320
             SetByteOrder('II');
@@ -476,7 +493,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 +531,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::LigoGPS::ProcessLigoGPS($et, \%dirInfo, $tbl, 1);
+            $$et{FoundGoodGPS} = 1;
         } elsif ($$et{FoundGoodGPS}) {
             $more = 1;
         }
@@ -576,7 +600,8 @@ sub ProcessM2TS($$)
     my %gpsPID = (
         0x0300 => 1,    # Novatek INNOVV, DOD_LS600W
         0x01e4 => 1,    # vsys a6l dashcam
-        0x0e1b => 1,    # Jomise T860S-GM dashcam
+        0x0e1b => 1,    # Jomise T860S-GM dashcam GPS
+        0x0e1a => 1,    # Jomise T860S-GM dashcam accelerometer
     );
     my $pEnd = 0;
 
@@ -694,7 +719,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 +812,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 +847,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 +979,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::LigoGPS::ProcessLigoGPS($et, \%dirInfo, $tbl);
+        }
+    }
+
     return 1;
 }
 
@@ -977,7 +1016,7 @@ video.
 
 =head1 AUTHOR
 
-Copyright 2003-2024, Phil Harvey (philharvey66 at gmail.com)
+Copyright 2003-2025, Phil Harvey (philharvey66 at gmail.com)
 
 This library is free software; you can redistribute it and/or modify it
 under the same terms as Perl itself.

package/bin/exiftool_files/lib/Image/ExifTool/MIE.pm

@@ -14,7 +14,7 @@ use Image::ExifTool qw(:DataAccess :Utils);
 use Image::ExifTool::Exif;
 use Image::ExifTool::GPS;
 
-$VERSION = '1.54';
+$VERSION = '1.56';
 
 sub ProcessMIE($$);
 sub ProcessMIEGroup($$$);
@@ -1376,8 +1376,9 @@ sub WriteMIEGroup($$$)
                 my $term = "~\0\0\0";
                 unless ($$dirInfo{Parent}) {
                     # write extended terminator for file-level group
-                    my $len = ref $outfile eq 'SCALAR' ? length($$outfile) : tell $outfile;
-                    $len += 10; # include length of terminator itself
+                    my $len = ref $outfile eq 'SCALAR' ? length($$outfile) || 0 : tell $outfile;
+                    # include length of terminator itself minus original $outfile position
+                    $len += 10 - ($$dirInfo{OutPos} || 0);
                     if ($len and $len <= 0x7fffffff) {
                         $term = "~\0\0\x06" . Set32u($len) . MIEGroupFormat(1) . "\x04";
                     }
@@ -1596,9 +1597,10 @@ sub ProcessMIEGroup($$$)
         } else {
             # process MIE data format types
             if ($tagInfo) {
-                my $rational;
+                my ($rational, $binVal);
                 # extract tag value
                 my $val = ReadMIEValue(\$value, 0, $formatStr, undef, $valLen, \$rational);
+                $binVal = substr($value, 0, $valLen) if $$et{OPTIONS}{SaveBin};
                 unless (defined $val) {
                     $et->Warn("Error reading $tag value");
                     $val = '<err>';
@@ -1661,7 +1663,12 @@ sub ProcessMIEGroup($$$)
                         $val .= "($units)" if defined $units;
                     }
                     my $key = $et->FoundTag($tagInfo, $val);
-                    $$et{RATIONAL}{$key} = $rational if defined $rational and defined $key;
+                    if (defined $key) {
+                        my $ex = $$et{TAG_EXTRA}{$key};
+                        $$ex{Rational} = $rational if defined $rational;
+                        $$ex{BinVal} = $binVal if defined $binVal;
+                        $$ex{G6} = $formatStr if $$et{OPTIONS}{SaveFormat};
+                    }
                 }
             } else {
                 # skip over unknown information or free bytes
@@ -1796,6 +1803,8 @@ sub ProcessMIE($$)
             # don't define Parent so WriteMIEGroup() writes extended terminator
         );
         if ($outfile) {
+            # save start position in $outfile
+            $subdirInfo{OutPos} = ref $outfile eq 'SCALAR' ? length($$outfile) || 0 : tell $outfile;
             # generate lookup for MIE format codes if not done already
             unless (%mieCode) {
                 foreach (keys %mieFormat) {
@@ -2551,7 +2560,7 @@ tag name.  For example:
 
 =head1 AUTHOR
 
-Copyright 2003-2024, Phil Harvey (philharvey66 at gmail.com)
+Copyright 2003-2025, Phil Harvey (philharvey66 at gmail.com)
 
 This library is free software; you can redistribute it and/or modify it
 under the same terms as Perl itself.  The MIE format itself is also