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