Limit the number of ARC codec

chrome/gpu/arc_gpu_video_decode_accelerator.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 "chrome/gpu/arc_gpu_video_decode_accelerator.h"
 
 #include "base/callback_helpers.h"
 #include "base/logging.h"
 #include "base/numerics/safe_math.h"
 #include "base/run_loop.h"
 #include "content/public/gpu/gpu_video_decode_accelerator_factory.h"
 #include "media/base/video_frame.h"
 
 namespace chromeos {
 namespace arc {
 
+namespace {
+
+// An arbitrary chosen limit of the number of buffers. The number of
+// buffers used is requested from the untrusted client side.
+const size_t kMaxBufferCount = 128;
+
+// Maximum number of concurrent ARC codec.
+// Currently we have no way to know the resources are not enough to create more
+// VDA. Arbitrarily chosen a reasonable constant as the limit.
+const int kMaxArcCodecCount = 8;
+
+}  // anonymous namespace
+
+// Since ArcGpuVideoDecodeAccelerator only works in the same thread, it's safe
+// to access this variable without lock.
+int ArcGpuVideoDecodeAccelerator::arc_codec_count_ = 0;
+
 ArcGpuVideoDecodeAccelerator::InputRecord::InputRecord(
     int32_t bitstream_buffer_id,
     uint32_t buffer_index,
     int64_t timestamp)
     : bitstream_buffer_id(bitstream_buffer_id),
       buffer_index(buffer_index),
       timestamp(timestamp) {}
 
 ArcGpuVideoDecodeAccelerator::InputBufferInfo::InputBufferInfo() = default;
 
 ArcGpuVideoDecodeAccelerator::InputBufferInfo::InputBufferInfo(
     InputBufferInfo&& other) = default;
 
 ArcGpuVideoDecodeAccelerator::InputBufferInfo::~InputBufferInfo() = default;
 
 ArcGpuVideoDecodeAccelerator::OutputBufferInfo::OutputBufferInfo() = default;
 
 ArcGpuVideoDecodeAccelerator::OutputBufferInfo::OutputBufferInfo(
     OutputBufferInfo&& other) = default;
 
 ArcGpuVideoDecodeAccelerator::OutputBufferInfo::~OutputBufferInfo() = default;
 
 ArcGpuVideoDecodeAccelerator::ArcGpuVideoDecodeAccelerator()
     : arc_client_(nullptr),
       next_bitstream_buffer_id_(0),
       output_pixel_format_(media::PIXEL_FORMAT_UNKNOWN),
       output_buffer_size_(0) {}
 
-ArcGpuVideoDecodeAccelerator::~ArcGpuVideoDecodeAccelerator() {}
+ArcGpuVideoDecodeAccelerator::~ArcGpuVideoDecodeAccelerator() {
+  if (vda_) {

[Pawel Osciak, 2016/06/03 03:56:18]

How do we guarantee this happens on the correct thread? Could we at least have a
DCHECK please?

[kcwu, 2016/06/03 13:14:14]

Done.

+    arc_codec_count_--;
+  }
+}
 
-namespace {
-
-// An arbitrary chosen limit of the number of buffers. The number of
-// buffers used is requested from the untrusted client side.
-const size_t kMaxBufferCount = 128;
-
-}  // anonymous namespace
-
-bool ArcGpuVideoDecodeAccelerator::Initialize(
+ArcVideoAccelerator::Error ArcGpuVideoDecodeAccelerator::Initialize(
     const Config& config,
     ArcVideoAccelerator::Client* client) {
   DVLOG(5) << "Initialize(device=" << config.device_type
            << ", input_pixel_format=" << config.input_pixel_format
            << ", num_input_buffers=" << config.num_input_buffers << ")";
   DCHECK(thread_checker_.CalledOnValidThread());
   if (config.device_type != Config::DEVICE_DECODER)
-    return false;
+    return INVALID_ARGUMENT;
   DCHECK(client);
 
   if (arc_client_) {
     DLOG(ERROR) << "Re-Initialize() is not allowed";
-    return false;
+    return ILLEGAL_STATE;
+  }
+
+  if (arc_codec_count_ >= kMaxArcCodecCount) {
+    LOG(WARNING) << "Reject to Initialize() due to too many ARC codec in use: "
+                 << arc_codec_count_;
+    return INSUFFICIENT_RESOURCES;
   }
 
   arc_client_ = client;
 
   if (config.num_input_buffers > kMaxBufferCount) {
     DLOG(ERROR) << "Request too many buffers: " << config.num_input_buffers;
-    return false;
+    return INVALID_ARGUMENT;
   }
   input_buffer_info_.resize(config.num_input_buffers);
 
   media::VideoDecodeAccelerator::Config vda_config;
   switch (config.input_pixel_format) {
     case HAL_PIXEL_FORMAT_H264:
       vda_config.profile = media::H264PROFILE_MAIN;
       break;
     case HAL_PIXEL_FORMAT_VP8:
       vda_config.profile = media::VP8PROFILE_ANY;
       break;
     default:
       DLOG(ERROR) << "Unsupported input format: " << config.input_pixel_format;
-      return false;
+      return INVALID_ARGUMENT;
   }
   vda_config.output_mode =
       media::VideoDecodeAccelerator::Config::OutputMode::IMPORT;
 
   std::unique_ptr<content::GpuVideoDecodeAcceleratorFactory> vda_factory =
       content::GpuVideoDecodeAcceleratorFactory::CreateWithNoGL();
   vda_ = vda_factory->CreateVDA(this, vda_config);
   if (!vda_) {
     DLOG(ERROR) << "Failed to create VDA.";
-    return false;
+    return PLATFORM_FAILURE;
   }
-  return true;
+
+  arc_codec_count_++;
+  DVLOG(5) << "Number of VDA in use: " << arc_codec_count_;
+
+  return NO_ERROR;
 }
 
 void ArcGpuVideoDecodeAccelerator::SetNumberOfOutputBuffers(size_t number) {
   DVLOG(5) << "SetNumberOfOutputBuffers(" << number << ")";
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!vda_) {
     DLOG(ERROR) << "VDA not initialized";
     return;
   }
 
@@ skipping 348 matching lines @@
       }
       return true;
     default:
       DLOG(ERROR) << "Invalid port: " << port;
       return false;
   }
 }
 
 }  // namespace arc
 }  // namespace chromeos