Enum ffmpeg_next::util::format::sample::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<Sample> for Sample

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

This method tests for self and other values to be equal, and is used by ==.

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

This method 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 StructuralEq for Sample

impl StructuralPartialEq for Sample