Media Source dispatches inband text tracks

media/filters/chunk_demuxer.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/filters/chunk_demuxer.h"
 
 #include <algorithm>
 #include <deque>
 #include <limits>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/location.h"
 #include "base/message_loop_proxy.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/stream_parser_buffer.h"
 #include "media/base/video_decoder_config.h"
 #include "media/filters/stream_parser_factory.h"
+#include "media/webm/webm_webvtt_parser.h"
 
 using base::TimeDelta;
 
 namespace media {
 
 // Contains state belonging to a source id.
 class SourceState {
  public:
   explicit SourceState(scoped_ptr<StreamParser> stream_parser);
 
   void Init(const StreamParser::InitCB& init_cb,
             const StreamParser::NewConfigCB& config_cb,
             const StreamParser::NewBuffersCB& audio_cb,
             const StreamParser::NewBuffersCB& video_cb,
+            const StreamParser::NewTextBuffersCB& text_cb,
             const StreamParser::NeedKeyCB& need_key_cb,
+            const AddTextTrackCB& add_text_track_cb,
             const StreamParser::NewMediaSegmentCB& new_segment_cb,
             const LogCB& log_cb);
 
   // Appends new data to the StreamParser.
   // Returns true if the data was successfully appended. Returns false if an
   // error occurred.
   bool Append(const uint8* data, size_t length);
 
   // Aborts the current append sequence and resets the parser.
   void Abort();
@@ skipping 17 matching lines @@
   void OnEndOfMediaSegment();
 
   // Called by the |stream_parser_| when new buffers have been parsed. It
   // applies |timestamp_offset_| to all buffers in |buffers| and then calls
   // |new_buffers_cb| with the modified buffers.
   // Returns true on a successful call. Returns false if an error occured while
   // processing the buffers.
   bool OnBuffers(const StreamParser::NewBuffersCB& new_buffers_cb,
                  const StreamParser::BufferQueue& buffers);
 
+  // Called by the |stream_parser_| when new text buffers have been parsed. It
+  // applies |timestamp_offset_| to all buffers in |buffers| and then calls
+  // |new_buffers_cb| with the modified buffers.
+  // Returns true on a successful call. Returns false if an error occured while
+  // processing the buffers.
+  bool OnTextBuffers(const StreamParser::NewTextBuffersCB& new_buffers_cb,
+                     TextTrack* text_track,
+                     const StreamParser::BufferQueue& buffers);
+
   // Helper function that adds |timestamp_offset_| to each buffer in |buffers|.
   void AdjustBufferTimestamps(const StreamParser::BufferQueue& buffers);
 
   // The offset to apply to media segment timestamps.
   TimeDelta timestamp_offset_;
 
   // Keeps track of whether |timestamp_offset_| can be modified.
   bool can_update_offset_;
 
   // The object used to parse appended data.
   scoped_ptr<StreamParser> stream_parser_;
 
   DISALLOW_COPY_AND_ASSIGN(SourceState);
 };
 
 SourceState::SourceState(scoped_ptr<StreamParser> stream_parser)
     : can_update_offset_(true),
       stream_parser_(stream_parser.release()) {
 }
 
 void SourceState::Init(const StreamParser::InitCB& init_cb,
                        const StreamParser::NewConfigCB& config_cb,
                        const StreamParser::NewBuffersCB& audio_cb,
                        const StreamParser::NewBuffersCB& video_cb,
+                       const StreamParser::NewTextBuffersCB& text_cb,
                        const StreamParser::NeedKeyCB& need_key_cb,
+                       const AddTextTrackCB& add_text_track_cb,
                        const StreamParser::NewMediaSegmentCB& new_segment_cb,
                        const LogCB& log_cb) {
   stream_parser_->Init(init_cb, config_cb,
                        base::Bind(&SourceState::OnBuffers,
                                   base::Unretained(this), audio_cb),
                        base::Bind(&SourceState::OnBuffers,
                                   base::Unretained(this), video_cb),
+                       base::Bind(&SourceState::OnTextBuffers,
+                                  base::Unretained(this), text_cb),
                        need_key_cb,
+                       add_text_track_cb,
                        base::Bind(&SourceState::OnNewMediaSegment,
                                   base::Unretained(this), new_segment_cb),
                        base::Bind(&SourceState::OnEndOfMediaSegment,
                                   base::Unretained(this)),
                        log_cb);
 }
 
 bool SourceState::SetTimestampOffset(TimeDelta timestamp_offset) {
   if (!can_update_offset_)
     return false;
@@ skipping 42 matching lines @@
 bool SourceState::OnBuffers(const StreamParser::NewBuffersCB& new_buffers_cb,
                             const StreamParser::BufferQueue& buffers) {
   if (new_buffers_cb.is_null())
     return false;
 
   AdjustBufferTimestamps(buffers);
 
   return new_buffers_cb.Run(buffers);
 }
 
+bool SourceState::OnTextBuffers(
+    const StreamParser::NewTextBuffersCB& new_buffers_cb,
+    TextTrack* text_track,
+    const StreamParser::BufferQueue& buffers) {
+  if (new_buffers_cb.is_null())
+    return false;
+
+  AdjustBufferTimestamps(buffers);
+
+  return new_buffers_cb.Run(text_track, buffers);
+}
+
 class ChunkDemuxerStream : public DemuxerStream {
  public:
   typedef std::deque<scoped_refptr<StreamParserBuffer> > BufferQueue;
   typedef std::deque<ReadCB> ReadCBQueue;
   typedef std::deque<base::Closure> ClosureQueue;
 
   ChunkDemuxerStream(const AudioDecoderConfig& audio_config,
                      const LogCB& log_cb);
   ChunkDemuxerStream(const VideoDecoderConfig& video_config,
                      const LogCB& log_cb);
@@ skipping 362 matching lines @@
       *buffer = StreamParserBuffer::CreateEOSBuffer();
       return true;
   }
 
   NOTREACHED();
   return false;
 }
 
 ChunkDemuxer::ChunkDemuxer(const base::Closure& open_cb,
                            const NeedKeyCB& need_key_cb,
+                           const AddTextTrackCB& add_text_track_cb,
                            const LogCB& log_cb)
     : state_(WAITING_FOR_INIT),
       host_(NULL),
       open_cb_(open_cb),
       need_key_cb_(need_key_cb),
+      add_text_track_cb_(add_text_track_cb),
       log_cb_(log_cb),
       duration_(kNoTimestamp()),
       user_specified_duration_(-1) {
   DCHECK(!open_cb_.is_null());
   DCHECK(!need_key_cb_.is_null());
 }
 
 void ChunkDemuxer::Initialize(DemuxerHost* host, const PipelineStatusCB& cb) {
   DVLOG(1) << "Init()";
 
@@ skipping 140 matching lines @@
                           base::Unretained(this));
   }
 
   scoped_ptr<SourceState> source_state(new SourceState(stream_parser.Pass()));
   source_state->Init(
       base::Bind(&ChunkDemuxer::OnSourceInitDone, base::Unretained(this)),
       base::Bind(&ChunkDemuxer::OnNewConfigs, base::Unretained(this),
                  has_audio, has_video),
       audio_cb,
       video_cb,
+      base::Bind(&ChunkDemuxer::OnTextBuffers, base::Unretained(this)),
       base::Bind(&ChunkDemuxer::OnNeedKey, base::Unretained(this)),
+      add_text_track_cb_,
       base::Bind(&ChunkDemuxer::OnNewMediaSegment, base::Unretained(this), id),
       log_cb_);
 
   source_state_map_[id] = source_state.release();
   return kOk;
 }
 
 void ChunkDemuxer::RemoveId(const std::string& id) {
   base::AutoLock auto_lock(lock_);
   CHECK(IsValidId(id));
@@ skipping 455 matching lines @@
     return false;
 
   CHECK(IsValidId(source_id_video_));
   if (!video_->Append(buffers))
     return false;
 
   IncreaseDurationIfNecessary(buffers, video_.get());
   return true;
 }
 
+bool ChunkDemuxer::OnTextBuffers(
+  TextTrack* text_track,
+  const StreamParser::BufferQueue& buffers) {
+  lock_.AssertAcquired();
+  DCHECK_NE(state_, SHUTDOWN);
+
+  // TODO(matthewjheaney): IncreaseDurationIfNecessary
+
+  for (StreamParser::BufferQueue::const_iterator itr = buffers.begin();
+       itr != buffers.end(); ++itr) {
+    const StreamParserBuffer* const buffer = itr->get();
+    const base::TimeDelta start = buffer->GetTimestamp();
+    const base::TimeDelta end = start + buffer->GetDuration();
+
+    std::string id, settings, content;
+
+    WebMWebVTTParser::Parse(buffer->GetData(),
+                            buffer->GetDataSize(),
+                            &id, &settings, &content);
+
+    text_track->addWebVTTCue(start, end, id, content, settings);
+  }
+
+  return true;
+}
+
 // TODO(acolwell): Remove bool from StreamParser::NeedKeyCB so that
 // this method can be removed and need_key_cb_ can be passed directly
 // to the parser.
 bool ChunkDemuxer::OnNeedKey(const std::string& type,
                              scoped_ptr<uint8[]> init_data,
                              int init_data_size) {
   lock_.AssertAcquired();
   need_key_cb_.Run(type, init_data.Pass(), init_data_size);
   return true;
 }
@@ skipping 51 matching lines @@
 
 Ranges<TimeDelta> ChunkDemuxer::GetBufferedRanges() const {
   if (audio_ && !video_)
     return audio_->GetBufferedRanges(duration_);
   else if (!audio_ && video_)
     return video_->GetBufferedRanges(duration_);
   return ComputeIntersection();
 }
 
 }  // namespace media