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