exiftool_vendored 12.15.0 → 12.22.0

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

@@ -89,7 +89,7 @@ my $parsePictureTiming; # flag to enable parsing of picture timing information (
         Notes => 'hours:minutes:seconds:frames',
         ValueConv => 'sprintf("%.2x:%.2x:%.2x:%.2x",reverse unpack("C*",$val))',
     },
-    # 0x14 - TitleBinaryGroup
+    # 0x14 - TitleBinaryGroup - val: 0x00000000,0x14200130
     # 0x15 - TitleCassetteNo (ref 7)
     # 0x16-0x17 - TitleSoftID (ref 7)
     # (0x18,0x19 listed as TitleTextHeader/TitleText by ref 7)
@@ -134,8 +134,8 @@ my $parsePictureTiming; # flag to enable parsing of picture timing information (
         Name => 'Camera2',
         SubDirectory => { TagTable => 'Image::ExifTool::H264::Camera2' },
     },
-    # 0x73 Lens - val: 0x75ffffd3,0x0effffd3,0x59ffffd3,0x79ffffd3,0xffffffd3...
-    # 0x74 Gain
+    # 0x73 Lens - val: 0x04ffffd3,0x0effffd3,0x15ffffd3,0x41ffffd3,0x52ffffd3,0x59ffffd3,0x65ffffd3,0x71ffffd3,0x75ffffd3,0x79ffffd3,0x7fffffd3,0xffffffd3...
+    # 0x74 Gain - val: 0xb8ffff0f
     # 0x75 Pedestal
     # 0x76 Gamma
     # 0x77 Detail
@@ -376,34 +376,49 @@ my $parsePictureTiming; # flag to enable parsing of picture timing information (
         Notes => 'combined with tag 0xc8',
     },
     # 0xc9-0xcf - GPSOption
+    # 0xc9 - val: 0x001d0203
+    0xca => { #PH (Sony DSC-HX7V)
+        Name => 'GPSDateStamp',
+        Format => 'string',
+        Groups => { 1 => 'GPS', 2 => 'Time' },
+        Combine => 2,    # the next 2 tags contain the rest of the string
+        Notes => 'combined with tags 0xcb and 0xcc',
+        ValueConv => 'Image::ExifTool::Exif::ExifDate($val)',
+    },
     0xe0 => {
         Name => 'MakeModel',
         SubDirectory => { TagTable => 'Image::ExifTool::H264::MakeModel' },
     },
     # 0xe1-0xef - MakerOption
     # 0xe1 - val: 0x01000670,0x01000678,0x06ffffff,0x01ffffff,0x01000020,0x01000400...
-    # 0xe2-0xe8 - val: 0x00000000 in many samples
     0xe1 => { #6
         Name => 'RecInfo',
         Condition => '$$self{Make} eq "Canon"',
         Notes => 'Canon only',
         SubDirectory => { TagTable => 'Image::ExifTool::H264::RecInfo' },
     },
+    # 0xe2-0xe8 - val: 0x00000000 in many samples
+    # 0xe2 - val: 0x00000000,0x01000000,0x01010000,0x8080900c,0x8080a074
+    # 0xe3 - val: 0x00801f89,0x00801f8b,0x00c01f89,0xc9c01f80
     0xe4 => { #PH
         Name => 'Model',
         Condition => '$$self{Make} eq "Sony"', # (possibly also Canon models?)
         Description => 'Camera Model Name',
-        Notes => 'Sony cameras only, combined with tags 0xe5 and 0xe6',
+        Notes => 'Sony only, combined with tags 0xe5 and 0xe6',
         Format => 'string',
         Combine => 2, # (not sure about 0xe6, but include it just in case)
         RawConv => '$val eq "" ? undef : $val',
     },
+    # 0xeb - val: 0x008a0a00,0x0a300000,0x508a0a00,0x52880a00,0x528a0a00
+    # 0xec - val: 0x0b700000
+    # 0xed - val: 0x0ce0f819
     0xee => { #6 (HFS200)
         Name => 'FrameInfo',
         Condition => '$$self{Make} eq "Canon"',
         Notes => 'Canon only',
         SubDirectory => { TagTable => 'Image::ExifTool::H264::FrameInfo' },
     },
+    # 0xef - val: 0x01c00000,0x0e00000c
 );
 
 # ConsumerCamera1 information (ref PH)

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

@@ -24,7 +24,7 @@ use strict;
 use vars qw($VERSION);
 use Image::ExifTool qw(:DataAccess :Utils);
 
-$VERSION = '1.35';
+$VERSION = '1.36';
 
 sub ProcessICC($$);
 sub ProcessICC_Profile($$$);
@@ -1225,7 +1225,7 @@ sub ProcessICC_Profile($$$)
             my $type = substr($$dataPt, $valuePtr, 4);
             #### eval Validate ($type)
             if (defined $$subdir{Validate} and not eval $$subdir{Validate}) {
-                $et->Warn("Invalid $name data");
+                $et->Warn("Invalid ICC $name data");
             } else {
                 $et->ProcessDirectory(\%subdirInfo, $newTagTable, $$subdir{ProcessProc});
             }

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

@@ -31,7 +31,7 @@ use strict;
 use vars qw($VERSION);
 use Image::ExifTool qw(:DataAccess :Utils);
 
-$VERSION = '1.18';
+$VERSION = '1.19';
 
 # program map table "stream_type" lookup (ref 6/1)
 my %streamType = (
@@ -57,7 +57,8 @@ my %streamType = (
     0x13 => 'ISO 14496-1 SL-packetized',
     0x14 => 'ISO 13818-6 Synchronized Download Protocol',
   # 0x15-0x7F => 'ISO 13818-1 Reserved',
-    0x1b => 'H.264 Video',
+    0x1b => 'H.264 (AVC) Video',
+    0x24 => 'H.265 (HEVC) Video', #PH
     0x80 => 'DigiCipher II Video',
     0x81 => 'A52/AC-3 Audio',
     0x82 => 'HDMV DTS Audio',
@@ -67,6 +68,7 @@ my %streamType = (
     0x86 => 'DTS-HD Audio',
     0x87 => 'E-AC-3 Audio',
     0x8a => 'DTS Audio',
+    0x90 => 'PGS Audio', #https://www.avsforum.com/threads/bass-eq-for-filtered-movies.2995212/page-399
     0x91 => 'A52b/AC-3 Audio',
     0x92 => 'DVD_SPU vls Subtitle',
     0x94 => 'SDDS Audio',
@@ -299,6 +301,33 @@ sub ParsePID($$$$$)
     } elsif ($type == 0x81 or $type == 0x87 or $type == 0x91) {
         # AC-3 audio
         ParseAC3Audio($et, $dataPt);
+    } elsif ($type < 0) {
+        if ($$dataPt =~ /^(.{164})?(.{24})A[NS][EW]/s) {
+            # (Blueskysea B4K, Novatek NT96670)
+            # 0000: 01 00 ff 00 30 31 32 33 34 35 37 38 61 62 63 64 [....01234578abcd]
+            # 0010: 65 66 67 0a 00 00 00 00 00 00 00 00 00 00 00 00 [efg.............]
+            # 0020: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 [................]
+            # 0030: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 [................]
+            # 0040: 00 00 00 00 30 31 32 33 34 35 37 38 71 77 65 72 [....01234578qwer]
+            # 0050: 74 79 75 69 6f 70 0a 00 00 00 00 00 00 00 00 00 [tyuiop..........]
+            # 0060: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 [................]
+            # 0070: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 [................]
+            # 0080: 00 00 00 00 63 38 61 61 32 35 63 66 34 35 65 65 [....c8aa25cf45ee]
+            # 0090: 61 39 65 32 34 34 32 66 61 65 62 35 65 30 39 39 [a9e2442faeb5e099]
+            # 00a0: 30 37 64 34 15 00 00 00 10 00 00 00 1b 00 00 00 [07d4............]
+            # 00b0: 15 00 00 00 01 00 00 00 09 00 00 00 41 4e 57 00 [............ANW.]
+            # 00c0: 82 9a 57 45 98 b2 00 46 66 66 e4 41 d7 e3 14 43 [..WE...Fff.A...C]
+            # 00d0: 01 00 02 00 03 00 04 00 05 00 06 00             [............]
+            # (Viofo A119V3)
+            # 0000: 08 00 00 00 07 00 00 00 18 00 00 00 15 00 00 00 [................]
+            # 0010: 03 00 00 00 0b 00 00 00 41 4e 45 00 01 f2 ac 45 [........ANE....E]
+            # 0020: 2d 7f 6e 45 b8 1e 97 41 d7 23 46 43 00 00 00 00 [-.nE...A.#FC....]
+            # pad with dummy header and parse with existing FreeGPS code (minimum 92 bytes)
+            my $dat = ("\0" x 16) . substr($$dataPt, length($1 || '')) . ("\0" x 20);
+            my $tbl = GetTagTable('Image::ExifTool::QuickTime::Stream');
+            Image::ExifTool::QuickTime::ProcessFreeGPS($et, { DataPt => \$dat }, $tbl);
+            $more = 1;
+        }
     }
     return $more;
 }
@@ -352,6 +381,14 @@ sub ProcessM2TS($$)
     my %needPID = ( 0 => 1 );       # lookup for stream PID's that we still need to parse
     my $pEnd = 0;
 
+    # scan entire file for GPS program 0x0300 if ExtractEmbedded option is 3 or higher
+    # (some dashcams write this program but don't include it in the PMT)
+    if (($et->Options('ExtractEmbedded') || 0) > 2) {
+        $needPID{0x0300} = 1;
+        $pidType{0x0300} = -1;
+        $pidName{0x0300} = 'unregistered dashcam GPS';
+    }
+
     # parse packets from MPEG-2 Transport Stream
     for (;;) {
 
@@ -421,12 +458,11 @@ sub ProcessM2TS($$)
         my $adaptation_field_exists      = $prefix & 0x00000020;
         my $payload_data_exists          = $prefix & 0x00000010;
       # my $continuity_counter           = $prefix & 0x0000000f;
-
         if ($verbose > 1) {
             my $i = ($raf->Tell() - length($buff) + $pEnd) / $pLen - 1;
             print  $out "Transport packet $i:\n";
             $et->VerboseDump(\$buff, Len => $pLen, Addr => $i * $pLen, Start => $pos - $prePos);
-            my $str = $pidName{$pid} ? " ($pidName{$pid})" : '';
+            my $str = $pidName{$pid} ? " ($pidName{$pid})" : ' <not in Program Map Table!>';
             printf $out "  Timecode:   0x%.4x\n", Get32u(\$buff, $pos - $prePos) if $pLen == 192;
             printf $out "  Packet ID:  0x%.4x$str\n", $pid;
             printf $out "  Start Flag: %s\n", $payload_unit_start_indicator ? 'Yes' : 'No';

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

@@ -393,7 +393,7 @@ my %offOn = ( 0 => 'Off', 1 => 'On' );
         ValueConv    => 'Image::ExifTool::GPS::ToDegrees($val, 1)',
         ValueConvInv => 'Image::ExifTool::GPS::ToDMS($self, $val, 0)',
         PrintConv    => 'Image::ExifTool::GPS::ToDMS($self, $val, 1, "N")',
-        PrintConvInv => 'Image::ExifTool::GPS::ToDegrees($val, 1)',
+        PrintConvInv => 'Image::ExifTool::GPS::ToDegrees($val, 1, "lat")',
     },
     Longitude => {
         Name => 'GPSLongitude',
@@ -406,7 +406,7 @@ my %offOn = ( 0 => 'Off', 1 => 'On' );
         ValueConv    => 'Image::ExifTool::GPS::ToDegrees($val, 1)',
         ValueConvInv => 'Image::ExifTool::GPS::ToDMS($self, $val, 0)',
         PrintConv    => 'Image::ExifTool::GPS::ToDMS($self, $val, 1, "E")',
-        PrintConvInv => 'Image::ExifTool::GPS::ToDegrees($val, 1)',
+        PrintConvInv => 'Image::ExifTool::GPS::ToDegrees($val, 1, "lon")',
     },
     MeasureMode => {
         Name => 'GPSMeasureMode',

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

@@ -5,6 +5,7 @@
 #
 # Revisions:    2010/10/01 - P. Harvey Created
 #               2011/10/05 - PH Added ProcessXtra()
+#               2021/02/23 - PH Added abiltity to write Xtra tags
 #
 # References:   1) http://research.microsoft.com/en-us/um/redmond/groups/ivm/hdview/hdmetadataspec.htm
 #------------------------------------------------------------------------------
@@ -16,9 +17,11 @@ use vars qw($VERSION);
 use Image::ExifTool qw(:DataAccess :Utils);
 use Image::ExifTool::XMP;
 
-$VERSION = '1.20';
+$VERSION = '1.22';
 
 sub ProcessXtra($$$);
+sub WriteXtra($$$);
+sub CheckXtra($$$);
 
 # tags written by Microsoft HDView (ref 1)
 %Image::ExifTool::Microsoft::Stitch = (
@@ -196,11 +199,20 @@ my %sRegions = (
 #       and Image::ExifTool::WTV::Metadata
 %Image::ExifTool::Microsoft::Xtra = (
     PROCESS_PROC => \&ProcessXtra,
+    WRITE_PROC => \&WriteXtra,
+    CHECK_PROC => \&CheckXtra,
+    WRITE_GROUP => 'Microsoft',
+    AVOID => 1,
     GROUPS => { 0 => 'QuickTime', 2 => 'Video' },
     VARS => { NO_ID => 1 },
     NOTES => q{
-        Tags extracted from the Microsoft "Xtra" atom of QuickTime videos.  Tag ID's
-        are not shown because some are unruly GUID's.
+        Tags found in the Microsoft "Xtra" atom of QuickTime videos.  Tag ID's are
+        not shown because some are unruly GUID's.  Currently most of these tags are
+        not writable because the Microsoft documentation is poor and samples were
+        not available, but more tags may be made writable in the future if samples
+        are provided.  Note that writable tags in this table are are flagged to
+        "Avoid", which means that other more common tags will be written instead if
+        possible unless the Microsoft group is specified explicitly.
     },
     Abstract                    => { },
     AcquisitionTime             => { Groups => { 2 => 'Time' } },
@@ -327,30 +339,34 @@ my %sRegions = (
     UserServiceRating           => { },
     VideoBitrate                => { },
     VideoFormat                 => { },
-    'WM/AlbumArtist'            => 'AlbumArtist',
-    'WM/AlbumCoverURL'          => 'AlbumCoverURL',
-    'WM/AlbumTitle'             => 'AlbumTitle',
+    'WM/AlbumArtist'            => { Name => 'AlbumArtist', Writable => 'Unicode' }, # (NC)
+    'WM/AlbumCoverURL'          => { Name => 'AlbumCoverURL', Writable => 'Unicode' }, # (NC)
+    'WM/AlbumTitle'             => { Name => 'AlbumTitle',  Writable => 'Unicode' }, # (NC)
     'WM/BeatsPerMinute'         => 'BeatsPerMinute',
-    'WM/Category'               => 'Category',
-    'WM/Composer'               => 'Composer',
-    'WM/Conductor'              => 'Conductor',
-    'WM/ContentDistributor'     => 'ContentDistributor',
+    'WM/Category'               => { Name => 'Category',    Writable => 'Unicode', List => 1 },
+    'WM/Composer'               => { Name => 'Composer',    Writable => 'Unicode' }, # (NC)
+    'WM/Conductor'              => { Name => 'Conductor',   Writable => 'Unicode', List => 1 },
+    'WM/ContentDistributor'     => { Name => 'ContentDistributor', Writable => 'Unicode' },
     'WM/ContentDistributorType' => 'ContentDistributorType',
     'WM/ContentGroupDescription'=> 'ContentGroupDescription',
-    'WM/Director'               => 'Director',
+    'WM/Director'               => { Name => 'Director',    Writable => 'Unicode', List => 1 },
     'WM/EncodingTime'           => {
         Name => 'EncodingTime',
         Groups => { 2 => 'Time' },
+        Shift => 'Time',
+        Writable => 'date',
         PrintConv => '$self->ConvertDateTime($val)',
+        PrintConvInv => '$self->InverseDateTime($val)',
     },
     'WM/Genre'                  => 'Genre',
     'WM/GenreID'                => 'GenreID',
-    'WM/InitialKey'             => 'InitialKey',
+    'WM/InitialKey'             => { Name => 'InitialKey',  Writable => 'Unicode' },
     'WM/Language'               => 'Language',
     'WM/Lyrics'                 => 'Lyrics',
     'WM/MCDI'                   => 'MCDI',
     'WM/MediaClassPrimaryID'    => {
         Name => 'MediaClassPrimaryID',
+        Writable => 'GUID',
         PrintConv => { #http://msdn.microsoft.com/en-us/library/windows/desktop/dd757960(v=vs.85).aspx
             'D1607DBC-E323-4BE2-86A1-48A42A28441E' => 'Music',
             'DB9830BD-3AB3-4FAB-8A37-1A995F7FF74B' => 'Video',
@@ -360,6 +376,7 @@ my %sRegions = (
     },
     'WM/MediaClassSecondaryID' => {
         Name => 'MediaClassSecondaryID',
+        Writable => 'GUID',
         PrintConv => { #http://msdn.microsoft.com/en-us/library/windows/desktop/dd757960(v=vs.85).aspx
             'E0236BEB-C281-4EDE-A36D-7AF76A3D45B5' => 'Audio Book',
             '3A172A13-2BD9-4831-835B-114F6A95943F' => 'Spoken Word',
@@ -385,22 +402,22 @@ my %sRegions = (
     },
     'WM/MediaOriginalChannel'   => 'MediaOriginalChannel',
     'WM/MediaStationName'       => 'MediaStationName',
-    'WM/Mood'                   => 'Mood',
-    'WM/OriginalAlbumTitle'     => 'OriginalAlbumTitle',
-    'WM/OriginalArtist'         => 'OriginalArtist',
-    'WM/OriginalLyricist'       => 'OriginalLyricist',
-    'WM/ParentalRating'         => 'ParentalRating',
+    'WM/Mood'                   => { Name => 'Mood',        Writable => 'Unicode' },
+    'WM/OriginalAlbumTitle'     => { Name => 'OriginalAlbumTitle',  Writable => 'Unicode' }, # (NC)
+    'WM/OriginalArtist'         => { Name => 'OriginalArtist',      Writable => 'Unicode' }, # (NC)
+    'WM/OriginalLyricist'       => { Name => 'OriginalLyricist',    Writable => 'Unicode' }, # (NC)
+    'WM/ParentalRating'         => { Name => 'ParentalRating',      Writable => 'Unicode' },
     'WM/PartOfSet'              => 'PartOfSet',
-    'WM/Period'                 => 'Period',
-    'WM/Producer'               => 'Producer',
+    'WM/Period'                 => { Name => 'Period',      Writable => 'Unicode' },
+    'WM/Producer'               => { Name => 'Producer',    Writable => 'Unicode', List => 1 },
     'WM/ProtectionType'         => 'ProtectionType',
-    'WM/Provider'               => 'Provider',
+    'WM/Provider'               => { Name => 'Provider',    Writable => 'Unicode' }, # (NC)
     'WM/ProviderRating'         => 'ProviderRating',
     'WM/ProviderStyle'          => 'ProviderStyle',
-    'WM/Publisher'              => 'Publisher',
-    'WM/SharedUserRating'       => 'SharedUserRating',
+    'WM/Publisher'              => { Name => 'Publisher',   Writable => 'Unicode' }, # (multiple entries separated by semicolon)
+    'WM/SharedUserRating'       => { Name => 'SharedUserRating', Writable => 'int64u' },
     'WM/SubscriptionContentID'  => 'SubscriptionContentID',
-    'WM/SubTitle'               => 'Subtitle',
+    'WM/SubTitle'               => { Name => 'Subtitle',    Writable => 'Unicode' },
     'WM/SubTitleDescription'    => 'SubtitleDescription',
     'WM/TrackNumber'            => 'TrackNumber',
     'WM/UniqueFileIdentifier'   => 'UniqueFileIdentifier',
@@ -412,8 +429,11 @@ my %sRegions = (
     'WM/WMContentID'            => 'WMContentID',
     'WM/WMShadowFileSourceDRMType' => 'WMShadowFileSourceDRMType',
     'WM/WMShadowFileSourceFileType' => 'WMShadowFileSourceFileType',
-    'WM/Writer'                 => 'Writer',
-    'WM/Year'                   => { Name => 'Year', Groups => { 2 => 'Time' } },
+    'WM/Writer'                 => { Name => 'Writer',  Groups => { 2 => 'Author' }, Writable => 'Unicode' }, # (NC)
+    'WM/Year'                   => { Name => 'Year',    Groups => { 2 => 'Time' } },
+    'WM/PromotionURL'           => { Name => 'PromotionURL',Writable => 'Unicode' },
+    'WM/AuthorURL'              => { Name => 'AuthorURL', Groups => { 2 => 'Author' }, Writable => 'Unicode' },
+    'WM/EncodedBy',             => { Name => 'EncodedBy',   Writable => 'Unicode' },
 
     # I can't find documentation for the following tags in videos,
     # but the tag ID's correspond to Microsoft property GUID+ID's
@@ -422,9 +442,12 @@ my %sRegions = (
     #  http://multi-rename-script.googlecode.com/svn-history/r4/trunk/plugins/ShellDetails/ShellDetails.ini
     # I have observed only 1 so far:
     '{2CBAA8F5-D81F-47CA-B17A-F8D822300131} 100' => {
-        Name => 'DateAcquired',
+        Name => 'DateAcquired', # (seems to be when videos are downloaded from the camera)
         Groups => { 2 => 'Time' },
+        Shift => 'Time',
+        Writable => 'vt_filetime',
         PrintConv => '$self->ConvertDateTime($val)',
+        PrintConvInv => '$self->InverseDateTime($val,undef)',
     },
     # the following have not yet been observed...
     '{B725F130-47EF-101A-A5F1-02608C9EEBAC} 10'    => 'Name',
@@ -764,6 +787,243 @@ my %sRegions = (
     '{64440491-4C8B-11D1-8B70-080036B11A03} 43'    => 'TotalBitrate',
 );
 
+#------------------------------------------------------------------------------
+# check new value for Xtra tag
+# Inputs: 0) ExifTool object ref, 1) tagInfo hash ref, 2) raw value ref
+# Returns: error string, or undef on success
+sub CheckXtra($$$)
+{
+    my ($et, $tagInfo, $valPt) = @_;
+    my $format = $$tagInfo{Writable};
+    return 'Unknown format' unless $format;
+    if ($format =~ /^int/) {
+        return 'Not an integer' unless Image::ExifTool::IsInt($$valPt);
+    } elsif ($format ne 'Unicode') {
+        my @vals = ($$valPt);
+        return 'Invalid format' unless WriteXtraValue($et, $tagInfo, \@vals);
+    }
+    return undef;
+}
+
+#------------------------------------------------------------------------------
+# Decode value(s) in Microsoft Xtra tag
+# Inputs: 0) ExifTool object ref, 1) value data
+# Returns: Scalar context: decoded value, List context: 0) decoded value, 1) format string
+sub ReadXtraValue($$)
+{
+    my ($et, $data) = @_;
+    my ($format, $i, @vals);
+    
+    return undef if length($data) < 10;
+
+    # (version flags according to the reference, but looks more like a count - PH)
+    my $count = Get32u(\$data, 0);
+    # point to start of first value (after 4-byte count, 4-byte length and 2-byte type)
+    my $valPos = 10;
+    for ($i=0; ;) {
+        # (stored value includes size of $valLen and $valType, so subtract 6)
+        my $valLen = Get32u(\$data, $valPos - 6) - 6;
+        last if $valPos + $valLen > length($data);
+        my $valType = Get16u(\$data, $valPos - 2);
+        my $val = substr($data, $valPos, $valLen);
+        # Note: all dumb Microsoft values are little-endian inside a big-endian-format file
+        SetByteOrder('II');
+        if ($valType == 8) {
+            $format = 'Unicode';
+            $val = $et->Decode($val, 'UCS2');
+        } elsif ($valType == 19 and $valLen == 8) {
+            $format = 'int64u';
+            $val = Get64u(\$val, 0);
+        } elsif ($valType == 21 and $valLen == 8) {
+            $format = 'date';
+            $val = Get64u(\$val, 0);
+            # convert time from 100 ns intervals since Jan 1, 1601
+            $val = $val * 1e-7 - 11644473600 if $val;
+            # (the Nikon S100 uses UTC timezone, same as ASF - PH)
+            $val = Image::ExifTool::ConvertUnixTime($val, 1);
+        } elsif ($valType == 72 and $valLen == 16) {
+            $format = 'GUID';
+            $val = uc unpack('H*',pack('NnnNN',unpack('VvvNN',$val)));
+            $val =~ s/(.{8})(.{4})(.{4})(.{4})/$1-$2-$3-$4-/;
+        } elsif ($valType == 65 and $valLen > 4) { #PH (empirical)
+            $format = 'variant';
+            require Image::ExifTool::FlashPix;
+            my $vPos = 0; # (necessary because ReadFPXValue updates this)
+            # read entry as a VT_VARIANT (use FlashPix module for this)
+            $val = Image::ExifTool::FlashPix::ReadFPXValue($et, \$val, $vPos,
+                   Image::ExifTool::FlashPix::VT_VARIANT(), $valLen, 1);
+        } else {
+            $format = "Unknown($valType)";
+        }
+        SetByteOrder('MM'); # back to native QuickTime byte ordering
+        push @vals, $val;
+        last if ++$i >= $count;
+        $valPos += $valLen + 6; # step to next value
+        last if $valPos > length($data);
+    }
+    return wantarray ? (\@vals, $format) : \@vals;
+}
+
+#------------------------------------------------------------------------------
+# Write a Microsoft Xtra value
+# Inputs: 0) ExifTool object ref, 1) tagInfo ref, 2) reference to list of values
+# Returns: new value binary data (or empty string)
+sub WriteXtraValue($$$)
+{
+    my ($et, $tagInfo, $vals) = @_;
+    my $format = $$tagInfo{Writable};
+    my $buff = '';
+    my $count = 0;
+    my $val;
+    foreach $val (@$vals) {
+        SetByteOrder('II');
+        my ($type, $dat);
+        if ($format eq 'Unicode') {
+            $dat = $et->Encode($val,'UCS2','II') . "\0\0";  # (must be null terminated)
+            $type = 8;
+        } elsif ($format eq 'int64u') {
+            if (Image::ExifTool::IsInt($val)) {
+                $dat = Set64u($val);
+                $type = 19;
+            }
+        } elsif ($format eq 'date') {
+            $dat = Image::ExifTool::GetUnixTime($val, 1);   # (convert to UTC, NC)
+            if ($dat) {
+                $dat = Set64u(($dat + 11644473600) * 1e7);
+                $type = 21;
+            }
+        } elsif ($format eq 'vt_filetime') {
+            $dat = Image::ExifTool::GetUnixTime($val);  # (leave as local time, NC)
+            if ($dat) {
+                $dat = Set32u(64) . Set64u(($dat + 11644473600) * 1e7);
+                $type = 65;
+            }
+        } elsif ($format eq 'GUID') {
+            ($dat = $val) =~ tr/-//d;
+            if (length($dat) == 32) {
+                $dat = pack('VvvNN',unpack('NnnNN',pack('H*', $dat)));
+                $type = 72;
+            }
+        } else {
+            $et->WarnOnce("Error converting value for Microsoft:$$tagInfo{Name}");
+        }
+        SetByteOrder('MM');
+        if (defined $type) {
+            ++$count;
+            $buff .= Set32u(length($dat)+6) . Set16u($type) . $dat;
+        }
+    }
+    return $count ? Set32u($count) . $buff : '';
+}
+
+#------------------------------------------------------------------------------
+# Add new values to list
+# Inputs: 0) ExifTool ref, 1) new value list ref, 2) nvHash ref
+# Returns: true if something was added
+sub AddNewValues($$$)
+{
+    my ($et, $vals, $nvHash) = @_;
+    my @newVals = $et->GetNewValue($nvHash) or return undef;
+    if ($$et{OPTIONS}{Verbose} > 1) {
+        $et->VPrint(1, "  + Microsoft:$$nvHash{TagInfo}{Name} = $_\n") foreach @newVals;
+    }
+    push @$vals, @newVals;
+    return 1;
+}
+
+#------------------------------------------------------------------------------
+# Write tags to a Microsoft Xtra MP4 atom
+# Inputs: 0) ExifTool object ref, 1) source dirInfo ref, 2) tag table ref
+# Returns: Microsoft Xtra data block (may be empty if no Xtra data) or undef on error
+sub WriteXtra($$$)
+{
+    my ($et, $dirInfo, $tagTablePtr) = @_;
+    $et or return 1;      # allow dummy access
+
+    my $delGroup = ($$et{DEL_GROUP} and $$et{DEL_GROUP}{Microsoft});
+    my $newTags = $et->GetNewTagInfoHash($tagTablePtr);
+
+    return undef unless $delGroup or %$newTags;  # don't rewrite if nothing to do
+
+    my $dataPt = $$dirInfo{DataPt};
+    my $dataLen = length $$dataPt;
+    my $newData = '';
+    my $pos = 0;
+    my ($err, %done, $changed, $tag);
+
+    if ($delGroup) {
+        $changed = 1 if $dataLen;
+        my $empty = '';
+        $dataPt = $empty;
+        $dataLen = 0;
+    }
+    for (;;) {
+        last if $pos + 4 > $dataLen;
+        my $size = Get32u($dataPt, $pos); # (includes $size word)
+        ($size < 8 or $pos + $size > $dataLen) and $err=1, last;
+        my $tagLen = Get32u($dataPt, $pos + 4);
+        $tagLen + 18 > $size and $err=1, last;
+        $tag = substr($$dataPt, $pos + 8, $tagLen);
+        my @newVals;
+        while ($$newTags{$tag}) {
+            my $nvHash = $et->GetNewValueHash($$newTags{$tag});
+            $$nvHash{CreateOnly} and delete($$newTags{$tag}), last; # don't edit this tag
+            my $valPos = $pos + 8 + $tagLen;
+            my $valLen = $size - 8 - $tagLen;
+            my $val = ReadXtraValue($et, substr($$dataPt, $valPos, $valLen));
+            foreach $val (@$val) {
+                my $overwrite = $et->IsOverwriting($nvHash, $val);
+                $overwrite or push(@newVals, $val), next;
+                $et->VPrint(1, "  - Microsoft:$$newTags{$tag}{Name} = $val\n");
+                next if $done{$tag};
+                $done{$tag} = 1;
+                AddNewValues($et, \@newVals, $nvHash);
+            }
+            # add to the end of the list if this was a List-type tag and we didn't delete anything
+            if (not $done{$tag} and $$newTags{$tag}{List}) {
+                AddNewValues($et, \@newVals, $nvHash) or last;
+                $done{$tag} = 1;
+            }
+            last;   # (it was a cheap goto)
+        }
+        if ($done{$tag}) {
+            # write changed values
+            my $buff = WriteXtraValue($et, $$newTags{$tag}, \@newVals);
+            if (length $buff) {
+                $newData .= Set32u(8+length($tag)+length($buff)) . Set32u(length($tag)) . $tag . $buff;
+                $changed = 1;
+            }
+        } else {
+            # nothing changed; just copy over
+            $newData .= substr($$dataPt, $pos, $size);
+        }
+        $pos += $size;  # step to next entry
+    }
+    if ($err) {
+        $et->Warn('Microsoft Xtra format error');
+        return undef;
+    }
+    # add any new tags
+    foreach $tag (sort keys %$newTags) {
+        next if $done{$tag};
+        my $nvHash = $et->GetNewValueHash($$newTags{$tag});
+        next unless $$nvHash{IsCreating} and not $$nvHash{EditOnly};
+        my @newVals;
+        AddNewValues($et, \@newVals, $nvHash) or next;
+        my $buff = WriteXtraValue($et, $$newTags{$tag}, \@newVals);
+        if (length $buff) {
+            $newData .= Set32u(8+length($tag)+length($buff)) . Set32u(length($tag)) . $tag . $buff;
+            $changed = 1;
+        }
+    }
+    if ($changed) {
+        ++$$et{CHANGED};
+    } else {
+        undef $newData;
+    }
+    return $newData;
+}
+
 #------------------------------------------------------------------------------
 # Extract information from Xtra MP4 atom
 # Inputs: 0) ExifTool object ref, 1) dirInfo ref, 2) tag table ref
@@ -783,61 +1043,13 @@ sub ProcessXtra($$$)
         last if $size < 8 or $pos + $size > $dataLen;
         my $tagLen = Get32u($dataPt, $pos + 4);
         last if $tagLen + 18 > $size;
-        my $tag = substr($$dataPt, $pos + 8, $tagLen);
-        # (version flags according to the reference, but looks more like a count - PH)
-        my $count = Get32u($dataPt, $pos + $tagLen + 8);
-        my ($i, $valPos, $valLen, $valType, $val, $format, @vals);
-        # point to start of first value (after 4-byte length and 2-byte type)
-        $valPos = $pos + $tagLen + 18;
-        for ($i=0; ;) {
-            # (stored value includes size of $valLen and $valType, so subtract 6)
-            $valLen  = Get32u($dataPt, $valPos - 6) - 6;
-            my $more = $pos + $size - $valPos - $valLen;
-            last if $more < 0;
-            $valType = Get16u($dataPt, $valPos - 2);
-            $val = substr($$dataPt, $valPos, $valLen);
-            # Note: all dumb Microsoft values are little-endian inside a big-endian-format file
-            SetByteOrder('II');
-            if ($valType == 8) {
-                $format = 'Unicode';
-                $val = $et->Decode($val, 'UCS2');
-            } elsif ($valType == 19 and $valLen == 8) {
-                $format = 'int64u';
-                $val = Get64u(\$val, 0);
-            } elsif ($valType == 21 and $valLen == 8) {
-                $format = 'date';
-                $val = Get64u(\$val, 0);
-                # convert time from 100 ns intervals since Jan 1, 1601
-                $val = $val * 1e-7 - 11644473600 if $val;
-                # (the Nikon S100 uses UTC timezone, same as ASF - PH)
-                $val = Image::ExifTool::ConvertUnixTime($val) . 'Z';
-            } elsif ($valType == 72 and $valLen == 16) {
-                $format = 'GUID';
-                $val = uc unpack('H*',pack('NnnNN',unpack('VvvNN',$val)));
-                $val =~ s/(.{8})(.{4})(.{4})(.{4})/$1-$2-$3-$4-/;
-            } elsif ($valType == 65 && $valLen > 4) { #PH (empirical)
-                $format = 'variant';
-                require Image::ExifTool::FlashPix;
-                my $vPos = $valPos; # (necessary because ReadFPXValue updates this)
-                # read entry as a VT_VARIANT (use FlashPix module for this)
-                $val = Image::ExifTool::FlashPix::ReadFPXValue($et, $dataPt, $vPos,
-                       Image::ExifTool::FlashPix::VT_VARIANT(), $valPos+$valLen, 1);
-            } else {
-                $format = "Unknown($valType)";
-            }
-            SetByteOrder('MM'); # back to native QuickTime byte ordering
-            last if ++$i >= $count or $more < 6;
-            push @vals, $val;
-            undef $val;
-            $valPos += $valLen + 6; # step to next value
-        }
-        if (@vals) {
-            push @vals, $val if defined $val;
-            $val = \@vals;
-            $valPos = $pos + $tagLen + 18;
-            $valLen = $size - 18 - $tagLen;
-        }
+        my $valLen = $size - 8 - $tagLen;
         if ($tagLen > 0 and $valLen > 0) {
+            my $tag = substr($$dataPt, $pos + 8, $tagLen);
+            my $valPos = $pos + 8 + $tagLen;
+            my ($val, $format) = ReadXtraValue($et, substr($$dataPt, $valPos, $valLen));
+            last unless defined $val;
+            $val = $$val[0] if @$val == 1;
             my $tagInfo = $et->GetTagInfo($tagTablePtr, $tag);
             unless ($tagInfo) {
                 # generate tag information for unrecognized tags
@@ -850,6 +1062,7 @@ sub ProcessXtra($$$)
                     $et->VPrint(0, $$et{INDENT}, "[adding Microsoft:$tag]\n");
                 }
             }
+            my $count = ref $val ? scalar @$val : 1;
             $et->HandleTag($tagTablePtr, $tag, $val,
                 TagInfo => $tagInfo,
                 DataPt  => $dataPt,
@@ -857,7 +1070,7 @@ sub ProcessXtra($$$)
                 Start   => $valPos,
                 Size    => $valLen,
                 Format  => $format,
-                Extra   => " count=$count type=$valType",
+                Extra   => " count=$count",
             );
         }
         $pos += $size;  # step to next entry
@@ -880,7 +1093,8 @@ This module is used by Image::ExifTool
 =head1 DESCRIPTION
 
 This module contains definitions required by Image::ExifTool to interpret
-Microsoft-specific EXIF and XMP tags.
+Microsoft-specific EXIF and XMP tags, and routines to read/write Microsoft
+Xtra tags in videos.
 
 =head1 AUTHOR