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