Struct devices::virtio::video::decoder::backend::ffmpeg::FfmpegDecoderSession

pub struct FfmpegDecoderSession {
    event_queue: Arc<SyncEventQueue<DecoderEvent>>,
    codec_jobs: VecDeque<CodecJob>,
    is_flushing: bool,
    state: SessionState,
    current_visible_res: (usize, usize),
    context: AvCodecContext,
    avframe: Option<AvFrame>,
}

A decoder session for the ffmpeg backend.

Fields

event_queue: Arc<SyncEventQueue<DecoderEvent>>

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.

is_flushing: bool

Whether we are currently flushing.

state: SessionState

Current state of the session.

current_visible_res: (usize, usize)

Visible size of the decoded frames (width, height).

context: AvCodecContext

The libav context for this session.

avframe: Option<AvFrame>

The last frame to have been decoded, waiting to be copied into an output buffer and sent to the client.

Implementations

impl FfmpegDecoderSession

fn queue_event(&mut self, event: DecoderEvent) -> Result<()>

Queue an event for the client to receive.

fn change_resolution( &mut self, new_visible_res: (usize, usize) ) -> Result<(), ChangeResolutionError>

Start the resolution change process, buffers will now be of size new_visible_res.

fn try_send_packet( &mut self, input_packet: &AvPacket<'static> ) -> Result<bool, TrySendPacketError>

Try to send one input packet to the codec.

Returns true if a packet has successfully been queued, false if it could not be, either because all pending work has already been queued or because the codec could not accept more input at the moment.

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

Try to run the next input job, if any.

Returns true if the next job has been submitted, false if it could not be, either because all pending work has already been queued or because the codec could not accept more input at the moment.

fn try_receive_frame(&mut self) -> Result<bool, TryReceiveFrameError>

Try to receive a frame from the codec and store it until we emit the corresponding PictureReady decoder event.

Returns true if a frame was successfully retrieved, or false if no frame was available at the time, a decoded frame is already waiting to be returned to the client, or the decoder needs more input data to proceed further.

fn try_send_frame(&mut self) -> Result<bool, TrySendFrameError>

Try to send a pending decoded frame to the client by copying its content into an output buffer.

This can only be done if self.avframe contains a decoded frame, and an output buffer is ready to be written into.

Returns true if a frame has been emitted, false if the conditions were not met for it to happen yet.

fn try_decode(&mut self) -> Result<(), TryDecodeError>

Try to progress as much as possible with decoding.

Our pipeline has three stages: send encoded input to libavcodec, receive decoded frames from libavcodec, and copy decoded frames into output buffers sent to the client. This method calls these three stages in a loop for as long as at least one makes progress.

Trait Implementations

impl DecoderSession for FfmpegDecoderSession

fn set_output_parameters( &mut self, buffer_count: usize, format: Format ) -> Result<(), VideoError>

Tell how many output buffers will be used for this session and which format they will carry. This method must be called after a ProvidePictureBuffers event is emitted, and before the first call to use_output_buffer().

fn decode( &mut self, resource_id: u32, timestamp: u64, resource: GuestResourceHandle, offset: u32, bytes_used: u32 ) -> Result<(), VideoError>

Decode the compressed stream contained in [offset..offset+bytes_used] of the shared memory in the input resource.

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

Flush the decoder device, i.e. finish processing all queued decode requests and emit frames for them.

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

Reset the decoder device, i.e. cancel all pending decoding requests.

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

Immediately release all buffers passed using use_output_buffer() and reuse_output_buffer().

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 use_output_buffer( &mut self, picture_buffer_id: i32, resource: GuestResource ) -> Result<(), VideoError>

Ask the device to use resource to store decoded frames according to its layout. picture_buffer_id is the ID of the picture that will be reproduced in PictureReady events using this buffer.

fn reuse_output_buffer( &mut self, picture_buffer_id: i32 ) -> Result<(), VideoError>

Ask the device to reuse an output buffer previously passed to use_output_buffer and that has previously been returned to the decoder in a PictureReady event.

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

Blocking call to read a single event from the event pipe.