Add AndroidVideoSurfaceChooser to manage overlays.

media/gpu/android_video_decode_accelerator.h

 // 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.
 
 #ifndef MEDIA_GPU_ANDROID_VIDEO_DECODE_ACCELERATOR_H_
 #define MEDIA_GPU_ANDROID_VIDEO_DECODE_ACCELERATOR_H_
 
 #include <stdint.h>
 
 #include <list>
 #include <map>
 #include <queue>
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/optional.h"
 #include "base/threading/thread_checker.h"
 #include "base/timer/timer.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 #include "gpu/command_buffer/service/gpu_preferences.h"
 #include "media/base/android/media_codec_bridge_impl.h"
 #include "media/base/android/media_drm_bridge_cdm_context.h"
 #include "media/base/content_decryption_module.h"
 #include "media/gpu/avda_codec_allocator.h"
+#include "media/gpu/avda_overlay_helper.h"
 #include "media/gpu/avda_picture_buffer_manager.h"
 #include "media/gpu/avda_state_provider.h"
 #include "media/gpu/gpu_video_decode_accelerator_helpers.h"
 #include "media/gpu/media_gpu_export.h"
 #include "media/video/video_decode_accelerator.h"
 #include "ui/gl/android/scoped_java_surface.h"
 #include "ui/gl/android/surface_texture.h"
 
 namespace media {
 class SharedMemoryRegion;
 
 // A VideoDecodeAccelerator implementation for Android. This class decodes the
 // encded input stream using Android's MediaCodec. It handles the work of
 // transferring data to and from MediaCodec, and delegates attaching MediaCodec
 // output buffers to PictureBuffers to AVDAPictureBufferManager.
 class MEDIA_GPU_EXPORT AndroidVideoDecodeAccelerator
     : public VideoDecodeAccelerator,
       public AVDAStateProvider,
       public AVDACodecAllocatorClient {
  public:
   static VideoDecodeAccelerator::Capabilities GetCapabilities(
       const gpu::GpuPreferences& gpu_preferences);
 
+  // Various things that we normally ask the platform for, mostly for testing.
+  struct PlatformConfig {
+    int sdk_int = base::android::SDK_VERSION_MARSHMALLOW;
+
+    // Is SetSurface supported?  This is not the same as >= M, since we
+    // blacklist some devices.
+    bool allow_setsurface = true;
+
+    bool force_deferred_surface_creation = false;
+  };
+
   AndroidVideoDecodeAccelerator(
       AVDACodecAllocator* codec_allocator,
+      std::unique_ptr<AVDAOverlayHelper> overlay_helper,
       const MakeGLContextCurrentCallback& make_context_current_cb,
-      const GetGLES2DecoderCallback& get_gles2_decoder_cb);
+      const GetGLES2DecoderCallback& get_gles2_decoder_cb,
+      const PlatformConfig* optional_platform_config);
 
   ~AndroidVideoDecodeAccelerator() override;
 
   // VideoDecodeAccelerator implementation:
   bool Initialize(const Config& config, Client* client) override;
   void Decode(const BitstreamBuffer& bitstream_buffer) override;
   void AssignPictureBuffers(const std::vector<PictureBuffer>& buffers) override;
   void ReusePictureBuffer(int32_t picture_buffer_id) override;
   void Flush() override;
   void Reset() override;
@@ skipping 17 matching lines @@
   void OnCodecConfigured(
       std::unique_ptr<MediaCodecBridge> media_codec) override;
 
  private:
   friend class AVDAManager;
 
   // TODO(timav): evaluate the need for more states in the AVDA state machine.
   enum State {
     NO_ERROR,
     ERROR,
-    // We have requested a surface, but haven't allocated it yet.  When the
-    // surface arrives, we'll transition to WAITING_FOR_CODEC, NO_ERROR, or
-    // ERROR.  This is also the initial state, before we've even requested a
-    // surface, just because it's convenient.
-    WAITING_FOR_SURFACE,
+    // We haven't initialized |overlay_helper_| yet, so we don't have a surface
+    // or a codec.  After we initialize |overlay_helper_|, we'll transition to
+    // WAITING_FOR_CODEC, NO_ERROR, or ERROR.
+    BEFORE_OVERLAY_INIT,
     // Set when we are asynchronously constructing the codec.  Will transition
     // to NO_ERROR or ERROR depending on success.
     WAITING_FOR_CODEC,
     // Set when we have a codec, but it doesn't yet have a key.
     WAITING_FOR_KEY,
     // The output surface was destroyed. We must not configure a new MediaCodec
     // with the destroyed surface.
     SURFACE_DESTROYED,
   };
 
   enum DrainType {
     DRAIN_FOR_FLUSH,
     DRAIN_FOR_RESET,
     DRAIN_FOR_DESTROY,
   };
 
-  // Entry point for configuring / reconfiguring a codec with a new surface.
-  // Start surface creation by trying to allocate the surface id.  Will either
-  // InitializePictureBufferManager if the surface is available immediately, or
-  // will wait for OnOverlayReady to do it.  This will transition |state_|
-  // to WAITING_FOR_SURFACE or WAITING_FOR_CODEC, as needed (or NO_ERROR if it
-  // gets the surface and the codec without waiting).
-  // Note that this requires that you create a new |incoming_bundle_| with the
-  // appropriate surface id.
-  void StartSurfaceCreation();
+  // Called once before (possibly deferred) initialization succeeds, to set up
+  // |overlay_helper_| with our inital factory from VDA::Config.
+  void StartOverlayHelper();
 
-  // Called by AndroidOverlay when a surface becomes available.
-  void OnOverlayReady(AndroidOverlay* overlay);
+  // Start a transition to an overlay, or, if |!overlay|, SurfaceTexture.  The
+  // transition doesn't have to be immediate; we'll favor not dropping frames.
+  void OnTransitionToOrFromOverlay(std::unique_ptr<AndroidOverlay> overlay);
 
-  // Called by AndroidOverlay when the overlay will not call OnOverlayReady.
-  void OnOverlayFailed(AndroidOverlay* overlay);
-
-  // Called by AndroidOverlay when a surface is lost.
-  void OnSurfaceDestroyed(AndroidOverlay* overlay);
+  // Called by AndroidOverlay when a surface is lost.  We will discard pending
+  // frames, as needed, to switch away from |overlay| if we're using it.  Before
+  // we return, we will have either dropped |overlay| if we own it, or posted
+  // it for async release with the codec that's using it.  We also handle the
+  // case where we're not using |overlay| at all, since that can happen too
+  // while async codec release is pending.
+  void OnStopUsingOverlayImmediately(AndroidOverlay* overlay);
 
   // Initializes the picture buffer manager to use the current surface, once
   // it is available.  This is not normally called directly, but rather via
   // StartSurfaceCreation.  If we have a media codec already, then this will
   // attempt to setSurface the new surface.  Otherwise, it will start codec
   // config using the new surface.  In that case, there might not be a codec
   // ready even if this succeeds, but async config will be started.  If
   // setSurface fails, this will not replace the codec.  On failure, this will
   // transition |state_| to ERROR.
   // Note that this assumes that there is an |incoming_bundle_| that we'll use.
@@ skipping 102 matching lines @@
   // On platforms which support seamless surface changes, this will reinitialize
   // the picture buffer manager with the new surface. This function reads and
   // clears the surface id from |pending_surface_id_|. It will issue a decode
   // error if the surface change fails. Returns false on failure.
   bool UpdateSurface();
 
   // Release |media_codec_| if it's not null, and notify
   // |picture_buffer_manager_|.
   void ReleaseCodec();
 
-  // Returns the surface ID from the incoming bundle, if we have one, or
-  // the current surface bundle if not.  The reasoning is that, if we have an
-  // incoming bundle, then the current (outgoing) one has already been returned
-  // to the codec allocator via DeallocateSurface.  The only place this happens
-  // is UpdateSurface, which handles it specially.
-  int surface_id() const {
-    return incoming_bundle_ ? incoming_bundle_->surface_id
-                            : codec_config_->surface_bundle->surface_id;
-  }
+  // ReleaseCodec(), and also drop our ref to it's surface bundle.  This is the
+  // right thing to do unless you're planning to re-use the bundle with another
+  // codec.  Normally, one doesn't.
+  void ReleaseCodecAndBundle();
 
   // Used to DCHECK that we are called on the correct thread.
   base::ThreadChecker thread_checker_;
 
   // To expose client callbacks from VideoDecodeAccelerator.
   Client* client_;
 
   AVDACodecAllocator* codec_allocator_;
 
   // Callback to set the correct gl context.
@@ skipping 104 matching lines @@
   // Copy of the VDA::Config we were given.
   Config config_;
 
   // SurfaceBundle that we're going to use for StartSurfaceCreation.  This is
   // separate than the bundle in |codec_config_|, since we can start surface
   // creation while another codec is using the old surface.  For example, if
   // we're going to SetSurface, then the current codec will depend on the
   // current bundle until then.
   scoped_refptr<AVDASurfaceBundle> incoming_bundle_;
 
+  // If we have been given an overlay to use, then this is it.  If we've been
+  // told to move to SurfaceTexture, then this will be value() == nullptr.
+  base::Optional<std::unique_ptr<AndroidOverlay>> incoming_overlay_;
+
+  std::unique_ptr<AVDAOverlayHelper> overlay_helper_;
+
+  PlatformConfig platform_config_;
+
+  // Private helper for |weak_this_factory_|.

[DaleCurtis, 2017/04/25 23:25:33]

Seems unnecessary since internal callers can just use the factory directly?

[liberato (no reviews please), 2017/04/26 17:53:58]

it just reads better to me as a utility method than the existing
|weak_this_factory_.GetWeakPtr()| -- less text to parse, fewer wrapped lines. 
plus, ironically in retrospect, less typing.  :)

i'll put it back.

+  base::WeakPtr<AndroidVideoDecodeAccelerator> GetWeakPtr();
+
   // WeakPtrFactory for posting tasks back to |this|.
   base::WeakPtrFactory<AndroidVideoDecodeAccelerator> weak_this_factory_;
 
   friend class AndroidVideoDecodeAcceleratorTest;
 };
 
 }  // namespace media
 
 #endif  // MEDIA_GPU_ANDROID_VIDEO_DECODE_ACCELERATOR_H_