1 /******************************************************************************
2 *
3 * Copyright (C) 2012 Ittiam Systems Pvt Ltd, Bangalore
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 *******************************************************************************
20 * @file
21 * ihevcd_parse_headers.c
22 *
23 * @brief
24 * Contains functions for parsing headers
25 *
26 * @author
27 * Harish
28 *
29 * @par List of Functions:
30 *
31 * @remarks
32 * None
33 *
34 *******************************************************************************
35 */
36
37 /*****************************************************************************/
38 /* File Includes */
39 /*****************************************************************************/
40 #include <stdio.h>
41 #include <stddef.h>
42 #include <stdlib.h>
43 #include <string.h>
44 #include <assert.h>
45
46 #include "ihevc_typedefs.h"
47 #include "iv.h"
48 #include "ivd.h"
49 #include "ihevcd_cxa.h"
50
51 #include "ihevc_defs.h"
52 #include "ihevc_debug.h"
53 #include "ihevc_defs.h"
54 #include "ihevc_structs.h"
55 #include "ihevc_buf_mgr.h"
56 #include "ihevc_dpb_mgr.h"
57 #include "ihevc_macros.h"
58 #include "ihevc_platform_macros.h"
59 #include "ihevc_cabac_tables.h"
60 #include "ihevc_common_tables.h"
61 #include "ihevc_quant_tables.h"
62
63 #include "ihevcd_trace.h"
64 #include "ihevcd_defs.h"
65 #include "ihevcd_function_selector.h"
66 #include "ihevcd_structs.h"
67 #include "ihevcd_error.h"
68 #include "ihevcd_debug.h"
69 #include "ihevcd_nal.h"
70 #include "ihevcd_bitstream.h"
71 #include "ihevcd_parse_headers.h"
72 #include "ihevcd_parse_slice_header.h"
73 #include "ihevcd_ref_list.h"
74
75 mv_buf_t* ihevcd_mv_mgr_get_poc(buf_mgr_t *ps_mv_buf_mgr, UWORD32 abs_poc);
76
77 /**
78 *******************************************************************************
79 *
80 * @brief
81 * Parses VPS operation point
82 *
83 * @par Description
84 * Parses VPS operation point as per section 7.3.5
85 *
86 * @param[out] ps_vps
87 * Pointer to VPS structure
88 *
89 * @param[in] ps_bitstrm
90 * Pointer to bitstream structure
91 *
92 * @param[in] ops_idx
93 * Operating point index
94 *
95 * @returns Error code from IHEVCD_ERROR_T
96 *
97 * @remarks
98 *
99 *******************************************************************************
100 */
ihevcd_operation_point_set(vps_t * ps_vps,bitstrm_t * ps_bitstrm,WORD32 ops_idx)101 IHEVCD_ERROR_T ihevcd_operation_point_set(vps_t *ps_vps, bitstrm_t *ps_bitstrm, WORD32 ops_idx)
102 {
103 WORD32 i;
104 WORD32 value;
105
106 IHEVCD_ERROR_T ret = (IHEVCD_ERROR_T)IHEVCD_SUCCESS;
107 UNUSED(ops_idx);
108 for(i = 0; i <= ps_vps->i1_vps_max_nuh_reserved_zero_layer_id; i++)
109 {
110 BITS_PARSE("list_entry_l0[ i ]", value, ps_bitstrm, 1);
111 //ps_vps->ai1_layer_id_included_flag[ops_idx][i] = value;
112
113 }
114 UNUSED(value);
115
116 return ret;
117 }
118
119 /**
120 *******************************************************************************
121 *
122 * @brief
123 * Parses pic_lismod_t (picture list mod syntax) Section:7.3.8.3 Reference
124 * picture list mod syntax
125 *
126 * @par Description:
127 * Parse pict list mod synt and update pic_lismod_t struct
128 *
129 * @param[in] ps_codec
130 * Pointer to codec context
131 *
132 * @returns Error code from IHEVCD_ERROR_T
133 *
134 * @remarks
135 *
136 *
137 *******************************************************************************
138 */
139
ihevcd_ref_pic_list_modification(bitstrm_t * ps_bitstrm,slice_header_t * ps_slice_hdr,WORD32 num_poc_total_curr)140 WORD32 ihevcd_ref_pic_list_modification(bitstrm_t *ps_bitstrm,
141 slice_header_t *ps_slice_hdr,
142 WORD32 num_poc_total_curr)
143 {
144 WORD32 ret = IHEVCD_SUCCESS;
145 WORD32 value;
146 WORD32 i;
147 rplm_t *ps_rplm;
148 WORD32 num_bits_list_entry;
149
150 ps_rplm = &(ps_slice_hdr->s_rplm);
151
152 /* Calculate Ceil(Log2(num_poc_total_curr)) */
153 {
154 num_bits_list_entry = 32 - CLZ(num_poc_total_curr);
155 /* Check if num_poc_total_curr is power of 2 */
156 if(0 == (num_poc_total_curr & (num_poc_total_curr - 1)))
157 {
158 num_bits_list_entry--;
159 }
160 }
161
162 if(ps_slice_hdr->i1_slice_type == PSLICE || ps_slice_hdr->i1_slice_type == BSLICE)
163 {
164 BITS_PARSE("ref_pic_list_modification_flag_l0", value, ps_bitstrm, 1);
165 ps_rplm->i1_ref_pic_list_modification_flag_l0 = value;
166
167 if(ps_rplm->i1_ref_pic_list_modification_flag_l0)
168 for(i = 0; i < ps_slice_hdr->i1_num_ref_idx_l0_active; i++)
169 {
170 BITS_PARSE("list_entry_l0", value, ps_bitstrm, num_bits_list_entry);
171 ps_rplm->i1_list_entry_l0[i] = value;
172
173 ps_rplm->i1_list_entry_l0[i] = CLIP3(ps_rplm->i1_list_entry_l0[i], 0, num_poc_total_curr - 1);
174 }
175 }
176
177 if(ps_slice_hdr->i1_slice_type == BSLICE)
178 {
179 BITS_PARSE("ref_pic_list_modification_flag_l1", value, ps_bitstrm, 1);
180 ps_rplm->i1_ref_pic_list_modification_flag_l1 = value;
181
182 if(ps_rplm->i1_ref_pic_list_modification_flag_l1)
183 for(i = 0; i < ps_slice_hdr->i1_num_ref_idx_l1_active; i++)
184 {
185 BITS_PARSE("list_entry_l1", value, ps_bitstrm, num_bits_list_entry);
186 ps_rplm->i1_list_entry_l1[i] = value;
187
188 ps_rplm->i1_list_entry_l1[i] = CLIP3(ps_rplm->i1_list_entry_l1[i], 0, num_poc_total_curr - 1);
189 }
190
191 }
192
193 return ret;
194 }
195
196 /**
197 *******************************************************************************
198 *
199 * @brief
200 * Parse Slice Header
201 * slice_header_syntax()
202 *
203 * @par Description:
204 * Parse Slice Header as per Section: 7.3.8
205 *
206 * @param[in] ps_codec
207 * Pointer to codec context
208 *
209 * @returns Error code from IHEVCD_ERROR_T
210 *
211 * @remarks
212 *
213 *
214 *******************************************************************************
215 */
216
ihevcd_parse_slice_header(codec_t * ps_codec,nal_header_t * ps_nal)217 IHEVCD_ERROR_T ihevcd_parse_slice_header(codec_t *ps_codec,
218 nal_header_t *ps_nal)
219 {
220 IHEVCD_ERROR_T ret = (IHEVCD_ERROR_T)IHEVCD_SUCCESS;
221 WORD32 value;
222 WORD32 i;
223 WORD32 sps_id;
224
225 pps_t *ps_pps;
226 sps_t *ps_sps;
227 slice_header_t *ps_slice_hdr;
228 WORD32 disable_deblocking_filter_flag;
229 bitstrm_t *ps_bitstrm = &ps_codec->s_parse.s_bitstrm;
230 WORD32 idr_pic_flag;
231 WORD32 pps_id;
232 WORD32 first_slice_in_pic_flag;
233 WORD32 no_output_of_prior_pics_flag = 0;
234 WORD8 i1_nal_unit_type = ps_nal->i1_nal_unit_type;
235 WORD32 num_poc_total_curr = 0;
236 WORD32 slice_address;
237
238 if(ps_codec->i4_slice_error == 1)
239 return ret;
240
241 idr_pic_flag = (NAL_IDR_W_LP == i1_nal_unit_type) ||
242 (NAL_IDR_N_LP == i1_nal_unit_type);
243
244
245 BITS_PARSE("first_slice_in_pic_flag", first_slice_in_pic_flag, ps_bitstrm, 1);
246 if((NAL_BLA_W_LP <= i1_nal_unit_type) &&
247 (NAL_RSV_RAP_VCL23 >= i1_nal_unit_type))
248 {
249 BITS_PARSE("no_output_of_prior_pics_flag", no_output_of_prior_pics_flag, ps_bitstrm, 1);
250 }
251 UEV_PARSE("pic_parameter_set_id", pps_id, ps_bitstrm);
252 pps_id = CLIP3(pps_id, 0, MAX_PPS_CNT - 2);
253
254 /* Get the current PPS structure */
255 ps_pps = ps_codec->s_parse.ps_pps_base + pps_id;
256 if(0 == ps_pps->i1_pps_valid)
257 {
258 pps_t *ps_pps_ref = ps_codec->ps_pps_base;
259 while(0 == ps_pps_ref->i1_pps_valid)
260 ps_pps_ref++;
261
262 if((ps_pps_ref - ps_codec->ps_pps_base >= MAX_PPS_CNT - 1))
263 return IHEVCD_INVALID_HEADER;
264
265 ihevcd_copy_pps(ps_codec, pps_id, ps_pps_ref->i1_pps_id);
266 }
267
268 /* Get SPS id for the current PPS */
269 sps_id = ps_pps->i1_sps_id;
270
271 /* Get the current SPS structure */
272 ps_sps = ps_codec->s_parse.ps_sps_base + sps_id;
273
274 /* When the current slice is the first in a pic,
275 * check whether the previous frame is complete
276 * If the previous frame is incomplete -
277 * treat the remaining CTBs as skip */
278 if((0 != ps_codec->u4_pic_cnt || ps_codec->i4_pic_present) &&
279 first_slice_in_pic_flag)
280 {
281 if(ps_codec->i4_pic_present)
282 {
283 slice_header_t *ps_slice_hdr_next;
284 ps_codec->i4_slice_error = 1;
285 ps_codec->s_parse.i4_cur_slice_idx--;
286 if(ps_codec->s_parse.i4_cur_slice_idx < 0)
287 ps_codec->s_parse.i4_cur_slice_idx = 0;
288
289 ps_slice_hdr_next = ps_codec->s_parse.ps_slice_hdr_base + ((ps_codec->s_parse.i4_cur_slice_idx + 1) & (MAX_SLICE_HDR_CNT - 1));
290 ps_slice_hdr_next->i2_ctb_x = 0;
291 ps_slice_hdr_next->i2_ctb_y = ps_codec->s_parse.ps_sps->i2_pic_ht_in_ctb;
292 return ret;
293 }
294 else
295 {
296 ps_codec->i4_slice_error = 0;
297 }
298 }
299
300 if(first_slice_in_pic_flag)
301 {
302 ps_codec->s_parse.i4_cur_slice_idx = 0;
303 }
304 else
305 {
306 /* If the current slice is not the first slice in the pic,
307 * but the first one to be parsed, set the current slice indx to 1
308 * Treat the first slice to be missing and copy the current slice header
309 * to the first one */
310 if(0 == ps_codec->i4_pic_present)
311 ps_codec->s_parse.i4_cur_slice_idx = 1;
312 }
313
314 ps_slice_hdr = ps_codec->s_parse.ps_slice_hdr_base + (ps_codec->s_parse.i4_cur_slice_idx & (MAX_SLICE_HDR_CNT - 1));
315
316
317 if((ps_pps->i1_dependent_slice_enabled_flag) &&
318 (!first_slice_in_pic_flag))
319 {
320 BITS_PARSE("dependent_slice_flag", value, ps_bitstrm, 1);
321
322 /* If dependendent slice, copy slice header from previous slice */
323 if(value && (ps_codec->s_parse.i4_cur_slice_idx > 0))
324 {
325 ihevcd_copy_slice_hdr(ps_codec,
326 (ps_codec->s_parse.i4_cur_slice_idx & (MAX_SLICE_HDR_CNT - 1)),
327 ((ps_codec->s_parse.i4_cur_slice_idx - 1) & (MAX_SLICE_HDR_CNT - 1)));
328 }
329 ps_slice_hdr->i1_dependent_slice_flag = value;
330 }
331 else
332 {
333 ps_slice_hdr->i1_dependent_slice_flag = 0;
334 }
335 ps_slice_hdr->i1_nal_unit_type = i1_nal_unit_type;
336 ps_slice_hdr->i1_pps_id = pps_id;
337 ps_slice_hdr->i1_first_slice_in_pic_flag = first_slice_in_pic_flag;
338
339 ps_slice_hdr->i1_no_output_of_prior_pics_flag = 1;
340 if((NAL_BLA_W_LP <= i1_nal_unit_type) &&
341 (NAL_RSV_RAP_VCL23 >= i1_nal_unit_type))
342 {
343 ps_slice_hdr->i1_no_output_of_prior_pics_flag = no_output_of_prior_pics_flag;
344 }
345 ps_slice_hdr->i1_pps_id = pps_id;
346
347 if(!ps_slice_hdr->i1_first_slice_in_pic_flag)
348 {
349 WORD32 num_bits;
350
351 /* Use CLZ to compute Ceil( Log2( PicSizeInCtbsY ) ) */
352 num_bits = 32 - CLZ(ps_sps->i4_pic_size_in_ctb - 1);
353 BITS_PARSE("slice_address", value, ps_bitstrm, num_bits);
354
355 slice_address = value;
356 /* If slice address is greater than the number of CTBs in a picture,
357 * ignore the slice */
358 if(value >= ps_sps->i4_pic_size_in_ctb)
359 return IHEVCD_IGNORE_SLICE;
360 }
361 else
362 {
363 slice_address = 0;
364 }
365
366 if(!ps_slice_hdr->i1_dependent_slice_flag)
367 {
368 ps_slice_hdr->i1_pic_output_flag = 1;
369 ps_slice_hdr->i4_pic_order_cnt_lsb = 0;
370 ps_slice_hdr->i1_num_long_term_sps = 0;
371 ps_slice_hdr->i1_num_long_term_pics = 0;
372
373 for(i = 0; i < ps_pps->i1_num_extra_slice_header_bits; i++)
374 {
375 BITS_PARSE("slice_reserved_undetermined_flag[ i ]", value, ps_bitstrm, 1);
376 //slice_reserved_undetermined_flag[ i ]
377 }
378 UEV_PARSE("slice_type", value, ps_bitstrm);
379 ps_slice_hdr->i1_slice_type = value;
380
381 /* If the picture is IRAP, slice type must be equal to ISLICE */
382 if((ps_slice_hdr->i1_nal_unit_type >= NAL_BLA_W_LP) &&
383 (ps_slice_hdr->i1_nal_unit_type <= NAL_RSV_RAP_VCL23))
384 ps_slice_hdr->i1_slice_type = ISLICE;
385
386 if((ps_slice_hdr->i1_slice_type < 0) ||
387 (ps_slice_hdr->i1_slice_type > 2))
388 return IHEVCD_IGNORE_SLICE;
389
390 if(ps_pps->i1_output_flag_present_flag)
391 {
392 BITS_PARSE("pic_output_flag", value, ps_bitstrm, 1);
393 ps_slice_hdr->i1_pic_output_flag = value;
394 }
395 ps_slice_hdr->i1_colour_plane_id = 0;
396 if(1 == ps_sps->i1_separate_colour_plane_flag)
397 {
398 BITS_PARSE("colour_plane_id", value, ps_bitstrm, 2);
399 ps_slice_hdr->i1_colour_plane_id = value;
400 }
401 ps_slice_hdr->i1_slice_temporal_mvp_enable_flag = 0;
402
403 if(!idr_pic_flag)
404 {
405
406 WORD32 st_rps_idx;
407 WORD32 num_neg_pics;
408 WORD32 num_pos_pics;
409 WORD8 *pi1_used;
410
411 BITS_PARSE("pic_order_cnt_lsb", value, ps_bitstrm, ps_sps->i1_log2_max_pic_order_cnt_lsb);
412 //value = ihevcd_extend_sign_bit(value, ps_sps->i1_log2_max_pic_order_cnt_lsb);
413 ps_slice_hdr->i4_pic_order_cnt_lsb = value;
414
415 BITS_PARSE("short_term_ref_pic_set_sps_flag", value, ps_bitstrm, 1);
416 ps_slice_hdr->i1_short_term_ref_pic_set_sps_flag = value;
417
418 if(1 == ps_slice_hdr->i1_short_term_ref_pic_set_sps_flag)
419 {
420 WORD32 numbits;
421
422 ps_slice_hdr->i1_short_term_ref_pic_set_idx = 0;
423 if(ps_sps->i1_num_short_term_ref_pic_sets > 1)
424 {
425 numbits = 32 - CLZ(ps_sps->i1_num_short_term_ref_pic_sets - 1);
426 BITS_PARSE("short_term_ref_pic_set_idx", value, ps_bitstrm, numbits);
427 ps_slice_hdr->i1_short_term_ref_pic_set_idx = value;
428 }
429
430 st_rps_idx = ps_slice_hdr->i1_short_term_ref_pic_set_idx;
431 num_neg_pics = ps_sps->as_stref_picset[st_rps_idx].i1_num_neg_pics;
432 num_pos_pics = ps_sps->as_stref_picset[st_rps_idx].i1_num_pos_pics;
433 pi1_used = ps_sps->as_stref_picset[st_rps_idx].ai1_used;
434 }
435 else
436 {
437 ihevcd_short_term_ref_pic_set(ps_bitstrm,
438 &ps_sps->as_stref_picset[0],
439 ps_sps->i1_num_short_term_ref_pic_sets,
440 ps_sps->i1_num_short_term_ref_pic_sets,
441 &ps_slice_hdr->s_stref_picset);
442
443 st_rps_idx = ps_sps->i1_num_short_term_ref_pic_sets;
444 num_neg_pics = ps_slice_hdr->s_stref_picset.i1_num_neg_pics;
445 num_pos_pics = ps_slice_hdr->s_stref_picset.i1_num_pos_pics;
446 pi1_used = ps_slice_hdr->s_stref_picset.ai1_used;
447 }
448
449 if(ps_sps->i1_long_term_ref_pics_present_flag)
450 {
451 if(ps_sps->i1_num_long_term_ref_pics_sps > 0)
452 {
453 UEV_PARSE("num_long_term_sps", value, ps_bitstrm);
454 ps_slice_hdr->i1_num_long_term_sps = value;
455
456 ps_slice_hdr->i1_num_long_term_sps = CLIP3(ps_slice_hdr->i1_num_long_term_sps,
457 0, MAX_DPB_SIZE - num_neg_pics - num_pos_pics);
458 }
459 UEV_PARSE("num_long_term_pics", value, ps_bitstrm);
460 ps_slice_hdr->i1_num_long_term_pics = value;
461 ps_slice_hdr->i1_num_long_term_pics = CLIP3(ps_slice_hdr->i1_num_long_term_pics,
462 0, MAX_DPB_SIZE - num_neg_pics - num_pos_pics -
463 ps_slice_hdr->i1_num_long_term_sps);
464
465 for(i = 0; i < (ps_slice_hdr->i1_num_long_term_sps +
466 ps_slice_hdr->i1_num_long_term_pics); i++)
467 {
468 if(i < ps_slice_hdr->i1_num_long_term_sps)
469 {
470 /* Use CLZ to compute Ceil( Log2( num_long_term_ref_pics_sps ) ) */
471 WORD32 num_bits = 32 - CLZ(ps_sps->i1_num_long_term_ref_pics_sps);
472 BITS_PARSE("lt_idx_sps[ i ]", value, ps_bitstrm, num_bits);
473 ps_slice_hdr->ai4_poc_lsb_lt[i] = ps_sps->ai1_lt_ref_pic_poc_lsb_sps[value];
474 ps_slice_hdr->ai1_used_by_curr_pic_lt_flag[i] = ps_sps->ai1_used_by_curr_pic_lt_sps_flag[value];
475
476 }
477 else
478 {
479 BITS_PARSE("poc_lsb_lt[ i ]", value, ps_bitstrm, ps_sps->i1_log2_max_pic_order_cnt_lsb);
480 ps_slice_hdr->ai4_poc_lsb_lt[i] = value;
481
482 BITS_PARSE("used_by_curr_pic_lt_flag[ i ]", value, ps_bitstrm, 1);
483 ps_slice_hdr->ai1_used_by_curr_pic_lt_flag[i] = value;
484
485 }
486 BITS_PARSE("delta_poc_msb_present_flag[ i ]", value, ps_bitstrm, 1);
487 ps_slice_hdr->ai1_delta_poc_msb_present_flag[i] = value;
488
489
490 ps_slice_hdr->ai1_delta_poc_msb_cycle_lt[i] = 0;
491 if(ps_slice_hdr->ai1_delta_poc_msb_present_flag[i])
492 {
493
494 UEV_PARSE("delata_poc_msb_cycle_lt[ i ]", value, ps_bitstrm);
495 ps_slice_hdr->ai1_delta_poc_msb_cycle_lt[i] = value;
496 }
497
498 if((i != 0) && (i != ps_slice_hdr->i1_num_long_term_sps))
499 {
500 ps_slice_hdr->ai1_delta_poc_msb_cycle_lt[i] += ps_slice_hdr->ai1_delta_poc_msb_cycle_lt[i - 1];
501 }
502
503 }
504 }
505
506 for(i = 0; i < num_neg_pics + num_pos_pics; i++)
507 {
508 if(pi1_used[i])
509 {
510 num_poc_total_curr++;
511 }
512 }
513 for(i = 0; i < ps_slice_hdr->i1_num_long_term_sps + ps_slice_hdr->i1_num_long_term_pics; i++)
514 {
515 if(ps_slice_hdr->ai1_used_by_curr_pic_lt_flag[i])
516 {
517 num_poc_total_curr++;
518 }
519 }
520
521
522 if(ps_sps->i1_sps_temporal_mvp_enable_flag)
523 {
524 BITS_PARSE("enable_temporal_mvp_flag", value, ps_bitstrm, 1);
525 ps_slice_hdr->i1_slice_temporal_mvp_enable_flag = value;
526 }
527
528 }
529 ps_slice_hdr->i1_slice_sao_luma_flag = 0;
530 ps_slice_hdr->i1_slice_sao_chroma_flag = 0;
531 if(ps_sps->i1_sample_adaptive_offset_enabled_flag)
532 {
533 BITS_PARSE("slice_sao_luma_flag", value, ps_bitstrm, 1);
534 ps_slice_hdr->i1_slice_sao_luma_flag = value;
535
536 BITS_PARSE("slice_sao_chroma_flag", value, ps_bitstrm, 1);
537 ps_slice_hdr->i1_slice_sao_chroma_flag = value;
538
539 }
540
541 ps_slice_hdr->i1_max_num_merge_cand = 1;
542 ps_slice_hdr->i1_cabac_init_flag = 0;
543
544 ps_slice_hdr->i1_num_ref_idx_l0_active = 0;
545 ps_slice_hdr->i1_num_ref_idx_l1_active = 0;
546 ps_slice_hdr->i1_slice_cb_qp_offset = 0;
547 ps_slice_hdr->i1_slice_cr_qp_offset = 0;
548 if((PSLICE == ps_slice_hdr->i1_slice_type) ||
549 (BSLICE == ps_slice_hdr->i1_slice_type))
550 {
551 BITS_PARSE("num_ref_idx_active_override_flag", value, ps_bitstrm, 1);
552 ps_slice_hdr->i1_num_ref_idx_active_override_flag = value;
553
554 if(ps_slice_hdr->i1_num_ref_idx_active_override_flag)
555 {
556 UEV_PARSE("num_ref_idx_l0_active_minus1", value, ps_bitstrm);
557 ps_slice_hdr->i1_num_ref_idx_l0_active = value + 1;
558
559 if(BSLICE == ps_slice_hdr->i1_slice_type)
560 {
561 UEV_PARSE("num_ref_idx_l1_active_minus1", value, ps_bitstrm);
562 ps_slice_hdr->i1_num_ref_idx_l1_active = value + 1;
563 }
564
565 }
566 else
567 {
568 ps_slice_hdr->i1_num_ref_idx_l0_active = ps_pps->i1_num_ref_idx_l0_default_active;
569
570 if(BSLICE == ps_slice_hdr->i1_slice_type)
571 {
572 ps_slice_hdr->i1_num_ref_idx_l1_active = ps_pps->i1_num_ref_idx_l1_default_active;
573 }
574 }
575
576 ps_slice_hdr->i1_num_ref_idx_l0_active = CLIP3(ps_slice_hdr->i1_num_ref_idx_l0_active, 0, MAX_DPB_SIZE - 1);
577 ps_slice_hdr->i1_num_ref_idx_l1_active = CLIP3(ps_slice_hdr->i1_num_ref_idx_l1_active, 0, MAX_DPB_SIZE - 1);
578
579 if(0 == num_poc_total_curr)
580 return IHEVCD_IGNORE_SLICE;
581 if((ps_pps->i1_lists_modification_present_flag) && (num_poc_total_curr > 1))
582 {
583 ihevcd_ref_pic_list_modification(ps_bitstrm,
584 ps_slice_hdr, num_poc_total_curr);
585 }
586 else
587 {
588 ps_slice_hdr->s_rplm.i1_ref_pic_list_modification_flag_l0 = 0;
589 ps_slice_hdr->s_rplm.i1_ref_pic_list_modification_flag_l1 = 0;
590 }
591
592 if(BSLICE == ps_slice_hdr->i1_slice_type)
593 {
594 BITS_PARSE("mvd_l1_zero_flag", value, ps_bitstrm, 1);
595 ps_slice_hdr->i1_mvd_l1_zero_flag = value;
596 }
597
598 ps_slice_hdr->i1_cabac_init_flag = 0;
599 if(ps_pps->i1_cabac_init_present_flag)
600 {
601 BITS_PARSE("cabac_init_flag", value, ps_bitstrm, 1);
602 ps_slice_hdr->i1_cabac_init_flag = value;
603
604 }
605 ps_slice_hdr->i1_collocated_from_l0_flag = 1;
606 ps_slice_hdr->i1_collocated_ref_idx = 0;
607 if(ps_slice_hdr->i1_slice_temporal_mvp_enable_flag)
608 {
609 if(BSLICE == ps_slice_hdr->i1_slice_type)
610 {
611 BITS_PARSE("collocated_from_l0_flag", value, ps_bitstrm, 1);
612 ps_slice_hdr->i1_collocated_from_l0_flag = value;
613 }
614
615 if((ps_slice_hdr->i1_collocated_from_l0_flag && (ps_slice_hdr->i1_num_ref_idx_l0_active > 1)) ||
616 (!ps_slice_hdr->i1_collocated_from_l0_flag && (ps_slice_hdr->i1_num_ref_idx_l1_active > 1)))
617 {
618 UEV_PARSE("collocated_ref_idx", value, ps_bitstrm);
619 ps_slice_hdr->i1_collocated_ref_idx = value;
620 }
621
622 }
623 ps_slice_hdr->i1_collocated_ref_idx = CLIP3(ps_slice_hdr->i1_collocated_ref_idx, 0, MAX_DPB_SIZE - 1);
624
625 if((ps_pps->i1_weighted_pred_flag && (PSLICE == ps_slice_hdr->i1_slice_type)) ||
626 (ps_pps->i1_weighted_bipred_flag && (BSLICE == ps_slice_hdr->i1_slice_type)))
627 {
628 ihevcd_parse_pred_wt_ofst(ps_bitstrm, ps_sps, ps_pps, ps_slice_hdr);
629 }
630 UEV_PARSE("five_minus_max_num_merge_cand", value, ps_bitstrm);
631 ps_slice_hdr->i1_max_num_merge_cand = 5 - value;
632
633 }
634 ps_slice_hdr->i1_max_num_merge_cand = CLIP3(ps_slice_hdr->i1_max_num_merge_cand, 1, 5);
635 SEV_PARSE("slice_qp_delta", value, ps_bitstrm);
636 ps_slice_hdr->i1_slice_qp_delta = value;
637
638 if(ps_pps->i1_pic_slice_level_chroma_qp_offsets_present_flag)
639 {
640 SEV_PARSE("slice_cb_qp_offset", value, ps_bitstrm);
641 ps_slice_hdr->i1_slice_cb_qp_offset = value;
642
643 SEV_PARSE("slice_cr_qp_offset", value, ps_bitstrm);
644 ps_slice_hdr->i1_slice_cr_qp_offset = value;
645
646 }
647 ps_slice_hdr->i1_deblocking_filter_override_flag = 0;
648 ps_slice_hdr->i1_slice_disable_deblocking_filter_flag = ps_pps->i1_pic_disable_deblocking_filter_flag;
649 ps_slice_hdr->i1_beta_offset_div2 = ps_pps->i1_beta_offset_div2;
650 ps_slice_hdr->i1_tc_offset_div2 = ps_pps->i1_tc_offset_div2;
651
652 disable_deblocking_filter_flag = ps_pps->i1_pic_disable_deblocking_filter_flag;
653
654 if(ps_pps->i1_deblocking_filter_control_present_flag)
655 {
656
657 if(ps_pps->i1_deblocking_filter_override_enabled_flag)
658 {
659 BITS_PARSE("deblocking_filter_override_flag", value, ps_bitstrm, 1);
660 ps_slice_hdr->i1_deblocking_filter_override_flag = value;
661 }
662
663 if(ps_slice_hdr->i1_deblocking_filter_override_flag)
664 {
665 BITS_PARSE("slice_disable_deblocking_filter_flag", value, ps_bitstrm, 1);
666 ps_slice_hdr->i1_slice_disable_deblocking_filter_flag = value;
667 disable_deblocking_filter_flag = ps_slice_hdr->i1_slice_disable_deblocking_filter_flag;
668
669 if(!ps_slice_hdr->i1_slice_disable_deblocking_filter_flag)
670 {
671 SEV_PARSE("beta_offset_div2", value, ps_bitstrm);
672 ps_slice_hdr->i1_beta_offset_div2 = value;
673
674 SEV_PARSE("tc_offset_div2", value, ps_bitstrm);
675 ps_slice_hdr->i1_tc_offset_div2 = value;
676
677 }
678 }
679 }
680
681 ps_slice_hdr->i1_slice_loop_filter_across_slices_enabled_flag = ps_pps->i1_loop_filter_across_slices_enabled_flag;
682 if(ps_pps->i1_loop_filter_across_slices_enabled_flag &&
683 (ps_slice_hdr->i1_slice_sao_luma_flag || ps_slice_hdr->i1_slice_sao_chroma_flag || !disable_deblocking_filter_flag))
684 {
685 BITS_PARSE("slice_loop_filter_across_slices_enabled_flag", value, ps_bitstrm, 1);
686 ps_slice_hdr->i1_slice_loop_filter_across_slices_enabled_flag = value;
687 }
688
689 }
690
691 /* Check sanity of slice */
692 if((!first_slice_in_pic_flag) &&
693 (ps_codec->i4_pic_present))
694 {
695 slice_header_t *ps_slice_hdr_base = ps_codec->ps_slice_hdr_base;
696
697
698 /* According to the standard, the above conditions must be satisfied - But for error resilience,
699 * only the following conditions are checked */
700 if((ps_slice_hdr_base->i1_pps_id != ps_slice_hdr->i1_pps_id) ||
701 (ps_slice_hdr_base->i4_pic_order_cnt_lsb != ps_slice_hdr->i4_pic_order_cnt_lsb))
702 {
703 return IHEVCD_IGNORE_SLICE;
704 }
705
706 }
707
708
709 if(0 == ps_codec->i4_pic_present)
710 {
711 ps_slice_hdr->i4_abs_pic_order_cnt = ihevcd_calc_poc(ps_codec, ps_nal, ps_sps->i1_log2_max_pic_order_cnt_lsb, ps_slice_hdr->i4_pic_order_cnt_lsb);
712 }
713 else
714 {
715 ps_slice_hdr->i4_abs_pic_order_cnt = ps_codec->s_parse.i4_abs_pic_order_cnt;
716 }
717
718
719 if(!first_slice_in_pic_flag)
720 {
721 /* Check if the current slice belongs to the same pic (Pic being parsed) */
722 if(ps_codec->s_parse.i4_abs_pic_order_cnt == ps_slice_hdr->i4_abs_pic_order_cnt)
723 {
724
725 /* If the Next CTB's index is less than the slice address,
726 * the previous slice is incomplete.
727 * Indicate slice error, and treat the remaining CTBs as skip */
728 if(slice_address > ps_codec->s_parse.i4_next_ctb_indx)
729 {
730 if(ps_codec->i4_pic_present)
731 {
732 ps_codec->i4_slice_error = 1;
733 ps_codec->s_parse.i4_cur_slice_idx--;
734 if(ps_codec->s_parse.i4_cur_slice_idx < 0)
735 ps_codec->s_parse.i4_cur_slice_idx = 0;
736
737 return ret;
738 }
739 else
740 {
741 return IHEVCD_IGNORE_SLICE;
742 }
743 }
744 /* If the slice address is less than the next CTB's index,
745 * extra CTBs have been decoded in the previous slice.
746 * Ignore the current slice. Treat it as incomplete */
747 else if(slice_address < ps_codec->s_parse.i4_next_ctb_indx)
748 {
749 return IHEVCD_IGNORE_SLICE;
750 }
751 else
752 {
753 ps_codec->i4_slice_error = 0;
754 }
755 }
756
757 /* The current slice does not belong to the pic that is being parsed */
758 else
759 {
760 /* The previous pic is incomplete.
761 * Treat the remaining CTBs as skip */
762 if(ps_codec->i4_pic_present)
763 {
764 slice_header_t *ps_slice_hdr_next;
765 ps_codec->i4_slice_error = 1;
766 ps_codec->s_parse.i4_cur_slice_idx--;
767 if(ps_codec->s_parse.i4_cur_slice_idx < 0)
768 ps_codec->s_parse.i4_cur_slice_idx = 0;
769
770 ps_slice_hdr_next = ps_codec->s_parse.ps_slice_hdr_base + ((ps_codec->s_parse.i4_cur_slice_idx + 1) & (MAX_SLICE_HDR_CNT - 1));
771 ps_slice_hdr_next->i2_ctb_x = 0;
772 ps_slice_hdr_next->i2_ctb_y = ps_codec->s_parse.ps_sps->i2_pic_ht_in_ctb;
773 return ret;
774 }
775
776 /* If the previous pic is complete,
777 * return if the current slice is dependant
778 * otherwise, update the parse context's POC */
779 else
780 {
781 if(ps_slice_hdr->i1_dependent_slice_flag)
782 return IHEVCD_IGNORE_SLICE;
783
784 ps_codec->s_parse.i4_abs_pic_order_cnt = ps_slice_hdr->i4_abs_pic_order_cnt;
785 }
786 }
787 }
788
789 /* If the slice is the first slice in the pic, update the parse context's POC */
790 else
791 {
792 /* If the first slice is repeated, ignore the second occurrence
793 * If any other slice is repeated, the CTB addr will be greater than the slice addr,
794 * and hence the second occurrence is ignored */
795 if(ps_codec->s_parse.i4_abs_pic_order_cnt == ps_slice_hdr->i4_abs_pic_order_cnt)
796 return IHEVCD_IGNORE_SLICE;
797
798 ps_codec->s_parse.i4_abs_pic_order_cnt = ps_slice_hdr->i4_abs_pic_order_cnt;
799 }
800
801 // printf("POC: %d\n", ps_slice_hdr->i4_abs_pic_order_cnt);
802 // AEV_TRACE("POC", ps_slice_hdr->i4_abs_pic_order_cnt, 0);
803 ps_slice_hdr->i4_num_entry_point_offsets = 0;
804 if((ps_pps->i1_tiles_enabled_flag) ||
805 (ps_pps->i1_entropy_coding_sync_enabled_flag))
806 {
807 UEV_PARSE("num_entry_point_offsets", value, ps_bitstrm);
808 ps_slice_hdr->i4_num_entry_point_offsets = value;
809
810 {
811 WORD32 max_num_entry_point_offsets;
812 if((ps_pps->i1_tiles_enabled_flag) &&
813 (ps_pps->i1_entropy_coding_sync_enabled_flag))
814 {
815 max_num_entry_point_offsets = ps_pps->i1_num_tile_columns * (ps_sps->i2_pic_ht_in_ctb - 1);
816 }
817 else if(ps_pps->i1_tiles_enabled_flag)
818 {
819 max_num_entry_point_offsets = ps_pps->i1_num_tile_columns * ps_pps->i1_num_tile_rows;
820 }
821 else
822 {
823 max_num_entry_point_offsets = (ps_sps->i2_pic_ht_in_ctb - 1);
824 }
825
826 ps_slice_hdr->i4_num_entry_point_offsets = CLIP3(ps_slice_hdr->i4_num_entry_point_offsets,
827 0, max_num_entry_point_offsets);
828 }
829
830 if(ps_slice_hdr->i4_num_entry_point_offsets > 0)
831 {
832 UEV_PARSE("offset_len_minus1", value, ps_bitstrm);
833 ps_slice_hdr->i1_offset_len = value + 1;
834
835 for(i = 0; i < ps_slice_hdr->i4_num_entry_point_offsets; i++)
836 {
837 BITS_PARSE("entry_point_offset", value, ps_bitstrm, ps_slice_hdr->i1_offset_len);
838
839 /* TODO: pu4_entry_point_offset needs to be initialized */
840 //ps_slice_hdr->pu4_entry_point_offset[i] = value;
841 }
842
843 }
844 }
845
846 if(ps_pps->i1_slice_header_extension_present_flag)
847 {
848 UEV_PARSE("slice_header_extension_length", value, ps_bitstrm);
849 ps_slice_hdr->i2_slice_header_extension_length = value;
850
851
852 for(i = 0; i < ps_slice_hdr->i2_slice_header_extension_length; i++)
853 {
854 BITS_PARSE("slice_header_extension_data_byte", value, ps_bitstrm, 8);
855 }
856
857 }
858
859 ihevcd_bits_flush_to_byte_boundary(ps_bitstrm);
860
861 {
862 dpb_mgr_t *ps_dpb_mgr = (dpb_mgr_t *)ps_codec->pv_dpb_mgr;
863 WORD32 r_idx;
864
865 if((NAL_IDR_W_LP == ps_slice_hdr->i1_nal_unit_type) ||
866 (NAL_IDR_N_LP == ps_slice_hdr->i1_nal_unit_type) ||
867 (NAL_BLA_N_LP == ps_slice_hdr->i1_nal_unit_type) ||
868 (NAL_BLA_W_DLP == ps_slice_hdr->i1_nal_unit_type) ||
869 (NAL_BLA_W_LP == ps_slice_hdr->i1_nal_unit_type) ||
870 (0 == ps_codec->u4_pic_cnt))
871 {
872 for(i = 0; i < MAX_DPB_BUFS; i++)
873 {
874 if(ps_dpb_mgr->as_dpb_info[i].ps_pic_buf)
875 {
876 pic_buf_t *ps_pic_buf = ps_dpb_mgr->as_dpb_info[i].ps_pic_buf;
877 mv_buf_t *ps_mv_buf;
878
879 /* Long term index is set to MAX_DPB_BUFS to ensure it is not added as LT */
880 ihevc_dpb_mgr_del_ref((dpb_mgr_t *)ps_codec->pv_dpb_mgr, (buf_mgr_t *)ps_codec->pv_pic_buf_mgr, ps_pic_buf->i4_abs_poc);
881 /* Find buffer id of the MV bank corresponding to the buffer being freed (Buffer with POC of u4_abs_poc) */
882 ps_mv_buf = (mv_buf_t *)ps_codec->ps_mv_buf;
883 for(i = 0; i < BUF_MGR_MAX_CNT; i++)
884 {
885 if(ps_mv_buf && ps_mv_buf->i4_abs_poc == ps_pic_buf->i4_abs_poc)
886 {
887 ihevc_buf_mgr_release((buf_mgr_t *)ps_codec->pv_mv_buf_mgr, i, BUF_MGR_REF);
888 break;
889 }
890 ps_mv_buf++;
891 }
892
893 }
894
895 }
896
897 /* Initialize the reference lists to NULL
898 * This is done to take care of the cases where the first pic is not IDR
899 * but the reference list is not created for the first pic because
900 * pic count is zero leaving the reference list uninitialised */
901 for(r_idx = 0; r_idx < MAX_DPB_SIZE; r_idx++)
902 {
903 ps_slice_hdr->as_ref_pic_list0[r_idx].pv_pic_buf = NULL;
904 ps_slice_hdr->as_ref_pic_list0[r_idx].pv_mv_buf = NULL;
905
906 ps_slice_hdr->as_ref_pic_list1[r_idx].pv_pic_buf = NULL;
907 ps_slice_hdr->as_ref_pic_list1[r_idx].pv_mv_buf = NULL;
908 }
909
910 }
911 else
912 {
913 ihevcd_ref_list(ps_codec, ps_pps, ps_sps, ps_slice_hdr);
914
915 }
916
917 }
918
919 /* Fill the remaining entries of the reference lists with the nearest POC
920 * This is done to handle cases where there is a corruption in the reference index */
921 if(ps_codec->i4_pic_present)
922 {
923 pic_buf_t *ps_pic_buf_ref;
924 mv_buf_t *ps_mv_buf_ref;
925 WORD32 r_idx;
926 dpb_mgr_t *ps_dpb_mgr = (dpb_mgr_t *)ps_codec->pv_dpb_mgr;
927 buf_mgr_t *ps_mv_buf_mgr = (buf_mgr_t *)ps_codec->pv_mv_buf_mgr;
928
929 ps_pic_buf_ref = ihevc_dpb_mgr_get_ref_by_nearest_poc(ps_dpb_mgr, ps_slice_hdr->i4_abs_pic_order_cnt);
930 if(NULL == ps_pic_buf_ref)
931 {
932 ps_pic_buf_ref = ps_codec->as_process[0].ps_cur_pic;
933 ps_mv_buf_ref = ps_codec->s_parse.ps_cur_mv_buf;
934 }
935 else
936 {
937 ps_mv_buf_ref = ihevcd_mv_mgr_get_poc(ps_mv_buf_mgr, ps_pic_buf_ref->i4_abs_poc);
938 }
939
940 for(r_idx = 0; r_idx < ps_slice_hdr->i1_num_ref_idx_l0_active; r_idx++)
941 {
942 if(NULL == ps_slice_hdr->as_ref_pic_list0[r_idx].pv_pic_buf)
943 {
944 ps_slice_hdr->as_ref_pic_list0[r_idx].pv_pic_buf = (void *)ps_pic_buf_ref;
945 ps_slice_hdr->as_ref_pic_list0[r_idx].pv_mv_buf = (void *)ps_mv_buf_ref;
946 }
947 }
948
949 for(r_idx = ps_slice_hdr->i1_num_ref_idx_l0_active; r_idx < MAX_DPB_SIZE; r_idx++)
950 {
951 ps_slice_hdr->as_ref_pic_list0[r_idx].pv_pic_buf = (void *)ps_pic_buf_ref;
952 ps_slice_hdr->as_ref_pic_list0[r_idx].pv_mv_buf = (void *)ps_mv_buf_ref;
953 }
954
955 for(r_idx = 0; r_idx < ps_slice_hdr->i1_num_ref_idx_l1_active; r_idx++)
956 {
957 if(NULL == ps_slice_hdr->as_ref_pic_list1[r_idx].pv_pic_buf)
958 {
959 ps_slice_hdr->as_ref_pic_list1[r_idx].pv_pic_buf = (void *)ps_pic_buf_ref;
960 ps_slice_hdr->as_ref_pic_list1[r_idx].pv_mv_buf = (void *)ps_mv_buf_ref;
961 }
962 }
963
964 for(r_idx = ps_slice_hdr->i1_num_ref_idx_l1_active; r_idx < MAX_DPB_SIZE; r_idx++)
965 {
966 ps_slice_hdr->as_ref_pic_list1[r_idx].pv_pic_buf = (void *)ps_pic_buf_ref;
967 ps_slice_hdr->as_ref_pic_list1[r_idx].pv_mv_buf = (void *)ps_mv_buf_ref;
968 }
969 }
970
971 /* Update slice address in the header */
972 if(!ps_slice_hdr->i1_first_slice_in_pic_flag)
973 {
974 ps_slice_hdr->i2_ctb_x = slice_address % ps_sps->i2_pic_wd_in_ctb;
975 ps_slice_hdr->i2_ctb_y = slice_address / ps_sps->i2_pic_wd_in_ctb;
976
977 if(!ps_slice_hdr->i1_dependent_slice_flag)
978 {
979 ps_slice_hdr->i2_independent_ctb_x = ps_slice_hdr->i2_ctb_x;
980 ps_slice_hdr->i2_independent_ctb_y = ps_slice_hdr->i2_ctb_y;
981 }
982 }
983 else
984 {
985 ps_slice_hdr->i2_ctb_x = 0;
986 ps_slice_hdr->i2_ctb_y = 0;
987
988 ps_slice_hdr->i2_independent_ctb_x = 0;
989 ps_slice_hdr->i2_independent_ctb_y = 0;
990 }
991
992 /* If the first slice in the pic is missing, copy the current slice header to
993 * the first slice's header */
994 if((!first_slice_in_pic_flag) &&
995 (0 == ps_codec->i4_pic_present))
996 {
997 slice_header_t *ps_slice_hdr_prev = ps_codec->s_parse.ps_slice_hdr_base;
998 ihevcd_copy_slice_hdr(ps_codec, 0, (ps_codec->s_parse.i4_cur_slice_idx & (MAX_SLICE_HDR_CNT - 1)));
999
1000 ps_codec->i4_slice_error = 1;
1001
1002 ps_slice_hdr_prev->i2_ctb_x = 0;
1003 ps_slice_hdr_prev->i2_ctb_y = 0;
1004
1005 ps_codec->s_parse.i4_ctb_x = 0;
1006 ps_codec->s_parse.i4_ctb_y = 0;
1007
1008 ps_codec->s_parse.i4_cur_slice_idx = 0;
1009
1010 if((ps_slice_hdr->i2_ctb_x == 0) &&
1011 (ps_slice_hdr->i2_ctb_y == 0))
1012 {
1013 ps_slice_hdr->i2_ctb_x++;
1014 }
1015 }
1016
1017 {
1018 /* If skip B is enabled,
1019 * ignore pictures that are non-reference
1020 * TODO: (i1_nal_unit_type < NAL_BLA_W_LP) && (i1_nal_unit_type % 2 == 0) only says it is
1021 * sub-layer non-reference slice. May need to find a way to detect actual non-reference pictures*/
1022
1023 if((i1_nal_unit_type < NAL_BLA_W_LP) &&
1024 (i1_nal_unit_type % 2 == 0))
1025 {
1026 if(IVD_SKIP_B == ps_codec->e_pic_skip_mode)
1027 return IHEVCD_IGNORE_SLICE;
1028 }
1029
1030 /* If skip PB is enabled,
1031 * decode only I slices */
1032 if((IVD_SKIP_PB == ps_codec->e_pic_skip_mode) &&
1033 (ISLICE != ps_slice_hdr->i1_slice_type))
1034 {
1035 return IHEVCD_IGNORE_SLICE;
1036 }
1037 }
1038
1039 return ret;
1040 }
1041