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