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

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