Introduce a client minimum picture pool size

content/common/gpu/media/v4l2_slice_video_decode_accelerator.cc

 // Copyright 2015 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 <fcntl.h>
 #include <linux/videodev2.h>
 #include <poll.h>
 #include <sys/eventfd.h>
 #include <sys/ioctl.h>
 #include <sys/mman.h>
@@ skipping 376 matching lines @@
       io_client_(io_client),
       device_(device),
       decoder_thread_("V4L2SliceVideoDecodeAcceleratorThread"),
       device_poll_thread_("V4L2SliceVideoDecodeAcceleratorDevicePollThread"),
       input_streamon_(false),
       input_buffer_queued_count_(0),
       output_streamon_(false),
       output_buffer_queued_count_(0),
       video_profile_(media::VIDEO_CODEC_PROFILE_UNKNOWN),
       output_format_fourcc_(0),
+      min_picture_count_(0),
       state_(kUninitialized),
       decoder_flushing_(false),
       decoder_resetting_(false),
       surface_set_change_pending_(false),
       picture_clearing_count_(0),
       pictures_assigned_(false, false),
       make_context_current_(make_context_current),
       egl_display_(egl_display),
       egl_context_(egl_context),
       weak_this_factory_(this) {
@@ skipping 20 matching lines @@
   }
 
   if (client_) {
     client_->NotifyError(error);
     client_ptr_factory_.reset();
   }
 }
 
 bool V4L2SliceVideoDecodeAccelerator::Initialize(
     media::VideoCodecProfile profile,
+    uint32_t min_picture_count,
     VideoDecodeAccelerator::Client* client) {
   DVLOGF(3) << "profile: " << profile;
   DCHECK(child_task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(state_, kUninitialized);
 
   client_ptr_factory_.reset(
       new base::WeakPtrFactory<VideoDecodeAccelerator::Client>(client));
   client_ = client_ptr_factory_->GetWeakPtr();
 
   video_profile_ = profile;
+  min_picture_count_ = min_picture_count;
 
   if (video_profile_ >= media::H264PROFILE_MIN &&
       video_profile_ <= media::H264PROFILE_MAX) {
     h264_accelerator_.reset(new V4L2H264Accelerator(this));
     decoder_.reset(new H264Decoder(h264_accelerator_.get()));
   } else if (video_profile_ >= media::VP8PROFILE_MIN &&
              video_profile_ <= media::VP8PROFILE_MAX) {
     vp8_accelerator_.reset(new V4L2VP8Accelerator(this));
     decoder_.reset(new VP8Decoder(vp8_accelerator_.get()));
   } else {
@@ skipping 219 matching lines @@
 
 bool V4L2SliceVideoDecodeAccelerator::CreateOutputBuffers() {
   DVLOGF(3);
   DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread());
   DCHECK(!output_streamon_);
   DCHECK(output_buffer_map_.empty());
   DCHECK(surfaces_at_display_.empty());
   DCHECK(surfaces_at_device_.empty());
 
   visible_size_ = decoder_->GetPicSize();
-  size_t num_pictures = decoder_->GetRequiredNumOfPictures();
+  size_t num_pictures = std::max(min_picture_count_,
+                                 static_cast<uint32_t>(
+                                     decoder_->GetRequiredNumOfPictures()));
 
   DCHECK_GT(num_pictures, 0u);
   DCHECK(!visible_size_.IsEmpty());
 
   struct v4l2_format format;
   memset(&format, 0, sizeof(format));
   format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
   format.fmt.pix_mp.pixelformat = output_format_fourcc_;
   format.fmt.pix_mp.width = visible_size_.width();
   format.fmt.pix_mp.height = visible_size_.height();
@@ skipping 1814 matching lines @@
   if (!device)
     return SupportedProfiles();
 
   const uint32_t supported_formats[] = {
       V4L2_PIX_FMT_H264_SLICE, V4L2_PIX_FMT_VP8_FRAME};
   return device->GetSupportedDecodeProfiles(arraysize(supported_formats),
                                             supported_formats);
 }
 
 }  // namespace content