exiftool_vendored 9.37.0 → 9.41.0

data/bin/{Image-ExifTool-9.37 → Image-ExifTool-9.41}/lib/Image/ExifTool/QuickTime.pm

@@ -8,42 +8,51 @@
 #               09/22/2006 - P. Harvey Added M4A support
 #               07/27/2010 - P. Harvey Updated to 2010-05-03 QuickTime spec
 #
-# References:   1) http://developer.apple.com/mac/library/documentation/QuickTime/QTFF/QTFFChap1/qtff1.html
-#               2) http://search.cpan.org/dist/MP4-Info-1.04/
-#               3) http://www.geocities.com/xhelmboyx/quicktime/formats/mp4-layout.txt
-#               4) http://wiki.multimedia.cx/index.php?title=Apple_QuickTime
-#               5) ISO 14496-12 (http://neuron2.net/library/avc/c041828_ISO_IEC_14496-12_2005(E).pdf)
-#               6) ISO 14496-16 (http://www.iec-normen.de/previewpdf/info_isoiec14496-16%7Bed2.0%7Den.pdf)
-#               7) http://atomicparsley.sourceforge.net/mpeg-4files.html
-#               8) http://wiki.multimedia.cx/index.php?title=QuickTime_container
-#               9) http://www.adobe.com/devnet/xmp/pdfs/XMPSpecificationPart3.pdf (Oct 2008)
-#               10) http://code.google.com/p/mp4v2/wiki/iTunesMetadata
-#               11) http://www.canieti.com.mx/assets/files/1011/IEC_100_1384_DC.pdf
-#               12) QuickTime file format specification 2010-05-03
-#               13) http://www.adobe.com/devnet/flv/pdf/video_file_format_spec_v10.pdf
-#               14) http://standards.iso.org/ittf/PubliclyAvailableStandards/c051533_ISO_IEC_14496-12_2008.zip
-#               15) http://getid3.sourceforge.net/source/module.audio-video.quicktime.phps
-#               16) http://qtra.apple.com/atoms.html
-#               17) http://www.etsi.org/deliver/etsi_ts/126200_126299/126244/10.01.00_60/ts_126244v100100p.pdf
+# References:
+#
+#   1) http://developer.apple.com/mac/library/documentation/QuickTime/QTFF/QTFFChap1/qtff1.html
+#   2) http://search.cpan.org/dist/MP4-Info-1.04/
+#   3) http://www.geocities.com/xhelmboyx/quicktime/formats/mp4-layout.txt
+#   4) http://wiki.multimedia.cx/index.php?title=Apple_QuickTime
+#   5) ISO 14496-12 (http://read.pudn.com/downloads64/ebook/226547/ISO_base_media_file_format.pdf)
+#   6) ISO 14496-16 (http://www.iec-normen.de/previewpdf/info_isoiec14496-16%7Bed2.0%7Den.pdf)
+#   7) http://atomicparsley.sourceforge.net/mpeg-4files.html
+#   8) http://wiki.multimedia.cx/index.php?title=QuickTime_container
+#   9) http://www.adobe.com/devnet/xmp/pdfs/XMPSpecificationPart3.pdf (Oct 2008)
+#   10) http://code.google.com/p/mp4v2/wiki/iTunesMetadata
+#   11) http://www.canieti.com.mx/assets/files/1011/IEC_100_1384_DC.pdf
+#   12) QuickTime file format specification 2010-05-03
+#   13) http://www.adobe.com/devnet/flv/pdf/video_file_format_spec_v10.pdf
+#   14) http://standards.iso.org/ittf/PubliclyAvailableStandards/c051533_ISO_IEC_14496-12_2008.zip
+#   15) http://getid3.sourceforge.net/source/module.audio-video.quicktime.phps
+#   16) http://qtra.apple.com/atoms.html
+#   17) http://www.etsi.org/deliver/etsi_ts/126200_126299/126244/10.01.00_60/ts_126244v100100p.pdf
+#   18) https://github.com/appsec-labs/iNalyzer/blob/master/scinfo.m
+#   19) http://nah6.com/~itsme/cvs-xdadevtools/iphone/tools/decodesinf.pl
+#   20) https://developer.apple.com/legacy/library/documentation/quicktime/reference/QT7-1_Update_Reference/QT7-1_Update_Reference.pdf
 #------------------------------------------------------------------------------
 
 package Image::ExifTool::QuickTime;
 
 use strict;
-use vars qw($VERSION);
+use vars qw($VERSION $AUTOLOAD);
 use Image::ExifTool qw(:DataAccess :Utils);
 use Image::ExifTool::Exif;
 
-$VERSION = '1.70';
+$VERSION = '1.72';
 
 sub FixWrongFormat($);
 sub ProcessMOV($$;$);
 sub ProcessKeys($$$);
 sub ProcessMetaData($$$);
 sub ProcessEncodingParams($$$);
+sub ProcessHybrid($$$);
+sub ProcessRights($$$);
 sub ConvertISO6709($);
 sub PrintGPSCoordinates($);
 sub UnpackLang($);
+sub WriteQuickTime($$$);
+sub WriteMOV($$);
 
 # MIME types for all entries in the ftypLookup with file extensions
 # (defaults to 'video/mp4' if not found in this lookup)
@@ -167,9 +176,15 @@ my %timeInfo = (
         $self->WarnOnce('Patched incorrect time zero for QuickTime date/time tag',1) if $val;
         return $val;
     },
+    Shift => 'Time',
+    Writable => 1,
+    Permanent => 1,
+    DelValue => 0,
     # Note: This value will be in UTC if generated by a system that is aware of the time zone
     ValueConv => 'ConvertUnixTime($val, $self->Options("QuickTimeUTC"))',
+    ValueConvInv => 'GetUnixTime($val) + (66 * 365 + 17) * 24 * 3600',
     PrintConv => '$self->ConvertDateTime($val)',
+    PrintConvInv => '$self->InverseDateTime($val)',
     # (can't put Groups here because they aren't constant!)
 );
 # information for duration tags
@@ -259,6 +274,7 @@ my %graphicsMode = (
 # QuickTime atoms
 %Image::ExifTool::QuickTime::Main = (
     PROCESS_PROC => \&ProcessMOV,
+    WRITE_PROC => \&WriteQuickTime,
     GROUPS => { 2 => 'Video' },
     NOTES => q{
         The QuickTime format is used for many different types of audio, video and
@@ -267,6 +283,9 @@ my %graphicsMode = (
         proprietary information written by many camera models.  Tags with a question
         mark after their name are not extracted unless the Unknown option is set.
 
+        ExifTool has the ability to write/create XMP, and edit date/time tags in
+        QuickTime format files.
+
         According to the specification, many QuickTime date/time tags should be
         stored as UTC.  Unfortunately, digital cameras often store local time values
         instead (presumably because they don't know the time zone).  For this
@@ -274,7 +293,7 @@ my %graphicsMode = (
         However, if the QuickTimeUTC option is set via the API or the ExifTool
         configuration file, then ExifTool will assume these values are properly
         stored as UTC, and will convert them to local time when extracting.
-      
+
         See
         L<http://developer.apple.com/mac/library/documentation/QuickTime/QTFF/QTFFChap1/qtff1.html>
         for the official specification.
@@ -332,6 +351,7 @@ my %graphicsMode = (
     uuid => [
         { #9 (MP4 files)
             Name => 'UUID-XMP',
+            # *** this is where ExifTool writes XMP in MP4 videos (as per XMP spec) ***
             Condition => '$$valPt=~/^\xbe\x7a\xcf\xcb\x97\xa9\x42\xe8\x9c\x71\x99\x94\x91\xe3\xaf\xac/',
             SubDirectory => {
                 TagTable => 'Image::ExifTool::XMP::Main',
@@ -366,8 +386,8 @@ my %graphicsMode = (
         SubDirectory => { TagTable => 'Image::ExifTool::QuickTime::HTC' },
     },
     udta => {
-        Name => 'TopUserData',
-        SubDirectory => { TagTable => 'Image::ExifTool::QuickTime::TopUserData' },
+        Name => 'UserData',
+        SubDirectory => { TagTable => 'Image::ExifTool::FLIR::UserData' },
     },
 );
 
@@ -391,7 +411,7 @@ my %graphicsMode = (
         Name => 'CompatibleBrands',
         Format => 'undef[$size-8]',
         # ignore any entry with a null, and return others as a list
-        ValueConv => 'my @a=($val=~/.{4}/sg); @a=grep(!/\0/,@a); \@a', 
+        ValueConv => 'my @a=($val=~/.{4}/sg); @a=grep(!/\0/,@a); \@a',
     },
 );
 
@@ -428,7 +448,8 @@ my %graphicsMode = (
 
 # image description data block
 %Image::ExifTool::QuickTime::ImageDesc = (
-    PROCESS_PROC => \&Image::ExifTool::ProcessBinaryData,
+    PROCESS_PROC => \&ProcessHybrid,
+    VARS => { ID_LABEL => 'ID/Index' },
     GROUPS => { 2 => 'Image' },
     FORMAT => 'int16u',
     2 => {
@@ -487,11 +508,75 @@ my %graphicsMode = (
         },
     },
     41 => 'BitDepth',
+#
+# Observed offsets for child atoms of various CompressorID types:
+#
+#   CompressorID  Offset  Child atoms
+#   -----------   ------  ----------------
+#   avc1          86      avcC, btrt, colr, pasp, fiel, clap
+#   mp4v          86      esds, pasp
+#   s263          86      d263
+#
+    btrt => {
+        Name => 'BitrateInfo',
+        SubDirectory => { TagTable => 'Image::ExifTool::QuickTime::Bitrate' },
+    },
+    # Reference for fiel, colr, pasp, clap:
+    # https://developer.apple.com/library/mac/technotes/tn2162/_index.html#//apple_ref/doc/uid/DTS40013070-CH1-TNTAG9
+    fiel => {
+        Name => 'VideoFieldOrder',
+        ValueConv => 'join(" ", unpack("C*",$val))',
+        PrintConv => [{
+            1 => 'Progressive',
+            2 => '2:1 Interlaced',
+        }],
+    },
+    colr => {
+        Name => 'ColorRepresentation',
+        ValueConv => 'join(" ", substr($val,0,4), unpack("x4n*",$val))',
+    },
+    pasp => {
+        Name => 'PixelAspectRatio',
+        ValueConv => 'join(":", unpack("N*",$val))',
+    },
+    clap => {
+        Name => 'CleanAperture',
+        SubDirectory => { TagTable => 'Image::ExifTool::QuickTime::CleanAperture' },
+    },
+    # avcC - AVC configuration (ref http://thompsonng.blogspot.ca/2010/11/mp4-file-format-part-2.html)
+    # esds - elementary stream descriptor
+    # d263
+    gama => { Name => 'Gamma', Format => 'fixed32u' },
+    # mjqt - default quantization table for MJPEG
+    # mjht - default Huffman table for MJPEG
+);
+
+# 'btrt' atom information (ref http://lists.freedesktop.org/archives/gstreamer-commits/2011-October/054459.html)
+%Image::ExifTool::QuickTime::Bitrate = (
+    PROCESS_PROC => \&Image::ExifTool::ProcessBinaryData,
+    GROUPS => { 2 => 'Video' },
+    FORMAT => 'int32u',
+    PRIORITY => 0, # often filled with zeros
+    0 => 'BufferSize',
+    1 => 'MaxBitrate',
+    2 => 'AverageBitrate',
+);
+
+# 'clap' atom information (ref https://developer.apple.com/library/mac/technotes/tn2162/_index.html#//apple_ref/doc/uid/DTS40013070-CH1-TNTAG9)
+%Image::ExifTool::QuickTime::CleanAperture = (
+    PROCESS_PROC => \&Image::ExifTool::ProcessBinaryData,
+    GROUPS => { 2 => 'Video' },
+    FORMAT => 'rational64u',
+    0 => 'CleanApertureWidth',
+    1 => 'CleanApertureHeight',
+    2 => 'CleanApertureOffsetX',
+    3 => 'CleanApertureOffsetY',
 );
 
 # preview data block
 %Image::ExifTool::QuickTime::Preview = (
     PROCESS_PROC => \&Image::ExifTool::ProcessBinaryData,
+    WRITE_PROC => \&Image::ExifTool::WriteBinaryData,
     GROUPS => { 2 => 'Image' },
     FORMAT => 'int16u',
     0 => {
@@ -511,6 +596,7 @@ my %graphicsMode = (
 # movie atoms
 %Image::ExifTool::QuickTime::Movie = (
     PROCESS_PROC => \&ProcessMOV,
+    WRITE_PROC => \&WriteQuickTime,
     GROUPS => { 2 => 'Video' },
     mvhd => {
         Name => 'MovieHeader',
@@ -567,8 +653,10 @@ my %graphicsMode = (
 # movie header data block
 %Image::ExifTool::QuickTime::MovieHeader = (
     PROCESS_PROC => \&Image::ExifTool::ProcessBinaryData,
+    WRITE_PROC => \&Image::ExifTool::WriteBinaryData,
     GROUPS => { 2 => 'Video' },
     FORMAT => 'int32u',
+    DATAMEMBER => [ 0, 1, 2, 3, 4 ],
     0 => {
         Name => 'MovieHeaderVersion',
         Format => 'int8u',
@@ -630,7 +718,8 @@ my %graphicsMode = (
 # track atoms
 %Image::ExifTool::QuickTime::Track = (
     PROCESS_PROC => \&ProcessMOV,
-    GROUPS => { 2 => 'Video' },
+    WRITE_PROC => \&WriteQuickTime,
+    GROUPS => { 1 => 'Track#', 2 => 'Video' },
     tkhd => {
         Name => 'TrackHeader',
         SubDirectory => { TagTable => 'Image::ExifTool::QuickTime::TrackHeader' },
@@ -681,8 +770,10 @@ my %graphicsMode = (
 # track header data block
 %Image::ExifTool::QuickTime::TrackHeader = (
     PROCESS_PROC => \&Image::ExifTool::ProcessBinaryData,
+    WRITE_PROC => \&Image::ExifTool::WriteBinaryData,
     GROUPS => { 1 => 'Track#', 2 => 'Video' },
     FORMAT => 'int32u',
+    DATAMEMBER => [ 0, 1, 2, 5 ],
     0 => {
         Name => 'TrackHeaderVersion',
         Format => 'int8u',
@@ -753,6 +844,7 @@ my %graphicsMode = (
 # user data atoms
 %Image::ExifTool::QuickTime::UserData = (
     PROCESS_PROC => \&ProcessMOV,
+    WRITE_PROC => \&WriteQuickTime,
     GROUPS => { 2 => 'Video' },
     NOTES => q{
         Tag ID's beginning with the copyright symbol (hex 0xa9) are multi-language
@@ -868,6 +960,7 @@ my %graphicsMode = (
     hinv => 'HintVersion', #PH (guess)
     XMP_ => { #PH (Adobe CS3 Bridge)
         Name => 'XMP',
+        # *** this is where ExifTool writes XMP in MOV videos (as per XMP spec) ***
         SubDirectory => { TagTable => 'Image::ExifTool::XMP::Main' },
     },
     # the following are 3gp tags, references:
@@ -1022,6 +1115,14 @@ my %graphicsMode = (
     scen => { Name => 'Scene',        Format => 'string' }, # (NC)
     shot => { Name => 'ShotName',     Format => 'string' }, # (NC)
     slno => { Name => 'SerialNumber', Format => 'string' }, # (NC)
+    apmd => { Name => 'ApertureMode', Format => 'undef' }, #20
+    kgtt => { #http://lists.ffmpeg.org/pipermail/ffmpeg-devel-irc/2012-June/000707.html
+        # 'TrackType' will expand to 'Track#Type' when found inside a track
+        Name => 'TrackType',
+        # set flag to process this as international text
+        # even though the tag ID doesn't start with 0xa9
+        IText => 1,
+    },
     # other non-Apple tags (ref 16)
     # hpix - HipixRichPicture (ref 16, HIPIX)
     # strk - sub-track information (ref 16, ISO)
@@ -1305,10 +1406,18 @@ my %graphicsMode = (
     # ducp - 4 bytes all zero (Samsung ST96,WB750), 52 bytes all zero (Samsung WB30F)
     # edli - 52 bytes all zero (Samsung WB30F)
     # @etc - 4 bytes all zero (Samsung WB30F)
+    # smrd - string "TRUEBLUE" (Samsung SM-C101)
    '@sec' => { #PH (Samsung WB30F)
         Name => 'SamsungSec',
         SubDirectory => { TagTable => 'Image::ExifTool::Samsung::sec' },
     },
+    'smta' => { #PH (Samsung SM-C101)
+        Name => 'SamsungSmta',
+        SubDirectory => {
+            TagTable => 'Image::ExifTool::Samsung::smta',
+            Start => 4,
+        },
+    },
 #
 # other 3rd-party tags
 # (ref http://code.google.com/p/mp4parser/source/browse/trunk/isoparser/src/main/resources/isoparser-default.properties?r=814)
@@ -1332,88 +1441,6 @@ my %graphicsMode = (
     },
 );
 
-# top-level user data written by FLIR cameras in MP4 videos
-%Image::ExifTool::QuickTime::TopUserData = (
-    PROCESS_PROC => \&ProcessMOV,
-    GROUPS => { 1 => 'FLIR', 2 => 'Camera' },
-    NOTES => 'Tags written in MP4 videos from some FLIR cameras.',
-    uuid => [
-        {
-            Name => 'FLIR_Parts',
-            Condition => '$$valPt=~/^\x43\xc3\x99\x3b\x0f\x94\x42\x4b\x82\x05\x6b\x66\x51\x3f\x48\x5d/s',
-            SubDirectory => {
-                TagTable => 'Image::ExifTool::FLIR::Parts',
-                Start => 16,
-            },
-        },
-        {
-            Name => 'FLIR_Serial',
-            Condition => '$$valPt=~/^\x57\xf5\xb9\x3e\x51\xe4\x48\xaf\xa0\xd9\xc3\xef\x1b\x37\xf7\x12/s',
-            SubDirectory => {
-                TagTable => 'Image::ExifTool::FLIR::SerialNums',
-                Start => 16,
-            },
-        },
-        {
-            Name => 'FLIR_Params',
-            Condition => '$$valPt=~/^\x41\xe5\xdc\xf9\xe8\x0a\x41\xce\xad\xfe\x7f\x0c\x58\x08\x2c\x19/s',
-            SubDirectory => {
-                TagTable => 'Image::ExifTool::FLIR::Params',
-                Start => 16,
-            },
-        },
-        {
-            Name => 'FLIR_UnknownUUID',
-            Condition => '$$valPt=~/^\x57\x45\x20\x50\x2c\xbb\x44\xad\xae\x54\x15\xe9\xb8\x39\xd9\x03/s',
-            SubDirectory => {
-                TagTable => 'Image::ExifTool::FLIR::UnknownUUID',
-                Start => 16,
-            },
-        },
-        {
-            Name => 'FLIR_GPS',
-            Condition => '$$valPt=~/^\x7f\x2e\x21\x00\x8b\x46\x49\x18\xaf\xb1\xde\x70\x9a\x74\xf6\xf5/s',
-            SubDirectory => {
-                TagTable => 'Image::ExifTool::FLIR::GPS_UUID',
-                Start => 16,
-            },
-        },
-        {
-            Name => 'FLIR_MoreInfo',
-            Condition => '$$valPt=~/^\x2b\x45\x2f\xdc\x74\x35\x40\x94\xba\xee\x22\xa6\xb2\x3a\x7c\xf8/s',
-            SubDirectory => {
-                TagTable => 'Image::ExifTool::FLIR::MoreInfo',
-                Start => 16,
-            },
-        },
-        {
-            Name => 'SoftwareComponents',
-            Condition => '$$valPt=~/^\x78\x3f\xc7\x83\x0c\x95\x4b\x00\x8c\xc7\xac\xf1\xec\xb4\xd3\x9a/s',
-            Unknown => 1,
-            ValueConv => 'join " ", unpack "x20N4xZ*", $val',
-        },
-        {
-            Name => 'FLIR_Unknown',
-            Condition => '$$valPt=~/^\x52\xae\xda\x45\x17\x1e\x48\xb1\x92\x47\x93\xa4\x21\x4e\x43\xf5/s',
-            Unknown => 1,
-            ValueConv => 'unpack "x20C*", $val',
-        },
-        {
-            Name => 'Units',
-            Condition => '$$valPt=~/^\xf8\xab\x72\x1e\x84\x73\x44\xa0\xb8\xc8\x1b\x04\x82\x6e\x07\x24/s',
-            List => 1,
-            RawConv => 'my @a = split "\0", substr($val, 20); \@a',
-        },
-        {
-            Name => 'ThumbnailImage',
-            Groups => { 2 => 'Image' },
-            Condition => '$$valPt=~/^\x91\xaf\x9b\x93\x45\x9b\x44\x56\x98\xd1\x5e\x76\xea\x01\x04\xac....\xff\xd8\xff/s',
-            RawConv => 'substr($val, 20)',
-            Binary => 1,
-        },
-    ],
-);
-
 # User-specific media data atoms (ref 11)
 %Image::ExifTool::QuickTime::MetaData = (
     PROCESS_PROC => \&Image::ExifTool::QuickTime::ProcessMetaData,
@@ -1636,6 +1663,7 @@ my %graphicsMode = (
     },
    'xml ' => {
         Name => 'XML',
+        Flags => [ 'Binary', 'Protected', 'BlockExtract' ],
         SubDirectory => { TagTable => 'Image::ExifTool::XMP::Main' },
     },
    'keys' => {
@@ -1659,7 +1687,7 @@ my %graphicsMode = (
 # track reference atoms
 %Image::ExifTool::QuickTime::TrackRef = (
     PROCESS_PROC => \&ProcessMOV,
-    GROUPS => { 2 => 'Video' },
+    GROUPS => { 1 => 'Track#', 2 => 'Video' },
     chap => { Name => 'ChapterList', Format => 'int32u' },
     tmcd => { Name => 'TimeCode', Format => 'int32u' },
     mpod => { #PH (FLIR MP4)
@@ -1674,7 +1702,7 @@ my %graphicsMode = (
 # (ref https://developer.apple.com/library/mac/#documentation/QuickTime/QTFF/QTFFChap2/qtff2.html)
 %Image::ExifTool::QuickTime::TrackAperture = (
     PROCESS_PROC => \&ProcessMOV,
-    GROUPS => { 2 => 'Video' },
+    GROUPS => { 1 => 'Track#', 2 => 'Video' },
     clef => {
         Name => 'CleanApertureDimensions',
         Format => 'fixed32u',
@@ -2063,7 +2091,7 @@ my %graphicsMode = (
     GROUPS => { 2 => 'Audio' },
     # (I have commented out the ones that don't have integer values because they
     #  probably don't appear, and definitly wouldn't work with current decoding - PH)
-    
+
     # global codec properties
     #'lnam' => 'AudioCodecName',
     #'lmak' => 'AudioCodecManufacturer',
@@ -2209,7 +2237,8 @@ my %graphicsMode = (
 # MP4 media box (ref 5)
 %Image::ExifTool::QuickTime::Media = (
     PROCESS_PROC => \&ProcessMOV,
-    GROUPS => { 2 => 'Video' },
+    WRITE_PROC => \&WriteQuickTime,
+    GROUPS => { 1 => 'Track#', 2 => 'Video' },
     NOTES => 'MP4 media box.',
     mdhd => {
         Name => 'MediaHeader',
@@ -2228,8 +2257,10 @@ my %graphicsMode = (
 # MP4 media header box (ref 5)
 %Image::ExifTool::QuickTime::MediaHeader = (
     PROCESS_PROC => \&Image::ExifTool::ProcessBinaryData,
-    GROUPS => { 2 => 'Video' },
+    WRITE_PROC => \&Image::ExifTool::WriteBinaryData,
+    GROUPS => { 1 => 'Track#', 2 => 'Video' },
     FORMAT => 'int32u',
+    DATAMEMBER => [ 0, 1, 2, 3, 4 ],
     0 => {
         Name => 'MediaHeaderVersion',
         RawConv => '$$self{MediaHeaderVersion} = $val',
@@ -2276,7 +2307,7 @@ my %graphicsMode = (
 # MP4 media information box (ref 5)
 %Image::ExifTool::QuickTime::MediaInfo = (
     PROCESS_PROC => \&ProcessMOV,
-    GROUPS => { 2 => 'Video' },
+    GROUPS => { 1 => 'Track#', 2 => 'Video' },
     NOTES => 'MP4 media info box.',
     vmhd => {
         Name => 'VideoHeader',
@@ -2460,53 +2491,211 @@ my %graphicsMode = (
     },
 );
 
-# MP4 audio sample description box (ref 5)
+# MP4 audio sample description box (ref 5/AtomicParsley 0.9.4 parsley.cpp)
 %Image::ExifTool::QuickTime::AudioSampleDesc = (
-    PROCESS_PROC => \&Image::ExifTool::ProcessBinaryData,
+    PROCESS_PROC => \&ProcessHybrid,
+    VARS => { ID_LABEL => 'ID/Index' },
     GROUPS => { 2 => 'Audio' },
-    FORMAT => 'int16u',
-    NOTES => 'MP4 audio sample description.',
-    2  => {
+    NOTES => q{
+        MP4 audio sample description.  This hybrid atom contains both data and child
+        atoms.
+    },
+    4  => {
         Name => 'AudioFormat',
         Format => 'undef[4]',
         RawConv => q{
+            $$self{AudioFormat} = $val;
             return undef unless $val =~ /^[\w ]{4}$/i;
             # check for protected audio format
             $self->OverrideFileType('M4P') if $val eq 'drms' and $$self{VALUE}{FileType} eq 'M4A';
             return $val;
         },
     },
-    10 => { #PH
+    20 => { #PH
         Name => 'AudioVendorID',
+        Condition => '$$self{AudioFormat} ne "mp4s"',
         Format => 'undef[4]',
         RawConv => '$val eq "\0\0\0\0" ? undef : $val',
         PrintConv => \%vendorID,
         SeparateTable => 'VendorID',
     },
-    12 => 'AudioChannels',
-    13 => 'AudioBitsPerSample',
-    16 => { Name => 'AudioSampleRate', Format => 'fixed32u' },
-    28 => { #PH
-        Name => 'AudioFormat',
+    24 => { Name => 'AudioChannels',        Format => 'int16u' },
+    26 => { Name => 'AudioBitsPerSample',   Format => 'int16u' },
+    32 => { Name => 'AudioSampleRate',      Format => 'fixed32u' },
+#
+# Observed offsets for child atoms of various AudioFormat types:
+#
+#   AudioFormat  Offset  Child atoms
+#   -----------  ------  ----------------
+#   mp4a         52 *    wave, chan, esds
+#   in24         52      wave, chan
+#   "ms\0\x11"   52      wave
+#   sowt         52      chan
+#   mp4a         36 *    esds, pinf
+#   drms         36      esds, sinf
+#   samr         36      damr
+#   alac         36      alac
+#
+# (* child atoms found at different offsets in mp4a)
+#
+    pinf => {
+        Name => 'PurchaseInfo',
+        SubDirectory => { TagTable => 'Image::ExifTool::QuickTime::ProtectionInfo' },
+    },
+    sinf => { # "protection scheme information"
+        Name => 'ProtectionInfo', #3
+        SubDirectory => { TagTable => 'Image::ExifTool::QuickTime::ProtectionInfo' },
+    },
+    # chan - 16/36 bytes
+    # esds - 31/40/42/43 bytes - ES descriptor (ref 3)
+    damr => { #3
+        Name => 'DecodeConfig',
+        SubDirectory => { TagTable => 'Image::ExifTool::QuickTime::DecodeConfig' },
+    },
+    wave => {
+        Name => 'Wave',
+        SubDirectory => { TagTable => 'Image::ExifTool::QuickTime::Wave' },
+    },
+    # alac - 28 bytes
+);
+
+# AMR decode config box (ref 3)
+%Image::ExifTool::QuickTime::DecodeConfig = (
+    PROCESS_PROC => \&Image::ExifTool::ProcessBinaryData,
+    GROUPS => { 2 => 'Audio' },
+    0 => {
+        Name => 'EncoderVendor',
         Format => 'undef[4]',
-        RawConv => '$val =~ /^[\w ]{4}$/i ? $val : undef',
-        Notes => 'in Casio MOV videos',
     },
+    4 => 'EncoderVersion',
+    # 5 - int16u - packet modes
+    # 7 - int8u - number of packet mode changes
+    # 8 - int8u - bytes per packet
+);
+
+%Image::ExifTool::QuickTime::ProtectionInfo = (
+    PROCESS_PROC => \&ProcessMOV,
+    GROUPS => { 2 => 'Audio' },
+    NOTES => 'Child atoms found in "sinf" and/or "pinf" atoms.',
+    frma => 'OriginalFormat',
+    # imif - IPMP information
+    schm => {
+        Name => 'SchemeType',
+        SubDirectory => { TagTable => 'Image::ExifTool::QuickTime::SchemeType' },
+    },
+    schi => {
+        Name => 'SchemeInfo',
+        SubDirectory => { TagTable => 'Image::ExifTool::QuickTime::SchemeInfo' },
+    },
+    # skcr
+    # enda
+);
+
+%Image::ExifTool::QuickTime::Wave = (
+    PROCESS_PROC => \&ProcessMOV,
+    frma => 'PurchaseFileFormat',
+    # "ms\0\x11" - 20 bytes
+);
+
+# scheme type atom
+# ref http://xhelmboyx.tripod.com/formats/mp4-layout.txt
+%Image::ExifTool::QuickTime::SchemeType = (
+    PROCESS_PROC => \&Image::ExifTool::ProcessBinaryData,
+    GROUPS => { 2 => 'Audio' },
+    # 0 - 4 bytes version
+    4 => { Name => 'SchemeType',    Format => 'undef[4]' },
+    8 => { Name => 'SchemeVersion', Format => 'int16u' },
+    10 => { Name => 'SchemeURL',    Format => 'string[$size-10]' },
+);
+
+%Image::ExifTool::QuickTime::SchemeInfo = (
+    PROCESS_PROC => \&ProcessMOV,
+    GROUPS => { 2 => 'Audio' },
+    user => {
+        Name => 'UserID',
+        Groups => { 2 => 'Author' },
+        ValueConv => '"0x" . unpack("H*",$val)',
+    },
+    cert => { # ref http://www.onvif.org/specs/stream/ONVIF-ExportFileFormat-Spec-v100.pdf
+        Name => 'Certificate',
+        ValueConv => '"0x" . unpack("H*",$val)',
+    },
+    'key ' => {
+        Name => 'KeyID',
+        ValueConv => '"0x" . unpack("H*",$val)',
+    },
+    iviv => {
+        Name => 'InitializationVector',
+        ValueConv => 'unpack("H*",$val)',
+    },
+    righ => {
+        Name => 'Rights',
+        Groups => { 2 => 'Author' },
+        SubDirectory => { TagTable => 'Image::ExifTool::QuickTime::Rights' },
+    },
+    name => { Name => 'UserName', Groups => { 2 => 'Author' } },
+    # chtb
+    # priv - private data
+    # sign
+    # adkm - Adobe DRM key management system (ref http://download.macromedia.com/f4v/video_file_format_spec_v10_1.pdf)
+    # iKMS
+    # iSFM
+    # iSLT
+);
+
+%Image::ExifTool::QuickTime::Rights = (
+    PROCESS_PROC => \&ProcessRights,
+    GROUPS => { 2 => 'Audio' },
+    veID => 'ItemVendorID', #PH ("VendorID" ref 19)
+    plat => 'Platform', #18?
+    aver => 'VersionRestrictions', #19 ("appversion?" ref 18)
+    tran => 'TransactionID', #18
+    song => 'ItemID', #19 ("appid" ref 18)
+    tool => {
+        Name => 'ItemTool', #PH (guess) ("itunes build?" ref 18)
+        Format => 'string',
+    },
+    medi => 'MediaFlags', #PH (?)
+    mode => 'ModeFlags', #PH (?) 0x04 is HD flag (https://compilr.com/heksesang/requiem-mac/UnDrm.java)
 );
 
 # MP4 hint sample description box (ref 5)
+# (ref https://developer.apple.com/library/mac/documentation/QuickTime/QTFF/QTFFChap3/qtff3.html#//apple_ref/doc/uid/TP40000939-CH205-SW1)
 %Image::ExifTool::QuickTime::HintSampleDesc = (
-    PROCESS_PROC => \&Image::ExifTool::ProcessBinaryData,
-    FORMAT => 'int16u',
+    PROCESS_PROC => \&ProcessHybrid,
+    VARS => { ID_LABEL => 'ID/Index' },
     NOTES => 'MP4 hint sample description.',
-    2 => { Name => 'HintFormat', Format => 'undef[4]' },
+    4  => { Name => 'HintFormat', Format => 'undef[4]' },
+    # 14 - int16u DataReferenceIndex
+    16 => { Name => 'HintTrackVersion', Format => 'int16u' },
+    # 18 - int16u LastCompatibleHintTrackVersion
+    20 => { Name => 'MaxPacketSize', Format => 'int32u' },
+#
+# Observed offsets for child atoms of various HintFormat types:
+#
+#   HintFormat   Offset  Child atoms
+#   -----------  ------  ----------------
+#   "rtp "       24      tims
+#
+    tims => { Name => 'RTPTimeScale',               Format => 'int32u' },
+    tsro => { Name => 'TimestampRandomOffset',      Format => 'int32u' },
+    snro => { Name => 'SequenceNumberRandomOffset', Format => 'int32u' },
 );
 
 # MP4 generic sample description box
 %Image::ExifTool::QuickTime::OtherSampleDesc = (
-    PROCESS_PROC => \&Image::ExifTool::ProcessBinaryData,
-    FORMAT => 'int16u',
-    2 => { Name => 'OtherFormat', Format => 'undef[4]' },
+    PROCESS_PROC => \&ProcessHybrid,
+    4 => { Name => 'OtherFormat', Format => 'undef[4]' },
+#
+# Observed offsets for child atoms of various OtherFormat types:
+#
+#   OtherFormat  Offset  Child atoms
+#   -----------  ------  ----------------
+#   avc1         86      avcC
+#   mp4a         36      esds
+#   mp4s         16      esds
+#   tmcd         34      name
+#
 );
 
 # MP4 data information box (ref 5)
@@ -2560,7 +2749,7 @@ my %graphicsMode = (
     6 => {
         Name => 'TextFace',
         Format => 'int16u',
-        PrintConv => { 
+        PrintConv => {
             0 => 'Plain',
             BITMASK => {
                 0 => 'Bold',
@@ -2577,15 +2766,16 @@ my %graphicsMode = (
         Name => 'TextSize',
         Format => 'int16u',
     },
-    10 => {
+    # 10 - reserved
+    12 => {
         Name => 'TextColor',
         Format => 'int16u[3]',
     },
-    16 => {
+    18 => {
         Name => 'BackgroundColor',
         Format => 'int16u[3]',
     },
-    22 => {
+    24 => {
         Name => 'FontName',
         Format => 'pstring',
         ValueConv => '$self->Decode($val, $self->Options("CharsetQuickTime"))',
@@ -2828,14 +3018,22 @@ my %graphicsMode = (
 Image::ExifTool::AddCompositeTags('Image::ExifTool::QuickTime');
 
 
+#------------------------------------------------------------------------------
+# AutoLoad our writer routines when necessary
+#
+sub AUTOLOAD
+{
+    return Image::ExifTool::DoAutoLoad($AUTOLOAD, @_);
+}
+
 #------------------------------------------------------------------------------
 # Calculate rotation of video track
 # Inputs: 0) ExifTool object ref
 # Returns: rotation angle or undef
 sub CalcRotation($)
 {
-    my $exifTool = shift;
-    my $value = $$exifTool{VALUE};
+    my $et = shift;
+    my $value = $$et{VALUE};
     my ($i, $track);
     # get the video track family 1 group (ie. "Track1");
     for ($i=0; ; ++$i) {
@@ -2843,7 +3041,7 @@ sub CalcRotation($)
         my $tag = "HandlerType$idx";
         last unless $$value{$tag};
         next unless $$value{$tag} eq 'vide';
-        $track = $exifTool->GetGroup($tag, 1);
+        $track = $et->GetGroup($tag, 1);
         last;
     }
     return undef unless $track;
@@ -2852,7 +3050,7 @@ sub CalcRotation($)
         my $idx = $i ? " ($i)" : '';
         my $tag = "MatrixStructure$idx";
         last unless $$value{$tag};
-        next unless $exifTool->GetGroup($tag, 1) eq $track;
+        next unless $et->GetGroup($tag, 1) eq $track;
         my @a = split ' ', $$value{$tag};
         return undef unless $a[0] or $a[1];
         # calculate the rotation angle (assume uniform rotation)
@@ -2869,7 +3067,7 @@ sub CalcRotation($)
 # Returns: average sample rate (in Hz)
 sub CalcSampleRate($$)
 {
-    my ($exifTool, $valPt) = @_;
+    my ($et, $valPt) = @_;
     my @dat = unpack('N*', $$valPt);
     my ($num, $dur) = (0, 0);
     my $i;
@@ -2877,8 +3075,8 @@ sub CalcSampleRate($$)
         $num += $dat[$i];               # total number of samples
         $dur += $dat[$i] * $dat[$i+1];  # total sample duration
     }
-    return undef unless $num and $dur and $$exifTool{MediaTS};
-    return $num * $$exifTool{MediaTS} / $dur;
+    return undef unless $num and $dur and $$et{MediaTS};
+    return $num * $$et{MediaTS} / $dur;
 }
 
 #------------------------------------------------------------------------------
@@ -2929,11 +3127,11 @@ sub ConvertISO6709($)
 # Returns: PrintConv value
 sub PrintGPSCoordinates($)
 {
-    my ($val, $exifTool) = @_;
+    my ($val, $et) = @_;
     require Image::ExifTool::GPS;
     my @v = split ' ', $val;
-    my $prt = Image::ExifTool::GPS::ToDMS($exifTool, $v[0], 1, "N") . ', ' .
-              Image::ExifTool::GPS::ToDMS($exifTool, $v[1], 1, "E");
+    my $prt = Image::ExifTool::GPS::ToDMS($et, $v[0], 1, "N") . ', ' .
+              Image::ExifTool::GPS::ToDMS($et, $v[1], 1, "E");
     if (defined $v[2]) {
         $prt .= ', ' . ($v[2] < 0 ? -$v[2] . ' m Below' : $v[2] . ' m Above') . ' Sea Level';
     }
@@ -2967,13 +3165,13 @@ sub UnpackLang($)
 # Returns: 1 on success
 sub ProcessMetaData($$$)
 {
-    my ($exifTool, $dirInfo, $tagTablePtr) = @_;
+    my ($et, $dirInfo, $tagTablePtr) = @_;
     my $dataPt = $$dirInfo{DataPt};
     my $dirLen = length $$dataPt;
-    my $verbose = $exifTool->Options('Verbose');
+    my $verbose = $et->Options('Verbose');
     return 0 unless $dirLen >= 2;
     my $count = Get16u($dataPt, 0);
-    $verbose and $exifTool->VerboseDir('MetaData', $count);
+    $verbose and $et->VerboseDir('MetaData', $count);
     my $i;
     my $pos = 2;
     for ($i=0; $i<$count; ++$i) {
@@ -2984,7 +3182,7 @@ sub ProcessMetaData($$$)
         my $lang = Get16u($dataPt, $pos + 6);
         my $enc  = Get16u($dataPt, $pos + 8);
         my $val  = substr($$dataPt, $pos + 10, $size);
-        my $tagInfo = $exifTool->GetTagInfo($tagTablePtr, $tag);
+        my $tagInfo = $et->GetTagInfo($tagTablePtr, $tag);
         if ($tagInfo) {
             # convert language code to ASCII (ignore read-only bit)
             $lang = UnpackLang($lang);
@@ -2993,19 +3191,19 @@ sub ProcessMetaData($$$)
                 my $langInfo = Image::ExifTool::GetLangInfo($tagInfo, $lang);
                 $tagInfo = $langInfo if $langInfo;
             }
-            $verbose and $exifTool->VerboseInfo($tag, $tagInfo,
+            $verbose and $et->VerboseInfo($tag, $tagInfo,
                 Value  => $val,
                 DataPt => $dataPt,
                 Start  => $pos + 10,
                 Size   => $size - 10,
             );
             # convert from UTF-16 BE if necessary
-            $val = $exifTool->Decode($val, 'UCS2') if $enc == 1;
+            $val = $et->Decode($val, 'UCS2') if $enc == 1;
             if ($enc == 0 and $$tagInfo{Unknown}) {
                 # binary data
-                $exifTool->FoundTag($tagInfo, \$val);
+                $et->FoundTag($tagInfo, \$val);
             } else {
-                $exifTool->FoundTag($tagInfo, $val);
+                $et->FoundTag($tagInfo, $val);
             }
         }
         $pos += $size;
@@ -3013,20 +3211,103 @@ sub ProcessMetaData($$$)
     return 1;
 }
 
+#------------------------------------------------------------------------------
+# Process hybrid binary data + QuickTime container (ref PH)
+# Inputs: 0) ExifTool object ref, 1) dirInfo ref, 2) tag table ref
+# Returns: 1 on success
+sub ProcessHybrid($$$)
+{
+    my ($et, $dirInfo, $tagTablePtr) = @_;
+    # brute-force search for child atoms after first 8 bytes of binary data
+    my $dataPt = $$dirInfo{DataPt};
+    my $pos = ($$dirInfo{DirStart} || 0) + 8;
+    my $len = length($$dataPt);
+    my $try = $pos;
+    my $childPos;
+
+    while ($pos <= $len - 8) {
+        my $tag = substr($$dataPt, $try+4, 4);
+        # look only for well-behaved tag ID's
+        $tag =~ /[^\w ]/ and $try = ++$pos, next;
+        my $size = Get32u($dataPt, $try);
+        if ($size + $try == $len) {
+            # the atom ends exactly at the end of the parent -- this must be it
+            $childPos = $pos;
+            $$dirInfo{DirLen} = $pos;   # the binary data ends at the first child atom
+            last;
+        }
+        if ($size < 8 or $size + $try > $len - 8) {
+            $try = ++$pos;  # fail.  try next position
+        } else {
+            $try += $size;  # could be another atom following this
+        }
+    }
+    # process binary data
+    $$dirInfo{MixedTags} = 1; # ignore non-integer tag ID's
+    $et->ProcessBinaryData($dirInfo, $tagTablePtr);
+    # process child atoms if found
+    if ($childPos) {
+        $$dirInfo{DirStart} = $childPos;
+        $$dirInfo{DirLen} = $len - $childPos;
+        ProcessMOV($et, $dirInfo, $tagTablePtr);
+    }
+    return 1;
+}
+
+#------------------------------------------------------------------------------
+# Process iTunes 'righ' atom (ref PH)
+# Inputs: 0) ExifTool object ref, 1) dirInfo ref, 2) tag table ref
+# Returns: 1 on success
+sub ProcessRights($$$)
+{
+    my ($et, $dirInfo, $tagTablePtr) = @_;
+    my $dataPt = $$dirInfo{DataPt};
+    my $dataPos = $$dirInfo{Base};
+    my $dirLen = length $$dataPt;
+    my $unknown = $$et{OPTIONS}{Unkown} || $$et{OPTIONS}{Verbose};
+    my $pos;
+    $et->VerboseDir('righ', $dirLen / 8);
+    for ($pos = 0; $pos + 8 <= $dirLen; $pos += 8) {
+        my $tag = substr($$dataPt, $pos, 4);
+        last if $tag eq "\0\0\0\0";
+        my $val = substr($$dataPt, $pos + 4, 4);
+        my $tagInfo = $et->GetTagInfo($tagTablePtr, $tag);
+        unless ($tagInfo) {
+            next unless $unknown;
+            my $name = $tag;
+            $name =~ s/([\x00-\x1f\x7f-\xff])/'x'.unpack('H*',$1)/eg;
+            $tagInfo = {
+                Name => "Unknown_$name",
+                Description => "Unknown $name",
+                Unknown => 1,
+            },
+            AddTagToTable($tagTablePtr, $tag, $tagInfo);
+        }
+        $val = '0x' . unpack('H*', $val) unless $$tagInfo{Format};
+        $et->HandleTag($tagTablePtr, $tag, $val,
+            DataPt  => $dataPt,
+            DataPos => $dataPos,
+            Start   => $pos + 4,
+            Size    => 4,
+        );
+    }
+    return 1;
+}
+
 #------------------------------------------------------------------------------
 # Process iTunes Encoding Params (ref PH)
 # Inputs: 0) ExifTool object ref, 1) dirInfo ref, 2) tag table ref
 # Returns: 1 on success
 sub ProcessEncodingParams($$$)
 {
-    my ($exifTool, $dirInfo, $tagTablePtr) = @_;
+    my ($et, $dirInfo, $tagTablePtr) = @_;
     my $dataPt = $$dirInfo{DataPt};
     my $dirLen = length $$dataPt;
     my $pos;
-    $exifTool->VerboseDir('Encoding Params', $dirLen / 8);
+    $et->VerboseDir('Encoding Params', $dirLen / 8);
     for ($pos = 0; $pos + 8 <= $dirLen; $pos += 8) {
         my ($tag, $val) = unpack("x${pos}a4N", $$dataPt);
-        $exifTool->HandleTag($tagTablePtr, $tag, $val);
+        $et->HandleTag($tagTablePtr, $tag, $val);
     }
     return 1;
 }
@@ -3037,13 +3318,13 @@ sub ProcessEncodingParams($$$)
 # Returns: 1 on success
 sub ProcessKeys($$$)
 {
-    my ($exifTool, $dirInfo, $tagTablePtr) = @_;
+    my ($et, $dirInfo, $tagTablePtr) = @_;
     my $dataPt = $$dirInfo{DataPt};
     my $dirLen = length $$dataPt;
     my $out;
-    if ($exifTool->Options('Verbose')) {
-        $exifTool->VerboseDir('Keys');
-        $out = $exifTool->Options('TextOut');
+    if ($et->Options('Verbose')) {
+        $et->VerboseDir('Keys');
+        $out = $et->Options('TextOut');
     }
     my $pos = 8;
     my $index = 1;
@@ -3061,15 +3342,15 @@ sub ProcessKeys($$$)
         }
         next unless $tag;
         # (I have some samples where the tag is a reversed ItemList or UserData tag ID)
-        my $tagInfo = $exifTool->GetTagInfo($tagTablePtr, $tag);
+        my $tagInfo = $et->GetTagInfo($tagTablePtr, $tag);
         unless ($tagInfo) {
-            $tagInfo = $exifTool->GetTagInfo($infoTable, $tag);
+            $tagInfo = $et->GetTagInfo($infoTable, $tag);
             unless ($tagInfo) {
-                $tagInfo = $exifTool->GetTagInfo($userTable, $tag);
+                $tagInfo = $et->GetTagInfo($userTable, $tag);
                 if (not $tagInfo and $tag =~ /^\w{3}\xa9$/) {
                     $tag = pack('N', unpack('V', $tag));
-                    $tagInfo = $exifTool->GetTagInfo($infoTable, $tag);
-                    $tagInfo or $tagInfo = $exifTool->GetTagInfo($userTable, $tag);
+                    $tagInfo = $et->GetTagInfo($infoTable, $tag);
+                    $tagInfo or $tagInfo = $et->GetTagInfo($userTable, $tag);
                 }
             }
         }
@@ -3095,7 +3376,7 @@ sub ProcessKeys($$$)
         if ($newInfo) {
             $msg or $msg = '';
             AddTagToTable($infoTable, $index, $newInfo);
-            $out and printf $out "%sAdded ItemList Tag 0x%.4x = $tag$msg\n", $exifTool->{INDENT}, $index;
+            $out and printf $out "%sAdded ItemList Tag 0x%.4x = $tag$msg\n", $$et{INDENT}, $index;
         }
         $pos += $len;
         ++$index;
@@ -3109,12 +3390,12 @@ sub ProcessKeys($$$)
 # Returns: 1 on success
 sub ProcessMOV($$;$)
 {
-    my ($exifTool, $dirInfo, $tagTablePtr) = @_;
+    my ($et, $dirInfo, $tagTablePtr) = @_;
     my $raf = $$dirInfo{RAF};
     my $dataPt = $$dirInfo{DataPt};
-    my $verbose = $exifTool->Options('Verbose');
+    my $verbose = $et->Options('Verbose');
     my $dataPos = $$dirInfo{Base} || 0;
-    my $charsetQuickTime = $exifTool->Options('CharsetQuickTime');
+    my $charsetQuickTime = $et->Options('CharsetQuickTime');
     my ($buff, $tag, $size, $track, $isUserData, %triplet);
 
     # more convenient to package data as a RandomAccess file
@@ -3134,69 +3415,95 @@ sub ProcessMOV($$;$)
     }
     ($size, $tag) = unpack('Na4', $buff);
     if ($dataPt) {
-        $verbose and $exifTool->VerboseDir($$dirInfo{DirName});
+        $verbose and $et->VerboseDir($$dirInfo{DirName});
     } else {
         # check on file type if called with a RAF
         $$tagTablePtr{$tag} or return 0;
-        if ($tag eq 'ftyp') {
-            # read ahead 4 bytes to see what type of file this is
+        if ($tag eq 'ftyp' and $size >= 12) {
+            # read ftyp atom to see what type of file this is
             my $fileType;
-            if ($raf->Read($buff, 4) == 4) {
-                $raf->Seek(-4, 1);
+            if ($raf->Read($buff, $size-8) == $size-8) {
+                $raf->Seek(-($size-8), 1);
+                my $type = substr($buff, 0, 4);
                 # see if we know the extension for this file type
-                $fileType = $1 if $ftypLookup{$buff} and $ftypLookup{$buff} =~ /\(\.(\w+)/;
+                if ($ftypLookup{$type} and $ftypLookup{$type} =~ /\(\.(\w+)/) {
+                    $fileType = $1;
+                # check compatible brands
+                } elsif ($buff =~ /^.{8}(.{4})+(mp41|mp42)/s) {
+                    $fileType = 'MP4';
+                } elsif ($buff =~ /^.{8}(.{4})+(f4v )/s) {
+                    $fileType = 'F4V';
+                } elsif ($buff =~ /^.{8}(.{4})+(qt  )/s) {
+                    $fileType = 'MOV';
+                }
             }
             $fileType or $fileType = 'MP4'; # default to MP4
-            $exifTool->SetFileType($fileType, $mimeLookup{$fileType} || 'video/mp4');
+            $et->SetFileType($fileType, $mimeLookup{$fileType} || 'video/mp4');
         } else {
-            $exifTool->SetFileType();       # MOV
+            $et->SetFileType();       # MOV
         }
         SetByteOrder('MM');
     }
     for (;;) {
         if ($size < 8) {
-            last if $size == 0;
-            $size == 1 or $exifTool->Warn('Invalid atom size'), last;
+            if ($size == 0) {
+                if ($dataPt) {
+                    # a zero size isn't legal for contained atoms, but Canon uses it to
+                    # terminate the CNTH atom (ie. CanonEOS100D.mov), so tolerate it here
+                    my $pos = $raf->Tell() - 4;
+                    $raf->Seek(0,2);
+                    my $str = $$dirInfo{DirName} . ' with ' . ($raf->Tell() - $pos) . ' bytes';
+                    $et->VPrint(0,"$$et{INDENT}\[Terminator found in $str remaining]");
+                } else {
+                    $tag = sprintf("0x%.8x",Get32u(\$tag,0)) if $tag =~ /[\x00-\x1f\x7f-\xff]/;
+                    $et->VPrint(0,"$$et{INDENT}Tag '$tag' extends to end of file");
+                }
+                last;
+            }
+            $size == 1 or $et->Warn('Invalid atom size'), last;
+            # read extended atom size
             $raf->Read($buff, 8) == 8 or last;
             $dataPos += 8;
             my ($hi, $lo) = unpack('NN', $buff);
-            $size = $lo;
             if ($hi or $lo > 0x7fffffff) {
                 if ($hi > 0x7fffffff) {
-                    $exifTool->Warn('Invalid atom size');
+                    $et->Warn('Invalid atom size');
                     last;
-                } elsif (not $exifTool->Options('LargeFileSupport')) {
-                    $exifTool->Warn('End of processing at large atom (LargeFileSupport not enabled)');
+                } elsif (not $et->Options('LargeFileSupport')) {
+                    $et->Warn('End of processing at large atom (LargeFileSupport not enabled)');
                     last;
                 }
             }
-            $size = $hi * 4294967296 + $lo - 8;
-            $size < 8 and $exifTool->Warn('Invalid extended size'), last;
+            $size = $hi * 4294967296 + $lo - 16;
+            $size < 0 and $et->Warn('Invalid extended size'), last;
+        } else {
+            $size -= 8;
         }
-        $size -= 8;
-        if ($isUserData and $$exifTool{SET_GROUP1}) {
-            my $tagInfo = $exifTool->GetTagInfo($tagTablePtr, $tag);
+        if ($isUserData and $$et{SET_GROUP1}) {
+            my $tagInfo = $et->GetTagInfo($tagTablePtr, $tag);
             # add track name to UserData tags inside tracks
-            $tag = $$exifTool{SET_GROUP1} . $tag;
+            $tag = $$et{SET_GROUP1} . $tag;
             if (not $$tagTablePtr{$tag} and $tagInfo) {
                 my %newInfo = %$tagInfo;
                 foreach ('Name', 'Description') {
-                    $newInfo{$_} = $$exifTool{SET_GROUP1} . $$tagInfo{$_} if $$tagInfo{$_};
+                    next unless $$tagInfo{$_};
+                    $newInfo{$_} = $$et{SET_GROUP1} . $$tagInfo{$_};
+                    $newInfo{$_} =~ s/^(Track\d+)Track/$1/; # remove duplicate "Track" in name
                 }
                 AddTagToTable($tagTablePtr, $tag, \%newInfo);
             }
         }
-        my $tagInfo = $exifTool->GetTagInfo($tagTablePtr, $tag);
+        my $tagInfo = $et->GetTagInfo($tagTablePtr, $tag);
         # allow numerical tag ID's
         unless ($tagInfo) {
             my $num = unpack('N', $tag);
             if ($$tagTablePtr{$num}) {
-                $tagInfo = $exifTool->GetTagInfo($tagTablePtr, $num);
+                $tagInfo = $et->GetTagInfo($tagTablePtr, $num);
                 $tag = $num;
             }
         }
         # generate tagInfo if Unknown option set
-        if (not defined $tagInfo and ($exifTool->{OPTIONS}->{Unknown} or
+        if (not defined $tagInfo and ($$et{OPTIONS}{Unknown} or
             $verbose or $tag =~ /^\xa9/))
         {
             my $name = $tag;
@@ -3219,23 +3526,24 @@ sub ProcessMOV($$;$)
             AddTagToTable($tagTablePtr, $tag, $tagInfo);
         }
         # save required tag sizes
-        $exifTool->HandleTag($tagTablePtr, "$tag-size", $size) if $$tagTablePtr{"$tag-size"};
+        $et->HandleTag($tagTablePtr, "$tag-size", $size) if $$tagTablePtr{"$tag-size"};
         # load values only if associated with a tag (or verbose) and < 16MB long
         if ((defined $tagInfo or $verbose) and $size < 0x1000000) {
             my $val;
-            unless ($raf->Read($val, $size) == $size) {
-                $exifTool->Warn("Truncated '$tag' data");
+            my $missing = $size - $raf->Read($val, $size);
+            if ($missing) {
+                $et->Warn("Truncated '$tag' data (missing $missing bytes)");
                 last;
             }
             # use value to get tag info if necessary
-            $tagInfo or $tagInfo = $exifTool->GetTagInfo($tagTablePtr, $tag, \$val);
+            $tagInfo or $tagInfo = $et->GetTagInfo($tagTablePtr, $tag, \$val);
             my $hasData = ($$dirInfo{HasData} and $val =~ /\0...data\0/s);
             if ($verbose and not $hasData) {
                 my $tval;
                 if ($tagInfo and $$tagInfo{Format}) {
                     $tval = ReadValue(\$val, 0, $$tagInfo{Format}, $$tagInfo{Count}, length($val));
                 }
-                $exifTool->VerboseInfo($tag, $tagInfo,
+                $et->VerboseInfo($tag, $tagInfo,
                     Value   => $tval,
                     DataPt  => \$val,
                     DataPos => $dataPos,
@@ -3249,7 +3557,7 @@ sub ProcessMOV($$;$)
                     $tag = $triplet{name};
                     # add 'mean' to name unless it is 'com.apple.iTunes'
                     $tag = $triplet{mean} . '/' . $tag unless $triplet{mean} eq 'com.apple.iTunes';
-                    $tagInfo = $exifTool->GetTagInfo($tagTablePtr, $tag, \$val);
+                    $tagInfo = $et->GetTagInfo($tagTablePtr, $tag, \$val);
                     unless ($tagInfo) {
                         my $name = $triplet{name};
                         my $desc = $name;
@@ -3298,20 +3606,21 @@ sub ProcessMOV($$;$)
                         # Base needed for IsOffset tags in binary data
                         Base     => $base,
                     );
+                    $dirInfo{BlockInfo} = $tagInfo if $$tagInfo{BlockExtract};
                     if ($$subdir{ByteOrder} and $$subdir{ByteOrder} =~ /^Little/) {
                         SetByteOrder('II');
                     }
-                    my $oldGroup1 = $exifTool->{SET_GROUP1};
+                    my $oldGroup1 = $$et{SET_GROUP1};
                     if ($$tagInfo{Name} eq 'Track') {
                         $track or $track = 0;
-                        $exifTool->{SET_GROUP1} = 'Track' . (++$track);
+                        $$et{SET_GROUP1} = 'Track' . (++$track);
                     }
                     my $subTable = GetTagTable($$subdir{TagTable});
                     my $proc = $$subdir{ProcessProc};
                     # make ProcessMOV() the default processing procedure for subdirectories
                     $proc = \&ProcessMOV unless $proc or $$subTable{PROCESS_PROC};
-                    $exifTool->ProcessDirectory(\%dirInfo, $subTable, $proc) if $size > $start;
-                    $exifTool->{SET_GROUP1} = $oldGroup1;
+                    $et->ProcessDirectory(\%dirInfo, $subTable, $proc) if $size > $start;
+                    $$et{SET_GROUP1} = $oldGroup1;
                     SetByteOrder('MM');
                 } elsif ($hasData) {
                     # handle atoms containing 'data' tags
@@ -3334,7 +3643,7 @@ sub ProcessMOV($$;$)
                             # 0x18=double, 0x1b=BMP, 0x1c='meta' atom
                             if ($stringEncoding{$flags}) {
                                 # handle all string formats
-                                $value = $exifTool->Decode($value, $stringEncoding{$flags});
+                                $value = $et->Decode($value, $stringEncoding{$flags});
                             } else {
                                 if (not $format) {
                                     if ($flags == 0x15 or $flags == 0x16) {
@@ -3381,7 +3690,7 @@ sub ProcessMOV($$;$)
                             $langInfo = Image::ExifTool::GetLangInfo($tagInfo, $lang) if $lang;
                         }
                         $langInfo or $langInfo = $tagInfo;
-                        $exifTool->VerboseInfo($tag, $langInfo,
+                        $et->VerboseInfo($tag, $langInfo,
                             Value   => ref $value ? $$value : $value,
                             DataPt  => \$val,
                             DataPos => $dataPos,
@@ -3390,10 +3699,10 @@ sub ProcessMOV($$;$)
                             Format  => $format,
                             Extra   => sprintf(", Type='$type', Flags=0x%x",$flags)
                         ) if $verbose;
-                        $exifTool->FoundTag($langInfo, $value) if defined $value;
+                        $et->FoundTag($langInfo, $value) if defined $value;
                         $pos += $len;
                     }
-                } elsif ($tag =~ /^\xa9/) {
+                } elsif ($tag =~ /^\xa9/ or $$tagInfo{IText}) {
                     # parse international text to extract all languages
                     my $pos = 0;
                     for (;;) {
@@ -3415,23 +3724,23 @@ sub ProcessMOV($$;$)
                         if ($lang < 0x400) {
                             # this is a Macintosh language code
                             # a language code of 0 is Macintosh english, so treat as default
-                            if ($lang) { 
+                            if ($lang) {
                                 # use Font.pm to look up language string
                                 require Image::ExifTool::Font;
                                 $lang = $Image::ExifTool::Font::ttLang{Macintosh}{$lang};
                             }
                             # the spec says only "Macintosh text encoding", but
                             # allow this to be configured by the user
-                            $str = $exifTool->Decode($str, $charsetQuickTime);
+                            $str = $et->Decode($str, $charsetQuickTime);
                         } else {
                             # convert language code to ASCII (ignore read-only bit)
                             $lang = UnpackLang($lang);
                             # may be either UTF-8 or UTF-16BE
                             my $enc = $str=~s/^\xfe\xff// ? 'UTF16' : 'UTF8';
-                            $str = $exifTool->Decode($str, $enc);
+                            $str = $et->Decode($str, $enc);
                         }
                         $langInfo = Image::ExifTool::GetLangInfo($tagInfo, $lang) if $lang;
-                        $exifTool->FoundTag($langInfo || $tagInfo, $str);
+                        $et->FoundTag($langInfo || $tagInfo, $str);
                         $pos += $len;
                     }
                 } else {
@@ -3439,22 +3748,22 @@ sub ProcessMOV($$;$)
                     if ($format) {
                         $val = ReadValue(\$val, 0, $format, $$tagInfo{Count}, length($val));
                     }
-                    my $key = $exifTool->FoundTag($tagInfo, $val);
+                    my $key = $et->FoundTag($tagInfo, $val);
                     # decode if necessary (NOTE: must be done after RawConv)
                     if (defined $key and (not $format or $format =~ /^string/) and
                         not $$tagInfo{Unknown} and not $$tagInfo{ValueConv} and
-                        not $$tagInfo{Binary} and defined $$exifTool{VALUE}{$key} and not ref $val)
+                        not $$tagInfo{Binary} and defined $$et{VALUE}{$key} and not ref $val)
                     {
-                        my $vp = \$$exifTool{VALUE}{$key};
+                        my $vp = \$$et{VALUE}{$key};
                         if (not ref $$vp and length($$vp) <= 65536 and $$vp =~ /[\x80-\xff]/) {
                             # the encoding of this is not specified, so use CharsetQuickTime
-                            $$vp = $exifTool->Decode($$vp, $charsetQuickTime);
+                            $$vp = $et->Decode($$vp, $charsetQuickTime);
                         }
                     }
                 }
             }
         } else {
-            $raf->Seek($size, 1) or $exifTool->Warn("Truncated '$tag' data"), last;
+            $raf->Seek($size, 1) or $et->Warn("Truncated '$tag' data"), last;
         }
         $raf->Read($buff, 8) == 8 or last;
         $dataPos += $size + 8;
@@ -3469,9 +3778,9 @@ sub ProcessMOV($$;$)
 # Returns: 1 on success
 sub ProcessQTIF($$)
 {
-    my ($exifTool, $dirInfo) = @_;
+    my ($et, $dirInfo) = @_;
     my $table = GetTagTable('Image::ExifTool::QuickTime::ImageFile');
-    return ProcessMOV($exifTool, $dirInfo, $table);
+    return ProcessMOV($et, $dirInfo, $table);
 }
 
 1;  # end