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