ffmpeg.c

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