vp9: add superframe merging bitstream filter.
[libav.git] / ffmpeg.c
CommitLineData
85f07f22 1/*
01310af2 2 * Copyright (c) 2000-2003 Fabrice Bellard
85f07f22 3 *
b78e7197
DB
4 * This file is part of FFmpeg.
5 *
6 * FFmpeg is free software; you can redistribute it and/or
bf5af568
FB
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
b78e7197 9 * version 2.1 of the License, or (at your option) any later version.
85f07f22 10 *
b78e7197 11 * FFmpeg is distributed in the hope that it will be useful,
85f07f22 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
bf5af568
FB
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
85f07f22 15 *
bf5af568 16 * You should have received a copy of the GNU Lesser General Public
b78e7197 17 * License along with FFmpeg; if not, write to the Free Software
5509bffa 18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
85f07f22 19 */
364a9607 20
93613338
SS
21/**
22 * @file
23 * multimedia converter based on the FFmpeg libraries
24 */
25
0f4e8165
RB
26#include "config.h"
27#include <ctype.h>
28#include <string.h>
29#include <math.h>
30#include <stdlib.h>
31#include <errno.h>
22f7a060 32#include <limits.h>
8f8bc923
DB
33#include <stdint.h>
34
23a5a24c
DB
35#if HAVE_IO_H
36#include <io.h>
37#endif
38#if HAVE_UNISTD_H
7246177d 39#include <unistd.h>
e847f412 40#endif
ccdfa3e2 41
245976da
DB
42#include "libavformat/avformat.h"
43#include "libavdevice/avdevice.h"
eb945ab4 44#include "libswresample/swresample.h"
41d0eb1c 45#include "libavutil/opt.h"
a903f8f0 46#include "libavutil/channel_layout.h"
7ffe76e5
RT
47#include "libavutil/parseutils.h"
48#include "libavutil/samplefmt.h"
245976da 49#include "libavutil/fifo.h"
495eee01 50#include "libavutil/internal.h"
2839dc97 51#include "libavutil/intreadwrite.h"
d2d67e42 52#include "libavutil/dict.h"
0ebcdf5c 53#include "libavutil/mathematics.h"
718c7b18 54#include "libavutil/pixdesc.h"
245976da 55#include "libavutil/avstring.h"
335ee1aa 56#include "libavutil/libm.h"
484e59a0 57#include "libavutil/imgutils.h"
5d12b83f 58#include "libavutil/timestamp.h"
fa29ca5f 59#include "libavutil/bprint.h"
896bb0d7 60#include "libavutil/time.h"
fc9c857c 61#include "libavutil/threadmessage.h"
98c7729c 62#include "libavcodec/mathops.h"
245976da 63#include "libavformat/os_support.h"
daf8e955 64
46847a33 65# include "libavfilter/avfilter.h"
484e59a0 66# include "libavfilter/buffersrc.h"
eb945ab4 67# include "libavfilter/buffersink.h"
46847a33 68
b250f9c6 69#if HAVE_SYS_RESOURCE_H
3f65eff4 70#include <sys/time.h>
0a1b29de 71#include <sys/types.h>
b091aa44 72#include <sys/resource.h>
b250f9c6 73#elif HAVE_GETPROCESSTIMES
7495c306
RP
74#include <windows.h>
75#endif
fc5607f8
RD
76#if HAVE_GETPROCESSMEMORYINFO
77#include <windows.h>
78#include <psapi.h>
79#endif
4ebb43f1 80#if HAVE_SETCONSOLECTRLHANDLER
81#include <windows.h>
82#endif
83
7495c306 84
b250f9c6 85#if HAVE_SYS_SELECT_H
fb1d2d7b
BC
86#include <sys/select.h>
87#endif
88
8b8bf89e
MN
89#if HAVE_TERMIOS_H
90#include <fcntl.h>
91#include <sys/ioctl.h>
92#include <sys/time.h>
93#include <termios.h>
94#elif HAVE_KBHIT
4b54c6d0 95#include <conio.h>
bdc4796f 96#endif
3630a075 97
5db5169e
AK
98#if HAVE_PTHREADS
99#include <pthread.h>
5db5169e
AK
100#endif
101
bf5af568 102#include <time.h>
85f07f22 103
11a1033c 104#include "ffmpeg.h"
01310af2
FB
105#include "cmdutils.h"
106
b64b4134 107#include "libavutil/avassert.h"
2b18dcd0 108
89b503b5 109const char program_name[] = "ffmpeg";
ea9c581f 110const int program_birth_year = 2000;
86074ed1 111
032aa7df 112static FILE *vstats_file;
5abdb4b1 113
43af18ef
SS
114const char *const forced_keyframes_const_names[] = {
115 "n",
116 "n_forced",
117 "prev_forced_n",
118 "prev_forced_t",
119 "t",
120 NULL
121};
122
cd379636 123static void do_video_stats(OutputStream *ost, int frame_size);
11a1033c 124static int64_t getutime(void);
4ae74c63 125static int64_t getmaxrss(void);
8aa3ee32 126
3c483620 127static int run_as_daemon = 0;
a6a92a9a
WG
128static int nb_frames_dup = 0;
129static int nb_frames_drop = 0;
eedcac68 130static int64_t decode_error_stat[2];
d9a916e2 131
733cf0ad 132static int current_time;
11a1033c 133AVIOContext *progress_avio = NULL;
8bbf6db9 134
f926d916
CB
135static uint8_t *subtitle_out;
136
f5e66827
AK
137InputStream **input_streams = NULL;
138int nb_input_streams = 0;
139InputFile **input_files = NULL;
140int nb_input_files = 0;
5db5169e 141
f5e66827
AK
142OutputStream **output_streams = NULL;
143int nb_output_streams = 0;
144OutputFile **output_files = NULL;
145int nb_output_files = 0;
85f07f22 146
f5e66827
AK
147FilterGraph **filtergraphs;
148int nb_filtergraphs;
85f07f22 149
8b8bf89e
MN
150#if HAVE_TERMIOS_H
151
152/* init terminal so that we can grab keys */
153static struct termios oldtty;
71a2c9b2 154static int restore_tty;
8b8bf89e
MN
155#endif
156
1fa637d2 157#if HAVE_PTHREADS
1a36c756 158static void free_input_threads(void);
1fa637d2 159#endif
733cf0ad 160
88fc1438
NG
161/* sub2video hack:
162 Convert subtitles to video with alpha to insert them in filter graphs.
163 This is a temporary solution until libavfilter gets real subtitles support.
164 */
165
f9b34b8b
NG
166static int sub2video_get_blank_frame(InputStream *ist)
167{
168 int ret;
169 AVFrame *frame = ist->sub2video.frame;
170
171 av_frame_unref(frame);
4ada49f9
MN
172 ist->sub2video.frame->width = ist->dec_ctx->width ? ist->dec_ctx->width : ist->sub2video.w;
173 ist->sub2video.frame->height = ist->dec_ctx->height ? ist->dec_ctx->height : ist->sub2video.h;
f9b34b8b
NG
174 ist->sub2video.frame->format = AV_PIX_FMT_RGB32;
175 if ((ret = av_frame_get_buffer(frame, 32)) < 0)
176 return ret;
177 memset(frame->data[0], 0, frame->height * frame->linesize[0]);
178 return 0;
179}
88fc1438
NG
180
181static void sub2video_copy_rect(uint8_t *dst, int dst_linesize, int w, int h,
182 AVSubtitleRect *r)
183{
184 uint32_t *pal, *dst2;
185 uint8_t *src, *src2;
186 int x, y;
187
188 if (r->type != SUBTITLE_BITMAP) {
189 av_log(NULL, AV_LOG_WARNING, "sub2video: non-bitmap subtitle\n");
190 return;
191 }
192 if (r->x < 0 || r->x + r->w > w || r->y < 0 || r->y + r->h > h) {
0ac83047
MN
193 av_log(NULL, AV_LOG_WARNING, "sub2video: rectangle (%d %d %d %d) overflowing %d %d\n",
194 r->x, r->y, r->w, r->h, w, h
195 );
88fc1438
NG
196 return;
197 }
198
199 dst += r->y * dst_linesize + r->x * 4;
200 src = r->pict.data[0];
201 pal = (uint32_t *)r->pict.data[1];
202 for (y = 0; y < r->h; y++) {
203 dst2 = (uint32_t *)dst;
204 src2 = src;
205 for (x = 0; x < r->w; x++)
206 *(dst2++) = pal[*(src2++)];
207 dst += dst_linesize;
208 src += r->pict.linesize[0];
209 }
210}
211
212static void sub2video_push_ref(InputStream *ist, int64_t pts)
213{
f9b34b8b 214 AVFrame *frame = ist->sub2video.frame;
88fc1438
NG
215 int i;
216
f9b34b8b
NG
217 av_assert1(frame->data[0]);
218 ist->sub2video.last_pts = frame->pts = pts;
88fc1438 219 for (i = 0; i < ist->nb_filters; i++)
fb14e37d
NG
220 av_buffersrc_add_frame_flags(ist->filters[i]->filter, frame,
221 AV_BUFFERSRC_FLAG_KEEP_REF |
222 AV_BUFFERSRC_FLAG_PUSH);
88fc1438
NG
223}
224
a9e48177 225static void sub2video_update(InputStream *ist, AVSubtitle *sub)
88fc1438 226{
f9b34b8b 227 AVFrame *frame = ist->sub2video.frame;
88fc1438
NG
228 int8_t *dst;
229 int dst_linesize;
0f236345
NG
230 int num_rects, i;
231 int64_t pts, end_pts;
88fc1438 232
f9b34b8b 233 if (!frame)
88fc1438 234 return;
0f236345 235 if (sub) {
59975de7 236 pts = av_rescale_q(sub->pts + sub->start_display_time * 1000LL,
0f236345 237 AV_TIME_BASE_Q, ist->st->time_base);
59975de7 238 end_pts = av_rescale_q(sub->pts + sub->end_display_time * 1000LL,
0f236345
NG
239 AV_TIME_BASE_Q, ist->st->time_base);
240 num_rects = sub->num_rects;
241 } else {
242 pts = ist->sub2video.end_pts;
243 end_pts = INT64_MAX;
244 num_rects = 0;
245 }
f9b34b8b 246 if (sub2video_get_blank_frame(ist) < 0) {
921d5ae3 247 av_log(ist->dec_ctx, AV_LOG_ERROR,
f9b34b8b
NG
248 "Impossible to get a blank canvas.\n");
249 return;
250 }
251 dst = frame->data [0];
252 dst_linesize = frame->linesize[0];
0f236345 253 for (i = 0; i < num_rects; i++)
bd5d11d9 254 sub2video_copy_rect(dst, dst_linesize, frame->width, frame->height, sub->rects[i]);
88fc1438 255 sub2video_push_ref(ist, pts);
0f236345 256 ist->sub2video.end_pts = end_pts;
88fc1438
NG
257}
258
259static void sub2video_heartbeat(InputStream *ist, int64_t pts)
260{
261 InputFile *infile = input_files[ist->file_index];
262 int i, j, nb_reqs;
263 int64_t pts2;
264
265 /* When a frame is read from a file, examine all sub2video streams in
266 the same file and send the sub2video frame again. Otherwise, decoded
267 video frames could be accumulating in the filter graph while a filter
268 (possibly overlay) is desperately waiting for a subtitle frame. */
269 for (i = 0; i < infile->nb_streams; i++) {
270 InputStream *ist2 = input_streams[infile->ist_index + i];
f9b34b8b 271 if (!ist2->sub2video.frame)
88fc1438
NG
272 continue;
273 /* subtitles seem to be usually muxed ahead of other streams;
88f2586a 274 if not, subtracting a larger time here is necessary */
88fc1438
NG
275 pts2 = av_rescale_q(pts, ist->st->time_base, ist2->st->time_base) - 1;
276 /* do not send the heartbeat frame if the subtitle is already ahead */
277 if (pts2 <= ist2->sub2video.last_pts)
278 continue;
f9b34b8b 279 if (pts2 >= ist2->sub2video.end_pts || !ist2->sub2video.frame->data[0])
0f236345 280 sub2video_update(ist2, NULL);
88fc1438
NG
281 for (j = 0, nb_reqs = 0; j < ist2->nb_filters; j++)
282 nb_reqs += av_buffersrc_get_nb_failed_requests(ist2->filters[j]->filter);
283 if (nb_reqs)
284 sub2video_push_ref(ist2, pts2);
285 }
286}
287
288static void sub2video_flush(InputStream *ist)
289{
290 int i;
291
521707d4
NG
292 if (ist->sub2video.end_pts < INT64_MAX)
293 sub2video_update(ist, NULL);
88fc1438 294 for (i = 0; i < ist->nb_filters; i++)
fbc8eb68 295 av_buffersrc_add_frame(ist->filters[i]->filter, NULL);
88fc1438
NG
296}
297
298/* end of sub2video hack */
299
d3ed8a4d 300static void term_exit_sigsafe(void)
d2084402 301{
11a1033c
MN
302#if HAVE_TERMIOS_H
303 if(restore_tty)
304 tcsetattr (0, TCSANOW, &oldtty);
305#endif
6291d7e4 306}
d2084402 307
d3ed8a4d
MN
308void term_exit(void)
309{
310 av_log(NULL, AV_LOG_QUIET, "%s", "");
311 term_exit_sigsafe();
312}
313
6291d7e4 314static volatile int received_sigterm = 0;
2cdb0810 315static volatile int received_nb_signals = 0;
517cc81e 316static volatile int transcode_init_done = 0;
4ebb43f1 317static volatile int ffmpeg_exited = 0;
706741e8 318static int main_return_code = 0;
d2084402 319
2cdb0810
MN
320static void
321sigterm_handler(int sig)
6291d7e4
AK
322{
323 received_sigterm = sig;
324 received_nb_signals++;
d3ed8a4d 325 term_exit_sigsafe();
1bcdac2d 326 if(received_nb_signals > 3) {
8c22143e
MN
327 write(2/*STDERR_FILENO*/, "Received > 3 system signals, hard exiting\n",
328 strlen("Received > 3 system signals, hard exiting\n"));
329
9dca02ee 330 exit(123);
1bcdac2d 331 }
d2084402
MN
332}
333
4ebb43f1 334#if HAVE_SETCONSOLECTRLHANDLER
335static BOOL WINAPI CtrlHandler(DWORD fdwCtrlType)
336{
337 av_log(NULL, AV_LOG_DEBUG, "\nReceived windows signal %ld\n", fdwCtrlType);
338
339 switch (fdwCtrlType)
340 {
341 case CTRL_C_EVENT:
342 case CTRL_BREAK_EVENT:
343 sigterm_handler(SIGINT);
344 return TRUE;
345
346 case CTRL_CLOSE_EVENT:
347 case CTRL_LOGOFF_EVENT:
348 case CTRL_SHUTDOWN_EVENT:
349 sigterm_handler(SIGTERM);
350 /* Basically, with these 3 events, when we return from this method the
351 process is hard terminated, so stall as long as we need to
352 to try and let the main thread(s) clean up and gracefully terminate
353 (we have at most 5 seconds, but should be done far before that). */
354 while (!ffmpeg_exited) {
355 Sleep(0);
356 }
357 return TRUE;
358
359 default:
360 av_log(NULL, AV_LOG_ERROR, "Received unknown windows signal %ld\n", fdwCtrlType);
361 return FALSE;
362 }
363}
364#endif
365
11a1033c 366void term_init(void)
46847a33 367{
11a1033c
MN
368#if HAVE_TERMIOS_H
369 if(!run_as_daemon){
370 struct termios tty;
3ae98497 371 if (tcgetattr (0, &tty) == 0) {
11a1033c
MN
372 oldtty = tty;
373 restore_tty = 1;
11a1033c
MN
374
375 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
376 |INLCR|IGNCR|ICRNL|IXON);
377 tty.c_oflag |= OPOST;
378 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
379 tty.c_cflag &= ~(CSIZE|PARENB);
380 tty.c_cflag |= CS8;
381 tty.c_cc[VMIN] = 1;
382 tty.c_cc[VTIME] = 0;
383
384 tcsetattr (0, TCSANOW, &tty);
47787831 385 }
11a1033c 386 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
47787831 387 }
11a1033c 388#endif
11a1033c 389
7636c8c6 390 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
6291d7e4
AK
391 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
392#ifdef SIGXCPU
393 signal(SIGXCPU, sigterm_handler);
394#endif
4ebb43f1 395#if HAVE_SETCONSOLECTRLHANDLER
396 SetConsoleCtrlHandler((PHANDLER_ROUTINE) CtrlHandler, TRUE);
397#endif
47787831
MN
398}
399
11a1033c
MN
400/* read a key without blocking */
401static int read_key(void)
b7327887 402{
11a1033c
MN
403 unsigned char ch;
404#if HAVE_TERMIOS_H
405 int n = 1;
406 struct timeval tv;
407 fd_set rfds;
ac712309 408
11a1033c
MN
409 FD_ZERO(&rfds);
410 FD_SET(0, &rfds);
411 tv.tv_sec = 0;
412 tv.tv_usec = 0;
413 n = select(1, &rfds, NULL, NULL, &tv);
414 if (n > 0) {
415 n = read(0, &ch, 1);
416 if (n == 1)
417 return ch;
418
419 return n;
420 }
421#elif HAVE_KBHIT
422# if HAVE_PEEKNAMEDPIPE
423 static int is_pipe;
424 static HANDLE input_handle;
425 DWORD dw, nchars;
426 if(!input_handle){
427 input_handle = GetStdHandle(STD_INPUT_HANDLE);
428 is_pipe = !GetConsoleMode(input_handle, &dw);
429 }
61930bd0 430
11a1033c
MN
431 if (is_pipe) {
432 /* When running under a GUI, you will end here. */
40648d8c 433 if (!PeekNamedPipe(input_handle, NULL, 0, NULL, &nchars, NULL)) {
434 // input pipe may have been closed by the program that ran ffmpeg
11a1033c 435 return -1;
40648d8c 436 }
11a1033c
MN
437 //Read it
438 if(nchars != 0) {
439 read(0, &ch, 1);
440 return ch;
441 }else{
442 return -1;
fc49f22c 443 }
11a1033c
MN
444 }
445# endif
446 if(kbhit())
447 return(getch());
448#endif
449 return -1;
b7327887
AK
450}
451
2abe947a 452static int decode_interrupt_cb(void *ctx)
6291d7e4 453{
517cc81e 454 return received_nb_signals > transcode_init_done;
fc49f22c
AK
455}
456
f5e66827 457const AVIOInterruptCB int_cb = { decode_interrupt_cb, NULL };
fc49f22c 458
f982d006 459static void ffmpeg_cleanup(int ret)
6291d7e4 460{
560f7774 461 int i, j;
fc49f22c 462
4ae74c63
MN
463 if (do_benchmark) {
464 int maxrss = getmaxrss() / 1024;
2c7f7a69 465 av_log(NULL, AV_LOG_INFO, "bench: maxrss=%ikB\n", maxrss);
4ae74c63
MN
466 }
467
560f7774 468 for (i = 0; i < nb_filtergraphs; i++) {
73ed8558
AK
469 FilterGraph *fg = filtergraphs[i];
470 avfilter_graph_free(&fg->graph);
471 for (j = 0; j < fg->nb_inputs; j++) {
472 av_freep(&fg->inputs[j]->name);
473 av_freep(&fg->inputs[j]);
cf6c38c6 474 }
73ed8558
AK
475 av_freep(&fg->inputs);
476 for (j = 0; j < fg->nb_outputs; j++) {
477 av_freep(&fg->outputs[j]->name);
478 av_freep(&fg->outputs[j]);
cf6c38c6 479 }
73ed8558
AK
480 av_freep(&fg->outputs);
481 av_freep(&fg->graph_desc);
482
560f7774
AK
483 av_freep(&filtergraphs[i]);
484 }
485 av_freep(&filtergraphs);
fc49f22c 486
11a1033c 487 av_freep(&subtitle_out);
fc49f22c 488
6291d7e4 489 /* close files */
7636c8c6 490 for (i = 0; i < nb_output_files; i++) {
73ed8558 491 OutputFile *of = output_files[i];
6e80fe1e
MN
492 AVFormatContext *s;
493 if (!of)
494 continue;
495 s = of->ctx;
04091552 496 if (s && s->oformat && !(s->oformat->flags & AVFMT_NOFILE))
78cb3c06 497 avio_closep(&s->pb);
6291d7e4 498 avformat_free_context(s);
73ed8558
AK
499 av_dict_free(&of->opts);
500
2e215267 501 av_freep(&output_files[i]);
6291d7e4 502 }
1135a071 503 for (i = 0; i < nb_output_streams; i++) {
73ed8558 504 OutputStream *ost = output_streams[i];
503ec713
MN
505 AVBitStreamFilterContext *bsfc;
506
507 if (!ost)
508 continue;
509
510 bsfc = ost->bitstream_filters;
1135a071
JG
511 while (bsfc) {
512 AVBitStreamFilterContext *next = bsfc->next;
513 av_bitstream_filter_close(bsfc);
514 bsfc = next;
515 }
73ed8558
AK
516 ost->bitstream_filters = NULL;
517 av_frame_free(&ost->filtered_frame);
9f6d48d6 518 av_frame_free(&ost->last_frame);
73ed8558
AK
519
520 av_parser_close(ost->parser);
560f7774 521
73ed8558 522 av_freep(&ost->forced_keyframes);
6e397074 523 av_expr_free(ost->forced_keyframes_pexpr);
73ed8558
AK
524 av_freep(&ost->avfilter);
525 av_freep(&ost->logfile_prefix);
0460b9bb 526
d3a22491
MN
527 av_freep(&ost->audio_channels_map);
528 ost->audio_channels_mapped = 0;
529
7a0361b0
MN
530 av_dict_free(&ost->sws_dict);
531
862120f9
MN
532 avcodec_free_context(&ost->enc_ctx);
533
2e215267 534 av_freep(&output_streams[i]);
1135a071 535 }
1a36c756
MN
536#if HAVE_PTHREADS
537 free_input_threads();
538#endif
7636c8c6 539 for (i = 0; i < nb_input_files; i++) {
2e215267
AK
540 avformat_close_input(&input_files[i]->ctx);
541 av_freep(&input_files[i]);
6291d7e4 542 }
9179f27c 543 for (i = 0; i < nb_input_streams; i++) {
73ed8558
AK
544 InputStream *ist = input_streams[i];
545
546 av_frame_free(&ist->decoded_frame);
547 av_frame_free(&ist->filter_frame);
f3a6ad22 548 av_dict_free(&ist->decoder_opts);
6e397074
MN
549 avsubtitle_free(&ist->prev_sub.subtitle);
550 av_frame_free(&ist->sub2video.frame);
73ed8558
AK
551 av_freep(&ist->filters);
552 av_freep(&ist->hwaccel_device);
553
d0979357
MN
554 avcodec_free_context(&ist->dec_ctx);
555
2e215267 556 av_freep(&input_streams[i]);
9179f27c 557 }
560f7774 558
7ab37cae
GA
559 if (vstats_file) {
560 if (fclose(vstats_file))
561 av_log(NULL, AV_LOG_ERROR,
562 "Error closing vstats file, loss of information possible: %s\n",
563 av_err2str(AVERROR(errno)));
564 }
627f5658 565 av_freep(&vstats_filename);
560f7774 566
6291d7e4
AK
567 av_freep(&input_streams);
568 av_freep(&input_files);
4288e031 569 av_freep(&output_streams);
af70aa45 570 av_freep(&output_files);
8daf21d5 571
6291d7e4 572 uninit_opts();
560f7774 573
776f2bb9 574 avformat_network_deinit();
560f7774 575
6291d7e4 576 if (received_sigterm) {
87961eff 577 av_log(NULL, AV_LOG_INFO, "Exiting normally, received signal %d.\n",
e3245b26 578 (int) received_sigterm);
ed72dae4 579 } else if (ret && transcode_init_done) {
fed0aceb 580 av_log(NULL, AV_LOG_INFO, "Conversion failed!\n");
6291d7e4 581 }
f982d006 582 term_exit();
4ebb43f1 583 ffmpeg_exited = 1;
560f7774
AK
584}
585
7d03732f
MN
586void remove_avoptions(AVDictionary **a, AVDictionary *b)
587{
588 AVDictionaryEntry *t = NULL;
589
590 while ((t = av_dict_get(b, "", t, AV_DICT_IGNORE_SUFFIX))) {
591 av_dict_set(a, t->key, NULL, AV_DICT_MATCH_CASE);
592 }
593}
594
f5e66827 595void assert_avoptions(AVDictionary *m)
3b266da3 596{
6291d7e4
AK
597 AVDictionaryEntry *t;
598 if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
f24facd3 599 av_log(NULL, AV_LOG_FATAL, "Option %s not found.\n", t->key);
636ced8e 600 exit_program(1);
3b266da3 601 }
6291d7e4 602}
3b266da3 603
c854102d 604static void abort_codec_experimental(AVCodec *c, int encoder)
6291d7e4 605{
636ced8e 606 exit_program(1);
6291d7e4 607}
3b266da3 608
11a1033c 609static void update_benchmark(const char *fmt, ...)
6291d7e4 610{
11a1033c
MN
611 if (do_benchmark_all) {
612 int64_t t = getutime();
613 va_list va;
614 char buf[1024];
3b266da3 615
11a1033c
MN
616 if (fmt) {
617 va_start(va, fmt);
618 vsnprintf(buf, sizeof(buf), fmt, va);
619 va_end(va);
2c7f7a69 620 av_log(NULL, AV_LOG_INFO, "bench: %8"PRIu64" %s \n", t - current_time, buf);
3b266da3 621 }
11a1033c 622 current_time = t;
3b266da3 623 }
3b266da3
AK
624}
625
740e6042 626static void close_all_output_streams(OutputStream *ost, OSTFinished this_stream, OSTFinished others)
706741e8
MN
627{
628 int i;
629 for (i = 0; i < nb_output_streams; i++) {
630 OutputStream *ost2 = output_streams[i];
631 ost2->finished |= ost == ost2 ? this_stream : others;
632 }
633}
634
f15f02c2 635static void write_frame(AVFormatContext *s, AVPacket *pkt, OutputStream *ost)
3b266da3 636{
f15f02c2 637 AVBitStreamFilterContext *bsfc = ost->bitstream_filters;
95989463 638 AVCodecContext *avctx = ost->encoding_needed ? ost->enc_ctx : ost->st->codec;
3b266da3
AK
639 int ret;
640
ab84effd 641 if (!ost->st->codec->extradata_size && ost->enc_ctx->extradata_size) {
29d147c9 642 ost->st->codec->extradata = av_mallocz(ost->enc_ctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
ab84effd
MN
643 if (ost->st->codec->extradata) {
644 memcpy(ost->st->codec->extradata, ost->enc_ctx->extradata, ost->enc_ctx->extradata_size);
645 ost->st->codec->extradata_size = ost->enc_ctx->extradata_size;
646 }
647 }
648
11a1033c
MN
649 if ((avctx->codec_type == AVMEDIA_TYPE_VIDEO && video_sync_method == VSYNC_DROP) ||
650 (avctx->codec_type == AVMEDIA_TYPE_AUDIO && audio_sync_method < 0))
651 pkt->pts = pkt->dts = AV_NOPTS_VALUE;
ac712309 652
99932847
AK
653 /*
654 * Audio encoders may split the packets -- #frames in != #packets out.
655 * But there is no reordering, so we can limit the number of output packets
656 * by simply dropping them here.
657 * Counting encoded video frames needs to be done separately because of
658 * reordering, see do_video_out()
659 */
660 if (!(avctx->codec_type == AVMEDIA_TYPE_VIDEO && avctx->codec)) {
c9594fe0 661 if (ost->frame_number >= ost->max_frames) {
c2f861ca 662 av_packet_unref(pkt);
99932847 663 return;
c9594fe0 664 }
99932847 665 ost->frame_number++;
ac712309 666 }
e5bae39f 667 if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
cdb0225f 668 int i;
c40ecffd 669 uint8_t *sd = av_packet_get_side_data(pkt, AV_PKT_DATA_QUALITY_STATS,
e5bae39f 670 NULL);
c40ecffd 671 ost->quality = sd ? AV_RL32(sd) : -1;
8c2f00d5 672 ost->pict_type = sd ? sd[4] : AV_PICTURE_TYPE_NONE;
cdb0225f
MN
673
674 for (i = 0; i<FF_ARRAY_ELEMS(ost->error); i++) {
675 if (sd && i < sd[5])
676 ost->error[i] = AV_RL64(sd + 8 + 8*i);
677 else
678 ost->error[i] = -1;
679 }
d3d4bc47 680
46070cc2 681 if (ost->frame_rate.num && ost->is_cfr) {
363673fb
MN
682 if (pkt->duration > 0)
683 av_log(NULL, AV_LOG_WARNING, "Overriding packet duration by frame rate, this should not happen\n");
d3d4bc47
HL
684 pkt->duration = av_rescale_q(1, av_inv_q(ost->frame_rate),
685 ost->st->time_base);
686 }
e5bae39f 687 }
ac712309 688
e9602dcb
MN
689 if (bsfc)
690 av_packet_split_side_data(pkt);
691
a5fd3a1a
RC
692 if ((ret = av_apply_bitstream_filters(avctx, pkt, bsfc)) < 0) {
693 print_error("", ret);
694 if (exit_on_error)
695 exit_program(1);
8daf21d5 696 }
6d8ab358
RB
697 if (pkt->size == 0 && pkt->side_data_elems == 0)
698 return;
8daf21d5 699
27856b2f 700 if (!(s->oformat->flags & AVFMT_NOTIMESTAMPS)) {
22844132
MN
701 if (pkt->dts != AV_NOPTS_VALUE &&
702 pkt->pts != AV_NOPTS_VALUE &&
703 pkt->dts > pkt->pts) {
704 av_log(s, AV_LOG_WARNING, "Invalid DTS: %"PRId64" PTS: %"PRId64" in output stream %d:%d, replacing by guess\n",
705 pkt->dts, pkt->pts,
706 ost->file_index, ost->st->index);
707 pkt->pts =
708 pkt->dts = pkt->pts + pkt->dts + ost->last_mux_dts + 1
709 - FFMIN3(pkt->pts, pkt->dts, ost->last_mux_dts + 1)
710 - FFMAX3(pkt->pts, pkt->dts, ost->last_mux_dts + 1);
711 }
27856b2f 712 if(
ee3824f6 713 (avctx->codec_type == AVMEDIA_TYPE_AUDIO || avctx->codec_type == AVMEDIA_TYPE_VIDEO) &&
6b2fbdb0 714 pkt->dts != AV_NOPTS_VALUE &&
2e6636aa 715 !(avctx->codec_id == AV_CODEC_ID_VP9 && ost->stream_copy) &&
26b89f62
MN
716 ost->last_mux_dts != AV_NOPTS_VALUE) {
717 int64_t max = ost->last_mux_dts + !(s->oformat->flags & AVFMT_TS_NONSTRICT);
718 if (pkt->dts < max) {
b2a1d92b 719 int loglevel = max - pkt->dts > 2 || avctx->codec_type == AVMEDIA_TYPE_VIDEO ? AV_LOG_WARNING : AV_LOG_DEBUG;
af2d9643 720 av_log(s, loglevel, "Non-monotonous DTS in output stream "
76d23f40
AK
721 "%d:%d; previous: %"PRId64", current: %"PRId64"; ",
722 ost->file_index, ost->st->index, ost->last_mux_dts, pkt->dts);
723 if (exit_on_error) {
724 av_log(NULL, AV_LOG_FATAL, "aborting.\n");
636ced8e 725 exit_program(1);
76d23f40 726 }
af2d9643 727 av_log(s, loglevel, "changing to %"PRId64". This may result "
76d23f40 728 "in incorrect timestamps in the output file.\n",
007ee09d 729 max);
30c05f6b 730 if(pkt->pts >= pkt->dts)
007ee09d 731 pkt->pts = FFMAX(pkt->pts, max);
30c05f6b 732 pkt->dts = max;
26b89f62 733 }
27856b2f 734 }
76d23f40
AK
735 }
736 ost->last_mux_dts = pkt->dts;
737
13278b97 738 ost->data_size += pkt->size;
47543450 739 ost->packets_written++;
13278b97 740
61a09968 741 pkt->stream_index = ost->index;
cddbafb5
MN
742
743 if (debug_ts) {
744 av_log(NULL, AV_LOG_INFO, "muxer <- type:%s "
44ae7bad 745 "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s size:%d\n",
137c5e11 746 av_get_media_type_string(ost->enc_ctx->codec_type),
cddbafb5 747 av_ts2str(pkt->pts), av_ts2timestr(pkt->pts, &ost->st->time_base),
44ae7bad
MN
748 av_ts2str(pkt->dts), av_ts2timestr(pkt->dts, &ost->st->time_base),
749 pkt->size
cddbafb5
MN
750 );
751 }
752
7636c8c6
AD
753 ret = av_interleaved_write_frame(s, pkt);
754 if (ret < 0) {
6291d7e4 755 print_error("av_interleaved_write_frame()", ret);
706741e8 756 main_return_code = 1;
740e6042 757 close_all_output_streams(ost, MUXER_FINISHED | ENCODER_FINISHED, ENCODER_FINISHED);
6291d7e4 758 }
c2f861ca 759 av_packet_unref(pkt);
3b266da3
AK
760}
761
666fd092
NG
762static void close_output_stream(OutputStream *ost)
763{
764 OutputFile *of = output_files[ost->file_index];
765
740e6042 766 ost->finished |= ENCODER_FINISHED;
666fd092 767 if (of->shortest) {
137c5e11 768 int64_t end = av_rescale_q(ost->sync_opts - ost->first_pts, ost->enc_ctx->time_base, AV_TIME_BASE_Q);
c4a32d92 769 of->recording_time = FFMIN(of->recording_time, end);
666fd092
NG
770 }
771}
772
1270e12e 773static int check_recording_time(OutputStream *ost)
0ad26cdf 774{
2e215267 775 OutputFile *of = output_files[ost->file_index];
0ad26cdf 776
1270e12e 777 if (of->recording_time != INT64_MAX &&
862120f9 778 av_compare_ts(ost->sync_opts - ost->first_pts, ost->enc_ctx->time_base, of->recording_time,
1270e12e 779 AV_TIME_BASE_Q) >= 0) {
8b61abac 780 close_output_stream(ost);
1270e12e 781 return 0;
d43812e2 782 }
1270e12e
AK
783 return 1;
784}
d43812e2 785
369cb092
AK
786static void do_audio_out(AVFormatContext *s, OutputStream *ost,
787 AVFrame *frame)
ee458cb1 788{
862120f9 789 AVCodecContext *enc = ost->enc_ctx;
ee458cb1 790 AVPacket pkt;
369cb092 791 int got_packet = 0;
0ad26cdf 792
ee458cb1
JR
793 av_init_packet(&pkt);
794 pkt.data = NULL;
795 pkt.size = 0;
0ad26cdf 796
369cb092
AK
797 if (!check_recording_time(ost))
798 return;
0ad26cdf 799
369cb092 800 if (frame->pts == AV_NOPTS_VALUE || audio_sync_method < 0)
9b9fc9ba 801 frame->pts = ost->sync_opts;
369cb092 802 ost->sync_opts = frame->pts + frame->nb_samples;
47543450
AK
803 ost->samples_encoded += frame->nb_samples;
804 ost->frames_encoded++;
16e25ef3 805
11a1033c
MN
806 av_assert0(pkt.size || !pkt.data);
807 update_benchmark(NULL);
290da7e7
SS
808 if (debug_ts) {
809 av_log(NULL, AV_LOG_INFO, "encoder <- type:audio "
810 "frame_pts:%s frame_pts_time:%s time_base:%d/%d\n",
811 av_ts2str(frame->pts), av_ts2timestr(frame->pts, &enc->time_base),
812 enc->time_base.num, enc->time_base.den);
813 }
1046cd60 814
ee458cb1 815 if (avcodec_encode_audio2(enc, &pkt, frame, &got_packet) < 0) {
11a1033c 816 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed (avcodec_encode_audio2)\n");
636ced8e 817 exit_program(1);
0ad26cdf 818 }
11a1033c 819 update_benchmark("encode_audio %d.%d", ost->file_index, ost->index);
0ad26cdf 820
ee458cb1 821 if (got_packet) {
afa7ab55 822 av_packet_rescale_ts(&pkt, enc->time_base, ost->st->time_base);
0ad26cdf 823
11a1033c
MN
824 if (debug_ts) {
825 av_log(NULL, AV_LOG_INFO, "encoder -> type:audio "
826 "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s\n",
827 av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ost->st->time_base),
828 av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ost->st->time_base));
829 }
cf6c38c6 830
ee458cb1 831 write_frame(s, &pkt, ost);
0ad26cdf
AK
832 }
833}
834
6291d7e4
AK
835static void do_subtitle_out(AVFormatContext *s,
836 OutputStream *ost,
837 InputStream *ist,
6d8b3263 838 AVSubtitle *sub)
a977d91e 839{
6291d7e4
AK
840 int subtitle_out_max_size = 1024 * 1024;
841 int subtitle_out_size, nb, i;
842 AVCodecContext *enc;
843 AVPacket pkt;
6d8b3263 844 int64_t pts;
16e25ef3 845
6d8b3263 846 if (sub->pts == AV_NOPTS_VALUE) {
e3245b26 847 av_log(NULL, AV_LOG_ERROR, "Subtitle packets must have a pts\n");
6291d7e4 848 if (exit_on_error)
636ced8e 849 exit_program(1);
6291d7e4 850 return;
8daf21d5 851 }
a977d91e 852
862120f9 853 enc = ost->enc_ctx;
cf6c38c6 854
6291d7e4
AK
855 if (!subtitle_out) {
856 subtitle_out = av_malloc(subtitle_out_max_size);
d2f9aefb
MN
857 if (!subtitle_out) {
858 av_log(NULL, AV_LOG_FATAL, "Failed to allocate subtitle_out\n");
859 exit_program(1);
860 }
a977d91e 861 }
a977d91e 862
6291d7e4
AK
863 /* Note: DVB subtitle need one packet to draw them and one other
864 packet to clear them */
865 /* XXX: signal it in the codec context ? */
36ef5369 866 if (enc->codec_id == AV_CODEC_ID_DVB_SUBTITLE)
6291d7e4
AK
867 nb = 2;
868 else
869 nb = 1;
3b266da3 870
11a1033c 871 /* shift timestamp to honor -ss and make check_recording_time() work with -t */
3fa72de8
MN
872 pts = sub->pts;
873 if (output_files[ost->file_index]->start_time != AV_NOPTS_VALUE)
874 pts -= output_files[ost->file_index]->start_time;
7636c8c6 875 for (i = 0; i < nb; i++) {
36393434
AM
876 unsigned save_num_rects = sub->num_rects;
877
11a1033c 878 ost->sync_opts = av_rescale_q(pts, AV_TIME_BASE_Q, enc->time_base);
1270e12e
AK
879 if (!check_recording_time(ost))
880 return;
3b266da3 881
11a1033c 882 sub->pts = pts;
6291d7e4 883 // start_display_time is required to be 0
7636c8c6
AD
884 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){ 1, 1000 }, AV_TIME_BASE_Q);
885 sub->end_display_time -= sub->start_display_time;
6291d7e4 886 sub->start_display_time = 0;
aed032c2
NG
887 if (i == 1)
888 sub->num_rects = 0;
47543450
AK
889
890 ost->frames_encoded++;
891
6291d7e4
AK
892 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
893 subtitle_out_max_size, sub);
36393434
AM
894 if (i == 1)
895 sub->num_rects = save_num_rects;
6291d7e4 896 if (subtitle_out_size < 0) {
e3245b26 897 av_log(NULL, AV_LOG_FATAL, "Subtitle encoding failed\n");
636ced8e 898 exit_program(1);
6291d7e4
AK
899 }
900
901 av_init_packet(&pkt);
6291d7e4
AK
902 pkt.data = subtitle_out;
903 pkt.size = subtitle_out_size;
7636c8c6 904 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
11a1033c 905 pkt.duration = av_rescale_q(sub->end_display_time, (AVRational){ 1, 1000 }, ost->st->time_base);
36ef5369 906 if (enc->codec_id == AV_CODEC_ID_DVB_SUBTITLE) {
6291d7e4
AK
907 /* XXX: the pts correction is handled here. Maybe handling
908 it in the codec would be better */
909 if (i == 0)
910 pkt.pts += 90 * sub->start_display_time;
911 else
912 pkt.pts += 90 * sub->end_display_time;
913 }
dad54e4a 914 pkt.dts = pkt.pts;
f0d50500 915 write_frame(s, &pkt, ost);
8daf21d5 916 }
6291d7e4 917}
3b266da3 918
87ef060c
AC
919static void do_video_out(AVFormatContext *s,
920 OutputStream *ost,
7b328560
MN
921 AVFrame *next_picture,
922 double sync_ipts)
87ef060c 923{
74b961db
AK
924 int ret, format_video_sync;
925 AVPacket pkt;
862120f9 926 AVCodecContext *enc = ost->enc_ctx;
0949bbc4 927 AVCodecContext *mux_enc = ost->st->codec;
9f6d48d6 928 int nb_frames, nb0_frames, i;
7b328560 929 double delta, delta0;
11a1033c
MN
930 double duration = 0;
931 int frame_size = 0;
932 InputStream *ist = NULL;
d3d9a00b 933 AVFilterContext *filter = ost->filter->filter;
3b266da3 934
11a1033c
MN
935 if (ost->source_index >= 0)
936 ist = input_streams[ost->source_index];
3b266da3 937
d3d9a00b
MN
938 if (filter->inputs[0]->frame_rate.num > 0 &&
939 filter->inputs[0]->frame_rate.den > 0)
a582705d
MN
940 duration = 1/(av_q2d(filter->inputs[0]->frame_rate) * av_q2d(enc->time_base));
941
942 if(ist && ist->st->start_time != AV_NOPTS_VALUE && ist->st->first_dts != AV_NOPTS_VALUE && ost->frame_rate.num)
943 duration = FFMIN(duration, 1/(av_q2d(ost->frame_rate) * av_q2d(enc->time_base)));
d3d9a00b 944
c5092025
MN
945 if (!ost->filters_script &&
946 !ost->filters &&
947 next_picture &&
948 ist &&
949 lrintf(av_frame_get_pkt_duration(next_picture) * av_q2d(ist->st->time_base) / av_q2d(enc->time_base)) > 0) {
950 duration = lrintf(av_frame_get_pkt_duration(next_picture) * av_q2d(ist->st->time_base) / av_q2d(enc->time_base));
951 }
952
98c7729c
MN
953 if (!next_picture) {
954 //end, flushing
955 nb0_frames = nb_frames = mid_pred(ost->last_nb0_frames[0],
956 ost->last_nb0_frames[1],
957 ost->last_nb0_frames[2]);
958 } else {
dfa98c4f 959 delta0 = sync_ipts - ost->sync_opts; // delta0 is the "drift" between the input frame (next_picture) and where it would fall in the output.
6eb6956d 960 delta = delta0 + duration;
3b266da3 961
6eb6956d 962 /* by default, we output a single frame */
dfa98c4f 963 nb0_frames = 0; // tracks the number of times the PREVIOUS frame should be duplicated, mostly for variable framerate (VFR)
6eb6956d 964 nb_frames = 1;
3b266da3 965
6eb6956d
MN
966 format_video_sync = video_sync_method;
967 if (format_video_sync == VSYNC_AUTO) {
968 if(!strcmp(s->oformat->name, "avi")) {
969 format_video_sync = VSYNC_VFR;
970 } else
971 format_video_sync = (s->oformat->flags & AVFMT_VARIABLE_FPS) ? ((s->oformat->flags & AVFMT_NOTIMESTAMPS) ? VSYNC_PASSTHROUGH : VSYNC_VFR) : VSYNC_CFR;
972 if ( ist
973 && format_video_sync == VSYNC_CFR
974 && input_files[ist->file_index]->ctx->nb_streams == 1
975 && input_files[ist->file_index]->input_ts_offset == 0) {
976 format_video_sync = VSYNC_VSCFR;
977 }
978 if (format_video_sync == VSYNC_CFR && copy_ts) {
979 format_video_sync = VSYNC_VSCFR;
980 }
738ebb4a 981 }
46070cc2 982 ost->is_cfr = (format_video_sync == VSYNC_CFR || format_video_sync == VSYNC_VSCFR);
11a1033c 983
6eb6956d
MN
984 if (delta0 < 0 &&
985 delta > 0 &&
986 format_video_sync != VSYNC_PASSTHROUGH &&
987 format_video_sync != VSYNC_DROP) {
6eb6956d
MN
988 if (delta0 < -0.6) {
989 av_log(NULL, AV_LOG_WARNING, "Past duration %f too large\n", -delta0);
990 } else
dfa98c4f 991 av_log(NULL, AV_LOG_DEBUG, "Clipping frame in rate conversion by %f\n", -delta0);
1fe82aba
BH
992 sync_ipts = ost->sync_opts;
993 duration += delta0;
994 delta0 = 0;
6eb6956d 995 }
33bc81e4 996
6eb6956d
MN
997 switch (format_video_sync) {
998 case VSYNC_VSCFR:
1fe82aba
BH
999 if (ost->frame_number == 0 && delta0 >= 0.5) {
1000 av_log(NULL, AV_LOG_DEBUG, "Not duplicating %d initial frames\n", (int)lrintf(delta0));
6eb6956d
MN
1001 delta = duration;
1002 delta0 = 0;
1003 ost->sync_opts = lrint(sync_ipts);
1004 }
1005 case VSYNC_CFR:
1006 // FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1007 if (frame_drop_threshold && delta < frame_drop_threshold && ost->frame_number) {
1008 nb_frames = 0;
1009 } else if (delta < -1.1)
1010 nb_frames = 0;
1011 else if (delta > 1.1) {
1012 nb_frames = lrintf(delta);
1013 if (delta0 > 1.1)
1014 nb0_frames = lrintf(delta0 - 0.6);
1015 }
1016 break;
1017 case VSYNC_VFR:
1018 if (delta <= -0.6)
1019 nb_frames = 0;
1020 else if (delta > 0.6)
1021 ost->sync_opts = lrint(sync_ipts);
1022 break;
1023 case VSYNC_DROP:
1024 case VSYNC_PASSTHROUGH:
d7ebeba8 1025 ost->sync_opts = lrint(sync_ipts);
6eb6956d
MN
1026 break;
1027 default:
1028 av_assert0(0);
d7ebeba8 1029 }
98c7729c 1030 }
11a1033c
MN
1031
1032 nb_frames = FFMIN(nb_frames, ost->max_frames - ost->frame_number);
9f6d48d6 1033 nb0_frames = FFMIN(nb0_frames, nb_frames);
98c7729c
MN
1034
1035 memmove(ost->last_nb0_frames + 1,
1036 ost->last_nb0_frames,
1037 sizeof(ost->last_nb0_frames[0]) * (FF_ARRAY_ELEMS(ost->last_nb0_frames) - 1));
1038 ost->last_nb0_frames[0] = nb0_frames;
1039
dfa98c4f 1040 if (nb0_frames == 0 && ost->last_dropped) {
d43040e2 1041 nb_frames_drop++;
506064ed 1042 av_log(NULL, AV_LOG_VERBOSE,
aa499568 1043 "*** dropping frame %d from stream %d at ts %"PRId64"\n",
61fc1cbf 1044 ost->frame_number, ost->st->index, ost->last_frame->pts);
9f6d48d6 1045 }
dfa98c4f 1046 if (nb_frames > (nb0_frames && ost->last_dropped) + (nb_frames > nb0_frames)) {
11a1033c 1047 if (nb_frames > dts_error_threshold * 30) {
4390f8c2 1048 av_log(NULL, AV_LOG_ERROR, "%d frame duplication too large, skipping\n", nb_frames - 1);
11a1033c
MN
1049 nb_frames_drop++;
1050 return;
3b266da3 1051 }
dfa98c4f 1052 nb_frames_dup += nb_frames - (nb0_frames && ost->last_dropped) - (nb_frames > nb0_frames);
11a1033c 1053 av_log(NULL, AV_LOG_VERBOSE, "*** %d dup!\n", nb_frames - 1);
3b266da3 1054 }
dfa98c4f 1055 ost->last_dropped = nb_frames == nb0_frames && next_picture;
3b266da3 1056
11a1033c
MN
1057 /* duplicates frame if needed */
1058 for (i = 0; i < nb_frames; i++) {
9f6d48d6 1059 AVFrame *in_picture;
39885a4b
AK
1060 av_init_packet(&pkt);
1061 pkt.data = NULL;
1062 pkt.size = 0;
3b266da3 1063
9f6d48d6
MN
1064 if (i < nb0_frames && ost->last_frame) {
1065 in_picture = ost->last_frame;
1066 } else
1067 in_picture = next_picture;
1068
93db2708
MN
1069 if (!in_picture)
1070 return;
1071
11a1033c 1072 in_picture->pts = ost->sync_opts;
3b266da3 1073
76c1f920 1074#if 1
11a1033c 1075 if (!check_recording_time(ost))
76c1f920 1076#else
a83c0da5 1077 if (ost->frame_number >= ost->max_frames)
76c1f920 1078#endif
39885a4b 1079 return;
3b266da3 1080
a34dfc93 1081#if FF_API_LAVF_FMT_RAWPICTURE
39885a4b 1082 if (s->oformat->flags & AVFMT_RAWPICTURE &&
36ef5369 1083 enc->codec->id == AV_CODEC_ID_RAWVIDEO) {
39885a4b
AK
1084 /* raw pictures are written as AVPicture structure to
1085 avoid any copies. We support temporarily the older
1086 method. */
242f1152
MN
1087 if (in_picture->interlaced_frame)
1088 mux_enc->field_order = in_picture->top_field_first ? AV_FIELD_TB:AV_FIELD_BT;
dcbf7283 1089 else
0949bbc4 1090 mux_enc->field_order = AV_FIELD_PROGRESSIVE;
39885a4b
AK
1091 pkt.data = (uint8_t *)in_picture;
1092 pkt.size = sizeof(AVPicture);
1093 pkt.pts = av_rescale_q(in_picture->pts, enc->time_base, ost->st->time_base);
1094 pkt.flags |= AV_PKT_FLAG_KEY;
3b266da3 1095
f0d50500 1096 write_frame(s, &pkt, ost);
a34dfc93
HL
1097 } else
1098#endif
1099 {
43af18ef 1100 int got_packet, forced_keyframe = 0;
43af18ef 1101 double pts_time;
85f07f22 1102
94d68a41 1103 if (enc->flags & (AV_CODEC_FLAG_INTERLACED_DCT | AV_CODEC_FLAG_INTERLACED_ME) &&
9b2dc295
AK
1104 ost->top_field_first >= 0)
1105 in_picture->top_field_first = !!ost->top_field_first;
9680a722 1106
32fdfdfb 1107 if (in_picture->interlaced_frame) {
dcbf7283 1108 if (enc->codec->id == AV_CODEC_ID_MJPEG)
0949bbc4 1109 mux_enc->field_order = in_picture->top_field_first ? AV_FIELD_TT:AV_FIELD_BB;
dcbf7283 1110 else
0949bbc4 1111 mux_enc->field_order = in_picture->top_field_first ? AV_FIELD_TB:AV_FIELD_BT;
dcbf7283 1112 } else
0949bbc4 1113 mux_enc->field_order = AV_FIELD_PROGRESSIVE;
dcbf7283 1114
862120f9 1115 in_picture->quality = enc->global_quality;
c48e8d9d 1116 in_picture->pict_type = 0;
43af18ef 1117
32fdfdfb
MN
1118 pts_time = in_picture->pts != AV_NOPTS_VALUE ?
1119 in_picture->pts * av_q2d(enc->time_base) : NAN;
39885a4b 1120 if (ost->forced_kf_index < ost->forced_kf_count &&
9b2dc295 1121 in_picture->pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
39885a4b 1122 ost->forced_kf_index++;
43af18ef
SS
1123 forced_keyframe = 1;
1124 } else if (ost->forced_keyframes_pexpr) {
1125 double res;
1126 ost->forced_keyframes_expr_const_values[FKF_T] = pts_time;
1127 res = av_expr_eval(ost->forced_keyframes_pexpr,
1128 ost->forced_keyframes_expr_const_values, NULL);
229843aa 1129 ff_dlog(NULL, "force_key_frame: n:%f n_forced:%f prev_forced_n:%f t:%f prev_forced_t:%f -> res:%f\n",
43af18ef
SS
1130 ost->forced_keyframes_expr_const_values[FKF_N],
1131 ost->forced_keyframes_expr_const_values[FKF_N_FORCED],
1132 ost->forced_keyframes_expr_const_values[FKF_PREV_FORCED_N],
1133 ost->forced_keyframes_expr_const_values[FKF_T],
1134 ost->forced_keyframes_expr_const_values[FKF_PREV_FORCED_T],
1135 res);
1136 if (res) {
1137 forced_keyframe = 1;
1138 ost->forced_keyframes_expr_const_values[FKF_PREV_FORCED_N] =
1139 ost->forced_keyframes_expr_const_values[FKF_N];
1140 ost->forced_keyframes_expr_const_values[FKF_PREV_FORCED_T] =
1141 ost->forced_keyframes_expr_const_values[FKF_T];
1142 ost->forced_keyframes_expr_const_values[FKF_N_FORCED] += 1;
1143 }
1144
1145 ost->forced_keyframes_expr_const_values[FKF_N] += 1;
77cc0d5b 1146 } else if ( ost->forced_keyframes
1147 && !strncmp(ost->forced_keyframes, "source", 6)
1148 && in_picture->key_frame==1) {
1149 forced_keyframe = 1;
39885a4b 1150 }
1046cd60 1151
43af18ef 1152 if (forced_keyframe) {
32fdfdfb 1153 in_picture->pict_type = AV_PICTURE_TYPE_I;
43af18ef
SS
1154 av_log(NULL, AV_LOG_DEBUG, "Forced keyframe at time %f\n", pts_time);
1155 }
1156
11a1033c 1157 update_benchmark(NULL);
290da7e7
SS
1158 if (debug_ts) {
1159 av_log(NULL, AV_LOG_INFO, "encoder <- type:video "
1160 "frame_pts:%s frame_pts_time:%s time_base:%d/%d\n",
1161 av_ts2str(in_picture->pts), av_ts2timestr(in_picture->pts, &enc->time_base),
1162 enc->time_base.num, enc->time_base.den);
1163 }
1164
47543450
AK
1165 ost->frames_encoded++;
1166
9b2dc295 1167 ret = avcodec_encode_video2(enc, &pkt, in_picture, &got_packet);
11a1033c 1168 update_benchmark("encode_video %d.%d", ost->file_index, ost->index);
39885a4b
AK
1169 if (ret < 0) {
1170 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
636ced8e 1171 exit_program(1);
39885a4b 1172 }
9680a722 1173
39885a4b 1174 if (got_packet) {
290da7e7
SS
1175 if (debug_ts) {
1176 av_log(NULL, AV_LOG_INFO, "encoder -> type:video "
1177 "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s\n",
1178 av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &enc->time_base),
1179 av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &enc->time_base));
1180 }
1181
444e9874 1182 if (pkt.pts == AV_NOPTS_VALUE && !(enc->codec->capabilities & AV_CODEC_CAP_DELAY))
11a1033c 1183 pkt.pts = ost->sync_opts;
9e6a1c89 1184
afa7ab55 1185 av_packet_rescale_ts(&pkt, enc->time_base, ost->st->time_base);
9e6a1c89 1186
11a1033c
MN
1187 if (debug_ts) {
1188 av_log(NULL, AV_LOG_INFO, "encoder -> type:video "
1189 "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s\n",
1190 av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ost->st->time_base),
1191 av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ost->st->time_base));
1192 }
1193
11a1033c 1194 frame_size = pkt.size;
f0d50500 1195 write_frame(s, &pkt, ost);
324fbadf 1196
39885a4b
AK
1197 /* if two pass, output log */
1198 if (ost->logfile && enc->stats_out) {
1199 fprintf(ost->logfile, "%s", enc->stats_out);
6291d7e4 1200 }
9e6a1c89 1201 }
39aafa5e 1202 }
39885a4b
AK
1203 ost->sync_opts++;
1204 /*
1205 * For video, number of frames in == number of packets out.
1206 * But there may be reordering, so we can't throw away frames on encoder
1207 * flush, we need to limit them here, before they go into encoder.
1208 */
1209 ost->frame_number++;
8b8bf89e 1210
11a1033c 1211 if (vstats_filename && frame_size)
cd379636 1212 do_video_stats(ost, frame_size);
fcf73f9c 1213 }
9f6d48d6
MN
1214
1215 if (!ost->last_frame)
1216 ost->last_frame = av_frame_alloc();
1217 av_frame_unref(ost->last_frame);
fd4c87fa 1218 if (next_picture && ost->last_frame)
6eb6956d 1219 av_frame_ref(ost->last_frame, next_picture);
d1050d99
MN
1220 else
1221 av_frame_free(&ost->last_frame);
85f07f22
FB
1222}
1223
7636c8c6 1224static double psnr(double d)
85f07f22 1225{
b45daad2 1226 return -10.0 * log10(d);
6291d7e4 1227}
8b8bf89e 1228
70478746 1229static void do_video_stats(OutputStream *ost, int frame_size)
e5295c0d 1230{
6291d7e4
AK
1231 AVCodecContext *enc;
1232 int frame_number;
1233 double ti1, bitrate, avg_bitrate;
560f7774 1234
6291d7e4
AK
1235 /* this is executed just the first time do_video_stats is called */
1236 if (!vstats_file) {
1237 vstats_file = fopen(vstats_filename, "w");
1238 if (!vstats_file) {
1239 perror("fopen");
636ced8e 1240 exit_program(1);
cf6c38c6 1241 }
560f7774 1242 }
e5295c0d 1243
862120f9 1244 enc = ost->enc_ctx;
6291d7e4 1245 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
60c2cddf 1246 frame_number = ost->st->nb_frames;
e5bae39f
MN
1247 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number,
1248 ost->quality / (float)FF_QP2LAMBDA);
495eee01 1249
cdb0225f
MN
1250 if (ost->error[0]>=0 && (enc->flags & AV_CODEC_FLAG_PSNR))
1251 fprintf(vstats_file, "PSNR= %6.2f ", psnr(ost->error[0] / (enc->width * enc->height * 255.0 * 255.0)));
f926d916 1252
6291d7e4
AK
1253 fprintf(vstats_file,"f_size= %6d ", frame_size);
1254 /* compute pts value */
1f359c85 1255 ti1 = av_stream_get_end_pts(ost->st) * av_q2d(ost->st->time_base);
6291d7e4
AK
1256 if (ti1 < 0.01)
1257 ti1 = 0.01;
67f5650a 1258
7636c8c6 1259 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
13278b97 1260 avg_bitrate = (double)(ost->data_size * 8) / ti1 / 1000.0;
6291d7e4 1261 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
13278b97 1262 (double)ost->data_size / 1024, ti1, bitrate, avg_bitrate);
8c2f00d5 1263 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(ost->pict_type));
b404ab9e 1264 }
6291d7e4 1265}
e5295c0d 1266
52ce6be8
MN
1267static void finish_output_stream(OutputStream *ost)
1268{
1269 OutputFile *of = output_files[ost->file_index];
1270 int i;
1271
1272 ost->finished = ENCODER_FINISHED | MUXER_FINISHED;
1273
1274 if (of->shortest) {
1275 for (i = 0; i < of->ctx->nb_streams; i++)
1276 output_streams[of->ost_index + i]->finished = ENCODER_FINISHED | MUXER_FINISHED;
1277 }
1278}
1279
9ccc349f 1280/**
429c6cab
NG
1281 * Get and encode new output from any of the filtergraphs, without causing
1282 * activity.
1283 *
1284 * @return 0 for success, <0 for severe errors
1285 */
98c7729c 1286static int reap_filters(int flush)
560f7774 1287{
560f7774 1288 AVFrame *filtered_frame = NULL;
429c6cab 1289 int i;
e5295c0d 1290
13b965ea
NG
1291 /* Reap all buffers present in the buffer sinks */
1292 for (i = 0; i < nb_output_streams; i++) {
1293 OutputStream *ost = output_streams[i];
1294 OutputFile *of = output_files[ost->file_index];
9651239f 1295 AVFilterContext *filter;
862120f9 1296 AVCodecContext *enc = ost->enc_ctx;
13b965ea
NG
1297 int ret = 0;
1298
1299 if (!ost->filter)
1300 continue;
9651239f 1301 filter = ost->filter->filter;
13b965ea 1302
0ee905e2 1303 if (!ost->filtered_frame && !(ost->filtered_frame = av_frame_alloc())) {
13b965ea 1304 return AVERROR(ENOMEM);
a4f50110 1305 }
13b965ea
NG
1306 filtered_frame = ost->filtered_frame;
1307
1308 while (1) {
f9614891 1309 double float_pts = AV_NOPTS_VALUE; // this is identical to filtered_frame.pts but with higher precision
9651239f 1310 ret = av_buffersink_get_frame_flags(filter, filtered_frame,
13b965ea
NG
1311 AV_BUFFERSINK_FLAG_NO_REQUEST);
1312 if (ret < 0) {
1313 if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF) {
13b965ea 1314 av_log(NULL, AV_LOG_WARNING,
27021790 1315 "Error in av_buffersink_get_frame_flags(): %s\n", av_err2str(ret));
b87dd7f8 1316 } else if (flush && ret == AVERROR_EOF) {
98c7729c
MN
1317 if (filter->inputs[0]->type == AVMEDIA_TYPE_VIDEO)
1318 do_video_out(of->ctx, ost, NULL, AV_NOPTS_VALUE);
11a1033c 1319 }
13b965ea
NG
1320 break;
1321 }
7d91fb30
MN
1322 if (ost->finished) {
1323 av_frame_unref(filtered_frame);
1324 continue;
1325 }
32fdfdfb 1326 if (filtered_frame->pts != AV_NOPTS_VALUE) {
3fa72de8 1327 int64_t start_time = (of->start_time == AV_NOPTS_VALUE) ? 0 : of->start_time;
7b328560
MN
1328 AVRational tb = enc->time_base;
1329 int extra_bits = av_clip(29 - av_log2(tb.den), 0, 16);
1330
1331 tb.den <<= extra_bits;
1332 float_pts =
1333 av_rescale_q(filtered_frame->pts, filter->inputs[0]->time_base, tb) -
1334 av_rescale_q(start_time, AV_TIME_BASE_Q, tb);
1335 float_pts /= 1 << extra_bits;
1336 // avoid exact midoints to reduce the chance of rounding differences, this can be removed in case the fps code is changed to work with integers
1337 float_pts += FFSIGN(float_pts) * 1.0 / (1<<17);
1338
261e8ccb 1339 filtered_frame->pts =
9651239f
SS
1340 av_rescale_q(filtered_frame->pts, filter->inputs[0]->time_base, enc->time_base) -
1341 av_rescale_q(start_time, AV_TIME_BASE_Q, enc->time_base);
11a1033c 1342 }
13b965ea
NG
1343 //if (ost->source_index >= 0)
1344 // *filtered_frame= *input_streams[ost->source_index]->decoded_frame; //for me_threshold
1345
9651239f 1346 switch (filter->inputs[0]->type) {
13b965ea 1347 case AVMEDIA_TYPE_VIDEO:
de38e7c8 1348 if (!ost->frame_aspect_ratio.num)
9651239f 1349 enc->sample_aspect_ratio = filtered_frame->sample_aspect_ratio;
13b965ea 1350
290da7e7 1351 if (debug_ts) {
7b328560 1352 av_log(NULL, AV_LOG_INFO, "filter -> pts:%s pts_time:%s exact:%f time_base:%d/%d\n",
290da7e7 1353 av_ts2str(filtered_frame->pts), av_ts2timestr(filtered_frame->pts, &enc->time_base),
7b328560 1354 float_pts,
290da7e7
SS
1355 enc->time_base.num, enc->time_base.den);
1356 }
1357
7b328560 1358 do_video_out(of->ctx, ost, filtered_frame, float_pts);
13b965ea
NG
1359 break;
1360 case AVMEDIA_TYPE_AUDIO:
444e9874 1361 if (!(enc->codec->capabilities & AV_CODEC_CAP_PARAM_CHANGE) &&
9651239f 1362 enc->channels != av_frame_get_channels(filtered_frame)) {
c3fb20ba
MN
1363 av_log(NULL, AV_LOG_ERROR,
1364 "Audio filter graph output is not normalized and encoder does not support parameter changes\n");
1365 break;
1366 }
13b965ea
NG
1367 do_audio_out(of->ctx, ost, filtered_frame);
1368 break;
1369 default:
1370 // TODO support subtitle filters
1371 av_assert0(0);
1372 }
1373
32fdfdfb 1374 av_frame_unref(filtered_frame);
aa1de0d9 1375 }
13b965ea 1376 }
429c6cab
NG
1377
1378 return 0;
aa1de0d9
RB
1379}
1380
afa442c1
MN
1381static void print_final_stats(int64_t total_size)
1382{
1383 uint64_t video_size = 0, audio_size = 0, extra_size = 0, other_size = 0;
1384 uint64_t subtitle_size = 0;
1385 uint64_t data_size = 0;
1386 float percent = -1.0;
47543450 1387 int i, j;
4fe38441 1388 int pass1_used = 1;
afa442c1
MN
1389
1390 for (i = 0; i < nb_output_streams; i++) {
1391 OutputStream *ost = output_streams[i];
862120f9 1392 switch (ost->enc_ctx->codec_type) {
afa442c1
MN
1393 case AVMEDIA_TYPE_VIDEO: video_size += ost->data_size; break;
1394 case AVMEDIA_TYPE_AUDIO: audio_size += ost->data_size; break;
1395 case AVMEDIA_TYPE_SUBTITLE: subtitle_size += ost->data_size; break;
1396 default: other_size += ost->data_size; break;
1397 }
862120f9 1398 extra_size += ost->enc_ctx->extradata_size;
afa442c1 1399 data_size += ost->data_size;
94d68a41
MN
1400 if ( (ost->enc_ctx->flags & (AV_CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))
1401 != AV_CODEC_FLAG_PASS1)
4fe38441 1402 pass1_used = 0;
afa442c1
MN
1403 }
1404
b3f46150 1405 if (data_size && total_size>0 && total_size >= data_size)
afa442c1
MN
1406 percent = 100.0 * (total_size - data_size) / data_size;
1407
afa442c1
MN
1408 av_log(NULL, AV_LOG_INFO, "video:%1.0fkB audio:%1.0fkB subtitle:%1.0fkB other streams:%1.0fkB global headers:%1.0fkB muxing overhead: ",
1409 video_size / 1024.0,
1410 audio_size / 1024.0,
1411 subtitle_size / 1024.0,
1412 other_size / 1024.0,
1413 extra_size / 1024.0);
1414 if (percent >= 0.0)
1415 av_log(NULL, AV_LOG_INFO, "%f%%", percent);
1416 else
1417 av_log(NULL, AV_LOG_INFO, "unknown");
1418 av_log(NULL, AV_LOG_INFO, "\n");
47543450
AK
1419
1420 /* print verbose per-stream stats */
1421 for (i = 0; i < nb_input_files; i++) {
1422 InputFile *f = input_files[i];
1423 uint64_t total_packets = 0, total_size = 0;
1424
1425 av_log(NULL, AV_LOG_VERBOSE, "Input file #%d (%s):\n",
1426 i, f->ctx->filename);
1427
1428 for (j = 0; j < f->nb_streams; j++) {
1429 InputStream *ist = input_streams[f->ist_index + j];
d0979357 1430 enum AVMediaType type = ist->dec_ctx->codec_type;
47543450
AK
1431
1432 total_size += ist->data_size;
1433 total_packets += ist->nb_packets;
1434
1435 av_log(NULL, AV_LOG_VERBOSE, " Input stream #%d:%d (%s): ",
1436 i, j, media_type_string(type));
1437 av_log(NULL, AV_LOG_VERBOSE, "%"PRIu64" packets read (%"PRIu64" bytes); ",
1438 ist->nb_packets, ist->data_size);
1439
1440 if (ist->decoding_needed) {
1441 av_log(NULL, AV_LOG_VERBOSE, "%"PRIu64" frames decoded",
1442 ist->frames_decoded);
1443 if (type == AVMEDIA_TYPE_AUDIO)
1444 av_log(NULL, AV_LOG_VERBOSE, " (%"PRIu64" samples)", ist->samples_decoded);
1445 av_log(NULL, AV_LOG_VERBOSE, "; ");
1446 }
1447
1448 av_log(NULL, AV_LOG_VERBOSE, "\n");
1449 }
1450
1451 av_log(NULL, AV_LOG_VERBOSE, " Total: %"PRIu64" packets (%"PRIu64" bytes) demuxed\n",
1452 total_packets, total_size);
1453 }
1454
1455 for (i = 0; i < nb_output_files; i++) {
1456 OutputFile *of = output_files[i];
1457 uint64_t total_packets = 0, total_size = 0;
1458
1459 av_log(NULL, AV_LOG_VERBOSE, "Output file #%d (%s):\n",
1460 i, of->ctx->filename);
1461
1462 for (j = 0; j < of->ctx->nb_streams; j++) {
1463 OutputStream *ost = output_streams[of->ost_index + j];
862120f9 1464 enum AVMediaType type = ost->enc_ctx->codec_type;
47543450
AK
1465
1466 total_size += ost->data_size;
1467 total_packets += ost->packets_written;
1468
1469 av_log(NULL, AV_LOG_VERBOSE, " Output stream #%d:%d (%s): ",
1470 i, j, media_type_string(type));
1471 if (ost->encoding_needed) {
1472 av_log(NULL, AV_LOG_VERBOSE, "%"PRIu64" frames encoded",
1473 ost->frames_encoded);
1474 if (type == AVMEDIA_TYPE_AUDIO)
1475 av_log(NULL, AV_LOG_VERBOSE, " (%"PRIu64" samples)", ost->samples_encoded);
1476 av_log(NULL, AV_LOG_VERBOSE, "; ");
1477 }
1478
1479 av_log(NULL, AV_LOG_VERBOSE, "%"PRIu64" packets muxed (%"PRIu64" bytes); ",
1480 ost->packets_written, ost->data_size);
1481
1482 av_log(NULL, AV_LOG_VERBOSE, "\n");
1483 }
1484
1485 av_log(NULL, AV_LOG_VERBOSE, " Total: %"PRIu64" packets (%"PRIu64" bytes) muxed\n",
1486 total_packets, total_size);
1487 }
afa442c1 1488 if(video_size + data_size + audio_size + subtitle_size + extra_size == 0){
4fe38441
MN
1489 av_log(NULL, AV_LOG_WARNING, "Output file is empty, nothing was encoded ");
1490 if (pass1_used) {
1491 av_log(NULL, AV_LOG_WARNING, "\n");
1492 } else {
1493 av_log(NULL, AV_LOG_WARNING, "(check -ss / -t / -frames parameters if used)\n");
1494 }
afa442c1
MN
1495 }
1496}
1497
11a1033c 1498static void print_report(int is_last_report, int64_t timer_start, int64_t cur_time)
4b961ddf 1499{
6291d7e4 1500 char buf[1024];
11a1033c 1501 AVBPrint buf_script;
6291d7e4
AK
1502 OutputStream *ost;
1503 AVFormatContext *oc;
1504 int64_t total_size;
1505 AVCodecContext *enc;
1506 int frame_number, vid, i;
11a1033c 1507 double bitrate;
9d1fb9ef 1508 double speed;
2f4374fa 1509 int64_t pts = INT64_MIN + 1;
6291d7e4
AK
1510 static int64_t last_time = -1;
1511 static int qp_histogram[52];
11a1033c 1512 int hours, mins, secs, us;
a956840c 1513 int ret;
9d1fb9ef 1514 float t;
2fc354f9 1515
11a1033c 1516 if (!print_stats && !is_last_report && !progress_avio)
fc49f22c 1517 return;
2fc354f9 1518
6291d7e4 1519 if (!is_last_report) {
6291d7e4
AK
1520 if (last_time == -1) {
1521 last_time = cur_time;
10d104e4 1522 return;
9e1cc598 1523 }
6291d7e4
AK
1524 if ((cur_time - last_time) < 500000)
1525 return;
1526 last_time = cur_time;
10d104e4
PG
1527 }
1528
9d1fb9ef
MB
1529 t = (cur_time-timer_start) / 1000000.0;
1530
cf7fc795 1531
2e215267 1532 oc = output_files[0]->ctx;
cf7fc795 1533
6291d7e4 1534 total_size = avio_size(oc->pb);
1b891d17 1535 if (total_size <= 0) // FIXME improve avio_size() so it works with non seekable output too
7636c8c6 1536 total_size = avio_tell(oc->pb);
cf7fc795 1537
6291d7e4 1538 buf[0] = '\0';
6291d7e4 1539 vid = 0;
11a1033c 1540 av_bprint_init(&buf_script, 0, 1);
ea9367e9 1541 for (i = 0; i < nb_output_streams; i++) {
6291d7e4 1542 float q = -1;
2e215267 1543 ost = output_streams[i];
862120f9 1544 enc = ost->enc_ctx;
e5bae39f
MN
1545 if (!ost->stream_copy)
1546 q = ost->quality / (float) FF_QP2LAMBDA;
1547
6291d7e4
AK
1548 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1549 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
11a1033c
MN
1550 av_bprintf(&buf_script, "stream_%d_%d_q=%.1f\n",
1551 ost->file_index, ost->index, q);
cf7fc795 1552 }
6291d7e4 1553 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
9d1fb9ef 1554 float fps;
cf7fc795 1555
6291d7e4 1556 frame_number = ost->frame_number;
11a1033c
MN
1557 fps = t > 1 ? frame_number / t : 0;
1558 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3.*f q=%3.1f ",
1559 frame_number, fps < 9.95, fps, q);
1560 av_bprintf(&buf_script, "frame=%d\n", frame_number);
1561 av_bprintf(&buf_script, "fps=%.1f\n", fps);
1562 av_bprintf(&buf_script, "stream_%d_%d_q=%.1f\n",
1563 ost->file_index, ost->index, q);
7636c8c6 1564 if (is_last_report)
6291d7e4 1565 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
7636c8c6 1566 if (qp_hist) {
6291d7e4
AK
1567 int j;
1568 int qp = lrintf(q);
7636c8c6 1569 if (qp >= 0 && qp < FF_ARRAY_ELEMS(qp_histogram))
6291d7e4 1570 qp_histogram[qp]++;
7636c8c6 1571 for (j = 0; j < 32; j++)
369b161d 1572 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", av_log2(qp_histogram[j] + 1));
85f07f22 1573 }
495eee01 1574
8c2f00d5 1575 if ((enc->flags & AV_CODEC_FLAG_PSNR) && (ost->pict_type != AV_PICTURE_TYPE_NONE || is_last_report)) {
6291d7e4 1576 int j;
7636c8c6
AD
1577 double error, error_sum = 0;
1578 double scale, scale_sum = 0;
11a1033c 1579 double p;
7636c8c6 1580 char type[3] = { 'Y','U','V' };
6291d7e4 1581 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
7636c8c6
AD
1582 for (j = 0; j < 3; j++) {
1583 if (is_last_report) {
1584 error = enc->error[j];
1585 scale = enc->width * enc->height * 255.0 * 255.0 * frame_number;
1586 } else {
cdb0225f 1587 error = ost->error[j];
7636c8c6 1588 scale = enc->width * enc->height * 255.0 * 255.0;
4dbce51b 1589 }
7636c8c6
AD
1590 if (j)
1591 scale /= 4;
6291d7e4
AK
1592 error_sum += error;
1593 scale_sum += scale;
11a1033c
MN
1594 p = psnr(error / scale);
1595 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], p);
1596 av_bprintf(&buf_script, "stream_%d_%d_psnr_%c=%2.2f\n",
e20f2dc0 1597 ost->file_index, ost->index, type[j] | 32, p);
6291d7e4 1598 }
11a1033c 1599 p = psnr(error_sum / scale_sum);
7636c8c6 1600 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum / scale_sum));
11a1033c
MN
1601 av_bprintf(&buf_script, "stream_%d_%d_psnr_all=%2.2f\n",
1602 ost->file_index, ost->index, p);
6291d7e4
AK
1603 }
1604 vid = 1;
85f07f22 1605 }
6291d7e4 1606 /* compute min output value */
1f359c85
MN
1607 if (av_stream_get_end_pts(ost->st) != AV_NOPTS_VALUE)
1608 pts = FFMAX(pts, av_rescale_q(av_stream_get_end_pts(ost->st),
18217bb0 1609 ost->st->time_base, AV_TIME_BASE_Q));
9f6d48d6 1610 if (is_last_report)
dfa98c4f 1611 nb_frames_drop += ost->last_dropped;
85f07f22
FB
1612 }
1613
23849339
MN
1614 secs = FFABS(pts) / AV_TIME_BASE;
1615 us = FFABS(pts) % AV_TIME_BASE;
11a1033c
MN
1616 mins = secs / 60;
1617 secs %= 60;
1618 hours = mins / 60;
1619 mins %= 60;
c5e1e982 1620
750382d5 1621 bitrate = pts && total_size >= 0 ? total_size * 8 / (pts / 1000.0) : -1;
9d1fb9ef 1622 speed = t != 0.0 ? (double)pts / AV_TIME_BASE / t : -1;
411cc5c4 1623
750382d5
SS
1624 if (total_size < 0) snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1625 "size=N/A time=");
1626 else snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1627 "size=%8.0fkB time=", total_size / 1024.0);
23849339
MN
1628 if (pts < 0)
1629 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "-");
11a1033c
MN
1630 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1631 "%02d:%02d:%02d.%02d ", hours, mins, secs,
1632 (100 * us) / AV_TIME_BASE);
4184d344 1633
1634 if (bitrate < 0) {
1635 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),"bitrate=N/A");
1636 av_bprintf(&buf_script, "bitrate=N/A\n");
1637 }else{
1638 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),"bitrate=%6.1fkbits/s", bitrate);
1639 av_bprintf(&buf_script, "bitrate=%6.1fkbits/s\n", bitrate);
1640 }
1641
750382d5
SS
1642 if (total_size < 0) av_bprintf(&buf_script, "total_size=N/A\n");
1643 else av_bprintf(&buf_script, "total_size=%"PRId64"\n", total_size);
11a1033c
MN
1644 av_bprintf(&buf_script, "out_time_ms=%"PRId64"\n", pts);
1645 av_bprintf(&buf_script, "out_time=%02d:%02d:%02d.%06d\n",
1646 hours, mins, secs, us);
6291d7e4 1647
e3245b26
AK
1648 if (nb_frames_dup || nb_frames_drop)
1649 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1650 nb_frames_dup, nb_frames_drop);
11a1033c
MN
1651 av_bprintf(&buf_script, "dup_frames=%d\n", nb_frames_dup);
1652 av_bprintf(&buf_script, "drop_frames=%d\n", nb_frames_drop);
6291d7e4 1653
9d1fb9ef
MB
1654 if (speed < 0) {
1655 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf)," speed=N/A");
1656 av_bprintf(&buf_script, "speed=N/A\n");
1657 } else {
1658 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf)," speed=%4.3gx", speed);
1659 av_bprintf(&buf_script, "speed=%4.3gx\n", speed);
1660 }
1661
11a1033c 1662 if (print_stats || is_last_report) {
8b43b0e8 1663 const char end = is_last_report ? '\n' : '\r';
9af8179c 1664 if (print_stats==1 && AV_LOG_INFO > av_log_get_level()) {
9421d974 1665 fprintf(stderr, "%s %c", buf, end);
9af8179c 1666 } else
9421d974 1667 av_log(NULL, AV_LOG_INFO, "%s %c", buf, end);
6291d7e4 1668
e3245b26 1669 fflush(stderr);
85f07f22
FB
1670 }
1671
11a1033c
MN
1672 if (progress_avio) {
1673 av_bprintf(&buf_script, "progress=%s\n",
1674 is_last_report ? "end" : "continue");
1675 avio_write(progress_avio, buf_script.str,
1676 FFMIN(buf_script.len, buf_script.size - 1));
1677 avio_flush(progress_avio);
1678 av_bprint_finalize(&buf_script, NULL);
1679 if (is_last_report) {
a956840c
GA
1680 if ((ret = avio_closep(&progress_avio)) < 0)
1681 av_log(NULL, AV_LOG_ERROR,
1682 "Error closing progress log, loss of information possible: %s\n", av_err2str(ret));
6d1ba1ac
LA
1683 }
1684 }
002c95d7 1685
afa442c1
MN
1686 if (is_last_report)
1687 print_final_stats(total_size);
6291d7e4 1688}
002c95d7 1689
ea9367e9 1690static void flush_encoders(void)
4a4ce2e7
AK
1691{
1692 int i, ret;
3b266da3 1693
ea9367e9 1694 for (i = 0; i < nb_output_streams; i++) {
2e215267 1695 OutputStream *ost = output_streams[i];
862120f9 1696 AVCodecContext *enc = ost->enc_ctx;
2e215267 1697 AVFormatContext *os = output_files[ost->file_index]->ctx;
ee458cb1 1698 int stop_encoding = 0;
6f1c66d5 1699
b62b5cb6 1700 if (!ost->encoding_needed)
6f1c66d5
AK
1701 continue;
1702
862120f9 1703 if (enc->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <= 1)
6f1c66d5 1704 continue;
a34dfc93 1705#if FF_API_LAVF_FMT_RAWPICTURE
862120f9 1706 if (enc->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE) && enc->codec->id == AV_CODEC_ID_RAWVIDEO)
6f1c66d5 1707 continue;
a34dfc93 1708#endif
6f1c66d5 1709
7636c8c6 1710 for (;;) {
369cb092
AK
1711 int (*encode)(AVCodecContext*, AVPacket*, const AVFrame*, int*) = NULL;
1712 const char *desc;
6f1c66d5 1713
862120f9 1714 switch (enc->codec_type) {
6f1c66d5 1715 case AVMEDIA_TYPE_AUDIO:
369cb092 1716 encode = avcodec_encode_audio2;
b91093a4 1717 desc = "audio";
6f1c66d5
AK
1718 break;
1719 case AVMEDIA_TYPE_VIDEO:
369cb092 1720 encode = avcodec_encode_video2;
b91093a4 1721 desc = "video";
369cb092
AK
1722 break;
1723 default:
1724 stop_encoding = 1;
1725 }
1726
1727 if (encode) {
1728 AVPacket pkt;
3868e97c 1729 int pkt_size;
369cb092
AK
1730 int got_packet;
1731 av_init_packet(&pkt);
1732 pkt.data = NULL;
1733 pkt.size = 0;
1734
11a1033c 1735 update_benchmark(NULL);
369cb092 1736 ret = encode(enc, &pkt, NULL, &got_packet);
b91093a4 1737 update_benchmark("flush_%s %d.%d", desc, ost->file_index, ost->index);
6f1c66d5 1738 if (ret < 0) {
b3d2035e
MN
1739 av_log(NULL, AV_LOG_FATAL, "%s encoding failed: %s\n",
1740 desc,
1741 av_err2str(ret));
636ced8e 1742 exit_program(1);
6f1c66d5 1743 }
6f1c66d5
AK
1744 if (ost->logfile && enc->stats_out) {
1745 fprintf(ost->logfile, "%s", enc->stats_out);
1746 }
8e37038a 1747 if (!got_packet) {
ee458cb1
JR
1748 stop_encoding = 1;
1749 break;
1750 }
740e6042 1751 if (ost->finished & MUXER_FINISHED) {
c2f861ca 1752 av_packet_unref(&pkt);
5c459504
MN
1753 continue;
1754 }
afa7ab55 1755 av_packet_rescale_ts(&pkt, enc->time_base, ost->st->time_base);
3868e97c 1756 pkt_size = pkt.size;
ee458cb1 1757 write_frame(os, &pkt, ost);
137c5e11 1758 if (ost->enc_ctx->codec_type == AVMEDIA_TYPE_VIDEO && vstats_filename) {
3868e97c 1759 do_video_stats(ost, pkt_size);
e98fab13 1760 }
3b266da3 1761 }
369cb092 1762
ee458cb1 1763 if (stop_encoding)
6f1c66d5 1764 break;
3b266da3
AK
1765 }
1766 }
4a4ce2e7 1767}
3b266da3 1768
7204ec1a
AK
1769/*
1770 * Check whether a packet from ist should be written into ost at this time
1771 */
1772static int check_output_constraints(InputStream *ist, OutputStream *ost)
1773{
2e215267
AK
1774 OutputFile *of = output_files[ost->file_index];
1775 int ist_index = input_files[ist->file_index]->ist_index + ist->st->index;
259a960f 1776
7204ec1a
AK
1777 if (ost->source_index != ist_index)
1778 return 0;
3b266da3 1779
4ff77d44
MN
1780 if (ost->finished)
1781 return 0;
1782
3fa72de8 1783 if (of->start_time != AV_NOPTS_VALUE && ist->pts < of->start_time)
7204ec1a 1784 return 0;
3b266da3 1785
7204ec1a
AK
1786 return 1;
1787}
3b266da3 1788
7204ec1a
AK
1789static void do_streamcopy(InputStream *ist, OutputStream *ost, const AVPacket *pkt)
1790{
2e215267 1791 OutputFile *of = output_files[ost->file_index];
488a0fa6 1792 InputFile *f = input_files [ist->file_index];
56ee3f9d
AK
1793 int64_t start_time = (of->start_time == AV_NOPTS_VALUE) ? 0 : of->start_time;
1794 int64_t ost_tb_start_time = av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
11a1033c 1795 AVPicture pict;
7204ec1a 1796 AVPacket opkt;
002c95d7 1797
7204ec1a
AK
1798 av_init_packet(&opkt);
1799
1800 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) &&
1801 !ost->copy_initial_nonkeyframes)
1802 return;
1803
bf2590ae
RC
1804 if (!ost->frame_number && !ost->copy_prior_start) {
1805 int64_t comp_start = start_time;
1806 if (copy_ts && f->start_time != AV_NOPTS_VALUE)
1807 comp_start = FFMAX(start_time, f->start_time + f->ts_offset);
1808 if (pkt->pts == AV_NOPTS_VALUE ?
1809 ist->pts < comp_start :
1810 pkt->pts < av_rescale_q(comp_start, AV_TIME_BASE_Q, ist->st->time_base))
e816a8bc
JR
1811 return;
1812 }
65f7aee6 1813
1270e12e 1814 if (of->recording_time != INT64_MAX &&
3fa72de8 1815 ist->pts >= of->recording_time + start_time) {
8b61abac 1816 close_output_stream(ost);
1270e12e 1817 return;
002c95d7
BC
1818 }
1819
488a0fa6
AK
1820 if (f->recording_time != INT64_MAX) {
1821 start_time = f->ctx->start_time;
5b6c0fdb 1822 if (f->start_time != AV_NOPTS_VALUE && copy_ts)
488a0fa6 1823 start_time += f->start_time;
b7fc2693
MN
1824 if (ist->pts >= f->recording_time + start_time) {
1825 close_output_stream(ost);
488a0fa6
AK
1826 return;
1827 }
1828 }
1829
7204ec1a 1830 /* force the input stream PTS */
862120f9 1831 if (ost->enc_ctx->codec_type == AVMEDIA_TYPE_VIDEO)
7204ec1a 1832 ost->sync_opts++;
85f07f22 1833
7204ec1a
AK
1834 if (pkt->pts != AV_NOPTS_VALUE)
1835 opkt.pts = av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1836 else
1837 opkt.pts = AV_NOPTS_VALUE;
2f51ec2b 1838
7204ec1a 1839 if (pkt->dts == AV_NOPTS_VALUE)
11a1033c 1840 opkt.dts = av_rescale_q(ist->dts, AV_TIME_BASE_Q, ost->st->time_base);
7204ec1a
AK
1841 else
1842 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1843 opkt.dts -= ost_tb_start_time;
2f51ec2b 1844
1909dbf1 1845 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->dts != AV_NOPTS_VALUE) {
921d5ae3 1846 int duration = av_get_audio_frame_duration(ist->dec_ctx, pkt->size);
1909dbf1 1847 if(!duration)
921d5ae3 1848 duration = ist->dec_ctx->frame_size;
1909dbf1 1849 opkt.dts = opkt.pts = av_rescale_delta(ist->st->time_base, pkt->dts,
921d5ae3 1850 (AVRational){1, ist->dec_ctx->sample_rate}, duration, &ist->filter_in_rescale_delta_last,
9f088712 1851 ost->st->time_base) - ost_tb_start_time;
1909dbf1
MN
1852 }
1853
7204ec1a
AK
1854 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1855 opkt.flags = pkt->flags;
7636c8c6 1856 // FIXME remove the following 2 lines they shall be replaced by the bitstream filters
45f3d4e6
MN
1857 if ( ost->st->codec->codec_id != AV_CODEC_ID_H264
1858 && ost->st->codec->codec_id != AV_CODEC_ID_MPEG1VIDEO
1859 && ost->st->codec->codec_id != AV_CODEC_ID_MPEG2VIDEO
1860 && ost->st->codec->codec_id != AV_CODEC_ID_VC1
7204ec1a 1861 ) {
ac0ba6f2 1862 int ret = av_parser_change(ost->parser, ost->st->codec,
0460b9bb
MN
1863 &opkt.data, &opkt.size,
1864 pkt->data, pkt->size,
ac0ba6f2
MN
1865 pkt->flags & AV_PKT_FLAG_KEY);
1866 if (ret < 0) {
b3d2035e
MN
1867 av_log(NULL, AV_LOG_FATAL, "av_parser_change failed: %s\n",
1868 av_err2str(ret));
ac0ba6f2
MN
1869 exit_program(1);
1870 }
1871 if (ret) {
9b2dc295
AK
1872 opkt.buf = av_buffer_create(opkt.data, opkt.size, av_buffer_default_free, NULL, 0);
1873 if (!opkt.buf)
636ced8e 1874 exit_program(1);
9b2dc295 1875 }
7204ec1a
AK
1876 } else {
1877 opkt.data = pkt->data;
1878 opkt.size = pkt->size;
2f51ec2b 1879 }
df87cfd7 1880 av_copy_packet_side_data(&opkt, pkt);
2f51ec2b 1881
a34dfc93 1882#if FF_API_LAVF_FMT_RAWPICTURE
c8890941
MN
1883 if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1884 ost->st->codec->codec_id == AV_CODEC_ID_RAWVIDEO &&
1885 (of->ctx->oformat->flags & AVFMT_RAWPICTURE)) {
11a1033c 1886 /* store AVPicture in AVPacket, as expected by the output format */
15ff3f3f
MN
1887 int ret = avpicture_fill(&pict, opkt.data, ost->st->codec->pix_fmt, ost->st->codec->width, ost->st->codec->height);
1888 if (ret < 0) {
b3d2035e
MN
1889 av_log(NULL, AV_LOG_FATAL, "avpicture_fill failed: %s\n",
1890 av_err2str(ret));
15ff3f3f
MN
1891 exit_program(1);
1892 }
11a1033c
MN
1893 opkt.data = (uint8_t *)&pict;
1894 opkt.size = sizeof(AVPicture);
1895 opkt.flags |= AV_PKT_FLAG_KEY;
1896 }
a34dfc93 1897#endif
2f51ec2b 1898
f15f02c2 1899 write_frame(of->ctx, &opkt, ost);
1cadab60 1900}
a508e7a1 1901
f5e66827 1902int guess_input_channel_layout(InputStream *ist)
1cadab60 1903{
d0979357 1904 AVCodecContext *dec = ist->dec_ctx;
1cadab60 1905
369cb092
AK
1906 if (!dec->channel_layout) {
1907 char layout_name[256];
1cadab60 1908
fccd8c21
NG
1909 if (dec->channels > ist->guess_layout_max)
1910 return 0;
369cb092
AK
1911 dec->channel_layout = av_get_default_channel_layout(dec->channels);
1912 if (!dec->channel_layout)
1913 return 0;
1914 av_get_channel_layout_string(layout_name, sizeof(layout_name),
1915 dec->channels, dec->channel_layout);
1916 av_log(NULL, AV_LOG_WARNING, "Guessed Channel Layout for Input Stream "
1917 "#%d.%d : %s\n", ist->file_index, ist->st->index, layout_name);
1cadab60 1918 }
369cb092 1919 return 1;
1cadab60
NG
1920}
1921
b69b43e2 1922static void check_decode_result(InputStream *ist, int *got_output, int ret)
e2b416b6
MB
1923{
1924 if (*got_output || ret<0)
1925 decode_error_stat[ret<0] ++;
1926
1927 if (ret < 0 && exit_on_error)
1928 exit_program(1);
b69b43e2
MB
1929
1930 if (exit_on_error && *got_output && ist) {
1931 if (av_frame_get_decode_error_flags(ist->decoded_frame) || (ist->decoded_frame->flags & AV_FRAME_FLAG_CORRUPT)) {
1932 av_log(NULL, AV_LOG_FATAL, "%s: corrupt decoded frame in stream %d\n", input_files[ist->file_index]->ctx->filename, ist->st->index);
1933 exit_program(1);
1934 }
1935 }
e2b416b6
MB
1936}
1937
0629f612 1938static int decode_audio(InputStream *ist, AVPacket *pkt, int *got_output)
25e87fc5 1939{
9b2dc295 1940 AVFrame *decoded_frame, *f;
d0979357 1941 AVCodecContext *avctx = ist->dec_ctx;
9b2dc295 1942 int i, ret, err = 0, resample_changed;
11a1033c 1943 AVRational decoded_frame_tb;
ded28ba3 1944
0ee905e2 1945 if (!ist->decoded_frame && !(ist->decoded_frame = av_frame_alloc()))
d1241ff3 1946 return AVERROR(ENOMEM);
9b2dc295
AK
1947 if (!ist->filter_frame && !(ist->filter_frame = av_frame_alloc()))
1948 return AVERROR(ENOMEM);
9179f27c 1949 decoded_frame = ist->decoded_frame;
ded28ba3 1950
11a1033c 1951 update_benchmark(NULL);
d1241ff3 1952 ret = avcodec_decode_audio4(avctx, decoded_frame, got_output, pkt);
11a1033c 1953 update_benchmark("decode_audio %d.%d", ist->file_index, ist->st->index);
b7e9eea3
MN
1954
1955 if (ret >= 0 && avctx->sample_rate <= 0) {
11a1033c 1956 av_log(avctx, AV_LOG_ERROR, "Sample rate %d invalid\n", avctx->sample_rate);
429c6cab 1957 ret = AVERROR_INVALIDDATA;
25e87fc5 1958 }
ded28ba3 1959
b69b43e2 1960 check_decode_result(ist, got_output, ret);
cd64ead8 1961
a50b0082 1962 if (!*got_output || ret < 0)
af8ad892 1963 return ret;
25e87fc5 1964
47543450
AK
1965 ist->samples_decoded += decoded_frame->nb_samples;
1966 ist->frames_decoded++;
1967
11a1033c
MN
1968#if 1
1969 /* increment next_dts to use for the case where the input stream does not
1970 have timestamps or there are multiple frames in the packet */
1971 ist->next_pts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /
1972 avctx->sample_rate;
1973 ist->next_dts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /
1974 avctx->sample_rate;
1975#endif
5db5169e 1976
369cb092
AK
1977 resample_changed = ist->resample_sample_fmt != decoded_frame->format ||
1978 ist->resample_channels != avctx->channels ||
1979 ist->resample_channel_layout != decoded_frame->channel_layout ||
1980 ist->resample_sample_rate != decoded_frame->sample_rate;
1981 if (resample_changed) {
1982 char layout1[64], layout2[64];
5db5169e 1983
369cb092
AK
1984 if (!guess_input_channel_layout(ist)) {
1985 av_log(NULL, AV_LOG_FATAL, "Unable to find default channel "
1986 "layout for Input Stream #%d.%d\n", ist->file_index,
1987 ist->st->index);
636ced8e 1988 exit_program(1);
369cb092
AK
1989 }
1990 decoded_frame->channel_layout = avctx->channel_layout;
5db5169e 1991
369cb092
AK
1992 av_get_channel_layout_string(layout1, sizeof(layout1), ist->resample_channels,
1993 ist->resample_channel_layout);
1994 av_get_channel_layout_string(layout2, sizeof(layout2), avctx->channels,
1995 decoded_frame->channel_layout);
5db5169e 1996
369cb092
AK
1997 av_log(NULL, AV_LOG_INFO,
1998 "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",
1999 ist->file_index, ist->st->index,
2000 ist->resample_sample_rate, av_get_sample_fmt_name(ist->resample_sample_fmt),
2001 ist->resample_channels, layout1,
2002 decoded_frame->sample_rate, av_get_sample_fmt_name(decoded_frame->format),
2003 avctx->channels, layout2);
2004
2005 ist->resample_sample_fmt = decoded_frame->format;
2006 ist->resample_sample_rate = decoded_frame->sample_rate;
2007 ist->resample_channel_layout = decoded_frame->channel_layout;
2008 ist->resample_channels = avctx->channels;
2009
2010 for (i = 0; i < nb_filtergraphs; i++)
11a1033c
MN
2011 if (ist_in_filtergraph(filtergraphs[i], ist)) {
2012 FilterGraph *fg = filtergraphs[i];
11a1033c
MN
2013 if (configure_filtergraph(fg) < 0) {
2014 av_log(NULL, AV_LOG_FATAL, "Error reinitializing filters!\n");
f982d006 2015 exit_program(1);
11a1033c 2016 }
369cb092 2017 }
5db5169e
AK
2018 }
2019
11a1033c
MN
2020 /* if the decoder provides a pts, use it instead of the last packet pts.
2021 the decoder could be delaying output by a packet or more. */
2022 if (decoded_frame->pts != AV_NOPTS_VALUE) {
2023 ist->dts = ist->next_dts = ist->pts = ist->next_pts = av_rescale_q(decoded_frame->pts, avctx->time_base, AV_TIME_BASE_Q);
2024 decoded_frame_tb = avctx->time_base;
2025 } else if (decoded_frame->pkt_pts != AV_NOPTS_VALUE) {
2026 decoded_frame->pts = decoded_frame->pkt_pts;
11a1033c
MN
2027 decoded_frame_tb = ist->st->time_base;
2028 } else if (pkt->pts != AV_NOPTS_VALUE) {
2029 decoded_frame->pts = pkt->pts;
11a1033c
MN
2030 decoded_frame_tb = ist->st->time_base;
2031 }else {
2032 decoded_frame->pts = ist->dts;
2033 decoded_frame_tb = AV_TIME_BASE_Q;
2034 }
3bf189bb 2035 pkt->pts = AV_NOPTS_VALUE;
715129cd 2036 if (decoded_frame->pts != AV_NOPTS_VALUE)
a9d97e1b 2037 decoded_frame->pts = av_rescale_delta(decoded_frame_tb, decoded_frame->pts,
d0979357
MN
2038 (AVRational){1, avctx->sample_rate}, decoded_frame->nb_samples, &ist->filter_in_rescale_delta_last,
2039 (AVRational){1, avctx->sample_rate});
9ccd9062 2040 ist->nb_samples = decoded_frame->nb_samples;
9b2dc295
AK
2041 for (i = 0; i < ist->nb_filters; i++) {
2042 if (i < ist->nb_filters - 1) {
2043 f = ist->filter_frame;
2044 err = av_frame_ref(f, decoded_frame);
2045 if (err < 0)
2046 break;
2047 } else
2048 f = decoded_frame;
32fdfdfb 2049 err = av_buffersrc_add_frame_flags(ist->filters[i]->filter, f,
fb14e37d 2050 AV_BUFFERSRC_FLAG_PUSH);
fc82f4a1
NG
2051 if (err == AVERROR_EOF)
2052 err = 0; /* ignore */
9b2dc295
AK
2053 if (err < 0)
2054 break;
2055 }
11a1033c 2056 decoded_frame->pts = AV_NOPTS_VALUE;
369cb092 2057
9b2dc295
AK
2058 av_frame_unref(ist->filter_frame);
2059 av_frame_unref(decoded_frame);
2060 return err < 0 ? err : ret;
5db5169e
AK
2061}
2062
0629f612 2063static int decode_video(InputStream *ist, AVPacket *pkt, int *got_output)
5db5169e 2064{
9b2dc295 2065 AVFrame *decoded_frame, *f;
9b2dc295 2066 int i, ret = 0, err = 0, resample_changed;
11a1033c
MN
2067 int64_t best_effort_timestamp;
2068 AVRational *frame_sample_aspect;
5db5169e 2069
9b2dc295
AK
2070 if (!ist->decoded_frame && !(ist->decoded_frame = av_frame_alloc()))
2071 return AVERROR(ENOMEM);
2072 if (!ist->filter_frame && !(ist->filter_frame = av_frame_alloc()))
45d4b66f 2073 return AVERROR(ENOMEM);
9179f27c 2074 decoded_frame = ist->decoded_frame;
11a1033c 2075 pkt->dts = av_rescale_q(ist->dts, AV_TIME_BASE_Q, ist->st->time_base);
5db5169e 2076
11a1033c 2077 update_benchmark(NULL);
d0979357 2078 ret = avcodec_decode_video2(ist->dec_ctx,
45d4b66f 2079 decoded_frame, got_output, pkt);
11a1033c 2080 update_benchmark("decode_video %d.%d", ist->file_index, ist->st->index);
a0b2de77
MN
2081
2082 // The following line may be required in some cases where there is no parser
2083 // or the parser does not has_b_frames correctly
768ef0f1 2084 if (ist->st->codec->has_b_frames < ist->dec_ctx->has_b_frames) {
5ded0b39
MN
2085 if (ist->dec_ctx->codec_id == AV_CODEC_ID_H264) {
2086 ist->st->codec->has_b_frames = ist->dec_ctx->has_b_frames;
2087 } else
9c29aa71
AC
2088 av_log(ist->dec_ctx, AV_LOG_WARNING,
2089 "has_b_frames is larger in decoder than demuxer %d > %d.\n"
2090 "If you want to help, upload a sample "
2091 "of this file to ftp://upload.ffmpeg.org/incoming/ "
2092 "and contact the ffmpeg-devel mailing list. (ffmpeg-devel@ffmpeg.org)",
2093 ist->dec_ctx->has_b_frames,
2094 ist->st->codec->has_b_frames);
768ef0f1 2095 }
eedcac68 2096
b69b43e2 2097 check_decode_result(ist, got_output, ret);
cd64ead8 2098
98e8a9e2
MN
2099 if (*got_output && ret >= 0) {
2100 if (ist->dec_ctx->width != decoded_frame->width ||
2101 ist->dec_ctx->height != decoded_frame->height ||
2102 ist->dec_ctx->pix_fmt != decoded_frame->format) {
2103 av_log(NULL, AV_LOG_DEBUG, "Frame parameters mismatch context %d,%d,%d != %d,%d,%d\n",
2104 decoded_frame->width,
2105 decoded_frame->height,
2106 decoded_frame->format,
2107 ist->dec_ctx->width,
2108 ist->dec_ctx->height,
2109 ist->dec_ctx->pix_fmt);
2110 }
2111 }
2112
a50b0082 2113 if (!*got_output || ret < 0)
af8ad892 2114 return ret;
5db5169e 2115
11a1033c
MN
2116 if(ist->top_field_first>=0)
2117 decoded_frame->top_field_first = ist->top_field_first;
5db5169e 2118
47543450
AK
2119 ist->frames_decoded++;
2120
07fd0a22 2121 if (ist->hwaccel_retrieve_data && decoded_frame->format == ist->hwaccel_pix_fmt) {
d0979357 2122 err = ist->hwaccel_retrieve_data(ist->dec_ctx, decoded_frame);
07fd0a22
AK
2123 if (err < 0)
2124 goto fail;
2125 }
62e10c37
MN
2126 ist->hwaccel_retrieved_pix_fmt = decoded_frame->format;
2127
11a1033c 2128 best_effort_timestamp= av_frame_get_best_effort_timestamp(decoded_frame);
5590ab45
MN
2129 if(best_effort_timestamp != AV_NOPTS_VALUE) {
2130 int64_t ts = av_rescale_q(decoded_frame->pts = best_effort_timestamp, ist->st->time_base, AV_TIME_BASE_Q);
2131
2132 if (ts != AV_NOPTS_VALUE)
2133 ist->next_pts = ist->pts = ts;
2134 }
5db5169e 2135
11a1033c
MN
2136 if (debug_ts) {
2137 av_log(NULL, AV_LOG_INFO, "decoder -> ist_index:%d type:video "
290da7e7
SS
2138 "frame_pts:%s frame_pts_time:%s best_effort_ts:%"PRId64" best_effort_ts_time:%s keyframe:%d frame_type:%d time_base:%d/%d\n",
2139 ist->st->index, av_ts2str(decoded_frame->pts),
2140 av_ts2timestr(decoded_frame->pts, &ist->st->time_base),
2141 best_effort_timestamp,
2142 av_ts2timestr(best_effort_timestamp, &ist->st->time_base),
2143 decoded_frame->key_frame, decoded_frame->pict_type,
2144 ist->st->time_base.num, ist->st->time_base.den);
5db5169e 2145 }
5db5169e 2146
45d4b66f 2147 pkt->size = 0;
5db5169e 2148
695ec04e
AK
2149 if (ist->st->sample_aspect_ratio.num)
2150 decoded_frame->sample_aspect_ratio = ist->st->sample_aspect_ratio;
5db5169e 2151
e77c8662
AK
2152 resample_changed = ist->resample_width != decoded_frame->width ||
2153 ist->resample_height != decoded_frame->height ||
2154 ist->resample_pix_fmt != decoded_frame->format;
2155 if (resample_changed) {
2156 av_log(NULL, AV_LOG_INFO,
2157 "Input stream #%d:%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
2158 ist->file_index, ist->st->index,
2159 ist->resample_width, ist->resample_height, av_get_pix_fmt_name(ist->resample_pix_fmt),
2160 decoded_frame->width, decoded_frame->height, av_get_pix_fmt_name(decoded_frame->format));
5db5169e 2161
e77c8662
AK
2162 ist->resample_width = decoded_frame->width;
2163 ist->resample_height = decoded_frame->height;
2164 ist->resample_pix_fmt = decoded_frame->format;
5db5169e 2165
3e0b29cc
MN
2166 for (i = 0; i < nb_filtergraphs; i++) {
2167 if (ist_in_filtergraph(filtergraphs[i], ist) && ist->reinit_filters &&
3b266da3 2168 configure_filtergraph(filtergraphs[i]) < 0) {
ac646076 2169 av_log(NULL, AV_LOG_FATAL, "Error reinitializing filters!\n");
636ced8e 2170 exit_program(1);
3b266da3 2171 }
3e0b29cc 2172 }
5db5169e 2173 }
5db5169e 2174
11a1033c 2175 frame_sample_aspect= av_opt_ptr(avcodec_get_frame_class(), decoded_frame, "sample_aspect_ratio");
3b266da3 2176 for (i = 0; i < ist->nb_filters; i++) {
11a1033c
MN
2177 if (!frame_sample_aspect->num)
2178 *frame_sample_aspect = ist->st->sample_aspect_ratio;
32fdfdfb 2179
9b2dc295
AK
2180 if (i < ist->nb_filters - 1) {
2181 f = ist->filter_frame;
2182 err = av_frame_ref(f, decoded_frame);
2183 if (err < 0)
2184 break;
04a14d4d 2185 } else
9b2dc295 2186 f = decoded_frame;
f6c9a325 2187 ret = av_buffersrc_add_frame_flags(ist->filters[i]->filter, f, AV_BUFFERSRC_FLAG_PUSH);
fc82f4a1
NG
2188 if (ret == AVERROR_EOF) {
2189 ret = 0; /* ignore */
2190 } else if (ret < 0) {
f6c9a325
SS
2191 av_log(NULL, AV_LOG_FATAL,
2192 "Failed to inject frame into filter network: %s\n", av_err2str(ret));
f982d006 2193 exit_program(1);
11a1033c 2194 }
45d4b66f 2195 }
5db5169e 2196
07fd0a22 2197fail:
9b2dc295
AK
2198 av_frame_unref(ist->filter_frame);
2199 av_frame_unref(decoded_frame);
9b2dc295 2200 return err < 0 ? err : ret;
5db5169e 2201}
5db5169e 2202
9595234c 2203static int transcode_subtitles(InputStream *ist, AVPacket *pkt, int *got_output)
93ed69ad 2204{
9595234c 2205 AVSubtitle subtitle;
d0979357 2206 int i, ret = avcodec_decode_subtitle2(ist->dec_ctx,
9595234c 2207 &subtitle, got_output, pkt);
eedcac68 2208
b69b43e2 2209 check_decode_result(NULL, got_output, ret);
cd64ead8 2210
11a1033c
MN
2211 if (ret < 0 || !*got_output) {
2212 if (!pkt->size)
2213 sub2video_flush(ist);
af8ad892 2214 return ret;
b51469a0 2215 }
a38469e1 2216
0cad101e 2217 if (ist->fix_sub_duration) {
31bb172b 2218 int end = 1;
0cad101e 2219 if (ist->prev_sub.got_output) {
31bb172b
MB
2220 end = av_rescale(subtitle.pts - ist->prev_sub.subtitle.pts,
2221 1000, AV_TIME_BASE);
0cad101e 2222 if (end < ist->prev_sub.subtitle.end_display_time) {
921d5ae3 2223 av_log(ist->dec_ctx, AV_LOG_DEBUG,
31bb172b
MB
2224 "Subtitle duration reduced from %d to %d%s\n",
2225 ist->prev_sub.subtitle.end_display_time, end,
2226 end <= 0 ? ", dropping it" : "");
0cad101e
NG
2227 ist->prev_sub.subtitle.end_display_time = end;
2228 }
2229 }
0cad101e
NG
2230 FFSWAP(int, *got_output, ist->prev_sub.got_output);
2231 FFSWAP(int, ret, ist->prev_sub.ret);
2232 FFSWAP(AVSubtitle, subtitle, ist->prev_sub.subtitle);
31bb172b
MB
2233 if (end <= 0)
2234 goto out;
0cad101e
NG
2235 }
2236
3e396ca8
MB
2237 if (!*got_output)
2238 return ret;
2239
a9e48177 2240 sub2video_update(ist, &subtitle);
1b9a2514 2241
3e396ca8 2242 if (!subtitle.num_rects)
4d6f2ff5 2243 goto out;
0cad101e 2244
47543450
AK
2245 ist->frames_decoded++;
2246
9595234c 2247 for (i = 0; i < nb_output_streams; i++) {
2e215267 2248 OutputStream *ost = output_streams[i];
5db5169e 2249
b79dfd16
MN
2250 if (!check_output_constraints(ist, ost) || !ost->encoding_needed
2251 || ost->enc->type != AVMEDIA_TYPE_SUBTITLE)
ad51c68c 2252 continue;
9e8aae44 2253
6d8b3263 2254 do_subtitle_out(output_files[ost->file_index]->ctx, ost, ist, &subtitle);
9595234c 2255 }
303e50e6 2256
4d6f2ff5 2257out:
9595234c 2258 avsubtitle_free(&subtitle);
af8ad892 2259 return ret;
9595234c 2260}
545465ec 2261
a50b0082
MN
2262static int send_filter_eof(InputStream *ist)
2263{
2264 int i, ret;
2265 for (i = 0; i < ist->nb_filters; i++) {
a50b0082 2266 ret = av_buffersrc_add_frame(ist->filters[i]->filter, NULL);
a50b0082
MN
2267 if (ret < 0)
2268 return ret;
2269 }
2270 return 0;
2271}
2272
6291d7e4 2273/* pkt = NULL means EOF (needed to flush decoder buffers) */
9ccd9062 2274static int process_input_packet(InputStream *ist, const AVPacket *pkt, int no_eof)
6291d7e4 2275{
11a1033c 2276 int ret = 0, i;
f7a02d5d 2277 int got_output = 0;
85f07f22 2278
6291d7e4 2279 AVPacket avpkt;
11a1033c 2280 if (!ist->saw_first_ts) {
921d5ae3 2281 ist->dts = ist->st->avg_frame_rate.num ? - ist->dec_ctx->has_b_frames * AV_TIME_BASE / av_q2d(ist->st->avg_frame_rate) : 0;
11a1033c 2282 ist->pts = 0;
81a663f4 2283 if (pkt && pkt->pts != AV_NOPTS_VALUE && !ist->decoding_needed) {
11a1033c
MN
2284 ist->dts += av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
2285 ist->pts = ist->dts; //unused but better to set it to a value thats not totally wrong
157f9569 2286 }
11a1033c
MN
2287 ist->saw_first_ts = 1;
2288 }
157f9569 2289
3101bb66 2290 if (ist->next_dts == AV_NOPTS_VALUE)
11a1033c
MN
2291 ist->next_dts = ist->dts;
2292 if (ist->next_pts == AV_NOPTS_VALUE)
2293 ist->next_pts = ist->pts;
fec401f7 2294
fb33bff9 2295 if (!pkt) {
6291d7e4
AK
2296 /* EOF handling */
2297 av_init_packet(&avpkt);
2298 avpkt.data = NULL;
2299 avpkt.size = 0;
2300 goto handle_eof;
2301 } else {
2302 avpkt = *pkt;
2303 }
8833f375 2304
11a1033c
MN
2305 if (pkt->dts != AV_NOPTS_VALUE) {
2306 ist->next_dts = ist->dts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
921d5ae3 2307 if (ist->dec_ctx->codec_type != AVMEDIA_TYPE_VIDEO || !ist->decoding_needed)
03e44bcb 2308 ist->next_pts = ist->pts = ist->dts;
11a1033c 2309 }
5d12b83f 2310
7636c8c6 2311 // while we have more to decode or while the decoder did output something on EOF
2a651b71 2312 while (ist->decoding_needed && (avpkt.size > 0 || (!pkt && got_output))) {
11a1033c 2313 int duration;
6291d7e4 2314 handle_eof:
72bd8100 2315
11a1033c
MN
2316 ist->pts = ist->next_pts;
2317 ist->dts = ist->next_dts;
88fc1438 2318
d1780e01 2319 if (avpkt.size && avpkt.size != pkt->size &&
444e9874 2320 !(ist->dec->capabilities & AV_CODEC_CAP_SUBFRAMES)) {
e3245b26
AK
2321 av_log(NULL, ist->showed_multi_packet_warning ? AV_LOG_VERBOSE : AV_LOG_WARNING,
2322 "Multiple frames in a packet from stream %d\n", pkt->stream_index);
8b0268a8 2323 ist->showed_multi_packet_warning = 1;
fe08925f 2324 }
cf7fc795 2325
d0979357 2326 switch (ist->dec_ctx->codec_type) {
82963f8f 2327 case AVMEDIA_TYPE_AUDIO:
0629f612 2328 ret = decode_audio (ist, &avpkt, &got_output);
82963f8f
AK
2329 break;
2330 case AVMEDIA_TYPE_VIDEO:
0629f612 2331 ret = decode_video (ist, &avpkt, &got_output);
11a1033c
MN
2332 if (avpkt.duration) {
2333 duration = av_rescale_q(avpkt.duration, ist->st->time_base, AV_TIME_BASE_Q);
137f7a63 2334 } else if(ist->dec_ctx->framerate.num != 0 && ist->dec_ctx->framerate.den != 0) {
8bbadc9b 2335 int ticks= av_stream_get_parser(ist->st) ? av_stream_get_parser(ist->st)->repeat_pict+1 : ist->dec_ctx->ticks_per_frame;
11a1033c 2336 duration = ((int64_t)AV_TIME_BASE *
137f7a63
MN
2337 ist->dec_ctx->framerate.den * ticks) /
2338 ist->dec_ctx->framerate.num / ist->dec_ctx->ticks_per_frame;
11a1033c
MN
2339 } else
2340 duration = 0;
115329f1 2341
11a1033c
MN
2342 if(ist->dts != AV_NOPTS_VALUE && duration) {
2343 ist->next_dts += duration;
2344 }else
2345 ist->next_dts = AV_NOPTS_VALUE;
a700a6ae 2346
11a1033c
MN
2347 if (got_output)
2348 ist->next_pts += duration; //FIXME the duration is not correct in some cases
82963f8f
AK
2349 break;
2350 case AVMEDIA_TYPE_SUBTITLE:
2351 ret = transcode_subtitles(ist, &avpkt, &got_output);
2352 break;
78162b4e
AK
2353 default:
2354 return -1;
a700a6ae 2355 }
85f07f22 2356
a5f409bc
MN
2357 if (ret < 0) {
2358 av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d:%d: %s\n",
2359 ist->file_index, ist->st->index, av_err2str(ret));
2360 if (exit_on_error)
2361 exit_program(1);
2362 break;
2363 }
c4e37247 2364
11a1033c
MN
2365 avpkt.dts=
2366 avpkt.pts= AV_NOPTS_VALUE;
37f5cd5a 2367
aa38cff2
JG
2368 // touch data and size only if not EOF
2369 if (pkt) {
921d5ae3 2370 if(ist->dec_ctx->codec_type != AVMEDIA_TYPE_AUDIO)
11a1033c 2371 ret = avpkt.size;
aa38cff2
JG
2372 avpkt.data += ret;
2373 avpkt.size -= ret;
85f07f22 2374 }
82963f8f 2375 if (!got_output) {
af8ad892 2376 continue;
85f07f22 2377 }
c69f7299
MN
2378 if (got_output && !pkt)
2379 break;
85f07f22 2380 }
85f07f22 2381
a50b0082 2382 /* after flushing, send an EOF on all the filter inputs attached to the stream */
9ccd9062
HL
2383 /* except when looping we need to flush but not to send an EOF */
2384 if (!pkt && ist->decoding_needed && !got_output && !no_eof) {
a50b0082
MN
2385 int ret = send_filter_eof(ist);
2386 if (ret < 0) {
2387 av_log(NULL, AV_LOG_FATAL, "Error marking filters as finished\n");
2388 exit_program(1);
2389 }
2390 }
2391
7204ec1a 2392 /* handle stream copy */
2a651b71 2393 if (!ist->decoding_needed) {
11a1033c 2394 ist->dts = ist->next_dts;
d0979357 2395 switch (ist->dec_ctx->codec_type) {
2a651b71 2396 case AVMEDIA_TYPE_AUDIO:
d0979357
MN
2397 ist->next_dts += ((int64_t)AV_TIME_BASE * ist->dec_ctx->frame_size) /
2398 ist->dec_ctx->sample_rate;
2a651b71
AK
2399 break;
2400 case AVMEDIA_TYPE_VIDEO:
356363c8 2401 if (ist->framerate.num) {
1c0d8f25
CEH
2402 // TODO: Remove work-around for c99-to-c89 issue 7
2403 AVRational time_base_q = AV_TIME_BASE_Q;
2404 int64_t next_dts = av_rescale_q(ist->next_dts, time_base_q, av_inv_q(ist->framerate));
2405 ist->next_dts = av_rescale_q(next_dts + 1, av_inv_q(ist->framerate), time_base_q);
356363c8 2406 } else if (pkt->duration) {
11a1033c 2407 ist->next_dts += av_rescale_q(pkt->duration, ist->st->time_base, AV_TIME_BASE_Q);
137f7a63 2408 } else if(ist->dec_ctx->framerate.num != 0) {
8bbadc9b 2409 int ticks= av_stream_get_parser(ist->st) ? av_stream_get_parser(ist->st)->repeat_pict + 1 : ist->dec_ctx->ticks_per_frame;
3101bb66 2410 ist->next_dts += ((int64_t)AV_TIME_BASE *
137f7a63
MN
2411 ist->dec_ctx->framerate.den * ticks) /
2412 ist->dec_ctx->framerate.num / ist->dec_ctx->ticks_per_frame;
85f07f22 2413 }
2a651b71 2414 break;
85f07f22 2415 }
11a1033c
MN
2416 ist->pts = ist->dts;
2417 ist->next_pts = ist->next_dts;
85f07f22 2418 }
ea9367e9 2419 for (i = 0; pkt && i < nb_output_streams; i++) {
2e215267 2420 OutputStream *ost = output_streams[i];
ab6d194a 2421
7204ec1a
AK
2422 if (!check_output_constraints(ist, ost) || ost->encoding_needed)
2423 continue;
1ff93ffc 2424
7204ec1a
AK
2425 do_streamcopy(ist, ost, pkt);
2426 }
a5df11ab 2427
c69f7299 2428 return got_output;
e3ee3283
AB
2429}
2430
ea9367e9 2431static void print_sdp(void)
85f07f22 2432{
a23abaf3 2433 char sdp[16384];
af70aa45 2434 int i;
cc63da12
ST
2435 int j;
2436 AVIOContext *sdp_pb;
a3477fef 2437 AVFormatContext **avc = av_malloc_array(nb_output_files, sizeof(*avc));
85f07f22 2438
af70aa45 2439 if (!avc)
636ced8e 2440 exit_program(1);
cc63da12
ST
2441 for (i = 0, j = 0; i < nb_output_files; i++) {
2442 if (!strcmp(output_files[i]->ctx->oformat->name, "rtp")) {
2443 avc[j] = output_files[i]->ctx;
2444 j++;
2445 }
2446 }
2447
70fb5ead
ST
2448 if (!j)
2449 goto fail;
2450
cc63da12
ST
2451 av_sdp_create(avc, j, sdp, sizeof(sdp));
2452
2453 if (!sdp_filename) {
2454 printf("SDP:\n%s\n", sdp);
2455 fflush(stdout);
2456 } else {
2457 if (avio_open2(&sdp_pb, sdp_filename, AVIO_FLAG_WRITE, &int_cb, NULL) < 0) {
2458 av_log(NULL, AV_LOG_ERROR, "Failed to open sdp file '%s'\n", sdp_filename);
2459 } else {
2460 avio_printf(sdp_pb, "SDP:\n%s", sdp);
78cb3c06 2461 avio_closep(&sdp_pb);
627f5658 2462 av_freep(&sdp_filename);
cc63da12
ST
2463 }
2464 }
2d726b19 2465
70fb5ead 2466fail:
af70aa45 2467 av_freep(&avc);
2d726b19
MN
2468}
2469
07fd0a22
AK
2470static const HWAccel *get_hwaccel(enum AVPixelFormat pix_fmt)
2471{
2472 int i;
2473 for (i = 0; hwaccels[i].name; i++)
2474 if (hwaccels[i].pix_fmt == pix_fmt)
2475 return &hwaccels[i];
2476 return NULL;
2477}
2478
2479static enum AVPixelFormat get_format(AVCodecContext *s, const enum AVPixelFormat *pix_fmts)
2480{
2481 InputStream *ist = s->opaque;
2482 const enum AVPixelFormat *p;
2483 int ret;
2484
2485 for (p = pix_fmts; *p != -1; p++) {
2486 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(*p);
2487 const HWAccel *hwaccel;
2488
2489 if (!(desc->flags & AV_PIX_FMT_FLAG_HWACCEL))
2490 break;
2491
2492 hwaccel = get_hwaccel(*p);
2493 if (!hwaccel ||
2494 (ist->active_hwaccel_id && ist->active_hwaccel_id != hwaccel->id) ||
2495 (ist->hwaccel_id != HWACCEL_AUTO && ist->hwaccel_id != hwaccel->id))
2496 continue;
2497
2498 ret = hwaccel->init(s);
2499 if (ret < 0) {
2500 if (ist->hwaccel_id == hwaccel->id) {
2501 av_log(NULL, AV_LOG_FATAL,
2502 "%s hwaccel requested for input stream #%d:%d, "
2503 "but cannot be initialized.\n", hwaccel->name,
2504 ist->file_index, ist->st->index);
f063a0b3 2505 return AV_PIX_FMT_NONE;
07fd0a22
AK
2506 }
2507 continue;
2508 }
2509 ist->active_hwaccel_id = hwaccel->id;
2510 ist->hwaccel_pix_fmt = *p;
2511 break;
2512 }
2513
2514 return *p;
2515}
2516
2517static int get_buffer(AVCodecContext *s, AVFrame *frame, int flags)
2518{
2519 InputStream *ist = s->opaque;
2520
2521 if (ist->hwaccel_get_buffer && frame->format == ist->hwaccel_pix_fmt)
2522 return ist->hwaccel_get_buffer(s, frame, flags);
2523
2524 return avcodec_default_get_buffer2(s, frame, flags);
2525}
2526
ea9367e9 2527static int init_input_stream(int ist_index, char *error, int error_len)
2d726b19 2528{
e3a91c51 2529 int ret;
2e215267 2530 InputStream *ist = input_streams[ist_index];
2d726b19 2531
630902a1
AK
2532 if (ist->decoding_needed) {
2533 AVCodec *codec = ist->dec;
630902a1 2534 if (!codec) {
11a1033c 2535 snprintf(error, error_len, "Decoder (codec %s) not found for input stream #%d:%d",
d0979357 2536 avcodec_get_name(ist->dec_ctx->codec_id), ist->file_index, ist->st->index);
630902a1 2537 return AVERROR(EINVAL);
88bfe451 2538 }
88bfe451 2539
d0979357
MN
2540 ist->dec_ctx->opaque = ist;
2541 ist->dec_ctx->get_format = get_format;
2542 ist->dec_ctx->get_buffer2 = get_buffer;
2543 ist->dec_ctx->thread_safe_callbacks = 1;
07fd0a22 2544
d0979357 2545 av_opt_set_int(ist->dec_ctx, "refcounted_frames", 1, 0);
b01d2a55
MN
2546 if (ist->dec_ctx->codec_id == AV_CODEC_ID_DVB_SUBTITLE &&
2547 (ist->decoding_needed & DECODING_FOR_OST)) {
a2dbf379 2548 av_dict_set(&ist->decoder_opts, "compute_edt", "1", AV_DICT_DONT_OVERWRITE);
b01d2a55
MN
2549 if (ist->decoding_needed & DECODING_FOR_FILTER)
2550 av_log(NULL, AV_LOG_WARNING, "Warning using DVB subtitles for filtering and output at the same time is not fully supported, also see -compute_edt [0|1]\n");
2551 }
64dca32c 2552
6433618d
CB
2553 av_dict_set(&ist->decoder_opts, "sub_text_format", "ass", AV_DICT_DONT_OVERWRITE);
2554
f3a6ad22
AK
2555 if (!av_dict_get(ist->decoder_opts, "threads", NULL, 0))
2556 av_dict_set(&ist->decoder_opts, "threads", "auto", 0);
d0979357 2557 if ((ret = avcodec_open2(ist->dec_ctx, codec, &ist->decoder_opts)) < 0) {
c854102d
NC
2558 if (ret == AVERROR_EXPERIMENTAL)
2559 abort_codec_experimental(codec, 0);
42cc6cef 2560
42cc6cef
LB
2561 snprintf(error, error_len,
2562 "Error while opening decoder for input stream "
2563 "#%d:%d : %s",
094516a5 2564 ist->file_index, ist->st->index, av_err2str(ret));
c854102d 2565 return ret;
88bfe451 2566 }
f3a6ad22 2567 assert_avoptions(ist->decoder_opts);
3b266da3 2568 }
88bfe451 2569
11a1033c 2570 ist->next_pts = AV_NOPTS_VALUE;
3101bb66 2571 ist->next_dts = AV_NOPTS_VALUE;
88bfe451 2572
eb8bc572 2573 return 0;
85f07f22
FB
2574}
2575
3b266da3 2576static InputStream *get_input_stream(OutputStream *ost)
e3b540b4 2577{
3b266da3
AK
2578 if (ost->source_index >= 0)
2579 return input_streams[ost->source_index];
3b266da3 2580 return NULL;
e3b540b4
LB
2581}
2582
beb5d8f0
NG
2583static int compare_int64(const void *a, const void *b)
2584{
92e483f8 2585 return FFDIFFSIGN(*(const int64_t *)a, *(const int64_t *)b);
beb5d8f0
NG
2586}
2587
15fbf3e7
MN
2588static int init_output_stream(OutputStream *ost, char *error, int error_len)
2589{
2590 int ret = 0;
2591
2592 if (ost->encoding_needed) {
2593 AVCodec *codec = ost->enc;
2594 AVCodecContext *dec = NULL;
2595 InputStream *ist;
2596
2597 if ((ist = get_input_stream(ost)))
2598 dec = ist->dec_ctx;
2599 if (dec && dec->subtitle_header) {
2600 /* ASS code assumes this buffer is null terminated so add extra byte. */
2601 ost->enc_ctx->subtitle_header = av_mallocz(dec->subtitle_header_size + 1);
2602 if (!ost->enc_ctx->subtitle_header)
2603 return AVERROR(ENOMEM);
2604 memcpy(ost->enc_ctx->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2605 ost->enc_ctx->subtitle_header_size = dec->subtitle_header_size;
2606 }
2607 if (!av_dict_get(ost->encoder_opts, "threads", NULL, 0))
2608 av_dict_set(&ost->encoder_opts, "threads", "auto", 0);
628a73f8
MN
2609 if (ost->enc->type == AVMEDIA_TYPE_AUDIO &&
2610 !codec->defaults &&
2611 !av_dict_get(ost->encoder_opts, "b", NULL, 0) &&
2612 !av_dict_get(ost->encoder_opts, "ab", NULL, 0))
2613 av_dict_set(&ost->encoder_opts, "b", "128000", 0);
15fbf3e7 2614
259fef86
DB
2615 if (ost->filter && ost->filter->filter->inputs[0]->hw_frames_ctx) {
2616 ost->enc_ctx->hw_frames_ctx = av_buffer_ref(ost->filter->filter->inputs[0]->hw_frames_ctx);
2617 if (!ost->enc_ctx->hw_frames_ctx)
2618 return AVERROR(ENOMEM);
2619 }
2620
15fbf3e7
MN
2621 if ((ret = avcodec_open2(ost->enc_ctx, codec, &ost->encoder_opts)) < 0) {
2622 if (ret == AVERROR_EXPERIMENTAL)
2623 abort_codec_experimental(codec, 1);
2624 snprintf(error, error_len,
2625 "Error while opening encoder for output stream #%d:%d - "
2626 "maybe incorrect parameters such as bit_rate, rate, width or height",
2627 ost->file_index, ost->index);
2628 return ret;
2629 }
2630 if (ost->enc->type == AVMEDIA_TYPE_AUDIO &&
444e9874 2631 !(ost->enc->capabilities & AV_CODEC_CAP_VARIABLE_FRAME_SIZE))
15fbf3e7
MN
2632 av_buffersink_set_frame_size(ost->filter->filter,
2633 ost->enc_ctx->frame_size);
2634 assert_avoptions(ost->encoder_opts);
2635 if (ost->enc_ctx->bit_rate && ost->enc_ctx->bit_rate < 1000)
2636 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2637 " It takes bits/s as argument, not kbits/s\n");
2638
2639 ret = avcodec_copy_context(ost->st->codec, ost->enc_ctx);
2640 if (ret < 0) {
2641 av_log(NULL, AV_LOG_FATAL,
2642 "Error initializing the output stream codec context.\n");
2643 exit_program(1);
2644 }
2645
be52b95d
HL
2646 if (ost->enc_ctx->nb_coded_side_data) {
2647 int i;
2648
2649 ost->st->side_data = av_realloc_array(NULL, ost->enc_ctx->nb_coded_side_data,
2650 sizeof(*ost->st->side_data));
2651 if (!ost->st->side_data)
2652 return AVERROR(ENOMEM);
2653
2654 for (i = 0; i < ost->enc_ctx->nb_coded_side_data; i++) {
2655 const AVPacketSideData *sd_src = &ost->enc_ctx->coded_side_data[i];
2656 AVPacketSideData *sd_dst = &ost->st->side_data[i];
2657
2658 sd_dst->data = av_malloc(sd_src->size);
2659 if (!sd_dst->data)
2660 return AVERROR(ENOMEM);
2661 memcpy(sd_dst->data, sd_src->data, sd_src->size);
2662 sd_dst->size = sd_src->size;
2663 sd_dst->type = sd_src->type;
2664 ost->st->nb_side_data++;
2665 }
2666 }
2667
15fbf3e7
MN
2668 // copy timebase while removing common factors
2669 ost->st->time_base = av_add_q(ost->enc_ctx->time_base, (AVRational){0, 1});
2670 ost->st->codec->codec= ost->enc_ctx->codec;
2671 } else {
2672 ret = av_opt_set_dict(ost->enc_ctx, &ost->encoder_opts);
2673 if (ret < 0) {
2674 av_log(NULL, AV_LOG_FATAL,
2675 "Error setting up codec context options.\n");
2676 return ret;
2677 }
2678 // copy timebase while removing common factors
2679 ost->st->time_base = av_add_q(ost->st->codec->time_base, (AVRational){0, 1});
2680 }
2681
2682 return ret;
2683}
2684
19ad5673
AK
2685static void parse_forced_key_frames(char *kf, OutputStream *ost,
2686 AVCodecContext *avctx)
f5cd136f 2687{
19ad5673 2688 char *p;
beb5d8f0
NG
2689 int n = 1, i, size, index = 0;
2690 int64_t t, *pts;
f5cd136f 2691
19ad5673
AK
2692 for (p = kf; *p; p++)
2693 if (*p == ',')
2694 n++;
beb5d8f0 2695 size = n;
a3477fef 2696 pts = av_malloc_array(size, sizeof(*pts));
beb5d8f0 2697 if (!pts) {
19ad5673 2698 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
636ced8e 2699 exit_program(1);
f5cd136f
CB
2700 }
2701
4c679750 2702 p = kf;
19ad5673 2703 for (i = 0; i < n; i++) {
4c679750 2704 char *next = strchr(p, ',');
f5cd136f 2705
4c679750
RD
2706 if (next)
2707 *next++ = 0;
2708
beb5d8f0
NG
2709 if (!memcmp(p, "chapters", 8)) {
2710
2711 AVFormatContext *avf = output_files[ost->file_index]->ctx;
2712 int j;
2713
2714 if (avf->nb_chapters > INT_MAX - size ||
2715 !(pts = av_realloc_f(pts, size += avf->nb_chapters - 1,
2716 sizeof(*pts)))) {
2717 av_log(NULL, AV_LOG_FATAL,
2718 "Could not allocate forced key frames array.\n");
f982d006 2719 exit_program(1);
beb5d8f0
NG
2720 }
2721 t = p[8] ? parse_time_or_die("force_key_frames", p + 8, 1) : 0;
2722 t = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
2723
2724 for (j = 0; j < avf->nb_chapters; j++) {
2725 AVChapter *c = avf->chapters[j];
2726 av_assert1(index < size);
2727 pts[index++] = av_rescale_q(c->start, c->time_base,
2728 avctx->time_base) + t;
2729 }
2730
2731 } else {
2732
2733 t = parse_time_or_die("force_key_frames", p, 1);
2734 av_assert1(index < size);
2735 pts[index++] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
2736
2737 }
4c679750
RD
2738
2739 p = next;
f5cd136f 2740 }
beb5d8f0
NG
2741
2742 av_assert0(index == size);
2743 qsort(pts, size, sizeof(*pts), compare_int64);
2744 ost->forced_kf_count = size;
2745 ost->forced_kf_pts = pts;
f5cd136f
CB
2746}
2747
11a1033c 2748static void report_new_stream(int input_index, AVPacket *pkt)
1829e195 2749{
11a1033c
MN
2750 InputFile *file = input_files[input_index];
2751 AVStream *st = file->ctx->streams[pkt->stream_index];
2752
2753 if (pkt->stream_index < file->nb_streams_warn)
2754 return;
2755 av_log(file->ctx, AV_LOG_WARNING,
2756 "New %s stream %d:%d at pos:%"PRId64" and DTS:%ss\n",
2757 av_get_media_type_string(st->codec->codec_type),
2758 input_index, pkt->stream_index,
2759 pkt->pos, av_ts2timestr(pkt->dts, &st->time_base));
2760 file->nb_streams_warn = pkt->stream_index + 1;
1829e195
AK
2761}
2762
6656370b
AK
2763static void set_encoder_id(OutputFile *of, OutputStream *ost)
2764{
2765 AVDictionaryEntry *e;
2766
2767 uint8_t *encoder_string;
2768 int encoder_string_len;
2769 int format_flags = 0;
bbee02ed 2770 int codec_flags = 0;
6656370b 2771
b2a8bc3d
MN
2772 if (av_dict_get(ost->st->metadata, "encoder", NULL, 0))
2773 return;
2774
6656370b
AK
2775 e = av_dict_get(of->opts, "fflags", NULL, 0);
2776 if (e) {
2777 const AVOption *o = av_opt_find(of->ctx, "fflags", NULL, 0, 0);
2778 if (!o)
2779 return;
2780 av_opt_eval_flags(of->ctx, o, e->value, &format_flags);
2781 }
bbee02ed
MN
2782 e = av_dict_get(ost->encoder_opts, "flags", NULL, 0);
2783 if (e) {
137c5e11 2784 const AVOption *o = av_opt_find(ost->enc_ctx, "flags", NULL, 0, 0);
bbee02ed
MN
2785 if (!o)
2786 return;
137c5e11 2787 av_opt_eval_flags(ost->enc_ctx, o, e->value, &codec_flags);
bbee02ed 2788 }
6656370b
AK
2789
2790 encoder_string_len = sizeof(LIBAVCODEC_IDENT) + strlen(ost->enc->name) + 2;
2791 encoder_string = av_mallocz(encoder_string_len);
2792 if (!encoder_string)
2793 exit_program(1);
2794
94d68a41 2795 if (!(format_flags & AVFMT_FLAG_BITEXACT) && !(codec_flags & AV_CODEC_FLAG_BITEXACT))
6656370b 2796 av_strlcpy(encoder_string, LIBAVCODEC_IDENT " ", encoder_string_len);
0c152fe9
MN
2797 else
2798 av_strlcpy(encoder_string, "Lavc ", encoder_string_len);
6656370b
AK
2799 av_strlcat(encoder_string, ost->enc->name, encoder_string_len);
2800 av_dict_set(&ost->st->metadata, "encoder", encoder_string,
2801 AV_DICT_DONT_STRDUP_VAL | AV_DICT_DONT_OVERWRITE);
2802}
2803
ea9367e9 2804static int transcode_init(void)
6291d7e4 2805{
2c474ddb 2806 int ret = 0, i, j, k;
1bb77e51 2807 AVFormatContext *oc;
4288e031 2808 OutputStream *ost;
6291d7e4 2809 InputStream *ist;
6d1a2efb 2810 char error[1024] = {0};
6291d7e4 2811 int want_sdp = 1;
4c1da0d1 2812
a72bf5fd
MN
2813 for (i = 0; i < nb_filtergraphs; i++) {
2814 FilterGraph *fg = filtergraphs[i];
2815 for (j = 0; j < fg->nb_outputs; j++) {
2816 OutputFilter *ofilter = fg->outputs[j];
b3625792 2817 if (!ofilter->ost || ofilter->ost->source_index >= 0)
a72bf5fd
MN
2818 continue;
2819 if (fg->nb_inputs != 1)
2820 continue;
2821 for (k = nb_input_streams-1; k >= 0 ; k--)
2822 if (fg->inputs[0]->ist == input_streams[k])
2823 break;
2824 ofilter->ost->source_index = k;
2825 }
2826 }
2827
f4805328
AK
2828 /* init framerate emulation */
2829 for (i = 0; i < nb_input_files; i++) {
2e215267 2830 InputFile *ifile = input_files[i];
f4805328
AK
2831 if (ifile->rate_emu)
2832 for (j = 0; j < ifile->nb_streams; j++)
76191c08 2833 input_streams[j + ifile->ist_index]->start = av_gettime_relative();
552ec4c9 2834 }
0a38bafd 2835
6291d7e4 2836 /* for each output stream, we compute the right encoding parameters */
4288e031 2837 for (i = 0; i < nb_output_streams; i++) {
65ed9e75 2838 AVCodecContext *enc_ctx;
650a5206 2839 AVCodecContext *dec_ctx = NULL;
2e215267
AK
2840 ost = output_streams[i];
2841 oc = output_files[ost->file_index]->ctx;
3b266da3 2842 ist = get_input_stream(ost);
8833f375 2843
4dbc6cee
AK
2844 if (ost->attachment_filename)
2845 continue;
4568325a 2846
95989463 2847 enc_ctx = ost->stream_copy ? ost->st->codec : ost->enc_ctx;
868013aa 2848
3b266da3 2849 if (ist) {
d0979357 2850 dec_ctx = ist->dec_ctx;
868013aa 2851
3b266da3 2852 ost->st->disposition = ist->st->disposition;
65ed9e75
AK
2853 enc_ctx->bits_per_raw_sample = dec_ctx->bits_per_raw_sample;
2854 enc_ctx->chroma_sample_location = dec_ctx->chroma_sample_location;
a443b973
MN
2855 } else {
2856 for (j=0; j<oc->nb_streams; j++) {
2857 AVStream *st = oc->streams[j];
1efc0892 2858 if (st != ost->st && st->codec->codec_type == enc_ctx->codec_type)
a443b973
MN
2859 break;
2860 }
2861 if (j == oc->nb_streams)
1efc0892 2862 if (enc_ctx->codec_type == AVMEDIA_TYPE_AUDIO || enc_ctx->codec_type == AVMEDIA_TYPE_VIDEO)
a443b973 2863 ost->st->disposition = AV_DISPOSITION_DEFAULT;
3b266da3 2864 }
4a897224 2865
3d813e4c 2866 if (ost->stream_copy) {
538bf767 2867 AVRational sar;
8c4022ac 2868 uint64_t extra_size;
81e46555 2869
8c4022ac 2870 av_assert0(ist && !ost->filter);
2e215267 2871
29d147c9 2872 extra_size = (uint64_t)dec_ctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE;
81e46555 2873
e6d2b737 2874 if (extra_size > INT_MAX) {
eaf2d37a 2875 return AVERROR(EINVAL);
e6d2b737 2876 }
2e215267 2877
6291d7e4 2878 /* if stream_copy is selected, no need to decode or encode */
65ed9e75
AK
2879 enc_ctx->codec_id = dec_ctx->codec_id;
2880 enc_ctx->codec_type = dec_ctx->codec_type;
81e46555 2881
65ed9e75 2882 if (!enc_ctx->codec_tag) {
9a038a95 2883 unsigned int codec_tag;
03f30c83 2884 if (!oc->oformat->codec_tag ||
65ed9e75 2885 av_codec_get_id (oc->oformat->codec_tag, dec_ctx->codec_tag) == enc_ctx->codec_id ||
1f40536c 2886 !av_codec_get_tag2(oc->oformat->codec_tag, dec_ctx->codec_id, &codec_tag))
65ed9e75 2887 enc_ctx->codec_tag = dec_ctx->codec_tag;
6291d7e4 2888 }
81e46555 2889
65ed9e75
AK
2890 enc_ctx->bit_rate = dec_ctx->bit_rate;
2891 enc_ctx->rc_max_rate = dec_ctx->rc_max_rate;
2892 enc_ctx->rc_buffer_size = dec_ctx->rc_buffer_size;
2893 enc_ctx->field_order = dec_ctx->field_order;
4d02dfbd
MN
2894 if (dec_ctx->extradata_size) {
2895 enc_ctx->extradata = av_mallocz(extra_size);
2896 if (!enc_ctx->extradata) {
2897 return AVERROR(ENOMEM);
2898 }
2899 memcpy(enc_ctx->extradata, dec_ctx->extradata, dec_ctx->extradata_size);
e6d2b737 2900 }
1efc0892
MN
2901 enc_ctx->extradata_size= dec_ctx->extradata_size;
2902 enc_ctx->bits_per_coded_sample = dec_ctx->bits_per_coded_sample;
6bca574a 2903
1efc0892 2904 enc_ctx->time_base = ist->st->time_base;
11a1033c
MN
2905 /*
2906 * Avi is a special case here because it supports variable fps but
2907 * having the fps and timebase differe significantly adds quite some
2908 * overhead
2909 */
2910 if(!strcmp(oc->oformat->name, "avi")) {
2911 if ( copy_tb<0 && av_q2d(ist->st->r_frame_rate) >= av_q2d(ist->st->avg_frame_rate)
2912 && 0.5/av_q2d(ist->st->r_frame_rate) > av_q2d(ist->st->time_base)
1f40536c
MN
2913 && 0.5/av_q2d(ist->st->r_frame_rate) > av_q2d(dec_ctx->time_base)
2914 && av_q2d(ist->st->time_base) < 1.0/500 && av_q2d(dec_ctx->time_base) < 1.0/500
11a1033c 2915 || copy_tb==2){
1efc0892
MN
2916 enc_ctx->time_base.num = ist->st->r_frame_rate.den;
2917 enc_ctx->time_base.den = 2*ist->st->r_frame_rate.num;
2918 enc_ctx->ticks_per_frame = 2;
1f40536c 2919 } else if ( copy_tb<0 && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > 2*av_q2d(ist->st->time_base)
11a1033c
MN
2920 && av_q2d(ist->st->time_base) < 1.0/500
2921 || copy_tb==0){
1efc0892
MN
2922 enc_ctx->time_base = dec_ctx->time_base;
2923 enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
2924 enc_ctx->time_base.den *= 2;
2925 enc_ctx->ticks_per_frame = 2;
11a1033c
MN
2926 }
2927 } else if(!(oc->oformat->flags & AVFMT_VARIABLE_FPS)
2928 && strcmp(oc->oformat->name, "mov") && strcmp(oc->oformat->name, "mp4") && strcmp(oc->oformat->name, "3gp")
2929 && strcmp(oc->oformat->name, "3g2") && strcmp(oc->oformat->name, "psp") && strcmp(oc->oformat->name, "ipod")
405ee405 2930 && strcmp(oc->oformat->name, "f4v")
11a1033c 2931 ) {
1f40536c
MN
2932 if( copy_tb<0 && dec_ctx->time_base.den
2933 && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > av_q2d(ist->st->time_base)
11a1033c
MN
2934 && av_q2d(ist->st->time_base) < 1.0/500
2935 || copy_tb==0){
1efc0892
MN
2936 enc_ctx->time_base = dec_ctx->time_base;
2937 enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
11a1033c
MN
2938 }
2939 }
1efc0892 2940 if ( enc_ctx->codec_tag == AV_RL32("tmcd")
1f40536c
MN
2941 && dec_ctx->time_base.num < dec_ctx->time_base.den
2942 && dec_ctx->time_base.num > 0
2943 && 121LL*dec_ctx->time_base.num > dec_ctx->time_base.den) {
1efc0892 2944 enc_ctx->time_base = dec_ctx->time_base;
bee044d7 2945 }
81e46555 2946
cf410f8f 2947 if (!ost->frame_rate.num)
356363c8 2948 ost->frame_rate = ist->framerate;
11a1033c 2949 if(ost->frame_rate.num)
1efc0892 2950 enc_ctx->time_base = av_inv_q(ost->frame_rate);
11a1033c 2951
1efc0892
MN
2952 av_reduce(&enc_ctx->time_base.num, &enc_ctx->time_base.den,
2953 enc_ctx->time_base.num, enc_ctx->time_base.den, INT_MAX);
03f30c83 2954
6ef5e292
MN
2955 if (ist->st->nb_side_data) {
2956 ost->st->side_data = av_realloc_array(NULL, ist->st->nb_side_data,
2957 sizeof(*ist->st->side_data));
2958 if (!ost->st->side_data)
2959 return AVERROR(ENOMEM);
2960
57e38043 2961 ost->st->nb_side_data = 0;
6ef5e292
MN
2962 for (j = 0; j < ist->st->nb_side_data; j++) {
2963 const AVPacketSideData *sd_src = &ist->st->side_data[j];
57e38043
MN
2964 AVPacketSideData *sd_dst = &ost->st->side_data[ost->st->nb_side_data];
2965
2966 if (ost->rotate_overridden && sd_src->type == AV_PKT_DATA_DISPLAYMATRIX)
2967 continue;
6ef5e292
MN
2968
2969 sd_dst->data = av_malloc(sd_src->size);
2970 if (!sd_dst->data)
2971 return AVERROR(ENOMEM);
2972 memcpy(sd_dst->data, sd_src->data, sd_src->size);
2973 sd_dst->size = sd_src->size;
2974 sd_dst->type = sd_src->type;
2975 ost->st->nb_side_data++;
2976 }
2977 }
2978
65ed9e75 2979 ost->parser = av_parser_init(enc_ctx->codec_id);
0460b9bb 2980
65ed9e75 2981 switch (enc_ctx->codec_type) {
6291d7e4 2982 case AVMEDIA_TYPE_AUDIO:
7636c8c6 2983 if (audio_volume != 256) {
e3245b26 2984 av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
636ced8e 2985 exit_program(1);
6291d7e4 2986 }
65ed9e75
AK
2987 enc_ctx->channel_layout = dec_ctx->channel_layout;
2988 enc_ctx->sample_rate = dec_ctx->sample_rate;
2989 enc_ctx->channels = dec_ctx->channels;
2990 enc_ctx->frame_size = dec_ctx->frame_size;
2991 enc_ctx->audio_service_type = dec_ctx->audio_service_type;
2992 enc_ctx->block_align = dec_ctx->block_align;
83f84e4c 2993 enc_ctx->initial_padding = dec_ctx->delay;
d21b690e 2994 enc_ctx->profile = dec_ctx->profile;
83f84e4c 2995#if FF_API_AUDIOENC_DELAY
1efc0892 2996 enc_ctx->delay = dec_ctx->delay;
83f84e4c 2997#endif
1efc0892
MN
2998 if((enc_ctx->block_align == 1 || enc_ctx->block_align == 1152 || enc_ctx->block_align == 576) && enc_ctx->codec_id == AV_CODEC_ID_MP3)
2999 enc_ctx->block_align= 0;
3000 if(enc_ctx->codec_id == AV_CODEC_ID_AC3)
3001 enc_ctx->block_align= 0;
6291d7e4
AK
3002 break;
3003 case AVMEDIA_TYPE_VIDEO:
65ed9e75
AK
3004 enc_ctx->pix_fmt = dec_ctx->pix_fmt;
3005 enc_ctx->width = dec_ctx->width;
3006 enc_ctx->height = dec_ctx->height;
3007 enc_ctx->has_b_frames = dec_ctx->has_b_frames;
b1cc12d0 3008 if (ost->frame_aspect_ratio.num) { // overridden by the -aspect cli option
2ad28840 3009 sar =
b1cc12d0 3010 av_mul_q(ost->frame_aspect_ratio,
1efc0892 3011 (AVRational){ enc_ctx->height, enc_ctx->width });
b1cc12d0
NG
3012 av_log(NULL, AV_LOG_WARNING, "Overriding aspect ratio "
3013 "with stream copy may produce invalid files\n");
6291d7e4 3014 }
538bf767
AK
3015 else if (ist->st->sample_aspect_ratio.num)
3016 sar = ist->st->sample_aspect_ratio;
3017 else
650a5206 3018 sar = dec_ctx->sample_aspect_ratio;
65ed9e75 3019 ost->st->sample_aspect_ratio = enc_ctx->sample_aspect_ratio = sar;
11a1033c 3020 ost->st->avg_frame_rate = ist->st->avg_frame_rate;
28a6f970 3021 ost->st->r_frame_rate = ist->st->r_frame_rate;
6291d7e4
AK
3022 break;
3023 case AVMEDIA_TYPE_SUBTITLE:
65ed9e75
AK
3024 enc_ctx->width = dec_ctx->width;
3025 enc_ctx->height = dec_ctx->height;
6291d7e4 3026 break;
18833daf 3027 case AVMEDIA_TYPE_UNKNOWN:
6291d7e4 3028 case AVMEDIA_TYPE_DATA:
3ccd1580 3029 case AVMEDIA_TYPE_ATTACHMENT:
6291d7e4
AK
3030 break;
3031 default:
3032 abort();
3033 }
3034 } else {
11a1033c 3035 if (!ost->enc)
1efc0892 3036 ost->enc = avcodec_find_encoder(enc_ctx->codec_id);
2994913d
AK
3037 if (!ost->enc) {
3038 /* should only happen when a default codec is not present. */
11a1033c
MN
3039 snprintf(error, sizeof(error), "Encoder (codec %s) not found for output stream #%d:%d",
3040 avcodec_get_name(ost->st->codec->codec_id), ost->file_index, ost->index);
2994913d
AK
3041 ret = AVERROR(EINVAL);
3042 goto dump_format;
81e46555 3043 }
81e46555 3044
6656370b
AK
3045 set_encoder_id(output_files[ost->file_index], ost);
3046
dd8a4b0f
HL
3047#if CONFIG_LIBMFX
3048 if (qsv_transcode_init(ost))
3049 exit_program(1);
3050#endif
3051
369cb092 3052 if (!ost->filter &&
65ed9e75
AK
3053 (enc_ctx->codec_type == AVMEDIA_TYPE_VIDEO ||
3054 enc_ctx->codec_type == AVMEDIA_TYPE_AUDIO)) {
3b266da3
AK
3055 FilterGraph *fg;
3056 fg = init_simple_filtergraph(ist, ost);
8daf21d5 3057 if (configure_filtergraph(fg)) {
3b266da3 3058 av_log(NULL, AV_LOG_FATAL, "Error opening filters!\n");
636ced8e 3059 exit_program(1);
3b266da3 3060 }
c9cc7629
AK
3061 }
3062
1efc0892 3063 if (enc_ctx->codec_type == AVMEDIA_TYPE_VIDEO) {
3a91a07f 3064 if (!ost->frame_rate.num)
11a1033c
MN
3065 ost->frame_rate = av_buffersink_get_frame_rate(ost->filter->filter);
3066 if (ist && !ost->frame_rate.num)
17106a7c
MN
3067 ost->frame_rate = ist->framerate;
3068 if (ist && !ost->frame_rate.num)
206c06d9
MN
3069 ost->frame_rate = ist->st->r_frame_rate;
3070 if (ist && !ost->frame_rate.num) {
3071 ost->frame_rate = (AVRational){25, 1};
3072 av_log(NULL, AV_LOG_WARNING,
3073 "No information "
3074 "about the input framerate is available. Falling "
3075 "back to a default value of 25fps for output stream #%d:%d. Use the -r option "
3076 "if you want a different framerate.\n",
3077 ost->file_index, ost->index);
3078 }
11a1033c
MN
3079// ost->frame_rate = ist->st->avg_frame_rate.num ? ist->st->avg_frame_rate : (AVRational){25, 1};
3080 if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
3081 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
3082 ost->frame_rate = ost->enc->supported_framerates[idx];
3083 }
c285937c 3084 // reduce frame rate for mpeg4 to be within the spec limits
1efc0892 3085 if (enc_ctx->codec_id == AV_CODEC_ID_MPEG4) {
3734c3ea
MN
3086 av_reduce(&ost->frame_rate.num, &ost->frame_rate.den,
3087 ost->frame_rate.num, ost->frame_rate.den, 65535);
3088 }
11a1033c 3089 }
60de7616 3090
65ed9e75 3091 switch (enc_ctx->codec_type) {
369cb092 3092 case AVMEDIA_TYPE_AUDIO:
65ed9e75
AK
3093 enc_ctx->sample_fmt = ost->filter->filter->inputs[0]->format;
3094 enc_ctx->sample_rate = ost->filter->filter->inputs[0]->sample_rate;
3095 enc_ctx->channel_layout = ost->filter->filter->inputs[0]->channel_layout;
1efc0892 3096 enc_ctx->channels = avfilter_link_get_channels(ost->filter->filter->inputs[0]);
65ed9e75 3097 enc_ctx->time_base = (AVRational){ 1, enc_ctx->sample_rate };
369cb092
AK
3098 break;
3099 case AVMEDIA_TYPE_VIDEO:
1efc0892 3100 enc_ctx->time_base = av_inv_q(ost->frame_rate);
da2f1568 3101 if (!(enc_ctx->time_base.num && enc_ctx->time_base.den))
1efc0892
MN
3102 enc_ctx->time_base = ost->filter->filter->inputs[0]->time_base;
3103 if ( av_q2d(enc_ctx->time_base) < 0.001 && video_sync_method != VSYNC_PASSTHROUGH
d7ebeba8 3104 && (video_sync_method == VSYNC_CFR || video_sync_method == VSYNC_VSCFR || (video_sync_method == VSYNC_AUTO && !(oc->oformat->flags & AVFMT_VARIABLE_FPS)))){
11a1033c
MN
3105 av_log(oc, AV_LOG_WARNING, "Frame rate very high for a muxer not efficiently supporting it.\n"
3106 "Please consider specifying a lower framerate, a different muxer or -vsync 2\n");
3107 }
3108 for (j = 0; j < ost->forced_kf_count; j++)
3109 ost->forced_kf_pts[j] = av_rescale_q(ost->forced_kf_pts[j],
3110 AV_TIME_BASE_Q,
1efc0892 3111 enc_ctx->time_base);
6291d7e4 3112
65ed9e75
AK
3113 enc_ctx->width = ost->filter->filter->inputs[0]->w;
3114 enc_ctx->height = ost->filter->filter->inputs[0]->h;
3115 enc_ctx->sample_aspect_ratio = ost->st->sample_aspect_ratio =
de38e7c8 3116 ost->frame_aspect_ratio.num ? // overridden by the -aspect cli option
1efc0892 3117 av_mul_q(ost->frame_aspect_ratio, (AVRational){ enc_ctx->height, enc_ctx->width }) :
3b266da3 3118 ost->filter->filter->inputs[0]->sample_aspect_ratio;
e4f5aa5e 3119 if (!strncmp(ost->enc->name, "libx264", 7) &&
1efc0892 3120 enc_ctx->pix_fmt == AV_PIX_FMT_NONE &&
e4f5aa5e 3121 ost->filter->filter->inputs[0]->format != AV_PIX_FMT_YUV420P)
f118b417 3122 av_log(NULL, AV_LOG_WARNING,
e4f5aa5e
CEH
3123 "No pixel format specified, %s for H.264 encoding chosen.\n"
3124 "Use -pix_fmt yuv420p for compatibility with outdated media players.\n",
3125 av_get_pix_fmt_name(ost->filter->filter->inputs[0]->format));
47f9a5b7 3126 if (!strncmp(ost->enc->name, "mpeg2video", 10) &&
1efc0892 3127 enc_ctx->pix_fmt == AV_PIX_FMT_NONE &&
47f9a5b7
CEH
3128 ost->filter->filter->inputs[0]->format != AV_PIX_FMT_YUV420P)
3129 av_log(NULL, AV_LOG_WARNING,
3130 "No pixel format specified, %s for MPEG-2 encoding chosen.\n"
3131 "Use -pix_fmt yuv420p for compatibility with outdated media players.\n",
3132 av_get_pix_fmt_name(ost->filter->filter->inputs[0]->format));
65ed9e75 3133 enc_ctx->pix_fmt = ost->filter->filter->inputs[0]->format;
b7327887 3134
93afb6c9
AK
3135 ost->st->avg_frame_rate = ost->frame_rate;
3136
1f40536c 3137 if (!dec_ctx ||
1efc0892
MN
3138 enc_ctx->width != dec_ctx->width ||
3139 enc_ctx->height != dec_ctx->height ||
3140 enc_ctx->pix_fmt != dec_ctx->pix_fmt) {
3141 enc_ctx->bits_per_raw_sample = frame_bits_per_raw_sample;
b7327887 3142 }
fc49f22c 3143
43af18ef
SS
3144 if (ost->forced_keyframes) {
3145 if (!strncmp(ost->forced_keyframes, "expr:", 5)) {
3146 ret = av_expr_parse(&ost->forced_keyframes_pexpr, ost->forced_keyframes+5,
3147 forced_keyframes_const_names, NULL, NULL, NULL, NULL, 0, NULL);
3148 if (ret < 0) {
3149 av_log(NULL, AV_LOG_ERROR,
3150 "Invalid force_key_frames expression '%s'\n", ost->forced_keyframes+5);
3151 return ret;
3152 }
3153 ost->forced_keyframes_expr_const_values[FKF_N] = 0;
3154 ost->forced_keyframes_expr_const_values[FKF_N_FORCED] = 0;
3155 ost->forced_keyframes_expr_const_values[FKF_PREV_FORCED_N] = NAN;
3156 ost->forced_keyframes_expr_const_values[FKF_PREV_FORCED_T] = NAN;
77cc0d5b 3157
3158 // Don't parse the 'forced_keyframes' in case of 'keep-source-keyframes',
3159 // parse it only for static kf timings
3160 } else if(strncmp(ost->forced_keyframes, "source", 6)) {
862120f9 3161 parse_forced_key_frames(ost->forced_keyframes, ost, ost->enc_ctx);
43af18ef
SS
3162 }
3163 }
6291d7e4
AK
3164 break;
3165 case AVMEDIA_TYPE_SUBTITLE:
65ed9e75 3166 enc_ctx->time_base = (AVRational){1, 1000};
1efc0892
MN
3167 if (!enc_ctx->width) {
3168 enc_ctx->width = input_streams[ost->source_index]->st->codec->width;
3169 enc_ctx->height = input_streams[ost->source_index]->st->codec->height;
690ef618 3170 }
6291d7e4 3171 break;
bb0344dc
AM
3172 case AVMEDIA_TYPE_DATA:
3173 break;
6291d7e4
AK
3174 default:
3175 abort();
3176 break;
3177 }
81e46555 3178 }
85d7e02e
MN
3179