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;
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         while ((t = av_metadata_get(ist->st->metadata, "", t, AV_METADATA_IGNORE_SUFFIX))) {
1926             av_metadata_set2(&ost->st->metadata, t->key, t->value, AV_METADATA_DONT_OVERWRITE);
1927         }
1928
1929         ost->st->disposition = ist->st->disposition;
1930         codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
1931         codec->chroma_sample_location = icodec->chroma_sample_location;
1932
1933         if (ost->st->stream_copy) {
1934             /* if stream_copy is selected, no need to decode or encode */
1935             codec->codec_id = icodec->codec_id;
1936             codec->codec_type = icodec->codec_type;
1937
1938             if(!codec->codec_tag){
1939                 if(   !os->oformat->codec_tag
1940                    || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
1941                    || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1942                     codec->codec_tag = icodec->codec_tag;
1943             }
1944
1945             codec->bit_rate = icodec->bit_rate;
1946             codec->extradata= icodec->extradata;
1947             codec->extradata_size= icodec->extradata_size;
1948             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){
1949                 codec->time_base = icodec->time_base;
1950                 codec->time_base.num *= icodec->ticks_per_frame;
1951             }else
1952                 codec->time_base = ist->st->time_base;
1953             switch(codec->codec_type) {
1954             case AVMEDIA_TYPE_AUDIO:
1955                 if(audio_volume != 256) {
1956                     fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
1957                     av_exit(1);
1958                 }
1959                 codec->channel_layout = icodec->channel_layout;
1960                 codec->sample_rate = icodec->sample_rate;
1961                 codec->channels = icodec->channels;
1962                 codec->frame_size = icodec->frame_size;
1963                 codec->block_align= icodec->block_align;
1964                 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
1965                     codec->block_align= 0;
1966                 if(codec->codec_id == CODEC_ID_AC3)
1967                     codec->block_align= 0;
1968                 break;
1969             case AVMEDIA_TYPE_VIDEO:
1970                 codec->pix_fmt = icodec->pix_fmt;
1971                 codec->width = icodec->width;
1972                 codec->height = icodec->height;
1973                 codec->has_b_frames = icodec->has_b_frames;
1974                 break;
1975             case AVMEDIA_TYPE_SUBTITLE:
1976                 codec->width = icodec->width;
1977                 codec->height = icodec->height;
1978                 break;
1979             default:
1980                 abort();
1981             }
1982         } else {
1983             switch(codec->codec_type) {
1984             case AVMEDIA_TYPE_AUDIO:
1985                 ost->fifo= av_fifo_alloc(1024);
1986                 if(!ost->fifo)
1987                     goto fail;
1988                 ost->reformat_pair = MAKE_SFMT_PAIR(SAMPLE_FMT_NONE,SAMPLE_FMT_NONE);
1989                 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
1990                 icodec->request_channels = codec->channels;
1991                 ist->decoding_needed = 1;
1992                 ost->encoding_needed = 1;
1993                 break;
1994             case AVMEDIA_TYPE_VIDEO:
1995                 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
1996                     fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
1997                     av_exit(1);
1998                 }
1999                 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
2000                 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
2001                 ost->video_resample = ((codec->width != icodec->width -
2002                                 (frame_leftBand + frame_rightBand) +
2003                                 (frame_padleft + frame_padright)) ||
2004                         (codec->height != icodec->height -
2005                                 (frame_topBand  + frame_bottomBand) +
2006                                 (frame_padtop + frame_padbottom)) ||
2007                         (codec->pix_fmt != icodec->pix_fmt));
2008                 if (ost->video_crop) {
2009                     ost->topBand    = ost->original_topBand    = frame_topBand;
2010                     ost->bottomBand = ost->original_bottomBand = frame_bottomBand;
2011                     ost->leftBand   = ost->original_leftBand   = frame_leftBand;
2012                     ost->rightBand  = ost->original_rightBand  = frame_rightBand;
2013                 }
2014                 if (ost->video_pad) {
2015                     ost->padtop = frame_padtop;
2016                     ost->padleft = frame_padleft;
2017                     ost->padbottom = frame_padbottom;
2018                     ost->padright = frame_padright;
2019                     if (!ost->video_resample) {
2020                         avcodec_get_frame_defaults(&ost->pict_tmp);
2021                         if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2022                                          codec->width, codec->height))
2023                             goto fail;
2024                     }
2025                 }
2026                 if (ost->video_resample) {
2027                     avcodec_get_frame_defaults(&ost->pict_tmp);
2028                     if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2029                                          codec->width, codec->height)) {
2030                         fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
2031                         av_exit(1);
2032                     }
2033                     sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
2034                     ost->img_resample_ctx = sws_getContext(
2035                             icodec->width - (frame_leftBand + frame_rightBand),
2036                             icodec->height - (frame_topBand + frame_bottomBand),
2037                             icodec->pix_fmt,
2038                             codec->width - (frame_padleft + frame_padright),
2039                             codec->height - (frame_padtop + frame_padbottom),
2040                             codec->pix_fmt,
2041                             sws_flags, NULL, NULL, NULL);
2042                     if (ost->img_resample_ctx == NULL) {
2043                         fprintf(stderr, "Cannot get resampling context\n");
2044                         av_exit(1);
2045                     }
2046
2047                     ost->original_height = icodec->height;
2048                     ost->original_width  = icodec->width;
2049
2050                     codec->bits_per_raw_sample= 0;
2051                 }
2052                 ost->resample_height = icodec->height - (frame_topBand  + frame_bottomBand);
2053                 ost->resample_width  = icodec->width  - (frame_leftBand + frame_rightBand);
2054                 ost->resample_pix_fmt= icodec->pix_fmt;
2055                 ost->encoding_needed = 1;
2056                 ist->decoding_needed = 1;
2057                 break;
2058             case AVMEDIA_TYPE_SUBTITLE:
2059                 ost->encoding_needed = 1;
2060                 ist->decoding_needed = 1;
2061                 break;
2062             default:
2063                 abort();
2064                 break;
2065             }
2066             /* two pass mode */
2067             if (ost->encoding_needed &&
2068                 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2069                 char logfilename[1024];
2070                 FILE *f;
2071
2072                 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2073                          pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2074                          i);
2075                 if (codec->flags & CODEC_FLAG_PASS1) {
2076                     f = fopen(logfilename, "w");
2077                     if (!f) {
2078                         fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2079                         av_exit(1);
2080                     }
2081                     ost->logfile = f;
2082                 } else {
2083                     char  *logbuffer;
2084                     size_t logbuffer_size;
2085                     if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2086                         fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2087                         av_exit(1);
2088                     }
2089                     codec->stats_in = logbuffer;
2090                 }
2091             }
2092         }
2093         if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2094             int size= codec->width * codec->height;
2095             bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2096         }
2097     }
2098
2099     if (!bit_buffer)
2100         bit_buffer = av_malloc(bit_buffer_size);
2101     if (!bit_buffer) {
2102         fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2103                 bit_buffer_size);
2104         ret = AVERROR(ENOMEM);
2105         goto fail;
2106     }
2107
2108     /* open each encoder */
2109     for(i=0;i<nb_ostreams;i++) {
2110         ost = ost_table[i];
2111         if (ost->encoding_needed) {
2112             AVCodec *codec = output_codecs[i];
2113             if (!codec)
2114                 codec = avcodec_find_encoder(ost->st->codec->codec_id);
2115             if (!codec) {
2116                 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2117                          ost->st->codec->codec_id, ost->file_index, ost->index);
2118                 ret = AVERROR(EINVAL);
2119                 goto dump_format;
2120             }
2121             if (avcodec_open(ost->st->codec, codec) < 0) {
2122                 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2123                         ost->file_index, ost->index);
2124                 ret = AVERROR(EINVAL);
2125                 goto dump_format;
2126             }
2127             extra_size += ost->st->codec->extradata_size;
2128         }
2129     }
2130
2131     /* open each decoder */
2132     for(i=0;i<nb_istreams;i++) {
2133         ist = ist_table[i];
2134         if (ist->decoding_needed) {
2135             AVCodec *codec = input_codecs[i];
2136             if (!codec)
2137                 codec = avcodec_find_decoder(ist->st->codec->codec_id);
2138             if (!codec) {
2139                 snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2140                         ist->st->codec->codec_id, ist->file_index, ist->index);
2141                 ret = AVERROR(EINVAL);
2142                 goto dump_format;
2143             }
2144             if (avcodec_open(ist->st->codec, codec) < 0) {
2145                 snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2146                         ist->file_index, ist->index);
2147                 ret = AVERROR(EINVAL);
2148                 goto dump_format;
2149             }
2150             //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2151             //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2152         }
2153     }
2154
2155     /* init pts */
2156     for(i=0;i<nb_istreams;i++) {
2157         AVStream *st;
2158         ist = ist_table[i];
2159         st= ist->st;
2160         ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2161         ist->next_pts = AV_NOPTS_VALUE;
2162         ist->is_start = 1;
2163     }
2164
2165     /* set meta data information from input file if required */
2166     for (i=0;i<nb_meta_data_maps;i++) {
2167         AVFormatContext *out_file;
2168         AVFormatContext *in_file;
2169         AVMetadataTag *mtag;
2170
2171         int out_file_index = meta_data_maps[i].out_file;
2172         int in_file_index = meta_data_maps[i].in_file;
2173         if (out_file_index < 0 || out_file_index >= nb_output_files) {
2174             snprintf(error, sizeof(error), "Invalid output file index %d map_meta_data(%d,%d)",
2175                      out_file_index, out_file_index, in_file_index);
2176             ret = AVERROR(EINVAL);
2177             goto dump_format;
2178         }
2179         if (in_file_index < 0 || in_file_index >= nb_input_files) {
2180             snprintf(error, sizeof(error), "Invalid input file index %d map_meta_data(%d,%d)",
2181                      in_file_index, out_file_index, in_file_index);
2182             ret = AVERROR(EINVAL);
2183             goto dump_format;
2184         }
2185
2186         out_file = output_files[out_file_index];
2187         in_file = input_files[in_file_index];
2188
2189
2190         mtag=NULL;
2191         while((mtag=av_metadata_get(in_file->metadata, "", mtag, AV_METADATA_IGNORE_SUFFIX)))
2192             av_metadata_set2(&out_file->metadata, mtag->key, mtag->value, AV_METADATA_DONT_OVERWRITE);
2193         av_metadata_conv(out_file, out_file->oformat->metadata_conv,
2194                                     in_file->iformat->metadata_conv);
2195     }
2196
2197     /* copy chapters from the first input file that has them*/
2198     for (i = 0; i < nb_input_files; i++) {
2199         if (!input_files[i]->nb_chapters)
2200             continue;
2201
2202         for (j = 0; j < nb_output_files; j++)
2203             if ((ret = copy_chapters(i, j)) < 0)
2204                 goto dump_format;
2205     }
2206
2207     /* open files and write file headers */
2208     for(i=0;i<nb_output_files;i++) {
2209         os = output_files[i];
2210         if (av_write_header(os) < 0) {
2211             snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2212             ret = AVERROR(EINVAL);
2213             goto dump_format;
2214         }
2215         if (strcmp(output_files[i]->oformat->name, "rtp")) {
2216             want_sdp = 0;
2217         }
2218     }
2219
2220  dump_format:
2221     /* dump the file output parameters - cannot be done before in case
2222        of stream copy */
2223     for(i=0;i<nb_output_files;i++) {
2224         dump_format(output_files[i], i, output_files[i]->filename, 1);
2225     }
2226
2227     /* dump the stream mapping */
2228     if (verbose >= 0) {
2229         fprintf(stderr, "Stream mapping:\n");
2230         for(i=0;i<nb_ostreams;i++) {
2231             ost = ost_table[i];
2232             fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
2233                     ist_table[ost->source_index]->file_index,
2234                     ist_table[ost->source_index]->index,
2235                     ost->file_index,
2236                     ost->index);
2237             if (ost->sync_ist != ist_table[ost->source_index])
2238                 fprintf(stderr, " [sync #%d.%d]",
2239                         ost->sync_ist->file_index,
2240                         ost->sync_ist->index);
2241             fprintf(stderr, "\n");
2242         }
2243     }
2244
2245     if (ret) {
2246         fprintf(stderr, "%s\n", error);
2247         goto fail;
2248     }
2249
2250     if (want_sdp) {
2251         print_sdp(output_files, nb_output_files);
2252     }
2253
2254     if (!using_stdin && verbose >= 0) {
2255         fprintf(stderr, "Press [q] to stop encoding\n");
2256         url_set_interrupt_cb(decode_interrupt_cb);
2257     }
2258     term_init();
2259
2260     timer_start = av_gettime();
2261
2262     for(; received_sigterm == 0;) {
2263         int file_index, ist_index;
2264         AVPacket pkt;
2265         double ipts_min;
2266         double opts_min;
2267
2268     redo:
2269         ipts_min= 1e100;
2270         opts_min= 1e100;
2271         /* if 'q' pressed, exits */
2272         if (!using_stdin) {
2273             if (q_pressed)
2274                 break;
2275             /* read_key() returns 0 on EOF */
2276             key = read_key();
2277             if (key == 'q')
2278                 break;
2279         }
2280
2281         /* select the stream that we must read now by looking at the
2282            smallest output pts */
2283         file_index = -1;
2284         for(i=0;i<nb_ostreams;i++) {
2285             double ipts, opts;
2286             ost = ost_table[i];
2287             os = output_files[ost->file_index];
2288             ist = ist_table[ost->source_index];
2289             if(ist->is_past_recording_time || no_packet[ist->file_index])
2290                 continue;
2291                 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2292             ipts = (double)ist->pts;
2293             if (!file_table[ist->file_index].eof_reached){
2294                 if(ipts < ipts_min) {
2295                     ipts_min = ipts;
2296                     if(input_sync ) file_index = ist->file_index;
2297                 }
2298                 if(opts < opts_min) {
2299                     opts_min = opts;
2300                     if(!input_sync) file_index = ist->file_index;
2301                 }
2302             }
2303             if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2304                 file_index= -1;
2305                 break;
2306             }
2307         }
2308         /* if none, if is finished */
2309         if (file_index < 0) {
2310             if(no_packet_count){
2311                 no_packet_count=0;
2312                 memset(no_packet, 0, sizeof(no_packet));
2313                 usleep(10000);
2314                 continue;
2315             }
2316             break;
2317         }
2318
2319         /* finish if limit size exhausted */
2320         if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2321             break;
2322
2323         /* read a frame from it and output it in the fifo */
2324         is = input_files[file_index];
2325         ret= av_read_frame(is, &pkt);
2326         if(ret == AVERROR(EAGAIN)){
2327             no_packet[file_index]=1;
2328             no_packet_count++;
2329             continue;
2330         }
2331         if (ret < 0) {
2332             file_table[file_index].eof_reached = 1;
2333             if (opt_shortest)
2334                 break;
2335             else
2336                 continue;
2337         }
2338
2339         no_packet_count=0;
2340         memset(no_packet, 0, sizeof(no_packet));
2341
2342         if (do_pkt_dump) {
2343             av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2344         }
2345         /* the following test is needed in case new streams appear
2346            dynamically in stream : we ignore them */
2347         if (pkt.stream_index >= file_table[file_index].nb_streams)
2348             goto discard_packet;
2349         ist_index = file_table[file_index].ist_index + pkt.stream_index;
2350         ist = ist_table[ist_index];
2351         if (ist->discard)
2352             goto discard_packet;
2353
2354         if (pkt.dts != AV_NOPTS_VALUE)
2355             pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2356         if (pkt.pts != AV_NOPTS_VALUE)
2357             pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2358
2359         if(input_files_ts_scale[file_index][pkt.stream_index]){
2360             if(pkt.pts != AV_NOPTS_VALUE)
2361                 pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2362             if(pkt.dts != AV_NOPTS_VALUE)
2363                 pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2364         }
2365
2366 //        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);
2367         if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2368             && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2369             int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2370             int64_t delta= pkt_dts - ist->next_pts;
2371             if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2372                 input_files_ts_offset[ist->file_index]-= delta;
2373                 if (verbose > 2)
2374                     fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2375                 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2376                 if(pkt.pts != AV_NOPTS_VALUE)
2377                     pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2378             }
2379         }
2380
2381         /* finish if recording time exhausted */
2382         if (recording_time != INT64_MAX &&
2383             av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2384             ist->is_past_recording_time = 1;
2385             goto discard_packet;
2386         }
2387
2388         //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
2389         if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2390
2391             if (verbose >= 0)
2392                 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2393                         ist->file_index, ist->index);
2394             if (exit_on_error)
2395                 av_exit(1);
2396             av_free_packet(&pkt);
2397             goto redo;
2398         }
2399
2400     discard_packet:
2401         av_free_packet(&pkt);
2402
2403         /* dump report by using the output first video and audio streams */
2404         print_report(output_files, ost_table, nb_ostreams, 0);
2405     }
2406
2407     /* at the end of stream, we must flush the decoder buffers */
2408     for(i=0;i<nb_istreams;i++) {
2409         ist = ist_table[i];
2410         if (ist->decoding_needed) {
2411             output_packet(ist, i, ost_table, nb_ostreams, NULL);
2412         }
2413     }
2414
2415     term_exit();
2416
2417     /* write the trailer if needed and close file */
2418     for(i=0;i<nb_output_files;i++) {
2419         os = output_files[i];
2420         av_write_trailer(os);
2421     }
2422
2423     /* dump report by using the first video and audio streams */
2424     print_report(output_files, ost_table, nb_ostreams, 1);
2425
2426     /* close each encoder */
2427     for(i=0;i<nb_ostreams;i++) {
2428         ost = ost_table[i];
2429         if (ost->encoding_needed) {
2430             av_freep(&ost->st->codec->stats_in);
2431             avcodec_close(ost->st->codec);
2432         }
2433     }
2434
2435     /* close each decoder */
2436     for(i=0;i<nb_istreams;i++) {
2437         ist = ist_table[i];
2438         if (ist->decoding_needed) {
2439             avcodec_close(ist->st->codec);
2440         }
2441     }
2442
2443     /* finished ! */
2444     ret = 0;
2445
2446  fail:
2447     av_freep(&bit_buffer);
2448     av_free(file_table);
2449
2450     if (ist_table) {
2451         for(i=0;i<nb_istreams;i++) {
2452             ist = ist_table[i];
2453             av_free(ist);
2454         }
2455         av_free(ist_table);
2456     }
2457     if (ost_table) {
2458         for(i=0;i<nb_ostreams;i++) {
2459             ost = ost_table[i];
2460             if (ost) {
2461                 if (ost->logfile) {
2462                     fclose(ost->logfile);
2463                     ost->logfile = NULL;
2464                 }
2465                 av_fifo_free(ost->fifo); /* works even if fifo is not
2466                                              initialized but set to zero */
2467                 av_free(ost->pict_tmp.data[0]);
2468                 if (ost->video_resample)
2469                     sws_freeContext(ost->img_resample_ctx);
2470                 if (ost->resample)
2471                     audio_resample_close(ost->resample);
2472                 if (ost->reformat_ctx)
2473                     av_audio_convert_free(ost->reformat_ctx);
2474                 av_free(ost);
2475             }
2476         }
2477         av_free(ost_table);
2478     }
2479     return ret;
2480 }
2481
2482 static void opt_format(const char *arg)
2483 {
2484     /* compatibility stuff for pgmyuv */
2485     if (!strcmp(arg, "pgmyuv")) {
2486         pgmyuv_compatibility_hack=1;
2487 //        opt_image_format(arg);
2488         arg = "image2";
2489         fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2490     }
2491
2492     last_asked_format = arg;
2493 }
2494
2495 static void opt_video_rc_override_string(const char *arg)
2496 {
2497     video_rc_override_string = arg;
2498 }
2499
2500 static int opt_me_threshold(const char *opt, const char *arg)
2501 {
2502     me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2503     return 0;
2504 }
2505
2506 static int opt_verbose(const char *opt, const char *arg)
2507 {
2508     verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2509     return 0;
2510 }
2511
2512 static int opt_frame_rate(const char *opt, const char *arg)
2513 {
2514     if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2515         fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2516         av_exit(1);
2517     }
2518     return 0;
2519 }
2520
2521 static int opt_bitrate(const char *opt, const char *arg)
2522 {
2523     int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2524
2525     opt_default(opt, arg);
2526
2527     if (av_get_int(avcodec_opts[codec_type], "b", NULL) < 1000)
2528         fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2529
2530     return 0;
2531 }
2532
2533 static void opt_frame_crop_top(const char *arg)
2534 {
2535     frame_topBand = atoi(arg);
2536     if (frame_topBand < 0) {
2537         fprintf(stderr, "Incorrect top crop size\n");
2538         av_exit(1);
2539     }
2540     if ((frame_topBand) >= frame_height){
2541         fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2542         av_exit(1);
2543     }
2544     frame_height -= frame_topBand;
2545 }
2546
2547 static void opt_frame_crop_bottom(const char *arg)
2548 {
2549     frame_bottomBand = atoi(arg);
2550     if (frame_bottomBand < 0) {
2551         fprintf(stderr, "Incorrect bottom crop size\n");
2552         av_exit(1);
2553     }
2554     if ((frame_bottomBand) >= frame_height){
2555         fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2556         av_exit(1);
2557     }
2558     frame_height -= frame_bottomBand;
2559 }
2560
2561 static void opt_frame_crop_left(const char *arg)
2562 {
2563     frame_leftBand = atoi(arg);
2564     if (frame_leftBand < 0) {
2565         fprintf(stderr, "Incorrect left crop size\n");
2566         av_exit(1);
2567     }
2568     if ((frame_leftBand) >= frame_width){
2569         fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2570         av_exit(1);
2571     }
2572     frame_width -= frame_leftBand;
2573 }
2574
2575 static void opt_frame_crop_right(const char *arg)
2576 {
2577     frame_rightBand = atoi(arg);
2578     if (frame_rightBand < 0) {
2579         fprintf(stderr, "Incorrect right crop size\n");
2580         av_exit(1);
2581     }
2582     if ((frame_rightBand) >= frame_width){
2583         fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2584         av_exit(1);
2585     }
2586     frame_width -= frame_rightBand;
2587 }
2588
2589 static void opt_frame_size(const char *arg)
2590 {
2591     if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2592         fprintf(stderr, "Incorrect frame size\n");
2593         av_exit(1);
2594     }
2595 }
2596
2597 static void opt_pad_color(const char *arg) {
2598     /* Input is expected to be six hex digits similar to
2599        how colors are expressed in html tags (but without the #) */
2600     int rgb = strtol(arg, NULL, 16);
2601     int r,g,b;
2602
2603     r = (rgb >> 16);
2604     g = ((rgb >> 8) & 255);
2605     b = (rgb & 255);
2606
2607     padcolor[0] = RGB_TO_Y(r,g,b);
2608     padcolor[1] = RGB_TO_U(r,g,b,0);
2609     padcolor[2] = RGB_TO_V(r,g,b,0);
2610 }
2611
2612 static void opt_frame_pad_top(const char *arg)
2613 {
2614     frame_padtop = atoi(arg);
2615     if (frame_padtop < 0) {
2616         fprintf(stderr, "Incorrect top pad size\n");
2617         av_exit(1);
2618     }
2619 }
2620
2621 static void opt_frame_pad_bottom(const char *arg)
2622 {
2623     frame_padbottom = atoi(arg);
2624     if (frame_padbottom < 0) {
2625         fprintf(stderr, "Incorrect bottom pad size\n");
2626         av_exit(1);
2627     }
2628 }
2629
2630
2631 static void opt_frame_pad_left(const char *arg)
2632 {
2633     frame_padleft = atoi(arg);
2634     if (frame_padleft < 0) {
2635         fprintf(stderr, "Incorrect left pad size\n");
2636         av_exit(1);
2637     }
2638 }
2639
2640
2641 static void opt_frame_pad_right(const char *arg)
2642 {
2643     frame_padright = atoi(arg);
2644     if (frame_padright < 0) {
2645         fprintf(stderr, "Incorrect right pad size\n");
2646         av_exit(1);
2647     }
2648 }
2649
2650 static void opt_frame_pix_fmt(const char *arg)
2651 {
2652     if (strcmp(arg, "list")) {
2653         frame_pix_fmt = av_get_pix_fmt(arg);
2654         if (frame_pix_fmt == PIX_FMT_NONE) {
2655             fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2656             av_exit(1);
2657         }
2658     } else {
2659         show_pix_fmts();
2660         av_exit(0);
2661     }
2662 }
2663
2664 static void opt_frame_aspect_ratio(const char *arg)
2665 {
2666     int x = 0, y = 0;
2667     double ar = 0;
2668     const char *p;
2669     char *end;
2670
2671     p = strchr(arg, ':');
2672     if (p) {
2673         x = strtol(arg, &end, 10);
2674         if (end == p)
2675             y = strtol(end+1, &end, 10);
2676         if (x > 0 && y > 0)
2677             ar = (double)x / (double)y;
2678     } else
2679         ar = strtod(arg, NULL);
2680
2681     if (!ar) {
2682         fprintf(stderr, "Incorrect aspect ratio specification.\n");
2683         av_exit(1);
2684     }
2685     frame_aspect_ratio = ar;
2686 }
2687
2688 static int opt_metadata(const char *opt, const char *arg)
2689 {
2690     char *mid= strchr(arg, '=');
2691
2692     if(!mid){
2693         fprintf(stderr, "Missing =\n");
2694         av_exit(1);
2695     }
2696     *mid++= 0;
2697
2698     metadata_count++;
2699     metadata= av_realloc(metadata, sizeof(*metadata)*metadata_count);
2700     metadata[metadata_count-1].key  = av_strdup(arg);
2701     metadata[metadata_count-1].value= av_strdup(mid);
2702
2703     return 0;
2704 }
2705
2706 static void opt_qscale(const char *arg)
2707 {
2708     video_qscale = atof(arg);
2709     if (video_qscale <= 0 ||
2710         video_qscale > 255) {
2711         fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2712         av_exit(1);
2713     }
2714 }
2715
2716 static void opt_top_field_first(const char *arg)
2717 {
2718     top_field_first= atoi(arg);
2719 }
2720
2721 static int opt_thread_count(const char *opt, const char *arg)
2722 {
2723     thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2724 #if !HAVE_THREADS
2725     if (verbose >= 0)
2726         fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2727 #endif
2728     return 0;
2729 }
2730
2731 static void opt_audio_sample_fmt(const char *arg)
2732 {
2733     if (strcmp(arg, "list"))
2734         audio_sample_fmt = avcodec_get_sample_fmt(arg);
2735     else {
2736         list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
2737         av_exit(0);
2738     }
2739 }
2740
2741 static int opt_audio_rate(const char *opt, const char *arg)
2742 {
2743     audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2744     return 0;
2745 }
2746
2747 static int opt_audio_channels(const char *opt, const char *arg)
2748 {
2749     audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2750     return 0;
2751 }
2752
2753 static void opt_video_channel(const char *arg)
2754 {
2755     video_channel = strtol(arg, NULL, 0);
2756 }
2757
2758 static void opt_video_standard(const char *arg)
2759 {
2760     video_standard = av_strdup(arg);
2761 }
2762
2763 static void opt_codec(int *pstream_copy, char **pcodec_name,
2764                       int codec_type, const char *arg)
2765 {
2766     av_freep(pcodec_name);
2767     if (!strcmp(arg, "copy")) {
2768         *pstream_copy = 1;
2769     } else {
2770         *pcodec_name = av_strdup(arg);
2771     }
2772 }
2773
2774 static void opt_audio_codec(const char *arg)
2775 {
2776     opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2777 }
2778
2779 static void opt_audio_tag(const char *arg)
2780 {
2781     char *tail;
2782     audio_codec_tag= strtol(arg, &tail, 0);
2783
2784     if(!tail || *tail)
2785         audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2786 }
2787
2788 static void opt_video_tag(const char *arg)
2789 {
2790     char *tail;
2791     video_codec_tag= strtol(arg, &tail, 0);
2792
2793     if(!tail || *tail)
2794         video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2795 }
2796
2797 static void opt_video_codec(const char *arg)
2798 {
2799     opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2800 }
2801
2802 static void opt_subtitle_codec(const char *arg)
2803 {
2804     opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2805 }
2806
2807 static void opt_subtitle_tag(const char *arg)
2808 {
2809     char *tail;
2810     subtitle_codec_tag= strtol(arg, &tail, 0);
2811
2812     if(!tail || *tail)
2813         subtitle_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2814 }
2815
2816 static void opt_map(const char *arg)
2817 {
2818     AVStreamMap *m;
2819     char *p;
2820
2821     m = &stream_maps[nb_stream_maps++];
2822
2823     m->file_index = strtol(arg, &p, 0);
2824     if (*p)
2825         p++;
2826
2827     m->stream_index = strtol(p, &p, 0);
2828     if (*p) {
2829         p++;
2830         m->sync_file_index = strtol(p, &p, 0);
2831         if (*p)
2832             p++;
2833         m->sync_stream_index = strtol(p, &p, 0);
2834     } else {
2835         m->sync_file_index = m->file_index;
2836         m->sync_stream_index = m->stream_index;
2837     }
2838 }
2839
2840 static void opt_map_meta_data(const char *arg)
2841 {
2842     AVMetaDataMap *m;
2843     char *p;
2844
2845     m = &meta_data_maps[nb_meta_data_maps++];
2846
2847     m->out_file = strtol(arg, &p, 0);
2848     if (*p)
2849         p++;
2850
2851     m->in_file = strtol(p, &p, 0);
2852 }
2853
2854 static void opt_input_ts_scale(const char *arg)
2855 {
2856     unsigned int stream;
2857     double scale;
2858     char *p;
2859
2860     stream = strtol(arg, &p, 0);
2861     if (*p)
2862         p++;
2863     scale= strtod(p, &p);
2864
2865     if(stream >= MAX_STREAMS)
2866         av_exit(1);
2867
2868     input_files_ts_scale[nb_input_files][stream]= scale;
2869 }
2870
2871 static int opt_recording_time(const char *opt, const char *arg)
2872 {
2873     recording_time = parse_time_or_die(opt, arg, 1);
2874     return 0;
2875 }
2876
2877 static int opt_start_time(const char *opt, const char *arg)
2878 {
2879     start_time = parse_time_or_die(opt, arg, 1);
2880     return 0;
2881 }
2882
2883 static int opt_rec_timestamp(const char *opt, const char *arg)
2884 {
2885     rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2886     return 0;
2887 }
2888
2889 static int opt_input_ts_offset(const char *opt, const char *arg)
2890 {
2891     input_ts_offset = parse_time_or_die(opt, arg, 1);
2892     return 0;
2893 }
2894
2895 static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2896 {
2897     const char *codec_string = encoder ? "encoder" : "decoder";
2898     AVCodec *codec;
2899
2900     if(!name)
2901         return CODEC_ID_NONE;
2902     codec = encoder ?
2903         avcodec_find_encoder_by_name(name) :
2904         avcodec_find_decoder_by_name(name);
2905     if(!codec) {
2906         fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
2907         av_exit(1);
2908     }
2909     if(codec->type != type) {
2910         fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
2911         av_exit(1);
2912     }
2913     return codec->id;
2914 }
2915
2916 static void opt_input_file(const char *filename)
2917 {
2918     AVFormatContext *ic;
2919     AVFormatParameters params, *ap = &params;
2920     AVInputFormat *file_iformat = NULL;
2921     int err, i, ret, rfps, rfps_base;
2922     int64_t timestamp;
2923
2924     if (last_asked_format) {
2925         if (!(file_iformat = av_find_input_format(last_asked_format))) {
2926             fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
2927             av_exit(1);
2928         }
2929         last_asked_format = NULL;
2930     }
2931
2932     if (!strcmp(filename, "-"))
2933         filename = "pipe:";
2934
2935     using_stdin |= !strncmp(filename, "pipe:", 5) ||
2936                     !strcmp(filename, "/dev/stdin");
2937
2938     /* get default parameters from command line */
2939     ic = avformat_alloc_context();
2940     if (!ic) {
2941         print_error(filename, AVERROR(ENOMEM));
2942         av_exit(1);
2943     }
2944
2945     memset(ap, 0, sizeof(*ap));
2946     ap->prealloced_context = 1;
2947     ap->sample_rate = audio_sample_rate;
2948     ap->channels = audio_channels;
2949     ap->time_base.den = frame_rate.num;
2950     ap->time_base.num = frame_rate.den;
2951     ap->width = frame_width + frame_padleft + frame_padright;
2952     ap->height = frame_height + frame_padtop + frame_padbottom;
2953     ap->pix_fmt = frame_pix_fmt;
2954    // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
2955     ap->channel = video_channel;
2956     ap->standard = video_standard;
2957
2958     set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2959
2960     ic->video_codec_id   = find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0);
2961     ic->audio_codec_id   = find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0);
2962     ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0);
2963     ic->flags |= AVFMT_FLAG_NONBLOCK;
2964
2965     if(pgmyuv_compatibility_hack)
2966         ic->video_codec_id= CODEC_ID_PGMYUV;
2967
2968     /* open the input file with generic libav function */
2969     err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2970     if (err < 0) {
2971         print_error(filename, err);
2972         av_exit(1);
2973     }
2974     if(opt_programid) {
2975         int i, j;
2976         int found=0;
2977         for(i=0; i<ic->nb_streams; i++){
2978             ic->streams[i]->discard= AVDISCARD_ALL;
2979         }
2980         for(i=0; i<ic->nb_programs; i++){
2981             AVProgram *p= ic->programs[i];
2982             if(p->id != opt_programid){
2983                 p->discard = AVDISCARD_ALL;
2984             }else{
2985                 found=1;
2986                 for(j=0; j<p->nb_stream_indexes; j++){
2987                     ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
2988                 }
2989             }
2990         }
2991         if(!found){
2992             fprintf(stderr, "Specified program id not found\n");
2993             av_exit(1);
2994         }
2995         opt_programid=0;
2996     }
2997
2998     ic->loop_input = loop_input;
2999
3000     /* If not enough info to get the stream parameters, we decode the
3001        first frames to get it. (used in mpeg case for example) */
3002     ret = av_find_stream_info(ic);
3003     if (ret < 0 && verbose >= 0) {
3004         fprintf(stderr, "%s: could not find codec parameters\n", filename);
3005         av_exit(1);
3006     }
3007
3008     timestamp = start_time;
3009     /* add the stream start time */
3010     if (ic->start_time != AV_NOPTS_VALUE)
3011         timestamp += ic->start_time;
3012
3013     /* if seeking requested, we execute it */
3014     if (start_time != 0) {
3015         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3016         if (ret < 0) {
3017             fprintf(stderr, "%s: could not seek to position %0.3f\n",
3018                     filename, (double)timestamp / AV_TIME_BASE);
3019         }
3020         /* reset seek info */
3021         start_time = 0;
3022     }
3023
3024     /* update the current parameters so that they match the one of the input stream */
3025     for(i=0;i<ic->nb_streams;i++) {
3026         AVStream *st = ic->streams[i];
3027         AVCodecContext *enc = st->codec;
3028         avcodec_thread_init(enc, thread_count);
3029         switch(enc->codec_type) {
3030         case AVMEDIA_TYPE_AUDIO:
3031             set_context_opts(enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
3032             //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
3033             channel_layout = enc->channel_layout;
3034             audio_channels = enc->channels;
3035             audio_sample_rate = enc->sample_rate;
3036             audio_sample_fmt = enc->sample_fmt;
3037             input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(audio_codec_name);
3038             if(audio_disable)
3039                 st->discard= AVDISCARD_ALL;
3040             break;
3041         case AVMEDIA_TYPE_VIDEO:
3042             set_context_opts(enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
3043             frame_height = enc->height;
3044             frame_width = enc->width;
3045             if(ic->streams[i]->sample_aspect_ratio.num)
3046                 frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
3047             else
3048                 frame_aspect_ratio=av_q2d(enc->sample_aspect_ratio);
3049             frame_aspect_ratio *= (float) enc->width / enc->height;
3050             frame_pix_fmt = enc->pix_fmt;
3051             rfps      = ic->streams[i]->r_frame_rate.num;
3052             rfps_base = ic->streams[i]->r_frame_rate.den;
3053             if(enc->lowres) {
3054                 enc->flags |= CODEC_FLAG_EMU_EDGE;
3055                 frame_height >>= enc->lowres;
3056                 frame_width  >>= enc->lowres;
3057             }
3058             if(me_threshold)
3059                 enc->debug |= FF_DEBUG_MV;
3060
3061             if (enc->time_base.den != rfps*enc->ticks_per_frame || enc->time_base.num != rfps_base) {
3062
3063                 if (verbose >= 0)
3064                     fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3065                             i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
3066
3067                     (float)rfps / rfps_base, rfps, rfps_base);
3068             }
3069             /* update the current frame rate to match the stream frame rate */
3070             frame_rate.num = rfps;
3071             frame_rate.den = rfps_base;
3072
3073             input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(video_codec_name);
3074             if(video_disable)
3075                 st->discard= AVDISCARD_ALL;
3076             else if(video_discard)
3077                 st->discard= video_discard;
3078             break;
3079         case AVMEDIA_TYPE_DATA:
3080             break;
3081         case AVMEDIA_TYPE_SUBTITLE:
3082             input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(subtitle_codec_name);
3083             if(subtitle_disable)
3084                 st->discard = AVDISCARD_ALL;
3085             break;
3086         case AVMEDIA_TYPE_ATTACHMENT:
3087         case AVMEDIA_TYPE_UNKNOWN:
3088             nb_icodecs++;
3089             break;
3090         default:
3091             abort();
3092         }
3093     }
3094
3095     input_files[nb_input_files] = ic;
3096     input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3097     /* dump the file content */
3098     if (verbose >= 0)
3099         dump_format(ic, nb_input_files, filename, 0);
3100
3101     nb_input_files++;
3102
3103     video_channel = 0;
3104
3105     av_freep(&video_codec_name);
3106     av_freep(&audio_codec_name);
3107     av_freep(&subtitle_codec_name);
3108 }
3109
3110 static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3111                                          int *has_subtitle_ptr)
3112 {
3113     int has_video, has_audio, has_subtitle, i, j;
3114     AVFormatContext *ic;
3115
3116     has_video = 0;
3117     has_audio = 0;
3118     has_subtitle = 0;
3119     for(j=0;j<nb_input_files;j++) {
3120         ic = input_files[j];
3121         for(i=0;i<ic->nb_streams;i++) {
3122             AVCodecContext *enc = ic->streams[i]->codec;
3123             switch(enc->codec_type) {
3124             case AVMEDIA_TYPE_AUDIO:
3125                 has_audio = 1;
3126                 break;
3127             case AVMEDIA_TYPE_VIDEO:
3128                 has_video = 1;
3129                 break;
3130             case AVMEDIA_TYPE_SUBTITLE:
3131                 has_subtitle = 1;
3132                 break;
3133             case AVMEDIA_TYPE_DATA:
3134             case AVMEDIA_TYPE_ATTACHMENT:
3135             case AVMEDIA_TYPE_UNKNOWN:
3136                 break;
3137             default:
3138                 abort();
3139             }
3140         }
3141     }
3142     *has_video_ptr = has_video;
3143     *has_audio_ptr = has_audio;
3144     *has_subtitle_ptr = has_subtitle;
3145 }
3146
3147 static void new_video_stream(AVFormatContext *oc)
3148 {
3149     AVStream *st;
3150     AVCodecContext *video_enc;
3151     enum CodecID codec_id;
3152
3153     st = av_new_stream(oc, oc->nb_streams);
3154     if (!st) {
3155         fprintf(stderr, "Could not alloc stream\n");
3156         av_exit(1);
3157     }
3158     avcodec_get_context_defaults2(st->codec, AVMEDIA_TYPE_VIDEO);
3159     bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
3160     video_bitstream_filters= NULL;
3161
3162     avcodec_thread_init(st->codec, thread_count);
3163
3164     video_enc = st->codec;
3165
3166     if(video_codec_tag)
3167         video_enc->codec_tag= video_codec_tag;
3168
3169     if(   (video_global_header&1)
3170        || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3171         video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3172         avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3173     }
3174     if(video_global_header&2){
3175         video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3176         avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3177     }
3178
3179     if (video_stream_copy) {
3180         st->stream_copy = 1;
3181         video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3182         video_enc->sample_aspect_ratio =
3183         st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3184     } else {
3185         const char *p;
3186         int i;
3187         AVCodec *codec;
3188         AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3189
3190         if (video_codec_name) {
3191             codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1);
3192             codec = avcodec_find_encoder_by_name(video_codec_name);
3193             output_codecs[nb_ocodecs] = codec;
3194         } else {
3195             codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3196             codec = avcodec_find_encoder(codec_id);
3197         }
3198
3199         video_enc->codec_id = codec_id;
3200
3201         set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3202
3203         if (codec && codec->supported_framerates && !force_fps)
3204             fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3205         video_enc->time_base.den = fps.num;
3206         video_enc->time_base.num = fps.den;
3207
3208         video_enc->width = frame_width + frame_padright + frame_padleft;
3209         video_enc->height = frame_height + frame_padtop + frame_padbottom;
3210         video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3211         video_enc->pix_fmt = frame_pix_fmt;
3212         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3213
3214         choose_pixel_fmt(st, codec);
3215
3216         if (intra_only)
3217             video_enc->gop_size = 0;
3218         if (video_qscale || same_quality) {
3219             video_enc->flags |= CODEC_FLAG_QSCALE;
3220             video_enc->global_quality=
3221                 st->quality = FF_QP2LAMBDA * video_qscale;
3222         }
3223
3224         if(intra_matrix)
3225             video_enc->intra_matrix = intra_matrix;
3226         if(inter_matrix)
3227             video_enc->inter_matrix = inter_matrix;
3228
3229         p= video_rc_override_string;
3230         for(i=0; p; i++){
3231             int start, end, q;
3232             int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3233             if(e!=3){
3234                 fprintf(stderr, "error parsing rc_override\n");
3235                 av_exit(1);
3236             }
3237             video_enc->rc_override=
3238                 av_realloc(video_enc->rc_override,
3239                            sizeof(RcOverride)*(i+1));
3240             video_enc->rc_override[i].start_frame= start;
3241             video_enc->rc_override[i].end_frame  = end;
3242             if(q>0){
3243                 video_enc->rc_override[i].qscale= q;
3244                 video_enc->rc_override[i].quality_factor= 1.0;
3245             }
3246             else{
3247                 video_enc->rc_override[i].qscale= 0;
3248                 video_enc->rc_override[i].quality_factor= -q/100.0;
3249             }
3250             p= strchr(p, '/');
3251             if(p) p++;
3252         }
3253         video_enc->rc_override_count=i;
3254         if (!video_enc->rc_initial_buffer_occupancy)
3255             video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3256         video_enc->me_threshold= me_threshold;
3257         video_enc->intra_dc_precision= intra_dc_precision - 8;
3258
3259         if (do_psnr)
3260             video_enc->flags|= CODEC_FLAG_PSNR;
3261
3262         /* two pass mode */
3263         if (do_pass) {
3264             if (do_pass == 1) {
3265                 video_enc->flags |= CODEC_FLAG_PASS1;
3266             } else {
3267                 video_enc->flags |= CODEC_FLAG_PASS2;
3268             }
3269         }
3270     }
3271     nb_ocodecs++;
3272     if (video_language) {
3273         av_metadata_set(&st->metadata, "language", video_language);
3274         av_freep(&video_language);
3275     }
3276
3277     /* reset some key parameters */
3278     video_disable = 0;
3279     av_freep(&video_codec_name);
3280     video_stream_copy = 0;
3281     frame_pix_fmt = PIX_FMT_NONE;
3282 }
3283
3284 static void new_audio_stream(AVFormatContext *oc)
3285 {
3286     AVStream *st;
3287     AVCodecContext *audio_enc;
3288     enum CodecID codec_id;
3289
3290     st = av_new_stream(oc, oc->nb_streams);
3291     if (!st) {
3292         fprintf(stderr, "Could not alloc stream\n");
3293         av_exit(1);
3294     }
3295     avcodec_get_context_defaults2(st->codec, AVMEDIA_TYPE_AUDIO);
3296
3297     bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3298     audio_bitstream_filters= NULL;
3299
3300     avcodec_thread_init(st->codec, thread_count);
3301
3302     audio_enc = st->codec;
3303     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3304
3305     if(audio_codec_tag)
3306         audio_enc->codec_tag= audio_codec_tag;
3307
3308     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3309         audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3310         avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3311     }
3312     if (audio_stream_copy) {
3313         st->stream_copy = 1;
3314         audio_enc->channels = audio_channels;
3315     } else {
3316         AVCodec *codec;
3317
3318         set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3319
3320         if (audio_codec_name) {
3321             codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1);
3322             codec = avcodec_find_encoder_by_name(audio_codec_name);
3323             output_codecs[nb_ocodecs] = codec;
3324         } else {
3325             codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3326             codec = avcodec_find_encoder(codec_id);
3327         }
3328         audio_enc->codec_id = codec_id;
3329
3330         if (audio_qscale > QSCALE_NONE) {
3331             audio_enc->flags |= CODEC_FLAG_QSCALE;
3332             audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3333         }
3334         audio_enc->channels = audio_channels;
3335         audio_enc->sample_fmt = audio_sample_fmt;
3336         audio_enc->channel_layout = channel_layout;
3337         if (avcodec_channel_layout_num_channels(channel_layout) != audio_channels)
3338             audio_enc->channel_layout = 0;
3339         choose_sample_fmt(st, codec);
3340     }
3341     nb_ocodecs++;
3342     audio_enc->sample_rate = audio_sample_rate;
3343     audio_enc->time_base= (AVRational){1, audio_sample_rate};
3344     if (audio_language) {
3345         av_metadata_set(&st->metadata, "language", audio_language);
3346         av_freep(&audio_language);
3347     }
3348
3349     /* reset some key parameters */
3350     audio_disable = 0;
3351     av_freep(&audio_codec_name);
3352     audio_stream_copy = 0;
3353 }
3354
3355 static void new_subtitle_stream(AVFormatContext *oc)
3356 {
3357     AVStream *st;
3358     AVCodecContext *subtitle_enc;
3359
3360     st = av_new_stream(oc, oc->nb_streams);
3361     if (!st) {
3362         fprintf(stderr, "Could not alloc stream\n");
3363         av_exit(1);
3364     }
3365     avcodec_get_context_defaults2(st->codec, AVMEDIA_TYPE_SUBTITLE);
3366
3367     bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3368     subtitle_bitstream_filters= NULL;
3369
3370     subtitle_enc = st->codec;
3371     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3372
3373     if(subtitle_codec_tag)
3374         subtitle_enc->codec_tag= subtitle_codec_tag;
3375
3376     if (subtitle_stream_copy) {
3377         st->stream_copy = 1;
3378     } else {
3379         set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3380         subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1);
3381         output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name);
3382     }
3383     nb_ocodecs++;
3384
3385     if (subtitle_language) {
3386         av_metadata_set(&st->metadata, "language", subtitle_language);
3387         av_freep(&subtitle_language);
3388     }
3389
3390     subtitle_disable = 0;
3391     av_freep(&subtitle_codec_name);
3392     subtitle_stream_copy = 0;
3393 }
3394
3395 static void opt_new_audio_stream(void)
3396 {
3397     AVFormatContext *oc;
3398     if (nb_output_files <= 0) {
3399         fprintf(stderr, "At least one output file must be specified\n");
3400         av_exit(1);
3401     }
3402     oc = output_files[nb_output_files - 1];
3403     new_audio_stream(oc);
3404 }
3405
3406 static void opt_new_video_stream(void)
3407 {
3408     AVFormatContext *oc;
3409     if (nb_output_files <= 0) {
3410         fprintf(stderr, "At least one output file must be specified\n");
3411         av_exit(1);
3412     }
3413     oc = output_files[nb_output_files - 1];
3414     new_video_stream(oc);
3415 }
3416
3417 static void opt_new_subtitle_stream(void)
3418 {
3419     AVFormatContext *oc;
3420     if (nb_output_files <= 0) {
3421         fprintf(stderr, "At least one output file must be specified\n");
3422         av_exit(1);
3423     }
3424     oc = output_files[nb_output_files - 1];
3425     new_subtitle_stream(oc);
3426 }
3427
3428 static void opt_output_file(const char *filename)
3429 {
3430     AVFormatContext *oc;
3431     int use_video, use_audio, use_subtitle;
3432     int input_has_video, input_has_audio, input_has_subtitle;
3433     AVFormatParameters params, *ap = &params;
3434     AVOutputFormat *file_oformat;
3435
3436     if (!strcmp(filename, "-"))
3437         filename = "pipe:";
3438
3439     oc = avformat_alloc_context();
3440     if (!oc) {
3441         print_error(filename, AVERROR(ENOMEM));
3442         av_exit(1);
3443     }
3444
3445     if (last_asked_format) {
3446         file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3447         if (!file_oformat) {
3448             fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3449             av_exit(1);
3450         }
3451         last_asked_format = NULL;
3452     } else {
3453         file_oformat = av_guess_format(NULL, filename, NULL);
3454         if (!file_oformat) {
3455             fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3456                     filename);
3457             av_exit(1);
3458         }
3459     }
3460
3461     oc->oformat = file_oformat;
3462     av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3463
3464     if (!strcmp(file_oformat->name, "ffm") &&
3465         av_strstart(filename, "http:", NULL)) {
3466         /* special case for files sent to ffserver: we get the stream
3467            parameters from ffserver */
3468         int err = read_ffserver_streams(oc, filename);
3469         if (err < 0) {
3470             print_error(filename, err);
3471             av_exit(1);
3472         }
3473     } else {
3474         use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3475         use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3476         use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3477
3478         /* disable if no corresponding type found and at least one
3479            input file */
3480         if (nb_input_files > 0) {
3481             check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3482                                          &input_has_subtitle);
3483             if (!input_has_video)
3484                 use_video = 0;
3485             if (!input_has_audio)
3486                 use_audio = 0;
3487             if (!input_has_subtitle)
3488                 use_subtitle = 0;
3489         }
3490
3491         /* manual disable */
3492         if (audio_disable) {
3493             use_audio = 0;
3494         }
3495         if (video_disable) {
3496             use_video = 0;
3497         }
3498         if (subtitle_disable) {
3499             use_subtitle = 0;
3500         }
3501
3502         if (use_video) {
3503             new_video_stream(oc);
3504         }
3505
3506         if (use_audio) {
3507             new_audio_stream(oc);
3508         }
3509
3510         if (use_subtitle) {
3511             new_subtitle_stream(oc);
3512         }
3513
3514         oc->timestamp = rec_timestamp;
3515
3516         for(; metadata_count>0; metadata_count--){
3517             av_metadata_set(&oc->metadata, metadata[metadata_count-1].key,
3518                                            metadata[metadata_count-1].value);
3519         }
3520         av_metadata_conv(oc, oc->oformat->metadata_conv, NULL);
3521     }
3522
3523     output_files[nb_output_files++] = oc;
3524
3525     /* check filename in case of an image number is expected */
3526     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3527         if (!av_filename_number_test(oc->filename)) {
3528             print_error(oc->filename, AVERROR_NUMEXPECTED);
3529             av_exit(1);
3530         }
3531     }
3532
3533     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3534         /* test if it already exists to avoid loosing precious files */
3535         if (!file_overwrite &&
3536             (strchr(filename, ':') == NULL ||
3537              filename[1] == ':' ||
3538              av_strstart(filename, "file:", NULL))) {
3539             if (url_exist(filename)) {
3540                 if (!using_stdin) {
3541                     fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3542                     fflush(stderr);
3543                     if (!read_yesno()) {
3544                         fprintf(stderr, "Not overwriting - exiting\n");
3545                         av_exit(1);
3546                     }
3547                 }
3548                 else {
3549                     fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3550                     av_exit(1);
3551                 }
3552             }
3553         }
3554
3555         /* open the file */
3556         if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3557             fprintf(stderr, "Could not open '%s'\n", filename);
3558             av_exit(1);
3559         }
3560     }
3561
3562     memset(ap, 0, sizeof(*ap));
3563     if (av_set_parameters(oc, ap) < 0) {
3564         fprintf(stderr, "%s: Invalid encoding parameters\n",
3565                 oc->filename);
3566         av_exit(1);
3567     }
3568
3569     oc->preload= (int)(mux_preload*AV_TIME_BASE);
3570     oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3571     oc->loop_output = loop_output;
3572     oc->flags |= AVFMT_FLAG_NONBLOCK;
3573
3574     set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3575 }
3576
3577 /* same option as mencoder */
3578 static void opt_pass(const char *pass_str)
3579 {
3580     int pass;
3581     pass = atoi(pass_str);
3582     if (pass != 1 && pass != 2) {
3583         fprintf(stderr, "pass number can be only 1 or 2\n");
3584         av_exit(1);
3585     }
3586     do_pass = pass;
3587 }
3588
3589 static int64_t getutime(void)
3590 {
3591 #if HAVE_GETRUSAGE
3592     struct rusage rusage;
3593
3594     getrusage(RUSAGE_SELF, &rusage);
3595     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3596 #elif HAVE_GETPROCESSTIMES
3597     HANDLE proc;
3598     FILETIME c, e, k, u;
3599     proc = GetCurrentProcess();
3600     GetProcessTimes(proc, &c, &e, &k, &u);
3601     return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3602 #else
3603     return av_gettime();
3604 #endif
3605 }
3606
3607 static int64_t getmaxrss(void)
3608 {
3609 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3610     struct rusage rusage;
3611     getrusage(RUSAGE_SELF, &rusage);
3612     return (int64_t)rusage.ru_maxrss * 1024;
3613 #elif HAVE_GETPROCESSMEMORYINFO
3614     HANDLE proc;
3615     PROCESS_MEMORY_COUNTERS memcounters;
3616     proc = GetCurrentProcess();
3617     memcounters.cb = sizeof(memcounters);
3618     GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3619     return memcounters.PeakPagefileUsage;
3620 #else
3621     return 0;
3622 #endif
3623 }
3624
3625 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3626 {
3627     int i;
3628     const char *p = str;
3629     for(i = 0;; i++) {
3630         dest[i] = atoi(p);
3631         if(i == 63)
3632             break;
3633         p = strchr(p, ',');
3634         if(!p) {
3635             fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3636             av_exit(1);
3637         }
3638         p++;
3639     }
3640 }
3641
3642 static void opt_inter_matrix(const char *arg)
3643 {
3644     inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3645     parse_matrix_coeffs(inter_matrix, arg);
3646 }
3647
3648 static void opt_intra_matrix(const char *arg)
3649 {
3650     intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3651     parse_matrix_coeffs(intra_matrix, arg);
3652 }
3653
3654 /**
3655  * Trivial log callback.
3656  * Only suitable for show_help and similar since it lacks prefix handling.
3657  */
3658 static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3659 {
3660     vfprintf(stdout, fmt, vl);
3661 }
3662
3663 static void show_usage(void)
3664 {
3665     printf("Hyper fast Audio and Video encoder\n");
3666     printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3667     printf("\n");
3668 }
3669
3670 static void show_help(void)
3671 {
3672     av_log_set_callback(log_callback_help);
3673     show_usage();
3674     show_help_options(options, "Main options:\n",
3675                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3676     show_help_options(options, "\nAdvanced options:\n",
3677                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3678                       OPT_EXPERT);
3679     show_help_options(options, "\nVideo options:\n",
3680                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3681                       OPT_VIDEO);
3682     show_help_options(options, "\nAdvanced Video options:\n",
3683                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3684                       OPT_VIDEO | OPT_EXPERT);
3685     show_help_options(options, "\nAudio options:\n",
3686                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3687                       OPT_AUDIO);
3688     show_help_options(options, "\nAdvanced Audio options:\n",
3689                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3690                       OPT_AUDIO | OPT_EXPERT);
3691     show_help_options(options, "\nSubtitle options:\n",
3692                       OPT_SUBTITLE | OPT_GRAB,
3693                       OPT_SUBTITLE);
3694     show_help_options(options, "\nAudio/Video grab options:\n",
3695                       OPT_GRAB,
3696                       OPT_GRAB);
3697     printf("\n");
3698     av_opt_show(avcodec_opts[0], NULL);
3699     printf("\n");
3700     av_opt_show(avformat_opts, NULL);
3701     printf("\n");
3702     av_opt_show(sws_opts, NULL);
3703 }
3704
3705 static void opt_target(const char *arg)
3706 {
3707     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3708     static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3709
3710     if(!strncmp(arg, "pal-", 4)) {
3711         norm = PAL;
3712         arg += 4;
3713     } else if(!strncmp(arg, "ntsc-", 5)) {
3714         norm = NTSC;
3715         arg += 5;
3716     } else if(!strncmp(arg, "film-", 5)) {
3717         norm = FILM;
3718         arg += 5;
3719     } else {
3720         int fr;
3721         /* Calculate FR via float to avoid int overflow */
3722         fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3723         if(fr == 25000) {
3724             norm = PAL;
3725         } else if((fr == 29970) || (fr == 23976)) {
3726             norm = NTSC;
3727         } else {
3728             /* Try to determine PAL/NTSC by peeking in the input files */
3729             if(nb_input_files) {
3730                 int i, j;
3731                 for(j = 0; j < nb_input_files; j++) {
3732                     for(i = 0; i < input_files[j]->nb_streams; i++) {
3733                         AVCodecContext *c = input_files[j]->streams[i]->codec;
3734                         if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3735                             continue;
3736                         fr = c->time_base.den * 1000 / c->time_base.num;
3737                         if(fr == 25000) {
3738                             norm = PAL;
3739                             break;
3740                         } else if((fr == 29970) || (fr == 23976)) {
3741                             norm = NTSC;
3742                             break;
3743                         }
3744                     }
3745                     if(norm != UNKNOWN)
3746                         break;
3747                 }
3748             }
3749         }
3750         if(verbose && norm != UNKNOWN)
3751             fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
3752     }
3753
3754     if(norm == UNKNOWN) {
3755         fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3756         fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3757         fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3758         av_exit(1);
3759     }
3760
3761     if(!strcmp(arg, "vcd")) {
3762
3763         opt_video_codec("mpeg1video");
3764         opt_audio_codec("mp2");
3765         opt_format("vcd");
3766
3767         opt_frame_size(norm == PAL ? "352x288" : "352x240");
3768         opt_frame_rate(NULL, frame_rates[norm]);
3769         opt_default("g", norm == PAL ? "15" : "18");
3770
3771         opt_default("b", "1150000");
3772         opt_default("maxrate", "1150000");
3773         opt_default("minrate", "1150000");
3774         opt_default("bufsize", "327680"); // 40*1024*8;
3775
3776         opt_default("ab", "224000");
3777         audio_sample_rate = 44100;
3778         audio_channels = 2;
3779
3780         opt_default("packetsize", "2324");
3781         opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3782
3783         /* We have to offset the PTS, so that it is consistent with the SCR.
3784            SCR starts at 36000, but the first two packs contain only padding
3785            and the first pack from the other stream, respectively, may also have
3786            been written before.
3787            So the real data starts at SCR 36000+3*1200. */
3788         mux_preload= (36000+3*1200) / 90000.0; //0.44
3789     } else if(!strcmp(arg, "svcd")) {
3790
3791         opt_video_codec("mpeg2video");
3792         opt_audio_codec("mp2");
3793         opt_format("svcd");
3794
3795         opt_frame_size(norm == PAL ? "480x576" : "480x480");
3796         opt_frame_rate(NULL, frame_rates[norm]);
3797         opt_default("g", norm == PAL ? "15" : "18");
3798
3799         opt_default("b", "2040000");
3800         opt_default("maxrate", "2516000");
3801         opt_default("minrate", "0"); //1145000;
3802         opt_default("bufsize", "1835008"); //224*1024*8;
3803         opt_default("flags", "+scan_offset");
3804
3805
3806         opt_default("ab", "224000");
3807         audio_sample_rate = 44100;
3808
3809         opt_default("packetsize", "2324");
3810
3811     } else if(!strcmp(arg, "dvd")) {
3812
3813         opt_video_codec("mpeg2video");
3814         opt_audio_codec("ac3");
3815         opt_format("dvd");
3816
3817         opt_frame_size(norm == PAL ? "720x576" : "720x480");
3818         opt_frame_rate(NULL, frame_rates[norm]);
3819         opt_default("g", norm == PAL ? "15" : "18");
3820
3821         opt_default("b", "6000000");
3822         opt_default("maxrate", "9000000");
3823         opt_default("minrate", "0"); //1500000;
3824         opt_default("bufsize", "1835008"); //224*1024*8;
3825
3826         opt_default("packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3827         opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3828
3829         opt_default("ab", "448000");
3830         audio_sample_rate = 48000;
3831
3832     } else if(!strncmp(arg, "dv", 2)) {
3833
3834         opt_format("dv");
3835
3836         opt_frame_size(norm == PAL ? "720x576" : "720x480");
3837         opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3838                           (norm == PAL ? "yuv420p" : "yuv411p"));
3839         opt_frame_rate(NULL, frame_rates[norm]);
3840
3841         audio_sample_rate = 48000;
3842         audio_channels = 2;
3843
3844     } else {
3845         fprintf(stderr, "Unknown target: %s\n", arg);
3846         av_exit(1);
3847     }
3848 }
3849
3850 static void opt_vstats_file (const char *arg)
3851 {
3852     av_free (vstats_filename);
3853     vstats_filename=av_strdup (arg);
3854 }
3855
3856 static void opt_vstats (void)
3857 {
3858     char filename[40];
3859     time_t today2 = time(NULL);
3860     struct tm *today = localtime(&today2);
3861
3862     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3863              today->tm_sec);
3864     opt_vstats_file(filename);
3865 }
3866
3867 static int opt_bsf(const char *opt, const char *arg)
3868 {
3869     AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3870     AVBitStreamFilterContext **bsfp;
3871
3872     if(!bsfc){
3873         fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3874         av_exit(1);
3875     }
3876
3877     bsfp= *opt == 'v' ? &video_bitstream_filters :
3878           *opt == 'a' ? &audio_bitstream_filters :
3879                         &subtitle_bitstream_filters;
3880     while(*bsfp)
3881         bsfp= &(*bsfp)->next;
3882
3883     *bsfp= bsfc;
3884
3885     return 0;
3886 }
3887
3888 static int opt_preset(const char *opt, const char *arg)
3889 {
3890     FILE *f=NULL;
3891     char filename[1000], tmp[1000], tmp2[1000], line[1000];
3892     int i;
3893     const char *base[2]= { getenv("HOME"),
3894                            FFMPEG_DATADIR,
3895                          };
3896
3897     if (*opt != 'f') {
3898         for(i=!base[0]; i<2 && !f; i++){
3899             snprintf(filename, sizeof(filename), "%s%s/%s.ffpreset", base[i], i ? "" : "/.ffmpeg", arg);
3900             f= fopen(filename, "r");
3901             if(!f){
3902                 char *codec_name= *opt == 'v' ? video_codec_name :
3903                                   *opt == 'a' ? audio_codec_name :
3904                                                 subtitle_codec_name;
3905                 snprintf(filename, sizeof(filename), "%s%s/%s-%s.ffpreset", base[i],  i ? "" : "/.ffmpeg", codec_name, arg);
3906                 f= fopen(filename, "r");
3907             }
3908         }
3909     } else {
3910         av_strlcpy(filename, arg, sizeof(filename));
3911         f= fopen(filename, "r");
3912     }
3913
3914     if(!f){
3915         fprintf(stderr, "File for preset '%s' not found\n", arg);
3916         av_exit(1);
3917     }
3918
3919     while(!feof(f)){
3920         int e= fscanf(f, "%999[^\n]\n", line) - 1;
3921         if(line[0] == '#' && !e)
3922             continue;
3923         e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
3924         if(e){
3925             fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
3926             av_exit(1);
3927         }
3928         if(!strcmp(tmp, "acodec")){
3929             opt_audio_codec(tmp2);
3930         }else if(!strcmp(tmp, "vcodec")){
3931             opt_video_codec(tmp2);
3932         }else if(!strcmp(tmp, "scodec")){
3933             opt_subtitle_codec(tmp2);
3934         }else if(opt_default(tmp, tmp2) < 0){
3935             fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
3936             av_exit(1);
3937         }
3938     }
3939
3940     fclose(f);
3941
3942     return 0;
3943 }
3944
3945 static const OptionDef options[] = {
3946     /* main options */
3947 #include "cmdutils_common_opts.h"
3948     { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3949     { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3950     { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3951     { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3952     { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3953     { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3954     { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
3955     { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3956     { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3957     { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
3958     { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_rec_timestamp}, "set the timestamp ('now' to set the current time)", "time" },
3959     { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
3960     { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
3961     { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3962       "add timings for benchmarking" },
3963     { "timelimit", OPT_FUNC2 | HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
3964     { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3965       "dump each input packet" },
3966     { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3967       "when dumping packets, also dump the payload" },
3968     { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3969     { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3970     { "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)", "" },
3971     { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
3972     { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3973     { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3974     { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3975     { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3976     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
3977     { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3978     { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
3979     { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3980     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
3981     { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
3982     { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
3983     { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)&copy_initial_nonkeyframes}, "copy initial non-keyframes" },
3984
3985     /* video options */
3986     { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3987     { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3988     { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3989     { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3990     { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3991     { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3992     { "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" },
3993     { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3994     { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3995     { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3996     { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3997     { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3998     { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3999     { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
4000     { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
4001     { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
4002     { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4003     { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4004     { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4005     { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4006     { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4007     { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4008     { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "threshold" },
4009     { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4010       "use same video quality as source (implies VBR)" },
4011     { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
4012     { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4013     { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4014       "deinterlace pictures" },
4015     { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4016     { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4017     { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4018     { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4019     { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4020     { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4021     { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4022     { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
4023     { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
4024     { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4025     { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4026     { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4027
4028     /* audio options */
4029     { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4030     { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4031     { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4032     { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4033     { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4034     { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4035     { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4036     { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
4037     { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4038     { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
4039     { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4040     { "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" },
4041
4042     /* subtitle options */
4043     { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4044     { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4045     { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
4046     { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4047     { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4048
4049     /* grab options */
4050     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4051     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4052     { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4053
4054     /* muxer options */
4055     { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4056     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4057
4058     { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4059     { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4060     { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4061
4062     { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4063     { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4064     { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4065     { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4066
4067     { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4068     { NULL, },
4069 };
4070
4071 int main(int argc, char **argv)
4072 {
4073     int i;
4074     int64_t ti;
4075
4076     avcodec_register_all();
4077     avdevice_register_all();
4078     av_register_all();
4079
4080 #if HAVE_ISATTY
4081     if(isatty(STDIN_FILENO))
4082         url_set_interrupt_cb(decode_interrupt_cb);
4083 #endif
4084
4085     for(i=0; i<AVMEDIA_TYPE_NB; i++){
4086         avcodec_opts[i]= avcodec_alloc_context2(i);
4087     }
4088     avformat_opts = avformat_alloc_context();
4089     sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
4090
4091     show_banner();
4092
4093     /* parse options */
4094     parse_options(argc, argv, options, opt_output_file);
4095
4096     if(nb_output_files <= 0 && nb_input_files == 0) {
4097         show_usage();
4098         fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4099         av_exit(1);
4100     }
4101
4102     /* file converter / grab */
4103     if (nb_output_files <= 0) {
4104         fprintf(stderr, "At least one output file must be specified\n");
4105         av_exit(1);
4106     }
4107
4108     if (nb_input_files == 0) {
4109         fprintf(stderr, "At least one input file must be specified\n");
4110         av_exit(1);
4111     }
4112
4113     ti = getutime();
4114     if (av_transcode(output_files, nb_output_files, input_files, nb_input_files,
4115                      stream_maps, nb_stream_maps) < 0)
4116         av_exit(1);
4117     ti = getutime() - ti;
4118     if (do_benchmark) {
4119         int maxrss = getmaxrss() / 1024;
4120         printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4121     }
4122
4123     return av_exit(0);
4124 }