ffmpeg_rs::codec::audio

Struct Audio

Source 
pub struct Audio { /* private fields */ }

Implementations§

Source§

impl Audio

Source

pub unsafe fn new(codec: Codec) -> Audio

Source§

impl Audio

Source

pub fn rates(&self) -> Option<RateIter>

Examples found in repository?
examples/codec-info.rs (line 37)
4fn main() {
5    ffmpeg_rs::init().unwrap();
6
7    for arg in env::args().skip(1) {
8        if let Some(codec) = ffmpeg_rs::decoder::find_by_name(&arg) {
9            println!("type: decoder");
10            println!("\t id: {:?}", codec.id());
11            println!("\t name: {}", codec.name());
12            println!("\t description: {}", codec.description());
13            println!("\t medium: {:?}", codec.medium());
14            println!("\t capabilities: {:?}", codec.capabilities());
15
16            if let Some(profiles) = codec.profiles() {
17                println!("\t profiles: {:?}", profiles.collect::<Vec<_>>());
18            } else {
19                println!("\t profiles: none");
20            }
21
22            if let Ok(video) = codec.video() {
23                if let Some(rates) = video.rates() {
24                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
25                } else {
26                    println!("\t rates: any");
27                }
28
29                if let Some(formats) = video.formats() {
30                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
31                } else {
32                    println!("\t formats: any");
33                }
34            }
35
36            if let Ok(audio) = codec.audio() {
37                if let Some(rates) = audio.rates() {
38                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
39                } else {
40                    println!("\t rates: any");
41                }
42
43                if let Some(formats) = audio.formats() {
44                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
45                } else {
46                    println!("\t formats: any");
47                }
48
49                if let Some(layouts) = audio.channel_layouts() {
50                    println!("\t channel_layouts: {:?}", layouts.collect::<Vec<_>>());
51                } else {
52                    println!("\t channel_layouts: any");
53                }
54            }
55
56            println!("\t max_lowres: {:?}", codec.max_lowres());
57        }
58
59        if let Some(codec) = ffmpeg_rs::encoder::find_by_name(&arg) {
60            println!();
61            println!("type: encoder");
62            println!("\t id: {:?}", codec.id());
63            println!("\t name: {}", codec.name());
64            println!("\t description: {}", codec.description());
65            println!("\t medium: {:?}", codec.medium());
66            println!("\t capabilities: {:?}", codec.capabilities());
67
68            if let Some(profiles) = codec.profiles() {
69                println!("\t profiles: {:?}", profiles.collect::<Vec<_>>());
70            }
71
72            if let Ok(video) = codec.video() {
73                if let Some(rates) = video.rates() {
74                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
75                } else {
76                    println!("\t rates: any");
77                }
78
79                if let Some(formats) = video.formats() {
80                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
81                } else {
82                    println!("\t formats: any");
83                }
84            }
85
86            if let Ok(audio) = codec.audio() {
87                if let Some(rates) = audio.rates() {
88                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
89                } else {
90                    println!("\t rates: any");
91                }
92
93                if let Some(formats) = audio.formats() {
94                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
95                } else {
96                    println!("\t formats: any");
97                }
98
99                if let Some(layouts) = audio.channel_layouts() {
100                    println!("\t channel_layouts: {:?}", layouts.collect::<Vec<_>>());
101                } else {
102                    println!("\t channel_layouts: any");
103                }
104            }
105
106            println!("\t max_lowres: {:?}", codec.max_lowres());
107        }
108    }
109}
Source

pub fn formats(&self) -> Option<FormatIter>

Examples found in repository?
examples/transcode-audio.rs (line 104)
64fn transcoder<P: AsRef<Path>>(
65    ictx: &mut format::context::Input,
66    octx: &mut format::context::Output,
67    path: &P,
68    filter_spec: &str,
69) -> Result<Transcoder, ffmpeg_rs::Error> {
70    let input = ictx
71        .streams()
72        .best(media::Type::Audio)
73        .expect("could not find best audio stream");
74    let context = ffmpeg_rs::codec::context::Context::from_parameters(input.parameters())?;
75    let mut decoder = context.decoder().audio()?;
76    let codec = ffmpeg_rs::encoder::find(octx.format().codec(path, media::Type::Audio))
77        .expect("failed to find encoder")
78        .audio()?;
79    let global = octx
80        .format()
81        .flags()
82        .contains(ffmpeg_rs::format::flag::Flags::GLOBAL_HEADER);
83
84    decoder.set_parameters(input.parameters())?;
85
86    let mut output = octx.add_stream(codec)?;
87    let context = ffmpeg_rs::codec::context::Context::from_parameters(output.parameters())?;
88    let mut encoder = context.encoder().audio()?;
89
90    let channel_layout = codec
91        .channel_layouts()
92        .map(|cls| cls.best(decoder.channel_layout().channels()))
93        .unwrap_or(ffmpeg_rs::channel_layout::ChannelLayout::STEREO);
94
95    if global {
96        encoder.set_flags(ffmpeg_rs::codec::flag::Flags::GLOBAL_HEADER);
97    }
98
99    encoder.set_rate(decoder.rate() as i32);
100    encoder.set_channel_layout(channel_layout);
101    encoder.set_channels(channel_layout.channels());
102    encoder.set_format(
103        codec
104            .formats()
105            .expect("unknown supported formats")
106            .next()
107            .unwrap(),
108    );
109    encoder.set_bit_rate(decoder.bit_rate());
110    encoder.set_max_bit_rate(decoder.max_bit_rate());
111
112    encoder.set_time_base((1, decoder.rate() as i32));
113    output.set_time_base((1, decoder.rate() as i32));
114
115    let encoder = encoder.open_as(codec)?;
116    output.set_parameters(&encoder);
117
118    let filter = filter(filter_spec, &decoder, &encoder)?;
119
120    let in_time_base = decoder.time_base();
121    let out_time_base = output.time_base();
122
123    Ok(Transcoder {
124        stream: input.index(),
125        filter,
126        decoder,
127        encoder,
128        in_time_base,
129        out_time_base,
130    })
131}
More examples
Hide additional examples
examples/codec-info.rs (line 43)
4fn main() {
5    ffmpeg_rs::init().unwrap();
6
7    for arg in env::args().skip(1) {
8        if let Some(codec) = ffmpeg_rs::decoder::find_by_name(&arg) {
9            println!("type: decoder");
10            println!("\t id: {:?}", codec.id());
11            println!("\t name: {}", codec.name());
12            println!("\t description: {}", codec.description());
13            println!("\t medium: {:?}", codec.medium());
14            println!("\t capabilities: {:?}", codec.capabilities());
15
16            if let Some(profiles) = codec.profiles() {
17                println!("\t profiles: {:?}", profiles.collect::<Vec<_>>());
18            } else {
19                println!("\t profiles: none");
20            }
21
22            if let Ok(video) = codec.video() {
23                if let Some(rates) = video.rates() {
24                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
25                } else {
26                    println!("\t rates: any");
27                }
28
29                if let Some(formats) = video.formats() {
30                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
31                } else {
32                    println!("\t formats: any");
33                }
34            }
35
36            if let Ok(audio) = codec.audio() {
37                if let Some(rates) = audio.rates() {
38                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
39                } else {
40                    println!("\t rates: any");
41                }
42
43                if let Some(formats) = audio.formats() {
44                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
45                } else {
46                    println!("\t formats: any");
47                }
48
49                if let Some(layouts) = audio.channel_layouts() {
50                    println!("\t channel_layouts: {:?}", layouts.collect::<Vec<_>>());
51                } else {
52                    println!("\t channel_layouts: any");
53                }
54            }
55
56            println!("\t max_lowres: {:?}", codec.max_lowres());
57        }
58
59        if let Some(codec) = ffmpeg_rs::encoder::find_by_name(&arg) {
60            println!();
61            println!("type: encoder");
62            println!("\t id: {:?}", codec.id());
63            println!("\t name: {}", codec.name());
64            println!("\t description: {}", codec.description());
65            println!("\t medium: {:?}", codec.medium());
66            println!("\t capabilities: {:?}", codec.capabilities());
67
68            if let Some(profiles) = codec.profiles() {
69                println!("\t profiles: {:?}", profiles.collect::<Vec<_>>());
70            }
71
72            if let Ok(video) = codec.video() {
73                if let Some(rates) = video.rates() {
74                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
75                } else {
76                    println!("\t rates: any");
77                }
78
79                if let Some(formats) = video.formats() {
80                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
81                } else {
82                    println!("\t formats: any");
83                }
84            }
85
86            if let Ok(audio) = codec.audio() {
87                if let Some(rates) = audio.rates() {
88                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
89                } else {
90                    println!("\t rates: any");
91                }
92
93                if let Some(formats) = audio.formats() {
94                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
95                } else {
96                    println!("\t formats: any");
97                }
98
99                if let Some(layouts) = audio.channel_layouts() {
100                    println!("\t channel_layouts: {:?}", layouts.collect::<Vec<_>>());
101                } else {
102                    println!("\t channel_layouts: any");
103                }
104            }
105
106            println!("\t max_lowres: {:?}", codec.max_lowres());
107        }
108    }
109}
Source

pub fn channel_layouts(&self) -> Option<ChannelLayoutIter>

Examples found in repository?
examples/transcode-audio.rs (line 91)
64fn transcoder<P: AsRef<Path>>(
65    ictx: &mut format::context::Input,
66    octx: &mut format::context::Output,
67    path: &P,
68    filter_spec: &str,
69) -> Result<Transcoder, ffmpeg_rs::Error> {
70    let input = ictx
71        .streams()
72        .best(media::Type::Audio)
73        .expect("could not find best audio stream");
74    let context = ffmpeg_rs::codec::context::Context::from_parameters(input.parameters())?;
75    let mut decoder = context.decoder().audio()?;
76    let codec = ffmpeg_rs::encoder::find(octx.format().codec(path, media::Type::Audio))
77        .expect("failed to find encoder")
78        .audio()?;
79    let global = octx
80        .format()
81        .flags()
82        .contains(ffmpeg_rs::format::flag::Flags::GLOBAL_HEADER);
83
84    decoder.set_parameters(input.parameters())?;
85
86    let mut output = octx.add_stream(codec)?;
87    let context = ffmpeg_rs::codec::context::Context::from_parameters(output.parameters())?;
88    let mut encoder = context.encoder().audio()?;
89
90    let channel_layout = codec
91        .channel_layouts()
92        .map(|cls| cls.best(decoder.channel_layout().channels()))
93        .unwrap_or(ffmpeg_rs::channel_layout::ChannelLayout::STEREO);
94
95    if global {
96        encoder.set_flags(ffmpeg_rs::codec::flag::Flags::GLOBAL_HEADER);
97    }
98
99    encoder.set_rate(decoder.rate() as i32);
100    encoder.set_channel_layout(channel_layout);
101    encoder.set_channels(channel_layout.channels());
102    encoder.set_format(
103        codec
104            .formats()
105            .expect("unknown supported formats")
106            .next()
107            .unwrap(),
108    );
109    encoder.set_bit_rate(decoder.bit_rate());
110    encoder.set_max_bit_rate(decoder.max_bit_rate());
111
112    encoder.set_time_base((1, decoder.rate() as i32));
113    output.set_time_base((1, decoder.rate() as i32));
114
115    let encoder = encoder.open_as(codec)?;
116    output.set_parameters(&encoder);
117
118    let filter = filter(filter_spec, &decoder, &encoder)?;
119
120    let in_time_base = decoder.time_base();
121    let out_time_base = output.time_base();
122
123    Ok(Transcoder {
124        stream: input.index(),
125        filter,
126        decoder,
127        encoder,
128        in_time_base,
129        out_time_base,
130    })
131}
More examples
Hide additional examples
examples/codec-info.rs (line 49)
4fn main() {
5    ffmpeg_rs::init().unwrap();
6
7    for arg in env::args().skip(1) {
8        if let Some(codec) = ffmpeg_rs::decoder::find_by_name(&arg) {
9            println!("type: decoder");
10            println!("\t id: {:?}", codec.id());
11            println!("\t name: {}", codec.name());
12            println!("\t description: {}", codec.description());
13            println!("\t medium: {:?}", codec.medium());
14            println!("\t capabilities: {:?}", codec.capabilities());
15
16            if let Some(profiles) = codec.profiles() {
17                println!("\t profiles: {:?}", profiles.collect::<Vec<_>>());
18            } else {
19                println!("\t profiles: none");
20            }
21
22            if let Ok(video) = codec.video() {
23                if let Some(rates) = video.rates() {
24                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
25                } else {
26                    println!("\t rates: any");
27                }
28
29                if let Some(formats) = video.formats() {
30                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
31                } else {
32                    println!("\t formats: any");
33                }
34            }
35
36            if let Ok(audio) = codec.audio() {
37                if let Some(rates) = audio.rates() {
38                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
39                } else {
40                    println!("\t rates: any");
41                }
42
43                if let Some(formats) = audio.formats() {
44                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
45                } else {
46                    println!("\t formats: any");
47                }
48
49                if let Some(layouts) = audio.channel_layouts() {
50                    println!("\t channel_layouts: {:?}", layouts.collect::<Vec<_>>());
51                } else {
52                    println!("\t channel_layouts: any");
53                }
54            }
55
56            println!("\t max_lowres: {:?}", codec.max_lowres());
57        }
58
59        if let Some(codec) = ffmpeg_rs::encoder::find_by_name(&arg) {
60            println!();
61            println!("type: encoder");
62            println!("\t id: {:?}", codec.id());
63            println!("\t name: {}", codec.name());
64            println!("\t description: {}", codec.description());
65            println!("\t medium: {:?}", codec.medium());
66            println!("\t capabilities: {:?}", codec.capabilities());
67
68            if let Some(profiles) = codec.profiles() {
69                println!("\t profiles: {:?}", profiles.collect::<Vec<_>>());
70            }
71
72            if let Ok(video) = codec.video() {
73                if let Some(rates) = video.rates() {
74                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
75                } else {
76                    println!("\t rates: any");
77                }
78
79                if let Some(formats) = video.formats() {
80                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
81                } else {
82                    println!("\t formats: any");
83                }
84            }
85
86            if let Ok(audio) = codec.audio() {
87                if let Some(rates) = audio.rates() {
88                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
89                } else {
90                    println!("\t rates: any");
91                }
92
93                if let Some(formats) = audio.formats() {
94                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
95                } else {
96                    println!("\t formats: any");
97                }
98
99                if let Some(layouts) = audio.channel_layouts() {
100                    println!("\t channel_layouts: {:?}", layouts.collect::<Vec<_>>());
101                } else {
102                    println!("\t channel_layouts: any");
103                }
104            }
105
106            println!("\t max_lowres: {:?}", codec.max_lowres());
107        }
108    }
109}

Methods from Deref<Target = Codec>§

Source

pub unsafe fn as_ptr(&self) -> *const AVCodec

Source

pub fn is_encoder(&self) -> bool

Source

pub fn is_decoder(&self) -> bool

Source

pub fn name(&self) -> &str

Examples found in repository?
examples/codec-info.rs (line 11)
4fn main() {
5    ffmpeg_rs::init().unwrap();
6
7    for arg in env::args().skip(1) {
8        if let Some(codec) = ffmpeg_rs::decoder::find_by_name(&arg) {
9            println!("type: decoder");
10            println!("\t id: {:?}", codec.id());
11            println!("\t name: {}", codec.name());
12            println!("\t description: {}", codec.description());
13            println!("\t medium: {:?}", codec.medium());
14            println!("\t capabilities: {:?}", codec.capabilities());
15
16            if let Some(profiles) = codec.profiles() {
17                println!("\t profiles: {:?}", profiles.collect::<Vec<_>>());
18            } else {
19                println!("\t profiles: none");
20            }
21
22            if let Ok(video) = codec.video() {
23                if let Some(rates) = video.rates() {
24                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
25                } else {
26                    println!("\t rates: any");
27                }
28
29                if let Some(formats) = video.formats() {
30                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
31                } else {
32                    println!("\t formats: any");
33                }
34            }
35
36            if let Ok(audio) = codec.audio() {
37                if let Some(rates) = audio.rates() {
38                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
39                } else {
40                    println!("\t rates: any");
41                }
42
43                if let Some(formats) = audio.formats() {
44                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
45                } else {
46                    println!("\t formats: any");
47                }
48
49                if let Some(layouts) = audio.channel_layouts() {
50                    println!("\t channel_layouts: {:?}", layouts.collect::<Vec<_>>());
51                } else {
52                    println!("\t channel_layouts: any");
53                }
54            }
55
56            println!("\t max_lowres: {:?}", codec.max_lowres());
57        }
58
59        if let Some(codec) = ffmpeg_rs::encoder::find_by_name(&arg) {
60            println!();
61            println!("type: encoder");
62            println!("\t id: {:?}", codec.id());
63            println!("\t name: {}", codec.name());
64            println!("\t description: {}", codec.description());
65            println!("\t medium: {:?}", codec.medium());
66            println!("\t capabilities: {:?}", codec.capabilities());
67
68            if let Some(profiles) = codec.profiles() {
69                println!("\t profiles: {:?}", profiles.collect::<Vec<_>>());
70            }
71
72            if let Ok(video) = codec.video() {
73                if let Some(rates) = video.rates() {
74                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
75                } else {
76                    println!("\t rates: any");
77                }
78
79                if let Some(formats) = video.formats() {
80                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
81                } else {
82                    println!("\t formats: any");
83                }
84            }
85
86            if let Ok(audio) = codec.audio() {
87                if let Some(rates) = audio.rates() {
88                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
89                } else {
90                    println!("\t rates: any");
91                }
92
93                if let Some(formats) = audio.formats() {
94                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
95                } else {
96                    println!("\t formats: any");
97                }
98
99                if let Some(layouts) = audio.channel_layouts() {
100                    println!("\t channel_layouts: {:?}", layouts.collect::<Vec<_>>());
101                } else {
102                    println!("\t channel_layouts: any");
103                }
104            }
105
106            println!("\t max_lowres: {:?}", codec.max_lowres());
107        }
108    }
109}
Source

pub fn description(&self) -> &str

Examples found in repository?
examples/codec-info.rs (line 12)
4fn main() {
5    ffmpeg_rs::init().unwrap();
6
7    for arg in env::args().skip(1) {
8        if let Some(codec) = ffmpeg_rs::decoder::find_by_name(&arg) {
9            println!("type: decoder");
10            println!("\t id: {:?}", codec.id());
11            println!("\t name: {}", codec.name());
12            println!("\t description: {}", codec.description());
13            println!("\t medium: {:?}", codec.medium());
14            println!("\t capabilities: {:?}", codec.capabilities());
15
16            if let Some(profiles) = codec.profiles() {
17                println!("\t profiles: {:?}", profiles.collect::<Vec<_>>());
18            } else {
19                println!("\t profiles: none");
20            }
21
22            if let Ok(video) = codec.video() {
23                if let Some(rates) = video.rates() {
24                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
25                } else {
26                    println!("\t rates: any");
27                }
28
29                if let Some(formats) = video.formats() {
30                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
31                } else {
32                    println!("\t formats: any");
33                }
34            }
35
36            if let Ok(audio) = codec.audio() {
37                if let Some(rates) = audio.rates() {
38                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
39                } else {
40                    println!("\t rates: any");
41                }
42
43                if let Some(formats) = audio.formats() {
44                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
45                } else {
46                    println!("\t formats: any");
47                }
48
49                if let Some(layouts) = audio.channel_layouts() {
50                    println!("\t channel_layouts: {:?}", layouts.collect::<Vec<_>>());
51                } else {
52                    println!("\t channel_layouts: any");
53                }
54            }
55
56            println!("\t max_lowres: {:?}", codec.max_lowres());
57        }
58
59        if let Some(codec) = ffmpeg_rs::encoder::find_by_name(&arg) {
60            println!();
61            println!("type: encoder");
62            println!("\t id: {:?}", codec.id());
63            println!("\t name: {}", codec.name());
64            println!("\t description: {}", codec.description());
65            println!("\t medium: {:?}", codec.medium());
66            println!("\t capabilities: {:?}", codec.capabilities());
67
68            if let Some(profiles) = codec.profiles() {
69                println!("\t profiles: {:?}", profiles.collect::<Vec<_>>());
70            }
71
72            if let Ok(video) = codec.video() {
73                if let Some(rates) = video.rates() {
74                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
75                } else {
76                    println!("\t rates: any");
77                }
78
79                if let Some(formats) = video.formats() {
80                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
81                } else {
82                    println!("\t formats: any");
83                }
84            }
85
86            if let Ok(audio) = codec.audio() {
87                if let Some(rates) = audio.rates() {
88                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
89                } else {
90                    println!("\t rates: any");
91                }
92
93                if let Some(formats) = audio.formats() {
94                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
95                } else {
96                    println!("\t formats: any");
97                }
98
99                if let Some(layouts) = audio.channel_layouts() {
100                    println!("\t channel_layouts: {:?}", layouts.collect::<Vec<_>>());
101                } else {
102                    println!("\t channel_layouts: any");
103                }
104            }
105
106            println!("\t max_lowres: {:?}", codec.max_lowres());
107        }
108    }
109}
Source

pub fn medium(&self) -> Type

Examples found in repository?
examples/codec-info.rs (line 13)
4fn main() {
5    ffmpeg_rs::init().unwrap();
6
7    for arg in env::args().skip(1) {
8        if let Some(codec) = ffmpeg_rs::decoder::find_by_name(&arg) {
9            println!("type: decoder");
10            println!("\t id: {:?}", codec.id());
11            println!("\t name: {}", codec.name());
12            println!("\t description: {}", codec.description());
13            println!("\t medium: {:?}", codec.medium());
14            println!("\t capabilities: {:?}", codec.capabilities());
15
16            if let Some(profiles) = codec.profiles() {
17                println!("\t profiles: {:?}", profiles.collect::<Vec<_>>());
18            } else {
19                println!("\t profiles: none");
20            }
21
22            if let Ok(video) = codec.video() {
23                if let Some(rates) = video.rates() {
24                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
25                } else {
26                    println!("\t rates: any");
27                }
28
29                if let Some(formats) = video.formats() {
30                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
31                } else {
32                    println!("\t formats: any");
33                }
34            }
35
36            if let Ok(audio) = codec.audio() {
37                if let Some(rates) = audio.rates() {
38                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
39                } else {
40                    println!("\t rates: any");
41                }
42
43                if let Some(formats) = audio.formats() {
44                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
45                } else {
46                    println!("\t formats: any");
47                }
48
49                if let Some(layouts) = audio.channel_layouts() {
50                    println!("\t channel_layouts: {:?}", layouts.collect::<Vec<_>>());
51                } else {
52                    println!("\t channel_layouts: any");
53                }
54            }
55
56            println!("\t max_lowres: {:?}", codec.max_lowres());
57        }
58
59        if let Some(codec) = ffmpeg_rs::encoder::find_by_name(&arg) {
60            println!();
61            println!("type: encoder");
62            println!("\t id: {:?}", codec.id());
63            println!("\t name: {}", codec.name());
64            println!("\t description: {}", codec.description());
65            println!("\t medium: {:?}", codec.medium());
66            println!("\t capabilities: {:?}", codec.capabilities());
67
68            if let Some(profiles) = codec.profiles() {
69                println!("\t profiles: {:?}", profiles.collect::<Vec<_>>());
70            }
71
72            if let Ok(video) = codec.video() {
73                if let Some(rates) = video.rates() {
74                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
75                } else {
76                    println!("\t rates: any");
77                }
78
79                if let Some(formats) = video.formats() {
80                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
81                } else {
82                    println!("\t formats: any");
83                }
84            }
85
86            if let Ok(audio) = codec.audio() {
87                if let Some(rates) = audio.rates() {
88                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
89                } else {
90                    println!("\t rates: any");
91                }
92
93                if let Some(formats) = audio.formats() {
94                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
95                } else {
96                    println!("\t formats: any");
97                }
98
99                if let Some(layouts) = audio.channel_layouts() {
100                    println!("\t channel_layouts: {:?}", layouts.collect::<Vec<_>>());
101                } else {
102                    println!("\t channel_layouts: any");
103                }
104            }
105
106            println!("\t max_lowres: {:?}", codec.max_lowres());
107        }
108    }
109}
Source

pub fn id(&self) -> Id

Examples found in repository?
examples/codec-info.rs (line 10)
4fn main() {
5    ffmpeg_rs::init().unwrap();
6
7    for arg in env::args().skip(1) {
8        if let Some(codec) = ffmpeg_rs::decoder::find_by_name(&arg) {
9            println!("type: decoder");
10            println!("\t id: {:?}", codec.id());
11            println!("\t name: {}", codec.name());
12            println!("\t description: {}", codec.description());
13            println!("\t medium: {:?}", codec.medium());
14            println!("\t capabilities: {:?}", codec.capabilities());
15
16            if let Some(profiles) = codec.profiles() {
17                println!("\t profiles: {:?}", profiles.collect::<Vec<_>>());
18            } else {
19                println!("\t profiles: none");
20            }
21
22            if let Ok(video) = codec.video() {
23                if let Some(rates) = video.rates() {
24                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
25                } else {
26                    println!("\t rates: any");
27                }
28
29                if let Some(formats) = video.formats() {
30                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
31                } else {
32                    println!("\t formats: any");
33                }
34            }
35
36            if let Ok(audio) = codec.audio() {
37                if let Some(rates) = audio.rates() {
38                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
39                } else {
40                    println!("\t rates: any");
41                }
42
43                if let Some(formats) = audio.formats() {
44                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
45                } else {
46                    println!("\t formats: any");
47                }
48
49                if let Some(layouts) = audio.channel_layouts() {
50                    println!("\t channel_layouts: {:?}", layouts.collect::<Vec<_>>());
51                } else {
52                    println!("\t channel_layouts: any");
53                }
54            }
55
56            println!("\t max_lowres: {:?}", codec.max_lowres());
57        }
58
59        if let Some(codec) = ffmpeg_rs::encoder::find_by_name(&arg) {
60            println!();
61            println!("type: encoder");
62            println!("\t id: {:?}", codec.id());
63            println!("\t name: {}", codec.name());
64            println!("\t description: {}", codec.description());
65            println!("\t medium: {:?}", codec.medium());
66            println!("\t capabilities: {:?}", codec.capabilities());
67
68            if let Some(profiles) = codec.profiles() {
69                println!("\t profiles: {:?}", profiles.collect::<Vec<_>>());
70            }
71
72            if let Ok(video) = codec.video() {
73                if let Some(rates) = video.rates() {
74                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
75                } else {
76                    println!("\t rates: any");
77                }
78
79                if let Some(formats) = video.formats() {
80                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
81                } else {
82                    println!("\t formats: any");
83                }
84            }
85
86            if let Ok(audio) = codec.audio() {
87                if let Some(rates) = audio.rates() {
88                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
89                } else {
90                    println!("\t rates: any");
91                }
92
93                if let Some(formats) = audio.formats() {
94                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
95                } else {
96                    println!("\t formats: any");
97                }
98
99                if let Some(layouts) = audio.channel_layouts() {
100                    println!("\t channel_layouts: {:?}", layouts.collect::<Vec<_>>());
101                } else {
102                    println!("\t channel_layouts: any");
103                }
104            }
105
106            println!("\t max_lowres: {:?}", codec.max_lowres());
107        }
108    }
109}
Source

pub fn is_video(&self) -> bool

Source

pub fn is_audio(&self) -> bool

Source

pub fn max_lowres(&self) -> i32

Examples found in repository?
examples/codec-info.rs (line 56)
4fn main() {
5    ffmpeg_rs::init().unwrap();
6
7    for arg in env::args().skip(1) {
8        if let Some(codec) = ffmpeg_rs::decoder::find_by_name(&arg) {
9            println!("type: decoder");
10            println!("\t id: {:?}", codec.id());
11            println!("\t name: {}", codec.name());
12            println!("\t description: {}", codec.description());
13            println!("\t medium: {:?}", codec.medium());
14            println!("\t capabilities: {:?}", codec.capabilities());
15
16            if let Some(profiles) = codec.profiles() {
17                println!("\t profiles: {:?}", profiles.collect::<Vec<_>>());
18            } else {
19                println!("\t profiles: none");
20            }
21
22            if let Ok(video) = codec.video() {
23                if let Some(rates) = video.rates() {
24                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
25                } else {
26                    println!("\t rates: any");
27                }
28
29                if let Some(formats) = video.formats() {
30                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
31                } else {
32                    println!("\t formats: any");
33                }
34            }
35
36            if let Ok(audio) = codec.audio() {
37                if let Some(rates) = audio.rates() {
38                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
39                } else {
40                    println!("\t rates: any");
41                }
42
43                if let Some(formats) = audio.formats() {
44                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
45                } else {
46                    println!("\t formats: any");
47                }
48
49                if let Some(layouts) = audio.channel_layouts() {
50                    println!("\t channel_layouts: {:?}", layouts.collect::<Vec<_>>());
51                } else {
52                    println!("\t channel_layouts: any");
53                }
54            }
55
56            println!("\t max_lowres: {:?}", codec.max_lowres());
57        }
58
59        if let Some(codec) = ffmpeg_rs::encoder::find_by_name(&arg) {
60            println!();
61            println!("type: encoder");
62            println!("\t id: {:?}", codec.id());
63            println!("\t name: {}", codec.name());
64            println!("\t description: {}", codec.description());
65            println!("\t medium: {:?}", codec.medium());
66            println!("\t capabilities: {:?}", codec.capabilities());
67
68            if let Some(profiles) = codec.profiles() {
69                println!("\t profiles: {:?}", profiles.collect::<Vec<_>>());
70            }
71
72            if let Ok(video) = codec.video() {
73                if let Some(rates) = video.rates() {
74                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
75                } else {
76                    println!("\t rates: any");
77                }
78
79                if let Some(formats) = video.formats() {
80                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
81                } else {
82                    println!("\t formats: any");
83                }
84            }
85
86            if let Ok(audio) = codec.audio() {
87                if let Some(rates) = audio.rates() {
88                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
89                } else {
90                    println!("\t rates: any");
91                }
92
93                if let Some(formats) = audio.formats() {
94                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
95                } else {
96                    println!("\t formats: any");
97                }
98
99                if let Some(layouts) = audio.channel_layouts() {
100                    println!("\t channel_layouts: {:?}", layouts.collect::<Vec<_>>());
101                } else {
102                    println!("\t channel_layouts: any");
103                }
104            }
105
106            println!("\t max_lowres: {:?}", codec.max_lowres());
107        }
108    }
109}
Source

pub fn capabilities(&self) -> Capabilities

Examples found in repository?
examples/transcode-audio.rs (line 41)
8fn filter(
9    spec: &str,
10    decoder: &codec::decoder::Audio,
11    encoder: &codec::encoder::Audio,
12) -> Result<filter::Graph, ffmpeg_rs::Error> {
13    let mut filter = filter::Graph::new();
14
15    let args = format!(
16        "time_base={}:sample_rate={}:sample_fmt={}:channel_layout=0x{:x}",
17        decoder.time_base(),
18        decoder.rate(),
19        decoder.format().name(),
20        decoder.channel_layout().bits()
21    );
22
23    filter.add(&filter::find("abuffer").unwrap(), "in", &args)?;
24    filter.add(&filter::find("abuffersink").unwrap(), "out", "")?;
25
26    {
27        let mut out = filter.get("out").unwrap();
28
29        out.set_sample_format(encoder.format());
30        out.set_channel_layout(encoder.channel_layout());
31        out.set_sample_rate(encoder.rate());
32    }
33
34    filter.output("in", 0)?.input("out", 0)?.parse(spec)?;
35    filter.validate()?;
36
37    println!("{}", filter.dump());
38
39    if let Some(codec) = encoder.codec() {
40        if !codec
41            .capabilities()
42            .contains(ffmpeg_rs::codec::capabilities::Capabilities::VARIABLE_FRAME_SIZE)
43        {
44            filter
45                .get("out")
46                .unwrap()
47                .sink()
48                .set_frame_size(encoder.frame_size());
49        }
50    }
51
52    Ok(filter)
53}
More examples
Hide additional examples
examples/codec-info.rs (line 14)
4fn main() {
5    ffmpeg_rs::init().unwrap();
6
7    for arg in env::args().skip(1) {
8        if let Some(codec) = ffmpeg_rs::decoder::find_by_name(&arg) {
9            println!("type: decoder");
10            println!("\t id: {:?}", codec.id());
11            println!("\t name: {}", codec.name());
12            println!("\t description: {}", codec.description());
13            println!("\t medium: {:?}", codec.medium());
14            println!("\t capabilities: {:?}", codec.capabilities());
15
16            if let Some(profiles) = codec.profiles() {
17                println!("\t profiles: {:?}", profiles.collect::<Vec<_>>());
18            } else {
19                println!("\t profiles: none");
20            }
21
22            if let Ok(video) = codec.video() {
23                if let Some(rates) = video.rates() {
24                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
25                } else {
26                    println!("\t rates: any");
27                }
28
29                if let Some(formats) = video.formats() {
30                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
31                } else {
32                    println!("\t formats: any");
33                }
34            }
35
36            if let Ok(audio) = codec.audio() {
37                if let Some(rates) = audio.rates() {
38                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
39                } else {
40                    println!("\t rates: any");
41                }
42
43                if let Some(formats) = audio.formats() {
44                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
45                } else {
46                    println!("\t formats: any");
47                }
48
49                if let Some(layouts) = audio.channel_layouts() {
50                    println!("\t channel_layouts: {:?}", layouts.collect::<Vec<_>>());
51                } else {
52                    println!("\t channel_layouts: any");
53                }
54            }
55
56            println!("\t max_lowres: {:?}", codec.max_lowres());
57        }
58
59        if let Some(codec) = ffmpeg_rs::encoder::find_by_name(&arg) {
60            println!();
61            println!("type: encoder");
62            println!("\t id: {:?}", codec.id());
63            println!("\t name: {}", codec.name());
64            println!("\t description: {}", codec.description());
65            println!("\t medium: {:?}", codec.medium());
66            println!("\t capabilities: {:?}", codec.capabilities());
67
68            if let Some(profiles) = codec.profiles() {
69                println!("\t profiles: {:?}", profiles.collect::<Vec<_>>());
70            }
71
72            if let Ok(video) = codec.video() {
73                if let Some(rates) = video.rates() {
74                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
75                } else {
76                    println!("\t rates: any");
77                }
78
79                if let Some(formats) = video.formats() {
80                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
81                } else {
82                    println!("\t formats: any");
83                }
84            }
85
86            if let Ok(audio) = codec.audio() {
87                if let Some(rates) = audio.rates() {
88                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
89                } else {
90                    println!("\t rates: any");
91                }
92
93                if let Some(formats) = audio.formats() {
94                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
95                } else {
96                    println!("\t formats: any");
97                }
98
99                if let Some(layouts) = audio.channel_layouts() {
100                    println!("\t channel_layouts: {:?}", layouts.collect::<Vec<_>>());
101                } else {
102                    println!("\t channel_layouts: any");
103                }
104            }
105
106            println!("\t max_lowres: {:?}", codec.max_lowres());
107        }
108    }
109}
Source

pub fn profiles(&self) -> Option<ProfileIter>

Examples found in repository?
examples/codec-info.rs (line 16)
4fn main() {
5    ffmpeg_rs::init().unwrap();
6
7    for arg in env::args().skip(1) {
8        if let Some(codec) = ffmpeg_rs::decoder::find_by_name(&arg) {
9            println!("type: decoder");
10            println!("\t id: {:?}", codec.id());
11            println!("\t name: {}", codec.name());
12            println!("\t description: {}", codec.description());
13            println!("\t medium: {:?}", codec.medium());
14            println!("\t capabilities: {:?}", codec.capabilities());
15
16            if let Some(profiles) = codec.profiles() {
17                println!("\t profiles: {:?}", profiles.collect::<Vec<_>>());
18            } else {
19                println!("\t profiles: none");
20            }
21
22            if let Ok(video) = codec.video() {
23                if let Some(rates) = video.rates() {
24                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
25                } else {
26                    println!("\t rates: any");
27                }
28
29                if let Some(formats) = video.formats() {
30                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
31                } else {
32                    println!("\t formats: any");
33                }
34            }
35
36            if let Ok(audio) = codec.audio() {
37                if let Some(rates) = audio.rates() {
38                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
39                } else {
40                    println!("\t rates: any");
41                }
42
43                if let Some(formats) = audio.formats() {
44                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
45                } else {
46                    println!("\t formats: any");
47                }
48
49                if let Some(layouts) = audio.channel_layouts() {
50                    println!("\t channel_layouts: {:?}", layouts.collect::<Vec<_>>());
51                } else {
52                    println!("\t channel_layouts: any");
53                }
54            }
55
56            println!("\t max_lowres: {:?}", codec.max_lowres());
57        }
58
59        if let Some(codec) = ffmpeg_rs::encoder::find_by_name(&arg) {
60            println!();
61            println!("type: encoder");
62            println!("\t id: {:?}", codec.id());
63            println!("\t name: {}", codec.name());
64            println!("\t description: {}", codec.description());
65            println!("\t medium: {:?}", codec.medium());
66            println!("\t capabilities: {:?}", codec.capabilities());
67
68            if let Some(profiles) = codec.profiles() {
69                println!("\t profiles: {:?}", profiles.collect::<Vec<_>>());
70            }
71
72            if let Ok(video) = codec.video() {
73                if let Some(rates) = video.rates() {
74                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
75                } else {
76                    println!("\t rates: any");
77                }
78
79                if let Some(formats) = video.formats() {
80                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
81                } else {
82                    println!("\t formats: any");
83                }
84            }
85
86            if let Ok(audio) = codec.audio() {
87                if let Some(rates) = audio.rates() {
88                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
89                } else {
90                    println!("\t rates: any");
91                }
92
93                if let Some(formats) = audio.formats() {
94                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
95                } else {
96                    println!("\t formats: any");
97                }
98
99                if let Some(layouts) = audio.channel_layouts() {
100                    println!("\t channel_layouts: {:?}", layouts.collect::<Vec<_>>());
101                } else {
102                    println!("\t channel_layouts: any");
103                }
104            }
105
106            println!("\t max_lowres: {:?}", codec.max_lowres());
107        }
108    }
109}

Trait Implementations§

Source§

impl Clone for Audio

Source§

fn clone(&self) -> Audio

Returns a copy of the value. Read more
1.0.0 · Source§

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

Performs copy-assignment from source. Read more
Source§

impl Decoder for Audio

Source§

fn decoder(self) -> Option<Codec>

Source§

impl Deref for Audio

Source§

type Target = Codec

The resulting type after dereferencing.
Source§

fn deref(&self) -> &Self::Target

Dereferences the value.
Source§

impl Encoder for Audio

Source§

fn encoder(self) -> Option<Codec>

Source§

impl PartialEq for Audio

Source§

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

Tests for self and other values to be equal, and is used by ==.
1.0.0 · Source§

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

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

impl Copy for Audio

Source§

impl Eq for Audio

Source§

impl StructuralPartialEq for Audio

Auto Trait Implementations§

§

impl Freeze for Audio

§

impl RefUnwindSafe for Audio

§

impl Send for Audio

§

impl Sync for Audio

§

impl Unpin for Audio

§

impl UnwindSafe for Audio

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> CloneToUninit for T
where T: Clone,

Source§

unsafe fn clone_to_uninit(&self, dst: *mut u8)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dst. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<P, T> Receiver for P
where P: Deref<Target = T> + ?Sized, T: ?Sized,

Source§

type Target = T

🔬This is a nightly-only experimental API. (arbitrary_self_types)
The target type on which the method may be called.
Source§

impl<T> ToOwned for T
where T: Clone,

Source§

type Owned = T

The resulting type after obtaining ownership.
Source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
Source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.