[Chromecast] Limit number of concurrent audio and video decoders

chromecast/media/cma/backend/media_pipeline_backend_manager.cc

 // Copyright 2016 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 "chromecast/media/cma/backend/media_pipeline_backend_manager.h"
 
 #include <algorithm>
 
 #include "base/memory/ptr_util.h"
 #include "chromecast/media/cma/backend/media_pipeline_backend_wrapper.h"
 #include "chromecast/public/cast_media_shlib.h"
 
 namespace chromecast {
 namespace media {
 
 MediaPipelineBackendManager::MediaPipelineBackendManager(
     scoped_refptr<base::SingleThreadTaskRunner> media_task_runner)
-    : media_task_runner_(std::move(media_task_runner)) {
-}
+    : media_task_runner_(std::move(media_task_runner)),
+      audio_decoder_count_(0),
+      video_decoder_count_(0) {}
 
 MediaPipelineBackendManager::~MediaPipelineBackendManager() {
 }
 
 std::unique_ptr<MediaPipelineBackend>
 MediaPipelineBackendManager::CreateMediaPipelineBackend(
     const media::MediaPipelineDeviceParams& params) {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
   return CreateMediaPipelineBackend(params, 0);
 }
 
 std::unique_ptr<MediaPipelineBackend>
 MediaPipelineBackendManager::CreateMediaPipelineBackend(
     const media::MediaPipelineDeviceParams& params,
     int stream_type) {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
   std::unique_ptr<MediaPipelineBackend> backend_ptr(
       new MediaPipelineBackendWrapper(
           base::WrapUnique(
               media::CastMediaShlib::CreateMediaPipelineBackend(params)),
           stream_type, GetVolumeMultiplier(stream_type), this));
   media_pipeline_backends_.push_back(backend_ptr.get());
   return backend_ptr;
 }
 
+bool MediaPipelineBackendManager::IncrementAudioDecoderCount() {

[alokp, 2016/07/22 16:46:44]

nit: You may want to merge the implementation for audio/video by passing decoder
type into Increment/DecrementDecoderCount(DecoderType).

[halliwell, 2016/07/22 17:16:29]

Done.

+  DCHECK(media_task_runner_->BelongsToCurrentThread());
+  if (audio_decoder_count_ >= 2) {
+    LOG(WARNING) << "AudioDecoder limit reached";
+    return false;
+  }
+
+  ++audio_decoder_count_;
+  return true;
+}
+
+bool MediaPipelineBackendManager::IncrementVideoDecoderCount() {
+  DCHECK(media_task_runner_->BelongsToCurrentThread());
+  if (video_decoder_count_ >= 1) {
+    LOG(WARNING) << "VideoDecoder limit reached";
+    return false;
+  }
+
+  ++video_decoder_count_;
+  return true;
+}
+
+void MediaPipelineBackendManager::DecrementAudioDecoderCount() {
+  DCHECK(media_task_runner_->BelongsToCurrentThread());
+  audio_decoder_count_--;

[alokp, 2016/07/22 16:46:44]

DCHECK(audio_decoder_count_ > 0)

[halliwell, 2016/07/22 17:16:29]

Done.

+}
+
+void MediaPipelineBackendManager::DecrementVideoDecoderCount() {
+  DCHECK(media_task_runner_->BelongsToCurrentThread());
+  video_decoder_count_--;

[alokp, 2016/07/22 16:46:44]

ditto

[halliwell, 2016/07/22 17:16:29]

Done.

+}
+
 void MediaPipelineBackendManager::OnMediaPipelineBackendDestroyed(
     const MediaPipelineBackend* backend) {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
   media_pipeline_backends_.erase(
       std::remove(media_pipeline_backends_.begin(),
                   media_pipeline_backends_.end(), backend),
       media_pipeline_backends_.end());
 }
 
 void MediaPipelineBackendManager::SetVolumeMultiplier(int stream_type,
@@ skipping 17 matching lines @@
   auto it = volume_by_stream_type_.find(stream_type);
   if (it == volume_by_stream_type_.end()) {
     return 1.0;
   } else {
     return it->second;
   }
 }
 
 }  // namespace media
 }  // namespace chromecast