media/base/text_renderer.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "media/base/text_renderer.h"
   6
   7 #include "base/bind.h"
   8 #include "base/callback_helpers.h"
   9 #include "base/logging.h"
  10 #include "base/single_thread_task_runner.h"
  11 #include "base/stl_util.h"
  12 #include "media/base/bind_to_current_loop.h"
  13 #include "media/base/decoder_buffer.h"
  14 #include "media/base/demuxer.h"
  15 #include "media/base/demuxer_stream.h"
  16 #include "media/base/text_cue.h"
  17
  18 namespace media {
  19
  20 TextRenderer::TextRenderer(
  21     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
  22     const AddTextTrackCB& add_text_track_cb)
  23     : task_runner_(task_runner),
  24       add_text_track_cb_(add_text_track_cb),
  25       state_(kUninitialized),
  26       pending_read_count_(0),
  27       weak_factory_(this) {}
  28
  29 TextRenderer::~TextRenderer() {
  30   DCHECK(task_runner_->BelongsToCurrentThread());
  31   STLDeleteValues(&text_track_state_map_);
  32   if (!pause_cb_.is_null())
  33     base::ResetAndReturn(&pause_cb_).Run();
  34 }
  35
  36 void TextRenderer::Initialize(const base::Closure& ended_cb) {
  37   DCHECK(task_runner_->BelongsToCurrentThread());
  38   DCHECK(!ended_cb.is_null());
  39   DCHECK_EQ(kUninitialized, state_)  << "state_ " << state_;
  40   DCHECK(text_track_state_map_.empty());
  41   DCHECK_EQ(pending_read_count_, 0);
  42   DCHECK(pending_eos_set_.empty());
  43   DCHECK(ended_cb_.is_null());
  44
  45   ended_cb_ = ended_cb;
  46   state_ = kPaused;
  47 }
  48
  49 void TextRenderer::StartPlaying() {
  50   DCHECK(task_runner_->BelongsToCurrentThread());
  51   DCHECK_EQ(state_, kPaused) << "state_ " << state_;
  52
  53   for (TextTrackStateMap::iterator itr = text_track_state_map_.begin();
  54        itr != text_track_state_map_.end(); ++itr) {
  55     TextTrackState* state = itr->second;
  56     if (state->read_state == TextTrackState::kReadPending) {
  57       DCHECK_GT(pending_read_count_, 0);
  58       continue;
  59     }
  60
  61     Read(state, itr->first);
  62   }
  63
  64   state_ = kPlaying;
  65 }
  66
  67 void TextRenderer::Pause(const base::Closure& callback) {
  68   DCHECK(task_runner_->BelongsToCurrentThread());
  69   DCHECK(state_ == kPlaying || state_ == kEnded) << "state_ " << state_;
  70   DCHECK_GE(pending_read_count_, 0);
  71
  72   if (pending_read_count_ == 0) {
  73     state_ = kPaused;
  74     task_runner_->PostTask(FROM_HERE, callback);
  75     return;
  76   }
  77
  78   pause_cb_ = callback;
  79   state_ = kPausePending;
  80 }
  81
  82 void TextRenderer::Flush(const base::Closure& callback) {
  83   DCHECK(task_runner_->BelongsToCurrentThread());
  84   DCHECK_EQ(pending_read_count_, 0);
  85   DCHECK(state_ == kPaused) << "state_ " << state_;
  86
  87   for (TextTrackStateMap::iterator itr = text_track_state_map_.begin();
  88        itr != text_track_state_map_.end(); ++itr) {
  89     pending_eos_set_.insert(itr->first);
  90     itr->second->text_ranges_.Reset();
  91   }
  92   DCHECK_EQ(pending_eos_set_.size(), text_track_state_map_.size());
  93   task_runner_->PostTask(FROM_HERE, callback);
  94 }
  95
  96 void TextRenderer::AddTextStream(DemuxerStream* text_stream,
  97                                  const TextTrackConfig& config) {
  98   DCHECK(task_runner_->BelongsToCurrentThread());
  99   DCHECK(state_ != kUninitialized) << "state_ " << state_;
 100   DCHECK(text_track_state_map_.find(text_stream) ==
 101          text_track_state_map_.end());
 102   DCHECK(pending_eos_set_.find(text_stream) ==
 103          pending_eos_set_.end());
 104
 105   AddTextTrackDoneCB done_cb =
 106       BindToCurrentLoop(base::Bind(&TextRenderer::OnAddTextTrackDone,
 107                                    weak_factory_.GetWeakPtr(),
 108                                    text_stream));
 109
 110   add_text_track_cb_.Run(config, done_cb);
 111 }
 112
 113 void TextRenderer::RemoveTextStream(DemuxerStream* text_stream) {
 114   DCHECK(task_runner_->BelongsToCurrentThread());
 115
 116   TextTrackStateMap::iterator itr = text_track_state_map_.find(text_stream);
 117   DCHECK(itr != text_track_state_map_.end());
 118
 119   TextTrackState* state = itr->second;
 120   DCHECK_EQ(state->read_state, TextTrackState::kReadIdle);
 121   delete state;
 122   text_track_state_map_.erase(itr);
 123
 124   pending_eos_set_.erase(text_stream);
 125 }
 126
 127 bool TextRenderer::HasTracks() const {
 128   DCHECK(task_runner_->BelongsToCurrentThread());
 129   return !text_track_state_map_.empty();
 130 }
 131
 132 void TextRenderer::BufferReady(
 133     DemuxerStream* stream,
 134     DemuxerStream::Status status,
 135     const scoped_refptr<DecoderBuffer>& input) {
 136   DCHECK(task_runner_->BelongsToCurrentThread());
 137   DCHECK_NE(status, DemuxerStream::kConfigChanged);
 138
 139   if (status == DemuxerStream::kAborted) {
 140     DCHECK(!input.get());
 141     DCHECK_GT(pending_read_count_, 0);
 142     DCHECK(pending_eos_set_.find(stream) != pending_eos_set_.end());
 143
 144     TextTrackStateMap::iterator itr = text_track_state_map_.find(stream);
 145     DCHECK(itr != text_track_state_map_.end());
 146
 147     TextTrackState* state = itr->second;
 148     DCHECK_EQ(state->read_state, TextTrackState::kReadPending);
 149
 150     --pending_read_count_;
 151     state->read_state = TextTrackState::kReadIdle;
 152
 153     switch (state_) {
 154       case kPlaying:
 155         return;
 156
 157       case kPausePending:
 158         if (pending_read_count_ == 0) {
 159           state_ = kPaused;
 160           base::ResetAndReturn(&pause_cb_).Run();
 161         }
 162
 163         return;
 164
 165       case kPaused:
 166       case kUninitialized:
 167       case kEnded:
 168         NOTREACHED();
 169         return;
 170     }
 171
 172     NOTREACHED();
 173     return;
 174   }
 175
 176   if (input->end_of_stream()) {
 177     CueReady(stream, NULL);
 178     return;
 179   }
 180
 181   DCHECK_EQ(status, DemuxerStream::kOk);
 182   DCHECK_GE(input->side_data_size(), 2);
 183
 184   // The side data contains both the cue id and cue settings,
 185   // each terminated with a NUL.
 186   const char* id_ptr = reinterpret_cast<const char*>(input->side_data());
 187   size_t id_len = strlen(id_ptr);
 188   std::string id(id_ptr, id_len);
 189
 190   const char* settings_ptr = id_ptr + id_len + 1;
 191   size_t settings_len = strlen(settings_ptr);
 192   std::string settings(settings_ptr, settings_len);
 193
 194   // The cue payload is stored in the data-part of the input buffer.
 195   std::string text(input->data(), input->data() + input->data_size());
 196
 197   scoped_refptr<TextCue> text_cue(
 198       new TextCue(input->timestamp(),
 199                   input->duration(),
 200                   id,
 201                   settings,
 202                   text));
 203
 204   CueReady(stream, text_cue);
 205 }
 206
 207 void TextRenderer::CueReady(
 208     DemuxerStream* text_stream,
 209     const scoped_refptr<TextCue>& text_cue) {
 210   DCHECK(task_runner_->BelongsToCurrentThread());
 211   DCHECK_NE(state_, kUninitialized);
 212   DCHECK_GT(pending_read_count_, 0);
 213   DCHECK(pending_eos_set_.find(text_stream) != pending_eos_set_.end());
 214
 215   TextTrackStateMap::iterator itr = text_track_state_map_.find(text_stream);
 216   DCHECK(itr != text_track_state_map_.end());
 217
 218   TextTrackState* state = itr->second;
 219   DCHECK_EQ(state->read_state, TextTrackState::kReadPending);
 220   DCHECK(state->text_track);
 221
 222   --pending_read_count_;
 223   state->read_state = TextTrackState::kReadIdle;
 224
 225   switch (state_) {
 226     case kPlaying: {
 227       if (text_cue.get())
 228         break;
 229
 230       const size_t count = pending_eos_set_.erase(text_stream);
 231       DCHECK_EQ(count, 1U);
 232
 233       if (pending_eos_set_.empty()) {
 234         DCHECK_EQ(pending_read_count_, 0);
 235         state_ = kEnded;
 236         task_runner_->PostTask(FROM_HERE, ended_cb_);
 237         return;
 238       }
 239
 240       DCHECK_GT(pending_read_count_, 0);
 241       return;
 242     }
 243     case kPausePending: {
 244       if (text_cue.get())
 245         break;
 246
 247       const size_t count = pending_eos_set_.erase(text_stream);
 248       DCHECK_EQ(count, 1U);
 249
 250       if (pending_read_count_ > 0) {
 251         DCHECK(!pending_eos_set_.empty());
 252         return;
 253       }
 254
 255       state_ = kPaused;
 256       base::ResetAndReturn(&pause_cb_).Run();
 257
 258       return;
 259     }
 260
 261     case kPaused:
 262     case kUninitialized:
 263     case kEnded:
 264       NOTREACHED();
 265       return;
 266   }
 267
 268   base::TimeDelta start = text_cue->timestamp();
 269
 270   if (state->text_ranges_.AddCue(start)) {
 271     base::TimeDelta end = start + text_cue->duration();
 272
 273     state->text_track->addWebVTTCue(start, end,
 274                                     text_cue->id(),
 275                                     text_cue->text(),
 276                                     text_cue->settings());
 277   }
 278
 279   if (state_ == kPlaying) {
 280     Read(state, text_stream);
 281     return;
 282   }
 283
 284   if (pending_read_count_ == 0) {
 285       DCHECK_EQ(state_, kPausePending) << "state_ " << state_;
 286       state_ = kPaused;
 287       base::ResetAndReturn(&pause_cb_).Run();
 288   }
 289 }
 290
 291 void TextRenderer::OnAddTextTrackDone(DemuxerStream* text_stream,
 292                                       scoped_ptr<TextTrack> text_track) {
 293   DCHECK(task_runner_->BelongsToCurrentThread());
 294   DCHECK_NE(state_, kUninitialized);
 295   DCHECK(text_stream);
 296   DCHECK(text_track);
 297
 298   scoped_ptr<TextTrackState> state(new TextTrackState(text_track.Pass()));
 299   text_track_state_map_[text_stream] = state.release();
 300   pending_eos_set_.insert(text_stream);
 301
 302   if (state_ == kPlaying)
 303     Read(text_track_state_map_[text_stream], text_stream);
 304 }
 305
 306 void TextRenderer::Read(
 307     TextTrackState* state,
 308     DemuxerStream* text_stream) {
 309   DCHECK_NE(state->read_state, TextTrackState::kReadPending);
 310
 311   state->read_state = TextTrackState::kReadPending;
 312   ++pending_read_count_;
 313
 314   text_stream->Read(base::Bind(
 315       &TextRenderer::BufferReady, weak_factory_.GetWeakPtr(), text_stream));
 316 }
 317
 318 TextRenderer::TextTrackState::TextTrackState(scoped_ptr<TextTrack> tt)
 319     : read_state(kReadIdle),
 320       text_track(tt.Pass()) {
 321 }
 322
 323 TextRenderer::TextTrackState::~TextTrackState() {
 324 }
 325
 326 }  // namespace media