ffmpeg.c

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