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