exiftool_vendored 13.04.0 → 13.06.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 374e7e5a3d68eeca0ec6cb6a40919d056e0731958606daa8bed45a7c4c70daba
-  data.tar.gz: 1263e0b2b35852265b4d5352eae7f35d12cffe0277f916799a8498c75482a9be
+  metadata.gz: 277daacb61b45f8ffcf01c45e8a2ae6c7814aa878af57ce5e700433e37a73a89
+  data.tar.gz: c27dc0342c61725b98adb52806417396827df205172ae6793f14bb6eb9d3949b
 SHA512:
-  metadata.gz: 7b5d47b1383f939d76af17239fb4f1e1a486ae619b0d728a010bde7e8ed044de0bfc93d755f8c0a22dfa098ddf997d84f1d7a3f562f07153d1486eee68744929
-  data.tar.gz: b8ba0c1b6c02546df4e54c6d5c4fe072cbb98bc4b6c5b1d0f1ac323ded4ca43e06ff5bcaaaf879005d37533df86f53262cba0dd87d1a09684f360a50a6d4834c
+  metadata.gz: acb79bdb9f29cb00439ad4006faba198b460abed0c655e1cce6d7a3845ec14c8fe19a778dcbdb5401bb5f77b51329329e9ab8a6932c98a9d04ff63ca04be9af0
+  data.tar.gz: 2771ca21af4d53e1d2138b4b94dd187f1e59c9f9c6230f8d3a8d83be61979b320570084a50f5ae5a3d038114a46cca518dca35e517d8304ed98087c73ceeb163

data/bin/Changes

@@ -7,6 +7,26 @@ RSS feed: https://exiftool.org/rss.xml
 Note: The most recent production release is Version 13.00. (Other versions are
 considered development releases, and are not uploaded to MetaCPAN.)
 
+Dec. 5, 2024 - Version 13.06
+
+  - Decode timed metadata from MP4 videos of yet another dashcam model
+  - Patched issue where FileSequence could increment twice for each file when a
+    -if condition was used
+  - API Changes:
+      - Revert default  WindowsLongPath option until we can solve the pipe
+        problem)
+
+Dec. 4, 2024 - Version 13.05
+
+  - Added a new SonyModelID
+  - Added support for XMP HDRGainMap and apdi namespaces
+  - Decode DJI timed djmd and dbgi protobuf-format metadata
+  - Decode APP10 AROT HDRGainCurve and APP2 URN UniformResourceName
+  - Decode a couple of new GoPro tags
+  - API Changes:
+      - Changed default  WindowsLongPath option to 1 (please report if this
+        causes any problems)
+
 Nov. 26, 2024 - Version 13.04
 
   - Added the ability to write GPSDOP and GPSMeasureMode from the -geotag option
@@ -21,6 +41,8 @@ Nov. 26, 2024 - Version 13.04
   - Renamed an Unknown Photoshop tag
   - Convert GoPro GPSSpeed and GPSSpeed3D from m/s to km/h
   - Patched to tolerate XML header in DOCX xml files
+  - Fixed incorrect file offsets for tags in some embedded files of -htmldump
+    output
   - Fixed -htmldump output to show the same names for unknown EXIF tags as with
     the -u option
 

data/bin/MANIFEST

@@ -397,6 +397,7 @@ lib/Image/ExifTool/PhotoMechanic.pm
 lib/Image/ExifTool/Photoshop.pm
 lib/Image/ExifTool/PostScript.pm
 lib/Image/ExifTool/PrintIM.pm
+lib/Image/ExifTool/Protobuf.pm
 lib/Image/ExifTool/Qualcomm.pm
 lib/Image/ExifTool/QuickTime.pm
 lib/Image/ExifTool/QuickTimeStream.pl

data/bin/META.json

@@ -50,5 +50,5 @@
       }
    },
    "release_status" : "stable",
-   "version" : "13.04"
+   "version" : "13.06"
 }

data/bin/META.yml

@@ -31,4 +31,4 @@ recommends:
   Time::HiRes: '0'
 requires:
   perl: '5.004'
-version: '13.04'
+version: '13.06'

data/bin/README

@@ -109,8 +109,8 @@ your home directory, then you would type the following commands in a
 terminal window to extract and run ExifTool:
 
   cd ~/Desktop
-  gzip -dc Image-ExifTool-13.04.tar.gz | tar -xf -
-  cd Image-ExifTool-13.04
+  gzip -dc Image-ExifTool-13.06.tar.gz | tar -xf -
+  cd Image-ExifTool-13.06
   ./exiftool t/images/ExifTool.jpg
 
 Note:  These commands extract meta information from one of the test images. 

data/bin/exiftool

@@ -11,7 +11,7 @@ use strict;
 use warnings;
 require 5.004;
 
-my $version = '13.04';
+my $version = '13.06';
 
 # add our 'lib' directory to the include list BEFORE 'use Image::ExifTool'
 my $exePath;
@@ -1918,7 +1918,7 @@ if (@dbKeys) {
                     print $vout "Imported entry for '${_}' (full path: '${absPath}')\n";
                 }
             } elsif ($verbose and $verbose > 1) {
-                print $vout "Imported entry for '${_}' (non-existent file)\n";
+                print $vout "Imported entry for '${_}' (no full path)\n";
             }
         }
     }
@@ -2172,7 +2172,10 @@ sub GetImageInfo($$)
         }
         # can't make use of $info if verbose because we must reprocess
         # the file anyway to generate the verbose output
-        undef $info if $verbose or defined $fastCondition or defined $diff;
+        if ($verbose or defined $fastCondition or defined $diff) {
+            undef $info;
+            --$$et{FILE_SEQUENCE};
+        }
     } elsif ($file =~ s/^(\@JSON:)(.*)/$1/) {
         # read JSON file from command line
         my $dat = $2;
@@ -4163,11 +4166,12 @@ sub ScanDir($$;$)
     }
     $dir =~ /\/$/ or $dir .= '/';   # make sure directory name ends with '/'
     foreach $file (@fileList) {
+        next if $file eq '.' or $file eq '..';
         my $path = "$dir$file";
         if ($et->IsDirectory($path)) {
             next unless $recurse;
             # ignore directories starting with "." by default
-            next if $file =~ /^\./ and ($recurse == 1 or $file eq '.' or $file eq '..');
+            next if $file =~ /^\./ and $recurse == 1;
             next if $ignore{$file} or ($ignore{SYMLINKS} and -l $path);
             ScanDir($et, $path, $list);
             last if $end;
@@ -4315,14 +4319,15 @@ sub AbsPath($)
 {
     my $file = shift;
     my $path;
-    if (defined $file and eval { require Cwd }) {
-        $path = eval { Cwd::abs_path($file) };
-        # make the delimiters and case consistent
-        # (abs_path is very inconsistent about what it returns in Windows)
-        if (defined $path and Image::ExifTool::IsPC()) {
-            $path =~ tr/\\/\//;
-            $path = lc $path;
+    if (defined $file) {
+        return undef if $file eq '*';   # (CSV SourceFile may be '*' -- no absolute path for that)
+        if ($^O eq 'MSWin32' and $mt->Options('WindowsLongPath')) {
+            $path = $mt->WindowsLongPath($file);
+        } elsif (eval { require Cwd }) {
+            local $SIG{'__WARN__'} = sub { };
+            $path = eval { Cwd::abs_path($file) };
         }
+        $path =~ tr/\\/\// if $^O eq 'MSWin32' and defined $path;   # use forward slashes
     }
     return $path;
 }
@@ -5907,7 +5912,7 @@ with this command:
 
 produces output like this:
 
-    -- Generated by ExifTool 13.04 --
+    -- Generated by ExifTool 13.06 --
     File: a.jpg - 2003:10:31 15:44:19
     (f/5.6, 1/60s, ISO 100)
     File: b.jpg - 2006:05:23 11:57:38
@@ -6022,7 +6027,8 @@ import).  May be combined with B<-s> to print tag names instead of
 descriptions, or B<-S> to print tag values only, tab-delimited on a single
 line.  The B<-t> option may be combined with B<-j>, B<-php> or B<-X> to add
 tag table information (C<table>, tag C<id>, and C<index> for cases where
-multiple conditional tags exist with the same ID).
+multiple conditional tags exist with the same ID), which allows the
+corresponding tag to be located in the B<-listx> output.
 
 =item B<-T> (B<-table>)
 
@@ -6781,14 +6787,14 @@ written (provided they can be calculated from the track log, and they are
 supported by the destination metadata format):  GPSLatitude, GPSLatitudeRef,
 GPSLongitude, GPSLongitudeRef, GPSAltitude, GPSAltitudeRef, GPSDateStamp,
 GPSTimeStamp, GPSDateTime, GPSTrack, GPSTrackRef, GPSSpeed, GPSSpeedRef,
-GPSImgDirection, GPSImgDirectionRef, GPSPitch, GPSRoll, GPSCoordinates,
-AmbientTemperature and CameraElevationAngle.  By default, in image files
-tags are created in EXIF, and updated in XMP only if they already exist.  In
-QuickTime-format files GPSCoordinates is created in the preferred location
-(ItemList by default) as well as in XMP.  However, C<EXIF:Geotime>,
-C<XMP:Geotime> or C<QuickTime:Geotime> may be specified to write to write
-only to one group. Also, C<ItemList:Geotime>, C<Keys:Geotime> or
-C<UserData:Geotime> may be used to write to a specific location in
+GPSImgDirection, GPSImgDirectionRef, GPSMeasureMode, GPSDOP, GPSPitch,
+GPSRoll, GPSCoordinates, AmbientTemperature and CameraElevationAngle.  By
+default, in image files tags are created in EXIF, and updated in XMP only if
+they already exist.  In QuickTime-format files GPSCoordinates is created in
+the preferred location (ItemList by default) as well as in XMP.  However,
+C<EXIF:Geotime>, C<XMP:Geotime> or C<QuickTime:Geotime> may be specified to
+write to write only to one group. Also, C<ItemList:Geotime>, C<Keys:Geotime>
+or C<UserData:Geotime> may be used to write to a specific location in
 QuickTime-format files.  Note that GPSPitch and GPSRoll are non-standard,
 and require user-defined tags in order to be written.
 

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

@@ -15,11 +15,11 @@ use Image::ExifTool qw(:DataAccess :Utils);
 use Image::ExifTool::Exif;
 use Image::ExifTool::XMP;
 use Image::ExifTool::GPS;
+use Image::ExifTool::Protobuf;
 
-$VERSION = '1.09';
+$VERSION = '1.10';
 
 sub ProcessDJIInfo($$$);
-sub Process_djmd($$$);
 
 my %convFloat2 = (
     PrintConv => 'sprintf("%+.2f", $val)',
@@ -187,34 +187,96 @@ my %convFloat2 = (
     },
 );
 
-# TODO - eventually add ability to decode this?
-%Image::ExifTool::DJI::djmd = (
-    PROCESS_PROC => \&Process_djmd,
+# metadata in protobuf format (djmd and dbgi meta types, ref PH)
+%Image::ExifTool::DJI::Protobuf = (
+    GROUPS => { 0 => 'Protobuf', 1 => 'DJI', 2 => 'Location' },
+    TAG_PREFIX => '',
+    PROCESS_PROC => \&Image::ExifTool::Protobuf::ProcessProtobuf,
+    NOTES => q{
+        Tags found in protobuf-format DJI meta djmd and dbgi timed metadata.  Only a
+        few tags are currently known, but unknown djmd tags may be extracted by
+        setting the Unknown option to 1 (or 2 to also extract unknown dbgi debug
+        tags).  Tag ID's are composed of the corresponding .proto file name combined
+        with the hierarchical protobuf field numbers.  The "dvtm_AVATA2.proto" file
+        is used by the DJI Avanta 2, and "dvtm_ac203.proto" by the OsmoAction4.
+    },
+    Protocol => { },
+   # dvtm_ac203_1-1-6 - some version number
+    'dvtm_ac203_1-1-10' => 'Model',
+    'dvtm_ac203_2-3-1' => { Name => 'FrameWidth',  Format => 'unsigned' },
+    'dvtm_ac203_2-3-2' => { Name => 'FrameHeight', Format => 'unsigned' },
+    'dvtm_ac203_2-3-3' => { Name => 'FrameRate',   Format => 'float' },
+   # dvtm_ac203_3-4-1-4 - model code?
+    'dvtm_ac203_3-4-2-1-1' => {
+        Name => 'CoordinateUnits',
+        Format  => 'unsigned',
+        # don't extract this -- just convert to degrees
+        RawConv => '$$self{CoordUnits} = $val; undef',
+        Hidden => 1,
+        # PrintConv => { 0 => 'Radians', 1 => 'Degrees' },
+    },
+    'dvtm_ac203_3-4-2-1-2' => {
+        Name => 'GPSLatitude',
+        Format => 'double',
+        # set ExifTool GPSLatitude/GPSLongitude members so GPSDateTime will be generated if necessary
+        RawConv => '$$self{GPSLatitude} = $$self{CoordUnits} ? $val : $val * 180 / 3.141592653589793', # (NC)
+        PrintConv => 'Image::ExifTool::GPS::ToDMS($self, $val, 1, "N")',
+    },
+    'dvtm_ac203_3-4-2-1-3' => {
+        Name => 'GPSLongitude',
+        Format => 'double',
+        RawConv => '$$self{GPSLongitude} = $$self{CoordUnits} ? $val : $val * 180 / 3.141592653589793', # (NC)
+        PrintConv => 'Image::ExifTool::GPS::ToDMS($self, $val, 1, "E")',
+    },
+    'dvtm_ac203_3-4-2-2' => {
+        Name => 'GPSAltitude',
+        Format => 'unsigned',
+        ValueConv => '$val / 1000',
+    },
+    'dvtm_ac203_3-4-2-6-1' => {
+        Name => 'GPSDateTime',
+        Format => 'string',
+        Groups => { 2 => 'Time' },
+        RawConv => '$$self{GPSDateTime} = $val',
+        ValueConv => '$val =~ tr/-/:/; $val',
+        PrintConv => '$self->ConvertDateTime($val)',
+    },
+   # dvtm_AVATA2_1-1-2 - some version number
+   # dvtm_AVATA2_1-1-3 - some version number
+    'dvtm_AVATA2_1-1-10' => 'Model',
+    'dvtm_AVATA2_2-2-3-1' => 'SerialNumber', # (NC)
+    'dvtm_AVATA2_2-3-1' => { Name => 'FrameWidth',  Format => 'unsigned' },
+    'dvtm_AVATA2_2-3-2' => { Name => 'FrameHeight', Format => 'unsigned' },
+    'dvtm_AVATA2_2-3-3' => { Name => 'FrameRate',   Format => 'float' },
+   # dvtm_AVATA2_3-1-1 - frame number (starting at 1)
+    'dvtm_AVATA2_3-1-2' => { # (also 3-2-1-6 and 3-4-1-6)
+        Name => 'TimeStamp',
+        Format => 'unsigned',
+        # milliseconds, but I don't know what the zero is
+        ValueConv => '$val / 1e6',
+    },
+   # dvtm_AVATA2_3-2-1-4 - model code?
+   # dvtm_AVATA2_3-4-1-4 - model code?
+    'dvtm_AVATA2_3-4-4-1-1' => { # (NC) (default seems to be radians if missing)
+        Name => 'CoordinateDegrees',
+        Format  => 'unsigned',
+        RawConv => '$$self{CoordDegrees} = $val; undef',
+        Hidden => 1,
+    },
+    'dvtm_AVATA2_3-4-4-1-2' => {
+        Name => 'GPSLatitude',
+        Format => 'double',
+        RawConv => '$$self{GPSLatitude} = $$self{CoordDegrees} ? $val : $val * 180 / 3.141592653589793', # (NC)
+        PrintConv => 'Image::ExifTool::GPS::ToDMS($self, $val, 1, "N")',
+    },
+    'dvtm_AVATA2_3-4-4-1-3' => {
+        Name => 'GPSLongitude',
+        Format => 'double',
+        RawConv => '$$self{GPSLongitude} = $$self{CoordDegrees} ? $val : $val * 180 / 3.141592653589793', # (NC)
+        PrintConv => 'Image::ExifTool::GPS::ToDMS($self, $val, 1, "E")',
+    },
 );
 
-#------------------------------------------------------------------------------
-# Process DJI djmd timed data from Action4 videos (ref PH)
-# Inputs: 0) ExifTool ref, 1) dirInfo ref, 2) tag table ref
-# Returns: 1 on success
-# TODO: work in progress
-sub Process_djmd($$$)
-{
-    my ($et, $dirInfo, $tagTbl) = @_;
-    my $dataPt = $$dirInfo{DataPt};
-    my ($pos, $bit, $val) = (6, 0, 0);
-    for (;;) {
-        my $v = Get8u($dataPt, $pos);
-        $val += ($v & 0x7f) << $bit;
-        last unless $v & 0x80;
-        ++$pos;
-        $bit += 7;
-    }
-    $pos += 49;
-    my @a = unpack("x${pos}fxfxfxfx3fxfxf", $$dataPt);
-    print "$val @a\n";
-    return 1;
-}
-
 #------------------------------------------------------------------------------
 # Process DJI info (ref PH)
 # Inputs: 0) ExifTool ref, 1) dirInfo ref, 2) tag table ref

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

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

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

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

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

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

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

@@ -0,0 +1,242 @@
+#------------------------------------------------------------------------------
+# File:         Protobuf.pm
+#
+# Description:  Decode protocol buffer data
+#
+# Revisions:    2024-12-04 - P. Harvey Created
+#
+# Notes:        Tag definitions for Protobuf tags support additional 'signed'
+#               and 'unsigned' formats for varInt (type 0) values
+#
+# References:   1) https://protobuf.dev/programming-guides/encoding/
+#------------------------------------------------------------------------------
+
+package Image::ExifTool::Protobuf;
+
+use strict;
+use vars qw($VERSION);
+use Image::ExifTool qw(:DataAccess :Utils);
+
+$VERSION = '1.00';
+
+sub ProcessProtobuf($$$;$);
+
+#------------------------------------------------------------------------------
+# Read bytes from dirInfo object
+# Inputs: 0) dirInfo ref, 1) number of bytes
+# Returns: binary data or undef on error
+sub GetBytes($$)
+{
+    my ($dirInfo, $n) = @_;
+    my $dataPt = $$dirInfo{DataPt};
+    my $pos = $$dirInfo{Pos};
+    return undef if $pos + $n > length $$dataPt;
+    $$dirInfo{Pos} += $n;
+    return substr($$dataPt, $pos, $n);
+}
+
+#------------------------------------------------------------------------------
+# Read variable-length integer
+# Inputs: 0) dirInfo ref
+# Returns: integer value
+sub VarInt($)
+{
+    my $dirInfo = shift;
+    my $val = 0;
+    my $shift = 0;
+    for (;;) {
+        my $buff = GetBytes($dirInfo, 1);
+        defined $buff or return undef;
+        $val += (ord($buff) & 0x7f) << $shift;
+        last unless ord($buff) & 0x80;
+        $shift += 7;
+    }
+    return $val;
+}
+
+#------------------------------------------------------------------------------
+# Read protobuf record
+# Inputs: 0) dirInfo ref
+# Returns: 0) record payload (plus tag id and format type in list context)
+# Notes: Updates dirInfo Pos to start of next record
+sub ReadRecord($)
+{
+    my $dirInfo = shift;
+    my $val = VarInt($dirInfo);
+    return undef unless defined $val;
+    my $id = $val >> 3;
+    my $type = $val & 0x07;
+    my $buff;
+
+    if ($type == 0) {       # varInt
+        $buff = VarInt($dirInfo);
+    } elsif ($type == 1) {  # 64-bit number
+        $buff = GetBytes($dirInfo, 8);
+    } elsif ($type == 2) {  # string, bytes or protobuf
+        my $len = VarInt($dirInfo);
+        if ($len) {
+            $buff = GetBytes($dirInfo, $len);
+        } else {
+            $buff = '';
+        }
+    } elsif ($type == 3) {  # (deprecated start group)
+        $buff = '';
+    } elsif ($type == 4) {  # (deprecated end group)
+        $buff = '';
+    } elsif ($type == 5) {  # 32-bit number
+        $buff = GetBytes($dirInfo, 4);
+    }
+    return wantarray ? ($buff, $id, $type) : $buff;
+}
+
+#------------------------------------------------------------------------------
+# Check to see if this could be a protobuf object
+# Inputs: 0) data reference
+# Retursn: true if this looks like a protobuf
+sub IsProtobuf($)
+{
+    my $pt = shift;
+    my $dirInfo = { DataPt => $pt, Pos => 0 };
+    for (;;) {
+        return 0 unless defined ReadRecord($dirInfo);
+        return 1 if $$dirInfo{Pos} == length $$pt;
+    }
+}
+
+#------------------------------------------------------------------------------
+# Process protobuf data (eg. DJI djmd timed data from Action4 videos) (ref 1)
+# Inputs: 0) ExifTool ref, 1) dirInfo ref with DataPt, DirName and Base,
+#         2) tag table ptr, 3) prefix of parent protobuf ID's
+# Returns: true on success
+sub ProcessProtobuf($$$;$)
+{
+    my ($et, $dirInfo, $tagTbl, $prefix) = @_;
+    my $dataPt = $$dirInfo{DataPt};
+    my $dirName = $$dirInfo{DirName};
+    my $unknown = $et->Options('Unknown') || $et->Options('Verbose');
+
+    $$dirInfo{Pos} = $$dirInfo{DirStart} || 0; # initialize buffer Pos
+
+    unless ($prefix) {
+        $prefix = '';
+        $$et{ProtocolName}{$dirName} = '*' unless defined $$et{ProtocolName}{$dirName};
+        SetByteOrder('II');
+    }
+    # loop through protobuf records
+    for (;;) {
+        my $pos = $$dirInfo{Pos};
+        last if $pos >= length $$dataPt;
+        my ($buff, $id, $type) = ReadRecord($dirInfo);
+        defined $buff or $et->WarnOnce('Protobuf format error'), last;
+        if ($type == 2 and $buff =~ /\.proto$/) {
+            # save protocol name separately for directory type
+            $$et{ProtocolName}{$dirName} = substr($buff, 0, -6);
+            $et->HandleTag($tagTbl, Protocol => $buff);
+        }
+        my $tag = "$$et{ProtocolName}{$dirName}_$prefix$id";
+        my $tagInfo = $$tagTbl{$tag};
+        if ($tagInfo) {
+            next if $type != 2 and $$tagInfo{Unknown} and not $unknown;
+        } else {
+            next unless $type == 2 or $unknown;
+            $tagInfo = AddTagToTable($tagTbl, $tag, { Unknown => 1 });
+        }
+        # set IsProtobuf flag (only for Unknown tags) if necessary
+        if ($type == 2 and $$tagInfo{Unknown}) {
+            if ($$tagInfo{IsProtobuf}) {
+                $$tagInfo{IsProtobuf} = 0 unless IsProtobuf(\$buff);
+            } elsif (not defined $$tagInfo{IsProtobuf} and $buff =~ /[^\x20-\x7f]/ and
+                IsProtobuf(\$buff))
+            {
+                $$tagInfo{IsProtobuf} = 1;
+            }
+            next unless $$tagInfo{IsProtobuf} or $unknown;
+        }
+        # format binary payload into a useful value
+        my $val;
+        if ($$tagInfo{Format}) {
+            if ($type == 0) {
+                $val = $buff;
+                $val = ($val & 1) ? -($val >> 1)-1 : ($val >> 1) if $$tagInfo{Format} eq 'signed';
+            } else {
+                $val = ReadValue(\$buff, 0, $$tagInfo{Format}, undef, length($buff));
+            }
+        } elsif ($type == 0) {
+            $val = $buff;
+            my $signed = ($val & 1) ? -($val >> 1)-1 : ($val >> 1);
+            $val .= sprintf(" (0x%x, signed $signed)", $val);
+        } elsif ($type == 1) {
+            $val = '0x' . unpack('H*', $buff) . ' (double ' . GetDouble(\$buff,0) . ')';
+        } elsif ($type == 2) {
+            if ($$tagInfo{IsProtobuf}) {
+                $et->VPrint(1, "+ Protobuf $tag (" . length($buff) . " bytes)\n");
+                my $addr = $$dirInfo{Base} + $$dirInfo{Pos} - length($buff);
+                $et->VerboseDump(\$buff, Addr => $addr);
+                my %subdir = ( DataPt => \$buff, Base => $addr, DirName => $dirName );
+                ProcessProtobuf($et, \%subdir, $tagTbl, "$prefix$id-");
+                next;
+            } elsif ($buff !~ /[^\x20-\x7f]/) {
+                $val = $buff;   # assume this is an ASCII string
+            } elsif (length($buff) % 4) {
+                $val = '0x' . unpack('H*', $buff);
+            } else {
+                $val = '0x' . join(' ', unpack('(H8)*', $buff)); # (group in 4-byte blocks)
+            }
+        } elsif ($type == 5) {
+            $val = '0x' . unpack('H*', $buff) . ' (int32u ' . Get32u(\$buff, 0);
+            $val .= ', int32s ' . Get32s(\$buff, 0) if ord(substr($buff,3,1)) & 0x80;
+            $val .= ', float ' . GetFloat(\$buff, 0) . ')';
+        } else {
+            $val = $buff;
+        }
+        # get length of data in the record
+        my $start = $type == 0 ? $pos + 1 : $$dirInfo{Pos} - length $buff;
+        $et->HandleTag($tagTbl, $tag, $val,
+            DataPt => $dataPt,
+            DataPos=> $$dirInfo{Base},
+            Start  => $start,
+            Size   => $$dirInfo{Pos} - $start,
+            Extra  => ", type=$type",
+            Format => $$tagInfo{Format},
+        );
+    }
+    # warn if we didn't finish exactly at the end of the buffer
+    $et->WarnOnce('Truncated protobuf data') unless $prefix or $$dirInfo{Pos} == length $$dataPt;
+    return 1;
+}
+
+__END__
+
+=head1 NAME
+
+Image::ExifTool::Protobuf - Decode protocol buffer information
+
+=head1 SYNOPSIS
+
+This module is loaded automatically by Image::ExifTool when required.
+
+=head1 DESCRIPTION
+
+This module contains definitions required by Image::ExifTool to decode
+information in protocol buffer (protobuf) format.
+
+=head1 AUTHOR
+
+Copyright 2003-2024, 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 REFERENCES
+
+=over 4
+
+=item L<https://protobuf.dev/programming-guides/encoding/>
+
+=back
+
+=head1 SEE ALSO
+
+L<Image::ExifTool(3pm)|Image::ExifTool>
+
+=cut