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