Skip to main content

Output

ffmpeg_next::format::context::output

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 wrap_with_custom_io( ptr: *mut AVFormatContext, custom_io: StreamIo, ) -> 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 50)
43    fn new(
44        ist: &format::stream::Stream,
45        octx: &mut format::context::Output,
46        ost_index: usize,
47        x264_opts: Dictionary,
48        enable_logging: bool,
49    ) -> Result<Self, ffmpeg::Error> {
50        let global_header = octx.format().flags().contains(format::Flags::GLOBAL_HEADER);
51        let decoder = ffmpeg::codec::context::Context::from_parameters(ist.parameters())?
52            .decoder()
53            .video()?;
54
55        let codec = encoder::find(codec::Id::H264);
56        let mut ost = octx.add_stream(codec)?;
57
58        let mut encoder =
59            codec::context::Context::new_with_codec(codec.ok_or(ffmpeg::Error::InvalidData)?)
60                .encoder()
61                .video()?;
62        ost.set_parameters(&encoder);
63        encoder.set_height(decoder.height());
64        encoder.set_width(decoder.width());
65        encoder.set_aspect_ratio(decoder.aspect_ratio());
66        encoder.set_format(decoder.format());
67        encoder.set_frame_rate(decoder.frame_rate());
68        encoder.set_time_base(ist.time_base());
69
70        if global_header {
71            encoder.set_flags(codec::Flags::GLOBAL_HEADER);
72        }
73
74        let opened_encoder = encoder
75            .open_with(x264_opts)
76            .expect("error opening x264 with supplied settings");
77        ost.set_parameters(&opened_encoder);
78        Ok(Self {
79            ost_index,
80            decoder,
81            input_time_base: ist.time_base(),
82            encoder: opened_encoder,
83            logging_enabled: enable_logging,
84            frame_count: 0,
85            last_log_frame_count: 0,
86            starting_time: Instant::now(),
87            last_log_time: Instant::now(),
88        })
89    }
More examples
Hide additional examples
examples/transcode-audio.rs (line 76)
64fn transcoder<P: AsRef<Path> + ?Sized>(
65    ictx: &mut format::context::Input,
66    octx: &mut format::context::Output,
67    path: &P,
68    filter_spec: &str,
69) -> Result<Transcoder, ffmpeg::Error> {
70    let input = ictx
71        .streams()
72        .best(media::Type::Audio)
73        .expect("could not find best audio stream");
74    let context = ffmpeg::codec::context::Context::from_parameters(input.parameters())?;
75    let mut decoder = context.decoder().audio()?;
76    let codec = ffmpeg::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::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::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::channel_layout::ChannelLayout::STEREO);
94
95    if global {
96        encoder.set_flags(ffmpeg::codec::flag::Flags::GLOBAL_HEADER);
97    }
98
99    encoder.set_rate(decoder.rate() as i32);
100    encoder.set_channel_layout(channel_layout);
101    #[cfg(not(feature = "ffmpeg_7_0"))]
102    {
103        encoder.set_channels(channel_layout.channels());
104    }
105    encoder.set_format(
106        codec
107            .formats()
108            .expect("unknown supported formats")
109            .next()
110            .unwrap(),
111    );
112    encoder.set_bit_rate(decoder.bit_rate());
113    encoder.set_max_bit_rate(decoder.max_bit_rate());
114
115    encoder.set_time_base((1, decoder.rate() as i32));
116    output.set_time_base((1, decoder.rate() as i32));
117
118    let encoder = encoder.open_as(codec)?;
119    output.set_parameters(&encoder);
120
121    let filter = filter(filter_spec, &decoder, &encoder)?;
122
123    let in_time_base = decoder.time_base();
124    let out_time_base = output.time_base();
125
126    Ok(Transcoder {
127        stream: input.index(),
128        filter,
129        decoder,
130        encoder,
131        in_time_base,
132        out_time_base,
133    })
134}
Source

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

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

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

Examples found in repository?
examples/transcode-x264.rs (line 56)
43    fn new(
44        ist: &format::stream::Stream,
45        octx: &mut format::context::Output,
46        ost_index: usize,
47        x264_opts: Dictionary,
48        enable_logging: bool,
49    ) -> Result<Self, ffmpeg::Error> {
50        let global_header = octx.format().flags().contains(format::Flags::GLOBAL_HEADER);
51        let decoder = ffmpeg::codec::context::Context::from_parameters(ist.parameters())?
52            .decoder()
53            .video()?;
54
55        let codec = encoder::find(codec::Id::H264);
56        let mut ost = octx.add_stream(codec)?;
57
58        let mut encoder =
59            codec::context::Context::new_with_codec(codec.ok_or(ffmpeg::Error::InvalidData)?)
60                .encoder()
61                .video()?;
62        ost.set_parameters(&encoder);
63        encoder.set_height(decoder.height());
64        encoder.set_width(decoder.width());
65        encoder.set_aspect_ratio(decoder.aspect_ratio());
66        encoder.set_format(decoder.format());
67        encoder.set_frame_rate(decoder.frame_rate());
68        encoder.set_time_base(ist.time_base());
69
70        if global_header {
71            encoder.set_flags(codec::Flags::GLOBAL_HEADER);
72        }
73
74        let opened_encoder = encoder
75            .open_with(x264_opts)
76            .expect("error opening x264 with supplied settings");
77        ost.set_parameters(&opened_encoder);
78        Ok(Self {
79            ost_index,
80            decoder,
81            input_time_base: ist.time_base(),
82            encoder: opened_encoder,
83            logging_enabled: enable_logging,
84            frame_count: 0,
85            last_log_frame_count: 0,
86            starting_time: Instant::now(),
87            last_log_time: Instant::now(),
88        })
89    }
90
91    fn send_packet_to_decoder(&mut self, packet: &Packet) {
92        self.decoder.send_packet(packet).unwrap();
93    }
94
95    fn send_eof_to_decoder(&mut self) {
96        self.decoder.send_eof().unwrap();
97    }
98
99    fn receive_and_process_decoded_frames(
100        &mut self,
101        octx: &mut format::context::Output,
102        ost_time_base: Rational,
103    ) {
104        let mut frame = frame::Video::empty();
105        while self.decoder.receive_frame(&mut frame).is_ok() {
106            self.frame_count += 1;
107            let timestamp = frame.timestamp();
108            self.log_progress(f64::from(
109                Rational(timestamp.unwrap_or(0) as i32, 1) * self.input_time_base,
110            ));
111            frame.set_pts(timestamp);
112            frame.set_kind(picture::Type::None);
113            self.send_frame_to_encoder(&frame);
114            self.receive_and_process_encoded_packets(octx, ost_time_base);
115        }
116    }
117
118    fn send_frame_to_encoder(&mut self, frame: &frame::Video) {
119        self.encoder.send_frame(frame).unwrap();
120    }
121
122    fn send_eof_to_encoder(&mut self) {
123        self.encoder.send_eof().unwrap();
124    }
125
126    fn receive_and_process_encoded_packets(
127        &mut self,
128        octx: &mut format::context::Output,
129        ost_time_base: Rational,
130    ) {
131        let mut encoded = Packet::empty();
132        while self.encoder.receive_packet(&mut encoded).is_ok() {
133            encoded.set_stream(self.ost_index);
134            encoded.rescale_ts(self.input_time_base, ost_time_base);
135            encoded.write_interleaved(octx).unwrap();
136        }
137    }
138
139    fn log_progress(&mut self, timestamp: f64) {
140        if !self.logging_enabled
141            || (self.frame_count - self.last_log_frame_count < 100
142                && self.last_log_time.elapsed().as_secs_f64() < 1.0)
143        {
144            return;
145        }
146        eprintln!(
147            "time elpased: \t{:8.2}\tframe count: {:8}\ttimestamp: {:8.2}",
148            self.starting_time.elapsed().as_secs_f64(),
149            self.frame_count,
150            timestamp
151        );
152        self.last_log_frame_count = self.frame_count;
153        self.last_log_time = Instant::now();
154    }
155}
156
157fn parse_opts<'a>(s: String) -> Option<Dictionary<'a>> {
158    let mut dict = Dictionary::new();
159    for keyval in s.split_terminator(',') {
160        let tokens: Vec<&str> = keyval.split('=').collect();
161        match tokens[..] {
162            [key, val] => dict.set(key, val),
163            _ => return None,
164        }
165    }
166    Some(dict)
167}
168
169fn main() {
170    let input_file = env::args().nth(1).expect("missing input file");
171    let output_file = env::args().nth(2).expect("missing output file");
172    let x264_opts = parse_opts(
173        env::args()
174            .nth(3)
175            .unwrap_or_else(|| DEFAULT_X264_OPTS.to_string()),
176    )
177    .expect("invalid x264 options string");
178
179    eprintln!("x264 options: {:?}", x264_opts);
180
181    ffmpeg::init().unwrap();
182    log::set_level(log::Level::Info);
183
184    let mut ictx = format::input(&input_file).unwrap();
185    let mut octx = format::output(&output_file).unwrap();
186
187    format::context::input::dump(&ictx, 0, Some(&input_file));
188
189    let best_video_stream_index = ictx
190        .streams()
191        .best(media::Type::Video)
192        .map(|stream| stream.index());
193    let mut stream_mapping: Vec<isize> = vec![0; ictx.nb_streams() as _];
194    let mut ist_time_bases = vec![Rational(0, 0); ictx.nb_streams() as _];
195    let mut ost_time_bases = vec![Rational(0, 0); ictx.nb_streams() as _];
196    let mut transcoders = HashMap::new();
197    let mut ost_index = 0;
198    for (ist_index, ist) in ictx.streams().enumerate() {
199        let ist_medium = ist.parameters().medium();
200        if ist_medium != media::Type::Audio
201            && ist_medium != media::Type::Video
202            && ist_medium != media::Type::Subtitle
203        {
204            stream_mapping[ist_index] = -1;
205            continue;
206        }
207        stream_mapping[ist_index] = ost_index;
208        ist_time_bases[ist_index] = ist.time_base();
209        if ist_medium == media::Type::Video {
210            // Initialize transcoder for video stream.
211            transcoders.insert(
212                ist_index,
213                Transcoder::new(
214                    &ist,
215                    &mut octx,
216                    ost_index as _,
217                    x264_opts.to_owned(),
218                    Some(ist_index) == best_video_stream_index,
219                )
220                .unwrap(),
221            );
222        } else {
223            // Set up for stream copy for non-video stream.
224            let mut ost = octx.add_stream(encoder::find(codec::Id::None)).unwrap();
225            ost.set_parameters(ist.parameters());
226            // We need to set codec_tag to 0 lest we run into incompatible codec tag
227            // issues when muxing into a different container format. Unfortunately
228            // there's no high level API to do this (yet).
229            unsafe {
230                (*ost.parameters().as_mut_ptr()).codec_tag = 0;
231            }
232        }
233        ost_index += 1;
234    }
235
236    octx.set_metadata(ictx.metadata().to_owned());
237    format::context::output::dump(&octx, 0, Some(&output_file));
238    octx.write_header().unwrap();
239
240    for (ost_index, _) in octx.streams().enumerate() {
241        ost_time_bases[ost_index] = octx.stream(ost_index as _).unwrap().time_base();
242    }
243
244    for (stream, mut packet) in ictx.packets() {
245        let ist_index = stream.index();
246        let ost_index = stream_mapping[ist_index];
247        if ost_index < 0 {
248            continue;
249        }
250        let ost_time_base = ost_time_bases[ost_index as usize];
251        match transcoders.get_mut(&ist_index) {
252            Some(transcoder) => {
253                transcoder.send_packet_to_decoder(&packet);
254                transcoder.receive_and_process_decoded_frames(&mut octx, ost_time_base);
255            }
256            None => {
257                // Do stream copy on non-video streams.
258                packet.rescale_ts(ist_time_bases[ist_index], ost_time_base);
259                packet.set_position(-1);
260                packet.set_stream(ost_index as _);
261                packet.write_interleaved(&mut octx).unwrap();
262            }
263        }
264    }
265
266    // Flush encoders and decoders.
267    for (ost_index, transcoder) in transcoders.iter_mut() {
268        let ost_time_base = ost_time_bases[*ost_index];
269        transcoder.send_eof_to_decoder();
270        transcoder.receive_and_process_decoded_frames(&mut octx, ost_time_base);
271        transcoder.send_eof_to_encoder();
272        transcoder.receive_and_process_encoded_packets(&mut octx, ost_time_base);
273    }
274
275    octx.write_trailer().unwrap();
276}
More examples
Hide additional examples
examples/remux.rs (line 32)
7fn main() {
8    let input_file = env::args().nth(1).expect("missing input file");
9    let output_file = env::args().nth(2).expect("missing output file");
10
11    ffmpeg::init().unwrap();
12    log::set_level(log::Level::Warning);
13
14    let mut ictx = format::input(&input_file).unwrap();
15    let mut octx = format::output(&output_file).unwrap();
16
17    let mut stream_mapping = vec![0; ictx.nb_streams() as _];
18    let mut ist_time_bases = vec![Rational(0, 1); ictx.nb_streams() as _];
19    let mut ost_index = 0;
20    for (ist_index, ist) in ictx.streams().enumerate() {
21        let ist_medium = ist.parameters().medium();
22        if ist_medium != media::Type::Audio
23            && ist_medium != media::Type::Video
24            && ist_medium != media::Type::Subtitle
25        {
26            stream_mapping[ist_index] = -1;
27            continue;
28        }
29        stream_mapping[ist_index] = ost_index;
30        ist_time_bases[ist_index] = ist.time_base();
31        ost_index += 1;
32        let mut ost = octx.add_stream(encoder::find(codec::Id::None)).unwrap();
33        ost.set_parameters(ist.parameters());
34        // We need to set codec_tag to 0 lest we run into incompatible codec tag
35        // issues when muxing into a different container format. Unfortunately
36        // there's no high level API to do this (yet).
37        unsafe {
38            (*ost.parameters().as_mut_ptr()).codec_tag = 0;
39        }
40    }
41
42    octx.set_metadata(ictx.metadata().to_owned());
43    octx.write_header().unwrap();
44
45    for (stream, mut packet) in ictx.packets() {
46        let ist_index = stream.index();
47        let ost_index = stream_mapping[ist_index];
48        if ost_index < 0 {
49            continue;
50        }
51        let ost = octx.stream(ost_index as _).unwrap();
52        packet.rescale_ts(ist_time_bases[ist_index], ost.time_base());
53        packet.set_position(-1);
54        packet.set_stream(ost_index as _);
55        packet.write_interleaved(&mut octx).unwrap();
56    }
57
58    octx.write_trailer().unwrap();
59}
examples/transcode-audio.rs (line 86)
64fn transcoder<P: AsRef<Path> + ?Sized>(
65    ictx: &mut format::context::Input,
66    octx: &mut format::context::Output,
67    path: &P,
68    filter_spec: &str,
69) -> Result<Transcoder, ffmpeg::Error> {
70    let input = ictx
71        .streams()
72        .best(media::Type::Audio)
73        .expect("could not find best audio stream");
74    let context = ffmpeg::codec::context::Context::from_parameters(input.parameters())?;
75    let mut decoder = context.decoder().audio()?;
76    let codec = ffmpeg::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::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::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::channel_layout::ChannelLayout::STEREO);
94
95    if global {
96        encoder.set_flags(ffmpeg::codec::flag::Flags::GLOBAL_HEADER);
97    }
98
99    encoder.set_rate(decoder.rate() as i32);
100    encoder.set_channel_layout(channel_layout);
101    #[cfg(not(feature = "ffmpeg_7_0"))]
102    {
103        encoder.set_channels(channel_layout.channels());
104    }
105    encoder.set_format(
106        codec
107            .formats()
108            .expect("unknown supported formats")
109            .next()
110            .unwrap(),
111    );
112    encoder.set_bit_rate(decoder.bit_rate());
113    encoder.set_max_bit_rate(decoder.max_bit_rate());
114
115    encoder.set_time_base((1, decoder.rate() as i32));
116    output.set_time_base((1, decoder.rate() as i32));
117
118    let encoder = encoder.open_as(codec)?;
119    output.set_parameters(&encoder);
120
121    let filter = filter(filter_spec, &decoder, &encoder)?;
122
123    let in_time_base = decoder.time_base();
124    let out_time_base = output.time_base();
125
126    Ok(Transcoder {
127        stream: input.index(),
128        filter,
129        decoder,
130        encoder,
131        in_time_base,
132        out_time_base,
133    })
134}
Source

pub fn add_stream_with( &mut self, context: &Context, ) -> Result<StreamMut<'_>, Error>

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

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

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

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.