ffmpeg.c

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