MSE: Parse WebM TrackEntry DefaultDuration field

media/formats/webm/tracks_builder.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/webm/tracks_builder.h"
 
 #include "media/formats/webm/webm_constants.h"
 
 namespace media {
 
@@ skipping 36 matching lines @@
 }
 
 static int MasterElementSize(int element_id, int payload_size) {
   return GetUIntSize(element_id) + GetUIntMkvSize(payload_size) + payload_size;
 }
 
 static int IntElementSize(int element_id, int value) {
   return GetUIntSize(element_id) + 1 + GetUIntSize(value);
 }
 
+static int DoubleElementSize(int element_id) {
+  return GetUIntSize(element_id) + 1 + 8;
+}
+
 static int StringElementSize(int element_id, const std::string& value) {
  return GetUIntSize(element_id) +
         GetUIntMkvSize(value.length()) +
         value.length();
 }
 
 static void SerializeInt(uint8** buf_ptr, int* buf_size_ptr,
                          int64 value, int size) {
   uint8*& buf = *buf_ptr;
   int& buf_size = *buf_size_ptr;
 
   for (int idx = 1; idx <= size; ++idx) {
     *buf++ = static_cast<uint8>(value >> ((size - idx) * 8));
     --buf_size;
   }
 }
 
+static void SerializeDouble(uint8** buf_ptr, int* buf_size_ptr,
+                            double value) {
+  uint8*& buf = *buf_ptr;
+  int& buf_size = *buf_size_ptr;
+
+  // Use a union to convert |value| to native endian integer bit pattern.
+  union {
+    double src;
+    int64 dst;
+  } tmp;
+  tmp.src = value;
+  int64 pattern = tmp.dst;
+
+  // Write the bytes from native endian |pattern| to big-endian form in buf.
+  for (int idx = 1; idx <= 8; ++idx) {

[acolwell GONE FROM CHROMIUM, 2014/03/26 22:25:32]

nit: How about SerializeInt(buf_ptr, buf_size_ptr, tmp.dst, 8) here instead to
avoid code duplication?

[wolenetz, 2014/03/27 01:21:43]

Nice. Done.

+    *buf++ = static_cast<uint8>(pattern >> ((8 - idx) * 8));
+    --buf_size;
+  }
+}
+
 static void WriteElementId(uint8** buf, int* buf_size, int element_id) {
   SerializeInt(buf, buf_size, element_id, GetUIntSize(element_id));
 }
 
 static void WriteUInt(uint8** buf, int* buf_size, uint64 value) {
   const int size = GetUIntMkvSize(value);
   value |= (1ULL << (size * 7));  // Matroska formatting
   SerializeInt(buf, buf_size, value, size);
 }
 
 static void WriteMasterElement(uint8** buf, int* buf_size,
                                int element_id, int payload_size) {
   WriteElementId(buf, buf_size, element_id);
   WriteUInt(buf, buf_size, payload_size);
 }
 
 static void WriteIntElement(uint8** buf, int* buf_size,
                             int element_id, int value) {
   WriteElementId(buf, buf_size, element_id);
 
   const int size = GetUIntSize(value);
   WriteUInt(buf, buf_size, size);
 
   SerializeInt(buf, buf_size, value, size);
 }
 
+static void WriteDoubleElement(uint8** buf, int* buf_size,
+                               int element_id, double value) {
+  WriteElementId(buf, buf_size, element_id);
+  WriteUInt(buf, buf_size, 8);
+  SerializeDouble(buf, buf_size, value);
+}
+
 static void WriteStringElement(uint8** buf_ptr, int* buf_size_ptr,
                                int element_id, const std::string& value) {
   uint8*& buf = *buf_ptr;
   int& buf_size = *buf_size_ptr;
 
   WriteElementId(&buf, &buf_size, element_id);
 
   const uint64 size = value.length();
   WriteUInt(&buf, &buf_size, size);
 
   memcpy(buf, value.data(), size);
   buf += size;
   buf_size -= size;
 }
 
 TracksBuilder::TracksBuilder() {}
 TracksBuilder::~TracksBuilder() {}
 
 void TracksBuilder::AddTrack(
     int track_num,
     int track_type,
     int track_uid,
     const std::string& codec_id,
     const std::string& name,
-    const std::string& language) {
+    const std::string& language,
+    int default_duration,
+    int video_pixel_width,
+    int video_pixel_height,
+    int audio_channels,
+    double audio_sampling_frequency) {
   tracks_.push_back(Track(track_num, track_type, track_uid, codec_id, name,
-                          language));
+                          language, default_duration, video_pixel_width,
+                          video_pixel_height, audio_channels,
+                          audio_sampling_frequency));
 }
 
 std::vector<uint8> TracksBuilder::Finish() {
   // Allocate the storage
   std::vector<uint8> buffer;
   buffer.resize(GetTracksSize());
 
   // Populate the storage with a tracks header
   WriteTracks(&buffer[0], buffer.size());
 
@@ skipping 20 matching lines @@
 
   for (TrackList::const_iterator itr = tracks_.begin();
        itr != tracks_.end(); ++itr) {
     itr->Write(&buf, &buf_size);
   }
 }
 
 TracksBuilder::Track::Track(int track_num, int track_type, int track_uid,
                             const std::string& codec_id,
                             const std::string& name,
-                            const std::string& language)
+                            const std::string& language,
+                            int default_duration,
+                            int video_pixel_width, int video_pixel_height,
+                            int audio_channels, double audio_sampling_frequency)
     : track_num_(track_num),
       track_type_(track_type),
       track_uid_(track_uid),
       codec_id_(codec_id),
       name_(name),
-      language_(language) {
+      language_(language),
+      default_duration_(default_duration),
+      video_pixel_width_(video_pixel_width),
+      video_pixel_height_(video_pixel_height),
+      audio_channels_(audio_channels),
+      audio_sampling_frequency_(audio_sampling_frequency) {
 }
 
 int TracksBuilder::Track::GetSize() const {
   return MasterElementSize(kWebMIdTrackEntry, GetPayloadSize());
 }
 
+int TracksBuilder::Track::GetVideoPayloadSize() const {

[acolwell GONE FROM CHROMIUM, 2014/03/26 22:25:32]

nit: s/Payload/Element to match other naming here and elsewhere.

[wolenetz, 2014/03/27 01:21:43]

Hmm. I thought PayloadSize refers to the contents of the element, not include
the actual (master) element header, and (Master)ElementSize refers to the sum of
the (master) element header plus its payload size. See, for example, how there
is a distinct need for the payload vs the master sizes in:
Track::Write()'s WriteMasterElement(...kWebMIdAudio, GetAudioPayloadSize())
Track::GetPayloadSize()'s MasterElementSize(KWebMIdAudio,
GetAudioPayloadSize()).

Update: I confirmed offline my assumption that kWebMIdAudio and kWebMIdVideo
should use similar MasterElement and PayloadSize nomenclature like
kWebMIdTracks.

+  int payload_size = 0;
+
+  if (video_pixel_width_ >= 0)
+    payload_size += IntElementSize(kWebMIdPixelWidth, video_pixel_width_);
+  if (video_pixel_height_ >= 0)
+    payload_size += IntElementSize(kWebMIdPixelHeight, video_pixel_height_);
+
+  return payload_size;
+}
+
+int TracksBuilder::Track::GetAudioPayloadSize() const {

[acolwell GONE FROM CHROMIUM, 2014/03/26 22:25:32]

ditto

[wolenetz, 2014/03/27 01:21:43]

ditto (confirmed offline that s/Payload/Element/ is incorrect.)

+  int payload_size = 0;
+
+  if (audio_channels_ >= 0)
+    payload_size += IntElementSize(kWebMIdChannels, audio_channels_);
+  if (audio_sampling_frequency_ >= 0)
+    payload_size += DoubleElementSize(kWebMIdSamplingFrequency);
+
+  return payload_size;
+}
+
 int TracksBuilder::Track::GetPayloadSize() const {
   int size = 0;
 
   size += IntElementSize(kWebMIdTrackNumber, track_num_);
   size += IntElementSize(kWebMIdTrackType, track_type_);
   size += IntElementSize(kWebMIdTrackUID, track_uid_);
 
+  if (default_duration_ >= 0)
+    size += IntElementSize(kWebMIdDefaultDuration, default_duration_);
+
   if (!codec_id_.empty())
     size += StringElementSize(kWebMIdCodecID, codec_id_);
 
   if (!name_.empty())
     size += StringElementSize(kWebMIdName, name_);
 
   if (!language_.empty())
     size += StringElementSize(kWebMIdLanguage, language_);
 
+  if (GetVideoPayloadSize() > 0) {
+    size += MasterElementSize(kWebMIdVideo, GetVideoPayloadSize());
+  }
+
+  if (GetAudioPayloadSize() > 0) {
+    size += MasterElementSize(kWebMIdAudio, GetAudioPayloadSize());
+  }
+
   return size;
 }
 
 void TracksBuilder::Track::Write(uint8** buf, int* buf_size) const {
   WriteMasterElement(buf, buf_size, kWebMIdTrackEntry, GetPayloadSize());
 
   WriteIntElement(buf, buf_size, kWebMIdTrackNumber, track_num_);
   WriteIntElement(buf, buf_size, kWebMIdTrackType, track_type_);
   WriteIntElement(buf, buf_size, kWebMIdTrackUID, track_uid_);
 
+  if (default_duration_ >= 0)

[acolwell GONE FROM CHROMIUM, 2014/03/26 22:25:32]

I wonder if we should have a "strict mode" that asserts if we try to use invalid
values. I can just see someone reusing this code to generate content "for realz"
and accidentally allowing this to be 0. Perhaps a TODO?

[wolenetz, 2014/03/27 01:21:43]

Done (see new TracksBuilder |allow_invalid_values_|).
I also noted I forgot to add a test of parse failure if DefaultDuration is
specified as 0ns. I've added that unit test now.

+    WriteIntElement(buf, buf_size, kWebMIdDefaultDuration, default_duration_);
+
   if (!codec_id_.empty())
     WriteStringElement(buf, buf_size, kWebMIdCodecID, codec_id_);
 
   if (!name_.empty())
     WriteStringElement(buf, buf_size, kWebMIdName, name_);
 
   if (!language_.empty())
     WriteStringElement(buf, buf_size, kWebMIdLanguage, language_);
+
+  if (GetVideoPayloadSize() > 0) {
+    WriteMasterElement(buf, buf_size, kWebMIdVideo, GetVideoPayloadSize());
+
+    if (video_pixel_width_ >= 0)
+      WriteIntElement(buf, buf_size, kWebMIdPixelWidth, video_pixel_width_);
+
+    if (video_pixel_height_ >= 0)
+      WriteIntElement(buf, buf_size, kWebMIdPixelHeight, video_pixel_height_);
+  }
+
+  if (GetAudioPayloadSize() > 0) {
+    WriteMasterElement(buf, buf_size, kWebMIdAudio, GetAudioPayloadSize());
+
+    if (audio_channels_ >= 0)
+      WriteIntElement(buf, buf_size, kWebMIdChannels, audio_channels_);
+
+    if (audio_sampling_frequency_ >= 0) {
+      WriteDoubleElement(buf, buf_size, kWebMIdSamplingFrequency,
+          audio_sampling_frequency_);
+    }
+  }
 }
 
 }  // namespace media