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 h264bsdIntraPrediction 27 h264bsdGetNeighbourPels 28 h264bsdIntra16x16Prediction 29 h264bsdIntra4x4Prediction 30 h264bsdIntraChromaPrediction 31 h264bsdAddResidual 32 Intra16x16VerticalPrediction 33 Intra16x16HorizontalPrediction 34 Intra16x16DcPrediction 35 Intra16x16PlanePrediction 36 IntraChromaDcPrediction 37 IntraChromaHorizontalPrediction 38 IntraChromaVerticalPrediction 39 IntraChromaPlanePrediction 40 Get4x4NeighbourPels 41 Write4x4To16x16 42 Intra4x4VerticalPrediction 43 Intra4x4HorizontalPrediction 44 Intra4x4DcPrediction 45 Intra4x4DiagonalDownLeftPrediction 46 Intra4x4DiagonalDownRightPrediction 47 Intra4x4VerticalRightPrediction 48 Intra4x4HorizontalDownPrediction 49 Intra4x4VerticalLeftPrediction 50 Intra4x4HorizontalUpPrediction 51 DetermineIntra4x4PredMode 52 53 ------------------------------------------------------------------------------*/ 54 55 /*------------------------------------------------------------------------------ 56 1. Include headers 57 ------------------------------------------------------------------------------*/ 58 59 #include "h264bsd_intra_prediction.h" 60 #include "h264bsd_util.h" 61 #include "h264bsd_macroblock_layer.h" 62 #include "h264bsd_neighbour.h" 63 #include "h264bsd_image.h" 64 65 #ifdef H264DEC_OMXDL 66 #include "omxtypes.h" 67 #include "omxVC.h" 68 #endif /* H264DEC_OMXDL */ 69 70 /*------------------------------------------------------------------------------ 71 2. External compiler flags 72 -------------------------------------------------------------------------------- 73 74 -------------------------------------------------------------------------------- 75 3. Module defines 76 ------------------------------------------------------------------------------*/ 77 78 /* Switch off the following Lint messages for this file: 79 * Info 702: Shift right of signed quantity (int) 80 */ 81 /*lint -e702 */ 82 83 84 /* x- and y-coordinates for each block */ 85 const u32 h264bsdBlockX[16] = 86 { 0, 4, 0, 4, 8, 12, 8, 12, 0, 4, 0, 4, 8, 12, 8, 12 }; 87 const u32 h264bsdBlockY[16] = 88 { 0, 0, 4, 4, 0, 0, 4, 4, 8, 8, 12, 12, 8, 8, 12, 12 }; 89 90 const u8 h264bsdClip[1280] = 91 { 92 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 93 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 94 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 95 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 96 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 97 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 98 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 99 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 100 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 101 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 102 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 103 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 104 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 105 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 106 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 107 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 108 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15, 109 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31, 110 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47, 111 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63, 112 64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79, 113 80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95, 114 96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111, 115 112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127, 116 128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143, 117 144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159, 118 160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175, 119 176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191, 120 192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207, 121 208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223, 122 224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239, 123 240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255, 124 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, 125 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, 126 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, 127 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, 128 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, 129 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, 130 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, 131 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, 132 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, 133 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, 134 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, 135 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, 136 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, 137 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, 138 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, 139 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, 140 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, 141 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, 142 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, 143 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, 144 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, 145 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, 146 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, 147 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, 148 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, 149 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, 150 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, 151 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, 152 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, 153 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, 154 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, 155 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255 156 }; 157 158 #ifndef H264DEC_OMXDL 159 /*------------------------------------------------------------------------------ 160 4. Local function prototypes 161 ------------------------------------------------------------------------------*/ 162 static void Get4x4NeighbourPels(u8 *a, u8 *l, u8 *data, u8 *above, u8 *left, 163 u32 blockNum); 164 static void Intra16x16VerticalPrediction(u8 *data, u8 *above); 165 static void Intra16x16HorizontalPrediction(u8 *data, u8 *left); 166 static void Intra16x16DcPrediction(u8 *data, u8 *above, u8 *left, 167 u32 A, u32 B); 168 static void Intra16x16PlanePrediction(u8 *data, u8 *above, u8 *left); 169 static void IntraChromaDcPrediction(u8 *data, u8 *above, u8 *left, 170 u32 A, u32 B); 171 static void IntraChromaHorizontalPrediction(u8 *data, u8 *left); 172 static void IntraChromaVerticalPrediction(u8 *data, u8 *above); 173 static void IntraChromaPlanePrediction(u8 *data, u8 *above, u8 *left); 174 175 static void Intra4x4VerticalPrediction(u8 *data, u8 *above); 176 static void Intra4x4HorizontalPrediction(u8 *data, u8 *left); 177 static void Intra4x4DcPrediction(u8 *data, u8 *above, u8 *left, u32 A, u32 B); 178 static void Intra4x4DiagonalDownLeftPrediction(u8 *data, u8 *above); 179 static void Intra4x4DiagonalDownRightPrediction(u8 *data, u8 *above, u8 *left); 180 static void Intra4x4VerticalRightPrediction(u8 *data, u8 *above, u8 *left); 181 static void Intra4x4HorizontalDownPrediction(u8 *data, u8 *above, u8 *left); 182 static void Intra4x4VerticalLeftPrediction(u8 *data, u8 *above); 183 static void Intra4x4HorizontalUpPrediction(u8 *data, u8 *left); 184 void h264bsdAddResidual(u8 *data, i32 *residual, u32 blockNum); 185 186 static void Write4x4To16x16(u8 *data, u8 *data4x4, u32 blockNum); 187 #endif /* H264DEC_OMXDL */ 188 189 static u32 DetermineIntra4x4PredMode(macroblockLayer_t *pMbLayer, 190 u32 available, neighbour_t *nA, neighbour_t *nB, u32 index, 191 mbStorage_t *nMbA, mbStorage_t *nMbB); 192 193 194 #ifdef H264DEC_OMXDL 195 196 /*------------------------------------------------------------------------------ 197 198 Function: h264bsdIntra16x16Prediction 199 200 Functional description: 201 Perform intra 16x16 prediction mode for luma pixels and add 202 residual into prediction. The resulting luma pixels are 203 stored in macroblock array 'data'. 204 205 ------------------------------------------------------------------------------*/ 206 u32 h264bsdIntra16x16Prediction(mbStorage_t *pMb, u8 *data, u8 *ptr, 207 u32 width, u32 constrainedIntraPred) 208 { 209 210 /* Variables */ 211 212 u32 availableA, availableB, availableD; 213 OMXResult omxRes; 214 215 /* Code */ 216 ASSERT(pMb); 217 ASSERT(data); 218 ASSERT(ptr); 219 ASSERT(h264bsdPredModeIntra16x16(pMb->mbType) < 4); 220 221 availableA = h264bsdIsNeighbourAvailable(pMb, pMb->mbA); 222 if (availableA && constrainedIntraPred && 223 (h264bsdMbPartPredMode(pMb->mbA->mbType) == PRED_MODE_INTER)) 224 availableA = HANTRO_FALSE; 225 availableB = h264bsdIsNeighbourAvailable(pMb, pMb->mbB); 226 if (availableB && constrainedIntraPred && 227 (h264bsdMbPartPredMode(pMb->mbB->mbType) == PRED_MODE_INTER)) 228 availableB = HANTRO_FALSE; 229 availableD = h264bsdIsNeighbourAvailable(pMb, pMb->mbD); 230 if (availableD && constrainedIntraPred && 231 (h264bsdMbPartPredMode(pMb->mbD->mbType) == PRED_MODE_INTER)) 232 availableD = HANTRO_FALSE; 233 234 omxRes = omxVCM4P10_PredictIntra_16x16( (ptr-1), 235 (ptr - width), 236 (ptr - width-1), 237 data, 238 (i32)width, 239 16, 240 (OMXVCM4P10Intra16x16PredMode) 241 h264bsdPredModeIntra16x16(pMb->mbType), 242 (i32)(availableB + (availableA<<1) + 243 (availableD<<5)) ); 244 if (omxRes != OMX_Sts_NoErr) 245 return HANTRO_NOK; 246 else 247 return(HANTRO_OK); 248 } 249 250 /*------------------------------------------------------------------------------ 251 252 Function: h264bsdIntra4x4Prediction 253 254 Functional description: 255 Perform intra 4x4 prediction for luma pixels and add residual 256 into prediction. The resulting luma pixels are stored in 257 macroblock array 'data'. The intra 4x4 prediction mode for each 258 block is stored in 'pMb' structure. 259 260 ------------------------------------------------------------------------------*/ 261 u32 h264bsdIntra4x4Prediction(mbStorage_t *pMb, u8 *data, 262 macroblockLayer_t *mbLayer, 263 u8 *ptr, u32 width, 264 u32 constrainedIntraPred, u32 block) 265 { 266 267 /* Variables */ 268 u32 mode; 269 neighbour_t neighbour, neighbourB; 270 mbStorage_t *nMb, *nMb2; 271 u32 availableA, availableB, availableC, availableD; 272 273 OMXResult omxRes; 274 u32 x, y; 275 u8 *l, *a, *al; 276 /* Code */ 277 ASSERT(pMb); 278 ASSERT(data); 279 ASSERT(mbLayer); 280 ASSERT(ptr); 281 ASSERT(pMb->intra4x4PredMode[block] < 9); 282 283 neighbour = *h264bsdNeighbour4x4BlockA(block); 284 nMb = h264bsdGetNeighbourMb(pMb, neighbour.mb); 285 availableA = h264bsdIsNeighbourAvailable(pMb, nMb); 286 if (availableA && constrainedIntraPred && 287 ( h264bsdMbPartPredMode(nMb->mbType) == PRED_MODE_INTER) ) 288 { 289 availableA = HANTRO_FALSE; 290 } 291 292 neighbourB = *h264bsdNeighbour4x4BlockB(block); 293 nMb2 = h264bsdGetNeighbourMb(pMb, neighbourB.mb); 294 availableB = h264bsdIsNeighbourAvailable(pMb, nMb2); 295 if (availableB && constrainedIntraPred && 296 ( h264bsdMbPartPredMode(nMb2->mbType) == PRED_MODE_INTER) ) 297 { 298 availableB = HANTRO_FALSE; 299 } 300 301 mode = DetermineIntra4x4PredMode(mbLayer, 302 (u32)(availableA && availableB), 303 &neighbour, &neighbourB, block, nMb, nMb2); 304 pMb->intra4x4PredMode[block] = (u8)mode; 305 306 neighbour = *h264bsdNeighbour4x4BlockC(block); 307 nMb = h264bsdGetNeighbourMb(pMb, neighbour.mb); 308 availableC = h264bsdIsNeighbourAvailable(pMb, nMb); 309 if (availableC && constrainedIntraPred && 310 ( h264bsdMbPartPredMode(nMb->mbType) == PRED_MODE_INTER) ) 311 { 312 availableC = HANTRO_FALSE; 313 } 314 315 neighbour = *h264bsdNeighbour4x4BlockD(block); 316 nMb = h264bsdGetNeighbourMb(pMb, neighbour.mb); 317 availableD = h264bsdIsNeighbourAvailable(pMb, nMb); 318 if (availableD && constrainedIntraPred && 319 ( h264bsdMbPartPredMode(nMb->mbType) == PRED_MODE_INTER) ) 320 { 321 availableD = HANTRO_FALSE; 322 } 323 324 x = h264bsdBlockX[block]; 325 y = h264bsdBlockY[block]; 326 327 if (y == 0) 328 a = ptr - width + x; 329 else 330 a = data-16; 331 332 if (x == 0) 333 l = ptr + y * width -1; 334 else 335 { 336 l = data-1; 337 width = 16; 338 } 339 340 if (x == 0) 341 al = l-width; 342 else 343 al = a-1; 344 345 omxRes = omxVCM4P10_PredictIntra_4x4( l, 346 a, 347 al, 348 data, 349 (i32)width, 350 16, 351 (OMXVCM4P10Intra4x4PredMode)mode, 352 (i32)(availableB + 353 (availableA<<1) + 354 (availableD<<5) + 355 (availableC<<6)) ); 356 if (omxRes != OMX_Sts_NoErr) 357 return HANTRO_NOK; 358 359 return(HANTRO_OK); 360 361 } 362 363 /*------------------------------------------------------------------------------ 364 365 Function: h264bsdIntraChromaPrediction 366 367 Functional description: 368 Perform intra prediction for chroma pixels and add residual 369 into prediction. The resulting chroma pixels are stored in 'data'. 370 371 ------------------------------------------------------------------------------*/ 372 u32 h264bsdIntraChromaPrediction(mbStorage_t *pMb, u8 *data, image_t *image, 373 u32 predMode, u32 constrainedIntraPred) 374 { 375 376 /* Variables */ 377 378 u32 availableA, availableB, availableD; 379 OMXResult omxRes; 380 u8 *ptr; 381 u32 width; 382 383 /* Code */ 384 ASSERT(pMb); 385 ASSERT(data); 386 ASSERT(image); 387 ASSERT(predMode < 4); 388 389 availableA = h264bsdIsNeighbourAvailable(pMb, pMb->mbA); 390 if (availableA && constrainedIntraPred && 391 (h264bsdMbPartPredMode(pMb->mbA->mbType) == PRED_MODE_INTER)) 392 availableA = HANTRO_FALSE; 393 availableB = h264bsdIsNeighbourAvailable(pMb, pMb->mbB); 394 if (availableB && constrainedIntraPred && 395 (h264bsdMbPartPredMode(pMb->mbB->mbType) == PRED_MODE_INTER)) 396 availableB = HANTRO_FALSE; 397 availableD = h264bsdIsNeighbourAvailable(pMb, pMb->mbD); 398 if (availableD && constrainedIntraPred && 399 (h264bsdMbPartPredMode(pMb->mbD->mbType) == PRED_MODE_INTER)) 400 availableD = HANTRO_FALSE; 401 402 ptr = image->cb; 403 width = image->width*8; 404 405 omxRes = omxVCM4P10_PredictIntraChroma_8x8( (ptr-1), 406 (ptr - width), 407 (ptr - width -1), 408 data, 409 (i32)width, 410 8, 411 (OMXVCM4P10IntraChromaPredMode) 412 predMode, 413 (i32)(availableB + 414 (availableA<<1) + 415 (availableD<<5)) ); 416 if (omxRes != OMX_Sts_NoErr) 417 return HANTRO_NOK; 418 419 /* advance pointers */ 420 data += 64; 421 ptr = image->cr; 422 423 omxRes = omxVCM4P10_PredictIntraChroma_8x8( (ptr-1), 424 (ptr - width), 425 (ptr - width -1), 426 data, 427 (i32)width, 428 8, 429 (OMXVCM4P10IntraChromaPredMode) 430 predMode, 431 (i32)(availableB + 432 (availableA<<1) + 433 (availableD<<5)) ); 434 if (omxRes != OMX_Sts_NoErr) 435 return HANTRO_NOK; 436 437 return(HANTRO_OK); 438 439 } 440 441 442 #else /* H264DEC_OMXDL */ 443 444 445 /*------------------------------------------------------------------------------ 446 447 Function: h264bsdIntraPrediction 448 449 Functional description: 450 Processes one intra macroblock. Performs intra prediction using 451 specified prediction mode. Writes the final macroblock 452 (prediction + residual) into the output image (image) 453 454 Inputs: 455 pMb pointer to macroblock specific information 456 mbLayer pointer to current macroblock data from stream 457 image pointer to output image 458 mbNum current macroblock number 459 constrainedIntraPred flag specifying if neighbouring inter 460 macroblocks are used in intra prediction 461 data pointer where output macroblock will be stored 462 463 Outputs: 464 pMb structure is updated with current macroblock 465 image current macroblock is written into image 466 data current macroblock is stored here 467 468 Returns: 469 HANTRO_OK success 470 HANTRO_NOK error in intra prediction 471 472 ------------------------------------------------------------------------------*/ 473 u32 h264bsdIntraPrediction(mbStorage_t *pMb, macroblockLayer_t *mbLayer, 474 image_t *image, u32 mbNum, u32 constrainedIntraPred, u8 *data) 475 { 476 477 /* Variables */ 478 479 /* pelAbove and pelLeft contain samples above and left to the current 480 * macroblock. Above array contains also sample above-left to the current 481 * mb as well as 4 samples above-right to the current mb (latter only for 482 * luma) */ 483 /* lumD + lumB + lumC + cbD + cbB + crD + crB */ 484 u8 pelAbove[1 + 16 + 4 + 1 + 8 + 1 + 8]; 485 /* lumA + cbA + crA */ 486 u8 pelLeft[16 + 8 + 8]; 487 u32 tmp; 488 489 /* Code */ 490 491 ASSERT(pMb); 492 ASSERT(image); 493 ASSERT(mbNum < image->width * image->height); 494 ASSERT(h264bsdMbPartPredMode(pMb->mbType) != PRED_MODE_INTER); 495 496 h264bsdGetNeighbourPels(image, pelAbove, pelLeft, mbNum); 497 498 if (h264bsdMbPartPredMode(pMb->mbType) == PRED_MODE_INTRA16x16) 499 { 500 tmp = h264bsdIntra16x16Prediction(pMb, data, mbLayer->residual.level, 501 pelAbove, pelLeft, constrainedIntraPred); 502 if (tmp != HANTRO_OK) 503 return(tmp); 504 } 505 else 506 { 507 tmp = h264bsdIntra4x4Prediction(pMb, data, mbLayer, 508 pelAbove, pelLeft, constrainedIntraPred); 509 if (tmp != HANTRO_OK) 510 return(tmp); 511 } 512 513 tmp = h264bsdIntraChromaPrediction(pMb, data + 256, 514 mbLayer->residual.level+16, pelAbove + 21, pelLeft + 16, 515 mbLayer->mbPred.intraChromaPredMode, constrainedIntraPred); 516 if (tmp != HANTRO_OK) 517 return(tmp); 518 519 /* if decoded flag > 1 -> mb has already been successfully decoded and 520 * written to output -> do not write again */ 521 if (pMb->decoded > 1) 522 return HANTRO_OK; 523 524 h264bsdWriteMacroblock(image, data); 525 526 return(HANTRO_OK); 527 528 } 529 530 /*------------------------------------------------------------------------------ 531 532 Function: h264bsdGetNeighbourPels 533 534 Functional description: 535 Get pixel values from neighbouring macroblocks into 'above' 536 and 'left' arrays. 537 538 ------------------------------------------------------------------------------*/ 539 540 void h264bsdGetNeighbourPels(image_t *image, u8 *above, u8 *left, u32 mbNum) 541 { 542 543 /* Variables */ 544 545 u32 i; 546 u32 width, picSize; 547 u8 *ptr, *tmp; 548 u32 row, col; 549 550 /* Code */ 551 552 ASSERT(image); 553 ASSERT(above); 554 ASSERT(left); 555 ASSERT(mbNum < image->width * image->height); 556 557 if (!mbNum) 558 return; 559 560 width = image->width; 561 picSize = width * image->height; 562 row = mbNum / width; 563 col = mbNum - row * width; 564 565 width *= 16; 566 ptr = image->data + row * 16 * width + col * 16; 567 568 /* note that luma samples above-right to current macroblock do not make 569 * sense when current mb is the right-most mb in a row. Same applies to 570 * sample above-left if col is zero. However, usage of pels in prediction 571 * is controlled by neighbour availability information in actual prediction 572 * process */ 573 if (row) 574 { 575 tmp = ptr - (width + 1); 576 for (i = 21; i--;) 577 *above++ = *tmp++; 578 } 579 580 if (col) 581 { 582 ptr--; 583 for (i = 16; i--; ptr+=width) 584 *left++ = *ptr; 585 } 586 587 width >>= 1; 588 ptr = image->data + picSize * 256 + row * 8 * width + col * 8; 589 590 if (row) 591 { 592 tmp = ptr - (width + 1); 593 for (i = 9; i--;) 594 *above++ = *tmp++; 595 tmp += (picSize * 64) - 9; 596 for (i = 9; i--;) 597 *above++ = *tmp++; 598 } 599 600 if (col) 601 { 602 ptr--; 603 for (i = 8; i--; ptr+=width) 604 *left++ = *ptr; 605 ptr += (picSize * 64) - 8 * width; 606 for (i = 8; i--; ptr+=width) 607 *left++ = *ptr; 608 } 609 } 610 611 /*------------------------------------------------------------------------------ 612 613 Function: Intra16x16Prediction 614 615 Functional description: 616 Perform intra 16x16 prediction mode for luma pixels and add 617 residual into prediction. The resulting luma pixels are 618 stored in macroblock array 'data'. 619 620 ------------------------------------------------------------------------------*/ 621 622 u32 h264bsdIntra16x16Prediction(mbStorage_t *pMb, u8 *data, i32 residual[][16], 623 u8 *above, u8 *left, u32 constrainedIntraPred) 624 { 625 626 /* Variables */ 627 628 u32 i; 629 u32 availableA, availableB, availableD; 630 631 /* Code */ 632 633 ASSERT(data); 634 ASSERT(residual); 635 ASSERT(above); 636 ASSERT(left); 637 ASSERT(h264bsdPredModeIntra16x16(pMb->mbType) < 4); 638 639 availableA = h264bsdIsNeighbourAvailable(pMb, pMb->mbA); 640 if (availableA && constrainedIntraPred && 641 (h264bsdMbPartPredMode(pMb->mbA->mbType) == PRED_MODE_INTER)) 642 availableA = HANTRO_FALSE; 643 availableB = h264bsdIsNeighbourAvailable(pMb, pMb->mbB); 644 if (availableB && constrainedIntraPred && 645 (h264bsdMbPartPredMode(pMb->mbB->mbType) == PRED_MODE_INTER)) 646 availableB = HANTRO_FALSE; 647 availableD = h264bsdIsNeighbourAvailable(pMb, pMb->mbD); 648 if (availableD && constrainedIntraPred && 649 (h264bsdMbPartPredMode(pMb->mbD->mbType) == PRED_MODE_INTER)) 650 availableD = HANTRO_FALSE; 651 652 switch(h264bsdPredModeIntra16x16(pMb->mbType)) 653 { 654 case 0: /* Intra_16x16_Vertical */ 655 if (!availableB) 656 return(HANTRO_NOK); 657 Intra16x16VerticalPrediction(data, above+1); 658 break; 659 660 case 1: /* Intra_16x16_Horizontal */ 661 if (!availableA) 662 return(HANTRO_NOK); 663 Intra16x16HorizontalPrediction(data, left); 664 break; 665 666 case 2: /* Intra_16x16_DC */ 667 Intra16x16DcPrediction(data, above+1, left, availableA, availableB); 668 break; 669 670 default: /* case 3: Intra_16x16_Plane */ 671 if (!availableA || !availableB || !availableD) 672 return(HANTRO_NOK); 673 Intra16x16PlanePrediction(data, above+1, left); 674 break; 675 } 676 /* add residual */ 677 for (i = 0; i < 16; i++) 678 h264bsdAddResidual(data, residual[i], i); 679 680 return(HANTRO_OK); 681 682 } 683 684 /*------------------------------------------------------------------------------ 685 686 Function: Intra4x4Prediction 687 688 Functional description: 689 Perform intra 4x4 prediction for luma pixels and add residual 690 into prediction. The resulting luma pixels are stored in 691 macroblock array 'data'. The intra 4x4 prediction mode for each 692 block is stored in 'pMb' structure. 693 694 ------------------------------------------------------------------------------*/ 695 696 u32 h264bsdIntra4x4Prediction(mbStorage_t *pMb, u8 *data, 697 macroblockLayer_t *mbLayer, u8 *above, 698 u8 *left, u32 constrainedIntraPred) 699 { 700 701 /* Variables */ 702 703 u32 block; 704 u32 mode; 705 neighbour_t neighbour, neighbourB; 706 mbStorage_t *nMb, *nMb2; 707 u8 a[1 + 4 + 4], l[1 + 4]; 708 u32 data4x4[4]; 709 u32 availableA, availableB, availableC, availableD; 710 711 /* Code */ 712 713 ASSERT(data); 714 ASSERT(mbLayer); 715 ASSERT(above); 716 ASSERT(left); 717 718 for (block = 0; block < 16; block++) 719 { 720 721 ASSERT(pMb->intra4x4PredMode[block] < 9); 722 723 neighbour = *h264bsdNeighbour4x4BlockA(block); 724 nMb = h264bsdGetNeighbourMb(pMb, neighbour.mb); 725 availableA = h264bsdIsNeighbourAvailable(pMb, nMb); 726 if (availableA && constrainedIntraPred && 727 ( h264bsdMbPartPredMode(nMb->mbType) == PRED_MODE_INTER) ) 728 { 729 availableA = HANTRO_FALSE; 730 } 731 732 neighbourB = *h264bsdNeighbour4x4BlockB(block); 733 nMb2 = h264bsdGetNeighbourMb(pMb, neighbourB.mb); 734 availableB = h264bsdIsNeighbourAvailable(pMb, nMb2); 735 if (availableB && constrainedIntraPred && 736 ( h264bsdMbPartPredMode(nMb2->mbType) == PRED_MODE_INTER) ) 737 { 738 availableB = HANTRO_FALSE; 739 } 740 741 mode = DetermineIntra4x4PredMode(mbLayer, 742 (u32)(availableA && availableB), 743 &neighbour, &neighbourB, block, nMb, nMb2); 744 pMb->intra4x4PredMode[block] = (u8)mode; 745 746 neighbour = *h264bsdNeighbour4x4BlockC(block); 747 nMb = h264bsdGetNeighbourMb(pMb, neighbour.mb); 748 availableC = h264bsdIsNeighbourAvailable(pMb, nMb); 749 if (availableC && constrainedIntraPred && 750 ( h264bsdMbPartPredMode(nMb->mbType) == PRED_MODE_INTER) ) 751 { 752 availableC = HANTRO_FALSE; 753 } 754 755 neighbour = *h264bsdNeighbour4x4BlockD(block); 756 nMb = h264bsdGetNeighbourMb(pMb, neighbour.mb); 757 availableD = h264bsdIsNeighbourAvailable(pMb, nMb); 758 if (availableD && constrainedIntraPred && 759 ( h264bsdMbPartPredMode(nMb->mbType) == PRED_MODE_INTER) ) 760 { 761 availableD = HANTRO_FALSE; 762 } 763 764 Get4x4NeighbourPels(a, l, data, above, left, block); 765 766 switch(mode) 767 { 768 case 0: /* Intra_4x4_Vertical */ 769 if (!availableB) 770 return(HANTRO_NOK); 771 Intra4x4VerticalPrediction((u8*)data4x4, a + 1); 772 break; 773 case 1: /* Intra_4x4_Horizontal */ 774 if (!availableA) 775 return(HANTRO_NOK); 776 Intra4x4HorizontalPrediction((u8*)data4x4, l + 1); 777 break; 778 case 2: /* Intra_4x4_DC */ 779 Intra4x4DcPrediction((u8*)data4x4, a + 1, l + 1, 780 availableA, availableB); 781 break; 782 case 3: /* Intra_4x4_Diagonal_Down_Left */ 783 if (!availableB) 784 return(HANTRO_NOK); 785 if (!availableC) 786 { 787 a[5] = a[6] = a[7] = a[8] = a[4]; 788 } 789 Intra4x4DiagonalDownLeftPrediction((u8*)data4x4, a + 1); 790 break; 791 case 4: /* Intra_4x4_Diagonal_Down_Right */ 792 if (!availableA || !availableB || !availableD) 793 return(HANTRO_NOK); 794 Intra4x4DiagonalDownRightPrediction((u8*)data4x4, a + 1, l + 1); 795 break; 796 case 5: /* Intra_4x4_Vertical_Right */ 797 if (!availableA || !availableB || !availableD) 798 return(HANTRO_NOK); 799 Intra4x4VerticalRightPrediction((u8*)data4x4, a + 1, l + 1); 800 break; 801 case 6: /* Intra_4x4_Horizontal_Down */ 802 if (!availableA || !availableB || !availableD) 803 return(HANTRO_NOK); 804 Intra4x4HorizontalDownPrediction((u8*)data4x4, a + 1, l + 1); 805 break; 806 case 7: /* Intra_4x4_Vertical_Left */ 807 if (!availableB) 808 return(HANTRO_NOK); 809 if (!availableC) 810 { 811 a[5] = a[6] = a[7] = a[8] = a[4]; 812 } 813 Intra4x4VerticalLeftPrediction((u8*)data4x4, a + 1); 814 break; 815 default: /* case 8 Intra_4x4_Horizontal_Up */ 816 if (!availableA) 817 return(HANTRO_NOK); 818 Intra4x4HorizontalUpPrediction((u8*)data4x4, l + 1); 819 break; 820 } 821 822 Write4x4To16x16(data, (u8*)data4x4, block); 823 h264bsdAddResidual(data, mbLayer->residual.level[block], block); 824 } 825 826 return(HANTRO_OK); 827 828 } 829 830 /*------------------------------------------------------------------------------ 831 832 Function: IntraChromaPrediction 833 834 Functional description: 835 Perform intra prediction for chroma pixels and add residual 836 into prediction. The resulting chroma pixels are stored in 'data'. 837 838 ------------------------------------------------------------------------------*/ 839 840 u32 h264bsdIntraChromaPrediction(mbStorage_t *pMb, u8 *data, i32 residual[][16], 841 u8 *above, u8 *left, u32 predMode, u32 constrainedIntraPred) 842 { 843 844 /* Variables */ 845 846 u32 i, comp, block; 847 u32 availableA, availableB, availableD; 848 849 /* Code */ 850 851 ASSERT(data); 852 ASSERT(residual); 853 ASSERT(above); 854 ASSERT(left); 855 ASSERT(predMode < 4); 856 857 availableA = h264bsdIsNeighbourAvailable(pMb, pMb->mbA); 858 if (availableA && constrainedIntraPred && 859 (h264bsdMbPartPredMode(pMb->mbA->mbType) == PRED_MODE_INTER)) 860 availableA = HANTRO_FALSE; 861 availableB = h264bsdIsNeighbourAvailable(pMb, pMb->mbB); 862 if (availableB && constrainedIntraPred && 863 (h264bsdMbPartPredMode(pMb->mbB->mbType) == PRED_MODE_INTER)) 864 availableB = HANTRO_FALSE; 865 availableD = h264bsdIsNeighbourAvailable(pMb, pMb->mbD); 866 if (availableD && constrainedIntraPred && 867 (h264bsdMbPartPredMode(pMb->mbD->mbType) == PRED_MODE_INTER)) 868 availableD = HANTRO_FALSE; 869 870 for (comp = 0, block = 16; comp < 2; comp++) 871 { 872 switch(predMode) 873 { 874 case 0: /* Intra_Chroma_DC */ 875 IntraChromaDcPrediction(data, above+1, left, availableA, 876 availableB); 877 break; 878 879 case 1: /* Intra_Chroma_Horizontal */ 880 if (!availableA) 881 return(HANTRO_NOK); 882 IntraChromaHorizontalPrediction(data, left); 883 break; 884 885 case 2: /* Intra_Chroma_Vertical */ 886 if (!availableB) 887 return(HANTRO_NOK); 888 IntraChromaVerticalPrediction(data, above+1); 889 890 break; 891 892 default: /* case 3: Intra_Chroma_Plane */ 893 if (!availableA || !availableB || !availableD) 894 return(HANTRO_NOK); 895 IntraChromaPlanePrediction(data, above+1, left); 896 break; 897 } 898 for (i = 0; i < 4; i++, block++) 899 h264bsdAddResidual(data, residual[i], block); 900 901 /* advance pointers */ 902 data += 64; 903 above += 9; 904 left += 8; 905 residual += 4; 906 } 907 908 return(HANTRO_OK); 909 910 } 911 912 /*------------------------------------------------------------------------------ 913 914 Function: h264bsdAddResidual 915 916 Functional description: 917 Add residual of a block into prediction in macroblock array 'data'. 918 The result (residual + prediction) is stored in 'data'. 919 920 ------------------------------------------------------------------------------*/ 921 #ifndef H264DEC_OMXDL 922 void h264bsdAddResidual(u8 *data, i32 *residual, u32 blockNum) 923 { 924 925 /* Variables */ 926 927 u32 i; 928 u32 x, y; 929 u32 width; 930 i32 tmp1, tmp2, tmp3, tmp4; 931 u8 *tmp; 932 const u8 *clp = h264bsdClip + 512; 933 934 /* Code */ 935 936 ASSERT(data); 937 ASSERT(residual); 938 ASSERT(blockNum < 16 + 4 + 4); 939 940 if (IS_RESIDUAL_EMPTY(residual)) 941 return; 942 943 RANGE_CHECK_ARRAY(residual, -512, 511, 16); 944 945 if (blockNum < 16) 946 { 947 width = 16; 948 x = h264bsdBlockX[blockNum]; 949 y = h264bsdBlockY[blockNum]; 950 } 951 else 952 { 953 width = 8; 954 x = h264bsdBlockX[blockNum & 0x3]; 955 y = h264bsdBlockY[blockNum & 0x3]; 956 } 957 958 tmp = data + y*width + x; 959 for (i = 4; i; i--) 960 { 961 tmp1 = *residual++; 962 tmp2 = tmp[0]; 963 tmp3 = *residual++; 964 tmp4 = tmp[1]; 965 966 tmp[0] = clp[tmp1 + tmp2]; 967 968 tmp1 = *residual++; 969 tmp2 = tmp[2]; 970 971 tmp[1] = clp[tmp3 + tmp4]; 972 973 tmp3 = *residual++; 974 tmp4 = tmp[3]; 975 976 tmp1 = clp[tmp1 + tmp2]; 977 tmp3 = clp[tmp3 + tmp4]; 978 tmp[2] = (u8)tmp1; 979 tmp[3] = (u8)tmp3; 980 981 tmp += width; 982 } 983 984 } 985 #endif 986 /*------------------------------------------------------------------------------ 987 988 Function: Intra16x16VerticalPrediction 989 990 Functional description: 991 Perform intra 16x16 vertical prediction mode. 992 993 ------------------------------------------------------------------------------*/ 994 995 void Intra16x16VerticalPrediction(u8 *data, u8 *above) 996 { 997 998 /* Variables */ 999 1000 u32 i, j; 1001 1002 /* Code */ 1003 1004 ASSERT(data); 1005 ASSERT(above); 1006 1007 for (i = 0; i < 16; i++) 1008 { 1009 for (j = 0; j < 16; j++) 1010 { 1011 *data++ = above[j]; 1012 } 1013 } 1014 1015 } 1016 1017 /*------------------------------------------------------------------------------ 1018 1019 Function: Intra16x16HorizontalPrediction 1020 1021 Functional description: 1022 Perform intra 16x16 horizontal prediction mode. 1023 1024 ------------------------------------------------------------------------------*/ 1025 1026 void Intra16x16HorizontalPrediction(u8 *data, u8 *left) 1027 { 1028 1029 /* Variables */ 1030 1031 u32 i, j; 1032 1033 /* Code */ 1034 1035 ASSERT(data); 1036 ASSERT(left); 1037 1038 for (i = 0; i < 16; i++) 1039 { 1040 for (j = 0; j < 16; j++) 1041 { 1042 *data++ = left[i]; 1043 } 1044 } 1045 1046 } 1047 1048 /*------------------------------------------------------------------------------ 1049 1050 Function: Intra16x16DcPrediction 1051 1052 Functional description: 1053 Perform intra 16x16 DC prediction mode. 1054 1055 ------------------------------------------------------------------------------*/ 1056 1057 void Intra16x16DcPrediction(u8 *data, u8 *above, u8 *left, u32 availableA, 1058 u32 availableB) 1059 { 1060 1061 /* Variables */ 1062 1063 u32 i, tmp; 1064 1065 /* Code */ 1066 1067 ASSERT(data); 1068 ASSERT(above); 1069 ASSERT(left); 1070 1071 if (availableA && availableB) 1072 { 1073 for (i = 0, tmp = 0; i < 16; i++) 1074 tmp += above[i] + left[i]; 1075 tmp = (tmp + 16) >> 5; 1076 } 1077 else if (availableA) 1078 { 1079 for (i = 0, tmp = 0; i < 16; i++) 1080 tmp += left[i]; 1081 tmp = (tmp + 8) >> 4; 1082 } 1083 else if (availableB) 1084 { 1085 for (i = 0, tmp = 0; i < 16; i++) 1086 tmp += above[i]; 1087 tmp = (tmp + 8) >> 4; 1088 } 1089 /* neither A nor B available */ 1090 else 1091 { 1092 tmp = 128; 1093 } 1094 for (i = 0; i < 256; i++) 1095 data[i] = (u8)tmp; 1096 1097 } 1098 1099 /*------------------------------------------------------------------------------ 1100 1101 Function: Intra16x16PlanePrediction 1102 1103 Functional description: 1104 Perform intra 16x16 plane prediction mode. 1105 1106 ------------------------------------------------------------------------------*/ 1107 1108 void Intra16x16PlanePrediction(u8 *data, u8 *above, u8 *left) 1109 { 1110 1111 /* Variables */ 1112 1113 u32 i, j; 1114 i32 a, b, c; 1115 i32 tmp; 1116 1117 /* Code */ 1118 1119 ASSERT(data); 1120 ASSERT(above); 1121 ASSERT(left); 1122 1123 a = 16 * (above[15] + left[15]); 1124 1125 for (i = 0, b = 0; i < 8; i++) 1126 b += ((i32)i + 1) * (above[8+i] - above[6-i]); 1127 b = (5 * b + 32) >> 6; 1128 1129 for (i = 0, c = 0; i < 7; i++) 1130 c += ((i32)i + 1) * (left[8+i] - left[6-i]); 1131 /* p[-1,-1] has to be accessed through above pointer */ 1132 c += ((i32)i + 1) * (left[8+i] - above[-1]); 1133 c = (5 * c + 32) >> 6; 1134 1135 for (i = 0; i < 16; i++) 1136 { 1137 for (j = 0; j < 16; j++) 1138 { 1139 tmp = (a + b * ((i32)j - 7) + c * ((i32)i - 7) + 16) >> 5; 1140 data[i*16+j] = (u8)CLIP1(tmp); 1141 } 1142 } 1143 1144 } 1145 1146 /*------------------------------------------------------------------------------ 1147 1148 Function: IntraChromaDcPrediction 1149 1150 Functional description: 1151 Perform intra chroma DC prediction mode. 1152 1153 ------------------------------------------------------------------------------*/ 1154 1155 void IntraChromaDcPrediction(u8 *data, u8 *above, u8 *left, u32 availableA, 1156 u32 availableB) 1157 { 1158 1159 /* Variables */ 1160 1161 u32 i; 1162 u32 tmp1, tmp2; 1163 1164 /* Code */ 1165 1166 ASSERT(data); 1167 ASSERT(above); 1168 ASSERT(left); 1169 1170 /* y = 0..3 */ 1171 if (availableA && availableB) 1172 { 1173 tmp1 = above[0] + above[1] + above[2] + above[3] + 1174 left[0] + left[1] + left[2] + left[3]; 1175 tmp1 = (tmp1 + 4) >> 3; 1176 tmp2 = (above[4] + above[5] + above[6] + above[7] + 2) >> 2; 1177 } 1178 else if (availableB) 1179 { 1180 tmp1 = (above[0] + above[1] + above[2] + above[3] + 2) >> 2; 1181 tmp2 = (above[4] + above[5] + above[6] + above[7] + 2) >> 2; 1182 } 1183 else if (availableA) 1184 { 1185 tmp1 = (left[0] + left[1] + left[2] + left[3] + 2) >> 2; 1186 tmp2 = tmp1; 1187 } 1188 /* neither A nor B available */ 1189 else 1190 { 1191 tmp1 = tmp2 = 128; 1192 } 1193 1194 ASSERT(tmp1 < 256 && tmp2 < 256); 1195 for (i = 4; i--;) 1196 { 1197 *data++ = (u8)tmp1; 1198 *data++ = (u8)tmp1; 1199 *data++ = (u8)tmp1; 1200 *data++ = (u8)tmp1; 1201 *data++ = (u8)tmp2; 1202 *data++ = (u8)tmp2; 1203 *data++ = (u8)tmp2; 1204 *data++ = (u8)tmp2; 1205 } 1206 1207 /* y = 4...7 */ 1208 if (availableA) 1209 { 1210 tmp1 = (left[4] + left[5] + left[6] + left[7] + 2) >> 2; 1211 if (availableB) 1212 { 1213 tmp2 = above[4] + above[5] + above[6] + above[7] + 1214 left[4] + left[5] + left[6] + left[7]; 1215 tmp2 = (tmp2 + 4) >> 3; 1216 } 1217 else 1218 tmp2 = tmp1; 1219 } 1220 else if (availableB) 1221 { 1222 tmp1 = (above[0] + above[1] + above[2] + above[3] + 2) >> 2; 1223 tmp2 = (above[4] + above[5] + above[6] + above[7] + 2) >> 2; 1224 } 1225 else 1226 { 1227 tmp1 = tmp2 = 128; 1228 } 1229 1230 ASSERT(tmp1 < 256 && tmp2 < 256); 1231 for (i = 4; i--;) 1232 { 1233 *data++ = (u8)tmp1; 1234 *data++ = (u8)tmp1; 1235 *data++ = (u8)tmp1; 1236 *data++ = (u8)tmp1; 1237 *data++ = (u8)tmp2; 1238 *data++ = (u8)tmp2; 1239 *data++ = (u8)tmp2; 1240 *data++ = (u8)tmp2; 1241 } 1242 } 1243 1244 /*------------------------------------------------------------------------------ 1245 1246 Function: IntraChromaHorizontalPrediction 1247 1248 Functional description: 1249 Perform intra chroma horizontal prediction mode. 1250 1251 ------------------------------------------------------------------------------*/ 1252 1253 void IntraChromaHorizontalPrediction(u8 *data, u8 *left) 1254 { 1255 1256 /* Variables */ 1257 1258 u32 i; 1259 1260 /* Code */ 1261 1262 ASSERT(data); 1263 ASSERT(left); 1264 1265 for (i = 8; i--;) 1266 { 1267 *data++ = *left; 1268 *data++ = *left; 1269 *data++ = *left; 1270 *data++ = *left; 1271 *data++ = *left; 1272 *data++ = *left; 1273 *data++ = *left; 1274 *data++ = *left++; 1275 } 1276 1277 } 1278 1279 /*------------------------------------------------------------------------------ 1280 1281 Function: IntraChromaVerticalPrediction 1282 1283 Functional description: 1284 Perform intra chroma vertical prediction mode. 1285 1286 ------------------------------------------------------------------------------*/ 1287 1288 void IntraChromaVerticalPrediction(u8 *data, u8 *above) 1289 { 1290 1291 /* Variables */ 1292 1293 u32 i; 1294 1295 /* Code */ 1296 1297 ASSERT(data); 1298 ASSERT(above); 1299 1300 for (i = 8; i--;data++/*above-=8*/) 1301 { 1302 data[0] = *above; 1303 data[8] = *above; 1304 data[16] = *above; 1305 data[24] = *above; 1306 data[32] = *above; 1307 data[40] = *above; 1308 data[48] = *above; 1309 data[56] = *above++; 1310 } 1311 1312 } 1313 1314 /*------------------------------------------------------------------------------ 1315 1316 Function: IntraChromaPlanePrediction 1317 1318 Functional description: 1319 Perform intra chroma plane prediction mode. 1320 1321 ------------------------------------------------------------------------------*/ 1322 1323 void IntraChromaPlanePrediction(u8 *data, u8 *above, u8 *left) 1324 { 1325 1326 /* Variables */ 1327 1328 u32 i; 1329 i32 a, b, c; 1330 i32 tmp; 1331 const u8 *clp = h264bsdClip + 512; 1332 1333 /* Code */ 1334 1335 ASSERT(data); 1336 ASSERT(above); 1337 ASSERT(left); 1338 1339 a = 16 * (above[7] + left[7]); 1340 1341 b = (above[4] - above[2]) + 2 * (above[5] - above[1]) 1342 + 3 * (above[6] - above[0]) + 4 * (above[7] - above[-1]); 1343 b = (17 * b + 16) >> 5; 1344 1345 /* p[-1,-1] has to be accessed through above pointer */ 1346 c = (left[4] - left[2]) + 2 * (left[5] - left[1]) 1347 + 3 * (left[6] - left[0]) + 4 * (left[7] - above[-1]); 1348 c = (17 * c + 16) >> 5; 1349 1350 /*a += 16;*/ 1351 a = a - 3 * c + 16; 1352 for (i = 8; i--; a += c) 1353 { 1354 tmp = (a - 3 * b); 1355 *data++ = clp[tmp>>5]; 1356 tmp += b; 1357 *data++ = clp[tmp>>5]; 1358 tmp += b; 1359 *data++ = clp[tmp>>5]; 1360 tmp += b; 1361 *data++ = clp[tmp>>5]; 1362 tmp += b; 1363 *data++ = clp[tmp>>5]; 1364 tmp += b; 1365 *data++ = clp[tmp>>5]; 1366 tmp += b; 1367 *data++ = clp[tmp>>5]; 1368 tmp += b; 1369 *data++ = clp[tmp>>5]; 1370 } 1371 1372 } 1373 1374 /*------------------------------------------------------------------------------ 1375 1376 Function: Get4x4NeighbourPels 1377 1378 Functional description: 1379 Get neighbouring pixels of a 4x4 block into 'a' and 'l'. 1380 1381 ------------------------------------------------------------------------------*/ 1382 1383 void Get4x4NeighbourPels(u8 *a, u8 *l, u8 *data, u8 *above, u8 *left, 1384 u32 blockNum) 1385 { 1386 1387 /* Variables */ 1388 1389 u32 x, y; 1390 u8 t1, t2; 1391 1392 /* Code */ 1393 1394 ASSERT(a); 1395 ASSERT(l); 1396 ASSERT(data); 1397 ASSERT(above); 1398 ASSERT(left); 1399 ASSERT(blockNum < 16); 1400 1401 x = h264bsdBlockX[blockNum]; 1402 y = h264bsdBlockY[blockNum]; 1403 1404 /* A and D */ 1405 if (x == 0) 1406 { 1407 t1 = left[y ]; 1408 t2 = left[y + 1]; 1409 l[1] = t1; 1410 l[2] = t2; 1411 t1 = left[y + 2]; 1412 t2 = left[y + 3]; 1413 l[3] = t1; 1414 l[4] = t2; 1415 } 1416 else 1417 { 1418 t1 = data[y * 16 + x - 1 ]; 1419 t2 = data[y * 16 + x - 1 + 16]; 1420 l[1] = t1; 1421 l[2] = t2; 1422 t1 = data[y * 16 + x - 1 + 32]; 1423 t2 = data[y * 16 + x - 1 + 48]; 1424 l[3] = t1; 1425 l[4] = t2; 1426 } 1427 1428 /* B, C and D */ 1429 if (y == 0) 1430 { 1431 t1 = above[x ]; 1432 t2 = above[x ]; 1433 l[0] = t1; 1434 a[0] = t2; 1435 t1 = above[x + 1]; 1436 t2 = above[x + 2]; 1437 a[1] = t1; 1438 a[2] = t2; 1439 t1 = above[x + 3]; 1440 t2 = above[x + 4]; 1441 a[3] = t1; 1442 a[4] = t2; 1443 t1 = above[x + 5]; 1444 t2 = above[x + 6]; 1445 a[5] = t1; 1446 a[6] = t2; 1447 t1 = above[x + 7]; 1448 t2 = above[x + 8]; 1449 a[7] = t1; 1450 a[8] = t2; 1451 } 1452 else 1453 { 1454 t1 = data[(y - 1) * 16 + x ]; 1455 t2 = data[(y - 1) * 16 + x + 1]; 1456 a[1] = t1; 1457 a[2] = t2; 1458 t1 = data[(y - 1) * 16 + x + 2]; 1459 t2 = data[(y - 1) * 16 + x + 3]; 1460 a[3] = t1; 1461 a[4] = t2; 1462 t1 = data[(y - 1) * 16 + x + 4]; 1463 t2 = data[(y - 1) * 16 + x + 5]; 1464 a[5] = t1; 1465 a[6] = t2; 1466 t1 = data[(y - 1) * 16 + x + 6]; 1467 t2 = data[(y - 1) * 16 + x + 7]; 1468 a[7] = t1; 1469 a[8] = t2; 1470 1471 if (x == 0) 1472 l[0] = a[0] = left[y-1]; 1473 else 1474 l[0] = a[0] = data[(y - 1) * 16 + x - 1]; 1475 } 1476 } 1477 1478 1479 /*------------------------------------------------------------------------------ 1480 1481 Function: Intra4x4VerticalPrediction 1482 1483 Functional description: 1484 Perform intra 4x4 vertical prediction mode. 1485 1486 ------------------------------------------------------------------------------*/ 1487 1488 void Intra4x4VerticalPrediction(u8 *data, u8 *above) 1489 { 1490 1491 /* Variables */ 1492 1493 u8 t1, t2; 1494 1495 /* Code */ 1496 1497 ASSERT(data); 1498 ASSERT(above); 1499 1500 t1 = above[0]; 1501 t2 = above[1]; 1502 data[0] = data[4] = data[8] = data[12] = t1; 1503 data[1] = data[5] = data[9] = data[13] = t2; 1504 t1 = above[2]; 1505 t2 = above[3]; 1506 data[2] = data[6] = data[10] = data[14] = t1; 1507 data[3] = data[7] = data[11] = data[15] = t2; 1508 1509 } 1510 1511 /*------------------------------------------------------------------------------ 1512 1513 Function: Intra4x4HorizontalPrediction 1514 1515 Functional description: 1516 Perform intra 4x4 horizontal prediction mode. 1517 1518 ------------------------------------------------------------------------------*/ 1519 1520 void Intra4x4HorizontalPrediction(u8 *data, u8 *left) 1521 { 1522 1523 /* Variables */ 1524 1525 u8 t1, t2; 1526 1527 /* Code */ 1528 1529 ASSERT(data); 1530 ASSERT(left); 1531 1532 t1 = left[0]; 1533 t2 = left[1]; 1534 data[0] = data[1] = data[2] = data[3] = t1; 1535 data[4] = data[5] = data[6] = data[7] = t2; 1536 t1 = left[2]; 1537 t2 = left[3]; 1538 data[8] = data[9] = data[10] = data[11] = t1; 1539 data[12] = data[13] = data[14] = data[15] = t2; 1540 1541 } 1542 1543 /*------------------------------------------------------------------------------ 1544 1545 Function: Intra4x4DcPrediction 1546 1547 Functional description: 1548 Perform intra 4x4 DC prediction mode. 1549 1550 ------------------------------------------------------------------------------*/ 1551 1552 void Intra4x4DcPrediction(u8 *data, u8 *above, u8 *left, u32 availableA, 1553 u32 availableB) 1554 { 1555 1556 /* Variables */ 1557 1558 u32 tmp; 1559 u8 t1, t2, t3, t4; 1560 1561 /* Code */ 1562 1563 ASSERT(data); 1564 ASSERT(above); 1565 ASSERT(left); 1566 1567 if (availableA && availableB) 1568 { 1569 t1 = above[0]; t2 = above[1]; t3 = above[2]; t4 = above[3]; 1570 tmp = t1 + t2 + t3 + t4; 1571 t1 = left[0]; t2 = left[1]; t3 = left[2]; t4 = left[3]; 1572 tmp += t1 + t2 + t3 + t4; 1573 tmp = (tmp + 4) >> 3; 1574 } 1575 else if (availableA) 1576 { 1577 t1 = left[0]; t2 = left[1]; t3 = left[2]; t4 = left[3]; 1578 tmp = (t1 + t2 + t3 + t4 + 2) >> 2; 1579 } 1580 else if (availableB) 1581 { 1582 t1 = above[0]; t2 = above[1]; t3 = above[2]; t4 = above[3]; 1583 tmp = (t1 + t2 + t3 + t4 + 2) >> 2; 1584 } 1585 else 1586 { 1587 tmp = 128; 1588 } 1589 1590 ASSERT(tmp < 256); 1591 data[0] = data[1] = data[2] = data[3] = 1592 data[4] = data[5] = data[6] = data[7] = 1593 data[8] = data[9] = data[10] = data[11] = 1594 data[12] = data[13] = data[14] = data[15] = (u8)tmp; 1595 1596 } 1597 1598 /*------------------------------------------------------------------------------ 1599 1600 Function: Intra4x4DiagonalDownLeftPrediction 1601 1602 Functional description: 1603 Perform intra 4x4 diagonal down-left prediction mode. 1604 1605 ------------------------------------------------------------------------------*/ 1606 1607 void Intra4x4DiagonalDownLeftPrediction(u8 *data, u8 *above) 1608 { 1609 1610 /* Variables */ 1611 1612 /* Code */ 1613 1614 ASSERT(data); 1615 ASSERT(above); 1616 1617 data[ 0] = (above[0] + 2 * above[1] + above[2] + 2) >> 2; 1618 data[ 1] = (above[1] + 2 * above[2] + above[3] + 2) >> 2; 1619 data[ 4] = (above[1] + 2 * above[2] + above[3] + 2) >> 2; 1620 data[ 2] = (above[2] + 2 * above[3] + above[4] + 2) >> 2; 1621 data[ 5] = (above[2] + 2 * above[3] + above[4] + 2) >> 2; 1622 data[ 8] = (above[2] + 2 * above[3] + above[4] + 2) >> 2; 1623 data[ 3] = (above[3] + 2 * above[4] + above[5] + 2) >> 2; 1624 data[ 6] = (above[3] + 2 * above[4] + above[5] + 2) >> 2; 1625 data[ 9] = (above[3] + 2 * above[4] + above[5] + 2) >> 2; 1626 data[12] = (above[3] + 2 * above[4] + above[5] + 2) >> 2; 1627 data[ 7] = (above[4] + 2 * above[5] + above[6] + 2) >> 2; 1628 data[10] = (above[4] + 2 * above[5] + above[6] + 2) >> 2; 1629 data[13] = (above[4] + 2 * above[5] + above[6] + 2) >> 2; 1630 data[11] = (above[5] + 2 * above[6] + above[7] + 2) >> 2; 1631 data[14] = (above[5] + 2 * above[6] + above[7] + 2) >> 2; 1632 data[15] = (above[6] + 3 * above[7] + 2) >> 2; 1633 1634 } 1635 1636 /*------------------------------------------------------------------------------ 1637 1638 Function: Intra4x4DiagonalDownRightPrediction 1639 1640 Functional description: 1641 Perform intra 4x4 diagonal down-right prediction mode. 1642 1643 ------------------------------------------------------------------------------*/ 1644 1645 void Intra4x4DiagonalDownRightPrediction(u8 *data, u8 *above, u8 *left) 1646 { 1647 1648 /* Variables */ 1649 1650 /* Code */ 1651 1652 ASSERT(data); 1653 ASSERT(above); 1654 ASSERT(left); 1655 1656 data[ 0] = (above[0] + 2 * above[-1] + left[0] + 2) >> 2; 1657 data[ 5] = (above[0] + 2 * above[-1] + left[0] + 2) >> 2; 1658 data[10] = (above[0] + 2 * above[-1] + left[0] + 2) >> 2; 1659 data[15] = (above[0] + 2 * above[-1] + left[0] + 2) >> 2; 1660 data[ 1] = (above[-1] + 2 * above[0] + above[1] + 2) >> 2; 1661 data[ 6] = (above[-1] + 2 * above[0] + above[1] + 2) >> 2; 1662 data[11] = (above[-1] + 2 * above[0] + above[1] + 2) >> 2; 1663 data[ 2] = (above[0] + 2 * above[1] + above[2] + 2) >> 2; 1664 data[ 7] = (above[0] + 2 * above[1] + above[2] + 2) >> 2; 1665 data[ 3] = (above[1] + 2 * above[2] + above[3] + 2) >> 2; 1666 data[ 4] = (left[-1] + 2 * left[0] + left[1] + 2) >> 2; 1667 data[ 9] = (left[-1] + 2 * left[0] + left[1] + 2) >> 2; 1668 data[14] = (left[-1] + 2 * left[0] + left[1] + 2) >> 2; 1669 data[ 8] = (left[0] + 2 * left[1] + left[2] + 2) >> 2; 1670 data[13] = (left[0] + 2 * left[1] + left[2] + 2) >> 2; 1671 data[12] = (left[1] + 2 * left[2] + left[3] + 2) >> 2; 1672 } 1673 1674 /*------------------------------------------------------------------------------ 1675 1676 Function: Intra4x4VerticalRightPrediction 1677 1678 Functional description: 1679 Perform intra 4x4 vertical right prediction mode. 1680 1681 ------------------------------------------------------------------------------*/ 1682 1683 void Intra4x4VerticalRightPrediction(u8 *data, u8 *above, u8 *left) 1684 { 1685 1686 /* Variables */ 1687 1688 /* Code */ 1689 1690 ASSERT(data); 1691 ASSERT(above); 1692 ASSERT(left); 1693 1694 data[ 0] = (above[-1] + above[0] + 1) >> 1; 1695 data[ 9] = (above[-1] + above[0] + 1) >> 1; 1696 data[ 5] = (above[-1] + 2 * above[0] + above[1] + 2) >> 2; 1697 data[14] = (above[-1] + 2 * above[0] + above[1] + 2) >> 2; 1698 data[ 4] = (above[0] + 2 * above[-1] + left[0] + 2) >> 2; 1699 data[13] = (above[0] + 2 * above[-1] + left[0] + 2) >> 2; 1700 data[ 1] = (above[0] + above[1] + 1) >> 1; 1701 data[10] = (above[0] + above[1] + 1) >> 1; 1702 data[ 6] = (above[0] + 2 * above[1] + above[2] + 2) >> 2; 1703 data[15] = (above[0] + 2 * above[1] + above[2] + 2) >> 2; 1704 data[ 2] = (above[1] + above[2] + 1) >> 1; 1705 data[11] = (above[1] + above[2] + 1) >> 1; 1706 data[ 7] = (above[1] + 2 * above[2] + above[3] + 2) >> 2; 1707 data[ 3] = (above[2] + above[3] + 1) >> 1; 1708 data[ 8] = (left[1] + 2 * left[0] + left[-1] + 2) >> 2; 1709 data[12] = (left[2] + 2 * left[1] + left[0] + 2) >> 2; 1710 1711 } 1712 1713 /*------------------------------------------------------------------------------ 1714 1715 Function: Intra4x4HorizontalDownPrediction 1716 1717 Functional description: 1718 Perform intra 4x4 horizontal down prediction mode. 1719 1720 ------------------------------------------------------------------------------*/ 1721 1722 void Intra4x4HorizontalDownPrediction(u8 *data, u8 *above, u8 *left) 1723 { 1724 1725 /* Variables */ 1726 1727 /* Code */ 1728 1729 ASSERT(data); 1730 ASSERT(above); 1731 ASSERT(left); 1732 1733 data[ 0] = (left[-1] + left[0] + 1) >> 1; 1734 data[ 6] = (left[-1] + left[0] + 1) >> 1; 1735 data[ 5] = (left[-1] + 2 * left[0] + left[1] + 2) >> 2; 1736 data[11] = (left[-1] + 2 * left[0] + left[1] + 2) >> 2; 1737 data[ 4] = (left[0] + left[1] + 1) >> 1; 1738 data[10] = (left[0] + left[1] + 1) >> 1; 1739 data[ 9] = (left[0] + 2 * left[1] + left[2] + 2) >> 2; 1740 data[15] = (left[0] + 2 * left[1] + left[2] + 2) >> 2; 1741 data[ 8] = (left[1] + left[2] + 1) >> 1; 1742 data[14] = (left[1] + left[2] + 1) >> 1; 1743 data[13] = (left[1] + 2 * left[2] + left[3] + 2) >> 2; 1744 data[12] = (left[2] + left[3] + 1) >> 1; 1745 data[ 1] = (above[0] + 2 * above[-1] + left[0] + 2) >> 2; 1746 data[ 7] = (above[0] + 2 * above[-1] + left[0] + 2) >> 2; 1747 data[ 2] = (above[1] + 2 * above[0] + above[-1] + 2) >> 2; 1748 data[ 3] = (above[2] + 2 * above[1] + above[0] + 2) >> 2; 1749 } 1750 1751 /*------------------------------------------------------------------------------ 1752 1753 Function: Intra4x4VerticalLeftPrediction 1754 1755 Functional description: 1756 Perform intra 4x4 vertical left prediction mode. 1757 1758 ------------------------------------------------------------------------------*/ 1759 1760 void Intra4x4VerticalLeftPrediction(u8 *data, u8 *above) 1761 { 1762 1763 /* Variables */ 1764 1765 /* Code */ 1766 1767 ASSERT(data); 1768 ASSERT(above); 1769 1770 data[ 0] = (above[0] + above[1] + 1) >> 1; 1771 data[ 1] = (above[1] + above[2] + 1) >> 1; 1772 data[ 2] = (above[2] + above[3] + 1) >> 1; 1773 data[ 3] = (above[3] + above[4] + 1) >> 1; 1774 data[ 4] = (above[0] + 2 * above[1] + above[2] + 2) >> 2; 1775 data[ 5] = (above[1] + 2 * above[2] + above[3] + 2) >> 2; 1776 data[ 6] = (above[2] + 2 * above[3] + above[4] + 2) >> 2; 1777 data[ 7] = (above[3] + 2 * above[4] + above[5] + 2) >> 2; 1778 data[ 8] = (above[1] + above[2] + 1) >> 1; 1779 data[ 9] = (above[2] + above[3] + 1) >> 1; 1780 data[10] = (above[3] + above[4] + 1) >> 1; 1781 data[11] = (above[4] + above[5] + 1) >> 1; 1782 data[12] = (above[1] + 2 * above[2] + above[3] + 2) >> 2; 1783 data[13] = (above[2] + 2 * above[3] + above[4] + 2) >> 2; 1784 data[14] = (above[3] + 2 * above[4] + above[5] + 2) >> 2; 1785 data[15] = (above[4] + 2 * above[5] + above[6] + 2) >> 2; 1786 1787 } 1788 1789 /*------------------------------------------------------------------------------ 1790 1791 Function: Intra4x4HorizontalUpPrediction 1792 1793 Functional description: 1794 Perform intra 4x4 horizontal up prediction mode. 1795 1796 ------------------------------------------------------------------------------*/ 1797 1798 void Intra4x4HorizontalUpPrediction(u8 *data, u8 *left) 1799 { 1800 1801 /* Variables */ 1802 1803 /* Code */ 1804 1805 ASSERT(data); 1806 ASSERT(left); 1807 1808 data[ 0] = (left[0] + left[1] + 1) >> 1; 1809 data[ 1] = (left[0] + 2 * left[1] + left[2] + 2) >> 2; 1810 data[ 2] = (left[1] + left[2] + 1) >> 1; 1811 data[ 3] = (left[1] + 2 * left[2] + left[3] + 2) >> 2; 1812 data[ 4] = (left[1] + left[2] + 1) >> 1; 1813 data[ 5] = (left[1] + 2 * left[2] + left[3] + 2) >> 2; 1814 data[ 6] = (left[2] + left[3] + 1) >> 1; 1815 data[ 7] = (left[2] + 3 * left[3] + 2) >> 2; 1816 data[ 8] = (left[2] + left[3] + 1) >> 1; 1817 data[ 9] = (left[2] + 3 * left[3] + 2) >> 2; 1818 data[10] = left[3]; 1819 data[11] = left[3]; 1820 data[12] = left[3]; 1821 data[13] = left[3]; 1822 data[14] = left[3]; 1823 data[15] = left[3]; 1824 1825 } 1826 1827 #endif /* H264DEC_OMXDL */ 1828 1829 /*------------------------------------------------------------------------------ 1830 1831 Function: Write4x4To16x16 1832 1833 Functional description: 1834 Write a 4x4 block (data4x4) into correct position 1835 in 16x16 macroblock (data). 1836 1837 ------------------------------------------------------------------------------*/ 1838 1839 void Write4x4To16x16(u8 *data, u8 *data4x4, u32 blockNum) 1840 { 1841 1842 /* Variables */ 1843 1844 u32 x, y; 1845 u32 *in32, *out32; 1846 1847 /* Code */ 1848 1849 ASSERT(data); 1850 ASSERT(data4x4); 1851 ASSERT(blockNum < 16); 1852 1853 x = h264bsdBlockX[blockNum]; 1854 y = h264bsdBlockY[blockNum]; 1855 1856 data += y*16+x; 1857 1858 ASSERT(((u32)data&0x3) == 0); 1859 1860 /*lint --e(826) */ 1861 out32 = (u32 *)data; 1862 /*lint --e(826) */ 1863 in32 = (u32 *)data4x4; 1864 1865 out32[0] = *in32++; 1866 out32[4] = *in32++; 1867 out32[8] = *in32++; 1868 out32[12] = *in32++; 1869 } 1870 1871 /*------------------------------------------------------------------------------ 1872 1873 Function: DetermineIntra4x4PredMode 1874 1875 Functional description: 1876 Returns the intra 4x4 prediction mode of a block based on the 1877 neighbouring macroblocks and information parsed from stream. 1878 1879 ------------------------------------------------------------------------------*/ 1880 1881 u32 DetermineIntra4x4PredMode(macroblockLayer_t *pMbLayer, 1882 u32 available, neighbour_t *nA, neighbour_t *nB, u32 index, 1883 mbStorage_t *nMbA, mbStorage_t *nMbB) 1884 { 1885 1886 /* Variables */ 1887 1888 u32 mode1, mode2; 1889 mbStorage_t *pMb; 1890 1891 /* Code */ 1892 1893 ASSERT(pMbLayer); 1894 1895 /* dc only prediction? */ 1896 if (!available) 1897 mode1 = 2; 1898 else 1899 { 1900 pMb = nMbA; 1901 if (h264bsdMbPartPredMode(pMb->mbType) == PRED_MODE_INTRA4x4) 1902 { 1903 mode1 = pMb->intra4x4PredMode[nA->index]; 1904 } 1905 else 1906 mode1 = 2; 1907 1908 pMb = nMbB; 1909 if (h264bsdMbPartPredMode(pMb->mbType) == PRED_MODE_INTRA4x4) 1910 { 1911 mode2 = pMb->intra4x4PredMode[nB->index]; 1912 } 1913 else 1914 mode2 = 2; 1915 1916 mode1 = MIN(mode1, mode2); 1917 } 1918 1919 if (!pMbLayer->mbPred.prevIntra4x4PredModeFlag[index]) 1920 { 1921 if (pMbLayer->mbPred.remIntra4x4PredMode[index] < mode1) 1922 { 1923 mode1 = pMbLayer->mbPred.remIntra4x4PredMode[index]; 1924 } 1925 else 1926 { 1927 mode1 = pMbLayer->mbPred.remIntra4x4PredMode[index] + 1; 1928 } 1929 } 1930 1931 return(mode1); 1932 } 1933 1934 1935 /*lint +e702 */ 1936 1937 1938
