git.sesse.net Git - ffmpeg/blob - libavcodec/libxvid.c

   1 /*
   2  * Interface to xvidcore for mpeg4 encoding
   3  * Copyright (c) 2004 Adam Thayer <krevnik@comcast.net>
   4  *
   5  * This file is part of Libav.
   6  *
   7  * Libav is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * Libav is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with Libav; 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  * Interface to xvidcore for MPEG-4 compliant encoding.
  25  * @author Adam Thayer (krevnik@comcast.net)
  26  */
  27
  28 #include <unistd.h>
  29 #include <xvid.h>
  30
  31 #include "libavutil/cpu.h"
  32 #include "libavutil/intreadwrite.h"
  33 #include "libavutil/mathematics.h"
  34
  35 #include "avcodec.h"
  36 #include "libxvid.h"
  37 #include "mpegvideo.h"
  38
  39 /**
  40  * Buffer management macros.
  41  */
  42 #define BUFFER_SIZE         1024
  43 #define BUFFER_REMAINING(x) (BUFFER_SIZE - strlen(x))
  44 #define BUFFER_CAT(x)       (&((x)[strlen(x)]))
  45
  46 /**
  47  * Structure for the private Xvid context.
  48  * This stores all the private context for the codec.
  49  */
  50 struct xvid_context {
  51     AVClass *class;                /**< Handle for Xvid encoder */
  52     void *encoder_handle;          /**< Handle for Xvid encoder */
  53     int xsize;                     /**< Frame x size */
  54     int ysize;                     /**< Frame y size */
  55     int vop_flags;                 /**< VOP flags for Xvid encoder */
  56     int vol_flags;                 /**< VOL flags for Xvid encoder */
  57     int me_flags;                  /**< Motion Estimation flags */
  58     int qscale;                    /**< Do we use constant scale? */
  59     int quicktime_format;          /**< Are we in a QT-based format? */
  60     char *twopassbuffer;           /**< Character buffer for two-pass */
  61     char *old_twopassbuffer;       /**< Old character buffer (two-pass) */
  62     char *twopassfile;             /**< second pass temp file name */
  63     unsigned char *intra_matrix;   /**< P-Frame Quant Matrix */
  64     unsigned char *inter_matrix;   /**< I-Frame Quant Matrix */
  65     int lumi_aq;                   /**< Lumi masking as an aq method */
  66     int variance_aq;               /**< Variance adaptive quantization */
  67     int ssim;                      /**< SSIM information display mode */
  68     int ssim_acc;                  /**< SSIM accuracy. 0: accurate. 4: fast. */
  69     int gmc;
  70 };
  71
  72 /**
  73  * Structure for the private first-pass plugin.
  74  */
  75 struct xvid_ff_pass1 {
  76     int version;                    /**< Xvid version */
  77     struct xvid_context *context;   /**< Pointer to private context */
  78 };
  79
  80 /*
  81  * Xvid 2-Pass Kludge Section
  82  *
  83  * Xvid's default 2-pass doesn't allow us to create data as we need to, so
  84  * this section spends time replacing the first pass plugin so we can write
  85  * statistic information as libavcodec requests in. We have another kludge
  86  * that allows us to pass data to the second pass in Xvid without a custom
  87  * rate-control plugin.
  88  */
  89
  90 /**
  91  * Initialize the two-pass plugin and context.
  92  *
  93  * @param param Input construction parameter structure
  94  * @param handle Private context handle
  95  * @return Returns XVID_ERR_xxxx on failure, or 0 on success.
  96  */
  97 static int xvid_ff_2pass_create(xvid_plg_create_t *param, void **handle)
  98 {
  99     struct xvid_ff_pass1 *x = (struct xvid_ff_pass1 *) param->param;
 100     char *log = x->context->twopassbuffer;
 101
 102     /* Do a quick bounds check */
 103     if (!log)
 104         return XVID_ERR_FAIL;
 105
 106     /* We use snprintf() */
 107     /* This is because we can safely prevent a buffer overflow */
 108     log[0] = 0;
 109     snprintf(log, BUFFER_REMAINING(log),
 110              "# avconv 2-pass log file, using xvid codec\n");
 111     snprintf(BUFFER_CAT(log), BUFFER_REMAINING(log),
 112              "# Do not modify. libxvidcore version: %d.%d.%d\n\n",
 113              XVID_VERSION_MAJOR(XVID_VERSION),
 114              XVID_VERSION_MINOR(XVID_VERSION),
 115              XVID_VERSION_PATCH(XVID_VERSION));
 116
 117     *handle = x->context;
 118     return 0;
 119 }
 120
 121 /**
 122  * Destroy the two-pass plugin context.
 123  *
 124  * @param ref Context pointer for the plugin
 125  * @param param Destrooy context
 126  * @return Returns 0, success guaranteed
 127  */
 128 static int xvid_ff_2pass_destroy(struct xvid_context *ref,
 129                                  xvid_plg_destroy_t *param)
 130 {
 131     /* Currently cannot think of anything to do on destruction */
 132     /* Still, the framework should be here for reference/use */
 133     if (ref->twopassbuffer)
 134         ref->twopassbuffer[0] = 0;
 135     return 0;
 136 }
 137
 138 /**
 139  * Enable fast encode mode during the first pass.
 140  *
 141  * @param ref Context pointer for the plugin
 142  * @param param Frame data
 143  * @return Returns 0, success guaranteed
 144  */
 145 static int xvid_ff_2pass_before(struct xvid_context *ref,
 146                                 xvid_plg_data_t *param)
 147 {
 148     int motion_remove;
 149     int motion_replacements;
 150     int vop_remove;
 151
 152     /* Nothing to do here, result is changed too much */
 153     if (param->zone && param->zone->mode == XVID_ZONE_QUANT)
 154         return 0;
 155
 156     /* We can implement a 'turbo' first pass mode here */
 157     param->quant = 2;
 158
 159     /* Init values */
 160     motion_remove       = ~XVID_ME_CHROMA_PVOP &
 161                           ~XVID_ME_CHROMA_BVOP &
 162                           ~XVID_ME_EXTSEARCH16 &
 163                           ~XVID_ME_ADVANCEDDIAMOND16;
 164     motion_replacements = XVID_ME_FAST_MODEINTERPOLATE |
 165                           XVID_ME_SKIP_DELTASEARCH     |
 166                           XVID_ME_FASTREFINE16         |
 167                           XVID_ME_BFRAME_EARLYSTOP;
 168     vop_remove          = ~XVID_VOP_MODEDECISION_RD      &
 169                           ~XVID_VOP_FAST_MODEDECISION_RD &
 170                           ~XVID_VOP_TRELLISQUANT         &
 171                           ~XVID_VOP_INTER4V              &
 172                           ~XVID_VOP_HQACPRED;
 173
 174     param->vol_flags    &= ~XVID_VOL_GMC;
 175     param->vop_flags    &= vop_remove;
 176     param->motion_flags &= motion_remove;
 177     param->motion_flags |= motion_replacements;
 178
 179     return 0;
 180 }
 181
 182 /**
 183  * Capture statistic data and write it during first pass.
 184  *
 185  * @param ref Context pointer for the plugin
 186  * @param param Statistic data
 187  * @return Returns XVID_ERR_xxxx on failure, or 0 on success
 188  */
 189 static int xvid_ff_2pass_after(struct xvid_context *ref,
 190                                xvid_plg_data_t *param)
 191 {
 192     char *log = ref->twopassbuffer;
 193     const char *frame_types = " ipbs";
 194     char frame_type;
 195
 196     /* Quick bounds check */
 197     if (!log)
 198         return XVID_ERR_FAIL;
 199
 200     /* Convert the type given to us into a character */
 201     if (param->type < 5 && param->type > 0)
 202         frame_type = frame_types[param->type];
 203     else
 204         return XVID_ERR_FAIL;
 205
 206     snprintf(BUFFER_CAT(log), BUFFER_REMAINING(log),
 207              "%c %d %d %d %d %d %d\n",
 208              frame_type, param->stats.quant, param->stats.kblks,
 209              param->stats.mblks, param->stats.ublks,
 210              param->stats.length, param->stats.hlength);
 211
 212     return 0;
 213 }
 214
 215 /**
 216  * Dispatch function for our custom plugin.
 217  * This handles the dispatch for the Xvid plugin. It passes data
 218  * on to other functions for actual processing.
 219  *
 220  * @param ref Context pointer for the plugin
 221  * @param cmd The task given for us to complete
 222  * @param p1 First parameter (varies)
 223  * @param p2 Second parameter (varies)
 224  * @return Returns XVID_ERR_xxxx on failure, or 0 on success
 225  */
 226 static int xvid_ff_2pass(void *ref, int cmd, void *p1, void *p2)
 227 {
 228     switch (cmd) {
 229     case XVID_PLG_INFO:
 230     case XVID_PLG_FRAME:
 231         return 0;
 232     case XVID_PLG_BEFORE:
 233         return xvid_ff_2pass_before(ref, p1);
 234     case XVID_PLG_CREATE:
 235         return xvid_ff_2pass_create(p1, p2);
 236     case XVID_PLG_AFTER:
 237         return xvid_ff_2pass_after(ref, p1);
 238     case XVID_PLG_DESTROY:
 239         return xvid_ff_2pass_destroy(ref, p1);
 240     default:
 241         return XVID_ERR_FAIL;
 242     }
 243 }
 244
 245 /**
 246  * Routine to create a global VO/VOL header for MP4 container.
 247  * What we do here is extract the header from the Xvid bitstream
 248  * as it is encoded. We also strip the repeated headers from the
 249  * bitstream when a global header is requested for MPEG-4 ISO
 250  * compliance.
 251  *
 252  * @param avctx AVCodecContext pointer to context
 253  * @param frame Pointer to encoded frame data
 254  * @param header_len Length of header to search
 255  * @param frame_len Length of encoded frame data
 256  * @return Returns new length of frame data
 257  */
 258 static int xvid_strip_vol_header(AVCodecContext *avctx, AVPacket *pkt,
 259                                  unsigned int header_len,
 260                                  unsigned int frame_len)
 261 {
 262     int vo_len = 0, i;
 263
 264     for (i = 0; i < header_len - 3; i++) {
 265         if (pkt->data[i]     == 0x00 &&
 266             pkt->data[i + 1] == 0x00 &&
 267             pkt->data[i + 2] == 0x01 &&
 268             pkt->data[i + 3] == 0xB6) {
 269             vo_len = i;
 270             break;
 271         }
 272     }
 273
 274     if (vo_len > 0) {
 275         /* We need to store the header, so extract it */
 276         if (!avctx->extradata) {
 277             avctx->extradata = av_malloc(vo_len);
 278             memcpy(avctx->extradata, pkt->data, vo_len);
 279             avctx->extradata_size = vo_len;
 280         }
 281         /* Less dangerous now, memmove properly copies the two
 282          * chunks of overlapping data */
 283         memmove(pkt->data, &pkt->data[vo_len], frame_len - vo_len);
 284         pkt->size = frame_len - vo_len;
 285     }
 286     return 0;
 287 }
 288
 289 /**
 290  * Routine to correct a possibly erroneous framerate being fed to us.
 291  * Xvid currently chokes on framerates where the ticks per frame is
 292  * extremely large. This function works to correct problems in this area
 293  * by estimating a new framerate and taking the simpler fraction of
 294  * the two presented.
 295  *
 296  * @param avctx Context that contains the framerate to correct.
 297  */
 298 static void xvid_correct_framerate(AVCodecContext *avctx)
 299 {
 300     int frate, fbase;
 301     int est_frate, est_fbase;
 302     int gcd;
 303     float est_fps, fps;
 304
 305     frate = avctx->time_base.den;
 306     fbase = avctx->time_base.num;
 307
 308     gcd = av_gcd(frate, fbase);
 309     if (gcd > 1) {
 310         frate /= gcd;
 311         fbase /= gcd;
 312     }
 313
 314     if (frate <= 65000 && fbase <= 65000) {
 315         avctx->time_base.den = frate;
 316         avctx->time_base.num = fbase;
 317         return;
 318     }
 319
 320     fps     = (float) frate / (float) fbase;
 321     est_fps = roundf(fps * 1000.0) / 1000.0;
 322
 323     est_frate = (int) est_fps;
 324     if (est_fps > (int) est_fps) {
 325         est_frate = (est_frate + 1) * 1000;
 326         est_fbase = (int) roundf((float) est_frate / est_fps);
 327     } else
 328         est_fbase = 1;
 329
 330     gcd = av_gcd(est_frate, est_fbase);
 331     if (gcd > 1) {
 332         est_frate /= gcd;
 333         est_fbase /= gcd;
 334     }
 335
 336     if (fbase > est_fbase) {
 337         avctx->time_base.den = est_frate;
 338         avctx->time_base.num = est_fbase;
 339         av_log(avctx, AV_LOG_DEBUG,
 340                "Xvid: framerate re-estimated: %.2f, %.3f%% correction\n",
 341                est_fps, (((est_fps - fps) / fps) * 100.0));
 342     } else {
 343         avctx->time_base.den = frate;
 344         avctx->time_base.num = fbase;
 345     }
 346 }
 347
 348 static av_cold int xvid_encode_init(AVCodecContext *avctx)
 349 {
 350     int xerr, i;
 351     int xvid_flags = avctx->flags;
 352     struct xvid_context *x = avctx->priv_data;
 353     uint16_t *intra, *inter;
 354     int fd;
 355
 356     xvid_plugin_single_t single         = { 0 };
 357     struct xvid_ff_pass1 rc2pass1       = { 0 };
 358     xvid_plugin_2pass2_t rc2pass2       = { 0 };
 359     xvid_plugin_lumimasking_t masking_l = { 0 }; /* For lumi masking */
 360     xvid_plugin_lumimasking_t masking_v = { 0 }; /* For variance AQ */
 361     xvid_plugin_ssim_t ssim             = { 0 };
 362     xvid_gbl_init_t xvid_gbl_init       = { 0 };
 363     xvid_enc_create_t xvid_enc_create   = { 0 };
 364     xvid_enc_plugin_t plugins[7];
 365
 366     /* Bring in VOP flags from avconv command-line */
 367     x->vop_flags = XVID_VOP_HALFPEL; /* Bare minimum quality */
 368     if (xvid_flags & CODEC_FLAG_4MV)
 369         x->vop_flags |= XVID_VOP_INTER4V; /* Level 3 */
 370     if (avctx->trellis)
 371         x->vop_flags |= XVID_VOP_TRELLISQUANT; /* Level 5 */
 372     if (xvid_flags & CODEC_FLAG_AC_PRED)
 373         x->vop_flags |= XVID_VOP_HQACPRED; /* Level 6 */
 374     if (xvid_flags & CODEC_FLAG_GRAY)
 375         x->vop_flags |= XVID_VOP_GREYSCALE;
 376
 377     /* Decide which ME quality setting to use */
 378     x->me_flags = 0;
 379     switch (avctx->me_method) {
 380     case ME_FULL:   /* Quality 6 */
 381         x->me_flags |= XVID_ME_EXTSEARCH16 |
 382                        XVID_ME_EXTSEARCH8;
 383
 384     case ME_EPZS:   /* Quality 4 */
 385         x->me_flags |= XVID_ME_ADVANCEDDIAMOND8 |
 386                        XVID_ME_HALFPELREFINE8   |
 387                        XVID_ME_CHROMA_PVOP      |
 388                        XVID_ME_CHROMA_BVOP;
 389
 390     case ME_LOG:    /* Quality 2 */
 391     case ME_PHODS:
 392     case ME_X1:
 393         x->me_flags |= XVID_ME_ADVANCEDDIAMOND16 |
 394                        XVID_ME_HALFPELREFINE16;
 395
 396     case ME_ZERO:   /* Quality 0 */
 397     default:
 398         break;
 399     }
 400
 401     /* Decide how we should decide blocks */
 402     switch (avctx->mb_decision) {
 403     case 2:
 404         x->vop_flags |=  XVID_VOP_MODEDECISION_RD;
 405         x->me_flags  |=  XVID_ME_HALFPELREFINE8_RD    |
 406                          XVID_ME_QUARTERPELREFINE8_RD |
 407                          XVID_ME_EXTSEARCH_RD         |
 408                          XVID_ME_CHECKPREDICTION_RD;
 409     case 1:
 410         if (!(x->vop_flags & XVID_VOP_MODEDECISION_RD))
 411             x->vop_flags |= XVID_VOP_FAST_MODEDECISION_RD;
 412         x->me_flags |= XVID_ME_HALFPELREFINE16_RD |
 413                        XVID_ME_QUARTERPELREFINE16_RD;
 414     default:
 415         break;
 416     }
 417
 418     /* Bring in VOL flags from avconv command-line */
 419 #if FF_API_GMC
 420     if (avctx->flags & CODEC_FLAG_GMC)
 421         x->gmc = 1;
 422 #endif
 423
 424     x->vol_flags = 0;
 425     if (x->gmc) {
 426         x->vol_flags |= XVID_VOL_GMC;
 427         x->me_flags  |= XVID_ME_GME_REFINE;
 428     }
 429     if (xvid_flags & CODEC_FLAG_QPEL) {
 430         x->vol_flags |= XVID_VOL_QUARTERPEL;
 431         x->me_flags  |= XVID_ME_QUARTERPELREFINE16;
 432         if (x->vop_flags & XVID_VOP_INTER4V)
 433             x->me_flags |= XVID_ME_QUARTERPELREFINE8;
 434     }
 435
 436     xvid_gbl_init.version   = XVID_VERSION;
 437     xvid_gbl_init.debug     = 0;
 438     xvid_gbl_init.cpu_flags = 0;
 439
 440     /* Initialize */
 441     xvid_global(NULL, XVID_GBL_INIT, &xvid_gbl_init, NULL);
 442
 443     /* Create the encoder reference */
 444     xvid_enc_create.version = XVID_VERSION;
 445
 446     /* Store the desired frame size */
 447     xvid_enc_create.width  =
 448     x->xsize               = avctx->width;
 449     xvid_enc_create.height =
 450     x->ysize               = avctx->height;
 451
 452     /* Xvid can determine the proper profile to use */
 453     /* xvid_enc_create.profile = XVID_PROFILE_S_L3; */
 454
 455     /* We don't use zones */
 456     xvid_enc_create.zones     = NULL;
 457     xvid_enc_create.num_zones = 0;
 458
 459     xvid_enc_create.num_threads = avctx->thread_count;
 460
 461     xvid_enc_create.plugins     = plugins;
 462     xvid_enc_create.num_plugins = 0;
 463
 464     /* Initialize Buffers */
 465     x->twopassbuffer     = NULL;
 466     x->old_twopassbuffer = NULL;
 467     x->twopassfile       = NULL;
 468
 469     if (xvid_flags & CODEC_FLAG_PASS1) {
 470         rc2pass1.version     = XVID_VERSION;
 471         rc2pass1.context     = x;
 472         x->twopassbuffer     = av_malloc(BUFFER_SIZE);
 473         x->old_twopassbuffer = av_malloc(BUFFER_SIZE);
 474         if (!x->twopassbuffer || !x->old_twopassbuffer) {
 475             av_log(avctx, AV_LOG_ERROR,
 476                    "Xvid: Cannot allocate 2-pass log buffers\n");
 477             return AVERROR(ENOMEM);
 478         }
 479         x->twopassbuffer[0]     =
 480         x->old_twopassbuffer[0] = 0;
 481
 482         plugins[xvid_enc_create.num_plugins].func  = xvid_ff_2pass;
 483         plugins[xvid_enc_create.num_plugins].param = &rc2pass1;
 484         xvid_enc_create.num_plugins++;
 485     } else if (xvid_flags & CODEC_FLAG_PASS2) {
 486         rc2pass2.version = XVID_VERSION;
 487         rc2pass2.bitrate = avctx->bit_rate;
 488
 489         fd = ff_tempfile("xvidff.", &x->twopassfile);
 490         if (fd < 0) {
 491             av_log(avctx, AV_LOG_ERROR, "Xvid: Cannot write 2-pass pipe\n");
 492             return fd;
 493         }
 494
 495         if (!avctx->stats_in) {
 496             av_log(avctx, AV_LOG_ERROR,
 497                    "Xvid: No 2-pass information loaded for second pass\n");
 498             return AVERROR_INVALIDDATA;
 499         }
 500
 501         if (strlen(avctx->stats_in) >
 502             write(fd, avctx->stats_in, strlen(avctx->stats_in))) {
 503             close(fd);
 504             av_log(avctx, AV_LOG_ERROR, "Xvid: Cannot write to 2-pass pipe\n");
 505             return AVERROR(EIO);
 506         }
 507
 508         close(fd);
 509         rc2pass2.filename                          = x->twopassfile;
 510         plugins[xvid_enc_create.num_plugins].func  = xvid_plugin_2pass2;
 511         plugins[xvid_enc_create.num_plugins].param = &rc2pass2;
 512         xvid_enc_create.num_plugins++;
 513     } else if (!(xvid_flags & CODEC_FLAG_QSCALE)) {
 514         /* Single Pass Bitrate Control! */
 515         single.version = XVID_VERSION;
 516         single.bitrate = avctx->bit_rate;
 517
 518         plugins[xvid_enc_create.num_plugins].func  = xvid_plugin_single;
 519         plugins[xvid_enc_create.num_plugins].param = &single;
 520         xvid_enc_create.num_plugins++;
 521     }
 522
 523     if (avctx->lumi_masking != 0.0)
 524         x->lumi_aq = 1;
 525
 526     if (x->lumi_aq && x->variance_aq) {
 527         x->variance_aq = 0;
 528         av_log(avctx, AV_LOG_WARNING,
 529                "variance_aq is ignored when lumi_aq is set.\n");
 530     }
 531
 532     /* Luminance Masking */
 533     if (x->lumi_aq) {
 534         masking_l.method                          = 0;
 535         plugins[xvid_enc_create.num_plugins].func = xvid_plugin_lumimasking;
 536
 537         /* The old behavior is that when avctx->lumi_masking is specified,
 538          * plugins[...].param = NULL. Trying to keep the old behavior here. */
 539         plugins[xvid_enc_create.num_plugins].param =
 540             avctx->lumi_masking ? NULL : &masking_l;
 541         xvid_enc_create.num_plugins++;
 542     }
 543
 544     /* Variance AQ */
 545     if (x->variance_aq) {
 546         masking_v.method                           = 1;
 547         plugins[xvid_enc_create.num_plugins].func  = xvid_plugin_lumimasking;
 548         plugins[xvid_enc_create.num_plugins].param = &masking_v;
 549         xvid_enc_create.num_plugins++;
 550     }
 551
 552     /* SSIM */
 553     if (x->ssim) {
 554         plugins[xvid_enc_create.num_plugins].func  = xvid_plugin_ssim;
 555         ssim.b_printstat                           = x->ssim == 2;
 556         ssim.acc                                   = x->ssim_acc;
 557         ssim.cpu_flags                             = xvid_gbl_init.cpu_flags;
 558         ssim.b_visualize                           = 0;
 559         plugins[xvid_enc_create.num_plugins].param = &ssim;
 560         xvid_enc_create.num_plugins++;
 561     }
 562
 563     /* Frame Rate and Key Frames */
 564     xvid_correct_framerate(avctx);
 565     xvid_enc_create.fincr = avctx->time_base.num;
 566     xvid_enc_create.fbase = avctx->time_base.den;
 567     if (avctx->gop_size > 0)
 568         xvid_enc_create.max_key_interval = avctx->gop_size;
 569     else
 570         xvid_enc_create.max_key_interval = 240; /* Xvid's best default */
 571
 572     /* Quants */
 573     if (xvid_flags & CODEC_FLAG_QSCALE)
 574         x->qscale = 1;
 575     else
 576         x->qscale = 0;
 577
 578     xvid_enc_create.min_quant[0] = avctx->qmin;
 579     xvid_enc_create.min_quant[1] = avctx->qmin;
 580     xvid_enc_create.min_quant[2] = avctx->qmin;
 581     xvid_enc_create.max_quant[0] = avctx->qmax;
 582     xvid_enc_create.max_quant[1] = avctx->qmax;
 583     xvid_enc_create.max_quant[2] = avctx->qmax;
 584
 585     /* Quant Matrices */
 586     x->intra_matrix =
 587     x->inter_matrix = NULL;
 588     if (avctx->mpeg_quant)
 589         x->vol_flags |= XVID_VOL_MPEGQUANT;
 590     if ((avctx->intra_matrix || avctx->inter_matrix)) {
 591         x->vol_flags |= XVID_VOL_MPEGQUANT;
 592
 593         if (avctx->intra_matrix) {
 594             intra           = avctx->intra_matrix;
 595             x->intra_matrix = av_malloc(sizeof(unsigned char) * 64);
 596         } else
 597             intra = NULL;
 598         if (avctx->inter_matrix) {
 599             inter           = avctx->inter_matrix;
 600             x->inter_matrix = av_malloc(sizeof(unsigned char) * 64);
 601         } else
 602             inter = NULL;
 603
 604         for (i = 0; i < 64; i++) {
 605             if (intra)
 606                 x->intra_matrix[i] = (unsigned char) intra[i];
 607             if (inter)
 608                 x->inter_matrix[i] = (unsigned char) inter[i];
 609         }
 610     }
 611
 612     /* Misc Settings */
 613     xvid_enc_create.frame_drop_ratio = 0;
 614     xvid_enc_create.global           = 0;
 615     if (xvid_flags & CODEC_FLAG_CLOSED_GOP)
 616         xvid_enc_create.global |= XVID_GLOBAL_CLOSED_GOP;
 617
 618     /* Determines which codec mode we are operating in */
 619     avctx->extradata      = NULL;
 620     avctx->extradata_size = 0;
 621     if (xvid_flags & CODEC_FLAG_GLOBAL_HEADER) {
 622         /* In this case, we are claiming to be MPEG4 */
 623         x->quicktime_format = 1;
 624         avctx->codec_id     = AV_CODEC_ID_MPEG4;
 625     } else {
 626         /* We are claiming to be Xvid */
 627         x->quicktime_format = 0;
 628         if (!avctx->codec_tag)
 629             avctx->codec_tag = AV_RL32("xvid");
 630     }
 631
 632     /* Bframes */
 633     xvid_enc_create.max_bframes   = avctx->max_b_frames;
 634     xvid_enc_create.bquant_offset = 100 * avctx->b_quant_offset;
 635     xvid_enc_create.bquant_ratio  = 100 * avctx->b_quant_factor;
 636     if (avctx->max_b_frames > 0 && !x->quicktime_format)
 637         xvid_enc_create.global |= XVID_GLOBAL_PACKED;
 638
 639     /* Create encoder context */
 640     xerr = xvid_encore(NULL, XVID_ENC_CREATE, &xvid_enc_create, NULL);
 641     if (xerr) {
 642         av_log(avctx, AV_LOG_ERROR, "Xvid: Could not create encoder reference\n");
 643         return -1;
 644     }
 645
 646     x->encoder_handle  = xvid_enc_create.handle;
 647     avctx->coded_frame = av_frame_alloc();
 648     if (!avctx->coded_frame)
 649         return AVERROR(ENOMEM);
 650
 651     return 0;
 652 }
 653
 654 static int xvid_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
 655                              const AVFrame *picture, int *got_packet)
 656 {
 657     int xerr, i, ret, user_packet = !!pkt->data;
 658     struct xvid_context *x = avctx->priv_data;
 659     AVFrame *p             = avctx->coded_frame;
 660     int mb_width  = (avctx->width  + 15) / 16;
 661     int mb_height = (avctx->height + 15) / 16;
 662     char *tmp;
 663
 664     xvid_enc_frame_t xvid_enc_frame = { 0 };
 665     xvid_enc_stats_t xvid_enc_stats = { 0 };
 666
 667     if (!user_packet &&
 668         (ret = av_new_packet(pkt, mb_width * mb_height * MAX_MB_BYTES + FF_MIN_BUFFER_SIZE)) < 0) {
 669         av_log(avctx, AV_LOG_ERROR, "Error getting output packet.\n");
 670         return ret;
 671     }
 672
 673     /* Start setting up the frame */
 674     xvid_enc_frame.version = XVID_VERSION;
 675     xvid_enc_stats.version = XVID_VERSION;
 676
 677     /* Let Xvid know where to put the frame. */
 678     xvid_enc_frame.bitstream = pkt->data;
 679     xvid_enc_frame.length    = pkt->size;
 680
 681     /* Initialize input image fields */
 682     if (avctx->pix_fmt != AV_PIX_FMT_YUV420P) {
 683         av_log(avctx, AV_LOG_ERROR,
 684                "Xvid: Color spaces other than 420P not supported\n");
 685         return -1;
 686     }
 687
 688     xvid_enc_frame.input.csp = XVID_CSP_PLANAR; /* YUV420P */
 689
 690     for (i = 0; i < 4; i++) {
 691         xvid_enc_frame.input.plane[i]  = picture->data[i];
 692         xvid_enc_frame.input.stride[i] = picture->linesize[i];
 693     }
 694
 695     /* Encoder Flags */
 696     xvid_enc_frame.vop_flags = x->vop_flags;
 697     xvid_enc_frame.vol_flags = x->vol_flags;
 698     xvid_enc_frame.motion    = x->me_flags;
 699     xvid_enc_frame.type      =
 700         picture->pict_type == AV_PICTURE_TYPE_I ? XVID_TYPE_IVOP :
 701         picture->pict_type == AV_PICTURE_TYPE_P ? XVID_TYPE_PVOP :
 702         picture->pict_type == AV_PICTURE_TYPE_B ? XVID_TYPE_BVOP :
 703                                                   XVID_TYPE_AUTO;
 704
 705     /* Pixel aspect ratio setting */
 706     if (avctx->sample_aspect_ratio.num < 1 || avctx->sample_aspect_ratio.num > 255 ||
 707         avctx->sample_aspect_ratio.den < 1 || avctx->sample_aspect_ratio.den > 255) {
 708         av_log(avctx, AV_LOG_ERROR, "Invalid pixel aspect ratio %i/%i\n",
 709                avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den);
 710         return -1;
 711     }
 712     xvid_enc_frame.par        = XVID_PAR_EXT;
 713     xvid_enc_frame.par_width  = avctx->sample_aspect_ratio.num;
 714     xvid_enc_frame.par_height = avctx->sample_aspect_ratio.den;
 715
 716     /* Quant Setting */
 717     if (x->qscale)
 718         xvid_enc_frame.quant = picture->quality / FF_QP2LAMBDA;
 719     else
 720         xvid_enc_frame.quant = 0;
 721
 722     /* Matrices */
 723     xvid_enc_frame.quant_intra_matrix = x->intra_matrix;
 724     xvid_enc_frame.quant_inter_matrix = x->inter_matrix;
 725
 726     /* Encode */
 727     xerr = xvid_encore(x->encoder_handle, XVID_ENC_ENCODE,
 728                        &xvid_enc_frame, &xvid_enc_stats);
 729
 730     /* Two-pass log buffer swapping */
 731     avctx->stats_out = NULL;
 732     if (x->twopassbuffer) {
 733         tmp                  = x->old_twopassbuffer;
 734         x->old_twopassbuffer = x->twopassbuffer;
 735         x->twopassbuffer     = tmp;
 736         x->twopassbuffer[0]  = 0;
 737         if (x->old_twopassbuffer[0] != 0) {
 738             avctx->stats_out = x->old_twopassbuffer;
 739         }
 740     }
 741
 742     if (xerr > 0) {
 743         *got_packet = 1;
 744
 745         p->quality = xvid_enc_stats.quant * FF_QP2LAMBDA;
 746         if (xvid_enc_stats.type == XVID_TYPE_PVOP)
 747             p->pict_type = AV_PICTURE_TYPE_P;
 748         else if (xvid_enc_stats.type == XVID_TYPE_BVOP)
 749             p->pict_type = AV_PICTURE_TYPE_B;
 750         else if (xvid_enc_stats.type == XVID_TYPE_SVOP)
 751             p->pict_type = AV_PICTURE_TYPE_S;
 752         else
 753             p->pict_type = AV_PICTURE_TYPE_I;
 754         if (xvid_enc_frame.out_flags & XVID_KEYFRAME) {
 755             p->key_frame = 1;
 756             pkt->flags  |= AV_PKT_FLAG_KEY;
 757             if (x->quicktime_format)
 758                 return xvid_strip_vol_header(avctx, pkt,
 759                                              xvid_enc_stats.hlength, xerr);
 760         } else
 761             p->key_frame = 0;
 762
 763         pkt->size = xerr;
 764
 765         return 0;
 766     } else {
 767         if (!user_packet)
 768             av_free_packet(pkt);
 769         if (!xerr)
 770             return 0;
 771         av_log(avctx, AV_LOG_ERROR,
 772                "Xvid: Encoding Error Occurred: %i\n", xerr);
 773         return xerr;
 774     }
 775 }
 776
 777 static av_cold int xvid_encode_close(AVCodecContext *avctx)
 778 {
 779     struct xvid_context *x = avctx->priv_data;
 780
 781     xvid_encore(x->encoder_handle, XVID_ENC_DESTROY, NULL, NULL);
 782
 783     av_freep(&avctx->extradata);
 784     if (x->twopassbuffer) {
 785         av_free(x->twopassbuffer);
 786         av_free(x->old_twopassbuffer);
 787     }
 788     av_free(x->twopassfile);
 789     av_free(x->intra_matrix);
 790     av_free(x->inter_matrix);
 791
 792     return 0;
 793 }
 794
 795 #define OFFSET(x) offsetof(struct xvid_context, x)
 796 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
 797 static const AVOption options[] = {
 798     { "lumi_aq",     "Luminance masking AQ",            OFFSET(lumi_aq),     AV_OPT_TYPE_INT,   { .i64 = 0 },       0,       1, VE         },
 799     { "variance_aq", "Variance AQ",                     OFFSET(variance_aq), AV_OPT_TYPE_INT,   { .i64 = 0 },       0,       1, VE         },
 800     { "ssim",        "Show SSIM information to stdout", OFFSET(ssim),        AV_OPT_TYPE_INT,   { .i64 = 0 },       0,       2, VE, "ssim" },
 801     { "off",         NULL,                                                0, AV_OPT_TYPE_CONST, { .i64 = 0 }, INT_MIN, INT_MAX, VE, "ssim" },
 802     { "avg",         NULL,                                                0, AV_OPT_TYPE_CONST, { .i64 = 1 }, INT_MIN, INT_MAX, VE, "ssim" },
 803     { "frame",       NULL,                                                0, AV_OPT_TYPE_CONST, { .i64 = 2 }, INT_MIN, INT_MAX, VE, "ssim" },
 804     { "ssim_acc",    "SSIM accuracy",                   OFFSET(ssim_acc),    AV_OPT_TYPE_INT,   { .i64 = 2 },       0,       4, VE         },
 805     { "gmc",         "use GMC",                         OFFSET(gmc),         AV_OPT_TYPE_INT,   { .i64 = 0 },       0,       1, VE         },
 806     { NULL },
 807 };
 808
 809 static const AVClass xvid_class = {
 810     .class_name = "libxvid",
 811     .item_name  = av_default_item_name,
 812     .option     = options,
 813     .version    = LIBAVUTIL_VERSION_INT,
 814 };
 815
 816 AVCodec ff_libxvid_encoder = {
 817     .name           = "libxvid",
 818     .long_name      = NULL_IF_CONFIG_SMALL("libxvidcore MPEG-4 part 2"),
 819     .type           = AVMEDIA_TYPE_VIDEO,
 820     .id             = AV_CODEC_ID_MPEG4,
 821     .priv_data_size = sizeof(struct xvid_context),
 822     .init           = xvid_encode_init,
 823     .encode2        = xvid_encode_frame,
 824     .close          = xvid_encode_close,
 825     .pix_fmts       = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
 826     .priv_class     = &xvid_class,
 827 };