fftools/ffmpeg: fix progress log message in case pts is not available
[ffmpeg.git] / fftools / ffmpeg.c
1 /*
2  * Copyright (c) 2000-2003 Fabrice Bellard
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20
21 /**
22  * @file
23  * multimedia converter based on the FFmpeg libraries
24  */
25
26 #include "config.h"
27 #include <ctype.h>
28 #include <string.h>
29 #include <math.h>
30 #include <stdlib.h>
31 #include <errno.h>
32 #include <limits.h>
33 #include <stdatomic.h>
34 #include <stdint.h>
35
36 #if HAVE_IO_H
37 #include <io.h>
38 #endif
39 #if HAVE_UNISTD_H
40 #include <unistd.h>
41 #endif
42
43 #include "libavformat/avformat.h"
44 #include "libavdevice/avdevice.h"
45 #include "libswresample/swresample.h"
46 #include "libavutil/opt.h"
47 #include "libavutil/channel_layout.h"
48 #include "libavutil/parseutils.h"
49 #include "libavutil/samplefmt.h"
50 #include "libavutil/fifo.h"
51 #include "libavutil/hwcontext.h"
52 #include "libavutil/internal.h"
53 #include "libavutil/intreadwrite.h"
54 #include "libavutil/dict.h"
55 #include "libavutil/display.h"
56 #include "libavutil/mathematics.h"
57 #include "libavutil/pixdesc.h"
58 #include "libavutil/avstring.h"
59 #include "libavutil/libm.h"
60 #include "libavutil/imgutils.h"
61 #include "libavutil/timestamp.h"
62 #include "libavutil/bprint.h"
63 #include "libavutil/time.h"
64 #include "libavutil/thread.h"
65 #include "libavutil/threadmessage.h"
66 #include "libavcodec/mathops.h"
67 #include "libavformat/os_support.h"
68
69 # include "libavfilter/avfilter.h"
70 # include "libavfilter/buffersrc.h"
71 # include "libavfilter/buffersink.h"
72
73 #if HAVE_SYS_RESOURCE_H
74 #include <sys/time.h>
75 #include <sys/types.h>
76 #include <sys/resource.h>
77 #elif HAVE_GETPROCESSTIMES
78 #include <windows.h>
79 #endif
80 #if HAVE_GETPROCESSMEMORYINFO
81 #include <windows.h>
82 #include <psapi.h>
83 #endif
84 #if HAVE_SETCONSOLECTRLHANDLER
85 #include <windows.h>
86 #endif
87
88
89 #if HAVE_SYS_SELECT_H
90 #include <sys/select.h>
91 #endif
92
93 #if HAVE_TERMIOS_H
94 #include <fcntl.h>
95 #include <sys/ioctl.h>
96 #include <sys/time.h>
97 #include <termios.h>
98 #elif HAVE_KBHIT
99 #include <conio.h>
100 #endif
101
102 #include <time.h>
103
104 #include "ffmpeg.h"
105 #include "cmdutils.h"
106
107 #include "libavutil/avassert.h"
108
109 const char program_name[] = "ffmpeg";
110 const int program_birth_year = 2000;
111
112 static FILE *vstats_file;
113
114 const 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
123 static void do_video_stats(OutputStream *ost, int frame_size);
124 static int64_t getutime(void);
125 static int64_t getmaxrss(void);
126 static int ifilter_has_all_input_formats(FilterGraph *fg);
127
128 static int run_as_daemon  = 0;
129 static int nb_frames_dup = 0;
130 static unsigned dup_warning = 1000;
131 static int nb_frames_drop = 0;
132 static int64_t decode_error_stat[2];
133
134 static int want_sdp = 1;
135
136 static int current_time;
137 AVIOContext *progress_avio = NULL;
138
139 static uint8_t *subtitle_out;
140
141 InputStream **input_streams = NULL;
142 int        nb_input_streams = 0;
143 InputFile   **input_files   = NULL;
144 int        nb_input_files   = 0;
145
146 OutputStream **output_streams = NULL;
147 int         nb_output_streams = 0;
148 OutputFile   **output_files   = NULL;
149 int         nb_output_files   = 0;
150
151 FilterGraph **filtergraphs;
152 int        nb_filtergraphs;
153
154 #if HAVE_TERMIOS_H
155
156 /* init terminal so that we can grab keys */
157 static struct termios oldtty;
158 static int restore_tty;
159 #endif
160
161 #if HAVE_THREADS
162 static void free_input_threads(void);
163 #endif
164
165 /* sub2video hack:
166    Convert subtitles to video with alpha to insert them in filter graphs.
167    This is a temporary solution until libavfilter gets real subtitles support.
168  */
169
170 static int sub2video_get_blank_frame(InputStream *ist)
171 {
172     int ret;
173     AVFrame *frame = ist->sub2video.frame;
174
175     av_frame_unref(frame);
176     ist->sub2video.frame->width  = ist->dec_ctx->width  ? ist->dec_ctx->width  : ist->sub2video.w;
177     ist->sub2video.frame->height = ist->dec_ctx->height ? ist->dec_ctx->height : ist->sub2video.h;
178     ist->sub2video.frame->format = AV_PIX_FMT_RGB32;
179     if ((ret = av_frame_get_buffer(frame, 32)) < 0)
180         return ret;
181     memset(frame->data[0], 0, frame->height * frame->linesize[0]);
182     return 0;
183 }
184
185 static void sub2video_copy_rect(uint8_t *dst, int dst_linesize, int w, int h,
186                                 AVSubtitleRect *r)
187 {
188     uint32_t *pal, *dst2;
189     uint8_t *src, *src2;
190     int x, y;
191
192     if (r->type != SUBTITLE_BITMAP) {
193         av_log(NULL, AV_LOG_WARNING, "sub2video: non-bitmap subtitle\n");
194         return;
195     }
196     if (r->x < 0 || r->x + r->w > w || r->y < 0 || r->y + r->h > h) {
197         av_log(NULL, AV_LOG_WARNING, "sub2video: rectangle (%d %d %d %d) overflowing %d %d\n",
198             r->x, r->y, r->w, r->h, w, h
199         );
200         return;
201     }
202
203     dst += r->y * dst_linesize + r->x * 4;
204     src = r->data[0];
205     pal = (uint32_t *)r->data[1];
206     for (y = 0; y < r->h; y++) {
207         dst2 = (uint32_t *)dst;
208         src2 = src;
209         for (x = 0; x < r->w; x++)
210             *(dst2++) = pal[*(src2++)];
211         dst += dst_linesize;
212         src += r->linesize[0];
213     }
214 }
215
216 static void sub2video_push_ref(InputStream *ist, int64_t pts)
217 {
218     AVFrame *frame = ist->sub2video.frame;
219     int i;
220     int ret;
221
222     av_assert1(frame->data[0]);
223     ist->sub2video.last_pts = frame->pts = pts;
224     for (i = 0; i < ist->nb_filters; i++) {
225         ret = av_buffersrc_add_frame_flags(ist->filters[i]->filter, frame,
226                                            AV_BUFFERSRC_FLAG_KEEP_REF |
227                                            AV_BUFFERSRC_FLAG_PUSH);
228         if (ret != AVERROR_EOF && ret < 0)
229             av_log(NULL, AV_LOG_WARNING, "Error while add the frame to buffer source(%s).\n",
230                    av_err2str(ret));
231     }
232 }
233
234 void sub2video_update(InputStream *ist, AVSubtitle *sub)
235 {
236     AVFrame *frame = ist->sub2video.frame;
237     int8_t *dst;
238     int     dst_linesize;
239     int num_rects, i;
240     int64_t pts, end_pts;
241
242     if (!frame)
243         return;
244     if (sub) {
245         pts       = av_rescale_q(sub->pts + sub->start_display_time * 1000LL,
246                                  AV_TIME_BASE_Q, ist->st->time_base);
247         end_pts   = av_rescale_q(sub->pts + sub->end_display_time   * 1000LL,
248                                  AV_TIME_BASE_Q, ist->st->time_base);
249         num_rects = sub->num_rects;
250     } else {
251         pts       = ist->sub2video.end_pts;
252         end_pts   = INT64_MAX;
253         num_rects = 0;
254     }
255     if (sub2video_get_blank_frame(ist) < 0) {
256         av_log(ist->dec_ctx, AV_LOG_ERROR,
257                "Impossible to get a blank canvas.\n");
258         return;
259     }
260     dst          = frame->data    [0];
261     dst_linesize = frame->linesize[0];
262     for (i = 0; i < num_rects; i++)
263         sub2video_copy_rect(dst, dst_linesize, frame->width, frame->height, sub->rects[i]);
264     sub2video_push_ref(ist, pts);
265     ist->sub2video.end_pts = end_pts;
266 }
267
268 static void sub2video_heartbeat(InputStream *ist, int64_t pts)
269 {
270     InputFile *infile = input_files[ist->file_index];
271     int i, j, nb_reqs;
272     int64_t pts2;
273
274     /* When a frame is read from a file, examine all sub2video streams in
275        the same file and send the sub2video frame again. Otherwise, decoded
276        video frames could be accumulating in the filter graph while a filter
277        (possibly overlay) is desperately waiting for a subtitle frame. */
278     for (i = 0; i < infile->nb_streams; i++) {
279         InputStream *ist2 = input_streams[infile->ist_index + i];
280         if (!ist2->sub2video.frame)
281             continue;
282         /* subtitles seem to be usually muxed ahead of other streams;
283            if not, subtracting a larger time here is necessary */
284         pts2 = av_rescale_q(pts, ist->st->time_base, ist2->st->time_base) - 1;
285         /* do not send the heartbeat frame if the subtitle is already ahead */
286         if (pts2 <= ist2->sub2video.last_pts)
287             continue;
288         if (pts2 >= ist2->sub2video.end_pts || !ist2->sub2video.frame->data[0])
289             sub2video_update(ist2, NULL);
290         for (j = 0, nb_reqs = 0; j < ist2->nb_filters; j++)
291             nb_reqs += av_buffersrc_get_nb_failed_requests(ist2->filters[j]->filter);
292         if (nb_reqs)
293             sub2video_push_ref(ist2, pts2);
294     }
295 }
296
297 static void sub2video_flush(InputStream *ist)
298 {
299     int i;
300     int ret;
301
302     if (ist->sub2video.end_pts < INT64_MAX)
303         sub2video_update(ist, NULL);
304     for (i = 0; i < ist->nb_filters; i++) {
305         ret = av_buffersrc_add_frame(ist->filters[i]->filter, NULL);
306         if (ret != AVERROR_EOF && ret < 0)
307             av_log(NULL, AV_LOG_WARNING, "Flush the frame error.\n");
308     }
309 }
310
311 /* end of sub2video hack */
312
313 static void term_exit_sigsafe(void)
314 {
315 #if HAVE_TERMIOS_H
316     if(restore_tty)
317         tcsetattr (0, TCSANOW, &oldtty);
318 #endif
319 }
320
321 void term_exit(void)
322 {
323     av_log(NULL, AV_LOG_QUIET, "%s", "");
324     term_exit_sigsafe();
325 }
326
327 static volatile int received_sigterm = 0;
328 static volatile int received_nb_signals = 0;
329 static atomic_int transcode_init_done = ATOMIC_VAR_INIT(0);
330 static volatile int ffmpeg_exited = 0;
331 static int main_return_code = 0;
332
333 static void
334 sigterm_handler(int sig)
335 {
336     int ret;
337     received_sigterm = sig;
338     received_nb_signals++;
339     term_exit_sigsafe();
340     if(received_nb_signals > 3) {
341         ret = write(2/*STDERR_FILENO*/, "Received > 3 system signals, hard exiting\n",
342                     strlen("Received > 3 system signals, hard exiting\n"));
343         if (ret < 0) { /* Do nothing */ };
344         exit(123);
345     }
346 }
347
348 #if HAVE_SETCONSOLECTRLHANDLER
349 static BOOL WINAPI CtrlHandler(DWORD fdwCtrlType)
350 {
351     av_log(NULL, AV_LOG_DEBUG, "\nReceived windows signal %ld\n", fdwCtrlType);
352
353     switch (fdwCtrlType)
354     {
355     case CTRL_C_EVENT:
356     case CTRL_BREAK_EVENT:
357         sigterm_handler(SIGINT);
358         return TRUE;
359
360     case CTRL_CLOSE_EVENT:
361     case CTRL_LOGOFF_EVENT:
362     case CTRL_SHUTDOWN_EVENT:
363         sigterm_handler(SIGTERM);
364         /* Basically, with these 3 events, when we return from this method the
365            process is hard terminated, so stall as long as we need to
366            to try and let the main thread(s) clean up and gracefully terminate
367            (we have at most 5 seconds, but should be done far before that). */
368         while (!ffmpeg_exited) {
369             Sleep(0);
370         }
371         return TRUE;
372
373     default:
374         av_log(NULL, AV_LOG_ERROR, "Received unknown windows signal %ld\n", fdwCtrlType);
375         return FALSE;
376     }
377 }
378 #endif
379
380 void term_init(void)
381 {
382 #if HAVE_TERMIOS_H
383     if (!run_as_daemon && stdin_interaction) {
384         struct termios tty;
385         if (tcgetattr (0, &tty) == 0) {
386             oldtty = tty;
387             restore_tty = 1;
388
389             tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
390                              |INLCR|IGNCR|ICRNL|IXON);
391             tty.c_oflag |= OPOST;
392             tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
393             tty.c_cflag &= ~(CSIZE|PARENB);
394             tty.c_cflag |= CS8;
395             tty.c_cc[VMIN] = 1;
396             tty.c_cc[VTIME] = 0;
397
398             tcsetattr (0, TCSANOW, &tty);
399         }
400         signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
401     }
402 #endif
403
404     signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).    */
405     signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
406 #ifdef SIGXCPU
407     signal(SIGXCPU, sigterm_handler);
408 #endif
409 #ifdef SIGPIPE
410     signal(SIGPIPE, SIG_IGN); /* Broken pipe (POSIX). */
411 #endif
412 #if HAVE_SETCONSOLECTRLHANDLER
413     SetConsoleCtrlHandler((PHANDLER_ROUTINE) CtrlHandler, TRUE);
414 #endif
415 }
416
417 /* read a key without blocking */
418 static int read_key(void)
419 {
420     unsigned char ch;
421 #if HAVE_TERMIOS_H
422     int n = 1;
423     struct timeval tv;
424     fd_set rfds;
425
426     FD_ZERO(&rfds);
427     FD_SET(0, &rfds);
428     tv.tv_sec = 0;
429     tv.tv_usec = 0;
430     n = select(1, &rfds, NULL, NULL, &tv);
431     if (n > 0) {
432         n = read(0, &ch, 1);
433         if (n == 1)
434             return ch;
435
436         return n;
437     }
438 #elif HAVE_KBHIT
439 #    if HAVE_PEEKNAMEDPIPE
440     static int is_pipe;
441     static HANDLE input_handle;
442     DWORD dw, nchars;
443     if(!input_handle){
444         input_handle = GetStdHandle(STD_INPUT_HANDLE);
445         is_pipe = !GetConsoleMode(input_handle, &dw);
446     }
447
448     if (is_pipe) {
449         /* When running under a GUI, you will end here. */
450         if (!PeekNamedPipe(input_handle, NULL, 0, NULL, &nchars, NULL)) {
451             // input pipe may have been closed by the program that ran ffmpeg
452             return -1;
453         }
454         //Read it
455         if(nchars != 0) {
456             read(0, &ch, 1);
457             return ch;
458         }else{
459             return -1;
460         }
461     }
462 #    endif
463     if(kbhit())
464         return(getch());
465 #endif
466     return -1;
467 }
468
469 static int decode_interrupt_cb(void *ctx)
470 {
471     return received_nb_signals > atomic_load(&transcode_init_done);
472 }
473
474 const AVIOInterruptCB int_cb = { decode_interrupt_cb, NULL };
475
476 static void ffmpeg_cleanup(int ret)
477 {
478     int i, j;
479
480     if (do_benchmark) {
481         int maxrss = getmaxrss() / 1024;
482         av_log(NULL, AV_LOG_INFO, "bench: maxrss=%ikB\n", maxrss);
483     }
484
485     for (i = 0; i < nb_filtergraphs; i++) {
486         FilterGraph *fg = filtergraphs[i];
487         avfilter_graph_free(&fg->graph);
488         for (j = 0; j < fg->nb_inputs; j++) {
489             while (av_fifo_size(fg->inputs[j]->frame_queue)) {
490                 AVFrame *frame;
491                 av_fifo_generic_read(fg->inputs[j]->frame_queue, &frame,
492                                      sizeof(frame), NULL);
493                 av_frame_free(&frame);
494             }
495             av_fifo_freep(&fg->inputs[j]->frame_queue);
496             if (fg->inputs[j]->ist->sub2video.sub_queue) {
497                 while (av_fifo_size(fg->inputs[j]->ist->sub2video.sub_queue)) {
498                     AVSubtitle sub;
499                     av_fifo_generic_read(fg->inputs[j]->ist->sub2video.sub_queue,
500                                          &sub, sizeof(sub), NULL);
501                     avsubtitle_free(&sub);
502                 }
503                 av_fifo_freep(&fg->inputs[j]->ist->sub2video.sub_queue);
504             }
505             av_buffer_unref(&fg->inputs[j]->hw_frames_ctx);
506             av_freep(&fg->inputs[j]->name);
507             av_freep(&fg->inputs[j]);
508         }
509         av_freep(&fg->inputs);
510         for (j = 0; j < fg->nb_outputs; j++) {
511             av_freep(&fg->outputs[j]->name);
512             av_freep(&fg->outputs[j]->formats);
513             av_freep(&fg->outputs[j]->channel_layouts);
514             av_freep(&fg->outputs[j]->sample_rates);
515             av_freep(&fg->outputs[j]);
516         }
517         av_freep(&fg->outputs);
518         av_freep(&fg->graph_desc);
519
520         av_freep(&filtergraphs[i]);
521     }
522     av_freep(&filtergraphs);
523
524     av_freep(&subtitle_out);
525
526     /* close files */
527     for (i = 0; i < nb_output_files; i++) {
528         OutputFile *of = output_files[i];
529         AVFormatContext *s;
530         if (!of)
531             continue;
532         s = of->ctx;
533         if (s && s->oformat && !(s->oformat->flags & AVFMT_NOFILE))
534             avio_closep(&s->pb);
535         avformat_free_context(s);
536         av_dict_free(&of->opts);
537
538         av_freep(&output_files[i]);
539     }
540     for (i = 0; i < nb_output_streams; i++) {
541         OutputStream *ost = output_streams[i];
542
543         if (!ost)
544             continue;
545
546         for (j = 0; j < ost->nb_bitstream_filters; j++)
547             av_bsf_free(&ost->bsf_ctx[j]);
548         av_freep(&ost->bsf_ctx);
549
550         av_frame_free(&ost->filtered_frame);
551         av_frame_free(&ost->last_frame);
552         av_dict_free(&ost->encoder_opts);
553
554         av_parser_close(ost->parser);
555         avcodec_free_context(&ost->parser_avctx);
556
557         av_freep(&ost->forced_keyframes);
558         av_expr_free(ost->forced_keyframes_pexpr);
559         av_freep(&ost->avfilter);
560         av_freep(&ost->logfile_prefix);
561
562         av_freep(&ost->audio_channels_map);
563         ost->audio_channels_mapped = 0;
564
565         av_dict_free(&ost->sws_dict);
566
567         avcodec_free_context(&ost->enc_ctx);
568         avcodec_parameters_free(&ost->ref_par);
569
570         if (ost->muxing_queue) {
571             while (av_fifo_size(ost->muxing_queue)) {
572                 AVPacket pkt;
573                 av_fifo_generic_read(ost->muxing_queue, &pkt, sizeof(pkt), NULL);
574                 av_packet_unref(&pkt);
575             }
576             av_fifo_freep(&ost->muxing_queue);
577         }
578
579         av_freep(&output_streams[i]);
580     }
581 #if HAVE_THREADS
582     free_input_threads();
583 #endif
584     for (i = 0; i < nb_input_files; i++) {
585         avformat_close_input(&input_files[i]->ctx);
586         av_freep(&input_files[i]);
587     }
588     for (i = 0; i < nb_input_streams; i++) {
589         InputStream *ist = input_streams[i];
590
591         av_frame_free(&ist->decoded_frame);
592         av_frame_free(&ist->filter_frame);
593         av_dict_free(&ist->decoder_opts);
594         avsubtitle_free(&ist->prev_sub.subtitle);
595         av_frame_free(&ist->sub2video.frame);
596         av_freep(&ist->filters);
597         av_freep(&ist->hwaccel_device);
598         av_freep(&ist->dts_buffer);
599
600         avcodec_free_context(&ist->dec_ctx);
601
602         av_freep(&input_streams[i]);
603     }
604
605     if (vstats_file) {
606         if (fclose(vstats_file))
607             av_log(NULL, AV_LOG_ERROR,
608                    "Error closing vstats file, loss of information possible: %s\n",
609                    av_err2str(AVERROR(errno)));
610     }
611     av_freep(&vstats_filename);
612
613     av_freep(&input_streams);
614     av_freep(&input_files);
615     av_freep(&output_streams);
616     av_freep(&output_files);
617
618     uninit_opts();
619
620     avformat_network_deinit();
621
622     if (received_sigterm) {
623         av_log(NULL, AV_LOG_INFO, "Exiting normally, received signal %d.\n",
624                (int) received_sigterm);
625     } else if (ret && atomic_load(&transcode_init_done)) {
626         av_log(NULL, AV_LOG_INFO, "Conversion failed!\n");
627     }
628     term_exit();
629     ffmpeg_exited = 1;
630 }
631
632 void remove_avoptions(AVDictionary **a, AVDictionary *b)
633 {
634     AVDictionaryEntry *t = NULL;
635
636     while ((t = av_dict_get(b, "", t, AV_DICT_IGNORE_SUFFIX))) {
637         av_dict_set(a, t->key, NULL, AV_DICT_MATCH_CASE);
638     }
639 }
640
641 void assert_avoptions(AVDictionary *m)
642 {
643     AVDictionaryEntry *t;
644     if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
645         av_log(NULL, AV_LOG_FATAL, "Option %s not found.\n", t->key);
646         exit_program(1);
647     }
648 }
649
650 static void abort_codec_experimental(AVCodec *c, int encoder)
651 {
652     exit_program(1);
653 }
654
655 static void update_benchmark(const char *fmt, ...)
656 {
657     if (do_benchmark_all) {
658         int64_t t = getutime();
659         va_list va;
660         char buf[1024];
661
662         if (fmt) {
663             va_start(va, fmt);
664             vsnprintf(buf, sizeof(buf), fmt, va);
665             va_end(va);
666             av_log(NULL, AV_LOG_INFO, "bench: %8"PRIu64" %s \n", t - current_time, buf);
667         }
668         current_time = t;
669     }
670 }
671
672 static void close_all_output_streams(OutputStream *ost, OSTFinished this_stream, OSTFinished others)
673 {
674     int i;
675     for (i = 0; i < nb_output_streams; i++) {
676         OutputStream *ost2 = output_streams[i];
677         ost2->finished |= ost == ost2 ? this_stream : others;
678     }
679 }
680
681 static void write_packet(OutputFile *of, AVPacket *pkt, OutputStream *ost, int unqueue)
682 {
683     AVFormatContext *s = of->ctx;
684     AVStream *st = ost->st;
685     int ret;
686
687     /*
688      * Audio encoders may split the packets --  #frames in != #packets out.
689      * But there is no reordering, so we can limit the number of output packets
690      * by simply dropping them here.
691      * Counting encoded video frames needs to be done separately because of
692      * reordering, see do_video_out().
693      * Do not count the packet when unqueued because it has been counted when queued.
694      */
695     if (!(st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && ost->encoding_needed) && !unqueue) {
696         if (ost->frame_number >= ost->max_frames) {
697             av_packet_unref(pkt);
698             return;
699         }
700         ost->frame_number++;
701     }
702
703     if (!of->header_written) {
704         AVPacket tmp_pkt = {0};
705         /* the muxer is not initialized yet, buffer the packet */
706         if (!av_fifo_space(ost->muxing_queue)) {
707             int new_size = FFMIN(2 * av_fifo_size(ost->muxing_queue),
708                                  ost->max_muxing_queue_size);
709             if (new_size <= av_fifo_size(ost->muxing_queue)) {
710                 av_log(NULL, AV_LOG_ERROR,
711                        "Too many packets buffered for output stream %d:%d.\n",
712                        ost->file_index, ost->st->index);
713                 exit_program(1);
714             }
715             ret = av_fifo_realloc2(ost->muxing_queue, new_size);
716             if (ret < 0)
717                 exit_program(1);
718         }
719         ret = av_packet_ref(&tmp_pkt, pkt);
720         if (ret < 0)
721             exit_program(1);
722         av_fifo_generic_write(ost->muxing_queue, &tmp_pkt, sizeof(tmp_pkt), NULL);
723         av_packet_unref(pkt);
724         return;
725     }
726
727     if ((st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && video_sync_method == VSYNC_DROP) ||
728         (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && audio_sync_method < 0))
729         pkt->pts = pkt->dts = AV_NOPTS_VALUE;
730
731     if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
732         int i;
733         uint8_t *sd = av_packet_get_side_data(pkt, AV_PKT_DATA_QUALITY_STATS,
734                                               NULL);
735         ost->quality = sd ? AV_RL32(sd) : -1;
736         ost->pict_type = sd ? sd[4] : AV_PICTURE_TYPE_NONE;
737
738         for (i = 0; i<FF_ARRAY_ELEMS(ost->error); i++) {
739             if (sd && i < sd[5])
740                 ost->error[i] = AV_RL64(sd + 8 + 8*i);
741             else
742                 ost->error[i] = -1;
743         }
744
745         if (ost->frame_rate.num && ost->is_cfr) {
746             if (pkt->duration > 0)
747                 av_log(NULL, AV_LOG_WARNING, "Overriding packet duration by frame rate, this should not happen\n");
748             pkt->duration = av_rescale_q(1, av_inv_q(ost->frame_rate),
749                                          ost->mux_timebase);
750         }
751     }
752
753     av_packet_rescale_ts(pkt, ost->mux_timebase, ost->st->time_base);
754
755     if (!(s->oformat->flags & AVFMT_NOTIMESTAMPS)) {
756         if (pkt->dts != AV_NOPTS_VALUE &&
757             pkt->pts != AV_NOPTS_VALUE &&
758             pkt->dts > pkt->pts) {
759             av_log(s, AV_LOG_WARNING, "Invalid DTS: %"PRId64" PTS: %"PRId64" in output stream %d:%d, replacing by guess\n",
760                    pkt->dts, pkt->pts,
761                    ost->file_index, ost->st->index);
762             pkt->pts =
763             pkt->dts = pkt->pts + pkt->dts + ost->last_mux_dts + 1
764                      - FFMIN3(pkt->pts, pkt->dts, ost->last_mux_dts + 1)
765                      - FFMAX3(pkt->pts, pkt->dts, ost->last_mux_dts + 1);
766         }
767         if ((st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO || st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) &&
768             pkt->dts != AV_NOPTS_VALUE &&
769             !(st->codecpar->codec_id == AV_CODEC_ID_VP9 && ost->stream_copy) &&
770             ost->last_mux_dts != AV_NOPTS_VALUE) {
771             int64_t max = ost->last_mux_dts + !(s->oformat->flags & AVFMT_TS_NONSTRICT);
772             if (pkt->dts < max) {
773                 int loglevel = max - pkt->dts > 2 || st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ? AV_LOG_WARNING : AV_LOG_DEBUG;
774                 av_log(s, loglevel, "Non-monotonous DTS in output stream "
775                        "%d:%d; previous: %"PRId64", current: %"PRId64"; ",
776                        ost->file_index, ost->st->index, ost->last_mux_dts, pkt->dts);
777                 if (exit_on_error) {
778                     av_log(NULL, AV_LOG_FATAL, "aborting.\n");
779                     exit_program(1);
780                 }
781                 av_log(s, loglevel, "changing to %"PRId64". This may result "
782                        "in incorrect timestamps in the output file.\n",
783                        max);
784                 if (pkt->pts >= pkt->dts)
785                     pkt->pts = FFMAX(pkt->pts, max);
786                 pkt->dts = max;
787             }
788         }
789     }
790     ost->last_mux_dts = pkt->dts;
791
792     ost->data_size += pkt->size;
793     ost->packets_written++;
794
795     pkt->stream_index = ost->index;
796
797     if (debug_ts) {
798         av_log(NULL, AV_LOG_INFO, "muxer <- type:%s "
799                 "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s size:%d\n",
800                 av_get_media_type_string(ost->enc_ctx->codec_type),
801                 av_ts2str(pkt->pts), av_ts2timestr(pkt->pts, &ost->st->time_base),
802                 av_ts2str(pkt->dts), av_ts2timestr(pkt->dts, &ost->st->time_base),
803                 pkt->size
804               );
805     }
806
807     ret = av_interleaved_write_frame(s, pkt);
808     if (ret < 0) {
809         print_error("av_interleaved_write_frame()", ret);
810         main_return_code = 1;
811         close_all_output_streams(ost, MUXER_FINISHED | ENCODER_FINISHED, ENCODER_FINISHED);
812     }
813     av_packet_unref(pkt);
814 }
815
816 static void close_output_stream(OutputStream *ost)
817 {
818     OutputFile *of = output_files[ost->file_index];
819
820     ost->finished |= ENCODER_FINISHED;
821     if (of->shortest) {
822         int64_t end = av_rescale_q(ost->sync_opts - ost->first_pts, ost->enc_ctx->time_base, AV_TIME_BASE_Q);
823         of->recording_time = FFMIN(of->recording_time, end);
824     }
825 }
826
827 /*
828  * Send a single packet to the output, applying any bitstream filters
829  * associated with the output stream.  This may result in any number
830  * of packets actually being written, depending on what bitstream
831  * filters are applied.  The supplied packet is consumed and will be
832  * blank (as if newly-allocated) when this function returns.
833  *
834  * If eof is set, instead indicate EOF to all bitstream filters and
835  * therefore flush any delayed packets to the output.  A blank packet
836  * must be supplied in this case.
837  */
838 static void output_packet(OutputFile *of, AVPacket *pkt,
839                           OutputStream *ost, int eof)
840 {
841     int ret = 0;
842
843     /* apply the output bitstream filters, if any */
844     if (ost->nb_bitstream_filters) {
845         int idx;
846
847         ret = av_bsf_send_packet(ost->bsf_ctx[0], eof ? NULL : pkt);
848         if (ret < 0)
849             goto finish;
850
851         eof = 0;
852         idx = 1;
853         while (idx) {
854             /* get a packet from the previous filter up the chain */
855             ret = av_bsf_receive_packet(ost->bsf_ctx[idx - 1], pkt);
856             if (ret == AVERROR(EAGAIN)) {
857                 ret = 0;
858                 idx--;
859                 continue;
860             } else if (ret == AVERROR_EOF) {
861                 eof = 1;
862             } else if (ret < 0)
863                 goto finish;
864
865             /* send it to the next filter down the chain or to the muxer */
866             if (idx < ost->nb_bitstream_filters) {
867                 ret = av_bsf_send_packet(ost->bsf_ctx[idx], eof ? NULL : pkt);
868                 if (ret < 0)
869                     goto finish;
870                 idx++;
871                 eof = 0;
872             } else if (eof)
873                 goto finish;
874             else
875                 write_packet(of, pkt, ost, 0);
876         }
877     } else if (!eof)
878         write_packet(of, pkt, ost, 0);
879
880 finish:
881     if (ret < 0 && ret != AVERROR_EOF) {
882         av_log(NULL, AV_LOG_ERROR, "Error applying bitstream filters to an output "
883                "packet for stream #%d:%d.\n", ost->file_index, ost->index);
884         if(exit_on_error)
885             exit_program(1);
886     }
887 }
888
889 static int check_recording_time(OutputStream *ost)
890 {
891     OutputFile *of = output_files[ost->file_index];
892
893     if (of->recording_time != INT64_MAX &&
894         av_compare_ts(ost->sync_opts - ost->first_pts, ost->enc_ctx->time_base, of->recording_time,
895                       AV_TIME_BASE_Q) >= 0) {
896         close_output_stream(ost);
897         return 0;
898     }
899     return 1;
900 }
901
902 static void do_audio_out(OutputFile *of, OutputStream *ost,
903                          AVFrame *frame)
904 {
905     AVCodecContext *enc = ost->enc_ctx;
906     AVPacket pkt;
907     int ret;
908
909     av_init_packet(&pkt);
910     pkt.data = NULL;
911     pkt.size = 0;
912
913     if (!check_recording_time(ost))
914         return;
915
916     if (frame->pts == AV_NOPTS_VALUE || audio_sync_method < 0)
917         frame->pts = ost->sync_opts;
918     ost->sync_opts = frame->pts + frame->nb_samples;
919     ost->samples_encoded += frame->nb_samples;
920     ost->frames_encoded++;
921
922     av_assert0(pkt.size || !pkt.data);
923     update_benchmark(NULL);
924     if (debug_ts) {
925         av_log(NULL, AV_LOG_INFO, "encoder <- type:audio "
926                "frame_pts:%s frame_pts_time:%s time_base:%d/%d\n",
927                av_ts2str(frame->pts), av_ts2timestr(frame->pts, &enc->time_base),
928                enc->time_base.num, enc->time_base.den);
929     }
930
931     ret = avcodec_send_frame(enc, frame);
932     if (ret < 0)
933         goto error;
934
935     while (1) {
936         ret = avcodec_receive_packet(enc, &pkt);
937         if (ret == AVERROR(EAGAIN))
938             break;
939         if (ret < 0)
940             goto error;
941
942         update_benchmark("encode_audio %d.%d", ost->file_index, ost->index);
943
944         av_packet_rescale_ts(&pkt, enc->time_base, ost->mux_timebase);
945
946         if (debug_ts) {
947             av_log(NULL, AV_LOG_INFO, "encoder -> type:audio "
948                    "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s\n",
949                    av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &enc->time_base),
950                    av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &enc->time_base));
951         }
952
953         output_packet(of, &pkt, ost, 0);
954     }
955
956     return;
957 error:
958     av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
959     exit_program(1);
960 }
961
962 static void do_subtitle_out(OutputFile *of,
963                             OutputStream *ost,
964                             AVSubtitle *sub)
965 {
966     int subtitle_out_max_size = 1024 * 1024;
967     int subtitle_out_size, nb, i;
968     AVCodecContext *enc;
969     AVPacket pkt;
970     int64_t pts;
971
972     if (sub->pts == AV_NOPTS_VALUE) {
973         av_log(NULL, AV_LOG_ERROR, "Subtitle packets must have a pts\n");
974         if (exit_on_error)
975             exit_program(1);
976         return;
977     }
978
979     enc = ost->enc_ctx;
980
981     if (!subtitle_out) {
982         subtitle_out = av_malloc(subtitle_out_max_size);
983         if (!subtitle_out) {
984             av_log(NULL, AV_LOG_FATAL, "Failed to allocate subtitle_out\n");
985             exit_program(1);
986         }
987     }
988
989     /* Note: DVB subtitle need one packet to draw them and one other
990        packet to clear them */
991     /* XXX: signal it in the codec context ? */
992     if (enc->codec_id == AV_CODEC_ID_DVB_SUBTITLE)
993         nb = 2;
994     else
995         nb = 1;
996
997     /* shift timestamp to honor -ss and make check_recording_time() work with -t */
998     pts = sub->pts;
999     if (output_files[ost->file_index]->start_time != AV_NOPTS_VALUE)
1000         pts -= output_files[ost->file_index]->start_time;
1001     for (i = 0; i < nb; i++) {
1002         unsigned save_num_rects = sub->num_rects;
1003
1004         ost->sync_opts = av_rescale_q(pts, AV_TIME_BASE_Q, enc->time_base);
1005         if (!check_recording_time(ost))
1006             return;
1007
1008         sub->pts = pts;
1009         // start_display_time is required to be 0
1010         sub->pts               += av_rescale_q(sub->start_display_time, (AVRational){ 1, 1000 }, AV_TIME_BASE_Q);
1011         sub->end_display_time  -= sub->start_display_time;
1012         sub->start_display_time = 0;
1013         if (i == 1)
1014             sub->num_rects = 0;
1015
1016         ost->frames_encoded++;
1017
1018         subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1019                                                     subtitle_out_max_size, sub);
1020         if (i == 1)
1021             sub->num_rects = save_num_rects;
1022         if (subtitle_out_size < 0) {
1023             av_log(NULL, AV_LOG_FATAL, "Subtitle encoding failed\n");
1024             exit_program(1);
1025         }
1026
1027         av_init_packet(&pkt);
1028         pkt.data = subtitle_out;
1029         pkt.size = subtitle_out_size;
1030         pkt.pts  = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->mux_timebase);
1031         pkt.duration = av_rescale_q(sub->end_display_time, (AVRational){ 1, 1000 }, ost->mux_timebase);
1032         if (enc->codec_id == AV_CODEC_ID_DVB_SUBTITLE) {
1033             /* XXX: the pts correction is handled here. Maybe handling
1034                it in the codec would be better */
1035             if (i == 0)
1036                 pkt.pts += av_rescale_q(sub->start_display_time, (AVRational){ 1, 1000 }, ost->mux_timebase);
1037             else
1038                 pkt.pts += av_rescale_q(sub->end_display_time, (AVRational){ 1, 1000 }, ost->mux_timebase);
1039         }
1040         pkt.dts = pkt.pts;
1041         output_packet(of, &pkt, ost, 0);
1042     }
1043 }
1044
1045 static void do_video_out(OutputFile *of,
1046                          OutputStream *ost,
1047                          AVFrame *next_picture,
1048                          double sync_ipts)
1049 {
1050     int ret, format_video_sync;
1051     AVPacket pkt;
1052     AVCodecContext *enc = ost->enc_ctx;
1053     AVCodecParameters *mux_par = ost->st->codecpar;
1054     AVRational frame_rate;
1055     int nb_frames, nb0_frames, i;
1056     double delta, delta0;
1057     double duration = 0;
1058     int frame_size = 0;
1059     InputStream *ist = NULL;
1060     AVFilterContext *filter = ost->filter->filter;
1061
1062     if (ost->source_index >= 0)
1063         ist = input_streams[ost->source_index];
1064
1065     frame_rate = av_buffersink_get_frame_rate(filter);
1066     if (frame_rate.num > 0 && frame_rate.den > 0)
1067         duration = 1/(av_q2d(frame_rate) * av_q2d(enc->time_base));
1068
1069     if(ist && ist->st->start_time != AV_NOPTS_VALUE && ist->st->first_dts != AV_NOPTS_VALUE && ost->frame_rate.num)
1070         duration = FFMIN(duration, 1/(av_q2d(ost->frame_rate) * av_q2d(enc->time_base)));
1071
1072     if (!ost->filters_script &&
1073         !ost->filters &&
1074         next_picture &&
1075         ist &&
1076         lrintf(next_picture->pkt_duration * av_q2d(ist->st->time_base) / av_q2d(enc->time_base)) > 0) {
1077         duration = lrintf(next_picture->pkt_duration * av_q2d(ist->st->time_base) / av_q2d(enc->time_base));
1078     }
1079
1080     if (!next_picture) {
1081         //end, flushing
1082         nb0_frames = nb_frames = mid_pred(ost->last_nb0_frames[0],
1083                                           ost->last_nb0_frames[1],
1084                                           ost->last_nb0_frames[2]);
1085     } else {
1086         delta0 = sync_ipts - ost->sync_opts; // delta0 is the "drift" between the input frame (next_picture) and where it would fall in the output.
1087         delta  = delta0 + duration;
1088
1089         /* by default, we output a single frame */
1090         nb0_frames = 0; // tracks the number of times the PREVIOUS frame should be duplicated, mostly for variable framerate (VFR)
1091         nb_frames = 1;
1092
1093         format_video_sync = video_sync_method;
1094         if (format_video_sync == VSYNC_AUTO) {
1095             if(!strcmp(of->ctx->oformat->name, "avi")) {
1096                 format_video_sync = VSYNC_VFR;
1097             } else
1098                 format_video_sync = (of->ctx->oformat->flags & AVFMT_VARIABLE_FPS) ? ((of->ctx->oformat->flags & AVFMT_NOTIMESTAMPS) ? VSYNC_PASSTHROUGH : VSYNC_VFR) : VSYNC_CFR;
1099             if (   ist
1100                 && format_video_sync == VSYNC_CFR
1101                 && input_files[ist->file_index]->ctx->nb_streams == 1
1102                 && input_files[ist->file_index]->input_ts_offset == 0) {
1103                 format_video_sync = VSYNC_VSCFR;
1104             }
1105             if (format_video_sync == VSYNC_CFR && copy_ts) {
1106                 format_video_sync = VSYNC_VSCFR;
1107             }
1108         }
1109         ost->is_cfr = (format_video_sync == VSYNC_CFR || format_video_sync == VSYNC_VSCFR);
1110
1111         if (delta0 < 0 &&
1112             delta > 0 &&
1113             format_video_sync != VSYNC_PASSTHROUGH &&
1114             format_video_sync != VSYNC_DROP) {
1115             if (delta0 < -0.6) {
1116                 av_log(NULL, AV_LOG_WARNING, "Past duration %f too large\n", -delta0);
1117             } else
1118                 av_log(NULL, AV_LOG_DEBUG, "Clipping frame in rate conversion by %f\n", -delta0);
1119             sync_ipts = ost->sync_opts;
1120             duration += delta0;
1121             delta0 = 0;
1122         }
1123
1124         switch (format_video_sync) {
1125         case VSYNC_VSCFR:
1126             if (ost->frame_number == 0 && delta0 >= 0.5) {
1127                 av_log(NULL, AV_LOG_DEBUG, "Not duplicating %d initial frames\n", (int)lrintf(delta0));
1128                 delta = duration;
1129                 delta0 = 0;
1130                 ost->sync_opts = lrint(sync_ipts);
1131             }
1132         case VSYNC_CFR:
1133             // FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1134             if (frame_drop_threshold && delta < frame_drop_threshold && ost->frame_number) {
1135                 nb_frames = 0;
1136             } else if (delta < -1.1)
1137                 nb_frames = 0;
1138             else if (delta > 1.1) {
1139                 nb_frames = lrintf(delta);
1140                 if (delta0 > 1.1)
1141                     nb0_frames = lrintf(delta0 - 0.6);
1142             }
1143             break;
1144         case VSYNC_VFR:
1145             if (delta <= -0.6)
1146                 nb_frames = 0;
1147             else if (delta > 0.6)
1148                 ost->sync_opts = lrint(sync_ipts);
1149             break;
1150         case VSYNC_DROP:
1151         case VSYNC_PASSTHROUGH:
1152             ost->sync_opts = lrint(sync_ipts);
1153             break;
1154         default:
1155             av_assert0(0);
1156         }
1157     }
1158
1159     nb_frames = FFMIN(nb_frames, ost->max_frames - ost->frame_number);
1160     nb0_frames = FFMIN(nb0_frames, nb_frames);
1161
1162     memmove(ost->last_nb0_frames + 1,
1163             ost->last_nb0_frames,
1164             sizeof(ost->last_nb0_frames[0]) * (FF_ARRAY_ELEMS(ost->last_nb0_frames) - 1));
1165     ost->last_nb0_frames[0] = nb0_frames;
1166
1167     if (nb0_frames == 0 && ost->last_dropped) {
1168         nb_frames_drop++;
1169         av_log(NULL, AV_LOG_VERBOSE,
1170                "*** dropping frame %d from stream %d at ts %"PRId64"\n",
1171                ost->frame_number, ost->st->index, ost->last_frame->pts);
1172     }
1173     if (nb_frames > (nb0_frames && ost->last_dropped) + (nb_frames > nb0_frames)) {
1174         if (nb_frames > dts_error_threshold * 30) {
1175             av_log(NULL, AV_LOG_ERROR, "%d frame duplication too large, skipping\n", nb_frames - 1);
1176             nb_frames_drop++;
1177             return;
1178         }
1179         nb_frames_dup += nb_frames - (nb0_frames && ost->last_dropped) - (nb_frames > nb0_frames);
1180         av_log(NULL, AV_LOG_VERBOSE, "*** %d dup!\n", nb_frames - 1);
1181         if (nb_frames_dup > dup_warning) {
1182             av_log(NULL, AV_LOG_WARNING, "More than %d frames duplicated\n", dup_warning);
1183             dup_warning *= 10;
1184         }
1185     }
1186     ost->last_dropped = nb_frames == nb0_frames && next_picture;
1187
1188   /* duplicates frame if needed */
1189   for (i = 0; i < nb_frames; i++) {
1190     AVFrame *in_picture;
1191     av_init_packet(&pkt);
1192     pkt.data = NULL;
1193     pkt.size = 0;
1194
1195     if (i < nb0_frames && ost->last_frame) {
1196         in_picture = ost->last_frame;
1197     } else
1198         in_picture = next_picture;
1199
1200     if (!in_picture)
1201         return;
1202
1203     in_picture->pts = ost->sync_opts;
1204
1205 #if 1
1206     if (!check_recording_time(ost))
1207 #else
1208     if (ost->frame_number >= ost->max_frames)
1209 #endif
1210         return;
1211
1212     {
1213         int forced_keyframe = 0;
1214         double pts_time;
1215
1216         if (enc->flags & (AV_CODEC_FLAG_INTERLACED_DCT | AV_CODEC_FLAG_INTERLACED_ME) &&
1217             ost->top_field_first >= 0)
1218             in_picture->top_field_first = !!ost->top_field_first;
1219
1220         if (in_picture->interlaced_frame) {
1221             if (enc->codec->id == AV_CODEC_ID_MJPEG)
1222                 mux_par->field_order = in_picture->top_field_first ? AV_FIELD_TT:AV_FIELD_BB;
1223             else
1224                 mux_par->field_order = in_picture->top_field_first ? AV_FIELD_TB:AV_FIELD_BT;
1225         } else
1226             mux_par->field_order = AV_FIELD_PROGRESSIVE;
1227
1228         in_picture->quality = enc->global_quality;
1229         in_picture->pict_type = 0;
1230
1231         pts_time = in_picture->pts != AV_NOPTS_VALUE ?
1232             in_picture->pts * av_q2d(enc->time_base) : NAN;
1233         if (ost->forced_kf_index < ost->forced_kf_count &&
1234             in_picture->pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1235             ost->forced_kf_index++;
1236             forced_keyframe = 1;
1237         } else if (ost->forced_keyframes_pexpr) {
1238             double res;
1239             ost->forced_keyframes_expr_const_values[FKF_T] = pts_time;
1240             res = av_expr_eval(ost->forced_keyframes_pexpr,
1241                                ost->forced_keyframes_expr_const_values, NULL);
1242             ff_dlog(NULL, "force_key_frame: n:%f n_forced:%f prev_forced_n:%f t:%f prev_forced_t:%f -> res:%f\n",
1243                     ost->forced_keyframes_expr_const_values[FKF_N],
1244                     ost->forced_keyframes_expr_const_values[FKF_N_FORCED],
1245                     ost->forced_keyframes_expr_const_values[FKF_PREV_FORCED_N],
1246                     ost->forced_keyframes_expr_const_values[FKF_T],
1247                     ost->forced_keyframes_expr_const_values[FKF_PREV_FORCED_T],
1248                     res);
1249             if (res) {
1250                 forced_keyframe = 1;
1251                 ost->forced_keyframes_expr_const_values[FKF_PREV_FORCED_N] =
1252                     ost->forced_keyframes_expr_const_values[FKF_N];
1253                 ost->forced_keyframes_expr_const_values[FKF_PREV_FORCED_T] =
1254                     ost->forced_keyframes_expr_const_values[FKF_T];
1255                 ost->forced_keyframes_expr_const_values[FKF_N_FORCED] += 1;
1256             }
1257
1258             ost->forced_keyframes_expr_const_values[FKF_N] += 1;
1259         } else if (   ost->forced_keyframes
1260                    && !strncmp(ost->forced_keyframes, "source", 6)
1261                    && in_picture->key_frame==1) {
1262             forced_keyframe = 1;
1263         }
1264
1265         if (forced_keyframe) {
1266             in_picture->pict_type = AV_PICTURE_TYPE_I;
1267             av_log(NULL, AV_LOG_DEBUG, "Forced keyframe at time %f\n", pts_time);
1268         }
1269
1270         update_benchmark(NULL);
1271         if (debug_ts) {
1272             av_log(NULL, AV_LOG_INFO, "encoder <- type:video "
1273                    "frame_pts:%s frame_pts_time:%s time_base:%d/%d\n",
1274                    av_ts2str(in_picture->pts), av_ts2timestr(in_picture->pts, &enc->time_base),
1275                    enc->time_base.num, enc->time_base.den);
1276         }
1277
1278         ost->frames_encoded++;
1279
1280         ret = avcodec_send_frame(enc, in_picture);
1281         if (ret < 0)
1282             goto error;
1283
1284         while (1) {
1285             ret = avcodec_receive_packet(enc, &pkt);
1286             update_benchmark("encode_video %d.%d", ost->file_index, ost->index);
1287             if (ret == AVERROR(EAGAIN))
1288                 break;
1289             if (ret < 0)
1290                 goto error;
1291
1292             if (debug_ts) {
1293                 av_log(NULL, AV_LOG_INFO, "encoder -> type:video "
1294                        "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s\n",
1295                        av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &enc->time_base),
1296                        av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &enc->time_base));
1297             }
1298
1299             if (pkt.pts == AV_NOPTS_VALUE && !(enc->codec->capabilities & AV_CODEC_CAP_DELAY))
1300                 pkt.pts = ost->sync_opts;
1301
1302             av_packet_rescale_ts(&pkt, enc->time_base, ost->mux_timebase);
1303
1304             if (debug_ts) {
1305                 av_log(NULL, AV_LOG_INFO, "encoder -> type:video "
1306                     "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s\n",
1307                     av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ost->mux_timebase),
1308                     av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ost->mux_timebase));
1309             }
1310
1311             frame_size = pkt.size;
1312             output_packet(of, &pkt, ost, 0);
1313
1314             /* if two pass, output log */
1315             if (ost->logfile && enc->stats_out) {
1316                 fprintf(ost->logfile, "%s", enc->stats_out);
1317             }
1318         }
1319     }
1320     ost->sync_opts++;
1321     /*
1322      * For video, number of frames in == number of packets out.
1323      * But there may be reordering, so we can't throw away frames on encoder
1324      * flush, we need to limit them here, before they go into encoder.
1325      */
1326     ost->frame_number++;
1327
1328     if (vstats_filename && frame_size)
1329         do_video_stats(ost, frame_size);
1330   }
1331
1332     if (!ost->last_frame)
1333         ost->last_frame = av_frame_alloc();
1334     av_frame_unref(ost->last_frame);
1335     if (next_picture && ost->last_frame)
1336         av_frame_ref(ost->last_frame, next_picture);
1337     else
1338         av_frame_free(&ost->last_frame);
1339
1340     return;
1341 error:
1342     av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
1343     exit_program(1);
1344 }
1345
1346 static double psnr(double d)
1347 {
1348     return -10.0 * log10(d);
1349 }
1350
1351 static void do_video_stats(OutputStream *ost, int frame_size)
1352 {
1353     AVCodecContext *enc;
1354     int frame_number;
1355     double ti1, bitrate, avg_bitrate;
1356
1357     /* this is executed just the first time do_video_stats is called */
1358     if (!vstats_file) {
1359         vstats_file = fopen(vstats_filename, "w");
1360         if (!vstats_file) {
1361             perror("fopen");
1362             exit_program(1);
1363         }
1364     }
1365
1366     enc = ost->enc_ctx;
1367     if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1368         frame_number = ost->st->nb_frames;
1369         if (vstats_version <= 1) {
1370             fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number,
1371                     ost->quality / (float)FF_QP2LAMBDA);
1372         } else  {
1373             fprintf(vstats_file, "out= %2d st= %2d frame= %5d q= %2.1f ", ost->file_index, ost->index, frame_number,
1374                     ost->quality / (float)FF_QP2LAMBDA);
1375         }
1376
1377         if (ost->error[0]>=0 && (enc->flags & AV_CODEC_FLAG_PSNR))
1378             fprintf(vstats_file, "PSNR= %6.2f ", psnr(ost->error[0] / (enc->width * enc->height * 255.0 * 255.0)));
1379
1380         fprintf(vstats_file,"f_size= %6d ", frame_size);
1381         /* compute pts value */
1382         ti1 = av_stream_get_end_pts(ost->st) * av_q2d(ost->st->time_base);
1383         if (ti1 < 0.01)
1384             ti1 = 0.01;
1385
1386         bitrate     = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1387         avg_bitrate = (double)(ost->data_size * 8) / ti1 / 1000.0;
1388         fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1389                (double)ost->data_size / 1024, ti1, bitrate, avg_bitrate);
1390         fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(ost->pict_type));
1391     }
1392 }
1393
1394 static int init_output_stream(OutputStream *ost, char *error, int error_len);
1395
1396 static void finish_output_stream(OutputStream *ost)
1397 {
1398     OutputFile *of = output_files[ost->file_index];
1399     int i;
1400
1401     ost->finished = ENCODER_FINISHED | MUXER_FINISHED;
1402
1403     if (of->shortest) {
1404         for (i = 0; i < of->ctx->nb_streams; i++)
1405             output_streams[of->ost_index + i]->finished = ENCODER_FINISHED | MUXER_FINISHED;
1406     }
1407 }
1408
1409 /**
1410  * Get and encode new output from any of the filtergraphs, without causing
1411  * activity.
1412  *
1413  * @return  0 for success, <0 for severe errors
1414  */
1415 static int reap_filters(int flush)
1416 {
1417     AVFrame *filtered_frame = NULL;
1418     int i;
1419
1420     /* Reap all buffers present in the buffer sinks */
1421     for (i = 0; i < nb_output_streams; i++) {
1422         OutputStream *ost = output_streams[i];
1423         OutputFile    *of = output_files[ost->file_index];
1424         AVFilterContext *filter;
1425         AVCodecContext *enc = ost->enc_ctx;
1426         int ret = 0;
1427
1428         if (!ost->filter || !ost->filter->graph->graph)
1429             continue;
1430         filter = ost->filter->filter;
1431
1432         if (!ost->initialized) {
1433             char error[1024] = "";
1434             ret = init_output_stream(ost, error, sizeof(error));
1435             if (ret < 0) {
1436                 av_log(NULL, AV_LOG_ERROR, "Error initializing output stream %d:%d -- %s\n",
1437                        ost->file_index, ost->index, error);
1438                 exit_program(1);
1439             }
1440         }
1441
1442         if (!ost->filtered_frame && !(ost->filtered_frame = av_frame_alloc())) {
1443             return AVERROR(ENOMEM);
1444         }
1445         filtered_frame = ost->filtered_frame;
1446
1447         while (1) {
1448             double float_pts = AV_NOPTS_VALUE; // this is identical to filtered_frame.pts but with higher precision
1449             ret = av_buffersink_get_frame_flags(filter, filtered_frame,
1450                                                AV_BUFFERSINK_FLAG_NO_REQUEST);
1451             if (ret < 0) {
1452                 if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF) {
1453                     av_log(NULL, AV_LOG_WARNING,
1454                            "Error in av_buffersink_get_frame_flags(): %s\n", av_err2str(ret));
1455                 } else if (flush && ret == AVERROR_EOF) {
1456                     if (av_buffersink_get_type(filter) == AVMEDIA_TYPE_VIDEO)
1457                         do_video_out(of, ost, NULL, AV_NOPTS_VALUE);
1458                 }
1459                 break;
1460             }
1461             if (ost->finished) {
1462                 av_frame_unref(filtered_frame);
1463                 continue;
1464             }
1465             if (filtered_frame->pts != AV_NOPTS_VALUE) {
1466                 int64_t start_time = (of->start_time == AV_NOPTS_VALUE) ? 0 : of->start_time;
1467                 AVRational filter_tb = av_buffersink_get_time_base(filter);
1468                 AVRational tb = enc->time_base;
1469                 int extra_bits = av_clip(29 - av_log2(tb.den), 0, 16);
1470
1471                 tb.den <<= extra_bits;
1472                 float_pts =
1473                     av_rescale_q(filtered_frame->pts, filter_tb, tb) -
1474                     av_rescale_q(start_time, AV_TIME_BASE_Q, tb);
1475                 float_pts /= 1 << extra_bits;
1476                 // 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
1477                 float_pts += FFSIGN(float_pts) * 1.0 / (1<<17);
1478
1479                 filtered_frame->pts =
1480                     av_rescale_q(filtered_frame->pts, filter_tb, enc->time_base) -
1481                     av_rescale_q(start_time, AV_TIME_BASE_Q, enc->time_base);
1482             }
1483             //if (ost->source_index >= 0)
1484             //    *filtered_frame= *input_streams[ost->source_index]->decoded_frame; //for me_threshold
1485
1486             switch (av_buffersink_get_type(filter)) {
1487             case AVMEDIA_TYPE_VIDEO:
1488                 if (!ost->frame_aspect_ratio.num)
1489                     enc->sample_aspect_ratio = filtered_frame->sample_aspect_ratio;
1490
1491                 if (debug_ts) {
1492                     av_log(NULL, AV_LOG_INFO, "filter -> pts:%s pts_time:%s exact:%f time_base:%d/%d\n",
1493                             av_ts2str(filtered_frame->pts), av_ts2timestr(filtered_frame->pts, &enc->time_base),
1494                             float_pts,
1495                             enc->time_base.num, enc->time_base.den);
1496                 }
1497
1498                 do_video_out(of, ost, filtered_frame, float_pts);
1499                 break;
1500             case AVMEDIA_TYPE_AUDIO:
1501                 if (!(enc->codec->capabilities & AV_CODEC_CAP_PARAM_CHANGE) &&
1502                     enc->channels != filtered_frame->channels) {
1503                     av_log(NULL, AV_LOG_ERROR,
1504                            "Audio filter graph output is not normalized and encoder does not support parameter changes\n");
1505                     break;
1506                 }
1507                 do_audio_out(of, ost, filtered_frame);
1508                 break;
1509             default:
1510                 // TODO support subtitle filters
1511                 av_assert0(0);
1512             }
1513
1514             av_frame_unref(filtered_frame);
1515         }
1516     }
1517
1518     return 0;
1519 }
1520
1521 static void print_final_stats(int64_t total_size)
1522 {
1523     uint64_t video_size = 0, audio_size = 0, extra_size = 0, other_size = 0;
1524     uint64_t subtitle_size = 0;
1525     uint64_t data_size = 0;
1526     float percent = -1.0;
1527     int i, j;
1528     int pass1_used = 1;
1529
1530     for (i = 0; i < nb_output_streams; i++) {
1531         OutputStream *ost = output_streams[i];
1532         switch (ost->enc_ctx->codec_type) {
1533             case AVMEDIA_TYPE_VIDEO: video_size += ost->data_size; break;
1534             case AVMEDIA_TYPE_AUDIO: audio_size += ost->data_size; break;
1535             case AVMEDIA_TYPE_SUBTITLE: subtitle_size += ost->data_size; break;
1536             default:                 other_size += ost->data_size; break;
1537         }
1538         extra_size += ost->enc_ctx->extradata_size;
1539         data_size  += ost->data_size;
1540         if (   (ost->enc_ctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2))
1541             != AV_CODEC_FLAG_PASS1)
1542             pass1_used = 0;
1543     }
1544
1545     if (data_size && total_size>0 && total_size >= data_size)
1546         percent = 100.0 * (total_size - data_size) / data_size;
1547
1548     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: ",
1549            video_size / 1024.0,
1550            audio_size / 1024.0,
1551            subtitle_size / 1024.0,
1552            other_size / 1024.0,
1553            extra_size / 1024.0);
1554     if (percent >= 0.0)
1555         av_log(NULL, AV_LOG_INFO, "%f%%", percent);
1556     else
1557         av_log(NULL, AV_LOG_INFO, "unknown");
1558     av_log(NULL, AV_LOG_INFO, "\n");
1559
1560     /* print verbose per-stream stats */
1561     for (i = 0; i < nb_input_files; i++) {
1562         InputFile *f = input_files[i];
1563         uint64_t total_packets = 0, total_size = 0;
1564
1565         av_log(NULL, AV_LOG_VERBOSE, "Input file #%d (%s):\n",
1566                i, f->ctx->url);
1567
1568         for (j = 0; j < f->nb_streams; j++) {
1569             InputStream *ist = input_streams[f->ist_index + j];
1570             enum AVMediaType type = ist->dec_ctx->codec_type;
1571
1572             total_size    += ist->data_size;
1573             total_packets += ist->nb_packets;
1574
1575             av_log(NULL, AV_LOG_VERBOSE, "  Input stream #%d:%d (%s): ",
1576                    i, j, media_type_string(type));
1577             av_log(NULL, AV_LOG_VERBOSE, "%"PRIu64" packets read (%"PRIu64" bytes); ",
1578                    ist->nb_packets, ist->data_size);
1579
1580             if (ist->decoding_needed) {
1581                 av_log(NULL, AV_LOG_VERBOSE, "%"PRIu64" frames decoded",
1582                        ist->frames_decoded);
1583                 if (type == AVMEDIA_TYPE_AUDIO)
1584                     av_log(NULL, AV_LOG_VERBOSE, " (%"PRIu64" samples)", ist->samples_decoded);
1585                 av_log(NULL, AV_LOG_VERBOSE, "; ");
1586             }
1587
1588             av_log(NULL, AV_LOG_VERBOSE, "\n");
1589         }
1590
1591         av_log(NULL, AV_LOG_VERBOSE, "  Total: %"PRIu64" packets (%"PRIu64" bytes) demuxed\n",
1592                total_packets, total_size);
1593     }
1594
1595     for (i = 0; i < nb_output_files; i++) {
1596         OutputFile *of = output_files[i];
1597         uint64_t total_packets = 0, total_size = 0;
1598
1599         av_log(NULL, AV_LOG_VERBOSE, "Output file #%d (%s):\n",
1600                i, of->ctx->url);
1601
1602         for (j = 0; j < of->ctx->nb_streams; j++) {
1603             OutputStream *ost = output_streams[of->ost_index + j];
1604             enum AVMediaType type = ost->enc_ctx->codec_type;
1605
1606             total_size    += ost->data_size;
1607             total_packets += ost->packets_written;
1608
1609             av_log(NULL, AV_LOG_VERBOSE, "  Output stream #%d:%d (%s): ",
1610                    i, j, media_type_string(type));
1611             if (ost->encoding_needed) {
1612                 av_log(NULL, AV_LOG_VERBOSE, "%"PRIu64" frames encoded",
1613                        ost->frames_encoded);
1614                 if (type == AVMEDIA_TYPE_AUDIO)
1615                     av_log(NULL, AV_LOG_VERBOSE, " (%"PRIu64" samples)", ost->samples_encoded);
1616                 av_log(NULL, AV_LOG_VERBOSE, "; ");
1617             }
1618
1619             av_log(NULL, AV_LOG_VERBOSE, "%"PRIu64" packets muxed (%"PRIu64" bytes); ",
1620                    ost->packets_written, ost->data_size);
1621
1622             av_log(NULL, AV_LOG_VERBOSE, "\n");
1623         }
1624
1625         av_log(NULL, AV_LOG_VERBOSE, "  Total: %"PRIu64" packets (%"PRIu64" bytes) muxed\n",
1626                total_packets, total_size);
1627     }
1628     if(video_size + data_size + audio_size + subtitle_size + extra_size == 0){
1629         av_log(NULL, AV_LOG_WARNING, "Output file is empty, nothing was encoded ");
1630         if (pass1_used) {
1631             av_log(NULL, AV_LOG_WARNING, "\n");
1632         } else {
1633             av_log(NULL, AV_LOG_WARNING, "(check -ss / -t / -frames parameters if used)\n");
1634         }
1635     }
1636 }
1637
1638 static void print_report(int is_last_report, int64_t timer_start, int64_t cur_time)
1639 {
1640     char buf[1024];
1641     AVBPrint buf_script;
1642     OutputStream *ost;
1643     AVFormatContext *oc;
1644     int64_t total_size;
1645     AVCodecContext *enc;
1646     int frame_number, vid, i;
1647     double bitrate;
1648     double speed;
1649     int64_t pts = INT64_MIN + 1;
1650     static int64_t last_time = -1;
1651     static int qp_histogram[52];
1652     int hours, mins, secs, us;
1653     const char *hours_sign;
1654     int ret;
1655     float t;
1656
1657     if (!print_stats && !is_last_report && !progress_avio)
1658         return;
1659
1660     if (!is_last_report) {
1661         if (last_time == -1) {
1662             last_time = cur_time;
1663             return;
1664         }
1665         if ((cur_time - last_time) < 500000)
1666             return;
1667         last_time = cur_time;
1668     }
1669
1670     t = (cur_time-timer_start) / 1000000.0;
1671
1672
1673     oc = output_files[0]->ctx;
1674
1675     total_size = avio_size(oc->pb);
1676     if (total_size <= 0) // FIXME improve avio_size() so it works with non seekable output too
1677         total_size = avio_tell(oc->pb);
1678
1679     buf[0] = '\0';
1680     vid = 0;
1681     av_bprint_init(&buf_script, 0, 1);
1682     for (i = 0; i < nb_output_streams; i++) {
1683         float q = -1;
1684         ost = output_streams[i];
1685         enc = ost->enc_ctx;
1686         if (!ost->stream_copy)
1687             q = ost->quality / (float) FF_QP2LAMBDA;
1688
1689         if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1690             snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1691             av_bprintf(&buf_script, "stream_%d_%d_q=%.1f\n",
1692                        ost->file_index, ost->index, q);
1693         }
1694         if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1695             float fps;
1696
1697             frame_number = ost->frame_number;
1698             fps = t > 1 ? frame_number / t : 0;
1699             snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3.*f q=%3.1f ",
1700                      frame_number, fps < 9.95, fps, q);
1701             av_bprintf(&buf_script, "frame=%d\n", frame_number);
1702             av_bprintf(&buf_script, "fps=%.1f\n", fps);
1703             av_bprintf(&buf_script, "stream_%d_%d_q=%.1f\n",
1704                        ost->file_index, ost->index, q);
1705             if (is_last_report)
1706                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1707             if (qp_hist) {
1708                 int j;
1709                 int qp = lrintf(q);
1710                 if (qp >= 0 && qp < FF_ARRAY_ELEMS(qp_histogram))
1711                     qp_histogram[qp]++;
1712                 for (j = 0; j < 32; j++)
1713                     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", av_log2(qp_histogram[j] + 1));
1714             }
1715
1716             if ((enc->flags & AV_CODEC_FLAG_PSNR) && (ost->pict_type != AV_PICTURE_TYPE_NONE || is_last_report)) {
1717                 int j;
1718                 double error, error_sum = 0;
1719                 double scale, scale_sum = 0;
1720                 double p;
1721                 char type[3] = { 'Y','U','V' };
1722                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1723                 for (j = 0; j < 3; j++) {
1724                     if (is_last_report) {
1725                         error = enc->error[j];
1726                         scale = enc->width * enc->height * 255.0 * 255.0 * frame_number;
1727                     } else {
1728                         error = ost->error[j];
1729                         scale = enc->width * enc->height * 255.0 * 255.0;
1730                     }
1731                     if (j)
1732                         scale /= 4;
1733                     error_sum += error;
1734                     scale_sum += scale;
1735                     p = psnr(error / scale);
1736                     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], p);
1737                     av_bprintf(&buf_script, "stream_%d_%d_psnr_%c=%2.2f\n",
1738                                ost->file_index, ost->index, type[j] | 32, p);
1739                 }
1740                 p = psnr(error_sum / scale_sum);
1741                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum / scale_sum));
1742                 av_bprintf(&buf_script, "stream_%d_%d_psnr_all=%2.2f\n",
1743                            ost->file_index, ost->index, p);
1744             }
1745             vid = 1;
1746         }
1747         /* compute min output value */
1748         if (av_stream_get_end_pts(ost->st) != AV_NOPTS_VALUE)
1749             pts = FFMAX(pts, av_rescale_q(av_stream_get_end_pts(ost->st),
1750                                           ost->st->time_base, AV_TIME_BASE_Q));
1751         if (is_last_report)
1752             nb_frames_drop += ost->last_dropped;
1753     }
1754
1755     secs = FFABS(pts) / AV_TIME_BASE;
1756     us = FFABS(pts) % AV_TIME_BASE;
1757     mins = secs / 60;
1758     secs %= 60;
1759     hours = mins / 60;
1760     mins %= 60;
1761     hours_sign = (pts < 0) ? "-" : "";
1762
1763     bitrate = pts && total_size >= 0 ? total_size * 8 / (pts / 1000.0) : -1;
1764     speed = t != 0.0 ? (double)pts / AV_TIME_BASE / t : -1;
1765
1766     if (total_size < 0) snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1767                                  "size=N/A time=");
1768     else                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1769                                  "size=%8.0fkB time=", total_size / 1024.0);
1770     if (pts == AV_NOPTS_VALUE) {
1771         snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "N/A ");
1772     } else {
1773         snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1774                  "%s%02d:%02d:%02d.%02d ", hours_sign, hours, mins, secs,
1775                  (100 * us) / AV_TIME_BASE);
1776     }
1777
1778     if (bitrate < 0) {
1779         snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),"bitrate=N/A");
1780         av_bprintf(&buf_script, "bitrate=N/A\n");
1781     }else{
1782         snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),"bitrate=%6.1fkbits/s", bitrate);
1783         av_bprintf(&buf_script, "bitrate=%6.1fkbits/s\n", bitrate);
1784     }
1785
1786     if (total_size < 0) av_bprintf(&buf_script, "total_size=N/A\n");
1787     else                av_bprintf(&buf_script, "total_size=%"PRId64"\n", total_size);
1788     if (pts == AV_NOPTS_VALUE) {
1789         av_bprintf(&buf_script, "out_time_ms=N/A\n");
1790         av_bprintf(&buf_script, "out_time=N/A\n");
1791     } else {
1792         av_bprintf(&buf_script, "out_time_ms=%"PRId64"\n", pts);
1793         av_bprintf(&buf_script, "out_time=%s%02d:%02d:%02d.%06d\n",
1794                    hours_sign, hours, mins, secs, us);
1795     }
1796
1797     if (nb_frames_dup || nb_frames_drop)
1798         snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1799                 nb_frames_dup, nb_frames_drop);
1800     av_bprintf(&buf_script, "dup_frames=%d\n", nb_frames_dup);
1801     av_bprintf(&buf_script, "drop_frames=%d\n", nb_frames_drop);
1802
1803     if (speed < 0) {
1804         snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf)," speed=N/A");
1805         av_bprintf(&buf_script, "speed=N/A\n");
1806     } else {
1807         snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf)," speed=%4.3gx", speed);
1808         av_bprintf(&buf_script, "speed=%4.3gx\n", speed);
1809     }
1810
1811     if (print_stats || is_last_report) {
1812         const char end = is_last_report ? '\n' : '\r';
1813         if (print_stats==1 && AV_LOG_INFO > av_log_get_level()) {
1814             fprintf(stderr, "%s    %c", buf, end);
1815         } else
1816             av_log(NULL, AV_LOG_INFO, "%s    %c", buf, end);
1817
1818     fflush(stderr);
1819     }
1820
1821     if (progress_avio) {
1822         av_bprintf(&buf_script, "progress=%s\n",
1823                    is_last_report ? "end" : "continue");
1824         avio_write(progress_avio, buf_script.str,
1825                    FFMIN(buf_script.len, buf_script.size - 1));
1826         avio_flush(progress_avio);
1827         av_bprint_finalize(&buf_script, NULL);
1828         if (is_last_report) {
1829             if ((ret = avio_closep(&progress_avio)) < 0)
1830                 av_log(NULL, AV_LOG_ERROR,
1831                        "Error closing progress log, loss of information possible: %s\n", av_err2str(ret));
1832         }
1833     }
1834
1835     if (is_last_report)
1836         print_final_stats(total_size);
1837 }
1838
1839 static void flush_encoders(void)
1840 {
1841     int i, ret;
1842
1843     for (i = 0; i < nb_output_streams; i++) {
1844         OutputStream   *ost = output_streams[i];
1845         AVCodecContext *enc = ost->enc_ctx;
1846         OutputFile      *of = output_files[ost->file_index];
1847
1848         if (!ost->encoding_needed)
1849             continue;
1850
1851         // Try to enable encoding with no input frames.
1852         // Maybe we should just let encoding fail instead.
1853         if (!ost->initialized) {
1854             FilterGraph *fg = ost->filter->graph;
1855             char error[1024] = "";
1856
1857             av_log(NULL, AV_LOG_WARNING,
1858                    "Finishing stream %d:%d without any data written to it.\n",
1859                    ost->file_index, ost->st->index);
1860
1861             if (ost->filter && !fg->graph) {
1862                 int x;
1863                 for (x = 0; x < fg->nb_inputs; x++) {
1864                     InputFilter *ifilter = fg->inputs[x];
1865                     if (ifilter->format < 0) {
1866                         AVCodecParameters *par = ifilter->ist->st->codecpar;
1867                         // We never got any input. Set a fake format, which will
1868                         // come from libavformat.
1869                         ifilter->format                 = par->format;
1870                         ifilter->sample_rate            = par->sample_rate;
1871                         ifilter->channels               = par->channels;
1872                         ifilter->channel_layout         = par->channel_layout;
1873                         ifilter->width                  = par->width;
1874                         ifilter->height                 = par->height;
1875                         ifilter->sample_aspect_ratio    = par->sample_aspect_ratio;
1876                     }
1877                 }
1878
1879                 if (!ifilter_has_all_input_formats(fg))
1880                     continue;
1881
1882                 ret = configure_filtergraph(fg);
1883                 if (ret < 0) {
1884                     av_log(NULL, AV_LOG_ERROR, "Error configuring filter graph\n");
1885                     exit_program(1);
1886                 }
1887
1888                 finish_output_stream(ost);
1889             }
1890
1891             ret = init_output_stream(ost, error, sizeof(error));
1892             if (ret < 0) {
1893                 av_log(NULL, AV_LOG_ERROR, "Error initializing output stream %d:%d -- %s\n",
1894                        ost->file_index, ost->index, error);
1895                 exit_program(1);
1896             }
1897         }
1898
1899         if (enc->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <= 1)
1900             continue;
1901
1902         if (enc->codec_type != AVMEDIA_TYPE_VIDEO && enc->codec_type != AVMEDIA_TYPE_AUDIO)
1903             continue;
1904
1905         for (;;) {
1906             const char *desc = NULL;
1907             AVPacket pkt;
1908             int pkt_size;
1909
1910             switch (enc->codec_type) {
1911             case AVMEDIA_TYPE_AUDIO:
1912                 desc   = "audio";
1913                 break;
1914             case AVMEDIA_TYPE_VIDEO:
1915                 desc   = "video";
1916                 break;
1917             default:
1918                 av_assert0(0);
1919             }
1920
1921                 av_init_packet(&pkt);
1922                 pkt.data = NULL;
1923                 pkt.size = 0;
1924
1925                 update_benchmark(NULL);
1926
1927                 while ((ret = avcodec_receive_packet(enc, &pkt)) == AVERROR(EAGAIN)) {
1928                     ret = avcodec_send_frame(enc, NULL);
1929                     if (ret < 0) {
1930                         av_log(NULL, AV_LOG_FATAL, "%s encoding failed: %s\n",
1931                                desc,
1932                                av_err2str(ret));
1933                         exit_program(1);
1934                     }
1935                 }
1936
1937                 update_benchmark("flush_%s %d.%d", desc, ost->file_index, ost->index);
1938                 if (ret < 0 && ret != AVERROR_EOF) {
1939                     av_log(NULL, AV_LOG_FATAL, "%s encoding failed: %s\n",
1940                            desc,
1941                            av_err2str(ret));
1942                     exit_program(1);
1943                 }
1944                 if (ost->logfile && enc->stats_out) {
1945                     fprintf(ost->logfile, "%s", enc->stats_out);
1946                 }
1947                 if (ret == AVERROR_EOF) {
1948                     output_packet(of, &pkt, ost, 1);
1949                     break;
1950                 }
1951                 if (ost->finished & MUXER_FINISHED) {
1952                     av_packet_unref(&pkt);
1953                     continue;
1954                 }
1955                 av_packet_rescale_ts(&pkt, enc->time_base, ost->mux_timebase);
1956                 pkt_size = pkt.size;
1957                 output_packet(of, &pkt, ost, 0);
1958                 if (ost->enc_ctx->codec_type == AVMEDIA_TYPE_VIDEO && vstats_filename) {
1959                     do_video_stats(ost, pkt_size);
1960                 }
1961         }
1962     }
1963 }
1964
1965 /*
1966  * Check whether a packet from ist should be written into ost at this time
1967  */
1968 static int check_output_constraints(InputStream *ist, OutputStream *ost)
1969 {
1970     OutputFile *of = output_files[ost->file_index];
1971     int ist_index  = input_files[ist->file_index]->ist_index + ist->st->index;
1972
1973     if (ost->source_index != ist_index)
1974         return 0;
1975
1976     if (ost->finished)
1977         return 0;
1978
1979     if (of->start_time != AV_NOPTS_VALUE && ist->pts < of->start_time)
1980         return 0;
1981
1982     return 1;
1983 }
1984
1985 static void do_streamcopy(InputStream *ist, OutputStream *ost, const AVPacket *pkt)
1986 {
1987     OutputFile *of = output_files[ost->file_index];
1988     InputFile   *f = input_files [ist->file_index];
1989     int64_t start_time = (of->start_time == AV_NOPTS_VALUE) ? 0 : of->start_time;
1990     int64_t ost_tb_start_time = av_rescale_q(start_time, AV_TIME_BASE_Q, ost->mux_timebase);
1991     AVPacket opkt = { 0 };
1992
1993     av_init_packet(&opkt);
1994
1995     // EOF: flush output bitstream filters.
1996     if (!pkt) {
1997         output_packet(of, &opkt, ost, 1);
1998         return;
1999     }
2000
2001     if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) &&
2002         !ost->copy_initial_nonkeyframes)
2003         return;
2004
2005     if (!ost->frame_number && !ost->copy_prior_start) {
2006         int64_t comp_start = start_time;
2007         if (copy_ts && f->start_time != AV_NOPTS_VALUE)
2008             comp_start = FFMAX(start_time, f->start_time + f->ts_offset);
2009         if (pkt->pts == AV_NOPTS_VALUE ?
2010             ist->pts < comp_start :
2011             pkt->pts < av_rescale_q(comp_start, AV_TIME_BASE_Q, ist->st->time_base))
2012             return;
2013     }
2014
2015     if (of->recording_time != INT64_MAX &&
2016         ist->pts >= of->recording_time + start_time) {
2017         close_output_stream(ost);
2018         return;
2019     }
2020
2021     if (f->recording_time != INT64_MAX) {
2022         start_time = f->ctx->start_time;
2023         if (f->start_time != AV_NOPTS_VALUE && copy_ts)
2024             start_time += f->start_time;
2025         if (ist->pts >= f->recording_time + start_time) {
2026             close_output_stream(ost);
2027             return;
2028         }
2029     }
2030
2031     /* force the input stream PTS */
2032     if (ost->enc_ctx->codec_type == AVMEDIA_TYPE_VIDEO)
2033         ost->sync_opts++;
2034
2035     if (pkt->pts != AV_NOPTS_VALUE)
2036         opkt.pts = av_rescale_q(pkt->pts, ist->st->time_base, ost->mux_timebase) - ost_tb_start_time;
2037     else
2038         opkt.pts = AV_NOPTS_VALUE;
2039
2040     if (pkt->dts == AV_NOPTS_VALUE)
2041         opkt.dts = av_rescale_q(ist->dts, AV_TIME_BASE_Q, ost->mux_timebase);
2042     else
2043         opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->mux_timebase);
2044     opkt.dts -= ost_tb_start_time;
2045
2046     if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && pkt->dts != AV_NOPTS_VALUE) {
2047         int duration = av_get_audio_frame_duration(ist->dec_ctx, pkt->size);
2048         if(!duration)
2049             duration = ist->dec_ctx->frame_size;
2050         opkt.dts = opkt.pts = av_rescale_delta(ist->st->time_base, pkt->dts,
2051                                                (AVRational){1, ist->dec_ctx->sample_rate}, duration, &ist->filter_in_rescale_delta_last,
2052                                                ost->mux_timebase) - ost_tb_start_time;
2053     }
2054
2055     opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->mux_timebase);
2056
2057     opkt.flags    = pkt->flags;
2058     // FIXME remove the following 2 lines they shall be replaced by the bitstream filters
2059     if (  ost->st->codecpar->codec_id != AV_CODEC_ID_H264
2060        && ost->st->codecpar->codec_id != AV_CODEC_ID_MPEG1VIDEO
2061        && ost->st->codecpar->codec_id != AV_CODEC_ID_MPEG2VIDEO
2062        && ost->st->codecpar->codec_id != AV_CODEC_ID_VC1
2063        ) {
2064         int ret = av_parser_change(ost->parser, ost->parser_avctx,
2065                              &opkt.data, &opkt.size,
2066                              pkt->data, pkt->size,
2067                              pkt->flags & AV_PKT_FLAG_KEY);
2068         if (ret < 0) {
2069             av_log(NULL, AV_LOG_FATAL, "av_parser_change failed: %s\n",
2070                    av_err2str(ret));
2071             exit_program(1);
2072         }
2073         if (ret) {
2074             opkt.buf = av_buffer_create(opkt.data, opkt.size, av_buffer_default_free, NULL, 0);
2075             if (!opkt.buf)
2076                 exit_program(1);
2077         }
2078     } else {
2079         opkt.data = pkt->data;
2080         opkt.size = pkt->size;
2081     }
2082     av_copy_packet_side_data(&opkt, pkt);
2083
2084     output_packet(of, &opkt, ost, 0);
2085 }
2086
2087 int guess_input_channel_layout(InputStream *ist)
2088 {
2089     AVCodecContext *dec = ist->dec_ctx;
2090
2091     if (!dec->channel_layout) {
2092         char layout_name[256];
2093
2094         if (dec->channels > ist->guess_layout_max)
2095             return 0;
2096         dec->channel_layout = av_get_default_channel_layout(dec->channels);
2097         if (!dec->channel_layout)
2098             return 0;
2099         av_get_channel_layout_string(layout_name, sizeof(layout_name),
2100                                      dec->channels, dec->channel_layout);
2101         av_log(NULL, AV_LOG_WARNING, "Guessed Channel Layout for Input Stream "
2102                "#%d.%d : %s\n", ist->file_index, ist->st->index, layout_name);
2103     }
2104     return 1;
2105 }
2106
2107 static void check_decode_result(InputStream *ist, int *got_output, int ret)
2108 {
2109     if (*got_output || ret<0)
2110         decode_error_stat[ret<0] ++;
2111
2112     if (ret < 0 && exit_on_error)
2113         exit_program(1);
2114
2115     if (exit_on_error && *got_output && ist) {
2116         if (ist->decoded_frame->decode_error_flags || (ist->decoded_frame->flags & AV_FRAME_FLAG_CORRUPT)) {
2117             av_log(NULL, AV_LOG_FATAL, "%s: corrupt decoded frame in stream %d\n", input_files[ist->file_index]->ctx->url, ist->st->index);
2118             exit_program(1);
2119         }
2120     }
2121 }
2122
2123 // Filters can be configured only if the formats of all inputs are known.
2124 static int ifilter_has_all_input_formats(FilterGraph *fg)
2125 {
2126     int i;
2127     for (i = 0; i < fg->nb_inputs; i++) {
2128         if (fg->inputs[i]->format < 0 && (fg->inputs[i]->type == AVMEDIA_TYPE_AUDIO ||
2129                                           fg->inputs[i]->type == AVMEDIA_TYPE_VIDEO))
2130             return 0;
2131     }
2132     return 1;
2133 }
2134
2135 static int ifilter_send_frame(InputFilter *ifilter, AVFrame *frame)
2136 {
2137     FilterGraph *fg = ifilter->graph;
2138     int need_reinit, ret, i;
2139
2140     /* determine if the parameters for this input changed */
2141     need_reinit = ifilter->format != frame->format;
2142     if (!!ifilter->hw_frames_ctx != !!frame->hw_frames_ctx ||
2143         (ifilter->hw_frames_ctx && ifilter->hw_frames_ctx->data != frame->hw_frames_ctx->data))
2144         need_reinit = 1;
2145
2146     switch (ifilter->ist->st->codecpar->codec_type) {
2147     case AVMEDIA_TYPE_AUDIO:
2148         need_reinit |= ifilter->sample_rate    != frame->sample_rate ||
2149                        ifilter->channels       != frame->channels ||
2150                        ifilter->channel_layout != frame->channel_layout;
2151         break;
2152     case AVMEDIA_TYPE_VIDEO:
2153         need_reinit |= ifilter->width  != frame->width ||
2154                        ifilter->height != frame->height;
2155         break;
2156     }
2157
2158     if (need_reinit) {
2159         ret = ifilter_parameters_from_frame(ifilter, frame);
2160         if (ret < 0)
2161             return ret;
2162     }
2163
2164     /* (re)init the graph if possible, otherwise buffer the frame and return */
2165     if (need_reinit || !fg->graph) {
2166         for (i = 0; i < fg->nb_inputs; i++) {
2167             if (!ifilter_has_all_input_formats(fg)) {
2168                 AVFrame *tmp = av_frame_clone(frame);
2169                 if (!tmp)
2170                     return AVERROR(ENOMEM);
2171                 av_frame_unref(frame);
2172
2173                 if (!av_fifo_space(ifilter->frame_queue)) {
2174                     ret = av_fifo_realloc2(ifilter->frame_queue, 2 * av_fifo_size(ifilter->frame_queue));
2175                     if (ret < 0) {
2176                         av_frame_free(&tmp);
2177                         return ret;
2178                     }
2179                 }
2180                 av_fifo_generic_write(ifilter->frame_queue, &tmp, sizeof(tmp), NULL);
2181                 return 0;
2182             }
2183         }
2184
2185         ret = reap_filters(1);
2186         if (ret < 0 && ret != AVERROR_EOF) {
2187             av_log(NULL, AV_LOG_ERROR, "Error while filtering: %s\n", av_err2str(ret));
2188             return ret;
2189         }
2190
2191         ret = configure_filtergraph(fg);
2192         if (ret < 0) {
2193             av_log(NULL, AV_LOG_ERROR, "Error reinitializing filters!\n");
2194             return ret;
2195         }
2196     }
2197
2198     ret = av_buffersrc_add_frame_flags(ifilter->filter, frame, AV_BUFFERSRC_FLAG_PUSH);
2199     if (ret < 0) {
2200         if (ret != AVERROR_EOF)
2201             av_log(NULL, AV_LOG_ERROR, "Error while filtering: %s\n", av_err2str(ret));
2202         return ret;
2203     }
2204
2205     return 0;
2206 }
2207
2208 static int ifilter_send_eof(InputFilter *ifilter, int64_t pts)
2209 {
2210     int i, j, ret;
2211
2212     ifilter->eof = 1;
2213
2214     if (ifilter->filter) {
2215         ret = av_buffersrc_close(ifilter->filter, pts, AV_BUFFERSRC_FLAG_PUSH);
2216         if (ret < 0)
2217             return ret;
2218     } else {
2219         // the filtergraph was never configured
2220         FilterGraph *fg = ifilter->graph;
2221         for (i = 0; i < fg->nb_inputs; i++)
2222             if (!fg->inputs[i]->eof)
2223                 break;
2224         if (i == fg->nb_inputs) {
2225             // All the input streams have finished without the filtergraph
2226             // ever being configured.
2227             // Mark the output streams as finished.
2228             for (j = 0; j < fg->nb_outputs; j++)
2229                 finish_output_stream(fg->outputs[j]->ost);
2230         }
2231     }
2232
2233     return 0;
2234 }
2235
2236 // This does not quite work like avcodec_decode_audio4/avcodec_decode_video2.
2237 // There is the following difference: if you got a frame, you must call
2238 // it again with pkt=NULL. pkt==NULL is treated differently from pkt->size==0
2239 // (pkt==NULL means get more output, pkt->size==0 is a flush/drain packet)
2240 static int decode(AVCodecContext *avctx, AVFrame *frame, int *got_frame, AVPacket *pkt)
2241 {
2242     int ret;
2243
2244     *got_frame = 0;
2245
2246     if (pkt) {
2247         ret = avcodec_send_packet(avctx, pkt);
2248         // In particular, we don't expect AVERROR(EAGAIN), because we read all
2249         // decoded frames with avcodec_receive_frame() until done.
2250         if (ret < 0 && ret != AVERROR_EOF)
2251             return ret;
2252     }
2253
2254     ret = avcodec_receive_frame(avctx, frame);
2255     if (ret < 0 && ret != AVERROR(EAGAIN))
2256         return ret;
2257     if (ret >= 0)
2258         *got_frame = 1;
2259
2260     return 0;
2261 }
2262
2263 static int send_frame_to_filters(InputStream *ist, AVFrame *decoded_frame)
2264 {
2265     int i, ret;
2266     AVFrame *f;
2267
2268     av_assert1(ist->nb_filters > 0); /* ensure ret is initialized */
2269     for (i = 0; i < ist->nb_filters; i++) {
2270         if (i < ist->nb_filters - 1) {
2271             f = ist->filter_frame;
2272             ret = av_frame_ref(f, decoded_frame);
2273             if (ret < 0)
2274                 break;
2275         } else
2276             f = decoded_frame;
2277         ret = ifilter_send_frame(ist->filters[i], f);
2278         if (ret == AVERROR_EOF)
2279             ret = 0; /* ignore */
2280         if (ret < 0) {
2281             av_log(NULL, AV_LOG_ERROR,
2282                    "Failed to inject frame into filter network: %s\n", av_err2str(ret));
2283             break;
2284         }
2285     }
2286     return ret;
2287 }
2288
2289 static int decode_audio(InputStream *ist, AVPacket *pkt, int *got_output,
2290                         int *decode_failed)
2291 {
2292     AVFrame *decoded_frame;
2293     AVCodecContext *avctx = ist->dec_ctx;
2294     int ret, err = 0;
2295     AVRational decoded_frame_tb;
2296
2297     if (!ist->decoded_frame && !(ist->decoded_frame = av_frame_alloc()))
2298         return AVERROR(ENOMEM);
2299     if (!ist->filter_frame && !(ist->filter_frame = av_frame_alloc()))
2300         return AVERROR(ENOMEM);
2301     decoded_frame = ist->decoded_frame;
2302
2303     update_benchmark(NULL);
2304     ret = decode(avctx, decoded_frame, got_output, pkt);
2305     update_benchmark("decode_audio %d.%d", ist->file_index, ist->st->index);
2306     if (ret < 0)
2307         *decode_failed = 1;
2308
2309     if (ret >= 0 && avctx->sample_rate <= 0) {
2310         av_log(avctx, AV_LOG_ERROR, "Sample rate %d invalid\n", avctx->sample_rate);
2311         ret = AVERROR_INVALIDDATA;
2312     }
2313
2314     if (ret != AVERROR_EOF)
2315         check_decode_result(ist, got_output, ret);
2316
2317     if (!*got_output || ret < 0)
2318         return ret;
2319
2320     ist->samples_decoded += decoded_frame->nb_samples;
2321     ist->frames_decoded++;
2322
2323 #if 1
2324     /* increment next_dts to use for the case where the input stream does not
2325        have timestamps or there are multiple frames in the packet */
2326     ist->next_pts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /
2327                      avctx->sample_rate;
2328     ist->next_dts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /
2329                      avctx->sample_rate;
2330 #endif
2331
2332     if (decoded_frame->pts != AV_NOPTS_VALUE) {
2333         decoded_frame_tb   = ist->st->time_base;
2334     } else if (pkt && pkt->pts != AV_NOPTS_VALUE) {
2335         decoded_frame->pts = pkt->pts;
2336         decoded_frame_tb   = ist->st->time_base;
2337     }else {
2338         decoded_frame->pts = ist->dts;
2339         decoded_frame_tb   = AV_TIME_BASE_Q;
2340     }
2341     if (decoded_frame->pts != AV_NOPTS_VALUE)
2342         decoded_frame->pts = av_rescale_delta(decoded_frame_tb, decoded_frame->pts,
2343                                               (AVRational){1, avctx->sample_rate}, decoded_frame->nb_samples, &ist->filter_in_rescale_delta_last,
2344                                               (AVRational){1, avctx->sample_rate});
2345     ist->nb_samples = decoded_frame->nb_samples;
2346     err = send_frame_to_filters(ist, decoded_frame);
2347
2348     av_frame_unref(ist->filter_frame);
2349     av_frame_unref(decoded_frame);
2350     return err < 0 ? err : ret;
2351 }
2352
2353 static int decode_video(InputStream *ist, AVPacket *pkt, int *got_output, int64_t *duration_pts, int eof,
2354                         int *decode_failed)
2355 {
2356     AVFrame *decoded_frame;
2357     int i, ret = 0, err = 0;
2358     int64_t best_effort_timestamp;
2359     int64_t dts = AV_NOPTS_VALUE;
2360     AVPacket avpkt;
2361
2362     // With fate-indeo3-2, we're getting 0-sized packets before EOF for some
2363     // reason. This seems like a semi-critical bug. Don't trigger EOF, and
2364     // skip the packet.
2365     if (!eof && pkt && pkt->size == 0)
2366         return 0;
2367
2368     if (!ist->decoded_frame && !(ist->decoded_frame = av_frame_alloc()))
2369         return AVERROR(ENOMEM);
2370     if (!ist->filter_frame && !(ist->filter_frame = av_frame_alloc()))
2371         return AVERROR(ENOMEM);
2372     decoded_frame = ist->decoded_frame;
2373     if (ist->dts != AV_NOPTS_VALUE)
2374         dts = av_rescale_q(ist->dts, AV_TIME_BASE_Q, ist->st->time_base);
2375     if (pkt) {
2376         avpkt = *pkt;
2377         avpkt.dts = dts; // ffmpeg.c probably shouldn't do this
2378     }
2379
2380     // The old code used to set dts on the drain packet, which does not work
2381     // with the new API anymore.
2382     if (eof) {
2383         void *new = av_realloc_array(ist->dts_buffer, ist->nb_dts_buffer + 1, sizeof(ist->dts_buffer[0]));
2384         if (!new)
2385             return AVERROR(ENOMEM);
2386         ist->dts_buffer = new;
2387         ist->dts_buffer[ist->nb_dts_buffer++] = dts;
2388     }
2389
2390     update_benchmark(NULL);
2391     ret = decode(ist->dec_ctx, decoded_frame, got_output, pkt ? &avpkt : NULL);
2392     update_benchmark("decode_video %d.%d", ist->file_index, ist->st->index);
2393     if (ret < 0)
2394         *decode_failed = 1;
2395
2396     // The following line may be required in some cases where there is no parser
2397     // or the parser does not has_b_frames correctly
2398     if (ist->st->codecpar->video_delay < ist->dec_ctx->has_b_frames) {
2399         if (ist->dec_ctx->codec_id == AV_CODEC_ID_H264) {
2400             ist->st->codecpar->video_delay = ist->dec_ctx->has_b_frames;
2401         } else
2402             av_log(ist->dec_ctx, AV_LOG_WARNING,
2403                    "video_delay is larger in decoder than demuxer %d > %d.\n"
2404                    "If you want to help, upload a sample "
2405                    "of this file to ftp://upload.ffmpeg.org/incoming/ "
2406                    "and contact the ffmpeg-devel mailing list. (ffmpeg-devel@ffmpeg.org)\n",
2407                    ist->dec_ctx->has_b_frames,
2408                    ist->st->codecpar->video_delay);
2409     }
2410
2411     if (ret != AVERROR_EOF)
2412         check_decode_result(ist, got_output, ret);
2413
2414     if (*got_output && ret >= 0) {
2415         if (ist->dec_ctx->width  != decoded_frame->width ||
2416             ist->dec_ctx->height != decoded_frame->height ||
2417             ist->dec_ctx->pix_fmt != decoded_frame->format) {
2418             av_log(NULL, AV_LOG_DEBUG, "Frame parameters mismatch context %d,%d,%d != %d,%d,%d\n",
2419                 decoded_frame->width,
2420                 decoded_frame->height,
2421                 decoded_frame->format,
2422                 ist->dec_ctx->width,
2423                 ist->dec_ctx->height,
2424                 ist->dec_ctx->pix_fmt);
2425         }
2426     }
2427
2428     if (!*got_output || ret < 0)
2429         return ret;
2430
2431     if(ist->top_field_first>=0)
2432         decoded_frame->top_field_first = ist->top_field_first;
2433
2434     ist->frames_decoded++;
2435
2436     if (ist->hwaccel_retrieve_data && decoded_frame->format == ist->hwaccel_pix_fmt) {
2437         err = ist->hwaccel_retrieve_data(ist->dec_ctx, decoded_frame);
2438         if (err < 0)
2439             goto fail;
2440     }
2441     ist->hwaccel_retrieved_pix_fmt = decoded_frame->format;
2442
2443     best_effort_timestamp= decoded_frame->best_effort_timestamp;
2444     *duration_pts = decoded_frame->pkt_duration;
2445
2446     if (ist->framerate.num)
2447         best_effort_timestamp = ist->cfr_next_pts++;
2448
2449     if (eof && best_effort_timestamp == AV_NOPTS_VALUE && ist->nb_dts_buffer > 0) {
2450         best_effort_timestamp = ist->dts_buffer[0];
2451
2452         for (i = 0; i < ist->nb_dts_buffer - 1; i++)
2453             ist->dts_buffer[i] = ist->dts_buffer[i + 1];
2454         ist->nb_dts_buffer--;
2455     }
2456
2457     if(best_effort_timestamp != AV_NOPTS_VALUE) {
2458         int64_t ts = av_rescale_q(decoded_frame->pts = best_effort_timestamp, ist->st->time_base, AV_TIME_BASE_Q);
2459
2460         if (ts != AV_NOPTS_VALUE)
2461             ist->next_pts = ist->pts = ts;
2462     }
2463
2464     if (debug_ts) {
2465         av_log(NULL, AV_LOG_INFO, "decoder -> ist_index:%d type:video "
2466                "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",
2467                ist->st->index, av_ts2str(decoded_frame->pts),
2468                av_ts2timestr(decoded_frame->pts, &ist->st->time_base),
2469                best_effort_timestamp,
2470                av_ts2timestr(best_effort_timestamp, &ist->st->time_base),
2471                decoded_frame->key_frame, decoded_frame->pict_type,
2472                ist->st->time_base.num, ist->st->time_base.den);
2473     }
2474
2475     if (ist->st->sample_aspect_ratio.num)
2476         decoded_frame->sample_aspect_ratio = ist->st->sample_aspect_ratio;
2477
2478     err = send_frame_to_filters(ist, decoded_frame);
2479
2480 fail:
2481     av_frame_unref(ist->filter_frame);
2482     av_frame_unref(decoded_frame);
2483     return err < 0 ? err : ret;
2484 }
2485
2486 static int transcode_subtitles(InputStream *ist, AVPacket *pkt, int *got_output,
2487                                int *decode_failed)
2488 {
2489     AVSubtitle subtitle;
2490     int free_sub = 1;
2491     int i, ret = avcodec_decode_subtitle2(ist->dec_ctx,
2492                                           &subtitle, got_output, pkt);
2493
2494     check_decode_result(NULL, got_output, ret);
2495
2496     if (ret < 0 || !*got_output) {
2497         *decode_failed = 1;
2498         if (!pkt->size)
2499             sub2video_flush(ist);
2500         return ret;
2501     }
2502
2503     if (ist->fix_sub_duration) {
2504         int end = 1;
2505         if (ist->prev_sub.got_output) {
2506             end = av_rescale(subtitle.pts - ist->prev_sub.subtitle.pts,
2507                              1000, AV_TIME_BASE);
2508             if (end < ist->prev_sub.subtitle.end_display_time) {
2509                 av_log(ist->dec_ctx, AV_LOG_DEBUG,
2510                        "Subtitle duration reduced from %"PRId32" to %d%s\n",
2511                        ist->prev_sub.subtitle.end_display_time, end,
2512                        end <= 0 ? ", dropping it" : "");
2513                 ist->prev_sub.subtitle.end_display_time = end;
2514             }
2515         }
2516         FFSWAP(int,        *got_output, ist->prev_sub.got_output);
2517         FFSWAP(int,        ret,         ist->prev_sub.ret);
2518         FFSWAP(AVSubtitle, subtitle,    ist->prev_sub.subtitle);
2519         if (end <= 0)
2520             goto out;
2521     }
2522
2523     if (!*got_output)
2524         return ret;
2525
2526     if (ist->sub2video.frame) {
2527         sub2video_update(ist, &subtitle);
2528     } else if (ist->nb_filters) {
2529         if (!ist->sub2video.sub_queue)
2530             ist->sub2video.sub_queue = av_fifo_alloc(8 * sizeof(AVSubtitle));
2531         if (!ist->sub2video.sub_queue)
2532             exit_program(1);
2533         if (!av_fifo_space(ist->sub2video.sub_queue)) {
2534             ret = av_fifo_realloc2(ist->sub2video.sub_queue, 2 * av_fifo_size(ist->sub2video.sub_queue));
2535             if (ret < 0)
2536                 exit_program(1);
2537         }
2538         av_fifo_generic_write(ist->sub2video.sub_queue, &subtitle, sizeof(subtitle), NULL);
2539         free_sub = 0;
2540     }
2541
2542     if (!subtitle.num_rects)
2543         goto out;
2544
2545     ist->frames_decoded++;
2546
2547     for (i = 0; i < nb_output_streams; i++) {
2548         OutputStream *ost = output_streams[i];
2549
2550         if (!check_output_constraints(ist, ost) || !ost->encoding_needed
2551             || ost->enc->type != AVMEDIA_TYPE_SUBTITLE)
2552             continue;
2553
2554         do_subtitle_out(output_files[ost->file_index], ost, &subtitle);
2555     }
2556
2557 out:
2558     if (free_sub)
2559         avsubtitle_free(&subtitle);
2560     return ret;
2561 }
2562
2563 static int send_filter_eof(InputStream *ist)
2564 {
2565     int i, ret;
2566     /* TODO keep pts also in stream time base to avoid converting back */
2567     int64_t pts = av_rescale_q_rnd(ist->pts, AV_TIME_BASE_Q, ist->st->time_base,
2568                                    AV_ROUND_NEAR_INF | AV_ROUND_PASS_MINMAX);
2569
2570     for (i = 0; i < ist->nb_filters; i++) {
2571         ret = ifilter_send_eof(ist->filters[i], pts);
2572         if (ret < 0)
2573             return ret;
2574     }
2575     return 0;
2576 }
2577
2578 /* pkt = NULL means EOF (needed to flush decoder buffers) */
2579 static int process_input_packet(InputStream *ist, const AVPacket *pkt, int no_eof)
2580 {
2581     int ret = 0, i;
2582     int repeating = 0;
2583     int eof_reached = 0;
2584
2585     AVPacket avpkt;
2586     if (!ist->saw_first_ts) {
2587         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;
2588         ist->pts = 0;
2589         if (pkt && pkt->pts != AV_NOPTS_VALUE && !ist->decoding_needed) {
2590             ist->dts += av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
2591             ist->pts = ist->dts; //unused but better to set it to a value thats not totally wrong
2592         }
2593         ist->saw_first_ts = 1;
2594     }
2595
2596     if (ist->next_dts == AV_NOPTS_VALUE)
2597         ist->next_dts = ist->dts;
2598     if (ist->next_pts == AV_NOPTS_VALUE)
2599         ist->next_pts = ist->pts;
2600
2601     if (!pkt) {
2602         /* EOF handling */
2603         av_init_packet(&avpkt);
2604         avpkt.data = NULL;
2605         avpkt.size = 0;
2606     } else {
2607         avpkt = *pkt;
2608     }
2609
2610     if (pkt && pkt->dts != AV_NOPTS_VALUE) {
2611         ist->next_dts = ist->dts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
2612         if (ist->dec_ctx->codec_type != AVMEDIA_TYPE_VIDEO || !ist->decoding_needed)
2613             ist->next_pts = ist->pts = ist->dts;
2614     }
2615
2616     // while we have more to decode or while the decoder did output something on EOF
2617     while (ist->decoding_needed) {
2618         int64_t duration_dts = 0;
2619         int64_t duration_pts = 0;
2620         int got_output = 0;
2621         int decode_failed = 0;
2622
2623         ist->pts = ist->next_pts;
2624         ist->dts = ist->next_dts;
2625
2626         switch (ist->dec_ctx->codec_type) {
2627         case AVMEDIA_TYPE_AUDIO:
2628             ret = decode_audio    (ist, repeating ? NULL : &avpkt, &got_output,
2629                                    &decode_failed);
2630             break;
2631         case AVMEDIA_TYPE_VIDEO:
2632             ret = decode_video    (ist, repeating ? NULL : &avpkt, &got_output, &duration_pts, !pkt,
2633                                    &decode_failed);
2634             if (!repeating || !pkt || got_output) {
2635                 if (pkt && pkt->duration) {
2636                     duration_dts = av_rescale_q(pkt->duration, ist->st->time_base, AV_TIME_BASE_Q);
2637                 } else if(ist->dec_ctx->framerate.num != 0 && ist->dec_ctx->framerate.den != 0) {
2638                     int ticks= av_stream_get_parser(ist->st) ? av_stream_get_parser(ist->st)->repeat_pict+1 : ist->dec_ctx->ticks_per_frame;
2639                     duration_dts = ((int64_t)AV_TIME_BASE *
2640                                     ist->dec_ctx->framerate.den * ticks) /
2641                                     ist->dec_ctx->framerate.num / ist->dec_ctx->ticks_per_frame;
2642                 }
2643
2644                 if(ist->dts != AV_NOPTS_VALUE && duration_dts) {
2645                     ist->next_dts += duration_dts;
2646                 }else
2647                     ist->next_dts = AV_NOPTS_VALUE;
2648             }
2649
2650             if (got_output) {
2651                 if (duration_pts > 0) {
2652                     ist->next_pts += av_rescale_q(duration_pts, ist->st->time_base, AV_TIME_BASE_Q);
2653                 } else {
2654                     ist->next_pts += duration_dts;
2655                 }
2656             }
2657             break;
2658         case AVMEDIA_TYPE_SUBTITLE:
2659             if (repeating)
2660                 break;
2661             ret = transcode_subtitles(ist, &avpkt, &got_output, &decode_failed);
2662             if (!pkt && ret >= 0)
2663                 ret = AVERROR_EOF;
2664             break;
2665         default:
2666             return -1;
2667         }
2668
2669         if (ret == AVERROR_EOF) {
2670             eof_reached = 1;
2671             break;
2672         }
2673
2674         if (ret < 0) {
2675             if (decode_failed) {
2676                 av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d:%d: %s\n",
2677                        ist->file_index, ist->st->index, av_err2str(ret));
2678             } else {
2679                 av_log(NULL, AV_LOG_FATAL, "Error while processing the decoded "
2680                        "data for stream #%d:%d\n", ist->file_index, ist->st->index);
2681             }
2682             if (!decode_failed || exit_on_error)
2683                 exit_program(1);
2684             break;
2685         }
2686
2687         if (got_output)
2688             ist->got_output = 1;
2689
2690         if (!got_output)
2691             break;
2692
2693         // During draining, we might get multiple output frames in this loop.
2694         // ffmpeg.c does not drain the filter chain on configuration changes,
2695         // which means if we send multiple frames at once to the filters, and
2696         // one of those frames changes configuration, the buffered frames will
2697         // be lost. This can upset certain FATE tests.
2698         // Decode only 1 frame per call on EOF to appease these FATE tests.
2699         // The ideal solution would be to rewrite decoding to use the new
2700         // decoding API in a better way.
2701         if (!pkt)
2702             break;
2703
2704         repeating = 1;
2705     }
2706
2707     /* after flushing, send an EOF on all the filter inputs attached to the stream */
2708     /* except when looping we need to flush but not to send an EOF */
2709     if (!pkt && ist->decoding_needed && eof_reached && !no_eof) {
2710         int ret = send_filter_eof(ist);
2711         if (ret < 0) {
2712             av_log(NULL, AV_LOG_FATAL, "Error marking filters as finished\n");
2713             exit_program(1);
2714         }
2715     }
2716
2717     /* handle stream copy */
2718     if (!ist->decoding_needed && pkt) {
2719         ist->dts = ist->next_dts;
2720         switch (ist->dec_ctx->codec_type) {
2721         case AVMEDIA_TYPE_AUDIO:
2722             ist->next_dts += ((int64_t)AV_TIME_BASE * ist->dec_ctx->frame_size) /
2723                              ist->dec_ctx->sample_rate;
2724             break;
2725         case AVMEDIA_TYPE_VIDEO:
2726             if (ist->framerate.num) {
2727                 // TODO: Remove work-around for c99-to-c89 issue 7
2728                 AVRational time_base_q = AV_TIME_BASE_Q;
2729                 int64_t next_dts = av_rescale_q(ist->next_dts, time_base_q, av_inv_q(ist->framerate));
2730                 ist->next_dts = av_rescale_q(next_dts + 1, av_inv_q(ist->framerate), time_base_q);
2731             } else if (pkt->duration) {
2732                 ist->next_dts += av_rescale_q(pkt->duration, ist->st->time_base, AV_TIME_BASE_Q);
2733             } else if(ist->dec_ctx->framerate.num != 0) {
2734                 int ticks= av_stream_get_parser(ist->st) ? av_stream_get_parser(ist->st)->repeat_pict + 1 : ist->dec_ctx->ticks_per_frame;
2735                 ist->next_dts += ((int64_t)AV_TIME_BASE *
2736                                   ist->dec_ctx->framerate.den * ticks) /
2737                                   ist->dec_ctx->framerate.num / ist->dec_ctx->ticks_per_frame;
2738             }
2739             break;
2740         }
2741         ist->pts = ist->dts;
2742         ist->next_pts = ist->next_dts;
2743     }
2744     for (i = 0; i < nb_output_streams; i++) {
2745         OutputStream *ost = output_streams[i];
2746
2747         if (!check_output_constraints(ist, ost) || ost->encoding_needed)
2748             continue;
2749
2750         do_streamcopy(ist, ost, pkt);
2751     }
2752
2753     return !eof_reached;
2754 }
2755
2756 static void print_sdp(void)
2757 {
2758     char sdp[16384];
2759     int i;
2760     int j;
2761     AVIOContext *sdp_pb;
2762     AVFormatContext **avc;
2763
2764     for (i = 0; i < nb_output_files; i++) {
2765         if (!output_files[i]->header_written)
2766             return;
2767     }
2768
2769     avc = av_malloc_array(nb_output_files, sizeof(*avc));
2770     if (!avc)
2771         exit_program(1);
2772     for (i = 0, j = 0; i < nb_output_files; i++) {
2773         if (!strcmp(output_files[i]->ctx->oformat->name, "rtp")) {
2774             avc[j] = output_files[i]->ctx;
2775             j++;
2776         }
2777     }
2778
2779     if (!j)
2780         goto fail;
2781
2782     av_sdp_create(avc, j, sdp, sizeof(sdp));
2783
2784     if (!sdp_filename) {
2785         printf("SDP:\n%s\n", sdp);
2786         fflush(stdout);
2787     } else {
2788         if (avio_open2(&sdp_pb, sdp_filename, AVIO_FLAG_WRITE, &int_cb, NULL) < 0) {
2789             av_log(NULL, AV_LOG_ERROR, "Failed to open sdp file '%s'\n", sdp_filename);
2790         } else {
2791             avio_printf(sdp_pb, "SDP:\n%s", sdp);
2792             avio_closep(&sdp_pb);
2793             av_freep(&sdp_filename);
2794         }
2795     }
2796
2797 fail:
2798     av_freep(&avc);
2799 }
2800
2801 static enum AVPixelFormat get_format(AVCodecContext *s, const enum AVPixelFormat *pix_fmts)
2802 {
2803     InputStream *ist = s->opaque;
2804     const enum AVPixelFormat *p;
2805     int ret;
2806
2807     for (p = pix_fmts; *p != AV_PIX_FMT_NONE; p++) {
2808         const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(*p);
2809         const AVCodecHWConfig  *config = NULL;
2810         int i;
2811
2812         if (!(desc->flags & AV_PIX_FMT_FLAG_HWACCEL))
2813             break;
2814
2815         if (ist->hwaccel_id == HWACCEL_GENERIC ||
2816             ist->hwaccel_id == HWACCEL_AUTO) {
2817             for (i = 0;; i++) {
2818                 config = avcodec_get_hw_config(s->codec, i);
2819                 if (!config)
2820                     break;
2821                 if (!(config->methods &
2822                       AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX))
2823                     continue;
2824                 if (config->pix_fmt == *p)
2825                     break;
2826             }
2827         }
2828         if (config) {
2829             if (config->device_type != ist->hwaccel_device_type) {
2830                 // Different hwaccel offered, ignore.
2831                 continue;
2832             }
2833
2834             ret = hwaccel_decode_init(s);
2835             if (ret < 0) {
2836                 if (ist->hwaccel_id == HWACCEL_GENERIC) {
2837                     av_log(NULL, AV_LOG_FATAL,
2838                            "%s hwaccel requested for input stream #%d:%d, "
2839                            "but cannot be initialized.\n",
2840                            av_hwdevice_get_type_name(config->device_type),
2841                            ist->file_index, ist->st->index);
2842                     return AV_PIX_FMT_NONE;
2843                 }
2844                 continue;
2845             }
2846         } else {
2847             const HWAccel *hwaccel = NULL;
2848             int i;
2849             for (i = 0; hwaccels[i].name; i++) {
2850                 if (hwaccels[i].pix_fmt == *p) {
2851                     hwaccel = &hwaccels[i];
2852                     break;
2853                 }
2854             }
2855             if (!hwaccel) {
2856                 // No hwaccel supporting this pixfmt.
2857                 continue;
2858             }
2859             if (hwaccel->id != ist->hwaccel_id) {
2860                 // Does not match requested hwaccel.
2861                 continue;
2862             }
2863
2864             ret = hwaccel->init(s);
2865             if (ret < 0) {
2866                 av_log(NULL, AV_LOG_FATAL,
2867                        "%s hwaccel requested for input stream #%d:%d, "
2868                        "but cannot be initialized.\n", hwaccel->name,
2869                        ist->file_index, ist->st->index);
2870                 return AV_PIX_FMT_NONE;
2871             }
2872         }
2873
2874         if (ist->hw_frames_ctx) {
2875             s->hw_frames_ctx = av_buffer_ref(ist->hw_frames_ctx);
2876             if (!s->hw_frames_ctx)
2877                 return AV_PIX_FMT_NONE;
2878         }
2879
2880         ist->hwaccel_pix_fmt = *p;
2881         break;
2882     }
2883
2884     return *p;
2885 }
2886
2887 static int get_buffer(AVCodecContext *s, AVFrame *frame, int flags)
2888 {
2889     InputStream *ist = s->opaque;
2890
2891     if (ist->hwaccel_get_buffer && frame->format == ist->hwaccel_pix_fmt)
2892         return ist->hwaccel_get_buffer(s, frame, flags);
2893
2894     return avcodec_default_get_buffer2(s, frame, flags);
2895 }
2896
2897 static int init_input_stream(int ist_index, char *error, int error_len)
2898 {
2899     int ret;
2900     InputStream *ist = input_streams[ist_index];
2901
2902     if (ist->decoding_needed) {
2903         AVCodec *codec = ist->dec;
2904         if (!codec) {
2905             snprintf(error, error_len, "Decoder (codec %s) not found for input stream #%d:%d",
2906                     avcodec_get_name(ist->dec_ctx->codec_id), ist->file_index, ist->st->index);
2907             return AVERROR(EINVAL);
2908         }
2909
2910         ist->dec_ctx->opaque                = ist;
2911         ist->dec_ctx->get_format            = get_format;
2912         ist->dec_ctx->get_buffer2           = get_buffer;
2913         ist->dec_ctx->thread_safe_callbacks = 1;
2914
2915         av_opt_set_int(ist->dec_ctx, "refcounted_frames", 1, 0);
2916         if (ist->dec_ctx->codec_id == AV_CODEC_ID_DVB_SUBTITLE &&
2917            (ist->decoding_needed & DECODING_FOR_OST)) {
2918             av_dict_set(&ist->decoder_opts, "compute_edt", "1", AV_DICT_DONT_OVERWRITE);
2919             if (ist->decoding_needed & DECODING_FOR_FILTER)
2920                 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");
2921         }
2922
2923         av_dict_set(&ist->decoder_opts, "sub_text_format", "ass", AV_DICT_DONT_OVERWRITE);
2924
2925         /* Useful for subtitles retiming by lavf (FIXME), skipping samples in
2926          * audio, and video decoders such as cuvid or mediacodec */
2927         ist->dec_ctx->pkt_timebase = ist->st->time_base;
2928
2929         if (!av_dict_get(ist->decoder_opts, "threads", NULL, 0))
2930             av_dict_set(&ist->decoder_opts, "threads", "auto", 0);
2931         /* Attached pics are sparse, therefore we would not want to delay their decoding till EOF. */
2932         if (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC)
2933             av_dict_set(&ist->decoder_opts, "threads", "1", 0);
2934
2935         ret = hw_device_setup_for_decode(ist);
2936         if (ret < 0) {
2937             snprintf(error, error_len, "Device setup failed for "
2938                      "decoder on input stream #%d:%d : %s",
2939                      ist->file_index, ist->st->index, av_err2str(ret));
2940             return ret;
2941         }
2942
2943         if ((ret = avcodec_open2(ist->dec_ctx, codec, &ist->decoder_opts)) < 0) {
2944             if (ret == AVERROR_EXPERIMENTAL)
2945                 abort_codec_experimental(codec, 0);
2946
2947             snprintf(error, error_len,
2948                      "Error while opening decoder for input stream "
2949                      "#%d:%d : %s",
2950                      ist->file_index, ist->st->index, av_err2str(ret));
2951             return ret;
2952         }
2953         assert_avoptions(ist->decoder_opts);
2954     }
2955
2956     ist->next_pts = AV_NOPTS_VALUE;
2957     ist->next_dts = AV_NOPTS_VALUE;
2958
2959     return 0;
2960 }
2961
2962 static InputStream *get_input_stream(OutputStream *ost)
2963 {
2964     if (ost->source_index >= 0)
2965         return input_streams[ost->source_index];
2966     return NULL;
2967 }
2968
2969 static int compare_int64(const void *a, const void *b)
2970 {
2971     return FFDIFFSIGN(*(const int64_t *)a, *(const int64_t *)b);
2972 }
2973
2974 /* open the muxer when all the streams are initialized */
2975 static int check_init_output_file(OutputFile *of, int file_index)
2976 {
2977     int ret, i;
2978
2979     for (i = 0; i < of->ctx->nb_streams; i++) {
2980         OutputStream *ost = output_streams[of->ost_index + i];
2981         if (!ost->initialized)
2982             return 0;
2983     }
2984
2985     of->ctx->interrupt_callback = int_cb;
2986
2987     ret = avformat_write_header(of->ctx, &of->opts);
2988     if (ret < 0) {
2989         av_log(NULL, AV_LOG_ERROR,
2990                "Could not write header for output file #%d "
2991                "(incorrect codec parameters ?): %s\n",
2992                file_index, av_err2str(ret));
2993         return ret;
2994     }
2995     //assert_avoptions(of->opts);
2996     of->header_written = 1;
2997
2998     av_dump_format(of->ctx, file_index, of->ctx->url, 1);
2999
3000     if (sdp_filename || want_sdp)
3001         print_sdp();
3002
3003     /* flush the muxing queues */
3004     for (i = 0; i < of->ctx->nb_streams; i++) {
3005         OutputStream *ost = output_streams[of->ost_index + i];
3006
3007         /* try to improve muxing time_base (only possible if nothing has been written yet) */
3008         if (!av_fifo_size(ost->muxing_queue))
3009             ost->mux_timebase = ost->st->time_base;
3010
3011         while (av_fifo_size(ost->muxing_queue)) {
3012             AVPacket pkt;
3013             av_fifo_generic_read(ost->muxing_queue, &pkt, sizeof(pkt), NULL);
3014             write_packet(of, &pkt, ost, 1);
3015         }
3016     }
3017
3018     return 0;
3019 }
3020
3021 static int init_output_bsfs(OutputStream *ost)
3022 {
3023     AVBSFContext *ctx;
3024     int i, ret;
3025
3026     if (!ost->nb_bitstream_filters)
3027         return 0;
3028
3029     for (i = 0; i < ost->nb_bitstream_filters; i++) {
3030         ctx = ost->bsf_ctx[i];
3031
3032         ret = avcodec_parameters_copy(ctx->par_in,
3033                                       i ? ost->bsf_ctx[i - 1]->par_out : ost->st->codecpar);
3034         if (ret < 0)
3035             return ret;
3036
3037         ctx->time_base_in = i ? ost->bsf_ctx[i - 1]->time_base_out : ost->st->time_base;
3038
3039         ret = av_bsf_init(ctx);
3040         if (ret < 0) {
3041             av_log(NULL, AV_LOG_ERROR, "Error initializing bitstream filter: %s\n",
3042                    ost->bsf_ctx[i]->filter->name);
3043             return ret;
3044         }
3045     }
3046
3047     ctx = ost->bsf_ctx[ost->nb_bitstream_filters - 1];
3048     ret = avcodec_parameters_copy(ost->st->codecpar, ctx->par_out);
3049     if (ret < 0)
3050         return ret;
3051
3052     ost->st->time_base = ctx->time_base_out;
3053
3054     return 0;
3055 }
3056
3057 static int init_output_stream_streamcopy(OutputStream *ost)
3058 {
3059     OutputFile *of = output_files[ost->file_index];
3060     InputStream *ist = get_input_stream(ost);
3061     AVCodecParameters *par_dst = ost->st->codecpar;
3062     AVCodecParameters *par_src = ost->ref_par;
3063     AVRational sar;
3064     int i, ret;
3065     uint32_t codec_tag = par_dst->codec_tag;
3066
3067     av_assert0(ist && !ost->filter);
3068
3069     ret = avcodec_parameters_to_context(ost->enc_ctx, ist->st->codecpar);
3070     if (ret >= 0)
3071         ret = av_opt_set_dict(ost->enc_ctx, &ost->encoder_opts);
3072     if (ret < 0) {
3073         av_log(NULL, AV_LOG_FATAL,
3074                "Error setting up codec context options.\n");
3075         return ret;
3076     }
3077     avcodec_parameters_from_context(par_src, ost->enc_ctx);
3078
3079     if (!codec_tag) {
3080         unsigned int codec_tag_tmp;
3081         if (!of->ctx->oformat->codec_tag ||
3082             av_codec_get_id (of->ctx->oformat->codec_tag, par_src->codec_tag) == par_src->codec_id ||
3083             !av_codec_get_tag2(of->ctx->oformat->codec_tag, par_src->codec_id, &codec_tag_tmp))
3084             codec_tag = par_src->codec_tag;
3085     }
3086
3087     ret = avcodec_parameters_copy(par_dst, par_src);
3088     if (ret < 0)
3089         return ret;
3090
3091     par_dst->codec_tag = codec_tag;
3092
3093     if (!ost->frame_rate.num)
3094         ost->frame_rate = ist->framerate;
3095     ost->st->avg_frame_rate = ost->frame_rate;
3096
3097     ret = avformat_transfer_internal_stream_timing_info(of->ctx->oformat, ost->st, ist->st, copy_tb);
3098     if (ret < 0)
3099         return ret;
3100
3101     // copy timebase while removing common factors
3102     if (ost->st->time_base.num <= 0 || ost->st->time_base.den <= 0)
3103         ost->st->time_base = av_add_q(av_stream_get_codec_timebase(ost->st), (AVRational){0, 1});
3104
3105     // copy estimated duration as a hint to the muxer
3106     if (ost->st->duration <= 0 && ist->st->duration > 0)
3107         ost->st->duration = av_rescale_q(ist->st->duration, ist->st->time_base, ost->st->time_base);
3108
3109     // copy disposition
3110     ost->st->disposition = ist->st->disposition;
3111
3112     if (ist->st->nb_side_data) {
3113         for (i = 0; i < ist->st->nb_side_data; i++) {
3114             const AVPacketSideData *sd_src = &ist->st->side_data[i];
3115             uint8_t *dst_data;
3116
3117             dst_data = av_stream_new_side_data(ost->st, sd_src->type, sd_src->size);
3118             if (!dst_data)
3119                 return AVERROR(ENOMEM);
3120             memcpy(dst_data, sd_src->data, sd_src->size);
3121         }
3122     }
3123
3124     if (ost->rotate_overridden) {
3125         uint8_t *sd = av_stream_new_side_data(ost->st, AV_PKT_DATA_DISPLAYMATRIX,
3126                                               sizeof(int32_t) * 9);
3127         if (sd)
3128             av_display_rotation_set((int32_t *)sd, -ost->rotate_override_value);
3129     }
3130
3131     ost->parser = av_parser_init(par_dst->codec_id);
3132     ost->parser_avctx = avcodec_alloc_context3(NULL);
3133     if (!ost->parser_avctx)
3134         return AVERROR(ENOMEM);
3135
3136     switch (par_dst->codec_type) {
3137     case AVMEDIA_TYPE_AUDIO:
3138         if (audio_volume != 256) {
3139             av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
3140             exit_program(1);
3141         }
3142         if((par_dst->block_align == 1 || par_dst->block_align == 1152 || par_dst->block_align == 576) && par_dst->codec_id == AV_CODEC_ID_MP3)
3143             par_dst->block_align= 0;
3144         if(par_dst->codec_id == AV_CODEC_ID_AC3)
3145             par_dst->block_align= 0;
3146         break;
3147     case AVMEDIA_TYPE_VIDEO:
3148         if (ost->frame_aspect_ratio.num) { // overridden by the -aspect cli option
3149             sar =
3150                 av_mul_q(ost->frame_aspect_ratio,
3151                          (AVRational){ par_dst->height, par_dst->width });
3152             av_log(NULL, AV_LOG_WARNING, "Overriding aspect ratio "
3153                    "with stream copy may produce invalid files\n");
3154             }
3155         else if (ist->st->sample_aspect_ratio.num)
3156             sar = ist->st->sample_aspect_ratio;
3157         else
3158             sar = par_src->sample_aspect_ratio;
3159         ost->st->sample_aspect_ratio = par_dst->sample_aspect_ratio = sar;
3160         ost->st->avg_frame_rate = ist->st->avg_frame_rate;
3161         ost->st->r_frame_rate = ist->st->r_frame_rate;
3162         break;
3163     }
3164
3165     ost->mux_timebase = ist->st->time_base;
3166
3167     return 0;
3168 }
3169
3170 static void set_encoder_id(OutputFile *of, OutputStream *ost)
3171 {
3172     AVDictionaryEntry *e;
3173
3174     uint8_t *encoder_string;
3175     int encoder_string_len;
3176     int format_flags = 0;
3177     int codec_flags = ost->enc_ctx->flags;
3178
3179     if (av_dict_get(ost->st->metadata, "encoder",  NULL, 0))
3180         return;
3181
3182     e = av_dict_get(of->opts, "fflags", NULL, 0);
3183     if (e) {
3184         const AVOption *o = av_opt_find(of->ctx, "fflags", NULL, 0, 0);
3185         if (!o)
3186             return;
3187         av_opt_eval_flags(of->ctx, o, e->value, &format_flags);
3188     }
3189     e = av_dict_get(ost->encoder_opts, "flags", NULL, 0);
3190     if (e) {
3191         const AVOption *o = av_opt_find(ost->enc_ctx, "flags", NULL, 0, 0);
3192         if (!o)
3193             return;
3194         av_opt_eval_flags(ost->enc_ctx, o, e->value, &codec_flags);
3195     }
3196
3197     encoder_string_len = sizeof(LIBAVCODEC_IDENT) + strlen(ost->enc->name) + 2;
3198     encoder_string     = av_mallocz(encoder_string_len);
3199     if (!encoder_string)
3200         exit_program(1);
3201
3202     if (!(format_flags & AVFMT_FLAG_BITEXACT) && !(codec_flags & AV_CODEC_FLAG_BITEXACT))
3203         av_strlcpy(encoder_string, LIBAVCODEC_IDENT " ", encoder_string_len);
3204     else
3205         av_strlcpy(encoder_string, "Lavc ", encoder_string_len);
3206     av_strlcat(encoder_string, ost->enc->name, encoder_string_len);
3207     av_dict_set(&ost->st->metadata, "encoder",  encoder_string,
3208                 AV_DICT_DONT_STRDUP_VAL | AV_DICT_DONT_OVERWRITE);
3209 }
3210
3211 static void parse_forced_key_frames(char *kf, OutputStream *ost,
3212                                     AVCodecContext *avctx)
3213 {
3214     char *p;
3215     int n = 1, i, size, index = 0;
3216     int64_t t, *pts;
3217
3218     for (p = kf; *p; p++)
3219         if (*p == ',')
3220             n++;
3221     size = n;
3222     pts = av_malloc_array(size, sizeof(*pts));
3223     if (!pts) {
3224         av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
3225         exit_program(1);
3226     }
3227
3228     p = kf;
3229     for (i = 0; i < n; i++) {
3230         char *next = strchr(p, ',');
3231
3232         if (next)
3233             *next++ = 0;
3234
3235         if (!memcmp(p, "chapters", 8)) {
3236
3237             AVFormatContext *avf = output_files[ost->file_index]->ctx;
3238             int j;
3239
3240             if (avf->nb_chapters > INT_MAX - size ||
3241                 !(pts = av_realloc_f(pts, size += avf->nb_chapters - 1,
3242                                      sizeof(*pts)))) {
3243                 av_log(NULL, AV_LOG_FATAL,
3244                        "Could not allocate forced key frames array.\n");
3245                 exit_program(1);
3246             }
3247             t = p[8] ? parse_time_or_die("force_key_frames", p + 8, 1) : 0;
3248             t = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
3249
3250             for (j = 0; j < avf->nb_chapters; j++) {
3251                 AVChapter *c = avf->chapters[j];
3252                 av_assert1(index < size);
3253                 pts[index++] = av_rescale_q(c->start, c->time_base,
3254                                             avctx->time_base) + t;
3255             }
3256
3257         } else {
3258
3259             t = parse_time_or_die("force_key_frames", p, 1);
3260             av_assert1(index < size);
3261             pts[index++] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
3262
3263         }
3264
3265         p = next;
3266     }
3267
3268     av_assert0(index == size);
3269     qsort(pts, size, sizeof(*pts), compare_int64);
3270     ost->forced_kf_count = size;
3271     ost->forced_kf_pts   = pts;
3272 }
3273
3274 static void init_encoder_time_base(OutputStream *ost, AVRational default_time_base)
3275 {
3276     InputStream *ist = get_input_stream(ost);
3277     AVCodecContext *enc_ctx = ost->enc_ctx;
3278     AVFormatContext *oc;
3279
3280     if (ost->enc_timebase.num > 0) {
3281         enc_ctx->time_base = ost->enc_timebase;
3282         return;
3283     }
3284
3285     if (ost->enc_timebase.num < 0) {
3286         if (ist) {
3287             enc_ctx->time_base = ist->st->time_base;
3288             return;
3289         }
3290
3291         oc = output_files[ost->file_index]->ctx;
3292         av_log(oc, AV_LOG_WARNING, "Input stream data not available, using default time base\n");
3293     }
3294
3295     enc_ctx->time_base = default_time_base;
3296 }
3297
3298 static int init_output_stream_encode(OutputStream *ost)
3299 {
3300     InputStream *ist = get_input_stream(ost);
3301     AVCodecContext *enc_ctx = ost->enc_ctx;
3302     AVCodecContext *dec_ctx = NULL;
3303     AVFormatContext *oc = output_files[ost->file_index]->ctx;
3304     int j, ret;
3305
3306     set_encoder_id(output_files[ost->file_index], ost);
3307
3308     // Muxers use AV_PKT_DATA_DISPLAYMATRIX to signal rotation. On the other
3309     // hand, the legacy API makes demuxers set "rotate" metadata entries,
3310     // which have to be filtered out to prevent leaking them to output files.
3311     av_dict_set(&ost->st->metadata, "rotate", NULL, 0);
3312
3313     if (ist) {
3314         ost->st->disposition          = ist->st->disposition;
3315
3316         dec_ctx = ist->dec_ctx;
3317
3318         enc_ctx->chroma_sample_location = dec_ctx->chroma_sample_location;
3319     } else {
3320         for (j = 0; j < oc->nb_streams; j++) {
3321             AVStream *st = oc->streams[j];
3322             if (st != ost->st && st->codecpar->codec_type == ost->st->codecpar->codec_type)
3323                 break;
3324         }
3325         if (j == oc->nb_streams)
3326             if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO ||
3327                 ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
3328                 ost->st->disposition = AV_DISPOSITION_DEFAULT;
3329     }
3330
3331     if (enc_ctx->codec_type == AVMEDIA_TYPE_VIDEO) {
3332         if (!ost->frame_rate.num)
3333             ost->frame_rate = av_buffersink_get_frame_rate(ost->filter->filter);
3334         if (ist && !ost->frame_rate.num)
3335             ost->frame_rate = ist->framerate;
3336         if (ist && !ost->frame_rate.num)
3337             ost->frame_rate = ist->st->r_frame_rate;
3338         if (ist && !ost->frame_rate.num) {
3339             ost->frame_rate = (AVRational){25, 1};
3340             av_log(NULL, AV_LOG_WARNING,
3341                    "No information "
3342                    "about the input framerate is available. Falling "
3343                    "back to a default value of 25fps for output stream #%d:%d. Use the -r option "
3344                    "if you want a different framerate.\n",
3345                    ost->file_index, ost->index);
3346         }
3347 //      ost->frame_rate = ist->st->avg_frame_rate.num ? ist->st->avg_frame_rate : (AVRational){25, 1};
3348         if (ost->enc->supported_framerates && !ost->force_fps) {
3349             int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
3350             ost->frame_rate = ost->enc->supported_framerates[idx];
3351         }
3352         // reduce frame rate for mpeg4 to be within the spec limits
3353         if (enc_ctx->codec_id == AV_CODEC_ID_MPEG4) {
3354             av_reduce(&ost->frame_rate.num, &ost->frame_rate.den,
3355                       ost->frame_rate.num, ost->frame_rate.den, 65535);
3356         }
3357     }
3358
3359     switch (enc_ctx->codec_type) {
3360     case AVMEDIA_TYPE_AUDIO:
3361         enc_ctx->sample_fmt     = av_buffersink_get_format(ost->filter->filter);
3362         if (dec_ctx)
3363             enc_ctx->bits_per_raw_sample = FFMIN(dec_ctx->bits_per_raw_sample,
3364                                                  av_get_bytes_per_sample(enc_ctx->sample_fmt) << 3);
3365         enc_ctx->sample_rate    = av_buffersink_get_sample_rate(ost->filter->filter);
3366         enc_ctx->channel_layout = av_buffersink_get_channel_layout(ost->filter->filter);
3367         enc_ctx->channels       = av_buffersink_get_channels(ost->filter->filter);
3368
3369         init_encoder_time_base(ost, av_make_q(1, enc_ctx->sample_rate));
3370         break;
3371
3372     case AVMEDIA_TYPE_VIDEO:
3373         init_encoder_time_base(ost, av_inv_q(ost->frame_rate));
3374
3375         if (!(enc_ctx->time_base.num && enc_ctx->time_base.den))
3376             enc_ctx->time_base = av_buffersink_get_time_base(ost->filter->filter);
3377         if (   av_q2d(enc_ctx->time_base) < 0.001 && video_sync_method != VSYNC_PASSTHROUGH
3378            && (video_sync_method == VSYNC_CFR || video_sync_method == VSYNC_VSCFR || (video_sync_method == VSYNC_AUTO && !(oc->oformat->flags & AVFMT_VARIABLE_FPS)))){
3379             av_log(oc, AV_LOG_WARNING, "Frame rate very high for a muxer not efficiently supporting it.\n"
3380                                        "Please consider specifying a lower framerate, a different muxer or -vsync 2\n");
3381         }
3382         for (j = 0; j < ost->forced_kf_count; j++)
3383             ost->forced_kf_pts[j] = av_rescale_q(ost->forced_kf_pts[j],
3384                                                  AV_TIME_BASE_Q,
3385                                                  enc_ctx->time_base);
3386
3387         enc_ctx->width  = av_buffersink_get_w(ost->filter->filter);
3388         enc_ctx->height = av_buffersink_get_h(ost->filter->filter);
3389         enc_ctx->sample_aspect_ratio = ost->st->sample_aspect_ratio =
3390             ost->frame_aspect_ratio.num ? // overridden by the -aspect cli option
3391             av_mul_q(ost->frame_aspect_ratio, (AVRational){ enc_ctx->height, enc_ctx->width }) :
3392             av_buffersink_get_sample_aspect_ratio(ost->filter->filter);
3393
3394         enc_ctx->pix_fmt = av_buffersink_get_format(ost->filter->filter);
3395         if (dec_ctx)
3396             enc_ctx->bits_per_raw_sample = FFMIN(dec_ctx->bits_per_raw_sample,
3397                                                  av_pix_fmt_desc_get(enc_ctx->pix_fmt)->comp[0].depth);
3398
3399         enc_ctx->framerate = ost->frame_rate;
3400
3401         ost->st->avg_frame_rate = ost->frame_rate;
3402
3403         if (!dec_ctx ||
3404             enc_ctx->width   != dec_ctx->width  ||
3405             enc_ctx->height  != dec_ctx->height ||
3406             enc_ctx->pix_fmt != dec_ctx->pix_fmt) {
3407             enc_ctx->bits_per_raw_sample = frame_bits_per_raw_sample;
3408         }
3409
3410         if (ost->forced_keyframes) {
3411             if (!strncmp(ost->forced_keyframes, "expr:", 5)) {
3412                 ret = av_expr_parse(&ost->forced_keyframes_pexpr, ost->forced_keyframes+5,
3413                                     forced_keyframes_const_names, NULL, NULL, NULL, NULL, 0, NULL);
3414                 if (ret < 0) {
3415                     av_log(NULL, AV_LOG_ERROR,
3416                            "Invalid force_key_frames expression '%s'\n", ost->forced_keyframes+5);
3417                     return ret;
3418                 }
3419                 ost->forced_keyframes_expr_const_values[FKF_N] = 0;
3420                 ost->forced_keyframes_expr_const_values[FKF_N_FORCED] = 0;
3421                 ost->forced_keyframes_expr_const_values[FKF_PREV_FORCED_N] = NAN;
3422                 ost->forced_keyframes_expr_const_values[FKF_PREV_FORCED_T] = NAN;
3423
3424             // Don't parse the 'forced_keyframes' in case of 'keep-source-keyframes',
3425             // parse it only for static kf timings
3426             } else if(strncmp(ost->forced_keyframes, "source", 6)) {
3427                 parse_forced_key_frames(ost->forced_keyframes, ost, ost->enc_ctx);
3428             }
3429         }
3430         break;
3431     case AVMEDIA_TYPE_SUBTITLE:
3432         enc_ctx->time_base = AV_TIME_BASE_Q;
3433         if (!enc_ctx->width) {
3434             enc_ctx->width     = input_streams[ost->source_index]->st->codecpar->width;
3435             enc_ctx->height    = input_streams[ost->source_index]->st->codecpar->height;
3436         }
3437         break;
3438     case AVMEDIA_TYPE_DATA:
3439         break;
3440     default:
3441         abort();
3442         break;
3443     }
3444
3445     ost->mux_timebase = enc_ctx->time_base;
3446
3447     return 0;
3448 }
3449
3450 static int init_output_stream(OutputStream *ost, char *error, int error_len)
3451 {
3452     int ret = 0;
3453
3454     if (ost->encoding_needed) {
3455         AVCodec      *codec = ost->enc;
3456         AVCodecContext *dec = NULL;
3457         InputStream *ist;
3458
3459         ret = init_output_stream_encode(ost);
3460         if (ret < 0)
3461             return ret;
3462
3463         if ((ist = get_input_stream(ost)))
3464             dec = ist->dec_ctx;
3465         if (dec && dec->subtitle_header) {
3466             /* ASS code assumes this buffer is null terminated so add extra byte. */
3467             ost->enc_ctx->subtitle_header = av_mallocz(dec->subtitle_header_size + 1);
3468             if (!ost->enc_ctx->subtitle_header)
3469                 return AVERROR(ENOMEM);
3470             memcpy(ost->enc_ctx->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
3471             ost->enc_ctx->subtitle_header_size = dec->subtitle_header_size;
3472         }
3473         if (!av_dict_get(ost->encoder_opts, "threads", NULL, 0))
3474             av_dict_set(&ost->encoder_opts, "threads", "auto", 0);
3475         if (ost->enc->type == AVMEDIA_TYPE_AUDIO &&
3476             !codec->defaults &&
3477             !av_dict_get(ost->encoder_opts, "b", NULL, 0) &&
3478             !av_dict_get(ost->encoder_opts, "ab", NULL, 0))
3479             av_dict_set(&ost->encoder_opts, "b", "128000", 0);
3480
3481         if (ost->filter && av_buffersink_get_hw_frames_ctx(ost->filter->filter) &&
3482             ((AVHWFramesContext*)av_buffersink_get_hw_frames_ctx(ost->filter->filter)->data)->format ==
3483             av_buffersink_get_format(ost->filter->filter)) {
3484             ost->enc_ctx->hw_frames_ctx = av_buffer_ref(av_buffersink_get_hw_frames_ctx(ost->filter->filter));
3485             if (!ost->enc_ctx->hw_frames_ctx)
3486                 return AVERROR(ENOMEM);
3487         } else {
3488             ret = hw_device_setup_for_encode(ost);
3489             if (ret < 0) {
3490                 snprintf(error, error_len, "Device setup failed for "
3491                          "encoder on output stream #%d:%d : %s",
3492                      ost->file_index, ost->index, av_err2str(ret));
3493                 return ret;
3494             }
3495         }
3496
3497         if ((ret = avcodec_open2(ost->enc_ctx, codec, &ost->encoder_opts)) < 0) {
3498             if (ret == AVERROR_EXPERIMENTAL)
3499                 abort_codec_experimental(codec, 1);
3500             snprintf(error, error_len,
3501                      "Error while opening encoder for output stream #%d:%d - "
3502                      "maybe incorrect parameters such as bit_rate, rate, width or height",
3503                     ost->file_index, ost->index);
3504             return ret;
3505         }
3506         if (ost->enc->type == AVMEDIA_TYPE_AUDIO &&
3507             !(ost->enc->capabilities & AV_CODEC_CAP_VARIABLE_FRAME_SIZE))
3508             av_buffersink_set_frame_size(ost->filter->filter,
3509                                             ost->enc_ctx->frame_size);
3510         assert_avoptions(ost->encoder_opts);
3511         if (ost->enc_ctx->bit_rate && ost->enc_ctx->bit_rate < 1000 &&
3512             ost->enc_ctx->codec_id != AV_CODEC_ID_CODEC2 /* don't complain about 700 bit/s modes */)
3513             av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
3514                                          " It takes bits/s as argument, not kbits/s\n");
3515
3516         ret = avcodec_parameters_from_context(ost->st->codecpar, ost->enc_ctx);
3517         if (ret < 0) {
3518             av_log(NULL, AV_LOG_FATAL,
3519                    "Error initializing the output stream codec context.\n");
3520             exit_program(1);
3521         }
3522         /*
3523          * FIXME: ost->st->codec should't be needed here anymore.
3524          */
3525         ret = avcodec_copy_context(ost->st->codec, ost->enc_ctx);
3526         if (ret < 0)
3527             return ret;
3528
3529         if (ost->enc_ctx->nb_coded_side_data) {
3530             int i;
3531
3532             for (i = 0; i < ost->enc_ctx->nb_coded_side_data; i++) {
3533                 const AVPacketSideData *sd_src = &ost->enc_ctx->coded_side_data[i];
3534                 uint8_t *dst_data;
3535
3536                 dst_data = av_stream_new_side_data(ost->st, sd_src->type, sd_src->size);
3537                 if (!dst_data)
3538                     return AVERROR(ENOMEM);
3539                 memcpy(dst_data, sd_src->data, sd_src->size);
3540             }
3541         }
3542
3543         /*
3544          * Add global input side data. For now this is naive, and copies it
3545          * from the input stream's global side data. All side data should
3546          * really be funneled over AVFrame and libavfilter, then added back to
3547          * packet side data, and then potentially using the first packet for
3548          * global side data.
3549          */
3550         if (ist) {
3551             int i;
3552             for (i = 0; i < ist->st->nb_side_data; i++) {
3553                 AVPacketSideData *sd = &ist->st->side_data[i];
3554                 uint8_t *dst = av_stream_new_side_data(ost->st, sd->type, sd->size);
3555                 if (!dst)
3556                     return AVERROR(ENOMEM);
3557                 memcpy(dst, sd->data, sd->size);
3558                 if (ist->autorotate && sd->type == AV_PKT_DATA_DISPLAYMATRIX)
3559                     av_display_rotation_set((uint32_t *)dst, 0);
3560             }
3561         }
3562
3563         // copy timebase while removing common factors
3564         if (ost->st->time_base.num <= 0 || ost->st->time_base.den <= 0)
3565             ost->st->time_base = av_add_q(ost->enc_ctx->time_base, (AVRational){0, 1});
3566
3567         // copy estimated duration as a hint to the muxer
3568         if (ost->st->duration <= 0 && ist && ist->st->duration > 0)
3569             ost->st->duration = av_rescale_q(ist->st->duration, ist->st->time_base, ost->st->time_base);
3570
3571         ost->st->codec->codec= ost->enc_ctx->codec;
3572     } else if (ost->stream_copy) {
3573         ret = init_output_stream_streamcopy(ost);
3574         if (ret < 0)
3575             return ret;
3576
3577         /*
3578          * FIXME: will the codec context used by the parser during streamcopy
3579          * This should go away with the new parser API.
3580          */
3581         ret = avcodec_parameters_to_context(ost->parser_avctx, ost->st->codecpar);
3582         if (ret < 0)
3583             return ret;
3584     }
3585
3586     // parse user provided disposition, and update stream values
3587     if (ost->disposition) {
3588         static const AVOption opts[] = {
3589             { "disposition"         , NULL, 0, AV_OPT_TYPE_FLAGS, { .i64 = 0 }, INT64_MIN, INT64_MAX, .unit = "flags" },
3590             { "default"             , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_DEFAULT           },    .unit = "flags" },
3591             { "dub"                 , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_DUB               },    .unit = "flags" },
3592             { "original"            , NUL