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

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