git.sesse.net Git - ffmpeg/blob - ffmpeg.c

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