Struct devices::virtio::video::encoder::backend::ffmpeg::FfmpegEncoderSession

pub struct FfmpegEncoderSession {
    event_queue: Arc<SyncEventQueue<EncoderEvent>>,
    codec_jobs: VecDeque<CodecJob>,
    output_queue: VecDeque<(u32, MemoryMappingArena)>,
    is_flushing: bool,
    context: AvCodecContext,
    next_input_buffer_id: u32,
    next_output_buffer_id: u32,
}

Fields

event_queue: Arc<SyncEventQueue<EncoderEvent>>

Queue of events waiting to be read by the client.

codec_jobs: VecDeque<CodecJob>

FIFO of jobs submitted by the client and waiting to be performed.

output_queue: VecDeque<(u32, MemoryMappingArena)>

Queue of (unfilled) output buffers to fill with upcoming encoder output.

is_flushing: bool

true if a flush is pending. While a pending flush exist, input buffers are temporarily held on and not sent to the encoder. An actual flush call will be issued when we run out of output buffers (to defend against FFmpeg bugs), and we’ll try to receive outputs again until we receive another code indicating the flush has completed, at which point this flag will be reset.

context: AvCodecContext

The libav context for this session.

next_input_buffer_id: u32

next_output_buffer_id: u32

Implementations

impl FfmpegEncoderSession

fn try_send_input_job(&mut self) -> Result<bool, VideoError>

Try to send one input frame to the codec for encode.

Returns Ok(true) if the frame was successfully queued, Ok(false) if the frame was not queued due to the queue being full or an in-progress flushing, and Err in case of errors.

fn try_receive_packet(&mut self) -> Result<bool, VideoError>

Try to retrieve one encoded packet from the codec, and if success, deliver it to the guest.

Returns Ok(true) if the packet was successfully retrieved and the guest was signaled, Ok(false) if there’s no full packet available right now, and Err in case of error.

fn try_encode(&mut self) -> Result<(), VideoError>

Try to progress through the encoding pipeline, either by sending input frames or by retrieving output packets and delivering them to the guest.

Trait Implementations

impl EncoderSession for FfmpegEncoderSession

fn encode( &mut self, resource: GuestResource, timestamp: u64, force_keyframe: bool ) -> Result<u32, VideoError>

Encodes the frame provided by resource. force_keyframe forces the frame to be encoded as a keyframe. When the buffer has been successfully processed, a ProcessedInputBuffer event will be readable from the event pipe, with the same InputBufferId as returned by this function. When the corresponding encoded data is ready, ProcessedOutputBuffer events will be readable from the event pipe, with the same timestamp as provided timestamp.

fn use_output_buffer( &mut self, resource: GuestResourceHandle, offset: u32, size: u32 ) -> Result<u32, VideoError>

Provides an output resource to store encoded output, where offset and size define the region of memory to use. When the buffer has been filled with encoded output, a ProcessedOutputBuffer event will be readable from the event pipe, with the same OutputBufferId as returned by this function.

fn flush(&mut self) -> Result<(), VideoError>

Requests the encoder to flush. When completed, an EncoderEvent::FlushResponse event will be readable from the event pipe.

fn request_encoding_params_change( &mut self, bitrate: Bitrate, framerate: u32 ) -> Result<(), VideoError>

Requests the encoder to use new encoding parameters provided by bitrate and framerate.

fn event_pipe(&self) -> &dyn AsRawDescriptor

Returns the event pipe on which the availability of events will be signaled. Note that the returned value is borrowed and only valid as long as the session is alive.

fn read_event(&mut self) -> Result<EncoderEvent, VideoError>

Performs a blocking read for an encoder event. This function should only be called when the file descriptor returned by event_pipe is readable.