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