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