Struct Output

Source

pub struct Output { /* private fields */ }

Implementations§

Source §

pub fn format(&self) -> Output

Examples found in repository ?

examples/transcode-audio.rs (line 74)

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

Source

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

Examples found in repository ?

examples/transcode-audio.rs (line 157)

136fn main() {
137    ffmpeg::init().unwrap();
138
139    let input = env::args().nth(1).expect("missing input");
140    let output = env::args().nth(2).expect("missing output");
141    let filter = env::args().nth(3).unwrap_or_else(|| "anull".to_owned());
142    let seek = env::args().nth(4).and_then(|s| s.parse::<i64>().ok());
143
144    let mut ictx = format::input(&input).unwrap();
145    let mut octx = format::output(&output).unwrap();
146    let mut transcoder = transcoder(&mut ictx, &mut octx, &output, &filter).unwrap();
147
148    if let Some(position) = seek {
149        // If the position was given in seconds, rescale it to ffmpegs base timebase.
150        let position = position.rescale((1, 1), rescale::TIME_BASE);
151        // If this seek was embedded in the transcoding loop, a call of `flush()`
152        // for every opened buffer after the successful seek would be advisable.
153        ictx.seek(position, ..position).unwrap();
154    }
155
156    octx.set_metadata(ictx.metadata().to_owned());
157    octx.write_header().unwrap();
158
159    let in_time_base = transcoder.decoder.time_base();
160    let out_time_base = octx.stream(0).unwrap().time_base();
161
162    let mut decoded = frame::Audio::empty();
163    let mut encoded = ffmpeg::Packet::empty();
164
165    for (stream, mut packet) in ictx.packets() {
166        if stream.index() == transcoder.stream {
167            packet.rescale_ts(stream.time_base(), in_time_base);
168
169            if let Ok(true) = transcoder.decoder.decode(&packet, &mut decoded) {
170                let timestamp = decoded.timestamp();
171                decoded.set_pts(timestamp);
172
173                transcoder
174                    .filter
175                    .get("in")
176                    .unwrap()
177                    .source()
178                    .add(&decoded)
179                    .unwrap();
180
181                while let Ok(..) = transcoder
182                    .filter
183                    .get("out")
184                    .unwrap()
185                    .sink()
186                    .frame(&mut decoded)
187                {
188                    if let Ok(true) = transcoder.encoder.encode(&decoded, &mut encoded) {
189                        encoded.set_stream(0);
190                        encoded.rescale_ts(in_time_base, out_time_base);
191                        encoded.write_interleaved(&mut octx).unwrap();
192                    }
193                }
194            }
195        }
196    }
197
198    transcoder
199        .filter
200        .get("in")
201        .unwrap()
202        .source()
203        .flush()
204        .unwrap();
205
206    while let Ok(..) = transcoder
207        .filter
208        .get("out")
209        .unwrap()
210        .sink()
211        .frame(&mut decoded)
212    {
213        if let Ok(true) = transcoder.encoder.encode(&decoded, &mut encoded) {
214            encoded.set_stream(0);
215            encoded.rescale_ts(in_time_base, out_time_base);
216            encoded.write_interleaved(&mut octx).unwrap();
217        }
218    }
219
220    if let Ok(true) = transcoder.encoder.flush(&mut encoded) {
221        encoded.set_stream(0);
222        encoded.rescale_ts(in_time_base, out_time_base);
223        encoded.write_interleaved(&mut octx).unwrap();
224    }
225
226    octx.write_trailer().unwrap();
227}

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 226)

136fn main() {
137    ffmpeg::init().unwrap();
138
139    let input = env::args().nth(1).expect("missing input");
140    let output = env::args().nth(2).expect("missing output");
141    let filter = env::args().nth(3).unwrap_or_else(|| "anull".to_owned());
142    let seek = env::args().nth(4).and_then(|s| s.parse::<i64>().ok());
143
144    let mut ictx = format::input(&input).unwrap();
145    let mut octx = format::output(&output).unwrap();
146    let mut transcoder = transcoder(&mut ictx, &mut octx, &output, &filter).unwrap();
147
148    if let Some(position) = seek {
149        // If the position was given in seconds, rescale it to ffmpegs base timebase.
150        let position = position.rescale((1, 1), rescale::TIME_BASE);
151        // If this seek was embedded in the transcoding loop, a call of `flush()`
152        // for every opened buffer after the successful seek would be advisable.
153        ictx.seek(position, ..position).unwrap();
154    }
155
156    octx.set_metadata(ictx.metadata().to_owned());
157    octx.write_header().unwrap();
158
159    let in_time_base = transcoder.decoder.time_base();
160    let out_time_base = octx.stream(0).unwrap().time_base();
161
162    let mut decoded = frame::Audio::empty();
163    let mut encoded = ffmpeg::Packet::empty();
164
165    for (stream, mut packet) in ictx.packets() {
166        if stream.index() == transcoder.stream {
167            packet.rescale_ts(stream.time_base(), in_time_base);
168
169            if let Ok(true) = transcoder.decoder.decode(&packet, &mut decoded) {
170                let timestamp = decoded.timestamp();
171                decoded.set_pts(timestamp);
172
173                transcoder
174                    .filter
175                    .get("in")
176                    .unwrap()
177                    .source()
178                    .add(&decoded)
179                    .unwrap();
180
181                while let Ok(..) = transcoder
182                    .filter
183                    .get("out")
184                    .unwrap()
185                    .sink()
186                    .frame(&mut decoded)
187                {
188                    if let Ok(true) = transcoder.encoder.encode(&decoded, &mut encoded) {
189                        encoded.set_stream(0);
190                        encoded.rescale_ts(in_time_base, out_time_base);
191                        encoded.write_interleaved(&mut octx).unwrap();
192                    }
193                }
194            }
195        }
196    }
197
198    transcoder
199        .filter
200        .get("in")
201        .unwrap()
202        .source()
203        .flush()
204        .unwrap();
205
206    while let Ok(..) = transcoder
207        .filter
208        .get("out")
209        .unwrap()
210        .sink()
211        .frame(&mut decoded)
212    {
213        if let Ok(true) = transcoder.encoder.encode(&decoded, &mut encoded) {
214            encoded.set_stream(0);
215            encoded.rescale_ts(in_time_base, out_time_base);
216            encoded.write_interleaved(&mut octx).unwrap();
217        }
218    }
219
220    if let Ok(true) = transcoder.encoder.flush(&mut encoded) {
221        encoded.set_stream(0);
222        encoded.rescale_ts(in_time_base, out_time_base);
223        encoded.write_interleaved(&mut octx).unwrap();
224    }
225
226    octx.write_trailer().unwrap();
227}

Source

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

Examples found in repository ?

examples/transcode-audio.rs (line 84)

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

Source

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

Examples found in repository ?

examples/chapters.rs (lines 32-38)

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 =
24                ffmpeg::format::output(&"test.mkv".to_owned()).expect("Couldn't open test file");
25
26            for chapter in ictx.chapters() {
27                let title = match chapter.metadata().get("title") {
28                    Some(title) => String::from(title),
29                    None => String::new(),
30                };
31
32                match octx.add_chapter(
33                    chapter.id(),
34                    chapter.time_base(),
35                    chapter.start(),
36                    chapter.end(),
37                    &title,
38                ) {
39                    Ok(chapter) => println!("Added chapter with id {} to output", chapter.id()),
40                    Err(error) => {
41                        println!("Error adding chapter with id: {} - {}", chapter.id(), error)
42                    }
43                }
44            }
45
46            println!("\nOuput: nb chapters: {}", octx.nb_chapters());
47            for chapter in octx.chapters() {
48                println!("chapter id {}:", chapter.id());
49                println!("\ttime_base: {}", chapter.time_base());
50                println!("\tstart: {}", chapter.start());
51                println!("\tend: {}", chapter.end());
52                for (k, v) in chapter.metadata().iter() {
53                    println!("\t{}: {}", k, v);
54                }
55            }
56        }
57
58        Err(error) => println!("error: {}", error),
59    }
60}

Source

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

Examples found in repository ?

examples/transcode-audio.rs (line 156)

136fn main() {
137    ffmpeg::init().unwrap();
138
139    let input = env::args().nth(1).expect("missing input");
140    let output = env::args().nth(2).expect("missing output");
141    let filter = env::args().nth(3).unwrap_or_else(|| "anull".to_owned());
142    let seek = env::args().nth(4).and_then(|s| s.parse::<i64>().ok());
143
144    let mut ictx = format::input(&input).unwrap();
145    let mut octx = format::output(&output).unwrap();
146    let mut transcoder = transcoder(&mut ictx, &mut octx, &output, &filter).unwrap();
147
148    if let Some(position) = seek {
149        // If the position was given in seconds, rescale it to ffmpegs base timebase.
150        let position = position.rescale((1, 1), rescale::TIME_BASE);
151        // If this seek was embedded in the transcoding loop, a call of `flush()`
152        // for every opened buffer after the successful seek would be advisable.
153        ictx.seek(position, ..position).unwrap();
154    }
155
156    octx.set_metadata(ictx.metadata().to_owned());
157    octx.write_header().unwrap();
158
159    let in_time_base = transcoder.decoder.time_base();
160    let out_time_base = octx.stream(0).unwrap().time_base();
161
162    let mut decoded = frame::Audio::empty();
163    let mut encoded = ffmpeg::Packet::empty();
164
165    for (stream, mut packet) in ictx.packets() {
166        if stream.index() == transcoder.stream {
167            packet.rescale_ts(stream.time_base(), in_time_base);
168
169            if let Ok(true) = transcoder.decoder.decode(&packet, &mut decoded) {
170                let timestamp = decoded.timestamp();
171                decoded.set_pts(timestamp);
172
173                transcoder
174                    .filter
175                    .get("in")
176                    .unwrap()
177                    .source()
178                    .add(&decoded)
179                    .unwrap();
180
181                while let Ok(..) = transcoder
182                    .filter
183                    .get("out")
184                    .unwrap()
185                    .sink()
186                    .frame(&mut decoded)
187                {
188                    if let Ok(true) = transcoder.encoder.encode(&decoded, &mut encoded) {
189                        encoded.set_stream(0);
190                        encoded.rescale_ts(in_time_base, out_time_base);
191                        encoded.write_interleaved(&mut octx).unwrap();
192                    }
193                }
194            }
195        }
196    }
197
198    transcoder
199        .filter
200        .get("in")
201        .unwrap()
202        .source()
203        .flush()
204        .unwrap();
205
206    while let Ok(..) = transcoder
207        .filter
208        .get("out")
209        .unwrap()
210        .sink()
211        .frame(&mut decoded)
212    {
213        if let Ok(true) = transcoder.encoder.encode(&decoded, &mut encoded) {
214            encoded.set_stream(0);
215            encoded.rescale_ts(in_time_base, out_time_base);
216            encoded.write_interleaved(&mut octx).unwrap();
217        }
218    }
219
220    if let Ok(true) = transcoder.encoder.flush(&mut encoded) {
221        encoded.set_stream(0);
222        encoded.rescale_ts(in_time_base, out_time_base);
223        encoded.write_interleaved(&mut octx).unwrap();
224    }
225
226    octx.write_trailer().unwrap();
227}