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