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