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 413 matching lines @@
   media_log_->AddEvent(media_log_->CreateEvent(MediaLogEvent::ENDED));
 
   if (state_ != kPlaying)
     return;
 
   DCHECK(!renderer_ended_);
   renderer_ended_ = true;
   CheckPlaybackEnded();
 }
 
+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::RendererWrapper::OnEnabledAudioTracksChanged(
+    const std::vector<MediaTrack::Id>& enabledTrackIds) {
+  DCHECK(media_task_runner_->BelongsToCurrentThread());
+
+  // Track status notifications might be delivered asynchronously. If we receive
+  // a notification when pipeline is stopped/shut down, it's safe to ignore it.
+  if (state_ == kStopping || state_ == kStopped) {
+    return;
+  }
+
+  DCHECK(demuxer_);
+  DCHECK(shared_state_.renderer);
+
+  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());
+
+  // Track status notifications might be delivered asynchronously. If we receive
+  // a notification when pipeline is stopped/shut down, it's safe to ignore it.
+  if (state_ == kStopping || state_ == kStopped) {
+    return;
+  }
+
+  DCHECK(demuxer_);
+  DCHECK(shared_state_.renderer);
+
+  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 458 matching lines @@
   seek_cb_.Reset();
   suspend_cb_.Reset();
   client_ = nullptr;
 
   // Invalidate self weak pointers effectively canceling all pending
   // notifications in the message queue.
   weak_factory_.InvalidateWeakPtrs();
 }
 
 void PipelineImpl::Seek(base::TimeDelta time, const PipelineStatusCB& seek_cb) {
-  DVLOG(2) << __FUNCTION__;
+  DVLOG(2) << __FUNCTION__ << " to " << time.InMicroseconds();
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!seek_cb.is_null());
 
   if (!IsRunning()) {
     DLOG(ERROR) << "Media pipeline isn't running. Ignoring Seek().";
     return;
   }
 
   DCHECK(seek_cb_.is_null());
   seek_cb_ = seek_cb;
@@ skipping 248 matching lines @@
 void PipelineImpl::OnSuspendDone(base::TimeDelta suspend_time) {
   DVLOG(3) << __FUNCTION__ << "(" << suspend_time.InMicroseconds() << ")";
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(IsRunning());
 
   DCHECK(!suspend_cb_.is_null());
   base::ResetAndReturn(&suspend_cb_).Run(PIPELINE_OK);
 }
 
 }  // namespace media