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