Implement reading of media track info from WebM and MP4 containers

media/formats/mp4/box_definitions.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/formats/mp4/box_definitions.h"
 
 #include <utility>
 
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 357 matching lines @@
 bool Edit::Parse(BoxReader* reader) {
   return reader->ScanChildren() && reader->ReadChild(&list);
 }
 
 HandlerReference::HandlerReference() : type(kInvalid) {}
 HandlerReference::~HandlerReference() {}
 FourCC HandlerReference::BoxType() const { return FOURCC_HDLR; }
 
 bool HandlerReference::Parse(BoxReader* reader) {
   FourCC hdlr_type;
-  RCHECK(reader->SkipBytes(8) && reader->ReadFourCC(&hdlr_type));
-  // Note: remaining fields in box ignored
+  RCHECK(reader->ReadFullBoxHeader() && reader->SkipBytes(4) &&
+         reader->ReadFourCC(&hdlr_type) && reader->SkipBytes(12));
+
+  // Now we should be at the beginning of the |name| field of HDLR box. The
+  // |name| is a zero-terminated ASCII string in ISO BMFF, but it was a
+  // Pascal-style counted string in older QT/Mov formats. So we'll read the
+  // remaining box bytes first, then if the last one is zero, we strip the last
+  // zero byte, otherwise we'll string the first byte (containing the length of
+  // the Pascal-style string).

[wolenetz, 2016/03/05 03:26:20]

A pascal-style string that is shorter than (remaining box bytes + 1) might need
to be truncated to remove potential garbage chars at the end. Should we do any
verification / truncation around suspected pascal-style strings here, too?

[servolk, 2016/03/07 23:45:01]

Sure, I've added an RCHECK to ensure that the length of pascal-style string is
correct.

+  std::vector<uint8_t> name_bytes;
+  RCHECK(reader->ReadVec(&name_bytes, reader->size() - reader->pos()));
+  if (name_bytes.back() == 0)
+    name_bytes.pop_back();
+  else
+    name_bytes.erase(name_bytes.begin());
+  name = std::string(name_bytes.begin(), name_bytes.end());
+
   if (hdlr_type == FOURCC_VIDE) {
     type = kVideo;
   } else if (hdlr_type == FOURCC_SOUN) {
     type = kAudio;
   } else {
     type = kInvalid;
   }
   return true;
 }
 
@@ skipping 235 matching lines @@
 
   // ESDS is not valid in case of EAC3.
   RCHECK(reader->MaybeReadChild(&esds));
   return true;
 }
 
 MediaHeader::MediaHeader()
     : creation_time(0),
       modification_time(0),
       timescale(0),
-      duration(0) {}
+      duration(0),
+      language_code(0) {}
 MediaHeader::~MediaHeader() {}
 FourCC MediaHeader::BoxType() const { return FOURCC_MDHD; }
 
 bool MediaHeader::Parse(BoxReader* reader) {
   RCHECK(reader->ReadFullBoxHeader());
 
   if (reader->version() == 1) {
-    RCHECK(reader->Read8(&creation_time) &&
-           reader->Read8(&modification_time) &&
-           reader->Read4(&timescale) &&
-           reader->Read8(&duration));
+    RCHECK(reader->Read8(&creation_time) && reader->Read8(&modification_time) &&
+           reader->Read4(&timescale) && reader->Read8(&duration) &&
+           reader->Read2(&language_code));
   } else {
     RCHECK(reader->Read4Into8(&creation_time) &&
            reader->Read4Into8(&modification_time) &&
-           reader->Read4(&timescale) &&
-           reader->Read4Into8(&duration));
+           reader->Read4(&timescale) && reader->Read4Into8(&duration) &&
+           reader->Read2(&language_code));
   }
-  // Skip language information
-  return reader->SkipBytes(4);
+  // Skip playback quality information
+  return reader->SkipBytes(2);
+}
+
+std::string MediaHeader::language() const {
+  if (language_code == 0x7fff || language_code < 0x400) {

[wolenetz, 2016/03/05 03:26:21]

A couple questions about this line:
1) Where do these two magic numbers come from?
2) Is the 16th bit always expected to be zero, or should we mask it off here
before comparing with the magic numbers?

[servolk, 2016/03/07 23:45:01]

1) I took those numbers from
https://developer.apple.com/library/mac/documentation/QuickTime/QTFF/QTFFChap...
which is linked from
https://developer.apple.com/library/mac/documentation/QuickTime/QTFF/QTFFChap....
Ideally we'll want to read and use BCP47 language tag from ELNG atom in .mp4
(see https://codereview.chromium.org/1718773002/). But we should probably keep
this as well, as a fallback for better backward compatibility with old streams,
that don't have the ELNG atom.
2) I think it should always be zero, but there's no harm in masking it.

[wolenetz, 2016/03/10 19:53:29]

Acknowledged.

+    return "und";
+  }
+  char lang_chars[4];
+  lang_chars[3] = 0;
+  lang_chars[2] = 0x60 + (language_code & 0x1f);

[wolenetz, 2016/03/05 03:26:21]

nit: constrain each of lang_chars[0..2] to be within the range of lower case
characters, and if that constraint isn't met, default to "und"?

[servolk, 2016/03/07 23:45:01]

Done.

+  lang_chars[1] = 0x60 + ((language_code >> 5) & 0x1f);
+  lang_chars[0] = 0x60 + ((language_code >> 10) & 0x1f);
+  return lang_chars;
 }
 
 MediaInformation::MediaInformation() {}
 MediaInformation::~MediaInformation() {}
 FourCC MediaInformation::BoxType() const { return FOURCC_MINF; }
 
 bool MediaInformation::Parse(BoxReader* reader) {
   return reader->ScanChildren() &&
          reader->ReadChild(&sample_table);
 }
@@ skipping 376 matching lines @@
 SampleDependsOn IndependentAndDisposableSamples::sample_depends_on(
     size_t i) const {
   if (i >= sample_depends_on_.size())
     return kSampleDependsOnUnknown;
 
   return sample_depends_on_[i];
 }
 
 }  // namespace mp4
 }  // namespace media