Struct Encoder

Source

pub struct Encoder(pub Audio);

Tuple Fields§

§0: Audio

Implementations§

Source §

impl Encoder

Source

pub fn encode<P: Mut>( &mut self, frame: &Audio, out: &mut P, ) -> Result<bool, Error>

👎Deprecated since 4.4.0: Underlying API avcodec_encode_audio2 has been deprecated since FFmpeg 3.1; consider switching to send_frame() and receive_packet()

Source

pub fn flush<P: Mut>(&mut self, out: &mut P) -> Result<bool, Error>

👎Deprecated since 4.4.0: Underlying API avcodec_encode_audio2 has been deprecated since FFmpeg 3.1; consider switching to send_eof() and receive_packet()

Source

pub fn frame_size(&self) -> u32

Examples found in repository ?

examples/transcode-audio.rs (line 48)

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

Methods from Deref<Target = Audio>§

Source

pub fn set_rate(&mut self, rate: i32)

Examples found in repository ?

examples/transcode-audio.rs (line 99)

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

Source

pub fn rate(&self) -> u32

Examples found in repository ?

examples/transcode-audio.rs (line 31)

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

Source

pub fn set_format(&mut self, value: Sample)

Examples found in repository ?

examples/transcode-audio.rs (lines 102-108)

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

Source

pub fn format(&self) -> Sample

Examples found in repository ?

examples/transcode-audio.rs (line 29)

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

Source

pub fn set_channel_layout(&mut self, value: ChannelLayout)

Examples found in repository ?

examples/transcode-audio.rs (line 100)

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

Source

pub fn channel_layout(&self) -> ChannelLayout

Examples found in repository ?

examples/transcode-audio.rs (line 30)

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

Source

pub fn set_channels(&mut self, value: i32)

Examples found in repository ?

examples/transcode-audio.rs (line 101)

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

Source

pub fn channels(&self) -> u16

Methods from Deref<Target = Super>§

Source

pub fn send_frame(&mut self, frame: &Frame) -> Result<(), Error>

Examples found in repository ?

examples/transcode-x264.rs (line 114)

113    fn send_frame_to_encoder(&mut self, frame: &frame::Video) {
114        self.encoder.send_frame(frame).unwrap();
115    }

More examples

Hide additional examples

examples/transcode-audio.rs (line 135)

134    fn send_frame_to_encoder(&mut self, frame: &ffmpeg_rs::Frame) {
135        self.encoder.send_frame(frame).unwrap();
136    }

Source

pub fn send_eof(&mut self) -> Result<(), Error>

Sends a NULL packet to the encoder to signal end of stream and enter draining mode.

Examples found in repository ?

examples/transcode-audio.rs (line 139)

138    fn send_eof_to_encoder(&mut self) {
139        self.encoder.send_eof().unwrap();
140    }

More examples

Hide additional examples

examples/transcode-x264.rs (line 118)

117    fn send_eof_to_encoder(&mut self) {
118        self.encoder.send_eof().unwrap();
119    }

Source

pub fn flush_buffers(&mut self)

Source

pub fn receive_packet<P: Mut>(&mut self, packet: &mut P) -> Result<(), Error>

Examples found in repository ?

examples/transcode-audio.rs (line 144)

142    fn receive_and_process_encoded_packets(&mut self, octx: &mut format::context::Output) {
143        let mut encoded = ffmpeg_rs::Packet::empty();
144        while self.encoder.receive_packet(&mut encoded).is_ok() {
145            encoded.set_stream(0);
146            encoded.rescale_ts(self.in_time_base, self.out_time_base);
147            encoded.write_interleaved(octx).unwrap();
148        }
149    }

More examples

Hide additional examples

examples/transcode-x264.rs (line 127)

121    fn receive_and_process_encoded_packets(
122        &mut self,
123        octx: &mut format::context::Output,
124        ost_time_base: Rational,
125    ) {
126        let mut encoded = Packet::empty();
127        while self.encoder.receive_packet(&mut encoded).is_ok() {
128            encoded.set_stream(self.ost_index);
129            encoded.rescale_ts(self.decoder.time_base(), ost_time_base);
130            encoded.write_interleaved(octx).unwrap();
131        }
132    }

Source

pub fn set_bit_rate(&mut self, value: usize)

Examples found in repository ?

examples/transcode-audio.rs (line 109)

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

Source

pub fn set_max_bit_rate(&mut self, value: usize)

Examples found in repository ?

examples/transcode-audio.rs (line 110)

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

Source

pub fn set_time_base<R: Into<Rational>>(&mut self, value: R)

Examples found in repository ?

examples/transcode-x264.rs (line 60)

40    fn new(
41        ist: &format::stream::Stream,
42        octx: &mut format::context::Output,
43        ost_index: usize,
44        x264_opts: Dictionary,
45        enable_logging: bool,
46    ) -> Result<Self, ffmpeg_rs::Error> {
47        let global_header = octx.format().flags().contains(format::Flags::GLOBAL_HEADER);
48        let decoder = ffmpeg_rs::codec::context::Context::from_parameters(ist.parameters())?
49            .decoder()
50            .video()?;
51        let mut ost = octx.add_stream(encoder::find(codec::Id::H264))?;
52        let mut encoder = codec::context::Context::from_parameters(ost.parameters())?
53            .encoder()
54            .video()?;
55        encoder.set_height(decoder.height());
56        encoder.set_width(decoder.width());
57        encoder.set_aspect_ratio(decoder.aspect_ratio());
58        encoder.set_format(decoder.format());
59        encoder.set_frame_rate(decoder.frame_rate());
60        encoder.set_time_base(decoder.frame_rate().unwrap().invert());
61        if global_header {
62            encoder.set_flags(codec::Flags::GLOBAL_HEADER);
63        }
64
65        encoder
66            .open_with(x264_opts)
67            .expect("error opening libx264 encoder with supplied settings");
68        encoder = codec::context::Context::from_parameters(ost.parameters())?
69            .encoder()
70            .video()?;
71        ost.set_parameters(&encoder);
72        Ok(Self {
73            ost_index,
74            decoder,
75            encoder: codec::context::Context::from_parameters(ost.parameters())?
76                .encoder()
77                .video()?,
78            logging_enabled: enable_logging,
79            frame_count: 0,
80            last_log_frame_count: 0,
81            starting_time: Instant::now(),
82            last_log_time: Instant::now(),
83        })
84    }

More examples

Hide additional examples

examples/transcode-audio.rs (line 112)

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

Source

pub fn set_frame_rate<R: Into<Rational>>(&mut self, value: Option<R>)

Examples found in repository ?

examples/transcode-x264.rs (line 59)

40    fn new(
41        ist: &format::stream::Stream,
42        octx: &mut format::context::Output,
43        ost_index: usize,
44        x264_opts: Dictionary,
45        enable_logging: bool,
46    ) -> Result<Self, ffmpeg_rs::Error> {
47        let global_header = octx.format().flags().contains(format::Flags::GLOBAL_HEADER);
48        let decoder = ffmpeg_rs::codec::context::Context::from_parameters(ist.parameters())?
49            .decoder()
50            .video()?;
51        let mut ost = octx.add_stream(encoder::find(codec::Id::H264))?;
52        let mut encoder = codec::context::Context::from_parameters(ost.parameters())?
53            .encoder()
54            .video()?;
55        encoder.set_height(decoder.height());
56        encoder.set_width(decoder.width());
57        encoder.set_aspect_ratio(decoder.aspect_ratio());
58        encoder.set_format(decoder.format());
59        encoder.set_frame_rate(decoder.frame_rate());
60        encoder.set_time_base(decoder.frame_rate().unwrap().invert());
61        if global_header {
62            encoder.set_flags(codec::Flags::GLOBAL_HEADER);
63        }
64
65        encoder
66            .open_with(x264_opts)
67            .expect("error opening libx264 encoder with supplied settings");
68        encoder = codec::context::Context::from_parameters(ost.parameters())?
69            .encoder()
70            .video()?;
71        ost.set_parameters(&encoder);
72        Ok(Self {
73            ost_index,
74            decoder,
75            encoder: codec::context::Context::from_parameters(ost.parameters())?
76                .encoder()
77                .video()?,
78            logging_enabled: enable_logging,
79            frame_count: 0,
80            last_log_frame_count: 0,
81            starting_time: Instant::now(),
82            last_log_time: Instant::now(),
83        })
84    }

Methods from Deref<Target = Context>§

Source

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

Source

pub unsafe fn as_mut_ptr(&mut self) -> *mut AVCodecContext

Source

pub fn codec(&self) -> Option<Codec>

Examples found in repository ?

examples/transcode-audio.rs (line 39)

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

Source

pub fn medium(&self) -> Type

Examples found in repository ?

examples/metadata.rs (line 46)

4fn main() -> Result<(), ffmpeg_rs::Error> {
5    ffmpeg_rs::init().unwrap();
6
7    match ffmpeg_rs::format::input(&env::args().nth(1).expect("missing file")) {
8        Ok(context) => {
9            for (k, v) in context.metadata().iter() {
10                println!("{}: {}", k, v);
11            }
12
13            if let Some(stream) = context.streams().best(ffmpeg_rs::media::Type::Video) {
14                println!("Best video stream index: {}", stream.index());
15            }
16
17            if let Some(stream) = context.streams().best(ffmpeg_rs::media::Type::Audio) {
18                println!("Best audio stream index: {}", stream.index());
19            }
20
21            if let Some(stream) = context.streams().best(ffmpeg_rs::media::Type::Subtitle) {
22                println!("Best subtitle stream index: {}", stream.index());
23            }
24
25            println!(
26                "duration (seconds): {:.2}",
27                context.duration() as f64 / f64::from(ffmpeg_rs::ffi::AV_TIME_BASE)
28            );
29
30            for stream in context.streams() {
31                println!("stream index {}:", stream.index());
32                println!("\ttime_base: {}", stream.time_base());
33                println!("\tstart_time: {}", stream.start_time());
34                println!("\tduration (stream timebase): {}", stream.duration());
35                println!(
36                    "\tduration (seconds): {:.2}",
37                    stream.duration() as f64 * f64::from(stream.time_base())
38                );
39                println!("\tframes: {}", stream.frames());
40                println!("\tdisposition: {:?}", stream.disposition());
41                println!("\tdiscard: {:?}", stream.discard());
42                println!("\trate: {}", stream.rate());
43
44                let codec =
45                    ffmpeg_rs::codec::context::Context::from_parameters(stream.parameters())?;
46                println!("\tmedium: {:?}", codec.medium());
47                println!("\tid: {:?}", codec.id());
48
49                if codec.medium() == ffmpeg_rs::media::Type::Video {
50                    if let Ok(video) = codec.decoder().video() {
51                        println!("\tbit_rate: {}", video.bit_rate());
52                        println!("\tmax_rate: {}", video.max_bit_rate());
53                        println!("\tdelay: {}", video.delay());
54                        println!("\tvideo.width: {}", video.width());
55                        println!("\tvideo.height: {}", video.height());
56                        println!("\tvideo.format: {:?}", video.format());
57                        println!("\tvideo.has_b_frames: {}", video.has_b_frames());
58                        println!("\tvideo.aspect_ratio: {}", video.aspect_ratio());
59                        println!("\tvideo.color_space: {:?}", video.color_space());
60                        println!("\tvideo.color_range: {:?}", video.color_range());
61                        println!("\tvideo.color_primaries: {:?}", video.color_primaries());
62                        println!(
63                            "\tvideo.color_transfer_characteristic: {:?}",
64                            video.color_transfer_characteristic()
65                        );
66                        println!("\tvideo.chroma_location: {:?}", video.chroma_location());
67                        println!("\tvideo.references: {}", video.references());
68                        println!("\tvideo.intra_dc_precision: {}", video.intra_dc_precision());
69                    }
70                } else if codec.medium() == ffmpeg_rs::media::Type::Audio {
71                    if let Ok(audio) = codec.decoder().audio() {
72                        println!("\tbit_rate: {}", audio.bit_rate());
73                        println!("\tmax_rate: {}", audio.max_bit_rate());
74                        println!("\tdelay: {}", audio.delay());
75                        println!("\taudio.rate: {}", audio.rate());
76                        println!("\taudio.channels: {}", audio.channels());
77                        println!("\taudio.format: {:?}", audio.format());
78                        println!("\taudio.frames: {}", audio.frames());
79                        println!("\taudio.align: {}", audio.align());
80                        println!("\taudio.channel_layout: {:?}", audio.channel_layout());
81                    }
82                }
83            }
84        }
85
86        Err(error) => println!("error: {}", error),
87    }
88    Ok(())
89}

Source

pub fn set_flags(&mut self, value: Flags)

Examples found in repository ?

examples/transcode-x264.rs (line 62)

40    fn new(
41        ist: &format::stream::Stream,
42        octx: &mut format::context::Output,
43        ost_index: usize,
44        x264_opts: Dictionary,
45        enable_logging: bool,
46    ) -> Result<Self, ffmpeg_rs::Error> {
47        let global_header = octx.format().flags().contains(format::Flags::GLOBAL_HEADER);
48        let decoder = ffmpeg_rs::codec::context::Context::from_parameters(ist.parameters())?
49            .decoder()
50            .video()?;
51        let mut ost = octx.add_stream(encoder::find(codec::Id::H264))?;
52        let mut encoder = codec::context::Context::from_parameters(ost.parameters())?
53            .encoder()
54            .video()?;
55        encoder.set_height(decoder.height());
56        encoder.set_width(decoder.width());
57        encoder.set_aspect_ratio(decoder.aspect_ratio());
58        encoder.set_format(decoder.format());
59        encoder.set_frame_rate(decoder.frame_rate());
60        encoder.set_time_base(decoder.frame_rate().unwrap().invert());
61        if global_header {
62            encoder.set_flags(codec::Flags::GLOBAL_HEADER);
63        }
64
65        encoder
66            .open_with(x264_opts)
67            .expect("error opening libx264 encoder with supplied settings");
68        encoder = codec::context::Context::from_parameters(ost.parameters())?
69            .encoder()
70            .video()?;
71        ost.set_parameters(&encoder);
72        Ok(Self {
73            ost_index,
74            decoder,
75            encoder: codec::context::Context::from_parameters(ost.parameters())?
76                .encoder()
77                .video()?,
78            logging_enabled: enable_logging,
79            frame_count: 0,
80            last_log_frame_count: 0,
81            starting_time: Instant::now(),
82            last_log_time: Instant::now(),
83        })
84    }

More examples

Hide additional examples

examples/transcode-audio.rs (line 96)

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

Source

pub fn id(&self) -> Id

Examples found in repository ?

examples/metadata.rs (line 47)

4fn main() -> Result<(), ffmpeg_rs::Error> {
5    ffmpeg_rs::init().unwrap();
6
7    match ffmpeg_rs::format::input(&env::args().nth(1).expect("missing file")) {
8        Ok(context) => {
9            for (k, v) in context.metadata().iter() {
10                println!("{}: {}", k, v);
11            }
12
13            if let Some(stream) = context.streams().best(ffmpeg_rs::media::Type::Video) {
14                println!("Best video stream index: {}", stream.index());
15            }
16
17            if let Some(stream) = context.streams().best(ffmpeg_rs::media::Type::Audio) {
18                println!("Best audio stream index: {}", stream.index());
19            }
20
21            if let Some(stream) = context.streams().best(ffmpeg_rs::media::Type::Subtitle) {
22                println!("Best subtitle stream index: {}", stream.index());
23            }
24
25            println!(
26                "duration (seconds): {:.2}",
27                context.duration() as f64 / f64::from(ffmpeg_rs::ffi::AV_TIME_BASE)
28            );
29
30            for stream in context.streams() {
31                println!("stream index {}:", stream.index());
32                println!("\ttime_base: {}", stream.time_base());
33                println!("\tstart_time: {}", stream.start_time());
34                println!("\tduration (stream timebase): {}", stream.duration());
35                println!(
36                    "\tduration (seconds): {:.2}",
37                    stream.duration() as f64 * f64::from(stream.time_base())
38                );
39                println!("\tframes: {}", stream.frames());
40                println!("\tdisposition: {:?}", stream.disposition());
41                println!("\tdiscard: {:?}", stream.discard());
42                println!("\trate: {}", stream.rate());
43
44                let codec =
45                    ffmpeg_rs::codec::context::Context::from_parameters(stream.parameters())?;
46                println!("\tmedium: {:?}", codec.medium());
47                println!("\tid: {:?}", codec.id());
48
49                if codec.medium() == ffmpeg_rs::media::Type::Video {
50                    if let Ok(video) = codec.decoder().video() {
51                        println!("\tbit_rate: {}", video.bit_rate());
52                        println!("\tmax_rate: {}", video.max_bit_rate());
53                        println!("\tdelay: {}", video.delay());
54                        println!("\tvideo.width: {}", video.width());
55                        println!("\tvideo.height: {}", video.height());
56                        println!("\tvideo.format: {:?}", video.format());
57                        println!("\tvideo.has_b_frames: {}", video.has_b_frames());
58                        println!("\tvideo.aspect_ratio: {}", video.aspect_ratio());
59                        println!("\tvideo.color_space: {:?}", video.color_space());
60                        println!("\tvideo.color_range: {:?}", video.color_range());
61                        println!("\tvideo.color_primaries: {:?}", video.color_primaries());
62                        println!(
63                            "\tvideo.color_transfer_characteristic: {:?}",
64                            video.color_transfer_characteristic()
65                        );
66                        println!("\tvideo.chroma_location: {:?}", video.chroma_location());
67                        println!("\tvideo.references: {}", video.references());
68                        println!("\tvideo.intra_dc_precision: {}", video.intra_dc_precision());
69                    }
70                } else if codec.medium() == ffmpeg_rs::media::Type::Audio {
71                    if let Ok(audio) = codec.decoder().audio() {
72                        println!("\tbit_rate: {}", audio.bit_rate());
73                        println!("\tmax_rate: {}", audio.max_bit_rate());
74                        println!("\tdelay: {}", audio.delay());
75                        println!("\taudio.rate: {}", audio.rate());
76                        println!("\taudio.channels: {}", audio.channels());
77                        println!("\taudio.format: {:?}", audio.format());
78                        println!("\taudio.frames: {}", audio.frames());
79                        println!("\taudio.align: {}", audio.align());
80                        println!("\taudio.channel_layout: {:?}", audio.channel_layout());
81                    }
82                }
83            }
84        }
85
86        Err(error) => println!("error: {}", error),
87    }
88    Ok(())
89}

Source

pub fn compliance(&mut self, value: Compliance)

Source

pub fn debug(&mut self, value: Debug)

Source

pub fn set_threading(&mut self, config: Config)

Source

pub fn threading(&self) -> Config

Source

pub fn set_parameters<P: Into<Parameters>>( &mut self, parameters: P, ) -> Result<(), Error>

Examples found in repository ?

examples/transcode-audio.rs (line 84)

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