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 UWORD32 value;
222 WORD32 i4_value;
223 WORD32 i, j;
224 WORD32 sps_id;
225
226 pps_t *ps_pps;
227 sps_t *ps_sps;
228 slice_header_t *ps_slice_hdr;
229 WORD32 disable_deblocking_filter_flag;
230 bitstrm_t *ps_bitstrm = &ps_codec->s_parse.s_bitstrm;
231 WORD32 idr_pic_flag;
232 WORD32 pps_id;
233 WORD32 first_slice_in_pic_flag;
234 WORD32 no_output_of_prior_pics_flag = 0;
235 WORD8 i1_nal_unit_type = ps_nal->i1_nal_unit_type;
236 WORD32 num_poc_total_curr = 0;
237 UWORD32 slice_address;
238 WORD32 prev_slice_incomplete_flag = 0;
239
240 if(ps_codec->i4_slice_error == 1)
241 return ret;
242
243 idr_pic_flag = (NAL_IDR_W_LP == i1_nal_unit_type) ||
244 (NAL_IDR_N_LP == i1_nal_unit_type);
245
246
247 BITS_PARSE("first_slice_in_pic_flag", first_slice_in_pic_flag, ps_bitstrm, 1);
248 if((NAL_BLA_W_LP <= i1_nal_unit_type) &&
249 (NAL_RSV_RAP_VCL23 >= i1_nal_unit_type))
250 {
251 BITS_PARSE("no_output_of_prior_pics_flag", no_output_of_prior_pics_flag, ps_bitstrm, 1);
252 }
253 UEV_PARSE("pic_parameter_set_id", pps_id, ps_bitstrm);
254 if(pps_id < 0 || pps_id > MAX_PPS_CNT - 2)
255 {
256 return IHEVCD_INVALID_PARAMETER;
257 }
258
259 /* Get the current PPS structure */
260 ps_pps = ps_codec->s_parse.ps_pps_base + pps_id;
261 if(0 == ps_pps->i1_pps_valid)
262 {
263 pps_t *ps_pps_ref = ps_codec->ps_pps_base;
264 while(0 == ps_pps_ref->i1_pps_valid)
265 {
266 ps_pps_ref++;
267 if((ps_pps_ref - ps_codec->ps_pps_base >= MAX_PPS_CNT - 1))
268 return IHEVCD_INVALID_HEADER;
269 }
270
271 ihevcd_copy_pps(ps_codec, pps_id, ps_pps_ref->i1_pps_id);
272 }
273
274 /* Get SPS id for the current PPS */
275 sps_id = ps_pps->i1_sps_id;
276
277 /* Get the current SPS structure */
278 ps_sps = ps_codec->s_parse.ps_sps_base + sps_id;
279
280 /* When the current slice is the first in a pic,
281 * check whether the previous frame is complete
282 * If the previous frame is incomplete -
283 * treat the remaining CTBs as skip */
284 if((0 != ps_codec->u4_pic_cnt || ps_codec->i4_pic_present) &&
285 first_slice_in_pic_flag)
286 {
287 if(ps_codec->i4_pic_present)
288 {
289 slice_header_t *ps_slice_hdr_next;
290 ps_codec->i4_slice_error = 1;
291 ps_codec->s_parse.i4_cur_slice_idx--;
292 if(ps_codec->s_parse.i4_cur_slice_idx < 0)
293 ps_codec->s_parse.i4_cur_slice_idx = 0;
294
295 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));
296 ps_slice_hdr_next->i2_ctb_x = 0;
297 ps_slice_hdr_next->i2_ctb_y = ps_codec->s_parse.ps_sps->i2_pic_ht_in_ctb;
298 return ret;
299 }
300 else
301 {
302 ps_codec->i4_slice_error = 0;
303 }
304 }
305
306 if(first_slice_in_pic_flag)
307 {
308 ps_codec->s_parse.i4_cur_slice_idx = 0;
309 }
310 else
311 {
312 /* If the current slice is not the first slice in the pic,
313 * but the first one to be parsed, set the current slice indx to 1
314 * Treat the first slice to be missing and copy the current slice header
315 * to the first one */
316 if(0 == ps_codec->i4_pic_present)
317 ps_codec->s_parse.i4_cur_slice_idx = 1;
318 }
319
320 ps_slice_hdr = ps_codec->s_parse.ps_slice_hdr_base + (ps_codec->s_parse.i4_cur_slice_idx & (MAX_SLICE_HDR_CNT - 1));
321 memset(ps_slice_hdr, 0, sizeof(*ps_slice_hdr));
322
323 if((ps_pps->i1_dependent_slice_enabled_flag) &&
324 (!first_slice_in_pic_flag))
325 {
326 BITS_PARSE("dependent_slice_flag", value, ps_bitstrm, 1);
327
328 /* First slice to be decoded in the current picture can't be dependent slice */
329 if (value && 0 == ps_codec->i4_pic_present)
330 {
331 return IHEVCD_IGNORE_SLICE;
332 }
333
334 /* If dependendent slice, copy slice header from previous slice */
335 if(value && (ps_codec->s_parse.i4_cur_slice_idx > 0))
336 {
337 ihevcd_copy_slice_hdr(ps_codec,
338 (ps_codec->s_parse.i4_cur_slice_idx & (MAX_SLICE_HDR_CNT - 1)),
339 ((ps_codec->s_parse.i4_cur_slice_idx - 1) & (MAX_SLICE_HDR_CNT - 1)));
340 }
341 ps_slice_hdr->i1_dependent_slice_flag = value;
342 }
343 else
344 {
345 ps_slice_hdr->i1_dependent_slice_flag = 0;
346 }
347 ps_slice_hdr->i1_nal_unit_type = i1_nal_unit_type;
348 ps_slice_hdr->i1_pps_id = pps_id;
349 ps_slice_hdr->i1_first_slice_in_pic_flag = first_slice_in_pic_flag;
350
351 ps_slice_hdr->i1_no_output_of_prior_pics_flag = 1;
352 if((NAL_BLA_W_LP <= i1_nal_unit_type) &&
353 (NAL_RSV_RAP_VCL23 >= i1_nal_unit_type))
354 {
355 ps_slice_hdr->i1_no_output_of_prior_pics_flag = no_output_of_prior_pics_flag;
356 }
357 ps_slice_hdr->i1_pps_id = pps_id;
358
359 if(!ps_slice_hdr->i1_first_slice_in_pic_flag)
360 {
361 WORD32 num_bits;
362
363 /* Use CLZ to compute Ceil( Log2( PicSizeInCtbsY ) ) */
364 num_bits = 32 - CLZ(ps_sps->i4_pic_size_in_ctb - 1);
365 BITS_PARSE("slice_address", value, ps_bitstrm, num_bits);
366
367 slice_address = value;
368 /* If slice address is greater than the number of CTBs in a picture,
369 * ignore the slice */
370 if(value >= ps_sps->i4_pic_size_in_ctb || value == 0)
371 return IHEVCD_IGNORE_SLICE;
372 }
373 else
374 {
375 slice_address = 0;
376 }
377
378 if(!ps_slice_hdr->i1_dependent_slice_flag)
379 {
380 ps_slice_hdr->i1_pic_output_flag = 1;
381 ps_slice_hdr->i4_pic_order_cnt_lsb = 0;
382 ps_slice_hdr->i1_num_long_term_sps = 0;
383 ps_slice_hdr->i1_num_long_term_pics = 0;
384
385 for(i = 0; i < ps_pps->i1_num_extra_slice_header_bits; i++)
386 {
387 BITS_PARSE("slice_reserved_undetermined_flag[ i ]", value, ps_bitstrm, 1);
388 //slice_reserved_undetermined_flag[ i ]
389 }
390 UEV_PARSE("slice_type", value, ps_bitstrm);
391 if(value > 2)
392 {
393 return IHEVCD_INVALID_PARAMETER;
394 }
395 ps_slice_hdr->i1_slice_type = value;
396
397 /* If the picture is IRAP, slice type must be equal to ISLICE */
398 if((ps_slice_hdr->i1_nal_unit_type >= NAL_BLA_W_LP) &&
399 (ps_slice_hdr->i1_nal_unit_type <= NAL_RSV_RAP_VCL23))
400 ps_slice_hdr->i1_slice_type = ISLICE;
401
402 if((ps_slice_hdr->i1_slice_type < 0) ||
403 (ps_slice_hdr->i1_slice_type > 2))
404 return IHEVCD_IGNORE_SLICE;
405
406 if(ps_pps->i1_output_flag_present_flag)
407 {
408 BITS_PARSE("pic_output_flag", value, ps_bitstrm, 1);
409 ps_slice_hdr->i1_pic_output_flag = value;
410 }
411 ps_slice_hdr->i1_colour_plane_id = 0;
412 if(1 == ps_sps->i1_separate_colour_plane_flag)
413 {
414 BITS_PARSE("colour_plane_id", value, ps_bitstrm, 2);
415 ps_slice_hdr->i1_colour_plane_id = value;
416 }
417 ps_slice_hdr->i1_slice_temporal_mvp_enable_flag = 0;
418
419 if(!idr_pic_flag)
420 {
421
422 WORD32 st_rps_idx;
423 WORD32 num_neg_pics;
424 WORD32 num_pos_pics;
425 WORD8 *pi1_used;
426
427 BITS_PARSE("pic_order_cnt_lsb", value, ps_bitstrm, ps_sps->i1_log2_max_pic_order_cnt_lsb);
428 //value = ihevcd_extend_sign_bit(value, ps_sps->i1_log2_max_pic_order_cnt_lsb);
429 ps_slice_hdr->i4_pic_order_cnt_lsb = value;
430
431 BITS_PARSE("short_term_ref_pic_set_sps_flag", value, ps_bitstrm, 1);
432 ps_slice_hdr->i1_short_term_ref_pic_set_sps_flag = value;
433
434 if(1 == ps_slice_hdr->i1_short_term_ref_pic_set_sps_flag)
435 {
436 WORD32 numbits;
437
438 ps_slice_hdr->i1_short_term_ref_pic_set_idx = 0;
439 if(ps_sps->i1_num_short_term_ref_pic_sets > 1)
440 {
441 numbits = 32 - CLZ(ps_sps->i1_num_short_term_ref_pic_sets - 1);
442 BITS_PARSE("short_term_ref_pic_set_idx", value, ps_bitstrm, numbits);
443 if (value >= ps_sps->i1_num_short_term_ref_pic_sets) {
444 return IHEVCD_INVALID_PARAMETER;
445 }
446 ps_slice_hdr->i1_short_term_ref_pic_set_idx = value;
447 }
448
449 st_rps_idx = ps_slice_hdr->i1_short_term_ref_pic_set_idx;
450 num_neg_pics = ps_sps->as_stref_picset[st_rps_idx].i1_num_neg_pics;
451 num_pos_pics = ps_sps->as_stref_picset[st_rps_idx].i1_num_pos_pics;
452 pi1_used = ps_sps->as_stref_picset[st_rps_idx].ai1_used;
453 }
454 else
455 {
456 ret = ihevcd_short_term_ref_pic_set(ps_bitstrm,
457 &ps_sps->as_stref_picset[0],
458 ps_sps->i1_num_short_term_ref_pic_sets,
459 ps_sps->i1_num_short_term_ref_pic_sets,
460 &ps_slice_hdr->s_stref_picset);
461 if (ret != IHEVCD_SUCCESS)
462 {
463 return ret;
464 }
465 st_rps_idx = ps_sps->i1_num_short_term_ref_pic_sets;
466 num_neg_pics = ps_slice_hdr->s_stref_picset.i1_num_neg_pics;
467 num_pos_pics = ps_slice_hdr->s_stref_picset.i1_num_pos_pics;
468 pi1_used = ps_slice_hdr->s_stref_picset.ai1_used;
469 }
470
471 if(ps_sps->i1_long_term_ref_pics_present_flag)
472 {
473 if(ps_sps->i1_num_long_term_ref_pics_sps > 0)
474 {
475 UEV_PARSE("num_long_term_sps", value, ps_bitstrm);
476 if(value > ps_sps->i1_num_long_term_ref_pics_sps)
477 {
478 return IHEVCD_INVALID_PARAMETER;
479 }
480 ps_slice_hdr->i1_num_long_term_sps = value;
481 }
482 UEV_PARSE("num_long_term_pics", value, ps_bitstrm);
483 if(((ULWORD64)value + ps_slice_hdr->i1_num_long_term_sps + num_neg_pics +
484 num_pos_pics) > (MAX_DPB_SIZE - 1))
485 {
486 return IHEVCD_INVALID_PARAMETER;
487 }
488 ps_slice_hdr->i1_num_long_term_pics = value;
489
490 for(i = 0; i < (ps_slice_hdr->i1_num_long_term_sps +
491 ps_slice_hdr->i1_num_long_term_pics); i++)
492 {
493 if(i < ps_slice_hdr->i1_num_long_term_sps)
494 {
495 /* Use CLZ to compute Ceil( Log2( num_long_term_ref_pics_sps ) ) */
496 if (ps_sps->i1_num_long_term_ref_pics_sps > 1)
497 {
498 WORD32 num_bits = 32 - CLZ(ps_sps->i1_num_long_term_ref_pics_sps - 1);
499 BITS_PARSE("lt_idx_sps[ i ]", value, ps_bitstrm, num_bits);
500 if(value >= ps_sps->i1_num_long_term_ref_pics_sps)
501 {
502 return IHEVCD_INVALID_PARAMETER;
503 }
504 }
505 else
506 {
507 value = 0;
508 }
509 ps_slice_hdr->ai4_poc_lsb_lt[i] = ps_sps->au2_lt_ref_pic_poc_lsb_sps[value];
510 ps_slice_hdr->ai1_used_by_curr_pic_lt_flag[i] = ps_sps->ai1_used_by_curr_pic_lt_sps_flag[value];
511
512 }
513 else
514 {
515 BITS_PARSE("poc_lsb_lt[ i ]", value, ps_bitstrm, ps_sps->i1_log2_max_pic_order_cnt_lsb);
516 ps_slice_hdr->ai4_poc_lsb_lt[i] = value;
517
518 BITS_PARSE("used_by_curr_pic_lt_flag[ i ]", value, ps_bitstrm, 1);
519 ps_slice_hdr->ai1_used_by_curr_pic_lt_flag[i] = value;
520
521 }
522 BITS_PARSE("delta_poc_msb_present_flag[ i ]", value, ps_bitstrm, 1);
523 ps_slice_hdr->ai1_delta_poc_msb_present_flag[i] = value;
524
525
526 ps_slice_hdr->ai1_delta_poc_msb_cycle_lt[i] = 0;
527 if(ps_slice_hdr->ai1_delta_poc_msb_present_flag[i])
528 {
529
530 UEV_PARSE("delata_poc_msb_cycle_lt[ i ]", value, ps_bitstrm);
531 ps_slice_hdr->ai1_delta_poc_msb_cycle_lt[i] = value;
532 }
533
534 if((i != 0) && (i != ps_slice_hdr->i1_num_long_term_sps))
535 {
536 ps_slice_hdr->ai1_delta_poc_msb_cycle_lt[i] += ps_slice_hdr->ai1_delta_poc_msb_cycle_lt[i - 1];
537 }
538
539 }
540 }
541
542 for(i = 0; i < num_neg_pics + num_pos_pics; i++)
543 {
544 if(pi1_used[i])
545 {
546 num_poc_total_curr++;
547 }
548 }
549 for(i = 0; i < ps_slice_hdr->i1_num_long_term_sps + ps_slice_hdr->i1_num_long_term_pics; i++)
550 {
551 if(ps_slice_hdr->ai1_used_by_curr_pic_lt_flag[i])
552 {
553 num_poc_total_curr++;
554 }
555 }
556
557
558 if(ps_sps->i1_sps_temporal_mvp_enable_flag)
559 {
560 BITS_PARSE("enable_temporal_mvp_flag", value, ps_bitstrm, 1);
561 ps_slice_hdr->i1_slice_temporal_mvp_enable_flag = value;
562 }
563
564 }
565 ps_slice_hdr->i1_slice_sao_luma_flag = 0;
566 ps_slice_hdr->i1_slice_sao_chroma_flag = 0;
567 if(ps_sps->i1_sample_adaptive_offset_enabled_flag)
568 {
569 BITS_PARSE("slice_sao_luma_flag", value, ps_bitstrm, 1);
570 ps_slice_hdr->i1_slice_sao_luma_flag = value;
571
572 BITS_PARSE("slice_sao_chroma_flag", value, ps_bitstrm, 1);
573 ps_slice_hdr->i1_slice_sao_chroma_flag = value;
574
575 }
576
577 ps_slice_hdr->i1_max_num_merge_cand = 1;
578 ps_slice_hdr->i1_cabac_init_flag = 0;
579
580 ps_slice_hdr->i1_num_ref_idx_l0_active = 0;
581 ps_slice_hdr->i1_num_ref_idx_l1_active = 0;
582 ps_slice_hdr->i1_slice_cb_qp_offset = 0;
583 ps_slice_hdr->i1_slice_cr_qp_offset = 0;
584 if((PSLICE == ps_slice_hdr->i1_slice_type) ||
585 (BSLICE == ps_slice_hdr->i1_slice_type))
586 {
587 BITS_PARSE("num_ref_idx_active_override_flag", value, ps_bitstrm, 1);
588 ps_slice_hdr->i1_num_ref_idx_active_override_flag = value;
589
590 if(ps_slice_hdr->i1_num_ref_idx_active_override_flag)
591 {
592 UEV_PARSE("num_ref_idx_l0_active_minus1", value, ps_bitstrm);
593 if(value > MAX_DPB_SIZE - 2)
594 {
595 return IHEVCD_INVALID_PARAMETER;
596 }
597 ps_slice_hdr->i1_num_ref_idx_l0_active = value + 1;
598
599 if(BSLICE == ps_slice_hdr->i1_slice_type)
600 {
601 UEV_PARSE("num_ref_idx_l1_active_minus1", value, ps_bitstrm);
602 if(value > MAX_DPB_SIZE - 2)
603 {
604 return IHEVCD_INVALID_PARAMETER;
605 }
606 ps_slice_hdr->i1_num_ref_idx_l1_active = value + 1;
607 }
608
609 }
610 else
611 {
612 ps_slice_hdr->i1_num_ref_idx_l0_active = ps_pps->i1_num_ref_idx_l0_default_active;
613 if(BSLICE == ps_slice_hdr->i1_slice_type)
614 {
615 ps_slice_hdr->i1_num_ref_idx_l1_active = ps_pps->i1_num_ref_idx_l1_default_active;
616 }
617 }
618
619 if(0 == num_poc_total_curr)
620 return IHEVCD_IGNORE_SLICE;
621 if((ps_pps->i1_lists_modification_present_flag) && (num_poc_total_curr > 1))
622 {
623 ihevcd_ref_pic_list_modification(ps_bitstrm,
624 ps_slice_hdr, num_poc_total_curr);
625 }
626 else
627 {
628 ps_slice_hdr->s_rplm.i1_ref_pic_list_modification_flag_l0 = 0;
629 ps_slice_hdr->s_rplm.i1_ref_pic_list_modification_flag_l1 = 0;
630 }
631
632 if(BSLICE == ps_slice_hdr->i1_slice_type)
633 {
634 BITS_PARSE("mvd_l1_zero_flag", value, ps_bitstrm, 1);
635 ps_slice_hdr->i1_mvd_l1_zero_flag = value;
636 }
637
638 ps_slice_hdr->i1_cabac_init_flag = 0;
639 if(ps_pps->i1_cabac_init_present_flag)
640 {
641 BITS_PARSE("cabac_init_flag", value, ps_bitstrm, 1);
642 ps_slice_hdr->i1_cabac_init_flag = value;
643
644 }
645 ps_slice_hdr->i1_collocated_from_l0_flag = 1;
646 ps_slice_hdr->i1_collocated_ref_idx = 0;
647 if(ps_slice_hdr->i1_slice_temporal_mvp_enable_flag)
648 {
649 if(BSLICE == ps_slice_hdr->i1_slice_type)
650 {
651 BITS_PARSE("collocated_from_l0_flag", value, ps_bitstrm, 1);
652 ps_slice_hdr->i1_collocated_from_l0_flag = value;
653 }
654
655 if((ps_slice_hdr->i1_collocated_from_l0_flag && (ps_slice_hdr->i1_num_ref_idx_l0_active > 1)) ||
656 (!ps_slice_hdr->i1_collocated_from_l0_flag && (ps_slice_hdr->i1_num_ref_idx_l1_active > 1)))
657 {
658 UEV_PARSE("collocated_ref_idx", value, ps_bitstrm);
659 if((PSLICE == ps_slice_hdr->i1_slice_type || BSLICE == ps_slice_hdr->i1_slice_type) &&
660 ps_slice_hdr->i1_collocated_from_l0_flag)
661 {
662 if(value >= ps_slice_hdr->i1_num_ref_idx_l0_active)
663 {
664 return IHEVCD_INVALID_PARAMETER;
665 }
666 }
667 if(BSLICE == ps_slice_hdr->i1_slice_type && !ps_slice_hdr->i1_collocated_from_l0_flag)
668 {
669 if(value >= ps_slice_hdr->i1_num_ref_idx_l1_active)
670 {
671 return IHEVCD_INVALID_PARAMETER;
672 }
673 }
674 ps_slice_hdr->i1_collocated_ref_idx = value;
675 }
676
677 }
678
679 if((ps_pps->i1_weighted_pred_flag && (PSLICE == ps_slice_hdr->i1_slice_type)) ||
680 (ps_pps->i1_weighted_bipred_flag && (BSLICE == ps_slice_hdr->i1_slice_type)))
681 {
682 ihevcd_parse_pred_wt_ofst(ps_bitstrm, ps_sps, ps_pps, ps_slice_hdr);
683 }
684 UEV_PARSE("five_minus_max_num_merge_cand", value, ps_bitstrm);
685 if(value > 4)
686 {
687 return IHEVCD_INVALID_PARAMETER;
688 }
689 ps_slice_hdr->i1_max_num_merge_cand = 5 - value;
690
691 }
692 SEV_PARSE("slice_qp_delta", i4_value, ps_bitstrm);
693 if((i4_value < (MIN_HEVC_QP - ps_pps->i1_pic_init_qp)) ||
694 (i4_value > (MAX_HEVC_QP - ps_pps->i1_pic_init_qp)))
695 {
696 return IHEVCD_INVALID_PARAMETER;
697 }
698 ps_slice_hdr->i1_slice_qp_delta = i4_value;
699
700 if(ps_pps->i1_pic_slice_level_chroma_qp_offsets_present_flag)
701 {
702 SEV_PARSE("slice_cb_qp_offset", i4_value, ps_bitstrm);
703 if(i4_value < -12 || i4_value > 12)
704 {
705 return IHEVCD_INVALID_PARAMETER;
706 }
707 ps_slice_hdr->i1_slice_cb_qp_offset = i4_value;
708
709 SEV_PARSE("slice_cr_qp_offset", i4_value, ps_bitstrm);
710 if(i4_value < -12 || i4_value > 12)
711 {
712 return IHEVCD_INVALID_PARAMETER;
713 }
714 ps_slice_hdr->i1_slice_cr_qp_offset = i4_value;
715
716 }
717 ps_slice_hdr->i1_deblocking_filter_override_flag = 0;
718 ps_slice_hdr->i1_slice_disable_deblocking_filter_flag = ps_pps->i1_pic_disable_deblocking_filter_flag;
719 ps_slice_hdr->i1_beta_offset_div2 = ps_pps->i1_beta_offset_div2;
720 ps_slice_hdr->i1_tc_offset_div2 = ps_pps->i1_tc_offset_div2;
721
722 disable_deblocking_filter_flag = ps_pps->i1_pic_disable_deblocking_filter_flag;
723
724 if(ps_pps->i1_deblocking_filter_control_present_flag)
725 {
726
727 if(ps_pps->i1_deblocking_filter_override_enabled_flag)
728 {
729 BITS_PARSE("deblocking_filter_override_flag", value, ps_bitstrm, 1);
730 ps_slice_hdr->i1_deblocking_filter_override_flag = value;
731 }
732
733 if(ps_slice_hdr->i1_deblocking_filter_override_flag)
734 {
735 BITS_PARSE("slice_disable_deblocking_filter_flag", value, ps_bitstrm, 1);
736 ps_slice_hdr->i1_slice_disable_deblocking_filter_flag = value;
737 disable_deblocking_filter_flag = ps_slice_hdr->i1_slice_disable_deblocking_filter_flag;
738
739 if(!ps_slice_hdr->i1_slice_disable_deblocking_filter_flag)
740 {
741 SEV_PARSE("beta_offset_div2", i4_value, ps_bitstrm);
742 if(i4_value < -6 || i4_value > 6)
743 {
744 return IHEVCD_INVALID_PARAMETER;
745 }
746 ps_slice_hdr->i1_beta_offset_div2 = i4_value;
747
748 SEV_PARSE("tc_offset_div2", i4_value, ps_bitstrm);
749 if(i4_value < -6 || i4_value > 6)
750 {
751 return IHEVCD_INVALID_PARAMETER;
752 }
753 ps_slice_hdr->i1_tc_offset_div2 = i4_value;
754
755 }
756 }
757 }
758
759 ps_slice_hdr->i1_slice_loop_filter_across_slices_enabled_flag = ps_pps->i1_loop_filter_across_slices_enabled_flag;
760 if(ps_pps->i1_loop_filter_across_slices_enabled_flag &&
761 (ps_slice_hdr->i1_slice_sao_luma_flag || ps_slice_hdr->i1_slice_sao_chroma_flag || !disable_deblocking_filter_flag))
762 {
763 BITS_PARSE("slice_loop_filter_across_slices_enabled_flag", value, ps_bitstrm, 1);
764 ps_slice_hdr->i1_slice_loop_filter_across_slices_enabled_flag = value;
765 }
766
767 }
768
769 /* Check sanity of slice */
770 if((!first_slice_in_pic_flag) &&
771 (ps_codec->i4_pic_present))
772 {
773 slice_header_t *ps_slice_hdr_base = ps_codec->ps_slice_hdr_base;
774
775
776 /* According to the standard, the above conditions must be satisfied - But for error resilience,
777 * only the following conditions are checked */
778 if((ps_slice_hdr_base->i1_pps_id != ps_slice_hdr->i1_pps_id) ||
779 (ps_slice_hdr_base->i4_pic_order_cnt_lsb != ps_slice_hdr->i4_pic_order_cnt_lsb))
780 {
781 return IHEVCD_IGNORE_SLICE;
782 }
783
784 }
785
786
787 if(0 == ps_codec->i4_pic_present)
788 {
789 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);
790 }
791 else
792 {
793 ps_slice_hdr->i4_abs_pic_order_cnt = ps_codec->s_parse.i4_abs_pic_order_cnt;
794 }
795
796
797 if(!first_slice_in_pic_flag)
798 {
799 /* Check if the current slice belongs to the same pic (Pic being parsed) */
800 if(ps_codec->s_parse.i4_abs_pic_order_cnt == ps_slice_hdr->i4_abs_pic_order_cnt)
801 {
802
803 /* If the Next CTB's index is less than the slice address,
804 * the previous slice is incomplete.
805 * Indicate slice error, and treat the remaining CTBs as skip */
806 if(slice_address > ps_codec->s_parse.i4_next_ctb_indx)
807 {
808 if(ps_codec->i4_pic_present)
809 {
810 prev_slice_incomplete_flag = 1;
811 ps_codec->i4_slice_error = 1;
812 ps_codec->s_parse.i4_cur_slice_idx--;
813 if(ps_codec->s_parse.i4_cur_slice_idx < 0)
814 ps_codec->s_parse.i4_cur_slice_idx = 0;
815 }
816 return IHEVCD_IGNORE_SLICE;
817 }
818 /* If the slice address is less than the next CTB's index,
819 * extra CTBs have been decoded in the previous slice.
820 * Ignore the current slice. Treat it as incomplete */
821 else if(slice_address < ps_codec->s_parse.i4_next_ctb_indx)
822 {
823 return IHEVCD_IGNORE_SLICE;
824 }
825 else
826 {
827 ps_codec->i4_slice_error = 0;
828 }
829 }
830
831 /* The current slice does not belong to the pic that is being parsed */
832 else
833 {
834 /* The previous pic is incomplete.
835 * Treat the remaining CTBs as skip */
836 if(ps_codec->i4_pic_present)
837 {
838 slice_header_t *ps_slice_hdr_next;
839 ps_codec->i4_slice_error = 1;
840 ps_codec->s_parse.i4_cur_slice_idx--;
841 if(ps_codec->s_parse.i4_cur_slice_idx < 0)
842 ps_codec->s_parse.i4_cur_slice_idx = 0;
843
844 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));
845 ps_slice_hdr_next->i2_ctb_x = 0;
846 ps_slice_hdr_next->i2_ctb_y = ps_codec->s_parse.ps_sps->i2_pic_ht_in_ctb;
847 return ret;
848 }
849
850 /* If the previous pic is complete,
851 * return if the current slice is dependant
852 * otherwise, update the parse context's POC */
853 else
854 {
855 if(ps_slice_hdr->i1_dependent_slice_flag)
856 return IHEVCD_IGNORE_SLICE;
857
858 ps_codec->s_parse.i4_abs_pic_order_cnt = ps_slice_hdr->i4_abs_pic_order_cnt;
859 }
860 }
861 }
862
863 /* If the slice is the first slice in the pic, update the parse context's POC */
864 else
865 {
866 /* If the first slice is repeated, ignore the second occurrence
867 * If any other slice is repeated, the CTB addr will be greater than the slice addr,
868 * and hence the second occurrence is ignored */
869 if(ps_codec->s_parse.i4_abs_pic_order_cnt == ps_slice_hdr->i4_abs_pic_order_cnt)
870 return IHEVCD_IGNORE_SLICE;
871
872 ps_codec->s_parse.i4_abs_pic_order_cnt = ps_slice_hdr->i4_abs_pic_order_cnt;
873 }
874
875 // printf("POC: %d\n", ps_slice_hdr->i4_abs_pic_order_cnt);
876 // AEV_TRACE("POC", ps_slice_hdr->i4_abs_pic_order_cnt, 0);
877 ps_slice_hdr->i4_num_entry_point_offsets = 0;
878 if((ps_pps->i1_tiles_enabled_flag) ||
879 (ps_pps->i1_entropy_coding_sync_enabled_flag))
880 {
881 UEV_PARSE("num_entry_point_offsets", value, ps_bitstrm);
882 ps_slice_hdr->i4_num_entry_point_offsets = value;
883
884 {
885 WORD32 max_num_entry_point_offsets;
886 if((ps_pps->i1_tiles_enabled_flag) &&
887 (ps_pps->i1_entropy_coding_sync_enabled_flag))
888 {
889 max_num_entry_point_offsets = ps_pps->i1_num_tile_columns * ps_sps->i2_pic_ht_in_ctb - 1;
890 }
891 else if(ps_pps->i1_tiles_enabled_flag)
892 {
893 max_num_entry_point_offsets = ps_pps->i1_num_tile_columns * ps_pps->i1_num_tile_rows - 1 ;
894 }
895 else
896 {
897 max_num_entry_point_offsets = (ps_sps->i2_pic_ht_in_ctb - 1);
898 }
899
900 if(ps_slice_hdr->i4_num_entry_point_offsets < 0 || ps_slice_hdr->i4_num_entry_point_offsets > max_num_entry_point_offsets)
901 {
902 return IHEVCD_INVALID_PARAMETER;
903 }
904 }
905
906 if(ps_slice_hdr->i4_num_entry_point_offsets > 0)
907 {
908 UEV_PARSE("offset_len_minus1", value, ps_bitstrm);
909 if(value > 31)
910 {
911 return IHEVCD_INVALID_PARAMETER;
912 }
913 ps_slice_hdr->i1_offset_len = value + 1;
914
915 for(i = 0; i < ps_slice_hdr->i4_num_entry_point_offsets; i++)
916 {
917 BITS_PARSE("entry_point_offset", value, ps_bitstrm, ps_slice_hdr->i1_offset_len);
918
919 /* TODO: pu4_entry_point_offset needs to be initialized */
920 //ps_slice_hdr->pu4_entry_point_offset[i] = value;
921 }
922
923 }
924 }
925
926 if(ps_pps->i1_slice_header_extension_present_flag)
927 {
928 UEV_PARSE("slice_header_extension_length", value, ps_bitstrm);
929 if(value > 256)
930 {
931 return IHEVCD_INVALID_PARAMETER;
932 }
933 ps_slice_hdr->i2_slice_header_extension_length = value;
934
935
936 for(i = 0; i < ps_slice_hdr->i2_slice_header_extension_length; i++)
937 {
938 BITS_PARSE("slice_header_extension_data_byte", value, ps_bitstrm, 8);
939 }
940
941 }
942
943 ihevcd_bits_flush_to_byte_boundary(ps_bitstrm);
944
945 if((UWORD8 *)ps_bitstrm->pu4_buf > ps_bitstrm->pu1_buf_max)
946 return IHEVCD_INVALID_PARAMETER;
947
948 {
949 dpb_mgr_t *ps_dpb_mgr = (dpb_mgr_t *)ps_codec->pv_dpb_mgr;
950 WORD32 r_idx;
951
952 if((NAL_IDR_W_LP == ps_slice_hdr->i1_nal_unit_type) ||
953 (NAL_IDR_N_LP == ps_slice_hdr->i1_nal_unit_type) ||
954 (NAL_BLA_N_LP == ps_slice_hdr->i1_nal_unit_type) ||
955 (NAL_BLA_W_DLP == ps_slice_hdr->i1_nal_unit_type) ||
956 (NAL_BLA_W_LP == ps_slice_hdr->i1_nal_unit_type) ||
957 (0 == ps_codec->u4_pic_cnt))
958 {
959 for(i = 0; i < MAX_DPB_BUFS; i++)
960 {
961 if(ps_dpb_mgr->as_dpb_info[i].ps_pic_buf)
962 {
963 pic_buf_t *ps_pic_buf = ps_dpb_mgr->as_dpb_info[i].ps_pic_buf;
964 mv_buf_t *ps_mv_buf;
965
966 /* Long term index is set to MAX_DPB_BUFS to ensure it is not added as LT */
967 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);
968 /* Find buffer id of the MV bank corresponding to the buffer being freed (Buffer with POC of u4_abs_poc) */
969 ps_mv_buf = (mv_buf_t *)ps_codec->ps_mv_buf;
970 for(j = 0; j < ps_codec->i4_max_dpb_size; j++)
971 {
972 if(ps_mv_buf && ps_mv_buf->i4_abs_poc == ps_pic_buf->i4_abs_poc)
973 {
974 ihevc_buf_mgr_release((buf_mgr_t *)ps_codec->pv_mv_buf_mgr, j, BUF_MGR_REF);
975 break;
976 }
977 ps_mv_buf++;
978 }
979
980 }
981
982 }
983
984 /* Initialize the reference lists to NULL
985 * This is done to take care of the cases where the first pic is not IDR
986 * but the reference list is not created for the first pic because
987 * pic count is zero leaving the reference list uninitialised */
988 for(r_idx = 0; r_idx < MAX_DPB_SIZE; r_idx++)
989 {
990 ps_slice_hdr->as_ref_pic_list0[r_idx].pv_pic_buf = NULL;
991 ps_slice_hdr->as_ref_pic_list0[r_idx].pv_mv_buf = NULL;
992
993 ps_slice_hdr->as_ref_pic_list1[r_idx].pv_pic_buf = NULL;
994 ps_slice_hdr->as_ref_pic_list1[r_idx].pv_mv_buf = NULL;
995 }
996
997 }
998 else
999 {
1000 ret = ihevcd_ref_list(ps_codec, ps_pps, ps_sps, ps_slice_hdr);
1001 if ((WORD32)IHEVCD_SUCCESS != ret)
1002 {
1003 return ret;
1004 }
1005
1006 }
1007
1008 }
1009
1010 /* Fill the remaining entries of the reference lists with the nearest POC
1011 * This is done to handle cases where there is a corruption in the reference index */
1012 if(ps_codec->i4_pic_present)
1013 {
1014 pic_buf_t *ps_pic_buf_ref;
1015 mv_buf_t *ps_mv_buf_ref;
1016 WORD32 r_idx;
1017 dpb_mgr_t *ps_dpb_mgr = (dpb_mgr_t *)ps_codec->pv_dpb_mgr;
1018 buf_mgr_t *ps_mv_buf_mgr = (buf_mgr_t *)ps_codec->pv_mv_buf_mgr;
1019
1020 ps_pic_buf_ref = ihevc_dpb_mgr_get_ref_by_nearest_poc(ps_dpb_mgr, ps_slice_hdr->i4_abs_pic_order_cnt);
1021 if(NULL == ps_pic_buf_ref)
1022 {
1023 ps_pic_buf_ref = ps_codec->as_process[0].ps_cur_pic;
1024 ps_mv_buf_ref = ps_codec->s_parse.ps_cur_mv_buf;
1025 }
1026 else
1027 {
1028 ps_mv_buf_ref = ihevcd_mv_mgr_get_poc(ps_mv_buf_mgr, ps_pic_buf_ref->i4_abs_poc);
1029 }
1030
1031 for(r_idx = 0; r_idx < ps_slice_hdr->i1_num_ref_idx_l0_active; r_idx++)
1032 {
1033 if(NULL == ps_slice_hdr->as_ref_pic_list0[r_idx].pv_pic_buf)
1034 {
1035 ps_slice_hdr->as_ref_pic_list0[r_idx].pv_pic_buf = (void *)ps_pic_buf_ref;
1036 ps_slice_hdr->as_ref_pic_list0[r_idx].pv_mv_buf = (void *)ps_mv_buf_ref;
1037 }
1038 }
1039
1040 for(r_idx = ps_slice_hdr->i1_num_ref_idx_l0_active; r_idx < MAX_DPB_SIZE; r_idx++)
1041 {
1042 ps_slice_hdr->as_ref_pic_list0[r_idx].pv_pic_buf = (void *)ps_pic_buf_ref;
1043 ps_slice_hdr->as_ref_pic_list0[r_idx].pv_mv_buf = (void *)ps_mv_buf_ref;
1044 }
1045
1046 for(r_idx = 0; r_idx < ps_slice_hdr->i1_num_ref_idx_l1_active; r_idx++)
1047 {
1048 if(NULL == ps_slice_hdr->as_ref_pic_list1[r_idx].pv_pic_buf)
1049 {
1050 ps_slice_hdr->as_ref_pic_list1[r_idx].pv_pic_buf = (void *)ps_pic_buf_ref;
1051 ps_slice_hdr->as_ref_pic_list1[r_idx].pv_mv_buf = (void *)ps_mv_buf_ref;
1052 }
1053 }
1054
1055 for(r_idx = ps_slice_hdr->i1_num_ref_idx_l1_active; r_idx < MAX_DPB_SIZE; r_idx++)
1056 {
1057 ps_slice_hdr->as_ref_pic_list1[r_idx].pv_pic_buf = (void *)ps_pic_buf_ref;
1058 ps_slice_hdr->as_ref_pic_list1[r_idx].pv_mv_buf = (void *)ps_mv_buf_ref;
1059 }
1060 }
1061
1062 /* Update slice address in the header */
1063 if(!ps_slice_hdr->i1_first_slice_in_pic_flag)
1064 {
1065 ps_slice_hdr->i2_ctb_x = slice_address % ps_sps->i2_pic_wd_in_ctb;
1066 ps_slice_hdr->i2_ctb_y = slice_address / ps_sps->i2_pic_wd_in_ctb;
1067
1068 if(!ps_slice_hdr->i1_dependent_slice_flag)
1069 {
1070 ps_slice_hdr->i2_independent_ctb_x = ps_slice_hdr->i2_ctb_x;
1071 ps_slice_hdr->i2_independent_ctb_y = ps_slice_hdr->i2_ctb_y;
1072 }
1073 }
1074 else
1075 {
1076 ps_slice_hdr->i2_ctb_x = 0;
1077 ps_slice_hdr->i2_ctb_y = 0;
1078
1079 ps_slice_hdr->i2_independent_ctb_x = 0;
1080 ps_slice_hdr->i2_independent_ctb_y = 0;
1081 }
1082
1083 /* If the first slice in the pic is missing, copy the current slice header to
1084 * the first slice's header */
1085 if((!first_slice_in_pic_flag) &&
1086 (0 == ps_codec->i4_pic_present))
1087 {
1088 slice_header_t *ps_slice_hdr_prev = ps_codec->s_parse.ps_slice_hdr_base;
1089 ihevcd_copy_slice_hdr(ps_codec, 0, (ps_codec->s_parse.i4_cur_slice_idx & (MAX_SLICE_HDR_CNT - 1)));
1090
1091 prev_slice_incomplete_flag = 1;
1092 ASSERT(ps_codec->s_parse.i4_cur_slice_idx == 1);
1093
1094 ps_slice_hdr_prev->i2_ctb_x = 0;
1095 ps_slice_hdr_prev->i2_ctb_y = 0;
1096
1097 ps_codec->s_parse.i4_ctb_x = 0;
1098 ps_codec->s_parse.i4_ctb_y = 0;
1099
1100 ps_codec->s_parse.i4_cur_slice_idx = 0;
1101
1102 if((ps_slice_hdr->i2_ctb_x == 0) &&
1103 (ps_slice_hdr->i2_ctb_y == 0))
1104 {
1105 ps_slice_hdr->i2_ctb_x++;
1106 }
1107 }
1108
1109 {
1110 /* If skip B is enabled,
1111 * ignore pictures that are non-reference
1112 * TODO: (i1_nal_unit_type < NAL_BLA_W_LP) && (i1_nal_unit_type % 2 == 0) only says it is
1113 * sub-layer non-reference slice. May need to find a way to detect actual non-reference pictures*/
1114
1115 if((i1_nal_unit_type < NAL_BLA_W_LP) &&
1116 (i1_nal_unit_type % 2 == 0))
1117 {
1118 if(IVD_SKIP_B == ps_codec->e_pic_skip_mode)
1119 return IHEVCD_IGNORE_SLICE;
1120 }
1121
1122 /* If skip PB is enabled,
1123 * decode only I slices */
1124 if((IVD_SKIP_PB == ps_codec->e_pic_skip_mode) &&
1125 (ISLICE != ps_slice_hdr->i1_slice_type))
1126 {
1127 return IHEVCD_IGNORE_SLICE;
1128 }
1129 }
1130
1131 if(prev_slice_incomplete_flag)
1132 {
1133 ps_codec->i4_slice_error = 1;
1134 ps_codec->s_parse.i4_cur_slice_idx--;
1135 if(ps_codec->s_parse.i4_cur_slice_idx < 0)
1136 ps_codec->s_parse.i4_cur_slice_idx = 0;
1137 }
1138
1139 return ret;
1140 }
1141