| /* |
| * 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 |
| h264bsdWriteMacroblock |
| h264bsdWriteOutputBlocks |
| |
| ------------------------------------------------------------------------------*/ |
| |
| /*------------------------------------------------------------------------------ |
| 1. Include headers |
| ------------------------------------------------------------------------------*/ |
| |
| #include "h264bsd_image.h" |
| #include "h264bsd_util.h" |
| #include "h264bsd_neighbour.h" |
| |
| /*------------------------------------------------------------------------------ |
| 2. External compiler flags |
| -------------------------------------------------------------------------------- |
| |
| -------------------------------------------------------------------------------- |
| 3. Module defines |
| ------------------------------------------------------------------------------*/ |
| |
| /* x- and y-coordinates for each block, defined in h264bsd_intra_prediction.c */ |
| extern const u32 h264bsdBlockX[]; |
| extern const u32 h264bsdBlockY[]; |
| |
| /* clipping table, defined in h264bsd_intra_prediction.c */ |
| extern const u8 h264bsdClip[]; |
| |
| /*------------------------------------------------------------------------------ |
| 4. Local function prototypes |
| ------------------------------------------------------------------------------*/ |
| |
| |
| |
| /*------------------------------------------------------------------------------ |
| |
| Function: h264bsdWriteMacroblock |
| |
| Functional description: |
| Write one macroblock into the image. Both luma and chroma |
| components will be written at the same time. |
| |
| Inputs: |
| data pointer to macroblock data to be written, 256 values for |
| luma followed by 64 values for both chroma components |
| |
| Outputs: |
| image pointer to the image where the macroblock will be written |
| |
| Returns: |
| none |
| |
| ------------------------------------------------------------------------------*/ |
| #ifndef H264DEC_NEON |
| void h264bsdWriteMacroblock(image_t *image, u8 *data) |
| { |
| |
| /* Variables */ |
| |
| u32 i; |
| u32 width; |
| u32 *lum, *cb, *cr; |
| u32 *ptr; |
| u32 tmp1, tmp2; |
| |
| /* Code */ |
| |
| ASSERT(image); |
| ASSERT(data); |
| ASSERT(!((u32)data&0x3)); |
| |
| width = image->width; |
| |
| /*lint -save -e826 lum, cb and cr used to copy 4 bytes at the time, disable |
| * "area too small" info message */ |
| lum = (u32*)image->luma; |
| cb = (u32*)image->cb; |
| cr = (u32*)image->cr; |
| ASSERT(!((u32)lum&0x3)); |
| ASSERT(!((u32)cb&0x3)); |
| ASSERT(!((u32)cr&0x3)); |
| |
| ptr = (u32*)data; |
| |
| width *= 4; |
| for (i = 16; i ; i--) |
| { |
| tmp1 = *ptr++; |
| tmp2 = *ptr++; |
| *lum++ = tmp1; |
| *lum++ = tmp2; |
| tmp1 = *ptr++; |
| tmp2 = *ptr++; |
| *lum++ = tmp1; |
| *lum++ = tmp2; |
| lum += width-4; |
| } |
| |
| width >>= 1; |
| for (i = 8; i ; i--) |
| { |
| tmp1 = *ptr++; |
| tmp2 = *ptr++; |
| *cb++ = tmp1; |
| *cb++ = tmp2; |
| cb += width-2; |
| } |
| |
| for (i = 8; i ; i--) |
| { |
| tmp1 = *ptr++; |
| tmp2 = *ptr++; |
| *cr++ = tmp1; |
| *cr++ = tmp2; |
| cr += width-2; |
| } |
| |
| } |
| #endif |
| #ifndef H264DEC_OMXDL |
| /*------------------------------------------------------------------------------ |
| |
| Function: h264bsdWriteOutputBlocks |
| |
| Functional description: |
| Write one macroblock into the image. Prediction for the macroblock |
| and the residual are given separately and will be combined while |
| writing the data to the image |
| |
| Inputs: |
| data pointer to macroblock prediction data, 256 values for |
| luma followed by 64 values for both chroma components |
| mbNum number of the macroblock |
| residual pointer to residual data, 16 16-element arrays for luma |
| followed by 4 16-element arrays for both chroma |
| components |
| |
| Outputs: |
| image pointer to the image where the data will be written |
| |
| Returns: |
| none |
| |
| ------------------------------------------------------------------------------*/ |
| |
| void h264bsdWriteOutputBlocks(image_t *image, u32 mbNum, u8 *data, |
| i32 residual[][16]) |
| { |
| |
| /* Variables */ |
| |
| u32 i; |
| u32 picWidth, picSize; |
| u8 *lum, *cb, *cr; |
| u8 *imageBlock; |
| u8 *tmp; |
| u32 row, col; |
| u32 block; |
| u32 x, y; |
| i32 *pRes; |
| i32 tmp1, tmp2, tmp3, tmp4; |
| const u8 *clp = h264bsdClip + 512; |
| |
| /* Code */ |
| |
| ASSERT(image); |
| ASSERT(data); |
| ASSERT(mbNum < image->width * image->height); |
| ASSERT(!((u32)data&0x3)); |
| |
| /* Image size in macroblocks */ |
| picWidth = image->width; |
| picSize = picWidth * image->height; |
| row = mbNum / picWidth; |
| col = mbNum % picWidth; |
| |
| /* Output macroblock position in output picture */ |
| lum = (image->data + row * picWidth * 256 + col * 16); |
| cb = (image->data + picSize * 256 + row * picWidth * 64 + col * 8); |
| cr = (cb + picSize * 64); |
| |
| picWidth *= 16; |
| |
| for (block = 0; block < 16; block++) |
| { |
| x = h264bsdBlockX[block]; |
| y = h264bsdBlockY[block]; |
| |
| pRes = residual[block]; |
| |
| ASSERT(pRes); |
| |
| tmp = data + y*16 + x; |
| imageBlock = lum + y*picWidth + x; |
| |
| ASSERT(!((u32)tmp&0x3)); |
| ASSERT(!((u32)imageBlock&0x3)); |
| |
| if (IS_RESIDUAL_EMPTY(pRes)) |
| { |
| /*lint -e826 */ |
| i32 *in32 = (i32*)tmp; |
| i32 *out32 = (i32*)imageBlock; |
| |
| /* Residual is zero => copy prediction block to output */ |
| tmp1 = *in32; in32 += 4; |
| tmp2 = *in32; in32 += 4; |
| *out32 = tmp1; out32 += picWidth/4; |
| *out32 = tmp2; out32 += picWidth/4; |
| tmp1 = *in32; in32 += 4; |
| tmp2 = *in32; |
| *out32 = tmp1; out32 += picWidth/4; |
| *out32 = tmp2; |
| } |
| else |
| { |
| |
| RANGE_CHECK_ARRAY(pRes, -512, 511, 16); |
| |
| /* Calculate image = prediction + residual |
| * Process four pixels in a loop */ |
| for (i = 4; i; i--) |
| { |
| tmp1 = tmp[0]; |
| tmp2 = *pRes++; |
| tmp3 = tmp[1]; |
| tmp1 = clp[tmp1 + tmp2]; |
| tmp4 = *pRes++; |
| imageBlock[0] = (u8)tmp1; |
| tmp3 = clp[tmp3 + tmp4]; |
| tmp1 = tmp[2]; |
| tmp2 = *pRes++; |
| imageBlock[1] = (u8)tmp3; |
| tmp1 = clp[tmp1 + tmp2]; |
| tmp3 = tmp[3]; |
| tmp4 = *pRes++; |
| imageBlock[2] = (u8)tmp1; |
| tmp3 = clp[tmp3 + tmp4]; |
| tmp += 16; |
| imageBlock[3] = (u8)tmp3; |
| imageBlock += picWidth; |
| } |
| } |
| |
| } |
| |
| picWidth /= 2; |
| |
| for (block = 16; block <= 23; block++) |
| { |
| x = h264bsdBlockX[block & 0x3]; |
| y = h264bsdBlockY[block & 0x3]; |
| |
| pRes = residual[block]; |
| |
| ASSERT(pRes); |
| |
| tmp = data + 256; |
| imageBlock = cb; |
| |
| if (block >= 20) |
| { |
| imageBlock = cr; |
| tmp += 64; |
| } |
| |
| tmp += y*8 + x; |
| imageBlock += y*picWidth + x; |
| |
| ASSERT(!((u32)tmp&0x3)); |
| ASSERT(!((u32)imageBlock&0x3)); |
| |
| if (IS_RESIDUAL_EMPTY(pRes)) |
| { |
| /*lint -e826 */ |
| i32 *in32 = (i32*)tmp; |
| i32 *out32 = (i32*)imageBlock; |
| |
| /* Residual is zero => copy prediction block to output */ |
| tmp1 = *in32; in32 += 2; |
| tmp2 = *in32; in32 += 2; |
| *out32 = tmp1; out32 += picWidth/4; |
| *out32 = tmp2; out32 += picWidth/4; |
| tmp1 = *in32; in32 += 2; |
| tmp2 = *in32; |
| *out32 = tmp1; out32 += picWidth/4; |
| *out32 = tmp2; |
| } |
| else |
| { |
| |
| RANGE_CHECK_ARRAY(pRes, -512, 511, 16); |
| |
| for (i = 4; i; i--) |
| { |
| tmp1 = tmp[0]; |
| tmp2 = *pRes++; |
| tmp3 = tmp[1]; |
| tmp1 = clp[tmp1 + tmp2]; |
| tmp4 = *pRes++; |
| imageBlock[0] = (u8)tmp1; |
| tmp3 = clp[tmp3 + tmp4]; |
| tmp1 = tmp[2]; |
| tmp2 = *pRes++; |
| imageBlock[1] = (u8)tmp3; |
| tmp1 = clp[tmp1 + tmp2]; |
| tmp3 = tmp[3]; |
| tmp4 = *pRes++; |
| imageBlock[2] = (u8)tmp1; |
| tmp3 = clp[tmp3 + tmp4]; |
| tmp += 8; |
| imageBlock[3] = (u8)tmp3; |
| imageBlock += picWidth; |
| } |
| } |
| } |
| |
| } |
| #endif /* H264DEC_OMXDL */ |
| |
