Integrate VDA with WebRTC.

content/renderer/media/rtc_video_decoder.h

+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef CONTENT_RENDERER_MEDIA_RTC_VIDEO_DECODER_H_
+#define CONTENT_RENDERER_MEDIA_RTC_VIDEO_DECODER_H_
+
+#include <deque>
+#include <set>
+#include <utility>
+
+#include "base/basictypes.h"
+#include "base/memory/weak_ptr.h"
+#include "base/message_loop.h"
+#include "base/synchronization/lock.h"
+#include "base/synchronization/waitable_event.h"
+#include "base/threading/thread.h"
+#include "content/common/content_export.h"
+#include "media/base/bitstream_buffer.h"
+#include "media/base/video_decoder.h"
+#include "media/filters/gpu_video_decoder.h"
+#include "media/video/picture.h"
+#include "media/video/video_decode_accelerator.h"
+#include "third_party/webrtc/modules/video_coding/codecs/interface/video_codec_interface.h"
+
+namespace base {
+class MessageLoopProxy;
+};
+
+namespace media {
+class DecoderBuffer;
+}
+
+namespace content {
+
+// This class uses hardware accelerated video decoder to decode video for
+// WebRTC. The message loop of RendererGpuVideoDecoderFactories is stored as
+// |vda_message_loop_|. It is the compositor thread, or the renderer thread if
+// threaded compositing is disabled. VDA::Client methods run on
+// |vda_message_loop_|. webrtc::VideoDecoder methods run on WebRTC
+// DecodingThread or Chrome_libJingle_WorkerThread, which are trampolined to
+// |vda_message_loop_|. Decode() is non-blocking and queues the buffers. Decoded
+// frames are delivered on |vda_message_loop_|.
+class CONTENT_EXPORT RTCVideoDecoder
+    : NON_EXPORTED_BASE(public webrtc::VideoDecoder),
+      public media::VideoDecodeAccelerator::Client,
+      public base::MessageLoop::DestructionObserver {
+ public:
+  virtual ~RTCVideoDecoder();
+
+  // Creates a RTCVideoDecoder. Returns NULL if failed.
+  static scoped_ptr<RTCVideoDecoder> Create(
+      const scoped_refptr<media::GpuVideoDecoder::Factories>& factories);
+
+  // webrtc::VideoDecoder implementation.
+  // Called on WebRTC DecodingThread.
+  virtual int32_t InitDecode(const webrtc::VideoCodec* codecSettings,
+                             int32_t numberOfCores) OVERRIDE;
+  // Called on WebRTC DecodingThread.
+  virtual 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.
+  virtual int32_t RegisterDecodeCompleteCallback(
+      webrtc::DecodedImageCallback* callback) OVERRIDE;
+  // Called on Chrome_libJingle_WorkerThread. The child thread is blocked while
+  // this runs.
+  virtual int32_t Release() OVERRIDE;
+  // Called on Chrome_libJingle_WorkerThread. The child thread is blocked while
+  // this runs.
+  virtual int32_t Reset() OVERRIDE;
+
+  // VideoDecodeAccelerator::Client implementation.
+  virtual void NotifyInitializeDone() OVERRIDE;
+  virtual void ProvidePictureBuffers(uint32 count,
+                                     const gfx::Size& size,
+                                     uint32 texture_target) OVERRIDE;
+  virtual void DismissPictureBuffer(int32 id) OVERRIDE;
+  virtual void PictureReady(const media::Picture& picture) OVERRIDE;
+  virtual void NotifyEndOfBitstreamBuffer(int32 id) OVERRIDE;
+  virtual void NotifyFlushDone() OVERRIDE;
+  virtual void NotifyResetDone() OVERRIDE;
+  virtual void NotifyError(media::VideoDecodeAccelerator::Error error) OVERRIDE;
+
+  // base::DestructionObserver implementation. Called when |vda_message_loop_|
+  // is stopped.
+  virtual void WillDestroyCurrentMessageLoop();
+
+ private:
+  struct SHMBuffer;
+  struct BufferData;
+
+  RTCVideoDecoder(
+      const scoped_refptr<media::GpuVideoDecoder::Factories>& factories);
+
+  // Initializes VDA. True if successful.
+  bool InitVideoDecodeAccelerator();
+
+  void Initialize(base::WaitableEvent* waiter);
+
+  // Requests a buffer to be decoded.
+  void RequestBufferDecode();
+
+  bool CanMoreDecodeWorkBeDone();
+
+  // Resets VDA.
+  void ResetInternal();
+
+  // Tells VDA that a picture buffer can be recycled.
+  void ReusePictureBuffer(int64 picture_buffer_id);
+
+  void DestroyTextures();
+  void DestroyVDA();
+  void ClearBufferQueue(std::deque<std::pair<SHMBuffer*, BufferData> >* queue);
+
+  // Requests a shared-memory segment of at least |min_size| bytes.  Will
+  // allocate as necessary.  Caller does not own returned pointer.
+  SHMBuffer* GetSHM(size_t min_size);
+
+  // Returns a shared-memory segment to the available pool.
+  void PutSHM(SHMBuffer* shm_buffer);
+
+  // 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 bitstream_buffer_id,
+                     uint32_t* timestamp,
+                     uint32_t* width,
+                     uint32_t* height,
+                     size_t* size);
+
+  enum State {
+    UNINITIALIZED,  // The decoder has not initialized.
+    INITIALIZED,    // The decoder has initialized.
+    RESETTING,      // The decoder is being reset.
+    DECODE_ERROR,   // Decoding error happened.
+  };
+
+  // The hardware video decoder.
+  scoped_ptr<media::VideoDecodeAccelerator> vda_;
+
+  // The size of the incoming video frames.
+  gfx::Size frame_size_;
+
+  // Protects |state_|, |decode_complete_callback_| , |available_shm_segments_|,
+  // |buffers_to_be_decoded_|, and |buffers_resetting_|.
+  base::Lock lock_;
+
+  // The state of RTCVideoDecoder. Guarded by |lock_|.
+  State state_;
+
+  // Guarded by |lock_|.
+  webrtc::DecodedImageCallback* decode_complete_callback_;
+
+  // 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<SHMBuffer*> available_shm_segments_;
+
+  // The weak pointer should live and die on the |vda_loop_proxy_|;
+  base::WeakPtrFactory<RTCVideoDecoder> weak_factory_;
+  base::WeakPtr<RTCVideoDecoder> weak_this_;
+
+  scoped_refptr<media::GpuVideoDecoder::Factories> factories_;
+
+  // The message loop to run callbacks on. This is should be the same as the one
+  // of |factories_|.
+  scoped_refptr<base::MessageLoopProxy> vda_loop_proxy_;
+
+  // The texture target used for decoded pictures.
+  uint32 decoder_texture_target_;
+
+  // Metadata of the buffers that have been sent for decode.
+  std::list<BufferData> input_buffer_data_;
+
+  // A queue storing buffers (and their metadata) that will be sent to VDA for
+  // decode. Guarded by |lock_|.
+  std::deque<std::pair<SHMBuffer*, BufferData> > buffers_to_be_decoded_;
+
+  // A queue storing buffers (and their metadata) that arrives when VDA is
+  // resetting. They will be sent for decoding after reset is done. Guarded by
+  // |lock_|.
+  std::deque<std::pair<SHMBuffer*, BufferData> > buffers_delayed_;
+
+  // A map from bitstream buffer IDs to bitstream buffers that are being
+  // processed by VDA.
+  std::map<int32, SHMBuffer*> bitstream_buffers_in_decoder_;
+
+  // A map from picture buffer IDs to texture-backed picture buffers.
+  std::map<int32, media::PictureBuffer> assigned_picture_buffers_;
+
+  // Picture buffers that are dismissed but not deleted yet.
+  std::map<int32, media::PictureBuffer> dismissed_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.
+  std::set<int32> picture_buffers_at_display_;
+
+  int32 next_picture_buffer_id_;
+  int32 next_bitstream_buffer_id_;
+
+  DISALLOW_COPY_AND_ASSIGN(RTCVideoDecoder);
+};
+
+}  // namespace content
+
+#endif  // CONTENT_RENDERER_MEDIA_RTC_VIDEO_DECODER_H_