Enum Sample

pub enum Sample {
    None,
    U8(Type),
    I16(Type),
    I32(Type),
    I64(Type),
    F32(Type),
    F64(Type),
}

Variants

None

U8(Type)

I16(Type)

I32(Type)

I64(Type)

F32(Type)

F64(Type)

Implementations

impl Sample

pub fn name(&self) -> &'static str

Examples found in repository

examples/transcode-audio.rs (line 20)

fn filter(
    spec: &str,
    decoder: &codec::decoder::Audio,
    encoder: &codec::encoder::Audio,
) -> Result<filter::Graph, ffmpeg::Error> {
    let mut filter = filter::Graph::new();

    let args = format!(
        "time_base={}:sample_rate={}:sample_fmt={}:channel_layout=0x{:x}",
        decoder.time_base(),
        decoder.rate(),
        decoder.format().name(),
        decoder.channel_layout().bits()
    );

    filter.add(&filter::find("abuffer").unwrap(), "in", &args)?;
    filter.add(&filter::find("abuffersink").unwrap(), "out", "")?;

    {
        let mut out = filter.get("out").unwrap();

        out.set_sample_format(encoder.format());
        out.set_channel_layout(encoder.channel_layout());
        out.set_sample_rate(encoder.rate());
    }

    filter.output("in", 0)?.input("out", 0)?.parse(spec)?;
    filter.validate()?;

    println!("{}", filter.dump());

    if let Some(codec) = encoder.codec() {
        if !codec
            .capabilities()
            .contains(ffmpeg::codec::capabilities::Capabilities::VARIABLE_FRAME_SIZE)
        {
            filter
                .get("out")
                .unwrap()
                .sink()
                .set_frame_size(encoder.frame_size());
        }
    }

    Ok(filter)
}

pub fn packed(&self) -> Self

pub fn planar(&self) -> Self

pub fn is_planar(&self) -> bool

pub fn is_packed(&self) -> bool

pub fn bytes(&self) -> usize

pub fn buffer(&self, channels: u16, samples: usize, align: bool) -> Buffer

Trait Implementations

impl Clone for Sample

fn clone(&self) -> Sample

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Sample

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

Formats the value using the given formatter.

impl From<&'static str> for Sample

fn from(value: &'static str) -> Self

Converts to this type from the input type.

impl From<AVSampleFormat> for Sample

fn from(value: AVSampleFormat) -> Self

Converts to this type from the input type.

impl From<Sample> for AVSampleFormat

fn from(value: Sample) -> AVSampleFormat

Converts to this type from the input type.

impl PartialEq for Sample

fn eq(&self, other: &Sample) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for Sample

impl Eq for Sample

impl StructuralPartialEq for Sample