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

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