WIP - WebMediaPlayer switch media renderer.

media/base/pipeline_impl.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/base/pipeline_impl.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/synchronization/lock.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread_task_runner_handle.h"
+#include "media/base/audio_decoder_config.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/demuxer.h"
 #include "media/base/media_log.h"
 #include "media/base/media_switches.h"
 #include "media/base/renderer.h"
 #include "media/base/renderer_client.h"
 #include "media/base/serial_runner.h"
 #include "media/base/text_renderer.h"
 #include "media/base/text_track_config.h"
 #include "media/base/timestamp_constants.h"
@@ skipping 29 matching lines @@
 
   // |enabledTrackIds| contains track ids of enabled audio tracks.
   void OnEnabledAudioTracksChanged(
       const std::vector<MediaTrack::Id>& enabledTrackIds);
 
   // |trackId| either empty, which means no video track is selected, or contain
   // one element - the selected video track id.
   void OnSelectedVideoTrackChanged(
       const std::vector<MediaTrack::Id>& selectedTrackId);
 
+  // Get current video/audio configure.
+  VideoDecoderConfig GetVideoDecoderConfig() const;
+  AudioDecoderConfig GetAudioDecoderConfig() const;
+
  private:
   // Contains state shared between main and media thread.
   // Main thread can only read. Media thread can both - read and write.
   // So it is not necessary to lock when reading from the media thread.
   // This struct should only contain state that is not immediately needed by
   // PipelineClient and can be cached on the media thread until queried.
   // Alternatively we could cache it on the main thread by posting the
   // notification to the main thread. But some of the state change notifications
   // (OnStatisticsUpdate and OnBufferedTimeRangesChanged) arrive much more
   // frequently than needed. Posting all those notifications to the main thread
@@ skipping 84 matching lines @@
   // reset the pipeline state, and restore this to PIPELINE_OK.
   PipelineStatus status_;
 
   // Whether we've received the audio/video/text ended events.
   bool renderer_ended_;
   bool text_renderer_ended_;
 
   // Series of tasks to Start(), Seek(), and Resume().
   std::unique_ptr<SerialRunner> pending_callbacks_;
 
+  // Current audio/video decoder config.
+  AudioDecoderConfig audio_decoder_config_;
+  VideoDecoderConfig video_decoder_config_;
+
   base::WeakPtr<RendererWrapper> weak_this_;
   base::WeakPtrFactory<RendererWrapper> weak_factory_;
   DISALLOW_COPY_AND_ASSIGN(RendererWrapper);
 };
 
 PipelineImpl::RendererWrapper::RendererWrapper(
     scoped_refptr<base::SingleThreadTaskRunner> media_task_runner,
     scoped_refptr<MediaLog> media_log)
     : media_task_runner_(std::move(media_task_runner)),
       main_task_runner_(base::ThreadTaskRunnerHandle::Get()),
@@ skipping 362 matching lines @@
   media_log_->AddEvent(media_log_->CreateEvent(MediaLogEvent::ENDED));
 
   if (state_ != kPlaying)
     return;
 
   DCHECK(!renderer_ended_);
   renderer_ended_ = true;
   CheckPlaybackEnded();
 }
 
+VideoDecoderConfig PipelineImpl::RendererWrapper::GetVideoDecoderConfig()
+    const {
+  return video_decoder_config_;
+}
+
+AudioDecoderConfig PipelineImpl::RendererWrapper::GetAudioDecoderConfig()

[miu, 2016/09/14 20:59:27]

base::Optional<AudioDecoderConfig>
PipelineImpl::RendererWrapper::GetAudioDecoderConfig() const {
  base::AutoLock autolock(&lock_);
  if (the var was set)
    return audio_decoder_config_;
  else
    return base::nullopt;
}

+    const {
+  return audio_decoder_config_;
+}
+
 void PipelineImpl::OnEnabledAudioTracksChanged(
     const std::vector<MediaTrack::Id>& enabledTrackIds) {
   DCHECK(thread_checker_.CalledOnValidThread());
   media_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&RendererWrapper::OnEnabledAudioTracksChanged,
                  base::Unretained(renderer_wrapper_.get()), enabledTrackIds));
 }
 
 void PipelineImpl::OnSelectedVideoTrackChanged(
@@ skipping 252 matching lines @@
 void PipelineImpl::RendererWrapper::InitializeRenderer(
     const PipelineStatusCB& done_cb) {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
   if (!demuxer_->GetStream(DemuxerStream::AUDIO) &&
       !demuxer_->GetStream(DemuxerStream::VIDEO)) {
     done_cb.Run(PIPELINE_ERROR_COULD_NOT_RENDER);
     return;
   }
 
+  DemuxerStream* stream = demuxer_->GetStream(DemuxerStream::AUDIO);
+  if (stream)
+    audio_decoder_config_ = stream->audio_decoder_config();
+  stream = demuxer_->GetStream(DemuxerStream::VIDEO);
+  if (stream)
+    video_decoder_config_ = stream->video_decoder_config();
+
   if (cdm_context_)
     shared_state_.renderer->SetCdm(cdm_context_,
                                    base::Bind(&IgnoreCdmAttached));
 
   shared_state_.renderer->Initialize(demuxer_, this, done_cb);
 }
 
 void PipelineImpl::RendererWrapper::DestroyRenderer() {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
@@ skipping 415 matching lines @@
 
 void PipelineImpl::OnSuspendDone() {
   DVLOG(3) << __func__;
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(IsRunning());
 
   DCHECK(!suspend_cb_.is_null());
   base::ResetAndReturn(&suspend_cb_).Run(PIPELINE_OK);
 }
 
+VideoDecoderConfig PipelineImpl::GetVideoDecoderConfig() const {
+  if (!renderer_wrapper_)
+    return VideoDecoderConfig();
+  return renderer_wrapper_->GetVideoDecoderConfig();
+}
+
+AudioDecoderConfig PipelineImpl::GetAudioDecoderConfig() const {
+  if (!renderer_wrapper_)
+    return AudioDecoderConfig();
+  return renderer_wrapper_->GetAudioDecoderConfig();
+}
+
 }  // namespace media