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
28using base::TimeDelta;
29
30namespace media {
31
32Pipeline::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
53Pipeline::~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
64void 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
97void 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
104void 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
117bool Pipeline::IsRunning() const {
118  base::AutoLock auto_lock(lock_);
119  return running_;
120}
121
122float Pipeline::GetPlaybackRate() const {
123  base::AutoLock auto_lock(lock_);
124  return playback_rate_;
125}
126
127void 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
141float Pipeline::GetVolume() const {
142  base::AutoLock auto_lock(lock_);
143  return volume_;
144}
145
146void 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
160TimeDelta 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
169Ranges<TimeDelta> Pipeline::GetBufferedTimeRanges() const {
170  base::AutoLock auto_lock(lock_);
171  return buffered_time_ranges_;
172}
173
174TimeDelta Pipeline::GetMediaDuration() const {
175  base::AutoLock auto_lock(lock_);
176  return duration_;
177}
178
179bool Pipeline::DidLoadingProgress() {
180  base::AutoLock auto_lock(lock_);
181  bool ret = did_loading_progress_;
182  did_loading_progress_ = false;
183  return ret;
184}
185
186PipelineStatistics Pipeline::GetStatistics() const {
187  base::AutoLock auto_lock(lock_);
188  return statistics_;
189}
190
191void Pipeline::SetErrorForTesting(PipelineStatus status) {
192  OnError(status);
193}
194
195bool Pipeline::HasWeakPtrsForTesting() const {
196  DCHECK(task_runner_->BelongsToCurrentThread());
197  return weak_factory_.HasWeakPtrs();
198}
199
200void 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
209const 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
225Pipeline::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
252void Pipeline::OnDemuxerError(PipelineStatus error) {
253  task_runner_->PostTask(FROM_HERE,
254                         base::Bind(&Pipeline::ErrorChangedTask,
255                                    weak_factory_.GetWeakPtr(),
256                                    error));
257}
258
259void 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
268void 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
275void 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
285void 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
298void 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
307void 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.
375void 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
405void 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
428void 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
468void 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.
476void 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
484void 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
499void 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
535void 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
551void 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
561void 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
571void 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
602void 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
615void 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
628void 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
641scoped_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
653void 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
662void Pipeline::RemoveTextStreamTask(DemuxerStream* text_stream) {
663  DCHECK(task_runner_->BelongsToCurrentThread());
664  if (text_renderer_)
665    text_renderer_->RemoveTextStream(text_stream);
666}
667
668void 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
674void Pipeline::InitializeDemuxer(const PipelineStatusCB& done_cb) {
675  DCHECK(task_runner_->BelongsToCurrentThread());
676  demuxer_->Initialize(this, done_cb, text_renderer_);
677}
678
679void 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
701void 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
715void 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
722