ffmpeg.c 138 KB
Newer Older
glantau's avatar
merge  
glantau committed
1
/*
2
 * FFmpeg main
bellard's avatar
bellard committed
3
 * Copyright (c) 2000-2003 Fabrice Bellard
glantau's avatar
merge  
glantau committed
4
 *
5 6 7
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
8 9
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
10
 * version 2.1 of the License, or (at your option) any later version.
glantau's avatar
merge  
glantau committed
11
 *
12
 * FFmpeg is distributed in the hope that it will be useful,
glantau's avatar
merge  
glantau committed
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 15
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
glantau's avatar
merge  
glantau committed
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
glantau's avatar
merge  
glantau committed
20
 */
glantau's avatar
glantau committed
21
#define HAVE_AV_CONFIG_H
michael's avatar
michael committed
22
#include <limits.h>
glantau's avatar
glantau committed
23
#include "avformat.h"
24
#include "swscale.h"
25
#include "framehook.h"
26
#include "dsputil.h"
michael's avatar
michael committed
27
#include "opt.h"
28
#include "fifo.h"
glantau's avatar
glantau committed
29

30
#ifndef __MINGW32__
glantau's avatar
merge  
glantau committed
31 32 33 34 35
#include <unistd.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <sys/time.h>
#include <termios.h>
glantau's avatar
glantau committed
36
#include <sys/resource.h>
37
#include <signal.h>
glantau's avatar
glantau committed
38
#endif
39 40 41 42 43
#ifdef CONFIG_OS2
#include <sys/types.h>
#include <sys/select.h>
#include <stdlib.h>
#endif
michael's avatar
michael committed
44
#undef time //needed because HAVE_AV_CONFIG_H is defined on top
45
#include <time.h>
glantau's avatar
merge  
glantau committed
46

47
#include "version.h"
bellard's avatar
bellard committed
48 49
#include "cmdutils.h"

michael's avatar
michael committed
50 51 52
#undef NDEBUG
#include <assert.h>

53 54 55
#if !defined(INFINITY) && defined(HUGE_VAL)
#define INFINITY HUGE_VAL
#endif
glantau's avatar
merge  
glantau committed
56 57 58 59 60

/* select an input stream for an output stream */
typedef struct AVStreamMap {
    int file_index;
    int stream_index;
61 62
    int sync_file_index;
    int sync_stream_index;
glantau's avatar
merge  
glantau committed
63 64
} AVStreamMap;

65 66 67 68 69 70
/** select an input file for an output file */
typedef struct AVMetaDataMap {
    int out_file;
    int in_file;
} AVMetaDataMap;

glantau's avatar
merge  
glantau committed
71 72
extern const OptionDef options[];

73 74
static void show_help(void);
static void show_license(void);
75
static int opt_default(const char *opt, const char *arg);
glantau's avatar
merge  
glantau committed
76 77 78 79

#define MAX_FILES 20

static AVFormatContext *input_files[MAX_FILES];
michael's avatar
michael committed
80
static int64_t input_files_ts_offset[MAX_FILES];
glantau's avatar
merge  
glantau committed
81 82 83 84 85 86 87 88
static int nb_input_files = 0;

static AVFormatContext *output_files[MAX_FILES];
static int nb_output_files = 0;

static AVStreamMap stream_maps[MAX_FILES];
static int nb_stream_maps;

89 90 91
static AVMetaDataMap meta_data_maps[MAX_FILES];
static int nb_meta_data_maps;

92 93
static AVInputFormat *file_iformat;
static AVOutputFormat *file_oformat;
94
static AVImageFormat *image_format;
michael's avatar
michael committed
95 96
static int frame_width  = 0;
static int frame_height = 0;
romansh's avatar
 
romansh committed
97
static float frame_aspect_ratio = 0;
michael's avatar
michael committed
98
static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
99 100 101 102 103
static int frame_padtop  = 0;
static int frame_padbottom = 0;
static int frame_padleft  = 0;
static int frame_padright = 0;
static int padcolor[3] = {16,128,128}; /* default to black */
104 105 106 107
static int frame_topBand  = 0;
static int frame_bottomBand = 0;
static int frame_leftBand  = 0;
static int frame_rightBand = 0;
108
static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
109 110
static int frame_rate = 25;
static int frame_rate_base = 1;
111
static float video_qscale = 0;
112
static int video_qdiff = 3;
113 114
static uint16_t *intra_matrix = NULL;
static uint16_t *inter_matrix = NULL;
115
#if 0 //experimental, (can be removed)
michaelni's avatar
michaelni committed
116 117 118
static float video_rc_qsquish=1.0;
static float video_rc_qmod_amp=0;
static int video_rc_qmod_freq=0;
119
#endif
michaelni's avatar
michaelni committed
120 121
static char *video_rc_override_string=NULL;
static char *video_rc_eq="tex^qComp";
122
static int me_method = ME_EPZS;
glantau's avatar
merge  
glantau committed
123
static int video_disable = 0;
124
static int video_discard = 0;
glantau's avatar
merge  
glantau committed
125
static int video_codec_id = CODEC_ID_NONE;
michael's avatar
michael committed
126
static int video_codec_tag = 0;
glantau's avatar
merge  
glantau committed
127
static int same_quality = 0;
128
static int do_deinterlace = 0;
129
static int packet_size = 0;
michaelni's avatar
michaelni committed
130
static int strict = 0;
michael's avatar
michael committed
131
static int top_field_first = -1;
132
static int me_threshold = 0;
michael's avatar
-cbp  
michael committed
133
static int intra_dc_precision = 8;
134
static int loop_input = 0;
135
static int loop_output = AVFMT_NOOUTPUTLOOP;
136
static int qp_hist = 0;
glantau's avatar
merge  
glantau committed
137 138 139 140

static int intra_only = 0;
static int audio_sample_rate = 44100;
static int audio_bit_rate = 64000;
141 142
#define QSCALE_NONE -99999
static float audio_qscale = QSCALE_NONE;
glantau's avatar
merge  
glantau committed
143 144 145
static int audio_disable = 0;
static int audio_channels = 1;
static int audio_codec_id = CODEC_ID_NONE;
michael's avatar
michael committed
146
static int audio_codec_tag = 0;
147 148 149 150
static char *audio_language = NULL;

static int subtitle_codec_id = CODEC_ID_NONE;
static char *subtitle_language = NULL;
glantau's avatar
merge  
glantau committed
151

152 153
static float mux_preload= 0.5;
static float mux_max_delay= 0.7;
154

kabi's avatar
kabi committed
155
static int64_t recording_time = 0;
156
static int64_t start_time = 0;
romansh's avatar
 
romansh committed
157
static int64_t rec_timestamp = 0;
michael's avatar
michael committed
158
static int64_t input_ts_offset = 0;
glantau's avatar
merge  
glantau committed
159 160 161 162 163
static int file_overwrite = 0;
static char *str_title = NULL;
static char *str_author = NULL;
static char *str_copyright = NULL;
static char *str_comment = NULL;
164
static char *str_album = NULL;
glantau's avatar
glantau committed
165
static int do_benchmark = 0;
166
static int do_hex_dump = 0;
167
static int do_pkt_dump = 0;
168
static int do_psnr = 0;
169
static int do_vstats = 0;
170 171
static int do_pass = 0;
static char *pass_logfilename = NULL;
172 173
static int audio_stream_copy = 0;
static int video_stream_copy = 0;
174
static int subtitle_stream_copy = 0;
michael's avatar
michael committed
175 176
static int video_sync_method= 1;
static int audio_sync_method= 0;
177
static int copy_ts= 0;
178
static int opt_shortest = 0; //
179
static int video_global_header = 0;
180

181 182
static int rate_emu = 0;

183
#ifdef CONFIG_BKTR
184
static const char *video_grab_format = "bktr";
185
#else
diego's avatar
diego committed
186
#ifdef CONFIG_VIDEO4LINUX2
187
static const char *video_grab_format = "video4linux2";
diego's avatar
diego committed
188
#else
189
static const char *video_grab_format = "video4linux";
190
#endif
diego's avatar
diego committed
191
#endif
192
static char *video_device = NULL;
romansh's avatar
 
romansh committed
193
static char *grab_device = NULL;
194
static int  video_channel = 0;
195
static char *video_standard = "ntsc";
196

197
static const char *audio_grab_format = "audio_device";
198
static char *audio_device = NULL;
199
static int audio_volume = 256;
200

201
static int using_stdin = 0;
202
static int using_vhook = 0;
203
static int verbose = 1;
204
static int thread_count= 1;
205
static int q_pressed = 0;
206 207 208
static int64_t video_size = 0;
static int64_t audio_size = 0;
static int64_t extra_size = 0;
michael's avatar
michael committed
209 210
static int nb_frames_dup = 0;
static int nb_frames_drop = 0;
211
static int input_sync;
212
static int limit_filesize = 0; //
213

214
static int pgmyuv_compatibility_hack=0;
215
static int dts_delta_threshold = 10;
216

217 218
static int sws_flags = SWS_BICUBIC;

michael's avatar
michael committed
219 220 221
const char **opt_names=NULL;
int opt_name_count=0;
AVCodecContext *avctx_opts;
222
AVFormatContext *avformat_opts;
michael's avatar
michael committed
223

224 225 226
static AVBitStreamFilterContext *video_bitstream_filters=NULL;
static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
227

228
#define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
glantau's avatar
merge  
glantau committed
229

230 231
struct AVInputStream;

glantau's avatar
merge  
glantau committed
232 233 234 235 236
typedef struct AVOutputStream {
    int file_index;          /* file index */
    int index;               /* stream index in the output file */
    int source_index;        /* AVInputStream index */
    AVStream *st;            /* stream in the output file */
237 238 239 240
    int encoding_needed;     /* true if encoding needed for this stream */
    int frame_number;
    /* input pts and corresponding output pts
       for A/V sync */
241 242
    //double sync_ipts;        /* dts from the AVPacket of the demuxer in second units */
    struct AVInputStream *sync_ist; /* input stream to sync against */
243
    int64_t sync_opts;       /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
glantau's avatar
merge  
glantau committed
244
    /* video only */
245
    int video_resample;
246
    AVFrame pict_tmp;      /* temporary image for resampling */
247 248
    struct SwsContext *img_resample_ctx; /* for image resampling */
    int resample_height;
249

250
    int video_crop;
251 252
    int topBand;             /* cropping area sizes */
    int leftBand;
253

254
    int video_pad;
255 256 257 258
    int padtop;              /* padding area sizes */
    int padbottom;
    int padleft;
    int padright;
259

glantau's avatar
merge  
glantau committed
260 261 262
    /* audio only */
    int audio_resample;
    ReSampleContext *resample; /* for audio resampling */
263
    AVFifoBuffer fifo;     /* for compression: one audio fifo per codec */
264
    FILE *logfile;
glantau's avatar
merge  
glantau committed
265 266 267 268 269 270 271 272
} AVOutputStream;

typedef struct AVInputStream {
    int file_index;
    int index;
    AVStream *st;
    int discard;             /* true if stream data should be discarded */
    int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
kabi's avatar
kabi committed
273
    int64_t sample_index;      /* current sample */
274 275 276

    int64_t       start;     /* time when read started */
    unsigned long frame;     /* current frame */
277 278
    int64_t       next_pts;  /* synthetic pts for cases where pkt.pts
                                is not defined */
romansh's avatar
 
romansh committed
279
    int64_t       pts;       /* current pts */
michael's avatar
michael committed
280
    int is_start;            /* is 1 at the start and after a discontinuity */
glantau's avatar
merge  
glantau committed
281 282 283 284 285 286 287 288
} AVInputStream;

typedef struct AVInputFile {
    int eof_reached;      /* true if eof reached */
    int ist_index;        /* index of first stream in ist_table */
    int buffer_size;      /* current total buffer size */
    int buffer_size_max;  /* buffer size at which we consider we can stop
                             buffering */
289
    int nb_streams;       /* nb streams we are aware of */
glantau's avatar
merge  
glantau committed
290 291
} AVInputFile;

292
#ifndef __MINGW32__
glantau's avatar
glantau committed
293

glantau's avatar
merge  
glantau committed
294 295 296 297 298 299 300 301
/* init terminal so that we can grab keys */
static struct termios oldtty;

static void term_exit(void)
{
    tcsetattr (0, TCSANOW, &oldtty);
}

302 303 304 305 306 307 308 309 310
static volatile sig_atomic_t received_sigterm = 0;

static void
sigterm_handler(int sig)
{
    received_sigterm = sig;
    term_exit();
}

glantau's avatar
merge  
glantau committed
311 312 313 314 315 316 317 318 319 320 321 322 323 324 325
static void term_init(void)
{
    struct termios tty;

    tcgetattr (0, &tty);
    oldtty = tty;

    tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
                          |INLCR|IGNCR|ICRNL|IXON);
    tty.c_oflag |= OPOST;
    tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
    tty.c_cflag &= ~(CSIZE|PARENB);
    tty.c_cflag |= CS8;
    tty.c_cc[VMIN] = 1;
    tty.c_cc[VTIME] = 0;
326

glantau's avatar
merge  
glantau committed
327 328
    tcsetattr (0, TCSANOW, &tty);

329 330 331 332 333 334
    signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
    signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
    signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
    /*
    register a function to be called at normal program termination
    */
glantau's avatar
merge  
glantau committed
335
    atexit(term_exit);
336 337 338
#ifdef CONFIG_BEOS_NETSERVER
    fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
#endif
glantau's avatar
merge  
glantau committed
339 340 341 342 343
}

/* read a key without blocking */
static int read_key(void)
{
344
    int n = 1;
glantau's avatar
merge  
glantau committed
345
    unsigned char ch;
346 347
#ifndef CONFIG_BEOS_NETSERVER
    struct timeval tv;
glantau's avatar
merge  
glantau committed
348 349 350 351 352 353 354
    fd_set rfds;

    FD_ZERO(&rfds);
    FD_SET(0, &rfds);
    tv.tv_sec = 0;
    tv.tv_usec = 0;
    n = select(1, &rfds, NULL, NULL, &tv);
355
#endif
glantau's avatar
merge  
glantau committed
356
    if (n > 0) {
357 358
        n = read(0, &ch, 1);
        if (n == 1)
glantau's avatar
merge  
glantau committed
359
            return ch;
360 361

        return n;
glantau's avatar
merge  
glantau committed
362 363 364 365
    }
    return -1;
}

366 367 368 369 370
static int decode_interrupt_cb(void)
{
    return q_pressed || (q_pressed = read_key() == 'q');
}

371
#else
glantau's avatar
merge  
glantau committed
372

373 374
static volatile int received_sigterm = 0;

375 376
/* no interactive support */
static void term_exit(void)
glantau's avatar
merge  
glantau committed
377
{
378
}
glantau's avatar
merge  
glantau committed
379

380 381 382
static void term_init(void)
{
}
glantau's avatar
merge  
glantau committed
383

384 385
static int read_key(void)
{
386
    return 0;
glantau's avatar
merge  
glantau committed
387 388
}

389
#endif
glantau's avatar
glantau committed
390

391
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
glantau's avatar
merge  
glantau committed
392
{
393
    int i, err;
glantau's avatar
merge  
glantau committed
394 395
    AVFormatContext *ic;

396 397 398
    err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
    if (err < 0)
        return err;
glantau's avatar
merge  
glantau committed
399 400 401 402
    /* copy stream format */
    s->nb_streams = ic->nb_streams;
    for(i=0;i<ic->nb_streams;i++) {
        AVStream *st;
michaelni's avatar
michaelni committed
403

404
        // FIXME: a more elegant solution is needed
405
        st = av_mallocz(sizeof(AVStream));
glantau's avatar
merge  
glantau committed
406
        memcpy(st, ic->streams[i], sizeof(AVStream));
407 408
        st->codec = avcodec_alloc_context();
        memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
glantau's avatar
merge  
glantau committed
409 410 411 412 413 414 415
        s->streams[i] = st;
    }

    av_close_input_file(ic);
    return 0;
}

416 417 418 419 420 421 422
static double
get_sync_ipts(const AVOutputStream *ost)
{
    const AVInputStream *ist = ost->sync_ist;
    return (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/AV_TIME_BASE;
}

423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441
static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
    while(bsfc){
        AVPacket new_pkt= *pkt;
        int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
                                          &new_pkt.data, &new_pkt.size,
                                          pkt->data, pkt->size,
                                          pkt->flags & PKT_FLAG_KEY);
        if(a){
            av_free_packet(pkt);
            new_pkt.destruct= av_destruct_packet;
        }
        *pkt= new_pkt;

        bsfc= bsfc->next;
    }

    av_interleaved_write_frame(s, pkt);
}

442
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
glantau's avatar
merge  
glantau committed
443

444 445
static void do_audio_out(AVFormatContext *s,
                         AVOutputStream *ost,
glantau's avatar
merge  
glantau committed
446 447 448
                         AVInputStream *ist,
                         unsigned char *buf, int size)
{
kabi's avatar
kabi committed
449
    uint8_t *buftmp;
450 451
    static uint8_t *audio_buf = NULL;
    static uint8_t *audio_out = NULL;
michaelni's avatar
10l  
michaelni committed
452
    const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
453

glantau's avatar
merge  
glantau committed
454
    int size_out, frame_bytes, ret;
455
    AVCodecContext *enc= ost->st->codec;
glantau's avatar
merge  
glantau committed
456

457 458 459 460
    /* SC: dynamic allocation of buffers */
    if (!audio_buf)
        audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
    if (!audio_out)
michaelni's avatar
10l  
michaelni committed
461
        audio_out = av_malloc(audio_out_size);
462 463 464
    if (!audio_buf || !audio_out)
        return;               /* Should signal an error ! */

michael's avatar
michael committed
465
    if(audio_sync_method){
466
        double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
467
                - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2);
468 469
        double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
        int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
michael's avatar
michael committed
470

michael's avatar
michael committed
471 472
        //FIXME resample delay
        if(fabs(delta) > 50){
michael's avatar
michael committed
473 474
            if(ist->is_start){
                if(byte_delta < 0){
475
                    byte_delta= FFMAX(byte_delta, -size);
michael's avatar
michael committed
476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503
                    size += byte_delta;
                    buf  -= byte_delta;
                    if(verbose > 2)
                        fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
                    if(!size)
                        return;
                    ist->is_start=0;
                }else{
                    static uint8_t *input_tmp= NULL;
                    input_tmp= av_realloc(input_tmp, byte_delta + size);

                    if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
                        ist->is_start=0;
                    else
                        byte_delta= MAX_AUDIO_PACKET_SIZE - size;

                    memset(input_tmp, 0, byte_delta);
                    memcpy(input_tmp + byte_delta, buf, size);
                    buf= input_tmp;
                    size += byte_delta;
                    if(verbose > 2)
                        fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
                }
            }else if(audio_sync_method>1){
                int comp= clip(delta, -audio_sync_method, audio_sync_method);
                assert(ost->audio_resample);
                if(verbose > 2)
                    fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
504
//                fprintf(stderr, "drift:%f len:%d opts:%lld ipts:%lld 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));
michael's avatar
michael committed
505 506
                av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
            }
507
        }
michael's avatar
michael committed
508
    }else
509
        ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
510
                        - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
glantau's avatar
merge  
glantau committed
511 512 513

    if (ost->audio_resample) {
        buftmp = audio_buf;
514
        size_out = audio_resample(ost->resample,
glantau's avatar
merge  
glantau committed
515
                                  (short *)buftmp, (short *)buf,
516
                                  size / (ist->st->codec->channels * 2));
glantau's avatar
merge  
glantau committed
517 518 519 520 521 522 523
        size_out = size_out * enc->channels * 2;
    } else {
        buftmp = buf;
        size_out = size;
    }

    /* now encode as many frames as possible */
524
    if (enc->frame_size > 1) {
glantau's avatar
merge  
glantau committed
525
        /* output resampled raw samples */
526
        av_fifo_write(&ost->fifo, buftmp, size_out);
glantau's avatar
merge  
glantau committed
527 528

        frame_bytes = enc->frame_size * 2 * enc->channels;
529

530
        while (av_fifo_read(&ost->fifo, audio_buf, frame_bytes) == 0) {
531 532 533
            AVPacket pkt;
            av_init_packet(&pkt);

534
            ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
535
                                       (short *)audio_buf);
536
            audio_size += ret;
537 538 539
            pkt.stream_index= ost->index;
            pkt.data= audio_out;
            pkt.size= ret;
michael's avatar
michael committed
540
            if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
michael's avatar
michael committed
541
                pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
542
            pkt.flags |= PKT_FLAG_KEY;
543
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
544

michael's avatar
michael committed
545
            ost->sync_opts += enc->frame_size;
glantau's avatar
merge  
glantau committed
546 547
        }
    } else {
548 549
        AVPacket pkt;
        av_init_packet(&pkt);
michael's avatar
michael committed
550

551
        ost->sync_opts += size_out / (2 * enc->channels);
michael's avatar
michael committed
552

553 554 555
        /* output a pcm frame */
        /* XXX: change encoding codec API to avoid this ? */
        switch(enc->codec->id) {
556 557 558 559 560 561 562 563 564 565 566 567 568
        case CODEC_ID_PCM_S32LE:
        case CODEC_ID_PCM_S32BE:
        case CODEC_ID_PCM_U32LE:
        case CODEC_ID_PCM_U32BE:
            size_out = size_out << 1;
            break;
        case CODEC_ID_PCM_S24LE:
        case CODEC_ID_PCM_S24BE:
        case CODEC_ID_PCM_U24LE:
        case CODEC_ID_PCM_U24BE:
        case CODEC_ID_PCM_S24DAUD:
            size_out = size_out / 2 * 3;
            break;
569 570 571 572 573 574 575 576 577
        case CODEC_ID_PCM_S16LE:
        case CODEC_ID_PCM_S16BE:
        case CODEC_ID_PCM_U16LE:
        case CODEC_ID_PCM_U16BE:
            break;
        default:
            size_out = size_out >> 1;
            break;
        }
578
        ret = avcodec_encode_audio(enc, audio_out, size_out,
579
                                   (short *)buftmp);
580
        audio_size += ret;
581 582 583
        pkt.stream_index= ost->index;
        pkt.data= audio_out;
        pkt.size= ret;
michael's avatar
michael committed
584
        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
michael's avatar
michael committed
585
            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
586
        pkt.flags |= PKT_FLAG_KEY;
587
        write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
glantau's avatar
merge  
glantau committed
588 589 590
    }
}

591 592 593 594 595
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
{
    AVCodecContext *dec;
    AVPicture *picture2;
    AVPicture picture_tmp;
kabi's avatar
kabi committed
596
    uint8_t *buf = 0;
597

598
    dec = ist->st->codec;
599 600

    /* deinterlace : must be done before any resize */
601
    if (do_deinterlace || using_vhook) {
602 603 604 605 606 607 608
        int size;

        /* create temporary picture */
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
        buf = av_malloc(size);
        if (!buf)
            return;
609

610 611 612
        picture2 = &picture_tmp;
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);

michaelni's avatar
10l  
michaelni committed
613
        if (do_deinterlace){
614
            if(avpicture_deinterlace(picture2, picture,
michaelni's avatar
10l  
michaelni committed
615 616 617 618 619 620 621
                                     dec->pix_fmt, dec->width, dec->height) < 0) {
                /* if error, do not deinterlace */
                av_free(buf);
                buf = NULL;
                picture2 = picture;
            }
        } else {
622
            img_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);
623
        }
624 625 626 627 628 629 630 631 632 633 634
    } else {
        picture2 = picture;
    }

    frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height);

    if (picture != picture2)
        *picture = *picture2;
    *bufp = buf;
}

635 636
/* we begin to correct av delay at this threshold */
#define AV_DELAY_MAX 0.100
glantau's avatar
merge  
glantau committed
637

638 639
static void do_subtitle_out(AVFormatContext *s,
                            AVOutputStream *ost,
640 641 642 643 644 645 646 647 648 649 650 651 652 653 654
                            AVInputStream *ist,
                            AVSubtitle *sub,
                            int64_t pts)
{
    static uint8_t *subtitle_out = NULL;
    int subtitle_out_max_size = 65536;
    int subtitle_out_size, nb, i;
    AVCodecContext *enc;
    AVPacket pkt;

    if (pts == AV_NOPTS_VALUE) {
        fprintf(stderr, "Subtitle packets must have a pts\n");
        return;
    }

655
    enc = ost->st->codec;
656 657 658 659 660 661 662 663 664 665 666 667 668 669

    if (!subtitle_out) {
        subtitle_out = av_malloc(subtitle_out_max_size);
    }

    /* Note: DVB subtitle need one packet to draw them and one other
       packet to clear them */
    /* XXX: signal it in the codec context ? */
    if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
        nb = 2;
    else
        nb = 1;

    for(i = 0; i < nb; i++) {
670
        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
671
                                                    subtitle_out_max_size, sub);
672

673 674 675 676 677 678 679 680 681 682 683 684 685
        av_init_packet(&pkt);
        pkt.stream_index = ost->index;
        pkt.data = subtitle_out;
        pkt.size = subtitle_out_size;
        pkt.pts = av_rescale_q(av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q) + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q,  ost->st->time_base);
        if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
            /* XXX: the pts correction is handled here. Maybe handling
               it in the codec would be better */
            if (i == 0)
                pkt.pts += 90 * sub->start_display_time;
            else
                pkt.pts += 90 * sub->end_display_time;
        }
686
        write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
687 688 689
    }
}

690
static int bit_buffer_size= 1024*256;
691
static uint8_t *bit_buffer= NULL;
692

693 694
static void do_video_out(AVFormatContext *s,
                         AVOutputStream *ost,
glantau's avatar
merge  
glantau committed
695
                         AVInputStream *ist,
696
                         AVFrame *in_picture,
michael's avatar
michael committed
697
                         int *frame_size)
glantau's avatar
merge  
glantau committed
698
{
699
    int nb_frames, i, ret;
700
    AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
701
    AVFrame picture_crop_temp, picture_pad_temp;
kabi's avatar
kabi committed
702
    uint8_t *buf = NULL, *buf1 = NULL;
703
    AVCodecContext *enc, *dec;
704

705
    avcodec_get_frame_defaults(&picture_crop_temp);
706
    avcodec_get_frame_defaults(&picture_pad_temp);
707

708 709
    enc = ost->st->codec;
    dec = ist->st->codec;
glantau's avatar
merge  
glantau committed
710

711 712 713
    /* by default, we output a single frame */
    nb_frames = 1;

714 715
    *frame_size = 0;

michael's avatar
michael committed
716
    if(video_sync_method){
717
        double vdelta;
718
        vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
719 720 721 722
        //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
        if (vdelta < -1.1)
            nb_frames = 0;
        else if (vdelta > 1.1)
michael's avatar
michael committed
723
            nb_frames = lrintf(vdelta);
724
//fprintf(stderr, "vdelta:%f, ost->sync_opts:%lld, ost->sync_ipts:%f nb_frames:%d\n", vdelta, ost->sync_opts, ost->sync_ipts, nb_frames);
725 726 727 728
        if (nb_frames == 0){
            ++nb_frames_drop;
            if (verbose>2)
                fprintf(stderr, "*** drop!\n");
michael's avatar
michael committed
729 730
        }else if (nb_frames > 1) {
            nb_frames_dup += nb_frames;
731
            if (verbose>2)
michael's avatar
michael committed
732
                fprintf(stderr, "*** %d dup!\n", nb_frames-1);
733 734
        }
    }else
735
        ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
romansh's avatar
 
romansh committed
736

michael's avatar
michael committed
737
    nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
738
    if (nb_frames <= 0)
glantau's avatar
merge  
glantau committed
739
        return;
740

741
    if (ost->video_crop) {
742
        if (img_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
743 744 745 746
            av_log(NULL, AV_LOG_ERROR, "error cropping picture\n");
            goto the_end;
        }
        formatted_picture = &picture_crop_temp;
747 748
    } else {
        formatted_picture = in_picture;
749 750 751 752 753 754 755 756
    }

    final_picture = formatted_picture;
    padding_src = formatted_picture;
    resampling_dst = &ost->pict_tmp;
    if (ost->video_pad) {
        final_picture = &ost->pict_tmp;
        if (ost->video_resample) {
757
            if (img_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
758 759 760 761 762 763 764
                av_log(NULL, AV_LOG_ERROR, "error padding picture\n");
                goto the_end;
            }
            resampling_dst = &picture_pad_temp;
        }
    }

glantau's avatar
merge  
glantau committed
765
    if (ost->video_resample) {
766
        padding_src = NULL;
767
        final_picture = &ost->pict_tmp;
768 769
        sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
              0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
770
    }
771 772 773 774 775

    if (ost->video_pad) {
        img_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
                enc->height, enc->width, enc->pix_fmt,
                ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
glantau's avatar
merge  
glantau committed
776
    }
777

glantau's avatar
merge  
glantau committed
778
    /* duplicates frame if needed */
779
    for(i=0;i<nb_frames;i++) {
780 781 782 783
        AVPacket pkt;
        av_init_packet(&pkt);
        pkt.stream_index= ost->index;

784 785 786 787
        if (s->oformat->flags & AVFMT_RAWPICTURE) {
            /* raw pictures are written as AVPicture structure to
               avoid any copies. We support temorarily the older
               method. */
romansh's avatar
 
romansh committed
788
            AVFrame* old_frame = enc->coded_frame;
789
            enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
790 791
            pkt.data= (uint8_t *)final_picture;
            pkt.size=  sizeof(AVPicture);
michael's avatar
michael committed
792
            if(dec->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
michael's avatar
michael committed
793
                pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
794 795 796
            if(dec->coded_frame && dec->coded_frame->key_frame)
                pkt.flags |= PKT_FLAG_KEY;

797
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
798
            enc->coded_frame = old_frame;
799
        } else {
michaelni's avatar
michaelni committed
800
            AVFrame big_picture;
801 802

            big_picture= *final_picture;
803 804 805
            /* better than nothing: use input picture interlaced
               settings */
            big_picture.interlaced_frame = in_picture->interlaced_frame;
806
            if(avctx_opts->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
michael's avatar
michael committed
807 808 809
                if(top_field_first == -1)
                    big_picture.top_field_first = in_picture->top_field_first;
                else
michael's avatar
michael committed
810
                    big_picture.top_field_first = top_field_first;
michael's avatar
michael committed
811
            }
812

glantau's avatar
merge  
glantau committed
813 814 815
            /* handles sameq here. This is not correct because it may
               not be a global option */
            if (same_quality) {
michaelni's avatar
michaelni committed
816 817 818
                big_picture.quality = ist->st->quality;
            }else
                big_picture.quality = ost->st->quality;
819 820
            if(!me_threshold)
                big_picture.pict_type = 0;
821
//            big_picture.pts = AV_NOPTS_VALUE;
michael's avatar
michael committed
822 823
            big_picture.pts= ost->sync_opts;
//            big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
824
//av_log(NULL, AV_LOG_DEBUG, "%lld -> encoder\n", ost->sync_opts);
825
            ret = avcodec_encode_video(enc,
826
                                       bit_buffer, bit_buffer_size,
michaelni's avatar
michaelni committed
827
                                       &big_picture);
takis's avatar
takis committed
828 829 830 831
            if (ret == -1) {
                fprintf(stderr, "Video encoding failed\n");
                exit(1);
            }
832
            //enc->frame_number = enc->real_pict_num;
michael's avatar
michael committed
833
            if(ret>0){
834
                pkt.data= bit_buffer;
835
                pkt.size= ret;
michael's avatar
michael committed
836
                if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
michael's avatar
michael committed
837
                    pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
838
/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %lld/%lld\n",
michael's avatar
michael committed
839 840
   pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
   pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
841

842 843
                if(enc->coded_frame && enc->coded_frame->key_frame)
                    pkt.flags |= PKT_FLAG_KEY;
844
                write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
845 846 847 848 849 850 851 852
                *frame_size = ret;
                //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
                //        enc->frame_number-1, enc->real_pict_num, ret,
                //        enc->pict_type);
                /* if two pass, output log */
                if (ost->logfile && enc->stats_out) {
                    fprintf(ost->logfile, "%s", enc->stats_out);
                }
853
            }
glantau's avatar
merge  
glantau committed
854
        }
855
        ost->sync_opts++;
856
        ost->frame_number++;
glantau's avatar
merge  
glantau committed
857
    }
858
 the_end:
glantau's avatar
glantau committed
859 860
    av_free(buf);
    av_free(buf1);
glantau's avatar
merge  
glantau committed
861 862
}

863 864
static double psnr(double d){
    if(d==0) return INFINITY;
865
    return -10.0*log(d)/log(10.0);
866 867
}

868
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
869
                           int frame_size)
870 871 872
{
    static FILE *fvstats=NULL;
    char filename[40];
873 874
    time_t today2;
    struct tm *today;
875 876
    AVCodecContext *enc;
    int frame_number;
kabi's avatar
kabi committed
877
    int64_t ti;
878
    double ti1, bitrate, avg_bitrate;
879

880 881 882
    if (!fvstats) {
        today2 = time(NULL);
        today = localtime(&today2);
michael's avatar
michael committed
883
        snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour,
884 885 886 887 888 889 890 891
                                               today->tm_min,
                                               today->tm_sec);
        fvstats = fopen(filename,"w");
        if (!fvstats) {
            perror("fopen");
            exit(1);
        }
    }
892

893
    ti = MAXINT64;
894
    enc = ost->st->codec;
895
    if (enc->codec_type == CODEC_TYPE_VIDEO) {
896
        frame_number = ost->frame_number;
897
        fprintf(fvstats, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
898
        if (enc->flags&CODEC_FLAG_PSNR)
michaelni's avatar
michaelni committed
899
            fprintf(fvstats, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
900

901
        fprintf(fvstats,"f_size= %6d ", frame_size);
902
        /* compute pts value */
michael's avatar
michael committed
903
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
904 905
        if (ti1 < 0.01)
            ti1 = 0.01;
906

michael's avatar
michael committed
907
        bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
908
        avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
909
        fprintf(fvstats, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
910
            (double)video_size / 1024, ti1, bitrate, avg_bitrate);
911
        fprintf(fvstats,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
912
    }
913 914
}

915
static void print_report(AVFormatContext **output_files,
916 917
                         AVOutputStream **ost_table, int nb_ostreams,
                         int is_last_report)
918 919 920 921
{
    char buf[1024];
    AVOutputStream *ost;
    AVFormatContext *oc, *os;
kabi's avatar
kabi committed
922
    int64_t total_size;
923 924 925
    AVCodecContext *enc;
    int frame_number, vid, i;
    double bitrate, ti1, pts;
kabi's avatar
kabi committed
926
    static int64_t last_time = -1;
927
    static int qp_histogram[52];
928

929
    if (!is_last_report) {
kabi's avatar
kabi committed
930
        int64_t cur_time;
931 932 933 934 935
        /* display the report every 0.5 seconds */
        cur_time = av_gettime();
        if (last_time == -1) {
            last_time = cur_time;
            return;
936
        }
937 938 939 940 941
        if ((cur_time - last_time) < 500000)
            return;
        last_time = cur_time;
    }

942

943 944 945
    oc = output_files[0];

    total_size = url_ftell(&oc->pb);
946

947 948 949 950 951 952
    buf[0] = '\0';
    ti1 = 1e10;
    vid = 0;
    for(i=0;i<nb_ostreams;i++) {
        ost = ost_table[i];
        os = output_files[ost->file_index];
953
        enc = ost->st->codec;
954
        if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
955
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
956
                    enc->coded_frame->quality/(float)FF_QP2LAMBDA);
957
        }
958 959
        if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
            frame_number = ost->frame_number;
960 961
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d q=%3.1f ",
                    frame_number, enc->coded_frame ? enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
962
            if(is_last_report)
963
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
964 965 966 967 968 969 970 971
            if(qp_hist && enc->coded_frame){
                int j;
                int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
                if(qp>=0 && qp<sizeof(qp_histogram)/sizeof(int))
                    qp_histogram[qp]++;
                for(j=0; j<32; j++)
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
            }
972 973 974 975 976
            if (enc->flags&CODEC_FLAG_PSNR){
                int j;
                double error, error_sum=0;
                double scale, scale_sum=0;
                char type[3]= {'Y','U','V'};
977
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
978 979 980 981 982 983 984 985 986 987 988
                for(j=0; j<3; j++){
                    if(is_last_report){
                        error= enc->error[j];
                        scale= enc->width*enc->height*255.0*255.0*frame_number;
                    }else{
                        error= enc->coded_frame->error[j];
                        scale= enc->width*enc->height*255.0*255.0;
                    }
                    if(j) scale/=4;
                    error_sum += error;
                    scale_sum += scale;
989
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
990
                }
991
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
992
            }
993 994 995
            vid = 1;
        }
        /* compute min output value */
996
        pts = (double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den;
997
        if ((pts < ti1) && (pts > 0))
998 999 1000 1001
            ti1 = pts;
    }
    if (ti1 < 0.01)
        ti1 = 0.01;
1002

1003 1004
    if (verbose || is_last_report) {
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1005 1006

        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1007 1008
            "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
            (double)total_size / 1024, ti1, bitrate);
michael's avatar
michael committed
1009

1010 1011 1012
        if (verbose > 1)
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
                  nb_frames_dup, nb_frames_drop);
1013

1014 1015 1016
        if (verbose >= 0)
            fprintf(stderr, "%s    \r", buf);

1017 1018
        fflush(stderr);
    }
1019

1020 1021
    if (is_last_report && verbose >= 0){
        int64_t raw= audio_size + video_size + extra_size;
1022
        fprintf(stderr, "\n");
1023 1024 1025 1026 1027 1028 1029
        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
                video_size/1024.0,
                audio_size/1024.0,
                extra_size/1024.0,
                100.0*(total_size - raw)/raw
        );
    }
1030 1031
}

1032 1033 1034
/* pkt = NULL means EOF (needed to flush decoder buffers) */
static int output_packet(AVInputStream *ist, int ist_index,
                         AVOutputStream **ost_table, int nb_ostreams,
1035
                         const AVPacket *pkt)
1036 1037 1038 1039 1040 1041 1042 1043 1044
{
    AVFormatContext *os;
    AVOutputStream *ost;
    uint8_t *ptr;
    int len, ret, i;
    uint8_t *data_buf;
    int data_size, got_picture;
    AVFrame picture;
    void *buffer_to_free;
1045
    static unsigned int samples_size= 0;
1046
    static short *samples= NULL;
1047 1048
    AVSubtitle subtitle, *subtitle_to_free;
    int got_subtitle;
1049

michael's avatar
michael committed
1050 1051 1052
    if(!pkt){
        ist->pts= ist->next_pts; // needed for last packet if vsync=0
    } else if (pkt->dts != AV_NOPTS_VALUE) { //FIXME seems redundant, as libavformat does this too
michael's avatar
michael committed
1053
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1054
    } else {
1055
//        assert(ist->pts == ist->next_pts);
1056
    }
1057

1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071
    if (pkt == NULL) {
        /* EOF handling */
        ptr = NULL;
        len = 0;
        goto handle_eof;
    }

    len = pkt->size;
    ptr = pkt->data;
    while (len > 0) {
    handle_eof:
        /* decode the packet if needed */
        data_buf = NULL; /* fail safe */
        data_size = 0;
1072
        subtitle_to_free = NULL;
1073
        if (ist->decoding_needed) {
1074
            switch(ist->st->codec->codec_type) {
michael's avatar
michael committed
1075
            case CODEC_TYPE_AUDIO:{
1076
                if(pkt)
1077
                    samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE));
1078 1079
                    /* XXX: could avoid copy if PCM 16 bits with same
                       endianness as CPU */
1080
                ret = avcodec_decode_audio(ist->st->codec, samples, &data_size,
1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092
                                           ptr, len);
                if (ret < 0)
                    goto fail_decode;
                ptr += ret;
                len -= ret;
                /* Some bug in mpeg audio decoder gives */
                /* data_size < 0, it seems they are overflows */
                if (data_size <= 0) {
                    /* no audio frame */
                    continue;
                }
                data_buf = (uint8_t *)samples;
1093
                ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1094
                    (ist->st->codec->sample_rate * ist->st->codec->channels);
michael's avatar
michael committed
1095
                break;}
1096
            case CODEC_TYPE_VIDEO:
1097
                    data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1098
                    /* XXX: allocate picture correctly */
1099 1100
                    avcodec_get_frame_defaults(&picture);

1101
                    ret = avcodec_decode_video(ist->st->codec,
1102 1103
                                               &picture, &got_picture, ptr, len);
                    ist->st->quality= picture.quality;
1104
                    if (ret < 0)
1105 1106 1107 1108 1109
                        goto fail_decode;
                    if (!got_picture) {
                        /* no picture yet */
                        goto discard_packet;
                    }
1110
                    if (ist->st->codec->time_base.num != 0) {
1111
                        ist->next_pts += ((int64_t)AV_TIME_BASE *
1112 1113
                                          ist->st->codec->time_base.num) /
                            ist->st->codec->time_base.den;
1114 1115 1116
                    }
                    len = 0;
                    break;
1117
            case CODEC_TYPE_SUBTITLE:
1118
                ret = avcodec_decode_subtitle(ist->st->codec,
1119 1120
                                              &subtitle, &got_subtitle, ptr, len);
                if (ret < 0)
1121
                    goto fail_decode;
1122 1123
                if (!got_subtitle) {
                    goto discard_packet;
1124
                }
1125 1126 1127 1128 1129 1130 1131
                subtitle_to_free = &subtitle;
                len = 0;
                break;
            default:
                goto fail_decode;
            }
        } else {
1132
                switch(ist->st->codec->codec_type) {
1133
                case CODEC_TYPE_AUDIO:
1134
                    ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1135
                        (ist->st->codec->sample_rate * ist->st->codec->channels);
1136 1137
                    break;
                case CODEC_TYPE_VIDEO:
1138
                    if (ist->st->codec->time_base.num != 0) {
1139
                        ist->next_pts += ((int64_t)AV_TIME_BASE *
1140 1141
                                          ist->st->codec->time_base.num) /
                            ist->st->codec->time_base.den;
1142 1143 1144
                    }
                    break;
                }
1145 1146 1147 1148 1149 1150 1151
                data_buf = ptr;
                data_size = len;
                ret = len;
                len = 0;
            }

            buffer_to_free = NULL;
1152
            if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1153
                pre_process_video_frame(ist, (AVPicture *)&picture,
1154 1155 1156
                                        &buffer_to_free);
            }

1157
            // preprocess audio (volume)
1158
            if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1159
                if (audio_volume != 256) {
1160 1161 1162
                    short *volp;
                    volp = samples;
                    for(i=0;i<(data_size / sizeof(short));i++) {
1163
                        int v = ((*volp) * audio_volume + 128) >> 8;
1164 1165 1166 1167 1168 1169 1170
                        if (v < -32768) v = -32768;
                        if (v >  32767) v = 32767;
                        *volp++ = v;
                    }
                }
            }

1171
            /* frame rate emulation */
1172 1173
            if (ist->st->codec->rate_emu) {
                int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184
                int64_t now = av_gettime() - ist->start;
                if (pts > now)
                    usleep(pts - now);

                ist->frame++;
            }

#if 0
            /* mpeg PTS deordering : if it is a P or I frame, the PTS
               is the one of the next displayed one */
            /* XXX: add mpeg4 too ? */
1185 1186
            if (ist->st->codec->codec_id == CODEC_ID_MPEG1VIDEO) {
                if (ist->st->codec->pict_type != B_TYPE) {
1187 1188 1189 1190 1191 1192 1193
                    int64_t tmp;
                    tmp = ist->last_ip_pts;
                    ist->last_ip_pts  = ist->frac_pts.val;
                    ist->frac_pts.val = tmp;
                }
            }
#endif
1194
            /* if output time reached then transcode raw format,
1195
               encode packets and output them */
1196 1197 1198 1199 1200 1201 1202 1203 1204
            if (start_time == 0 || ist->pts >= start_time)
                for(i=0;i<nb_ostreams;i++) {
                    int frame_size;

                    ost = ost_table[i];
                    if (ost->source_index == ist_index) {
                        os = output_files[ost->file_index];

#if 0
1205 1206 1207
                        printf("%d: got pts=%0.3f %0.3f\n", i,
                               (double)pkt->pts / AV_TIME_BASE,
                               ((double)ist->pts / AV_TIME_BASE) -
michael's avatar
michael committed
1208
                               ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1209 1210
#endif
                        /* set the input output pts pairs */
1211
                        //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1212 1213

                        if (ost->encoding_needed) {
1214
                            switch(ost->st->codec->codec_type) {
1215 1216 1217 1218
                            case CODEC_TYPE_AUDIO:
                                do_audio_out(os, ost, ist, data_buf, data_size);
                                break;
                            case CODEC_TYPE_VIDEO:
michael's avatar
michael committed
1219
                                    do_video_out(os, ost, ist, &picture, &frame_size);
1220
                                    video_size += frame_size;
1221 1222 1223
                                    if (do_vstats && frame_size)
                                        do_video_stats(os, ost, frame_size);
                                break;
1224 1225 1226 1227
                            case CODEC_TYPE_SUBTITLE:
                                do_subtitle_out(os, ost, ist, &subtitle,
                                                pkt->pts);
                                break;
1228 1229 1230 1231
                            default:
                                av_abort();
                            }
                        } else {
1232 1233 1234 1235
                            AVFrame avframe; //FIXME/XXX remove this
                            AVPacket opkt;
                            av_init_packet(&opkt);

1236 1237
                            /* no reencoding needed : output the packet directly */
                            /* force the input stream PTS */
1238

1239
                            avcodec_get_frame_defaults(&avframe);
1240
                            ost->st->codec->coded_frame= &avframe;
1241
                            avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
michael's avatar
michael committed
1242

1243
                            if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
michael's avatar
 
michael committed
1244
                                audio_size += data_size;
1245
                            else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
michael's avatar
 
michael committed
1246
                                video_size += data_size;
1247 1248
                                ost->sync_opts++;
                            }
michael's avatar
 
michael committed
1249

1250
                            opkt.stream_index= ost->index;
1251
                            if(pkt->pts != AV_NOPTS_VALUE)
michael's avatar
michael committed
1252
                                opkt.pts= av_rescale_q(av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q) + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q,  ost->st->time_base);
1253 1254
                            else
                                opkt.pts= AV_NOPTS_VALUE;
1255 1256 1257 1258 1259 1260 1261 1262 1263

                            {
                                int64_t dts;
                                if (pkt->dts == AV_NOPTS_VALUE)
                                    dts = ist->next_pts;
                                else
                                    dts= av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
                                opkt.dts= av_rescale_q(dts + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q,  ost->st->time_base);
                            }
1264
                            opkt.flags= pkt->flags;
1265 1266

                            //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1267
                            if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1268
                                opkt.destruct= av_destruct_packet;
1269 1270

                            write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][pkt->stream_index]);
1271
                            ost->st->codec->frame_number++;
1272
                            ost->frame_number++;
1273
                            av_free_packet(&opkt);
1274 1275 1276 1277
                        }
                    }
                }
            av_free(buffer_to_free);
1278 1279
            /* XXX: allocate the subtitles in the codec ? */
            if (subtitle_to_free) {
1280 1281 1282 1283 1284 1285 1286 1287
                if (subtitle_to_free->rects != NULL) {
                    for (i = 0; i < subtitle_to_free->num_rects; i++) {
                        av_free(subtitle_to_free->rects[i].bitmap);
                        av_free(subtitle_to_free->rects[i].rgba_palette);
                    }
                    av_freep(&subtitle_to_free->rects);
                }
                subtitle_to_free->num_rects = 0;
1288 1289
                subtitle_to_free = NULL;
            }
1290 1291
        }
 discard_packet:
1292 1293
    if (pkt == NULL) {
        /* EOF handling */
1294

1295 1296 1297
        for(i=0;i<nb_ostreams;i++) {
            ost = ost_table[i];
            if (ost->source_index == ist_index) {
1298
                AVCodecContext *enc= ost->st->codec;
1299
                os = output_files[ost->file_index];
1300

1301
                if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1302
                    continue;
1303
                if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1304 1305 1306 1307 1308
                    continue;

                if (ost->encoding_needed) {
                    for(;;) {
                        AVPacket pkt;
1309
                        int fifo_bytes;
1310 1311
                        av_init_packet(&pkt);
                        pkt.stream_index= ost->index;
1312

1313
                        switch(ost->st->codec->codec_type) {
1314
                        case CODEC_TYPE_AUDIO:
1315
                            fifo_bytes = av_fifo_size(&ost->fifo);
1316 1317 1318 1319 1320
                            ret = 0;
                            /* encode any samples remaining in fifo */
                            if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
                                int fs_tmp = enc->frame_size;
                                enc->frame_size = fifo_bytes / (2 * enc->channels);
1321
                                if(av_fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes) == 0) {
1322 1323 1324
                                    ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
                                }
                                enc->frame_size = fs_tmp;
michael's avatar
michael committed
1325 1326
                            }
                            if(ret <= 0) {
1327 1328
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
                            }
1329 1330 1331 1332
                            audio_size += ret;
                            pkt.flags |= PKT_FLAG_KEY;
                            break;
                        case CODEC_TYPE_VIDEO:
1333
                            ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1334 1335 1336 1337 1338 1339 1340 1341 1342 1343
                            video_size += ret;
                            if(enc->coded_frame && enc->coded_frame->key_frame)
                                pkt.flags |= PKT_FLAG_KEY;
                            if (ost->logfile && enc->stats_out) {
                                fprintf(ost->logfile, "%s", enc->stats_out);
                            }
                            break;
                        default:
                            ret=-1;
                        }
1344

1345 1346
                        if(ret<=0)
                            break;
1347
                        pkt.data= bit_buffer;
1348
                        pkt.size= ret;
michael's avatar
michael committed
1349
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
michael's avatar
michael committed
1350
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1351
                        write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1352 1353 1354 1355 1356
                    }
                }
            }
        }
    }
1357

1358 1359 1360 1361 1362 1363
    return 0;
 fail_decode:
    return -1;
}


glantau's avatar
merge  
glantau committed
1364 1365 1366 1367 1368 1369 1370 1371 1372
/*
 * The following code is the main loop of the file converter
 */
static int av_encode(AVFormatContext **output_files,
                     int nb_output_files,
                     AVFormatContext **input_files,
                     int nb_input_files,
                     AVStreamMap *stream_maps, int nb_stream_maps)
{
romansh's avatar
 
romansh committed
1373
    int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
glantau's avatar
merge  
glantau committed
1374 1375 1376 1377
    AVFormatContext *is, *os;
    AVCodecContext *codec, *icodec;
    AVOutputStream *ost, **ost_table = NULL;
    AVInputStream *ist, **ist_table = NULL;
glantau's avatar
glantau committed
1378
    AVInputFile *file_table;
1379
    AVFormatContext *stream_no_data;
1380
    int key;
glantau's avatar
glantau committed
1381

1382
    file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
glantau's avatar
glantau committed
1383 1384
    if (!file_table)
        goto fail;
1385

glantau's avatar
merge  
glantau committed
1386 1387 1388 1389 1390
    /* input stream init */
    j = 0;
    for(i=0;i<nb_input_files;i++) {
        is = input_files[i];
        file_table[i].ist_index = j;
1391
        file_table[i].nb_streams = is->nb_streams;
glantau's avatar
merge  
glantau committed
1392 1393 1394 1395 1396 1397
        j += is->nb_streams;
    }
    nb_istreams = j;

    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
    if (!ist_table)
glantau's avatar
glantau committed
1398
        goto fail;
1399

glantau's avatar
merge  
glantau committed
1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415
    for(i=0;i<nb_istreams;i++) {
        ist = av_mallocz(sizeof(AVInputStream));
        if (!ist)
            goto fail;
        ist_table[i] = ist;
    }
    j = 0;
    for(i=0;i<nb_input_files;i++) {
        is = input_files[i];
        for(k=0;k<is->nb_streams;k++) {
            ist = ist_table[j++];
            ist->st = is->streams[k];
            ist->file_index = i;
            ist->index = k;
            ist->discard = 1; /* the stream is discarded by default
                                 (changed later) */
1416

1417
            if (ist->st->codec->rate_emu) {
1418 1419 1420
                ist->start = av_gettime();
                ist->frame = 0;
            }
glantau's avatar
merge  
glantau committed
1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434
        }
    }

    /* output stream init */
    nb_ostreams = 0;
    for(i=0;i<nb_output_files;i++) {
        os = output_files[i];
        nb_ostreams += os->nb_streams;
    }
    if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
        fprintf(stderr, "Number of stream maps must match number of output streams\n");
        exit(1);
    }

1435 1436 1437 1438
    /* Sanity check the mapping args -- do the input files & streams exist? */
    for(i=0;i<nb_stream_maps;i++) {
        int fi = stream_maps[i].file_index;
        int si = stream_maps[i].stream_index;
1439

1440 1441 1442 1443 1444
        if (fi < 0 || fi > nb_input_files - 1 ||
            si < 0 || si > file_table[fi].nb_streams - 1) {
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
            exit(1);
        }
1445 1446 1447 1448 1449 1450 1451
        fi = stream_maps[i].sync_file_index;
        si = stream_maps[i].sync_stream_index;
        if (fi < 0 || fi > nb_input_files - 1 ||
            si < 0 || si > file_table[fi].nb_streams - 1) {
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
            exit(1);
        }
1452
    }
1453

glantau's avatar
merge  
glantau committed
1454 1455 1456 1457 1458 1459 1460 1461 1462
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
    if (!ost_table)
        goto fail;
    for(i=0;i<nb_ostreams;i++) {
        ost = av_mallocz(sizeof(AVOutputStream));
        if (!ost)
            goto fail;
        ost_table[i] = ost;
    }
1463

glantau's avatar
merge  
glantau committed
1464 1465 1466 1467 1468 1469 1470 1471 1472 1473
    n = 0;
    for(k=0;k<nb_output_files;k++) {
        os = output_files[k];
        for(i=0;i<os->nb_streams;i++) {
            int found;
            ost = ost_table[n++];
            ost->file_index = k;
            ost->index = i;
            ost->st = os->streams[i];
            if (nb_stream_maps > 0) {
1474
                ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
glantau's avatar
merge  
glantau committed
1475
                    stream_maps[n-1].stream_index;
1476

1477
                /* Sanity check that the stream types match */
1478
                if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1479 1480 1481 1482 1483
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
                        stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
                        ost->file_index, ost->index);
                    exit(1);
                }
1484

glantau's avatar
merge  
glantau committed
1485 1486 1487 1488 1489
            } else {
                /* get corresponding input stream index : we select the first one with the right type */
                found = 0;
                for(j=0;j<nb_istreams;j++) {
                    ist = ist_table[j];
1490
                    if (ist->discard &&
1491
                        ist->st->codec->codec_type == ost->st->codec->codec_type) {
glantau's avatar
merge  
glantau committed
1492 1493
                        ost->source_index = j;
                        found = 1;
1494
                        break;
glantau's avatar
merge  
glantau committed
1495 1496
                    }
                }
1497

glantau's avatar
merge  
glantau committed
1498 1499 1500 1501
                if (!found) {
                    /* try again and reuse existing stream */
                    for(j=0;j<nb_istreams;j++) {
                        ist = ist_table[j];
1502
                        if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
glantau's avatar
merge  
glantau committed
1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515
                            ost->source_index = j;
                            found = 1;
                        }
                    }
                    if (!found) {
                        fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
                                ost->file_index, ost->index);
                        exit(1);
                    }
                }
            }
            ist = ist_table[ost->source_index];
            ist->discard = 0;
1516 1517 1518
            ost->sync_ist = (nb_stream_maps > 0) ?
                ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
                         stream_maps[n-1].sync_stream_index] : ist;
glantau's avatar
merge  
glantau committed
1519 1520 1521 1522 1523 1524 1525 1526
        }
    }

    /* for each output stream, we compute the right encoding parameters */
    for(i=0;i<nb_ostreams;i++) {
        ost = ost_table[i];
        ist = ist_table[ost->source_index];

1527 1528
        codec = ost->st->codec;
        icodec = ist->st->codec;
glantau's avatar
merge  
glantau committed
1529

1530 1531 1532 1533
        if (ost->st->stream_copy) {
            /* if stream_copy is selected, no need to decode or encode */
            codec->codec_id = icodec->codec_id;
            codec->codec_type = icodec->codec_type;
michael's avatar
michael committed
1534
            if(!codec->codec_tag) codec->codec_tag = icodec->codec_tag;
1535
            codec->bit_rate = icodec->bit_rate;
michael's avatar
michael committed
1536 1537
            codec->extradata= icodec->extradata;
            codec->extradata_size= icodec->extradata_size;
1538 1539 1540 1541
            if(av_q2d(icodec->time_base) > av_q2d(ist->st->time_base))
                codec->time_base = icodec->time_base;
            else
                codec->time_base = ist->st->time_base;
1542 1543 1544 1545
            switch(codec->codec_type) {
            case CODEC_TYPE_AUDIO:
                codec->sample_rate = icodec->sample_rate;
                codec->channels = icodec->channels;
michael's avatar
michael committed
1546
                codec->frame_size = icodec->frame_size;
michael's avatar
michael committed
1547
                codec->block_align= icodec->block_align;
1548 1549
                break;
            case CODEC_TYPE_VIDEO:
1550
                codec->pix_fmt = icodec->pix_fmt;
1551 1552
                codec->width = icodec->width;
                codec->height = icodec->height;
michael's avatar
michael committed
1553
                codec->has_b_frames = icodec->has_b_frames;
1554
                break;
1555 1556
            case CODEC_TYPE_SUBTITLE:
                break;
1557 1558 1559 1560 1561 1562
            default:
                av_abort();
            }
        } else {
            switch(codec->codec_type) {
            case CODEC_TYPE_AUDIO:
1563
                if (av_fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
glantau's avatar
merge  
glantau committed
1564
                    goto fail;
1565

glantau's avatar
merge  
glantau committed
1566 1567 1568 1569
                if (codec->channels == icodec->channels &&
                    codec->sample_rate == icodec->sample_rate) {
                    ost->audio_resample = 0;
                } else {
1570
                    if (codec->channels != icodec->channels &&
1571 1572 1573
                        (icodec->codec_id == CODEC_ID_AC3 ||
                         icodec->codec_id == CODEC_ID_DTS)) {
                        /* Special case for 5:1 AC3 and DTS input */
1574
                        /* and mono or stereo output      */
1575 1576 1577 1578 1579 1580 1581
                        /* Request specific number of channels */
                        icodec->channels = codec->channels;
                        if (codec->sample_rate == icodec->sample_rate)
                            ost->audio_resample = 0;
                        else {
                            ost->audio_resample = 1;
                        }
1582
                    } else {
1583
                        ost->audio_resample = 1;
michael's avatar
michael committed
1584 1585
                    }
                }
michael's avatar
michael committed
1586
                if(audio_sync_method>1)
michael's avatar
michael committed
1587 1588 1589 1590 1591 1592 1593 1594
                    ost->audio_resample = 1;

                if(ost->audio_resample){
                    ost->resample = audio_resample_init(codec->channels, icodec->channels,
                                                    codec->sample_rate, icodec->sample_rate);
                    if(!ost->resample){
                        printf("Can't resample.  Aborting.\n");
                        av_abort();
1595
                    }
glantau's avatar
merge  
glantau committed
1596 1597 1598
                }
                ist->decoding_needed = 1;
                ost->encoding_needed = 1;
1599 1600
                break;
            case CODEC_TYPE_VIDEO:
1601 1602 1603 1604 1605 1606 1607
                ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
                ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
                ost->video_resample = ((codec->width != icodec->width -
                                (frame_leftBand + frame_rightBand) +
                                (frame_padleft + frame_padright)) ||
                        (codec->height != icodec->height -
                                (frame_topBand  + frame_bottomBand) +
1608 1609
                                (frame_padtop + frame_padbottom)) ||
                        (codec->pix_fmt != icodec->pix_fmt));
1610
                if (ost->video_crop) {
1611 1612
                    ost->topBand = frame_topBand;
                    ost->leftBand = frame_leftBand;
1613 1614
                }
                if (ost->video_pad) {
1615 1616 1617 1618
                    ost->padtop = frame_padtop;
                    ost->padleft = frame_padleft;
                    ost->padbottom = frame_padbottom;
                    ost->padright = frame_padright;
1619 1620 1621 1622 1623 1624 1625 1626
                    if (!ost->video_resample) {
                        avcodec_get_frame_defaults(&ost->pict_tmp);
                        if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
                                         codec->width, codec->height ) )
                            goto fail;
                    }
                }
                if (ost->video_resample) {
michael's avatar
michael committed
1627
                    avcodec_get_frame_defaults(&ost->pict_tmp);
1628
                    if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1629
                                         codec->width, codec->height ) )
glantau's avatar
merge  
glantau committed
1630 1631
                        goto fail;

1632 1633 1634 1635
                    ost->img_resample_ctx = sws_getContext(
                            icodec->width - (frame_leftBand + frame_rightBand),
                            icodec->height - (frame_topBand + frame_bottomBand),
                            icodec->pix_fmt,
1636 1637
                            codec->width - (frame_padleft + frame_padright),
                            codec->height - (frame_padtop + frame_padbottom),
1638 1639
                            codec->pix_fmt,
                            sws_flags, NULL, NULL, NULL);
1640 1641 1642 1643
                    if (ost->img_resample_ctx == NULL) {
                        fprintf(stderr, "Cannot get resampling context\n");
                        exit(1);
                    }
1644
                    ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
glantau's avatar
merge  
glantau committed
1645 1646 1647
                }
                ost->encoding_needed = 1;
                ist->decoding_needed = 1;
1648
                break;
1649 1650 1651 1652
            case CODEC_TYPE_SUBTITLE:
                ost->encoding_needed = 1;
                ist->decoding_needed = 1;
                break;
1653 1654
            default:
                av_abort();
1655
                break;
glantau's avatar
merge  
glantau committed
1656
            }
1657
            /* two pass mode */
1658
            if (ost->encoding_needed &&
1659 1660 1661 1662 1663
                (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
                char logfilename[1024];
                FILE *f;
                int size;
                char *logbuffer;
1664 1665 1666

                snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
                         pass_logfilename ?
1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689
                         pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
                if (codec->flags & CODEC_FLAG_PASS1) {
                    f = fopen(logfilename, "w");
                    if (!f) {
                        perror(logfilename);
                        exit(1);
                    }
                    ost->logfile = f;
                } else {
                    /* read the log file */
                    f = fopen(logfilename, "r");
                    if (!f) {
                        perror(logfilename);
                        exit(1);
                    }
                    fseek(f, 0, SEEK_END);
                    size = ftell(f);
                    fseek(f, 0, SEEK_SET);
                    logbuffer = av_malloc(size + 1);
                    if (!logbuffer) {
                        fprintf(stderr, "Could not allocate log buffer\n");
                        exit(1);
                    }
1690
                    size = fread(logbuffer, 1, size, f);
1691 1692 1693
                    fclose(f);
                    logbuffer[size] = '\0';
                    codec->stats_in = logbuffer;
1694 1695 1696
                }
            }
        }
1697 1698 1699 1700
        if(codec->codec_type == CODEC_TYPE_VIDEO){
            int size= codec->width * codec->height;
            bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
        }
glantau's avatar
merge  
glantau committed
1701 1702
    }

1703 1704 1705 1706 1707
    if (!bit_buffer)
        bit_buffer = av_malloc(bit_buffer_size);
    if (!bit_buffer)
        goto fail;

1708 1709 1710 1711 1712 1713 1714
    /* dump the file output parameters - cannot be done before in case
       of stream copy */
    for(i=0;i<nb_output_files;i++) {
        dump_format(output_files[i], i, output_files[i]->filename, 1);
    }

    /* dump the stream mapping */
1715 1716 1717 1718
    if (verbose >= 0) {
        fprintf(stderr, "Stream mapping:\n");
        for(i=0;i<nb_ostreams;i++) {
            ost = ost_table[i];
1719
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
1720 1721
                    ist_table[ost->source_index]->file_index,
                    ist_table[ost->source_index]->index,
1722
                    ost->file_index,
1723
                    ost->index);
1724 1725 1726 1727 1728
            if (ost->sync_ist != ist_table[ost->source_index])
                fprintf(stderr, " [sync #%d.%d]",
                        ost->sync_ist->file_index,
                        ost->sync_ist->index);
            fprintf(stderr, "\n");
1729
        }
1730 1731
    }

glantau's avatar
merge  
glantau committed
1732 1733 1734 1735 1736
    /* open each encoder */
    for(i=0;i<nb_ostreams;i++) {
        ost = ost_table[i];
        if (ost->encoding_needed) {
            AVCodec *codec;
1737
            codec = avcodec_find_encoder(ost->st->codec->codec_id);
glantau's avatar
merge  
glantau committed
1738
            if (!codec) {
1739
                fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
glantau's avatar
merge  
glantau committed
1740 1741 1742
                        ost->file_index, ost->index);
                exit(1);
            }
1743
            if (avcodec_open(ost->st->codec, codec) < 0) {
1744
                fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
glantau's avatar
merge  
glantau committed
1745 1746 1747
                        ost->file_index, ost->index);
                exit(1);
            }
1748
            extra_size += ost->st->codec->extradata_size;
glantau's avatar
merge  
glantau committed
1749 1750 1751 1752 1753 1754 1755 1756
        }
    }

    /* open each decoder */
    for(i=0;i<nb_istreams;i++) {
        ist = ist_table[i];
        if (ist->decoding_needed) {
            AVCodec *codec;
1757
            codec = avcodec_find_decoder(ist->st->codec->codec_id);
glantau's avatar
merge  
glantau committed
1758
            if (!codec) {
1759
                fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1760
                        ist->st->codec->codec_id, ist->file_index, ist->index);
glantau's avatar
merge  
glantau committed
1761 1762
                exit(1);
            }
1763
            if (avcodec_open(ist->st->codec, codec) < 0) {
1764
                fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
glantau's avatar
merge  
glantau committed
1765 1766 1767
                        ist->file_index, ist->index);
                exit(1);
            }
1768 1769
            //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
            //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
glantau's avatar
merge  
glantau committed
1770 1771 1772 1773 1774 1775
        }
    }

    /* init pts */
    for(i=0;i<nb_istreams;i++) {
        ist = ist_table[i];
1776
        is = input_files[ist->file_index];
romansh's avatar
 
romansh committed
1777
        ist->pts = 0;
michael's avatar
michael committed
1778
        ist->next_pts = av_rescale_q(ist->st->start_time, ist->st->time_base, AV_TIME_BASE_Q);
1779
        if(ist->st->start_time == AV_NOPTS_VALUE)
michael's avatar
michael committed
1780
            ist->next_pts=0;
michael's avatar
michael committed
1781 1782
        if(input_files_ts_offset[ist->file_index])
            ist->next_pts= AV_NOPTS_VALUE;
michael's avatar
michael committed
1783
        ist->is_start = 1;
glantau's avatar
merge  
glantau committed
1784
    }
michael's avatar
michael committed
1785

glantau's avatar
merge  
glantau committed
1786 1787 1788 1789 1790
    /* compute buffer size max (should use a complete heuristic) */
    for(i=0;i<nb_input_files;i++) {
        file_table[i].buffer_size_max = 2048;
    }

1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806
    /* set meta data information from input file if required */
    for (i=0;i<nb_meta_data_maps;i++) {
        AVFormatContext *out_file;
        AVFormatContext *in_file;

        int out_file_index = meta_data_maps[i].out_file;
        int in_file_index = meta_data_maps[i].in_file;
        if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
            fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
            ret = -EINVAL;
            goto fail;
        }
        if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
            fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
            ret = -EINVAL;
            goto fail;
1807 1808
        }

1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820
        out_file = output_files[out_file_index];
        in_file = input_files[in_file_index];

        strcpy(out_file->title, in_file->title);
        strcpy(out_file->author, in_file->author);
        strcpy(out_file->copyright, in_file->copyright);
        strcpy(out_file->comment, in_file->comment);
        strcpy(out_file->album, in_file->album);
        out_file->year = in_file->year;
        out_file->track = in_file->track;
        strcpy(out_file->genre, in_file->genre);
    }
1821

glantau's avatar
merge  
glantau committed
1822 1823 1824
    /* open files and write file headers */
    for(i=0;i<nb_output_files;i++) {
        os = output_files[i];
1825
        if (av_write_header(os) < 0) {
1826
            fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1827 1828 1829
            ret = -EINVAL;
            goto fail;
        }
glantau's avatar
merge  
glantau committed
1830 1831
    }

1832
#ifndef __MINGW32__
1833
    if ( !using_stdin && verbose >= 0) {
1834
        fprintf(stderr, "Press [q] to stop encoding\n");
1835 1836
        url_set_interrupt_cb(decode_interrupt_cb);
    }
1837 1838 1839
#endif
    term_init();

1840
    stream_no_data = 0;
1841
    key = -1;
1842

1843
    for(; received_sigterm == 0;) {
glantau's avatar
merge  
glantau committed
1844 1845
        int file_index, ist_index;
        AVPacket pkt;
1846 1847
        double ipts_min;
        double opts_min;
michael's avatar
michael committed
1848

glantau's avatar
merge  
glantau committed
1849
    redo:
1850 1851
        ipts_min= 1e100;
        opts_min= 1e100;
1852
        /* if 'q' pressed, exits */
1853
        if (!using_stdin) {
1854 1855
            if (q_pressed)
                break;
1856 1857 1858 1859 1860
            /* read_key() returns 0 on EOF */
            key = read_key();
            if (key == 'q')
                break;
        }
1861

1862 1863
        /* select the stream that we must read now by looking at the
           smallest output pts */
glantau's avatar
merge  
glantau committed
1864
        file_index = -1;
1865
        for(i=0;i<nb_ostreams;i++) {
michael's avatar
michael committed
1866
            double ipts, opts;
1867 1868 1869
            ost = ost_table[i];
            os = output_files[ost->file_index];
            ist = ist_table[ost->source_index];
1870 1871
            if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
                opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
michael's avatar
michael committed
1872
            else
michael's avatar
michael committed
1873
                opts = ost->st->pts.val * av_q2d(ost->st->time_base);
michael's avatar
michael committed
1874 1875 1876 1877 1878 1879 1880 1881 1882 1883
            ipts = (double)ist->pts;
            if (!file_table[ist->file_index].eof_reached){
                if(ipts < ipts_min) {
                    ipts_min = ipts;
                    if(input_sync ) file_index = ist->file_index;
                }
                if(opts < opts_min) {
                    opts_min = opts;
                    if(!input_sync) file_index = ist->file_index;
                }
glantau's avatar
merge  
glantau committed
1884
            }
1885
            if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
michael's avatar
michael committed
1886 1887 1888
                file_index= -1;
                break;
            }
glantau's avatar
merge  
glantau committed
1889 1890
        }
        /* if none, if is finished */
1891
        if (file_index < 0) {
glantau's avatar
merge  
glantau committed
1892
            break;
1893 1894
        }

glantau's avatar
merge  
glantau committed
1895
        /* finish if recording time exhausted */
michael's avatar
michael committed
1896
        if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
glantau's avatar
merge  
glantau committed
1897
            break;
1898

1899 1900 1901 1902
        /* finish if limit size exhausted */
        if (limit_filesize != 0 && (limit_filesize * 1024) < url_ftell(&output_files[0]->pb))
            break;

1903
        /* read a frame from it and output it in the fifo */
glantau's avatar
merge  
glantau committed
1904
        is = input_files[file_index];
1905
        if (av_read_frame(is, &pkt) < 0) {
glantau's avatar
merge  
glantau committed
1906
            file_table[file_index].eof_reached = 1;
1907
            if (opt_shortest) break; else continue; //
glantau's avatar
merge  
glantau committed
1908
        }
1909

1910 1911 1912 1913 1914
        if (!pkt.size) {
            stream_no_data = is;
        } else {
            stream_no_data = 0;
        }
1915 1916
        if (do_pkt_dump) {
            av_pkt_dump(stdout, &pkt, do_hex_dump);
1917
        }
1918 1919 1920
        /* the following test is needed in case new streams appear
           dynamically in stream : we ignore them */
        if (pkt.stream_index >= file_table[file_index].nb_streams)
1921
            goto discard_packet;
glantau's avatar
merge  
glantau committed
1922 1923
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
        ist = ist_table[ist_index];
1924 1925
        if (ist->discard)
            goto discard_packet;
glantau's avatar
merge  
glantau committed
1926

1927
//        fprintf(stderr, "next:%lld dts:%lld off:%lld %d\n", ist->next_pts, pkt.dts, input_files_ts_offset[ist->file_index], ist->st->codec->codec_type);
michael's avatar
michael committed
1928
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
michael's avatar
michael committed
1929
            int64_t delta= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q) - ist->next_pts;
diego's avatar
diego committed
1930
            if(FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE && !copy_ts){
1931 1932
                input_files_ts_offset[ist->file_index]-= delta;
                if (verbose > 2)
1933
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
1934 1935 1936
                for(i=0; i<file_table[file_index].nb_streams; i++){
                    int index= file_table[file_index].ist_index + i;
                    ist_table[index]->next_pts += delta;
michael's avatar
michael committed
1937
                    ist_table[index]->is_start=1;
1938 1939 1940 1941
                }
            }
        }

1942
        //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
1943
        if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
1944 1945 1946 1947 1948

            if (verbose >= 0)
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
                        ist->file_index, ist->index);

1949 1950
            av_free_packet(&pkt);
            goto redo;
michael's avatar
michael committed
1951
        }
1952

1953
    discard_packet:
glantau's avatar
merge  
glantau committed
1954
        av_free_packet(&pkt);
1955

1956 1957
        /* dump report by using the output first video and audio streams */
        print_report(output_files, ost_table, nb_ostreams, 0);
glantau's avatar
merge  
glantau committed
1958
    }
1959 1960 1961 1962 1963 1964 1965 1966 1967

    /* at the end of stream, we must flush the decoder buffers */
    for(i=0;i<nb_istreams;i++) {
        ist = ist_table[i];
        if (ist->decoding_needed) {
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
        }
    }

1968
    term_exit();
glantau's avatar
merge  
glantau committed
1969

1970 1971 1972 1973 1974 1975
    /* write the trailer if needed and close file */
    for(i=0;i<nb_output_files;i++) {
        os = output_files[i];
        av_write_trailer(os);
    }

1976 1977 1978
    /* dump report by using the first video and audio streams */
    print_report(output_files, ost_table, nb_ostreams, 1);

glantau's avatar
merge  
glantau committed
1979 1980 1981 1982
    /* close each encoder */
    for(i=0;i<nb_ostreams;i++) {
        ost = ost_table[i];
        if (ost->encoding_needed) {
1983 1984
            av_freep(&ost->st->codec->stats_in);
            avcodec_close(ost->st->codec);
glantau's avatar
merge  
glantau committed
1985 1986
        }
    }
1987

glantau's avatar
merge  
glantau committed
1988 1989 1990 1991
    /* close each decoder */
    for(i=0;i<nb_istreams;i++) {
        ist = ist_table[i];
        if (ist->decoding_needed) {
1992
            avcodec_close(ist->st->codec);
glantau's avatar
merge  
glantau committed
1993 1994 1995 1996
        }
    }

    /* finished ! */
1997

glantau's avatar
merge  
glantau committed
1998 1999
    ret = 0;
 fail1:
michael's avatar
michael committed
2000
    av_freep(&bit_buffer);
glantau's avatar
glantau committed
2001
    av_free(file_table);
glantau's avatar
glantau committed
2002

glantau's avatar
merge  
glantau committed
2003 2004 2005
    if (ist_table) {
        for(i=0;i<nb_istreams;i++) {
            ist = ist_table[i];
glantau's avatar
glantau committed
2006
            av_free(ist);
glantau's avatar
merge  
glantau committed
2007
        }
glantau's avatar
glantau committed
2008
        av_free(ist_table);
glantau's avatar
merge  
glantau committed
2009 2010 2011 2012 2013
    }
    if (ost_table) {
        for(i=0;i<nb_ostreams;i++) {
            ost = ost_table[i];
            if (ost) {
2014 2015 2016 2017
                if (ost->logfile) {
                    fclose(ost->logfile);
                    ost->logfile = NULL;
                }
2018 2019
                av_fifo_free(&ost->fifo); /* works even if fifo is not
                                             initialized but set to zero */
glantau's avatar
glantau committed
2020
                av_free(ost->pict_tmp.data[0]);
glantau's avatar
merge  
glantau committed
2021
                if (ost->video_resample)
2022
                    sws_freeContext(ost->img_resample_ctx);
glantau's avatar
merge  
glantau committed
2023 2024
                if (ost->audio_resample)
                    audio_resample_close(ost->resample);
glantau's avatar
glantau committed
2025
                av_free(ost);
glantau's avatar
merge  
glantau committed
2026 2027
            }
        }
glantau's avatar
glantau committed
2028
        av_free(ost_table);
glantau's avatar
merge  
glantau committed
2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057
    }
    return ret;
 fail:
    ret = -ENOMEM;
    goto fail1;
}

#if 0
int file_read(const char *filename)
{
    URLContext *h;
    unsigned char buffer[1024];
    int len, i;

    if (url_open(&h, filename, O_RDONLY) < 0) {
        printf("could not open '%s'\n", filename);
        return -1;
    }
    for(;;) {
        len = url_read(h, buffer, sizeof(buffer));
        if (len <= 0)
            break;
        for(i=0;i<len;i++) putchar(buffer[i]);
    }
    url_close(h);
    return 0;
}
#endif

2058
static void opt_image_format(const char *arg)
2059 2060
{
    AVImageFormat *f;
2061

2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072
    for(f = first_image_format; f != NULL; f = f->next) {
        if (!strcmp(arg, f->name))
            break;
    }
    if (!f) {
        fprintf(stderr, "Unknown image format: '%s'\n", arg);
        exit(1);
    }
    image_format = f;
}

2073
static void opt_format(const char *arg)
glantau's avatar
merge  
glantau committed
2074
{
2075 2076
    /* compatibility stuff for pgmyuv */
    if (!strcmp(arg, "pgmyuv")) {
2077
        pgmyuv_compatibility_hack=1;
2078
//        opt_image_format(arg);
2079
        arg = "image2";
2080 2081
    }

2082 2083 2084 2085
    file_iformat = av_find_input_format(arg);
    file_oformat = guess_format(arg, NULL, NULL);
    if (!file_iformat && !file_oformat) {
        fprintf(stderr, "Unknown input or output format: %s\n", arg);
glantau's avatar
merge  
glantau committed
2086 2087 2088 2089
        exit(1);
    }
}

2090
static void opt_video_rc_eq(char *arg)
michaelni's avatar
michaelni committed
2091 2092 2093 2094
{
    video_rc_eq = arg;
}

2095
static void opt_video_rc_override_string(char *arg)
2096 2097 2098 2099
{
    video_rc_override_string = arg;
}

2100 2101 2102 2103 2104
static void opt_me_threshold(const char *arg)
{
    me_threshold = atoi(arg);
}

2105 2106 2107
static void opt_verbose(const char *arg)
{
    verbose = atoi(arg);
2108
    av_log_set_level(atoi(arg));
2109 2110
}

2111
static void opt_frame_rate(const char *arg)
glantau's avatar
merge  
glantau committed
2112
{
romansh's avatar
 
romansh committed
2113 2114
    if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
        fprintf(stderr, "Incorrect frame rate\n");
2115
        exit(1);
romansh's avatar
 
romansh committed
2116
    }
glantau's avatar
merge  
glantau committed
2117 2118
}

2119
static void opt_frame_crop_top(const char *arg)
2120
{
2121
    frame_topBand = atoi(arg);
2122 2123 2124 2125 2126 2127 2128 2129 2130
    if (frame_topBand < 0) {
        fprintf(stderr, "Incorrect top crop size\n");
        exit(1);
    }
    if ((frame_topBand % 2) != 0) {
        fprintf(stderr, "Top crop size must be a multiple of 2\n");
        exit(1);
    }
    if ((frame_topBand) >= frame_height){
2131
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2132 2133 2134 2135 2136
        exit(1);
    }
    frame_height -= frame_topBand;
}

2137
static void opt_frame_crop_bottom(const char *arg)
2138 2139 2140 2141 2142 2143 2144 2145
{
    frame_bottomBand = atoi(arg);
    if (frame_bottomBand < 0) {
        fprintf(stderr, "Incorrect bottom crop size\n");
        exit(1);
    }
    if ((frame_bottomBand % 2) != 0) {
        fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2146
        exit(1);
2147 2148
    }
    if ((frame_bottomBand) >= frame_height){
2149
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2150 2151 2152 2153 2154
        exit(1);
    }
    frame_height -= frame_bottomBand;
}

2155
static void opt_frame_crop_left(const char *arg)
2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166
{
    frame_leftBand = atoi(arg);
    if (frame_leftBand < 0) {
        fprintf(stderr, "Incorrect left crop size\n");
        exit(1);
    }
    if ((frame_leftBand % 2) != 0) {
        fprintf(stderr, "Left crop size must be a multiple of 2\n");
        exit(1);
    }
    if ((frame_leftBand) >= frame_width){
2167
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2168 2169 2170 2171 2172
        exit(1);
    }
    frame_width -= frame_leftBand;
}

2173
static void opt_frame_crop_right(const char *arg)
2174 2175 2176 2177 2178 2179 2180 2181
{
    frame_rightBand = atoi(arg);
    if (frame_rightBand < 0) {
        fprintf(stderr, "Incorrect right crop size\n");
        exit(1);
    }
    if ((frame_rightBand % 2) != 0) {
        fprintf(stderr, "Right crop size must be a multiple of 2\n");
2182
        exit(1);
2183 2184
    }
    if ((frame_rightBand) >= frame_width){
2185
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2186 2187 2188 2189 2190
        exit(1);
    }
    frame_width -= frame_rightBand;
}

2191
static void opt_frame_size(const char *arg)
glantau's avatar
merge  
glantau committed
2192
{
romansh's avatar
 
romansh committed
2193
    if (parse_image_size(&frame_width, &frame_height, arg) < 0) {
glantau's avatar
merge  
glantau committed
2194 2195 2196 2197 2198 2199 2200 2201 2202
        fprintf(stderr, "Incorrect frame size\n");
        exit(1);
    }
    if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
        fprintf(stderr, "Frame size must be a multiple of 2\n");
        exit(1);
    }
}

2203 2204 2205

#define SCALEBITS 10
#define ONE_HALF  (1 << (SCALEBITS - 1))
2206
#define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224

#define RGB_TO_Y(r, g, b) \
((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
  FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)

#define RGB_TO_U(r1, g1, b1, shift)\
(((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         \
     FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)

#define RGB_TO_V(r1, g1, b1, shift)\
(((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
   FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)

static void opt_pad_color(const char *arg) {
    /* Input is expected to be six hex digits similar to
       how colors are expressed in html tags (but without the #) */
    int rgb = strtol(arg, NULL, 16);
    int r,g,b;
2225 2226

    r = (rgb >> 16);
2227 2228 2229 2230 2231 2232 2233 2234 2235 2236
    g = ((rgb >> 8) & 255);
    b = (rgb & 255);

    padcolor[0] = RGB_TO_Y(r,g,b);
    padcolor[1] = RGB_TO_U(r,g,b,0);
    padcolor[2] = RGB_TO_V(r,g,b,0);
}

static void opt_frame_pad_top(const char *arg)
{
2237
    frame_padtop = atoi(arg);
2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249
    if (frame_padtop < 0) {
        fprintf(stderr, "Incorrect top pad size\n");
        exit(1);
    }
    if ((frame_padtop % 2) != 0) {
        fprintf(stderr, "Top pad size must be a multiple of 2\n");
        exit(1);
    }
}

static void opt_frame_pad_bottom(const char *arg)
{
2250
    frame_padbottom = atoi(arg);
2251 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261 2262 2263
    if (frame_padbottom < 0) {
        fprintf(stderr, "Incorrect bottom pad size\n");
        exit(1);
    }
    if ((frame_padbottom % 2) != 0) {
        fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
        exit(1);
    }
}


static void opt_frame_pad_left(const char *arg)
{
2264
    frame_padleft = atoi(arg);
2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277
    if (frame_padleft < 0) {
        fprintf(stderr, "Incorrect left pad size\n");
        exit(1);
    }
    if ((frame_padleft % 2) != 0) {
        fprintf(stderr, "Left pad size must be a multiple of 2\n");
        exit(1);
    }
}


static void opt_frame_pad_right(const char *arg)
{
2278
    frame_padright = atoi(arg);
2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289
    if (frame_padright < 0) {
        fprintf(stderr, "Incorrect right pad size\n");
        exit(1);
    }
    if ((frame_padright % 2) != 0) {
        fprintf(stderr, "Right pad size must be a multiple of 2\n");
        exit(1);
    }
}


romansh's avatar
 
romansh committed
2290 2291 2292 2293 2294
static void opt_frame_pix_fmt(const char *arg)
{
    frame_pix_fmt = avcodec_get_pix_fmt(arg);
}

romansh's avatar
 
romansh committed
2295 2296 2297 2298 2299
static void opt_frame_aspect_ratio(const char *arg)
{
    int x = 0, y = 0;
    double ar = 0;
    const char *p;
2300

romansh's avatar
 
romansh committed
2301 2302 2303
    p = strchr(arg, ':');
    if (p) {
        x = strtol(arg, (char **)&arg, 10);
2304 2305 2306 2307
        if (arg == p)
            y = strtol(arg+1, (char **)&arg, 10);
        if (x > 0 && y > 0)
            ar = (double)x / (double)y;
romansh's avatar
 
romansh committed
2308 2309 2310 2311 2312
    } else
        ar = strtod(arg, (char **)&arg);

    if (!ar) {
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2313
        exit(1);
romansh's avatar
 
romansh committed
2314 2315 2316 2317
    }
    frame_aspect_ratio = ar;
}

2318
static void opt_qscale(const char *arg)
glantau's avatar
merge  
glantau committed
2319
{
2320
    video_qscale = atof(arg);
lorenm's avatar
lorenm committed
2321
    if (video_qscale <= 0 ||
2322
        video_qscale > 255) {
lorenm's avatar
lorenm committed
2323
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
glantau's avatar
merge  
glantau committed
2324 2325 2326 2327
        exit(1);
    }
}

2328
static void opt_qdiff(const char *arg)
2329 2330 2331 2332 2333 2334 2335 2336 2337
{
    video_qdiff = atoi(arg);
    if (video_qdiff < 0 ||
        video_qdiff > 31) {
        fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
        exit(1);
    }
}

2338
static void opt_packet_size(const char *arg)
2339 2340 2341 2342
{
    packet_size= atoi(arg);
}

2343
static void opt_strict(const char *arg)
michaelni's avatar
michaelni committed
2344 2345 2346 2347
{
    strict= atoi(arg);
}

michael's avatar
michael committed
2348 2349 2350 2351 2352
static void opt_top_field_first(const char *arg)
{
    top_field_first= atoi(arg);
}

2353 2354 2355
static void opt_thread_count(const char *arg)
{
    thread_count= atoi(arg);
2356
#if !defined(HAVE_THREADS)
2357 2358
    if (verbose >= 0)
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
michael's avatar
michael committed
2359
#endif
2360 2361
}

2362
static void opt_audio_bitrate(const char *arg)
glantau's avatar
merge  
glantau committed
2363 2364 2365 2366
{
    audio_bit_rate = atoi(arg) * 1000;
}

2367
static void opt_audio_rate(const char *arg)
glantau's avatar
merge  
glantau committed
2368 2369 2370 2371
{
    audio_sample_rate = atoi(arg);
}

2372
static void opt_audio_channels(const char *arg)
glantau's avatar
merge  
glantau committed
2373 2374 2375 2376
{
    audio_channels = atoi(arg);
}

2377
static void opt_video_device(const char *arg)
glantau's avatar
merge  
glantau committed
2378
{
bellard's avatar
bellard committed
2379
    video_device = av_strdup(arg);
glantau's avatar
merge  
glantau committed
2380 2381
}

romansh's avatar
 
romansh committed
2382 2383 2384 2385 2386
static void opt_grab_device(const char *arg)
{
    grab_device = av_strdup(arg);
}

2387
static void opt_video_channel(const char *arg)
2388 2389 2390 2391
{
    video_channel = strtol(arg, NULL, 0);
}

2392 2393 2394 2395 2396
static void opt_video_standard(const char *arg)
{
    video_standard = av_strdup(arg);
}

2397
static void opt_audio_device(const char *arg)
glantau's avatar
merge  
glantau committed
2398
{
bellard's avatar
bellard committed
2399
    audio_device = av_strdup(arg);
glantau's avatar
merge  
glantau committed
2400 2401
}

2402 2403
static void opt_codec(int *pstream_copy, int *pcodec_id,
                      int codec_type, const char *arg)
glantau's avatar
merge  
glantau committed
2404 2405 2406
{
    AVCodec *p;

2407
    if (!strcmp(arg, "copy")) {
2408
        *pstream_copy = 1;
glantau's avatar
merge  
glantau committed
2409
    } else {
2410 2411
        p = first_avcodec;
        while (p) {
2412
            if (!strcmp(p->name, arg) && p->type == codec_type)
2413 2414 2415 2416
                break;
            p = p->next;
        }
        if (p == NULL) {
2417
            fprintf(stderr, "Unknown codec '%s'\n", arg);
2418 2419
            exit(1);
        } else {
2420
            *pcodec_id = p->id;
2421
        }
glantau's avatar
merge  
glantau committed
2422 2423 2424
    }
}

2425 2426 2427 2428 2429
static void opt_audio_codec(const char *arg)
{
    opt_codec(&audio_stream_copy, &audio_codec_id, CODEC_TYPE_AUDIO, arg);
}

michael's avatar
michael committed
2430 2431 2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447
static void opt_audio_tag(const char *arg)
{
    char *tail;
    audio_codec_tag= strtol(arg, &tail, 0);

    if(!tail || *tail)
        audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
}

static void opt_video_tag(const char *arg)
{
    char *tail;
    video_codec_tag= strtol(arg, &tail, 0);

    if(!tail || *tail)
        video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
}

2448
static void add_frame_hooker(const char *arg)
2449 2450 2451 2452
{
    int argc = 0;
    char *argv[64];
    int i;
bellard's avatar
bellard committed
2453
    char *args = av_strdup(arg);
2454

2455 2456
    using_vhook = 1;

2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468
    argv[0] = strtok(args, " ");
    while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
    }

    i = frame_hook_add(argc, argv);

    if (i != 0) {
        fprintf(stderr, "Failed to add video hook function: %s\n", arg);
        exit(1);
    }
}

glantau's avatar
merge  
glantau committed
2469 2470 2471 2472 2473
const char *motion_str[] = {
    "zero",
    "full",
    "log",
    "phods",
michaelni's avatar
michaelni committed
2474 2475
    "epzs",
    "x1",
2476 2477 2478
    "hex",
    "umh",
    "iter",
glantau's avatar
merge  
glantau committed
2479 2480 2481
    NULL,
};

2482
static void opt_motion_estimation(const char *arg)
glantau's avatar
merge  
glantau committed
2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494
{
    const char **p;
    p = motion_str;
    for(;;) {
        if (!*p) {
            fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
            exit(1);
        }
        if (!strcmp(*p, arg))
            break;
        p++;
    }
2495
    me_method = (p - motion_str) + 1;
glantau's avatar
merge  
glantau committed
2496 2497
}

2498
static void opt_video_codec(const char *arg)
glantau's avatar
merge  
glantau committed
2499
{
2500 2501
    opt_codec(&video_stream_copy, &video_codec_id, CODEC_TYPE_VIDEO, arg);
}
glantau's avatar
merge  
glantau committed
2502

2503 2504 2505
static void opt_subtitle_codec(const char *arg)
{
    opt_codec(&subtitle_stream_copy, &subtitle_codec_id, CODEC_TYPE_SUBTITLE, arg);
glantau's avatar
merge  
glantau committed
2506 2507
}

2508
static void opt_map(const char *arg)
glantau's avatar
merge  
glantau committed
2509 2510 2511 2512 2513 2514 2515 2516 2517 2518
{
    AVStreamMap *m;
    const char *p;

    p = arg;
    m = &stream_maps[nb_stream_maps++];

    m->file_index = strtol(arg, (char **)&p, 0);
    if (*p)
        p++;
pulento's avatar
pulento committed
2519 2520

    m->stream_index = strtol(p, (char **)&p, 0);
2521 2522 2523 2524 2525 2526 2527 2528 2529 2530
    if (*p) {
        p++;
        m->sync_file_index = strtol(p, (char **)&p, 0);
        if (*p)
            p++;
        m->sync_stream_index = strtol(p, (char **)&p, 0);
    } else {
        m->sync_file_index = m->file_index;
        m->sync_stream_index = m->stream_index;
    }
glantau's avatar
merge  
glantau committed
2531 2532
}

2533 2534 2535 2536
static void opt_map_meta_data(const char *arg)
{
    AVMetaDataMap *m;
    const char *p;
2537

2538 2539 2540 2541 2542 2543 2544 2545 2546 2547
    p = arg;
    m = &meta_data_maps[nb_meta_data_maps++];

    m->out_file = strtol(arg, (char **)&p, 0);
    if (*p)
        p++;

    m->in_file = strtol(p, (char **)&p, 0);
}

2548
static void opt_recording_time(const char *arg)
glantau's avatar
merge  
glantau committed
2549 2550 2551 2552
{
    recording_time = parse_date(arg, 1);
}

2553 2554 2555 2556 2557
static void opt_start_time(const char *arg)
{
    start_time = parse_date(arg, 1);
}

romansh's avatar
 
romansh committed
2558 2559 2560 2561 2562
static void opt_rec_timestamp(const char *arg)
{
    rec_timestamp = parse_date(arg, 0) / 1000000;
}

michael's avatar
michael committed
2563 2564 2565 2566 2567
static void opt_input_ts_offset(const char *arg)
{
    input_ts_offset = parse_date(arg, 1);
}

2568
static void opt_input_file(const char *filename)
glantau's avatar
merge  
glantau committed
2569 2570 2571
{
    AVFormatContext *ic;
    AVFormatParameters params, *ap = &params;
2572
    int err, i, ret, rfps, rfps_base;
michael's avatar
michael committed
2573
    int64_t timestamp;
glantau's avatar
merge  
glantau committed
2574

bellard's avatar
bellard committed
2575 2576 2577
    if (!strcmp(filename, "-"))
        filename = "pipe:";

2578
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2579 2580
                   !strcmp( filename, "/dev/stdin" );

glantau's avatar
merge  
glantau committed
2581
    /* get default parameters from command line */
2582 2583
    ic = av_alloc_format_context();

2584
    memset(ap, 0, sizeof(*ap));
2585
    ap->prealloced_context = 1;
2586 2587
    ap->sample_rate = audio_sample_rate;
    ap->channels = audio_channels;
michael's avatar
michael committed
2588 2589
    ap->time_base.den = frame_rate;
    ap->time_base.num = frame_rate_base;
2590 2591
    ap->width = frame_width + frame_padleft + frame_padright;
    ap->height = frame_height + frame_padtop + frame_padbottom;
2592
    ap->image_format = image_format;
romansh's avatar
 
romansh committed
2593
    ap->pix_fmt = frame_pix_fmt;
romansh's avatar
 
romansh committed
2594 2595 2596
    ap->device  = grab_device;
    ap->channel = video_channel;
    ap->standard = video_standard;
2597 2598 2599 2600
    ap->video_codec_id = video_codec_id;
    ap->audio_codec_id = audio_codec_id;
    if(pgmyuv_compatibility_hack)
        ap->video_codec_id= CODEC_ID_PGMYUV;
2601

2602 2603 2604 2605 2606 2607
    for(i=0; i<opt_name_count; i++){
        AVOption *opt;
        double d= av_get_double(avformat_opts, opt_names[i], &opt);
        if(d==d && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
            av_set_double(ic, opt_names[i], d);
    }
2608 2609
    /* open the input file with generic libav function */
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
glantau's avatar
merge  
glantau committed
2610
    if (err < 0) {
2611
        print_error(filename, err);
glantau's avatar
merge  
glantau committed
2612 2613
        exit(1);
    }
2614

2615 2616
    ic->loop_input = loop_input;

2617 2618 2619
    /* If not enough info to get the stream parameters, we decode the
       first frames to get it. (used in mpeg case for example) */
    ret = av_find_stream_info(ic);
2620
    if (ret < 0 && verbose >= 0) {
glantau's avatar
merge  
glantau committed
2621 2622 2623 2624
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
        exit(1);
    }

michael's avatar
michael committed
2625 2626 2627 2628 2629
    timestamp = start_time;
    /* add the stream start time */
    if (ic->start_time != AV_NOPTS_VALUE)
        timestamp += ic->start_time;

2630 2631
    /* if seeking requested, we execute it */
    if (start_time != 0) {
michael's avatar
michael committed
2632
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2633
        if (ret < 0) {
2634
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
2635 2636 2637 2638 2639 2640
                    filename, (double)timestamp / AV_TIME_BASE);
        }
        /* reset seek info */
        start_time = 0;
    }

glantau's avatar
merge  
glantau committed
2641 2642
    /* update the current parameters so that they match the one of the input stream */
    for(i=0;i<ic->nb_streams;i++) {
2643
        int j;
2644
        AVCodecContext *enc = ic->streams[i]->codec;
2645
#if defined(HAVE_THREADS)
michael's avatar
michael committed
2646 2647 2648 2649
        if(thread_count>1)
            avcodec_thread_init(enc, thread_count);
#endif
        enc->thread_count= thread_count;
glantau's avatar
merge  
glantau committed
2650 2651
        switch(enc->codec_type) {
        case CODEC_TYPE_AUDIO:
2652 2653 2654 2655 2656 2657
            for(j=0; j<opt_name_count; j++){
                AVOption *opt;
                double d= av_get_double(avctx_opts, opt_names[j], &opt);
                if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
                    av_set_double(enc, opt_names[j], d);
            }
2658
            //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
glantau's avatar
merge  
glantau committed
2659 2660
            audio_channels = enc->channels;
            audio_sample_rate = enc->sample_rate;
2661
            if(audio_disable)
2662
                ic->streams[i]->discard= AVDISCARD_ALL;
glantau's avatar
merge  
glantau committed
2663 2664
            break;
        case CODEC_TYPE_VIDEO:
2665 2666 2667 2668 2669 2670
            for(j=0; j<opt_name_count; j++){
                AVOption *opt;
                double d= av_get_double(avctx_opts, opt_names[j], &opt);
                if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
                    av_set_double(enc, opt_names[j], d);
            }
glantau's avatar
merge  
glantau committed
2671 2672
            frame_height = enc->height;
            frame_width = enc->width;
2673 2674
            frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
            frame_pix_fmt = enc->pix_fmt;
michael's avatar
michael committed
2675 2676
            rfps      = ic->streams[i]->r_frame_rate.num;
            rfps_base = ic->streams[i]->r_frame_rate.den;
2677
            if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2678 2679
            if(me_threshold)
                enc->debug |= FF_DEBUG_MV;
2680

2681
            if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2682 2683

                if (verbose >= 0)
2684
                    fprintf(stderr,"\nSeems that stream %d comes from film source: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
michael's avatar
michael committed
2685
                            i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2686

2687
                    (float)rfps / rfps_base, rfps, rfps_base);
2688
            }
2689
            /* update the current frame rate to match the stream frame rate */
2690 2691
            frame_rate      = rfps;
            frame_rate_base = rfps_base;
2692 2693

            enc->rate_emu = rate_emu;
2694
            if(video_disable)
2695 2696 2697
                ic->streams[i]->discard= AVDISCARD_ALL;
            else if(video_discard)
                ic->streams[i]->discard= video_discard;
glantau's avatar
merge  
glantau committed
2698
            break;
2699 2700
        case CODEC_TYPE_DATA:
            break;
2701 2702
        case CODEC_TYPE_SUBTITLE:
            break;
2703 2704
        case CODEC_TYPE_UNKNOWN:
            break;
2705
        default:
2706
            av_abort();
glantau's avatar
merge  
glantau committed
2707 2708
        }
    }
2709

glantau's avatar
merge  
glantau committed
2710
    input_files[nb_input_files] = ic;
michael's avatar
michael committed
2711
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
glantau's avatar
merge  
glantau committed
2712
    /* dump the file content */
2713 2714 2715
    if (verbose >= 0)
        dump_format(ic, nb_input_files, filename, 0);

glantau's avatar
merge  
glantau committed
2716
    nb_input_files++;
2717 2718
    file_iformat = NULL;
    file_oformat = NULL;
2719
    image_format = NULL;
2720

romansh's avatar
 
romansh committed
2721 2722
    grab_device = NULL;
    video_channel = 0;
2723

2724
    rate_emu = 0;
glantau's avatar
merge  
glantau committed
2725 2726
}

romansh's avatar
 
romansh committed
2727 2728 2729 2730 2731 2732
static void opt_grab(const char *arg)
{
    file_iformat = av_find_input_format(arg);
    opt_input_file("");
}

2733
static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2734 2735 2736 2737 2738 2739 2740 2741 2742
{
    int has_video, has_audio, i, j;
    AVFormatContext *ic;

    has_video = 0;
    has_audio = 0;
    for(j=0;j<nb_input_files;j++) {
        ic = input_files[j];
        for(i=0;i<ic->nb_streams;i++) {
2743
            AVCodecContext *enc = ic->streams[i]->codec;
2744 2745 2746 2747 2748 2749 2750
            switch(enc->codec_type) {
            case CODEC_TYPE_AUDIO:
                has_audio = 1;
                break;
            case CODEC_TYPE_VIDEO:
                has_video = 1;
                break;
2751
            case CODEC_TYPE_DATA:
2752
            case CODEC_TYPE_UNKNOWN:
2753
            case CODEC_TYPE_SUBTITLE:
2754
                break;
2755
            default:
2756
                av_abort();
2757 2758 2759 2760 2761 2762 2763
            }
        }
    }
    *has_video_ptr = has_video;
    *has_audio_ptr = has_audio;
}

2764
static void new_video_stream(AVFormatContext *oc)
glantau's avatar
merge  
glantau committed
2765 2766
{
    AVStream *st;
2767 2768
    AVCodecContext *video_enc;
    int codec_id;
2769

2770 2771 2772 2773 2774
    st = av_new_stream(oc, oc->nb_streams);
    if (!st) {
        fprintf(stderr, "Could not alloc stream\n");
        exit(1);
    }
2775 2776 2777
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
    video_bitstream_filters= NULL;

2778 2779
#if defined(HAVE_THREADS)
    if(thread_count>1)
2780
        avcodec_thread_init(st->codec, thread_count);
2781
#endif
2782

2783
    video_enc = st->codec;
2784

2785 2786
    if(video_codec_tag)
        video_enc->codec_tag= video_codec_tag;
2787

2788
    if(   (video_global_header&1)
2789
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2790
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2791 2792 2793
        avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
    }
    if(video_global_header&2){
2794
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2795 2796
        avctx_opts->flags2|= CODEC_FLAG2_LOCAL_HEADER;
    }
2797

2798 2799 2800 2801 2802 2803 2804
    if (video_stream_copy) {
        st->stream_copy = 1;
        video_enc->codec_type = CODEC_TYPE_VIDEO;
    } else {
        char *p;
        int i;
        AVCodec *codec;
2805

2806 2807 2808
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
        if (video_codec_id != CODEC_ID_NONE)
            codec_id = video_codec_id;
2809

2810 2811
        video_enc->codec_id = codec_id;
        codec = avcodec_find_encoder(codec_id);
2812

michael's avatar
michael committed
2813 2814 2815 2816 2817 2818
        for(i=0; i<opt_name_count; i++){
             AVOption *opt;
             double d= av_get_double(avctx_opts, opt_names[i], &opt);
             if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
                 av_set_double(video_enc, opt_names[i], d);
        }
2819 2820 2821

        video_enc->time_base.den = frame_rate;
        video_enc->time_base.num = frame_rate_base;
2822 2823 2824 2825 2826 2827 2828 2829 2830 2831 2832 2833 2834 2835 2836 2837
        if(codec && codec->supported_framerates){
            const AVRational *p= codec->supported_framerates;
            AVRational req= (AVRational){frame_rate, frame_rate_base};
            const AVRational *best=NULL;
            AVRational best_error= (AVRational){INT_MAX, 1};
            for(; p->den!=0; p++){
                AVRational error= av_sub_q(req, *p);
                if(error.num <0) error.num *= -1;
                if(av_cmp_q(error, best_error) < 0){
                    best_error= error;
                    best= p;
                }
            }
            video_enc->time_base.den= best->num;
            video_enc->time_base.num= best->den;
        }
2838

2839 2840
        video_enc->width = frame_width + frame_padright + frame_padleft;
        video_enc->height = frame_height + frame_padtop + frame_padbottom;
lucabe's avatar
lucabe committed
2841
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2842 2843 2844 2845 2846 2847 2848 2849 2850 2851 2852 2853
        video_enc->pix_fmt = frame_pix_fmt;

        if(codec && codec->pix_fmts){
            const enum PixelFormat *p= codec->pix_fmts;
            for(; *p!=-1; p++){
                if(*p == video_enc->pix_fmt)
                    break;
            }
            if(*p == -1)
                video_enc->pix_fmt = codec->pix_fmts[0];
        }

2854
        if (intra_only)
2855 2856 2857
            video_enc->gop_size = 0;
        if (video_qscale || same_quality) {
            video_enc->flags |= CODEC_FLAG_QSCALE;
2858
            video_enc->global_quality=
2859 2860 2861 2862 2863 2864 2865 2866 2867 2868 2869 2870 2871 2872 2873 2874 2875 2876 2877
                st->quality = FF_QP2LAMBDA * video_qscale;
        }

        if(intra_matrix)
            video_enc->intra_matrix = intra_matrix;
        if(inter_matrix)
            video_enc->inter_matrix = inter_matrix;

        video_enc->max_qdiff = video_qdiff;
        video_enc->rc_eq = video_rc_eq;
        video_enc->thread_count = thread_count;
        p= video_rc_override_string;
        for(i=0; p; i++){
            int start, end, q;
            int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
            if(e!=3){
                fprintf(stderr, "error parsing rc_override\n");
                exit(1);
            }
2878 2879
            video_enc->rc_override=
                av_realloc(video_enc->rc_override,
2880 2881 2882 2883 2884 2885 2886 2887 2888 2889 2890 2891 2892 2893 2894
                           sizeof(RcOverride)*(i+1));
            video_enc->rc_override[i].start_frame= start;
            video_enc->rc_override[i].end_frame  = end;
            if(q>0){
                video_enc->rc_override[i].qscale= q;
                video_enc->rc_override[i].quality_factor= 1.0;
            }
            else{
                video_enc->rc_override[i].qscale= 0;
                video_enc->rc_override[i].quality_factor= -q/100.0;
            }
            p= strchr(p, '/');
            if(p) p++;
        }
        video_enc->rc_override_count=i;
2895
        video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
2896 2897 2898 2899 2900 2901 2902 2903
        video_enc->me_threshold= me_threshold;
        video_enc->intra_dc_precision= intra_dc_precision - 8;
        video_enc->strict_std_compliance = strict;

        if(packet_size){
            video_enc->rtp_mode= 1;
            video_enc->rtp_payload_size= packet_size;
        }
2904

2905 2906
        if (do_psnr)
            video_enc->flags|= CODEC_FLAG_PSNR;
2907

2908 2909 2910 2911 2912 2913 2914 2915 2916 2917 2918 2919 2920 2921 2922 2923 2924 2925 2926 2927 2928 2929
        video_enc->me_method = me_method;

        /* two pass mode */
        if (do_pass) {
            if (do_pass == 1) {
                video_enc->flags |= CODEC_FLAG_PASS1;
            } else {
                video_enc->flags |= CODEC_FLAG_PASS2;
            }
        }
    }

    /* reset some key parameters */
    video_disable = 0;
    video_codec_id = CODEC_ID_NONE;
    video_stream_copy = 0;
}

static void new_audio_stream(AVFormatContext *oc)
{
    AVStream *st;
    AVCodecContext *audio_enc;
michael's avatar
michael committed
2930
    int codec_id, i;
2931

2932 2933 2934 2935 2936
    st = av_new_stream(oc, oc->nb_streams);
    if (!st) {
        fprintf(stderr, "Could not alloc stream\n");
        exit(1);
    }
2937 2938 2939 2940

    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
    audio_bitstream_filters= NULL;

2941 2942
#if defined(HAVE_THREADS)
    if(thread_count>1)
2943
        avcodec_thread_init(st->codec, thread_count);
2944
#endif
2945

2946
    audio_enc = st->codec;
2947
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
2948

2949 2950
    if(audio_codec_tag)
        audio_enc->codec_tag= audio_codec_tag;
2951

2952
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
2953
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2954 2955
        avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
    }
2956 2957 2958 2959 2960
    if (audio_stream_copy) {
        st->stream_copy = 1;
        audio_enc->channels = audio_channels;
    } else {
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
2961

michael's avatar
michael committed
2962 2963 2964 2965 2966 2967
        for(i=0; i<opt_name_count; i++){
            AVOption *opt;
            double d= av_get_double(avctx_opts, opt_names[i], &opt);
            if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
                av_set_double(audio_enc, opt_names[i], d);
        }
2968

2969 2970 2971
        if (audio_codec_id != CODEC_ID_NONE)
            codec_id = audio_codec_id;
        audio_enc->codec_id = codec_id;
2972

2973
        audio_enc->bit_rate = audio_bit_rate;
2974 2975 2976 2977
        if (audio_qscale > QSCALE_NONE) {
            audio_enc->flags |= CODEC_FLAG_QSCALE;
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
        }
2978 2979 2980 2981 2982 2983 2984 2985 2986 2987 2988
        audio_enc->strict_std_compliance = strict;
        audio_enc->thread_count = thread_count;
        /* For audio codecs other than AC3 or DTS we limit */
        /* the number of coded channels to stereo   */
        if (audio_channels > 2 && codec_id != CODEC_ID_AC3
            && codec_id != CODEC_ID_DTS) {
            audio_enc->channels = 2;
        } else
            audio_enc->channels = audio_channels;
    }
    audio_enc->sample_rate = audio_sample_rate;
2989
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
2990 2991 2992 2993 2994 2995 2996 2997 2998 2999 3000 3001 3002 3003 3004 3005 3006
    if (audio_language) {
        pstrcpy(st->language, sizeof(st->language), audio_language);
        av_free(audio_language);
        audio_language = NULL;
    }

    /* reset some key parameters */
    audio_disable = 0;
    audio_codec_id = CODEC_ID_NONE;
    audio_stream_copy = 0;
}

static void opt_new_subtitle_stream(void)
{
    AVFormatContext *oc;
    AVStream *st;
    AVCodecContext *subtitle_enc;
michael's avatar
michael committed
3007
    int i;
3008

3009 3010 3011 3012 3013 3014 3015 3016 3017 3018 3019 3020
    if (nb_output_files <= 0) {
        fprintf(stderr, "At least one output file must be specified\n");
        exit(1);
    }
    oc = output_files[nb_output_files - 1];

    st = av_new_stream(oc, oc->nb_streams);
    if (!st) {
        fprintf(stderr, "Could not alloc stream\n");
        exit(1);
    }

3021
    subtitle_enc = st->codec;
3022 3023 3024 3025
    subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
    if (subtitle_stream_copy) {
        st->stream_copy = 1;
    } else {
michael's avatar
michael committed
3026 3027 3028 3029 3030 3031
        for(i=0; i<opt_name_count; i++){
             AVOption *opt;
             double d= av_get_double(avctx_opts, opt_names[i], &opt);
             if(d==d && (opt->flags&AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
                 av_set_double(subtitle_enc, opt_names[i], d);
        }
3032 3033 3034 3035 3036 3037 3038 3039 3040 3041 3042 3043 3044 3045 3046 3047 3048 3049 3050 3051 3052 3053 3054 3055 3056 3057 3058 3059 3060 3061 3062 3063 3064 3065 3066 3067 3068 3069
        subtitle_enc->codec_id = subtitle_codec_id;
    }

    if (subtitle_language) {
        pstrcpy(st->language, sizeof(st->language), subtitle_language);
        av_free(subtitle_language);
        subtitle_language = NULL;
    }

    subtitle_codec_id = CODEC_ID_NONE;
    subtitle_stream_copy = 0;
}

static void opt_new_audio_stream(void)
{
    AVFormatContext *oc;
    if (nb_output_files <= 0) {
        fprintf(stderr, "At least one output file must be specified\n");
        exit(1);
    }
    oc = output_files[nb_output_files - 1];
    new_audio_stream(oc);
}

static void opt_new_video_stream(void)
{
    AVFormatContext *oc;
    if (nb_output_files <= 0) {
        fprintf(stderr, "At least one output file must be specified\n");
        exit(1);
    }
    oc = output_files[nb_output_files - 1];
    new_video_stream(oc);
}

static void opt_output_file(const char *filename)
{
    AVFormatContext *oc;
gpoirier's avatar
gpoirier committed
3070
    int use_video, use_audio, input_has_video, input_has_audio, i;
3071
    AVFormatParameters params, *ap = &params;
glantau's avatar
merge  
glantau committed
3072 3073 3074 3075

    if (!strcmp(filename, "-"))
        filename = "pipe:";

3076
    oc = av_alloc_format_context();
glantau's avatar
merge  
glantau committed
3077

3078 3079 3080 3081 3082 3083 3084
    if (!file_oformat) {
        file_oformat = guess_format(NULL, filename, NULL);
        if (!file_oformat) {
            fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
                    filename);
            exit(1);
        }
glantau's avatar
merge  
glantau committed
3085
    }
3086

3087
    oc->oformat = file_oformat;
3088
    pstrcpy(oc->filename, sizeof(oc->filename), filename);
glantau's avatar
merge  
glantau committed
3089

3090
    if (!strcmp(file_oformat->name, "ffm") &&
glantau's avatar
merge  
glantau committed
3091 3092 3093 3094 3095 3096 3097 3098
        strstart(filename, "http:", NULL)) {
        /* special case for files sent to ffserver: we get the stream
           parameters from ffserver */
        if (read_ffserver_streams(oc, filename) < 0) {
            fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
            exit(1);
        }
    } else {
3099 3100
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_id != CODEC_ID_NONE;
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_id != CODEC_ID_NONE;
3101

3102 3103 3104 3105 3106 3107 3108 3109 3110
        /* disable if no corresponding type found and at least one
           input file */
        if (nb_input_files > 0) {
            check_audio_video_inputs(&input_has_video, &input_has_audio);
            if (!input_has_video)
                use_video = 0;
            if (!input_has_audio)
                use_audio = 0;
        }
3111 3112

        /* manual disable */
glantau's avatar
merge  
glantau committed
3113 3114 3115 3116 3117 3118
        if (audio_disable) {
            use_audio = 0;
        }
        if (video_disable) {
            use_video = 0;
        }
3119

glantau's avatar
merge  
glantau committed
3120
        if (use_video) {
3121
            new_video_stream(oc);
glantau's avatar
merge  
glantau committed
3122
        }
3123

glantau's avatar
merge  
glantau committed
3124
        if (use_audio) {
3125
            new_audio_stream(oc);
glantau's avatar
merge  
glantau committed
3126 3127
        }

3128
        if (!oc->nb_streams) {
3129
            fprintf(stderr, "Note: Output file will not contain a video or audio stream\n");
glantau's avatar
merge  
glantau committed
3130 3131
        }

romansh's avatar
 
romansh committed
3132
        oc->timestamp = rec_timestamp;
3133

3134
        if (str_title)
3135
            pstrcpy(oc->title, sizeof(oc->title), str_title);
glantau's avatar
merge  
glantau committed
3136
        if (str_author)
3137
            pstrcpy(oc->author, sizeof(oc->author), str_author);
glantau's avatar
merge  
glantau committed
3138
        if (str_copyright)
3139
            pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
glantau's avatar
merge  
glantau committed
3140
        if (str_comment)
3141
            pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3142 3143
        if (str_album)
            pstrcpy(oc->album, sizeof(oc->album), str_album);
glantau's avatar
merge  
glantau committed
3144 3145
    }

3146
    output_files[nb_output_files++] = oc;
glantau's avatar
merge  
glantau committed
3147

3148
    /* check filename in case of an image number is expected */
3149
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3150
        if (!av_filename_number_test(oc->filename)) {
3151
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3152
            exit(1);
3153
        }
3154 3155
    }

3156
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
glantau's avatar
merge  
glantau committed
3157
        /* test if it already exists to avoid loosing precious files */
3158
        if (!file_overwrite &&
glantau's avatar
merge  
glantau committed
3159 3160 3161 3162
            (strchr(filename, ':') == NULL ||
             strstart(filename, "file:", NULL))) {
            if (url_exist(filename)) {
                int c;
3163

3164 3165 3166 3167 3168 3169 3170 3171
                if ( !using_stdin ) {
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
                    fflush(stderr);
                    c = getchar();
                    if (toupper(c) != 'Y') {
                        fprintf(stderr, "Not overwriting - exiting\n");
                        exit(1);
                    }
3172 3173
                                }
                                else {
3174
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
glantau's avatar
merge  
glantau committed
3175
                    exit(1);
3176
                                }
glantau's avatar
merge  
glantau committed
3177 3178
            }
        }
3179

glantau's avatar
merge  
glantau committed
3180 3181 3182 3183 3184 3185 3186
        /* open the file */
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
            fprintf(stderr, "Could not open '%s'\n", filename);
            exit(1);
        }
    }

3187 3188 3189 3190 3191 3192 3193 3194
    memset(ap, 0, sizeof(*ap));
    ap->image_format = image_format;
    if (av_set_parameters(oc, ap) < 0) {
        fprintf(stderr, "%s: Invalid encoding parameters\n",
                oc->filename);
        exit(1);
    }

3195 3196
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3197
    oc->loop_output = loop_output;
3198

gpoirier's avatar
gpoirier committed
3199 3200 3201 3202 3203 3204 3205
    for(i=0; i<opt_name_count; i++){
        AVOption *opt;
        double d = av_get_double(avformat_opts, opt_names[i], &opt);
        if(d==d && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
            av_set_double(oc, opt_names[i], d);
    }

glantau's avatar
merge  
glantau committed
3206
    /* reset some options */
3207 3208
    file_oformat = NULL;
    file_iformat = NULL;
3209
    image_format = NULL;
glantau's avatar
merge  
glantau committed
3210 3211
}

3212
/* prepare dummy protocols for grab */
3213
static void prepare_grab(void)
3214 3215 3216 3217
{
    int has_video, has_audio, i, j;
    AVFormatContext *oc;
    AVFormatContext *ic;
3218
    AVFormatParameters vp1, *vp = &vp1;
3219
    AVFormatParameters ap1, *ap = &ap1;
3220

3221 3222 3223 3224
    /* see if audio/video inputs are needed */
    has_video = 0;
    has_audio = 0;
    memset(ap, 0, sizeof(*ap));
3225
    memset(vp, 0, sizeof(*vp));
michael's avatar
michael committed
3226
    vp->time_base.num= 1;
3227 3228 3229
    for(j=0;j<nb_output_files;j++) {
        oc = output_files[j];
        for(i=0;i<oc->nb_streams;i++) {
3230
            AVCodecContext *enc = oc->streams[i]->codec;
3231 3232 3233 3234 3235 3236 3237 3238 3239
            switch(enc->codec_type) {
            case CODEC_TYPE_AUDIO:
                if (enc->sample_rate > ap->sample_rate)
                    ap->sample_rate = enc->sample_rate;
                if (enc->channels > ap->channels)
                    ap->channels = enc->channels;
                has_audio = 1;
                break;
            case CODEC_TYPE_VIDEO:
3240 3241 3242 3243
                if (enc->width > vp->width)
                    vp->width = enc->width;
                if (enc->height > vp->height)
                    vp->height = enc->height;
3244

michael's avatar
michael committed
3245 3246
                if (vp->time_base.num*(int64_t)enc->time_base.den > enc->time_base.num*(int64_t)vp->time_base.den){
                    vp->time_base = enc->time_base;
3247 3248 3249 3250
                    vp->width += frame_leftBand + frame_rightBand;
                    vp->width -= (frame_padleft + frame_padright);
                    vp->height += frame_topBand + frame_bottomBand;
                    vp->height -= (frame_padtop + frame_padbottom);
3251
                }
3252 3253
                has_video = 1;
                break;
3254
            default:
3255
                av_abort();
3256 3257 3258
            }
        }
    }
3259

3260 3261 3262 3263
    if (has_video == 0 && has_audio == 0) {
        fprintf(stderr, "Output file must have at least one audio or video stream\n");
        exit(1);
    }
3264

3265
    if (has_video) {
3266
        AVInputFormat *fmt1;
3267
        fmt1 = av_find_input_format(video_grab_format);
3268 3269
        vp->device  = video_device;
        vp->channel = video_channel;
3270
        vp->standard = video_standard;
3271
        vp->pix_fmt = frame_pix_fmt;
3272
        if (av_open_input_file(&ic, "", fmt1, 0, vp) < 0) {
3273
            fprintf(stderr, "Could not find video grab device\n");
3274 3275
            exit(1);
        }
romansh's avatar
 
romansh committed
3276 3277
        /* If not enough info to get the stream parameters, we decode the
           first frames to get it. */
3278
        if ((ic->ctx_flags & AVFMTCTX_NOHEADER) && av_find_stream_info(ic) < 0) {
romansh's avatar
 
romansh committed
3279 3280 3281
            fprintf(stderr, "Could not find video grab parameters\n");
            exit(1);
        }
3282
        /* by now video grab has one stream */
michael's avatar
michael committed
3283 3284
        ic->streams[0]->r_frame_rate.num = vp->time_base.den;
        ic->streams[0]->r_frame_rate.den = vp->time_base.num;
3285
        input_files[nb_input_files] = ic;
3286 3287 3288 3289

        if (verbose >= 0)
            dump_format(ic, nb_input_files, "", 0);

3290 3291
        nb_input_files++;
    }
3292
    if (has_audio && audio_grab_format) {
3293
        AVInputFormat *fmt1;
3294
        fmt1 = av_find_input_format(audio_grab_format);
3295
        ap->device = audio_device;
3296
        if (av_open_input_file(&ic, "", fmt1, 0, ap) < 0) {
3297
            fprintf(stderr, "Could not find audio grab device\n");
3298 3299 3300
            exit(1);
        }
        input_files[nb_input_files] = ic;
3301 3302 3303 3304

        if (verbose >= 0)
            dump_format(ic, nb_input_files, "", 0);

3305 3306 3307 3308
        nb_input_files++;
    }
}

3309
/* same option as mencoder */
3310
static void opt_pass(const char *pass_str)
3311 3312 3313 3314 3315 3316 3317 3318 3319
{
    int pass;
    pass = atoi(pass_str);
    if (pass != 1 && pass != 2) {
        fprintf(stderr, "pass number can be only 1 or 2\n");
        exit(1);
    }
    do_pass = pass;
}
3320

3321
#if defined(__MINGW32__) || defined(CONFIG_OS2)
kabi's avatar
kabi committed
3322
static int64_t getutime(void)
glantau's avatar
glantau committed
3323
{
3324
  return av_gettime();
glantau's avatar
glantau committed
3325
}
glantau's avatar
glantau committed
3326
#else
kabi's avatar
kabi committed
3327
static int64_t getutime(void)
glantau's avatar
glantau committed
3328
{
3329 3330 3331 3332
    struct rusage rusage;

    getrusage(RUSAGE_SELF, &rusage);
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
glantau's avatar
glantau committed
3333 3334
}
#endif
glantau's avatar
glantau committed
3335

3336
#if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3337
extern int ffm_nopts;
3338
#endif
3339

3340
static void show_formats(void)
glantau's avatar
merge  
glantau committed
3341
{
3342 3343
    AVInputFormat *ifmt;
    AVOutputFormat *ofmt;
3344
    AVImageFormat *image_fmt;
glantau's avatar
merge  
glantau committed
3345
    URLProtocol *up;
michael's avatar
michael committed
3346 3347 3348 3349 3350 3351 3352 3353 3354
    AVCodec *p, *p2;
    const char **pp, *last_name;

    printf("File formats:\n");
    last_name= "000";
    for(;;){
        int decode=0;
        int encode=0;
        const char *name=NULL;
3355
        const char *long_name=NULL;
michael's avatar
michael committed
3356 3357 3358 3359 3360

        for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
            if((name == NULL || strcmp(ofmt->name, name)<0) &&
                strcmp(ofmt->name, last_name)>0){
                name= ofmt->name;
3361
                long_name= ofmt->long_name;
michael's avatar
michael committed
3362 3363 3364 3365 3366 3367 3368
                encode=1;
            }
        }
        for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
            if((name == NULL || strcmp(ifmt->name, name)<0) &&
                strcmp(ifmt->name, last_name)>0){
                name= ifmt->name;
3369
                long_name= ifmt->long_name;
michael's avatar
michael committed
3370 3371 3372 3373 3374 3375 3376 3377
                encode=0;
            }
            if(name && strcmp(ifmt->name, name)==0)
                decode=1;
        }
        if(name==NULL)
            break;
        last_name= name;
3378

michael's avatar
michael committed
3379
        printf(
3380 3381 3382
            " %s%s %-15s %s\n",
            decode ? "D":" ",
            encode ? "E":" ",
3383 3384
            name,
            long_name ? long_name:" ");
3385 3386 3387
    }
    printf("\n");

3388
    printf("Image formats (filename extensions, if any, follow):\n");
3389
    for(image_fmt = first_image_format; image_fmt != NULL;
3390
        image_fmt = image_fmt->next) {
michael's avatar
michael committed
3391
        printf(
3392
            " %s%s %-6s %s\n",
michael's avatar
michael committed
3393 3394
            image_fmt->img_read  ? "D":" ",
            image_fmt->img_write ? "E":" ",
3395 3396
            image_fmt->name,
            image_fmt->extensions ? image_fmt->extensions:" ");
3397 3398 3399
    }
    printf("\n");

glantau's avatar
merge  
glantau committed
3400
    printf("Codecs:\n");
michael's avatar
michael committed
3401 3402 3403 3404 3405
    last_name= "000";
    for(;;){
        int decode=0;
        int encode=0;
        int cap=0;
3406
        const char *type_str;
michael's avatar
michael committed
3407 3408 3409 3410 3411 3412 3413 3414 3415 3416 3417 3418 3419 3420 3421 3422 3423

        p2=NULL;
        for(p = first_avcodec; p != NULL; p = p->next) {
            if((p2==NULL || strcmp(p->name, p2->name)<0) &&
                strcmp(p->name, last_name)>0){
                p2= p;
                decode= encode= cap=0;
            }
            if(p2 && strcmp(p->name, p2->name)==0){
                if(p->decode) decode=1;
                if(p->encode) encode=1;
                cap |= p->capabilities;
            }
        }
        if(p2==NULL)
            break;
        last_name= p2->name;
3424

3425 3426 3427 3428 3429 3430 3431 3432 3433 3434 3435 3436 3437 3438
        switch(p2->type) {
        case CODEC_TYPE_VIDEO:
            type_str = "V";
            break;
        case CODEC_TYPE_AUDIO:
            type_str = "A";
            break;
        case CODEC_TYPE_SUBTITLE:
            type_str = "S";
            break;
        default:
            type_str = "?";
            break;
        }
michael's avatar
michael committed
3439
        printf(
3440 3441 3442
            " %s%s%s%s%s%s %s",
            decode ? "D": (/*p2->decoder ? "d":*/" "),
            encode ? "E":" ",
3443
            type_str,
michael's avatar
michael committed
3444 3445 3446 3447 3448 3449 3450
            cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
            cap & CODEC_CAP_DR1 ? "D":" ",
            cap & CODEC_CAP_TRUNCATED ? "T":" ",
            p2->name);
       /* if(p2->decoder && decode==0)
            printf(" use %s for decoding", p2->decoder->name);*/
        printf("\n");
glantau's avatar
merge  
glantau committed
3451 3452 3453
    }
    printf("\n");

michael's avatar
michael committed
3454
    printf("Supported file protocols:\n");
glantau's avatar
merge  
glantau committed
3455 3456 3457
    for(up = first_protocol; up != NULL; up = up->next)
        printf(" %s:", up->name);
    printf("\n");
3458

michael's avatar
michael committed
3459 3460
    printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
    printf("Motion estimation methods:\n");
glantau's avatar
merge  
glantau committed
3461 3462 3463
    pp = motion_str;
    while (*pp) {
        printf(" %s", *pp);
3464
        if ((pp - motion_str + 1) == ME_ZERO)
glantau's avatar
merge  
glantau committed
3465
            printf("(fastest)");
3466
        else if ((pp - motion_str + 1) == ME_FULL)
glantau's avatar
merge  
glantau committed
3467
            printf("(slowest)");
3468
        else if ((pp - motion_str + 1) == ME_EPZS)
glantau's avatar
merge  
glantau committed
3469 3470 3471
            printf("(default)");
        pp++;
    }
michael's avatar
michael committed
3472 3473 3474 3475 3476 3477 3478
    printf("\n\n");
    printf(
"Note, the names of encoders and decoders dont always match, so there are\n"
"several cases where the above table shows encoder only or decoder only entries\n"
"even though both encoding and decoding are supported for example, the h263\n"
"decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
"worse\n");
glantau's avatar
merge  
glantau committed
3479 3480 3481
    exit(1);
}

mru's avatar
mru committed
3482
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3483 3484 3485 3486 3487 3488 3489 3490 3491 3492 3493 3494 3495 3496 3497 3498
{
    int i;
    const char *p = str;
    for(i = 0;; i++) {
        dest[i] = atoi(p);
        if(i == 63)
            break;
        p = strchr(p, ',');
        if(!p) {
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
            exit(1);
        }
        p++;
    }
}

mru's avatar
mru committed
3499
static void opt_inter_matrix(const char *arg)
3500 3501 3502 3503 3504
{
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
    parse_matrix_coeffs(inter_matrix, arg);
}

mru's avatar
mru committed
3505
static void opt_intra_matrix(const char *arg)
3506 3507 3508 3509 3510
{
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
    parse_matrix_coeffs(intra_matrix, arg);
}

3511 3512 3513
static void opt_target(const char *arg)
{
    int norm = -1;
3514
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3515 3516 3517 3518 3519 3520 3521

    if(!strncmp(arg, "pal-", 4)) {
        norm = 0;
        arg += 4;
    } else if(!strncmp(arg, "ntsc-", 5)) {
        norm = 1;
        arg += 5;
3522 3523 3524
    } else if(!strncmp(arg, "film-", 5)) {
        norm = 2;
        arg += 5;
3525 3526 3527 3528 3529 3530 3531 3532 3533 3534 3535 3536 3537 3538
    } else {
        int fr;
        /* Calculate FR via float to avoid int overflow */
        fr = (int)(frame_rate * 1000.0 / frame_rate_base);
        if(fr == 25000) {
            norm = 0;
        } else if((fr == 29970) || (fr == 23976)) {
            norm = 1;
        } else {
            /* Try to determine PAL/NTSC by peeking in the input files */
            if(nb_input_files) {
                int i, j;
                for(j = 0; j < nb_input_files; j++) {
                    for(i = 0; i < input_files[j]->nb_streams; i++) {
3539
                        AVCodecContext *c = input_files[j]->streams[i]->codec;
3540 3541
                        if(c->codec_type != CODEC_TYPE_VIDEO)
                            continue;
michael's avatar
michael committed
3542
                        fr = c->time_base.den * 1000 / c->time_base.num;
3543 3544 3545 3546 3547 3548 3549 3550 3551 3552 3553 3554 3555 3556
                        if(fr == 25000) {
                            norm = 0;
                            break;
                        } else if((fr == 29970) || (fr == 23976)) {
                            norm = 1;
                            break;
                        }
                    }
                    if(norm >= 0)
                        break;
                }
            }
        }
        if(verbose && norm >= 0)
3557
            fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3558 3559 3560
    }

    if(norm < 0) {
3561 3562
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3563 3564 3565 3566 3567 3568 3569 3570 3571 3572 3573
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
        exit(1);
    }

    if(!strcmp(arg, "vcd")) {

        opt_video_codec("mpeg1video");
        opt_audio_codec("mp2");
        opt_format("vcd");

        opt_frame_size(norm ? "352x240" : "352x288");
3574
        opt_frame_rate(frame_rates[norm]);
3575
        opt_default("gop", norm ? "18" : "15");
3576

3577
        opt_default("b", "1150000");
3578 3579
        opt_default("maxrate", "1150000");
        opt_default("minrate", "1150000");
3580
        opt_default("bufsize", "327680"); // 40*1024*8;
3581 3582 3583

        audio_bit_rate = 224000;
        audio_sample_rate = 44100;
3584

3585
        opt_default("packetsize", "2324");
3586
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3587

3588 3589 3590 3591 3592 3593
        /* We have to offset the PTS, so that it is consistent with the SCR.
           SCR starts at 36000, but the first two packs contain only padding
           and the first pack from the other stream, respectively, may also have
           been written before.
           So the real data starts at SCR 36000+3*1200. */
        mux_preload= (36000+3*1200) / 90000.0; //0.44
3594 3595 3596 3597
    } else if(!strcmp(arg, "svcd")) {

        opt_video_codec("mpeg2video");
        opt_audio_codec("mp2");
3598
        opt_format("svcd");
3599 3600

        opt_frame_size(norm ? "480x480" : "480x576");
3601
        opt_frame_rate(frame_rates[norm]);
3602
        opt_default("gop", norm ? "18" : "15");
3603

3604
        opt_default("b", "2040000");
3605 3606
        opt_default("maxrate", "2516000");
        opt_default("minrate", "0"); //1145000;
3607
        opt_default("bufsize", "1835008"); //224*1024*8;
3608 3609
        opt_default("flags", "+SCAN_OFFSET");

3610 3611 3612 3613

        audio_bit_rate = 224000;
        audio_sample_rate = 44100;

3614
        opt_default("packetsize", "2324");
3615

3616 3617 3618 3619
    } else if(!strcmp(arg, "dvd")) {

        opt_video_codec("mpeg2video");
        opt_audio_codec("ac3");
3620
        opt_format("dvd");
3621 3622

        opt_frame_size(norm ? "720x480" : "720x576");
3623
        opt_frame_rate(frame_rates[norm]);
3624
        opt_default("gop", norm ? "18" : "15");
3625

3626
        opt_default("b", "6000000");
3627 3628
        opt_default("maxrate", "9000000");
        opt_default("minrate", "0"); //1500000;
3629
        opt_default("bufsize", "1835008"); //224*1024*8;
3630

3631
        opt_default("packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3632
        opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3633

3634 3635 3636
        audio_bit_rate = 448000;
        audio_sample_rate = 48000;

romansh's avatar
 
romansh committed
3637
    } else if(!strncmp(arg, "dv", 2)) {
3638 3639 3640 3641

        opt_format("dv");

        opt_frame_size(norm ? "720x480" : "720x576");
romansh's avatar
 
romansh committed
3642 3643
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
                                             (norm ? "yuv411p" : "yuv420p"));
3644 3645 3646 3647 3648
        opt_frame_rate(frame_rates[norm]);

        audio_sample_rate = 48000;
        audio_channels = 2;

3649 3650 3651 3652 3653 3654
    } else {
        fprintf(stderr, "Unknown target: %s\n", arg);
        exit(1);
    }
}

3655 3656 3657 3658 3659 3660 3661 3662 3663 3664 3665 3666 3667 3668 3669 3670 3671 3672 3673 3674 3675 3676 3677 3678 3679 3680 3681 3682 3683 3684 3685 3686 3687 3688 3689
static void opt_video_bsf(const char *arg)
{
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
    AVBitStreamFilterContext **bsfp;

    if(!bsfc){
        fprintf(stderr, "Unkown bitstream filter %s\n", arg);
        exit(1);
    }

    bsfp= &video_bitstream_filters;
    while(*bsfp)
        bsfp= &(*bsfp)->next;

    *bsfp= bsfc;
}

//FIXME avoid audio - video code duplication
static void opt_audio_bsf(const char *arg)
{
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
    AVBitStreamFilterContext **bsfp;

    if(!bsfc){
        fprintf(stderr, "Unkown bitstream filter %s\n", arg);
        exit(1);
    }

    bsfp= &audio_bitstream_filters;
    while(*bsfp)
        bsfp= &(*bsfp)->next;

    *bsfp= bsfc;
}

michael's avatar
michael committed
3690 3691
static void show_version(void)
{
al's avatar
al committed
3692
    /* TODO: add function interface to avutil and avformat */
3693
    fprintf(stderr, "ffmpeg      " FFMPEG_VERSION "\n"
al's avatar
al committed
3694
           "libavutil   %d\n"
michael's avatar
michael committed
3695
           "libavcodec  %d\n"
3696
           "libavformat %d\n",
al's avatar
al committed
3697
           LIBAVUTIL_BUILD, avcodec_build(), LIBAVFORMAT_BUILD);
michael's avatar
michael committed
3698 3699 3700
    exit(1);
}

michael's avatar
michael committed
3701 3702
static int opt_default(const char *opt, const char *arg){
    AVOption *o= av_set_string(avctx_opts, opt, arg);
3703 3704
    if(!o)
        o = av_set_string(avformat_opts, opt, arg);
michael's avatar
michael committed
3705 3706
    if(!o)
        return -1;
3707

3708
//    av_log(NULL, AV_LOG_ERROR, "%s:%s: %f 0x%0X\n", opt, arg, av_get_double(avctx_opts, opt, NULL), (int)av_get_int(avctx_opts, opt, NULL));
michael's avatar
michael committed
3709 3710 3711

    //FIXME we should always use avctx_opts, ... for storing options so there wont be any need to keep track of whats set over this
    opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
3712
    opt_names[opt_name_count++]= o->name;
3713

3714
#if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3715 3716 3717
    /* disable generate of real time pts in ffm (need to be supressed anyway) */
    if(avctx_opts->flags & CODEC_FLAG_BITEXACT)
        ffm_nopts = 1;
3718
#endif
3719 3720 3721

    if(avctx_opts->debug)
        av_log_set_level(AV_LOG_DEBUG);
michael's avatar
michael committed
3722 3723 3724
    return 0;
}

glantau's avatar
merge  
glantau committed
3725
const OptionDef options[] = {
3726 3727
    /* main options */
    { "L", 0, {(void*)show_license}, "show license" },
glantau's avatar
glantau committed
3728
    { "h", 0, {(void*)show_help}, "show help" },
michael's avatar
michael committed
3729
    { "version", 0, {(void*)show_version}, "show version" },
glantau's avatar
glantau committed
3730 3731
    { "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
    { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3732
    { "img", HAS_ARG, {(void*)opt_image_format}, "force image format", "img_fmt" },
glantau's avatar
glantau committed
3733 3734
    { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
    { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3735
    { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3736
    { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
glantau's avatar
glantau committed
3737
    { "t", HAS_ARG, {(void*)opt_recording_time}, "set the recording time", "duration" },
3738
    { "fs", HAS_ARG | OPT_INT, {(void*)&limit_filesize}, "set the limit file size", "limit_size" }, //
3739
    { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
michael's avatar
michael committed
3740
    { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
glantau's avatar
glantau committed
3741
    { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
romansh's avatar
 
romansh committed
3742
    { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
glantau's avatar
glantau committed
3743 3744 3745
    { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
    { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
    { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3746
    { "album", HAS_ARG | OPT_STRING, {(void*)&str_album}, "set the album", "string" },
3747
    { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
glantau's avatar
glantau committed
3748
      "add timings for benchmarking" },
3749
    { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3750
      "dump each input packet" },
3751
    { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3752
      "when dumping packets, also dump the payload" },
bellard's avatar
bellard committed
3753
    { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3754
    { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3755
    { "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)", "" },
3756
    { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
romansh's avatar
 
romansh committed
3757
    { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3758
    { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
michael's avatar
michael committed
3759 3760
    { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
    { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3761
    { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3762
    { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
3763
    { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3764
    { "dts_delta_threshold", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "" },
3765 3766

    /* video options */
michael's avatar
michael committed
3767 3768 3769
    { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
    { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3770 3771 3772 3773 3774 3775 3776 3777
    { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
    { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
    { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
    { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format", "format" },
    { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
    { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
    { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
    { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3778 3779 3780 3781 3782
    { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
    { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
    { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
    { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
    { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3783 3784
    { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
    { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
mru's avatar
mru committed
3785
    { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
diego's avatar
diego committed
3786 3787
    { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
    { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantizer scale (VBR)", "q" },
3788
    { "rc_eq", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_eq}, "set rate control equation", "equation" },
bellard's avatar
bellard committed
3789
    { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3790
    { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3791
    { "me", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_motion_estimation}, "set motion estimation method",
3792
      "method" },
3793
    { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "" },
3794
    { "ps", HAS_ARG | OPT_EXPERT, {(void*)opt_packet_size}, "set packet size in bits", "size" },
3795
    { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
3796
    { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3797 3798 3799
      "use same video quality as source (implies VBR)" },
    { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
    { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3800
    { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3801 3802
      "deinterlace pictures" },
    { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3803
    { "vstats", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_vstats}, "dump video coding statistics to file" },
3804
    { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3805 3806
    { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
    { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
michael's avatar
michael committed
3807
    { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3808
    { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
michael's avatar
michael committed
3809
    { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3810
    { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3811
    { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3812 3813 3814

    /* audio options */
    { "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_bitrate}, "set audio bitrate (in kbit/s)", "bitrate", },
3815
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3816 3817 3818 3819
    { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
    { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
michael's avatar
michael committed
3820
    { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3821
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3822 3823
    { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3824

3825 3826 3827 3828
    /* subtitle options */
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
    { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3829

3830 3831 3832 3833 3834
    /* grab options */
    { "vd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_device}, "set video grab device", "device" },
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
    { "ad", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_GRAB, {(void*)opt_audio_device}, "set audio device", "device" },
romansh's avatar
 
romansh committed
3835

3836
    /* G.2 grab options */
romansh's avatar
 
romansh committed
3837 3838
    { "grab", HAS_ARG | OPT_EXPERT | OPT_GRAB, {(void*)opt_grab}, "request grabbing using", "format" },
    { "gd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_grab_device}, "set grab device", "device" },
3839 3840

    /* muxer options */
3841 3842
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3843 3844 3845 3846

    { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_audio_bsf}, "", "bitstream filter" },
    { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_video_bsf}, "", "bitstream filter" },

michael's avatar
michael committed
3847
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
glantau's avatar
merge  
glantau committed
3848 3849 3850
    { NULL, },
};

3851 3852
static void show_banner(void)
{
3853
    fprintf(stderr, "FFmpeg version " FFMPEG_VERSION ", Copyright (c) 2000-2006 Fabrice Bellard, et al.\n");
alex's avatar
alex committed
3854
    fprintf(stderr, "  configuration: " FFMPEG_CONFIGURATION "\n");
al's avatar
al committed
3855
    fprintf(stderr, "  libavutil version: " AV_STRINGIFY(LIBAVUTIL_VERSION) "\n");
alex's avatar
alex committed
3856 3857
    fprintf(stderr, "  libavcodec version: " AV_STRINGIFY(LIBAVCODEC_VERSION) "\n");
    fprintf(stderr, "  libavformat version: " AV_STRINGIFY(LIBAVFORMAT_VERSION) "\n");
3858
    fprintf(stderr, "  built on " __DATE__ " " __TIME__);
3859
#ifdef __GNUC__
alex's avatar
alex committed
3860
    fprintf(stderr, ", gcc: " __VERSION__ "\n");
3861
#else
3862
    fprintf(stderr, ", using a non-gcc compiler\n");
3863
#endif
3864 3865 3866 3867 3868
}

static void show_license(void)
{
    show_banner();
3869
#ifdef CONFIG_GPL
3870
    printf(
3871
    "FFmpeg is free software; you can redistribute it and/or modify\n"
3872 3873 3874 3875
    "it under the terms of the GNU General Public License as published by\n"
    "the Free Software Foundation; either version 2 of the License, or\n"
    "(at your option) any later version.\n"
    "\n"
3876
    "FFmpeg is distributed in the hope that it will be useful,\n"
3877 3878 3879 3880 3881
    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
    "GNU General Public License for more details.\n"
    "\n"
    "You should have received a copy of the GNU General Public License\n"
3882
    "along with FFmpeg; if not, write to the Free Software\n"
3883
    "Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA\n"
3884
    );
3885
#else
3886
    printf(
3887
    "FFmpeg is free software; you can redistribute it and/or\n"
3888 3889
    "modify it under the terms of the GNU Lesser General Public\n"
    "License as published by the Free Software Foundation; either\n"
3890
    "version 2.1 of the License, or (at your option) any later version.\n"
3891
    "\n"
3892
    "FFmpeg is distributed in the hope that it will be useful,\n"
3893 3894 3895 3896 3897
    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n"
    "Lesser General Public License for more details.\n"
    "\n"
    "You should have received a copy of the GNU Lesser General Public\n"
3898
    "License along with FFmpeg; if not, write to the Free Software\n"
3899
    "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n"
3900
    );
3901
#endif
3902 3903 3904 3905
    exit(1);
}

static void show_help(void)
bellard's avatar
bellard committed
3906
{
3907
    show_banner();
michael's avatar
michael committed
3908
    printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
bellard's avatar
bellard committed
3909 3910
           "Hyper fast Audio and Video encoder\n");
    printf("\n");
3911 3912 3913
    show_help_options(options, "Main options:\n",
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
    show_help_options(options, "\nVideo options:\n",
3914
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3915 3916
                      OPT_VIDEO);
    show_help_options(options, "\nAdvanced Video options:\n",
3917
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3918 3919
                      OPT_VIDEO | OPT_EXPERT);
    show_help_options(options, "\nAudio options:\n",
3920
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3921 3922
                      OPT_AUDIO);
    show_help_options(options, "\nAdvanced Audio options:\n",
3923
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3924
                      OPT_AUDIO | OPT_EXPERT);
3925
    show_help_options(options, "\nSubtitle options:\n",
3926
                      OPT_SUBTITLE | OPT_GRAB,
3927
                      OPT_SUBTITLE);
3928
    show_help_options(options, "\nAudio/Video grab options:\n",
3929
                      OPT_GRAB,
3930 3931
                      OPT_GRAB);
    show_help_options(options, "\nAdvanced options:\n",
3932
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3933
                      OPT_EXPERT);
michael's avatar
michael committed
3934
    av_opt_show(avctx_opts, NULL);
3935
    av_opt_show(avformat_opts, NULL);
3936

bellard's avatar
bellard committed
3937 3938 3939 3940 3941 3942 3943 3944
    exit(1);
}

void parse_arg_file(const char *filename)
{
    opt_output_file(filename);
}

glantau's avatar
merge  
glantau committed
3945 3946
int main(int argc, char **argv)
{
bellard's avatar
bellard committed
3947
    int i;
kabi's avatar
kabi committed
3948
    int64_t ti;
3949

3950
    av_register_all();
3951

michael's avatar
michael committed
3952
    avctx_opts= avcodec_alloc_context();
3953
    avformat_opts = av_alloc_format_context();
glantau's avatar
merge  
glantau committed
3954 3955 3956

    if (argc <= 1)
        show_help();
3957 3958
    else
        show_banner();
3959

3960
    /* parse options */
bellard's avatar
bellard committed
3961
    parse_options(argc, argv, options);
glantau's avatar
merge  
glantau committed
3962

bellard's avatar
bellard committed
3963 3964 3965 3966 3967
    /* file converter / grab */
    if (nb_output_files <= 0) {
        fprintf(stderr, "Must supply at least one output file\n");
        exit(1);
    }
3968

bellard's avatar
bellard committed
3969
    if (nb_input_files == 0) {
3970
        input_sync = 1;
bellard's avatar
bellard committed
3971
        prepare_grab();
3972 3973 3974
    }

    ti = getutime();
3975
    av_encode(output_files, nb_output_files, input_files, nb_input_files,
3976 3977 3978 3979
              stream_maps, nb_stream_maps);
    ti = getutime() - ti;
    if (do_benchmark) {
        printf("bench: utime=%0.3fs\n", ti / 1000000.0);
glantau's avatar
merge  
glantau committed
3980 3981 3982 3983
    }

    /* close files */
    for(i=0;i<nb_output_files;i++) {
kabi's avatar
kabi committed
3984 3985
        /* maybe av_close_output_file ??? */
        AVFormatContext *s = output_files[i];
3986
        int j;
kabi's avatar
kabi committed
3987
        if (!(s->oformat->flags & AVFMT_NOFILE))
3988 3989 3990
            url_fclose(&s->pb);
        for(j=0;j<s->nb_streams;j++)
            av_free(s->streams[j]);
kabi's avatar
kabi committed
3991
        av_free(s);
glantau's avatar
merge  
glantau committed
3992
    }
3993 3994
    for(i=0;i<nb_input_files;i++)
        av_close_input_file(input_files[i]);
glantau's avatar
merge  
glantau committed
3995

3996
    av_free_static();
3997

3998 3999 4000 4001
    if(intra_matrix)
        av_free(intra_matrix);
    if(inter_matrix)
        av_free(inter_matrix);
4002

4003
#ifdef POWERPC_PERFORMANCE_REPORT
4004 4005
    extern void powerpc_display_perf_report(void);
    powerpc_display_perf_report();
4006
#endif /* POWERPC_PERFORMANCE_REPORT */
4007

4008
#ifndef __MINGW32__
4009 4010 4011 4012 4013 4014 4015 4016
    if (received_sigterm) {
        fprintf(stderr,
            "Received signal %d: terminating.\n",
            (int) received_sigterm);
        exit (255);
    }
#endif
    exit(0); /* not all OS-es handle main() return value */
glantau's avatar
merge  
glantau committed
4017 4018
    return 0;
}