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->block_align= icodec->block_align;
2104                 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2105                     codec->block_align= 0;
2106                 if(codec->codec_id == CODEC_ID_AC3)
2107                     codec->block_align= 0;
2108                 break;
2109             case AVMEDIA_TYPE_VIDEO:
2110                 codec->pix_fmt = icodec->pix_fmt;
2111                 codec->width = icodec->width;
2112                 codec->height = icodec->height;
2113                 codec->has_b_frames = icodec->has_b_frames;
2114                 break;
2115             case AVMEDIA_TYPE_SUBTITLE:
2116                 codec->width = icodec->width;
2117                 codec->height = icodec->height;
2118                 break;
2119             default:
2120                 abort();
2121             }
2122         } else {
2123             switch(codec->codec_type) {
2124             case AVMEDIA_TYPE_AUDIO:
2125                 ost->fifo= av_fifo_alloc(1024);
2126                 if(!ost->fifo)
2127                     goto fail;
2128                 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2129                 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2130                 icodec->request_channels = codec->channels;
2131                 ist->decoding_needed = 1;
2132                 ost->encoding_needed = 1;
2133                 ost->resample_sample_fmt  = icodec->sample_fmt;
2134                 ost->resample_sample_rate = icodec->sample_rate;
2135                 ost->resample_channels    = icodec->channels;
2136                 break;
2137             case AVMEDIA_TYPE_VIDEO:
2138                 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2139                     fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2140                     ffmpeg_exit(1);
2141                 }
2142                 ost->video_resample = (codec->width != icodec->width   ||
2143                                        codec->height != icodec->height ||
2144                         (codec->pix_fmt != icodec->pix_fmt));
2145                 if (ost->video_resample) {
2146 #if !CONFIG_AVFILTER
2147                     avcodec_get_frame_defaults(&ost->pict_tmp);
2148                     if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2149                                          codec->width, codec->height)) {
2150                         fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
2151                         ffmpeg_exit(1);
2152                     }
2153                     sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
2154                     ost->img_resample_ctx = sws_getContext(
2155                         icodec->width,
2156                         icodec->height,
2157                             icodec->pix_fmt,
2158                             codec->width,
2159                             codec->height,
2160                             codec->pix_fmt,
2161                             sws_flags, NULL, NULL, NULL);
2162                     if (ost->img_resample_ctx == NULL) {
2163                         fprintf(stderr, "Cannot get resampling context\n");
2164                         ffmpeg_exit(1);
2165                     }
2166
2167                     ost->original_height = icodec->height;
2168                     ost->original_width  = icodec->width;
2169 #endif
2170                     codec->bits_per_raw_sample= 0;
2171                 }
2172                 ost->resample_height = icodec->height;
2173                 ost->resample_width  = icodec->width;
2174                 ost->resample_pix_fmt= icodec->pix_fmt;
2175                 ost->encoding_needed = 1;
2176                 ist->decoding_needed = 1;
2177
2178 #if CONFIG_AVFILTER
2179                 if (configure_filters(ist, ost)) {
2180                     fprintf(stderr, "Error opening filters!\n");
2181                     exit(1);
2182                 }
2183 #endif
2184                 break;
2185             case AVMEDIA_TYPE_SUBTITLE:
2186                 ost->encoding_needed = 1;
2187                 ist->decoding_needed = 1;
2188                 break;
2189             default:
2190                 abort();
2191                 break;
2192             }
2193             /* two pass mode */
2194             if (ost->encoding_needed &&
2195                 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2196                 char logfilename[1024];
2197                 FILE *f;
2198
2199                 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2200                          pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2201                          i);
2202                 if (codec->flags & CODEC_FLAG_PASS1) {
2203                     f = fopen(logfilename, "wb");
2204                     if (!f) {
2205                         fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2206                         ffmpeg_exit(1);
2207                     }
2208                     ost->logfile = f;
2209                 } else {
2210                     char  *logbuffer;
2211                     size_t logbuffer_size;
2212                     if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2213                         fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2214                         ffmpeg_exit(1);
2215                     }
2216                     codec->stats_in = logbuffer;
2217                 }
2218             }
2219         }
2220         if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2221             int size= codec->width * codec->height;
2222             bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2223         }
2224     }
2225
2226     if (!bit_buffer)
2227         bit_buffer = av_malloc(bit_buffer_size);
2228     if (!bit_buffer) {
2229         fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2230                 bit_buffer_size);
2231         ret = AVERROR(ENOMEM);
2232         goto fail;
2233     }
2234
2235     /* open each encoder */
2236     for(i=0;i<nb_ostreams;i++) {
2237         ost = ost_table[i];
2238         if (ost->encoding_needed) {
2239             AVCodec *codec = i < nb_output_codecs ? output_codecs[i] : NULL;
2240             AVCodecContext *dec = ist_table[ost->source_index]->st->codec;
2241             if (!codec)
2242                 codec = avcodec_find_encoder(ost->st->codec->codec_id);
2243             if (!codec) {
2244                 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2245                          ost->st->codec->codec_id, ost->file_index, ost->index);
2246                 ret = AVERROR(EINVAL);
2247                 goto dump_format;
2248             }
2249             if (dec->subtitle_header) {
2250                 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2251                 if (!ost->st->codec->subtitle_header) {
2252                     ret = AVERROR(ENOMEM);
2253                     goto dump_format;
2254                 }
2255                 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2256                 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2257             }
2258             if (avcodec_open(ost->st->codec, codec) < 0) {
2259                 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2260                         ost->file_index, ost->index);
2261                 ret = AVERROR(EINVAL);
2262                 goto dump_format;
2263             }
2264             extra_size += ost->st->codec->extradata_size;
2265         }
2266     }
2267
2268     /* open each decoder */
2269     for(i=0;i<nb_istreams;i++) {
2270         ist = ist_table[i];
2271         if (ist->decoding_needed) {
2272             AVCodec *codec = i < nb_input_codecs ? input_codecs[i] : NULL;
2273             if (!codec)
2274                 codec = avcodec_find_decoder(ist->st->codec->codec_id);
2275             if (!codec) {
2276                 snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2277                         ist->st->codec->codec_id, ist->file_index, ist->index);
2278                 ret = AVERROR(EINVAL);
2279                 goto dump_format;
2280             }
2281             if (avcodec_open(ist->st->codec, codec) < 0) {
2282                 snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2283                         ist->file_index, ist->index);
2284                 ret = AVERROR(EINVAL);
2285                 goto dump_format;
2286             }
2287             //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2288             //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2289         }
2290     }
2291
2292     /* init pts */
2293     for(i=0;i<nb_istreams;i++) {
2294         AVStream *st;
2295         ist = ist_table[i];
2296         st= ist->st;
2297         ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2298         ist->next_pts = AV_NOPTS_VALUE;
2299         init_pts_correction(&ist->pts_ctx);
2300         ist->is_start = 1;
2301     }
2302
2303     /* set meta data information from input file if required */
2304     for (i=0;i<nb_meta_data_maps;i++) {
2305         AVFormatContext *files[2];
2306         AVMetadata      **meta[2];
2307         int j;
2308
2309 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
2310         if ((index) < 0 || (index) >= (nb_elems)) {\
2311             snprintf(error, sizeof(error), "Invalid %s index %d while processing metadata maps\n",\
2312                      (desc), (index));\
2313             ret = AVERROR(EINVAL);\
2314             goto dump_format;\
2315         }
2316
2317         int out_file_index = meta_data_maps[i][0].file;
2318         int in_file_index = meta_data_maps[i][1].file;
2319         if (in_file_index < 0 || out_file_index < 0)
2320             continue;
2321         METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2322         METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2323
2324         files[0] = output_files[out_file_index];
2325         files[1] = input_files[in_file_index];
2326
2327         for (j = 0; j < 2; j++) {
2328             AVMetaDataMap *map = &meta_data_maps[i][j];
2329
2330             switch (map->type) {
2331             case 'g':
2332                 meta[j] = &files[j]->metadata;
2333                 break;
2334             case 's':
2335                 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
2336                 meta[j] = &files[j]->streams[map->index]->metadata;
2337                 break;
2338             case 'c':
2339                 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
2340                 meta[j] = &files[j]->chapters[map->index]->metadata;
2341                 break;
2342             case 'p':
2343                 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
2344                 meta[j] = &files[j]->programs[map->index]->metadata;
2345                 break;
2346             }
2347         }
2348
2349         av_metadata_copy(meta[0], *meta[1], AV_METADATA_DONT_OVERWRITE);
2350     }
2351
2352     /* copy global metadata by default */
2353     if (metadata_global_autocopy) {
2354
2355         for (i = 0; i < nb_output_files; i++)
2356             av_metadata_copy(&output_files[i]->metadata, input_files[0]->metadata,
2357                              AV_METADATA_DONT_OVERWRITE);
2358     }
2359
2360     /* copy chapters according to chapter maps */
2361     for (i = 0; i < nb_chapter_maps; i++) {
2362         int infile  = chapter_maps[i].in_file;
2363         int outfile = chapter_maps[i].out_file;
2364
2365         if (infile < 0 || outfile < 0)
2366             continue;
2367         if (infile >= nb_input_files) {
2368             snprintf(error, sizeof(error), "Invalid input file index %d in chapter mapping.\n", infile);
2369             ret = AVERROR(EINVAL);
2370             goto dump_format;
2371         }
2372         if (outfile >= nb_output_files) {
2373             snprintf(error, sizeof(error), "Invalid output file index %d in chapter mapping.\n",outfile);
2374             ret = AVERROR(EINVAL);
2375             goto dump_format;
2376         }
2377         copy_chapters(infile, outfile);
2378     }
2379
2380     /* copy chapters from the first input file that has them*/
2381     if (!nb_chapter_maps)
2382         for (i = 0; i < nb_input_files; i++) {
2383             if (!input_files[i]->nb_chapters)
2384                 continue;
2385
2386             for (j = 0; j < nb_output_files; j++)
2387                 if ((ret = copy_chapters(i, j)) < 0)
2388                     goto dump_format;
2389             break;
2390         }
2391
2392     /* open files and write file headers */
2393     for(i=0;i<nb_output_files;i++) {
2394         os = output_files[i];
2395         if (av_write_header(os) < 0) {
2396             snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2397             ret = AVERROR(EINVAL);
2398             goto dump_format;
2399         }
2400         if (strcmp(output_files[i]->oformat->name, "rtp")) {
2401             want_sdp = 0;
2402         }
2403     }
2404
2405  dump_format:
2406     /* dump the file output parameters - cannot be done before in case
2407        of stream copy */
2408     for(i=0;i<nb_output_files;i++) {
2409         av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2410     }
2411
2412     /* dump the stream mapping */
2413     if (verbose >= 0) {
2414         fprintf(stderr, "Stream mapping:\n");
2415         for(i=0;i<nb_ostreams;i++) {
2416             ost = ost_table[i];
2417             fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
2418                     ist_table[ost->source_index]->file_index,
2419                     ist_table[ost->source_index]->index,
2420                     ost->file_index,
2421                     ost->index);
2422             if (ost->sync_ist != ist_table[ost->source_index])
2423                 fprintf(stderr, " [sync #%d.%d]",
2424                         ost->sync_ist->file_index,
2425                         ost->sync_ist->index);
2426             fprintf(stderr, "\n");
2427         }
2428     }
2429
2430     if (ret) {
2431         fprintf(stderr, "%s\n", error);
2432         goto fail;
2433     }
2434
2435     if (want_sdp) {
2436         print_sdp(output_files, nb_output_files);
2437     }
2438
2439     if (!using_stdin && verbose >= 0) {
2440 #if HAVE_KBHIT
2441         fprintf(stderr, "Press [q] to stop encoding\n");
2442 #else
2443         fprintf(stderr, "Press ctrl-c to stop encoding\n");
2444 #endif
2445         url_set_interrupt_cb(decode_interrupt_cb);
2446     }
2447     term_init();
2448
2449     timer_start = av_gettime();
2450
2451     for(; received_sigterm == 0;) {
2452         int file_index, ist_index;
2453         AVPacket pkt;
2454         double ipts_min;
2455         double opts_min;
2456
2457     redo:
2458         ipts_min= 1e100;
2459         opts_min= 1e100;
2460         /* if 'q' pressed, exits */
2461         if (!using_stdin) {
2462             if (q_pressed)
2463                 break;
2464             /* read_key() returns 0 on EOF */
2465             key = read_key();
2466             if (key == 'q')
2467                 break;
2468         }
2469
2470         /* select the stream that we must read now by looking at the
2471            smallest output pts */
2472         file_index = -1;
2473         for(i=0;i<nb_ostreams;i++) {
2474             double ipts, opts;
2475             ost = ost_table[i];
2476             os = output_files[ost->file_index];
2477             ist = ist_table[ost->source_index];
2478             if(ist->is_past_recording_time || no_packet[ist->file_index])
2479                 continue;
2480                 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2481             ipts = (double)ist->pts;
2482             if (!file_table[ist->file_index].eof_reached){
2483                 if(ipts < ipts_min) {
2484                     ipts_min = ipts;
2485                     if(input_sync ) file_index = ist->file_index;
2486                 }
2487                 if(opts < opts_min) {
2488                     opts_min = opts;
2489                     if(!input_sync) file_index = ist->file_index;
2490                 }
2491             }
2492             if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2493                 file_index= -1;
2494                 break;
2495             }
2496         }
2497         /* if none, if is finished */
2498         if (file_index < 0) {
2499             if(no_packet_count){
2500                 no_packet_count=0;
2501                 memset(no_packet, 0, sizeof(no_packet));
2502                 usleep(10000);
2503                 continue;
2504             }
2505             break;
2506         }
2507
2508         /* finish if limit size exhausted */
2509         if (limit_filesize != 0 && limit_filesize <= avio_tell(output_files[0]->pb))
2510             break;
2511
2512         /* read a frame from it and output it in the fifo */
2513         is = input_files[file_index];
2514         ret= av_read_frame(is, &pkt);
2515         if(ret == AVERROR(EAGAIN)){
2516             no_packet[file_index]=1;
2517             no_packet_count++;
2518             continue;
2519         }
2520         if (ret < 0) {
2521             file_table[file_index].eof_reached = 1;
2522             if (opt_shortest)
2523                 break;
2524             else
2525                 continue;
2526         }
2527
2528         no_packet_count=0;
2529         memset(no_packet, 0, sizeof(no_packet));
2530
2531         if (do_pkt_dump) {
2532             av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2533                              is->streams[pkt.stream_index]);
2534         }
2535         /* the following test is needed in case new streams appear
2536            dynamically in stream : we ignore them */
2537         if (pkt.stream_index >= file_table[file_index].nb_streams)
2538             goto discard_packet;
2539         ist_index = file_table[file_index].ist_index + pkt.stream_index;
2540         ist = ist_table[ist_index];
2541         if (ist->discard)
2542             goto discard_packet;
2543
2544         if (pkt.dts != AV_NOPTS_VALUE)
2545             pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2546         if (pkt.pts != AV_NOPTS_VALUE)
2547             pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2548
2549         if (pkt.stream_index < nb_input_files_ts_scale[file_index]
2550             && input_files_ts_scale[file_index][pkt.stream_index]){
2551             if(pkt.pts != AV_NOPTS_VALUE)
2552                 pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2553             if(pkt.dts != AV_NOPTS_VALUE)
2554                 pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2555         }
2556
2557 //        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);
2558         if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2559             && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2560             int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2561             int64_t delta= pkt_dts - ist->next_pts;
2562             if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2563                 input_files_ts_offset[ist->file_index]-= delta;
2564                 if (verbose > 2)
2565                     fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2566                 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2567                 if(pkt.pts != AV_NOPTS_VALUE)
2568                     pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2569             }
2570         }
2571
2572         /* finish if recording time exhausted */
2573         if (recording_time != INT64_MAX &&
2574             av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2575             ist->is_past_recording_time = 1;
2576             goto discard_packet;
2577         }
2578
2579         //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
2580         if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2581
2582             if (verbose >= 0)
2583                 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2584                         ist->file_index, ist->index);
2585             if (exit_on_error)
2586                 ffmpeg_exit(1);
2587             av_free_packet(&pkt);
2588             goto redo;
2589         }
2590
2591     discard_packet:
2592         av_free_packet(&pkt);
2593
2594         /* dump report by using the output first video and audio streams */
2595         print_report(output_files, ost_table, nb_ostreams, 0);
2596     }
2597
2598     /* at the end of stream, we must flush the decoder buffers */
2599     for(i=0;i<nb_istreams;i++) {
2600         ist = ist_table[i];
2601         if (ist->decoding_needed) {
2602             output_packet(ist, i, ost_table, nb_ostreams, NULL);
2603         }
2604     }
2605
2606     term_exit();
2607
2608     /* write the trailer if needed and close file */
2609     for(i=0;i<nb_output_files;i++) {
2610         os = output_files[i];
2611         av_write_trailer(os);
2612     }
2613
2614     /* dump report by using the first video and audio streams */
2615     print_report(output_files, ost_table, nb_ostreams, 1);
2616
2617     /* close each encoder */
2618     for(i=0;i<nb_ostreams;i++) {
2619         ost = ost_table[i];
2620         if (ost->encoding_needed) {
2621             av_freep(&ost->st->codec->stats_in);
2622             avcodec_close(ost->st->codec);
2623         }
2624     }
2625
2626     /* close each decoder */
2627     for(i=0;i<nb_istreams;i++) {
2628         ist = ist_table[i];
2629         if (ist->decoding_needed) {
2630             avcodec_close(ist->st->codec);
2631         }
2632     }
2633 #if CONFIG_AVFILTER
2634     avfilter_graph_free(&graph);
2635 #endif
2636
2637     /* finished ! */
2638     ret = 0;
2639
2640  fail:
2641     av_freep(&bit_buffer);
2642     av_free(file_table);
2643
2644     if (ist_table) {
2645         for(i=0;i<nb_istreams;i++) {
2646             ist = ist_table[i];
2647             av_free(ist);
2648         }
2649         av_free(ist_table);
2650     }
2651     if (ost_table) {
2652         for(i=0;i<nb_ostreams;i++) {
2653             ost = ost_table[i];
2654             if (ost) {
2655                 if (ost->st->stream_copy)
2656                     av_freep(&ost->st->codec->extradata);
2657                 if (ost->logfile) {
2658                     fclose(ost->logfile);
2659                     ost->logfile = NULL;
2660                 }
2661                 av_fifo_free(ost->fifo); /* works even if fifo is not
2662                                              initialized but set to zero */
2663                 av_freep(&ost->st->codec->subtitle_header);
2664                 av_free(ost->pict_tmp.data[0]);
2665                 av_free(ost->forced_kf_pts);
2666                 if (ost->video_resample)
2667                     sws_freeContext(ost->img_resample_ctx);
2668                 if (ost->resample)
2669                     audio_resample_close(ost->resample);
2670                 if (ost->reformat_ctx)
2671                     av_audio_convert_free(ost->reformat_ctx);
2672                 av_free(ost);
2673             }
2674         }
2675         av_free(ost_table);
2676     }
2677     return ret;
2678 }
2679
2680 static void opt_format(const char *arg)
2681 {
2682     last_asked_format = arg;
2683 }
2684
2685 static void opt_video_rc_override_string(const char *arg)
2686 {
2687     video_rc_override_string = arg;
2688 }
2689
2690 static int opt_me_threshold(const char *opt, const char *arg)
2691 {
2692     me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2693     return 0;
2694 }
2695
2696 static int opt_verbose(const char *opt, const char *arg)
2697 {
2698     verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2699     return 0;
2700 }
2701
2702 static int opt_frame_rate(const char *opt, const char *arg)
2703 {
2704     if (av_parse_video_rate(&frame_rate, arg) < 0) {
2705         fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2706         ffmpeg_exit(1);
2707     }
2708     return 0;
2709 }
2710
2711 static int opt_bitrate(const char *opt, const char *arg)
2712 {
2713     int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2714
2715     opt_default(opt, arg);
2716
2717     if (av_get_int(avcodec_opts[codec_type], "b", NULL) < 1000)
2718         fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2719
2720     return 0;
2721 }
2722
2723 static int opt_frame_crop(const char *opt, const char *arg)
2724 {
2725     fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2726     return AVERROR(EINVAL);
2727 }
2728
2729 static void opt_frame_size(const char *arg)
2730 {
2731     if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2732         fprintf(stderr, "Incorrect frame size\n");
2733         ffmpeg_exit(1);
2734     }
2735 }
2736
2737 static int opt_pad(const char *opt, const char *arg) {
2738     fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2739     return -1;
2740 }
2741
2742 static void opt_frame_pix_fmt(const char *arg)
2743 {
2744     if (strcmp(arg, "list")) {
2745         frame_pix_fmt = av_get_pix_fmt(arg);
2746         if (frame_pix_fmt == PIX_FMT_NONE) {
2747             fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2748             ffmpeg_exit(1);
2749         }
2750     } else {
2751         show_pix_fmts();
2752         ffmpeg_exit(0);
2753     }
2754 }
2755
2756 static void opt_frame_aspect_ratio(const char *arg)
2757 {
2758     int x = 0, y = 0;
2759     double ar = 0;
2760     const char *p;
2761     char *end;
2762
2763     p = strchr(arg, ':');
2764     if (p) {
2765         x = strtol(arg, &end, 10);
2766         if (end == p)
2767             y = strtol(end+1, &end, 10);
2768         if (x > 0 && y > 0)
2769             ar = (double)x / (double)y;
2770     } else
2771         ar = strtod(arg, NULL);
2772
2773     if (!ar) {
2774         fprintf(stderr, "Incorrect aspect ratio specification.\n");
2775         ffmpeg_exit(1);
2776     }
2777     frame_aspect_ratio = ar;
2778 }
2779
2780 static int opt_metadata(const char *opt, const char *arg)
2781 {
2782     char *mid= strchr(arg, '=');
2783
2784     if(!mid){
2785         fprintf(stderr, "Missing =\n");
2786         ffmpeg_exit(1);
2787     }
2788     *mid++= 0;
2789
2790     av_metadata_set2(&metadata, arg, mid, 0);
2791
2792     return 0;
2793 }
2794
2795 static void opt_qscale(const char *arg)
2796 {
2797     video_qscale = atof(arg);
2798     if (video_qscale <= 0 ||
2799         video_qscale > 255) {
2800         fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2801         ffmpeg_exit(1);
2802     }
2803 }
2804
2805 static void opt_top_field_first(const char *arg)
2806 {
2807     top_field_first= atoi(arg);
2808 }
2809
2810 static int opt_thread_count(const char *opt, const char *arg)
2811 {
2812     thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2813 #if !HAVE_THREADS
2814     if (verbose >= 0)
2815         fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2816 #endif
2817     return 0;
2818 }
2819
2820 static void opt_audio_sample_fmt(const char *arg)
2821 {
2822     if (strcmp(arg, "list")) {
2823         audio_sample_fmt = av_get_sample_fmt(arg);
2824         if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2825             av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2826             ffmpeg_exit(1);
2827         }
2828     } else {
2829         list_fmts(av_get_sample_fmt_string, AV_SAMPLE_FMT_NB);
2830         ffmpeg_exit(0);
2831     }
2832 }
2833
2834 static int opt_audio_rate(const char *opt, const char *arg)
2835 {
2836     audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2837     return 0;
2838 }
2839
2840 static int opt_audio_channels(const char *opt, const char *arg)
2841 {
2842     audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2843     return 0;
2844 }
2845
2846 static void opt_video_channel(const char *arg)
2847 {
2848     video_channel = strtol(arg, NULL, 0);
2849 }
2850
2851 static void opt_video_standard(const char *arg)
2852 {
2853     video_standard = av_strdup(arg);
2854 }
2855
2856 static void opt_codec(int *pstream_copy, char **pcodec_name,
2857                       int codec_type, const char *arg)
2858 {
2859     av_freep(pcodec_name);
2860     if (!strcmp(arg, "copy")) {
2861         *pstream_copy = 1;
2862     } else {
2863         *pcodec_name = av_strdup(arg);
2864     }
2865 }
2866
2867 static void opt_audio_codec(const char *arg)
2868 {
2869     opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2870 }
2871
2872 static void opt_video_codec(const char *arg)
2873 {
2874     opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2875 }
2876
2877 static void opt_subtitle_codec(const char *arg)
2878 {
2879     opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2880 }
2881
2882 static int opt_codec_tag(const char *opt, const char *arg)
2883 {
2884     char *tail;
2885     uint32_t *codec_tag;
2886
2887     codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2888                 !strcmp(opt, "vtag") ? &video_codec_tag :
2889                 !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2890     if (!codec_tag)
2891         return -1;
2892
2893     *codec_tag = strtol(arg, &tail, 0);
2894     if (!tail || *tail)
2895         *codec_tag = AV_RL32(arg);
2896
2897     return 0;
2898 }
2899
2900 static void opt_map(const char *arg)
2901 {
2902     AVStreamMap *m;
2903     char *p;
2904
2905     stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
2906     m = &stream_maps[nb_stream_maps-1];
2907
2908     m->file_index = strtol(arg, &p, 0);
2909     if (*p)
2910         p++;
2911
2912     m->stream_index = strtol(p, &p, 0);
2913     if (*p) {
2914         p++;
2915         m->sync_file_index = strtol(p, &p, 0);
2916         if (*p)
2917             p++;
2918         m->sync_stream_index = strtol(p, &p, 0);
2919     } else {
2920         m->sync_file_index = m->file_index;
2921         m->sync_stream_index = m->stream_index;
2922     }
2923 }
2924
2925 static void parse_meta_type(char *arg, char *type, int *index, char **endptr)
2926 {
2927     *endptr = arg;
2928     if (*arg == ',') {
2929         *type = *(++arg);
2930         switch (*arg) {
2931         case 'g':
2932             break;
2933         case 's':
2934         case 'c':
2935         case 'p':
2936             *index = strtol(++arg, endptr, 0);
2937             break;
2938         default:
2939             fprintf(stderr, "Invalid metadata type %c.\n", *arg);
2940             ffmpeg_exit(1);
2941         }
2942     } else
2943         *type = 'g';
2944 }
2945
2946 static void opt_map_metadata(const char *arg)
2947 {
2948     AVMetaDataMap *m, *m1;
2949     char *p;
2950
2951     meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
2952                                 &nb_meta_data_maps, nb_meta_data_maps + 1);
2953
2954     m = &meta_data_maps[nb_meta_data_maps - 1][0];
2955     m->file = strtol(arg, &p, 0);
2956     parse_meta_type(p, &m->type, &m->index, &p);
2957     if (*p)
2958         p++;
2959
2960     m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
2961     m1->file = strtol(p, &p, 0);
2962     parse_meta_type(p, &m1->type, &m1->index, &p);
2963
2964     if (m->type == 'g' || m1->type == 'g')
2965         metadata_global_autocopy = 0;
2966     if (m->type == 's' || m1->type == 's')
2967         metadata_streams_autocopy = 0;
2968     if (m->type == 'c' || m1->type == 'c')
2969         metadata_chapters_autocopy = 0;
2970 }
2971
2972 static void opt_map_meta_data(const char *arg)
2973 {
2974     fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "
2975                     "Use -map_metadata instead.\n");
2976     opt_map_metadata(arg);
2977 }
2978
2979 static void opt_map_chapters(const char *arg)
2980 {
2981     AVChapterMap *c;
2982     char *p;
2983
2984     chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
2985                               nb_chapter_maps + 1);
2986     c = &chapter_maps[nb_chapter_maps - 1];
2987     c->out_file = strtol(arg, &p, 0);
2988     if (*p)
2989         p++;
2990
2991     c->in_file = strtol(p, &p, 0);
2992 }
2993
2994 static void opt_input_ts_scale(const char *arg)
2995 {
2996     unsigned int stream;
2997     double scale;
2998     char *p;
2999
3000     stream = strtol(arg, &p, 0);
3001     if (*p)
3002         p++;
3003     scale= strtod(p, &p);
3004
3005     if(stream >= MAX_STREAMS)
3006         ffmpeg_exit(1);
3007
3008     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);
3009     input_files_ts_scale[nb_input_files][stream]= scale;
3010 }
3011
3012 static int opt_recording_time(const char *opt, const char *arg)
3013 {
3014     recording_time = parse_time_or_die(opt, arg, 1);
3015     return 0;
3016 }
3017
3018 static int opt_start_time(const char *opt, const char *arg)
3019 {
3020     start_time = parse_time_or_die(opt, arg, 1);
3021     return 0;
3022 }
3023
3024 static int opt_recording_timestamp(const char *opt, const char *arg)
3025 {
3026     recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
3027     return 0;
3028 }
3029
3030 static int opt_input_ts_offset(const char *opt, const char *arg)
3031 {
3032     input_ts_offset = parse_time_or_die(opt, arg, 1);
3033     return 0;
3034 }
3035
3036 static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3037 {
3038     const char *codec_string = encoder ? "encoder" : "decoder";
3039     AVCodec *codec;
3040
3041     if(!name)
3042         return CODEC_ID_NONE;
3043     codec = encoder ?
3044         avcodec_find_encoder_by_name(name) :
3045         avcodec_find_decoder_by_name(name);
3046     if(!codec) {
3047         fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3048         ffmpeg_exit(1);
3049     }
3050     if(codec->type != type) {
3051         fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3052         ffmpeg_exit(1);
3053     }
3054     if(codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
3055        strict > FF_COMPLIANCE_EXPERIMENTAL) {
3056         fprintf(stderr, "%s '%s' is experimental and might produce bad "
3057                 "results.\nAdd '-strict experimental' if you want to use it.\n",
3058                 codec_string, codec->name);
3059         codec = encoder ?
3060             avcodec_find_encoder(codec->id) :
3061             avcodec_find_decoder(codec->id);
3062         if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
3063             fprintf(stderr, "Or use the non experimental %s '%s'.\n",
3064                     codec_string, codec->name);
3065         ffmpeg_exit(1);
3066     }
3067     return codec->id;
3068 }
3069
3070 static void opt_input_file(const char *filename)
3071 {
3072     AVFormatContext *ic;
3073     AVFormatParameters params, *ap = &params;
3074     AVInputFormat *file_iformat = NULL;
3075     int err, i, ret, rfps, rfps_base;
3076     int64_t timestamp;
3077
3078     if (last_asked_format) {
3079         if (!(file_iformat = av_find_input_format(last_asked_format))) {
3080             fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3081             ffmpeg_exit(1);
3082         }
3083         last_asked_format = NULL;
3084     }
3085
3086     if (!strcmp(filename, "-"))
3087         filename = "pipe:";
3088
3089     using_stdin |= !strncmp(filename, "pipe:", 5) ||
3090                     !strcmp(filename, "/dev/stdin");
3091
3092     /* get default parameters from command line */
3093     ic = avformat_alloc_context();
3094     if (!ic) {
3095         print_error(filename, AVERROR(ENOMEM));
3096         ffmpeg_exit(1);
3097     }
3098
3099     memset(ap, 0, sizeof(*ap));
3100     ap->prealloced_context = 1;
3101     ap->sample_rate = audio_sample_rate;
3102     ap->channels = audio_channels;
3103     ap->time_base.den = frame_rate.num;
3104     ap->time_base.num = frame_rate.den;
3105     ap->width = frame_width;
3106     ap->height = frame_height;
3107     ap->pix_fmt = frame_pix_fmt;
3108    // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
3109     ap->channel = video_channel;
3110     ap->standard = video_standard;
3111
3112     set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3113
3114     ic->video_codec_id   =
3115         find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0,
3116                           avcodec_opts[AVMEDIA_TYPE_VIDEO   ]->strict_std_compliance);
3117     ic->audio_codec_id   =
3118         find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0,
3119                           avcodec_opts[AVMEDIA_TYPE_AUDIO   ]->strict_std_compliance);
3120     ic->subtitle_codec_id=
3121         find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
3122                           avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3123     ic->flags |= AVFMT_FLAG_NONBLOCK;
3124
3125     /* open the input file with generic libav function */
3126     err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
3127     if (err < 0) {
3128         print_error(filename, err);
3129         ffmpeg_exit(1);
3130     }
3131     if(opt_programid) {
3132         int i, j;
3133         int found=0;
3134         for(i=0; i<ic->nb_streams; i++){
3135             ic->streams[i]->discard= AVDISCARD_ALL;
3136         }
3137         for(i=0; i<ic->nb_programs; i++){
3138             AVProgram *p= ic->programs[i];
3139             if(p->id != opt_programid){
3140                 p->discard = AVDISCARD_ALL;
3141             }else{
3142                 found=1;
3143                 for(j=0; j<p->nb_stream_indexes; j++){
3144                     ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3145                 }
3146             }
3147         }
3148         if(!found){
3149             fprintf(stderr, "Specified program id not found\n");
3150             ffmpeg_exit(1);
3151         }
3152         opt_programid=0;
3153     }
3154
3155     ic->loop_input = loop_input;
3156
3157     /* If not enough info to get the stream parameters, we decode the
3158        first frames to get it. (used in mpeg case for example) */
3159     ret = av_find_stream_info(ic);
3160     if (ret < 0 && verbose >= 0) {
3161         fprintf(stderr, "%s: could not find codec parameters\n", filename);
3162         av_close_input_file(ic);
3163         ffmpeg_exit(1);
3164     }
3165
3166     timestamp = start_time;
3167     /* add the stream start time */
3168     if (ic->start_time != AV_NOPTS_VALUE)
3169         timestamp += ic->start_time;
3170
3171     /* if seeking requested, we execute it */
3172     if (start_time != 0) {
3173         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3174         if (ret < 0) {
3175             fprintf(stderr, "%s: could not seek to position %0.3f\n",
3176                     filename, (double)timestamp / AV_TIME_BASE);
3177         }
3178         /* reset seek info */
3179         start_time = 0;
3180     }
3181
3182     /* update the current parameters so that they match the one of the input stream */
3183     for(i=0;i<ic->nb_streams;i++) {
3184         AVStream *st = ic->streams[i];
3185         AVCodecContext *dec = st->codec;
3186         dec->thread_count = thread_count;
3187         input_codecs = grow_array(input_codecs, sizeof(*input_codecs), &nb_input_codecs, nb_input_codecs + 1);
3188         switch (dec->codec_type) {
3189         case AVMEDIA_TYPE_AUDIO:
3190             input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(audio_codec_name);
3191             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]);
3192             //fprintf(stderr, "\nInput Audio channels: %d", dec->channels);
3193             channel_layout    = dec->channel_layout;
3194             audio_channels    = dec->channels;
3195             audio_sample_rate = dec->sample_rate;
3196             audio_sample_fmt  = dec->sample_fmt;
3197             if(audio_disable)
3198                 st->discard= AVDISCARD_ALL;
3199             /* Note that av_find_stream_info can add more streams, and we
3200              * currently have no chance of setting up lowres decoding
3201              * early enough for them. */
3202             if (dec->lowres)
3203                 audio_sample_rate >>= dec->lowres;
3204             break;
3205         case AVMEDIA_TYPE_VIDEO:
3206             input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(video_codec_name);
3207             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]);
3208             frame_height = dec->height;
3209             frame_width  = dec->width;
3210             if(ic->streams[i]->sample_aspect_ratio.num)
3211                 frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
3212             else
3213                 frame_aspect_ratio=av_q2d(dec->sample_aspect_ratio);
3214             frame_aspect_ratio *= (float) dec->width / dec->height;
3215             frame_pix_fmt = dec->pix_fmt;
3216             rfps      = ic->streams[i]->r_frame_rate.num;
3217             rfps_base = ic->streams[i]->r_frame_rate.den;
3218             if (dec->lowres) {
3219                 dec->flags |= CODEC_FLAG_EMU_EDGE;
3220                 frame_height >>= dec->lowres;
3221                 frame_width  >>= dec->lowres;
3222                 dec->height = frame_height;
3223                 dec->width  = frame_width;
3224             }
3225             if(me_threshold)
3226                 dec->debug |= FF_DEBUG_MV;
3227
3228             if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3229
3230                 if (verbose >= 0)
3231                     fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3232                             i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3233
3234                     (float)rfps / rfps_base, rfps, rfps_base);
3235             }
3236             /* update the current frame rate to match the stream frame rate */
3237             frame_rate.num = rfps;
3238             frame_rate.den = rfps_base;
3239
3240             if(video_disable)
3241                 st->discard= AVDISCARD_ALL;
3242             else if(video_discard)
3243                 st->discard= video_discard;
3244             break;
3245         case AVMEDIA_TYPE_DATA:
3246             break;
3247         case AVMEDIA_TYPE_SUBTITLE:
3248             input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(subtitle_codec_name);
3249             if(subtitle_disable)
3250                 st->discard = AVDISCARD_ALL;
3251             break;
3252         case AVMEDIA_TYPE_ATTACHMENT:
3253         case AVMEDIA_TYPE_UNKNOWN:
3254             break;
3255         default:
3256             abort();
3257         }
3258     }
3259
3260     input_files[nb_input_files] = ic;
3261     input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3262     /* dump the file content */
3263     if (verbose >= 0)
3264         av_dump_format(ic, nb_input_files, filename, 0);
3265
3266     nb_input_files++;
3267
3268     video_channel = 0;
3269
3270     av_freep(&video_codec_name);
3271     av_freep(&audio_codec_name);
3272     av_freep(&subtitle_codec_name);
3273 }
3274
3275 static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3276                                          int *has_subtitle_ptr)
3277 {
3278     int has_video, has_audio, has_subtitle, i, j;
3279     AVFormatContext *ic;
3280
3281     has_video = 0;
3282     has_audio = 0;
3283     has_subtitle = 0;
3284     for(j=0;j<nb_input_files;j++) {
3285         ic = input_files[j];
3286         for(i=0;i<ic->nb_streams;i++) {
3287             AVCodecContext *enc = ic->streams[i]->codec;
3288             switch(enc->codec_type) {
3289             case AVMEDIA_TYPE_AUDIO:
3290                 has_audio = 1;
3291                 break;
3292             case AVMEDIA_TYPE_VIDEO:
3293                 has_video = 1;
3294                 break;
3295             case AVMEDIA_TYPE_SUBTITLE:
3296                 has_subtitle = 1;
3297                 break;
3298             case AVMEDIA_TYPE_DATA:
3299             case AVMEDIA_TYPE_ATTACHMENT:
3300             case AVMEDIA_TYPE_UNKNOWN:
3301                 break;
3302             default:
3303                 abort();
3304             }
3305         }
3306     }
3307     *has_video_ptr = has_video;
3308     *has_audio_ptr = has_audio;
3309     *has_subtitle_ptr = has_subtitle;
3310 }
3311
3312 static void new_video_stream(AVFormatContext *oc, int file_idx)
3313 {
3314     AVStream *st;
3315     AVOutputStream *ost;
3316     AVCodecContext *video_enc;
3317     enum CodecID codec_id = CODEC_ID_NONE;
3318     AVCodec *codec= NULL;
3319
3320     st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3321     if (!st) {
3322         fprintf(stderr, "Could not alloc stream\n");
3323         ffmpeg_exit(1);
3324     }
3325     ost = new_output_stream(oc, file_idx);
3326
3327     output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3328     if(!video_stream_copy){
3329         if (video_codec_name) {
3330             codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
3331                                          avcodec_opts[AVMEDIA_TYPE_VIDEO]->strict_std_compliance);
3332             codec = avcodec_find_encoder_by_name(video_codec_name);
3333             output_codecs[nb_output_codecs-1] = codec;
3334         } else {
3335             codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3336             codec = avcodec_find_encoder(codec_id);
3337         }
3338     }
3339
3340     avcodec_get_context_defaults3(st->codec, codec);
3341     ost->bitstream_filters = video_bitstream_filters;
3342     video_bitstream_filters= NULL;
3343
3344     st->codec->thread_count= thread_count;
3345
3346     video_enc = st->codec;
3347
3348     if(video_codec_tag)
3349         video_enc->codec_tag= video_codec_tag;
3350
3351     if(   (video_global_header&1)
3352        || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3353         video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3354         avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3355     }
3356     if(video_global_header&2){
3357         video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3358         avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3359     }
3360
3361     if (video_stream_copy) {
3362         st->stream_copy = 1;
3363         video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3364         video_enc->sample_aspect_ratio =
3365         st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3366     } else {
3367         const char *p;
3368         int i;
3369         AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3370
3371         video_enc->codec_id = codec_id;
3372         set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3373
3374         if (codec && codec->supported_framerates && !force_fps)
3375             fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3376         video_enc->time_base.den = fps.num;
3377         video_enc->time_base.num = fps.den;
3378
3379         video_enc->width = frame_width;
3380         video_enc->height = frame_height;
3381         video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3382         video_enc->pix_fmt = frame_pix_fmt;
3383         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3384
3385         choose_pixel_fmt(st, codec);
3386
3387         if (intra_only)
3388             video_enc->gop_size = 0;
3389         if (video_qscale || same_quality) {
3390             video_enc->flags |= CODEC_FLAG_QSCALE;
3391             video_enc->global_quality=
3392                 st->quality = FF_QP2LAMBDA * video_qscale;
3393         }
3394
3395         if(intra_matrix)
3396             video_enc->intra_matrix = intra_matrix;
3397         if(inter_matrix)
3398             video_enc->inter_matrix = inter_matrix;
3399
3400         p= video_rc_override_string;
3401         for(i=0; p; i++){
3402             int start, end, q;
3403             int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3404             if(e!=3){
3405                 fprintf(stderr, "error parsing rc_override\n");
3406                 ffmpeg_exit(1);
3407             }
3408             video_enc->rc_override=
3409                 av_realloc(video_enc->rc_override,
3410                            sizeof(RcOverride)*(i+1));
3411             video_enc->rc_override[i].start_frame= start;
3412             video_enc->rc_override[i].end_frame  = end;
3413             if(q>0){
3414                 video_enc->rc_override[i].qscale= q;
3415                 video_enc->rc_override[i].quality_factor= 1.0;
3416             }
3417             else{
3418                 video_enc->rc_override[i].qscale= 0;
3419                 video_enc->rc_override[i].quality_factor= -q/100.0;
3420             }
3421             p= strchr(p, '/');
3422             if(p) p++;
3423         }
3424         video_enc->rc_override_count=i;
3425         if (!video_enc->rc_initial_buffer_occupancy)
3426             video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3427         video_enc->me_threshold= me_threshold;
3428         video_enc->intra_dc_precision= intra_dc_precision - 8;
3429
3430         if (do_psnr)
3431             video_enc->flags|= CODEC_FLAG_PSNR;
3432
3433         /* two pass mode */
3434         if (do_pass) {
3435             if (do_pass == 1) {
3436                 video_enc->flags |= CODEC_FLAG_PASS1;
3437             } else {
3438                 video_enc->flags |= CODEC_FLAG_PASS2;
3439             }
3440         }
3441
3442         if (forced_key_frames)
3443             parse_forced_key_frames(forced_key_frames, ost, video_enc);
3444     }
3445     if (video_language) {
3446         av_metadata_set2(&st->metadata, "language", video_language, 0);
3447         av_freep(&video_language);
3448     }
3449
3450     /* reset some key parameters */
3451     video_disable = 0;
3452     av_freep(&video_codec_name);
3453     av_freep(&forced_key_frames);
3454     video_stream_copy = 0;
3455     frame_pix_fmt = PIX_FMT_NONE;
3456 }
3457
3458 static void new_audio_stream(AVFormatContext *oc, int file_idx)
3459 {
3460     AVStream *st;
3461     AVOutputStream *ost;
3462     AVCodec *codec= NULL;
3463     AVCodecContext *audio_enc;
3464     enum CodecID codec_id = CODEC_ID_NONE;
3465
3466     st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3467     if (!st) {
3468         fprintf(stderr, "Could not alloc stream\n");
3469         ffmpeg_exit(1);
3470     }
3471     ost = new_output_stream(oc, file_idx);
3472
3473     output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3474     if(!audio_stream_copy){
3475         if (audio_codec_name) {
3476             codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
3477                                          avcodec_opts[AVMEDIA_TYPE_AUDIO]->strict_std_compliance);
3478             codec = avcodec_find_encoder_by_name(audio_codec_name);
3479             output_codecs[nb_output_codecs-1] = codec;
3480         } else {
3481             codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3482             codec = avcodec_find_encoder(codec_id);
3483         }
3484     }
3485
3486     avcodec_get_context_defaults3(st->codec, codec);
3487
3488     ost->bitstream_filters = audio_bitstream_filters;
3489     audio_bitstream_filters= NULL;
3490
3491     st->codec->thread_count= thread_count;
3492
3493     audio_enc = st->codec;
3494     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3495
3496     if(audio_codec_tag)
3497         audio_enc->codec_tag= audio_codec_tag;
3498
3499     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3500         audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3501         avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3502     }
3503     if (audio_stream_copy) {
3504         st->stream_copy = 1;
3505         audio_enc->channels = audio_channels;
3506         audio_enc->sample_rate = audio_sample_rate;
3507     } else {
3508         audio_enc->codec_id = codec_id;
3509         set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3510
3511         if (audio_qscale > QSCALE_NONE) {
3512             audio_enc->flags |= CODEC_FLAG_QSCALE;
3513             audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3514         }
3515         audio_enc->channels = audio_channels;
3516         audio_enc->sample_fmt = audio_sample_fmt;
3517         audio_enc->sample_rate = audio_sample_rate;
3518         audio_enc->channel_layout = channel_layout;
3519         if (av_get_channel_layout_nb_channels(channel_layout) != audio_channels)
3520             audio_enc->channel_layout = 0;
3521         choose_sample_fmt(st, codec);
3522         choose_sample_rate(st, codec);
3523     }
3524     audio_enc->time_base= (AVRational){1, audio_sample_rate};
3525     if (audio_language) {
3526         av_metadata_set2(&st->metadata, "language", audio_language, 0);
3527         av_freep(&audio_language);
3528     }
3529
3530     /* reset some key parameters */
3531     audio_disable = 0;
3532     av_freep(&audio_codec_name);
3533     audio_stream_copy = 0;
3534 }
3535
3536 static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3537 {
3538     AVStream *st;
3539     AVOutputStream *ost;
3540     AVCodec *codec=NULL;
3541     AVCodecContext *subtitle_enc;
3542     enum CodecID codec_id = CODEC_ID_NONE;
3543
3544     st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3545     if (!st) {
3546         fprintf(stderr, "Could not alloc stream\n");
3547         ffmpeg_exit(1);
3548     }
3549     ost = new_output_stream(oc, file_idx);
3550     subtitle_enc = st->codec;
3551     output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3552     if(!subtitle_stream_copy){
3553         if (subtitle_codec_name) {
3554             codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,
3555                                          avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3556             codec= output_codecs[nb_output_codecs-1] = avcodec_find_encoder_by_name(subtitle_codec_name);
3557         } else {
3558             codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_SUBTITLE);
3559             codec = avcodec_find_encoder(codec_id);
3560         }
3561     }
3562     avcodec_get_context_defaults3(st->codec, codec);
3563
3564     ost->bitstream_filters = subtitle_bitstream_filters;
3565     subtitle_bitstream_filters= NULL;
3566
3567     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3568
3569     if(subtitle_codec_tag)
3570         subtitle_enc->codec_tag= subtitle_codec_tag;
3571
3572     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3573         subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3574         avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3575     }
3576     if (subtitle_stream_copy) {
3577         st->stream_copy = 1;
3578     } else {
3579         subtitle_enc->codec_id = codec_id;
3580         set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3581     }
3582
3583     if (subtitle_language) {
3584         av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3585         av_freep(&subtitle_language);
3586     }
3587
3588     subtitle_disable = 0;
3589     av_freep(&subtitle_codec_name);
3590     subtitle_stream_copy = 0;
3591 }
3592
3593 static int opt_new_stream(const char *opt, const char *arg)
3594 {
3595     AVFormatContext *oc;
3596     int file_idx = nb_output_files - 1;
3597     if (nb_output_files <= 0) {
3598         fprintf(stderr, "At least one output file must be specified\n");
3599         ffmpeg_exit(1);
3600     }
3601     oc = output_files[file_idx];
3602
3603     if      (!strcmp(opt, "newvideo"   )) new_video_stream   (oc, file_idx);
3604     else if (!strcmp(opt, "newaudio"   )) new_audio_stream   (oc, file_idx);
3605     else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3606     else av_assert0(0);
3607     return 0;
3608 }
3609
3610 /* arg format is "output-stream-index:streamid-value". */
3611 static int opt_streamid(const char *opt, const char *arg)
3612 {
3613     int idx;
3614     char *p;
3615     char idx_str[16];
3616
3617     strncpy(idx_str, arg, sizeof(idx_str));
3618     idx_str[sizeof(idx_str)-1] = '\0';
3619     p = strchr(idx_str, ':');
3620     if (!p) {
3621         fprintf(stderr,
3622                 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3623                 arg, opt);
3624         ffmpeg_exit(1);
3625     }
3626     *p++ = '\0';
3627     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3628     streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3629     streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3630     return 0;
3631 }
3632
3633 static void opt_output_file(const char *filename)
3634 {
3635     AVFormatContext *oc;
3636     int err, use_video, use_audio, use_subtitle;
3637     int input_has_video, input_has_audio, input_has_subtitle;
3638     AVFormatParameters params, *ap = &params;
3639     AVOutputFormat *file_oformat;
3640
3641     if (!strcmp(filename, "-"))
3642         filename = "pipe:";
3643
3644     oc = avformat_alloc_context();
3645     if (!oc) {
3646         print_error(filename, AVERROR(ENOMEM));
3647         ffmpeg_exit(1);
3648     }
3649
3650     if (last_asked_format) {
3651         file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3652         if (!file_oformat) {
3653             fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3654             ffmpeg_exit(1);
3655         }
3656         last_asked_format = NULL;
3657     } else {
3658         file_oformat = av_guess_format(NULL, filename, NULL);
3659         if (!file_oformat) {
3660             fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3661                     filename);
3662             ffmpeg_exit(1);
3663         }
3664     }
3665
3666     oc->oformat = file_oformat;
3667     av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3668
3669     if (!strcmp(file_oformat->name, "ffm") &&
3670         av_strstart(filename, "http:", NULL)) {
3671         /* special case for files sent to ffserver: we get the stream
3672            parameters from ffserver */
3673         int err = read_ffserver_streams(oc, filename);
3674         if (err < 0) {
3675             print_error(filename, err);
3676             ffmpeg_exit(1);
3677         }
3678     } else {
3679         use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3680         use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3681         use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3682
3683         /* disable if no corresponding type found and at least one
3684            input file */
3685         if (nb_input_files > 0) {
3686             check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3687                                          &input_has_subtitle);
3688             if (!input_has_video)
3689                 use_video = 0;
3690             if (!input_has_audio)
3691                 use_audio = 0;
3692             if (!input_has_subtitle)
3693                 use_subtitle = 0;
3694         }
3695
3696         /* manual disable */
3697         if (audio_disable)    use_audio    = 0;
3698         if (video_disable)    use_video    = 0;
3699         if (subtitle_disable) use_subtitle = 0;
3700
3701         if (use_video)    new_video_stream(oc, nb_output_files);
3702         if (use_audio)    new_audio_stream(oc, nb_output_files);
3703         if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3704
3705         oc->timestamp = recording_timestamp;
3706
3707         av_metadata_copy(&oc->metadata, metadata, 0);
3708         av_metadata_free(&metadata);
3709     }
3710
3711     output_files[nb_output_files++] = oc;
3712
3713     /* check filename in case of an image number is expected */
3714     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3715         if (!av_filename_number_test(oc->filename)) {
3716             print_error(oc->filename, AVERROR_NUMEXPECTED);
3717             ffmpeg_exit(1);
3718         }
3719     }
3720
3721     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3722         /* test if it already exists to avoid loosing precious files */
3723         if (!file_overwrite &&
3724             (strchr(filename, ':') == NULL ||
3725              filename[1] == ':' ||
3726              av_strstart(filename, "file:", NULL))) {
3727             if (url_exist(filename)) {
3728                 if (!using_stdin) {
3729                     fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3730                     fflush(stderr);
3731                     if (!read_yesno()) {
3732                         fprintf(stderr, "Not overwriting - exiting\n");
3733                         ffmpeg_exit(1);
3734                     }
3735                 }
3736                 else {
3737                     fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3738                     ffmpeg_exit(1);
3739                 }
3740             }
3741         }
3742
3743         /* open the file */
3744         if ((err = avio_open(&oc->pb, filename, URL_WRONLY)) < 0) {
3745             print_error(filename, err);
3746             ffmpeg_exit(1);
3747         }
3748     }
3749
3750     memset(ap, 0, sizeof(*ap));
3751     if (av_set_parameters(oc, ap) < 0) {
3752         fprintf(stderr, "%s: Invalid encoding parameters\n",
3753                 oc->filename);
3754         ffmpeg_exit(1);
3755     }
3756
3757     oc->preload= (int)(mux_preload*AV_TIME_BASE);
3758     oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3759     oc->loop_output = loop_output;
3760     oc->flags |= AVFMT_FLAG_NONBLOCK;
3761
3762     set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
3763
3764     av_freep(&forced_key_frames);
3765 }
3766
3767 /* same option as mencoder */
3768 static void opt_pass(const char *pass_str)
3769 {
3770     int pass;
3771     pass = atoi(pass_str);
3772     if (pass != 1 && pass != 2) {
3773         fprintf(stderr, "pass number can be only 1 or 2\n");
3774         ffmpeg_exit(1);
3775     }
3776     do_pass = pass;
3777 }
3778
3779 static int64_t getutime(void)
3780 {
3781 #if HAVE_GETRUSAGE
3782     struct rusage rusage;
3783
3784     getrusage(RUSAGE_SELF, &rusage);
3785     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3786 #elif HAVE_GETPROCESSTIMES
3787     HANDLE proc;
3788     FILETIME c, e, k, u;
3789     proc = GetCurrentProcess();
3790     GetProcessTimes(proc, &c, &e, &k, &u);
3791     return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3792 #else
3793     return av_gettime();
3794 #endif
3795 }
3796
3797 static int64_t getmaxrss(void)
3798 {
3799 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3800     struct rusage rusage;
3801     getrusage(RUSAGE_SELF, &rusage);
3802     return (int64_t)rusage.ru_maxrss * 1024;
3803 #elif HAVE_GETPROCESSMEMORYINFO
3804     HANDLE proc;
3805     PROCESS_MEMORY_COUNTERS memcounters;
3806     proc = GetCurrentProcess();
3807     memcounters.cb = sizeof(memcounters);
3808     GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3809     return memcounters.PeakPagefileUsage;
3810 #else
3811     return 0;
3812 #endif
3813 }
3814
3815 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3816 {
3817     int i;
3818     const char *p = str;
3819     for(i = 0;; i++) {
3820         dest[i] = atoi(p);
3821         if(i == 63)
3822             break;
3823         p = strchr(p, ',');
3824         if(!p) {
3825             fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3826             ffmpeg_exit(1);
3827         }
3828         p++;
3829     }
3830 }
3831
3832 static void opt_inter_matrix(const char *arg)
3833 {
3834     inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3835     parse_matrix_coeffs(inter_matrix, arg);
3836 }
3837
3838 static void opt_intra_matrix(const char *arg)
3839 {
3840     intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3841     parse_matrix_coeffs(intra_matrix, arg);
3842 }
3843
3844 static void show_usage(void)
3845 {
3846     printf("Hyper fast Audio and Video encoder\n");
3847     printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3848     printf("\n");
3849 }
3850
3851 static void show_help(void)
3852 {
3853     AVCodec *c;
3854     AVOutputFormat *oformat = NULL;
3855
3856     av_log_set_callback(log_callback_help);
3857     show_usage();
3858     show_help_options(options, "Main options:\n",
3859                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3860     show_help_options(options, "\nAdvanced options:\n",
3861                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3862                       OPT_EXPERT);
3863     show_help_options(options, "\nVideo options:\n",
3864                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3865                       OPT_VIDEO);
3866     show_help_options(options, "\nAdvanced Video options:\n",
3867                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3868                       OPT_VIDEO | OPT_EXPERT);
3869     show_help_options(options, "\nAudio options:\n",
3870                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3871                       OPT_AUDIO);
3872     show_help_options(options, "\nAdvanced Audio options:\n",
3873                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3874                       OPT_AUDIO | OPT_EXPERT);
3875     show_help_options(options, "\nSubtitle options:\n",
3876                       OPT_SUBTITLE | OPT_GRAB,
3877                       OPT_SUBTITLE);
3878     show_help_options(options, "\nAudio/Video grab options:\n",
3879                       OPT_GRAB,
3880                       OPT_GRAB);
3881     printf("\n");
3882     av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3883     printf("\n");
3884
3885     /* individual codec options */
3886     c = NULL;
3887     while ((c = av_codec_next(c))) {
3888         if (c->priv_class) {
3889             av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3890             printf("\n");
3891         }
3892     }
3893
3894     av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3895     printf("\n");
3896
3897     /* individual muxer options */
3898     while ((oformat = av_oformat_next(oformat))) {
3899         if (oformat->priv_class) {
3900             av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
3901             printf("\n");
3902         }
3903     }
3904
3905     av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3906 }
3907
3908 static void opt_target(const char *arg)
3909 {
3910     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3911     static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3912
3913     if(!strncmp(arg, "pal-", 4)) {
3914         norm = PAL;
3915         arg += 4;
3916     } else if(!strncmp(arg, "ntsc-", 5)) {
3917         norm = NTSC;
3918         arg += 5;
3919     } else if(!strncmp(arg, "film-", 5)) {
3920         norm = FILM;
3921         arg += 5;
3922     } else {
3923         int fr;
3924         /* Calculate FR via float to avoid int overflow */
3925         fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3926         if(fr == 25000) {
3927             norm = PAL;
3928         } else if((fr == 29970) || (fr == 23976)) {
3929             norm = NTSC;
3930         } else {
3931             /* Try to determine PAL/NTSC by peeking in the input files */
3932             if(nb_input_files) {
3933                 int i, j;
3934                 for(j = 0; j < nb_input_files; j++) {
3935                     for(i = 0; i < input_files[j]->nb_streams; i++) {
3936                         AVCodecContext *c = input_files[j]->streams[i]->codec;
3937                         if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3938                             continue;
3939                         fr = c->time_base.den * 1000 / c->time_base.num;
3940                         if(fr == 25000) {
3941                             norm = PAL;
3942                             break;
3943                         } else if((fr == 29970) || (fr == 23976)) {
3944                             norm = NTSC;
3945                             break;
3946                         }
3947                     }
3948                     if(norm != UNKNOWN)
3949                         break;
3950                 }
3951             }
3952         }
3953         if(verbose && norm != UNKNOWN)
3954             fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
3955     }
3956
3957     if(norm == UNKNOWN) {
3958         fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3959         fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3960         fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3961         ffmpeg_exit(1);
3962     }
3963
3964     if(!strcmp(arg, "vcd")) {
3965
3966         opt_video_codec("mpeg1video");
3967         opt_audio_codec("mp2");
3968         opt_format("vcd");
3969
3970         opt_frame_size(norm == PAL ? "352x288" : "352x240");
3971         opt_frame_rate(NULL, frame_rates[norm]);
3972         opt_default("g", norm == PAL ? "15" : "18");
3973
3974         opt_default("b", "1150000");
3975         opt_default("maxrate", "1150000");
3976         opt_default("minrate", "1150000");
3977         opt_default("bufsize", "327680"); // 40*1024*8;
3978
3979         opt_default("ab", "224000");
3980         audio_sample_rate = 44100;
3981         audio_channels = 2;
3982
3983         opt_default("packetsize", "2324");
3984         opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3985
3986         /* We have to offset the PTS, so that it is consistent with the SCR.
3987            SCR starts at 36000, but the first two packs contain only padding
3988            and the first pack from the other stream, respectively, may also have
3989            been written before.
3990            So the real data starts at SCR 36000+3*1200. */
3991         mux_preload= (36000+3*1200) / 90000.0; //0.44
3992     } else if(!strcmp(arg, "svcd")) {
3993
3994         opt_video_codec("mpeg2video");
3995         opt_audio_codec("mp2");
3996         opt_format("svcd");
3997
3998         opt_frame_size(norm == PAL ? "480x576" : "480x480");
3999         opt_frame_rate(NULL, frame_rates[norm]);
4000         opt_default("g", norm == PAL ? "15" : "18");
4001
4002         opt_default("b", "2040000");
4003         opt_default("maxrate", "2516000");
4004         opt_default("minrate", "0"); //1145000;
4005         opt_default("bufsize", "1835008"); //224*1024*8;
4006         opt_default("flags", "+scan_offset");
4007
4008
4009         opt_default("ab", "224000");
4010         audio_sample_rate = 44100;
4011
4012         opt_default("packetsize", "2324");
4013
4014     } else if(!strcmp(arg, "dvd")) {
4015
4016         opt_video_codec("mpeg2video");
4017         opt_audio_codec("ac3");
4018         opt_format("dvd");
4019
4020         opt_frame_size(norm == PAL ? "720x576" : "720x480");
4021         opt_frame_rate(NULL, frame_rates[norm]);
4022         opt_default("g", norm == PAL ? "15" : "18");
4023
4024         opt_default("b", "6000000");
4025         opt_default("maxrate", "9000000");
4026         opt_default("minrate", "0"); //1500000;
4027         opt_default("bufsize", "1835008"); //224*1024*8;
4028
4029         opt_default("packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4030         opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4031
4032         opt_default("ab", "448000");
4033         audio_sample_rate = 48000;
4034
4035     } else if(!strncmp(arg, "dv", 2)) {
4036
4037         opt_format("dv");
4038
4039         opt_frame_size(norm == PAL ? "720x576" : "720x480");
4040         opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
4041                           (norm == PAL ? "yuv420p" : "yuv411p"));
4042         opt_frame_rate(NULL, frame_rates[norm]);
4043
4044         audio_sample_rate = 48000;
4045         audio_channels = 2;
4046
4047     } else {
4048         fprintf(stderr, "Unknown target: %s\n", arg);
4049         ffmpeg_exit(1);
4050     }
4051 }
4052
4053 static void opt_vstats_file (const char *arg)
4054 {
4055     av_free (vstats_filename);
4056     vstats_filename=av_strdup (arg);
4057 }
4058
4059 static void opt_vstats (void)
4060 {
4061     char filename[40];
4062     time_t today2 = time(NULL);
4063     struct tm *today = localtime(&today2);
4064
4065     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4066              today->tm_sec);
4067     opt_vstats_file(filename);
4068 }
4069
4070 static int opt_bsf(const char *opt, const char *arg)
4071 {
4072     AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4073     AVBitStreamFilterContext **bsfp;
4074
4075     if(!bsfc){
4076         fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4077         ffmpeg_exit(1);
4078     }
4079
4080     bsfp= *opt == 'v' ? &video_bitstream_filters :
4081           *opt == 'a' ? &audio_bitstream_filters :
4082                         &subtitle_bitstream_filters;
4083     while(*bsfp)
4084         bsfp= &(*bsfp)->next;
4085
4086     *bsfp= bsfc;
4087
4088     return 0;
4089 }
4090
4091 static int opt_preset(const char *opt, const char *arg)
4092 {
4093     FILE *f=NULL;
4094     char filename[1000], tmp[1000], tmp2[1000], line[1000];
4095     char *codec_name = *opt == 'v' ? video_codec_name :
4096                        *opt == 'a' ? audio_codec_name :
4097                                      subtitle_codec_name;
4098
4099     if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4100         fprintf(stderr, "File for preset '%s' not found\n", arg);
4101         ffmpeg_exit(1);
4102     }
4103
4104     while(!feof(f)){
4105         int e= fscanf(f, "%999[^\n]\n", line) - 1;
4106         if(line[0] == '#' && !e)
4107             continue;
4108         e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4109         if(e){
4110             fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4111             ffmpeg_exit(1);
4112         }
4113         if(!strcmp(tmp, "acodec")){
4114             opt_audio_codec(tmp2);
4115         }else if(!strcmp(tmp, "vcodec")){
4116             opt_video_codec(tmp2);
4117         }else if(!strcmp(tmp, "scodec")){
4118             opt_subtitle_codec(tmp2);
4119         }else if(opt_default(tmp, tmp2) < 0){
4120             fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4121             ffmpeg_exit(1);
4122         }
4123     }
4124
4125     fclose(f);
4126
4127     return 0;
4128 }
4129
4130 static const OptionDef options[] = {
4131     /* main options */
4132 #include "cmdutils_common_opts.h"
4133     { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4134     { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4135     { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4136     { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4137     { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
4138       "outfile[,metadata]:infile[,metadata]" },
4139     { "map_metadata", HAS_ARG | OPT_EXPERT, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4140       "outfile[,metadata]:infile[,metadata]" },
4141     { "map_chapters",  HAS_ARG | OPT_EXPERT, {(void*)opt_map_chapters},  "set chapters mapping", "outfile:infile" },
4142     { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4143     { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4144     { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4145     { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4146     { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
4147     { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4148     { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4149     { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4150     { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4151       "add timings for benchmarking" },
4152     { "timelimit", OPT_FUNC2 | HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4153     { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4154       "dump each input packet" },
4155     { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4156       "when dumping packets, also dump the payload" },
4157     { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4158     { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
4159     { "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)", "" },
4160     { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
4161     { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4162     { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4163     { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4164     { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4165     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4166     { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
4167     { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
4168     { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)&copy_tb}, "copy input stream time base when stream copying" },
4169     { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4170     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4171     { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4172     { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4173     { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)&copy_initial_nonkeyframes}, "copy initial non-keyframes" },
4174
4175     /* video options */
4176     { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4177     { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4178     { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4179     { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4180     { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4181     { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4182     { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format, 'list' as argument shows all the pixel formats supported", "format" },
4183     { "croptop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4184     { "cropbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4185     { "cropleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4186     { "cropright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4187     { "padtop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4188     { "padbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4189     { "padleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4190     { "padright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4191     { "padcolor", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4192     { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4193     { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4194     { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4195     { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4196     { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4197     { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4198     { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "threshold" },
4199     { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4200       "use same video quality as source (implies VBR)" },
4201     { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
4202     { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4203     { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4204       "deinterlace pictures" },
4205     { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4206     { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4207     { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4208 #if CONFIG_AVFILTER
4209     { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4210 #endif
4211     { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4212     { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4213     { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4214     { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4215     { "vtag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4216     { "newvideo", OPT_VIDEO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new video stream to the current output stream" },
4217     { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4218     { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4219     { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4220     { "streamid", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4221     { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4222
4223     /* audio options */
4224     { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4225     { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4226     { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4227     { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4228     { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4229     { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4230     { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4231     { "atag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4232     { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4233     { "newaudio", OPT_AUDIO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
4234     { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4235     { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_sample_fmt}, "set sample format, 'list' as argument shows all the sample formats supported", "format" },
4236
4237     /* subtitle options */
4238     { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4239     { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4240     { "newsubtitle", OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4241     { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4242     { "stag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4243
4244     /* grab options */
4245     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4246     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4247     { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4248
4249     /* muxer options */
4250     { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4251     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4252
4253     { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4254     { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4255     { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4256
4257     { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4258     { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4259     { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4260     { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4261
4262     { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4263     { NULL, },
4264 };
4265
4266 int main(int argc, char **argv)
4267 {
4268     int64_t ti;
4269
4270     av_log_set_flags(AV_LOG_SKIP_REPEATED);
4271
4272     avcodec_register_all();
4273 #if CONFIG_AVDEVICE
4274     avdevice_register_all();
4275 #endif
4276 #if CONFIG_AVFILTER
4277     avfilter_register_all();
4278 #endif
4279     av_register_all();
4280
4281 #if HAVE_ISATTY
4282     if(isatty(STDIN_FILENO))
4283         url_set_interrupt_cb(decode_interrupt_cb);
4284 #endif
4285
4286     init_opts();
4287
4288     show_banner();
4289
4290     /* parse options */
4291     parse_options(argc, argv, options, opt_output_file);
4292
4293     if(nb_output_files <= 0 && nb_input_files == 0) {
4294         show_usage();
4295         fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4296         ffmpeg_exit(1);
4297     }
4298
4299     /* file converter / grab */
4300     if (nb_output_files <= 0) {
4301         fprintf(stderr, "At least one output file must be specified\n");
4302         ffmpeg_exit(1);
4303     }
4304
4305     if (nb_input_files == 0) {
4306         fprintf(stderr, "At least one input file must be specified\n");
4307         ffmpeg_exit(1);
4308     }
4309
4310     ti = getutime();
4311     if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4312                   stream_maps, nb_stream_maps) < 0)
4313         ffmpeg_exit(1);
4314     ti = getutime() - ti;
4315     if (do_benchmark) {
4316         int maxrss = getmaxrss() / 1024;
4317         printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4318     }
4319
4320     return ffmpeg_exit(0);
4321 }