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, *os;
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         os = output_files[ost->file_index];
1098         enc = ost->st->codec;
1099         if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1100             snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1101                      !ost->st->stream_copy ?
1102                      enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1103         }
1104         if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1105             float t = (av_gettime()-timer_start) / 1000000.0;
1106
1107             frame_number = ost->frame_number;
1108             snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1109                      frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
1110                      !ost->st->stream_copy ?
1111                      enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1112             if(is_last_report)
1113                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1114             if(qp_hist){
1115                 int j;
1116                 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1117                 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1118                     qp_histogram[qp]++;
1119                 for(j=0; j<32; j++)
1120                     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1121             }
1122             if (enc->flags&CODEC_FLAG_PSNR){
1123                 int j;
1124                 double error, error_sum=0;
1125                 double scale, scale_sum=0;
1126                 char type[3]= {'Y','U','V'};
1127                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1128                 for(j=0; j<3; j++){
1129                     if(is_last_report){
1130                         error= enc->error[j];
1131                         scale= enc->width*enc->height*255.0*255.0*frame_number;
1132                     }else{
1133                         error= enc->coded_frame->error[j];
1134                         scale= enc->width*enc->height*255.0*255.0;
1135                     }
1136                     if(j) scale/=4;
1137                     error_sum += error;
1138                     scale_sum += scale;
1139                     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1140                 }
1141                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1142             }
1143             vid = 1;
1144         }
1145         /* compute min output value */
1146         pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1147         if ((pts < ti1) && (pts > 0))
1148             ti1 = pts;
1149     }
1150     if (ti1 < 0.01)
1151         ti1 = 0.01;
1152
1153     if (verbose || is_last_report) {
1154         bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1155
1156         snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1157             "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1158             (double)total_size / 1024, ti1, bitrate);
1159
1160         if (verbose > 1)
1161           snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1162                   nb_frames_dup, nb_frames_drop);
1163
1164         if (verbose >= 0)
1165             fprintf(stderr, "%s    \r", buf);
1166
1167         fflush(stderr);
1168     }
1169
1170     if (is_last_report && verbose >= 0){
1171         int64_t raw= audio_size + video_size + extra_size;
1172         fprintf(stderr, "\n");
1173         fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1174                 video_size/1024.0,
1175                 audio_size/1024.0,
1176                 extra_size/1024.0,
1177                 100.0*(total_size - raw)/raw
1178         );
1179     }
1180 }
1181
1182 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1183 static int output_packet(AVInputStream *ist, int ist_index,
1184                          AVOutputStream **ost_table, int nb_ostreams,
1185                          const AVPacket *pkt)
1186 {
1187     AVFormatContext *os;
1188     AVOutputStream *ost;
1189     int ret, i;
1190     uint8_t *data_buf;
1191     int data_size, got_picture;
1192     AVFrame picture;
1193     void *buffer_to_free;
1194     static unsigned int samples_size= 0;
1195     AVSubtitle subtitle, *subtitle_to_free;
1196     int got_subtitle;
1197     AVPacket avpkt;
1198
1199     if(ist->next_pts == AV_NOPTS_VALUE)
1200         ist->next_pts= ist->pts;
1201
1202     if (pkt == NULL) {
1203         /* EOF handling */
1204         av_init_packet(&avpkt);
1205         avpkt.data = NULL;
1206         avpkt.size = 0;
1207         goto handle_eof;
1208     } else {
1209         avpkt = *pkt;
1210     }
1211
1212     if(pkt->dts != AV_NOPTS_VALUE)
1213         ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1214
1215     //while we have more to decode or while the decoder did output something on EOF
1216     while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) {
1217     handle_eof:
1218         ist->pts= ist->next_pts;
1219
1220         if(avpkt.size && avpkt.size != pkt->size && verbose>0)
1221             fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1222
1223         /* decode the packet if needed */
1224         data_buf = NULL; /* fail safe */
1225         data_size = 0;
1226         subtitle_to_free = NULL;
1227         if (ist->decoding_needed) {
1228             switch(ist->st->codec->codec_type) {
1229             case CODEC_TYPE_AUDIO:{
1230                 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1231                     samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1232                     av_free(samples);
1233                     samples= av_malloc(samples_size);
1234                 }
1235                 data_size= samples_size;
1236                     /* XXX: could avoid copy if PCM 16 bits with same
1237                        endianness as CPU */
1238                 ret = avcodec_decode_audio3(ist->st->codec, samples, &data_size,
1239                                             &avpkt);
1240                 if (ret < 0)
1241                     goto fail_decode;
1242                 avpkt.data += ret;
1243                 avpkt.size -= ret;
1244                 /* Some bug in mpeg audio decoder gives */
1245                 /* data_size < 0, it seems they are overflows */
1246                 if (data_size <= 0) {
1247                     /* no audio frame */
1248                     continue;
1249                 }
1250                 data_buf = (uint8_t *)samples;
1251                 ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1252                     (ist->st->codec->sample_rate * ist->st->codec->channels);
1253                 break;}
1254             case CODEC_TYPE_VIDEO:
1255                     data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1256                     /* XXX: allocate picture correctly */
1257                     avcodec_get_frame_defaults(&picture);
1258
1259                     ret = avcodec_decode_video2(ist->st->codec,
1260                                                 &picture, &got_picture, &avpkt);
1261                     ist->st->quality= picture.quality;
1262                     if (ret < 0)
1263                         goto fail_decode;
1264                     if (!got_picture) {
1265                         /* no picture yet */
1266                         goto discard_packet;
1267                     }
1268                     if (ist->st->codec->time_base.num != 0) {
1269                         int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1270                         ist->next_pts += ((int64_t)AV_TIME_BASE *
1271                                           ist->st->codec->time_base.num * ticks) /
1272                             ist->st->codec->time_base.den;
1273                     }
1274                     avpkt.size = 0;
1275                     break;
1276             case CODEC_TYPE_SUBTITLE:
1277                 ret = avcodec_decode_subtitle2(ist->st->codec,
1278                                                &subtitle, &got_subtitle, &avpkt);
1279                 if (ret < 0)
1280                     goto fail_decode;
1281                 if (!got_subtitle) {
1282                     goto discard_packet;
1283                 }
1284                 subtitle_to_free = &subtitle;
1285                 avpkt.size = 0;
1286                 break;
1287             default:
1288                 goto fail_decode;
1289             }
1290         } else {
1291             switch(ist->st->codec->codec_type) {
1292             case CODEC_TYPE_AUDIO:
1293                 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1294                     ist->st->codec->sample_rate;
1295                 break;
1296             case CODEC_TYPE_VIDEO:
1297                 if (ist->st->codec->time_base.num != 0) {
1298                     int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1299                     ist->next_pts += ((int64_t)AV_TIME_BASE *
1300                                       ist->st->codec->time_base.num * ticks) /
1301                         ist->st->codec->time_base.den;
1302                 }
1303                 break;
1304             }
1305             data_buf = avpkt.data;
1306             data_size = avpkt.size;
1307             ret = avpkt.size;
1308             avpkt.size = 0;
1309         }
1310
1311         buffer_to_free = NULL;
1312         if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1313             pre_process_video_frame(ist, (AVPicture *)&picture,
1314                                     &buffer_to_free);
1315         }
1316
1317         // preprocess audio (volume)
1318         if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1319             if (audio_volume != 256) {
1320                 short *volp;
1321                 volp = samples;
1322                 for(i=0;i<(data_size / sizeof(short));i++) {
1323                     int v = ((*volp) * audio_volume + 128) >> 8;
1324                     if (v < -32768) v = -32768;
1325                     if (v >  32767) v = 32767;
1326                     *volp++ = v;
1327                 }
1328             }
1329         }
1330
1331         /* frame rate emulation */
1332         if (rate_emu) {
1333             int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1334             int64_t now = av_gettime() - ist->start;
1335             if (pts > now)
1336                 usleep(pts - now);
1337         }
1338
1339         /* if output time reached then transcode raw format,
1340            encode packets and output them */
1341         if (start_time == 0 || ist->pts >= start_time)
1342             for(i=0;i<nb_ostreams;i++) {
1343                 int frame_size;
1344
1345                 ost = ost_table[i];
1346                 if (ost->source_index == ist_index) {
1347                     os = output_files[ost->file_index];
1348
1349 #if 0
1350                     printf("%d: got pts=%0.3f %0.3f\n", i,
1351                            (double)pkt->pts / AV_TIME_BASE,
1352                            ((double)ist->pts / AV_TIME_BASE) -
1353                            ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1354 #endif
1355                     /* set the input output pts pairs */
1356                     //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1357
1358                     if (ost->encoding_needed) {
1359                         switch(ost->st->codec->codec_type) {
1360                         case CODEC_TYPE_AUDIO:
1361                             do_audio_out(os, ost, ist, data_buf, data_size);
1362                             break;
1363                         case CODEC_TYPE_VIDEO:
1364                             do_video_out(os, ost, ist, &picture, &frame_size);
1365                             if (vstats_filename && frame_size)
1366                                 do_video_stats(os, ost, frame_size);
1367                             break;
1368                         case CODEC_TYPE_SUBTITLE:
1369                             do_subtitle_out(os, ost, ist, &subtitle,
1370                                             pkt->pts);
1371                             break;
1372                         default:
1373                             abort();
1374                         }
1375                     } else {
1376                         AVFrame avframe; //FIXME/XXX remove this
1377                         AVPacket opkt;
1378                         int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1379
1380                         av_init_packet(&opkt);
1381
1382                         if ((!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1383                             continue;
1384
1385                         /* no reencoding needed : output the packet directly */
1386                         /* force the input stream PTS */
1387
1388                         avcodec_get_frame_defaults(&avframe);
1389                         ost->st->codec->coded_frame= &avframe;
1390                         avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1391
1392                         if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1393                             audio_size += data_size;
1394                         else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1395                             video_size += data_size;
1396                             ost->sync_opts++;
1397                         }
1398
1399                         opkt.stream_index= ost->index;
1400                         if(pkt->pts != AV_NOPTS_VALUE)
1401                             opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1402                         else
1403                             opkt.pts= AV_NOPTS_VALUE;
1404
1405                         if (pkt->dts == AV_NOPTS_VALUE)
1406                             opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1407                         else
1408                             opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1409                         opkt.dts -= ost_tb_start_time;
1410
1411                         opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1412                         opkt.flags= pkt->flags;
1413
1414                         //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1415                         if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1416                             opkt.destruct= av_destruct_packet;
1417
1418                         write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][opkt.stream_index]);
1419                         ost->st->codec->frame_number++;
1420                         ost->frame_number++;
1421                         av_free_packet(&opkt);
1422                     }
1423                 }
1424             }
1425         av_free(buffer_to_free);
1426         /* XXX: allocate the subtitles in the codec ? */
1427         if (subtitle_to_free) {
1428             if (subtitle_to_free->rects != NULL) {
1429                 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1430                     av_freep(&subtitle_to_free->rects[i]->pict.data[0]);
1431                     av_freep(&subtitle_to_free->rects[i]->pict.data[1]);
1432                     av_freep(&subtitle_to_free->rects[i]);
1433                 }
1434                 av_freep(&subtitle_to_free->rects);
1435             }
1436             subtitle_to_free->num_rects = 0;
1437             subtitle_to_free = NULL;
1438         }
1439     }
1440  discard_packet:
1441     if (pkt == NULL) {
1442         /* EOF handling */
1443
1444         for(i=0;i<nb_ostreams;i++) {
1445             ost = ost_table[i];
1446             if (ost->source_index == ist_index) {
1447                 AVCodecContext *enc= ost->st->codec;
1448                 os = output_files[ost->file_index];
1449
1450                 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1451                     continue;
1452                 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1453                     continue;
1454
1455                 if (ost->encoding_needed) {
1456                     for(;;) {
1457                         AVPacket pkt;
1458                         int fifo_bytes;
1459                         av_init_packet(&pkt);
1460                         pkt.stream_index= ost->index;
1461
1462                         switch(ost->st->codec->codec_type) {
1463                         case CODEC_TYPE_AUDIO:
1464                             fifo_bytes = av_fifo_size(ost->fifo);
1465                             ret = 0;
1466                             /* encode any samples remaining in fifo */
1467                             if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1468                                 int fs_tmp = enc->frame_size;
1469                                 enc->frame_size = fifo_bytes / (2 * 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                                 enc->frame_size = fs_tmp;
1473                             }
1474                             if(ret <= 0) {
1475                                 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1476                             }
1477                             if (ret < 0) {
1478                                 fprintf(stderr, "Audio encoding failed\n");
1479                                 av_exit(1);
1480                             }
1481                             audio_size += ret;
1482                             pkt.flags |= PKT_FLAG_KEY;
1483                             break;
1484                         case CODEC_TYPE_VIDEO:
1485                             ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1486                             if (ret < 0) {
1487                                 fprintf(stderr, "Video encoding failed\n");
1488                                 av_exit(1);
1489                             }
1490                             video_size += ret;
1491                             if(enc->coded_frame && enc->coded_frame->key_frame)
1492                                 pkt.flags |= PKT_FLAG_KEY;
1493                             if (ost->logfile && enc->stats_out) {
1494                                 fprintf(ost->logfile, "%s", enc->stats_out);
1495                             }
1496                             break;
1497                         default:
1498                             ret=-1;
1499                         }
1500
1501                         if(ret<=0)
1502                             break;
1503                         pkt.data= bit_buffer;
1504                         pkt.size= ret;
1505                         if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1506                             pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1507                         write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1508                     }
1509                 }
1510             }
1511         }
1512     }
1513
1514     return 0;
1515  fail_decode:
1516     return -1;
1517 }
1518
1519 static void print_sdp(AVFormatContext **avc, int n)
1520 {
1521     char sdp[2048];
1522
1523     avf_sdp_create(avc, n, sdp, sizeof(sdp));
1524     printf("SDP:\n%s\n", sdp);
1525     fflush(stdout);
1526 }
1527
1528 static int stream_index_from_inputs(AVFormatContext **input_files,
1529                                     int nb_input_files,
1530                                     AVInputFile *file_table,
1531                                     AVInputStream **ist_table,
1532                                     enum CodecType type,
1533                                     int programid)
1534 {
1535     int p, q, z;
1536     for(z=0; z<nb_input_files; z++) {
1537         AVFormatContext *ic = input_files[z];
1538         for(p=0; p<ic->nb_programs; p++) {
1539             AVProgram *program = ic->programs[p];
1540             if(program->id != programid)
1541                 continue;
1542             for(q=0; q<program->nb_stream_indexes; q++) {
1543                 int sidx = program->stream_index[q];
1544                 int ris = file_table[z].ist_index + sidx;
1545                 if(ist_table[ris]->discard && ic->streams[sidx]->codec->codec_type == type)
1546                     return ris;
1547             }
1548         }
1549     }
1550
1551     return -1;
1552 }
1553
1554 /*
1555  * The following code is the main loop of the file converter
1556  */
1557 static int av_encode(AVFormatContext **output_files,
1558                      int nb_output_files,
1559                      AVFormatContext **input_files,
1560                      int nb_input_files,
1561                      AVStreamMap *stream_maps, int nb_stream_maps)
1562 {
1563     int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1564     AVFormatContext *is, *os;
1565     AVCodecContext *codec, *icodec;
1566     AVOutputStream *ost, **ost_table = NULL;
1567     AVInputStream *ist, **ist_table = NULL;
1568     AVInputFile *file_table;
1569     char error[1024];
1570     int key;
1571     int want_sdp = 1;
1572     uint8_t no_packet[MAX_FILES]={0};
1573     int no_packet_count=0;
1574
1575     file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1576     if (!file_table)
1577         goto fail;
1578
1579     /* input stream init */
1580     j = 0;
1581     for(i=0;i<nb_input_files;i++) {
1582         is = input_files[i];
1583         file_table[i].ist_index = j;
1584         file_table[i].nb_streams = is->nb_streams;
1585         j += is->nb_streams;
1586     }
1587     nb_istreams = j;
1588
1589     ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1590     if (!ist_table)
1591         goto fail;
1592
1593     for(i=0;i<nb_istreams;i++) {
1594         ist = av_mallocz(sizeof(AVInputStream));
1595         if (!ist)
1596             goto fail;
1597         ist_table[i] = ist;
1598     }
1599     j = 0;
1600     for(i=0;i<nb_input_files;i++) {
1601         is = input_files[i];
1602         for(k=0;k<is->nb_streams;k++) {
1603             ist = ist_table[j++];
1604             ist->st = is->streams[k];
1605             ist->file_index = i;
1606             ist->index = k;
1607             ist->discard = 1; /* the stream is discarded by default
1608                                  (changed later) */
1609
1610             if (rate_emu) {
1611                 ist->start = av_gettime();
1612             }
1613         }
1614     }
1615
1616     /* output stream init */
1617     nb_ostreams = 0;
1618     for(i=0;i<nb_output_files;i++) {
1619         os = output_files[i];
1620         if (!os->nb_streams) {
1621             dump_format(output_files[i], i, output_files[i]->filename, 1);
1622             fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1623             av_exit(1);
1624         }
1625         nb_ostreams += os->nb_streams;
1626     }
1627     if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1628         fprintf(stderr, "Number of stream maps must match number of output streams\n");
1629         av_exit(1);
1630     }
1631
1632     /* Sanity check the mapping args -- do the input files & streams exist? */
1633     for(i=0;i<nb_stream_maps;i++) {
1634         int fi = stream_maps[i].file_index;
1635         int si = stream_maps[i].stream_index;
1636
1637         if (fi < 0 || fi > nb_input_files - 1 ||
1638             si < 0 || si > file_table[fi].nb_streams - 1) {
1639             fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1640             av_exit(1);
1641         }
1642         fi = stream_maps[i].sync_file_index;
1643         si = stream_maps[i].sync_stream_index;
1644         if (fi < 0 || fi > nb_input_files - 1 ||
1645             si < 0 || si > file_table[fi].nb_streams - 1) {
1646             fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1647             av_exit(1);
1648         }
1649     }
1650
1651     ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1652     if (!ost_table)
1653         goto fail;
1654     for(i=0;i<nb_ostreams;i++) {
1655         ost = av_mallocz(sizeof(AVOutputStream));
1656         if (!ost)
1657             goto fail;
1658         ost_table[i] = ost;
1659     }
1660
1661     n = 0;
1662     for(k=0;k<nb_output_files;k++) {
1663         os = output_files[k];
1664         for(i=0;i<os->nb_streams;i++,n++) {
1665             int found;
1666             ost = ost_table[n];
1667             ost->file_index = k;
1668             ost->index = i;
1669             ost->st = os->streams[i];
1670             if (nb_stream_maps > 0) {
1671                 ost->source_index = file_table[stream_maps[n].file_index].ist_index +
1672                     stream_maps[n].stream_index;
1673
1674                 /* Sanity check that the stream types match */
1675                 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1676                     int i= ost->file_index;
1677                     dump_format(output_files[i], i, output_files[i]->filename, 1);
1678                     fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1679                         stream_maps[n].file_index, stream_maps[n].stream_index,
1680                         ost->file_index, ost->index);
1681                     av_exit(1);
1682                 }
1683
1684             } else {
1685                 if(opt_programid) {
1686                     found = 0;
1687                     j = stream_index_from_inputs(input_files, nb_input_files, file_table, ist_table, ost->st->codec->codec_type, opt_programid);
1688                     if(j != -1) {
1689                         ost->source_index = j;
1690                         found = 1;
1691                     }
1692                 } else {
1693                     /* get corresponding input stream index : we select the first one with the right type */
1694                     found = 0;
1695                     for(j=0;j<nb_istreams;j++) {
1696                         ist = ist_table[j];
1697                         if (ist->discard &&
1698                             ist->st->codec->codec_type == ost->st->codec->codec_type) {
1699                             ost->source_index = j;
1700                             found = 1;
1701                             break;
1702                         }
1703                     }
1704                 }
1705
1706                 if (!found) {
1707                     if(! opt_programid) {
1708                         /* try again and reuse existing stream */
1709                         for(j=0;j<nb_istreams;j++) {
1710                             ist = ist_table[j];
1711                             if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1712                                 ost->source_index = j;
1713                                 found = 1;
1714                             }
1715                         }
1716                     }
1717                     if (!found) {
1718                         int i= ost->file_index;
1719                         dump_format(output_files[i], i, output_files[i]->filename, 1);
1720                         fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1721                                 ost->file_index, ost->index);
1722                         av_exit(1);
1723                     }
1724                 }
1725             }
1726             ist = ist_table[ost->source_index];
1727             ist->discard = 0;
1728             ost->sync_ist = (nb_stream_maps > 0) ?
1729                 ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
1730                          stream_maps[n].sync_stream_index] : ist;
1731         }
1732     }
1733
1734     /* for each output stream, we compute the right encoding parameters */
1735     for(i=0;i<nb_ostreams;i++) {
1736         AVMetadataTag *lang;
1737         ost = ost_table[i];
1738         os = output_files[ost->file_index];
1739         ist = ist_table[ost->source_index];
1740
1741         codec = ost->st->codec;
1742         icodec = ist->st->codec;
1743
1744         if ((lang=av_metadata_get(ist->st->metadata, "language", NULL, 0))
1745             &&   !av_metadata_get(ost->st->metadata, "language", NULL, 0))
1746             av_metadata_set(&ost->st->metadata, "language", lang->value);
1747
1748         ost->st->disposition = ist->st->disposition;
1749
1750         if (ost->st->stream_copy) {
1751             /* if stream_copy is selected, no need to decode or encode */
1752             codec->codec_id = icodec->codec_id;
1753             codec->codec_type = icodec->codec_type;
1754
1755             if(!codec->codec_tag){
1756                 if(   !os->oformat->codec_tag
1757                    || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0
1758                    || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1759                     codec->codec_tag = icodec->codec_tag;
1760             }
1761
1762             codec->bit_rate = icodec->bit_rate;
1763             codec->extradata= icodec->extradata;
1764             codec->extradata_size= icodec->extradata_size;
1765             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){
1766                 codec->time_base = icodec->time_base;
1767                 codec->time_base.num *= icodec->ticks_per_frame;
1768             }else
1769                 codec->time_base = ist->st->time_base;
1770             switch(codec->codec_type) {
1771             case CODEC_TYPE_AUDIO:
1772                 if(audio_volume != 256) {
1773                     fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
1774                     av_exit(1);
1775                 }
1776                 codec->channel_layout = icodec->channel_layout;
1777                 codec->sample_rate = icodec->sample_rate;
1778                 codec->channels = icodec->channels;
1779                 codec->frame_size = icodec->frame_size;
1780                 codec->block_align= icodec->block_align;
1781                 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
1782                     codec->block_align= 0;
1783                 if(codec->codec_id == CODEC_ID_AC3)
1784                     codec->block_align= 0;
1785                 break;
1786             case CODEC_TYPE_VIDEO:
1787                 codec->pix_fmt = icodec->pix_fmt;
1788                 codec->width = icodec->width;
1789                 codec->height = icodec->height;
1790                 codec->has_b_frames = icodec->has_b_frames;
1791                 break;
1792             case CODEC_TYPE_SUBTITLE:
1793                 codec->width = icodec->width;
1794                 codec->height = icodec->height;
1795                 break;
1796             default:
1797                 abort();
1798             }
1799         } else {
1800             switch(codec->codec_type) {
1801             case CODEC_TYPE_AUDIO:
1802                 ost->fifo= av_fifo_alloc(1024);
1803                 if(!ost->fifo)
1804                     goto fail;
1805                 ost->reformat_pair = MAKE_SFMT_PAIR(SAMPLE_FMT_NONE,SAMPLE_FMT_NONE);
1806                 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
1807                 icodec->request_channels = codec->channels;
1808                 ist->decoding_needed = 1;
1809                 ost->encoding_needed = 1;
1810                 break;
1811             case CODEC_TYPE_VIDEO:
1812                 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1813                 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1814                 ost->video_resample = ((codec->width != icodec->width -
1815                                 (frame_leftBand + frame_rightBand) +
1816                                 (frame_padleft + frame_padright)) ||
1817                         (codec->height != icodec->height -
1818                                 (frame_topBand  + frame_bottomBand) +
1819                                 (frame_padtop + frame_padbottom)) ||
1820                         (codec->pix_fmt != icodec->pix_fmt));
1821                 if (ost->video_crop) {
1822                     ost->topBand = frame_topBand;
1823                     ost->leftBand = frame_leftBand;
1824                 }
1825                 if (ost->video_pad) {
1826                     ost->padtop = frame_padtop;
1827                     ost->padleft = frame_padleft;
1828                     ost->padbottom = frame_padbottom;
1829                     ost->padright = frame_padright;
1830                     if (!ost->video_resample) {
1831                         avcodec_get_frame_defaults(&ost->pict_tmp);
1832                         if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1833                                          codec->width, codec->height))
1834                             goto fail;
1835                     }
1836                 }
1837                 if (ost->video_resample) {
1838                     avcodec_get_frame_defaults(&ost->pict_tmp);
1839                     if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1840                                          codec->width, codec->height)) {
1841                         fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1842                         av_exit(1);
1843                     }
1844                     sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1845                     ost->img_resample_ctx = sws_getContext(
1846                             icodec->width - (frame_leftBand + frame_rightBand),
1847                             icodec->height - (frame_topBand + frame_bottomBand),
1848                             icodec->pix_fmt,
1849                             codec->width - (frame_padleft + frame_padright),
1850                             codec->height - (frame_padtop + frame_padbottom),
1851                             codec->pix_fmt,
1852                             sws_flags, NULL, NULL, NULL);
1853                     if (ost->img_resample_ctx == NULL) {
1854                         fprintf(stderr, "Cannot get resampling context\n");
1855                         av_exit(1);
1856                     }
1857                     ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1858                 }
1859                 ost->encoding_needed = 1;
1860                 ist->decoding_needed = 1;
1861                 break;
1862             case CODEC_TYPE_SUBTITLE:
1863                 ost->encoding_needed = 1;
1864                 ist->decoding_needed = 1;
1865                 break;
1866             default:
1867                 abort();
1868                 break;
1869             }
1870             /* two pass mode */
1871             if (ost->encoding_needed &&
1872                 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1873                 char logfilename[1024];
1874                 FILE *f;
1875                 int size;
1876                 char *logbuffer;
1877
1878                 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1879                          pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
1880                          i);
1881                 if (codec->flags & CODEC_FLAG_PASS1) {
1882                     f = fopen(logfilename, "w");
1883                     if (!f) {
1884                         fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
1885                         av_exit(1);
1886                     }
1887                     ost->logfile = f;
1888                 } else {
1889                     /* read the log file */
1890                     f = fopen(logfilename, "r");
1891                     if (!f) {
1892                         fprintf(stderr, "Cannot read log file '%s' for pass-2 encoding: %s\n", logfilename, strerror(errno));
1893                         av_exit(1);
1894                     }
1895                     fseek(f, 0, SEEK_END);
1896                     size = ftell(f);
1897                     fseek(f, 0, SEEK_SET);
1898                     logbuffer = av_malloc(size + 1);
1899                     if (!logbuffer) {
1900                         fprintf(stderr, "Could not allocate log buffer\n");
1901                         av_exit(1);
1902                     }
1903                     size = fread(logbuffer, 1, size, f);
1904                     fclose(f);
1905                     logbuffer[size] = '\0';
1906                     codec->stats_in = logbuffer;
1907                 }
1908             }
1909         }
1910         if(codec->codec_type == CODEC_TYPE_VIDEO){
1911             int size= codec->width * codec->height;
1912             bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
1913         }
1914     }
1915
1916     if (!bit_buffer)
1917         bit_buffer = av_malloc(bit_buffer_size);
1918     if (!bit_buffer) {
1919         ret = AVERROR(ENOMEM);
1920         goto fail;
1921     }
1922
1923     /* open each encoder */
1924     for(i=0;i<nb_ostreams;i++) {
1925         ost = ost_table[i];
1926         if (ost->encoding_needed) {
1927             AVCodec *codec = output_codecs[i];
1928             if (!codec)
1929                 codec = avcodec_find_encoder(ost->st->codec->codec_id);
1930             if (!codec) {
1931                 snprintf(error, sizeof(error), "Unsupported codec for output stream #%d.%d",
1932                         ost->file_index, ost->index);
1933                 ret = AVERROR(EINVAL);
1934                 goto dump_format;
1935             }
1936             if (avcodec_open(ost->st->codec, codec) < 0) {
1937                 snprintf(error, sizeof(error), "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
1938                         ost->file_index, ost->index);
1939                 ret = AVERROR(EINVAL);
1940                 goto dump_format;
1941             }
1942             extra_size += ost->st->codec->extradata_size;
1943         }
1944     }
1945
1946     /* open each decoder */
1947     for(i=0;i<nb_istreams;i++) {
1948         ist = ist_table[i];
1949         if (ist->decoding_needed) {
1950             AVCodec *codec = input_codecs[i];
1951             if (!codec)
1952                 codec = avcodec_find_decoder(ist->st->codec->codec_id);
1953             if (!codec) {
1954                 snprintf(error, sizeof(error), "Unsupported codec (id=%d) for input stream #%d.%d",
1955                         ist->st->codec->codec_id, ist->file_index, ist->index);
1956                 ret = AVERROR(EINVAL);
1957                 goto dump_format;
1958             }
1959             if (avcodec_open(ist->st->codec, codec) < 0) {
1960                 snprintf(error, sizeof(error), "Error while opening codec for input stream #%d.%d",
1961                         ist->file_index, ist->index);
1962                 ret = AVERROR(EINVAL);
1963                 goto dump_format;
1964             }
1965             //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1966             //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1967         }
1968     }
1969
1970     /* init pts */
1971     for(i=0;i<nb_istreams;i++) {
1972         ist = ist_table[i];
1973         is = input_files[ist->file_index];
1974         ist->pts = 0;
1975         ist->next_pts = AV_NOPTS_VALUE;
1976         ist->is_start = 1;
1977     }
1978
1979     /* set meta data information from input file if required */
1980     for (i=0;i<nb_meta_data_maps;i++) {
1981         AVFormatContext *out_file;
1982         AVFormatContext *in_file;
1983         AVMetadataTag *mtag;
1984
1985         int out_file_index = meta_data_maps[i].out_file;
1986         int in_file_index = meta_data_maps[i].in_file;
1987         if (out_file_index < 0 || out_file_index >= nb_output_files) {
1988             snprintf(error, sizeof(error), "Invalid output file index %d map_meta_data(%d,%d)",
1989                      out_file_index, out_file_index, in_file_index);
1990             ret = AVERROR(EINVAL);
1991             goto dump_format;
1992         }
1993         if (in_file_index < 0 || in_file_index >= nb_input_files) {
1994             snprintf(error, sizeof(error), "Invalid input file index %d map_meta_data(%d,%d)",
1995                      in_file_index, out_file_index, in_file_index);
1996             ret = AVERROR(EINVAL);
1997             goto dump_format;
1998         }
1999
2000         out_file = output_files[out_file_index];
2001         in_file = input_files[in_file_index];
2002
2003
2004         mtag=NULL;
2005         while((mtag=av_metadata_get(in_file->metadata, "", mtag, AV_METADATA_IGNORE_SUFFIX)))
2006             av_metadata_set(&out_file->metadata, mtag->key, mtag->value);
2007         av_metadata_conv(out_file, out_file->oformat->metadata_conv,
2008                                     in_file->iformat->metadata_conv);
2009     }
2010
2011     /* open files and write file headers */
2012     for(i=0;i<nb_output_files;i++) {
2013         os = output_files[i];
2014         if (av_write_header(os) < 0) {
2015             snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2016             ret = AVERROR(EINVAL);
2017             goto dump_format;
2018         }
2019         if (strcmp(output_files[i]->oformat->name, "rtp")) {
2020             want_sdp = 0;
2021         }
2022     }
2023
2024  dump_format:
2025     /* dump the file output parameters - cannot be done before in case
2026        of stream copy */
2027     for(i=0;i<nb_output_files;i++) {
2028         dump_format(output_files[i], i, output_files[i]->filename, 1);
2029     }
2030
2031     /* dump the stream mapping */
2032     if (verbose >= 0) {
2033         fprintf(stderr, "Stream mapping:\n");
2034         for(i=0;i<nb_ostreams;i++) {
2035             ost = ost_table[i];
2036             fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
2037                     ist_table[ost->source_index]->file_index,
2038                     ist_table[ost->source_index]->index,
2039                     ost->file_index,
2040                     ost->index);
2041             if (ost->sync_ist != ist_table[ost->source_index])
2042                 fprintf(stderr, " [sync #%d.%d]",
2043                         ost->sync_ist->file_index,
2044                         ost->sync_ist->index);
2045             fprintf(stderr, "\n");
2046         }
2047     }
2048
2049     if (ret) {
2050         fprintf(stderr, "%s\n", error);
2051         goto fail;
2052     }
2053
2054     if (want_sdp) {
2055         print_sdp(output_files, nb_output_files);
2056     }
2057
2058     if (!using_stdin && verbose >= 0) {
2059         fprintf(stderr, "Press [q] to stop encoding\n");
2060         url_set_interrupt_cb(decode_interrupt_cb);
2061     }
2062     term_init();
2063
2064     key = -1;
2065     timer_start = av_gettime();
2066
2067     for(; received_sigterm == 0;) {
2068         int file_index, ist_index;
2069         AVPacket pkt;
2070         double ipts_min;
2071         double opts_min;
2072
2073     redo:
2074         ipts_min= 1e100;
2075         opts_min= 1e100;
2076         /* if 'q' pressed, exits */
2077         if (!using_stdin) {
2078             if (q_pressed)
2079                 break;
2080             /* read_key() returns 0 on EOF */
2081             key = read_key();
2082             if (key == 'q')
2083                 break;
2084         }
2085
2086         /* select the stream that we must read now by looking at the
2087            smallest output pts */
2088         file_index = -1;
2089         for(i=0;i<nb_ostreams;i++) {
2090             double ipts, opts;
2091             ost = ost_table[i];
2092             os = output_files[ost->file_index];
2093             ist = ist_table[ost->source_index];
2094             if(no_packet[ist->file_index])
2095                 continue;
2096             if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
2097                 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
2098             else
2099                 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2100             ipts = (double)ist->pts;
2101             if (!file_table[ist->file_index].eof_reached){
2102                 if(ipts < ipts_min) {
2103                     ipts_min = ipts;
2104                     if(input_sync ) file_index = ist->file_index;
2105                 }
2106                 if(opts < opts_min) {
2107                     opts_min = opts;
2108                     if(!input_sync) file_index = ist->file_index;
2109                 }
2110             }
2111             if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2112                 file_index= -1;
2113                 break;
2114             }
2115         }
2116         /* if none, if is finished */
2117         if (file_index < 0) {
2118             if(no_packet_count){
2119                 no_packet_count=0;
2120                 memset(no_packet, 0, sizeof(no_packet));
2121                 usleep(10000);
2122                 continue;
2123             }
2124             break;
2125         }
2126
2127         /* finish if recording time exhausted */
2128         if (opts_min >= (recording_time / 1000000.0))
2129             break;
2130
2131         /* finish if limit size exhausted */
2132         if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2133             break;
2134
2135         /* read a frame from it and output it in the fifo */
2136         is = input_files[file_index];
2137         ret= av_read_frame(is, &pkt);
2138         if(ret == AVERROR(EAGAIN)){
2139             no_packet[file_index]=1;
2140             no_packet_count++;
2141             continue;
2142         }
2143         if (ret < 0) {
2144             file_table[file_index].eof_reached = 1;
2145             if (opt_shortest)
2146                 break;
2147             else
2148                 continue;
2149         }
2150
2151         no_packet_count=0;
2152         memset(no_packet, 0, sizeof(no_packet));
2153
2154         if (do_pkt_dump) {
2155             av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2156         }
2157         /* the following test is needed in case new streams appear
2158            dynamically in stream : we ignore them */
2159         if (pkt.stream_index >= file_table[file_index].nb_streams)
2160             goto discard_packet;
2161         ist_index = file_table[file_index].ist_index + pkt.stream_index;
2162         ist = ist_table[ist_index];
2163         if (ist->discard)
2164             goto discard_packet;
2165
2166         if (pkt.dts != AV_NOPTS_VALUE)
2167             pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2168         if (pkt.pts != AV_NOPTS_VALUE)
2169             pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2170
2171         if(input_files_ts_scale[file_index][pkt.stream_index]){
2172             if(pkt.pts != AV_NOPTS_VALUE)
2173                 pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2174             if(pkt.dts != AV_NOPTS_VALUE)
2175                 pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2176         }
2177
2178 //        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);
2179         if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2180             && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2181             int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2182             int64_t delta= pkt_dts - ist->next_pts;
2183             if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2184                 input_files_ts_offset[ist->file_index]-= delta;
2185                 if (verbose > 2)
2186                     fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2187                 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2188                 if(pkt.pts != AV_NOPTS_VALUE)
2189                     pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2190             }
2191         }
2192
2193         //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
2194         if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2195
2196             if (verbose >= 0)
2197                 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2198                         ist->file_index, ist->index);
2199             if (exit_on_error)
2200                 av_exit(1);
2201             av_free_packet(&pkt);
2202             goto redo;
2203         }
2204
2205     discard_packet:
2206         av_free_packet(&pkt);
2207
2208         /* dump report by using the output first video and audio streams */
2209         print_report(output_files, ost_table, nb_ostreams, 0);
2210     }
2211
2212     /* at the end of stream, we must flush the decoder buffers */
2213     for(i=0;i<nb_istreams;i++) {
2214         ist = ist_table[i];
2215         if (ist->decoding_needed) {
2216             output_packet(ist, i, ost_table, nb_ostreams, NULL);
2217         }
2218     }
2219
2220     term_exit();
2221
2222     /* write the trailer if needed and close file */
2223     for(i=0;i<nb_output_files;i++) {
2224         os = output_files[i];
2225         av_write_trailer(os);
2226     }
2227
2228     /* dump report by using the first video and audio streams */
2229     print_report(output_files, ost_table, nb_ostreams, 1);
2230
2231     /* close each encoder */
2232     for(i=0;i<nb_ostreams;i++) {
2233         ost = ost_table[i];
2234         if (ost->encoding_needed) {
2235             av_freep(&ost->st->codec->stats_in);
2236             avcodec_close(ost->st->codec);
2237         }
2238     }
2239
2240     /* close each decoder */
2241     for(i=0;i<nb_istreams;i++) {
2242         ist = ist_table[i];
2243         if (ist->decoding_needed) {
2244             avcodec_close(ist->st->codec);
2245         }
2246     }
2247
2248     /* finished ! */
2249     ret = 0;
2250
2251  fail:
2252     av_freep(&bit_buffer);
2253     av_free(file_table);
2254
2255     if (ist_table) {
2256         for(i=0;i<nb_istreams;i++) {
2257             ist = ist_table[i];
2258             av_free(ist);
2259         }
2260         av_free(ist_table);
2261     }
2262     if (ost_table) {
2263         for(i=0;i<nb_ostreams;i++) {
2264             ost = ost_table[i];
2265             if (ost) {
2266                 if (ost->logfile) {
2267                     fclose(ost->logfile);
2268                     ost->logfile = NULL;
2269                 }
2270                 av_fifo_free(ost->fifo); /* works even if fifo is not
2271                                              initialized but set to zero */
2272                 av_free(ost->pict_tmp.data[0]);
2273                 if (ost->video_resample)
2274                     sws_freeContext(ost->img_resample_ctx);
2275                 if (ost->resample)
2276                     audio_resample_close(ost->resample);
2277                 if (ost->reformat_ctx)
2278                     av_audio_convert_free(ost->reformat_ctx);
2279                 av_free(ost);
2280             }
2281         }
2282         av_free(ost_table);
2283     }
2284     return ret;
2285 }
2286
2287 #if 0
2288 int file_read(const char *filename)
2289 {
2290     URLContext *h;
2291     unsigned char buffer[1024];
2292     int len, i;
2293
2294     if (url_open(&h, filename, O_RDONLY) < 0) {
2295         printf("could not open '%s'\n", filename);
2296         return -1;
2297     }
2298     for(;;) {
2299         len = url_read(h, buffer, sizeof(buffer));
2300         if (len <= 0)
2301             break;
2302         for(i=0;i<len;i++) putchar(buffer[i]);
2303     }
2304     url_close(h);
2305     return 0;
2306 }
2307 #endif
2308
2309 static void opt_format(const char *arg)
2310 {
2311     /* compatibility stuff for pgmyuv */
2312     if (!strcmp(arg, "pgmyuv")) {
2313         pgmyuv_compatibility_hack=1;
2314 //        opt_image_format(arg);
2315         arg = "image2";
2316         fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2317     }
2318
2319     file_iformat = av_find_input_format(arg);
2320     file_oformat = guess_format(arg, NULL, NULL);
2321     if (!file_iformat && !file_oformat) {
2322         fprintf(stderr, "Unknown input or output format: %s\n", arg);
2323         av_exit(1);
2324     }
2325 }
2326
2327 static void opt_video_rc_override_string(const char *arg)
2328 {
2329     video_rc_override_string = arg;
2330 }
2331
2332 static int opt_me_threshold(const char *opt, const char *arg)
2333 {
2334     me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2335     return 0;
2336 }
2337
2338 static void opt_loglevel(const char *opt, const char *arg)
2339 {
2340     int level = parse_number_or_die(opt, arg, OPT_INT, INT_MIN, INT_MAX);
2341     av_log_set_level(level);
2342 }
2343
2344 static int opt_verbose(const char *opt, const char *arg)
2345 {
2346     verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2347     return 0;
2348 }
2349
2350 static int opt_frame_rate(const char *opt, const char *arg)
2351 {
2352     if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2353         fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2354         av_exit(1);
2355     }
2356     return 0;
2357 }
2358
2359 static int opt_bitrate(const char *opt, const char *arg)
2360 {
2361     int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2362
2363     opt_default(opt, arg);
2364
2365     if (av_get_int(avcodec_opts[codec_type], "b", NULL) < 1000)
2366         fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2367
2368     return 0;
2369 }
2370
2371 static void opt_frame_crop_top(const char *arg)
2372 {
2373     frame_topBand = atoi(arg);
2374     if (frame_topBand < 0) {
2375         fprintf(stderr, "Incorrect top crop size\n");
2376         av_exit(1);
2377     }
2378     if ((frame_topBand % 2) != 0) {
2379         fprintf(stderr, "Top crop size must be a multiple of 2\n");
2380         av_exit(1);
2381     }
2382     if ((frame_topBand) >= frame_height){
2383         fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2384         av_exit(1);
2385     }
2386     frame_height -= frame_topBand;
2387 }
2388
2389 static void opt_frame_crop_bottom(const char *arg)
2390 {
2391     frame_bottomBand = atoi(arg);
2392     if (frame_bottomBand < 0) {
2393         fprintf(stderr, "Incorrect bottom crop size\n");
2394         av_exit(1);
2395     }
2396     if ((frame_bottomBand % 2) != 0) {
2397         fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2398         av_exit(1);
2399     }
2400     if ((frame_bottomBand) >= frame_height){
2401         fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2402         av_exit(1);
2403     }
2404     frame_height -= frame_bottomBand;
2405 }
2406
2407 static void opt_frame_crop_left(const char *arg)
2408 {
2409     frame_leftBand = atoi(arg);
2410     if (frame_leftBand < 0) {
2411         fprintf(stderr, "Incorrect left crop size\n");
2412         av_exit(1);
2413     }
2414     if ((frame_leftBand % 2) != 0) {
2415         fprintf(stderr, "Left crop size must be a multiple of 2\n");
2416         av_exit(1);
2417     }
2418     if ((frame_leftBand) >= frame_width){
2419         fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2420         av_exit(1);
2421     }
2422     frame_width -= frame_leftBand;
2423 }
2424
2425 static void opt_frame_crop_right(const char *arg)
2426 {
2427     frame_rightBand = atoi(arg);
2428     if (frame_rightBand < 0) {
2429         fprintf(stderr, "Incorrect right crop size\n");
2430         av_exit(1);
2431     }
2432     if ((frame_rightBand % 2) != 0) {
2433         fprintf(stderr, "Right crop size must be a multiple of 2\n");
2434         av_exit(1);
2435     }
2436     if ((frame_rightBand) >= frame_width){
2437         fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2438         av_exit(1);
2439     }
2440     frame_width -= frame_rightBand;
2441 }
2442
2443 static void opt_frame_size(const char *arg)
2444 {
2445     if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2446         fprintf(stderr, "Incorrect frame size\n");
2447         av_exit(1);
2448     }
2449     if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2450         fprintf(stderr, "Frame size must be a multiple of 2\n");
2451         av_exit(1);
2452     }
2453 }
2454
2455
2456 #define SCALEBITS 10
2457 #define ONE_HALF  (1 << (SCALEBITS - 1))
2458 #define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
2459
2460 #define RGB_TO_Y(r, g, b) \
2461 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2462   FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2463
2464 #define RGB_TO_U(r1, g1, b1, shift)\
2465 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         \
2466      FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2467
2468 #define RGB_TO_V(r1, g1, b1, shift)\
2469 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
2470    FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2471
2472 static void opt_pad_color(const char *arg) {
2473     /* Input is expected to be six hex digits similar to
2474        how colors are expressed in html tags (but without the #) */
2475     int rgb = strtol(arg, NULL, 16);
2476     int r,g,b;
2477
2478     r = (rgb >> 16);
2479     g = ((rgb >> 8) & 255);
2480     b = (rgb & 255);
2481
2482     padcolor[0] = RGB_TO_Y(r,g,b);
2483     padcolor[1] = RGB_TO_U(r,g,b,0);
2484     padcolor[2] = RGB_TO_V(r,g,b,0);
2485 }
2486
2487 static void opt_frame_pad_top(const char *arg)
2488 {
2489     frame_padtop = atoi(arg);
2490     if (frame_padtop < 0) {
2491         fprintf(stderr, "Incorrect top pad size\n");
2492         av_exit(1);
2493     }
2494     if ((frame_padtop % 2) != 0) {
2495         fprintf(stderr, "Top pad size must be a multiple of 2\n");
2496         av_exit(1);
2497     }
2498 }
2499
2500 static void opt_frame_pad_bottom(const char *arg)
2501 {
2502     frame_padbottom = atoi(arg);
2503     if (frame_padbottom < 0) {
2504         fprintf(stderr, "Incorrect bottom pad size\n");
2505         av_exit(1);
2506     }
2507     if ((frame_padbottom % 2) != 0) {
2508         fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2509         av_exit(1);
2510     }
2511 }
2512
2513
2514 static void opt_frame_pad_left(const char *arg)
2515 {
2516     frame_padleft = atoi(arg);
2517     if (frame_padleft < 0) {
2518         fprintf(stderr, "Incorrect left pad size\n");
2519         av_exit(1);
2520     }
2521     if ((frame_padleft % 2) != 0) {
2522         fprintf(stderr, "Left pad size must be a multiple of 2\n");
2523         av_exit(1);
2524     }
2525 }
2526
2527
2528 static void opt_frame_pad_right(const char *arg)
2529 {
2530     frame_padright = atoi(arg);
2531     if (frame_padright < 0) {
2532         fprintf(stderr, "Incorrect right pad size\n");
2533         av_exit(1);
2534     }
2535     if ((frame_padright % 2) != 0) {
2536         fprintf(stderr, "Right pad size must be a multiple of 2\n");
2537         av_exit(1);
2538     }
2539 }
2540
2541 static void list_fmts(void (*get_fmt_string)(char *buf, int buf_size, int fmt), int nb_fmts)
2542 {
2543     int i;
2544     char fmt_str[128];
2545     for (i=-1; i < nb_fmts; i++) {
2546         get_fmt_string (fmt_str, sizeof(fmt_str), i);
2547         fprintf(stdout, "%s\n", fmt_str);
2548     }
2549 }
2550
2551 static void opt_frame_pix_fmt(const char *arg)
2552 {
2553     if (strcmp(arg, "list")) {
2554         frame_pix_fmt = avcodec_get_pix_fmt(arg);
2555         if (frame_pix_fmt == PIX_FMT_NONE) {
2556             fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2557             av_exit(1);
2558         }
2559     } else {
2560         list_fmts(avcodec_pix_fmt_string, PIX_FMT_NB);
2561         av_exit(0);
2562     }
2563 }
2564
2565 static void opt_frame_aspect_ratio(const char *arg)
2566 {
2567     int x = 0, y = 0;
2568     double ar = 0;
2569     const char *p;
2570     char *end;
2571
2572     p = strchr(arg, ':');
2573     if (p) {
2574         x = strtol(arg, &end, 10);
2575         if (end == p)
2576             y = strtol(end+1, &end, 10);
2577         if (x > 0 && y > 0)
2578             ar = (double)x / (double)y;
2579     } else
2580         ar = strtod(arg, NULL);
2581
2582     if (!ar) {
2583         fprintf(stderr, "Incorrect aspect ratio specification.\n");
2584         av_exit(1);
2585     }
2586     frame_aspect_ratio = ar;
2587 }
2588
2589 static int opt_metadata(const char *opt, const char *arg)
2590 {
2591     char *mid= strchr(arg, '=');
2592
2593     if(!mid){
2594         fprintf(stderr, "Missing =\n");
2595         av_exit(1);
2596     }
2597     *mid++= 0;
2598
2599     metadata_count++;
2600     metadata= av_realloc(metadata, sizeof(*metadata)*metadata_count);
2601     metadata[metadata_count-1].key  = av_strdup(arg);
2602     metadata[metadata_count-1].value= av_strdup(mid);
2603
2604     return 0;
2605 }
2606
2607 static void opt_qscale(const char *arg)
2608 {
2609     video_qscale = atof(arg);
2610     if (video_qscale <= 0 ||
2611         video_qscale > 255) {
2612         fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2613         av_exit(1);
2614     }
2615 }
2616
2617 static void opt_top_field_first(const char *arg)
2618 {
2619     top_field_first= atoi(arg);
2620 }
2621
2622 static int opt_thread_count(const char *opt, const char *arg)
2623 {
2624     thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2625 #if !HAVE_THREADS
2626     if (verbose >= 0)
2627         fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2628 #endif
2629     return 0;
2630 }
2631
2632 static void opt_audio_sample_fmt(const char *arg)
2633 {
2634     if (strcmp(arg, "list"))
2635         audio_sample_fmt = avcodec_get_sample_fmt(arg);
2636     else {
2637         list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
2638         av_exit(0);
2639     }
2640 }
2641
2642 static int opt_audio_rate(const char *opt, const char *arg)
2643 {
2644     audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2645     return 0;
2646 }
2647
2648 static int opt_audio_channels(const char *opt, const char *arg)
2649 {
2650     audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2651     return 0;
2652 }
2653
2654 static void opt_video_channel(const char *arg)
2655 {
2656     video_channel = strtol(arg, NULL, 0);
2657 }
2658
2659 static void opt_video_standard(const char *arg)
2660 {
2661     video_standard = av_strdup(arg);
2662 }
2663
2664 static void opt_codec(int *pstream_copy, char **pcodec_name,
2665                       int codec_type, const char *arg)
2666 {
2667     av_freep(pcodec_name);
2668     if (!strcmp(arg, "copy")) {
2669         *pstream_copy = 1;
2670     } else {
2671         *pcodec_name = av_strdup(arg);
2672     }
2673 }
2674
2675 static void opt_audio_codec(const char *arg)
2676 {
2677     opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2678 }
2679
2680 static void opt_audio_tag(const char *arg)
2681 {
2682     char *tail;
2683     audio_codec_tag= strtol(arg, &tail, 0);
2684
2685     if(!tail || *tail)
2686         audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2687 }
2688
2689 static void opt_video_tag(const char *arg)
2690 {
2691     char *tail;
2692     video_codec_tag= strtol(arg, &tail, 0);
2693
2694     if(!tail || *tail)
2695         video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2696 }
2697
2698 static void opt_video_codec(const char *arg)
2699 {
2700     opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2701 }
2702
2703 static void opt_subtitle_codec(const char *arg)
2704 {
2705     opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2706 }
2707
2708 static void opt_subtitle_tag(const char *arg)
2709 {
2710     char *tail;
2711     subtitle_codec_tag= strtol(arg, &tail, 0);
2712
2713     if(!tail || *tail)
2714         subtitle_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2715 }
2716
2717 static void opt_map(const char *arg)
2718 {
2719     AVStreamMap *m;
2720     char *p;
2721
2722     m = &stream_maps[nb_stream_maps++];
2723
2724     m->file_index = strtol(arg, &p, 0);
2725     if (*p)
2726         p++;
2727
2728     m->stream_index = strtol(p, &p, 0);
2729     if (*p) {
2730         p++;
2731         m->sync_file_index = strtol(p, &p, 0);
2732         if (*p)
2733             p++;
2734         m->sync_stream_index = strtol(p, &p, 0);
2735     } else {
2736         m->sync_file_index = m->file_index;
2737         m->sync_stream_index = m->stream_index;
2738     }
2739 }
2740
2741 static void opt_map_meta_data(const char *arg)
2742 {
2743     AVMetaDataMap *m;
2744     char *p;
2745
2746     m = &meta_data_maps[nb_meta_data_maps++];
2747
2748     m->out_file = strtol(arg, &p, 0);
2749     if (*p)
2750         p++;
2751
2752     m->in_file = strtol(p, &p, 0);
2753 }
2754
2755 static void opt_input_ts_scale(const char *arg)
2756 {
2757     unsigned int stream;
2758     double scale;
2759     char *p;
2760
2761     stream = strtol(arg, &p, 0);
2762     if (*p)
2763         p++;
2764     scale= strtod(p, &p);
2765
2766     if(stream >= MAX_STREAMS)
2767         av_exit(1);
2768
2769     input_files_ts_scale[nb_input_files][stream]= scale;
2770 }
2771
2772 static int opt_recording_time(const char *opt, const char *arg)
2773 {
2774     recording_time = parse_time_or_die(opt, arg, 1);
2775     return 0;
2776 }
2777
2778 static int opt_start_time(const char *opt, const char *arg)
2779 {
2780     start_time = parse_time_or_die(opt, arg, 1);
2781     return 0;
2782 }
2783
2784 static int opt_rec_timestamp(const char *opt, const char *arg)
2785 {
2786     rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2787     return 0;
2788 }
2789
2790 static int opt_input_ts_offset(const char *opt, const char *arg)
2791 {
2792     input_ts_offset = parse_time_or_die(opt, arg, 1);
2793     return 0;
2794 }
2795
2796 static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2797 {
2798     const char *codec_string = encoder ? "encoder" : "decoder";
2799     AVCodec *codec;
2800
2801     if(!name)
2802         return CODEC_ID_NONE;
2803     codec = encoder ?
2804         avcodec_find_encoder_by_name(name) :
2805         avcodec_find_decoder_by_name(name);
2806     if(!codec) {
2807         fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
2808         av_exit(1);
2809     }
2810     if(codec->type != type) {
2811         fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
2812         av_exit(1);
2813     }
2814     return codec->id;
2815 }
2816
2817 static void opt_input_file(const char *filename)
2818 {
2819     AVFormatContext *ic;
2820     AVFormatParameters params, *ap = &params;
2821     int err, i, ret, rfps, rfps_base;
2822     int64_t timestamp;
2823
2824     if (!strcmp(filename, "-"))
2825         filename = "pipe:";
2826
2827     using_stdin |= !strncmp(filename, "pipe:", 5) ||
2828                     !strcmp(filename, "/dev/stdin");
2829
2830     /* get default parameters from command line */
2831     ic = avformat_alloc_context();
2832
2833     memset(ap, 0, sizeof(*ap));
2834     ap->prealloced_context = 1;
2835     ap->sample_rate = audio_sample_rate;
2836     ap->channels = audio_channels;
2837     ap->time_base.den = frame_rate.num;
2838     ap->time_base.num = frame_rate.den;
2839     ap->width = frame_width + frame_padleft + frame_padright;
2840     ap->height = frame_height + frame_padtop + frame_padbottom;
2841     ap->pix_fmt = frame_pix_fmt;
2842    // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
2843     ap->channel = video_channel;
2844     ap->standard = video_standard;
2845     ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
2846     ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
2847     if(pgmyuv_compatibility_hack)
2848         ap->video_codec_id= CODEC_ID_PGMYUV;
2849
2850     set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2851
2852     ic->video_codec_id   = find_codec_or_die(video_codec_name   , CODEC_TYPE_VIDEO   , 0);
2853     ic->audio_codec_id   = find_codec_or_die(audio_codec_name   , CODEC_TYPE_AUDIO   , 0);
2854     ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2855     ic->flags |= AVFMT_FLAG_NONBLOCK;
2856
2857     /* open the input file with generic libav function */
2858     err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2859     if (err < 0) {
2860         print_error(filename, err);
2861         av_exit(1);
2862     }
2863     if(opt_programid) {
2864         int i;
2865         for(i=0; i<ic->nb_programs; i++)
2866             if(ic->programs[i]->id != opt_programid)
2867                 ic->programs[i]->discard = AVDISCARD_ALL;
2868     }
2869
2870     ic->loop_input = loop_input;
2871
2872     /* If not enough info to get the stream parameters, we decode the
2873        first frames to get it. (used in mpeg case for example) */
2874     ret = av_find_stream_info(ic);
2875     if (ret < 0 && verbose >= 0) {
2876         fprintf(stderr, "%s: could not find codec parameters\n", filename);
2877         av_exit(1);
2878     }
2879
2880     timestamp = start_time;
2881     /* add the stream start time */
2882     if (ic->start_time != AV_NOPTS_VALUE)
2883         timestamp += ic->start_time;
2884
2885     /* if seeking requested, we execute it */
2886     if (start_time != 0) {
2887         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2888         if (ret < 0) {
2889             fprintf(stderr, "%s: could not seek to position %0.3f\n",
2890                     filename, (double)timestamp / AV_TIME_BASE);
2891         }
2892         /* reset seek info */
2893         start_time = 0;
2894     }
2895
2896     /* update the current parameters so that they match the one of the input stream */
2897     for(i=0;i<ic->nb_streams;i++) {
2898         AVCodecContext *enc = ic->streams[i]->codec;
2899         if(thread_count>1)
2900             avcodec_thread_init(enc, thread_count);
2901         enc->thread_count= thread_count;
2902         switch(enc->codec_type) {
2903         case CODEC_TYPE_AUDIO:
2904             set_context_opts(enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2905             //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2906             channel_layout = enc->channel_layout;
2907             audio_channels = enc->channels;
2908             audio_sample_rate = enc->sample_rate;
2909             audio_sample_fmt = enc->sample_fmt;
2910             input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(audio_codec_name);
2911             if(audio_disable)
2912                 ic->streams[i]->discard= AVDISCARD_ALL;
2913             break;
2914         case CODEC_TYPE_VIDEO:
2915             set_context_opts(enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2916             frame_height = enc->height;
2917             frame_width = enc->width;
2918             if(ic->streams[i]->sample_aspect_ratio.num)
2919                 frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
2920             else
2921                 frame_aspect_ratio=av_q2d(enc->sample_aspect_ratio);
2922             frame_aspect_ratio *= (float) enc->width / enc->height;
2923             frame_pix_fmt = enc->pix_fmt;
2924             rfps      = ic->streams[i]->r_frame_rate.num;
2925             rfps_base = ic->streams[i]->r_frame_rate.den;
2926             if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2927             if(me_threshold)
2928                 enc->debug |= FF_DEBUG_MV;
2929
2930             if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2931
2932                 if (verbose >= 0)
2933                     fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2934                             i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2935
2936                     (float)rfps / rfps_base, rfps, rfps_base);
2937             }
2938             /* update the current frame rate to match the stream frame rate */
2939             frame_rate.num = rfps;
2940             frame_rate.den = rfps_base;
2941
2942             input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(video_codec_name);
2943             if(video_disable)
2944                 ic->streams[i]->discard= AVDISCARD_ALL;
2945             else if(video_discard)
2946                 ic->streams[i]->discard= video_discard;
2947             break;
2948         case CODEC_TYPE_DATA:
2949             break;
2950         case CODEC_TYPE_SUBTITLE:
2951             input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(subtitle_codec_name);
2952             if(subtitle_disable)
2953                 ic->streams[i]->discard = AVDISCARD_ALL;
2954             break;
2955         case CODEC_TYPE_ATTACHMENT:
2956         case CODEC_TYPE_UNKNOWN:
2957             nb_icodecs++;
2958             break;
2959         default:
2960             abort();
2961         }
2962     }
2963
2964     input_files[nb_input_files] = ic;
2965     input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2966     /* dump the file content */
2967     if (verbose >= 0)
2968         dump_format(ic, nb_input_files, filename, 0);
2969
2970     nb_input_files++;
2971     file_iformat = NULL;
2972     file_oformat = NULL;
2973
2974     video_channel = 0;
2975
2976     av_freep(&video_codec_name);
2977     av_freep(&audio_codec_name);
2978     av_freep(&subtitle_codec_name);
2979 }
2980
2981 static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2982                                          int *has_subtitle_ptr)
2983 {
2984     int has_video, has_audio, has_subtitle, i, j;
2985     AVFormatContext *ic;
2986
2987     has_video = 0;
2988     has_audio = 0;
2989     has_subtitle = 0;
2990     for(j=0;j<nb_input_files;j++) {
2991         ic = input_files[j];
2992         for(i=0;i<ic->nb_streams;i++) {
2993             AVCodecContext *enc = ic->streams[i]->codec;
2994             switch(enc->codec_type) {
2995             case CODEC_TYPE_AUDIO:
2996                 has_audio = 1;
2997                 break;
2998             case CODEC_TYPE_VIDEO:
2999                 has_video = 1;
3000                 break;
3001             case CODEC_TYPE_SUBTITLE:
3002                 has_subtitle = 1;
3003                 break;
3004             case CODEC_TYPE_DATA:
3005             case CODEC_TYPE_ATTACHMENT:
3006             case CODEC_TYPE_UNKNOWN:
3007                 break;
3008             default:
3009                 abort();
3010             }
3011         }
3012     }
3013     *has_video_ptr = has_video;
3014     *has_audio_ptr = has_audio;
3015     *has_subtitle_ptr = has_subtitle;
3016 }
3017
3018 static void new_video_stream(AVFormatContext *oc)
3019 {
3020     AVStream *st;
3021     AVCodecContext *video_enc;
3022     int codec_id;
3023
3024     st = av_new_stream(oc, oc->nb_streams);
3025     if (!st) {
3026         fprintf(stderr, "Could not alloc stream\n");
3027         av_exit(1);
3028     }
3029     avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
3030     bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
3031     video_bitstream_filters= NULL;
3032
3033     if(thread_count>1)
3034         avcodec_thread_init(st->codec, thread_count);
3035
3036     video_enc = st->codec;
3037
3038     if(video_codec_tag)
3039         video_enc->codec_tag= video_codec_tag;
3040
3041     if(   (video_global_header&1)
3042        || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3043         video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3044         avcodec_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3045     }
3046     if(video_global_header&2){
3047         video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3048         avcodec_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3049     }
3050
3051     if (video_stream_copy) {
3052         st->stream_copy = 1;
3053         video_enc->codec_type = CODEC_TYPE_VIDEO;
3054         video_enc->sample_aspect_ratio =
3055         st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3056     } else {
3057         const char *p;
3058         int i;
3059         AVCodec *codec;
3060         AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3061
3062         if (video_codec_name) {
3063             codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
3064             codec = avcodec_find_encoder_by_name(video_codec_name);
3065             output_codecs[nb_ocodecs] = codec;
3066         } else {
3067             codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
3068             codec = avcodec_find_encoder(codec_id);
3069         }
3070
3071         video_enc->codec_id = codec_id;
3072
3073         set_context_opts(video_enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3074
3075         if (codec && codec->supported_framerates && !force_fps)
3076             fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3077         video_enc->time_base.den = fps.num;
3078         video_enc->time_base.num = fps.den;
3079
3080         video_enc->width = frame_width + frame_padright + frame_padleft;
3081         video_enc->height = frame_height + frame_padtop + frame_padbottom;
3082         video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3083         video_enc->pix_fmt = frame_pix_fmt;
3084         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3085
3086         if(codec && codec->pix_fmts){
3087             const enum PixelFormat *p= codec->pix_fmts;
3088             for(; *p!=-1; p++){
3089                 if(*p == video_enc->pix_fmt)
3090                     break;
3091             }
3092             if(*p == -1)
3093                 video_enc->pix_fmt = codec->pix_fmts[0];
3094         }
3095
3096         if (intra_only)
3097             video_enc->gop_size = 0;
3098         if (video_qscale || same_quality) {
3099             video_enc->flags |= CODEC_FLAG_QSCALE;
3100             video_enc->global_quality=
3101                 st->quality = FF_QP2LAMBDA * video_qscale;
3102         }
3103
3104         if(intra_matrix)
3105             video_enc->intra_matrix = intra_matrix;
3106         if(inter_matrix)
3107             video_enc->inter_matrix = inter_matrix;
3108
3109         video_enc->thread_count = thread_count;
3110         p= video_rc_override_string;
3111         for(i=0; p; i++){
3112             int start, end, q;
3113             int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3114             if(e!=3){
3115                 fprintf(stderr, "error parsing rc_override\n");
3116                 av_exit(1);
3117             }
3118             video_enc->rc_override=
3119                 av_realloc(video_enc->rc_override,
3120                            sizeof(RcOverride)*(i+1));
3121             video_enc->rc_override[i].start_frame= start;
3122             video_enc->rc_override[i].end_frame  = end;
3123             if(q>0){
3124                 video_enc->rc_override[i].qscale= q;
3125                 video_enc->rc_override[i].quality_factor= 1.0;
3126             }
3127             else{
3128                 video_enc->rc_override[i].qscale= 0;
3129                 video_enc->rc_override[i].quality_factor= -q/100.0;
3130             }
3131             p= strchr(p, '/');
3132             if(p) p++;
3133         }
3134         video_enc->rc_override_count=i;
3135         if (!video_enc->rc_initial_buffer_occupancy)
3136             video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3137         video_enc->me_threshold= me_threshold;
3138         video_enc->intra_dc_precision= intra_dc_precision - 8;
3139
3140         if (do_psnr)
3141             video_enc->flags|= CODEC_FLAG_PSNR;
3142
3143         /* two pass mode */
3144         if (do_pass) {
3145             if (do_pass == 1) {
3146                 video_enc->flags |= CODEC_FLAG_PASS1;
3147             } else {
3148                 video_enc->flags |= CODEC_FLAG_PASS2;
3149             }
3150         }
3151     }
3152     nb_ocodecs++;
3153
3154     /* reset some key parameters */
3155     video_disable = 0;
3156     av_freep(&video_codec_name);
3157     video_stream_copy = 0;
3158 }
3159
3160 static void new_audio_stream(AVFormatContext *oc)
3161 {
3162     AVStream *st;
3163     AVCodecContext *audio_enc;
3164     int codec_id;
3165
3166     st = av_new_stream(oc, oc->nb_streams);
3167     if (!st) {
3168         fprintf(stderr, "Could not alloc stream\n");
3169         av_exit(1);
3170     }
3171     avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3172
3173     bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3174     audio_bitstream_filters= NULL;
3175
3176     if(thread_count>1)
3177         avcodec_thread_init(st->codec, thread_count);
3178
3179     audio_enc = st->codec;
3180     audio_enc->codec_type = CODEC_TYPE_AUDIO;
3181
3182     if(audio_codec_tag)
3183         audio_enc->codec_tag= audio_codec_tag;
3184
3185     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3186         audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3187         avcodec_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3188     }
3189     if (audio_stream_copy) {
3190         st->stream_copy = 1;
3191         audio_enc->channels = audio_channels;
3192     } else {
3193         AVCodec *codec;
3194
3195         set_context_opts(audio_enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3196
3197         if (audio_codec_name) {
3198             codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3199             codec = avcodec_find_encoder_by_name(audio_codec_name);
3200             output_codecs[nb_ocodecs] = codec;
3201         } else {
3202             codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3203             codec = avcodec_find_encoder(codec_id);
3204         }
3205         audio_enc->codec_id = codec_id;
3206
3207         if (audio_qscale > QSCALE_NONE) {
3208             audio_enc->flags |= CODEC_FLAG_QSCALE;
3209             audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3210         }
3211         audio_enc->thread_count = thread_count;
3212         audio_enc->channels = audio_channels;
3213         audio_enc->sample_fmt = audio_sample_fmt;
3214         audio_enc->channel_layout = channel_layout;
3215
3216         if(codec && codec->sample_fmts){
3217             const enum SampleFormat *p= codec->sample_fmts;
3218             for(; *p!=-1; p++){
3219                 if(*p == audio_enc->sample_fmt)
3220                     break;
3221             }
3222             if(*p == -1)
3223                 audio_enc->sample_fmt = codec->sample_fmts[0];
3224         }
3225     }
3226     nb_ocodecs++;
3227     audio_enc->sample_rate = audio_sample_rate;
3228     audio_enc->time_base= (AVRational){1, audio_sample_rate};
3229     if (audio_language) {
3230         av_metadata_set(&st->metadata, "language", audio_language);
3231         av_free(audio_language);
3232         audio_language = NULL;
3233     }
3234
3235     /* reset some key parameters */
3236     audio_disable = 0;
3237     av_freep(&audio_codec_name);
3238     audio_stream_copy = 0;
3239 }
3240
3241 static void new_subtitle_stream(AVFormatContext *oc)
3242 {
3243     AVStream *st;
3244     AVCodecContext *subtitle_enc;
3245
3246     st = av_new_stream(oc, oc->nb_streams);
3247     if (!st) {
3248         fprintf(stderr, "Could not alloc stream\n");
3249         av_exit(1);
3250     }
3251     avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3252
3253     bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3254     subtitle_bitstream_filters= NULL;
3255
3256     subtitle_enc = st->codec;
3257     subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3258
3259     if(subtitle_codec_tag)
3260         subtitle_enc->codec_tag= subtitle_codec_tag;
3261
3262     if (subtitle_stream_copy) {
3263         st->stream_copy = 1;
3264     } else {
3265         set_context_opts(avcodec_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3266         subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3267         output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name);
3268     }
3269     nb_ocodecs++;
3270
3271     if (subtitle_language) {
3272         av_metadata_set(&st->metadata, "language", subtitle_language);
3273         av_free(subtitle_language);
3274         subtitle_language = NULL;
3275     }
3276
3277     subtitle_disable = 0;
3278     av_freep(&subtitle_codec_name);
3279     subtitle_stream_copy = 0;
3280 }
3281
3282 static void opt_new_audio_stream(void)
3283 {
3284     AVFormatContext *oc;
3285     if (nb_output_files <= 0) {
3286         fprintf(stderr, "At least one output file must be specified\n");
3287         av_exit(1);
3288     }
3289     oc = output_files[nb_output_files - 1];
3290     new_audio_stream(oc);
3291 }
3292
3293 static void opt_new_video_stream(void)
3294 {
3295     AVFormatContext *oc;
3296     if (nb_output_files <= 0) {
3297         fprintf(stderr, "At least one output file must be specified\n");
3298         av_exit(1);
3299     }
3300     oc = output_files[nb_output_files - 1];
3301     new_video_stream(oc);
3302 }
3303
3304 static void opt_new_subtitle_stream(void)
3305 {
3306     AVFormatContext *oc;
3307     if (nb_output_files <= 0) {
3308         fprintf(stderr, "At least one output file must be specified\n");
3309         av_exit(1);
3310     }
3311     oc = output_files[nb_output_files - 1];
3312     new_subtitle_stream(oc);
3313 }
3314
3315 static void opt_output_file(const char *filename)
3316 {
3317     AVFormatContext *oc;
3318     int use_video, use_audio, use_subtitle;
3319     int input_has_video, input_has_audio, input_has_subtitle;
3320     AVFormatParameters params, *ap = &params;
3321
3322     if (!strcmp(filename, "-"))
3323         filename = "pipe:";
3324
3325     oc = avformat_alloc_context();
3326
3327     if (!file_oformat) {
3328         file_oformat = guess_format(NULL, filename, NULL);
3329         if (!file_oformat) {
3330             fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3331                     filename);
3332             av_exit(1);
3333         }
3334     }
3335
3336     oc->oformat = file_oformat;
3337     av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3338
3339     if (!strcmp(file_oformat->name, "ffm") &&
3340         av_strstart(filename, "http:", NULL)) {
3341         /* special case for files sent to ffserver: we get the stream
3342            parameters from ffserver */
3343         int err = read_ffserver_streams(oc, filename);
3344         if (err < 0) {
3345             print_error(filename, err);
3346             av_exit(1);
3347         }
3348     } else {
3349         use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3350         use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3351         use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3352
3353         /* disable if no corresponding type found and at least one
3354            input file */
3355         if (nb_input_files > 0) {
3356             check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3357                                          &input_has_subtitle);
3358             if (!input_has_video)
3359                 use_video = 0;
3360             if (!input_has_audio)
3361                 use_audio = 0;
3362             if (!input_has_subtitle)
3363                 use_subtitle = 0;
3364         }
3365
3366         /* manual disable */
3367         if (audio_disable) {
3368             use_audio = 0;
3369         }
3370         if (video_disable) {
3371             use_video = 0;
3372         }
3373         if (subtitle_disable) {
3374             use_subtitle = 0;
3375         }
3376
3377         if (use_video) {
3378             new_video_stream(oc);
3379         }
3380
3381         if (use_audio) {
3382             new_audio_stream(oc);
3383         }
3384
3385         if (use_subtitle) {
3386             new_subtitle_stream(oc);
3387         }
3388
3389         oc->timestamp = rec_timestamp;
3390
3391         for(; metadata_count>0; metadata_count--){
3392             av_metadata_set(&oc->metadata, metadata[metadata_count-1].key,
3393                                            metadata[metadata_count-1].value);
3394         }
3395         av_metadata_conv(oc, oc->oformat->metadata_conv, NULL);
3396     }
3397
3398     output_files[nb_output_files++] = oc;
3399
3400     /* check filename in case of an image number is expected */
3401     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3402         if (!av_filename_number_test(oc->filename)) {
3403             print_error(oc->filename, AVERROR_NUMEXPECTED);
3404             av_exit(1);
3405         }
3406     }
3407
3408     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3409         /* test if it already exists to avoid loosing precious files */
3410         if (!file_overwrite &&
3411             (strchr(filename, ':') == NULL ||
3412              filename[1] == ':' ||
3413              av_strstart(filename, "file:", NULL))) {
3414             if (url_exist(filename)) {
3415                 if (!using_stdin) {
3416                     fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3417                     fflush(stderr);
3418                     if (!read_yesno()) {
3419                         fprintf(stderr, "Not overwriting - exiting\n");
3420                         av_exit(1);
3421                     }
3422                 }
3423                 else {
3424                     fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3425                     av_exit(1);
3426                 }
3427             }
3428         }
3429
3430         /* open the file */
3431         if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3432             fprintf(stderr, "Could not open '%s'\n", filename);
3433             av_exit(1);
3434         }
3435     }
3436
3437     memset(ap, 0, sizeof(*ap));
3438     if (av_set_parameters(oc, ap) < 0) {
3439         fprintf(stderr, "%s: Invalid encoding parameters\n",
3440                 oc->filename);
3441         av_exit(1);
3442     }
3443
3444     oc->preload= (int)(mux_preload*AV_TIME_BASE);
3445     oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3446     oc->loop_output = loop_output;
3447     oc->flags |= AVFMT_FLAG_NONBLOCK;
3448
3449     set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3450
3451     /* reset some options */
3452     file_oformat = NULL;
3453     file_iformat = NULL;
3454 }
3455
3456 /* same option as mencoder */
3457 static void opt_pass(const char *pass_str)
3458 {
3459     int pass;
3460     pass = atoi(pass_str);
3461     if (pass != 1 && pass != 2) {
3462         fprintf(stderr, "pass number can be only 1 or 2\n");
3463         av_exit(1);
3464     }
3465     do_pass = pass;
3466 }
3467
3468 static int64_t getutime(void)
3469 {
3470 #if HAVE_GETRUSAGE
3471     struct rusage rusage;
3472
3473     getrusage(RUSAGE_SELF, &rusage);
3474     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3475 #elif HAVE_GETPROCESSTIMES
3476     HANDLE proc;
3477     FILETIME c, e, k, u;
3478     proc = GetCurrentProcess();
3479     GetProcessTimes(proc, &c, &e, &k, &u);
3480     return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3481 #else
3482     return av_gettime();
3483 #endif
3484 }
3485
3486 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3487 {
3488     int i;
3489     const char *p = str;
3490     for(i = 0;; i++) {
3491         dest[i] = atoi(p);
3492         if(i == 63)
3493             break;
3494         p = strchr(p, ',');
3495         if(!p) {
3496             fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3497             av_exit(1);
3498         }
3499         p++;
3500     }
3501 }
3502
3503 static void opt_inter_matrix(const char *arg)
3504 {
3505     inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3506     parse_matrix_coeffs(inter_matrix, arg);
3507 }
3508
3509 static void opt_intra_matrix(const char *arg)
3510 {
3511     intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3512     parse_matrix_coeffs(intra_matrix, arg);
3513 }
3514
3515 /**
3516  * Trivial log callback.
3517  * Only suitable for show_help and similar since it lacks prefix handling.
3518  */
3519 static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3520 {
3521     vfprintf(stdout, fmt, vl);
3522 }
3523
3524 static void show_help(void)
3525 {
3526     av_log_set_callback(log_callback_help);
3527     printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3528            "Hyper fast Audio and Video encoder\n");
3529     printf("\n");
3530     show_help_options(options, "Main options:\n",
3531                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3532     show_help_options(options, "\nAdvanced options:\n",
3533                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3534                       OPT_EXPERT);
3535     show_help_options(options, "\nVideo options:\n",
3536                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3537                       OPT_VIDEO);
3538     show_help_options(options, "\nAdvanced Video options:\n",
3539                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3540                       OPT_VIDEO | OPT_EXPERT);
3541     show_help_options(options, "\nAudio options:\n",
3542                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3543                       OPT_AUDIO);
3544     show_help_options(options, "\nAdvanced Audio options:\n",
3545                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3546                       OPT_AUDIO | OPT_EXPERT);
3547     show_help_options(options, "\nSubtitle options:\n",
3548                       OPT_SUBTITLE | OPT_GRAB,
3549                       OPT_SUBTITLE);
3550     show_help_options(options, "\nAudio/Video grab options:\n",
3551                       OPT_GRAB,
3552                       OPT_GRAB);
3553     printf("\n");
3554     av_opt_show(avcodec_opts[0], NULL);
3555     printf("\n");
3556     av_opt_show(avformat_opts, NULL);
3557     printf("\n");
3558     av_opt_show(sws_opts, NULL);
3559 }
3560
3561 static void opt_target(const char *arg)
3562 {
3563     int norm = -1;
3564     static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3565
3566     if(!strncmp(arg, "pal-", 4)) {
3567         norm = 0;
3568         arg += 4;
3569     } else if(!strncmp(arg, "ntsc-", 5)) {
3570         norm = 1;
3571         arg += 5;
3572     } else if(!strncmp(arg, "film-", 5)) {
3573         norm = 2;
3574         arg += 5;
3575     } else {
3576         int fr;
3577         /* Calculate FR via float to avoid int overflow */
3578         fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3579         if(fr == 25000) {
3580             norm = 0;
3581         } else if((fr == 29970) || (fr == 23976)) {
3582             norm = 1;
3583         } else {
3584             /* Try to determine PAL/NTSC by peeking in the input files */
3585             if(nb_input_files) {
3586                 int i, j;
3587                 for(j = 0; j < nb_input_files; j++) {
3588                     for(i = 0; i < input_files[j]->nb_streams; i++) {
3589                         AVCodecContext *c = input_files[j]->streams[i]->codec;
3590                         if(c->codec_type != CODEC_TYPE_VIDEO)
3591                             continue;
3592                         fr = c->time_base.den * 1000 / c->time_base.num;
3593                         if(fr == 25000) {
3594                             norm = 0;
3595                             break;
3596                         } else if((fr == 29970) || (fr == 23976)) {
3597                             norm = 1;
3598                             break;
3599                         }
3600                     }
3601                     if(norm >= 0)
3602                         break;
3603                 }
3604             }
3605         }
3606         if(verbose && norm >= 0)
3607             fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3608     }
3609
3610     if(norm < 0) {
3611         fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3612         fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3613         fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3614         av_exit(1);
3615     }
3616
3617     if(!strcmp(arg, "vcd")) {
3618
3619         opt_video_codec("mpeg1video");
3620         opt_audio_codec("mp2");
3621         opt_format("vcd");
3622
3623         opt_frame_size(norm ? "352x240" : "352x288");
3624         opt_frame_rate(NULL, frame_rates[norm]);
3625         opt_default("gop", norm ? "18" : "15");
3626
3627         opt_default("b", "1150000");
3628         opt_default("maxrate", "1150000");
3629         opt_default("minrate", "1150000");
3630         opt_default("bufsize", "327680"); // 40*1024*8;
3631
3632         opt_default("ab", "224000");
3633         audio_sample_rate = 44100;
3634         audio_channels = 2;
3635
3636         opt_default("packetsize", "2324");
3637         opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3638
3639         /* We have to offset the PTS, so that it is consistent with the SCR.
3640            SCR starts at 36000, but the first two packs contain only padding
3641            and the first pack from the other stream, respectively, may also have
3642            been written before.
3643            So the real data starts at SCR 36000+3*1200. */
3644         mux_preload= (36000+3*1200) / 90000.0; //0.44
3645     } else if(!strcmp(arg, "svcd")) {
3646
3647         opt_video_codec("mpeg2video");
3648         opt_audio_codec("mp2");
3649         opt_format("svcd");
3650
3651         opt_frame_size(norm ? "480x480" : "480x576");
3652         opt_frame_rate(NULL, frame_rates[norm]);
3653         opt_default("gop", norm ? "18" : "15");
3654
3655         opt_default("b", "2040000");
3656         opt_default("maxrate", "2516000");
3657         opt_default("minrate", "0"); //1145000;
3658         opt_default("bufsize", "1835008"); //224*1024*8;
3659         opt_default("flags", "+scan_offset");
3660
3661
3662         opt_default("ab", "224000");
3663         audio_sample_rate = 44100;
3664
3665         opt_default("packetsize", "2324");
3666
3667     } else if(!strcmp(arg, "dvd")) {
3668
3669         opt_video_codec("mpeg2video");
3670         opt_audio_codec("ac3");
3671         opt_format("dvd");
3672
3673         opt_frame_size(norm ? "720x480" : "720x576");
3674         opt_frame_rate(NULL, frame_rates[norm]);
3675         opt_default("gop", norm ? "18" : "15");
3676
3677         opt_default("b", "6000000");
3678         opt_default("maxrate", "9000000");
3679         opt_default("minrate", "0"); //1500000;
3680         opt_default("bufsize", "1835008"); //224*1024*8;
3681
3682         opt_default("packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3683         opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3684
3685         opt_default("ab", "448000");
3686         audio_sample_rate = 48000;
3687
3688     } else if(!strncmp(arg, "dv", 2)) {
3689
3690         opt_format("dv");
3691
3692         opt_frame_size(norm ? "720x480" : "720x576");
3693         opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3694                                              (norm ? "yuv411p" : "yuv420p"));
3695         opt_frame_rate(NULL, frame_rates[norm]);
3696
3697         audio_sample_rate = 48000;
3698         audio_channels = 2;
3699
3700     } else {
3701         fprintf(stderr, "Unknown target: %s\n", arg);
3702         av_exit(1);
3703     }
3704 }
3705
3706 static void opt_vstats_file (const char *arg)
3707 {
3708     av_free (vstats_filename);
3709     vstats_filename=av_strdup (arg);
3710 }
3711
3712 static void opt_vstats (void)
3713 {
3714     char filename[40];
3715     time_t today2 = time(NULL);
3716     struct tm *today = localtime(&today2);
3717
3718     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3719              today->tm_sec);
3720     opt_vstats_file(filename);
3721 }
3722
3723 static int opt_bsf(const char *opt, const char *arg)
3724 {
3725     AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3726     AVBitStreamFilterContext **bsfp;
3727
3728     if(!bsfc){
3729         fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3730         av_exit(1);
3731     }
3732
3733     bsfp= *opt == 'v' ? &video_bitstream_filters :
3734           *opt == 'a' ? &audio_bitstream_filters :
3735                         &subtitle_bitstream_filters;
3736     while(*bsfp)
3737         bsfp= &(*bsfp)->next;
3738
3739     *bsfp= bsfc;
3740
3741     return 0;
3742 }
3743
3744 static int opt_preset(const char *opt, const char *arg)
3745 {
3746     FILE *f=NULL;
3747     char filename[1000], tmp[1000], tmp2[1000], line[1000];
3748     int i;
3749     const char *base[2]= { getenv("HOME"),
3750                            FFMPEG_DATADIR,
3751                          };
3752
3753     for(i=!base[0]; i<2 && !f; i++){
3754         snprintf(filename, sizeof(filename), "%s%s/%s.ffpreset", base[i], i ? "" : "/.ffmpeg", arg);
3755         f= fopen(filename, "r");
3756         if(!f){
3757             char *codec_name= *opt == 'v' ? video_codec_name :
3758                               *opt == 'a' ? audio_codec_name :
3759                                             subtitle_codec_name;
3760             snprintf(filename, sizeof(filename), "%s%s/%s-%s.ffpreset", base[i],  i ? "" : "/.ffmpeg", codec_name, arg);
3761             f= fopen(filename, "r");
3762         }
3763     }
3764     if(!f && ((arg[0]=='.' && arg[1]=='/') || arg[0]=='/' ||
3765               is_dos_path(arg))){
3766         av_strlcpy(filename, arg, sizeof(filename));
3767         f= fopen(filename, "r");
3768     }
3769
3770     if(!f){
3771         fprintf(stderr, "File for preset '%s' not found\n", arg);
3772         av_exit(1);
3773     }
3774
3775     while(!feof(f)){
3776         int e= fscanf(f, "%999[^\n]\n", line) - 1;
3777         if(line[0] == '#' && !e)
3778             continue;
3779         e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
3780         if(e){
3781             fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
3782             av_exit(1);
3783         }
3784         if(!strcmp(tmp, "acodec")){
3785             opt_audio_codec(tmp2);
3786         }else if(!strcmp(tmp, "vcodec")){
3787             opt_video_codec(tmp2);
3788         }else if(!strcmp(tmp, "scodec")){
3789             opt_subtitle_codec(tmp2);
3790         }else if(opt_default(tmp, tmp2) < 0){
3791             fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
3792             av_exit(1);
3793         }
3794     }
3795
3796     fclose(f);
3797
3798     return 0;
3799 }
3800
3801 static const OptionDef options[] = {
3802     /* main options */
3803     { "L", OPT_EXIT, {(void*)show_license}, "show license" },
3804     { "h", OPT_EXIT, {(void*)show_help}, "show help" },
3805     { "version", OPT_EXIT, {(void*)show_version}, "show version" },
3806     { "formats", OPT_EXIT, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3807     { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3808     { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3809     { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3810     { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3811     { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3812     { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3813     { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
3814     { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3815     { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3816     { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
3817     { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp ('now' to set the current time)", "time" },
3818     { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)&opt_metadata}, "add metadata", "string=string" },
3819     { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3820     { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3821       "add timings for benchmarking" },
3822     { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3823       "dump each input packet" },
3824     { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3825       "when dumping packets, also dump the payload" },
3826     { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3827     { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3828     { "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)", "" },
3829     { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
3830     { "loglevel", HAS_ARG | OPT_FUNC2, {(void*)opt_loglevel}, "set libav* logging level", "number" },
3831     { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3832     { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3833     { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3834     { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3835     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
3836     { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3837     { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
3838     { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3839     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
3840     { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
3841     { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
3842     { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)&copy_initial_nonkeyframes}, "copy initial non-keyframes" },
3843
3844     /* video options */
3845     { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3846     { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3847     { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3848     { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3849     { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3850     { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3851     { "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" },
3852     { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3853     { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3854     { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3855     { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3856     { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3857     { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3858     { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3859     { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3860     { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3861     { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3862     { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3863     { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3864     { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3865     { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3866     { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3867     { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "threshold" },
3868     { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3869       "use same video quality as source (implies VBR)" },
3870     { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3871     { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
3872     { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3873       "deinterlace pictures" },
3874     { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3875     { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
3876     { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
3877     { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3878     { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3879     { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3880     { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3881     { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3882     { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3883     { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3884     { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
3885
3886     /* audio options */
3887     { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3888     { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3889     { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3890     { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3891     { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3892     { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3893     { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3894     { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3895     { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3896     { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3897     { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3898     { "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" },
3899
3900     /* subtitle options */
3901     { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3902     { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3903     { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3904     { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3905     { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
3906
3907     /* grab options */
3908     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3909     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3910     { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3911
3912     /* muxer options */
3913     { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3914     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3915
3916     { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3917     { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3918     { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3919
3920     { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
3921     { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
3922     { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
3923
3924     { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3925     { NULL, },
3926 };
3927
3928 int main(int argc, char **argv)
3929 {
3930     int i;
3931     int64_t ti;
3932
3933     avcodec_register_all();
3934     avdevice_register_all();
3935     av_register_all();
3936
3937     if(isatty(STDIN_FILENO))
3938         url_set_interrupt_cb(decode_interrupt_cb);
3939
3940     for(i=0; i<CODEC_TYPE_NB; i++){
3941         avcodec_opts[i]= avcodec_alloc_context2(i);
3942     }
3943     avformat_opts = avformat_alloc_context();
3944     sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3945
3946     show_banner();
3947
3948     /* parse options */
3949     parse_options(argc, argv, options, opt_output_file);
3950
3951     /* file converter / grab */
3952     if (nb_output_files <= 0) {
3953         fprintf(stderr, "At least one output file must be specified\n");
3954         av_exit(1);
3955     }
3956
3957     if (nb_input_files == 0) {
3958         fprintf(stderr, "At least one input file must be specified\n");
3959         av_exit(1);
3960     }
3961
3962     ti = getutime();
3963     if (av_encode(output_files, nb_output_files, input_files, nb_input_files,
3964                   stream_maps, nb_stream_maps) < 0)
3965         av_exit(1);
3966     ti = getutime() - ti;
3967     if (do_benchmark) {
3968         printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3969     }
3970
3971     return av_exit(0);
3972 }