1/*
2 * ffmpeg main
3 * Copyright (c) 2000-2003 Fabrice Bellard
4 *
5 * This file is part of Libav.
6 *
7 * Libav is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * Libav is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with Libav; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 */
21
22#include "config.h"
23#include <ctype.h>
24#include <string.h>
25#include <math.h>
26#include <stdlib.h>
27#include <errno.h>
28#include <signal.h>
29#include <limits.h>
30#include <unistd.h>
31#include "libavformat/avformat.h"
32#include "libavdevice/avdevice.h"
33#include "libswscale/swscale.h"
34#include "libavutil/opt.h"
35#include "libavcodec/audioconvert.h"
36#include "libavutil/audioconvert.h"
37#include "libavutil/parseutils.h"
38#include "libavutil/samplefmt.h"
39#include "libavutil/colorspace.h"
40#include "libavutil/fifo.h"
41#include "libavutil/intreadwrite.h"
42#include "libavutil/dict.h"
43#include "libavutil/mathematics.h"
44#include "libavutil/pixdesc.h"
45#include "libavutil/avstring.h"
46#include "libavutil/libm.h"
47#include "libavformat/os_support.h"
48
49#if CONFIG_AVFILTER
50# include "libavfilter/avfilter.h"
51# include "libavfilter/avfiltergraph.h"
52# include "libavfilter/vsrc_buffer.h"
53#endif
54
55#if HAVE_SYS_RESOURCE_H
56#include <sys/types.h>
57#include <sys/time.h>
58#include <sys/resource.h>
59#elif HAVE_GETPROCESSTIMES
60#include <windows.h>
61#endif
62#if HAVE_GETPROCESSMEMORYINFO
63#include <windows.h>
64#include <psapi.h>
65#endif
66
67#if HAVE_SYS_SELECT_H
68#include <sys/select.h>
69#endif
70
71#include <time.h>
72
73#include "cmdutils.h"
74
75#include "libavutil/avassert.h"
76
77const char program_name[] = "ffmpeg";
78const int program_birth_year = 2000;
79
80/* select an input stream for an output stream */
81typedef struct StreamMap {
82    int file_index;
83    int stream_index;
84    int sync_file_index;
85    int sync_stream_index;
86} StreamMap;
87
88/**
89 * select an input file for an output file
90 */
91typedef struct MetadataMap {
92    int  file;      ///< file index
93    char type;      ///< type of metadata to copy -- (g)lobal, (s)tream, (c)hapter or (p)rogram
94    int  index;     ///< stream/chapter/program number
95} MetadataMap;
96
97typedef struct ChapterMap {
98    int in_file;
99    int out_file;
100} ChapterMap;
101
102static const OptionDef options[];
103
104#define MAX_FILES 100
105
106static const char *last_asked_format = NULL;
107static double *ts_scale;
108static int  nb_ts_scale;
109
110static AVFormatContext *output_files[MAX_FILES];
111static AVDictionary *output_opts[MAX_FILES];
112static int nb_output_files = 0;
113
114static StreamMap *stream_maps = NULL;
115static int nb_stream_maps;
116
117/* first item specifies output metadata, second is input */
118static MetadataMap (*meta_data_maps)[2] = NULL;
119static int nb_meta_data_maps;
120static int metadata_global_autocopy   = 1;
121static int metadata_streams_autocopy  = 1;
122static int metadata_chapters_autocopy = 1;
123
124static ChapterMap *chapter_maps = NULL;
125static int nb_chapter_maps;
126
127/* indexed by output file stream index */
128static int *streamid_map = NULL;
129static int nb_streamid_map = 0;
130
131static int frame_width  = 0;
132static int frame_height = 0;
133static float frame_aspect_ratio = 0;
134static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
135static enum AVSampleFormat audio_sample_fmt = AV_SAMPLE_FMT_NONE;
136static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
137static AVRational frame_rate;
138static float video_qscale = 0;
139static uint16_t *intra_matrix = NULL;
140static uint16_t *inter_matrix = NULL;
141static const char *video_rc_override_string=NULL;
142static int video_disable = 0;
143static int video_discard = 0;
144static char *video_codec_name = NULL;
145static unsigned int video_codec_tag = 0;
146static char *video_language = NULL;
147static int same_quality = 0;
148static int do_deinterlace = 0;
149static int top_field_first = -1;
150static int me_threshold = 0;
151static int intra_dc_precision = 8;
152static int loop_input = 0;
153static int loop_output = AVFMT_NOOUTPUTLOOP;
154static int qp_hist = 0;
155#if CONFIG_AVFILTER
156static char *vfilters = NULL;
157#endif
158
159static int intra_only = 0;
160static int audio_sample_rate = 0;
161#define QSCALE_NONE -99999
162static float audio_qscale = QSCALE_NONE;
163static int audio_disable = 0;
164static int audio_channels = 0;
165static char  *audio_codec_name = NULL;
166static unsigned int audio_codec_tag = 0;
167static char *audio_language = NULL;
168
169static int subtitle_disable = 0;
170static char *subtitle_codec_name = NULL;
171static char *subtitle_language = NULL;
172static unsigned int subtitle_codec_tag = 0;
173
174static int data_disable = 0;
175static char *data_codec_name = NULL;
176static unsigned int data_codec_tag = 0;
177
178static float mux_preload= 0.5;
179static float mux_max_delay= 0.7;
180
181static int64_t recording_time = INT64_MAX;
182static int64_t start_time = 0;
183static int64_t input_ts_offset = 0;
184static int file_overwrite = 0;
185static AVDictionary *metadata;
186static int do_benchmark = 0;
187static int do_hex_dump = 0;
188static int do_pkt_dump = 0;
189static int do_psnr = 0;
190static int do_pass = 0;
191static char *pass_logfilename_prefix = NULL;
192static int audio_stream_copy = 0;
193static int video_stream_copy = 0;
194static int subtitle_stream_copy = 0;
195static int data_stream_copy = 0;
196static int video_sync_method= -1;
197static int audio_sync_method= 0;
198static float audio_drift_threshold= 0.1;
199static int copy_ts= 0;
200static int copy_tb;
201static int opt_shortest = 0;
202static char *vstats_filename;
203static FILE *vstats_file;
204static int opt_programid = 0;
205static int copy_initial_nonkeyframes = 0;
206
207static int rate_emu = 0;
208
209static int audio_volume = 256;
210
211static int exit_on_error = 0;
212static int using_stdin = 0;
213static int verbose = 1;
214static int thread_count= 1;
215static int64_t video_size = 0;
216static int64_t audio_size = 0;
217static int64_t extra_size = 0;
218static int nb_frames_dup = 0;
219static int nb_frames_drop = 0;
220static int input_sync;
221static uint64_t limit_filesize = 0;
222static int force_fps = 0;
223static char *forced_key_frames = NULL;
224
225static float dts_delta_threshold = 10;
226
227static int64_t timer_start;
228
229static uint8_t *audio_buf;
230static uint8_t *audio_out;
231static unsigned int allocated_audio_out_size, allocated_audio_buf_size;
232
233static short *samples;
234
235static AVBitStreamFilterContext *video_bitstream_filters=NULL;
236static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
237static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
238
239#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
240
241struct InputStream;
242
243typedef struct OutputStream {
244    int file_index;          /* file index */
245    int index;               /* stream index in the output file */
246    int source_index;        /* InputStream index */
247    AVStream *st;            /* stream in the output file */
248    int encoding_needed;     /* true if encoding needed for this stream */
249    int frame_number;
250    /* input pts and corresponding output pts
251       for A/V sync */
252    //double sync_ipts;        /* dts from the AVPacket of the demuxer in second units */
253    struct InputStream *sync_ist; /* input stream to sync against */
254    int64_t sync_opts;       /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
255    AVBitStreamFilterContext *bitstream_filters;
256    AVCodec *enc;
257
258    /* video only */
259    int video_resample;
260    AVFrame pict_tmp;      /* temporary image for resampling */
261    struct SwsContext *img_resample_ctx; /* for image resampling */
262    int resample_height;
263    int resample_width;
264    int resample_pix_fmt;
265    AVRational frame_rate;
266
267    float frame_aspect_ratio;
268
269    /* forced key frames */
270    int64_t *forced_kf_pts;
271    int forced_kf_count;
272    int forced_kf_index;
273
274    /* audio only */
275    int audio_resample;
276    ReSampleContext *resample; /* for audio resampling */
277    int resample_sample_fmt;
278    int resample_channels;
279    int resample_sample_rate;
280    int reformat_pair;
281    AVAudioConvert *reformat_ctx;
282    AVFifoBuffer *fifo;     /* for compression: one audio fifo per codec */
283    FILE *logfile;
284
285#if CONFIG_AVFILTER
286    AVFilterContext *output_video_filter;
287    AVFilterContext *input_video_filter;
288    AVFilterBufferRef *picref;
289    char *avfilter;
290    AVFilterGraph *graph;
291#endif
292
293   int sws_flags;
294   AVDictionary *opts;
295} OutputStream;
296
297static OutputStream **output_streams_for_file[MAX_FILES] = { NULL };
298static int nb_output_streams_for_file[MAX_FILES] = { 0 };
299
300typedef struct InputStream {
301    int file_index;
302    AVStream *st;
303    int discard;             /* true if stream data should be discarded */
304    int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
305    AVCodec *dec;
306
307    int64_t       start;     /* time when read started */
308    int64_t       next_pts;  /* synthetic pts for cases where pkt.pts
309                                is not defined */
310    int64_t       pts;       /* current pts */
311    PtsCorrectionContext pts_ctx;
312    double ts_scale;
313    int is_start;            /* is 1 at the start and after a discontinuity */
314    int showed_multi_packet_warning;
315    int is_past_recording_time;
316    AVDictionary *opts;
317} InputStream;
318
319typedef struct InputFile {
320    AVFormatContext *ctx;
321    int eof_reached;      /* true if eof reached */
322    int ist_index;        /* index of first stream in ist_table */
323    int buffer_size;      /* current total buffer size */
324    int64_t ts_offset;
325    int nb_streams;       /* nb streams we are aware of */
326} InputFile;
327
328static InputStream *input_streams = NULL;
329static int         nb_input_streams = 0;
330static InputFile   *input_files   = NULL;
331static int         nb_input_files   = 0;
332
333#if CONFIG_AVFILTER
334
335static int configure_video_filters(InputStream *ist, OutputStream *ost)
336{
337    AVFilterContext *last_filter, *filter;
338    /** filter graph containing all filters including input & output */
339    AVCodecContext *codec = ost->st->codec;
340    AVCodecContext *icodec = ist->st->codec;
341    AVSinkContext avsink_ctx = { .pix_fmt = codec->pix_fmt };
342    AVRational sample_aspect_ratio;
343    char args[255];
344    int ret;
345
346    ost->graph = avfilter_graph_alloc();
347
348    if (ist->st->sample_aspect_ratio.num){
349        sample_aspect_ratio = ist->st->sample_aspect_ratio;
350    }else
351        sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
352
353    snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
354             ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
355             sample_aspect_ratio.num, sample_aspect_ratio.den);
356
357    ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
358                                       "src", args, NULL, ost->graph);
359    if (ret < 0)
360        return ret;
361    ret = avfilter_graph_create_filter(&ost->output_video_filter, &avsink,
362                                       "out", NULL, &avsink_ctx, ost->graph);
363    if (ret < 0)
364        return ret;
365    last_filter = ost->input_video_filter;
366
367    if (codec->width  != icodec->width || codec->height != icodec->height) {
368        snprintf(args, 255, "%d:%d:flags=0x%X",
369                 codec->width,
370                 codec->height,
371                 ost->sws_flags);
372        if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
373                                                NULL, args, NULL, ost->graph)) < 0)
374            return ret;
375        if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
376            return ret;
377        last_filter = filter;
378    }
379
380    snprintf(args, sizeof(args), "flags=0x%X", ost->sws_flags);
381    ost->graph->scale_sws_opts = av_strdup(args);
382
383    if (ost->avfilter) {
384        AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
385        AVFilterInOut *inputs  = av_malloc(sizeof(AVFilterInOut));
386
387        outputs->name    = av_strdup("in");
388        outputs->filter_ctx = last_filter;
389        outputs->pad_idx = 0;
390        outputs->next    = NULL;
391
392        inputs->name    = av_strdup("out");
393        inputs->filter_ctx = ost->output_video_filter;
394        inputs->pad_idx = 0;
395        inputs->next    = NULL;
396
397        if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, inputs, outputs, NULL)) < 0)
398            return ret;
399        av_freep(&ost->avfilter);
400    } else {
401        if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
402            return ret;
403    }
404
405    if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
406        return ret;
407
408    codec->width  = ost->output_video_filter->inputs[0]->w;
409    codec->height = ost->output_video_filter->inputs[0]->h;
410    codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
411        ost->frame_aspect_ratio ? // overriden by the -aspect cli option
412        av_d2q(ost->frame_aspect_ratio*codec->height/codec->width, 255) :
413        ost->output_video_filter->inputs[0]->sample_aspect_ratio;
414
415    return 0;
416}
417#endif /* CONFIG_AVFILTER */
418
419static void term_exit(void)
420{
421    av_log(NULL, AV_LOG_QUIET, "");
422}
423
424static volatile int received_sigterm = 0;
425static volatile int received_nb_signals = 0;
426
427static void
428sigterm_handler(int sig)
429{
430    received_sigterm = sig;
431    received_nb_signals++;
432    term_exit();
433}
434
435static void term_init(void)
436{
437    signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
438    signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
439#ifdef SIGXCPU
440    signal(SIGXCPU, sigterm_handler);
441#endif
442}
443
444static int decode_interrupt_cb(void)
445{
446    return received_nb_signals > 1;
447}
448
449void exit_program(int ret)
450{
451    int i;
452
453    /* close files */
454    for(i=0;i<nb_output_files;i++) {
455        AVFormatContext *s = output_files[i];
456        if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
457            avio_close(s->pb);
458        avformat_free_context(s);
459        av_free(output_streams_for_file[i]);
460        av_dict_free(&output_opts[i]);
461    }
462    for(i=0;i<nb_input_files;i++) {
463        av_close_input_file(input_files[i].ctx);
464    }
465    for (i = 0; i < nb_input_streams; i++)
466        av_dict_free(&input_streams[i].opts);
467
468    av_free(intra_matrix);
469    av_free(inter_matrix);
470
471    if (vstats_file)
472        fclose(vstats_file);
473    av_free(vstats_filename);
474
475    av_free(streamid_map);
476    av_free(stream_maps);
477    av_free(meta_data_maps);
478
479    av_freep(&input_streams);
480    av_freep(&input_files);
481
482    av_free(video_codec_name);
483    av_free(audio_codec_name);
484    av_free(subtitle_codec_name);
485    av_free(data_codec_name);
486
487    uninit_opts();
488    av_free(audio_buf);
489    av_free(audio_out);
490    allocated_audio_buf_size= allocated_audio_out_size= 0;
491    av_free(samples);
492
493#if CONFIG_AVFILTER
494    avfilter_uninit();
495#endif
496    avformat_network_deinit();
497
498    if (received_sigterm) {
499        fprintf(stderr,
500            "Received signal %d: terminating.\n",
501            (int) received_sigterm);
502        exit (255);
503    }
504
505    exit(ret); /* not all OS-es handle main() return value */
506}
507
508static void assert_avoptions(AVDictionary *m)
509{
510    AVDictionaryEntry *t;
511    if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
512        av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key);
513        exit_program(1);
514    }
515}
516
517static void assert_codec_experimental(AVCodecContext *c, int encoder)
518{
519    const char *codec_string = encoder ? "encoder" : "decoder";
520    AVCodec *codec;
521    if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
522        c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
523        av_log(NULL, AV_LOG_ERROR, "%s '%s' is experimental and might produce bad "
524                "results.\nAdd '-strict experimental' if you want to use it.\n",
525                codec_string, c->codec->name);
526        codec = encoder ? avcodec_find_encoder(c->codec->id) : avcodec_find_decoder(c->codec->id);
527        if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
528            av_log(NULL, AV_LOG_ERROR, "Or use the non experimental %s '%s'.\n",
529                   codec_string, codec->name);
530        exit_program(1);
531    }
532}
533
534static void choose_sample_fmt(AVStream *st, AVCodec *codec)
535{
536    if(codec && codec->sample_fmts){
537        const enum AVSampleFormat *p= codec->sample_fmts;
538        for(; *p!=-1; p++){
539            if(*p == st->codec->sample_fmt)
540                break;
541        }
542        if (*p == -1) {
543            av_log(NULL, AV_LOG_WARNING,
544                   "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
545                   av_get_sample_fmt_name(st->codec->sample_fmt),
546                   codec->name,
547                   av_get_sample_fmt_name(codec->sample_fmts[0]));
548            st->codec->sample_fmt = codec->sample_fmts[0];
549        }
550    }
551}
552
553/**
554 * Update the requested input sample format based on the output sample format.
555 * This is currently only used to request float output from decoders which
556 * support multiple sample formats, one of which is AV_SAMPLE_FMT_FLT.
557 * Ideally this will be removed in the future when decoders do not do format
558 * conversion and only output in their native format.
559 */
560static void update_sample_fmt(AVCodecContext *dec, AVCodec *dec_codec,
561                              AVCodecContext *enc)
562{
563    /* if sample formats match or a decoder sample format has already been
564       requested, just return */
565    if (enc->sample_fmt == dec->sample_fmt ||
566        dec->request_sample_fmt > AV_SAMPLE_FMT_NONE)
567        return;
568
569    /* if decoder supports more than one output format */
570    if (dec_codec && dec_codec->sample_fmts &&
571        dec_codec->sample_fmts[0] != AV_SAMPLE_FMT_NONE &&
572        dec_codec->sample_fmts[1] != AV_SAMPLE_FMT_NONE) {
573        const enum AVSampleFormat *p;
574        int min_dec = -1, min_inc = -1;
575
576        /* find a matching sample format in the encoder */
577        for (p = dec_codec->sample_fmts; *p != AV_SAMPLE_FMT_NONE; p++) {
578            if (*p == enc->sample_fmt) {
579                dec->request_sample_fmt = *p;
580                return;
581            } else if (*p > enc->sample_fmt) {
582                min_inc = FFMIN(min_inc, *p - enc->sample_fmt);
583            } else
584                min_dec = FFMIN(min_dec, enc->sample_fmt - *p);
585        }
586
587        /* if none match, provide the one that matches quality closest */
588        dec->request_sample_fmt = min_inc > 0 ? enc->sample_fmt + min_inc :
589                                  enc->sample_fmt - min_dec;
590    }
591}
592
593static void choose_sample_rate(AVStream *st, AVCodec *codec)
594{
595    if(codec && codec->supported_samplerates){
596        const int *p= codec->supported_samplerates;
597        int best=0;
598        int best_dist=INT_MAX;
599        for(; *p; p++){
600            int dist= abs(st->codec->sample_rate - *p);
601            if(dist < best_dist){
602                best_dist= dist;
603                best= *p;
604            }
605        }
606        if(best_dist){
607            av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
608        }
609        st->codec->sample_rate= best;
610    }
611}
612
613static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
614{
615    if(codec && codec->pix_fmts){
616        const enum PixelFormat *p= codec->pix_fmts;
617        if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
618            if(st->codec->codec_id==CODEC_ID_MJPEG){
619                p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
620            }else if(st->codec->codec_id==CODEC_ID_LJPEG){
621                p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUVJ444P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_BGRA, PIX_FMT_NONE};
622            }
623        }
624        for(; *p!=-1; p++){
625            if(*p == st->codec->pix_fmt)
626                break;
627        }
628        if (*p == -1) {
629            if(st->codec->pix_fmt != PIX_FMT_NONE)
630                av_log(NULL, AV_LOG_WARNING,
631                        "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
632                        av_pix_fmt_descriptors[st->codec->pix_fmt].name,
633                        codec->name,
634                        av_pix_fmt_descriptors[codec->pix_fmts[0]].name);
635            st->codec->pix_fmt = codec->pix_fmts[0];
636        }
637    }
638}
639
640static OutputStream *new_output_stream(AVFormatContext *oc, int file_idx, AVCodec *codec)
641{
642    OutputStream *ost;
643    AVStream *st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
644    int idx      = oc->nb_streams - 1;
645
646    if (!st) {
647        av_log(NULL, AV_LOG_ERROR, "Could not alloc stream.\n");
648        exit_program(1);
649    }
650
651    output_streams_for_file[file_idx] =
652        grow_array(output_streams_for_file[file_idx],
653                   sizeof(*output_streams_for_file[file_idx]),
654                   &nb_output_streams_for_file[file_idx],
655                   oc->nb_streams);
656    ost = output_streams_for_file[file_idx][idx] =
657        av_mallocz(sizeof(OutputStream));
658    if (!ost) {
659        fprintf(stderr, "Could not alloc output stream\n");
660        exit_program(1);
661    }
662    ost->file_index = file_idx;
663    ost->index = idx;
664    ost->st    = st;
665    ost->enc   = codec;
666    if (codec)
667        ost->opts  = filter_codec_opts(codec_opts, codec->id, oc, st);
668
669    avcodec_get_context_defaults3(st->codec, codec);
670
671    ost->sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
672    return ost;
673}
674
675static int read_avserver_streams(AVFormatContext *s, const char *filename)
676{
677    int i, err;
678    AVFormatContext *ic = NULL;
679
680    err = avformat_open_input(&ic, filename, NULL, NULL);
681    if (err < 0)
682        return err;
683    /* copy stream format */
684    for(i=0;i<ic->nb_streams;i++) {
685        AVStream *st;
686        OutputStream *ost;
687        AVCodec *codec;
688
689        codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
690        ost   = new_output_stream(s, nb_output_files, codec);
691        st    = ost->st;
692
693        // FIXME: a more elegant solution is needed
694        memcpy(st, ic->streams[i], sizeof(AVStream));
695        st->info = NULL;
696        avcodec_copy_context(st->codec, ic->streams[i]->codec);
697
698        if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
699            if (audio_stream_copy) {
700                st->stream_copy = 1;
701            } else
702                choose_sample_fmt(st, codec);
703        } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
704            if (video_stream_copy) {
705                st->stream_copy = 1;
706            } else
707                choose_pixel_fmt(st, codec);
708        }
709    }
710
711    av_close_input_file(ic);
712    return 0;
713}
714
715static double
716get_sync_ipts(const OutputStream *ost)
717{
718    const InputStream *ist = ost->sync_ist;
719    return (double)(ist->pts - start_time)/AV_TIME_BASE;
720}
721
722static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
723    int ret;
724
725    while(bsfc){
726        AVPacket new_pkt= *pkt;
727        int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
728                                          &new_pkt.data, &new_pkt.size,
729                                          pkt->data, pkt->size,
730                                          pkt->flags & AV_PKT_FLAG_KEY);
731        if(a>0){
732            av_free_packet(pkt);
733            new_pkt.destruct= av_destruct_packet;
734        } else if(a<0){
735            fprintf(stderr, "%s failed for stream %d, codec %s",
736                    bsfc->filter->name, pkt->stream_index,
737                    avctx->codec ? avctx->codec->name : "copy");
738            print_error("", a);
739            if (exit_on_error)
740                exit_program(1);
741        }
742        *pkt= new_pkt;
743
744        bsfc= bsfc->next;
745    }
746
747    ret= av_interleaved_write_frame(s, pkt);
748    if(ret < 0){
749        print_error("av_interleaved_write_frame()", ret);
750        exit_program(1);
751    }
752}
753
754#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
755
756static void do_audio_out(AVFormatContext *s,
757                         OutputStream *ost,
758                         InputStream *ist,
759                         unsigned char *buf, int size)
760{
761    uint8_t *buftmp;
762    int64_t audio_out_size, audio_buf_size;
763    int64_t allocated_for_size= size;
764
765    int size_out, frame_bytes, ret, resample_changed;
766    AVCodecContext *enc= ost->st->codec;
767    AVCodecContext *dec= ist->st->codec;
768    int osize = av_get_bytes_per_sample(enc->sample_fmt);
769    int isize = av_get_bytes_per_sample(dec->sample_fmt);
770    const int coded_bps = av_get_bits_per_sample(enc->codec->id);
771
772need_realloc:
773    audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
774    audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
775    audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
776    audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
777    audio_buf_size*= osize*enc->channels;
778
779    audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
780    if(coded_bps > 8*osize)
781        audio_out_size= audio_out_size * coded_bps / (8*osize);
782    audio_out_size += FF_MIN_BUFFER_SIZE;
783
784    if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
785        fprintf(stderr, "Buffer sizes too large\n");
786        exit_program(1);
787    }
788
789    av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
790    av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
791    if (!audio_buf || !audio_out){
792        fprintf(stderr, "Out of memory in do_audio_out\n");
793        exit_program(1);
794    }
795
796    if (enc->channels != dec->channels || enc->sample_rate != dec->sample_rate)
797        ost->audio_resample = 1;
798
799    resample_changed = ost->resample_sample_fmt  != dec->sample_fmt ||
800                       ost->resample_channels    != dec->channels   ||
801                       ost->resample_sample_rate != dec->sample_rate;
802
803    if ((ost->audio_resample && !ost->resample) || resample_changed) {
804        if (resample_changed) {
805            av_log(NULL, AV_LOG_INFO, "Input stream #%d.%d frame changed from rate:%d fmt:%s ch:%d to rate:%d fmt:%s ch:%d\n",
806                   ist->file_index, ist->st->index,
807                   ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
808                   dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
809            ost->resample_sample_fmt  = dec->sample_fmt;
810            ost->resample_channels    = dec->channels;
811            ost->resample_sample_rate = dec->sample_rate;
812            if (ost->resample)
813                audio_resample_close(ost->resample);
814        }
815        /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
816        if (audio_sync_method <= 1 &&
817            ost->resample_sample_fmt  == enc->sample_fmt &&
818            ost->resample_channels    == enc->channels   &&
819            ost->resample_sample_rate == enc->sample_rate) {
820            ost->resample = NULL;
821            ost->audio_resample = 0;
822        } else if (ost->audio_resample) {
823            if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
824                fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
825            ost->resample = av_audio_resample_init(enc->channels,    dec->channels,
826                                                   enc->sample_rate, dec->sample_rate,
827                                                   enc->sample_fmt,  dec->sample_fmt,
828                                                   16, 10, 0, 0.8);
829            if (!ost->resample) {
830                fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
831                        dec->channels, dec->sample_rate,
832                        enc->channels, enc->sample_rate);
833                exit_program(1);
834            }
835        }
836    }
837
838#define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
839    if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
840        MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
841        if (ost->reformat_ctx)
842            av_audio_convert_free(ost->reformat_ctx);
843        ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
844                                                   dec->sample_fmt, 1, NULL, 0);
845        if (!ost->reformat_ctx) {
846            fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
847                av_get_sample_fmt_name(dec->sample_fmt),
848                av_get_sample_fmt_name(enc->sample_fmt));
849            exit_program(1);
850        }
851        ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
852    }
853
854    if(audio_sync_method){
855        double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
856                - av_fifo_size(ost->fifo)/(enc->channels * 2);
857        double idelta= delta*dec->sample_rate / enc->sample_rate;
858        int byte_delta= ((int)idelta)*2*dec->channels;
859
860        //FIXME resample delay
861        if(fabs(delta) > 50){
862            if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
863                if(byte_delta < 0){
864                    byte_delta= FFMAX(byte_delta, -size);
865                    size += byte_delta;
866                    buf  -= byte_delta;
867                    if(verbose > 2)
868                        fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
869                    if(!size)
870                        return;
871                    ist->is_start=0;
872                }else{
873                    static uint8_t *input_tmp= NULL;
874                    input_tmp= av_realloc(input_tmp, byte_delta + size);
875
876                    if(byte_delta > allocated_for_size - size){
877                        allocated_for_size= byte_delta + (int64_t)size;
878                        goto need_realloc;
879                    }
880                    ist->is_start=0;
881
882                    memset(input_tmp, 0, byte_delta);
883                    memcpy(input_tmp + byte_delta, buf, size);
884                    buf= input_tmp;
885                    size += byte_delta;
886                    if(verbose > 2)
887                        fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
888                }
889            }else if(audio_sync_method>1){
890                int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
891                av_assert0(ost->audio_resample);
892                if(verbose > 2)
893                    fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
894//                fprintf(stderr, "drift:%f len:%d opts:%"PRId64" ipts:%"PRId64" fifo:%d\n", delta, -1, ost->sync_opts, (int64_t)(get_sync_ipts(ost) * enc->sample_rate), av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2));
895                av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
896            }
897        }
898    }else
899        ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
900                        - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
901
902    if (ost->audio_resample) {
903        buftmp = audio_buf;
904        size_out = audio_resample(ost->resample,
905                                  (short *)buftmp, (short *)buf,
906                                  size / (dec->channels * isize));
907        size_out = size_out * enc->channels * osize;
908    } else {
909        buftmp = buf;
910        size_out = size;
911    }
912
913    if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
914        const void *ibuf[6]= {buftmp};
915        void *obuf[6]= {audio_buf};
916        int istride[6]= {isize};
917        int ostride[6]= {osize};
918        int len= size_out/istride[0];
919        if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
920            printf("av_audio_convert() failed\n");
921            if (exit_on_error)
922                exit_program(1);
923            return;
924        }
925        buftmp = audio_buf;
926        size_out = len*osize;
927    }
928
929    /* now encode as many frames as possible */
930    if (enc->frame_size > 1) {
931        /* output resampled raw samples */
932        if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
933            fprintf(stderr, "av_fifo_realloc2() failed\n");
934            exit_program(1);
935        }
936        av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
937
938        frame_bytes = enc->frame_size * osize * enc->channels;
939
940        while (av_fifo_size(ost->fifo) >= frame_bytes) {
941            AVPacket pkt;
942            av_init_packet(&pkt);
943
944            av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
945
946            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
947
948            ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
949                                       (short *)audio_buf);
950            if (ret < 0) {
951                fprintf(stderr, "Audio encoding failed\n");
952                exit_program(1);
953            }
954            audio_size += ret;
955            pkt.stream_index= ost->index;
956            pkt.data= audio_out;
957            pkt.size= ret;
958            if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
959                pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
960            pkt.flags |= AV_PKT_FLAG_KEY;
961            write_frame(s, &pkt, enc, ost->bitstream_filters);
962
963            ost->sync_opts += enc->frame_size;
964        }
965    } else {
966        AVPacket pkt;
967        av_init_packet(&pkt);
968
969        ost->sync_opts += size_out / (osize * enc->channels);
970
971        /* output a pcm frame */
972        /* determine the size of the coded buffer */
973        size_out /= osize;
974        if (coded_bps)
975            size_out = size_out*coded_bps/8;
976
977        if(size_out > audio_out_size){
978            fprintf(stderr, "Internal error, buffer size too small\n");
979            exit_program(1);
980        }
981
982        //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
983        ret = avcodec_encode_audio(enc, audio_out, size_out,
984                                   (short *)buftmp);
985        if (ret < 0) {
986            fprintf(stderr, "Audio encoding failed\n");
987            exit_program(1);
988        }
989        audio_size += ret;
990        pkt.stream_index= ost->index;
991        pkt.data= audio_out;
992        pkt.size= ret;
993        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
994            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
995        pkt.flags |= AV_PKT_FLAG_KEY;
996        write_frame(s, &pkt, enc, ost->bitstream_filters);
997    }
998}
999
1000static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
1001{
1002    AVCodecContext *dec;
1003    AVPicture *picture2;
1004    AVPicture picture_tmp;
1005    uint8_t *buf = 0;
1006
1007    dec = ist->st->codec;
1008
1009    /* deinterlace : must be done before any resize */
1010    if (do_deinterlace) {
1011        int size;
1012
1013        /* create temporary picture */
1014        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1015        buf = av_malloc(size);
1016        if (!buf)
1017            return;
1018
1019        picture2 = &picture_tmp;
1020        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1021
1022        if(avpicture_deinterlace(picture2, picture,
1023                                 dec->pix_fmt, dec->width, dec->height) < 0) {
1024            /* if error, do not deinterlace */
1025            fprintf(stderr, "Deinterlacing failed\n");
1026            av_free(buf);
1027            buf = NULL;
1028            picture2 = picture;
1029        }
1030    } else {
1031        picture2 = picture;
1032    }
1033
1034    if (picture != picture2)
1035        *picture = *picture2;
1036    *bufp = buf;
1037}
1038
1039/* we begin to correct av delay at this threshold */
1040#define AV_DELAY_MAX 0.100
1041
1042static void do_subtitle_out(AVFormatContext *s,
1043                            OutputStream *ost,
1044                            InputStream *ist,
1045                            AVSubtitle *sub,
1046                            int64_t pts)
1047{
1048    static uint8_t *subtitle_out = NULL;
1049    int subtitle_out_max_size = 1024 * 1024;
1050    int subtitle_out_size, nb, i;
1051    AVCodecContext *enc;
1052    AVPacket pkt;
1053
1054    if (pts == AV_NOPTS_VALUE) {
1055        fprintf(stderr, "Subtitle packets must have a pts\n");
1056        if (exit_on_error)
1057            exit_program(1);
1058        return;
1059    }
1060
1061    enc = ost->st->codec;
1062
1063    if (!subtitle_out) {
1064        subtitle_out = av_malloc(subtitle_out_max_size);
1065    }
1066
1067    /* Note: DVB subtitle need one packet to draw them and one other
1068       packet to clear them */
1069    /* XXX: signal it in the codec context ? */
1070    if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1071        nb = 2;
1072    else
1073        nb = 1;
1074
1075    for(i = 0; i < nb; i++) {
1076        sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1077        // start_display_time is required to be 0
1078        sub->pts              += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1079        sub->end_display_time -= sub->start_display_time;
1080        sub->start_display_time = 0;
1081        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1082                                                    subtitle_out_max_size, sub);
1083        if (subtitle_out_size < 0) {
1084            fprintf(stderr, "Subtitle encoding failed\n");
1085            exit_program(1);
1086        }
1087
1088        av_init_packet(&pkt);
1089        pkt.stream_index = ost->index;
1090        pkt.data = subtitle_out;
1091        pkt.size = subtitle_out_size;
1092        pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1093        if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1094            /* XXX: the pts correction is handled here. Maybe handling
1095               it in the codec would be better */
1096            if (i == 0)
1097                pkt.pts += 90 * sub->start_display_time;
1098            else
1099                pkt.pts += 90 * sub->end_display_time;
1100        }
1101        write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1102    }
1103}
1104
1105static int bit_buffer_size= 1024*256;
1106static uint8_t *bit_buffer= NULL;
1107
1108static void do_video_out(AVFormatContext *s,
1109                         OutputStream *ost,
1110                         InputStream *ist,
1111                         AVFrame *in_picture,
1112                         int *frame_size, float quality)
1113{
1114    int nb_frames, i, ret, resample_changed;
1115    AVFrame *final_picture, *formatted_picture;
1116    AVCodecContext *enc, *dec;
1117    double sync_ipts;
1118
1119    enc = ost->st->codec;
1120    dec = ist->st->codec;
1121
1122    sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1123
1124    /* by default, we output a single frame */
1125    nb_frames = 1;
1126
1127    *frame_size = 0;
1128
1129    if(video_sync_method){
1130        double vdelta = sync_ipts - ost->sync_opts;
1131        //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1132        if (vdelta < -1.1)
1133            nb_frames = 0;
1134        else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
1135            if(vdelta<=-0.6){
1136                nb_frames=0;
1137            }else if(vdelta>0.6)
1138                ost->sync_opts= lrintf(sync_ipts);
1139        }else if (vdelta > 1.1)
1140            nb_frames = lrintf(vdelta);
1141//fprintf(stderr, "vdelta:%f, ost->sync_opts:%"PRId64", ost->sync_ipts:%f nb_frames:%d\n", vdelta, ost->sync_opts, get_sync_ipts(ost), nb_frames);
1142        if (nb_frames == 0){
1143            ++nb_frames_drop;
1144            if (verbose>2)
1145                fprintf(stderr, "*** drop!\n");
1146        }else if (nb_frames > 1) {
1147            nb_frames_dup += nb_frames - 1;
1148            if (verbose>2)
1149                fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1150        }
1151    }else
1152        ost->sync_opts= lrintf(sync_ipts);
1153
1154    nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1155    if (nb_frames <= 0)
1156        return;
1157
1158    formatted_picture = in_picture;
1159    final_picture = formatted_picture;
1160
1161    resample_changed = ost->resample_width   != dec->width  ||
1162                       ost->resample_height  != dec->height ||
1163                       ost->resample_pix_fmt != dec->pix_fmt;
1164
1165    if (resample_changed) {
1166        av_log(NULL, AV_LOG_INFO,
1167               "Input stream #%d.%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1168               ist->file_index, ist->st->index,
1169               ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
1170               dec->width         , dec->height         , av_get_pix_fmt_name(dec->pix_fmt));
1171        if(!ost->video_resample)
1172            exit_program(1);
1173    }
1174
1175#if !CONFIG_AVFILTER
1176    if (ost->video_resample) {
1177        final_picture = &ost->pict_tmp;
1178        if (resample_changed) {
1179            /* initialize a new scaler context */
1180            sws_freeContext(ost->img_resample_ctx);
1181            ost->img_resample_ctx = sws_getContext(
1182                ist->st->codec->width,
1183                ist->st->codec->height,
1184                ist->st->codec->pix_fmt,
1185                ost->st->codec->width,
1186                ost->st->codec->height,
1187                ost->st->codec->pix_fmt,
1188                ost->sws_flags, NULL, NULL, NULL);
1189            if (ost->img_resample_ctx == NULL) {
1190                fprintf(stderr, "Cannot get resampling context\n");
1191                exit_program(1);
1192            }
1193        }
1194        sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1195              0, ost->resample_height, final_picture->data, final_picture->linesize);
1196    }
1197#endif
1198
1199    /* duplicates frame if needed */
1200    for(i=0;i<nb_frames;i++) {
1201        AVPacket pkt;
1202        av_init_packet(&pkt);
1203        pkt.stream_index= ost->index;
1204
1205        if (s->oformat->flags & AVFMT_RAWPICTURE) {
1206            /* raw pictures are written as AVPicture structure to
1207               avoid any copies. We support temorarily the older
1208               method. */
1209            AVFrame* old_frame = enc->coded_frame;
1210            enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1211            pkt.data= (uint8_t *)final_picture;
1212            pkt.size=  sizeof(AVPicture);
1213            pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1214            pkt.flags |= AV_PKT_FLAG_KEY;
1215
1216            write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1217            enc->coded_frame = old_frame;
1218        } else {
1219            AVFrame big_picture;
1220
1221            big_picture= *final_picture;
1222            /* better than nothing: use input picture interlaced
1223               settings */
1224            big_picture.interlaced_frame = in_picture->interlaced_frame;
1225            if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1226                if(top_field_first == -1)
1227                    big_picture.top_field_first = in_picture->top_field_first;
1228                else
1229                    big_picture.top_field_first = top_field_first;
1230            }
1231
1232            /* handles sameq here. This is not correct because it may
1233               not be a global option */
1234            big_picture.quality = quality;
1235            if(!me_threshold)
1236                big_picture.pict_type = 0;
1237//            big_picture.pts = AV_NOPTS_VALUE;
1238            big_picture.pts= ost->sync_opts;
1239//            big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1240//av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1241            if (ost->forced_kf_index < ost->forced_kf_count &&
1242                big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1243                big_picture.pict_type = AV_PICTURE_TYPE_I;
1244                ost->forced_kf_index++;
1245            }
1246            ret = avcodec_encode_video(enc,
1247                                       bit_buffer, bit_buffer_size,
1248                                       &big_picture);
1249            if (ret < 0) {
1250                fprintf(stderr, "Video encoding failed\n");
1251                exit_program(1);
1252            }
1253
1254            if(ret>0){
1255                pkt.data= bit_buffer;
1256                pkt.size= ret;
1257                if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1258                    pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1259/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1260   pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1261   pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1262
1263                if(enc->coded_frame->key_frame)
1264                    pkt.flags |= AV_PKT_FLAG_KEY;
1265                write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1266                *frame_size = ret;
1267                video_size += ret;
1268                //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1269                //        enc->frame_number-1, ret, enc->pict_type);
1270                /* if two pass, output log */
1271                if (ost->logfile && enc->stats_out) {
1272                    fprintf(ost->logfile, "%s", enc->stats_out);
1273                }
1274            }
1275        }
1276        ost->sync_opts++;
1277        ost->frame_number++;
1278    }
1279}
1280
1281static double psnr(double d){
1282    return -10.0*log(d)/log(10.0);
1283}
1284
1285static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1286                           int frame_size)
1287{
1288    AVCodecContext *enc;
1289    int frame_number;
1290    double ti1, bitrate, avg_bitrate;
1291
1292    /* this is executed just the first time do_video_stats is called */
1293    if (!vstats_file) {
1294        vstats_file = fopen(vstats_filename, "w");
1295        if (!vstats_file) {
1296            perror("fopen");
1297            exit_program(1);
1298        }
1299    }
1300
1301    enc = ost->st->codec;
1302    if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1303        frame_number = ost->frame_number;
1304        fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1305        if (enc->flags&CODEC_FLAG_PSNR)
1306            fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1307
1308        fprintf(vstats_file,"f_size= %6d ", frame_size);
1309        /* compute pts value */
1310        ti1 = ost->sync_opts * av_q2d(enc->time_base);
1311        if (ti1 < 0.01)
1312            ti1 = 0.01;
1313
1314        bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1315        avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1316        fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1317            (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1318        fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1319    }
1320}
1321
1322static void print_report(AVFormatContext **output_files,
1323                         OutputStream **ost_table, int nb_ostreams,
1324                         int is_last_report)
1325{
1326    char buf[1024];
1327    OutputStream *ost;
1328    AVFormatContext *oc;
1329    int64_t total_size;
1330    AVCodecContext *enc;
1331    int frame_number, vid, i;
1332    double bitrate, ti1, pts;
1333    static int64_t last_time = -1;
1334    static int qp_histogram[52];
1335
1336    if (!is_last_report) {
1337        int64_t cur_time;
1338        /* display the report every 0.5 seconds */
1339        cur_time = av_gettime();
1340        if (last_time == -1) {
1341            last_time = cur_time;
1342            return;
1343        }
1344        if ((cur_time - last_time) < 500000)
1345            return;
1346        last_time = cur_time;
1347    }
1348
1349
1350    oc = output_files[0];
1351
1352    total_size = avio_size(oc->pb);
1353    if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1354        total_size= avio_tell(oc->pb);
1355
1356    buf[0] = '\0';
1357    ti1 = 1e10;
1358    vid = 0;
1359    for(i=0;i<nb_ostreams;i++) {
1360        float q = -1;
1361        ost = ost_table[i];
1362        enc = ost->st->codec;
1363        if (!ost->st->stream_copy && enc->coded_frame)
1364            q = enc->coded_frame->quality/(float)FF_QP2LAMBDA;
1365        if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1366            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1367        }
1368        if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1369            float t = (av_gettime()-timer_start) / 1000000.0;
1370
1371            frame_number = ost->frame_number;
1372            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1373                     frame_number, (t>1)?(int)(frame_number/t+0.5) : 0, q);
1374            if(is_last_report)
1375                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1376            if(qp_hist){
1377                int j;
1378                int qp = lrintf(q);
1379                if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1380                    qp_histogram[qp]++;
1381                for(j=0; j<32; j++)
1382                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1383            }
1384            if (enc->flags&CODEC_FLAG_PSNR){
1385                int j;
1386                double error, error_sum=0;
1387                double scale, scale_sum=0;
1388                char type[3]= {'Y','U','V'};
1389                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1390                for(j=0; j<3; j++){
1391                    if(is_last_report){
1392                        error= enc->error[j];
1393                        scale= enc->width*enc->height*255.0*255.0*frame_number;
1394                    }else{
1395                        error= enc->coded_frame->error[j];
1396                        scale= enc->width*enc->height*255.0*255.0;
1397                    }
1398                    if(j) scale/=4;
1399                    error_sum += error;
1400                    scale_sum += scale;
1401                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1402                }
1403                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1404            }
1405            vid = 1;
1406        }
1407        /* compute min output value */
1408        pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1409        if ((pts < ti1) && (pts > 0))
1410            ti1 = pts;
1411    }
1412    if (ti1 < 0.01)
1413        ti1 = 0.01;
1414
1415    if (verbose > 0 || is_last_report) {
1416        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1417
1418        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1419            "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1420            (double)total_size / 1024, ti1, bitrate);
1421
1422        if (nb_frames_dup || nb_frames_drop)
1423          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1424                  nb_frames_dup, nb_frames_drop);
1425
1426        if (verbose >= 0)
1427            fprintf(stderr, "%s    \r", buf);
1428
1429        fflush(stderr);
1430    }
1431
1432    if (is_last_report && verbose >= 0){
1433        int64_t raw= audio_size + video_size + extra_size;
1434        fprintf(stderr, "\n");
1435        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1436                video_size/1024.0,
1437                audio_size/1024.0,
1438                extra_size/1024.0,
1439                100.0*(total_size - raw)/raw
1440        );
1441    }
1442}
1443
1444static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
1445{
1446    int fill_char = 0x00;
1447    if (sample_fmt == AV_SAMPLE_FMT_U8)
1448        fill_char = 0x80;
1449    memset(buf, fill_char, size);
1450}
1451
1452/* pkt = NULL means EOF (needed to flush decoder buffers) */
1453static int output_packet(InputStream *ist, int ist_index,
1454                         OutputStream **ost_table, int nb_ostreams,
1455                         const AVPacket *pkt)
1456{
1457    AVFormatContext *os;
1458    OutputStream *ost;
1459    int ret, i;
1460    int got_output;
1461    AVFrame picture;
1462    void *buffer_to_free = NULL;
1463    static unsigned int samples_size= 0;
1464    AVSubtitle subtitle, *subtitle_to_free;
1465    int64_t pkt_pts = AV_NOPTS_VALUE;
1466#if CONFIG_AVFILTER
1467    int frame_available;
1468#endif
1469    float quality;
1470
1471    AVPacket avpkt;
1472    int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
1473
1474    if(ist->next_pts == AV_NOPTS_VALUE)
1475        ist->next_pts= ist->pts;
1476
1477    if (pkt == NULL) {
1478        /* EOF handling */
1479        av_init_packet(&avpkt);
1480        avpkt.data = NULL;
1481        avpkt.size = 0;
1482        goto handle_eof;
1483    } else {
1484        avpkt = *pkt;
1485    }
1486
1487    if(pkt->dts != AV_NOPTS_VALUE)
1488        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1489    if(pkt->pts != AV_NOPTS_VALUE)
1490        pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1491
1492    //while we have more to decode or while the decoder did output something on EOF
1493    while (avpkt.size > 0 || (!pkt && got_output)) {
1494        uint8_t *data_buf, *decoded_data_buf;
1495        int data_size, decoded_data_size;
1496    handle_eof:
1497        ist->pts= ist->next_pts;
1498
1499        if(avpkt.size && avpkt.size != pkt->size &&
1500           ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1501            fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1502            ist->showed_multi_packet_warning=1;
1503        }
1504
1505        /* decode the packet if needed */
1506        decoded_data_buf = NULL; /* fail safe */
1507        decoded_data_size= 0;
1508        data_buf  = avpkt.data;
1509        data_size = avpkt.size;
1510        subtitle_to_free = NULL;
1511        if (ist->decoding_needed) {
1512            switch(ist->st->codec->codec_type) {
1513            case AVMEDIA_TYPE_AUDIO:{
1514                if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1515                    samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1516                    av_free(samples);
1517                    samples= av_malloc(samples_size);
1518                }
1519                decoded_data_size= samples_size;
1520                    /* XXX: could avoid copy if PCM 16 bits with same
1521                       endianness as CPU */
1522                ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1523                                            &avpkt);
1524                if (ret < 0)
1525                    return ret;
1526                avpkt.data += ret;
1527                avpkt.size -= ret;
1528                data_size   = ret;
1529                got_output  = decoded_data_size > 0;
1530                /* Some bug in mpeg audio decoder gives */
1531                /* decoded_data_size < 0, it seems they are overflows */
1532                if (!got_output) {
1533                    /* no audio frame */
1534                    continue;
1535                }
1536                decoded_data_buf = (uint8_t *)samples;
1537                ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1538                    (ist->st->codec->sample_rate * ist->st->codec->channels);
1539                break;}
1540            case AVMEDIA_TYPE_VIDEO:
1541                    decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1542                    /* XXX: allocate picture correctly */
1543                    avcodec_get_frame_defaults(&picture);
1544                    avpkt.pts = pkt_pts;
1545                    avpkt.dts = ist->pts;
1546                    pkt_pts = AV_NOPTS_VALUE;
1547
1548                    ret = avcodec_decode_video2(ist->st->codec,
1549                                                &picture, &got_output, &avpkt);
1550                    quality = same_quality ? picture.quality : 0;
1551                    if (ret < 0)
1552                        return ret;
1553                    if (!got_output) {
1554                        /* no picture yet */
1555                        goto discard_packet;
1556                    }
1557                    ist->next_pts = ist->pts = guess_correct_pts(&ist->pts_ctx, picture.pkt_pts, picture.pkt_dts);
1558                    if (ist->st->codec->time_base.num != 0) {
1559                        int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1560                        ist->next_pts += ((int64_t)AV_TIME_BASE *
1561                                          ist->st->codec->time_base.num * ticks) /
1562                            ist->st->codec->time_base.den;
1563                    }
1564                    avpkt.size = 0;
1565                    buffer_to_free = NULL;
1566                    pre_process_video_frame(ist, (AVPicture *)&picture, &buffer_to_free);
1567                    break;
1568            case AVMEDIA_TYPE_SUBTITLE:
1569                ret = avcodec_decode_subtitle2(ist->st->codec,
1570                                               &subtitle, &got_output, &avpkt);
1571                if (ret < 0)
1572                    return ret;
1573                if (!got_output) {
1574                    goto discard_packet;
1575                }
1576                subtitle_to_free = &subtitle;
1577                avpkt.size = 0;
1578                break;
1579            default:
1580                return -1;
1581            }
1582        } else {
1583            switch(ist->st->codec->codec_type) {
1584            case AVMEDIA_TYPE_AUDIO:
1585                ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1586                    ist->st->codec->sample_rate;
1587                break;
1588            case AVMEDIA_TYPE_VIDEO:
1589                if (ist->st->codec->time_base.num != 0) {
1590                    int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1591                    ist->next_pts += ((int64_t)AV_TIME_BASE *
1592                                      ist->st->codec->time_base.num * ticks) /
1593                        ist->st->codec->time_base.den;
1594                }
1595                break;
1596            }
1597            ret = avpkt.size;
1598            avpkt.size = 0;
1599        }
1600
1601#if CONFIG_AVFILTER
1602        if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1603            for (i = 0; i < nb_ostreams; i++) {
1604                ost = ost_table[i];
1605                if (ost->input_video_filter && ost->source_index == ist_index) {
1606                    AVRational sar;
1607                    if (ist->st->sample_aspect_ratio.num)
1608                        sar = ist->st->sample_aspect_ratio;
1609                    else
1610                        sar = ist->st->codec->sample_aspect_ratio;
1611                    // add it to be filtered
1612                    av_vsrc_buffer_add_frame(ost->input_video_filter, &picture,
1613                                             ist->pts,
1614                                             sar);
1615                }
1616            }
1617        }
1618#endif
1619
1620        // preprocess audio (volume)
1621        if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1622            if (audio_volume != 256) {
1623                short *volp;
1624                volp = samples;
1625                for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1626                    int v = ((*volp) * audio_volume + 128) >> 8;
1627                    if (v < -32768) v = -32768;
1628                    if (v >  32767) v = 32767;
1629                    *volp++ = v;
1630                }
1631            }
1632        }
1633
1634        /* frame rate emulation */
1635        if (rate_emu) {
1636            int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1637            int64_t now = av_gettime() - ist->start;
1638            if (pts > now)
1639                usleep(pts - now);
1640        }
1641        /* if output time reached then transcode raw format,
1642           encode packets and output them */
1643        if (start_time == 0 || ist->pts >= start_time)
1644            for(i=0;i<nb_ostreams;i++) {
1645                int frame_size;
1646
1647                ost = ost_table[i];
1648                if (ost->source_index == ist_index) {
1649#if CONFIG_AVFILTER
1650                frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1651                    !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1652                while (frame_available) {
1653                    AVRational ist_pts_tb;
1654                    if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter)
1655                        get_filtered_video_frame(ost->output_video_filter, &picture, &ost->picref, &ist_pts_tb);
1656                    if (ost->picref)
1657                        ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1658#endif
1659                    os = output_files[ost->file_index];
1660
1661                    /* set the input output pts pairs */
1662                    //ost->sync_ipts = (double)(ist->pts + input_files[ist->file_index].ts_offset - start_time)/ AV_TIME_BASE;
1663
1664                    if (ost->encoding_needed) {
1665                        av_assert0(ist->decoding_needed);
1666                        switch(ost->st->codec->codec_type) {
1667                        case AVMEDIA_TYPE_AUDIO:
1668                            do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1669                            break;
1670                        case AVMEDIA_TYPE_VIDEO:
1671#if CONFIG_AVFILTER
1672                            if (ost->picref->video && !ost->frame_aspect_ratio)
1673                                ost->st->codec->sample_aspect_ratio = ost->picref->video->pixel_aspect;
1674#endif
1675                            do_video_out(os, ost, ist, &picture, &frame_size,
1676                                         same_quality ? quality : ost->st->codec->global_quality);
1677                            if (vstats_filename && frame_size)
1678                                do_video_stats(os, ost, frame_size);
1679                            break;
1680                        case AVMEDIA_TYPE_SUBTITLE:
1681                            do_subtitle_out(os, ost, ist, &subtitle,
1682                                            pkt->pts);
1683                            break;
1684                        default:
1685                            abort();
1686                        }
1687                    } else {
1688                        AVFrame avframe; //FIXME/XXX remove this
1689                        AVPacket opkt;
1690                        int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1691
1692                        av_init_packet(&opkt);
1693
1694                        if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1695#if !CONFIG_AVFILTER
1696                            continue;
1697#else
1698                            goto cont;
1699#endif
1700
1701                        /* no reencoding needed : output the packet directly */
1702                        /* force the input stream PTS */
1703
1704                        avcodec_get_frame_defaults(&avframe);
1705                        ost->st->codec->coded_frame= &avframe;
1706                        avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1707
1708                        if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1709                            audio_size += data_size;
1710                        else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1711                            video_size += data_size;
1712                            ost->sync_opts++;
1713                        }
1714
1715                        opkt.stream_index= ost->index;
1716                        if(pkt->pts != AV_NOPTS_VALUE)
1717                            opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1718                        else
1719                            opkt.pts= AV_NOPTS_VALUE;
1720
1721                        if (pkt->dts == AV_NOPTS_VALUE)
1722                            opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1723                        else
1724                            opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1725                        opkt.dts -= ost_tb_start_time;
1726
1727                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1728                        opkt.flags= pkt->flags;
1729
1730                        //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1731                        if(   ost->st->codec->codec_id != CODEC_ID_H264
1732                           && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1733                           && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1734                           ) {
1735                            if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1736                                opkt.destruct= av_destruct_packet;
1737                        } else {
1738                            opkt.data = data_buf;
1739                            opkt.size = data_size;
1740                        }
1741
1742                        write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1743                        ost->st->codec->frame_number++;
1744                        ost->frame_number++;
1745                        av_free_packet(&opkt);
1746                    }
1747#if CONFIG_AVFILTER
1748                    cont:
1749                    frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1750                                       ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1751                    if (ost->picref)
1752                        avfilter_unref_buffer(ost->picref);
1753                }
1754#endif
1755                }
1756            }
1757
1758        av_free(buffer_to_free);
1759        /* XXX: allocate the subtitles in the codec ? */
1760        if (subtitle_to_free) {
1761            avsubtitle_free(subtitle_to_free);
1762            subtitle_to_free = NULL;
1763        }
1764    }
1765 discard_packet:
1766    if (pkt == NULL) {
1767        /* EOF handling */
1768
1769        for(i=0;i<nb_ostreams;i++) {
1770            ost = ost_table[i];
1771            if (ost->source_index == ist_index) {
1772                AVCodecContext *enc= ost->st->codec;
1773                os = output_files[ost->file_index];
1774
1775                if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1776                    continue;
1777                if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1778                    continue;
1779
1780                if (ost->encoding_needed) {
1781                    for(;;) {
1782                        AVPacket pkt;
1783                        int fifo_bytes;
1784                        av_init_packet(&pkt);
1785                        pkt.stream_index= ost->index;
1786
1787                        switch(ost->st->codec->codec_type) {
1788                        case AVMEDIA_TYPE_AUDIO:
1789                            fifo_bytes = av_fifo_size(ost->fifo);
1790                            ret = 0;
1791                            /* encode any samples remaining in fifo */
1792                            if (fifo_bytes > 0) {
1793                                int osize = av_get_bytes_per_sample(enc->sample_fmt);
1794                                int fs_tmp = enc->frame_size;
1795
1796                                av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1797                                if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1798                                    enc->frame_size = fifo_bytes / (osize * enc->channels);
1799                                } else { /* pad */
1800                                    int frame_bytes = enc->frame_size*osize*enc->channels;
1801                                    if (allocated_audio_buf_size < frame_bytes)
1802                                        exit_program(1);
1803                                    generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1804                                }
1805
1806                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1807                                pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1808                                                          ost->st->time_base.num, enc->sample_rate);
1809                                enc->frame_size = fs_tmp;
1810                            }
1811                            if(ret <= 0) {
1812                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1813                            }
1814                            if (ret < 0) {
1815                                fprintf(stderr, "Audio encoding failed\n");
1816                                exit_program(1);
1817                            }
1818                            audio_size += ret;
1819                            pkt.flags |= AV_PKT_FLAG_KEY;
1820                            break;
1821                        case AVMEDIA_TYPE_VIDEO:
1822                            ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1823                            if (ret < 0) {
1824                                fprintf(stderr, "Video encoding failed\n");
1825                                exit_program(1);
1826                            }
1827                            video_size += ret;
1828                            if(enc->coded_frame && enc->coded_frame->key_frame)
1829                                pkt.flags |= AV_PKT_FLAG_KEY;
1830                            if (ost->logfile && enc->stats_out) {
1831                                fprintf(ost->logfile, "%s", enc->stats_out);
1832                            }
1833                            break;
1834                        default:
1835                            ret=-1;
1836                        }
1837
1838                        if(ret<=0)
1839                            break;
1840                        pkt.data= bit_buffer;
1841                        pkt.size= ret;
1842                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1843                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1844                        write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1845                    }
1846                }
1847            }
1848        }
1849    }
1850
1851    return 0;
1852}
1853
1854static void print_sdp(AVFormatContext **avc, int n)
1855{
1856    char sdp[2048];
1857
1858    av_sdp_create(avc, n, sdp, sizeof(sdp));
1859    printf("SDP:\n%s\n", sdp);
1860    fflush(stdout);
1861}
1862
1863static int copy_chapters(int infile, int outfile)
1864{
1865    AVFormatContext *is = input_files[infile].ctx;
1866    AVFormatContext *os = output_files[outfile];
1867    int i;
1868
1869    for (i = 0; i < is->nb_chapters; i++) {
1870        AVChapter *in_ch = is->chapters[i], *out_ch;
1871        int64_t ts_off   = av_rescale_q(start_time - input_files[infile].ts_offset,
1872                                      AV_TIME_BASE_Q, in_ch->time_base);
1873        int64_t rt       = (recording_time == INT64_MAX) ? INT64_MAX :
1874                           av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1875
1876
1877        if (in_ch->end < ts_off)
1878            continue;
1879        if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1880            break;
1881
1882        out_ch = av_mallocz(sizeof(AVChapter));
1883        if (!out_ch)
1884            return AVERROR(ENOMEM);
1885
1886        out_ch->id        = in_ch->id;
1887        out_ch->time_base = in_ch->time_base;
1888        out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1889        out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1890
1891        if (metadata_chapters_autocopy)
1892            av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1893
1894        os->nb_chapters++;
1895        os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1896        if (!os->chapters)
1897            return AVERROR(ENOMEM);
1898        os->chapters[os->nb_chapters - 1] = out_ch;
1899    }
1900    return 0;
1901}
1902
1903static void parse_forced_key_frames(char *kf, OutputStream *ost,
1904                                    AVCodecContext *avctx)
1905{
1906    char *p;
1907    int n = 1, i;
1908    int64_t t;
1909
1910    for (p = kf; *p; p++)
1911        if (*p == ',')
1912            n++;
1913    ost->forced_kf_count = n;
1914    ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
1915    if (!ost->forced_kf_pts) {
1916        av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
1917        exit_program(1);
1918    }
1919    for (i = 0; i < n; i++) {
1920        p = i ? strchr(p, ',') + 1 : kf;
1921        t = parse_time_or_die("force_key_frames", p, 1);
1922        ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
1923    }
1924}
1925
1926/*
1927 * The following code is the main loop of the file converter
1928 */
1929static int transcode(AVFormatContext **output_files,
1930                     int nb_output_files,
1931                     InputFile *input_files,
1932                     int nb_input_files,
1933                     StreamMap *stream_maps, int nb_stream_maps)
1934{
1935    int ret = 0, i, j, k, n, nb_ostreams = 0;
1936    AVFormatContext *is, *os;
1937    AVCodecContext *codec, *icodec;
1938    OutputStream *ost, **ost_table = NULL;
1939    InputStream *ist;
1940    char error[1024];
1941    int want_sdp = 1;
1942    uint8_t no_packet[MAX_FILES]={0};
1943    int no_packet_count=0;
1944
1945    if (rate_emu)
1946        for (i = 0; i < nb_input_streams; i++)
1947            input_streams[i].start = av_gettime();
1948
1949    /* output stream init */
1950    nb_ostreams = 0;
1951    for(i=0;i<nb_output_files;i++) {
1952        os = output_files[i];
1953        if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
1954            av_dump_format(output_files[i], i, output_files[i]->filename, 1);
1955            fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1956            ret = AVERROR(EINVAL);
1957            goto fail;
1958        }
1959        nb_ostreams += os->nb_streams;
1960    }
1961    if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1962        fprintf(stderr, "Number of stream maps must match number of output streams\n");
1963        ret = AVERROR(EINVAL);
1964        goto fail;
1965    }
1966
1967    /* Sanity check the mapping args -- do the input files & streams exist? */
1968    for(i=0;i<nb_stream_maps;i++) {
1969        int fi = stream_maps[i].file_index;
1970        int si = stream_maps[i].stream_index;
1971
1972        if (fi < 0 || fi > nb_input_files - 1 ||
1973            si < 0 || si > input_files[fi].nb_streams - 1) {
1974            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1975            ret = AVERROR(EINVAL);
1976            goto fail;
1977        }
1978        fi = stream_maps[i].sync_file_index;
1979        si = stream_maps[i].sync_stream_index;
1980        if (fi < 0 || fi > nb_input_files - 1 ||
1981            si < 0 || si > input_files[fi].nb_streams - 1) {
1982            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1983            ret = AVERROR(EINVAL);
1984            goto fail;
1985        }
1986    }
1987
1988    ost_table = av_mallocz(sizeof(OutputStream *) * nb_ostreams);
1989    if (!ost_table)
1990        goto fail;
1991    n = 0;
1992    for(k=0;k<nb_output_files;k++) {
1993        os = output_files[k];
1994        for(i=0;i<os->nb_streams;i++,n++) {
1995            int found;
1996            ost = ost_table[n] = output_streams_for_file[k][i];
1997            if (nb_stream_maps > 0) {
1998                ost->source_index = input_files[stream_maps[n].file_index].ist_index +
1999                    stream_maps[n].stream_index;
2000
2001                /* Sanity check that the stream types match */
2002                if (input_streams[ost->source_index].st->codec->codec_type != ost->st->codec->codec_type) {
2003                    int i= ost->file_index;
2004                    av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2005                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
2006                        stream_maps[n].file_index, stream_maps[n].stream_index,
2007                        ost->file_index, ost->index);
2008                    exit_program(1);
2009                }
2010
2011            } else {
2012                int best_nb_frames=-1;
2013                /* get corresponding input stream index : we select the first one with the right type */
2014                found = 0;
2015                for (j = 0; j < nb_input_streams; j++) {
2016                    int skip=0;
2017                    ist = &input_streams[j];
2018                    if(opt_programid){
2019                        int pi,si;
2020                        AVFormatContext *f = input_files[ist->file_index].ctx;
2021                        skip=1;
2022                        for(pi=0; pi<f->nb_programs; pi++){
2023                            AVProgram *p= f->programs[pi];
2024                            if(p->id == opt_programid)
2025                                for(si=0; si<p->nb_stream_indexes; si++){
2026                                    if(f->streams[ p->stream_index[si] ] == ist->st)
2027                                        skip=0;
2028                                }
2029                        }
2030                    }
2031                    if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
2032                        ist->st->codec->codec_type == ost->st->codec->codec_type) {
2033                        if(best_nb_frames < ist->st->codec_info_nb_frames){
2034                            best_nb_frames= ist->st->codec_info_nb_frames;
2035                            ost->source_index = j;
2036                            found = 1;
2037                        }
2038                    }
2039                }
2040
2041                if (!found) {
2042                    if(! opt_programid) {
2043                        /* try again and reuse existing stream */
2044                        for (j = 0; j < nb_input_streams; j++) {
2045                            ist = &input_streams[j];
2046                            if (   ist->st->codec->codec_type == ost->st->codec->codec_type
2047                                && ist->st->discard != AVDISCARD_ALL) {
2048                                ost->source_index = j;
2049                                found = 1;
2050                            }
2051                        }
2052                    }
2053                    if (!found) {
2054                        int i= ost->file_index;
2055                        av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2056                        fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
2057                                ost->file_index, ost->index);
2058                        exit_program(1);
2059                    }
2060                }
2061            }
2062            ist = &input_streams[ost->source_index];
2063            ist->discard = 0;
2064            ost->sync_ist = (nb_stream_maps > 0) ?
2065                &input_streams[input_files[stream_maps[n].sync_file_index].ist_index +
2066                         stream_maps[n].sync_stream_index] : ist;
2067        }
2068    }
2069
2070    /* for each output stream, we compute the right encoding parameters */
2071    for(i=0;i<nb_ostreams;i++) {
2072        ost = ost_table[i];
2073        os = output_files[ost->file_index];
2074        ist = &input_streams[ost->source_index];
2075
2076        codec = ost->st->codec;
2077        icodec = ist->st->codec;
2078
2079        if (metadata_streams_autocopy)
2080            av_dict_copy(&ost->st->metadata, ist->st->metadata,
2081                         AV_DICT_DONT_OVERWRITE);
2082
2083        ost->st->disposition = ist->st->disposition;
2084        codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2085        codec->chroma_sample_location = icodec->chroma_sample_location;
2086
2087        if (ost->st->stream_copy) {
2088            uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2089
2090            if (extra_size > INT_MAX)
2091                goto fail;
2092
2093            /* if stream_copy is selected, no need to decode or encode */
2094            codec->codec_id = icodec->codec_id;
2095            codec->codec_type = icodec->codec_type;
2096
2097            if(!codec->codec_tag){
2098                if(   !os->oformat->codec_tag
2099                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2100                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2101                    codec->codec_tag = icodec->codec_tag;
2102            }
2103
2104            codec->bit_rate = icodec->bit_rate;
2105            codec->rc_max_rate    = icodec->rc_max_rate;
2106            codec->rc_buffer_size = icodec->rc_buffer_size;
2107            codec->extradata= av_mallocz(extra_size);
2108            if (!codec->extradata)
2109                goto fail;
2110            memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2111            codec->extradata_size= icodec->extradata_size;
2112            if(!copy_tb && av_q2d(icodec->time_base)*icodec->ticks_per_frame > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/500){
2113                codec->time_base = icodec->time_base;
2114                codec->time_base.num *= icodec->ticks_per_frame;
2115                av_reduce(&codec->time_base.num, &codec->time_base.den,
2116                          codec->time_base.num, codec->time_base.den, INT_MAX);
2117            }else
2118                codec->time_base = ist->st->time_base;
2119            switch(codec->codec_type) {
2120            case AVMEDIA_TYPE_AUDIO:
2121                if(audio_volume != 256) {
2122                    fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2123                    exit_program(1);
2124                }
2125                codec->channel_layout = icodec->channel_layout;
2126                codec->sample_rate = icodec->sample_rate;
2127                codec->channels = icodec->channels;
2128                codec->frame_size = icodec->frame_size;
2129                codec->audio_service_type = icodec->audio_service_type;
2130                codec->block_align= icodec->block_align;
2131                if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2132                    codec->block_align= 0;
2133                if(codec->codec_id == CODEC_ID_AC3)
2134                    codec->block_align= 0;
2135                break;
2136            case AVMEDIA_TYPE_VIDEO:
2137                codec->pix_fmt = icodec->pix_fmt;
2138                codec->width = icodec->width;
2139                codec->height = icodec->height;
2140                codec->has_b_frames = icodec->has_b_frames;
2141                if (!codec->sample_aspect_ratio.num) {
2142                    codec->sample_aspect_ratio =
2143                    ost->st->sample_aspect_ratio =
2144                        ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2145                        ist->st->codec->sample_aspect_ratio.num ?
2146                        ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2147                }
2148                break;
2149            case AVMEDIA_TYPE_SUBTITLE:
2150                codec->width = icodec->width;
2151                codec->height = icodec->height;
2152                break;
2153            case AVMEDIA_TYPE_DATA:
2154                break;
2155            default:
2156                abort();
2157            }
2158        } else {
2159            if (!ost->enc)
2160                ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2161            switch(codec->codec_type) {
2162            case AVMEDIA_TYPE_AUDIO:
2163                ost->fifo= av_fifo_alloc(1024);
2164                if(!ost->fifo)
2165                    goto fail;
2166                ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2167                if (!codec->sample_rate) {
2168                    codec->sample_rate = icodec->sample_rate;
2169                    if (icodec->lowres)
2170                        codec->sample_rate >>= icodec->lowres;
2171                }
2172                choose_sample_rate(ost->st, ost->enc);
2173                codec->time_base = (AVRational){1, codec->sample_rate};
2174                if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2175                    codec->sample_fmt = icodec->sample_fmt;
2176                choose_sample_fmt(ost->st, ost->enc);
2177                if (!codec->channels)
2178                    codec->channels = icodec->channels;
2179                codec->channel_layout = icodec->channel_layout;
2180                if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2181                    codec->channel_layout = 0;
2182                ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2183                icodec->request_channels = codec->channels;
2184                ist->decoding_needed = 1;
2185                ost->encoding_needed = 1;
2186                ost->resample_sample_fmt  = icodec->sample_fmt;
2187                ost->resample_sample_rate = icodec->sample_rate;
2188                ost->resample_channels    = icodec->channels;
2189                break;
2190            case AVMEDIA_TYPE_VIDEO:
2191                if (codec->pix_fmt == PIX_FMT_NONE)
2192                    codec->pix_fmt = icodec->pix_fmt;
2193                choose_pixel_fmt(ost->st, ost->enc);
2194
2195                if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2196                    fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2197                    exit_program(1);
2198                }
2199
2200                if (!codec->width || !codec->height) {
2201                    codec->width  = icodec->width;
2202                    codec->height = icodec->height;
2203                }
2204
2205                ost->video_resample = codec->width   != icodec->width  ||
2206                                      codec->height  != icodec->height ||
2207                                      codec->pix_fmt != icodec->pix_fmt;
2208                if (ost->video_resample) {
2209#if !CONFIG_AVFILTER
2210                    avcodec_get_frame_defaults(&ost->pict_tmp);
2211                    if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2212                                       codec->width, codec->height)) {
2213                        fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
2214                        exit_program(1);
2215                    }
2216                    ost->img_resample_ctx = sws_getContext(
2217                        icodec->width,
2218                        icodec->height,
2219                        icodec->pix_fmt,
2220                        codec->width,
2221                        codec->height,
2222                        codec->pix_fmt,
2223                        ost->sws_flags, NULL, NULL, NULL);
2224                    if (ost->img_resample_ctx == NULL) {
2225                        fprintf(stderr, "Cannot get resampling context\n");
2226                        exit_program(1);
2227                    }
2228#endif
2229                    codec->bits_per_raw_sample= 0;
2230                }
2231
2232                ost->resample_height = icodec->height;
2233                ost->resample_width  = icodec->width;
2234                ost->resample_pix_fmt= icodec->pix_fmt;
2235                ost->encoding_needed = 1;
2236                ist->decoding_needed = 1;
2237
2238                if (!ost->frame_rate.num)
2239                    ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
2240                if (ost->enc && ost->enc->supported_framerates && !force_fps) {
2241                    int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2242                    ost->frame_rate = ost->enc->supported_framerates[idx];
2243                }
2244                codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2245
2246#if CONFIG_AVFILTER
2247                if (configure_video_filters(ist, ost)) {
2248                    fprintf(stderr, "Error opening filters!\n");
2249                    exit(1);
2250                }
2251#endif
2252                break;
2253            case AVMEDIA_TYPE_SUBTITLE:
2254                ost->encoding_needed = 1;
2255                ist->decoding_needed = 1;
2256                break;
2257            default:
2258                abort();
2259                break;
2260            }
2261            /* two pass mode */
2262            if (ost->encoding_needed &&
2263                (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2264                char logfilename[1024];
2265                FILE *f;
2266
2267                snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2268                         pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2269                         i);
2270                if (codec->flags & CODEC_FLAG_PASS1) {
2271                    f = fopen(logfilename, "wb");
2272                    if (!f) {
2273                        fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2274                        exit_program(1);
2275                    }
2276                    ost->logfile = f;
2277                } else {
2278                    char  *logbuffer;
2279                    size_t logbuffer_size;
2280                    if (cmdutils_read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2281                        fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2282                        exit_program(1);
2283                    }
2284                    codec->stats_in = logbuffer;
2285                }
2286            }
2287        }
2288        if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2289            int size= codec->width * codec->height;
2290            bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2291        }
2292    }
2293
2294    if (!bit_buffer)
2295        bit_buffer = av_malloc(bit_buffer_size);
2296    if (!bit_buffer) {
2297        fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2298                bit_buffer_size);
2299        ret = AVERROR(ENOMEM);
2300        goto fail;
2301    }
2302
2303    /* open each encoder */
2304    for(i=0;i<nb_ostreams;i++) {
2305        ost = ost_table[i];
2306        if (ost->encoding_needed) {
2307            AVCodec *codec = ost->enc;
2308            AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2309            if (!codec) {
2310                snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2311                         ost->st->codec->codec_id, ost->file_index, ost->index);
2312                ret = AVERROR(EINVAL);
2313                goto dump_format;
2314            }
2315            if (dec->subtitle_header) {
2316                ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2317                if (!ost->st->codec->subtitle_header) {
2318                    ret = AVERROR(ENOMEM);
2319                    goto dump_format;
2320                }
2321                memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2322                ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2323            }
2324            if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2325                snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2326                        ost->file_index, ost->index);
2327                ret = AVERROR(EINVAL);
2328                goto dump_format;
2329            }
2330            assert_codec_experimental(ost->st->codec, 1);
2331            assert_avoptions(ost->opts);
2332            if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2333                av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2334                                             "It takes bits/s as argument, not kbits/s\n");
2335            extra_size += ost->st->codec->extradata_size;
2336        }
2337    }
2338
2339    /* open each decoder */
2340    for (i = 0; i < nb_input_streams; i++) {
2341        ist = &input_streams[i];
2342        if (ist->decoding_needed) {
2343            AVCodec *codec = ist->dec;
2344            if (!codec)
2345                codec = avcodec_find_decoder(ist->st->codec->codec_id);
2346            if (!codec) {
2347                snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2348                        ist->st->codec->codec_id, ist->file_index, ist->st->index);
2349                ret = AVERROR(EINVAL);
2350                goto dump_format;
2351            }
2352
2353            /* update requested sample format for the decoder based on the
2354               corresponding encoder sample format */
2355            for (j = 0; j < nb_ostreams; j++) {
2356                ost = ost_table[j];
2357                if (ost->source_index == i) {
2358                    update_sample_fmt(ist->st->codec, codec, ost->st->codec);
2359                    break;
2360                }
2361            }
2362
2363            if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
2364                snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2365                        ist->file_index, ist->st->index);
2366                ret = AVERROR(EINVAL);
2367                goto dump_format;
2368            }
2369            assert_codec_experimental(ist->st->codec, 0);
2370            assert_avoptions(ost->opts);
2371        }
2372    }
2373
2374    /* init pts */
2375    for (i = 0; i < nb_input_streams; i++) {
2376        AVStream *st;
2377        ist = &input_streams[i];
2378        st= ist->st;
2379        ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2380        ist->next_pts = AV_NOPTS_VALUE;
2381        init_pts_correction(&ist->pts_ctx);
2382        ist->is_start = 1;
2383    }
2384
2385    /* set meta data information from input file if required */
2386    for (i=0;i<nb_meta_data_maps;i++) {
2387        AVFormatContext *files[2];
2388        AVDictionary    **meta[2];
2389        int j;
2390
2391#define METADATA_CHECK_INDEX(index, nb_elems, desc)\
2392        if ((index) < 0 || (index) >= (nb_elems)) {\
2393            snprintf(error, sizeof(error), "Invalid %s index %d while processing metadata maps\n",\
2394                     (desc), (index));\
2395            ret = AVERROR(EINVAL);\
2396            goto dump_format;\
2397        }
2398
2399        int out_file_index = meta_data_maps[i][0].file;
2400        int in_file_index = meta_data_maps[i][1].file;
2401        if (in_file_index < 0 || out_file_index < 0)
2402            continue;
2403        METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2404        METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2405
2406        files[0] = output_files[out_file_index];
2407        files[1] = input_files[in_file_index].ctx;
2408
2409        for (j = 0; j < 2; j++) {
2410            MetadataMap *map = &meta_data_maps[i][j];
2411
2412            switch (map->type) {
2413            case 'g':
2414                meta[j] = &files[j]->metadata;
2415                break;
2416            case 's':
2417                METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
2418                meta[j] = &files[j]->streams[map->index]->metadata;
2419                break;
2420            case 'c':
2421                METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
2422                meta[j] = &files[j]->chapters[map->index]->metadata;
2423                break;
2424            case 'p':
2425                METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
2426                meta[j] = &files[j]->programs[map->index]->metadata;
2427                break;
2428            }
2429        }
2430
2431        av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
2432    }
2433
2434    /* copy global metadata by default */
2435    if (metadata_global_autocopy) {
2436
2437        for (i = 0; i < nb_output_files; i++)
2438            av_dict_copy(&output_files[i]->metadata, input_files[0].ctx->metadata,
2439                         AV_DICT_DONT_OVERWRITE);
2440    }
2441
2442    /* copy chapters according to chapter maps */
2443    for (i = 0; i < nb_chapter_maps; i++) {
2444        int infile  = chapter_maps[i].in_file;
2445        int outfile = chapter_maps[i].out_file;
2446
2447        if (infile < 0 || outfile < 0)
2448            continue;
2449        if (infile >= nb_input_files) {
2450            snprintf(error, sizeof(error), "Invalid input file index %d in chapter mapping.\n", infile);
2451            ret = AVERROR(EINVAL);
2452            goto dump_format;
2453        }
2454        if (outfile >= nb_output_files) {
2455            snprintf(error, sizeof(error), "Invalid output file index %d in chapter mapping.\n",outfile);
2456            ret = AVERROR(EINVAL);
2457            goto dump_format;
2458        }
2459        copy_chapters(infile, outfile);
2460    }
2461
2462    /* copy chapters from the first input file that has them*/
2463    if (!nb_chapter_maps)
2464        for (i = 0; i < nb_input_files; i++) {
2465            if (!input_files[i].ctx->nb_chapters)
2466                continue;
2467
2468            for (j = 0; j < nb_output_files; j++)
2469                if ((ret = copy_chapters(i, j)) < 0)
2470                    goto dump_format;
2471            break;
2472        }
2473
2474    /* open files and write file headers */
2475    for(i=0;i<nb_output_files;i++) {
2476        os = output_files[i];
2477        if (avformat_write_header(os, &output_opts[i]) < 0) {
2478            snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2479            ret = AVERROR(EINVAL);
2480            goto dump_format;
2481        }
2482        assert_avoptions(output_opts[i]);
2483        if (strcmp(output_files[i]->oformat->name, "rtp")) {
2484            want_sdp = 0;
2485        }
2486    }
2487
2488 dump_format:
2489    /* dump the file output parameters - cannot be done before in case
2490       of stream copy */
2491    for(i=0;i<nb_output_files;i++) {
2492        av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2493    }
2494
2495    /* dump the stream mapping */
2496    if (verbose >= 0) {
2497        fprintf(stderr, "Stream mapping:\n");
2498        for(i=0;i<nb_ostreams;i++) {
2499            ost = ost_table[i];
2500            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
2501                    input_streams[ost->source_index].file_index,
2502                    input_streams[ost->source_index].st->index,
2503                    ost->file_index,
2504                    ost->index);
2505            if (ost->sync_ist != &input_streams[ost->source_index])
2506                fprintf(stderr, " [sync #%d.%d]",
2507                        ost->sync_ist->file_index,
2508                        ost->sync_ist->st->index);
2509            fprintf(stderr, "\n");
2510        }
2511    }
2512
2513    if (ret) {
2514        fprintf(stderr, "%s\n", error);
2515        goto fail;
2516    }
2517
2518    if (want_sdp) {
2519        print_sdp(output_files, nb_output_files);
2520    }
2521
2522    if (verbose >= 0)
2523        fprintf(stderr, "Press ctrl-c to stop encoding\n");
2524    term_init();
2525
2526    timer_start = av_gettime();
2527
2528    for(; received_sigterm == 0;) {
2529        int file_index, ist_index;
2530        AVPacket pkt;
2531        double ipts_min;
2532        double opts_min;
2533
2534    redo:
2535        ipts_min= 1e100;
2536        opts_min= 1e100;
2537
2538        /* select the stream that we must read now by looking at the
2539           smallest output pts */
2540        file_index = -1;
2541        for(i=0;i<nb_ostreams;i++) {
2542            double ipts, opts;
2543            ost = ost_table[i];
2544            os = output_files[ost->file_index];
2545            ist = &input_streams[ost->source_index];
2546            if(ist->is_past_recording_time || no_packet[ist->file_index])
2547                continue;
2548                opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2549            ipts = (double)ist->pts;
2550            if (!input_files[ist->file_index].eof_reached){
2551                if(ipts < ipts_min) {
2552                    ipts_min = ipts;
2553                    if(input_sync ) file_index = ist->file_index;
2554                }
2555                if(opts < opts_min) {
2556                    opts_min = opts;
2557                    if(!input_sync) file_index = ist->file_index;
2558                }
2559            }
2560            if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2561                file_index= -1;
2562                break;
2563            }
2564        }
2565        /* if none, if is finished */
2566        if (file_index < 0) {
2567            if(no_packet_count){
2568                no_packet_count=0;
2569                memset(no_packet, 0, sizeof(no_packet));
2570                usleep(10000);
2571                continue;
2572            }
2573            break;
2574        }
2575
2576        /* finish if limit size exhausted */
2577        if (limit_filesize != 0 && limit_filesize <= avio_tell(output_files[0]->pb))
2578            break;
2579
2580        /* read a frame from it and output it in the fifo */
2581        is = input_files[file_index].ctx;
2582        ret= av_read_frame(is, &pkt);
2583        if(ret == AVERROR(EAGAIN)){
2584            no_packet[file_index]=1;
2585            no_packet_count++;
2586            continue;
2587        }
2588        if (ret < 0) {
2589            input_files[file_index].eof_reached = 1;
2590            if (opt_shortest)
2591                break;
2592            else
2593                continue;
2594        }
2595
2596        no_packet_count=0;
2597        memset(no_packet, 0, sizeof(no_packet));
2598
2599        if (do_pkt_dump) {
2600            av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2601                             is->streams[pkt.stream_index]);
2602        }
2603        /* the following test is needed in case new streams appear
2604           dynamically in stream : we ignore them */
2605        if (pkt.stream_index >= input_files[file_index].nb_streams)
2606            goto discard_packet;
2607        ist_index = input_files[file_index].ist_index + pkt.stream_index;
2608        ist = &input_streams[ist_index];
2609        if (ist->discard)
2610            goto discard_packet;
2611
2612        if (pkt.dts != AV_NOPTS_VALUE)
2613            pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2614        if (pkt.pts != AV_NOPTS_VALUE)
2615            pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2616
2617        if (ist->ts_scale) {
2618            if(pkt.pts != AV_NOPTS_VALUE)
2619                pkt.pts *= ist->ts_scale;
2620            if(pkt.dts != AV_NOPTS_VALUE)
2621                pkt.dts *= ist->ts_scale;
2622        }
2623
2624//        fprintf(stderr, "next:%"PRId64" dts:%"PRId64" off:%"PRId64" %d\n", ist->next_pts, pkt.dts, input_files[ist->file_index].ts_offset, ist->st->codec->codec_type);
2625        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2626            && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2627            int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2628            int64_t delta= pkt_dts - ist->next_pts;
2629            if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2630                input_files[ist->file_index].ts_offset -= delta;
2631                if (verbose > 2)
2632                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2633                            delta, input_files[ist->file_index].ts_offset);
2634                pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2635                if(pkt.pts != AV_NOPTS_VALUE)
2636                    pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2637            }
2638        }
2639
2640        /* finish if recording time exhausted */
2641        if (recording_time != INT64_MAX &&
2642            av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2643            ist->is_past_recording_time = 1;
2644            goto discard_packet;
2645        }
2646
2647        //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2648        if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2649
2650            if (verbose >= 0)
2651                fprintf(stderr, "Error while decoding stream #%d.%d\n",
2652                        ist->file_index, ist->st->index);
2653            if (exit_on_error)
2654                exit_program(1);
2655            av_free_packet(&pkt);
2656            goto redo;
2657        }
2658
2659    discard_packet:
2660        av_free_packet(&pkt);
2661
2662        /* dump report by using the output first video and audio streams */
2663        print_report(output_files, ost_table, nb_ostreams, 0);
2664    }
2665
2666    /* at the end of stream, we must flush the decoder buffers */
2667    for (i = 0; i < nb_input_streams; i++) {
2668        ist = &input_streams[i];
2669        if (ist->decoding_needed) {
2670            output_packet(ist, i, ost_table, nb_ostreams, NULL);
2671        }
2672    }
2673
2674    term_exit();
2675
2676    /* write the trailer if needed and close file */
2677    for(i=0;i<nb_output_files;i++) {
2678        os = output_files[i];
2679        av_write_trailer(os);
2680    }
2681
2682    /* dump report by using the first video and audio streams */
2683    print_report(output_files, ost_table, nb_ostreams, 1);
2684
2685    /* close each encoder */
2686    for(i=0;i<nb_ostreams;i++) {
2687        ost = ost_table[i];
2688        if (ost->encoding_needed) {
2689            av_freep(&ost->st->codec->stats_in);
2690            avcodec_close(ost->st->codec);
2691        }
2692#if CONFIG_AVFILTER
2693        avfilter_graph_free(&ost->graph);
2694#endif
2695    }
2696
2697    /* close each decoder */
2698    for (i = 0; i < nb_input_streams; i++) {
2699        ist = &input_streams[i];
2700        if (ist->decoding_needed) {
2701            avcodec_close(ist->st->codec);
2702        }
2703    }
2704
2705    /* finished ! */
2706    ret = 0;
2707
2708 fail:
2709    av_freep(&bit_buffer);
2710
2711    if (ost_table) {
2712        for(i=0;i<nb_ostreams;i++) {
2713            ost = ost_table[i];
2714            if (ost) {
2715                if (ost->st->stream_copy)
2716                    av_freep(&ost->st->codec->extradata);
2717                if (ost->logfile) {
2718                    fclose(ost->logfile);
2719                    ost->logfile = NULL;
2720                }
2721                av_fifo_free(ost->fifo); /* works even if fifo is not
2722                                             initialized but set to zero */
2723                av_freep(&ost->st->codec->subtitle_header);
2724                av_free(ost->pict_tmp.data[0]);
2725                av_free(ost->forced_kf_pts);
2726                if (ost->video_resample)
2727                    sws_freeContext(ost->img_resample_ctx);
2728                if (ost->resample)
2729                    audio_resample_close(ost->resample);
2730                if (ost->reformat_ctx)
2731                    av_audio_convert_free(ost->reformat_ctx);
2732                av_dict_free(&ost->opts);
2733                av_free(ost);
2734            }
2735        }
2736        av_free(ost_table);
2737    }
2738    return ret;
2739}
2740
2741static int opt_format(const char *opt, const char *arg)
2742{
2743    last_asked_format = arg;
2744    return 0;
2745}
2746
2747static int opt_video_rc_override_string(const char *opt, const char *arg)
2748{
2749    video_rc_override_string = arg;
2750    return 0;
2751}
2752
2753static int opt_me_threshold(const char *opt, const char *arg)
2754{
2755    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2756    return 0;
2757}
2758
2759static int opt_verbose(const char *opt, const char *arg)
2760{
2761    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2762    return 0;
2763}
2764
2765static int opt_frame_rate(const char *opt, const char *arg)
2766{
2767    if (av_parse_video_rate(&frame_rate, arg) < 0) {
2768        fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2769        exit_program(1);
2770    }
2771    return 0;
2772}
2773
2774static int opt_frame_crop(const char *opt, const char *arg)
2775{
2776    fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2777    return AVERROR(EINVAL);
2778}
2779
2780static int opt_frame_size(const char *opt, const char *arg)
2781{
2782    if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2783        fprintf(stderr, "Incorrect frame size\n");
2784        return AVERROR(EINVAL);
2785    }
2786    return 0;
2787}
2788
2789static int opt_pad(const char *opt, const char *arg) {
2790    fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2791    return -1;
2792}
2793
2794static int opt_frame_pix_fmt(const char *opt, const char *arg)
2795{
2796    if (strcmp(arg, "list")) {
2797        frame_pix_fmt = av_get_pix_fmt(arg);
2798        if (frame_pix_fmt == PIX_FMT_NONE) {
2799            fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2800            return AVERROR(EINVAL);
2801        }
2802    } else {
2803        show_pix_fmts();
2804        exit_program(0);
2805    }
2806    return 0;
2807}
2808
2809static int opt_frame_aspect_ratio(const char *opt, const char *arg)
2810{
2811    int x = 0, y = 0;
2812    double ar = 0;
2813    const char *p;
2814    char *end;
2815
2816    p = strchr(arg, ':');
2817    if (p) {
2818        x = strtol(arg, &end, 10);
2819        if (end == p)
2820            y = strtol(end+1, &end, 10);
2821        if (x > 0 && y > 0)
2822            ar = (double)x / (double)y;
2823    } else
2824        ar = strtod(arg, NULL);
2825
2826    if (!ar) {
2827        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2828        return AVERROR(EINVAL);
2829    }
2830    frame_aspect_ratio = ar;
2831    return 0;
2832}
2833
2834static int opt_metadata(const char *opt, const char *arg)
2835{
2836    char *mid= strchr(arg, '=');
2837
2838    if(!mid){
2839        fprintf(stderr, "Missing =\n");
2840        exit_program(1);
2841    }
2842    *mid++= 0;
2843
2844    av_dict_set(&metadata, arg, mid, 0);
2845
2846    return 0;
2847}
2848
2849static int opt_qscale(const char *opt, const char *arg)
2850{
2851    video_qscale = parse_number_or_die(opt, arg, OPT_FLOAT, 0, 255);
2852    if (video_qscale == 0) {
2853        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2854        return AVERROR(EINVAL);
2855    }
2856    return 0;
2857}
2858
2859static int opt_top_field_first(const char *opt, const char *arg)
2860{
2861    top_field_first = parse_number_or_die(opt, arg, OPT_INT, 0, 1);
2862    return 0;
2863}
2864
2865static int opt_thread_count(const char *opt, const char *arg)
2866{
2867    thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2868#if !HAVE_THREADS
2869    if (verbose >= 0)
2870        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2871#endif
2872    return 0;
2873}
2874
2875static int opt_audio_sample_fmt(const char *opt, const char *arg)
2876{
2877    if (strcmp(arg, "list")) {
2878        audio_sample_fmt = av_get_sample_fmt(arg);
2879        if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2880            av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2881            return AVERROR(EINVAL);
2882        }
2883    } else {
2884        int i;
2885        char fmt_str[128];
2886        for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
2887            printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
2888        exit_program(0);
2889    }
2890    return 0;
2891}
2892
2893static int opt_audio_rate(const char *opt, const char *arg)
2894{
2895    audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2896    return 0;
2897}
2898
2899static int opt_audio_channels(const char *opt, const char *arg)
2900{
2901    audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2902    return 0;
2903}
2904
2905static int opt_video_channel(const char *opt, const char *arg)
2906{
2907    av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
2908    opt_default("channel", arg);
2909    return 0;
2910}
2911
2912static int opt_video_standard(const char *opt, const char *arg)
2913{
2914    av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
2915    opt_default("standard", arg);
2916    return 0;
2917}
2918
2919static int opt_codec(int *pstream_copy, char **pcodec_name,
2920                      int codec_type, const char *arg)
2921{
2922    av_freep(pcodec_name);
2923    if (!strcmp(arg, "copy")) {
2924        *pstream_copy = 1;
2925    } else {
2926        *pcodec_name = av_strdup(arg);
2927    }
2928    return 0;
2929}
2930
2931static int opt_audio_codec(const char *opt, const char *arg)
2932{
2933    return opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2934}
2935
2936static int opt_video_codec(const char *opt, const char *arg)
2937{
2938    return opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2939}
2940
2941static int opt_subtitle_codec(const char *opt, const char *arg)
2942{
2943    return opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2944}
2945
2946static int opt_data_codec(const char *opt, const char *arg)
2947{
2948    return opt_codec(&data_stream_copy, &data_codec_name, AVMEDIA_TYPE_DATA, arg);
2949}
2950
2951static int opt_codec_tag(const char *opt, const char *arg)
2952{
2953    char *tail;
2954    uint32_t *codec_tag;
2955
2956    codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2957                !strcmp(opt, "vtag") ? &video_codec_tag :
2958                !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2959    if (!codec_tag)
2960        return -1;
2961
2962    *codec_tag = strtol(arg, &tail, 0);
2963    if (!tail || *tail)
2964        *codec_tag = AV_RL32(arg);
2965
2966    return 0;
2967}
2968
2969static int opt_map(const char *opt, const char *arg)
2970{
2971    StreamMap *m;
2972    char *p;
2973
2974    stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
2975    m = &stream_maps[nb_stream_maps-1];
2976
2977    m->file_index = strtol(arg, &p, 0);
2978    if (*p)
2979        p++;
2980
2981    m->stream_index = strtol(p, &p, 0);
2982    if (*p) {
2983        p++;
2984        m->sync_file_index = strtol(p, &p, 0);
2985        if (*p)
2986            p++;
2987        m->sync_stream_index = strtol(p, &p, 0);
2988    } else {
2989        m->sync_file_index = m->file_index;
2990        m->sync_stream_index = m->stream_index;
2991    }
2992    return 0;
2993}
2994
2995static void parse_meta_type(char *arg, char *type, int *index, char **endptr)
2996{
2997    *endptr = arg;
2998    if (*arg == ',') {
2999        *type = *(++arg);
3000        switch (*arg) {
3001        case 'g':
3002            break;
3003        case 's':
3004        case 'c':
3005        case 'p':
3006            *index = strtol(++arg, endptr, 0);
3007            break;
3008        default:
3009            fprintf(stderr, "Invalid metadata type %c.\n", *arg);
3010            exit_program(1);
3011        }
3012    } else
3013        *type = 'g';
3014}
3015
3016static int opt_map_metadata(const char *opt, const char *arg)
3017{
3018    MetadataMap *m, *m1;
3019    char *p;
3020
3021    meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
3022                                &nb_meta_data_maps, nb_meta_data_maps + 1);
3023
3024    m = &meta_data_maps[nb_meta_data_maps - 1][0];
3025    m->file = strtol(arg, &p, 0);
3026    parse_meta_type(p, &m->type, &m->index, &p);
3027    if (*p)
3028        p++;
3029
3030    m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
3031    m1->file = strtol(p, &p, 0);
3032    parse_meta_type(p, &m1->type, &m1->index, &p);
3033
3034    if (m->type == 'g' || m1->type == 'g')
3035        metadata_global_autocopy = 0;
3036    if (m->type == 's' || m1->type == 's')
3037        metadata_streams_autocopy = 0;
3038    if (m->type == 'c' || m1->type == 'c')
3039        metadata_chapters_autocopy = 0;
3040
3041    return 0;
3042}
3043
3044static int opt_map_meta_data(const char *opt, const char *arg)
3045{
3046    fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "
3047                    "Use -map_metadata instead.\n");
3048    return opt_map_metadata(opt, arg);
3049}
3050
3051static int opt_map_chapters(const char *opt, const char *arg)
3052{
3053    ChapterMap *c;
3054    char *p;
3055
3056    chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
3057                              nb_chapter_maps + 1);
3058    c = &chapter_maps[nb_chapter_maps - 1];
3059    c->out_file = strtol(arg, &p, 0);
3060    if (*p)
3061        p++;
3062
3063    c->in_file = strtol(p, &p, 0);
3064    return 0;
3065}
3066
3067static int opt_input_ts_scale(const char *opt, const char *arg)
3068{
3069    unsigned int stream;
3070    double scale;
3071    char *p;
3072
3073    stream = strtol(arg, &p, 0);
3074    if (*p)
3075        p++;
3076    scale= strtod(p, &p);
3077
3078    ts_scale = grow_array(ts_scale, sizeof(*ts_scale), &nb_ts_scale, stream + 1);
3079    ts_scale[stream] = scale;
3080    return 0;
3081}
3082
3083static int opt_recording_time(const char *opt, const char *arg)
3084{
3085    recording_time = parse_time_or_die(opt, arg, 1);
3086    return 0;
3087}
3088
3089static int opt_start_time(const char *opt, const char *arg)
3090{
3091    start_time = parse_time_or_die(opt, arg, 1);
3092    return 0;
3093}
3094
3095static int opt_recording_timestamp(const char *opt, const char *arg)
3096{
3097    char buf[128];
3098    int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
3099    struct tm time = *gmtime((time_t*)&recording_timestamp);
3100    strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
3101    opt_metadata("metadata", buf);
3102
3103    av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
3104                                 "tag instead.\n", opt);
3105    return 0;
3106}
3107
3108static int opt_input_ts_offset(const char *opt, const char *arg)
3109{
3110    input_ts_offset = parse_time_or_die(opt, arg, 1);
3111    return 0;
3112}
3113
3114static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
3115{
3116    const char *codec_string = encoder ? "encoder" : "decoder";
3117    AVCodec *codec;
3118
3119    if(!name)
3120        return CODEC_ID_NONE;
3121    codec = encoder ?
3122        avcodec_find_encoder_by_name(name) :
3123        avcodec_find_decoder_by_name(name);
3124    if(!codec) {
3125        fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3126        exit_program(1);
3127    }
3128    if(codec->type != type) {
3129        fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3130        exit_program(1);
3131    }
3132    return codec->id;
3133}
3134
3135static int opt_input_file(const char *opt, const char *filename)
3136{
3137    AVFormatContext *ic;
3138    AVInputFormat *file_iformat = NULL;
3139    int err, i, ret, rfps, rfps_base;
3140    int64_t timestamp;
3141    uint8_t buf[128];
3142    AVDictionary **opts;
3143    int orig_nb_streams;                     // number of streams before avformat_find_stream_info
3144
3145    if (last_asked_format) {
3146        if (!(file_iformat = av_find_input_format(last_asked_format))) {
3147            fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3148            exit_program(1);
3149        }
3150        last_asked_format = NULL;
3151    }
3152
3153    if (!strcmp(filename, "-"))
3154        filename = "pipe:";
3155
3156    using_stdin |= !strncmp(filename, "pipe:", 5) ||
3157                    !strcmp(filename, "/dev/stdin");
3158
3159    /* get default parameters from command line */
3160    ic = avformat_alloc_context();
3161    if (!ic) {
3162        print_error(filename, AVERROR(ENOMEM));
3163        exit_program(1);
3164    }
3165    if (audio_sample_rate) {
3166        snprintf(buf, sizeof(buf), "%d", audio_sample_rate);
3167        av_dict_set(&format_opts, "sample_rate", buf, 0);
3168    }
3169    if (audio_channels) {
3170        snprintf(buf, sizeof(buf), "%d", audio_channels);
3171        av_dict_set(&format_opts, "channels", buf, 0);
3172    }
3173    if (frame_rate.num) {
3174        snprintf(buf, sizeof(buf), "%d/%d", frame_rate.num, frame_rate.den);
3175        av_dict_set(&format_opts, "framerate", buf, 0);
3176    }
3177    if (frame_width && frame_height) {
3178        snprintf(buf, sizeof(buf), "%dx%d", frame_width, frame_height);
3179        av_dict_set(&format_opts, "video_size", buf, 0);
3180    }
3181    if (frame_pix_fmt != PIX_FMT_NONE)
3182        av_dict_set(&format_opts, "pixel_format", av_get_pix_fmt_name(frame_pix_fmt), 0);
3183
3184    ic->video_codec_id   =
3185        find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0);
3186    ic->audio_codec_id   =
3187        find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0);
3188    ic->subtitle_codec_id=
3189        find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0);
3190    ic->flags |= AVFMT_FLAG_NONBLOCK;
3191
3192    /* open the input file with generic libav function */
3193    err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
3194    if (err < 0) {
3195        print_error(filename, err);
3196        exit_program(1);
3197    }
3198    assert_avoptions(format_opts);
3199
3200    if(opt_programid) {
3201        int i, j;
3202        int found=0;
3203        for(i=0; i<ic->nb_streams; i++){
3204            ic->streams[i]->discard= AVDISCARD_ALL;
3205        }
3206        for(i=0; i<ic->nb_programs; i++){
3207            AVProgram *p= ic->programs[i];
3208            if(p->id != opt_programid){
3209                p->discard = AVDISCARD_ALL;
3210            }else{
3211                found=1;
3212                for(j=0; j<p->nb_stream_indexes; j++){
3213                    ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3214                }
3215            }
3216        }
3217        if(!found){
3218            fprintf(stderr, "Specified program id not found\n");
3219            exit_program(1);
3220        }
3221        opt_programid=0;
3222    }
3223
3224    if (loop_input) {
3225        av_log(NULL, AV_LOG_WARNING, "-loop_input is deprecated, use -loop 1\n");
3226        ic->loop_input = loop_input;
3227    }
3228
3229    /* Set AVCodecContext options for avformat_find_stream_info */
3230    opts = setup_find_stream_info_opts(ic, codec_opts);
3231    orig_nb_streams = ic->nb_streams;
3232
3233    /* If not enough info to get the stream parameters, we decode the
3234       first frames to get it. (used in mpeg case for example) */
3235    ret = avformat_find_stream_info(ic, opts);
3236    if (ret < 0 && verbose >= 0) {
3237        fprintf(stderr, "%s: could not find codec parameters\n", filename);
3238        av_close_input_file(ic);
3239        exit_program(1);
3240    }
3241
3242    timestamp = start_time;
3243    /* add the stream start time */
3244    if (ic->start_time != AV_NOPTS_VALUE)
3245        timestamp += ic->start_time;
3246
3247    /* if seeking requested, we execute it */
3248    if (start_time != 0) {
3249        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3250        if (ret < 0) {
3251            fprintf(stderr, "%s: could not seek to position %0.3f\n",
3252                    filename, (double)timestamp / AV_TIME_BASE);
3253        }
3254        /* reset seek info */
3255        start_time = 0;
3256    }
3257
3258    /* update the current parameters so that they match the one of the input stream */
3259    for(i=0;i<ic->nb_streams;i++) {
3260        AVStream *st = ic->streams[i];
3261        AVCodecContext *dec = st->codec;
3262        InputStream *ist;
3263
3264        dec->thread_count = thread_count;
3265
3266        input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
3267        ist = &input_streams[nb_input_streams - 1];
3268        ist->st = st;
3269        ist->file_index = nb_input_files;
3270        ist->discard = 1;
3271        ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st);
3272
3273        if (i < nb_ts_scale)
3274            ist->ts_scale = ts_scale[i];
3275
3276        switch (dec->codec_type) {
3277        case AVMEDIA_TYPE_AUDIO:
3278            ist->dec = avcodec_find_decoder_by_name(audio_codec_name);
3279            if(audio_disable)
3280                st->discard= AVDISCARD_ALL;
3281            break;
3282        case AVMEDIA_TYPE_VIDEO:
3283            ist->dec = avcodec_find_decoder_by_name(video_codec_name);
3284            rfps      = ic->streams[i]->r_frame_rate.num;
3285            rfps_base = ic->streams[i]->r_frame_rate.den;
3286            if (dec->lowres) {
3287                dec->flags |= CODEC_FLAG_EMU_EDGE;
3288                dec->height >>= dec->lowres;
3289                dec->width  >>= dec->lowres;
3290            }
3291            if(me_threshold)
3292                dec->debug |= FF_DEBUG_MV;
3293
3294            if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3295
3296                if (verbose >= 0)
3297                    fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3298                            i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3299
3300                    (float)rfps / rfps_base, rfps, rfps_base);
3301            }
3302
3303            if(video_disable)
3304                st->discard= AVDISCARD_ALL;
3305            else if(video_discard)
3306                st->discard= video_discard;
3307            break;
3308        case AVMEDIA_TYPE_DATA:
3309            break;
3310        case AVMEDIA_TYPE_SUBTITLE:
3311            ist->dec = avcodec_find_decoder_by_name(subtitle_codec_name);
3312            if(subtitle_disable)
3313                st->discard = AVDISCARD_ALL;
3314            break;
3315        case AVMEDIA_TYPE_ATTACHMENT:
3316        case AVMEDIA_TYPE_UNKNOWN:
3317            break;
3318        default:
3319            abort();
3320        }
3321    }
3322
3323    /* dump the file content */
3324    if (verbose >= 0)
3325        av_dump_format(ic, nb_input_files, filename, 0);
3326
3327    input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3328    input_files[nb_input_files - 1].ctx        = ic;
3329    input_files[nb_input_files - 1].ist_index  = nb_input_streams - ic->nb_streams;
3330    input_files[nb_input_files - 1].ts_offset  = input_ts_offset - (copy_ts ? 0 : timestamp);
3331    input_files[nb_input_files - 1].nb_streams = ic->nb_streams;
3332
3333    frame_rate    = (AVRational){0, 0};
3334    frame_pix_fmt = PIX_FMT_NONE;
3335    frame_height = 0;
3336    frame_width  = 0;
3337    audio_sample_rate = 0;
3338    audio_channels    = 0;
3339    audio_sample_fmt  = AV_SAMPLE_FMT_NONE;
3340    av_freep(&ts_scale);
3341    nb_ts_scale = 0;
3342
3343    for (i = 0; i < orig_nb_streams; i++)
3344        av_dict_free(&opts[i]);
3345    av_freep(&opts);
3346    av_freep(&video_codec_name);
3347    av_freep(&audio_codec_name);
3348    av_freep(&subtitle_codec_name);
3349    uninit_opts();
3350    init_opts();
3351    return 0;
3352}
3353
3354static void check_inputs(int *has_video_ptr,
3355                         int *has_audio_ptr,
3356                         int *has_subtitle_ptr,
3357                         int *has_data_ptr)
3358{
3359    int has_video, has_audio, has_subtitle, has_data, i, j;
3360    AVFormatContext *ic;
3361
3362    has_video = 0;
3363    has_audio = 0;
3364    has_subtitle = 0;
3365    has_data = 0;
3366
3367    for(j=0;j<nb_input_files;j++) {
3368        ic = input_files[j].ctx;
3369        for(i=0;i<ic->nb_streams;i++) {
3370            AVCodecContext *enc = ic->streams[i]->codec;
3371            switch(enc->codec_type) {
3372            case AVMEDIA_TYPE_AUDIO:
3373                has_audio = 1;
3374                break;
3375            case AVMEDIA_TYPE_VIDEO:
3376                has_video = 1;
3377                break;
3378            case AVMEDIA_TYPE_SUBTITLE:
3379                has_subtitle = 1;
3380                break;
3381            case AVMEDIA_TYPE_DATA:
3382            case AVMEDIA_TYPE_ATTACHMENT:
3383            case AVMEDIA_TYPE_UNKNOWN:
3384                has_data = 1;
3385                break;
3386            default:
3387                abort();
3388            }
3389        }
3390    }
3391    *has_video_ptr = has_video;
3392    *has_audio_ptr = has_audio;
3393    *has_subtitle_ptr = has_subtitle;
3394    *has_data_ptr = has_data;
3395}
3396
3397static void new_video_stream(AVFormatContext *oc, int file_idx)
3398{
3399    AVStream *st;
3400    OutputStream *ost;
3401    AVCodecContext *video_enc;
3402    enum CodecID codec_id = CODEC_ID_NONE;
3403    AVCodec *codec= NULL;
3404
3405    if(!video_stream_copy){
3406        if (video_codec_name) {
3407            codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1);
3408            codec = avcodec_find_encoder_by_name(video_codec_name);
3409        } else {
3410            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3411            codec = avcodec_find_encoder(codec_id);
3412        }
3413    }
3414
3415    ost = new_output_stream(oc, file_idx, codec);
3416    st  = ost->st;
3417    if (!video_stream_copy) {
3418        ost->frame_aspect_ratio = frame_aspect_ratio;
3419        frame_aspect_ratio = 0;
3420#if CONFIG_AVFILTER
3421        ost->avfilter= vfilters;
3422        vfilters = NULL;
3423#endif
3424    }
3425
3426    ost->bitstream_filters = video_bitstream_filters;
3427    video_bitstream_filters= NULL;
3428
3429    st->codec->thread_count= thread_count;
3430
3431    video_enc = st->codec;
3432
3433    if(video_codec_tag)
3434        video_enc->codec_tag= video_codec_tag;
3435
3436    if(oc->oformat->flags & AVFMT_GLOBALHEADER) {
3437        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3438    }
3439
3440    video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3441    if (video_stream_copy) {
3442        st->stream_copy = 1;
3443        video_enc->sample_aspect_ratio =
3444        st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3445    } else {
3446        const char *p;
3447        int i;
3448
3449        if (frame_rate.num)
3450            ost->frame_rate = frame_rate;
3451        video_enc->codec_id = codec_id;
3452
3453        video_enc->width = frame_width;
3454        video_enc->height = frame_height;
3455        video_enc->pix_fmt = frame_pix_fmt;
3456        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3457
3458        if (intra_only)
3459            video_enc->gop_size = 0;
3460        if (video_qscale || same_quality) {
3461            video_enc->flags |= CODEC_FLAG_QSCALE;
3462            video_enc->global_quality = FF_QP2LAMBDA * video_qscale;
3463        }
3464
3465        if(intra_matrix)
3466            video_enc->intra_matrix = intra_matrix;
3467        if(inter_matrix)
3468            video_enc->inter_matrix = inter_matrix;
3469
3470        p= video_rc_override_string;
3471        for(i=0; p; i++){
3472            int start, end, q;
3473            int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3474            if(e!=3){
3475                fprintf(stderr, "error parsing rc_override\n");
3476                exit_program(1);
3477            }
3478            video_enc->rc_override=
3479                av_realloc(video_enc->rc_override,
3480                           sizeof(RcOverride)*(i+1));
3481            video_enc->rc_override[i].start_frame= start;
3482            video_enc->rc_override[i].end_frame  = end;
3483            if(q>0){
3484                video_enc->rc_override[i].qscale= q;
3485                video_enc->rc_override[i].quality_factor= 1.0;
3486            }
3487            else{
3488                video_enc->rc_override[i].qscale= 0;
3489                video_enc->rc_override[i].quality_factor= -q/100.0;
3490            }
3491            p= strchr(p, '/');
3492            if(p) p++;
3493        }
3494        video_enc->rc_override_count=i;
3495        if (!video_enc->rc_initial_buffer_occupancy)
3496            video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3497        video_enc->me_threshold= me_threshold;
3498        video_enc->intra_dc_precision= intra_dc_precision - 8;
3499
3500        if (do_psnr)
3501            video_enc->flags|= CODEC_FLAG_PSNR;
3502
3503        /* two pass mode */
3504        if (do_pass) {
3505            if (do_pass == 1) {
3506                video_enc->flags |= CODEC_FLAG_PASS1;
3507            } else {
3508                video_enc->flags |= CODEC_FLAG_PASS2;
3509            }
3510        }
3511
3512        if (forced_key_frames)
3513            parse_forced_key_frames(forced_key_frames, ost, video_enc);
3514    }
3515    if (video_language) {
3516        av_dict_set(&st->metadata, "language", video_language, 0);
3517        av_freep(&video_language);
3518    }
3519
3520    /* reset some key parameters */
3521    video_disable = 0;
3522    av_freep(&video_codec_name);
3523    av_freep(&forced_key_frames);
3524    video_stream_copy = 0;
3525    frame_pix_fmt = PIX_FMT_NONE;
3526}
3527
3528static void new_audio_stream(AVFormatContext *oc, int file_idx)
3529{
3530    AVStream *st;
3531    OutputStream *ost;
3532    AVCodec *codec= NULL;
3533    AVCodecContext *audio_enc;
3534    enum CodecID codec_id = CODEC_ID_NONE;
3535
3536    if(!audio_stream_copy){
3537        if (audio_codec_name) {
3538            codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1);
3539            codec = avcodec_find_encoder_by_name(audio_codec_name);
3540        } else {
3541            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3542            codec = avcodec_find_encoder(codec_id);
3543        }
3544    }
3545    ost = new_output_stream(oc, file_idx, codec);
3546    st  = ost->st;
3547
3548    ost->bitstream_filters = audio_bitstream_filters;
3549    audio_bitstream_filters= NULL;
3550
3551    st->codec->thread_count= thread_count;
3552
3553    audio_enc = st->codec;
3554    audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3555
3556    if(audio_codec_tag)
3557        audio_enc->codec_tag= audio_codec_tag;
3558
3559    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3560        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3561    }
3562    if (audio_stream_copy) {
3563        st->stream_copy = 1;
3564    } else {
3565        audio_enc->codec_id = codec_id;
3566
3567        if (audio_qscale > QSCALE_NONE) {
3568            audio_enc->flags |= CODEC_FLAG_QSCALE;
3569            audio_enc->global_quality = FF_QP2LAMBDA * audio_qscale;
3570        }
3571        if (audio_channels)
3572            audio_enc->channels = audio_channels;
3573        if (audio_sample_fmt != AV_SAMPLE_FMT_NONE)
3574            audio_enc->sample_fmt = audio_sample_fmt;
3575        if (audio_sample_rate)
3576            audio_enc->sample_rate = audio_sample_rate;
3577    }
3578    if (audio_language) {
3579        av_dict_set(&st->metadata, "language", audio_language, 0);
3580        av_freep(&audio_language);
3581    }
3582
3583    /* reset some key parameters */
3584    audio_disable = 0;
3585    av_freep(&audio_codec_name);
3586    audio_stream_copy = 0;
3587}
3588
3589static void new_data_stream(AVFormatContext *oc, int file_idx)
3590{
3591    AVStream *st;
3592    OutputStream *ost;
3593    AVCodecContext *data_enc;
3594
3595    ost = new_output_stream(oc, file_idx, NULL);
3596    st  = ost->st;
3597    data_enc = st->codec;
3598    if (!data_stream_copy) {
3599        fprintf(stderr, "Data stream encoding not supported yet (only streamcopy)\n");
3600        exit_program(1);
3601    }
3602
3603    data_enc->codec_type = AVMEDIA_TYPE_DATA;
3604
3605    if (data_codec_tag)
3606        data_enc->codec_tag= data_codec_tag;
3607
3608    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3609        data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3610    }
3611    if (data_stream_copy) {
3612        st->stream_copy = 1;
3613    }
3614
3615    data_disable = 0;
3616    av_freep(&data_codec_name);
3617    data_stream_copy = 0;
3618}
3619
3620static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3621{
3622    AVStream *st;
3623    OutputStream *ost;
3624    AVCodec *codec=NULL;
3625    AVCodecContext *subtitle_enc;
3626    enum CodecID codec_id = CODEC_ID_NONE;
3627
3628    if(!subtitle_stream_copy){
3629        if (subtitle_codec_name) {
3630            codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1);
3631            codec = avcodec_find_encoder_by_name(subtitle_codec_name);
3632        } else {
3633            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_SUBTITLE);
3634            codec = avcodec_find_encoder(codec_id);
3635        }
3636    }
3637    ost = new_output_stream(oc, file_idx, codec);
3638    st  = ost->st;
3639    subtitle_enc = st->codec;
3640
3641    ost->bitstream_filters = subtitle_bitstream_filters;
3642    subtitle_bitstream_filters= NULL;
3643
3644    subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3645
3646    if(subtitle_codec_tag)
3647        subtitle_enc->codec_tag= subtitle_codec_tag;
3648
3649    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3650        subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3651    }
3652    if (subtitle_stream_copy) {
3653        st->stream_copy = 1;
3654    } else {
3655        subtitle_enc->codec_id = codec_id;
3656    }
3657
3658    if (subtitle_language) {
3659        av_dict_set(&st->metadata, "language", subtitle_language, 0);
3660        av_freep(&subtitle_language);
3661    }
3662
3663    subtitle_disable = 0;
3664    av_freep(&subtitle_codec_name);
3665    subtitle_stream_copy = 0;
3666}
3667
3668static int opt_new_stream(const char *opt, const char *arg)
3669{
3670    AVFormatContext *oc;
3671    int file_idx = nb_output_files - 1;
3672    if (nb_output_files <= 0) {
3673        fprintf(stderr, "At least one output file must be specified\n");
3674        exit_program(1);
3675    }
3676    oc = output_files[file_idx];
3677
3678    if      (!strcmp(opt, "newvideo"   )) new_video_stream   (oc, file_idx);
3679    else if (!strcmp(opt, "newaudio"   )) new_audio_stream   (oc, file_idx);
3680    else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3681    else if (!strcmp(opt, "newdata"    )) new_data_stream    (oc, file_idx);
3682    else av_assert0(0);
3683    return 0;
3684}
3685
3686/* arg format is "output-stream-index:streamid-value". */
3687static int opt_streamid(const char *opt, const char *arg)
3688{
3689    int idx;
3690    char *p;
3691    char idx_str[16];
3692
3693    av_strlcpy(idx_str, arg, sizeof(idx_str));
3694    p = strchr(idx_str, ':');
3695    if (!p) {
3696        fprintf(stderr,
3697                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3698                arg, opt);
3699        exit_program(1);
3700    }
3701    *p++ = '\0';
3702    idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
3703    streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3704    streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3705    return 0;
3706}
3707
3708static void opt_output_file(void *optctx, const char *filename)
3709{
3710    AVFormatContext *oc;
3711    int err, use_video, use_audio, use_subtitle, use_data;
3712    int input_has_video, input_has_audio, input_has_subtitle, input_has_data;
3713    AVOutputFormat *file_oformat;
3714
3715    if (!strcmp(filename, "-"))
3716        filename = "pipe:";
3717
3718    oc = avformat_alloc_context();
3719    if (!oc) {
3720        print_error(filename, AVERROR(ENOMEM));
3721        exit_program(1);
3722    }
3723
3724    if (last_asked_format) {
3725        file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3726        if (!file_oformat) {
3727            fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3728            exit_program(1);
3729        }
3730        last_asked_format = NULL;
3731    } else {
3732        file_oformat = av_guess_format(NULL, filename, NULL);
3733        if (!file_oformat) {
3734            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3735                    filename);
3736            exit_program(1);
3737        }
3738    }
3739
3740    oc->oformat = file_oformat;
3741    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3742
3743    if (!strcmp(file_oformat->name, "ffm") &&
3744        av_strstart(filename, "http:", NULL)) {
3745        /* special case for files sent to avserver: we get the stream
3746           parameters from avserver */
3747        int err = read_avserver_streams(oc, filename);
3748        if (err < 0) {
3749            print_error(filename, err);
3750            exit_program(1);
3751        }
3752    } else {
3753        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3754        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3755        use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3756        use_data = data_stream_copy ||  data_codec_name; /* XXX once generic data codec will be available add a ->data_codec reference and use it here */
3757
3758        /* disable if no corresponding type found */
3759        check_inputs(&input_has_video,
3760                     &input_has_audio,
3761                     &input_has_subtitle,
3762                     &input_has_data);
3763
3764        if (!input_has_video)
3765            use_video = 0;
3766        if (!input_has_audio)
3767            use_audio = 0;
3768        if (!input_has_subtitle)
3769            use_subtitle = 0;
3770        if (!input_has_data)
3771            use_data = 0;
3772
3773        /* manual disable */
3774        if (audio_disable)    use_audio    = 0;
3775        if (video_disable)    use_video    = 0;
3776        if (subtitle_disable) use_subtitle = 0;
3777        if (data_disable)     use_data     = 0;
3778
3779        if (use_video)    new_video_stream(oc, nb_output_files);
3780        if (use_audio)    new_audio_stream(oc, nb_output_files);
3781        if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3782        if (use_data)     new_data_stream(oc, nb_output_files);
3783
3784        av_dict_copy(&oc->metadata, metadata, 0);
3785        av_dict_free(&metadata);
3786    }
3787
3788    av_dict_copy(&output_opts[nb_output_files], format_opts, 0);
3789    output_files[nb_output_files++] = oc;
3790
3791    /* check filename in case of an image number is expected */
3792    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3793        if (!av_filename_number_test(oc->filename)) {
3794            print_error(oc->filename, AVERROR(EINVAL));
3795            exit_program(1);
3796        }
3797    }
3798
3799    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3800        /* test if it already exists to avoid losing precious files */
3801        if (!file_overwrite &&
3802            (strchr(filename, ':') == NULL ||
3803             filename[1] == ':' ||
3804             av_strstart(filename, "file:", NULL))) {
3805            if (avio_check(filename, 0) == 0) {
3806                if (!using_stdin) {
3807                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3808                    fflush(stderr);
3809                    if (!read_yesno()) {
3810                        fprintf(stderr, "Not overwriting - exiting\n");
3811                        exit_program(1);
3812                    }
3813                }
3814                else {
3815                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3816                    exit_program(1);
3817                }
3818            }
3819        }
3820
3821        /* open the file */
3822        if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3823            print_error(filename, err);
3824            exit_program(1);
3825        }
3826    }
3827
3828    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3829    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3830    if (loop_output >= 0) {
3831        av_log(NULL, AV_LOG_WARNING, "-loop_output is deprecated, use -loop\n");
3832        oc->loop_output = loop_output;
3833    }
3834    oc->flags |= AVFMT_FLAG_NONBLOCK;
3835
3836    frame_rate    = (AVRational){0, 0};
3837    frame_width   = 0;
3838    frame_height  = 0;
3839    audio_sample_rate = 0;
3840    audio_channels    = 0;
3841    audio_sample_fmt  = AV_SAMPLE_FMT_NONE;
3842
3843    av_freep(&forced_key_frames);
3844    uninit_opts();
3845    init_opts();
3846}
3847
3848/* same option as mencoder */
3849static int opt_pass(const char *opt, const char *arg)
3850{
3851    do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3852    return 0;
3853}
3854
3855static int64_t getutime(void)
3856{
3857#if HAVE_GETRUSAGE
3858    struct rusage rusage;
3859
3860    getrusage(RUSAGE_SELF, &rusage);
3861    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3862#elif HAVE_GETPROCESSTIMES
3863    HANDLE proc;
3864    FILETIME c, e, k, u;
3865    proc = GetCurrentProcess();
3866    GetProcessTimes(proc, &c, &e, &k, &u);
3867    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3868#else
3869    return av_gettime();
3870#endif
3871}
3872
3873static int64_t getmaxrss(void)
3874{
3875#if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3876    struct rusage rusage;
3877    getrusage(RUSAGE_SELF, &rusage);
3878    return (int64_t)rusage.ru_maxrss * 1024;
3879#elif HAVE_GETPROCESSMEMORYINFO
3880    HANDLE proc;
3881    PROCESS_MEMORY_COUNTERS memcounters;
3882    proc = GetCurrentProcess();
3883    memcounters.cb = sizeof(memcounters);
3884    GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3885    return memcounters.PeakPagefileUsage;
3886#else
3887    return 0;
3888#endif
3889}
3890
3891static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3892{
3893    int i;
3894    const char *p = str;
3895    for(i = 0;; i++) {
3896        dest[i] = atoi(p);
3897        if(i == 63)
3898            break;
3899        p = strchr(p, ',');
3900        if(!p) {
3901            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3902            exit_program(1);
3903        }
3904        p++;
3905    }
3906}
3907
3908static void opt_inter_matrix(const char *arg)
3909{
3910    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3911    parse_matrix_coeffs(inter_matrix, arg);
3912}
3913
3914static void opt_intra_matrix(const char *arg)
3915{
3916    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3917    parse_matrix_coeffs(intra_matrix, arg);
3918}
3919
3920static void show_usage(void)
3921{
3922    printf("Hyper fast Audio and Video encoder\n");
3923    printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3924    printf("\n");
3925}
3926
3927static void show_help(void)
3928{
3929    AVCodec *c;
3930    AVOutputFormat *oformat = NULL;
3931    AVInputFormat  *iformat = NULL;
3932    const AVClass *class;
3933
3934    av_log_set_callback(log_callback_help);
3935    show_usage();
3936    show_help_options(options, "Main options:\n",
3937                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3938    show_help_options(options, "\nAdvanced options:\n",
3939                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3940                      OPT_EXPERT);
3941    show_help_options(options, "\nVideo options:\n",
3942                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3943                      OPT_VIDEO);
3944    show_help_options(options, "\nAdvanced Video options:\n",
3945                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3946                      OPT_VIDEO | OPT_EXPERT);
3947    show_help_options(options, "\nAudio options:\n",
3948                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3949                      OPT_AUDIO);
3950    show_help_options(options, "\nAdvanced Audio options:\n",
3951                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3952                      OPT_AUDIO | OPT_EXPERT);
3953    show_help_options(options, "\nSubtitle options:\n",
3954                      OPT_SUBTITLE | OPT_GRAB,
3955                      OPT_SUBTITLE);
3956    show_help_options(options, "\nAudio/Video grab options:\n",
3957                      OPT_GRAB,
3958                      OPT_GRAB);
3959    printf("\n");
3960    class = avcodec_get_class();
3961    av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3962    printf("\n");
3963
3964    /* individual codec options */
3965    c = NULL;
3966    while ((c = av_codec_next(c))) {
3967        if (c->priv_class) {
3968            av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3969            printf("\n");
3970        }
3971    }
3972
3973    class = avformat_get_class();
3974    av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3975    printf("\n");
3976
3977    /* individual muxer options */
3978    while ((oformat = av_oformat_next(oformat))) {
3979        if (oformat->priv_class) {
3980            av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
3981            printf("\n");
3982        }
3983    }
3984
3985    /* individual demuxer options */
3986    while ((iformat = av_iformat_next(iformat))) {
3987        if (iformat->priv_class) {
3988            av_opt_show2(&iformat->priv_class, NULL, AV_OPT_FLAG_DECODING_PARAM, 0);
3989            printf("\n");
3990        }
3991    }
3992
3993    class = sws_get_class();
3994    av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3995}
3996
3997static int opt_target(const char *opt, const char *arg)
3998{
3999    enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4000    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
4001
4002    if(!strncmp(arg, "pal-", 4)) {
4003        norm = PAL;
4004        arg += 4;
4005    } else if(!strncmp(arg, "ntsc-", 5)) {
4006        norm = NTSC;
4007        arg += 5;
4008    } else if(!strncmp(arg, "film-", 5)) {
4009        norm = FILM;
4010        arg += 5;
4011    } else {
4012        int fr;
4013        /* Calculate FR via float to avoid int overflow */
4014        fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
4015        if(fr == 25000) {
4016            norm = PAL;
4017        } else if((fr == 29970) || (fr == 23976)) {
4018            norm = NTSC;
4019        } else {
4020            /* Try to determine PAL/NTSC by peeking in the input files */
4021            if(nb_input_files) {
4022                int i, j;
4023                for (j = 0; j < nb_input_files; j++) {
4024                    for (i = 0; i < input_files[j].ctx->nb_streams; i++) {
4025                        AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
4026                        if(c->codec_type != AVMEDIA_TYPE_VIDEO)
4027                            continue;
4028                        fr = c->time_base.den * 1000 / c->time_base.num;
4029                        if(fr == 25000) {
4030                            norm = PAL;
4031                            break;
4032                        } else if((fr == 29970) || (fr == 23976)) {
4033                            norm = NTSC;
4034                            break;
4035                        }
4036                    }
4037                    if(norm != UNKNOWN)
4038                        break;
4039                }
4040            }
4041        }
4042        if(verbose > 0 && norm != UNKNOWN)
4043            fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4044    }
4045
4046    if(norm == UNKNOWN) {
4047        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4048        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4049        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4050        exit_program(1);
4051    }
4052
4053    if(!strcmp(arg, "vcd")) {
4054        opt_video_codec("vcodec", "mpeg1video");
4055        opt_audio_codec("vcodec", "mp2");
4056        opt_format("f", "vcd");
4057
4058        opt_frame_size("s", norm == PAL ? "352x288" : "352x240");
4059        opt_frame_rate("r", frame_rates[norm]);
4060        opt_default("g", norm == PAL ? "15" : "18");
4061
4062        opt_default("b", "1150000");
4063        opt_default("maxrate", "1150000");
4064        opt_default("minrate", "1150000");
4065        opt_default("bufsize", "327680"); // 40*1024*8;
4066
4067        opt_default("ab", "224000");
4068        audio_sample_rate = 44100;
4069        audio_channels = 2;
4070
4071        opt_default("packetsize", "2324");
4072        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4073
4074        /* We have to offset the PTS, so that it is consistent with the SCR.
4075           SCR starts at 36000, but the first two packs contain only padding
4076           and the first pack from the other stream, respectively, may also have
4077           been written before.
4078           So the real data starts at SCR 36000+3*1200. */
4079        mux_preload= (36000+3*1200) / 90000.0; //0.44
4080    } else if(!strcmp(arg, "svcd")) {
4081
4082        opt_video_codec("vcodec", "mpeg2video");
4083        opt_audio_codec("acodec", "mp2");
4084        opt_format("f", "svcd");
4085
4086        opt_frame_size("s", norm == PAL ? "480x576" : "480x480");
4087        opt_frame_rate("r", frame_rates[norm]);
4088        opt_default("g", norm == PAL ? "15" : "18");
4089
4090        opt_default("b", "2040000");
4091        opt_default("maxrate", "2516000");
4092        opt_default("minrate", "0"); //1145000;
4093        opt_default("bufsize", "1835008"); //224*1024*8;
4094        opt_default("flags", "+scan_offset");
4095
4096
4097        opt_default("ab", "224000");
4098        audio_sample_rate = 44100;
4099
4100        opt_default("packetsize", "2324");
4101
4102    } else if(!strcmp(arg, "dvd")) {
4103
4104        opt_video_codec("vcodec", "mpeg2video");
4105        opt_audio_codec("vcodec", "ac3");
4106        opt_format("f", "dvd");
4107
4108        opt_frame_size("vcodec", norm == PAL ? "720x576" : "720x480");
4109        opt_frame_rate("r", frame_rates[norm]);
4110        opt_default("g", norm == PAL ? "15" : "18");
4111
4112        opt_default("b", "6000000");
4113        opt_default("maxrate", "9000000");
4114        opt_default("minrate", "0"); //1500000;
4115        opt_default("bufsize", "1835008"); //224*1024*8;
4116
4117        opt_default("packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4118        opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4119
4120        opt_default("ab", "448000");
4121        audio_sample_rate = 48000;
4122
4123    } else if(!strncmp(arg, "dv", 2)) {
4124
4125        opt_format("f", "dv");
4126
4127        opt_frame_size("s", norm == PAL ? "720x576" : "720x480");
4128        opt_frame_pix_fmt("pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4129                          norm == PAL ? "yuv420p" : "yuv411p");
4130        opt_frame_rate("r", frame_rates[norm]);
4131
4132        audio_sample_rate = 48000;
4133        audio_channels = 2;
4134
4135    } else {
4136        fprintf(stderr, "Unknown target: %s\n", arg);
4137        return AVERROR(EINVAL);
4138    }
4139    return 0;
4140}
4141
4142static int opt_vstats_file(const char *opt, const char *arg)
4143{
4144    av_free (vstats_filename);
4145    vstats_filename=av_strdup (arg);
4146    return 0;
4147}
4148
4149static int opt_vstats(const char *opt, const char *arg)
4150{
4151    char filename[40];
4152    time_t today2 = time(NULL);
4153    struct tm *today = localtime(&today2);
4154
4155    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4156             today->tm_sec);
4157    return opt_vstats_file(opt, filename);
4158}
4159
4160static int opt_bsf(const char *opt, const char *arg)
4161{
4162    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4163    AVBitStreamFilterContext **bsfp;
4164
4165    if(!bsfc){
4166        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4167        exit_program(1);
4168    }
4169
4170    bsfp= *opt == 'v' ? &video_bitstream_filters :
4171          *opt == 'a' ? &audio_bitstream_filters :
4172                        &subtitle_bitstream_filters;
4173    while(*bsfp)
4174        bsfp= &(*bsfp)->next;
4175
4176    *bsfp= bsfc;
4177
4178    return 0;
4179}
4180
4181static int opt_preset(const char *opt, const char *arg)
4182{
4183    FILE *f=NULL;
4184    char filename[1000], tmp[1000], tmp2[1000], line[1000];
4185    char *codec_name = *opt == 'v' ? video_codec_name :
4186                       *opt == 'a' ? audio_codec_name :
4187                                     subtitle_codec_name;
4188
4189    if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4190        fprintf(stderr, "File for preset '%s' not found\n", arg);
4191        exit_program(1);
4192    }
4193
4194    while(!feof(f)){
4195        int e= fscanf(f, "%999[^\n]\n", line) - 1;
4196        if(line[0] == '#' && !e)
4197            continue;
4198        e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4199        if(e){
4200            fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4201            exit_program(1);
4202        }
4203        if(!strcmp(tmp, "acodec")){
4204            opt_audio_codec(tmp, tmp2);
4205        }else if(!strcmp(tmp, "vcodec")){
4206            opt_video_codec(tmp, tmp2);
4207        }else if(!strcmp(tmp, "scodec")){
4208            opt_subtitle_codec(tmp, tmp2);
4209        }else if(!strcmp(tmp, "dcodec")){
4210            opt_data_codec(tmp, tmp2);
4211        }else if(opt_default(tmp, tmp2) < 0){
4212            fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4213            exit_program(1);
4214        }
4215    }
4216
4217    fclose(f);
4218
4219    return 0;
4220}
4221
4222static const OptionDef options[] = {
4223    /* main options */
4224#include "cmdutils_common_opts.h"
4225    { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4226    { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4227    { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4228    { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4229    { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
4230      "outfile[,metadata]:infile[,metadata]" },
4231    { "map_metadata", HAS_ARG | OPT_EXPERT, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4232      "outfile[,metadata]:infile[,metadata]" },
4233    { "map_chapters",  HAS_ARG | OPT_EXPERT, {(void*)opt_map_chapters},  "set chapters mapping", "outfile:infile" },
4234    { "t", HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4235    { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4236    { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4237    { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4238    { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
4239    { "timestamp", HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4240    { "metadata", HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4241    { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4242    { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4243      "add timings for benchmarking" },
4244    { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4245    { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4246      "dump each input packet" },
4247    { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4248      "when dumping packets, also dump the payload" },
4249    { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4250    { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "deprecated, use -loop" },
4251    { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "deprecated, use -loop", "" },
4252    { "v", HAS_ARG, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
4253    { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4254    { "threads",  HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4255    { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4256    { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4257    { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4258    { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
4259    { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)&copy_tb}, "copy input stream time base when stream copying" },
4260    { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4261    { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4262    { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4263    { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4264    { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)&copy_initial_nonkeyframes}, "copy initial non-keyframes" },
4265
4266    /* video options */
4267    { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4268    { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4269    { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4270    { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4271    { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format, 'list' as argument shows all the pixel formats supported", "format" },
4272    { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4273    { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4274    { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4275    { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4276    { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4277    { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4278    { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4279    { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4280    { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4281    { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4282    { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4283    { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4284    { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4285    { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4286    { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4287    { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "threshold" },
4288    { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4289      "use same quantizer as source (implies VBR)" },
4290    { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4291    { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4292    { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4293      "deinterlace pictures" },
4294    { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4295    { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4296    { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4297#if CONFIG_AVFILTER
4298    { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4299#endif
4300    { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4301    { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4302    { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4303    { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4304    { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4305    { "newvideo", OPT_VIDEO, {(void*)opt_new_stream}, "add a new video stream to the current output stream" },
4306    { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4307    { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4308    { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4309    { "streamid", HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4310    { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4311
4312    /* audio options */
4313    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4314    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4315    { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4316    { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4317    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4318    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4319    { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4320    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4321    { "newaudio", OPT_AUDIO, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
4322    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4323    { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_sample_fmt}, "set sample format, 'list' as argument shows all the sample formats supported", "format" },
4324
4325    /* subtitle options */
4326    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4327    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4328    { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4329    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4330    { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4331
4332    /* grab options */
4333    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "deprecated, use -channel", "channel" },
4334    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "deprecated, use -standard", "standard" },
4335    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4336
4337    /* muxer options */
4338    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4339    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4340
4341    { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4342    { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4343    { "sbsf", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4344
4345    { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4346    { "vpre", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4347    { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4348    { "fpre", HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4349    /* data codec support */
4350    { "dcodec", HAS_ARG | OPT_DATA, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4351
4352    { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4353    { NULL, },
4354};
4355
4356int main(int argc, char **argv)
4357{
4358    int64_t ti;
4359
4360    av_log_set_flags(AV_LOG_SKIP_REPEATED);
4361    parse_loglevel(argc, argv, options);
4362
4363    avcodec_register_all();
4364#if CONFIG_AVDEVICE
4365    avdevice_register_all();
4366#endif
4367#if CONFIG_AVFILTER
4368    avfilter_register_all();
4369#endif
4370    av_register_all();
4371    avformat_network_init();
4372
4373    avio_set_interrupt_cb(decode_interrupt_cb);
4374
4375    init_opts();
4376
4377    show_banner();
4378
4379    av_log(NULL, AV_LOG_WARNING, "This program is not developed anymore and is only "
4380                                 "provided for compatibility. Use avconv instead "
4381                                 "(see Changelog for the list of incompatible changes).\n");
4382
4383    /* parse options */
4384    parse_options(NULL, argc, argv, options, opt_output_file);
4385
4386    if(nb_output_files <= 0 && nb_input_files == 0) {
4387        show_usage();
4388        fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4389        exit_program(1);
4390    }
4391
4392    /* file converter / grab */
4393    if (nb_output_files <= 0) {
4394        fprintf(stderr, "At least one output file must be specified\n");
4395        exit_program(1);
4396    }
4397
4398    if (nb_input_files == 0) {
4399        fprintf(stderr, "At least one input file must be specified\n");
4400        exit_program(1);
4401    }
4402
4403    ti = getutime();
4404    if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4405                  stream_maps, nb_stream_maps) < 0)
4406        exit_program(1);
4407    ti = getutime() - ti;
4408    if (do_benchmark) {
4409        int maxrss = getmaxrss() / 1024;
4410        printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4411    }
4412
4413    exit_program(0);
4414    return 0;
4415}
4416