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