git.sesse.net Git - ffmpeg/blob - ffmpeg.c

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