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, *padding_src;
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     padding_src = formatted_picture;
1125     resampling_dst = &ost->pict_tmp;
1126
1127     if (   ost->resample_height != ist->st->codec->height
1128         || ost->resample_width  != ist->st->codec->width
1129         || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1130
1131         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));
1132         if(!ost->video_resample)
1133             ffmpeg_exit(1);
1134     }
1135
1136 #if !CONFIG_AVFILTER
1137     if (ost->video_resample) {
1138         padding_src = NULL;
1139         final_picture = &ost->pict_tmp;
1140         if(  ost->resample_height != ist->st->codec->height
1141           || ost->resample_width  != ist->st->codec->width
1142           || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1143
1144             /* initialize a new scaler context */
1145             sws_freeContext(ost->img_resample_ctx);
1146             ost->img_resample_ctx = sws_getContext(
1147                 ist->st->codec->width,
1148                 ist->st->codec->height,
1149                 ist->st->codec->pix_fmt,
1150                 ost->st->codec->width,
1151                 ost->st->codec->height,
1152                 ost->st->codec->pix_fmt,
1153                 ost->sws_flags, NULL, NULL, NULL);
1154             if (ost->img_resample_ctx == NULL) {
1155                 fprintf(stderr, "Cannot get resampling context\n");
1156                 ffmpeg_exit(1);
1157             }
1158         }
1159         sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1160               0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
1161     }
1162 #endif
1163
1164     /* duplicates frame if needed */
1165     for(i=0;i<nb_frames;i++) {
1166         AVPacket pkt;
1167         av_init_packet(&pkt);
1168         pkt.stream_index= ost->index;
1169
1170         if (s->oformat->flags & AVFMT_RAWPICTURE) {
1171             /* raw pictures are written as AVPicture structure to
1172                avoid any copies. We support temorarily the older
1173                method. */
1174             AVFrame* old_frame = enc->coded_frame;
1175             enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1176             pkt.data= (uint8_t *)final_picture;
1177             pkt.size=  sizeof(AVPicture);
1178             pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1179             pkt.flags |= AV_PKT_FLAG_KEY;
1180
1181             write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1182             enc->coded_frame = old_frame;
1183         } else {
1184             AVFrame big_picture;
1185
1186             big_picture= *final_picture;
1187             /* better than nothing: use input picture interlaced
1188                settings */
1189             big_picture.interlaced_frame = in_picture->interlaced_frame;
1190             if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1191                 if(top_field_first == -1)
1192                     big_picture.top_field_first = in_picture->top_field_first;
1193                 else
1194                     big_picture.top_field_first = top_field_first;
1195             }
1196
1197             /* handles sameq here. This is not correct because it may
1198                not be a global option */
1199             big_picture.quality = same_quality ? ist->st->quality : ost->st->quality;
1200             if(!me_threshold)
1201                 big_picture.pict_type = 0;
1202 //            big_picture.pts = AV_NOPTS_VALUE;
1203             big_picture.pts= ost->sync_opts;
1204 //            big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1205 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1206             if (ost->forced_kf_index < ost->forced_kf_count &&
1207                 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1208                 big_picture.pict_type = AV_PICTURE_TYPE_I;
1209                 ost->forced_kf_index++;
1210             }
1211             ret = avcodec_encode_video(enc,
1212                                        bit_buffer, bit_buffer_size,
1213                                        &big_picture);
1214             if (ret < 0) {
1215                 fprintf(stderr, "Video encoding failed\n");
1216                 ffmpeg_exit(1);
1217             }
1218
1219             if(ret>0){
1220                 pkt.data= bit_buffer;
1221                 pkt.size= ret;
1222                 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1223                     pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1224 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1225    pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1226    pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1227
1228                 if(enc->coded_frame->key_frame)
1229                     pkt.flags |= AV_PKT_FLAG_KEY;
1230                 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1231                 *frame_size = ret;
1232                 video_size += ret;
1233                 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1234                 //        enc->frame_number-1, ret, enc->pict_type);
1235                 /* if two pass, output log */
1236                 if (ost->logfile && enc->stats_out) {
1237                     fprintf(ost->logfile, "%s", enc->stats_out);
1238                 }
1239             }
1240         }
1241         ost->sync_opts++;
1242         ost->frame_number++;
1243     }
1244 }
1245
1246 static double psnr(double d){
1247     return -10.0*log(d)/log(10.0);
1248 }
1249
1250 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1251                            int frame_size)
1252 {
1253     AVCodecContext *enc;
1254     int frame_number;
1255     double ti1, bitrate, avg_bitrate;
1256
1257     /* this is executed just the first time do_video_stats is called */
1258     if (!vstats_file) {
1259         vstats_file = fopen(vstats_filename, "w");
1260         if (!vstats_file) {
1261             perror("fopen");
1262             ffmpeg_exit(1);
1263         }
1264     }
1265
1266     enc = ost->st->codec;
1267     if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1268         frame_number = ost->frame_number;
1269         fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1270         if (enc->flags&CODEC_FLAG_PSNR)
1271             fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1272
1273         fprintf(vstats_file,"f_size= %6d ", frame_size);
1274         /* compute pts value */
1275         ti1 = ost->sync_opts * av_q2d(enc->time_base);
1276         if (ti1 < 0.01)
1277             ti1 = 0.01;
1278
1279         bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1280         avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1281         fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1282             (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1283         fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1284     }
1285 }
1286
1287 static void print_report(AVFormatContext **output_files,
1288                          AVOutputStream **ost_table, int nb_ostreams,
1289                          int is_last_report)
1290 {
1291     char buf[1024];
1292     AVOutputStream *ost;
1293     AVFormatContext *oc;
1294     int64_t total_size;
1295     AVCodecContext *enc;
1296     int frame_number, vid, i;
1297     double bitrate, ti1, pts;
1298     static int64_t last_time = -1;
1299     static int qp_histogram[52];
1300
1301     if (!is_last_report) {
1302         int64_t cur_time;
1303         /* display the report every 0.5 seconds */
1304         cur_time = av_gettime();
1305         if (last_time == -1) {
1306             last_time = cur_time;
1307             return;
1308         }
1309         if ((cur_time - last_time) < 500000)
1310             return;
1311         last_time = cur_time;
1312     }
1313
1314
1315     oc = output_files[0];
1316
1317     total_size = avio_size(oc->pb);
1318     if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1319         total_size= avio_tell(oc->pb);
1320
1321     buf[0] = '\0';
1322     ti1 = 1e10;
1323     vid = 0;
1324     for(i=0;i<nb_ostreams;i++) {
1325         ost = ost_table[i];
1326         enc = ost->st->codec;
1327         if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1328             snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1329                      !ost->st->stream_copy ?
1330                      enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1331         }
1332         if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1333             float t = (av_gettime()-timer_start) / 1000000.0;
1334
1335             frame_number = ost->frame_number;
1336             snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1337                      frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
1338                      !ost->st->stream_copy ?
1339                      enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1340             if(is_last_report)
1341                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1342             if(qp_hist){
1343                 int j;
1344                 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1345                 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1346                     qp_histogram[qp]++;
1347                 for(j=0; j<32; j++)
1348                     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1349             }
1350             if (enc->flags&CODEC_FLAG_PSNR){
1351                 int j;
1352                 double error, error_sum=0;
1353                 double scale, scale_sum=0;
1354                 char type[3]= {'Y','U','V'};
1355                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1356                 for(j=0; j<3; j++){
1357                     if(is_last_report){
1358                         error= enc->error[j];
1359                         scale= enc->width*enc->height*255.0*255.0*frame_number;
1360                     }else{
1361                         error= enc->coded_frame->error[j];
1362                         scale= enc->width*enc->height*255.0*255.0;
1363                     }
1364                     if(j) scale/=4;
1365                     error_sum += error;
1366                     scale_sum += scale;
1367                     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1368                 }
1369                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1370             }
1371             vid = 1;
1372         }
1373         /* compute min output value */
1374         pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1375         if ((pts < ti1) && (pts > 0))
1376             ti1 = pts;
1377     }
1378     if (ti1 < 0.01)
1379         ti1 = 0.01;
1380
1381     if (verbose || is_last_report) {
1382         bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1383
1384         snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1385             "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1386             (double)total_size / 1024, ti1, bitrate);
1387
1388         if (nb_frames_dup || nb_frames_drop)
1389           snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1390                   nb_frames_dup, nb_frames_drop);
1391
1392         if (verbose >= 0)
1393             fprintf(stderr, "%s    \r", buf);
1394
1395         fflush(stderr);
1396     }
1397
1398     if (is_last_report && verbose >= 0){
1399         int64_t raw= audio_size + video_size + extra_size;
1400         fprintf(stderr, "\n");
1401         fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1402                 video_size/1024.0,
1403                 audio_size/1024.0,
1404                 extra_size/1024.0,
1405                 100.0*(total_size - raw)/raw
1406         );
1407     }
1408 }
1409
1410 static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
1411 {
1412     int fill_char = 0x00;
1413     if (sample_fmt == AV_SAMPLE_FMT_U8)
1414         fill_char = 0x80;
1415     memset(buf, fill_char, size);
1416 }
1417
1418 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1419 static int output_packet(AVInputStream *ist, int ist_index,
1420                          AVOutputStream **ost_table, int nb_ostreams,
1421                          const AVPacket *pkt)
1422 {
1423     AVFormatContext *os;
1424     AVOutputStream *ost;
1425     int ret, i;
1426     int got_picture;
1427     AVFrame picture;
1428     void *buffer_to_free;
1429     static unsigned int samples_size= 0;
1430     AVSubtitle subtitle, *subtitle_to_free;
1431     int64_t pkt_pts = AV_NOPTS_VALUE;
1432 #if CONFIG_AVFILTER
1433     int frame_available;
1434 #endif
1435
1436     AVPacket avpkt;
1437     int bps = av_get_bits_per_sample_fmt(ist->st->codec->sample_fmt)>>3;
1438
1439     if(ist->next_pts == AV_NOPTS_VALUE)
1440         ist->next_pts= ist->pts;
1441
1442     if (pkt == NULL) {
1443         /* EOF handling */
1444         av_init_packet(&avpkt);
1445         avpkt.data = NULL;
1446         avpkt.size = 0;
1447         goto handle_eof;
1448     } else {
1449         avpkt = *pkt;
1450     }
1451
1452     if(pkt->dts != AV_NOPTS_VALUE)
1453         ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1454     if(pkt->pts != AV_NOPTS_VALUE)
1455         pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1456
1457     //while we have more to decode or while the decoder did output something on EOF
1458     while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) {
1459         uint8_t *data_buf, *decoded_data_buf;
1460         int data_size, decoded_data_size;
1461     handle_eof:
1462         ist->pts= ist->next_pts;
1463
1464         if(avpkt.size && avpkt.size != pkt->size &&
1465            ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1466             fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1467             ist->showed_multi_packet_warning=1;
1468         }
1469
1470         /* decode the packet if needed */
1471         decoded_data_buf = NULL; /* fail safe */
1472         decoded_data_size= 0;
1473         data_buf  = avpkt.data;
1474         data_size = avpkt.size;
1475         subtitle_to_free = NULL;
1476         if (ist->decoding_needed) {
1477             switch(ist->st->codec->codec_type) {
1478             case AVMEDIA_TYPE_AUDIO:{
1479                 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1480                     samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1481                     av_free(samples);
1482                     samples= av_malloc(samples_size);
1483                 }
1484                 decoded_data_size= samples_size;
1485                     /* XXX: could avoid copy if PCM 16 bits with same
1486                        endianness as CPU */
1487                 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1488                                             &avpkt);
1489                 if (ret < 0)
1490                     goto fail_decode;
1491                 avpkt.data += ret;
1492                 avpkt.size -= ret;
1493                 data_size   = ret;
1494                 /* Some bug in mpeg audio decoder gives */
1495                 /* decoded_data_size < 0, it seems they are overflows */
1496                 if (decoded_data_size <= 0) {
1497                     /* no audio frame */
1498                     continue;
1499                 }
1500                 decoded_data_buf = (uint8_t *)samples;
1501                 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1502                     (ist->st->codec->sample_rate * ist->st->codec->channels);
1503                 break;}
1504             case AVMEDIA_TYPE_VIDEO:
1505                     decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1506                     /* XXX: allocate picture correctly */
1507                     avcodec_get_frame_defaults(&picture);
1508                     avpkt.pts = pkt_pts;
1509                     avpkt.dts = ist->pts;
1510                     pkt_pts = AV_NOPTS_VALUE;
1511
1512                     ret = avcodec_decode_video2(ist->st->codec,
1513                                                 &picture, &got_picture, &avpkt);
1514                     ist->st->quality= picture.quality;
1515                     if (ret < 0)
1516                         goto fail_decode;
1517                     if (!got_picture) {
1518                         /* no picture yet */
1519                         goto discard_packet;
1520                     }
1521                     ist->next_pts = ist->pts = guess_correct_pts(&ist->pts_ctx, picture.pkt_pts, picture.pkt_dts);
1522                     if (ist->st->codec->time_base.num != 0) {
1523                         int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1524                         ist->next_pts += ((int64_t)AV_TIME_BASE *
1525                                           ist->st->codec->time_base.num * ticks) /
1526                             ist->st->codec->time_base.den;
1527                     }
1528                     avpkt.size = 0;
1529                     break;
1530             case AVMEDIA_TYPE_SUBTITLE:
1531                 ret = avcodec_decode_subtitle2(ist->st->codec,
1532                                                &subtitle, &got_picture, &avpkt);
1533                 if (ret < 0)
1534                     goto fail_decode;
1535                 if (!got_picture) {
1536                     goto discard_packet;
1537                 }
1538                 subtitle_to_free = &subtitle;
1539                 avpkt.size = 0;
1540                 break;
1541             default:
1542                 goto fail_decode;
1543             }
1544         } else {
1545             switch(ist->st->codec->codec_type) {
1546             case AVMEDIA_TYPE_AUDIO:
1547                 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1548                     ist->st->codec->sample_rate;
1549                 break;
1550             case AVMEDIA_TYPE_VIDEO:
1551                 if (ist->st->codec->time_base.num != 0) {
1552                     int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1553                     ist->next_pts += ((int64_t)AV_TIME_BASE *
1554                                       ist->st->codec->time_base.num * ticks) /
1555                         ist->st->codec->time_base.den;
1556                 }
1557                 break;
1558             }
1559             ret = avpkt.size;
1560             avpkt.size = 0;
1561         }
1562
1563         buffer_to_free = NULL;
1564         if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1565             pre_process_video_frame(ist, (AVPicture *)&picture,
1566                                     &buffer_to_free);
1567         }
1568
1569 #if CONFIG_AVFILTER
1570         if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->input_video_filter) {
1571             AVRational sar;
1572             if (ist->st->sample_aspect_ratio.num) sar = ist->st->sample_aspect_ratio;
1573             else                                  sar = ist->st->codec->sample_aspect_ratio;
1574             // add it to be filtered
1575             av_vsrc_buffer_add_frame(ist->input_video_filter, &picture,
1576                                      ist->pts,
1577                                      sar);
1578         }
1579 #endif
1580
1581         // preprocess audio (volume)
1582         if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1583             if (audio_volume != 256) {
1584                 short *volp;
1585                 volp = samples;
1586                 for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1587                     int v = ((*volp) * audio_volume + 128) >> 8;
1588                     if (v < -32768) v = -32768;
1589                     if (v >  32767) v = 32767;
1590                     *volp++ = v;
1591                 }
1592             }
1593         }
1594
1595         /* frame rate emulation */
1596         if (rate_emu) {
1597             int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1598             int64_t now = av_gettime() - ist->start;
1599             if (pts > now)
1600                 usleep(pts - now);
1601         }
1602 #if CONFIG_AVFILTER
1603         frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1604             !ist->output_video_filter || avfilter_poll_frame(ist->output_video_filter->inputs[0]);
1605 #endif
1606         /* if output time reached then transcode raw format,
1607            encode packets and output them */
1608         if (start_time == 0 || ist->pts >= start_time)
1609 #if CONFIG_AVFILTER
1610         while (frame_available) {
1611             AVRational ist_pts_tb;
1612             if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->output_video_filter)
1613                 get_filtered_video_frame(ist->output_video_filter, &picture, &ist->picref, &ist_pts_tb);
1614             if (ist->picref)
1615                 ist->pts = av_rescale_q(ist->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1616 #endif
1617             for(i=0;i<nb_ostreams;i++) {
1618                 int frame_size;
1619
1620                 ost = ost_table[i];
1621                 if (ost->source_index == ist_index) {
1622                     os = output_files[ost->file_index];
1623
1624                     /* set the input output pts pairs */
1625                     //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1626
1627                     if (ost->encoding_needed) {
1628                         av_assert0(ist->decoding_needed);
1629                         switch(ost->st->codec->codec_type) {
1630                         case AVMEDIA_TYPE_AUDIO:
1631                             do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1632                             break;
1633                         case AVMEDIA_TYPE_VIDEO:
1634 #if CONFIG_AVFILTER
1635                             if (ist->picref->video)
1636                                 ost->st->codec->sample_aspect_ratio = ist->picref->video->pixel_aspect;
1637 #endif
1638                             do_video_out(os, ost, ist, &picture, &frame_size);
1639                             if (vstats_filename && frame_size)
1640                                 do_video_stats(os, ost, frame_size);
1641                             break;
1642                         case AVMEDIA_TYPE_SUBTITLE:
1643                             do_subtitle_out(os, ost, ist, &subtitle,
1644                                             pkt->pts);
1645                             break;
1646                         default:
1647                             abort();
1648                         }
1649                     } else {
1650                         AVFrame avframe; //FIXME/XXX remove this
1651                         AVPacket opkt;
1652                         int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1653
1654                         av_init_packet(&opkt);
1655
1656                         if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1657                             continue;
1658
1659                         /* no reencoding needed : output the packet directly */
1660                         /* force the input stream PTS */
1661
1662                         avcodec_get_frame_defaults(&avframe);
1663                         ost->st->codec->coded_frame= &avframe;
1664                         avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1665
1666                         if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1667                             audio_size += data_size;
1668                         else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1669                             video_size += data_size;
1670                             ost->sync_opts++;
1671                         }
1672
1673                         opkt.stream_index= ost->index;
1674                         if(pkt->pts != AV_NOPTS_VALUE)
1675                             opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1676                         else
1677                             opkt.pts= AV_NOPTS_VALUE;
1678
1679                         if (pkt->dts == AV_NOPTS_VALUE)
1680                             opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1681                         else
1682                             opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1683                         opkt.dts -= ost_tb_start_time;
1684
1685                         opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1686                         opkt.flags= pkt->flags;
1687
1688                         //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1689                         if(   ost->st->codec->codec_id != CODEC_ID_H264
1690                            && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1691                            && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1692                            ) {
1693                             if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1694                                 opkt.destruct= av_destruct_packet;
1695                         } else {
1696                             opkt.data = data_buf;
1697                             opkt.size = data_size;
1698                         }
1699
1700                         write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1701                         ost->st->codec->frame_number++;
1702                         ost->frame_number++;
1703                         av_free_packet(&opkt);
1704                     }
1705                 }
1706             }
1707
1708 #if CONFIG_AVFILTER
1709             frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1710                               ist->output_video_filter && avfilter_poll_frame(ist->output_video_filter->inputs[0]);
1711             if(ist->picref)
1712                 avfilter_unref_buffer(ist->picref);
1713         }
1714 #endif
1715         av_free(buffer_to_free);
1716         /* XXX: allocate the subtitles in the codec ? */
1717         if (subtitle_to_free) {
1718             avsubtitle_free(subtitle_to_free);
1719             subtitle_to_free = NULL;
1720         }
1721     }
1722  discard_packet:
1723     if (pkt == NULL) {
1724         /* EOF handling */
1725
1726         for(i=0;i<nb_ostreams;i++) {
1727             ost = ost_table[i];
1728             if (ost->source_index == ist_index) {
1729                 AVCodecContext *enc= ost->st->codec;
1730                 os = output_files[ost->file_index];
1731
1732                 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1733                     continue;
1734                 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1735                     continue;
1736
1737                 if (ost->encoding_needed) {
1738                     for(;;) {
1739                         AVPacket pkt;
1740                         int fifo_bytes;
1741                         av_init_packet(&pkt);
1742                         pkt.stream_index= ost->index;
1743
1744                         switch(ost->st->codec->codec_type) {
1745                         case AVMEDIA_TYPE_AUDIO:
1746                             fifo_bytes = av_fifo_size(ost->fifo);
1747                             ret = 0;
1748                             /* encode any samples remaining in fifo */
1749                             if (fifo_bytes > 0) {
1750                                 int osize = av_get_bits_per_sample_fmt(enc->sample_fmt) >> 3;
1751                                 int fs_tmp = enc->frame_size;
1752
1753                                 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1754                                 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1755                                     enc->frame_size = fifo_bytes / (osize * enc->channels);
1756                                 } else { /* pad */
1757                                     int frame_bytes = enc->frame_size*osize*enc->channels;
1758                                     if (allocated_audio_buf_size < frame_bytes)
1759                                         ffmpeg_exit(1);
1760                                     generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1761                                 }
1762
1763                                 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1764                                 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1765                                                           ost->st->time_base.num, enc->sample_rate);
1766                                 enc->frame_size = fs_tmp;
1767                             }
1768                             if(ret <= 0) {
1769                                 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1770                             }
1771                             if (ret < 0) {
1772                                 fprintf(stderr, "Audio encoding failed\n");
1773                                 ffmpeg_exit(1);
1774                             }
1775                             audio_size += ret;
1776                             pkt.flags |= AV_PKT_FLAG_KEY;
1777                             break;
1778                         case AVMEDIA_TYPE_VIDEO:
1779                             ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1780                             if (ret < 0) {
1781                                 fprintf(stderr, "Video encoding failed\n");
1782                                 ffmpeg_exit(1);
1783                             }
1784                             video_size += ret;
1785                             if(enc->coded_frame && enc->coded_frame->key_frame)
1786                                 pkt.flags |= AV_PKT_FLAG_KEY;
1787                             if (ost->logfile && enc->stats_out) {
1788                                 fprintf(ost->logfile, "%s", enc->stats_out);
1789                             }
1790                             break;
1791                         default:
1792                             ret=-1;
1793                         }
1794
1795                         if(ret<=0)
1796                             break;
1797                         pkt.data= bit_buffer;
1798                         pkt.size= ret;
1799                         if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1800                             pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1801                         write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1802                     }
1803                 }
1804             }
1805         }
1806     }
1807
1808     return 0;
1809  fail_decode:
1810     return -1;
1811 }
1812
1813 static void print_sdp(AVFormatContext **avc, int n)
1814 {
1815     char sdp[2048];
1816
1817     av_sdp_create(avc, n, sdp, sizeof(sdp));
1818     printf("SDP:\n%s\n", sdp);
1819     fflush(stdout);
1820 }
1821
1822 static int copy_chapters(int infile, int outfile)
1823 {
1824     AVFormatContext *is = input_files[infile];
1825     AVFormatContext *os = output_files[outfile];
1826     int i;
1827
1828     for (i = 0; i < is->nb_chapters; i++) {
1829         AVChapter *in_ch = is->chapters[i], *out_ch;
1830         int64_t ts_off   = av_rescale_q(start_time - input_files_ts_offset[infile],
1831                                       AV_TIME_BASE_Q, in_ch->time_base);
1832         int64_t rt       = (recording_time == INT64_MAX) ? INT64_MAX :
1833                            av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1834
1835
1836         if (in_ch->end < ts_off)
1837             continue;
1838         if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1839             break;
1840
1841         out_ch = av_mallocz(sizeof(AVChapter));
1842         if (!out_ch)
1843             return AVERROR(ENOMEM);
1844
1845         out_ch->id        = in_ch->id;
1846         out_ch->time_base = in_ch->time_base;
1847         out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1848         out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1849
1850         if (metadata_chapters_autocopy)
1851             av_metadata_copy(&out_ch->metadata, in_ch->metadata, 0);
1852
1853         os->nb_chapters++;
1854         os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1855         if (!os->chapters)
1856             return AVERROR(ENOMEM);
1857         os->chapters[os->nb_chapters - 1] = out_ch;
1858     }
1859     return 0;
1860 }
1861
1862 static void parse_forced_key_frames(char *kf, AVOutputStream *ost,
1863                                     AVCodecContext *avctx)
1864 {
1865     char *p;
1866     int n = 1, i;
1867     int64_t t;
1868
1869     for (p = kf; *p; p++)
1870         if (*p == ',')
1871             n++;
1872     ost->forced_kf_count = n;
1873     ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
1874     if (!ost->forced_kf_pts) {
1875         av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
1876         ffmpeg_exit(1);
1877     }
1878     for (i = 0; i < n; i++) {
1879         p = i ? strchr(p, ',') + 1 : kf;
1880         t = parse_time_or_die("force_key_frames", p, 1);
1881         ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
1882     }
1883 }
1884
1885 /*
1886  * The following code is the main loop of the file converter
1887  */
1888 static int transcode(AVFormatContext **output_files,
1889                      int nb_output_files,
1890                      AVFormatContext **input_files,
1891                      int nb_input_files,
1892                      AVStreamMap *stream_maps, int nb_stream_maps)
1893 {
1894     int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1895     AVFormatContext *is, *os;
1896     AVCodecContext *codec, *icodec;
1897     AVOutputStream *ost, **ost_table = NULL;
1898     AVInputStream *ist, **ist_table = NULL;
1899     AVInputFile *file_table;
1900     char error[1024];
1901     int key;
1902     int want_sdp = 1;
1903     uint8_t no_packet[MAX_FILES]={0};
1904     int no_packet_count=0;
1905
1906     file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1907     if (!file_table)
1908         goto fail;
1909
1910     /* input stream init */
1911     j = 0;
1912     for(i=0;i<nb_input_files;i++) {
1913         is = input_files[i];
1914         file_table[i].ist_index = j;
1915         file_table[i].nb_streams = is->nb_streams;
1916         j += is->nb_streams;
1917     }
1918     nb_istreams = j;
1919
1920     ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1921     if (!ist_table)
1922         goto fail;
1923
1924     for(i=0;i<nb_istreams;i++) {
1925         ist = av_mallocz(sizeof(AVInputStream));
1926         if (!ist)
1927             goto fail;
1928         ist_table[i] = ist;
1929     }
1930     j = 0;
1931     for(i=0;i<nb_input_files;i++) {
1932         is = input_files[i];
1933         for(k=0;k<is->nb_streams;k++) {
1934             ist = ist_table[j++];
1935             ist->st = is->streams[k];
1936             ist->file_index = i;
1937             ist->index = k;
1938             ist->discard = 1; /* the stream is discarded by default
1939                                  (changed later) */
1940
1941             if (rate_emu) {
1942                 ist->start = av_gettime();
1943             }
1944         }
1945     }
1946
1947     /* output stream init */
1948     nb_ostreams = 0;
1949     for(i=0;i<nb_output_files;i++) {
1950         os = output_files[i];
1951         if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
1952             av_dump_format(output_files[i], i, output_files[i]->filename, 1);
1953             fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1954             ret = AVERROR(EINVAL);
1955             goto fail;
1956         }
1957         nb_ostreams += os->nb_streams;
1958     }
1959     if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1960         fprintf(stderr, "Number of stream maps must match number of output streams\n");
1961         ret = AVERROR(EINVAL);
1962         goto fail;
1963     }
1964
1965     /* Sanity check the mapping args -- do the input files & streams exist? */
1966     for(i=0;i<nb_stream_maps;i++) {
1967         int fi = stream_maps[i].file_index;
1968         int si = stream_maps[i].stream_index;
1969
1970         if (fi < 0 || fi > nb_input_files - 1 ||
1971             si < 0 || si > file_table[fi].nb_streams - 1) {
1972             fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1973             ret = AVERROR(EINVAL);
1974             goto fail;
1975         }
1976         fi = stream_maps[i].sync_file_index;
1977         si = stream_maps[i].sync_stream_index;
1978         if (fi < 0 || fi > nb_input_files - 1 ||
1979             si < 0 || si > file_table[fi].nb_streams - 1) {
1980             fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1981             ret = AVERROR(EINVAL);
1982             goto fail;
1983         }
1984     }
1985
1986     ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1987     if (!ost_table)
1988         goto fail;
1989     n = 0;
1990     for(k=0;k<nb_output_files;k++) {
1991         os = output_files[k];
1992         for(i=0;i<os->nb_streams;i++,n++) {
1993             int found;
1994             ost = ost_table[n] = output_streams_for_file[k][i];
1995             ost->st = os->streams[i];
1996             if (nb_stream_maps > 0) {
1997                 ost->source_index = file_table[stream_maps[n].file_index].ist_index +
1998                     stream_maps[n].stream_index;
1999
2000                 /* Sanity check that the stream types match */
2001                 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
2002                     int i= ost->file_index;
2003                     av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2004                     fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
2005                         stream_maps[n].file_index, stream_maps[n].stream_index,
2006                         ost->file_index, ost->index);
2007                     ffmpeg_exit(1);
2008                 }
2009
2010             } else {
2011                 int best_nb_frames=-1;
2012                 /* get corresponding input stream index : we select the first one with the right type */
2013                 found = 0;
2014                 for(j=0;j<nb_istreams;j++) {
2015                     int skip=0;
2016                     ist = ist_table[j];
2017                     if(opt_programid){
2018                         int pi,si;
2019                         AVFormatContext *f= input_files[ ist->file_index ];
2020                         skip=1;
2021                         for(pi=0; pi<f->nb_programs; pi++){
2022                             AVProgram *p= f->programs[pi];
2023                             if(p->id == opt_programid)
2024                                 for(si=0; si<p->nb_stream_indexes; si++){
2025                                     if(f->streams[ p->stream_index[si] ] == ist->st)
2026                                         skip=0;
2027                                 }
2028                         }
2029                     }
2030                     if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
2031                         ist->st->codec->codec_type == ost->st->codec->codec_type) {
2032                         if(best_nb_frames < ist->st->codec_info_nb_frames){
2033                             best_nb_frames= ist->st->codec_info_nb_frames;
2034                             ost->source_index = j;
2035                             found = 1;
2036                         }
2037                     }
2038                 }
2039
2040                 if (!found) {
2041                     if(! opt_programid) {
2042                         /* try again and reuse existing stream */
2043                         for(j=0;j<nb_istreams;j++) {
2044                             ist = ist_table[j];
2045                             if (   ist->st->codec->codec_type == ost->st->codec->codec_type
2046                                 && ist->st->discard != AVDISCARD_ALL) {
2047                                 ost->source_index = j;
2048                                 found = 1;
2049                             }
2050                         }
2051                     }
2052                     if (!found) {
2053                         int i= ost->file_index;
2054                         av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2055                         fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
2056                                 ost->file_index, ost->index);
2057                         ffmpeg_exit(1);
2058                     }
2059                 }
2060             }
2061             ist = ist_table[ost->source_index];
2062             ist->discard = 0;
2063             ost->sync_ist = (nb_stream_maps > 0) ?
2064                 ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
2065                          stream_maps[n].sync_stream_index] : ist;
2066         }
2067     }
2068
2069     /* for each output stream, we compute the right encoding parameters */
2070     for(i=0;i<nb_ostreams;i++) {
2071         ost = ost_table[i];
2072         os = output_files[ost->file_index];
2073         ist = ist_table[ost->source_index];
2074
2075         codec = ost->st->codec;
2076         icodec = ist->st->codec;
2077
2078         if (metadata_streams_autocopy)
2079             av_metadata_copy(&ost->st->metadata, ist->st->metadata,
2080                              AV_METADATA_DONT_OVERWRITE);
2081
2082         ost->st->disposition = ist->st->disposition;
2083         codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2084         codec->chroma_sample_location = icodec->chroma_sample_location;
2085
2086         if (ost->st->stream_copy) {
2087             uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2088
2089             if (extra_size > INT_MAX)
2090                 goto fail;
2091
2092             /* if stream_copy is selected, no need to decode or encode */
2093             codec->codec_id = icodec->codec_id;
2094             codec->codec_type = icodec->codec_type;
2095
2096             if(!codec->codec_tag){
2097                 if(   !os->oformat->codec_tag
2098                    || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2099                    || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2100                     codec->codec_tag = icodec->codec_tag;
2101             }
2102
2103             codec->bit_rate = icodec->bit_rate;
2104             codec->rc_max_rate    = icodec->rc_max_rate;
2105             codec->rc_buffer_size = icodec->rc_buffer_size;
2106             codec->extradata= av_mallocz(extra_size);
2107             if (!codec->extradata)
2108                 goto fail;
2109             memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2110             codec->extradata_size= icodec->extradata_size;
2111             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){
2112                 codec->time_base = icodec->time_base;
2113                 codec->time_base.num *= icodec->ticks_per_frame;
2114                 av_reduce(&codec->time_base.num, &codec->time_base.den,
2115                           codec->time_base.num, codec->time_base.den, INT_MAX);
2116             }else
2117                 codec->time_base = ist->st->time_base;
2118             switch(codec->codec_type) {
2119             case AVMEDIA_TYPE_AUDIO:
2120                 if(audio_volume != 256) {
2121                     fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2122                     ffmpeg_exit(1);
2123                 }
2124                 codec->channel_layout = icodec->channel_layout;
2125                 codec->sample_rate = icodec->sample_rate;
2126                 codec->channels = icodec->channels;
2127                 codec->frame_size = icodec->frame_size;
2128                 codec->audio_service_type = icodec->audio_service_type;
2129                 codec->block_align= icodec->block_align;
2130                 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2131                     codec->block_align= 0;
2132                 if(codec->codec_id == CODEC_ID_AC3)
2133                     codec->block_align= 0;
2134                 break;
2135             case AVMEDIA_TYPE_VIDEO:
2136                 codec->pix_fmt = icodec->pix_fmt;
2137                 codec->width = icodec->width;
2138                 codec->height = icodec->height;
2139                 codec->has_b_frames = icodec->has_b_frames;
2140                 break;
2141             case AVMEDIA_TYPE_SUBTITLE:
2142                 codec->width = icodec->width;
2143                 codec->height = icodec->height;
2144                 break;
2145             case AVMEDIA_TYPE_DATA:
2146                 break;
2147             default:
2148                 abort();
2149             }
2150         } else {
2151             switch(codec->codec_type) {
2152             case AVMEDIA_TYPE_AUDIO:
2153                 ost->fifo= av_fifo_alloc(1024);
2154                 if(!ost->fifo)
2155                     goto fail;
2156                 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2157                 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2158                 icodec->request_channels = codec->channels;
2159                 ist->decoding_needed = 1;
2160                 ost->encoding_needed = 1;
2161                 ost->resample_sample_fmt  = icodec->sample_fmt;
2162                 ost->resample_sample_rate = icodec->sample_rate;
2163                 ost->resample_channels    = icodec->channels;
2164                 break;
2165             case AVMEDIA_TYPE_VIDEO:
2166                 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2167                     fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2168                     ffmpeg_exit(1);
2169                 }
2170                 ost->video_resample = (codec->width != icodec->width   ||
2171                                        codec->height != icodec->height ||
2172                         (codec->pix_fmt != icodec->pix_fmt));
2173                 if (ost->video_resample) {
2174 #if !CONFIG_AVFILTER
2175                     avcodec_get_frame_defaults(&ost->pict_tmp);
2176                     if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2177                                          codec->width, codec->height)) {
2178                         fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
2179                         ffmpeg_exit(1);
2180                     }
2181                     ost->img_resample_ctx = sws_getContext(
2182                         icodec->width,
2183                         icodec->height,
2184                             icodec->pix_fmt,
2185                             codec->width,
2186                             codec->height,
2187                             codec->pix_fmt,
2188                             ost->sws_flags, NULL, NULL, NULL);
2189                     if (ost->img_resample_ctx == NULL) {
2190                         fprintf(stderr, "Cannot get resampling context\n");
2191                         ffmpeg_exit(1);
2192                     }
2193
2194                     ost->original_height = icodec->height;
2195                     ost->original_width  = icodec->width;
2196 #endif
2197                     codec->bits_per_raw_sample= 0;
2198                 }
2199                 ost->resample_height = icodec->height;
2200                 ost->resample_width  = icodec->width;
2201                 ost->resample_pix_fmt= icodec->pix_fmt;
2202                 ost->encoding_needed = 1;
2203                 ist->decoding_needed = 1;
2204
2205 #if CONFIG_AVFILTER
2206                 if (configure_video_filters(ist, ost)) {
2207                     fprintf(stderr, "Error opening filters!\n");
2208                     exit(1);
2209                 }
2210 #endif
2211                 break;
2212             case AVMEDIA_TYPE_SUBTITLE:
2213                 ost->encoding_needed = 1;
2214                 ist->decoding_needed = 1;
2215                 break;
2216             default:
2217                 abort();
2218                 break;
2219             }
2220             /* two pass mode */
2221             if (ost->encoding_needed &&
2222                 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2223                 char logfilename[1024];
2224                 FILE *f;
2225
2226                 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2227                          pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2228                          i);
2229                 if (codec->flags & CODEC_FLAG_PASS1) {
2230                     f = fopen(logfilename, "wb");
2231                     if (!f) {
2232                         fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2233                         ffmpeg_exit(1);
2234                     }
2235                     ost->logfile = f;
2236                 } else {
2237                     char  *logbuffer;
2238                     size_t logbuffer_size;
2239                     if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2240                         fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2241                         ffmpeg_exit(1);
2242                     }
2243                     codec->stats_in = logbuffer;
2244                 }
2245             }
2246         }
2247         if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2248             int size= codec->width * codec->height;
2249             bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2250         }
2251     }
2252
2253     if (!bit_buffer)
2254         bit_buffer = av_malloc(bit_buffer_size);
2255     if (!bit_buffer) {
2256         fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2257                 bit_buffer_size);
2258         ret = AVERROR(ENOMEM);
2259         goto fail;
2260     }
2261
2262     /* open each encoder */
2263     for(i=0;i<nb_ostreams;i++) {
2264         ost = ost_table[i];
2265         if (ost->encoding_needed) {
2266             AVCodec *codec = i < nb_output_codecs ? output_codecs[i] : NULL;
2267             AVCodecContext *dec = ist_table[ost->source_index]->st->codec;
2268             if (!codec)
2269                 codec = avcodec_find_encoder(ost->st->codec->codec_id);
2270             if (!codec) {
2271                 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2272                          ost->st->codec->codec_id, ost->file_index, ost->index);
2273                 ret = AVERROR(EINVAL);
2274                 goto dump_format;
2275             }
2276             if (dec->subtitle_header) {
2277                 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2278                 if (!ost->st->codec->subtitle_header) {
2279                     ret = AVERROR(ENOMEM);
2280                     goto dump_format;
2281                 }
2282                 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2283                 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2284             }
2285             if (avcodec_open(ost->st->codec, codec) < 0) {
2286                 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2287                         ost->file_index, ost->index);
2288                 ret = AVERROR(EINVAL);
2289                 goto dump_format;
2290             }
2291             extra_size += ost->st->codec->extradata_size;
2292         }
2293     }
2294
2295     /* open each decoder */
2296     for(i=0;i<nb_istreams;i++) {
2297         ist = ist_table[i];
2298         if (ist->decoding_needed) {
2299             AVCodec *codec = i < nb_input_codecs ? input_codecs[i] : NULL;
2300             if (!codec)
2301                 codec = avcodec_find_decoder(ist->st->codec->codec_id);
2302             if (!codec) {
2303                 snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2304                         ist->st->codec->codec_id, ist->file_index, ist->index);
2305                 ret = AVERROR(EINVAL);
2306                 goto dump_format;
2307             }
2308             if (avcodec_open(ist->st->codec, codec) < 0) {
2309                 snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2310                         ist->file_index, ist->index);
2311                 ret = AVERROR(EINVAL);
2312                 goto dump_format;
2313             }
2314             //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2315             //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2316         }
2317     }
2318
2319     /* init pts */
2320     for(i=0;i<nb_istreams;i++) {
2321         AVStream *st;
2322         ist = ist_table[i];
2323         st= ist->st;
2324         ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2325         ist->next_pts = AV_NOPTS_VALUE;
2326         init_pts_correction(&ist->pts_ctx);
2327         ist->is_start = 1;
2328     }
2329
2330     /* set meta data information from input file if required */
2331     for (i=0;i<nb_meta_data_maps;i++) {
2332         AVFormatContext *files[2];
2333         AVMetadata      **meta[2];
2334         int j;
2335
2336 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
2337         if ((index) < 0 || (index) >= (nb_elems)) {\
2338             snprintf(error, sizeof(error), "Invalid %s index %d while processing metadata maps\n",\
2339                      (desc), (index));\
2340             ret = AVERROR(EINVAL);\
2341             goto dump_format;\
2342         }
2343
2344         int out_file_index = meta_data_maps[i][0].file;
2345         int in_file_index = meta_data_maps[i][1].file;
2346         if (in_file_index < 0 || out_file_index < 0)
2347             continue;
2348         METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2349         METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2350
2351         files[0] = output_files[out_file_index];
2352         files[1] = input_files[in_file_index];
2353
2354         for (j = 0; j < 2; j++) {
2355             AVMetaDataMap *map = &meta_data_maps[i][j];
2356
2357             switch (map->type) {
2358             case 'g':
2359                 meta[j] = &files[j]->metadata;
2360                 break;
2361             case 's':
2362                 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
2363                 meta[j] = &files[j]->streams[map->index]->metadata;
2364                 break;
2365             case 'c':
2366                 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
2367                 meta[j] = &files[j]->chapters[map->index]->metadata;
2368                 break;
2369             case 'p':
2370                 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
2371                 meta[j] = &files[j]->programs[map->index]->metadata;
2372                 break;
2373             }
2374         }
2375
2376         av_metadata_copy(meta[0], *meta[1], AV_METADATA_DONT_OVERWRITE);
2377     }
2378
2379     /* copy global metadata by default */
2380     if (metadata_global_autocopy) {
2381
2382         for (i = 0; i < nb_output_files; i++)
2383             av_metadata_copy(&output_files[i]->metadata, input_files[0]->metadata,
2384                              AV_METADATA_DONT_OVERWRITE);
2385     }
2386
2387     /* copy chapters according to chapter maps */
2388     for (i = 0; i < nb_chapter_maps; i++) {
2389         int infile  = chapter_maps[i].in_file;
2390         int outfile = chapter_maps[i].out_file;
2391
2392         if (infile < 0 || outfile < 0)
2393             continue;
2394         if (infile >= nb_input_files) {
2395             snprintf(error, sizeof(error), "Invalid input file index %d in chapter mapping.\n", infile);
2396             ret = AVERROR(EINVAL);
2397             goto dump_format;
2398         }
2399         if (outfile >= nb_output_files) {
2400             snprintf(error, sizeof(error), "Invalid output file index %d in chapter mapping.\n",outfile);
2401             ret = AVERROR(EINVAL);
2402             goto dump_format;
2403         }
2404         copy_chapters(infile, outfile);
2405     }
2406
2407     /* copy chapters from the first input file that has them*/
2408     if (!nb_chapter_maps)
2409         for (i = 0; i < nb_input_files; i++) {
2410             if (!input_files[i]->nb_chapters)
2411                 continue;
2412
2413             for (j = 0; j < nb_output_files; j++)
2414                 if ((ret = copy_chapters(i, j)) < 0)
2415                     goto dump_format;
2416             break;
2417         }
2418
2419     /* open files and write file headers */
2420     for(i=0;i<nb_output_files;i++) {
2421         os = output_files[i];
2422         if (av_write_header(os) < 0) {
2423             snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2424             ret = AVERROR(EINVAL);
2425             goto dump_format;
2426         }
2427         if (strcmp(output_files[i]->oformat->name, "rtp")) {
2428             want_sdp = 0;
2429         }
2430     }
2431
2432  dump_format:
2433     /* dump the file output parameters - cannot be done before in case
2434        of stream copy */
2435     for(i=0;i<nb_output_files;i++) {
2436         av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2437     }
2438
2439     /* dump the stream mapping */
2440     if (verbose >= 0) {
2441         fprintf(stderr, "Stream mapping:\n");
2442         for(i=0;i<nb_ostreams;i++) {
2443             ost = ost_table[i];
2444             fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
2445                     ist_table[ost->source_index]->file_index,
2446                     ist_table[ost->source_index]->index,
2447                     ost->file_index,
2448                     ost->index);
2449             if (ost->sync_ist != ist_table[ost->source_index])
2450                 fprintf(stderr, " [sync #%d.%d]",
2451                         ost->sync_ist->file_index,
2452                         ost->sync_ist->index);
2453             fprintf(stderr, "\n");
2454         }
2455     }
2456
2457     if (ret) {
2458         fprintf(stderr, "%s\n", error);
2459         goto fail;
2460     }
2461
2462     if (want_sdp) {
2463         print_sdp(output_files, nb_output_files);
2464     }
2465
2466     if (!using_stdin && verbose >= 0) {
2467 #if HAVE_KBHIT
2468         fprintf(stderr, "Press [q] to stop encoding\n");
2469 #else
2470         fprintf(stderr, "Press ctrl-c to stop encoding\n");
2471 #endif
2472         avio_set_interrupt_cb(decode_interrupt_cb);
2473     }
2474     term_init();
2475
2476     timer_start = av_gettime();
2477
2478     for(; received_sigterm == 0;) {
2479         int file_index, ist_index;
2480         AVPacket pkt;
2481         double ipts_min;
2482         double opts_min;
2483
2484     redo:
2485         ipts_min= 1e100;
2486         opts_min= 1e100;
2487         /* if 'q' pressed, exits */
2488         if (!using_stdin) {
2489             if (q_pressed)
2490                 break;
2491             /* read_key() returns 0 on EOF */
2492             key = read_key();
2493             if (key == 'q')
2494                 break;
2495         }
2496
2497         /* select the stream that we must read now by looking at the
2498            smallest output pts */
2499         file_index = -1;
2500         for(i=0;i<nb_ostreams;i++) {
2501             double ipts, opts;
2502             ost = ost_table[i];
2503             os = output_files[ost->file_index];
2504             ist = ist_table[ost->source_index];
2505             if(ist->is_past_recording_time || no_packet[ist->file_index])
2506                 continue;
2507                 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2508             ipts = (double)ist->pts;
2509             if (!file_table[ist->file_index].eof_reached){
2510                 if(ipts < ipts_min) {
2511                     ipts_min = ipts;
2512                     if(input_sync ) file_index = ist->file_index;
2513                 }
2514                 if(opts < opts_min) {
2515                     opts_min = opts;
2516                     if(!input_sync) file_index = ist->file_index;
2517                 }
2518             }
2519             if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2520                 file_index= -1;
2521                 break;
2522             }
2523         }
2524         /* if none, if is finished */
2525         if (file_index < 0) {
2526             if(no_packet_count){
2527                 no_packet_count=0;
2528                 memset(no_packet, 0, sizeof(no_packet));
2529                 usleep(10000);
2530                 continue;
2531             }
2532             break;
2533         }
2534
2535         /* finish if limit size exhausted */
2536         if (limit_filesize != 0 && limit_filesize <= avio_tell(output_files[0]->pb))
2537             break;
2538
2539         /* read a frame from it and output it in the fifo */
2540         is = input_files[file_index];
2541         ret= av_read_frame(is, &pkt);
2542         if(ret == AVERROR(EAGAIN)){
2543             no_packet[file_index]=1;
2544             no_packet_count++;
2545             continue;
2546         }
2547         if (ret < 0) {
2548             file_table[file_index].eof_reached = 1;
2549             if (opt_shortest)
2550                 break;
2551             else
2552                 continue;
2553         }
2554
2555         no_packet_count=0;
2556         memset(no_packet, 0, sizeof(no_packet));
2557
2558         if (do_pkt_dump) {
2559             av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2560                              is->streams[pkt.stream_index]);
2561         }
2562         /* the following test is needed in case new streams appear
2563            dynamically in stream : we ignore them */
2564         if (pkt.stream_index >= file_table[file_index].nb_streams)
2565             goto discard_packet;
2566         ist_index = file_table[file_index].ist_index + pkt.stream_index;
2567         ist = ist_table[ist_index];
2568         if (ist->discard)
2569             goto discard_packet;
2570
2571         if (pkt.dts != AV_NOPTS_VALUE)
2572             pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2573         if (pkt.pts != AV_NOPTS_VALUE)
2574             pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2575
2576         if (pkt.stream_index < nb_input_files_ts_scale[file_index]
2577             && input_files_ts_scale[file_index][pkt.stream_index]){
2578             if(pkt.pts != AV_NOPTS_VALUE)
2579                 pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2580             if(pkt.dts != AV_NOPTS_VALUE)
2581                 pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2582         }
2583
2584 //        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);
2585         if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2586             && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2587             int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2588             int64_t delta= pkt_dts - ist->next_pts;
2589             if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2590                 input_files_ts_offset[ist->file_index]-= delta;
2591                 if (verbose > 2)
2592                     fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2593                 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2594                 if(pkt.pts != AV_NOPTS_VALUE)
2595                     pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2596             }
2597         }
2598
2599         /* finish if recording time exhausted */
2600         if (recording_time != INT64_MAX &&
2601             av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2602             ist->is_past_recording_time = 1;
2603             goto discard_packet;
2604         }
2605
2606         //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
2607         if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2608
2609             if (verbose >= 0)
2610                 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2611                         ist->file_index, ist->index);
2612             if (exit_on_error)
2613                 ffmpeg_exit(1);
2614             av_free_packet(&pkt);
2615             goto redo;
2616         }
2617
2618     discard_packet:
2619         av_free_packet(&pkt);
2620
2621         /* dump report by using the output first video and audio streams */
2622         print_report(output_files, ost_table, nb_ostreams, 0);
2623     }
2624
2625     /* at the end of stream, we must flush the decoder buffers */
2626     for(i=0;i<nb_istreams;i++) {
2627         ist = ist_table[i];
2628         if (ist->decoding_needed) {
2629             output_packet(ist, i, ost_table, nb_ostreams, NULL);
2630         }
2631     }
2632
2633     term_exit();
2634
2635     /* write the trailer if needed and close file */
2636     for(i=0;i<nb_output_files;i++) {
2637         os = output_files[i];
2638         av_write_trailer(os);
2639     }
2640
2641     /* dump report by using the first video and audio streams */
2642     print_report(output_files, ost_table, nb_ostreams, 1);
2643
2644     /* close each encoder */
2645     for(i=0;i<nb_ostreams;i++) {
2646         ost = ost_table[i];
2647         if (ost->encoding_needed) {
2648             av_freep(&ost->st->codec->stats_in);
2649             avcodec_close(ost->st->codec);
2650         }
2651     }
2652
2653     /* close each decoder */
2654     for(i=0;i<nb_istreams;i++) {
2655         ist = ist_table[i];
2656         if (ist->decoding_needed) {
2657             avcodec_close(ist->st->codec);
2658         }
2659     }
2660 #if CONFIG_AVFILTER
2661     avfilter_graph_free(&graph);
2662 #endif
2663
2664     /* finished ! */
2665     ret = 0;
2666
2667  fail:
2668     av_freep(&bit_buffer);
2669     av_free(file_table);
2670
2671     if (ist_table) {
2672         for(i=0;i<nb_istreams;i++) {
2673             ist = ist_table[i];
2674             av_free(ist);
2675         }
2676         av_free(ist_table);
2677     }
2678     if (ost_table) {
2679         for(i=0;i<nb_ostreams;i++) {
2680             ost = ost_table[i];
2681             if (ost) {
2682                 if (ost->st->stream_copy)
2683                     av_freep(&ost->st->codec->extradata);
2684                 if (ost->logfile) {
2685                     fclose(ost->logfile);
2686                     ost->logfile = NULL;
2687                 }
2688                 av_fifo_free(ost->fifo); /* works even if fifo is not
2689                                              initialized but set to zero */
2690                 av_freep(&ost->st->codec->subtitle_header);
2691                 av_free(ost->pict_tmp.data[0]);
2692                 av_free(ost->forced_kf_pts);
2693                 if (ost->video_resample)
2694                     sws_freeContext(ost->img_resample_ctx);
2695                 if (ost->resample)
2696                     audio_resample_close(ost->resample);
2697                 if (ost->reformat_ctx)
2698                     av_audio_convert_free(ost->reformat_ctx);
2699                 av_free(ost);
2700             }
2701         }
2702         av_free(ost_table);
2703     }
2704     return ret;
2705 }
2706
2707 static void opt_format(const char *arg)
2708 {
2709     last_asked_format = arg;
2710 }
2711
2712 static void opt_video_rc_override_string(const char *arg)
2713 {
2714     video_rc_override_string = arg;
2715 }
2716
2717 static int opt_me_threshold(const char *opt, const char *arg)
2718 {
2719     me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2720     return 0;
2721 }
2722
2723 static int opt_verbose(const char *opt, const char *arg)
2724 {
2725     verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2726     return 0;
2727 }
2728
2729 static int opt_frame_rate(const char *opt, const char *arg)
2730 {
2731     if (av_parse_video_rate(&frame_rate, arg) < 0) {
2732         fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2733         ffmpeg_exit(1);
2734     }
2735     return 0;
2736 }
2737
2738 static int opt_bitrate(const char *opt, const char *arg)
2739 {
2740     int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2741
2742     opt_default(opt, arg);
2743
2744     if (av_get_int(avcodec_opts[codec_type], "b", NULL) < 1000)
2745         fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2746
2747     return 0;
2748 }
2749
2750 static int opt_frame_crop(const char *opt, const char *arg)
2751 {
2752     fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2753     return AVERROR(EINVAL);
2754 }
2755
2756 static void opt_frame_size(const char *arg)
2757 {
2758     if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2759         fprintf(stderr, "Incorrect frame size\n");
2760         ffmpeg_exit(1);
2761     }
2762 }
2763
2764 static int opt_pad(const char *opt, const char *arg) {
2765     fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2766     return -1;
2767 }
2768
2769 static void opt_frame_pix_fmt(const char *arg)
2770 {
2771     if (strcmp(arg, "list")) {
2772         frame_pix_fmt = av_get_pix_fmt(arg);
2773         if (frame_pix_fmt == PIX_FMT_NONE) {
2774             fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2775             ffmpeg_exit(1);
2776         }
2777     } else {
2778         show_pix_fmts();
2779         ffmpeg_exit(0);
2780     }
2781 }
2782
2783 static void opt_frame_aspect_ratio(const char *arg)
2784 {
2785     int x = 0, y = 0;
2786     double ar = 0;
2787     const char *p;
2788     char *end;
2789
2790     p = strchr(arg, ':');
2791     if (p) {
2792         x = strtol(arg, &end, 10);
2793         if (end == p)
2794             y = strtol(end+1, &end, 10);
2795         if (x > 0 && y > 0)
2796             ar = (double)x / (double)y;
2797     } else
2798         ar = strtod(arg, NULL);
2799
2800     if (!ar) {
2801         fprintf(stderr, "Incorrect aspect ratio specification.\n");
2802         ffmpeg_exit(1);
2803     }
2804     frame_aspect_ratio = ar;
2805
2806 #if CONFIG_AVFILTER
2807     x = vfilters ? strlen(vfilters) : 0;
2808     vfilters = av_realloc(vfilters, x+100);
2809     snprintf(vfilters+x, x+100, "%csetdar=%f\n", x?',':' ', ar);
2810 #endif
2811 }
2812
2813 static int opt_metadata(const char *opt, const char *arg)
2814 {
2815     char *mid= strchr(arg, '=');
2816
2817     if(!mid){
2818         fprintf(stderr, "Missing =\n");
2819         ffmpeg_exit(1);
2820     }
2821     *mid++= 0;
2822
2823     av_metadata_set2(&metadata, arg, mid, 0);
2824
2825     return 0;
2826 }
2827
2828 static void opt_qscale(const char *arg)
2829 {
2830     video_qscale = atof(arg);
2831     if (video_qscale <= 0 ||
2832         video_qscale > 255) {
2833         fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2834         ffmpeg_exit(1);
2835     }
2836 }
2837
2838 static void opt_top_field_first(const char *arg)
2839 {
2840     top_field_first= atoi(arg);
2841 }
2842
2843 static int opt_thread_count(const char *opt, const char *arg)
2844 {
2845     thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2846 #if !HAVE_THREADS
2847     if (verbose >= 0)
2848         fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2849 #endif
2850     return 0;
2851 }
2852
2853 static void opt_audio_sample_fmt(const char *arg)
2854 {
2855     if (strcmp(arg, "list")) {
2856         audio_sample_fmt = av_get_sample_fmt(arg);
2857         if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2858             av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2859             ffmpeg_exit(1);
2860         }
2861     } else {
2862         int i;
2863         char fmt_str[128];
2864         for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
2865             printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
2866         ffmpeg_exit(0);
2867     }
2868 }
2869
2870 static int opt_audio_rate(const char *opt, const char *arg)
2871 {
2872     audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2873     return 0;
2874 }
2875
2876 static int opt_audio_channels(const char *opt, const char *arg)
2877 {
2878     audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2879     return 0;
2880 }
2881
2882 static void opt_video_channel(const char *arg)
2883 {
2884     video_channel = strtol(arg, NULL, 0);
2885 }
2886
2887 static void opt_video_standard(const char *arg)
2888 {
2889     video_standard = av_strdup(arg);
2890 }
2891
2892 static void opt_codec(int *pstream_copy, char **pcodec_name,
2893                       int codec_type, const char *arg)
2894 {
2895     av_freep(pcodec_name);
2896     if (!strcmp(arg, "copy")) {
2897         *pstream_copy = 1;
2898     } else {
2899         *pcodec_name = av_strdup(arg);
2900     }
2901 }
2902
2903 static void opt_audio_codec(const char *arg)
2904 {
2905     opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2906 }
2907
2908 static void opt_video_codec(const char *arg)
2909 {
2910     opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2911 }
2912
2913 static void opt_subtitle_codec(const char *arg)
2914 {
2915     opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2916 }
2917
2918 static void opt_data_codec(const char *arg)
2919 {
2920     opt_codec(&data_stream_copy, &data_codec_name, AVMEDIA_TYPE_DATA, arg);
2921 }
2922
2923 static int opt_codec_tag(const char *opt, const char *arg)
2924 {
2925     char *tail;
2926     uint32_t *codec_tag;
2927
2928     codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2929                 !strcmp(opt, "vtag") ? &video_codec_tag :
2930                 !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2931     if (!codec_tag)
2932         return -1;
2933
2934     *codec_tag = strtol(arg, &tail, 0);
2935     if (!tail || *tail)
2936         *codec_tag = AV_RL32(arg);
2937
2938     return 0;
2939 }
2940
2941 static void opt_map(const char *arg)
2942 {
2943     AVStreamMap *m;
2944     char *p;
2945
2946     stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
2947     m = &stream_maps[nb_stream_maps-1];
2948
2949     m->file_index = strtol(arg, &p, 0);
2950     if (*p)
2951         p++;
2952
2953     m->stream_index = strtol(p, &p, 0);
2954     if (*p) {
2955         p++;
2956         m->sync_file_index = strtol(p, &p, 0);
2957         if (*p)
2958             p++;
2959         m->sync_stream_index = strtol(p, &p, 0);
2960     } else {
2961         m->sync_file_index = m->file_index;
2962         m->sync_stream_index = m->stream_index;
2963     }
2964 }
2965
2966 static void parse_meta_type(char *arg, char *type, int *index, char **endptr)
2967 {
2968     *endptr = arg;
2969     if (*arg == ',') {
2970         *type = *(++arg);
2971         switch (*arg) {
2972         case 'g':
2973             break;
2974         case 's':
2975         case 'c':
2976         case 'p':
2977             *index = strtol(++arg, endptr, 0);
2978             break;
2979         default:
2980             fprintf(stderr, "Invalid metadata type %c.\n", *arg);
2981             ffmpeg_exit(1);
2982         }
2983     } else
2984         *type = 'g';
2985 }
2986
2987 static void opt_map_metadata(const char *arg)
2988 {
2989     AVMetaDataMap *m, *m1;
2990     char *p;
2991
2992     meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
2993                                 &nb_meta_data_maps, nb_meta_data_maps + 1);
2994
2995     m = &meta_data_maps[nb_meta_data_maps - 1][0];
2996     m->file = strtol(arg, &p, 0);
2997     parse_meta_type(p, &m->type, &m->index, &p);
2998     if (*p)
2999         p++;
3000
3001     m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
3002     m1->file = strtol(p, &p, 0);
3003     parse_meta_type(p, &m1->type, &m1->index, &p);
3004
3005     if (m->type == 'g' || m1->type == 'g')
3006         metadata_global_autocopy = 0;
3007     if (m->type == 's' || m1->type == 's')
3008         metadata_streams_autocopy = 0;
3009     if (m->type == 'c' || m1->type == 'c')
3010         metadata_chapters_autocopy = 0;
3011 }
3012
3013 static void opt_map_meta_data(const char *arg)
3014 {
3015     fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "
3016                     "Use -map_metadata instead.\n");
3017     opt_map_metadata(arg);
3018 }
3019
3020 static void opt_map_chapters(const char *arg)
3021 {
3022     AVChapterMap *c;
3023     char *p;
3024
3025     chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
3026                               nb_chapter_maps + 1);
3027     c = &chapter_maps[nb_chapter_maps - 1];
3028     c->out_file = strtol(arg, &p, 0);
3029     if (*p)
3030         p++;
3031
3032     c->in_file = strtol(p, &p, 0);
3033 }
3034
3035 static void opt_input_ts_scale(const char *arg)
3036 {
3037     unsigned int stream;
3038     double scale;
3039     char *p;
3040
3041     stream = strtol(arg, &p, 0);
3042     if (*p)
3043         p++;
3044     scale= strtod(p, &p);
3045
3046     if(stream >= MAX_STREAMS)
3047         ffmpeg_exit(1);
3048
3049     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);
3050     input_files_ts_scale[nb_input_files][stream]= scale;
3051 }
3052
3053 static int opt_recording_time(const char *opt, const char *arg)
3054 {
3055     recording_time = parse_time_or_die(opt, arg, 1);
3056     return 0;
3057 }
3058
3059 static int opt_start_time(const char *opt, const char *arg)
3060 {
3061     start_time = parse_time_or_die(opt, arg, 1);
3062     return 0;
3063 }
3064
3065 static int opt_recording_timestamp(const char *opt, const char *arg)
3066 {
3067     recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
3068     return 0;
3069 }
3070
3071 static int opt_input_ts_offset(const char *opt, const char *arg)
3072 {
3073     input_ts_offset = parse_time_or_die(opt, arg, 1);
3074     return 0;
3075 }
3076
3077 static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3078 {
3079     const char *codec_string = encoder ? "encoder" : "decoder";
3080     AVCodec *codec;
3081
3082     if(!name)
3083         return CODEC_ID_NONE;
3084     codec = encoder ?
3085         avcodec_find_encoder_by_name(name) :
3086         avcodec_find_decoder_by_name(name);
3087     if(!codec) {
3088         fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3089         ffmpeg_exit(1);
3090     }
3091     if(codec->type != type) {
3092         fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3093         ffmpeg_exit(1);
3094     }
3095     if(codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
3096        strict > FF_COMPLIANCE_EXPERIMENTAL) {
3097         fprintf(stderr, "%s '%s' is experimental and might produce bad "
3098                 "results.\nAdd '-strict experimental' if you want to use it.\n",
3099                 codec_string, codec->name);
3100         codec = encoder ?
3101             avcodec_find_encoder(codec->id) :
3102             avcodec_find_decoder(codec->id);
3103         if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
3104             fprintf(stderr, "Or use the non experimental %s '%s'.\n",
3105                     codec_string, codec->name);
3106         ffmpeg_exit(1);
3107     }
3108     return codec->id;
3109 }
3110
3111 static void opt_input_file(const char *filename)
3112 {
3113     AVFormatContext *ic;
3114     AVFormatParameters params, *ap = &params;
3115     AVInputFormat *file_iformat = NULL;
3116     int err, i, ret, rfps, rfps_base;
3117     int64_t timestamp;
3118
3119     if (last_asked_format) {
3120         if (!(file_iformat = av_find_input_format(last_asked_format))) {
3121             fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3122             ffmpeg_exit(1);
3123         }
3124         last_asked_format = NULL;
3125     }
3126
3127     if (!strcmp(filename, "-"))
3128         filename = "pipe:";
3129
3130     using_stdin |= !strncmp(filename, "pipe:", 5) ||
3131                     !strcmp(filename, "/dev/stdin");
3132
3133     /* get default parameters from command line */
3134     ic = avformat_alloc_context();
3135     if (!ic) {
3136         print_error(filename, AVERROR(ENOMEM));
3137         ffmpeg_exit(1);
3138     }
3139
3140     memset(ap, 0, sizeof(*ap));
3141     ap->prealloced_context = 1;
3142     ap->sample_rate = audio_sample_rate;
3143     ap->channels = audio_channels;
3144     ap->time_base.den = frame_rate.num;
3145     ap->time_base.num = frame_rate.den;
3146     ap->width = frame_width;
3147     ap->height = frame_height;
3148     ap->pix_fmt = frame_pix_fmt;
3149    // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
3150     ap->channel = video_channel;
3151     ap->standard = video_standard;
3152
3153     set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3154
3155     ic->video_codec_id   =
3156         find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0,
3157                           avcodec_opts[AVMEDIA_TYPE_VIDEO   ]->strict_std_compliance);
3158     ic->audio_codec_id   =
3159         find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0,
3160                           avcodec_opts[AVMEDIA_TYPE_AUDIO   ]->strict_std_compliance);
3161     ic->subtitle_codec_id=
3162         find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
3163                           avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3164     ic->flags |= AVFMT_FLAG_NONBLOCK;
3165
3166     /* open the input file with generic libav function */
3167     err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
3168     if (err < 0) {
3169         print_error(filename, err);
3170         ffmpeg_exit(1);
3171     }
3172     if(opt_programid) {
3173         int i, j;
3174         int found=0;
3175         for(i=0; i<ic->nb_streams; i++){
3176             ic->streams[i]->discard= AVDISCARD_ALL;
3177         }
3178         for(i=0; i<ic->nb_programs; i++){
3179             AVProgram *p= ic->programs[i];
3180             if(p->id != opt_programid){
3181                 p->discard = AVDISCARD_ALL;
3182             }else{
3183                 found=1;
3184                 for(j=0; j<p->nb_stream_indexes; j++){
3185                     ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3186                 }
3187             }
3188         }
3189         if(!found){
3190             fprintf(stderr, "Specified program id not found\n");
3191             ffmpeg_exit(1);
3192         }
3193         opt_programid=0;
3194     }
3195
3196     ic->loop_input = loop_input;
3197
3198     /* If not enough info to get the stream parameters, we decode the
3199        first frames to get it. (used in mpeg case for example) */
3200     ret = av_find_stream_info(ic);
3201     if (ret < 0 && verbose >= 0) {
3202         fprintf(stderr, "%s: could not find codec parameters\n", filename);
3203         av_close_input_file(ic);
3204         ffmpeg_exit(1);
3205     }
3206
3207     timestamp = start_time;
3208     /* add the stream start time */
3209     if (ic->start_time != AV_NOPTS_VALUE)
3210         timestamp += ic->start_time;
3211
3212     /* if seeking requested, we execute it */
3213     if (start_time != 0) {
3214         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3215         if (ret < 0) {
3216             fprintf(stderr, "%s: could not seek to position %0.3f\n",
3217                     filename, (double)timestamp / AV_TIME_BASE);
3218         }
3219         /* reset seek info */
3220         start_time = 0;
3221     }
3222
3223     /* update the current parameters so that they match the one of the input stream */
3224     for(i=0;i<ic->nb_streams;i++) {
3225         AVStream *st = ic->streams[i];
3226         AVCodecContext *dec = st->codec;
3227         dec->thread_count = thread_count;
3228         input_codecs = grow_array(input_codecs, sizeof(*input_codecs), &nb_input_codecs, nb_input_codecs + 1);
3229         switch (dec->codec_type) {
3230         case AVMEDIA_TYPE_AUDIO:
3231             input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(audio_codec_name);
3232             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]);
3233             channel_layout    = dec->channel_layout;
3234             audio_channels    = dec->channels;
3235             audio_sample_rate = dec->sample_rate;
3236             audio_sample_fmt  = dec->sample_fmt;
3237             if(audio_disable)
3238                 st->discard= AVDISCARD_ALL;
3239             /* Note that av_find_stream_info can add more streams, and we
3240              * currently have no chance of setting up lowres decoding
3241              * early enough for them. */
3242             if (dec->lowres)
3243                 audio_sample_rate >>= dec->lowres;
3244             break;
3245         case AVMEDIA_TYPE_VIDEO:
3246             input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(video_codec_name);
3247             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]);
3248             frame_height = dec->height;
3249             frame_width  = dec->width;
3250             if(ic->streams[i]->sample_aspect_ratio.num)
3251                 frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
3252             else
3253                 frame_aspect_ratio=av_q2d(dec->sample_aspect_ratio);
3254             frame_aspect_ratio *= (float) dec->width / dec->height;
3255             frame_pix_fmt = dec->pix_fmt;
3256             rfps      = ic->streams[i]->r_frame_rate.num;
3257             rfps_base = ic->streams[i]->r_frame_rate.den;
3258             if (dec->lowres) {
3259                 dec->flags |= CODEC_FLAG_EMU_EDGE;
3260                 frame_height >>= dec->lowres;
3261                 frame_width  >>= dec->lowres;
3262                 dec->height = frame_height;
3263                 dec->width  = frame_width;
3264             }
3265             if(me_threshold)
3266                 dec->debug |= FF_DEBUG_MV;
3267
3268             if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3269
3270                 if (verbose >= 0)
3271                     fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3272                             i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3273
3274                     (float)rfps / rfps_base, rfps, rfps_base);
3275             }
3276             /* update the current frame rate to match the stream frame rate */
3277             frame_rate.num = rfps;
3278             frame_rate.den = rfps_base;
3279
3280             if(video_disable)
3281                 st->discard= AVDISCARD_ALL;
3282             else if(video_discard)
3283                 st->discard= video_discard;
3284             break;
3285         case AVMEDIA_TYPE_DATA:
3286             break;
3287         case AVMEDIA_TYPE_SUBTITLE:
3288             input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(subtitle_codec_name);
3289             if(subtitle_disable)
3290                 st->discard = AVDISCARD_ALL;
3291             break;
3292         case AVMEDIA_TYPE_ATTACHMENT:
3293         case AVMEDIA_TYPE_UNKNOWN:
3294             break;
3295         default:
3296             abort();
3297         }
3298     }
3299
3300     input_files[nb_input_files] = ic;
3301     input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3302     /* dump the file content */
3303     if (verbose >= 0)
3304         av_dump_format(ic, nb_input_files, filename, 0);
3305
3306     nb_input_files++;
3307
3308     video_channel = 0;
3309
3310     av_freep(&video_codec_name);
3311     av_freep(&audio_codec_name);
3312     av_freep(&subtitle_codec_name);
3313     uninit_opts();
3314     init_opts();
3315 }
3316
3317 static void check_inputs(int *has_video_ptr,
3318                          int *has_audio_ptr,
3319                          int *has_subtitle_ptr,
3320                          int *has_data_ptr)
3321 {
3322     int has_video, has_audio, has_subtitle, has_data, i, j;
3323     AVFormatContext *ic;
3324
3325     has_video = 0;
3326     has_audio = 0;
3327     has_subtitle = 0;
3328     has_data = 0;
3329
3330     for(j=0;j<nb_input_files;j++) {
3331         ic = input_files[j];
3332         for(i=0;i<ic->nb_streams;i++) {
3333             AVCodecContext *enc = ic->streams[i]->codec;
3334             switch(enc->codec_type) {
3335             case AVMEDIA_TYPE_AUDIO:
3336                 has_audio = 1;
3337                 break;
3338             case AVMEDIA_TYPE_VIDEO:
3339                 has_video = 1;
3340                 break;
3341             case AVMEDIA_TYPE_SUBTITLE:
3342                 has_subtitle = 1;
3343                 break;
3344             case AVMEDIA_TYPE_DATA:
3345             case AVMEDIA_TYPE_ATTACHMENT:
3346             case AVMEDIA_TYPE_UNKNOWN:
3347                 has_data = 1;
3348                 break;
3349             default:
3350                 abort();
3351             }
3352         }
3353     }
3354     *has_video_ptr = has_video;
3355     *has_audio_ptr = has_audio;
3356     *has_subtitle_ptr = has_subtitle;
3357     *has_data_ptr = has_data;
3358 }
3359
3360 static void new_video_stream(AVFormatContext *oc, int file_idx)
3361 {
3362     AVStream *st;
3363     AVOutputStream *ost;
3364     AVCodecContext *video_enc;
3365     enum CodecID codec_id = CODEC_ID_NONE;
3366     AVCodec *codec= NULL;
3367
3368     st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3369     if (!st) {
3370         fprintf(stderr, "Could not alloc stream\n");
3371         ffmpeg_exit(1);
3372     }
3373     ost = new_output_stream(oc, file_idx);
3374
3375     output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3376     if(!video_stream_copy){
3377         if (video_codec_name) {
3378             codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
3379                                          avcodec_opts[AVMEDIA_TYPE_VIDEO]->strict_std_compliance);
3380             codec = avcodec_find_encoder_by_name(video_codec_name);
3381             output_codecs[nb_output_codecs-1] = codec;
3382         } else {
3383             codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3384             codec = avcodec_find_encoder(codec_id);
3385         }
3386     }
3387
3388     avcodec_get_context_defaults3(st->codec, codec);
3389     ost->bitstream_filters = video_bitstream_filters;
3390     video_bitstream_filters= NULL;
3391
3392     st->codec->thread_count= thread_count;
3393
3394     video_enc = st->codec;
3395
3396     if(video_codec_tag)
3397         video_enc->codec_tag= video_codec_tag;
3398
3399     if(   (video_global_header&1)
3400        || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3401         video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3402         avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3403     }
3404     if(video_global_header&2){
3405         video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3406         avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3407     }
3408
3409     if (video_stream_copy) {
3410         st->stream_copy = 1;
3411         video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3412         video_enc->sample_aspect_ratio =
3413         st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3414     } else {
3415         const char *p;
3416         int i;
3417         AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3418
3419         video_enc->codec_id = codec_id;
3420         set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3421
3422         if (codec && codec->supported_framerates && !force_fps)
3423             fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3424         video_enc->time_base.den = fps.num;
3425         video_enc->time_base.num = fps.den;
3426
3427         video_enc->width = frame_width;
3428         video_enc->height = frame_height;
3429         video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3430         video_enc->pix_fmt = frame_pix_fmt;
3431         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3432
3433         choose_pixel_fmt(st, codec);
3434
3435         if (intra_only)
3436             video_enc->gop_size = 0;
3437         if (video_qscale || same_quality) {
3438             video_enc->flags |= CODEC_FLAG_QSCALE;
3439             video_enc->global_quality=
3440                 st->quality = FF_QP2LAMBDA * video_qscale;
3441         }
3442
3443         if(intra_matrix)
3444             video_enc->intra_matrix = intra_matrix;
3445         if(inter_matrix)
3446             video_enc->inter_matrix = inter_matrix;
3447
3448         p= video_rc_override_string;
3449         for(i=0; p; i++){
3450             int start, end, q;
3451             int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3452             if(e!=3){
3453                 fprintf(stderr, "error parsing rc_override\n");
3454                 ffmpeg_exit(1);
3455             }
3456             video_enc->rc_override=
3457                 av_realloc(video_enc->rc_override,
3458                            sizeof(RcOverride)*(i+1));
3459             video_enc->rc_override[i].start_frame= start;
3460             video_enc->rc_override[i].end_frame  = end;
3461             if(q>0){
3462                 video_enc->rc_override[i].qscale= q;
3463                 video_enc->rc_override[i].quality_factor= 1.0;
3464             }
3465             else{
3466                 video_enc->rc_override[i].qscale= 0;
3467                 video_enc->rc_override[i].quality_factor= -q/100.0;
3468             }
3469             p= strchr(p, '/');
3470             if(p) p++;
3471         }
3472         video_enc->rc_override_count=i;
3473         if (!video_enc->rc_initial_buffer_occupancy)
3474             video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3475         video_enc->me_threshold= me_threshold;
3476         video_enc->intra_dc_precision= intra_dc_precision - 8;
3477
3478         if (do_psnr)
3479             video_enc->flags|= CODEC_FLAG_PSNR;
3480
3481         /* two pass mode */
3482         if (do_pass) {
3483             if (do_pass == 1) {
3484                 video_enc->flags |= CODEC_FLAG_PASS1;
3485             } else {
3486                 video_enc->flags |= CODEC_FLAG_PASS2;
3487             }
3488         }
3489
3490         if (forced_key_frames)
3491             parse_forced_key_frames(forced_key_frames, ost, video_enc);
3492     }
3493     if (video_language) {
3494         av_metadata_set2(&st->metadata, "language", video_language, 0);
3495         av_freep(&video_language);
3496     }
3497
3498     /* reset some key parameters */
3499     video_disable = 0;
3500     av_freep(&video_codec_name);
3501     av_freep(&forced_key_frames);
3502     video_stream_copy = 0;
3503     frame_pix_fmt = PIX_FMT_NONE;
3504 }
3505
3506 static void new_audio_stream(AVFormatContext *oc, int file_idx)
3507 {
3508     AVStream *st;
3509     AVOutputStream *ost;
3510     AVCodec *codec= NULL;
3511     AVCodecContext *audio_enc;
3512     enum CodecID codec_id = CODEC_ID_NONE;
3513
3514     st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3515     if (!st) {
3516         fprintf(stderr, "Could not alloc stream\n");
3517         ffmpeg_exit(1);
3518     }
3519     ost = new_output_stream(oc, file_idx);
3520
3521     output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3522     if(!audio_stream_copy){
3523         if (audio_codec_name) {
3524             codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
3525                                          avcodec_opts[AVMEDIA_TYPE_AUDIO]->strict_std_compliance);
3526             codec = avcodec_find_encoder_by_name(audio_codec_name);
3527             output_codecs[nb_output_codecs-1] = codec;
3528         } else {
3529             codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3530             codec = avcodec_find_encoder(codec_id);
3531         }
3532     }
3533
3534     avcodec_get_context_defaults3(st->codec, codec);
3535
3536     ost->bitstream_filters = audio_bitstream_filters;
3537     audio_bitstream_filters= NULL;
3538
3539     st->codec->thread_count= thread_count;
3540
3541     audio_enc = st->codec;
3542     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3543
3544     if(audio_codec_tag)
3545         audio_enc->codec_tag= audio_codec_tag;
3546
3547     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3548         audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3549         avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3550     }
3551     if (audio_stream_copy) {
3552         st->stream_copy = 1;
3553         audio_enc->channels = audio_channels;
3554         audio_enc->sample_rate = audio_sample_rate;
3555     } else {
3556         audio_enc->codec_id = codec_id;
3557         set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3558
3559         if (audio_qscale > QSCALE_NONE) {
3560             audio_enc->flags |= CODEC_FLAG_QSCALE;
3561             audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3562         }
3563         audio_enc->channels = audio_channels;
3564         audio_enc->sample_fmt = audio_sample_fmt;
3565         audio_enc->sample_rate = audio_sample_rate;
3566         audio_enc->channel_layout = channel_layout;
3567         if (av_get_channel_layout_nb_channels(channel_layout) != audio_channels)
3568             audio_enc->channel_layout = 0;
3569         choose_sample_fmt(st, codec);
3570         choose_sample_rate(st, codec);
3571     }
3572     audio_enc->time_base= (AVRational){1, audio_sample_rate};
3573     if (audio_language) {
3574         av_metadata_set2(&st->metadata, "language", audio_language, 0);
3575         av_freep(&audio_language);
3576     }
3577
3578     /* reset some key parameters */
3579     audio_disable = 0;
3580     av_freep(&audio_codec_name);
3581     audio_stream_copy = 0;
3582 }
3583
3584 static void new_data_stream(AVFormatContext *oc, int file_idx)
3585 {
3586     AVStream *st;
3587     AVOutputStream *ost;
3588     AVCodec *codec=NULL;
3589     AVCodecContext *data_enc;
3590
3591     st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3592     if (!st) {
3593         fprintf(stderr, "Could not alloc stream\n");
3594         ffmpeg_exit(1);
3595     }
3596     ost = new_output_stream(oc, file_idx);
3597     data_enc = st->codec;
3598     output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3599     if (!data_stream_copy) {
3600         fprintf(stderr, "Data stream encoding not supported yet (only streamcopy)\n");
3601         ffmpeg_exit(1);
3602     }
3603     avcodec_get_context_defaults3(st->codec, codec);
3604
3605     data_enc->codec_type = AVMEDIA_TYPE_DATA;
3606
3607     if (data_codec_tag)
3608         data_enc->codec_tag= data_codec_tag;
3609
3610     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3611         data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3612         avcodec_opts[AVMEDIA_TYPE_DATA]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3613     }
3614     if (data_stream_copy) {
3615         st->stream_copy = 1;
3616     }
3617
3618     data_disable = 0;
3619     av_freep(&data_codec_name);
3620     data_stream_copy = 0;
3621 }
3622
3623 static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3624 {
3625     AVStream *st;
3626     AVOutputStream *ost;
3627     AVCodec *codec=NULL;
3628     AVCodecContext *subtitle_enc;
3629     enum CodecID codec_id = CODEC_ID_NONE;
3630
3631     st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3632     if (!st) {
3633         fprintf(stderr, "Could not alloc stream\n");
3634         ffmpeg_exit(1);
3635     }
3636     ost = new_output_stream(oc, file_idx);
3637     subtitle_enc = st->codec;
3638     output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3639     if(!subtitle_stream_copy){
3640         if (subtitle_codec_name) {
3641             codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,
3642                                          avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3643             codec= output_codecs[nb_output_codecs-1] = avcodec_find_encoder_by_name(subtitle_codec_name);
3644         } else {
3645             codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_SUBTITLE);
3646             codec = avcodec_find_encoder(codec_id);
3647         }
3648     }
3649     avcodec_get_context_defaults3(st->codec, codec);
3650
3651     ost->bitstream_filters = subtitle_bitstream_filters;
3652     subtitle_bitstream_filters= NULL;
3653
3654     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3655
3656     if(subtitle_codec_tag)
3657         subtitle_enc->codec_tag= subtitle_codec_tag;
3658
3659     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3660         subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3661         avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3662     }
3663     if (subtitle_stream_copy) {
3664         st->stream_copy = 1;
3665     } else {
3666         subtitle_enc->codec_id = codec_id;
3667         set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3668     }
3669
3670     if (subtitle_language) {
3671         av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3672         av_freep(&subtitle_language);
3673     }
3674
3675     subtitle_disable = 0;
3676     av_freep(&subtitle_codec_name);
3677     subtitle_stream_copy = 0;
3678 }
3679
3680 static int opt_new_stream(const char *opt, const char *arg)
3681 {
3682     AVFormatContext *oc;
3683     int file_idx = nb_output_files - 1;
3684     if (nb_output_files <= 0) {
3685         fprintf(stderr, "At least one output file must be specified\n");
3686         ffmpeg_exit(1);
3687     }
3688     oc = output_files[file_idx];
3689
3690     if      (!strcmp(opt, "newvideo"   )) new_video_stream   (oc, file_idx);
3691     else if (!strcmp(opt, "newaudio"   )) new_audio_stream   (oc, file_idx);
3692     else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3693     else if (!strcmp(opt, "newdata"    )) new_data_stream    (oc, file_idx);
3694     else av_assert0(0);
3695     return 0;
3696 }
3697
3698 /* arg format is "output-stream-index:streamid-value". */
3699 static int opt_streamid(const char *opt, const char *arg)
3700 {
3701     int idx;
3702     char *p;
3703     char idx_str[16];
3704
3705     av_strlcpy(idx_str, arg, sizeof(idx_str));
3706     p = strchr(idx_str, ':');
3707     if (!p) {
3708         fprintf(stderr,
3709                 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3710                 arg, opt);
3711         ffmpeg_exit(1);
3712     }
3713     *p++ = '\0';
3714     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3715     streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3716     streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3717     return 0;
3718 }
3719
3720 static void opt_output_file(const char *filename)
3721 {
3722     AVFormatContext *oc;
3723     int err, use_video, use_audio, use_subtitle, use_data;
3724     int input_has_video, input_has_audio, input_has_subtitle, input_has_data;
3725     AVFormatParameters params, *ap = &params;
3726     AVOutputFormat *file_oformat;
3727
3728     if (!strcmp(filename, "-"))
3729         filename = "pipe:";
3730
3731     oc = avformat_alloc_context();
3732     if (!oc) {
3733         print_error(filename, AVERROR(ENOMEM));
3734         ffmpeg_exit(1);
3735     }
3736
3737     if (last_asked_format) {
3738         file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3739         if (!file_oformat) {
3740             fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3741             ffmpeg_exit(1);
3742         }
3743         last_asked_format = NULL;
3744     } else {
3745         file_oformat = av_guess_format(NULL, filename, NULL);
3746         if (!file_oformat) {
3747             fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3748                     filename);
3749             ffmpeg_exit(1);
3750         }
3751     }
3752
3753     oc->oformat = file_oformat;
3754     av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3755
3756     if (!strcmp(file_oformat->name, "ffm") &&
3757         av_strstart(filename, "http:", NULL)) {
3758         /* special case for files sent to ffserver: we get the stream
3759            parameters from ffserver */
3760         int err = read_ffserver_streams(oc, filename);
3761         if (err < 0) {
3762             print_error(filename, err);
3763             ffmpeg_exit(1);
3764         }
3765     } else {
3766         use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3767         use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3768         use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3769         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 */
3770
3771         /* disable if no corresponding type found and at least one
3772            input file */
3773         if (nb_input_files > 0) {
3774             check_inputs(&input_has_video,
3775                          &input_has_audio,
3776                          &input_has_subtitle,
3777                          &input_has_data);
3778
3779             if (!input_has_video)
3780                 use_video = 0;
3781             if (!input_has_audio)
3782                 use_audio = 0;
3783             if (!input_has_subtitle)
3784                 use_subtitle = 0;
3785             if (!input_has_data)
3786                 use_data = 0;
3787         }
3788
3789         /* manual disable */
3790         if (audio_disable)    use_audio    = 0;
3791         if (video_disable)    use_video    = 0;
3792         if (subtitle_disable) use_subtitle = 0;
3793         if (data_disable)     use_data     = 0;
3794
3795         if (use_video)    new_video_stream(oc, nb_output_files);
3796         if (use_audio)    new_audio_stream(oc, nb_output_files);
3797         if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3798         if (use_data)     new_data_stream(oc, nb_output_files);
3799
3800         oc->timestamp = recording_timestamp;
3801
3802         av_metadata_copy(&oc->metadata, metadata, 0);
3803         av_metadata_free(&metadata);
3804     }
3805
3806     output_files[nb_output_files++] = oc;
3807
3808     /* check filename in case of an image number is expected */
3809     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3810         if (!av_filename_number_test(oc->filename)) {
3811             print_error(oc->filename, AVERROR(EINVAL));
3812             ffmpeg_exit(1);
3813         }
3814     }
3815
3816     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3817         /* test if it already exists to avoid loosing precious files */
3818         if (!file_overwrite &&
3819             (strchr(filename, ':') == NULL ||
3820              filename[1] == ':' ||
3821              av_strstart(filename, "file:", NULL))) {
3822             if (avio_check(filename, 0) == 0) {
3823                 if (!using_stdin) {
3824                     fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3825                     fflush(stderr);
3826                     if (!read_yesno()) {
3827                         fprintf(stderr, "Not overwriting - exiting\n");
3828                         ffmpeg_exit(1);
3829                     }
3830                 }
3831                 else {
3832                     fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3833                     ffmpeg_exit(1);
3834                 }
3835             }
3836         }
3837
3838         /* open the file */
3839         if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3840             print_error(filename, err);
3841             ffmpeg_exit(1);
3842         }
3843     }
3844
3845     memset(ap, 0, sizeof(*ap));
3846     if (av_set_parameters(oc, ap) < 0) {
3847         fprintf(stderr, "%s: Invalid encoding parameters\n",
3848                 oc->filename);
3849         ffmpeg_exit(1);
3850     }
3851
3852     oc->preload= (int)(mux_preload*AV_TIME_BASE);
3853     oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3854     oc->loop_output = loop_output;
3855     oc->flags |= AVFMT_FLAG_NONBLOCK;
3856
3857     set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
3858
3859     av_freep(&forced_key_frames);
3860     uninit_opts();
3861     init_opts();
3862 }
3863
3864 /* same option as mencoder */
3865 static void opt_pass(const char *pass_str)
3866 {
3867     int pass;
3868     pass = atoi(pass_str);
3869     if (pass != 1 && pass != 2) {
3870         fprintf(stderr, "pass number can be only 1 or 2\n");
3871         ffmpeg_exit(1);
3872     }
3873     do_pass = pass;
3874 }
3875
3876 static int64_t getutime(void)
3877 {
3878 #if HAVE_GETRUSAGE
3879     struct rusage rusage;
3880
3881     getrusage(RUSAGE_SELF, &rusage);
3882     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3883 #elif HAVE_GETPROCESSTIMES
3884     HANDLE proc;
3885     FILETIME c, e, k, u;
3886     proc = GetCurrentProcess();
3887     GetProcessTimes(proc, &c, &e, &k, &u);
3888     return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3889 #else
3890     return av_gettime();
3891 #endif
3892 }
3893
3894 static int64_t getmaxrss(void)
3895 {
3896 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3897     struct rusage rusage;
3898     getrusage(RUSAGE_SELF, &rusage);
3899     return (int64_t)rusage.ru_maxrss * 1024;
3900 #elif HAVE_GETPROCESSMEMORYINFO
3901     HANDLE proc;
3902     PROCESS_MEMORY_COUNTERS memcounters;
3903     proc = GetCurrentProcess();
3904     memcounters.cb = sizeof(memcounters);
3905     GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3906     return memcounters.PeakPagefileUsage;
3907 #else
3908     return 0;
3909 #endif
3910 }
3911
3912 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3913 {
3914     int i;
3915     const char *p = str;
3916     for(i = 0;; i++) {
3917         dest[i] = atoi(p);
3918         if(i == 63)
3919             break;
3920         p = strchr(p, ',');
3921         if(!p) {
3922             fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3923             ffmpeg_exit(1);
3924         }
3925         p++;
3926     }
3927 }
3928
3929 static void opt_inter_matrix(const char *arg)
3930 {
3931     inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3932     parse_matrix_coeffs(inter_matrix, arg);
3933 }
3934
3935 static void opt_intra_matrix(const char *arg)
3936 {
3937     intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3938     parse_matrix_coeffs(intra_matrix, arg);
3939 }
3940
3941 static void show_usage(void)
3942 {
3943     printf("Hyper fast Audio and Video encoder\n");
3944     printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3945     printf("\n");
3946 }
3947
3948 static void show_help(void)
3949 {
3950     AVCodec *c;
3951     AVOutputFormat *oformat = NULL;
3952
3953     av_log_set_callback(log_callback_help);
3954     show_usage();
3955     show_help_options(options, "Main options:\n",
3956                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3957     show_help_options(options, "\nAdvanced options:\n",
3958                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3959                       OPT_EXPERT);
3960     show_help_options(options, "\nVideo options:\n",
3961                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3962                       OPT_VIDEO);
3963     show_help_options(options, "\nAdvanced Video options:\n",
3964                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3965                       OPT_VIDEO | OPT_EXPERT);
3966     show_help_options(options, "\nAudio options:\n",
3967                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3968                       OPT_AUDIO);
3969     show_help_options(options, "\nAdvanced Audio options:\n",
3970                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3971                       OPT_AUDIO | OPT_EXPERT);
3972     show_help_options(options, "\nSubtitle options:\n",
3973                       OPT_SUBTITLE | OPT_GRAB,
3974                       OPT_SUBTITLE);
3975     show_help_options(options, "\nAudio/Video grab options:\n",
3976                       OPT_GRAB,
3977                       OPT_GRAB);
3978     printf("\n");
3979     av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3980     printf("\n");
3981
3982     /* individual codec options */
3983     c = NULL;
3984     while ((c = av_codec_next(c))) {
3985         if (c->priv_class) {
3986             av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3987             printf("\n");
3988         }
3989     }
3990
3991     av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3992     printf("\n");
3993
3994     /* individual muxer options */
3995     while ((oformat = av_oformat_next(oformat))) {
3996         if (oformat->priv_class) {
3997             av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
3998             printf("\n");
3999         }
4000     }
4001
4002     av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4003 }
4004
4005 static void opt_target(const char *arg)
4006 {
4007     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4008     static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
4009
4010     if(!strncmp(arg, "pal-", 4)) {
4011         norm = PAL;
4012         arg += 4;
4013     } else if(!strncmp(arg, "ntsc-", 5)) {
4014         norm = NTSC;
4015         arg += 5;
4016     } else if(!strncmp(arg, "film-", 5)) {
4017         norm = FILM;
4018         arg += 5;
4019     } else {
4020         int fr;
4021         /* Calculate FR via float to avoid int overflow */
4022         fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
4023         if(fr == 25000) {
4024             norm = PAL;
4025         } else if((fr == 29970) || (fr == 23976)) {
4026             norm = NTSC;
4027         } else {
4028             /* Try to determine PAL/NTSC by peeking in the input files */
4029             if(nb_input_files) {
4030                 int i, j;
4031                 for(j = 0; j < nb_input_files; j++) {
4032                     for(i = 0; i < input_files[j]->nb_streams; i++) {
4033                         AVCodecContext *c = input_files[j]->streams[i]->codec;
4034                         if(c->codec_type != AVMEDIA_TYPE_VIDEO)
4035                             continue;
4036                         fr = c->time_base.den * 1000 / c->time_base.num;
4037                         if(fr == 25000) {
4038                             norm = PAL;
4039                             break;
4040                         } else if((fr == 29970) || (fr == 23976)) {
4041                             norm = NTSC;
4042                             break;
4043                         }
4044                     }
4045                     if(norm != UNKNOWN)
4046                         break;
4047                 }
4048             }
4049         }
4050         if(verbose && norm != UNKNOWN)
4051             fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4052     }
4053
4054     if(norm == UNKNOWN) {
4055         fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4056         fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4057         fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4058         ffmpeg_exit(1);
4059     }
4060
4061     if(!strcmp(arg, "vcd")) {
4062
4063         opt_video_codec("mpeg1video");
4064         opt_audio_codec("mp2");
4065         opt_format("vcd");
4066
4067         opt_frame_size(norm == PAL ? "352x288" : "352x240");
4068         opt_frame_rate(NULL, frame_rates[norm]);
4069         opt_default("g", norm == PAL ? "15" : "18");
4070
4071         opt_default("b", "1150000");
4072         opt_default("maxrate", "1150000");
4073         opt_default("minrate", "1150000");
4074         opt_default("bufsize", "327680"); // 40*1024*8;
4075
4076         opt_default("ab", "224000");
4077         audio_sample_rate = 44100;
4078         audio_channels = 2;
4079
4080         opt_default("packetsize", "2324");
4081         opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4082
4083         /* We have to offset the PTS, so that it is consistent with the SCR.
4084            SCR starts at 36000, but the first two packs contain only padding
4085            and the first pack from the other stream, respectively, may also have
4086            been written before.
4087            So the real data starts at SCR 36000+3*1200. */
4088         mux_preload= (36000+3*1200) / 90000.0; //0.44
4089     } else if(!strcmp(arg, "svcd")) {
4090
4091         opt_video_codec("mpeg2video");
4092         opt_audio_codec("mp2");
4093         opt_format("svcd");
4094
4095         opt_frame_size(norm == PAL ? "480x576" : "480x480");
4096         opt_frame_rate(NULL, frame_rates[norm]);
4097         opt_default("g", norm == PAL ? "15" : "18");
4098
4099         opt_default("b", "2040000");
4100         opt_default("maxrate", "2516000");
4101         opt_default("minrate", "0"); //1145000;
4102         opt_default("bufsize", "1835008"); //224*1024*8;
4103         opt_default("flags", "+scan_offset");
4104
4105
4106         opt_default("ab", "224000");
4107         audio_sample_rate = 44100;
4108
4109         opt_default("packetsize", "2324");
4110
4111     } else if(!strcmp(arg, "dvd")) {
4112
4113         opt_video_codec("mpeg2video");
4114         opt_audio_codec("ac3");
4115         opt_format("dvd");
4116
4117         opt_frame_size(norm == PAL ? "720x576" : "720x480");
4118         opt_frame_rate(NULL, frame_rates[norm]);
4119         opt_default("g", norm == PAL ? "15" : "18");
4120
4121         opt_default("b", "6000000");
4122         opt_default("maxrate", "9000000");
4123         opt_default("minrate", "0"); //1500000;
4124         opt_default("bufsize", "1835008"); //224*1024*8;
4125
4126         opt_default("packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4127         opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4128
4129         opt_default("ab", "448000");
4130         audio_sample_rate = 48000;
4131
4132     } else if(!strncmp(arg, "dv", 2)) {
4133
4134         opt_format("dv");
4135
4136         opt_frame_size(norm == PAL ? "720x576" : "720x480");
4137         opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
4138                           (norm == PAL ? "yuv420p" : "yuv411p"));
4139         opt_frame_rate(NULL, frame_rates[norm]);
4140
4141         audio_sample_rate = 48000;
4142         audio_channels = 2;
4143
4144     } else {
4145         fprintf(stderr, "Unknown target: %s\n", arg);
4146         ffmpeg_exit(1);
4147     }
4148 }
4149
4150 static void opt_vstats_file (const char *arg)
4151 {
4152     av_free (vstats_filename);
4153     vstats_filename=av_strdup (arg);
4154 }
4155
4156 static void opt_vstats (void)
4157 {
4158     char filename[40];
4159     time_t today2 = time(NULL);
4160     struct tm *today = localtime(&today2);
4161
4162     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4163              today->tm_sec);
4164     opt_vstats_file(filename);
4165 }
4166
4167 static int opt_bsf(const char *opt, const char *arg)
4168 {
4169     AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4170     AVBitStreamFilterContext **bsfp;
4171
4172     if(!bsfc){
4173         fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4174         ffmpeg_exit(1);
4175     }
4176
4177     bsfp= *opt == 'v' ? &video_bitstream_filters :
4178           *opt == 'a' ? &audio_bitstream_filters :
4179                         &subtitle_bitstream_filters;
4180     while(*bsfp)
4181         bsfp= &(*bsfp)->next;
4182
4183     *bsfp= bsfc;
4184
4185     return 0;
4186 }
4187
4188 static int opt_preset(const char *opt, const char *arg)
4189 {
4190     FILE *f=NULL;
4191     char filename[1000], tmp[1000], tmp2[1000], line[1000];
4192     char *codec_name = *opt == 'v' ? video_codec_name :
4193                        *opt == 'a' ? audio_codec_name :
4194                                      subtitle_codec_name;
4195
4196     if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4197         fprintf(stderr, "File for preset '%s' not found\n", arg);
4198         ffmpeg_exit(1);
4199     }
4200
4201     while(!feof(f)){
4202         int e= fscanf(f, "%999[^\n]\n", line) - 1;
4203         if(line[0] == '#' && !e)
4204             continue;
4205         e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4206         if(e){
4207             fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4208             ffmpeg_exit(1);
4209         }
4210         if(!strcmp(tmp, "acodec")){
4211             opt_audio_codec(tmp2);
4212         }else if(!strcmp(tmp, "vcodec")){
4213             opt_video_codec(tmp2);
4214         }else if(!strcmp(tmp, "scodec")){
4215             opt_subtitle_codec(tmp2);
4216         }else if(!strcmp(tmp, "dcodec")){
4217             opt_data_codec(tmp2);
4218         }else if(opt_default(tmp, tmp2) < 0){
4219             fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4220             ffmpeg_exit(1);
4221         }
4222     }
4223
4224     fclose(f);
4225
4226     return 0;
4227 }
4228
4229 static const OptionDef options[] = {
4230     /* main options */
4231 #include "cmdutils_common_opts.h"
4232     { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4233     { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4234     { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4235     { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4236     { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
4237       "outfile[,metadata]:infile[,metadata]" },
4238     { "map_metadata", HAS_ARG | OPT_EXPERT, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4239       "outfile[,metadata]:infile[,metadata]" },
4240     { "map_chapters",  HAS_ARG | OPT_EXPERT, {(void*)opt_map_chapters},  "set chapters mapping", "outfile:infile" },
4241     { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4242     { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4243     { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4244     { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4245     { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
4246     { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4247     { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4248     { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4249     { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4250       "add timings for benchmarking" },
4251     { "timelimit", OPT_FUNC2 | HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4252     { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4253       "dump each input packet" },
4254     { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4255       "when dumping packets, also dump the payload" },
4256     { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4257     { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
4258     { "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)", "" },
4259     { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
4260     { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4261     { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4262     { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4263     { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4264     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4265     { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
4266     { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
4267     { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)&copy_tb}, "copy input stream time base when stream copying" },
4268     { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4269     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4270     { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4271     { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4272     { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)&copy_initial_nonkeyframes}, "copy initial non-keyframes" },
4273
4274     /* video options */
4275     { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4276     { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4277     { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4278     { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4279     { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4280     { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4281     { "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" },
4282     { "croptop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4283     { "cropbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4284     { "cropleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4285     { "cropright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4286     { "padtop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4287     { "padbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4288     { "padleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4289     { "padright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4290     { "padcolor", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4291     { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4292     { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4293     { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4294     { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4295     { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4296     { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4297     { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "threshold" },
4298     { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4299       "use same quantizer as source (implies VBR)" },
4300     { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
4301     { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4302     { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4303       "deinterlace pictures" },
4304     { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4305     { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4306     { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4307 #if CONFIG_AVFILTER
4308     { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4309 #endif
4310     { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4311     { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4312     { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4313     { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4314     { "vtag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4315     { "newvideo", OPT_VIDEO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new video stream to the current output stream" },
4316     { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4317     { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4318     { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4319     { "streamid", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4320     { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4321
4322     /* audio options */
4323     { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4324     { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4325     { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4326     { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4327     { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4328     { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4329     { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4330     { "atag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4331     { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4332     { "newaudio", OPT_AUDIO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
4333     { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4334     { "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" },
4335
4336     /* subtitle options */
4337     { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4338     { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4339     { "newsubtitle", OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4340     { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4341     { "stag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4342
4343     /* grab options */
4344     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4345     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4346     { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4347
4348     /* muxer options */
4349     { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4350     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4351
4352     { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4353     { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4354     { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4355
4356     { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4357     { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4358     { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4359     { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4360     /* data codec support */
4361     { "dcodec", HAS_ARG | OPT_DATA, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4362
4363     { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4364     { NULL, },
4365 };
4366
4367 int main(int argc, char **argv)
4368 {
4369     int64_t ti;
4370
4371     av_log_set_flags(AV_LOG_SKIP_REPEATED);
4372
4373     avcodec_register_all();
4374 #if CONFIG_AVDEVICE
4375     avdevice_register_all();
4376 #endif
4377 #if CONFIG_AVFILTER
4378     avfilter_register_all();
4379 #endif
4380     av_register_all();
4381
4382 #if HAVE_ISATTY
4383     if(isatty(STDIN_FILENO))
4384         avio_set_interrupt_cb(decode_interrupt_cb);
4385 #endif
4386
4387     init_opts();
4388
4389     show_banner();
4390
4391     /* parse options */
4392     parse_options(argc, argv, options, opt_output_file);
4393
4394     if(nb_output_files <= 0 && nb_input_files == 0) {
4395         show_usage();
4396         fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4397         ffmpeg_exit(1);
4398     }
4399
4400     /* file converter / grab */
4401     if (nb_output_files <= 0) {
4402         fprintf(stderr, "At least one output file must be specified\n");
4403         ffmpeg_exit(1);
4404     }
4405
4406     if (nb_input_files == 0) {
4407         fprintf(stderr, "At least one input file must be specified\n");
4408         ffmpeg_exit(1);
4409     }
4410
4411     ti = getutime();
4412     if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4413                   stream_maps, nb_stream_maps) < 0)
4414         ffmpeg_exit(1);
4415     ti = getutime() - ti;
4416     if (do_benchmark) {
4417         int maxrss = getmaxrss() / 1024;
4418         printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4419     }
4420
4421     return ffmpeg_exit(0);
4422 }