Struct ChannelLayout

Source

pub struct ChannelLayout { /* private fields */ }

Implementations§

Source §

pub const fn empty() -> ChannelLayout

Returns an empty set of flags

Source

pub const fn all() -> ChannelLayout

Returns the set containing all flags.

Source

pub const fn bits(&self) -> c_ulonglong

Returns the raw value of the flags currently stored.

Examples found in repository ?

examples/transcode-audio.rs (line 21)

9fn filter(
10    spec: &str,
11    decoder: &codec::decoder::Audio,
12    encoder: &codec::encoder::Audio,
13) -> Result<filter::Graph, ffmpeg::Error> {
14    let mut filter = filter::Graph::new();
15
16    let args = format!(
17        "time_base={}:sample_rate={}:sample_fmt={}:channel_layout=0x{:x}",
18        decoder.time_base(),
19        decoder.rate(),
20        decoder.format().name(),
21        decoder.channel_layout().bits()
22    );
23
24    filter.add(&filter::find("abuffer").unwrap(), "in", &args)?;
25    filter.add(&filter::find("abuffersink").unwrap(), "out", "")?;
26
27    {
28        let mut out = filter.get("out").unwrap();
29
30        out.set_sample_format(encoder.format());
31        out.set_channel_layout(encoder.channel_layout());
32        out.set_sample_rate(encoder.rate());
33    }
34
35    filter.output("in", 0)?.input("out", 0)?.parse(spec)?;
36    filter.validate()?;
37
38    println!("{}", filter.dump());
39
40    if let Some(codec) = encoder.codec() {
41        if !codec
42            .capabilities()
43            .contains(ffmpeg::codec::capabilities::Capabilities::VARIABLE_FRAME_SIZE)
44        {
45            filter
46                .get("out")
47                .unwrap()
48                .sink()
49                .set_frame_size(encoder.frame_size());
50        }
51    }
52
53    Ok(filter)
54}

Source

pub fn from_bits(bits: c_ulonglong) -> Option<ChannelLayout>

Convert from underlying bit representation, unless that representation contains bits that do not correspond to a flag.

Source

pub const fn from_bits_truncate(bits: c_ulonglong) -> ChannelLayout

Convert from underlying bit representation, dropping any bits that do not correspond to flags.

Source

pub const unsafe fn from_bits_unchecked(bits: c_ulonglong) -> ChannelLayout

Convert from underlying bit representation, preserving all bits (even those not corresponding to a defined flag).

Source

pub const fn is_empty(&self) -> bool

Returns true if no flags are currently stored.

Source

pub const fn is_all(&self) -> bool

Returns true if all flags are currently set.

Source

pub const fn intersects(&self, other: ChannelLayout) -> bool

Returns true if there are flags common to both self and other.

Source

pub const fn contains(&self, other: ChannelLayout) -> bool

Returns true all of the flags in other are contained within self.

Source

pub fn insert(&mut self, other: ChannelLayout)

Inserts the specified flags in-place.

Source

pub fn remove(&mut self, other: ChannelLayout)

Removes the specified flags in-place.

Source

pub fn toggle(&mut self, other: ChannelLayout)

Toggles the specified flags in-place.

Source

pub fn set(&mut self, other: ChannelLayout, value: bool)

Inserts or removes the specified flags depending on the passed value.

Source §

impl ChannelLayout

Source

pub fn channels(&self) -> i32

Examples found in repository ?

examples/transcode-audio.rs (line 89)

63fn transcoder<P: AsRef<Path>>(
64    ictx: &mut format::context::Input,
65    octx: &mut format::context::Output,
66    path: &P,
67    filter_spec: &str,
68) -> Result<Transcoder, ffmpeg::Error> {
69    let input = ictx
70        .streams()
71        .best(media::Type::Audio)
72        .expect("could not find best audio stream");
73    let mut decoder = input.codec().decoder().audio()?;
74    let codec = ffmpeg::encoder::find(octx.format().codec(path, media::Type::Audio))
75        .expect("failed to find encoder")
76        .audio()?;
77    let global = octx
78        .format()
79        .flags()
80        .contains(ffmpeg::format::flag::Flags::GLOBAL_HEADER);
81
82    decoder.set_parameters(input.parameters())?;
83
84    let mut output = octx.add_stream(codec)?;
85    let mut encoder = output.codec().encoder().audio()?;
86
87    let channel_layout = codec
88        .channel_layouts()
89        .map(|cls| cls.best(decoder.channel_layout().channels()))
90        .unwrap_or(ffmpeg::channel_layout::ChannelLayout::STEREO);
91
92    if global {
93        encoder.set_flags(ffmpeg::codec::flag::Flags::GLOBAL_HEADER);
94    }
95
96    encoder.set_rate(decoder.rate() as i32);
97    encoder.set_channel_layout(channel_layout);
98    encoder.set_channels(channel_layout.channels());
99    encoder.set_format(
100        codec
101            .formats()
102            .expect("unknown supported formats")
103            .next()
104            .unwrap(),
105    );
106    encoder.set_bit_rate(decoder.bit_rate());
107    encoder.set_max_bit_rate(decoder.max_bit_rate());
108
109    encoder.set_time_base((1, decoder.rate() as i32));
110    output.set_time_base((1, decoder.rate() as i32));
111
112    let encoder = encoder.open_as(codec)?;
113    output.set_parameters(&encoder);
114
115    let filter = filter(filter_spec, &decoder, &encoder)?;
116
117    Ok(Transcoder {
118        stream: input.index(),
119        filter: filter,
120        decoder: decoder,
121        encoder: encoder,
122    })
123}