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

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