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