Struct ffmpeg_the_third::codec::codec::Codec

source · 
pub struct Codec { /* private fields */ }

Implementations§

source§

impl Codec

source

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

source

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

source

pub unsafe fn as_mut_ptr(&mut self) -> *mut 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)
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

fn main() {
    ffmpeg::init().unwrap();

    for arg in env::args().skip(1) {
        if let Some(codec) = ffmpeg::decoder::find_by_name(&arg) {
            println!("type: decoder");
            println!("\t id: {:?}", codec.id());
            println!("\t name: {}", codec.name());
            println!("\t description: {}", codec.description());
            println!("\t medium: {:?}", codec.medium());
            println!("\t capabilities: {:?}", codec.capabilities());

            if let Some(profiles) = codec.profiles() {
                println!("\t profiles: {:?}", profiles.collect::<Vec<_>>());
            } else {
                println!("\t profiles: none");
            }

            if let Ok(video) = codec.video() {
                if let Some(rates) = video.rates() {
                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
                } else {
                    println!("\t rates: any");
                }

                if let Some(formats) = video.formats() {
                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
                } else {
                    println!("\t formats: any");
                }
            }

            if let Ok(audio) = codec.audio() {
                if let Some(rates) = audio.rates() {
                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
                } else {
                    println!("\t rates: any");
                }

                if let Some(formats) = audio.formats() {
                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
                } else {
                    println!("\t formats: any");
                }

                if let Some(layouts) = audio.channel_layouts() {
                    println!("\t channel_layouts: {:?}", layouts.collect::<Vec<_>>());
                } else {
                    println!("\t channel_layouts: any");
                }
            }

            println!("\t max_lowres: {:?}", codec.max_lowres());
        }

        if let Some(codec) = ffmpeg::encoder::find_by_name(&arg) {
            println!();
            println!("type: encoder");
            println!("\t id: {:?}", codec.id());
            println!("\t name: {}", codec.name());
            println!("\t description: {}", codec.description());
            println!("\t medium: {:?}", codec.medium());
            println!("\t capabilities: {:?}", codec.capabilities());

            if let Some(profiles) = codec.profiles() {
                println!("\t profiles: {:?}", profiles.collect::<Vec<_>>());
            }

            if let Ok(video) = codec.video() {
                if let Some(rates) = video.rates() {
                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
                } else {
                    println!("\t rates: any");
                }

                if let Some(formats) = video.formats() {
                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
                } else {
                    println!("\t formats: any");
                }
            }

            if let Ok(audio) = codec.audio() {
                if let Some(rates) = audio.rates() {
                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
                } else {
                    println!("\t rates: any");
                }

                if let Some(formats) = audio.formats() {
                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
                } else {
                    println!("\t formats: any");
                }

                if let Some(layouts) = audio.channel_layouts() {
                    println!("\t channel_layouts: {:?}", layouts.collect::<Vec<_>>());
                } else {
                    println!("\t channel_layouts: any");
                }
            }

            println!("\t max_lowres: {:?}", codec.max_lowres());
        }
    }
}
source

pub fn description(&self) -> &str

Examples found in repository?
examples/codec-info.rs (line 13)
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

fn main() {
    ffmpeg::init().unwrap();

    for arg in env::args().skip(1) {
        if let Some(codec) = ffmpeg::decoder::find_by_name(&arg) {
            println!("type: decoder");
            println!("\t id: {:?}", codec.id());
            println!("\t name: {}", codec.name());
            println!("\t description: {}", codec.description());
            println!("\t medium: {:?}", codec.medium());
            println!("\t capabilities: {:?}", codec.capabilities());

            if let Some(profiles) = codec.profiles() {
                println!("\t profiles: {:?}", profiles.collect::<Vec<_>>());
            } else {
                println!("\t profiles: none");
            }

            if let Ok(video) = codec.video() {
                if let Some(rates) = video.rates() {
                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
                } else {
                    println!("\t rates: any");
                }

                if let Some(formats) = video.formats() {
                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
                } else {
                    println!("\t formats: any");
                }
            }

            if let Ok(audio) = codec.audio() {
                if let Some(rates) = audio.rates() {
                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
                } else {
                    println!("\t rates: any");
                }

                if let Some(formats) = audio.formats() {
                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
                } else {
                    println!("\t formats: any");
                }

                if let Some(layouts) = audio.channel_layouts() {
                    println!("\t channel_layouts: {:?}", layouts.collect::<Vec<_>>());
                } else {
                    println!("\t channel_layouts: any");
                }
            }

            println!("\t max_lowres: {:?}", codec.max_lowres());
        }

        if let Some(codec) = ffmpeg::encoder::find_by_name(&arg) {
            println!();
            println!("type: encoder");
            println!("\t id: {:?}", codec.id());
            println!("\t name: {}", codec.name());
            println!("\t description: {}", codec.description());
            println!("\t medium: {:?}", codec.medium());
            println!("\t capabilities: {:?}", codec.capabilities());

            if let Some(profiles) = codec.profiles() {
                println!("\t profiles: {:?}", profiles.collect::<Vec<_>>());
            }

            if let Ok(video) = codec.video() {
                if let Some(rates) = video.rates() {
                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
                } else {
                    println!("\t rates: any");
                }

                if let Some(formats) = video.formats() {
                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
                } else {
                    println!("\t formats: any");
                }
            }

            if let Ok(audio) = codec.audio() {
                if let Some(rates) = audio.rates() {
                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
                } else {
                    println!("\t rates: any");
                }

                if let Some(formats) = audio.formats() {
                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
                } else {
                    println!("\t formats: any");
                }

                if let Some(layouts) = audio.channel_layouts() {
                    println!("\t channel_layouts: {:?}", layouts.collect::<Vec<_>>());
                } else {
                    println!("\t channel_layouts: any");
                }
            }

            println!("\t max_lowres: {:?}", codec.max_lowres());
        }
    }
}
source

pub fn medium(&self) -> Type

Examples found in repository?
examples/codec-info.rs (line 14)
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

fn main() {
    ffmpeg::init().unwrap();

    for arg in env::args().skip(1) {
        if let Some(codec) = ffmpeg::decoder::find_by_name(&arg) {
            println!("type: decoder");
            println!("\t id: {:?}", codec.id());
            println!("\t name: {}", codec.name());
            println!("\t description: {}", codec.description());
            println!("\t medium: {:?}", codec.medium());
            println!("\t capabilities: {:?}", codec.capabilities());

            if let Some(profiles) = codec.profiles() {
                println!("\t profiles: {:?}", profiles.collect::<Vec<_>>());
            } else {
                println!("\t profiles: none");
            }

            if let Ok(video) = codec.video() {
                if let Some(rates) = video.rates() {
                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
                } else {
                    println!("\t rates: any");
                }

                if let Some(formats) = video.formats() {
                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
                } else {
                    println!("\t formats: any");
                }
            }

            if let Ok(audio) = codec.audio() {
                if let Some(rates) = audio.rates() {
                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
                } else {
                    println!("\t rates: any");
                }

                if let Some(formats) = audio.formats() {
                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
                } else {
                    println!("\t formats: any");
                }

                if let Some(layouts) = audio.channel_layouts() {
                    println!("\t channel_layouts: {:?}", layouts.collect::<Vec<_>>());
                } else {
                    println!("\t channel_layouts: any");
                }
            }

            println!("\t max_lowres: {:?}", codec.max_lowres());
        }

        if let Some(codec) = ffmpeg::encoder::find_by_name(&arg) {
            println!();
            println!("type: encoder");
            println!("\t id: {:?}", codec.id());
            println!("\t name: {}", codec.name());
            println!("\t description: {}", codec.description());
            println!("\t medium: {:?}", codec.medium());
            println!("\t capabilities: {:?}", codec.capabilities());

            if let Some(profiles) = codec.profiles() {
                println!("\t profiles: {:?}", profiles.collect::<Vec<_>>());
            }

            if let Ok(video) = codec.video() {
                if let Some(rates) = video.rates() {
                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
                } else {
                    println!("\t rates: any");
                }

                if let Some(formats) = video.formats() {
                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
                } else {
                    println!("\t formats: any");
                }
            }

            if let Ok(audio) = codec.audio() {
                if let Some(rates) = audio.rates() {
                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
                } else {
                    println!("\t rates: any");
                }

                if let Some(formats) = audio.formats() {
                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
                } else {
                    println!("\t formats: any");
                }

                if let Some(layouts) = audio.channel_layouts() {
                    println!("\t channel_layouts: {:?}", layouts.collect::<Vec<_>>());
                } else {
                    println!("\t channel_layouts: any");
                }
            }

            println!("\t max_lowres: {:?}", codec.max_lowres());
        }
    }
}
source

pub fn id(&self) -> Id

Examples found in repository?
examples/codec-info.rs (line 11)
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

fn main() {
    ffmpeg::init().unwrap();

    for arg in env::args().skip(1) {
        if let Some(codec) = ffmpeg::decoder::find_by_name(&arg) {
            println!("type: decoder");
            println!("\t id: {:?}", codec.id());
            println!("\t name: {}", codec.name());
            println!("\t description: {}", codec.description());
            println!("\t medium: {:?}", codec.medium());
            println!("\t capabilities: {:?}", codec.capabilities());

            if let Some(profiles) = codec.profiles() {
                println!("\t profiles: {:?}", profiles.collect::<Vec<_>>());
            } else {
                println!("\t profiles: none");
            }

            if let Ok(video) = codec.video() {
                if let Some(rates) = video.rates() {
                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
                } else {
                    println!("\t rates: any");
                }

                if let Some(formats) = video.formats() {
                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
                } else {
                    println!("\t formats: any");
                }
            }

            if let Ok(audio) = codec.audio() {
                if let Some(rates) = audio.rates() {
                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
                } else {
                    println!("\t rates: any");
                }

                if let Some(formats) = audio.formats() {
                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
                } else {
                    println!("\t formats: any");
                }

                if let Some(layouts) = audio.channel_layouts() {
                    println!("\t channel_layouts: {:?}", layouts.collect::<Vec<_>>());
                } else {
                    println!("\t channel_layouts: any");
                }
            }

            println!("\t max_lowres: {:?}", codec.max_lowres());
        }

        if let Some(codec) = ffmpeg::encoder::find_by_name(&arg) {
            println!();
            println!("type: encoder");
            println!("\t id: {:?}", codec.id());
            println!("\t name: {}", codec.name());
            println!("\t description: {}", codec.description());
            println!("\t medium: {:?}", codec.medium());
            println!("\t capabilities: {:?}", codec.capabilities());

            if let Some(profiles) = codec.profiles() {
                println!("\t profiles: {:?}", profiles.collect::<Vec<_>>());
            }

            if let Ok(video) = codec.video() {
                if let Some(rates) = video.rates() {
                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
                } else {
                    println!("\t rates: any");
                }

                if let Some(formats) = video.formats() {
                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
                } else {
                    println!("\t formats: any");
                }
            }

            if let Ok(audio) = codec.audio() {
                if let Some(rates) = audio.rates() {
                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
                } else {
                    println!("\t rates: any");
                }

                if let Some(formats) = audio.formats() {
                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
                } else {
                    println!("\t formats: any");
                }

                if let Some(layouts) = audio.channel_layouts() {
                    println!("\t channel_layouts: {:?}", layouts.collect::<Vec<_>>());
                } else {
                    println!("\t channel_layouts: any");
                }
            }

            println!("\t max_lowres: {:?}", codec.max_lowres());
        }
    }
}
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)
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

fn main() {
    ffmpeg::init().unwrap();

    for arg in env::args().skip(1) {
        if let Some(codec) = ffmpeg::decoder::find_by_name(&arg) {
            println!("type: decoder");
            println!("\t id: {:?}", codec.id());
            println!("\t name: {}", codec.name());
            println!("\t description: {}", codec.description());
            println!("\t medium: {:?}", codec.medium());
            println!("\t capabilities: {:?}", codec.capabilities());

            if let Some(profiles) = codec.profiles() {
                println!("\t profiles: {:?}", profiles.collect::<Vec<_>>());
            } else {
                println!("\t profiles: none");
            }

            if let Ok(video) = codec.video() {
                if let Some(rates) = video.rates() {
                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
                } else {
                    println!("\t rates: any");
                }

                if let Some(formats) = video.formats() {
                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
                } else {
                    println!("\t formats: any");
                }
            }

            if let Ok(audio) = codec.audio() {
                if let Some(rates) = audio.rates() {
                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
                } else {
                    println!("\t rates: any");
                }

                if let Some(formats) = audio.formats() {
                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
                } else {
                    println!("\t formats: any");
                }

                if let Some(layouts) = audio.channel_layouts() {
                    println!("\t channel_layouts: {:?}", layouts.collect::<Vec<_>>());
                } else {
                    println!("\t channel_layouts: any");
                }
            }

            println!("\t max_lowres: {:?}", codec.max_lowres());
        }

        if let Some(codec) = ffmpeg::encoder::find_by_name(&arg) {
            println!();
            println!("type: encoder");
            println!("\t id: {:?}", codec.id());
            println!("\t name: {}", codec.name());
            println!("\t description: {}", codec.description());
            println!("\t medium: {:?}", codec.medium());
            println!("\t capabilities: {:?}", codec.capabilities());

            if let Some(profiles) = codec.profiles() {
                println!("\t profiles: {:?}", profiles.collect::<Vec<_>>());
            }

            if let Ok(video) = codec.video() {
                if let Some(rates) = video.rates() {
                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
                } else {
                    println!("\t rates: any");
                }

                if let Some(formats) = video.formats() {
                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
                } else {
                    println!("\t formats: any");
                }
            }

            if let Ok(audio) = codec.audio() {
                if let Some(rates) = audio.rates() {
                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
                } else {
                    println!("\t rates: any");
                }

                if let Some(formats) = audio.formats() {
                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
                } else {
                    println!("\t formats: any");
                }

                if let Some(layouts) = audio.channel_layouts() {
                    println!("\t channel_layouts: {:?}", layouts.collect::<Vec<_>>());
                } else {
                    println!("\t channel_layouts: any");
                }
            }

            println!("\t max_lowres: {:?}", codec.max_lowres());
        }
    }
}
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)
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

fn transcoder<P: AsRef<Path>>(
    ictx: &mut format::context::Input,
    octx: &mut format::context::Output,
    path: &P,
    filter_spec: &str,
) -> Result<Transcoder, ffmpeg::Error> {
    let input = ictx
        .streams()
        .best(media::Type::Audio)
        .expect("could not find best audio stream");
    let context = ffmpeg::codec::context::Context::from_parameters(input.parameters())?;
    let mut decoder = context.decoder().audio()?;
    let codec = ffmpeg::encoder::find(octx.format().codec(path, media::Type::Audio))
        .expect("failed to find encoder")
        .audio()?;
    let global = octx
        .format()
        .flags()
        .contains(ffmpeg::format::flag::Flags::GLOBAL_HEADER);

    decoder.set_parameters(input.parameters())?;

    let mut output = octx.add_stream(codec)?;
    let context = ffmpeg::codec::context::Context::from_parameters(output.parameters())?;
    let mut encoder = context.encoder().audio()?;

    let channel_layout = codec
        .channel_layouts()
        .map(|cls| cls.best(decoder.channel_layout().channels()))
        .unwrap_or(ffmpeg::channel_layout::ChannelLayout::STEREO);

    if global {
        encoder.set_flags(ffmpeg::codec::flag::Flags::GLOBAL_HEADER);
    }

    encoder.set_rate(decoder.rate() as i32);
    encoder.set_channel_layout(channel_layout);
    encoder.set_channels(channel_layout.channels());
    encoder.set_format(
        codec
            .formats()
            .expect("unknown supported formats")
            .next()
            .unwrap(),
    );
    encoder.set_bit_rate(decoder.bit_rate());
    encoder.set_max_bit_rate(decoder.max_bit_rate());

    encoder.set_time_base((1, decoder.rate() as i32));
    output.set_time_base((1, decoder.rate() as i32));

    let encoder = encoder.open_as(codec)?;
    output.set_parameters(&encoder);

    let filter = filter(filter_spec, &decoder, &encoder)?;

    let in_time_base = decoder.time_base();
    let out_time_base = output.time_base();

    Ok(Transcoder {
        stream: input.index(),
        filter,
        decoder,
        encoder,
        in_time_base,
        out_time_base,
    })
}
More examples
Hide additional examples
examples/codec-info.rs (line 37)
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

fn main() {
    ffmpeg::init().unwrap();

    for arg in env::args().skip(1) {
        if let Some(codec) = ffmpeg::decoder::find_by_name(&arg) {
            println!("type: decoder");
            println!("\t id: {:?}", codec.id());
            println!("\t name: {}", codec.name());
            println!("\t description: {}", codec.description());
            println!("\t medium: {:?}", codec.medium());
            println!("\t capabilities: {:?}", codec.capabilities());

            if let Some(profiles) = codec.profiles() {
                println!("\t profiles: {:?}", profiles.collect::<Vec<_>>());
            } else {
                println!("\t profiles: none");
            }

            if let Ok(video) = codec.video() {
                if let Some(rates) = video.rates() {
                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
                } else {
                    println!("\t rates: any");
                }

                if let Some(formats) = video.formats() {
                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
                } else {
                    println!("\t formats: any");
                }
            }

            if let Ok(audio) = codec.audio() {
                if let Some(rates) = audio.rates() {
                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
                } else {
                    println!("\t rates: any");
                }

                if let Some(formats) = audio.formats() {
                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
                } else {
                    println!("\t formats: any");
                }

                if let Some(layouts) = audio.channel_layouts() {
                    println!("\t channel_layouts: {:?}", layouts.collect::<Vec<_>>());
                } else {
                    println!("\t channel_layouts: any");
                }
            }

            println!("\t max_lowres: {:?}", codec.max_lowres());
        }

        if let Some(codec) = ffmpeg::encoder::find_by_name(&arg) {
            println!();
            println!("type: encoder");
            println!("\t id: {:?}", codec.id());
            println!("\t name: {}", codec.name());
            println!("\t description: {}", codec.description());
            println!("\t medium: {:?}", codec.medium());
            println!("\t capabilities: {:?}", codec.capabilities());

            if let Some(profiles) = codec.profiles() {
                println!("\t profiles: {:?}", profiles.collect::<Vec<_>>());
            }

            if let Ok(video) = codec.video() {
                if let Some(rates) = video.rates() {
                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
                } else {
                    println!("\t rates: any");
                }

                if let Some(formats) = video.formats() {
                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
                } else {
                    println!("\t formats: any");
                }
            }

            if let Ok(audio) = codec.audio() {
                if let Some(rates) = audio.rates() {
                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
                } else {
                    println!("\t rates: any");
                }

                if let Some(formats) = audio.formats() {
                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
                } else {
                    println!("\t formats: any");
                }

                if let Some(layouts) = audio.channel_layouts() {
                    println!("\t channel_layouts: {:?}", layouts.collect::<Vec<_>>());
                } else {
                    println!("\t channel_layouts: any");
                }
            }

            println!("\t max_lowres: {:?}", codec.max_lowres());
        }
    }
}
source

pub fn max_lowres(&self) -> i32

Examples found in repository?
examples/codec-info.rs (line 57)
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

fn main() {
    ffmpeg::init().unwrap();

    for arg in env::args().skip(1) {
        if let Some(codec) = ffmpeg::decoder::find_by_name(&arg) {
            println!("type: decoder");
            println!("\t id: {:?}", codec.id());
            println!("\t name: {}", codec.name());
            println!("\t description: {}", codec.description());
            println!("\t medium: {:?}", codec.medium());
            println!("\t capabilities: {:?}", codec.capabilities());

            if let Some(profiles) = codec.profiles() {
                println!("\t profiles: {:?}", profiles.collect::<Vec<_>>());
            } else {
                println!("\t profiles: none");
            }

            if let Ok(video) = codec.video() {
                if let Some(rates) = video.rates() {
                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
                } else {
                    println!("\t rates: any");
                }

                if let Some(formats) = video.formats() {
                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
                } else {
                    println!("\t formats: any");
                }
            }

            if let Ok(audio) = codec.audio() {
                if let Some(rates) = audio.rates() {
                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
                } else {
                    println!("\t rates: any");
                }

                if let Some(formats) = audio.formats() {
                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
                } else {
                    println!("\t formats: any");
                }

                if let Some(layouts) = audio.channel_layouts() {
                    println!("\t channel_layouts: {:?}", layouts.collect::<Vec<_>>());
                } else {
                    println!("\t channel_layouts: any");
                }
            }

            println!("\t max_lowres: {:?}", codec.max_lowres());
        }

        if let Some(codec) = ffmpeg::encoder::find_by_name(&arg) {
            println!();
            println!("type: encoder");
            println!("\t id: {:?}", codec.id());
            println!("\t name: {}", codec.name());
            println!("\t description: {}", codec.description());
            println!("\t medium: {:?}", codec.medium());
            println!("\t capabilities: {:?}", codec.capabilities());

            if let Some(profiles) = codec.profiles() {
                println!("\t profiles: {:?}", profiles.collect::<Vec<_>>());
            }

            if let Ok(video) = codec.video() {
                if let Some(rates) = video.rates() {
                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
                } else {
                    println!("\t rates: any");
                }

                if let Some(formats) = video.formats() {
                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
                } else {
                    println!("\t formats: any");
                }
            }

            if let Ok(audio) = codec.audio() {
                if let Some(rates) = audio.rates() {
                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
                } else {
                    println!("\t rates: any");
                }

                if let Some(formats) = audio.formats() {
                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
                } else {
                    println!("\t formats: any");
                }

                if let Some(layouts) = audio.channel_layouts() {
                    println!("\t channel_layouts: {:?}", layouts.collect::<Vec<_>>());
                } else {
                    println!("\t channel_layouts: any");
                }
            }

            println!("\t max_lowres: {:?}", codec.max_lowres());
        }
    }
}
source

pub fn capabilities(&self) -> Capabilities

Examples found in repository?
examples/transcode-audio.rs (line 42)
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

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

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

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

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

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

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

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

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

    Ok(filter)
}
More examples
Hide additional examples
examples/codec-info.rs (line 15)
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

fn main() {
    ffmpeg::init().unwrap();

    for arg in env::args().skip(1) {
        if let Some(codec) = ffmpeg::decoder::find_by_name(&arg) {
            println!("type: decoder");
            println!("\t id: {:?}", codec.id());
            println!("\t name: {}", codec.name());
            println!("\t description: {}", codec.description());
            println!("\t medium: {:?}", codec.medium());
            println!("\t capabilities: {:?}", codec.capabilities());

            if let Some(profiles) = codec.profiles() {
                println!("\t profiles: {:?}", profiles.collect::<Vec<_>>());
            } else {
                println!("\t profiles: none");
            }

            if let Ok(video) = codec.video() {
                if let Some(rates) = video.rates() {
                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
                } else {
                    println!("\t rates: any");
                }

                if let Some(formats) = video.formats() {
                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
                } else {
                    println!("\t formats: any");
                }
            }

            if let Ok(audio) = codec.audio() {
                if let Some(rates) = audio.rates() {
                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
                } else {
                    println!("\t rates: any");
                }

                if let Some(formats) = audio.formats() {
                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
                } else {
                    println!("\t formats: any");
                }

                if let Some(layouts) = audio.channel_layouts() {
                    println!("\t channel_layouts: {:?}", layouts.collect::<Vec<_>>());
                } else {
                    println!("\t channel_layouts: any");
                }
            }

            println!("\t max_lowres: {:?}", codec.max_lowres());
        }

        if let Some(codec) = ffmpeg::encoder::find_by_name(&arg) {
            println!();
            println!("type: encoder");
            println!("\t id: {:?}", codec.id());
            println!("\t name: {}", codec.name());
            println!("\t description: {}", codec.description());
            println!("\t medium: {:?}", codec.medium());
            println!("\t capabilities: {:?}", codec.capabilities());

            if let Some(profiles) = codec.profiles() {
                println!("\t profiles: {:?}", profiles.collect::<Vec<_>>());
            }

            if let Ok(video) = codec.video() {
                if let Some(rates) = video.rates() {
                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
                } else {
                    println!("\t rates: any");
                }

                if let Some(formats) = video.formats() {
                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
                } else {
                    println!("\t formats: any");
                }
            }

            if let Ok(audio) = codec.audio() {
                if let Some(rates) = audio.rates() {
                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
                } else {
                    println!("\t rates: any");
                }

                if let Some(formats) = audio.formats() {
                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
                } else {
                    println!("\t formats: any");
                }

                if let Some(layouts) = audio.channel_layouts() {
                    println!("\t channel_layouts: {:?}", layouts.collect::<Vec<_>>());
                } else {
                    println!("\t channel_layouts: any");
                }
            }

            println!("\t max_lowres: {:?}", codec.max_lowres());
        }
    }
}
source

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

Examples found in repository?
examples/codec-info.rs (line 17)
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

fn main() {
    ffmpeg::init().unwrap();

    for arg in env::args().skip(1) {
        if let Some(codec) = ffmpeg::decoder::find_by_name(&arg) {
            println!("type: decoder");
            println!("\t id: {:?}", codec.id());
            println!("\t name: {}", codec.name());
            println!("\t description: {}", codec.description());
            println!("\t medium: {:?}", codec.medium());
            println!("\t capabilities: {:?}", codec.capabilities());

            if let Some(profiles) = codec.profiles() {
                println!("\t profiles: {:?}", profiles.collect::<Vec<_>>());
            } else {
                println!("\t profiles: none");
            }

            if let Ok(video) = codec.video() {
                if let Some(rates) = video.rates() {
                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
                } else {
                    println!("\t rates: any");
                }

                if let Some(formats) = video.formats() {
                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
                } else {
                    println!("\t formats: any");
                }
            }

            if let Ok(audio) = codec.audio() {
                if let Some(rates) = audio.rates() {
                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
                } else {
                    println!("\t rates: any");
                }

                if let Some(formats) = audio.formats() {
                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
                } else {
                    println!("\t formats: any");
                }

                if let Some(layouts) = audio.channel_layouts() {
                    println!("\t channel_layouts: {:?}", layouts.collect::<Vec<_>>());
                } else {
                    println!("\t channel_layouts: any");
                }
            }

            println!("\t max_lowres: {:?}", codec.max_lowres());
        }

        if let Some(codec) = ffmpeg::encoder::find_by_name(&arg) {
            println!();
            println!("type: encoder");
            println!("\t id: {:?}", codec.id());
            println!("\t name: {}", codec.name());
            println!("\t description: {}", codec.description());
            println!("\t medium: {:?}", codec.medium());
            println!("\t capabilities: {:?}", codec.capabilities());

            if let Some(profiles) = codec.profiles() {
                println!("\t profiles: {:?}", profiles.collect::<Vec<_>>());
            }

            if let Ok(video) = codec.video() {
                if let Some(rates) = video.rates() {
                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
                } else {
                    println!("\t rates: any");
                }

                if let Some(formats) = video.formats() {
                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
                } else {
                    println!("\t formats: any");
                }
            }

            if let Ok(audio) = codec.audio() {
                if let Some(rates) = audio.rates() {
                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
                } else {
                    println!("\t rates: any");
                }

                if let Some(formats) = audio.formats() {
                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
                } else {
                    println!("\t formats: any");
                }

                if let Some(layouts) = audio.channel_layouts() {
                    println!("\t channel_layouts: {:?}", layouts.collect::<Vec<_>>());
                } else {
                    println!("\t channel_layouts: any");
                }
            }

            println!("\t max_lowres: {:?}", codec.max_lowres());
        }
    }
}

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<Codec> for Codec

source§

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

impl Copy for Codec

source§

impl Eq for Codec

source§

impl Send for Codec

source§

impl StructuralEq for Codec

source§

impl StructuralPartialEq for Codec

source§

impl Sync for Codec

Auto Trait Implementations§

Blanket Implementations§

source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

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

const: unstable · source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

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

const: unstable · source§

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

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

const: unstable · source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

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

const: unstable · 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 Twhere T: Clone,

§

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 Twhere U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
const: unstable · source§

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

Performs the conversion.
source§

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

§

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

The type returned in the event of a conversion error.
const: unstable · source§

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

Performs the conversion.