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

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