| /* |
| * 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 |
| h264bsdCountLeadingZeros |
| h264bsdRbspTrailingBits |
| h264bsdMoreRbspData |
| h264bsdNextMbAddress |
| h264bsdSetCurrImageMbPointers |
| |
| ------------------------------------------------------------------------------*/ |
| |
| /*------------------------------------------------------------------------------ |
| 1. Include headers |
| ------------------------------------------------------------------------------*/ |
| |
| #include "h264bsd_util.h" |
| |
| /*------------------------------------------------------------------------------ |
| 2. External compiler flags |
| -------------------------------------------------------------------------------- |
| |
| -------------------------------------------------------------------------------- |
| 3. Module defines |
| ------------------------------------------------------------------------------*/ |
| |
| /* look-up table for expected values of stuffing bits */ |
| static const u32 stuffingTable[8] = {0x1,0x2,0x4,0x8,0x10,0x20,0x40,0x80}; |
| |
| /* look-up table for chroma quantization parameter as a function of luma QP */ |
| const u32 h264bsdQpC[52] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19, |
| 20,21,22,23,24,25,26,27,28,29,29,30,31,32,32,33,34,34,35,35,36,36,37,37,37, |
| 38,38,38,39,39,39,39}; |
| |
| /*------------------------------------------------------------------------------ |
| 4. Local function prototypes |
| ------------------------------------------------------------------------------*/ |
| |
| /*------------------------------------------------------------------------------ |
| |
| 5.1 Function: h264bsdCountLeadingZeros |
| |
| Functional description: |
| Count leading zeros in a code word. Code word is assumed to be |
| right-aligned, last bit of the code word in the lsb of the value. |
| |
| Inputs: |
| value code word |
| length number of bits in the code word |
| |
| Outputs: |
| none |
| |
| Returns: |
| number of leading zeros in the code word |
| |
| ------------------------------------------------------------------------------*/ |
| #ifndef H264DEC_NEON |
| u32 h264bsdCountLeadingZeros(u32 value, u32 length) |
| { |
| |
| /* Variables */ |
| |
| u32 zeros = 0; |
| u32 mask = 1 << (length - 1); |
| |
| /* Code */ |
| |
| ASSERT(length <= 32); |
| |
| while (mask && !(value & mask)) |
| { |
| zeros++; |
| mask >>= 1; |
| } |
| return(zeros); |
| |
| } |
| #endif |
| /*------------------------------------------------------------------------------ |
| |
| 5.2 Function: h264bsdRbspTrailingBits |
| |
| Functional description: |
| Check Raw Byte Stream Payload (RBSP) trailing bits, i.e. stuffing. |
| Rest of the current byte (whole byte if allready byte aligned) |
| in the stream buffer shall contain a '1' bit followed by zero or |
| more '0' bits. |
| |
| Inputs: |
| pStrmData pointer to stream data structure |
| |
| Outputs: |
| none |
| |
| Returns: |
| HANTRO_OK RBSP trailing bits found |
| HANTRO_NOK otherwise |
| |
| ------------------------------------------------------------------------------*/ |
| |
| u32 h264bsdRbspTrailingBits(strmData_t *pStrmData) |
| { |
| |
| /* Variables */ |
| |
| u32 stuffing; |
| u32 stuffingLength; |
| |
| /* Code */ |
| |
| ASSERT(pStrmData); |
| ASSERT(pStrmData->bitPosInWord < 8); |
| |
| stuffingLength = 8 - pStrmData->bitPosInWord; |
| |
| stuffing = h264bsdGetBits(pStrmData, stuffingLength); |
| if (stuffing == END_OF_STREAM) |
| return(HANTRO_NOK); |
| |
| if (stuffing != stuffingTable[stuffingLength - 1]) |
| return(HANTRO_NOK); |
| else |
| return(HANTRO_OK); |
| |
| } |
| |
| /*------------------------------------------------------------------------------ |
| |
| 5.3 Function: h264bsdMoreRbspData |
| |
| Functional description: |
| Check if there is more data in the current RBSP. The standard |
| defines this function so that there is more data if |
| -more than 8 bits left or |
| -last bits are not RBSP trailing bits |
| |
| Inputs: |
| pStrmData pointer to stream data structure |
| |
| Outputs: |
| none |
| |
| Returns: |
| HANTRO_TRUE there is more data |
| HANTRO_FALSE no more data |
| |
| ------------------------------------------------------------------------------*/ |
| |
| u32 h264bsdMoreRbspData(strmData_t *pStrmData) |
| { |
| |
| /* Variables */ |
| |
| u32 bits; |
| |
| /* Code */ |
| |
| ASSERT(pStrmData); |
| ASSERT(pStrmData->strmBuffReadBits <= 8 * pStrmData->strmBuffSize); |
| |
| bits = pStrmData->strmBuffSize * 8 - pStrmData->strmBuffReadBits; |
| |
| if (bits == 0) |
| return(HANTRO_FALSE); |
| |
| if ( (bits > 8) || |
| ((h264bsdShowBits32(pStrmData)>>(32-bits)) != (1ul << (bits-1))) ) |
| return(HANTRO_TRUE); |
| else |
| return(HANTRO_FALSE); |
| |
| } |
| |
| /*------------------------------------------------------------------------------ |
| |
| 5.4 Function: h264bsdNextMbAddress |
| |
| Functional description: |
| Get address of the next macroblock in the current slice group. |
| |
| Inputs: |
| pSliceGroupMap slice group for each macroblock |
| picSizeInMbs size of the picture |
| currMbAddr where to start |
| |
| Outputs: |
| none |
| |
| Returns: |
| address of the next macroblock |
| 0 if none of the following macroblocks belong to same slice |
| group as currMbAddr |
| |
| ------------------------------------------------------------------------------*/ |
| |
| u32 h264bsdNextMbAddress(u32 *pSliceGroupMap, u32 picSizeInMbs, u32 currMbAddr) |
| { |
| |
| /* Variables */ |
| |
| u32 i, sliceGroup; |
| |
| /* Code */ |
| |
| ASSERT(pSliceGroupMap); |
| ASSERT(picSizeInMbs); |
| ASSERT(currMbAddr < picSizeInMbs); |
| |
| sliceGroup = pSliceGroupMap[currMbAddr]; |
| |
| i = currMbAddr + 1; |
| while ((i < picSizeInMbs) && (pSliceGroupMap[i] != sliceGroup)) |
| { |
| i++; |
| } |
| |
| if (i == picSizeInMbs) |
| i = 0; |
| |
| return(i); |
| |
| } |
| |
| |
| /*------------------------------------------------------------------------------ |
| |
| 5.5 Function: h264bsdSetCurrImageMbPointers |
| |
| Functional description: |
| Set luma and chroma pointers in image_t for current MB |
| |
| Inputs: |
| image Current image |
| mbNum number of current MB |
| |
| Outputs: |
| none |
| |
| Returns: |
| none |
| ------------------------------------------------------------------------------*/ |
| void h264bsdSetCurrImageMbPointers(image_t *image, u32 mbNum) |
| { |
| u32 width, height; |
| u32 picSize; |
| u32 row, col; |
| u32 tmp; |
| |
| width = image->width; |
| height = image->height; |
| row = mbNum / width; |
| col = mbNum % width; |
| |
| tmp = row * width; |
| picSize = width * height; |
| |
| image->luma = (u8*)(image->data + col * 16 + tmp * 256); |
| image->cb = (u8*)(image->data + picSize * 256 + tmp * 64 + col * 8); |
| image->cr = (u8*)(image->cb + picSize * 64); |
| } |
| |
| |