/*

 * 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/av1_common_int.h"

#include "av1/common/resize.h"

#include "av1/common/tile_common.h"

#include "aom_dsp/aom_dsp_common.h"

void av1_tile_init(TileInfo *tile, const AV1_COMMON *cm, int row, int col) {

  av1_tile_set_row(tile, cm, row);

  av1_tile_set_col(tile, cm, col);

}

// Find smallest k>=0 such that (blk_size << k) >= target

static int tile_log2(int blk_size, int target) {

  int k;

  for (k = 0; (blk_size << k) < target; k++) {

  }

  return k;

}

void av1_get_tile_limits(AV1_COMMON *const cm) {

  const SequenceHeader *const seq_params = cm->seq_params;

  CommonTileParams *const tiles = &cm->tiles;

  const int mi_cols =

      ALIGN_POWER_OF_TWO(cm->mi_params.mi_cols, seq_params->mib_size_log2);

  const int mi_rows =

      ALIGN_POWER_OF_TWO(cm->mi_params.mi_rows, seq_params->mib_size_log2);

  const int sb_cols = mi_cols >> seq_params->mib_size_log2;

  const int sb_rows = mi_rows >> seq_params->mib_size_log2;

  const int sb_size_log2 = seq_params->mib_size_log2 + MI_SIZE_LOG2;

  tiles->max_width_sb = MAX_TILE_WIDTH >> sb_size_log2;

  const int max_tile_area_sb = MAX_TILE_AREA >> (2 * sb_size_log2);

  tiles->min_log2_cols = tile_log2(tiles->max_width_sb, sb_cols);

  tiles->max_log2_cols = tile_log2(1, AOMMIN(sb_cols, MAX_TILE_COLS));

  tiles->max_log2_rows = tile_log2(1, AOMMIN(sb_rows, MAX_TILE_ROWS));

  tiles->min_log2 = tile_log2(max_tile_area_sb, sb_cols * sb_rows);

  tiles->min_log2 = AOMMAX(tiles->min_log2, tiles->min_log2_cols);

}

void av1_calculate_tile_cols(const SequenceHeader *const seq_params,

                             int cm_mi_rows, int cm_mi_cols,

                             CommonTileParams *const tiles) {

  int mi_cols = ALIGN_POWER_OF_TWO(cm_mi_cols, seq_params->mib_size_log2);

  int mi_rows = ALIGN_POWER_OF_TWO(cm_mi_rows, seq_params->mib_size_log2);

  int sb_cols = mi_cols >> seq_params->mib_size_log2;

  int sb_rows = mi_rows >> seq_params->mib_size_log2;

  int i;

  // This will be overridden if there is at least two columns of tiles

  // (otherwise there is no inner tile width)

  tiles->min_inner_width = -1;

  if (tiles->uniform_spacing) {

    int start_sb;

    int size_sb = ALIGN_POWER_OF_TWO(sb_cols, tiles->log2_cols);

    size_sb >>= tiles->log2_cols;

    assert(size_sb > 0);

    for (i = 0, start_sb = 0; start_sb < sb_cols; i++) {

      tiles->col_start_sb[i] = start_sb;

      start_sb += size_sb;

    }

    tiles->cols = i;

    tiles->col_start_sb[i] = sb_cols;

    tiles->min_log2_rows = AOMMAX(tiles->min_log2 - tiles->log2_cols, 0);

    tiles->max_height_sb = sb_rows >> tiles->min_log2_rows;

    tiles->width = size_sb << seq_params->mib_size_log2;

    tiles->width = AOMMIN(tiles->width, cm_mi_cols);

    if (tiles->cols > 1) {

      tiles->min_inner_width = tiles->width;

    }

  } else {

    int max_tile_area_sb = (sb_rows * sb_cols);

    int widest_tile_sb = 1;

    int narrowest_inner_tile_sb = 65536;

    tiles->log2_cols = tile_log2(1, tiles->cols);

    for (i = 0; i < tiles->cols; i++) {

      int size_sb = tiles->col_start_sb[i + 1] - tiles->col_start_sb[i];

      widest_tile_sb = AOMMAX(widest_tile_sb, size_sb);

      // ignore the rightmost tile in frame for determining the narrowest

      if (i < tiles->cols - 1)

        narrowest_inner_tile_sb = AOMMIN(narrowest_inner_tile_sb, size_sb);

    }

    if (tiles->min_log2) {

      max_tile_area_sb >>= (tiles->min_log2 + 1);

    }

    tiles->max_height_sb = AOMMAX(max_tile_area_sb / widest_tile_sb, 1);

    if (tiles->cols > 1) {

      tiles->min_inner_width = narrowest_inner_tile_sb

                               << seq_params->mib_size_log2;

    }

  }

}

void av1_calculate_tile_rows(const SequenceHeader *const seq_params,

                             int cm_mi_rows, CommonTileParams *const tiles) {

  int mi_rows = ALIGN_POWER_OF_TWO(cm_mi_rows, seq_params->mib_size_log2);

  int sb_rows = mi_rows >> seq_params->mib_size_log2;

  int start_sb, size_sb, i;

  if (tiles->uniform_spacing) {

    size_sb = ALIGN_POWER_OF_TWO(sb_rows, tiles->log2_rows);

    size_sb >>= tiles->log2_rows;

    assert(size_sb > 0);

    for (i = 0, start_sb = 0; start_sb < sb_rows; i++) {

      tiles->row_start_sb[i] = start_sb;

      start_sb += size_sb;

    }

    tiles->rows = i;

    tiles->row_start_sb[i] = sb_rows;

    tiles->height = size_sb << seq_params->mib_size_log2;

    tiles->height = AOMMIN(tiles->height, cm_mi_rows);

  } else {

    tiles->log2_rows = tile_log2(1, tiles->rows);

  }

}

void av1_tile_set_row(TileInfo *tile, const AV1_COMMON *cm, int row) {

  assert(row < cm->tiles.rows);

  int mi_row_start = cm->tiles.row_start_sb[row]

                     << cm->seq_params->mib_size_log2;

  int mi_row_end = cm->tiles.row_start_sb[row + 1]

                   << cm->seq_params->mib_size_log2;

  tile->tile_row = row;

  tile->mi_row_start = mi_row_start;

  tile->mi_row_end = AOMMIN(mi_row_end, cm->mi_params.mi_rows);

  assert(tile->mi_row_end > tile->mi_row_start);

}

void av1_tile_set_col(TileInfo *tile, const AV1_COMMON *cm, int col) {

  assert(col < cm->tiles.cols);

  int mi_col_start = cm->tiles.col_start_sb[col]

                     << cm->seq_params->mib_size_log2;

  int mi_col_end = cm->tiles.col_start_sb[col + 1]

                   << cm->seq_params->mib_size_log2;

  tile->tile_col = col;

  tile->mi_col_start = mi_col_start;

  tile->mi_col_end = AOMMIN(mi_col_end, cm->mi_params.mi_cols);

  assert(tile->mi_col_end > tile->mi_col_start);

}

int av1_get_sb_rows_in_tile(AV1_COMMON *cm, TileInfo tile) {

  int mi_rows_aligned_to_sb = ALIGN_POWER_OF_TWO(

      tile.mi_row_end - tile.mi_row_start, cm->seq_params->mib_size_log2);

  int sb_rows = mi_rows_aligned_to_sb >> cm->seq_params->mib_size_log2;

  return sb_rows;

}

int av1_get_sb_cols_in_tile(AV1_COMMON *cm, TileInfo tile) {

  int mi_cols_aligned_to_sb = ALIGN_POWER_OF_TWO(

      tile.mi_col_end - tile.mi_col_start, cm->seq_params->mib_size_log2);

  int sb_cols = mi_cols_aligned_to_sb >> cm->seq_params->mib_size_log2;

  return sb_cols;

}

AV1PixelRect av1_get_tile_rect(const TileInfo *tile_info, const AV1_COMMON *cm,

                               int is_uv) {

  AV1PixelRect r;

  // Calculate position in the Y plane

  r.left = tile_info->mi_col_start * MI_SIZE;

  r.right = tile_info->mi_col_end * MI_SIZE;

  r.top = tile_info->mi_row_start * MI_SIZE;

  r.bottom = tile_info->mi_row_end * MI_SIZE;

  // If upscaling is enabled, the tile limits need scaling to match the

  // upscaled frame where the restoration units live. To do this, scale up the

  // top-left and bottom-right of the tile.

  if (av1_superres_scaled(cm)) {

    av1_calculate_unscaled_superres_size(&r.left, &r.top,

                                         cm->superres_scale_denominator);

    av1_calculate_unscaled_superres_size(&r.right, &r.bottom,

                                         cm->superres_scale_denominator);

  }

  const int frame_w = cm->superres_upscaled_width;

  const int frame_h = cm->superres_upscaled_height;

  // Make sure we don't fall off the bottom-right of the frame.

  r.right = AOMMIN(r.right, frame_w);

  r.bottom = AOMMIN(r.bottom, frame_h);

  // Convert to coordinates in the appropriate plane

  const int ss_x = is_uv && cm->seq_params->subsampling_x;

  const int ss_y = is_uv && cm->seq_params->subsampling_y;

  r.left = ROUND_POWER_OF_TWO(r.left, ss_x);

  r.right = ROUND_POWER_OF_TWO(r.right, ss_x);

  r.top = ROUND_POWER_OF_TWO(r.top, ss_y);

  r.bottom = ROUND_POWER_OF_TWO(r.bottom, ss_y);

  return r;

}

void av1_get_uniform_tile_size(const AV1_COMMON *cm, int *w, int *h) {

  const CommonTileParams *const tiles = &cm->tiles;

  if (tiles->uniform_spacing) {

    *w = tiles->width;

    *h = tiles->height;

  } else {

    for (int i = 0; i < tiles->cols; ++i) {

      const int tile_width_sb =

          tiles->col_start_sb[i + 1] - tiles->col_start_sb[i];

      const int tile_w = tile_width_sb * cm->seq_params->mib_size;

      assert(i == 0 || tile_w == *w);  // ensure all tiles have same dimension

      *w = tile_w;

    }

    for (int i = 0; i < tiles->rows; ++i) {

      const int tile_height_sb =

          tiles->row_start_sb[i + 1] - tiles->row_start_sb[i];

      const int tile_h = tile_height_sb * cm->seq_params->mib_size;

      assert(i == 0 || tile_h == *h);  // ensure all tiles have same dimension

      *h = tile_h;

    }

  }

}

int av1_is_min_tile_width_satisfied(const AV1_COMMON *cm) {

  // Disable check if there is a single tile col in the frame

  if (cm->tiles.cols == 1) return 1;

  return ((cm->tiles.min_inner_width << MI_SIZE_LOG2) >=

          (64 << av1_superres_scaled(cm)));

}