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