Commit | Line | Data |
---|---|---|
6291d7e4 AK |
1 | /* |
2 | * avconv main | |
3 | * Copyright (c) 2000-2011 The libav developers. | |
4 | * | |
5 | * This file is part of Libav. | |
6 | * | |
7 | * Libav is free software; you can redistribute it and/or | |
8 | * modify it under the terms of the GNU Lesser General Public | |
9 | * License as published by the Free Software Foundation; either | |
10 | * version 2.1 of the License, or (at your option) any later version. | |
11 | * | |
12 | * Libav is distributed in the hope that it will be useful, | |
13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
15 | * Lesser General Public License for more details. | |
16 | * | |
17 | * You should have received a copy of the GNU Lesser General Public | |
18 | * License along with Libav; if not, write to the Free Software | |
19 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | |
20 | */ | |
21 | ||
22 | #include "config.h" | |
23 | #include <ctype.h> | |
24 | #include <string.h> | |
25 | #include <math.h> | |
26 | #include <stdlib.h> | |
27 | #include <errno.h> | |
28 | #include <signal.h> | |
29 | #include <limits.h> | |
8f8bc923 DB |
30 | #include <stdint.h> |
31 | ||
6291d7e4 AK |
32 | #include "libavformat/avformat.h" |
33 | #include "libavdevice/avdevice.h" | |
34 | #include "libswscale/swscale.h" | |
bcb82fe1 | 35 | #include "libavresample/avresample.h" |
6291d7e4 | 36 | #include "libavutil/opt.h" |
a903f8f0 | 37 | #include "libavutil/channel_layout.h" |
6291d7e4 AK |
38 | #include "libavutil/parseutils.h" |
39 | #include "libavutil/samplefmt.h" | |
6291d7e4 AK |
40 | #include "libavutil/fifo.h" |
41 | #include "libavutil/intreadwrite.h" | |
42 | #include "libavutil/dict.h" | |
43 | #include "libavutil/mathematics.h" | |
44 | #include "libavutil/pixdesc.h" | |
45 | #include "libavutil/avstring.h" | |
46 | #include "libavutil/libm.h" | |
64dca32c | 47 | #include "libavutil/imgutils.h" |
896bb0d7 | 48 | #include "libavutil/time.h" |
6291d7e4 AK |
49 | #include "libavformat/os_support.h" |
50 | ||
6291d7e4 | 51 | # include "libavfilter/avfilter.h" |
04a14d4d | 52 | # include "libavfilter/buffersrc.h" |
ac712309 | 53 | # include "libavfilter/buffersink.h" |
6291d7e4 AK |
54 | |
55 | #if HAVE_SYS_RESOURCE_H | |
3f65eff4 | 56 | #include <sys/time.h> |
6291d7e4 | 57 | #include <sys/types.h> |
6291d7e4 AK |
58 | #include <sys/resource.h> |
59 | #elif HAVE_GETPROCESSTIMES | |
60 | #include <windows.h> | |
61 | #endif | |
62 | #if HAVE_GETPROCESSMEMORYINFO | |
63 | #include <windows.h> | |
64 | #include <psapi.h> | |
65 | #endif | |
66 | ||
67 | #if HAVE_SYS_SELECT_H | |
68 | #include <sys/select.h> | |
69 | #endif | |
70 | ||
5db5169e AK |
71 | #if HAVE_PTHREADS |
72 | #include <pthread.h> | |
5db5169e AK |
73 | #endif |
74 | ||
6291d7e4 AK |
75 | #include <time.h> |
76 | ||
f5e66827 | 77 | #include "avconv.h" |
6291d7e4 AK |
78 | #include "cmdutils.h" |
79 | ||
80 | #include "libavutil/avassert.h" | |
81 | ||
82 | const char program_name[] = "avconv"; | |
83 | const int program_birth_year = 2000; | |
84 | ||
6291d7e4 | 85 | static FILE *vstats_file; |
6291d7e4 | 86 | |
6291d7e4 | 87 | static int nb_frames_drop = 0; |
6291d7e4 | 88 | |
6291d7e4 | 89 | |
3460dd8a | 90 | |
47b812e9 | 91 | #if HAVE_PTHREADS |
5db5169e AK |
92 | /* signal to input threads that they should exit; set by the main thread */ |
93 | static int transcoding_finished; | |
94 | #endif | |
95 | ||
6291d7e4 AK |
96 | #define DEFAULT_PASS_LOGFILENAME_PREFIX "av2pass" |
97 | ||
f5e66827 AK |
98 | InputStream **input_streams = NULL; |
99 | int nb_input_streams = 0; | |
100 | InputFile **input_files = NULL; | |
101 | int nb_input_files = 0; | |
6b779ccc | 102 | |
f5e66827 AK |
103 | OutputStream **output_streams = NULL; |
104 | int nb_output_streams = 0; | |
105 | OutputFile **output_files = NULL; | |
106 | int nb_output_files = 0; | |
6b779ccc | 107 | |
f5e66827 AK |
108 | FilterGraph **filtergraphs; |
109 | int nb_filtergraphs; | |
575ec4e1 | 110 | |
6291d7e4 AK |
111 | static void term_exit(void) |
112 | { | |
113 | av_log(NULL, AV_LOG_QUIET, ""); | |
114 | } | |
115 | ||
116 | static volatile int received_sigterm = 0; | |
117 | static volatile int received_nb_signals = 0; | |
118 | ||
119 | static void | |
120 | sigterm_handler(int sig) | |
121 | { | |
122 | received_sigterm = sig; | |
123 | received_nb_signals++; | |
124 | term_exit(); | |
125 | } | |
126 | ||
127 | static void term_init(void) | |
128 | { | |
7636c8c6 | 129 | signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */ |
6291d7e4 AK |
130 | signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */ |
131 | #ifdef SIGXCPU | |
132 | signal(SIGXCPU, sigterm_handler); | |
133 | #endif | |
134 | } | |
135 | ||
2abe947a | 136 | static int decode_interrupt_cb(void *ctx) |
6291d7e4 AK |
137 | { |
138 | return received_nb_signals > 1; | |
139 | } | |
140 | ||
f5e66827 | 141 | const AVIOInterruptCB int_cb = { decode_interrupt_cb, NULL }; |
2abe947a | 142 | |
636ced8e | 143 | static void avconv_cleanup(int ret) |
6291d7e4 | 144 | { |
560f7774 AK |
145 | int i, j; |
146 | ||
147 | for (i = 0; i < nb_filtergraphs; i++) { | |
73ed8558 AK |
148 | FilterGraph *fg = filtergraphs[i]; |
149 | avfilter_graph_free(&fg->graph); | |
150 | for (j = 0; j < fg->nb_inputs; j++) { | |
151 | av_freep(&fg->inputs[j]->name); | |
152 | av_freep(&fg->inputs[j]); | |
cf6c38c6 | 153 | } |
73ed8558 AK |
154 | av_freep(&fg->inputs); |
155 | for (j = 0; j < fg->nb_outputs; j++) { | |
156 | av_freep(&fg->outputs[j]->name); | |
157 | av_freep(&fg->outputs[j]); | |
cf6c38c6 | 158 | } |
73ed8558 AK |
159 | av_freep(&fg->outputs); |
160 | av_freep(&fg->graph_desc); | |
161 | ||
560f7774 AK |
162 | av_freep(&filtergraphs[i]); |
163 | } | |
164 | av_freep(&filtergraphs); | |
6291d7e4 AK |
165 | |
166 | /* close files */ | |
7636c8c6 | 167 | for (i = 0; i < nb_output_files; i++) { |
73ed8558 AK |
168 | OutputFile *of = output_files[i]; |
169 | AVFormatContext *s = of->ctx; | |
274e134e | 170 | if (s && s->oformat && !(s->oformat->flags & AVFMT_NOFILE) && s->pb) |
6291d7e4 AK |
171 | avio_close(s->pb); |
172 | avformat_free_context(s); | |
73ed8558 AK |
173 | av_dict_free(&of->opts); |
174 | ||
2e215267 | 175 | av_freep(&output_files[i]); |
6291d7e4 | 176 | } |
1135a071 | 177 | for (i = 0; i < nb_output_streams; i++) { |
73ed8558 AK |
178 | OutputStream *ost = output_streams[i]; |
179 | AVBitStreamFilterContext *bsfc = ost->bitstream_filters; | |
1135a071 JG |
180 | while (bsfc) { |
181 | AVBitStreamFilterContext *next = bsfc->next; | |
182 | av_bitstream_filter_close(bsfc); | |
183 | bsfc = next; | |
184 | } | |
73ed8558 AK |
185 | ost->bitstream_filters = NULL; |
186 | av_frame_free(&ost->filtered_frame); | |
187 | ||
188 | av_parser_close(ost->parser); | |
ac646076 | 189 | |
73ed8558 AK |
190 | av_freep(&ost->forced_keyframes); |
191 | av_freep(&ost->avfilter); | |
192 | av_freep(&ost->logfile_prefix); | |
c872d310 | 193 | |
38313626 AK |
194 | avcodec_free_context(&ost->enc_ctx); |
195 | ||
2e215267 | 196 | av_freep(&output_streams[i]); |
1135a071 | 197 | } |
7636c8c6 | 198 | for (i = 0; i < nb_input_files; i++) { |
2e215267 AK |
199 | avformat_close_input(&input_files[i]->ctx); |
200 | av_freep(&input_files[i]); | |
6291d7e4 | 201 | } |
9179f27c | 202 | for (i = 0; i < nb_input_streams; i++) { |
73ed8558 AK |
203 | InputStream *ist = input_streams[i]; |
204 | ||
205 | av_frame_free(&ist->decoded_frame); | |
206 | av_frame_free(&ist->filter_frame); | |
f3a6ad22 | 207 | av_dict_free(&ist->decoder_opts); |
73ed8558 AK |
208 | av_freep(&ist->filters); |
209 | av_freep(&ist->hwaccel_device); | |
210 | ||
41776ba9 AK |
211 | avcodec_free_context(&ist->dec_ctx); |
212 | ||
2e215267 | 213 | av_freep(&input_streams[i]); |
9179f27c | 214 | } |
6291d7e4 | 215 | |
6291d7e4 AK |
216 | if (vstats_file) |
217 | fclose(vstats_file); | |
218 | av_free(vstats_filename); | |
219 | ||
6291d7e4 AK |
220 | av_freep(&input_streams); |
221 | av_freep(&input_files); | |
4288e031 | 222 | av_freep(&output_streams); |
af70aa45 | 223 | av_freep(&output_files); |
6291d7e4 | 224 | |
6291d7e4 | 225 | uninit_opts(); |
6291d7e4 | 226 | |
776f2bb9 | 227 | avformat_network_deinit(); |
6291d7e4 AK |
228 | |
229 | if (received_sigterm) { | |
e3245b26 AK |
230 | av_log(NULL, AV_LOG_INFO, "Received signal %d: terminating.\n", |
231 | (int) received_sigterm); | |
6291d7e4 AK |
232 | exit (255); |
233 | } | |
6291d7e4 AK |
234 | } |
235 | ||
f5e66827 | 236 | void assert_avoptions(AVDictionary *m) |
6291d7e4 AK |
237 | { |
238 | AVDictionaryEntry *t; | |
239 | if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) { | |
f24facd3 | 240 | av_log(NULL, AV_LOG_FATAL, "Option %s not found.\n", t->key); |
636ced8e | 241 | exit_program(1); |
6291d7e4 AK |
242 | } |
243 | } | |
244 | ||
c854102d | 245 | static void abort_codec_experimental(AVCodec *c, int encoder) |
6291d7e4 AK |
246 | { |
247 | const char *codec_string = encoder ? "encoder" : "decoder"; | |
248 | AVCodec *codec; | |
c854102d NC |
249 | av_log(NULL, AV_LOG_FATAL, "%s '%s' is experimental and might produce bad " |
250 | "results.\nAdd '-strict experimental' if you want to use it.\n", | |
251 | codec_string, c->name); | |
252 | codec = encoder ? avcodec_find_encoder(c->id) : avcodec_find_decoder(c->id); | |
253 | if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL)) | |
254 | av_log(NULL, AV_LOG_FATAL, "Or use the non experimental %s '%s'.\n", | |
255 | codec_string, codec->name); | |
636ced8e | 256 | exit_program(1); |
6291d7e4 AK |
257 | } |
258 | ||
c1ef30a6 | 259 | /* |
6291d7e4 AK |
260 | * Update the requested input sample format based on the output sample format. |
261 | * This is currently only used to request float output from decoders which | |
262 | * support multiple sample formats, one of which is AV_SAMPLE_FMT_FLT. | |
263 | * Ideally this will be removed in the future when decoders do not do format | |
264 | * conversion and only output in their native format. | |
265 | */ | |
266 | static void update_sample_fmt(AVCodecContext *dec, AVCodec *dec_codec, | |
267 | AVCodecContext *enc) | |
268 | { | |
269 | /* if sample formats match or a decoder sample format has already been | |
270 | requested, just return */ | |
271 | if (enc->sample_fmt == dec->sample_fmt || | |
272 | dec->request_sample_fmt > AV_SAMPLE_FMT_NONE) | |
273 | return; | |
274 | ||
275 | /* if decoder supports more than one output format */ | |
276 | if (dec_codec && dec_codec->sample_fmts && | |
277 | dec_codec->sample_fmts[0] != AV_SAMPLE_FMT_NONE && | |
278 | dec_codec->sample_fmts[1] != AV_SAMPLE_FMT_NONE) { | |
279 | const enum AVSampleFormat *p; | |
fd41cb43 JR |
280 | int min_dec = INT_MAX, min_inc = INT_MAX; |
281 | enum AVSampleFormat dec_fmt = AV_SAMPLE_FMT_NONE; | |
282 | enum AVSampleFormat inc_fmt = AV_SAMPLE_FMT_NONE; | |
6291d7e4 AK |
283 | |
284 | /* find a matching sample format in the encoder */ | |
285 | for (p = dec_codec->sample_fmts; *p != AV_SAMPLE_FMT_NONE; p++) { | |
286 | if (*p == enc->sample_fmt) { | |
287 | dec->request_sample_fmt = *p; | |
288 | return; | |
fd41cb43 JR |
289 | } else { |
290 | enum AVSampleFormat dfmt = av_get_packed_sample_fmt(*p); | |
291 | enum AVSampleFormat efmt = av_get_packed_sample_fmt(enc->sample_fmt); | |
292 | int fmt_diff = 32 * abs(dfmt - efmt); | |
293 | if (av_sample_fmt_is_planar(*p) != | |
294 | av_sample_fmt_is_planar(enc->sample_fmt)) | |
295 | fmt_diff++; | |
296 | if (dfmt == efmt) { | |
297 | min_inc = fmt_diff; | |
298 | inc_fmt = *p; | |
299 | } else if (dfmt > efmt) { | |
300 | if (fmt_diff < min_inc) { | |
301 | min_inc = fmt_diff; | |
302 | inc_fmt = *p; | |
303 | } | |
304 | } else { | |
305 | if (fmt_diff < min_dec) { | |
306 | min_dec = fmt_diff; | |
307 | dec_fmt = *p; | |
308 | } | |
309 | } | |
310 | } | |
6291d7e4 AK |
311 | } |
312 | ||
313 | /* if none match, provide the one that matches quality closest */ | |
fd41cb43 | 314 | dec->request_sample_fmt = min_inc != INT_MAX ? inc_fmt : dec_fmt; |
6291d7e4 AK |
315 | } |
316 | } | |
317 | ||
f15f02c2 | 318 | static void write_frame(AVFormatContext *s, AVPacket *pkt, OutputStream *ost) |
7636c8c6 | 319 | { |
f15f02c2 | 320 | AVBitStreamFilterContext *bsfc = ost->bitstream_filters; |
38313626 | 321 | AVCodecContext *avctx = ost->enc_ctx; |
6291d7e4 AK |
322 | int ret; |
323 | ||
99932847 AK |
324 | /* |
325 | * Audio encoders may split the packets -- #frames in != #packets out. | |
326 | * But there is no reordering, so we can limit the number of output packets | |
327 | * by simply dropping them here. | |
328 | * Counting encoded video frames needs to be done separately because of | |
329 | * reordering, see do_video_out() | |
330 | */ | |
331 | if (!(avctx->codec_type == AVMEDIA_TYPE_VIDEO && avctx->codec)) { | |
c9594fe0 JR |
332 | if (ost->frame_number >= ost->max_frames) { |
333 | av_free_packet(pkt); | |
99932847 | 334 | return; |
c9594fe0 | 335 | } |
99932847 AK |
336 | ost->frame_number++; |
337 | } | |
338 | ||
7636c8c6 AD |
339 | while (bsfc) { |
340 | AVPacket new_pkt = *pkt; | |
341 | int a = av_bitstream_filter_filter(bsfc, avctx, NULL, | |
342 | &new_pkt.data, &new_pkt.size, | |
343 | pkt->data, pkt->size, | |
344 | pkt->flags & AV_PKT_FLAG_KEY); | |
345 | if (a > 0) { | |
6291d7e4 | 346 | av_free_packet(pkt); |
9b2dc295 AK |
347 | new_pkt.buf = av_buffer_create(new_pkt.data, new_pkt.size, |
348 | av_buffer_default_free, NULL, 0); | |
349 | if (!new_pkt.buf) | |
636ced8e | 350 | exit_program(1); |
7636c8c6 | 351 | } else if (a < 0) { |
e3245b26 AK |
352 | av_log(NULL, AV_LOG_ERROR, "%s failed for stream %d, codec %s", |
353 | bsfc->filter->name, pkt->stream_index, | |
354 | avctx->codec ? avctx->codec->name : "copy"); | |
6291d7e4 AK |
355 | print_error("", a); |
356 | if (exit_on_error) | |
636ced8e | 357 | exit_program(1); |
6291d7e4 | 358 | } |
7636c8c6 | 359 | *pkt = new_pkt; |
6291d7e4 | 360 | |
7636c8c6 | 361 | bsfc = bsfc->next; |
6291d7e4 AK |
362 | } |
363 | ||
76d23f40 AK |
364 | if (!(s->oformat->flags & AVFMT_NOTIMESTAMPS) && |
365 | ost->last_mux_dts != AV_NOPTS_VALUE && | |
366 | pkt->dts < ost->last_mux_dts + !(s->oformat->flags & AVFMT_TS_NONSTRICT)) { | |
367 | av_log(NULL, AV_LOG_WARNING, "Non-monotonous DTS in output stream " | |
368 | "%d:%d; previous: %"PRId64", current: %"PRId64"; ", | |
369 | ost->file_index, ost->st->index, ost->last_mux_dts, pkt->dts); | |
370 | if (exit_on_error) { | |
371 | av_log(NULL, AV_LOG_FATAL, "aborting.\n"); | |
636ced8e | 372 | exit_program(1); |
76d23f40 AK |
373 | } |
374 | av_log(NULL, AV_LOG_WARNING, "changing to %"PRId64". This may result " | |
375 | "in incorrect timestamps in the output file.\n", | |
376 | ost->last_mux_dts + 1); | |
377 | pkt->dts = ost->last_mux_dts + 1; | |
378 | if (pkt->pts != AV_NOPTS_VALUE) | |
379 | pkt->pts = FFMAX(pkt->pts, pkt->dts); | |
380 | } | |
381 | ost->last_mux_dts = pkt->dts; | |
382 | ||
baeb59d8 | 383 | ost->data_size += pkt->size; |
47543450 | 384 | ost->packets_written++; |
baeb59d8 | 385 | |
61a09968 | 386 | pkt->stream_index = ost->index; |
7636c8c6 AD |
387 | ret = av_interleaved_write_frame(s, pkt); |
388 | if (ret < 0) { | |
6291d7e4 | 389 | print_error("av_interleaved_write_frame()", ret); |
636ced8e | 390 | exit_program(1); |
6291d7e4 AK |
391 | } |
392 | } | |
393 | ||
1270e12e AK |
394 | static int check_recording_time(OutputStream *ost) |
395 | { | |
2e215267 | 396 | OutputFile *of = output_files[ost->file_index]; |
1270e12e AK |
397 | |
398 | if (of->recording_time != INT64_MAX && | |
38313626 | 399 | av_compare_ts(ost->sync_opts - ost->first_pts, ost->enc_ctx->time_base, of->recording_time, |
1270e12e | 400 | AV_TIME_BASE_Q) >= 0) { |
57d24225 | 401 | ost->finished = 1; |
1270e12e AK |
402 | return 0; |
403 | } | |
404 | return 1; | |
405 | } | |
406 | ||
369cb092 AK |
407 | static void do_audio_out(AVFormatContext *s, OutputStream *ost, |
408 | AVFrame *frame) | |
ee458cb1 | 409 | { |
38313626 | 410 | AVCodecContext *enc = ost->enc_ctx; |
ee458cb1 | 411 | AVPacket pkt; |
369cb092 | 412 | int got_packet = 0; |
ee458cb1 JR |
413 | |
414 | av_init_packet(&pkt); | |
415 | pkt.data = NULL; | |
416 | pkt.size = 0; | |
417 | ||
369cb092 | 418 | if (frame->pts == AV_NOPTS_VALUE || audio_sync_method < 0) |
9b9fc9ba | 419 | frame->pts = ost->sync_opts; |
369cb092 | 420 | ost->sync_opts = frame->pts + frame->nb_samples; |
ee458cb1 | 421 | |
47543450 AK |
422 | ost->samples_encoded += frame->nb_samples; |
423 | ost->frames_encoded++; | |
424 | ||
ee458cb1 JR |
425 | if (avcodec_encode_audio2(enc, &pkt, frame, &got_packet) < 0) { |
426 | av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n"); | |
636ced8e | 427 | exit_program(1); |
ee458cb1 JR |
428 | } |
429 | ||
430 | if (got_packet) { | |
ee458cb1 JR |
431 | if (pkt.pts != AV_NOPTS_VALUE) |
432 | pkt.pts = av_rescale_q(pkt.pts, enc->time_base, ost->st->time_base); | |
a75bc764 JR |
433 | if (pkt.dts != AV_NOPTS_VALUE) |
434 | pkt.dts = av_rescale_q(pkt.dts, enc->time_base, ost->st->time_base); | |
ee458cb1 JR |
435 | if (pkt.duration > 0) |
436 | pkt.duration = av_rescale_q(pkt.duration, enc->time_base, ost->st->time_base); | |
437 | ||
438 | write_frame(s, &pkt, ost); | |
ee458cb1 | 439 | } |
6291d7e4 AK |
440 | } |
441 | ||
6291d7e4 AK |
442 | static void do_subtitle_out(AVFormatContext *s, |
443 | OutputStream *ost, | |
444 | InputStream *ist, | |
445 | AVSubtitle *sub, | |
446 | int64_t pts) | |
447 | { | |
448 | static uint8_t *subtitle_out = NULL; | |
449 | int subtitle_out_max_size = 1024 * 1024; | |
450 | int subtitle_out_size, nb, i; | |
451 | AVCodecContext *enc; | |
452 | AVPacket pkt; | |
453 | ||
454 | if (pts == AV_NOPTS_VALUE) { | |
e3245b26 | 455 | av_log(NULL, AV_LOG_ERROR, "Subtitle packets must have a pts\n"); |
6291d7e4 | 456 | if (exit_on_error) |
636ced8e | 457 | exit_program(1); |
6291d7e4 AK |
458 | return; |
459 | } | |
460 | ||
38313626 | 461 | enc = ost->enc_ctx; |
6291d7e4 AK |
462 | |
463 | if (!subtitle_out) { | |
464 | subtitle_out = av_malloc(subtitle_out_max_size); | |
465 | } | |
466 | ||
467 | /* Note: DVB subtitle need one packet to draw them and one other | |
468 | packet to clear them */ | |
469 | /* XXX: signal it in the codec context ? */ | |
36ef5369 | 470 | if (enc->codec_id == AV_CODEC_ID_DVB_SUBTITLE) |
6291d7e4 AK |
471 | nb = 2; |
472 | else | |
473 | nb = 1; | |
474 | ||
7636c8c6 | 475 | for (i = 0; i < nb; i++) { |
1270e12e AK |
476 | ost->sync_opts = av_rescale_q(pts, ist->st->time_base, enc->time_base); |
477 | if (!check_recording_time(ost)) | |
478 | return; | |
479 | ||
6291d7e4 AK |
480 | sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q); |
481 | // start_display_time is required to be 0 | |
7636c8c6 AD |
482 | sub->pts += av_rescale_q(sub->start_display_time, (AVRational){ 1, 1000 }, AV_TIME_BASE_Q); |
483 | sub->end_display_time -= sub->start_display_time; | |
6291d7e4 | 484 | sub->start_display_time = 0; |
47543450 AK |
485 | |
486 | ost->frames_encoded++; | |
487 | ||
6291d7e4 AK |
488 | subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out, |
489 | subtitle_out_max_size, sub); | |
490 | if (subtitle_out_size < 0) { | |
e3245b26 | 491 | av_log(NULL, AV_LOG_FATAL, "Subtitle encoding failed\n"); |
636ced8e | 492 | exit_program(1); |
6291d7e4 AK |
493 | } |
494 | ||
495 | av_init_packet(&pkt); | |
6291d7e4 AK |
496 | pkt.data = subtitle_out; |
497 | pkt.size = subtitle_out_size; | |
7636c8c6 | 498 | pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base); |
36ef5369 | 499 | if (enc->codec_id == AV_CODEC_ID_DVB_SUBTITLE) { |
6291d7e4 AK |
500 | /* XXX: the pts correction is handled here. Maybe handling |
501 | it in the codec would be better */ | |
502 | if (i == 0) | |
503 | pkt.pts += 90 * sub->start_display_time; | |
504 | else | |
505 | pkt.pts += 90 * sub->end_display_time; | |
506 | } | |
f15f02c2 | 507 | write_frame(s, &pkt, ost); |
6291d7e4 AK |
508 | } |
509 | } | |
510 | ||
87ef060c AC |
511 | static void do_video_out(AVFormatContext *s, |
512 | OutputStream *ost, | |
87ef060c | 513 | AVFrame *in_picture, |
fb722a90 | 514 | int *frame_size) |
87ef060c | 515 | { |
74b961db AK |
516 | int ret, format_video_sync; |
517 | AVPacket pkt; | |
38313626 | 518 | AVCodecContext *enc = ost->enc_ctx; |
87ef060c AC |
519 | |
520 | *frame_size = 0; | |
521 | ||
553735f5 | 522 | format_video_sync = video_sync_method; |
e8c04f62 AK |
523 | if (format_video_sync == VSYNC_AUTO) |
524 | format_video_sync = (s->oformat->flags & AVFMT_NOTIMESTAMPS) ? VSYNC_PASSTHROUGH : | |
525 | (s->oformat->flags & AVFMT_VARIABLE_FPS) ? VSYNC_VFR : VSYNC_CFR; | |
74b961db AK |
526 | if (format_video_sync != VSYNC_PASSTHROUGH && |
527 | ost->frame_number && | |
528 | in_picture->pts != AV_NOPTS_VALUE && | |
529 | in_picture->pts < ost->sync_opts) { | |
d43040e2 | 530 | nb_frames_drop++; |
aa499568 VG |
531 | av_log(NULL, AV_LOG_WARNING, |
532 | "*** dropping frame %d from stream %d at ts %"PRId64"\n", | |
533 | ost->frame_number, ost->st->index, in_picture->pts); | |
87ef060c | 534 | return; |
d43040e2 | 535 | } |
87ef060c | 536 | |
74b961db AK |
537 | if (in_picture->pts == AV_NOPTS_VALUE) |
538 | in_picture->pts = ost->sync_opts; | |
539 | ost->sync_opts = in_picture->pts; | |
540 | ||
541 | ||
1270e12e | 542 | if (!ost->frame_number) |
74b961db | 543 | ost->first_pts = in_picture->pts; |
1270e12e | 544 | |
39885a4b AK |
545 | av_init_packet(&pkt); |
546 | pkt.data = NULL; | |
547 | pkt.size = 0; | |
6291d7e4 | 548 | |
a83c0da5 | 549 | if (ost->frame_number >= ost->max_frames) |
39885a4b | 550 | return; |
1270e12e | 551 | |
39885a4b | 552 | if (s->oformat->flags & AVFMT_RAWPICTURE && |
36ef5369 | 553 | enc->codec->id == AV_CODEC_ID_RAWVIDEO) { |
39885a4b AK |
554 | /* raw pictures are written as AVPicture structure to |
555 | avoid any copies. We support temporarily the older | |
556 | method. */ | |
557 | enc->coded_frame->interlaced_frame = in_picture->interlaced_frame; | |
558 | enc->coded_frame->top_field_first = in_picture->top_field_first; | |
559 | pkt.data = (uint8_t *)in_picture; | |
560 | pkt.size = sizeof(AVPicture); | |
561 | pkt.pts = av_rescale_q(in_picture->pts, enc->time_base, ost->st->time_base); | |
562 | pkt.flags |= AV_PKT_FLAG_KEY; | |
6291d7e4 | 563 | |
39885a4b AK |
564 | write_frame(s, &pkt, ost); |
565 | } else { | |
566 | int got_packet; | |
6291d7e4 | 567 | |
38313626 | 568 | if (enc->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME) && |
9b2dc295 AK |
569 | ost->top_field_first >= 0) |
570 | in_picture->top_field_first = !!ost->top_field_first; | |
571 | ||
38313626 | 572 | in_picture->quality = enc->global_quality; |
39885a4b | 573 | if (!enc->me_threshold) |
9b2dc295 | 574 | in_picture->pict_type = 0; |
39885a4b | 575 | if (ost->forced_kf_index < ost->forced_kf_count && |
9b2dc295 AK |
576 | in_picture->pts >= ost->forced_kf_pts[ost->forced_kf_index]) { |
577 | in_picture->pict_type = AV_PICTURE_TYPE_I; | |
39885a4b AK |
578 | ost->forced_kf_index++; |
579 | } | |
47543450 AK |
580 | |
581 | ost->frames_encoded++; | |
582 | ||
9b2dc295 | 583 | ret = avcodec_encode_video2(enc, &pkt, in_picture, &got_packet); |
39885a4b AK |
584 | if (ret < 0) { |
585 | av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n"); | |
636ced8e | 586 | exit_program(1); |
39885a4b | 587 | } |
6291d7e4 | 588 | |
39885a4b AK |
589 | if (got_packet) { |
590 | if (pkt.pts != AV_NOPTS_VALUE) | |
591 | pkt.pts = av_rescale_q(pkt.pts, enc->time_base, ost->st->time_base); | |
592 | if (pkt.dts != AV_NOPTS_VALUE) | |
593 | pkt.dts = av_rescale_q(pkt.dts, enc->time_base, ost->st->time_base); | |
6291d7e4 | 594 | |
39885a4b AK |
595 | write_frame(s, &pkt, ost); |
596 | *frame_size = pkt.size; | |
324fbadf | 597 | |
39885a4b AK |
598 | /* if two pass, output log */ |
599 | if (ost->logfile && enc->stats_out) { | |
600 | fprintf(ost->logfile, "%s", enc->stats_out); | |
6291d7e4 AK |
601 | } |
602 | } | |
39885a4b AK |
603 | } |
604 | ost->sync_opts++; | |
605 | /* | |
606 | * For video, number of frames in == number of packets out. | |
607 | * But there may be reordering, so we can't throw away frames on encoder | |
608 | * flush, we need to limit them here, before they go into encoder. | |
609 | */ | |
610 | ost->frame_number++; | |
6291d7e4 AK |
611 | } |
612 | ||
7636c8c6 AD |
613 | static double psnr(double d) |
614 | { | |
615 | return -10.0 * log(d) / log(10.0); | |
6291d7e4 AK |
616 | } |
617 | ||
70478746 | 618 | static void do_video_stats(OutputStream *ost, int frame_size) |
6291d7e4 AK |
619 | { |
620 | AVCodecContext *enc; | |
621 | int frame_number; | |
622 | double ti1, bitrate, avg_bitrate; | |
623 | ||
624 | /* this is executed just the first time do_video_stats is called */ | |
625 | if (!vstats_file) { | |
626 | vstats_file = fopen(vstats_filename, "w"); | |
627 | if (!vstats_file) { | |
628 | perror("fopen"); | |
636ced8e | 629 | exit_program(1); |
6291d7e4 AK |
630 | } |
631 | } | |
632 | ||
38313626 | 633 | enc = ost->enc_ctx; |
6291d7e4 AK |
634 | if (enc->codec_type == AVMEDIA_TYPE_VIDEO) { |
635 | frame_number = ost->frame_number; | |
7636c8c6 | 636 | fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality / (float)FF_QP2LAMBDA); |
6291d7e4 | 637 | if (enc->flags&CODEC_FLAG_PSNR) |
7636c8c6 | 638 | fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0] / (enc->width * enc->height * 255.0 * 255.0))); |
6291d7e4 AK |
639 | |
640 | fprintf(vstats_file,"f_size= %6d ", frame_size); | |
641 | /* compute pts value */ | |
642 | ti1 = ost->sync_opts * av_q2d(enc->time_base); | |
643 | if (ti1 < 0.01) | |
644 | ti1 = 0.01; | |
645 | ||
7636c8c6 | 646 | bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0; |
baeb59d8 | 647 | avg_bitrate = (double)(ost->data_size * 8) / ti1 / 1000.0; |
6291d7e4 | 648 | fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ", |
baeb59d8 | 649 | (double)ost->data_size / 1024, ti1, bitrate, avg_bitrate); |
6291d7e4 AK |
650 | fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type)); |
651 | } | |
652 | } | |
653 | ||
c1ef30a6 | 654 | /* |
a4f50110 AK |
655 | * Read one frame for lavfi output for ost and encode it. |
656 | */ | |
657 | static int poll_filter(OutputStream *ost) | |
560f7774 | 658 | { |
a4f50110 | 659 | OutputFile *of = output_files[ost->file_index]; |
560f7774 | 660 | AVFrame *filtered_frame = NULL; |
a4f50110 AK |
661 | int frame_size, ret; |
662 | ||
5b9c3b45 | 663 | if (!ost->filtered_frame && !(ost->filtered_frame = av_frame_alloc())) { |
a4f50110 | 664 | return AVERROR(ENOMEM); |
674fa491 | 665 | } |
a4f50110 AK |
666 | filtered_frame = ost->filtered_frame; |
667 | ||
668 | if (ost->enc->type == AVMEDIA_TYPE_AUDIO && | |
669 | !(ost->enc->capabilities & CODEC_CAP_VARIABLE_FRAME_SIZE)) | |
9b2dc295 | 670 | ret = av_buffersink_get_samples(ost->filter->filter, filtered_frame, |
38313626 | 671 | ost->enc_ctx->frame_size); |
a4f50110 | 672 | else |
9b2dc295 | 673 | ret = av_buffersink_get_frame(ost->filter->filter, filtered_frame); |
369cb092 | 674 | |
a4f50110 AK |
675 | if (ret < 0) |
676 | return ret; | |
560f7774 | 677 | |
9b2dc295 | 678 | if (filtered_frame->pts != AV_NOPTS_VALUE) { |
56ee3f9d | 679 | int64_t start_time = (of->start_time == AV_NOPTS_VALUE) ? 0 : of->start_time; |
9b2dc295 | 680 | filtered_frame->pts = av_rescale_q(filtered_frame->pts, |
a4f50110 | 681 | ost->filter->filter->inputs[0]->time_base, |
38313626 | 682 | ost->enc_ctx->time_base) - |
56ee3f9d | 683 | av_rescale_q(start_time, |
a4f50110 | 684 | AV_TIME_BASE_Q, |
38313626 | 685 | ost->enc_ctx->time_base); |
560f7774 | 686 | } |
a4f50110 AK |
687 | |
688 | switch (ost->filter->filter->inputs[0]->type) { | |
689 | case AVMEDIA_TYPE_VIDEO: | |
690 | if (!ost->frame_aspect_ratio) | |
38313626 | 691 | ost->enc_ctx->sample_aspect_ratio = filtered_frame->sample_aspect_ratio; |
a4f50110 | 692 | |
fb722a90 | 693 | do_video_out(of->ctx, ost, filtered_frame, &frame_size); |
a4f50110 | 694 | if (vstats_filename && frame_size) |
70478746 | 695 | do_video_stats(ost, frame_size); |
a4f50110 AK |
696 | break; |
697 | case AVMEDIA_TYPE_AUDIO: | |
698 | do_audio_out(of->ctx, ost, filtered_frame); | |
699 | break; | |
700 | default: | |
701 | // TODO support subtitle filters | |
702 | av_assert0(0); | |
703 | } | |
704 | ||
9b2dc295 | 705 | av_frame_unref(filtered_frame); |
a4f50110 | 706 | |
560f7774 AK |
707 | return 0; |
708 | } | |
709 | ||
c1ef30a6 | 710 | /* |
a4f50110 AK |
711 | * Read as many frames from possible from lavfi and encode them. |
712 | * | |
713 | * Always read from the active stream with the lowest timestamp. If no frames | |
714 | * are available for it then return EAGAIN and wait for more input. This way we | |
715 | * can use lavfi sources that generate unlimited amount of frames without memory | |
716 | * usage exploding. | |
717 | */ | |
718 | static int poll_filters(void) | |
719 | { | |
3c0df905 | 720 | int i, j, ret = 0; |
a4f50110 AK |
721 | |
722 | while (ret >= 0 && !received_sigterm) { | |
723 | OutputStream *ost = NULL; | |
724 | int64_t min_pts = INT64_MAX; | |
725 | ||
726 | /* choose output stream with the lowest timestamp */ | |
727 | for (i = 0; i < nb_output_streams; i++) { | |
728 | int64_t pts = output_streams[i]->sync_opts; | |
729 | ||
57d24225 | 730 | if (!output_streams[i]->filter || output_streams[i]->finished) |
a4f50110 AK |
731 | continue; |
732 | ||
38313626 | 733 | pts = av_rescale_q(pts, output_streams[i]->enc_ctx->time_base, |
a4f50110 AK |
734 | AV_TIME_BASE_Q); |
735 | if (pts < min_pts) { | |
736 | min_pts = pts; | |
737 | ost = output_streams[i]; | |
738 | } | |
739 | } | |
740 | ||
741 | if (!ost) | |
742 | break; | |
743 | ||
744 | ret = poll_filter(ost); | |
745 | ||
746 | if (ret == AVERROR_EOF) { | |
3c0df905 AK |
747 | OutputFile *of = output_files[ost->file_index]; |
748 | ||
57d24225 | 749 | ost->finished = 1; |
a4f50110 | 750 | |
3c0df905 AK |
751 | if (of->shortest) { |
752 | for (j = 0; j < of->ctx->nb_streams; j++) | |
753 | output_streams[of->ost_index + j]->finished = 1; | |
754 | } | |
a4f50110 AK |
755 | |
756 | ret = 0; | |
757 | } else if (ret == AVERROR(EAGAIN)) | |
758 | return 0; | |
759 | } | |
760 | ||
761 | return ret; | |
762 | } | |
763 | ||
a220b07b AK |
764 | static void print_final_stats(int64_t total_size) |
765 | { | |
766 | uint64_t video_size = 0, audio_size = 0, extra_size = 0, other_size = 0; | |
767 | uint64_t data_size = 0; | |
768 | float percent = -1.0; | |
47543450 | 769 | int i, j; |
a220b07b AK |
770 | |
771 | for (i = 0; i < nb_output_streams; i++) { | |
772 | OutputStream *ost = output_streams[i]; | |
38313626 | 773 | switch (ost->enc_ctx->codec_type) { |
a220b07b AK |
774 | case AVMEDIA_TYPE_VIDEO: video_size += ost->data_size; break; |
775 | case AVMEDIA_TYPE_AUDIO: audio_size += ost->data_size; break; | |
776 | default: other_size += ost->data_size; break; | |
777 | } | |
38313626 | 778 | extra_size += ost->enc_ctx->extradata_size; |
a220b07b AK |
779 | data_size += ost->data_size; |
780 | } | |
781 | ||
782 | if (data_size && total_size >= data_size) | |
783 | percent = 100.0 * (total_size - data_size) / data_size; | |
784 | ||
785 | av_log(NULL, AV_LOG_INFO, "\n"); | |
786 | av_log(NULL, AV_LOG_INFO, "video:%1.0fkB audio:%1.0fkB other streams:%1.0fkB global headers:%1.0fkB muxing overhead: ", | |
787 | video_size / 1024.0, | |
788 | audio_size / 1024.0, | |
789 | other_size / 1024.0, | |
790 | extra_size / 1024.0); | |
791 | if (percent >= 0.0) | |
792 | av_log(NULL, AV_LOG_INFO, "%f%%", percent); | |
793 | else | |
794 | av_log(NULL, AV_LOG_INFO, "unknown"); | |
795 | av_log(NULL, AV_LOG_INFO, "\n"); | |
47543450 AK |
796 | |
797 | /* print verbose per-stream stats */ | |
798 | for (i = 0; i < nb_input_files; i++) { | |
799 | InputFile *f = input_files[i]; | |
800 | uint64_t total_packets = 0, total_size = 0; | |
801 | ||
802 | av_log(NULL, AV_LOG_VERBOSE, "Input file #%d (%s):\n", | |
803 | i, f->ctx->filename); | |
804 | ||
805 | for (j = 0; j < f->nb_streams; j++) { | |
806 | InputStream *ist = input_streams[f->ist_index + j]; | |
41776ba9 | 807 | enum AVMediaType type = ist->dec_ctx->codec_type; |
47543450 AK |
808 | |
809 | total_size += ist->data_size; | |
810 | total_packets += ist->nb_packets; | |
811 | ||
812 | av_log(NULL, AV_LOG_VERBOSE, " Input stream #%d:%d (%s): ", | |
813 | i, j, media_type_string(type)); | |
814 | av_log(NULL, AV_LOG_VERBOSE, "%"PRIu64" packets read (%"PRIu64" bytes); ", | |
815 | ist->nb_packets, ist->data_size); | |
816 | ||
817 | if (ist->decoding_needed) { | |
818 | av_log(NULL, AV_LOG_VERBOSE, "%"PRIu64" frames decoded", | |
819 | ist->frames_decoded); | |
820 | if (type == AVMEDIA_TYPE_AUDIO) | |
821 | av_log(NULL, AV_LOG_VERBOSE, " (%"PRIu64" samples)", ist->samples_decoded); | |
822 | av_log(NULL, AV_LOG_VERBOSE, "; "); | |
823 | } | |
824 | ||
825 | av_log(NULL, AV_LOG_VERBOSE, "\n"); | |
826 | } | |
827 | ||
828 | av_log(NULL, AV_LOG_VERBOSE, " Total: %"PRIu64" packets (%"PRIu64" bytes) demuxed\n", | |
829 | total_packets, total_size); | |
830 | } | |
831 | ||
832 | for (i = 0; i < nb_output_files; i++) { | |
833 | OutputFile *of = output_files[i]; | |
834 | uint64_t total_packets = 0, total_size = 0; | |
835 | ||
836 | av_log(NULL, AV_LOG_VERBOSE, "Output file #%d (%s):\n", | |
837 | i, of->ctx->filename); | |
838 | ||
839 | for (j = 0; j < of->ctx->nb_streams; j++) { | |
840 | OutputStream *ost = output_streams[of->ost_index + j]; | |
38313626 | 841 | enum AVMediaType type = ost->enc_ctx->codec_type; |
47543450 AK |
842 | |
843 | total_size += ost->data_size; | |
844 | total_packets += ost->packets_written; | |
845 | ||
846 | av_log(NULL, AV_LOG_VERBOSE, " Output stream #%d:%d (%s): ", | |
847 | i, j, media_type_string(type)); | |
848 | if (ost->encoding_needed) { | |
849 | av_log(NULL, AV_LOG_VERBOSE, "%"PRIu64" frames encoded", | |
850 | ost->frames_encoded); | |
851 | if (type == AVMEDIA_TYPE_AUDIO) | |
852 | av_log(NULL, AV_LOG_VERBOSE, " (%"PRIu64" samples)", ost->samples_encoded); | |
853 | av_log(NULL, AV_LOG_VERBOSE, "; "); | |
854 | } | |
855 | ||
856 | av_log(NULL, AV_LOG_VERBOSE, "%"PRIu64" packets muxed (%"PRIu64" bytes); ", | |
857 | ost->packets_written, ost->data_size); | |
858 | ||
859 | av_log(NULL, AV_LOG_VERBOSE, "\n"); | |
860 | } | |
861 | ||
862 | av_log(NULL, AV_LOG_VERBOSE, " Total: %"PRIu64" packets (%"PRIu64" bytes) muxed\n", | |
863 | total_packets, total_size); | |
864 | } | |
a220b07b AK |
865 | } |
866 | ||
ea9367e9 | 867 | static void print_report(int is_last_report, int64_t timer_start) |
6291d7e4 AK |
868 | { |
869 | char buf[1024]; | |
870 | OutputStream *ost; | |
871 | AVFormatContext *oc; | |
872 | int64_t total_size; | |
873 | AVCodecContext *enc; | |
874 | int frame_number, vid, i; | |
875 | double bitrate, ti1, pts; | |
876 | static int64_t last_time = -1; | |
877 | static int qp_histogram[52]; | |
878 | ||
3460dd8a AK |
879 | if (!print_stats && !is_last_report) |
880 | return; | |
881 | ||
6291d7e4 AK |
882 | if (!is_last_report) { |
883 | int64_t cur_time; | |
884 | /* display the report every 0.5 seconds */ | |
885 | cur_time = av_gettime(); | |
886 | if (last_time == -1) { | |
887 | last_time = cur_time; | |
888 | return; | |
889 | } | |
890 | if ((cur_time - last_time) < 500000) | |
891 | return; | |
892 | last_time = cur_time; | |
893 | } | |
894 | ||
895 | ||
2e215267 | 896 | oc = output_files[0]->ctx; |
6291d7e4 AK |
897 | |
898 | total_size = avio_size(oc->pb); | |
1b891d17 | 899 | if (total_size <= 0) // FIXME improve avio_size() so it works with non seekable output too |
7636c8c6 | 900 | total_size = avio_tell(oc->pb); |
1b891d17 JG |
901 | if (total_size < 0) { |
902 | char errbuf[128]; | |
903 | av_strerror(total_size, errbuf, sizeof(errbuf)); | |
904 | av_log(NULL, AV_LOG_VERBOSE, "Bitrate not available, " | |
905 | "avio_tell() failed: %s\n", errbuf); | |
906 | total_size = 0; | |
907 | } | |
6291d7e4 AK |
908 | |
909 | buf[0] = '\0'; | |
910 | ti1 = 1e10; | |
911 | vid = 0; | |
ea9367e9 | 912 | for (i = 0; i < nb_output_streams; i++) { |
6291d7e4 | 913 | float q = -1; |
2e215267 | 914 | ost = output_streams[i]; |
38313626 | 915 | enc = ost->enc_ctx; |
3d813e4c | 916 | if (!ost->stream_copy && enc->coded_frame) |
7636c8c6 | 917 | q = enc->coded_frame->quality / (float)FF_QP2LAMBDA; |
6291d7e4 AK |
918 | if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) { |
919 | snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q); | |
920 | } | |
921 | if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) { | |
7636c8c6 | 922 | float t = (av_gettime() - timer_start) / 1000000.0; |
6291d7e4 AK |
923 | |
924 | frame_number = ost->frame_number; | |
925 | snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ", | |
7636c8c6 AD |
926 | frame_number, (t > 1) ? (int)(frame_number / t + 0.5) : 0, q); |
927 | if (is_last_report) | |
6291d7e4 | 928 | snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L"); |
7636c8c6 | 929 | if (qp_hist) { |
6291d7e4 AK |
930 | int j; |
931 | int qp = lrintf(q); | |
7636c8c6 | 932 | if (qp >= 0 && qp < FF_ARRAY_ELEMS(qp_histogram)) |
6291d7e4 | 933 | qp_histogram[qp]++; |
7636c8c6 | 934 | for (j = 0; j < 32; j++) |
d752509b | 935 | snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log2(qp_histogram[j] + 1))); |
6291d7e4 | 936 | } |
7636c8c6 | 937 | if (enc->flags&CODEC_FLAG_PSNR) { |
6291d7e4 | 938 | int j; |
7636c8c6 AD |
939 | double error, error_sum = 0; |
940 | double scale, scale_sum = 0; | |
941 | char type[3] = { 'Y','U','V' }; | |
6291d7e4 | 942 | snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR="); |
7636c8c6 AD |
943 | for (j = 0; j < 3; j++) { |
944 | if (is_last_report) { | |
945 | error = enc->error[j]; | |
946 | scale = enc->width * enc->height * 255.0 * 255.0 * frame_number; | |
947 | } else { | |
948 | error = enc->coded_frame->error[j]; | |
949 | scale = enc->width * enc->height * 255.0 * 255.0; | |
6291d7e4 | 950 | } |
7636c8c6 AD |
951 | if (j) |
952 | scale /= 4; | |
6291d7e4 AK |
953 | error_sum += error; |
954 | scale_sum += scale; | |
7636c8c6 | 955 | snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error / scale)); |
6291d7e4 | 956 | } |
7636c8c6 | 957 | snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum / scale_sum)); |
6291d7e4 AK |
958 | } |
959 | vid = 1; | |
960 | } | |
961 | /* compute min output value */ | |
dc40d886 | 962 | pts = (double)ost->last_mux_dts * av_q2d(ost->st->time_base); |
6291d7e4 AK |
963 | if ((pts < ti1) && (pts > 0)) |
964 | ti1 = pts; | |
965 | } | |
966 | if (ti1 < 0.01) | |
967 | ti1 = 0.01; | |
968 | ||
e3245b26 | 969 | bitrate = (double)(total_size * 8) / ti1 / 1000.0; |
6291d7e4 | 970 | |
e3245b26 | 971 | snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), |
6291d7e4 AK |
972 | "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s", |
973 | (double)total_size / 1024, ti1, bitrate); | |
974 | ||
781d97fd AK |
975 | if (nb_frames_drop) |
976 | snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " drop=%d", | |
977 | nb_frames_drop); | |
6291d7e4 | 978 | |
f5646a32 | 979 | av_log(NULL, AV_LOG_INFO, "%s \r", buf); |
6291d7e4 | 980 | |
e3245b26 | 981 | fflush(stderr); |
6291d7e4 | 982 | |
a220b07b AK |
983 | if (is_last_report) |
984 | print_final_stats(total_size); | |
baeb59d8 | 985 | |
6291d7e4 AK |
986 | } |
987 | ||
ea9367e9 | 988 | static void flush_encoders(void) |
4a4ce2e7 AK |
989 | { |
990 | int i, ret; | |
991 | ||
ea9367e9 | 992 | for (i = 0; i < nb_output_streams; i++) { |
2e215267 | 993 | OutputStream *ost = output_streams[i]; |
38313626 | 994 | AVCodecContext *enc = ost->enc_ctx; |
2e215267 | 995 | AVFormatContext *os = output_files[ost->file_index]->ctx; |
ee458cb1 | 996 | int stop_encoding = 0; |
6f1c66d5 | 997 | |
b62b5cb6 | 998 | if (!ost->encoding_needed) |
6f1c66d5 AK |
999 | continue; |
1000 | ||
38313626 | 1001 | if (enc->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <= 1) |
6f1c66d5 | 1002 | continue; |
38313626 | 1003 | if (enc->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE) && enc->codec->id == AV_CODEC_ID_RAWVIDEO) |
6f1c66d5 AK |
1004 | continue; |
1005 | ||
7636c8c6 | 1006 | for (;;) { |
369cb092 AK |
1007 | int (*encode)(AVCodecContext*, AVPacket*, const AVFrame*, int*) = NULL; |
1008 | const char *desc; | |
6f1c66d5 | 1009 | |
38313626 | 1010 | switch (enc->codec_type) { |
6f1c66d5 | 1011 | case AVMEDIA_TYPE_AUDIO: |
369cb092 AK |
1012 | encode = avcodec_encode_audio2; |
1013 | desc = "Audio"; | |
6f1c66d5 AK |
1014 | break; |
1015 | case AVMEDIA_TYPE_VIDEO: | |
369cb092 AK |
1016 | encode = avcodec_encode_video2; |
1017 | desc = "Video"; | |
369cb092 AK |
1018 | break; |
1019 | default: | |
1020 | stop_encoding = 1; | |
1021 | } | |
1022 | ||
1023 | if (encode) { | |
1024 | AVPacket pkt; | |
1025 | int got_packet; | |
1026 | av_init_packet(&pkt); | |
1027 | pkt.data = NULL; | |
1028 | pkt.size = 0; | |
1029 | ||
1030 | ret = encode(enc, &pkt, NULL, &got_packet); | |
6f1c66d5 | 1031 | if (ret < 0) { |
369cb092 | 1032 | av_log(NULL, AV_LOG_FATAL, "%s encoding failed\n", desc); |
636ced8e | 1033 | exit_program(1); |
6f1c66d5 | 1034 | } |
6f1c66d5 AK |
1035 | if (ost->logfile && enc->stats_out) { |
1036 | fprintf(ost->logfile, "%s", enc->stats_out); | |
1037 | } | |
8e37038a | 1038 | if (!got_packet) { |
ee458cb1 JR |
1039 | stop_encoding = 1; |
1040 | break; | |
1041 | } | |
8e37038a AK |
1042 | if (pkt.pts != AV_NOPTS_VALUE) |
1043 | pkt.pts = av_rescale_q(pkt.pts, enc->time_base, ost->st->time_base); | |
1044 | if (pkt.dts != AV_NOPTS_VALUE) | |
1045 | pkt.dts = av_rescale_q(pkt.dts, enc->time_base, ost->st->time_base); | |
3ba41640 JR |
1046 | if (pkt.duration > 0) |
1047 | pkt.duration = av_rescale_q(pkt.duration, enc->time_base, ost->st->time_base); | |
ee458cb1 | 1048 | write_frame(os, &pkt, ost); |
4a4ce2e7 | 1049 | } |
369cb092 | 1050 | |
ee458cb1 | 1051 | if (stop_encoding) |
6f1c66d5 | 1052 | break; |
4a4ce2e7 AK |
1053 | } |
1054 | } | |
1055 | } | |
1056 | ||
7204ec1a AK |
1057 | /* |
1058 | * Check whether a packet from ist should be written into ost at this time | |
1059 | */ | |
1060 | static int check_output_constraints(InputStream *ist, OutputStream *ost) | |
1061 | { | |
2e215267 AK |
1062 | OutputFile *of = output_files[ost->file_index]; |
1063 | int ist_index = input_files[ist->file_index]->ist_index + ist->st->index; | |
7204ec1a AK |
1064 | |
1065 | if (ost->source_index != ist_index) | |
1066 | return 0; | |
1067 | ||
56ee3f9d | 1068 | if (of->start_time != AV_NOPTS_VALUE && ist->last_dts < of->start_time) |
7204ec1a AK |
1069 | return 0; |
1070 | ||
7204ec1a AK |
1071 | return 1; |
1072 | } | |
1073 | ||
1074 | static void do_streamcopy(InputStream *ist, OutputStream *ost, const AVPacket *pkt) | |
1075 | { | |
2e215267 | 1076 | OutputFile *of = output_files[ost->file_index]; |
488a0fa6 | 1077 | InputFile *f = input_files [ist->file_index]; |
56ee3f9d AK |
1078 | int64_t start_time = (of->start_time == AV_NOPTS_VALUE) ? 0 : of->start_time; |
1079 | int64_t ost_tb_start_time = av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base); | |
7204ec1a AK |
1080 | AVPacket opkt; |
1081 | ||
1082 | av_init_packet(&opkt); | |
1083 | ||
1084 | if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && | |
1085 | !ost->copy_initial_nonkeyframes) | |
1086 | return; | |
1087 | ||
1270e12e | 1088 | if (of->recording_time != INT64_MAX && |
56ee3f9d | 1089 | ist->last_dts >= of->recording_time + start_time) { |
57d24225 | 1090 | ost->finished = 1; |
1270e12e AK |
1091 | return; |
1092 | } | |
1093 | ||
488a0fa6 AK |
1094 | if (f->recording_time != INT64_MAX) { |
1095 | start_time = f->ctx->start_time; | |
1096 | if (f->start_time != AV_NOPTS_VALUE) | |
1097 | start_time += f->start_time; | |
1098 | if (ist->last_dts >= f->recording_time + start_time) { | |
1099 | ost->finished = 1; | |
1100 | return; | |
1101 | } | |
1102 | } | |
1103 | ||
7204ec1a | 1104 | /* force the input stream PTS */ |
38313626 | 1105 | if (ost->enc_ctx->codec_type == AVMEDIA_TYPE_VIDEO) |
7204ec1a | 1106 | ost->sync_opts++; |
7204ec1a | 1107 | |
7204ec1a AK |
1108 | if (pkt->pts != AV_NOPTS_VALUE) |
1109 | opkt.pts = av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time; | |
1110 | else | |
1111 | opkt.pts = AV_NOPTS_VALUE; | |
1112 | ||
1113 | if (pkt->dts == AV_NOPTS_VALUE) | |
23576b3f | 1114 | opkt.dts = av_rescale_q(ist->last_dts, AV_TIME_BASE_Q, ost->st->time_base); |
7204ec1a AK |
1115 | else |
1116 | opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base); | |
1117 | opkt.dts -= ost_tb_start_time; | |
1118 | ||
1119 | opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base); | |
1120 | opkt.flags = pkt->flags; | |
1121 | ||
7636c8c6 | 1122 | // FIXME remove the following 2 lines they shall be replaced by the bitstream filters |
38313626 AK |
1123 | if ( ost->enc_ctx->codec_id != AV_CODEC_ID_H264 |
1124 | && ost->enc_ctx->codec_id != AV_CODEC_ID_MPEG1VIDEO | |
1125 | && ost->enc_ctx->codec_id != AV_CODEC_ID_MPEG2VIDEO | |
1126 | && ost->enc_ctx->codec_id != AV_CODEC_ID_VC1 | |
7204ec1a | 1127 | ) { |
c872d310 AK |
1128 | if (av_parser_change(ost->parser, ost->st->codec, |
1129 | &opkt.data, &opkt.size, | |
1130 | pkt->data, pkt->size, | |
1131 | pkt->flags & AV_PKT_FLAG_KEY)) { | |
9b2dc295 AK |
1132 | opkt.buf = av_buffer_create(opkt.data, opkt.size, av_buffer_default_free, NULL, 0); |
1133 | if (!opkt.buf) | |
636ced8e | 1134 | exit_program(1); |
9b2dc295 | 1135 | } |
7204ec1a AK |
1136 | } else { |
1137 | opkt.data = pkt->data; | |
1138 | opkt.size = pkt->size; | |
1139 | } | |
1140 | ||
f15f02c2 | 1141 | write_frame(of->ctx, &opkt, ost); |
7204ec1a AK |
1142 | } |
1143 | ||
f5e66827 | 1144 | int guess_input_channel_layout(InputStream *ist) |
369cb092 | 1145 | { |
41776ba9 | 1146 | AVCodecContext *dec = ist->dec_ctx; |
369cb092 AK |
1147 | |
1148 | if (!dec->channel_layout) { | |
1149 | char layout_name[256]; | |
1150 | ||
1151 | dec->channel_layout = av_get_default_channel_layout(dec->channels); | |
1152 | if (!dec->channel_layout) | |
1153 | return 0; | |
1154 | av_get_channel_layout_string(layout_name, sizeof(layout_name), | |
1155 | dec->channels, dec->channel_layout); | |
1156 | av_log(NULL, AV_LOG_WARNING, "Guessed Channel Layout for Input Stream " | |
1157 | "#%d.%d : %s\n", ist->file_index, ist->st->index, layout_name); | |
1158 | } | |
1159 | return 1; | |
1160 | } | |
1161 | ||
0629f612 | 1162 | static int decode_audio(InputStream *ist, AVPacket *pkt, int *got_output) |
ded28ba3 | 1163 | { |
9b2dc295 | 1164 | AVFrame *decoded_frame, *f; |
41776ba9 | 1165 | AVCodecContext *avctx = ist->dec_ctx; |
9b2dc295 | 1166 | int i, ret, err = 0, resample_changed; |
ded28ba3 | 1167 | |
5b9c3b45 | 1168 | if (!ist->decoded_frame && !(ist->decoded_frame = av_frame_alloc())) |
d1241ff3 | 1169 | return AVERROR(ENOMEM); |
9b2dc295 AK |
1170 | if (!ist->filter_frame && !(ist->filter_frame = av_frame_alloc())) |
1171 | return AVERROR(ENOMEM); | |
9179f27c | 1172 | decoded_frame = ist->decoded_frame; |
ded28ba3 | 1173 | |
d1241ff3 | 1174 | ret = avcodec_decode_audio4(avctx, decoded_frame, got_output, pkt); |
f154ef1a AK |
1175 | if (!*got_output || ret < 0) { |
1176 | if (!pkt->size) { | |
369cb092 | 1177 | for (i = 0; i < ist->nb_filters; i++) |
9b2dc295 | 1178 | av_buffersrc_add_frame(ist->filters[i]->filter, NULL); |
f154ef1a | 1179 | } |
af8ad892 | 1180 | return ret; |
ded28ba3 AK |
1181 | } |
1182 | ||
47543450 AK |
1183 | ist->samples_decoded += decoded_frame->nb_samples; |
1184 | ist->frames_decoded++; | |
1185 | ||
d1241ff3 JR |
1186 | /* if the decoder provides a pts, use it instead of the last packet pts. |
1187 | the decoder could be delaying output by a packet or more. */ | |
1188 | if (decoded_frame->pts != AV_NOPTS_VALUE) | |
3101bb66 | 1189 | ist->next_dts = decoded_frame->pts; |
1ae8198b | 1190 | else if (pkt->pts != AV_NOPTS_VALUE) |
369cb092 | 1191 | decoded_frame->pts = pkt->pts; |
1ae8198b | 1192 | pkt->pts = AV_NOPTS_VALUE; |
ded28ba3 | 1193 | |
369cb092 AK |
1194 | resample_changed = ist->resample_sample_fmt != decoded_frame->format || |
1195 | ist->resample_channels != avctx->channels || | |
1196 | ist->resample_channel_layout != decoded_frame->channel_layout || | |
1197 | ist->resample_sample_rate != decoded_frame->sample_rate; | |
1198 | if (resample_changed) { | |
1199 | char layout1[64], layout2[64]; | |
ded28ba3 | 1200 | |
369cb092 AK |
1201 | if (!guess_input_channel_layout(ist)) { |
1202 | av_log(NULL, AV_LOG_FATAL, "Unable to find default channel " | |
1203 | "layout for Input Stream #%d.%d\n", ist->file_index, | |
1204 | ist->st->index); | |
636ced8e | 1205 | exit_program(1); |
369cb092 AK |
1206 | } |
1207 | decoded_frame->channel_layout = avctx->channel_layout; | |
1208 | ||
1209 | av_get_channel_layout_string(layout1, sizeof(layout1), ist->resample_channels, | |
1210 | ist->resample_channel_layout); | |
1211 | av_get_channel_layout_string(layout2, sizeof(layout2), avctx->channels, | |
1212 | decoded_frame->channel_layout); | |
1213 | ||
1214 | av_log(NULL, AV_LOG_INFO, | |
1215 | "Input stream #%d:%d frame changed from rate:%d fmt:%s ch:%d chl:%s to rate:%d fmt:%s ch:%d chl:%s\n", | |
1216 | ist->file_index, ist->st->index, | |
1217 | ist->resample_sample_rate, av_get_sample_fmt_name(ist->resample_sample_fmt), | |
1218 | ist->resample_channels, layout1, | |
1219 | decoded_frame->sample_rate, av_get_sample_fmt_name(decoded_frame->format), | |
1220 | avctx->channels, layout2); | |
1221 | ||
1222 | ist->resample_sample_fmt = decoded_frame->format; | |
1223 | ist->resample_sample_rate = decoded_frame->sample_rate; | |
1224 | ist->resample_channel_layout = decoded_frame->channel_layout; | |
1225 | ist->resample_channels = avctx->channels; | |
1226 | ||
1227 | for (i = 0; i < nb_filtergraphs; i++) | |
1228 | if (ist_in_filtergraph(filtergraphs[i], ist) && | |
1229 | configure_filtergraph(filtergraphs[i]) < 0) { | |
1230 | av_log(NULL, AV_LOG_FATAL, "Error reinitializing filters!\n"); | |
636ced8e | 1231 | exit_program(1); |
369cb092 | 1232 | } |
ded28ba3 | 1233 | } |
110d2af2 | 1234 | |
715129cd MS |
1235 | if (decoded_frame->pts != AV_NOPTS_VALUE) |
1236 | decoded_frame->pts = av_rescale_q(decoded_frame->pts, | |
1237 | ist->st->time_base, | |
41776ba9 | 1238 | (AVRational){1, avctx->sample_rate}); |
9b2dc295 AK |
1239 | for (i = 0; i < ist->nb_filters; i++) { |
1240 | if (i < ist->nb_filters - 1) { | |
1241 | f = ist->filter_frame; | |
1242 | err = av_frame_ref(f, decoded_frame); | |
1243 | if (err < 0) | |
1244 | break; | |
1245 | } else | |
1246 | f = decoded_frame; | |
369cb092 | 1247 | |
9b2dc295 AK |
1248 | err = av_buffersrc_add_frame(ist->filters[i]->filter, f); |
1249 | if (err < 0) | |
1250 | break; | |
1251 | } | |
1252 | ||
1253 | av_frame_unref(ist->filter_frame); | |
1254 | av_frame_unref(decoded_frame); | |
1255 | return err < 0 ? err : ret; | |
ded28ba3 AK |
1256 | } |
1257 | ||
0629f612 | 1258 | static int decode_video(InputStream *ist, AVPacket *pkt, int *got_output) |
45d4b66f | 1259 | { |
9b2dc295 | 1260 | AVFrame *decoded_frame, *f; |
9b2dc295 | 1261 | int i, ret = 0, err = 0, resample_changed; |
45d4b66f | 1262 | |
9b2dc295 AK |
1263 | if (!ist->decoded_frame && !(ist->decoded_frame = av_frame_alloc())) |
1264 | return AVERROR(ENOMEM); | |
1265 | if (!ist->filter_frame && !(ist->filter_frame = av_frame_alloc())) | |
45d4b66f | 1266 | return AVERROR(ENOMEM); |
9179f27c | 1267 | decoded_frame = ist->decoded_frame; |
45d4b66f | 1268 | |
41776ba9 | 1269 | ret = avcodec_decode_video2(ist->dec_ctx, |
45d4b66f | 1270 | decoded_frame, got_output, pkt); |
f154ef1a AK |
1271 | if (!*got_output || ret < 0) { |
1272 | if (!pkt->size) { | |
89605e4a | 1273 | for (i = 0; i < ist->nb_filters; i++) |
9b2dc295 | 1274 | av_buffersrc_add_frame(ist->filters[i]->filter, NULL); |
f154ef1a | 1275 | } |
af8ad892 | 1276 | return ret; |
45d4b66f | 1277 | } |
f154ef1a | 1278 | |
47543450 AK |
1279 | ist->frames_decoded++; |
1280 | ||
07fd0a22 | 1281 | if (ist->hwaccel_retrieve_data && decoded_frame->format == ist->hwaccel_pix_fmt) { |
41776ba9 | 1282 | err = ist->hwaccel_retrieve_data(ist->dec_ctx, decoded_frame); |
07fd0a22 AK |
1283 | if (err < 0) |
1284 | goto fail; | |
1285 | } | |
1286 | ist->hwaccel_retrieved_pix_fmt = decoded_frame->format; | |
1287 | ||
b34856a1 AK |
1288 | decoded_frame->pts = guess_correct_pts(&ist->pts_ctx, decoded_frame->pkt_pts, |
1289 | decoded_frame->pkt_dts); | |
45d4b66f | 1290 | pkt->size = 0; |
45d4b66f | 1291 | |
695ec04e AK |
1292 | if (ist->st->sample_aspect_ratio.num) |
1293 | decoded_frame->sample_aspect_ratio = ist->st->sample_aspect_ratio; | |
1294 | ||
e77c8662 AK |
1295 | resample_changed = ist->resample_width != decoded_frame->width || |
1296 | ist->resample_height != decoded_frame->height || | |
1297 | ist->resample_pix_fmt != decoded_frame->format; | |
1298 | if (resample_changed) { | |
1299 | av_log(NULL, AV_LOG_INFO, | |
1300 | "Input stream #%d:%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n", | |
1301 | ist->file_index, ist->st->index, | |
1302 | ist->resample_width, ist->resample_height, av_get_pix_fmt_name(ist->resample_pix_fmt), | |
1303 | decoded_frame->width, decoded_frame->height, av_get_pix_fmt_name(decoded_frame->format)); | |
1304 | ||
2f34021d JG |
1305 | ret = poll_filters(); |
1306 | if (ret < 0 && (ret != AVERROR_EOF && ret != AVERROR(EAGAIN))) | |
1307 | av_log(NULL, AV_LOG_ERROR, "Error while filtering.\n"); | |
1308 | ||
e77c8662 AK |
1309 | ist->resample_width = decoded_frame->width; |
1310 | ist->resample_height = decoded_frame->height; | |
1311 | ist->resample_pix_fmt = decoded_frame->format; | |
e77c8662 | 1312 | |
3b266da3 AK |
1313 | for (i = 0; i < nb_filtergraphs; i++) |
1314 | if (ist_in_filtergraph(filtergraphs[i], ist) && | |
1315 | configure_filtergraph(filtergraphs[i]) < 0) { | |
ac646076 | 1316 | av_log(NULL, AV_LOG_FATAL, "Error reinitializing filters!\n"); |
636ced8e | 1317 | exit_program(1); |
3b266da3 AK |
1318 | } |
1319 | } | |
ac646076 | 1320 | |
3b266da3 | 1321 | for (i = 0; i < ist->nb_filters; i++) { |
9b2dc295 AK |
1322 | if (i < ist->nb_filters - 1) { |
1323 | f = ist->filter_frame; | |
1324 | err = av_frame_ref(f, decoded_frame); | |
1325 | if (err < 0) | |
1326 | break; | |
04a14d4d | 1327 | } else |
9b2dc295 AK |
1328 | f = decoded_frame; |
1329 | ||
1330 | err = av_buffersrc_add_frame(ist->filters[i]->filter, f); | |
1331 | if (err < 0) | |
1332 | break; | |
45d4b66f AK |
1333 | } |
1334 | ||
07fd0a22 | 1335 | fail: |
9b2dc295 AK |
1336 | av_frame_unref(ist->filter_frame); |
1337 | av_frame_unref(decoded_frame); | |
9b2dc295 | 1338 | return err < 0 ? err : ret; |
45d4b66f AK |
1339 | } |
1340 | ||
9595234c AK |
1341 | static int transcode_subtitles(InputStream *ist, AVPacket *pkt, int *got_output) |
1342 | { | |
1343 | AVSubtitle subtitle; | |
41776ba9 | 1344 | int i, ret = avcodec_decode_subtitle2(ist->dec_ctx, |
9595234c AK |
1345 | &subtitle, got_output, pkt); |
1346 | if (ret < 0) | |
1347 | return ret; | |
1348 | if (!*got_output) | |
af8ad892 | 1349 | return ret; |
9595234c | 1350 | |
47543450 AK |
1351 | ist->frames_decoded++; |
1352 | ||
9595234c | 1353 | for (i = 0; i < nb_output_streams; i++) { |
2e215267 | 1354 | OutputStream *ost = output_streams[i]; |
9595234c AK |
1355 | |
1356 | if (!check_output_constraints(ist, ost) || !ost->encoding_needed) | |
1357 | continue; | |
1358 | ||
2e215267 | 1359 | do_subtitle_out(output_files[ost->file_index]->ctx, ost, ist, &subtitle, pkt->pts); |
9595234c AK |
1360 | } |
1361 | ||
1362 | avsubtitle_free(&subtitle); | |
af8ad892 | 1363 | return ret; |
9595234c AK |
1364 | } |
1365 | ||
6291d7e4 | 1366 | /* pkt = NULL means EOF (needed to flush decoder buffers) */ |
ea9367e9 | 1367 | static int output_packet(InputStream *ist, const AVPacket *pkt) |
6291d7e4 | 1368 | { |
ffa0674e | 1369 | int i; |
6291d7e4 | 1370 | int got_output; |
6291d7e4 | 1371 | AVPacket avpkt; |
6291d7e4 | 1372 | |
3101bb66 | 1373 | if (ist->next_dts == AV_NOPTS_VALUE) |
23576b3f | 1374 | ist->next_dts = ist->last_dts; |
6291d7e4 AK |
1375 | |
1376 | if (pkt == NULL) { | |
1377 | /* EOF handling */ | |
1378 | av_init_packet(&avpkt); | |
1379 | avpkt.data = NULL; | |
1380 | avpkt.size = 0; | |
1381 | goto handle_eof; | |
1382 | } else { | |
1383 | avpkt = *pkt; | |
1384 | } | |
1385 | ||
7636c8c6 | 1386 | if (pkt->dts != AV_NOPTS_VALUE) |
23576b3f | 1387 | ist->next_dts = ist->last_dts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q); |
6291d7e4 | 1388 | |
7636c8c6 | 1389 | // while we have more to decode or while the decoder did output something on EOF |
2a651b71 | 1390 | while (ist->decoding_needed && (avpkt.size > 0 || (!pkt && got_output))) { |
ffa0674e | 1391 | int ret = 0; |
6291d7e4 | 1392 | handle_eof: |
6291d7e4 | 1393 | |
23576b3f | 1394 | ist->last_dts = ist->next_dts; |
8b0268a8 | 1395 | |
d1780e01 AK |
1396 | if (avpkt.size && avpkt.size != pkt->size && |
1397 | !(ist->dec->capabilities & CODEC_CAP_SUBFRAMES)) { | |
e3245b26 AK |
1398 | av_log(NULL, ist->showed_multi_packet_warning ? AV_LOG_VERBOSE : AV_LOG_WARNING, |
1399 | "Multiple frames in a packet from stream %d\n", pkt->stream_index); | |
8b0268a8 AK |
1400 | ist->showed_multi_packet_warning = 1; |
1401 | } | |
6291d7e4 | 1402 | |
41776ba9 | 1403 | switch (ist->dec_ctx->codec_type) { |
82963f8f | 1404 | case AVMEDIA_TYPE_AUDIO: |
0629f612 | 1405 | ret = decode_audio (ist, &avpkt, &got_output); |
82963f8f AK |
1406 | break; |
1407 | case AVMEDIA_TYPE_VIDEO: | |
0629f612 | 1408 | ret = decode_video (ist, &avpkt, &got_output); |
b34856a1 AK |
1409 | if (avpkt.duration) |
1410 | ist->next_dts += av_rescale_q(avpkt.duration, ist->st->time_base, AV_TIME_BASE_Q); | |
aba232cf | 1411 | else if (ist->st->avg_frame_rate.num) |
82494835 | 1412 | ist->next_dts += av_rescale_q(1, av_inv_q(ist->st->avg_frame_rate), |
722410ad | 1413 | AV_TIME_BASE_Q); |
41776ba9 | 1414 | else if (ist->dec_ctx->time_base.num != 0) { |
b34856a1 | 1415 | int ticks = ist->st->parser ? ist->st->parser->repeat_pict + 1 : |
41776ba9 AK |
1416 | ist->dec_ctx->ticks_per_frame; |
1417 | ist->next_dts += av_rescale_q(ticks, ist->dec_ctx->time_base, AV_TIME_BASE_Q); | |
b34856a1 | 1418 | } |
82963f8f AK |
1419 | break; |
1420 | case AVMEDIA_TYPE_SUBTITLE: | |
1421 | ret = transcode_subtitles(ist, &avpkt, &got_output); | |
1422 | break; | |
78162b4e AK |
1423 | default: |
1424 | return -1; | |
1425 | } | |
6291d7e4 | 1426 | |
d3c1d37a AK |
1427 | if (ret < 0) |
1428 | return ret; | |
aa38cff2 JG |
1429 | // touch data and size only if not EOF |
1430 | if (pkt) { | |
1431 | avpkt.data += ret; | |
1432 | avpkt.size -= ret; | |
1433 | } | |
82963f8f | 1434 | if (!got_output) { |
af8ad892 | 1435 | continue; |
82963f8f | 1436 | } |
6291d7e4 | 1437 | } |
6291d7e4 | 1438 | |
7204ec1a | 1439 | /* handle stream copy */ |
2a651b71 | 1440 | if (!ist->decoding_needed) { |
23576b3f | 1441 | ist->last_dts = ist->next_dts; |
41776ba9 | 1442 | switch (ist->dec_ctx->codec_type) { |
2a651b71 | 1443 | case AVMEDIA_TYPE_AUDIO: |
41776ba9 AK |
1444 | ist->next_dts += ((int64_t)AV_TIME_BASE * ist->dec_ctx->frame_size) / |
1445 | ist->dec_ctx->sample_rate; | |
2a651b71 AK |
1446 | break; |
1447 | case AVMEDIA_TYPE_VIDEO: | |
41776ba9 AK |
1448 | if (ist->dec_ctx->time_base.num != 0) { |
1449 | int ticks = ist->st->parser ? ist->st->parser->repeat_pict + 1 : ist->dec_ctx->ticks_per_frame; | |
3101bb66 | 1450 | ist->next_dts += ((int64_t)AV_TIME_BASE * |
41776ba9 AK |
1451 | ist->dec_ctx->time_base.num * ticks) / |
1452 | ist->dec_ctx->time_base.den; | |
2a651b71 AK |
1453 | } |
1454 | break; | |
1455 | } | |
1456 | } | |
ea9367e9 | 1457 | for (i = 0; pkt && i < nb_output_streams; i++) { |
2e215267 | 1458 | OutputStream *ost = output_streams[i]; |
7204ec1a AK |
1459 | |
1460 | if (!check_output_constraints(ist, ost) || ost->encoding_needed) | |
1461 | continue; | |
1462 | ||
1463 | do_streamcopy(ist, ost, pkt); | |
1464 | } | |
1465 | ||
6291d7e4 AK |
1466 | return 0; |
1467 | } | |
1468 | ||
ea9367e9 | 1469 | static void print_sdp(void) |
6291d7e4 | 1470 | { |
a23abaf3 | 1471 | char sdp[16384]; |
af70aa45 | 1472 | int i; |
ea9367e9 | 1473 | AVFormatContext **avc = av_malloc(sizeof(*avc) * nb_output_files); |
af70aa45 AK |
1474 | |
1475 | if (!avc) | |
636ced8e | 1476 | exit_program(1); |
ea9367e9 | 1477 | for (i = 0; i < nb_output_files; i++) |
2e215267 | 1478 | avc[i] = output_files[i]->ctx; |
6291d7e4 | 1479 | |
ea9367e9 | 1480 | av_sdp_create(avc, nb_output_files, sdp, sizeof(sdp)); |
6291d7e4 AK |
1481 | printf("SDP:\n%s\n", sdp); |
1482 | fflush(stdout); | |
af70aa45 | 1483 | av_freep(&avc); |
6291d7e4 AK |
1484 | } |
1485 | ||
07fd0a22 AK |
1486 | static const HWAccel *get_hwaccel(enum AVPixelFormat pix_fmt) |
1487 | { | |
1488 | int i; | |
1489 | for (i = 0; hwaccels[i].name; i++) | |
1490 | if (hwaccels[i].pix_fmt == pix_fmt) | |
1491 | return &hwaccels[i]; | |
1492 | return NULL; | |
1493 | } | |
1494 | ||
1495 | static enum AVPixelFormat get_format(AVCodecContext *s, const enum AVPixelFormat *pix_fmts) | |
1496 | { | |
1497 | InputStream *ist = s->opaque; | |
1498 | const enum AVPixelFormat *p; | |
1499 | int ret; | |
1500 | ||
1501 | for (p = pix_fmts; *p != -1; p++) { | |
1502 | const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(*p); | |
1503 | const HWAccel *hwaccel; | |
1504 | ||
1505 | if (!(desc->flags & AV_PIX_FMT_FLAG_HWACCEL)) | |
1506 | break; | |
1507 | ||
1508 | hwaccel = get_hwaccel(*p); | |
1509 | if (!hwaccel || | |
1510 | (ist->active_hwaccel_id && ist->active_hwaccel_id != hwaccel->id) || | |
1511 | (ist->hwaccel_id != HWACCEL_AUTO && ist->hwaccel_id != hwaccel->id)) | |
1512 | continue; | |
1513 | ||
1514 | ret = hwaccel->init(s); | |
1515 | if (ret < 0) { | |
1516 | if (ist->hwaccel_id == hwaccel->id) { | |
1517 | av_log(NULL, AV_LOG_FATAL, | |
1518 | "%s hwaccel requested for input stream #%d:%d, " | |
1519 | "but cannot be initialized.\n", hwaccel->name, | |
1520 | ist->file_index, ist->st->index); | |
1521 | exit_program(1); | |
1522 | } | |
1523 | continue; | |
1524 | } | |
1525 | ist->active_hwaccel_id = hwaccel->id; | |
1526 | ist->hwaccel_pix_fmt = *p; | |
1527 | break; | |
1528 | } | |
1529 | ||
1530 | return *p; | |
1531 | } | |
1532 | ||
1533 | static int get_buffer(AVCodecContext *s, AVFrame *frame, int flags) | |
1534 | { | |
1535 | InputStream *ist = s->opaque; | |
1536 | ||
1537 | if (ist->hwaccel_get_buffer && frame->format == ist->hwaccel_pix_fmt) | |
1538 | return ist->hwaccel_get_buffer(s, frame, flags); | |
1539 | ||
1540 | return avcodec_default_get_buffer2(s, frame, flags); | |
1541 | } | |
1542 | ||
ea9367e9 | 1543 | static int init_input_stream(int ist_index, char *error, int error_len) |
630902a1 | 1544 | { |
c854102d | 1545 | int i, ret; |
2e215267 | 1546 | InputStream *ist = input_streams[ist_index]; |
630902a1 AK |
1547 | if (ist->decoding_needed) { |
1548 | AVCodec *codec = ist->dec; | |
630902a1 | 1549 | if (!codec) { |
9a414d89 | 1550 | snprintf(error, error_len, "Decoder (codec id %d) not found for input stream #%d:%d", |
41776ba9 | 1551 | ist->dec_ctx->codec_id, ist->file_index, ist->st->index); |
630902a1 AK |
1552 | return AVERROR(EINVAL); |
1553 | } | |
1554 | ||
1555 | /* update requested sample format for the decoder based on the | |
1556 | corresponding encoder sample format */ | |
1557 | for (i = 0; i < nb_output_streams; i++) { | |
2e215267 | 1558 | OutputStream *ost = output_streams[i]; |
630902a1 | 1559 | if (ost->source_index == ist_index) { |
38313626 | 1560 | update_sample_fmt(ist->dec_ctx, codec, ost->enc_ctx); |
630902a1 AK |
1561 | break; |
1562 | } | |
1563 | } | |
1564 | ||
41776ba9 AK |
1565 | ist->dec_ctx->opaque = ist; |
1566 | ist->dec_ctx->get_format = get_format; | |
1567 | ist->dec_ctx->get_buffer2 = get_buffer; | |
1568 | ist->dec_ctx->thread_safe_callbacks = 1; | |
07fd0a22 | 1569 | |
41776ba9 | 1570 | av_opt_set_int(ist->dec_ctx, "refcounted_frames", 1, 0); |
64dca32c | 1571 | |
f3a6ad22 AK |
1572 | if (!av_dict_get(ist->decoder_opts, "threads", NULL, 0)) |
1573 | av_dict_set(&ist->decoder_opts, "threads", "auto", 0); | |
41776ba9 | 1574 | if ((ret = avcodec_open2(ist->dec_ctx, codec, &ist->decoder_opts)) < 0) { |
42cc6cef | 1575 | char errbuf[128]; |
c854102d NC |
1576 | if (ret == AVERROR_EXPERIMENTAL) |
1577 | abort_codec_experimental(codec, 0); | |
42cc6cef LB |
1578 | |
1579 | av_strerror(ret, errbuf, sizeof(errbuf)); | |
1580 | ||
1581 | snprintf(error, error_len, | |
1582 | "Error while opening decoder for input stream " | |
1583 | "#%d:%d : %s", | |
1584 | ist->file_index, ist->st->index, errbuf); | |
c854102d | 1585 | return ret; |
630902a1 | 1586 | } |
f3a6ad22 | 1587 | assert_avoptions(ist->decoder_opts); |
630902a1 AK |
1588 | } |
1589 | ||
41776ba9 | 1590 | ist->last_dts = ist->st->avg_frame_rate.num ? - ist->dec_ctx->has_b_frames * AV_TIME_BASE / av_q2d(ist->st->avg_frame_rate) : 0; |
3101bb66 | 1591 | ist->next_dts = AV_NOPTS_VALUE; |
630902a1 | 1592 | init_pts_correction(&ist->pts_ctx); |
630902a1 AK |
1593 | |
1594 | return 0; | |
1595 | } | |
1596 | ||
3b266da3 AK |
1597 | static InputStream *get_input_stream(OutputStream *ost) |
1598 | { | |
1599 | if (ost->source_index >= 0) | |
1600 | return input_streams[ost->source_index]; | |
1601 | ||
1602 | if (ost->filter) { | |
1603 | FilterGraph *fg = ost->filter->graph; | |
1604 | int i; | |
1605 | ||
1606 | for (i = 0; i < fg->nb_inputs; i++) | |
38313626 | 1607 | if (fg->inputs[i]->ist->dec_ctx->codec_type == ost->enc_ctx->codec_type) |
3b266da3 AK |
1608 | return fg->inputs[i]->ist; |
1609 | } | |
1610 | ||
1611 | return NULL; | |
1612 | } | |
1613 | ||
19ad5673 AK |
1614 | static void parse_forced_key_frames(char *kf, OutputStream *ost, |
1615 | AVCodecContext *avctx) | |
1616 | { | |
1617 | char *p; | |
1618 | int n = 1, i; | |
1619 | int64_t t; | |
1620 | ||
1621 | for (p = kf; *p; p++) | |
1622 | if (*p == ',') | |
1623 | n++; | |
1624 | ost->forced_kf_count = n; | |
1625 | ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n); | |
1626 | if (!ost->forced_kf_pts) { | |
1627 | av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n"); | |
636ced8e | 1628 | exit_program(1); |
19ad5673 | 1629 | } |
4c679750 RD |
1630 | |
1631 | p = kf; | |
19ad5673 | 1632 | for (i = 0; i < n; i++) { |
4c679750 RD |
1633 | char *next = strchr(p, ','); |
1634 | ||
1635 | if (next) | |
1636 | *next++ = 0; | |
1637 | ||
19ad5673 AK |
1638 | t = parse_time_or_die("force_key_frames", p, 1); |
1639 | ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base); | |
4c679750 RD |
1640 | |
1641 | p = next; | |
19ad5673 AK |
1642 | } |
1643 | } | |
1644 | ||
6656370b AK |
1645 | static void set_encoder_id(OutputFile *of, OutputStream *ost) |
1646 | { | |
1647 | AVDictionaryEntry *e; | |
1648 | ||
1649 | uint8_t *encoder_string; | |
1650 | int encoder_string_len; | |
1651 | int format_flags = 0; | |
1652 | ||
1653 | e = av_dict_get(of->opts, "fflags", NULL, 0); | |
1654 | if (e) { | |
1655 | const AVOption *o = av_opt_find(of->ctx, "fflags", NULL, 0, 0); | |
1656 | if (!o) | |
1657 | return; | |
1658 | av_opt_eval_flags(of->ctx, o, e->value, &format_flags); | |
1659 | } | |
1660 | ||
1661 | encoder_string_len = sizeof(LIBAVCODEC_IDENT) + strlen(ost->enc->name) + 2; | |
1662 | encoder_string = av_mallocz(encoder_string_len); | |
1663 | if (!encoder_string) | |
1664 | exit_program(1); | |
1665 | ||
1666 | if (!(format_flags & AVFMT_FLAG_BITEXACT)) | |
1667 | av_strlcpy(encoder_string, LIBAVCODEC_IDENT " ", encoder_string_len); | |
1668 | av_strlcat(encoder_string, ost->enc->name, encoder_string_len); | |
1669 | av_dict_set(&ost->st->metadata, "encoder", encoder_string, | |
1670 | AV_DICT_DONT_STRDUP_VAL | AV_DICT_DONT_OVERWRITE); | |
1671 | } | |
1672 | ||
ea9367e9 | 1673 | static int transcode_init(void) |
6291d7e4 | 1674 | { |
2c474ddb | 1675 | int ret = 0, i, j, k; |
1bb77e51 | 1676 | AVFormatContext *oc; |
4288e031 | 1677 | OutputStream *ost; |
6291d7e4 AK |
1678 | InputStream *ist; |
1679 | char error[1024]; | |
1680 | int want_sdp = 1; | |
b0c9e8e0 | 1681 | |
f4805328 AK |
1682 | /* init framerate emulation */ |
1683 | for (i = 0; i < nb_input_files; i++) { | |
2e215267 | 1684 | InputFile *ifile = input_files[i]; |
f4805328 AK |
1685 | if (ifile->rate_emu) |
1686 | for (j = 0; j < ifile->nb_streams; j++) | |
2e215267 | 1687 | input_streams[j + ifile->ist_index]->start = av_gettime(); |
f4805328 | 1688 | } |
6291d7e4 AK |
1689 | |
1690 | /* output stream init */ | |
03f30c83 | 1691 | for (i = 0; i < nb_output_files; i++) { |
2e215267 | 1692 | oc = output_files[i]->ctx; |
1bb77e51 AK |
1693 | if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) { |
1694 | av_dump_format(oc, i, oc->filename, 1); | |
e3245b26 | 1695 | av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", i); |
eaf2d37a | 1696 | return AVERROR(EINVAL); |
6291d7e4 | 1697 | } |
6291d7e4 AK |
1698 | } |
1699 | ||
3b266da3 AK |
1700 | /* init complex filtergraphs */ |
1701 | for (i = 0; i < nb_filtergraphs; i++) | |
1702 | if ((ret = avfilter_graph_config(filtergraphs[i]->graph, NULL)) < 0) | |
1703 | return ret; | |
1704 | ||
6291d7e4 | 1705 | /* for each output stream, we compute the right encoding parameters */ |
4288e031 | 1706 | for (i = 0; i < nb_output_streams; i++) { |
65ed9e75 | 1707 | AVCodecContext *enc_ctx; |
650a5206 | 1708 | AVCodecContext *dec_ctx = NULL; |
2e215267 AK |
1709 | ost = output_streams[i]; |
1710 | oc = output_files[ost->file_index]->ctx; | |
3b266da3 | 1711 | ist = get_input_stream(ost); |
6291d7e4 | 1712 | |
4dbc6cee AK |
1713 | if (ost->attachment_filename) |
1714 | continue; | |
1715 | ||
38313626 | 1716 | enc_ctx = ost->enc_ctx; |
6291d7e4 | 1717 | |
3b266da3 | 1718 | if (ist) { |
41776ba9 | 1719 | dec_ctx = ist->dec_ctx; |
3b266da3 AK |
1720 | |
1721 | ost->st->disposition = ist->st->disposition; | |
65ed9e75 AK |
1722 | enc_ctx->bits_per_raw_sample = dec_ctx->bits_per_raw_sample; |
1723 | enc_ctx->chroma_sample_location = dec_ctx->chroma_sample_location; | |
3b266da3 | 1724 | } |
6291d7e4 | 1725 | |
3d813e4c | 1726 | if (ost->stream_copy) { |
538bf767 | 1727 | AVRational sar; |
8c4022ac AK |
1728 | uint64_t extra_size; |
1729 | ||
1730 | av_assert0(ist && !ost->filter); | |
1731 | ||
650a5206 | 1732 | extra_size = (uint64_t)dec_ctx->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE; |
6291d7e4 | 1733 | |
e6d2b737 | 1734 | if (extra_size > INT_MAX) { |
eaf2d37a | 1735 | return AVERROR(EINVAL); |
e6d2b737 | 1736 | } |
6291d7e4 AK |
1737 | |
1738 | /* if stream_copy is selected, no need to decode or encode */ | |
65ed9e75 AK |
1739 | enc_ctx->codec_id = dec_ctx->codec_id; |
1740 | enc_ctx->codec_type = dec_ctx->codec_type; | |
6291d7e4 | 1741 | |
65ed9e75 | 1742 | if (!enc_ctx->codec_tag) { |
03f30c83 | 1743 | if (!oc->oformat->codec_tag || |
65ed9e75 | 1744 | av_codec_get_id (oc->oformat->codec_tag, dec_ctx->codec_tag) == enc_ctx->codec_id || |
650a5206 | 1745 | av_codec_get_tag(oc->oformat->codec_tag, dec_ctx->codec_id) <= 0) |
65ed9e75 | 1746 | enc_ctx->codec_tag = dec_ctx->codec_tag; |
6291d7e4 AK |
1747 | } |
1748 | ||
65ed9e75 AK |
1749 | enc_ctx->bit_rate = dec_ctx->bit_rate; |
1750 | enc_ctx->rc_max_rate = dec_ctx->rc_max_rate; | |
1751 | enc_ctx->rc_buffer_size = dec_ctx->rc_buffer_size; | |
1752 | enc_ctx->field_order = dec_ctx->field_order; | |
1753 | enc_ctx->extradata = av_mallocz(extra_size); | |
1754 | if (!enc_ctx->extradata) { | |
eaf2d37a | 1755 | return AVERROR(ENOMEM); |
e6d2b737 | 1756 | } |
65ed9e75 AK |
1757 | memcpy(enc_ctx->extradata, dec_ctx->extradata, dec_ctx->extradata_size); |
1758 | enc_ctx->extradata_size = dec_ctx->extradata_size; | |
7bb3e625 | 1759 | if (!copy_tb) { |
65ed9e75 AK |
1760 | enc_ctx->time_base = dec_ctx->time_base; |
1761 | enc_ctx->time_base.num *= dec_ctx->ticks_per_frame; | |
1762 | av_reduce(&enc_ctx->time_base.num, &enc_ctx->time_base.den, | |
1763 | enc_ctx->time_base.num, enc_ctx->time_base.den, INT_MAX); | |
03f30c83 | 1764 | } else |
65ed9e75 | 1765 | enc_ctx->time_base = ist->st->time_base; |
03f30c83 | 1766 | |
65ed9e75 | 1767 | ost->parser = av_parser_init(enc_ctx->codec_id); |
c872d310 | 1768 | |
65ed9e75 | 1769 | switch (enc_ctx->codec_type) { |
6291d7e4 | 1770 | case AVMEDIA_TYPE_AUDIO: |
7636c8c6 | 1771 | if (audio_volume != 256) { |
e3245b26 | 1772 | av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n"); |
636ced8e | 1773 | exit_program(1); |
6291d7e4 | 1774 | } |
65ed9e75 AK |
1775 | enc_ctx->channel_layout = dec_ctx->channel_layout; |
1776 | enc_ctx->sample_rate = dec_ctx->sample_rate; | |
1777 | enc_ctx->channels = dec_ctx->channels; | |
1778 | enc_ctx->frame_size = dec_ctx->frame_size; | |
1779 | enc_ctx->audio_service_type = dec_ctx->audio_service_type; | |
1780 | enc_ctx->block_align = dec_ctx->block_align; | |
6291d7e4 AK |
1781 | break; |
1782 | case AVMEDIA_TYPE_VIDEO: | |
65ed9e75 AK |
1783 | enc_ctx->pix_fmt = dec_ctx->pix_fmt; |
1784 | enc_ctx->width = dec_ctx->width; | |
1785 | enc_ctx->height = dec_ctx->height; | |
1786 | enc_ctx->has_b_frames = dec_ctx->has_b_frames; | |
538bf767 | 1787 | if (ost->frame_aspect_ratio) |
65ed9e75 | 1788 | sar = av_d2q(ost->frame_aspect_ratio * enc_ctx->height / enc_ctx->width, 255); |
538bf767 AK |
1789 | else if (ist->st->sample_aspect_ratio.num) |
1790 | sar = ist->st->sample_aspect_ratio; | |
1791 | else | |
650a5206 | 1792 | sar = dec_ctx->sample_aspect_ratio; |
65ed9e75 | 1793 | ost->st->sample_aspect_ratio = enc_ctx->sample_aspect_ratio = sar; |
6291d7e4 AK |
1794 | break; |
1795 | case AVMEDIA_TYPE_SUBTITLE: | |
65ed9e75 AK |
1796 | enc_ctx->width = dec_ctx->width; |
1797 | enc_ctx->height = dec_ctx->height; | |
6291d7e4 AK |
1798 | break; |
1799 | case AVMEDIA_TYPE_DATA: | |
3ccd1580 | 1800 | case AVMEDIA_TYPE_ATTACHMENT: |
6291d7e4 AK |
1801 | break; |
1802 | default: | |
1803 | abort(); | |
1804 | } | |
1805 | } else { | |
2994913d AK |
1806 | if (!ost->enc) { |
1807 | /* should only happen when a default codec is not present. */ | |
1808 | snprintf(error, sizeof(error), "Automatic encoder selection " | |
1809 | "failed for output stream #%d:%d. Default encoder for " | |
1810 | "format %s is probably disabled. Please choose an " | |
1811 | "encoder manually.\n", ost->file_index, ost->index, | |
1812 | oc->oformat->name); | |
1813 | ret = AVERROR(EINVAL); | |
1814 | goto dump_format; | |
1815 | } | |
03f30c83 | 1816 | |
3b266da3 AK |
1817 | if (ist) |
1818 | ist->decoding_needed = 1; | |
11fdb7e1 | 1819 | ost->encoding_needed = 1; |
03f30c83 | 1820 | |
6656370b AK |
1821 | set_encoder_id(output_files[ost->file_index], ost); |
1822 | ||
74b961db AK |
1823 | /* |
1824 | * We want CFR output if and only if one of those is true: | |
1825 | * 1) user specified output framerate with -r | |
1826 | * 2) user specified -vsync cfr | |
1827 | * 3) output format is CFR and the user didn't force vsync to | |
1828 | * something else than CFR | |
1829 | * | |
1830 | * in such a case, set ost->frame_rate | |
1831 | */ | |
65ed9e75 | 1832 | if (enc_ctx->codec_type == AVMEDIA_TYPE_VIDEO && |
74b961db AK |
1833 | !ost->frame_rate.num && ist && |
1834 | (video_sync_method == VSYNC_CFR || | |
1835 | (video_sync_method == VSYNC_AUTO && | |
1836 | !(oc->oformat->flags & (AVFMT_NOTIMESTAMPS | AVFMT_VARIABLE_FPS))))) { | |
2ce8bca5 AK |
1837 | if (ist->framerate.num) |
1838 | ost->frame_rate = ist->framerate; | |
1839 | else if (ist->st->avg_frame_rate.num) | |
1840 | ost->frame_rate = ist->st->avg_frame_rate; | |
1841 | else { | |
1842 | av_log(NULL, AV_LOG_WARNING, "Constant framerate requested " | |
1843 | "for the output stream #%d:%d, but no information " | |
1844 | "about the input framerate is available. Falling " | |
1845 | "back to a default value of 25fps. Use the -r option " | |
1846 | "if you want a different framerate.\n", | |
1847 | ost->file_index, ost->index); | |
1848 | ost->frame_rate = (AVRational){ 25, 1 }; | |
1849 | } | |
44b0b85f | 1850 | |
74b961db AK |
1851 | if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) { |
1852 | int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates); | |
1853 | ost->frame_rate = ost->enc->supported_framerates[idx]; | |
1854 | } | |
1855 | } | |
1856 | ||
369cb092 | 1857 | if (!ost->filter && |
65ed9e75 AK |
1858 | (enc_ctx->codec_type == AVMEDIA_TYPE_VIDEO || |
1859 | enc_ctx->codec_type == AVMEDIA_TYPE_AUDIO)) { | |
3b266da3 AK |
1860 | FilterGraph *fg; |
1861 | fg = init_simple_filtergraph(ist, ost); | |
8daf21d5 | 1862 | if (configure_filtergraph(fg)) { |
3b266da3 | 1863 | av_log(NULL, AV_LOG_FATAL, "Error opening filters!\n"); |
636ced8e | 1864 | exit_program(1); |
3b266da3 | 1865 | } |
369cb092 | 1866 | } |
3b266da3 | 1867 | |
65ed9e75 | 1868 | switch (enc_ctx->codec_type) { |
369cb092 | 1869 | case AVMEDIA_TYPE_AUDIO: |
65ed9e75 AK |
1870 | enc_ctx->sample_fmt = ost->filter->filter->inputs[0]->format; |
1871 | enc_ctx->sample_rate = ost->filter->filter->inputs[0]->sample_rate; | |
1872 | enc_ctx->channel_layout = ost->filter->filter->inputs[0]->channel_layout; | |
1873 | enc_ctx->channels = av_get_channel_layout_nb_channels(enc_ctx->channel_layout); | |
1874 | enc_ctx->time_base = (AVRational){ 1, enc_ctx->sample_rate }; | |
369cb092 AK |
1875 | break; |
1876 | case AVMEDIA_TYPE_VIDEO: | |
65ed9e75 | 1877 | enc_ctx->time_base = ost->filter->filter->inputs[0]->time_base; |
6291d7e4 | 1878 | |
65ed9e75 AK |
1879 | enc_ctx->width = ost->filter->filter->inputs[0]->w; |
1880 | enc_ctx->height = ost->filter->filter->inputs[0]->h; | |
1881 | enc_ctx->sample_aspect_ratio = ost->st->sample_aspect_ratio = | |
3b266da3 | 1882 | ost->frame_aspect_ratio ? // overridden by the -aspect cli option |
65ed9e75 | 1883 | av_d2q(ost->frame_aspect_ratio * enc_ctx->height/enc_ctx->width, 255) : |
3b266da3 | 1884 | ost->filter->filter->inputs[0]->sample_aspect_ratio; |
65ed9e75 | 1885 | enc_ctx->pix_fmt = ost->filter->filter->inputs[0]->format; |
b7327887 | 1886 | |
93afb6c9 AK |
1887 | ost->st->avg_frame_rate = ost->frame_rate; |
1888 | ||
650a5206 | 1889 | if (dec_ctx && |
65ed9e75 AK |
1890 | (enc_ctx->width != dec_ctx->width || |
1891 | enc_ctx->height != dec_ctx->height || | |
1892 | enc_ctx->pix_fmt != dec_ctx->pix_fmt)) { | |
1893 | enc_ctx->bits_per_raw_sample = 0; | |
b7327887 AK |
1894 | } |
1895 | ||
19ad5673 AK |
1896 | if (ost->forced_keyframes) |
1897 | parse_forced_key_frames(ost->forced_keyframes, ost, | |
38313626 | 1898 | ost->enc_ctx); |
6291d7e4 AK |
1899 | break; |
1900 | case AVMEDIA_TYPE_SUBTITLE: | |
65ed9e75 | 1901 | enc_ctx->time_base = (AVRational){1, 1000}; |
6291d7e4 AK |
1902 | break; |
1903 | default: | |
1904 | abort(); | |
1905 | break; | |
1906 | } | |
1907 | /* two pass mode */ | |
65ed9e75 | 1908 | if ((enc_ctx->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) { |
6291d7e4 AK |
1909 | char logfilename[1024]; |
1910 | FILE *f; | |
1911 | ||
1912 | snprintf(logfilename, sizeof(logfilename), "%s-%d.log", | |
bbcedade AK |
1913 | ost->logfile_prefix ? ost->logfile_prefix : |
1914 | DEFAULT_PASS_LOGFILENAME_PREFIX, | |
6291d7e4 | 1915 | i); |
6e8be949 | 1916 | if (!strcmp(ost->enc->name, "libx264")) { |
9580818c | 1917 | av_dict_set(&ost->encoder_opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE); |
6e8be949 | 1918 | } else { |
65ed9e75 | 1919 | if (enc_ctx->flags & CODEC_FLAG_PASS1) { |
64334ddb AK |
1920 | f = fopen(logfilename, "wb"); |
1921 | if (!f) { | |
1922 | av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n", | |
1923 | logfilename, strerror(errno)); | |
636ced8e | 1924 | exit_program(1); |
64334ddb AK |
1925 | } |
1926 | ost->logfile = f; | |
1927 | } else { | |
1928 | char *logbuffer; | |
1929 | size_t logbuffer_size; | |
1930 | if (cmdutils_read_file(logfilename, &logbuffer, &logbuffer_size) < 0) { | |
1931 | av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n", | |
1932 | logfilename); | |
636ced8e | 1933 | exit_program(1); |
64334ddb | 1934 | } |
65ed9e75 | 1935 | enc_ctx->stats_in = logbuffer; |
6291d7e4 | 1936 | } |
6e8be949 | 1937 | } |
6291d7e4 AK |
1938 | } |
1939 | } | |
6291d7e4 AK |
1940 | } |
1941 | ||
1942 | /* open each encoder */ | |
4288e031 | 1943 | for (i = 0; i < nb_output_streams; i++) { |
2e215267 | 1944 | ost = output_streams[i]; |
6291d7e4 | 1945 | if (ost->encoding_needed) { |
03f30c83 | 1946 | AVCodec *codec = ost->enc; |
3b266da3 | 1947 | AVCodecContext *dec = NULL; |
3b266da3 AK |
1948 | |
1949 | if ((ist = get_input_stream(ost))) | |
41776ba9 | 1950 | dec = ist->dec_ctx; |
3b266da3 | 1951 | if (dec && dec->subtitle_header) { |
38313626 AK |
1952 | ost->enc_ctx->subtitle_header = av_malloc(dec->subtitle_header_size); |
1953 | if (!ost->enc_ctx->subtitle_header) { | |
6291d7e4 AK |
1954 | ret = AVERROR(ENOMEM); |
1955 | goto dump_format; | |
1956 | } | |
38313626 AK |
1957 | memcpy(ost->enc_ctx->subtitle_header, dec->subtitle_header, dec->subtitle_header_size); |
1958 | ost->enc_ctx->subtitle_header_size = dec->subtitle_header_size; | |
6291d7e4 | 1959 | } |
9580818c AK |
1960 | if (!av_dict_get(ost->encoder_opts, "threads", NULL, 0)) |
1961 | av_dict_set(&ost->encoder_opts, "threads", "auto", 0); | |
38313626 AK |
1962 | av_dict_set(&ost->encoder_opts, "side_data_only_packets", "1", 0); |
1963 | ||
1964 | if ((ret = avcodec_open2(ost->enc_ctx, codec, &ost->encoder_opts)) < 0) { | |
c854102d NC |
1965 | if (ret == AVERROR_EXPERIMENTAL) |
1966 | abort_codec_experimental(codec, 1); | |
9a414d89 | 1967 | snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d:%d - maybe incorrect parameters such as bit_rate, rate, width or height", |
6291d7e4 | 1968 | ost->file_index, ost->index); |
6291d7e4 AK |
1969 | goto dump_format; |
1970 | } | |
9580818c | 1971 | assert_avoptions(ost->encoder_opts); |
38313626 | 1972 | if (ost->enc_ctx->bit_rate && ost->enc_ctx->bit_rate < 1000) |
6291d7e4 AK |
1973 | av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low." |
1974 | "It takes bits/s as argument, not kbits/s\n"); | |
df0229a7 | 1975 | } else { |
38313626 AK |
1976 | av_opt_set_dict(ost->enc_ctx, &ost->encoder_opts); |
1977 | } | |
1978 | ||
1979 | ret = avcodec_copy_context(ost->st->codec, ost->enc_ctx); | |
1980 | if (ret < 0) { | |
1981 | av_log(NULL, AV_LOG_FATAL, | |
1982 | "Error initializing the output stream codec context.\n"); | |
1983 | exit_program(1); | |
6291d7e4 AK |
1984 | } |
1985 | } | |
1986 | ||
630902a1 AK |
1987 | /* init input streams */ |
1988 | for (i = 0; i < nb_input_streams; i++) | |
ea9367e9 | 1989 | if ((ret = init_input_stream(i, error, sizeof(error))) < 0) |
630902a1 | 1990 | goto dump_format; |
6291d7e4 | 1991 | |
2c474ddb AK |
1992 | /* discard unused programs */ |
1993 | for (i = 0; i < nb_input_files; i++) { | |
2e215267 | 1994 | InputFile *ifile = input_files[i]; |
2c474ddb AK |
1995 | for (j = 0; j < ifile->ctx->nb_programs; j++) { |
1996 | AVProgram *p = ifile->ctx->programs[j]; | |
1997 | int discard = AVDISCARD_ALL; | |
1998 | ||
1999 | for (k = 0; k < p->nb_stream_indexes; k++) | |
2e215267 | 2000 | if (!input_streams[ifile->ist_index + p->stream_index[k]]->discard) { |
2c474ddb AK |
2001 | discard = AVDISCARD_DEFAULT; |
2002 | break; | |
2003 | } | |
2004 | p->discard = discard; | |
2005 | } | |
2006 | } | |
2007 | ||
6291d7e4 | 2008 | /* open files and write file headers */ |
af70aa45 | 2009 | for (i = 0; i < nb_output_files; i++) { |
2e215267 | 2010 | oc = output_files[i]->ctx; |
1bb77e51 | 2011 | oc->interrupt_callback = int_cb; |
a1a6cdc2 MS |
2012 | if ((ret = avformat_write_header(oc, &output_files[i]->opts)) < 0) { |
2013 | char errbuf[128]; | |
1e340af8 LB |
2014 | av_strerror(ret, errbuf, sizeof(errbuf)); |
2015 | snprintf(error, sizeof(error), | |
2016 | "Could not write header for output file #%d " | |
2017 | "(incorrect codec parameters ?): %s", | |
2018 | i, errbuf); | |
6291d7e4 AK |
2019 | ret = AVERROR(EINVAL); |
2020 | goto dump_format; | |
2021 | } | |
2e215267 | 2022 | assert_avoptions(output_files[i]->opts); |
1bb77e51 | 2023 | if (strcmp(oc->oformat->name, "rtp")) { |
6291d7e4 AK |
2024 | want_sdp = 0; |
2025 | } | |
2026 | } | |
2027 | ||
2028 | dump_format: | |
2029 | /* dump the file output parameters - cannot be done before in case | |
2030 | of stream copy */ | |
03f30c83 | 2031 | for (i = 0; i < nb_output_files; i++) { |
2e215267 | 2032 | av_dump_format(output_files[i]->ctx, i, output_files[i]->ctx->filename, 1); |
6291d7e4 AK |
2033 | } |
2034 | ||
2035 | /* dump the stream mapping */ | |
e3245b26 | 2036 | av_log(NULL, AV_LOG_INFO, "Stream mapping:\n"); |
3b266da3 AK |
2037 | for (i = 0; i < nb_input_streams; i++) { |
2038 | ist = input_streams[i]; | |
2039 | ||
2040 | for (j = 0; j < ist->nb_filters; j++) { | |
3b266da3 AK |
2041 | if (ist->filters[j]->graph->graph_desc) { |
2042 | av_log(NULL, AV_LOG_INFO, " Stream #%d:%d (%s) -> %s", | |
2043 | ist->file_index, ist->st->index, ist->dec ? ist->dec->name : "?", | |
cf6c38c6 | 2044 | ist->filters[j]->name); |
3b266da3 AK |
2045 | if (nb_filtergraphs > 1) |
2046 | av_log(NULL, AV_LOG_INFO, " (graph %d)", ist->filters[j]->graph->index); | |
2047 | av_log(NULL, AV_LOG_INFO, "\n"); | |
2048 | } | |
2049 | } | |
2050 | } | |
2051 | ||
e3245b26 | 2052 | for (i = 0; i < nb_output_streams; i++) { |
2e215267 | 2053 | ost = output_streams[i]; |
4dbc6cee AK |
2054 | |
2055 | if (ost->attachment_filename) { | |
2056 | /* an attached file */ | |
2057 | av_log(NULL, AV_LOG_INFO, " File %s -> Stream #%d:%d\n", | |
2058 | ost->attachment_filename, ost->file_index, ost->index); | |
2059 | continue; | |
2060 | } | |
3b266da3 AK |
2061 | |
2062 | if (ost->filter && ost->filter->graph->graph_desc) { | |
2063 | /* output from a complex graph */ | |
cf6c38c6 | 2064 | av_log(NULL, AV_LOG_INFO, " %s", ost->filter->name); |
3b266da3 AK |
2065 | if (nb_filtergraphs > 1) |
2066 | av_log(NULL, AV_LOG_INFO, " (graph %d)", ost->filter->graph->index); | |
2067 | ||
2068 | av_log(NULL, AV_LOG_INFO, " -> Stream #%d:%d (%s)\n", ost->file_index, | |
2069 | ost->index, ost->enc ? ost->enc->name : "?"); | |
2070 | continue; | |
2071 | } | |
2072 | ||
9a414d89 | 2073 | av_log(NULL, AV_LOG_INFO, " Stream #%d:%d -> #%d:%d", |
2e215267 AK |
2074 | input_streams[ost->source_index]->file_index, |
2075 | input_streams[ost->source_index]->st->index, | |
e3245b26 AK |
2076 | ost->file_index, |
2077 | ost->index); | |
2e215267 | 2078 | if (ost->sync_ist != input_streams[ost->source_index]) |
9a414d89 | 2079 | av_log(NULL, AV_LOG_INFO, " [sync #%d:%d]", |
e3245b26 AK |
2080 | ost->sync_ist->file_index, |
2081 | ost->sync_ist->st->index); | |
3d813e4c | 2082 | if (ost->stream_copy) |
e3245b26 AK |
2083 | av_log(NULL, AV_LOG_INFO, " (copy)"); |
2084 | else | |
2e215267 AK |
2085 | av_log(NULL, AV_LOG_INFO, " (%s -> %s)", input_streams[ost->source_index]->dec ? |
2086 | input_streams[ost->source_index]->dec->name : "?", | |
e3245b26 AK |
2087 | ost->enc ? ost->enc->name : "?"); |
2088 | av_log(NULL, AV_LOG_INFO, "\n"); | |
6291d7e4 AK |
2089 | } |
2090 | ||
2091 | if (ret) { | |
e3245b26 | 2092 | av_log(NULL, AV_LOG_ERROR, "%s\n", error); |
eaf2d37a | 2093 | return ret; |
6291d7e4 AK |
2094 | } |
2095 | ||
2096 | if (want_sdp) { | |
ea9367e9 | 2097 | print_sdp(); |
6291d7e4 AK |
2098 | } |
2099 | ||
eaf2d37a AC |
2100 | return 0; |
2101 | } | |
2102 | ||
c1ef30a6 | 2103 | /* Return 1 if there remain streams where more output is wanted, 0 otherwise. */ |
2f51ec2b AK |
2104 | static int need_output(void) |
2105 | { | |
2106 | int i; | |
2107 | ||
2108 | for (i = 0; i < nb_output_streams; i++) { | |
2109 | OutputStream *ost = output_streams[i]; | |
2110 | OutputFile *of = output_files[ost->file_index]; | |
2111 | AVFormatContext *os = output_files[ost->file_index]->ctx; | |
2112 | ||
57d24225 | 2113 | if (ost->finished || |
2f51ec2b AK |
2114 | (os->pb && avio_tell(os->pb) >= of->limit_filesize)) |
2115 | continue; | |
e58b75f7 | 2116 | if (ost->frame_number >= ost->max_frames) { |
2f51ec2b AK |
2117 | int j; |
2118 | for (j = 0; j < of->ctx->nb_streams; j++) | |
57d24225 | 2119 | output_streams[of->ost_index + j]->finished = 1; |
2f51ec2b AK |
2120 | continue; |
2121 | } | |
2122 | ||
2123 | return 1; | |
2124 | } | |
2125 | ||
2126 | return 0; | |
2127 | } | |
2128 | ||
83916029 | 2129 | static InputFile *select_input_file(void) |
a508e7a1 | 2130 | { |
83916029 | 2131 | InputFile *ifile = NULL; |
a508e7a1 | 2132 | int64_t ipts_min = INT64_MAX; |
83916029 | 2133 | int i; |
a508e7a1 AK |
2134 | |
2135 | for (i = 0; i < nb_input_streams; i++) { | |
2136 | InputStream *ist = input_streams[i]; | |
2137 | int64_t ipts = ist->last_dts; | |
2138 | ||
0b26ef42 | 2139 | if (ist->discard || input_files[ist->file_index]->eagain) |
a508e7a1 AK |
2140 | continue; |
2141 | if (!input_files[ist->file_index]->eof_reached) { | |
2142 | if (ipts < ipts_min) { | |
2143 | ipts_min = ipts; | |
83916029 | 2144 | ifile = input_files[ist->file_index]; |
a508e7a1 AK |
2145 | } |
2146 | } | |
2147 | } | |
2148 | ||
83916029 | 2149 | return ifile; |
a508e7a1 AK |
2150 | } |
2151 | ||
47b812e9 | 2152 | #if HAVE_PTHREADS |
5db5169e AK |
2153 | static void *input_thread(void *arg) |
2154 | { | |
2155 | InputFile *f = arg; | |
2156 | int ret = 0; | |
2157 | ||
2158 | while (!transcoding_finished && ret >= 0) { | |
2159 | AVPacket pkt; | |
2160 | ret = av_read_frame(f->ctx, &pkt); | |
2161 | ||
2162 | if (ret == AVERROR(EAGAIN)) { | |
896bb0d7 | 2163 | av_usleep(10000); |
5db5169e AK |
2164 | ret = 0; |
2165 | continue; | |
2166 | } else if (ret < 0) | |
2167 | break; | |
2168 | ||
2169 | pthread_mutex_lock(&f->fifo_lock); | |
2170 | while (!av_fifo_space(f->fifo)) | |
2171 | pthread_cond_wait(&f->fifo_cond, &f->fifo_lock); | |
2172 | ||
2173 | av_dup_packet(&pkt); | |
2174 | av_fifo_generic_write(f->fifo, &pkt, sizeof(pkt), NULL); | |
2175 | ||
2176 | pthread_mutex_unlock(&f->fifo_lock); | |
2177 | } | |
2178 | ||
2179 | f->finished = 1; | |
2180 | return NULL; | |
2181 | } | |
2182 | ||
2183 | static void free_input_threads(void) | |
2184 | { | |
2185 | int i; | |
2186 | ||
2187 | if (nb_input_files == 1) | |
2188 | return; | |
2189 | ||
2190 | transcoding_finished = 1; | |
2191 | ||
2192 | for (i = 0; i < nb_input_files; i++) { | |
2193 | InputFile *f = input_files[i]; | |
2194 | AVPacket pkt; | |
2195 | ||
9034b0ed | 2196 | if (!f->fifo || f->joined) |
5db5169e AK |
2197 | continue; |
2198 | ||
2199 | pthread_mutex_lock(&f->fifo_lock); | |
2200 | while (av_fifo_size(f->fifo)) { | |
2201 | av_fifo_generic_read(f->fifo, &pkt, sizeof(pkt), NULL); | |
2202 | av_free_packet(&pkt); | |
2203 | } | |
2204 | pthread_cond_signal(&f->fifo_cond); | |
2205 | pthread_mutex_unlock(&f->fifo_lock); | |
2206 | ||
2207 | pthread_join(f->thread, NULL); | |
2208 | f->joined = 1; | |
2209 | ||
2210 | while (av_fifo_size(f->fifo)) { | |
2211 | av_fifo_generic_read(f->fifo, &pkt, sizeof(pkt), NULL); | |
2212 | av_free_packet(&pkt); | |
2213 | } | |
2214 | av_fifo_free(f->fifo); | |
2215 | } | |
2216 | } | |
2217 | ||
2218 | static int init_input_threads(void) | |
2219 | { | |
2220 | int i, ret; | |
2221 | ||
2222 | if (nb_input_files == 1) | |
2223 | return 0; | |
2224 | ||
2225 | for (i = 0; i < nb_input_files; i++) { | |
2226 | InputFile *f = input_files[i]; | |
2227 | ||
2228 | if (!(f->fifo = av_fifo_alloc(8*sizeof(AVPacket)))) | |
2229 | return AVERROR(ENOMEM); | |
2230 | ||
2231 | pthread_mutex_init(&f->fifo_lock, NULL); | |
2232 | pthread_cond_init (&f->fifo_cond, NULL); | |
2233 | ||
2234 | if ((ret = pthread_create(&f->thread, NULL, input_thread, f))) | |
2235 | return AVERROR(ret); | |
2236 | } | |
2237 | return 0; | |
2238 | } | |
2239 | ||
2240 | static int get_input_packet_mt(InputFile *f, AVPacket *pkt) | |
2241 | { | |
2242 | int ret = 0; | |
2243 | ||
2244 | pthread_mutex_lock(&f->fifo_lock); | |
2245 | ||
2246 | if (av_fifo_size(f->fifo)) { | |
2247 | av_fifo_generic_read(f->fifo, pkt, sizeof(*pkt), NULL); | |
2248 | pthread_cond_signal(&f->fifo_cond); | |
2249 | } else { | |
2250 | if (f->finished) | |
2251 | ret = AVERROR_EOF; | |
2252 | else | |
2253 | ret = AVERROR(EAGAIN); | |
2254 | } | |
2255 | ||
2256 | pthread_mutex_unlock(&f->fifo_lock); | |
2257 | ||
2258 | return ret; | |
2259 | } | |
2260 | #endif | |
2261 | ||
2262 | static int get_input_packet(InputFile *f, AVPacket *pkt) | |
2263 | { | |
b4a5a292 AK |
2264 | if (f->rate_emu) { |
2265 | int i; | |
2266 | for (i = 0; i < f->nb_streams; i++) { | |
2267 | InputStream *ist = input_streams[f->ist_index + i]; | |
2268 | int64_t pts = av_rescale(ist->last_dts, 1000000, AV_TIME_BASE); | |
2269 | int64_t now = av_gettime() - ist->start; | |
2270 | if (pts > now) | |
2271 | return AVERROR(EAGAIN); | |
2272 | } | |
2273 | } | |
2274 | ||
47b812e9 | 2275 | #if HAVE_PTHREADS |
5db5169e AK |
2276 | if (nb_input_files > 1) |
2277 | return get_input_packet_mt(f, pkt); | |
2278 | #endif | |
2279 | return av_read_frame(f->ctx, pkt); | |
2280 | } | |
2281 | ||
0b26ef42 AK |
2282 | static int got_eagain(void) |
2283 | { | |
2284 | int i; | |
2285 | for (i = 0; i < nb_input_files; i++) | |
2286 | if (input_files[i]->eagain) | |
2287 | return 1; | |
2288 | return 0; | |
2289 | } | |
2290 | ||
2291 | static void reset_eagain(void) | |
2292 | { | |
2293 | int i; | |
2294 | for (i = 0; i < nb_input_files; i++) | |
2295 | input_files[i]->eagain = 0; | |
2296 | } | |
2297 | ||
c1ef30a6 | 2298 | /* |
0c00fd80 AK |
2299 | * Read one packet from an input file and send it for |
2300 | * - decoding -> lavfi (audio/video) | |
2301 | * - decoding -> encoding -> muxing (subtitles) | |
2302 | * - muxing (streamcopy) | |
2303 | * | |
c1ef30a6 | 2304 | * Return |
0c00fd80 AK |
2305 | * - 0 -- one packet was read and processed |
2306 | * - AVERROR(EAGAIN) -- no packets were available for selected file, | |
2307 | * this function should be called again | |
2308 | * - AVERROR_EOF -- this function should not be called again | |
2309 | */ | |
2310 | static int process_input(void) | |
2311 | { | |
2312 | InputFile *ifile; | |
2313 | AVFormatContext *is; | |
2314 | InputStream *ist; | |
2315 | AVPacket pkt; | |
2316 | int ret, i, j; | |
2317 | ||
2318 | /* select the stream that we must read now */ | |
2319 | ifile = select_input_file(); | |
2320 | /* if none, if is finished */ | |
2321 | if (!ifile) { | |
2322 | if (got_eagain()) { | |
2323 | reset_eagain(); | |
2324 | av_usleep(10000); | |
2325 | return AVERROR(EAGAIN); | |
2326 | } | |
2327 | av_log(NULL, AV_LOG_VERBOSE, "No more inputs to read from.\n"); | |
2328 | return AVERROR_EOF; | |
2329 | } | |
2330 | ||
2331 | is = ifile->ctx; | |
2332 | ret = get_input_packet(ifile, &pkt); | |
2333 | ||
2334 | if (ret == AVERROR(EAGAIN)) { | |
2335 | ifile->eagain = 1; | |
2336 | return ret; | |
2337 | } | |
2338 | if (ret < 0) { | |
2339 | if (ret != AVERROR_EOF) { | |
2340 | print_error(is->filename, ret); | |
2341 | if (exit_on_error) | |
636ced8e | 2342 | exit_program(1); |
0c00fd80 AK |
2343 | } |
2344 | ifile->eof_reached = 1; | |
2345 | ||
2346 | for (i = 0; i < ifile->nb_streams; i++) { | |
2347 | ist = input_streams[ifile->ist_index + i]; | |
2348 | if (ist->decoding_needed) | |
2349 | output_packet(ist, NULL); | |
2350 | ||
2351 | /* mark all outputs that don't go through lavfi as finished */ | |
2352 | for (j = 0; j < nb_output_streams; j++) { | |
2353 | OutputStream *ost = output_streams[j]; | |
2354 | ||
2355 | if (ost->source_index == ifile->ist_index + i && | |
2356 | (ost->stream_copy || ost->enc->type == AVMEDIA_TYPE_SUBTITLE)) | |
57d24225 | 2357 | ost->finished= 1; |
0c00fd80 AK |
2358 | } |
2359 | } | |
2360 | ||
3c0df905 | 2361 | return AVERROR(EAGAIN); |
0c00fd80 AK |
2362 | } |
2363 | ||
2364 | reset_eagain(); | |
2365 | ||
2366 | if (do_pkt_dump) { | |
2367 | av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump, | |
2368 | is->streams[pkt.stream_index]); | |
2369 | } | |
2370 | /* the following test is needed in case new streams appear | |
2371 | dynamically in stream : we ignore them */ | |
2372 | if (pkt.stream_index >= ifile->nb_streams) | |
2373 | goto discard_packet; | |
2374 | ||
2375 | ist = input_streams[ifile->ist_index + pkt.stream_index]; | |
47543450 AK |
2376 | |
2377 | ist->data_size += pkt.size; | |
59444c76 | 2378 | ist->nb_packets++; |
47543450 | 2379 | |
0c00fd80 AK |
2380 | if (ist->discard) |
2381 | goto discard_packet; | |
2382 | ||
59444c76 AK |
2383 | /* add the stream-global side data to the first packet */ |
2384 | if (ist->nb_packets == 1) | |
2385 | for (i = 0; i < ist->st->nb_side_data; i++) { | |
2386 | AVPacketSideData *src_sd = &ist->st->side_data[i]; | |
2387 | uint8_t *dst_data; | |
2388 | ||
2389 | if (av_packet_get_side_data(&pkt, src_sd->type, NULL)) | |
2390 | continue; | |
2391 | ||
2392 | dst_data = av_packet_new_side_data(&pkt, src_sd->type, src_sd->size); | |
2393 | if (!dst_data) | |
2394 | exit_program(1); | |
2395 | ||
2396 | memcpy(dst_data, src_sd->data, src_sd->size); | |
2397 | } | |
2398 | ||
0c00fd80 AK |
2399 | if (pkt.dts != AV_NOPTS_VALUE) |
2400 | pkt.dts += av_rescale_q(ifile->ts_offset, AV_TIME_BASE_Q, ist->st->time_base); | |
2401 | if (pkt.pts != AV_NOPTS_VALUE) | |
2402 | pkt.pts += av_rescale_q(ifile->ts_offset, AV_TIME_BASE_Q, ist->st->time_base); | |
2403 | ||
2404 | if (pkt.pts != AV_NOPTS_VALUE) | |
2405 | pkt.pts *= ist->ts_scale; | |
2406 | if (pkt.dts != AV_NOPTS_VALUE) | |
2407 | pkt.dts *= ist->ts_scale; | |
2408 | ||
2409 | if (pkt.dts != AV_NOPTS_VALUE && ist->next_dts != AV_NOPTS_VALUE && | |
2410 | (is->iformat->flags & AVFMT_TS_DISCONT)) { | |
2411 | int64_t pkt_dts = av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q); | |
2412 | int64_t delta = pkt_dts - ist->next_dts; | |
2413 | ||
2414 | if ((FFABS(delta) > 1LL * dts_delta_threshold * AV_TIME_BASE || pkt_dts + 1 < ist->last_dts) && !copy_ts) { | |
2415 | ifile->ts_offset -= delta; | |
2416 | av_log(NULL, AV_LOG_DEBUG, | |
2417 | "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", | |
2418 | delta, ifile->ts_offset); | |
2419 | pkt.dts -= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base); | |
2420 | if (pkt.pts != AV_NOPTS_VALUE) | |
2421 | pkt.pts -= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base); | |
2422 | } | |
2423 | } | |
2424 | ||
2425 | ret = output_packet(ist, &pkt); | |
2426 | if (ret < 0) { | |
2427 | av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d:%d\n", | |
2428 | ist->file_index, ist->st->index); | |
2429 | if (exit_on_error) | |
636ced8e | 2430 | exit_program(1); |
0c00fd80 AK |
2431 | } |
2432 | ||
2433 | discard_packet: | |
2434 | av_free_packet(&pkt); | |
2435 | ||
2436 | return 0; | |
2437 | } | |
2438 | ||
eaf2d37a AC |
2439 | /* |
2440 | * The following code is the main loop of the file converter | |
2441 | */ | |
ea9367e9 | 2442 | static int transcode(void) |
eaf2d37a | 2443 | { |
0c00fd80 AK |
2444 | int ret, i, need_input = 1; |
2445 | AVFormatContext *os; | |
eaf2d37a AC |
2446 | OutputStream *ost; |
2447 | InputStream *ist; | |
eaf2d37a AC |
2448 | int64_t timer_start; |
2449 | ||
ea9367e9 | 2450 | ret = transcode_init(); |
eaf2d37a AC |
2451 | if (ret < 0) |
2452 | goto fail; | |
2453 | ||
e3245b26 | 2454 | av_log(NULL, AV_LOG_INFO, "Press ctrl-c to stop encoding\n"); |
6291d7e4 AK |
2455 | term_init(); |
2456 | ||
2457 | timer_start = av_gettime(); | |
2458 | ||
47b812e9 | 2459 | #if HAVE_PTHREADS |
5db5169e AK |
2460 | if ((ret = init_input_threads()) < 0) |
2461 | goto fail; | |
2462 | #endif | |
2463 | ||
c0fbf971 | 2464 | while (!received_sigterm) { |
3b266da3 | 2465 | /* check if there's any stream where output is still needed */ |
2f51ec2b AK |
2466 | if (!need_output()) { |
2467 | av_log(NULL, AV_LOG_VERBOSE, "No more output streams to write to, finishing.\n"); | |
3b266da3 | 2468 | break; |
2f51ec2b | 2469 | } |
3b266da3 | 2470 | |
0c00fd80 AK |
2471 | /* read and process one input packet if needed */ |
2472 | if (need_input) { | |
2473 | ret = process_input(); | |
2474 | if (ret == AVERROR_EOF) | |
2475 | need_input = 0; | |
6291d7e4 AK |
2476 | } |
2477 | ||
0c00fd80 | 2478 | ret = poll_filters(); |
6291d7e4 | 2479 | if (ret < 0) { |
0c00fd80 | 2480 | if (ret == AVERROR_EOF || ret == AVERROR(EAGAIN)) |
6291d7e4 | 2481 | continue; |
6291d7e4 | 2482 | |
0c00fd80 AK |
2483 | av_log(NULL, AV_LOG_ERROR, "Error while filtering.\n"); |
2484 | break; | |
6291d7e4 AK |
2485 | } |
2486 | ||
6291d7e4 | 2487 | /* dump report by using the output first video and audio streams */ |
ea9367e9 | 2488 | print_report(0, timer_start); |
6291d7e4 | 2489 | } |
47b812e9 | 2490 | #if HAVE_PTHREADS |
5db5169e AK |
2491 | free_input_threads(); |
2492 | #endif | |
6291d7e4 AK |
2493 | |
2494 | /* at the end of stream, we must flush the decoder buffers */ | |
2495 | for (i = 0; i < nb_input_streams; i++) { | |
2e215267 | 2496 | ist = input_streams[i]; |
9e8aae44 | 2497 | if (!input_files[ist->file_index]->eof_reached && ist->decoding_needed) { |
ea9367e9 | 2498 | output_packet(ist, NULL); |
6291d7e4 AK |
2499 | } |
2500 | } | |
560f7774 | 2501 | poll_filters(); |
ea9367e9 | 2502 | flush_encoders(); |
6291d7e4 AK |
2503 | |
2504 | term_exit(); | |
2505 | ||
2506 | /* write the trailer if needed and close file */ | |
7636c8c6 | 2507 | for (i = 0; i < nb_output_files; i++) { |
2e215267 | 2508 | os = output_files[i]->ctx; |
6291d7e4 AK |
2509 | av_write_trailer(os); |
2510 | } | |
2511 | ||
2512 | /* dump report by using the first video and audio streams */ | |
ea9367e9 | 2513 | print_report(1, timer_start); |
6291d7e4 AK |
2514 | |
2515 | /* close each encoder */ | |
4288e031 | 2516 | for (i = 0; i < nb_output_streams; i++) { |
2e215267 | 2517 | ost = output_streams[i]; |
6291d7e4 | 2518 | if (ost->encoding_needed) { |
38313626 | 2519 | av_freep(&ost->enc_ctx->stats_in); |
6291d7e4 | 2520 | } |
6291d7e4 AK |
2521 | } |
2522 | ||
2523 | /* close each decoder */ | |
2524 | for (i = 0; i < nb_input_streams; i++) { | |
2e215267 | 2525 | ist = input_streams[i]; |
6291d7e4 | 2526 | if (ist->decoding_needed) { |
41776ba9 | 2527 | avcodec_close(ist->dec_ctx); |
07fd0a22 | 2528 | if (ist->hwaccel_uninit) |
41776ba9 | 2529 | ist->hwaccel_uninit(ist->dec_ctx); |
6291d7e4 AK |
2530 | } |
2531 | } | |
2532 | ||
2533 | /* finished ! */ | |
2534 | ret = 0; | |
2535 | ||
2536 | fail: | |
47b812e9 | 2537 | #if HAVE_PTHREADS |
5db5169e AK |
2538 | free_input_threads(); |
2539 | #endif | |
6291d7e4 | 2540 | |
4288e031 AK |
2541 | if (output_streams) { |
2542 | for (i = 0; i < nb_output_streams; i++) { | |
2e215267 | 2543 | ost = output_streams[i]; |
6291d7e4 | 2544 | if (ost) { |
6291d7e4 AK |
2545 | if (ost->logfile) { |
2546 | fclose(ost->logfile); | |
2547 | ost->logfile = NULL; | |
2548 | } | |
6291d7e4 | 2549 | av_free(ost->forced_kf_pts); |
9580818c | 2550 | av_dict_free(&ost->encoder_opts); |
5c7db097 | 2551 | av_dict_free(&ost->resample_opts); |
6291d7e4 AK |
2552 | } |
2553 | } | |
6291d7e4 AK |
2554 | } |
2555 | return ret; | |
2556 | } | |
2557 | ||
f5e66827 | 2558 | static int64_t getutime(void) |
a2c0b830 | 2559 | { |
f5e66827 AK |
2560 | #if HAVE_GETRUSAGE |
2561 | struct rusage rusage; | |
a2c0b830 | 2562 | |
f5e66827 AK |
2563 | getrusage(RUSAGE_SELF, &rusage); |
2564 | return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec; | |
2565 | #elif HAVE_GETPROCESSTIMES | |
2566 | HANDLE proc; | |
2567 | FILETIME c, e, k, u; | |
2568 | proc = GetCurrentProcess(); | |
2569 | GetProcessTimes(proc, &c, &e, &k, &u); | |
2570 | return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10; | |
2571 | #else | |
2572 | return av_gettime(); | |
2573 | #endif | |
a2c0b830 AK |
2574 | } |
2575 | ||
f5e66827 | 2576 | static int64_t getmaxrss(void) |
6291d7e4 | 2577 | { |
f5e66827 AK |
2578 | #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS |
2579 | struct rusage rusage; | |
2580 | getrusage(RUSAGE_SELF, &rusage); | |
2581 | return (int64_t)rusage.ru_maxrss * 1024; | |
2582 | #elif HAVE_GETPROCESSMEMORYINFO | |
2583 | HANDLE proc; | |
2584 | PROCESS_MEMORY_COUNTERS memcounters; | |
2585 | proc = GetCurrentProcess(); | |
2586 | memcounters.cb = sizeof(memcounters); | |
2587 | GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters)); | |
2588 | return memcounters.PeakPagefileUsage; | |
2589 | #else | |
6291d7e4 | 2590 | return 0; |
f5e66827 | 2591 | #endif |
6291d7e4 AK |
2592 | } |
2593 | ||
6291d7e4 AK |
2594 | int main(int argc, char **argv) |
2595 | { | |
77bd1bc7 | 2596 | int ret; |
6291d7e4 AK |
2597 | int64_t ti; |
2598 | ||
636ced8e | 2599 | register_exit(avconv_cleanup); |
5e3f9979 | 2600 | |
6291d7e4 | 2601 | av_log_set_flags(AV_LOG_SKIP_REPEATED); |
182cbe43 | 2602 | parse_loglevel(argc, argv, options); |
6291d7e4 AK |
2603 | |
2604 | avcodec_register_all(); | |
2605 | #if CONFIG_AVDEVICE | |
2606 | avdevice_register_all(); | |
2607 | #endif | |
6291d7e4 | 2608 | avfilter_register_all(); |
6291d7e4 | 2609 | av_register_all(); |
776f2bb9 | 2610 | avformat_network_init(); |
6291d7e4 | 2611 | |
6291d7e4 AK |
2612 | show_banner(); |
2613 | ||
77bd1bc7 AK |
2614 | /* parse options and open all input/output files */ |
2615 | ret = avconv_parse_options(argc, argv); | |
2616 | if (ret < 0) | |
636ced8e | 2617 | exit_program(1); |
6291d7e4 | 2618 | |
7636c8c6 | 2619 | if (nb_output_files <= 0 && nb_input_files == 0) { |
6291d7e4 | 2620 | show_usage(); |
e3245b26 | 2621 | av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name); |
636ced8e | 2622 | exit_program(1); |
6291d7e4 AK |
2623 | } |
2624 | ||
2625 | /* file converter / grab */ | |
2626 | if (nb_output_files <= 0) { | |
2627 | fprintf(stderr, "At least one output file must be specified\n"); | |
636ced8e | 2628 | exit_program(1); |
6291d7e4 AK |
2629 | } |
2630 | ||
6291d7e4 | 2631 | ti = getutime(); |
ea9367e9 | 2632 | if (transcode() < 0) |
636ced8e | 2633 | exit_program(1); |
6291d7e4 AK |
2634 | ti = getutime() - ti; |
2635 | if (do_benchmark) { | |
2636 | int maxrss = getmaxrss() / 1024; | |
2637 | printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss); | |
2638 | } | |
2639 | ||
636ced8e | 2640 | exit_program(0); |
dad09ff9 | 2641 | return 0; |
6291d7e4 | 2642 | } |