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(state_ == kUninitialized ||
  31          state_ == kStopped) << "state_ " << state_;
  32   DCHECK_EQ(pending_read_count_, 0);
  33   STLDeleteValues(&text_track_state_map_);
  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::Play(const base::Closure& callback) {
  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   callback.Run();
  66 }
  67
  68 void TextRenderer::Pause(const base::Closure& callback) {
  69   DCHECK(task_runner_->BelongsToCurrentThread());
  70   DCHECK(state_ == kPlaying || state_ == kEnded) << "state_ " << state_;
  71   DCHECK_GE(pending_read_count_, 0);
  72   pause_cb_ = callback;
  73
  74   if (pending_read_count_ == 0) {
  75     state_ = kPaused;
  76     base::ResetAndReturn(&pause_cb_).Run();
  77     return;
  78   }
  79
  80   state_ = kPausePending;
  81 }
  82
  83 void TextRenderer::Flush(const base::Closure& callback) {
  84   DCHECK(task_runner_->BelongsToCurrentThread());
  85   DCHECK_EQ(pending_read_count_, 0);
  86   DCHECK(state_ == kPaused) << "state_ " << state_;
  87
  88   for (TextTrackStateMap::iterator itr = text_track_state_map_.begin();
  89        itr != text_track_state_map_.end(); ++itr) {
  90     pending_eos_set_.insert(itr->first);
  91     itr->second->text_ranges_.Reset();
  92   }
  93   DCHECK_EQ(pending_eos_set_.size(), text_track_state_map_.size());
  94   callback.Run();
  95 }
  96
  97 void TextRenderer::Stop(const base::Closure& cb) {
  98   DCHECK(task_runner_->BelongsToCurrentThread());
  99   DCHECK(!cb.is_null());
 100   DCHECK(state_ == kPlaying ||
 101          state_ == kPausePending ||
 102          state_ == kPaused ||
 103          state_ == kEnded) << "state_ " << state_;
 104   DCHECK_GE(pending_read_count_, 0);
 105
 106   stop_cb_ = cb;
 107
 108   if (pending_read_count_ == 0) {
 109     state_ = kStopped;
 110     base::ResetAndReturn(&stop_cb_).Run();
 111     return;
 112   }
 113
 114   state_ = kStopPending;
 115 }
 116
 117 void TextRenderer::AddTextStream(DemuxerStream* text_stream,
 118                                  const TextTrackConfig& config) {
 119   DCHECK(task_runner_->BelongsToCurrentThread());
 120   DCHECK(state_ != kUninitialized) << "state_ " << state_;
 121   DCHECK_NE(state_, kStopPending);
 122   DCHECK_NE(state_, kStopped);
 123   DCHECK(text_track_state_map_.find(text_stream) ==
 124          text_track_state_map_.end());
 125   DCHECK(pending_eos_set_.find(text_stream) ==
 126          pending_eos_set_.end());
 127
 128   AddTextTrackDoneCB done_cb =
 129       BindToCurrentLoop(base::Bind(&TextRenderer::OnAddTextTrackDone,
 130                                    weak_factory_.GetWeakPtr(),
 131                                    text_stream));
 132
 133   add_text_track_cb_.Run(config, done_cb);
 134 }
 135
 136 void TextRenderer::RemoveTextStream(DemuxerStream* text_stream) {
 137   DCHECK(task_runner_->BelongsToCurrentThread());
 138
 139   TextTrackStateMap::iterator itr = text_track_state_map_.find(text_stream);
 140   DCHECK(itr != text_track_state_map_.end());
 141
 142   TextTrackState* state = itr->second;
 143   DCHECK_EQ(state->read_state, TextTrackState::kReadIdle);
 144   delete state;
 145   text_track_state_map_.erase(itr);
 146
 147   pending_eos_set_.erase(text_stream);
 148 }
 149
 150 bool TextRenderer::HasTracks() const {
 151   DCHECK(task_runner_->BelongsToCurrentThread());
 152   return !text_track_state_map_.empty();
 153 }
 154
 155 void TextRenderer::BufferReady(
 156     DemuxerStream* stream,
 157     DemuxerStream::Status status,
 158     const scoped_refptr<DecoderBuffer>& input) {
 159   DCHECK(task_runner_->BelongsToCurrentThread());
 160   DCHECK_NE(status, DemuxerStream::kConfigChanged);
 161
 162   if (status == DemuxerStream::kAborted) {
 163     DCHECK(!input);
 164     DCHECK_GT(pending_read_count_, 0);
 165     DCHECK(pending_eos_set_.find(stream) != pending_eos_set_.end());
 166
 167     TextTrackStateMap::iterator itr = text_track_state_map_.find(stream);
 168     DCHECK(itr != text_track_state_map_.end());
 169
 170     TextTrackState* state = itr->second;
 171     DCHECK_EQ(state->read_state, TextTrackState::kReadPending);
 172
 173     --pending_read_count_;
 174     state->read_state = TextTrackState::kReadIdle;
 175
 176     switch (state_) {
 177       case kPlaying:
 178         return;
 179
 180       case kPausePending:
 181         if (pending_read_count_ == 0) {
 182           state_ = kPaused;
 183           base::ResetAndReturn(&pause_cb_).Run();
 184         }
 185
 186         return;
 187
 188       case kStopPending:
 189         if (pending_read_count_ == 0) {
 190           state_ = kStopped;
 191           base::ResetAndReturn(&stop_cb_).Run();
 192         }
 193
 194         return;
 195
 196       case kPaused:
 197       case kStopped:
 198       case kUninitialized:
 199       case kEnded:
 200         NOTREACHED();
 201         return;
 202     }
 203
 204     NOTREACHED();
 205     return;
 206   }
 207
 208   if (input->end_of_stream()) {
 209     CueReady(stream, NULL);
 210     return;
 211   }
 212
 213   DCHECK_EQ(status, DemuxerStream::kOk);
 214   DCHECK_GE(input->side_data_size(), 2);
 215
 216   // The side data contains both the cue id and cue settings,
 217   // each terminated with a NUL.
 218   const char* id_ptr = reinterpret_cast<const char*>(input->side_data());
 219   size_t id_len = strlen(id_ptr);
 220   std::string id(id_ptr, id_len);
 221
 222   const char* settings_ptr = id_ptr + id_len + 1;
 223   size_t settings_len = strlen(settings_ptr);
 224   std::string settings(settings_ptr, settings_len);
 225
 226   // The cue payload is stored in the data-part of the input buffer.
 227   std::string text(input->data(), input->data() + input->data_size());
 228
 229   scoped_refptr<TextCue> text_cue(
 230       new TextCue(input->timestamp(),
 231                   input->duration(),
 232                   id,
 233                   settings,
 234                   text));
 235
 236   CueReady(stream, text_cue);
 237 }
 238
 239 void TextRenderer::CueReady(
 240     DemuxerStream* text_stream,
 241     const scoped_refptr<TextCue>& text_cue) {
 242   DCHECK(task_runner_->BelongsToCurrentThread());
 243   DCHECK(state_ != kUninitialized &&
 244          state_ != kStopped) << "state_ " << state_;
 245   DCHECK_GT(pending_read_count_, 0);
 246   DCHECK(pending_eos_set_.find(text_stream) != pending_eos_set_.end());
 247
 248   TextTrackStateMap::iterator itr = text_track_state_map_.find(text_stream);
 249   DCHECK(itr != text_track_state_map_.end());
 250
 251   TextTrackState* state = itr->second;
 252   DCHECK_EQ(state->read_state, TextTrackState::kReadPending);
 253   DCHECK(state->text_track);
 254
 255   --pending_read_count_;
 256   state->read_state = TextTrackState::kReadIdle;
 257
 258   switch (state_) {
 259     case kPlaying: {
 260       if (text_cue)
 261         break;
 262
 263       const size_t count = pending_eos_set_.erase(text_stream);
 264       DCHECK_EQ(count, 1U);
 265
 266       if (pending_eos_set_.empty()) {
 267         DCHECK_EQ(pending_read_count_, 0);
 268         state_ = kEnded;
 269         ended_cb_.Run();
 270         return;
 271       }
 272
 273       DCHECK_GT(pending_read_count_, 0);
 274       return;
 275     }
 276     case kPausePending: {
 277       if (text_cue)
 278         break;
 279
 280       const size_t count = pending_eos_set_.erase(text_stream);
 281       DCHECK_EQ(count, 1U);
 282
 283       if (pending_read_count_ > 0) {
 284         DCHECK(!pending_eos_set_.empty());
 285         return;
 286       }
 287
 288       state_ = kPaused;
 289       base::ResetAndReturn(&pause_cb_).Run();
 290
 291       return;
 292     }
 293     case kStopPending:
 294       if (pending_read_count_ == 0) {
 295         state_ = kStopped;
 296         base::ResetAndReturn(&stop_cb_).Run();
 297       }
 298
 299       return;
 300
 301     case kPaused:
 302     case kStopped:
 303     case kUninitialized:
 304     case kEnded:
 305       NOTREACHED();
 306       return;
 307   }
 308
 309   base::TimeDelta start = text_cue->timestamp();
 310
 311   if (state->text_ranges_.AddCue(start)) {
 312     base::TimeDelta end = start + text_cue->duration();
 313
 314     state->text_track->addWebVTTCue(start, end,
 315                                     text_cue->id(),
 316                                     text_cue->text(),
 317                                     text_cue->settings());
 318   }
 319
 320   if (state_ == kPlaying) {
 321     Read(state, text_stream);
 322     return;
 323   }
 324
 325   if (pending_read_count_ == 0) {
 326       DCHECK_EQ(state_, kPausePending) << "state_ " << state_;
 327       state_ = kPaused;
 328       base::ResetAndReturn(&pause_cb_).Run();
 329   }
 330 }
 331
 332 void TextRenderer::OnAddTextTrackDone(DemuxerStream* text_stream,
 333                                       scoped_ptr<TextTrack> text_track) {
 334   DCHECK(task_runner_->BelongsToCurrentThread());
 335   DCHECK(state_ != kUninitialized &&
 336          state_ != kStopped &&
 337          state_ != kStopPending) << "state_ " << state_;
 338   DCHECK(text_stream);
 339   DCHECK(text_track);
 340
 341   scoped_ptr<TextTrackState> state(new TextTrackState(text_track.Pass()));
 342   text_track_state_map_[text_stream] = state.release();
 343   pending_eos_set_.insert(text_stream);
 344
 345   if (state_ == kPlaying)
 346     Read(text_track_state_map_[text_stream], text_stream);
 347 }
 348
 349 void TextRenderer::Read(
 350     TextTrackState* state,
 351     DemuxerStream* text_stream) {
 352   DCHECK_NE(state->read_state, TextTrackState::kReadPending);
 353
 354   state->read_state = TextTrackState::kReadPending;
 355   ++pending_read_count_;
 356
 357   text_stream->Read(base::Bind(
 358       &TextRenderer::BufferReady, weak_factory_.GetWeakPtr(), text_stream));
 359 }
 360
 361 TextRenderer::TextTrackState::TextTrackState(scoped_ptr<TextTrack> tt)
 362     : read_state(kReadIdle),
 363       text_track(tt.Pass()) {
 364 }
 365
 366 TextRenderer::TextTrackState::~TextTrackState() {
 367 }
 368
 369 }  // namespace media