/*
 * Copyright (c) 2016, Alliance for Open Media. All rights reserved
 *
 * This source code is subject to the terms of the BSD 2 Clause License and
 * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
 * was not distributed with this source code in the LICENSE file, you can
 * obtain it at www.aomedia.org/license/software. If the Alliance for Open
 * Media Patent License 1.0 was not distributed with this source code in the
 * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
 */

#include "av1/common/cfl.h"
#include "av1/common/common_data.h"

// CfL computes its own block-level DC_PRED. This is required to compute both
// alpha_cb and alpha_cr before the prediction are computed.
void cfl_dc_pred(MACROBLOCKD *xd, BLOCK_SIZE plane_bsize, TX_SIZE tx_size) {
  const struct macroblockd_plane *const pd_cb = &xd->plane[AOM_PLANE_U];
  const struct macroblockd_plane *const pd_cr = &xd->plane[AOM_PLANE_V];

  const uint8_t *const dst_cb = pd_cb->dst.buf;
  const uint8_t *const dst_cr = pd_cr->dst.buf;

  const int dst_cb_stride = pd_cb->dst.stride;
  const int dst_cr_stride = pd_cr->dst.stride;

  const int block_width = (plane_bsize != BLOCK_INVALID)
                              ? block_size_wide[plane_bsize]
                              : tx_size_wide[tx_size];
  const int block_height = (plane_bsize != BLOCK_INVALID)
                               ? block_size_high[plane_bsize]
                               : tx_size_high[tx_size];
  const int num_pel = block_width + block_height;

  int sum_cb = 0;
  int sum_cr = 0;

  // Match behavior of build_intra_predictors (reconintra.c) at superblock
  // boundaries:
  //
  // 127 127 127 .. 127 127 127 127 127 127
  // 129  A   B  ..  Y   Z
  // 129  C   D  ..  W   X
  // 129  E   F  ..  U   V
  // 129  G   H  ..  S   T   T   T   T   T
  // ..

  // TODO(ltrudeau) replace this with DC_PRED assembly
  if (xd->up_available && xd->mb_to_right_edge >= 0) {
    for (int i = 0; i < block_width; i++) {
      sum_cb += dst_cb[-dst_cb_stride + i];
      sum_cr += dst_cr[-dst_cr_stride + i];
    }
  } else {
    sum_cb = block_width * 127;
    sum_cr = block_width * 127;
  }

  if (xd->left_available && xd->mb_to_bottom_edge >= 0) {
    for (int i = 0; i < block_height; i++) {
      sum_cb += dst_cb[i * dst_cb_stride - 1];
      sum_cr += dst_cr[i * dst_cr_stride - 1];
    }
  } else {
    sum_cb += block_height * 129;
    sum_cr += block_height * 129;
  }

  xd->cfl->dc_pred[CFL_PRED_U] = (sum_cb + (num_pel >> 1)) / num_pel;
  xd->cfl->dc_pred[CFL_PRED_V] = (sum_cr + (num_pel >> 1)) / num_pel;
}

// Predict the current transform block using CfL.
// it is assumed that dst points at the start of the transform block
void cfl_predict_block(uint8_t *dst, int dst_stride, TX_SIZE tx_size,
                       int dc_pred) {
  const int tx_block_width = tx_size_wide[tx_size];
  const int tx_block_height = tx_size_high[tx_size];

  for (int j = 0; j < tx_block_height; j++) {
    for (int i = 0; i < tx_block_width; i++) {
      dst[i] = dc_pred;
    }
    dst += dst_stride;
  }
}

void cfl_store(CFL_CTX *cfl, const uint8_t *input, int input_stride, int row,
               int col, TX_SIZE tx_size) {
  const int tx_width = tx_size_wide[tx_size];
  const int tx_height = tx_size_high[tx_size];
  const int tx_off_log2 = tx_size_wide_log2[0];

  // Store the input into the CfL pixel buffer
  uint8_t *y_pix = &cfl->y_pix[(row * MAX_SB_SIZE + col) << tx_off_log2];

  // Check that we remain inside the pixel buffer.
  assert(MAX_SB_SIZE * (row + tx_height - 1) + col + tx_width - 1 <
         MAX_SB_SQUARE);

  for (int j = 0; j < tx_height; j++) {
    for (int i = 0; i < tx_width; i++) {
      y_pix[i] = input[i];
    }
    y_pix += MAX_SB_SIZE;
    input += input_stride;
  }

  // Store the surface of the pixel buffer that was written to, this way we
  // can manage chroma overrun (e.g. when the chroma surfaces goes beyond the
  // frame boundary)
  if (col == 0 && row == 0) {
    cfl->y_width = tx_width;
    cfl->y_height = tx_height;
  } else {
    cfl->y_width = OD_MAXI((col << tx_off_log2) + tx_width, cfl->y_width);
    cfl->y_height = OD_MAXI((row << tx_off_log2) + tx_height, cfl->y_height);
  }
}