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 }
208
dec_vlc_read(oapv_bs_t * bs,int k)209 static int dec_vlc_read(oapv_bs_t *bs, int k)
210 {
211 u32 symbol = 0;
212 int t0 = -1;
213 int parse_exp_golomb = 1;
214 if(bs->leftbits == 0) {
215 OAPV_READ_FLUSH(bs, 4);
216 }
217 t0 = (u32)(bs->code >> 31);
218 bs->code <<= 1;
219 bs->leftbits -= 1;
220 if(t0 == 1) {
221 parse_exp_golomb = 0;
222 }
223 else {
224 if(bs->leftbits == 0) {
225 OAPV_READ_FLUSH(bs, 4);
226 }
227 t0 = (u32)(bs->code >> 31);
228 bs->code <<= 1;
229 bs->leftbits -= 1;
230 if(t0 == 0) {
231 symbol += (1 << k);
232 parse_exp_golomb = 0;
233 }
234 else {
235 symbol += (2 << k);
236 parse_exp_golomb = 1;
237 }
238 }
239 if(parse_exp_golomb) {
240 while(1) {
241 if(bs->leftbits == 0) {
242 OAPV_READ_FLUSH(bs, 4);
243 }
244 t0 = (u32)(bs->code >> 31);
245 bs->code <<= 1;
246 bs->leftbits -= 1;
247 if(t0 == 1) {
248 break;
249 }
250 else {
251 symbol += (1 << k);
252 k++;
253 }
254 }
255 }
256 if(k > 0) {
257 u32 code = 0;
258 if(bs->leftbits < k) {
259 code = bs->code >> (32 - k);
260 k -= bs->leftbits;
261 OAPV_READ_FLUSH(bs, 4);
262 }
263 code |= bs->code >> (32 - k);
264 bsr_skip_code_opt(bs, k);
265 symbol += code;
266 }
267 return symbol;
268 }
269
oapve_set_frame_header(oapve_ctx_t * ctx,oapv_fh_t * fh)270 void oapve_set_frame_header(oapve_ctx_t *ctx, oapv_fh_t *fh)
271 {
272 oapve_param_t * param = ctx->param;
273
274 oapv_mset(fh, 0, sizeof(oapv_fh_t));
275 fh->fi.profile_idc = param->profile_idc;
276 fh->fi.level_idc = param->level_idc;
277 fh->fi.band_idc = param->band_idc;
278 fh->fi.frame_width = param->w;
279 fh->fi.frame_height = param->h;
280 fh->fi.chroma_format_idc = ctx->cfi;
281 fh->fi.bit_depth = ctx->bit_depth;
282 fh->tile_width_in_mbs = param->tile_w_mb;
283 fh->tile_height_in_mbs = param->tile_h_mb;
284
285 fh->color_description_present_flag = param->color_description_present_flag;
286 fh->color_primaries = param->color_primaries;
287 fh->transfer_characteristics = param->transfer_characteristics;
288 fh->matrix_coefficients = param->matrix_coefficients;
289 fh->full_range_flag = param->full_range_flag;
290
291 fh->use_q_matrix = param->use_q_matrix;
292 if(fh->use_q_matrix == 0) {
293 for(int cidx = 0; cidx < ctx->num_comp; cidx++) {
294 for(int y = 0; y < OAPV_BLK_H; y++) {
295 for(int x = 0; x < OAPV_BLK_W; x++) {
296 fh->q_matrix[cidx][y][x] = 16;
297 }
298 }
299 }
300 }
301 else {
302 int mod = (1 << OAPV_LOG2_BLK) - 1;
303 for(int c= 0; c <OAPV_MAX_CC; c++) {
304 for(int i = 0; i < OAPV_BLK_D; i++) {
305 fh->q_matrix[c][i >> OAPV_LOG2_BLK][i & mod] = param->q_matrix[c][i];
306 }
307 }
308 }
309 fh->tile_size_present_in_fh_flag = 0;
310 }
311
enc_vlc_quantization_matrix(oapv_bs_t * bs,oapve_ctx_t * ctx,oapv_fh_t * fh)312 static int enc_vlc_quantization_matrix(oapv_bs_t *bs, oapve_ctx_t *ctx, oapv_fh_t *fh)
313 {
314 for(int cidx = 0; cidx < ctx->num_comp; cidx++) {
315 for(int y = 0; y < 8; y++) {
316 for(int x = 0; x < 8; x++) {
317 oapv_bsw_write(bs, fh->q_matrix[cidx][y][x], 8);
318 DUMP_HLS(fh->q_matrix, fh->q_matrix[cidx][y][x]);
319 }
320 }
321 }
322 return 0;
323 }
324
enc_vlc_tile_info(oapv_bs_t * bs,oapve_ctx_t * ctx,oapv_fh_t * fh)325 static int enc_vlc_tile_info(oapv_bs_t *bs, oapve_ctx_t *ctx, oapv_fh_t *fh)
326 {
327 oapv_bsw_write(bs, fh->tile_width_in_mbs, 20);
328 DUMP_HLS(fh->tile_width_in_mbs, fh->tile_width_in_mbs);
329 oapv_bsw_write(bs, fh->tile_height_in_mbs, 20);
330 DUMP_HLS(fh->tile_height_in_mbs, fh->tile_height_in_mbs);
331 oapv_bsw_write(bs, fh->tile_size_present_in_fh_flag, 1);
332 DUMP_HLS(fh->tile_size_present_in_fh_flag, fh->tile_size_present_in_fh_flag);
333 if(fh->tile_size_present_in_fh_flag) {
334 for(int i = 0; i < ctx->num_tiles; i++) {
335 oapv_bsw_write(bs, fh->tile_size[i], 32);
336 DUMP_HLS(fh->tile_size, fh->tile_size[i]);
337 }
338 }
339
340 return 0;
341 }
342
oapve_vlc_frame_info(oapv_bs_t * bs,oapv_fi_t * fi)343 int oapve_vlc_frame_info(oapv_bs_t *bs, oapv_fi_t *fi)
344 {
345 oapv_bsw_write(bs, fi->profile_idc, 8);
346 DUMP_HLS(fi->profile_idc, fi->profile_idc);
347 oapv_bsw_write(bs, fi->level_idc, 8);
348 DUMP_HLS(fi->level_idc, fi->level_idc);
349 oapv_bsw_write(bs, fi->band_idc, 3);
350 DUMP_HLS(fi->band_idc, fi->band_idc);
351 oapv_bsw_write(bs, 0, 5); // reserved_zero_5bits
352 DUMP_HLS(reserved_zero, 0);
353 oapv_bsw_write(bs, fi->frame_width, 24);
354 DUMP_HLS(fi->frame_width, fi->frame_width);
355 oapv_bsw_write(bs, fi->frame_height, 24);
356 DUMP_HLS(fi->frame_height, fi->frame_height);
357 oapv_bsw_write(bs, fi->chroma_format_idc, 4);
358 DUMP_HLS(fi->chroma_format_idc, fi->chroma_format_idc);
359 oapv_bsw_write(bs, fi->bit_depth - 8, 4);
360 DUMP_HLS(fi->bit_depth, fi->bit_depth - 8);
361 oapv_bsw_write(bs, fi->capture_time_distance, 8);
362 DUMP_HLS(fi->capture_time_distance, fi->capture_time_distance);
363 oapv_bsw_write(bs, 0, 8); // reserved_zero_8bits
364 DUMP_HLS(reserved_zero, 0);
365 return OAPV_OK;
366 }
367
oapve_vlc_frame_header(oapv_bs_t * bs,oapve_ctx_t * ctx,oapv_fh_t * fh)368 int oapve_vlc_frame_header(oapv_bs_t *bs, oapve_ctx_t *ctx, oapv_fh_t *fh)
369 {
370 oapv_assert_rv(bsw_is_align8(bs), OAPV_ERR_MALFORMED_BITSTREAM);
371
372 oapve_vlc_frame_info(bs, &fh->fi);
373 oapv_bsw_write(bs, 0, 8); // reserved_zero_8bits
374 DUMP_HLS(reserved_zero, 0);
375 oapv_bsw_write1(bs, fh->color_description_present_flag);
376 DUMP_HLS(fh->color_description_present_flag, fh->color_description_present_flag);
377 if(fh->color_description_present_flag) {
378 oapv_bsw_write(bs, fh->color_primaries, 8);
379 DUMP_HLS(fh->color_primaries, fh->color_primaries);
380 oapv_bsw_write(bs, fh->transfer_characteristics, 8);
381 DUMP_HLS(fh->transfer_characteristics, fh->transfer_characteristics);
382 oapv_bsw_write(bs, fh->matrix_coefficients, 8);
383 DUMP_HLS(fh->matrix_coefficients, fh->matrix_coefficients);
384 oapv_bsw_write1(bs, fh->full_range_flag);
385 DUMP_HLS(fh->full_range_flag, fh->full_range_flag);
386 }
387 oapv_bsw_write1(bs, fh->use_q_matrix);
388 DUMP_HLS(fh->use_q_matrix, fh->use_q_matrix);
389 if(fh->use_q_matrix) {
390 enc_vlc_quantization_matrix(bs, ctx, fh);
391 }
392 enc_vlc_tile_info(bs, ctx, fh);
393
394 oapv_bsw_write(bs, 0, 8); // reserved_zero_8bits
395 DUMP_HLS(reserved_zero, 0);
396 return OAPV_OK;
397 }
398
oapve_vlc_tile_size(oapv_bs_t * bs,int tile_size)399 int oapve_vlc_tile_size(oapv_bs_t *bs, int tile_size)
400 {
401 oapv_assert_rv(bsw_is_align8(bs), OAPV_ERR_MALFORMED_BITSTREAM);
402 oapv_bsw_write(bs, tile_size, 32);
403 DUMP_HLS(tile_size, tile_size);
404 return OAPV_OK;
405 }
406
oapve_set_tile_header(oapve_ctx_t * ctx,oapv_th_t * th,int tile_idx,int qp)407 void oapve_set_tile_header(oapve_ctx_t *ctx, oapv_th_t *th, int tile_idx, int qp)
408 {
409 oapv_mset(th, 0, sizeof(oapv_th_t));
410
411 for(int c = 0; c < ctx->num_comp; c++) {
412 th->tile_qp[c] = oapv_clip3(MIN_QUANT, MAX_QUANT(10), qp + ctx->qp_offset[c]);
413 }
414 th->tile_index = tile_idx;
415
416 for(int i = 0; i < N_C; i++) {
417 // this setting is required to prevent underflow at dummy writing tile header due to '-1'.
418 th->tile_data_size[i] = 1;
419 }
420 }
421
oapve_vlc_tile_header(oapve_ctx_t * ctx,oapv_bs_t * bs,oapv_th_t * th)422 int oapve_vlc_tile_header(oapve_ctx_t *ctx, oapv_bs_t *bs, oapv_th_t *th)
423 {
424 oapv_assert_rv(bsw_is_align8(bs), OAPV_ERR_MALFORMED_BITSTREAM);
425 th->tile_header_size = 5; // tile_header_size + tile_index + reserved_zero_8bits
426 th->tile_header_size += (ctx->num_comp * 5); // tile_data_size + tile_qp
427
428 oapv_bsw_write(bs, th->tile_header_size, 16);
429 DUMP_HLS(th->tile_header_size, th->tile_header_size);
430 oapv_bsw_write(bs, th->tile_index, 16);
431 DUMP_HLS(th->tile_index, th->tile_index);
432 for(int c = 0; c < ctx->num_comp; c++) {
433 oapv_bsw_write(bs, th->tile_data_size[c], 32);
434 DUMP_HLS(th->tile_data_size, th->tile_data_size[c]);
435 }
436 for(int c = 0; c < ctx->num_comp; c++) {
437 oapv_bsw_write(bs, th->tile_qp[c], 8);
438 DUMP_HLS(th->tile_qp, th->tile_qp[c]);
439 }
440 oapv_bsw_write(bs, th->reserved_zero_8bits, 8);
441 DUMP_HLS(th->reserved_zero_8bits, th->reserved_zero_8bits);
442
443 return OAPV_OK;
444 }
445
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 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)
447 {
448 u32 num_coeff, scan_pos;
449 u32 sign, level, prev_level, run;
450 const u16 *scanp;
451 s16 coef_cur;
452
453 scanp = oapv_tbl_scan;
454 num_coeff = 1 << (log2_w + log2_h);
455 run = 0;
456 int first_ac = 1;
457 prev_level = core->prev_1st_ac_ctx[ch_type];
458
459 int prev_run = 0;
460
461 int rice_level = 0;
462 scan_pos = 0;
463
464 // for DC
465 {
466 coef_cur = coef[scanp[scan_pos]];
467 level = oapv_abs16(coef_cur);
468 sign = (coef_cur > 0) ? 0 : 1;
469
470 rice_level = oapv_clip3(OAPV_MIN_DC_LEVEL_CTX, OAPV_MAX_DC_LEVEL_CTX, core->prev_dc_ctx[ch_type] >> 1);
471
472 enc_vlc_write(bs, level, rice_level);
473
474 if(level)
475 oapv_bsw_write1(bs, sign);
476
477 core->prev_dc_ctx[ch_type] = level;
478 }
479
480 for(scan_pos = 1; scan_pos < num_coeff; scan_pos++) {
481 coef_cur = coef[scanp[scan_pos]];
482
483 if(coef_cur) {
484 level = oapv_abs16(coef_cur);
485 sign = (coef_cur > 0) ? 0 : 1;
486
487 /* Run coding */
488 int rice_run = 0;
489 rice_run = prev_run / 4;
490 if(rice_run > 2)
491 rice_run = 2;
492 enc_vlc_write(bs, run, rice_run);
493
494 /* Level coding */
495 rice_level = oapv_clip3(OAPV_MIN_AC_LEVEL_CTX, OAPV_MAX_AC_LEVEL_CTX, prev_level >> 2);
496 enc_vlc_write(bs, level - 1, rice_level);
497
498 /* Sign coding */
499 oapv_bsw_write1(bs, sign);
500
501 if(first_ac) {
502 first_ac = 0;
503 core->prev_1st_ac_ctx[ch_type] = level;
504 }
505
506 if(scan_pos == num_coeff - 1) {
507 break;
508 }
509 prev_run = run;
510 run = 0;
511
512 {
513 prev_level = level;
514 }
515
516 num_sig--;
517 }
518 else {
519 run++;
520 }
521 }
522
523 if(coef[scanp[num_coeff - 1]] == 0) {
524 int rice_run = 0;
525 rice_run = prev_run / 4;
526 if(rice_run > 2)
527 rice_run = 2;
528 enc_vlc_write(bs, run, rice_run);
529 }
530 }
531
oapve_vlc_au_info(oapv_bs_t * bs,oapve_ctx_t * ctx,oapv_frms_t * frms,oapv_bs_t ** bs_fi_pos)532 int oapve_vlc_au_info(oapv_bs_t *bs, oapve_ctx_t *ctx, oapv_frms_t *frms, oapv_bs_t **bs_fi_pos)
533 {
534 oapv_bsw_write(bs, frms->num_frms, 16);
535 DUMP_HLS(num_frames, frms->num_frms);
536 for(int fidx = 0; fidx < frms->num_frms; fidx++) {
537 oapv_bsw_write(bs, frms->frm[fidx].pbu_type, 8);
538 DUMP_HLS(pbu_type, frms->frm[fidx].pbu_type);
539 oapv_bsw_write(bs, frms->frm[fidx].group_id, 16);
540 DUMP_HLS(group_id, frms->frm[fidx].group_id);
541 oapv_bsw_write(bs, 0, 8);
542 DUMP_HLS(reserved_zero_8bits, 0);
543 memcpy(*(bs_fi_pos + sizeof(oapv_bs_t) * fidx), bs, sizeof(oapv_bs_t)); /* store fi pos in au to re-write */
544 oapve_vlc_frame_info(bs, &ctx->fh.fi);
545 }
546
547 oapv_bsw_write(bs, 0, 8);
548 DUMP_HLS(reserved_zero_8bits, 0);
549 while(!bsw_is_align8(bs)) {
550 oapv_bsw_write1(bs, 0);
551 }
552 return OAPV_OK;
553 }
554
oapve_vlc_pbu_size(oapv_bs_t * bs,int pbu_size)555 int oapve_vlc_pbu_size(oapv_bs_t *bs, int pbu_size)
556 {
557 oapv_assert_rv(bsw_is_align8(bs), OAPV_ERR_MALFORMED_BITSTREAM);
558 oapv_bsw_write(bs, pbu_size, 32);
559 DUMP_HLS(pbu_size, pbu_size);
560 return OAPV_OK;
561 }
562
oapve_vlc_pbu_header(oapv_bs_t * bs,int pbu_type,int group_id)563 int oapve_vlc_pbu_header(oapv_bs_t *bs, int pbu_type, int group_id)
564 {
565 oapv_bsw_write(bs, pbu_type, 8);
566 DUMP_HLS(pbu_type, pbu_type);
567 oapv_bsw_write(bs, group_id, 16);
568 DUMP_HLS(group_id, group_id);
569 oapv_bsw_write(bs, 0, 8); // reserved_zero_8bit
570 DUMP_HLS(reserved_zero, 0);
571
572 return OAPV_OK;
573 }
574
575 /****** ENABLE_DECODER ******/
oapve_vlc_metadata(oapv_md_t * md,oapv_bs_t * bs)576 int oapve_vlc_metadata(oapv_md_t *md, oapv_bs_t *bs)
577 {
578 oapv_bsw_write(bs, md->md_size, 32);
579 DUMP_HLS(metadata_size, md->md_size);
580 oapv_mdp_t *mdp = md->md_payload;
581
582 while(mdp != NULL) {
583 u32 mdp_pltype = mdp->pld_type;
584 while(mdp_pltype >= 255) {
585 oapv_bsw_write(bs, 0xFF, 8);
586 DUMP_HLS(payload_type, 0xFF);
587 mdp_pltype -= 255;
588 }
589 oapv_bsw_write(bs, mdp_pltype, 8);
590 DUMP_HLS(payload_type, mdp_pltype);
591
592 u32 mdp_size = mdp->pld_size;
593 while(mdp_size >= 255) {
594 oapv_bsw_write(bs, 0xFF, 8);
595 DUMP_HLS(payload_size, 0xFF);
596 mdp_size -= 255;
597 }
598 oapv_bsw_write(bs, mdp_size, 8);
599 DUMP_HLS(payload_size, mdp_size);
600
601 for(u32 i = 0; i < mdp->pld_size; i++) {
602 u8 *payload_data = (u8 *)mdp->pld_data;
603 oapv_bsw_write(bs, payload_data[i], 8);
604 DUMP_HLS(payload_data, payload_data[i]);
605 }
606
607 mdp = mdp->next;
608 }
609 return OAPV_OK;
610 }
611
612 ///////////////////////////////////////////////////////////////////////////////
613 // end of encoder code
614 #endif // ENABLE_ENCODER
615 ///////////////////////////////////////////////////////////////////////////////
616
617 ///////////////////////////////////////////////////////////////////////////////
618 // start of decoder code
619 #if ENABLE_DECODER
620 ///////////////////////////////////////////////////////////////////////////////
oapvd_vlc_au_size(oapv_bs_t * bs,u32 * au_size)621 int oapvd_vlc_au_size(oapv_bs_t *bs, u32 *au_size)
622 {
623 u32 size;
624 size = oapv_bsr_read(bs, 32);
625 oapv_assert_rv(size > 0 && size < 0xFFFFFFFF, OAPV_ERR_MALFORMED_BITSTREAM);
626 *au_size = size;
627 return OAPV_OK;
628 }
629
oapvd_vlc_pbu_size(oapv_bs_t * bs,u32 * pbu_size)630 int oapvd_vlc_pbu_size(oapv_bs_t *bs, u32 *pbu_size)
631 {
632 u32 size;
633 size = oapv_bsr_read(bs, 32);
634 DUMP_HLS(pbu_size, size);
635 oapv_assert_rv(size > 0 && size < 0xFFFFFFFF, OAPV_ERR_MALFORMED_BITSTREAM);
636 *pbu_size = size;
637 return OAPV_OK;
638 }
639
oapvd_vlc_pbu_header(oapv_bs_t * bs,oapv_pbuh_t * pbuh)640 int oapvd_vlc_pbu_header(oapv_bs_t *bs, oapv_pbuh_t *pbuh)
641 {
642 int reserved_zero;
643 pbuh->pbu_type = oapv_bsr_read(bs, 8);
644 DUMP_HLS(pbu_type, pbuh->pbu_type);
645 oapv_assert_rv(pbuh->pbu_type != 0, OAPV_ERR_MALFORMED_BITSTREAM);
646 oapv_assert_rv(!(pbuh->pbu_type >= 3 && pbuh->pbu_type <= 24), OAPV_ERR_MALFORMED_BITSTREAM);
647 oapv_assert_rv(!(pbuh->pbu_type >= 28 && pbuh->pbu_type <= 64), OAPV_ERR_MALFORMED_BITSTREAM);
648 oapv_assert_rv(!(pbuh->pbu_type >= 68), OAPV_ERR_MALFORMED_BITSTREAM);
649
650 pbuh->group_id = oapv_bsr_read(bs, 16);
651 DUMP_HLS(group_id, pbuh->group_id);
652 oapv_assert_rv(pbuh->group_id >= 0 && pbuh->group_id < 0xFFFF, OAPV_ERR_MALFORMED_BITSTREAM);
653
654 reserved_zero = oapv_bsr_read(bs, 8);
655 DUMP_HLS(reserved_zero, reserved_zero);
656 oapv_assert_rv(reserved_zero == 0, OAPV_ERR_MALFORMED_BITSTREAM);
657 return OAPV_OK;
658 }
659
oapvd_vlc_frame_info(oapv_bs_t * bs,oapv_fi_t * fi)660 int oapvd_vlc_frame_info(oapv_bs_t *bs, oapv_fi_t *fi)
661 {
662 int reserved_zero;
663
664 fi->profile_idc = oapv_bsr_read(bs, 8);
665 DUMP_HLS(fi->profile_idc, fi->profile_idc);
666
667 fi->level_idc = oapv_bsr_read(bs, 8);
668 DUMP_HLS(fi->level_idc, fi->level_idc);
669
670 fi->band_idc = oapv_bsr_read(bs, 3);
671 DUMP_HLS(fi->band_idc, fi->band_idc);
672
673 reserved_zero = oapv_bsr_read(bs, 5);
674 DUMP_HLS(reserved_zero, reserved_zero);
675 oapv_assert_rv(reserved_zero == 0, OAPV_ERR_MALFORMED_BITSTREAM);
676
677 fi->frame_width = oapv_bsr_read(bs, 24);
678 DUMP_HLS(fi->frame_width, fi->frame_width);
679 oapv_assert_rv(fi->frame_width > 0, OAPV_ERR_MALFORMED_BITSTREAM);
680
681 fi->frame_height = oapv_bsr_read(bs, 24);
682 DUMP_HLS(fi->frame_height, fi->frame_height);
683 oapv_assert_rv(fi->frame_height > 0, OAPV_ERR_MALFORMED_BITSTREAM);
684
685 fi->chroma_format_idc = oapv_bsr_read(bs, 4);
686 DUMP_HLS(fi->chroma_format_idc, fi->chroma_format_idc);
687 oapv_assert_rv(fi->chroma_format_idc >= 0 && fi->chroma_format_idc <= 4, OAPV_ERR_MALFORMED_BITSTREAM);
688 oapv_assert_rv(fi->chroma_format_idc != 1, OAPV_ERR_MALFORMED_BITSTREAM);
689
690 fi->bit_depth = oapv_bsr_read(bs, 4);
691 DUMP_HLS(fi->bit_depth, fi->bit_depth);
692 oapv_assert_rv(fi->bit_depth >= 2 && fi->bit_depth <= 8, OAPV_ERR_MALFORMED_BITSTREAM);
693 fi->bit_depth += 8;
694
695 fi->capture_time_distance = oapv_bsr_read(bs, 8);
696 DUMP_HLS(fi->capture_time_distance, fi->capture_time_distance);
697
698 reserved_zero = oapv_bsr_read(bs, 8);
699 DUMP_HLS(reserved_zero, reserved_zero);
700 oapv_assert_rv(reserved_zero == 0, OAPV_ERR_MALFORMED_BITSTREAM);
701
702 // check frame width in case of 422 format.
703 if(fi->chroma_format_idc == 2) {
704 // frame_width should be multiple of 2
705 oapv_assert_rv((fi->frame_width & 0x1) == 0, OAPV_ERR_MALFORMED_BITSTREAM);
706 }
707
708 return OAPV_OK;
709 }
710
oapvd_vlc_au_info(oapv_bs_t * bs,oapv_aui_t * aui)711 int oapvd_vlc_au_info(oapv_bs_t *bs, oapv_aui_t *aui)
712 {
713 int ret;
714 int reserved_zero_8bits;
715
716 aui->num_frames = oapv_bsr_read(bs, 16);
717 DUMP_HLS(num_frames, aui->num_frames);
718 oapv_assert_rv(aui->num_frames <= OAPV_MAX_NUM_FRAMES, OAPV_ERR_REACHED_MAX);
719 for(int fidx = 0; fidx < aui->num_frames; fidx++) {
720 aui->pbu_type[fidx] = oapv_bsr_read(bs, 8);
721 DUMP_HLS(pbu_type, aui->pbu_type[fidx]);
722 aui->group_id[fidx] = oapv_bsr_read(bs, 16);
723 DUMP_HLS(group_id, aui->group_id[fidx]);
724 reserved_zero_8bits = oapv_bsr_read(bs, 8);
725 DUMP_HLS(reserved_zero_8bits, reserved_zero_8bits);
726 oapv_assert_rv(reserved_zero_8bits == 0, OAPV_ERR_MALFORMED_BITSTREAM);
727 ret = oapvd_vlc_frame_info(bs, &aui->frame_info[fidx]);
728 oapv_assert_rv(OAPV_SUCCEEDED(ret), ret);
729 }
730 reserved_zero_8bits = oapv_bsr_read(bs, 8);
731 DUMP_HLS(reserved_zero_8bits, reserved_zero_8bits);
732 oapv_assert_rv(reserved_zero_8bits == 0, OAPV_ERR_MALFORMED_BITSTREAM);
733 /* byte align */
734 oapv_bsr_align8(bs);
735 return OAPV_OK;
736 }
737
dec_vlc_q_matrix(oapv_bs_t * bs,oapv_fh_t * fh)738 static int dec_vlc_q_matrix(oapv_bs_t *bs, oapv_fh_t *fh)
739 {
740 int num_comp = get_num_comp(fh->fi.chroma_format_idc);
741 for(int cidx = 0; cidx < num_comp; cidx++) {
742 for(int y = 0; y < OAPV_BLK_H; y++) {
743 for(int x = 0; x < OAPV_BLK_W; x++) {
744 fh->q_matrix[cidx][y][x] = oapv_bsr_read(bs, 8);
745 DUMP_HLS(fh->q_matrix, fh->q_matrix[cidx][y][x]);
746 oapv_assert_rv(fh->q_matrix[cidx][y][x] > 0, OAPV_ERR_MALFORMED_BITSTREAM);
747 }
748 }
749 }
750 return OAPV_OK;
751 }
752
dec_vlc_tile_info(oapv_bs_t * bs,oapv_fh_t * fh)753 static int dec_vlc_tile_info(oapv_bs_t *bs, oapv_fh_t *fh)
754 {
755 int pic_w, pic_h, tile_w, tile_h, tile_cols, tile_rows;
756
757 fh->tile_width_in_mbs = oapv_bsr_read(bs, 20);
758 DUMP_HLS(fh->tile_width_in_mbs, fh->tile_width_in_mbs);
759 oapv_assert_rv(fh->tile_width_in_mbs > 0, OAPV_ERR_MALFORMED_BITSTREAM);
760
761 fh->tile_height_in_mbs = oapv_bsr_read(bs, 20);
762 DUMP_HLS(fh->tile_height_in_mbs, fh->tile_height_in_mbs);
763 oapv_assert_rv(fh->tile_height_in_mbs > 0, OAPV_ERR_MALFORMED_BITSTREAM);
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, OAPV_ERR_MALFORMED_BITSTREAM);
785 }
786 }
787 return OAPV_OK;
788 }
789
oapvd_vlc_frame_header(oapv_bs_t * bs,oapv_fh_t * fh)790 int oapvd_vlc_frame_header(oapv_bs_t *bs, oapv_fh_t *fh)
791 {
792 int ret, reserved_zero;
793 ret = oapvd_vlc_frame_info(bs, &fh->fi);
794 oapv_assert_rv(OAPV_SUCCEEDED(ret), ret);
795
796 reserved_zero = oapv_bsr_read(bs, 8);
797 DUMP_HLS(reserved_zero, reserved_zero);
798 oapv_assert_rv(reserved_zero == 0, OAPV_ERR_MALFORMED_BITSTREAM);
799
800 fh->color_description_present_flag = oapv_bsr_read1(bs);
801 DUMP_HLS(fh->color_description_present_flag, fh->color_description_present_flag);
802 if(fh->color_description_present_flag) {
803 fh->color_primaries = oapv_bsr_read(bs, 8);
804 DUMP_HLS(fh->color_primaries, fh->color_primaries);
805 fh->transfer_characteristics = oapv_bsr_read(bs, 8);
806 DUMP_HLS(fh->transfer_characteristics, fh->transfer_characteristics);
807 fh->matrix_coefficients = oapv_bsr_read(bs, 8);
808 DUMP_HLS(fh->matrix_coefficients, fh->matrix_coefficients);
809 fh->full_range_flag = oapv_bsr_read1(bs);
810 DUMP_HLS(fh->full_range_flag, fh->full_range_flag);
811 }
812 else {
813 // default value settings
814 fh->color_primaries = 2; // unspecified
815 fh->transfer_characteristics = 2; // unspecified
816 fh->matrix_coefficients = 2; // unspecified
817 fh->full_range_flag = 0; // limited range
818 }
819 fh->use_q_matrix = oapv_bsr_read1(bs);
820 DUMP_HLS(fh->use_q_matrix, fh->use_q_matrix);
821 if(fh->use_q_matrix) {
822 ret = dec_vlc_q_matrix(bs, fh);
823 oapv_assert_rv(OAPV_SUCCEEDED(ret), ret);
824 }
825
826 ret = dec_vlc_tile_info(bs, fh);
827 oapv_assert_rv(OAPV_SUCCEEDED(ret), ret);
828
829 reserved_zero = oapv_bsr_read(bs, 8);
830 DUMP_HLS(reserved_zero, reserved_zero);
831 oapv_assert_rv(reserved_zero == 0, OAPV_ERR_MALFORMED_BITSTREAM);
832
833 /* byte align */
834 oapv_bsr_align8(bs);
835
836 if(fh->use_q_matrix == 0) {
837 int num_comp = get_num_comp(fh->fi.chroma_format_idc);
838 for(int cidx = 0; cidx < num_comp; cidx++) {
839 for(int y = 0; y < OAPV_BLK_H; y++) {
840 for(int x = 0; x < OAPV_BLK_W; x++) {
841 fh->q_matrix[cidx][y][x] = 16;
842 }
843 }
844 }
845 }
846
847 return OAPV_OK;
848 }
849
oapvd_vlc_tile_size(oapv_bs_t * bs,u32 * tile_size)850 int oapvd_vlc_tile_size(oapv_bs_t *bs, u32 *tile_size)
851 {
852 u32 size = oapv_bsr_read(bs, 32);
853 DUMP_HLS(tile_size, size);
854 oapv_assert_rv(size > 0, OAPV_ERR_MALFORMED_BITSTREAM);
855 *tile_size = size;
856 return OAPV_OK;
857 }
858
oapvd_vlc_tile_header(oapv_bs_t * bs,oapvd_ctx_t * ctx,oapv_th_t * th)859 int oapvd_vlc_tile_header(oapv_bs_t *bs, oapvd_ctx_t *ctx, oapv_th_t *th)
860 {
861 th->tile_header_size = oapv_bsr_read(bs, 16);
862 DUMP_HLS(th->tile_header_size, th->tile_header_size);
863 th->tile_index = oapv_bsr_read(bs, 16);
864 DUMP_HLS(th->tile_index, th->tile_index);
865 for(int c = 0; c < ctx->num_comp; c++) {
866 th->tile_data_size[c] = oapv_bsr_read(bs, 32);
867 DUMP_HLS(th->tile_data_size, th->tile_data_size[c]);
868 oapv_assert_rv(th->tile_data_size[c] > 0, OAPV_ERR_MALFORMED_BITSTREAM);
869 }
870 for(int c = 0; c < ctx->num_comp; c++) {
871 th->tile_qp[c] = oapv_bsr_read(bs, 8);
872 DUMP_HLS(th->tile_qp, th->tile_qp[c]);
873 }
874 th->reserved_zero_8bits = oapv_bsr_read(bs, 8);
875 DUMP_HLS(th->reserved_zero_8bits, th->reserved_zero_8bits);
876 /* byte align */
877 oapv_bsr_align8(bs);
878
879 oapv_assert_rv(th->reserved_zero_8bits == 0, OAPV_ERR_MALFORMED_BITSTREAM);
880 return OAPV_OK;
881 }
882
oapve_vlc_dc_coeff(oapve_ctx_t * ctx,oapve_core_t * core,oapv_bs_t * bs,int dc_diff,int c)883 int oapve_vlc_dc_coeff(oapve_ctx_t *ctx, oapve_core_t *core, oapv_bs_t *bs, int dc_diff, int c)
884 {
885 int rice_level = 0;
886 int abs_dc_diff = oapv_abs32(dc_diff);
887 int sign_dc_diff = (dc_diff > 0) ? 0 : 1;
888
889 rice_level = oapv_clip3(OAPV_MIN_DC_LEVEL_CTX, OAPV_MAX_DC_LEVEL_CTX, core->prev_dc_ctx[c] >> 1);
890 enc_vlc_write(bs, abs_dc_diff, rice_level);
891
892 if(abs_dc_diff)
893 oapv_bsw_write1(bs, sign_dc_diff);
894
895 core->prev_dc_ctx[c] = abs_dc_diff;
896 return OAPV_OK;
897 }
oapve_vlc_ac_coeff(oapve_ctx_t * ctx,oapve_core_t * core,oapv_bs_t * bs,s16 * coef,int num_sig,int ch_type)898 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)
899 {
900 ALIGNED_16(s16 coef_temp[64]);
901 u32 num_coeff, scan_pos;
902 u32 sign, level, prev_level, run;
903 const u16 *scanp;
904 s16 coef_cur;
905
906 scanp = oapv_tbl_scan;
907 num_coeff = OAPV_BLK_D;
908 run = 0;
909 int first_ac = 1;
910 prev_level = core->prev_1st_ac_ctx[ch_type];
911 int prev_run = 0;
912 int rice_run = 0;
913 int rice_level = 0;
914 int lb = bs->leftbits;
915 u32 code = bs->code;
916 u8 *cur = bs->cur;
917
918 for(scan_pos = 1; scan_pos < num_coeff; scan_pos++) {
919 coef_temp[scan_pos] = coef[scanp[scan_pos]];
920 }
921
922 const s32 simple_vlc_table[3][2] = { {
923 1,
924 },
925 { 0, 0 },
926 { 0, 1 } };
927 for(scan_pos = 1; scan_pos < num_coeff - 1; scan_pos++) {
928 coef_cur = coef_temp[scan_pos];
929 if(coef_cur) {
930 level = oapv_abs16(coef_cur);
931 sign = (coef_cur > 0) ? 0 : 1;
932 rice_run = prev_run >> 2;
933 if(rice_run > 2)
934 rice_run = 2;
935 if(run == 0 && rice_run == 0) {
936 lb--; // bs->leftbits--;
937 code |= (1 << lb);
938 if(lb == 0) {
939 OAPV_FLUSH_SWAP(cur, code, lb);
940 }
941 }
942 else {
943 int leftbits;
944 leftbits = lb;
945 u32 code_from_lut = CODE_LUT_100[run][rice_run][0];
946 int len_from_lut = CODE_LUT_100[run][rice_run][1];
947 code |= (code_from_lut >> (32 - leftbits));
948 if(len_from_lut < leftbits) {
949 lb -= len_from_lut;
950 }
951 else {
952 lb = 0;
953 OAPV_FLUSH_SWAP(cur, code, lb);
954 code = (leftbits < 32 ? code_from_lut << leftbits : 0);
955 lb = 32 - (len_from_lut - leftbits);
956 }
957 }
958 rice_level = prev_level >> 2;
959 if(rice_level > 4)
960 rice_level = OAPV_MAX_AC_LEVEL_CTX;
961 if(level - 1 == 0 && rice_level == 0) {
962 lb--;
963 code |= (1 << lb);
964 if(lb == 0) {
965 OAPV_FLUSH_SWAP(cur, code, lb);
966 }
967 }
968 else {
969 if(level - 1 > 98) {
970 {
971 int k = rice_level;
972 u32 symbol = level - 1;
973 u32 simple_vlc_val = oapv_clip3(0, 2, symbol >> k);
974 int bit_cnt = 0;
975 if(symbol >= (u32)(1 << k)) {
976 symbol -= (1 << k);
977 int val = simple_vlc_table[simple_vlc_val][bit_cnt];
978 lb--;
979 code |= ((val & 0x1) << lb);
980 if(lb == 0) {
981 OAPV_FLUSH_SWAP(cur, code, lb);
982 }
983 bit_cnt++;
984 }
985 if(symbol >= (u32)(1 << k) && simple_vlc_val > 0) {
986 symbol -= (1 << k);
987 int val = simple_vlc_table[simple_vlc_val][bit_cnt];
988 lb--;
989 code |= ((val & 0x1) << lb);
990 if(lb == 0) {
991 OAPV_FLUSH_SWAP(cur, code, lb);
992 }
993 bit_cnt++;
994 }
995 while(symbol >= (u32)(1 << k)) {
996 symbol -= (1 << k);
997 lb--;
998 if(lb == 0) {
999 OAPV_FLUSH_SWAP(cur, code, lb);
1000 }
1001 if(bit_cnt >= 2) {
1002 k++;
1003 }
1004 bit_cnt++;
1005 }
1006 if(bit_cnt < 2) {
1007 int val = simple_vlc_table[simple_vlc_val][bit_cnt];
1008 lb--;
1009 code |= ((val & 0x1) << lb);
1010 if(lb == 0) {
1011 OAPV_FLUSH_SWAP(cur, code, lb);
1012 }
1013 }
1014 else {
1015 lb--;
1016 code |= ((1 & 0x1) << lb);
1017 if(lb == 0) {
1018 OAPV_FLUSH_SWAP(cur, code, lb);
1019 }
1020 }
1021 if(k > 0) {
1022 int leftbits;
1023 leftbits = lb;
1024 symbol <<= (32 - k);
1025 code |= (symbol >> (32 - leftbits));
1026 if(k < leftbits) {
1027 lb -= k;
1028 }
1029 else {
1030 lb = 0;
1031 OAPV_FLUSH_SWAP(cur, code, lb);
1032 code = (leftbits < 32 ? symbol << leftbits : 0);
1033 lb = 32 - (k - leftbits);
1034 }
1035 }
1036 }
1037 }
1038 else {
1039 int leftbits;
1040 leftbits = lb;
1041 u32 code_from_lut = CODE_LUT_100[level - 1][rice_level][0];
1042 int len_from_lut = CODE_LUT_100[level - 1][rice_level][1];
1043 code |= (code_from_lut >> (32 - leftbits));
1044 if(len_from_lut < leftbits) {
1045 lb -= len_from_lut;
1046 }
1047 else {
1048 lb = 0;
1049 OAPV_FLUSH_SWAP(cur, code, lb);
1050 code = (leftbits < 32 ? code_from_lut << leftbits : 0);
1051 lb = 32 - (len_from_lut - leftbits);
1052 }
1053 }
1054 }
1055 {
1056 lb--;
1057 code |= ((sign & 0x1) << lb);
1058 if(lb == 0) {
1059 OAPV_FLUSH_SWAP(cur, code, lb);
1060 }
1061 }
1062 if(first_ac) {
1063 first_ac = 0;
1064 core->prev_1st_ac_ctx[ch_type] = level;
1065 }
1066 prev_run = run;
1067 run = 0;
1068 prev_level = level;
1069 }
1070 else {
1071 run++;
1072 }
1073 }
1074 bs->cur = cur;
1075 bs->code = code;
1076 bs->leftbits = lb;
1077 coef_cur = coef_temp[scan_pos];
1078 if(coef_cur) {
1079 level = oapv_abs16(coef_cur);
1080 sign = (coef_cur > 0) ? 0 : 1;
1081 /* Run coding */
1082 rice_run = prev_run >> 2;
1083 if(rice_run > 2)
1084 rice_run = 2;
1085 if(run == 0 && rice_run == 0) {
1086 bs->leftbits--;
1087 bs->code |= (1 << bs->leftbits);
1088 if(bs->leftbits == 0) {
1089 OAPV_FLUSH(bs);
1090 }
1091 }
1092 else {
1093 int leftbits;
1094 leftbits = bs->leftbits;
1095 u32 code_from_lut = CODE_LUT_100[run][rice_run][0];
1096 int len_from_lut = CODE_LUT_100[run][rice_run][1];
1097 bs->code |= (code_from_lut >> (32 - leftbits));
1098 if(len_from_lut < leftbits) {
1099 bs->leftbits -= len_from_lut;
1100 }
1101 else {
1102 bs->leftbits = 0;
1103 OAPV_FLUSH(bs);
1104 bs->code = (leftbits < 32 ? code_from_lut << leftbits : 0);
1105 bs->leftbits = 32 - (len_from_lut - leftbits);
1106 }
1107 }
1108 /* Level coding */
1109 rice_level = prev_level >> 2;
1110 if(rice_level > 4)
1111 rice_level = OAPV_MAX_AC_LEVEL_CTX;
1112 if(level - 1 == 0 && rice_level == 0) {
1113 bs->leftbits--;
1114 bs->code |= (1 << bs->leftbits);
1115 if(bs->leftbits == 0) {
1116 OAPV_FLUSH(bs);
1117 }
1118 }
1119 else {
1120 if(level - 1 > 98) {
1121 enc_vlc_write(bs, level - 1, rice_level);
1122 }
1123 else {
1124 int leftbits;
1125 leftbits = bs->leftbits;
1126 u32 code_from_lut = CODE_LUT_100[level - 1][rice_level][0];
1127 int len_from_lut = CODE_LUT_100[level - 1][rice_level][1];
1128 bs->code |= (code_from_lut >> (32 - leftbits));
1129 if(len_from_lut < leftbits) {
1130 bs->leftbits -= len_from_lut;
1131 }
1132 else {
1133 bs->leftbits = 0;
1134 OAPV_FLUSH(bs);
1135 bs->code = (leftbits < 32 ? code_from_lut << leftbits : 0);
1136 bs->leftbits = 32 - (len_from_lut - leftbits);
1137 }
1138 }
1139 }
1140 /* Sign coding */
1141 {
1142 bs->leftbits--;
1143 bs->code |= ((sign & 0x1) << bs->leftbits);
1144 if(bs->leftbits == 0) {
1145 OAPV_FLUSH(bs);
1146 }
1147 }
1148 if(first_ac) {
1149 first_ac = 0;
1150 core->prev_1st_ac_ctx[ch_type] = level;
1151 }
1152 }
1153 else {
1154 run++;
1155 }
1156 if(coef_temp[num_coeff - 1] == 0) {
1157 int rice_run = 0;
1158 rice_run = prev_run >> 2;
1159 if(rice_run > 2)
1160 rice_run = 2;
1161
1162 if(run == 0 && rice_run == 0) {
1163 bs->leftbits--;
1164 bs->code |= (1 << bs->leftbits);
1165 if(bs->leftbits == 0) {
1166 OAPV_FLUSH(bs);
1167 }
1168 }
1169 else {
1170 int leftbits;
1171 leftbits = bs->leftbits;
1172 u32 code_from_lut = CODE_LUT_100[run][rice_run][0];
1173 int len_from_lut = CODE_LUT_100[run][rice_run][1];
1174 bs->code |= (code_from_lut >> (32 - leftbits));
1175 if(len_from_lut < leftbits) {
1176 bs->leftbits -= len_from_lut;
1177 }
1178 else {
1179 bs->leftbits = 0;
1180 OAPV_FLUSH(bs);
1181 bs->code = (leftbits < 32 ? code_from_lut << leftbits : 0);
1182 bs->leftbits = 32 - (len_from_lut - leftbits);
1183 }
1184 }
1185 }
1186 }
1187
oapvd_vlc_dc_coeff(oapvd_ctx_t * ctx,oapvd_core_t * core,oapv_bs_t * bs,int * dc_diff,int c)1188 int oapvd_vlc_dc_coeff(oapvd_ctx_t *ctx, oapvd_core_t *core, oapv_bs_t *bs, int *dc_diff, int c)
1189 {
1190 int rice_level = 0;
1191 int abs_dc_diff;
1192 int sign_dc_diff = 0;
1193
1194 rice_level = oapv_clip3(OAPV_MIN_DC_LEVEL_CTX, OAPV_MAX_DC_LEVEL_CTX, core->prev_dc_ctx[c] >> 1);
1195 abs_dc_diff = dec_vlc_read(bs, rice_level);
1196 if(abs_dc_diff)
1197 sign_dc_diff = oapv_bsr_read1(bs);
1198
1199 *dc_diff = sign_dc_diff ? -abs_dc_diff : abs_dc_diff;
1200 core->prev_dc_ctx[c] = abs_dc_diff;
1201
1202 return OAPV_OK;
1203 }
1204
oapvd_vlc_ac_coeff(oapvd_ctx_t * ctx,oapvd_core_t * core,oapv_bs_t * bs,s16 * coef,int c)1205 int oapvd_vlc_ac_coeff(oapvd_ctx_t *ctx, oapvd_core_t *core, oapv_bs_t *bs, s16 *coef, int c)
1206 {
1207 int sign, level, prev_level, run;
1208 int scan_pos_offset, num_coeff, i;
1209 const u16 *scanp;
1210
1211 scanp = oapv_tbl_scan;
1212 num_coeff = OAPV_BLK_D;
1213 scan_pos_offset = 1;
1214 run = 0;
1215
1216 int first_ac = 1;
1217 prev_level = core->prev_1st_ac_ctx[c];
1218 int prev_run = 0;
1219
1220 do {
1221 int rice_run = 0;
1222 rice_run = prev_run / 4;
1223 if(rice_run > 2)
1224 rice_run = 2;
1225 if(rice_run == 0) {
1226 if(bs->leftbits == 0) {
1227 OAPV_READ_FLUSH(bs, 4);
1228 }
1229 u32 t0 = (u32)(bs->code >> 31);
1230 bs->code <<= 1;
1231 bs->leftbits -= 1;
1232 if(t0)
1233 run = 0;
1234 else
1235 run = dec_vlc_read_1bit_read(bs, rice_run);
1236 }
1237 else {
1238 run = dec_vlc_read(bs, rice_run);
1239 }
1240
1241 oapv_assert_rv((scan_pos_offset + run) <= 64, OAPV_ERR_MALFORMED_BITSTREAM);
1242 for (i = scan_pos_offset; i < scan_pos_offset + run; i++){
1243 coef[scanp[i]] = 0;
1244 }
1245
1246 if(scan_pos_offset + run == num_coeff) {
1247 break;
1248 }
1249
1250 scan_pos_offset += run;
1251
1252 /* Level parsing */
1253 int rice_level = 0;
1254 if(scan_pos_offset == 0) {
1255 rice_level = oapv_clip3(OAPV_MIN_DC_LEVEL_CTX, OAPV_MAX_DC_LEVEL_CTX, core->prev_dc_ctx[c] >> 1);
1256 }
1257 else {
1258 rice_level = oapv_clip3(OAPV_MIN_AC_LEVEL_CTX, OAPV_MAX_AC_LEVEL_CTX, prev_level >> 2);
1259 }
1260
1261 if(rice_level == 0) {
1262 if(bs->leftbits == 0) {
1263 OAPV_READ_FLUSH(bs, 4);
1264 }
1265 u32 t0 = (u32)(bs->code >> 31);
1266 bs->code <<= 1;
1267 bs->leftbits -= 1;
1268 if(t0)
1269 level = 0;
1270 else
1271 level = dec_vlc_read_1bit_read(bs, rice_level);
1272 }
1273 else {
1274 level = dec_vlc_read(bs, rice_level);
1275 }
1276 level++;
1277
1278 if(scan_pos_offset != 0) {
1279 prev_level = level;
1280 }
1281 prev_run = run;
1282
1283 if(scan_pos_offset == 0) {
1284 core->prev_dc_ctx[c] = level;
1285 }
1286 else if(first_ac) {
1287 first_ac = 0;
1288 core->prev_1st_ac_ctx[c] = level;
1289 }
1290
1291 /* Sign parsing */
1292 if(bs->leftbits == 0) {
1293 OAPV_READ_FLUSH(bs, 4);
1294 }
1295 sign = (u32)(bs->code >> 31);
1296 bs->code <<= 1;
1297 bs->leftbits -= 1;
1298 coef[scanp[scan_pos_offset]] = sign ? -(s16)level : (s16)level;
1299
1300 if(scan_pos_offset >= num_coeff - 1) {
1301 break;
1302 }
1303 scan_pos_offset++;
1304 } while(1);
1305
1306 return OAPV_OK;
1307 }
1308
oapvd_vlc_tile_dummy_data(oapv_bs_t * bs)1309 int oapvd_vlc_tile_dummy_data(oapv_bs_t *bs)
1310 {
1311 while(bs->cur <= bs->end) {
1312 oapv_bsr_read(bs, 8);
1313 }
1314 return OAPV_OK;
1315 }
1316
oapvd_vlc_metadata(oapv_bs_t * bs,u32 pbu_size,oapvm_t mid,int group_id)1317 int oapvd_vlc_metadata(oapv_bs_t *bs, u32 pbu_size, oapvm_t mid, int group_id)
1318 {
1319 int ret;
1320 u32 t0;
1321 u32 metadata_size;
1322 metadata_size = oapv_bsr_read(bs, 32);
1323 DUMP_HLS(metadata_size, metadata_size);
1324 oapv_assert_gv(pbu_size >= 8 && metadata_size <= (pbu_size - 8), ret, OAPV_ERR_MALFORMED_BITSTREAM, ERR);
1325 u8 *bs_start_pos = bs->cur;
1326 u8 *payload_data = NULL;
1327
1328 while(metadata_size > 0) {
1329 u32 payload_type = 0, payload_size = 0;
1330 t0 = 0;
1331 do {
1332 t0 = oapv_bsr_read(bs, 8);
1333 DUMP_HLS(payload_type, t0);
1334 oapv_assert_gv(metadata_size > 0, ret, OAPV_ERR_MALFORMED_BITSTREAM, ERR);
1335 metadata_size -= 1;
1336 if(t0 == 0xFF) {
1337 payload_type += 255;
1338 }
1339 } while(t0 == 0xFF);
1340 payload_type += t0;
1341
1342 t0 = 0;
1343 do {
1344 t0 = oapv_bsr_read(bs, 8);
1345 DUMP_HLS(payload_size, t0);
1346 oapv_assert_gv(metadata_size > 0, ret, OAPV_ERR_MALFORMED_BITSTREAM, ERR);
1347 metadata_size -= 1;
1348 if(t0 == 0xFF) {
1349 payload_size += 255;
1350 }
1351 } while(t0 == 0xFF);
1352 payload_size += t0;
1353 oapv_assert_gv(payload_size <= metadata_size, ret, OAPV_ERR_MALFORMED_BITSTREAM, ERR);
1354
1355 if(payload_size > 0) {
1356
1357 payload_data = oapv_malloc(payload_size);
1358 oapv_assert_gv(payload_data != NULL, ret, OAPV_ERR_OUT_OF_MEMORY, ERR);
1359 if(payload_type == OAPV_METADATA_FILLER) {
1360 for(u32 i = 0; i < payload_size; i++) {
1361 t0 = oapv_bsr_read(bs, 8);
1362 DUMP_HLS(payload_data, t0);
1363 oapv_assert_gv(t0 == 0xFF, ret, OAPV_ERR_MALFORMED_BITSTREAM, ERR);
1364 payload_data[i] = 0xFF;
1365 }
1366 }
1367 else {
1368 for(u32 i = 0; i < payload_size; i++) {
1369 t0 = oapv_bsr_read(bs, 8);
1370 DUMP_HLS(payload_data, t0);
1371 payload_data[i] = t0;
1372 }
1373 }
1374 }
1375 ret = oapvm_set(mid, group_id, payload_type, payload_data, payload_size,
1376 payload_type == OAPV_METADATA_USER_DEFINED ? payload_data : NULL);
1377 oapv_assert_g(OAPV_SUCCEEDED(ret), ERR);
1378 metadata_size -= payload_size;
1379 }
1380 const u32 target_read_size = (pbu_size - 8);
1381 ret = oapvd_vlc_filler(bs, target_read_size - (bs->cur - bs_start_pos));
1382 oapv_assert_g(OAPV_SUCCEEDED(ret), ERR);
1383 return OAPV_OK;
1384
1385 ERR:
1386 // TO-DO: free memory
1387 return ret;
1388 }
1389
oapvd_vlc_filler(oapv_bs_t * bs,u32 filler_size)1390 int oapvd_vlc_filler(oapv_bs_t *bs, u32 filler_size)
1391 {
1392 int val;
1393 while(filler_size > 0) {
1394 val = oapv_bsr_read(bs, 8);
1395 if(val != 0xFF) {
1396 return OAPV_ERR_MALFORMED_BITSTREAM;
1397 }
1398 filler_size--;
1399 }
1400 return OAPV_OK;
1401 }
1402
1403 ///////////////////////////////////////////////////////////////////////////////
1404 // end of decoder code
1405 #endif // ENABLE_DECODER
1406 ///////////////////////////////////////////////////////////////////////////////
1407