Render inband text tracks in the media pipeline

media/webm/webm_stream_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_stream_parser.h"
 
 #include <string>
 
 #include "base/callback.h"
 #include "base/logging.h"
-#include "base/stl_util.h"
 #include "media/webm/webm_cluster_parser.h"
 #include "media/webm/webm_constants.h"
 #include "media/webm/webm_content_encodings.h"
 #include "media/webm/webm_crypto_helpers.h"
 #include "media/webm/webm_info_parser.h"
 #include "media/webm/webm_tracks_parser.h"
 
 namespace media {
 
 WebMStreamParser::WebMStreamParser()
     : state_(kWaitingForInit),
       waiting_for_buffers_(false) {
 }
 
 WebMStreamParser::~WebMStreamParser() {
-  STLDeleteValues(&text_track_map_);
 }
 
 void WebMStreamParser::Init(const InitCB& init_cb,
                             const NewConfigCB& config_cb,
                             const NewBuffersCB& new_buffers_cb,
                             const NewTextBuffersCB& text_cb,
                             const NeedKeyCB& need_key_cb,
-                            const AddTextTrackCB& add_text_track_cb,
                             const NewMediaSegmentCB& new_segment_cb,
                             const base::Closure& end_of_segment_cb,
                             const LogCB& log_cb) {
   DCHECK_EQ(state_, kWaitingForInit);
   DCHECK(init_cb_.is_null());
   DCHECK(!init_cb.is_null());
   DCHECK(!config_cb.is_null());
   DCHECK(!new_buffers_cb.is_null());
-  DCHECK(!text_cb.is_null());
   DCHECK(!need_key_cb.is_null());
   DCHECK(!new_segment_cb.is_null());
   DCHECK(!end_of_segment_cb.is_null());
 
   ChangeState(kParsingHeaders);
   init_cb_ = init_cb;
   config_cb_ = config_cb;
   new_buffers_cb_ = new_buffers_cb;
   text_cb_ = text_cb;
   need_key_cb_ = need_key_cb;
-  add_text_track_cb_ = add_text_track_cb;
   new_segment_cb_ = new_segment_cb;
   end_of_segment_cb_ = end_of_segment_cb;
   log_cb_ = log_cb;
 }
 
 void WebMStreamParser::Flush() {
   DCHECK_NE(state_, kWaitingForInit);
 
   byte_queue_.Reset();
 
@@ skipping 102 matching lines @@
   WebMInfoParser info_parser;
   result = info_parser.Parse(cur, cur_size);
 
   if (result <= 0)
     return result;
 
   cur += result;
   cur_size -= result;
   bytes_parsed += result;
 
-  WebMTracksParser tracks_parser(log_cb_, add_text_track_cb_.is_null());
+  WebMTracksParser tracks_parser(log_cb_, text_cb_.is_null());
   result = tracks_parser.Parse(cur, cur_size);
 
   if (result <= 0)
     return result;
 
   bytes_parsed += result;
 
   base::TimeDelta duration = kInfiniteDuration();
 
   if (info_parser.duration() > 0) {
     double mult = info_parser.timecode_scale() / 1000.0;
     int64 duration_in_us = info_parser.duration() * mult;
     duration = base::TimeDelta::FromMicroseconds(duration_in_us);
   }
 
   const AudioDecoderConfig& audio_config = tracks_parser.audio_decoder_config();
   if (audio_config.is_encrypted())
     FireNeedKey(tracks_parser.audio_encryption_key_id());
 
   const VideoDecoderConfig& video_config = tracks_parser.video_decoder_config();
   if (video_config.is_encrypted())
     FireNeedKey(tracks_parser.video_encryption_key_id());
 
-  if (!config_cb_.Run(audio_config, video_config)) {
-    DVLOG(1) << "New config data isn't allowed.";
-    return -1;
-  }
+  TextTrackConfigMap text_track_config_map;
 
   typedef WebMTracksParser::TextTracks TextTracks;
   const TextTracks& text_tracks = tracks_parser.text_tracks();
 
   for (TextTracks::const_iterator itr = text_tracks.begin();
        itr != text_tracks.end(); ++itr) {
     const WebMTracksParser::TextTrackInfo& text_track_info = itr->second;
 
     // TODO(matthewjheaney): verify that WebVTT uses ISO 639-2 for lang
-    scoped_ptr<TextTrack> text_track =
-        add_text_track_cb_.Run(text_track_info.kind,
-                               text_track_info.name,
-                               text_track_info.language);
 
-    // Assume ownership of pointer, and cache the text track object, for use
-    // later when we have text track buffers. (The text track objects are
-    // deallocated in the dtor for this class.)
+    text_track_config_map.insert(
+        std::make_pair(itr->first,
+                       TextTrackConfig(text_track_info.kind,

[acolwell GONE FROM CHROMIUM, 2013/10/29 21:14:19]

It looks like TextTrackInfo is equivalent to TextTrackConfig. If you convert the
code in WebMTracksParser you can eliminate this loop and just pass
tracks_parser.text_tracks() to config_cb_.Run().

[Matthew Heaney (Chromium), 2013/11/05 04:52:40]

Done.

+                                       text_track_info.name,
+                                       text_track_info.language)));
+  }
 
-    if (text_track)
-      text_track_map_.insert(std::make_pair(itr->first, text_track.release()));
+  if (!config_cb_.Run(audio_config, video_config, text_track_config_map)) {
+    DVLOG(1) << "New config data isn't allowed.";
+    return -1;
   }
 
   cluster_parser_.reset(new WebMClusterParser(
       info_parser.timecode_scale(),
       tracks_parser.audio_track_num(),
       tracks_parser.video_track_num(),
       text_tracks,
       tracks_parser.ignored_tracks(),
       tracks_parser.audio_encryption_key_id(),
       tracks_parser.video_encryption_key_id(),
@@ skipping 58 matching lines @@
     return -1;
   }
 
   WebMClusterParser::TextTrackIterator text_track_iter =
     cluster_parser_->CreateTextTrackIterator();
 
   int text_track_num;
   const BufferQueue* text_buffers;
 
   while (text_track_iter(&text_track_num, &text_buffers)) {
-    TextTrackMap::iterator find_result = text_track_map_.find(text_track_num);
-
-    if (find_result == text_track_map_.end())
-      continue;
-
-    TextTrack* const text_track = find_result->second;
-
-    if (!text_buffers->empty() && !text_cb_.Run(text_track, *text_buffers))
+    if (!text_buffers->empty() && !text_cb_.Run(text_track_num, *text_buffers))
       return -1;
   }
 
   if (cluster_ended)
     end_of_segment_cb_.Run();
 
   return bytes_parsed;
 }
 
 void WebMStreamParser::FireNeedKey(const std::string& key_id) {
   std::vector<uint8> key_id_vector(key_id.begin(), key_id.end());
   need_key_cb_.Run(kWebMEncryptInitDataType, key_id_vector);
 }
 
 }  // namespace media