| // 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_LIBVDA_ENCODE_H_ |
| #define ARC_VM_LIBVDA_LIBVDA_ENCODE_H_ |
| |
| #include <stddef.h> |
| #include <stdint.h> |
| |
| #include "arc/vm/libvda/libvda_common.h" |
| #include "arc/vm/libvda/libvda_export.h" |
| |
| #ifdef __cplusplus |
| extern "C" { |
| #endif |
| |
| // VEA implementation types. |
| typedef enum vea_impl_type { |
| // A fake implementation for testing. |
| VEA_FAKE, |
| // A GpuArcVideoEncodeAccelerator-backed implementation. |
| GAVEA |
| } vea_impl_type_t; |
| |
| // Adapted from VideoEncodeProfile. |
| typedef struct vea_profile { |
| video_codec_profile_t profile; |
| uint32_t max_width; |
| uint32_t max_height; |
| uint32_t max_framerate_numerator; |
| uint32_t max_framerate_denominator; |
| } vea_profile_t; |
| |
| // Media capabilities of a VEA implementation. |
| typedef struct vea_capabilities { |
| // Supported input formats. |
| size_t num_input_formats; |
| const video_pixel_format_t* input_formats; |
| |
| // Supported output formats, valid for any supported input format. |
| size_t num_output_formats; |
| const vea_profile_t* output_formats; |
| } vea_capabilities_t; |
| |
| // Adapted from VideoEncodeAcceleratorConfig. |
| typedef struct vea_config { |
| video_pixel_format_t input_format; |
| uint32_t input_visible_width; |
| uint32_t input_visible_height; |
| video_codec_profile_t output_profile; |
| uint32_t initial_bitrate; |
| uint32_t initial_framerate; |
| uint8_t has_initial_framerate; |
| uint8_t h264_output_level; |
| uint8_t has_h264_output_level; |
| } vea_config_t; |
| |
| // Adapted from VideoEncodeAccelerator::Error. |
| typedef enum vea_error { |
| ILLEGAL_STATE_ERROR = 0, |
| INVALID_ARGUMENT_ERROR = 1, |
| PLATFORM_FAILURE_ERROR = 2 |
| } vea_error_t; |
| |
| // VEA encode session info returned by init_encode_session(). |
| typedef struct vea_session_info { |
| // An encode session context used for encoding. |
| void* ctx; |
| // Event pipe file descriptor. When new encode session events occur, |
| // vea_event_t objects can be read from the fd. |
| int event_pipe_fd; |
| } vea_session_info_t; |
| |
| // A unique ID assigned to an input buffer sent to the encoder for encoding |
| // using the function vea_encode. |
| typedef int32_t vea_input_buffer_id_t; |
| |
| // A unique ID assigned to an output buffer sent to the encoder using the |
| // function vea_use_output_buffer. |
| typedef int32_t vea_output_buffer_id_t; |
| |
| // Possible VEA event types. |
| typedef enum vea_event_type { |
| REQUIRE_INPUT_BUFFERS, |
| PROCESSED_INPUT_BUFFER, |
| PROCESSED_OUTPUT_BUFFER, |
| VEA_FLUSH_RESPONSE, |
| VEA_NOTIFY_ERROR |
| } vea_event_type_t; |
| |
| // Event data for VEA event type REQUIRE_INPUT_BUFFERS. |
| // Requests the users to provide input buffers, |
| // and specifies the buffer size for output buffers. |
| typedef struct vea_require_input_buffers_event_data { |
| uint32_t input_count; |
| uint32_t input_frame_width; |
| uint32_t input_frame_height; |
| uint32_t output_buffer_size; |
| } vea_require_input_buffers_event_data_t; |
| |
| // Event data for VEA event type PROCESSED_OUTPUT_BUFFER. |
| // This event can be received when an output buffer provided by |
| // vea_use_output_buffer has been processed. |payload_size| |
| // will be set to the number of bytes used. |
| typedef struct vea_processed_output_buffer_event_data { |
| vea_output_buffer_id_t output_buffer_id; |
| uint32_t payload_size; |
| uint8_t key_frame; |
| int64_t timestamp; |
| } vea_processed_output_buffer_event_data_t; |
| |
| // Union of data provided for possible VEA events. |
| typedef union vea_event_data { |
| // Event data for event type REQUIRE_INPUT_BUFFERS. |
| vea_require_input_buffers_event_data_t require_input_buffers; |
| // Event data for event type PROCESSED_INPUT_BUFFER. |
| vea_input_buffer_id_t processed_input_buffer_id; |
| // Event data for event type PROCESSED_OUTPUT_BUFFER. |
| vea_processed_output_buffer_event_data_t processed_output_buffer; |
| // Event data for event type FLUSH_RESPONSE. |
| uint8_t flush_done; |
| // Event data for event type NOTIFY_ERROR. |
| vea_error_t error; |
| } vea_event_data_t; |
| |
| // A struct representing a single VEA event. Structs of this type and size |
| // can be read from |event_pipe_fd| provided in the vea_session_info_t struct. |
| typedef struct vea_event { |
| vea_event_type_t event_type; |
| vea_event_data_t event_data; |
| } vea_event_t; |
| |
| // Initializes the livda encode API and return an implementation object of type |
| // |impl_type|. The returned implementation object can be used as a global |
| // context for creating new encode sessions. |
| void* LIBVDA_EXPORT initialize_encode(vea_impl_type_t type); |
| |
| // Deinitializes the implementation object. This should be called after |
| // all encoding contexts have been closed with close_encode_session. |
| // The provided object will be destroyed and can no longer be used as an |
| // argument for get_vea_capabilities, init_encode_session, or |
| // close_encode_session. |
| void LIBVDA_EXPORT deinitialize_encode(void* impl); |
| |
| // Returns the underlying implementation capabilities of the provided |
| // implementation object. Ownership of the returned vea_capabilities_t object |
| // is retained by the library. When deinitialize_encode() is called on |impl|, |
| // the capabilities object is deleted. |
| const vea_capabilities_t* LIBVDA_EXPORT get_vea_capabilities(void* impl); |
| |
| // Creates and initializes a new encode session that supports encoding |
| // configuration |config|, using the provided implementation object. |
| // |
| // The returned vea_session_info_t object contains an initialized encode session |
| // context, |ctx|. |ctx| can then be used as an argument in invocations of |
| // vea_encode, vea_use_output_buffer, vea_request_encoding_params_change, |
| // and vea_flush. |
| // NULL is returned if an error occurs and an encode session could not be |
| // initialized. |
| vea_session_info_t* LIBVDA_EXPORT init_encode_session(void* impl, |
| vea_config_t* config); |
| |
| // Close a previously created encode session specified by |session_info|. |
| void LIBVDA_EXPORT close_encode_session(void* impl, |
| vea_session_info_t* session_info); |
| |
| // Encodes the frame provided by the buffer specified by |fd|. |
| // |
| // The caller is responsible for passing in a unique value for |
| // |input_buffer_id| which it can reference when handling |
| // PROCESSED_INPUT_BUFFER events. |
| // |
| // Setting |force_keyframe| to true will signal to the encoder implementation |
| // to generate a keyframe from the raw frame at buffer |fd|. |
| // |
| // When the frame has been processed and the buffer is no longer needed, a |
| // vea_event_t struct with type PROCESSED_INPUT_BUFFER and |
| // processed_input_buffer_id set to |input_buffer_id| can be received from |
| // the event pipe. |
| // |
| // When the buffer has been encoded, a vea_event_t struct with type |
| // PROCESSED_OUTPUT_BUFFER will be readable from the event pipe with an |
| // instantiated vea_processed_output_buffer_event_data struct. The timestamp |
| // field in vea_processed_output_buffer_event_data will be the same as the |
| // value passed in as |timestamp|. See vea_use_output_buffer() below for |
| // details on providing output buffers. |
| // |
| // The returned value will be 0 when the request was successfully sent. |
| int LIBVDA_EXPORT vea_encode(void* ctx, |
| vea_input_buffer_id_t input_buffer_id, |
| int fd, |
| size_t num_planes, |
| video_frame_plane_t* planes, |
| int64_t timestamp, |
| uint8_t force_keyframe); |
| |
| // Provide a buffer for storing encoded output. |
| // |
| // The caller is responsible for passing in a unique value for |
| // |output_buffer_id| which it can reference when handling |
| // PROCESSED_OUTPUT_BUFFER events. |
| // |
| // When the output buffer has been filled, a vea_event_t struct with |
| // type PROCESSED_OUTPUT_BUFFER and processed_output_buffer_id set to |
| // |output_buffer_id| can be received from the event pipe. |
| // |
| // The returned value will be 0 if the request was successfully sent. |
| int LIBVDA_EXPORT vea_use_output_buffer(void* ctx, |
| vea_output_buffer_id_t output_buffer_id, |
| int fd, |
| uint32_t offset, |
| uint32_t size); |
| |
| // Requests a change to encoding parameters. |
| // The request is not guaranteed to be honored and could be ignored by the |
| // backing encoder implementation. |
| // The returned value will be 0 when the param change request has been |
| // successfully sent. |
| int LIBVDA_EXPORT vea_request_encoding_params_change(void* ctx, |
| uint32_t bitrate, |
| uint32_t framerate); |
| |
| // Requests the encoder to flush. All pending buffers provided by vea_encode |
| // will be encoded. When the flush has completed, a vea_event_type_t struct with |
| // type FLUSH_RESPONSE can be received from the event pipe. |
| // |
| // The user should not invoke additional vea_flush or vea_encode calls until |
| // a FLUSH_RESPONSE has been read from the event pipe. |
| // |
| // The returned value will be 0 when the flush request has been successfully |
| // sent. |
| int LIBVDA_EXPORT vea_flush(void* ctx); |
| |
| #ifdef __cplusplus |
| } |
| #endif |
| |
| #endif // ARC_VM_LIBVDA_LIBVDA_ENCODE_H_ |