Introduce a client minimum picture pool size

content/common/gpu/media/android_video_decode_accelerator.cc

 // Copyright (c) 2013 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/android_video_decode_accelerator.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
@@ skipping 52 matching lines @@
 }
 
 static inline const base::TimeDelta NoWaitTimeOut() {
   return base::TimeDelta::FromMicroseconds(0);
 }
 
 AndroidVideoDecodeAccelerator::AndroidVideoDecodeAccelerator(
     const base::WeakPtr<gpu::gles2::GLES2Decoder> decoder,
     const base::Callback<bool(void)>& make_context_current)
     : client_(NULL),
+      num_picture_buffers_(kNumPictureBuffers),
       make_context_current_(make_context_current),
       codec_(media::kCodecH264),
       state_(NO_ERROR),
       surface_texture_id_(0),
       picturebuffers_requested_(false),
       gl_decoder_(decoder),
       weak_this_factory_(this) {}
 
 AndroidVideoDecodeAccelerator::~AndroidVideoDecodeAccelerator() {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 bool AndroidVideoDecodeAccelerator::Initialize(media::VideoCodecProfile profile,
+                                               uint32 min_picture_count,
                                                Client* client) {
   DCHECK(!media_codec_);
   DCHECK(thread_checker_.CalledOnValidThread());
 
   client_ = client;
+  num_picture_buffers_ = std::max(min_picture_count,
+                                  static_cast<uint32>(kNumPictureBuffers));
 
   if (profile == media::VP8PROFILE_ANY) {
     codec_ = media::kCodecVP8;
   } else {
     // TODO(dwkang): enable H264 once b/8125974 is fixed.
     LOG(ERROR) << "Unsupported profile: " << profile;
     return false;
   }
 
   // Only consider using MediaCodec if it's likely backed by hardware.
@@ skipping 307 matching lines @@
                       INVALID_ARGUMENT);
     int32 id = buffers[i].id();
     output_picture_buffers_.insert(std::make_pair(id, buffers[i]));
     free_picture_ids_.push(id);
     // Since the client might be re-using |picture_buffer_id| values, forget
     // about previously-dismissed IDs now.  See ReusePictureBuffer() comment
     // about "zombies" for why we maintain this set in the first place.
     dismissed_picture_ids_.erase(id);
   }
 
-  RETURN_ON_FAILURE(output_picture_buffers_.size() == kNumPictureBuffers,
+  RETURN_ON_FAILURE(output_picture_buffers_.size() == num_picture_buffers_,
                     "Invalid picture buffers were passed.",
                     INVALID_ARGUMENT);
 
   DoIOTask();
 }
 
 void AndroidVideoDecodeAccelerator::ReusePictureBuffer(
     int32 picture_buffer_id) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
@@ skipping 92 matching lines @@
   if (copier_)
     copier_->Destroy();
   delete this;
 }
 
 bool AndroidVideoDecodeAccelerator::CanDecodeOnIOThread() {
   return false;
 }
 
 void AndroidVideoDecodeAccelerator::RequestPictureBuffers() {
-  client_->ProvidePictureBuffers(kNumPictureBuffers, size_, GL_TEXTURE_2D);
+  client_->ProvidePictureBuffers(num_picture_buffers_, size_, GL_TEXTURE_2D);
 }
 
 void AndroidVideoDecodeAccelerator::NotifyPictureReady(
     const media::Picture& picture) {
   client_->PictureReady(picture);
 }
 
 void AndroidVideoDecodeAccelerator::NotifyEndOfBitstreamBuffer(
     int input_buffer_id) {
   client_->NotifyEndOfBitstreamBuffer(input_buffer_id);
@@ skipping 22 matching lines @@
   }
   SupportedProfile profile;
   profile.profile = media::VP8PROFILE_ANY;
   profile.min_resolution.SetSize(16, 16);
   profile.max_resolution.SetSize(1920, 1088);
   profiles.push_back(profile);
   return profiles;
 }
 
 }  // namespace content