1 /*
2 * Copyright (c) 2022 Samsung Electronics Co., Ltd.
3 * All Rights Reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are met:
7 *
8 * - Redistributions of source code must retain the above copyright notice,
9 * this list of conditions and the following disclaimer.
10 *
11 * - Redistributions in binary form must reproduce the above copyright notice,
12 * this list of conditions and the following disclaimer in the documentation
13 * and/or other materials provided with the distribution.
14 *
15 * - Neither the name of the copyright owner, nor the names of its contributors
16 * may be used to endorse or promote products derived from this software
17 * without specific prior written permission.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
20 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22 * ARE DISCLAIMED.IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
23 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24 * CONSEQUENTIAL DAMAGES(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 */
31
32 #include "oapv_def.h"
33 #include "oapv_metadata.h"
34
35 #define OAPV_FLUSH_SWAP(cur, code, lb) \
36 { \
37 *cur++ = (code >> 24) & 0xFF; \
38 *cur++ = (code >> 16) & 0xFF; \
39 *cur++ = (code >> 8) & 0xFF; \
40 *cur++ = (code) & 0xFF; \
41 code = 0; \
42 lb = 32; \
43 }
44
45 #define OAPV_FLUSH(bs) \
46 { \
47 *bs->cur++ = (bs->code >> 24) & 0xFF; \
48 *bs->cur++ = (bs->code >> 16) & 0xFF; \
49 *bs->cur++ = (bs->code >> 8) & 0xFF; \
50 *bs->cur++ = (bs->code) & 0xFF; \
51 bs->code = 0; \
52 bs->leftbits = 32; \
53 }
54
55 #define OAPV_READ_FLUSH(bs, byte) \
56 { \
57 bs->code = 0; \
58 bs->code |= *(bs->cur++) << 24; \
59 bs->code |= *(bs->cur++) << 16; \
60 bs->code |= *(bs->cur++) << 8; \
61 bs->code |= *(bs->cur++); \
62 bs->leftbits = 32; \
63 }
64
65 ///////////////////////////////////////////////////////////////////////////////
66 // start of encoder code
67 #if ENABLE_ENCODER
68 ///////////////////////////////////////////////////////////////////////////////
69
enc_vlc_write(oapv_bs_t * bs,int coef,int k)70 static inline void enc_vlc_write(oapv_bs_t *bs, int coef, int k)
71 {
72 const s32 simple_vlc_table[3][2] = { {
73 1,
74 },
75 { 0, 0 },
76 { 0, 1 } };
77 u32 symbol = coef;
78 u32 simple_vlc_val = oapv_clip3(0, 2, symbol >> k);
79 int bit_cnt = 0;
80 if(bs->is_bin_count) {
81 bs->bin_count += coef;
82 return;
83 }
84 if(symbol >= (u32)(1 << k)) {
85 symbol -= (1 << k);
86 int val = simple_vlc_table[simple_vlc_val][bit_cnt];
87 bs->leftbits--;
88 bs->code |= ((val & 0x1) << bs->leftbits);
89 if(bs->leftbits == 0) {
90 OAPV_FLUSH(bs);
91 }
92 bit_cnt++;
93 }
94 if(symbol >= (u32)(1 << k) && simple_vlc_val > 0) {
95 symbol -= (1 << k);
96 int val = simple_vlc_table[simple_vlc_val][bit_cnt];
97 bs->leftbits--;
98 bs->code |= ((val & 0x1) << bs->leftbits);
99 if(bs->leftbits == 0) {
100 OAPV_FLUSH(bs);
101 }
102 bit_cnt++;
103 }
104 while(symbol >= (u32)(1 << k)) {
105 symbol -= (1 << k);
106 bs->leftbits--;
107 if(bs->leftbits == 0) {
108 OAPV_FLUSH(bs);
109 }
110 if(bit_cnt >= 2) {
111 k++;
112 }
113 bit_cnt++;
114 }
115 if(bit_cnt < 2) {
116 int val = simple_vlc_table[simple_vlc_val][bit_cnt];
117 bs->leftbits--;
118 bs->code |= ((val & 0x1) << bs->leftbits);
119 if(bs->leftbits == 0) {
120 OAPV_FLUSH(bs);
121 }
122 }
123 else {
124 bs->leftbits--;
125 bs->code |= ((1 & 0x1) << bs->leftbits);
126 if(bs->leftbits == 0) {
127 OAPV_FLUSH(bs);
128 }
129 }
130 if(k > 0) {
131 int leftbits;
132 leftbits = bs->leftbits;
133 symbol <<= (32 - k);
134 bs->code |= (symbol >> (32 - leftbits));
135 if(k < leftbits) {
136 bs->leftbits -= k;
137 }
138 else {
139 bs->leftbits = 0;
140 OAPV_FLUSH(bs);
141 bs->code = (leftbits < 32 ? symbol << leftbits : 0);
142 bs->leftbits = 32 - (k - leftbits);
143 }
144 }
145 }
146
bsr_skip_code_opt(oapv_bs_t * bs,int size)147 static void inline bsr_skip_code_opt(oapv_bs_t *bs, int size)
148 {
149
150 if(size == 32) {
151 bs->code = 0;
152 bs->leftbits = 0;
153 }
154 else {
155 bs->code <<= size;
156 bs->leftbits -= size;
157 }
158 }
dec_vlc_read_1bit_read(oapv_bs_t * bs,int k)159 static int dec_vlc_read_1bit_read(oapv_bs_t *bs, int k)
160 {
161 u32 symbol = 0;
162 int t0 = -1;
163 int parse_exp_golomb = 1;
164 if(bs->leftbits == 0) {
165 OAPV_READ_FLUSH(bs, 4);
166 }
167 t0 = (u32)(bs->code >> 31);
168 bs->code <<= 1;
169 bs->leftbits -= 1;
170 if(t0 == 0) {
171 symbol += (1 << k);
172 parse_exp_golomb = 0;
173 }
174 else {
175 symbol += (2 << k);
176 parse_exp_golomb = 1;
177 }
178 if(parse_exp_golomb) {
179 while(1) {
180 if(bs->leftbits == 0) {
181 OAPV_READ_FLUSH(bs, 4);
182 }
183 t0 = (u32)(bs->code >> 31);
184 bs->code <<= 1;
185 bs->leftbits -= 1;
186 if(t0 == 1) {
187 break;
188 }
189 else {
190 symbol += (1 << k);
191 k++;
192 }
193 }
194 }
195 if(k > 0) {
196 u32 code = 0;
197 if(bs->leftbits < k) {
198 code = bs->code >> (32 - k);
199 k -= bs->leftbits;
200 OAPV_READ_FLUSH(bs, 4);
201 }
202 code |= bs->code >> (32 - k);
203 bsr_skip_code_opt(bs, k);
204 symbol += code;
205 }
206 return symbol;
207 }
dec_vlc_read(oapv_bs_t * bs,int k)208 static int dec_vlc_read(oapv_bs_t *bs, int k)
209 {
210 u32 symbol = 0;
211 int t0 = -1;
212 int parse_exp_golomb = 1;
213 if(bs->leftbits == 0) {
214 OAPV_READ_FLUSH(bs, 4);
215 }
216 t0 = (u32)(bs->code >> 31);
217 bs->code <<= 1;
218 bs->leftbits -= 1;
219 if(t0 == 1) {
220 parse_exp_golomb = 0;
221 }
222 else {
223 if(bs->leftbits == 0) {
224 OAPV_READ_FLUSH(bs, 4);
225 }
226 t0 = (u32)(bs->code >> 31);
227 bs->code <<= 1;
228 bs->leftbits -= 1;
229 if(t0 == 0) {
230 symbol += (1 << k);
231 parse_exp_golomb = 0;
232 }
233 else {
234 symbol += (2 << k);
235 parse_exp_golomb = 1;
236 }
237 }
238 if(parse_exp_golomb) {
239 while(1) {
240 if(bs->leftbits == 0) {
241 OAPV_READ_FLUSH(bs, 4);
242 }
243 t0 = (u32)(bs->code >> 31);
244 bs->code <<= 1;
245 bs->leftbits -= 1;
246 if(t0 == 1) {
247 break;
248 }
249 else {
250 symbol += (1 << k);
251 k++;
252 }
253 }
254 }
255 if(k > 0) {
256 u32 code = 0;
257 if(bs->leftbits < k) {
258 code = bs->code >> (32 - k);
259 k -= bs->leftbits;
260 OAPV_READ_FLUSH(bs, 4);
261 }
262 code |= bs->code >> (32 - k);
263 bsr_skip_code_opt(bs, k);
264 symbol += code;
265 }
266 return symbol;
267 }
268
oapve_set_frame_header(oapve_ctx_t * ctx,oapv_fh_t * fh)269 void oapve_set_frame_header(oapve_ctx_t *ctx, oapv_fh_t *fh)
270 {
271 oapv_mset(fh, 0, sizeof(oapv_fh_t));
272 fh->fi.profile_idc = ctx->param->profile_idc;
273 fh->fi.level_idc = ctx->param->level_idc;
274 fh->fi.band_idc = ctx->param->band_idc;
275 fh->fi.frame_width = ctx->param->w;
276 fh->fi.frame_height = ctx->param->h;
277 fh->fi.chroma_format_idc = ctx->cfi;
278 fh->fi.bit_depth = ctx->bit_depth;
279 fh->tile_width_in_mbs = ctx->param->tile_w_mb;
280 fh->tile_height_in_mbs = ctx->param->tile_h_mb;
281 if(fh->color_description_present_flag == 0) {
282 fh->color_primaries = 2;
283 fh->transfer_characteristics = 2;
284 fh->matrix_coefficients = 2;
285 }
286 fh->use_q_matrix = ctx->param->use_q_matrix;
287 if(fh->use_q_matrix == 0) {
288 for(int cidx = 0; cidx < ctx->num_comp; cidx++) {
289 for(int y = 0; y < OAPV_BLK_H; y++) {
290 for(int x = 0; x < OAPV_BLK_W; x++) {
291 fh->q_matrix[cidx][y][x] = 16;
292 }
293 }
294 }
295 }
296 else {
297 int mod = (1 << OAPV_LOG2_BLK) - 1;
298 for(int i = 0; i < OAPV_BLK_D; i++) {
299 fh->q_matrix[Y_C][i >> OAPV_LOG2_BLK][i & mod] = ctx->param->q_matrix_y[i];
300 fh->q_matrix[U_C][i >> OAPV_LOG2_BLK][i & mod] = ctx->param->q_matrix_u[i];
301 fh->q_matrix[V_C][i >> OAPV_LOG2_BLK][i & mod] = ctx->param->q_matrix_v[i];
302 fh->q_matrix[X_C][i >> OAPV_LOG2_BLK][i & mod] = ctx->param->q_matrix_x[i];
303 }
304 }
305 fh->tile_size_present_in_fh_flag = 0;
306 }
307
enc_vlc_quantization_matrix(oapv_bs_t * bs,oapve_ctx_t * ctx,oapv_fh_t * fh)308 static int enc_vlc_quantization_matrix(oapv_bs_t *bs, oapve_ctx_t *ctx, oapv_fh_t *fh)
309 {
310 for(int cidx = 0; cidx < ctx->num_comp; cidx++) {
311 for(int y = 0; y < 8; y++) {
312 for(int x = 0; x < 8; x++) {
313 oapv_bsw_write(bs, fh->q_matrix[cidx][y][x] - 1, 8);
314 DUMP_HLS(fh->q_matrix, fh->q_matrix[cidx][y][x]);
315 }
316 }
317 }
318 return 0;
319 }
320
enc_vlc_tile_info(oapv_bs_t * bs,oapve_ctx_t * ctx,oapv_fh_t * fh)321 static int enc_vlc_tile_info(oapv_bs_t *bs, oapve_ctx_t *ctx, oapv_fh_t *fh)
322 {
323 oapv_bsw_write(bs, fh->tile_width_in_mbs - 1, 28);
324 DUMP_HLS(fh->tile_width_in_mbs, fh->tile_width_in_mbs);
325 oapv_bsw_write(bs, fh->tile_height_in_mbs - 1, 28);
326 DUMP_HLS(fh->tile_height_in_mbs, fh->tile_height_in_mbs);
327 oapv_bsw_write(bs, fh->tile_size_present_in_fh_flag, 1);
328 DUMP_HLS(fh->tile_size_present_in_fh_flag, fh->tile_size_present_in_fh_flag);
329 if(fh->tile_size_present_in_fh_flag) {
330 for(int i = 0; i < ctx->num_tiles; i++) {
331 oapv_bsw_write(bs, fh->tile_size[i] - 1, 32);
332 DUMP_HLS(fh->tile_size, fh->tile_size[i] - 1);
333 }
334 }
335
336 return 0;
337 }
338
oapve_vlc_frame_info(oapv_bs_t * bs,oapv_fi_t * fi)339 int oapve_vlc_frame_info(oapv_bs_t *bs, oapv_fi_t *fi)
340 {
341 oapv_bsw_write(bs, fi->profile_idc, 8);
342 DUMP_HLS(fi->profile_idc, fi->profile_idc);
343 oapv_bsw_write(bs, fi->level_idc, 8);
344 DUMP_HLS(fi->level_idc, fi->level_idc);
345 oapv_bsw_write(bs, fi->band_idc, 3);
346 DUMP_HLS(fi->band_idc, fi->band_idc);
347 oapv_bsw_write(bs, 0, 5); // reserved_zero_5bits
348 DUMP_HLS(reserved_zero, 0);
349 oapv_bsw_write(bs, fi->frame_width - 1, 32);
350 DUMP_HLS(fi->frame_width, fi->frame_width - 1);
351 oapv_bsw_write(bs, fi->frame_height - 1, 32);
352 DUMP_HLS(fi->frame_height, fi->frame_height - 1);
353 oapv_bsw_write(bs, fi->chroma_format_idc, 4);
354 DUMP_HLS(fi->chroma_format_idc, fi->chroma_format_idc);
355 oapv_bsw_write(bs, fi->bit_depth - 8, 4);
356 DUMP_HLS(fi->bit_depth, fi->bit_depth - 8);
357 oapv_bsw_write(bs, fi->capture_time_distance, 8);
358 DUMP_HLS(fi->capture_time_distance, fi->capture_time_distance);
359 oapv_bsw_write(bs, 0, 8); // reserved_zero_8bits
360 DUMP_HLS(reserved_zero, 0);
361 return OAPV_OK;
362 }
363
oapve_vlc_frame_header(oapv_bs_t * bs,oapve_ctx_t * ctx,oapv_fh_t * fh)364 int oapve_vlc_frame_header(oapv_bs_t *bs, oapve_ctx_t *ctx, oapv_fh_t *fh)
365 {
366 oapv_assert_rv(bsw_is_align8(bs), OAPV_ERR_MALFORMED_BITSTREAM);
367
368 oapve_vlc_frame_info(bs, &fh->fi);
369 oapv_bsw_write(bs, 0, 8); // reserved_zero_8bits
370 DUMP_HLS(reserved_zero, 0);
371 oapv_bsw_write(bs, fh->color_description_present_flag, 1);
372 DUMP_HLS(fh->color_description_present_flag, fh->color_description_present_flag);
373 if(fh->color_description_present_flag) {
374 oapv_bsw_write(bs, fh->color_primaries, 8);
375 DUMP_HLS(fh->color_primaries, fh->color_primaries);
376 oapv_bsw_write(bs, fh->transfer_characteristics, 8);
377 DUMP_HLS(fh->transfer_characteristics, fh->transfer_characteristics);
378 oapv_bsw_write(bs, fh->matrix_coefficients, 8);
379 DUMP_HLS(fh->matrix_coefficients, fh->matrix_coefficients);
380 }
381 oapv_bsw_write(bs, fh->use_q_matrix, 1);
382 DUMP_HLS(fh->use_q_matrix, fh->use_q_matrix);
383 if(fh->use_q_matrix) {
384 enc_vlc_quantization_matrix(bs, ctx, fh);
385 }
386 enc_vlc_tile_info(bs, ctx, fh);
387
388 oapv_bsw_write(bs, 0, 8); // reserved_zero_8bits
389 DUMP_HLS(reserved_zero, 0);
390 return OAPV_OK;
391 }
392
oapve_vlc_tile_size(oapv_bs_t * bs,int tile_size)393 int oapve_vlc_tile_size(oapv_bs_t *bs, int tile_size)
394 {
395 oapv_assert_rv(bsw_is_align8(bs), OAPV_ERR_MALFORMED_BITSTREAM);
396 oapv_bsw_write(bs, tile_size - 1, 32);
397 DUMP_HLS(tile_size, tile_size - 1);
398 return OAPV_OK;
399 }
400
oapve_set_tile_header(oapve_ctx_t * ctx,oapv_th_t * th,int tile_idx,int qp)401 void oapve_set_tile_header(oapve_ctx_t *ctx, oapv_th_t *th, int tile_idx, int qp)
402 {
403 oapv_mset(th, 0, sizeof(oapv_th_t));
404 for(int c = 0; c < ctx->num_comp; c++) {
405 th->tile_qp[c] = qp;
406 if(c == 1) {
407 th->tile_qp[c] += ctx->param->qp_cb_offset;
408 }
409 else if(c == 2) {
410 th->tile_qp[c] += ctx->param->qp_cr_offset;
411 }
412 }
413 th->tile_index = tile_idx;
414
415 for(int i = 0; i < N_C; i++) {
416 // this setting is required to prevent underflow at dummy writing tile header due to '-1'.
417 th->tile_data_size[i] = 1;
418 }
419 }
420
oapve_vlc_tile_header(oapve_ctx_t * ctx,oapv_bs_t * bs,oapv_th_t * th)421 int oapve_vlc_tile_header(oapve_ctx_t *ctx, oapv_bs_t *bs, oapv_th_t *th)
422 {
423 oapv_assert_rv(bsw_is_align8(bs), OAPV_ERR_MALFORMED_BITSTREAM);
424 th->tile_header_size = 5; // tile_header_size + tile_index + reserved_zero_8bits
425 th->tile_header_size += (ctx->num_comp * 5); // tile_data_size + tile_qp
426
427 oapv_bsw_write(bs, th->tile_header_size, 16);
428 DUMP_HLS(th->tile_header_size, th->tile_header_size);
429 oapv_bsw_write(bs, th->tile_index, 16);
430 DUMP_HLS(th->tile_index, th->tile_index);
431 for(int c = 0; c < ctx->num_comp; c++) {
432 oapv_bsw_write(bs, th->tile_data_size[c] - 1, 32);
433 DUMP_HLS(th->tile_data_size, th->tile_data_size[c] - 1);
434 }
435 for(int c = 0; c < ctx->num_comp; c++) {
436 oapv_bsw_write(bs, th->tile_qp[c], 8);
437 DUMP_HLS(th->tile_qp, th->tile_qp[c]);
438 }
439 oapv_bsw_write(bs, th->reserved_zero_8bits, 8);
440 DUMP_HLS(th->reserved_zero_8bits, th->reserved_zero_8bits);
441
442 return OAPV_OK;
443 }
444
oapve_vlc_run_length_cc(oapve_ctx_t * ctx,oapve_core_t * core,oapv_bs_t * bs,s16 * coef,int log2_w,int log2_h,int num_sig,int ch_type)445 void oapve_vlc_run_length_cc(oapve_ctx_t *ctx, oapve_core_t *core, oapv_bs_t *bs, s16 *coef, int log2_w, int log2_h, int num_sig, int ch_type)
446 {
447 u32 num_coeff, scan_pos;
448 u32 sign, level, prev_level, run;
449 const u16 *scanp;
450 s16 coef_cur;
451
452 scanp = oapv_tbl_scan;
453 num_coeff = 1 << (log2_w + log2_h);
454 run = 0;
455 int first_ac = 1;
456 prev_level = core->prev_1st_ac_ctx[ch_type];
457
458 int prev_run = 0;
459
460 int rice_level = 0;
461 scan_pos = 0;
462
463 // for DC
464 {
465 coef_cur = coef[scanp[scan_pos]];
466 level = oapv_abs16(coef_cur);
467 sign = (coef_cur > 0) ? 0 : 1;
468
469 rice_level = oapv_clip3(OAPV_MIN_DC_LEVEL_CTX, OAPV_MAX_DC_LEVEL_CTX, core->prev_dc_ctx[ch_type] >> 1);
470
471 enc_vlc_write(bs, level, rice_level);
472
473 if(level)
474 oapv_bsw_write1(bs, sign);
475
476 core->prev_dc_ctx[ch_type] = level;
477 }
478
479 for(scan_pos = 1; scan_pos < num_coeff; scan_pos++) {
480 coef_cur = coef[scanp[scan_pos]];
481
482 if(coef_cur) {
483 level = oapv_abs16(coef_cur);
484 sign = (coef_cur > 0) ? 0 : 1;
485
486 /* Run coding */
487 int rice_run = 0;
488 rice_run = prev_run / 4;
489 if(rice_run > 2)
490 rice_run = 2;
491 enc_vlc_write(bs, run, rice_run);
492
493 /* Level coding */
494 rice_level = oapv_clip3(OAPV_MIN_AC_LEVEL_CTX, OAPV_MAX_AC_LEVEL_CTX, prev_level >> 2);
495 enc_vlc_write(bs, level - 1, rice_level);
496
497 /* Sign coding */
498 oapv_bsw_write1(bs, sign);
499
500 if(first_ac) {
501 first_ac = 0;
502 core->prev_1st_ac_ctx[ch_type] = level;
503 }
504
505 if(scan_pos == num_coeff - 1) {
506 break;
507 }
508 prev_run = run;
509 run = 0;
510
511 {
512 prev_level = level;
513 }
514
515 num_sig--;
516 }
517 else {
518 run++;
519 }
520 }
521
522 if(coef[scanp[num_coeff - 1]] == 0) {
523 int rice_run = 0;
524 rice_run = prev_run / 4;
525 if(rice_run > 2)
526 rice_run = 2;
527 enc_vlc_write(bs, run, rice_run);
528 }
529 }
530
oapve_vlc_au_info(oapv_bs_t * bs,oapve_ctx_t * ctx,oapv_frms_t * frms,oapv_bs_t ** bs_fi_pos)531 int oapve_vlc_au_info(oapv_bs_t *bs, oapve_ctx_t *ctx, oapv_frms_t *frms, oapv_bs_t **bs_fi_pos)
532 {
533 oapv_bsw_write(bs, frms->num_frms, 16);
534 DUMP_HLS(num_frames, frms->num_frms);
535 for(int fidx = 0; fidx < frms->num_frms; fidx++) {
536 oapv_bsw_write(bs, frms->frm[fidx].pbu_type, 8);
537 DUMP_HLS(pbu_type, frms->frm[fidx].pbu_type);
538 oapv_bsw_write(bs, frms->frm[fidx].group_id, 16);
539 DUMP_HLS(group_id, frms->frm[fidx].group_id);
540 oapv_bsw_write(bs, 0, 8);
541 DUMP_HLS(reserved_zero_8bits, 0);
542 memcpy(*(bs_fi_pos + sizeof(oapv_bs_t) * fidx), bs, sizeof(oapv_bs_t)); /* store fi pos in au to re-write */
543 oapve_vlc_frame_info(bs, &ctx->fh.fi);
544 }
545
546 oapv_bsw_write(bs, 0, 8);
547 DUMP_HLS(reserved_zero_8bits, 0);
548 while(!bsw_is_align8(bs)) {
549 oapv_bsw_write1(bs, 0);
550 }
551 return OAPV_OK;
552 }
553
oapve_vlc_pbu_size(oapv_bs_t * bs,int pbu_size)554 int oapve_vlc_pbu_size(oapv_bs_t *bs, int pbu_size)
555 {
556 oapv_assert_rv(bsw_is_align8(bs), OAPV_ERR_MALFORMED_BITSTREAM);
557 oapv_bsw_write(bs, pbu_size, 32);
558 DUMP_HLS(pbu_size, pbu_size);
559 return OAPV_OK;
560 }
561
oapve_vlc_pbu_header(oapv_bs_t * bs,int pbu_type,int group_id)562 int oapve_vlc_pbu_header(oapv_bs_t *bs, int pbu_type, int group_id)
563 {
564 oapv_bsw_write(bs, pbu_type, 8);
565 DUMP_HLS(pbu_type, pbu_type);
566 oapv_bsw_write(bs, group_id, 16);
567 DUMP_HLS(group_id, group_id);
568 oapv_bsw_write(bs, 0, 8); // reserved_zero_8bit
569 DUMP_HLS(reserved_zero, 0);
570
571 return OAPV_OK;
572 }
573
574 /****** ENABLE_DECODER ******/
oapve_vlc_metadata(oapv_md_t * md,oapv_bs_t * bs)575 int oapve_vlc_metadata(oapv_md_t *md, oapv_bs_t *bs)
576 {
577 oapv_bsw_write(bs, md->md_size, 32);
578 DUMP_HLS(metadata_size, md->md_size);
579 oapv_mdp_t *mdp = md->md_payload;
580
581 while(mdp != NULL) {
582 u32 mdp_pltype = mdp->pld_type;
583 while(mdp_pltype >= 255) {
584 oapv_bsw_write(bs, 0xFF, 8);
585 DUMP_HLS(payload_type, 0xFF);
586 mdp_pltype -= 255;
587 }
588 oapv_bsw_write(bs, mdp_pltype, 8);
589 DUMP_HLS(payload_type, mdp_pltype);
590
591 u32 mdp_size = mdp->pld_size;
592 while(mdp_size >= 255) {
593 oapv_bsw_write(bs, 0xFF, 8);
594 DUMP_HLS(payload_size, 0xFF);
595 mdp_size -= 255;
596 }
597 oapv_bsw_write(bs, mdp_size, 8);
598 DUMP_HLS(payload_size, mdp_size);
599
600 for(u32 i = 0; i < mdp->pld_size; i++) {
601 u8 *payload_data = (u8 *)mdp->pld_data;
602 oapv_bsw_write(bs, payload_data[i], 8);
603 DUMP_HLS(payload_data, payload_data[i]);
604 }
605
606 mdp = mdp->next;
607 }
608 return OAPV_OK;
609 }
610
611 ///////////////////////////////////////////////////////////////////////////////
612 // end of encoder code
613 #endif // ENABLE_ENCODER
614 ///////////////////////////////////////////////////////////////////////////////
615
616 ///////////////////////////////////////////////////////////////////////////////
617 // start of decoder code
618 #if ENABLE_DECODER
619 ///////////////////////////////////////////////////////////////////////////////
oapvd_vlc_au_size(oapv_bs_t * bs,u32 * au_size)620 int oapvd_vlc_au_size(oapv_bs_t *bs, u32 *au_size)
621 {
622 u32 size;
623 size = oapv_bsr_read(bs, 32);
624 oapv_assert_rv(size > 0 && size < 0xFFFFFFFF, OAPV_ERR_MALFORMED_BITSTREAM);
625 *au_size = size;
626 return OAPV_OK;
627 }
628
oapvd_vlc_pbu_size(oapv_bs_t * bs,u32 * pbu_size)629 int oapvd_vlc_pbu_size(oapv_bs_t *bs, u32 *pbu_size)
630 {
631 u32 size;
632 size = oapv_bsr_read(bs, 32);
633 DUMP_HLS(pbu_size, size);
634 oapv_assert_rv(size > 0 && size < 0xFFFFFFFF, OAPV_ERR_MALFORMED_BITSTREAM);
635 *pbu_size = size;
636 return OAPV_OK;
637 }
638
oapvd_vlc_pbu_header(oapv_bs_t * bs,oapv_pbuh_t * pbuh)639 int oapvd_vlc_pbu_header(oapv_bs_t *bs, oapv_pbuh_t *pbuh)
640 {
641 int reserved_zero;
642 pbuh->pbu_type = oapv_bsr_read(bs, 8);
643 DUMP_HLS(pbu_type, pbuh->pbu_type);
644 oapv_assert_rv(pbuh->pbu_type != 0, OAPV_ERR_MALFORMED_BITSTREAM);
645 oapv_assert_rv(!(pbuh->pbu_type >= 3 && pbuh->pbu_type <= 24), OAPV_ERR_MALFORMED_BITSTREAM);
646 oapv_assert_rv(!(pbuh->pbu_type >= 28 && pbuh->pbu_type <= 64), OAPV_ERR_MALFORMED_BITSTREAM);
647 oapv_assert_rv(!(pbuh->pbu_type >= 68), OAPV_ERR_MALFORMED_BITSTREAM);
648
649 pbuh->group_id = oapv_bsr_read(bs, 16);
650 DUMP_HLS(group_id, pbuh->group_id);
651 oapv_assert_rv(pbuh->group_id >= 0 && pbuh->group_id < 0xFFFF, OAPV_ERR_MALFORMED_BITSTREAM);
652
653 reserved_zero = oapv_bsr_read(bs, 8);
654 DUMP_HLS(reserved_zero, reserved_zero);
655 oapv_assert_rv(reserved_zero == 0, OAPV_ERR_MALFORMED_BITSTREAM);
656 return OAPV_OK;
657 }
658
oapvd_vlc_frame_info(oapv_bs_t * bs,oapv_fi_t * fi)659 int oapvd_vlc_frame_info(oapv_bs_t *bs, oapv_fi_t *fi)
660 {
661 int reserved_zero;
662
663 fi->profile_idc = oapv_bsr_read(bs, 8);
664 DUMP_HLS(fi->profile_idc, fi->profile_idc);
665
666 fi->level_idc = oapv_bsr_read(bs, 8);
667 DUMP_HLS(fi->level_idc, fi->level_idc);
668
669 fi->band_idc = oapv_bsr_read(bs, 3);
670 DUMP_HLS(fi->band_idc, fi->band_idc);
671
672 reserved_zero = oapv_bsr_read(bs, 5);
673 DUMP_HLS(reserved_zero, reserved_zero);
674 oapv_assert_rv(reserved_zero == 0, OAPV_ERR_MALFORMED_BITSTREAM);
675
676 fi->frame_width = oapv_bsr_read(bs, 32);
677 DUMP_HLS(fi->frame_width, fi->frame_width);
678 oapv_assert_rv(fi->frame_width > 0 && fi->frame_width < 0xFFFFFFFF, OAPV_ERR_MALFORMED_BITSTREAM);
679 fi->frame_width += 1;
680 oapv_assert_rv(fi->frame_width <= INT_MAX, OAPV_ERR_UNSUPPORTED); // frame width greater than 2^31 is unsupported in the current implementation
681
682 fi->frame_height = oapv_bsr_read(bs, 32);
683 DUMP_HLS(fi->frame_height, fi->frame_height);
684 oapv_assert_rv(fi->frame_height > 0 && fi->frame_height < 0xFFFFFFFF, OAPV_ERR_MALFORMED_BITSTREAM);
685 fi->frame_height += 1;
686 oapv_assert_rv(fi->frame_height <= INT_MAX, OAPV_ERR_UNSUPPORTED); // frame height greater than 2^31 is unsupported in the current implementation
687
688 fi->chroma_format_idc = oapv_bsr_read(bs, 4);
689 DUMP_HLS(fi->chroma_format_idc, fi->chroma_format_idc);
690 oapv_assert_rv(fi->chroma_format_idc >= 0 && fi->chroma_format_idc <= 4, OAPV_ERR_MALFORMED_BITSTREAM);
691 oapv_assert_rv(fi->chroma_format_idc != 1, OAPV_ERR_MALFORMED_BITSTREAM);
692
693 fi->bit_depth = oapv_bsr_read(bs, 4);
694 DUMP_HLS(fi->bit_depth, fi->bit_depth);
695 oapv_assert_rv(fi->bit_depth >= 2 && fi->bit_depth <= 8, OAPV_ERR_MALFORMED_BITSTREAM);
696 fi->bit_depth += 8;
697
698 fi->capture_time_distance = oapv_bsr_read(bs, 8);
699 DUMP_HLS(fi->capture_time_distance, fi->capture_time_distance);
700
701 reserved_zero = oapv_bsr_read(bs, 8);
702 DUMP_HLS(reserved_zero, reserved_zero);
703 oapv_assert_rv(reserved_zero == 0, OAPV_ERR_MALFORMED_BITSTREAM);
704
705 // check frame width in case of 422 format.
706 if(fi->chroma_format_idc == 2) {
707 // frame_width should be multiple of 2
708 oapv_assert_rv((fi->frame_width & 0x1) == 0, OAPV_ERR_MALFORMED_BITSTREAM);
709 }
710
711 return OAPV_OK;
712 }
713
oapvd_vlc_au_info(oapv_bs_t * bs,oapv_aui_t * aui)714 int oapvd_vlc_au_info(oapv_bs_t *bs, oapv_aui_t *aui)
715 {
716 int ret;
717 int reserved_zero_8bits;
718
719 aui->num_frames = oapv_bsr_read(bs, 16);
720 DUMP_HLS(num_frames, aui->num_frames);
721 oapv_assert_rv(aui->num_frames <= OAPV_MAX_NUM_FRAMES, OAPV_ERR_REACHED_MAX);
722 for(int fidx = 0; fidx < aui->num_frames; fidx++) {
723 aui->pbu_type[fidx] = oapv_bsr_read(bs, 8);
724 DUMP_HLS(pbu_type, aui->pbu_type[fidx]);
725 aui->group_id[fidx] = oapv_bsr_read(bs, 16);
726 DUMP_HLS(group_id, aui->group_id[fidx]);
727 reserved_zero_8bits = oapv_bsr_read(bs, 8);
728 DUMP_HLS(reserved_zero_8bits, reserved_zero_8bits);
729 oapv_assert_rv(reserved_zero_8bits == 0, OAPV_ERR_MALFORMED_BITSTREAM);
730 ret = oapvd_vlc_frame_info(bs, &aui->frame_info[fidx]);
731 oapv_assert_rv(OAPV_SUCCEEDED(ret), ret);
732 }
733 reserved_zero_8bits = oapv_bsr_read(bs, 8);
734 DUMP_HLS(reserved_zero_8bits, reserved_zero_8bits);
735 oapv_assert_rv(reserved_zero_8bits == 0, OAPV_ERR_MALFORMED_BITSTREAM);
736 /* byte align */
737 oapv_bsr_align8(bs);
738 return OAPV_OK;
739 }
740
dec_vlc_q_matrix(oapv_bs_t * bs,oapv_fh_t * fh)741 static int dec_vlc_q_matrix(oapv_bs_t *bs, oapv_fh_t *fh)
742 {
743 int num_comp = get_num_comp(fh->fi.chroma_format_idc);
744 for(int cidx = 0; cidx < num_comp; cidx++) {
745 for(int y = 0; y < OAPV_BLK_H; y++) {
746 for(int x = 0; x < OAPV_BLK_W; x++) {
747 fh->q_matrix[cidx][y][x] = oapv_bsr_read(bs, 8) + 1;
748 DUMP_HLS(fh->q_matrix, fh->q_matrix[cidx][y][x]);
749 }
750 }
751 }
752 return OAPV_OK;
753 }
754
dec_vlc_tile_info(oapv_bs_t * bs,oapv_fh_t * fh)755 static int dec_vlc_tile_info(oapv_bs_t *bs, oapv_fh_t *fh)
756 {
757 int pic_w, pic_h, tile_w, tile_h, tile_cols, tile_rows;
758
759 fh->tile_width_in_mbs = oapv_bsr_read(bs, 28) + 1;
760 DUMP_HLS(fh->tile_width_in_mbs, fh->tile_width_in_mbs);
761
762 fh->tile_height_in_mbs = oapv_bsr_read(bs, 28) + 1;
763 DUMP_HLS(fh->tile_height_in_mbs, fh->tile_height_in_mbs);
764
765 /* set various value */
766 pic_w = ((fh->fi.frame_width + (OAPV_MB_W - 1)) >> OAPV_LOG2_MB_W) << OAPV_LOG2_MB_W;
767 pic_h = ((fh->fi.frame_height + (OAPV_MB_H - 1)) >> OAPV_LOG2_MB_H) << OAPV_LOG2_MB_H;
768
769 tile_w = fh->tile_width_in_mbs * OAPV_MB_W;
770 tile_h = fh->tile_height_in_mbs * OAPV_MB_H;
771
772 tile_cols = (pic_w + (tile_w - 1)) / tile_w;
773 tile_rows = (pic_h + (tile_h - 1)) / tile_h;
774
775 oapv_assert_rv(tile_cols <= OAPV_MAX_TILE_COLS && tile_rows <= OAPV_MAX_TILE_ROWS, OAPV_ERR_MALFORMED_BITSTREAM)
776
777 fh->tile_size_present_in_fh_flag = oapv_bsr_read1(bs);
778 DUMP_HLS(fh->tile_size_present_in_fh_flag, fh->tile_size_present_in_fh_flag);
779
780 if(fh->tile_size_present_in_fh_flag) {
781 for(int i = 0; i < tile_cols * tile_rows; i++) {
782 fh->tile_size[i] = oapv_bsr_read(bs, 32);
783 DUMP_HLS(fh->tile_size, fh->tile_size[i]);
784 oapv_assert_rv(fh->tile_size[i] > 0 && fh->tile_size[i] < 0xFFFFFFFF, OAPV_ERR_MALFORMED_BITSTREAM);
785 fh->tile_size[i] += 1;
786 }
787 }
788 return OAPV_OK;
789 }
790
oapvd_vlc_frame_header(oapv_bs_t * bs,oapv_fh_t * fh)791 int oapvd_vlc_frame_header(oapv_bs_t *bs, oapv_fh_t *fh)
792 {
793 int ret, reserved_zero;
794 ret = oapvd_vlc_frame_info(bs, &fh->fi);
795 oapv_assert_rv(OAPV_SUCCEEDED(ret), ret);
796
797 reserved_zero = oapv_bsr_read(bs, 8);
798 DUMP_HLS(reserved_zero, reserved_zero);
799 oapv_assert_rv(reserved_zero == 0, OAPV_ERR_MALFORMED_BITSTREAM);
800
801 fh->color_description_present_flag = oapv_bsr_read(bs, 1);
802 DUMP_HLS(fh->color_description_present_flag, fh->color_description_present_flag);
803 if(fh->color_description_present_flag) {
804 fh->color_primaries = oapv_bsr_read(bs, 8);
805 DUMP_HLS(fh->color_primaries, fh->color_primaries);
806 fh->transfer_characteristics = oapv_bsr_read(bs, 8);
807 DUMP_HLS(fh->transfer_characteristics, fh->transfer_characteristics);
808 fh->matrix_coefficients = oapv_bsr_read(bs, 8);
809 DUMP_HLS(fh->matrix_coefficients, fh->matrix_coefficients);
810 }
811 else {
812 fh->color_primaries = 2;
813 fh->transfer_characteristics = 2;
814 fh->matrix_coefficients = 2;
815 }
816 fh->use_q_matrix = oapv_bsr_read(bs, 1);
817 DUMP_HLS(fh->use_q_matrix, fh->use_q_matrix);
818 if(fh->use_q_matrix) {
819 ret = dec_vlc_q_matrix(bs, fh);
820 oapv_assert_rv(OAPV_SUCCEEDED(ret), ret);
821 }
822
823 ret = dec_vlc_tile_info(bs, fh);
824 oapv_assert_rv(OAPV_SUCCEEDED(ret), ret);
825
826 reserved_zero = oapv_bsr_read(bs, 8);
827 DUMP_HLS(reserved_zero, reserved_zero);
828 oapv_assert_rv(reserved_zero == 0, OAPV_ERR_MALFORMED_BITSTREAM);
829
830 /* byte align */
831 oapv_bsr_align8(bs);
832
833 if(fh->use_q_matrix == 0) {
834 int num_comp = get_num_comp(fh->fi.chroma_format_idc);
835 for(int cidx = 0; cidx < num_comp; cidx++) {
836 for(int y = 0; y < OAPV_BLK_H; y++) {
837 for(int x = 0; x < OAPV_BLK_W; x++) {
838 fh->q_matrix[cidx][y][x] = 16;
839 }
840 }
841 }
842 }
843
844 return OAPV_OK;
845 }
846
oapvd_vlc_tile_size(oapv_bs_t * bs,u32 * tile_size)847 int oapvd_vlc_tile_size(oapv_bs_t *bs, u32 *tile_size)
848 {
849 u32 size = oapv_bsr_read(bs, 32);
850 DUMP_HLS(tile_size, size);
851 oapv_assert_rv(size > 0 && size < 0xFFFFFFFF, OAPV_ERR_MALFORMED_BITSTREAM);
852 *tile_size = size + 1;
853 return OAPV_OK;
854 }
855
oapvd_vlc_tile_header(oapv_bs_t * bs,oapvd_ctx_t * ctx,oapv_th_t * th)856 int oapvd_vlc_tile_header(oapv_bs_t *bs, oapvd_ctx_t *ctx, oapv_th_t *th)
857 {
858 th->tile_header_size = oapv_bsr_read(bs, 16);
859 DUMP_HLS(th->tile_header_size, th->tile_header_size);
860 th->tile_index = oapv_bsr_read(bs, 16);
861 DUMP_HLS(th->tile_index, th->tile_index);
862 for(int c = 0; c < ctx->num_comp; c++) {
863 th->tile_data_size[c] = oapv_bsr_read(bs, 32);
864 DUMP_HLS(th->tile_data_size, th->tile_data_size[c]);
865 oapv_assert_rv(th->tile_data_size[c] > 0 && th->tile_data_size[c] < 0xFFFFFFFF, OAPV_ERR_MALFORMED_BITSTREAM);
866 th->tile_data_size[c] += 1;
867 }
868 for(int c = 0; c < ctx->num_comp; c++) {
869 th->tile_qp[c] = oapv_bsr_read(bs, 8);
870 DUMP_HLS(th->tile_qp, th->tile_qp[c]);
871 }
872 th->reserved_zero_8bits = oapv_bsr_read(bs, 8);
873 DUMP_HLS(th->reserved_zero_8bits, th->reserved_zero_8bits);
874 /* byte align */
875 oapv_bsr_align8(bs);
876
877 oapv_assert_rv(th->reserved_zero_8bits == 0, OAPV_ERR_MALFORMED_BITSTREAM);
878 return OAPV_OK;
879 }
880
oapve_vlc_dc_coeff(oapve_ctx_t * ctx,oapve_core_t * core,oapv_bs_t * bs,int dc_diff,int c)881 int oapve_vlc_dc_coeff(oapve_ctx_t *ctx, oapve_core_t *core, oapv_bs_t *bs, int dc_diff, int c)
882 {
883 int rice_level = 0;
884 int abs_dc_diff = oapv_abs32(dc_diff);
885 int sign_dc_diff = (dc_diff > 0) ? 0 : 1;
886
887 rice_level = oapv_clip3(OAPV_MIN_DC_LEVEL_CTX, OAPV_MAX_DC_LEVEL_CTX, core->prev_dc_ctx[c] >> 1);
888 enc_vlc_write(bs, abs_dc_diff, rice_level);
889
890 if(abs_dc_diff)
891 oapv_bsw_write1(bs, sign_dc_diff);
892
893 core->prev_dc_ctx[c] = abs_dc_diff;
894 return OAPV_OK;
895 }
oapve_vlc_ac_coeff(oapve_ctx_t * ctx,oapve_core_t * core,oapv_bs_t * bs,s16 * coef,int num_sig,int ch_type)896 void oapve_vlc_ac_coeff(oapve_ctx_t *ctx, oapve_core_t *core, oapv_bs_t *bs, s16 *coef, int num_sig, int ch_type)
897 {
898 ALIGNED_16(s16 coef_temp[64]);
899 u32 num_coeff, scan_pos;
900 u32 sign, level, prev_level, run;
901 const u16 *scanp;
902 s16 coef_cur;
903
904 scanp = oapv_tbl_scan;
905 num_coeff = OAPV_BLK_D;
906 run = 0;
907 int first_ac = 1;
908 prev_level = core->prev_1st_ac_ctx[ch_type];
909 int prev_run = 0;
910 int rice_run = 0;
911 int rice_level = 0;
912 int lb = bs->leftbits;
913 u32 code = bs->code;
914 u8 *cur = bs->cur;
915
916 for(scan_pos = 1; scan_pos < num_coeff; scan_pos++) {
917 coef_temp[scan_pos] = coef[scanp[scan_pos]];
918 }
919
920 const s32 simple_vlc_table[3][2] = { {
921 1,
922 },
923 { 0, 0 },
924 { 0, 1 } };
925 for(scan_pos = 1; scan_pos < num_coeff - 1; scan_pos++) {
926 coef_cur = coef_temp[scan_pos];
927 if(coef_cur) {
928 level = oapv_abs16(coef_cur);
929 sign = (coef_cur > 0) ? 0 : 1;
930 rice_run = prev_run >> 2;
931 if(rice_run > 2)
932 rice_run = 2;
933 if(run == 0 && rice_run == 0) {
934 lb--; // bs->leftbits--;
935 code |= (1 << lb);
936 if(lb == 0) {
937 OAPV_FLUSH_SWAP(cur, code, lb);
938 }
939 }
940 else {
941 int leftbits;
942 leftbits = lb;
943 u32 code_from_lut = CODE_LUT_100[run][rice_run][0];
944 int len_from_lut = CODE_LUT_100[run][rice_run][1];
945 code |= (code_from_lut >> (32 - leftbits));
946 if(len_from_lut < leftbits) {
947 lb -= len_from_lut;
948 }
949 else {
950 lb = 0;
951 OAPV_FLUSH_SWAP(cur, code, lb);
952 code = (leftbits < 32 ? code_from_lut << leftbits : 0);
953 lb = 32 - (len_from_lut - leftbits);
954 }
955 }
956 rice_level = prev_level >> 2;
957 if(rice_level > 4)
958 rice_level = OAPV_MAX_AC_LEVEL_CTX;
959 if(level - 1 == 0 && rice_level == 0) {
960 lb--;
961 code |= (1 << lb);
962 if(lb == 0) {
963 OAPV_FLUSH_SWAP(cur, code, lb);
964 }
965 }
966 else {
967 if(level - 1 > 98) {
968 {
969 int k = rice_level;
970 u32 symbol = level - 1;
971 u32 simple_vlc_val = oapv_clip3(0, 2, symbol >> k);
972 int bit_cnt = 0;
973 if(symbol >= (u32)(1 << k)) {
974 symbol -= (1 << k);
975 int val = simple_vlc_table[simple_vlc_val][bit_cnt];
976 lb--;
977 code |= ((val & 0x1) << lb);
978 if(lb == 0) {
979 OAPV_FLUSH_SWAP(cur, code, lb);
980 }
981 bit_cnt++;
982 }
983 if(symbol >= (u32)(1 << k) && simple_vlc_val > 0) {
984 symbol -= (1 << k);
985 int val = simple_vlc_table[simple_vlc_val][bit_cnt];
986 lb--;
987 code |= ((val & 0x1) << lb);
988 if(lb == 0) {
989 OAPV_FLUSH_SWAP(cur, code, lb);
990 }
991 bit_cnt++;
992 }
993 while(symbol >= (u32)(1 << k)) {
994 symbol -= (1 << k);
995 lb--;
996 if(lb == 0) {
997 OAPV_FLUSH_SWAP(cur, code, lb);
998 }
999 if(bit_cnt >= 2) {
1000 k++;
1001 }
1002 bit_cnt++;
1003 }
1004 if(bit_cnt < 2) {
1005 int val = simple_vlc_table[simple_vlc_val][bit_cnt];
1006 lb--;
1007 code |= ((val & 0x1) << lb);
1008 if(lb == 0) {
1009 OAPV_FLUSH_SWAP(cur, code, lb);
1010 }
1011 }
1012 else {
1013 lb--;
1014 code |= ((1 & 0x1) << lb);
1015 if(lb == 0) {
1016 OAPV_FLUSH_SWAP(cur, code, lb);
1017 }
1018 }
1019 if(k > 0) {
1020 int leftbits;
1021 leftbits = lb;
1022 symbol <<= (32 - k);
1023 code |= (symbol >> (32 - leftbits));
1024 if(k < leftbits) {
1025 lb -= k;
1026 }
1027 else {
1028 lb = 0;
1029 OAPV_FLUSH_SWAP(cur, code, lb);
1030 code = (leftbits < 32 ? symbol << leftbits : 0);
1031 lb = 32 - (k - leftbits);
1032 }
1033 }
1034 }
1035 }
1036 else {
1037 int leftbits;
1038 leftbits = lb;
1039 u32 code_from_lut = CODE_LUT_100[level - 1][rice_level][0];
1040 int len_from_lut = CODE_LUT_100[level - 1][rice_level][1];
1041 code |= (code_from_lut >> (32 - leftbits));
1042 if(len_from_lut < leftbits) {
1043 lb -= len_from_lut;
1044 }
1045 else {
1046 lb = 0;
1047 OAPV_FLUSH_SWAP(cur, code, lb);
1048 code = (leftbits < 32 ? code_from_lut << leftbits : 0);
1049 lb = 32 - (len_from_lut - leftbits);
1050 }
1051 }
1052 }
1053 {
1054 lb--;
1055 code |= ((sign & 0x1) << lb);
1056 if(lb == 0) {
1057 OAPV_FLUSH_SWAP(cur, code, lb);
1058 }
1059 }
1060 if(first_ac) {
1061 first_ac = 0;
1062 core->prev_1st_ac_ctx[ch_type] = level;
1063 }
1064 prev_run = run;
1065 run = 0;
1066 prev_level = level;
1067 }
1068 else {
1069 run++;
1070 }
1071 }
1072 bs->cur = cur;
1073 bs->code = code;
1074 bs->leftbits = lb;
1075 coef_cur = coef_temp[scan_pos];
1076 if(coef_cur) {
1077 level = oapv_abs16(coef_cur);
1078 sign = (coef_cur > 0) ? 0 : 1;
1079 /* Run coding */
1080 rice_run = prev_run >> 2;
1081 if(rice_run > 2)
1082 rice_run = 2;
1083 if(run == 0 && rice_run == 0) {
1084 bs->leftbits--;
1085 bs->code |= (1 << bs->leftbits);
1086 if(bs->leftbits == 0) {
1087 OAPV_FLUSH(bs);
1088 }
1089 }
1090 else {
1091 int leftbits;
1092 leftbits = bs->leftbits;
1093 u32 code_from_lut = CODE_LUT_100[run][rice_run][0];
1094 int len_from_lut = CODE_LUT_100[run][rice_run][1];
1095 bs->code |= (code_from_lut >> (32 - leftbits));
1096 if(len_from_lut < leftbits) {
1097 bs->leftbits -= len_from_lut;
1098 }
1099 else {
1100 bs->leftbits = 0;
1101 OAPV_FLUSH(bs);
1102 bs->code = (leftbits < 32 ? code_from_lut << leftbits : 0);
1103 bs->leftbits = 32 - (len_from_lut - leftbits);
1104 }
1105 }
1106 /* Level coding */
1107 rice_level = prev_level >> 2;
1108 if(rice_level > 4)
1109 rice_level = OAPV_MAX_AC_LEVEL_CTX;
1110 if(level - 1 == 0 && rice_level == 0) {
1111 bs->leftbits--;
1112 bs->code |= (1 << bs->leftbits);
1113 if(bs->leftbits == 0) {
1114 OAPV_FLUSH(bs);
1115 }
1116 }
1117 else {
1118 if(level - 1 > 98) {
1119 enc_vlc_write(bs, level - 1, rice_level);
1120 }
1121 else {
1122 int leftbits;
1123 leftbits = bs->leftbits;
1124 u32 code_from_lut = CODE_LUT_100[level - 1][rice_level][0];
1125 int len_from_lut = CODE_LUT_100[level - 1][rice_level][1];
1126 bs->code |= (code_from_lut >> (32 - leftbits));
1127 if(len_from_lut < leftbits) {
1128 bs->leftbits -= len_from_lut;
1129 }
1130 else {
1131 bs->leftbits = 0;
1132 OAPV_FLUSH(bs);
1133 bs->code = (leftbits < 32 ? code_from_lut << leftbits : 0);
1134 bs->leftbits = 32 - (len_from_lut - leftbits);
1135 }
1136 }
1137 }
1138 /* Sign coding */
1139 {
1140 bs->leftbits--;
1141 bs->code |= ((sign & 0x1) << bs->leftbits);
1142 if(bs->leftbits == 0) {
1143 OAPV_FLUSH(bs);
1144 }
1145 }
1146 if(first_ac) {
1147 first_ac = 0;
1148 core->prev_1st_ac_ctx[ch_type] = level;
1149 }
1150 }
1151 else {
1152 run++;
1153 }
1154 if(coef_temp[num_coeff - 1] == 0) {
1155 int rice_run = 0;
1156 rice_run = prev_run >> 2;
1157 if(rice_run > 2)
1158 rice_run = 2;
1159
1160 if(run == 0 && rice_run == 0) {
1161 bs->leftbits--;
1162 bs->code |= (1 << bs->leftbits);
1163 if(bs->leftbits == 0) {
1164 OAPV_FLUSH(bs);
1165 }
1166 }
1167 else {
1168 int leftbits;
1169 leftbits = bs->leftbits;
1170 u32 code_from_lut = CODE_LUT_100[run][rice_run][0];
1171 int len_from_lut = CODE_LUT_100[run][rice_run][1];
1172 bs->code |= (code_from_lut >> (32 - leftbits));
1173 if(len_from_lut < leftbits) {
1174 bs->leftbits -= len_from_lut;
1175 }
1176 else {
1177 bs->leftbits = 0;
1178 OAPV_FLUSH(bs);
1179 bs->code = (leftbits < 32 ? code_from_lut << leftbits : 0);
1180 bs->leftbits = 32 - (len_from_lut - leftbits);
1181 }
1182 }
1183 }
1184 }
1185
oapvd_vlc_dc_coeff(oapvd_ctx_t * ctx,oapvd_core_t * core,oapv_bs_t * bs,s16 * dc_diff,int c)1186 int oapvd_vlc_dc_coeff(oapvd_ctx_t *ctx, oapvd_core_t *core, oapv_bs_t *bs, s16 *dc_diff, int c)
1187 {
1188 int rice_level = 0;
1189 int abs_dc_diff;
1190 int sign_dc_diff = 0;
1191
1192 rice_level = oapv_clip3(OAPV_MIN_DC_LEVEL_CTX, OAPV_MAX_DC_LEVEL_CTX, core->prev_dc_ctx[c] >> 1);
1193 abs_dc_diff = dec_vlc_read(bs, rice_level);
1194 if(abs_dc_diff)
1195 sign_dc_diff = oapv_bsr_read1(bs);
1196
1197 *dc_diff = sign_dc_diff ? -abs_dc_diff : abs_dc_diff;
1198 core->prev_dc_ctx[c] = abs_dc_diff;
1199
1200 return OAPV_OK;
1201 }
1202
oapvd_vlc_ac_coeff(oapvd_ctx_t * ctx,oapvd_core_t * core,oapv_bs_t * bs,s16 * coef,int c)1203 int oapvd_vlc_ac_coeff(oapvd_ctx_t *ctx, oapvd_core_t *core, oapv_bs_t *bs, s16 *coef, int c)
1204 {
1205 int sign, level, prev_level, run;
1206 int scan_pos_offset, num_coeff, i, coef_cnt = 0;
1207 const u16 *scanp;
1208
1209 scanp = oapv_tbl_scan;
1210 num_coeff = OAPV_BLK_D;
1211 scan_pos_offset = 1;
1212 run = 0;
1213
1214 int first_ac = 1;
1215 prev_level = core->prev_1st_ac_ctx[c];
1216 int prev_run = 0;
1217
1218 do {
1219 int rice_run = 0;
1220 rice_run = prev_run / 4;
1221 if(rice_run > 2)
1222 rice_run = 2;
1223 if(rice_run == 0) {
1224 if(bs->leftbits == 0) {
1225 OAPV_READ_FLUSH(bs, 4);
1226 }
1227 u32 t0 = (u32)(bs->code >> 31);
1228 bs->code <<= 1;
1229 bs->leftbits -= 1;
1230 if(t0)
1231 run = 0;
1232 else
1233 run = dec_vlc_read_1bit_read(bs, rice_run);
1234 }
1235 else {
1236 run = dec_vlc_read(bs, rice_run);
1237 }
1238
1239 oapv_assert_rv((scan_pos_offset + run) <= 64, OAPV_ERR_MALFORMED_BITSTREAM);
1240 for (i = scan_pos_offset; i < scan_pos_offset + run; i++){
1241 coef[scanp[i]] = 0;
1242 }
1243
1244 if(scan_pos_offset + run == num_coeff) {
1245 break;
1246 }
1247
1248 scan_pos_offset += run;
1249
1250 /* Level parsing */
1251 int rice_level = 0;
1252 if(scan_pos_offset == 0) {
1253 rice_level = oapv_clip3(OAPV_MIN_DC_LEVEL_CTX, OAPV_MAX_DC_LEVEL_CTX, core->prev_dc_ctx[c] >> 1);
1254 }
1255 else {
1256 rice_level = oapv_clip3(OAPV_MIN_AC_LEVEL_CTX, OAPV_MAX_AC_LEVEL_CTX, prev_level >> 2);
1257 }
1258 if(rice_level == 0) {
1259 if(bs->leftbits == 0) {
1260 OAPV_READ_FLUSH(bs, 4);
1261 }
1262 u32 t0 = (u32)(bs->code >> 31);
1263 bs->code <<= 1;
1264 bs->leftbits -= 1;
1265 if(t0)
1266 level = 0;
1267 else
1268 level = dec_vlc_read_1bit_read(bs, rice_level);
1269 }
1270 else {
1271 level = dec_vlc_read(bs, rice_level);
1272 }
1273 level++;
1274
1275 if(scan_pos_offset != 0) {
1276 prev_level = level;
1277 }
1278 prev_run = run;
1279
1280 if(scan_pos_offset == 0) {
1281 core->prev_dc_ctx[c] = level;
1282 }
1283 else if(first_ac) {
1284 first_ac = 0;
1285 core->prev_1st_ac_ctx[c] = level;
1286 }
1287
1288 /* Sign parsing */
1289 if(bs->leftbits == 0) {
1290 OAPV_READ_FLUSH(bs, 4);
1291 }
1292 sign = (u32)(bs->code >> 31);
1293 bs->code <<= 1;
1294 bs->leftbits -= 1;
1295 coef[scanp[scan_pos_offset]] = sign ? -(s16)level : (s16)level;
1296
1297 coef_cnt++;
1298
1299 if(scan_pos_offset >= num_coeff - 1) {
1300 break;
1301 }
1302 scan_pos_offset++;
1303 } while(1);
1304
1305 return OAPV_OK;
1306 }
1307
oapvd_vlc_tile_dummy_data(oapv_bs_t * bs)1308 int oapvd_vlc_tile_dummy_data(oapv_bs_t *bs)
1309 {
1310 while(bs->cur <= bs->end) {
1311 oapv_bsr_read(bs, 8);
1312 }
1313 return OAPV_OK;
1314 }
1315
oapvd_vlc_metadata(oapv_bs_t * bs,u32 pbu_size,oapvm_t mid,int group_id)1316 int oapvd_vlc_metadata(oapv_bs_t *bs, u32 pbu_size, oapvm_t mid, int group_id)
1317 {
1318 int ret;
1319 u32 t0;
1320 u32 metadata_size;
1321 metadata_size = oapv_bsr_read(bs, 32);
1322 DUMP_HLS(metadata_size, metadata_size);
1323 oapv_assert_gv(metadata_size <= (pbu_size - 8), ret, OAPV_ERR_MALFORMED_BITSTREAM, ERR);
1324 u8 *bs_start_pos = bs->cur;
1325 u8 *payload_data = NULL;
1326
1327 while(metadata_size > 0) {
1328 u32 payload_type = 0, payload_size = 0;
1329 t0 = 0;
1330 do {
1331 t0 = oapv_bsr_read(bs, 8);
1332 DUMP_HLS(payload_type, t0);
1333 metadata_size -= 1;
1334 if(t0 == 0xFF) {
1335 payload_type += 255;
1336 }
1337 } while(t0 == 0xFF);
1338 payload_type += t0;
1339
1340 t0 = 0;
1341 do {
1342 t0 = oapv_bsr_read(bs, 8);
1343 DUMP_HLS(payload_size, t0);
1344 metadata_size -= 1;
1345 if(t0 == 0xFF) {
1346 payload_size += 255;
1347 }
1348 } while(t0 == 0xFF);
1349 payload_size += t0;
1350 oapv_assert_gv(payload_size <= metadata_size, ret, OAPV_ERR_MALFORMED_BITSTREAM, ERR);
1351
1352 if(payload_size > 0) {
1353
1354 payload_data = oapv_malloc(payload_size);
1355 oapv_assert_gv(payload_data != NULL, ret, OAPV_ERR_OUT_OF_MEMORY, ERR);
1356 if(payload_type == OAPV_METADATA_FILLER) {
1357 for(u32 i = 0; i < payload_size; i++) {
1358 t0 = oapv_bsr_read(bs, 8);
1359 DUMP_HLS(payload_data, t0);
1360 oapv_assert_gv(t0 == 0xFF, ret, OAPV_ERR_MALFORMED_BITSTREAM, ERR);
1361 payload_data[i] = 0xFF;
1362 }
1363 }
1364 else {
1365 for(u32 i = 0; i < payload_size; i++) {
1366 t0 = oapv_bsr_read(bs, 8);
1367 DUMP_HLS(payload_data, t0);
1368 payload_data[i] = t0;
1369 }
1370 }
1371 }
1372 ret = oapvm_set(mid, group_id, payload_type, payload_data, payload_size,
1373 payload_type == OAPV_METADATA_USER_DEFINED ? payload_data : NULL);
1374 oapv_assert_g(OAPV_SUCCEEDED(ret), ERR);
1375 metadata_size -= payload_size;
1376 }
1377 const u32 target_read_size = (pbu_size - 8);
1378 ret = oapvd_vlc_filler(bs, target_read_size - (bs->cur - bs_start_pos));
1379 oapv_assert_g(OAPV_SUCCEEDED(ret), ERR);
1380 return OAPV_OK;
1381
1382 ERR:
1383 // TO-DO: free memory
1384 return ret;
1385 }
1386
oapvd_vlc_filler(oapv_bs_t * bs,u32 filler_size)1387 int oapvd_vlc_filler(oapv_bs_t *bs, u32 filler_size)
1388 {
1389 int val;
1390 while(filler_size > 0) {
1391 val = oapv_bsr_read(bs, 8);
1392 if(val != 0xFF) {
1393 return OAPV_ERR_MALFORMED_BITSTREAM;
1394 }
1395 filler_size--;
1396 }
1397 return OAPV_OK;
1398 }
1399
1400 ///////////////////////////////////////////////////////////////////////////////
1401 // end of decoder code
1402 #endif // ENABLE_DECODER
1403 ///////////////////////////////////////////////////////////////////////////////
1404