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