Struct Output

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

Implementations§

Source§

impl Output

Source

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

Source

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

Source

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

Source§

impl Output

Source

pub fn format(&self) -> Output

Examples found in repository?
examples/transcode-x264.rs (line 47)
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 76)
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 write_header(&mut self) -> Result<(), Error>

Examples found in repository?
examples/transcode-audio.rs (line 225)
204fn main() {
205    ffmpeg_rs::init().unwrap();
206
207    let input = env::args().nth(1).expect("missing input");
208    let output = env::args().nth(2).expect("missing output");
209    let filter = env::args().nth(3).unwrap_or_else(|| "anull".to_owned());
210    let seek = env::args().nth(4).and_then(|s| s.parse::<i64>().ok());
211
212    let mut ictx = format::input(&input).unwrap();
213    let mut octx = format::output(&output).unwrap();
214    let mut transcoder = transcoder(&mut ictx, &mut octx, &output, &filter).unwrap();
215
216    if let Some(position) = seek {
217        // If the position was given in seconds, rescale it to ffmpegs base timebase.
218        let position = position.rescale((1, 1), rescale::TIME_BASE);
219        // If this seek was embedded in the transcoding loop, a call of `flush()`
220        // for every opened buffer after the successful seek would be advisable.
221        ictx.seek(position, ..position).unwrap();
222    }
223
224    octx.set_metadata(ictx.metadata().to_owned());
225    octx.write_header().unwrap();
226
227    for (stream, mut packet) in ictx.packets() {
228        if stream.index() == transcoder.stream {
229            packet.rescale_ts(stream.time_base(), transcoder.in_time_base);
230            transcoder.send_packet_to_decoder(&packet);
231            transcoder.receive_and_process_decoded_frames(&mut octx);
232        }
233    }
234
235    transcoder.send_eof_to_decoder();
236    transcoder.receive_and_process_decoded_frames(&mut octx);
237
238    transcoder.flush_filter();
239    transcoder.get_and_process_filtered_frames(&mut octx);
240
241    transcoder.send_eof_to_encoder();
242    transcoder.receive_and_process_encoded_packets(&mut octx);
243
244    octx.write_trailer().unwrap();
245}
More examples
Hide additional examples
examples/remux.rs (line 42)
6fn main() {
7    let input_file = env::args().nth(1).expect("missing input file");
8    let output_file = env::args().nth(2).expect("missing output file");
9
10    ffmpeg_rs::init().unwrap();
11    log::set_level(log::Level::Warning);
12
13    let mut ictx = format::input(&input_file).unwrap();
14    let mut octx = format::output(&output_file).unwrap();
15
16    let mut stream_mapping = vec![0; ictx.nb_streams() as _];
17    let mut ist_time_bases = vec![Rational(0, 1); ictx.nb_streams() as _];
18    let mut ost_index = 0;
19    for (ist_index, ist) in ictx.streams().enumerate() {
20        let ist_medium = ist.parameters().codec_type();
21        if ist_medium != media::Type::Audio
22            && ist_medium != media::Type::Video
23            && ist_medium != media::Type::Subtitle
24        {
25            stream_mapping[ist_index] = -1;
26            continue;
27        }
28        stream_mapping[ist_index] = ost_index;
29        ist_time_bases[ist_index] = ist.time_base();
30        ost_index += 1;
31        let mut ost = octx.add_stream(encoder::find(codec::Id::None)).unwrap();
32        ost.set_parameters(ist.parameters());
33        // We need to set codec_tag to 0 lest we run into incompatible codec tag
34        // issues when muxing into a different container format. Unfortunately
35        // there's no high level API to do this (yet).
36        unsafe {
37            (*ost.parameters().as_mut_ptr()).codec_tag = 0;
38        }
39    }
40
41    octx.set_metadata(ictx.metadata().to_owned());
42    octx.write_header().unwrap();
43
44    for (stream, mut packet) in ictx.packets() {
45        let ist_index = stream.index();
46        let ost_index = stream_mapping[ist_index];
47        if ost_index < 0 {
48            continue;
49        }
50        let ost = octx.stream(ost_index as _).unwrap();
51        packet.rescale_ts(ist_time_bases[ist_index], ost.time_base());
52        packet.set_position(-1);
53        packet.set_stream(ost_index as _);
54        packet.write_interleaved(&mut octx).unwrap();
55    }
56
57    octx.write_trailer().unwrap();
58}
examples/transcode-x264.rs (line 233)
164fn main() {
165    let input_file = env::args().nth(1).expect("missing input file");
166    let output_file = env::args().nth(2).expect("missing output file");
167    let x264_opts = parse_opts(
168        env::args()
169            .nth(3)
170            .unwrap_or_else(|| DEFAULT_X264_OPTS.to_string()),
171    )
172    .expect("invalid x264 options string");
173
174    eprintln!("x264 options: {:?}", x264_opts);
175
176    ffmpeg_rs::init().unwrap();
177    log::set_level(log::Level::Info);
178
179    let mut ictx = format::input(&input_file).unwrap();
180    let mut octx = format::output(&output_file).unwrap();
181
182    format::context::input::dump(&ictx, 0, Some(&input_file));
183
184    let best_video_stream_index = ictx
185        .streams()
186        .best(media::Type::Video)
187        .map(|stream| stream.index());
188    let mut stream_mapping: Vec<isize> = vec![0; ictx.nb_streams() as _];
189    let mut ist_time_bases = vec![Rational(0, 0); ictx.nb_streams() as _];
190    let mut ost_time_bases = vec![Rational(0, 0); ictx.nb_streams() as _];
191    let mut transcoders = HashMap::new();
192    let mut ost_index = 0;
193    for (ist_index, ist) in ictx.streams().enumerate() {
194        let ist_medium = ist.parameters().codec_type();
195        if ist_medium != media::Type::Audio
196            && ist_medium != media::Type::Video
197            && ist_medium != media::Type::Subtitle
198        {
199            stream_mapping[ist_index] = -1;
200            continue;
201        }
202        stream_mapping[ist_index] = ost_index;
203        ist_time_bases[ist_index] = ist.time_base();
204        if ist_medium == media::Type::Video {
205            // Initialize transcoder for video stream.
206            transcoders.insert(
207                ist_index,
208                Transcoder::new(
209                    &ist,
210                    &mut octx,
211                    ost_index as _,
212                    x264_opts.to_owned(),
213                    Some(ist_index) == best_video_stream_index,
214                )
215                .unwrap(),
216            );
217        } else {
218            // Set up for stream copy for non-video stream.
219            let mut ost = octx.add_stream(encoder::find(codec::Id::None)).unwrap();
220            ost.set_parameters(ist.parameters());
221            // We need to set codec_tag to 0 lest we run into incompatible codec tag
222            // issues when muxing into a different container format. Unfortunately
223            // there's no high level API to do this (yet).
224            unsafe {
225                (*ost.parameters().as_mut_ptr()).codec_tag = 0;
226            }
227        }
228        ost_index += 1;
229    }
230
231    octx.set_metadata(ictx.metadata().to_owned());
232    format::context::output::dump(&octx, 0, Some(&output_file));
233    octx.write_header().unwrap();
234
235    for (ost_index, _) in octx.streams().enumerate() {
236        ost_time_bases[ost_index] = octx.stream(ost_index as _).unwrap().time_base();
237    }
238
239    for (stream, mut packet) in ictx.packets() {
240        let ist_index = stream.index();
241        let ost_index = stream_mapping[ist_index];
242        if ost_index < 0 {
243            continue;
244        }
245        let ost_time_base = ost_time_bases[ost_index as usize];
246        match transcoders.get_mut(&ist_index) {
247            Some(transcoder) => {
248                packet.rescale_ts(stream.time_base(), transcoder.decoder.time_base());
249                transcoder.send_packet_to_decoder(&packet);
250                transcoder.receive_and_process_decoded_frames(&mut octx, ost_time_base);
251            }
252            None => {
253                // Do stream copy on non-video streams.
254                packet.rescale_ts(ist_time_bases[ist_index], ost_time_base);
255                packet.set_position(-1);
256                packet.set_stream(ost_index as _);
257                packet.write_interleaved(&mut octx).unwrap();
258            }
259        }
260    }
261
262    // Flush encoders and decoders.
263    for (ost_index, transcoder) in transcoders.iter_mut() {
264        let ost_time_base = ost_time_bases[*ost_index];
265        transcoder.send_eof_to_decoder();
266        transcoder.receive_and_process_decoded_frames(&mut octx, ost_time_base);
267        transcoder.send_eof_to_encoder();
268        transcoder.receive_and_process_encoded_packets(&mut octx, ost_time_base);
269    }
270
271    octx.write_trailer().unwrap();
272}
Source

pub fn write_header_with( &mut self, options: Dictionary<'_>, ) -> Result<Dictionary<'_>, Error>

Source

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

Examples found in repository?
examples/transcode-audio.rs (line 244)
204fn main() {
205    ffmpeg_rs::init().unwrap();
206
207    let input = env::args().nth(1).expect("missing input");
208    let output = env::args().nth(2).expect("missing output");
209    let filter = env::args().nth(3).unwrap_or_else(|| "anull".to_owned());
210    let seek = env::args().nth(4).and_then(|s| s.parse::<i64>().ok());
211
212    let mut ictx = format::input(&input).unwrap();
213    let mut octx = format::output(&output).unwrap();
214    let mut transcoder = transcoder(&mut ictx, &mut octx, &output, &filter).unwrap();
215
216    if let Some(position) = seek {
217        // If the position was given in seconds, rescale it to ffmpegs base timebase.
218        let position = position.rescale((1, 1), rescale::TIME_BASE);
219        // If this seek was embedded in the transcoding loop, a call of `flush()`
220        // for every opened buffer after the successful seek would be advisable.
221        ictx.seek(position, ..position).unwrap();
222    }
223
224    octx.set_metadata(ictx.metadata().to_owned());
225    octx.write_header().unwrap();
226
227    for (stream, mut packet) in ictx.packets() {
228        if stream.index() == transcoder.stream {
229            packet.rescale_ts(stream.time_base(), transcoder.in_time_base);
230            transcoder.send_packet_to_decoder(&packet);
231            transcoder.receive_and_process_decoded_frames(&mut octx);
232        }
233    }
234
235    transcoder.send_eof_to_decoder();
236    transcoder.receive_and_process_decoded_frames(&mut octx);
237
238    transcoder.flush_filter();
239    transcoder.get_and_process_filtered_frames(&mut octx);
240
241    transcoder.send_eof_to_encoder();
242    transcoder.receive_and_process_encoded_packets(&mut octx);
243
244    octx.write_trailer().unwrap();
245}
More examples
Hide additional examples
examples/remux.rs (line 57)
6fn main() {
7    let input_file = env::args().nth(1).expect("missing input file");
8    let output_file = env::args().nth(2).expect("missing output file");
9
10    ffmpeg_rs::init().unwrap();
11    log::set_level(log::Level::Warning);
12
13    let mut ictx = format::input(&input_file).unwrap();
14    let mut octx = format::output(&output_file).unwrap();
15
16    let mut stream_mapping = vec![0; ictx.nb_streams() as _];
17    let mut ist_time_bases = vec![Rational(0, 1); ictx.nb_streams() as _];
18    let mut ost_index = 0;
19    for (ist_index, ist) in ictx.streams().enumerate() {
20        let ist_medium = ist.parameters().codec_type();
21        if ist_medium != media::Type::Audio
22            && ist_medium != media::Type::Video
23            && ist_medium != media::Type::Subtitle
24        {
25            stream_mapping[ist_index] = -1;
26            continue;
27        }
28        stream_mapping[ist_index] = ost_index;
29        ist_time_bases[ist_index] = ist.time_base();
30        ost_index += 1;
31        let mut ost = octx.add_stream(encoder::find(codec::Id::None)).unwrap();
32        ost.set_parameters(ist.parameters());
33        // We need to set codec_tag to 0 lest we run into incompatible codec tag
34        // issues when muxing into a different container format. Unfortunately
35        // there's no high level API to do this (yet).
36        unsafe {
37            (*ost.parameters().as_mut_ptr()).codec_tag = 0;
38        }
39    }
40
41    octx.set_metadata(ictx.metadata().to_owned());
42    octx.write_header().unwrap();
43
44    for (stream, mut packet) in ictx.packets() {
45        let ist_index = stream.index();
46        let ost_index = stream_mapping[ist_index];
47        if ost_index < 0 {
48            continue;
49        }
50        let ost = octx.stream(ost_index as _).unwrap();
51        packet.rescale_ts(ist_time_bases[ist_index], ost.time_base());
52        packet.set_position(-1);
53        packet.set_stream(ost_index as _);
54        packet.write_interleaved(&mut octx).unwrap();
55    }
56
57    octx.write_trailer().unwrap();
58}
examples/transcode-x264.rs (line 271)
164fn main() {
165    let input_file = env::args().nth(1).expect("missing input file");
166    let output_file = env::args().nth(2).expect("missing output file");
167    let x264_opts = parse_opts(
168        env::args()
169            .nth(3)
170            .unwrap_or_else(|| DEFAULT_X264_OPTS.to_string()),
171    )
172    .expect("invalid x264 options string");
173
174    eprintln!("x264 options: {:?}", x264_opts);
175
176    ffmpeg_rs::init().unwrap();
177    log::set_level(log::Level::Info);
178
179    let mut ictx = format::input(&input_file).unwrap();
180    let mut octx = format::output(&output_file).unwrap();
181
182    format::context::input::dump(&ictx, 0, Some(&input_file));
183
184    let best_video_stream_index = ictx
185        .streams()
186        .best(media::Type::Video)
187        .map(|stream| stream.index());
188    let mut stream_mapping: Vec<isize> = vec![0; ictx.nb_streams() as _];
189    let mut ist_time_bases = vec![Rational(0, 0); ictx.nb_streams() as _];
190    let mut ost_time_bases = vec![Rational(0, 0); ictx.nb_streams() as _];
191    let mut transcoders = HashMap::new();
192    let mut ost_index = 0;
193    for (ist_index, ist) in ictx.streams().enumerate() {
194        let ist_medium = ist.parameters().codec_type();
195        if ist_medium != media::Type::Audio
196            && ist_medium != media::Type::Video
197            && ist_medium != media::Type::Subtitle
198        {
199            stream_mapping[ist_index] = -1;
200            continue;
201        }
202        stream_mapping[ist_index] = ost_index;
203        ist_time_bases[ist_index] = ist.time_base();
204        if ist_medium == media::Type::Video {
205            // Initialize transcoder for video stream.
206            transcoders.insert(
207                ist_index,
208                Transcoder::new(
209                    &ist,
210                    &mut octx,
211                    ost_index as _,
212                    x264_opts.to_owned(),
213                    Some(ist_index) == best_video_stream_index,
214                )
215                .unwrap(),
216            );
217        } else {
218            // Set up for stream copy for non-video stream.
219            let mut ost = octx.add_stream(encoder::find(codec::Id::None)).unwrap();
220            ost.set_parameters(ist.parameters());
221            // We need to set codec_tag to 0 lest we run into incompatible codec tag
222            // issues when muxing into a different container format. Unfortunately
223            // there's no high level API to do this (yet).
224            unsafe {
225                (*ost.parameters().as_mut_ptr()).codec_tag = 0;
226            }
227        }
228        ost_index += 1;
229    }
230
231    octx.set_metadata(ictx.metadata().to_owned());
232    format::context::output::dump(&octx, 0, Some(&output_file));
233    octx.write_header().unwrap();
234
235    for (ost_index, _) in octx.streams().enumerate() {
236        ost_time_bases[ost_index] = octx.stream(ost_index as _).unwrap().time_base();
237    }
238
239    for (stream, mut packet) in ictx.packets() {
240        let ist_index = stream.index();
241        let ost_index = stream_mapping[ist_index];
242        if ost_index < 0 {
243            continue;
244        }
245        let ost_time_base = ost_time_bases[ost_index as usize];
246        match transcoders.get_mut(&ist_index) {
247            Some(transcoder) => {
248                packet.rescale_ts(stream.time_base(), transcoder.decoder.time_base());
249                transcoder.send_packet_to_decoder(&packet);
250                transcoder.receive_and_process_decoded_frames(&mut octx, ost_time_base);
251            }
252            None => {
253                // Do stream copy on non-video streams.
254                packet.rescale_ts(ist_time_bases[ist_index], ost_time_base);
255                packet.set_position(-1);
256                packet.set_stream(ost_index as _);
257                packet.write_interleaved(&mut octx).unwrap();
258            }
259        }
260    }
261
262    // Flush encoders and decoders.
263    for (ost_index, transcoder) in transcoders.iter_mut() {
264        let ost_time_base = ost_time_bases[*ost_index];
265        transcoder.send_eof_to_decoder();
266        transcoder.receive_and_process_decoded_frames(&mut octx, ost_time_base);
267        transcoder.send_eof_to_encoder();
268        transcoder.receive_and_process_encoded_packets(&mut octx, ost_time_base);
269    }
270
271    octx.write_trailer().unwrap();
272}
Source

pub fn add_stream<E: Encoder>( &mut self, codec: E, ) -> Result<StreamMut<'_>, Error>

Examples found in repository?
examples/transcode-x264.rs (line 51)
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    }
85
86    fn send_packet_to_decoder(&mut self, packet: &Packet) {
87        self.decoder.send_packet(packet).unwrap();
88    }
89
90    fn send_eof_to_decoder(&mut self) {
91        self.decoder.send_eof().unwrap();
92    }
93
94    fn receive_and_process_decoded_frames(
95        &mut self,
96        octx: &mut format::context::Output,
97        ost_time_base: Rational,
98    ) {
99        let mut frame = frame::Video::empty();
100        while self.decoder.receive_frame(&mut frame).is_ok() {
101            self.frame_count += 1;
102            let timestamp = frame.timestamp();
103            self.log_progress(f64::from(
104                Rational(timestamp.unwrap_or(0) as i32, 1) * self.decoder.time_base(),
105            ));
106            frame.set_pts(timestamp);
107            frame.set_kind(picture::Type::None);
108            self.send_frame_to_encoder(&frame);
109            self.receive_and_process_encoded_packets(octx, ost_time_base);
110        }
111    }
112
113    fn send_frame_to_encoder(&mut self, frame: &frame::Video) {
114        self.encoder.send_frame(frame).unwrap();
115    }
116
117    fn send_eof_to_encoder(&mut self) {
118        self.encoder.send_eof().unwrap();
119    }
120
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    }
133
134    fn log_progress(&mut self, timestamp: f64) {
135        if !self.logging_enabled
136            || (self.frame_count - self.last_log_frame_count < 100
137                && self.last_log_time.elapsed().as_secs_f64() < 1.0)
138        {
139            return;
140        }
141        eprintln!(
142            "time elpased: \t{:8.2}\tframe count: {:8}\ttimestamp: {:8.2}",
143            self.starting_time.elapsed().as_secs_f64(),
144            self.frame_count,
145            timestamp
146        );
147        self.last_log_frame_count = self.frame_count;
148        self.last_log_time = Instant::now();
149    }
150}
151
152fn parse_opts<'a>(s: String) -> Option<Dictionary<'a>> {
153    let mut dict = Dictionary::new();
154    for keyval in s.split_terminator(',') {
155        let tokens: Vec<&str> = keyval.split('=').collect();
156        match tokens[..] {
157            [key, val] => dict.set(key, val),
158            _ => return None,
159        }
160    }
161    Some(dict)
162}
163
164fn main() {
165    let input_file = env::args().nth(1).expect("missing input file");
166    let output_file = env::args().nth(2).expect("missing output file");
167    let x264_opts = parse_opts(
168        env::args()
169            .nth(3)
170            .unwrap_or_else(|| DEFAULT_X264_OPTS.to_string()),
171    )
172    .expect("invalid x264 options string");
173
174    eprintln!("x264 options: {:?}", x264_opts);
175
176    ffmpeg_rs::init().unwrap();
177    log::set_level(log::Level::Info);
178
179    let mut ictx = format::input(&input_file).unwrap();
180    let mut octx = format::output(&output_file).unwrap();
181
182    format::context::input::dump(&ictx, 0, Some(&input_file));
183
184    let best_video_stream_index = ictx
185        .streams()
186        .best(media::Type::Video)
187        .map(|stream| stream.index());
188    let mut stream_mapping: Vec<isize> = vec![0; ictx.nb_streams() as _];
189    let mut ist_time_bases = vec![Rational(0, 0); ictx.nb_streams() as _];
190    let mut ost_time_bases = vec![Rational(0, 0); ictx.nb_streams() as _];
191    let mut transcoders = HashMap::new();
192    let mut ost_index = 0;
193    for (ist_index, ist) in ictx.streams().enumerate() {
194        let ist_medium = ist.parameters().codec_type();
195        if ist_medium != media::Type::Audio
196            && ist_medium != media::Type::Video
197            && ist_medium != media::Type::Subtitle
198        {
199            stream_mapping[ist_index] = -1;
200            continue;
201        }
202        stream_mapping[ist_index] = ost_index;
203        ist_time_bases[ist_index] = ist.time_base();
204        if ist_medium == media::Type::Video {
205            // Initialize transcoder for video stream.
206            transcoders.insert(
207                ist_index,
208                Transcoder::new(
209                    &ist,
210                    &mut octx,
211                    ost_index as _,
212                    x264_opts.to_owned(),
213                    Some(ist_index) == best_video_stream_index,
214                )
215                .unwrap(),
216            );
217        } else {
218            // Set up for stream copy for non-video stream.
219            let mut ost = octx.add_stream(encoder::find(codec::Id::None)).unwrap();
220            ost.set_parameters(ist.parameters());
221            // We need to set codec_tag to 0 lest we run into incompatible codec tag
222            // issues when muxing into a different container format. Unfortunately
223            // there's no high level API to do this (yet).
224            unsafe {
225                (*ost.parameters().as_mut_ptr()).codec_tag = 0;
226            }
227        }
228        ost_index += 1;
229    }
230
231    octx.set_metadata(ictx.metadata().to_owned());
232    format::context::output::dump(&octx, 0, Some(&output_file));
233    octx.write_header().unwrap();
234
235    for (ost_index, _) in octx.streams().enumerate() {
236        ost_time_bases[ost_index] = octx.stream(ost_index as _).unwrap().time_base();
237    }
238
239    for (stream, mut packet) in ictx.packets() {
240        let ist_index = stream.index();
241        let ost_index = stream_mapping[ist_index];
242        if ost_index < 0 {
243            continue;
244        }
245        let ost_time_base = ost_time_bases[ost_index as usize];
246        match transcoders.get_mut(&ist_index) {
247            Some(transcoder) => {
248                packet.rescale_ts(stream.time_base(), transcoder.decoder.time_base());
249                transcoder.send_packet_to_decoder(&packet);
250                transcoder.receive_and_process_decoded_frames(&mut octx, ost_time_base);
251            }
252            None => {
253                // Do stream copy on non-video streams.
254                packet.rescale_ts(ist_time_bases[ist_index], ost_time_base);
255                packet.set_position(-1);
256                packet.set_stream(ost_index as _);
257                packet.write_interleaved(&mut octx).unwrap();
258            }
259        }
260    }
261
262    // Flush encoders and decoders.
263    for (ost_index, transcoder) in transcoders.iter_mut() {
264        let ost_time_base = ost_time_bases[*ost_index];
265        transcoder.send_eof_to_decoder();
266        transcoder.receive_and_process_decoded_frames(&mut octx, ost_time_base);
267        transcoder.send_eof_to_encoder();
268        transcoder.receive_and_process_encoded_packets(&mut octx, ost_time_base);
269    }
270
271    octx.write_trailer().unwrap();
272}
More examples
Hide additional examples
examples/remux.rs (line 31)
6fn main() {
7    let input_file = env::args().nth(1).expect("missing input file");
8    let output_file = env::args().nth(2).expect("missing output file");
9
10    ffmpeg_rs::init().unwrap();
11    log::set_level(log::Level::Warning);
12
13    let mut ictx = format::input(&input_file).unwrap();
14    let mut octx = format::output(&output_file).unwrap();
15
16    let mut stream_mapping = vec![0; ictx.nb_streams() as _];
17    let mut ist_time_bases = vec![Rational(0, 1); ictx.nb_streams() as _];
18    let mut ost_index = 0;
19    for (ist_index, ist) in ictx.streams().enumerate() {
20        let ist_medium = ist.parameters().codec_type();
21        if ist_medium != media::Type::Audio
22            && ist_medium != media::Type::Video
23            && ist_medium != media::Type::Subtitle
24        {
25            stream_mapping[ist_index] = -1;
26            continue;
27        }
28        stream_mapping[ist_index] = ost_index;
29        ist_time_bases[ist_index] = ist.time_base();
30        ost_index += 1;
31        let mut ost = octx.add_stream(encoder::find(codec::Id::None)).unwrap();
32        ost.set_parameters(ist.parameters());
33        // We need to set codec_tag to 0 lest we run into incompatible codec tag
34        // issues when muxing into a different container format. Unfortunately
35        // there's no high level API to do this (yet).
36        unsafe {
37            (*ost.parameters().as_mut_ptr()).codec_tag = 0;
38        }
39    }
40
41    octx.set_metadata(ictx.metadata().to_owned());
42    octx.write_header().unwrap();
43
44    for (stream, mut packet) in ictx.packets() {
45        let ist_index = stream.index();
46        let ost_index = stream_mapping[ist_index];
47        if ost_index < 0 {
48            continue;
49        }
50        let ost = octx.stream(ost_index as _).unwrap();
51        packet.rescale_ts(ist_time_bases[ist_index], ost.time_base());
52        packet.set_position(-1);
53        packet.set_stream(ost_index as _);
54        packet.write_interleaved(&mut octx).unwrap();
55    }
56
57    octx.write_trailer().unwrap();
58}
examples/transcode-audio.rs (line 86)
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_flags(&mut self, value: Flags)

Source

pub fn add_chapter<R: Into<Rational>, S: AsRef<str>>( &mut self, id: i64, time_base: R, start: i64, end: i64, title: S, ) -> Result<ChapterMut<'_>, Error>

Examples found in repository?
examples/chapters.rs (lines 30-36)
4fn main() {
5    ffmpeg_rs::init().unwrap();
6
7    match ffmpeg_rs::format::input(&env::args().nth(1).expect("missing input file name")) {
8        Ok(ictx) => {
9            println!("Nb chapters: {}", ictx.nb_chapters());
10
11            for chapter in ictx.chapters() {
12                println!("chapter id {}:", chapter.id());
13                println!("\ttime_base: {}", chapter.time_base());
14                println!("\tstart: {}", chapter.start());
15                println!("\tend: {}", chapter.end());
16
17                for (k, v) in chapter.metadata().iter() {
18                    println!("\t{}: {}", k, v);
19                }
20            }
21
22            let mut octx = ffmpeg_rs::format::output(&"test.mkv").expect("Couldn't open test file");
23
24            for chapter in ictx.chapters() {
25                let title = match chapter.metadata().get("title") {
26                    Some(title) => String::from(title),
27                    None => String::new(),
28                };
29
30                match octx.add_chapter(
31                    chapter.id(),
32                    chapter.time_base(),
33                    chapter.start(),
34                    chapter.end(),
35                    &title,
36                ) {
37                    Ok(chapter) => println!("Added chapter with id {} to output", chapter.id()),
38                    Err(error) => {
39                        println!("Error adding chapter with id: {} - {}", chapter.id(), error)
40                    }
41                }
42            }
43
44            println!("\nOuput: nb chapters: {}", octx.nb_chapters());
45            for chapter in octx.chapters() {
46                println!("chapter id {}:", chapter.id());
47                println!("\ttime_base: {}", chapter.time_base());
48                println!("\tstart: {}", chapter.start());
49                println!("\tend: {}", chapter.end());
50                for (k, v) in chapter.metadata().iter() {
51                    println!("\t{}: {}", k, v);
52                }
53            }
54        }
55
56        Err(error) => println!("error: {}", error),
57    }
58}
Source

pub fn set_metadata(&mut self, dictionary: Dictionary<'_>)

Examples found in repository?
examples/transcode-audio.rs (line 224)
204fn main() {
205    ffmpeg_rs::init().unwrap();
206
207    let input = env::args().nth(1).expect("missing input");
208    let output = env::args().nth(2).expect("missing output");
209    let filter = env::args().nth(3).unwrap_or_else(|| "anull".to_owned());
210    let seek = env::args().nth(4).and_then(|s| s.parse::<i64>().ok());
211
212    let mut ictx = format::input(&input).unwrap();
213    let mut octx = format::output(&output).unwrap();
214    let mut transcoder = transcoder(&mut ictx, &mut octx, &output, &filter).unwrap();
215
216    if let Some(position) = seek {
217        // If the position was given in seconds, rescale it to ffmpegs base timebase.
218        let position = position.rescale((1, 1), rescale::TIME_BASE);
219        // If this seek was embedded in the transcoding loop, a call of `flush()`
220        // for every opened buffer after the successful seek would be advisable.
221        ictx.seek(position, ..position).unwrap();
222    }
223
224    octx.set_metadata(ictx.metadata().to_owned());
225    octx.write_header().unwrap();
226
227    for (stream, mut packet) in ictx.packets() {
228        if stream.index() == transcoder.stream {
229            packet.rescale_ts(stream.time_base(), transcoder.in_time_base);
230            transcoder.send_packet_to_decoder(&packet);
231            transcoder.receive_and_process_decoded_frames(&mut octx);
232        }
233    }
234
235    transcoder.send_eof_to_decoder();
236    transcoder.receive_and_process_decoded_frames(&mut octx);
237
238    transcoder.flush_filter();
239    transcoder.get_and_process_filtered_frames(&mut octx);
240
241    transcoder.send_eof_to_encoder();
242    transcoder.receive_and_process_encoded_packets(&mut octx);
243
244    octx.write_trailer().unwrap();
245}
More examples
Hide additional examples
examples/remux.rs (line 41)
6fn main() {
7    let input_file = env::args().nth(1).expect("missing input file");
8    let output_file = env::args().nth(2).expect("missing output file");
9
10    ffmpeg_rs::init().unwrap();
11    log::set_level(log::Level::Warning);
12
13    let mut ictx = format::input(&input_file).unwrap();
14    let mut octx = format::output(&output_file).unwrap();
15
16    let mut stream_mapping = vec![0; ictx.nb_streams() as _];
17    let mut ist_time_bases = vec![Rational(0, 1); ictx.nb_streams() as _];
18    let mut ost_index = 0;
19    for (ist_index, ist) in ictx.streams().enumerate() {
20        let ist_medium = ist.parameters().codec_type();
21        if ist_medium != media::Type::Audio
22            && ist_medium != media::Type::Video
23            && ist_medium != media::Type::Subtitle
24        {
25            stream_mapping[ist_index] = -1;
26            continue;
27        }
28        stream_mapping[ist_index] = ost_index;
29        ist_time_bases[ist_index] = ist.time_base();
30        ost_index += 1;
31        let mut ost = octx.add_stream(encoder::find(codec::Id::None)).unwrap();
32        ost.set_parameters(ist.parameters());
33        // We need to set codec_tag to 0 lest we run into incompatible codec tag
34        // issues when muxing into a different container format. Unfortunately
35        // there's no high level API to do this (yet).
36        unsafe {
37            (*ost.parameters().as_mut_ptr()).codec_tag = 0;
38        }
39    }
40
41    octx.set_metadata(ictx.metadata().to_owned());
42    octx.write_header().unwrap();
43
44    for (stream, mut packet) in ictx.packets() {
45        let ist_index = stream.index();
46        let ost_index = stream_mapping[ist_index];
47        if ost_index < 0 {
48            continue;
49        }
50        let ost = octx.stream(ost_index as _).unwrap();
51        packet.rescale_ts(ist_time_bases[ist_index], ost.time_base());
52        packet.set_position(-1);
53        packet.set_stream(ost_index as _);
54        packet.write_interleaved(&mut octx).unwrap();
55    }
56
57    octx.write_trailer().unwrap();
58}
examples/transcode-x264.rs (line 231)
164fn main() {
165    let input_file = env::args().nth(1).expect("missing input file");
166    let output_file = env::args().nth(2).expect("missing output file");
167    let x264_opts = parse_opts(
168        env::args()
169            .nth(3)
170            .unwrap_or_else(|| DEFAULT_X264_OPTS.to_string()),
171    )
172    .expect("invalid x264 options string");
173
174    eprintln!("x264 options: {:?}", x264_opts);
175
176    ffmpeg_rs::init().unwrap();
177    log::set_level(log::Level::Info);
178
179    let mut ictx = format::input(&input_file).unwrap();
180    let mut octx = format::output(&output_file).unwrap();
181
182    format::context::input::dump(&ictx, 0, Some(&input_file));
183
184    let best_video_stream_index = ictx
185        .streams()
186        .best(media::Type::Video)
187        .map(|stream| stream.index());
188    let mut stream_mapping: Vec<isize> = vec![0; ictx.nb_streams() as _];
189    let mut ist_time_bases = vec![Rational(0, 0); ictx.nb_streams() as _];
190    let mut ost_time_bases = vec![Rational(0, 0); ictx.nb_streams() as _];
191    let mut transcoders = HashMap::new();
192    let mut ost_index = 0;
193    for (ist_index, ist) in ictx.streams().enumerate() {
194        let ist_medium = ist.parameters().codec_type();
195        if ist_medium != media::Type::Audio
196            && ist_medium != media::Type::Video
197            && ist_medium != media::Type::Subtitle
198        {
199            stream_mapping[ist_index] = -1;
200            continue;
201        }
202        stream_mapping[ist_index] = ost_index;
203        ist_time_bases[ist_index] = ist.time_base();
204        if ist_medium == media::Type::Video {
205            // Initialize transcoder for video stream.
206            transcoders.insert(
207                ist_index,
208                Transcoder::new(
209                    &ist,
210                    &mut octx,
211                    ost_index as _,
212                    x264_opts.to_owned(),
213                    Some(ist_index) == best_video_stream_index,
214                )
215                .unwrap(),
216            );
217        } else {
218            // Set up for stream copy for non-video stream.
219            let mut ost = octx.add_stream(encoder::find(codec::Id::None)).unwrap();
220            ost.set_parameters(ist.parameters());
221            // We need to set codec_tag to 0 lest we run into incompatible codec tag
222            // issues when muxing into a different container format. Unfortunately
223            // there's no high level API to do this (yet).
224            unsafe {
225                (*ost.parameters().as_mut_ptr()).codec_tag = 0;
226            }
227        }
228        ost_index += 1;
229    }
230
231    octx.set_metadata(ictx.metadata().to_owned());
232    format::context::output::dump(&octx, 0, Some(&output_file));
233    octx.write_header().unwrap();
234
235    for (ost_index, _) in octx.streams().enumerate() {
236        ost_time_bases[ost_index] = octx.stream(ost_index as _).unwrap().time_base();
237    }
238
239    for (stream, mut packet) in ictx.packets() {
240        let ist_index = stream.index();
241        let ost_index = stream_mapping[ist_index];
242        if ost_index < 0 {
243            continue;
244        }
245        let ost_time_base = ost_time_bases[ost_index as usize];
246        match transcoders.get_mut(&ist_index) {
247            Some(transcoder) => {
248                packet.rescale_ts(stream.time_base(), transcoder.decoder.time_base());
249                transcoder.send_packet_to_decoder(&packet);
250                transcoder.receive_and_process_decoded_frames(&mut octx, ost_time_base);
251            }
252            None => {
253                // Do stream copy on non-video streams.
254                packet.rescale_ts(ist_time_bases[ist_index], ost_time_base);
255                packet.set_position(-1);
256                packet.set_stream(ost_index as _);
257                packet.write_interleaved(&mut octx).unwrap();
258            }
259        }
260    }
261
262    // Flush encoders and decoders.
263    for (ost_index, transcoder) in transcoders.iter_mut() {
264        let ost_time_base = ost_time_bases[*ost_index];
265        transcoder.send_eof_to_decoder();
266        transcoder.receive_and_process_decoded_frames(&mut octx, ost_time_base);
267        transcoder.send_eof_to_encoder();
268        transcoder.receive_and_process_encoded_packets(&mut octx, ost_time_base);
269    }
270
271    octx.write_trailer().unwrap();
272}

Trait Implementations§

Source§

impl Deref for Output

Source§

type Target = Context

The resulting type after dereferencing.
Source§

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

Dereferences the value.
Source§

impl DerefMut for Output

Source§

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.
Source§

impl Send for Output

Auto Trait Implementations§

Blanket Implementations§

Source§

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

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

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

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

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

Source§

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

Mutably borrows from an owned value. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

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

Source§

fn into(self) -> U

Calls U::from(self).

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

Source§

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

Source§

type Target = T

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

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

Source§

type Error = Infallible

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

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

Performs the conversion.
Source§

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

Source§

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

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

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

Performs the conversion.