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"
@@ skipping 20 matching lines @@
   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 kBackingStrategy AndroidDeferredRenderingBackingStrategy

[DaleCurtis, 2015/12/03 21:59:46]

ALL_CAPS

[liberato (no reviews please), 2015/12/04 18:28:58]

DONE

+#else
+#define kBackingStrategy 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),
       state_(NO_ERROR),
       picturebuffers_requested_(false),
       gl_decoder_(decoder),
-      strategy_(strategy.Pass()),
+      strategy_(new kBackingStrategy()),

[liberato (no reviews please), 2015/12/03 21:21:01]

interesting aside: this isn't, and wasn't before, protected by the unified media
pipeline.  rtc will use the zero copy strategy if one compiles with
media_use_ffmpeg=1, regardless of the runtime setting.

https://code.google.com/p/chromium/issues/detail?id=565561

       weak_this_factory_(this) {}
 
 AndroidVideoDecodeAccelerator::~AndroidVideoDecodeAccelerator() {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 bool AndroidVideoDecodeAccelerator::Initialize(media::VideoCodecProfile profile,
                                                Client* client) {
   DCHECK(!media_codec_);
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 559 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
 
+  // Allow the backing strategy to set the flags for each profile.
+  for (auto& profile : profiles) {
+    profile.flags = kBackingStrategy::GetProfileFlags();
+  }
+
   return profiles;
 }
 
 }  // namespace content