Group AVDA output surface into AVDASurfaceBundle.

media/gpu/avda_codec_allocator.h

 // Copyright 2016 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_AVDA_CODEC_ALLOCATOR_H_
 #define MEDIA_GPU_AVDA_CODEC_ALLOCATOR_H_
 
 #include <stddef.h>
 
 #include <memory>
 
 #include "base/android/build_info.h"
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/optional.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/sys_info.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_checker.h"
 #include "base/time/tick_clock.h"
 #include "base/trace_event/trace_event.h"
 #include "media/base/android/media_codec_bridge_impl.h"
 #include "media/base/android/media_drm_bridge_cdm_context.h"
 #include "media/base/media.h"
 #include "media/base/surface_manager.h"
 #include "media/base/video_codecs.h"
+#include "media/gpu/avda_surface_bundle.h"
 #include "media/gpu/media_gpu_export.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gl/android/scoped_java_surface.h"
 
 namespace media {
 
 // For TaskRunnerFor. These are used as vector indices, so please update
 // AVDACodecAllocator's constructor if you add / change them.
 enum TaskType {
   // Task for an autodetected MediaCodec instance.
   AUTO_CODEC = 0,
 
   // Task for a software-codec-required MediaCodec.
   SW_CODEC = 1,
 };
 
 // Configuration info for MediaCodec.
 // This is used to shuttle configuration info between threads without needing
 // to worry about the lifetime of the AVDA instance.
 class CodecConfig : public base::RefCountedThreadSafe<CodecConfig> {
  public:
   CodecConfig();
 
   VideoCodec codec = kUnknownVideoCodec;
 
   // The surface that MediaCodec is configured to output to.
-  gl::ScopedJavaSurface surface;
-  int surface_id = SurfaceManager::kNoSurfaceID;
-
-  // The SurfaceTexture attached to |surface|, or nullptr if |surface| is
-  // SurfaceView backed.
-  scoped_refptr<gl::SurfaceTexture> surface_texture;
+  scoped_refptr<AVDASurfaceBundle> surface_bundle;
 
   // The MediaCrypto that MediaCodec is configured with for an encrypted stream.
   MediaDrmBridgeCdmContext::JavaObjectPtr media_crypto;
 
   // Whether the encryption scheme requires us to use a protected surface.
   bool needs_protected_surface = false;
 
   // The initial coded size. The actual size might change at any time, so this
   // is only a hint.
   gfx::Size initial_expected_coded_size;
@@ skipping 68 matching lines @@
   // Create and configure a MediaCodec synchronously.
   std::unique_ptr<MediaCodecBridge> CreateMediaCodecSync(
       scoped_refptr<CodecConfig> codec_config);
 
   // Create and configure a MediaCodec asynchronously. The result is delivered
   // via OnCodecConfigured().
   virtual void CreateMediaCodecAsync(
       base::WeakPtr<AVDACodecAllocatorClient> client,
       scoped_refptr<CodecConfig> codec_config);
 
-  // Asynchronously release |media_codec| with the attached surface.
+  // Asynchronously release |media_codec| with the attached surface.  We will
+  // drop our reference to |surface_bundle| on the main thread after the codec
+  // is deallocated, since the codec isn't using it anymore.  We will not take
+  // other action on it (e.g., calling ReleaseSurfaceTexture if it has one),
+  // since some other codec might be going to use it.  We just want to be sure
+  // that it outlives |media_codec|.
   // TODO(watk): Bundle the MediaCodec and surface together so you can't get
   // this pairing wrong.
-  void ReleaseMediaCodec(std::unique_ptr<MediaCodecBridge> media_codec,
-                         TaskType task_type,
-                         int surface_id);
+  void ReleaseMediaCodec(
+      std::unique_ptr<MediaCodecBridge> media_codec,
+      TaskType task_type,
+      const scoped_refptr<AVDASurfaceBundle>& surface_bundle);
 
   // Returns a hint about whether the construction thread has hung for
   // |task_type|.  Note that if a thread isn't started, then we'll just return
   // "not hung", since it'll run on the current thread anyway.  The hang
   // detector will see no pending jobs in that case, so it's automatic.
   bool IsThreadLikelyHung(TaskType task_type);
 
   // Return true if and only if there is any AVDA registered.
   bool IsAnyRegisteredAVDA();
 
   // Return the task type to use for a new codec allocation, or nullopt if
   // both threads are hung.
   base::Optional<TaskType> TaskTypeForAllocation();
 
   // Return the task runner for tasks of type |type|.
   scoped_refptr<base::SingleThreadTaskRunner> TaskRunnerFor(TaskType task_type);
 
   // Return a reference to the thread for unit tests.
   base::Thread& GetThreadForTesting(TaskType task_type);
 
  protected:
   // |tick_clock| and |stop_event| are for tests only.
   AVDACodecAllocator(base::TickClock* tick_clock = nullptr,
                      base::WaitableEvent* stop_event = nullptr);
   virtual ~AVDACodecAllocator();
 
+  // Forward |media_codec|, which is configured to output to |surface_bundle|,
+  // to |client| if |client| is still around.  Otherwise, release the codec and
+  // then drop our ref to |surface_bundle|.
+  void ForwardOrDropCodec(base::WeakPtr<AVDACodecAllocatorClient> client,
+                          TaskType task_type,
+                          scoped_refptr<AVDASurfaceBundle> surface_bundle,
+                          std::unique_ptr<MediaCodecBridge> media_codec);
+
  private:
   friend class AVDACodecAllocatorTest;
 
   struct OwnerRecord {
     AVDACodecAllocatorClient* owner = nullptr;
     AVDACodecAllocatorClient* waiter = nullptr;
   };
 
   class HangDetector : public base::MessageLoop::TaskObserver {
    public:
@@ skipping 14 matching lines @@
   };
 
   // Handy combination of a thread and hang detector for it.
   struct ThreadAndHangDetector {
     ThreadAndHangDetector(const std::string& name, base::TickClock* tick_clock)
         : thread(name), hang_detector(tick_clock) {}
     base::Thread thread;
     HangDetector hang_detector;
   };
 
-  void OnMediaCodecAndSurfaceReleased(int surface_id);
+  // Called on the gpu main thread when a codec is freed on a codec thread.
+  // |surface_bundle| is the surface bundle that the codec was using.
+  void OnMediaCodecReleased(scoped_refptr<AVDASurfaceBundle> surface_bundle);
 
   // Stop the thread indicated by |index|. This signals stop_event_for_testing_
   // after both threads are stopped.
   void StopThreadTask(size_t index);
 
   // All registered AVDAs.
   std::set<AVDACodecAllocatorClient*> clients_;
 
   // Indexed by surface id.
   std::map<int32_t, OwnerRecord> surface_owners_;
@@ skipping 12 matching lines @@
 
   // For canceling pending StopThreadTask()s.
   base::WeakPtrFactory<AVDACodecAllocator> weak_this_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(AVDACodecAllocator);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_GPU_AVDA_CODEC_ALLOCATOR_H_