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