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