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