Render inband text tracks in the media pipeline

media/base/text_renderer.cc

+// Copyright (c) 2013 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/text_renderer.h"
+
+#include "base/bind.h"
+#include "base/callback_helpers.h"
+#include "base/logging.h"
+#include "base/message_loop/message_loop_proxy.h"
+#include "base/stl_util.h"
+#include "media/base/bind_to_loop.h"
+#include "media/base/demuxer.h"
+#include "media/base/demuxer_stream.h"
+#include "media/base/text_cue.h"
+#include "media/base/text_decoder.h"
+
+namespace media {
+
+TextRenderer::TextRenderer(
+    const scoped_refptr<base::MessageLoopProxy>& message_loop,
+    scoped_ptr<TextDecoder> decoder,
+    const AddTextTrackCB2& add_text_track_cb)
+    : message_loop_(message_loop),
+      weak_factory_(this),
+      decoder_(decoder.Pass()),
+      add_text_track_cb_(add_text_track_cb),
+      state_(kUninitialized),
+      pending_read_count_(0),
+      pending_eos_count_(0) {
+}
+
+TextRenderer::~TextRenderer() {
+  DCHECK(state_ == kUninitialized || state_ == kStopped);
+  DCHECK_EQ(pending_read_count_, 0);
+
+  STLDeleteValues(&text_track_map_);
+}
+
+void TextRenderer::Initialize(const base::Closure& ended_cb) {
+  DCHECK(message_loop_->BelongsToCurrentThread());
+  DCHECK(!ended_cb.is_null());
+  DCHECK_EQ(kUninitialized, state_);
+  DCHECK(read_state_.empty());
+  DCHECK_EQ(pending_read_count_, 0);
+  DCHECK_EQ(pending_eos_count_, 0);
+  DCHECK(ended_cb_.is_null());
+
+  weak_this_ = weak_factory_.GetWeakPtr();
+  ended_cb_ = ended_cb;
+  state_ = kPaused;
+  decoder_->Initialize();
+}
+
+void TextRenderer::Play(const base::Closure& callback) {
+  DCHECK(message_loop_->BelongsToCurrentThread());
+  DCHECK(state_ == kPaused);
+
+  state_ = kPlaying;
+  callback.Run();
+
+  for (ReadStateMap::iterator itr = read_state_.begin();
+       itr != read_state_.end(); ++itr) {
+    ReadStateMap::value_type& val = *itr;
+
+    if (val.second == kReadPending) {

[acolwell GONE FROM CHROMIUM, 2013/10/08 15:45:24]

nit: Just use itr-> here and below. Val isn't really providing any extra clarity
here.

[Matthew Heaney (Chromium), 2013/10/13 05:30:17]

Done.

+      DCHECK_GT(pending_read_count_, 0);
+      continue;
+    }
+
+    val.second = kReadPending;
+    ++pending_read_count_;
+    decoder_->Read(val.first,
+                   base::Bind(&TextRenderer::CueReady, weak_this_));
+  }
+}
+
+void TextRenderer::Pause(const base::Closure& callback) {
+  DCHECK(message_loop_->BelongsToCurrentThread());
+  DCHECK(state_ == kPlaying || state_ == kEnded);
+  pause_cb_ = callback;
+
+  if (pending_read_count_ <= 0) {

[acolwell GONE FROM CHROMIUM, 2013/10/08 15:45:24]

nit: Add DCHECK_GE(pending_read_count_, 0) above and just s/<=/==/ here since a
negative count is a bug.

[Matthew Heaney (Chromium), 2013/10/13 05:30:17]

Done.

+    state_ = kPaused;
+    base::ResetAndReturn(&pause_cb_).Run();
+    return;
+  }
+
+  state_ = kPausePending;

[acolwell GONE FROM CHROMIUM, 2013/10/08 15:45:24]

nit: Consider using a ChangeState() helper method for all state transitions like
ChunkDemuxer does. It makes debugging state transitions a lot easier.

[Matthew Heaney (Chromium), 2013/10/13 05:30:17]

Ack.

+}
+
+void TextRenderer::Flush(const base::Closure& callback) {
+  DCHECK(message_loop_->BelongsToCurrentThread());
+  DCHECK_EQ(pending_read_count_, 0);
+  DCHECK(state_ == kPaused || state_ == kEnded);
+
+  pending_eos_count_ = read_state_.size();
+
+  callback.Run();

[acolwell GONE FROM CHROMIUM, 2013/10/08 15:45:24]

You likely need to wait for any pending reads to complete before running the
callback. Otherwise you won't know if the data returned is pre or post Flush().

[Matthew Heaney (Chromium), 2013/10/13 05:30:17]

No reads are pending during the kPaused or kEnded states.  (Or is it the case
that the flush request can arrive when state_ ==  kPausePending?)

+}
+
+void TextRenderer::Stop(const base::Closure& cb) {
+  DCHECK(message_loop_->BelongsToCurrentThread());
+  DCHECK(!cb.is_null());
+  DCHECK(state_ == kPlaying || state_ == kPaused || state_ == kEnded);
+
+  stop_cb_ = cb;
+
+  if (pending_read_count_ <= 0) {

[acolwell GONE FROM CHROMIUM, 2013/10/08 15:45:24]

nit: s/<=/==/ since a negative value is a sign of a bug.

[Matthew Heaney (Chromium), 2013/10/13 05:30:17]

Done.

+    state_ = kStopped;
+    base::ResetAndReturn(&stop_cb_).Run();
+    return;
+  }
+
+  state_ = kStopPending;
+}
+
+void TextRenderer::AddTextStream(DemuxerStream* text_stream,
+                                 TextKind kind,
+                                 const std::string& label,
+                                 const std::string& language) {
+  DCHECK(message_loop_->BelongsToCurrentThread());
+  DCHECK(state_ != kUninitialized && state_ != kStopped);
+
+  media::AddTextTrackDoneCB done_cb =
+      media::BindToLoop(message_loop_,
+                        base::Bind(&TextRenderer::OnAddTextTrackDone,
+                                   weak_this_));
+
+  // TODO(matthewjheaney): curry-away the text_stream arg, if possible.
+  add_text_track_cb_.Run(text_stream, kind, label, language, done_cb);

[acolwell GONE FROM CHROMIUM, 2013/10/08 15:45:24]

Yes. You should include text_stream in the Bind above.

[Matthew Heaney (Chromium), 2013/10/13 05:30:17]

Done.

+}
+
+void TextRenderer::OnAddTextTrackDone(DemuxerStream* text_stream,
+                                      scoped_ptr<TextTrack> text_track) {
+  DCHECK(message_loop_->BelongsToCurrentThread());
+  DCHECK(state_ != kUninitialized && state_ != kStopped);

[acolwell GONE FROM CHROMIUM, 2013/10/08 15:45:24]

nit: Add << "state_ " << state so that it is easy to see what state we are
actually in if this fails. Ditto for similar DCHECKs elsewhere or use multiple
DCHECK_NE(state_, ...) instead.

[Matthew Heaney (Chromium), 2013/10/13 05:30:17]

Done.

+
+  text_track_map_[text_stream] = text_track.release();
+
+  ++pending_eos_count_;
+
+  if (state_ != kPlaying) {
+    read_state_[text_stream] = kReadIdle;
+  } else {
+    read_state_[text_stream] = kReadPending;
+    ++pending_read_count_;
+
+    decoder_->Read(text_stream,
+                   base::Bind(&TextRenderer::CueReady, weak_this_));
+  }
+}
+
+bool TextRenderer::HasTracks() const {
+  DCHECK(message_loop_->BelongsToCurrentThread());
+  return (!text_track_map_.empty());

[acolwell GONE FROM CHROMIUM, 2013/10/08 15:45:24]

nit: remove unnecessary ()

[Matthew Heaney (Chromium), 2013/10/13 05:30:17]

Done.

+}
+
+void TextRenderer::CueReady(
+    DemuxerStream* text_stream,
+    const scoped_refptr<TextCue>& text_cue) {
+  DCHECK(message_loop_->BelongsToCurrentThread());
+  DCHECK_NE(state_, kUninitialized);
+  DCHECK_NE(state_, kStopped);
+  DCHECK_GT(pending_read_count_, 0);
+  DCHECK_GT(pending_eos_count_, 0);
+  DCHECK_EQ(read_state_[text_stream], kReadPending);
+
+  --pending_read_count_;
+  read_state_[text_stream] = kReadIdle;
+
+  switch (state_) {
+    case kPlaying:
+      if (text_cue)
+        break;
+
+      // A NULL buffer means that we have reached EOS (or there's an error).
+
+      --pending_eos_count_;
+
+      if (pending_read_count_ > 0)

[acolwell GONE FROM CHROMIUM, 2013/10/08 15:45:24]

Why do you need to worry about the pending_read_count_ here? You shouldn't have
any pending reads if pending_eos_count_ == 0 right? It seems
s/pending_read_count_/pending_eos_count_/ would be clearer and then just drop
the <= conditional below.

[Matthew Heaney (Chromium), 2013/10/13 05:30:17]

Done.

+        return;
+
+      if (pending_eos_count_ <= 0) {
+        state_ = kEnded;
+        ended_cb_.Run();
+      }
+
+      return;
+
+    case kPausePending:
+      if (pending_read_count_ <= 0) {

[acolwell GONE FROM CHROMIUM, 2013/10/08 15:45:24]

Do we really want to drop cues received while trying to pause? It seems like
pause/play cycles could cause cues to go missing.

[Matthew Heaney (Chromium), 2013/10/13 05:30:17]

Done.

+        state_ = kPaused;
+        pause_cb_.Run();
+      }
+
+      return;
+
+    case kStopPending:
+      if (pending_read_count_ <= 0) {
+        state_ = kStopped;
+        stop_cb_.Run();
+      }
+
+      return;
+
+    case kPaused:
+    case kStopped:
+    case kUninitialized:
+    default:

[acolwell GONE FROM CHROMIUM, 2013/10/08 15:45:24]

nit: remove default so the compiler will warn us of unhandled states.

[Matthew Heaney (Chromium), 2013/10/13 05:30:17]

Done.

+      NOTREACHED();
+      return;
+  }
+
+  if (!text_cue->text().empty()) {

[acolwell GONE FROM CHROMIUM, 2013/10/08 15:45:24]

Why is a cue w/ empty text being skipped? Either these should not be generated
by the demuxers or they should be allowed through and processed like all the
other cues. I believe WebVTT allows cues w/ empty text so the later is probably
appropriate.

[Matthew Heaney (Chromium), 2013/10/13 05:30:17]

Done.

+    TextTrackMap::iterator it = text_track_map_.find(text_stream);
+    DCHECK(it != text_track_map_.end());
+
+    media::TextTrack* text_track = it->second;
+    DCHECK_NE(text_track, static_cast<media::TextTrack*>(NULL));
+
+    base::TimeDelta start = text_cue->timestamp();
+    base::TimeDelta end = start + text_cue->duration();
+
+    text_track->addWebVTTCue(start, end,
+                             text_cue->id(),
+                             text_cue->text(),
+                             text_cue->settings());
+  }
+
+  read_state_[text_stream] = kReadPending;
+  ++pending_read_count_;
+  decoder_->Read(text_stream,
+            base::Bind(&TextRenderer::CueReady, weak_this_));
+}
+
+}  // namespace media