Introduce a client minimum picture pool size

content/common/gpu/media/dxva_video_decode_accelerator.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 "content/common/gpu/media/dxva_video_decode_accelerator.h"
 
 #if !defined(OS_WIN)
 #error This file should only be built on Windows.
 #endif   // !defined(OS_WIN)
 
@@ skipping 499 matching lines @@
 DXVAVideoDecodeAccelerator::PendingSampleInfo::~PendingSampleInfo() {}
 
 DXVAVideoDecodeAccelerator::DXVAVideoDecodeAccelerator(
     const base::Callback<bool(void)>& make_context_current,
     gfx::GLContext* gl_context)
     : client_(NULL),
       dev_manager_reset_token_(0),
       dx11_dev_manager_reset_token_(0),
       egl_config_(NULL),
       state_(kUninitialized),
+      num_picture_buffers_(kNumPictureBuffers),
       pictures_requested_(false),
       inputs_before_decode_(0),
       sent_drain_message_(false),
       make_context_current_(make_context_current),
       codec_(media::kUnknownVideoCodec),
       decoder_thread_("DXVAVideoDecoderThread"),
       pending_flush_(false),
       use_dx11_(false),
       dx11_video_format_converter_media_type_needs_init_(true),
       gl_context_(gl_context),
       weak_this_factory_(this) {
   weak_ptr_ = weak_this_factory_.GetWeakPtr();
   memset(&input_stream_info_, 0, sizeof(input_stream_info_));
   memset(&output_stream_info_, 0, sizeof(output_stream_info_));
 }
 
 DXVAVideoDecodeAccelerator::~DXVAVideoDecodeAccelerator() {
   client_ = NULL;
 }
 
 bool DXVAVideoDecodeAccelerator::Initialize(media::VideoCodecProfile profile,
-                                           Client* client) {
+                                            uint32_t min_picture_count,
+                                            Client* client) {
   client_ = client;
 
+  num_picture_buffers_ = std::max(min_picture_count,
+                                  static_cast<uint32_t>(kNumPictureBuffers));
+
   main_thread_task_runner_ = base::MessageLoop::current()->task_runner();
 
   bool profile_supported = false;
   for (const auto& supported_profile : kSupportedProfiles) {
     if (profile == supported_profile) {
       profile_supported = true;
       break;
     }
   }
   if (!profile_supported) {
@@ skipping 216 matching lines @@
                  base::Unretained(this), sample));
 }
 
 void DXVAVideoDecodeAccelerator::AssignPictureBuffers(
     const std::vector<media::PictureBuffer>& buffers) {
   DCHECK(main_thread_task_runner_->BelongsToCurrentThread());
 
   State state = GetState();
   RETURN_AND_NOTIFY_ON_FAILURE((state != kUninitialized),
       "Invalid state: " << state, ILLEGAL_STATE,);
-  RETURN_AND_NOTIFY_ON_FAILURE((kNumPictureBuffers == buffers.size()),
+  RETURN_AND_NOTIFY_ON_FAILURE((num_picture_buffers_ == buffers.size()),
       "Failed to provide requested picture buffers. (Got " << buffers.size() <<
-      ", requested " << kNumPictureBuffers << ")", INVALID_ARGUMENT,);
+      ", requested " << num_picture_buffers_ << ")", INVALID_ARGUMENT,);
 
   // Copy the picture buffers provided by the client to the available list,
   // and mark these buffers as available for use.
   for (size_t buffer_index = 0; buffer_index < buffers.size();
        ++buffer_index) {
     linked_ptr<DXVAPictureBuffer> picture_buffer =
         DXVAPictureBuffer::Create(*this, buffers[buffer_index], egl_config_);
     RETURN_AND_NOTIFY_ON_FAILURE(picture_buffer.get(),
         "Failed to allocate picture buffer", PLATFORM_FAILURE,);
 
@@ skipping 679 matching lines @@
   DCHECK(main_thread_task_runner_->BelongsToCurrentThread());
   if (client_)
     client_->NotifyResetDone();
 }
 
 void DXVAVideoDecodeAccelerator::RequestPictureBuffers(int width, int height) {
   DCHECK(main_thread_task_runner_->BelongsToCurrentThread());
   // This task could execute after the decoder has been torn down.
   if (GetState() != kUninitialized && client_) {
     client_->ProvidePictureBuffers(
-        kNumPictureBuffers,
+        num_picture_buffers_,
         gfx::Size(width, height),
         GL_TEXTURE_2D);
   }
 }
 
 void DXVAVideoDecodeAccelerator::NotifyPictureReady(
     int picture_buffer_id,
     int input_buffer_id,
     const gfx::Rect& picture_buffer_size) {
   DCHECK(main_thread_task_runner_->BelongsToCurrentThread());
@@ skipping 694 matching lines @@
     D3DSURFACE_DESC surface_desc;
     hr = surface->GetDesc(&surface_desc);
     RETURN_ON_HR_FAILURE(hr, "Failed to get surface description", false);
     *width = surface_desc.Width;
     *height = surface_desc.Height;
   }
   return true;
 }
 
 }  // namespace content