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