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