/* * Copyright (C) 2009 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /*------------------------------------------------------------------------------ Table of contents 1. Include headers 2. External compiler flags 3. Module defines 4. Local function prototypes 5. Functions ------------------------------------------------------------------------------*/ /*------------------------------------------------------------------------------ 1. Include headers ------------------------------------------------------------------------------*/ #include "basetype.h" #include "h264bsd_reconstruct.h" #include "h264bsd_macroblock_layer.h" #include "h264bsd_image.h" #include "h264bsd_util.h" #ifdef H264DEC_OMXDL #include "omxtypes.h" #include "omxVC.h" #include "armVC.h" #endif /* H264DEC_OMXDL */ #define UNUSED(x) (void)(x) /*------------------------------------------------------------------------------ 2. External compiler flags -------------------------------------------------------------------------------- -------------------------------------------------------------------------------- 3. Module defines ------------------------------------------------------------------------------*/ /* Switch off the following Lint messages for this file: * Info 701: Shift left of signed quantity (int) * Info 702: Shift right of signed quantity (int) */ /*lint -e701 -e702 */ /* Luma fractional-sample positions * * G a b c H * d e f g * h i j k m * n p q r * M s N * * G, H, M and N are integer sample positions * a-s are fractional samples that need to be interpolated. */ #ifndef H264DEC_OMXDL static const u32 lumaFracPos[4][4] = { /* G d h n a e i p b f j q c g k r */ {0, 1, 2, 3}, {4, 5, 6, 7}, {8, 9, 10, 11}, {12, 13, 14, 15}}; #endif /* H264DEC_OMXDL */ /* clipping table, defined in h264bsd_intra_prediction.c */ extern const u8 h264bsdClip[]; /*------------------------------------------------------------------------------ 4. Local function prototypes ------------------------------------------------------------------------------*/ #ifndef H264DEC_OMXDL /*------------------------------------------------------------------------------ Function: h264bsdInterpolateChromaHor Functional description: This function performs chroma interpolation in horizontal direction. Overfilling is done only if needed. Reference image (pRef) is read at correct position and the predicted part is written to macroblock's chrominance (predPartChroma) Inputs: pRef pointer to reference frame Cb top-left corner x0 integer x-coordinate for prediction y0 integer y-coordinate for prediction width width of the reference frame chrominance in pixels height height of the reference frame chrominance in pixels xFrac horizontal fraction for prediction in 1/8 pixels chromaPartWidth width of the predicted part in pixels chromaPartHeight height of the predicted part in pixels Outputs: predPartChroma pointer where predicted part is written ------------------------------------------------------------------------------*/ #ifndef H264DEC_ARM11 void h264bsdInterpolateChromaHor( u8 *pRef, u8 *predPartChroma, i32 x0, i32 y0, u32 width, u32 height, u32 xFrac, u32 chromaPartWidth, u32 chromaPartHeight) { /* Variables */ u32 x, y, tmp1, tmp2, tmp3, tmp4, c, val; u8 *ptrA, *cbr; u32 comp; u8 block[9*8*2]; /* Code */ ASSERT(predPartChroma); ASSERT(chromaPartWidth); ASSERT(chromaPartHeight); ASSERT(xFrac < 8); ASSERT(pRef); if ((x0 < 0) || ((u32)x0+chromaPartWidth+1 > width) || (y0 < 0) || ((u32)y0+chromaPartHeight > height)) { h264bsdFillBlock(pRef, block, x0, y0, width, height, chromaPartWidth + 1, chromaPartHeight, chromaPartWidth + 1); pRef += width * height; h264bsdFillBlock(pRef, block + (chromaPartWidth+1)*chromaPartHeight, x0, y0, width, height, chromaPartWidth + 1, chromaPartHeight, chromaPartWidth + 1); pRef = block; x0 = 0; y0 = 0; width = chromaPartWidth+1; height = chromaPartHeight; } val = 8 - xFrac; for (comp = 0; comp <= 1; comp++) { ptrA = pRef + (comp * height + (u32)y0) * width + x0; cbr = predPartChroma + comp * 8 * 8; /* 2x2 pels per iteration * bilinear horizontal interpolation */ for (y = (chromaPartHeight >> 1); y; y--) { for (x = (chromaPartWidth >> 1); x; x--) { tmp1 = ptrA[width]; tmp2 = *ptrA++; tmp3 = ptrA[width]; tmp4 = *ptrA++; c = ((val * tmp1 + xFrac * tmp3) << 3) + 32; c >>= 6; cbr[8] = (u8)c; c = ((val * tmp2 + xFrac * tmp4) << 3) + 32; c >>= 6; *cbr++ = (u8)c; tmp1 = ptrA[width]; tmp2 = *ptrA; c = ((val * tmp3 + xFrac * tmp1) << 3) + 32; c >>= 6; cbr[8] = (u8)c; c = ((val * tmp4 + xFrac * tmp2) << 3) + 32; c >>= 6; *cbr++ = (u8)c; } cbr += 2*8 - chromaPartWidth; ptrA += 2*width - chromaPartWidth; } } } /*------------------------------------------------------------------------------ Function: h264bsdInterpolateChromaVer Functional description: This function performs chroma interpolation in vertical direction. Overfilling is done only if needed. Reference image (pRef) is read at correct position and the predicted part is written to macroblock's chrominance (predPartChroma) ------------------------------------------------------------------------------*/ void h264bsdInterpolateChromaVer( u8 *pRef, u8 *predPartChroma, i32 x0, i32 y0, u32 width, u32 height, u32 yFrac, u32 chromaPartWidth, u32 chromaPartHeight) { /* Variables */ u32 x, y, tmp1, tmp2, tmp3, c, val; u8 *ptrA, *cbr; u32 comp; u8 block[9*8*2]; /* Code */ ASSERT(predPartChroma); ASSERT(chromaPartWidth); ASSERT(chromaPartHeight); ASSERT(yFrac < 8); ASSERT(pRef); if ((x0 < 0) || ((u32)x0+chromaPartWidth > width) || (y0 < 0) || ((u32)y0+chromaPartHeight+1 > height)) { h264bsdFillBlock(pRef, block, x0, y0, width, height, chromaPartWidth, chromaPartHeight + 1, chromaPartWidth); pRef += width * height; h264bsdFillBlock(pRef, block + chromaPartWidth*(chromaPartHeight+1), x0, y0, width, height, chromaPartWidth, chromaPartHeight + 1, chromaPartWidth); pRef = block; x0 = 0; y0 = 0; width = chromaPartWidth; height = chromaPartHeight+1; } val = 8 - yFrac; for (comp = 0; comp <= 1; comp++) { ptrA = pRef + (comp * height + (u32)y0) * width + x0; cbr = predPartChroma + comp * 8 * 8; /* 2x2 pels per iteration * bilinear vertical interpolation */ for (y = (chromaPartHeight >> 1); y; y--) { for (x = (chromaPartWidth >> 1); x; x--) { tmp3 = ptrA[width*2]; tmp2 = ptrA[width]; tmp1 = *ptrA++; c = ((val * tmp2 + yFrac * tmp3) << 3) + 32; c >>= 6; cbr[8] = (u8)c; c = ((val * tmp1 + yFrac * tmp2) << 3) + 32; c >>= 6; *cbr++ = (u8)c; tmp3 = ptrA[width*2]; tmp2 = ptrA[width]; tmp1 = *ptrA++; c = ((val * tmp2 + yFrac * tmp3) << 3) + 32; c >>= 6; cbr[8] = (u8)c; c = ((val * tmp1 + yFrac * tmp2) << 3) + 32; c >>= 6; *cbr++ = (u8)c; } cbr += 2*8 - chromaPartWidth; ptrA += 2*width - chromaPartWidth; } } } #endif /*------------------------------------------------------------------------------ Function: h264bsdInterpolateChromaHorVer Functional description: This function performs chroma interpolation in horizontal and vertical direction. Overfilling is done only if needed. Reference image (ref) is read at correct position and the predicted part is written to macroblock's chrominance (predPartChroma) ------------------------------------------------------------------------------*/ void h264bsdInterpolateChromaHorVer( u8 *ref, u8 *predPartChroma, i32 x0, i32 y0, u32 width, u32 height, u32 xFrac, u32 yFrac, u32 chromaPartWidth, u32 chromaPartHeight) { u8 block[9*9*2]; u32 x, y, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, valX, valY, plus32 = 32; u32 comp; u8 *ptrA, *cbr; /* Code */ ASSERT(predPartChroma); ASSERT(chromaPartWidth); ASSERT(chromaPartHeight); ASSERT(xFrac < 8); ASSERT(yFrac < 8); ASSERT(ref); if ((x0 < 0) || ((u32)x0+chromaPartWidth+1 > width) || (y0 < 0) || ((u32)y0+chromaPartHeight+1 > height)) { h264bsdFillBlock(ref, block, x0, y0, width, height, chromaPartWidth + 1, chromaPartHeight + 1, chromaPartWidth + 1); ref += width * height; h264bsdFillBlock(ref, block + (chromaPartWidth+1)*(chromaPartHeight+1), x0, y0, width, height, chromaPartWidth + 1, chromaPartHeight + 1, chromaPartWidth + 1); ref = block; x0 = 0; y0 = 0; width = chromaPartWidth+1; height = chromaPartHeight+1; } valX = 8 - xFrac; valY = 8 - yFrac; for (comp = 0; comp <= 1; comp++) { ptrA = ref + (comp * height + (u32)y0) * width + x0; cbr = predPartChroma + comp * 8 * 8; /* 2x2 pels per iteration * bilinear vertical and horizontal interpolation */ for (y = (chromaPartHeight >> 1); y; y--) { tmp1 = *ptrA; tmp3 = ptrA[width]; tmp5 = ptrA[width*2]; tmp1 *= valY; tmp1 += tmp3 * yFrac; tmp3 *= valY; tmp3 += tmp5 * yFrac; for (x = (chromaPartWidth >> 1); x; x--) { tmp2 = *++ptrA; tmp4 = ptrA[width]; tmp6 = ptrA[width*2]; tmp2 *= valY; tmp2 += tmp4 * yFrac; tmp4 *= valY; tmp4 += tmp6 * yFrac; tmp1 = tmp1 * valX + plus32; tmp3 = tmp3 * valX + plus32; tmp1 += tmp2 * xFrac; tmp1 >>= 6; tmp3 += tmp4 * xFrac; tmp3 >>= 6; cbr[8] = (u8)tmp3; *cbr++ = (u8)tmp1; tmp1 = *++ptrA; tmp3 = ptrA[width]; tmp5 = ptrA[width*2]; tmp1 *= valY; tmp1 += tmp3 * yFrac; tmp3 *= valY; tmp3 += tmp5 * yFrac; tmp2 = tmp2 * valX + plus32; tmp4 = tmp4 * valX + plus32; tmp2 += tmp1 * xFrac; tmp2 >>= 6; tmp4 += tmp3 * xFrac; tmp4 >>= 6; cbr[8] = (u8)tmp4; *cbr++ = (u8)tmp2; } cbr += 2*8 - chromaPartWidth; ptrA += 2*width - chromaPartWidth; } } } /*------------------------------------------------------------------------------ Function: PredictChroma Functional description: Top level chroma prediction function that calls the appropriate interpolation function. The output is written to macroblock array. ------------------------------------------------------------------------------*/ static void PredictChroma( u8 *mbPartChroma, u32 xAL, u32 yAL, u32 partWidth, u32 partHeight, mv_t *mv, image_t *refPic) { /* Variables */ u32 xFrac, yFrac, width, height, chromaPartWidth, chromaPartHeight; i32 xInt, yInt; u8 *ref; /* Code */ ASSERT(mv); ASSERT(refPic); ASSERT(refPic->data); ASSERT(refPic->width); ASSERT(refPic->height); width = 8 * refPic->width; height = 8 * refPic->height; xInt = (xAL >> 1) + (mv->hor >> 3); yInt = (yAL >> 1) + (mv->ver >> 3); xFrac = mv->hor & 0x7; yFrac = mv->ver & 0x7; chromaPartWidth = partWidth >> 1; chromaPartHeight = partHeight >> 1; ref = refPic->data + 256 * refPic->width * refPic->height; if (xFrac && yFrac) { h264bsdInterpolateChromaHorVer(ref, mbPartChroma, xInt, yInt, width, height, xFrac, yFrac, chromaPartWidth, chromaPartHeight); } else if (xFrac) { h264bsdInterpolateChromaHor(ref, mbPartChroma, xInt, yInt, width, height, xFrac, chromaPartWidth, chromaPartHeight); } else if (yFrac) { h264bsdInterpolateChromaVer(ref, mbPartChroma, xInt, yInt, width, height, yFrac, chromaPartWidth, chromaPartHeight); } else { h264bsdFillBlock(ref, mbPartChroma, xInt, yInt, width, height, chromaPartWidth, chromaPartHeight, 8); ref += width * height; h264bsdFillBlock(ref, mbPartChroma + 8*8, xInt, yInt, width, height, chromaPartWidth, chromaPartHeight, 8); } } /*------------------------------------------------------------------------------ Function: h264bsdInterpolateVerHalf Functional description: Function to perform vertical interpolation of pixel position 'h' for a block. Overfilling is done only if needed. Reference image (ref) is read at correct position and the predicted part is written to macroblock array (mb) ------------------------------------------------------------------------------*/ #ifndef H264DEC_ARM11 void h264bsdInterpolateVerHalf( u8 *ref, u8 *mb, i32 x0, i32 y0, u32 width, u32 height, u32 partWidth, u32 partHeight) { u32 p1[21*21/4+1]; u32 i, j; i32 tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7; u8 *ptrC, *ptrV; const u8 *clp = h264bsdClip + 512; /* Code */ ASSERT(ref); ASSERT(mb); if ((x0 < 0) || ((u32)x0+partWidth > width) || (y0 < 0) || ((u32)y0+partHeight+5 > height)) { h264bsdFillBlock(ref, (u8*)p1, x0, y0, width, height, partWidth, partHeight+5, partWidth); x0 = 0; y0 = 0; ref = (u8*)p1; width = partWidth; } ref += (u32)y0 * width + (u32)x0; ptrC = ref + width; ptrV = ptrC + 5*width; /* 4 pixels per iteration, interpolate using 5 vertical samples */ for (i = (partHeight >> 2); i; i--) { /* h1 = (16 + A + 16(G+M) + 4(G+M) - 4(C+R) - (C+R) + T) >> 5 */ for (j = partWidth; j; j--) { tmp4 = ptrV[-(i32)width*2]; tmp5 = ptrV[-(i32)width]; tmp1 = ptrV[width]; tmp2 = ptrV[width*2]; tmp6 = *ptrV++; tmp7 = tmp4 + tmp1; tmp2 -= (tmp7 << 2); tmp2 -= tmp7; tmp2 += 16; tmp7 = tmp5 + tmp6; tmp3 = ptrC[width*2]; tmp2 += (tmp7 << 4); tmp2 += (tmp7 << 2); tmp2 += tmp3; tmp2 = clp[tmp2>>5]; tmp1 += 16; mb[48] = (u8)tmp2; tmp7 = tmp3 + tmp6; tmp1 -= (tmp7 << 2); tmp1 -= tmp7; tmp7 = tmp4 + tmp5; tmp2 = ptrC[width]; tmp1 += (tmp7 << 4); tmp1 += (tmp7 << 2); tmp1 += tmp2; tmp1 = clp[tmp1>>5]; tmp6 += 16; mb[32] = (u8)tmp1; tmp7 = tmp2 + tmp5; tmp6 -= (tmp7 << 2); tmp6 -= tmp7; tmp7 = tmp4 + tmp3; tmp1 = *ptrC; tmp6 += (tmp7 << 4); tmp6 += (tmp7 << 2); tmp6 += tmp1; tmp6 = clp[tmp6>>5]; tmp5 += 16; mb[16] = (u8)tmp6; tmp1 += tmp4; tmp5 -= (tmp1 << 2); tmp5 -= tmp1; tmp3 += tmp2; tmp6 = ptrC[-(i32)width]; tmp5 += (tmp3 << 4); tmp5 += (tmp3 << 2); tmp5 += tmp6; tmp5 = clp[tmp5>>5]; *mb++ = (u8)tmp5; ptrC++; } ptrC += 4*width - partWidth; ptrV += 4*width - partWidth; mb += 4*16 - partWidth; } } /*------------------------------------------------------------------------------ Function: h264bsdInterpolateVerQuarter Functional description: Function to perform vertical interpolation of pixel position 'd' or 'n' for a block. Overfilling is done only if needed. Reference image (ref) is read at correct position and the predicted part is written to macroblock array (mb) ------------------------------------------------------------------------------*/ void h264bsdInterpolateVerQuarter( u8 *ref, u8 *mb, i32 x0, i32 y0, u32 width, u32 height, u32 partWidth, u32 partHeight, u32 verOffset) /* 0 for pixel d, 1 for pixel n */ { u32 p1[21*21/4+1]; u32 i, j; i32 tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7; u8 *ptrC, *ptrV, *ptrInt; const u8 *clp = h264bsdClip + 512; /* Code */ ASSERT(ref); ASSERT(mb); if ((x0 < 0) || ((u32)x0+partWidth > width) || (y0 < 0) || ((u32)y0+partHeight+5 > height)) { h264bsdFillBlock(ref, (u8*)p1, x0, y0, width, height, partWidth, partHeight+5, partWidth); x0 = 0; y0 = 0; ref = (u8*)p1; width = partWidth; } ref += (u32)y0 * width + (u32)x0; ptrC = ref + width; ptrV = ptrC + 5*width; /* Pointer to integer sample position, either M or R */ ptrInt = ptrC + (2+verOffset)*width; /* 4 pixels per iteration * interpolate using 5 vertical samples and average between * interpolated value and integer sample value */ for (i = (partHeight >> 2); i; i--) { /* h1 = (16 + A + 16(G+M) + 4(G+M) - 4(C+R) - (C+R) + T) >> 5 */ for (j = partWidth; j; j--) { tmp4 = ptrV[-(i32)width*2]; tmp5 = ptrV[-(i32)width]; tmp1 = ptrV[width]; tmp2 = ptrV[width*2]; tmp6 = *ptrV++; tmp7 = tmp4 + tmp1; tmp2 -= (tmp7 << 2); tmp2 -= tmp7; tmp2 += 16; tmp7 = tmp5 + tmp6; tmp3 = ptrC[width*2]; tmp2 += (tmp7 << 4); tmp2 += (tmp7 << 2); tmp2 += tmp3; tmp2 = clp[tmp2>>5]; tmp7 = ptrInt[width*2]; tmp1 += 16; tmp2++; mb[48] = (u8)((tmp2 + tmp7) >> 1); tmp7 = tmp3 + tmp6; tmp1 -= (tmp7 << 2); tmp1 -= tmp7; tmp7 = tmp4 + tmp5; tmp2 = ptrC[width]; tmp1 += (tmp7 << 4); tmp1 += (tmp7 << 2); tmp1 += tmp2; tmp1 = clp[tmp1>>5]; tmp7 = ptrInt[width]; tmp6 += 16; tmp1++; mb[32] = (u8)((tmp1 + tmp7) >> 1); tmp7 = tmp2 + tmp5; tmp6 -= (tmp7 << 2); tmp6 -= tmp7; tmp7 = tmp4 + tmp3; tmp1 = *ptrC; tmp6 += (tmp7 << 4); tmp6 += (tmp7 << 2); tmp6 += tmp1; tmp6 = clp[tmp6>>5]; tmp7 = *ptrInt; tmp5 += 16; tmp6++; mb[16] = (u8)((tmp6 + tmp7) >> 1); tmp1 += tmp4; tmp5 -= (tmp1 << 2); tmp5 -= tmp1; tmp3 += tmp2; tmp6 = ptrC[-(i32)width]; tmp5 += (tmp3 << 4); tmp5 += (tmp3 << 2); tmp5 += tmp6; tmp5 = clp[tmp5>>5]; tmp7 = ptrInt[-(i32)width]; tmp5++; *mb++ = (u8)((tmp5 + tmp7) >> 1); ptrC++; ptrInt++; } ptrC += 4*width - partWidth; ptrV += 4*width - partWidth; ptrInt += 4*width - partWidth; mb += 4*16 - partWidth; } } /*------------------------------------------------------------------------------ Function: h264bsdInterpolateHorHalf Functional description: Function to perform horizontal interpolation of pixel position 'b' for a block. Overfilling is done only if needed. Reference image (ref) is read at correct position and the predicted part is written to macroblock array (mb) ------------------------------------------------------------------------------*/ void h264bsdInterpolateHorHalf( u8 *ref, u8 *mb, i32 x0, i32 y0, u32 width, u32 height, u32 partWidth, u32 partHeight) { u32 p1[21*21/4+1]; u8 *ptrJ; u32 x, y; i32 tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7; const u8 *clp = h264bsdClip + 512; /* Code */ ASSERT(ref); ASSERT(mb); ASSERT((partWidth&0x3) == 0); ASSERT((partHeight&0x3) == 0); if ((x0 < 0) || ((u32)x0+partWidth+5 > width) || (y0 < 0) || ((u32)y0+partHeight > height)) { h264bsdFillBlock(ref, (u8*)p1, x0, y0, width, height, partWidth+5, partHeight, partWidth+5); x0 = 0; y0 = 0; ref = (u8*)p1; width = partWidth + 5; } ref += (u32)y0 * width + (u32)x0; ptrJ = ref + 5; for (y = partHeight; y; y--) { tmp6 = *(ptrJ - 5); tmp5 = *(ptrJ - 4); tmp4 = *(ptrJ - 3); tmp3 = *(ptrJ - 2); tmp2 = *(ptrJ - 1); /* calculate 4 pels per iteration */ for (x = (partWidth >> 2); x; x--) { /* First pixel */ tmp6 += 16; tmp7 = tmp3 + tmp4; tmp6 += (tmp7 << 4); tmp6 += (tmp7 << 2); tmp7 = tmp2 + tmp5; tmp1 = *ptrJ++; tmp6 -= (tmp7 << 2); tmp6 -= tmp7; tmp6 += tmp1; tmp6 = clp[tmp6>>5]; /* Second pixel */ tmp5 += 16; tmp7 = tmp2 + tmp3; *mb++ = (u8)tmp6; tmp5 += (tmp7 << 4); tmp5 += (tmp7 << 2); tmp7 = tmp1 + tmp4; tmp6 = *ptrJ++; tmp5 -= (tmp7 << 2); tmp5 -= tmp7; tmp5 += tmp6; tmp5 = clp[tmp5>>5]; /* Third pixel */ tmp4 += 16; tmp7 = tmp1 + tmp2; *mb++ = (u8)tmp5; tmp4 += (tmp7 << 4); tmp4 += (tmp7 << 2); tmp7 = tmp6 + tmp3; tmp5 = *ptrJ++; tmp4 -= (tmp7 << 2); tmp4 -= tmp7; tmp4 += tmp5; tmp4 = clp[tmp4>>5]; /* Fourth pixel */ tmp3 += 16; tmp7 = tmp6 + tmp1; *mb++ = (u8)tmp4; tmp3 += (tmp7 << 4); tmp3 += (tmp7 << 2); tmp7 = tmp5 + tmp2; tmp4 = *ptrJ++; tmp3 -= (tmp7 << 2); tmp3 -= tmp7; tmp3 += tmp4; tmp3 = clp[tmp3>>5]; tmp7 = tmp4; tmp4 = tmp6; tmp6 = tmp2; tmp2 = tmp7; *mb++ = (u8)tmp3; tmp3 = tmp5; tmp5 = tmp1; } ptrJ += width - partWidth; mb += 16 - partWidth; } } /*------------------------------------------------------------------------------ Function: h264bsdInterpolateHorQuarter Functional description: Function to perform horizontal interpolation of pixel position 'a' or 'c' for a block. Overfilling is done only if needed. Reference image (ref) is read at correct position and the predicted part is written to macroblock array (mb) ------------------------------------------------------------------------------*/ void h264bsdInterpolateHorQuarter( u8 *ref, u8 *mb, i32 x0, i32 y0, u32 width, u32 height, u32 partWidth, u32 partHeight, u32 horOffset) /* 0 for pixel a, 1 for pixel c */ { u32 p1[21*21/4+1]; u8 *ptrJ; u32 x, y; i32 tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7; const u8 *clp = h264bsdClip + 512; /* Code */ ASSERT(ref); ASSERT(mb); if ((x0 < 0) || ((u32)x0+partWidth+5 > width) || (y0 < 0) || ((u32)y0+partHeight > height)) { h264bsdFillBlock(ref, (u8*)p1, x0, y0, width, height, partWidth+5, partHeight, partWidth+5); x0 = 0; y0 = 0; ref = (u8*)p1; width = partWidth + 5; } ref += (u32)y0 * width + (u32)x0; ptrJ = ref + 5; for (y = partHeight; y; y--) { tmp6 = *(ptrJ - 5); tmp5 = *(ptrJ - 4); tmp4 = *(ptrJ - 3); tmp3 = *(ptrJ - 2); tmp2 = *(ptrJ - 1); /* calculate 4 pels per iteration */ for (x = (partWidth >> 2); x; x--) { /* First pixel */ tmp6 += 16; tmp7 = tmp3 + tmp4; tmp6 += (tmp7 << 4); tmp6 += (tmp7 << 2); tmp7 = tmp2 + tmp5; tmp1 = *ptrJ++; tmp6 -= (tmp7 << 2); tmp6 -= tmp7; tmp6 += tmp1; tmp6 = clp[tmp6>>5]; tmp5 += 16; if (!horOffset) tmp6 += tmp4; else tmp6 += tmp3; *mb++ = (u8)((tmp6 + 1) >> 1); /* Second pixel */ tmp7 = tmp2 + tmp3; tmp5 += (tmp7 << 4); tmp5 += (tmp7 << 2); tmp7 = tmp1 + tmp4; tmp6 = *ptrJ++; tmp5 -= (tmp7 << 2); tmp5 -= tmp7; tmp5 += tmp6; tmp5 = clp[tmp5>>5]; tmp4 += 16; if (!horOffset) tmp5 += tmp3; else tmp5 += tmp2; *mb++ = (u8)((tmp5 + 1) >> 1); /* Third pixel */ tmp7 = tmp1 + tmp2; tmp4 += (tmp7 << 4); tmp4 += (tmp7 << 2); tmp7 = tmp6 + tmp3; tmp5 = *ptrJ++; tmp4 -= (tmp7 << 2); tmp4 -= tmp7; tmp4 += tmp5; tmp4 = clp[tmp4>>5]; tmp3 += 16; if (!horOffset) tmp4 += tmp2; else tmp4 += tmp1; *mb++ = (u8)((tmp4 + 1) >> 1); /* Fourth pixel */ tmp7 = tmp6 + tmp1; tmp3 += (tmp7 << 4); tmp3 += (tmp7 << 2); tmp7 = tmp5 + tmp2; tmp4 = *ptrJ++; tmp3 -= (tmp7 << 2); tmp3 -= tmp7; tmp3 += tmp4; tmp3 = clp[tmp3>>5]; if (!horOffset) tmp3 += tmp1; else tmp3 += tmp6; *mb++ = (u8)((tmp3 + 1) >> 1); tmp3 = tmp5; tmp5 = tmp1; tmp7 = tmp4; tmp4 = tmp6; tmp6 = tmp2; tmp2 = tmp7; } ptrJ += width - partWidth; mb += 16 - partWidth; } } /*------------------------------------------------------------------------------ Function: h264bsdInterpolateHorVerQuarter Functional description: Function to perform horizontal and vertical interpolation of pixel position 'e', 'g', 'p' or 'r' for a block. Overfilling is done only if needed. Reference image (ref) is read at correct position and the predicted part is written to macroblock array (mb) ------------------------------------------------------------------------------*/ void h264bsdInterpolateHorVerQuarter( u8 *ref, u8 *mb, i32 x0, i32 y0, u32 width, u32 height, u32 partWidth, u32 partHeight, u32 horVerOffset) /* 0 for pixel e, 1 for pixel g, 2 for pixel p, 3 for pixel r */ { u32 p1[21*21/4+1]; u8 *ptrC, *ptrJ, *ptrV; u32 x, y; i32 tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7; const u8 *clp = h264bsdClip + 512; /* Code */ ASSERT(ref); ASSERT(mb); if ((x0 < 0) || ((u32)x0+partWidth+5 > width) || (y0 < 0) || ((u32)y0+partHeight+5 > height)) { h264bsdFillBlock(ref, (u8*)p1, x0, y0, width, height, partWidth+5, partHeight+5, partWidth+5); x0 = 0; y0 = 0; ref = (u8*)p1; width = partWidth+5; } /* Ref points to G + (-2, -2) */ ref += (u32)y0 * width + (u32)x0; /* ptrJ points to either J or Q, depending on vertical offset */ ptrJ = ref + (((horVerOffset & 0x2) >> 1) + 2) * width + 5; /* ptrC points to either C or D, depending on horizontal offset */ ptrC = ref + width + 2 + (horVerOffset & 0x1); for (y = partHeight; y; y--) { tmp6 = *(ptrJ - 5); tmp5 = *(ptrJ - 4); tmp4 = *(ptrJ - 3); tmp3 = *(ptrJ - 2); tmp2 = *(ptrJ - 1); /* Horizontal interpolation, calculate 4 pels per iteration */ for (x = (partWidth >> 2); x; x--) { /* First pixel */ tmp6 += 16; tmp7 = tmp3 + tmp4; tmp6 += (tmp7 << 4); tmp6 += (tmp7 << 2); tmp7 = tmp2 + tmp5; tmp1 = *ptrJ++; tmp6 -= (tmp7 << 2); tmp6 -= tmp7; tmp6 += tmp1; tmp6 = clp[tmp6>>5]; /* Second pixel */ tmp5 += 16; tmp7 = tmp2 + tmp3; *mb++ = (u8)tmp6; tmp5 += (tmp7 << 4); tmp5 += (tmp7 << 2); tmp7 = tmp1 + tmp4; tmp6 = *ptrJ++; tmp5 -= (tmp7 << 2); tmp5 -= tmp7; tmp5 += tmp6; tmp5 = clp[tmp5>>5]; /* Third pixel */ tmp4 += 16; tmp7 = tmp1 + tmp2; *mb++ = (u8)tmp5; tmp4 += (tmp7 << 4); tmp4 += (tmp7 << 2); tmp7 = tmp6 + tmp3; tmp5 = *ptrJ++; tmp4 -= (tmp7 << 2); tmp4 -= tmp7; tmp4 += tmp5; tmp4 = clp[tmp4>>5]; /* Fourth pixel */ tmp3 += 16; tmp7 = tmp6 + tmp1; *mb++ = (u8)tmp4; tmp3 += (tmp7 << 4); tmp3 += (tmp7 << 2); tmp7 = tmp5 + tmp2; tmp4 = *ptrJ++; tmp3 -= (tmp7 << 2); tmp3 -= tmp7; tmp3 += tmp4; tmp3 = clp[tmp3>>5]; tmp7 = tmp4; tmp4 = tmp6; tmp6 = tmp2; tmp2 = tmp7; *mb++ = (u8)tmp3; tmp3 = tmp5; tmp5 = tmp1; } ptrJ += width - partWidth; mb += 16 - partWidth; } mb -= 16*partHeight; ptrV = ptrC + 5*width; for (y = (partHeight >> 2); y; y--) { /* Vertical interpolation and averaging, 4 pels per iteration */ for (x = partWidth; x; x--) { tmp4 = ptrV[-(i32)width*2]; tmp5 = ptrV[-(i32)width]; tmp1 = ptrV[width]; tmp2 = ptrV[width*2]; tmp6 = *ptrV++; tmp7 = tmp4 + tmp1; tmp2 -= (tmp7 << 2); tmp2 -= tmp7; tmp2 += 16; tmp7 = tmp5 + tmp6; tmp3 = ptrC[width*2]; tmp2 += (tmp7 << 4); tmp2 += (tmp7 << 2); tmp2 += tmp3; tmp7 = clp[tmp2>>5]; tmp2 = mb[48]; tmp1 += 16; tmp7++; mb[48] = (u8)((tmp2 + tmp7) >> 1); tmp7 = tmp3 + tmp6; tmp1 -= (tmp7 << 2); tmp1 -= tmp7; tmp7 = tmp4 + tmp5; tmp2 = ptrC[width]; tmp1 += (tmp7 << 4); tmp1 += (tmp7 << 2); tmp1 += tmp2; tmp7 = clp[tmp1>>5]; tmp1 = mb[32]; tmp6 += 16; tmp7++; mb[32] = (u8)((tmp1 + tmp7) >> 1); tmp1 = *ptrC; tmp7 = tmp2 + tmp5; tmp6 -= (tmp7 << 2); tmp6 -= tmp7; tmp7 = tmp4 + tmp3; tmp6 += (tmp7 << 4); tmp6 += (tmp7 << 2); tmp6 += tmp1; tmp7 = clp[tmp6>>5]; tmp6 = mb[16]; tmp5 += 16; tmp7++; mb[16] = (u8)((tmp6 + tmp7) >> 1); tmp6 = ptrC[-(i32)width]; tmp1 += tmp4; tmp5 -= (tmp1 << 2); tmp5 -= tmp1; tmp3 += tmp2; tmp5 += (tmp3 << 4); tmp5 += (tmp3 << 2); tmp5 += tmp6; tmp7 = clp[tmp5>>5]; tmp5 = *mb; tmp7++; *mb++ = (u8)((tmp5 + tmp7) >> 1); ptrC++; } ptrC += 4*width - partWidth; ptrV += 4*width - partWidth; mb += 4*16 - partWidth; } } #endif /*------------------------------------------------------------------------------ Function: h264bsdInterpolateMidHalf Functional description: Function to perform horizontal and vertical interpolation of pixel position 'j' for a block. Overfilling is done only if needed. Reference image (ref) is read at correct position and the predicted part is written to macroblock array (mb) ------------------------------------------------------------------------------*/ void h264bsdInterpolateMidHalf( u8 *ref, u8 *mb, i32 x0, i32 y0, u32 width, u32 height, u32 partWidth, u32 partHeight) { u32 p1[21*21/4+1]; u32 x, y; i32 tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7; i32 *ptrC, *ptrV, *b1; u8 *ptrJ; i32 table[21*16]; const u8 *clp = h264bsdClip + 512; /* Code */ ASSERT(ref); ASSERT(mb); if ((x0 < 0) || ((u32)x0+partWidth+5 > width) || (y0 < 0) || ((u32)y0+partHeight+5 > height)) { h264bsdFillBlock(ref, (u8*)p1, x0, y0, width, height, partWidth+5, partHeight+5, partWidth+5); x0 = 0; y0 = 0; ref = (u8*)p1; width = partWidth+5; } ref += (u32)y0 * width + (u32)x0; b1 = table; ptrJ = ref + 5; /* First step: calculate intermediate values for * horizontal interpolation */ for (y = partHeight + 5; y; y--) { tmp6 = *(ptrJ - 5); tmp5 = *(ptrJ - 4); tmp4 = *(ptrJ - 3); tmp3 = *(ptrJ - 2); tmp2 = *(ptrJ - 1); /* 4 pels per iteration */ for (x = (partWidth >> 2); x; x--) { /* First pixel */ tmp7 = tmp3 + tmp4; tmp6 += (tmp7 << 4); tmp6 += (tmp7 << 2); tmp7 = tmp2 + tmp5; tmp1 = *ptrJ++; tmp6 -= (tmp7 << 2); tmp6 -= tmp7; tmp6 += tmp1; *b1++ = tmp6; /* Second pixel */ tmp7 = tmp2 + tmp3; tmp5 += (tmp7 << 4); tmp5 += (tmp7 << 2); tmp7 = tmp1 + tmp4; tmp6 = *ptrJ++; tmp5 -= (tmp7 << 2); tmp5 -= tmp7; tmp5 += tmp6; *b1++ = tmp5; /* Third pixel */ tmp7 = tmp1 + tmp2; tmp4 += (tmp7 << 4); tmp4 += (tmp7 << 2); tmp7 = tmp6 + tmp3; tmp5 = *ptrJ++; tmp4 -= (tmp7 << 2); tmp4 -= tmp7; tmp4 += tmp5; *b1++ = tmp4; /* Fourth pixel */ tmp7 = tmp6 + tmp1; tmp3 += (tmp7 << 4); tmp3 += (tmp7 << 2); tmp7 = tmp5 + tmp2; tmp4 = *ptrJ++; tmp3 -= (tmp7 << 2); tmp3 -= tmp7; tmp3 += tmp4; *b1++ = tmp3; tmp7 = tmp4; tmp4 = tmp6; tmp6 = tmp2; tmp2 = tmp7; tmp3 = tmp5; tmp5 = tmp1; } ptrJ += width - partWidth; } /* Second step: calculate vertical interpolation */ ptrC = table + partWidth; ptrV = ptrC + 5*partWidth; for (y = (partHeight >> 2); y; y--) { /* 4 pels per iteration */ for (x = partWidth; x; x--) { tmp4 = ptrV[-(i32)partWidth*2]; tmp5 = ptrV[-(i32)partWidth]; tmp1 = ptrV[partWidth]; tmp2 = ptrV[partWidth*2]; tmp6 = *ptrV++; tmp7 = tmp4 + tmp1; tmp2 -= (tmp7 << 2); tmp2 -= tmp7; tmp2 += 512; tmp7 = tmp5 + tmp6; tmp3 = ptrC[partWidth*2]; tmp2 += (tmp7 << 4); tmp2 += (tmp7 << 2); tmp2 += tmp3; tmp7 = clp[tmp2>>10]; tmp1 += 512; mb[48] = (u8)tmp7; tmp7 = tmp3 + tmp6; tmp1 -= (tmp7 << 2); tmp1 -= tmp7; tmp7 = tmp4 + tmp5; tmp2 = ptrC[partWidth]; tmp1 += (tmp7 << 4); tmp1 += (tmp7 << 2); tmp1 += tmp2; tmp7 = clp[tmp1>>10]; tmp6 += 512; mb[32] = (u8)tmp7; tmp1 = *ptrC; tmp7 = tmp2 + tmp5; tmp6 -= (tmp7 << 2); tmp6 -= tmp7; tmp7 = tmp4 + tmp3; tmp6 += (tmp7 << 4); tmp6 += (tmp7 << 2); tmp6 += tmp1; tmp7 = clp[tmp6>>10]; tmp5 += 512; mb[16] = (u8)tmp7; tmp6 = ptrC[-(i32)partWidth]; tmp1 += tmp4; tmp5 -= (tmp1 << 2); tmp5 -= tmp1; tmp3 += tmp2; tmp5 += (tmp3 << 4); tmp5 += (tmp3 << 2); tmp5 += tmp6; tmp7 = clp[tmp5>>10]; *mb++ = (u8)tmp7; ptrC++; } mb += 4*16 - partWidth; ptrC += 3*partWidth; ptrV += 3*partWidth; } } /*------------------------------------------------------------------------------ Function: h264bsdInterpolateMidVerQuarter Functional description: Function to perform horizontal and vertical interpolation of pixel position 'f' or 'q' for a block. Overfilling is done only if needed. Reference image (ref) is read at correct position and the predicted part is written to macroblock array (mb) ------------------------------------------------------------------------------*/ void h264bsdInterpolateMidVerQuarter( u8 *ref, u8 *mb, i32 x0, i32 y0, u32 width, u32 height, u32 partWidth, u32 partHeight, u32 verOffset) /* 0 for pixel f, 1 for pixel q */ { u32 p1[21*21/4+1]; u32 x, y; i32 tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7; i32 *ptrC, *ptrV, *ptrInt, *b1; u8 *ptrJ; i32 table[21*16]; const u8 *clp = h264bsdClip + 512; /* Code */ ASSERT(ref); ASSERT(mb); if ((x0 < 0) || ((u32)x0+partWidth+5 > width) || (y0 < 0) || ((u32)y0+partHeight+5 > height)) { h264bsdFillBlock(ref, (u8*)p1, x0, y0, width, height, partWidth+5, partHeight+5, partWidth+5); x0 = 0; y0 = 0; ref = (u8*)p1; width = partWidth+5; } ref += (u32)y0 * width + (u32)x0; b1 = table; ptrJ = ref + 5; /* First step: calculate intermediate values for * horizontal interpolation */ for (y = partHeight + 5; y; y--) { tmp6 = *(ptrJ - 5); tmp5 = *(ptrJ - 4); tmp4 = *(ptrJ - 3); tmp3 = *(ptrJ - 2); tmp2 = *(ptrJ - 1); for (x = (partWidth >> 2); x; x--) { /* First pixel */ tmp7 = tmp3 + tmp4; tmp6 += (tmp7 << 4); tmp6 += (tmp7 << 2); tmp7 = tmp2 + tmp5; tmp1 = *ptrJ++; tmp6 -= (tmp7 << 2); tmp6 -= tmp7; tmp6 += tmp1; *b1++ = tmp6; /* Second pixel */ tmp7 = tmp2 + tmp3; tmp5 += (tmp7 << 4); tmp5 += (tmp7 << 2); tmp7 = tmp1 + tmp4; tmp6 = *ptrJ++; tmp5 -= (tmp7 << 2); tmp5 -= tmp7; tmp5 += tmp6; *b1++ = tmp5; /* Third pixel */ tmp7 = tmp1 + tmp2; tmp4 += (tmp7 << 4); tmp4 += (tmp7 << 2); tmp7 = tmp6 + tmp3; tmp5 = *ptrJ++; tmp4 -= (tmp7 << 2); tmp4 -= tmp7; tmp4 += tmp5; *b1++ = tmp4; /* Fourth pixel */ tmp7 = tmp6 + tmp1; tmp3 += (tmp7 << 4); tmp3 += (tmp7 << 2); tmp7 = tmp5 + tmp2; tmp4 = *ptrJ++; tmp3 -= (tmp7 << 2); tmp3 -= tmp7; tmp3 += tmp4; *b1++ = tmp3; tmp7 = tmp4; tmp4 = tmp6; tmp6 = tmp2; tmp2 = tmp7; tmp3 = tmp5; tmp5 = tmp1; } ptrJ += width - partWidth; } /* Second step: calculate vertical interpolation and average */ ptrC = table + partWidth; ptrV = ptrC + 5*partWidth; /* Pointer to integer sample position, either M or R */ ptrInt = ptrC + (2+verOffset)*partWidth; for (y = (partHeight >> 2); y; y--) { for (x = partWidth; x; x--) { tmp4 = ptrV[-(i32)partWidth*2]; tmp5 = ptrV[-(i32)partWidth]; tmp1 = ptrV[partWidth]; tmp2 = ptrV[partWidth*2]; tmp6 = *ptrV++; tmp7 = tmp4 + tmp1; tmp2 -= (tmp7 << 2); tmp2 -= tmp7; tmp2 += 512; tmp7 = tmp5 + tmp6; tmp3 = ptrC[partWidth*2]; tmp2 += (tmp7 << 4); tmp2 += (tmp7 << 2); tmp7 = ptrInt[partWidth*2]; tmp2 += tmp3; tmp2 = clp[tmp2>>10]; tmp7 += 16; tmp7 = clp[tmp7>>5]; tmp1 += 512; tmp2++; mb[48] = (u8)((tmp7 + tmp2) >> 1); tmp7 = tmp3 + tmp6; tmp1 -= (tmp7 << 2); tmp1 -= tmp7; tmp7 = tmp4 + tmp5; tmp2 = ptrC[partWidth]; tmp1 += (tmp7 << 4); tmp1 += (tmp7 << 2); tmp7 = ptrInt[partWidth]; tmp1 += tmp2; tmp1 = clp[tmp1>>10]; tmp7 += 16; tmp7 = clp[tmp7>>5]; tmp6 += 512; tmp1++; mb[32] = (u8)((tmp7 + tmp1) >> 1); tmp1 = *ptrC; tmp7 = tmp2 + tmp5; tmp6 -= (tmp7 << 2); tmp6 -= tmp7; tmp7 = tmp4 + tmp3; tmp6 += (tmp7 << 4); tmp6 += (tmp7 << 2); tmp7 = *ptrInt; tmp6 += tmp1; tmp6 = clp[tmp6>>10]; tmp7 += 16; tmp7 = clp[tmp7>>5]; tmp5 += 512; tmp6++; mb[16] = (u8)((tmp7 + tmp6) >> 1); tmp6 = ptrC[-(i32)partWidth]; tmp1 += tmp4; tmp5 -= (tmp1 << 2); tmp5 -= tmp1; tmp3 += tmp2; tmp5 += (tmp3 << 4); tmp5 += (tmp3 << 2); tmp7 = ptrInt[-(i32)partWidth]; tmp5 += tmp6; tmp5 = clp[tmp5>>10]; tmp7 += 16; tmp7 = clp[tmp7>>5]; tmp5++; *mb++ = (u8)((tmp7 + tmp5) >> 1); ptrC++; ptrInt++; } mb += 4*16 - partWidth; ptrC += 3*partWidth; ptrV += 3*partWidth; ptrInt += 3*partWidth; } } /*------------------------------------------------------------------------------ Function: h264bsdInterpolateMidHorQuarter Functional description: Function to perform horizontal and vertical interpolation of pixel position 'i' or 'k' for a block. Overfilling is done only if needed. Reference image (ref) is read at correct position and the predicted part is written to macroblock array (mb) ------------------------------------------------------------------------------*/ void h264bsdInterpolateMidHorQuarter( u8 *ref, u8 *mb, i32 x0, i32 y0, u32 width, u32 height, u32 partWidth, u32 partHeight, u32 horOffset) /* 0 for pixel i, 1 for pixel k */ { u32 p1[21*21/4+1]; u32 x, y; i32 tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7; i32 *ptrJ, *ptrInt, *h1; u8 *ptrC, *ptrV; i32 table[21*16]; i32 tableWidth = (i32)partWidth+5; const u8 *clp = h264bsdClip + 512; /* Code */ ASSERT(ref); ASSERT(mb); if ((x0 < 0) || ((u32)x0+partWidth+5 > width) || (y0 < 0) || ((u32)y0+partHeight+5 > height)) { h264bsdFillBlock(ref, (u8*)p1, x0, y0, width, height, partWidth+5, partHeight+5, partWidth+5); x0 = 0; y0 = 0; ref = (u8*)p1; width = partWidth+5; } ref += (u32)y0 * width + (u32)x0; h1 = table + tableWidth; ptrC = ref + width; ptrV = ptrC + 5*width; /* First step: calculate intermediate values for * vertical interpolation */ for (y = (partHeight >> 2); y; y--) { for (x = (u32)tableWidth; x; x--) { tmp4 = ptrV[-(i32)width*2]; tmp5 = ptrV[-(i32)width]; tmp1 = ptrV[width]; tmp2 = ptrV[width*2]; tmp6 = *ptrV++; tmp7 = tmp4 + tmp1; tmp2 -= (tmp7 << 2); tmp2 -= tmp7; tmp7 = tmp5 + tmp6; tmp3 = ptrC[width*2]; tmp2 += (tmp7 << 4); tmp2 += (tmp7 << 2); tmp2 += tmp3; h1[tableWidth*2] = tmp2; tmp7 = tmp3 + tmp6; tmp1 -= (tmp7 << 2); tmp1 -= tmp7; tmp7 = tmp4 + tmp5; tmp2 = ptrC[width]; tmp1 += (tmp7 << 4); tmp1 += (tmp7 << 2); tmp1 += tmp2; h1[tableWidth] = tmp1; tmp1 = *ptrC; tmp7 = tmp2 + tmp5; tmp6 -= (tmp7 << 2); tmp6 -= tmp7; tmp7 = tmp4 + tmp3; tmp6 += (tmp7 << 4); tmp6 += (tmp7 << 2); tmp6 += tmp1; *h1 = tmp6; tmp6 = ptrC[-(i32)width]; tmp1 += tmp4; tmp5 -= (tmp1 << 2); tmp5 -= tmp1; tmp3 += tmp2; tmp5 += (tmp3 << 4); tmp5 += (tmp3 << 2); tmp5 += tmp6; h1[-tableWidth] = tmp5; h1++; ptrC++; } ptrC += 4*width - partWidth - 5; ptrV += 4*width - partWidth - 5; h1 += 3*tableWidth; } /* Second step: calculate horizontal interpolation and average */ ptrJ = table + 5; /* Pointer to integer sample position, either G or H */ ptrInt = table + 2 + horOffset; for (y = partHeight; y; y--) { tmp6 = *(ptrJ - 5); tmp5 = *(ptrJ - 4); tmp4 = *(ptrJ - 3); tmp3 = *(ptrJ - 2); tmp2 = *(ptrJ - 1); for (x = (partWidth>>2); x; x--) { /* First pixel */ tmp6 += 512; tmp7 = tmp3 + tmp4; tmp6 += (tmp7 << 4); tmp6 += (tmp7 << 2); tmp7 = tmp2 + tmp5; tmp1 = *ptrJ++; tmp6 -= (tmp7 << 2); tmp6 -= tmp7; tmp7 = *ptrInt++; tmp6 += tmp1; tmp6 = clp[tmp6 >> 10]; tmp7 += 16; tmp7 = clp[tmp7 >> 5]; tmp5 += 512; tmp6++; *mb++ = (u8)((tmp6 + tmp7) >> 1); /* Second pixel */ tmp7 = tmp2 + tmp3; tmp5 += (tmp7 << 4); tmp5 += (tmp7 << 2); tmp7 = tmp1 + tmp4; tmp6 = *ptrJ++; tmp5 -= (tmp7 << 2); tmp5 -= tmp7; tmp7 = *ptrInt++; tmp5 += tmp6; tmp5 = clp[tmp5 >> 10]; tmp7 += 16; tmp7 = clp[tmp7 >> 5]; tmp4 += 512; tmp5++; *mb++ = (u8)((tmp5 + tmp7) >> 1); /* Third pixel */ tmp7 = tmp1 + tmp2; tmp4 += (tmp7 << 4); tmp4 += (tmp7 << 2); tmp7 = tmp6 + tmp3; tmp5 = *ptrJ++; tmp4 -= (tmp7 << 2); tmp4 -= tmp7; tmp7 = *ptrInt++; tmp4 += tmp5; tmp4 = clp[tmp4 >> 10]; tmp7 += 16; tmp7 = clp[tmp7 >> 5]; tmp3 += 512; tmp4++; *mb++ = (u8)((tmp4 + tmp7) >> 1); /* Fourth pixel */ tmp7 = tmp6 + tmp1; tmp3 += (tmp7 << 4); tmp3 += (tmp7 << 2); tmp7 = tmp5 + tmp2; tmp4 = *ptrJ++; tmp3 -= (tmp7 << 2); tmp3 -= tmp7; tmp7 = *ptrInt++; tmp3 += tmp4; tmp3 = clp[tmp3 >> 10]; tmp7 += 16; tmp7 = clp[tmp7 >> 5]; tmp3++; *mb++ = (u8)((tmp3 + tmp7) >> 1); tmp3 = tmp5; tmp5 = tmp1; tmp7 = tmp4; tmp4 = tmp6; tmp6 = tmp2; tmp2 = tmp7; } ptrJ += 5; ptrInt += 5; mb += 16 - partWidth; } } /*------------------------------------------------------------------------------ Function: h264bsdPredictSamples Functional description: This function reconstructs a prediction for a macroblock partition. The prediction is either copied or interpolated using the reference frame and the motion vector. Both luminance and chrominance parts are predicted. The prediction is stored in given macroblock array (data). Inputs: data pointer to macroblock array (384 bytes) for output mv pointer to motion vector used for prediction refPic pointer to reference picture structure xA x-coordinate for current macroblock yA y-coordinate for current macroblock partX x-offset for partition in macroblock partY y-offset for partition in macroblock partWidth width of partition partHeight height of partition Outputs: data macroblock array (16x16+8x8+8x8) where predicted partition is stored at correct position ------------------------------------------------------------------------------*/ void h264bsdPredictSamples( u8 *data, mv_t *mv, image_t *refPic, u32 xA, u32 yA, u32 partX, u32 partY, u32 partWidth, u32 partHeight) { /* Variables */ u32 xFrac, yFrac, width, height; i32 xInt, yInt; u8 *lumaPartData; /* Code */ ASSERT(data); ASSERT(mv); ASSERT(partWidth); ASSERT(partHeight); ASSERT(refPic); ASSERT(refPic->data); ASSERT(refPic->width); ASSERT(refPic->height); /* luma */ lumaPartData = data + 16*partY + partX; xFrac = mv->hor & 0x3; yFrac = mv->ver & 0x3; width = 16 * refPic->width; height = 16 * refPic->height; xInt = (i32)xA + (i32)partX + (mv->hor >> 2); yInt = (i32)yA + (i32)partY + (mv->ver >> 2); ASSERT(lumaFracPos[xFrac][yFrac] < 16); switch (lumaFracPos[xFrac][yFrac]) { case 0: /* G */ h264bsdFillBlock(refPic->data, lumaPartData, xInt,yInt,width,height,partWidth,partHeight,16); break; case 1: /* d */ h264bsdInterpolateVerQuarter(refPic->data, lumaPartData, xInt, yInt-2, width, height, partWidth, partHeight, 0); break; case 2: /* h */ h264bsdInterpolateVerHalf(refPic->data, lumaPartData, xInt, yInt-2, width, height, partWidth, partHeight); break; case 3: /* n */ h264bsdInterpolateVerQuarter(refPic->data, lumaPartData, xInt, yInt-2, width, height, partWidth, partHeight, 1); break; case 4: /* a */ h264bsdInterpolateHorQuarter(refPic->data, lumaPartData, xInt-2, yInt, width, height, partWidth, partHeight, 0); break; case 5: /* e */ h264bsdInterpolateHorVerQuarter(refPic->data, lumaPartData, xInt-2, yInt-2, width, height, partWidth, partHeight, 0); break; case 6: /* i */ h264bsdInterpolateMidHorQuarter(refPic->data, lumaPartData, xInt-2, yInt-2, width, height, partWidth, partHeight, 0); break; case 7: /* p */ h264bsdInterpolateHorVerQuarter(refPic->data, lumaPartData, xInt-2, yInt-2, width, height, partWidth, partHeight, 2); break; case 8: /* b */ h264bsdInterpolateHorHalf(refPic->data, lumaPartData, xInt-2, yInt, width, height, partWidth, partHeight); break; case 9: /* f */ h264bsdInterpolateMidVerQuarter(refPic->data, lumaPartData, xInt-2, yInt-2, width, height, partWidth, partHeight, 0); break; case 10: /* j */ h264bsdInterpolateMidHalf(refPic->data, lumaPartData, xInt-2, yInt-2, width, height, partWidth, partHeight); break; case 11: /* q */ h264bsdInterpolateMidVerQuarter(refPic->data, lumaPartData, xInt-2, yInt-2, width, height, partWidth, partHeight, 1); break; case 12: /* c */ h264bsdInterpolateHorQuarter(refPic->data, lumaPartData, xInt-2, yInt, width, height, partWidth, partHeight, 1); break; case 13: /* g */ h264bsdInterpolateHorVerQuarter(refPic->data, lumaPartData, xInt-2, yInt-2, width, height, partWidth, partHeight, 1); break; case 14: /* k */ h264bsdInterpolateMidHorQuarter(refPic->data, lumaPartData, xInt-2, yInt-2, width, height, partWidth, partHeight, 1); break; default: /* case 15, r */ h264bsdInterpolateHorVerQuarter(refPic->data, lumaPartData, xInt-2, yInt-2, width, height, partWidth, partHeight, 3); break; } /* chroma */ PredictChroma( data + 16*16 + (partY>>1)*8 + (partX>>1), xA + partX, yA + partY, partWidth, partHeight, mv, refPic); } #else /* H264DEC_OMXDL */ /*------------------------------------------------------------------------------ Function: h264bsdPredictSamples Functional description: This function reconstructs a prediction for a macroblock partition. The prediction is either copied or interpolated using the reference frame and the motion vector. Both luminance and chrominance parts are predicted. The prediction is stored in given macroblock array (data). Inputs: data pointer to macroblock array (384 bytes) for output mv pointer to motion vector used for prediction refPic pointer to reference picture structure xA x-coordinate for current macroblock yA y-coordinate for current macroblock partX x-offset for partition in macroblock partY y-offset for partition in macroblock partWidth width of partition partHeight height of partition Outputs: data macroblock array (16x16+8x8+8x8) where predicted partition is stored at correct position ------------------------------------------------------------------------------*/ /*lint -e{550} Symbol 'res' not accessed */ void h264bsdPredictSamples( u8 *data, mv_t *mv, image_t *refPic, u32 colAndRow, u32 part, u8 *pFill) { /* Variables */ u32 xFrac, yFrac; u32 width, height; i32 xInt, yInt, x0, y0; u8 *partData, *ref; OMXSize roi; u32 fillWidth; u32 fillHeight; OMXResult res; u32 xA, yA; u32 partX, partY; u32 partWidth, partHeight; /* Code */ ASSERT(data); ASSERT(mv); ASSERT(refPic); ASSERT(refPic->data); ASSERT(refPic->width); ASSERT(refPic->height); xA = (colAndRow & 0xFFFF0000) >> 16; yA = (colAndRow & 0x0000FFFF); partX = (part & 0xFF000000) >> 24; partY = (part & 0x00FF0000) >> 16; partWidth = (part & 0x0000FF00) >> 8; partHeight = (part & 0x000000FF); ASSERT(partWidth); ASSERT(partHeight); /* luma */ partData = data + 16*partY + partX; xFrac = mv->hor & 0x3; yFrac = mv->ver & 0x3; width = 16 * refPic->width; height = 16 * refPic->height; xInt = (i32)xA + (i32)partX + (mv->hor >> 2); yInt = (i32)yA + (i32)partY + (mv->ver >> 2); x0 = (xFrac) ? xInt-2 : xInt; y0 = (yFrac) ? yInt-2 : yInt; if (xFrac) { if (partWidth == 16) fillWidth = 32; else fillWidth = 16; } else fillWidth = (partWidth*2); if (yFrac) fillHeight = partHeight+5; else fillHeight = partHeight; if ((x0 < 0) || ((u32)x0+fillWidth > width) || (y0 < 0) || ((u32)y0+fillHeight > height)) { h264bsdFillBlock(refPic->data, (u8*)pFill, x0, y0, width, height, fillWidth, fillHeight, fillWidth); x0 = 0; y0 = 0; ref = pFill; width = fillWidth; if (yFrac) ref += 2*width; if (xFrac) ref += 2; } else { /*lint --e(737) Loss of sign */ ref = refPic->data + yInt*width + xInt; } /* Luma interpolation */ roi.width = (i32)partWidth; roi.height = (i32)partHeight; res = omxVCM4P10_InterpolateLuma(ref, (i32)width, partData, 16, (i32)xFrac, (i32)yFrac, roi); ASSERT(res == 0); /* Chroma */ width = 8 * refPic->width; height = 8 * refPic->height; x0 = ((xA + partX) >> 1) + (mv->hor >> 3); y0 = ((yA + partY) >> 1) + (mv->ver >> 3); xFrac = mv->hor & 0x7; yFrac = mv->ver & 0x7; ref = refPic->data + 256 * refPic->width * refPic->height; roi.width = (i32)(partWidth >> 1); fillWidth = ((partWidth >> 1) + 8) & ~0x7; roi.height = (i32)(partHeight >> 1); fillHeight = (partHeight >> 1) + 1; if ((x0 < 0) || ((u32)x0+fillWidth > width) || (y0 < 0) || ((u32)y0+fillHeight > height)) { h264bsdFillBlock(ref, pFill, x0, y0, width, height, fillWidth, fillHeight, fillWidth); ref += width * height; h264bsdFillBlock(ref, pFill + fillWidth*fillHeight, x0, y0, width, height, fillWidth, fillHeight, fillWidth); ref = pFill; x0 = 0; y0 = 0; width = fillWidth; height = fillHeight; } partData = data + 16*16 + (partY>>1)*8 + (partX>>1); /* Chroma interpolation */ /*lint --e(737) Loss of sign */ ref += y0 * width + x0; res = armVCM4P10_Interpolate_Chroma(ref, width, partData, 8, (u32)roi.width, (u32)roi.height, xFrac, yFrac); ASSERT(res == 0); partData += 8 * 8; ref += height * width; res = armVCM4P10_Interpolate_Chroma(ref, width, partData, 8, (u32)roi.width, (u32)roi.height, xFrac, yFrac); ASSERT(res == 0); } #endif /* H264DEC_OMXDL */ /*------------------------------------------------------------------------------ Function: FillRow1 Functional description: This function gets a row of reference pels in a 'normal' case when no overfilling is necessary. ------------------------------------------------------------------------------*/ static void FillRow1( u8 *ref, u8 *fill, i32 left, i32 center, i32 right) { UNUSED(left); UNUSED(right); ASSERT(ref); ASSERT(fill); H264SwDecMemcpy(fill, ref, (u32)center); /*lint -e(715) */ } /*------------------------------------------------------------------------------ Function: h264bsdFillRow7 Functional description: This function gets a row of reference pels when horizontal coordinate is partly negative or partly greater than reference picture width (overfilling some pels on left and/or right edge). Inputs: ref pointer to reference samples left amount of pixels to overfill on left-edge center amount of pixels to copy right amount of pixels to overfill on right-edge Outputs: fill pointer where samples are stored ------------------------------------------------------------------------------*/ #ifndef H264DEC_NEON void h264bsdFillRow7( u8 *ref, u8 *fill, i32 left, i32 center, i32 right) { u8 tmp; ASSERT(ref); ASSERT(fill); if (left) tmp = *ref; for ( ; left; left--) /*lint -esym(644,tmp) tmp is initialized if used */ *fill++ = tmp; for ( ; center; center--) *fill++ = *ref++; if (right) tmp = ref[-1]; for ( ; right; right--) /*lint -esym(644,tmp) tmp is initialized if used */ *fill++ = tmp; } #endif /*------------------------------------------------------------------------------ Function: h264bsdFillBlock Functional description: This function gets a block of reference pels. It determines whether overfilling is needed or not and repeatedly calls an appropriate function (by using a function pointer) that fills one row the block. Inputs: ref pointer to reference frame x0 x-coordinate for block y0 y-coordinate for block width width of reference frame height height of reference frame blockWidth width of block blockHeight height of block fillScanLength length of a line in output array (pixels) Outputs: fill pointer to array where output block is written ------------------------------------------------------------------------------*/ void h264bsdFillBlock( u8 *ref, u8 *fill, i32 x0, i32 y0, u32 width, u32 height, u32 blockWidth, u32 blockHeight, u32 fillScanLength) { /* Variables */ i32 xstop, ystop; void (*fp)(u8*, u8*, i32, i32, i32); i32 left, x, right; i32 top, y, bottom; /* Code */ ASSERT(ref); ASSERT(fill); ASSERT(width); ASSERT(height); ASSERT(fill); ASSERT(blockWidth); ASSERT(blockHeight); xstop = x0 + (i32)blockWidth; ystop = y0 + (i32)blockHeight; /* Choose correct function whether overfilling on left-edge or right-edge * is needed or not */ if (x0 >= 0 && xstop <= (i32)width) fp = FillRow1; else fp = h264bsdFillRow7; if (ystop < 0) y0 = -(i32)blockHeight; if (xstop < 0) x0 = -(i32)blockWidth; if (y0 > (i32)height) y0 = (i32)height; if (x0 > (i32)width) x0 = (i32)width; xstop = x0 + (i32)blockWidth; ystop = y0 + (i32)blockHeight; if (x0 > 0) ref += x0; if (y0 > 0) ref += y0 * (i32)width; left = x0 < 0 ? -x0 : 0; right = xstop > (i32)width ? xstop - (i32)width : 0; x = (i32)blockWidth - left - right; top = y0 < 0 ? -y0 : 0; bottom = ystop > (i32)height ? ystop - (i32)height : 0; y = (i32)blockHeight - top - bottom; /* Top-overfilling */ for ( ; top; top-- ) { (*fp)(ref, fill, left, x, right); fill += fillScanLength; } /* Lines inside reference image */ for ( ; y; y-- ) { (*fp)(ref, fill, left, x, right); ref += width; fill += fillScanLength; } ref -= width; /* Bottom-overfilling */ for ( ; bottom; bottom-- ) { (*fp)(ref, fill, left, x, right); fill += fillScanLength; } } /*lint +e701 +e702 */