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_buf))
 372         return -1;
 373     *picref = pic;
 374     ctx->inputs[0]->cur_buf = 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->video->interlaced;
 381     pic2->top_field_first  = pic->video->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 (avfilter_open(&ist->input_video_filter, avfilter_get_by_name("buffer"), "src") < 0)
 414         return -1;
 415     if (avfilter_open(&ist->out_video_filter, &output_filter, "out") < 0)
 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         avfilter_open(&filter, 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         avfilter_open(&filter, 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                             if (ist->picref->video)
1705                                 ost->st->codec->sample_aspect_ratio = ist->picref->video->pixel_aspect;
1706 #endif
1707                             do_video_out(os, ost, ist, &picture, &frame_size);
1708                             if (vstats_filename && frame_size)
1709                                 do_video_stats(os, ost, frame_size);
1710                             break;
1711                         case AVMEDIA_TYPE_SUBTITLE:
1712                             do_subtitle_out(os, ost, ist, &subtitle,
1713                                             pkt->pts);
1714                             break;
1715                         default:
1716                             abort();
1717                         }
1718                     } else {
1719                         AVFrame avframe; //FIXME/XXX remove this
1720                         AVPacket opkt;
1721                         int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1722
1723                         av_init_packet(&opkt);
1724
1725                         if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1726                             continue;
1727
1728                         /* no reencoding needed : output the packet directly */
1729                         /* force the input stream PTS */
1730
1731                         avcodec_get_frame_defaults(&avframe);
1732                         ost->st->codec->coded_frame= &avframe;
1733                         avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1734
1735                         if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1736                             audio_size += data_size;
1737                         else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1738                             video_size += data_size;
1739                             ost->sync_opts++;
1740                         }
1741
1742                         opkt.stream_index= ost->index;
1743                         if(pkt->pts != AV_NOPTS_VALUE)
1744                             opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1745                         else
1746                             opkt.pts= AV_NOPTS_VALUE;
1747
1748                         if (pkt->dts == AV_NOPTS_VALUE)
1749                             opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1750                         else
1751                             opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1752                         opkt.dts -= ost_tb_start_time;
1753
1754                         opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1755                         opkt.flags= pkt->flags;
1756
1757                         //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1758                         if(   ost->st->codec->codec_id != CODEC_ID_H264
1759                            && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1760                            && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1761                            ) {
1762                             if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1763                                 opkt.destruct= av_destruct_packet;
1764                         } else {
1765                             opkt.data = data_buf;
1766                             opkt.size = data_size;
1767                         }
1768
1769                         write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][opkt.stream_index]);
1770                         ost->st->codec->frame_number++;
1771                         ost->frame_number++;
1772                         av_free_packet(&opkt);
1773                     }
1774                 }
1775             }
1776
1777 #if CONFIG_AVFILTER
1778             frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1779                               ist->out_video_filter && avfilter_poll_frame(ist->out_video_filter->inputs[0]);
1780             if(ist->picref)
1781                 avfilter_unref_buffer(ist->picref);
1782         }
1783 #endif
1784         av_free(buffer_to_free);
1785         /* XXX: allocate the subtitles in the codec ? */
1786         if (subtitle_to_free) {
1787             if (subtitle_to_free->rects != NULL) {
1788                 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1789                     av_freep(&subtitle_to_free->rects[i]->pict.data[0]);
1790                     av_freep(&subtitle_to_free->rects[i]->pict.data[1]);
1791                     av_freep(&subtitle_to_free->rects[i]);
1792                 }
1793                 av_freep(&subtitle_to_free->rects);
1794             }
1795             subtitle_to_free->num_rects = 0;
1796             subtitle_to_free = NULL;
1797         }
1798     }
1799  discard_packet:
1800     if (pkt == NULL) {
1801         /* EOF handling */
1802
1803         for(i=0;i<nb_ostreams;i++) {
1804             ost = ost_table[i];
1805             if (ost->source_index == ist_index) {
1806                 AVCodecContext *enc= ost->st->codec;
1807                 os = output_files[ost->file_index];
1808
1809                 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1810                     continue;
1811                 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1812                     continue;
1813
1814                 if (ost->encoding_needed) {
1815                     for(;;) {
1816                         AVPacket pkt;
1817                         int fifo_bytes;
1818                         av_init_packet(&pkt);
1819                         pkt.stream_index= ost->index;
1820
1821                         switch(ost->st->codec->codec_type) {
1822                         case AVMEDIA_TYPE_AUDIO:
1823                             fifo_bytes = av_fifo_size(ost->fifo);
1824                             ret = 0;
1825                             /* encode any samples remaining in fifo */
1826                             if (fifo_bytes > 0) {
1827                                 int osize = av_get_bits_per_sample_format(enc->sample_fmt) >> 3;
1828                                 int fs_tmp = enc->frame_size;
1829
1830                                 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1831                                 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1832                                     enc->frame_size = fifo_bytes / (osize * enc->channels);
1833                                 } else { /* pad */
1834                                     int frame_bytes = enc->frame_size*osize*enc->channels;
1835                                     if (allocated_audio_buf_size < frame_bytes)
1836                                         ffmpeg_exit(1);
1837                                     memset(audio_buf+fifo_bytes, 0, frame_bytes - fifo_bytes);
1838                                 }
1839
1840                                 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1841                                 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1842                                                           ost->st->time_base.num, enc->sample_rate);
1843                                 enc->frame_size = fs_tmp;
1844                             }
1845                             if(ret <= 0) {
1846                                 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1847                             }
1848                             if (ret < 0) {
1849                                 fprintf(stderr, "Audio encoding failed\n");
1850                                 ffmpeg_exit(1);
1851                             }
1852                             audio_size += ret;
1853                             pkt.flags |= AV_PKT_FLAG_KEY;
1854                             break;
1855                         case AVMEDIA_TYPE_VIDEO:
1856                             ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1857                             if (ret < 0) {
1858                                 fprintf(stderr, "Video encoding failed\n");
1859                                 ffmpeg_exit(1);
1860                             }
1861                             video_size += ret;
1862                             if(enc->coded_frame && enc->coded_frame->key_frame)
1863                                 pkt.flags |= AV_PKT_FLAG_KEY;
1864                             if (ost->logfile && enc->stats_out) {
1865                                 fprintf(ost->logfile, "%s", enc->stats_out);
1866                             }
1867                             break;
1868                         default:
1869                             ret=-1;
1870                         }
1871
1872                         if(ret<=0)
1873                             break;
1874                         pkt.data= bit_buffer;
1875                         pkt.size= ret;
1876                         if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1877                             pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1878                         write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1879                     }
1880                 }
1881             }
1882         }
1883     }
1884
1885     return 0;
1886  fail_decode:
1887     return -1;
1888 }
1889
1890 static void print_sdp(AVFormatContext **avc, int n)
1891 {
1892     char sdp[2048];
1893
1894     avf_sdp_create(avc, n, sdp, sizeof(sdp));
1895     printf("SDP:\n%s\n", sdp);
1896     fflush(stdout);
1897 }
1898
1899 static int copy_chapters(int infile, int outfile)
1900 {
1901     AVFormatContext *is = input_files[infile];
1902     AVFormatContext *os = output_files[outfile];
1903     int i;
1904
1905     for (i = 0; i < is->nb_chapters; i++) {
1906         AVChapter *in_ch = is->chapters[i], *out_ch;
1907         AVMetadataTag *t = NULL;
1908         int64_t ts_off   = av_rescale_q(start_time - input_files_ts_offset[infile],
1909                                       AV_TIME_BASE_Q, in_ch->time_base);
1910         int64_t rt       = (recording_time == INT64_MAX) ? INT64_MAX :
1911                            av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1912
1913
1914         if (in_ch->end < ts_off)
1915             continue;
1916         if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1917             break;
1918
1919         out_ch = av_mallocz(sizeof(AVChapter));
1920         if (!out_ch)
1921             return AVERROR(ENOMEM);
1922
1923         out_ch->id        = in_ch->id;
1924         out_ch->time_base = in_ch->time_base;
1925         out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1926         out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1927
1928         while ((t = av_metadata_get(in_ch->metadata, "", t, AV_METADATA_IGNORE_SUFFIX)))
1929             av_metadata_set2(&out_ch->metadata, t->key, t->value, 0);
1930
1931         os->nb_chapters++;
1932         os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1933         if (!os->chapters)
1934             return AVERROR(ENOMEM);
1935         os->chapters[os->nb_chapters - 1] = out_ch;
1936     }
1937     return 0;
1938 }
1939
1940 /*
1941  * The following code is the main loop of the file converter
1942  */
1943 static int transcode(AVFormatContext **output_files,
1944                      int nb_output_files,
1945                      AVFormatContext **input_files,
1946                      int nb_input_files,
1947                      AVStreamMap *stream_maps, int nb_stream_maps)
1948 {
1949     int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1950     AVFormatContext *is, *os;
1951     AVCodecContext *codec, *icodec;
1952     AVOutputStream *ost, **ost_table = NULL;
1953     AVInputStream *ist, **ist_table = NULL;
1954     AVInputFile *file_table;
1955     char error[1024];
1956     int key;
1957     int want_sdp = 1;
1958     uint8_t no_packet[MAX_FILES]={0};
1959     int no_packet_count=0;
1960
1961     file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1962     if (!file_table)
1963         goto fail;
1964
1965     /* input stream init */
1966     j = 0;
1967     for(i=0;i<nb_input_files;i++) {
1968         is = input_files[i];
1969         file_table[i].ist_index = j;
1970         file_table[i].nb_streams = is->nb_streams;
1971         j += is->nb_streams;
1972     }
1973     nb_istreams = j;
1974
1975     ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1976     if (!ist_table)
1977         goto fail;
1978
1979     for(i=0;i<nb_istreams;i++) {
1980         ist = av_mallocz(sizeof(AVInputStream));
1981         if (!ist)
1982             goto fail;
1983         ist_table[i] = ist;
1984     }
1985     j = 0;
1986     for(i=0;i<nb_input_files;i++) {
1987         is = input_files[i];
1988         for(k=0;k<is->nb_streams;k++) {
1989             ist = ist_table[j++];
1990             ist->st = is->streams[k];
1991             ist->file_index = i;
1992             ist->index = k;
1993             ist->discard = 1; /* the stream is discarded by default
1994                                  (changed later) */
1995
1996             if (rate_emu) {
1997                 ist->start = av_gettime();
1998             }
1999         }
2000     }
2001
2002     /* output stream init */
2003     nb_ostreams = 0;
2004     for(i=0;i<nb_output_files;i++) {
2005         os = output_files[i];
2006         if (!os->nb_streams) {
2007             dump_format(output_files[i], i, output_files[i]->filename, 1);
2008             fprintf(stderr, "Output file #%d does not contain any stream\n", i);
2009             ret = AVERROR(EINVAL);
2010             goto fail;
2011         }
2012         nb_ostreams += os->nb_streams;
2013     }
2014     if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
2015         fprintf(stderr, "Number of stream maps must match number of output streams\n");
2016         ret = AVERROR(EINVAL);
2017         goto fail;
2018     }
2019
2020     /* Sanity check the mapping args -- do the input files & streams exist? */
2021     for(i=0;i<nb_stream_maps;i++) {
2022         int fi = stream_maps[i].file_index;
2023         int si = stream_maps[i].stream_index;
2024
2025         if (fi < 0 || fi > nb_input_files - 1 ||
2026             si < 0 || si > file_table[fi].nb_streams - 1) {
2027             fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
2028             ret = AVERROR(EINVAL);
2029             goto fail;
2030         }
2031         fi = stream_maps[i].sync_file_index;
2032         si = stream_maps[i].sync_stream_index;
2033         if (fi < 0 || fi > nb_input_files - 1 ||
2034             si < 0 || si > file_table[fi].nb_streams - 1) {
2035             fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
2036             ret = AVERROR(EINVAL);
2037             goto fail;
2038         }
2039     }
2040
2041     ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
2042     if (!ost_table)
2043         goto fail;
2044     for(i=0;i<nb_ostreams;i++) {
2045         ost = av_mallocz(sizeof(AVOutputStream));
2046         if (!ost)
2047             goto fail;
2048         ost_table[i] = ost;
2049     }
2050
2051     n = 0;
2052     for(k=0;k<nb_output_files;k++) {
2053         os = output_files[k];
2054         for(i=0;i<os->nb_streams;i++,n++) {
2055             int found;
2056             ost = ost_table[n];
2057             ost->file_index = k;
2058             ost->index = i;
2059             ost->st = os->streams[i];
2060             if (nb_stream_maps > 0) {
2061                 ost->source_index = file_table[stream_maps[n].file_index].ist_index +
2062                     stream_maps[n].stream_index;
2063
2064                 /* Sanity check that the stream types match */
2065                 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
2066                     int i= ost->file_index;
2067                     dump_format(output_files[i], i, output_files[i]->filename, 1);
2068                     fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
2069                         stream_maps[n].file_index, stream_maps[n].stream_index,
2070                         ost->file_index, ost->index);
2071                     ffmpeg_exit(1);
2072                 }
2073
2074             } else {
2075                 int best_nb_frames=-1;
2076                     /* get corresponding input stream index : we select the first one with the right type */
2077                     found = 0;
2078                     for(j=0;j<nb_istreams;j++) {
2079                         int skip=0;
2080                         ist = ist_table[j];
2081                         if(opt_programid){
2082                             int pi,si;
2083                             AVFormatContext *f= input_files[ ist->file_index ];
2084                             skip=1;
2085                             for(pi=0; pi<f->nb_programs; pi++){
2086                                 AVProgram *p= f->programs[pi];
2087                                 if(p->id == opt_programid)
2088                                     for(si=0; si<p->nb_stream_indexes; si++){
2089                                         if(f->streams[ p->stream_index[si] ] == ist->st)
2090                                             skip=0;
2091                                     }
2092                             }
2093                         }
2094                         if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
2095                             ist->st->codec->codec_type == ost->st->codec->codec_type) {
2096                             if(best_nb_frames < ist->st->codec_info_nb_frames){
2097                                 best_nb_frames= ist->st->codec_info_nb_frames;
2098                                 ost->source_index = j;
2099                                 found = 1;
2100                             }
2101                         }
2102                     }
2103
2104                 if (!found) {
2105                     if(! opt_programid) {
2106                         /* try again and reuse existing stream */
2107                         for(j=0;j<nb_istreams;j++) {
2108                             ist = ist_table[j];
2109                             if (   ist->st->codec->codec_type == ost->st->codec->codec_type
2110                                 && ist->st->discard != AVDISCARD_ALL) {
2111                                 ost->source_index = j;
2112                                 found = 1;
2113                             }
2114                         }
2115                     }
2116                     if (!found) {
2117                         int i= ost->file_index;
2118                         dump_format(output_files[i], i, output_files[i]->filename, 1);
2119                         fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
2120                                 ost->file_index, ost->index);
2121                         ffmpeg_exit(1);
2122                     }
2123                 }
2124             }
2125             ist = ist_table[ost->source_index];
2126             ist->discard = 0;
2127             ost->sync_ist = (nb_stream_maps > 0) ?
2128                 ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
2129                          stream_maps[n].sync_stream_index] : ist;
2130         }
2131     }
2132
2133     /* for each output stream, we compute the right encoding parameters */
2134     for(i=0;i<nb_ostreams;i++) {
2135         AVMetadataTag *t = NULL;
2136         ost = ost_table[i];
2137         os = output_files[ost->file_index];
2138         ist = ist_table[ost->source_index];
2139
2140         codec = ost->st->codec;
2141         icodec = ist->st->codec;
2142
2143         while ((t = av_metadata_get(ist->st->metadata, "", t, AV_METADATA_IGNORE_SUFFIX))) {
2144             av_metadata_set2(&ost->st->metadata, t->key, t->value, AV_METADATA_DONT_OVERWRITE);
2145         }
2146
2147         ost->st->disposition = ist->st->disposition;
2148         codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2149         codec->chroma_sample_location = icodec->chroma_sample_location;
2150
2151         if (ost->st->stream_copy) {
2152             uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2153
2154             if (extra_size > INT_MAX)
2155                 goto fail;
2156
2157             /* if stream_copy is selected, no need to decode or encode */
2158             codec->codec_id = icodec->codec_id;
2159             codec->codec_type = icodec->codec_type;
2160
2161             if(!codec->codec_tag){
2162                 if(   !os->oformat->codec_tag
2163                    || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2164                    || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2165                     codec->codec_tag = icodec->codec_tag;
2166             }
2167
2168             codec->bit_rate = icodec->bit_rate;
2169             codec->extradata= av_mallocz(extra_size);
2170             if (!codec->extradata)
2171                 goto fail;
2172             memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2173             codec->extradata_size= icodec->extradata_size;
2174             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){
2175                 codec->time_base = icodec->time_base;
2176                 codec->time_base.num *= icodec->ticks_per_frame;
2177                 av_reduce(&codec->time_base.num, &codec->time_base.den,
2178                           codec->time_base.num, codec->time_base.den, INT_MAX);
2179             }else
2180                 codec->time_base = ist->st->time_base;
2181             switch(codec->codec_type) {
2182             case AVMEDIA_TYPE_AUDIO:
2183                 if(audio_volume != 256) {
2184                     fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2185                     ffmpeg_exit(1);
2186                 }
2187                 codec->channel_layout = icodec->channel_layout;
2188                 codec->sample_rate = icodec->sample_rate;
2189                 codec->channels = icodec->channels;
2190                 codec->frame_size = icodec->frame_size;
2191                 codec->block_align= icodec->block_align;
2192                 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2193                     codec->block_align= 0;
2194                 if(codec->codec_id == CODEC_ID_AC3)
2195                     codec->block_align= 0;
2196                 break;
2197             case AVMEDIA_TYPE_VIDEO:
2198                 codec->pix_fmt = icodec->pix_fmt;
2199                 codec->width = icodec->width;
2200                 codec->height = icodec->height;
2201                 codec->has_b_frames = icodec->has_b_frames;
2202                 break;
2203             case AVMEDIA_TYPE_SUBTITLE:
2204                 codec->width = icodec->width;
2205                 codec->height = icodec->height;
2206                 break;
2207             default:
2208                 abort();
2209             }
2210         } else {
2211             switch(codec->codec_type) {
2212             case AVMEDIA_TYPE_AUDIO:
2213                 ost->fifo= av_fifo_alloc(1024);
2214                 if(!ost->fifo)
2215                     goto fail;
2216                 ost->reformat_pair = MAKE_SFMT_PAIR(SAMPLE_FMT_NONE,SAMPLE_FMT_NONE);
2217                 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2218                 icodec->request_channels = codec->channels;
2219                 ist->decoding_needed = 1;
2220                 ost->encoding_needed = 1;
2221                 break;
2222             case AVMEDIA_TYPE_VIDEO:
2223                 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2224                     fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2225                     ffmpeg_exit(1);
2226                 }
2227                 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
2228                 ost->video_resample = ((codec->width != icodec->width -
2229                                 (frame_leftBand + frame_rightBand)) ||
2230                         (codec->height != icodec->height -
2231                                 (frame_topBand  + frame_bottomBand)) ||
2232                         (codec->pix_fmt != icodec->pix_fmt));
2233                 if (ost->video_crop) {
2234                     ost->topBand    = ost->original_topBand    = frame_topBand;
2235                     ost->bottomBand = ost->original_bottomBand = frame_bottomBand;
2236                     ost->leftBand   = ost->original_leftBand   = frame_leftBand;
2237                     ost->rightBand  = ost->original_rightBand  = frame_rightBand;
2238                 }
2239                 if (ost->video_resample) {
2240                     avcodec_get_frame_defaults(&ost->pict_tmp);
2241                     if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2242                                          codec->width, codec->height)) {
2243                         fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
2244                         ffmpeg_exit(1);
2245                     }
2246                     sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
2247                     ost->img_resample_ctx = sws_getContext(
2248                             icodec->width - (frame_leftBand + frame_rightBand),
2249                             icodec->height - (frame_topBand + frame_bottomBand),
2250                             icodec->pix_fmt,
2251                             codec->width,
2252                             codec->height,
2253                             codec->pix_fmt,
2254                             sws_flags, NULL, NULL, NULL);
2255                     if (ost->img_resample_ctx == NULL) {
2256                         fprintf(stderr, "Cannot get resampling context\n");
2257                         ffmpeg_exit(1);
2258                     }
2259
2260 #if !CONFIG_AVFILTER
2261                     ost->original_height = icodec->height;
2262                     ost->original_width  = icodec->width;
2263 #endif
2264                     codec->bits_per_raw_sample= 0;
2265                 }
2266                 ost->resample_height = icodec->height - (frame_topBand  + frame_bottomBand);
2267                 ost->resample_width  = icodec->width  - (frame_leftBand + frame_rightBand);
2268                 ost->resample_pix_fmt= icodec->pix_fmt;
2269                 ost->encoding_needed = 1;
2270                 ist->decoding_needed = 1;
2271
2272 #if CONFIG_AVFILTER
2273                 if (configure_filters(ist, ost)) {
2274                     fprintf(stderr, "Error opening filters!\n");
2275                     exit(1);
2276                 }
2277 #endif
2278                 break;
2279             case AVMEDIA_TYPE_SUBTITLE:
2280                 ost->encoding_needed = 1;
2281                 ist->decoding_needed = 1;
2282                 break;
2283             default:
2284                 abort();
2285                 break;
2286             }
2287             /* two pass mode */
2288             if (ost->encoding_needed &&
2289                 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2290                 char logfilename[1024];
2291                 FILE *f;
2292
2293                 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2294                          pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2295                          i);
2296                 if (codec->flags & CODEC_FLAG_PASS1) {
2297                     f = fopen(logfilename, "wb");
2298                     if (!f) {
2299                         fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2300                         ffmpeg_exit(1);
2301                     }
2302                     ost->logfile = f;
2303                 } else {
2304                     char  *logbuffer;
2305                     size_t logbuffer_size;
2306                     if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2307                         fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2308                         ffmpeg_exit(1);
2309                     }
2310                     codec->stats_in = logbuffer;
2311                 }
2312             }
2313         }
2314         if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2315             int size= codec->width * codec->height;
2316             bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2317         }
2318     }
2319
2320     if (!bit_buffer)
2321         bit_buffer = av_malloc(bit_buffer_size);
2322     if (!bit_buffer) {
2323         fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2324                 bit_buffer_size);
2325         ret = AVERROR(ENOMEM);
2326         goto fail;
2327     }
2328
2329     /* open each encoder */
2330     for(i=0;i<nb_ostreams;i++) {
2331         ost = ost_table[i];
2332         if (ost->encoding_needed) {
2333             AVCodec *codec = output_codecs[i];
2334             if (!codec)
2335                 codec = avcodec_find_encoder(ost->st->codec->codec_id);
2336             if (!codec) {
2337                 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2338                          ost->st->codec->codec_id, ost->file_index, ost->index);
2339                 ret = AVERROR(EINVAL);
2340                 goto dump_format;
2341             }
2342             if (avcodec_open(ost->st->codec, codec) < 0) {
2343                 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2344                         ost->file_index, ost->index);
2345                 ret = AVERROR(EINVAL);
2346                 goto dump_format;
2347             }
2348             extra_size += ost->st->codec->extradata_size;
2349         }
2350     }
2351
2352     /* open each decoder */
2353     for(i=0;i<nb_istreams;i++) {
2354         ist = ist_table[i];
2355         if (ist->decoding_needed) {
2356             AVCodec *codec = input_codecs[i];
2357             if (!codec)
2358                 codec = avcodec_find_decoder(ist->st->codec->codec_id);
2359             if (!codec) {
2360                 snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2361                         ist->st->codec->codec_id, ist->file_index, ist->index);
2362                 ret = AVERROR(EINVAL);
2363                 goto dump_format;
2364             }
2365             if (avcodec_open(ist->st->codec, codec) < 0) {
2366                 snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2367                         ist->file_index, ist->index);
2368                 ret = AVERROR(EINVAL);
2369                 goto dump_format;
2370             }
2371             //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2372             //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2373         }
2374     }
2375
2376     /* init pts */
2377     for(i=0;i<nb_istreams;i++) {
2378         AVStream *st;
2379         ist = ist_table[i];
2380         st= ist->st;
2381         ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2382         ist->next_pts = AV_NOPTS_VALUE;
2383         ist->is_start = 1;
2384     }
2385
2386     /* set meta data information from input file if required */
2387     for (i=0;i<nb_meta_data_maps;i++) {
2388         AVFormatContext *out_file;
2389         AVFormatContext *in_file;
2390         AVMetadataTag *mtag;
2391
2392         int out_file_index = meta_data_maps[i].out_file;
2393         int in_file_index = meta_data_maps[i].in_file;
2394         if (out_file_index < 0 || out_file_index >= nb_output_files) {
2395             snprintf(error, sizeof(error), "Invalid output file index %d map_meta_data(%d,%d)",
2396                      out_file_index, out_file_index, in_file_index);
2397             ret = AVERROR(EINVAL);
2398             goto dump_format;
2399         }
2400         if (in_file_index < 0 || in_file_index >= nb_input_files) {
2401             snprintf(error, sizeof(error), "Invalid input file index %d map_meta_data(%d,%d)",
2402                      in_file_index, out_file_index, in_file_index);
2403             ret = AVERROR(EINVAL);
2404             goto dump_format;
2405         }
2406
2407         out_file = output_files[out_file_index];
2408         in_file = input_files[in_file_index];
2409
2410
2411         mtag=NULL;
2412         while((mtag=av_metadata_get(in_file->metadata, "", mtag, AV_METADATA_IGNORE_SUFFIX)))
2413             av_metadata_set2(&out_file->metadata, mtag->key, mtag->value, AV_METADATA_DONT_OVERWRITE);
2414         av_metadata_conv(out_file, out_file->oformat->metadata_conv,
2415                                     in_file->iformat->metadata_conv);
2416     }
2417
2418     /* copy chapters from the first input file that has them*/
2419     for (i = 0; i < nb_input_files; i++) {
2420         if (!input_files[i]->nb_chapters)
2421             continue;
2422
2423         for (j = 0; j < nb_output_files; j++)
2424             if ((ret = copy_chapters(i, j)) < 0)
2425                 goto dump_format;
2426     }
2427
2428     /* open files and write file headers */
2429     for(i=0;i<nb_output_files;i++) {
2430         os = output_files[i];
2431         if (av_write_header(os) < 0) {
2432             snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2433             ret = AVERROR(EINVAL);
2434             goto dump_format;
2435         }
2436         if (strcmp(output_files[i]->oformat->name, "rtp")) {
2437             want_sdp = 0;
2438         }
2439     }
2440
2441  dump_format:
2442     /* dump the file output parameters - cannot be done before in case
2443        of stream copy */
2444     for(i=0;i<nb_output_files;i++) {
2445         dump_format(output_files[i], i, output_files[i]->filename, 1);
2446     }
2447
2448     /* dump the stream mapping */
2449     if (verbose >= 0) {
2450         fprintf(stderr, "Stream mapping:\n");
2451         for(i=0;i<nb_ostreams;i++) {
2452             ost = ost_table[i];
2453             fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
2454                     ist_table[ost->source_index]->file_index,
2455                     ist_table[ost->source_index]->index,
2456                     ost->file_index,
2457                     ost->index);
2458             if (ost->sync_ist != ist_table[ost->source_index])
2459                 fprintf(stderr, " [sync #%d.%d]",
2460                         ost->sync_ist->file_index,
2461                         ost->sync_ist->index);
2462             fprintf(stderr, "\n");
2463         }
2464     }
2465
2466     if (ret) {
2467         fprintf(stderr, "%s\n", error);
2468         goto fail;
2469     }
2470
2471     if (want_sdp) {
2472         print_sdp(output_files, nb_output_files);
2473     }
2474
2475     if (!using_stdin && verbose >= 0) {
2476         fprintf(stderr, "Press [q] to stop encoding\n");
2477         url_set_interrupt_cb(decode_interrupt_cb);
2478     }
2479     term_init();
2480
2481     timer_start = av_gettime();
2482
2483     for(; received_sigterm == 0;) {
2484         int file_index, ist_index;
2485         AVPacket pkt;
2486         double ipts_min;
2487         double opts_min;
2488
2489     redo:
2490         ipts_min= 1e100;
2491         opts_min= 1e100;
2492         /* if 'q' pressed, exits */
2493         if (!using_stdin) {
2494             if (q_pressed)
2495                 break;
2496             /* read_key() returns 0 on EOF */
2497             key = read_key();
2498             if (key == 'q')
2499                 break;
2500         }
2501
2502         /* select the stream that we must read now by looking at the
2503            smallest output pts */
2504         file_index = -1;
2505         for(i=0;i<nb_ostreams;i++) {
2506             double ipts, opts;
2507             ost = ost_table[i];
2508             os = output_files[ost->file_index];
2509             ist = ist_table[ost->source_index];
2510             if(ist->is_past_recording_time || no_packet[ist->file_index])
2511                 continue;
2512                 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2513             ipts = (double)ist->pts;
2514             if (!file_table[ist->file_index].eof_reached){
2515                 if(ipts < ipts_min) {
2516                     ipts_min = ipts;
2517                     if(input_sync ) file_index = ist->file_index;
2518                 }
2519                 if(opts < opts_min) {
2520                     opts_min = opts;
2521                     if(!input_sync) file_index = ist->file_index;
2522                 }
2523             }
2524             if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2525                 file_index= -1;
2526                 break;
2527             }
2528         }
2529         /* if none, if is finished */
2530         if (file_index < 0) {
2531             if(no_packet_count){
2532                 no_packet_count=0;
2533                 memset(no_packet, 0, sizeof(no_packet));
2534                 usleep(10000);
2535                 continue;
2536             }
2537             break;
2538         }
2539
2540         /* finish if limit size exhausted */
2541         if (limit_filesize != 0 && limit_filesize <= url_ftell(output_files[0]->pb))
2542             break;
2543
2544         /* read a frame from it and output it in the fifo */
2545         is = input_files[file_index];
2546         ret= av_read_frame(is, &pkt);
2547         if(ret == AVERROR(EAGAIN)){
2548             no_packet[file_index]=1;
2549             no_packet_count++;
2550             continue;
2551         }
2552         if (ret < 0) {
2553             file_table[file_index].eof_reached = 1;
2554             if (opt_shortest)
2555                 break;
2556             else
2557                 continue;
2558         }
2559
2560         no_packet_count=0;
2561         memset(no_packet, 0, sizeof(no_packet));
2562
2563         if (do_pkt_dump) {
2564             av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2565         }
2566         /* the following test is needed in case new streams appear
2567            dynamically in stream : we ignore them */
2568         if (pkt.stream_index >= file_table[file_index].nb_streams)
2569             goto discard_packet;
2570         ist_index = file_table[file_index].ist_index + pkt.stream_index;
2571         ist = ist_table[ist_index];
2572         if (ist->discard)
2573             goto discard_packet;
2574
2575         if (pkt.dts != AV_NOPTS_VALUE)
2576             pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2577         if (pkt.pts != AV_NOPTS_VALUE)
2578             pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2579
2580         if(input_files_ts_scale[file_index][pkt.stream_index]){
2581             if(pkt.pts != AV_NOPTS_VALUE)
2582                 pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2583             if(pkt.dts != AV_NOPTS_VALUE)
2584                 pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2585         }
2586
2587 //        fprintf(stderr, "next:%"PRId64" dts:%"PRId64" off:%"PRId64" %d\n", ist->next_pts, pkt.dts, input_files_ts_offset[ist->file_index], ist->st->codec->codec_type);
2588         if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2589             && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2590             int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2591             int64_t delta= pkt_dts - ist->next_pts;
2592             if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2593                 input_files_ts_offset[ist->file_index]-= delta;
2594                 if (verbose > 2)
2595                     fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2596                 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2597                 if(pkt.pts != AV_NOPTS_VALUE)
2598                     pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2599             }
2600         }
2601
2602         /* finish if recording time exhausted */
2603         if (recording_time != INT64_MAX &&
2604             av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2605             ist->is_past_recording_time = 1;
2606             goto discard_packet;
2607         }
2608
2609         //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
2610         if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2611
2612             if (verbose >= 0)
2613                 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2614                         ist->file_index, ist->index);
2615             if (exit_on_error)
2616                 ffmpeg_exit(1);
2617             av_free_packet(&pkt);
2618             goto redo;
2619         }
2620
2621     discard_packet:
2622         av_free_packet(&pkt);
2623
2624         /* dump report by using the output first video and audio streams */
2625         print_report(output_files, ost_table, nb_ostreams, 0);
2626     }
2627
2628     /* at the end of stream, we must flush the decoder buffers */
2629     for(i=0;i<nb_istreams;i++) {
2630         ist = ist_table[i];
2631         if (ist->decoding_needed) {
2632             output_packet(ist, i, ost_table, nb_ostreams, NULL);
2633         }
2634     }
2635
2636     term_exit();
2637
2638     /* write the trailer if needed and close file */
2639     for(i=0;i<nb_output_files;i++) {
2640         os = output_files[i];
2641         av_write_trailer(os);
2642     }
2643
2644     /* dump report by using the first video and audio streams */
2645     print_report(output_files, ost_table, nb_ostreams, 1);
2646
2647     /* close each encoder */
2648     for(i=0;i<nb_ostreams;i++) {
2649         ost = ost_table[i];
2650         if (ost->encoding_needed) {
2651             av_freep(&ost->st->codec->stats_in);
2652             avcodec_close(ost->st->codec);
2653         }
2654     }
2655
2656     /* close each decoder */
2657     for(i=0;i<nb_istreams;i++) {
2658         ist = ist_table[i];
2659         if (ist->decoding_needed) {
2660             avcodec_close(ist->st->codec);
2661         }
2662     }
2663 #if CONFIG_AVFILTER
2664     if (graph) {
2665         avfilter_graph_destroy(graph);
2666         av_freep(&graph);
2667     }
2668 #endif
2669
2670     /* finished ! */
2671     ret = 0;
2672
2673  fail:
2674     av_freep(&bit_buffer);
2675     av_free(file_table);
2676
2677     if (ist_table) {
2678         for(i=0;i<nb_istreams;i++) {
2679             ist = ist_table[i];
2680             av_free(ist);
2681         }
2682         av_free(ist_table);
2683     }
2684     if (ost_table) {
2685         for(i=0;i<nb_ostreams;i++) {
2686             ost = ost_table[i];
2687             if (ost) {
2688                 if (ost->st->stream_copy)
2689                     av_freep(&ost->st->codec->extradata);
2690                 if (ost->logfile) {
2691                     fclose(ost->logfile);
2692                     ost->logfile = NULL;
2693                 }
2694                 av_fifo_free(ost->fifo); /* works even if fifo is not
2695                                              initialized but set to zero */
2696                 av_free(ost->pict_tmp.data[0]);
2697                 if (ost->video_resample)
2698                     sws_freeContext(ost->img_resample_ctx);
2699                 if (ost->resample)
2700                     audio_resample_close(ost->resample);
2701                 if (ost->reformat_ctx)
2702                     av_audio_convert_free(ost->reformat_ctx);
2703                 av_free(ost);
2704             }
2705         }
2706         av_free(ost_table);
2707     }
2708     return ret;
2709 }
2710
2711 static void opt_format(const char *arg)
2712 {
2713     /* compatibility stuff for pgmyuv */
2714     if (!strcmp(arg, "pgmyuv")) {
2715         pgmyuv_compatibility_hack=1;
2716 //        opt_image_format(arg);
2717         arg = "image2";
2718         fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2719     }
2720
2721     last_asked_format = arg;
2722 }
2723
2724 static void opt_video_rc_override_string(const char *arg)
2725 {
2726     video_rc_override_string = arg;
2727 }
2728
2729 static int opt_me_threshold(const char *opt, const char *arg)
2730 {
2731     me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2732     return 0;
2733 }
2734
2735 static int opt_verbose(const char *opt, const char *arg)
2736 {
2737     verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2738     return 0;
2739 }
2740
2741 static int opt_frame_rate(const char *opt, const char *arg)
2742 {
2743     if (av_parse_video_rate(&frame_rate, arg) < 0) {
2744         fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2745         ffmpeg_exit(1);
2746     }
2747     return 0;
2748 }
2749
2750 static int opt_bitrate(const char *opt, const char *arg)
2751 {
2752     int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2753
2754     opt_default(opt, arg);
2755
2756     if (av_get_int(avcodec_opts[codec_type], "b", NULL) < 1000)
2757         fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2758
2759     return 0;
2760 }
2761
2762 static void opt_frame_crop_top(const char *arg)
2763 {
2764     frame_topBand = atoi(arg);
2765     if (frame_topBand < 0) {
2766         fprintf(stderr, "Incorrect top crop size\n");
2767         ffmpeg_exit(1);
2768     }
2769     if ((frame_topBand) >= frame_height){
2770         fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2771         ffmpeg_exit(1);
2772     }
2773     fprintf(stderr, "-crop* is deprecated in favor of the crop avfilter\n");
2774     frame_height -= frame_topBand;
2775 }
2776
2777 static void opt_frame_crop_bottom(const char *arg)
2778 {
2779     frame_bottomBand = atoi(arg);
2780     if (frame_bottomBand < 0) {
2781         fprintf(stderr, "Incorrect bottom crop size\n");
2782         ffmpeg_exit(1);
2783     }
2784     if ((frame_bottomBand) >= frame_height){
2785         fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2786         ffmpeg_exit(1);
2787     }
2788     fprintf(stderr, "-crop* is deprecated in favor of the crop avfilter\n");
2789     frame_height -= frame_bottomBand;
2790 }
2791
2792 static void opt_frame_crop_left(const char *arg)
2793 {
2794     frame_leftBand = atoi(arg);
2795     if (frame_leftBand < 0) {
2796         fprintf(stderr, "Incorrect left crop size\n");
2797         ffmpeg_exit(1);
2798     }
2799     if ((frame_leftBand) >= frame_width){
2800         fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2801         ffmpeg_exit(1);
2802     }
2803     fprintf(stderr, "-crop* is deprecated in favor of the crop avfilter\n");
2804     frame_width -= frame_leftBand;
2805 }
2806
2807 static void opt_frame_crop_right(const char *arg)
2808 {
2809     frame_rightBand = atoi(arg);
2810     if (frame_rightBand < 0) {
2811         fprintf(stderr, "Incorrect right crop size\n");
2812         ffmpeg_exit(1);
2813     }
2814     if ((frame_rightBand) >= frame_width){
2815         fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2816         ffmpeg_exit(1);
2817     }
2818     fprintf(stderr, "-crop* is deprecated in favor of the crop avfilter\n");
2819     frame_width -= frame_rightBand;
2820 }
2821
2822 static void opt_frame_size(const char *arg)
2823 {
2824     if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2825         fprintf(stderr, "Incorrect frame size\n");
2826         ffmpeg_exit(1);
2827     }
2828 }
2829
2830 static int opt_pad(const char *opt, const char *arg) {
2831     fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2832     return -1;
2833 }
2834
2835 static void opt_frame_pix_fmt(const char *arg)
2836 {
2837     if (strcmp(arg, "list")) {
2838         frame_pix_fmt = av_get_pix_fmt(arg);
2839         if (frame_pix_fmt == PIX_FMT_NONE) {
2840             fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2841             ffmpeg_exit(1);
2842         }
2843     } else {
2844         show_pix_fmts();
2845         ffmpeg_exit(0);
2846     }
2847 }
2848
2849 static void opt_frame_aspect_ratio(const char *arg)
2850 {
2851     int x = 0, y = 0;
2852     double ar = 0;
2853     const char *p;
2854     char *end;
2855
2856     p = strchr(arg, ':');
2857     if (p) {
2858         x = strtol(arg, &end, 10);
2859         if (end == p)
2860             y = strtol(end+1, &end, 10);
2861         if (x > 0 && y > 0)
2862             ar = (double)x / (double)y;
2863     } else
2864         ar = strtod(arg, NULL);
2865
2866     if (!ar) {
2867         fprintf(stderr, "Incorrect aspect ratio specification.\n");
2868         ffmpeg_exit(1);
2869     }
2870     frame_aspect_ratio = ar;
2871 }
2872
2873 static int opt_metadata(const char *opt, const char *arg)
2874 {
2875     char *mid= strchr(arg, '=');
2876
2877     if(!mid){
2878         fprintf(stderr, "Missing =\n");
2879         ffmpeg_exit(1);
2880     }
2881     *mid++= 0;
2882
2883     metadata_count++;
2884     metadata= av_realloc(metadata, sizeof(*metadata)*metadata_count);
2885     metadata[metadata_count-1].key  = av_strdup(arg);
2886     metadata[metadata_count-1].value= av_strdup(mid);
2887
2888     return 0;
2889 }
2890
2891 static void opt_qscale(const char *arg)
2892 {
2893     video_qscale = atof(arg);
2894     if (video_qscale <= 0 ||
2895         video_qscale > 255) {
2896         fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2897         ffmpeg_exit(1);
2898     }
2899 }
2900
2901 static void opt_top_field_first(const char *arg)
2902 {
2903     top_field_first= atoi(arg);
2904 }
2905
2906 static int opt_thread_count(const char *opt, const char *arg)
2907 {
2908     thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2909 #if !HAVE_THREADS
2910     if (verbose >= 0)
2911         fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2912 #endif
2913     return 0;
2914 }
2915
2916 static void opt_audio_sample_fmt(const char *arg)
2917 {
2918     if (strcmp(arg, "list"))
2919         audio_sample_fmt = avcodec_get_sample_fmt(arg);
2920     else {
2921         list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
2922         ffmpeg_exit(0);
2923     }
2924 }
2925
2926 static int opt_audio_rate(const char *opt, const char *arg)
2927 {
2928     audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2929     return 0;
2930 }
2931
2932 static int opt_audio_channels(const char *opt, const char *arg)
2933 {
2934     audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2935     return 0;
2936 }
2937
2938 static void opt_video_channel(const char *arg)
2939 {
2940     video_channel = strtol(arg, NULL, 0);
2941 }
2942
2943 static void opt_video_standard(const char *arg)
2944 {
2945     video_standard = av_strdup(arg);
2946 }
2947
2948 static void opt_codec(int *pstream_copy, char **pcodec_name,
2949                       int codec_type, const char *arg)
2950 {
2951     av_freep(pcodec_name);
2952     if (!strcmp(arg, "copy")) {
2953         *pstream_copy = 1;
2954     } else {
2955         *pcodec_name = av_strdup(arg);
2956     }
2957 }
2958
2959 static void opt_audio_codec(const char *arg)
2960 {
2961     opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2962 }
2963
2964 static void opt_audio_tag(const char *arg)
2965 {
2966     char *tail;
2967     audio_codec_tag= strtol(arg, &tail, 0);
2968
2969     if(!tail || *tail)
2970         audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2971 }
2972
2973 static void opt_video_tag(const char *arg)
2974 {
2975     char *tail;
2976     video_codec_tag= strtol(arg, &tail, 0);
2977
2978     if(!tail || *tail)
2979         video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2980 }
2981
2982 static void opt_video_codec(const char *arg)
2983 {
2984     opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2985 }
2986
2987 static void opt_subtitle_codec(const char *arg)
2988 {
2989     opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2990 }
2991
2992 static void opt_subtitle_tag(const char *arg)
2993 {
2994     char *tail;
2995     subtitle_codec_tag= strtol(arg, &tail, 0);
2996
2997     if(!tail || *tail)
2998         subtitle_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2999 }
3000
3001 static void opt_map(const char *arg)
3002 {
3003     AVStreamMap *m;
3004     char *p;
3005
3006     m = &stream_maps[nb_stream_maps++];
3007
3008     m->file_index = strtol(arg, &p, 0);
3009     if (*p)
3010         p++;
3011
3012     m->stream_index = strtol(p, &p, 0);
3013     if (*p) {
3014         p++;
3015         m->sync_file_index = strtol(p, &p, 0);
3016         if (*p)
3017             p++;
3018         m->sync_stream_index = strtol(p, &p, 0);
3019     } else {
3020         m->sync_file_index = m->file_index;
3021         m->sync_stream_index = m->stream_index;
3022     }
3023 }
3024
3025 static void opt_map_meta_data(const char *arg)
3026 {
3027     AVMetaDataMap *m;
3028     char *p;
3029
3030     m = &meta_data_maps[nb_meta_data_maps++];
3031
3032     m->out_file = strtol(arg, &p, 0);
3033     if (*p)
3034         p++;
3035
3036     m->in_file = strtol(p, &p, 0);
3037 }
3038
3039 static void opt_input_ts_scale(const char *arg)
3040 {
3041     unsigned int stream;
3042     double scale;
3043     char *p;
3044
3045     stream = strtol(arg, &p, 0);
3046     if (*p)
3047         p++;
3048     scale= strtod(p, &p);
3049
3050     if(stream >= MAX_STREAMS)
3051         ffmpeg_exit(1);
3052
3053     input_files_ts_scale[nb_input_files][stream]= scale;
3054 }
3055
3056 static int opt_recording_time(const char *opt, const char *arg)
3057 {
3058     recording_time = parse_time_or_die(opt, arg, 1);
3059     return 0;
3060 }
3061
3062 static int opt_start_time(const char *opt, const char *arg)
3063 {
3064     start_time = parse_time_or_die(opt, arg, 1);
3065     return 0;
3066 }
3067
3068 static int opt_recording_timestamp(const char *opt, const char *arg)
3069 {
3070     recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
3071     return 0;
3072 }
3073
3074 static int opt_input_ts_offset(const char *opt, const char *arg)
3075 {
3076     input_ts_offset = parse_time_or_die(opt, arg, 1);
3077     return 0;
3078 }
3079
3080 static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3081 {
3082     const char *codec_string = encoder ? "encoder" : "decoder";
3083     AVCodec *codec;
3084
3085     if(!name)
3086         return CODEC_ID_NONE;
3087     codec = encoder ?
3088         avcodec_find_encoder_by_name(name) :
3089         avcodec_find_decoder_by_name(name);
3090     if(!codec) {
3091         fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3092         ffmpeg_exit(1);
3093     }
3094     if(codec->type != type) {
3095         fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3096         ffmpeg_exit(1);
3097     }
3098     if(codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
3099        strict > FF_COMPLIANCE_EXPERIMENTAL) {
3100         fprintf(stderr, "%s '%s' is experimental and might produce bad "
3101                 "results.\nAdd '-strict experimental' if you want to use it.\n",
3102                 codec_string, codec->name);
3103         codec = encoder ?
3104             avcodec_find_encoder(codec->id) :
3105             avcodec_find_decoder(codec->id);
3106         if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
3107             fprintf(stderr, "Or use the non experimental %s '%s'.\n",
3108                     codec_string, codec->name);
3109         ffmpeg_exit(1);
3110     }
3111     return codec->id;
3112 }
3113
3114 static void opt_input_file(const char *filename)
3115 {
3116     AVFormatContext *ic;
3117     AVFormatParameters params, *ap = &params;
3118     AVInputFormat *file_iformat = NULL;
3119     int err, i, ret, rfps, rfps_base;
3120     int64_t timestamp;
3121
3122     if (last_asked_format) {
3123         if (!(file_iformat = av_find_input_format(last_asked_format))) {
3124             fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3125             ffmpeg_exit(1);
3126         }
3127         last_asked_format = NULL;
3128     }
3129
3130     if (!strcmp(filename, "-"))
3131         filename = "pipe:";
3132
3133     using_stdin |= !strncmp(filename, "pipe:", 5) ||
3134                     !strcmp(filename, "/dev/stdin");
3135
3136     /* get default parameters from command line */
3137     ic = avformat_alloc_context();
3138     if (!ic) {
3139         print_error(filename, AVERROR(ENOMEM));
3140         ffmpeg_exit(1);
3141     }
3142
3143     memset(ap, 0, sizeof(*ap));
3144     ap->prealloced_context = 1;
3145     ap->sample_rate = audio_sample_rate;
3146     ap->channels = audio_channels;
3147     ap->time_base.den = frame_rate.num;
3148     ap->time_base.num = frame_rate.den;
3149     ap->width = frame_width;
3150     ap->height = frame_height;
3151     ap->pix_fmt = frame_pix_fmt;
3152    // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
3153     ap->channel = video_channel;
3154     ap->standard = video_standard;
3155
3156     set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
3157
3158     ic->video_codec_id   =
3159         find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0,
3160                           avcodec_opts[AVMEDIA_TYPE_VIDEO   ]->strict_std_compliance);
3161     ic->audio_codec_id   =
3162         find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0,
3163                           avcodec_opts[AVMEDIA_TYPE_AUDIO   ]->strict_std_compliance);
3164     ic->subtitle_codec_id=
3165         find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
3166                           avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3167     ic->flags |= AVFMT_FLAG_NONBLOCK;
3168
3169     if(pgmyuv_compatibility_hack)
3170         ic->video_codec_id= CODEC_ID_PGMYUV;
3171
3172     /* open the input file with generic libav function */
3173     err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
3174     if (err < 0) {
3175         print_error(filename, err);
3176         ffmpeg_exit(1);
3177     }
3178     if(opt_programid) {
3179         int i, j;
3180         int found=0;
3181         for(i=0; i<ic->nb_streams; i++){
3182             ic->streams[i]->discard= AVDISCARD_ALL;
3183         }
3184         for(i=0; i<ic->nb_programs; i++){
3185             AVProgram *p= ic->programs[i];
3186             if(p->id != opt_programid){
3187                 p->discard = AVDISCARD_ALL;
3188             }else{
3189                 found=1;
3190                 for(j=0; j<p->nb_stream_indexes; j++){
3191                     ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3192                 }
3193             }
3194         }
3195         if(!found){
3196             fprintf(stderr, "Specified program id not found\n");
3197             ffmpeg_exit(1);
3198         }
3199         opt_programid=0;
3200     }
3201
3202     ic->loop_input = loop_input;
3203
3204     /* If not enough info to get the stream parameters, we decode the
3205        first frames to get it. (used in mpeg case for example) */
3206     ret = av_find_stream_info(ic);
3207     if (ret < 0 && verbose >= 0) {
3208         fprintf(stderr, "%s: could not find codec parameters\n", filename);
3209         av_close_input_file(ic);
3210         ffmpeg_exit(1);
3211     }
3212
3213     timestamp = start_time;
3214     /* add the stream start time */
3215     if (ic->start_time != AV_NOPTS_VALUE)
3216         timestamp += ic->start_time;
3217
3218     /* if seeking requested, we execute it */
3219     if (start_time != 0) {
3220         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3221         if (ret < 0) {
3222             fprintf(stderr, "%s: could not seek to position %0.3f\n",
3223                     filename, (double)timestamp / AV_TIME_BASE);
3224         }
3225         /* reset seek info */
3226         start_time = 0;
3227     }
3228
3229     /* update the current parameters so that they match the one of the input stream */
3230     for(i=0;i<ic->nb_streams;i++) {
3231         AVStream *st = ic->streams[i];
3232         AVCodecContext *dec = st->codec;
3233         avcodec_thread_init(dec, thread_count);
3234         switch (dec->codec_type) {
3235         case AVMEDIA_TYPE_AUDIO:
3236             set_context_opts(dec, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
3237             //fprintf(stderr, "\nInput Audio channels: %d", dec->channels);
3238             channel_layout    = dec->channel_layout;
3239             audio_channels    = dec->channels;
3240             audio_sample_rate = dec->sample_rate;
3241             audio_sample_fmt  = dec->sample_fmt;
3242             input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(audio_codec_name);
3243             if(audio_disable)
3244                 st->discard= AVDISCARD_ALL;
3245             break;
3246         case AVMEDIA_TYPE_VIDEO:
3247             set_context_opts(dec, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
3248             frame_height = dec->height;
3249             frame_width  = dec->width;
3250             if(ic->streams[i]->sample_aspect_ratio.num)
3251                 frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
3252             else
3253                 frame_aspect_ratio=av_q2d(dec->sample_aspect_ratio);
3254             frame_aspect_ratio *= (float) dec->width / dec->height;
3255             frame_pix_fmt = dec->pix_fmt;
3256             rfps      = ic->streams[i]->r_frame_rate.num;
3257             rfps_base = ic->streams[i]->r_frame_rate.den;
3258             if (dec->lowres) {
3259                 dec->flags |= CODEC_FLAG_EMU_EDGE;
3260                 frame_height >>= dec->lowres;
3261                 frame_width  >>= dec->lowres;
3262             }
3263             if(me_threshold)
3264                 dec->debug |= FF_DEBUG_MV;
3265
3266             if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3267
3268                 if (verbose >= 0)
3269                     fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3270                             i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3271
3272                     (float)rfps / rfps_base, rfps, rfps_base);
3273             }
3274             /* update the current frame rate to match the stream frame rate */
3275             frame_rate.num = rfps;
3276             frame_rate.den = rfps_base;
3277
3278             input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(video_codec_name);
3279             if(video_disable)
3280                 st->discard= AVDISCARD_ALL;
3281             else if(video_discard)
3282                 st->discard= video_discard;
3283             break;
3284         case AVMEDIA_TYPE_DATA:
3285             break;
3286         case AVMEDIA_TYPE_SUBTITLE:
3287             input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(subtitle_codec_name);
3288             if(subtitle_disable)
3289                 st->discard = AVDISCARD_ALL;
3290             break;
3291         case AVMEDIA_TYPE_ATTACHMENT:
3292         case AVMEDIA_TYPE_UNKNOWN:
3293             nb_icodecs++;
3294             break;
3295         default:
3296             abort();
3297         }
3298     }
3299
3300     input_files[nb_input_files] = ic;
3301     input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3302     /* dump the file content */
3303     if (verbose >= 0)
3304         dump_format(ic, nb_input_files, filename, 0);
3305
3306     nb_input_files++;
3307
3308     video_channel = 0;
3309
3310     av_freep(&video_codec_name);
3311     av_freep(&audio_codec_name);
3312     av_freep(&subtitle_codec_name);
3313 }
3314
3315 static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3316                                          int *has_subtitle_ptr)
3317 {
3318     int has_video, has_audio, has_subtitle, i, j;
3319     AVFormatContext *ic;
3320
3321     has_video = 0;
3322     has_audio = 0;
3323     has_subtitle = 0;
3324     for(j=0;j<nb_input_files;j++) {
3325         ic = input_files[j];
3326         for(i=0;i<ic->nb_streams;i++) {
3327             AVCodecContext *enc = ic->streams[i]->codec;
3328             switch(enc->codec_type) {
3329             case AVMEDIA_TYPE_AUDIO:
3330                 has_audio = 1;
3331                 break;
3332             case AVMEDIA_TYPE_VIDEO:
3333                 has_video = 1;
3334                 break;
3335             case AVMEDIA_TYPE_SUBTITLE:
3336                 has_subtitle = 1;
3337                 break;
3338             case AVMEDIA_TYPE_DATA:
3339             case AVMEDIA_TYPE_ATTACHMENT:
3340             case AVMEDIA_TYPE_UNKNOWN:
3341                 break;
3342             default:
3343                 abort();
3344             }
3345         }
3346     }
3347     *has_video_ptr = has_video;
3348     *has_audio_ptr = has_audio;
3349     *has_subtitle_ptr = has_subtitle;
3350 }
3351
3352 static void new_video_stream(AVFormatContext *oc)
3353 {
3354     AVStream *st;
3355     AVCodecContext *video_enc;
3356     enum CodecID codec_id;
3357
3358     st = av_new_stream(oc, streamid_map[oc->nb_streams]);
3359     if (!st) {
3360         fprintf(stderr, "Could not alloc stream\n");
3361         ffmpeg_exit(1);
3362     }
3363     avcodec_get_context_defaults2(st->codec, AVMEDIA_TYPE_VIDEO);
3364     bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
3365     video_bitstream_filters= NULL;
3366
3367     avcodec_thread_init(st->codec, thread_count);
3368
3369     video_enc = st->codec;
3370
3371     if(video_codec_tag)
3372         video_enc->codec_tag= video_codec_tag;
3373
3374     if(   (video_global_header&1)
3375        || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3376         video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3377         avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3378     }
3379     if(video_global_header&2){
3380         video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3381         avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3382     }
3383
3384     if (video_stream_copy) {
3385         st->stream_copy = 1;
3386         video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3387         video_enc->sample_aspect_ratio =
3388         st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3389     } else {
3390         const char *p;
3391         int i;
3392         AVCodec *codec;
3393         AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3394
3395         if (video_codec_name) {
3396             codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
3397                                          video_enc->strict_std_compliance);
3398             codec = avcodec_find_encoder_by_name(video_codec_name);
3399             output_codecs[nb_ocodecs] = codec;
3400         } else {
3401             codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3402             codec = avcodec_find_encoder(codec_id);
3403         }
3404
3405         video_enc->codec_id = codec_id;
3406
3407         set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3408
3409         if (codec && codec->supported_framerates && !force_fps)
3410             fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3411         video_enc->time_base.den = fps.num;
3412         video_enc->time_base.num = fps.den;
3413
3414         video_enc->width = frame_width;
3415         video_enc->height = frame_height;
3416         video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3417         video_enc->pix_fmt = frame_pix_fmt;
3418         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3419
3420         choose_pixel_fmt(st, codec);
3421
3422         if (intra_only)
3423             video_enc->gop_size = 0;
3424         if (video_qscale || same_quality) {
3425             video_enc->flags |= CODEC_FLAG_QSCALE;
3426             video_enc->global_quality=
3427                 st->quality = FF_QP2LAMBDA * video_qscale;
3428         }
3429
3430         if(intra_matrix)
3431             video_enc->intra_matrix = intra_matrix;
3432         if(inter_matrix)
3433             video_enc->inter_matrix = inter_matrix;
3434
3435         p= video_rc_override_string;
3436         for(i=0; p; i++){
3437             int start, end, q;
3438             int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3439             if(e!=3){
3440                 fprintf(stderr, "error parsing rc_override\n");
3441                 ffmpeg_exit(1);
3442             }
3443             video_enc->rc_override=
3444                 av_realloc(video_enc->rc_override,
3445                            sizeof(RcOverride)*(i+1));
3446             video_enc->rc_override[i].start_frame= start;
3447             video_enc->rc_override[i].end_frame  = end;
3448             if(q>0){
3449                 video_enc->rc_override[i].qscale= q;
3450                 video_enc->rc_override[i].quality_factor= 1.0;
3451             }
3452             else{
3453                 video_enc->rc_override[i].qscale= 0;
3454                 video_enc->rc_override[i].quality_factor= -q/100.0;
3455             }
3456             p= strchr(p, '/');
3457             if(p) p++;
3458         }
3459         video_enc->rc_override_count=i;
3460         if (!video_enc->rc_initial_buffer_occupancy)
3461             video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3462         video_enc->me_threshold= me_threshold;
3463         video_enc->intra_dc_precision= intra_dc_precision - 8;
3464
3465         if (do_psnr)
3466             video_enc->flags|= CODEC_FLAG_PSNR;
3467
3468         /* two pass mode */
3469         if (do_pass) {
3470             if (do_pass == 1) {
3471                 video_enc->flags |= CODEC_FLAG_PASS1;
3472             } else {
3473                 video_enc->flags |= CODEC_FLAG_PASS2;
3474             }
3475         }
3476     }
3477     nb_ocodecs++;
3478     if (video_language) {
3479         av_metadata_set2(&st->metadata, "language", video_language, 0);
3480         av_freep(&video_language);
3481     }
3482
3483     /* reset some key parameters */
3484     video_disable = 0;
3485     av_freep(&video_codec_name);
3486     video_stream_copy = 0;
3487     frame_pix_fmt = PIX_FMT_NONE;
3488 }
3489
3490 static void new_audio_stream(AVFormatContext *oc)
3491 {
3492     AVStream *st;
3493     AVCodecContext *audio_enc;
3494     enum CodecID codec_id;
3495
3496     st = av_new_stream(oc, streamid_map[oc->nb_streams]);
3497     if (!st) {
3498         fprintf(stderr, "Could not alloc stream\n");
3499         ffmpeg_exit(1);
3500     }
3501     avcodec_get_context_defaults2(st->codec, AVMEDIA_TYPE_AUDIO);
3502
3503     bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3504     audio_bitstream_filters= NULL;
3505
3506     avcodec_thread_init(st->codec, thread_count);
3507
3508     audio_enc = st->codec;
3509     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3510
3511     if(audio_codec_tag)
3512         audio_enc->codec_tag= audio_codec_tag;
3513
3514     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3515         audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3516         avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3517     }
3518     if (audio_stream_copy) {
3519         st->stream_copy = 1;
3520         audio_enc->channels = audio_channels;
3521         audio_enc->sample_rate = audio_sample_rate;
3522     } else {
3523         AVCodec *codec;
3524
3525         set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3526
3527         if (audio_codec_name) {
3528             codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
3529                                          audio_enc->strict_std_compliance);
3530             codec = avcodec_find_encoder_by_name(audio_codec_name);
3531             output_codecs[nb_ocodecs] = codec;
3532         } else {
3533             codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3534             codec = avcodec_find_encoder(codec_id);
3535         }
3536         audio_enc->codec_id = codec_id;
3537
3538         if (audio_qscale > QSCALE_NONE) {
3539             audio_enc->flags |= CODEC_FLAG_QSCALE;
3540             audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3541         }
3542         audio_enc->channels = audio_channels;
3543         audio_enc->sample_fmt = audio_sample_fmt;
3544         audio_enc->sample_rate = audio_sample_rate;
3545         audio_enc->channel_layout = channel_layout;
3546         if (avcodec_channel_layout_num_channels(channel_layout) != audio_channels)
3547             audio_enc->channel_layout = 0;
3548         choose_sample_fmt(st, codec);
3549         choose_sample_rate(st, codec);
3550     }
3551     nb_ocodecs++;
3552     audio_enc->time_base= (AVRational){1, audio_sample_rate};
3553     if (audio_language) {
3554         av_metadata_set2(&st->metadata, "language", audio_language, 0);
3555         av_freep(&audio_language);
3556     }
3557
3558     /* reset some key parameters */
3559     audio_disable = 0;
3560     av_freep(&audio_codec_name);
3561     audio_stream_copy = 0;
3562 }
3563
3564 static void new_subtitle_stream(AVFormatContext *oc)
3565 {
3566     AVStream *st;
3567     AVCodecContext *subtitle_enc;
3568
3569     st = av_new_stream(oc, streamid_map[oc->nb_streams]);
3570     if (!st) {
3571         fprintf(stderr, "Could not alloc stream\n");
3572         ffmpeg_exit(1);
3573     }
3574     avcodec_get_context_defaults2(st->codec, AVMEDIA_TYPE_SUBTITLE);
3575
3576     bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3577     subtitle_bitstream_filters= NULL;
3578
3579     subtitle_enc = st->codec;
3580     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3581
3582     if(subtitle_codec_tag)
3583         subtitle_enc->codec_tag= subtitle_codec_tag;
3584
3585     if (subtitle_stream_copy) {
3586         st->stream_copy = 1;
3587     } else {
3588         set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3589         subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,
3590                                                    subtitle_enc->strict_std_compliance);
3591         output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name);
3592     }
3593     nb_ocodecs++;
3594
3595     if (subtitle_language) {
3596         av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3597         av_freep(&subtitle_language);
3598     }
3599
3600     subtitle_disable = 0;
3601     av_freep(&subtitle_codec_name);
3602     subtitle_stream_copy = 0;
3603 }
3604
3605 static void opt_new_audio_stream(void)
3606 {
3607     AVFormatContext *oc;
3608     if (nb_output_files <= 0) {
3609         fprintf(stderr, "At least one output file must be specified\n");
3610         ffmpeg_exit(1);
3611     }
3612     oc = output_files[nb_output_files - 1];
3613     new_audio_stream(oc);
3614 }
3615
3616 static void opt_new_video_stream(void)
3617 {
3618     AVFormatContext *oc;
3619     if (nb_output_files <= 0) {
3620         fprintf(stderr, "At least one output file must be specified\n");
3621         ffmpeg_exit(1);
3622     }
3623     oc = output_files[nb_output_files - 1];
3624     new_video_stream(oc);
3625 }
3626
3627 static void opt_new_subtitle_stream(void)
3628 {
3629     AVFormatContext *oc;
3630     if (nb_output_files <= 0) {
3631         fprintf(stderr, "At least one output file must be specified\n");
3632         ffmpeg_exit(1);
3633     }
3634     oc = output_files[nb_output_files - 1];
3635     new_subtitle_stream(oc);
3636 }
3637
3638 /* arg format is "output-stream-index:streamid-value". */
3639 static void opt_streamid(const char *opt, const char *arg)
3640 {
3641     int idx;
3642     char *p;
3643     char idx_str[16];
3644
3645     strncpy(idx_str, arg, sizeof(idx_str));
3646     idx_str[sizeof(idx_str)-1] = '\0';
3647     p = strchr(idx_str, ':');
3648     if (!p) {
3649         fprintf(stderr,
3650                 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3651                 arg, opt);
3652         ffmpeg_exit(1);
3653     }
3654     *p++ = '\0';
3655     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3656     streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3657 }
3658
3659 static void opt_output_file(const char *filename)
3660 {
3661     AVFormatContext *oc;
3662     int err, use_video, use_audio, use_subtitle;
3663     int input_has_video, input_has_audio, input_has_subtitle;
3664     AVFormatParameters params, *ap = &params;
3665     AVOutputFormat *file_oformat;
3666
3667     if (!strcmp(filename, "-"))
3668         filename = "pipe:";
3669
3670     oc = avformat_alloc_context();
3671     if (!oc) {
3672         print_error(filename, AVERROR(ENOMEM));
3673         ffmpeg_exit(1);
3674     }
3675
3676     if (last_asked_format) {
3677         file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3678         if (!file_oformat) {
3679             fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3680             ffmpeg_exit(1);
3681         }
3682         last_asked_format = NULL;
3683     } else {
3684         file_oformat = av_guess_format(NULL, filename, NULL);
3685         if (!file_oformat) {
3686             fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3687                     filename);
3688             ffmpeg_exit(1);
3689         }
3690     }
3691
3692     oc->oformat = file_oformat;
3693     av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3694
3695     if (!strcmp(file_oformat->name, "ffm") &&
3696         av_strstart(filename, "http:", NULL)) {
3697         /* special case for files sent to ffserver: we get the stream
3698            parameters from ffserver */
3699         int err = read_ffserver_streams(oc, filename);
3700         if (err < 0) {
3701             print_error(filename, err);
3702             ffmpeg_exit(1);
3703         }
3704     } else {
3705         use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3706         use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3707         use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3708
3709         /* disable if no corresponding type found and at least one
3710            input file */
3711         if (nb_input_files > 0) {
3712             check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3713                                          &input_has_subtitle);
3714             if (!input_has_video)
3715                 use_video = 0;
3716             if (!input_has_audio)
3717                 use_audio = 0;
3718             if (!input_has_subtitle)
3719                 use_subtitle = 0;
3720         }
3721
3722         /* manual disable */
3723         if (audio_disable) {
3724             use_audio = 0;
3725         }
3726         if (video_disable) {
3727             use_video = 0;
3728         }
3729         if (subtitle_disable) {
3730             use_subtitle = 0;
3731         }
3732
3733         if (use_video) {
3734             new_video_stream(oc);
3735         }
3736
3737         if (use_audio) {
3738             new_audio_stream(oc);
3739         }
3740
3741         if (use_subtitle) {
3742             new_subtitle_stream(oc);
3743         }
3744
3745         oc->timestamp = recording_timestamp;
3746
3747         for(; metadata_count>0; metadata_count--){
3748             av_metadata_set2(&oc->metadata, metadata[metadata_count-1].key,
3749                                             metadata[metadata_count-1].value, 0);
3750         }
3751         av_metadata_conv(oc, oc->oformat->metadata_conv, NULL);
3752     }
3753
3754     output_files[nb_output_files++] = oc;
3755
3756     /* check filename in case of an image number is expected */
3757     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3758         if (!av_filename_number_test(oc->filename)) {
3759             print_error(oc->filename, AVERROR_NUMEXPECTED);
3760             ffmpeg_exit(1);
3761         }
3762     }
3763
3764     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3765         /* test if it already exists to avoid loosing precious files */
3766         if (!file_overwrite &&
3767             (strchr(filename, ':') == NULL ||
3768              filename[1] == ':' ||
3769              av_strstart(filename, "file:", NULL))) {
3770             if (url_exist(filename)) {
3771                 if (!using_stdin) {
3772                     fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3773                     fflush(stderr);
3774                     if (!read_yesno()) {
3775                         fprintf(stderr, "Not overwriting - exiting\n");
3776                         ffmpeg_exit(1);
3777                     }
3778                 }
3779                 else {
3780                     fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3781                     ffmpeg_exit(1);
3782                 }
3783             }
3784         }
3785
3786         /* open the file */
3787         if ((err = url_fopen(&oc->pb, filename, URL_WRONLY)) < 0) {
3788             print_error(filename, err);
3789             ffmpeg_exit(1);
3790         }
3791     }
3792
3793     memset(ap, 0, sizeof(*ap));
3794     if (av_set_parameters(oc, ap) < 0) {
3795         fprintf(stderr, "%s: Invalid encoding parameters\n",
3796                 oc->filename);
3797         ffmpeg_exit(1);
3798     }
3799
3800     oc->preload= (int)(mux_preload*AV_TIME_BASE);
3801     oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3802     oc->loop_output = loop_output;
3803     oc->flags |= AVFMT_FLAG_NONBLOCK;
3804
3805     set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3806
3807     memset(streamid_map, 0, sizeof(streamid_map));
3808 }
3809
3810 /* same option as mencoder */
3811 static void opt_pass(const char *pass_str)
3812 {
3813     int pass;
3814     pass = atoi(pass_str);
3815     if (pass != 1 && pass != 2) {
3816         fprintf(stderr, "pass number can be only 1 or 2\n");
3817         ffmpeg_exit(1);
3818     }
3819     do_pass = pass;
3820 }
3821
3822 static int64_t getutime(void)
3823 {
3824 #if HAVE_GETRUSAGE
3825     struct rusage rusage;
3826
3827     getrusage(RUSAGE_SELF, &rusage);
3828     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3829 #elif HAVE_GETPROCESSTIMES
3830     HANDLE proc;
3831     FILETIME c, e, k, u;
3832     proc = GetCurrentProcess();
3833     GetProcessTimes(proc, &c, &e, &k, &u);
3834     return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3835 #else
3836     return av_gettime();
3837 #endif
3838 }
3839
3840 static int64_t getmaxrss(void)
3841 {
3842 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3843     struct rusage rusage;
3844     getrusage(RUSAGE_SELF, &rusage);
3845     return (int64_t)rusage.ru_maxrss * 1024;
3846 #elif HAVE_GETPROCESSMEMORYINFO
3847     HANDLE proc;
3848     PROCESS_MEMORY_COUNTERS memcounters;
3849     proc = GetCurrentProcess();
3850     memcounters.cb = sizeof(memcounters);
3851     GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3852     return memcounters.PeakPagefileUsage;
3853 #else
3854     return 0;
3855 #endif
3856 }
3857
3858 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3859 {
3860     int i;
3861     const char *p = str;
3862     for(i = 0;; i++) {
3863         dest[i] = atoi(p);
3864         if(i == 63)
3865             break;
3866         p = strchr(p, ',');
3867         if(!p) {
3868             fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3869             ffmpeg_exit(1);
3870         }
3871         p++;
3872     }
3873 }
3874
3875 static void opt_inter_matrix(const char *arg)
3876 {
3877     inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3878     parse_matrix_coeffs(inter_matrix, arg);
3879 }
3880
3881 static void opt_intra_matrix(const char *arg)
3882 {
3883     intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3884     parse_matrix_coeffs(intra_matrix, arg);
3885 }
3886
3887 /**
3888  * Trivial log callback.
3889  * Only suitable for show_help and similar since it lacks prefix handling.
3890  */
3891 static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3892 {
3893     vfprintf(stdout, fmt, vl);
3894 }
3895
3896 static void show_usage(void)
3897 {
3898     printf("Hyper fast Audio and Video encoder\n");
3899     printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3900     printf("\n");
3901 }
3902
3903 static void show_help(void)
3904 {
3905     av_log_set_callback(log_callback_help);
3906     show_usage();
3907     show_help_options(options, "Main options:\n",
3908                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3909     show_help_options(options, "\nAdvanced options:\n",
3910                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3911                       OPT_EXPERT);
3912     show_help_options(options, "\nVideo options:\n",
3913                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3914                       OPT_VIDEO);
3915     show_help_options(options, "\nAdvanced Video options:\n",
3916                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3917                       OPT_VIDEO | OPT_EXPERT);
3918     show_help_options(options, "\nAudio options:\n",
3919                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3920                       OPT_AUDIO);
3921     show_help_options(options, "\nAdvanced Audio options:\n",
3922                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3923                       OPT_AUDIO | OPT_EXPERT);
3924     show_help_options(options, "\nSubtitle options:\n",
3925                       OPT_SUBTITLE | OPT_GRAB,
3926                       OPT_SUBTITLE);
3927     show_help_options(options, "\nAudio/Video grab options:\n",
3928                       OPT_GRAB,
3929                       OPT_GRAB);
3930     printf("\n");
3931     av_opt_show(avcodec_opts[0], NULL);
3932     printf("\n");
3933     av_opt_show(avformat_opts, NULL);
3934     printf("\n");
3935     av_opt_show(sws_opts, NULL);
3936 }
3937
3938 static void opt_target(const char *arg)
3939 {
3940     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3941     static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3942
3943     if(!strncmp(arg, "pal-", 4)) {
3944         norm = PAL;
3945         arg += 4;
3946     } else if(!strncmp(arg, "ntsc-", 5)) {
3947         norm = NTSC;
3948         arg += 5;
3949     } else if(!strncmp(arg, "film-", 5)) {
3950         norm = FILM;
3951         arg += 5;
3952     } else {
3953         int fr;
3954         /* Calculate FR via float to avoid int overflow */
3955         fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3956         if(fr == 25000) {
3957             norm = PAL;
3958         } else if((fr == 29970) || (fr == 23976)) {
3959             norm = NTSC;
3960         } else {
3961             /* Try to determine PAL/NTSC by peeking in the input files */
3962             if(nb_input_files) {
3963                 int i, j;
3964                 for(j = 0; j < nb_input_files; j++) {
3965                     for(i = 0; i < input_files[j]->nb_streams; i++) {
3966                         AVCodecContext *c = input_files[j]->streams[i]->codec;
3967                         if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3968                             continue;
3969                         fr = c->time_base.den * 1000 / c->time_base.num;
3970                         if(fr == 25000) {
3971                             norm = PAL;
3972                             break;
3973                         } else if((fr == 29970) || (fr == 23976)) {
3974                             norm = NTSC;
3975                             break;
3976                         }
3977                     }
3978                     if(norm != UNKNOWN)
3979                         break;
3980                 }
3981             }
3982         }
3983         if(verbose && norm != UNKNOWN)
3984             fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
3985     }
3986
3987     if(norm == UNKNOWN) {
3988         fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3989         fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3990         fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3991         ffmpeg_exit(1);
3992     }
3993
3994     if(!strcmp(arg, "vcd")) {
3995
3996         opt_video_codec("mpeg1video");
3997         opt_audio_codec("mp2");
3998         opt_format("vcd");
3999
4000         opt_frame_size(norm == PAL ? "352x288" : "352x240");
4001         opt_frame_rate(NULL, frame_rates[norm]);
4002         opt_default("g", norm == PAL ? "15" : "18");
4003
4004         opt_default("b", "1150000");
4005         opt_default("maxrate", "1150000");
4006         opt_default("minrate", "1150000");
4007         opt_default("bufsize", "327680"); // 40*1024*8;
4008
4009         opt_default("ab", "224000");
4010         audio_sample_rate = 44100;
4011         audio_channels = 2;
4012
4013         opt_default("packetsize", "2324");
4014         opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4015
4016         /* We have to offset the PTS, so that it is consistent with the SCR.
4017            SCR starts at 36000, but the first two packs contain only padding
4018            and the first pack from the other stream, respectively, may also have
4019            been written before.
4020            So the real data starts at SCR 36000+3*1200. */
4021         mux_preload= (36000+3*1200) / 90000.0; //0.44
4022     } else if(!strcmp(arg, "svcd")) {
4023
4024         opt_video_codec("mpeg2video");
4025         opt_audio_codec("mp2");
4026         opt_format("svcd");
4027
4028         opt_frame_size(norm == PAL ? "480x576" : "480x480");
4029         opt_frame_rate(NULL, frame_rates[norm]);
4030         opt_default("g", norm == PAL ? "15" : "18");
4031
4032         opt_default("b", "2040000");
4033         opt_default("maxrate", "2516000");
4034         opt_default("minrate", "0"); //1145000;
4035         opt_default("bufsize", "1835008"); //224*1024*8;
4036         opt_default("flags", "+scan_offset");
4037
4038
4039         opt_default("ab", "224000");
4040         audio_sample_rate = 44100;
4041
4042         opt_default("packetsize", "2324");
4043
4044     } else if(!strcmp(arg, "dvd")) {
4045
4046         opt_video_codec("mpeg2video");
4047         opt_audio_codec("ac3");
4048         opt_format("dvd");
4049
4050         opt_frame_size(norm == PAL ? "720x576" : "720x480");
4051         opt_frame_rate(NULL, frame_rates[norm]);
4052         opt_default("g", norm == PAL ? "15" : "18");
4053
4054         opt_default("b", "6000000");
4055         opt_default("maxrate", "9000000");
4056         opt_default("minrate", "0"); //1500000;
4057         opt_default("bufsize", "1835008"); //224*1024*8;
4058
4059         opt_default("packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4060         opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4061
4062         opt_default("ab", "448000");
4063         audio_sample_rate = 48000;
4064
4065     } else if(!strncmp(arg, "dv", 2)) {
4066
4067         opt_format("dv");
4068
4069         opt_frame_size(norm == PAL ? "720x576" : "720x480");
4070         opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
4071                           (norm == PAL ? "yuv420p" : "yuv411p"));
4072         opt_frame_rate(NULL, frame_rates[norm]);
4073
4074         audio_sample_rate = 48000;
4075         audio_channels = 2;
4076
4077     } else {
4078         fprintf(stderr, "Unknown target: %s\n", arg);
4079         ffmpeg_exit(1);
4080     }
4081 }
4082
4083 static void opt_vstats_file (const char *arg)
4084 {
4085     av_free (vstats_filename);
4086     vstats_filename=av_strdup (arg);
4087 }
4088
4089 static void opt_vstats (void)
4090 {
4091     char filename[40];
4092     time_t today2 = time(NULL);
4093     struct tm *today = localtime(&today2);
4094
4095     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4096              today->tm_sec);
4097     opt_vstats_file(filename);
4098 }
4099
4100 static int opt_bsf(const char *opt, const char *arg)
4101 {
4102     AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4103     AVBitStreamFilterContext **bsfp;
4104
4105     if(!bsfc){
4106         fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4107         ffmpeg_exit(1);
4108     }
4109
4110     bsfp= *opt == 'v' ? &video_bitstream_filters :
4111           *opt == 'a' ? &audio_bitstream_filters :
4112                         &subtitle_bitstream_filters;
4113     while(*bsfp)
4114         bsfp= &(*bsfp)->next;
4115
4116     *bsfp= bsfc;
4117
4118     return 0;
4119 }
4120
4121 static int opt_preset(const char *opt, const char *arg)
4122 {
4123     FILE *f=NULL;
4124     char filename[1000], tmp[1000], tmp2[1000], line[1000];
4125     int i;
4126     const char *base[3]= { getenv("FFMPEG_DATADIR"),
4127                            getenv("HOME"),
4128                            FFMPEG_DATADIR,
4129                          };
4130
4131     if (*opt != 'f') {
4132         for(i=0; i<3 && !f; i++){
4133             if(!base[i])
4134                 continue;
4135             snprintf(filename, sizeof(filename), "%s%s/%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", arg);
4136             f= fopen(filename, "r");
4137             if(!f){
4138                 char *codec_name= *opt == 'v' ? video_codec_name :
4139                                   *opt == 'a' ? audio_codec_name :
4140                                                 subtitle_codec_name;
4141                 snprintf(filename, sizeof(filename), "%s%s/%s-%s.ffpreset", base[i],  i != 1 ? "" : "/.ffmpeg", codec_name, arg);
4142                 f= fopen(filename, "r");
4143             }
4144         }
4145     } else {
4146         av_strlcpy(filename, arg, sizeof(filename));
4147         f= fopen(filename, "r");
4148     }
4149
4150     if(!f){
4151         fprintf(stderr, "File for preset '%s' not found\n", arg);
4152         ffmpeg_exit(1);
4153     }
4154
4155     while(!feof(f)){
4156         int e= fscanf(f, "%999[^\n]\n", line) - 1;
4157         if(line[0] == '#' && !e)
4158             continue;
4159         e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4160         if(e){
4161             fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4162             ffmpeg_exit(1);
4163         }
4164         if(!strcmp(tmp, "acodec")){
4165             opt_audio_codec(tmp2);
4166         }else if(!strcmp(tmp, "vcodec")){
4167             opt_video_codec(tmp2);
4168         }else if(!strcmp(tmp, "scodec")){
4169             opt_subtitle_codec(tmp2);
4170         }else if(opt_default(tmp, tmp2) < 0){
4171             fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4172             ffmpeg_exit(1);
4173         }
4174     }
4175
4176     fclose(f);
4177
4178     return 0;
4179 }
4180
4181 static const OptionDef options[] = {
4182     /* main options */
4183 #include "cmdutils_common_opts.h"
4184     { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4185     { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4186     { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4187     { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
4188     { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
4189     { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4190     { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4191     { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4192     { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4193     { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
4194     { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4195     { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4196     { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4197     { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4198       "add timings for benchmarking" },
4199     { "timelimit", OPT_FUNC2 | HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4200     { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4201       "dump each input packet" },
4202     { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4203       "when dumping packets, also dump the payload" },
4204     { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4205     { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
4206     { "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)", "" },
4207     { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
4208     { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4209     { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4210     { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4211     { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4212     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4213     { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
4214     { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
4215     { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4216     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4217     { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4218     { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4219     { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)&copy_initial_nonkeyframes}, "copy initial non-keyframes" },
4220
4221     /* video options */
4222     { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4223     { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4224     { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4225     { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4226     { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4227     { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4228     { "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" },
4229     { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "Deprecated, please use the crop avfilter", "size" },
4230     { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "Deprecated, please use the crop avfilter", "size" },
4231     { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "Deprecated, please use the crop avfilter", "size" },
4232     { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "Deprecated, please use the crop avfilter", "size" },
4233     { "padtop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4234     { "padbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4235     { "padleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4236     { "padright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4237     { "padcolor", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4238     { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4239     { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4240     { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4241     { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4242     { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4243     { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4244     { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "threshold" },
4245     { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4246       "use same video quality as source (implies VBR)" },
4247     { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
4248     { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4249     { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4250       "deinterlace pictures" },
4251     { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4252     { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4253     { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4254 #if CONFIG_AVFILTER
4255     { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4256 #endif
4257     { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4258     { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4259     { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4260     { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4261     { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
4262     { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
4263     { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4264     { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4265     { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4266     { "streamid", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4267
4268     /* audio options */
4269     { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4270     { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4271     { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4272     { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4273     { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4274     { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4275     { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4276     { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
4277     { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4278     { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
4279     { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4280     { "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" },
4281
4282     /* subtitle options */
4283     { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4284     { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4285     { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
4286     { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4287     { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4288
4289     /* grab options */
4290     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4291     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4292     { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4293
4294     /* muxer options */
4295     { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4296     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4297
4298     { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4299     { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4300     { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4301
4302     { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4303     { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4304     { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4305     { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4306
4307     { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4308     { NULL, },
4309 };
4310
4311 int main(int argc, char **argv)
4312 {
4313     int i;
4314     int64_t ti;
4315
4316     avcodec_register_all();
4317 #if CONFIG_AVDEVICE
4318     avdevice_register_all();
4319 #endif
4320 #if CONFIG_AVFILTER
4321     avfilter_register_all();
4322 #endif
4323     av_register_all();
4324
4325 #if HAVE_ISATTY
4326     if(isatty(STDIN_FILENO))
4327         url_set_interrupt_cb(decode_interrupt_cb);
4328 #endif
4329
4330     for(i=0; i<AVMEDIA_TYPE_NB; i++){
4331         avcodec_opts[i]= avcodec_alloc_context2(i);
4332     }
4333     avformat_opts = avformat_alloc_context();
4334     sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
4335
4336     show_banner();
4337
4338     /* parse options */
4339     parse_options(argc, argv, options, opt_output_file);
4340
4341     if(nb_output_files <= 0 && nb_input_files == 0) {
4342         show_usage();
4343         fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4344         ffmpeg_exit(1);
4345     }
4346
4347     /* file converter / grab */
4348     if (nb_output_files <= 0) {
4349         fprintf(stderr, "At least one output file must be specified\n");
4350         ffmpeg_exit(1);
4351     }
4352
4353     if (nb_input_files == 0) {
4354         fprintf(stderr, "At least one input file must be specified\n");
4355         ffmpeg_exit(1);
4356     }
4357
4358     ti = getutime();
4359     if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4360                   stream_maps, nb_stream_maps) < 0)
4361         ffmpeg_exit(1);
4362     ti = getutime() - ti;
4363     if (do_benchmark) {
4364         int maxrss = getmaxrss() / 1024;
4365         printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4366     }
4367
4368     return ffmpeg_exit(0);
4369 }