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