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