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