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