Coverage Report

Created: 2025-06-13 07:07

/src/aom/av1/common/tile_common.c
Line
Count
Source
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 <stdbool.h>
13
14
#include "av1/common/av1_common_int.h"
15
#include "av1/common/resize.h"
16
#include "av1/common/tile_common.h"
17
#include "aom_dsp/aom_dsp_common.h"
18
19
380k
void av1_tile_init(TileInfo *tile, const AV1_COMMON *cm, int row, int col) {
20
380k
  av1_tile_set_row(tile, cm, row);
21
380k
  av1_tile_set_col(tile, cm, col);
22
380k
}
23
24
// Find smallest k>=0 such that (blk_size << k) >= target
25
942k
static int tile_log2(int blk_size, int target) {
26
942k
  int k;
27
1.39M
  for (k = 0; (blk_size << k) < target; k++) {
28
450k
  }
29
942k
  return k;
30
942k
}
31
32
190k
void av1_get_tile_limits(AV1_COMMON *const cm) {
33
190k
  const SequenceHeader *const seq_params = cm->seq_params;
34
190k
  CommonTileParams *const tiles = &cm->tiles;
35
190k
  const int sb_cols =
36
190k
      CEIL_POWER_OF_TWO(cm->mi_params.mi_cols, seq_params->mib_size_log2);
37
190k
  const int sb_rows =
38
190k
      CEIL_POWER_OF_TWO(cm->mi_params.mi_rows, seq_params->mib_size_log2);
39
40
190k
  const int sb_size_log2 = seq_params->mib_size_log2 + MI_SIZE_LOG2;
41
190k
  tiles->max_width_sb = MAX_TILE_WIDTH >> sb_size_log2;
42
43
#if CONFIG_CWG_C013
44
  bool use_level_7_above = false;
45
  for (int i = 0; i < seq_params->operating_points_cnt_minus_1 + 1; i++) {
46
    if (seq_params->seq_level_idx[i] >= SEQ_LEVEL_7_0 &&
47
        seq_params->seq_level_idx[i] <= SEQ_LEVEL_8_3) {
48
      // Currently it is assumed that levels 7.x and 8.x are either used for all
49
      // operating points, or none of them.
50
      if (i != 0 && !use_level_7_above) {
51
        aom_internal_error(cm->error, AOM_CODEC_UNSUP_BITSTREAM,
52
                           "Either all the operating points are levels 7.x or "
53
                           "8.x, or none of them are.");
54
      }
55
      use_level_7_above = true;
56
    }
57
  }
58
  const int max_tile_area_sb =
59
      (use_level_7_above ? MAX_TILE_AREA_LEVEL_7_AND_ABOVE : MAX_TILE_AREA) >>
60
      (2 * sb_size_log2);
61
#else
62
190k
  const int max_tile_area_sb = MAX_TILE_AREA >> (2 * sb_size_log2);
63
190k
#endif
64
65
190k
  tiles->min_log2_cols = tile_log2(tiles->max_width_sb, sb_cols);
66
190k
  tiles->max_log2_cols = tile_log2(1, AOMMIN(sb_cols, MAX_TILE_COLS));
67
190k
  tiles->max_log2_rows = tile_log2(1, AOMMIN(sb_rows, MAX_TILE_ROWS));
68
190k
  tiles->min_log2 = tile_log2(max_tile_area_sb, sb_cols * sb_rows);
69
190k
  tiles->min_log2 = AOMMAX(tiles->min_log2, tiles->min_log2_cols);
70
190k
}
71
72
void av1_calculate_tile_cols(const SequenceHeader *const seq_params,
73
                             int cm_mi_rows, int cm_mi_cols,
74
190k
                             CommonTileParams *const tiles) {
75
190k
  int sb_cols = CEIL_POWER_OF_TWO(cm_mi_cols, seq_params->mib_size_log2);
76
190k
  int sb_rows = CEIL_POWER_OF_TWO(cm_mi_rows, seq_params->mib_size_log2);
77
190k
  int i;
78
79
  // This will be overridden if there is at least two columns of tiles
80
  // (otherwise there is no inner tile width)
81
190k
  tiles->min_inner_width = -1;
82
83
190k
  if (tiles->uniform_spacing) {
84
100k
    int start_sb;
85
100k
    int size_sb = CEIL_POWER_OF_TWO(sb_cols, tiles->log2_cols);
86
100k
    assert(size_sb > 0);
87
247k
    for (i = 0, start_sb = 0; start_sb < sb_cols; i++) {
88
147k
      tiles->col_start_sb[i] = start_sb;
89
147k
      start_sb += size_sb;
90
147k
    }
91
100k
    tiles->cols = i;
92
100k
    tiles->col_start_sb[i] = sb_cols;
93
100k
    tiles->min_log2_rows = AOMMAX(tiles->min_log2 - tiles->log2_cols, 0);
94
100k
    tiles->max_height_sb = sb_rows >> tiles->min_log2_rows;
95
96
100k
    tiles->width = size_sb << seq_params->mib_size_log2;
97
100k
    tiles->width = AOMMIN(tiles->width, cm_mi_cols);
98
100k
    if (tiles->cols > 1) {
99
9.45k
      tiles->min_inner_width = tiles->width;
100
9.45k
    }
101
100k
  } else {
102
90.3k
    int max_tile_area_sb = (sb_rows * sb_cols);
103
90.3k
    int widest_tile_sb = 1;
104
90.3k
    int narrowest_inner_tile_sb = 65536;
105
90.3k
    tiles->log2_cols = tile_log2(1, tiles->cols);
106
214k
    for (i = 0; i < tiles->cols; i++) {
107
123k
      int size_sb = tiles->col_start_sb[i + 1] - tiles->col_start_sb[i];
108
123k
      widest_tile_sb = AOMMAX(widest_tile_sb, size_sb);
109
      // ignore the rightmost tile in frame for determining the narrowest
110
123k
      if (i < tiles->cols - 1)
111
33.2k
        narrowest_inner_tile_sb = AOMMIN(narrowest_inner_tile_sb, size_sb);
112
123k
    }
113
90.3k
    if (tiles->min_log2) {
114
1.85k
      max_tile_area_sb >>= (tiles->min_log2 + 1);
115
1.85k
    }
116
90.3k
    tiles->max_height_sb = AOMMAX(max_tile_area_sb / widest_tile_sb, 1);
117
90.3k
    if (tiles->cols > 1) {
118
11.5k
      tiles->min_inner_width = narrowest_inner_tile_sb
119
11.5k
                               << seq_params->mib_size_log2;
120
11.5k
    }
121
90.3k
  }
122
190k
}
123
124
void av1_calculate_tile_rows(const SequenceHeader *const seq_params,
125
190k
                             int cm_mi_rows, CommonTileParams *const tiles) {
126
190k
  int sb_rows = CEIL_POWER_OF_TWO(cm_mi_rows, seq_params->mib_size_log2);
127
190k
  int start_sb, size_sb, i;
128
129
190k
  if (tiles->uniform_spacing) {
130
100k
    size_sb = CEIL_POWER_OF_TWO(sb_rows, tiles->log2_rows);
131
100k
    assert(size_sb > 0);
132
232k
    for (i = 0, start_sb = 0; start_sb < sb_rows; i++) {
133
131k
      tiles->row_start_sb[i] = start_sb;
134
131k
      start_sb += size_sb;
135
131k
    }
136
100k
    tiles->rows = i;
137
100k
    tiles->row_start_sb[i] = sb_rows;
138
139
100k
    tiles->height = size_sb << seq_params->mib_size_log2;
140
100k
    tiles->height = AOMMIN(tiles->height, cm_mi_rows);
141
100k
  } else {
142
90.2k
    tiles->log2_rows = tile_log2(1, tiles->rows);
143
90.2k
  }
144
190k
}
145
146
456k
void av1_tile_set_row(TileInfo *tile, const AV1_COMMON *cm, int row) {
147
456k
  assert(row < cm->tiles.rows);
148
456k
  int mi_row_start = cm->tiles.row_start_sb[row]
149
456k
                     << cm->seq_params->mib_size_log2;
150
456k
  int mi_row_end = cm->tiles.row_start_sb[row + 1]
151
456k
                   << cm->seq_params->mib_size_log2;
152
456k
  tile->tile_row = row;
153
456k
  tile->mi_row_start = mi_row_start;
154
456k
  tile->mi_row_end = AOMMIN(mi_row_end, cm->mi_params.mi_rows);
155
456k
  assert(tile->mi_row_end > tile->mi_row_start);
156
456k
}
157
158
502k
void av1_tile_set_col(TileInfo *tile, const AV1_COMMON *cm, int col) {
159
502k
  assert(col < cm->tiles.cols);
160
502k
  int mi_col_start = cm->tiles.col_start_sb[col]
161
502k
                     << cm->seq_params->mib_size_log2;
162
502k
  int mi_col_end = cm->tiles.col_start_sb[col + 1]
163
502k
                   << cm->seq_params->mib_size_log2;
164
502k
  tile->tile_col = col;
165
502k
  tile->mi_col_start = mi_col_start;
166
502k
  tile->mi_col_end = AOMMIN(mi_col_end, cm->mi_params.mi_cols);
167
502k
  assert(tile->mi_col_end > tile->mi_col_start);
168
502k
}
169
170
400k
int av1_get_sb_rows_in_tile(const AV1_COMMON *cm, const TileInfo *tile) {
171
400k
  return CEIL_POWER_OF_TWO(tile->mi_row_end - tile->mi_row_start,
172
400k
                           cm->seq_params->mib_size_log2);
173
400k
}
174
175
127k
int av1_get_sb_cols_in_tile(const AV1_COMMON *cm, const TileInfo *tile) {
176
127k
  return CEIL_POWER_OF_TWO(tile->mi_col_end - tile->mi_col_start,
177
127k
                           cm->seq_params->mib_size_log2);
178
127k
}
179
180
// Section 7.3.1 of the AV1 spec says, on pages 200-201:
181
//   It is a requirement of bitstream conformance that the following conditions
182
//   are met:
183
//     ...
184
//     * TileHeight is equal to (use_128x128_superblock ? 128 : 64) for all
185
//       tiles (i.e. the tile is exactly one superblock high)
186
//     * TileWidth is identical for all tiles and is an integer multiple of
187
//       TileHeight (i.e. the tile is an integer number of superblocks wide)
188
//     ...
189
7.49k
bool av1_get_uniform_tile_size(const AV1_COMMON *cm, int *w, int *h) {
190
7.49k
  const CommonTileParams *const tiles = &cm->tiles;
191
7.49k
  if (tiles->uniform_spacing) {
192
5.06k
    *w = tiles->width;
193
5.06k
    *h = tiles->height;
194
5.06k
  } else {
195
6.85k
    for (int i = 0; i < tiles->cols; ++i) {
196
5.17k
      const int tile_width_sb =
197
5.17k
          tiles->col_start_sb[i + 1] - tiles->col_start_sb[i];
198
5.17k
      const int tile_w = tile_width_sb * cm->seq_params->mib_size;
199
      // ensure all tiles have same dimension
200
5.17k
      if (i != 0 && tile_w != *w) {
201
745
        return false;
202
745
      }
203
4.43k
      *w = tile_w;
204
4.43k
    }
205
206
5.52k
    for (int i = 0; i < tiles->rows; ++i) {
207
4.30k
      const int tile_height_sb =
208
4.30k
          tiles->row_start_sb[i + 1] - tiles->row_start_sb[i];
209
4.30k
      const int tile_h = tile_height_sb * cm->seq_params->mib_size;
210
      // ensure all tiles have same dimension
211
4.30k
      if (i != 0 && tile_h != *h) {
212
455
        return false;
213
455
      }
214
3.84k
      *h = tile_h;
215
3.84k
    }
216
1.68k
  }
217
6.29k
  return true;
218
7.49k
}
219
220
189k
int av1_is_min_tile_width_satisfied(const AV1_COMMON *cm) {
221
  // Disable check if there is a single tile col in the frame
222
189k
  if (cm->tiles.cols == 1) return 1;
223
224
19.8k
  return ((cm->tiles.min_inner_width << MI_SIZE_LOG2) >=
225
19.8k
          (64 << av1_superres_scaled(cm)));
226
189k
}