Render inband text tracks in the media pipeline

media/webm/webm_cluster_parser.cc

 // Copyright (c) 2012 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/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/webm/webm_constants.h"
 #include "media/webm/webm_crypto_helpers.h"
+#include "media/webm/webm_webvtt_parser.h"
 
 namespace media {
 
 WebMClusterParser::TextTrackIterator::TextTrackIterator(
     const TextTrackMap& text_track_map) :
     iterator_(text_track_map.begin()),
     iterator_end_(text_track_map.end()) {
 }
 
 WebMClusterParser::TextTrackIterator::TextTrackIterator(
@@ skipping 275 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;
   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_;
   } 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;
   } 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_);
 
   // 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);
 
-  scoped_refptr<StreamParserBuffer> buffer =
-      StreamParserBuffer::CopyFrom(data, size, additional, additional_size,
-                                   is_keyframe);
+  scoped_refptr<StreamParserBuffer> buffer;
+  if (!is_text) {
+    buffer = StreamParserBuffer::CopyFrom(data, size,
+                                          additional, additional_size,
+                                          is_keyframe);
+  } else {
+    std::string id, settings, content;
+    WebMWebVTTParser::Parse(data, size,
+                            &id, &settings, &content);
+
+    // The DecoderBuffer only supports a single side data item. In the case of
+    // a WebVTT cue, we can have potentially two side data items. In order to
+    // avoid disrupting DecoderBuffer any more than we need to, we copy both
+    // side data items onto a single one, and terminate each with a NUL marker.
+    std::vector<char> side_data;
+    side_data.reserve(id.length() + 1 + settings.length() + 1);
+    side_data.insert(side_data.end(), id.begin(), id.end());
+    side_data.push_back(0);
+    side_data.insert(side_data.end(), settings.begin(), settings.end());
+    side_data.push_back(0);
+
+    buffer = StreamParserBuffer::CopyFrom(
+        reinterpret_cast<const uint8*>(content.data()),
+        content.length(),
+        reinterpret_cast<const uint8*>(side_data.data()),
+        side_data.size(),
+        is_keyframe);
+  }
 
   // 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
   if (!encryption_key_id.empty()) {
     scoped_ptr<DecryptConfig> config(WebMCreateDecryptConfig(
         data, size,
         reinterpret_cast<const uint8*>(encryption_key_id.data()),
         encryption_key_id.size()));
     if (!config)
@@ skipping 76 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