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