exiftool_vendored 10.65.0 → 11.41.0

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

@@ -0,0 +1,1857 @@
+#------------------------------------------------------------------------------
+# File:         QuickTimeStream.pl
+#
+# Description:  Extract embedded information from QuickTime movie data
+#
+# Revisions:    2018-01-03 - P. Harvey Created
+#
+# References:   1) https://developer.apple.com/library/content/documentation/QuickTime/QTFF/QTFFChap3/qtff3.html#//apple_ref/doc/uid/TP40000939-CH205-SW130
+#               2) http://sergei.nz/files/nvtk_mp42gpx.py
+#               3) https://forum.flitsservice.nl/dashcam-info/dod-ls460w-gps-data-uit-mov-bestand-lezen-t87926.html
+#               4) https://developers.google.com/streetview/publish/camm-spec
+#               5) https://sergei.nz/extracting-gps-data-from-viofo-a119-and-other-novatek-powered-cameras/
+#------------------------------------------------------------------------------
+package Image::ExifTool::QuickTime;
+
+use strict;
+
+sub Process_tx3g($$$);
+sub ProcessFreeGPS($$$);
+sub ProcessFreeGPS2($$$);
+
+# QuickTime data types that have ExifTool equivalents
+# (ref https://developer.apple.com/library/content/documentation/QuickTime/QTFF/Metadata/Metadata.html#//apple_ref/doc/uid/TP40000939-CH1-SW35)
+my %qtFmt = (
+    0 => 'undef',
+    1 => 'string', # (UTF-8)
+    # 2 - UTF-16
+    # 3 - shift-JIS
+    # 4 - UTF-8 sort
+    # 5 - UTF-16 sort
+    # 13 - JPEG image
+    # 14 - PNG image
+    # 21 - signed integer (1,2,3 or 4 bytes)
+    # 22 - unsigned integer (1,2,3 or 4 bytes)
+    23 => 'float',
+    24 => 'double',
+    # 27 - BMP image
+    # 28 - QuickTime atom
+    65 => 'int8s',
+    66 => 'int16s',
+    67 => 'int32s',
+    70 => 'float', # float[2] x,y
+    71 => 'float', # float[2] width,height
+    72 => 'float', # float[4] x,y,width,height
+    74 => 'int64s',
+    75 => 'int8u',
+    76 => 'int16u',
+    77 => 'int32u',
+    78 => 'int64u',
+    79 => 'float', # float[9] transform matrix
+    80 => 'float', # float[8] face coordinates
+);
+
+# maximums for validating H,M,S,d,m,Y from "freeGPS " metadata
+my @dateMax = ( 24, 59, 59, 2200, 12, 31 );
+
+# typical (minimum?) size of freeGPS block
+my $gpsBlockSize = 0x8000;
+
+# conversion factors
+my $knotsToKph = 1.852; # knots --> km/h
+my $mpsToKph   = 3.6;   # m/s   --> km/h
+
+# handler types to process based on MetaFormat/OtherFormat
+my %processByMetaFormat = (
+    meta => 1,  # ('CTMD' in CR3 images, 'priv' unknown in DJI video)
+    data => 1,  # ('RVMI')
+    sbtl => 1,  # (subtitle; 'tx3g' in Yuneec drone videos)
+);
+
+# data lengths for each INSV record type
+my %insvDataLen = (
+    0x300 => 56,
+    0x400 => 16,
+    0x700 => 53,
+);
+
+# tags extracted from various QuickTime data streams
+%Image::ExifTool::QuickTime::Stream = (
+    GROUPS => { 2 => 'Location' },
+    NOTES => q{
+        Timed metadata extracted from QuickTime movie data and some AVI videos when
+        the ExtractEmbedded option is used.
+    },
+    VARS => { NO_ID => 1 },
+    GPSLatitude  => { PrintConv => 'Image::ExifTool::GPS::ToDMS($self, $val, 1, "N")' },
+    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' } },
+    GPSTimeStamp => { PrintConv => 'Image::ExifTool::GPS::PrintTimeStamp($val)', Groups => { 2 => 'Time' } },
+    GPSSatellites=> { },
+    GPSDOP       => { Description => 'GPS Dilution Of Precision' },
+    CameraDateTime=>{ PrintConv => '$self->ConvertDateTime($val)', Groups => { 2 => 'Time' } },
+    Accelerometer=> { Notes => 'right/up/backward acceleration in units of g' },
+    AngularVelocity => { },
+    RawGSensor   => {
+        # (same as GSensor, but offset by some unknown value)
+        ValueConv => 'my @a=split " ",$val; $_/=1000 foreach @a; "@a"',
+    },
+    Text         => { Groups => { 2 => 'Other' } },
+    TimeCode     => { Groups => { 2 => 'Video' } },
+    FrameNumber  => { Groups => { 2 => 'Video' } },
+    SampleTime   => { Groups => { 2 => 'Video' }, PrintConv => 'ConvertDuration($val)', Notes => 'sample decoding time' },
+    SampleDuration=>{ Groups => { 2 => 'Video' }, PrintConv => 'ConvertDuration($val)' },
+    UserLabel    => { Groups => { 2 => 'Other' } },
+#
+# timed metadata decoded based on MetaFormat (format of 'meta' or 'data' sample description)
+# [or HandlerType, or specific 'vide' type if specified]
+#
+    mebx => {
+        Name => 'mebx',
+        SubDirectory => {
+            TagTable => 'Image::ExifTool::QuickTime::Keys',
+            ProcessProc => \&Process_mebx,
+        },
+    },
+    gpmd => {
+        Name => 'gpmd',
+        SubDirectory => { TagTable => 'Image::ExifTool::GoPro::GPMF' },
+    },
+    fdsc => {
+        Name => 'fdsc',
+        Condition => '$$valPt =~ /^GPRO/',
+        # (other types of "fdsc" samples aren't yet parsed: /^GP\x00/ and /^GP\x04/)
+        SubDirectory => { TagTable => 'Image::ExifTool::GoPro::fdsc' },
+    },
+    rtmd => {
+        Name => 'rtmd',
+        SubDirectory => { TagTable => 'Image::ExifTool::Sony::rtmd' },
+    },
+    CTMD => { # (Canon Timed MetaData)
+        Name => 'CTMD',
+        SubDirectory => { TagTable => 'Image::ExifTool::Canon::CTMD' },
+    },
+    tx3g => {
+        Name => 'tx3g',
+        SubDirectory => { TagTable => 'Image::ExifTool::QuickTime::tx3g' },
+    },
+    RVMI => [{ # data "OtherFormat" written by unknown software
+        Name => 'RVMI_gReV',
+        Condition => '$$valPt =~ /^gReV/',  # GPS data
+        SubDirectory => {
+            TagTable => 'Image::ExifTool::QuickTime::RVMI_gReV',
+            ByteOrder => 'Little-endian',
+        },
+    },{
+        Name => 'RVMI_sReV',
+        Condition => '$$valPt =~ /^sReV/',  # sensor data
+        SubDirectory => {
+            TagTable => 'Image::ExifTool::QuickTime::RVMI_sReV',
+            ByteOrder => 'Little-endian',
+        },
+    # (there is also "tReV" data that hasn't been decoded yet)
+    }],
+    camm => [{
+        Name => 'camm0',
+        # (according to the spec. the first 2 bytes are reserved and should be zero,
+        # but I have a sample where these bytes are non-zero, so allow anything here)
+        Condition => '$$valPt =~ /^..\0\0/s',
+        SubDirectory => {
+            TagTable => 'Image::ExifTool::QuickTime::camm0',
+            ByteOrder => 'Little-Endian',
+        },
+    },{
+        Name => 'camm1',
+        Condition => '$$valPt =~ /^..\x01\0/s',
+        SubDirectory => {
+            TagTable => 'Image::ExifTool::QuickTime::camm1',
+            ByteOrder => 'Little-Endian',
+        },
+    },{ # (written by Insta360) - [HandlerType, not MetaFormat]
+        Name => 'camm2',
+        Condition => '$$valPt =~ /^..\x02\0/s',
+        SubDirectory => {
+            TagTable => 'Image::ExifTool::QuickTime::camm2',
+            ByteOrder => 'Little-Endian',
+        },
+    },{
+        Name => 'camm3',
+        Condition => '$$valPt =~ /^..\x03\0/s',
+        SubDirectory => {
+            TagTable => 'Image::ExifTool::QuickTime::camm3',
+            ByteOrder => 'Little-Endian',
+        },
+    },{
+        Name => 'camm4',
+        Condition => '$$valPt =~ /^..\x04\0/s',
+        SubDirectory => {
+            TagTable => 'Image::ExifTool::QuickTime::camm4',
+            ByteOrder => 'Little-Endian',
+        },
+    },{
+        Name => 'camm5',
+        Condition => '$$valPt =~ /^..\x05\0/s',
+        SubDirectory => {
+            TagTable => 'Image::ExifTool::QuickTime::camm5',
+            ByteOrder => 'Little-Endian',
+        },
+    },{
+        Name => 'camm6',
+        Condition => '$$valPt =~ /^..\x06\0/s',
+        SubDirectory => {
+            TagTable => 'Image::ExifTool::QuickTime::camm6',
+            ByteOrder => 'Little-Endian',
+        },
+    },{
+        Name => 'camm7',
+        Condition => '$$valPt =~ /^..\x07\0/s',
+        SubDirectory => {
+            TagTable => 'Image::ExifTool::QuickTime::camm7',
+            ByteOrder => 'Little-Endian',
+        },
+    }],
+    JPEG => { # (in CR3 images) - [vide HandlerType with JPEG in SampleDescription, not MetaFormat]
+        Name => 'JpgFromRaw',
+        Groups => { 2 => 'Preview' },
+        RawConv => '$self->ValidateImage(\$val,$tag)',
+    },
+    text => { # (TomTom Bandit MP4) - [sbtl HandlerType with 'text' in SampleDescription]
+        Name => 'PreviewInfo',
+        Condition => 'length $$valPt > 12 and Get32u($valPt,4) == length($$valPt) and $$valPt =~ /^.{8}\xff\xd8\xff/s',
+        SubDirectory => { TagTable => 'Image::ExifTool::QuickTime::PreviewInfo' },
+    },
+    INSV => { SubDirectory => { TagTable => 'Image::ExifTool::QuickTime::INSV_MakerNotes' } },
+    Unknown00 => { Unknown => 1 },
+    Unknown01 => { Unknown => 1 },
+    Unknown02 => { Unknown => 1 },
+    Unknown03 => { Unknown => 1 },
+);
+
+# tags found in 'camm' type 0 timed metadata (ref 4)
+%Image::ExifTool::QuickTime::camm0 = (
+    PROCESS_PROC => \&Image::ExifTool::ProcessBinaryData,
+    GROUPS => { 2 => 'Location' },
+    FIRST_ENTRY => 0,
+    NOTES => q{
+        The camm0 through camm7 tables define tags extracted from the Google Street
+        View Camera Motion Metadata of MP4 videos.  See
+        L<https://developers.google.com/streetview/publish/camm-spec> for the
+        specification.
+    },
+    4 => {
+        Name => 'AngleAxis',
+        Notes => 'angle axis orientation in radians in local coordinate system',
+        Format => 'float[3]',
+    },
+);
+
+# tags found in 'camm' type 1 timed metadata (ref 4)
+%Image::ExifTool::QuickTime::camm1 = (
+    PROCESS_PROC => \&Image::ExifTool::ProcessBinaryData,
+    GROUPS => { 2 => 'Camera' },
+    FIRST_ENTRY => 0,
+    4 => {
+        Name => 'PixelExposureTime',
+        Format => 'int32s',
+        ValueConv => '$val * 1e-9',
+        PrintConv => 'sprintf("%.4g ms", $val * 1000)',
+    },
+    8 => {
+        Name => 'RollingShutterSkewTime',
+        Format => 'int32s',
+        ValueConv => '$val * 1e-9',
+        PrintConv => 'sprintf("%.4g ms", $val * 1000)',
+    },
+);
+
+# tags found in 'camm' type 2 timed metadata (ref PH, Insta360Pro)
+%Image::ExifTool::QuickTime::camm2 = (
+    PROCESS_PROC => \&Image::ExifTool::ProcessBinaryData,
+    GROUPS => { 2 => 'Location' },
+    FIRST_ENTRY => 0,
+    4 => {
+        Name => 'AngularVelocity',
+        Notes => 'gyro angular velocity about X, Y and Z axes in rad/s',
+        Format => 'float[3]',
+    },
+);
+
+# tags found in 'camm' type 3 timed metadata (ref PH, Insta360Pro)
+%Image::ExifTool::QuickTime::camm3 = (
+    PROCESS_PROC => \&Image::ExifTool::ProcessBinaryData,
+    GROUPS => { 2 => 'Location' },
+    FIRST_ENTRY => 0,
+    4 => {
+        Name => 'Acceleration',
+        Notes => 'acceleration in the X, Y and Z directions in m/s^2',
+        Format => 'float[3]',
+    },
+);
+
+# tags found in 'camm' type 4 timed metadata (ref 4)
+%Image::ExifTool::QuickTime::camm4 = (
+    PROCESS_PROC => \&Image::ExifTool::ProcessBinaryData,
+    GROUPS => { 2 => 'Location' },
+    FIRST_ENTRY => 0,
+    4 => {
+        Name => 'Position',
+        Notes => 'X, Y, Z position in local coordinate system',
+        Format => 'float[3]',
+    },
+);
+
+# tags found in 'camm' type 5 timed metadata (ref 4)
+%Image::ExifTool::QuickTime::camm5 = (
+    PROCESS_PROC => \&Image::ExifTool::ProcessBinaryData,
+    GROUPS => { 2 => 'Location' },
+    FIRST_ENTRY => 0,
+    4 => {
+        Name => 'GPSLatitude',
+        Format => 'double',
+        ValueConv => 'Image::ExifTool::GPS::ToDegrees($val, 1)',
+        PrintConv => 'Image::ExifTool::GPS::ToDMS($self, $val, 1, "N")',
+    },
+    12 => {
+        Name => 'GPSLongitude',
+        Format => 'double',
+        ValueConv => 'Image::ExifTool::GPS::ToDegrees($val, 1)',
+        PrintConv => 'Image::ExifTool::GPS::ToDMS($self, $val, 1, "E")',
+    },
+    20 => {
+        Name => 'GPSAltitude',
+        Format => 'double',
+        PrintConv => '$_ = sprintf("%.6f", $val); s/\.?0+$//; "$_ m"',
+    },
+);
+
+# tags found in 'camm' type 6 timed metadata (ref PH/4, Insta360)
+%Image::ExifTool::QuickTime::camm6 = (
+    PROCESS_PROC => \&Image::ExifTool::ProcessBinaryData,
+    GROUPS => { 2 => 'Location' },
+    FIRST_ENTRY => 0,
+    0x04 => {
+        Name => 'GPSDateTime',
+        Groups => { 2 => 'Time' },
+        Format => 'double',
+        ValueConv => q{
+            my $str = ConvertUnixTime($val);
+            my $frac = $val - int($val);
+            if ($frac != 0) {
+                $frac = sprintf('%.6f', $frac);
+                $frac =~ s/^0//;
+                $frac =~ s/0+$//;
+                $str .= $frac;
+            }
+            return $str . 'Z';
+        },
+        PrintConv => '$self->ConvertDateTime($val)',
+    },
+    0x0c => {
+        Name => 'GPSMeasureMode',
+        Format => 'int32u',
+        PrintConv => {
+            0 => 'No Measurement',
+            2 => '2-Dimensional Measurement',
+            3 => '3-Dimensional Measurement',
+        },
+    },
+    0x10 => {
+        Name => 'GPSLatitude',
+        Format => 'double',
+        ValueConv => 'Image::ExifTool::GPS::ToDegrees($val, 1)',
+        PrintConv => 'Image::ExifTool::GPS::ToDMS($self, $val, 1, "N")',
+    },
+    0x18 => {
+        Name => 'GPSLongitude',
+        Format => 'double',
+        ValueConv => 'Image::ExifTool::GPS::ToDegrees($val, 1)',
+        PrintConv => 'Image::ExifTool::GPS::ToDMS($self, $val, 1, "E")',
+    },
+    0x20 => {
+        Name => 'GPSAltitude',
+        Format => 'float',
+        PrintConv => '$_ = sprintf("%.3f", $val); s/\.?0+$//; "$_ m"',
+    },
+    0x24 => { Name => 'GPSHorizontalAccuracy', Format => 'float', Notes => 'metres' },
+    0x28 => { Name => 'GPSVerticalAccuracy',   Format => 'float' },
+    0x2c => { Name => 'GPSVelocityEast',       Format => 'float', Notes => 'm/s' },
+    0x30 => { Name => 'GPSVelocityNorth',      Format => 'float' },
+    0x34 => { Name => 'GPSVelocityUp',         Format => 'float' },
+    0x38 => { Name => 'GPSSpeedAccuracy',      Format => 'float' },
+);
+
+# tags found in 'camm' type 7 timed metadata (ref 4)
+%Image::ExifTool::QuickTime::camm7 = (
+    PROCESS_PROC => \&Image::ExifTool::ProcessBinaryData,
+    GROUPS => { 2 => 'Location' },
+    FIRST_ENTRY => 0,
+    4 => {
+        Name => 'MagneticField',
+        Format => 'float[3]',
+        Notes => 'microtesla',
+    },
+);
+
+# preview image stored by TomTom Bandit ActionCam
+%Image::ExifTool::QuickTime::PreviewInfo = (
+    PROCESS_PROC => \&Image::ExifTool::ProcessBinaryData,
+    FIRST_ENTRY => 0,
+    NOTES => 'Preview stored by TomTom Bandit ActionCam.',
+    8 => {
+        Name => 'PreviewImage',
+        Groups => { 2 => 'Preview' },
+        Binary => 1,
+        Format => 'undef[$size-8]',
+    },
+);
+
+# tags found in 'RVMI' 'gReV' timed metadata (ref PH)
+%Image::ExifTool::QuickTime::RVMI_gReV = (
+    PROCESS_PROC => \&Image::ExifTool::ProcessBinaryData,
+    GROUPS => { 2 => 'Location' },
+    FIRST_ENTRY => 0,
+    NOTES => 'GPS information extracted from the RVMI box of MOV videos.',
+    4 => {
+        Name => 'GPSLatitude',
+        Format => 'int32s',
+        ValueConv => 'Image::ExifTool::GPS::ToDegrees($val/1e6, 1)',
+        PrintConv => 'Image::ExifTool::GPS::ToDMS($self, $val, 1, "N")',
+    },
+    8 => {
+        Name => 'GPSLongitude',
+        Format => 'int32s',
+        ValueConv => 'Image::ExifTool::GPS::ToDegrees($val/1e6, 1)',
+        PrintConv => 'Image::ExifTool::GPS::ToDMS($self, $val, 1, "E")',
+    },
+    # 12 - int32s: space for altitude? (always zero in my sample)
+    16 => {
+        Name => 'GPSSpeed', # km/h
+        Format => 'int16s',
+        ValueConv => '$val / 10',
+    },
+    18 => {
+        Name => 'GPSTrack',
+        Format => 'int16u',
+        ValueConv => '$val * 2',
+    },
+);
+
+# tags found in 'RVMI' 'sReV' timed metadata (ref PH)
+%Image::ExifTool::QuickTime::RVMI_sReV = (
+    PROCESS_PROC => \&Image::ExifTool::ProcessBinaryData,
+    GROUPS => { 2 => 'Location' },
+    FIRST_ENTRY => 0,
+    NOTES => q{
+        G-sensor information extracted from the RVMI box of MOV videos.
+    },
+    4 => {
+        Name => 'GSensor',
+        Format => 'int16s[3]', # X Y Z
+        ValueConv => 'my @a=split " ",$val; $_/=1000 foreach @a; "@a"',
+    },
+);
+
+# tags found in 'tx3g' sbtl timed metadata (ref PH)
+%Image::ExifTool::QuickTime::tx3g = (
+    PROCESS_PROC => \&Process_tx3g,
+    GROUPS => { 2 => 'Location' },
+    FIRST_ENTRY => 0,
+    NOTES => 'Tags extracted from the tx3g sbtl timed metadata of Yuneec drones.',
+    Lat => {
+        Name => 'GPSLatitude',
+        PrintConv => 'Image::ExifTool::GPS::ToDMS($self, $val, 1, "N")',
+    },
+    Lon => {
+        Name => 'GPSLongitude',
+        PrintConv => 'Image::ExifTool::GPS::ToDMS($self, $val, 1, "E")',
+    },
+    Alt => {
+        Name => 'GPSAltitude',
+        ValueConv => '$val =~ s/\s*m$//; $val', # remove " m"
+        PrintConv => '"$val m"', # add it back again
+    },
+    Yaw      => 'Yaw',
+    Pitch    => 'Pitch',
+    Roll     => 'Roll',
+    GimYaw   => 'GimbalYaw',
+    GimPitch => 'GimbalPitch',
+    GimRoll  => 'GimbalRoll',
+);
+
+%Image::ExifTool::QuickTime::INSV_MakerNotes = (
+    GROUPS => { 1 => 'MakerNotes', 2 => 'Camera' },
+    0x0a => 'SerialNumber',
+    0x12 => 'Model',
+    0x1a => 'Firmware',
+    0x2a => {
+        Name => 'Parameters',
+        ValueConv => '$val =~ tr/_/ /; $val',
+    },
+);
+
+#------------------------------------------------------------------------------
+# Save information from keys in OtherSampleDesc directory for processing timed metadata
+# Inputs: 0) ExifTool object ref, 1) dirInfo ref, 2) tag table ref
+# Returns: 1 on success
+# (ref "Timed Metadata Media" here:
+#  https://developer.apple.com/library/content/documentation/QuickTime/QTFF/QTFFChap3/qtff3.html)
+sub SaveMetaKeys($$$)
+{
+    local $_;
+    my ($et, $dirInfo, $tagTbl) = @_;
+    my $dataPt = $$dirInfo{DataPt};
+    my $dirLen = length $$dataPt;
+    return 0 unless $dirLen > 8;
+    my $pos = 0;
+    my $verbose = $$et{OPTIONS}{Verbose};
+    my $oldIndent = $$et{INDENT};
+    my $ee = $$et{ee};
+    $ee or $ee = $$et{ee} = { };
+
+    $verbose and $et->VerboseDir($$dirInfo{DirName}, undef, $dirLen);
+
+    # loop through metadata key table
+    while ($pos + 8 < $dirLen) {
+        my $size = Get32u($dataPt, $pos);
+        my $id = substr($$dataPt, $pos+4, 4);
+        my $end = $pos + $size;
+        $end = $dirLen if $end > $dirLen;
+        $pos += 8;
+        my ($tagID, $format, $pid);
+        if ($verbose) {
+            $pid = PrintableTagID($id,1);
+            $et->VPrint(0, "$oldIndent+ [Metdata Key entry, Local ID=$pid, $size bytes]\n");
+            $$et{INDENT} .= '| ';
+        }
+
+        while ($pos + 4 < $end) {
+            my $len = unpack("x${pos}N", $$dataPt);
+            last if $len < 8 or $pos + $len > $end;
+            my $tag = substr($$dataPt, $pos + 4, 4);
+            $pos += 8;  $len -= 8;
+            my $val = substr($$dataPt, $pos, $len);
+            $pos += $len;
+            my $str;
+            if ($tag eq 'keyd') {
+                ($tagID = $val) =~ s/^(mdta|fiel)com\.apple\.quicktime\.//;
+                $tagID = "Tag_$val" unless $tagID;
+                ($str = $val) =~ s/(.{4})/$1 / if $verbose;
+            } elsif ($tag eq 'dtyp') {
+                next if length $val < 4;
+                if (length $val >= 4) {
+                    my $ns = unpack('N', $val);
+                    if ($ns == 0) {
+                        length $val >= 8 or $et->Warn('Short dtyp data'), next;
+                        $str = unpack('x4N',$val);
+                        $format = $qtFmt{$str} || 'undef';
+                    } elsif ($ns == 1) {
+                        $str = substr($val, 4);
+                        $format = 'undef';
+                    } else {
+                        $format = 'undef';
+                    }
+                    $str .= " ($format)" if $verbose and defined $str;
+                }
+            }
+            if ($verbose > 1) {
+                if (defined $str) {
+                    $str =~ tr/\x00-\x1f\x7f-\xff/./;
+                    $str = " = $str";
+                } else {
+                    $str = '';
+                }
+                $et->VPrint(1, $$et{INDENT}."- Tag '".PrintableTagID($tag)."' ($len bytes)$str\n");
+                $et->VerboseDump(\$val);
+            }
+        }
+        if (defined $tagID and defined $format) {
+            if ($verbose) {
+                my $t2 = PrintableTagID($tagID);
+                $et->VPrint(0, "$$et{INDENT}Added Local ID $pid = $t2 ($format)\n");
+            }
+            $$ee{'keys'}{$id} = { TagID => $tagID, Format => $format };
+        }
+        $$et{INDENT} = $oldIndent;
+    }
+    return 1;
+}
+
+#------------------------------------------------------------------------------
+# We found some tags for this sample, so set document number and save timing information
+# Inputs: 0) ExifTool ref, 1) tag table ref, 2) sample time, 3) sample duration
+sub FoundSomething($$;$$)
+{
+    my ($et, $tagTbl, $time, $dur) = @_;
+    $$et{DOC_NUM} = ++$$et{DOC_COUNT};
+    $et->HandleTag($tagTbl, SampleTime => $time) if defined $time;
+    $et->HandleTag($tagTbl, SampleDuration => $dur) if defined $dur;
+}
+
+#------------------------------------------------------------------------------
+# Parse textual metadata
+# Inputs: 0) ExifTool ref, 1) tag table ref, 2) data ref
+sub ParseText($$$)
+{
+    my ($et, $tagTbl, $buffPt) = @_;
+    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+)/) {
+            $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) {
+                $et->HandleTag($tagTbl, GPSSpeed => $11 * $knotsToKph);
+                $et->HandleTag($tagTbl, GPSSpeedRef => 'K');
+            }
+            if (length $12) {
+                $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);
+        } elsif ($tag eq 'BEGINGSENSOR' and $dat =~ /^:([-+]\d+\.\d+):([-+]\d+\.\d+):([-+]\d+\.\d+)/) {
+            $et->HandleTag($tagTbl, Accelerometer => "$1 $2 $3");
+        } elsif ($tag eq 'TIME' and $dat =~ /^:(\d+)/) {
+            $et->HandleTag($tagTbl, TimeCode => $1 / ($$et{MediaTS} || 1));
+        } elsif ($tag eq 'BEGIN') {
+            $et->HandleTag($tagTbl, Text => $dat) if length $dat;
+        } elsif ($tag ne 'END') {
+            $et->HandleTag($tagTbl, Text => "\$$tag$dat");
+        }
+    }
+}
+
+#------------------------------------------------------------------------------
+# Exract embedded metadata from media samples
+# Inputs: 0) ExifTool ref
+# Notes: Also accesses ExifTool RAF*, SET_GROUP1, HandlerType, MetaFormat,
+#        ee*, and avcC elements (* = must exist)
+sub ProcessSamples($)
+{
+    my $et = shift;
+    my ($raf, $ee) = @$et{qw(RAF ee)};
+    my ($i, $buff, $pos, $hdrLen, $hdrFmt, @time, @dur, $oldIndent);
+
+    return unless $ee;
+    delete $$et{ee};    # use only once
+
+    # only process specific types of video streams
+    my $type = $$et{HandlerType} || '';
+    if ($type eq 'vide') {
+        if    ($$ee{avcC}) { $type = 'avcC' }
+        elsif ($$ee{JPEG}) { $type = 'JPEG' }
+        else { return }
+    }
+
+    my ($start, $size) = @$ee{qw(start size)};
+#
+# determine sample start offsets from chunk offsets (stco) and sample-to-chunk table (stsc),
+# and sample time/duration from time-to-sample (stts)
+#
+    unless ($start and $size) {
+        return unless $size;
+        my ($stco, $stsc, $stts) = @$ee{qw(stco stsc stts)};
+        return unless $stco and $stsc and @$stsc;
+        $start = [ ];
+        my ($nextChunk, $iChunk) = (0, 1);
+        my ($chunkStart, $startChunk, $samplesPerChunk, $descIdx, $timeCount, $timeDelta, $time);
+        if ($stts and @$stts > 1) {
+            $time = 0;
+            $timeCount = shift @$stts;
+            $timeDelta = shift @$stts;
+        }
+        my $ts = $$et{MediaTS} || 1;
+        foreach $chunkStart (@$stco) {
+            if ($iChunk >= $nextChunk and @$stsc) {
+                ($startChunk, $samplesPerChunk, $descIdx) = @{shift @$stsc};
+                $nextChunk = $$stsc[0][0] if @$stsc;
+            }
+            @$size < @$start + $samplesPerChunk and $et->WarnOnce('Sample size error'), return;
+            my $sampleStart = $chunkStart;
+            for ($i=0; ; ) {
+                push @$start, $sampleStart;
+                if (defined $time) {
+                    until ($timeCount) {
+                        if (@$stts < 2) {
+                            undef $time;
+                            last;
+                        }
+                        $timeCount = shift @$stts;
+                        $timeDelta = shift @$stts;
+                    }
+                    push @time, $time / $ts;
+                    push @dur, $timeDelta / $ts;
+                    $time += $timeDelta;
+                    --$timeCount;
+                }
+                # (eventually should use the description indices: $descIdx)
+                last if ++$i >= $samplesPerChunk;
+                $sampleStart += $$size[$#$start];
+            }
+            ++$iChunk;
+        }
+        @$start == @$size or $et->WarnOnce('Incorrect sample start/size count'), return;
+    }
+#
+# extract and parse the sample data
+#
+    my $tagTbl = GetTagTable('Image::ExifTool::QuickTime::Stream');
+    my $verbose = $et->Options('Verbose');
+    my $metaFormat = $$et{MetaFormat} || '';
+    my $tell = $raf->Tell();
+
+    if ($verbose) {
+        $et->VPrint(0, "---- Extract Embedded ----\n");
+        $oldIndent = $$et{INDENT};
+        $$et{INDENT} = '';
+    }
+    # get required information from avcC box if parsing video data
+    if ($type eq 'avcC') {
+        $hdrLen = (Get8u(\$$ee{avcC}, 4) & 0x03) + 1;
+        $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) {
+
+        # read the sample data
+        my $size = $$size[$i];
+        next unless $raf->Seek($$start[$i], 0) and $raf->Read($buff, $size) == $size;
+
+        if ($type eq 'avcC') {
+            next if length($buff) <= $hdrLen;
+            # scan through all NAL units and send them to ParseH264Video()
+            for ($pos=0; ; ) {
+                my $len = unpack("x$pos$hdrFmt", $buff);
+                last if $pos + $hdrLen + $len > length($buff);
+                my $tmp = "\0\0\0\x01" . substr($buff, $pos+$hdrLen, $len);
+                Image::ExifTool::H264::ParseH264Video($et, \$tmp);
+                $pos += $hdrLen + $len;
+                last if $pos + $hdrLen >= length($buff);
+            }
+            next;
+        }
+        if ($verbose > 1) {
+            my $hdr = $$et{SET_GROUP1} ? "$$et{SET_GROUP1} Type='${type}' Format='${metaFormat}'" : "Type='${type}'";
+            $et->VPrint(1, "${hdr}, Sample ".($i+1).' of '.scalar(@$start)." ($size bytes)\n");
+            $et->VerboseDump(\$buff, Addr => $$start[$i]);
+        }
+        if ($type eq 'text') {
+
+            FoundSomething($et, $tagTbl, $time[$i], $dur[$i]);
+            unless ($buff =~ /^\$BEGIN/) {
+                # remove ending "encd" box if it exists
+                $buff =~ s/\0\0\0\x0cencd\0\0\x01\0$// and $size -= 12;
+                # cameras such as the CanonPowerShotN100 store ASCII time codes with a
+                # leading 2-byte integer giving the length of the string
+                # (and chapter names start with a 2-byte integer too)
+                if ($size >= 2 and unpack('n',$buff) == $size - 2) {
+                    next if $size == 2;
+                    $buff = substr($buff,2);
+                }
+                my $val;
+                # check for encrypted GPS text as written by E-PRANCE B47FS camera
+                if ($buff =~ /^\0/ and $buff =~ /\x0a$/ and length($buff) > 5) {
+                    # decode simple ASCII difference cipher,
+                    # based on known value of 4th-last char = '*'
+                    my $dif = ord('*') - ord(substr($buff, -4, 1));
+                    my $tmp = pack 'C*',map { $_=($_+$dif)&0xff } unpack 'C*',substr $buff,1,-1;
+                    if ($verbose > 2) {
+                        $et->VPrint(0, "[decrypted text]\n");
+                        $et->VerboseDump(\$tmp);
+                    }
+                    if ($tmp =~ /^(.*?)(\$[A-Z]{2}RMC.*)/s) {
+                        ($val, $buff) = ($1, $2);
+                        $val =~ tr/\t/ /;
+                        $et->HandleTag($tagTbl, RawGSensor => $val) if length $val;
+                    }
+                } elsif ($buff =~ /^PNDM/ and length $buff >= 20) {
+                    # Garmin Dashcam format (actually binary, not text)
+                    $et->HandleTag($tagTbl, GPSLatitude  => Get32s(\$buff, 12) * 180/0x80000000);
+                    $et->HandleTag($tagTbl, GPSLongitude => Get32s(\$buff, 16) * 180/0x80000000);
+                    $et->HandleTag($tagTbl, GPSSpeed => Get16u(\$buff, 8));
+                    $et->HandleTag($tagTbl, GPSSpeedRef => 'M');
+                    next;
+                }
+                unless (defined $val) {
+                    $et->HandleTag($tagTbl, Text => $buff); # just store any other text
+                    next;
+                }
+            }
+            ParseText($et, $tagTbl, \$buff);
+
+        } elsif ($processByMetaFormat{$type}) {
+
+            if ($$tagTbl{$metaFormat}) {
+                my $tagInfo = $et->GetTagInfo($tagTbl, $metaFormat, \$buff);
+                if ($tagInfo) {
+                    FoundSomething($et, $tagTbl, $time[$i], $dur[$i]);
+                    $$et{ee} = $ee; # need ee information for 'keys'
+                    $et->HandleTag($tagTbl, $metaFormat, undef,
+                        DataPt  => \$buff,
+                        Base    => $$start[$i],
+                        TagInfo => $tagInfo,
+                    );
+                    delete $$et{ee};
+                } elsif ($metaFormat eq 'camm' and $buff =~ /^X/) {
+                    # seen 'camm' metadata in this format (X/Y/Z acceleration and G force? + GPRMC + ?)
+                    # "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);
+                }
+            } elsif ($verbose) {
+                $et->VPrint(0, "Unknown meta format ($metaFormat)");
+            }
+
+        } elsif ($type eq 'gps ') { # (ie. GPSDataList tag)
+
+            if ($buff =~ /^....freeGPS /s) {
+                # decode "freeGPS " data (Novatek)
+                ProcessFreeGPS($et, {
+                    DataPt => \$buff,
+                    SampleTime => $time[$i],
+                    SampleDuration => $dur[$i],
+                }, $tagTbl) ;
+            }
+
+        } elsif ($$tagTbl{$type}) {
+
+            my $tagInfo = $et->GetTagInfo($tagTbl, $type, \$buff);
+            if ($tagInfo) {
+                FoundSomething($et, $tagTbl, $time[$i], $dur[$i]);
+                $et->HandleTag($tagTbl, $type, undef,
+                    DataPt  => \$buff,
+                    Base    => $$start[$i],
+                    TagInfo => $tagInfo,
+                );
+            }
+        }
+    }
+    if ($verbose) {
+        $$et{INDENT} = $oldIndent;
+        $et->VPrint(0, "--------------------------\n");
+    }
+    # clean up
+    $raf->Seek($tell, 0); # restore original file position
+    $$et{DOC_NUM} = 0;
+    $$et{HandlerType} = $$et{HanderDesc} = '';
+}
+
+#------------------------------------------------------------------------------
+# Process "freeGPS " data blocks referenced by a 'gps ' (GPSDataList) atom
+# Inputs: 0) ExifTool ref, 1) dirInfo ref {DataPt,SampleTime,SampleDuration}, 2) tagTable ref
+# Returns: 1 on success (or 0 on unrecognized or "measurement-void" GPS data)
+# Notes:
+# - also see ProcessFreeGPS2() below for processing of other types of freeGPS blocks
+sub ProcessFreeGPS($$$)
+{
+    my ($et, $dirInfo, $tagTbl) = @_;
+    my $dataPt = $$dirInfo{DataPt};
+    my $dirLen = length $$dataPt;
+    my ($yr, $mon, $day, $hr, $min, $sec, $stat, $lbl);
+    my ($lat, $latRef, $lon, $lonRef, $spd, $trk, $alt, @acc, @xtra);
+
+    return 0 if $dirLen < 92;
+
+    if (substr($$dataPt,12,1) eq "\x05") {
+
+        # decode encrypted ASCII-based GPS (DashCam Azdome GS63H, ref 5)
+        # header looks like this in my sample:
+        #  0000: 00 00 80 00 66 72 65 65 47 50 53 20 05 01 00 00 [....freeGPS ....]
+        #  0010: 01 03 aa aa f2 e1 f0 ee 54 54 98 9a 9b 92 9a 93 [........TT......]
+        #  0020: 98 9e 98 98 9e 93 98 92 a6 9f 9f 9c 9d ed fa 8a [................]
+        my $n = $dirLen - 18;
+        $n = 0x101 if $n > 0x101;
+        my $buf2 = pack 'C*', map { $_ ^ 0xaa } unpack 'C*', substr($$dataPt,18,$n);
+        if ($et->Options('Verbose') > 1) {
+            $et->VPrint(1, '[decrypted freeGPS data]');
+            $et->VerboseDump(\$buf2);
+        }
+        # (extract longitude as 9 digits, not 8, ref PH)
+        return 0 unless $buf2 =~ /^.{8}(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2}).(.{15})([NS])(\d{8})([EW])(\d{9})(\d{8})/s;
+        ($yr,$mon,$day,$hr,$min,$sec,$lbl,$latRef,$lat,$lonRef,$lon,$spd) = ($1,$2,$3,$4,$5,$6,$7,$8,$9/1e4,$10,$11/1e4,$12);
+        $spd += 0;  # remove leading 0's
+        $lbl =~ s/\0.*//s;  $lbl =~ s/\s+$//;  # truncate at null and remove trailing spaces
+        push @xtra, UserLabel => $lbl if length $lbl;
+        # extract accelerometer data (ref PH)
+        @acc = ($1/100,$2/100,$3/100) if $buf2 =~ /^.{173}([-+]\d{3})([-+]\d{3})([-+]\d{3})/s;
+
+    } elsif ($$dataPt =~ /^.{52}(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})/s) {
+
+        # decode NMEA-format GPS data (NextBase 512GW dashcam, ref PH)
+        # header looks like this in my sample:
+        #  0000: 00 00 80 00 66 72 65 65 47 50 53 20 40 01 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 [................]
+        push @xtra, CameraDateTime => "$1:$2:$3 $4:$5:$6";
+        if ($$dataPt =~ /\$[A-Z]{2}RMC,(\d{2})(\d{2})(\d+(\.\d*)?),A?,(\d+\.\d+),([NS]),(\d+\.\d+),([EW]),(\d*\.?\d*),(\d*\.?\d*),(\d{2})(\d{2})(\d+)/s) {
+            ($lat,$latRef,$lon,$lonRef) = ($5,$6,$7,$8);
+            $yr = $13 + ($13 >= 70 ? 1900 : 2000);
+            ($mon,$day,$hr,$min,$sec) = ($12,$11,$1,$2,$3);
+            $spd = $9 * $knotsToKph if length $9;
+            $trk = $10 if length $10;
+        }
+        if ($$dataPt =~ /\$[A-Z]{2}GGA,(\d{2})(\d{2})(\d+(\.\d*)?),(\d+\.\d+),([NS]),(\d+\.\d+),([EW]),[1-6]?,(\d+)?,(\.\d+|\d+\.?\d*)?,(-?\d+\.?\d*)?,M?/s) {
+            ($hr,$min,$sec,$lat,$latRef,$lon,$lonRef) = ($1,$2,$3,$5,$6,$7,$8) unless defined $yr;
+            $alt = $11;
+            unshift @xtra, GPSSatellites => $9;
+            unshift @xtra, GPSDOP => $10;
+        }
+        if (defined $lat) {
+            # extract accelerometer readings if GPS was valid
+            @acc = unpack('x68V3', $$dataPt);
+            # change to signed integer and divide by 256
+            map { $_ = $_ - 4294967296 if $_ >= 0x80000000; $_ /= 256 } @acc;
+        }
+
+    } else {
+
+        # decode binary GPS format (Viofo A119S, ref 2)
+        # header looks like this in my sample:
+        #  0000: 00 00 80 00 66 72 65 65 47 50 53 20 4c 00 00 00 [....freeGPS L...]
+        #  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 [................]
+        # (records are same structure as Type 3 Novatek GPS in ProcessFreeGPS2() below)
+        ($hr,$min,$sec,$yr,$mon,$day,$stat,$latRef,$lonRef,$lat,$lon,$spd,$trk) =
+            unpack('x48V6a1a1a1x1V4', $$dataPt);
+        # ignore invalid fixes
+        return 0 unless $stat eq 'A' and ($latRef eq 'N' or $latRef eq 'S') and
+                                         ($lonRef eq 'E' or $lonRef eq 'W');
+        ($lat,$lon,$spd,$trk) = unpack 'f*', pack 'L*', $lat, $lon, $spd, $trk;
+        $yr += 2000 if $yr < 2000;
+        $spd *= $knotsToKph;    # convert speed to km/h
+        # ($trk is not confirmed; may be GPSImageDirection, ref PH)
+    }
+#
+# save tag values extracted by above code
+#
+    FoundSomething($et, $tagTbl, $$dirInfo{SampleTime}, $$dirInfo{SampleDuration});
+    # lat/long are in DDDMM.MMMM format
+    my $deg = int($lat / 100);
+    $lat = $deg + ($lat - $deg * 100) / 60;
+    $deg = int($lon / 100);
+    $lon = $deg + ($lon - $deg * 100) / 60;
+    $sec = '0' . $sec unless $sec =~ /^\d{2}/;   # pad integer part of seconds to 2 digits
+    if (defined $yr) {
+        my $time = sprintf('%.4d:%.2d:%.2d %.2d:%.2d:%sZ',$yr,$mon,$day,$hr,$min,$sec);
+        $et->HandleTag($tagTbl, GPSDateTime => $time);
+    } elsif (defined $hr) {
+        my $time = sprintf('%.2d:%.2d:%sZ',$hr,$min,$sec);
+        $et->HandleTag($tagTbl, GPSTimeStamp => $time);
+    }
+    $et->HandleTag($tagTbl, GPSLatitude  => $lat * ($latRef eq 'S' ? -1 : 1));
+    $et->HandleTag($tagTbl, GPSLongitude => $lon * ($lonRef eq 'W' ? -1 : 1));
+    $et->HandleTag($tagTbl, GPSAltitude  => $alt) if defined $alt;
+    if (defined $spd) {
+        $et->HandleTag($tagTbl, GPSSpeed => $spd);
+        $et->HandleTag($tagTbl, GPSSpeedRef => 'K');
+    }
+    if (defined $trk) {
+        $et->HandleTag($tagTbl, GPSTrack => $trk);
+        $et->HandleTag($tagTbl, GPSTrackRef => 'T');
+    }
+    while (@xtra) {
+        my $tag = shift @xtra;
+        $et->HandleTag($tagTbl, $tag => shift @xtra);
+    }
+    $et->HandleTag($tagTbl, Accelerometer => \@acc) if @acc;
+    return 1;
+}
+
+#------------------------------------------------------------------------------
+# Process "freeGPS " data blocks _not_ referenced by a 'gps ' atom
+# Inputs: 0) ExifTool ref, 1) dirInfo ref {DataPt,DataPos,DirLen}, 2) tagTable ref
+# Returns: 1 on success
+# Notes:
+# - also see ProcessFreeGPS() above
+sub ProcessFreeGPS2($$$)
+{
+    my ($et, $dirInfo, $tagTbl) = @_;
+    my $dataPt = $$dirInfo{DataPt};
+    my $dirLen = $$dirInfo{DirLen};
+    my ($yr, $mon, $day, $hr, $min, $sec, $pos);
+    my ($lat, $latRef, $lon, $lonRef, $spd, $trk, $alt, $ddd, $unk);
+
+    return 0 if $dirLen < 82;   # minimum size of block with a single GPS record
+
+    if (substr($$dataPt,0x45,3) eq 'ATC') {
+
+        # header looks like this: (sample 1)
+        #  0000: 00 00 80 00 66 72 65 65 47 50 53 20 38 06 00 00 [....freeGPS 8...]
+        #  0010: 49 51 53 32 30 31 33 30 33 30 36 42 00 00 00 00 [IQS20130306B....]
+        #  0020: 4d 61 79 20 31 35 20 32 30 31 35 2c 20 31 39 3a [May 15 2015, 19:]
+        # (sample 2)
+        #  0000: 00 00 80 00 66 72 65 65 47 50 53 20 4c 06 00 00 [....freeGPS L...]
+        #  0010: 32 30 31 33 30 33 31 38 2e 30 31 00 00 00 00 00 [20130318.01.....]
+        #  0020: 4d 61 72 20 31 38 20 32 30 31 33 2c 20 31 34 3a [Mar 18 2013, 14:]
+
+        my ($recPos, $lastRecPos, $foundNew);
+        my $verbose = $et->Options('Verbose');
+        my $dataPos = $$dirInfo{DataPos};
+        my $then = $$et{FreeGPS2}{Then};
+        $then or $then = $$et{FreeGPS2}{Then} = [ (0) x 6 ];
+        # Loop through records in the ATC-type GPS block until we find the most recent.
+        # If we have already found one, then we only need to check the first record
+        # (in case the buffer wrapped around), and the record after the position of
+        # the last record we found, because the others will be old.  Odd, but this
+        # is the way it is done...  I have only seen one new 52-byte record in the
+        # entire 32 kB block, but the entire device ring buffer (containing 30
+        # entries in my samples) is stored every time.  The code below allows for
+        # the possibility of missing blocks and multiple new records in a single
+        # block, but I have never seen this.  Note that there may be some earlier
+        # GPS records at the end of the first block that we will miss decoding, but
+        # these should (I believe) be before the start of the video
+ATCRec: for ($recPos = 0x30; $recPos + 52 < $dirLen; $recPos += 52) {
+
+            my $a = substr($$dataPt, $recPos, 52); # isolate a single record
+            # decrypt record
+            my @a = unpack('C*', $a);
+            my ($key1, $key2) = @a[0x14, 0x1c];
+            $a[$_] ^= $key1 foreach 0x00..0x14, 0x18..0x1b;
+            $a[$_] ^= $key2 foreach 0x1c, 0x20..0x32;
+            my $b = pack 'C*', @a;
+            # unpack and validate date/time
+            my @now = unpack 'x13C3x28vC2', $b; # (H-1,M,S,Y,m,d)
+            $now[0] = ($now[0] + 1) & 0xff;     # increment hour
+            my $i;
+            for ($i=0; $i<@dateMax; ++$i) {
+                next if $now[$i] <= $dateMax[$i];
+                $et->WarnOnce('Invalid GPS date/time');
+                next ATCRec;    # ignore this record
+            }
+            # look for next ATC record in temporal sequence
+            foreach $i (3..5, 0..2) {
+                if ($now[$i] < $$then[$i]) {
+                    last ATCRec if $foundNew;
+                    last;
+                }
+                next if $now[$i] == $$then[$i];
+                # we found a more recent record -- extract it and remember its location
+                if ($verbose) {
+                    $et->VPrint(2, "  + [encrypted GPS record]\n");
+                    $et->VerboseDump(\$a, DataPos => $dataPos + $recPos);
+                    $et->VPrint(2, "  + [decrypted GPS record]\n");
+                    $et->VerboseDump(\$b);
+                    #my @v = unpack 'H8VVC4V!CA3V!CA3VvvV!vCCCCH4', $b;
+                    #$et->VPrint(2, "  + [unpacked: @v]\n");
+                    # values unpacked above (ref PH):
+                    #  0) 0x00 4 bytes - byte 0=1, 1=counts to 255, 2=record index, 3=0 (ref 3)
+                    #  1) 0x04 4 bytes - int32u: bits 0-4=day, 5-8=mon, 9-19=year (ref 3)
+                    #  2) 0x08 4 bytes - int32u: bits 0-5=sec, 6-11=min, 12-16=hour (ref 3)
+                    #  3) 0x0c 1 byte  - seen values of 0,1,2 - GPS status maybe?
+                    #  4) 0x0d 1 byte  - hour minus 1
+                    #  5) 0x0e 1 byte  - minute
+                    #  6) 0x0f 1 byte  - second
+                    #  7) 0x10 4 bytes - int32s latitude * 1e7
+                    #  8) 0x14 1 byte  - always 0 (used for decryption)
+                    #  9) 0x15 3 bytes - always "ATC"
+                    # 10) 0x18 4 bytes - int32s longitude * 1e7
+                    # 11) 0x1c 1 byte  - always 0 (used for decryption)
+                    # 12) 0x1d 3 bytes - always "001"
+                    # 13) 0x20 4 bytes - int32s speed * 100 (m/s)
+                    # 14) 0x24 2 bytes - int16u heading * 100 (-180 to 180 deg)
+                    # 15) 0x26 2 bytes - always zero
+                    # 16) 0x28 4 bytes - int32s altitude * 1000 (ref 3)
+                    # 17) 0x2c 2 bytes - int16u year
+                    # 18) 0x2e 1 byte  - month
+                    # 19) 0x2f 1 byte  - day
+                    # 20) 0x30 1 byte  - unknown
+                    # 21) 0x31 1 byte  - always zero
+                    # 22) 0x32 2 bytes - checksum ?
+                }
+                @$then = @now;
+                $$et{DOC_NUM} = ++$$et{DOC_COUNT};
+                $trk = Get16s(\$b, 0x24) / 100;
+                $trk += 360 if $trk < 0;
+                my $time = sprintf('%.4d:%.2d:%.2d %.2d:%.2d:%.2dZ', @now[3..5, 0..2]);
+                $et->HandleTag($tagTbl, GPSDateTime  => $time);
+                $et->HandleTag($tagTbl, GPSLatitude  => Get32s(\$b, 0x10) / 1e7);
+                $et->HandleTag($tagTbl, GPSLongitude => Get32s(\$b, 0x18) / 1e7);
+                $et->HandleTag($tagTbl, GPSSpeed     => Get32s(\$b, 0x20) / 100 * $mpsToKph);
+                $et->HandleTag($tagTbl, GPSSpeedRef  => 'K');
+                $et->HandleTag($tagTbl, GPSTrack     => $trk);
+                $et->HandleTag($tagTbl, GPSTrackRef  => 'T');
+                $et->HandleTag($tagTbl, GPSAltitude  => Get32s(\$b, 0x28) / 1000);
+                $lastRecPos = $recPos;
+                $foundNew = 1;
+                # don't skip to location of previous recent record in ring buffer
+                # since we found a more recent record here
+                delete $$et{FreeGPS2}{RecentRecPos};
+                last;
+            }
+            # skip older records
+            my $recentRecPos = $$et{FreeGPS2}{RecentRecPos};
+            $recPos = $recentRecPos if $recentRecPos and $recPos < $recentRecPos;
+        }
+        # save position of most recent record (needed when parsing the next freeGPS block)
+        $$et{FreeGPS2}{RecentRecPos} = $lastRecPos;
+        return 1;
+
+    } elsif ($$dataPt =~ /^.{60}A\0.{10}([NS])\0.{14}([EW])\0/s) {
+
+        # header looks like this in my sample:
+        #  0000: 00 00 80 00 66 72 65 65 47 50 53 20 08 01 00 00 [....freeGPS ....]
+        #  0010: 32 30 31 33 30 38 31 35 2e 30 31 00 00 00 00 00 [20130815.01.....]
+        #  0020: 4a 75 6e 20 31 30 20 32 30 31 37 2c 20 31 34 3a [Jun 10 2017, 14:]
+
+        # Type 2 (ref PH):
+        # 0x30 - int32u hour
+        # 0x34 - int32u minute
+        # 0x38 - int32u second
+        # 0x3c - int32u GPS status ('A' or 'V')
+        # 0x40 - double latitude  (DDMM.MMMMMM)
+        # 0x48 - int32u latitude ref  ('N' or 'S')
+        # 0x50 - double longitude (DDMM.MMMMMM)
+        # 0x58 - int32u longitude ref ('E' or 'W')
+        # 0x60 - double speed (knots)
+        # 0x68 - double heading (deg)
+        # 0x70 - int32u year - 2000
+        # 0x74 - int32u month
+        # 0x78 - int32u day
+        ($latRef, $lonRef) = ($1, $2);
+        ($hr,$min,$sec,$yr,$mon,$day) = unpack('x48V3x52V3', $$dataPt);
+        $lat = GetDouble($dataPt, 0x40);
+        $lon = GetDouble($dataPt, 0x50);
+        $spd = GetDouble($dataPt, 0x60) * $knotsToKph;
+        $trk = GetDouble($dataPt, 0x68);
+
+    } elsif ($$dataPt =~ /^.{72}A([NS])([EW])/s) {
+
+        # Type 3 (Novatek GPS, ref 2): (in case it wasn't decoded via 'gps ' atom)
+        # 0x30 - int32u hour
+        # 0x34 - int32u minute
+        # 0x38 - int32u second
+        # 0x3c - int32u year - 2000
+        # 0x40 - int32u month
+        # 0x44 - int32u day
+        # 0x48 - int8u  GPS status ('A' or 'V')
+        # 0x49 - int8u  latitude ref  ('N' or 'S')
+        # 0x4a - int8u  longitude ref ('E' or 'W')
+        # 0x4b - 0
+        # 0x4c - float  latitude  (DDMM.MMMMMM)
+        # 0x50 - float  longitude (DDMM.MMMMMM)
+        # 0x54 - float  speed (knots)
+        # 0x58 - float  heading (deg)
+        # Type 3b, same as above for 0x30-0x4a (ref PH)
+        # 0x4c - int32s latitude (decimal degrees * 1e7)
+        # 0x50 - int32s longitude (decimal degrees * 1e7)
+        # 0x54 - int32s speed (m/s * 100)
+        # 0x58 - float  altitude (m * 1000, NC)
+        ($latRef, $lonRef) = ($1, $2);
+        ($hr,$min,$sec,$yr,$mon,$day) = unpack('x48V6', $$dataPt);
+        if (substr($$dataPt, 16, 3) eq 'IQS') {
+            # Type 3b (ref PH)
+            # header looks like this in my sample:
+            #  0000: 00 00 80 00 66 72 65 65 47 50 53 20 4c 00 00 00 [....freeGPS L...]
+            #  0010: 49 51 53 5f 41 37 5f 32 30 31 35 30 34 31 37 00 [IQS_A7_20150417.]
+            #  0020: 4d 61 72 20 32 39 20 32 30 31 37 2c 20 31 36 3a [Mar 29 2017, 16:]
+            $ddd = 1;
+            $lat = abs Get32s($dataPt, 0x4c) / 1e7;
+            $lon = abs Get32s($dataPt, 0x50) / 1e7;
+            $spd = Get32s($dataPt, 0x54) / 100 * $mpsToKph;
+            $alt = GetFloat($dataPt, 0x58) / 1000; # (NC)
+        } else {
+            # Type 3 (ref 2)
+            # (no sample with this format)
+            $lat = GetFloat($dataPt, 0x4c);
+            $lon = GetFloat($dataPt, 0x50);
+            $spd = GetFloat($dataPt, 0x54) * $knotsToKph;
+            $trk = GetFloat($dataPt, 0x58);
+        }
+
+    } else {
+
+        # (look for binary GPS as stored by NextBase 512G, ref PH)
+        # header looks like this in my sample:
+        #  0000: 00 00 80 00 66 72 65 65 47 50 53 20 78 01 00 00 [....freeGPS x...]
+        #  0010: 78 2e 78 78 00 00 00 00 00 00 00 00 00 00 00 00 [x.xx............]
+        #  0020: 30 30 30 30 30 00 00 00 00 00 00 00 00 00 00 00 [00000...........]
+
+        # followed by a number of 32-byte records in this format (big endian!):
+        # 0x30 - int16u unknown (seen: 0x24 0x53 = "$S")
+        # 0x32 - int16u speed (m/s * 100)
+        # 0x34 - int16s heading (deg * 100) (or GPSImgDirection?)
+        # 0x36 - int16u year
+        # 0x38 - int8u  month
+        # 0x39 - int8u  day
+        # 0x3a - int8u  hour
+        # 0x3b - int8u  min
+        # 0x3c - int16u sec * 10
+        # 0x3e - int8u  unknown (seen: 2)
+        # 0x3f - int32s latitude (decimal degrees * 1e7)
+        # 0x43 - int32s longitude (decimal degrees * 1e7)
+        # 0x47 - int8u  unknown (seen: 16)
+        # 0x48-0x4f -   all zero
+        for ($pos=0x32; ; ) {
+            ($spd,$trk,$yr,$mon,$day,$hr,$min,$sec,$unk,$lat,$lon) = unpack "x${pos}nnnCCCCnCNN", $$dataPt;
+            # validate record using date/time
+            last if $yr < 2000 or $yr > 2200 or
+                    $mon < 1 or $mon > 12 or
+                    $day < 1 or $day > 31 or
+                    $hr > 59 or $min > 59 or $sec > 600;
+            # change lat/lon to signed integer and divide by 1e7
+            map { $_ = $_ - 4294967296 if $_ >= 0x80000000; $_ /= 1e7 } $lat, $lon;
+            $trk -= 0x10000 if $trk >= 0x8000;  # make it signed
+            $trk /= 100;
+            $trk += 360 if $trk < 0;
+            my $time = sprintf("%.4d:%.2d:%.2d %.2d:%.2d:%04.1fZ", $yr, $mon, $day, $hr, $min, $sec/10);
+            $$et{DOC_NUM} = ++$$et{DOC_COUNT};
+            $et->HandleTag($tagTbl, GPSDateTime  => $time);
+            $et->HandleTag($tagTbl, GPSLatitude  => $lat);
+            $et->HandleTag($tagTbl, GPSLongitude => $lon);
+            $et->HandleTag($tagTbl, GPSSpeed     => $spd / 100 * $mpsToKph);
+            $et->HandleTag($tagTbl, GPSSpeedRef  => 'K');
+            $et->HandleTag($tagTbl, GPSTrack     => $trk);
+            $et->HandleTag($tagTbl, GPSTrackRef  => 'T');
+            last if $pos += 0x20 > length($$dataPt) - 0x1e;
+        }
+        return $$et{DOC_NUM} ? 1 : 0;   # return 0 if nothing extracted
+    }
+#
+# save tag values extracted by above code
+#
+    return 0 if $mon < 1 or $mon > 12;  # quick sanity check
+    $$et{DOC_NUM} = ++$$et{DOC_COUNT};
+    $yr += 2000 if $yr < 2000;
+    my $time = sprintf('%.4d:%.2d:%.2d %.2d:%.2d:%.2dZ', $yr, $mon, $day, $hr, $min, $sec);
+    # convert from DDMM.MMMMMM to DD.DDDDDD format if necessary
+    unless ($ddd) {
+        my $deg = int($lat / 100);
+        $lat = $deg + ($lat - $deg * 100) / 60;
+        $deg = int($lon / 100);
+        $lon = $deg + ($lon - $deg * 100) / 60;
+    }
+    $et->HandleTag($tagTbl, GPSDateTime  => $time);
+    $et->HandleTag($tagTbl, GPSLatitude  => $lat * ($latRef eq 'S' ? -1 : 1));
+    $et->HandleTag($tagTbl, GPSLongitude => $lon * ($lonRef eq 'W' ? -1 : 1));
+    $et->HandleTag($tagTbl, GPSSpeed     => $spd); # (now in km/h)
+    $et->HandleTag($tagTbl, GPSSpeedRef  => 'K');
+    if (defined $trk) {
+        $et->HandleTag($tagTbl, GPSTrack     => $trk);
+        $et->HandleTag($tagTbl, GPSTrackRef  => 'T');
+    }
+    if (defined $alt) {
+        $et->HandleTag($tagTbl, GPSAltitude  => $alt);
+    }
+    return 1;
+}
+
+#------------------------------------------------------------------------------
+# Extract embedded information referenced from a track
+# Inputs: 0) ExifTool ref, 1) tag name, 2) data ref
+sub ParseTag($$$)
+{
+    local $_;
+    my ($et, $tag, $dataPt) = @_;
+    my $dataLen = length $$dataPt;
+
+    if ($tag eq 'stsz' or $tag eq 'stz2' and $dataLen > 12) {
+        # read the sample sizes
+        my ($sz, $num) = unpack('x4N2', $$dataPt);
+        my $size = $$et{ee}{size} = [ ];
+        if ($tag eq 'stsz') {
+            if ($sz == 0) {
+                @$size = ReadValue($dataPt, 12, 'int32u', $num, $dataLen-12);
+            } else {
+                @$size = ($sz) x $num;
+            }
+        } else {
+            $sz &= 0xff;
+            if ($sz == 4) {
+                my @tmp = ReadValue($dataPt, 12, 'int8u', int(($num+1)/2), $dataLen-12);
+                foreach (@tmp) {
+                    push @$size, $_ >> 4;
+                    push @$size, $_ & 0xff;
+                }
+            } elsif ($sz == 8 || $sz == 16) {
+                @$size = ReadValue($dataPt, 12, "int${sz}u", $num, $dataLen-12);
+            }
+        }
+    } elsif ($tag eq 'stco' or $tag eq 'co64' and $dataLen > 8) {
+        # read the chunk offsets
+        my $num = unpack('x4N', $$dataPt);
+        my $stco = $$et{ee}{stco} = [ ];
+        @$stco = ReadValue($dataPt, 8, $tag eq 'stco' ? 'int32u' : 'int64u', $num, $dataLen-8);
+    } elsif ($tag eq 'stsc' and $dataLen > 8) {
+        # read the sample-to-chunk box
+        my $num = unpack('x4N', $$dataPt);
+        if ($dataLen >= 8 + $num * 12) {
+            my ($i, @stsc);
+            for ($i=0; $i<$num; ++$i) {
+                # list of (first-chunk, samples-per-chunk, sample-description-index)
+                push @stsc, [ unpack('x'.(8+$i*12).'N3', $$dataPt) ];
+            }
+            $$et{ee}{stsc} = \@stsc;
+        }
+    } elsif ($tag eq 'stts' and $dataLen > 8) {
+        # read the time-to-sample box
+        my $num = unpack('x4N', $$dataPt);
+        if ($dataLen >= 8 + $num * 8) {
+            $$et{ee}{stts} = [ unpack('x8N'.($num*2), $$dataPt) ];
+        }
+    } elsif ($tag eq 'avcC') {
+        # read the AVC compressor configuration
+        $$et{ee}{avcC} = $$dataPt if $dataLen >= 7;  # (minimum length is 7)
+    } elsif ($tag eq 'JPEG') {
+        $$et{ee}{JPEG} = $$dataPt;
+    } elsif ($tag eq 'gps ' and $dataLen > 8) {
+        # decode Novatek 'gps ' box (ref 2)
+        my $num = Get32u($dataPt, 4);
+        $num = int(($dataLen - 8) / 8) if $num * 8 + 8 > $dataLen;
+        my $start = $$et{ee}{start} = [ ];
+        my $size = $$et{ee}{size} = [ ];
+        my $i;
+        for ($i=0; $i<$num; ++$i) {
+            push @$start, Get32u($dataPt, 8 + $i * 8);
+            push @$size, Get32u($dataPt, 12 + $i * 8);
+        }
+        $$et{HandlerType} = $tag;   # fake handler type
+        ProcessSamples($et);        # we have all we need to process sample data now
+    }
+}
+
+#------------------------------------------------------------------------------
+# Process Yuneec 'tx3g' sbtl metadata (ref PH)
+# Inputs: 0) ExifTool object ref, 1) dirInfo ref, 2) tag table ref
+# Returns: 1 on success
+sub Process_tx3g($$$)
+{
+    my ($et, $dirInfo, $tagTablePtr) = @_;
+    my $dataPt = $$dirInfo{DataPt};
+    return 0 if length $$dataPt < 2;
+    pos($$dataPt) = 2;  # skip 2-byte length word
+    $et->HandleTag($tagTablePtr, $1, $2) while $$dataPt =~ /(\w+):([^:]*[^:\s])(\s|$)/sg;
+    return 1;
+}
+
+#------------------------------------------------------------------------------
+# Process QuickTime 'mebx' timed metadata
+# Inputs: 0) ExifTool ref, 1) dirInfo ref, 2) tag table ref
+# Returns: 1 on success
+# - uses tag ID keys stored in the ExifTool ee data member by a previous call to SaveMetaKeys
+sub Process_mebx($$$)
+{
+    my ($et, $dirInfo, $tagTbl) = @_;
+    my $ee = $$et{ee} or return 0;
+    return 0 unless $$ee{'keys'};
+    my $dataPt = $$dirInfo{DataPt};
+
+    # parse using information from 'keys' table (eg. Apple iPhone7+ hevc 'Core Media Data Handler')
+    $et->VerboseDir('mebx', undef, length $$dataPt);
+    my $pos = 0;
+    while ($pos + 8 < length $$dataPt) {
+        my $len = Get32u($dataPt, $pos);
+        last if $len < 8 or $pos + $len > length $$dataPt;
+        my $id = substr($$dataPt, $pos+4, 4);
+        my $info = $$ee{'keys'}{$id};
+        if ($info) {
+            my $tag = $$info{TagID};
+            unless ($$tagTbl{$tag}) {
+                next unless $tag =~ /^[-\w.]+$/;
+                # create info for tags with reasonable id's
+                my $name = $tag;
+                $name =~ s/[-.](.)/\U$1/g;
+                AddTagToTable($tagTbl, $tag, { Name => ucfirst($name) });
+            }
+            my $val = ReadValue($dataPt, $pos+8, $$info{Format}, undef, $len-8);
+            $et->HandleTag($tagTbl, $tag, $val,
+                DataPt => $dataPt,
+                Base   => $$dirInfo{Base},
+                Start  => $pos + 8,
+                Size   => $len - 8,
+            );
+        } else {
+            $et->WarnOnce('No key information for mebx ID ' . PrintableTagID($id,1));
+        }
+        $pos += $len;
+    }
+    return 1;
+}
+
+#------------------------------------------------------------------------------
+# Process QuickTime '3gf' timed metadata (Pittasoft Blackvue dashcam)
+# Inputs: 0) ExifTool ref, 1) dirInfo ref, 2) tag table ref
+# Returns: 1 on success
+sub Process_3gf($$$)
+{
+    my ($et, $dirInfo, $tagTbl) = @_;
+    my $dataPt = $$dirInfo{DataPt};
+    my $dirLen = $$dirInfo{DirLen};
+    my $recLen = 10;     # 10-byte record length
+    $et->VerboseDir('3gf', 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 $tc = Get32u($dataPt, $pos);
+        last if $tc == 0xffffffff;
+        my ($x, $y, $z) = (Get16s($dataPt, $pos+4)/10, Get16s($dataPt, $pos+6)/10, Get16s($dataPt, $pos+8)/10);
+        $et->HandleTag($tagTbl, TimeCode => $tc / 1000);
+        $et->HandleTag($tagTbl, Accelerometer => "$x $y $z");
+    }
+    delete $$et{DOC_NUM};
+    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
+# Returns: 1 on success
+sub Process_gps0($$$)
+{
+    my ($et, $dirInfo, $tagTbl) = @_;
+    my $dataPt = $$dirInfo{DataPt};
+    my $dirLen = $$dirInfo{DirLen};
+    my $recLen = 32;    # 32-byte record length
+    $et->VerboseDir('gps0', undef, $dirLen);
+    SetByteOrder('II');
+    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};
+        # lat/long are in DDDMM.MMMM format
+        my $lat = GetDouble($dataPt, $pos);
+        my $lon = GetDouble($dataPt, $pos+8);
+        next if abs($lat) > 9000 or abs($lon) > 18000;
+        # (note: this method works fine for negative coordinates)
+        my $deg = int($lat / 100);
+        $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
+        $a[0] += 2000;
+        $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($dataPt, $pos+0x14));
+        $et->HandleTag($tagTbl, GPSSpeedRef  => 'K');
+        $et->HandleTag($tagTbl, GPSTrack     => Get8u($dataPt, $pos+0x1c) * 2); # (NC)
+        $et->HandleTag($tagTbl, GPSTrackRef  => 'T');
+        $et->HandleTag($tagTbl, GPSAltitude  => Get32s($dataPt, $pos + 0x10));
+        # yet to be decoded:
+        # 0x1d - int8u[3] seen: "1 1 0"
+    }
+    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
+# Returns: 1 on success
+sub ProcessNMEA($$$)
+{
+    my ($et, $dirInfo, $tagTbl) = @_;
+    my $dataPt = $$dirInfo{DataPt};
+    # parse only RMC sentence (with leading timestamp) for now
+    while ($$dataPt =~ /(?:\[(\d+)\])?\$[A-Z]{2}RMC,(\d{2})(\d{2})(\d+(\.\d*)?),A?,(\d+\.\d+),([NS]),(\d+\.\d+),([EW]),(\d*\.?\d*),(\d*\.?\d*),(\d{2})(\d{2})(\d+)/g) {
+        my $tc = $1;    # milliseconds since 1970 (local time)
+        my ($lat,$latRef,$lon,$lonRef) = ($6,$7,$8,$9);
+        my $yr = $14 + ($14 >= 70 ? 1900 : 2000);
+        my ($mon,$day,$hr,$min,$sec) = ($13,$12,$2,$3,$4);
+        my ($spd, $trk);
+        $spd = $10 * $knotsToKph if length $10;
+        $trk = $11 if length $11;
+        # lat/long are in DDDMM.MMMM format
+        my $deg = int($lat / 100);
+        $lat = $deg + ($lat - $deg * 100) / 60;
+        $deg = int($lon / 100);
+        $lon = $deg + ($lon - $deg * 100) / 60;
+        $sec = '0' . $sec unless $sec =~ /^\d{2}/;   # pad integer part of seconds to 2 digits
+        my $time = sprintf('%.4d:%.2d:%.2d %.2d:%.2d:%sZ',$yr,$mon,$day,$hr,$min,$sec);
+        my $sampleTime;
+        $sampleTime = ($tc - $$et{StartTime}) / 1000 if $tc and $$et{StartTime};
+        FoundSomething($et, $tagTbl, $sampleTime);
+        $et->HandleTag($tagTbl, GPSDateTime => $time);
+        $et->HandleTag($tagTbl, GPSLatitude  => $lat * ($latRef eq 'S' ? -1 : 1));
+        $et->HandleTag($tagTbl, GPSLongitude => $lon * ($lonRef eq 'W' ? -1 : 1));
+        if (defined $spd) {
+            $et->HandleTag($tagTbl, GPSSpeed => $spd);
+            $et->HandleTag($tagTbl, GPSSpeedRef => 'K');
+        }
+        if (defined $trk) {
+            $et->HandleTag($tagTbl, GPSTrack => $trk);
+            $et->HandleTag($tagTbl, GPSTrackRef => 'T');
+        }
+    }
+    delete $$et{DOC_NUM};
+    return 1;
+}
+
+#------------------------------------------------------------------------------
+# Process TomTom Bandit Action Cam TTAD atom (ref PH)
+# Inputs: 0) ExifTool object ref, 1) dirInfo ref, 2) tag table ref
+# Returns: 1 on success
+my %ttLen = ( # lengths of known TomTom records
+    0 => 12,    # angular velocity (NC)
+    1 => 4,     # ?
+    2 => 12,    # ?
+    3 => 12,    # accelerometer (NC)
+    # (haven't seen a record 4 yet)
+    5 => 92,    # GPS
+    0xff => 4,  # timecode
+);
+sub ProcessTTAD($$$)
+{
+    my ($et, $dirInfo, $tagTbl) = @_;
+    my $dataPt = $$dirInfo{DataPt};
+    my $dirLen = $$dirInfo{DirLen};
+    my $pos = 76;
+
+    return 0 if $dirLen < $pos;
+
+    $et->VerboseDir('TTAD', undef, $dirLen);
+    SetByteOrder('II');
+
+    my $eeOpt = $et->Options('ExtractEmbedded');
+    my $unknown = $et->Options('Unknown');
+    my $found = 0;
+    my $sampleTime = 0;
+    my $resync = 1;
+    my $skipped = 0;
+    my $warned;
+
+    while ($pos < $dirLen) {
+        # get next record type
+        my $type = Get8u($dataPt, $pos++);
+        # resync if necessary by skipping data until next timecode record
+        if ($resync and $type != 0xff) {
+            ++$skipped > 0x100 and $et->Warn('Unrecognized or bad TTAD data', 1), last;
+            next;
+        }
+        unless ($ttLen{$type}) {
+            # skip unknown records
+            $et->Warn("Unknown TTAD record type $type",1) unless $warned;
+            $resync = $warned = 1;
+            ++$skipped;
+            next;
+        }
+        last if $pos + $ttLen{$type} > $dirLen;
+        if ($type == 0xff) {    # timecode?
+            my $tm = Get32u($dataPt, $pos);
+            # validate timecode if skipping unknown data
+            if ($resync) {
+                if ($tm < $sampleTime or $tm > $sampleTime + 250) {
+                    ++$skipped;
+                    next;
+                }
+                undef $resync;
+                $skipped = 0;
+            }
+            $pos += $ttLen{$type};
+            $sampleTime = $tm;
+            next;
+        }
+        unless ($eeOpt) {
+            # only extract one of each type without -ee option
+            $found & (1 << $type) and $pos += $ttLen{$type}, next;
+            $found |= (1 << $type);
+        }
+        if ($type == 0 or $type == 3) {
+            # (these are both just educated guesses - PH)
+            FoundSomething($et, $tagTbl, $sampleTime / 1000);
+            my @a = map { Get32s($dataPt,$pos+4*$_) / 1000 } 0..2;
+            $et->HandleTag($tagTbl, ($type ? 'Accelerometer' : 'AngularVelocity') => "@a");
+        } elsif ($type == 5) {
+            # example records unpacked with 'dVddddVddddv*'
+            # datetime                 ? spd  ele    lat        lon       ? trk   ?     ?      ?      ? ? ? ?     ? ?
+            # 2019:03:05 07:52:58.999Z 3 0.02 242    48.0254203 7.8497567 0 45.69 13.34 17.218 17.218 0 0 0 32760 5 0
+            # 2019:03:05 07:52:59.999Z 3 0.14 242    48.0254203 7.8497567 0 45.7  12.96 15.662 15.662 0 0 0 32760 5 0
+            # 2019:03:05 07:53:00.999Z 3 0.67 243.78 48.0254584 7.8497907 0 50.93  9.16 10.84  10.84  0 0 0 32760 5 0
+            # (I think "5" may be the number of satellites.  seen: 5,6,7 - PH)
+            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, GPSSpeed     => GetDouble($dataPt, $pos+0x0c) * $mpsToKph);
+            $et->HandleTag($tagTbl, GPSSpeedRef  => 'K');
+            $et->HandleTag($tagTbl, GPSTrack     => GetDouble($dataPt, $pos+0x30));
+            $et->HandleTag($tagTbl, GPSTrackRef  => 'T');
+            if ($unknown) {
+                my @a = map { GetDouble($dataPt, $pos+0x38+8*$_) } 0..2;
+                $et->HandleTag($tagTbl, Unknown03 => "@a");
+            }
+        } elsif ($type < 3) {
+            # as yet unknown:
+            # 1 - int32s[1]? (values around 98k)
+            # 2 - int32s[3] (values like "806 8124 4323" -- probably something * 1000 again)
+            if ($unknown) {
+                FoundSomething($et, $tagTbl, $sampleTime / 1000);
+                my $n = $type == 1 ? 0 : 2;
+                my @a = map { Get32s($dataPt,$pos+4*$_) } 0..$n;
+                $et->HandleTag($tagTbl, "Unknown0$type" => "@a");
+            }
+        } else {
+            $et->WarnOnce("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;
+        $pos += $ttLen{$type};
+    }
+    SetByteOrder('MM');
+    delete $$et{DOC_NUM};
+    return 1;
+}
+
+#------------------------------------------------------------------------------
+# Extract information from Insta360 trailer
+# Inputs: 0) ExifTool ref
+sub ProcessINSVTrailer($)
+{
+    local $_;
+    my $et = shift;
+    my $raf = $$et{RAF};
+    my $buff;
+
+    return unless $raf->Seek(-78, 2) and $raf->Read($buff, 78) == 78 and
+        substr($buff,-32) eq "8db42d694ccc418790edff439fe026bf";    # check magic number
+
+    my $tagTbl = GetTagTable('Image::ExifTool::QuickTime::Stream');
+    my $fileEnd = $raf->Tell();
+    my $trailerLen = unpack('x38V', $buff);
+    my $trailerStart = $fileEnd - $trailerLen;
+    my $unknown = $et->Options('Unknown');
+    my $verbose = $et->Options('Verbose');
+    my $pos = $fileEnd - 78;
+    my ($i, $p);
+    SetByteOrder('II');
+    # loop through all records in the trailer, from last to first
+    for (;;) {
+        my ($id, $len) = unpack('vV', $buff);
+        ($pos -= $len) < $trailerStart and last;
+        $raf->Seek($pos, 0) or last;
+        $raf->Read($buff, $len) == $len or last;
+        if ($verbose) {
+            $et->VPrint(0, sprintf("INSV Record 0x%x (offset 0x%x, %d bytes):\n", $id, $pos, $len));
+            $et->VerboseDump(\$buff);
+        }
+        my $dlen = $insvDataLen{$id};
+        if ($dlen) {
+            $len % $dlen and $et->Warn(sprintf('Unexpected INSV record 0x%x length',$id)), last;
+            if ($id == 0x300) {
+                for ($p=0; $p<$len; $p+=$dlen) {
+                    $$et{DOC_NUM} = ++$$et{DOC_COUNT};
+                    my @a = map { GetDouble(\$buff, $p + 8 * $_) } 1..6;
+                    $et->HandleTag($tagTbl, TimeCode => sprintf('%.3f', Get64u(\$buff, $p) / 1000));
+                    $et->HandleTag($tagTbl, Accelerometer => "@a[0..2]"); # (NC)
+                    $et->HandleTag($tagTbl, AngularVelocity => "@a[3..5]"); # (NC)
+                }
+            } elsif ($id == 0x400 and $unknown) {
+                for ($p=0; $p<$len; $p+=$dlen) {
+                    $$et{DOC_NUM} = ++$$et{DOC_COUNT};
+                    $et->HandleTag($tagTbl, TimeCode => sprintf('%.3f', Get64u(\$buff, $p) / 1000));
+                    $et->HandleTag($tagTbl, Unknown01 => GetDouble(\$buff, $p + 8));
+                }
+            } elsif ($id == 0x700) {
+                for ($p=0; $p<$len; $p+=$dlen) {
+                    my $tmp = substr($buff, $p, $dlen);
+                    my @a = unpack('VVvaa8aa8aa8a8a8', $tmp);
+                    next unless $a[3] eq 'A';   # (ignore void fixes)
+                    last unless ($a[5] eq 'N' or $a[5] eq 'S') and # (quick validation)
+                                ($a[7] eq 'E' or $a[7] eq 'W');
+                    $$et{DOC_NUM} = ++$$et{DOC_COUNT};
+                    $a[$_] = GetDouble(\$a[$_], 0) foreach 4,6,8,9,10;
+                    $a[4] *= -abs($a[4]) if $a[5] eq 'S'; # (abs just in case it was already signed)
+                    $a[6] *= -abs($a[6]) if $a[7] eq 'W';
+                    $et->HandleTag($tagTbl, GPSDateTime => Image::ExifTool::ConvertUnixTime($a[0]) . 'Z');
+                    $et->HandleTag($tagTbl, GPSLatitude => $a[4]);
+                    $et->HandleTag($tagTbl, GPSLongitude => $a[6]);
+                    $et->HandleTag($tagTbl, GPSSpeed => $a[8] * $mpsToKph);
+                    $et->HandleTag($tagTbl, GPSSpeedRef => 'K');
+                    $et->HandleTag($tagTbl, GPSTrack => $a[9]);
+                    $et->HandleTag($tagTbl, GPSTrackRef => 'T');
+                    $et->HandleTag($tagTbl, GPSAltitude => $a[10]);
+                    $et->HandleTag($tagTbl, Unknown02 => "@a[1,2]");
+                }
+            }
+        } elsif ($id == 0x101) {
+            my $tagTablePtr = GetTagTable('Image::ExifTool::QuickTime::INSV_MakerNotes');
+            for ($i=0, $p=0; $i<4; ++$i) {
+                last if $p + 2 > $len;
+                my ($t, $n) = unpack("x${p}CC", $buff);
+                last if $p + 2 + $n > $len;
+                my $val = substr($buff, $p+2, $n);
+                $et->HandleTag($tagTablePtr, $t, $val);
+                $p += 2 + $n;
+            }
+        }
+        ($pos -= 6) < $trailerStart and last;   # step back to previous record
+        $raf->Seek($pos, 0) or last;
+        $raf->Read($buff, 6) == 6 or last;
+    }
+    SetByteOrder('MM');
+}
+
+#------------------------------------------------------------------------------
+# Scan movie data for "freeGPS" metadata if not found already (ref PH)
+# Inputs: 0) ExifTool ref
+sub ScanMovieData($)
+{
+    my $et = shift;
+    my $raf = $$et{RAF} or return;
+    my ($tagTbl, $oldByteOrder, $verbose, $buff, $dataLen);
+    my ($pos, $buf2) = (0, '');
+
+    # don't rescan for freeGPS if we already found embedded metadata
+    my $dataPos = $$et{VALUE}{MovieDataOffset};
+    if ($dataPos and not $$et{DOC_COUNT}) {
+        $dataLen = $$et{VALUE}{MovieDataSize};
+        if ($dataLen) {
+            if ($raf->Seek($dataPos, 0)) {
+                $$et{FreeGPS2} = { };   # initialize variable space for FreeGPS2()
+            } else {
+                undef $dataLen;
+            }
+        }
+    }
+
+    # loop through 'mdat' movie data looking for GPS information
+    while ($dataLen) {
+        last if $pos + $gpsBlockSize > $dataLen;
+        last unless $raf->Read($buff, $gpsBlockSize);
+        $buff = $buf2 . $buff if length $buf2;
+        last if length $buff < $gpsBlockSize;
+        # look for "freeGPS " block
+        # (found on an absolute 0x8000-byte boundary in all of my samples,
+        #  but allow for any alignment when searching)
+        if ($buff !~ /\0..\0freeGPS /sg) { # (seen ".." = "\0\x80","\x01\0")
+            $buf2 = substr($buff,-12);
+            $pos += length($buff)-12;
+            # in all of my samples the first freeGPS block is within 2 MB of the start
+            # of the mdat, so limit the scan to the first 20 MB to be fast and safe
+            next if $tagTbl or $pos < 20e6;
+            last;
+        } elsif (not $tagTbl) {
+            # initialize variables for extracting metadata from this block
+            $tagTbl = GetTagTable('Image::ExifTool::QuickTime::Stream');
+            $verbose = $$et{OPTIONS}{Verbose};
+            $oldByteOrder = GetByteOrder();
+            SetByteOrder('II');
+            $et->VPrint(0, "---- Extract Embedded ----\n");
+            $$et{INDENT} .= '| ';
+        }
+        if (pos($buff) > 12) {
+            $pos += pos($buff) - 12;
+            $buff = substr($buff, pos($buff) - 12);
+        }
+        # make sure we have the full freeGPS record
+        my $len = unpack('N', $buff);
+        if ($len < 12) {
+            $len = 12;
+        } else {
+            my $more = $len - length($buff);
+            if ($more > 0) {
+                last unless $raf->Read($buf2, $more) == $more;
+                $buff .= $buf2;
+            }
+            if ($verbose) {
+                $et->VerboseDir('GPS', undef, $len);
+                $et->VerboseDump(\$buff, DataPos => $pos + $dataPos);
+            }
+            my $dirInfo = { DataPt => \$buff, DataPos => $pos + $dataPos, DirLen => $len };
+            ProcessFreeGPS2($et, $dirInfo, $tagTbl);
+        }
+        $pos += $len;
+        $buf2 = substr($buff, $len);
+    }
+    if ($tagTbl) {
+        $$et{DOC_NUM} = 0;
+        $et->VPrint(0, "--------------------------\n");
+        SetByteOrder($oldByteOrder);
+        $$et{INDENT} = substr $$et{INDENT}, 0, -2;
+    }
+    # process INSV trailer if it exists
+    ProcessINSVTrailer($et);
+}
+
+1;  # end
+
+__END__
+
+=head1 NAME
+
+Image::ExifTool::QuickTime - Extract embedded information from movie data
+
+=head1 SYNOPSIS
+
+These routines are autoloaded by Image::ExifTool::QuickTime.
+
+=head1 DESCRIPTION
+
+This file contains routines used by Image::ExifTool to extract embedded
+information like GPS tracks from MOV, MP4 and INSV movie data.
+
+=head1 AUTHOR
+
+Copyright 2003-2019, Phil Harvey (phil at owl.phy.queensu.ca)
+
+This library is free software; you can redistribute it and/or modify it
+under the same terms as Perl itself.
+
+=head1 REFERENCES
+
+=over 4
+
+=item Lhttps://developer.apple.com/library/content/documentation/QuickTime/QTFF/QTFFChap3/qtff3.html#//apple_ref/doc/uid/TP40000939-CH205-SW130>
+
+=item L<http://sergei.nz/files/nvtk_mp42gpx.py>
+
+=item L<https://forum.flitsservice.nl/dashcam-info/dod-ls460w-gps-data-uit-mov-bestand-lezen-t87926.html>
+
+=item L<https://developers.google.com/streetview/publish/camm-spec>
+
+=item L<https://sergei.nz/extracting-gps-data-from-viofo-a119-and-other-novatek-powered-cameras/>
+
+=back
+
+=head1 SEE ALSO
+
+L<Image::ExifTool::QuickTime(3pm)|Image::ExifTool::QuickTime>,
+L<Image::ExifTool::TagNames/QuickTime Stream Tags>,
+L<Image::ExifTool::TagNames/GoPro GPMF Tags>,
+L<Image::ExifTool::TagNames/Sony rtmd Tags>,
+L<Image::ExifTool(3pm)|Image::ExifTool>
+
+=cut
+