ffmpeg.c

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