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