ffmpeg.c 134 KB
Newer Older
Fabrice Bellard's avatar
merge  
Fabrice Bellard committed
1 2
/*
 * FFmpeg main 
Fabrice Bellard's avatar
Fabrice Bellard committed
3
 * Copyright (c) 2000-2003 Fabrice Bellard
Fabrice Bellard's avatar
merge  
Fabrice Bellard committed
4
 *
5 6 7 8
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
Fabrice Bellard's avatar
merge  
Fabrice Bellard committed
9
 *
10
 * This library is distributed in the hope that it will be useful,
Fabrice Bellard's avatar
merge  
Fabrice Bellard committed
11
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 13
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
Fabrice Bellard's avatar
merge  
Fabrice Bellard committed
14
 *
15 16 17
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
Fabrice Bellard's avatar
merge  
Fabrice Bellard committed
18
 */
19
#define HAVE_AV_CONFIG_H
20
#include <limits.h>
21
#include "avformat.h"
22
#include "framehook.h"
23
#include "dsputil.h"
24

Fabrice Bellard's avatar
Fabrice Bellard committed
25
#ifndef CONFIG_WIN32
Fabrice Bellard's avatar
merge  
Fabrice Bellard committed
26 27 28 29 30
#include <unistd.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <sys/time.h>
#include <termios.h>
Fabrice Bellard's avatar
Fabrice Bellard committed
31
#include <sys/resource.h>
32
#include <signal.h>
Fabrice Bellard's avatar
Fabrice Bellard committed
33
#endif
34 35 36 37 38
#ifdef CONFIG_OS2
#include <sys/types.h>
#include <sys/select.h>
#include <stdlib.h>
#endif
Michael Niedermayer's avatar
10000l  
Michael Niedermayer committed
39
#undef time //needed because HAVE_AV_CONFIG_H is defined on top
40
#include <time.h>
Fabrice Bellard's avatar
merge  
Fabrice Bellard committed
41

Fabrice Bellard's avatar
Fabrice Bellard committed
42 43
#include "cmdutils.h"

44 45 46
#if !defined(INFINITY) && defined(HUGE_VAL)
#define INFINITY HUGE_VAL
#endif
Fabrice Bellard's avatar
merge  
Fabrice Bellard committed
47 48 49 50 51 52 53 54 55

/* select an input stream for an output stream */
typedef struct AVStreamMap {
    int file_index;
    int stream_index;
} AVStreamMap;

extern const OptionDef options[];

56 57
static void show_help(void);
static void show_license(void);
Fabrice Bellard's avatar
merge  
Fabrice Bellard committed
58 59 60 61

#define MAX_FILES 20

static AVFormatContext *input_files[MAX_FILES];
62
static int64_t input_files_ts_offset[MAX_FILES];
Fabrice Bellard's avatar
merge  
Fabrice Bellard committed
63 64 65 66 67 68 69 70
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;

71 72
static AVInputFormat *file_iformat;
static AVOutputFormat *file_oformat;
73
static AVImageFormat *image_format;
Fabrice Bellard's avatar
merge  
Fabrice Bellard committed
74 75
static int frame_width  = 160;
static int frame_height = 128;
76
static float frame_aspect_ratio = 0;
77
static enum PixelFormat frame_pix_fmt = PIX_FMT_YUV420P;
78 79 80 81 82
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 */
83 84 85 86
static int frame_topBand  = 0;
static int frame_bottomBand = 0;
static int frame_leftBand  = 0;
static int frame_rightBand = 0;
87 88
static int frame_rate = 25;
static int frame_rate_base = 1;
Michael Niedermayer's avatar
Michael Niedermayer committed
89 90
static int video_bit_rate = 200*1000;
static int video_bit_rate_tolerance = 4000*1000;
91
static float video_qscale = 0;
Michael Niedermayer's avatar
Michael Niedermayer committed
92 93
static int video_qmin = 2;
static int video_qmax = 31;
Michael Niedermayer's avatar
Michael Niedermayer committed
94 95
static int video_lmin = 2*FF_QP2LAMBDA;
static int video_lmax = 31*FF_QP2LAMBDA;
Michael Niedermayer's avatar
Michael Niedermayer committed
96 97
static int video_mb_qmin = 2;
static int video_mb_qmax = 31;
98 99 100
static int video_qdiff = 3;
static float video_qblur = 0.5;
static float video_qcomp = 0.5;
101 102
static uint16_t *intra_matrix = NULL;
static uint16_t *inter_matrix = NULL;
103
#if 0 //experimental, (can be removed)
Michael Niedermayer's avatar
Michael Niedermayer committed
104 105 106
static float video_rc_qsquish=1.0;
static float video_rc_qmod_amp=0;
static int video_rc_qmod_freq=0;
107
#endif
Michael Niedermayer's avatar
Michael Niedermayer committed
108 109 110 111 112 113 114 115 116
static char *video_rc_override_string=NULL;
static char *video_rc_eq="tex^qComp";
static int video_rc_buffer_size=0;
static float video_rc_buffer_aggressivity=1.0;
static int video_rc_max_rate=0;
static int video_rc_min_rate=0;
static float video_rc_initial_cplx=0;
static float video_b_qfactor = 1.25;
static float video_b_qoffset = 1.25;
117
static float video_i_qfactor = -0.8;
Michael Niedermayer's avatar
Michael Niedermayer committed
118
static float video_i_qoffset = 0.0;
119 120
static int video_intra_quant_bias= FF_DEFAULT_QUANT_BIAS;
static int video_inter_quant_bias= FF_DEFAULT_QUANT_BIAS;
121
static int me_method = ME_EPZS;
Fabrice Bellard's avatar
merge  
Fabrice Bellard committed
122 123 124
static int video_disable = 0;
static int video_codec_id = CODEC_ID_NONE;
static int same_quality = 0;
125
static int b_frames = 0;
126
static int mb_decision = FF_MB_DECISION_SIMPLE;
127
static int ildct_cmp = FF_CMP_VSAD;
128 129 130
static int mb_cmp = FF_CMP_SAD;
static int sub_cmp = FF_CMP_SAD;
static int cmp = FF_CMP_SAD;
131 132 133 134 135 136 137
static int pre_cmp = FF_CMP_SAD;
static int pre_me = 0;
static float lumi_mask = 0;
static float dark_mask = 0;
static float scplx_mask = 0;
static float tcplx_mask = 0;
static float p_mask = 0;
138
static int use_4mv = 0;
139
static int use_obmc = 0;
Michael Niedermayer's avatar
Michael Niedermayer committed
140
static int use_loop = 0;
141
static int use_aic = 0;
142
static int use_aiv = 0;
143
static int use_umv = 0;
144
static int use_ss = 0;
145
static int use_alt_scan = 0;
146
static int use_trell = 0;
Michael Niedermayer's avatar
Michael Niedermayer committed
147
static int use_scan_offset = 0;
Michael Niedermayer's avatar
Michael Niedermayer committed
148
static int use_qpel = 0;
Michael Niedermayer's avatar
-qprd  
Michael Niedermayer committed
149
static int use_qprd = 0;
Michael Niedermayer's avatar
-cbp  
Michael Niedermayer committed
150
static int use_cbprd = 0;
Michael Niedermayer's avatar
Michael Niedermayer committed
151
static int qns = 0;
152
static int closed_gop = 0;
153
static int do_deinterlace = 0;
154 155
static int do_interlace_dct = 0;
static int do_interlace_me = 0;
156 157 158
static int workaround_bugs = FF_BUG_AUTODETECT;
static int error_resilience = 2;
static int error_concealment = 3;
159
static int dct_algo = 0;
160
static int idct_algo = 0;
161 162
static int use_part = 0;
static int packet_size = 0;
163
static int error_rate = 0;
Michael Niedermayer's avatar
Michael Niedermayer committed
164
static int strict = 0;
165 166
static int top_field_first = -1;
static int noise_reduction = 0;
167
static int sc_threshold = 0;
Michael Niedermayer's avatar
Michael Niedermayer committed
168
static int debug = 0;
169
static int debug_mv = 0;
170
static int me_threshold = 0;
171
static int mb_threshold = 0;
Michael Niedermayer's avatar
-cbp  
Michael Niedermayer committed
172
static int intra_dc_precision = 8;
173 174 175
static int coder = 0;
static int context = 0;
static int predictor = 0;
Fabrice Bellard's avatar
Fabrice Bellard committed
176
extern int loop_input; /* currently a hack */
Fabrice Bellard's avatar
merge  
Fabrice Bellard committed
177 178 179 180 181 182 183 184 185

static int gop_size = 12;
static int intra_only = 0;
static int audio_sample_rate = 44100;
static int audio_bit_rate = 64000;
static int audio_disable = 0;
static int audio_channels = 1;
static int audio_codec_id = CODEC_ID_NONE;

186
static int64_t recording_time = 0;
187
static int64_t start_time = 0;
188
static int64_t rec_timestamp = 0;
189
static int64_t input_ts_offset = 0;
Fabrice Bellard's avatar
merge  
Fabrice Bellard committed
190 191 192 193 194
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;
Fabrice Bellard's avatar
Fabrice Bellard committed
195
static int do_benchmark = 0;
196
static int do_hex_dump = 0;
197
static int do_pkt_dump = 0;
198
static int do_psnr = 0;
199
static int do_vstats = 0;
200
static int do_pass = 0;
201
static int bitexact = 0;
202
static char *pass_logfilename = NULL;
203 204
static int audio_stream_copy = 0;
static int video_stream_copy = 0;
205 206
static int video_sync_method= 1;
static int audio_sync_method= 0;
207
static int copy_ts= 0;
208

209 210
static int rate_emu = 0;

211
static char *video_grab_format = "video4linux";
212
static char *video_device = NULL;
213
static int  video_channel = 0;
214
static char *video_standard = "ntsc";
215

216
static char *audio_grab_format = "audio_device";
217
static char *audio_device = NULL;
218

219
static int using_stdin = 0;
220
static int using_vhook = 0;
221
static int verbose = 1;
222
static int thread_count= 1;
223
static int q_pressed = 0;
224
static int me_range = 0;
225 226 227
static int64_t video_size = 0;
static int64_t audio_size = 0;
static int64_t extra_size = 0;
228 229
static int nb_frames_dup = 0;
static int nb_frames_drop = 0;
230
static int input_sync;
231

232
#define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
Fabrice Bellard's avatar
merge  
Fabrice Bellard committed
233 234 235 236 237 238

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 */
239 240 241 242
    int encoding_needed;     /* true if encoding needed for this stream */
    int frame_number;
    /* input pts and corresponding output pts
       for A/V sync */
243 244
    double sync_ipts;        /* dts from the AVPacket of the demuxer in second units */
    int64_t sync_opts;       /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
Fabrice Bellard's avatar
merge  
Fabrice Bellard committed
245
    /* video only */
246
    int video_resample;      /* video_resample and video_crop are mutually exclusive */
247
    AVFrame pict_tmp;      /* temporary image for resampling */
Fabrice Bellard's avatar
merge  
Fabrice Bellard committed
248
    ImgReSampleContext *img_resample_ctx; /* for image resampling */
249 250 251 252

    int video_crop;          /* video_resample and video_crop are mutually exclusive */
    int topBand;             /* cropping area sizes */
    int leftBand;
Fabrice Bellard's avatar
merge  
Fabrice Bellard committed
253
    
254 255 256 257 258 259
    int video_pad;           /* video_resample and video_pad are mutually exclusive */
    int padtop;              /* padding area sizes */
    int padbottom;
    int padleft;
    int padright;
    
Fabrice Bellard's avatar
merge  
Fabrice Bellard committed
260 261 262 263
    /* audio only */
    int audio_resample;
    ReSampleContext *resample; /* for audio resampling */
    FifoBuffer fifo;     /* for compression: one audio fifo per codec */
264
    FILE *logfile;
Fabrice Bellard's avatar
merge  
Fabrice Bellard 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' */
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 */
279
    int64_t       pts;       /* current pts */
280
    int is_start;            /* is 1 at the start and after a discontinuity */
Fabrice Bellard's avatar
merge  
Fabrice Bellard 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 */
Fabrice Bellard's avatar
merge  
Fabrice Bellard committed
290 291
} AVInputFile;

Fabrice Bellard's avatar
Fabrice Bellard committed
292 293
#ifndef CONFIG_WIN32

Fabrice Bellard's avatar
merge  
Fabrice Bellard 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();
}

Fabrice Bellard's avatar
merge  
Fabrice Bellard committed
311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328
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;
    
    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
    */
Fabrice Bellard's avatar
merge  
Fabrice Bellard committed
335
    atexit(term_exit);
336 337 338
#ifdef CONFIG_BEOS_NETSERVER
    fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
#endif
Fabrice Bellard's avatar
merge  
Fabrice Bellard committed
339 340 341 342 343
}

/* read a key without blocking */
static int read_key(void)
{
344
    int n = 1;
Fabrice Bellard's avatar
merge  
Fabrice Bellard committed
345
    unsigned char ch;
346 347
#ifndef CONFIG_BEOS_NETSERVER
    struct timeval tv;
Fabrice Bellard's avatar
merge  
Fabrice Bellard 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
Fabrice Bellard's avatar
merge  
Fabrice Bellard committed
356
    if (n > 0) {
357 358
        n = read(0, &ch, 1);
        if (n == 1)
Fabrice Bellard's avatar
merge  
Fabrice Bellard committed
359
            return ch;
360 361

        return n;
Fabrice Bellard's avatar
merge  
Fabrice Bellard 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
Fabrice Bellard's avatar
merge  
Fabrice Bellard committed
372

373 374
static volatile int received_sigterm = 0;

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

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

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

389
#endif
Fabrice Bellard's avatar
Fabrice Bellard committed
390

391
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
Fabrice Bellard's avatar
merge  
Fabrice Bellard committed
392
{
393
    int i, err;
Fabrice Bellard's avatar
merge  
Fabrice Bellard 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;
Fabrice Bellard's avatar
merge  
Fabrice Bellard committed
399 400 401 402
    /* copy stream format */
    s->nb_streams = ic->nb_streams;
    for(i=0;i<ic->nb_streams;i++) {
        AVStream *st;
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
403

404
        st = av_mallocz(sizeof(AVStream));
Fabrice Bellard's avatar
merge  
Fabrice Bellard committed
405 406 407 408 409 410 411 412
        memcpy(st, ic->streams[i], sizeof(AVStream));
        s->streams[i] = st;
    }

    av_close_input_file(ic);
    return 0;
}

413
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
Fabrice Bellard's avatar
merge  
Fabrice Bellard committed
414 415 416 417 418 419

static void do_audio_out(AVFormatContext *s, 
                         AVOutputStream *ost, 
                         AVInputStream *ist,
                         unsigned char *buf, int size)
{
420
    uint8_t *buftmp;
421 422
    static uint8_t *audio_buf = NULL;
    static uint8_t *audio_out = NULL;
Michael Niedermayer's avatar
10l  
Michael Niedermayer committed
423
    const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
424

Fabrice Bellard's avatar
merge  
Fabrice Bellard committed
425
    int size_out, frame_bytes, ret;
426
    AVCodecContext *enc= &ost->st->codec;
Fabrice Bellard's avatar
merge  
Fabrice Bellard committed
427

428 429 430 431
    /* SC: dynamic allocation of buffers */
    if (!audio_buf)
        audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
    if (!audio_out)
Michael Niedermayer's avatar
10l  
Michael Niedermayer committed
432
        audio_out = av_malloc(audio_out_size);
433 434 435
    if (!audio_buf || !audio_out)
        return;               /* Should signal an error ! */

436 437 438
    if(audio_sync_method){
        double delta = ost->sync_ipts * enc->sample_rate - ost->sync_opts 
                - fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec.channels * 2);
439 440 441
        double idelta= delta*ist->st->codec.sample_rate / enc->sample_rate;
        int byte_delta= ((int)idelta)*2*ist->st->codec.channels;

442 443
        //FIXME resample delay
        if(fabs(delta) > 50){
444 445
            if(ist->is_start){
                if(byte_delta < 0){
446
                    byte_delta= FFMAX(byte_delta, -size);
447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478
                    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);
                fprintf(stderr, "drift:%f len:%d opts:%lld ipts:%lld fifo:%d\n", delta, -1, ost->sync_opts, (int64_t)(ost->sync_ipts * enc->sample_rate), fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec.channels * 2));
                av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
            }
        } 
479 480 481
    }else
        ost->sync_opts= lrintf(ost->sync_ipts * enc->sample_rate)
                        - fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec.channels * 2); //FIXME wrong
Fabrice Bellard's avatar
merge  
Fabrice Bellard committed
482 483 484 485 486 487 488 489 490 491 492 493 494

    if (ost->audio_resample) {
        buftmp = audio_buf;
        size_out = audio_resample(ost->resample, 
                                  (short *)buftmp, (short *)buf,
                                  size / (ist->st->codec.channels * 2));
        size_out = size_out * enc->channels * 2;
    } else {
        buftmp = buf;
        size_out = size;
    }

    /* now encode as many frames as possible */
495
    if (enc->frame_size > 1) {
Fabrice Bellard's avatar
merge  
Fabrice Bellard committed
496 497 498 499 500 501 502 503
        /* output resampled raw samples */
        fifo_write(&ost->fifo, buftmp, size_out, 
                   &ost->fifo.wptr);

        frame_bytes = enc->frame_size * 2 * enc->channels;
        
        while (fifo_read(&ost->fifo, audio_buf, frame_bytes, 
                     &ost->fifo.rptr) == 0) {
504 505 506
            AVPacket pkt;
            av_init_packet(&pkt);

Michael Niedermayer's avatar
10l  
Michael Niedermayer committed
507
            ret = avcodec_encode_audio(enc, audio_out, audio_out_size, 
508
                                       (short *)audio_buf);
509
            audio_size += ret;
510 511 512 513 514 515
            pkt.stream_index= ost->index;
            pkt.data= audio_out;
            pkt.size= ret;
            if(enc->coded_frame)
                pkt.pts= enc->coded_frame->pts;
            pkt.flags |= PKT_FLAG_KEY;
516
            av_interleaved_write_frame(s, &pkt);
517 518
            
            ost->sync_opts += enc->frame_size;
Fabrice Bellard's avatar
merge  
Fabrice Bellard committed
519 520
        }
    } else {
521 522
        AVPacket pkt;
        av_init_packet(&pkt);
523

524
        ost->sync_opts += size_out / (2 * enc->channels);
525

526 527 528 529 530 531 532 533 534 535 536 537 538
        /* output a pcm frame */
        /* XXX: change encoding codec API to avoid this ? */
        switch(enc->codec->id) {
        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;
        }
        ret = avcodec_encode_audio(enc, audio_out, size_out, 
539
				   (short *)buftmp);
540
        audio_size += ret;
541 542 543 544 545 546
        pkt.stream_index= ost->index;
        pkt.data= audio_out;
        pkt.size= ret;
        if(enc->coded_frame)
            pkt.pts= enc->coded_frame->pts;
        pkt.flags |= PKT_FLAG_KEY;
547
        av_interleaved_write_frame(s, &pkt);
Fabrice Bellard's avatar
merge  
Fabrice Bellard committed
548 549 550
    }
}

551 552 553 554 555
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
{
    AVCodecContext *dec;
    AVPicture *picture2;
    AVPicture picture_tmp;
556
    uint8_t *buf = 0;
557 558 559 560

    dec = &ist->st->codec;

    /* deinterlace : must be done before any resize */
561
    if (do_deinterlace || using_vhook) {
562 563 564 565 566 567 568 569 570 571 572
        int size;

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

Michael Niedermayer's avatar
10l  
Michael Niedermayer committed
573 574 575 576 577 578 579 580 581
        if (do_deinterlace){
            if(avpicture_deinterlace(picture2, picture, 
                                     dec->pix_fmt, dec->width, dec->height) < 0) {
                /* if error, do not deinterlace */
                av_free(buf);
                buf = NULL;
                picture2 = picture;
            }
        } else {
582 583 584 585 586 587 588 589
            if (img_convert(picture2, dec->pix_fmt, picture, 
                            dec->pix_fmt, dec->width, dec->height) < 0) {
                /* if error, do not copy */
                av_free(buf);
                buf = NULL;
                picture2 = picture;
            }
        }
590 591 592 593 594 595 596 597 598 599 600
    } else {
        picture2 = picture;
    }

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

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

601 602
/* we begin to correct av delay at this threshold */
#define AV_DELAY_MAX 0.100
Fabrice Bellard's avatar
merge  
Fabrice Bellard committed
603

604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636

/* Expects img to be yuv420 */
static void fill_pad_region(AVPicture* img, int height, int width,
        int padtop, int padbottom, int padleft, int padright, int *color) {
  
    int i, y, shift;
    uint8_t *optr;
    
    for (i = 0; i < 3; i++) {
        shift = (i == 0) ? 0 : 1;
        
        if (padtop || padleft) {
            memset(img->data[i], color[i], (((img->linesize[i] * padtop) + 
                            padleft) >> shift));
        }

        if (padleft || padright) {
            optr = img->data[i] + (img->linesize[i] * (padtop >> shift)) +
                (img->linesize[i] - (padright >> shift));

            for (y = 0; y < ((height - (padtop + padbottom)) >> shift); y++) {
                memset(optr, color[i], (padleft + padright) >> shift);
                optr += img->linesize[i];
            }
        }
      
        if (padbottom) {
            optr = img->data[i] + (img->linesize[i] * ((height - padbottom) >> shift));
            memset(optr, color[i], ((img->linesize[i] * padbottom) >> shift));
        }
    }
}

637
static uint8_t *bit_buffer= NULL;
638

Fabrice Bellard's avatar
merge  
Fabrice Bellard committed
639 640 641
static void do_video_out(AVFormatContext *s, 
                         AVOutputStream *ost, 
                         AVInputStream *ist,
642
                         AVFrame *in_picture,
643
                         int *frame_size)
Fabrice Bellard's avatar
merge  
Fabrice Bellard committed
644
{
645
    int nb_frames, i, ret;
646 647
    AVFrame *final_picture, *formatted_picture;
    AVFrame picture_format_temp, picture_crop_temp;
648
    uint8_t *buf = NULL, *buf1 = NULL;
649
    AVCodecContext *enc, *dec;
650
    enum PixelFormat target_pixfmt;
651
    
Michael Niedermayer's avatar
Michael Niedermayer committed
652 653
#define VIDEO_BUFFER_SIZE (1024*1024)

654 655 656
    avcodec_get_frame_defaults(&picture_format_temp);
    avcodec_get_frame_defaults(&picture_crop_temp);

Fabrice Bellard's avatar
merge  
Fabrice Bellard committed
657
    enc = &ost->st->codec;
658
    dec = &ist->st->codec;
Fabrice Bellard's avatar
merge  
Fabrice Bellard committed
659

660 661 662
    /* by default, we output a single frame */
    nb_frames = 1;

663 664
    *frame_size = 0;

665
    if(video_sync_method){
666
        double vdelta;
667 668 669 670 671 672
        vdelta = ost->sync_ipts * enc->frame_rate / enc->frame_rate_base - ost->sync_opts;
        //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)
            nb_frames = 2;
673
//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);
674 675 676 677 678 679 680 681 682 683 684
        if (nb_frames == 0){
            ++nb_frames_drop;
            if (verbose>2)
                fprintf(stderr, "*** drop!\n");
        }else if (nb_frames == 2) {
            ++nb_frames_dup;
            if (verbose>2)
                fprintf(stderr, "*** dup!\n");
        }
    }else
        ost->sync_opts= lrintf(ost->sync_ipts * enc->frame_rate / enc->frame_rate_base);
685

686
    if (nb_frames <= 0) 
Fabrice Bellard's avatar
merge  
Fabrice Bellard committed
687
        return;
688

689
    /* convert pixel format if needed */
690 691
    target_pixfmt = ost->video_resample || ost->video_pad
        ? PIX_FMT_YUV420P : enc->pix_fmt;
692
    if (dec->pix_fmt != target_pixfmt) {
693 694 695
        int size;

        /* create temporary picture */
696
        size = avpicture_get_size(target_pixfmt, dec->width, dec->height);
Fabrice Bellard's avatar
Fabrice Bellard committed
697
        buf = av_malloc(size);
698 699
        if (!buf)
            return;
700
        formatted_picture = &picture_format_temp;
701
        avpicture_fill((AVPicture*)formatted_picture, buf, target_pixfmt, dec->width, dec->height);
702
        
703
        if (img_convert((AVPicture*)formatted_picture, target_pixfmt, 
704
                        (AVPicture *)in_picture, dec->pix_fmt, 
705
                        dec->width, dec->height) < 0) {
706 707 708 709

            if (verbose >= 0)
                fprintf(stderr, "pixel format conversion not handled\n");

710 711 712
            goto the_end;
        }
    } else {
713
        formatted_picture = in_picture;
714 715
    }

716
    /* XXX: resampling could be done before raw format conversion in
717 718
       some cases to go faster */
    /* XXX: only works for YUV420P */
Fabrice Bellard's avatar
merge  
Fabrice Bellard committed
719
    if (ost->video_resample) {
720
        final_picture = &ost->pict_tmp;
721
        img_resample(ost->img_resample_ctx, (AVPicture*)final_picture, (AVPicture*)formatted_picture);
722 723
       
        if (ost->padtop || ost->padbottom || ost->padleft || ost->padright) {
724
            fill_pad_region((AVPicture*)final_picture, enc->height, enc->width,
725 726 727 728
                    ost->padtop, ost->padbottom, ost->padleft, ost->padright,
                    padcolor);
        }
        
729 730 731 732 733 734 735 736 737 738
	if (enc->pix_fmt != PIX_FMT_YUV420P) {
            int size;
	    
	    av_free(buf);
            /* create temporary picture */
            size = avpicture_get_size(enc->pix_fmt, enc->width, enc->height);
            buf = av_malloc(size);
            if (!buf)
                return;
            final_picture = &picture_format_temp;
739
            avpicture_fill((AVPicture*)final_picture, buf, enc->pix_fmt, enc->width, enc->height);
740
        
741 742
            if (img_convert((AVPicture*)final_picture, enc->pix_fmt, 
                            (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P, 
743
                            enc->width, enc->height) < 0) {
744 745 746 747

                if (verbose >= 0)
                    fprintf(stderr, "pixel format conversion not handled\n");

748 749 750
                goto the_end;
            }
	}
751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766
    } else if (ost->video_crop) {
        picture_crop_temp.data[0] = formatted_picture->data[0] +
                (ost->topBand * formatted_picture->linesize[0]) + ost->leftBand;

        picture_crop_temp.data[1] = formatted_picture->data[1] +
                ((ost->topBand >> 1) * formatted_picture->linesize[1]) +
                (ost->leftBand >> 1);

        picture_crop_temp.data[2] = formatted_picture->data[2] +
                ((ost->topBand >> 1) * formatted_picture->linesize[2]) +
                (ost->leftBand >> 1);

        picture_crop_temp.linesize[0] = formatted_picture->linesize[0];
        picture_crop_temp.linesize[1] = formatted_picture->linesize[1];
        picture_crop_temp.linesize[2] = formatted_picture->linesize[2];
        final_picture = &picture_crop_temp;
767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788
    } else if (ost->video_pad) {
        final_picture = &ost->pict_tmp;

        for (i = 0; i < 3; i++) {
            uint8_t *optr, *iptr;
            int shift = (i == 0) ? 0 : 1;
            int y, yheight;
            
            /* set offset to start writing image into */
            optr = final_picture->data[i] + (((final_picture->linesize[i] * 
                            ost->padtop) + ost->padleft) >> shift);
            iptr = formatted_picture->data[i];

            yheight = (enc->height - ost->padtop - ost->padbottom) >> shift;
            for (y = 0; y < yheight; y++) {
                /* copy unpadded image row into padded image row */
                memcpy(optr, iptr, formatted_picture->linesize[i]);
                optr += final_picture->linesize[i];
                iptr += formatted_picture->linesize[i];
            }
        }

789
        fill_pad_region((AVPicture*)final_picture, enc->height, enc->width,
790 791 792 793 794 795 796 797 798 799 800 801 802
                ost->padtop, ost->padbottom, ost->padleft, ost->padright,
                padcolor);
        
        if (enc->pix_fmt != PIX_FMT_YUV420P) {
            int size;

            av_free(buf);
            /* create temporary picture */
            size = avpicture_get_size(enc->pix_fmt, enc->width, enc->height);
            buf = av_malloc(size);
            if (!buf)
                return;
            final_picture = &picture_format_temp;
803
            avpicture_fill((AVPicture*)final_picture, buf, enc->pix_fmt, enc->width, enc->height);
804

805 806
            if (img_convert((AVPicture*)final_picture, enc->pix_fmt, 
                        (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P, 
807
                        enc->width, enc->height) < 0) {
808 809 810 811

                if (verbose >= 0)
                    fprintf(stderr, "pixel format conversion not handled\n");

812 813 814
                goto the_end;
            }
        }
Fabrice Bellard's avatar
merge  
Fabrice Bellard committed
815
    } else {
816
        final_picture = formatted_picture;
Fabrice Bellard's avatar
merge  
Fabrice Bellard committed
817 818 819
    }
    /* duplicates frame if needed */
    /* XXX: pb because no interleaving */
820
    for(i=0;i<nb_frames;i++) {
821 822 823 824
        AVPacket pkt;
        av_init_packet(&pkt);
        pkt.stream_index= ost->index;

825 826 827 828
        if (s->oformat->flags & AVFMT_RAWPICTURE) {
            /* raw pictures are written as AVPicture structure to
               avoid any copies. We support temorarily the older
               method. */
829
            AVFrame* old_frame = enc->coded_frame;
830 831 832 833 834 835 836 837
	    enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
            pkt.data= (uint8_t *)final_picture;
            pkt.size=  sizeof(AVPicture);
            if(dec->coded_frame)
                pkt.pts= dec->coded_frame->pts;
            if(dec->coded_frame && dec->coded_frame->key_frame)
                pkt.flags |= PKT_FLAG_KEY;

838
            av_interleaved_write_frame(s, &pkt);
839
	    enc->coded_frame = old_frame;
840
        } else {
Michael Niedermayer's avatar
Michael Niedermayer committed
841
            AVFrame big_picture;
842 843

            big_picture= *final_picture;
844 845 846
            /* better than nothing: use input picture interlaced
               settings */
            big_picture.interlaced_frame = in_picture->interlaced_frame;
847 848 849 850
            if(do_interlace_me || do_interlace_dct){
                if(top_field_first == -1)
                    big_picture.top_field_first = in_picture->top_field_first;
                else
Michael Niedermayer's avatar
Michael Niedermayer committed
851
                    big_picture.top_field_first = top_field_first;
852
            }
853

Fabrice Bellard's avatar
merge  
Fabrice Bellard committed
854 855 856
            /* handles sameq here. This is not correct because it may
               not be a global option */
            if (same_quality) {
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
857 858 859
                big_picture.quality = ist->st->quality;
            }else
                big_picture.quality = ost->st->quality;
860 861
            if(!me_threshold)
                big_picture.pict_type = 0;
862 863 864
//            big_picture.pts = AV_NOPTS_VALUE;
            big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->frame_rate_base, enc->frame_rate);
//av_log(NULL, AV_LOG_DEBUG, "%lld -> encoder\n", ost->sync_opts);
865
            ret = avcodec_encode_video(enc, 
866
                                       bit_buffer, VIDEO_BUFFER_SIZE,
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
867
                                       &big_picture);
868
            //enc->frame_number = enc->real_pict_num;
869
            if(ret){
870
                pkt.data= bit_buffer;
871 872 873
                pkt.size= ret;
                if(enc->coded_frame)
                    pkt.pts= enc->coded_frame->pts;
874 875 876 877
/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %lld/%lld\n", 
   pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->frame_rate, AV_TIME_BASE*(int64_t)enc->frame_rate_base) : -1,
   pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->frame_rate, AV_TIME_BASE*(int64_t)enc->frame_rate_base) : -1);*/

878 879
                if(enc->coded_frame && enc->coded_frame->key_frame)
                    pkt.flags |= PKT_FLAG_KEY;
880
                av_interleaved_write_frame(s, &pkt);
881 882 883 884 885 886 887 888
                *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);
                }
889
            }
Fabrice Bellard's avatar
merge  
Fabrice Bellard committed
890
        }
891
        ost->sync_opts++;
892
        ost->frame_number++;
Fabrice Bellard's avatar
merge  
Fabrice Bellard committed
893
    }
894
 the_end:
Fabrice Bellard's avatar
Fabrice Bellard committed
895 896
    av_free(buf);
    av_free(buf1);
Fabrice Bellard's avatar
merge  
Fabrice Bellard committed
897 898
}

899 900
static double psnr(double d){
    if(d==0) return INFINITY;
901
    return -10.0*log(d)/log(10.0);