avconv.c

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