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
#include "packet_internal.h"
46

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

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

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

/**
63
 * Structure for the private Xvid context.
64 65
 * This stores all the private context for the codec.
 */
66
struct xvid_context {
67
    AVClass *class;
68 69 70 71 72 73 74 75 76 77 78
    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 */
79
    int twopassfd;
80 81
    unsigned char *intra_matrix;   /**< P-Frame Quant Matrix */
    unsigned char *inter_matrix;   /**< I-Frame Quant Matrix */
82 83
    int lumi_aq;                   /**< Lumi masking as an aq method */
    int variance_aq;               /**< Variance adaptive quantization */
84 85
    int ssim;                      /**< SSIM information display mode */
    int ssim_acc;                  /**< SSIM accuracy. 0: accurate. 4: fast. */
86
    int gmc;
87
    int me_quality;                /**< Motion estimation quality. 0: fast 6: best. */
88
    int mpeg_quant;                /**< Quantization type. 0: H.263, 1: MPEG */
89
};
90

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

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

103

104 105 106 107 108 109 110 111 112
/*
 * 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.
 */
113 114

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

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

130 131 132 133
    /* We use snprintf() */
    /* This is because we can safely prevent a buffer overflow */
    log[0] = 0;
    snprintf(log, BUFFER_REMAINING(log),
134
             "# ffmpeg 2-pass log file, using xvid codec\n");
135
    snprintf(BUFFER_CAT(log), BUFFER_REMAINING(log),
136 137 138 139
             "# 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));
140

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

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

162 163 164 165 166 167 168 169
/**
 * 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,
170 171
                                xvid_plg_data_t *param)
{
172 173 174
    int motion_remove;
    int motion_replacements;
    int vop_remove;
175

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

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

183
    /* Init values */
184 185 186 187
    motion_remove       = ~XVID_ME_CHROMA_PVOP &
                          ~XVID_ME_CHROMA_BVOP &
                          ~XVID_ME_EXTSEARCH16 &
                          ~XVID_ME_ADVANCEDDIAMOND16;
188
    motion_replacements = XVID_ME_FAST_MODEINTERPOLATE |
189 190
                          XVID_ME_SKIP_DELTASEARCH     |
                          XVID_ME_FASTREFINE16         |
191
                          XVID_ME_BFRAME_EARLYSTOP;
192 193 194 195 196 197 198 199
    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;
200 201
    param->motion_flags &= motion_remove;
    param->motion_flags |= motion_replacements;
202

203 204
    return 0;
}
205

206 207 208 209 210 211 212 213
/**
 * 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,
214 215
                               xvid_plg_data_t *param)
{
216 217 218
    char *log = ref->twopassbuffer;
    const char *frame_types = " ipbs";
    char frame_type;
219

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

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

230
    snprintf(BUFFER_CAT(log), BUFFER_REMAINING(log),
231 232 233 234
             "%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);
235

236 237
    return 0;
}
238

239 240 241 242 243 244 245 246 247 248 249 250 251
/**
 * 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)
{
252 253 254 255 256 257 258 259 260 261 262 263 264 265
    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;
266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281
    }
}

/**
 * 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
 */
282 283 284 285
static int xvid_strip_vol_header(AVCodecContext *avctx, AVPacket *pkt,
                                 unsigned int header_len,
                                 unsigned int frame_len)
{
286 287
    int vo_len = 0, i;

288 289 290 291 292
    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) {
293 294 295 296 297
            vo_len = i;
            break;
        }
    }

298
    if (vo_len > 0) {
299
        /* We need to store the header, so extract it */
300
        if (!avctx->extradata) {
301
            avctx->extradata = av_malloc(vo_len);
302 303
            if (!avctx->extradata)
                return AVERROR(ENOMEM);
304 305 306 307
            memcpy(avctx->extradata, pkt->data, vo_len);
            avctx->extradata_size = vo_len;
        }
        /* Less dangerous now, memmove properly copies the two
308
         * chunks of overlapping data */
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 334
        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);
335
    if (gcd > 1) {
336 337 338 339
        frate /= gcd;
        fbase /= gcd;
    }

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

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

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

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

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

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

382 383 384 385 386 387 388 389
    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 };
390
    xvid_enc_plugin_t         plugins[4];
391

392 393
    x->twopassfd = -1;

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

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

    /* Decide how we should decide blocks */
425 426 427 428 429 430 431 432 433 434 435 436 437 438
    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;
439 440
    }

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

454 455
    xvid_gbl_init.version   = XVID_VERSION;
    xvid_gbl_init.debug     = 0;
456 457 458 459 460 461 462 463 464
    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 */
465 466 467 468
    xvid_enc_create.width  =
    x->xsize               = avctx->width;
    xvid_enc_create.height =
    x->ysize               = avctx->height;
469 470 471 472 473

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

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

    xvid_enc_create.num_threads = avctx->thread_count;
478 479 480 481 482 483 484 485
#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.");
486
            return AVERROR(EINVAL);
487 488 489
        }
    }
#endif
490

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

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

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

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

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

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

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

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

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

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

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

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

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

579
    if (x->lumi_aq && x->variance_aq )
580 581 582 583
        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");

584
    /* SSIM */
585
    if (x->ssim) {
586 587 588 589 590
        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;
591 592 593 594
        plugins[xvid_enc_create.num_plugins].param = &ssim;
        xvid_enc_create.num_plugins++;
    }

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

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

610 611 612 613 614 615
    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;
616

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

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

    if (x->mpeg_quant)
629 630 631 632 633 634 635
        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);
636 637
            if (!x->intra_matrix)
                return AVERROR(ENOMEM);
638 639 640 641 642
        } else
            intra = NULL;
        if (avctx->inter_matrix) {
            inter           = avctx->inter_matrix;
            x->inter_matrix = av_malloc(sizeof(unsigned char) * 64);
643 644
            if (!x->inter_matrix)
                return AVERROR(ENOMEM);
645 646 647 648 649 650 651 652 653
        } 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];
        }
654
    }
655

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

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

676
    /* Bframes */
677
    xvid_enc_create.max_bframes   = avctx->max_b_frames;
678
    xvid_enc_create.bquant_offset = 100 * avctx->b_quant_offset;
679 680 681
    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;
682

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

685 686 687
    /* Encode a dummy frame to get the extradata immediately */
    if (x->quicktime_format) {
        AVFrame *picture;
688
        AVPacket packet = {0};
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 721
        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);
    }

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

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

    return 0;
}

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

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

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

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

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

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

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

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

771 772 773
    /* Encoder Flags */
    xvid_enc_frame.vop_flags = x->vop_flags;
    xvid_enc_frame.vol_flags = x->vol_flags;
774 775
    xvid_enc_frame.motion    = x->me_flags;
    xvid_enc_frame.type      =
776 777 778
        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 :
779
                                                  XVID_TYPE_AUTO;
780

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

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

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

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

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

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

823 824
        *got_packet = 1;

825
        if (xvid_enc_stats.type == XVID_TYPE_PVOP)
826
            pict_type = AV_PICTURE_TYPE_P;
827
        else if (xvid_enc_stats.type == XVID_TYPE_BVOP)
828
            pict_type = AV_PICTURE_TYPE_B;
829
        else if (xvid_enc_stats.type == XVID_TYPE_SVOP)
830
            pict_type = AV_PICTURE_TYPE_S;
831
        else
832 833 834 835 836 837
            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;
838 839
FF_ENABLE_DEPRECATION_WARNINGS
#endif
840 841 842

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

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

861 862 863
        pkt->size = xerr;

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

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

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

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

    return 0;
}

902 903 904
#define OFFSET(x) offsetof(struct xvid_context, x)
#define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
static const AVOption options[] = {
905 906 907 908 909 910 911 912
    { "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         },
913
    { "me_quality",  "Motion estimation quality",       OFFSET(me_quality),  AV_OPT_TYPE_INT,   { .i64 = 4 },       0,       6, VE         },
914
    { "mpeg_quant",  "Use MPEG quantizers instead of H.263", OFFSET(mpeg_quant), AV_OPT_TYPE_INT, { .i64 = 0 },     0,       1, VE         },
915 916 917 918 919 920 921 922 923 924
    { NULL },
};

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

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