Introduce a client minimum picture pool size

content/common/gpu/media/vt_video_decode_accelerator.cc

 // Copyright 2014 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 <algorithm>
 
 #include <CoreVideo/CoreVideo.h>
 #include <OpenGL/CGLIOSurface.h>
 #include <OpenGL/gl.h>
 
@@ skipping 273 matching lines @@
   return lhs->bitstream_id > rhs->bitstream_id;
 }
 
 VTVideoDecodeAccelerator::VTVideoDecodeAccelerator(
     CGLContextObj cgl_context,
     const base::Callback<bool(void)>& make_context_current)
     : cgl_context_(cgl_context),
       make_context_current_(make_context_current),
       client_(nullptr),
       state_(STATE_DECODING),
+      num_picture_buffers_(kNumPictureBuffers),
       format_(nullptr),
       session_(nullptr),
       last_sps_id_(-1),
       last_pps_id_(-1),
       gpu_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       decoder_thread_("VTDecoderThread"),
       weak_this_factory_(this) {
   DCHECK(!make_context_current_.is_null());
   callback_.decompressionOutputCallback = OutputThunk;
   callback_.decompressionOutputRefCon = this;
   weak_this_ = weak_this_factory_.GetWeakPtr();
 }
 
 VTVideoDecodeAccelerator::~VTVideoDecodeAccelerator() {
 }
 
 bool VTVideoDecodeAccelerator::Initialize(
     media::VideoCodecProfile profile,
+    uint32_t min_picture_count,
     Client* client) {
   DCHECK(gpu_thread_checker_.CalledOnValidThread());
   client_ = client;
 
+  num_picture_buffers_ = std::max(min_picture_count,
+                                  static_cast<uint32_t>(kNumPictureBuffers));
+
   if (!InitializeVideoToolbox())
     return false;
 
   bool profile_supported = false;
   for (const auto& supported_profile : kSupportedProfiles) {
     if (profile == supported_profile) {
       profile_supported = true;
       break;
     }
   }
@@ skipping 634 matching lines @@
     if (picture_size_ != frame.coded_size) {
       // Dismiss current pictures.
       for (int32_t picture_id : assigned_picture_ids_)
         client_->DismissPictureBuffer(picture_id);
       assigned_picture_ids_.clear();
       available_picture_ids_.clear();
 
       // Request new pictures.
       picture_size_ = frame.coded_size;
       client_->ProvidePictureBuffers(
-          kNumPictureBuffers, coded_size_, GL_TEXTURE_RECTANGLE_ARB);
+          num_picture_buffers_, coded_size_, GL_TEXTURE_RECTANGLE_ARB);
       return false;
     }
     if (!SendFrame(frame))
       return false;
   }
 
   return true;
 }
 
 bool VTVideoDecodeAccelerator::SendFrame(const Frame& frame) {
@@ skipping 109 matching lines @@
     SupportedProfile profile;
     profile.profile = supported_profile;
     profile.min_resolution.SetSize(16, 16);
     profile.max_resolution.SetSize(4096, 2160);
     profiles.push_back(profile);
   }
   return profiles;
 }
 
 }  // namespace content