gst-libs/ext/libav/ffmpeg.c

   1 /*
   2  * ffmpeg main
   3  * Copyright (c) 2000-2003 Fabrice Bellard
   4  *
   5  * This file is part of Libav.
   6  *
   7  * Libav is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * Libav is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with Libav; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 #include "config.h"
  23 #include <ctype.h>
  24 #include <string.h>
  25 #include <math.h>
  26 #include <stdlib.h>
  27 #include <errno.h>
  28 #include <signal.h>
  29 #include <limits.h>
  30 #include <unistd.h>
  31 #include "libavformat/avformat.h"
  32 #include "libavdevice/avdevice.h"
  33 #include "libswscale/swscale.h"
  34 #include "libavutil/opt.h"
  35 #include "libavcodec/audioconvert.h"
  36 #include "libavutil/audioconvert.h"
  37 #include "libavutil/parseutils.h"
  38 #include "libavutil/samplefmt.h"
  39 #include "libavutil/colorspace.h"
  40 #include "libavutil/fifo.h"
  41 #include "libavutil/intreadwrite.h"
  42 #include "libavutil/dict.h"
  43 #include "libavutil/pixdesc.h"
  44 #include "libavutil/avstring.h"
  45 #include "libavutil/libm.h"
  46 #include "libavformat/os_support.h"
  47
  48 #if CONFIG_AVFILTER
  49 # include "libavfilter/avfilter.h"
  50 # include "libavfilter/avfiltergraph.h"
  51 # include "libavfilter/vsrc_buffer.h"
  52 #endif
  53
  54 #if HAVE_SYS_RESOURCE_H
  55 #include <sys/types.h>
  56 #include <sys/time.h>
  57 #include <sys/resource.h>
  58 #elif HAVE_GETPROCESSTIMES
  59 #include <windows.h>
  60 #endif
  61 #if HAVE_GETPROCESSMEMORYINFO
  62 #include <windows.h>
  63 #include <psapi.h>
  64 #endif
  65
  66 #if HAVE_SYS_SELECT_H
  67 #include <sys/select.h>
  68 #endif
  69
  70 #include <time.h>
  71
  72 #include "cmdutils.h"
  73
  74 #include "libavutil/avassert.h"
  75
  76 const char program_name[] = "ffmpeg";
  77 const int program_birth_year = 2000;
  78
  79 /* select an input stream for an output stream */
  80 typedef struct AVStreamMap {
  81     int file_index;
  82     int stream_index;
  83     int sync_file_index;
  84     int sync_stream_index;
  85 } AVStreamMap;
  86
  87 /**
  88  * select an input file for an output file
  89  */
  90 typedef struct AVMetaDataMap {
  91     int  file;      //< file index
  92     char type;      //< type of metadata to copy -- (g)lobal, (s)tream, (c)hapter or (p)rogram
  93     int  index;     //< stream/chapter/program number
  94 } AVMetaDataMap;
  95
  96 typedef struct AVChapterMap {
  97     int in_file;
  98     int out_file;
  99 } AVChapterMap;
 100
 101 static const OptionDef options[];
 102
 103 #define MAX_FILES 100
 104 #define MAX_STREAMS 1024    /* arbitrary sanity check value */
 105
 106 #define FFM_PACKET_SIZE 4096 //XXX a duplicate of the line in ffm.h
 107
 108 static const char *last_asked_format = NULL;
 109 static int64_t input_files_ts_offset[MAX_FILES];
 110 static double *input_files_ts_scale[MAX_FILES] = {NULL};
 111 static AVCodec **input_codecs = NULL;
 112 static int nb_input_codecs = 0;
 113 static int nb_input_files_ts_scale[MAX_FILES] = {0};
 114
 115 static AVFormatContext *output_files[MAX_FILES];
 116 static AVDictionary *output_opts[MAX_FILES];
 117 static int nb_output_files = 0;
 118
 119 static AVStreamMap *stream_maps = NULL;
 120 static int nb_stream_maps;
 121
 122 /* first item specifies output metadata, second is input */
 123 static AVMetaDataMap (*meta_data_maps)[2] = NULL;
 124 static int nb_meta_data_maps;
 125 static int metadata_global_autocopy   = 1;
 126 static int metadata_streams_autocopy  = 1;
 127 static int metadata_chapters_autocopy = 1;
 128
 129 static AVChapterMap *chapter_maps = NULL;
 130 static int nb_chapter_maps;
 131
 132 /* indexed by output file stream index */
 133 static int *streamid_map = NULL;
 134 static int nb_streamid_map = 0;
 135
 136 static int frame_width  = 0;
 137 static int frame_height = 0;
 138 static float frame_aspect_ratio = 0;
 139 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
 140 static enum AVSampleFormat audio_sample_fmt = AV_SAMPLE_FMT_NONE;
 141 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
 142 static AVRational frame_rate;
 143 static float video_qscale = 0;
 144 static uint16_t *intra_matrix = NULL;
 145 static uint16_t *inter_matrix = NULL;
 146 static const char *video_rc_override_string=NULL;
 147 static int video_disable = 0;
 148 static int video_discard = 0;
 149 static char *video_codec_name = NULL;
 150 static unsigned int video_codec_tag = 0;
 151 static char *video_language = NULL;
 152 static int same_quality = 0;
 153 static int do_deinterlace = 0;
 154 static int top_field_first = -1;
 155 static int me_threshold = 0;
 156 static int intra_dc_precision = 8;
 157 static int loop_input = 0;
 158 static int loop_output = AVFMT_NOOUTPUTLOOP;
 159 static int qp_hist = 0;
 160 #if CONFIG_AVFILTER
 161 static char *vfilters = NULL;
 162 #endif
 163
 164 static int intra_only = 0;
 165 static int audio_sample_rate = 0;
 166 static int64_t channel_layout = 0;
 167 #define QSCALE_NONE -99999
 168 static float audio_qscale = QSCALE_NONE;
 169 static int audio_disable = 0;
 170 static int audio_channels = 0;
 171 static char  *audio_codec_name = NULL;
 172 static unsigned int audio_codec_tag = 0;
 173 static char *audio_language = NULL;
 174
 175 static int subtitle_disable = 0;
 176 static char *subtitle_codec_name = NULL;
 177 static char *subtitle_language = NULL;
 178 static unsigned int subtitle_codec_tag = 0;
 179
 180 static int data_disable = 0;
 181 static char *data_codec_name = NULL;
 182 static unsigned int data_codec_tag = 0;
 183
 184 static float mux_preload= 0.5;
 185 static float mux_max_delay= 0.7;
 186
 187 static int64_t recording_time = INT64_MAX;
 188 static int64_t start_time = 0;
 189 static int64_t recording_timestamp = 0;
 190 static int64_t input_ts_offset = 0;
 191 static int file_overwrite = 0;
 192 static AVDictionary *metadata;
 193 static int do_benchmark = 0;
 194 static int do_hex_dump = 0;
 195 static int do_pkt_dump = 0;
 196 static int do_psnr = 0;
 197 static int do_pass = 0;
 198 static char *pass_logfilename_prefix = NULL;
 199 static int audio_stream_copy = 0;
 200 static int video_stream_copy = 0;
 201 static int subtitle_stream_copy = 0;
 202 static int data_stream_copy = 0;
 203 static int video_sync_method= -1;
 204 static int audio_sync_method= 0;
 205 static float audio_drift_threshold= 0.1;
 206 static int copy_ts= 0;
 207 static int copy_tb;
 208 static int opt_shortest = 0;
 209 static char *vstats_filename;
 210 static FILE *vstats_file;
 211 static int opt_programid = 0;
 212 static int copy_initial_nonkeyframes = 0;
 213
 214 static int rate_emu = 0;
 215
 216 static int audio_volume = 256;
 217
 218 static int exit_on_error = 0;
 219 static int using_stdin = 0;
 220 static int verbose = 1;
 221 static int thread_count= 1;
 222 static int64_t video_size = 0;
 223 static int64_t audio_size = 0;
 224 static int64_t extra_size = 0;
 225 static int nb_frames_dup = 0;
 226 static int nb_frames_drop = 0;
 227 static int input_sync;
 228 static uint64_t limit_filesize = 0;
 229 static int force_fps = 0;
 230 static char *forced_key_frames = NULL;
 231
 232 static float dts_delta_threshold = 10;
 233
 234 static int64_t timer_start;
 235
 236 static uint8_t *audio_buf;
 237 static uint8_t *audio_out;
 238 static unsigned int allocated_audio_out_size, allocated_audio_buf_size;
 239
 240 static short *samples;
 241
 242 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
 243 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
 244 static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
 245
 246 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
 247
 248 struct AVInputStream;
 249
 250 typedef struct AVOutputStream {
 251     int file_index;          /* file index */
 252     int index;               /* stream index in the output file */
 253     int source_index;        /* AVInputStream index */
 254     AVStream *st;            /* stream in the output file */
 255     int encoding_needed;     /* true if encoding needed for this stream */
 256     int frame_number;
 257     /* input pts and corresponding output pts
 258        for A/V sync */
 259     //double sync_ipts;        /* dts from the AVPacket of the demuxer in second units */
 260     struct AVInputStream *sync_ist; /* input stream to sync against */
 261     int64_t sync_opts;       /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
 262     AVBitStreamFilterContext *bitstream_filters;
 263     AVCodec *enc;
 264
 265     /* video only */
 266     int video_resample;
 267     AVFrame pict_tmp;      /* temporary image for resampling */
 268     struct SwsContext *img_resample_ctx; /* for image resampling */
 269     int resample_height;
 270     int resample_width;
 271     int resample_pix_fmt;
 272     AVRational frame_rate;
 273
 274     float frame_aspect_ratio;
 275
 276     /* forced key frames */
 277     int64_t *forced_kf_pts;
 278     int forced_kf_count;
 279     int forced_kf_index;
 280
 281     /* audio only */
 282     int audio_resample;
 283     ReSampleContext *resample; /* for audio resampling */
 284     int resample_sample_fmt;
 285     int resample_channels;
 286     int resample_sample_rate;
 287     int reformat_pair;
 288     AVAudioConvert *reformat_ctx;
 289     AVFifoBuffer *fifo;     /* for compression: one audio fifo per codec */
 290     FILE *logfile;
 291
 292 #if CONFIG_AVFILTER
 293     AVFilterContext *output_video_filter;
 294     AVFilterContext *input_video_filter;
 295     AVFilterBufferRef *picref;
 296     char *avfilter;
 297     AVFilterGraph *graph;
 298 #endif
 299
 300    int sws_flags;
 301 } AVOutputStream;
 302
 303 static AVOutputStream **output_streams_for_file[MAX_FILES] = { NULL };
 304 static int nb_output_streams_for_file[MAX_FILES] = { 0 };
 305
 306 typedef struct AVInputStream {
 307     int file_index;
 308     AVStream *st;
 309     int discard;             /* true if stream data should be discarded */
 310     int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
 311     int64_t sample_index;      /* current sample */
 312
 313     int64_t       start;     /* time when read started */
 314     int64_t       next_pts;  /* synthetic pts for cases where pkt.pts
 315                                 is not defined */
 316     int64_t       pts;       /* current pts */
 317     PtsCorrectionContext pts_ctx;
 318     int is_start;            /* is 1 at the start and after a discontinuity */
 319     int showed_multi_packet_warning;
 320     int is_past_recording_time;
 321 #if CONFIG_AVFILTER
 322     AVFrame *filter_frame;
 323     int has_filter_frame;
 324 #endif
 325 } AVInputStream;
 326
 327 typedef struct AVInputFile {
 328     AVFormatContext *ctx;
 329     int eof_reached;      /* true if eof reached */
 330     int ist_index;        /* index of first stream in ist_table */
 331     int buffer_size;      /* current total buffer size */
 332     int nb_streams;       /* nb streams we are aware of */
 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_bits_per_sample_fmt(enc->sample_fmt)/8;
 783     int isize= av_get_bits_per_sample_fmt(dec->sample_fmt)/8;
 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_bits_per_sample_fmt(ist->st->codec->sample_fmt)>>3;
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].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].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
2211                 if (!codec->width || !codec->height) {
2212                     codec->width  = icodec->width;
2213                     codec->height = icodec->height;
2214                 }
2215
2216                 ost->video_resample = codec->width   != icodec->width  ||
2217                                       codec->height  != icodec->height ||
2218                                       codec->pix_fmt != icodec->pix_fmt;
2219                 if (ost->video_resample) {
2220 #if !CONFIG_AVFILTER
2221                     avcodec_get_frame_defaults(&ost->pict_tmp);
2222                     if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2223                                          codec->width, codec->height)) {
2224                         fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
2225                         ffmpeg_exit(1);
2226                     }
2227                     ost->img_resample_ctx = sws_getContext(
2228                         icodec->width,
2229                         icodec->height,
2230                             icodec->pix_fmt,
2231                             codec->width,
2232                             codec->height,
2233                             codec->pix_fmt,
2234                             ost->sws_flags, NULL, NULL, NULL);
2235                     if (ost->img_resample_ctx == NULL) {
2236                         fprintf(stderr, "Cannot get resampling context\n");
2237                         ffmpeg_exit(1);
2238                     }
2239 #endif
2240                     codec->bits_per_raw_sample= 0;
2241                 }
2242
2243                 ost->resample_height = icodec->height;
2244                 ost->resample_width  = icodec->width;
2245                 ost->resample_pix_fmt= icodec->pix_fmt;
2246                 ost->encoding_needed = 1;
2247                 ist->decoding_needed = 1;
2248
2249                 if (!ost->frame_rate.num)
2250                     ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
2251                 if (ost->enc && ost->enc->supported_framerates && !force_fps) {
2252                     int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2253                     ost->frame_rate = ost->enc->supported_framerates[idx];
2254                 }
2255                 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2256
2257 #if CONFIG_AVFILTER
2258                 if (configure_video_filters(ist, ost)) {
2259                     fprintf(stderr, "Error opening filters!\n");
2260                     exit(1);
2261                 }
2262 #endif
2263                 break;
2264             case AVMEDIA_TYPE_SUBTITLE:
2265                 ost->encoding_needed = 1;
2266                 ist->decoding_needed = 1;
2267                 break;
2268             default:
2269                 abort();
2270                 break;
2271             }
2272             /* two pass mode */
2273             if (ost->encoding_needed &&
2274                 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2275                 char logfilename[1024];
2276                 FILE *f;
2277
2278                 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2279                          pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2280                          i);
2281                 if (codec->flags & CODEC_FLAG_PASS1) {
2282                     f = fopen(logfilename, "wb");
2283                     if (!f) {
2284                         fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2285                         ffmpeg_exit(1);
2286                     }
2287                     ost->logfile = f;
2288                 } else {
2289                     char  *logbuffer;
2290                     size_t logbuffer_size;
2291                     if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2292                         fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2293                         ffmpeg_exit(1);
2294                     }
2295                     codec->stats_in = logbuffer;
2296                 }
2297             }
2298         }
2299         if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2300             int size= codec->width * codec->height;
2301             bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2302         }
2303     }
2304
2305     if (!bit_buffer)
2306         bit_buffer = av_malloc(bit_buffer_size);
2307     if (!bit_buffer) {
2308         fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2309                 bit_buffer_size);
2310         ret = AVERROR(ENOMEM);
2311         goto fail;
2312     }
2313
2314     /* open each encoder */
2315     for(i=0;i<nb_ostreams;i++) {
2316         ost = ost_table[i];
2317         if (ost->encoding_needed) {
2318             AVCodec *codec = ost->enc;
2319             AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2320             if (!codec) {
2321                 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2322                          ost->st->codec->codec_id, ost->file_index, ost->index);
2323                 ret = AVERROR(EINVAL);
2324                 goto dump_format;
2325             }
2326             if (dec->subtitle_header) {
2327                 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2328                 if (!ost->st->codec->subtitle_header) {
2329                     ret = AVERROR(ENOMEM);
2330                     goto dump_format;
2331                 }
2332                 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2333                 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2334             }
2335             if (avcodec_open(ost->st->codec, codec) < 0) {
2336                 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2337                         ost->file_index, ost->index);
2338                 ret = AVERROR(EINVAL);
2339                 goto dump_format;
2340             }
2341             extra_size += ost->st->codec->extradata_size;
2342         }
2343     }
2344
2345     /* open each decoder */
2346     for (i = 0; i < nb_input_streams; i++) {
2347         ist = &input_streams[i];
2348         if (ist->decoding_needed) {
2349             AVCodec *codec = i < nb_input_codecs ? input_codecs[i] : NULL;
2350             if (!codec)
2351                 codec = avcodec_find_decoder(ist->st->codec->codec_id);
2352             if (!codec) {
2353                 snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2354                         ist->st->codec->codec_id, ist->file_index, ist->st->index);
2355                 ret = AVERROR(EINVAL);
2356                 goto dump_format;
2357             }
2358
2359             /* update requested sample format for the decoder based on the
2360                corresponding encoder sample format */
2361             for (j = 0; j < nb_ostreams; j++) {
2362                 ost = ost_table[j];
2363                 if (ost->source_index == i) {
2364                     update_sample_fmt(ist->st->codec, codec, ost->st->codec);
2365                     break;
2366                 }
2367             }
2368
2369             if (avcodec_open(ist->st->codec, codec) < 0) {
2370                 snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2371                         ist->file_index, ist->st->index);
2372                 ret = AVERROR(EINVAL);
2373                 goto dump_format;
2374             }
2375             //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2376             //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2377         }
2378     }
2379
2380     /* init pts */
2381     for (i = 0; i < nb_input_streams; i++) {
2382         AVStream *st;
2383         ist = &input_streams[i];
2384         st= ist->st;
2385         ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2386         ist->next_pts = AV_NOPTS_VALUE;
2387         init_pts_correction(&ist->pts_ctx);
2388         ist->is_start = 1;
2389     }
2390
2391     /* set meta data information from input file if required */
2392     for (i=0;i<nb_meta_data_maps;i++) {
2393         AVFormatContext *files[2];
2394         AVDictionary    **meta[2];
2395         int j;
2396
2397 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
2398         if ((index) < 0 || (index) >= (nb_elems)) {\
2399             snprintf(error, sizeof(error), "Invalid %s index %d while processing metadata maps\n",\
2400                      (desc), (index));\
2401             ret = AVERROR(EINVAL);\
2402             goto dump_format;\
2403         }
2404
2405         int out_file_index = meta_data_maps[i][0].file;
2406         int in_file_index = meta_data_maps[i][1].file;
2407         if (in_file_index < 0 || out_file_index < 0)
2408             continue;
2409         METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2410         METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2411
2412         files[0] = output_files[out_file_index];
2413         files[1] = input_files[in_file_index].ctx;
2414
2415         for (j = 0; j < 2; j++) {
2416             AVMetaDataMap *map = &meta_data_maps[i][j];
2417
2418             switch (map->type) {
2419             case 'g':
2420                 meta[j] = &files[j]->metadata;
2421                 break;
2422             case 's':
2423                 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
2424                 meta[j] = &files[j]->streams[map->index]->metadata;
2425                 break;
2426             case 'c':
2427                 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
2428                 meta[j] = &files[j]->chapters[map->index]->metadata;
2429                 break;
2430             case 'p':
2431                 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
2432                 meta[j] = &files[j]->programs[map->index]->metadata;
2433                 break;
2434             }
2435         }
2436
2437         av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
2438     }
2439
2440     /* copy global metadata by default */
2441     if (metadata_global_autocopy) {
2442
2443         for (i = 0; i < nb_output_files; i++)
2444             av_dict_copy(&output_files[i]->metadata, input_files[0].ctx->metadata,
2445                          AV_DICT_DONT_OVERWRITE);
2446     }
2447
2448     /* copy chapters according to chapter maps */
2449     for (i = 0; i < nb_chapter_maps; i++) {
2450         int infile  = chapter_maps[i].in_file;
2451         int outfile = chapter_maps[i].out_file;
2452
2453         if (infile < 0 || outfile < 0)
2454             continue;
2455         if (infile >= nb_input_files) {
2456             snprintf(error, sizeof(error), "Invalid input file index %d in chapter mapping.\n", infile);
2457             ret = AVERROR(EINVAL);
2458             goto dump_format;
2459         }
2460         if (outfile >= nb_output_files) {
2461             snprintf(error, sizeof(error), "Invalid output file index %d in chapter mapping.\n",outfile);
2462             ret = AVERROR(EINVAL);
2463             goto dump_format;
2464         }
2465         copy_chapters(infile, outfile);
2466     }
2467
2468     /* copy chapters from the first input file that has them*/
2469     if (!nb_chapter_maps)
2470         for (i = 0; i < nb_input_files; i++) {
2471             if (!input_files[i].ctx->nb_chapters)
2472                 continue;
2473
2474             for (j = 0; j < nb_output_files; j++)
2475                 if ((ret = copy_chapters(i, j)) < 0)
2476                     goto dump_format;
2477             break;
2478         }
2479
2480     /* open files and write file headers */
2481     for(i=0;i<nb_output_files;i++) {
2482         os = output_files[i];
2483         if (avformat_write_header(os, &output_opts[i]) < 0) {
2484             snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2485             ret = AVERROR(EINVAL);
2486             goto dump_format;
2487         }
2488         assert_avoptions(output_opts[i]);
2489         if (strcmp(output_files[i]->oformat->name, "rtp")) {
2490             want_sdp = 0;
2491         }
2492     }
2493
2494  dump_format:
2495     /* dump the file output parameters - cannot be done before in case
2496        of stream copy */
2497     for(i=0;i<nb_output_files;i++) {
2498         av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2499     }
2500
2501     /* dump the stream mapping */
2502     if (verbose >= 0) {
2503         fprintf(stderr, "Stream mapping:\n");
2504         for(i=0;i<nb_ostreams;i++) {
2505             ost = ost_table[i];
2506             fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
2507                     input_streams[ost->source_index].file_index,
2508                     input_streams[ost->source_index].st->index,
2509                     ost->file_index,
2510                     ost->index);
2511             if (ost->sync_ist != &input_streams[ost->source_index])
2512                 fprintf(stderr, " [sync #%d.%d]",
2513                         ost->sync_ist->file_index,
2514                         ost->sync_ist->st->index);
2515             fprintf(stderr, "\n");
2516         }
2517     }
2518
2519     if (ret) {
2520         fprintf(stderr, "%s\n", error);
2521         goto fail;
2522     }
2523
2524     if (want_sdp) {
2525         print_sdp(output_files, nb_output_files);
2526     }
2527
2528     if (verbose >= 0)
2529         fprintf(stderr, "Press ctrl-c to stop encoding\n");
2530     term_init();
2531
2532     timer_start = av_gettime();
2533
2534     for(; received_sigterm == 0;) {
2535         int file_index, ist_index;
2536         AVPacket pkt;
2537         double ipts_min;
2538         double opts_min;
2539
2540     redo:
2541         ipts_min= 1e100;
2542         opts_min= 1e100;
2543
2544         /* select the stream that we must read now by looking at the
2545            smallest output pts */
2546         file_index = -1;
2547         for(i=0;i<nb_ostreams;i++) {
2548             double ipts, opts;
2549             ost = ost_table[i];
2550             os = output_files[ost->file_index];
2551             ist = &input_streams[ost->source_index];
2552             if(ist->is_past_recording_time || no_packet[ist->file_index])
2553                 continue;
2554                 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2555             ipts = (double)ist->pts;
2556             if (!input_files[ist->file_index].eof_reached){
2557                 if(ipts < ipts_min) {
2558                     ipts_min = ipts;
2559                     if(input_sync ) file_index = ist->file_index;
2560                 }
2561                 if(opts < opts_min) {
2562                     opts_min = opts;
2563                     if(!input_sync) file_index = ist->file_index;
2564                 }
2565             }
2566             if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2567                 file_index= -1;
2568                 break;
2569             }
2570         }
2571         /* if none, if is finished */
2572         if (file_index < 0) {
2573             if(no_packet_count){
2574                 no_packet_count=0;
2575                 memset(no_packet, 0, sizeof(no_packet));
2576                 usleep(10000);
2577                 continue;
2578             }
2579             break;
2580         }
2581
2582         /* finish if limit size exhausted */
2583         if (limit_filesize != 0 && limit_filesize <= avio_tell(output_files[0]->pb))
2584             break;
2585
2586         /* read a frame from it and output it in the fifo */
2587         is = input_files[file_index].ctx;
2588         ret= av_read_frame(is, &pkt);
2589         if(ret == AVERROR(EAGAIN)){
2590             no_packet[file_index]=1;
2591             no_packet_count++;
2592             continue;
2593         }
2594         if (ret < 0) {
2595             input_files[file_index].eof_reached = 1;
2596             if (opt_shortest)
2597                 break;
2598             else
2599                 continue;
2600         }
2601
2602         no_packet_count=0;
2603         memset(no_packet, 0, sizeof(no_packet));
2604
2605         if (do_pkt_dump) {
2606             av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2607                              is->streams[pkt.stream_index]);
2608         }
2609         /* the following test is needed in case new streams appear
2610            dynamically in stream : we ignore them */
2611         if (pkt.stream_index >= input_files[file_index].nb_streams)
2612             goto discard_packet;
2613         ist_index = input_files[file_index].ist_index + pkt.stream_index;
2614         ist = &input_streams[ist_index];
2615         if (ist->discard)
2616             goto discard_packet;
2617
2618         if (pkt.dts != AV_NOPTS_VALUE)
2619             pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2620         if (pkt.pts != AV_NOPTS_VALUE)
2621             pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2622
2623         if (pkt.stream_index < nb_input_files_ts_scale[file_index]
2624             && input_files_ts_scale[file_index][pkt.stream_index]){
2625             if(pkt.pts != AV_NOPTS_VALUE)
2626                 pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2627             if(pkt.dts != AV_NOPTS_VALUE)
2628                 pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2629         }
2630
2631 //        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);
2632         if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2633             && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2634             int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2635             int64_t delta= pkt_dts - ist->next_pts;
2636             if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2637                 input_files_ts_offset[ist->file_index]-= delta;
2638                 if (verbose > 2)
2639                     fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2640                 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2641                 if(pkt.pts != AV_NOPTS_VALUE)
2642                     pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2643             }
2644         }
2645
2646         /* finish if recording time exhausted */
2647         if (recording_time != INT64_MAX &&
2648             av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2649             ist->is_past_recording_time = 1;
2650             goto discard_packet;
2651         }
2652
2653         //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2654         if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2655
2656             if (verbose >= 0)
2657                 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2658                         ist->file_index, ist->st->index);
2659             if (exit_on_error)
2660                 ffmpeg_exit(1);
2661             av_free_packet(&pkt);
2662             goto redo;
2663         }
2664
2665     discard_packet:
2666         av_free_packet(&pkt);
2667
2668         /* dump report by using the output first video and audio streams */
2669         print_report(output_files, ost_table, nb_ostreams, 0);
2670     }
2671
2672     /* at the end of stream, we must flush the decoder buffers */
2673     for (i = 0; i < nb_input_streams; i++) {
2674         ist = &input_streams[i];
2675         if (ist->decoding_needed) {
2676             output_packet(ist, i, ost_table, nb_ostreams, NULL);
2677         }
2678     }
2679
2680     term_exit();
2681
2682     /* write the trailer if needed and close file */
2683     for(i=0;i<nb_output_files;i++) {
2684         os = output_files[i];
2685         av_write_trailer(os);
2686     }
2687
2688     /* dump report by using the first video and audio streams */
2689     print_report(output_files, ost_table, nb_ostreams, 1);
2690
2691     /* close each encoder */
2692     for(i=0;i<nb_ostreams;i++) {
2693         ost = ost_table[i];
2694         if (ost->encoding_needed) {
2695             av_freep(&ost->st->codec->stats_in);
2696             avcodec_close(ost->st->codec);
2697         }
2698 #if CONFIG_AVFILTER
2699         avfilter_graph_free(&ost->graph);
2700 #endif
2701     }
2702
2703     /* close each decoder */
2704     for (i = 0; i < nb_input_streams; i++) {
2705         ist = &input_streams[i];
2706         if (ist->decoding_needed) {
2707             avcodec_close(ist->st->codec);
2708         }
2709     }
2710
2711     /* finished ! */
2712     ret = 0;
2713
2714  fail:
2715     av_freep(&bit_buffer);
2716
2717     if (ost_table) {
2718         for(i=0;i<nb_ostreams;i++) {
2719             ost = ost_table[i];
2720             if (ost) {
2721                 if (ost->st->stream_copy)
2722                     av_freep(&ost->st->codec->extradata);
2723                 if (ost->logfile) {
2724                     fclose(ost->logfile);
2725                     ost->logfile = NULL;
2726                 }
2727                 av_fifo_free(ost->fifo); /* works even if fifo is not
2728                                              initialized but set to zero */
2729                 av_freep(&ost->st->codec->subtitle_header);
2730                 av_free(ost->pict_tmp.data[0]);
2731                 av_free(ost->forced_kf_pts);
2732                 if (ost->video_resample)
2733                     sws_freeContext(ost->img_resample_ctx);
2734                 if (ost->resample)
2735                     audio_resample_close(ost->resample);
2736                 if (ost->reformat_ctx)
2737                     av_audio_convert_free(ost->reformat_ctx);
2738                 av_free(ost);
2739             }
2740         }
2741         av_free(ost_table);
2742     }
2743     return ret;
2744 }
2745
2746 static int opt_format(const char *opt, const char *arg)
2747 {
2748     last_asked_format = arg;
2749     return 0;
2750 }
2751
2752 static int opt_video_rc_override_string(const char *opt, const char *arg)
2753 {
2754     video_rc_override_string = arg;
2755     return 0;
2756 }
2757
2758 static int opt_me_threshold(const char *opt, const char *arg)
2759 {
2760     me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2761     return 0;
2762 }
2763
2764 static int opt_verbose(const char *opt, const char *arg)
2765 {
2766     verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2767     return 0;
2768 }
2769
2770 static int opt_frame_rate(const char *opt, const char *arg)
2771 {
2772     if (av_parse_video_rate(&frame_rate, arg) < 0) {
2773         fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2774         ffmpeg_exit(1);
2775     }
2776     return 0;
2777 }
2778
2779 static int opt_bitrate(const char *opt, const char *arg)
2780 {
2781     int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2782
2783     opt_default(opt, arg);
2784
2785     if (av_get_int(avcodec_opts[codec_type], "b", NULL) < 1000)
2786         fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2787
2788     return 0;
2789 }
2790
2791 static int opt_frame_crop(const char *opt, const char *arg)
2792 {
2793     fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2794     return AVERROR(EINVAL);
2795 }
2796
2797 static int opt_frame_size(const char *opt, const char *arg)
2798 {
2799     if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2800         fprintf(stderr, "Incorrect frame size\n");
2801         return AVERROR(EINVAL);
2802     }
2803     return 0;
2804 }
2805
2806 static int opt_pad(const char *opt, const char *arg) {
2807     fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2808     return -1;
2809 }
2810
2811 static int opt_frame_pix_fmt(const char *opt, const char *arg)
2812 {
2813     if (strcmp(arg, "list")) {
2814         frame_pix_fmt = av_get_pix_fmt(arg);
2815         if (frame_pix_fmt == PIX_FMT_NONE) {
2816             fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2817             return AVERROR(EINVAL);
2818         }
2819     } else {
2820         show_pix_fmts();
2821         ffmpeg_exit(0);
2822     }
2823     return 0;
2824 }
2825
2826 static int opt_frame_aspect_ratio(const char *opt, const char *arg)
2827 {
2828     int x = 0, y = 0;
2829     double ar = 0;
2830     const char *p;
2831     char *end;
2832
2833     p = strchr(arg, ':');
2834     if (p) {
2835         x = strtol(arg, &end, 10);
2836         if (end == p)
2837             y = strtol(end+1, &end, 10);
2838         if (x > 0 && y > 0)
2839             ar = (double)x / (double)y;
2840     } else
2841         ar = strtod(arg, NULL);
2842
2843     if (!ar) {
2844         fprintf(stderr, "Incorrect aspect ratio specification.\n");
2845         return AVERROR(EINVAL);
2846     }
2847     frame_aspect_ratio = ar;
2848     return 0;
2849 }
2850
2851 static int opt_metadata(const char *opt, const char *arg)
2852 {
2853     char *mid= strchr(arg, '=');
2854
2855     if(!mid){
2856         fprintf(stderr, "Missing =\n");
2857         ffmpeg_exit(1);
2858     }
2859     *mid++= 0;
2860
2861     av_dict_set(&metadata, arg, mid, 0);
2862
2863     return 0;
2864 }
2865
2866 static int opt_qscale(const char *opt, const char *arg)
2867 {
2868     video_qscale = parse_number_or_die(opt, arg, OPT_FLOAT, 0, 255);
2869     if (video_qscale == 0) {
2870         fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2871         return AVERROR(EINVAL);
2872     }
2873     return 0;
2874 }
2875
2876 static int opt_top_field_first(const char *opt, const char *arg)
2877 {
2878     top_field_first = parse_number_or_die(opt, arg, OPT_INT, 0, 1);
2879     return 0;
2880 }
2881
2882 static int opt_thread_count(const char *opt, const char *arg)
2883 {
2884     thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2885 #if !HAVE_THREADS
2886     if (verbose >= 0)
2887         fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2888 #endif
2889     return 0;
2890 }
2891
2892 static int opt_audio_sample_fmt(const char *opt, const char *arg)
2893 {
2894     if (strcmp(arg, "list")) {
2895         audio_sample_fmt = av_get_sample_fmt(arg);
2896         if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2897             av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2898             return AVERROR(EINVAL);
2899         }
2900     } else {
2901         int i;
2902         char fmt_str[128];
2903         for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
2904             printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
2905         ffmpeg_exit(0);
2906     }
2907     return 0;
2908 }
2909
2910 static int opt_audio_rate(const char *opt, const char *arg)
2911 {
2912     audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2913     return 0;
2914 }
2915
2916 static int opt_audio_channels(const char *opt, const char *arg)
2917 {
2918     audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2919     return 0;
2920 }
2921
2922 static int opt_video_channel(const char *opt, const char *arg)
2923 {
2924     av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
2925     opt_default("channel", arg);
2926     return 0;
2927 }
2928
2929 static int opt_video_standard(const char *opt, const char *arg)
2930 {
2931     av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
2932     opt_default("standard", arg);
2933     return 0;
2934 }
2935
2936 static int opt_codec(int *pstream_copy, char **pcodec_name,
2937                       int codec_type, const char *arg)
2938 {
2939     av_freep(pcodec_name);
2940     if (!strcmp(arg, "copy")) {
2941         *pstream_copy = 1;
2942     } else {
2943         *pcodec_name = av_strdup(arg);
2944     }
2945     return 0;
2946 }
2947
2948 static int opt_audio_codec(const char *opt, const char *arg)
2949 {
2950     return opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2951 }
2952
2953 static int opt_video_codec(const char *opt, const char *arg)
2954 {
2955     return opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2956 }
2957
2958 static int opt_subtitle_codec(const char *opt, const char *arg)
2959 {
2960     return opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2961 }
2962
2963 static int opt_data_codec(const char *opt, const char *arg)
2964 {
2965     return opt_codec(&data_stream_copy, &data_codec_name, AVMEDIA_TYPE_DATA, arg);
2966 }
2967
2968 static int opt_codec_tag(const char *opt, const char *arg)
2969 {
2970     char *tail;
2971     uint32_t *codec_tag;
2972
2973     codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2974                 !strcmp(opt, "vtag") ? &video_codec_tag :
2975                 !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2976     if (!codec_tag)
2977         return -1;
2978
2979     *codec_tag = strtol(arg, &tail, 0);
2980     if (!tail || *tail)
2981         *codec_tag = AV_RL32(arg);
2982
2983     return 0;
2984 }
2985
2986 static int opt_map(const char *opt, const char *arg)
2987 {
2988     AVStreamMap *m;
2989     char *p;
2990
2991     stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
2992     m = &stream_maps[nb_stream_maps-1];
2993
2994     m->file_index = strtol(arg, &p, 0);
2995     if (*p)
2996         p++;
2997
2998     m->stream_index = strtol(p, &p, 0);
2999     if (*p) {
3000         p++;
3001         m->sync_file_index = strtol(p, &p, 0);
3002         if (*p)
3003             p++;
3004         m->sync_stream_index = strtol(p, &p, 0);
3005     } else {
3006         m->sync_file_index = m->file_index;
3007         m->sync_stream_index = m->stream_index;
3008     }
3009     return 0;
3010 }
3011
3012 static void parse_meta_type(char *arg, char *type, int *index, char **endptr)
3013 {
3014     *endptr = arg;
3015     if (*arg == ',') {
3016         *type = *(++arg);
3017         switch (*arg) {
3018         case 'g':
3019             break;
3020         case 's':
3021         case 'c':
3022         case 'p':
3023             *index = strtol(++arg, endptr, 0);
3024             break;
3025         default:
3026             fprintf(stderr, "Invalid metadata type %c.\n", *arg);
3027             ffmpeg_exit(1);
3028         }
3029     } else
3030         *type = 'g';
3031 }
3032
3033 static int opt_map_metadata(const char *opt, const char *arg)
3034 {
3035     AVMetaDataMap *m, *m1;
3036     char *p;
3037
3038     meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
3039                                 &nb_meta_data_maps, nb_meta_data_maps + 1);
3040
3041     m = &meta_data_maps[nb_meta_data_maps - 1][0];
3042     m->file = strtol(arg, &p, 0);
3043     parse_meta_type(p, &m->type, &m->index, &p);
3044     if (*p)
3045         p++;
3046
3047     m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
3048     m1->file = strtol(p, &p, 0);
3049     parse_meta_type(p, &m1->type, &m1->index, &p);
3050
3051     if (m->type == 'g' || m1->type == 'g')
3052         metadata_global_autocopy = 0;
3053     if (m->type == 's' || m1->type == 's')
3054         metadata_streams_autocopy = 0;
3055     if (m->type == 'c' || m1->type == 'c')
3056         metadata_chapters_autocopy = 0;
3057
3058     return 0;
3059 }
3060
3061 static int opt_map_meta_data(const char *opt, const char *arg)
3062 {
3063     fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "
3064                     "Use -map_metadata instead.\n");
3065     return opt_map_metadata(opt, arg);
3066 }
3067
3068 static int opt_map_chapters(const char *opt, const char *arg)
3069 {
3070     AVChapterMap *c;
3071     char *p;
3072
3073     chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
3074                               nb_chapter_maps + 1);
3075     c = &chapter_maps[nb_chapter_maps - 1];
3076     c->out_file = strtol(arg, &p, 0);
3077     if (*p)
3078         p++;
3079
3080     c->in_file = strtol(p, &p, 0);
3081     return 0;
3082 }
3083
3084 static int opt_input_ts_scale(const char *opt, const char *arg)
3085 {
3086     unsigned int stream;
3087     double scale;
3088     char *p;
3089
3090     stream = strtol(arg, &p, 0);
3091     if (*p)
3092         p++;
3093     scale= strtod(p, &p);
3094
3095     if(stream >= MAX_STREAMS)
3096         ffmpeg_exit(1);
3097
3098     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);
3099     input_files_ts_scale[nb_input_files][stream]= scale;
3100     return 0;
3101 }
3102
3103 static int opt_recording_time(const char *opt, const char *arg)
3104 {
3105     recording_time = parse_time_or_die(opt, arg, 1);
3106     return 0;
3107 }
3108
3109 static int opt_start_time(const char *opt, const char *arg)
3110 {
3111     start_time = parse_time_or_die(opt, arg, 1);
3112     return 0;
3113 }
3114
3115 static int opt_recording_timestamp(const char *opt, const char *arg)
3116 {
3117     recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
3118     return 0;
3119 }
3120
3121 static int opt_input_ts_offset(const char *opt, const char *arg)
3122 {
3123     input_ts_offset = parse_time_or_die(opt, arg, 1);
3124     return 0;
3125 }
3126
3127 static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3128 {
3129     const char *codec_string = encoder ? "encoder" : "decoder";
3130     AVCodec *codec;
3131
3132     if(!name)
3133         return CODEC_ID_NONE;
3134     codec = encoder ?
3135         avcodec_find_encoder_by_name(name) :
3136         avcodec_find_decoder_by_name(name);
3137     if(!codec) {
3138         fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3139         ffmpeg_exit(1);
3140     }
3141     if(codec->type != type) {
3142         fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3143         ffmpeg_exit(1);
3144     }
3145     if(codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
3146        strict > FF_COMPLIANCE_EXPERIMENTAL) {
3147         fprintf(stderr, "%s '%s' is experimental and might produce bad "
3148                 "results.\nAdd '-strict experimental' if you want to use it.\n",
3149                 codec_string, codec->name);
3150         codec = encoder ?
3151             avcodec_find_encoder(codec->id) :
3152             avcodec_find_decoder(codec->id);
3153         if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
3154             fprintf(stderr, "Or use the non experimental %s '%s'.\n",
3155                     codec_string, codec->name);
3156         ffmpeg_exit(1);
3157     }
3158     return codec->id;
3159 }
3160
3161 static int opt_input_file(const char *opt, const char *filename)
3162 {
3163     AVFormatContext *ic;
3164     AVInputFormat *file_iformat = NULL;
3165     int err, i, ret, rfps, rfps_base;
3166     int64_t timestamp;
3167     uint8_t buf[128];
3168
3169     if (last_asked_format) {
3170         if (!(file_iformat = av_find_input_format(last_asked_format))) {
3171             fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3172             ffmpeg_exit(1);
3173         }
3174         last_asked_format = NULL;
3175     }
3176
3177     if (!strcmp(filename, "-"))
3178         filename = "pipe:";
3179
3180     using_stdin |= !strncmp(filename, "pipe:", 5) ||
3181                     !strcmp(filename, "/dev/stdin");
3182
3183     /* get default parameters from command line */
3184     ic = avformat_alloc_context();
3185     if (!ic) {
3186         print_error(filename, AVERROR(ENOMEM));
3187         ffmpeg_exit(1);
3188     }
3189     if (audio_sample_rate) {
3190         snprintf(buf, sizeof(buf), "%d", audio_sample_rate);
3191         av_dict_set(&format_opts, "sample_rate", buf, 0);
3192     }
3193     if (audio_channels) {
3194         snprintf(buf, sizeof(buf), "%d", audio_channels);
3195         av_dict_set(&format_opts, "channels", buf, 0);
3196     }
3197     if (frame_rate.num) {
3198         snprintf(buf, sizeof(buf), "%d/%d", frame_rate.num, frame_rate.den);
3199         av_dict_set(&format_opts, "framerate", buf, 0);
3200     }
3201     if (frame_width && frame_height) {
3202         snprintf(buf, sizeof(buf), "%dx%d", frame_width, frame_height);
3203         av_dict_set(&format_opts, "video_size", buf, 0);
3204     }
3205     if (frame_pix_fmt != PIX_FMT_NONE)
3206         av_dict_set(&format_opts, "pixel_format", av_get_pix_fmt_name(frame_pix_fmt), 0);
3207
3208     ic->video_codec_id   =
3209         find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0,
3210                           avcodec_opts[AVMEDIA_TYPE_VIDEO   ]->strict_std_compliance);
3211     ic->audio_codec_id   =
3212         find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0,
3213                           avcodec_opts[AVMEDIA_TYPE_AUDIO   ]->strict_std_compliance);
3214     ic->subtitle_codec_id=
3215         find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
3216                           avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3217     ic->flags |= AVFMT_FLAG_NONBLOCK;
3218
3219     /* open the input file with generic libav function */
3220     err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
3221     if (err < 0) {
3222         print_error(filename, err);
3223         ffmpeg_exit(1);
3224     }
3225     assert_avoptions(format_opts);
3226
3227     if(opt_programid) {
3228         int i, j;
3229         int found=0;
3230         for(i=0; i<ic->nb_streams; i++){
3231             ic->streams[i]->discard= AVDISCARD_ALL;
3232         }
3233         for(i=0; i<ic->nb_programs; i++){
3234             AVProgram *p= ic->programs[i];
3235             if(p->id != opt_programid){
3236                 p->discard = AVDISCARD_ALL;
3237             }else{
3238                 found=1;
3239                 for(j=0; j<p->nb_stream_indexes; j++){
3240                     ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3241                 }
3242             }
3243         }
3244         if(!found){
3245             fprintf(stderr, "Specified program id not found\n");
3246             ffmpeg_exit(1);
3247         }
3248         opt_programid=0;
3249     }
3250
3251     ic->loop_input = loop_input;
3252
3253     /* Set AVCodecContext options so they will be seen by av_find_stream_info() */
3254     for (i = 0; i < ic->nb_streams; i++) {
3255         AVCodecContext *dec = ic->streams[i]->codec;
3256         switch (dec->codec_type) {
3257         case AVMEDIA_TYPE_AUDIO:
3258             set_context_opts(dec, avcodec_opts[AVMEDIA_TYPE_AUDIO],
3259                              AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM,
3260                              NULL);
3261             break;
3262         case AVMEDIA_TYPE_VIDEO:
3263             set_context_opts(dec, avcodec_opts[AVMEDIA_TYPE_VIDEO],
3264                              AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM,
3265                              NULL);
3266             break;
3267         }
3268     }
3269
3270     /* If not enough info to get the stream parameters, we decode the
3271        first frames to get it. (used in mpeg case for example) */
3272     ret = av_find_stream_info(ic);
3273     if (ret < 0 && verbose >= 0) {
3274         fprintf(stderr, "%s: could not find codec parameters\n", filename);
3275         av_close_input_file(ic);
3276         ffmpeg_exit(1);
3277     }
3278
3279     timestamp = start_time;
3280     /* add the stream start time */
3281     if (ic->start_time != AV_NOPTS_VALUE)
3282         timestamp += ic->start_time;
3283
3284     /* if seeking requested, we execute it */
3285     if (start_time != 0) {
3286         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3287         if (ret < 0) {
3288             fprintf(stderr, "%s: could not seek to position %0.3f\n",
3289                     filename, (double)timestamp / AV_TIME_BASE);
3290         }
3291         /* reset seek info */
3292         start_time = 0;
3293     }
3294
3295     /* update the current parameters so that they match the one of the input stream */
3296     for(i=0;i<ic->nb_streams;i++) {
3297         AVStream *st = ic->streams[i];
3298         AVCodecContext *dec = st->codec;
3299         AVInputStream *ist;
3300
3301         dec->thread_count = thread_count;
3302         input_codecs = grow_array(input_codecs, sizeof(*input_codecs), &nb_input_codecs, nb_input_codecs + 1);
3303
3304         input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
3305         ist = &input_streams[nb_input_streams - 1];
3306         ist->st = st;
3307         ist->file_index = nb_input_files;
3308         ist->discard = 1;
3309
3310         switch (dec->codec_type) {
3311         case AVMEDIA_TYPE_AUDIO:
3312             input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(audio_codec_name);
3313             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]);
3314             channel_layout    = dec->channel_layout;
3315             audio_sample_fmt  = dec->sample_fmt;
3316             if(audio_disable)
3317                 st->discard= AVDISCARD_ALL;
3318             break;
3319         case AVMEDIA_TYPE_VIDEO:
3320             input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(video_codec_name);
3321             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]);
3322             rfps      = ic->streams[i]->r_frame_rate.num;
3323             rfps_base = ic->streams[i]->r_frame_rate.den;
3324             if (dec->lowres) {
3325                 dec->flags |= CODEC_FLAG_EMU_EDGE;
3326                 dec->height >>= dec->lowres;
3327                 dec->width  >>= dec->lowres;
3328             }
3329             if(me_threshold)
3330                 dec->debug |= FF_DEBUG_MV;
3331
3332             if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3333
3334                 if (verbose >= 0)
3335                     fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3336                             i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3337
3338                     (float)rfps / rfps_base, rfps, rfps_base);
3339             }
3340
3341             if(video_disable)
3342                 st->discard= AVDISCARD_ALL;
3343             else if(video_discard)
3344                 st->discard= video_discard;
3345             break;
3346         case AVMEDIA_TYPE_DATA:
3347             break;
3348         case AVMEDIA_TYPE_SUBTITLE:
3349             input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(subtitle_codec_name);
3350             if(subtitle_disable)
3351                 st->discard = AVDISCARD_ALL;
3352             break;
3353         case AVMEDIA_TYPE_ATTACHMENT:
3354         case AVMEDIA_TYPE_UNKNOWN:
3355             break;
3356         default:
3357             abort();
3358         }
3359     }
3360
3361     input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3362     /* dump the file content */
3363     if (verbose >= 0)
3364         av_dump_format(ic, nb_input_files, filename, 0);
3365
3366     input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3367     input_files[nb_input_files - 1].ctx        = ic;
3368     input_files[nb_input_files - 1].ist_index  = nb_input_streams - ic->nb_streams;
3369     input_files[nb_input_files - 1].nb_streams = ic->nb_streams;
3370
3371     frame_rate    = (AVRational){0, 0};
3372     frame_pix_fmt = PIX_FMT_NONE;
3373     frame_height = 0;
3374     frame_width  = 0;
3375     audio_sample_rate = 0;
3376     audio_channels    = 0;
3377
3378     av_freep(&video_codec_name);
3379     av_freep(&audio_codec_name);
3380     av_freep(&subtitle_codec_name);
3381     uninit_opts();
3382     init_opts();
3383     return 0;
3384 }
3385
3386 static void check_inputs(int *has_video_ptr,
3387                          int *has_audio_ptr,
3388                          int *has_subtitle_ptr,
3389                          int *has_data_ptr)
3390 {
3391     int has_video, has_audio, has_subtitle, has_data, i, j;
3392     AVFormatContext *ic;
3393
3394     has_video = 0;
3395     has_audio = 0;
3396     has_subtitle = 0;
3397     has_data = 0;
3398
3399     for(j=0;j<nb_input_files;j++) {
3400         ic = input_files[j].ctx;
3401         for(i=0;i<ic->nb_streams;i++) {
3402             AVCodecContext *enc = ic->streams[i]->codec;
3403             switch(enc->codec_type) {
3404             case AVMEDIA_TYPE_AUDIO:
3405                 has_audio = 1;
3406                 break;
3407             case AVMEDIA_TYPE_VIDEO:
3408                 has_video = 1;
3409                 break;
3410             case AVMEDIA_TYPE_SUBTITLE:
3411                 has_subtitle = 1;
3412                 break;
3413             case AVMEDIA_TYPE_DATA:
3414             case AVMEDIA_TYPE_ATTACHMENT:
3415             case AVMEDIA_TYPE_UNKNOWN:
3416                 has_data = 1;
3417                 break;
3418             default:
3419                 abort();
3420             }
3421         }
3422     }
3423     *has_video_ptr = has_video;
3424     *has_audio_ptr = has_audio;
3425     *has_subtitle_ptr = has_subtitle;
3426     *has_data_ptr = has_data;
3427 }
3428
3429 static void new_video_stream(AVFormatContext *oc, int file_idx)
3430 {
3431     AVStream *st;
3432     AVOutputStream *ost;
3433     AVCodecContext *video_enc;
3434     enum CodecID codec_id = CODEC_ID_NONE;
3435     AVCodec *codec= NULL;
3436
3437     st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3438     if (!st) {
3439         fprintf(stderr, "Could not alloc stream\n");
3440         ffmpeg_exit(1);
3441     }
3442     ost = new_output_stream(oc, file_idx);
3443
3444     if(!video_stream_copy){
3445         if (video_codec_name) {
3446             codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
3447                                          avcodec_opts[AVMEDIA_TYPE_VIDEO]->strict_std_compliance);
3448             codec = avcodec_find_encoder_by_name(video_codec_name);
3449             ost->enc = codec;
3450         } else {
3451             codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3452             codec = avcodec_find_encoder(codec_id);
3453         }
3454
3455         ost->frame_aspect_ratio = frame_aspect_ratio;
3456         frame_aspect_ratio = 0;
3457 #if CONFIG_AVFILTER
3458         ost->avfilter= vfilters;
3459         vfilters = NULL;
3460 #endif
3461     }
3462
3463     avcodec_get_context_defaults3(st->codec, codec);
3464     ost->bitstream_filters = video_bitstream_filters;
3465     video_bitstream_filters= NULL;
3466
3467     st->codec->thread_count= thread_count;
3468
3469     video_enc = st->codec;
3470
3471     if(video_codec_tag)
3472         video_enc->codec_tag= video_codec_tag;
3473
3474     if(oc->oformat->flags & AVFMT_GLOBALHEADER) {
3475         video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3476         avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3477     }
3478
3479     if (video_stream_copy) {
3480         st->stream_copy = 1;
3481         video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3482         video_enc->sample_aspect_ratio =
3483         st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3484     } else {
3485         const char *p;
3486         int i;
3487
3488         if (frame_rate.num)
3489             ost->frame_rate = frame_rate;
3490         video_enc->codec_id = codec_id;
3491         set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3492
3493         video_enc->width = frame_width;
3494         video_enc->height = frame_height;
3495         video_enc->pix_fmt = frame_pix_fmt;
3496         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3497
3498         if (intra_only)
3499             video_enc->gop_size = 0;
3500         if (video_qscale || same_quality) {
3501             video_enc->flags |= CODEC_FLAG_QSCALE;
3502             video_enc->global_quality=
3503                 st->quality = FF_QP2LAMBDA * video_qscale;
3504         }
3505
3506         if(intra_matrix)
3507             video_enc->intra_matrix = intra_matrix;
3508         if(inter_matrix)
3509             video_enc->inter_matrix = inter_matrix;
3510
3511         p= video_rc_override_string;
3512         for(i=0; p; i++){
3513             int start, end, q;
3514             int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3515             if(e!=3){
3516                 fprintf(stderr, "error parsing rc_override\n");
3517                 ffmpeg_exit(1);
3518             }
3519             video_enc->rc_override=
3520                 av_realloc(video_enc->rc_override,
3521                            sizeof(RcOverride)*(i+1));
3522             video_enc->rc_override[i].start_frame= start;
3523             video_enc->rc_override[i].end_frame  = end;
3524             if(q>0){
3525                 video_enc->rc_override[i].qscale= q;
3526                 video_enc->rc_override[i].quality_factor= 1.0;
3527             }
3528             else{
3529                 video_enc->rc_override[i].qscale= 0;
3530                 video_enc->rc_override[i].quality_factor= -q/100.0;
3531             }
3532             p= strchr(p, '/');
3533             if(p) p++;
3534         }
3535         video_enc->rc_override_count=i;
3536         if (!video_enc->rc_initial_buffer_occupancy)
3537             video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3538         video_enc->me_threshold= me_threshold;
3539         video_enc->intra_dc_precision= intra_dc_precision - 8;
3540
3541         if (do_psnr)
3542             video_enc->flags|= CODEC_FLAG_PSNR;
3543
3544         /* two pass mode */
3545         if (do_pass) {
3546             if (do_pass == 1) {
3547                 video_enc->flags |= CODEC_FLAG_PASS1;
3548             } else {
3549                 video_enc->flags |= CODEC_FLAG_PASS2;
3550             }
3551         }
3552
3553         if (forced_key_frames)
3554             parse_forced_key_frames(forced_key_frames, ost, video_enc);
3555     }
3556     if (video_language) {
3557         av_dict_set(&st->metadata, "language", video_language, 0);
3558         av_freep(&video_language);
3559     }
3560
3561     /* reset some key parameters */
3562     video_disable = 0;
3563     av_freep(&video_codec_name);
3564     av_freep(&forced_key_frames);
3565     video_stream_copy = 0;
3566     frame_pix_fmt = PIX_FMT_NONE;
3567 }
3568
3569 static void new_audio_stream(AVFormatContext *oc, int file_idx)
3570 {
3571     AVStream *st;
3572     AVOutputStream *ost;
3573     AVCodec *codec= NULL;
3574     AVCodecContext *audio_enc;
3575     enum CodecID codec_id = CODEC_ID_NONE;
3576
3577     st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3578     if (!st) {
3579         fprintf(stderr, "Could not alloc stream\n");
3580         ffmpeg_exit(1);
3581     }
3582     ost = new_output_stream(oc, file_idx);
3583
3584     if(!audio_stream_copy){
3585         if (audio_codec_name) {
3586             codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
3587                                          avcodec_opts[AVMEDIA_TYPE_AUDIO]->strict_std_compliance);
3588             codec = avcodec_find_encoder_by_name(audio_codec_name);
3589             ost->enc = codec;
3590         } else {
3591             codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3592             codec = avcodec_find_encoder(codec_id);
3593         }
3594     }
3595
3596     avcodec_get_context_defaults3(st->codec, codec);
3597
3598     ost->bitstream_filters = audio_bitstream_filters;
3599     audio_bitstream_filters= NULL;
3600
3601     st->codec->thread_count= thread_count;
3602
3603     audio_enc = st->codec;
3604     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3605
3606     if(audio_codec_tag)
3607         audio_enc->codec_tag= audio_codec_tag;
3608
3609     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3610         audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3611         avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3612     }
3613     if (audio_stream_copy) {
3614         st->stream_copy = 1;
3615     } else {
3616         audio_enc->codec_id = codec_id;
3617         set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3618
3619         if (audio_qscale > QSCALE_NONE) {
3620             audio_enc->flags |= CODEC_FLAG_QSCALE;
3621             audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3622         }
3623         if (audio_channels)
3624             audio_enc->channels = audio_channels;
3625         audio_enc->sample_fmt = audio_sample_fmt;
3626         if (audio_sample_rate)
3627             audio_enc->sample_rate = audio_sample_rate;
3628         audio_enc->channel_layout = channel_layout;
3629         choose_sample_fmt(st, codec);
3630     }
3631     if (audio_language) {
3632         av_dict_set(&st->metadata, "language", audio_language, 0);
3633         av_freep(&audio_language);
3634     }
3635
3636     /* reset some key parameters */
3637     audio_disable = 0;
3638     av_freep(&audio_codec_name);
3639     audio_stream_copy = 0;
3640 }
3641
3642 static void new_data_stream(AVFormatContext *oc, int file_idx)
3643 {
3644     AVStream *st;
3645     AVCodec *codec=NULL;
3646     AVCodecContext *data_enc;
3647
3648     st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3649     if (!st) {
3650         fprintf(stderr, "Could not alloc stream\n");
3651         ffmpeg_exit(1);
3652     }
3653     new_output_stream(oc, file_idx);
3654     data_enc = st->codec;
3655     if (!data_stream_copy) {
3656         fprintf(stderr, "Data stream encoding not supported yet (only streamcopy)\n");
3657         ffmpeg_exit(1);
3658     }
3659     avcodec_get_context_defaults3(st->codec, codec);
3660
3661     data_enc->codec_type = AVMEDIA_TYPE_DATA;
3662
3663     if (data_codec_tag)
3664         data_enc->codec_tag= data_codec_tag;
3665
3666     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3667         data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3668         avcodec_opts[AVMEDIA_TYPE_DATA]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3669     }
3670     if (data_stream_copy) {
3671         st->stream_copy = 1;
3672     }
3673
3674     data_disable = 0;
3675     av_freep(&data_codec_name);
3676     data_stream_copy = 0;
3677 }
3678
3679 static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3680 {
3681     AVStream *st;
3682     AVOutputStream *ost;
3683     AVCodec *codec=NULL;
3684     AVCodecContext *subtitle_enc;
3685     enum CodecID codec_id = CODEC_ID_NONE;
3686
3687     st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3688     if (!st) {
3689         fprintf(stderr, "Could not alloc stream\n");
3690         ffmpeg_exit(1);
3691     }
3692     ost = new_output_stream(oc, file_idx);
3693     subtitle_enc = st->codec;
3694     if(!subtitle_stream_copy){
3695         if (subtitle_codec_name) {
3696             codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,
3697                                          avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3698             codec = avcodec_find_encoder_by_name(subtitle_codec_name);
3699             ost->enc = codec;
3700         } else {
3701             codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_SUBTITLE);
3702             codec = avcodec_find_encoder(codec_id);
3703         }
3704     }
3705     avcodec_get_context_defaults3(st->codec, codec);
3706
3707     ost->bitstream_filters = subtitle_bitstream_filters;
3708     subtitle_bitstream_filters= NULL;
3709
3710     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3711
3712     if(subtitle_codec_tag)
3713         subtitle_enc->codec_tag= subtitle_codec_tag;
3714
3715     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3716         subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3717         avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3718     }
3719     if (subtitle_stream_copy) {
3720         st->stream_copy = 1;
3721     } else {
3722         subtitle_enc->codec_id = codec_id;
3723         set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3724     }
3725
3726     if (subtitle_language) {
3727         av_dict_set(&st->metadata, "language", subtitle_language, 0);
3728         av_freep(&subtitle_language);
3729     }
3730
3731     subtitle_disable = 0;
3732     av_freep(&subtitle_codec_name);
3733     subtitle_stream_copy = 0;
3734 }
3735
3736 static int opt_new_stream(const char *opt, const char *arg)
3737 {
3738     AVFormatContext *oc;
3739     int file_idx = nb_output_files - 1;
3740     if (nb_output_files <= 0) {
3741         fprintf(stderr, "At least one output file must be specified\n");
3742         ffmpeg_exit(1);
3743     }
3744     oc = output_files[file_idx];
3745
3746     if      (!strcmp(opt, "newvideo"   )) new_video_stream   (oc, file_idx);
3747     else if (!strcmp(opt, "newaudio"   )) new_audio_stream   (oc, file_idx);
3748     else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3749     else if (!strcmp(opt, "newdata"    )) new_data_stream    (oc, file_idx);
3750     else av_assert0(0);
3751     return 0;
3752 }
3753
3754 /* arg format is "output-stream-index:streamid-value". */
3755 static int opt_streamid(const char *opt, const char *arg)
3756 {
3757     int idx;
3758     char *p;
3759     char idx_str[16];
3760
3761     av_strlcpy(idx_str, arg, sizeof(idx_str));
3762     p = strchr(idx_str, ':');
3763     if (!p) {
3764         fprintf(stderr,
3765                 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3766                 arg, opt);
3767         ffmpeg_exit(1);
3768     }
3769     *p++ = '\0';
3770     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3771     streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3772     streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3773     return 0;
3774 }
3775
3776 static void opt_output_file(const char *filename)
3777 {
3778     AVFormatContext *oc;
3779     int err, use_video, use_audio, use_subtitle, use_data;
3780     int input_has_video, input_has_audio, input_has_subtitle, input_has_data;
3781     AVOutputFormat *file_oformat;
3782
3783     if (!strcmp(filename, "-"))
3784         filename = "pipe:";
3785
3786     oc = avformat_alloc_context();
3787     if (!oc) {
3788         print_error(filename, AVERROR(ENOMEM));
3789         ffmpeg_exit(1);
3790     }
3791
3792     if (last_asked_format) {
3793         file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3794         if (!file_oformat) {
3795             fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3796             ffmpeg_exit(1);
3797         }
3798         last_asked_format = NULL;
3799     } else {
3800         file_oformat = av_guess_format(NULL, filename, NULL);
3801         if (!file_oformat) {
3802             fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3803                     filename);
3804             ffmpeg_exit(1);
3805         }
3806     }
3807
3808     oc->oformat = file_oformat;
3809     av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3810
3811     if (!strcmp(file_oformat->name, "ffm") &&
3812         av_strstart(filename, "http:", NULL)) {
3813         /* special case for files sent to ffserver: we get the stream
3814            parameters from ffserver */
3815         int err = read_ffserver_streams(oc, filename);
3816         if (err < 0) {
3817             print_error(filename, err);
3818             ffmpeg_exit(1);
3819         }
3820     } else {
3821         use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3822         use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3823         use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3824         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 */
3825
3826         /* disable if no corresponding type found and at least one
3827            input file */
3828         if (nb_input_files > 0) {
3829             check_inputs(&input_has_video,
3830                          &input_has_audio,
3831                          &input_has_subtitle,
3832                          &input_has_data);
3833
3834             if (!input_has_video)
3835                 use_video = 0;
3836             if (!input_has_audio)
3837                 use_audio = 0;
3838             if (!input_has_subtitle)
3839                 use_subtitle = 0;
3840             if (!input_has_data)
3841                 use_data = 0;
3842         }
3843
3844         /* manual disable */
3845         if (audio_disable)    use_audio    = 0;
3846         if (video_disable)    use_video    = 0;
3847         if (subtitle_disable) use_subtitle = 0;
3848         if (data_disable)     use_data     = 0;
3849
3850         if (use_video)    new_video_stream(oc, nb_output_files);
3851         if (use_audio)    new_audio_stream(oc, nb_output_files);
3852         if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3853         if (use_data)     new_data_stream(oc, nb_output_files);
3854
3855         oc->timestamp = recording_timestamp;
3856
3857         av_dict_copy(&oc->metadata, metadata, 0);
3858         av_dict_free(&metadata);
3859     }
3860
3861     av_dict_copy(&output_opts[nb_output_files], format_opts, 0);
3862     output_files[nb_output_files++] = oc;
3863
3864     /* check filename in case of an image number is expected */
3865     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3866         if (!av_filename_number_test(oc->filename)) {
3867             print_error(oc->filename, AVERROR(EINVAL));
3868             ffmpeg_exit(1);
3869         }
3870     }
3871
3872     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3873         /* test if it already exists to avoid loosing precious files */
3874         if (!file_overwrite &&
3875             (strchr(filename, ':') == NULL ||
3876              filename[1] == ':' ||
3877              av_strstart(filename, "file:", NULL))) {
3878             if (avio_check(filename, 0) == 0) {
3879                 if (!using_stdin) {
3880                     fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3881                     fflush(stderr);
3882                     if (!read_yesno()) {
3883                         fprintf(stderr, "Not overwriting - exiting\n");
3884                         ffmpeg_exit(1);
3885                     }
3886                 }
3887                 else {
3888                     fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3889                     ffmpeg_exit(1);
3890                 }
3891             }
3892         }
3893
3894         /* open the file */
3895         if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3896             print_error(filename, err);
3897             ffmpeg_exit(1);
3898         }
3899     }
3900
3901     oc->preload= (int)(mux_preload*AV_TIME_BASE);
3902     oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3903     oc->loop_output = loop_output;
3904     oc->flags |= AVFMT_FLAG_NONBLOCK;
3905
3906     frame_rate    = (AVRational){0, 0};
3907     frame_width   = 0;
3908     frame_height  = 0;
3909     audio_sample_rate = 0;
3910     audio_channels    = 0;
3911
3912     av_freep(&forced_key_frames);
3913     uninit_opts();
3914     init_opts();
3915 }
3916
3917 /* same option as mencoder */
3918 static int opt_pass(const char *opt, const char *arg)
3919 {
3920     do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3921     return 0;
3922 }
3923
3924 static int64_t getutime(void)
3925 {
3926 #if HAVE_GETRUSAGE
3927     struct rusage rusage;
3928
3929     getrusage(RUSAGE_SELF, &rusage);
3930     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3931 #elif HAVE_GETPROCESSTIMES
3932     HANDLE proc;
3933     FILETIME c, e, k, u;
3934     proc = GetCurrentProcess();
3935     GetProcessTimes(proc, &c, &e, &k, &u);
3936     return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3937 #else
3938     return av_gettime();
3939 #endif
3940 }
3941
3942 static int64_t getmaxrss(void)
3943 {
3944 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3945     struct rusage rusage;
3946     getrusage(RUSAGE_SELF, &rusage);
3947     return (int64_t)rusage.ru_maxrss * 1024;
3948 #elif HAVE_GETPROCESSMEMORYINFO
3949     HANDLE proc;
3950     PROCESS_MEMORY_COUNTERS memcounters;
3951     proc = GetCurrentProcess();
3952     memcounters.cb = sizeof(memcounters);
3953     GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3954     return memcounters.PeakPagefileUsage;
3955 #else
3956     return 0;
3957 #endif
3958 }
3959
3960 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3961 {
3962     int i;
3963     const char *p = str;
3964     for(i = 0;; i++) {
3965         dest[i] = atoi(p);
3966         if(i == 63)
3967             break;
3968         p = strchr(p, ',');
3969         if(!p) {
3970             fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3971             ffmpeg_exit(1);
3972         }
3973         p++;
3974     }
3975 }
3976
3977 static void opt_inter_matrix(const char *arg)
3978 {
3979     inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3980     parse_matrix_coeffs(inter_matrix, arg);
3981 }
3982
3983 static void opt_intra_matrix(const char *arg)
3984 {
3985     intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3986     parse_matrix_coeffs(intra_matrix, arg);
3987 }
3988
3989 static void show_usage(void)
3990 {
3991     printf("Hyper fast Audio and Video encoder\n");
3992     printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3993     printf("\n");
3994 }
3995
3996 static void show_help(void)
3997 {
3998     AVCodec *c;
3999     AVOutputFormat *oformat = NULL;
4000     AVInputFormat  *iformat = NULL;
4001
4002     av_log_set_callback(log_callback_help);
4003     show_usage();
4004     show_help_options(options, "Main options:\n",
4005                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
4006     show_help_options(options, "\nAdvanced options:\n",
4007                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
4008                       OPT_EXPERT);
4009     show_help_options(options, "\nVideo options:\n",
4010                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4011                       OPT_VIDEO);
4012     show_help_options(options, "\nAdvanced Video options:\n",
4013                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4014                       OPT_VIDEO | OPT_EXPERT);
4015     show_help_options(options, "\nAudio options:\n",
4016                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4017                       OPT_AUDIO);
4018     show_help_options(options, "\nAdvanced Audio options:\n",
4019                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4020                       OPT_AUDIO | OPT_EXPERT);
4021     show_help_options(options, "\nSubtitle options:\n",
4022                       OPT_SUBTITLE | OPT_GRAB,
4023                       OPT_SUBTITLE);
4024     show_help_options(options, "\nAudio/Video grab options:\n",
4025                       OPT_GRAB,
4026                       OPT_GRAB);
4027     printf("\n");
4028     av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4029     printf("\n");
4030
4031     /* individual codec options */
4032     c = NULL;
4033     while ((c = av_codec_next(c))) {
4034         if (c->priv_class) {
4035             av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4036             printf("\n");
4037         }
4038     }
4039
4040     av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4041     printf("\n");
4042
4043     /* individual muxer options */
4044     while ((oformat = av_oformat_next(oformat))) {
4045         if (oformat->priv_class) {
4046             av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
4047             printf("\n");
4048         }
4049     }
4050
4051     /* individual demuxer options */
4052     while ((iformat = av_iformat_next(iformat))) {
4053         if (iformat->priv_class) {
4054             av_opt_show2(&iformat->priv_class, NULL, AV_OPT_FLAG_DECODING_PARAM, 0);
4055             printf("\n");
4056         }
4057     }
4058
4059     av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4060 }
4061
4062 static int opt_target(const char *opt, const char *arg)
4063 {
4064     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4065     static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
4066
4067     if(!strncmp(arg, "pal-", 4)) {
4068         norm = PAL;
4069         arg += 4;
4070     } else if(!strncmp(arg, "ntsc-", 5)) {
4071         norm = NTSC;
4072         arg += 5;
4073     } else if(!strncmp(arg, "film-", 5)) {
4074         norm = FILM;
4075         arg += 5;
4076     } else {
4077         int fr;
4078         /* Calculate FR via float to avoid int overflow */
4079         fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
4080         if(fr == 25000) {
4081             norm = PAL;
4082         } else if((fr == 29970) || (fr == 23976)) {
4083             norm = NTSC;
4084         } else {
4085             /* Try to determine PAL/NTSC by peeking in the input files */
4086             if(nb_input_files) {
4087                 int i, j;
4088                 for (j = 0; j < nb_input_files; j++) {
4089                     for (i = 0; i < input_files[j].ctx->nb_streams; i++) {
4090                         AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
4091                         if(c->codec_type != AVMEDIA_TYPE_VIDEO)
4092                             continue;
4093                         fr = c->time_base.den * 1000 / c->time_base.num;
4094                         if(fr == 25000) {
4095                             norm = PAL;
4096                             break;
4097                         } else if((fr == 29970) || (fr == 23976)) {
4098                             norm = NTSC;
4099                             break;
4100                         }
4101                     }
4102                     if(norm != UNKNOWN)
4103                         break;
4104                 }
4105             }
4106         }
4107         if(verbose > 0 && norm != UNKNOWN)
4108             fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4109     }
4110
4111     if(norm == UNKNOWN) {
4112         fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4113         fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4114         fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4115         ffmpeg_exit(1);
4116     }
4117
4118     if(!strcmp(arg, "vcd")) {
4119         opt_video_codec("vcodec", "mpeg1video");
4120         opt_audio_codec("vcodec", "mp2");
4121         opt_format("f", "vcd");
4122
4123         opt_frame_size("s", norm == PAL ? "352x288" : "352x240");
4124         opt_frame_rate("r", frame_rates[norm]);
4125         opt_default("g", norm == PAL ? "15" : "18");
4126
4127         opt_default("b", "1150000");
4128         opt_default("maxrate", "1150000");
4129         opt_default("minrate", "1150000");
4130         opt_default("bufsize", "327680"); // 40*1024*8;
4131
4132         opt_default("ab", "224000");
4133         audio_sample_rate = 44100;
4134         audio_channels = 2;
4135
4136         opt_default("packetsize", "2324");
4137         opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4138
4139         /* We have to offset the PTS, so that it is consistent with the SCR.
4140            SCR starts at 36000, but the first two packs contain only padding
4141            and the first pack from the other stream, respectively, may also have
4142            been written before.
4143            So the real data starts at SCR 36000+3*1200. */
4144         mux_preload= (36000+3*1200) / 90000.0; //0.44
4145     } else if(!strcmp(arg, "svcd")) {
4146
4147         opt_video_codec("vcodec", "mpeg2video");
4148         opt_audio_codec("acodec", "mp2");
4149         opt_format("f", "svcd");
4150
4151         opt_frame_size("s", norm == PAL ? "480x576" : "480x480");
4152         opt_frame_rate("r", frame_rates[norm]);
4153         opt_default("g", norm == PAL ? "15" : "18");
4154
4155         opt_default("b", "2040000");
4156         opt_default("maxrate", "2516000");
4157         opt_default("minrate", "0"); //1145000;
4158         opt_default("bufsize", "1835008"); //224*1024*8;
4159         opt_default("flags", "+scan_offset");
4160
4161
4162         opt_default("ab", "224000");
4163         audio_sample_rate = 44100;
4164
4165         opt_default("packetsize", "2324");
4166
4167     } else if(!strcmp(arg, "dvd")) {
4168
4169         opt_video_codec("vcodec", "mpeg2video");
4170         opt_audio_codec("vcodec", "ac3");
4171         opt_format("f", "dvd");
4172
4173         opt_frame_size("vcodec", norm == PAL ? "720x576" : "720x480");
4174         opt_frame_rate("r", frame_rates[norm]);
4175         opt_default("g", norm == PAL ? "15" : "18");
4176
4177         opt_default("b", "6000000");
4178         opt_default("maxrate", "9000000");
4179         opt_default("minrate", "0"); //1500000;
4180         opt_default("bufsize", "1835008"); //224*1024*8;
4181
4182         opt_default("packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4183         opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4184
4185         opt_default("ab", "448000");
4186         audio_sample_rate = 48000;
4187
4188     } else if(!strncmp(arg, "dv", 2)) {
4189
4190         opt_format("f", "dv");
4191
4192         opt_frame_size("s", norm == PAL ? "720x576" : "720x480");
4193         opt_frame_pix_fmt("pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4194                           norm == PAL ? "yuv420p" : "yuv411p");
4195         opt_frame_rate("r", frame_rates[norm]);
4196
4197         audio_sample_rate = 48000;
4198         audio_channels = 2;
4199
4200     } else {
4201         fprintf(stderr, "Unknown target: %s\n", arg);
4202         return AVERROR(EINVAL);
4203     }
4204     return 0;
4205 }
4206
4207 static int opt_vstats_file(const char *opt, const char *arg)
4208 {
4209     av_free (vstats_filename);
4210     vstats_filename=av_strdup (arg);
4211     return 0;
4212 }
4213
4214 static int opt_vstats(const char *opt, const char *arg)
4215 {
4216     char filename[40];
4217     time_t today2 = time(NULL);
4218     struct tm *today = localtime(&today2);
4219
4220     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4221              today->tm_sec);
4222     return opt_vstats_file(opt, filename);
4223 }
4224
4225 static int opt_bsf(const char *opt, const char *arg)
4226 {
4227     AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4228     AVBitStreamFilterContext **bsfp;
4229
4230     if(!bsfc){
4231         fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4232         ffmpeg_exit(1);
4233     }
4234
4235     bsfp= *opt == 'v' ? &video_bitstream_filters :
4236           *opt == 'a' ? &audio_bitstream_filters :
4237                         &subtitle_bitstream_filters;
4238     while(*bsfp)
4239         bsfp= &(*bsfp)->next;
4240
4241     *bsfp= bsfc;
4242
4243     return 0;
4244 }
4245
4246 static int opt_preset(const char *opt, const char *arg)
4247 {
4248     FILE *f=NULL;
4249     char filename[1000], tmp[1000], tmp2[1000], line[1000];
4250     char *codec_name = *opt == 'v' ? video_codec_name :
4251                        *opt == 'a' ? audio_codec_name :
4252                                      subtitle_codec_name;
4253
4254     if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4255         fprintf(stderr, "File for preset '%s' not found\n", arg);
4256         ffmpeg_exit(1);
4257     }
4258
4259     while(!feof(f)){
4260         int e= fscanf(f, "%999[^\n]\n", line) - 1;
4261         if(line[0] == '#' && !e)
4262             continue;
4263         e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4264         if(e){
4265             fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4266             ffmpeg_exit(1);
4267         }
4268         if(!strcmp(tmp, "acodec")){
4269             opt_audio_codec(tmp, tmp2);
4270         }else if(!strcmp(tmp, "vcodec")){
4271             opt_video_codec(tmp, tmp2);
4272         }else if(!strcmp(tmp, "scodec")){
4273             opt_subtitle_codec(tmp, tmp2);
4274         }else if(!strcmp(tmp, "dcodec")){
4275             opt_data_codec(tmp, tmp2);
4276         }else if(opt_default(tmp, tmp2) < 0){
4277             fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4278             ffmpeg_exit(1);
4279         }
4280     }
4281
4282     fclose(f);
4283
4284     return 0;
4285 }
4286
4287 static const OptionDef options[] = {
4288     /* main options */
4289 #include "cmdutils_common_opts.h"
4290     { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4291     { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4292     { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4293     { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4294     { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
4295       "outfile[,metadata]:infile[,metadata]" },
4296     { "map_metadata", HAS_ARG | OPT_EXPERT, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4297       "outfile[,metadata]:infile[,metadata]" },
4298     { "map_chapters",  HAS_ARG | OPT_EXPERT, {(void*)opt_map_chapters},  "set chapters mapping", "outfile:infile" },
4299     { "t", HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4300     { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4301     { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4302     { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4303     { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
4304     { "timestamp", HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4305     { "metadata", HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4306     { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4307     { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4308       "add timings for benchmarking" },
4309     { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4310     { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4311       "dump each input packet" },
4312     { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4313       "when dumping packets, also dump the payload" },
4314     { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4315     { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
4316     { "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)", "" },
4317     { "v", HAS_ARG, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
4318     { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4319     { "threads",  HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4320     { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4321     { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4322     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4323     { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
4324     { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)&copy_tb}, "copy input stream time base when stream copying" },
4325     { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4326     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4327     { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4328     { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4329     { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)&copy_initial_nonkeyframes}, "copy initial non-keyframes" },
4330
4331     /* video options */
4332     { "b", HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4333     { "vb", HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4334     { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4335     { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4336     { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4337     { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4338     { "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" },
4339     { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4340     { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4341     { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4342     { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4343     { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4344     { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4345     { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4346     { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4347     { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4348     { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4349     { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4350     { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4351     { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4352     { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4353     { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4354     { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "threshold" },
4355     { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4356       "use same quantizer as source (implies VBR)" },
4357     { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4358     { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4359     { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4360       "deinterlace pictures" },
4361     { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4362     { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4363     { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4364 #if CONFIG_AVFILTER
4365     { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4366 #endif
4367     { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4368     { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4369     { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4370     { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4371     { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4372     { "newvideo", OPT_VIDEO, {(void*)opt_new_stream}, "add a new video stream to the current output stream" },
4373     { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4374     { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4375     { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4376     { "streamid", HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4377     { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4378
4379     /* audio options */
4380     { "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4381     { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4382     { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4383     { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4384     { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4385     { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4386     { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4387     { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4388     { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4389     { "newaudio", OPT_AUDIO, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
4390     { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4391     { "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" },
4392
4393     /* subtitle options */
4394     { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4395     { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4396     { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4397     { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4398     { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4399
4400     /* grab options */
4401     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "deprecated, use -channel", "channel" },
4402     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "deprecated, use -standard", "standard" },
4403     { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4404
4405     /* muxer options */
4406     { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4407     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4408
4409     { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4410     { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4411     { "sbsf", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4412
4413     { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4414     { "vpre", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4415     { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4416     { "fpre", HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4417     /* data codec support */
4418     { "dcodec", HAS_ARG | OPT_DATA, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4419
4420     { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4421     { NULL, },
4422 };
4423
4424 int main(int argc, char **argv)
4425 {
4426     int64_t ti;
4427
4428     av_log_set_flags(AV_LOG_SKIP_REPEATED);
4429
4430     avcodec_register_all();
4431 #if CONFIG_AVDEVICE
4432     avdevice_register_all();
4433 #endif
4434 #if CONFIG_AVFILTER
4435     avfilter_register_all();
4436 #endif
4437     av_register_all();
4438
4439     avio_set_interrupt_cb(decode_interrupt_cb);
4440
4441     init_opts();
4442
4443     show_banner();
4444
4445     /* parse options */
4446     parse_options(argc, argv, options, opt_output_file);
4447
4448     if(nb_output_files <= 0 && nb_input_files == 0) {
4449         show_usage();
4450         fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4451         ffmpeg_exit(1);
4452     }
4453
4454     /* file converter / grab */
4455     if (nb_output_files <= 0) {
4456         fprintf(stderr, "At least one output file must be specified\n");
4457         ffmpeg_exit(1);
4458     }
4459
4460     if (nb_input_files == 0) {
4461         fprintf(stderr, "At least one input file must be specified\n");
4462         ffmpeg_exit(1);
4463     }
4464
4465     ti = getutime();
4466     if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4467                   stream_maps, nb_stream_maps) < 0)
4468         ffmpeg_exit(1);
4469     ti = getutime() - ti;
4470     if (do_benchmark) {
4471         int maxrss = getmaxrss() / 1024;
4472         printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4473     }
4474
4475     return ffmpeg_exit(0);
4476 }