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

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