Support external buffer import in VDA interface and add a V4L2SVDA impl.

media/video/video_decode_accelerator.h

 // Copyright (c) 2012 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_VIDEO_VIDEO_DECODE_ACCELERATOR_H_
 #define MEDIA_VIDEO_VIDEO_DECODE_ACCELERATOR_H_
 
 #include <stdint.h>
 
 #include <memory>
 #include <vector>
 
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "media/base/bitstream_buffer.h"
 #include "media/base/surface_manager.h"
 #include "media/base/video_decoder_config.h"
 #include "media/video/picture.h"
 #include "ui/gfx/geometry/size.h"
+#include "ui/gfx/gpu_memory_buffer.h"
 
 typedef unsigned int GLenum;
 
 namespace base {
 class SingleThreadTaskRunner;
 }
 
 namespace media {
 
 // Video decoder interface.
@@ skipping 65 matching lines @@
     // failures, GPU library failures, browser programming errors, and so on.
     PLATFORM_FAILURE,
     // Largest used enum. This should be adjusted when new errors are added.
     ERROR_MAX = PLATFORM_FAILURE,
   };
 
   // Config structure contains parameters required for the VDA initialization.
   struct MEDIA_EXPORT Config {
     enum { kNoSurfaceID = SurfaceManager::kNoSurfaceID };
 
+    // Specifies the allocation and handling mode for output PictureBuffers.
+    // When set to ALLOCATE, the VDA is expected to allocate backing memory
+    // for PictureBuffers at the time of AssignPictureBuffers() call.
+    // When set to IMPORT, the VDA will not allocate, but after receiving
+    // AssignPictureBuffers() call, it will expect a call to
+    // ImportBufferForPicture() for each PictureBuffer before use.
+    enum class OutputMode {
+      ALLOCATE,
+      IMPORT,
+    };
+
     Config() = default;
     Config(VideoCodecProfile profile);
     Config(const VideoDecoderConfig& video_decoder_config);
 
     std::string AsHumanReadableString() const;
 
     // |profile| combines the information about the codec and its profile.
     VideoCodecProfile profile = VIDEO_CODEC_PROFILE_UNKNOWN;
 
     // The flag indicating whether the stream is encrypted.
     bool is_encrypted = false;
 
     // The flag indicating whether the client supports deferred initialization
     // or not.
     bool is_deferred_initialization_allowed = false;
 
     // An optional graphics surface that the VDA should render to. For setting
     // an output SurfaceView on Android. It's only valid when not equal to
     // |kNoSurfaceID|.
     int surface_id = kNoSurfaceID;
 
     // Coded size of the video frame hint, subject to change.
     gfx::Size initial_expected_coded_size;
+
+    OutputMode output_mode = OutputMode::ALLOCATE;
   };
 
   // Interface for collaborating with picture interface to provide memory for
   // output picture and blitting them. These callbacks will not be made unless
   // Initialize() has returned successfully.
   // This interface is extended by the various layers that relay messages back
   // to the plugin, through the PPP_VideoDecoder_Dev interface the plugin
   // implements.
   class MEDIA_EXPORT Client {
    public:
@@ skipping 85 matching lines @@
   // is not allowed to deallocate the buffer before the DismissPictureBuffer
   // callback has been initiated for a given buffer.
   //
   // Parameters:
   //  |buffers| contains the allocated picture buffers for the output.  Note
   //  that the count of buffers may be larger than the count requested through
   //  the call to Client::ProvidePictureBuffers().
   virtual void AssignPictureBuffers(
       const std::vector<PictureBuffer>& buffers) = 0;
 
+  // Imports |gpu_memory_buffer_handles| as backing memory for picture buffer
+  // associated with |picture_buffer_id|. The n-th element in
+  // |gpu_memory_buffer_handles| should be a handle to a GpuMemoryBuffer backing
+  // the n-th plane of the PictureBuffer. This can only be be used if the VDA
+  // has been Initialize()d with config.output_mode = IMPORT, and should be
+  // preceded by a call to AssignPictureBuffers() to set up the number of
+  // PictureBuffers and their details.
+  // After this call, the VDA becomes the owner of the GpuMemoryBufferHandles,
+  // and is responsible for closing them after use, also on import failure.
+  virtual void ImportBufferForPicture(
+      int32_t picture_buffer_id,
+      const std::vector<gfx::GpuMemoryBufferHandle>& gpu_memory_buffer_handles);
+
   // Sends picture buffers to be reused by the decoder. This needs to be called
   // for each buffer that has been processed so that decoder may know onto which
   // picture buffers it can write the output to.
   //
   // Parameters:
   //  |picture_buffer_id| id of the picture buffer that is to be reused.
   virtual void ReusePictureBuffer(int32_t picture_buffer_id) = 0;
 
   // Flushes the decoder: all pending inputs will be decoded and pictures handed
   // back to the client, followed by NotifyFlushDone() being called on the
@@ skipping 44 matching lines @@
   // to run decode operations without GL context, which helps reduce latency and
   // offloads the GPU Child thread.
   virtual bool TryToSetupDecodeOnSeparateThread(
       const base::WeakPtr<Client>& decode_client,
       const scoped_refptr<base::SingleThreadTaskRunner>& decode_task_runner);
 
   // Windows creates a BGRA texture.
   // TODO(dshwang): after moving to D3D11, remove this. crbug.com/438691
   virtual GLenum GetSurfaceInternalFormat() const;
 
+  // In IMPORT OutputMode, if supported by the VDA, return the format that it
+  // requires for imported picture buffers.
+  virtual VideoPixelFormat GetOutputFormat() const;
+
  protected:
   // Do not delete directly; use Destroy() or own it with a scoped_ptr, which
   // will Destroy() it properly by default.
   virtual ~VideoDecodeAccelerator();
 };
 
 }  // namespace media
 
 namespace std {
 
 // Specialize std::default_delete so that scoped_ptr<VideoDecodeAccelerator>
 // uses "Destroy()" instead of trying to use the destructor.
 template <>
 struct MEDIA_EXPORT default_delete<media::VideoDecodeAccelerator> {
   void operator()(media::VideoDecodeAccelerator* vda) const;
 };
 
 }  // namespace std
 
 #endif  // MEDIA_VIDEO_VIDEO_DECODE_ACCELERATOR_H_