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