media/base/pipeline.cc

   1 // Copyright (c) 2012 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/pipeline.h"
   6
   7 #include <algorithm>
   8
   9 #include "base/bind.h"
  10 #include "base/callback.h"
  11 #include "base/callback_helpers.h"
  12 #include "base/command_line.h"
  13 #include "base/compiler_specific.h"
  14 #include "base/location.h"
  15 #include "base/metrics/histogram.h"
  16 #include "base/single_thread_task_runner.h"
  17 #include "base/stl_util.h"
  18 #include "base/strings/string_number_conversions.h"
  19 #include "base/strings/string_util.h"
  20 #include "base/synchronization/condition_variable.h"
  21 #include "media/base/media_log.h"
  22 #include "media/base/media_switches.h"
  23 #include "media/base/renderer.h"
  24 #include "media/base/text_renderer.h"
  25 #include "media/base/text_track_config.h"
  26 #include "media/base/video_decoder_config.h"
  27
  28 using base::TimeDelta;
  29
  30 namespace media {
  31
  32 Pipeline::Pipeline(
  33     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
  34     MediaLog* media_log)
  35     : task_runner_(task_runner),
  36       media_log_(media_log),
  37       running_(false),
  38       did_loading_progress_(false),
  39       volume_(1.0f),
  40       playback_rate_(0.0f),
  41       status_(PIPELINE_OK),
  42       is_initialized_(false),
  43       state_(kCreated),
  44       renderer_ended_(false),
  45       text_renderer_ended_(false),
  46       demuxer_(NULL),
  47       weak_factory_(this) {
  48   media_log_->AddEvent(media_log_->CreatePipelineStateChangedEvent(kCreated));
  49   media_log_->AddEvent(
  50       media_log_->CreateEvent(MediaLogEvent::PIPELINE_CREATED));
  51 }
  52
  53 Pipeline::~Pipeline() {
  54   DCHECK(thread_checker_.CalledOnValidThread())
  55       << "Pipeline must be destroyed on same thread that created it";
  56   DCHECK(!running_) << "Stop() must complete before destroying object";
  57   DCHECK(stop_cb_.is_null());
  58   DCHECK(seek_cb_.is_null());
  59
  60   media_log_->AddEvent(
  61       media_log_->CreateEvent(MediaLogEvent::PIPELINE_DESTROYED));
  62 }
  63
  64 void Pipeline::Start(Demuxer* demuxer,
  65                      scoped_ptr<Renderer> renderer,
  66                      const base::Closure& ended_cb,
  67                      const PipelineStatusCB& error_cb,
  68                      const PipelineStatusCB& seek_cb,
  69                      const PipelineMetadataCB& metadata_cb,
  70                      const BufferingStateCB& buffering_state_cb,
  71                      const base::Closure& duration_change_cb,
  72                      const AddTextTrackCB& add_text_track_cb) {
  73   DCHECK(!ended_cb.is_null());
  74   DCHECK(!error_cb.is_null());
  75   DCHECK(!seek_cb.is_null());
  76   DCHECK(!metadata_cb.is_null());
  77   DCHECK(!buffering_state_cb.is_null());
  78
  79   base::AutoLock auto_lock(lock_);
  80   CHECK(!running_) << "Media pipeline is already running";
  81   running_ = true;
  82
  83   demuxer_ = demuxer;
  84   renderer_ = renderer.Pass();
  85   ended_cb_ = ended_cb;
  86   error_cb_ = error_cb;
  87   seek_cb_ = seek_cb;
  88   metadata_cb_ = metadata_cb;
  89   buffering_state_cb_ = buffering_state_cb;
  90   duration_change_cb_ = duration_change_cb;
  91   add_text_track_cb_ = add_text_track_cb;
  92
  93   task_runner_->PostTask(
  94       FROM_HERE, base::Bind(&Pipeline::StartTask, weak_factory_.GetWeakPtr()));
  95 }
  96
  97 void Pipeline::Stop(const base::Closure& stop_cb) {
  98   DVLOG(2) << __FUNCTION__;
  99   task_runner_->PostTask(
 100       FROM_HERE,
 101       base::Bind(&Pipeline::StopTask, weak_factory_.GetWeakPtr(), stop_cb));
 102 }
 103
 104 void Pipeline::Seek(TimeDelta time, const PipelineStatusCB& seek_cb) {
 105   base::AutoLock auto_lock(lock_);
 106   if (!running_) {
 107     DLOG(ERROR) << "Media pipeline isn't running. Ignoring Seek().";
 108     return;
 109   }
 110
 111   task_runner_->PostTask(
 112       FROM_HERE,
 113       base::Bind(
 114           &Pipeline::SeekTask, weak_factory_.GetWeakPtr(), time, seek_cb));
 115 }
 116
 117 bool Pipeline::IsRunning() const {
 118   base::AutoLock auto_lock(lock_);
 119   return running_;
 120 }
 121
 122 float Pipeline::GetPlaybackRate() const {
 123   base::AutoLock auto_lock(lock_);
 124   return playback_rate_;
 125 }
 126
 127 void Pipeline::SetPlaybackRate(float playback_rate) {
 128   if (playback_rate < 0.0f)
 129     return;
 130
 131   base::AutoLock auto_lock(lock_);
 132   playback_rate_ = playback_rate;
 133   if (running_) {
 134     task_runner_->PostTask(FROM_HERE,
 135                            base::Bind(&Pipeline::PlaybackRateChangedTask,
 136                                       weak_factory_.GetWeakPtr(),
 137                                       playback_rate));
 138   }
 139 }
 140
 141 float Pipeline::GetVolume() const {
 142   base::AutoLock auto_lock(lock_);
 143   return volume_;
 144 }
 145
 146 void Pipeline::SetVolume(float volume) {
 147   if (volume < 0.0f || volume > 1.0f)
 148     return;
 149
 150   base::AutoLock auto_lock(lock_);
 151   volume_ = volume;
 152   if (running_) {
 153     task_runner_->PostTask(
 154         FROM_HERE,
 155         base::Bind(
 156             &Pipeline::VolumeChangedTask, weak_factory_.GetWeakPtr(), volume));
 157   }
 158 }
 159
 160 TimeDelta Pipeline::GetMediaTime() const {
 161   base::AutoLock auto_lock(lock_);
 162   if (!renderer_)
 163     return TimeDelta();
 164
 165   TimeDelta media_time = renderer_->GetMediaTime();
 166   return std::min(media_time, duration_);
 167 }
 168
 169 Ranges<TimeDelta> Pipeline::GetBufferedTimeRanges() const {
 170   base::AutoLock auto_lock(lock_);
 171   return buffered_time_ranges_;
 172 }
 173
 174 TimeDelta Pipeline::GetMediaDuration() const {
 175   base::AutoLock auto_lock(lock_);
 176   return duration_;
 177 }
 178
 179 bool Pipeline::DidLoadingProgress() {
 180   base::AutoLock auto_lock(lock_);
 181   bool ret = did_loading_progress_;
 182   did_loading_progress_ = false;
 183   return ret;
 184 }
 185
 186 PipelineStatistics Pipeline::GetStatistics() const {
 187   base::AutoLock auto_lock(lock_);
 188   return statistics_;
 189 }
 190
 191 void Pipeline::SetErrorForTesting(PipelineStatus status) {
 192   OnError(status);
 193 }
 194
 195 bool Pipeline::HasWeakPtrsForTesting() const {
 196   DCHECK(task_runner_->BelongsToCurrentThread());
 197   return weak_factory_.HasWeakPtrs();
 198 }
 199
 200 void Pipeline::SetState(State next_state) {
 201   DVLOG(1) << GetStateString(state_) << " -> " << GetStateString(next_state);
 202
 203   state_ = next_state;
 204   media_log_->AddEvent(media_log_->CreatePipelineStateChangedEvent(next_state));
 205 }
 206
 207 #define RETURN_STRING(state) case state: return #state;
 208
 209 const char* Pipeline::GetStateString(State state) {
 210   switch (state) {
 211     RETURN_STRING(kCreated);
 212     RETURN_STRING(kInitDemuxer);
 213     RETURN_STRING(kInitRenderer);
 214     RETURN_STRING(kSeeking);
 215     RETURN_STRING(kPlaying);
 216     RETURN_STRING(kStopping);
 217     RETURN_STRING(kStopped);
 218   }
 219   NOTREACHED();
 220   return "INVALID";
 221 }
 222
 223 #undef RETURN_STRING
 224
 225 Pipeline::State Pipeline::GetNextState() const {
 226   DCHECK(task_runner_->BelongsToCurrentThread());
 227   DCHECK(stop_cb_.is_null())
 228       << "State transitions don't happen when stopping";
 229   DCHECK_EQ(status_, PIPELINE_OK)
 230       << "State transitions don't happen when there's an error: " << status_;
 231
 232   switch (state_) {
 233     case kCreated:
 234       return kInitDemuxer;
 235
 236     case kInitDemuxer:
 237       return kInitRenderer;
 238
 239     case kInitRenderer:
 240     case kSeeking:
 241       return kPlaying;
 242
 243     case kPlaying:
 244     case kStopping:
 245     case kStopped:
 246       break;
 247   }
 248   NOTREACHED() << "State has no transition: " << state_;
 249   return state_;
 250 }
 251
 252 void Pipeline::OnDemuxerError(PipelineStatus error) {
 253   task_runner_->PostTask(FROM_HERE,
 254                          base::Bind(&Pipeline::ErrorChangedTask,
 255                                     weak_factory_.GetWeakPtr(),
 256                                     error));
 257 }
 258
 259 void Pipeline::AddTextStream(DemuxerStream* text_stream,
 260                              const TextTrackConfig& config) {
 261   task_runner_->PostTask(FROM_HERE,
 262                          base::Bind(&Pipeline::AddTextStreamTask,
 263                                     weak_factory_.GetWeakPtr(),
 264                                     text_stream,
 265                                     config));
 266 }
 267
 268 void Pipeline::RemoveTextStream(DemuxerStream* text_stream) {
 269   task_runner_->PostTask(FROM_HERE,
 270                          base::Bind(&Pipeline::RemoveTextStreamTask,
 271                                     weak_factory_.GetWeakPtr(),
 272                                     text_stream));
 273 }
 274
 275 void Pipeline::OnError(PipelineStatus error) {
 276   DCHECK(task_runner_->BelongsToCurrentThread());
 277   DCHECK(IsRunning());
 278   DCHECK_NE(PIPELINE_OK, error);
 279   VLOG(1) << "Media pipeline error: " << error;
 280
 281   task_runner_->PostTask(FROM_HERE, base::Bind(
 282       &Pipeline::ErrorChangedTask, weak_factory_.GetWeakPtr(), error));
 283 }
 284
 285 void Pipeline::SetDuration(TimeDelta duration) {
 286   DCHECK(IsRunning());
 287   media_log_->AddEvent(
 288       media_log_->CreateTimeEvent(
 289           MediaLogEvent::DURATION_SET, "duration", duration));
 290   UMA_HISTOGRAM_LONG_TIMES("Media.Duration", duration);
 291
 292   base::AutoLock auto_lock(lock_);
 293   duration_ = duration;
 294   if (!duration_change_cb_.is_null())
 295     duration_change_cb_.Run();
 296 }
 297
 298 void Pipeline::OnStateTransition(PipelineStatus status) {
 299   DCHECK(task_runner_->BelongsToCurrentThread());
 300   // Force post to process state transitions after current execution frame.
 301   task_runner_->PostTask(
 302       FROM_HERE,
 303       base::Bind(
 304           &Pipeline::StateTransitionTask, weak_factory_.GetWeakPtr(), status));
 305 }
 306
 307 void Pipeline::StateTransitionTask(PipelineStatus status) {
 308   DCHECK(task_runner_->BelongsToCurrentThread());
 309
 310   // No-op any state transitions if we're stopping.
 311   if (state_ == kStopping || state_ == kStopped)
 312     return;
 313
 314   // Preserve existing abnormal status, otherwise update based on the result of
 315   // the previous operation.
 316   status_ = (status_ != PIPELINE_OK ? status_ : status);
 317
 318   if (status_ != PIPELINE_OK) {
 319     ErrorChangedTask(status_);
 320     return;
 321   }
 322
 323   // Guard against accidentally clearing |pending_callbacks_| for states that
 324   // use it as well as states that should not be using it.
 325   DCHECK_EQ(pending_callbacks_.get() != NULL, state_ == kSeeking);
 326
 327   pending_callbacks_.reset();
 328
 329   PipelineStatusCB done_cb =
 330       base::Bind(&Pipeline::OnStateTransition, weak_factory_.GetWeakPtr());
 331
 332   // Switch states, performing any entrance actions for the new state as well.
 333   SetState(GetNextState());
 334   switch (state_) {
 335     case kInitDemuxer:
 336       return InitializeDemuxer(done_cb);
 337
 338     case kInitRenderer:
 339       return InitializeRenderer(base::Bind(done_cb, PIPELINE_OK));
 340
 341     case kPlaying:
 342       // Report metadata the first time we enter the playing state.
 343       if (!is_initialized_) {
 344         is_initialized_ = true;
 345         ReportMetadata();
 346         start_timestamp_ = demuxer_->GetStartTime();
 347       }
 348
 349       base::ResetAndReturn(&seek_cb_).Run(PIPELINE_OK);
 350
 351       DCHECK(start_timestamp_ >= base::TimeDelta());
 352       renderer_->StartPlayingFrom(start_timestamp_);
 353
 354       if (text_renderer_)
 355         text_renderer_->StartPlaying();
 356
 357       PlaybackRateChangedTask(GetPlaybackRate());
 358       VolumeChangedTask(GetVolume());
 359       return;
 360
 361     case kStopping:
 362     case kStopped:
 363     case kCreated:
 364     case kSeeking:
 365       NOTREACHED() << "State has no transition: " << state_;
 366       return;
 367   }
 368 }
 369
 370 // Note that the usage of base::Unretained() with the renderers is considered
 371 // safe as they are owned by |pending_callbacks_| and share the same lifetime.
 372 //
 373 // That being said, deleting the renderers while keeping |pending_callbacks_|
 374 // running on the media thread would result in crashes.
 375 void Pipeline::DoSeek(TimeDelta seek_timestamp,
 376                       const PipelineStatusCB& done_cb) {
 377   DCHECK(task_runner_->BelongsToCurrentThread());
 378   DCHECK(!pending_callbacks_.get());
 379   DCHECK_EQ(state_, kSeeking);
 380   SerialRunner::Queue bound_fns;
 381
 382   // Pause.
 383   if (text_renderer_) {
 384     bound_fns.Push(base::Bind(
 385         &TextRenderer::Pause, base::Unretained(text_renderer_.get())));
 386   }
 387
 388   // Flush.
 389   DCHECK(renderer_);
 390   bound_fns.Push(
 391       base::Bind(&Renderer::Flush, base::Unretained(renderer_.get())));
 392
 393   if (text_renderer_) {
 394     bound_fns.Push(base::Bind(
 395         &TextRenderer::Flush, base::Unretained(text_renderer_.get())));
 396   }
 397
 398   // Seek demuxer.
 399   bound_fns.Push(base::Bind(
 400       &Demuxer::Seek, base::Unretained(demuxer_), seek_timestamp));
 401
 402   pending_callbacks_ = SerialRunner::Run(bound_fns, done_cb);
 403 }
 404
 405 void Pipeline::DoStop(const PipelineStatusCB& done_cb) {
 406   DVLOG(2) << __FUNCTION__;
 407   DCHECK(task_runner_->BelongsToCurrentThread());
 408   DCHECK(!pending_callbacks_.get());
 409
 410   // TODO(scherkus): Enforce that Renderer is only called on a single thread,
 411   // even for accessing media time http://crbug.com/370634
 412   scoped_ptr<Renderer> renderer;
 413   {
 414     base::AutoLock auto_lock(lock_);
 415     renderer.swap(renderer_);
 416   }
 417   renderer.reset();
 418   text_renderer_.reset();
 419
 420   if (demuxer_) {
 421     demuxer_->Stop();
 422     demuxer_ = NULL;
 423   }
 424
 425   task_runner_->PostTask(FROM_HERE, base::Bind(done_cb, PIPELINE_OK));
 426 }
 427
 428 void Pipeline::OnStopCompleted(PipelineStatus status) {
 429   DVLOG(2) << __FUNCTION__;
 430   DCHECK(task_runner_->BelongsToCurrentThread());
 431   DCHECK_EQ(state_, kStopping);
 432   DCHECK(!renderer_);
 433   DCHECK(!text_renderer_);
 434
 435   {
 436     base::AutoLock auto_lock(lock_);
 437     running_ = false;
 438   }
 439
 440   SetState(kStopped);
 441   demuxer_ = NULL;
 442
 443   // If we stop during initialization/seeking we want to run |seek_cb_|
 444   // followed by |stop_cb_| so we don't leave outstanding callbacks around.
 445   if (!seek_cb_.is_null()) {
 446     base::ResetAndReturn(&seek_cb_).Run(status_);
 447     error_cb_.Reset();
 448   }
 449   if (!stop_cb_.is_null()) {
 450     error_cb_.Reset();
 451
 452     // Invalid all weak pointers so it's safe to destroy |this| on the render
 453     // main thread.
 454     weak_factory_.InvalidateWeakPtrs();
 455
 456     base::ResetAndReturn(&stop_cb_).Run();
 457
 458     // NOTE: pipeline may be deleted at this point in time as a result of
 459     // executing |stop_cb_|.
 460     return;
 461   }
 462   if (!error_cb_.is_null()) {
 463     DCHECK_NE(status_, PIPELINE_OK);
 464     base::ResetAndReturn(&error_cb_).Run(status_);
 465   }
 466 }
 467
 468 void Pipeline::AddBufferedTimeRange(TimeDelta start, TimeDelta end) {
 469   DCHECK(IsRunning());
 470   base::AutoLock auto_lock(lock_);
 471   buffered_time_ranges_.Add(start, end);
 472   did_loading_progress_ = true;
 473 }
 474
 475 // Called from any thread.
 476 void Pipeline::OnUpdateStatistics(const PipelineStatistics& stats) {
 477   base::AutoLock auto_lock(lock_);
 478   statistics_.audio_bytes_decoded += stats.audio_bytes_decoded;
 479   statistics_.video_bytes_decoded += stats.video_bytes_decoded;
 480   statistics_.video_frames_decoded += stats.video_frames_decoded;
 481   statistics_.video_frames_dropped += stats.video_frames_dropped;
 482 }
 483
 484 void Pipeline::StartTask() {
 485   DCHECK(task_runner_->BelongsToCurrentThread());
 486
 487   CHECK_EQ(kCreated, state_)
 488       << "Media pipeline cannot be started more than once";
 489
 490   text_renderer_ = CreateTextRenderer();
 491   if (text_renderer_) {
 492     text_renderer_->Initialize(
 493         base::Bind(&Pipeline::OnTextRendererEnded, weak_factory_.GetWeakPtr()));
 494   }
 495
 496   StateTransitionTask(PIPELINE_OK);
 497 }
 498
 499 void Pipeline::StopTask(const base::Closure& stop_cb) {
 500   DCHECK(task_runner_->BelongsToCurrentThread());
 501   DCHECK(stop_cb_.is_null());
 502
 503   if (state_ == kStopped) {
 504     // Invalid all weak pointers so it's safe to destroy |this| on the render
 505     // main thread.
 506     weak_factory_.InvalidateWeakPtrs();
 507
 508     // NOTE: pipeline may be deleted at this point in time as a result of
 509     // executing |stop_cb|.
 510     stop_cb.Run();
 511
 512     return;
 513   }
 514
 515   stop_cb_ = stop_cb;
 516
 517   // We may already be stopping due to a runtime error.
 518   if (state_ == kStopping)
 519     return;
 520
 521   // Do not report statistics if the pipeline is not fully initialized.
 522   if (state_ == kSeeking || state_ == kPlaying) {
 523     PipelineStatistics stats = GetStatistics();
 524     if (renderer_->HasVideo() && stats.video_frames_decoded > 0) {
 525       UMA_HISTOGRAM_COUNTS("Media.DroppedFrameCount",
 526                            stats.video_frames_dropped);
 527     }
 528   }
 529
 530   SetState(kStopping);
 531   pending_callbacks_.reset();
 532   DoStop(base::Bind(&Pipeline::OnStopCompleted, weak_factory_.GetWeakPtr()));
 533 }
 534
 535 void Pipeline::ErrorChangedTask(PipelineStatus error) {
 536   DCHECK(task_runner_->BelongsToCurrentThread());
 537   DCHECK_NE(PIPELINE_OK, error) << "PIPELINE_OK isn't an error!";
 538
 539   media_log_->AddEvent(media_log_->CreatePipelineErrorEvent(error));
 540
 541   if (state_ == kStopping || state_ == kStopped)
 542     return;
 543
 544   SetState(kStopping);
 545   pending_callbacks_.reset();
 546   status_ = error;
 547
 548   DoStop(base::Bind(&Pipeline::OnStopCompleted, weak_factory_.GetWeakPtr()));
 549 }
 550
 551 void Pipeline::PlaybackRateChangedTask(float playback_rate) {
 552   DCHECK(task_runner_->BelongsToCurrentThread());
 553
 554   // Playback rate changes are only carried out while playing.
 555   if (state_ != kPlaying)
 556     return;
 557
 558   renderer_->SetPlaybackRate(playback_rate);
 559 }
 560
 561 void Pipeline::VolumeChangedTask(float volume) {
 562   DCHECK(task_runner_->BelongsToCurrentThread());
 563
 564   // Volume changes are only carried out while playing.
 565   if (state_ != kPlaying)
 566     return;
 567
 568   renderer_->SetVolume(volume);
 569 }
 570
 571 void Pipeline::SeekTask(TimeDelta time, const PipelineStatusCB& seek_cb) {
 572   DCHECK(task_runner_->BelongsToCurrentThread());
 573   DCHECK(stop_cb_.is_null());
 574
 575   // Suppress seeking if we're not fully started.
 576   if (state_ != kPlaying) {
 577     DCHECK(state_ == kStopping || state_ == kStopped)
 578         << "Receive extra seek in unexpected state: " << state_;
 579
 580     // TODO(scherkus): should we run the callback?  I'm tempted to say the API
 581     // will only execute the first Seek() request.
 582     DVLOG(1) << "Media pipeline has not started, ignoring seek to "
 583              << time.InMicroseconds() << " (current state: " << state_ << ")";
 584     return;
 585   }
 586
 587   DCHECK(seek_cb_.is_null());
 588
 589   const base::TimeDelta seek_timestamp =
 590       std::max(time, demuxer_->GetStartTime());
 591
 592   SetState(kSeeking);
 593   seek_cb_ = seek_cb;
 594   renderer_ended_ = false;
 595   text_renderer_ended_ = false;
 596   start_timestamp_ = seek_timestamp;
 597
 598   DoSeek(seek_timestamp,
 599          base::Bind(&Pipeline::OnStateTransition, weak_factory_.GetWeakPtr()));
 600 }
 601
 602 void Pipeline::OnRendererEnded() {
 603   DCHECK(task_runner_->BelongsToCurrentThread());
 604   media_log_->AddEvent(media_log_->CreateEvent(MediaLogEvent::ENDED));
 605
 606   if (state_ != kPlaying)
 607     return;
 608
 609   DCHECK(!renderer_ended_);
 610   renderer_ended_ = true;
 611
 612   RunEndedCallbackIfNeeded();
 613 }
 614
 615 void Pipeline::OnTextRendererEnded() {
 616   DCHECK(task_runner_->BelongsToCurrentThread());
 617   media_log_->AddEvent(media_log_->CreateEvent(MediaLogEvent::TEXT_ENDED));
 618
 619   if (state_ != kPlaying)
 620     return;
 621
 622   DCHECK(!text_renderer_ended_);
 623   text_renderer_ended_ = true;
 624
 625   RunEndedCallbackIfNeeded();
 626 }
 627
 628 void Pipeline::RunEndedCallbackIfNeeded() {
 629   DCHECK(task_runner_->BelongsToCurrentThread());
 630
 631   if (renderer_ && !renderer_ended_)
 632     return;
 633
 634   if (text_renderer_ && text_renderer_->HasTracks() && !text_renderer_ended_)
 635     return;
 636
 637   DCHECK_EQ(status_, PIPELINE_OK);
 638   ended_cb_.Run();
 639 }
 640
 641 scoped_ptr<TextRenderer> Pipeline::CreateTextRenderer() {
 642   DCHECK(task_runner_->BelongsToCurrentThread());
 643
 644   const CommandLine* cmd_line = CommandLine::ForCurrentProcess();
 645   if (!cmd_line->HasSwitch(switches::kEnableInbandTextTracks))
 646     return scoped_ptr<media::TextRenderer>();
 647
 648   return scoped_ptr<media::TextRenderer>(new media::TextRenderer(
 649       task_runner_,
 650       base::Bind(&Pipeline::OnAddTextTrack, weak_factory_.GetWeakPtr())));
 651 }
 652
 653 void Pipeline::AddTextStreamTask(DemuxerStream* text_stream,
 654                                  const TextTrackConfig& config) {
 655   DCHECK(task_runner_->BelongsToCurrentThread());
 656   // TODO(matthewjheaney): fix up text_ended_ when text stream
 657   // is added (http://crbug.com/321446).
 658   if (text_renderer_)
 659     text_renderer_->AddTextStream(text_stream, config);
 660 }
 661
 662 void Pipeline::RemoveTextStreamTask(DemuxerStream* text_stream) {
 663   DCHECK(task_runner_->BelongsToCurrentThread());
 664   if (text_renderer_)
 665     text_renderer_->RemoveTextStream(text_stream);
 666 }
 667
 668 void Pipeline::OnAddTextTrack(const TextTrackConfig& config,
 669                               const AddTextTrackDoneCB& done_cb) {
 670   DCHECK(task_runner_->BelongsToCurrentThread());
 671   add_text_track_cb_.Run(config, done_cb);
 672 }
 673
 674 void Pipeline::InitializeDemuxer(const PipelineStatusCB& done_cb) {
 675   DCHECK(task_runner_->BelongsToCurrentThread());
 676   demuxer_->Initialize(this, done_cb, text_renderer_);
 677 }
 678
 679 void Pipeline::InitializeRenderer(const base::Closure& done_cb) {
 680   DCHECK(task_runner_->BelongsToCurrentThread());
 681
 682   if (!demuxer_->GetStream(DemuxerStream::AUDIO) &&
 683       !demuxer_->GetStream(DemuxerStream::VIDEO)) {
 684     {
 685       base::AutoLock auto_lock(lock_);
 686       renderer_.reset();
 687     }
 688     OnError(PIPELINE_ERROR_COULD_NOT_RENDER);
 689     return;
 690   }
 691
 692   base::WeakPtr<Pipeline> weak_this = weak_factory_.GetWeakPtr();
 693   renderer_->Initialize(
 694       done_cb,
 695       base::Bind(&Pipeline::OnUpdateStatistics, weak_this),
 696       base::Bind(&Pipeline::OnRendererEnded, weak_this),
 697       base::Bind(&Pipeline::OnError, weak_this),
 698       base::Bind(&Pipeline::BufferingStateChanged, weak_this));
 699 }
 700
 701 void Pipeline::ReportMetadata() {
 702   DCHECK(task_runner_->BelongsToCurrentThread());
 703   PipelineMetadata metadata;
 704   metadata.has_audio = renderer_->HasAudio();
 705   metadata.has_video = renderer_->HasVideo();
 706   metadata.timeline_offset = demuxer_->GetTimelineOffset();
 707   DemuxerStream* stream = demuxer_->GetStream(DemuxerStream::VIDEO);
 708   if (stream) {
 709     metadata.natural_size = stream->video_decoder_config().natural_size();
 710     metadata.video_rotation = stream->video_rotation();
 711   }
 712   metadata_cb_.Run(metadata);
 713 }
 714
 715 void Pipeline::BufferingStateChanged(BufferingState new_buffering_state) {
 716   DVLOG(1) << __FUNCTION__ << "(" << new_buffering_state << ") ";
 717   DCHECK(task_runner_->BelongsToCurrentThread());
 718   buffering_state_cb_.Run(new_buffering_state);
 719 }
 720
 721 }  // namespace media