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

   1 /*
   2  * FFmpeg main
   3  * Copyright (c) 2000-2003 Fabrice Bellard
   4  *
   5  * This file is part of 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 "libavcodec/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 #if !FF_API_MAX_STREAMS
 110 #define MAX_STREAMS 1024    /* arbitrary sanity check value */
 111 #endif
 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 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1394 static int output_packet(AVInputStream *ist, int ist_index,
1395                          AVOutputStream **ost_table, int nb_ostreams,
1396                          const AVPacket *pkt)
1397 {
1398     AVFormatContext *os;
1399     AVOutputStream *ost;
1400     int ret, i;
1401     int got_picture;
1402     AVFrame picture;
1403     void *buffer_to_free;
1404     static unsigned int samples_size= 0;
1405     AVSubtitle subtitle, *subtitle_to_free;
1406     int64_t pkt_pts = AV_NOPTS_VALUE;
1407 #if CONFIG_AVFILTER
1408     int frame_available;
1409 #endif
1410
1411     AVPacket avpkt;
1412     int bps = av_get_bits_per_sample_fmt(ist->st->codec->sample_fmt)>>3;
1413
1414     if(ist->next_pts == AV_NOPTS_VALUE)
1415         ist->next_pts= ist->pts;
1416
1417     if (pkt == NULL) {
1418         /* EOF handling */
1419         av_init_packet(&avpkt);
1420         avpkt.data = NULL;
1421         avpkt.size = 0;
1422         goto handle_eof;
1423     } else {
1424         avpkt = *pkt;
1425     }
1426
1427     if(pkt->dts != AV_NOPTS_VALUE)
1428         ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1429     if(pkt->pts != AV_NOPTS_VALUE)
1430         pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1431
1432     //while we have more to decode or while the decoder did output something on EOF
1433     while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) {
1434         uint8_t *data_buf, *decoded_data_buf;
1435         int data_size, decoded_data_size;
1436     handle_eof:
1437         ist->pts= ist->next_pts;
1438
1439         if(avpkt.size && avpkt.size != pkt->size &&
1440            ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1441             fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1442             ist->showed_multi_packet_warning=1;
1443         }
1444
1445         /* decode the packet if needed */
1446         decoded_data_buf = NULL; /* fail safe */
1447         decoded_data_size= 0;
1448         data_buf  = avpkt.data;
1449         data_size = avpkt.size;
1450         subtitle_to_free = NULL;
1451         if (ist->decoding_needed) {
1452             switch(ist->st->codec->codec_type) {
1453             case AVMEDIA_TYPE_AUDIO:{
1454                 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1455                     samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1456                     av_free(samples);
1457                     samples= av_malloc(samples_size);
1458                 }
1459                 decoded_data_size= samples_size;
1460                     /* XXX: could avoid copy if PCM 16 bits with same
1461                        endianness as CPU */
1462                 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1463                                             &avpkt);
1464                 if (ret < 0)
1465                     goto fail_decode;
1466                 avpkt.data += ret;
1467                 avpkt.size -= ret;
1468                 data_size   = ret;
1469                 /* Some bug in mpeg audio decoder gives */
1470                 /* decoded_data_size < 0, it seems they are overflows */
1471                 if (decoded_data_size <= 0) {
1472                     /* no audio frame */
1473                     continue;
1474                 }
1475                 decoded_data_buf = (uint8_t *)samples;
1476                 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1477                     (ist->st->codec->sample_rate * ist->st->codec->channels);
1478                 break;}
1479             case AVMEDIA_TYPE_VIDEO:
1480                     decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1481                     /* XXX: allocate picture correctly */
1482                     avcodec_get_frame_defaults(&picture);
1483                     avpkt.pts = pkt_pts;
1484                     avpkt.dts = ist->pts;
1485                     pkt_pts = AV_NOPTS_VALUE;
1486
1487                     ret = avcodec_decode_video2(ist->st->codec,
1488                                                 &picture, &got_picture, &avpkt);
1489                     ist->st->quality= picture.quality;
1490                     if (ret < 0)
1491                         goto fail_decode;
1492                     if (!got_picture) {
1493                         /* no picture yet */
1494                         goto discard_packet;
1495                     }
1496                     ist->next_pts = ist->pts = guess_correct_pts(&ist->pts_ctx, picture.pkt_pts, picture.pkt_dts);
1497                     if (ist->st->codec->time_base.num != 0) {
1498                         int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1499                         ist->next_pts += ((int64_t)AV_TIME_BASE *
1500                                           ist->st->codec->time_base.num * ticks) /
1501                             ist->st->codec->time_base.den;
1502                     }
1503                     avpkt.size = 0;
1504                     break;
1505             case AVMEDIA_TYPE_SUBTITLE:
1506                 ret = avcodec_decode_subtitle2(ist->st->codec,
1507                                                &subtitle, &got_picture, &avpkt);
1508                 if (ret < 0)
1509                     goto fail_decode;
1510                 if (!got_picture) {
1511                     goto discard_packet;
1512                 }
1513                 subtitle_to_free = &subtitle;
1514                 avpkt.size = 0;
1515                 break;
1516             default:
1517                 goto fail_decode;
1518             }
1519         } else {
1520             switch(ist->st->codec->codec_type) {
1521             case AVMEDIA_TYPE_AUDIO:
1522                 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1523                     ist->st->codec->sample_rate;
1524                 break;
1525             case AVMEDIA_TYPE_VIDEO:
1526                 if (ist->st->codec->time_base.num != 0) {
1527                     int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1528                     ist->next_pts += ((int64_t)AV_TIME_BASE *
1529                                       ist->st->codec->time_base.num * ticks) /
1530                         ist->st->codec->time_base.den;
1531                 }
1532                 break;
1533             }
1534             ret = avpkt.size;
1535             avpkt.size = 0;
1536         }
1537
1538         buffer_to_free = NULL;
1539         if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1540             pre_process_video_frame(ist, (AVPicture *)&picture,
1541                                     &buffer_to_free);
1542         }
1543
1544 #if CONFIG_AVFILTER
1545         if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->input_video_filter) {
1546             AVRational sar;
1547             if (ist->st->sample_aspect_ratio.num) sar = ist->st->sample_aspect_ratio;
1548             else                                  sar = ist->st->codec->sample_aspect_ratio;
1549             // add it to be filtered
1550             av_vsrc_buffer_add_frame(ist->input_video_filter, &picture,
1551                                      ist->pts,
1552                                      sar);
1553         }
1554 #endif
1555
1556         // preprocess audio (volume)
1557         if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1558             if (audio_volume != 256) {
1559                 short *volp;
1560                 volp = samples;
1561                 for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1562                     int v = ((*volp) * audio_volume + 128) >> 8;
1563                     if (v < -32768) v = -32768;
1564                     if (v >  32767) v = 32767;
1565                     *volp++ = v;
1566                 }
1567             }
1568         }
1569
1570         /* frame rate emulation */
1571         if (rate_emu) {
1572             int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1573             int64_t now = av_gettime() - ist->start;
1574             if (pts > now)
1575                 usleep(pts - now);
1576         }
1577 #if CONFIG_AVFILTER
1578         frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1579             !ist->output_video_filter || avfilter_poll_frame(ist->output_video_filter->inputs[0]);
1580 #endif
1581         /* if output time reached then transcode raw format,
1582            encode packets and output them */
1583         if (start_time == 0 || ist->pts >= start_time)
1584 #if CONFIG_AVFILTER
1585         while (frame_available) {
1586             AVRational ist_pts_tb;
1587             if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->output_video_filter)
1588                 get_filtered_video_frame(ist->output_video_filter, &picture, &ist->picref, &ist_pts_tb);
1589             if (ist->picref)
1590                 ist->pts = av_rescale_q(ist->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1591 #endif
1592             for(i=0;i<nb_ostreams;i++) {
1593                 int frame_size;
1594
1595                 ost = ost_table[i];
1596                 if (ost->source_index == ist_index) {
1597                     os = output_files[ost->file_index];
1598
1599                     /* set the input output pts pairs */
1600                     //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1601
1602                     if (ost->encoding_needed) {
1603                         av_assert0(ist->decoding_needed);
1604                         switch(ost->st->codec->codec_type) {
1605                         case AVMEDIA_TYPE_AUDIO:
1606                             do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1607                             break;
1608                         case AVMEDIA_TYPE_VIDEO:
1609 #if CONFIG_AVFILTER
1610                             if (ist->picref->video)
1611                                 ost->st->codec->sample_aspect_ratio = ist->picref->video->pixel_aspect;
1612 #endif
1613                             do_video_out(os, ost, ist, &picture, &frame_size);
1614                             if (vstats_filename && frame_size)
1615                                 do_video_stats(os, ost, frame_size);
1616                             break;
1617                         case AVMEDIA_TYPE_SUBTITLE:
1618                             do_subtitle_out(os, ost, ist, &subtitle,
1619                                             pkt->pts);
1620                             break;
1621                         default:
1622                             abort();
1623                         }
1624                     } else {
1625                         AVFrame avframe; //FIXME/XXX remove this
1626                         AVPacket opkt;
1627                         int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1628
1629                         av_init_packet(&opkt);
1630
1631                         if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1632                             continue;
1633
1634                         /* no reencoding needed : output the packet directly */
1635                         /* force the input stream PTS */
1636
1637                         avcodec_get_frame_defaults(&avframe);
1638                         ost->st->codec->coded_frame= &avframe;
1639                         avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1640
1641                         if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1642                             audio_size += data_size;
1643                         else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1644                             video_size += data_size;
1645                             ost->sync_opts++;
1646                         }
1647
1648                         opkt.stream_index= ost->index;
1649                         if(pkt->pts != AV_NOPTS_VALUE)
1650                             opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1651                         else
1652                             opkt.pts= AV_NOPTS_VALUE;
1653
1654                         if (pkt->dts == AV_NOPTS_VALUE)
1655                             opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1656                         else
1657                             opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1658                         opkt.dts -= ost_tb_start_time;
1659
1660                         opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1661                         opkt.flags= pkt->flags;
1662
1663                         //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1664                         if(   ost->st->codec->codec_id != CODEC_ID_H264
1665                            && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1666                            && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1667                            ) {
1668                             if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1669                                 opkt.destruct= av_destruct_packet;
1670                         } else {
1671                             opkt.data = data_buf;
1672                             opkt.size = data_size;
1673                         }
1674
1675                         write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1676                         ost->st->codec->frame_number++;
1677                         ost->frame_number++;
1678                         av_free_packet(&opkt);
1679                     }
1680                 }
1681             }
1682
1683 #if CONFIG_AVFILTER
1684             frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1685                               ist->output_video_filter && avfilter_poll_frame(ist->output_video_filter->inputs[0]);
1686             if(ist->picref)
1687                 avfilter_unref_buffer(ist->picref);
1688         }
1689 #endif
1690         av_free(buffer_to_free);
1691         /* XXX: allocate the subtitles in the codec ? */
1692         if (subtitle_to_free) {
1693             avsubtitle_free(subtitle_to_free);
1694             subtitle_to_free = NULL;
1695         }
1696     }
1697  discard_packet:
1698     if (pkt == NULL) {
1699         /* EOF handling */
1700
1701         for(i=0;i<nb_ostreams;i++) {
1702             ost = ost_table[i];
1703             if (ost->source_index == ist_index) {
1704                 AVCodecContext *enc= ost->st->codec;
1705                 os = output_files[ost->file_index];
1706
1707                 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1708                     continue;
1709                 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1710                     continue;
1711
1712                 if (ost->encoding_needed) {
1713                     for(;;) {
1714                         AVPacket pkt;
1715                         int fifo_bytes;
1716                         av_init_packet(&pkt);
1717                         pkt.stream_index= ost->index;
1718
1719                         switch(ost->st->codec->codec_type) {
1720                         case AVMEDIA_TYPE_AUDIO:
1721                             fifo_bytes = av_fifo_size(ost->fifo);
1722                             ret = 0;
1723                             /* encode any samples remaining in fifo */
1724                             if (fifo_bytes > 0) {
1725                                 int osize = av_get_bits_per_sample_fmt(enc->sample_fmt) >> 3;
1726                                 int fs_tmp = enc->frame_size;
1727
1728                                 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1729                                 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1730                                     enc->frame_size = fifo_bytes / (osize * enc->channels);
1731                                 } else { /* pad */
1732                                     int frame_bytes = enc->frame_size*osize*enc->channels;
1733                                     if (allocated_audio_buf_size < frame_bytes)
1734                                         ffmpeg_exit(1);
1735                                     memset(audio_buf+fifo_bytes, 0, frame_bytes - fifo_bytes);
1736                                 }
1737
1738                                 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1739                                 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1740                                                           ost->st->time_base.num, enc->sample_rate);
1741                                 enc->frame_size = fs_tmp;
1742                             }
1743                             if(ret <= 0) {
1744                                 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1745                             }
1746                             if (ret < 0) {
1747                                 fprintf(stderr, "Audio encoding failed\n");
1748                                 ffmpeg_exit(1);
1749                             }
1750                             audio_size += ret;
1751                             pkt.flags |= AV_PKT_FLAG_KEY;
1752                             break;
1753                         case AVMEDIA_TYPE_VIDEO:
1754                             ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1755                             if (ret < 0) {
1756                                 fprintf(stderr, "Video encoding failed\n");
1757                                 ffmpeg_exit(1);
1758                             }
1759                             video_size += ret;
1760                             if(enc->coded_frame && enc->coded_frame->key_frame)
1761                                 pkt.flags |= AV_PKT_FLAG_KEY;
1762                             if (ost->logfile && enc->stats_out) {
1763                                 fprintf(ost->logfile, "%s", enc->stats_out);
1764                             }
1765                             break;
1766                         default:
1767                             ret=-1;
1768                         }
1769
1770                         if(ret<=0)
1771                             break;
1772                         pkt.data= bit_buffer;
1773                         pkt.size= ret;
1774                         if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1775                             pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1776                         write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1777                     }
1778                 }
1779             }
1780         }
1781     }
1782
1783     return 0;
1784  fail_decode:
1785     return -1;
1786 }
1787
1788 static void print_sdp(AVFormatContext **avc, int n)
1789 {
1790     char sdp[2048];
1791
1792     avf_sdp_create(avc, n, sdp, sizeof(sdp));
1793     printf("SDP:\n%s\n", sdp);
1794     fflush(stdout);
1795 }
1796
1797 static int copy_chapters(int infile, int outfile)
1798 {
1799     AVFormatContext *is = input_files[infile];
1800     AVFormatContext *os = output_files[outfile];
1801     int i;
1802
1803     for (i = 0; i < is->nb_chapters; i++) {
1804         AVChapter *in_ch = is->chapters[i], *out_ch;
1805         int64_t ts_off   = av_rescale_q(start_time - input_files_ts_offset[infile],
1806                                       AV_TIME_BASE_Q, in_ch->time_base);
1807         int64_t rt       = (recording_time == INT64_MAX) ? INT64_MAX :
1808                            av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1809
1810
1811         if (in_ch->end < ts_off)
1812             continue;
1813         if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1814             break;
1815
1816         out_ch = av_mallocz(sizeof(AVChapter));
1817         if (!out_ch)
1818             return AVERROR(ENOMEM);
1819
1820         out_ch->id        = in_ch->id;
1821         out_ch->time_base = in_ch->time_base;
1822         out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1823         out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1824
1825         if (metadata_chapters_autocopy)
1826             av_metadata_copy(&out_ch->metadata, in_ch->metadata, 0);
1827
1828         os->nb_chapters++;
1829         os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1830         if (!os->chapters)
1831             return AVERROR(ENOMEM);
1832         os->chapters[os->nb_chapters - 1] = out_ch;
1833     }
1834     return 0;
1835 }
1836
1837 static void parse_forced_key_frames(char *kf, AVOutputStream *ost,
1838                                     AVCodecContext *avctx)
1839 {
1840     char *p;
1841     int n = 1, i;
1842     int64_t t;
1843
1844     for (p = kf; *p; p++)
1845         if (*p == ',')
1846             n++;
1847     ost->forced_kf_count = n;
1848     ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
1849     if (!ost->forced_kf_pts) {
1850         av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
1851         ffmpeg_exit(1);
1852     }
1853     for (i = 0; i < n; i++) {
1854         p = i ? strchr(p, ',') + 1 : kf;
1855         t = parse_time_or_die("force_key_frames", p, 1);
1856         ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
1857     }
1858 }
1859
1860 /*
1861  * The following code is the main loop of the file converter
1862  */
1863 static int transcode(AVFormatContext **output_files,
1864                      int nb_output_files,
1865                      AVFormatContext **input_files,
1866                      int nb_input_files,
1867                      AVStreamMap *stream_maps, int nb_stream_maps)
1868 {
1869     int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1870     AVFormatContext *is, *os;
1871     AVCodecContext *codec, *icodec;
1872     AVOutputStream *ost, **ost_table = NULL;
1873     AVInputStream *ist, **ist_table = NULL;
1874     AVInputFile *file_table;
1875     char error[1024];
1876     int key;
1877     int want_sdp = 1;
1878     uint8_t no_packet[MAX_FILES]={0};
1879     int no_packet_count=0;
1880
1881     file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1882     if (!file_table)
1883         goto fail;
1884
1885     /* input stream init */
1886     j = 0;
1887     for(i=0;i<nb_input_files;i++) {
1888         is = input_files[i];
1889         file_table[i].ist_index = j;
1890         file_table[i].nb_streams = is->nb_streams;
1891         j += is->nb_streams;
1892     }
1893     nb_istreams = j;
1894
1895     ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1896     if (!ist_table)
1897         goto fail;
1898
1899     for(i=0;i<nb_istreams;i++) {
1900         ist = av_mallocz(sizeof(AVInputStream));
1901         if (!ist)
1902             goto fail;
1903         ist_table[i] = ist;
1904     }
1905     j = 0;
1906     for(i=0;i<nb_input_files;i++) {
1907         is = input_files[i];
1908         for(k=0;k<is->nb_streams;k++) {
1909             ist = ist_table[j++];
1910             ist->st = is->streams[k];
1911             ist->file_index = i;
1912             ist->index = k;
1913             ist->discard = 1; /* the stream is discarded by default
1914                                  (changed later) */
1915
1916             if (rate_emu) {
1917                 ist->start = av_gettime();
1918             }
1919         }
1920     }
1921
1922     /* output stream init */
1923     nb_ostreams = 0;
1924     for(i=0;i<nb_output_files;i++) {
1925         os = output_files[i];
1926         if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
1927             av_dump_format(output_files[i], i, output_files[i]->filename, 1);
1928             fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1929             ret = AVERROR(EINVAL);
1930             goto fail;
1931         }
1932         nb_ostreams += os->nb_streams;
1933     }
1934     if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1935         fprintf(stderr, "Number of stream maps must match number of output streams\n");
1936         ret = AVERROR(EINVAL);
1937         goto fail;
1938     }
1939
1940     /* Sanity check the mapping args -- do the input files & streams exist? */
1941     for(i=0;i<nb_stream_maps;i++) {
1942         int fi = stream_maps[i].file_index;
1943         int si = stream_maps[i].stream_index;
1944
1945         if (fi < 0 || fi > nb_input_files - 1 ||
1946             si < 0 || si > file_table[fi].nb_streams - 1) {
1947             fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1948             ret = AVERROR(EINVAL);
1949             goto fail;
1950         }
1951         fi = stream_maps[i].sync_file_index;
1952         si = stream_maps[i].sync_stream_index;
1953         if (fi < 0 || fi > nb_input_files - 1 ||
1954             si < 0 || si > file_table[fi].nb_streams - 1) {
1955             fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1956             ret = AVERROR(EINVAL);
1957             goto fail;
1958         }
1959     }
1960
1961     ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1962     if (!ost_table)
1963         goto fail;
1964     n = 0;
1965     for(k=0;k<nb_output_files;k++) {
1966         os = output_files[k];
1967         for(i=0;i<os->nb_streams;i++,n++) {
1968             int found;
1969             ost = ost_table[n] = output_streams_for_file[k][i];
1970             ost->st = os->streams[i];
1971             if (nb_stream_maps > 0) {
1972                 ost->source_index = file_table[stream_maps[n].file_index].ist_index +
1973                     stream_maps[n].stream_index;
1974
1975                 /* Sanity check that the stream types match */
1976                 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1977                     int i= ost->file_index;
1978                     av_dump_format(output_files[i], i, output_files[i]->filename, 1);
1979                     fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1980                         stream_maps[n].file_index, stream_maps[n].stream_index,
1981                         ost->file_index, ost->index);
1982                     ffmpeg_exit(1);
1983                 }
1984
1985             } else {
1986                 int best_nb_frames=-1;
1987                 /* get corresponding input stream index : we select the first one with the right type */
1988                 found = 0;
1989                 for(j=0;j<nb_istreams;j++) {
1990                     int skip=0;
1991                     ist = ist_table[j];
1992                     if(opt_programid){
1993                         int pi,si;
1994                         AVFormatContext *f= input_files[ ist->file_index ];
1995                         skip=1;
1996                         for(pi=0; pi<f->nb_programs; pi++){
1997                             AVProgram *p= f->programs[pi];
1998                             if(p->id == opt_programid)
1999                                 for(si=0; si<p->nb_stream_indexes; si++){
2000                                     if(f->streams[ p->stream_index[si] ] == ist->st)
2001                                         skip=0;
2002                                 }
2003                         }
2004                     }
2005                     if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
2006                         ist->st->codec->codec_type == ost->st->codec->codec_type) {
2007                         if(best_nb_frames < ist->st->codec_info_nb_frames){
2008                             best_nb_frames= ist->st->codec_info_nb_frames;
2009                             ost->source_index = j;
2010                             found = 1;
2011                         }
2012                     }
2013                 }
2014
2015                 if (!found) {
2016                     if(! opt_programid) {
2017                         /* try again and reuse existing stream */
2018                         for(j=0;j<nb_istreams;j++) {
2019                             ist = ist_table[j];
2020                             if (   ist->st->codec->codec_type == ost->st->codec->codec_type
2021                                 && ist->st->discard != AVDISCARD_ALL) {
2022                                 ost->source_index = j;
2023                                 found = 1;
2024                             }
2025                         }
2026                     }
2027                     if (!found) {
2028                         int i= ost->file_index;
2029                         av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2030                         fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
2031                                 ost->file_index, ost->index);
2032                         ffmpeg_exit(1);
2033                     }
2034                 }
2035             }
2036             ist = ist_table[ost->source_index];
2037             ist->discard = 0;
2038             ost->sync_ist = (nb_stream_maps > 0) ?
2039                 ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
2040                          stream_maps[n].sync_stream_index] : ist;
2041         }
2042     }
2043
2044     /* for each output stream, we compute the right encoding parameters */
2045     for(i=0;i<nb_ostreams;i++) {
2046         ost = ost_table[i];
2047         os = output_files[ost->file_index];
2048         ist = ist_table[ost->source_index];
2049
2050         codec = ost->st->codec;
2051         icodec = ist->st->codec;
2052
2053         if (metadata_streams_autocopy)
2054             av_metadata_copy(&ost->st->metadata, ist->st->metadata,
2055                              AV_METADATA_DONT_OVERWRITE);
2056
2057         ost->st->disposition = ist->st->disposition;
2058         codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2059         codec->chroma_sample_location = icodec->chroma_sample_location;
2060
2061         if (ost->st->stream_copy) {
2062             uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2063
2064             if (extra_size > INT_MAX)
2065                 goto fail;
2066
2067             /* if stream_copy is selected, no need to decode or encode */
2068             codec->codec_id = icodec->codec_id;
2069             codec->codec_type = icodec->codec_type;
2070
2071             if(!codec->codec_tag){
2072                 if(   !os->oformat->codec_tag
2073                    || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2074                    || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2075                     codec->codec_tag = icodec->codec_tag;
2076             }
2077
2078             codec->bit_rate = icodec->bit_rate;
2079             codec->rc_max_rate    = icodec->rc_max_rate;
2080             codec->rc_buffer_size = icodec->rc_buffer_size;
2081             codec->extradata= av_mallocz(extra_size);
2082             if (!codec->extradata)
2083                 goto fail;
2084             memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2085             codec->extradata_size= icodec->extradata_size;
2086             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){
2087                 codec->time_base = icodec->time_base;
2088                 codec->time_base.num *= icodec->ticks_per_frame;
2089                 av_reduce(&codec->time_base.num, &codec->time_base.den,
2090                           codec->time_base.num, codec->time_base.den, INT_MAX);
2091             }else
2092                 codec->time_base = ist->st->time_base;
2093             switch(codec->codec_type) {
2094             case AVMEDIA_TYPE_AUDIO:
2095                 if(audio_volume != 256) {
2096                     fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2097                     ffmpeg_exit(1);
2098                 }
2099                 codec->channel_layout = icodec->channel_layout;
2100                 codec->sample_rate = icodec->sample_rate;
2101                 codec->channels = icodec->channels;
2102                 codec->frame_size = icodec->frame_size;
2103                 codec->audio_service_type = icodec->audio_service_type;
2104                 codec->block_align= icodec->block_align;
2105                 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2106                     codec->block_align= 0;
2107                 if(codec->codec_id == CODEC_ID_AC3)
2108                     codec->block_align= 0;
2109                 break;
2110             case AVMEDIA_TYPE_VIDEO:
2111                 codec->pix_fmt = icodec->pix_fmt;
2112                 codec->width = icodec->width;
2113                 codec->height = icodec->height;
2114                 codec->has_b_frames = icodec->has_b_frames;
2115                 break;
2116             case AVMEDIA_TYPE_SUBTITLE:
2117                 codec->width = icodec->width;
2118                 codec->height = icodec->height;
2119                 break;
2120             default:
2121                 abort();
2122             }
2123         } else {
2124             switch(codec->codec_type) {
2125             case AVMEDIA_TYPE_AUDIO:
2126                 ost->fifo= av_fifo_alloc(1024);
2127                 if(!ost->fifo)
2128                     goto fail;
2129                 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2130                 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2131                 icodec->request_channels = codec->channels;
2132                 ist->decoding_needed = 1;
2133                 ost->encoding_needed = 1;
2134                 ost->resample_sample_fmt  = icodec->sample_fmt;
2135                 ost->resample_sample_rate = icodec->sample_rate;
2136                 ost->resample_channels    = icodec->channels;
2137                 break;
2138             case AVMEDIA_TYPE_VIDEO:
2139                 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2140                     fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2141                     ffmpeg_exit(1);
2142                 }
2143                 ost->video_resample = (codec->width != icodec->width   ||
2144                                        codec->height != icodec->height ||
2145                         (codec->pix_fmt != icodec->pix_fmt));
2146                 if (ost->video_resample) {
2147 #if !CONFIG_AVFILTER
2148                     avcodec_get_frame_defaults(&ost->pict_tmp);
2149                     if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2150                                          codec->width, codec->height)) {
2151                         fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
2152                         ffmpeg_exit(1);
2153                     }
2154                     sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
2155                     ost->img_resample_ctx = sws_getContext(
2156                         icodec->width,
2157                         icodec->height,
2158                             icodec->pix_fmt,
2159                             codec->width,
2160                             codec->height,
2161                             codec->pix_fmt,
2162                             sws_flags, NULL, NULL, NULL);
2163                     if (ost->img_resample_ctx == NULL) {
2164                         fprintf(stderr, "Cannot get resampling context\n");
2165                         ffmpeg_exit(1);
2166                     }
2167
2168                     ost->original_height = icodec->height;
2169                     ost->original_width  = icodec->width;
2170 #endif
2171                     codec->bits_per_raw_sample= 0;
2172                 }
2173                 ost->resample_height = icodec->height;
2174                 ost->resample_width  = icodec->width;
2175                 ost->resample_pix_fmt= icodec->pix_fmt;
2176                 ost->encoding_needed = 1;
2177                 ist->decoding_needed = 1;
2178
2179 #if CONFIG_AVFILTER
2180                 if (configure_filters(ist, ost)) {
2181                     fprintf(stderr, "Error opening filters!\n");
2182                     exit(1);
2183                 }
2184 #endif
2185                 break;
2186             case AVMEDIA_TYPE_SUBTITLE:
2187                 ost->encoding_needed = 1;
2188                 ist->decoding_needed = 1;
2189                 break;
2190             default:
2191                 abort();
2192                 break;
2193             }
2194             /* two pass mode */
2195             if (ost->encoding_needed &&
2196                 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2197                 char logfilename[1024];
2198                 FILE *f;
2199
2200                 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2201                          pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2202                          i);
2203                 if (codec->flags & CODEC_FLAG_PASS1) {
2204                     f = fopen(logfilename, "wb");
2205                     if (!f) {
2206                         fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2207                         ffmpeg_exit(1);
2208                     }
2209                     ost->logfile = f;
2210                 } else {
2211                     char  *logbuffer;
2212                     size_t logbuffer_size;
2213                     if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2214                         fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2215                         ffmpeg_exit(1);
2216                     }
2217                     codec->stats_in = logbuffer;
2218                 }
2219             }
2220         }
2221         if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2222             int size= codec->width * codec->height;
2223             bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2224         }
2225     }
2226
2227     if (!bit_buffer)
2228         bit_buffer = av_malloc(bit_buffer_size);
2229     if (!bit_buffer) {
2230         fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2231                 bit_buffer_size);
2232         ret = AVERROR(ENOMEM);
2233         goto fail;
2234     }
2235
2236     /* open each encoder */
2237     for(i=0;i<nb_ostreams;i++) {
2238         ost = ost_table[i];
2239         if (ost->encoding_needed) {
2240             AVCodec *codec = i < nb_output_codecs ? output_codecs[i] : NULL;
2241             AVCodecContext *dec = ist_table[ost->source_index]->st->codec;
2242             if (!codec)
2243                 codec = avcodec_find_encoder(ost->st->codec->codec_id);
2244             if (!codec) {
2245                 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2246                          ost->st->codec->codec_id, ost->file_index, ost->index);
2247                 ret = AVERROR(EINVAL);
2248                 goto dump_format;
2249             }
2250             if (dec->subtitle_header) {
2251                 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2252                 if (!ost->st->codec->subtitle_header) {
2253                     ret = AVERROR(ENOMEM);
2254                     goto dump_format;
2255                 }
2256                 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2257                 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2258             }
2259             if (avcodec_open(ost->st->codec, codec) < 0) {
2260                 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2261                         ost->file_index, ost->index);
2262                 ret = AVERROR(EINVAL);
2263                 goto dump_format;
2264             }
2265             extra_size += ost->st->codec->extradata_size;
2266         }
2267     }
2268
2269     /* open each decoder */
2270     for(i=0;i<nb_istreams;i++) {
2271         ist = ist_table[i];
2272         if (ist->decoding_needed) {
2273             AVCodec *codec = i < nb_input_codecs ? input_codecs[i] : NULL;
2274             if (!codec)
2275                 codec = avcodec_find_decoder(ist->st->codec->codec_id);
2276             if (!codec) {
2277                 snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2278                         ist->st->codec->codec_id, ist->file_index, ist->index);
2279                 ret = AVERROR(EINVAL);
2280                 goto dump_format;
2281             }
2282             if (avcodec_open(ist->st->codec, codec) < 0) {
2283                 snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2284                         ist->file_index, ist->index);
2285                 ret = AVERROR(EINVAL);
2286                 goto dump_format;
2287             }
2288             //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2289             //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2290         }
2291     }
2292
2293     /* init pts */
2294     for(i=0;i<nb_istreams;i++) {
2295         AVStream *st;
2296         ist = ist_table[i];
2297         st= ist->st;
2298         ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2299         ist->next_pts = AV_NOPTS_VALUE;
2300         init_pts_correction(&ist->pts_ctx);
2301         ist->is_start = 1;
2302     }
2303
2304     /* set meta data information from input file if required */
2305     for (i=0;i<nb_meta_data_maps;i++) {
2306         AVFormatContext *files[2];
2307         AVMetadata      **meta[2];
2308         int j;
2309
2310 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
2311         if ((index) < 0 || (index) >= (nb_elems)) {\
2312             snprintf(error, sizeof(error), "Invalid %s index %d while processing metadata maps\n",\
2313                      (desc), (index));\
2314             ret = AVERROR(EINVAL);\
2315             goto dump_format;\
2316         }
2317
2318         int out_file_index = meta_data_maps[i][0].file;
2319         int in_file_index = meta_data_maps[i][1].file;
2320         if (in_file_index < 0 || out_file_index < 0)
2321             continue;
2322         METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2323         METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2324
2325         files[0] = output_files[out_file_index];
2326         files[1] = input_files[in_file_index];
2327
2328         for (j = 0; j < 2; j++) {
2329             AVMetaDataMap *map = &meta_data_maps[i][j];
2330
2331             switch (map->type) {
2332             case 'g':
2333                 meta[j] = &files[j]->metadata;
2334                 break;
2335             case 's':
2336                 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
2337                 meta[j] = &files[j]->streams[map->index]->metadata;
2338                 break;
2339             case 'c':
2340                 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
2341                 meta[j] = &files[j]->chapters[map->index]->metadata;
2342                 break;
2343             case 'p':
2344                 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
2345                 meta[j] = &files[j]->programs[map->index]->metadata;
2346                 break;
2347             }
2348         }
2349
2350         av_metadata_copy(meta[0], *meta[1], AV_METADATA_DONT_OVERWRITE);
2351     }
2352
2353     /* copy global metadata by default */
2354     if (metadata_global_autocopy) {
2355
2356         for (i = 0; i < nb_output_files; i++)
2357             av_metadata_copy(&output_files[i]->metadata, input_files[0]->metadata,
2358                              AV_METADATA_DONT_OVERWRITE);
2359     }
2360
2361     /* copy chapters according to chapter maps */
2362     for (i = 0; i < nb_chapter_maps; i++) {
2363         int infile  = chapter_maps[i].in_file;
2364         int outfile = chapter_maps[i].out_file;
2365
2366         if (infile < 0 || outfile < 0)
2367             continue;
2368         if (infile >= nb_input_files) {
2369             snprintf(error, sizeof(error), "Invalid input file index %d in chapter mapping.\n", infile);
2370             ret = AVERROR(EINVAL);
2371             goto dump_format;
2372         }
2373         if (outfile >= nb_output_files) {
2374             snprintf(error, sizeof(error), "Invalid output file index %d in chapter mapping.\n",outfile);
2375             ret = AVERROR(EINVAL);
2376             goto dump_format;
2377         }
2378         copy_chapters(infile, outfile);
2379     }
2380
2381     /* copy chapters from the first input file that has them*/
2382     if (!nb_chapter_maps)
2383         for (i = 0; i < nb_input_files; i++) {
2384             if (!input_files[i]->nb_chapters)
2385                 continue;
2386
2387             for (j = 0; j < nb_output_files; j++)
2388                 if ((ret = copy_chapters(i, j)) < 0)
2389                     goto dump_format;
2390             break;
2391         }
2392
2393     /* open files and write file headers */
2394     for(i=0;i<nb_output_files;i++) {
2395         os = output_files[i];
2396         if (av_write_header(os) < 0) {
2397             snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2398             ret = AVERROR(EINVAL);
2399             goto dump_format;
2400         }
2401         if (strcmp(output_files[i]->oformat->name, "rtp")) {
2402             want_sdp = 0;
2403         }
2404     }
2405
2406  dump_format:
2407     /* dump the file output parameters - cannot be done before in case
2408        of stream copy */
2409     for(i=0;i<nb_output_files;i++) {
2410         av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2411     }
2412
2413     /* dump the stream mapping */
2414     if (verbose >= 0) {
2415         fprintf(stderr, "Stream mapping:\n");
2416         for(i=0;i<nb_ostreams;i++) {
2417             ost = ost_table[i];
2418             fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
2419                     ist_table[ost->source_index]->file_index,
2420                     ist_table[ost->source_index]->index,
2421                     ost->file_index,
2422                     ost->index);
2423             if (ost->sync_ist != ist_table[ost->source_index])
2424                 fprintf(stderr, " [sync #%d.%d]",
2425                         ost->sync_ist->file_index,
2426                         ost->sync_ist->index);
2427             fprintf(stderr, "\n");
2428         }
2429     }
2430
2431     if (ret) {
2432         fprintf(stderr, "%s\n", error);
2433         goto fail;
2434     }
2435
2436     if (want_sdp) {
2437         print_sdp(output_files, nb_output_files);
2438     }
2439
2440     if (!using_stdin && verbose >= 0) {
2441 #if HAVE_KBHIT
2442         fprintf(stderr, "Press [q] to stop encoding\n");
2443 #else
2444         fprintf(stderr, "Press ctrl-c to stop encoding\n");
2445 #endif
2446         url_set_interrupt_cb(decode_interrupt_cb);
2447     }
2448     term_init();
2449
2450     timer_start = av_gettime();
2451
2452     for(; received_sigterm == 0;) {
2453         int file_index, ist_index;
2454         AVPacket pkt;
2455         double ipts_min;
2456         double opts_min;
2457
2458     redo:
2459         ipts_min= 1e100;
2460         opts_min= 1e100;
2461         /* if 'q' pressed, exits */
2462         if (!using_stdin) {
2463             if (q_pressed)
2464                 break;
2465             /* read_key() returns 0 on EOF */
2466             key = read_key();
2467             if (key == 'q')
2468                 break;
2469         }
2470
2471         /* select the stream that we must read now by looking at the
2472            smallest output pts */
2473         file_index = -1;
2474         for(i=0;i<nb_ostreams;i++) {
2475             double ipts, opts;
2476             ost = ost_table[i];
2477             os = output_files[ost->file_index];
2478             ist = ist_table[ost->source_index];
2479             if(ist->is_past_recording_time || no_packet[ist->file_index])
2480                 continue;
2481                 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2482             ipts = (double)ist->pts;
2483             if (!file_table[ist->file_index].eof_reached){
2484                 if(ipts < ipts_min) {
2485                     ipts_min = ipts;
2486                     if(input_sync ) file_index = ist->file_index;
2487                 }
2488                 if(opts < opts_min) {
2489                     opts_min = opts;
2490                     if(!input_sync) file_index = ist->file_index;
2491                 }
2492             }
2493             if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2494                 file_index= -1;
2495                 break;
2496             }
2497         }
2498         /* if none, if is finished */
2499         if (file_index < 0) {
2500             if(no_packet_count){
2501                 no_packet_count=0;
2502                 memset(no_packet, 0, sizeof(no_packet));
2503                 usleep(10000);
2504                 continue;
2505             }
2506             break;
2507         }
2508
2509         /* finish if limit size exhausted */
2510         if (limit_filesize != 0 && limit_filesize <= avio_tell(output_files[0]->pb))
2511             break;
2512
2513         /* read a frame from it and output it in the fifo */
2514         is = input_files[file_index];
2515         ret= av_read_frame(is, &pkt);
2516         if(ret == AVERROR(EAGAIN)){
2517             no_packet[file_index]=1;
2518             no_packet_count++;
2519             continue;
2520         }
2521         if (ret < 0) {
2522             file_table[file_index].eof_reached = 1;
2523             if (opt_shortest)
2524                 break;
2525             else
2526                 continue;
2527         }
2528
2529         no_packet_count=0;
2530         memset(no_packet, 0, sizeof(no_packet));
2531
2532         if (do_pkt_dump) {
2533             av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2534                              is->streams[pkt.stream_index]);
2535         }
2536         /* the following test is needed in case new streams appear
2537            dynamically in stream : we ignore them */
2538         if (pkt.stream_index >= file_table[file_index].nb_streams)
2539             goto discard_packet;
2540         ist_index = file_table[file_index].ist_index + pkt.stream_index;
2541         ist = ist_table[ist_index];
2542         if (ist->discard)
2543             goto discard_packet;
2544
2545         if (pkt.dts != AV_NOPTS_VALUE)
2546             pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2547         if (pkt.pts != AV_NOPTS_VALUE)
2548             pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2549
2550         if (pkt.stream_index < nb_input_files_ts_scale[file_index]
2551             && input_files_ts_scale[file_index][pkt.stream_index]){
2552             if(pkt.pts != AV_NOPTS_VALUE)
2553                 pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2554             if(pkt.dts != AV_NOPTS_VALUE)
2555                 pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2556         }
2557
2558 //        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);
2559         if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2560             && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2561             int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2562             int64_t delta= pkt_dts - ist->next_pts;
2563             if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2564                 input_files_ts_offset[ist->file_index]-= delta;
2565                 if (verbose > 2)
2566                     fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2567                 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2568                 if(pkt.pts != AV_NOPTS_VALUE)
2569                     pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2570             }
2571         }
2572
2573         /* finish if recording time exhausted */
2574         if (recording_time != INT64_MAX &&
2575             av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2576             ist->is_past_recording_time = 1;
2577             goto discard_packet;
2578         }
2579
2580         //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
2581         if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2582
2583             if (verbose >= 0)
2584                 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2585                         ist->file_index, ist->index);
2586             if (exit_on_error)
2587                 ffmpeg_exit(1);
2588             av_free_packet(&pkt);
2589             goto redo;
2590         }
2591
2592     discard_packet:
2593         av_free_packet(&pkt);
2594
2595         /* dump report by using the output first video and audio streams */
2596         print_report(output_files, ost_table, nb_ostreams, 0);
2597     }
2598
2599     /* at the end of stream, we must flush the decoder buffers */
2600     for(i=0;i<nb_istreams;i++) {
2601         ist = ist_table[i];
2602         if (ist->decoding_needed) {
2603             output_packet(ist, i, ost_table, nb_ostreams, NULL);
2604         }
2605     }
2606
2607     term_exit();
2608
2609     /* write the trailer if needed and close file */
2610     for(i=0;i<nb_output_files;i++) {
2611         os = output_files[i];
2612         av_write_trailer(os);
2613     }
2614
2615     /* dump report by using the first video and audio streams */
2616     print_report(output_files, ost_table, nb_ostreams, 1);
2617
2618     /* close each encoder */
2619     for(i=0;i<nb_ostreams;i++) {
2620         ost = ost_table[i];
2621         if (ost->encoding_needed) {
2622             av_freep(&ost->st->codec->stats_in);
2623             avcodec_close(ost->st->codec);
2624         }
2625     }
2626
2627     /* close each decoder */
2628     for(i=0;i<nb_istreams;i++) {
2629         ist = ist_table[i];
2630         if (ist->decoding_needed) {
2631             avcodec_close(ist->st->codec);
2632         }
2633     }
2634 #if CONFIG_AVFILTER
2635     avfilter_graph_free(&graph);
2636 #endif
2637
2638     /* finished ! */
2639     ret = 0;
2640
2641  fail:
2642     av_freep(&bit_buffer);
2643     av_free(file_table);
2644
2645     if (ist_table) {
2646         for(i=0;i<nb_istreams;i++) {
2647             ist = ist_table[i];
2648             av_free(ist);
2649         }
2650         av_free(ist_table);
2651     }
2652     if (ost_table) {
2653         for(i=0;i<nb_ostreams;i++) {
2654             ost = ost_table[i];
2655             if (ost) {
2656                 if (ost->st->stream_copy)
2657                     av_freep(&ost->st->codec->extradata);
2658                 if (ost->logfile) {
2659                     fclose(ost->logfile);
2660                     ost->logfile = NULL;
2661                 }
2662                 av_fifo_free(ost->fifo); /* works even if fifo is not
2663                                              initialized but set to zero */
2664                 av_freep(&ost->st->codec->subtitle_header);
2665                 av_free(ost->pict_tmp.data[0]);
2666                 av_free(ost->forced_kf_pts);
2667                 if (ost->video_resample)
2668                     sws_freeContext(ost->img_resample_ctx);
2669                 if (ost->resample)
2670                     audio_resample_close(ost->resample);
2671                 if (ost->reformat_ctx)
2672                     av_audio_convert_free(ost->reformat_ctx);
2673                 av_free(ost);
2674             }
2675         }
2676         av_free(ost_table);
2677     }
2678     return ret;
2679 }
2680
2681 static void opt_format(const char *arg)
2682 {
2683     last_asked_format = arg;
2684 }
2685
2686 static void opt_video_rc_override_string(const char *arg)
2687 {
2688     video_rc_override_string = arg;
2689 }
2690
2691 static int opt_me_threshold(const char *opt, const char *arg)
2692 {
2693     me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2694     return 0;
2695 }
2696
2697 static int opt_verbose(const char *opt, const char *arg)
2698 {
2699     verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2700     return 0;
2701 }
2702
2703 static int opt_frame_rate(const char *opt, const char *arg)
2704 {
2705     if (av_parse_video_rate(&frame_rate, arg) < 0) {
2706         fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2707         ffmpeg_exit(1);
2708     }
2709     return 0;
2710 }
2711
2712 static int opt_bitrate(const char *opt, const char *arg)
2713 {
2714     int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2715
2716     opt_default(opt, arg);
2717
2718     if (av_get_int(avcodec_opts[codec_type], "b", NULL) < 1000)
2719         fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2720
2721     return 0;
2722 }
2723
2724 static int opt_frame_crop(const char *opt, const char *arg)
2725 {
2726     fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2727     return AVERROR(EINVAL);
2728 }
2729
2730 static void opt_frame_size(const char *arg)
2731 {
2732     if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2733         fprintf(stderr, "Incorrect frame size\n");
2734         ffmpeg_exit(1);
2735     }
2736 }
2737
2738 static int opt_pad(const char *opt, const char *arg) {
2739     fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2740     return -1;
2741 }
2742
2743 static void opt_frame_pix_fmt(const char *arg)
2744 {
2745     if (strcmp(arg, "list")) {
2746         frame_pix_fmt = av_get_pix_fmt(arg);
2747         if (frame_pix_fmt == PIX_FMT_NONE) {
2748             fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2749             ffmpeg_exit(1);
2750         }
2751     } else {
2752         show_pix_fmts();
2753         ffmpeg_exit(0);
2754     }
2755 }
2756
2757 static void opt_frame_aspect_ratio(const char *arg)
2758 {
2759     int x = 0, y = 0;
2760     double ar = 0;
2761     const char *p;
2762     char *end;
2763
2764     p = strchr(arg, ':');
2765     if (p) {
2766         x = strtol(arg, &end, 10);
2767         if (end == p)
2768             y = strtol(end+1, &end, 10);
2769         if (x > 0 && y > 0)
2770             ar = (double)x / (double)y;
2771     } else
2772         ar = strtod(arg, NULL);
2773
2774     if (!ar) {
2775         fprintf(stderr, "Incorrect aspect ratio specification.\n");
2776         ffmpeg_exit(1);
2777     }
2778     frame_aspect_ratio = ar;
2779 }
2780
2781 static int opt_metadata(const char *opt, const char *arg)
2782 {
2783     char *mid= strchr(arg, '=');
2784
2785     if(!mid){
2786         fprintf(stderr, "Missing =\n");
2787         ffmpeg_exit(1);
2788     }
2789     *mid++= 0;
2790
2791     av_metadata_set2(&metadata, arg, mid, 0);
2792
2793     return 0;
2794 }
2795
2796 static void opt_qscale(const char *arg)
2797 {
2798     video_qscale = atof(arg);
2799     if (video_qscale <= 0 ||
2800         video_qscale > 255) {
2801         fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2802         ffmpeg_exit(1);
2803     }
2804 }
2805
2806 static void opt_top_field_first(const char *arg)
2807 {
2808     top_field_first= atoi(arg);
2809 }
2810
2811 static int opt_thread_count(const char *opt, const char *arg)
2812 {
2813     thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2814 #if !HAVE_THREADS
2815     if (verbose >= 0)
2816         fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2817 #endif
2818     return 0;
2819 }
2820
2821 static void opt_audio_sample_fmt(const char *arg)
2822 {
2823     if (strcmp(arg, "list")) {
2824         audio_sample_fmt = av_get_sample_fmt(arg);
2825         if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2826             av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2827             ffmpeg_exit(1);
2828         }
2829     } else {
2830         list_fmts(av_get_sample_fmt_string, AV_SAMPLE_FMT_NB);
2831         ffmpeg_exit(0);
2832     }
2833 }
2834
2835 static int opt_audio_rate(const char *opt, const char *arg)
2836 {
2837     audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2838     return 0;
2839 }
2840
2841 static int opt_audio_channels(const char *opt, const char *arg)
2842 {
2843     audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2844     return 0;
2845 }
2846
2847 static void opt_video_channel(const char *arg)
2848 {
2849     video_channel = strtol(arg, NULL, 0);
2850 }
2851
2852 static void opt_video_standard(const char *arg)
2853 {
2854     video_standard = av_strdup(arg);
2855 }
2856
2857 static void opt_codec(int *pstream_copy, char **pcodec_name,
2858                       int codec_type, const char *arg)
2859 {
2860     av_freep(pcodec_name);
2861     if (!strcmp(arg, "copy")) {
2862         *pstream_copy = 1;
2863     } else {
2864         *pcodec_name = av_strdup(arg);
2865     }
2866 }
2867
2868 static void opt_audio_codec(const char *arg)
2869 {
2870     opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2871 }
2872
2873 static void opt_video_codec(const char *arg)
2874 {
2875     opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2876 }
2877
2878 static void opt_subtitle_codec(const char *arg)
2879 {
2880     opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2881 }
2882
2883 static int opt_codec_tag(const char *opt, const char *arg)
2884 {
2885     char *tail;
2886     uint32_t *codec_tag;
2887
2888     codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2889                 !strcmp(opt, "vtag") ? &video_codec_tag :
2890                 !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2891     if (!codec_tag)
2892         return -1;
2893
2894     *codec_tag = strtol(arg, &tail, 0);
2895     if (!tail || *tail)
2896         *codec_tag = AV_RL32(arg);
2897
2898     return 0;
2899 }
2900
2901 static void opt_map(const char *arg)
2902 {
2903     AVStreamMap *m;
2904     char *p;
2905
2906     stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
2907     m = &stream_maps[nb_stream_maps-1];
2908
2909     m->file_index = strtol(arg, &p, 0);
2910     if (*p)
2911         p++;
2912
2913     m->stream_index = strtol(p, &p, 0);
2914     if (*p) {
2915         p++;
2916         m->sync_file_index = strtol(p, &p, 0);
2917         if (*p)
2918             p++;
2919         m->sync_stream_index = strtol(p, &p, 0);
2920     } else {
2921         m->sync_file_index = m->file_index;
2922         m->sync_stream_index = m->stream_index;
2923     }
2924 }
2925
2926 static void parse_meta_type(char *arg, char *type, int *index, char **endptr)
2927 {
2928     *endptr = arg;
2929     if (*arg == ',') {
2930         *type = *(++arg);
2931         switch (*arg) {
2932         case 'g':
2933             break;
2934         case 's':
2935         case 'c':
2936         case 'p':
2937             *index = strtol(++arg, endptr, 0);
2938             break;
2939         default:
2940             fprintf(stderr, "Invalid metadata type %c.\n", *arg);
2941             ffmpeg_exit(1);
2942         }
2943     } else
2944         *type = 'g';
2945 }
2946
2947 static void opt_map_metadata(const char *arg)
2948 {
2949     AVMetaDataMap *m, *m1;
2950     char *p;
2951
2952     meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
2953                                 &nb_meta_data_maps, nb_meta_data_maps + 1);
2954
2955     m = &meta_data_maps[nb_meta_data_maps - 1][0];
2956     m->file = strtol(arg, &p, 0);
2957     parse_meta_type(p, &m->type, &m->index, &p);
2958     if (*p)
2959         p++;
2960
2961     m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
2962     m1->file = strtol(p, &p, 0);
2963     parse_meta_type(p, &m1->type, &m1->index, &p);
2964
2965     if (m->type == 'g' || m1->type == 'g')
2966         metadata_global_autocopy = 0;
2967     if (m->type == 's' || m1->type == 's')
2968         metadata_streams_autocopy = 0;
2969     if (m->type == 'c' || m1->type == 'c')
2970         metadata_chapters_autocopy = 0;
2971 }
2972
2973 static void opt_map_meta_data(const char *arg)
2974 {
2975     fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "
2976                     "Use -map_metadata instead.\n");
2977     opt_map_metadata(arg);
2978 }
2979
2980 static void opt_map_chapters(const char *arg)
2981 {
2982     AVChapterMap *c;
2983     char *p;
2984
2985     chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
2986                               nb_chapter_maps + 1);
2987     c = &chapter_maps[nb_chapter_maps - 1];
2988     c->out_file = strtol(arg, &p, 0);
2989     if (*p)
2990         p++;
2991
2992     c->in_file = strtol(p, &p, 0);
2993 }
2994
2995 static void opt_input_ts_scale(const char *arg)
2996 {
2997     unsigned int stream;
2998     double scale;
2999     char *p;
3000
3001     stream = strtol(arg, &p, 0);
3002     if (*p)
3003         p++;
3004     scale= strtod(p, &p);
3005
3006     if(stream >= MAX_STREAMS)
3007         ffmpeg_exit(1);
3008
3009     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);
3010     input_files_ts_scale[nb_input_files][stream]= scale;
3011 }
3012
3013 static int opt_recording_time(const char *opt, const char *arg)
3014 {
3015     recording_time = parse_time_or_die(opt, arg, 1);
3016     return 0;
3017 }
3018
3019 static int opt_start_time(const char *opt, const char *arg)
3020 {
3021     start_time = parse_time_or_die(opt, arg, 1);
3022     return 0;
3023 }
3024
3025 static int opt_recording_timestamp(const char *opt, const char *arg)
3026 {
3027     recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
3028     return 0;
3029 }
3030
3031 static int opt_input_ts_offset(const char *opt, const char *arg)
3032 {
3033     input_ts_offset = parse_time_or_die(opt, arg, 1);
3034     return 0;
3035 }
3036
3037 static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3038 {
3039     const char *codec_string = encoder ? "encoder" : "decoder";
3040     AVCodec *codec;
3041
3042     if(!name)
3043         return CODEC_ID_NONE;
3044     codec = encoder ?
3045         avcodec_find_encoder_by_name(name) :
3046         avcodec_find_decoder_by_name(name);
3047     if(!codec) {
3048         fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3049         ffmpeg_exit(1);
3050     }
3051     if(codec->type != type) {
3052         fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3053         ffmpeg_exit(1);
3054     }
3055     if(codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
3056        strict > FF_COMPLIANCE_EXPERIMENTAL) {
3057         fprintf(stderr, "%s '%s' is experimental and might produce bad "
3058                 "results.\nAdd '-strict experimental' if you want to use it.\n",
3059                 codec_string, codec->name);
3060         codec = encoder ?
3061             avcodec_find_encoder(codec->id) :
3062             avcodec_find_decoder(codec->id);
3063         if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
3064             fprintf(stderr, "Or use the non experimental %s '%s'.\n",
3065                     codec_string, codec->name);
3066         ffmpeg_exit(1);
3067     }
3068     return codec->id;
3069 }
3070
3071 static void opt_input_file(const char *filename)
3072 {
3073     AVFormatContext *ic;
3074     AVFormatParameters params, *ap = &params;
3075     AVInputFormat *file_iformat = NULL;
3076     int err, i, ret, rfps, rfps_base;
3077     int64_t timestamp;
3078
3079     if (last_asked_format) {
3080         if (!(file_iformat = av_find_input_format(last_asked_format))) {
3081             fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3082             ffmpeg_exit(1);
3083         }
3084         last_asked_format = NULL;
3085     }
3086
3087     if (!strcmp(filename, "-"))
3088         filename = "pipe:";
3089
3090     using_stdin |= !strncmp(filename, "pipe:", 5) ||
3091                     !strcmp(filename, "/dev/stdin");
3092
3093     /* get default parameters from command line */
3094     ic = avformat_alloc_context();
3095     if (!ic) {
3096         print_error(filename, AVERROR(ENOMEM));
3097         ffmpeg_exit(1);
3098     }
3099
3100     memset(ap, 0, sizeof(*ap));
3101     ap->prealloced_context = 1;
3102     ap->sample_rate = audio_sample_rate;
3103     ap->channels = audio_channels;
3104     ap->time_base.den = frame_rate.num;
3105     ap->time_base.num = frame_rate.den;
3106     ap->width = frame_width;
3107     ap->height = frame_height;
3108     ap->pix_fmt = frame_pix_fmt;
3109    // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
3110     ap->channel = video_channel;
3111     ap->standard = video_standard;
3112
3113     set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3114
3115     ic->video_codec_id   =
3116         find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0,
3117                           avcodec_opts[AVMEDIA_TYPE_VIDEO   ]->strict_std_compliance);
3118     ic->audio_codec_id   =
3119         find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0,
3120                           avcodec_opts[AVMEDIA_TYPE_AUDIO   ]->strict_std_compliance);
3121     ic->subtitle_codec_id=
3122         find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
3123                           avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3124     ic->flags |= AVFMT_FLAG_NONBLOCK;
3125
3126     /* open the input file with generic libav function */
3127     err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
3128     if (err < 0) {
3129         print_error(filename, err);
3130         ffmpeg_exit(1);
3131     }
3132     if(opt_programid) {
3133         int i, j;
3134         int found=0;
3135         for(i=0; i<ic->nb_streams; i++){
3136             ic->streams[i]->discard= AVDISCARD_ALL;
3137         }
3138         for(i=0; i<ic->nb_programs; i++){
3139             AVProgram *p= ic->programs[i];
3140             if(p->id != opt_programid){
3141                 p->discard = AVDISCARD_ALL;
3142             }else{
3143                 found=1;
3144                 for(j=0; j<p->nb_stream_indexes; j++){
3145                     ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3146                 }
3147             }
3148         }
3149         if(!found){
3150             fprintf(stderr, "Specified program id not found\n");
3151             ffmpeg_exit(1);
3152         }
3153         opt_programid=0;
3154     }
3155
3156     ic->loop_input = loop_input;
3157
3158     /* If not enough info to get the stream parameters, we decode the
3159        first frames to get it. (used in mpeg case for example) */
3160     ret = av_find_stream_info(ic);
3161     if (ret < 0 && verbose >= 0) {
3162         fprintf(stderr, "%s: could not find codec parameters\n", filename);
3163         av_close_input_file(ic);
3164         ffmpeg_exit(1);
3165     }
3166
3167     timestamp = start_time;
3168     /* add the stream start time */
3169     if (ic->start_time != AV_NOPTS_VALUE)
3170         timestamp += ic->start_time;
3171
3172     /* if seeking requested, we execute it */
3173     if (start_time != 0) {
3174         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3175         if (ret < 0) {
3176             fprintf(stderr, "%s: could not seek to position %0.3f\n",
3177                     filename, (double)timestamp / AV_TIME_BASE);
3178         }
3179         /* reset seek info */
3180         start_time = 0;
3181     }
3182
3183     /* update the current parameters so that they match the one of the input stream */
3184     for(i=0;i<ic->nb_streams;i++) {
3185         AVStream *st = ic->streams[i];
3186         AVCodecContext *dec = st->codec;
3187         dec->thread_count = thread_count;
3188         input_codecs = grow_array(input_codecs, sizeof(*input_codecs), &nb_input_codecs, nb_input_codecs + 1);
3189         switch (dec->codec_type) {
3190         case AVMEDIA_TYPE_AUDIO:
3191             input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(audio_codec_name);
3192             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]);
3193             //fprintf(stderr, "\nInput Audio channels: %d", dec->channels);
3194             channel_layout    = dec->channel_layout;
3195             audio_channels    = dec->channels;
3196             audio_sample_rate = dec->sample_rate;
3197             audio_sample_fmt  = dec->sample_fmt;
3198             if(audio_disable)
3199                 st->discard= AVDISCARD_ALL;
3200             /* Note that av_find_stream_info can add more streams, and we
3201              * currently have no chance of setting up lowres decoding
3202              * early enough for them. */
3203             if (dec->lowres)
3204                 audio_sample_rate >>= dec->lowres;
3205             break;
3206         case AVMEDIA_TYPE_VIDEO:
3207             input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(video_codec_name);
3208             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]);
3209             frame_height = dec->height;
3210             frame_width  = dec->width;
3211             if(ic->streams[i]->sample_aspect_ratio.num)
3212                 frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
3213             else
3214                 frame_aspect_ratio=av_q2d(dec->sample_aspect_ratio);
3215             frame_aspect_ratio *= (float) dec->width / dec->height;
3216             frame_pix_fmt = dec->pix_fmt;
3217             rfps      = ic->streams[i]->r_frame_rate.num;
3218             rfps_base = ic->streams[i]->r_frame_rate.den;
3219             if (dec->lowres) {
3220                 dec->flags |= CODEC_FLAG_EMU_EDGE;
3221                 frame_height >>= dec->lowres;
3222                 frame_width  >>= dec->lowres;
3223                 dec->height = frame_height;
3224                 dec->width  = frame_width;
3225             }
3226             if(me_threshold)
3227                 dec->debug |= FF_DEBUG_MV;
3228
3229             if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3230
3231                 if (verbose >= 0)
3232                     fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3233                             i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3234
3235                     (float)rfps / rfps_base, rfps, rfps_base);
3236             }
3237             /* update the current frame rate to match the stream frame rate */
3238             frame_rate.num = rfps;
3239             frame_rate.den = rfps_base;
3240
3241             if(video_disable)
3242                 st->discard= AVDISCARD_ALL;
3243             else if(video_discard)
3244                 st->discard= video_discard;
3245             break;
3246         case AVMEDIA_TYPE_DATA:
3247             break;
3248         case AVMEDIA_TYPE_SUBTITLE:
3249             input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(subtitle_codec_name);
3250             if(subtitle_disable)
3251                 st->discard = AVDISCARD_ALL;
3252             break;
3253         case AVMEDIA_TYPE_ATTACHMENT:
3254         case AVMEDIA_TYPE_UNKNOWN:
3255             break;
3256         default:
3257             abort();
3258         }
3259     }
3260
3261     input_files[nb_input_files] = ic;
3262     input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3263     /* dump the file content */
3264     if (verbose >= 0)
3265         av_dump_format(ic, nb_input_files, filename, 0);
3266
3267     nb_input_files++;
3268
3269     video_channel = 0;
3270
3271     av_freep(&video_codec_name);
3272     av_freep(&audio_codec_name);
3273     av_freep(&subtitle_codec_name);
3274 }
3275
3276 static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3277                                          int *has_subtitle_ptr)
3278 {
3279     int has_video, has_audio, has_subtitle, i, j;
3280     AVFormatContext *ic;
3281
3282     has_video = 0;
3283     has_audio = 0;
3284     has_subtitle = 0;
3285     for(j=0;j<nb_input_files;j++) {
3286         ic = input_files[j];
3287         for(i=0;i<ic->nb_streams;i++) {
3288             AVCodecContext *enc = ic->streams[i]->codec;
3289             switch(enc->codec_type) {
3290             case AVMEDIA_TYPE_AUDIO:
3291                 has_audio = 1;
3292                 break;
3293             case AVMEDIA_TYPE_VIDEO:
3294                 has_video = 1;
3295                 break;
3296             case AVMEDIA_TYPE_SUBTITLE:
3297                 has_subtitle = 1;
3298                 break;
3299             case AVMEDIA_TYPE_DATA:
3300             case AVMEDIA_TYPE_ATTACHMENT:
3301             case AVMEDIA_TYPE_UNKNOWN:
3302                 break;
3303             default:
3304                 abort();
3305             }
3306         }
3307     }
3308     *has_video_ptr = has_video;
3309     *has_audio_ptr = has_audio;
3310     *has_subtitle_ptr = has_subtitle;
3311 }
3312
3313 static void new_video_stream(AVFormatContext *oc, int file_idx)
3314 {
3315     AVStream *st;
3316     AVOutputStream *ost;
3317     AVCodecContext *video_enc;
3318     enum CodecID codec_id = CODEC_ID_NONE;
3319     AVCodec *codec= NULL;
3320
3321     st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3322     if (!st) {
3323         fprintf(stderr, "Could not alloc stream\n");
3324         ffmpeg_exit(1);
3325     }
3326     ost = new_output_stream(oc, file_idx);
3327
3328     output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3329     if(!video_stream_copy){
3330         if (video_codec_name) {
3331             codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
3332                                          avcodec_opts[AVMEDIA_TYPE_VIDEO]->strict_std_compliance);
3333             codec = avcodec_find_encoder_by_name(video_codec_name);
3334             output_codecs[nb_output_codecs-1] = codec;
3335         } else {
3336             codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3337             codec = avcodec_find_encoder(codec_id);
3338         }
3339     }
3340
3341     avcodec_get_context_defaults3(st->codec, codec);
3342     ost->bitstream_filters = video_bitstream_filters;
3343     video_bitstream_filters= NULL;
3344
3345     st->codec->thread_count= thread_count;
3346
3347     video_enc = st->codec;
3348
3349     if(video_codec_tag)
3350         video_enc->codec_tag= video_codec_tag;
3351
3352     if(   (video_global_header&1)
3353        || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3354         video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3355         avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3356     }
3357     if(video_global_header&2){
3358         video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3359         avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3360     }
3361
3362     if (video_stream_copy) {
3363         st->stream_copy = 1;
3364         video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3365         video_enc->sample_aspect_ratio =
3366         st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3367     } else {
3368         const char *p;
3369         int i;
3370         AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3371
3372         video_enc->codec_id = codec_id;
3373         set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3374
3375         if (codec && codec->supported_framerates && !force_fps)
3376             fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3377         video_enc->time_base.den = fps.num;
3378         video_enc->time_base.num = fps.den;
3379
3380         video_enc->width = frame_width;
3381         video_enc->height = frame_height;
3382         video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3383         video_enc->pix_fmt = frame_pix_fmt;
3384         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3385
3386         choose_pixel_fmt(st, codec);
3387
3388         if (intra_only)
3389             video_enc->gop_size = 0;
3390         if (video_qscale || same_quality) {
3391             video_enc->flags |= CODEC_FLAG_QSCALE;
3392             video_enc->global_quality=
3393                 st->quality = FF_QP2LAMBDA * video_qscale;
3394         }
3395
3396         if(intra_matrix)
3397             video_enc->intra_matrix = intra_matrix;
3398         if(inter_matrix)
3399             video_enc->inter_matrix = inter_matrix;
3400
3401         p= video_rc_override_string;
3402         for(i=0; p; i++){
3403             int start, end, q;
3404             int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3405             if(e!=3){
3406                 fprintf(stderr, "error parsing rc_override\n");
3407                 ffmpeg_exit(1);
3408             }
3409             video_enc->rc_override=
3410                 av_realloc(video_enc->rc_override,
3411                            sizeof(RcOverride)*(i+1));
3412             video_enc->rc_override[i].start_frame= start;
3413             video_enc->rc_override[i].end_frame  = end;
3414             if(q>0){
3415                 video_enc->rc_override[i].qscale= q;
3416                 video_enc->rc_override[i].quality_factor= 1.0;
3417             }
3418             else{
3419                 video_enc->rc_override[i].qscale= 0;
3420                 video_enc->rc_override[i].quality_factor= -q/100.0;
3421             }
3422             p= strchr(p, '/');
3423             if(p) p++;
3424         }
3425         video_enc->rc_override_count=i;
3426         if (!video_enc->rc_initial_buffer_occupancy)
3427             video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3428         video_enc->me_threshold= me_threshold;
3429         video_enc->intra_dc_precision= intra_dc_precision - 8;
3430
3431         if (do_psnr)
3432             video_enc->flags|= CODEC_FLAG_PSNR;
3433
3434         /* two pass mode */
3435         if (do_pass) {
3436             if (do_pass == 1) {
3437                 video_enc->flags |= CODEC_FLAG_PASS1;
3438             } else {
3439                 video_enc->flags |= CODEC_FLAG_PASS2;
3440             }
3441         }
3442
3443         if (forced_key_frames)
3444             parse_forced_key_frames(forced_key_frames, ost, video_enc);
3445     }
3446     if (video_language) {
3447         av_metadata_set2(&st->metadata, "language", video_language, 0);
3448         av_freep(&video_language);
3449     }
3450
3451     /* reset some key parameters */
3452     video_disable = 0;
3453     av_freep(&video_codec_name);
3454     av_freep(&forced_key_frames);
3455     video_stream_copy = 0;
3456     frame_pix_fmt = PIX_FMT_NONE;
3457 }
3458
3459 static void new_audio_stream(AVFormatContext *oc, int file_idx)
3460 {
3461     AVStream *st;
3462     AVOutputStream *ost;
3463     AVCodec *codec= NULL;
3464     AVCodecContext *audio_enc;
3465     enum CodecID codec_id = CODEC_ID_NONE;
3466
3467     st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3468     if (!st) {
3469         fprintf(stderr, "Could not alloc stream\n");
3470         ffmpeg_exit(1);
3471     }
3472     ost = new_output_stream(oc, file_idx);
3473
3474     output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3475     if(!audio_stream_copy){
3476         if (audio_codec_name) {
3477             codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
3478                                          avcodec_opts[AVMEDIA_TYPE_AUDIO]->strict_std_compliance);
3479             codec = avcodec_find_encoder_by_name(audio_codec_name);
3480             output_codecs[nb_output_codecs-1] = codec;
3481         } else {
3482             codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3483             codec = avcodec_find_encoder(codec_id);
3484         }
3485     }
3486
3487     avcodec_get_context_defaults3(st->codec, codec);
3488
3489     ost->bitstream_filters = audio_bitstream_filters;
3490     audio_bitstream_filters= NULL;
3491
3492     st->codec->thread_count= thread_count;
3493
3494     audio_enc = st->codec;
3495     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3496
3497     if(audio_codec_tag)
3498         audio_enc->codec_tag= audio_codec_tag;
3499
3500     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3501         audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3502         avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3503     }
3504     if (audio_stream_copy) {
3505         st->stream_copy = 1;
3506         audio_enc->channels = audio_channels;
3507         audio_enc->sample_rate = audio_sample_rate;
3508     } else {
3509         audio_enc->codec_id = codec_id;
3510         set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3511
3512         if (audio_qscale > QSCALE_NONE) {
3513             audio_enc->flags |= CODEC_FLAG_QSCALE;
3514             audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3515         }
3516         audio_enc->channels = audio_channels;
3517         audio_enc->sample_fmt = audio_sample_fmt;
3518         audio_enc->sample_rate = audio_sample_rate;
3519         audio_enc->channel_layout = channel_layout;
3520         if (av_get_channel_layout_nb_channels(channel_layout) != audio_channels)
3521             audio_enc->channel_layout = 0;
3522         choose_sample_fmt(st, codec);
3523         choose_sample_rate(st, codec);
3524     }
3525     audio_enc->time_base= (AVRational){1, audio_sample_rate};
3526     if (audio_language) {
3527         av_metadata_set2(&st->metadata, "language", audio_language, 0);
3528         av_freep(&audio_language);
3529     }
3530
3531     /* reset some key parameters */
3532     audio_disable = 0;
3533     av_freep(&audio_codec_name);
3534     audio_stream_copy = 0;
3535 }
3536
3537 static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3538 {
3539     AVStream *st;
3540     AVOutputStream *ost;
3541     AVCodec *codec=NULL;
3542     AVCodecContext *subtitle_enc;
3543     enum CodecID codec_id = CODEC_ID_NONE;
3544
3545     st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3546     if (!st) {
3547         fprintf(stderr, "Could not alloc stream\n");
3548         ffmpeg_exit(1);
3549     }
3550     ost = new_output_stream(oc, file_idx);
3551     subtitle_enc = st->codec;
3552     output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3553     if(!subtitle_stream_copy){
3554         if (subtitle_codec_name) {
3555             codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,
3556                                          avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3557             codec= output_codecs[nb_output_codecs-1] = avcodec_find_encoder_by_name(subtitle_codec_name);
3558         } else {
3559             codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_SUBTITLE);
3560             codec = avcodec_find_encoder(codec_id);
3561         }
3562     }
3563     avcodec_get_context_defaults3(st->codec, codec);
3564
3565     ost->bitstream_filters = subtitle_bitstream_filters;
3566     subtitle_bitstream_filters= NULL;
3567
3568     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3569
3570     if(subtitle_codec_tag)
3571         subtitle_enc->codec_tag= subtitle_codec_tag;
3572
3573     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3574         subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3575         avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3576     }
3577     if (subtitle_stream_copy) {
3578         st->stream_copy = 1;
3579     } else {
3580         subtitle_enc->codec_id = codec_id;
3581         set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3582     }
3583
3584     if (subtitle_language) {
3585         av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3586         av_freep(&subtitle_language);
3587     }
3588
3589     subtitle_disable = 0;
3590     av_freep(&subtitle_codec_name);
3591     subtitle_stream_copy = 0;
3592 }
3593
3594 static int opt_new_stream(const char *opt, const char *arg)
3595 {
3596     AVFormatContext *oc;
3597     int file_idx = nb_output_files - 1;
3598     if (nb_output_files <= 0) {
3599         fprintf(stderr, "At least one output file must be specified\n");
3600         ffmpeg_exit(1);
3601     }
3602     oc = output_files[file_idx];
3603
3604     if      (!strcmp(opt, "newvideo"   )) new_video_stream   (oc, file_idx);
3605     else if (!strcmp(opt, "newaudio"   )) new_audio_stream   (oc, file_idx);
3606     else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3607     else av_assert0(0);
3608     return 0;
3609 }
3610
3611 /* arg format is "output-stream-index:streamid-value". */
3612 static int opt_streamid(const char *opt, const char *arg)
3613 {
3614     int idx;
3615     char *p;
3616     char idx_str[16];
3617
3618     strncpy(idx_str, arg, sizeof(idx_str));
3619     idx_str[sizeof(idx_str)-1] = '\0';
3620     p = strchr(idx_str, ':');
3621     if (!p) {
3622         fprintf(stderr,
3623                 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3624                 arg, opt);
3625         ffmpeg_exit(1);
3626     }
3627     *p++ = '\0';
3628     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3629     streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3630     streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3631     return 0;
3632 }
3633
3634 static void opt_output_file(const char *filename)
3635 {
3636     AVFormatContext *oc;
3637     int err, use_video, use_audio, use_subtitle;
3638     int input_has_video, input_has_audio, input_has_subtitle;
3639     AVFormatParameters params, *ap = &params;
3640     AVOutputFormat *file_oformat;
3641
3642     if (!strcmp(filename, "-"))
3643         filename = "pipe:";
3644
3645     oc = avformat_alloc_context();
3646     if (!oc) {
3647         print_error(filename, AVERROR(ENOMEM));
3648         ffmpeg_exit(1);
3649     }
3650
3651     if (last_asked_format) {
3652         file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3653         if (!file_oformat) {
3654             fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3655             ffmpeg_exit(1);
3656         }
3657         last_asked_format = NULL;
3658     } else {
3659         file_oformat = av_guess_format(NULL, filename, NULL);
3660         if (!file_oformat) {
3661             fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3662                     filename);
3663             ffmpeg_exit(1);
3664         }
3665     }
3666
3667     oc->oformat = file_oformat;
3668     av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3669
3670     if (!strcmp(file_oformat->name, "ffm") &&
3671         av_strstart(filename, "http:", NULL)) {
3672         /* special case for files sent to ffserver: we get the stream
3673            parameters from ffserver */
3674         int err = read_ffserver_streams(oc, filename);
3675         if (err < 0) {
3676             print_error(filename, err);
3677             ffmpeg_exit(1);
3678         }
3679     } else {
3680         use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3681         use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3682         use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3683
3684         /* disable if no corresponding type found and at least one
3685            input file */
3686         if (nb_input_files > 0) {
3687             check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3688                                          &input_has_subtitle);
3689             if (!input_has_video)
3690                 use_video = 0;
3691             if (!input_has_audio)
3692                 use_audio = 0;
3693             if (!input_has_subtitle)
3694                 use_subtitle = 0;
3695         }
3696
3697         /* manual disable */
3698         if (audio_disable)    use_audio    = 0;
3699         if (video_disable)    use_video    = 0;
3700         if (subtitle_disable) use_subtitle = 0;
3701
3702         if (use_video)    new_video_stream(oc, nb_output_files);
3703         if (use_audio)    new_audio_stream(oc, nb_output_files);
3704         if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3705
3706         oc->timestamp = recording_timestamp;
3707
3708         av_metadata_copy(&oc->metadata, metadata, 0);
3709         av_metadata_free(&metadata);
3710     }
3711
3712     output_files[nb_output_files++] = oc;
3713
3714     /* check filename in case of an image number is expected */
3715     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3716         if (!av_filename_number_test(oc->filename)) {
3717             print_error(oc->filename, AVERROR_NUMEXPECTED);
3718             ffmpeg_exit(1);
3719         }
3720     }
3721
3722     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3723         /* test if it already exists to avoid loosing precious files */
3724         if (!file_overwrite &&
3725             (strchr(filename, ':') == NULL ||
3726              filename[1] == ':' ||
3727              av_strstart(filename, "file:", NULL))) {
3728             if (url_exist(filename)) {
3729                 if (!using_stdin) {
3730                     fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3731                     fflush(stderr);
3732                     if (!read_yesno()) {
3733                         fprintf(stderr, "Not overwriting - exiting\n");
3734                         ffmpeg_exit(1);
3735                     }
3736                 }
3737                 else {
3738                     fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3739                     ffmpeg_exit(1);
3740                 }
3741             }
3742         }
3743
3744         /* open the file */
3745         if ((err = avio_open(&oc->pb, filename, URL_WRONLY)) < 0) {
3746             print_error(filename, err);
3747             ffmpeg_exit(1);
3748         }
3749     }
3750
3751     memset(ap, 0, sizeof(*ap));
3752     if (av_set_parameters(oc, ap) < 0) {
3753         fprintf(stderr, "%s: Invalid encoding parameters\n",
3754                 oc->filename);
3755         ffmpeg_exit(1);
3756     }
3757
3758     oc->preload= (int)(mux_preload*AV_TIME_BASE);
3759     oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3760     oc->loop_output = loop_output;
3761     oc->flags |= AVFMT_FLAG_NONBLOCK;
3762
3763     set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
3764
3765     av_freep(&forced_key_frames);
3766 }
3767
3768 /* same option as mencoder */
3769 static void opt_pass(const char *pass_str)
3770 {
3771     int pass;
3772     pass = atoi(pass_str);
3773     if (pass != 1 && pass != 2) {
3774         fprintf(stderr, "pass number can be only 1 or 2\n");
3775         ffmpeg_exit(1);
3776     }
3777     do_pass = pass;
3778 }
3779
3780 static int64_t getutime(void)
3781 {
3782 #if HAVE_GETRUSAGE
3783     struct rusage rusage;
3784
3785     getrusage(RUSAGE_SELF, &rusage);
3786     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3787 #elif HAVE_GETPROCESSTIMES
3788     HANDLE proc;
3789     FILETIME c, e, k, u;
3790     proc = GetCurrentProcess();
3791     GetProcessTimes(proc, &c, &e, &k, &u);
3792     return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3793 #else
3794     return av_gettime();
3795 #endif
3796 }
3797
3798 static int64_t getmaxrss(void)
3799 {
3800 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3801     struct rusage rusage;
3802     getrusage(RUSAGE_SELF, &rusage);
3803     return (int64_t)rusage.ru_maxrss * 1024;
3804 #elif HAVE_GETPROCESSMEMORYINFO
3805     HANDLE proc;
3806     PROCESS_MEMORY_COUNTERS memcounters;
3807     proc = GetCurrentProcess();
3808     memcounters.cb = sizeof(memcounters);
3809     GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3810     return memcounters.PeakPagefileUsage;
3811 #else
3812     return 0;
3813 #endif
3814 }
3815
3816 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3817 {
3818     int i;
3819     const char *p = str;
3820     for(i = 0;; i++) {
3821         dest[i] = atoi(p);
3822         if(i == 63)
3823             break;
3824         p = strchr(p, ',');
3825         if(!p) {
3826             fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3827             ffmpeg_exit(1);
3828         }
3829         p++;
3830     }
3831 }
3832
3833 static void opt_inter_matrix(const char *arg)
3834 {
3835     inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3836     parse_matrix_coeffs(inter_matrix, arg);
3837 }
3838
3839 static void opt_intra_matrix(const char *arg)
3840 {
3841     intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3842     parse_matrix_coeffs(intra_matrix, arg);
3843 }
3844
3845 static void show_usage(void)
3846 {
3847     printf("Hyper fast Audio and Video encoder\n");
3848     printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3849     printf("\n");
3850 }
3851
3852 static void show_help(void)
3853 {
3854     AVCodec *c;
3855     AVOutputFormat *oformat = NULL;
3856
3857     av_log_set_callback(log_callback_help);
3858     show_usage();
3859     show_help_options(options, "Main options:\n",
3860                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3861     show_help_options(options, "\nAdvanced options:\n",
3862                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3863                       OPT_EXPERT);
3864     show_help_options(options, "\nVideo options:\n",
3865                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3866                       OPT_VIDEO);
3867     show_help_options(options, "\nAdvanced Video options:\n",
3868                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3869                       OPT_VIDEO | OPT_EXPERT);
3870     show_help_options(options, "\nAudio options:\n",
3871                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3872                       OPT_AUDIO);
3873     show_help_options(options, "\nAdvanced Audio options:\n",
3874                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3875                       OPT_AUDIO | OPT_EXPERT);
3876     show_help_options(options, "\nSubtitle options:\n",
3877                       OPT_SUBTITLE | OPT_GRAB,
3878                       OPT_SUBTITLE);
3879     show_help_options(options, "\nAudio/Video grab options:\n",
3880                       OPT_GRAB,
3881                       OPT_GRAB);
3882     printf("\n");
3883     av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3884     printf("\n");
3885
3886     /* individual codec options */
3887     c = NULL;
3888     while ((c = av_codec_next(c))) {
3889         if (c->priv_class) {
3890             av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3891             printf("\n");
3892         }
3893     }
3894
3895     av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3896     printf("\n");
3897
3898     /* individual muxer options */
3899     while ((oformat = av_oformat_next(oformat))) {
3900         if (oformat->priv_class) {
3901             av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
3902             printf("\n");
3903         }
3904     }
3905
3906     av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3907 }
3908
3909 static void opt_target(const char *arg)
3910 {
3911     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3912     static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3913
3914     if(!strncmp(arg, "pal-", 4)) {
3915         norm = PAL;
3916         arg += 4;
3917     } else if(!strncmp(arg, "ntsc-", 5)) {
3918         norm = NTSC;
3919         arg += 5;
3920     } else if(!strncmp(arg, "film-", 5)) {
3921         norm = FILM;
3922         arg += 5;
3923     } else {
3924         int fr;
3925         /* Calculate FR via float to avoid int overflow */
3926         fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3927         if(fr == 25000) {
3928             norm = PAL;
3929         } else if((fr == 29970) || (fr == 23976)) {
3930             norm = NTSC;
3931         } else {
3932             /* Try to determine PAL/NTSC by peeking in the input files */
3933             if(nb_input_files) {
3934                 int i, j;
3935                 for(j = 0; j < nb_input_files; j++) {
3936                     for(i = 0; i < input_files[j]->nb_streams; i++) {
3937                         AVCodecContext *c = input_files[j]->streams[i]->codec;
3938                         if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3939                             continue;
3940                         fr = c->time_base.den * 1000 / c->time_base.num;
3941                         if(fr == 25000) {
3942                             norm = PAL;
3943                             break;
3944                         } else if((fr == 29970) || (fr == 23976)) {
3945                             norm = NTSC;
3946                             break;
3947                         }
3948                     }
3949                     if(norm != UNKNOWN)
3950                         break;
3951                 }
3952             }
3953         }
3954         if(verbose && norm != UNKNOWN)
3955             fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
3956     }
3957
3958     if(norm == UNKNOWN) {
3959         fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3960         fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3961         fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3962         ffmpeg_exit(1);
3963     }
3964
3965     if(!strcmp(arg, "vcd")) {
3966
3967         opt_video_codec("mpeg1video");
3968         opt_audio_codec("mp2");
3969         opt_format("vcd");
3970
3971         opt_frame_size(norm == PAL ? "352x288" : "352x240");
3972         opt_frame_rate(NULL, frame_rates[norm]);
3973         opt_default("g", norm == PAL ? "15" : "18");
3974
3975         opt_default("b", "1150000");
3976         opt_default("maxrate", "1150000");
3977         opt_default("minrate", "1150000");
3978         opt_default("bufsize", "327680"); // 40*1024*8;
3979
3980         opt_default("ab", "224000");
3981         audio_sample_rate = 44100;
3982         audio_channels = 2;
3983
3984         opt_default("packetsize", "2324");
3985         opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3986
3987         /* We have to offset the PTS, so that it is consistent with the SCR.
3988            SCR starts at 36000, but the first two packs contain only padding
3989            and the first pack from the other stream, respectively, may also have
3990            been written before.
3991            So the real data starts at SCR 36000+3*1200. */
3992         mux_preload= (36000+3*1200) / 90000.0; //0.44
3993     } else if(!strcmp(arg, "svcd")) {
3994
3995         opt_video_codec("mpeg2video");
3996         opt_audio_codec("mp2");
3997         opt_format("svcd");
3998
3999         opt_frame_size(norm == PAL ? "480x576" : "480x480");
4000         opt_frame_rate(NULL, frame_rates[norm]);
4001         opt_default("g", norm == PAL ? "15" : "18");
4002
4003         opt_default("b", "2040000");
4004         opt_default("maxrate", "2516000");
4005         opt_default("minrate", "0"); //1145000;
4006         opt_default("bufsize", "1835008"); //224*1024*8;
4007         opt_default("flags", "+scan_offset");
4008
4009
4010         opt_default("ab", "224000");
4011         audio_sample_rate = 44100;
4012
4013         opt_default("packetsize", "2324");
4014
4015     } else if(!strcmp(arg, "dvd")) {
4016
4017         opt_video_codec("mpeg2video");
4018         opt_audio_codec("ac3");
4019         opt_format("dvd");
4020
4021         opt_frame_size(norm == PAL ? "720x576" : "720x480");
4022         opt_frame_rate(NULL, frame_rates[norm]);
4023         opt_default("g", norm == PAL ? "15" : "18");
4024
4025         opt_default("b", "6000000");
4026         opt_default("maxrate", "9000000");
4027         opt_default("minrate", "0"); //1500000;
4028         opt_default("bufsize", "1835008"); //224*1024*8;
4029
4030         opt_default("packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4031         opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4032
4033         opt_default("ab", "448000");
4034         audio_sample_rate = 48000;
4035
4036     } else if(!strncmp(arg, "dv", 2)) {
4037
4038         opt_format("dv");
4039
4040         opt_frame_size(norm == PAL ? "720x576" : "720x480");
4041         opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
4042                           (norm == PAL ? "yuv420p" : "yuv411p"));
4043         opt_frame_rate(NULL, frame_rates[norm]);
4044
4045         audio_sample_rate = 48000;
4046         audio_channels = 2;
4047
4048     } else {
4049         fprintf(stderr, "Unknown target: %s\n", arg);
4050         ffmpeg_exit(1);
4051     }
4052 }
4053
4054 static void opt_vstats_file (const char *arg)
4055 {
4056     av_free (vstats_filename);
4057     vstats_filename=av_strdup (arg);
4058 }
4059
4060 static void opt_vstats (void)
4061 {
4062     char filename[40];
4063     time_t today2 = time(NULL);
4064     struct tm *today = localtime(&today2);
4065
4066     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4067              today->tm_sec);
4068     opt_vstats_file(filename);
4069 }
4070
4071 static int opt_bsf(const char *opt, const char *arg)
4072 {
4073     AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4074     AVBitStreamFilterContext **bsfp;
4075
4076     if(!bsfc){
4077         fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4078         ffmpeg_exit(1);
4079     }
4080
4081     bsfp= *opt == 'v' ? &video_bitstream_filters :
4082           *opt == 'a' ? &audio_bitstream_filters :
4083                         &subtitle_bitstream_filters;
4084     while(*bsfp)
4085         bsfp= &(*bsfp)->next;
4086
4087     *bsfp= bsfc;
4088
4089     return 0;
4090 }
4091
4092 static int opt_preset(const char *opt, const char *arg)
4093 {
4094     FILE *f=NULL;
4095     char filename[1000], tmp[1000], tmp2[1000], line[1000];
4096     char *codec_name = *opt == 'v' ? video_codec_name :
4097                        *opt == 'a' ? audio_codec_name :
4098                                      subtitle_codec_name;
4099
4100     if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4101         fprintf(stderr, "File for preset '%s' not found\n", arg);
4102         ffmpeg_exit(1);
4103     }
4104
4105     while(!feof(f)){
4106         int e= fscanf(f, "%999[^\n]\n", line) - 1;
4107         if(line[0] == '#' && !e)
4108             continue;
4109         e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4110         if(e){
4111             fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4112             ffmpeg_exit(1);
4113         }
4114         if(!strcmp(tmp, "acodec")){
4115             opt_audio_codec(tmp2);
4116         }else if(!strcmp(tmp, "vcodec")){
4117             opt_video_codec(tmp2);
4118         }else if(!strcmp(tmp, "scodec")){
4119             opt_subtitle_codec(tmp2);
4120         }else if(opt_default(tmp, tmp2) < 0){
4121             fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4122             ffmpeg_exit(1);
4123         }
4124     }
4125
4126     fclose(f);
4127
4128     return 0;
4129 }
4130
4131 static const OptionDef options[] = {
4132     /* main options */
4133 #include "cmdutils_common_opts.h"
4134     { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4135     { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4136     { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4137     { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4138     { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
4139       "outfile[,metadata]:infile[,metadata]" },
4140     { "map_metadata", HAS_ARG | OPT_EXPERT, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4141       "outfile[,metadata]:infile[,metadata]" },
4142     { "map_chapters",  HAS_ARG | OPT_EXPERT, {(void*)opt_map_chapters},  "set chapters mapping", "outfile:infile" },
4143     { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4144     { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4145     { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4146     { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4147     { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
4148     { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4149     { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4150     { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4151     { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4152       "add timings for benchmarking" },
4153     { "timelimit", OPT_FUNC2 | HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4154     { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4155       "dump each input packet" },
4156     { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4157       "when dumping packets, also dump the payload" },
4158     { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4159     { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
4160     { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "number of times to loop output in formats that support looping (0 loops forever)", "" },
4161     { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
4162     { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4163     { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4164     { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4165     { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4166     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4167     { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
4168     { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
4169     { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)&copy_tb}, "copy input stream time base when stream copying" },
4170     { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4171     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4172     { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4173     { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4174     { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)&copy_initial_nonkeyframes}, "copy initial non-keyframes" },
4175
4176     /* video options */
4177     { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4178     { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4179     { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4180     { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4181     { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4182     { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4183     { "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" },
4184     { "croptop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4185     { "cropbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4186     { "cropleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4187     { "cropright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4188     { "padtop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4189     { "padbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4190     { "padleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4191     { "padright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4192     { "padcolor", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4193     { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4194     { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4195     { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4196     { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4197     { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4198     { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4199     { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "threshold" },
4200     { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4201       "use same video quality as source (implies VBR)" },
4202     { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
4203     { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4204     { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4205       "deinterlace pictures" },
4206     { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4207     { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4208     { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4209 #if CONFIG_AVFILTER
4210     { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4211 #endif
4212     { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4213     { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4214     { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4215     { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4216     { "vtag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4217     { "newvideo", OPT_VIDEO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new video stream to the current output stream" },
4218     { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4219     { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4220     { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4221     { "streamid", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4222     { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4223
4224     /* audio options */
4225     { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4226     { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4227     { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4228     { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4229     { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4230     { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4231     { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4232     { "atag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4233     { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4234     { "newaudio", OPT_AUDIO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
4235     { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4236     { "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" },
4237
4238     /* subtitle options */
4239     { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4240     { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4241     { "newsubtitle", OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4242     { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4243     { "stag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4244
4245     /* grab options */
4246     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4247     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4248     { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4249
4250     /* muxer options */
4251     { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4252     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4253
4254     { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4255     { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4256     { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4257
4258     { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4259     { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4260     { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4261     { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4262
4263     { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4264     { NULL, },
4265 };
4266
4267 int main(int argc, char **argv)
4268 {
4269     int64_t ti;
4270
4271     av_log_set_flags(AV_LOG_SKIP_REPEATED);
4272
4273     avcodec_register_all();
4274 #if CONFIG_AVDEVICE
4275     avdevice_register_all();
4276 #endif
4277 #if CONFIG_AVFILTER
4278     avfilter_register_all();
4279 #endif
4280     av_register_all();
4281
4282 #if HAVE_ISATTY
4283     if(isatty(STDIN_FILENO))
4284         url_set_interrupt_cb(decode_interrupt_cb);
4285 #endif
4286
4287     init_opts();
4288
4289     show_banner();
4290
4291     /* parse options */
4292     parse_options(argc, argv, options, opt_output_file);
4293
4294     if(nb_output_files <= 0 && nb_input_files == 0) {
4295         show_usage();
4296         fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4297         ffmpeg_exit(1);
4298     }
4299
4300     /* file converter / grab */
4301     if (nb_output_files <= 0) {
4302         fprintf(stderr, "At least one output file must be specified\n");
4303         ffmpeg_exit(1);
4304     }
4305
4306     if (nb_input_files == 0) {
4307         fprintf(stderr, "At least one input file must be specified\n");
4308         ffmpeg_exit(1);
4309     }
4310
4311     ti = getutime();
4312     if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4313                   stream_maps, nb_stream_maps) < 0)
4314         ffmpeg_exit(1);
4315     ti = getutime() - ti;
4316     if (do_benchmark) {
4317         int maxrss = getmaxrss() / 1024;
4318         printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4319     }
4320
4321     return ffmpeg_exit(0);
4322 }