Struct SimpleFramePool 

pub struct SimpleFramePool { /* private fields */ }

A simple frame pool implementation with fixed capacity.

This pool stores a fixed number of frame buffers and reuses them during video decoding. When the pool is empty, callers must allocate new buffers directly.

Thread Safety

This implementation uses a Mutex internally, making it safe to share across threads.

Examples

use ff_decode::{VideoDecoder, SimpleFramePool};

// Create a pool with capacity for 32 frames (automatically initialized)
let pool = SimpleFramePool::new(32);

let decoder = VideoDecoder::open("video.mp4")?
    .frame_pool(pool)
    .build()?;

// Frames are acquired from the pool during decoding
for frame in decoder.frames().take(100) {
    let frame = frame?;
    // Process frame...
}

Implementations

impl SimpleFramePool

pub fn new(max_capacity: usize) -> Arc<Self>

Creates a new frame pool with the specified maximum capacity.

This function uses RAII (Resource Acquisition Is Initialization) pattern and automatically initializes the pool’s self-reference, eliminating the need for a separate initialization step.

Arguments

• max_capacity - Maximum number of buffers to keep in the pool. When the pool is full, returned buffers are dropped instead of being stored.

Examples

use ff_decode::SimpleFramePool;
use std::sync::Arc;

// Create a pool for 32 frames - automatically initialized
let pool = SimpleFramePool::new(32);

// Use with decoder
let decoder = VideoDecoder::open("video.mp4")?
    .frame_pool(pool)
    .build()?;

pub fn max_capacity(&self) -> usize

Returns the maximum capacity of this pool.

pub fn available(&self) -> usize

Returns the current number of buffers available in the pool.

Examples

use ff_decode::SimpleFramePool;

let pool = SimpleFramePool::new(32);
assert_eq!(pool.available(), 0); // Pool starts empty

Trait Implementations

impl Debug for SimpleFramePool

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl FramePool for SimpleFramePool

fn acquire(&self, size: usize) -> Option<PooledBuffer>

Acquires a buffer of at least the specified size from the pool.

fn release(&self, buffer: Vec<u8>)

Returns a buffer to the pool.