Ticket #3680: ffmpeg.c

File ffmpeg.c, 137.2 KB (added by hxuanyu, 5 years ago)

test code (my own test code put into main function of ffmpeg.c)

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