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

   1 /*
   2  * ffmpeg main
   3  * Copyright (c) 2000-2003 Fabrice Bellard
   4  *
   5  * This file is part of Libav.
   6  *
   7  * Libav is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * Libav is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with Libav; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 #include "config.h"
  23 #include <ctype.h>
  24 #include <string.h>
  25 #include <math.h>
  26 #include <stdlib.h>
  27 #include <errno.h>
  28 #include <signal.h>
  29 #include <limits.h>
  30 #include <unistd.h>
  31 #include "libavformat/avformat.h"
  32 #include "libavdevice/avdevice.h"
  33 #include "libswscale/swscale.h"
  34 #include "libavutil/opt.h"
  35 #include "libavcodec/audioconvert.h"
  36 #include "libavutil/audioconvert.h"
  37 #include "libavutil/parseutils.h"
  38 #include "libavutil/samplefmt.h"
  39 #include "libavutil/colorspace.h"
  40 #include "libavutil/fifo.h"
  41 #include "libavutil/intreadwrite.h"
  42 #include "libavutil/dict.h"
  43 #include "libavutil/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)
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 = same_quality ? ist->st->quality : ost->st->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
1484     AVPacket avpkt;
1485     int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
1486
1487     if(ist->next_pts == AV_NOPTS_VALUE)
1488         ist->next_pts= ist->pts;
1489
1490     if (pkt == NULL) {
1491         /* EOF handling */
1492         av_init_packet(&avpkt);
1493         avpkt.data = NULL;
1494         avpkt.size = 0;
1495         goto handle_eof;
1496     } else {
1497         avpkt = *pkt;
1498     }
1499
1500     if(pkt->dts != AV_NOPTS_VALUE)
1501         ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1502     if(pkt->pts != AV_NOPTS_VALUE)
1503         pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1504
1505     //while we have more to decode or while the decoder did output something on EOF
1506     while (avpkt.size > 0 || (!pkt && got_output)) {
1507         uint8_t *data_buf, *decoded_data_buf;
1508         int data_size, decoded_data_size;
1509     handle_eof:
1510         ist->pts= ist->next_pts;
1511
1512         if(avpkt.size && avpkt.size != pkt->size &&
1513            ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1514             fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1515             ist->showed_multi_packet_warning=1;
1516         }
1517
1518         /* decode the packet if needed */
1519         decoded_data_buf = NULL; /* fail safe */
1520         decoded_data_size= 0;
1521         data_buf  = avpkt.data;
1522         data_size = avpkt.size;
1523         subtitle_to_free = NULL;
1524         if (ist->decoding_needed) {
1525             switch(ist->st->codec->codec_type) {
1526             case AVMEDIA_TYPE_AUDIO:{
1527                 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1528                     samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1529                     av_free(samples);
1530                     samples= av_malloc(samples_size);
1531                 }
1532                 decoded_data_size= samples_size;
1533                     /* XXX: could avoid copy if PCM 16 bits with same
1534                        endianness as CPU */
1535                 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1536                                             &avpkt);
1537                 if (ret < 0)
1538                     goto fail_decode;
1539                 avpkt.data += ret;
1540                 avpkt.size -= ret;
1541                 data_size   = ret;
1542                 got_output  = decoded_data_size > 0;
1543                 /* Some bug in mpeg audio decoder gives */
1544                 /* decoded_data_size < 0, it seems they are overflows */
1545                 if (!got_output) {
1546                     /* no audio frame */
1547                     continue;
1548                 }
1549                 decoded_data_buf = (uint8_t *)samples;
1550                 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1551                     (ist->st->codec->sample_rate * ist->st->codec->channels);
1552                 break;}
1553             case AVMEDIA_TYPE_VIDEO:
1554                     decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1555                     /* XXX: allocate picture correctly */
1556                     avcodec_get_frame_defaults(&picture);
1557                     avpkt.pts = pkt_pts;
1558                     avpkt.dts = ist->pts;
1559                     pkt_pts = AV_NOPTS_VALUE;
1560
1561                     ret = avcodec_decode_video2(ist->st->codec,
1562                                                 &picture, &got_output, &avpkt);
1563                     ist->st->quality= picture.quality;
1564                     if (ret < 0)
1565                         goto fail_decode;
1566                     if (!got_output) {
1567                         /* no picture yet */
1568                         goto discard_packet;
1569                     }
1570                     ist->next_pts = ist->pts = guess_correct_pts(&ist->pts_ctx, picture.pkt_pts, picture.pkt_dts);
1571                     if (ist->st->codec->time_base.num != 0) {
1572                         int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1573                         ist->next_pts += ((int64_t)AV_TIME_BASE *
1574                                           ist->st->codec->time_base.num * ticks) /
1575                             ist->st->codec->time_base.den;
1576                     }
1577                     avpkt.size = 0;
1578                     buffer_to_free = NULL;
1579                     pre_process_video_frame(ist, (AVPicture *)&picture, &buffer_to_free);
1580                     break;
1581             case AVMEDIA_TYPE_SUBTITLE:
1582                 ret = avcodec_decode_subtitle2(ist->st->codec,
1583                                                &subtitle, &got_output, &avpkt);
1584                 if (ret < 0)
1585                     goto fail_decode;
1586                 if (!got_output) {
1587                     goto discard_packet;
1588                 }
1589                 subtitle_to_free = &subtitle;
1590                 avpkt.size = 0;
1591                 break;
1592             default:
1593                 goto fail_decode;
1594             }
1595         } else {
1596             switch(ist->st->codec->codec_type) {
1597             case AVMEDIA_TYPE_AUDIO:
1598                 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1599                     ist->st->codec->sample_rate;
1600                 break;
1601             case AVMEDIA_TYPE_VIDEO:
1602                 if (ist->st->codec->time_base.num != 0) {
1603                     int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1604                     ist->next_pts += ((int64_t)AV_TIME_BASE *
1605                                       ist->st->codec->time_base.num * ticks) /
1606                         ist->st->codec->time_base.den;
1607                 }
1608                 break;
1609             }
1610             ret = avpkt.size;
1611             avpkt.size = 0;
1612         }
1613
1614 #if CONFIG_AVFILTER
1615         if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1616             for (i = 0; i < nb_ostreams; i++) {
1617                 ost = ost_table[i];
1618                 if (ost->input_video_filter && ost->source_index == ist_index) {
1619                     AVRational sar;
1620                     if (ist->st->sample_aspect_ratio.num)
1621                         sar = ist->st->sample_aspect_ratio;
1622                     else
1623                         sar = ist->st->codec->sample_aspect_ratio;
1624                     // add it to be filtered
1625                     av_vsrc_buffer_add_frame(ost->input_video_filter, &picture,
1626                                              ist->pts,
1627                                              sar);
1628                 }
1629             }
1630         }
1631 #endif
1632
1633         // preprocess audio (volume)
1634         if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1635             if (audio_volume != 256) {
1636                 short *volp;
1637                 volp = samples;
1638                 for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1639                     int v = ((*volp) * audio_volume + 128) >> 8;
1640                     if (v < -32768) v = -32768;
1641                     if (v >  32767) v = 32767;
1642                     *volp++ = v;
1643                 }
1644             }
1645         }
1646
1647         /* frame rate emulation */
1648         if (rate_emu) {
1649             int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1650             int64_t now = av_gettime() - ist->start;
1651             if (pts > now)
1652                 usleep(pts - now);
1653         }
1654         /* if output time reached then transcode raw format,
1655            encode packets and output them */
1656         if (start_time == 0 || ist->pts >= start_time)
1657             for(i=0;i<nb_ostreams;i++) {
1658                 int frame_size;
1659
1660                 ost = ost_table[i];
1661                 if (ost->source_index == ist_index) {
1662 #if CONFIG_AVFILTER
1663                 frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1664                     !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1665                 while (frame_available) {
1666                     AVRational ist_pts_tb;
1667                     if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter)
1668                         get_filtered_video_frame(ost->output_video_filter, &picture, &ost->picref, &ist_pts_tb);
1669                     if (ost->picref)
1670                         ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1671 #endif
1672                     os = output_files[ost->file_index];
1673
1674                     /* set the input output pts pairs */
1675                     //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1676
1677                     if (ost->encoding_needed) {
1678                         av_assert0(ist->decoding_needed);
1679                         switch(ost->st->codec->codec_type) {
1680                         case AVMEDIA_TYPE_AUDIO:
1681                             do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1682                             break;
1683                         case AVMEDIA_TYPE_VIDEO:
1684 #if CONFIG_AVFILTER
1685                             if (ost->picref->video && !ost->frame_aspect_ratio)
1686                                 ost->st->codec->sample_aspect_ratio = ost->picref->video->pixel_aspect;
1687 #endif
1688                             do_video_out(os, ost, ist, &picture, &frame_size);
1689                             if (vstats_filename && frame_size)
1690                                 do_video_stats(os, ost, frame_size);
1691                             break;
1692                         case AVMEDIA_TYPE_SUBTITLE:
1693                             do_subtitle_out(os, ost, ist, &subtitle,
1694                                             pkt->pts);
1695                             break;
1696                         default:
1697                             abort();
1698                         }
1699                     } else {
1700                         AVFrame avframe; //FIXME/XXX remove this
1701                         AVPacket opkt;
1702                         int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1703
1704                         av_init_packet(&opkt);
1705
1706                         if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1707 #if !CONFIG_AVFILTER
1708                             continue;
1709 #else
1710                             goto cont;
1711 #endif
1712
1713                         /* no reencoding needed : output the packet directly */
1714                         /* force the input stream PTS */
1715
1716                         avcodec_get_frame_defaults(&avframe);
1717                         ost->st->codec->coded_frame= &avframe;
1718                         avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1719
1720                         if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1721                             audio_size += data_size;
1722                         else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1723                             video_size += data_size;
1724                             ost->sync_opts++;
1725                         }
1726
1727                         opkt.stream_index= ost->index;
1728                         if(pkt->pts != AV_NOPTS_VALUE)
1729                             opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1730                         else
1731                             opkt.pts= AV_NOPTS_VALUE;
1732
1733                         if (pkt->dts == AV_NOPTS_VALUE)
1734                             opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1735                         else
1736                             opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1737                         opkt.dts -= ost_tb_start_time;
1738
1739                         opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1740                         opkt.flags= pkt->flags;
1741
1742                         //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1743                         if(   ost->st->codec->codec_id != CODEC_ID_H264
1744                            && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1745                            && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1746                            ) {
1747                             if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1748                                 opkt.destruct= av_destruct_packet;
1749                         } else {
1750                             opkt.data = data_buf;
1751                             opkt.size = data_size;
1752                         }
1753
1754                         write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1755                         ost->st->codec->frame_number++;
1756                         ost->frame_number++;
1757                         av_free_packet(&opkt);
1758                     }
1759 #if CONFIG_AVFILTER
1760                     cont:
1761                     frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1762                                        ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1763                     if (ost->picref)
1764                         avfilter_unref_buffer(ost->picref);
1765                 }
1766 #endif
1767                 }
1768             }
1769
1770         av_free(buffer_to_free);
1771         /* XXX: allocate the subtitles in the codec ? */
1772         if (subtitle_to_free) {
1773             avsubtitle_free(subtitle_to_free);
1774             subtitle_to_free = NULL;
1775         }
1776     }
1777  discard_packet:
1778     if (pkt == NULL) {
1779         /* EOF handling */
1780
1781         for(i=0;i<nb_ostreams;i++) {
1782             ost = ost_table[i];
1783             if (ost->source_index == ist_index) {
1784                 AVCodecContext *enc= ost->st->codec;
1785                 os = output_files[ost->file_index];
1786
1787                 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1788                     continue;
1789                 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1790                     continue;
1791
1792                 if (ost->encoding_needed) {
1793                     for(;;) {
1794                         AVPacket pkt;
1795                         int fifo_bytes;
1796                         av_init_packet(&pkt);
1797                         pkt.stream_index= ost->index;
1798
1799                         switch(ost->st->codec->codec_type) {
1800                         case AVMEDIA_TYPE_AUDIO:
1801                             fifo_bytes = av_fifo_size(ost->fifo);
1802                             ret = 0;
1803                             /* encode any samples remaining in fifo */
1804                             if (fifo_bytes > 0) {
1805                                 int osize = av_get_bytes_per_sample(enc->sample_fmt);
1806                                 int fs_tmp = enc->frame_size;
1807
1808                                 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1809                                 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1810                                     enc->frame_size = fifo_bytes / (osize * enc->channels);
1811                                 } else { /* pad */
1812                                     int frame_bytes = enc->frame_size*osize*enc->channels;
1813                                     if (allocated_audio_buf_size < frame_bytes)
1814                                         ffmpeg_exit(1);
1815                                     generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1816                                 }
1817
1818                                 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1819                                 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1820                                                           ost->st->time_base.num, enc->sample_rate);
1821                                 enc->frame_size = fs_tmp;
1822                             }
1823                             if(ret <= 0) {
1824                                 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1825                             }
1826                             if (ret < 0) {
1827                                 fprintf(stderr, "Audio encoding failed\n");
1828                                 ffmpeg_exit(1);
1829                             }
1830                             audio_size += ret;
1831                             pkt.flags |= AV_PKT_FLAG_KEY;
1832                             break;
1833                         case AVMEDIA_TYPE_VIDEO:
1834                             ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1835                             if (ret < 0) {
1836                                 fprintf(stderr, "Video encoding failed\n");
1837                                 ffmpeg_exit(1);
1838                             }
1839                             video_size += ret;
1840                             if(enc->coded_frame && enc->coded_frame->key_frame)
1841                                 pkt.flags |= AV_PKT_FLAG_KEY;
1842                             if (ost->logfile && enc->stats_out) {
1843                                 fprintf(ost->logfile, "%s", enc->stats_out);
1844                             }
1845                             break;
1846                         default:
1847                             ret=-1;
1848                         }
1849
1850                         if(ret<=0)
1851                             break;
1852                         pkt.data= bit_buffer;
1853                         pkt.size= ret;
1854                         if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1855                             pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1856                         write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1857                     }
1858                 }
1859             }
1860         }
1861     }
1862
1863     return 0;
1864  fail_decode:
1865     return -1;
1866 }
1867
1868 static void print_sdp(AVFormatContext **avc, int n)
1869 {
1870     char sdp[2048];
1871
1872     av_sdp_create(avc, n, sdp, sizeof(sdp));
1873     printf("SDP:\n%s\n", sdp);
1874     fflush(stdout);
1875 }
1876
1877 static int copy_chapters(int infile, int outfile)
1878 {
1879     AVFormatContext *is = input_files[infile].ctx;
1880     AVFormatContext *os = output_files[outfile];
1881     int i;
1882
1883     for (i = 0; i < is->nb_chapters; i++) {
1884         AVChapter *in_ch = is->chapters[i], *out_ch;
1885         int64_t ts_off   = av_rescale_q(start_time - input_files_ts_offset[infile],
1886                                       AV_TIME_BASE_Q, in_ch->time_base);
1887         int64_t rt       = (recording_time == INT64_MAX) ? INT64_MAX :
1888                            av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1889
1890
1891         if (in_ch->end < ts_off)
1892             continue;
1893         if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1894             break;
1895
1896         out_ch = av_mallocz(sizeof(AVChapter));
1897         if (!out_ch)
1898             return AVERROR(ENOMEM);
1899
1900         out_ch->id        = in_ch->id;
1901         out_ch->time_base = in_ch->time_base;
1902         out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1903         out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1904
1905         if (metadata_chapters_autocopy)
1906             av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1907
1908         os->nb_chapters++;
1909         os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1910         if (!os->chapters)
1911             return AVERROR(ENOMEM);
1912         os->chapters[os->nb_chapters - 1] = out_ch;
1913     }
1914     return 0;
1915 }
1916
1917 static void parse_forced_key_frames(char *kf, AVOutputStream *ost,
1918                                     AVCodecContext *avctx)
1919 {
1920     char *p;
1921     int n = 1, i;
1922     int64_t t;
1923
1924     for (p = kf; *p; p++)
1925         if (*p == ',')
1926             n++;
1927     ost->forced_kf_count = n;
1928     ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
1929     if (!ost->forced_kf_pts) {
1930         av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
1931         ffmpeg_exit(1);
1932     }
1933     for (i = 0; i < n; i++) {
1934         p = i ? strchr(p, ',') + 1 : kf;
1935         t = parse_time_or_die("force_key_frames", p, 1);
1936         ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
1937     }
1938 }
1939
1940 /*
1941  * The following code is the main loop of the file converter
1942  */
1943 static int transcode(AVFormatContext **output_files,
1944                      int nb_output_files,
1945                      AVInputFile *input_files,
1946                      int nb_input_files,
1947                      AVStreamMap *stream_maps, int nb_stream_maps)
1948 {
1949     int ret = 0, i, j, k, n, nb_ostreams = 0;
1950     AVFormatContext *is, *os;
1951     AVCodecContext *codec, *icodec;
1952     AVOutputStream *ost, **ost_table = NULL;
1953     AVInputStream *ist;
1954     char error[1024];
1955     int want_sdp = 1;
1956     uint8_t no_packet[MAX_FILES]={0};
1957     int no_packet_count=0;
1958
1959     if (rate_emu)
1960         for (i = 0; i < nb_input_streams; i++)
1961             input_streams[i].start = av_gettime();
1962
1963     /* output stream init */
1964     nb_ostreams = 0;
1965     for(i=0;i<nb_output_files;i++) {
1966         os = output_files[i];
1967         if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
1968             av_dump_format(output_files[i], i, output_files[i]->filename, 1);
1969             fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1970             ret = AVERROR(EINVAL);
1971             goto fail;
1972         }
1973         nb_ostreams += os->nb_streams;
1974     }
1975     if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1976         fprintf(stderr, "Number of stream maps must match number of output streams\n");
1977         ret = AVERROR(EINVAL);
1978         goto fail;
1979     }
1980
1981     /* Sanity check the mapping args -- do the input files & streams exist? */
1982     for(i=0;i<nb_stream_maps;i++) {
1983         int fi = stream_maps[i].file_index;
1984         int si = stream_maps[i].stream_index;
1985
1986         if (fi < 0 || fi > nb_input_files - 1 ||
1987             si < 0 || si > input_files[fi].ctx->nb_streams - 1) {
1988             fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1989             ret = AVERROR(EINVAL);
1990             goto fail;
1991         }
1992         fi = stream_maps[i].sync_file_index;
1993         si = stream_maps[i].sync_stream_index;
1994         if (fi < 0 || fi > nb_input_files - 1 ||
1995             si < 0 || si > input_files[fi].ctx->nb_streams - 1) {
1996             fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1997             ret = AVERROR(EINVAL);
1998             goto fail;
1999         }
2000     }
2001
2002     ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
2003     if (!ost_table)
2004         goto fail;
2005     n = 0;
2006     for(k=0;k<nb_output_files;k++) {
2007         os = output_files[k];
2008         for(i=0;i<os->nb_streams;i++,n++) {
2009             int found;
2010             ost = ost_table[n] = output_streams_for_file[k][i];
2011             ost->st = os->streams[i];
2012             if (nb_stream_maps > 0) {
2013                 ost->source_index = input_files[stream_maps[n].file_index].ist_index +
2014                     stream_maps[n].stream_index;
2015
2016                 /* Sanity check that the stream types match */
2017                 if (input_streams[ost->source_index].st->codec->codec_type != ost->st->codec->codec_type) {
2018                     int i= ost->file_index;
2019                     av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2020                     fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
2021                         stream_maps[n].file_index, stream_maps[n].stream_index,
2022                         ost->file_index, ost->index);
2023                     ffmpeg_exit(1);
2024                 }
2025
2026             } else {
2027                 int best_nb_frames=-1;
2028                 /* get corresponding input stream index : we select the first one with the right type */
2029                 found = 0;
2030                 for (j = 0; j < nb_input_streams; j++) {
2031                     int skip=0;
2032                     ist = &input_streams[j];
2033                     if(opt_programid){
2034                         int pi,si;
2035                         AVFormatContext *f = input_files[ist->file_index].ctx;
2036                         skip=1;
2037                         for(pi=0; pi<f->nb_programs; pi++){
2038                             AVProgram *p= f->programs[pi];
2039                             if(p->id == opt_programid)
2040                                 for(si=0; si<p->nb_stream_indexes; si++){
2041                                     if(f->streams[ p->stream_index[si] ] == ist->st)
2042                                         skip=0;
2043                                 }
2044                         }
2045                     }
2046                     if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
2047                         ist->st->codec->codec_type == ost->st->codec->codec_type) {
2048                         if(best_nb_frames < ist->st->codec_info_nb_frames){
2049                             best_nb_frames= ist->st->codec_info_nb_frames;
2050                             ost->source_index = j;
2051                             found = 1;
2052                         }
2053                     }
2054                 }
2055
2056                 if (!found) {
2057                     if(! opt_programid) {
2058                         /* try again and reuse existing stream */
2059                         for (j = 0; j < nb_input_streams; j++) {
2060                             ist = &input_streams[j];
2061                             if (   ist->st->codec->codec_type == ost->st->codec->codec_type
2062                                 && ist->st->discard != AVDISCARD_ALL) {
2063                                 ost->source_index = j;
2064                                 found = 1;
2065                             }
2066                         }
2067                     }
2068                     if (!found) {
2069                         int i= ost->file_index;
2070                         av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2071                         fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
2072                                 ost->file_index, ost->index);
2073                         ffmpeg_exit(1);
2074                     }
2075                 }
2076             }
2077             ist = &input_streams[ost->source_index];
2078             ist->discard = 0;
2079             ost->sync_ist = (nb_stream_maps > 0) ?
2080                 &input_streams[input_files[stream_maps[n].sync_file_index].ist_index +
2081                          stream_maps[n].sync_stream_index] : ist;
2082         }
2083     }
2084
2085     /* for each output stream, we compute the right encoding parameters */
2086     for(i=0;i<nb_ostreams;i++) {
2087         ost = ost_table[i];
2088         os = output_files[ost->file_index];
2089         ist = &input_streams[ost->source_index];
2090
2091         codec = ost->st->codec;
2092         icodec = ist->st->codec;
2093
2094         if (metadata_streams_autocopy)
2095             av_dict_copy(&ost->st->metadata, ist->st->metadata,
2096                          AV_DICT_DONT_OVERWRITE);
2097
2098         ost->st->disposition = ist->st->disposition;
2099         codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2100         codec->chroma_sample_location = icodec->chroma_sample_location;
2101
2102         if (ost->st->stream_copy) {
2103             uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2104
2105             if (extra_size > INT_MAX)
2106                 goto fail;
2107
2108             /* if stream_copy is selected, no need to decode or encode */
2109             codec->codec_id = icodec->codec_id;
2110             codec->codec_type = icodec->codec_type;
2111
2112             if(!codec->codec_tag){
2113                 if(   !os->oformat->codec_tag
2114                    || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2115                    || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2116                     codec->codec_tag = icodec->codec_tag;
2117             }
2118
2119             codec->bit_rate = icodec->bit_rate;
2120             codec->rc_max_rate    = icodec->rc_max_rate;
2121             codec->rc_buffer_size = icodec->rc_buffer_size;
2122             codec->extradata= av_mallocz(extra_size);
2123             if (!codec->extradata)
2124                 goto fail;
2125             memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2126             codec->extradata_size= icodec->extradata_size;
2127             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){
2128                 codec->time_base = icodec->time_base;
2129                 codec->time_base.num *= icodec->ticks_per_frame;
2130                 av_reduce(&codec->time_base.num, &codec->time_base.den,
2131                           codec->time_base.num, codec->time_base.den, INT_MAX);
2132             }else
2133                 codec->time_base = ist->st->time_base;
2134             switch(codec->codec_type) {
2135             case AVMEDIA_TYPE_AUDIO:
2136                 if(audio_volume != 256) {
2137                     fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2138                     ffmpeg_exit(1);
2139                 }
2140                 codec->channel_layout = icodec->channel_layout;
2141                 codec->sample_rate = icodec->sample_rate;
2142                 codec->channels = icodec->channels;
2143                 codec->frame_size = icodec->frame_size;
2144                 codec->audio_service_type = icodec->audio_service_type;
2145                 codec->block_align= icodec->block_align;
2146                 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2147                     codec->block_align= 0;
2148                 if(codec->codec_id == CODEC_ID_AC3)
2149                     codec->block_align= 0;
2150                 break;
2151             case AVMEDIA_TYPE_VIDEO:
2152                 codec->pix_fmt = icodec->pix_fmt;
2153                 codec->width = icodec->width;
2154                 codec->height = icodec->height;
2155                 codec->has_b_frames = icodec->has_b_frames;
2156                 if (!codec->sample_aspect_ratio.num) {
2157                     codec->sample_aspect_ratio =
2158                     ost->st->sample_aspect_ratio =
2159                         ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2160                         ist->st->codec->sample_aspect_ratio.num ?
2161                         ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2162                 }
2163                 break;
2164             case AVMEDIA_TYPE_SUBTITLE:
2165                 codec->width = icodec->width;
2166                 codec->height = icodec->height;
2167                 break;
2168             case AVMEDIA_TYPE_DATA:
2169                 break;
2170             default:
2171                 abort();
2172             }
2173         } else {
2174             if (!ost->enc)
2175                 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2176             switch(codec->codec_type) {
2177             case AVMEDIA_TYPE_AUDIO:
2178                 ost->fifo= av_fifo_alloc(1024);
2179                 if(!ost->fifo)
2180                     goto fail;
2181                 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2182                 if (!codec->sample_rate) {
2183                     codec->sample_rate = icodec->sample_rate;
2184                     if (icodec->lowres)
2185                         codec->sample_rate >>= icodec->lowres;
2186                 }
2187                 choose_sample_rate(ost->st, ost->enc);
2188                 codec->time_base = (AVRational){1, codec->sample_rate};
2189                 if (!codec->channels)
2190                     codec->channels = icodec->channels;
2191                 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2192                     codec->channel_layout = 0;
2193                 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2194                 icodec->request_channels = codec->channels;
2195                 ist->decoding_needed = 1;
2196                 ost->encoding_needed = 1;
2197                 ost->resample_sample_fmt  = icodec->sample_fmt;
2198                 ost->resample_sample_rate = icodec->sample_rate;
2199                 ost->resample_channels    = icodec->channels;
2200                 break;
2201             case AVMEDIA_TYPE_VIDEO:
2202                 if (codec->pix_fmt == PIX_FMT_NONE)
2203                     codec->pix_fmt = icodec->pix_fmt;
2204                 choose_pixel_fmt(ost->st, ost->enc);
2205
2206                 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2207                     fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2208                     ffmpeg_exit(1);
2209                 }
2210                 ost->video_resample = codec->width   != icodec->width  ||
2211                                       codec->height  != icodec->height ||
2212                                       codec->pix_fmt != icodec->pix_fmt;
2213                 if (ost->video_resample) {
2214 #if !CONFIG_AVFILTER
2215                     avcodec_get_frame_defaults(&ost->pict_tmp);
2216                     if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2217                                          codec->width, codec->height)) {
2218                         fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
2219                         ffmpeg_exit(1);
2220                     }
2221                     ost->img_resample_ctx = sws_getContext(
2222                         icodec->width,
2223                         icodec->height,
2224                             icodec->pix_fmt,
2225                             codec->width,
2226                             codec->height,
2227                             codec->pix_fmt,
2228                             ost->sws_flags, NULL, NULL, NULL);
2229                     if (ost->img_resample_ctx == NULL) {
2230                         fprintf(stderr, "Cannot get resampling context\n");
2231                         ffmpeg_exit(1);
2232                     }
2233 #endif
2234                     codec->bits_per_raw_sample= 0;
2235                 }
2236                 if (!codec->width || !codec->height) {
2237                     codec->width  = icodec->width;
2238                     codec->height = icodec->height;
2239                 }
2240                 ost->resample_height = icodec->height;
2241                 ost->resample_width  = icodec->width;
2242                 ost->resample_pix_fmt= icodec->pix_fmt;
2243                 ost->encoding_needed = 1;
2244                 ist->decoding_needed = 1;
2245
2246                 if (!ost->frame_rate.num)
2247                     ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
2248                 if (ost->enc && ost->enc->supported_framerates && !force_fps) {
2249                     int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2250                     ost->frame_rate = ost->enc->supported_framerates[idx];
2251                 }
2252                 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2253
2254 #if CONFIG_AVFILTER
2255                 if (configure_video_filters(ist, ost)) {
2256                     fprintf(stderr, "Error opening filters!\n");
2257                     exit(1);
2258                 }
2259 #endif
2260                 break;
2261             case AVMEDIA_TYPE_SUBTITLE:
2262                 ost->encoding_needed = 1;
2263                 ist->decoding_needed = 1;
2264                 break;
2265             default:
2266                 abort();
2267                 break;
2268             }
2269             /* two pass mode */
2270             if (ost->encoding_needed &&
2271                 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2272                 char logfilename[1024];
2273                 FILE *f;
2274
2275                 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2276                          pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2277                          i);
2278                 if (codec->flags & CODEC_FLAG_PASS1) {
2279                     f = fopen(logfilename, "wb");
2280                     if (!f) {
2281                         fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2282                         ffmpeg_exit(1);
2283                     }
2284                     ost->logfile = f;
2285                 } else {
2286                     char  *logbuffer;
2287                     size_t logbuffer_size;
2288                     if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2289                         fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2290                         ffmpeg_exit(1);
2291                     }
2292                     codec->stats_in = logbuffer;
2293                 }
2294             }
2295         }
2296         if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2297             int size= codec->width * codec->height;
2298             bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2299         }
2300     }
2301
2302     if (!bit_buffer)
2303         bit_buffer = av_malloc(bit_buffer_size);
2304     if (!bit_buffer) {
2305         fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2306                 bit_buffer_size);
2307         ret = AVERROR(ENOMEM);
2308         goto fail;
2309     }
2310
2311     /* open each encoder */
2312     for(i=0;i<nb_ostreams;i++) {
2313         ost = ost_table[i];
2314         if (ost->encoding_needed) {
2315             AVCodec *codec = ost->enc;
2316             AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2317             if (!codec) {
2318                 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2319                          ost->st->codec->codec_id, ost->file_index, ost->index);
2320                 ret = AVERROR(EINVAL);
2321                 goto dump_format;
2322             }
2323             if (dec->subtitle_header) {
2324                 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2325                 if (!ost->st->codec->subtitle_header) {
2326                     ret = AVERROR(ENOMEM);
2327                     goto dump_format;
2328                 }
2329                 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2330                 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2331             }
2332             if (avcodec_open(ost->st->codec, codec) < 0) {
2333                 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2334                         ost->file_index, ost->index);
2335                 ret = AVERROR(EINVAL);
2336                 goto dump_format;
2337             }
2338             extra_size += ost->st->codec->extradata_size;
2339         }
2340     }
2341
2342     /* open each decoder */
2343     for (i = 0; i < nb_input_streams; i++) {
2344         ist = &input_streams[i];
2345         if (ist->decoding_needed) {
2346             AVCodec *codec = i < nb_input_codecs ? input_codecs[i] : NULL;
2347             if (!codec)
2348                 codec = avcodec_find_decoder(ist->st->codec->codec_id);
2349             if (!codec) {
2350                 snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2351                         ist->st->codec->codec_id, ist->file_index, ist->st->index);
2352                 ret = AVERROR(EINVAL);
2353                 goto dump_format;
2354             }
2355
2356             /* update requested sample format for the decoder based on the
2357                corresponding encoder sample format */
2358             for (j = 0; j < nb_ostreams; j++) {
2359                 ost = ost_table[j];
2360                 if (ost->source_index == i) {
2361                     update_sample_fmt(ist->st->codec, codec, ost->st->codec);
2362                     break;
2363                 }
2364             }
2365
2366             if (avcodec_open(ist->st->codec, codec) < 0) {
2367                 snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2368                         ist->file_index, ist->st->index);
2369                 ret = AVERROR(EINVAL);
2370                 goto dump_format;
2371             }
2372             //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2373             //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2374         }
2375     }
2376
2377     /* init pts */
2378     for (i = 0; i < nb_input_streams; i++) {
2379         AVStream *st;
2380         ist = &input_streams[i];
2381         st= ist->st;
2382         ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2383         ist->next_pts = AV_NOPTS_VALUE;
2384         init_pts_correction(&ist->pts_ctx);
2385         ist->is_start = 1;
2386     }
2387
2388     /* set meta data information from input file if required */
2389     for (i=0;i<nb_meta_data_maps;i++) {
2390         AVFormatContext *files[2];
2391         AVDictionary    **meta[2];
2392         int j;
2393
2394 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
2395         if ((index) < 0 || (index) >= (nb_elems)) {\
2396             snprintf(error, sizeof(error), "Invalid %s index %d while processing metadata maps\n",\
2397                      (desc), (index));\
2398             ret = AVERROR(EINVAL);\
2399             goto dump_format;\
2400         }
2401
2402         int out_file_index = meta_data_maps[i][0].file;
2403         int in_file_index = meta_data_maps[i][1].file;
2404         if (in_file_index < 0 || out_file_index < 0)
2405             continue;
2406         METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2407         METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2408
2409         files[0] = output_files[out_file_index];
2410         files[1] = input_files[in_file_index].ctx;
2411
2412         for (j = 0; j < 2; j++) {
2413             AVMetaDataMap *map = &meta_data_maps[i][j];
2414
2415             switch (map->type) {
2416             case 'g':
2417                 meta[j] = &files[j]->metadata;
2418                 break;
2419             case 's':
2420                 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
2421                 meta[j] = &files[j]->streams[map->index]->metadata;
2422                 break;
2423             case 'c':
2424                 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
2425                 meta[j] = &files[j]->chapters[map->index]->metadata;
2426                 break;
2427             case 'p':
2428                 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
2429                 meta[j] = &files[j]->programs[map->index]->metadata;
2430                 break;
2431             }
2432         }
2433
2434         av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
2435     }
2436
2437     /* copy global metadata by default */
2438     if (metadata_global_autocopy) {
2439
2440         for (i = 0; i < nb_output_files; i++)
2441             av_dict_copy(&output_files[i]->metadata, input_files[0].ctx->metadata,
2442                          AV_DICT_DONT_OVERWRITE);
2443     }
2444
2445     /* copy chapters according to chapter maps */
2446     for (i = 0; i < nb_chapter_maps; i++) {
2447         int infile  = chapter_maps[i].in_file;
2448         int outfile = chapter_maps[i].out_file;
2449
2450         if (infile < 0 || outfile < 0)
2451             continue;
2452         if (infile >= nb_input_files) {
2453             snprintf(error, sizeof(error), "Invalid input file index %d in chapter mapping.\n", infile);
2454             ret = AVERROR(EINVAL);
2455             goto dump_format;
2456         }
2457         if (outfile >= nb_output_files) {
2458             snprintf(error, sizeof(error), "Invalid output file index %d in chapter mapping.\n",outfile);
2459             ret = AVERROR(EINVAL);
2460             goto dump_format;
2461         }
2462         copy_chapters(infile, outfile);
2463     }
2464
2465     /* copy chapters from the first input file that has them*/
2466     if (!nb_chapter_maps)
2467         for (i = 0; i < nb_input_files; i++) {
2468             if (!input_files[i].ctx->nb_chapters)
2469                 continue;
2470
2471             for (j = 0; j < nb_output_files; j++)
2472                 if ((ret = copy_chapters(i, j)) < 0)
2473                     goto dump_format;
2474             break;
2475         }
2476
2477     /* open files and write file headers */
2478     for(i=0;i<nb_output_files;i++) {
2479         os = output_files[i];
2480         if (avformat_write_header(os, &output_opts[i]) < 0) {
2481             snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2482             ret = AVERROR(EINVAL);
2483             goto dump_format;
2484         }
2485         assert_avoptions(output_opts[i]);
2486         if (strcmp(output_files[i]->oformat->name, "rtp")) {
2487             want_sdp = 0;
2488         }
2489     }
2490
2491  dump_format:
2492     /* dump the file output parameters - cannot be done before in case
2493        of stream copy */
2494     for(i=0;i<nb_output_files;i++) {
2495         av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2496     }
2497
2498     /* dump the stream mapping */
2499     if (verbose >= 0) {
2500         fprintf(stderr, "Stream mapping:\n");
2501         for(i=0;i<nb_ostreams;i++) {
2502             ost = ost_table[i];
2503             fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
2504                     input_streams[ost->source_index].file_index,
2505                     input_streams[ost->source_index].st->index,
2506                     ost->file_index,
2507                     ost->index);
2508             if (ost->sync_ist != &input_streams[ost->source_index])
2509                 fprintf(stderr, " [sync #%d.%d]",
2510                         ost->sync_ist->file_index,
2511                         ost->sync_ist->st->index);
2512             fprintf(stderr, "\n");
2513         }
2514     }
2515
2516     if (ret) {
2517         fprintf(stderr, "%s\n", error);
2518         goto fail;
2519     }
2520
2521     if (want_sdp) {
2522         print_sdp(output_files, nb_output_files);
2523     }
2524
2525     if (verbose >= 0)
2526         fprintf(stderr, "Press ctrl-c to stop encoding\n");
2527     term_init();
2528
2529     timer_start = av_gettime();
2530
2531     for(; received_sigterm == 0;) {
2532         int file_index, ist_index;
2533         AVPacket pkt;
2534         double ipts_min;
2535         double opts_min;
2536
2537     redo:
2538         ipts_min= 1e100;
2539         opts_min= 1e100;
2540
2541         /* select the stream that we must read now by looking at the
2542            smallest output pts */
2543         file_index = -1;
2544         for(i=0;i<nb_ostreams;i++) {
2545             double ipts, opts;
2546             ost = ost_table[i];
2547             os = output_files[ost->file_index];
2548             ist = &input_streams[ost->source_index];
2549             if(ist->is_past_recording_time || no_packet[ist->file_index])
2550                 continue;
2551                 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2552             ipts = (double)ist->pts;
2553             if (!input_files[ist->file_index].eof_reached){
2554                 if(ipts < ipts_min) {
2555                     ipts_min = ipts;
2556                     if(input_sync ) file_index = ist->file_index;
2557                 }
2558                 if(opts < opts_min) {
2559                     opts_min = opts;
2560                     if(!input_sync) file_index = ist->file_index;
2561                 }
2562             }
2563             if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2564                 file_index= -1;
2565                 break;
2566             }
2567         }
2568         /* if none, if is finished */
2569         if (file_index < 0) {
2570             if(no_packet_count){
2571                 no_packet_count=0;
2572                 memset(no_packet, 0, sizeof(no_packet));
2573                 usleep(10000);
2574                 continue;
2575             }
2576             break;
2577         }
2578
2579         /* finish if limit size exhausted */
2580         if (limit_filesize != 0 && limit_filesize <= avio_tell(output_files[0]->pb))
2581             break;
2582
2583         /* read a frame from it and output it in the fifo */
2584         is = input_files[file_index].ctx;
2585         ret= av_read_frame(is, &pkt);
2586         if(ret == AVERROR(EAGAIN)){
2587             no_packet[file_index]=1;
2588             no_packet_count++;
2589             continue;
2590         }
2591         if (ret < 0) {
2592             input_files[file_index].eof_reached = 1;
2593             if (opt_shortest)
2594                 break;
2595             else
2596                 continue;
2597         }
2598
2599         no_packet_count=0;
2600         memset(no_packet, 0, sizeof(no_packet));
2601
2602         if (do_pkt_dump) {
2603             av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2604                              is->streams[pkt.stream_index]);
2605         }
2606         /* the following test is needed in case new streams appear
2607            dynamically in stream : we ignore them */
2608         if (pkt.stream_index >= input_files[file_index].ctx->nb_streams)
2609             goto discard_packet;
2610         ist_index = input_files[file_index].ist_index + pkt.stream_index;
2611         ist = &input_streams[ist_index];
2612         if (ist->discard)
2613             goto discard_packet;
2614
2615         if (pkt.dts != AV_NOPTS_VALUE)
2616             pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2617         if (pkt.pts != AV_NOPTS_VALUE)
2618             pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2619
2620         if (pkt.stream_index < nb_input_files_ts_scale[file_index]
2621             && input_files_ts_scale[file_index][pkt.stream_index]){
2622             if(pkt.pts != AV_NOPTS_VALUE)
2623                 pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2624             if(pkt.dts != AV_NOPTS_VALUE)
2625                 pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2626         }
2627
2628 //        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);
2629         if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2630             && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2631             int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2632             int64_t delta= pkt_dts - ist->next_pts;
2633             if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2634                 input_files_ts_offset[ist->file_index]-= delta;
2635                 if (verbose > 2)
2636                     fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2637                 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2638                 if(pkt.pts != AV_NOPTS_VALUE)
2639                     pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2640             }
2641         }
2642
2643         /* finish if recording time exhausted */
2644         if (recording_time != INT64_MAX &&
2645             av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2646             ist->is_past_recording_time = 1;
2647             goto discard_packet;
2648         }
2649
2650         //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2651         if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2652
2653             if (verbose >= 0)
2654                 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2655                         ist->file_index, ist->st->index);
2656             if (exit_on_error)
2657                 ffmpeg_exit(1);
2658             av_free_packet(&pkt);
2659             goto redo;
2660         }
2661
2662     discard_packet:
2663         av_free_packet(&pkt);
2664
2665         /* dump report by using the output first video and audio streams */
2666         print_report(output_files, ost_table, nb_ostreams, 0);
2667     }
2668
2669     /* at the end of stream, we must flush the decoder buffers */
2670     for (i = 0; i < nb_input_streams; i++) {
2671         ist = &input_streams[i];
2672         if (ist->decoding_needed) {
2673             output_packet(ist, i, ost_table, nb_ostreams, NULL);
2674         }
2675     }
2676
2677     term_exit();
2678
2679     /* write the trailer if needed and close file */
2680     for(i=0;i<nb_output_files;i++) {
2681         os = output_files[i];
2682         av_write_trailer(os);
2683     }
2684
2685     /* dump report by using the first video and audio streams */
2686     print_report(output_files, ost_table, nb_ostreams, 1);
2687
2688     /* close each encoder */
2689     for(i=0;i<nb_ostreams;i++) {
2690         ost = ost_table[i];
2691         if (ost->encoding_needed) {
2692             av_freep(&ost->st->codec->stats_in);
2693             avcodec_close(ost->st->codec);
2694         }
2695 #if CONFIG_AVFILTER
2696         avfilter_graph_free(&ost->graph);
2697 #endif
2698     }
2699
2700     /* close each decoder */
2701     for (i = 0; i < nb_input_streams; i++) {
2702         ist = &input_streams[i];
2703         if (ist->decoding_needed) {
2704             avcodec_close(ist->st->codec);
2705         }
2706     }
2707
2708     /* finished ! */
2709     ret = 0;
2710
2711  fail:
2712     av_freep(&bit_buffer);
2713
2714     if (ost_table) {
2715         for(i=0;i<nb_ostreams;i++) {
2716             ost = ost_table[i];
2717             if (ost) {
2718                 if (ost->st->stream_copy)
2719                     av_freep(&ost->st->codec->extradata);
2720                 if (ost->logfile) {
2721                     fclose(ost->logfile);
2722                     ost->logfile = NULL;
2723                 }
2724                 av_fifo_free(ost->fifo); /* works even if fifo is not
2725                                              initialized but set to zero */
2726                 av_freep(&ost->st->codec->subtitle_header);
2727                 av_free(ost->pict_tmp.data[0]);
2728                 av_free(ost->forced_kf_pts);
2729                 if (ost->video_resample)
2730                     sws_freeContext(ost->img_resample_ctx);
2731                 if (ost->resample)
2732                     audio_resample_close(ost->resample);
2733                 if (ost->reformat_ctx)
2734                     av_audio_convert_free(ost->reformat_ctx);
2735                 av_free(ost);
2736             }
2737         }
2738         av_free(ost_table);
2739     }
2740     return ret;
2741 }
2742
2743 static int opt_format(const char *opt, const char *arg)
2744 {
2745     last_asked_format = arg;
2746     return 0;
2747 }
2748
2749 static int opt_video_rc_override_string(const char *opt, const char *arg)
2750 {
2751     video_rc_override_string = arg;
2752     return 0;
2753 }
2754
2755 static int opt_me_threshold(const char *opt, const char *arg)
2756 {
2757     me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2758     return 0;
2759 }
2760
2761 static int opt_verbose(const char *opt, const char *arg)
2762 {
2763     verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2764     return 0;
2765 }
2766
2767 static int opt_frame_rate(const char *opt, const char *arg)
2768 {
2769     if (av_parse_video_rate(&frame_rate, arg) < 0) {
2770         fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2771         ffmpeg_exit(1);
2772     }
2773     return 0;
2774 }
2775
2776 static int opt_bitrate(const char *opt, const char *arg)
2777 {
2778     int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2779
2780     opt_default(opt, arg);
2781
2782     if (av_get_int(avcodec_opts[codec_type], "b", NULL) < 1000)
2783         fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2784
2785     return 0;
2786 }
2787
2788 static int opt_frame_crop(const char *opt, const char *arg)
2789 {
2790     fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2791     return AVERROR(EINVAL);
2792 }
2793
2794 static int opt_frame_size(const char *opt, const char *arg)
2795 {
2796     if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2797         fprintf(stderr, "Incorrect frame size\n");
2798         return AVERROR(EINVAL);
2799     }
2800     return 0;
2801 }
2802
2803 static int opt_pad(const char *opt, const char *arg) {
2804     fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2805     return -1;
2806 }
2807
2808 static int opt_frame_pix_fmt(const char *opt, const char *arg)
2809 {
2810     if (strcmp(arg, "list")) {
2811         frame_pix_fmt = av_get_pix_fmt(arg);
2812         if (frame_pix_fmt == PIX_FMT_NONE) {
2813             fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2814             return AVERROR(EINVAL);
2815         }
2816     } else {
2817         show_pix_fmts();
2818         ffmpeg_exit(0);
2819     }
2820     return 0;
2821 }
2822
2823 static int opt_frame_aspect_ratio(const char *opt, const char *arg)
2824 {
2825     int x = 0, y = 0;
2826     double ar = 0;
2827     const char *p;
2828     char *end;
2829
2830     p = strchr(arg, ':');
2831     if (p) {
2832         x = strtol(arg, &end, 10);
2833         if (end == p)
2834             y = strtol(end+1, &end, 10);
2835         if (x > 0 && y > 0)
2836             ar = (double)x / (double)y;
2837     } else
2838         ar = strtod(arg, NULL);
2839
2840     if (!ar) {
2841         fprintf(stderr, "Incorrect aspect ratio specification.\n");
2842         return AVERROR(EINVAL);
2843     }
2844     frame_aspect_ratio = ar;
2845     return 0;
2846 }
2847
2848 static int opt_metadata(const char *opt, const char *arg)
2849 {
2850     char *mid= strchr(arg, '=');
2851
2852     if(!mid){
2853         fprintf(stderr, "Missing =\n");
2854         ffmpeg_exit(1);
2855     }
2856     *mid++= 0;
2857
2858     av_dict_set(&metadata, arg, mid, 0);
2859
2860     return 0;
2861 }
2862
2863 static int opt_qscale(const char *opt, const char *arg)
2864 {
2865     video_qscale = parse_number_or_die(opt, arg, OPT_FLOAT, 0, 255);
2866     if (video_qscale == 0) {
2867         fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2868         return AVERROR(EINVAL);
2869     }
2870     return 0;
2871 }
2872
2873 static int opt_top_field_first(const char *opt, const char *arg)
2874 {
2875     top_field_first = parse_number_or_die(opt, arg, OPT_INT, 0, 1);
2876     return 0;
2877 }
2878
2879 static int opt_thread_count(const char *opt, const char *arg)
2880 {
2881     thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2882 #if !HAVE_THREADS
2883     if (verbose >= 0)
2884         fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2885 #endif
2886     return 0;
2887 }
2888
2889 static int opt_audio_sample_fmt(const char *opt, const char *arg)
2890 {
2891     if (strcmp(arg, "list")) {
2892         audio_sample_fmt = av_get_sample_fmt(arg);
2893         if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2894             av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2895             return AVERROR(EINVAL);
2896         }
2897     } else {
2898         int i;
2899         char fmt_str[128];
2900         for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
2901             printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
2902         ffmpeg_exit(0);
2903     }
2904     return 0;
2905 }
2906
2907 static int opt_audio_rate(const char *opt, const char *arg)
2908 {
2909     audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2910     return 0;
2911 }
2912
2913 static int opt_audio_channels(const char *opt, const char *arg)
2914 {
2915     audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2916     return 0;
2917 }
2918
2919 static int opt_video_channel(const char *opt, const char *arg)
2920 {
2921     av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
2922     opt_default("channel", arg);
2923     return 0;
2924 }
2925
2926 static int opt_video_standard(const char *opt, const char *arg)
2927 {
2928     av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
2929     opt_default("standard", arg);
2930     return 0;
2931 }
2932
2933 static int opt_codec(int *pstream_copy, char **pcodec_name,
2934                       int codec_type, const char *arg)
2935 {
2936     av_freep(pcodec_name);
2937     if (!strcmp(arg, "copy")) {
2938         *pstream_copy = 1;
2939     } else {
2940         *pcodec_name = av_strdup(arg);
2941     }
2942     return 0;
2943 }
2944
2945 static int opt_audio_codec(const char *opt, const char *arg)
2946 {
2947     return opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2948 }
2949
2950 static int opt_video_codec(const char *opt, const char *arg)
2951 {
2952     return opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2953 }
2954
2955 static int opt_subtitle_codec(const char *opt, const char *arg)
2956 {
2957     return opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2958 }
2959
2960 static int opt_data_codec(const char *opt, const char *arg)
2961 {
2962     return opt_codec(&data_stream_copy, &data_codec_name, AVMEDIA_TYPE_DATA, arg);
2963 }
2964
2965 static int opt_codec_tag(const char *opt, const char *arg)
2966 {
2967     char *tail;
2968     uint32_t *codec_tag;
2969
2970     codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2971                 !strcmp(opt, "vtag") ? &video_codec_tag :
2972                 !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2973     if (!codec_tag)
2974         return -1;
2975
2976     *codec_tag = strtol(arg, &tail, 0);
2977     if (!tail || *tail)
2978         *codec_tag = AV_RL32(arg);
2979
2980     return 0;
2981 }
2982
2983 static int opt_map(const char *opt, const char *arg)
2984 {
2985     AVStreamMap *m;
2986     char *p;
2987
2988     stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
2989     m = &stream_maps[nb_stream_maps-1];
2990
2991     m->file_index = strtol(arg, &p, 0);
2992     if (*p)
2993         p++;
2994
2995     m->stream_index = strtol(p, &p, 0);
2996     if (*p) {
2997         p++;
2998         m->sync_file_index = strtol(p, &p, 0);
2999         if (*p)
3000             p++;
3001         m->sync_stream_index = strtol(p, &p, 0);
3002     } else {
3003         m->sync_file_index = m->file_index;
3004         m->sync_stream_index = m->stream_index;
3005     }
3006     return 0;
3007 }
3008
3009 static void parse_meta_type(char *arg, char *type, int *index, char **endptr)
3010 {
3011     *endptr = arg;
3012     if (*arg == ',') {
3013         *type = *(++arg);
3014         switch (*arg) {
3015         case 'g':
3016             break;
3017         case 's':
3018         case 'c':
3019         case 'p':
3020             *index = strtol(++arg, endptr, 0);
3021             break;
3022         default:
3023             fprintf(stderr, "Invalid metadata type %c.\n", *arg);
3024             ffmpeg_exit(1);
3025         }
3026     } else
3027         *type = 'g';
3028 }
3029
3030 static int opt_map_metadata(const char *opt, const char *arg)
3031 {
3032     AVMetaDataMap *m, *m1;
3033     char *p;
3034
3035     meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
3036                                 &nb_meta_data_maps, nb_meta_data_maps + 1);
3037
3038     m = &meta_data_maps[nb_meta_data_maps - 1][0];
3039     m->file = strtol(arg, &p, 0);
3040     parse_meta_type(p, &m->type, &m->index, &p);
3041     if (*p)
3042         p++;
3043
3044     m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
3045     m1->file = strtol(p, &p, 0);
3046     parse_meta_type(p, &m1->type, &m1->index, &p);
3047
3048     if (m->type == 'g' || m1->type == 'g')
3049         metadata_global_autocopy = 0;
3050     if (m->type == 's' || m1->type == 's')
3051         metadata_streams_autocopy = 0;
3052     if (m->type == 'c' || m1->type == 'c')
3053         metadata_chapters_autocopy = 0;
3054
3055     return 0;
3056 }
3057
3058 static int opt_map_meta_data(const char *opt, const char *arg)
3059 {
3060     fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "
3061                     "Use -map_metadata instead.\n");
3062     return opt_map_metadata(opt, arg);
3063 }
3064
3065 static int opt_map_chapters(const char *opt, const char *arg)
3066 {
3067     AVChapterMap *c;
3068     char *p;
3069
3070     chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
3071                               nb_chapter_maps + 1);
3072     c = &chapter_maps[nb_chapter_maps - 1];
3073     c->out_file = strtol(arg, &p, 0);
3074     if (*p)
3075         p++;
3076
3077     c->in_file = strtol(p, &p, 0);
3078     return 0;
3079 }
3080
3081 static int opt_input_ts_scale(const char *opt, const char *arg)
3082 {
3083     unsigned int stream;
3084     double scale;
3085     char *p;
3086
3087     stream = strtol(arg, &p, 0);
3088     if (*p)
3089         p++;
3090     scale= strtod(p, &p);
3091
3092     if(stream >= MAX_STREAMS)
3093         ffmpeg_exit(1);
3094
3095     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);
3096     input_files_ts_scale[nb_input_files][stream]= scale;
3097     return 0;
3098 }
3099
3100 static int opt_recording_time(const char *opt, const char *arg)
3101 {
3102     recording_time = parse_time_or_die(opt, arg, 1);
3103     return 0;
3104 }
3105
3106 static int opt_start_time(const char *opt, const char *arg)
3107 {
3108     start_time = parse_time_or_die(opt, arg, 1);
3109     return 0;
3110 }
3111
3112 static int opt_recording_timestamp(const char *opt, const char *arg)
3113 {
3114     recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
3115     return 0;
3116 }
3117
3118 static int opt_input_ts_offset(const char *opt, const char *arg)
3119 {
3120     input_ts_offset = parse_time_or_die(opt, arg, 1);
3121     return 0;
3122 }
3123
3124 static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3125 {
3126     const char *codec_string = encoder ? "encoder" : "decoder";
3127     AVCodec *codec;
3128
3129     if(!name)
3130         return CODEC_ID_NONE;
3131     codec = encoder ?
3132         avcodec_find_encoder_by_name(name) :
3133         avcodec_find_decoder_by_name(name);
3134     if(!codec) {
3135         fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3136         ffmpeg_exit(1);
3137     }
3138     if(codec->type != type) {
3139         fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3140         ffmpeg_exit(1);
3141     }
3142     if(codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
3143        strict > FF_COMPLIANCE_EXPERIMENTAL) {
3144         fprintf(stderr, "%s '%s' is experimental and might produce bad "
3145                 "results.\nAdd '-strict experimental' if you want to use it.\n",
3146                 codec_string, codec->name);
3147         codec = encoder ?
3148             avcodec_find_encoder(codec->id) :
3149             avcodec_find_decoder(codec->id);
3150         if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
3151             fprintf(stderr, "Or use the non experimental %s '%s'.\n",
3152                     codec_string, codec->name);
3153         ffmpeg_exit(1);
3154     }
3155     return codec->id;
3156 }
3157
3158 static int opt_input_file(const char *opt, const char *filename)
3159 {
3160     AVFormatContext *ic;
3161     AVInputFormat *file_iformat = NULL;
3162     int err, i, ret, rfps, rfps_base;
3163     int64_t timestamp;
3164     uint8_t buf[128];
3165
3166     if (last_asked_format) {
3167         if (!(file_iformat = av_find_input_format(last_asked_format))) {
3168             fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3169             ffmpeg_exit(1);
3170         }
3171         last_asked_format = NULL;
3172     }
3173
3174     if (!strcmp(filename, "-"))
3175         filename = "pipe:";
3176
3177     using_stdin |= !strncmp(filename, "pipe:", 5) ||
3178                     !strcmp(filename, "/dev/stdin");
3179
3180     /* get default parameters from command line */
3181     ic = avformat_alloc_context();
3182     if (!ic) {
3183         print_error(filename, AVERROR(ENOMEM));
3184         ffmpeg_exit(1);
3185     }
3186     if (audio_sample_rate) {
3187         snprintf(buf, sizeof(buf), "%d", audio_sample_rate);
3188         av_dict_set(&format_opts, "sample_rate", buf, 0);
3189     }
3190     if (audio_channels) {
3191         snprintf(buf, sizeof(buf), "%d", audio_channels);
3192         av_dict_set(&format_opts, "channels", buf, 0);
3193     }
3194     if (frame_rate.num) {
3195         snprintf(buf, sizeof(buf), "%d/%d", frame_rate.num, frame_rate.den);
3196         av_dict_set(&format_opts, "framerate", buf, 0);
3197     }
3198     if (frame_width && frame_height) {
3199         snprintf(buf, sizeof(buf), "%dx%d", frame_width, frame_height);
3200         av_dict_set(&format_opts, "video_size", buf, 0);
3201     }
3202     if (frame_pix_fmt != PIX_FMT_NONE)
3203         av_dict_set(&format_opts, "pixel_format", av_get_pix_fmt_name(frame_pix_fmt), 0);
3204
3205     ic->video_codec_id   =
3206         find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0,
3207                           avcodec_opts[AVMEDIA_TYPE_VIDEO   ]->strict_std_compliance);
3208     ic->audio_codec_id   =
3209         find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0,
3210                           avcodec_opts[AVMEDIA_TYPE_AUDIO   ]->strict_std_compliance);
3211     ic->subtitle_codec_id=
3212         find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
3213                           avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3214     ic->flags |= AVFMT_FLAG_NONBLOCK;
3215
3216     /* open the input file with generic libav function */
3217     err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
3218     if (err < 0) {
3219         print_error(filename, err);
3220         ffmpeg_exit(1);
3221     }
3222     assert_avoptions(format_opts);
3223
3224     if(opt_programid) {
3225         int i, j;
3226         int found=0;
3227         for(i=0; i<ic->nb_streams; i++){
3228             ic->streams[i]->discard= AVDISCARD_ALL;
3229         }
3230         for(i=0; i<ic->nb_programs; i++){
3231             AVProgram *p= ic->programs[i];
3232             if(p->id != opt_programid){
3233                 p->discard = AVDISCARD_ALL;
3234             }else{
3235                 found=1;
3236                 for(j=0; j<p->nb_stream_indexes; j++){
3237                     ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3238                 }
3239             }
3240         }
3241         if(!found){
3242             fprintf(stderr, "Specified program id not found\n");
3243             ffmpeg_exit(1);
3244         }
3245         opt_programid=0;
3246     }
3247
3248     ic->loop_input = loop_input;
3249
3250     /* Set AVCodecContext options so they will be seen by av_find_stream_info() */
3251     for (i = 0; i < ic->nb_streams; i++) {
3252         AVCodecContext *dec = ic->streams[i]->codec;
3253         switch (dec->codec_type) {
3254         case AVMEDIA_TYPE_AUDIO:
3255             set_context_opts(dec, avcodec_opts[AVMEDIA_TYPE_AUDIO],
3256                              AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM,
3257                              NULL);
3258             break;
3259         case AVMEDIA_TYPE_VIDEO:
3260             set_context_opts(dec, avcodec_opts[AVMEDIA_TYPE_VIDEO],
3261                              AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM,
3262                              NULL);
3263             break;
3264         }
3265     }
3266
3267     /* If not enough info to get the stream parameters, we decode the
3268        first frames to get it. (used in mpeg case for example) */
3269     ret = av_find_stream_info(ic);
3270     if (ret < 0 && verbose >= 0) {
3271         fprintf(stderr, "%s: could not find codec parameters\n", filename);
3272         av_close_input_file(ic);
3273         ffmpeg_exit(1);
3274     }
3275
3276     timestamp = start_time;
3277     /* add the stream start time */
3278     if (ic->start_time != AV_NOPTS_VALUE)
3279         timestamp += ic->start_time;
3280
3281     /* if seeking requested, we execute it */
3282     if (start_time != 0) {
3283         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3284         if (ret < 0) {
3285             fprintf(stderr, "%s: could not seek to position %0.3f\n",
3286                     filename, (double)timestamp / AV_TIME_BASE);
3287         }
3288         /* reset seek info */
3289         start_time = 0;
3290     }
3291
3292     /* update the current parameters so that they match the one of the input stream */
3293     for(i=0;i<ic->nb_streams;i++) {
3294         AVStream *st = ic->streams[i];
3295         AVCodecContext *dec = st->codec;
3296         AVInputStream *ist;
3297
3298         dec->thread_count = thread_count;
3299         input_codecs = grow_array(input_codecs, sizeof(*input_codecs), &nb_input_codecs, nb_input_codecs + 1);
3300
3301         input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
3302         ist = &input_streams[nb_input_streams - 1];
3303         ist->st = st;
3304         ist->file_index = nb_input_files;
3305         ist->discard = 1;
3306
3307         switch (dec->codec_type) {
3308         case AVMEDIA_TYPE_AUDIO:
3309             input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(audio_codec_name);
3310             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]);
3311             channel_layout    = dec->channel_layout;
3312             audio_sample_fmt  = dec->sample_fmt;
3313             if(audio_disable)
3314                 st->discard= AVDISCARD_ALL;
3315             break;
3316         case AVMEDIA_TYPE_VIDEO:
3317             input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(video_codec_name);
3318             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]);
3319             rfps      = ic->streams[i]->r_frame_rate.num;
3320             rfps_base = ic->streams[i]->r_frame_rate.den;
3321             if (dec->lowres) {
3322                 dec->flags |= CODEC_FLAG_EMU_EDGE;
3323                 dec->height >>= dec->lowres;
3324                 dec->width  >>= dec->lowres;
3325             }
3326             if(me_threshold)
3327                 dec->debug |= FF_DEBUG_MV;
3328
3329             if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3330
3331                 if (verbose >= 0)
3332                     fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3333                             i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3334
3335                     (float)rfps / rfps_base, rfps, rfps_base);
3336             }
3337
3338             if(video_disable)
3339                 st->discard= AVDISCARD_ALL;
3340             else if(video_discard)
3341                 st->discard= video_discard;
3342             break;
3343         case AVMEDIA_TYPE_DATA:
3344             break;
3345         case AVMEDIA_TYPE_SUBTITLE:
3346             input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(subtitle_codec_name);
3347             if(subtitle_disable)
3348                 st->discard = AVDISCARD_ALL;
3349             break;
3350         case AVMEDIA_TYPE_ATTACHMENT:
3351         case AVMEDIA_TYPE_UNKNOWN:
3352             break;
3353         default:
3354             abort();
3355         }
3356     }
3357
3358     input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3359     /* dump the file content */
3360     if (verbose >= 0)
3361         av_dump_format(ic, nb_input_files, filename, 0);
3362
3363     input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3364     input_files[nb_input_files - 1].ctx        = ic;
3365     input_files[nb_input_files - 1].ist_index  = nb_input_streams - ic->nb_streams;
3366
3367     frame_rate    = (AVRational){0, 0};
3368     frame_pix_fmt = PIX_FMT_NONE;
3369     frame_height = 0;
3370     frame_width  = 0;
3371     audio_sample_rate = 0;
3372     audio_channels    = 0;
3373
3374     av_freep(&video_codec_name);
3375     av_freep(&audio_codec_name);
3376     av_freep(&subtitle_codec_name);
3377     uninit_opts();
3378     init_opts();
3379     return 0;
3380 }
3381
3382 static void check_inputs(int *has_video_ptr,
3383                          int *has_audio_ptr,
3384                          int *has_subtitle_ptr,
3385                          int *has_data_ptr)
3386 {
3387     int has_video, has_audio, has_subtitle, has_data, i, j;
3388     AVFormatContext *ic;
3389
3390     has_video = 0;
3391     has_audio = 0;
3392     has_subtitle = 0;
3393     has_data = 0;
3394
3395     for(j=0;j<nb_input_files;j++) {
3396         ic = input_files[j].ctx;
3397         for(i=0;i<ic->nb_streams;i++) {
3398             AVCodecContext *enc = ic->streams[i]->codec;
3399             switch(enc->codec_type) {
3400             case AVMEDIA_TYPE_AUDIO:
3401                 has_audio = 1;
3402                 break;
3403             case AVMEDIA_TYPE_VIDEO:
3404                 has_video = 1;
3405                 break;
3406             case AVMEDIA_TYPE_SUBTITLE:
3407                 has_subtitle = 1;
3408                 break;
3409             case AVMEDIA_TYPE_DATA:
3410             case AVMEDIA_TYPE_ATTACHMENT:
3411             case AVMEDIA_TYPE_UNKNOWN:
3412                 has_data = 1;
3413                 break;
3414             default:
3415                 abort();
3416             }
3417         }
3418     }
3419     *has_video_ptr = has_video;
3420     *has_audio_ptr = has_audio;
3421     *has_subtitle_ptr = has_subtitle;
3422     *has_data_ptr = has_data;
3423 }
3424
3425 static void new_video_stream(AVFormatContext *oc, int file_idx)
3426 {
3427     AVStream *st;
3428     AVOutputStream *ost;
3429     AVCodecContext *video_enc;
3430     enum CodecID codec_id = CODEC_ID_NONE;
3431     AVCodec *codec= NULL;
3432
3433     st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3434     if (!st) {
3435         fprintf(stderr, "Could not alloc stream\n");
3436         ffmpeg_exit(1);
3437     }
3438     ost = new_output_stream(oc, file_idx);
3439
3440     if(!video_stream_copy){
3441         if (video_codec_name) {
3442             codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
3443                                          avcodec_opts[AVMEDIA_TYPE_VIDEO]->strict_std_compliance);
3444             codec = avcodec_find_encoder_by_name(video_codec_name);
3445             ost->enc = codec;
3446         } else {
3447             codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3448             codec = avcodec_find_encoder(codec_id);
3449         }
3450
3451         ost->frame_aspect_ratio = frame_aspect_ratio;
3452         frame_aspect_ratio = 0;
3453 #if CONFIG_AVFILTER
3454         ost->avfilter= vfilters;
3455         vfilters = NULL;
3456 #endif
3457     }
3458
3459     avcodec_get_context_defaults3(st->codec, codec);
3460     ost->bitstream_filters = video_bitstream_filters;
3461     video_bitstream_filters= NULL;
3462
3463     st->codec->thread_count= thread_count;
3464
3465     video_enc = st->codec;
3466
3467     if(video_codec_tag)
3468         video_enc->codec_tag= video_codec_tag;
3469
3470     if(oc->oformat->flags & AVFMT_GLOBALHEADER) {
3471         video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3472         avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3473     }
3474
3475     if (video_stream_copy) {
3476         st->stream_copy = 1;
3477         video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3478         video_enc->sample_aspect_ratio =
3479         st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3480     } else {
3481         const char *p;
3482         int i;
3483
3484         if (frame_rate.num)
3485             ost->frame_rate = frame_rate;
3486         video_enc->codec_id = codec_id;
3487         set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3488
3489         video_enc->width = frame_width;
3490         video_enc->height = frame_height;
3491         video_enc->pix_fmt = frame_pix_fmt;
3492         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3493
3494         if (intra_only)
3495             video_enc->gop_size = 0;
3496         if (video_qscale || same_quality) {
3497             video_enc->flags |= CODEC_FLAG_QSCALE;
3498             video_enc->global_quality=
3499                 st->quality = FF_QP2LAMBDA * video_qscale;
3500         }
3501
3502         if(intra_matrix)
3503             video_enc->intra_matrix = intra_matrix;
3504         if(inter_matrix)
3505             video_enc->inter_matrix = inter_matrix;
3506
3507         p= video_rc_override_string;
3508         for(i=0; p; i++){
3509             int start, end, q;
3510             int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3511             if(e!=3){
3512                 fprintf(stderr, "error parsing rc_override\n");
3513                 ffmpeg_exit(1);
3514             }
3515             video_enc->rc_override=
3516                 av_realloc(video_enc->rc_override,
3517                            sizeof(RcOverride)*(i+1));
3518             video_enc->rc_override[i].start_frame= start;
3519             video_enc->rc_override[i].end_frame  = end;
3520             if(q>0){
3521                 video_enc->rc_override[i].qscale= q;
3522                 video_enc->rc_override[i].quality_factor= 1.0;
3523             }
3524             else{
3525                 video_enc->rc_override[i].qscale= 0;
3526                 video_enc->rc_override[i].quality_factor= -q/100.0;
3527             }
3528             p= strchr(p, '/');
3529             if(p) p++;
3530         }
3531         video_enc->rc_override_count=i;
3532         if (!video_enc->rc_initial_buffer_occupancy)
3533             video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3534         video_enc->me_threshold= me_threshold;
3535         video_enc->intra_dc_precision= intra_dc_precision - 8;
3536
3537         if (do_psnr)
3538             video_enc->flags|= CODEC_FLAG_PSNR;
3539
3540         /* two pass mode */
3541         if (do_pass) {
3542             if (do_pass == 1) {
3543                 video_enc->flags |= CODEC_FLAG_PASS1;
3544             } else {
3545                 video_enc->flags |= CODEC_FLAG_PASS2;
3546             }
3547         }
3548
3549         if (forced_key_frames)
3550             parse_forced_key_frames(forced_key_frames, ost, video_enc);
3551     }
3552     if (video_language) {
3553         av_dict_set(&st->metadata, "language", video_language, 0);
3554         av_freep(&video_language);
3555     }
3556
3557     /* reset some key parameters */
3558     video_disable = 0;
3559     av_freep(&video_codec_name);
3560     av_freep(&forced_key_frames);
3561     video_stream_copy = 0;
3562     frame_pix_fmt = PIX_FMT_NONE;
3563 }
3564
3565 static void new_audio_stream(AVFormatContext *oc, int file_idx)
3566 {
3567     AVStream *st;
3568     AVOutputStream *ost;
3569     AVCodec *codec= NULL;
3570     AVCodecContext *audio_enc;
3571     enum CodecID codec_id = CODEC_ID_NONE;
3572
3573     st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3574     if (!st) {
3575         fprintf(stderr, "Could not alloc stream\n");
3576         ffmpeg_exit(1);
3577     }
3578     ost = new_output_stream(oc, file_idx);
3579
3580     if(!audio_stream_copy){
3581         if (audio_codec_name) {
3582             codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
3583                                          avcodec_opts[AVMEDIA_TYPE_AUDIO]->strict_std_compliance);
3584             codec = avcodec_find_encoder_by_name(audio_codec_name);
3585             ost->enc = codec;
3586         } else {
3587             codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3588             codec = avcodec_find_encoder(codec_id);
3589         }
3590     }
3591
3592     avcodec_get_context_defaults3(st->codec, codec);
3593
3594     ost->bitstream_filters = audio_bitstream_filters;
3595     audio_bitstream_filters= NULL;
3596
3597     st->codec->thread_count= thread_count;
3598
3599     audio_enc = st->codec;
3600     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3601
3602     if(audio_codec_tag)
3603         audio_enc->codec_tag= audio_codec_tag;
3604
3605     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3606         audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3607         avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3608     }
3609     if (audio_stream_copy) {
3610         st->stream_copy = 1;
3611     } else {
3612         audio_enc->codec_id = codec_id;
3613         set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3614
3615         if (audio_qscale > QSCALE_NONE) {
3616             audio_enc->flags |= CODEC_FLAG_QSCALE;
3617             audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3618         }
3619         if (audio_channels)
3620             audio_enc->channels = audio_channels;
3621         audio_enc->sample_fmt = audio_sample_fmt;
3622         if (audio_sample_rate)
3623             audio_enc->sample_rate = audio_sample_rate;
3624         audio_enc->channel_layout = channel_layout;
3625         choose_sample_fmt(st, codec);
3626     }
3627     if (audio_language) {
3628         av_dict_set(&st->metadata, "language", audio_language, 0);
3629         av_freep(&audio_language);
3630     }
3631
3632     /* reset some key parameters */
3633     audio_disable = 0;
3634     av_freep(&audio_codec_name);
3635     audio_stream_copy = 0;
3636 }
3637
3638 static void new_data_stream(AVFormatContext *oc, int file_idx)
3639 {
3640     AVStream *st;
3641     AVCodec *codec=NULL;
3642     AVCodecContext *data_enc;
3643
3644     st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3645     if (!st) {
3646         fprintf(stderr, "Could not alloc stream\n");
3647         ffmpeg_exit(1);
3648     }
3649     new_output_stream(oc, file_idx);
3650     data_enc = st->codec;
3651     if (!data_stream_copy) {
3652         fprintf(stderr, "Data stream encoding not supported yet (only streamcopy)\n");
3653         ffmpeg_exit(1);
3654     }
3655     avcodec_get_context_defaults3(st->codec, codec);
3656
3657     data_enc->codec_type = AVMEDIA_TYPE_DATA;
3658
3659     if (data_codec_tag)
3660         data_enc->codec_tag= data_codec_tag;
3661
3662     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3663         data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3664         avcodec_opts[AVMEDIA_TYPE_DATA]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3665     }
3666     if (data_stream_copy) {
3667         st->stream_copy = 1;
3668     }
3669
3670     data_disable = 0;
3671     av_freep(&data_codec_name);
3672     data_stream_copy = 0;
3673 }
3674
3675 static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3676 {
3677     AVStream *st;
3678     AVOutputStream *ost;
3679     AVCodec *codec=NULL;
3680     AVCodecContext *subtitle_enc;
3681     enum CodecID codec_id = CODEC_ID_NONE;
3682
3683     st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3684     if (!st) {
3685         fprintf(stderr, "Could not alloc stream\n");
3686         ffmpeg_exit(1);
3687     }
3688     ost = new_output_stream(oc, file_idx);
3689     subtitle_enc = st->codec;
3690     if(!subtitle_stream_copy){
3691         if (subtitle_codec_name) {
3692             codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,
3693                                          avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3694             codec = avcodec_find_encoder_by_name(subtitle_codec_name);
3695             ost->enc = codec;
3696         } else {
3697             codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_SUBTITLE);
3698             codec = avcodec_find_encoder(codec_id);
3699         }
3700     }
3701     avcodec_get_context_defaults3(st->codec, codec);
3702
3703     ost->bitstream_filters = subtitle_bitstream_filters;
3704     subtitle_bitstream_filters= NULL;
3705
3706     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3707
3708     if(subtitle_codec_tag)
3709         subtitle_enc->codec_tag= subtitle_codec_tag;
3710
3711     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3712         subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3713         avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3714     }
3715     if (subtitle_stream_copy) {
3716         st->stream_copy = 1;
3717     } else {
3718         subtitle_enc->codec_id = codec_id;
3719         set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3720     }
3721
3722     if (subtitle_language) {
3723         av_dict_set(&st->metadata, "language", subtitle_language, 0);
3724         av_freep(&subtitle_language);
3725     }
3726
3727     subtitle_disable = 0;
3728     av_freep(&subtitle_codec_name);
3729     subtitle_stream_copy = 0;
3730 }
3731
3732 static int opt_new_stream(const char *opt, const char *arg)
3733 {
3734     AVFormatContext *oc;
3735     int file_idx = nb_output_files - 1;
3736     if (nb_output_files <= 0) {
3737         fprintf(stderr, "At least one output file must be specified\n");
3738         ffmpeg_exit(1);
3739     }
3740     oc = output_files[file_idx];
3741
3742     if      (!strcmp(opt, "newvideo"   )) new_video_stream   (oc, file_idx);
3743     else if (!strcmp(opt, "newaudio"   )) new_audio_stream   (oc, file_idx);
3744     else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3745     else if (!strcmp(opt, "newdata"    )) new_data_stream    (oc, file_idx);
3746     else av_assert0(0);
3747     return 0;
3748 }
3749
3750 /* arg format is "output-stream-index:streamid-value". */
3751 static int opt_streamid(const char *opt, const char *arg)
3752 {
3753     int idx;
3754     char *p;
3755     char idx_str[16];
3756
3757     av_strlcpy(idx_str, arg, sizeof(idx_str));
3758     p = strchr(idx_str, ':');
3759     if (!p) {
3760         fprintf(stderr,
3761                 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3762                 arg, opt);
3763         ffmpeg_exit(1);
3764     }
3765     *p++ = '\0';
3766     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3767     streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3768     streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3769     return 0;
3770 }
3771
3772 static void opt_output_file(const char *filename)
3773 {
3774     AVFormatContext *oc;
3775     int err, use_video, use_audio, use_subtitle, use_data;
3776     int input_has_video, input_has_audio, input_has_subtitle, input_has_data;
3777     AVOutputFormat *file_oformat;
3778
3779     if (!strcmp(filename, "-"))
3780         filename = "pipe:";
3781
3782     oc = avformat_alloc_context();
3783     if (!oc) {
3784         print_error(filename, AVERROR(ENOMEM));
3785         ffmpeg_exit(1);
3786     }
3787
3788     if (last_asked_format) {
3789         file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3790         if (!file_oformat) {
3791             fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3792             ffmpeg_exit(1);
3793         }
3794         last_asked_format = NULL;
3795     } else {
3796         file_oformat = av_guess_format(NULL, filename, NULL);
3797         if (!file_oformat) {
3798             fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3799                     filename);
3800             ffmpeg_exit(1);
3801         }
3802     }
3803
3804     oc->oformat = file_oformat;
3805     av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3806
3807     if (!strcmp(file_oformat->name, "ffm") &&
3808         av_strstart(filename, "http:", NULL)) {
3809         /* special case for files sent to ffserver: we get the stream
3810            parameters from ffserver */
3811         int err = read_ffserver_streams(oc, filename);
3812         if (err < 0) {
3813             print_error(filename, err);
3814             ffmpeg_exit(1);
3815         }
3816     } else {
3817         use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3818         use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3819         use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3820         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 */
3821
3822         /* disable if no corresponding type found and at least one
3823            input file */
3824         if (nb_input_files > 0) {
3825             check_inputs(&input_has_video,
3826                          &input_has_audio,
3827                          &input_has_subtitle,
3828                          &input_has_data);
3829
3830             if (!input_has_video)
3831                 use_video = 0;
3832             if (!input_has_audio)
3833                 use_audio = 0;
3834             if (!input_has_subtitle)
3835                 use_subtitle = 0;
3836             if (!input_has_data)
3837                 use_data = 0;
3838         }
3839
3840         /* manual disable */
3841         if (audio_disable)    use_audio    = 0;
3842         if (video_disable)    use_video    = 0;
3843         if (subtitle_disable) use_subtitle = 0;
3844         if (data_disable)     use_data     = 0;
3845
3846         if (use_video)    new_video_stream(oc, nb_output_files);
3847         if (use_audio)    new_audio_stream(oc, nb_output_files);
3848         if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3849         if (use_data)     new_data_stream(oc, nb_output_files);
3850
3851         oc->timestamp = recording_timestamp;
3852
3853         av_dict_copy(&oc->metadata, metadata, 0);
3854         av_dict_free(&metadata);
3855     }
3856
3857     av_dict_copy(&output_opts[nb_output_files], format_opts, 0);
3858     output_files[nb_output_files++] = oc;
3859
3860     /* check filename in case of an image number is expected */
3861     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3862         if (!av_filename_number_test(oc->filename)) {
3863             print_error(oc->filename, AVERROR(EINVAL));
3864             ffmpeg_exit(1);
3865         }
3866     }
3867
3868     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3869         /* test if it already exists to avoid loosing precious files */
3870         if (!file_overwrite &&
3871             (strchr(filename, ':') == NULL ||
3872              filename[1] == ':' ||
3873              av_strstart(filename, "file:", NULL))) {
3874             if (avio_check(filename, 0) == 0) {
3875                 if (!using_stdin) {
3876                     fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3877                     fflush(stderr);
3878                     if (!read_yesno()) {
3879                         fprintf(stderr, "Not overwriting - exiting\n");
3880                         ffmpeg_exit(1);
3881                     }
3882                 }
3883                 else {
3884                     fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3885                     ffmpeg_exit(1);
3886                 }
3887             }
3888         }
3889
3890         /* open the file */
3891         if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3892             print_error(filename, err);
3893             ffmpeg_exit(1);
3894         }
3895     }
3896
3897     oc->preload= (int)(mux_preload*AV_TIME_BASE);
3898     oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3899     oc->loop_output = loop_output;
3900     oc->flags |= AVFMT_FLAG_NONBLOCK;
3901
3902     frame_rate    = (AVRational){0, 0};
3903     frame_width   = 0;
3904     frame_height  = 0;
3905     audio_sample_rate = 0;
3906     audio_channels    = 0;
3907
3908     av_freep(&forced_key_frames);
3909     uninit_opts();
3910     init_opts();
3911 }
3912
3913 /* same option as mencoder */
3914 static int opt_pass(const char *opt, const char *arg)
3915 {
3916     do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3917     return 0;
3918 }
3919
3920 static int64_t getutime(void)
3921 {
3922 #if HAVE_GETRUSAGE
3923     struct rusage rusage;
3924
3925     getrusage(RUSAGE_SELF, &rusage);
3926     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3927 #elif HAVE_GETPROCESSTIMES
3928     HANDLE proc;
3929     FILETIME c, e, k, u;
3930     proc = GetCurrentProcess();
3931     GetProcessTimes(proc, &c, &e, &k, &u);
3932     return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3933 #else
3934     return av_gettime();
3935 #endif
3936 }
3937
3938 static int64_t getmaxrss(void)
3939 {
3940 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3941     struct rusage rusage;
3942     getrusage(RUSAGE_SELF, &rusage);
3943     return (int64_t)rusage.ru_maxrss * 1024;
3944 #elif HAVE_GETPROCESSMEMORYINFO
3945     HANDLE proc;
3946     PROCESS_MEMORY_COUNTERS memcounters;
3947     proc = GetCurrentProcess();
3948     memcounters.cb = sizeof(memcounters);
3949     GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3950     return memcounters.PeakPagefileUsage;
3951 #else
3952     return 0;
3953 #endif
3954 }
3955
3956 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3957 {
3958     int i;
3959     const char *p = str;
3960     for(i = 0;; i++) {
3961         dest[i] = atoi(p);
3962         if(i == 63)
3963             break;
3964         p = strchr(p, ',');
3965         if(!p) {
3966             fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3967             ffmpeg_exit(1);
3968         }
3969         p++;
3970     }
3971 }
3972
3973 static void opt_inter_matrix(const char *arg)
3974 {
3975     inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3976     parse_matrix_coeffs(inter_matrix, arg);
3977 }
3978
3979 static void opt_intra_matrix(const char *arg)
3980 {
3981     intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3982     parse_matrix_coeffs(intra_matrix, arg);
3983 }
3984
3985 static void show_usage(void)
3986 {
3987     printf("Hyper fast Audio and Video encoder\n");
3988     printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3989     printf("\n");
3990 }
3991
3992 static void show_help(void)
3993 {
3994     AVCodec *c;
3995     AVOutputFormat *oformat = NULL;
3996     AVInputFormat  *iformat = NULL;
3997
3998     av_log_set_callback(log_callback_help);
3999     show_usage();
4000     show_help_options(options, "Main options:\n",
4001                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
4002     show_help_options(options, "\nAdvanced options:\n",
4003                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
4004                       OPT_EXPERT);
4005     show_help_options(options, "\nVideo options:\n",
4006                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4007                       OPT_VIDEO);
4008     show_help_options(options, "\nAdvanced Video options:\n",
4009                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4010                       OPT_VIDEO | OPT_EXPERT);
4011     show_help_options(options, "\nAudio options:\n",
4012                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4013                       OPT_AUDIO);
4014     show_help_options(options, "\nAdvanced Audio options:\n",
4015                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4016                       OPT_AUDIO | OPT_EXPERT);
4017     show_help_options(options, "\nSubtitle options:\n",
4018                       OPT_SUBTITLE | OPT_GRAB,
4019                       OPT_SUBTITLE);
4020     show_help_options(options, "\nAudio/Video grab options:\n",
4021                       OPT_GRAB,
4022                       OPT_GRAB);
4023     printf("\n");
4024     av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4025     printf("\n");
4026
4027     /* individual codec options */
4028     c = NULL;
4029     while ((c = av_codec_next(c))) {
4030         if (c->priv_class) {
4031             av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4032             printf("\n");
4033         }
4034     }
4035
4036     av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4037     printf("\n");
4038
4039     /* individual muxer options */
4040     while ((oformat = av_oformat_next(oformat))) {
4041         if (oformat->priv_class) {
4042             av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
4043             printf("\n");
4044         }
4045     }
4046
4047     /* individual demuxer options */
4048     while ((iformat = av_iformat_next(iformat))) {
4049         if (iformat->priv_class) {
4050             av_opt_show2(&iformat->priv_class, NULL, AV_OPT_FLAG_DECODING_PARAM, 0);
4051             printf("\n");
4052         }
4053     }
4054
4055     av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4056 }
4057
4058 static int opt_target(const char *opt, const char *arg)
4059 {
4060     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4061     static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
4062
4063     if(!strncmp(arg, "pal-", 4)) {
4064         norm = PAL;
4065         arg += 4;
4066     } else if(!strncmp(arg, "ntsc-", 5)) {
4067         norm = NTSC;
4068         arg += 5;
4069     } else if(!strncmp(arg, "film-", 5)) {
4070         norm = FILM;
4071         arg += 5;
4072     } else {
4073         int fr;
4074         /* Calculate FR via float to avoid int overflow */
4075         fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
4076         if(fr == 25000) {
4077             norm = PAL;
4078         } else if((fr == 29970) || (fr == 23976)) {
4079             norm = NTSC;
4080         } else {
4081             /* Try to determine PAL/NTSC by peeking in the input files */
4082             if(nb_input_files) {
4083                 int i, j;
4084                 for (j = 0; j < nb_input_files; j++) {
4085                     for (i = 0; i < input_files[j].ctx->nb_streams; i++) {
4086                         AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
4087                         if(c->codec_type != AVMEDIA_TYPE_VIDEO)
4088                             continue;
4089                         fr = c->time_base.den * 1000 / c->time_base.num;
4090                         if(fr == 25000) {
4091                             norm = PAL;
4092                             break;
4093                         } else if((fr == 29970) || (fr == 23976)) {
4094                             norm = NTSC;
4095                             break;
4096                         }
4097                     }
4098                     if(norm != UNKNOWN)
4099                         break;
4100                 }
4101             }
4102         }
4103         if(verbose > 0 && norm != UNKNOWN)
4104             fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4105     }
4106
4107     if(norm == UNKNOWN) {
4108         fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4109         fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4110         fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4111         ffmpeg_exit(1);
4112     }
4113
4114     if(!strcmp(arg, "vcd")) {
4115         opt_video_codec("vcodec", "mpeg1video");
4116         opt_audio_codec("vcodec", "mp2");
4117         opt_format("f", "vcd");
4118
4119         opt_frame_size("s", norm == PAL ? "352x288" : "352x240");
4120         opt_frame_rate("r", frame_rates[norm]);
4121         opt_default("g", norm == PAL ? "15" : "18");
4122
4123         opt_default("b", "1150000");
4124         opt_default("maxrate", "1150000");
4125         opt_default("minrate", "1150000");
4126         opt_default("bufsize", "327680"); // 40*1024*8;
4127
4128         opt_default("ab", "224000");
4129         audio_sample_rate = 44100;
4130         audio_channels = 2;
4131
4132         opt_default("packetsize", "2324");
4133         opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4134
4135         /* We have to offset the PTS, so that it is consistent with the SCR.
4136            SCR starts at 36000, but the first two packs contain only padding
4137            and the first pack from the other stream, respectively, may also have
4138            been written before.
4139            So the real data starts at SCR 36000+3*1200. */
4140         mux_preload= (36000+3*1200) / 90000.0; //0.44
4141     } else if(!strcmp(arg, "svcd")) {
4142
4143         opt_video_codec("vcodec", "mpeg2video");
4144         opt_audio_codec("acodec", "mp2");
4145         opt_format("f", "svcd");
4146
4147         opt_frame_size("s", norm == PAL ? "480x576" : "480x480");
4148         opt_frame_rate("r", frame_rates[norm]);
4149         opt_default("g", norm == PAL ? "15" : "18");
4150
4151         opt_default("b", "2040000");
4152         opt_default("maxrate", "2516000");
4153         opt_default("minrate", "0"); //1145000;
4154         opt_default("bufsize", "1835008"); //224*1024*8;
4155         opt_default("flags", "+scan_offset");
4156
4157
4158         opt_default("ab", "224000");
4159         audio_sample_rate = 44100;
4160
4161         opt_default("packetsize", "2324");
4162
4163     } else if(!strcmp(arg, "dvd")) {
4164
4165         opt_video_codec("vcodec", "mpeg2video");
4166         opt_audio_codec("vcodec", "ac3");
4167         opt_format("f", "dvd");
4168
4169         opt_frame_size("vcodec", norm == PAL ? "720x576" : "720x480");
4170         opt_frame_rate("r", frame_rates[norm]);
4171         opt_default("g", norm == PAL ? "15" : "18");
4172
4173         opt_default("b", "6000000");
4174         opt_default("maxrate", "9000000");
4175         opt_default("minrate", "0"); //1500000;
4176         opt_default("bufsize", "1835008"); //224*1024*8;
4177
4178         opt_default("packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4179         opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4180
4181         opt_default("ab", "448000");
4182         audio_sample_rate = 48000;
4183
4184     } else if(!strncmp(arg, "dv", 2)) {
4185
4186         opt_format("f", "dv");
4187
4188         opt_frame_size("s", norm == PAL ? "720x576" : "720x480");
4189         opt_frame_pix_fmt("pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4190                           norm == PAL ? "yuv420p" : "yuv411p");
4191         opt_frame_rate("r", frame_rates[norm]);
4192
4193         audio_sample_rate = 48000;
4194         audio_channels = 2;
4195
4196     } else {
4197         fprintf(stderr, "Unknown target: %s\n", arg);
4198         return AVERROR(EINVAL);
4199     }
4200     return 0;
4201 }
4202
4203 static int opt_vstats_file(const char *opt, const char *arg)
4204 {
4205     av_free (vstats_filename);
4206     vstats_filename=av_strdup (arg);
4207     return 0;
4208 }
4209
4210 static int opt_vstats(const char *opt, const char *arg)
4211 {
4212     char filename[40];
4213     time_t today2 = time(NULL);
4214     struct tm *today = localtime(&today2);
4215
4216     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4217              today->tm_sec);
4218     return opt_vstats_file(opt, filename);
4219 }
4220
4221 static int opt_bsf(const char *opt, const char *arg)
4222 {
4223     AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4224     AVBitStreamFilterContext **bsfp;
4225
4226     if(!bsfc){
4227         fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4228         ffmpeg_exit(1);
4229     }
4230
4231     bsfp= *opt == 'v' ? &video_bitstream_filters :
4232           *opt == 'a' ? &audio_bitstream_filters :
4233                         &subtitle_bitstream_filters;
4234     while(*bsfp)
4235         bsfp= &(*bsfp)->next;
4236
4237     *bsfp= bsfc;
4238
4239     return 0;
4240 }
4241
4242 static int opt_preset(const char *opt, const char *arg)
4243 {
4244     FILE *f=NULL;
4245     char filename[1000], tmp[1000], tmp2[1000], line[1000];
4246     char *codec_name = *opt == 'v' ? video_codec_name :
4247                        *opt == 'a' ? audio_codec_name :
4248                                      subtitle_codec_name;
4249
4250     if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4251         fprintf(stderr, "File for preset '%s' not found\n", arg);
4252         ffmpeg_exit(1);
4253     }
4254
4255     while(!feof(f)){
4256         int e= fscanf(f, "%999[^\n]\n", line) - 1;
4257         if(line[0] == '#' && !e)
4258             continue;
4259         e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4260         if(e){
4261             fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4262             ffmpeg_exit(1);
4263         }
4264         if(!strcmp(tmp, "acodec")){
4265             opt_audio_codec(tmp, tmp2);
4266         }else if(!strcmp(tmp, "vcodec")){
4267             opt_video_codec(tmp, tmp2);
4268         }else if(!strcmp(tmp, "scodec")){
4269             opt_subtitle_codec(tmp, tmp2);
4270         }else if(!strcmp(tmp, "dcodec")){
4271             opt_data_codec(tmp, tmp2);
4272         }else if(opt_default(tmp, tmp2) < 0){
4273             fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4274             ffmpeg_exit(1);
4275         }
4276     }
4277
4278     fclose(f);
4279
4280     return 0;
4281 }
4282
4283 static const OptionDef options[] = {
4284     /* main options */
4285 #include "cmdutils_common_opts.h"
4286     { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4287     { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4288     { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4289     { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4290     { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
4291       "outfile[,metadata]:infile[,metadata]" },
4292     { "map_metadata", HAS_ARG | OPT_EXPERT, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4293       "outfile[,metadata]:infile[,metadata]" },
4294     { "map_chapters",  HAS_ARG | OPT_EXPERT, {(void*)opt_map_chapters},  "set chapters mapping", "outfile:infile" },
4295     { "t", HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4296     { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4297     { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4298     { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4299     { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
4300     { "timestamp", HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4301     { "metadata", HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4302     { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4303     { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4304       "add timings for benchmarking" },
4305     { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4306     { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4307       "dump each input packet" },
4308     { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4309       "when dumping packets, also dump the payload" },
4310     { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4311     { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
4312     { "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)", "" },
4313     { "v", HAS_ARG, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
4314     { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4315     { "threads",  HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4316     { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4317     { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4318     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4319     { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
4320     { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)&copy_tb}, "copy input stream time base when stream copying" },
4321     { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4322     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4323     { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4324     { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4325     { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)&copy_initial_nonkeyframes}, "copy initial non-keyframes" },
4326
4327     /* video options */
4328     { "b", HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4329     { "vb", HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4330     { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4331     { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4332     { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4333     { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4334     { "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" },
4335     { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4336     { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4337     { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4338     { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4339     { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4340     { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4341     { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4342     { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4343     { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4344     { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4345     { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4346     { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4347     { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4348     { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4349     { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4350     { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "threshold" },
4351     { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4352       "use same quantizer as source (implies VBR)" },
4353     { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4354     { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4355     { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4356       "deinterlace pictures" },
4357     { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4358     { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4359     { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4360 #if CONFIG_AVFILTER
4361     { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4362 #endif
4363     { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4364     { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4365     { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4366     { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4367     { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4368     { "newvideo", OPT_VIDEO, {(void*)opt_new_stream}, "add a new video stream to the current output stream" },
4369     { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4370     { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4371     { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4372     { "streamid", HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4373     { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4374
4375     /* audio options */
4376     { "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4377     { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4378     { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4379     { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4380     { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4381     { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4382     { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4383     { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4384     { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4385     { "newaudio", OPT_AUDIO, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
4386     { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4387     { "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" },
4388
4389     /* subtitle options */
4390     { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4391     { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4392     { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4393     { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4394     { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4395
4396     /* grab options */
4397     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "deprecated, use -channel", "channel" },
4398     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "deprecated, use -standard", "standard" },
4399     { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4400
4401     /* muxer options */
4402     { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4403     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4404
4405     { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4406     { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4407     { "sbsf", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4408
4409     { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4410     { "vpre", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4411     { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4412     { "fpre", HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4413     /* data codec support */
4414     { "dcodec", HAS_ARG | OPT_DATA, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4415
4416     { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4417     { NULL, },
4418 };
4419
4420 int main(int argc, char **argv)
4421 {
4422     int64_t ti;
4423
4424     av_log_set_flags(AV_LOG_SKIP_REPEATED);
4425
4426     avcodec_register_all();
4427 #if CONFIG_AVDEVICE
4428     avdevice_register_all();
4429 #endif
4430 #if CONFIG_AVFILTER
4431     avfilter_register_all();
4432 #endif
4433     av_register_all();
4434
4435     avio_set_interrupt_cb(decode_interrupt_cb);
4436
4437     init_opts();
4438
4439     show_banner();
4440
4441     /* parse options */
4442     parse_options(argc, argv, options, opt_output_file);
4443
4444     if(nb_output_files <= 0 && nb_input_files == 0) {
4445         show_usage();
4446         fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4447         ffmpeg_exit(1);
4448     }
4449
4450     /* file converter / grab */
4451     if (nb_output_files <= 0) {
4452         fprintf(stderr, "At least one output file must be specified\n");
4453         ffmpeg_exit(1);
4454     }
4455
4456     if (nb_input_files == 0) {
4457         fprintf(stderr, "At least one input file must be specified\n");
4458         ffmpeg_exit(1);
4459     }
4460
4461     ti = getutime();
4462     if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4463                   stream_maps, nb_stream_maps) < 0)
4464         ffmpeg_exit(1);
4465     ti = getutime() - ti;
4466     if (do_benchmark) {
4467         int maxrss = getmaxrss() / 1024;
4468         printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4469     }
4470
4471     return ffmpeg_exit(0);
4472 }