pub fn find(id: Id) -> Option<Codec>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
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 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}