/*****************************************************************************
 * This file is part of Kvazaar HEVC encoder.
 *
 * Copyright (C) 2013-2015 Tampere University of Technology and others (see
 * COPYING file).
 *
 * Kvazaar is free software: you can redistribute it and/or modify it under
 * the terms of the GNU Lesser General Public License as published by the
 * Free Software Foundation; either version 2.1 of the License, or (at your
 * option) any later version.
 *
 * Kvazaar is distributed in the hope that it will be useful, 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 General Public License along
 * with Kvazaar.  If not, see <http://www.gnu.org/licenses/>.
 ****************************************************************************/

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

#include "cu.h"
#include "threads.h"

/**
 * \brief Number of PUs in a CU.
 *
 * Indexed by part_mode_t values.
 */
const uint8_t kvz_part_mode_num_parts[] = {
  1, // 2Nx2N
  2, // 2NxN
  2, // Nx2N
  4, // NxN
  2, // 2NxnU
  2, // 2NxnD
  2, // nLx2N
  2, // nRx2N
};

/**
 * \brief PU offsets.
 *
 * Indexed by [part mode][PU number][axis].
 *
 * Units are 1/4 of the width of the CU.
 */
const uint8_t kvz_part_mode_offsets[][4][2] = {
  { {0, 0}                         }, // 2Nx2N
  { {0, 0}, {0, 2}                 }, // 2NxN
  { {0, 0}, {2, 0}                 }, // Nx2N
  { {0, 0}, {2, 0}, {0, 2}, {2, 2} }, // NxN
  { {0, 0}, {0, 1}                 }, // 2NxnU
  { {0, 0}, {0, 3}                 }, // 2NxnD
  { {0, 0}, {1, 0}                 }, // nLx2N
  { {0, 0}, {3, 0}                 }, // nRx2N
};

/**
 * \brief PU sizes.
 *
 * Indexed by [part mode][PU number][axis].
 *
 * Units are 1/4 of the width of the CU.
 */
const uint8_t kvz_part_mode_sizes[][4][2] = {
  { {4, 4}                         }, // 2Nx2N
  { {4, 2}, {4, 2}                 }, // 2NxN
  { {2, 4}, {2, 4}                 }, // Nx2N
  { {2, 2}, {2, 2}, {2, 2}, {2, 2} }, // NxN
  { {4, 1}, {4, 3}                 }, // 2NxnU
  { {4, 3}, {4, 1}                 }, // 2NxnD
  { {1, 4}, {3, 4}                 }, // nLx2N
  { {3, 4}, {1, 4}                 }, // nRx2N
};

void kvz_coefficients_blit(const coeff_t * const orig, coeff_t * const dst,
                         const unsigned width, const unsigned height,
                         const unsigned orig_stride, const unsigned dst_stride)
{
  unsigned y;
  
  int nxn_width = (width == height) ? width : 0;
  switch (nxn_width) {
    case 4:
      *(int64_t*)&dst[dst_stride*0] = *(int64_t*)&orig[orig_stride*0];
      *(int64_t*)&dst[dst_stride*1] = *(int64_t*)&orig[orig_stride*1];
      *(int64_t*)&dst[dst_stride*2] = *(int64_t*)&orig[orig_stride*2];
      *(int64_t*)&dst[dst_stride*3] = *(int64_t*)&orig[orig_stride*3];
      break;
    case 8:
#define KVZ_COPY_ROW_8(row_num) \
*(int64_t*)&dst[dst_stride*(row_num)] = *(int64_t*)&orig[orig_stride*(row_num)]; \
*(int64_t*)&dst[dst_stride*(row_num) + 4] = *(int64_t*)&orig[orig_stride*(row_num) + 4];
      
      KVZ_COPY_ROW_8(0);
      KVZ_COPY_ROW_8(1);
      KVZ_COPY_ROW_8(2);
      KVZ_COPY_ROW_8(3);
      KVZ_COPY_ROW_8(4);
      KVZ_COPY_ROW_8(5);
      KVZ_COPY_ROW_8(6);
      KVZ_COPY_ROW_8(7);
      break;
#undef KVZ_COPY_ROW_8
          case 16:
#define KVZ_COPY_ROW_16(row_num) \
*(int64_t*)&dst[dst_stride*(row_num)] = *(int64_t*)&orig[orig_stride*(row_num)]; \
*(int64_t*)&dst[dst_stride*(row_num) + 4] = *(int64_t*)&orig[orig_stride*(row_num) + 4]; \
*(int64_t*)&dst[dst_stride*(row_num) + 8] = *(int64_t*)&orig[orig_stride*(row_num) + 8]; \
*(int64_t*)&dst[dst_stride*(row_num) + 12] = *(int64_t*)&orig[orig_stride*(row_num) + 12];
      
      KVZ_COPY_ROW_16(0);
      KVZ_COPY_ROW_16(1);
      KVZ_COPY_ROW_16(2);
      KVZ_COPY_ROW_16(3);
      KVZ_COPY_ROW_16(4);
      KVZ_COPY_ROW_16(5);
      KVZ_COPY_ROW_16(6);
      KVZ_COPY_ROW_16(7);
      KVZ_COPY_ROW_16(8);
      KVZ_COPY_ROW_16(9);
      KVZ_COPY_ROW_16(10);
      KVZ_COPY_ROW_16(11);
      KVZ_COPY_ROW_16(12);
      KVZ_COPY_ROW_16(13);
      KVZ_COPY_ROW_16(14);
      KVZ_COPY_ROW_16(15);
      break;
#undef KVZ_COPY_ROW_16
  default:
    for (y = 0; y < height; ++y) {
      memcpy(&dst[y*dst_stride], &orig[y*orig_stride], width * sizeof(coeff_t));
    }
    break;
  }
}

unsigned kvz_coefficients_calc_abs(const coeff_t *const buf, const int buf_stride,
                        const int width)
{
  int sum = 0;
  int y, x;

  for (y = 0; y < width; ++y) {
    for (x = 0; x < width; ++x) {
      sum += abs(buf[x + y * buf_stride]);
    }
  }

  return sum;
}

cu_array_t * kvz_cu_array_alloc(const int width_in_scu, const int height_in_scu) {
  unsigned cu_array_size = height_in_scu * width_in_scu;
  cu_array_t *cua;
  cua = MALLOC(cu_array_t, 1);
  cua->data = (cu_info_t*)malloc(sizeof(cu_info_t) * cu_array_size);
  cua->refcount = 1;
  FILL_ARRAY(cua->data, 0, cu_array_size);
  return cua;
}

int kvz_cu_array_free(cu_array_t * const cua)
{
  int32_t new_refcount;
  if (!cua) return 1;
  
  new_refcount = KVZ_ATOMIC_DEC(&(cua->refcount));
  //Still we have some references, do nothing
  if (new_refcount > 0) return 1;
  
  FREE_POINTER(cua->data);
  free(cua);

  return 1;
}