[WIP] Proxy RtcVideoDecoder calls to a media::VideoDecoder.

content/renderer/media/gpu/rtc_video_decoder.h

 // Copyright 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 CONTENT_RENDERER_MEDIA_GPU_RTC_VIDEO_DECODER_H_
 #define CONTENT_RENDERER_MEDIA_GPU_RTC_VIDEO_DECODER_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 17 matching lines @@
 #include "third_party/webrtc/modules/video_coding/include/video_codec_interface.h"
 #include "ui/gfx/geometry/rect.h"
 
 namespace base {
 class WaitableEvent;
 };
 
 namespace media {
 class DecoderBuffer;
 class GpuVideoAcceleratorFactories;
+class VideoDecoder;
 }
 
 namespace gpu {
 struct SyncToken;
 }
 
 namespace content {
 
 // This class uses hardware accelerated video decoder to decode video for
 // WebRTC. Lives on the media thread, where VDA::Client methods run on.
 // webrtc::VideoDecoder methods run on WebRTC DecodingThread or
 // Chrome_libJingle_WorkerThread, which are trampolined to the media thread.
 // Decode() is non-blocking and queues the buffers. Decoded frames are
 // delivered to WebRTC on the media task runner.
 class CONTENT_EXPORT RTCVideoDecoder
-    : NON_EXPORTED_BASE(public webrtc::VideoDecoder),
-      public media::VideoDecodeAccelerator::Client {
+    : NON_EXPORTED_BASE(public webrtc::VideoDecoder) {
  public:
   ~RTCVideoDecoder() override;
 
-  // Creates a RTCVideoDecoder on the message loop of |factories|. Returns NULL
-  // if failed. The video decoder will run on the message loop of |factories|.
+  using CreateVideoDecoderCB =
+      base::Callback<std::unique_ptr<media::VideoDecoder>()>;
+
+  // TODO(slan): Document!
   static std::unique_ptr<RTCVideoDecoder> Create(
       webrtc::VideoCodecType type,
-      media::GpuVideoAcceleratorFactories* factories);
-  // Destroys |decoder| on the loop of |factories|
-  static void Destroy(webrtc::VideoDecoder* decoder,
-                      media::GpuVideoAcceleratorFactories* factories);
+      const CreateVideoDecoderCB& create_video_decoder_cb,
+      const scoped_refptr<base::SingleThreadTaskRunner>& decoder_task_runner);
+  // Destroys |decoder| on |decoder_task_runner|.
+  static void Destroy(
+      webrtc::VideoDecoder* decoder,
+      const scoped_refptr<base::SingleThreadTaskRunner>& decoder_task_runner);
 
   // webrtc::VideoDecoder implementation.
   // Called on WebRTC DecodingThread.
   int32_t InitDecode(const webrtc::VideoCodec* codecSettings,
                      int32_t numberOfCores) override;
   // Called on WebRTC DecodingThread.
   int32_t Decode(const webrtc::EncodedImage& inputImage,
                  bool missingFrames,
                  const webrtc::RTPFragmentationHeader* fragmentation,
                  const webrtc::CodecSpecificInfo* codecSpecificInfo = NULL,
                  int64_t renderTimeMs = -1) override;
   // Called on WebRTC DecodingThread.
   int32_t RegisterDecodeCompleteCallback(
       webrtc::DecodedImageCallback* callback) override;
   // Called on Chrome_libJingle_WorkerThread. The child thread is blocked while
   // this runs.
   int32_t Release() override;
 
-  // VideoDecodeAccelerator::Client implementation.
-  void ProvidePictureBuffers(uint32_t count,
-                             media::VideoPixelFormat format,
-                             uint32_t textures_per_buffer,
-                             const gfx::Size& size,
-                             uint32_t texture_target) override;
-  void DismissPictureBuffer(int32_t id) override;
-  void PictureReady(const media::Picture& picture) override;
-  void NotifyEndOfBitstreamBuffer(int32_t id) override;
-  void NotifyFlushDone() override;
-  void NotifyResetDone() override;
-  void NotifyError(media::VideoDecodeAccelerator::Error error) override;
-
  private:
-  // Metadata of a bitstream buffer.
-  struct BufferData {
-    BufferData(int32_t bitstream_buffer_id,
-               uint32_t timestamp,
-               size_t size,
-               const gfx::Rect& visible_rect);
-    BufferData();
-    ~BufferData();
-    int32_t bitstream_buffer_id;
-    uint32_t timestamp;  // in 90KHz
-    size_t size;  // buffer size
-    gfx::Rect visible_rect;
-  };
-
   FRIEND_TEST_ALL_PREFIXES(RTCVideoDecoderTest, IsBufferAfterReset);
   FRIEND_TEST_ALL_PREFIXES(RTCVideoDecoderTest, IsFirstBufferAfterReset);
   FRIEND_TEST_ALL_PREFIXES(RTCVideoDecoderTest, GetVDAErrorCounterForTesting);
 
-  RTCVideoDecoder(webrtc::VideoCodecType type,
-                  media::GpuVideoAcceleratorFactories* factories);
+  RTCVideoDecoder(
+      webrtc::VideoCodecType type,
+      const CreateVideoDecoderCB& create_video_decoder_cb,
+      const scoped_refptr<base::SingleThreadTaskRunner>& decoder_task_runner);
 
   // Requests a buffer to be decoded by VDA.
   void RequestBufferDecode();
 
   bool CanMoreDecodeWorkBeDone();
 
   // Returns true if bitstream buffer id |id_buffer| comes after |id_reset|.
   // This handles the wraparound.
   bool IsBufferAfterReset(int32_t id_buffer, int32_t id_reset);
 
   // Returns true if bitstream buffer |id_buffer| is the first buffer after
   // |id_reset|.
   bool IsFirstBufferAfterReset(int32_t id_buffer, int32_t id_reset);
 
-  int GetVDAErrorCounterForTesting() { return vda_error_counter_; }
+  int GetVDAErrorCounterForTesting() { return decoder_error_counter_; }
 
-  // Saves a WebRTC buffer in |decode_buffers_| for decode.
-  void SaveToDecodeBuffers_Locked(
-      const webrtc::EncodedImage& input_image,
-      std::unique_ptr<base::SharedMemory> shm_buffer,
-      const BufferData& buffer_data);
+  // Saves a DecoderBuffer buffer in |pending_buffers_| waiting to be sent to
+  // the decoder. Returns true on success.
+  bool SaveToPendingBuffers_Locked(
+      int32_t decoder_buffer_id,
+      const scoped_refptr<media::DecoderBuffer>& decoder_buffer);
 
-  // Saves a WebRTC buffer in |pending_buffers_| waiting for SHM available.
-  // Returns true on success.
-  bool SaveToPendingBuffers_Locked(const webrtc::EncodedImage& input_image,
-                                   const BufferData& buffer_data);
+  // Calls Reset() on |decoder_|. Must be executed on the decoder thread.
+  void ResetOnDecoderThread();
+  void OnResetDone();
 
-  // Gets SHM and moves pending buffers to decode buffers.
-  void MovePendingBuffersToDecodeBuffers();
-
-  scoped_refptr<media::VideoFrame> CreateVideoFrame(
-      const media::Picture& picture,
-      const media::PictureBuffer& pb,
-      uint32_t timestamp,
-      const gfx::Rect& visible_rect,
-      media::VideoPixelFormat pixel_format);
-
-  // Resets VDA.
-  void ResetInternal();
-
-  // Static method is to allow it to run even after RVD is deleted.
-  static void ReleaseMailbox(base::WeakPtr<RTCVideoDecoder> decoder,
-                             media::GpuVideoAcceleratorFactories* factories,
-                             int64_t picture_buffer_id,
-                             uint32_t texture_id,
-                             const gpu::SyncToken& release_sync_token);
-  // Tells VDA that a picture buffer can be recycled.
-  void ReusePictureBuffer(int64_t picture_buffer_id);
-
-  // Creates |vda_| on the media thread.
-  void CreateVDA(media::VideoCodecProfile profile, base::WaitableEvent* waiter);
-
-  void DestroyTextures();
-  void DestroyVDA();
-
-  // Gets a shared-memory segment of at least |min_size| bytes from
-  // |available_shm_segments_|. Returns NULL if there is no buffer or the
-  // buffer is not big enough.
-  std::unique_ptr<base::SharedMemory> GetSHM_Locked(size_t min_size);
-
-  // Returns a shared-memory segment to the available pool.
-  void PutSHM_Locked(std::unique_ptr<base::SharedMemory> shm_buffer);
-
-  // Allocates |count| shared memory buffers of |size| bytes.
-  void CreateSHM(size_t count, size_t size);
-
-  // Stores the buffer metadata to |input_buffer_data_|.
-  void RecordBufferData(const BufferData& buffer_data);
-  // Gets the buffer metadata from |input_buffer_data_|.
-  void GetBufferData(int32_t bitstream_buffer_id,
-                     uint32_t* timestamp,
-                     gfx::Rect* visible_rect);
+  void OnBufferDecoded(int32_t buffer_decode_id,
+                       bool is_eos,
+                       media::DecodeStatus status);
 
   // Records the result of InitDecode to UMA and returns |status|.
   int32_t RecordInitDecodeUMA(int32_t status);
 
   // Asserts the contract that this class is operated on the right thread.
-  void DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent() const;
+  void DCheckDecoderTaskRunnerIsCurrent() const;
 
   // Queries factories_ whether |profile| is supported and return true is so,
   // false otherwise. If true, also set resolution limits for |profile|
   // in min/max_resolution_.
   bool IsProfileSupported(media::VideoCodecProfile profile);
 
-  // Clears the pending_buffers_ queue, freeing memory.
-  void ClearPendingBuffers();
+  // Clears the pending_buffers_ queue, freeing memory. Guarded by |lock_|.
+  void ClearPendingBuffers_Locked();
 
   enum State {
     UNINITIALIZED,  // The decoder has not initialized.
     INITIALIZED,    // The decoder has initialized.
     RESETTING,      // The decoder is being reset.
     DECODE_ERROR,   // Decoding error happened.
   };
 
   static const int32_t ID_LAST;     // maximum bitstream buffer id
   static const int32_t ID_HALF;     // half of the maximum bitstream buffer id
   static const int32_t ID_INVALID;  // indicates Reset or Release never occurred
 
   // The hardware video decoder.
-  std::unique_ptr<media::VideoDecodeAccelerator> vda_;
+  std::unique_ptr<::media::VideoDecoder> decoder_;
+  void InitializeDecoder(media::VideoCodecProfile profile,
+                         media::VideoCodec codec,
+                         base::WaitableEvent* waiter);
+  void OnDecoderInitialized(base::WaitableEvent* waiter, bool success);
+  void OnFrameReady(const scoped_refptr<media::VideoFrame>& frame);
 
   media::VideoCodecProfile vda_codec_profile_;
 
   // Number of times that |vda_| notified of an error.
-  uint32_t vda_error_counter_;
+  uint32_t decoder_error_counter_;
 
   // The video codec type, as reported by WebRTC.
   const webrtc::VideoCodecType video_codec_type_;
 
   // The size of the incoming video frames.
   gfx::Size frame_size_;
 
-  media::GpuVideoAcceleratorFactories* const factories_;
-
-  // The texture target used for decoded pictures.
-  uint32_t decoder_texture_target_;
+  const CreateVideoDecoderCB create_video_decoder_cb_;
+  scoped_refptr<base::SingleThreadTaskRunner> decoder_task_runner_;
 
   // The format of the decoded pictures.
   media::VideoPixelFormat pixel_format_;
 
-  // Metadata of the buffers that have been sent for decode.
-  std::list<BufferData> input_buffer_data_;
-
-  // A map from bitstream buffer IDs to bitstream buffers that are being
-  // processed by VDA.
-  std::map<int32_t, std::unique_ptr<base::SharedMemory>>
-      bitstream_buffers_in_decoder_;
-
-  // A map from picture buffer IDs to texture-backed picture buffers.
-  std::map<int32_t, media::PictureBuffer> assigned_picture_buffers_;
-
-  // PictureBuffers given to us by VDA via PictureReady, which we sent forward
-  // as VideoFrames to be rendered via read_cb_, and which will be returned
-  // to us via ReusePictureBuffer.
-  typedef std::map<int32_t /* picture_buffer_id */, uint32_t /* texture_id */>
-      PictureBufferTextureMap;
-  PictureBufferTextureMap picture_buffers_at_display_;
-
-  // The id that will be given to the next picture buffer.
-  int32_t next_picture_buffer_id_;
-
   // Protects |state_|, |decode_complete_callback_| , |num_shm_buffers_|,
   // |available_shm_segments_|, |pending_buffers_|, |decode_buffers_|,
-  // |next_bitstream_buffer_id_|, |reset_bitstream_buffer_id_| and
-  // |vda_error_counter_|.
+  // |next_decoder_buffer_id_|, |reset_bitstream_buffer_id_| and
+  // |decoder_error_counter_|.
   base::Lock lock_;
 
   // The state of RTCVideoDecoder. Guarded by |lock_|.
   State state_;
 
   // Guarded by |lock_|.
   webrtc::DecodedImageCallback* decode_complete_callback_;
 
-  // Total number of allocated SHM buffers. Guarded by |lock_|.
-  size_t num_shm_buffers_;
-
-  // Shared-memory buffer pool.  Since allocating SHM segments requires a
-  // round-trip to the browser process, we keep allocation out of the
-  // steady-state of the decoder. Guarded by |lock_|.
-  std::vector<std::unique_ptr<base::SharedMemory>> available_shm_segments_;
-
   // A queue storing WebRTC encoding images (and their metadata) that are
   // waiting for the shared memory. Guarded by |lock_|.
-  std::deque<std::pair<webrtc::EncodedImage, BufferData>> pending_buffers_;
+  std::deque<std::pair<int32_t, scoped_refptr<media::DecoderBuffer>>>
+      pending_buffers_;
 
-  // A queue storing buffers (and their metadata) that will be sent to VDA for
-  // decode. Guarded by |lock_|.
-  std::deque<std::pair<std::unique_ptr<base::SharedMemory>, BufferData>>
-      decode_buffers_;
+  std::unordered_map<int32_t /* decoder_buffer_id */,
+                     scoped_refptr<media::DecoderBuffer>>
+      buffers_in_decoder_;
 
   // The id that will be given to the next bitstream buffer. Guarded by |lock_|.
-  int32_t next_bitstream_buffer_id_;
+  int32_t next_decoder_buffer_id_;
 
   // A buffer that has an id less than this should be dropped because Reset or
   // Release has been called. Guarded by |lock_|.
-  int32_t reset_bitstream_buffer_id_;
+  int32_t reset_decoder_buffer_id_;
 
   // Minimum and maximum supported resolutions for the current profile/VDA.
   gfx::Size min_resolution_;
   gfx::Size max_resolution_;
 
   // Must be destroyed, or invalidated, on the media thread.
   // NOTE: Weak pointers must be invalidated before all other member variables.
   base::WeakPtrFactory<RTCVideoDecoder> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(RTCVideoDecoder);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_RENDERER_MEDIA_GPU_RTC_VIDEO_DECODER_H_