Render inband text tracks in the media pipeline

media/base/pipeline.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/base/pipeline.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/synchronization/condition_variable.h"
 #include "media/base/audio_decoder.h"
 #include "media/base/audio_renderer.h"
 #include "media/base/clock.h"
 #include "media/base/filter_collection.h"
 #include "media/base/media_log.h"
+#include "media/base/text_renderer.h"
 #include "media/base/video_decoder.h"
 #include "media/base/video_decoder_config.h"
 #include "media/base/video_renderer.h"
 
 using base::TimeDelta;
 
 namespace media {
 
 Pipeline::Pipeline(const scoped_refptr<base::MessageLoopProxy>& message_loop,
                    MediaLog* media_log)
     : message_loop_(message_loop),
       media_log_(media_log),
       running_(false),
       did_loading_progress_(false),
       total_bytes_(0),
       natural_size_(0, 0),
       volume_(1.0f),
       playback_rate_(0.0f),
       clock_(new Clock(&default_tick_clock_)),
       waiting_for_clock_update_(false),
       status_(PIPELINE_OK),
       has_audio_(false),
       has_video_(false),
       state_(kCreated),
       audio_ended_(false),
       video_ended_(false),
+      text_ended_(false),
       audio_disabled_(false),
       demuxer_(NULL),
       creation_time_(default_tick_clock_.NowTicks()) {
   media_log_->AddEvent(media_log_->CreatePipelineStateChangedEvent(kCreated));
   media_log_->AddEvent(
       media_log_->CreateEvent(MediaLogEvent::PIPELINE_CREATED));
 }
 
 Pipeline::~Pipeline() {
   DCHECK(thread_checker_.CalledOnValidThread())
@@ skipping 226 matching lines @@
       break;
   }
   NOTREACHED() << "State has no transition: " << state_;
   return state_;
 }
 
 void Pipeline::OnDemuxerError(PipelineStatus error) {
   SetError(error);
 }
 
+void Pipeline::AddTextStream(DemuxerStream* text_stream,
+                             TextKind kind,
+                             const std::string& label,
+                             const std::string& language) {
+  base::AutoLock auto_lock(lock_);

[acolwell GONE FROM CHROMIUM, 2013/10/21 20:10:40]

I don't think you need to lock here since you are just posting a task to the
message_loop_.

[Matthew Heaney (Chromium), 2013/10/23 05:09:01]

Done.

+  message_loop_->PostTask(FROM_HERE, base::Bind(
+    &Pipeline::AddTextStreamTask, base::Unretained(this),
+    text_stream, kind, label, language));
+}
+
+void Pipeline::RemoveTextStream(DemuxerStream* text_stream) {
+  DCHECK(message_loop_->BelongsToCurrentThread());

[acolwell GONE FROM CHROMIUM, 2013/10/21 20:10:40]

I think you'll need to PostTask() here too since tracks can get removed by
removing a SourceBuffer which happens on the renderer thread.

[Matthew Heaney (Chromium), 2013/10/23 05:09:01]

Done.

+  if (text_renderer_)
+    text_renderer_->RemoveTextStream(text_stream);
+}
+
 void Pipeline::SetError(PipelineStatus error) {
   DCHECK(IsRunning());
   DCHECK_NE(PIPELINE_OK, error);
   VLOG(1) << "Media pipeline error: " << error;
 
   message_loop_->PostTask(FROM_HERE, base::Bind(
       &Pipeline::ErrorChangedTask, base::Unretained(this), error));
 
   media_log_->AddEvent(media_log_->CreatePipelineErrorEvent(error));
 }
@@ skipping 224 matching lines @@
 
   // Pause.
   if (audio_renderer_) {
     bound_fns.Push(base::Bind(
         &AudioRenderer::Pause, base::Unretained(audio_renderer_.get())));
   }
   if (video_renderer_) {
     bound_fns.Push(base::Bind(
         &VideoRenderer::Pause, base::Unretained(video_renderer_.get())));
   }
+  if (text_renderer_) {
+    bound_fns.Push(base::Bind(
+        &TextRenderer::Pause, base::Unretained(text_renderer_.get())));
+  }
 
   // Flush.
   if (audio_renderer_) {
     bound_fns.Push(base::Bind(
         &AudioRenderer::Flush, base::Unretained(audio_renderer_.get())));
   }
   if (video_renderer_) {
     bound_fns.Push(base::Bind(
         &VideoRenderer::Flush, base::Unretained(video_renderer_.get())));
   }
+  if (text_renderer_) {
+    bound_fns.Push(base::Bind(
+        &TextRenderer::Flush, base::Unretained(text_renderer_.get())));
+  }
 
   // Seek demuxer.
   bound_fns.Push(base::Bind(
       &Demuxer::Seek, base::Unretained(demuxer_), seek_timestamp));
 
   // Preroll renderers.
   if (audio_renderer_) {
     bound_fns.Push(base::Bind(
         &AudioRenderer::Preroll, base::Unretained(audio_renderer_.get()),
         seek_timestamp));
@@ skipping 19 matching lines @@
   if (audio_renderer_) {
     bound_fns.Push(base::Bind(
         &AudioRenderer::Play, base::Unretained(audio_renderer_.get())));
   }
 
   if (video_renderer_) {
     bound_fns.Push(base::Bind(
         &VideoRenderer::Play, base::Unretained(video_renderer_.get())));
   }
 
+  if (text_renderer_) {
+    bound_fns.Push(base::Bind(
+        &TextRenderer::Play, base::Unretained(text_renderer_.get())));
+  }
+
   pending_callbacks_ = SerialRunner::Run(bound_fns, done_cb);
 }
 
 void Pipeline::DoStop(const PipelineStatusCB& done_cb) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   DCHECK(!pending_callbacks_.get());
   SerialRunner::Queue bound_fns;
 
   if (demuxer_) {
     bound_fns.Push(base::Bind(
         &Demuxer::Stop, base::Unretained(demuxer_)));
   }
 
   if (audio_renderer_) {
     bound_fns.Push(base::Bind(
         &AudioRenderer::Stop, base::Unretained(audio_renderer_.get())));
   }
 
   if (video_renderer_) {
     bound_fns.Push(base::Bind(
         &VideoRenderer::Stop, base::Unretained(video_renderer_.get())));
   }
 
+  if (text_renderer_) {
+    bound_fns.Push(base::Bind(
+        &TextRenderer::Stop, base::Unretained(text_renderer_.get())));
+  }
+
   pending_callbacks_ = SerialRunner::Run(bound_fns, done_cb);
 }
 
 void Pipeline::OnStopCompleted(PipelineStatus status) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   DCHECK_EQ(state_, kStopping);
   {
     base::AutoLock l(lock_);
     running_ = false;
   }
 
   SetState(kStopped);
   pending_callbacks_.reset();
   filter_collection_.reset();
   audio_renderer_.reset();
   video_renderer_.reset();
+  text_renderer_.reset();
   demuxer_ = NULL;
 
   // If we stop during initialization/seeking we want to run |seek_cb_|
   // followed by |stop_cb_| so we don't leave outstanding callbacks around.
   if (!seek_cb_.is_null()) {
     base::ResetAndReturn(&seek_cb_).Run(status_);
     error_cb_.Reset();
   }
   if (!stop_cb_.is_null()) {
     error_cb_.Reset();
@@ skipping 40 matching lines @@
   media_log_->AddEvent(media_log_->CreateEvent(MediaLogEvent::AUDIO_ENDED));
 }
 
 void Pipeline::OnVideoRendererEnded() {
   // Force post to process ended messages after current execution frame.
   message_loop_->PostTask(FROM_HERE, base::Bind(
       &Pipeline::DoVideoRendererEnded, base::Unretained(this)));
   media_log_->AddEvent(media_log_->CreateEvent(MediaLogEvent::VIDEO_ENDED));
 }
 
+void Pipeline::OnTextRendererEnded() {
+  // Force post to process ended messages after current execution frame.
+  message_loop_->PostTask(FROM_HERE, base::Bind(
+      &Pipeline::DoTextRendererEnded, base::Unretained(this)));
+  media_log_->AddEvent(media_log_->CreateEvent(MediaLogEvent::TEXT_ENDED));
+}
+
 // Called from any thread.
 void Pipeline::OnUpdateStatistics(const PipelineStatistics& stats) {
   base::AutoLock auto_lock(lock_);
   statistics_.audio_bytes_decoded += stats.audio_bytes_decoded;
   statistics_.video_bytes_decoded += stats.video_bytes_decoded;
   statistics_.video_frames_decoded += stats.video_frames_decoded;
   statistics_.video_frames_dropped += stats.video_frames_dropped;
 }
 
 void Pipeline::StartTask(scoped_ptr<FilterCollection> filter_collection,
                          const base::Closure& ended_cb,
                          const PipelineStatusCB& error_cb,
                          const PipelineStatusCB& seek_cb,
                          const BufferingStateCB& buffering_state_cb,
                          const base::Closure& duration_change_cb) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   CHECK_EQ(kCreated, state_)
       << "Media pipeline cannot be started more than once";
 
   filter_collection_ = filter_collection.Pass();
   ended_cb_ = ended_cb;
   error_cb_ = error_cb;
   seek_cb_ = seek_cb;
   buffering_state_cb_ = buffering_state_cb;
   duration_change_cb_ = duration_change_cb;
 
+  text_renderer_ = filter_collection_->GetTextRenderer();
+
+  if (text_renderer_) {
+    text_renderer_->Initialize(
+        base::Bind(&Pipeline::OnTextRendererEnded, base::Unretained(this)));
+  }
+
   StateTransitionTask(PIPELINE_OK);
 }
 
 void Pipeline::StopTask(const base::Closure& stop_cb) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   DCHECK(stop_cb_.is_null());
 
   if (state_ == kStopped) {
     stop_cb.Run();
     return;
@@ skipping 69 matching lines @@
     return;
   }
 
   DCHECK(seek_cb_.is_null());
 
   SetState(kSeeking);
   base::TimeDelta seek_timestamp = std::max(time, demuxer_->GetStartTime());
   seek_cb_ = seek_cb;
   audio_ended_ = false;
   video_ended_ = false;
+  text_ended_ = false;
 
   // Kick off seeking!
   {
     base::AutoLock auto_lock(lock_);
     if (clock_->IsPlaying())
       clock_->Pause();
     clock_->SetTime(seek_timestamp, seek_timestamp);
   }
   DoSeek(seek_timestamp, base::Bind(
       &Pipeline::OnStateTransition, base::Unretained(this)));
@@ skipping 23 matching lines @@
 
   if (state_ != kStarted)
     return;
 
   DCHECK(!video_ended_);
   video_ended_ = true;
 
   RunEndedCallbackIfNeeded();
 }
 
+void Pipeline::DoTextRendererEnded() {
+  DCHECK(message_loop_->BelongsToCurrentThread());
+
+  if (state_ != kStarted)
+    return;
+
+  DCHECK(!text_ended_);
+  text_ended_ = true;
+
+  RunEndedCallbackIfNeeded();
+}
+
 void Pipeline::RunEndedCallbackIfNeeded() {
   DCHECK(message_loop_->BelongsToCurrentThread());
 
   if (audio_renderer_ && !audio_ended_ && !audio_disabled_)
     return;
 
   if (video_renderer_ && !video_ended_)
     return;
 
+  if (text_renderer_ && text_renderer_->HasTracks() && !text_ended_)
+    return;
+
   {
     base::AutoLock auto_lock(lock_);
     clock_->EndOfStream();
   }
 
   DCHECK_EQ(status_, PIPELINE_OK);
   ended_cb_.Run();
 }
 
 void Pipeline::AudioDisabledTask() {
   DCHECK(message_loop_->BelongsToCurrentThread());
 
   base::AutoLock auto_lock(lock_);
   has_audio_ = false;
   audio_disabled_ = true;
 
   // Notify our demuxer that we're no longer rendering audio.
   demuxer_->OnAudioRendererDisabled();
 
   // Start clock since there is no more audio to trigger clock updates.
   clock_->SetMaxTime(clock_->Duration());
   StartClockIfWaitingForTimeUpdate_Locked();
 }
 
+void Pipeline::AddTextStreamTask(DemuxerStream* text_stream,
+                                 TextKind kind,
+                                 const std::string& label,
+                                 const std::string& language) {
+  DCHECK(message_loop_->BelongsToCurrentThread());
+  text_renderer_->AddTextStream(text_stream, kind, label, language);
+}
+
 void Pipeline::InitializeDemuxer(const PipelineStatusCB& done_cb) {
   DCHECK(message_loop_->BelongsToCurrentThread());
 
   demuxer_ = filter_collection_->GetDemuxer();
   demuxer_->Initialize(this, done_cb);
 }
 
 void Pipeline::InitializeAudioRenderer(const PipelineStatusCB& done_cb) {
   DCHECK(message_loop_->BelongsToCurrentThread());
 
@@ skipping 51 matching lines @@
 void Pipeline::StartClockIfWaitingForTimeUpdate_Locked() {
   lock_.AssertAcquired();
   if (!waiting_for_clock_update_)
     return;
 
   waiting_for_clock_update_ = false;
   clock_->Play();
 }
 
 }  // namespace media