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