git.sesse.net Git - ffmpeg/blob - ffmpeg.c

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