/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 | } |