git.sesse.net Git - ffmpeg/blob - ffmpeg.c

   1 /*
   2  * FFmpeg main
   3  * Copyright (c) 2000-2003 Fabrice Bellard
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18  */
  19 #define HAVE_AV_CONFIG_H
  20 #include "avformat.h"
  21 #include "framehook.h"
  22
  23 #ifndef CONFIG_WIN32
  24 #include <unistd.h>
  25 #include <fcntl.h>
  26 #include <sys/ioctl.h>
  27 #include <sys/time.h>
  28 #include <termios.h>
  29 #include <sys/resource.h>
  30 #include <signal.h>
  31 #endif
  32 #ifdef CONFIG_OS2
  33 #include <sys/types.h>
  34 #include <sys/select.h>
  35 #include <stdlib.h>
  36 #endif
  37 #undef time //needed because HAVE_AV_CONFIG_H is defined on top
  38 #include <time.h>
  39
  40 #include "cmdutils.h"
  41
  42 #if !defined(INFINITY) && defined(HUGE_VAL)
  43 #define INFINITY HUGE_VAL
  44 #endif
  45
  46 /* select an input stream for an output stream */
  47 typedef struct AVStreamMap {
  48     int file_index;
  49     int stream_index;
  50 } AVStreamMap;
  51
  52 extern const OptionDef options[];
  53
  54 static void show_help(void);
  55 static void show_license(void);
  56
  57 #define MAX_FILES 20
  58
  59 static AVFormatContext *input_files[MAX_FILES];
  60 static int nb_input_files = 0;
  61
  62 static AVFormatContext *output_files[MAX_FILES];
  63 static int nb_output_files = 0;
  64
  65 static AVStreamMap stream_maps[MAX_FILES];
  66 static int nb_stream_maps;
  67
  68 static AVInputFormat *file_iformat;
  69 static AVOutputFormat *file_oformat;
  70 static AVImageFormat *image_format;
  71 static int frame_width  = 160;
  72 static int frame_height = 128;
  73 static float frame_aspect_ratio = 0;
  74 static enum PixelFormat frame_pix_fmt = PIX_FMT_YUV420P;
  75 static int frame_padtop  = 0;
  76 static int frame_padbottom = 0;
  77 static int frame_padleft  = 0;
  78 static int frame_padright = 0;
  79 static int padcolor[3] = {16,128,128}; /* default to black */
  80 static int frame_topBand  = 0;
  81 static int frame_bottomBand = 0;
  82 static int frame_leftBand  = 0;
  83 static int frame_rightBand = 0;
  84 static int frame_rate = 25;
  85 static int frame_rate_base = 1;
  86 static int video_bit_rate = 200*1000;
  87 static int video_bit_rate_tolerance = 4000*1000;
  88 static float video_qscale = 0;
  89 static int video_qmin = 2;
  90 static int video_qmax = 31;
  91 static int video_mb_qmin = 2;
  92 static int video_mb_qmax = 31;
  93 static int video_qdiff = 3;
  94 static float video_qblur = 0.5;
  95 static float video_qcomp = 0.5;
  96 static uint16_t *intra_matrix = NULL;
  97 static uint16_t *inter_matrix = NULL;
  98 #if 0 //experimental, (can be removed)
  99 static float video_rc_qsquish=1.0;
 100 static float video_rc_qmod_amp=0;
 101 static int video_rc_qmod_freq=0;
 102 #endif
 103 static char *video_rc_override_string=NULL;
 104 static char *video_rc_eq="tex^qComp";
 105 static int video_rc_buffer_size=0;
 106 static float video_rc_buffer_aggressivity=1.0;
 107 static int video_rc_max_rate=0;
 108 static int video_rc_min_rate=0;
 109 static float video_rc_initial_cplx=0;
 110 static float video_b_qfactor = 1.25;
 111 static float video_b_qoffset = 1.25;
 112 static float video_i_qfactor = -0.8;
 113 static float video_i_qoffset = 0.0;
 114 static int video_intra_quant_bias= FF_DEFAULT_QUANT_BIAS;
 115 static int video_inter_quant_bias= FF_DEFAULT_QUANT_BIAS;
 116 static int me_method = ME_EPZS;
 117 static int video_disable = 0;
 118 static int video_codec_id = CODEC_ID_NONE;
 119 static int same_quality = 0;
 120 static int b_frames = 0;
 121 static int mb_decision = FF_MB_DECISION_SIMPLE;
 122 static int ildct_cmp = FF_CMP_VSAD;
 123 static int mb_cmp = FF_CMP_SAD;
 124 static int sub_cmp = FF_CMP_SAD;
 125 static int cmp = FF_CMP_SAD;
 126 static int pre_cmp = FF_CMP_SAD;
 127 static int pre_me = 0;
 128 static float lumi_mask = 0;
 129 static float dark_mask = 0;
 130 static float scplx_mask = 0;
 131 static float tcplx_mask = 0;
 132 static float p_mask = 0;
 133 static int use_4mv = 0;
 134 static int use_obmc = 0;
 135 static int use_loop = 0;
 136 static int use_aic = 0;
 137 static int use_aiv = 0;
 138 static int use_umv = 0;
 139 static int use_ss = 0;
 140 static int use_alt_scan = 0;
 141 static int use_trell = 0;
 142 static int use_scan_offset = 0;
 143 static int qns = 0;
 144 static int closed_gop = 0;
 145 static int do_deinterlace = 0;
 146 static int do_interlace_dct = 0;
 147 static int do_interlace_me = 0;
 148 static int workaround_bugs = FF_BUG_AUTODETECT;
 149 static int error_resilience = 2;
 150 static int error_concealment = 3;
 151 static int dct_algo = 0;
 152 static int idct_algo = 0;
 153 static int use_part = 0;
 154 static int packet_size = 0;
 155 static int error_rate = 0;
 156 static int strict = 0;
 157 static int top_field_first = -1;
 158 static int noise_reduction = 0;
 159 static int sc_threshold = 0;
 160 static int debug = 0;
 161 static int debug_mv = 0;
 162 extern int loop_input; /* currently a hack */
 163
 164 static int gop_size = 12;
 165 static int intra_only = 0;
 166 static int audio_sample_rate = 44100;
 167 static int audio_bit_rate = 64000;
 168 static int audio_disable = 0;
 169 static int audio_channels = 1;
 170 static int audio_codec_id = CODEC_ID_NONE;
 171
 172 static int64_t recording_time = 0;
 173 static int64_t start_time = 0;
 174 static int64_t rec_timestamp = 0;
 175 static int file_overwrite = 0;
 176 static char *str_title = NULL;
 177 static char *str_author = NULL;
 178 static char *str_copyright = NULL;
 179 static char *str_comment = NULL;
 180 static int do_benchmark = 0;
 181 static int do_hex_dump = 0;
 182 static int do_pkt_dump = 0;
 183 static int do_psnr = 0;
 184 static int do_vstats = 0;
 185 static int do_pass = 0;
 186 static int bitexact = 0;
 187 static char *pass_logfilename = NULL;
 188 static int audio_stream_copy = 0;
 189 static int video_stream_copy = 0;
 190
 191 static int rate_emu = 0;
 192
 193 static char *video_grab_format = "video4linux";
 194 static char *video_device = NULL;
 195 static int  video_channel = 0;
 196 static char *video_standard = "ntsc";
 197
 198 static char *audio_grab_format = "audio_device";
 199 static char *audio_device = NULL;
 200
 201 static int using_stdin = 0;
 202 static int using_vhook = 0;
 203 static int verbose = 1;
 204 static int thread_count= 1;
 205 static int q_pressed = 0;
 206 static int64_t video_size = 0;
 207 static int64_t audio_size = 0;
 208 static int64_t extra_size = 0;
 209
 210 #define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
 211
 212 typedef struct AVOutputStream {
 213     int file_index;          /* file index */
 214     int index;               /* stream index in the output file */
 215     int source_index;        /* AVInputStream index */
 216     AVStream *st;            /* stream in the output file */
 217     int encoding_needed;     /* true if encoding needed for this stream */
 218     int frame_number;
 219     /* input pts and corresponding output pts
 220        for A/V sync */
 221     double sync_ipts;
 222     double sync_ipts_offset;
 223     int64_t sync_opts;
 224     /* video only */
 225     int video_resample;      /* video_resample and video_crop are mutually exclusive */
 226     AVPicture pict_tmp;      /* temporary image for resampling */
 227     ImgReSampleContext *img_resample_ctx; /* for image resampling */
 228
 229     int video_crop;          /* video_resample and video_crop are mutually exclusive */
 230     int topBand;             /* cropping area sizes */
 231     int leftBand;
 232
 233     int video_pad;           /* video_resample and video_pad are mutually exclusive */
 234     int padtop;              /* padding area sizes */
 235     int padbottom;
 236     int padleft;
 237     int padright;
 238
 239     /* audio only */
 240     int audio_resample;
 241     ReSampleContext *resample; /* for audio resampling */
 242     FifoBuffer fifo;     /* for compression: one audio fifo per codec */
 243     FILE *logfile;
 244 } AVOutputStream;
 245
 246 typedef struct AVInputStream {
 247     int file_index;
 248     int index;
 249     AVStream *st;
 250     int discard;             /* true if stream data should be discarded */
 251     int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
 252     int64_t sample_index;      /* current sample */
 253
 254     int64_t       start;     /* time when read started */
 255     unsigned long frame;     /* current frame */
 256     int64_t       next_pts;  /* synthetic pts for cases where pkt.pts
 257                                 is not defined */
 258     int64_t       pts;       /* current pts */
 259 } AVInputStream;
 260
 261 typedef struct AVInputFile {
 262     int eof_reached;      /* true if eof reached */
 263     int ist_index;        /* index of first stream in ist_table */
 264     int buffer_size;      /* current total buffer size */
 265     int buffer_size_max;  /* buffer size at which we consider we can stop
 266                              buffering */
 267     int nb_streams;       /* nb streams we are aware of */
 268 } AVInputFile;
 269
 270 #ifndef CONFIG_WIN32
 271
 272 /* init terminal so that we can grab keys */
 273 static struct termios oldtty;
 274
 275 static void term_exit(void)
 276 {
 277     tcsetattr (0, TCSANOW, &oldtty);
 278 }
 279
 280 static volatile sig_atomic_t received_sigterm = 0;
 281
 282 static void
 283 sigterm_handler(int sig)
 284 {
 285     received_sigterm = sig;
 286     term_exit();
 287 }
 288
 289 static void term_init(void)
 290 {
 291     struct termios tty;
 292
 293     tcgetattr (0, &tty);
 294     oldtty = tty;
 295
 296     tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
 297                           |INLCR|IGNCR|ICRNL|IXON);
 298     tty.c_oflag |= OPOST;
 299     tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
 300     tty.c_cflag &= ~(CSIZE|PARENB);
 301     tty.c_cflag |= CS8;
 302     tty.c_cc[VMIN] = 1;
 303     tty.c_cc[VTIME] = 0;
 304
 305     tcsetattr (0, TCSANOW, &tty);
 306
 307     signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
 308     signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
 309     signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
 310     /*
 311     register a function to be called at normal program termination
 312     */
 313     atexit(term_exit);
 314 #ifdef CONFIG_BEOS_NETSERVER
 315     fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
 316 #endif
 317 }
 318
 319 /* read a key without blocking */
 320 static int read_key(void)
 321 {
 322     int n = 1;
 323     unsigned char ch;
 324 #ifndef CONFIG_BEOS_NETSERVER
 325     struct timeval tv;
 326     fd_set rfds;
 327
 328     FD_ZERO(&rfds);
 329     FD_SET(0, &rfds);
 330     tv.tv_sec = 0;
 331     tv.tv_usec = 0;
 332     n = select(1, &rfds, NULL, NULL, &tv);
 333 #endif
 334     if (n > 0) {
 335         n = read(0, &ch, 1);
 336         if (n == 1)
 337             return ch;
 338
 339         return n;
 340     }
 341     return -1;
 342 }
 343
 344 static int decode_interrupt_cb(void)
 345 {
 346     return q_pressed || (q_pressed = read_key() == 'q');
 347 }
 348
 349 #else
 350
 351 static volatile int received_sigterm = 0;
 352
 353 /* no interactive support */
 354 static void term_exit(void)
 355 {
 356 }
 357
 358 static void term_init(void)
 359 {
 360 }
 361
 362 static int read_key(void)
 363 {
 364     return 0;
 365 }
 366
 367 #endif
 368
 369 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
 370 {
 371     int i, err;
 372     AVFormatContext *ic;
 373
 374     err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
 375     if (err < 0)
 376         return err;
 377     /* copy stream format */
 378     s->nb_streams = ic->nb_streams;
 379     for(i=0;i<ic->nb_streams;i++) {
 380         AVStream *st;
 381
 382         st = av_mallocz(sizeof(AVStream));
 383         memcpy(st, ic->streams[i], sizeof(AVStream));
 384         s->streams[i] = st;
 385     }
 386
 387     av_close_input_file(ic);
 388     return 0;
 389 }
 390
 391 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
 392
 393 static void do_audio_out(AVFormatContext *s,
 394                          AVOutputStream *ost,
 395                          AVInputStream *ist,
 396                          unsigned char *buf, int size)
 397 {
 398     uint8_t *buftmp;
 399     static uint8_t *audio_buf = NULL;
 400     static uint8_t *audio_out = NULL;
 401     const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
 402
 403     int size_out, frame_bytes, ret;
 404     AVCodecContext *enc;
 405
 406     /* SC: dynamic allocation of buffers */
 407     if (!audio_buf)
 408         audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
 409     if (!audio_out)
 410         audio_out = av_malloc(audio_out_size);
 411     if (!audio_buf || !audio_out)
 412         return;               /* Should signal an error ! */
 413
 414
 415     enc = &ost->st->codec;
 416
 417     if (ost->audio_resample) {
 418         buftmp = audio_buf;
 419         size_out = audio_resample(ost->resample,
 420                                   (short *)buftmp, (short *)buf,
 421                                   size / (ist->st->codec.channels * 2));
 422         size_out = size_out * enc->channels * 2;
 423     } else {
 424         buftmp = buf;
 425         size_out = size;
 426     }
 427
 428     /* now encode as many frames as possible */
 429     if (enc->frame_size > 1) {
 430         /* output resampled raw samples */
 431         fifo_write(&ost->fifo, buftmp, size_out,
 432                    &ost->fifo.wptr);
 433
 434         frame_bytes = enc->frame_size * 2 * enc->channels;
 435
 436         while (fifo_read(&ost->fifo, audio_buf, frame_bytes,
 437                      &ost->fifo.rptr) == 0) {
 438             ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
 439                                        (short *)audio_buf);
 440             audio_size += ret;
 441             av_write_frame(s, ost->index, audio_out, ret);
 442         }
 443     } else {
 444         /* output a pcm frame */
 445         /* XXX: change encoding codec API to avoid this ? */
 446         switch(enc->codec->id) {
 447         case CODEC_ID_PCM_S16LE:
 448         case CODEC_ID_PCM_S16BE:
 449         case CODEC_ID_PCM_U16LE:
 450         case CODEC_ID_PCM_U16BE:
 451             break;
 452         default:
 453             size_out = size_out >> 1;
 454             break;
 455         }
 456         ret = avcodec_encode_audio(enc, audio_out, size_out,
 457                                    (short *)buftmp);
 458         audio_size += ret;
 459         av_write_frame(s, ost->index, audio_out, ret);
 460     }
 461 }
 462
 463 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
 464 {
 465     AVCodecContext *dec;
 466     AVPicture *picture2;
 467     AVPicture picture_tmp;
 468     uint8_t *buf = 0;
 469
 470     dec = &ist->st->codec;
 471
 472     /* deinterlace : must be done before any resize */
 473     if (do_deinterlace || using_vhook) {
 474         int size;
 475
 476         /* create temporary picture */
 477         size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
 478         buf = av_malloc(size);
 479         if (!buf)
 480             return;
 481
 482         picture2 = &picture_tmp;
 483         avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
 484
 485         if (do_deinterlace){
 486             if(avpicture_deinterlace(picture2, picture,
 487                                      dec->pix_fmt, dec->width, dec->height) < 0) {
 488                 /* if error, do not deinterlace */
 489                 av_free(buf);
 490                 buf = NULL;
 491                 picture2 = picture;
 492             }
 493         } else {
 494             if (img_convert(picture2, dec->pix_fmt, picture,
 495                             dec->pix_fmt, dec->width, dec->height) < 0) {
 496                 /* if error, do not copy */
 497                 av_free(buf);
 498                 buf = NULL;
 499                 picture2 = picture;
 500             }
 501         }
 502     } else {
 503         picture2 = picture;
 504     }
 505
 506     frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height);
 507
 508     if (picture != picture2)
 509         *picture = *picture2;
 510     *bufp = buf;
 511 }
 512
 513 /* we begin to correct av delay at this threshold */
 514 #define AV_DELAY_MAX 0.100
 515
 516
 517 /* Expects img to be yuv420 */
 518 static void fill_pad_region(AVPicture* img, int height, int width,
 519         int padtop, int padbottom, int padleft, int padright, int *color) {
 520
 521     int i, y, shift;
 522     uint8_t *optr;
 523
 524     for (i = 0; i < 3; i++) {
 525         shift = (i == 0) ? 0 : 1;
 526
 527         if (padtop || padleft) {
 528             memset(img->data[i], color[i], (((img->linesize[i] * padtop) +
 529                             padleft) >> shift));
 530         }
 531
 532         if (padleft || padright) {
 533             optr = img->data[i] + (img->linesize[i] * (padtop >> shift)) +
 534                 (img->linesize[i] - (padright >> shift));
 535
 536             for (y = 0; y < ((height - (padtop + padbottom)) >> shift); y++) {
 537                 memset(optr, color[i], (padleft + padright) >> shift);
 538                 optr += img->linesize[i];
 539             }
 540         }
 541
 542         if (padbottom) {
 543             optr = img->data[i] + (img->linesize[i] * ((height - padbottom) >> shift));
 544             memset(optr, color[i], ((img->linesize[i] * padbottom) >> shift));
 545         }
 546     }
 547 }
 548
 549
 550 static void do_video_out(AVFormatContext *s,
 551                          AVOutputStream *ost,
 552                          AVInputStream *ist,
 553                          AVFrame *in_picture,
 554                          int *frame_size, AVOutputStream *audio_sync)
 555 {
 556     int nb_frames, i, ret;
 557     AVPicture *final_picture, *formatted_picture;
 558     AVPicture picture_format_temp, picture_crop_temp;
 559     static uint8_t *video_buffer= NULL;
 560     uint8_t *buf = NULL, *buf1 = NULL;
 561     AVCodecContext *enc, *dec;
 562     enum PixelFormat target_pixfmt;
 563
 564 #define VIDEO_BUFFER_SIZE (1024*1024)
 565
 566     enc = &ost->st->codec;
 567     dec = &ist->st->codec;
 568
 569     /* by default, we output a single frame */
 570     nb_frames = 1;
 571
 572     *frame_size = 0;
 573
 574     /* NOTE: the A/V sync is always done by considering the audio is
 575        the master clock. It is suffisant for transcoding or playing,
 576        but not for the general case */
 577     if (audio_sync) {
 578         /* compute the A-V delay and duplicate/remove frames if needed */
 579         double adelta, vdelta, av_delay;
 580
 581         adelta = audio_sync->sync_ipts - ((double)audio_sync->sync_opts *
 582             s->pts_num / s->pts_den);
 583
 584         vdelta = ost->sync_ipts - ((double)ost->sync_opts *
 585             s->pts_num / s->pts_den);
 586
 587         av_delay = adelta - vdelta;
 588         //            printf("delay=%f\n", av_delay);
 589         if (av_delay < -AV_DELAY_MAX)
 590             nb_frames = 2;
 591         else if (av_delay > AV_DELAY_MAX)
 592             nb_frames = 0;
 593     } else {
 594         double vdelta;
 595
 596         vdelta = (double)(ost->st->pts.val) * s->pts_num / s->pts_den - (ost->sync_ipts - ost->sync_ipts_offset);
 597         if (vdelta < 100 && vdelta > -100 && ost->sync_ipts_offset) {
 598             if (vdelta < -AV_DELAY_MAX)
 599                 nb_frames = 2;
 600             else if (vdelta > AV_DELAY_MAX)
 601                 nb_frames = 0;
 602         } else {
 603             ost->sync_ipts_offset -= vdelta;
 604             if (!ost->sync_ipts_offset)
 605                 ost->sync_ipts_offset = 0.000001; /* one microsecond */
 606         }
 607     }
 608
 609 #if defined(AVSYNC_DEBUG)
 610     {
 611         static char *action[] = { "drop frame", "copy frame", "dup frame" };
 612         if (audio_sync && verbose >=0) {
 613             fprintf(stderr, "Input APTS %12.6f, output APTS %12.6f, ",
 614                     (double) audio_sync->sync_ipts,
 615                     (double) audio_sync->st->pts.val * s->pts_num / s->pts_den);
 616             fprintf(stderr, "Input VPTS %12.6f, output VPTS %12.6f: %s\n",
 617                     (double) ost->sync_ipts,
 618                     (double) ost->st->pts.val * s->pts_num / s->pts_den,
 619                     action[nb_frames]);
 620         }
 621     }
 622 #endif
 623
 624     if (nb_frames <= 0)
 625         return;
 626
 627     if (!video_buffer)
 628         video_buffer = av_malloc(VIDEO_BUFFER_SIZE);
 629     if (!video_buffer)
 630         return;
 631
 632     /* convert pixel format if needed */
 633     target_pixfmt = ost->video_resample || ost->video_pad
 634         ? PIX_FMT_YUV420P : enc->pix_fmt;
 635     if (dec->pix_fmt != target_pixfmt) {
 636         int size;
 637
 638         /* create temporary picture */
 639         size = avpicture_get_size(target_pixfmt, dec->width, dec->height);
 640         buf = av_malloc(size);
 641         if (!buf)
 642             return;
 643         formatted_picture = &picture_format_temp;
 644         avpicture_fill(formatted_picture, buf, target_pixfmt, dec->width, dec->height);
 645
 646         if (img_convert(formatted_picture, target_pixfmt,
 647                         (AVPicture *)in_picture, dec->pix_fmt,
 648                         dec->width, dec->height) < 0) {
 649
 650             if (verbose >= 0)
 651                 fprintf(stderr, "pixel format conversion not handled\n");
 652
 653             goto the_end;
 654         }
 655     } else {
 656         formatted_picture = (AVPicture *)in_picture;
 657     }
 658
 659     /* XXX: resampling could be done before raw format conversion in
 660        some cases to go faster */
 661     /* XXX: only works for YUV420P */
 662     if (ost->video_resample) {
 663         final_picture = &ost->pict_tmp;
 664         img_resample(ost->img_resample_ctx, final_picture, formatted_picture);
 665
 666         if (ost->padtop || ost->padbottom || ost->padleft || ost->padright) {
 667             fill_pad_region(final_picture, enc->height, enc->width,
 668                     ost->padtop, ost->padbottom, ost->padleft, ost->padright,
 669                     padcolor);
 670         }
 671
 672         if (enc->pix_fmt != PIX_FMT_YUV420P) {
 673             int size;
 674
 675             av_free(buf);
 676             /* create temporary picture */
 677             size = avpicture_get_size(enc->pix_fmt, enc->width, enc->height);
 678             buf = av_malloc(size);
 679             if (!buf)
 680                 return;
 681             final_picture = &picture_format_temp;
 682             avpicture_fill(final_picture, buf, enc->pix_fmt, enc->width, enc->height);
 683
 684             if (img_convert(final_picture, enc->pix_fmt,
 685                             &ost->pict_tmp, PIX_FMT_YUV420P,
 686                             enc->width, enc->height) < 0) {
 687
 688                 if (verbose >= 0)
 689                     fprintf(stderr, "pixel format conversion not handled\n");
 690
 691                 goto the_end;
 692             }
 693         }
 694     } else if (ost->video_crop) {
 695         picture_crop_temp.data[0] = formatted_picture->data[0] +
 696                 (ost->topBand * formatted_picture->linesize[0]) + ost->leftBand;
 697
 698         picture_crop_temp.data[1] = formatted_picture->data[1] +
 699                 ((ost->topBand >> 1) * formatted_picture->linesize[1]) +
 700                 (ost->leftBand >> 1);
 701
 702         picture_crop_temp.data[2] = formatted_picture->data[2] +
 703                 ((ost->topBand >> 1) * formatted_picture->linesize[2]) +
 704                 (ost->leftBand >> 1);
 705
 706         picture_crop_temp.linesize[0] = formatted_picture->linesize[0];
 707         picture_crop_temp.linesize[1] = formatted_picture->linesize[1];
 708         picture_crop_temp.linesize[2] = formatted_picture->linesize[2];
 709         final_picture = &picture_crop_temp;
 710     } else if (ost->video_pad) {
 711         final_picture = &ost->pict_tmp;
 712
 713         for (i = 0; i < 3; i++) {
 714             uint8_t *optr, *iptr;
 715             int shift = (i == 0) ? 0 : 1;
 716             int y, yheight;
 717
 718             /* set offset to start writing image into */
 719             optr = final_picture->data[i] + (((final_picture->linesize[i] *
 720                             ost->padtop) + ost->padleft) >> shift);
 721             iptr = formatted_picture->data[i];
 722
 723             yheight = (enc->height - ost->padtop - ost->padbottom) >> shift;
 724             for (y = 0; y < yheight; y++) {
 725                 /* copy unpadded image row into padded image row */
 726                 memcpy(optr, iptr, formatted_picture->linesize[i]);
 727                 optr += final_picture->linesize[i];
 728                 iptr += formatted_picture->linesize[i];
 729             }
 730         }
 731
 732         fill_pad_region(final_picture, enc->height, enc->width,
 733                 ost->padtop, ost->padbottom, ost->padleft, ost->padright,
 734                 padcolor);
 735
 736         if (enc->pix_fmt != PIX_FMT_YUV420P) {
 737             int size;
 738
 739             av_free(buf);
 740             /* create temporary picture */
 741             size = avpicture_get_size(enc->pix_fmt, enc->width, enc->height);
 742             buf = av_malloc(size);
 743             if (!buf)
 744                 return;
 745             final_picture = &picture_format_temp;
 746             avpicture_fill(final_picture, buf, enc->pix_fmt, enc->width, enc->height);
 747
 748             if (img_convert(final_picture, enc->pix_fmt,
 749                         &ost->pict_tmp, PIX_FMT_YUV420P,
 750                         enc->width, enc->height) < 0) {
 751
 752                 if (verbose >= 0)
 753                     fprintf(stderr, "pixel format conversion not handled\n");
 754
 755                 goto the_end;
 756             }
 757         }
 758     } else {
 759         final_picture = formatted_picture;
 760     }
 761     /* duplicates frame if needed */
 762     /* XXX: pb because no interleaving */
 763     for(i=0;i<nb_frames;i++) {
 764         if (s->oformat->flags & AVFMT_RAWPICTURE) {
 765             /* raw pictures are written as AVPicture structure to
 766                avoid any copies. We support temorarily the older
 767                method. */
 768             AVFrame* old_frame = enc->coded_frame;
 769             enc->coded_frame = dec->coded_frame;
 770             av_write_frame(s, ost->index,
 771                            (uint8_t *)final_picture, sizeof(AVPicture));
 772             enc->coded_frame = old_frame;
 773         } else {
 774             AVFrame big_picture;
 775
 776             avcodec_get_frame_defaults(&big_picture);
 777             *(AVPicture*)&big_picture= *final_picture;
 778             /* better than nothing: use input picture interlaced
 779                settings */
 780             big_picture.interlaced_frame = in_picture->interlaced_frame;
 781             if(do_interlace_me || do_interlace_dct){
 782                 if(top_field_first == -1)
 783                     big_picture.top_field_first = in_picture->top_field_first;
 784                 else
 785                     big_picture.top_field_first = 1;
 786             }
 787
 788             /* handles sameq here. This is not correct because it may
 789                not be a global option */
 790             if (same_quality) {
 791                 big_picture.quality = ist->st->quality;
 792             }else
 793                 big_picture.quality = ost->st->quality;
 794             ret = avcodec_encode_video(enc,
 795                                        video_buffer, VIDEO_BUFFER_SIZE,
 796                                        &big_picture);
 797             //enc->frame_number = enc->real_pict_num;
 798             av_write_frame(s, ost->index, video_buffer, ret);
 799             *frame_size = ret;
 800             //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
 801             //        enc->frame_number-1, enc->real_pict_num, ret,
 802             //        enc->pict_type);
 803             /* if two pass, output log */
 804             if (ost->logfile && enc->stats_out) {
 805                 fprintf(ost->logfile, "%s", enc->stats_out);
 806             }
 807         }
 808         ost->frame_number++;
 809     }
 810  the_end:
 811     av_free(buf);
 812     av_free(buf1);
 813 }
 814
 815 static double psnr(double d){
 816     if(d==0) return INFINITY;
 817     return -10.0*log(d)/log(10.0);
 818 }
 819
 820 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
 821                            int frame_size)
 822 {
 823     static FILE *fvstats=NULL;
 824     char filename[40];
 825     time_t today2;
 826     struct tm *today;
 827     AVCodecContext *enc;
 828     int frame_number;
 829     int64_t ti;
 830     double ti1, bitrate, avg_bitrate;
 831
 832     if (!fvstats) {
 833         today2 = time(NULL);
 834         today = localtime(&today2);
 835         sprintf(filename, "vstats_%02d%02d%02d.log", today->tm_hour,
 836                                                today->tm_min,
 837                                                today->tm_sec);
 838         fvstats = fopen(filename,"w");
 839         if (!fvstats) {
 840             perror("fopen");
 841             exit(1);
 842         }
 843     }
 844
 845     ti = MAXINT64;
 846     enc = &ost->st->codec;
 847     if (enc->codec_type == CODEC_TYPE_VIDEO) {
 848         frame_number = ost->frame_number;
 849         fprintf(fvstats, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
 850         if (enc->flags&CODEC_FLAG_PSNR)
 851             fprintf(fvstats, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
 852
 853         fprintf(fvstats,"f_size= %6d ", frame_size);
 854         /* compute pts value */
 855         ti1 = (double)ost->st->pts.val * os->pts_num / os->pts_den;
 856         if (ti1 < 0.01)
 857             ti1 = 0.01;
 858
 859         bitrate = (double)(frame_size * 8) * enc->frame_rate / enc->frame_rate_base / 1000.0;
 860         avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
 861         fprintf(fvstats, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
 862             (double)video_size / 1024, ti1, bitrate, avg_bitrate);
 863         fprintf(fvstats,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
 864     }
 865 }
 866
 867 static void print_report(AVFormatContext **output_files,
 868                          AVOutputStream **ost_table, int nb_ostreams,
 869                          int is_last_report)
 870 {
 871     char buf[1024];
 872     AVOutputStream *ost;
 873     AVFormatContext *oc, *os;
 874     int64_t total_size;
 875     AVCodecContext *enc;
 876     int frame_number, vid, i;
 877     double bitrate, ti1, pts;
 878     static int64_t last_time = -1;
 879
 880     if (!is_last_report) {
 881         int64_t cur_time;
 882         /* display the report every 0.5 seconds */
 883         cur_time = av_gettime();
 884         if (last_time == -1) {
 885             last_time = cur_time;
 886             return;
 887         }
 888         if ((cur_time - last_time) < 500000)
 889             return;
 890         last_time = cur_time;
 891     }
 892
 893
 894     oc = output_files[0];
 895
 896     total_size = url_ftell(&oc->pb);
 897
 898     buf[0] = '\0';
 899     ti1 = 1e10;
 900     vid = 0;
 901     for(i=0;i<nb_ostreams;i++) {
 902         ost = ost_table[i];
 903         os = output_files[ost->file_index];
 904         enc = &ost->st->codec;
 905         if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
 906             sprintf(buf + strlen(buf), "q=%2.1f ",
 907                     enc->coded_frame->quality/(float)FF_QP2LAMBDA);
 908         }
 909         if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
 910             frame_number = ost->frame_number;
 911             sprintf(buf + strlen(buf), "frame=%5d q=%2.1f ",
 912                     frame_number, enc->coded_frame ? enc->coded_frame->quality/(float)FF_QP2LAMBDA : 0);
 913             if(is_last_report)
 914                 sprintf(buf + strlen(buf), "L");
 915             if (enc->flags&CODEC_FLAG_PSNR){
 916                 int j;
 917                 double error, error_sum=0;
 918                 double scale, scale_sum=0;
 919                 char type[3]= {'Y','U','V'};
 920                 sprintf(buf + strlen(buf), "PSNR=");
 921                 for(j=0; j<3; j++){
 922                     if(is_last_report){
 923                         error= enc->error[j];
 924                         scale= enc->width*enc->height*255.0*255.0*frame_number;
 925                     }else{
 926                         error= enc->coded_frame->error[j];
 927                         scale= enc->width*enc->height*255.0*255.0;
 928                     }
 929                     if(j) scale/=4;
 930                     error_sum += error;
 931                     scale_sum += scale;
 932                     sprintf(buf + strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
 933                 }
 934                 sprintf(buf + strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
 935             }
 936             vid = 1;
 937         }
 938         /* compute min output value */
 939         pts = (double)ost->st->pts.val * os->pts_num / os->pts_den;
 940         if ((pts < ti1) && (pts > 0))
 941             ti1 = pts;
 942     }
 943     if (ti1 < 0.01)
 944         ti1 = 0.01;
 945
 946     if (verbose || is_last_report) {
 947         bitrate = (double)(total_size * 8) / ti1 / 1000.0;
 948
 949         sprintf(buf + strlen(buf),
 950             "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
 951             (double)total_size / 1024, ti1, bitrate);
 952
 953         if (verbose >= 0)
 954             fprintf(stderr, "%s    \r", buf);
 955
 956         fflush(stderr);
 957     }
 958
 959     if (is_last_report && verbose >= 0){
 960         int64_t raw= audio_size + video_size + extra_size;
 961         fprintf(stderr, "\n");
 962         fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
 963                 video_size/1024.0,
 964                 audio_size/1024.0,
 965                 extra_size/1024.0,
 966                 100.0*(total_size - raw)/raw
 967         );
 968     }
 969 }
 970
 971 /* pkt = NULL means EOF (needed to flush decoder buffers) */
 972 static int output_packet(AVInputStream *ist, int ist_index,
 973                          AVOutputStream **ost_table, int nb_ostreams,
 974                          AVPacket *pkt)
 975 {
 976     AVFormatContext *os;
 977     AVOutputStream *ost;
 978     uint8_t *ptr;
 979     int len, ret, i;
 980     uint8_t *data_buf;
 981     int data_size, got_picture;
 982     AVFrame picture;
 983     short samples[AVCODEC_MAX_AUDIO_FRAME_SIZE / 2];
 984     void *buffer_to_free;
 985
 986     if (pkt && pkt->pts != AV_NOPTS_VALUE) {
 987         ist->pts = pkt->pts;
 988     } else {
 989         ist->pts = ist->next_pts;
 990     }
 991
 992     if (pkt == NULL) {
 993         /* EOF handling */
 994         ptr = NULL;
 995         len = 0;
 996         goto handle_eof;
 997     }
 998
 999     len = pkt->size;
1000     ptr = pkt->data;
1001     while (len > 0) {
1002     handle_eof:
1003         /* decode the packet if needed */
1004         data_buf = NULL; /* fail safe */
1005         data_size = 0;
1006         if (ist->decoding_needed) {
1007             switch(ist->st->codec.codec_type) {
1008             case CODEC_TYPE_AUDIO:
1009                     /* XXX: could avoid copy if PCM 16 bits with same
1010                        endianness as CPU */
1011                 ret = avcodec_decode_audio(&ist->st->codec, samples, &data_size,
1012                                            ptr, len);
1013                 if (ret < 0)
1014                     goto fail_decode;
1015                 ptr += ret;
1016                 len -= ret;
1017                 /* Some bug in mpeg audio decoder gives */
1018                 /* data_size < 0, it seems they are overflows */
1019                 if (data_size <= 0) {
1020                     /* no audio frame */
1021                     continue;
1022                 }
1023                 data_buf = (uint8_t *)samples;
1024                 ist->next_pts += ((int64_t)AV_TIME_BASE * data_size) /
1025                     (2 * ist->st->codec.channels);
1026                 break;
1027             case CODEC_TYPE_VIDEO:
1028                     data_size = (ist->st->codec.width * ist->st->codec.height * 3) / 2;
1029                     /* XXX: allocate picture correctly */
1030                     avcodec_get_frame_defaults(&picture);
1031
1032                     ret = avcodec_decode_video(&ist->st->codec,
1033                                                &picture, &got_picture, ptr, len);
1034                     ist->st->quality= picture.quality;
1035                     if (ret < 0)
1036                         goto fail_decode;
1037                     if (!got_picture) {
1038                         /* no picture yet */
1039                         goto discard_packet;
1040                     }
1041                     if (ist->st->codec.frame_rate_base != 0) {
1042                         ist->next_pts += ((int64_t)AV_TIME_BASE *
1043                                           ist->st->codec.frame_rate_base) /
1044                             ist->st->codec.frame_rate;
1045                     }
1046                     len = 0;
1047                     break;
1048                 default:
1049                     goto fail_decode;
1050                 }
1051             } else {
1052                 data_buf = ptr;
1053                 data_size = len;
1054                 ret = len;
1055                 len = 0;
1056             }
1057
1058             buffer_to_free = NULL;
1059             if (ist->st->codec.codec_type == CODEC_TYPE_VIDEO) {
1060                 pre_process_video_frame(ist, (AVPicture *)&picture,
1061                                         &buffer_to_free);
1062             }
1063
1064             /* frame rate emulation */
1065             if (ist->st->codec.rate_emu) {
1066                 int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec.frame_rate_base, 1000000, ist->st->codec.frame_rate);
1067                 int64_t now = av_gettime() - ist->start;
1068                 if (pts > now)
1069                     usleep(pts - now);
1070
1071                 ist->frame++;
1072             }
1073
1074 #if 0
1075             /* mpeg PTS deordering : if it is a P or I frame, the PTS
1076                is the one of the next displayed one */
1077             /* XXX: add mpeg4 too ? */
1078             if (ist->st->codec.codec_id == CODEC_ID_MPEG1VIDEO) {
1079                 if (ist->st->codec.pict_type != B_TYPE) {
1080                     int64_t tmp;
1081                     tmp = ist->last_ip_pts;
1082                     ist->last_ip_pts  = ist->frac_pts.val;
1083                     ist->frac_pts.val = tmp;
1084                 }
1085             }
1086 #endif
1087             /* if output time reached then transcode raw format,
1088                encode packets and output them */
1089             if (start_time == 0 || ist->pts >= start_time)
1090                 for(i=0;i<nb_ostreams;i++) {
1091                     int frame_size;
1092
1093                     ost = ost_table[i];
1094                     if (ost->source_index == ist_index) {
1095                         os = output_files[ost->file_index];
1096
1097 #if 0
1098                         printf("%d: got pts=%0.3f %0.3f\n", i,
1099                                (double)pkt->pts / AV_TIME_BASE,
1100                                ((double)ist->pts / AV_TIME_BASE) -
1101                                ((double)ost->st->pts.val * os->pts_num / os->pts_den));
1102 #endif
1103                         /* set the input output pts pairs */
1104                         ost->sync_ipts = (double)ist->pts / AV_TIME_BASE;
1105                         /* XXX: take into account the various fifos,
1106                            in particular for audio */
1107                         ost->sync_opts = ost->st->pts.val;
1108                         //printf("ipts=%lld sync_ipts=%f sync_opts=%lld pts.val=%lld pkt->pts=%lld\n", ist->pts, ost->sync_ipts, ost->sync_opts, ost->st->pts.val, pkt->pts);
1109
1110                         if (ost->encoding_needed) {
1111                             switch(ost->st->codec.codec_type) {
1112                             case CODEC_TYPE_AUDIO:
1113                                 do_audio_out(os, ost, ist, data_buf, data_size);
1114                                 break;
1115                             case CODEC_TYPE_VIDEO:
1116                                 /* find an audio stream for synchro */
1117                                 {
1118                                     int i;
1119                                     AVOutputStream *audio_sync, *ost1;
1120                                     audio_sync = NULL;
1121                                     for(i=0;i<nb_ostreams;i++) {
1122                                         ost1 = ost_table[i];
1123                                         if (ost1->file_index == ost->file_index &&
1124                                             ost1->st->codec.codec_type == CODEC_TYPE_AUDIO) {
1125                                             audio_sync = ost1;
1126                                             break;
1127                                         }
1128                                     }
1129
1130                                     do_video_out(os, ost, ist, &picture, &frame_size, audio_sync);
1131                                     video_size += frame_size;
1132                                     if (do_vstats && frame_size)
1133                                         do_video_stats(os, ost, frame_size);
1134                                 }
1135                                 break;
1136                             default:
1137                                 av_abort();
1138                             }
1139                         } else {
1140                             AVFrame avframe;
1141
1142                             /* no reencoding needed : output the packet directly */
1143                             /* force the input stream PTS */
1144
1145                             avcodec_get_frame_defaults(&avframe);
1146                             ost->st->codec.coded_frame= &avframe;
1147                             avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1148                             ost->st->pts.val= av_rescale(ist->pts, os->pts_den, os->pts_num*AV_TIME_BASE);
1149
1150                             av_write_frame(os, ost->index, data_buf, data_size);
1151                             ost->st->codec.frame_number++;
1152                             ost->frame_number++;
1153                         }
1154                     }
1155                 }
1156             av_free(buffer_to_free);
1157         }
1158  discard_packet:
1159     return 0;
1160  fail_decode:
1161     return -1;
1162 }
1163
1164
1165 /*
1166  * The following code is the main loop of the file converter
1167  */
1168 static int av_encode(AVFormatContext **output_files,
1169                      int nb_output_files,
1170                      AVFormatContext **input_files,
1171                      int nb_input_files,
1172                      AVStreamMap *stream_maps, int nb_stream_maps)
1173 {
1174     int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1175     AVFormatContext *is, *os;
1176     AVCodecContext *codec, *icodec;
1177     AVOutputStream *ost, **ost_table = NULL;
1178     AVInputStream *ist, **ist_table = NULL;
1179     AVInputFile *file_table;
1180     AVFormatContext *stream_no_data;
1181     int key;
1182
1183     file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
1184     if (!file_table)
1185         goto fail;
1186
1187     /* input stream init */
1188     j = 0;
1189     for(i=0;i<nb_input_files;i++) {
1190         is = input_files[i];
1191         file_table[i].ist_index = j;
1192         file_table[i].nb_streams = is->nb_streams;
1193         j += is->nb_streams;
1194     }
1195     nb_istreams = j;
1196
1197     ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1198     if (!ist_table)
1199         goto fail;
1200
1201     for(i=0;i<nb_istreams;i++) {
1202         ist = av_mallocz(sizeof(AVInputStream));
1203         if (!ist)
1204             goto fail;
1205         ist_table[i] = ist;
1206     }
1207     j = 0;
1208     for(i=0;i<nb_input_files;i++) {
1209         is = input_files[i];
1210         for(k=0;k<is->nb_streams;k++) {
1211             ist = ist_table[j++];
1212             ist->st = is->streams[k];
1213             ist->file_index = i;
1214             ist->index = k;
1215             ist->discard = 1; /* the stream is discarded by default
1216                                  (changed later) */
1217
1218             if (ist->st->codec.rate_emu) {
1219                 ist->start = av_gettime();
1220                 ist->frame = 0;
1221             }
1222         }
1223     }
1224
1225     /* output stream init */
1226     nb_ostreams = 0;
1227     for(i=0;i<nb_output_files;i++) {
1228         os = output_files[i];
1229         nb_ostreams += os->nb_streams;
1230     }
1231     if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1232         fprintf(stderr, "Number of stream maps must match number of output streams\n");
1233         exit(1);
1234     }
1235
1236     /* Sanity check the mapping args -- do the input files & streams exist? */
1237     for(i=0;i<nb_stream_maps;i++) {
1238         int fi = stream_maps[i].file_index;
1239         int si = stream_maps[i].stream_index;
1240
1241         if (fi < 0 || fi > nb_input_files - 1 ||
1242             si < 0 || si > file_table[fi].nb_streams - 1) {
1243             fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1244             exit(1);
1245         }
1246     }
1247
1248     ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1249     if (!ost_table)
1250         goto fail;
1251     for(i=0;i<nb_ostreams;i++) {
1252         ost = av_mallocz(sizeof(AVOutputStream));
1253         if (!ost)
1254             goto fail;
1255         ost_table[i] = ost;
1256     }
1257
1258     n = 0;
1259     for(k=0;k<nb_output_files;k++) {
1260         os = output_files[k];
1261         for(i=0;i<os->nb_streams;i++) {
1262             int found;
1263             ost = ost_table[n++];
1264             ost->file_index = k;
1265             ost->index = i;
1266             ost->st = os->streams[i];
1267             if (nb_stream_maps > 0) {
1268                 ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1269                     stream_maps[n-1].stream_index;
1270
1271                 /* Sanity check that the stream types match */
1272                 if (ist_table[ost->source_index]->st->codec.codec_type != ost->st->codec.codec_type) {
1273                     fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1274                         stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1275                         ost->file_index, ost->index);
1276                     exit(1);
1277                 }
1278
1279             } else {
1280                 /* get corresponding input stream index : we select the first one with the right type */
1281                 found = 0;
1282                 for(j=0;j<nb_istreams;j++) {
1283                     ist = ist_table[j];
1284                     if (ist->discard &&
1285                         ist->st->codec.codec_type == ost->st->codec.codec_type) {
1286                         ost->source_index = j;
1287                         found = 1;
1288                     }
1289                 }
1290
1291                 if (!found) {
1292                     /* try again and reuse existing stream */
1293                     for(j=0;j<nb_istreams;j++) {
1294                         ist = ist_table[j];
1295                         if (ist->st->codec.codec_type == ost->st->codec.codec_type) {
1296                             ost->source_index = j;
1297                             found = 1;
1298                         }
1299                     }
1300                     if (!found) {
1301                         fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1302                                 ost->file_index, ost->index);
1303                         exit(1);
1304                     }
1305                 }
1306             }
1307             ist = ist_table[ost->source_index];
1308             ist->discard = 0;
1309         }
1310     }
1311
1312     /* for each output stream, we compute the right encoding parameters */
1313     for(i=0;i<nb_ostreams;i++) {
1314         ost = ost_table[i];
1315         ist = ist_table[ost->source_index];
1316
1317         codec = &ost->st->codec;
1318         icodec = &ist->st->codec;
1319
1320         if (ost->st->stream_copy) {
1321             /* if stream_copy is selected, no need to decode or encode */
1322             codec->codec_id = icodec->codec_id;
1323             codec->codec_type = icodec->codec_type;
1324             codec->codec_tag = icodec->codec_tag;
1325             codec->bit_rate = icodec->bit_rate;
1326             switch(codec->codec_type) {
1327             case CODEC_TYPE_AUDIO:
1328                 codec->sample_rate = icodec->sample_rate;
1329                 codec->channels = icodec->channels;
1330                 codec->frame_size = icodec->frame_size;
1331                 break;
1332             case CODEC_TYPE_VIDEO:
1333                 codec->frame_rate = icodec->frame_rate;
1334                 codec->frame_rate_base = icodec->frame_rate_base;
1335                 codec->width = icodec->width;
1336                 codec->height = icodec->height;
1337                 break;
1338             default:
1339                 av_abort();
1340             }
1341         } else {
1342             switch(codec->codec_type) {
1343             case CODEC_TYPE_AUDIO:
1344                 if (fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
1345                     goto fail;
1346
1347                 if (codec->channels == icodec->channels &&
1348                     codec->sample_rate == icodec->sample_rate) {
1349                     ost->audio_resample = 0;
1350                 } else {
1351                     if (codec->channels != icodec->channels &&
1352                         icodec->codec_id == CODEC_ID_AC3) {
1353                         /* Special case for 5:1 AC3 input */
1354                         /* and mono or stereo output      */
1355                         /* Request specific number of channels */
1356                         icodec->channels = codec->channels;
1357                         if (codec->sample_rate == icodec->sample_rate)
1358                             ost->audio_resample = 0;
1359                         else {
1360                             ost->audio_resample = 1;
1361                             ost->resample = audio_resample_init(codec->channels, icodec->channels,
1362                                                         codec->sample_rate,
1363                                                         icodec->sample_rate);
1364                             if(!ost->resample)
1365                               {
1366                                 printf("Can't resample.  Aborting.\n");
1367                                 av_abort();
1368                               }
1369                         }
1370                         /* Request specific number of channels */
1371                         icodec->channels = codec->channels;
1372                     } else {
1373                         ost->audio_resample = 1;
1374                         ost->resample = audio_resample_init(codec->channels, icodec->channels,
1375                                                         codec->sample_rate,
1376                                                         icodec->sample_rate);
1377                         if(!ost->resample)
1378                           {
1379                             printf("Can't resample.  Aborting.\n");
1380                             av_abort();
1381                           }
1382                     }
1383                 }
1384                 ist->decoding_needed = 1;
1385                 ost->encoding_needed = 1;
1386                 break;
1387             case CODEC_TYPE_VIDEO:
1388                 if (codec->width == icodec->width &&
1389                     codec->height == icodec->height &&
1390                     frame_topBand == 0 &&
1391                     frame_bottomBand == 0 &&
1392                     frame_leftBand == 0 &&
1393                     frame_rightBand == 0 &&
1394                     frame_padtop == 0 &&
1395                     frame_padbottom == 0 &&
1396                     frame_padleft == 0 &&
1397                     frame_padright == 0)
1398                 {
1399                     ost->video_resample = 0;
1400                     ost->video_crop = 0;
1401                     ost->video_pad = 0;
1402                 } else if ((codec->width == icodec->width -
1403                                 (frame_leftBand + frame_rightBand)) &&
1404                         (codec->height == icodec->height -
1405                                 (frame_topBand  + frame_bottomBand)))
1406                 {
1407                     ost->video_resample = 0;
1408                     ost->video_crop = 1;
1409                     ost->topBand = frame_topBand;
1410                     ost->leftBand = frame_leftBand;
1411                 } else if ((codec->width == icodec->width +
1412                                 (frame_padleft + frame_padright)) &&
1413                         (codec->height == icodec->height +
1414                                 (frame_padtop + frame_padbottom))) {
1415                     ost->video_resample = 0;
1416                     ost->video_crop = 0;
1417                     ost->video_pad = 1;
1418                     ost->padtop = frame_padtop;
1419                     ost->padleft = frame_padleft;
1420                     ost->padbottom = frame_padbottom;
1421                     ost->padright = frame_padright;
1422                     if( avpicture_alloc( &ost->pict_tmp, PIX_FMT_YUV420P,
1423                                 codec->width, codec->height ) )
1424                         goto fail;
1425                 } else {
1426                     ost->video_resample = 1;
1427                     ost->video_crop = 0; // cropping is handled as part of resample
1428                     if( avpicture_alloc( &ost->pict_tmp, PIX_FMT_YUV420P,
1429                                          codec->width, codec->height ) )
1430                         goto fail;
1431
1432                     ost->img_resample_ctx = img_resample_full_init(
1433                                       ost->st->codec.width, ost->st->codec.height,
1434                                       ist->st->codec.width, ist->st->codec.height,
1435                                       frame_topBand, frame_bottomBand,
1436                             frame_leftBand, frame_rightBand,
1437                             frame_padtop, frame_padbottom,
1438                             frame_padleft, frame_padright);
1439
1440                     ost->padtop = frame_padtop;
1441                     ost->padleft = frame_padleft;
1442                     ost->padbottom = frame_padbottom;
1443                     ost->padright = frame_padright;
1444
1445                 }
1446                 ost->encoding_needed = 1;
1447                 ist->decoding_needed = 1;
1448                 break;
1449             default:
1450                 av_abort();
1451             }
1452             /* two pass mode */
1453             if (ost->encoding_needed &&
1454                 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1455                 char logfilename[1024];
1456                 FILE *f;
1457                 int size;
1458                 char *logbuffer;
1459
1460                 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1461                          pass_logfilename ?
1462                          pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1463                 if (codec->flags & CODEC_FLAG_PASS1) {
1464                     f = fopen(logfilename, "w");
1465                     if (!f) {
1466                         perror(logfilename);
1467                         exit(1);
1468                     }
1469                     ost->logfile = f;
1470                 } else {
1471                     /* read the log file */
1472                     f = fopen(logfilename, "r");
1473                     if (!f) {
1474                         perror(logfilename);
1475                         exit(1);
1476                     }
1477                     fseek(f, 0, SEEK_END);
1478                     size = ftell(f);
1479                     fseek(f, 0, SEEK_SET);
1480                     logbuffer = av_malloc(size + 1);
1481                     if (!logbuffer) {
1482                         fprintf(stderr, "Could not allocate log buffer\n");
1483                         exit(1);
1484                     }
1485                     size = fread(logbuffer, 1, size, f);
1486                     fclose(f);
1487                     logbuffer[size] = '\0';
1488                     codec->stats_in = logbuffer;
1489                 }
1490             }
1491         }
1492     }
1493
1494     /* dump the file output parameters - cannot be done before in case
1495        of stream copy */
1496     for(i=0;i<nb_output_files;i++) {
1497         dump_format(output_files[i], i, output_files[i]->filename, 1);
1498     }
1499
1500     /* dump the stream mapping */
1501     if (verbose >= 0) {
1502         fprintf(stderr, "Stream mapping:\n");
1503         for(i=0;i<nb_ostreams;i++) {
1504             ost = ost_table[i];
1505             fprintf(stderr, "  Stream #%d.%d -> #%d.%d\n",
1506                     ist_table[ost->source_index]->file_index,
1507                     ist_table[ost->source_index]->index,
1508                     ost->file_index,
1509                     ost->index);
1510         }
1511     }
1512
1513     /* open each encoder */
1514     for(i=0;i<nb_ostreams;i++) {
1515         ost = ost_table[i];
1516         if (ost->encoding_needed) {
1517             AVCodec *codec;
1518             codec = avcodec_find_encoder(ost->st->codec.codec_id);
1519             if (!codec) {
1520                 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1521                         ost->file_index, ost->index);
1522                 exit(1);
1523             }
1524             if (avcodec_open(&ost->st->codec, codec) < 0) {
1525                 fprintf(stderr, "Error while opening codec for stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1526                         ost->file_index, ost->index);
1527                 exit(1);
1528             }
1529             extra_size += ost->st->codec.extradata_size;
1530         }
1531     }
1532
1533     /* open each decoder */
1534     for(i=0;i<nb_istreams;i++) {
1535         ist = ist_table[i];
1536         if (ist->decoding_needed) {
1537             AVCodec *codec;
1538             codec = avcodec_find_decoder(ist->st->codec.codec_id);
1539             if (!codec) {
1540                 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1541                         ist->st->codec.codec_id, ist->file_index, ist->index);
1542                 exit(1);
1543             }
1544             if (avcodec_open(&ist->st->codec, codec) < 0) {
1545                 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1546                         ist->file_index, ist->index);
1547                 exit(1);
1548             }
1549             //if (ist->st->codec.codec_type == CODEC_TYPE_VIDEO)
1550             //    ist->st->codec.flags |= CODEC_FLAG_REPEAT_FIELD;
1551         }
1552     }
1553
1554     /* init pts */
1555     for(i=0;i<nb_istreams;i++) {
1556         ist = ist_table[i];
1557         is = input_files[ist->file_index];
1558         ist->pts = 0;
1559         ist->next_pts = 0;
1560     }
1561
1562     /* compute buffer size max (should use a complete heuristic) */
1563     for(i=0;i<nb_input_files;i++) {
1564         file_table[i].buffer_size_max = 2048;
1565     }
1566
1567     /* open files and write file headers */
1568     for(i=0;i<nb_output_files;i++) {
1569         os = output_files[i];
1570         if (av_write_header(os) < 0) {
1571             fprintf(stderr, "Could not write header for output file #%d (incorrect codec paramters ?)\n", i);
1572             ret = -EINVAL;
1573             goto fail;
1574         }
1575     }
1576
1577 #ifndef CONFIG_WIN32
1578     if ( !using_stdin && verbose >= 0) {
1579         fprintf(stderr, "Press [q] to stop encoding\n");
1580         url_set_interrupt_cb(decode_interrupt_cb);
1581     }
1582 #endif
1583     term_init();
1584
1585     stream_no_data = 0;
1586     key = -1;
1587
1588     for(; received_sigterm == 0;) {
1589         int file_index, ist_index;
1590         AVPacket pkt;
1591         double pts_min;
1592
1593     redo:
1594         /* if 'q' pressed, exits */
1595         if (!using_stdin) {
1596             if (q_pressed)
1597                 break;
1598             /* read_key() returns 0 on EOF */
1599             key = read_key();
1600             if (key == 'q')
1601                 break;
1602         }
1603
1604         /* select the stream that we must read now by looking at the
1605            smallest output pts */
1606         file_index = -1;
1607         pts_min = 1e10;
1608         for(i=0;i<nb_ostreams;i++) {
1609             double pts;
1610             ost = ost_table[i];
1611             os = output_files[ost->file_index];
1612             ist = ist_table[ost->source_index];
1613             pts = (double)ost->st->pts.val * os->pts_num / os->pts_den;
1614             if (!file_table[ist->file_index].eof_reached &&
1615                 pts < pts_min) {
1616                 pts_min = pts;
1617                 file_index = ist->file_index;
1618             }
1619         }
1620         /* if none, if is finished */
1621         if (file_index < 0) {
1622             break;
1623         }
1624
1625         /* finish if recording time exhausted */
1626         if (recording_time > 0 && pts_min >= (recording_time / 1000000.0))
1627             break;
1628
1629         /* read a frame from it and output it in the fifo */
1630         is = input_files[file_index];
1631         if (av_read_frame(is, &pkt) < 0) {
1632             file_table[file_index].eof_reached = 1;
1633             continue;
1634         }
1635
1636         if (!pkt.size) {
1637             stream_no_data = is;
1638         } else {
1639             stream_no_data = 0;
1640         }
1641         if (do_pkt_dump) {
1642             av_pkt_dump(stdout, &pkt, do_hex_dump);
1643         }
1644         /* the following test is needed in case new streams appear
1645            dynamically in stream : we ignore them */
1646         if (pkt.stream_index >= file_table[file_index].nb_streams)
1647             goto discard_packet;
1648         ist_index = file_table[file_index].ist_index + pkt.stream_index;
1649         ist = ist_table[ist_index];
1650         if (ist->discard)
1651             goto discard_packet;
1652
1653         //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
1654         if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
1655
1656             if (verbose >= 0)
1657                 fprintf(stderr, "Error while decoding stream #%d.%d\n",
1658                         ist->file_index, ist->index);
1659
1660             av_free_packet(&pkt);
1661             goto redo;
1662         }
1663
1664     discard_packet:
1665         av_free_packet(&pkt);
1666
1667         /* dump report by using the output first video and audio streams */
1668         print_report(output_files, ost_table, nb_ostreams, 0);
1669     }
1670
1671     /* at the end of stream, we must flush the decoder buffers */
1672     for(i=0;i<nb_istreams;i++) {
1673         ist = ist_table[i];
1674         if (ist->decoding_needed) {
1675             output_packet(ist, i, ost_table, nb_ostreams, NULL);
1676         }
1677     }
1678
1679     term_exit();
1680
1681     /* write the trailer if needed and close file */
1682     for(i=0;i<nb_output_files;i++) {
1683         os = output_files[i];
1684         av_write_trailer(os);
1685     }
1686
1687     /* dump report by using the first video and audio streams */
1688     print_report(output_files, ost_table, nb_ostreams, 1);
1689
1690     /* close each encoder */
1691     for(i=0;i<nb_ostreams;i++) {
1692         ost = ost_table[i];
1693         if (ost->encoding_needed) {
1694             av_freep(&ost->st->codec.stats_in);
1695             avcodec_close(&ost->st->codec);
1696         }
1697     }
1698
1699     /* close each decoder */
1700     for(i=0;i<nb_istreams;i++) {
1701         ist = ist_table[i];
1702         if (ist->decoding_needed) {
1703             avcodec_close(&ist->st->codec);
1704         }
1705     }
1706
1707     /* finished ! */
1708
1709     ret = 0;
1710  fail1:
1711     av_free(file_table);
1712
1713     if (ist_table) {
1714         for(i=0;i<nb_istreams;i++) {
1715             ist = ist_table[i];
1716             av_free(ist);
1717         }
1718         av_free(ist_table);
1719     }
1720     if (ost_table) {
1721         for(i=0;i<nb_ostreams;i++) {
1722             ost = ost_table[i];
1723             if (ost) {
1724                 if (ost->logfile) {
1725                     fclose(ost->logfile);
1726                     ost->logfile = NULL;
1727                 }
1728                 fifo_free(&ost->fifo); /* works even if fifo is not
1729                                           initialized but set to zero */
1730                 av_free(ost->pict_tmp.data[0]);
1731                 if (ost->video_resample)
1732                     img_resample_close(ost->img_resample_ctx);
1733                 if (ost->audio_resample)
1734                     audio_resample_close(ost->resample);
1735                 av_free(ost);
1736             }
1737         }
1738         av_free(ost_table);
1739     }
1740     return ret;
1741  fail:
1742     ret = -ENOMEM;
1743     goto fail1;
1744 }
1745
1746 #if 0
1747 int file_read(const char *filename)
1748 {
1749     URLContext *h;
1750     unsigned char buffer[1024];
1751     int len, i;
1752
1753     if (url_open(&h, filename, O_RDONLY) < 0) {
1754         printf("could not open '%s'\n", filename);
1755         return -1;
1756     }
1757     for(;;) {
1758         len = url_read(h, buffer, sizeof(buffer));
1759         if (len <= 0)
1760             break;
1761         for(i=0;i<len;i++) putchar(buffer[i]);
1762     }
1763     url_close(h);
1764     return 0;
1765 }
1766 #endif
1767
1768 static void opt_image_format(const char *arg)
1769 {
1770     AVImageFormat *f;
1771
1772     for(f = first_image_format; f != NULL; f = f->next) {
1773         if (!strcmp(arg, f->name))
1774             break;
1775     }
1776     if (!f) {
1777         fprintf(stderr, "Unknown image format: '%s'\n", arg);
1778         exit(1);
1779     }
1780     image_format = f;
1781 }
1782
1783 static void opt_format(const char *arg)
1784 {
1785     /* compatibility stuff for pgmyuv */
1786     if (!strcmp(arg, "pgmyuv")) {
1787         opt_image_format(arg);
1788         arg = "image";
1789     }
1790
1791     file_iformat = av_find_input_format(arg);
1792     file_oformat = guess_format(arg, NULL, NULL);
1793     if (!file_iformat && !file_oformat) {
1794         fprintf(stderr, "Unknown input or output format: %s\n", arg);
1795         exit(1);
1796     }
1797 }
1798
1799 static void opt_video_bitrate(const char *arg)
1800 {
1801     video_bit_rate = atoi(arg) * 1000;
1802 }
1803
1804 static void opt_video_bitrate_tolerance(const char *arg)
1805 {
1806     video_bit_rate_tolerance = atoi(arg) * 1000;
1807 }
1808
1809 static void opt_video_bitrate_max(const char *arg)
1810 {
1811     video_rc_max_rate = atoi(arg) * 1000;
1812 }
1813
1814 static void opt_video_bitrate_min(const char *arg)
1815 {
1816     video_rc_min_rate = atoi(arg) * 1000;
1817 }
1818
1819 static void opt_video_buffer_size(const char *arg)
1820 {
1821     video_rc_buffer_size = atoi(arg) * 8*1024;
1822 }
1823
1824 static void opt_video_rc_eq(char *arg)
1825 {
1826     video_rc_eq = arg;
1827 }
1828
1829 static void opt_video_rc_override_string(char *arg)
1830 {
1831     video_rc_override_string = arg;
1832 }
1833
1834
1835 static void opt_workaround_bugs(const char *arg)
1836 {
1837     workaround_bugs = atoi(arg);
1838 }
1839
1840 static void opt_dct_algo(const char *arg)
1841 {
1842     dct_algo = atoi(arg);
1843 }
1844
1845 static void opt_idct_algo(const char *arg)
1846 {
1847     idct_algo = atoi(arg);
1848 }
1849
1850
1851 static void opt_error_resilience(const char *arg)
1852 {
1853     error_resilience = atoi(arg);
1854 }
1855
1856 static void opt_error_concealment(const char *arg)
1857 {
1858     error_concealment = atoi(arg);
1859 }
1860
1861 static void opt_debug(const char *arg)
1862 {
1863     debug = atoi(arg);
1864 }
1865
1866 static void opt_vismv(const char *arg)
1867 {
1868     debug_mv = atoi(arg);
1869 }
1870
1871 static void opt_verbose(const char *arg)
1872 {
1873     verbose = atoi(arg);
1874     av_log_set_level(atoi(arg));
1875 }
1876
1877 static void opt_frame_rate(const char *arg)
1878 {
1879     if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
1880         fprintf(stderr, "Incorrect frame rate\n");
1881         exit(1);
1882     }
1883 }
1884
1885 static void opt_frame_crop_top(const char *arg)
1886 {
1887     frame_topBand = atoi(arg);
1888     if (frame_topBand < 0) {
1889         fprintf(stderr, "Incorrect top crop size\n");
1890         exit(1);
1891     }
1892     if ((frame_topBand % 2) != 0) {
1893         fprintf(stderr, "Top crop size must be a multiple of 2\n");
1894         exit(1);
1895     }
1896     if ((frame_topBand) >= frame_height){
1897         fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
1898         exit(1);
1899     }
1900     frame_height -= frame_topBand;
1901 }
1902
1903 static void opt_frame_crop_bottom(const char *arg)
1904 {
1905     frame_bottomBand = atoi(arg);
1906     if (frame_bottomBand < 0) {
1907         fprintf(stderr, "Incorrect bottom crop size\n");
1908         exit(1);
1909     }
1910     if ((frame_bottomBand % 2) != 0) {
1911         fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
1912         exit(1);
1913     }
1914     if ((frame_bottomBand) >= frame_height){
1915         fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
1916         exit(1);
1917     }
1918     frame_height -= frame_bottomBand;
1919 }
1920
1921 static void opt_frame_crop_left(const char *arg)
1922 {
1923     frame_leftBand = atoi(arg);
1924     if (frame_leftBand < 0) {
1925         fprintf(stderr, "Incorrect left crop size\n");
1926         exit(1);
1927     }
1928     if ((frame_leftBand % 2) != 0) {
1929         fprintf(stderr, "Left crop size must be a multiple of 2\n");
1930         exit(1);
1931     }
1932     if ((frame_leftBand) >= frame_width){
1933         fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
1934         exit(1);
1935     }
1936     frame_width -= frame_leftBand;
1937 }
1938
1939 static void opt_frame_crop_right(const char *arg)
1940 {
1941     frame_rightBand = atoi(arg);
1942     if (frame_rightBand < 0) {
1943         fprintf(stderr, "Incorrect right crop size\n");
1944         exit(1);
1945     }
1946     if ((frame_rightBand % 2) != 0) {
1947         fprintf(stderr, "Right crop size must be a multiple of 2\n");
1948         exit(1);
1949     }
1950     if ((frame_rightBand) >= frame_width){
1951         fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
1952         exit(1);
1953     }
1954     frame_width -= frame_rightBand;
1955 }
1956
1957 static void opt_frame_size(const char *arg)
1958 {
1959     if (parse_image_size(&frame_width, &frame_height, arg) < 0) {
1960         fprintf(stderr, "Incorrect frame size\n");
1961         exit(1);
1962     }
1963     if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
1964         fprintf(stderr, "Frame size must be a multiple of 2\n");
1965         exit(1);
1966     }
1967 }
1968
1969
1970 #define SCALEBITS 10
1971 #define ONE_HALF  (1 << (SCALEBITS - 1))
1972 #define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
1973
1974 #define RGB_TO_Y(r, g, b) \
1975 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
1976   FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
1977
1978 #define RGB_TO_U(r1, g1, b1, shift)\
1979 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         \
1980      FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
1981
1982 #define RGB_TO_V(r1, g1, b1, shift)\
1983 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
1984    FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
1985
1986 static void opt_pad_color(const char *arg) {
1987     /* Input is expected to be six hex digits similar to
1988        how colors are expressed in html tags (but without the #) */
1989     int rgb = strtol(arg, NULL, 16);
1990     int r,g,b;
1991
1992     r = (rgb >> 16);
1993     g = ((rgb >> 8) & 255);
1994     b = (rgb & 255);
1995
1996     padcolor[0] = RGB_TO_Y(r,g,b);
1997     padcolor[1] = RGB_TO_U(r,g,b,0);
1998     padcolor[2] = RGB_TO_V(r,g,b,0);
1999 }
2000
2001 static void opt_frame_pad_top(const char *arg)
2002 {
2003     frame_padtop = atoi(arg);
2004     if (frame_padtop < 0) {
2005         fprintf(stderr, "Incorrect top pad size\n");
2006         exit(1);
2007     }
2008     if ((frame_padtop % 2) != 0) {
2009         fprintf(stderr, "Top pad size must be a multiple of 2\n");
2010         exit(1);
2011     }
2012 }
2013
2014 static void opt_frame_pad_bottom(const char *arg)
2015 {
2016     frame_padbottom = atoi(arg);
2017     if (frame_padbottom < 0) {
2018         fprintf(stderr, "Incorrect bottom pad size\n");
2019         exit(1);
2020     }
2021     if ((frame_padbottom % 2) != 0) {
2022         fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2023         exit(1);
2024     }
2025 }
2026
2027
2028 static void opt_frame_pad_left(const char *arg)
2029 {
2030     frame_padleft = atoi(arg);
2031     if (frame_padleft < 0) {
2032         fprintf(stderr, "Incorrect left pad size\n");
2033         exit(1);
2034     }
2035     if ((frame_padleft % 2) != 0) {
2036         fprintf(stderr, "Left pad size must be a multiple of 2\n");
2037         exit(1);
2038     }
2039 }
2040
2041
2042 static void opt_frame_pad_right(const char *arg)
2043 {
2044     frame_padright = atoi(arg);
2045     if (frame_padright < 0) {
2046         fprintf(stderr, "Incorrect right pad size\n");
2047         exit(1);
2048     }
2049     if ((frame_padright % 2) != 0) {
2050         fprintf(stderr, "Right pad size must be a multiple of 2\n");
2051         exit(1);
2052     }
2053 }
2054
2055
2056 static void opt_frame_pix_fmt(const char *arg)
2057 {
2058     frame_pix_fmt = avcodec_get_pix_fmt(arg);
2059 }
2060
2061 static void opt_frame_aspect_ratio(const char *arg)
2062 {
2063     int x = 0, y = 0;
2064     double ar = 0;
2065     const char *p;
2066
2067     p = strchr(arg, ':');
2068     if (p) {
2069         x = strtol(arg, (char **)&arg, 10);
2070         if (arg == p)
2071             y = strtol(arg+1, (char **)&arg, 10);
2072         if (x > 0 && y > 0)
2073             ar = (double)x / (double)y;
2074     } else
2075         ar = strtod(arg, (char **)&arg);
2076
2077     if (!ar) {
2078         fprintf(stderr, "Incorrect aspect ratio specification.\n");
2079         exit(1);
2080     }
2081     frame_aspect_ratio = ar;
2082 }
2083
2084 static void opt_gop_size(const char *arg)
2085 {
2086     gop_size = atoi(arg);
2087 }
2088
2089 static void opt_b_frames(const char *arg)
2090 {
2091     b_frames = atoi(arg);
2092     if (b_frames > FF_MAX_B_FRAMES) {
2093         fprintf(stderr, "\nCannot have more than %d B frames, increase FF_MAX_B_FRAMES.\n", FF_MAX_B_FRAMES);
2094         exit(1);
2095     } else if (b_frames < 1) {
2096         fprintf(stderr, "\nNumber of B frames must be higher than 0\n");
2097         exit(1);
2098     }
2099 }
2100
2101 static void opt_mb_decision(const char *arg)
2102 {
2103     mb_decision = atoi(arg);
2104 }
2105
2106 static void opt_mb_cmp(const char *arg)
2107 {
2108     mb_cmp = atoi(arg);
2109 }
2110
2111 static void opt_ildct_cmp(const char *arg)
2112 {
2113     ildct_cmp = atoi(arg);
2114 }
2115
2116 static void opt_sub_cmp(const char *arg)
2117 {
2118     sub_cmp = atoi(arg);
2119 }
2120
2121 static void opt_cmp(const char *arg)
2122 {
2123     cmp = atoi(arg);
2124 }
2125
2126 static void opt_pre_cmp(const char *arg)
2127 {
2128     pre_cmp = atoi(arg);
2129 }
2130
2131 static void opt_pre_me(const char *arg)
2132 {
2133     pre_me = atoi(arg);
2134 }
2135
2136 static void opt_lumi_mask(const char *arg)
2137 {
2138     lumi_mask = atof(arg);
2139 }
2140
2141 static void opt_dark_mask(const char *arg)
2142 {
2143     dark_mask = atof(arg);
2144 }
2145
2146 static void opt_scplx_mask(const char *arg)
2147 {
2148     scplx_mask = atof(arg);
2149 }
2150
2151 static void opt_tcplx_mask(const char *arg)
2152 {
2153     tcplx_mask = atof(arg);
2154 }
2155
2156 static void opt_p_mask(const char *arg)
2157 {
2158     p_mask = atof(arg);
2159 }
2160
2161 static void opt_qscale(const char *arg)
2162 {
2163     video_qscale = atof(arg);
2164     if (video_qscale < 0.01 ||
2165         video_qscale > 255) {
2166         fprintf(stderr, "qscale must be >= 0.01 and <= 255\n");
2167         exit(1);
2168     }
2169 }
2170
2171 static void opt_qmin(const char *arg)
2172 {
2173     video_qmin = atoi(arg);
2174     if (video_qmin < 0 ||
2175         video_qmin > 31) {
2176         fprintf(stderr, "qmin must be >= 1 and <= 31\n");
2177         exit(1);
2178     }
2179 }
2180
2181 static void opt_qmax(const char *arg)
2182 {
2183     video_qmax = atoi(arg);
2184     if (video_qmax < 0 ||
2185         video_qmax > 31) {
2186         fprintf(stderr, "qmax must be >= 1 and <= 31\n");
2187         exit(1);
2188     }
2189 }
2190
2191 static void opt_mb_qmin(const char *arg)
2192 {
2193     video_mb_qmin = atoi(arg);
2194     if (video_mb_qmin < 0 ||
2195         video_mb_qmin > 31) {
2196         fprintf(stderr, "qmin must be >= 1 and <= 31\n");
2197         exit(1);
2198     }
2199 }
2200
2201 static void opt_mb_qmax(const char *arg)
2202 {
2203     video_mb_qmax = atoi(arg);
2204     if (video_mb_qmax < 0 ||
2205         video_mb_qmax > 31) {
2206         fprintf(stderr, "qmax must be >= 1 and <= 31\n");
2207         exit(1);
2208     }
2209 }
2210
2211 static void opt_qdiff(const char *arg)
2212 {
2213     video_qdiff = atoi(arg);
2214     if (video_qdiff < 0 ||
2215         video_qdiff > 31) {
2216         fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2217         exit(1);
2218     }
2219 }
2220
2221 static void opt_qblur(const char *arg)
2222 {
2223     video_qblur = atof(arg);
2224 }
2225
2226 static void opt_qcomp(const char *arg)
2227 {
2228     video_qcomp = atof(arg);
2229 }
2230
2231 static void opt_rc_initial_cplx(const char *arg)
2232 {
2233     video_rc_initial_cplx = atof(arg);
2234 }
2235 static void opt_b_qfactor(const char *arg)
2236 {
2237     video_b_qfactor = atof(arg);
2238 }
2239 static void opt_i_qfactor(const char *arg)
2240 {
2241     video_i_qfactor = atof(arg);
2242 }
2243 static void opt_b_qoffset(const char *arg)
2244 {
2245     video_b_qoffset = atof(arg);
2246 }
2247 static void opt_i_qoffset(const char *arg)
2248 {
2249     video_i_qoffset = atof(arg);
2250 }
2251
2252 static void opt_ibias(const char *arg)
2253 {
2254     video_intra_quant_bias = atoi(arg);
2255 }
2256 static void opt_pbias(const char *arg)
2257 {
2258     video_inter_quant_bias = atoi(arg);
2259 }
2260
2261 static void opt_packet_size(const char *arg)
2262 {
2263     packet_size= atoi(arg);
2264 }
2265
2266 static void opt_error_rate(const char *arg)
2267 {
2268     error_rate= atoi(arg);
2269 }
2270
2271 static void opt_strict(const char *arg)
2272 {
2273     strict= atoi(arg);
2274 }
2275
2276 static void opt_top_field_first(const char *arg)
2277 {
2278     top_field_first= atoi(arg);
2279 }
2280
2281 static void opt_noise_reduction(const char *arg)
2282 {
2283     noise_reduction= atoi(arg);
2284 }
2285
2286 static void opt_qns(const char *arg)
2287 {
2288     qns= atoi(arg);
2289 }
2290
2291 static void opt_sc_threshold(const char *arg)
2292 {
2293     sc_threshold= atoi(arg);
2294 }
2295
2296 static void opt_thread_count(const char *arg)
2297 {
2298     thread_count= atoi(arg);
2299 #if !defined(HAVE_PTHREADS) && !defined(HAVE_W32THREADS)
2300     if (verbose >= 0)
2301         fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2302 #endif
2303 }
2304
2305 static void opt_audio_bitrate(const char *arg)
2306 {
2307     audio_bit_rate = atoi(arg) * 1000;
2308 }
2309
2310 static void opt_audio_rate(const char *arg)
2311 {
2312     audio_sample_rate = atoi(arg);
2313 }
2314
2315 static void opt_audio_channels(const char *arg)
2316 {
2317     audio_channels = atoi(arg);
2318 }
2319
2320 static void opt_video_device(const char *arg)
2321 {
2322     video_device = av_strdup(arg);
2323 }
2324
2325 static void opt_video_channel(const char *arg)
2326 {
2327     video_channel = strtol(arg, NULL, 0);
2328 }
2329
2330 static void opt_video_standard(const char *arg)
2331 {
2332     video_standard = av_strdup(arg);
2333 }
2334
2335 static void opt_audio_device(const char *arg)
2336 {
2337     audio_device = av_strdup(arg);
2338 }
2339
2340 static void opt_dv1394(const char *arg)
2341 {
2342     video_grab_format = "dv1394";
2343     audio_grab_format = NULL;
2344 }
2345
2346 static void opt_audio_codec(const char *arg)
2347 {
2348     AVCodec *p;
2349
2350     if (!strcmp(arg, "copy")) {
2351         audio_stream_copy = 1;
2352     } else {
2353         p = first_avcodec;
2354         while (p) {
2355             if (!strcmp(p->name, arg) && p->type == CODEC_TYPE_AUDIO)
2356                 break;
2357             p = p->next;
2358         }
2359         if (p == NULL) {
2360             fprintf(stderr, "Unknown audio codec '%s'\n", arg);
2361             exit(1);
2362         } else {
2363             audio_codec_id = p->id;
2364         }
2365     }
2366 }
2367
2368 static void add_frame_hooker(const char *arg)
2369 {
2370     int argc = 0;
2371     char *argv[64];
2372     int i;
2373     char *args = av_strdup(arg);
2374
2375     using_vhook = 1;
2376
2377     argv[0] = strtok(args, " ");
2378     while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2379     }
2380
2381     i = frame_hook_add(argc, argv);
2382
2383     if (i != 0) {
2384         fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2385         exit(1);
2386     }
2387 }
2388
2389 const char *motion_str[] = {
2390     "zero",
2391     "full",
2392     "log",
2393     "phods",
2394     "epzs",
2395     "x1",
2396     NULL,
2397 };
2398
2399 static void opt_motion_estimation(const char *arg)
2400 {
2401     const char **p;
2402     p = motion_str;
2403     for(;;) {
2404         if (!*p) {
2405             fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
2406             exit(1);
2407         }
2408         if (!strcmp(*p, arg))
2409             break;
2410         p++;
2411     }
2412     me_method = (p - motion_str) + 1;
2413 }
2414
2415 static void opt_video_codec(const char *arg)
2416 {
2417     AVCodec *p;
2418
2419     if (!strcmp(arg, "copy")) {
2420         video_stream_copy = 1;
2421     } else {
2422         p = first_avcodec;
2423         while (p) {
2424             if (!strcmp(p->name, arg) && p->type == CODEC_TYPE_VIDEO)
2425                 break;
2426             p = p->next;
2427         }
2428         if (p == NULL) {
2429             fprintf(stderr, "Unknown video codec '%s'\n", arg);
2430             exit(1);
2431         } else {
2432             video_codec_id = p->id;
2433         }
2434     }
2435 }
2436
2437 static void opt_map(const char *arg)
2438 {
2439     AVStreamMap *m;
2440     const char *p;
2441
2442     p = arg;
2443     m = &stream_maps[nb_stream_maps++];
2444
2445     m->file_index = strtol(arg, (char **)&p, 0);
2446     if (*p)
2447         p++;
2448
2449     m->stream_index = strtol(p, (char **)&p, 0);
2450 }
2451
2452 static void opt_recording_time(const char *arg)
2453 {
2454     recording_time = parse_date(arg, 1);
2455 }
2456
2457 static void opt_start_time(const char *arg)
2458 {
2459     start_time = parse_date(arg, 1);
2460 }
2461
2462 static void opt_rec_timestamp(const char *arg)
2463 {
2464     rec_timestamp = parse_date(arg, 0) / 1000000;
2465 }
2466
2467 static void opt_input_file(const char *filename)
2468 {
2469     AVFormatContext *ic;
2470     AVFormatParameters params, *ap = &params;
2471     int err, i, ret, rfps, rfps_base;
2472
2473     if (!strcmp(filename, "-"))
2474         filename = "pipe:";
2475
2476     using_stdin |= !strcmp(filename, "pipe:" ) ||
2477                    !strcmp( filename, "/dev/stdin" );
2478
2479     /* get default parameters from command line */
2480     memset(ap, 0, sizeof(*ap));
2481     ap->sample_rate = audio_sample_rate;
2482     ap->channels = audio_channels;
2483     ap->frame_rate = frame_rate;
2484     ap->frame_rate_base = frame_rate_base;
2485     ap->width = frame_width + frame_padleft + frame_padright;
2486     ap->height = frame_height + frame_padtop + frame_padbottom;
2487     ap->image_format = image_format;
2488     ap->pix_fmt = frame_pix_fmt;
2489
2490     /* open the input file with generic libav function */
2491     err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2492     if (err < 0) {
2493         print_error(filename, err);
2494         exit(1);
2495     }
2496
2497     /* If not enough info to get the stream parameters, we decode the
2498        first frames to get it. (used in mpeg case for example) */
2499     ret = av_find_stream_info(ic);
2500     if (ret < 0 && verbose >= 0) {
2501         fprintf(stderr, "%s: could not find codec parameters\n", filename);
2502         exit(1);
2503     }
2504
2505     /* if seeking requested, we execute it */
2506     if (start_time != 0) {
2507         int64_t timestamp;
2508
2509         timestamp = start_time;
2510         /* add the stream start time */
2511         if (ic->start_time != AV_NOPTS_VALUE)
2512             timestamp += ic->start_time;
2513         ret = av_seek_frame(ic, -1, timestamp);
2514         if (ret < 0) {
2515             fprintf(stderr, "%s: could not seek to position %0.3f\n",
2516                     filename, (double)timestamp / AV_TIME_BASE);
2517         }
2518         /* reset seek info */
2519         start_time = 0;
2520     }
2521
2522     /* update the current parameters so that they match the one of the input stream */
2523     for(i=0;i<ic->nb_streams;i++) {
2524         AVCodecContext *enc = &ic->streams[i]->codec;
2525 #if defined(HAVE_PTHREADS) || defined(HAVE_W32THREADS)
2526         if(thread_count>1)
2527             avcodec_thread_init(enc, thread_count);
2528 #endif
2529         enc->thread_count= thread_count;
2530         switch(enc->codec_type) {
2531         case CODEC_TYPE_AUDIO:
2532             //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2533             audio_channels = enc->channels;
2534             audio_sample_rate = enc->sample_rate;
2535             break;
2536         case CODEC_TYPE_VIDEO:
2537             frame_height = enc->height;
2538             frame_width = enc->width;
2539             frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2540             frame_pix_fmt = enc->pix_fmt;
2541             rfps      = ic->streams[i]->r_frame_rate;
2542             rfps_base = ic->streams[i]->r_frame_rate_base;
2543             enc->workaround_bugs = workaround_bugs;
2544             enc->error_resilience = error_resilience;
2545             enc->error_concealment = error_concealment;
2546             enc->idct_algo = idct_algo;
2547             enc->debug = debug;
2548             enc->debug_mv = debug_mv;
2549             if(bitexact)
2550                 enc->flags|= CODEC_FLAG_BITEXACT;
2551
2552             assert(enc->frame_rate_base == rfps_base); // should be true for now
2553             if (enc->frame_rate != rfps) {
2554
2555                 if (verbose >= 0)
2556                     fprintf(stderr,"\nSeems that stream %d comes from film source: %2.2f->%2.2f\n",
2557                             i, (float)enc->frame_rate / enc->frame_rate_base,
2558
2559                     (float)rfps / rfps_base);
2560             }
2561             /* update the current frame rate to match the stream frame rate */
2562             frame_rate      = rfps;
2563             frame_rate_base = rfps_base;
2564
2565             enc->rate_emu = rate_emu;
2566             break;
2567         case CODEC_TYPE_DATA:
2568             break;
2569         default:
2570             av_abort();
2571         }
2572     }
2573
2574     input_files[nb_input_files] = ic;
2575     /* dump the file content */
2576     if (verbose >= 0)
2577         dump_format(ic, nb_input_files, filename, 0);
2578
2579     nb_input_files++;
2580     file_iformat = NULL;
2581     file_oformat = NULL;
2582     image_format = NULL;
2583
2584     rate_emu = 0;
2585 }
2586
2587 static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2588 {
2589     int has_video, has_audio, i, j;
2590     AVFormatContext *ic;
2591
2592     has_video = 0;
2593     has_audio = 0;
2594     for(j=0;j<nb_input_files;j++) {
2595         ic = input_files[j];
2596         for(i=0;i<ic->nb_streams;i++) {
2597             AVCodecContext *enc = &ic->streams[i]->codec;
2598             switch(enc->codec_type) {
2599             case CODEC_TYPE_AUDIO:
2600                 has_audio = 1;
2601                 break;
2602             case CODEC_TYPE_VIDEO:
2603                 has_video = 1;
2604                 break;
2605             case CODEC_TYPE_DATA:
2606                 break;
2607             default:
2608                 av_abort();
2609             }
2610         }
2611     }
2612     *has_video_ptr = has_video;
2613     *has_audio_ptr = has_audio;
2614 }
2615
2616 static void opt_output_file(const char *filename)
2617 {
2618     AVStream *st;
2619     AVFormatContext *oc;
2620     int use_video, use_audio, nb_streams, input_has_video, input_has_audio;
2621     int codec_id;
2622     AVFormatParameters params, *ap = &params;
2623
2624     if (!strcmp(filename, "-"))
2625         filename = "pipe:";
2626
2627     oc = av_alloc_format_context();
2628
2629     if (!file_oformat) {
2630         file_oformat = guess_format(NULL, filename, NULL);
2631         if (!file_oformat) {
2632             fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
2633                     filename);
2634             exit(1);
2635         }
2636     }
2637
2638     oc->oformat = file_oformat;
2639
2640     if (!strcmp(file_oformat->name, "ffm") &&
2641         strstart(filename, "http:", NULL)) {
2642         /* special case for files sent to ffserver: we get the stream
2643            parameters from ffserver */
2644         if (read_ffserver_streams(oc, filename) < 0) {
2645             fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
2646             exit(1);
2647         }
2648     } else {
2649         use_video = file_oformat->video_codec != CODEC_ID_NONE;
2650         use_audio = file_oformat->audio_codec != CODEC_ID_NONE;
2651
2652         /* disable if no corresponding type found and at least one
2653            input file */
2654         if (nb_input_files > 0) {
2655             check_audio_video_inputs(&input_has_video, &input_has_audio);
2656             if (!input_has_video)
2657                 use_video = 0;
2658             if (!input_has_audio)
2659                 use_audio = 0;
2660         }
2661
2662         /* manual disable */
2663         if (audio_disable) {
2664             use_audio = 0;
2665         }
2666         if (video_disable) {
2667             use_video = 0;
2668         }
2669
2670         nb_streams = 0;
2671         if (use_video) {
2672             AVCodecContext *video_enc;
2673
2674             st = av_mallocz(sizeof(AVStream));
2675             if (!st) {
2676                 fprintf(stderr, "Could not alloc stream\n");
2677                 exit(1);
2678             }
2679             avcodec_get_context_defaults(&st->codec);
2680 #if defined(HAVE_PTHREADS) || defined(HAVE_W32THREADS)
2681             if(thread_count>1)
2682                 avcodec_thread_init(&st->codec, thread_count);
2683 #endif
2684
2685             video_enc = &st->codec;
2686
2687             if(!strcmp(file_oformat->name, "mp4") || !strcmp(file_oformat->name, "mov") || !strcmp(file_oformat->name, "3gp"))
2688                 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2689             if (video_stream_copy) {
2690                 st->stream_copy = 1;
2691                 video_enc->codec_type = CODEC_TYPE_VIDEO;
2692             } else {
2693                 char *p;
2694                 int i;
2695
2696                 codec_id = file_oformat->video_codec;
2697                 if (video_codec_id != CODEC_ID_NONE)
2698                     codec_id = video_codec_id;
2699
2700                 video_enc->codec_id = codec_id;
2701
2702                 video_enc->bit_rate = video_bit_rate;
2703                 video_enc->bit_rate_tolerance = video_bit_rate_tolerance;
2704                 video_enc->frame_rate = frame_rate;
2705                 video_enc->frame_rate_base = frame_rate_base;
2706
2707                 video_enc->width = frame_width + frame_padright + frame_padleft;
2708                 video_enc->height = frame_height + frame_padtop + frame_padbottom;
2709                 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
2710                 video_enc->pix_fmt = frame_pix_fmt;
2711
2712                 if (!intra_only)
2713                     video_enc->gop_size = gop_size;
2714                 else
2715                     video_enc->gop_size = 0;
2716                 if (video_qscale || same_quality) {
2717                     video_enc->flags |= CODEC_FLAG_QSCALE;
2718                     st->quality = FF_QP2LAMBDA * video_qscale;
2719                 }
2720
2721                 if(intra_matrix)
2722                     video_enc->intra_matrix = intra_matrix;
2723                 if(inter_matrix)
2724                     video_enc->inter_matrix = inter_matrix;
2725
2726                 if(bitexact)
2727                     video_enc->flags |= CODEC_FLAG_BITEXACT;
2728
2729                 video_enc->mb_decision = mb_decision;
2730                 video_enc->mb_cmp = mb_cmp;
2731                 video_enc->ildct_cmp = ildct_cmp;
2732                 video_enc->me_sub_cmp = sub_cmp;
2733                 video_enc->me_cmp = cmp;
2734                 video_enc->me_pre_cmp = pre_cmp;
2735                 video_enc->pre_me = pre_me;
2736                 video_enc->lumi_masking = lumi_mask;
2737                 video_enc->dark_masking = dark_mask;
2738                 video_enc->spatial_cplx_masking = scplx_mask;
2739                 video_enc->temporal_cplx_masking = tcplx_mask;
2740                 video_enc->p_masking = p_mask;
2741                 video_enc->quantizer_noise_shaping= qns;
2742
2743                 if (use_umv) {
2744                     video_enc->flags |= CODEC_FLAG_H263P_UMV;
2745                 }
2746                 if (use_ss) {
2747                     video_enc->flags |= CODEC_FLAG_H263P_SLICE_STRUCT;
2748                 }
2749                 if (use_aic) {
2750                     video_enc->flags |= CODEC_FLAG_H263P_AIC;
2751                 }
2752                 if (use_aiv) {
2753                     video_enc->flags |= CODEC_FLAG_H263P_AIV;
2754                 }
2755                 if (use_4mv) {
2756                     video_enc->flags |= CODEC_FLAG_4MV;
2757                 }
2758                 if (use_obmc) {
2759                     video_enc->flags |= CODEC_FLAG_OBMC;
2760                 }
2761                 if (use_loop) {
2762                     video_enc->flags |= CODEC_FLAG_LOOP_FILTER;
2763                 }
2764
2765                 if(use_part) {
2766                     video_enc->flags |= CODEC_FLAG_PART;
2767                 }
2768                 if (use_alt_scan) {
2769                     video_enc->flags |= CODEC_FLAG_ALT_SCAN;
2770                 }
2771                 if (use_trell) {
2772                     video_enc->flags |= CODEC_FLAG_TRELLIS_QUANT;
2773                 }
2774                 if (use_scan_offset) {
2775                     video_enc->flags |= CODEC_FLAG_SVCD_SCAN_OFFSET;
2776                 }
2777                 if (closed_gop) {
2778                     video_enc->flags |= CODEC_FLAG_CLOSED_GOP;
2779                 }
2780                 if (b_frames) {
2781                     video_enc->max_b_frames = b_frames;
2782                     video_enc->b_frame_strategy = 0;
2783                     video_enc->b_quant_factor = 2.0;
2784                 }
2785                 if (do_interlace_dct) {
2786                     video_enc->flags |= CODEC_FLAG_INTERLACED_DCT;
2787                 }
2788                 if (do_interlace_me) {
2789                     video_enc->flags |= CODEC_FLAG_INTERLACED_ME;
2790                 }
2791                 video_enc->qmin = video_qmin;
2792                 video_enc->qmax = video_qmax;
2793                 video_enc->mb_qmin = video_mb_qmin;
2794                 video_enc->mb_qmax = video_mb_qmax;
2795                 video_enc->max_qdiff = video_qdiff;
2796                 video_enc->qblur = video_qblur;
2797                 video_enc->qcompress = video_qcomp;
2798                 video_enc->rc_eq = video_rc_eq;
2799                 video_enc->debug = debug;
2800                 video_enc->debug_mv = debug_mv;
2801                 video_enc->thread_count = thread_count;
2802                 p= video_rc_override_string;
2803                 for(i=0; p; i++){
2804                     int start, end, q;
2805                     int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
2806                     if(e!=3){
2807                         fprintf(stderr, "error parsing rc_override\n");
2808                         exit(1);
2809                     }
2810                     video_enc->rc_override=
2811                         av_realloc(video_enc->rc_override,
2812                                    sizeof(RcOverride)*(i+1));
2813                     video_enc->rc_override[i].start_frame= start;
2814                     video_enc->rc_override[i].end_frame  = end;
2815                     if(q>0){
2816                         video_enc->rc_override[i].qscale= q;
2817                         video_enc->rc_override[i].quality_factor= 1.0;
2818                     }
2819                     else{
2820                         video_enc->rc_override[i].qscale= 0;
2821                         video_enc->rc_override[i].quality_factor= -q/100.0;
2822                     }
2823                     p= strchr(p, '/');
2824                     if(p) p++;
2825                 }
2826                 video_enc->rc_override_count=i;
2827
2828                 video_enc->rc_max_rate = video_rc_max_rate;
2829                 video_enc->rc_min_rate = video_rc_min_rate;
2830                 video_enc->rc_buffer_size = video_rc_buffer_size;
2831                 video_enc->rc_buffer_aggressivity= video_rc_buffer_aggressivity;
2832                 video_enc->rc_initial_cplx= video_rc_initial_cplx;
2833                 video_enc->i_quant_factor = video_i_qfactor;
2834                 video_enc->b_quant_factor = video_b_qfactor;
2835                 video_enc->i_quant_offset = video_i_qoffset;
2836                 video_enc->b_quant_offset = video_b_qoffset;
2837                 video_enc->intra_quant_bias = video_intra_quant_bias;
2838                 video_enc->inter_quant_bias = video_inter_quant_bias;
2839                 video_enc->dct_algo = dct_algo;
2840                 video_enc->idct_algo = idct_algo;
2841                 video_enc->strict_std_compliance = strict;
2842                 video_enc->error_rate = error_rate;
2843                 video_enc->noise_reduction= noise_reduction;
2844                 video_enc->scenechange_threshold= sc_threshold;
2845                 if(packet_size){
2846                     video_enc->rtp_mode= 1;
2847                     video_enc->rtp_payload_size= packet_size;
2848                 }
2849
2850                 if (do_psnr)
2851                     video_enc->flags|= CODEC_FLAG_PSNR;
2852
2853                 video_enc->me_method = me_method;
2854
2855                 /* two pass mode */
2856                 if (do_pass) {
2857                     if (do_pass == 1) {
2858                         video_enc->flags |= CODEC_FLAG_PASS1;
2859                     } else {
2860                         video_enc->flags |= CODEC_FLAG_PASS2;
2861                     }
2862                 }
2863             }
2864             oc->streams[nb_streams] = st;
2865             nb_streams++;
2866         }
2867
2868         if (use_audio) {
2869             AVCodecContext *audio_enc;
2870
2871             st = av_mallocz(sizeof(AVStream));
2872             if (!st) {
2873                 fprintf(stderr, "Could not alloc stream\n");
2874                 exit(1);
2875             }
2876             avcodec_get_context_defaults(&st->codec);
2877 #if defined(HAVE_PTHREADS) || defined(HAVE_W32THREADS)
2878             if(thread_count>1)
2879                 avcodec_thread_init(&st->codec, thread_count);
2880 #endif
2881
2882             audio_enc = &st->codec;
2883             audio_enc->codec_type = CODEC_TYPE_AUDIO;
2884
2885             if(!strcmp(file_oformat->name, "mp4") || !strcmp(file_oformat->name, "mov") || !strcmp(file_oformat->name, "3gp"))
2886                 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2887             if (audio_stream_copy) {
2888                 st->stream_copy = 1;
2889             } else {
2890                 codec_id = file_oformat->audio_codec;
2891                 if (audio_codec_id != CODEC_ID_NONE)
2892                     codec_id = audio_codec_id;
2893                 audio_enc->codec_id = codec_id;
2894
2895                 audio_enc->bit_rate = audio_bit_rate;
2896                 audio_enc->sample_rate = audio_sample_rate;
2897                 audio_enc->strict_std_compliance = strict;
2898                 audio_enc->thread_count = thread_count;
2899                 /* For audio codecs other than AC3 we limit */
2900                 /* the number of coded channels to stereo   */
2901                 if (audio_channels > 2 && codec_id != CODEC_ID_AC3) {
2902                     audio_enc->channels = 2;
2903                 } else
2904                     audio_enc->channels = audio_channels;
2905             }
2906             oc->streams[nb_streams] = st;
2907             nb_streams++;
2908         }
2909
2910         oc->nb_streams = nb_streams;
2911
2912         if (!nb_streams) {
2913             fprintf(stderr, "No audio or video streams available\n");
2914             exit(1);
2915         }
2916
2917         oc->timestamp = rec_timestamp;
2918
2919         if (str_title)
2920             pstrcpy(oc->title, sizeof(oc->title), str_title);
2921         if (str_author)
2922             pstrcpy(oc->author, sizeof(oc->author), str_author);
2923         if (str_copyright)
2924             pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
2925         if (str_comment)
2926             pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
2927     }
2928
2929     output_files[nb_output_files++] = oc;
2930
2931     strcpy(oc->filename, filename);
2932
2933     /* check filename in case of an image number is expected */
2934     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2935         if (filename_number_test(oc->filename) < 0) {
2936             print_error(oc->filename, AVERROR_NUMEXPECTED);
2937             exit(1);
2938         }
2939     }
2940
2941     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2942         /* test if it already exists to avoid loosing precious files */
2943         if (!file_overwrite &&
2944             (strchr(filename, ':') == NULL ||
2945              strstart(filename, "file:", NULL))) {
2946             if (url_exist(filename)) {
2947                 int c;
2948
2949                 if ( !using_stdin ) {
2950                     fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
2951                     fflush(stderr);
2952                     c = getchar();
2953                     if (toupper(c) != 'Y') {
2954                         fprintf(stderr, "Not overwriting - exiting\n");
2955                         exit(1);
2956                     }
2957                                 }
2958                                 else {
2959                     fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
2960                     exit(1);
2961                                 }
2962             }
2963         }
2964
2965         /* open the file */
2966         if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
2967             fprintf(stderr, "Could not open '%s'\n", filename);
2968             exit(1);
2969         }
2970     }
2971
2972     memset(ap, 0, sizeof(*ap));
2973     ap->image_format = image_format;
2974     if (av_set_parameters(oc, ap) < 0) {
2975         fprintf(stderr, "%s: Invalid encoding parameters\n",
2976                 oc->filename);
2977         exit(1);
2978     }
2979
2980     /* reset some options */
2981     file_oformat = NULL;
2982     file_iformat = NULL;
2983     image_format = NULL;
2984     audio_disable = 0;
2985     video_disable = 0;
2986     audio_codec_id = CODEC_ID_NONE;
2987     video_codec_id = CODEC_ID_NONE;
2988     audio_stream_copy = 0;
2989     video_stream_copy = 0;
2990 }
2991
2992 /* prepare dummy protocols for grab */
2993 static void prepare_grab(void)
2994 {
2995     int has_video, has_audio, i, j;
2996     AVFormatContext *oc;
2997     AVFormatContext *ic;
2998     AVFormatParameters vp1, *vp = &vp1;
2999     AVFormatParameters ap1, *ap = &ap1;
3000
3001     /* see if audio/video inputs are needed */
3002     has_video = 0;
3003     has_audio = 0;
3004     memset(ap, 0, sizeof(*ap));
3005     memset(vp, 0, sizeof(*vp));
3006     for(j=0;j<nb_output_files;j++) {
3007         oc = output_files[j];
3008         for(i=0;i<oc->nb_streams;i++) {
3009             AVCodecContext *enc = &oc->streams[i]->codec;
3010             switch(enc->codec_type) {
3011             case CODEC_TYPE_AUDIO:
3012                 if (enc->sample_rate > ap->sample_rate)
3013                     ap->sample_rate = enc->sample_rate;
3014                 if (enc->channels > ap->channels)
3015                     ap->channels = enc->channels;
3016                 has_audio = 1;
3017                 break;
3018             case CODEC_TYPE_VIDEO:
3019                 if (enc->width > vp->width)
3020                     vp->width = enc->width;
3021                 if (enc->height > vp->height)
3022                     vp->height = enc->height;
3023
3024                 assert(enc->frame_rate_base == DEFAULT_FRAME_RATE_BASE);
3025                 if (enc->frame_rate > vp->frame_rate){
3026                     vp->frame_rate      = enc->frame_rate;
3027                     vp->frame_rate_base = enc->frame_rate_base;
3028                 }
3029                 has_video = 1;
3030                 break;
3031             default:
3032                 av_abort();
3033             }
3034         }
3035     }
3036
3037     if (has_video == 0 && has_audio == 0) {
3038         fprintf(stderr, "Output file must have at least one audio or video stream\n");
3039         exit(1);
3040     }
3041
3042     if (has_video) {
3043         AVInputFormat *fmt1;
3044         fmt1 = av_find_input_format(video_grab_format);
3045         vp->device  = video_device;
3046         vp->channel = video_channel;
3047         vp->standard = video_standard;
3048         if (av_open_input_file(&ic, "", fmt1, 0, vp) < 0) {
3049             fprintf(stderr, "Could not find video grab device\n");
3050             exit(1);
3051         }
3052         /* If not enough info to get the stream parameters, we decode the
3053            first frames to get it. */
3054         if ((ic->ctx_flags & AVFMTCTX_NOHEADER) && av_find_stream_info(ic) < 0) {
3055             fprintf(stderr, "Could not find video grab parameters\n");
3056             exit(1);
3057         }
3058         /* by now video grab has one stream */
3059         ic->streams[0]->r_frame_rate      = vp->frame_rate;
3060         ic->streams[0]->r_frame_rate_base = vp->frame_rate_base;
3061         input_files[nb_input_files] = ic;
3062
3063         if (verbose >= 0)
3064             dump_format(ic, nb_input_files, "", 0);
3065
3066         nb_input_files++;
3067     }
3068     if (has_audio && audio_grab_format) {
3069         AVInputFormat *fmt1;
3070         fmt1 = av_find_input_format(audio_grab_format);
3071         ap->device = audio_device;
3072         if (av_open_input_file(&ic, "", fmt1, 0, ap) < 0) {
3073             fprintf(stderr, "Could not find audio grab device\n");
3074             exit(1);
3075         }
3076         input_files[nb_input_files] = ic;
3077
3078         if (verbose >= 0)
3079             dump_format(ic, nb_input_files, "", 0);
3080
3081         nb_input_files++;
3082     }
3083 }
3084
3085 /* same option as mencoder */
3086 static void opt_pass(const char *pass_str)
3087 {
3088     int pass;
3089     pass = atoi(pass_str);
3090     if (pass != 1 && pass != 2) {
3091         fprintf(stderr, "pass number can be only 1 or 2\n");
3092         exit(1);
3093     }
3094     do_pass = pass;
3095 }
3096
3097 #if defined(CONFIG_WIN32) || defined(CONFIG_OS2)
3098 static int64_t getutime(void)
3099 {
3100   return av_gettime();
3101 }
3102 #else
3103 static int64_t getutime(void)
3104 {
3105     struct rusage rusage;
3106
3107     getrusage(RUSAGE_SELF, &rusage);
3108     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3109 }
3110 #endif
3111
3112 extern int ffm_nopts;
3113
3114 static void opt_bitexact(void)
3115 {
3116     bitexact=1;
3117     /* disable generate of real time pts in ffm (need to be supressed anyway) */
3118     ffm_nopts = 1;
3119 }
3120
3121 static void show_formats(void)
3122 {
3123     AVInputFormat *ifmt;
3124     AVOutputFormat *ofmt;
3125     AVImageFormat *image_fmt;
3126     URLProtocol *up;
3127     AVCodec *p, *p2;
3128     const char **pp, *last_name;
3129
3130     printf("File formats:\n");
3131     last_name= "000";
3132     for(;;){
3133         int decode=0;
3134         int encode=0;
3135         const char *name=NULL;
3136
3137         for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3138             if((name == NULL || strcmp(ofmt->name, name)<0) &&
3139                 strcmp(ofmt->name, last_name)>0){
3140                 name= ofmt->name;
3141                 encode=1;
3142             }
3143         }
3144         for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3145             if((name == NULL || strcmp(ifmt->name, name)<0) &&
3146                 strcmp(ifmt->name, last_name)>0){
3147                 name= ifmt->name;
3148                 encode=0;
3149             }
3150             if(name && strcmp(ifmt->name, name)==0)
3151                 decode=1;
3152         }
3153         if(name==NULL)
3154             break;
3155         last_name= name;
3156
3157         printf(
3158             " %s%s %s\n",
3159             decode ? "D":" ",
3160             encode ? "E":" ",
3161             name);
3162     }
3163     printf("\n");
3164
3165     printf("Image formats:\n");
3166     for(image_fmt = first_image_format; image_fmt != NULL;
3167         image_fmt = image_fmt->next) {
3168         printf(
3169             " %s%s %s\n",
3170             image_fmt->img_read  ? "D":" ",
3171             image_fmt->img_write ? "E":" ",
3172             image_fmt->name);
3173     }
3174     printf("\n");
3175
3176     printf("Codecs:\n");
3177     last_name= "000";
3178     for(;;){
3179         int decode=0;
3180         int encode=0;
3181         int cap=0;
3182
3183         p2=NULL;
3184         for(p = first_avcodec; p != NULL; p = p->next) {
3185             if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3186                 strcmp(p->name, last_name)>0){
3187                 p2= p;
3188                 decode= encode= cap=0;
3189             }
3190             if(p2 && strcmp(p->name, p2->name)==0){
3191                 if(p->decode) decode=1;
3192                 if(p->encode) encode=1;
3193                 cap |= p->capabilities;
3194             }
3195         }
3196         if(p2==NULL)
3197             break;
3198         last_name= p2->name;
3199
3200         printf(
3201             " %s%s%s%s%s%s %s",
3202             decode ? "D": (/*p2->decoder ? "d":*/" "),
3203             encode ? "E":" ",
3204             p2->type == CODEC_TYPE_AUDIO ? "A":"V",
3205             cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3206             cap & CODEC_CAP_DR1 ? "D":" ",
3207             cap & CODEC_CAP_TRUNCATED ? "T":" ",
3208             p2->name);
3209        /* if(p2->decoder && decode==0)
3210             printf(" use %s for decoding", p2->decoder->name);*/
3211         printf("\n");
3212     }
3213     printf("\n");
3214
3215     printf("Supported file protocols:\n");
3216     for(up = first_protocol; up != NULL; up = up->next)
3217         printf(" %s:", up->name);
3218     printf("\n");
3219
3220     printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3221     printf("Motion estimation methods:\n");
3222     pp = motion_str;
3223     while (*pp) {
3224         printf(" %s", *pp);
3225         if ((pp - motion_str + 1) == ME_ZERO)
3226             printf("(fastest)");
3227         else if ((pp - motion_str + 1) == ME_FULL)
3228             printf("(slowest)");
3229         else if ((pp - motion_str + 1) == ME_EPZS)
3230             printf("(default)");
3231         pp++;
3232     }
3233     printf("\n\n");
3234     printf(
3235 "Note, the names of encoders and decoders dont always match, so there are\n"
3236 "several cases where the above table shows encoder only or decoder only entries\n"
3237 "even though both encoding and decoding are supported for example, the h263\n"
3238 "decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
3239 "worse\n");
3240     exit(1);
3241 }
3242
3243 void parse_matrix_coeffs(uint16_t *dest, const char *str)
3244 {
3245     int i;
3246     const char *p = str;
3247     for(i = 0;; i++) {
3248         dest[i] = atoi(p);
3249         if(i == 63)
3250             break;
3251         p = strchr(p, ',');
3252         if(!p) {
3253             fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3254             exit(1);
3255         }
3256         p++;
3257     }
3258 }
3259
3260 void opt_inter_matrix(const char *arg)
3261 {
3262     inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3263     parse_matrix_coeffs(inter_matrix, arg);
3264 }
3265
3266 void opt_intra_matrix(const char *arg)
3267 {
3268     intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3269     parse_matrix_coeffs(intra_matrix, arg);
3270 }
3271
3272 static void opt_target(const char *arg)
3273 {
3274     int norm = -1;
3275
3276     if(!strncmp(arg, "pal-", 4)) {
3277         norm = 0;
3278         arg += 4;
3279     } else if(!strncmp(arg, "ntsc-", 5)) {
3280         norm = 1;
3281         arg += 5;
3282     } else {
3283         int fr;
3284         /* Calculate FR via float to avoid int overflow */
3285         fr = (int)(frame_rate * 1000.0 / frame_rate_base);
3286         if(fr == 25000) {
3287             norm = 0;
3288         } else if((fr == 29970) || (fr == 23976)) {
3289             norm = 1;
3290         } else {
3291             /* Try to determine PAL/NTSC by peeking in the input files */
3292             if(nb_input_files) {
3293                 int i, j;
3294                 for(j = 0; j < nb_input_files; j++) {
3295                     for(i = 0; i < input_files[j]->nb_streams; i++) {
3296                         AVCodecContext *c = &input_files[j]->streams[i]->codec;
3297                         if(c->codec_type != CODEC_TYPE_VIDEO)
3298                             continue;
3299                         fr = c->frame_rate * 1000 / c->frame_rate_base;
3300                         if(fr == 25000) {
3301                             norm = 0;
3302                             break;
3303                         } else if((fr == 29970) || (fr == 23976)) {
3304                             norm = 1;
3305                             break;
3306                         }
3307                     }
3308                     if(norm >= 0)
3309                         break;
3310                 }
3311             }
3312         }
3313         if(verbose && norm >= 0)
3314             printf("Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3315     }
3316
3317     if(norm < 0) {
3318         fprintf(stderr, "Could not determine norm (PAL/NTSC) for target.\n");
3319         fprintf(stderr, "Please prefix target with \"pal-\" or \"ntsc-\",\n");
3320         fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3321         exit(1);
3322     }
3323
3324     if(!strcmp(arg, "vcd")) {
3325
3326         opt_video_codec("mpeg1video");
3327         opt_audio_codec("mp2");
3328         opt_format("vcd");
3329
3330         opt_frame_size(norm ? "352x240" : "352x288");
3331
3332         video_bit_rate = 1150000;
3333         video_rc_max_rate = 1150000;
3334         video_rc_min_rate = 1150000;
3335         video_rc_buffer_size = 40*1024*8;
3336
3337         audio_bit_rate = 224000;
3338         audio_sample_rate = 44100;
3339
3340     } else if(!strcmp(arg, "svcd")) {
3341
3342         opt_video_codec("mpeg2video");
3343         opt_audio_codec("mp2");
3344         opt_format("svcd");
3345
3346         opt_frame_size(norm ? "480x480" : "480x576");
3347         opt_gop_size(norm ? "18" : "15");
3348
3349         video_bit_rate = 2040000;
3350         video_rc_max_rate = 2516000;
3351         video_rc_min_rate = 0; //1145000;
3352         video_rc_buffer_size = 224*1024*8;
3353         use_scan_offset = 1;
3354
3355         audio_bit_rate = 224000;
3356         audio_sample_rate = 44100;
3357
3358     } else if(!strcmp(arg, "dvd")) {
3359
3360         opt_video_codec("mpeg2video");
3361         opt_audio_codec("ac3");
3362         opt_format("vob");
3363
3364         opt_frame_size(norm ? "720x480" : "720x576");
3365         opt_gop_size(norm ? "18" : "15");
3366
3367         video_bit_rate = 6000000;
3368         video_rc_max_rate = 9000000;
3369         video_rc_min_rate = 0; //1500000;
3370         video_rc_buffer_size = 224*1024*8;
3371
3372         audio_bit_rate = 448000;
3373         audio_sample_rate = 48000;
3374
3375     } else {
3376         fprintf(stderr, "Unknown target: %s\n", arg);
3377         exit(1);
3378     }
3379 }
3380
3381 const OptionDef options[] = {
3382     /* main options */
3383     { "L", 0, {(void*)show_license}, "show license" },
3384     { "h", 0, {(void*)show_help}, "show help" },
3385     { "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3386     { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3387     { "img", HAS_ARG, {(void*)opt_image_format}, "force image format", "img_fmt" },
3388     { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3389     { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3390     { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream" },
3391     { "t", HAS_ARG, {(void*)opt_recording_time}, "set the recording time", "duration" },
3392     { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3393     { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3394     { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3395     { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3396     { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3397     { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3398     { "debug", HAS_ARG | OPT_EXPERT, {(void*)opt_debug}, "print specific debug info", "" },
3399     { "vismv", HAS_ARG | OPT_EXPERT, {(void*)opt_vismv}, "visualize motion vectors", "" },
3400     { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3401       "add timings for benchmarking" },
3402     { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3403       "dump each input packet" },
3404     { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3405       "when dumping packets, also dump the payload" },
3406     { "bitexact", OPT_EXPERT, {(void*)opt_bitexact}, "only use bit exact algorithms (for codec testing)" },
3407     { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3408     { "loop", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3409     { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
3410     { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\" or \"dvd\")", "type" },
3411     { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3412
3413     /* video options */
3414     { "b", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate}, "set video bitrate (in kbit/s)", "bitrate" },
3415     { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3416     { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3417     { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3418     { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format", "format" },
3419     { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3420     { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3421     { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3422     { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3423     { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3424     { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3425     { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3426     { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3427     { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3428     { "g", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_gop_size}, "set the group of picture size", "gop_size" },
3429     { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3430     { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3431     { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantiser scale (VBR)", "q" },
3432     { "qmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmin}, "min video quantiser scale (VBR)", "q" },
3433     { "qmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmax}, "max video quantiser scale (VBR)", "q" },
3434     { "mbqmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_qmin}, "min macroblock quantiser scale (VBR)", "q" },
3435     { "mbqmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_qmax}, "max macroblock quantiser scale (VBR)", "q" },
3436     { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantiser scale (VBR)", "q" },
3437     { "qblur", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qblur}, "video quantiser scale blur (VBR)", "blur" },
3438     { "qcomp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qcomp}, "video quantiser scale compression (VBR)", "compression" },
3439     { "rc_init_cplx", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_rc_initial_cplx}, "initial complexity for 1-pass encoding", "complexity" },
3440     { "b_qfactor", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_qfactor}, "qp factor between p and b frames", "factor" },
3441     { "i_qfactor", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_i_qfactor}, "qp factor between p and i frames", "factor" },
3442     { "b_qoffset", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_qoffset}, "qp offset between p and b frames", "offset" },
3443     { "i_qoffset", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_i_qoffset}, "qp offset between p and i frames", "offset" },
3444     { "ibias", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_ibias}, "intra quant bias", "bias" },
3445     { "pbias", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pbias}, "inter quant bias", "bias" },
3446 //    { "b_strategy", HAS_ARG | OPT_EXPERT, {(void*)opt_b_strategy}, "dynamic b frame selection strategy", "strategy" },
3447     { "rc_eq", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_eq}, "set rate control equation", "equation" },
3448     { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3449     { "bt", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_tolerance}, "set video bitrate tolerance (in kbit/s)", "tolerance" },
3450     { "maxrate", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_max}, "set max video bitrate tolerance (in kbit/s)", "bitrate" },
3451     { "minrate", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_min}, "set min video bitrate tolerance (in kbit/s)", "bitrate" },
3452     { "bufsize", HAS_ARG | OPT_VIDEO, {(void*)opt_video_buffer_size}, "set ratecontrol buffere size (in kByte)", "size" },
3453     { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3454     { "me", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_motion_estimation}, "set motion estimation method",
3455       "method" },
3456     { "dct_algo", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_dct_algo}, "set dct algo",  "algo" },
3457     { "idct_algo", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_idct_algo}, "set idct algo",  "algo" },
3458     { "er", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_error_resilience}, "set error resilience",  "n" },
3459     { "ec", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_error_concealment}, "set error concealment",  "bit_mask" },
3460     { "bf", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_frames}, "use 'frames' B frames", "frames" },
3461     { "hq", OPT_BOOL, {(void*)&mb_decision}, "activate high quality settings" },
3462     { "mbd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_decision}, "macroblock decision", "mode" },
3463     { "mbcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_cmp}, "macroblock compare function", "cmp function" },
3464     { "ildctcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_ildct_cmp}, "ildct compare function", "cmp function" },
3465     { "subcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_sub_cmp}, "subpel compare function", "cmp function" },
3466     { "cmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_cmp}, "fullpel compare function", "cmp function" },
3467     { "precmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pre_cmp}, "pre motion estimation compare function", "cmp function" },
3468     { "preme", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pre_me}, "pre motion estimation", "" },
3469     { "lumi_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lumi_mask}, "luminance masking", "" },
3470     { "dark_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_dark_mask}, "darkness masking", "" },
3471     { "scplx_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_scplx_mask}, "spatial complexity masking", "" },
3472     { "tcplx_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_tcplx_mask}, "teporal complexity masking", "" },
3473     { "p_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_p_mask}, "inter masking", "" },
3474     { "4mv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_4mv}, "use four motion vector by macroblock (MPEG4)" },
3475     { "obmc", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_obmc}, "use overlapped block motion compensation (h263+)" },
3476     { "lf", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_loop}, "use loop filter (h263+)" },
3477     { "part", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_part}, "use data partitioning (MPEG4)" },
3478     { "bug", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_workaround_bugs}, "workaround not auto detected encoder bugs", "param" },
3479     { "ps", HAS_ARG | OPT_EXPERT, {(void*)opt_packet_size}, "set packet size in bits", "size" },
3480     { "error", HAS_ARG | OPT_EXPERT, {(void*)opt_error_rate}, "error rate", "rate" },
3481     { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
3482     { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3483       "use same video quality as source (implies VBR)" },
3484     { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3485     { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3486     { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3487       "deinterlace pictures" },
3488     { "ildct", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_interlace_dct},
3489       "force interlaced dct support in encoder (MPEG2/MPEG4)" },
3490     { "ilme", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_interlace_me},
3491       "force interlaced me support in encoder (MPEG2/MPEG4)" },
3492     { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3493     { "vstats", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_vstats}, "dump video coding statistics to file" },
3494     { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3495     { "aic", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_aic}, "enable Advanced intra coding (h263+)" },
3496     { "aiv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_aiv}, "enable Alternative inter vlc (h263+)" },
3497     { "umv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_umv}, "enable Unlimited Motion Vector (h263+)" },
3498     { "ssm", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_ss}, "enable Slice Structured mode (h263+)" },
3499     { "alt", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_alt_scan}, "enable alternate scantable (MPEG2/MPEG4)" },
3500     { "trell", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_trell}, "enable trellis quantization" },
3501     { "cgop", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&closed_gop}, "closed gop" },
3502     { "scan_offset", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_scan_offset}, "enable SVCD Scan Offset placeholder" },
3503     { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3504     { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3505     { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3506     { "nr", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_noise_reduction}, "noise reduction", "" },
3507     { "qns", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qns}, "quantization noise shaping", "" },
3508     { "sc_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_sc_threshold}, "scene change threshold", "threshold" },
3509
3510     /* audio options */
3511     { "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_bitrate}, "set audio bitrate (in kbit/s)", "bitrate", },
3512     { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3513     { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3514     { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3515     { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3516
3517     /* grab options */
3518     { "vd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_device}, "set video grab device", "device" },
3519     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3520     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3521     { "dv1394", OPT_EXPERT | OPT_GRAB, {(void*)opt_dv1394}, "set DV1394 grab", "" },
3522     { "ad", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_GRAB, {(void*)opt_audio_device}, "set audio device", "device" },
3523     { NULL, },
3524 };
3525
3526 static void show_banner(void)
3527 {
3528     printf("ffmpeg version " FFMPEG_VERSION ", Copyright (c) 2000-2003 Fabrice Bellard\n");
3529 }
3530
3531 static void show_license(void)
3532 {
3533     show_banner();
3534 #ifdef CONFIG_GPL
3535     printf(
3536     "This program is free software; you can redistribute it and/or modify\n"
3537     "it under the terms of the GNU General Public License as published by\n"
3538     "the Free Software Foundation; either version 2 of the License, or\n"
3539     "(at your option) any later version.\n"
3540     "\n"
3541     "This program is distributed in the hope that it will be useful,\n"
3542     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3543     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
3544     "GNU General Public License for more details.\n"
3545     "\n"
3546     "You should have received a copy of the GNU General Public License\n"
3547     "along with this program; if not, write to the Free Software\n"
3548     "Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA\n"
3549     );
3550 #else
3551     printf(
3552     "This library is free software; you can redistribute it and/or\n"
3553     "modify it under the terms of the GNU Lesser General Public\n"
3554     "License as published by the Free Software Foundation; either\n"
3555     "version 2 of the License, or (at your option) any later version.\n"
3556     "\n"
3557     "This library is distributed in the hope that it will be useful,\n"
3558     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3559     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n"
3560     "Lesser General Public License for more details.\n"
3561     "\n"
3562     "You should have received a copy of the GNU Lesser General Public\n"
3563     "License along with this library; if not, write to the Free Software\n"
3564     "Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA\n"
3565     );
3566 #endif
3567     exit(1);
3568 }
3569
3570 static void show_help(void)
3571 {
3572     show_banner();
3573     printf("usage: ffmpeg [[options] -i input_file]... {[options] outfile}...\n"
3574            "Hyper fast Audio and Video encoder\n");
3575     printf("\n");
3576     show_help_options(options, "Main options:\n",
3577                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
3578     show_help_options(options, "\nVideo options:\n",
3579                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3580                       OPT_VIDEO);
3581     show_help_options(options, "\nAdvanced Video options:\n",
3582                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3583                       OPT_VIDEO | OPT_EXPERT);
3584     show_help_options(options, "\nAudio options:\n",
3585                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3586                       OPT_AUDIO);
3587     show_help_options(options, "\nAdvanced Audio options:\n",
3588                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3589                       OPT_AUDIO | OPT_EXPERT);
3590     show_help_options(options, "\nAudio/Video grab options:\n",
3591                       OPT_GRAB,
3592                       OPT_GRAB);
3593     show_help_options(options, "\nAdvanced options:\n",
3594                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3595                       OPT_EXPERT);
3596     exit(1);
3597 }
3598
3599 void parse_arg_file(const char *filename)
3600 {
3601     opt_output_file(filename);
3602 }
3603
3604 int main(int argc, char **argv)
3605 {
3606     int i;
3607     int64_t ti;
3608
3609     av_register_all();
3610
3611     if (argc <= 1)
3612         show_help();
3613
3614     /* parse options */
3615     parse_options(argc, argv, options);
3616
3617     /* file converter / grab */
3618     if (nb_output_files <= 0) {
3619         fprintf(stderr, "Must supply at least one output file\n");
3620         exit(1);
3621     }
3622
3623     if (nb_input_files == 0) {
3624         prepare_grab();
3625     }
3626
3627     ti = getutime();
3628     av_encode(output_files, nb_output_files, input_files, nb_input_files,
3629               stream_maps, nb_stream_maps);
3630     ti = getutime() - ti;
3631     if (do_benchmark) {
3632         printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3633     }
3634
3635     /* close files */
3636     for(i=0;i<nb_output_files;i++) {
3637         /* maybe av_close_output_file ??? */
3638         AVFormatContext *s = output_files[i];
3639         int j;
3640         if (!(s->oformat->flags & AVFMT_NOFILE))
3641             url_fclose(&s->pb);
3642         for(j=0;j<s->nb_streams;j++)
3643             av_free(s->streams[j]);
3644         av_free(s);
3645     }
3646     for(i=0;i<nb_input_files;i++)
3647         av_close_input_file(input_files[i]);
3648
3649     av_free_static();
3650
3651     if(intra_matrix)
3652         av_free(intra_matrix);
3653     if(inter_matrix)
3654         av_free(inter_matrix);
3655
3656 #ifdef POWERPC_PERFORMANCE_REPORT
3657     extern void powerpc_display_perf_report(void);
3658     powerpc_display_perf_report();
3659 #endif /* POWERPC_PERFORMANCE_REPORT */
3660
3661 #ifndef CONFIG_WIN32
3662     if (received_sigterm) {
3663         fprintf(stderr,
3664             "Received signal %d: terminating.\n",
3665             (int) received_sigterm);
3666         exit (255);
3667     }
3668 #endif
3669     exit(0); /* not all OS-es handle main() return value */
3670     return 0;
3671 }