content/renderer/pepper/pepper_video_encoder_host.h

   1 // Copyright 2015 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef CONTENT_RENDERER_PEPPER_PEPPER_VIDEO_ENCODER_HOST_H_
   6 #define CONTENT_RENDERER_PEPPER_PEPPER_VIDEO_ENCODER_HOST_H_
   7
   8 #include "base/memory/ref_counted.h"
   9 #include "base/memory/scoped_ptr.h"
  10 #include "base/memory/scoped_vector.h"
  11 #include "content/common/content_export.h"
  12 #include "media/video/video_encode_accelerator.h"
  13 #include "ppapi/c/pp_codecs.h"
  14 #include "ppapi/c/ppb_video_frame.h"
  15 #include "ppapi/host/host_message_context.h"
  16 #include "ppapi/host/resource_host.h"
  17 #include "ppapi/proxy/resource_message_params.h"
  18 #include "ppapi/shared_impl/media_stream_buffer_manager.h"
  19
  20 namespace media {
  21 class GpuVideoAcceleratorFactories;
  22 }
  23
  24 namespace content {
  25
  26 class CommandBufferProxyImpl;
  27 class GpuChannelHost;
  28 class RendererPpapiHost;
  29 class VideoEncoderShim;
  30
  31 class CONTENT_EXPORT PepperVideoEncoderHost
  32     : public ppapi::host::ResourceHost,
  33       public media::VideoEncodeAccelerator::Client,
  34       public ppapi::MediaStreamBufferManager::Delegate {
  35  public:
  36   PepperVideoEncoderHost(RendererPpapiHost* host,
  37                          PP_Instance instance,
  38                          PP_Resource resource);
  39   ~PepperVideoEncoderHost() override;
  40
  41  private:
  42   friend class VideoEncoderShim;
  43
  44   // Shared memory buffers.
  45   struct ShmBuffer {
  46     ShmBuffer(uint32_t id, scoped_ptr<base::SharedMemory> shm);
  47     ~ShmBuffer();
  48
  49     media::BitstreamBuffer ToBitstreamBuffer();
  50
  51     // Index of the buffer in the ScopedVector. Buffers have the same id in
  52     // the plugin and the host.
  53     uint32_t id;
  54     scoped_ptr<base::SharedMemory> shm;
  55     bool in_use;
  56   };
  57
  58   // media::VideoEncodeAccelerator implementation.
  59   void RequireBitstreamBuffers(unsigned int input_count,
  60                                const gfx::Size& input_coded_size,
  61                                size_t output_buffer_size) override;
  62   void BitstreamBufferReady(int32 bitstream_buffer_id,
  63                             size_t payload_size,
  64                             bool key_frame) override;
  65   void NotifyError(media::VideoEncodeAccelerator::Error error) override;
  66
  67   // ResourceHost implementation.
  68   int32_t OnResourceMessageReceived(
  69       const IPC::Message& msg,
  70       ppapi::host::HostMessageContext* context) override;
  71
  72   int32_t OnHostMsgGetSupportedProfiles(
  73       ppapi::host::HostMessageContext* context);
  74   int32_t OnHostMsgInitialize(ppapi::host::HostMessageContext* context,
  75                               PP_VideoFrame_Format input_format,
  76                               const PP_Size& input_visible_size,
  77                               PP_VideoProfile output_profile,
  78                               uint32_t initial_bitrate,
  79                               PP_HardwareAcceleration acceleration);
  80   int32_t OnHostMsgGetVideoFrames(ppapi::host::HostMessageContext* context);
  81   int32_t OnHostMsgEncode(ppapi::host::HostMessageContext* context,
  82                           uint32_t frame_id,
  83                           bool force_keyframe);
  84   int32_t OnHostMsgRecycleBitstreamBuffer(
  85       ppapi::host::HostMessageContext* context,
  86       uint32_t buffer_id);
  87   int32_t OnHostMsgRequestEncodingParametersChange(
  88       ppapi::host::HostMessageContext* context,
  89       uint32_t bitrate,
  90       uint32_t framerate);
  91   int32_t OnHostMsgClose(ppapi::host::HostMessageContext* context);
  92
  93   // Internal methods.
  94   void GetSupportedProfiles(
  95       std::vector<PP_VideoProfileDescription>* pp_profiles);
  96   bool IsInitializationValid(const PP_Size& input_size,
  97                              PP_VideoProfile ouput_profile,
  98                              PP_HardwareAcceleration acceleration);
  99   bool EnsureGpuChannel();
 100   bool InitializeHardware(media::VideoFrame::Format input_format,
 101                           const gfx::Size& input_visible_size,
 102                           media::VideoCodecProfile output_profile,
 103                           uint32_t initial_bitrate);
 104   void Close();
 105   void AllocateVideoFrames();
 106   void SendGetFramesErrorReply(int32_t error);
 107   scoped_refptr<media::VideoFrame> CreateVideoFrame(
 108       uint32_t frame_id,
 109       const ppapi::host::ReplyMessageContext& reply_context);
 110   void FrameReleased(const ppapi::host::ReplyMessageContext& reply_context,
 111                      uint32_t frame_id);
 112   void NotifyPepperError(int32_t error);
 113
 114   // Helper method for VideoEncoderShim.
 115   uint8_t* ShmHandleToAddress(int32 buffer_id);
 116
 117   // Non-owning pointer.
 118   RendererPpapiHost* renderer_ppapi_host_;
 119
 120   ScopedVector<ShmBuffer> shm_buffers_;
 121
 122   // Buffer manager for shared memory that holds video frames.
 123   ppapi::MediaStreamBufferManager buffer_manager_;
 124
 125   scoped_refptr<GpuChannelHost> channel_;
 126   CommandBufferProxyImpl* command_buffer_;
 127
 128   scoped_ptr<media::VideoEncodeAccelerator> encoder_;
 129
 130   // Whether the encoder has been successfully initialized.
 131   bool initialized_;
 132
 133   // Saved context to answer an Initialize message from the plugin.
 134   ppapi::host::ReplyMessageContext initialize_reply_context_;
 135
 136   // Saved context to answer a GetVideoFrames message from the plugin.
 137   ppapi::host::ReplyMessageContext get_video_frames_reply_context_;
 138
 139   // This represents the current error state of the encoder, i.e. PP_OK
 140   // normally, or a Pepper error code if the encoder is uninitialized,
 141   // has been notified of an encoder error, has encountered some
 142   // other unrecoverable error, or has been closed by  the plugin.
 143   // This field is checked in most message handlers to decide whether
 144   // operations should proceed or fail.
 145   int32_t encoder_last_error_;
 146
 147   // Size of the frames allocated for the encoder (matching hardware
 148   // constraints).
 149   gfx::Size input_coded_size_;
 150
 151   // Number of frames the encoder needs.
 152   uint32_t frame_count_;
 153
 154   // Format of the frames to give to the encoder.
 155   media::VideoFrame::Format media_input_format_;
 156
 157   base::WeakPtrFactory<PepperVideoEncoderHost> weak_ptr_factory_;
 158
 159   DISALLOW_COPY_AND_ASSIGN(PepperVideoEncoderHost);
 160 };
 161
 162 }  // namespace content
 163
 164 #endif  // CONTENT_RENDERER_PEPPER_PEPPER_VIDEO_ENCODER_HOST_H_