Integrate VDA with WebRTC.

content/renderer/media/rtc_video_decoder.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 CONTENT_RENDERER_MEDIA_RTC_VIDEO_DECODER_H_
+#define CONTENT_RENDERER_MEDIA_RTC_VIDEO_DECODER_H_
+
+#include <deque>
+#include <utility>
+
+#include "base/basictypes.h"
+#include "base/memory/weak_ptr.h"
+#include "base/synchronization/lock.h"
+#include "base/synchronization/waitable_event.h"
+#include "content/common/content_export.h"
+#include "media/base/bitstream_buffer.h"
+#include "media/base/video_decoder.h"
+#include "media/base/video_decoder_config.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:
+  RTCVideoDecoder(
+      const scoped_refptr<media::GpuVideoDecoder::Factories>& factories);

[wuchengli, 2013/05/28 15:01:00]

Should GpuVideoDecoder::Factories be moved out of GpuVideoDecoder because
RTCVideoDecoder also uses it?

[Ami GONE FROM CHROMIUM, 2013/05/29 21:11:46]

That would be a reasonable thing to do, but it doesn't need to be part of this
CL unless you want to.

+  virtual ~RTCVideoDecoder();
+
+  // Initialize VDA. Return false if the codec type is not supported.
+  // Called on Chrome_libJingle_WorkerThread
+  bool Initialize(webrtc::VideoCodecType type);
+
+  // 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.
+  virtual int32_t Release() OVERRIDE;
+  // Called on Chrome_libJingle_WorkerThread.
+  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;
+
+ private:
+  // A shared memory segment and its allocated size.
+  struct SHMBuffer {
+    SHMBuffer(base::SharedMemory* m, size_t s);
+    ~SHMBuffer();
+    base::SharedMemory* shm;
+    size_t size;
+  };
+
+  struct BufferData {
+    BufferData(int32 bbid, uint32_t ts, int w, int h, size_t s);
+    ~BufferData();
+    int32 bitstream_buffer_id;
+    uint32_t timestamp;
+    uint32_t width;
+    uint32_t height;
+    size_t size;
+  };
+
+  void InitWeakPtr();
+  void ResetInternal();
+  void Destroy();
+  void ReusePictureBuffer(int64 picture_buffer_id);
+
+  // Request 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);
+
+  // Return a shared-memory segment to the available pool.
+  void PutSHM(SHMBuffer* shm_buffer);
+
+  void CreateVideoDecodeAccelerator(media::VideoCodecProfile profile);
+  void DestroyTextures();
+  void DestroyVDA();
+  void RecordBufferData(const BufferData& buffer_data);
+  void GetBufferData(int32 id, uint32_t* timestamp, uint32_t* width,
+                     uint32_t* height, size_t *size);
+  bool CanMoreDecodeWorkBeDone();
+  void RequestBufferDecode();
+
+  enum State {
+    kUninitialized, // The decoder has not initialized.
+    kInitialized,   // The decoder has initialized.
+    kDecodeError,   // Decoding error happened.
+  };
+
+  scoped_ptr<media::VideoDecodeAccelerator> vda_;
+
+  // Guarded by |lock_|.
+  webrtc::DecodedImageCallback* decode_complete_callback_;
+
+  // Used to wait for VDA calls to complete in InitDecode(), Release() and
+  // Reset().
+  base::WaitableEvent decoder_waiter_;
+
+  // The size of the video frames.
+  int32_t frame_width_;
+  int32_t frame_height_;
+
+  // Protects |state_|, |decode_complete_callback_| , and
+  // |available_shm_segments_|;
+  base::Lock lock_;
+
+  // The state of RTCVideoDecoder (guarded by |lock_|).
+  State state_;
+
+  // The weak pointer should live and die on the |decoder_message_loop_|;
+  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 from |factories|.
+  scoped_refptr<base::MessageLoopProxy> vda_loop_proxy_;
+
+  // The texture target used for decoded pictures.
+  uint32 decoder_texture_target_;
+
+  // 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_;
+
+  // Book-keeping variables.
+  std::list<BufferData> input_buffer_data_;
+  std::deque<std::pair<SHMBuffer*, BufferData> > buffers_to_be_decoded;
+  std::map<int32, SHMBuffer*> bitstream_buffers_in_decoder_;
+  std::map<int32, media::PictureBuffer> picture_buffers_in_decoder_;
+
+  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_