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

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