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

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