1 /*
2 * Copyright (C) 2009 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 /*------------------------------------------------------------------------------
18
19 Table of contents
20
21 1. Include headers
22 2. External compiler flags
23 3. Module defines
24 4. Local function prototypes
25 5. Functions
26 h264bsdDecodeSliceHeader
27 NumSliceGroupChangeCycleBits
28 RefPicListReordering
29 DecRefPicMarking
30 CheckPpsId
31 CheckFrameNum
32 CheckIdrPicId
33 CheckPicOrderCntLsb
34 CheckDeltaPicOrderCntBottom
35 CheckDeltaPicOrderCnt
36 CheckRedundantPicCnt
37
38 ------------------------------------------------------------------------------*/
39
40 /*------------------------------------------------------------------------------
41 1. Include headers
42 ------------------------------------------------------------------------------*/
43
44 #include "h264bsd_slice_header.h"
45 #include "h264bsd_util.h"
46 #include "h264bsd_vlc.h"
47 #include "h264bsd_nal_unit.h"
48 #include "h264bsd_dpb.h"
49
50 #define UNUSED(x) (void)(x)
51
52 /*------------------------------------------------------------------------------
53 2. External compiler flags
54 --------------------------------------------------------------------------------
55
56 --------------------------------------------------------------------------------
57 3. Module defines
58 ------------------------------------------------------------------------------*/
59
60 /*------------------------------------------------------------------------------
61 4. Local function prototypes
62 ------------------------------------------------------------------------------*/
63
64 static u32 RefPicListReordering(strmData_t *, refPicListReordering_t *,
65 u32, u32);
66
67 static u32 NumSliceGroupChangeCycleBits(u32 picSizeInMbs,
68 u32 sliceGroupChangeRate);
69
70 static u32 DecRefPicMarking(strmData_t *pStrmData,
71 decRefPicMarking_t *pDecRefPicMarking, nalUnitType_e nalUnitType,
72 u32 numRefFrames);
73
74
75 /*------------------------------------------------------------------------------
76
77 Function name: h264bsdDecodeSliceHeader
78
79 Functional description:
80 Decode slice header data from the stream.
81
82 Inputs:
83 pStrmData pointer to stream data structure
84 pSeqParamSet pointer to active sequence parameter set
85 pPicParamSet pointer to active picture parameter set
86 pNalUnit pointer to current NAL unit structure
87
88 Outputs:
89 pSliceHeader decoded data is stored here
90
91 Returns:
92 HANTRO_OK success
93 HANTRO_NOK invalid stream data or end of stream
94
95 ------------------------------------------------------------------------------*/
96
h264bsdDecodeSliceHeader(strmData_t * pStrmData,sliceHeader_t * pSliceHeader,seqParamSet_t * pSeqParamSet,picParamSet_t * pPicParamSet,nalUnit_t * pNalUnit)97 u32 h264bsdDecodeSliceHeader(strmData_t *pStrmData, sliceHeader_t *pSliceHeader,
98 seqParamSet_t *pSeqParamSet, picParamSet_t *pPicParamSet,
99 nalUnit_t *pNalUnit)
100 {
101
102 /* Variables */
103
104 u32 tmp, i, value;
105 i32 itmp;
106 u32 picSizeInMbs;
107
108 /* Code */
109
110 ASSERT(pStrmData);
111 ASSERT(pSliceHeader);
112 ASSERT(pSeqParamSet);
113 ASSERT(pPicParamSet);
114 ASSERT( pNalUnit->nalUnitType == NAL_CODED_SLICE ||
115 pNalUnit->nalUnitType == NAL_CODED_SLICE_IDR );
116
117
118 H264SwDecMemset(pSliceHeader, 0, sizeof(sliceHeader_t));
119
120 picSizeInMbs = pSeqParamSet->picWidthInMbs * pSeqParamSet->picHeightInMbs;
121 tmp = h264bsdDecodeExpGolombUnsigned(pStrmData, &value);
122 if (tmp != HANTRO_OK)
123 return(tmp);
124 pSliceHeader->firstMbInSlice = value;
125 if (value >= picSizeInMbs)
126 {
127 EPRINT("first_mb_in_slice");
128 return(HANTRO_NOK);
129 }
130
131 tmp = h264bsdDecodeExpGolombUnsigned(pStrmData, &value);
132 if (tmp != HANTRO_OK)
133 return(tmp);
134 pSliceHeader->sliceType = value;
135 /* slice type has to be either I or P slice. P slice is not allowed when
136 * current NAL unit is an IDR NAL unit or num_ref_frames is 0 */
137 if ( !IS_I_SLICE(pSliceHeader->sliceType) &&
138 ( !IS_P_SLICE(pSliceHeader->sliceType) ||
139 IS_IDR_NAL_UNIT(pNalUnit) ||
140 !pSeqParamSet->numRefFrames ) )
141 {
142 EPRINT("slice_type");
143 return(HANTRO_NOK);
144 }
145
146 tmp = h264bsdDecodeExpGolombUnsigned(pStrmData, &value);
147 if (tmp != HANTRO_OK)
148 return(tmp);
149 pSliceHeader->picParameterSetId = value;
150 if (pSliceHeader->picParameterSetId != pPicParamSet->picParameterSetId)
151 {
152 EPRINT("pic_parameter_set_id");
153 return(HANTRO_NOK);
154 }
155
156 /* log2(maxFrameNum) -> num bits to represent frame_num */
157 i = 0;
158 while (pSeqParamSet->maxFrameNum >> i)
159 i++;
160 i--;
161
162 tmp = h264bsdGetBits(pStrmData, i);
163 if (tmp == END_OF_STREAM)
164 return(HANTRO_NOK);
165 if (IS_IDR_NAL_UNIT(pNalUnit) && tmp != 0)
166 {
167 EPRINT("frame_num");
168 return(HANTRO_NOK);
169 }
170 pSliceHeader->frameNum = tmp;
171
172 if (IS_IDR_NAL_UNIT(pNalUnit))
173 {
174 tmp = h264bsdDecodeExpGolombUnsigned(pStrmData, &value);
175 if (tmp != HANTRO_OK)
176 return(tmp);
177 pSliceHeader->idrPicId = value;
178 if (value > 65535)
179 {
180 EPRINT("idr_pic_id");
181 return(HANTRO_NOK);
182 }
183 }
184
185 if (pSeqParamSet->picOrderCntType == 0)
186 {
187 /* log2(maxPicOrderCntLsb) -> num bits to represent pic_order_cnt_lsb */
188 i = 0;
189 while (pSeqParamSet->maxPicOrderCntLsb >> i)
190 i++;
191 i--;
192
193 tmp = h264bsdGetBits(pStrmData, i);
194 if (tmp == END_OF_STREAM)
195 return(HANTRO_NOK);
196 pSliceHeader->picOrderCntLsb = tmp;
197
198 if (pPicParamSet->picOrderPresentFlag)
199 {
200 tmp = h264bsdDecodeExpGolombSigned(pStrmData, &itmp);
201 if (tmp != HANTRO_OK)
202 return(tmp);
203 pSliceHeader->deltaPicOrderCntBottom = itmp;
204 }
205
206 /* check that picOrderCnt for IDR picture will be zero. See
207 * DecodePicOrderCnt function to understand the logic here */
208 if ( IS_IDR_NAL_UNIT(pNalUnit) &&
209 ( (pSliceHeader->picOrderCntLsb >
210 pSeqParamSet->maxPicOrderCntLsb/2) ||
211 MIN((i32)pSliceHeader->picOrderCntLsb,
212 (i32)pSliceHeader->picOrderCntLsb +
213 pSliceHeader->deltaPicOrderCntBottom) != 0 ) )
214 {
215 return(HANTRO_NOK);
216 }
217 }
218
219 if ( (pSeqParamSet->picOrderCntType == 1) &&
220 !pSeqParamSet->deltaPicOrderAlwaysZeroFlag )
221 {
222 tmp = h264bsdDecodeExpGolombSigned(pStrmData, &itmp);
223 if (tmp != HANTRO_OK)
224 return(tmp);
225 pSliceHeader->deltaPicOrderCnt[0] = itmp;
226
227 if (pPicParamSet->picOrderPresentFlag)
228 {
229 tmp = h264bsdDecodeExpGolombSigned(pStrmData, &itmp);
230 if (tmp != HANTRO_OK)
231 return(tmp);
232 pSliceHeader->deltaPicOrderCnt[1] = itmp;
233 }
234
235 /* check that picOrderCnt for IDR picture will be zero. See
236 * DecodePicOrderCnt function to understand the logic here */
237 if ( IS_IDR_NAL_UNIT(pNalUnit) &&
238 MIN(pSliceHeader->deltaPicOrderCnt[0],
239 pSliceHeader->deltaPicOrderCnt[0] +
240 pSeqParamSet->offsetForTopToBottomField +
241 pSliceHeader->deltaPicOrderCnt[1]) != 0)
242 {
243 return(HANTRO_NOK);
244 }
245 }
246
247 if (pPicParamSet->redundantPicCntPresentFlag)
248 {
249 tmp = h264bsdDecodeExpGolombUnsigned(pStrmData, &value);
250 if (tmp != HANTRO_OK)
251 return(tmp);
252 pSliceHeader->redundantPicCnt = value;
253 if (value > 127)
254 {
255 EPRINT("redundant_pic_cnt");
256 return(HANTRO_NOK);
257 }
258 }
259
260 if (IS_P_SLICE(pSliceHeader->sliceType))
261 {
262 tmp = h264bsdGetBits(pStrmData, 1);
263 if (tmp == END_OF_STREAM)
264 return(HANTRO_NOK);
265 pSliceHeader->numRefIdxActiveOverrideFlag = tmp;
266
267 if (pSliceHeader->numRefIdxActiveOverrideFlag)
268 {
269 tmp = h264bsdDecodeExpGolombUnsigned(pStrmData, &value);
270 if (tmp != HANTRO_OK)
271 return(tmp);
272 if (value > 15)
273 {
274 EPRINT("num_ref_idx_l0_active_minus1");
275 return(HANTRO_NOK);
276 }
277 pSliceHeader->numRefIdxL0Active = value + 1;
278 }
279 /* set numRefIdxL0Active from pic param set */
280 else
281 {
282 /* if value (minus1) in picture parameter set exceeds 15 it should
283 * have been overridden here */
284 if (pPicParamSet->numRefIdxL0Active > 16)
285 {
286 EPRINT("num_ref_idx_active_override_flag");
287 return(HANTRO_NOK);
288 }
289 pSliceHeader->numRefIdxL0Active = pPicParamSet->numRefIdxL0Active;
290 }
291 }
292
293 if (IS_P_SLICE(pSliceHeader->sliceType))
294 {
295 tmp = RefPicListReordering(pStrmData,
296 &pSliceHeader->refPicListReordering,
297 pSliceHeader->numRefIdxL0Active,
298 pSeqParamSet->maxFrameNum);
299 if (tmp != HANTRO_OK)
300 return(tmp);
301 }
302
303 if (pNalUnit->nalRefIdc != 0)
304 {
305 tmp = DecRefPicMarking(pStrmData, &pSliceHeader->decRefPicMarking,
306 pNalUnit->nalUnitType, pSeqParamSet->numRefFrames);
307 if (tmp != HANTRO_OK)
308 return(tmp);
309 }
310
311 /* decode sliceQpDelta and check that initial QP for the slice will be on
312 * the range [0, 51] */
313 tmp = h264bsdDecodeExpGolombSigned(pStrmData, &itmp);
314 if (tmp != HANTRO_OK)
315 return(tmp);
316 pSliceHeader->sliceQpDelta = itmp;
317 itmp += (i32)pPicParamSet->picInitQp;
318 if ( (itmp < 0) || (itmp > 51) )
319 {
320 EPRINT("slice_qp_delta");
321 return(HANTRO_NOK);
322 }
323
324 if (pPicParamSet->deblockingFilterControlPresentFlag)
325 {
326 tmp = h264bsdDecodeExpGolombUnsigned(pStrmData, &value);
327 if (tmp != HANTRO_OK)
328 return(tmp);
329 pSliceHeader->disableDeblockingFilterIdc = value;
330 if (pSliceHeader->disableDeblockingFilterIdc > 2)
331 {
332 EPRINT("disable_deblocking_filter_idc");
333 return(HANTRO_NOK);
334 }
335
336 if (pSliceHeader->disableDeblockingFilterIdc != 1)
337 {
338 tmp = h264bsdDecodeExpGolombSigned(pStrmData, &itmp);
339 if (tmp != HANTRO_OK)
340 return(tmp);
341 if ( (itmp < -6) || (itmp > 6) )
342 {
343 EPRINT("slice_alpha_c0_offset_div2");
344 return(HANTRO_NOK);
345 }
346 pSliceHeader->sliceAlphaC0Offset = itmp * 2;
347
348 tmp = h264bsdDecodeExpGolombSigned(pStrmData, &itmp);
349 if (tmp != HANTRO_OK)
350 return(tmp);
351 if ( (itmp < -6) || (itmp > 6) )
352 {
353 EPRINT("slice_beta_offset_div2");
354 return(HANTRO_NOK);
355 }
356 pSliceHeader->sliceBetaOffset = itmp * 2;
357 }
358 }
359
360 if ( (pPicParamSet->numSliceGroups > 1) &&
361 (pPicParamSet->sliceGroupMapType >= 3) &&
362 (pPicParamSet->sliceGroupMapType <= 5) )
363 {
364 /* set tmp to number of bits used to represent slice_group_change_cycle
365 * in the stream */
366 tmp = NumSliceGroupChangeCycleBits(picSizeInMbs,
367 pPicParamSet->sliceGroupChangeRate);
368 value = h264bsdGetBits(pStrmData, tmp);
369 if (value == END_OF_STREAM)
370 return(HANTRO_NOK);
371 pSliceHeader->sliceGroupChangeCycle = value;
372
373 /* corresponds to tmp = Ceil(picSizeInMbs / sliceGroupChangeRate) */
374 tmp = (picSizeInMbs + pPicParamSet->sliceGroupChangeRate - 1) /
375 pPicParamSet->sliceGroupChangeRate;
376 if (pSliceHeader->sliceGroupChangeCycle > tmp)
377 {
378 EPRINT("slice_group_change_cycle");
379 return(HANTRO_NOK);
380 }
381 }
382
383 return(HANTRO_OK);
384
385 }
386
387 /*------------------------------------------------------------------------------
388
389 Function: NumSliceGroupChangeCycleBits
390
391 Functional description:
392 Determine number of bits needed to represent
393 slice_group_change_cycle in the stream. The standard states that
394 slice_group_change_cycle is represented by
395 Ceil( Log2( (picSizeInMbs / sliceGroupChangeRate) + 1) )
396
397 bits. Division "/" in the equation is non-truncating division.
398
399 Inputs:
400 picSizeInMbs picture size in macroblocks
401 sliceGroupChangeRate
402
403 Outputs:
404 none
405
406 Returns:
407 number of bits needed
408
409 ------------------------------------------------------------------------------*/
410
NumSliceGroupChangeCycleBits(u32 picSizeInMbs,u32 sliceGroupChangeRate)411 u32 NumSliceGroupChangeCycleBits(u32 picSizeInMbs, u32 sliceGroupChangeRate)
412 {
413
414 /* Variables */
415
416 u32 tmp,numBits,mask;
417
418 /* Code */
419
420 ASSERT(picSizeInMbs);
421 ASSERT(sliceGroupChangeRate);
422 ASSERT(sliceGroupChangeRate <= picSizeInMbs);
423
424 /* compute (picSizeInMbs / sliceGroupChangeRate + 1), rounded up */
425 if (picSizeInMbs % sliceGroupChangeRate)
426 tmp = 2 + picSizeInMbs/sliceGroupChangeRate;
427 else
428 tmp = 1 + picSizeInMbs/sliceGroupChangeRate;
429
430 numBits = 0;
431 mask = ~0U;
432
433 /* set numBits to position of right-most non-zero bit */
434 while (tmp & (mask<<++numBits))
435 ;
436 numBits--;
437
438 /* add one more bit if value greater than 2^numBits */
439 if (tmp & ((1<<numBits)-1))
440 numBits++;
441
442 return(numBits);
443
444 }
445
446 /*------------------------------------------------------------------------------
447
448 Function: RefPicListReordering
449
450 Functional description:
451 Decode reference picture list reordering syntax elements from
452 the stream. Max number of reordering commands is numRefIdxActive.
453
454 Inputs:
455 pStrmData pointer to stream data structure
456 numRefIdxActive number of active reference indices to be used for
457 current slice
458 maxPicNum maxFrameNum from the active SPS
459
460 Outputs:
461 pRefPicListReordering decoded data is stored here
462
463 Returns:
464 HANTRO_OK success
465 HANTRO_NOK invalid stream data
466
467 ------------------------------------------------------------------------------*/
468
RefPicListReordering(strmData_t * pStrmData,refPicListReordering_t * pRefPicListReordering,u32 numRefIdxActive,u32 maxPicNum)469 u32 RefPicListReordering(strmData_t *pStrmData,
470 refPicListReordering_t *pRefPicListReordering, u32 numRefIdxActive,
471 u32 maxPicNum)
472 {
473
474 /* Variables */
475
476 u32 tmp, value, i;
477 u32 command;
478
479 /* Code */
480
481 ASSERT(pStrmData);
482 ASSERT(pRefPicListReordering);
483 ASSERT(numRefIdxActive);
484 ASSERT(maxPicNum);
485
486
487 tmp = h264bsdGetBits(pStrmData, 1);
488 if (tmp == END_OF_STREAM)
489 return(HANTRO_NOK);
490
491 pRefPicListReordering->refPicListReorderingFlagL0 = tmp;
492
493 if (pRefPicListReordering->refPicListReorderingFlagL0)
494 {
495 i = 0;
496
497 do
498 {
499 if (i > numRefIdxActive)
500 {
501 EPRINT("Too many reordering commands");
502 return(HANTRO_NOK);
503 }
504
505 tmp = h264bsdDecodeExpGolombUnsigned(pStrmData, &command);
506 if (tmp != HANTRO_OK)
507 return(tmp);
508 if (command > 3)
509 {
510 EPRINT("reordering_of_pic_nums_idc");
511 return(HANTRO_NOK);
512 }
513
514 pRefPicListReordering->command[i].reorderingOfPicNumsIdc = command;
515
516 if ((command == 0) || (command == 1))
517 {
518 tmp = h264bsdDecodeExpGolombUnsigned(pStrmData, &value);
519 if (tmp != HANTRO_OK)
520 return(tmp);
521 if (value >= maxPicNum)
522 {
523 EPRINT("abs_diff_pic_num_minus1");
524 return(HANTRO_NOK);
525 }
526 pRefPicListReordering->command[i].absDiffPicNum = value + 1;
527 }
528 else if (command == 2)
529 {
530 tmp = h264bsdDecodeExpGolombUnsigned(pStrmData, &value);
531 if (tmp != HANTRO_OK)
532 return(tmp);
533 pRefPicListReordering->command[i].longTermPicNum = value;
534 }
535 i++;
536 } while (command != 3);
537
538 /* there shall be at least one reordering command if
539 * refPicListReorderingFlagL0 was set */
540 if (i == 1)
541 {
542 EPRINT("ref_pic_list_reordering");
543 return(HANTRO_NOK);
544 }
545 }
546
547 return(HANTRO_OK);
548
549 }
550
551 /*------------------------------------------------------------------------------
552
553 Function: DecRefPicMarking
554
555 Functional description:
556 Decode decoded reference picture marking syntax elements from
557 the stream.
558
559 Inputs:
560 pStrmData pointer to stream data structure
561 nalUnitType type of the current NAL unit
562 numRefFrames max number of reference frames from the active SPS
563
564 Outputs:
565 pDecRefPicMarking decoded data is stored here
566
567 Returns:
568 HANTRO_OK success
569 HANTRO_NOK invalid stream data
570
571 ------------------------------------------------------------------------------*/
572
DecRefPicMarking(strmData_t * pStrmData,decRefPicMarking_t * pDecRefPicMarking,nalUnitType_e nalUnitType,u32 numRefFrames)573 u32 DecRefPicMarking(strmData_t *pStrmData,
574 decRefPicMarking_t *pDecRefPicMarking, nalUnitType_e nalUnitType,
575 u32 numRefFrames)
576 {
577
578 /* Variables */
579
580 u32 tmp, value;
581 u32 i;
582 u32 operation;
583 /* variables for error checking purposes, store number of memory
584 * management operations of certain type */
585 u32 num4 = 0, num5 = 0, num6 = 0, num1to3 = 0;
586
587 /* Code */
588
589 ASSERT( nalUnitType == NAL_CODED_SLICE_IDR ||
590 nalUnitType == NAL_CODED_SLICE ||
591 nalUnitType == NAL_SEI );
592
593
594 if (nalUnitType == NAL_CODED_SLICE_IDR)
595 {
596 tmp = h264bsdGetBits(pStrmData, 1);
597 if (tmp == END_OF_STREAM)
598 return(HANTRO_NOK);
599 pDecRefPicMarking->noOutputOfPriorPicsFlag = tmp;
600
601 tmp = h264bsdGetBits(pStrmData, 1);
602 if (tmp == END_OF_STREAM)
603 return(HANTRO_NOK);
604 pDecRefPicMarking->longTermReferenceFlag = tmp;
605 if (!numRefFrames && pDecRefPicMarking->longTermReferenceFlag)
606 {
607 EPRINT("long_term_reference_flag");
608 return(HANTRO_NOK);
609 }
610 }
611 else
612 {
613 tmp = h264bsdGetBits(pStrmData, 1);
614 if (tmp == END_OF_STREAM)
615 return(HANTRO_NOK);
616 pDecRefPicMarking->adaptiveRefPicMarkingModeFlag = tmp;
617 if (pDecRefPicMarking->adaptiveRefPicMarkingModeFlag)
618 {
619 i = 0;
620 do
621 {
622 /* see explanation of the MAX_NUM_MMC_OPERATIONS in
623 * slice_header.h */
624 if (i > (2 * numRefFrames + 2))
625 {
626 EPRINT("Too many management operations");
627 return(HANTRO_NOK);
628 }
629
630 tmp = h264bsdDecodeExpGolombUnsigned(pStrmData, &operation);
631 if (tmp != HANTRO_OK)
632 return(tmp);
633 if (operation > 6)
634 {
635 EPRINT("memory_management_control_operation");
636 return(HANTRO_NOK);
637 }
638
639 pDecRefPicMarking->operation[i].
640 memoryManagementControlOperation = operation;
641 if ((operation == 1) || (operation == 3))
642 {
643 tmp = h264bsdDecodeExpGolombUnsigned(pStrmData, &value);
644 if (tmp != HANTRO_OK)
645 return(tmp);
646 pDecRefPicMarking->operation[i].differenceOfPicNums =
647 value + 1;
648 }
649 if (operation == 2)
650 {
651 tmp = h264bsdDecodeExpGolombUnsigned(pStrmData, &value);
652 if (tmp != HANTRO_OK)
653 return(tmp);
654 pDecRefPicMarking->operation[i].longTermPicNum = value;
655 }
656 if ((operation == 3) || (operation == 6))
657 {
658 tmp = h264bsdDecodeExpGolombUnsigned(pStrmData, &value);
659 if (tmp != HANTRO_OK)
660 return(tmp);
661 pDecRefPicMarking->operation[i].longTermFrameIdx =
662 value;
663 }
664 if (operation == 4)
665 {
666 tmp = h264bsdDecodeExpGolombUnsigned(pStrmData, &value);
667 if (tmp != HANTRO_OK)
668 return(tmp);
669 /* value shall be in range [0, numRefFrames] */
670 if (value > numRefFrames)
671 {
672 EPRINT("max_long_term_frame_idx_plus1");
673 return(HANTRO_NOK);
674 }
675 if (value == 0)
676 {
677 pDecRefPicMarking->operation[i].
678 maxLongTermFrameIdx =
679 NO_LONG_TERM_FRAME_INDICES;
680 }
681 else
682 {
683 pDecRefPicMarking->operation[i].
684 maxLongTermFrameIdx = value - 1;
685 }
686 num4++;
687 }
688 if (operation == 5)
689 {
690 num5++;
691 }
692 if (operation && operation <= 3)
693 num1to3++;
694 if (operation == 6)
695 num6++;
696
697 i++;
698 } while (operation != 0);
699
700 /* error checking */
701 if (num4 > 1 || num5 > 1 || num6 > 1 || (num1to3 && num5))
702 return(HANTRO_NOK);
703
704 }
705 }
706
707 return(HANTRO_OK);
708 }
709
710 /*------------------------------------------------------------------------------
711
712 Function name: h264bsdCheckPpsId
713
714 Functional description:
715 Peek value of pic_parameter_set_id from the slice header. Function
716 does not modify current stream positions but copies the stream
717 data structure to tmp structure which is used while accessing
718 stream data.
719
720 Inputs:
721 pStrmData pointer to stream data structure
722
723 Outputs:
724 picParamSetId value is stored here
725
726 Returns:
727 HANTRO_OK success
728 HANTRO_NOK invalid stream data
729
730 ------------------------------------------------------------------------------*/
731
h264bsdCheckPpsId(strmData_t * pStrmData,u32 * picParamSetId)732 u32 h264bsdCheckPpsId(strmData_t *pStrmData, u32 *picParamSetId)
733 {
734
735 /* Variables */
736
737 u32 tmp, value;
738 strmData_t tmpStrmData[1];
739
740 /* Code */
741
742 ASSERT(pStrmData);
743
744 /* don't touch original stream position params */
745 *tmpStrmData = *pStrmData;
746
747 /* first_mb_in_slice */
748 tmp = h264bsdDecodeExpGolombUnsigned(tmpStrmData, &value);
749 if (tmp != HANTRO_OK)
750 return(tmp);
751
752 /* slice_type */
753 tmp = h264bsdDecodeExpGolombUnsigned(tmpStrmData, &value);
754 if (tmp != HANTRO_OK)
755 return(tmp);
756
757 tmp = h264bsdDecodeExpGolombUnsigned(tmpStrmData, &value);
758 if (tmp != HANTRO_OK)
759 return(tmp);
760 if (value >= MAX_NUM_PIC_PARAM_SETS)
761 return(HANTRO_NOK);
762
763 *picParamSetId = value;
764
765 return(HANTRO_OK);
766
767 }
768
769 /*------------------------------------------------------------------------------
770
771 Function: h264bsdCheckFrameNum
772
773 Functional description:
774 Peek value of frame_num from the slice header. Function does not
775 modify current stream positions but copies the stream data
776 structure to tmp structure which is used while accessing stream
777 data.
778
779 Inputs:
780 pStrmData pointer to stream data structure
781 maxFrameNum
782
783 Outputs:
784 frameNum value is stored here
785
786 Returns:
787 HANTRO_OK success
788 HANTRO_NOK invalid stream data
789
790 ------------------------------------------------------------------------------*/
791
h264bsdCheckFrameNum(strmData_t * pStrmData,u32 maxFrameNum,u32 * frameNum)792 u32 h264bsdCheckFrameNum(
793 strmData_t *pStrmData,
794 u32 maxFrameNum,
795 u32 *frameNum)
796 {
797
798 /* Variables */
799
800 u32 tmp, value, i;
801 strmData_t tmpStrmData[1];
802
803 /* Code */
804
805 ASSERT(pStrmData);
806 ASSERT(maxFrameNum);
807 ASSERT(frameNum);
808
809 /* don't touch original stream position params */
810 *tmpStrmData = *pStrmData;
811
812 /* skip first_mb_in_slice */
813 tmp = h264bsdDecodeExpGolombUnsigned(tmpStrmData, &value);
814 if (tmp != HANTRO_OK)
815 return(tmp);
816
817 /* skip slice_type */
818 tmp = h264bsdDecodeExpGolombUnsigned(tmpStrmData, &value);
819 if (tmp != HANTRO_OK)
820 return(tmp);
821
822 /* skip pic_parameter_set_id */
823 tmp = h264bsdDecodeExpGolombUnsigned(tmpStrmData, &value);
824 if (tmp != HANTRO_OK)
825 return(tmp);
826
827 /* log2(maxFrameNum) -> num bits to represent frame_num */
828 i = 0;
829 while (maxFrameNum >> i)
830 i++;
831 i--;
832
833 /* frame_num */
834 tmp = h264bsdGetBits(tmpStrmData, i);
835 if (tmp == END_OF_STREAM)
836 return(HANTRO_NOK);
837 *frameNum = tmp;
838
839 return(HANTRO_OK);
840
841 }
842
843 /*------------------------------------------------------------------------------
844
845 Function: h264bsdCheckIdrPicId
846
847 Functional description:
848 Peek value of idr_pic_id from the slice header. Function does not
849 modify current stream positions but copies the stream data
850 structure to tmp structure which is used while accessing stream
851 data.
852
853 Inputs:
854 pStrmData pointer to stream data structure
855 maxFrameNum max frame number from active SPS
856 nalUnitType type of the current NAL unit
857
858 Outputs:
859 idrPicId value is stored here
860
861 Returns:
862 HANTRO_OK success
863 HANTRO_NOK invalid stream data
864
865 ------------------------------------------------------------------------------*/
866
h264bsdCheckIdrPicId(strmData_t * pStrmData,u32 maxFrameNum,nalUnitType_e nalUnitType,u32 * idrPicId)867 u32 h264bsdCheckIdrPicId(
868 strmData_t *pStrmData,
869 u32 maxFrameNum,
870 nalUnitType_e nalUnitType,
871 u32 *idrPicId)
872 {
873
874 /* Variables */
875
876 u32 tmp, value, i;
877 strmData_t tmpStrmData[1];
878
879 /* Code */
880
881 ASSERT(pStrmData);
882 ASSERT(maxFrameNum);
883 ASSERT(idrPicId);
884
885 /* nalUnitType must be equal to 5 because otherwise idrPicId is not
886 * present */
887 if (nalUnitType != NAL_CODED_SLICE_IDR)
888 return(HANTRO_NOK);
889
890 /* don't touch original stream position params */
891 *tmpStrmData = *pStrmData;
892
893 /* skip first_mb_in_slice */
894 tmp = h264bsdDecodeExpGolombUnsigned(tmpStrmData, &value);
895 if (tmp != HANTRO_OK)
896 return(tmp);
897
898 /* skip slice_type */
899 tmp = h264bsdDecodeExpGolombUnsigned(tmpStrmData, &value);
900 if (tmp != HANTRO_OK)
901 return(tmp);
902
903 /* skip pic_parameter_set_id */
904 tmp = h264bsdDecodeExpGolombUnsigned(tmpStrmData, &value);
905 if (tmp != HANTRO_OK)
906 return(tmp);
907
908 /* log2(maxFrameNum) -> num bits to represent frame_num */
909 i = 0;
910 while (maxFrameNum >> i)
911 i++;
912 i--;
913
914 /* skip frame_num */
915 tmp = h264bsdGetBits(tmpStrmData, i);
916 if (tmp == END_OF_STREAM)
917 return(HANTRO_NOK);
918
919 /* idr_pic_id */
920 tmp = h264bsdDecodeExpGolombUnsigned(tmpStrmData, idrPicId);
921 if (tmp != HANTRO_OK)
922 return(tmp);
923
924 return(HANTRO_OK);
925
926 }
927
928 /*------------------------------------------------------------------------------
929
930 Function: h264bsdCheckPicOrderCntLsb
931
932 Functional description:
933 Peek value of pic_order_cnt_lsb from the slice header. Function
934 does not modify current stream positions but copies the stream
935 data structure to tmp structure which is used while accessing
936 stream data.
937
938 Inputs:
939 pStrmData pointer to stream data structure
940 pSeqParamSet pointer to active SPS
941 nalUnitType type of the current NAL unit
942
943 Outputs:
944 picOrderCntLsb value is stored here
945
946 Returns:
947 HANTRO_OK success
948 HANTRO_NOK invalid stream data
949
950 ------------------------------------------------------------------------------*/
951
h264bsdCheckPicOrderCntLsb(strmData_t * pStrmData,seqParamSet_t * pSeqParamSet,nalUnitType_e nalUnitType,u32 * picOrderCntLsb)952 u32 h264bsdCheckPicOrderCntLsb(
953 strmData_t *pStrmData,
954 seqParamSet_t *pSeqParamSet,
955 nalUnitType_e nalUnitType,
956 u32 *picOrderCntLsb)
957 {
958
959 /* Variables */
960
961 u32 tmp, value, i;
962 strmData_t tmpStrmData[1];
963
964 /* Code */
965
966 ASSERT(pStrmData);
967 ASSERT(pSeqParamSet);
968 ASSERT(picOrderCntLsb);
969
970 /* picOrderCntType must be equal to 0 */
971 ASSERT(pSeqParamSet->picOrderCntType == 0);
972 ASSERT(pSeqParamSet->maxFrameNum);
973 ASSERT(pSeqParamSet->maxPicOrderCntLsb);
974
975 /* don't touch original stream position params */
976 *tmpStrmData = *pStrmData;
977
978 /* skip first_mb_in_slice */
979 tmp = h264bsdDecodeExpGolombUnsigned(tmpStrmData, &value);
980 if (tmp != HANTRO_OK)
981 return(tmp);
982
983 /* skip slice_type */
984 tmp = h264bsdDecodeExpGolombUnsigned(tmpStrmData, &value);
985 if (tmp != HANTRO_OK)
986 return(tmp);
987
988 /* skip pic_parameter_set_id */
989 tmp = h264bsdDecodeExpGolombUnsigned(tmpStrmData, &value);
990 if (tmp != HANTRO_OK)
991 return(tmp);
992
993 /* log2(maxFrameNum) -> num bits to represent frame_num */
994 i = 0;
995 while (pSeqParamSet->maxFrameNum >> i)
996 i++;
997 i--;
998
999 /* skip frame_num */
1000 tmp = h264bsdGetBits(tmpStrmData, i);
1001 if (tmp == END_OF_STREAM)
1002 return(HANTRO_NOK);
1003
1004 /* skip idr_pic_id when necessary */
1005 if (nalUnitType == NAL_CODED_SLICE_IDR)
1006 {
1007 tmp = h264bsdDecodeExpGolombUnsigned(tmpStrmData, &value);
1008 if (tmp != HANTRO_OK)
1009 return(tmp);
1010 }
1011
1012 /* log2(maxPicOrderCntLsb) -> num bits to represent pic_order_cnt_lsb */
1013 i = 0;
1014 while (pSeqParamSet->maxPicOrderCntLsb >> i)
1015 i++;
1016 i--;
1017
1018 /* pic_order_cnt_lsb */
1019 tmp = h264bsdGetBits(tmpStrmData, i);
1020 if (tmp == END_OF_STREAM)
1021 return(HANTRO_NOK);
1022 *picOrderCntLsb = tmp;
1023
1024 return(HANTRO_OK);
1025
1026 }
1027
1028 /*------------------------------------------------------------------------------
1029
1030 Function: h264bsdCheckDeltaPicOrderCntBottom
1031
1032 Functional description:
1033 Peek value of delta_pic_order_cnt_bottom from the slice header.
1034 Function does not modify current stream positions but copies the
1035 stream data structure to tmp structure which is used while
1036 accessing stream data.
1037
1038 Inputs:
1039 pStrmData pointer to stream data structure
1040 pSeqParamSet pointer to active SPS
1041 nalUnitType type of the current NAL unit
1042
1043 Outputs:
1044 deltaPicOrderCntBottom value is stored here
1045
1046 Returns:
1047 HANTRO_OK success
1048 HANTRO_NOK invalid stream data
1049
1050 ------------------------------------------------------------------------------*/
1051
h264bsdCheckDeltaPicOrderCntBottom(strmData_t * pStrmData,seqParamSet_t * pSeqParamSet,nalUnitType_e nalUnitType,i32 * deltaPicOrderCntBottom)1052 u32 h264bsdCheckDeltaPicOrderCntBottom(
1053 strmData_t *pStrmData,
1054 seqParamSet_t *pSeqParamSet,
1055 nalUnitType_e nalUnitType,
1056 i32 *deltaPicOrderCntBottom)
1057 {
1058
1059 /* Variables */
1060
1061 u32 tmp, value, i;
1062 strmData_t tmpStrmData[1];
1063
1064 /* Code */
1065
1066 ASSERT(pStrmData);
1067 ASSERT(pSeqParamSet);
1068 ASSERT(deltaPicOrderCntBottom);
1069
1070 /* picOrderCntType must be equal to 0 and picOrderPresentFlag must be TRUE
1071 * */
1072 ASSERT(pSeqParamSet->picOrderCntType == 0);
1073 ASSERT(pSeqParamSet->maxFrameNum);
1074 ASSERT(pSeqParamSet->maxPicOrderCntLsb);
1075
1076 /* don't touch original stream position params */
1077 *tmpStrmData = *pStrmData;
1078
1079 /* skip first_mb_in_slice */
1080 tmp = h264bsdDecodeExpGolombUnsigned(tmpStrmData, &value);
1081 if (tmp != HANTRO_OK)
1082 return(tmp);
1083
1084 /* skip slice_type */
1085 tmp = h264bsdDecodeExpGolombUnsigned(tmpStrmData, &value);
1086 if (tmp != HANTRO_OK)
1087 return(tmp);
1088
1089 /* skip pic_parameter_set_id */
1090 tmp = h264bsdDecodeExpGolombUnsigned(tmpStrmData, &value);
1091 if (tmp != HANTRO_OK)
1092 return(tmp);
1093
1094 /* log2(maxFrameNum) -> num bits to represent frame_num */
1095 i = 0;
1096 while (pSeqParamSet->maxFrameNum >> i)
1097 i++;
1098 i--;
1099
1100 /* skip frame_num */
1101 tmp = h264bsdGetBits(tmpStrmData, i);
1102 if (tmp == END_OF_STREAM)
1103 return(HANTRO_NOK);
1104
1105 /* skip idr_pic_id when necessary */
1106 if (nalUnitType == NAL_CODED_SLICE_IDR)
1107 {
1108 tmp = h264bsdDecodeExpGolombUnsigned(tmpStrmData, &value);
1109 if (tmp != HANTRO_OK)
1110 return(tmp);
1111 }
1112
1113 /* log2(maxPicOrderCntLsb) -> num bits to represent pic_order_cnt_lsb */
1114 i = 0;
1115 while (pSeqParamSet->maxPicOrderCntLsb >> i)
1116 i++;
1117 i--;
1118
1119 /* skip pic_order_cnt_lsb */
1120 tmp = h264bsdGetBits(tmpStrmData, i);
1121 if (tmp == END_OF_STREAM)
1122 return(HANTRO_NOK);
1123
1124 /* delta_pic_order_cnt_bottom */
1125 tmp = h264bsdDecodeExpGolombSigned(tmpStrmData, deltaPicOrderCntBottom);
1126 if (tmp != HANTRO_OK)
1127 return(tmp);
1128
1129 return(HANTRO_OK);
1130
1131 }
1132
1133 /*------------------------------------------------------------------------------
1134
1135 Function: h264bsdCheckDeltaPicOrderCnt
1136
1137 Functional description:
1138 Peek values delta_pic_order_cnt[0] and delta_pic_order_cnt[1]
1139 from the slice header. Function does not modify current stream
1140 positions but copies the stream data structure to tmp structure
1141 which is used while accessing stream data.
1142
1143 Inputs:
1144 pStrmData pointer to stream data structure
1145 pSeqParamSet pointer to active SPS
1146 nalUnitType type of the current NAL unit
1147 picOrderPresentFlag flag indicating if delta_pic_order_cnt[1]
1148 is present in the stream
1149
1150 Outputs:
1151 deltaPicOrderCnt values are stored here
1152
1153 Returns:
1154 HANTRO_OK success
1155 HANTRO_NOK invalid stream data
1156
1157 ------------------------------------------------------------------------------*/
1158
h264bsdCheckDeltaPicOrderCnt(strmData_t * pStrmData,seqParamSet_t * pSeqParamSet,nalUnitType_e nalUnitType,u32 picOrderPresentFlag,i32 * deltaPicOrderCnt)1159 u32 h264bsdCheckDeltaPicOrderCnt(
1160 strmData_t *pStrmData,
1161 seqParamSet_t *pSeqParamSet,
1162 nalUnitType_e nalUnitType,
1163 u32 picOrderPresentFlag,
1164 i32 *deltaPicOrderCnt)
1165 {
1166
1167 /* Variables */
1168
1169 u32 tmp, value, i;
1170 strmData_t tmpStrmData[1];
1171
1172 /* Code */
1173
1174 ASSERT(pStrmData);
1175 ASSERT(pSeqParamSet);
1176 ASSERT(deltaPicOrderCnt);
1177
1178 /* picOrderCntType must be equal to 1 and deltaPicOrderAlwaysZeroFlag must
1179 * be FALSE */
1180 ASSERT(pSeqParamSet->picOrderCntType == 1);
1181 ASSERT(!pSeqParamSet->deltaPicOrderAlwaysZeroFlag);
1182 ASSERT(pSeqParamSet->maxFrameNum);
1183
1184 /* don't touch original stream position params */
1185 *tmpStrmData = *pStrmData;
1186
1187 /* skip first_mb_in_slice */
1188 tmp = h264bsdDecodeExpGolombUnsigned(tmpStrmData, &value);
1189 if (tmp != HANTRO_OK)
1190 return(tmp);
1191
1192 /* skip slice_type */
1193 tmp = h264bsdDecodeExpGolombUnsigned(tmpStrmData, &value);
1194 if (tmp != HANTRO_OK)
1195 return(tmp);
1196
1197 /* skip pic_parameter_set_id */
1198 tmp = h264bsdDecodeExpGolombUnsigned(tmpStrmData, &value);
1199 if (tmp != HANTRO_OK)
1200 return(tmp);
1201
1202 /* log2(maxFrameNum) -> num bits to represent frame_num */
1203 i = 0;
1204 while (pSeqParamSet->maxFrameNum >> i)
1205 i++;
1206 i--;
1207
1208 /* skip frame_num */
1209 tmp = h264bsdGetBits(tmpStrmData, i);
1210 if (tmp == END_OF_STREAM)
1211 return(HANTRO_NOK);
1212
1213 /* skip idr_pic_id when necessary */
1214 if (nalUnitType == NAL_CODED_SLICE_IDR)
1215 {
1216 tmp = h264bsdDecodeExpGolombUnsigned(tmpStrmData, &value);
1217 if (tmp != HANTRO_OK)
1218 return(tmp);
1219 }
1220
1221 /* delta_pic_order_cnt[0] */
1222 tmp = h264bsdDecodeExpGolombSigned(tmpStrmData, &deltaPicOrderCnt[0]);
1223 if (tmp != HANTRO_OK)
1224 return(tmp);
1225
1226 /* delta_pic_order_cnt[1] if present */
1227 if (picOrderPresentFlag)
1228 {
1229 tmp = h264bsdDecodeExpGolombSigned(tmpStrmData, &deltaPicOrderCnt[1]);
1230 if (tmp != HANTRO_OK)
1231 return(tmp);
1232 }
1233
1234 return(HANTRO_OK);
1235
1236 }
1237
1238 /*------------------------------------------------------------------------------
1239
1240 Function: h264bsdCheckRedundantPicCnt
1241
1242 Functional description:
1243 Peek value of redundant_pic_cnt from the slice header. Function
1244 does not modify current stream positions but copies the stream
1245 data structure to tmp structure which is used while accessing
1246 stream data.
1247
1248 Inputs:
1249 pStrmData pointer to stream data structure
1250 pSeqParamSet pointer to active SPS
1251 pPicParamSet pointer to active PPS
1252 nalUnitType type of the current NAL unit
1253
1254 Outputs:
1255 redundantPicCnt value is stored here
1256
1257 Returns:
1258 HANTRO_OK success
1259 HANTRO_NOK invalid stream data
1260
1261 ------------------------------------------------------------------------------*/
1262
h264bsdCheckRedundantPicCnt(strmData_t * pStrmData,seqParamSet_t * pSeqParamSet,picParamSet_t * pPicParamSet,nalUnitType_e nalUnitType,u32 * redundantPicCnt)1263 u32 h264bsdCheckRedundantPicCnt(
1264 strmData_t *pStrmData,
1265 seqParamSet_t *pSeqParamSet,
1266 picParamSet_t *pPicParamSet,
1267 nalUnitType_e nalUnitType,
1268 u32 *redundantPicCnt)
1269 {
1270
1271 /* Variables */
1272
1273 u32 tmp, value, i;
1274 i32 ivalue;
1275 strmData_t tmpStrmData[1];
1276
1277 /* Code */
1278
1279 ASSERT(pStrmData);
1280 ASSERT(pSeqParamSet);
1281 ASSERT(pPicParamSet);
1282 ASSERT(redundantPicCnt);
1283
1284 /* redundant_pic_cnt_flag must be TRUE */
1285 ASSERT(pPicParamSet->redundantPicCntPresentFlag);
1286 ASSERT(pSeqParamSet->maxFrameNum);
1287 ASSERT(pSeqParamSet->picOrderCntType > 0 ||
1288 pSeqParamSet->maxPicOrderCntLsb);
1289
1290 /* don't touch original stream position params */
1291 *tmpStrmData = *pStrmData;
1292
1293 /* skip first_mb_in_slice */
1294 tmp = h264bsdDecodeExpGolombUnsigned(tmpStrmData, &value);
1295 if (tmp != HANTRO_OK)
1296 return(tmp);
1297
1298 /* skip slice_type */
1299 tmp = h264bsdDecodeExpGolombUnsigned(tmpStrmData, &value);
1300 if (tmp != HANTRO_OK)
1301 return(tmp);
1302
1303 /* skip pic_parameter_set_id */
1304 tmp = h264bsdDecodeExpGolombUnsigned(tmpStrmData, &value);
1305 if (tmp != HANTRO_OK)
1306 return(tmp);
1307
1308 /* log2(maxFrameNum) -> num bits to represent frame_num */
1309 i = 0;
1310 while (pSeqParamSet->maxFrameNum >> i)
1311 i++;
1312 i--;
1313
1314 /* skip frame_num */
1315 tmp = h264bsdGetBits(tmpStrmData, i);
1316 if (tmp == END_OF_STREAM)
1317 return(HANTRO_NOK);
1318
1319 /* skip idr_pic_id when necessary */
1320 if (nalUnitType == NAL_CODED_SLICE_IDR)
1321 {
1322 tmp = h264bsdDecodeExpGolombUnsigned(tmpStrmData, &value);
1323 if (tmp != HANTRO_OK)
1324 return(tmp);
1325 }
1326
1327 if (pSeqParamSet->picOrderCntType == 0)
1328 {
1329 /* log2(maxPicOrderCntLsb) -> num bits to represent pic_order_cnt_lsb */
1330 i = 0;
1331 while (pSeqParamSet->maxPicOrderCntLsb >> i)
1332 i++;
1333 i--;
1334
1335 /* pic_order_cnt_lsb */
1336 tmp = h264bsdGetBits(tmpStrmData, i);
1337 if (tmp == END_OF_STREAM)
1338 return(HANTRO_NOK);
1339
1340 if (pPicParamSet->picOrderPresentFlag)
1341 {
1342 /* skip delta_pic_order_cnt_bottom */
1343 tmp = h264bsdDecodeExpGolombSigned(tmpStrmData, &ivalue);
1344 if (tmp != HANTRO_OK)
1345 return(tmp);
1346 }
1347 }
1348
1349 if (pSeqParamSet->picOrderCntType == 1 &&
1350 !pSeqParamSet->deltaPicOrderAlwaysZeroFlag)
1351 {
1352 /* delta_pic_order_cnt[0] */
1353 tmp = h264bsdDecodeExpGolombSigned(tmpStrmData, &ivalue);
1354 if (tmp != HANTRO_OK)
1355 return(tmp);
1356
1357 /* delta_pic_order_cnt[1] if present */
1358 if (pPicParamSet->picOrderPresentFlag)
1359 {
1360 tmp = h264bsdDecodeExpGolombSigned(tmpStrmData, &ivalue);
1361 if (tmp != HANTRO_OK)
1362 return(tmp);
1363 }
1364 }
1365
1366 /* redundant_pic_cnt */
1367 tmp = h264bsdDecodeExpGolombUnsigned(tmpStrmData, redundantPicCnt);
1368 if (tmp != HANTRO_OK)
1369 return(tmp);
1370
1371 return(HANTRO_OK);
1372
1373 }
1374
1375
1376 /*------------------------------------------------------------------------------
1377
1378 Function: h264bsdCheckPriorPicsFlag
1379
1380 Functional description:
1381 Peek value of no_output_of_prior_pics_flag from the slice header.
1382 Function does not modify current stream positions but copies
1383 the stream data structure to tmp structure which is used while
1384 accessing stream data.
1385
1386 Inputs:
1387 pStrmData pointer to stream data structure
1388 pSeqParamSet pointer to active SPS
1389 pPicParamSet pointer to active PPS
1390 nalUnitType type of the current NAL unit
1391
1392 Outputs:
1393 noOutputOfPriorPicsFlag value is stored here
1394
1395 Returns:
1396 HANTRO_OK success
1397 HANTRO_NOK invalid stream data
1398
1399 ------------------------------------------------------------------------------*/
1400 /*lint -e715 disable lint info nalUnitType not referenced */
h264bsdCheckPriorPicsFlag(u32 * noOutputOfPriorPicsFlag,const strmData_t * pStrmData,const seqParamSet_t * pSeqParamSet,const picParamSet_t * pPicParamSet,nalUnitType_e nalUnitType)1401 u32 h264bsdCheckPriorPicsFlag(u32 * noOutputOfPriorPicsFlag,
1402 const strmData_t * pStrmData,
1403 const seqParamSet_t * pSeqParamSet,
1404 const picParamSet_t * pPicParamSet,
1405 nalUnitType_e nalUnitType)
1406 {
1407 /* Variables */
1408
1409 u32 tmp, value, i;
1410 i32 ivalue;
1411 strmData_t tmpStrmData[1];
1412 UNUSED(nalUnitType);
1413
1414 /* Code */
1415
1416 ASSERT(pStrmData);
1417 ASSERT(pSeqParamSet);
1418 ASSERT(pPicParamSet);
1419 ASSERT(noOutputOfPriorPicsFlag);
1420
1421 /* must be IDR lsice */
1422 ASSERT(nalUnitType == NAL_CODED_SLICE_IDR);
1423
1424 /* don't touch original stream position params */
1425 *tmpStrmData = *pStrmData;
1426
1427 /* skip first_mb_in_slice */
1428 tmp = h264bsdDecodeExpGolombUnsigned(tmpStrmData, &value);
1429 if(tmp != HANTRO_OK)
1430 return (tmp);
1431
1432 /* slice_type */
1433 tmp = h264bsdDecodeExpGolombUnsigned(tmpStrmData, &value);
1434 if(tmp != HANTRO_OK)
1435 return (tmp);
1436
1437 /* skip pic_parameter_set_id */
1438 tmp = h264bsdDecodeExpGolombUnsigned(tmpStrmData, &value);
1439 if(tmp != HANTRO_OK)
1440 return (tmp);
1441
1442 /* log2(maxFrameNum) -> num bits to represent frame_num */
1443 i = 0;
1444 while(pSeqParamSet->maxFrameNum >> i)
1445 i++;
1446 i--;
1447
1448 /* skip frame_num */
1449 tmp = h264bsdGetBits(tmpStrmData, i);
1450 if(tmp == END_OF_STREAM)
1451 return (HANTRO_NOK);
1452
1453 /* skip idr_pic_id */
1454 tmp = h264bsdDecodeExpGolombUnsigned(tmpStrmData, &value);
1455 if(tmp != HANTRO_OK)
1456 return (tmp);
1457
1458 if(pSeqParamSet->picOrderCntType == 0)
1459 {
1460 /* log2(maxPicOrderCntLsb) -> num bits to represent pic_order_cnt_lsb */
1461 i = 0;
1462 while(pSeqParamSet->maxPicOrderCntLsb >> i)
1463 i++;
1464 i--;
1465
1466 /* skip pic_order_cnt_lsb */
1467 tmp = h264bsdGetBits(tmpStrmData, i);
1468 if(tmp == END_OF_STREAM)
1469 return (HANTRO_NOK);
1470
1471 if(pPicParamSet->picOrderPresentFlag)
1472 {
1473 /* skip delta_pic_order_cnt_bottom */
1474 tmp = h264bsdDecodeExpGolombSigned(tmpStrmData, &ivalue);
1475 if(tmp != HANTRO_OK)
1476 return (tmp);
1477 }
1478 }
1479
1480 if(pSeqParamSet->picOrderCntType == 1 &&
1481 !pSeqParamSet->deltaPicOrderAlwaysZeroFlag)
1482 {
1483 /* skip delta_pic_order_cnt[0] */
1484 tmp = h264bsdDecodeExpGolombSigned(tmpStrmData, &ivalue);
1485 if(tmp != HANTRO_OK)
1486 return (tmp);
1487
1488 /* skip delta_pic_order_cnt[1] if present */
1489 if(pPicParamSet->picOrderPresentFlag)
1490 {
1491 tmp = h264bsdDecodeExpGolombSigned(tmpStrmData, &ivalue);
1492 if(tmp != HANTRO_OK)
1493 return (tmp);
1494 }
1495 }
1496
1497 /* skip redundant_pic_cnt */
1498 if(pPicParamSet->redundantPicCntPresentFlag)
1499 {
1500 tmp = h264bsdDecodeExpGolombUnsigned(tmpStrmData, &value);
1501 if(tmp != HANTRO_OK)
1502 return (tmp);
1503 }
1504
1505 *noOutputOfPriorPicsFlag = h264bsdGetBits(tmpStrmData, 1);
1506 if(*noOutputOfPriorPicsFlag == END_OF_STREAM)
1507 return (HANTRO_NOK);
1508
1509 return (HANTRO_OK);
1510
1511 }
1512 /*lint +e715 */
1513
1514
1515