Implement disabling and enabling media tracks

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"
@@ skipping 39 matching lines @@
   void Suspend();
   void Resume(std::unique_ptr<Renderer> renderer, base::TimeDelta time);
   void SetPlaybackRate(double playback_rate);
   void SetVolume(float volume);
   base::TimeDelta GetMediaTime() const;
   Ranges<base::TimeDelta> GetBufferedTimeRanges() const;
   bool DidLoadingProgress();
   PipelineStatistics GetStatistics() const;
   void SetCdm(CdmContext* cdm_context, const CdmAttachedCB& cdm_attached_cb);
 
+  // |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);
+
  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 147 matching lines @@
   }
 
   media_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&RendererWrapper::Start,
                  base::Unretained(renderer_wrapper_.get()), demuxer,
                  base::Passed(&renderer), base::Passed(&text_renderer),
                  weak_factory_.GetWeakPtr()));
 }
 
+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(
+    const std::vector<MediaTrack::Id>& selectedTrackId) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  media_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&RendererWrapper::OnSelectedVideoTrackChanged,
+                 base::Unretained(renderer_wrapper_.get()), selectedTrackId));
+}
+
 void PipelineImpl::Stop() {
   DVLOG(2) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!IsRunning()) {
     DVLOG(2) << "Media pipeline isn't running. Ignoring Stop()";
     return;
   }
 
   if (media_task_runner_->BelongsToCurrentThread()) {
@@ skipping 275 matching lines @@
   media_log_->AddEvent(media_log_->CreateEvent(MediaLogEvent::ENDED));
 
   if (state_ != kPlaying)
     return;
 
   DCHECK(!renderer_ended_);
   renderer_ended_ = true;
   RunEndedCallbackIfNeeded();
 }
 
+void PipelineImpl::RendererWrapper::OnEnabledAudioTracksChanged(
+    const std::vector<MediaTrack::Id>& enabledTrackIds) {
+  DCHECK(media_task_runner_->BelongsToCurrentThread());
+
+  // This might happen at the very beginning of the media playback, when the
+  // first video track gets selected by default before the playback has been
+  // started, so we don't need to react to this.
+  if (!demuxer_ || !shared_state_.renderer) {
+    return;
+  }
+
+  base::TimeDelta currTime = (state_ == kPlaying)
+                                 ? shared_state_.renderer->GetMediaTime()
+                                 : start_timestamp_;
+  demuxer_->OnEnabledAudioTracksChanged(enabledTrackIds, currTime);
+}
+
+void PipelineImpl::RendererWrapper::OnSelectedVideoTrackChanged(
+    const std::vector<MediaTrack::Id>& selectedTrackId) {
+  DCHECK(media_task_runner_->BelongsToCurrentThread());
+
+  // This might happen at the very beginning of the media playback, when the
+  // first video track gets selected by default before the playback has been

[chcunningham, 2016/06/24 23:32:55]

What if something other than the first/default track is selected prior to
starting playback? Should we save the selection and apply once the demuxer comes
available? 

I'm not sure this is possible, but from a quick glance it seems it may sometimes
take a moment for the async initializition of the data_source in WMPI to
complete, meaning we may have a window of opportunity for non-default tracks to
be enabled.

+  // started, so we don't need to react to this.
+  if (!demuxer_ || !shared_state_.renderer) {
+    return;
+  }
+
+  base::TimeDelta currTime = (state_ == kPlaying)
+                                 ? shared_state_.renderer->GetMediaTime()
+                                 : start_timestamp_;
+  demuxer_->OnSelectedVideoTrackChanged(selectedTrackId, currTime);
+}
+
 void PipelineImpl::RendererWrapper::OnStatisticsUpdate(
     const PipelineStatistics& stats) {
   DVLOG(3) << __FUNCTION__;
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
   base::AutoLock auto_lock(shared_state_lock_);
   shared_state_.statistics.audio_bytes_decoded += stats.audio_bytes_decoded;
   shared_state_.statistics.video_bytes_decoded += stats.video_bytes_decoded;
   shared_state_.statistics.video_frames_decoded += stats.video_frames_decoded;
   shared_state_.statistics.video_frames_dropped += stats.video_frames_dropped;
@@ skipping 695 matching lines @@
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   base::AutoLock auto_lock(shared_state_lock_);
   if (shared_state_.suspend_timestamp != kNoTimestamp())
     return shared_state_.suspend_timestamp;
   return shared_state_.renderer ? shared_state_.renderer->GetMediaTime()
                                 : base::TimeDelta();
 }
 
 }  // namespace media