| // Copyright 2019 The Chromium OS 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 ARC_VM_LIBVDA_ENCODE_WRAPPER_H_ |
| #define ARC_VM_LIBVDA_ENCODE_WRAPPER_H_ |
| |
| #include <stdint.h> |
| |
| #include <memory> |
| |
| #include <base/files/scoped_file.h> |
| #include <base/macros.h> |
| |
| #include "arc/vm/libvda/event_pipe.h" |
| #include "arc/vm/libvda/libvda_encode.h" |
| |
| namespace arc { |
| |
| // VeaContext is the encode session context created by VeaImpl. |
| // Implementations should be able to handle method invocations on any thread. |
| class VeaContext { |
| public: |
| VeaContext(); |
| VeaContext(const VeaContext&) = delete; |
| VeaContext& operator=(const VeaContext&) = delete; |
| |
| virtual ~VeaContext(); |
| |
| // Encodes the frame pointed to by |fd|. |
| virtual int Encode(vea_input_buffer_id_t input_buffer_id, |
| base::ScopedFD fd, |
| size_t num_planes, |
| video_frame_plane_t* planes, |
| uint64_t timestamp, |
| bool force_keyframe) = 0; |
| |
| // Provides an output buffer for use by the internal encoder |
| // implementation. Encoded frames will be placed at the buffer specified |
| // by |fd|. |offset| should specify the offset at the buffer to start |
| // placing the encoded content and |size| should specify the buffer size. |
| virtual int UseOutputBuffer(vea_output_buffer_id_t output_buffer_id, |
| base::ScopedFD fd, |
| uint32_t offset, |
| uint32_t size) = 0; |
| |
| // Requests a change to encoding parameters. |
| // The return value will be 0 when the param change request has been |
| // successfully sent, and non-zero otherwise. |
| virtual int RequestEncodingParamsChange(uint32_t bitrate, |
| uint32_t framerate) = 0; |
| |
| // Requests to flush the encode session. |
| virtual int Flush() = 0; |
| |
| // Returns the read-only endpoint of the event pipe file descriptor. |
| int GetEventFd(); |
| |
| protected: |
| // Dispatch a REQUIRE_INPUT_BUFFERS event to the event pipe. |
| void DispatchRequireInputBuffers(uint32_t input_count, |
| uint32_t input_frame_width, |
| uint32_t input_frame_height, |
| uint32_t output_buffer_size); |
| |
| // Dispatch a PROCESSED_INPUT_BUFFER event to the event pipe. |
| void DispatchProcessedInputBuffer(vea_input_buffer_id_t input_buffer_id); |
| |
| // Dispatch a PROCESSED_OUTPUT_BUFFER event to the event pipe. |
| void DispatchProcessedOutputBuffer(vea_output_buffer_id_t output_buffer_id, |
| uint32_t payload_size, |
| bool key_frame, |
| int64_t timestamp); |
| |
| // Dispatch a FLUSH_RESPONSE event to the event pipe. |
| void DispatchFlushResponse(bool flush_done); |
| |
| // Dispatch a NOTIFY_ERROR event to the event pipe. |
| void DispatchNotifyError(vea_error_t error); |
| |
| private: |
| void WriteEvent(const vea_event_t& event); |
| |
| EventPipe event_pipe_; |
| }; |
| |
| // VeaImpl encapsulates a VEA implementation that can be used to create encode |
| // sessions. |
| class VeaImpl { |
| public: |
| VeaImpl(); |
| VeaImpl(const VeaImpl&) = delete; |
| VeaImpl& operator=(const VeaImpl&) = delete; |
| |
| virtual ~VeaImpl(); |
| |
| // Returns the encoding capabilities of this implementation. |
| // The returned vea_capabilities_t object is owned by VeaImpl. |
| virtual const vea_capabilities_t* const GetCapabilities(); |
| |
| // Initializes a new encode session and returns a new encode session context. |
| virtual VeaContext* InitEncodeSession(vea_config_t* config) = 0; |
| |
| // Closes an open encode session. |
| virtual void CloseEncodeSession(VeaContext* ctx) = 0; |
| |
| protected: |
| vea_capabilities_t capabilities_; |
| }; |
| |
| } // namespace arc |
| |
| #endif // ARC_VM_LIBVDA_ENCODE_WRAPPER_H_ |