ffmpeg.c

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