1 /*
2 *
3 * Copyright 2015 Rockchip Electronics Co. LTD
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17
18 /*
19 * @file h265d_ps.c
20 * @brief
21 * @author csy(csy@rock-chips.com)
22
23 * @version 1.0.0
24 * @history
25 * 2015.7.15 : Create
26 */
27
28 #define MODULE_TAG "H265PARSER_PS"
29
30 #include "mpp_mem.h"
31 #include "mpp_bitread.h"
32 #include "h265d_parser.h"
33
34 static const RK_U8 default_scaling_list_intra[] = {
35 16, 16, 16, 16, 17, 18, 21, 24,
36 16, 16, 16, 16, 17, 19, 22, 25,
37 16, 16, 17, 18, 20, 22, 25, 29,
38 16, 16, 18, 21, 24, 27, 31, 36,
39 17, 17, 20, 24, 30, 35, 41, 47,
40 18, 19, 22, 27, 35, 44, 54, 65,
41 21, 22, 25, 31, 41, 54, 70, 88,
42 24, 25, 29, 36, 47, 65, 88, 115
43 };
44
45 static const RK_U8 default_scaling_list_inter[] = {
46 16, 16, 16, 16, 17, 18, 20, 24,
47 16, 16, 16, 17, 18, 20, 24, 25,
48 16, 16, 17, 18, 20, 24, 25, 28,
49 16, 17, 18, 20, 24, 25, 28, 33,
50 17, 18, 20, 24, 25, 28, 33, 41,
51 18, 20, 24, 25, 28, 33, 41, 54,
52 20, 24, 25, 28, 33, 41, 54, 71,
53 24, 25, 28, 33, 41, 54, 71, 91
54 };
55
56 static const MppRational_t vui_sar[] = {
57 { 0, 1 },
58 { 1, 1 },
59 { 12, 11 },
60 { 10, 11 },
61 { 16, 11 },
62 { 40, 33 },
63 { 24, 11 },
64 { 20, 11 },
65 { 32, 11 },
66 { 80, 33 },
67 { 18, 11 },
68 { 15, 11 },
69 { 64, 33 },
70 { 160, 99 },
71 { 4, 3 },
72 { 3, 2 },
73 { 2, 1 },
74 };
75
76 const RK_U8 mpp_hevc_diag_scan4x4_x[16] = {
77 0, 0, 1, 0,
78 1, 2, 0, 1,
79 2, 3, 1, 2,
80 3, 2, 3, 3,
81 };
82
83 const RK_U8 mpp_hevc_diag_scan4x4_y[16] = {
84 0, 1, 0, 2,
85 1, 0, 3, 2,
86 1, 0, 3, 2,
87 1, 3, 2, 3,
88 };
89
90 const RK_U8 mpp_hevc_diag_scan8x8_x[64] = {
91 0, 0, 1, 0,
92 1, 2, 0, 1,
93 2, 3, 0, 1,
94 2, 3, 4, 0,
95 1, 2, 3, 4,
96 5, 0, 1, 2,
97 3, 4, 5, 6,
98 0, 1, 2, 3,
99 4, 5, 6, 7,
100 1, 2, 3, 4,
101 5, 6, 7, 2,
102 3, 4, 5, 6,
103 7, 3, 4, 5,
104 6, 7, 4, 5,
105 6, 7, 5, 6,
106 7, 6, 7, 7,
107 };
108
109 const RK_U8 mpp_hevc_diag_scan8x8_y[64] = {
110 0, 1, 0, 2,
111 1, 0, 3, 2,
112 1, 0, 4, 3,
113 2, 1, 0, 5,
114 4, 3, 2, 1,
115 0, 6, 5, 4,
116 3, 2, 1, 0,
117 7, 6, 5, 4,
118 3, 2, 1, 0,
119 7, 6, 5, 4,
120 3, 2, 1, 7,
121 6, 5, 4, 3,
122 2, 7, 6, 5,
123 4, 3, 7, 6,
124 5, 4, 7, 6,
125 5, 7, 6, 7,
126 };
127
rkv_len_align_422(RK_U32 val)128 static RK_U32 rkv_len_align_422(RK_U32 val)
129 {
130 return (2 * MPP_ALIGN(val, 16));
131 }
132
rkv_len_align_444(RK_U32 val)133 static RK_U32 rkv_len_align_444(RK_U32 val)
134 {
135 return (3 * MPP_ALIGN(val, 16));
136 }
137
mpp_hevc_decode_short_term_rps(HEVCContext * s,ShortTermRPS * rps,const HEVCSPS * sps,RK_S32 is_slice_header)138 int mpp_hevc_decode_short_term_rps(HEVCContext *s, ShortTermRPS *rps,
139 const HEVCSPS *sps, RK_S32 is_slice_header)
140 {
141 HEVCLocalContext *lc = s->HEVClc;
142 RK_U8 rps_predict = 0;
143 RK_S32 delta_poc;
144 RK_S32 k0 = 0;
145 RK_S32 k = 0;
146 RK_S32 i;
147
148 BitReadCtx_t *gb = &lc->gb;
149
150 if (rps != sps->st_rps && sps->nb_st_rps)
151 READ_ONEBIT(gb, &rps_predict);
152
153 if (rps_predict) {
154 const ShortTermRPS *rps_ridx;
155 RK_S32 delta_rps, abs_delta_rps;
156 RK_U8 use_delta_flag = 0;
157 RK_U8 delta_rps_sign;
158
159 if (is_slice_header) {
160 RK_U32 delta_idx = 0;
161 READ_UE(gb, &delta_idx);
162 delta_idx = delta_idx + 1;
163 if (delta_idx > sps->nb_st_rps) {
164 mpp_err(
165 "Invalid value of delta_idx in slice header RPS: %d > %d.\n",
166 delta_idx, sps->nb_st_rps);
167 return MPP_ERR_STREAM;
168 }
169 rps_ridx = &sps->st_rps[sps->nb_st_rps - delta_idx];
170 } else
171 rps_ridx = &sps->st_rps[rps - sps->st_rps - 1];
172
173 READ_BITS(gb, 1, &delta_rps_sign);
174
175 READ_UE(gb, &abs_delta_rps);
176
177 abs_delta_rps = abs_delta_rps + 1;
178
179 delta_rps = (1 - (delta_rps_sign << 1)) * abs_delta_rps;
180 for (i = 0; i <= rps_ridx->num_delta_pocs; i++) {
181 RK_S32 used = 0;
182 READ_ONEBIT(gb, &used);
183
184 rps->used[k] = used;
185
186 if (!used)
187 READ_ONEBIT(gb, &use_delta_flag);
188
189 if (used || use_delta_flag) {
190 if (i < rps_ridx->num_delta_pocs)
191 delta_poc = delta_rps + rps_ridx->delta_poc[i];
192 else
193 delta_poc = delta_rps;
194 rps->delta_poc[k] = delta_poc;
195 if (delta_poc < 0)
196 k0++;
197 k++;
198 }
199 }
200
201 rps->num_delta_pocs = k;
202 rps->num_negative_pics = k0;
203 // sort in increasing order (smallest first)
204 if (rps->num_delta_pocs != 0) {
205 RK_S32 used, tmp;
206 for (i = 1; i < rps->num_delta_pocs; i++) {
207 delta_poc = rps->delta_poc[i];
208 used = rps->used[i];
209 for (k = i - 1; k >= 0; k--) {
210 tmp = rps->delta_poc[k];
211 if (delta_poc < tmp) {
212 rps->delta_poc[k + 1] = tmp;
213 rps->used[k + 1] = rps->used[k];
214 rps->delta_poc[k] = delta_poc;
215 rps->used[k] = used;
216 }
217 }
218 }
219 }
220 if ((rps->num_negative_pics >> 1) != 0) {
221 RK_S32 used;
222 k = rps->num_negative_pics - 1;
223 // flip the negative values to largest first
224 for (i = 0; (RK_U32)i < rps->num_negative_pics >> 1; i++) {
225 delta_poc = rps->delta_poc[i];
226 used = rps->used[i];
227 rps->delta_poc[i] = rps->delta_poc[k];
228 rps->used[i] = rps->used[k];
229 rps->delta_poc[k] = delta_poc;
230 rps->used[k] = used;
231 k--;
232 }
233 }
234 } else {
235 RK_U32 prev, nb_positive_pics;
236
237 READ_UE(gb, &rps->num_negative_pics);
238
239 READ_UE(gb, &nb_positive_pics);
240
241 if (rps->num_negative_pics >= MAX_REFS ||
242 nb_positive_pics >= MAX_REFS) {
243 mpp_err( "Too many refs in a short term RPS.\n");
244 return MPP_ERR_STREAM;
245 }
246
247 rps->num_delta_pocs = rps->num_negative_pics + nb_positive_pics;
248 if (rps->num_delta_pocs) {
249 prev = 0;
250 for (i = 0; (RK_U32)i < rps->num_negative_pics; i++) {
251 READ_UE(gb, &delta_poc);
252 delta_poc += 1;
253 prev -= delta_poc;
254 rps->delta_poc[i] = prev;
255 READ_ONEBIT(gb, &rps->used[i]);
256 }
257 prev = 0;
258 for (i = 0; (RK_U32)i < nb_positive_pics; i++) {
259 READ_UE(gb, &delta_poc);
260 delta_poc = delta_poc + 1;
261 prev += delta_poc;
262 rps->delta_poc[rps->num_negative_pics + i] = prev;
263 READ_ONEBIT(gb, &rps->used[rps->num_negative_pics + i]);
264 }
265 }
266 }
267 s->rps_need_upate = 1;
268 return 0;
269 __BITREAD_ERR:
270 return MPP_ERR_STREAM;
271 }
272
273
decode_profile_tier_level(HEVCContext * s,PTLCommon * ptl)274 static RK_S32 decode_profile_tier_level(HEVCContext *s, PTLCommon *ptl)
275 {
276 int i;
277 HEVCLocalContext *lc = s->HEVClc;
278 BitReadCtx_t *gb = &lc->gb;
279
280 READ_BITS(gb, 2, &ptl->profile_space);
281 READ_ONEBIT(gb, &ptl->tier_flag);
282 READ_BITS(gb, 5, &ptl->profile_idc);
283
284 if (ptl->profile_idc == MPP_PROFILE_HEVC_MAIN)
285 h265d_dbg(H265D_DBG_GLOBAL, "Main profile bitstream\n");
286 else if (ptl->profile_idc == MPP_PROFILE_HEVC_MAIN_10)
287 h265d_dbg(H265D_DBG_GLOBAL, "Main 10 profile bitstream\n");
288 else if (ptl->profile_idc == MPP_PROFILE_HEVC_MAIN_STILL_PICTURE)
289 h265d_dbg(H265D_DBG_GLOBAL, "Main Still Picture profile bitstream\n");
290 else if (ptl->profile_idc == MPP_PROFILE_HEVC_FORMAT_RANGE_EXTENDIONS)
291 h265d_dbg(H265D_DBG_GLOBAL, "Main 4:4:4 profile profile bitstream\n");
292 else
293 mpp_log("Unknown HEVC profile: %d\n", ptl->profile_idc);
294
295 for (i = 0; i < 32; i++)
296 READ_ONEBIT(gb, & ptl->profile_compatibility_flag[i]);
297 READ_ONEBIT(gb, &ptl->progressive_source_flag);
298 READ_ONEBIT(gb, &ptl->interlaced_source_flag);
299 READ_ONEBIT(gb, &ptl->non_packed_constraint_flag);
300 READ_ONEBIT(gb, &ptl->frame_only_constraint_flag);
301
302 ptl->bit_depth_constraint = (ptl->profile_idc == MPP_PROFILE_HEVC_MAIN_10) ? 10 : 8;
303 ptl->chroma_format_constraint = H265_CHROMA_420;
304 ptl->intra_constraint_flag = 0;
305 ptl->lower_bitrate_constraint_flag = 1;
306
307 SKIP_BITS(gb, 16); // XXX_reserved_zero_44bits[0..15]
308 SKIP_BITS(gb, 16); // XXX_reserved_zero_44bits[16..31]
309 SKIP_BITS(gb, 12); // XXX_reserved_zero_44bits[32..43]
310 return 0;
311 __BITREAD_ERR:
312 return MPP_ERR_STREAM;
313 }
314
parse_ptl(HEVCContext * s,PTL * ptl,int max_num_sub_layers)315 static RK_S32 parse_ptl(HEVCContext *s, PTL *ptl, int max_num_sub_layers)
316 {
317 RK_S32 i;
318 HEVCLocalContext *lc = s->HEVClc;
319 BitReadCtx_t *gb = &lc->gb;
320
321 decode_profile_tier_level(s, &ptl->general_ptl);
322 READ_BITS(gb, 8, &ptl->general_ptl.level_idc);
323
324 for (i = 0; i < max_num_sub_layers - 1; i++) {
325 READ_ONEBIT(gb, &ptl->sub_layer_profile_present_flag[i]);
326 READ_ONEBIT(gb, &ptl->sub_layer_level_present_flag[i]);
327 }
328 if (max_num_sub_layers - 1 > 0)
329 for (i = max_num_sub_layers - 1; i < 8; i++)
330 SKIP_BITS(gb, 2); // reserved_zero_2bits[i]
331 for (i = 0; i < max_num_sub_layers - 1; i++) {
332 if (ptl->sub_layer_profile_present_flag[i])
333 decode_profile_tier_level(s, &ptl->sub_layer_ptl[i]);
334 if (ptl->sub_layer_level_present_flag[i])
335 READ_BITS(gb, 8, &ptl->sub_layer_ptl[i].level_idc);
336 }
337
338 return 0;
339 __BITREAD_ERR:
340 return MPP_ERR_STREAM;
341 }
342
decode_sublayer_hrd(HEVCContext * s,unsigned int nb_cpb,int subpic_params_present)343 static RK_S32 decode_sublayer_hrd(HEVCContext *s, unsigned int nb_cpb,
344 int subpic_params_present)
345 {
346 BitReadCtx_t *gb = &s->HEVClc->gb;
347 RK_U32 i, value;
348
349 for (i = 0; i < nb_cpb; i++) {
350 READ_UE(gb, &value); // bit_rate_value_minus1
351 READ_UE(gb, &value); // cpb_size_value_minus1
352
353 if (subpic_params_present) {
354 READ_UE(gb, &value); // cpb_size_du_value_minus1
355 READ_UE(gb, &value); // bit_rate_du_value_minus1
356 }
357 SKIP_BITS(gb, 1); // cbr_flag
358 }
359 return 0;
360 __BITREAD_ERR:
361 return MPP_ERR_STREAM;
362 }
363
decode_hrd(HEVCContext * s,int common_inf_present,int max_sublayers)364 static RK_S32 decode_hrd(HEVCContext *s, int common_inf_present,
365 int max_sublayers)
366 {
367 BitReadCtx_t *gb = &s->HEVClc->gb;
368 int nal_params_present = 0, vcl_params_present = 0;
369 int subpic_params_present = 0;
370 int i;
371
372 if (common_inf_present) {
373 READ_ONEBIT(gb, &nal_params_present);
374 READ_ONEBIT(gb, &vcl_params_present);
375
376 if (nal_params_present || vcl_params_present) {
377 READ_ONEBIT(gb, &subpic_params_present);
378
379 if (subpic_params_present) {
380 SKIP_BITS(gb, 8); // tick_divisor_minus2
381 SKIP_BITS(gb, 5); // du_cpb_removal_delay_increment_length_minus1
382 SKIP_BITS(gb, 1); // sub_pic_cpb_params_in_pic_timing_sei_flag
383 SKIP_BITS(gb, 5); // dpb_output_delay_du_length_minus1
384 }
385
386 SKIP_BITS(gb, 4); // bit_rate_scale
387 SKIP_BITS(gb, 4); // cpb_size_scale
388
389 if (subpic_params_present)
390 SKIP_BITS(gb, 4); // cpb_size_du_scale
391
392 SKIP_BITS(gb, 5); // initial_cpb_removal_delay_length_minus1
393 SKIP_BITS(gb, 5); // au_cpb_removal_delay_length_minus1
394 SKIP_BITS(gb, 5); // dpb_output_delay_length_minus1
395 }
396 }
397
398 for (i = 0; i < max_sublayers; i++) {
399 RK_S32 low_delay = 0;
400 RK_U32 nb_cpb = 1;
401 RK_S32 fixed_rate = 0;
402 RK_S32 value = 0;
403
404 READ_ONEBIT(gb, &fixed_rate);
405
406 if (!fixed_rate)
407 READ_ONEBIT(gb, &fixed_rate);
408
409 if (fixed_rate)
410 READ_UE(gb, &value); // elemental_duration_in_tc_minus1
411 else
412 READ_ONEBIT(gb, &low_delay);
413
414 if (!low_delay) {
415 READ_UE(gb, &nb_cpb);
416 nb_cpb = nb_cpb + 1;
417 }
418
419 if (nal_params_present)
420 decode_sublayer_hrd(s, nb_cpb, subpic_params_present);
421 if (vcl_params_present)
422 decode_sublayer_hrd(s, nb_cpb, subpic_params_present);
423 }
424 return 0;
425 __BITREAD_ERR:
426 return MPP_ERR_STREAM;
427 }
428
429
430 #ifdef VPS_EXTENSION
parse_vps_extension(HEVCContext * s,HEVCVPS * vps)431 static RK_S32 parse_vps_extension (HEVCContext *s, HEVCVPS *vps)
432 {
433 RK_S32 i, j;
434 RK_S32 value = 0;
435 BitReadCtx_t *gb = &s->HEVClc->gb;
436 #ifdef VPS_EXTN_MASK_AND_DIM_INFO
437 RK_S32 numScalabilityTypes = 0;
438 READ_ONEBIT(gb, &vps->avc_base_layer_flag);
439 READ_ONEBIT(gb, &vps->splitting_flag);
440
441 for (i = 0; i < MAX_VPS_NUM_SCALABILITY_TYPES; i++) {
442 READ_ONEBIT(gb, &vps->scalability_mask[i]);
443 numScalabilityTypes += vps->scalability_mask[i];
444 if ( i != 1 && vps->scalability_mask[i] != 0) {
445 mpp_err( "Multiview and reserved masks are not used in this version of software \n");
446 }
447 }
448
449 vps->m_numScalabilityTypes = numScalabilityTypes;
450 for (i = 0; i < numScalabilityTypes; i++) {
451 READ_BITS(gb, 3, &vps->dimension_id_len[i]);
452 vps->dimension_id_len[i] = vps->dimension_id_len[i] + 1;
453 }
454
455 if (vps->splitting_flag) {
456 int numBits = 0;
457 for (i = 0; i < numScalabilityTypes; i++) {
458 numBits += vps->dimension_id_len[i];
459 }
460 if (numBits > 6)
461 mpp_err( "numBits>6 \n");
462 }
463
464 READ_ONEBIT(gb, &vps->nuh_layer_id_present_flag);
465 vps->layer_id_in_nuh[0] = 0;
466 vps->m_layerIdInVps[0] = 0;
467
468 for (i = 1; i < vps->vps_max_layers; i++) {
469 if (vps->nuh_layer_id_present_flag ) {
470 READ_BITS(gb, 6, vps->layer_id_in_nuh[i]);
471 } else {
472 vps->layer_id_in_nuh[i] = i;
473 }
474 vps->m_layerIdInVps[vps->layer_id_in_nuh[i]] = i;
475 for (j = 0; j < numScalabilityTypes; j++) {
476 READ_BITS(gb, vps->dimension_id_len[j], &vps->dimension_id[i][j]);
477 }
478 }
479
480 #endif
481 #ifdef VPS_MOVE_DIR_DEPENDENCY_FLAG
482 #ifdef VPS_EXTN_DIRECT_REF_LAYERS
483 vps->m_numDirectRefLayers[0] = 0;
484 for ( i = 1; i <= vps->vps_max_layers - 1; i++) {
485 RK_S32 numDirectRefLayers = 0;
486 for ( j = 0; j < i; j++) {
487 READ_ONEBIT(gb, &vps->direct_dependency_flag[i][j]);
488 if (vps->direct_dependency_flag[i][j]) {
489 vps->m_refLayerId[i][numDirectRefLayers] = j;
490 numDirectRefLayers++;
491 }
492 }
493
494 vps->m_numDirectRefLayers[i] = numDirectRefLayers;
495 }
496 #endif
497 #endif
498 #ifdef VPS_EXTN_PROFILE_INFO
499 #ifdef VPS_PROFILE_OUTPUT_LAYERS
500 READ_BITS(gb, 10, value);
501 if ( value != (vps->vps_num_layer_sets - 1)) { //vps_number_layer_sets_minus1
502 mpp_err( "Erro vps_number_layer_sets_minus1 != vps->vps_num_layer_sets-1 \n");
503 }
504 READ_BITS(gb, 6, &vps->vps_num_profile_tier_level);
505 vps->vps_num_profile_tier_level = vps->vps_num_profile_tier_level + 1;
506 vps->PTLExt = mpp_malloc(PTL*, vps->vps_num_profile_tier_level); // TO DO add free
507
508 for (i = 1; i <= vps->vps_num_profile_tier_level - 1; i++)
509 #else
510 vps->PTLExt = mpp_malloc(PTL*, vps->vps_num_layer_sets); // TO DO add free
511 for (i = 1; i <= vps->vps_num_layer_sets - 1; i++)
512 #endif
513 {
514 READ_ONEBIT(gb, &vps->vps_profile_present_flag[i]);
515 if ( !vps->vps_profile_present_flag[i] ) {
516 #ifdef VPS_PROFILE_OUTPUT_LAYERS
517 READ_BITS(gb, 6, &vps->profile_ref[i])
518
519 vps->profile_ref[i] = vps->profile_ref[i] + 1;
520
521 #else
522 READ_UE(gb, &vps->profile_ref[i]);
523 #endif
524 vps->PTLExt[i] = mpp_malloc(PTL, 1); // TO DO add free
525 memcpy(vps->PTLExt[i], vps->PTLExt[vps->profile_ref[i]], sizeof(PTL));
526 }
527 vps->PTLExt[i] = mpp_malloc(PTL, 1); // TO DO add free
528 parse_ptl(s, vps->PTLExt[i], vps->vps_max_sub_layers);
529 }
530 #endif
531
532 #ifdef VPS_PROFILE_OUTPUT_LAYERS
533 READ_ONEBIT(gb, &vps->more_output_layer_sets_than_default_flag );
534 RK_S32 numOutputLayerSets = 0;
535 if (! vps->more_output_layer_sets_than_default_flag ) {
536 numOutputLayerSets = vps->vps_num_layer_sets;
537 } else {
538 READ_BITS(gb, 10, &vps->num_add_output_layer_sets);
539 numOutputLayerSets = vps->vps_num_layer_sets + vps->num_add_output_layer_sets;
540 }
541 if (numOutputLayerSets > 1) {
542 READ_ONEBIT(gb, &vps->default_one_target_output_layer_flag);
543 }
544 vps->m_numOutputLayerSets = numOutputLayerSets;
545 for (i = 1; i < numOutputLayerSets; i++) {
546 if ( i > (vps->vps_num_layer_sets - 1) ) {
547 RK_S32 numBits = 1, lsIdx;
548 while ((1 << numBits) < (vps->vps_num_layer_sets - 1)) {
549 numBits++;
550 }
551 READ_BITS(gb, numBits, &vps->output_layer_set_idx[i]);
552 vps->output_layer_set_idx[i] = vps->output_layer_set_idx[i] + 1;
553 lsIdx = vps->output_layer_set_idx[i];
554 for (j = 0; j < vps->m_numLayerInIdList[lsIdx] - 1; j++) {
555 READ_ONEBIT(gb, &vps->output_layer_flag[i][j]);
556 }
557 } else {
558 int lsIdx = i;
559 if ( vps->default_one_target_output_layer_flag ) {
560 for (j = 0; j < vps->m_numLayerInIdList[lsIdx]; j++) {
561 vps->output_layer_flag[i][j] = (j == (vps->m_numLayerInIdList[lsIdx] - 1));
562 }
563 } else {
564 for (j = 0; j < vps->m_numLayerInIdList[lsIdx]; j++) {
565 vps->output_layer_flag[i][j] = 1;
566 }
567 }
568 }
569 int numBits = 1;
570 while ((1 << numBits) < (vps->vps_num_profile_tier_level)) {
571 numBits++;
572 }
573 READ_BITS(gb, numBits, &vps->profile_level_tier_idx[i]);
574 }
575 #endif
576 #ifdef JCTVC_M0458_INTERLAYER_RPS_SIG
577 READ_ONEBIT(gb, &vps->max_one_active_ref_layer_flag);
578 #endif
579 }
580 #endif
compare_vps(HEVCVPS * openhevc_vps,HEVCVPS * vps)581 static RK_S32 compare_vps(HEVCVPS *openhevc_vps, HEVCVPS *vps)
582 {
583
584 if (openhevc_vps->vps_temporal_id_nesting_flag !=
585 vps->vps_temporal_id_nesting_flag) {
586 mpp_log("vps_temporal_id_nesting_flag diff\n");
587 return -1;
588 }
589
590 if (openhevc_vps->vps_max_layers != vps->vps_max_layers) {
591 mpp_log("vps_max_layers diff\n");
592 return -1;
593 }
594
595 if (openhevc_vps->vps_max_sub_layers != vps->vps_max_sub_layers) {
596 mpp_log("vps_max_sub_layers diff\n");
597 return -1;
598 }
599 if (openhevc_vps->vps_sub_layer_ordering_info_present_flag !=
600 vps->vps_sub_layer_ordering_info_present_flag) {
601 mpp_log("vps_sub_layer_ordering_info_present_flag diff\n");
602 return -1;
603 }
604
605 if (openhevc_vps->vps_max_layer_id != vps->vps_max_layer_id) {
606
607 mpp_log("vps_max_layer_id diff\n");
608 return -1;
609 }
610
611 if (openhevc_vps->vps_num_layer_sets != vps->vps_num_layer_sets) {
612
613 mpp_log("vps_num_layer_sets diff\n");
614 return -1;
615 }
616 if (openhevc_vps->vps_timing_info_present_flag !=
617 vps->vps_timing_info_present_flag) {
618
619 mpp_log("vps_timing_info_present_flag diff\n");
620 return -1;
621 }
622 if (openhevc_vps->vps_num_units_in_tick !=
623 vps->vps_num_units_in_tick) {
624 mpp_log("vps_num_units_in_tick diff\n");
625 return -1;
626 }
627
628 if ( openhevc_vps->vps_time_scale !=
629 vps->vps_time_scale) {
630 mpp_log("vps_time_scale diff\n");
631 return -1;
632 }
633 if (openhevc_vps->vps_poc_proportional_to_timing_flag !=
634 vps->vps_poc_proportional_to_timing_flag) {
635 mpp_log("vps_poc_proportional_to_timing_flag \n");
636 return -1;
637 }
638 if (openhevc_vps->vps_num_ticks_poc_diff_one !=
639 vps->vps_num_ticks_poc_diff_one) {
640 mpp_log("vps_poc_proportional_to_timing_flag \n");
641 return -1;
642 }
643
644 if (openhevc_vps->vps_num_hrd_parameters
645 != vps->vps_num_hrd_parameters) {
646 mpp_log("vps_num_hrd_parameters \n");
647 return -1;
648 }
649 return 0;
650 }
651
compare_sps(HEVCSPS * openhevc_sps,HEVCSPS * sps)652 static RK_S32 compare_sps(HEVCSPS *openhevc_sps, HEVCSPS *sps)
653 {
654 if (openhevc_sps->vps_id != sps->vps_id) {
655 mpp_log("vps_id diff\n");
656 return -1;
657 }
658 if (openhevc_sps->sps_id != sps->sps_id) {
659 mpp_log("sps_id diff\n");
660 return -1;
661 }
662 if (openhevc_sps->chroma_format_idc != sps->chroma_format_idc) {
663 mpp_log("chroma_format_idc diff\n");
664 return -1;
665 }
666 if (openhevc_sps->separate_colour_plane_flag
667 != sps->separate_colour_plane_flag) {
668 mpp_log("separate_colour_plane_flag diff\n");
669 return -1;
670 }
671
672 if (openhevc_sps->output_width != sps->output_width) {
673 mpp_log("output_width diff\n");
674 return -1;
675 }
676 if (openhevc_sps->output_height != sps->output_height) {
677 mpp_log("output_height diff\n");
678 return -1;
679 }
680
681 if (openhevc_sps->bit_depth != sps->bit_depth) {
682 mpp_log("bit_depth diff\n");
683 return -1;
684 }
685 if (openhevc_sps->bit_depth_chroma != sps->bit_depth_chroma) {
686 mpp_log("bit_depth_chroma diff\n");
687 return -1;
688 }
689 if (openhevc_sps->pixel_shift != sps->pixel_shift) {
690 mpp_log("pixel_shift diff\n");
691 return -1;
692 }
693 // openhevc_sps->pix_fmt;
694
695 if (openhevc_sps->log2_max_poc_lsb != sps->log2_max_poc_lsb) {
696 mpp_log("log2_max_poc_lsb diff\n");
697 return -1;
698 }
699 if (openhevc_sps->pcm_enabled_flag != sps->pcm_enabled_flag) {
700 mpp_log("pcm_enabled_flag diff\n");
701 return -1;
702 }
703
704 if (openhevc_sps->max_sub_layers != sps->max_sub_layers) {
705 mpp_log("max_sub_layers diff\n");
706 return -1;
707 }
708
709 if (openhevc_sps->scaling_list_enable_flag != sps->scaling_list_enable_flag) {
710 mpp_log("scaling_list_enable_flag diff\n");
711 return -1;
712 }
713
714 if (openhevc_sps->nb_st_rps != sps->nb_st_rps) {
715 mpp_log("nb_st_rps diff\n");
716 return -1;
717 }
718
719 if (openhevc_sps->amp_enabled_flag != sps->amp_enabled_flag) {
720 mpp_log(" amp_enabled_flag diff openhevc %d != %d\n", openhevc_sps->amp_enabled_flag, sps->amp_enabled_flag);
721 return -1;
722 }
723 if (openhevc_sps->sao_enabled != sps->sao_enabled) {
724 mpp_log("sao_enabled diff\n");
725 return -1;
726 }
727
728 if (openhevc_sps->long_term_ref_pics_present_flag
729 != sps->long_term_ref_pics_present_flag) {
730 mpp_log("long_term_ref_pics_present_flag diff\n");
731 return -1;
732 }
733 if (openhevc_sps->num_long_term_ref_pics_sps !=
734 sps->num_long_term_ref_pics_sps) {
735 mpp_log("num_long_term_ref_pics_sps diff\n");
736 return -1;
737 }
738
739 if (openhevc_sps->sps_temporal_mvp_enabled_flag !=
740 sps->sps_temporal_mvp_enabled_flag) {
741 mpp_log("sps_temporal_mvp_enabled_flag diff\n");
742 return -1;
743 }
744 if (openhevc_sps->sps_strong_intra_smoothing_enable_flag !=
745 sps->sps_strong_intra_smoothing_enable_flag) {
746 mpp_log("sps_strong_intra_smoothing_enable_flag diff\n");
747 return -1;
748 }
749
750 if (openhevc_sps->log2_min_cb_size != sps->log2_min_cb_size) {
751 mpp_log("log2_min_cb_size diff\n");
752 return -1;
753 }
754 if (openhevc_sps->log2_diff_max_min_coding_block_size !=
755 sps->log2_diff_max_min_coding_block_size) {
756 mpp_log("log2_diff_max_min_coding_block_size diff\n");
757 return -1;
758 }
759 if (openhevc_sps->log2_min_tb_size != sps->log2_min_tb_size) {
760 mpp_log("log2_min_tb_size diff\n");
761 return -1;
762 }
763 if (openhevc_sps->log2_max_trafo_size != sps->log2_max_trafo_size) {
764 mpp_log("log2_max_trafo_size diff\n");
765 return -1;
766 }
767 if (openhevc_sps->log2_ctb_size != sps->log2_ctb_size) {
768 mpp_log("log2_ctb_size diff\n");
769 return -1;
770 }
771 if (openhevc_sps->log2_min_pu_size != sps->log2_min_pu_size) {
772 mpp_log("log2_min_pu_size diff\n");
773 return -1;
774 }
775
776 if (openhevc_sps->max_transform_hierarchy_depth_inter !=
777 sps->max_transform_hierarchy_depth_inter) {
778 mpp_log("max_transform_hierarchy_depth_inter diff\n");
779 return -1;
780 }
781 if (openhevc_sps->max_transform_hierarchy_depth_intra !=
782 sps->max_transform_hierarchy_depth_intra) {
783 mpp_log("max_transform_hierarchy_depth_intra diff\n");
784 return -1;
785 }
786
787 if (openhevc_sps->width != sps->width) {
788 mpp_log("width diff\n");
789 return -1;
790 }
791
792 if (openhevc_sps->height != sps->height) {
793 mpp_log("height diff\n");
794 return -1;
795 }
796
797 if (openhevc_sps->ctb_width != sps->ctb_width) {
798 mpp_log("ctb_width diff\n");
799 return -1;
800 }
801
802 if ( openhevc_sps->ctb_height != sps->ctb_height) {
803 mpp_log("ctb_height diff\n");
804 return -1;
805 }
806
807 if (openhevc_sps->ctb_size != sps->ctb_size) {
808 mpp_log("ctb_size diff\n");
809 return -1;
810 }
811
812 if (openhevc_sps->min_cb_width != sps->min_cb_width) {
813 mpp_log("min_cb_width diff\n");
814 return -1;
815 }
816
817 if (openhevc_sps->min_cb_height != sps->min_cb_height) {
818 mpp_log("min_cb_height diff\n");
819 return -1;
820 }
821
822 if (openhevc_sps->min_tb_width != sps->min_tb_width) {
823 mpp_log("min_tb_width diff\n");
824 return -1;
825 }
826
827 if (openhevc_sps->min_tb_height != sps->min_tb_height) {
828 mpp_log("min_tb_height diff\n");
829 return -1;
830 }
831
832 if (openhevc_sps->min_pu_width != sps->min_pu_width) {
833 mpp_log("min_pu_width diff\n");
834 return -1;
835 }
836
837 if (openhevc_sps->min_pu_height != sps->min_pu_height) {
838 mpp_log("min_pu_height diff\n");
839 return -1;
840 }
841
842 if (openhevc_sps->qp_bd_offset != sps->qp_bd_offset) {
843 mpp_log("qp_bd_offset diff \n");
844 return -1;
845 }
846 return 0;
847 }
848
compare_pps(HEVCPPS * openhevc_pps,HEVCPPS * pps)849 static RK_S32 compare_pps(HEVCPPS *openhevc_pps, HEVCPPS *pps)
850 {
851
852 if (openhevc_pps->sps_id != pps->sps_id) {
853 mpp_log("sps_id diff \n");
854 return -1;
855 }
856
857 if (openhevc_pps->pps_id != pps->pps_id) {
858 mpp_log("pps_id diff \n");
859 return -1;
860 }
861
862 if (openhevc_pps->sign_data_hiding_flag != pps->sign_data_hiding_flag) {
863 mpp_log("sign_data_hiding_flag diff \n");
864 return -1;
865 }
866
867 if (openhevc_pps->cabac_init_present_flag != pps->cabac_init_present_flag) {
868 mpp_log("cabac_init_present_flag diff \n");
869 return -1;
870 }
871
872 if (openhevc_pps->num_ref_idx_l0_default_active != pps->num_ref_idx_l0_default_active) {
873 mpp_log("num_ref_idx_l0_default_active diff \n");
874 return -1;
875 }
876 if (openhevc_pps->num_ref_idx_l1_default_active != pps->num_ref_idx_l1_default_active) {
877 mpp_log("num_ref_idx_l1_default_active diff \n");
878 return -1;
879 }
880 if (openhevc_pps->pic_init_qp_minus26 != pps->pic_init_qp_minus26) {
881 mpp_log("pic_init_qp_minus26 diff \n");
882 return -1;
883 }
884
885 if (openhevc_pps->constrained_intra_pred_flag != pps->constrained_intra_pred_flag) {
886 mpp_log("constrained_intra_pred_flag diff \n");
887 return -1;
888 }
889 if (openhevc_pps->transform_skip_enabled_flag != pps->transform_skip_enabled_flag) {
890 mpp_log("transform_skip_enabled_flag diff \n");
891 return -1;
892 }
893
894 if (openhevc_pps->cu_qp_delta_enabled_flag != pps->cu_qp_delta_enabled_flag) {
895 mpp_log("cu_qp_delta_enabled_flag diff \n");
896 return -1;
897 }
898 if (openhevc_pps->diff_cu_qp_delta_depth != pps->diff_cu_qp_delta_depth) {
899 mpp_log("diff_cu_qp_delta_depth diff \n");
900 return -1;
901 }
902
903 if (openhevc_pps->cb_qp_offset != pps->cb_qp_offset) {
904 mpp_log("cb_qp_offset diff \n");
905 return -1;
906 }
907
908 if (openhevc_pps->cr_qp_offset != pps->cr_qp_offset) {
909 mpp_log("cr_qp_offset diff \n");
910 return -1;
911 }
912
913 if (openhevc_pps->pic_slice_level_chroma_qp_offsets_present_flag !=
914 pps->pic_slice_level_chroma_qp_offsets_present_flag) {
915 mpp_log("pic_slice_level_chroma_qp_offsets_present_flag diff \n");
916 return -1;
917 }
918 if (openhevc_pps->weighted_pred_flag != pps->weighted_pred_flag) {
919 mpp_log("weighted_pred_flag diff \n");
920 return -1;
921 }
922 if (openhevc_pps->weighted_bipred_flag != pps->weighted_bipred_flag) {
923 mpp_log("weighted_bipred_flag diff \n");
924 return -1;
925 }
926 if (openhevc_pps->output_flag_present_flag != pps->output_flag_present_flag) {
927 mpp_log("output_flag_present_flag diff \n");
928 return -1;
929 }
930 if (openhevc_pps->transquant_bypass_enable_flag !=
931 pps->transquant_bypass_enable_flag) {
932 mpp_log("transquant_bypass_enable_flag diff \n");
933 return -1;
934 }
935
936 if (openhevc_pps->dependent_slice_segments_enabled_flag !=
937 pps->dependent_slice_segments_enabled_flag) {
938 mpp_log("dependent_slice_segments_enabled_flag diff \n");
939 return -1;
940 }
941 if (openhevc_pps->tiles_enabled_flag != pps->tiles_enabled_flag) {
942 mpp_log("tiles_enabled_flag diff \n");
943 return -1;
944 }
945 if (openhevc_pps->entropy_coding_sync_enabled_flag !=
946 pps->entropy_coding_sync_enabled_flag) {
947 mpp_log("entropy_coding_sync_enabled_flag diff \n");
948 return -1;
949 }
950
951 if (openhevc_pps->num_tile_columns != pps->num_tile_columns) {
952 mpp_log("num_tile_columns diff \n");
953 return -1;
954 }
955 if (openhevc_pps->num_tile_rows != pps->num_tile_rows) {
956 mpp_log("num_tile_rows diff \n");
957 return -1;
958 }
959 if (openhevc_pps->uniform_spacing_flag != pps->uniform_spacing_flag) {
960 mpp_log("qp_bd_offset diff \n");
961 return -1;
962 }
963 if (openhevc_pps->loop_filter_across_tiles_enabled_flag !=
964 pps->loop_filter_across_tiles_enabled_flag) {
965 mpp_log("loop_filter_across_tiles_enabled_flag diff \n");
966 return -1;
967 }
968
969 if (openhevc_pps->seq_loop_filter_across_slices_enabled_flag !=
970 pps->seq_loop_filter_across_slices_enabled_flag) {
971 mpp_log("seq_loop_filter_across_slices_enabled_flag diff \n");
972 return -1;
973 }
974
975 if (openhevc_pps->deblocking_filter_control_present_flag !=
976 pps->deblocking_filter_control_present_flag) {
977 mpp_log("deblocking_filter_control_present_flag diff \n");
978 return -1;
979 }
980 if (openhevc_pps->deblocking_filter_override_enabled_flag !=
981 pps->deblocking_filter_override_enabled_flag) {
982 mpp_log("deblocking_filter_override_enabled_flag diff \n");
983 return -1;
984 }
985 if (openhevc_pps->disable_dbf != pps->disable_dbf) {
986 mpp_log("disable_dbf diff \n");
987 return -1;
988 }
989 if (openhevc_pps->beta_offset != pps->beta_offset) {
990 mpp_log("beta_offset diff \n");
991 return -1;
992 }
993 if (openhevc_pps->tc_offset != pps->tc_offset) {
994 mpp_log("tc_offset diff \n");
995 return -1;
996 }
997
998 if (openhevc_pps->scaling_list_data_present_flag !=
999 pps->scaling_list_data_present_flag) {
1000 mpp_log("scaling_list_data_present_flag diff \n");
1001 return -1;
1002 }
1003
1004 if (openhevc_pps->lists_modification_present_flag !=
1005 pps->lists_modification_present_flag) {
1006 mpp_log("lists_modification_present_flag diff \n");
1007 return -1;
1008 }
1009 if (openhevc_pps->log2_parallel_merge_level != pps->log2_parallel_merge_level) {
1010 mpp_log("log2_parallel_merge_level diff \n");
1011 return -1;
1012 }
1013 if (openhevc_pps->num_extra_slice_header_bits !=
1014 pps->num_extra_slice_header_bits) {
1015 mpp_log("num_extra_slice_header_bits diff \n");
1016 return -1;
1017 }
1018 #if 0
1019 if (openhevc_pps->slice_header_extension_present_flag !=
1020 pps->slice_header_extension_present_flag) {
1021 mpp_log("slice_header_extension_present_flag diff \n");
1022 return -1;
1023 }
1024
1025 if (openhevc_pps->pps_extension_flag != pps->pps_extension_flag) {
1026 mpp_log("pps_extension_flag diff \n");
1027 return -1;
1028 }
1029 if (openhevc_pps->pps_extension_data_flag != pps->pps_extension_data_flag) {
1030 mpp_log("pps_extension_data_flag diff \n");
1031 return -1;
1032 }
1033 #endif
1034 return 0;
1035
1036 }
1037
1038
1039
mpp_hevc_decode_nal_vps(HEVCContext * s)1040 int mpp_hevc_decode_nal_vps(HEVCContext *s)
1041 {
1042 RK_S32 i, j;
1043 BitReadCtx_t *gb = &s->HEVClc->gb;
1044 RK_U32 vps_id = 0;
1045 HEVCVPS *vps = NULL;
1046 RK_U8 *vps_buf = mpp_mem_pool_get_f(s->vps_pool);
1047 RK_S32 value = 0;
1048
1049 if (!vps_buf)
1050 return MPP_ERR_NOMEM;
1051 vps = (HEVCVPS*)vps_buf;
1052
1053 h265d_dbg(H265D_DBG_FUNCTION, "Decoding VPS\n");
1054
1055 READ_BITS(gb, 4, &vps_id);
1056
1057 h265d_dbg(H265D_DBG_VPS, "vps_id = 0x%x", vps_id);
1058
1059 if (vps_id >= MAX_VPS_COUNT) {
1060 mpp_err( "VPS id out of range: %d\n", vps_id);
1061 goto err;
1062 }
1063 READ_BITS(gb, 2, &value);
1064 if (value != 3) { // vps_reserved_three_2bits
1065 mpp_err( "vps_reserved_three_2bits is not three\n");
1066 goto err;
1067 }
1068
1069 READ_BITS(gb, 6, &vps->vps_max_layers);
1070 vps->vps_max_layers = vps->vps_max_layers + 1;
1071
1072 READ_BITS(gb, 3, &vps->vps_max_sub_layers);
1073 vps->vps_max_sub_layers = vps->vps_max_sub_layers + 1;
1074
1075 READ_ONEBIT(gb, & vps->vps_temporal_id_nesting_flag);
1076 READ_BITS(gb, 16, &value);
1077
1078 if (value != 0xffff) { // vps_reserved_ffff_16bits
1079 mpp_err( "vps_reserved_ffff_16bits is not 0xffff\n");
1080 goto err;
1081 }
1082
1083 if (vps->vps_max_sub_layers > MAX_SUB_LAYERS) {
1084 mpp_err( "vps_max_sub_layers out of range: %d\n",
1085 vps->vps_max_sub_layers);
1086 goto err;
1087 }
1088
1089 parse_ptl(s, &vps->ptl, vps->vps_max_sub_layers);
1090
1091 READ_ONEBIT(gb, &vps->vps_sub_layer_ordering_info_present_flag);
1092
1093 i = vps->vps_sub_layer_ordering_info_present_flag ? 0 : vps->vps_max_sub_layers - 1;
1094 for (; i < vps->vps_max_sub_layers; i++) {
1095 READ_UE(gb, &vps->vps_max_dec_pic_buffering[i]);
1096 vps->vps_max_dec_pic_buffering[i] = vps->vps_max_dec_pic_buffering[i] + 1;
1097 READ_UE(gb, &vps->vps_num_reorder_pics[i]);
1098 READ_UE(gb, &vps->vps_max_latency_increase[i]);
1099 vps->vps_max_latency_increase[i] = vps->vps_max_latency_increase[i] - 1;
1100
1101 if (vps->vps_max_dec_pic_buffering[i] > MAX_DPB_SIZE) {
1102 mpp_err( "vps_max_dec_pic_buffering_minus1 out of range: %d\n",
1103 vps->vps_max_dec_pic_buffering[i] - 1);
1104 goto err;
1105 }
1106 if (vps->vps_num_reorder_pics[i] > vps->vps_max_dec_pic_buffering[i] - 1) {
1107 mpp_err( "vps_max_num_reorder_pics out of range: %d\n",
1108 vps->vps_num_reorder_pics[i]);
1109 goto err;
1110 }
1111 }
1112
1113 READ_BITS(gb, 6, &vps->vps_max_layer_id);
1114 READ_UE(gb, &vps->vps_num_layer_sets);
1115 vps->vps_num_layer_sets += 1;
1116 for (i = 1; i < vps->vps_num_layer_sets; i++)
1117 for (j = 0; j <= vps->vps_max_layer_id; j++)
1118 SKIP_BITS(gb, 1); // layer_id_included_flag[i][j]
1119
1120 READ_ONEBIT(gb, &vps->vps_timing_info_present_flag);
1121 if (vps->vps_timing_info_present_flag) {
1122 mpp_read_longbits(gb, 32, &vps->vps_num_units_in_tick);
1123 mpp_read_longbits(gb, 32, &vps->vps_time_scale);
1124 READ_ONEBIT(gb, &vps->vps_poc_proportional_to_timing_flag);
1125 if (vps->vps_poc_proportional_to_timing_flag) {
1126 READ_UE(gb, &vps->vps_num_ticks_poc_diff_one);
1127 vps->vps_num_ticks_poc_diff_one += 1;
1128 }
1129 READ_UE(gb, &vps->vps_num_hrd_parameters);
1130 for (i = 0; i < vps->vps_num_hrd_parameters; i++) {
1131 RK_S32 common_inf_present = 1;
1132 RK_S32 hrd_layer_set_idx = 0;
1133
1134 READ_UE(gb, &hrd_layer_set_idx); // hrd_layer_set_idx
1135 if (i)
1136 READ_ONEBIT(gb, &common_inf_present);
1137 decode_hrd(s, common_inf_present, vps->vps_max_sub_layers);
1138 }
1139 }
1140
1141 // READ_ONEBIT(gb, &vps->vps_extension_flag);
1142
1143 #ifdef VPS_EXTENSION
1144 if (vps->vps_extension_flag) { // vps_extension_flag
1145 parse_vps_extension(s, vps);
1146 }
1147 #endif
1148 if (s->h265dctx->compare_info != NULL) {
1149 CurrentFameInf_t *info = (CurrentFameInf_t *)s->h265dctx->compare_info;
1150 HEVCVPS *openhevc_vps = (HEVCVPS*)&info->vps[vps_id];
1151 mpp_log("compare_vps in \n");
1152 if (compare_vps(openhevc_vps, (HEVCVPS*)vps_buf) < 0) {
1153 mpp_err("compare_vps return error \n");
1154 mpp_assert(0);
1155 return -1;
1156 }
1157 mpp_log("compare_vps ok \n");
1158 }
1159
1160 if (s->vps_list[vps_id] &&
1161 !memcmp(s->vps_list[vps_id], vps_buf, sizeof(HEVCVPS))) {
1162 mpp_mem_pool_put_f(s->vps_pool, vps_buf);
1163 } else {
1164 if (s->vps_list[vps_id] != NULL) {
1165 mpp_mem_pool_put_f(s->vps_pool, s->vps_list[vps_id]);
1166 }
1167 s->vps_list[vps_id] = vps_buf;
1168 s->ps_need_upate = 1;
1169 }
1170
1171 return 0;
1172 __BITREAD_ERR:
1173 err:
1174 mpp_mem_pool_put_f(s->vps_pool, vps_buf);
1175 return MPP_ERR_STREAM;
1176 }
1177
1178
decode_vui(HEVCContext * s,HEVCSPS * sps)1179 static RK_S32 decode_vui(HEVCContext *s, HEVCSPS *sps)
1180 {
1181 VUI *vui = &sps->vui;
1182 BitReadCtx_t *gb = &s->HEVClc->gb;
1183 RK_S32 sar_present;
1184
1185 h265d_dbg(H265D_DBG_FUNCTION, "Decoding VUI\n");
1186
1187 vui->colour_primaries = MPP_FRAME_PRI_UNSPECIFIED;
1188 vui->transfer_characteristic = MPP_FRAME_TRC_UNSPECIFIED;
1189 vui->matrix_coeffs = MPP_FRAME_SPC_UNSPECIFIED;
1190
1191 READ_ONEBIT(gb, &sar_present);
1192 if (sar_present) {
1193 RK_U8 sar_idx = 0;
1194 READ_BITS(gb, 8, &sar_idx);
1195 if (sar_idx < MPP_ARRAY_ELEMS(vui_sar))
1196 vui->sar = vui_sar[sar_idx];
1197 else if (sar_idx == 255) {
1198 READ_BITS(gb, 16, &vui->sar.num);
1199 READ_BITS(gb, 16, &vui->sar.den);
1200 } else
1201 mpp_log("Unknown SAR index: %u.\n", sar_idx);
1202 }
1203
1204 READ_ONEBIT(gb, &vui->overscan_info_present_flag);
1205 if (vui->overscan_info_present_flag)
1206 READ_ONEBIT(gb, &vui->overscan_appropriate_flag);
1207
1208 READ_ONEBIT(gb, &vui->video_signal_type_present_flag);
1209 if (vui->video_signal_type_present_flag) {
1210 READ_BITS(gb, 3, & vui->video_format);
1211 READ_ONEBIT(gb, &vui->video_full_range_flag);
1212 READ_ONEBIT(gb, &vui->colour_description_present_flag);
1213
1214 if (vui->colour_description_present_flag) {
1215 READ_BITS(gb, 8, &vui->colour_primaries);
1216 READ_BITS(gb, 8, &vui->transfer_characteristic);
1217 READ_BITS(gb, 8, &vui->matrix_coeffs);
1218
1219 // Set invalid values to "unspecified"
1220 // if (vui->colour_primaries >= RKCOL_PRI_NB)
1221 // vui->colour_primaries = RKCOL_PRI_UNSPECIFIED;
1222 // if (vui->transfer_characteristic >= RKCOL_TRC_NB)
1223 // vui->transfer_characteristic = RKCOL_TRC_UNSPECIFIED;
1224 if (vui->transfer_characteristic == MPP_FRAME_TRC_SMPTEST2084 ||
1225 vui->transfer_characteristic == MPP_FRAME_TRC_ARIB_STD_B67)
1226 s->is_hdr = 1;
1227 if (vui->matrix_coeffs >= MPP_FRAME_SPC_NB)
1228 vui->matrix_coeffs = MPP_FRAME_SPC_UNSPECIFIED;
1229 }
1230 }
1231
1232 READ_ONEBIT(gb, &vui->chroma_loc_info_present_flag );
1233 if (vui->chroma_loc_info_present_flag) {
1234 READ_UE(gb, &vui->chroma_sample_loc_type_top_field);
1235 READ_UE(gb, &vui->chroma_sample_loc_type_bottom_field);
1236 }
1237
1238 READ_ONEBIT(gb, &vui->neutra_chroma_indication_flag);
1239 READ_ONEBIT(gb, &vui->field_seq_flag);
1240 READ_ONEBIT(gb, &vui->frame_field_info_present_flag);
1241
1242 READ_ONEBIT(gb, &vui->default_display_window_flag);
1243 if (vui->default_display_window_flag) {
1244 READ_UE(gb, &vui->def_disp_win.left_offset);
1245 READ_UE(gb, &vui->def_disp_win.right_offset);
1246 READ_UE(gb, &vui->def_disp_win.top_offset);
1247 READ_UE(gb, &vui->def_disp_win.bottom_offset);
1248 if (sps) {
1249 if (sps->chroma_format_idc == H265_CHROMA_420) {
1250 vui->def_disp_win.left_offset *= 2;
1251 vui->def_disp_win.right_offset *= 2;
1252 vui->def_disp_win.top_offset *= 2;
1253 vui->def_disp_win.bottom_offset *= 2;
1254 } else if (sps->chroma_format_idc == H265_CHROMA_422) {
1255 vui->def_disp_win.left_offset *= 2;
1256 vui->def_disp_win.right_offset *= 2;
1257 }
1258 }
1259
1260 #if 0
1261 if (s->apply_defdispwin &&
1262 s->h265dctx->flags2 & CODEC_FLAG2_IGNORE_CROP) {
1263 h265d_dbg(H265D_DBG_SPS,
1264 "discarding vui default display window, "
1265 "original values are l:%u r:%u t:%u b:%u\n",
1266 vui->def_disp_win.left_offset,
1267 vui->def_disp_win.right_offset,
1268 vui->def_disp_win.top_offset,
1269 vui->def_disp_win.bottom_offset);
1270
1271 vui->def_disp_win.left_offset =
1272 vui->def_disp_win.right_offset =
1273 vui->def_disp_win.top_offset =
1274 vui->def_disp_win.bottom_offset = 0;
1275 }
1276 #endif
1277 }
1278
1279 READ_ONEBIT(gb, &vui->vui_timing_info_present_flag);
1280
1281 if (vui->vui_timing_info_present_flag) {
1282 mpp_read_longbits(gb, 32, &vui->vui_num_units_in_tick);
1283 mpp_read_longbits(gb, 32, &vui->vui_time_scale);
1284 READ_ONEBIT(gb, &vui->vui_poc_proportional_to_timing_flag);
1285 if (vui->vui_poc_proportional_to_timing_flag)
1286 READ_UE(gb, &vui->vui_num_ticks_poc_diff_one_minus1);
1287 READ_ONEBIT(gb, &vui->vui_hrd_parameters_present_flag);
1288 if (vui->vui_hrd_parameters_present_flag)
1289 decode_hrd(s, 1, sps->max_sub_layers);
1290 }
1291
1292 READ_ONEBIT(gb, &vui->bitstream_restriction_flag);
1293 if (vui->bitstream_restriction_flag) {
1294 READ_ONEBIT(gb, &vui->tiles_fixed_structure_flag);
1295 READ_ONEBIT(gb, &vui->motion_vectors_over_pic_boundaries_flag);
1296 READ_ONEBIT(gb, &vui->restricted_ref_pic_lists_flag);
1297 READ_UE(gb, &vui->min_spatial_segmentation_idc);
1298 READ_UE(gb, &vui->max_bytes_per_pic_denom);
1299 READ_UE(gb, &vui->max_bits_per_min_cu_denom);
1300 READ_UE(gb, &vui->log2_max_mv_length_horizontal);
1301 READ_UE(gb, &vui->log2_max_mv_length_vertical);
1302 }
1303 return 0;
1304 __BITREAD_ERR:
1305 return MPP_ERR_STREAM;
1306 }
1307
set_default_scaling_list_data(ScalingList * sl)1308 static void set_default_scaling_list_data(ScalingList *sl)
1309 {
1310 int matrixId;
1311
1312 for (matrixId = 0; matrixId < 6; matrixId++) {
1313 // 4x4 default is 16
1314 memset(sl->sl[0][matrixId], 16, 16);
1315 sl->sl_dc[0][matrixId] = 16; // default for 16x16
1316 sl->sl_dc[1][matrixId] = 16; // default for 32x32
1317 }
1318 memcpy(sl->sl[1][0], default_scaling_list_intra, 64);
1319 memcpy(sl->sl[1][1], default_scaling_list_intra, 64);
1320 memcpy(sl->sl[1][2], default_scaling_list_intra, 64);
1321 memcpy(sl->sl[1][3], default_scaling_list_inter, 64);
1322 memcpy(sl->sl[1][4], default_scaling_list_inter, 64);
1323 memcpy(sl->sl[1][5], default_scaling_list_inter, 64);
1324 memcpy(sl->sl[2][0], default_scaling_list_intra, 64);
1325 memcpy(sl->sl[2][1], default_scaling_list_intra, 64);
1326 memcpy(sl->sl[2][2], default_scaling_list_intra, 64);
1327 memcpy(sl->sl[2][3], default_scaling_list_inter, 64);
1328 memcpy(sl->sl[2][4], default_scaling_list_inter, 64);
1329 memcpy(sl->sl[2][5], default_scaling_list_inter, 64);
1330 memcpy(sl->sl[3][0], default_scaling_list_intra, 64);
1331 memcpy(sl->sl[3][0], default_scaling_list_intra, 64);
1332 memcpy(sl->sl[3][1], default_scaling_list_intra, 64);
1333 memcpy(sl->sl[3][2], default_scaling_list_intra, 64);
1334 memcpy(sl->sl[3][3], default_scaling_list_inter, 64);
1335 memcpy(sl->sl[3][4], default_scaling_list_inter, 64);
1336 memcpy(sl->sl[3][5], default_scaling_list_inter, 64);
1337 }
1338
scaling_list_data(HEVCContext * s,ScalingList * sl,HEVCSPS * sps)1339 static int scaling_list_data(HEVCContext *s, ScalingList *sl, HEVCSPS *sps)
1340 {
1341 BitReadCtx_t *gb = &s->HEVClc->gb;
1342 RK_U8 scaling_list_pred_mode_flag;
1343 RK_S32 scaling_list_dc_coef[2][6];
1344 RK_S32 size_id, i, pos;
1345 RK_U32 matrix_id;
1346
1347 for (size_id = 0; size_id < 4; size_id++)
1348 for (matrix_id = 0; matrix_id < 6; matrix_id += ((size_id == 3) ? 3 : 1)) {
1349 READ_ONEBIT(gb, &scaling_list_pred_mode_flag);
1350 if (!scaling_list_pred_mode_flag) {
1351 RK_U32 delta = 0;
1352 READ_UE(gb, &delta);
1353 /* Only need to handle non-zero delta. Zero means default,
1354 * which should already be in the arrays. */
1355 if (delta) {
1356 // Copy from previous array.
1357 delta *= (size_id == 3) ? 3 : 1;
1358 if (matrix_id < delta) {
1359 mpp_err(
1360 "Invalid delta in scaling list data: %d.\n", delta);
1361 return MPP_ERR_STREAM;
1362 }
1363
1364 memcpy(sl->sl[size_id][matrix_id],
1365 sl->sl[size_id][matrix_id - delta],
1366 size_id > 0 ? 64 : 16);
1367 if (size_id > 1)
1368 sl->sl_dc[size_id - 2][matrix_id] = sl->sl_dc[size_id - 2][matrix_id - delta];
1369 }
1370 } else {
1371 RK_S32 next_coef, coef_num;
1372 RK_S32 scaling_list_delta_coef;
1373
1374 next_coef = 8;
1375 coef_num = MPP_MIN(64, 1 << (4 + (size_id << 1)));
1376 if (size_id > 1) {
1377 READ_SE(gb, &scaling_list_dc_coef[size_id - 2][matrix_id]);
1378 scaling_list_dc_coef[size_id - 2][matrix_id] = scaling_list_dc_coef[size_id - 2][matrix_id] + 8;
1379 next_coef = scaling_list_dc_coef[size_id - 2][matrix_id];
1380 sl->sl_dc[size_id - 2][matrix_id] = next_coef;
1381 }
1382 for (i = 0; i < coef_num; i++) {
1383 if (size_id == 0)
1384 pos = 4 * mpp_hevc_diag_scan4x4_y[i] +
1385 mpp_hevc_diag_scan4x4_x[i];
1386 else
1387 pos = 8 * mpp_hevc_diag_scan8x8_y[i] +
1388 mpp_hevc_diag_scan8x8_x[i];
1389
1390 READ_SE(gb, &scaling_list_delta_coef);
1391 next_coef = (next_coef + scaling_list_delta_coef + 256) % 256;
1392 sl->sl[size_id][matrix_id][pos] = next_coef;
1393 }
1394 }
1395 }
1396 if (sps->chroma_format_idc == H265_CHROMA_444) {
1397 for (i = 0; i < 64; i++) {
1398 sl->sl[3][1][i] = sl->sl[2][1][i];
1399 sl->sl[3][2][i] = sl->sl[2][2][i];
1400 sl->sl[3][4][i] = sl->sl[2][4][i];
1401 sl->sl[3][5][i] = sl->sl[2][5][i];
1402 }
1403 sl->sl_dc[1][1] = sl->sl_dc[0][1];
1404 sl->sl_dc[1][2] = sl->sl_dc[0][2];
1405 sl->sl_dc[1][4] = sl->sl_dc[0][4];
1406 sl->sl_dc[1][5] = sl->sl_dc[0][5];
1407 }
1408 return 0;
1409 __BITREAD_ERR:
1410 return MPP_ERR_STREAM;
1411 }
1412
mpp_hevc_decode_nal_sps(HEVCContext * s)1413 RK_S32 mpp_hevc_decode_nal_sps(HEVCContext *s)
1414 {
1415 // const AVPixFmtDescriptor *desc;
1416 BitReadCtx_t *gb = &s->HEVClc->gb;
1417 RK_S32 ret = 0;
1418 RK_U32 sps_id = 0;
1419 RK_S32 log2_diff_max_min_transform_block_size;
1420 RK_S32 bit_depth_chroma, start, vui_en, sublayer_ordering_info;
1421 RK_S32 i;
1422 RK_S32 value = 0;
1423
1424 HEVCSPS *sps;
1425 RK_U8 *sps_buf = mpp_mem_pool_get_f(s->sps_pool);
1426
1427 if (!sps_buf)
1428 return MPP_ERR_NOMEM;
1429 sps = (HEVCSPS*)sps_buf;
1430
1431 h265d_dbg(H265D_DBG_FUNCTION, "Decoding SPS\n");
1432
1433 // Coded parameters
1434
1435 READ_BITS(gb, 4, &sps->vps_id);
1436 if (sps->vps_id >= MAX_VPS_COUNT) {
1437 mpp_err( "VPS id out of range: %d\n", sps->vps_id);
1438 ret = MPP_ERR_STREAM;
1439 goto err;
1440 }
1441
1442 if (!s->vps_list[sps->vps_id]) {
1443 mpp_err( "VPS %d does not exist\n",
1444 sps->vps_id);
1445 }
1446
1447 READ_BITS(gb, 3, &sps->max_sub_layers);
1448 sps->max_sub_layers += 1;
1449
1450 if (sps->max_sub_layers > MAX_SUB_LAYERS) {
1451 mpp_err( "sps_max_sub_layers out of range: %d\n",
1452 sps->max_sub_layers);
1453 ret = MPP_ERR_STREAM;
1454 goto err;
1455 }
1456
1457 SKIP_BITS(gb, 1); // temporal_id_nesting_flag
1458
1459 parse_ptl(s, &sps->ptl, sps->max_sub_layers);
1460
1461 READ_UE(gb, &sps_id);
1462 sps->sps_id = sps_id;
1463 if (sps_id >= MAX_SPS_COUNT) {
1464 mpp_err( "SPS id out of range: %d\n", sps_id);
1465 ret = MPP_ERR_STREAM;
1466 goto err;
1467 }
1468
1469 READ_UE(gb, &sps->chroma_format_idc);
1470
1471 if (sps->chroma_format_idc == H265_CHROMA_444)
1472 READ_ONEBIT(gb, &sps->separate_colour_plane_flag);
1473
1474 READ_UE(gb, &sps->width);
1475 READ_UE(gb, &sps->height);
1476
1477 READ_ONEBIT(gb, &value);
1478
1479 if (value) { // pic_conformance_flag
1480 READ_UE(gb, &sps->pic_conf_win.left_offset);
1481 READ_UE(gb, &sps->pic_conf_win.right_offset);
1482 READ_UE(gb, &sps->pic_conf_win.top_offset);
1483 READ_UE(gb, &sps->pic_conf_win.bottom_offset);
1484 if (sps->chroma_format_idc == H265_CHROMA_420) {
1485 sps->pic_conf_win.left_offset *= 2;
1486 sps->pic_conf_win.right_offset *= 2;
1487 sps->pic_conf_win.top_offset *= 2;
1488 sps->pic_conf_win.bottom_offset *= 2;
1489 } else if (sps->chroma_format_idc == H265_CHROMA_422) {
1490 sps->pic_conf_win.left_offset *= 2;
1491 sps->pic_conf_win.right_offset *= 2;
1492 }
1493 sps->output_window = sps->pic_conf_win;
1494 }
1495
1496 READ_UE(gb, &sps->bit_depth);
1497
1498 sps->bit_depth = sps->bit_depth + 8;
1499 READ_UE(gb, &bit_depth_chroma);
1500 bit_depth_chroma = bit_depth_chroma + 8;
1501 sps->bit_depth_chroma = bit_depth_chroma;
1502 if (bit_depth_chroma != sps->bit_depth) {
1503 mpp_err(
1504 "Luma bit depth (%d) is different from chroma bit depth (%d), "
1505 "this is unsupported.\n",
1506 sps->bit_depth, bit_depth_chroma);
1507 ret = MPP_ERR_STREAM;
1508 goto err;
1509 }
1510
1511 switch (sps->chroma_format_idc) {
1512 case H265_CHROMA_400 : {
1513 sps->pix_fmt = MPP_FMT_YUV400;
1514 } break;
1515 case H265_CHROMA_420 : {
1516 switch (sps->bit_depth) {
1517 case 8: sps->pix_fmt = MPP_FMT_YUV420SP; break;
1518 case 10: sps->pix_fmt = MPP_FMT_YUV420SP_10BIT; break;
1519 default:
1520 mpp_err("Unsupported bit depth: %d\n",
1521 sps->bit_depth);
1522 ret = MPP_ERR_PROTOL;
1523 goto err;
1524 }
1525 } break;
1526 case H265_CHROMA_422 : {
1527 switch (sps->bit_depth) {
1528 case 8: sps->pix_fmt = MPP_FMT_YUV422SP; break;
1529 case 10: sps->pix_fmt = MPP_FMT_YUV422SP_10BIT; break;
1530 default:
1531 mpp_err("Unsupported bit depth: %d\n",
1532 sps->bit_depth);
1533 ret = MPP_ERR_PROTOL;
1534 goto err;
1535 }
1536 mpp_slots_set_prop(s->slots, SLOTS_LEN_ALIGN, rkv_len_align_422);
1537 } break;
1538 case H265_CHROMA_444 : {
1539 switch (sps->bit_depth) {
1540 case 8: sps->pix_fmt = MPP_FMT_YUV444SP; break;
1541 case 10: sps->pix_fmt = MPP_FMT_YUV444SP_10BIT; break;
1542 default:
1543 mpp_err("Unsupported bit depth: %d\n",
1544 sps->bit_depth);
1545 ret = MPP_ERR_PROTOL;
1546 goto err;
1547 }
1548 mpp_slots_set_prop(s->slots, SLOTS_LEN_ALIGN, rkv_len_align_444);
1549 } break;
1550 }
1551
1552 sps->pixel_shift = sps->bit_depth > 8;
1553
1554 READ_UE(gb, &sps->log2_max_poc_lsb);
1555 sps->log2_max_poc_lsb += 4;
1556 if (sps->log2_max_poc_lsb > 16) {
1557 mpp_err( "log2_max_pic_order_cnt_lsb_minus4 out range: %d\n",
1558 sps->log2_max_poc_lsb - 4);
1559 ret = MPP_ERR_STREAM;
1560 goto err;
1561 }
1562
1563 READ_ONEBIT(gb, &sublayer_ordering_info);
1564 h265d_dbg(H265D_DBG_SPS, "read bit left %d", gb->num_remaining_bits_in_curr_byte_ + gb->bytes_left_ * 8);
1565 start = sublayer_ordering_info ? 0 : sps->max_sub_layers - 1;
1566 for (i = start; i < sps->max_sub_layers; i++) {
1567 READ_UE(gb, &sps->temporal_layer[i].max_dec_pic_buffering) ;
1568 sps->temporal_layer[i].max_dec_pic_buffering += 1;
1569 READ_UE(gb, &sps->temporal_layer[i].num_reorder_pics);
1570 READ_UE(gb, &sps->temporal_layer[i].max_latency_increase );
1571 sps->temporal_layer[i].max_latency_increase -= 1;
1572 if (sps->temporal_layer[i].max_dec_pic_buffering > MAX_DPB_SIZE) {
1573 mpp_err( "sps_max_dec_pic_buffering_minus1 out of range: %d\n",
1574 sps->temporal_layer[i].max_dec_pic_buffering - 1);
1575 ret = MPP_ERR_STREAM;
1576 goto err;
1577 }
1578 if (sps->temporal_layer[i].num_reorder_pics > sps->temporal_layer[i].max_dec_pic_buffering - 1) {
1579 mpp_err( "sps_max_num_reorder_pics out of range: %d\n",
1580 sps->temporal_layer[i].num_reorder_pics);
1581 if (sps->temporal_layer[i].num_reorder_pics > MAX_DPB_SIZE - 1) {
1582 ret = MPP_ERR_STREAM;
1583 goto err;
1584 }
1585 sps->temporal_layer[i].max_dec_pic_buffering = sps->temporal_layer[i].num_reorder_pics + 1;
1586 }
1587 }
1588
1589 if (!sublayer_ordering_info) {
1590 for (i = 0; i < start; i++) {
1591 sps->temporal_layer[i].max_dec_pic_buffering = sps->temporal_layer[start].max_dec_pic_buffering;
1592 sps->temporal_layer[i].num_reorder_pics = sps->temporal_layer[start].num_reorder_pics;
1593 sps->temporal_layer[i].max_latency_increase = sps->temporal_layer[start].max_latency_increase;
1594 }
1595 }
1596
1597 /* According to T-REC-H.265 Chapter 7.4.4:
1598 * If general_progressive_source_flag is equal to 0 and general_interlaced_source_flag is equal to 1, the
1599 * source scan type of the pictures in the CVS should be interpreted as interlaced only.
1600 * But the actual scan type is depending on encoder's behavior and out of this specification.
1601 */
1602 h265d_dbg(H265D_DBG_SPS, "sps progressive: %d, interlaced: %d\n",
1603 sps->ptl.general_ptl.progressive_source_flag,
1604 sps->ptl.general_ptl.interlaced_source_flag);
1605 if (!sps->ptl.general_ptl.progressive_source_flag &&
1606 sps->ptl.general_ptl.interlaced_source_flag) {
1607 for (i = 0; i < sps->max_sub_layers; i++) {
1608 sps->temporal_layer[i].num_reorder_pics += 2;
1609 }
1610 }
1611
1612 h265d_dbg(H265D_DBG_SPS, "2 read bit left %d", gb->num_remaining_bits_in_curr_byte_ + gb->bytes_left_ * 8);
1613 READ_UE(gb, &sps->log2_min_cb_size) ;
1614 if (sps->log2_min_cb_size > (LOG2_MAX_CU_SIZE - 3)) {
1615 mpp_err( "Invalid value for log2_min_cb_size");
1616 ret = MPP_ERR_STREAM;
1617 goto err;
1618 }
1619 sps->log2_min_cb_size += 3;
1620
1621 h265d_dbg(H265D_DBG_SPS, "sps->log2_min_cb_size %d", sps->log2_min_cb_size);
1622 READ_UE(gb, &sps->log2_diff_max_min_coding_block_size);
1623 if (sps->log2_diff_max_min_coding_block_size > (LOG2_MAX_CU_SIZE - LOG2_MIN_CU_SIZE)) {
1624 mpp_err( "Invalid value for log2_diff_max_min_coding_block_size");
1625 ret = MPP_ERR_STREAM;
1626 goto err;
1627 }
1628
1629 h265d_dbg(H265D_DBG_SPS, "sps->log2_diff_max_min_coding_block_size %d", sps->log2_diff_max_min_coding_block_size);
1630 READ_UE(gb, &sps->log2_min_tb_size);
1631 if (sps->log2_min_tb_size > (LOG2_MAX_TU_SIZE - 2)) {
1632 mpp_err( "Invalid value for log2_min_tb_size");
1633 ret = MPP_ERR_STREAM;
1634 goto err;
1635 }
1636 sps->log2_min_tb_size += 2;
1637
1638 h265d_dbg(H265D_DBG_SPS, "sps->log2_min_tb_size %d", sps->log2_min_tb_size);
1639 READ_UE(gb, &log2_diff_max_min_transform_block_size);
1640 if (log2_diff_max_min_transform_block_size > (LOG2_MAX_TU_SIZE - LOG2_MIN_TU_SIZE)) {
1641 mpp_err( "Invalid value for log2_diff_max_min_transform_block_size");
1642 ret = MPP_ERR_STREAM;
1643 goto err;
1644 }
1645
1646
1647 h265d_dbg(H265D_DBG_SPS, "sps->log2_diff_max_min_transform_block_size %d", log2_diff_max_min_transform_block_size);
1648 sps->log2_max_trafo_size = log2_diff_max_min_transform_block_size +
1649 sps->log2_min_tb_size;
1650
1651 h265d_dbg(H265D_DBG_SPS, "sps->log2_max_trafo_size %d", sps->log2_max_trafo_size);
1652
1653 if (sps->log2_min_tb_size >= sps->log2_min_cb_size) {
1654 mpp_err( "Invalid value for log2_min_tb_size");
1655 ret = MPP_ERR_STREAM;
1656 goto err;
1657 }
1658
1659 READ_UE(gb, &sps->max_transform_hierarchy_depth_inter);
1660 READ_UE(gb, &sps->max_transform_hierarchy_depth_intra);
1661
1662
1663 READ_ONEBIT(gb, &sps->scaling_list_enable_flag );
1664
1665 if (sps->scaling_list_enable_flag) {
1666 value = 0;
1667 set_default_scaling_list_data(&sps->scaling_list);
1668 READ_ONEBIT(gb, &value);
1669 if (value) {
1670 ret = scaling_list_data(s, &sps->scaling_list, sps);
1671 if (ret < 0)
1672 goto err;
1673 }
1674
1675 s->scaling_list_listen[sps_id] = 1;
1676 }
1677
1678 READ_ONEBIT(gb, &sps->amp_enabled_flag);
1679 READ_ONEBIT(gb, &sps->sao_enabled);
1680 READ_ONEBIT(gb, &sps->pcm_enabled_flag);
1681
1682 h265d_dbg(H265D_DBG_SPS, "sps->amp_enabled_flag = %d", sps->amp_enabled_flag);
1683 h265d_dbg(H265D_DBG_SPS, "sps->sao_enabled = %d", sps->sao_enabled);
1684 h265d_dbg(H265D_DBG_SPS, "sps->pcm_enabled_flag = %d", sps->pcm_enabled_flag);
1685
1686 if (sps->pcm_enabled_flag) {
1687 READ_BITS(gb, 4, &sps->pcm.bit_depth);
1688 sps->pcm.bit_depth += 1;
1689 READ_BITS(gb, 4, &sps->pcm.bit_depth_chroma);
1690 sps->pcm.bit_depth_chroma += 1;
1691 READ_UE(gb, &sps->pcm.log2_min_pcm_cb_size );
1692 sps->pcm.log2_min_pcm_cb_size += 3;
1693 READ_UE(gb, &value);
1694 sps->pcm.log2_max_pcm_cb_size = sps->pcm.log2_min_pcm_cb_size + value;
1695
1696 if (sps->pcm.bit_depth > sps->bit_depth) {
1697 mpp_err(
1698 "PCM bit depth (%d) is greater than normal bit depth (%d)\n",
1699 sps->pcm.bit_depth, sps->bit_depth);
1700 ret = MPP_ERR_STREAM;
1701 goto err;
1702 }
1703 READ_ONEBIT(gb, &sps->pcm.loop_filter_disable_flag);
1704 }
1705
1706 READ_UE(gb, &sps->nb_st_rps);
1707 if (sps->nb_st_rps > MAX_SHORT_TERM_RPS_COUNT) {
1708 mpp_err( "Too many short term RPS: %d.\n",
1709 sps->nb_st_rps);
1710 ret = MPP_ERR_STREAM;
1711 goto err;
1712 }
1713 for (i = 0; (RK_U32)i < sps->nb_st_rps; i++) {
1714 if ((ret = mpp_hevc_decode_short_term_rps(s, &sps->st_rps[i],
1715 sps, 0)) < 0)
1716 goto err;
1717 }
1718
1719 READ_ONEBIT(gb, &sps->long_term_ref_pics_present_flag);
1720 if (sps->long_term_ref_pics_present_flag) {
1721 READ_UE(gb, &sps->num_long_term_ref_pics_sps);
1722 for (i = 0; (RK_U8)i < sps->num_long_term_ref_pics_sps; i++) {
1723 READ_BITS(gb, sps->log2_max_poc_lsb, &sps->lt_ref_pic_poc_lsb_sps[i]);
1724 READ_ONEBIT(gb, &sps->used_by_curr_pic_lt_sps_flag[i]);
1725 }
1726 }
1727
1728 READ_ONEBIT(gb, &sps->sps_temporal_mvp_enabled_flag);
1729
1730 #ifdef REF_IDX_MFM
1731 if (s->nuh_layer_id > 0)
1732 READ_ONEBIT(gb, &sps->set_mfm_enabled_flag);
1733 #endif
1734 READ_ONEBIT(gb, &sps->sps_strong_intra_smoothing_enable_flag);
1735
1736 sps->vui.sar.num = 0;
1737 sps->vui.sar.den = 1;
1738 READ_ONEBIT(gb, &vui_en);
1739 if (vui_en)
1740 decode_vui(s, sps);
1741 #ifdef SCALED_REF_LAYER_OFFSETS
1742 if ( s->nuh_layer_id > 0 ) {
1743 READ_SE(gb, &value);
1744 sps->scaled_ref_layer_window.left_offset = (value << 1);
1745 READ_SE(gb, &value);
1746 sps->scaled_ref_layer_window.top_offset = (value << 1);
1747 READ_SE(gb, &value);
1748 sps->scaled_ref_layer_window.right_offset = (value << 1);
1749 READ_SE(gb, &value);
1750 sps->scaled_ref_layer_window.bottom_offset = (value << 1);
1751 }
1752 #endif
1753
1754 READ_ONEBIT(gb, &sps->sps_extension_flag);
1755 if (sps->sps_extension_flag) { // sps_extension_flag
1756 READ_ONEBIT(gb, &sps->sps_range_extension_flag);
1757 SKIP_BITS(gb, 7); //sps_extension_7bits = get_bits(gb, 7);
1758 if (sps->sps_range_extension_flag) {
1759 READ_ONEBIT(gb, &sps->transform_skip_rotation_enabled_flag);
1760 READ_ONEBIT(gb, &sps->transform_skip_context_enabled_flag);
1761 READ_ONEBIT(gb, &sps->implicit_rdpcm_enabled_flag);
1762 READ_ONEBIT(gb, &sps->explicit_rdpcm_enabled_flag);
1763
1764 READ_ONEBIT(gb, &sps->extended_precision_processing_flag);
1765 if (sps->extended_precision_processing_flag)
1766 mpp_log("extended_precision_processing_flag not yet implemented\n");
1767
1768 READ_ONEBIT(gb, &sps->intra_smoothing_disabled_flag);
1769 READ_ONEBIT(gb, &sps->high_precision_offsets_enabled_flag);
1770 if (sps->high_precision_offsets_enabled_flag)
1771 mpp_log("high_precision_offsets_enabled_flag not yet implemented\n");
1772
1773 READ_ONEBIT(gb, &sps->persistent_rice_adaptation_enabled_flag);
1774
1775 READ_ONEBIT(gb, &sps->cabac_bypass_alignment_enabled_flag);
1776 if (sps->cabac_bypass_alignment_enabled_flag)
1777 mpp_log("cabac_bypass_alignment_enabled_flag not yet implemented\n");
1778 }
1779 }
1780
1781 if (s->apply_defdispwin) {
1782 sps->output_window.left_offset += sps->vui.def_disp_win.left_offset;
1783 sps->output_window.right_offset += sps->vui.def_disp_win.right_offset;
1784 sps->output_window.top_offset += sps->vui.def_disp_win.top_offset;
1785 sps->output_window.bottom_offset += sps->vui.def_disp_win.bottom_offset;
1786 }
1787 #if 1
1788 if (sps->output_window.left_offset & (0x1F >> (sps->pixel_shift))) {
1789 sps->output_window.left_offset &= ~(0x1F >> (sps->pixel_shift));
1790 mpp_log("Reducing left output window to %d "
1791 "chroma samples to preserve alignment.\n",
1792 sps->output_window.left_offset);
1793 }
1794 #endif
1795 sps->output_width = sps->width -
1796 (sps->output_window.left_offset + sps->output_window.right_offset);
1797 sps->output_height = sps->height -
1798 (sps->output_window.top_offset + sps->output_window.bottom_offset);
1799 if (sps->output_width <= 0 || sps->output_height <= 0) {
1800 mpp_log("Invalid visible frame dimensions: %dx%d.\n",
1801 sps->output_width, sps->output_height);
1802 #if 0
1803 if (s->h265dctx->err_recognition & AV_EF_EXPLODE) {
1804 ret = MPP_ERR_STREAM;
1805 goto err;
1806 }
1807 #endif
1808 mpp_log("Displaying the whole video surface.\n");
1809 sps->pic_conf_win.left_offset = 0;
1810 sps->pic_conf_win.right_offset = 0;
1811 sps->pic_conf_win.top_offset = 0;
1812 sps->pic_conf_win.bottom_offset = 0;
1813 sps->output_width = sps->width;
1814 sps->output_height = sps->height;
1815 }
1816
1817 // NOTE: only do this for the first time of parsing sps
1818 // this is for extra data sps/pps parser
1819 if (s->h265dctx->width == 0 && s->h265dctx->height == 0) {
1820 s->h265dctx->width = sps->output_width;
1821 s->h265dctx->height = sps->output_height;
1822 }
1823
1824 // Inferred parameters
1825 sps->log2_ctb_size = sps->log2_min_cb_size + sps->log2_diff_max_min_coding_block_size;
1826
1827 h265d_dbg(H265D_DBG_SPS, "sps->log2_min_cb_size = %d sps->log2_diff_max_min_coding_block_size = %d", sps->log2_min_cb_size, sps->log2_diff_max_min_coding_block_size);
1828
1829 h265d_dbg(H265D_DBG_SPS, "plus sps->log2_ctb_size %d", sps->log2_ctb_size);
1830 sps->log2_min_pu_size = sps->log2_min_cb_size - 1;
1831
1832 sps->ctb_width = (sps->width + (1 << sps->log2_ctb_size) - 1) >> sps->log2_ctb_size;
1833 sps->ctb_height = (sps->height + (1 << sps->log2_ctb_size) - 1) >> sps->log2_ctb_size;
1834 sps->ctb_size = sps->ctb_width * sps->ctb_height;
1835
1836 sps->min_cb_width = sps->width >> sps->log2_min_cb_size;
1837 sps->min_cb_height = sps->height >> sps->log2_min_cb_size;
1838 sps->min_tb_width = sps->width >> sps->log2_min_tb_size;
1839 sps->min_tb_height = sps->height >> sps->log2_min_tb_size;
1840 sps->min_pu_width = sps->width >> sps->log2_min_pu_size;
1841 sps->min_pu_height = sps->height >> sps->log2_min_pu_size;
1842
1843 sps->qp_bd_offset = 6 * (sps->bit_depth - 8);
1844
1845 if (sps->width & ((1 << sps->log2_min_cb_size) - 1) ||
1846 sps->height & ((1 << sps->log2_min_cb_size) - 1)) {
1847 mpp_err( "Invalid coded frame dimensions.\n");
1848 goto err;
1849 }
1850
1851 if (sps->log2_ctb_size > MAX_LOG2_CTB_SIZE) {
1852 mpp_err( "CTB size out of range: 2^%d\n", sps->log2_ctb_size);
1853 goto err;
1854 }
1855 if (sps->max_transform_hierarchy_depth_inter > (RK_S32)(sps->log2_ctb_size - sps->log2_min_tb_size)) {
1856 mpp_err( "max_transform_hierarchy_depth_inter out of range: %d\n",
1857 sps->max_transform_hierarchy_depth_inter);
1858 goto err;
1859 }
1860 if (sps->max_transform_hierarchy_depth_intra > (RK_S32)(sps->log2_ctb_size - sps->log2_min_tb_size)) {
1861 mpp_err( "max_transform_hierarchy_depth_intra out of range: %d\n",
1862 sps->max_transform_hierarchy_depth_intra);
1863 goto err;
1864 }
1865 h265d_dbg(H265D_DBG_SPS, "sps->log2_ctb_size %d", sps->log2_ctb_size);
1866 if (sps->log2_max_trafo_size > (RK_U32)MPP_MIN(sps->log2_ctb_size, 5)) {
1867 mpp_err(
1868 "max transform block size out of range: %d\n",
1869 sps->log2_max_trafo_size);
1870 goto err;
1871 }
1872 if (s->h265dctx->compare_info != NULL) {
1873 CurrentFameInf_t *info = (CurrentFameInf_t *)s->h265dctx->compare_info;
1874 HEVCSPS *openhevc_sps = (HEVCSPS *)&info->sps[sps_id];
1875 mpp_log("compare sps in");
1876 if (compare_sps(openhevc_sps, (HEVCSPS *)sps_buf) < 0) {
1877 mpp_err("compare sps with openhevc error found");
1878 mpp_assert(0);
1879 return -1;
1880 }
1881 mpp_log("compare sps ok");
1882 }
1883
1884 /* check if this is a repeat of an already parsed SPS, then keep the
1885 * original one.
1886 * otherwise drop all PPSes that depend on it
1887 */
1888 if (s->sps_list[sps_id] &&
1889 !memcmp(s->sps_list[sps_id], sps_buf, sizeof(HEVCSPS))) {
1890 mpp_mem_pool_put_f(s->sps_pool, sps_buf);
1891 } else {
1892 for (i = 0; (RK_U32)i < MPP_ARRAY_ELEMS(s->pps_list); i++) {
1893 if (s->pps_list[i] && ((HEVCPPS*)s->pps_list[i])->sps_id == sps_id) {
1894 mpp_hevc_pps_free(s->pps_list[i]);
1895 s->pps_list[i] = NULL;
1896 }
1897 }
1898 if (s->sps_list[sps_id] != NULL)
1899 mpp_mem_pool_put_f(s->sps_pool, s->sps_list[sps_id]);
1900 s->sps_list[sps_id] = sps_buf;
1901 s->sps_need_upate = 1;
1902 }
1903
1904 if (s->sps_list[sps_id])
1905 s->sps_list_of_updated[sps_id] = 1;
1906
1907 return 0;
1908 __BITREAD_ERR:
1909 ret = MPP_ERR_STREAM;
1910 err:
1911 mpp_mem_pool_put_f(s->sps_pool, sps_buf);
1912 return ret;
1913 }
1914
mpp_hevc_pps_free(RK_U8 * data)1915 void mpp_hevc_pps_free(RK_U8 *data)
1916 {
1917 HEVCPPS *pps = (HEVCPPS*)data;
1918
1919 if (pps) {
1920 MPP_FREE(pps->bufs.column_width);
1921 MPP_FREE(pps->bufs.row_height);
1922 MPP_FREE(pps);
1923 }
1924 }
1925
mpp_hevc_decode_nal_pps(HEVCContext * s)1926 int mpp_hevc_decode_nal_pps(HEVCContext *s)
1927 {
1928 BitReadCtx_t *gb = &s->HEVClc->gb;
1929 HEVCSPS *sps = NULL;
1930 HEVCPPS *pps = mpp_calloc(HEVCPPS, 1);
1931 HevcPpsBufInfo *bufs = NULL;
1932 RK_S32 buf_size = 0;
1933 RK_U32 pps_id = 0;
1934 RK_S32 ret = 0;
1935 RK_S32 i;
1936
1937 h265d_dbg(H265D_DBG_FUNCTION, "Decoding PPS\n");
1938
1939 if (!pps)
1940 return MPP_ERR_NOMEM;
1941
1942 // Coded parameters
1943 READ_UE(gb, &pps_id);
1944 if (pps_id >= MAX_PPS_COUNT) {
1945 mpp_err( "PPS id out of range: %d\n", pps_id);
1946 ret = MPP_ERR_STREAM;
1947 goto err;
1948 }
1949
1950 if (s->pps_list[pps_id]) {
1951 bufs = &(((HEVCPPS *)s->pps_list[pps_id])->bufs);
1952 } else {
1953 bufs = &pps->bufs;
1954 }
1955
1956 pps->pps_id = pps_id;
1957 // Default values
1958 pps->loop_filter_across_tiles_enabled_flag = 1;
1959 pps->num_tile_columns = 1;
1960 pps->num_tile_rows = 1;
1961 pps->uniform_spacing_flag = 1;
1962 pps->disable_dbf = 0;
1963 pps->beta_offset = 0;
1964 pps->tc_offset = 0;
1965
1966 READ_UE(gb, &pps->sps_id);
1967 if (pps->sps_id >= MAX_SPS_COUNT) {
1968 mpp_err( "SPS id out of range: %d\n", pps->sps_id);
1969 ret = MPP_ERR_STREAM;
1970 goto err;
1971 }
1972 if (!s->sps_list[pps->sps_id]) {
1973 mpp_err( "SPS %u does not exist.\n", pps->sps_id);
1974 ret = MPP_ERR_STREAM;
1975 goto err;
1976 }
1977 sps = (HEVCSPS *)s->sps_list[pps->sps_id];
1978
1979 h265d_dbg(H265D_DBG_FUNCTION, "Decoding PPS 1\n");
1980 READ_ONEBIT(gb, &pps->dependent_slice_segments_enabled_flag);
1981 READ_ONEBIT(gb, &pps->output_flag_present_flag );
1982 READ_BITS(gb, 3, &pps->num_extra_slice_header_bits);
1983
1984 READ_ONEBIT(gb, &pps->sign_data_hiding_flag);
1985
1986 READ_ONEBIT(gb, &pps->cabac_init_present_flag);
1987
1988 READ_UE(gb, &pps->num_ref_idx_l0_default_active);
1989 pps->num_ref_idx_l0_default_active += 1;
1990 READ_UE(gb, &pps->num_ref_idx_l1_default_active);
1991 pps->num_ref_idx_l1_default_active += 1;
1992
1993 READ_SE(gb, &pps->pic_init_qp_minus26);
1994
1995 READ_ONEBIT(gb, & pps->constrained_intra_pred_flag);
1996 READ_ONEBIT(gb, &pps->transform_skip_enabled_flag);
1997
1998 READ_ONEBIT(gb, &pps->cu_qp_delta_enabled_flag);
1999 pps->diff_cu_qp_delta_depth = 0;
2000 if (pps->cu_qp_delta_enabled_flag)
2001 READ_UE(gb, &pps->diff_cu_qp_delta_depth);
2002
2003 READ_SE(gb, &pps->cb_qp_offset);
2004 if (pps->cb_qp_offset < -12 || pps->cb_qp_offset > 12) {
2005 mpp_err( "pps_cb_qp_offset out of range: %d\n",
2006 pps->cb_qp_offset);
2007 ret = MPP_ERR_STREAM;
2008 goto err;
2009 }
2010 READ_SE(gb, &pps->cr_qp_offset);
2011 if (pps->cr_qp_offset < -12 || pps->cr_qp_offset > 12) {
2012 mpp_err( "pps_cr_qp_offset out of range: %d\n",
2013 pps->cr_qp_offset);
2014 ret = MPP_ERR_STREAM;
2015 goto err;
2016 }
2017 READ_ONEBIT(gb, &pps->pic_slice_level_chroma_qp_offsets_present_flag);
2018
2019 READ_ONEBIT(gb, &pps->weighted_pred_flag);
2020
2021 READ_ONEBIT(gb, &pps->weighted_bipred_flag);
2022
2023 READ_ONEBIT(gb, &pps->transquant_bypass_enable_flag);
2024 READ_ONEBIT(gb, &pps->tiles_enabled_flag);
2025 READ_ONEBIT(gb, &pps->entropy_coding_sync_enabled_flag);
2026
2027 // check support solution
2028 if (s->h265dctx->hw_info) {
2029 const MppDecHwCap *hw_info = s->h265dctx->hw_info;
2030
2031 if (hw_info->cap_lmt_linebuf) {
2032 RK_S32 max_supt_width = PIXW_1080P;
2033 RK_S32 max_supt_height = pps->tiles_enabled_flag ? PIXH_1080P : PIXW_1080P;
2034
2035 if (hw_info && hw_info->cap_8k) {
2036 max_supt_width = PIXW_8Kx4K;
2037 max_supt_height = pps->tiles_enabled_flag ? PIXH_8Kx4K : PIXW_8Kx4K;
2038 } else if (hw_info && hw_info->cap_4k) {
2039 max_supt_width = PIXW_4Kx2K;
2040 max_supt_height = pps->tiles_enabled_flag ? PIXH_4Kx2K : PIXW_4Kx2K;
2041 }
2042
2043 if (sps->width > max_supt_width || (sps->height > max_supt_height && pps->tiles_enabled_flag)
2044 || sps->width * sps->height > max_supt_width * max_supt_width) {
2045 mpp_err("cannot support %dx%d, max solution %dx%d\n",
2046 sps->width, sps->height, max_supt_width, max_supt_height);
2047 goto err;
2048 }
2049 } else {
2050 if (sps->width * sps->height > PIXW_8Kx4K * PIXW_8Kx4K * hw_info->cap_core_num) {
2051 mpp_err("cannot support %dx%d, max solution %dx%d\n",
2052 sps->width, sps->height, PIXW_8Kx4K, PIXW_8Kx4K);
2053 goto err;
2054 }
2055 }
2056 }
2057
2058 if (pps->tiles_enabled_flag) {
2059 READ_UE(gb, &pps->num_tile_columns);
2060 pps->num_tile_columns += 1;
2061 READ_UE(gb, &pps->num_tile_rows);
2062 pps->num_tile_rows += 1;
2063 if (pps->num_tile_columns == 0 ||
2064 pps->num_tile_columns >= sps->width) {
2065 mpp_err( "num_tile_columns_minus1 out of range: %d\n",
2066 pps->num_tile_columns - 1);
2067 ret = MPP_ERR_STREAM;
2068 goto err;
2069 }
2070 if (pps->num_tile_rows == 0 ||
2071 pps->num_tile_rows >= sps->height) {
2072 mpp_err( "num_tile_rows_minus1 out of range: %d\n",
2073 pps->num_tile_rows - 1);
2074 ret = MPP_ERR_STREAM;
2075 goto err;
2076 }
2077
2078 buf_size = pps->num_tile_columns * sizeof(RK_U32);
2079 if (bufs->column_width_size < buf_size) {
2080 bufs->column_width = mpp_malloc_size(RK_U32, buf_size);
2081 bufs->column_width_size = buf_size;
2082 }
2083
2084 buf_size = pps->num_tile_rows * sizeof(RK_U32);
2085 if (bufs->row_height_size < buf_size) {
2086 bufs->row_height = mpp_malloc_size(RK_U32, buf_size);
2087 bufs->row_height_size = buf_size;
2088 }
2089
2090 if (!bufs->column_width || !bufs->row_height) {
2091 ret = MPP_ERR_NOMEM;
2092 goto err;
2093 }
2094
2095 READ_ONEBIT(gb, &pps->uniform_spacing_flag );
2096 if (!pps->uniform_spacing_flag) {
2097 RK_S32 sum = 0;
2098 for (i = 0; i < pps->num_tile_columns - 1; i++) {
2099 READ_UE(gb, &bufs->column_width[i]);
2100 bufs->column_width[i] += 1;
2101 sum += bufs->column_width[i];
2102 }
2103 if (sum >= sps->ctb_width) {
2104 mpp_err( "Invalid tile widths.\n");
2105 ret = MPP_ERR_STREAM;
2106 goto err;
2107 }
2108 bufs->column_width[pps->num_tile_columns - 1] = sps->ctb_width - sum;
2109
2110 sum = 0;
2111 for (i = 0; i < pps->num_tile_rows - 1; i++) {
2112 READ_UE(gb, &bufs->row_height[i]);
2113 bufs->row_height[i] += 1;
2114 sum += bufs->row_height[i];
2115 }
2116 if (sum >= sps->ctb_height) {
2117 mpp_err( "Invalid tile heights.\n");
2118 ret = MPP_ERR_STREAM;
2119 goto err;
2120 }
2121 bufs->row_height[pps->num_tile_rows - 1] = sps->ctb_height - sum;
2122 }
2123 READ_ONEBIT(gb, &pps->loop_filter_across_tiles_enabled_flag);
2124 }
2125
2126 READ_ONEBIT(gb, &pps->seq_loop_filter_across_slices_enabled_flag);
2127 READ_ONEBIT(gb, &pps->deblocking_filter_control_present_flag);
2128 if (pps->deblocking_filter_control_present_flag) {
2129 READ_ONEBIT(gb, &pps->deblocking_filter_override_enabled_flag);
2130 READ_ONEBIT(gb, & pps->disable_dbf);
2131 if (!pps->disable_dbf) {
2132 READ_SE(gb, &pps->beta_offset);
2133 pps->beta_offset = pps->beta_offset * 2;
2134 READ_SE(gb, &pps->tc_offset);
2135 pps->tc_offset = pps->tc_offset * 2;
2136 if (pps->beta_offset / 2 < -6 || pps->beta_offset / 2 > 6) {
2137 mpp_err( "pps_beta_offset_div2 out of range: %d\n",
2138 pps->beta_offset / 2);
2139 ret = MPP_ERR_STREAM;
2140 goto err;
2141 }
2142 if (pps->tc_offset / 2 < -6 || pps->tc_offset / 2 > 6) {
2143 mpp_err( "pps_tc_offset_div2 out of range: %d\n",
2144 pps->tc_offset / 2);
2145 ret = MPP_ERR_STREAM;
2146 goto err;
2147 }
2148 }
2149 }
2150
2151 READ_ONEBIT(gb, &pps->scaling_list_data_present_flag);
2152 if (pps->scaling_list_data_present_flag) {
2153 set_default_scaling_list_data(&pps->scaling_list);
2154 ret = scaling_list_data(s, &pps->scaling_list, sps);
2155
2156 if (ret < 0)
2157 goto err;
2158 s->scaling_list_listen[pps_id + 16] = 1;
2159 }
2160
2161 h265d_dbg(H265D_DBG_PPS, "num bit left %d", gb->num_remaining_bits_in_curr_byte_);
2162 READ_ONEBIT(gb, & pps->lists_modification_present_flag);
2163
2164
2165 h265d_dbg(H265D_DBG_PPS, "num bit left %d", gb->num_remaining_bits_in_curr_byte_);
2166 READ_UE(gb, &pps->log2_parallel_merge_level);
2167
2168 h265d_dbg(H265D_DBG_PPS, "num bit left %d", gb->num_remaining_bits_in_curr_byte_);
2169 pps->log2_parallel_merge_level += 2;
2170 if (pps->log2_parallel_merge_level > sps->log2_ctb_size) {
2171 mpp_err( "log2_parallel_merge_level_minus2 out of range: %d\n",
2172 pps->log2_parallel_merge_level - 2);
2173 ret = MPP_ERR_STREAM;
2174 goto err;
2175 }
2176 READ_ONEBIT(gb, &pps->slice_header_extension_present_flag);
2177 READ_ONEBIT(gb, &pps->pps_extension_flag);
2178 h265d_dbg(H265D_DBG_PPS, "pps_extension_flag %d", pps->pps_extension_flag);
2179 if (pps->pps_extension_flag) {
2180 READ_ONEBIT(gb, &pps->pps_range_extensions_flag);
2181 SKIP_BITS(gb, 7); // pps_extension_7bits
2182 }
2183
2184 if (s->h265dctx->compare_info != NULL) {
2185 CurrentFameInf_t *info = (CurrentFameInf_t *)s->h265dctx->compare_info;
2186 HEVCPPS *openhevc_pps = (HEVCPPS*)&info->pps[pps_id];
2187 mpp_log("compare pps in");
2188 if (compare_pps(openhevc_pps, (HEVCPPS*)pps) < 0) {
2189 mpp_err("compare pps with openhevc error found");
2190 mpp_assert(0);
2191 return -1;
2192 }
2193 mpp_log("compare pps ok");
2194 }
2195
2196 // Inferred parameters
2197 if (pps->uniform_spacing_flag) {
2198 buf_size = pps->num_tile_columns * sizeof(RK_U32);
2199 if (bufs->column_width_size < buf_size) {
2200 bufs->column_width = mpp_malloc_size(RK_U32, buf_size);
2201 bufs->column_width_size = buf_size;
2202 }
2203
2204 buf_size = pps->num_tile_rows * sizeof(RK_U32);
2205 if (bufs->row_height_size < buf_size) {
2206 bufs->row_height = mpp_malloc_size(RK_U32, buf_size);
2207 bufs->row_height_size = buf_size;
2208 }
2209 if (!bufs->column_width || !bufs->row_height) {
2210 ret = MPP_ERR_NOMEM;
2211 goto err;
2212 }
2213
2214 for (i = 0; i < pps->num_tile_columns; i++) {
2215 bufs->column_width[i] = ((i + 1) * sps->ctb_width) / pps->num_tile_columns -
2216 (i * sps->ctb_width) / pps->num_tile_columns;
2217 }
2218
2219 for (i = 0; i < pps->num_tile_rows; i++) {
2220 bufs->row_height[i] = ((i + 1) * sps->ctb_height) / pps->num_tile_rows -
2221 (i * sps->ctb_height) / pps->num_tile_rows;
2222 }
2223 }
2224
2225 if (s->pps_list[pps_id]) {
2226 memcpy(s->pps_list[pps_id], pps, sizeof(*pps) - sizeof(pps->bufs));
2227 mpp_hevc_pps_free((RK_U8 *)pps);
2228 } else {
2229 s->pps_list[pps_id] = (RK_U8 *)pps;
2230 }
2231 s->ps_need_upate = 1;
2232
2233 if (s->pps_list[pps_id])
2234 s->pps_list_of_updated[pps_id] = 1;
2235
2236 return 0;
2237 __BITREAD_ERR:
2238 ret = MPP_ERR_STREAM;
2239 err:
2240 if (pps)
2241 mpp_hevc_pps_free((RK_U8 *)pps);
2242
2243 return ret;
2244 }
2245