ffmpeg.c

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