ffmpeg.c

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