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 h264bsdDecodeMacroblockLayer
27 h264bsdMbPartPredMode
28 h264bsdNumMbPart
29 h264bsdNumSubMbPart
30 DecodeMbPred
31 DecodeSubMbPred
32 DecodeResidual
33 DetermineNc
34 CbpIntra16x16
35 h264bsdPredModeIntra16x16
36 h264bsdDecodeMacroblock
37 ProcessResidual
38 h264bsdSubMbPartMode
39
40 ------------------------------------------------------------------------------*/
41
42 /*------------------------------------------------------------------------------
43 1. Include headers
44 ------------------------------------------------------------------------------*/
45
46 #include "h264bsd_macroblock_layer.h"
47 #include "h264bsd_slice_header.h"
48 #include "h264bsd_util.h"
49 #include "h264bsd_vlc.h"
50 #include "h264bsd_cavlc.h"
51 #include "h264bsd_nal_unit.h"
52 #include "h264bsd_neighbour.h"
53 #include "h264bsd_transform.h"
54 #include "h264bsd_intra_prediction.h"
55 #include "h264bsd_inter_prediction.h"
56
57 #ifdef H264DEC_OMXDL
58 #include "omxtypes.h"
59 #include "omxVC.h"
60 #include "armVC.h"
61 #endif /* H264DEC_OMXDL */
62
63 /*------------------------------------------------------------------------------
64 2. External compiler flags
65 --------------------------------------------------------------------------------
66
67 --------------------------------------------------------------------------------
68 3. Module defines
69 ------------------------------------------------------------------------------*/
70 #ifdef H264DEC_OMXDL
71 static const u32 chromaIndex[8] = { 256, 260, 288, 292, 320, 324, 352, 356 };
72 static const u32 lumaIndex[16] = { 0, 4, 64, 68,
73 8, 12, 72, 76,
74 128, 132, 192, 196,
75 136, 140, 200, 204 };
76 #endif
77 /* mapping of dc coefficients array to luma blocks */
78 static const u32 dcCoeffIndex[16] =
79 {0, 1, 4, 5, 2, 3, 6, 7, 8, 9, 12, 13, 10, 11, 14, 15};
80
81 /*------------------------------------------------------------------------------
82 4. Local function prototypes
83 ------------------------------------------------------------------------------*/
84
85 static u32 DecodeMbPred(strmData_t *pStrmData, mbPred_t *pMbPred,
86 mbType_e mbType, u32 numRefIdxActive);
87 static u32 DecodeSubMbPred(strmData_t *pStrmData, subMbPred_t *pSubMbPred,
88 mbType_e mbType, u32 numRefIdxActive);
89 static u32 DecodeResidual(strmData_t *pStrmData, residual_t *pResidual,
90 mbStorage_t *pMb, mbType_e mbType, u32 codedBlockPattern);
91
92 #ifdef H264DEC_OMXDL
93 static u32 DetermineNc(mbStorage_t *pMb, u32 blockIndex, u8 *pTotalCoeff);
94 #else
95 static u32 DetermineNc(mbStorage_t *pMb, u32 blockIndex, i16 *pTotalCoeff);
96 #endif
97
98 static u32 CbpIntra16x16(mbType_e mbType);
99 #ifdef H264DEC_OMXDL
100 static u32 ProcessIntra4x4Residual(mbStorage_t *pMb, u8 *data, u32 constrainedIntraPred,
101 macroblockLayer_t *mbLayer, const u8 **pSrc, image_t *image);
102 static u32 ProcessChromaResidual(mbStorage_t *pMb, u8 *data, const u8 **pSrc );
103 static u32 ProcessIntra16x16Residual(mbStorage_t *pMb, u8 *data, u32 constrainedIntraPred,
104 u32 intraChromaPredMode, const u8 **pSrc, image_t *image);
105
106
107 #else
108 static u32 ProcessResidual(mbStorage_t *pMb, i32 residualLevel[][16], u32 *);
109 #endif
110
111 /*------------------------------------------------------------------------------
112
113 Function name: h264bsdDecodeMacroblockLayer
114
115 Functional description:
116 Parse macroblock specific information from bit stream.
117
118 Inputs:
119 pStrmData pointer to stream data structure
120 pMb pointer to macroblock storage structure
121 sliceType type of the current slice
122 numRefIdxActive maximum reference index
123
124 Outputs:
125 pMbLayer stores the macroblock data parsed from stream
126
127 Returns:
128 HANTRO_OK success
129 HANTRO_NOK end of stream or error in stream
130
131 ------------------------------------------------------------------------------*/
132
h264bsdDecodeMacroblockLayer(strmData_t * pStrmData,macroblockLayer_t * pMbLayer,mbStorage_t * pMb,u32 sliceType,u32 numRefIdxActive)133 u32 h264bsdDecodeMacroblockLayer(strmData_t *pStrmData,
134 macroblockLayer_t *pMbLayer, mbStorage_t *pMb, u32 sliceType,
135 u32 numRefIdxActive)
136 {
137
138 /* Variables */
139
140 u32 tmp, i, value;
141 i32 itmp;
142 mbPartPredMode_e partMode;
143
144 /* Code */
145
146 ASSERT(pStrmData);
147 ASSERT(pMbLayer);
148
149 #ifdef H264DEC_NEON
150 h264bsdClearMbLayer(pMbLayer, ((sizeof(macroblockLayer_t) + 63) & ~0x3F));
151 #else
152 H264SwDecMemset(pMbLayer, 0, sizeof(macroblockLayer_t));
153 #endif
154
155 tmp = h264bsdDecodeExpGolombUnsigned(pStrmData, &value);
156
157 if (IS_I_SLICE(sliceType))
158 {
159 if ((value + 6) > 31 || tmp != HANTRO_OK)
160 return(HANTRO_NOK);
161 pMbLayer->mbType = (mbType_e)(value + 6);
162 }
163 else
164 {
165 if ((value + 1) > 31 || tmp != HANTRO_OK)
166 return(HANTRO_NOK);
167 pMbLayer->mbType = (mbType_e)(value + 1);
168 }
169
170 if (pMbLayer->mbType == I_PCM)
171 {
172 i32 *level;
173 while( !h264bsdIsByteAligned(pStrmData) )
174 {
175 /* pcm_alignment_zero_bit */
176 tmp = h264bsdGetBits(pStrmData, 1);
177 if (tmp)
178 return(HANTRO_NOK);
179 }
180
181 level = pMbLayer->residual.level[0];
182 for (i = 0; i < 384; i++)
183 {
184 value = h264bsdGetBits(pStrmData, 8);
185 if (value == END_OF_STREAM)
186 return(HANTRO_NOK);
187 *level++ = (i32)value;
188 }
189 }
190 else
191 {
192 partMode = h264bsdMbPartPredMode(pMbLayer->mbType);
193 if ( (partMode == PRED_MODE_INTER) &&
194 (h264bsdNumMbPart(pMbLayer->mbType) == 4) )
195 {
196 tmp = DecodeSubMbPred(pStrmData, &pMbLayer->subMbPred,
197 pMbLayer->mbType, numRefIdxActive);
198 }
199 else
200 {
201 tmp = DecodeMbPred(pStrmData, &pMbLayer->mbPred,
202 pMbLayer->mbType, numRefIdxActive);
203 }
204 if (tmp != HANTRO_OK)
205 return(tmp);
206
207 if (partMode != PRED_MODE_INTRA16x16)
208 {
209 tmp = h264bsdDecodeExpGolombMapped(pStrmData, &value,
210 (u32)(partMode == PRED_MODE_INTRA4x4));
211 if (tmp != HANTRO_OK)
212 return(tmp);
213 pMbLayer->codedBlockPattern = value;
214 }
215 else
216 {
217 pMbLayer->codedBlockPattern = CbpIntra16x16(pMbLayer->mbType);
218 }
219
220 if ( pMbLayer->codedBlockPattern ||
221 (partMode == PRED_MODE_INTRA16x16) )
222 {
223 tmp = h264bsdDecodeExpGolombSigned(pStrmData, &itmp);
224 if (tmp != HANTRO_OK || (itmp < -26) || (itmp > 25) )
225 return(HANTRO_NOK);
226 pMbLayer->mbQpDelta = itmp;
227
228 tmp = DecodeResidual(pStrmData, &pMbLayer->residual, pMb,
229 pMbLayer->mbType, pMbLayer->codedBlockPattern);
230
231 pStrmData->strmBuffReadBits =
232 (u32)(pStrmData->pStrmCurrPos - pStrmData->pStrmBuffStart) * 8 +
233 pStrmData->bitPosInWord;
234
235 if (tmp != HANTRO_OK)
236 return(tmp);
237 }
238 }
239
240 return(HANTRO_OK);
241
242 }
243
244 /*------------------------------------------------------------------------------
245
246 Function: h264bsdMbPartPredMode
247
248 Functional description:
249 Returns the prediction mode of a macroblock type
250
251 ------------------------------------------------------------------------------*/
252
h264bsdMbPartPredMode(mbType_e mbType)253 mbPartPredMode_e h264bsdMbPartPredMode(mbType_e mbType)
254 {
255
256 /* Variables */
257
258
259 /* Code */
260
261 ASSERT(mbType <= 31);
262
263 if ((mbType <= P_8x8ref0))
264 return(PRED_MODE_INTER);
265 else if (mbType == I_4x4)
266 return(PRED_MODE_INTRA4x4);
267 else
268 return(PRED_MODE_INTRA16x16);
269
270 }
271
272 /*------------------------------------------------------------------------------
273
274 Function: h264bsdNumMbPart
275
276 Functional description:
277 Returns the amount of macroblock partitions in a macroblock type
278
279 ------------------------------------------------------------------------------*/
280
h264bsdNumMbPart(mbType_e mbType)281 u32 h264bsdNumMbPart(mbType_e mbType)
282 {
283
284 /* Variables */
285
286
287 /* Code */
288
289 ASSERT(h264bsdMbPartPredMode(mbType) == PRED_MODE_INTER);
290
291 switch (mbType)
292 {
293 case P_L0_16x16:
294 case P_Skip:
295 return(1);
296
297 case P_L0_L0_16x8:
298 case P_L0_L0_8x16:
299 return(2);
300
301 /* P_8x8 or P_8x8ref0 */
302 default:
303 return(4);
304 }
305
306 }
307
308 /*------------------------------------------------------------------------------
309
310 Function: h264bsdNumSubMbPart
311
312 Functional description:
313 Returns the amount of sub-partitions in a sub-macroblock type
314
315 ------------------------------------------------------------------------------*/
316
h264bsdNumSubMbPart(subMbType_e subMbType)317 u32 h264bsdNumSubMbPart(subMbType_e subMbType)
318 {
319
320 /* Variables */
321
322
323 /* Code */
324
325 ASSERT(subMbType <= P_L0_4x4);
326
327 switch (subMbType)
328 {
329 case P_L0_8x8:
330 return(1);
331
332 case P_L0_8x4:
333 case P_L0_4x8:
334 return(2);
335
336 /* P_L0_4x4 */
337 default:
338 return(4);
339 }
340
341 }
342
343 /*------------------------------------------------------------------------------
344
345 Function: DecodeMbPred
346
347 Functional description:
348 Parse macroblock prediction information from bit stream and store
349 in 'pMbPred'.
350
351 ------------------------------------------------------------------------------*/
352
DecodeMbPred(strmData_t * pStrmData,mbPred_t * pMbPred,mbType_e mbType,u32 numRefIdxActive)353 u32 DecodeMbPred(strmData_t *pStrmData, mbPred_t *pMbPred, mbType_e mbType,
354 u32 numRefIdxActive)
355 {
356
357 /* Variables */
358
359 u32 tmp, i, j, value;
360 i32 itmp;
361
362 /* Code */
363
364 ASSERT(pStrmData);
365 ASSERT(pMbPred);
366
367 switch (h264bsdMbPartPredMode(mbType))
368 {
369 case PRED_MODE_INTER: /* PRED_MODE_INTER */
370 if (numRefIdxActive > 1)
371 {
372 for (i = h264bsdNumMbPart(mbType), j = 0; i--; j++)
373 {
374 tmp = h264bsdDecodeExpGolombTruncated(pStrmData, &value,
375 (u32)(numRefIdxActive > 2));
376 if (tmp != HANTRO_OK || value >= numRefIdxActive)
377 return(HANTRO_NOK);
378
379 pMbPred->refIdxL0[j] = value;
380 }
381 }
382
383 for (i = h264bsdNumMbPart(mbType), j = 0; i--; j++)
384 {
385 tmp = h264bsdDecodeExpGolombSigned(pStrmData, &itmp);
386 if (tmp != HANTRO_OK)
387 return(tmp);
388 pMbPred->mvdL0[j].hor = (i16)itmp;
389
390 tmp = h264bsdDecodeExpGolombSigned(pStrmData, &itmp);
391 if (tmp != HANTRO_OK)
392 return(tmp);
393 pMbPred->mvdL0[j].ver = (i16)itmp;
394 }
395 break;
396
397 case PRED_MODE_INTRA4x4:
398 for (itmp = 0, i = 0; itmp < 2; itmp++)
399 {
400 value = h264bsdShowBits32(pStrmData);
401 tmp = 0;
402 for (j = 8; j--; i++)
403 {
404 pMbPred->prevIntra4x4PredModeFlag[i] =
405 value & 0x80000000 ? HANTRO_TRUE : HANTRO_FALSE;
406 value <<= 1;
407 if (!pMbPred->prevIntra4x4PredModeFlag[i])
408 {
409 pMbPred->remIntra4x4PredMode[i] = value>>29;
410 value <<= 3;
411 tmp++;
412 }
413 }
414 if (h264bsdFlushBits(pStrmData, 8 + 3*tmp) == END_OF_STREAM)
415 return(HANTRO_NOK);
416 }
417 /* fall-through */
418
419 case PRED_MODE_INTRA16x16:
420 tmp = h264bsdDecodeExpGolombUnsigned(pStrmData, &value);
421 if (tmp != HANTRO_OK || value > 3)
422 return(HANTRO_NOK);
423 pMbPred->intraChromaPredMode = value;
424 break;
425 }
426
427 return(HANTRO_OK);
428
429 }
430
431 /*------------------------------------------------------------------------------
432
433 Function: DecodeSubMbPred
434
435 Functional description:
436 Parse sub-macroblock prediction information from bit stream and
437 store in 'pMbPred'.
438
439 ------------------------------------------------------------------------------*/
440
DecodeSubMbPred(strmData_t * pStrmData,subMbPred_t * pSubMbPred,mbType_e mbType,u32 numRefIdxActive)441 u32 DecodeSubMbPred(strmData_t *pStrmData, subMbPred_t *pSubMbPred,
442 mbType_e mbType, u32 numRefIdxActive)
443 {
444
445 /* Variables */
446
447 u32 tmp, i, j, value;
448 i32 itmp;
449
450 /* Code */
451
452 ASSERT(pStrmData);
453 ASSERT(pSubMbPred);
454 ASSERT(h264bsdMbPartPredMode(mbType) == PRED_MODE_INTER);
455
456 for (i = 0; i < 4; i++)
457 {
458 tmp = h264bsdDecodeExpGolombUnsigned(pStrmData, &value);
459 if (tmp != HANTRO_OK || value > 3)
460 return(HANTRO_NOK);
461 pSubMbPred->subMbType[i] = (subMbType_e)value;
462 }
463
464 if ( (numRefIdxActive > 1) && (mbType != P_8x8ref0) )
465 {
466 for (i = 0; i < 4; i++)
467 {
468 tmp = h264bsdDecodeExpGolombTruncated(pStrmData, &value,
469 (u32)(numRefIdxActive > 2));
470 if (tmp != HANTRO_OK || value >= numRefIdxActive)
471 return(HANTRO_NOK);
472 pSubMbPred->refIdxL0[i] = value;
473 }
474 }
475
476 for (i = 0; i < 4; i++)
477 {
478 j = 0;
479 for (value = h264bsdNumSubMbPart(pSubMbPred->subMbType[i]);
480 value--; j++)
481 {
482 tmp = h264bsdDecodeExpGolombSigned(pStrmData, &itmp);
483 if (tmp != HANTRO_OK)
484 return(tmp);
485 pSubMbPred->mvdL0[i][j].hor = (i16)itmp;
486
487 tmp = h264bsdDecodeExpGolombSigned(pStrmData, &itmp);
488 if (tmp != HANTRO_OK)
489 return(tmp);
490 pSubMbPred->mvdL0[i][j].ver = (i16)itmp;
491 }
492 }
493
494 return(HANTRO_OK);
495
496 }
497
498 #ifdef H264DEC_OMXDL
499 /*------------------------------------------------------------------------------
500
501 Function: DecodeResidual
502
503 Functional description:
504 Parse residual information from bit stream and store in 'pResidual'.
505
506 ------------------------------------------------------------------------------*/
507
DecodeResidual(strmData_t * pStrmData,residual_t * pResidual,mbStorage_t * pMb,mbType_e mbType,u32 codedBlockPattern)508 u32 DecodeResidual(strmData_t *pStrmData, residual_t *pResidual,
509 mbStorage_t *pMb, mbType_e mbType, u32 codedBlockPattern)
510 {
511
512 /* Variables */
513
514 u32 i, j;
515 u32 blockCoded;
516 u32 blockIndex;
517 u32 is16x16;
518 OMX_INT nc;
519 OMXResult omxRes;
520 OMX_U8 *pPosCoefBuf;
521
522
523 /* Code */
524
525 ASSERT(pStrmData);
526 ASSERT(pResidual);
527
528 pPosCoefBuf = pResidual->posCoefBuf;
529
530 /* luma DC is at index 24 */
531 if (h264bsdMbPartPredMode(mbType) == PRED_MODE_INTRA16x16)
532 {
533 nc = (OMX_INT)DetermineNc(pMb, 0, pResidual->totalCoeff);
534 #ifndef H264DEC_NEON
535 omxRes = omxVCM4P10_DecodeCoeffsToPairCAVLC(
536 (const OMX_U8 **) (&pStrmData->pStrmCurrPos),
537 (OMX_S32*) (&pStrmData->bitPosInWord),
538 &pResidual->totalCoeff[24],
539 &pPosCoefBuf,
540 nc,
541 16);
542 #else
543 omxRes = armVCM4P10_DecodeCoeffsToPair(
544 (const OMX_U8 **) (&pStrmData->pStrmCurrPos),
545 (OMX_S32*) (&pStrmData->bitPosInWord),
546 &pResidual->totalCoeff[24],
547 &pPosCoefBuf,
548 nc,
549 16);
550 #endif
551 if (omxRes != OMX_Sts_NoErr)
552 return(HANTRO_NOK);
553 is16x16 = HANTRO_TRUE;
554 }
555 else
556 is16x16 = HANTRO_FALSE;
557
558 for (i = 4, blockIndex = 0; i--;)
559 {
560 /* luma cbp in bits 0-3 */
561 blockCoded = codedBlockPattern & 0x1;
562 codedBlockPattern >>= 1;
563 if (blockCoded)
564 {
565 for (j = 4; j--; blockIndex++)
566 {
567 nc = (OMX_INT)DetermineNc(pMb,blockIndex,pResidual->totalCoeff);
568 if (is16x16)
569 {
570 #ifndef H264DEC_NEON
571 omxRes = omxVCM4P10_DecodeCoeffsToPairCAVLC(
572 (const OMX_U8 **) (&pStrmData->pStrmCurrPos),
573 (OMX_S32*) (&pStrmData->bitPosInWord),
574 &pResidual->totalCoeff[blockIndex],
575 &pPosCoefBuf,
576 nc,
577 15);
578 #else
579 omxRes = armVCM4P10_DecodeCoeffsToPair(
580 (const OMX_U8 **) (&pStrmData->pStrmCurrPos),
581 (OMX_S32*) (&pStrmData->bitPosInWord),
582 &pResidual->totalCoeff[blockIndex],
583 &pPosCoefBuf,
584 nc,
585 15);
586 #endif
587 }
588 else
589 {
590 #ifndef H264DEC_NEON
591 omxRes = omxVCM4P10_DecodeCoeffsToPairCAVLC(
592 (const OMX_U8 **) (&pStrmData->pStrmCurrPos),
593 (OMX_S32*) (&pStrmData->bitPosInWord),
594 &pResidual->totalCoeff[blockIndex],
595 &pPosCoefBuf,
596 nc,
597 16);
598 #else
599 omxRes = armVCM4P10_DecodeCoeffsToPair(
600 (const OMX_U8 **) (&pStrmData->pStrmCurrPos),
601 (OMX_S32*) (&pStrmData->bitPosInWord),
602 &pResidual->totalCoeff[blockIndex],
603 &pPosCoefBuf,
604 nc,
605 16);
606 #endif
607 }
608 if (omxRes != OMX_Sts_NoErr)
609 return(HANTRO_NOK);
610 }
611 }
612 else
613 blockIndex += 4;
614 }
615
616 /* chroma DC block are at indices 25 and 26 */
617 blockCoded = codedBlockPattern & 0x3;
618 if (blockCoded)
619 {
620 #ifndef H264DEC_NEON
621 omxRes = omxVCM4P10_DecodeChromaDcCoeffsToPairCAVLC(
622 (const OMX_U8**) (&pStrmData->pStrmCurrPos),
623 (OMX_S32*) (&pStrmData->bitPosInWord),
624 &pResidual->totalCoeff[25],
625 &pPosCoefBuf);
626 #else
627 omxRes = armVCM4P10_DecodeCoeffsToPair(
628 (const OMX_U8**) (&pStrmData->pStrmCurrPos),
629 (OMX_S32*) (&pStrmData->bitPosInWord),
630 &pResidual->totalCoeff[25],
631 &pPosCoefBuf,
632 17,
633 4);
634 #endif
635 if (omxRes != OMX_Sts_NoErr)
636 return(HANTRO_NOK);
637 #ifndef H264DEC_NEON
638 omxRes = omxVCM4P10_DecodeChromaDcCoeffsToPairCAVLC(
639 (const OMX_U8**) (&pStrmData->pStrmCurrPos),
640 (OMX_S32*) (&pStrmData->bitPosInWord),
641 &pResidual->totalCoeff[26],
642 &pPosCoefBuf);
643 #else
644 omxRes = armVCM4P10_DecodeCoeffsToPair(
645 (const OMX_U8**) (&pStrmData->pStrmCurrPos),
646 (OMX_S32*) (&pStrmData->bitPosInWord),
647 &pResidual->totalCoeff[26],
648 &pPosCoefBuf,
649 17,
650 4);
651 #endif
652 if (omxRes != OMX_Sts_NoErr)
653 return(HANTRO_NOK);
654 }
655
656 /* chroma AC */
657 blockCoded = codedBlockPattern & 0x2;
658 if (blockCoded)
659 {
660 for (i = 8; i--;blockIndex++)
661 {
662 nc = (OMX_INT)DetermineNc(pMb, blockIndex, pResidual->totalCoeff);
663 #ifndef H264DEC_NEON
664 omxRes = omxVCM4P10_DecodeCoeffsToPairCAVLC(
665 (const OMX_U8 **) (&pStrmData->pStrmCurrPos),
666 (OMX_S32*) (&pStrmData->bitPosInWord),
667 &pResidual->totalCoeff[blockIndex],
668 &pPosCoefBuf,
669 nc,
670 15);
671 #else
672 omxRes = armVCM4P10_DecodeCoeffsToPair(
673 (const OMX_U8 **) (&pStrmData->pStrmCurrPos),
674 (OMX_S32*) (&pStrmData->bitPosInWord),
675 &pResidual->totalCoeff[blockIndex],
676 &pPosCoefBuf,
677 nc,
678 15);
679 #endif
680 if (omxRes != OMX_Sts_NoErr)
681 return(HANTRO_NOK);
682 }
683 }
684
685 return(HANTRO_OK);
686
687 }
688
689 #else
690 /*------------------------------------------------------------------------------
691
692 Function: DecodeResidual
693
694 Functional description:
695 Parse residual information from bit stream and store in 'pResidual'.
696
697 ------------------------------------------------------------------------------*/
698
DecodeResidual(strmData_t * pStrmData,residual_t * pResidual,mbStorage_t * pMb,mbType_e mbType,u32 codedBlockPattern)699 u32 DecodeResidual(strmData_t *pStrmData, residual_t *pResidual,
700 mbStorage_t *pMb, mbType_e mbType, u32 codedBlockPattern)
701 {
702
703 /* Variables */
704
705 u32 i, j, tmp;
706 i32 nc;
707 u32 blockCoded;
708 u32 blockIndex;
709 u32 is16x16;
710 i32 (*level)[16];
711
712 /* Code */
713
714 ASSERT(pStrmData);
715 ASSERT(pResidual);
716
717 level = pResidual->level;
718
719 /* luma DC is at index 24 */
720 if (h264bsdMbPartPredMode(mbType) == PRED_MODE_INTRA16x16)
721 {
722 nc = (i32)DetermineNc(pMb, 0, pResidual->totalCoeff);
723 tmp = h264bsdDecodeResidualBlockCavlc(pStrmData, level[24], nc, 16);
724 if ((tmp & 0xF) != HANTRO_OK)
725 return(tmp);
726 pResidual->totalCoeff[24] = (tmp >> 4) & 0xFF;
727 is16x16 = HANTRO_TRUE;
728 }
729 else
730 is16x16 = HANTRO_FALSE;
731
732 for (i = 4, blockIndex = 0; i--;)
733 {
734 /* luma cbp in bits 0-3 */
735 blockCoded = codedBlockPattern & 0x1;
736 codedBlockPattern >>= 1;
737 if (blockCoded)
738 {
739 for (j = 4; j--; blockIndex++)
740 {
741 nc = (i32)DetermineNc(pMb, blockIndex, pResidual->totalCoeff);
742 if (is16x16)
743 {
744 tmp = h264bsdDecodeResidualBlockCavlc(pStrmData,
745 level[blockIndex] + 1, nc, 15);
746 pResidual->coeffMap[blockIndex] = tmp >> 15;
747 }
748 else
749 {
750 tmp = h264bsdDecodeResidualBlockCavlc(pStrmData,
751 level[blockIndex], nc, 16);
752 pResidual->coeffMap[blockIndex] = tmp >> 16;
753 }
754 if ((tmp & 0xF) != HANTRO_OK)
755 return(tmp);
756 pResidual->totalCoeff[blockIndex] = (tmp >> 4) & 0xFF;
757 }
758 }
759 else
760 blockIndex += 4;
761 }
762
763 /* chroma DC block are at indices 25 and 26 */
764 blockCoded = codedBlockPattern & 0x3;
765 if (blockCoded)
766 {
767 tmp = h264bsdDecodeResidualBlockCavlc(pStrmData, level[25], -1, 4);
768 if ((tmp & 0xF) != HANTRO_OK)
769 return(tmp);
770 pResidual->totalCoeff[25] = (tmp >> 4) & 0xFF;
771 tmp = h264bsdDecodeResidualBlockCavlc(pStrmData, level[25]+4, -1, 4);
772 if ((tmp & 0xF) != HANTRO_OK)
773 return(tmp);
774 pResidual->totalCoeff[26] = (tmp >> 4) & 0xFF;
775 }
776
777 /* chroma AC */
778 blockCoded = codedBlockPattern & 0x2;
779 if (blockCoded)
780 {
781 for (i = 8; i--;blockIndex++)
782 {
783 nc = (i32)DetermineNc(pMb, blockIndex, pResidual->totalCoeff);
784 tmp = h264bsdDecodeResidualBlockCavlc(pStrmData,
785 level[blockIndex] + 1, nc, 15);
786 if ((tmp & 0xF) != HANTRO_OK)
787 return(tmp);
788 pResidual->totalCoeff[blockIndex] = (tmp >> 4) & 0xFF;
789 pResidual->coeffMap[blockIndex] = (tmp >> 15);
790 }
791 }
792
793 return(HANTRO_OK);
794
795 }
796 #endif
797
798 /*------------------------------------------------------------------------------
799
800 Function: DetermineNc
801
802 Functional description:
803 Returns the nC of a block.
804
805 ------------------------------------------------------------------------------*/
806 #ifdef H264DEC_OMXDL
DetermineNc(mbStorage_t * pMb,u32 blockIndex,u8 * pTotalCoeff)807 u32 DetermineNc(mbStorage_t *pMb, u32 blockIndex, u8 *pTotalCoeff)
808 #else
809 u32 DetermineNc(mbStorage_t *pMb, u32 blockIndex, i16 *pTotalCoeff)
810 #endif
811 {
812 /*lint -e702 */
813 /* Variables */
814
815 u32 tmp;
816 i32 n;
817 const neighbour_t *neighbourA, *neighbourB;
818 u8 neighbourAindex, neighbourBindex;
819
820 /* Code */
821
822 ASSERT(blockIndex < 24);
823
824 /* if neighbour block belongs to current macroblock totalCoeff array
825 * mbStorage has not been set/updated yet -> use pTotalCoeff */
826 neighbourA = h264bsdNeighbour4x4BlockA(blockIndex);
827 neighbourB = h264bsdNeighbour4x4BlockB(blockIndex);
828 neighbourAindex = neighbourA->index;
829 neighbourBindex = neighbourB->index;
830 if (neighbourA->mb == MB_CURR && neighbourB->mb == MB_CURR)
831 {
832 n = (pTotalCoeff[neighbourAindex] +
833 pTotalCoeff[neighbourBindex] + 1)>>1;
834 }
835 else if (neighbourA->mb == MB_CURR)
836 {
837 n = pTotalCoeff[neighbourAindex];
838 if (h264bsdIsNeighbourAvailable(pMb, pMb->mbB))
839 {
840 n = (n + pMb->mbB->totalCoeff[neighbourBindex] + 1) >> 1;
841 }
842 }
843 else if (neighbourB->mb == MB_CURR)
844 {
845 n = pTotalCoeff[neighbourBindex];
846 if (h264bsdIsNeighbourAvailable(pMb, pMb->mbA))
847 {
848 n = (n + pMb->mbA->totalCoeff[neighbourAindex] + 1) >> 1;
849 }
850 }
851 else
852 {
853 n = tmp = 0;
854 if (h264bsdIsNeighbourAvailable(pMb, pMb->mbA))
855 {
856 n = pMb->mbA->totalCoeff[neighbourAindex];
857 tmp = 1;
858 }
859 if (h264bsdIsNeighbourAvailable(pMb, pMb->mbB))
860 {
861 if (tmp)
862 n = (n + pMb->mbB->totalCoeff[neighbourBindex] + 1) >> 1;
863 else
864 n = pMb->mbB->totalCoeff[neighbourBindex];
865 }
866 }
867 return((u32)n);
868 /*lint +e702 */
869 }
870
871 /*------------------------------------------------------------------------------
872
873 Function: CbpIntra16x16
874
875 Functional description:
876 Returns the coded block pattern for intra 16x16 macroblock.
877
878 ------------------------------------------------------------------------------*/
879
CbpIntra16x16(mbType_e mbType)880 u32 CbpIntra16x16(mbType_e mbType)
881 {
882
883 /* Variables */
884
885 u32 cbp;
886 u32 tmp;
887
888 /* Code */
889
890 ASSERT(mbType >= I_16x16_0_0_0 && mbType <= I_16x16_3_2_1);
891
892 if (mbType >= I_16x16_0_0_1)
893 cbp = 15;
894 else
895 cbp = 0;
896
897 /* tmp is 0 for I_16x16_0_0_0 mb type */
898 /* ignore lint warning on arithmetic on enum's */
899 tmp = /*lint -e(656)*/(mbType - I_16x16_0_0_0) >> 2;
900 if (tmp > 2)
901 tmp -= 3;
902
903 cbp += tmp << 4;
904
905 return(cbp);
906
907 }
908
909 /*------------------------------------------------------------------------------
910
911 Function: h264bsdPredModeIntra16x16
912
913 Functional description:
914 Returns the prediction mode for intra 16x16 macroblock.
915
916 ------------------------------------------------------------------------------*/
917
h264bsdPredModeIntra16x16(mbType_e mbType)918 u32 h264bsdPredModeIntra16x16(mbType_e mbType)
919 {
920
921 /* Variables */
922
923 u32 tmp;
924
925 /* Code */
926
927 ASSERT(mbType >= I_16x16_0_0_0 && mbType <= I_16x16_3_2_1);
928
929 /* tmp is 0 for I_16x16_0_0_0 mb type */
930 /* ignore lint warning on arithmetic on enum's */
931 tmp = /*lint -e(656)*/(mbType - I_16x16_0_0_0);
932
933 return(tmp & 0x3);
934
935 }
936
937 /*------------------------------------------------------------------------------
938
939 Function: h264bsdDecodeMacroblock
940
941 Functional description:
942 Decode one macroblock and write into output image.
943
944 Inputs:
945 pMb pointer to macroblock specific information
946 mbLayer pointer to current macroblock data from stream
947 currImage pointer to output image
948 dpb pointer to decoded picture buffer
949 qpY pointer to slice QP
950 mbNum current macroblock number
951 constrainedIntraPred flag specifying if neighbouring inter
952 macroblocks are used in intra prediction
953
954 Outputs:
955 pMb structure is updated with current macroblock
956 currImage decoded macroblock is written into output image
957
958 Returns:
959 HANTRO_OK success
960 HANTRO_NOK error in macroblock decoding
961
962 ------------------------------------------------------------------------------*/
963
h264bsdDecodeMacroblock(mbStorage_t * pMb,macroblockLayer_t * pMbLayer,image_t * currImage,dpbStorage_t * dpb,i32 * qpY,u32 mbNum,u32 constrainedIntraPredFlag,u8 * data)964 u32 h264bsdDecodeMacroblock(mbStorage_t *pMb, macroblockLayer_t *pMbLayer,
965 image_t *currImage, dpbStorage_t *dpb, i32 *qpY, u32 mbNum,
966 u32 constrainedIntraPredFlag, u8* data)
967 {
968
969 /* Variables */
970
971 u32 i, tmp;
972 mbType_e mbType;
973 #ifdef H264DEC_OMXDL
974 const u8 *pSrc;
975 #endif
976 /* Code */
977
978 ASSERT(pMb);
979 ASSERT(pMbLayer);
980 ASSERT(currImage);
981 ASSERT(qpY && *qpY < 52);
982 ASSERT(mbNum < currImage->width*currImage->height);
983
984 mbType = pMbLayer->mbType;
985 pMb->mbType = mbType;
986
987 pMb->decoded++;
988
989 h264bsdSetCurrImageMbPointers(currImage, mbNum);
990
991 if (mbType == I_PCM)
992 {
993 u8 *pData = (u8*)data;
994 #ifdef H264DEC_OMXDL
995 u8 *tot = pMb->totalCoeff;
996 #else
997 i16 *tot = pMb->totalCoeff;
998 #endif
999 i32 *lev = pMbLayer->residual.level[0];
1000
1001 pMb->qpY = 0;
1002
1003 /* if decoded flag > 1 -> mb has already been successfully decoded and
1004 * written to output -> do not write again */
1005 if (pMb->decoded > 1)
1006 {
1007 for (i = 24; i--;)
1008 *tot++ = 16;
1009 return HANTRO_OK;
1010 }
1011
1012 for (i = 24; i--;)
1013 {
1014 *tot++ = 16;
1015 for (tmp = 16; tmp--;)
1016 *pData++ = (u8)(*lev++);
1017 }
1018 h264bsdWriteMacroblock(currImage, (u8*)data);
1019
1020 return(HANTRO_OK);
1021 }
1022 else
1023 {
1024 #ifdef H264DEC_OMXDL
1025 if (h264bsdMbPartPredMode(mbType) == PRED_MODE_INTER)
1026 {
1027 tmp = h264bsdInterPrediction(pMb, pMbLayer, dpb, mbNum,
1028 currImage, (u8*)data);
1029 if (tmp != HANTRO_OK) return (tmp);
1030 }
1031 #endif
1032 if (mbType != P_Skip)
1033 {
1034 H264SwDecMemcpy(pMb->totalCoeff,
1035 pMbLayer->residual.totalCoeff,
1036 27*sizeof(*pMb->totalCoeff));
1037
1038 /* update qpY */
1039 if (pMbLayer->mbQpDelta)
1040 {
1041 *qpY = *qpY + pMbLayer->mbQpDelta;
1042 if (*qpY < 0) *qpY += 52;
1043 else if (*qpY >= 52) *qpY -= 52;
1044 }
1045 pMb->qpY = (u32)*qpY;
1046
1047 #ifdef H264DEC_OMXDL
1048 pSrc = pMbLayer->residual.posCoefBuf;
1049
1050 if (h264bsdMbPartPredMode(mbType) == PRED_MODE_INTER)
1051 {
1052 OMXResult res;
1053 u8 *p;
1054 u8 *totalCoeff = pMb->totalCoeff;
1055
1056 for (i = 0; i < 16; i++, totalCoeff++)
1057 {
1058 p = data + lumaIndex[i];
1059 if (*totalCoeff)
1060 {
1061 res = omxVCM4P10_DequantTransformResidualFromPairAndAdd(
1062 &pSrc, p, 0, p, 16, 16, *qpY, *totalCoeff);
1063 if (res != OMX_Sts_NoErr)
1064 return (HANTRO_NOK);
1065 }
1066 }
1067
1068 }
1069 else if (h264bsdMbPartPredMode(mbType) == PRED_MODE_INTRA4x4)
1070 {
1071 tmp = ProcessIntra4x4Residual(pMb,
1072 data,
1073 constrainedIntraPredFlag,
1074 pMbLayer,
1075 &pSrc,
1076 currImage);
1077 if (tmp != HANTRO_OK)
1078 return (tmp);
1079 }
1080 else if (h264bsdMbPartPredMode(mbType) == PRED_MODE_INTRA16x16)
1081 {
1082 tmp = ProcessIntra16x16Residual(pMb,
1083 data,
1084 constrainedIntraPredFlag,
1085 pMbLayer->mbPred.intraChromaPredMode,
1086 &pSrc,
1087 currImage);
1088 if (tmp != HANTRO_OK)
1089 return (tmp);
1090 }
1091
1092 tmp = ProcessChromaResidual(pMb, data, &pSrc);
1093
1094 #else
1095 tmp = ProcessResidual(pMb, pMbLayer->residual.level,
1096 pMbLayer->residual.coeffMap);
1097 #endif
1098 if (tmp != HANTRO_OK)
1099 return (tmp);
1100 }
1101 else
1102 {
1103 H264SwDecMemset(pMb->totalCoeff, 0, 27*sizeof(*pMb->totalCoeff));
1104 pMb->qpY = (u32)*qpY;
1105 }
1106 #ifdef H264DEC_OMXDL
1107 /* if decoded flag > 1 -> mb has already been successfully decoded and
1108 * written to output -> do not write again */
1109 if (pMb->decoded > 1)
1110 return HANTRO_OK;
1111
1112 h264bsdWriteMacroblock(currImage, data);
1113 #else
1114 if (h264bsdMbPartPredMode(mbType) != PRED_MODE_INTER)
1115 {
1116 tmp = h264bsdIntraPrediction(pMb, pMbLayer, currImage, mbNum,
1117 constrainedIntraPredFlag, (u8*)data);
1118 if (tmp != HANTRO_OK) return (tmp);
1119 }
1120 else
1121 {
1122 tmp = h264bsdInterPrediction(pMb, pMbLayer, dpb, mbNum,
1123 currImage, (u8*)data);
1124 if (tmp != HANTRO_OK) return (tmp);
1125 }
1126 #endif
1127 }
1128
1129 return HANTRO_OK;
1130 }
1131
1132
1133 #ifdef H264DEC_OMXDL
1134
1135 /*------------------------------------------------------------------------------
1136
1137 Function: ProcessChromaResidual
1138
1139 Functional description:
1140 Process the residual data of chroma with
1141 inverse quantization and inverse transform.
1142
1143 ------------------------------------------------------------------------------*/
ProcessChromaResidual(mbStorage_t * pMb,u8 * data,const u8 ** pSrc)1144 u32 ProcessChromaResidual(mbStorage_t *pMb, u8 *data, const u8 **pSrc )
1145 {
1146 u32 i;
1147 u32 chromaQp;
1148 i16 *pDc;
1149 i16 dc[4 + 4] = {0,0,0,0,0,0,0,0};
1150 u8 *totalCoeff;
1151 OMXResult result;
1152 u8 *p;
1153
1154 /* chroma DC processing. First chroma dc block is block with index 25 */
1155 chromaQp =
1156 h264bsdQpC[CLIP3(0, 51, (i32)pMb->qpY + pMb->chromaQpIndexOffset)];
1157
1158 if (pMb->totalCoeff[25])
1159 {
1160 pDc = dc;
1161 result = omxVCM4P10_TransformDequantChromaDCFromPair(
1162 pSrc,
1163 pDc,
1164 (i32)chromaQp);
1165 if (result != OMX_Sts_NoErr)
1166 return (HANTRO_NOK);
1167 }
1168 if (pMb->totalCoeff[26])
1169 {
1170 pDc = dc+4;
1171 result = omxVCM4P10_TransformDequantChromaDCFromPair(
1172 pSrc,
1173 pDc,
1174 (i32)chromaQp);
1175 if (result != OMX_Sts_NoErr)
1176 return (HANTRO_NOK);
1177 }
1178
1179 pDc = dc;
1180 totalCoeff = pMb->totalCoeff + 16;
1181 for (i = 0; i < 8; i++, pDc++, totalCoeff++)
1182 {
1183 /* chroma prediction */
1184 if (*totalCoeff || *pDc)
1185 {
1186 p = data + chromaIndex[i];
1187 result = omxVCM4P10_DequantTransformResidualFromPairAndAdd(
1188 pSrc,
1189 p,
1190 pDc,
1191 p,
1192 8,
1193 8,
1194 (i32)chromaQp,
1195 *totalCoeff);
1196 if (result != OMX_Sts_NoErr)
1197 return (HANTRO_NOK);
1198 }
1199 }
1200
1201 return(HANTRO_OK);
1202 }
1203
1204 /*------------------------------------------------------------------------------
1205
1206 Function: ProcessIntra16x16Residual
1207
1208 Functional description:
1209 Process the residual data of luma with
1210 inverse quantization and inverse transform.
1211
1212 ------------------------------------------------------------------------------*/
ProcessIntra16x16Residual(mbStorage_t * pMb,u8 * data,u32 constrainedIntraPred,u32 intraChromaPredMode,const u8 ** pSrc,image_t * image)1213 u32 ProcessIntra16x16Residual(mbStorage_t *pMb,
1214 u8 *data,
1215 u32 constrainedIntraPred,
1216 u32 intraChromaPredMode,
1217 const u8** pSrc,
1218 image_t *image)
1219 {
1220 u32 i;
1221 i16 *pDc;
1222 i16 dc[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
1223 u8 *totalCoeff;
1224 OMXResult result;
1225 u8 *p;
1226
1227 totalCoeff = pMb->totalCoeff;
1228
1229 if (totalCoeff[24])
1230 {
1231 pDc = dc;
1232 result = omxVCM4P10_TransformDequantLumaDCFromPair(
1233 pSrc,
1234 pDc,
1235 (i32)pMb->qpY);
1236 if (result != OMX_Sts_NoErr)
1237 return (HANTRO_NOK);
1238 }
1239 /* Intra 16x16 pred */
1240 if (h264bsdIntra16x16Prediction(pMb, data, image->luma,
1241 image->width*16, constrainedIntraPred) != HANTRO_OK)
1242 return(HANTRO_NOK);
1243 for (i = 0; i < 16; i++, totalCoeff++)
1244 {
1245 p = data + lumaIndex[i];
1246 pDc = &dc[dcCoeffIndex[i]];
1247 if (*totalCoeff || *pDc)
1248 {
1249 result = omxVCM4P10_DequantTransformResidualFromPairAndAdd(
1250 pSrc,
1251 p,
1252 pDc,
1253 p,
1254 16,
1255 16,
1256 (i32)pMb->qpY,
1257 *totalCoeff);
1258 if (result != OMX_Sts_NoErr)
1259 return (HANTRO_NOK);
1260 }
1261 }
1262
1263 if (h264bsdIntraChromaPrediction(pMb, data + 256,
1264 image,
1265 intraChromaPredMode,
1266 constrainedIntraPred) != HANTRO_OK)
1267 return(HANTRO_NOK);
1268
1269 return HANTRO_OK;
1270 }
1271
1272 /*------------------------------------------------------------------------------
1273
1274 Function: ProcessIntra4x4Residual
1275
1276 Functional description:
1277 Process the residual data of luma with
1278 inverse quantization and inverse transform.
1279
1280 ------------------------------------------------------------------------------*/
ProcessIntra4x4Residual(mbStorage_t * pMb,u8 * data,u32 constrainedIntraPred,macroblockLayer_t * mbLayer,const u8 ** pSrc,image_t * image)1281 u32 ProcessIntra4x4Residual(mbStorage_t *pMb,
1282 u8 *data,
1283 u32 constrainedIntraPred,
1284 macroblockLayer_t *mbLayer,
1285 const u8 **pSrc,
1286 image_t *image)
1287 {
1288 u32 i;
1289 u8 *totalCoeff;
1290 OMXResult result;
1291 u8 *p;
1292
1293 totalCoeff = pMb->totalCoeff;
1294
1295 for (i = 0; i < 16; i++, totalCoeff++)
1296 {
1297 p = data + lumaIndex[i];
1298 if (h264bsdIntra4x4Prediction(pMb, p, mbLayer, image->luma,
1299 image->width*16, constrainedIntraPred, i) != HANTRO_OK)
1300 return(HANTRO_NOK);
1301
1302 if (*totalCoeff)
1303 {
1304 result = omxVCM4P10_DequantTransformResidualFromPairAndAdd(
1305 pSrc,
1306 p,
1307 NULL,
1308 p,
1309 16,
1310 16,
1311 (i32)pMb->qpY,
1312 *totalCoeff);
1313 if (result != OMX_Sts_NoErr)
1314 return (HANTRO_NOK);
1315 }
1316 }
1317
1318 if (h264bsdIntraChromaPrediction(pMb, data + 256,
1319 image,
1320 mbLayer->mbPred.intraChromaPredMode,
1321 constrainedIntraPred) != HANTRO_OK)
1322 return(HANTRO_NOK);
1323
1324 return HANTRO_OK;
1325 }
1326
1327 #else /* H264DEC_OMXDL */
1328
1329 /*------------------------------------------------------------------------------
1330
1331 Function: ProcessResidual
1332
1333 Functional description:
1334 Process the residual data of one macroblock with
1335 inverse quantization and inverse transform.
1336
1337 ------------------------------------------------------------------------------*/
1338
ProcessResidual(mbStorage_t * pMb,i32 residualLevel[][16],u32 * coeffMap)1339 u32 ProcessResidual(mbStorage_t *pMb, i32 residualLevel[][16], u32 *coeffMap)
1340 {
1341
1342 /* Variables */
1343
1344 u32 i;
1345 u32 chromaQp;
1346 i32 (*blockData)[16];
1347 i32 (*blockDc)[16];
1348 i16 *totalCoeff;
1349 i32 *chromaDc;
1350 const u32 *dcCoeffIdx;
1351
1352 /* Code */
1353
1354 ASSERT(pMb);
1355 ASSERT(residualLevel);
1356
1357 /* set pointers to DC coefficient blocks */
1358 blockDc = residualLevel + 24;
1359
1360 blockData = residualLevel;
1361 totalCoeff = pMb->totalCoeff;
1362 if (h264bsdMbPartPredMode(pMb->mbType) == PRED_MODE_INTRA16x16)
1363 {
1364 if (totalCoeff[24])
1365 {
1366 h264bsdProcessLumaDc(*blockDc, pMb->qpY);
1367 }
1368 dcCoeffIdx = dcCoeffIndex;
1369
1370 for (i = 16; i--; blockData++, totalCoeff++, coeffMap++)
1371 {
1372 /* set dc coefficient of luma block */
1373 (*blockData)[0] = (*blockDc)[*dcCoeffIdx++];
1374 if ((*blockData)[0] || *totalCoeff)
1375 {
1376 if (h264bsdProcessBlock(*blockData, pMb->qpY, 1, *coeffMap) !=
1377 HANTRO_OK)
1378 return(HANTRO_NOK);
1379 }
1380 else
1381 MARK_RESIDUAL_EMPTY(*blockData);
1382 }
1383 }
1384 else
1385 {
1386 for (i = 16; i--; blockData++, totalCoeff++, coeffMap++)
1387 {
1388 if (*totalCoeff)
1389 {
1390 if (h264bsdProcessBlock(*blockData, pMb->qpY, 0, *coeffMap) !=
1391 HANTRO_OK)
1392 return(HANTRO_NOK);
1393 }
1394 else
1395 MARK_RESIDUAL_EMPTY(*blockData);
1396 }
1397 }
1398
1399 /* chroma DC processing. First chroma dc block is block with index 25 */
1400 chromaQp =
1401 h264bsdQpC[CLIP3(0, 51, (i32)pMb->qpY + pMb->chromaQpIndexOffset)];
1402 if (pMb->totalCoeff[25] || pMb->totalCoeff[26])
1403 h264bsdProcessChromaDc(residualLevel[25], chromaQp);
1404 chromaDc = residualLevel[25];
1405 for (i = 8; i--; blockData++, totalCoeff++, coeffMap++)
1406 {
1407 /* set dc coefficient of chroma block */
1408 (*blockData)[0] = *chromaDc++;
1409 if ((*blockData)[0] || *totalCoeff)
1410 {
1411 if (h264bsdProcessBlock(*blockData, chromaQp, 1,*coeffMap) !=
1412 HANTRO_OK)
1413 return(HANTRO_NOK);
1414 }
1415 else
1416 MARK_RESIDUAL_EMPTY(*blockData);
1417 }
1418
1419 return(HANTRO_OK);
1420 }
1421 #endif /* H264DEC_OMXDL */
1422
1423 /*------------------------------------------------------------------------------
1424
1425 Function: h264bsdSubMbPartMode
1426
1427 Functional description:
1428 Returns the macroblock's sub-partition mode.
1429
1430 ------------------------------------------------------------------------------*/
1431
h264bsdSubMbPartMode(subMbType_e subMbType)1432 subMbPartMode_e h264bsdSubMbPartMode(subMbType_e subMbType)
1433 {
1434
1435 /* Variables */
1436
1437
1438 /* Code */
1439
1440 ASSERT(subMbType < 4);
1441
1442 return((subMbPartMode_e)subMbType);
1443
1444 }
1445
1446
1447