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

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