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