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

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