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