blob: b69fca5a9a1d279c700a80eb778a9bf39ab9fa63 [file] [log] [blame]
// Copyright 2015 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 PPAPI_PROXY_VIDEO_ENCODER_RESOURCE_H_
#define PPAPI_PROXY_VIDEO_ENCODER_RESOURCE_H_
#include <stdint.h>
#include <memory>
#include <vector>
#include "base/containers/circular_deque.h"
#include "base/macros.h"
#include "base/memory/ref_counted.h"
#include "ppapi/proxy/connection.h"
#include "ppapi/proxy/plugin_resource.h"
#include "ppapi/shared_impl/media_stream_buffer_manager.h"
#include "ppapi/shared_impl/resource.h"
#include "ppapi/thunk/ppb_video_encoder_api.h"
namespace base {
class SharedMemory;
}
namespace ppapi {
class TrackedCallback;
namespace proxy {
class VideoFrameResource;
class PPAPI_PROXY_EXPORT VideoEncoderResource
: public PluginResource,
public thunk::PPB_VideoEncoder_API,
public ppapi::MediaStreamBufferManager::Delegate {
public:
VideoEncoderResource(Connection connection, PP_Instance instance);
~VideoEncoderResource() override;
thunk::PPB_VideoEncoder_API* AsPPB_VideoEncoder_API() override;
private:
struct ShmBuffer {
ShmBuffer(uint32_t id, std::unique_ptr<base::SharedMemory> shm);
~ShmBuffer();
// Index of the buffer in the vector. Buffers have the same id in
// the plugin and the host.
uint32_t id;
std::unique_ptr<base::SharedMemory> shm;
};
struct BitstreamBuffer {
BitstreamBuffer(uint32_t id, uint32_t size, bool key_frame);
~BitstreamBuffer();
// Index of the buffer in the vector. Same as ShmBuffer::id.
uint32_t id;
uint32_t size;
bool key_frame;
};
// PPB_VideoEncoder_API implementation.
int32_t GetSupportedProfiles(
const PP_ArrayOutput& output,
const scoped_refptr<TrackedCallback>& callback) override;
int32_t GetSupportedProfiles0_1(
const PP_ArrayOutput& output,
const scoped_refptr<TrackedCallback>& callback) override;
int32_t Initialize(PP_VideoFrame_Format input_format,
const PP_Size* input_visible_size,
PP_VideoProfile output_profile,
uint32_t initial_bitrate,
PP_HardwareAcceleration acceleration,
const scoped_refptr<TrackedCallback>& callback) override;
int32_t GetFramesRequired() override;
int32_t GetFrameCodedSize(PP_Size* size) override;
int32_t GetVideoFrame(
PP_Resource* video_frame,
const scoped_refptr<TrackedCallback>& callback) override;
int32_t Encode(PP_Resource video_frame,
PP_Bool force_keyframe,
const scoped_refptr<TrackedCallback>& callback) override;
int32_t GetBitstreamBuffer(
PP_BitstreamBuffer* picture,
const scoped_refptr<TrackedCallback>& callback) override;
void RecycleBitstreamBuffer(const PP_BitstreamBuffer* picture) override;
void RequestEncodingParametersChange(uint32_t bitrate,
uint32_t framerate) override;
void Close() override;
// PluginResource implementation.
void OnReplyReceived(const ResourceMessageReplyParams& params,
const IPC::Message& msg) override;
// Reply message handlers for operations that are done in the host.
void OnPluginMsgGetSupportedProfilesReply(
const PP_ArrayOutput& output,
bool version0_1,
const ResourceMessageReplyParams& params,
const std::vector<PP_VideoProfileDescription>& profiles);
void OnPluginMsgInitializeReply(const ResourceMessageReplyParams& params,
uint32_t input_frame_count,
const PP_Size& input_coded_size);
void OnPluginMsgGetVideoFramesReply(const ResourceMessageReplyParams& params,
uint32_t frame_count,
uint32_t frame_length,
const PP_Size& frame_size);
void OnPluginMsgEncodeReply(PP_Resource video_frame,
const ResourceMessageReplyParams& params,
uint32_t frame_id);
// Unsolicited reply message handlers.
void OnPluginMsgBitstreamBuffers(const ResourceMessageReplyParams& params,
uint32_t buffer_length);
void OnPluginMsgBitstreamBufferReady(const ResourceMessageReplyParams& params,
uint32_t buffer_id,
uint32_t buffer_size,
bool key_frame);
void OnPluginMsgNotifyError(const ResourceMessageReplyParams& params,
int32_t error);
// Internal utility functions.
void NotifyError(int32_t error);
void TryWriteVideoFrame();
void WriteBitstreamBuffer(const BitstreamBuffer& buffer);
void ReleaseFrames();
bool initialized_;
bool closed_;
int32_t encoder_last_error_;
int32_t input_frame_count_;
PP_Size input_coded_size_;
MediaStreamBufferManager buffer_manager_;
typedef std::map<PP_Resource, scoped_refptr<VideoFrameResource> >
VideoFrameMap;
VideoFrameMap video_frames_;
std::vector<std::unique_ptr<ShmBuffer>> shm_buffers_;
base::circular_deque<BitstreamBuffer> available_bitstream_buffers_;
using BitstreamBufferMap = std::map<void*, uint32_t>;
BitstreamBufferMap bitstream_buffer_map_;
scoped_refptr<TrackedCallback> get_supported_profiles_callback_;
scoped_refptr<TrackedCallback> initialize_callback_;
scoped_refptr<TrackedCallback> get_video_frame_callback_;
PP_Resource* get_video_frame_data_;
using EncodeMap = std::map<PP_Resource, scoped_refptr<TrackedCallback>>;
EncodeMap encode_callbacks_;
scoped_refptr<TrackedCallback> get_bitstream_buffer_callback_;
PP_BitstreamBuffer* get_bitstream_buffer_data_;
DISALLOW_COPY_AND_ASSIGN(VideoEncoderResource);
};
} // namespace proxy
} // namespace ppapi
#endif // PPAPI_PROXY_VIDEO_ENCODER_RESOURCE_H_