ffmpeg.c

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