ffmpeg_next::codec::codec

Struct Codec

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

Implementations§

Source§

impl Codec

Source

pub unsafe fn wrap(ptr: *const AVCodec) -> Self

Source

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

Source§

impl Codec

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

pub fn description(&self) -> &str

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

pub fn medium(&self) -> Type

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

pub fn id(&self) -> Id

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

pub fn is_video(&self) -> bool

Source

pub fn video(self) -> Result<Video, Error>

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

pub fn is_audio(&self) -> bool

Source

pub fn audio(self) -> Result<Audio, Error>

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

pub fn max_lowres(&self) -> i32

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

pub fn capabilities(&self) -> Capabilities

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

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

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

Trait Implementations§

Source§

impl Clone for Codec

Source§

fn clone(&self) -> Codec

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 Codec

Source§

fn decoder(self) -> Option<Codec>

Source§

impl Encoder for Codec

Source§

fn encoder(self) -> Option<Codec>

Source§

impl PartialEq for Codec

Source§

fn eq(&self, other: &Codec) -> 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 Codec

Source§

impl Eq for Codec

Source§

impl Send for Codec

Source§

impl StructuralPartialEq for Codec

Source§

impl Sync for Codec

Auto Trait Implementations§

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, dest: *mut u8)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dest. 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<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.