Don't require VDAs to return all PictureBuffers at once.

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"
 #include "base/trace_event/trace_event.h"
 #include "content/common/gpu/gpu_channel.h"
+#include "content/common/gpu/media/android_copying_backing_strategy.h"
+#include "content/common/gpu/media/android_deferred_rendering_backing_strategy.h"
 #include "content/common/gpu/media/avda_return_on_failure.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 #include "media/base/bitstream_buffer.h"
 #include "media/base/limits.h"
 #include "media/base/timestamp_constants.h"
 #include "media/base/video_decoder_config.h"
 #include "media/video/picture.h"
 #include "ui/gl/android/scoped_java_surface.h"
 #include "ui/gl/android/surface_texture.h"
 #include "ui/gl/gl_bindings.h"
 
 #if defined(ENABLE_MOJO_MEDIA_IN_GPU_PROCESS)
 #include "media/base/media_keys.h"
 #include "media/mojo/services/mojo_cdm_service.h"
 #endif
 
 namespace content {
 
+// TODO(liberato): It is unclear if we have an issue with deadlock during
+// playback if we lower this.  Previously (crbug.com/176036), a deadlock
+// could occur during preroll.  More recent tests have shown some
+// instability with kNumPictureBuffers==2 with similar symptoms
+// during playback.  crbug.com/531588 .
+enum { kNumPictureBuffers = media::limits::kMaxVideoFrames + 1 };
+
 // Max number of bitstreams notified to the client with
 // NotifyEndOfBitstreamBuffer() before getting output from the bitstream.
 enum { kMaxBitstreamsNotifiedInAdvance = 32 };
 
 #if defined(ENABLE_MEDIA_PIPELINE_ON_ANDROID)
 // MediaCodec is only guaranteed to support baseline, but some devices may
 // support others. Advertise support for all H264 profiles and let the
 // MediaCodec fail when decoding if it's not actually supported. It's assumed
 // that consumers won't have software fallback for H264 on Android anyway.
 static const media::VideoCodecProfile kSupportedH264Profiles[] = {
   media::H264PROFILE_BASELINE,
   media::H264PROFILE_MAIN,
   media::H264PROFILE_EXTENDED,
   media::H264PROFILE_HIGH,
   media::H264PROFILE_HIGH10PROFILE,
   media::H264PROFILE_HIGH422PROFILE,
   media::H264PROFILE_HIGH444PREDICTIVEPROFILE,
   media::H264PROFILE_SCALABLEBASELINE,
   media::H264PROFILE_SCALABLEHIGH,
   media::H264PROFILE_STEREOHIGH,
   media::H264PROFILE_MULTIVIEWHIGH
 };
+
+#define BACKING_STRATEGY AndroidDeferredRenderingBackingStrategy
+#else
+#define BACKING_STRATEGY AndroidCopyingBackingStrategy
 #endif
 
 // Because MediaCodec is thread-hostile (must be poked on a single thread) and
 // has no callback mechanism (b/11990118), we must drive it by polling for
 // complete frames (and available input buffers, when the codec is fully
 // saturated).  This function defines the polling delay.  The value used is an
 // arbitrary choice that trades off CPU utilization (spinning) against latency.
 // Mirrors android_video_encode_accelerator.cc:EncodePollDelay().
 static inline const base::TimeDelta DecodePollDelay() {
   // An alternative to this polling scheme could be to dedicate a new thread
   // (instead of using the ChildThread) to run the MediaCodec, and make that
   // thread use the timeout-based flavor of MediaCodec's dequeue methods when it
   // believes the codec should complete "soon" (e.g. waiting for an input
   // buffer, or waiting for a picture when it knows enough complete input
   // pictures have been fed to saturate any internal buffering).  This is
   // speculative and it's unclear that this would be a win (nor that there's a
   // reasonably device-agnostic way to fill in the "believes" above).
   return base::TimeDelta::FromMilliseconds(10);
 }
 
 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,
-    scoped_ptr<BackingStrategy> strategy)
+    const base::Callback<bool(void)>& make_context_current)
     : client_(NULL),
       make_context_current_(make_context_current),
       codec_(media::kCodecH264),
       is_encrypted_(false),
       state_(NO_ERROR),
       picturebuffers_requested_(false),
       gl_decoder_(decoder),
-      strategy_(strategy.Pass()),
+      strategy_(new BACKING_STRATEGY()),
       weak_this_factory_(this) {}
 
 AndroidVideoDecodeAccelerator::~AndroidVideoDecodeAccelerator() {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 bool AndroidVideoDecodeAccelerator::Initialize(const Config& config,
                                                Client* client) {
   DCHECK(!media_codec_);
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 328 matching lines @@
 
   pending_bitstream_buffers_.push(
       std::make_pair(bitstream_buffer, base::Time::Now()));
   TRACE_COUNTER1("media", "AVDA::PendingBitstreamBufferCount",
                  pending_bitstream_buffers_.size());
 
   DoIOTask();
 }
 
 void AndroidVideoDecodeAccelerator::RequestPictureBuffers() {
-  client_->ProvidePictureBuffers(strategy_->GetNumPictureBuffers(), size_,
+  client_->ProvidePictureBuffers(kNumPictureBuffers, size_,
                                  strategy_->GetTextureTarget());
 }
 
 void AndroidVideoDecodeAccelerator::AssignPictureBuffers(
     const std::vector<media::PictureBuffer>& buffers) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(output_picture_buffers_.empty());
   DCHECK(free_picture_ids_.empty());
 
   for (size_t i = 0; i < buffers.size(); ++i) {
     RETURN_ON_FAILURE(this, buffers[i].size() == size_,
                       "Invalid picture buffer size was passed.",
                       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);
 
     strategy_->AssignOnePictureBuffer(buffers[i]);
   }
   TRACE_COUNTER1("media", "AVDA::FreePictureIds", free_picture_ids_.size());
 
-  RETURN_ON_FAILURE(
-      this, output_picture_buffers_.size() >= strategy_->GetNumPictureBuffers(),
-      "Invalid picture buffers were passed.", INVALID_ARGUMENT);
+  RETURN_ON_FAILURE(this, output_picture_buffers_.size() >= kNumPictureBuffers,
+                    "Invalid picture buffers were passed.", INVALID_ARGUMENT);
 
   DoIOTask();
 }
 
 void AndroidVideoDecodeAccelerator::ReusePictureBuffer(
     int32 picture_buffer_id) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // This ReusePictureBuffer() might have been in a pipe somewhere (queued in
   // IPC, or in a PostTask either at the sender or receiver) when we sent a
@@ skipping 151 matching lines @@
 void AndroidVideoDecodeAccelerator::NotifyResetDone() {
   client_->NotifyResetDone();
 }
 
 void AndroidVideoDecodeAccelerator::NotifyError(
     media::VideoDecodeAccelerator::Error error) {
   client_->NotifyError(error);
 }
 
 // static
-media::VideoDecodeAccelerator::SupportedProfiles
-AndroidVideoDecodeAccelerator::GetSupportedProfiles() {
-  SupportedProfiles profiles;
+media::VideoDecodeAccelerator::Capabilities
+AndroidVideoDecodeAccelerator::GetCapabilities() {
+  Capabilities capabilities;
+  SupportedProfiles& profiles = capabilities.supported_profiles;
 
   if (!media::VideoCodecBridge::IsKnownUnaccelerated(
           media::kCodecVP8, media::MEDIA_CODEC_DECODER)) {
     SupportedProfile profile;
     profile.profile = media::VP8PROFILE_ANY;
     profile.min_resolution.SetSize(0, 0);
     profile.max_resolution.SetSize(1920, 1088);
     profiles.push_back(profile);
   }
 
@@ skipping 12 matching lines @@
     profile.profile = supported_profile;
     profile.min_resolution.SetSize(0, 0);
     // Advertise support for 4k and let the MediaCodec fail when decoding if it
     // doesn't support the resolution. It's assumed that consumers won't have
     // software fallback for H264 on Android anyway.
     profile.max_resolution.SetSize(3840, 2160);
     profiles.push_back(profile);
   }
 #endif
 
-  return profiles;
+  capabilities.flags = BACKING_STRATEGY::GetCapabilitiesFlags();
+
+  return capabilities;
 }
 
 }  // namespace content