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

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