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