/* Copyright 2014 The Chromium OS Authors. All rights reserved.
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */

#include "rk_vp8encapi.h"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "enccommon.h"
#include "vp8encapi.h"
#include "vp8instance.h"
#include "libvpu/rk_vepu_debug.h"
#include "libvpu/vp8_enc/vpu_mem.h"

/* Value for parameter to use API default */
#define DEFAULT -100

/* Intermediate Video File Format */
#define IVF_HDR_BYTES       32
#define IVF_FRM_BYTES       12

#define PRIVATE_DATA_HEADER_SIZE  192

static int rk_vp8_encoder_after_encode(struct rk_vp8_encoder *enc,
                                      uint32_t outputStreamSize);
static int rk_vp8_encoder_before_encode(struct rk_vp8_encoder *enc);
static int rk_vp8_encoder_init(struct rk_vp8_encoder *enc,
                               struct rk_vepu_init_param *enc_parms);
static void rk_vp8_encoder_genpriv(struct rk_vp8_encoder *enc);
static void rk_vp8_encoder_getpriv(struct rk_vp8_encoder *enc,
                                   uint8_t **priv_data, uint32_t *size);
static void rk_vp8_encoder_setconfig(struct rk_vp8_encoder *enc,
                                     struct rk_vepu_runtime_param *param);
static void rk_vp8_encoder_store_priv_data(struct rk_vp8_encoder *enc,
                                          uint8_t *priv, uint32_t size,
                                          int32_t type);
static int rk_vp8_encoder_updatepriv(struct rk_vp8_encoder *enc,
                                     void *config, uint32_t cfglen);
static int OpenEncoder(EncoderParameters* cml, VP8EncInst* pEnc);
static void CloseEncoder(VP8EncInst encoder);
static void MaAddFrame(ma_s* ma, int32_t frameSizeBits);
static int32_t Ma(ma_s* ma);
static void SetDefaultParameter(EncoderParameters* tb);


static int rk_vp8_encoder_init(struct rk_vp8_encoder *enc,
                              struct rk_vepu_init_param *enc_parms) {
  EncoderParameters* cml = &enc->cmdl;

  SetDefaultParameter(cml);

  /* modify parameters using input encode setting */
  cml->lumWidthSrc = enc_parms->width;
  cml->lumHeightSrc = enc_parms->height;
  cml->width = enc_parms->width;
  cml->height = enc_parms->height;

  switch (enc_parms->input_format) {
    case V4L2_PIX_FMT_YUV420:
    case V4L2_PIX_FMT_YUV420M:
      cml->inputFormat = VP8ENC_YUV420_PLANAR;
      break;
    case V4L2_PIX_FMT_NV12:
    case V4L2_PIX_FMT_NV12M:
      cml->inputFormat = VP8ENC_YUV420_SEMIPLANAR;
      break;
    case V4L2_PIX_FMT_YUYV:
      cml->inputFormat = VP8ENC_YUV422_INTERLEAVED_YUYV;
      break;
    case V4L2_PIX_FMT_UYVY:
      cml->inputFormat = VP8ENC_YUV422_INTERLEAVED_UYVY;
      break;
    default:
      VPU_PLG_ERR("Unsupport format 0x%08x\n", enc_parms->input_format);
      return -1;
  }

  /* Encoder initialization */
  if (OpenEncoder(cml, &enc->encoder) != 0)
    return -1;

  /* First frame is always intra with zero time increment */
  enc->encIn.codingType = VP8ENC_INTRA_FRAME;
  enc->encIn.timeIncrement = 0;

  enc->priv_data = (uint8_t *)calloc(1, 5487);
  if (enc->priv_data == NULL) {
    VPU_PLG_ERR("allocate private data buffer failed\n");
    CloseEncoder(enc->encoder);
    return -1;
  }

  enc->hdr_idx = 0;
  enc->priv_offset = 0;
  return 0;
}

static void rk_vp8_encoder_setconfig(struct rk_vp8_encoder *enc,
                                    struct rk_vepu_runtime_param *param)
{
  int ret;
  VP8EncRateCtrl rc;
  bool reset = false;

  VP8EncGetRateCtrl(enc->encoder, &rc);

  if (param->framerate_denom != 0 && param->framerate_numer != 0 &&
      (param->framerate_denom != rc.outRateDenom ||
       param->framerate_numer != rc.outRateNum)) {
    rc.outRateNum = param->framerate_numer;
    rc.outRateDenom = param->framerate_denom;
    enc->cmdl.outputRateNumer = param->framerate_numer;
    enc->cmdl.outputRateDenom = param->framerate_denom;
    reset = true;
  }

  if (param->bitrate != 0 && param->bitrate != rc.bitPerSecond) {
    rc.bitPerSecond = param->bitrate;
    rc.pictureRc = ENCHW_YES;
    rc.qpHdr = -1;
    reset = true;
  }

  if (reset) {
    VPU_PLG_INF("Reset bitrate calculation parameters\n");
    enc->cmdl.streamSize = 0;
    enc->cmdl.frameCntTotal = 0;
    ret = VP8EncSetRateCtrl(enc->encoder, &rc);
    if (ret < 0) {
      VPU_PLG_ERR("failed to set rate control\n");
    }
  }

  if (param->keyframe_request) {
    enc->cmdl.keyframeRequest = true;
  }
}

static int rk_vp8_encoder_after_encode(struct rk_vp8_encoder *enc,
                                      uint32_t outputStreamSize) {
  VP8EncRet ret;
  EncoderParameters* cml = &enc->cmdl;

  ret = VP8EncStrmEncodeResult(enc->encoder, &cml->encOut, outputStreamSize);

  VP8EncGetRateCtrl(enc->encoder, &cml->rc);

  cml->streamSize += cml->encOut.frameSize;

  MaAddFrame(&cml->ma, cml->encOut.frameSize * 8);

  enc->encIn.timeIncrement = cml->outputRateDenom;

  cml->frameCnt++;
  cml->frameCntTotal++;

  if (cml->encOut.codingType != VP8ENC_NOTCODED_FRAME) {
    enc->intraPeriodCnt++;
    enc->codedFrameCnt++;
  }

  /* calculate the bitrate using output stream size. */
  if ((cml->frameCntTotal + 1) && cml->outputRateDenom) {
    /* Using 64-bits to avoid overflow */
    uint64_t tmp = cml->streamSize / (cml->frameCntTotal + 1);
    tmp *= (uint32_t)cml->outputRateNumer;

    cml->bitrate = (uint32_t)(8 * (tmp / (uint32_t)cml->outputRateDenom));
  }

  /* Print information about encoded frames */
  VPU_PLG_INF("\nBitrate target %d bps, actual %d bps (%d%%).\n",
              cml->rc.bitPerSecond, cml->bitrate,
              (cml->rc.bitPerSecond) ?
              cml->bitrate * 100 / cml->rc.bitPerSecond : 0);
  VPU_PLG_INF("Total of %llu frames processed, %d frames encoded, %d bytes.\n",
              cml->frameCntTotal, enc->codedFrameCnt, cml->streamSize);

  if (cml->psnrCnt)
    VPU_PLG_INF("Average PSNR %d.%02d\n",
                (cml->psnrSum / cml->psnrCnt) / 100,
                (cml->psnrSum / cml->psnrCnt) % 100);

  return ret;
}

static int rk_vp8_encoder_before_encode(struct rk_vp8_encoder *enc) {
  int ret = 0;
  EncoderParameters* cml = &enc->cmdl;

  cml->ma.pos = cml->ma.count = 0;
  cml->ma.frameRateNumer = cml->outputRateNumer;
  cml->ma.frameRateDenom = cml->outputRateDenom;
  if (cml->outputRateDenom)
    cml->ma.length = MAX(1, MIN(cml->outputRateNumer / cml->outputRateDenom,
                                MOVING_AVERAGE_FRAMES));
  else
    cml->ma.length = MOVING_AVERAGE_FRAMES;

  /* Source Image Size */
  if (cml->inputFormat <= 1) {
    enc->src_img_size = cml->lumWidthSrc * cml->lumHeightSrc +
        2 * (((cml->lumWidthSrc + 1) >> 1) *
             ((cml->lumHeightSrc + 1) >> 1));
  } else if ((cml->inputFormat <= 9) || (cml->inputFormat == 14)) {
    /* 422 YUV or 16-bit RGB */
    enc->src_img_size = cml->lumWidthSrc * cml->lumHeightSrc * 2;
  } else {
    /* 32-bit RGB */
    enc->src_img_size = cml->lumWidthSrc * cml->lumHeightSrc * 4;
  }

  if (VP8EncGetRateCtrl(enc->encoder, &cml->rc) < 0) {
    VPU_PLG_ERR("VP8 Get Rate Control failed\n");
    return -1;
  }

  /* Code keyframe according to intra period counter
   * or if requested by client. */
  if (cml->keyframeRequest ||
      (cml->intraPicRate != 0 &&
       enc->intraPeriodCnt >= cml->intraPicRate)) {
    enc->encIn.codingType = VP8ENC_INTRA_FRAME;
    enc->intraPeriodCnt = 0;
    cml->keyframeRequest = false;
  } else {
    enc->encIn.codingType = VP8ENC_PREDICTED_FRAME;
  }

  /* This applies for PREDICTED frames only. By default always predict
   * from the previous frame only. */
  enc->encIn.ipf = VP8ENC_REFERENCE_AND_REFRESH;
  enc->encIn.grf = enc->encIn.arf = VP8ENC_REFERENCE;

  /* Encode one frame */
  ret = VP8EncStrmEncode(enc->encoder, &enc->encIn, &cml->encOut, cml);
  if (ret < 0) {
    VPU_PLG_ERR("Generate Encoder configuration failed\n");
    return -1;
  }

  VP8EncGetFrameHeader(enc->encoder, (uint8_t**)&enc->rk_payloads[0],
                       &enc->rk_payload_sizes[0]);
  VP8EncGetRegs(enc->encoder, (uint32_t**)&enc->rk_payloads[1],
                &enc->rk_payload_sizes[1]);
  rk_vp8_encoder_getpriv(
      enc, (uint8_t**)&enc->rk_payloads[2], &enc->rk_payload_sizes[2]);
  return 0;
}

static void rk_vp8_encoder_store_priv_data(struct rk_vp8_encoder *enc,
                                          uint8_t *priv, uint32_t size,
                                          int32_t type) {
  uint32_t* hdr = (uint32_t*)enc->priv_data;
  uint8_t* data = (uint8_t*)enc->priv_data + PRIVATE_DATA_HEADER_SIZE;

  VPU_PLG_DBG("store type %02x, size %02x\n", type, size);
  enc->priv_offset = (enc->priv_offset + 7) & (~7);

  hdr[enc->hdr_idx++] = type;
  hdr[enc->hdr_idx++] = size;
  hdr[enc->hdr_idx++] = enc->priv_offset;

  memcpy(data + enc->priv_offset, priv, size);
  enc->priv_offset += size;
}

static void rk_vp8_encoder_genpriv(struct rk_vp8_encoder *enc) {
  uint8_t *priv;
  uint32_t size;

  enc->hdr_idx = 0;
  enc->priv_offset = 0;
  VP8EncGetCabacCtx(enc->encoder, &priv, &size);
  rk_vp8_encoder_store_priv_data(enc, priv, size, VP8E_PRIVATE_DATA_TYPE_CABAC);
  VP8EncGetSegmentMap(enc->encoder, &priv, &size);
  rk_vp8_encoder_store_priv_data(enc, priv, size, VP8E_PRIVATE_DATA_TYPE_SEGMAP);
  rk_vp8_encoder_store_priv_data(enc, NULL, 0, VP8E_PRIVATE_DATA_TYPE_END);
}

static void rk_vp8_encoder_getpriv(struct rk_vp8_encoder *enc,
                                 uint8_t **priv_data, uint32_t *size) {
  rk_vp8_encoder_genpriv(enc);
  *priv_data = enc->priv_data;
  *size = 5487;
}

static int rk_vp8_encoder_updatepriv(struct rk_vp8_encoder *enc,
                                    void *config, uint32_t cfglen) {
  return VP8EncSetProbCnt(enc->encoder, (uint8_t *)config, cfglen);
}

static void rk_vp8_encoder_deinit(struct rk_vp8_encoder *enc) {
  free(enc->priv_data);
  enc->priv_data = NULL;
  CloseEncoder(enc->encoder);
}

/*----------------------------------------------------------------------------

    OpenEncoder
        Create and configure an encoder instance.

    Params:
        cml     - processed command line options
        pEnc    - place where to save the new encoder instance
    Return:
        0   - for success
        -1  - error

-----------------------------------------------------------------------------*/
static int OpenEncoder(EncoderParameters* cml, VP8EncInst* pEnc) {
  VP8EncRet ret;
  VP8EncConfig cfg;
  VP8EncCodingCtrl codingCfg;
  VP8EncRateCtrl rcCfg;

  VP8EncInst encoder;

  /* input resolution == encoded resolution if not defined */
  if (cml->width == DEFAULT)
    cml->width = cml->lumWidthSrc;
  if (cml->height == DEFAULT)
    cml->height = cml->lumHeightSrc;

  if (cml->rotation) {
    cfg.width = cml->height;
    cfg.height = cml->width;
  } else {
    cfg.width = cml->width;
    cfg.height = cml->height;
  }

  cfg.frameRateDenom = cml->outputRateDenom;
  cfg.frameRateNum = cml->outputRateNumer;
  cfg.refFrameAmount = cml->refFrameAmount;

  VPU_PLG_DBG("Init config: size %dx%d   %d/%d fps  %d refFrames\n",
         cfg.width, cfg.height, cfg.frameRateNum, cfg.frameRateDenom,
         cfg.refFrameAmount);

  if ((ret = VP8EncInit(&cfg, pEnc)) != VP8ENC_OK) {
    VPU_PLG_ERR("VP8EncInit() failed. ret %d\n", ret);
    return ret;
  }

  encoder = *pEnc;

  /* Encoder setup: rate control */
  if ((ret = VP8EncGetRateCtrl(encoder, &rcCfg)) != VP8ENC_OK) {
    VPU_PLG_ERR("VP8EncGetRateCtrl() failed. ret %d\n", ret);
    CloseEncoder(encoder);
    return -1;
  }

  VPU_PLG_INF("Get rate control: qp=%2d [%2d..%2d] %8d bps,"
              " picRc=%d gop=%d\n",
              rcCfg.qpHdr, rcCfg.qpMin, rcCfg.qpMax, rcCfg.bitPerSecond,
              rcCfg.pictureRc, rcCfg.bitrateWindow);

  if (cml->picRc != DEFAULT)
    rcCfg.pictureRc = cml->picRc;
  if (cml->picSkip != DEFAULT)
    rcCfg.pictureSkip = cml->picSkip;
  if (cml->qpHdr != DEFAULT)
    rcCfg.qpHdr = cml->qpHdr;
  if (cml->qpMin != DEFAULT)
    rcCfg.qpMin = cml->qpMin;
  if (cml->qpMax != DEFAULT)
    rcCfg.qpMax = cml->qpMax;
  if (cml->bitPerSecond != DEFAULT)
    rcCfg.bitPerSecond = cml->bitPerSecond;
  if (cml->gopLength != DEFAULT)
    rcCfg.bitrateWindow = cml->gopLength;
  if (cml->intraQpDelta != DEFAULT)
    rcCfg.intraQpDelta = cml->intraQpDelta;
  if (cml->fixedIntraQp != DEFAULT)
    rcCfg.fixedIntraQp = cml->fixedIntraQp;

  VPU_PLG_DBG("Set rate control: qp=%2d [%2d..%2d] %8d bps,"
         " picRc=%d gop=%d\n",
         rcCfg.qpHdr, rcCfg.qpMin, rcCfg.qpMax, rcCfg.bitPerSecond,
         rcCfg.pictureRc, rcCfg.bitrateWindow);

  if ((ret = VP8EncSetRateCtrl(encoder, &rcCfg)) != VP8ENC_OK) {
    VPU_PLG_ERR("VP8EncSetRateCtrl() failed. ret %d\n", ret);
    CloseEncoder(encoder);
    return -1;
  }

  /* Encoder setup: coding control */
  if ((ret = VP8EncGetCodingCtrl(encoder, &codingCfg)) != VP8ENC_OK) {
    VPU_PLG_ERR("VP8EncGetCodingCtrl() failed. ret %d\n", ret);
    CloseEncoder(encoder);
    return -1;
  }

  if (cml->dctPartitions != DEFAULT)
    codingCfg.dctPartitions = cml->dctPartitions;
  if (cml->errorResilient != DEFAULT)
    codingCfg.errorResilient = cml->errorResilient;
  if (cml->ipolFilter != DEFAULT)
    codingCfg.interpolationFilter = cml->ipolFilter;
  if (cml->filterType != DEFAULT)
    codingCfg.filterType = cml->filterType;
  if (cml->filterLevel != DEFAULT)
    codingCfg.filterLevel = cml->filterLevel;
  if (cml->filterSharpness != DEFAULT)
    codingCfg.filterSharpness = cml->filterSharpness;
  if (cml->quarterPixelMv != DEFAULT)
    codingCfg.quarterPixelMv = cml->quarterPixelMv;
  if (cml->splitMv != DEFAULT)
    codingCfg.splitMv = cml->splitMv;

  codingCfg.cirStart = cml->cirStart;
  codingCfg.cirInterval = cml->cirInterval;
  codingCfg.intraArea.enable = cml->intraAreaEnable;
  codingCfg.intraArea.top = cml->intraAreaTop;
  codingCfg.intraArea.left = cml->intraAreaLeft;
  codingCfg.intraArea.bottom = cml->intraAreaBottom;
  codingCfg.intraArea.right = cml->intraAreaRight;
  codingCfg.roi1Area.enable = cml->roi1AreaEnable;
  codingCfg.roi1Area.top = cml->roi1AreaTop;
  codingCfg.roi1Area.left = cml->roi1AreaLeft;
  codingCfg.roi1Area.bottom = cml->roi1AreaBottom;
  codingCfg.roi1Area.right = cml->roi1AreaRight;
  codingCfg.roi2Area.enable = cml->roi2AreaEnable;
  codingCfg.roi2Area.top = cml->roi2AreaTop;
  codingCfg.roi2Area.left = cml->roi2AreaLeft;
  codingCfg.roi2Area.bottom = cml->roi2AreaBottom;
  codingCfg.roi2Area.right = cml->roi2AreaRight;
  codingCfg.roi1DeltaQp = cml->roi1DeltaQp;
  codingCfg.roi2DeltaQp = cml->roi2DeltaQp;

  VPU_PLG_DBG("Set coding control: dctPartitions=%d ipolFilter=%d"
              " errorResilient=%d\n"
              " filterType=%d filterLevel=%d filterSharpness=%d"
              " quarterPixelMv=%d"
              " splitMv=%d\n",
              codingCfg.dctPartitions, codingCfg.interpolationFilter,
              codingCfg.errorResilient, codingCfg.filterType,
              codingCfg.filterLevel, codingCfg.filterSharpness,
              codingCfg.quarterPixelMv, codingCfg.splitMv);

  if (codingCfg.cirInterval)
    VPU_PLG_DBG("  CIR: %d %d\n",
                codingCfg.cirStart, codingCfg.cirInterval);

  if (codingCfg.intraArea.enable)
    VPU_PLG_DBG("  IntraArea: %dx%d-%dx%d\n",
                codingCfg.intraArea.left, codingCfg.intraArea.top,
                codingCfg.intraArea.right, codingCfg.intraArea.bottom);

  if (codingCfg.roi1Area.enable)
    VPU_PLG_DBG("  ROI 1: %d  %dx%d-%dx%d\n", codingCfg.roi1DeltaQp,
                codingCfg.roi1Area.left, codingCfg.roi1Area.top,
                codingCfg.roi1Area.right, codingCfg.roi1Area.bottom);

  if (codingCfg.roi2Area.enable)
    VPU_PLG_DBG("  ROI 2: %d  %dx%d-%dx%d\n", codingCfg.roi2DeltaQp,
                codingCfg.roi2Area.left, codingCfg.roi2Area.top,
                codingCfg.roi2Area.right, codingCfg.roi2Area.bottom);


  if ((ret = VP8EncSetCodingCtrl(encoder, &codingCfg)) != VP8ENC_OK) {
    VPU_PLG_ERR("VP8EncSetCodingCtrl() failed. ret %d\n", ret);
    CloseEncoder(encoder);
    return -1;
  }

  return 0;
}

/*------------------------------------------------------------------------------

    CloseEncoder
       Release an encoder insatnce.

   Params:
        encoder - the instance to be released
------------------------------------------------------------------------------*/
static void CloseEncoder(VP8EncInst encoder) {
  VP8EncRet ret;

  if ((ret = VP8EncRelease(encoder)) != VP8ENC_OK)
    VPU_PLG_ERR("VP8EncRelease() failed. ret %d\n", ret);
}

void SetDefaultParameter(EncoderParameters* cml) {
  memset(cml, 0, sizeof(EncoderParameters));

  /* Default setting tries to parse resolution from file name */

  /* Width of encoded output image */
  cml->width              = 176;
  /* Height of encoded output image */
  cml->height             = 144;
  /* Width of source image [176] */
  cml->lumWidthSrc        = 176;
  /* Height of source image [144] */
  cml->lumHeightSrc       = 144;
  /* Output image horizontal cropping offset [0] */
  cml->horOffsetSrc       = 0;
  /* Output image vertical cropping offset [0] */
  cml->verOffsetSrc       = 0;

  /* Input YUV format [1] */
  cml->inputFormat        = VP8ENC_YUV420_SEMIPLANAR;
  /* 1..1048575 Output picture rate numerator. [--inputRateNumer] */
  cml->outputRateNumer    = 30;
  /* 1..1048575 Output picture rate denominator. [--inputRateDenom] */
  cml->outputRateDenom    = 1;
  /* 1..3 Amount of buffered reference frames. [1] */
  cml->refFrameAmount     = 1;

  /* Default settings are get from API and not changed in testbench */

  /* RGB to YCbCr color conversion type. [0] */
  cml->colorConversion    = VP8ENC_RGBTOYUV_BT601;
  /* Enable video stabilization or scene change detection. [0] */
  cml->videoStab          = 0;
  /* Rotate input image. [0] */
  cml->rotation           = 0;

  /* -1..127, Initial QP used for the first frame. [36] */
  cml->qpHdr              = 36;
  /* 0..127, Minimum frame header QP. [10] */
  cml->qpMin              = 0;
  /* 0..127, Maximum frame header QP. [51] */
  cml->qpMax              = QINDEX_RANGE - 1;
  /* 10000..60000000, Target bitrate for rate control [1000000] */
  cml->bitPerSecond       = 1000000;
  /* 0=OFF, 1=ON, Picture rate control enable. [1] */
  cml->picRc              = 0;
  /* 0=OFF, 1=ON, Picture skip rate control. [0] */
  cml->picSkip            = 0;
  /* -12..12, Intra QP delta. [0] */
  cml->intraQpDelta       = 0;
  /* 0..127, Fixed Intra QP, 0 = disabled. [0] */
  cml->fixedIntraQp       = 0;

  /* Intra picture rate in frames. [0] */
  cml->intraPicRate       = 150;
  /* 1..300, Group Of Pictures length in frames. [--intraPicRate] */
  cml->gopLength          = cml->intraPicRate;
  /* 0=1, 1=2, 2=4, 3=8, Amount of DCT partitions to create */
  cml->dctPartitions      = 0;
  /* Enable error resilient stream mode. [0] */
  cml->errorResilient     = 0;
  /* 0=Bicubic, 1=Bilinear, 2=None, Interpolation filter mode. [1] */
  cml->ipolFilter         = 1;
  /* 0=Normal, 1=Simple, Type of in-loop deblocking filter. [0] */
  cml->filterType         = 0;
  /* 0..64, 64=auto, Filter strength level for deblocking. [64] */
  cml->filterLevel        = 64;
  /* 0..8, 8=auto, Filter sharpness for deblocking. [8] */
  cml->filterSharpness    = 8;
  /* 0=OFF, 1=Adaptive, 2=ON, use 1/4 pixel MVs. [1] */
  cml->quarterPixelMv     = 1;
  /* 0=OFF, 1=Adaptive, 2=ON, allowed to to use more than 1 MV/MB. [1] */
  cml->splitMv            = 1;

  /* start:interval for Cyclic Intra Refresh, forces MBs intra */
  cml->cirStart           = 0;
  /* start:interval for Cyclic Intra Refresh, forces MBs intra */
  cml->cirInterval        = 0;

  /* left:top:right:bottom macroblock coordinates */
  cml->intraAreaLeft      = 0;
  cml->intraAreaTop       = 0;
  cml->intraAreaRight     = 0;
  cml->intraAreaBottom    = 0;
  cml->intraAreaEnable    = 0;

  /* left:top:right:bottom macroblock coordinates */
  cml->roi1AreaLeft      = 0;
  cml->roi1AreaTop       = 0;
  cml->roi1AreaRight     = 0;
  cml->roi1AreaBottom    = 0;
  cml->roi1AreaEnable    = 0;
  cml->roi2AreaLeft      = 0;
  cml->roi2AreaTop       = 0;
  cml->roi2AreaRight     = 0;
  cml->roi2AreaBottom    = 0;
  cml->roi2AreaEnable    = 0;

  /* QP delta value for 1st Region-Of-Interest. [-50,0] */
  cml->roi1DeltaQp    = 0;
  cml->roi2DeltaQp    = 0;
  cml->roi1AreaEnable = cml->roi1DeltaQp;
  cml->roi2AreaEnable = cml->roi2DeltaQp;

  /* Enables PSNR calculation for each frame. [0] */
  cml->psnrSum        = 0;
  cml->psnrCnt        = 0;

  /* Enable MV writing in <mv.txt> [0] */
  cml->mvOutput           = 0;

  /* Favor value for I16x16 mode in I16/I4 */
  cml->intra16Favor       = 0;
  /* Penalty value for intra mode in intra/inter */
  cml->intraPenalty       = 0;
}

void PrintTitle(EncoderParameters* cml) {
  VPU_PLG_DBG("\n");
  VPU_PLG_DBG("Input | Pic |  QP | Type | IP GR AR |   "
         "BR avg    MA(%3d) | ByteCnt (inst) |",
         cml->ma.length);

  if (cml->printPsnr)
    VPU_PLG_DBG(" PSNR  |");

  VPU_PLG_DBG("\n");
  VPU_PLG_DBG("----------------------------------------"
         "-----------------------------------------\n");

  VPU_PLG_DBG("      |     | %3d | HDR  |          |   "
         "                  | %7i %6i |",
         cml->rc.qpHdr, cml->streamSize, IVF_HDR_BYTES);

  if (cml->printPsnr)
    VPU_PLG_DBG("       |");
  VPU_PLG_DBG("\n");
}

void PrintFrame(EncoderParameters* cml, VP8EncInst encoder,
                uint32_t frameNumber,
                VP8EncRet ret) {
  if ((cml->frameCntTotal + 1) && cml->outputRateDenom) {
    /* Using 64-bits to avoid overflow */
    uint64_t tmp = cml->streamSize / (cml->frameCntTotal + 1);
    tmp *= (uint32_t)cml->outputRateNumer;

    cml->bitrate = (uint32_t)(8 * (tmp / (uint32_t)cml->outputRateDenom));
  }

  VPU_PLG_DBG("%5i | %3llu | %3d | ",
         frameNumber, cml->frameCntTotal, cml->rc.qpHdr);

  VPU_PLG_DBG("%s",
         (ret == VP8ENC_OUTPUT_BUFFER_OVERFLOW) ?
         "lost" : (cml->encOut.codingType == VP8ENC_INTRA_FRAME) ? " I  " :
         (cml->encOut.codingType == VP8ENC_PREDICTED_FRAME) ? " P  " : "skip");

  /* Print reference frame usage */
  VPU_PLG_DBG(" | %c%c %c%c %c%c",
         cml->encOut.ipf & VP8ENC_REFERENCE ? 'R' : ' ',
         cml->encOut.ipf & VP8ENC_REFRESH   ? 'W' : ' ',
         cml->encOut.grf & VP8ENC_REFERENCE ? 'R' : ' ',
         cml->encOut.grf & VP8ENC_REFRESH   ? 'W' : ' ',
         cml->encOut.arf & VP8ENC_REFERENCE ? 'R' : ' ',
         cml->encOut.arf & VP8ENC_REFRESH   ? 'W' : ' ');

  /* Print bitrate statistics and frame size */
  VPU_PLG_DBG(" | %9u %9u | %7i %6i | ",
         cml->bitrate, Ma(&cml->ma), cml->streamSize, cml->encOut.frameSize);

  /* Print size of each partition in bytes */
  VPU_PLG_DBG("%d %d %d %d\n", cml->encOut.frameSize ? IVF_FRM_BYTES : 0,
         cml->encOut.streamSize[0],
         cml->encOut.streamSize[1], cml->encOut.streamSize[2]);

  /* Check that partition sizes match frame size */
  if (cml->encOut.frameSize != (cml->encOut.streamSize[0] +
                                cml->encOut.streamSize[1] +
                                cml->encOut.streamSize[2])) {
    VPU_PLG_DBG("ERROR: Frame size doesn't match partition sizes!\n");
  }
}

/*----------------------------------------------------------------------------
    Add new frame bits for moving average bitrate calculation
-----------------------------------------------------------------------------*/
static void MaAddFrame(ma_s* ma, int32_t frameSizeBits) {
  ma->frame[ma->pos++] = frameSizeBits;

  if (ma->pos == ma->length)
    ma->pos = 0;

  if (ma->count < ma->length)
    ma->count++;
}

/*----------------------------------------------------------------------------
    Calculate average bitrate of moving window
-----------------------------------------------------------------------------*/
static int32_t Ma(ma_s* ma) {
  int32_t i;
  uint64_t sum = 0;     /* Using 64-bits to avoid overflow */

  for (i = 0; i < ma->count; i++)
    sum += ma->frame[i];

  if (!ma->frameRateDenom)
    return 0;

  sum = sum / ma->length;

  return sum * ma->frameRateNumer / ma->frameRateDenom;
}

static struct rk_venc_ops vp8_enc_ops = {
  .init = rk_vp8_encoder_init,
  .before_encode = rk_vp8_encoder_before_encode,
  .after_encode = rk_vp8_encoder_after_encode,
  .deinit = rk_vp8_encoder_deinit,
  .updatepriv = rk_vp8_encoder_updatepriv,
  .updateparameter = rk_vp8_encoder_setconfig,
};

struct rk_vp8_encoder* rk_vp8_encoder_alloc_ctx(void)
{
  struct rk_vp8_encoder* enc =
    (struct rk_vp8_encoder*)calloc(1, sizeof(struct rk_vp8_encoder));

  if (enc == NULL) {
    VPU_PLG_ERR("allocate decoder context failed\n");
    return NULL;
  }

  enc->ops = &vp8_enc_ops;

  return enc;
}

void rk_vp8_encoder_free_ctx(struct rk_vp8_encoder *enc)
{
  free(enc);
}