[Chromecast] Limit number of concurrent audio and video decoders

chromecast/media/cma/backend/media_pipeline_backend_wrapper.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_wrapper.h"
 
 #include "base/logging.h"
 #include "chromecast/media/cma/backend/media_pipeline_backend_manager.h"
 
 namespace chromecast {
 namespace media {
 
 MediaPipelineBackendWrapper::MediaPipelineBackendWrapper(
     std::unique_ptr<MediaPipelineBackend> backend,
     int stream_type,
     float stream_type_volume,
     MediaPipelineBackendManager* backend_manager)
     : backend_(std::move(backend)),
       stream_type_(stream_type),
       audio_decoder_wrapper_(nullptr),
       stream_type_volume_(stream_type_volume),
       is_initialized_(false),
+      have_video_decoder_(false),
       backend_manager_(backend_manager) {
   DCHECK(backend_);
 }
 
 MediaPipelineBackendWrapper::~MediaPipelineBackendWrapper() {
   backend_manager_->OnMediaPipelineBackendDestroyed(this);
+
+  if (audio_decoder_wrapper_)
+    backend_manager_->DecrementAudioDecoderCount();
+  if (have_video_decoder_)
+    backend_manager_->DecrementVideoDecoderCount();

[kmackay, 2016/07/22 16:50:07]

Can't we have multiple video decoders (for DolbyVision?)

[kmackay, 2016/07/22 16:53:08]

I think, since the API allows you to create multiple video/audio decoders from a
single backend instance, you should track how many have been created in this
class, and then decrement by N in the destructor here.

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

DV is handled by a single video decoder.  You can see the single video decoder
assumption baked into MediaPipelinImpl.

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

Although the API does, the implementation doesn't allow multiple audio decoders
(see audio_decoder_wrapper_ here).  I added a DCHECK to enforce a similar thing
for video, which matches current usage.

i.e. if we want to support multiple decoders in a single backend in future, we
will have other work to do anyway.  At that point we can change this to count
them as you suggest.

 }
 
 MediaPipelineBackend::AudioDecoder*
 MediaPipelineBackendWrapper::CreateAudioDecoder() {
   DCHECK(!is_initialized_);
   if (audio_decoder_wrapper_)
     return nullptr;
 
+  if (!backend_manager_->IncrementAudioDecoderCount())
+    return nullptr;
+
   audio_decoder_wrapper_.reset(
       new AudioDecoderWrapper(backend_->CreateAudioDecoder()));
   return audio_decoder_wrapper_.get();
 }
 
 MediaPipelineBackend::VideoDecoder*
 MediaPipelineBackendWrapper::CreateVideoDecoder() {
   DCHECK(!is_initialized_);
+  if (!backend_manager_->IncrementVideoDecoderCount())
+    return nullptr;
+  have_video_decoder_ = true;
+
   return backend_->CreateVideoDecoder();
 }
 
 bool MediaPipelineBackendWrapper::Initialize() {
   DCHECK(!is_initialized_);
   is_initialized_ = backend_->Initialize();
   if (is_initialized_ && audio_decoder_wrapper_)
     audio_decoder_wrapper_->SetStreamTypeVolume(stream_type_volume_);
 
   return is_initialized_;
@@ skipping 29 matching lines @@
 
 void MediaPipelineBackendWrapper::SetStreamTypeVolume(
     float stream_type_volume) {
   stream_type_volume_ = stream_type_volume;
   if (is_initialized_ && audio_decoder_wrapper_)
     audio_decoder_wrapper_->SetStreamTypeVolume(stream_type_volume_);
 }
 
 }  // namespace media
 }  // namespace chromecast