tile_common.c (8496B)
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 void av1_tile_init(TileInfo *tile, const AV1_COMMON *cm, int row, int col) { 20 av1_tile_set_row(tile, cm, row); 21 av1_tile_set_col(tile, cm, col); 22 } 23 24 // Find smallest k>=0 such that (blk_size << k) >= target 25 static int tile_log2(int blk_size, int target) { 26 int k; 27 for (k = 0; (blk_size << k) < target; k++) { 28 } 29 return k; 30 } 31 32 void av1_get_tile_limits(AV1_COMMON *const cm) { 33 const SequenceHeader *const seq_params = cm->seq_params; 34 CommonTileParams *const tiles = &cm->tiles; 35 const int sb_cols = 36 CEIL_POWER_OF_TWO(cm->mi_params.mi_cols, seq_params->mib_size_log2); 37 const int sb_rows = 38 CEIL_POWER_OF_TWO(cm->mi_params.mi_rows, seq_params->mib_size_log2); 39 40 const int sb_size_log2 = seq_params->mib_size_log2 + MI_SIZE_LOG2; 41 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 const int max_tile_area_sb = MAX_TILE_AREA >> (2 * sb_size_log2); 63 #endif 64 65 tiles->min_log2_cols = tile_log2(tiles->max_width_sb, sb_cols); 66 tiles->max_log2_cols = tile_log2(1, AOMMIN(sb_cols, MAX_TILE_COLS)); 67 tiles->max_log2_rows = tile_log2(1, AOMMIN(sb_rows, MAX_TILE_ROWS)); 68 tiles->min_log2 = tile_log2(max_tile_area_sb, sb_cols * sb_rows); 69 tiles->min_log2 = AOMMAX(tiles->min_log2, tiles->min_log2_cols); 70 } 71 72 void av1_calculate_tile_cols(const SequenceHeader *const seq_params, 73 int cm_mi_rows, int cm_mi_cols, 74 CommonTileParams *const tiles) { 75 int sb_cols = CEIL_POWER_OF_TWO(cm_mi_cols, seq_params->mib_size_log2); 76 int sb_rows = CEIL_POWER_OF_TWO(cm_mi_rows, seq_params->mib_size_log2); 77 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 tiles->min_inner_width = -1; 82 83 if (tiles->uniform_spacing) { 84 int start_sb; 85 int size_sb = CEIL_POWER_OF_TWO(sb_cols, tiles->log2_cols); 86 assert(size_sb > 0); 87 for (i = 0, start_sb = 0; start_sb < sb_cols; i++) { 88 tiles->col_start_sb[i] = start_sb; 89 start_sb += size_sb; 90 } 91 tiles->cols = i; 92 tiles->col_start_sb[i] = sb_cols; 93 tiles->min_log2_rows = AOMMAX(tiles->min_log2 - tiles->log2_cols, 0); 94 tiles->max_height_sb = sb_rows >> tiles->min_log2_rows; 95 96 tiles->width = size_sb << seq_params->mib_size_log2; 97 tiles->width = AOMMIN(tiles->width, cm_mi_cols); 98 if (tiles->cols > 1) { 99 tiles->min_inner_width = tiles->width; 100 } 101 } else { 102 int max_tile_area_sb = (sb_rows * sb_cols); 103 int widest_tile_sb = 1; 104 int narrowest_inner_tile_sb = 65536; 105 tiles->log2_cols = tile_log2(1, tiles->cols); 106 for (i = 0; i < tiles->cols; i++) { 107 int size_sb = tiles->col_start_sb[i + 1] - tiles->col_start_sb[i]; 108 widest_tile_sb = AOMMAX(widest_tile_sb, size_sb); 109 // ignore the rightmost tile in frame for determining the narrowest 110 if (i < tiles->cols - 1) 111 narrowest_inner_tile_sb = AOMMIN(narrowest_inner_tile_sb, size_sb); 112 } 113 if (tiles->min_log2) { 114 max_tile_area_sb >>= (tiles->min_log2 + 1); 115 } 116 tiles->max_height_sb = AOMMAX(max_tile_area_sb / widest_tile_sb, 1); 117 if (tiles->cols > 1) { 118 tiles->min_inner_width = narrowest_inner_tile_sb 119 << seq_params->mib_size_log2; 120 } 121 } 122 } 123 124 void av1_calculate_tile_rows(const SequenceHeader *const seq_params, 125 int cm_mi_rows, CommonTileParams *const tiles) { 126 int sb_rows = CEIL_POWER_OF_TWO(cm_mi_rows, seq_params->mib_size_log2); 127 int start_sb, size_sb, i; 128 129 if (tiles->uniform_spacing) { 130 size_sb = CEIL_POWER_OF_TWO(sb_rows, tiles->log2_rows); 131 assert(size_sb > 0); 132 for (i = 0, start_sb = 0; start_sb < sb_rows; i++) { 133 tiles->row_start_sb[i] = start_sb; 134 start_sb += size_sb; 135 } 136 tiles->rows = i; 137 tiles->row_start_sb[i] = sb_rows; 138 139 tiles->height = size_sb << seq_params->mib_size_log2; 140 tiles->height = AOMMIN(tiles->height, cm_mi_rows); 141 } else { 142 tiles->log2_rows = tile_log2(1, tiles->rows); 143 } 144 } 145 146 void av1_tile_set_row(TileInfo *tile, const AV1_COMMON *cm, int row) { 147 assert(row < cm->tiles.rows); 148 int mi_row_start = cm->tiles.row_start_sb[row] 149 << cm->seq_params->mib_size_log2; 150 int mi_row_end = cm->tiles.row_start_sb[row + 1] 151 << cm->seq_params->mib_size_log2; 152 tile->tile_row = row; 153 tile->mi_row_start = mi_row_start; 154 tile->mi_row_end = AOMMIN(mi_row_end, cm->mi_params.mi_rows); 155 assert(tile->mi_row_end > tile->mi_row_start); 156 } 157 158 void av1_tile_set_col(TileInfo *tile, const AV1_COMMON *cm, int col) { 159 assert(col < cm->tiles.cols); 160 int mi_col_start = cm->tiles.col_start_sb[col] 161 << cm->seq_params->mib_size_log2; 162 int mi_col_end = cm->tiles.col_start_sb[col + 1] 163 << cm->seq_params->mib_size_log2; 164 tile->tile_col = col; 165 tile->mi_col_start = mi_col_start; 166 tile->mi_col_end = AOMMIN(mi_col_end, cm->mi_params.mi_cols); 167 assert(tile->mi_col_end > tile->mi_col_start); 168 } 169 170 int av1_get_sb_rows_in_tile(const AV1_COMMON *cm, const TileInfo *tile) { 171 return CEIL_POWER_OF_TWO(tile->mi_row_end - tile->mi_row_start, 172 cm->seq_params->mib_size_log2); 173 } 174 175 int av1_get_sb_cols_in_tile(const AV1_COMMON *cm, const TileInfo *tile) { 176 return CEIL_POWER_OF_TWO(tile->mi_col_end - tile->mi_col_start, 177 cm->seq_params->mib_size_log2); 178 } 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 bool av1_get_uniform_tile_size(const AV1_COMMON *cm, int *w, int *h) { 190 const CommonTileParams *const tiles = &cm->tiles; 191 if (tiles->uniform_spacing) { 192 *w = tiles->width; 193 *h = tiles->height; 194 } else { 195 for (int i = 0; i < tiles->cols; ++i) { 196 const int tile_width_sb = 197 tiles->col_start_sb[i + 1] - tiles->col_start_sb[i]; 198 const int tile_w = tile_width_sb * cm->seq_params->mib_size; 199 // ensure all tiles have same dimension 200 if (i != 0 && tile_w != *w) { 201 return false; 202 } 203 *w = tile_w; 204 } 205 206 for (int i = 0; i < tiles->rows; ++i) { 207 const int tile_height_sb = 208 tiles->row_start_sb[i + 1] - tiles->row_start_sb[i]; 209 const int tile_h = tile_height_sb * cm->seq_params->mib_size; 210 // ensure all tiles have same dimension 211 if (i != 0 && tile_h != *h) { 212 return false; 213 } 214 *h = tile_h; 215 } 216 } 217 return true; 218 } 219 220 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 if (cm->tiles.cols == 1) return 1; 223 224 return ((cm->tiles.min_inner_width << MI_SIZE_LOG2) >= 225 (64 << av1_superres_scaled(cm))); 226 }