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 video client.

[Pawel Osciak, 2016/06/06 05:49:12]

s/client/clients/

[kcwu, 2016/06/06 06:53:12]

Done.

+// 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 kMaxConcurrentClient = 8;

[Pawel Osciak, 2016/06/06 05:49:13]

s/Client/Clients/

[kcwu, 2016/06/06 06:53:12]

Done.

+
+}  // anonymous namespace
+
+int ArcGpuVideoDecodeAccelerator::client_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() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  if (vda_) {
+    client_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::Result 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 (client_count_ >= kMaxConcurrentClient) {
+    LOG(WARNING) << "Reject to Initialize() due to too many clients: "
+                 << client_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;
+
+  client_count_++;
+  DVLOG(5) << "Number of concurrent ArcVideoAccelerator client: "

[Pawel Osciak, 2016/06/06 05:49:12]

s/client/clients/

[kcwu, 2016/06/06 06:53:12]

Done.

+           << client_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 275 matching lines @@
 void ArcGpuVideoDecodeAccelerator::NotifyFlushDone() {
   DCHECK(thread_checker_.CalledOnValidThread());
   arc_client_->OnFlushDone();
 }
 
 void ArcGpuVideoDecodeAccelerator::NotifyResetDone() {
   DCHECK(thread_checker_.CalledOnValidThread());
   arc_client_->OnResetDone();
 }
 
-static ArcVideoAccelerator::Error ConvertErrorCode(
+static ArcVideoAccelerator::Result ConvertErrorCode(
     media::VideoDecodeAccelerator::Error error) {
   switch (error) {
     case media::VideoDecodeAccelerator::ILLEGAL_STATE:
       return ArcVideoAccelerator::ILLEGAL_STATE;
     case media::VideoDecodeAccelerator::INVALID_ARGUMENT:
       return ArcVideoAccelerator::INVALID_ARGUMENT;
     case media::VideoDecodeAccelerator::UNREADABLE_INPUT:
       return ArcVideoAccelerator::UNREADABLE_INPUT;
     case media::VideoDecodeAccelerator::PLATFORM_FAILURE:
       return ArcVideoAccelerator::PLATFORM_FAILURE;
@@ skipping 52 matching lines @@
       }
       return true;
     default:
       DLOG(ERROR) << "Invalid port: " << port;
       return false;
   }
 }
 
 }  // namespace arc
 }  // namespace chromeos