libxvid.c 32 KB
Newer Older
1
/*
2
 * Interface to xvidcore for MPEG-4 encoding
3 4
 * Copyright (c) 2004 Adam Thayer <krevnik@comcast.net>
 *
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.
11
 *
12
 * FFmpeg is distributed in the hope that it will be useful,
13 14 15 16 17
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with FFmpeg; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 */
21

22
/**
23
 * @file
24 25 26
 * Interface to xvidcore for MPEG-4 compliant encoding.
 * @author Adam Thayer (krevnik@comcast.net)
 */
27

28 29
#include <stdio.h>
#include <string.h>
30
#include <xvid.h>
31

32
#include "libavutil/avassert.h"
33
#include "libavutil/cpu.h"
34
#include "libavutil/file.h"
35
#include "libavutil/internal.h"
36
#include "libavutil/intreadwrite.h"
37
#include "libavutil/mathematics.h"
38
#include "libavutil/mem.h"
39
#include "libavutil/opt.h"
40 41

#include "avcodec.h"
42
#include "internal.h"
43
#include "libxvid.h"
44
#include "mpegutils.h"
45

46 47 48 49
#if HAVE_UNISTD_H
#include <unistd.h>
#endif

50 51 52 53
#if HAVE_IO_H
#include <io.h>
#endif

54 55 56
/**
 * Buffer management macros.
 */
57 58 59
#define BUFFER_SIZE         1024
#define BUFFER_REMAINING(x) (BUFFER_SIZE - strlen(x))
#define BUFFER_CAT(x)       (&((x)[strlen(x)]))
60 61

/**
62
 * Structure for the private Xvid context.
63 64
 * This stores all the private context for the codec.
 */
65
struct xvid_context {
66
    AVClass *class;
67 68 69 70 71 72 73 74 75 76 77
    void *encoder_handle;          /**< Handle for Xvid encoder */
    int xsize;                     /**< Frame x size */
    int ysize;                     /**< Frame y size */
    int vop_flags;                 /**< VOP flags for Xvid encoder */
    int vol_flags;                 /**< VOL flags for Xvid encoder */
    int me_flags;                  /**< Motion Estimation flags */
    int qscale;                    /**< Do we use constant scale? */
    int quicktime_format;          /**< Are we in a QT-based format? */
    char *twopassbuffer;           /**< Character buffer for two-pass */
    char *old_twopassbuffer;       /**< Old character buffer (two-pass) */
    char *twopassfile;             /**< second pass temp file name */
78
    int twopassfd;
79 80
    unsigned char *intra_matrix;   /**< P-Frame Quant Matrix */
    unsigned char *inter_matrix;   /**< I-Frame Quant Matrix */
81 82
    int lumi_aq;                   /**< Lumi masking as an aq method */
    int variance_aq;               /**< Variance adaptive quantization */
83 84
    int ssim;                      /**< SSIM information display mode */
    int ssim_acc;                  /**< SSIM accuracy. 0: accurate. 4: fast. */
85
    int gmc;
86
    int me_quality;                /**< Motion estimation quality. 0: fast 6: best. */
87
    int mpeg_quant;                /**< Quantization type. 0: H.263, 1: MPEG */
88
};
89

90 91 92
/**
 * Structure for the private first-pass plugin.
 */
93
struct xvid_ff_pass1 {
94
    int version;                    /**< Xvid version */
95
    struct xvid_context *context;   /**< Pointer to private context */
96
};
97

98
static int xvid_encode_close(AVCodecContext *avctx);
99 100 101
static int xvid_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
                             const AVFrame *picture, int *got_packet);

102

103 104 105 106 107 108 109 110 111
/*
 * Xvid 2-Pass Kludge Section
 *
 * Xvid's default 2-pass doesn't allow us to create data as we need to, so
 * this section spends time replacing the first pass plugin so we can write
 * statistic information as libavcodec requests in. We have another kludge
 * that allows us to pass data to the second pass in Xvid without a custom
 * rate-control plugin.
 */
112 113

/**
114
 * Initialize the two-pass plugin and context.
115
 *
116 117 118
 * @param param Input construction parameter structure
 * @param handle Private context handle
 * @return Returns XVID_ERR_xxxx on failure, or 0 on success.
119
 */
120 121 122
static int xvid_ff_2pass_create(xvid_plg_create_t *param, void **handle)
{
    struct xvid_ff_pass1 *x = (struct xvid_ff_pass1 *) param->param;
123
    char *log = x->context->twopassbuffer;
124

125
    /* Do a quick bounds check */
126
    if (!log)
127
        return XVID_ERR_FAIL;
128

129 130 131 132
    /* We use snprintf() */
    /* This is because we can safely prevent a buffer overflow */
    log[0] = 0;
    snprintf(log, BUFFER_REMAINING(log),
133
             "# ffmpeg 2-pass log file, using xvid codec\n");
134
    snprintf(BUFFER_CAT(log), BUFFER_REMAINING(log),
135 136 137 138
             "# Do not modify. libxvidcore version: %d.%d.%d\n\n",
             XVID_VERSION_MAJOR(XVID_VERSION),
             XVID_VERSION_MINOR(XVID_VERSION),
             XVID_VERSION_PATCH(XVID_VERSION));
139

140 141 142
    *handle = x->context;
    return 0;
}
143

144 145 146 147
/**
 * Destroy the two-pass plugin context.
 *
 * @param ref Context pointer for the plugin
148
 * @param param Destroy context
149 150 151
 * @return Returns 0, success guaranteed
 */
static int xvid_ff_2pass_destroy(struct xvid_context *ref,
152 153
                                 xvid_plg_destroy_t *param)
{
154 155
    /* Currently cannot think of anything to do on destruction */
    /* Still, the framework should be here for reference/use */
156
    if (ref->twopassbuffer)
157 158 159
        ref->twopassbuffer[0] = 0;
    return 0;
}
160

161 162 163 164 165 166 167 168
/**
 * Enable fast encode mode during the first pass.
 *
 * @param ref Context pointer for the plugin
 * @param param Frame data
 * @return Returns 0, success guaranteed
 */
static int xvid_ff_2pass_before(struct xvid_context *ref,
169 170
                                xvid_plg_data_t *param)
{
171 172 173
    int motion_remove;
    int motion_replacements;
    int vop_remove;
174

175
    /* Nothing to do here, result is changed too much */
176
    if (param->zone && param->zone->mode == XVID_ZONE_QUANT)
177
        return 0;
178

179 180
    /* We can implement a 'turbo' first pass mode here */
    param->quant = 2;
181

182
    /* Init values */
183 184 185 186
    motion_remove       = ~XVID_ME_CHROMA_PVOP &
                          ~XVID_ME_CHROMA_BVOP &
                          ~XVID_ME_EXTSEARCH16 &
                          ~XVID_ME_ADVANCEDDIAMOND16;
187
    motion_replacements = XVID_ME_FAST_MODEINTERPOLATE |
188 189
                          XVID_ME_SKIP_DELTASEARCH     |
                          XVID_ME_FASTREFINE16         |
190
                          XVID_ME_BFRAME_EARLYSTOP;
191 192 193 194 195 196 197 198
    vop_remove          = ~XVID_VOP_MODEDECISION_RD      &
                          ~XVID_VOP_FAST_MODEDECISION_RD &
                          ~XVID_VOP_TRELLISQUANT         &
                          ~XVID_VOP_INTER4V              &
                          ~XVID_VOP_HQACPRED;

    param->vol_flags    &= ~XVID_VOL_GMC;
    param->vop_flags    &= vop_remove;
199 200
    param->motion_flags &= motion_remove;
    param->motion_flags |= motion_replacements;
201

202 203
    return 0;
}
204

205 206 207 208 209 210 211 212
/**
 * Capture statistic data and write it during first pass.
 *
 * @param ref Context pointer for the plugin
 * @param param Statistic data
 * @return Returns XVID_ERR_xxxx on failure, or 0 on success
 */
static int xvid_ff_2pass_after(struct xvid_context *ref,
213 214
                               xvid_plg_data_t *param)
{
215 216 217
    char *log = ref->twopassbuffer;
    const char *frame_types = " ipbs";
    char frame_type;
218

219
    /* Quick bounds check */
220
    if (!log)
221
        return XVID_ERR_FAIL;
222

223
    /* Convert the type given to us into a character */
224
    if (param->type < 5 && param->type > 0)
225
        frame_type = frame_types[param->type];
226
    else
227
        return XVID_ERR_FAIL;
228

229
    snprintf(BUFFER_CAT(log), BUFFER_REMAINING(log),
230 231 232 233
             "%c %d %d %d %d %d %d\n",
             frame_type, param->stats.quant, param->stats.kblks,
             param->stats.mblks, param->stats.ublks,
             param->stats.length, param->stats.hlength);
234

235 236
    return 0;
}
237

238 239 240 241 242 243 244 245 246 247 248 249 250
/**
 * Dispatch function for our custom plugin.
 * This handles the dispatch for the Xvid plugin. It passes data
 * on to other functions for actual processing.
 *
 * @param ref Context pointer for the plugin
 * @param cmd The task given for us to complete
 * @param p1 First parameter (varies)
 * @param p2 Second parameter (varies)
 * @return Returns XVID_ERR_xxxx on failure, or 0 on success
 */
static int xvid_ff_2pass(void *ref, int cmd, void *p1, void *p2)
{
251 252 253 254 255 256 257 258 259 260 261 262 263 264
    switch (cmd) {
    case XVID_PLG_INFO:
    case XVID_PLG_FRAME:
        return 0;
    case XVID_PLG_BEFORE:
        return xvid_ff_2pass_before(ref, p1);
    case XVID_PLG_CREATE:
        return xvid_ff_2pass_create(p1, p2);
    case XVID_PLG_AFTER:
        return xvid_ff_2pass_after(ref, p1);
    case XVID_PLG_DESTROY:
        return xvid_ff_2pass_destroy(ref, p1);
    default:
        return XVID_ERR_FAIL;
265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280
    }
}

/**
 * Routine to create a global VO/VOL header for MP4 container.
 * What we do here is extract the header from the Xvid bitstream
 * as it is encoded. We also strip the repeated headers from the
 * bitstream when a global header is requested for MPEG-4 ISO
 * compliance.
 *
 * @param avctx AVCodecContext pointer to context
 * @param frame Pointer to encoded frame data
 * @param header_len Length of header to search
 * @param frame_len Length of encoded frame data
 * @return Returns new length of frame data
 */
281 282 283 284
static int xvid_strip_vol_header(AVCodecContext *avctx, AVPacket *pkt,
                                 unsigned int header_len,
                                 unsigned int frame_len)
{
285 286
    int vo_len = 0, i;

287 288 289 290 291
    for (i = 0; i < header_len - 3; i++) {
        if (pkt->data[i]     == 0x00 &&
            pkt->data[i + 1] == 0x00 &&
            pkt->data[i + 2] == 0x01 &&
            pkt->data[i + 3] == 0xB6) {
292 293 294 295 296
            vo_len = i;
            break;
        }
    }

297
    if (vo_len > 0) {
298
        /* We need to store the header, so extract it */
299
        if (!avctx->extradata) {
300
            avctx->extradata = av_malloc(vo_len);
301 302
            if (!avctx->extradata)
                return AVERROR(ENOMEM);
303 304 305 306
            memcpy(avctx->extradata, pkt->data, vo_len);
            avctx->extradata_size = vo_len;
        }
        /* Less dangerous now, memmove properly copies the two
307
         * chunks of overlapping data */
308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333
        memmove(pkt->data, &pkt->data[vo_len], frame_len - vo_len);
        pkt->size = frame_len - vo_len;
    }
    return 0;
}

/**
 * Routine to correct a possibly erroneous framerate being fed to us.
 * Xvid currently chokes on framerates where the ticks per frame is
 * extremely large. This function works to correct problems in this area
 * by estimating a new framerate and taking the simpler fraction of
 * the two presented.
 *
 * @param avctx Context that contains the framerate to correct.
 */
static void xvid_correct_framerate(AVCodecContext *avctx)
{
    int frate, fbase;
    int est_frate, est_fbase;
    int gcd;
    float est_fps, fps;

    frate = avctx->time_base.den;
    fbase = avctx->time_base.num;

    gcd = av_gcd(frate, fbase);
334
    if (gcd > 1) {
335 336 337 338
        frate /= gcd;
        fbase /= gcd;
    }

339
    if (frate <= 65000 && fbase <= 65000) {
340 341 342 343 344
        avctx->time_base.den = frate;
        avctx->time_base.num = fbase;
        return;
    }

345
    fps     = (float) frate / (float) fbase;
346 347
    est_fps = roundf(fps * 1000.0) / 1000.0;

348 349
    est_frate = (int) est_fps;
    if (est_fps > (int) est_fps) {
350
        est_frate = (est_frate + 1) * 1000;
351
        est_fbase = (int) roundf((float) est_frate / est_fps);
352 353 354 355
    } else
        est_fbase = 1;

    gcd = av_gcd(est_frate, est_fbase);
356
    if (gcd > 1) {
357 358 359 360
        est_frate /= gcd;
        est_fbase /= gcd;
    }

361
    if (fbase > est_fbase) {
362 363 364
        avctx->time_base.den = est_frate;
        avctx->time_base.num = est_fbase;
        av_log(avctx, AV_LOG_DEBUG,
365 366
               "Xvid: framerate re-estimated: %.2f, %.3f%% correction\n",
               est_fps, (((est_fps - fps) / fps) * 100.0));
367 368 369 370 371 372
    } else {
        avctx->time_base.den = frate;
        avctx->time_base.num = fbase;
    }
}

373 374
static av_cold int xvid_encode_init(AVCodecContext *avctx)
{
375
    int xerr, i, ret = -1;
376 377 378 379 380
    int xvid_flags = avctx->flags;
    struct xvid_context *x = avctx->priv_data;
    uint16_t *intra, *inter;
    int fd;

381 382 383 384 385 386 387 388
    xvid_plugin_single_t      single          = { 0 };
    struct xvid_ff_pass1      rc2pass1        = { 0 };
    xvid_plugin_2pass2_t      rc2pass2        = { 0 };
    xvid_plugin_lumimasking_t masking_l       = { 0 }; /* For lumi masking */
    xvid_plugin_lumimasking_t masking_v       = { 0 }; /* For variance AQ */
    xvid_plugin_ssim_t        ssim            = { 0 };
    xvid_gbl_init_t           xvid_gbl_init   = { 0 };
    xvid_enc_create_t         xvid_enc_create = { 0 };
389
    xvid_enc_plugin_t         plugins[4];
390

391 392
    x->twopassfd = -1;

393
    /* Bring in VOP flags from ffmpeg command-line */
394
    x->vop_flags = XVID_VOP_HALFPEL;              /* Bare minimum quality */
395
    if (xvid_flags & AV_CODEC_FLAG_4MV)
396
        x->vop_flags    |= XVID_VOP_INTER4V;      /* Level 3 */
397
    if (avctx->trellis)
398
        x->vop_flags    |= XVID_VOP_TRELLISQUANT; /* Level 5 */
399
    if (xvid_flags & AV_CODEC_FLAG_AC_PRED)
400
        x->vop_flags    |= XVID_VOP_HQACPRED;     /* Level 6 */
401
    if (xvid_flags & AV_CODEC_FLAG_GRAY)
402
        x->vop_flags    |= XVID_VOP_GREYSCALE;
403 404 405

    /* Decide which ME quality setting to use */
    x->me_flags = 0;
406 407 408
    switch (x->me_quality) {
    case 6:
    case 5:
409 410
        x->me_flags |= XVID_ME_EXTSEARCH16 |
                       XVID_ME_EXTSEARCH8;
411 412
    case 4:
    case 3:
413 414 415 416
        x->me_flags |= XVID_ME_ADVANCEDDIAMOND8 |
                       XVID_ME_HALFPELREFINE8   |
                       XVID_ME_CHROMA_PVOP      |
                       XVID_ME_CHROMA_BVOP;
417 418
    case 2:
    case 1:
419 420
        x->me_flags |= XVID_ME_ADVANCEDDIAMOND16 |
                       XVID_ME_HALFPELREFINE16;
421 422 423
    }

    /* Decide how we should decide blocks */
424 425 426 427 428 429 430 431 432 433 434 435 436 437
    switch (avctx->mb_decision) {
    case 2:
        x->vop_flags |=  XVID_VOP_MODEDECISION_RD;
        x->me_flags  |=  XVID_ME_HALFPELREFINE8_RD    |
                         XVID_ME_QUARTERPELREFINE8_RD |
                         XVID_ME_EXTSEARCH_RD         |
                         XVID_ME_CHECKPREDICTION_RD;
    case 1:
        if (!(x->vop_flags & XVID_VOP_MODEDECISION_RD))
            x->vop_flags |= XVID_VOP_FAST_MODEDECISION_RD;
        x->me_flags |= XVID_ME_HALFPELREFINE16_RD |
                       XVID_ME_QUARTERPELREFINE16_RD;
    default:
        break;
438 439
    }

440
    /* Bring in VOL flags from ffmpeg command-line */
441
    x->vol_flags = 0;
442
    if (x->gmc) {
443
        x->vol_flags |= XVID_VOL_GMC;
444
        x->me_flags  |= XVID_ME_GME_REFINE;
445
    }
446
    if (xvid_flags & AV_CODEC_FLAG_QPEL) {
447
        x->vol_flags |= XVID_VOL_QUARTERPEL;
448 449
        x->me_flags  |= XVID_ME_QUARTERPELREFINE16;
        if (x->vop_flags & XVID_VOP_INTER4V)
450 451 452
            x->me_flags |= XVID_ME_QUARTERPELREFINE8;
    }

453 454
    xvid_gbl_init.version   = XVID_VERSION;
    xvid_gbl_init.debug     = 0;
455 456 457 458 459 460 461 462 463
    xvid_gbl_init.cpu_flags = 0;

    /* Initialize */
    xvid_global(NULL, XVID_GBL_INIT, &xvid_gbl_init, NULL);

    /* Create the encoder reference */
    xvid_enc_create.version = XVID_VERSION;

    /* Store the desired frame size */
464 465 466 467
    xvid_enc_create.width  =
    x->xsize               = avctx->width;
    xvid_enc_create.height =
    x->ysize               = avctx->height;
468 469 470 471 472

    /* Xvid can determine the proper profile to use */
    /* xvid_enc_create.profile = XVID_PROFILE_S_L3; */

    /* We don't use zones */
473
    xvid_enc_create.zones     = NULL;
474 475 476
    xvid_enc_create.num_zones = 0;

    xvid_enc_create.num_threads = avctx->thread_count;
477 478 479 480 481 482 483 484
#if (XVID_VERSION <= 0x010303) && (XVID_VERSION >= 0x010300)
    /* workaround for a bug in libxvidcore */
    if (avctx->height <= 16) {
        if (avctx->thread_count < 2) {
            xvid_enc_create.num_threads = 0;
        } else {
            av_log(avctx, AV_LOG_ERROR,
                   "Too small height for threads > 1.");
485
            return AVERROR(EINVAL);
486 487 488
        }
    }
#endif
489

490
    xvid_enc_create.plugins     = plugins;
491 492 493
    xvid_enc_create.num_plugins = 0;

    /* Initialize Buffers */
494
    x->twopassbuffer     = NULL;
495
    x->old_twopassbuffer = NULL;
496
    x->twopassfile       = NULL;
497

498
    if (xvid_flags & AV_CODEC_FLAG_PASS1) {
499 500 501
        rc2pass1.version     = XVID_VERSION;
        rc2pass1.context     = x;
        x->twopassbuffer     = av_malloc(BUFFER_SIZE);
502
        x->old_twopassbuffer = av_malloc(BUFFER_SIZE);
503
        if (!x->twopassbuffer || !x->old_twopassbuffer) {
504
            av_log(avctx, AV_LOG_ERROR,
505
                   "Xvid: Cannot allocate 2-pass log buffers\n");
506
            return AVERROR(ENOMEM);
507
        }
508 509
        x->twopassbuffer[0]     =
        x->old_twopassbuffer[0] = 0;
510

511
        plugins[xvid_enc_create.num_plugins].func  = xvid_ff_2pass;
512 513
        plugins[xvid_enc_create.num_plugins].param = &rc2pass1;
        xvid_enc_create.num_plugins++;
514
    } else if (xvid_flags & AV_CODEC_FLAG_PASS2) {
515 516
        rc2pass2.version = XVID_VERSION;
        rc2pass2.bitrate = avctx->bit_rate;
517

518
        fd = avpriv_tempfile("xvidff.", &x->twopassfile, 0, avctx);
519
        if (fd < 0) {
520
            av_log(avctx, AV_LOG_ERROR, "Xvid: Cannot write 2-pass pipe\n");
521
            return fd;
522
        }
523
        x->twopassfd = fd;
524

525
        if (!avctx->stats_in) {
526
            av_log(avctx, AV_LOG_ERROR,
527
                   "Xvid: No 2-pass information loaded for second pass\n");
528
            return AVERROR(EINVAL);
529
        }
530

531 532 533 534
        ret = write(fd, avctx->stats_in, strlen(avctx->stats_in));
        if (ret == -1)
            ret = AVERROR(errno);
        else if (strlen(avctx->stats_in) > ret) {
535
            av_log(avctx, AV_LOG_ERROR, "Xvid: Cannot write to 2-pass pipe\n");
536
            ret = AVERROR(EIO);
537
        }
538
        if (ret < 0)
539
            return ret;
540

541 542
        rc2pass2.filename                          = x->twopassfile;
        plugins[xvid_enc_create.num_plugins].func  = xvid_plugin_2pass2;
543 544
        plugins[xvid_enc_create.num_plugins].param = &rc2pass2;
        xvid_enc_create.num_plugins++;
545
    } else if (!(xvid_flags & AV_CODEC_FLAG_QSCALE)) {
546 547 548
        /* Single Pass Bitrate Control! */
        single.version = XVID_VERSION;
        single.bitrate = avctx->bit_rate;
549

550
        plugins[xvid_enc_create.num_plugins].func  = xvid_plugin_single;
551 552 553 554
        plugins[xvid_enc_create.num_plugins].param = &single;
        xvid_enc_create.num_plugins++;
    }

555
    if (avctx->lumi_masking != 0.0)
556 557
        x->lumi_aq = 1;

558
    /* Luminance Masking */
559
    if (x->lumi_aq) {
560
        masking_l.method                          = 0;
561
        plugins[xvid_enc_create.num_plugins].func = xvid_plugin_lumimasking;
562 563 564

        /* The old behavior is that when avctx->lumi_masking is specified,
         * plugins[...].param = NULL. Trying to keep the old behavior here. */
565 566 567
        plugins[xvid_enc_create.num_plugins].param =
            avctx->lumi_masking ? NULL : &masking_l;
        xvid_enc_create.num_plugins++;
568 569
    }

570
    /* Variance AQ */
571
    if (x->variance_aq) {
572
        masking_v.method                           = 1;
573
        plugins[xvid_enc_create.num_plugins].func  = xvid_plugin_lumimasking;
574
        plugins[xvid_enc_create.num_plugins].param = &masking_v;
575 576 577
        xvid_enc_create.num_plugins++;
    }

578
    if (x->lumi_aq && x->variance_aq )
579 580 581 582
        av_log(avctx, AV_LOG_INFO,
               "Both lumi_aq and variance_aq are enabled. The resulting quality"
               "will be the worse one of the two effects made by the AQ.\n");

583
    /* SSIM */
584
    if (x->ssim) {
585 586 587 588 589
        plugins[xvid_enc_create.num_plugins].func  = xvid_plugin_ssim;
        ssim.b_printstat                           = x->ssim == 2;
        ssim.acc                                   = x->ssim_acc;
        ssim.cpu_flags                             = xvid_gbl_init.cpu_flags;
        ssim.b_visualize                           = 0;
590 591 592 593
        plugins[xvid_enc_create.num_plugins].param = &ssim;
        xvid_enc_create.num_plugins++;
    }

594 595
    /* Frame Rate and Key Frames */
    xvid_correct_framerate(avctx);
596 597
    xvid_enc_create.fincr = avctx->time_base.num;
    xvid_enc_create.fbase = avctx->time_base.den;
598
    if (avctx->gop_size > 0)
599 600
        xvid_enc_create.max_key_interval = avctx->gop_size;
    else
601
        xvid_enc_create.max_key_interval = 240; /* Xvid's best default */
602 603

    /* Quants */
604
    if (xvid_flags & AV_CODEC_FLAG_QSCALE)
605 606 607
        x->qscale = 1;
    else
        x->qscale = 0;
608

609 610 611 612 613 614
    xvid_enc_create.min_quant[0] = avctx->qmin;
    xvid_enc_create.min_quant[1] = avctx->qmin;
    xvid_enc_create.min_quant[2] = avctx->qmin;
    xvid_enc_create.max_quant[0] = avctx->qmax;
    xvid_enc_create.max_quant[1] = avctx->qmax;
    xvid_enc_create.max_quant[2] = avctx->qmax;
615

616
    /* Quant Matrices */
617 618
    x->intra_matrix =
    x->inter_matrix = NULL;
619 620 621

#if FF_API_PRIVATE_OPT
FF_DISABLE_DEPRECATION_WARNINGS
622
    if (avctx->mpeg_quant)
623 624 625 626 627
        x->mpeg_quant = avctx->mpeg_quant;
FF_ENABLE_DEPRECATION_WARNINGS
#endif

    if (x->mpeg_quant)
628 629 630 631 632 633 634
        x->vol_flags |= XVID_VOL_MPEGQUANT;
    if ((avctx->intra_matrix || avctx->inter_matrix)) {
        x->vol_flags |= XVID_VOL_MPEGQUANT;

        if (avctx->intra_matrix) {
            intra           = avctx->intra_matrix;
            x->intra_matrix = av_malloc(sizeof(unsigned char) * 64);
635 636
            if (!x->intra_matrix)
                return AVERROR(ENOMEM);
637 638 639 640 641
        } else
            intra = NULL;
        if (avctx->inter_matrix) {
            inter           = avctx->inter_matrix;
            x->inter_matrix = av_malloc(sizeof(unsigned char) * 64);
642 643
            if (!x->inter_matrix)
                return AVERROR(ENOMEM);
644 645 646 647 648 649 650 651 652
        } else
            inter = NULL;

        for (i = 0; i < 64; i++) {
            if (intra)
                x->intra_matrix[i] = (unsigned char) intra[i];
            if (inter)
                x->inter_matrix[i] = (unsigned char) inter[i];
        }
653
    }
654

655 656
    /* Misc Settings */
    xvid_enc_create.frame_drop_ratio = 0;
657
    xvid_enc_create.global           = 0;
658
    if (xvid_flags & AV_CODEC_FLAG_CLOSED_GOP)
659 660 661
        xvid_enc_create.global |= XVID_GLOBAL_CLOSED_GOP;

    /* Determines which codec mode we are operating in */
662
    avctx->extradata      = NULL;
663
    avctx->extradata_size = 0;
664
    if (xvid_flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
665
        /* In this case, we are claiming to be MPEG-4 */
666
        x->quicktime_format = 1;
667
        avctx->codec_id     = AV_CODEC_ID_MPEG4;
668
    } else {
669
        /* We are claiming to be Xvid */
670
        x->quicktime_format = 0;
671
        if (!avctx->codec_tag)
672
            avctx->codec_tag = AV_RL32("xvid");
673 674
    }

675
    /* Bframes */
676
    xvid_enc_create.max_bframes   = avctx->max_b_frames;
677
    xvid_enc_create.bquant_offset = 100 * avctx->b_quant_offset;
678 679 680
    xvid_enc_create.bquant_ratio  = 100 * avctx->b_quant_factor;
    if (avctx->max_b_frames > 0 && !x->quicktime_format)
        xvid_enc_create.global |= XVID_GLOBAL_PACKED;
681

682 683
    av_assert0(xvid_enc_create.num_plugins + (!!x->ssim) + (!!x->variance_aq) + (!!x->lumi_aq) <= FF_ARRAY_ELEMS(plugins));

684 685 686
    /* Encode a dummy frame to get the extradata immediately */
    if (x->quicktime_format) {
        AVFrame *picture;
687
        AVPacket packet = {0};
688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720
        int size, got_packet, ret;

        av_init_packet(&packet);

        picture = av_frame_alloc();
        if (!picture)
            return AVERROR(ENOMEM);

        xerr = xvid_encore(NULL, XVID_ENC_CREATE, &xvid_enc_create, NULL);
        if( xerr ) {
            av_frame_free(&picture);
            av_log(avctx, AV_LOG_ERROR, "Xvid: Could not create encoder reference\n");
            return AVERROR_EXTERNAL;
        }
        x->encoder_handle = xvid_enc_create.handle;
        size = ((avctx->width + 1) & ~1) * ((avctx->height + 1) & ~1);
        picture->data[0] = av_malloc(size + size / 2);
        if (!picture->data[0]) {
            av_frame_free(&picture);
            return AVERROR(ENOMEM);
        }
        picture->data[1] = picture->data[0] + size;
        picture->data[2] = picture->data[1] + size / 4;
        memset(picture->data[0], 0, size);
        memset(picture->data[1], 128, size / 2);
        ret = xvid_encode_frame(avctx, &packet, picture, &got_packet);
        if (!ret && got_packet)
            av_packet_unref(&packet);
        av_free(picture->data[0]);
        av_frame_free(&picture);
        xvid_encore(x->encoder_handle, XVID_ENC_DESTROY, NULL, NULL);
    }

721 722
    /* Create encoder context */
    xerr = xvid_encore(NULL, XVID_ENC_CREATE, &xvid_enc_create, NULL);
723
    if (xerr) {
724
        av_log(avctx, AV_LOG_ERROR, "Xvid: Could not create encoder reference\n");
725
        return AVERROR_EXTERNAL;
726
    }
727

728
    x->encoder_handle  = xvid_enc_create.handle;
729 730 731 732

    return 0;
}

733 734 735 736
static int xvid_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
                             const AVFrame *picture, int *got_packet)
{
    int xerr, i, ret, user_packet = !!pkt->data;
737
    struct xvid_context *x = avctx->priv_data;
738 739 740
    int mb_width  = (avctx->width  + 15) / 16;
    int mb_height = (avctx->height + 15) / 16;
    char *tmp;
741

742 743
    xvid_enc_frame_t xvid_enc_frame = { 0 };
    xvid_enc_stats_t xvid_enc_stats = { 0 };
744

745
    if ((ret = ff_alloc_packet2(avctx, pkt, mb_width*(int64_t)mb_height*MAX_MB_BYTES + AV_INPUT_BUFFER_MIN_SIZE, 0)) < 0)
746
        return ret;
747

748 749 750
    /* Start setting up the frame */
    xvid_enc_frame.version = XVID_VERSION;
    xvid_enc_stats.version = XVID_VERSION;
751

752
    /* Let Xvid know where to put the frame. */
753 754
    xvid_enc_frame.bitstream = pkt->data;
    xvid_enc_frame.length    = pkt->size;
755

756
    /* Initialize input image fields */
757 758 759
    if (avctx->pix_fmt != AV_PIX_FMT_YUV420P) {
        av_log(avctx, AV_LOG_ERROR,
               "Xvid: Color spaces other than 420P not supported\n");
760
        return AVERROR(EINVAL);
761 762 763
    }

    xvid_enc_frame.input.csp = XVID_CSP_PLANAR; /* YUV420P */
764

765 766
    for (i = 0; i < 4; i++) {
        xvid_enc_frame.input.plane[i]  = picture->data[i];
767 768
        xvid_enc_frame.input.stride[i] = picture->linesize[i];
    }
769

770 771 772
    /* Encoder Flags */
    xvid_enc_frame.vop_flags = x->vop_flags;
    xvid_enc_frame.vol_flags = x->vol_flags;
773 774
    xvid_enc_frame.motion    = x->me_flags;
    xvid_enc_frame.type      =
775 776 777
        picture->pict_type == AV_PICTURE_TYPE_I ? XVID_TYPE_IVOP :
        picture->pict_type == AV_PICTURE_TYPE_P ? XVID_TYPE_PVOP :
        picture->pict_type == AV_PICTURE_TYPE_B ? XVID_TYPE_BVOP :
778
                                                  XVID_TYPE_AUTO;
779

780
    /* Pixel aspect ratio setting */
781 782
    if (avctx->sample_aspect_ratio.num < 0 || avctx->sample_aspect_ratio.num > 255 ||
        avctx->sample_aspect_ratio.den < 0 || avctx->sample_aspect_ratio.den > 255) {
783 784
        av_log(avctx, AV_LOG_WARNING,
               "Invalid pixel aspect ratio %i/%i, limit is 255/255 reducing\n",
785
               avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den);
786 787
        av_reduce(&avctx->sample_aspect_ratio.num, &avctx->sample_aspect_ratio.den,
                   avctx->sample_aspect_ratio.num,  avctx->sample_aspect_ratio.den, 255);
788
    }
789
    xvid_enc_frame.par        = XVID_PAR_EXT;
790 791
    xvid_enc_frame.par_width  = avctx->sample_aspect_ratio.num;
    xvid_enc_frame.par_height = avctx->sample_aspect_ratio.den;
792

793
    /* Quant Setting */
794 795 796 797
    if (x->qscale)
        xvid_enc_frame.quant = picture->quality / FF_QP2LAMBDA;
    else
        xvid_enc_frame.quant = 0;
798

799 800 801 802 803
    /* Matrices */
    xvid_enc_frame.quant_intra_matrix = x->intra_matrix;
    xvid_enc_frame.quant_inter_matrix = x->inter_matrix;

    /* Encode */
804
    xerr = xvid_encore(x->encoder_handle, XVID_ENC_ENCODE,
805
                       &xvid_enc_frame, &xvid_enc_stats);
806 807 808

    /* Two-pass log buffer swapping */
    avctx->stats_out = NULL;
809 810
    if (x->twopassbuffer) {
        tmp                  = x->old_twopassbuffer;
811
        x->old_twopassbuffer = x->twopassbuffer;
812 813 814
        x->twopassbuffer     = tmp;
        x->twopassbuffer[0]  = 0;
        if (x->old_twopassbuffer[0] != 0) {
815 816
            avctx->stats_out = x->old_twopassbuffer;
        }
817 818
    }

819
    if (xerr > 0) {
820
        int pict_type;
821

822 823
        *got_packet = 1;

824
        if (xvid_enc_stats.type == XVID_TYPE_PVOP)
825
            pict_type = AV_PICTURE_TYPE_P;
826
        else if (xvid_enc_stats.type == XVID_TYPE_BVOP)
827
            pict_type = AV_PICTURE_TYPE_B;
828
        else if (xvid_enc_stats.type == XVID_TYPE_SVOP)
829
            pict_type = AV_PICTURE_TYPE_S;
830
        else
831 832 833 834 835 836
            pict_type = AV_PICTURE_TYPE_I;

#if FF_API_CODED_FRAME
FF_DISABLE_DEPRECATION_WARNINGS
        avctx->coded_frame->pict_type = pict_type;
        avctx->coded_frame->quality = xvid_enc_stats.quant * FF_QP2LAMBDA;
837 838
FF_ENABLE_DEPRECATION_WARNINGS
#endif
839 840 841

        ff_side_data_set_encoder_stats(pkt, xvid_enc_stats.quant * FF_QP2LAMBDA, NULL, 0, pict_type);

842
        if (xvid_enc_frame.out_flags & XVID_KEYFRAME) {
843 844
#if FF_API_CODED_FRAME
FF_DISABLE_DEPRECATION_WARNINGS
845
            avctx->coded_frame->key_frame = 1;
846 847
FF_ENABLE_DEPRECATION_WARNINGS
#endif
848 849
            pkt->flags  |= AV_PKT_FLAG_KEY;
            if (x->quicktime_format)
850
                return xvid_strip_vol_header(avctx, pkt,
851
                                             xvid_enc_stats.hlength, xerr);
852
        } else {
853 854
#if FF_API_CODED_FRAME
FF_DISABLE_DEPRECATION_WARNINGS
855
            avctx->coded_frame->key_frame = 0;
856 857
FF_ENABLE_DEPRECATION_WARNINGS
#endif
858
        }
859

860 861 862
        pkt->size = xerr;

        return 0;
863
    } else {
864
        if (!user_packet)
865
            av_packet_unref(pkt);
866 867
        if (!xerr)
            return 0;
868 869
        av_log(avctx, AV_LOG_ERROR,
               "Xvid: Encoding Error Occurred: %i\n", xerr);
870
        return AVERROR_EXTERNAL;
871 872 873
    }
}

874 875
static av_cold int xvid_encode_close(AVCodecContext *avctx)
{
876
    struct xvid_context *x = avctx->priv_data;
877

878
    if (x->encoder_handle) {
879
        xvid_encore(x->encoder_handle, XVID_ENC_DESTROY, NULL, NULL);
880 881
        x->encoder_handle = NULL;
    }
882

883
    av_freep(&avctx->extradata);
884
    if (x->twopassbuffer) {
885 886
        av_freep(&x->twopassbuffer);
        av_freep(&x->old_twopassbuffer);
887
        avctx->stats_out = NULL;
888
    }
889 890 891 892 893
    if (x->twopassfd>=0) {
        unlink(x->twopassfile);
        close(x->twopassfd);
        x->twopassfd = -1;
    }
894 895 896
    av_freep(&x->twopassfile);
    av_freep(&x->intra_matrix);
    av_freep(&x->inter_matrix);
897 898 899 900

    return 0;
}

901 902 903
#define OFFSET(x) offsetof(struct xvid_context, x)
#define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
static const AVOption options[] = {
904 905 906 907 908 909 910 911
    { "lumi_aq",     "Luminance masking AQ",            OFFSET(lumi_aq),     AV_OPT_TYPE_INT,   { .i64 = 0 },       0,       1, VE         },
    { "variance_aq", "Variance AQ",                     OFFSET(variance_aq), AV_OPT_TYPE_INT,   { .i64 = 0 },       0,       1, VE         },
    { "ssim",        "Show SSIM information to stdout", OFFSET(ssim),        AV_OPT_TYPE_INT,   { .i64 = 0 },       0,       2, VE, "ssim" },
    { "off",         NULL,                                                0, AV_OPT_TYPE_CONST, { .i64 = 0 }, INT_MIN, INT_MAX, VE, "ssim" },
    { "avg",         NULL,                                                0, AV_OPT_TYPE_CONST, { .i64 = 1 }, INT_MIN, INT_MAX, VE, "ssim" },
    { "frame",       NULL,                                                0, AV_OPT_TYPE_CONST, { .i64 = 2 }, INT_MIN, INT_MAX, VE, "ssim" },
    { "ssim_acc",    "SSIM accuracy",                   OFFSET(ssim_acc),    AV_OPT_TYPE_INT,   { .i64 = 2 },       0,       4, VE         },
    { "gmc",         "use GMC",                         OFFSET(gmc),         AV_OPT_TYPE_INT,   { .i64 = 0 },       0,       1, VE         },
912
    { "me_quality",  "Motion estimation quality",       OFFSET(me_quality),  AV_OPT_TYPE_INT,   { .i64 = 4 },       0,       6, VE         },
913
    { "mpeg_quant",  "Use MPEG quantizers instead of H.263", OFFSET(mpeg_quant), AV_OPT_TYPE_INT, { .i64 = 0 },     0,       1, VE         },
914 915 916 917 918 919 920 921 922 923
    { NULL },
};

static const AVClass xvid_class = {
    .class_name = "libxvid",
    .item_name  = av_default_item_name,
    .option     = options,
    .version    = LIBAVUTIL_VERSION_INT,
};

924
AVCodec ff_libxvid_encoder = {
925
    .name           = "libxvid",
926
    .long_name      = NULL_IF_CONFIG_SMALL("libxvidcore MPEG-4 part 2"),
927
    .type           = AVMEDIA_TYPE_VIDEO,
928
    .id             = AV_CODEC_ID_MPEG4,
929 930
    .priv_data_size = sizeof(struct xvid_context),
    .init           = xvid_encode_init,
931
    .encode2        = xvid_encode_frame,
932
    .close          = xvid_encode_close,
933
    .pix_fmts       = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
934
    .priv_class     = &xvid_class,
935 936
    .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE |
                      FF_CODEC_CAP_INIT_CLEANUP,
937
    .wrapper_name   = "libxvid",
938
};