Coverage Report

Created: 2022-08-24 06:17

/src/aom/av1/common/tile_common.c
Line
Count
Source (jump to first uncovered line)
1
/*
2
 * Copyright (c) 2016, Alliance for Open Media. All rights reserved
3
 *
4
 * This source code is subject to the terms of the BSD 2 Clause License and
5
 * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
6
 * was not distributed with this source code in the LICENSE file, you can
7
 * obtain it at www.aomedia.org/license/software. If the Alliance for Open
8
 * Media Patent License 1.0 was not distributed with this source code in the
9
 * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
10
 */
11
12
#include "av1/common/av1_common_int.h"
13
#include "av1/common/resize.h"
14
#include "av1/common/tile_common.h"
15
#include "aom_dsp/aom_dsp_common.h"
16
17
23.4k
void av1_tile_init(TileInfo *tile, const AV1_COMMON *cm, int row, int col) {
18
23.4k
  av1_tile_set_row(tile, cm, row);
19
23.4k
  av1_tile_set_col(tile, cm, col);
20
23.4k
}
21
22
// Find smallest k>=0 such that (blk_size << k) >= target
23
70.3k
static int tile_log2(int blk_size, int target) {
24
70.3k
  int k;
25
134k
  for (k = 0; (blk_size << k) < target; k++) {
26
64.2k
  }
27
70.3k
  return k;
28
70.3k
}
29
30
17.5k
void av1_get_tile_limits(AV1_COMMON *const cm) {
31
17.5k
  const SequenceHeader *const seq_params = cm->seq_params;
32
17.5k
  CommonTileParams *const tiles = &cm->tiles;
33
17.5k
  const int mi_cols =
34
17.5k
      ALIGN_POWER_OF_TWO(cm->mi_params.mi_cols, seq_params->mib_size_log2);
35
17.5k
  const int mi_rows =
36
17.5k
      ALIGN_POWER_OF_TWO(cm->mi_params.mi_rows, seq_params->mib_size_log2);
37
17.5k
  const int sb_cols = mi_cols >> seq_params->mib_size_log2;
38
17.5k
  const int sb_rows = mi_rows >> seq_params->mib_size_log2;
39
40
17.5k
  const int sb_size_log2 = seq_params->mib_size_log2 + MI_SIZE_LOG2;
41
17.5k
  tiles->max_width_sb = MAX_TILE_WIDTH >> sb_size_log2;
42
17.5k
  const int max_tile_area_sb = MAX_TILE_AREA >> (2 * sb_size_log2);
43
44
17.5k
  tiles->min_log2_cols = tile_log2(tiles->max_width_sb, sb_cols);
45
17.5k
  tiles->max_log2_cols = tile_log2(1, AOMMIN(sb_cols, MAX_TILE_COLS));
46
17.5k
  tiles->max_log2_rows = tile_log2(1, AOMMIN(sb_rows, MAX_TILE_ROWS));
47
17.5k
  tiles->min_log2 = tile_log2(max_tile_area_sb, sb_cols * sb_rows);
48
17.5k
  tiles->min_log2 = AOMMAX(tiles->min_log2, tiles->min_log2_cols);
49
17.5k
}
50
51
void av1_calculate_tile_cols(const SequenceHeader *const seq_params,
52
                             int cm_mi_rows, int cm_mi_cols,
53
17.5k
                             CommonTileParams *const tiles) {
54
17.5k
  int mi_cols = ALIGN_POWER_OF_TWO(cm_mi_cols, seq_params->mib_size_log2);
55
17.5k
  int mi_rows = ALIGN_POWER_OF_TWO(cm_mi_rows, seq_params->mib_size_log2);
56
17.5k
  int sb_cols = mi_cols >> seq_params->mib_size_log2;
57
17.5k
  int sb_rows = mi_rows >> seq_params->mib_size_log2;
58
17.5k
  int i;
59
60
  // This will be overridden if there is at least two columns of tiles
61
  // (otherwise there is no inner tile width)
62
17.5k
  tiles->min_inner_width = -1;
63
64
17.5k
  if (tiles->uniform_spacing) {
65
17.5k
    int start_sb;
66
17.5k
    int size_sb = ALIGN_POWER_OF_TWO(sb_cols, tiles->log2_cols);
67
17.5k
    size_sb >>= tiles->log2_cols;
68
17.5k
    assert(size_sb > 0);
69
35.1k
    for (i = 0, start_sb = 0; start_sb < sb_cols; i++) {
70
17.5k
      tiles->col_start_sb[i] = start_sb;
71
17.5k
      start_sb += size_sb;
72
17.5k
    }
73
17.5k
    tiles->cols = i;
74
17.5k
    tiles->col_start_sb[i] = sb_cols;
75
17.5k
    tiles->min_log2_rows = AOMMAX(tiles->min_log2 - tiles->log2_cols, 0);
76
17.5k
    tiles->max_height_sb = sb_rows >> tiles->min_log2_rows;
77
78
17.5k
    tiles->width = size_sb << seq_params->mib_size_log2;
79
17.5k
    tiles->width = AOMMIN(tiles->width, cm_mi_cols);
80
17.5k
    if (tiles->cols > 1) {
81
2
      tiles->min_inner_width = tiles->width;
82
2
    }
83
17.5k
  } else {
84
22
    int max_tile_area_sb = (sb_rows * sb_cols);
85
22
    int widest_tile_sb = 1;
86
22
    int narrowest_inner_tile_sb = 65536;
87
22
    tiles->log2_cols = tile_log2(1, tiles->cols);
88
410
    for (i = 0; i < tiles->cols; i++) {
89
388
      int size_sb = tiles->col_start_sb[i + 1] - tiles->col_start_sb[i];
90
388
      widest_tile_sb = AOMMAX(widest_tile_sb, size_sb);
91
      // ignore the rightmost tile in frame for determining the narrowest
92
388
      if (i < tiles->cols - 1)
93
366
        narrowest_inner_tile_sb = AOMMIN(narrowest_inner_tile_sb, size_sb);
94
388
    }
95
22
    if (tiles->min_log2) {
96
0
      max_tile_area_sb >>= (tiles->min_log2 + 1);
97
0
    }
98
22
    tiles->max_height_sb = AOMMAX(max_tile_area_sb / widest_tile_sb, 1);
99
22
    if (tiles->cols > 1) {
100
22
      tiles->min_inner_width = narrowest_inner_tile_sb
101
22
                               << seq_params->mib_size_log2;
102
22
    }
103
22
  }
104
17.5k
}
105
106
void av1_calculate_tile_rows(const SequenceHeader *const seq_params,
107
17.5k
                             int cm_mi_rows, CommonTileParams *const tiles) {
108
17.5k
  int mi_rows = ALIGN_POWER_OF_TWO(cm_mi_rows, seq_params->mib_size_log2);
109
17.5k
  int sb_rows = mi_rows >> seq_params->mib_size_log2;
110
17.5k
  int start_sb, size_sb, i;
111
112
17.5k
  if (tiles->uniform_spacing) {
113
17.5k
    size_sb = ALIGN_POWER_OF_TWO(sb_rows, tiles->log2_rows);
114
17.5k
    size_sb >>= tiles->log2_rows;
115
17.5k
    assert(size_sb > 0);
116
35.1k
    for (i = 0, start_sb = 0; start_sb < sb_rows; i++) {
117
17.5k
      tiles->row_start_sb[i] = start_sb;
118
17.5k
      start_sb += size_sb;
119
17.5k
    }
120
17.5k
    tiles->rows = i;
121
17.5k
    tiles->row_start_sb[i] = sb_rows;
122
123
17.5k
    tiles->height = size_sb << seq_params->mib_size_log2;
124
17.5k
    tiles->height = AOMMIN(tiles->height, cm_mi_rows);
125
17.5k
  } else {
126
22
    tiles->log2_rows = tile_log2(1, tiles->rows);
127
22
  }
128
17.5k
}
129
130
27.1k
void av1_tile_set_row(TileInfo *tile, const AV1_COMMON *cm, int row) {
131
27.1k
  assert(row < cm->tiles.rows);
132
27.1k
  int mi_row_start = cm->tiles.row_start_sb[row]
133
27.1k
                     << cm->seq_params->mib_size_log2;
134
27.1k
  int mi_row_end = cm->tiles.row_start_sb[row + 1]
135
27.1k
                   << cm->seq_params->mib_size_log2;
136
27.1k
  tile->tile_row = row;
137
27.1k
  tile->mi_row_start = mi_row_start;
138
27.1k
  tile->mi_row_end = AOMMIN(mi_row_end, cm->mi_params.mi_rows);
139
27.1k
  assert(tile->mi_row_end > tile->mi_row_start);
140
27.1k
}
141
142
26.6k
void av1_tile_set_col(TileInfo *tile, const AV1_COMMON *cm, int col) {
143
26.6k
  assert(col < cm->tiles.cols);
144
26.6k
  int mi_col_start = cm->tiles.col_start_sb[col]
145
26.6k
                     << cm->seq_params->mib_size_log2;
146
26.6k
  int mi_col_end = cm->tiles.col_start_sb[col + 1]
147
26.6k
                   << cm->seq_params->mib_size_log2;
148
26.6k
  tile->tile_col = col;
149
26.6k
  tile->mi_col_start = mi_col_start;
150
26.6k
  tile->mi_col_end = AOMMIN(mi_col_end, cm->mi_params.mi_cols);
151
26.6k
  assert(tile->mi_col_end > tile->mi_col_start);
152
26.6k
}
153
154
22.2k
int av1_get_sb_rows_in_tile(AV1_COMMON *cm, TileInfo tile) {
155
22.2k
  int mi_rows_aligned_to_sb = ALIGN_POWER_OF_TWO(
156
22.2k
      tile.mi_row_end - tile.mi_row_start, cm->seq_params->mib_size_log2);
157
22.2k
  int sb_rows = mi_rows_aligned_to_sb >> cm->seq_params->mib_size_log2;
158
159
22.2k
  return sb_rows;
160
22.2k
}
161
162
25.8k
int av1_get_sb_cols_in_tile(AV1_COMMON *cm, TileInfo tile) {
163
25.8k
  int mi_cols_aligned_to_sb = ALIGN_POWER_OF_TWO(
164
25.8k
      tile.mi_col_end - tile.mi_col_start, cm->seq_params->mib_size_log2);
165
25.8k
  int sb_cols = mi_cols_aligned_to_sb >> cm->seq_params->mib_size_log2;
166
167
25.8k
  return sb_cols;
168
25.8k
}
169
170
AV1PixelRect av1_get_tile_rect(const TileInfo *tile_info, const AV1_COMMON *cm,
171
0
                               int is_uv) {
172
0
  AV1PixelRect r;
173
174
  // Calculate position in the Y plane
175
0
  r.left = tile_info->mi_col_start * MI_SIZE;
176
0
  r.right = tile_info->mi_col_end * MI_SIZE;
177
0
  r.top = tile_info->mi_row_start * MI_SIZE;
178
0
  r.bottom = tile_info->mi_row_end * MI_SIZE;
179
180
  // If upscaling is enabled, the tile limits need scaling to match the
181
  // upscaled frame where the restoration units live. To do this, scale up the
182
  // top-left and bottom-right of the tile.
183
0
  if (av1_superres_scaled(cm)) {
184
0
    av1_calculate_unscaled_superres_size(&r.left, &r.top,
185
0
                                         cm->superres_scale_denominator);
186
0
    av1_calculate_unscaled_superres_size(&r.right, &r.bottom,
187
0
                                         cm->superres_scale_denominator);
188
0
  }
189
190
0
  const int frame_w = cm->superres_upscaled_width;
191
0
  const int frame_h = cm->superres_upscaled_height;
192
193
  // Make sure we don't fall off the bottom-right of the frame.
194
0
  r.right = AOMMIN(r.right, frame_w);
195
0
  r.bottom = AOMMIN(r.bottom, frame_h);
196
197
  // Convert to coordinates in the appropriate plane
198
0
  const int ss_x = is_uv && cm->seq_params->subsampling_x;
199
0
  const int ss_y = is_uv && cm->seq_params->subsampling_y;
200
201
0
  r.left = ROUND_POWER_OF_TWO(r.left, ss_x);
202
0
  r.right = ROUND_POWER_OF_TWO(r.right, ss_x);
203
0
  r.top = ROUND_POWER_OF_TWO(r.top, ss_y);
204
0
  r.bottom = ROUND_POWER_OF_TWO(r.bottom, ss_y);
205
206
0
  return r;
207
0
}
208
209
0
void av1_get_uniform_tile_size(const AV1_COMMON *cm, int *w, int *h) {
210
0
  const CommonTileParams *const tiles = &cm->tiles;
211
0
  if (tiles->uniform_spacing) {
212
0
    *w = tiles->width;
213
0
    *h = tiles->height;
214
0
  } else {
215
0
    for (int i = 0; i < tiles->cols; ++i) {
216
0
      const int tile_width_sb =
217
0
          tiles->col_start_sb[i + 1] - tiles->col_start_sb[i];
218
0
      const int tile_w = tile_width_sb * cm->seq_params->mib_size;
219
0
      assert(i == 0 || tile_w == *w);  // ensure all tiles have same dimension
220
0
      *w = tile_w;
221
0
    }
222
223
0
    for (int i = 0; i < tiles->rows; ++i) {
224
0
      const int tile_height_sb =
225
0
          tiles->row_start_sb[i + 1] - tiles->row_start_sb[i];
226
0
      const int tile_h = tile_height_sb * cm->seq_params->mib_size;
227
0
      assert(i == 0 || tile_h == *h);  // ensure all tiles have same dimension
228
0
      *h = tile_h;
229
0
    }
230
0
  }
231
0
}
232
233
1.98k
int av1_is_min_tile_width_satisfied(const AV1_COMMON *cm) {
234
  // Disable check if there is a single tile col in the frame
235
1.98k
  if (cm->tiles.cols == 1) return 1;
236
237
24
  return ((cm->tiles.min_inner_width << MI_SIZE_LOG2) >=
238
24
          (64 << av1_superres_scaled(cm)));
239
1.98k
}