ffmpeg.c

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