MSE: Add StreamParser buffer remuxing utility and tests

media/formats/webm/webm_cluster_parser.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/webm_cluster_parser.h"
 
 #include <vector>
 
 #include "base/logging.h"
 #include "base/sys_byteorder.h"
 #include "media/base/buffers.h"
 #include "media/base/decrypt_config.h"
 #include "media/filters/webvtt_util.h"
 #include "media/formats/webm/webm_constants.h"
 #include "media/formats/webm/webm_crypto_helpers.h"
 #include "media/formats/webm/webm_webvtt_parser.h"
 
 namespace media {
 
 WebMClusterParser::WebMClusterParser(
     int64 timecode_scale, int audio_track_num, int video_track_num,

[xhwang, 2014/02/07 00:09:56]

Shall we s/track_num/track_id/ in this file?

[wolenetz, 2014/02/07 00:29:18]

Longer term, a track configuration or buffer's track_id() will not necessarily
be the bytestream's track number. I would rather not reinforce confusion :) See
http://crbug.com/341581.

I've now added a comment for WebM's CopyFrom()'s referencing that bug like I've
done in the other MSE stream parsers.

Also, I've filed http://crbug.com/341601 to track smelly WebM parser track
number datatype/range discrepancies. Those again are bytestream, not necessarily
track config or buffer track_id() in long run.

     const WebMTracksParser::TextTracks& text_tracks,
     const std::set<int64>& ignored_tracks,
     const std::string& audio_encryption_key_id,
     const std::string& video_encryption_key_id,
     const LogCB& log_cb)
     : timecode_multiplier_(timecode_scale / 1000.0),
       ignored_tracks_(ignored_tracks),
       audio_encryption_key_id_(audio_encryption_key_id),
       video_encryption_key_id_(video_encryption_key_id),
       parser_(kWebMIdCluster, this),
@@ skipping 253 matching lines @@
     return false;
   }
 
   if (last_block_timecode_ != -1 && timecode < last_block_timecode_) {
     MEDIA_LOG(log_cb_)
         << "Got a block with a timecode before the previous block.";
     return false;
   }
 
   Track* track = NULL;
-  bool is_text = false;
+  StreamParserBuffer::Type buffer_type = DemuxerStream::AUDIO;
   std::string encryption_key_id;
   if (track_num == audio_.track_num()) {
     track = &audio_;
     encryption_key_id = audio_encryption_key_id_;
   } else if (track_num == video_.track_num()) {
     track = &video_;
     encryption_key_id = video_encryption_key_id_;
+    buffer_type = DemuxerStream::VIDEO;
   } else if (ignored_tracks_.find(track_num) != ignored_tracks_.end()) {
     return true;
   } else if (Track* const text_track = FindTextTrack(track_num)) {
     if (is_simple_block)  // BlockGroup is required for WebVTT cues
       return false;
     if (block_duration < 0)  // not specified
       return false;
     track = text_track;
-    is_text = true;
+    buffer_type = DemuxerStream::TEXT;
   } else {
     MEDIA_LOG(log_cb_) << "Unexpected track number " << track_num;
     return false;
   }
 
   last_block_timecode_ = timecode;
 
   base::TimeDelta timestamp = base::TimeDelta::FromMicroseconds(
       (cluster_timecode_ + timecode) * timecode_multiplier_);
 
   scoped_refptr<StreamParserBuffer> buffer;
-  if (!is_text) {
+  if (buffer_type != DemuxerStream::TEXT) {
     // The first bit of the flags is set when a SimpleBlock contains only
     // keyframes. If this is a Block, then inspection of the payload is
     // necessary to determine whether it contains a keyframe or not.
     // http://www.matroska.org/technical/specs/index.html
     bool is_keyframe =
         is_simple_block ? (flags & 0x80) != 0 : track->IsKeyframe(data, size);
 
     // Every encrypted Block has a signal byte and IV prepended to it. Current
     // encrypted WebM request for comments specification is here
     // http://wiki.webmproject.org/encryption/webm-encryption-rfc
     scoped_ptr<DecryptConfig> decrypt_config;
     int data_offset = 0;
     if (!encryption_key_id.empty() &&
         !WebMCreateDecryptConfig(
              data, size,
              reinterpret_cast<const uint8*>(encryption_key_id.data()),
              encryption_key_id.size(),
              &decrypt_config, &data_offset)) {
       return false;
     }
 
     buffer = StreamParserBuffer::CopyFrom(
         data + data_offset, size - data_offset,
         additional, additional_size,
-        is_keyframe);
+        is_keyframe, buffer_type, track_num);
 
     if (decrypt_config)
       buffer->set_decrypt_config(decrypt_config.Pass());
   } else {
     std::string id, settings, content;
     WebMWebVTTParser::Parse(data, size, &id, &settings, &content);
 
     std::vector<uint8> side_data;
     MakeSideData(id.begin(), id.end(),
                  settings.begin(), settings.end(),
                  &side_data);
 
     buffer = StreamParserBuffer::CopyFrom(
         reinterpret_cast<const uint8*>(content.data()),
         content.length(),
         &side_data[0],
         side_data.size(),
-        true);
+        true, buffer_type, track_num);
   }
 
   buffer->set_timestamp(timestamp);
   if (cluster_start_time_ == kNoTimestamp())
     cluster_start_time_ = timestamp;
 
   if (block_duration >= 0) {
     buffer->set_duration(base::TimeDelta::FromMicroseconds(
         block_duration * timecode_multiplier_));
   }
@@ skipping 65 matching lines @@
 WebMClusterParser::FindTextTrack(int track_num) {
   const TextTrackMap::iterator it = text_track_map_.find(track_num);
 
   if (it == text_track_map_.end())
     return NULL;
 
   return &it->second;
 }
 
 }  // namespace media