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