1 /* SPDX-License-Identifier: Apache-2.0 OR MIT */
2 /*
3 * Copyright (c) 2017 Rockchip Electronics Co., Ltd.
4 */
5
6 #define MODULE_TAG "hal_vp8e_entropy"
7
8 #include <string.h>
9
10 #include "mpp_common.h"
11
12 #include "hal_vp8e_base.h"
13 #include "hal_vp8e_entropy.h"
14 #include "hal_vp8e_putbit.h"
15 #include "hal_vp8e_table.h"
16
17 #define COST_BOOL(prob, bin)\
18 ((bin) ? vp8_prob_cost_tbl[255 - (prob)] : vp8_prob_cost_tbl[prob])
19
calc_mvprob(RK_U32 left,RK_U32 right,RK_U32 prob)20 static RK_U32 calc_mvprob(RK_U32 left, RK_U32 right, RK_U32 prob)
21 {
22 RK_U32 p;
23
24 if (left + right) {
25 p = (left * 255) / (left + right);
26 p &= -2;
27 if (!p)
28 p = 1;
29 } else
30 p = prob;
31
32 return p;
33 }
34
update_prob(RK_U32 prob,RK_U32 left,RK_U32 right,RK_U32 old_prob,RK_U32 new_prob,RK_U32 fixed)35 static RK_U32 update_prob(RK_U32 prob, RK_U32 left, RK_U32 right,
36 RK_U32 old_prob, RK_U32 new_prob, RK_U32 fixed)
37 {
38 RK_S32 u, s;
39
40 u = (RK_S32)fixed + ((vp8_prob_cost_tbl[255 - prob] - vp8_prob_cost_tbl[prob]) >> 8);
41 s = ((RK_S32)left * (vp8_prob_cost_tbl[old_prob] - vp8_prob_cost_tbl[new_prob]) +
42 (RK_S32)right * (vp8_prob_cost_tbl[255 - old_prob] - vp8_prob_cost_tbl[255 - new_prob])) >> 8;
43
44 return (s > u);
45 }
46
get_cost_tree(Vp8eTree const * tree,RK_S32 * prob)47 static RK_S32 get_cost_tree(Vp8eTree const *tree, RK_S32 *prob)
48 {
49 RK_S32 bit_cost = 0;
50 RK_S32 value = tree->value;
51 RK_S32 number = tree->number;
52 RK_S32 const *index = tree->index;
53
54 while (number--) {
55 bit_cost += COST_BOOL(prob[*index++], (value >> number) & 1);
56 }
57
58 return bit_cost;
59 }
60
vp8e_init_entropy(void * hal)61 MPP_RET vp8e_init_entropy(void *hal)
62 {
63 HalVp8eCtx *ctx = (HalVp8eCtx *)hal;
64
65 Vp8eVpuBuf *buffers = (Vp8eVpuBuf *)ctx->buffers;
66 Vp8eHalEntropy *entropy = &ctx->entropy;
67
68 entropy->update_coeff_prob_flag = 0;
69 if (!ctx->sps.refresh_entropy || ctx->picbuf.cur_pic->i_frame) {
70 if (!entropy->default_coeff_prob_flag) {
71 memcpy(entropy->coeff_prob, default_prob_coeff_tbl, sizeof(default_prob_coeff_tbl));
72 entropy->update_coeff_prob_flag = 1;
73 }
74 memcpy(entropy->mv_prob, default_prob_mv_tbl, sizeof(default_prob_mv_tbl));
75 entropy->default_coeff_prob_flag = 1;
76 }
77
78 memcpy(entropy->old_coeff_prob, entropy->coeff_prob, sizeof(entropy->coeff_prob));
79 if (ctx->frame_cnt == 0 || !ctx->last_frm_intra)
80 memcpy(entropy->old_mv_prob, entropy->mv_prob, sizeof(entropy->mv_prob));
81
82 entropy->skip_false_prob = default_skip_false_prob_tbl[ctx->rc->qp_hdr];
83
84 if (ctx->frame_cnt == 0)
85 return MPP_OK;
86
87 if ((!ctx->picbuf.cur_pic->ipf) && (!ctx->picbuf.cur_pic->grf) &&
88 (!ctx->picbuf.cur_pic->arf))
89 return MPP_OK;
90
91 if (ctx->prev_frame_lost)
92 return MPP_OK;
93 {
94 RK_S32 i, j, k, l;
95
96 RK_U32 p, left, right;
97 RK_U32 old_p, upd_p = 0;
98
99 RK_U32 type;
100 RK_U32 branch_cnt[2];
101 RK_U16 *p_tmp = NULL;
102
103 RK_U16 *p_cnt = (RK_U16 *)mpp_buffer_get_ptr(buffers->hw_prob_count_buf);
104
105 mpp_buffer_sync_end(buffers->hw_prob_count_buf);
106
107 for (i = 0; i < 4; i++) {
108 for (j = 0; j < 7; j++) {
109 for (k = 0; k < 3; k++) {
110 RK_S32 tmp, ii;
111
112 tmp = i * 7 * 3 + j * 3 + k;
113 tmp += 2 * 4 * 7 * 3;
114 ii = offset_tbl[tmp];
115
116 right = ii >= 0 ? p_cnt[ii] : 0;
117
118 for (l = 2; l--;) {
119 old_p = entropy->coeff_prob[i][j][k][l];
120 upd_p = coeff_update_prob_tbl[i][j][k][l];
121
122 tmp -= 4 * 7 * 3;
123 ii = offset_tbl[tmp];
124 left = ii >= 0 ? p_cnt[ii] : 0;
125 if (left + right) {
126 p = ((left * 256) + ((left + right) >> 1)) / (left + right);
127 if (p > 255) p = 255;
128 } else
129 p = old_p;
130
131 if (update_prob(upd_p, left, right, old_p, p, 8)) {
132 entropy->coeff_prob[i][j][k][l] = p;
133 entropy->update_coeff_prob_flag = 1;
134 }
135 right += left;
136 }
137 }
138 }
139 }
140
141 if (entropy->update_coeff_prob_flag)
142 entropy->default_coeff_prob_flag = 0;
143
144 p_tmp = p_cnt + VP8_PROB_COUNT_MV_OFFSET;
145 for (i = 0; i < 2; i++) {
146 left = *p_tmp++;
147 right = *p_tmp++;
148
149 p = calc_mvprob(left, right, entropy->old_mv_prob[i][0]);
150
151 if (update_prob(mv_update_prob_tbl[i][0], left, right,
152 entropy->old_mv_prob[i][0], p, 6))
153 entropy->mv_prob[i][0] = p;
154
155 right += left;
156 left = *p_tmp++;
157 right -= left - p_tmp[0];
158
159 p = calc_mvprob(left, right, entropy->old_mv_prob[i][1]);
160 if (update_prob(mv_update_prob_tbl[i][1], left, right,
161 entropy->old_mv_prob[i][1], p, 6))
162 entropy->mv_prob[i][1] = p;
163
164 for (j = 0; j < 2; j++) {
165 left = *p_tmp++;
166 right = *p_tmp++;
167 p = calc_mvprob(left, right, entropy->old_mv_prob[i][4 + j]);
168 if (update_prob(mv_update_prob_tbl[i][4 + j], left, right,
169 entropy->old_mv_prob[i][4 + j], p, 6))
170 entropy->mv_prob[i][4 + j] = p;
171 branch_cnt[j] = left + right;
172 }
173
174 p = calc_mvprob(branch_cnt[0], branch_cnt[1], entropy->old_mv_prob[i][3]);
175 if (update_prob(mv_update_prob_tbl[i][3], branch_cnt[0], branch_cnt[1],
176 entropy->old_mv_prob[i][3], p, 6))
177 entropy->mv_prob[i][3] = p;
178
179 type = branch_cnt[0] + branch_cnt[1];
180
181 for (j = 0; j < 2; j++) {
182 left = *p_tmp++;
183 right = *p_tmp++;
184 p = calc_mvprob(left, right, entropy->old_mv_prob[i][7 + j]);
185 if (update_prob(mv_update_prob_tbl[i][7 + j], left, right,
186 entropy->old_mv_prob[i][7 + j], p, 6))
187 entropy->mv_prob[i][7 + j] = p;
188 branch_cnt[j] = left + right;
189 }
190
191 p = calc_mvprob(branch_cnt[0], branch_cnt[1], entropy->old_mv_prob[i][6]);
192 if (update_prob(mv_update_prob_tbl[i][6], branch_cnt[0], branch_cnt[1],
193 entropy->old_mv_prob[i][6], p, 6))
194 entropy->mv_prob[i][6] = p;
195
196 p = calc_mvprob(type, branch_cnt[0] + branch_cnt[1],
197 entropy->old_mv_prob[i][2]);
198 if (update_prob(mv_update_prob_tbl[i][2], type, branch_cnt[0] + branch_cnt[1],
199 entropy->old_mv_prob[i][2], p, 6))
200 entropy->mv_prob[i][2] = p;
201 }
202 }
203 {
204 entropy->last_prob = 255;
205 entropy->gf_prob = 128;
206 memcpy(entropy->y_mode_prob, y_mode_prob_tbl, sizeof(y_mode_prob_tbl));
207 memcpy(entropy->uv_mode_prob, uv_mode_prob_tbl, sizeof(uv_mode_prob_tbl));
208 }
209 return MPP_OK;
210 }
211
vp8e_swap_endian(RK_U32 * buf,RK_U32 bytes)212 MPP_RET vp8e_swap_endian(RK_U32 *buf, RK_U32 bytes)
213 {
214 RK_U32 i = 0;
215 RK_S32 words = bytes / 4;
216
217 while (words > 0) {
218 RK_U32 val = buf[i];
219 RK_U32 tmp = 0;
220
221 tmp |= (val & 0xFF) << 24;
222 tmp |= (val & 0xFF00) << 8;
223 tmp |= (val & 0xFF0000) >> 8;
224 tmp |= (val & 0xFF000000) >> 24;
225
226 {
227 RK_U32 val2 = buf[i + 1];
228 RK_U32 tmp2 = 0;
229
230 tmp2 |= (val2 & 0xFF) << 24;
231 tmp2 |= (val2 & 0xFF00) << 8;
232 tmp2 |= (val2 & 0xFF0000) >> 8;
233 tmp2 |= (val2 & 0xFF000000) >> 24;
234
235 buf[i] = tmp2;
236 words--;
237 i++;
238 }
239
240 buf[i] = tmp;
241 words--;
242 i++;
243 }
244 return MPP_OK;
245 }
246
247
vp8e_write_entropy_tables(void * hal)248 MPP_RET vp8e_write_entropy_tables(void *hal)
249 {
250 HalVp8eCtx *ctx = (HalVp8eCtx *)hal;
251
252 Vp8eVpuBuf *buffers = (Vp8eVpuBuf *)ctx->buffers;
253 Vp8eHalEntropy *entropy = &ctx->entropy;
254
255 RK_U8 *table = (RK_U8 *)mpp_buffer_get_ptr(buffers->hw_cabac_table_buf);
256 /* Write probability tables to ASIC linear memory, reg + mem */
257 memset(table, 0, 56); // use 56 bytes
258 table[0] = entropy->skip_false_prob;
259 table[1] = entropy->intra_prob;
260 table[2] = entropy->last_prob;
261 table[3] = entropy->gf_prob;
262 table[4] = entropy->segment_prob[0];
263 table[5] = entropy->segment_prob[1];
264 table[6] = entropy->segment_prob[2];
265
266 table[8] = entropy->y_mode_prob[0];
267 table[9] = entropy->y_mode_prob[1];
268 table[10] = entropy->y_mode_prob[2];
269 table[11] = entropy->y_mode_prob[3];
270 table[12] = entropy->uv_mode_prob[0];
271 table[13] = entropy->uv_mode_prob[1];
272 table[14] = entropy->uv_mode_prob[2];
273
274 /* MV probabilities x+y: short, sign, size 8-9 */
275 table[16] = entropy->mv_prob[1][0];
276 table[17] = entropy->mv_prob[0][0];
277 table[18] = entropy->mv_prob[1][1];
278 table[19] = entropy->mv_prob[0][1];
279 table[20] = entropy->mv_prob[1][17];
280 table[21] = entropy->mv_prob[1][18];
281 table[22] = entropy->mv_prob[0][17];
282 table[23] = entropy->mv_prob[0][18];
283 {
284 RK_S32 i, j, k, l;
285 /* MV X size */
286 for (i = 0; i < 8; i++)
287 table[24 + i] = entropy->mv_prob[1][9 + i];
288
289 /* MV Y size */
290 for (i = 0; i < 8; i++)
291 table[32 + i] = entropy->mv_prob[0][9 + i];
292
293 /* MV X short tree */
294 for (i = 0; i < 7; i++)
295 table[40 + i] = entropy->mv_prob[1][2 + i];
296
297 /* MV Y short tree */
298 for (i = 0; i < 7; i++)
299 table[48 + i] = entropy->mv_prob[0][2 + i];
300
301 /* Update the ASIC table when needed. */
302 if (entropy->update_coeff_prob_flag) {
303 table += 56;
304 /* DCT coeff probabilities 0-2, two fields per line. */
305 for (i = 0; i < 4; i++)
306 for (j = 0; j < 8; j++)
307 for (k = 0; k < 3; k++) {
308 for (l = 0; l < 3; l++) {
309 *table++ = entropy->coeff_prob[i][j][k][l];
310 }
311 *table++ = 0;
312 }
313
314 /* ASIC second probability table in ext mem.
315 * DCT coeff probabilities 4 5 6 7 8 9 10 3 on each line.
316 * coeff 3 was moved from first table to second so it is last. */
317 for (i = 0; i < 4; i++)
318 for (j = 0; j < 8; j++)
319 for (k = 0; k < 3; k++) {
320 for (l = 4; l < 11; l++) {
321 *table++ = entropy->coeff_prob[i][j][k][l];
322 }
323 *table++ = entropy->coeff_prob[i][j][k][3];
324 }
325 }
326 }
327 table = mpp_buffer_get_ptr(buffers->hw_cabac_table_buf);
328 if (entropy->update_coeff_prob_flag)
329 vp8e_swap_endian((RK_U32 *) table, 56 + 8 * 48 + 8 * 96);
330 else
331 vp8e_swap_endian((RK_U32 *) table, 56);
332
333 mpp_buffer_sync_end(buffers->hw_cabac_table_buf);
334
335 return MPP_OK;
336 }
337
vp8e_calc_cost_mv(RK_S32 mvd,RK_S32 * mv_prob)338 RK_S32 vp8e_calc_cost_mv(RK_S32 mvd, RK_S32 *mv_prob)
339 {
340 RK_S32 i = 0;
341 RK_S32 bit_cost = 0;
342
343 RK_S32 tmp = MPP_ABS(mvd >> 1);
344
345 if (tmp < 8) {
346 bit_cost += COST_BOOL(mv_prob[0], 0);
347 bit_cost += get_cost_tree(&mv_tree_tbl[tmp], mv_prob + 2);
348 if (!tmp)
349 return bit_cost;
350
351 /* Sign */
352 bit_cost += COST_BOOL(mv_prob[1], mvd < 0);
353 return bit_cost;
354 }
355
356 bit_cost += COST_BOOL(mv_prob[0], 1);
357
358 for (i = 0; i < 3; i++) {
359 bit_cost += COST_BOOL(mv_prob[9 + i], (tmp >> i) & 1);
360 }
361
362 for (i = 9; i > 3; i--) {
363 bit_cost += COST_BOOL(mv_prob[9 + i], (tmp >> i) & 1);
364 }
365
366 if (tmp > 15) {
367 bit_cost += COST_BOOL(mv_prob[9 + 3], (tmp >> 3) & 1);
368 }
369
370 bit_cost += COST_BOOL(mv_prob[1], mvd < 0);
371
372 return bit_cost;
373 }
374
vp8e_calc_coeff_prob(Vp8ePutBitBuf * bitbuf,RK_S32 (* curr)[4][8][3][11],RK_S32 (* prev)[4][8][3][11])375 MPP_RET vp8e_calc_coeff_prob(Vp8ePutBitBuf *bitbuf, RK_S32 (*curr)[4][8][3][11],
376 RK_S32 (*prev)[4][8][3][11])
377 {
378 RK_S32 i, j, k, l;
379 RK_S32 prob, new, old;
380
381 for (i = 0; i < 4; i++) {
382 for (j = 0; j < 8; j++) {
383 for (k = 0; k < 3; k++) {
384 for (l = 0; l < 11; l++) {
385 prob = coeff_update_prob_tbl[i][j][k][l];
386 old = (RK_S32) (*prev)[i][j][k][l];
387 new = (RK_S32) (*curr)[i][j][k][l];
388
389 if (new == old) {
390 vp8e_put_bool(bitbuf, prob, 0);
391 } else {
392 vp8e_put_bool(bitbuf, prob, 1);
393 vp8e_put_lit(bitbuf, new, 8);
394 }
395 }
396 }
397 }
398 }
399 return MPP_OK;
400 }
401
vp8e_calc_mv_prob(Vp8ePutBitBuf * bitbuf,RK_S32 (* curr)[2][19],RK_S32 (* prev)[2][19])402 MPP_RET vp8e_calc_mv_prob(Vp8ePutBitBuf *bitbuf, RK_S32 (*curr)[2][19],
403 RK_S32 (*prev)[2][19])
404 {
405 RK_S32 i, j;
406 RK_S32 prob, new, old;
407
408 for (i = 0; i < 2; i++) {
409 for (j = 0; j < 19; j++) {
410 prob = mv_update_prob_tbl[i][j];
411 old = (RK_S32) (*prev)[i][j];
412 new = (RK_S32) (*curr)[i][j];
413
414 if (new == old) {
415 vp8e_put_bool(bitbuf, prob, 0);
416 } else {
417 vp8e_put_bool(bitbuf, prob, 1);
418 vp8e_put_lit(bitbuf, new >> 1, 7);
419 }
420 }
421 }
422 return MPP_OK;
423 }
424