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