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