1 /*
2 * Copyright(c) 2019 Netflix, Inc.
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 https://www.aomedia.org/license/software-license. 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 https://www.aomedia.org/license/patent-license.
10 */
11
12 // SUMMARY
13 // Contains the Parse related functions
14
15 /**************************************
16 * Includes
17 **************************************/
18
19 #include "EbDefinitions.h"
20 #include "EbPictureBufferDesc.h"
21
22 #include "EbDecHandle.h"
23 #include "EbDecBitReader.h"
24 #include "EbDecProcessFrame.h"
25 #include "EbDecUtils.h"
26
27 #include "EbDecParseFrame.h"
28 #include "EbDecParseHelper.h"
29
30 /* Inititalizes prms for current tile from main TilesInfo ! */
svt_tile_init(TileInfo * cur_tile_info,FrameHeader * frame_header,int32_t tile_row,int32_t tile_col)31 void svt_tile_init(TileInfo *cur_tile_info, FrameHeader *frame_header, int32_t tile_row,
32 int32_t tile_col) {
33 TilesInfo *tiles_info = &frame_header->tiles_info;
34
35 /* tile_set_row */
36 assert(tile_row < tiles_info->tile_rows);
37 cur_tile_info->tile_row = tile_row;
38 cur_tile_info->mi_row_start = tiles_info->tile_row_start_mi[tile_row];
39 cur_tile_info->mi_row_end = AOMMIN(tiles_info->tile_row_start_mi[tile_row + 1],
40 frame_header->mi_rows);
41
42 assert(cur_tile_info->mi_row_end > cur_tile_info->mi_row_start);
43
44 /* tile_set_col */
45 assert(tile_col < tiles_info->tile_cols);
46
47 cur_tile_info->tile_col = tile_col;
48 cur_tile_info->mi_col_start = tiles_info->tile_col_start_mi[tile_col];
49 cur_tile_info->mi_col_end = AOMMIN(tiles_info->tile_col_start_mi[tile_col + 1],
50 frame_header->mi_cols);
51
52 assert(cur_tile_info->mi_col_end > cur_tile_info->mi_col_start);
53 }
54
clear_above_context(ParseCtxt * parse_ctxt,int mi_col_start,int mi_col_end,int num_threads)55 void clear_above_context(ParseCtxt *parse_ctxt, int mi_col_start, int mi_col_end, int num_threads) {
56 SeqHeader *seq_params = parse_ctxt->seq_header;
57 int num_planes = av1_num_planes(&seq_params->color_config);
58 int width = mi_col_end - mi_col_start;
59 /* ToDo: Bhavna : Can be optimized for ST */
60 if (num_threads == 1) {
61 int32_t num_mi_sb = seq_params->sb_mi_size;
62 int32_t sb_size_log2 = seq_params->sb_size_log2;
63 int32_t sb_aligned_width = ALIGN_POWER_OF_TWO(seq_params->max_frame_width, sb_size_log2);
64 int32_t sb_cols = sb_aligned_width >> sb_size_log2;
65 width = sb_cols * num_mi_sb;
66 }
67
68 int8_t num4_64x64 = mi_size_wide[BLOCK_64X64];
69
70 for (int i = 0; i < num_planes; i++) {
71 ZERO_ARRAY(parse_ctxt->parse_above_nbr4x4_ctxt->above_ctx[i], width);
72 ZERO_ARRAY((parse_ctxt->parse_above_nbr4x4_ctxt->above_palette_colors[i]),
73 num4_64x64 * PALETTE_MAX_SIZE);
74 }
75
76 ZERO_ARRAY(parse_ctxt->parse_above_nbr4x4_ctxt->above_seg_pred_ctx, width);
77
78 ZERO_ARRAY(parse_ctxt->parse_above_nbr4x4_ctxt->above_part_wd, width);
79
80 ZERO_ARRAY(parse_ctxt->parse_above_nbr4x4_ctxt->above_comp_grp_idx, width);
81
82 memset(parse_ctxt->parse_above_nbr4x4_ctxt->above_tx_wd,
83 tx_size_wide[TX_SIZES_LARGEST],
84 width * sizeof(uint8_t));
85 }
86
clear_left_context(ParseCtxt * parse_ctxt)87 void clear_left_context(ParseCtxt *parse_ctxt) {
88 SeqHeader *seq_params = parse_ctxt->seq_header;
89
90 /* Maintained only for 1 left SB! */
91 int blk_cnt = seq_params->sb_mi_size;
92 int num_planes = av1_num_planes(&seq_params->color_config);
93 int32_t num_4x4_neigh_sb = seq_params->sb_mi_size;
94
95 /* TODO : after Optimizing the allocation for Chroma fix here also */
96 for (int i = 0; i < num_planes; i++)
97 ZERO_ARRAY(parse_ctxt->parse_left_nbr4x4_ctxt->left_ctx[i], blk_cnt);
98
99 ZERO_ARRAY(parse_ctxt->parse_left_nbr4x4_ctxt->left_seg_pred_ctx, blk_cnt);
100
101 ZERO_ARRAY(parse_ctxt->parse_left_nbr4x4_ctxt->left_part_ht, blk_cnt);
102
103 ZERO_ARRAY(parse_ctxt->parse_left_nbr4x4_ctxt->left_comp_grp_idx, blk_cnt);
104
105 for (int i = 0; i < num_planes; i++) {
106 ZERO_ARRAY((parse_ctxt->parse_left_nbr4x4_ctxt->left_palette_colors[i]),
107 num_4x4_neigh_sb * PALETTE_MAX_SIZE);
108 }
109
110 memset(parse_ctxt->parse_left_nbr4x4_ctxt->left_tx_ht,
111 tx_size_high[TX_SIZES_LARGEST],
112 blk_cnt * sizeof(parse_ctxt->parse_left_nbr4x4_ctxt->left_tx_ht[0]));
113 }
114
clear_cdef(int8_t * sb_cdef_strength,int32_t cdef_factor)115 void clear_cdef(int8_t *sb_cdef_strength, int32_t cdef_factor) {
116 memset(sb_cdef_strength, -1, cdef_factor * sizeof(*sb_cdef_strength));
117 }
118
clear_loop_filter_delta(ParseCtxt * parse_ctx)119 void clear_loop_filter_delta(ParseCtxt *parse_ctx) {
120 for (int lf_id = 0; lf_id < FRAME_LF_COUNT; ++lf_id) parse_ctx->delta_lf[lf_id] = 0;
121 }
122
start_parse_tile(EbDecHandle * dec_handle_ptr,ParseCtxt * parse_ctxt,TilesInfo * tiles_info,int tile_num,int is_mt)123 EbErrorType start_parse_tile(EbDecHandle *dec_handle_ptr, ParseCtxt *parse_ctxt,
124 TilesInfo *tiles_info, int tile_num, int is_mt) {
125 MainParseCtxt *main_parse_ctxt = (MainParseCtxt *)dec_handle_ptr->pv_main_parse_ctxt;
126 FrameHeader * frame_header = &dec_handle_ptr->frame_header;
127 ParseTileData *parse_tile_data = &main_parse_ctxt->parse_tile_data[tile_num];
128 int tile_row = tile_num / tiles_info->tile_cols;
129 int tile_col = tile_num % tiles_info->tile_cols;
130 svt_tile_init(&parse_ctxt->cur_tile_info, frame_header, tile_row, tile_col);
131
132 parse_ctxt->cur_q_ind = frame_header->quantization_params.base_q_idx;
133
134 EbErrorType status = init_svt_reader(&parse_ctxt->r,
135 (const uint8_t *)parse_tile_data->data,
136 parse_tile_data->data_end,
137 parse_tile_data->tile_size,
138 !(parse_ctxt->frame_header->disable_cdf_update));
139 if (status != EB_ErrorNone)
140 return status;
141
142 parse_ctxt->cur_tile_ctx = main_parse_ctxt->init_frm_ctx;
143
144 /* Parse Tile */
145 status = parse_tile(
146 dec_handle_ptr, parse_ctxt, tiles_info, tile_num, tile_row, tile_col, is_mt);
147
148 /* Save CDF */
149 if (!frame_header->disable_frame_end_update_cdf &&
150 (tile_num == tiles_info->context_update_tile_id)) {
151 dec_handle_ptr->cur_pic_buf[0]->final_frm_ctx = parse_ctxt->cur_tile_ctx;
152 svt_av1_reset_cdf_symbol_counters(&dec_handle_ptr->cur_pic_buf[0]->final_frm_ctx);
153 }
154 return status;
155 }
156
parse_tile(EbDecHandle * dec_handle_ptr,ParseCtxt * parse_ctx,TilesInfo * tile_info,int tile_num,int32_t tile_row,int32_t tile_col,int32_t is_mt)157 EbErrorType parse_tile(EbDecHandle *dec_handle_ptr, ParseCtxt *parse_ctx, TilesInfo *tile_info,
158 int tile_num, int32_t tile_row, int32_t tile_col, int32_t is_mt) {
159 EbErrorType status = EB_ErrorNone;
160
161 EbColorConfig *color_config = &dec_handle_ptr->seq_header.color_config;
162 int num_planes = av1_num_planes(color_config);
163
164 clear_above_context(parse_ctx,
165 tile_info->tile_col_start_mi[tile_col],
166 tile_info->tile_col_start_mi[tile_col + 1],
167 dec_handle_ptr->dec_config.threads);
168 clear_loop_filter_delta(parse_ctx);
169
170 /* Init ParseCtxt */
171 RestorationUnitInfo *lr_unit[MAX_MB_PLANE];
172
173 // Default initialization of Wiener and SGR Filter
174 for (int p = 0; p < num_planes; ++p) {
175 lr_unit[p] = &parse_ctx->ref_lr_unit[p];
176
177 set_default_wiener(&lr_unit[p]->wiener_info);
178 set_default_sgrproj(&lr_unit[p]->sgrproj_info);
179 }
180
181 // to-do access to wiener info that is currently part of PartitionInfo
182 int32_t sb_row_tile_start = 0;
183 if (is_mt) {
184 DecMtParseReconTileInfo *parse_recon_tile_info =
185 &dec_handle_ptr->main_frame_buf.cur_frame_bufs[0]
186 .dec_mt_frame_data.parse_recon_tile_info_array[tile_num];
187
188 sb_row_tile_start = (parse_recon_tile_info->tile_info.mi_row_start << MI_SIZE_LOG2) >>
189 dec_handle_ptr->seq_header.sb_size_log2;
190 }
191 for (uint32_t mi_row = tile_info->tile_row_start_mi[tile_row];
192 mi_row < tile_info->tile_row_start_mi[tile_row + 1];
193 mi_row += dec_handle_ptr->seq_header.sb_mi_size) {
194 int32_t sb_row = (mi_row << MI_SIZE_LOG2) >> dec_handle_ptr->seq_header.sb_size_log2;
195
196 clear_left_context(parse_ctx);
197
198 /*TODO: Move CFL to thread ctxt! We need to access DecModCtxt
199 from parse_tile function . Add tile level cfl init. */
200 if (!is_mt) {
201 svt_cfl_init(&((DecModCtxt *)dec_handle_ptr->pv_dec_mod_ctxt)->cfl_ctx, color_config);
202 }
203
204 for (uint32_t mi_col = tile_info->tile_col_start_mi[tile_col];
205 mi_col < tile_info->tile_col_start_mi[tile_col + 1];
206 mi_col += dec_handle_ptr->seq_header.sb_mi_size)
207
208 {
209 int32_t sb_col = (mi_col << MI_SIZE_LOG2) >> dec_handle_ptr->seq_header.sb_size_log2;
210 uint8_t sx = color_config->subsampling_x;
211 uint8_t sy = color_config->subsampling_y;
212
213 //clear_block_decoded_flags(r, c, sbSize4)
214 MainFrameBuf *main_frame_buf = &dec_handle_ptr->main_frame_buf;
215 CurFrameBuf * frame_buf = &main_frame_buf->cur_frame_bufs[0];
216 int32_t num_mis_in_sb = main_frame_buf->num_mis_in_sb;
217
218 SBInfo *sb_info = frame_buf->sb_info + (sb_row * main_frame_buf->sb_cols) + sb_col;
219 *(main_frame_buf->frame_mi_map.pps_sb_info +
220 sb_row * main_frame_buf->frame_mi_map.sb_cols + sb_col) = sb_info;
221 sb_info->sb_mode_info = frame_buf->mode_info +
222 (sb_row * num_mis_in_sb * main_frame_buf->sb_cols) + sb_col * num_mis_in_sb;
223
224 sb_info->sb_trans_info[AOM_PLANE_Y] = frame_buf->trans_info[AOM_PLANE_Y] +
225 (sb_row * num_mis_in_sb * main_frame_buf->sb_cols) + sb_col * num_mis_in_sb;
226
227 sb_info->sb_trans_info[AOM_PLANE_U] = frame_buf->trans_info[AOM_PLANE_U] +
228 ((sb_row * num_mis_in_sb * main_frame_buf->sb_cols >> sy) +
229 (sb_col * num_mis_in_sb >> sx)) *
230 2;
231 if (dec_handle_ptr->dec_config.threads == 1) {
232 /*TODO : Change to macro */
233 sb_info->sb_coeff[AOM_PLANE_Y] = frame_buf->coeff[AOM_PLANE_Y];
234 sb_info->sb_coeff[AOM_PLANE_U] = frame_buf->coeff[AOM_PLANE_U];
235 sb_info->sb_coeff[AOM_PLANE_V] = frame_buf->coeff[AOM_PLANE_V];
236 } else {
237 /*TODO : Change to macro */
238 sb_info->sb_coeff[AOM_PLANE_Y] = frame_buf->coeff[AOM_PLANE_Y] +
239 (sb_row * num_mis_in_sb * main_frame_buf->sb_cols * (16 + 1)) +
240 sb_col * num_mis_in_sb * (16 + 1);
241 /*TODO : Change to macro */
242 sb_info->sb_coeff[AOM_PLANE_U] = frame_buf->coeff[AOM_PLANE_U] +
243 (sb_row * num_mis_in_sb * main_frame_buf->sb_cols * (16 + 1) >> (sy + sx)) +
244 (sb_col * num_mis_in_sb * (16 + 1) >> (sy + sx));
245 sb_info->sb_coeff[AOM_PLANE_V] = frame_buf->coeff[AOM_PLANE_V] +
246 (sb_row * num_mis_in_sb * main_frame_buf->sb_cols * (16 + 1) >> (sy + sx)) +
247 (sb_col * num_mis_in_sb * (16 + 1) >> (sy + sx));
248 }
249 int cdef_factor = dec_handle_ptr->seq_header.use_128x128_superblock ? 4 : 1;
250 sb_info->sb_cdef_strength = frame_buf->cdef_strength +
251 (((sb_row * main_frame_buf->sb_cols) + sb_col) * cdef_factor);
252
253 sb_info->sb_delta_lf = frame_buf->delta_lf +
254 (FRAME_LF_COUNT * ((sb_row * main_frame_buf->sb_cols) + sb_col));
255
256 sb_info->sb_delta_q = frame_buf->delta_q + (sb_row * main_frame_buf->sb_cols) + sb_col;
257
258 clear_cdef(sb_info->sb_cdef_strength, cdef_factor);
259
260 parse_ctx->first_txb_offset[AOM_PLANE_Y] = 0;
261 parse_ctx->first_txb_offset[AOM_PLANE_U] = 0;
262 parse_ctx->cur_mode_info = sb_info->sb_mode_info;
263 parse_ctx->cur_mode_info_cnt = 0;
264 parse_ctx->sb_row_mi = mi_row;
265 parse_ctx->sb_col_mi = mi_col;
266 parse_ctx->cur_coeff_buf[AOM_PLANE_Y] = sb_info->sb_coeff[AOM_PLANE_Y];
267 parse_ctx->cur_coeff_buf[AOM_PLANE_U] = sb_info->sb_coeff[AOM_PLANE_U];
268 parse_ctx->cur_coeff_buf[AOM_PLANE_V] = sb_info->sb_coeff[AOM_PLANE_V];
269 parse_ctx->prev_blk_has_chroma = 1; //default at start of frame / tile
270
271 sb_info->num_block = 0;
272 // Bit-stream parsing of the superblock
273 parse_super_block(dec_handle_ptr, parse_ctx, mi_row, mi_col, sb_info);
274
275 if (!is_mt) {
276 /* Init DecModCtxt */
277 DecModCtxt *dec_mod_ctxt = (DecModCtxt *)dec_handle_ptr->pv_dec_mod_ctxt;
278 dec_mod_ctxt->cur_coeff[AOM_PLANE_Y] = sb_info->sb_coeff[AOM_PLANE_Y];
279 dec_mod_ctxt->cur_coeff[AOM_PLANE_U] = sb_info->sb_coeff[AOM_PLANE_U];
280 dec_mod_ctxt->cur_coeff[AOM_PLANE_V] = sb_info->sb_coeff[AOM_PLANE_V];
281
282 dec_mod_ctxt->cur_tile_info = parse_ctx->cur_tile_info;
283
284 /* TO DO : Will move later */
285 // decoding of the superblock
286 decode_super_block(dec_mod_ctxt, mi_row, mi_col, sb_info);
287 }
288 }
289 if (is_mt) {
290 DecMtFrameData *dec_mt_frame_data =
291 &dec_handle_ptr->main_frame_buf.cur_frame_bufs[0]
292 .dec_mt_frame_data; //multi frame Parallel 0 -> idx
293 assert(sb_row >= sb_row_tile_start);
294 dec_mt_frame_data->parse_recon_tile_info_array[tile_num]
295 .sb_recon_row_parsed[sb_row - sb_row_tile_start] = 1;
296 }
297 }
298
299 return status;
300 }
301