/* * 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 h264bsdDecodeExpGolombUnsigned h264bsdDecodeExpGolombSigned h264bsdDecodeExpGolombMapped h264bsdDecodeExpGolombTruncated ------------------------------------------------------------------------------*/ /*------------------------------------------------------------------------------ 1. Include headers ------------------------------------------------------------------------------*/ #include "h264bsd_vlc.h" #include "basetype.h" #include "h264bsd_stream.h" #include "h264bsd_util.h" /*------------------------------------------------------------------------------ 2. External compiler flags -------------------------------------------------------------------------------- -------------------------------------------------------------------------------- 3. Module defines ------------------------------------------------------------------------------*/ /* definition of special code num, this along with the return value is used * to handle code num in the range [0, 2^32] in the DecodeExpGolombUnsigned * function */ #define BIG_CODE_NUM 0xFFFFFFFFU /* Mapping tables for coded_block_pattern, used for decoding of mapped * Exp-Golomb codes */ static const u8 codedBlockPatternIntra4x4[48] = { 47,31,15,0,23,27,29,30,7,11,13,14,39,43,45,46,16,3,5,10,12,19,21,26,28,35, 37,42,44,1,2,4,8,17,18,20,24,6,9,22,25,32,33,34,36,40,38,41}; static const u8 codedBlockPatternInter[48] = { 0,16,1,2,4,8,32,3,5,10,12,15,47,7,11,13,14,6,9,31,35,37,42,44,33,34,36,40, 39,43,45,46,17,18,20,24,19,21,26,28,23,27,29,30,22,25,38,41}; /*------------------------------------------------------------------------------ 4. Local function prototypes ------------------------------------------------------------------------------*/ /*------------------------------------------------------------------------------ 5.1 Function: h264bsdDecodeExpGolombUnsigned Functional description: Decode unsigned Exp-Golomb code. This is the same as codeNum used in other Exp-Golomb code mappings. Code num (i.e. the decoded symbol) is determined as codeNum = 2^leadingZeros - 1 + GetBits(leadingZeros) Normal decoded symbols are in the range [0, 2^32 - 2]. Symbol 2^32-1 is indicated by BIG_CODE_NUM with return value HANTRO_OK while symbol 2^32 is indicated by BIG_CODE_NUM with return value HANTRO_NOK. These two symbols are special cases with code length of 65, i.e. 32 '0' bits, a '1' bit, and either 0 or 1 represented by 32 bits. Symbol 2^32 is out of unsigned 32-bit range but is needed for DecodeExpGolombSigned to express value -2^31. Inputs: pStrmData pointer to stream data structure Outputs: codeNum decoded code word is stored here Returns: HANTRO_OK success HANTRO_NOK failure, no valid code word found, note exception with BIG_CODE_NUM ------------------------------------------------------------------------------*/ u32 h264bsdDecodeExpGolombUnsigned(strmData_t *pStrmData, u32 *codeNum) { /* Variables */ u32 bits, numZeros; /* Code */ ASSERT(pStrmData); ASSERT(codeNum); bits = h264bsdShowBits32(pStrmData); /* first bit is 1 -> code length 1 */ if (bits >= 0x80000000) { h264bsdFlushBits(pStrmData, 1); *codeNum = 0; return(HANTRO_OK); } /* second bit is 1 -> code length 3 */ else if (bits >= 0x40000000) { if (h264bsdFlushBits(pStrmData, 3) == END_OF_STREAM) return(HANTRO_NOK); *codeNum = 1 + ((bits >> 29) & 0x1); return(HANTRO_OK); } /* third bit is 1 -> code length 5 */ else if (bits >= 0x20000000) { if (h264bsdFlushBits(pStrmData, 5) == END_OF_STREAM) return(HANTRO_NOK); *codeNum = 3 + ((bits >> 27) & 0x3); return(HANTRO_OK); } /* fourth bit is 1 -> code length 7 */ else if (bits >= 0x10000000) { if (h264bsdFlushBits(pStrmData, 7) == END_OF_STREAM) return(HANTRO_NOK); *codeNum = 7 + ((bits >> 25) & 0x7); return(HANTRO_OK); } /* other code lengths */ else { #ifndef H264DEC_NEON numZeros = 4 + h264bsdCountLeadingZeros(bits, 28); #else numZeros = h264bsdCountLeadingZeros(bits); #endif /* all 32 bits are zero */ if (numZeros == 32) { *codeNum = 0; h264bsdFlushBits(pStrmData,32); bits = h264bsdGetBits(pStrmData, 1); /* check 33rd bit, must be 1 */ if (bits == 1) { /* cannot use h264bsdGetBits, limited to 31 bits */ bits = h264bsdShowBits32(pStrmData); if (h264bsdFlushBits(pStrmData, 32) == END_OF_STREAM) return(HANTRO_NOK); /* code num 2^32 - 1, needed for unsigned mapping */ if (bits == 0) { *codeNum = BIG_CODE_NUM; return(HANTRO_OK); } /* code num 2^32, needed for unsigned mapping * (results in -2^31) */ else if (bits == 1) { *codeNum = BIG_CODE_NUM; return(HANTRO_NOK); } } /* if more zeros than 32, it is an error */ return(HANTRO_NOK); } else h264bsdFlushBits(pStrmData,numZeros+1); bits = h264bsdGetBits(pStrmData, numZeros); if (bits == END_OF_STREAM) return(HANTRO_NOK); *codeNum = (1 << numZeros) - 1 + bits; } return(HANTRO_OK); } /*------------------------------------------------------------------------------ 5.2 Function: h264bsdDecodeExpGolombSigned Functional description: Decode signed Exp-Golomb code. Code num is determined by h264bsdDecodeExpGolombUnsigned and then mapped to signed representation as symbol = (-1)^(codeNum+1) * (codeNum+1)/2 Signed symbols shall be in the range [-2^31, 2^31 - 1]. Symbol -2^31 is obtained when codeNum is 2^32, which cannot be expressed by unsigned 32-bit value. This is signaled as a special case from the h264bsdDecodeExpGolombUnsigned by setting codeNum to BIG_CODE_NUM and returning HANTRO_NOK status. Inputs: pStrmData pointer to stream data structure Outputs: value decoded code word is stored here Returns: HANTRO_OK success HANTRO_NOK failure, no valid code word found ------------------------------------------------------------------------------*/ u32 h264bsdDecodeExpGolombSigned(strmData_t *pStrmData, i32 *value) { /* Variables */ u32 status, codeNum = 0; /* Code */ ASSERT(pStrmData); ASSERT(value); status = h264bsdDecodeExpGolombUnsigned(pStrmData, &codeNum); if (codeNum == BIG_CODE_NUM) { /* BIG_CODE_NUM and HANTRO_OK status means codeNum 2^32-1 which would * result in signed integer valued 2^31 (i.e. out of 32-bit signed * integer range) */ if (status == HANTRO_OK) return(HANTRO_NOK); /* BIG_CODE_NUM and HANTRO_NOK status means codeNum 2^32 which results * in signed integer valued -2^31 */ else { *value = (i32)(2147483648U); return (HANTRO_OK); } } else if (status == HANTRO_OK) { /* (-1)^(codeNum+1) results in positive sign if codeNum is odd, * negative when it is even. (codeNum+1)/2 is obtained as * (codeNum+1)>>1 when value is positive and as (-codeNum)>>1 for * negative value */ /*lint -e702 */ *value = (codeNum & 0x1) ? (i32)((codeNum + 1) >> 1) : -(i32)((codeNum + 1) >> 1); /*lint +e702 */ return(HANTRO_OK); } return(HANTRO_NOK); } /*------------------------------------------------------------------------------ 5.3 Function: h264bsdDecodeExpGolombMapped Functional description: Decode mapped Exp-Golomb code. Code num is determined by h264bsdDecodeExpGolombUnsigned and then mapped to codedBlockPattern either for intra or inter macroblock. The mapping is implemented by look-up tables defined in the beginning of the file. Inputs: pStrmData pointer to stream data structure isIntra flag to indicate if intra or inter mapping is to be used Outputs: value decoded code word is stored here Returns: HANTRO_OK success HANTRO_NOK failure, no valid code word found ------------------------------------------------------------------------------*/ u32 h264bsdDecodeExpGolombMapped(strmData_t *pStrmData, u32 *value, u32 isIntra) { /* Variables */ u32 status, codeNum; /* Code */ ASSERT(pStrmData); ASSERT(value); status = h264bsdDecodeExpGolombUnsigned(pStrmData, &codeNum); if (status != HANTRO_OK) return (HANTRO_NOK); else { /* range of valid codeNums [0,47] */ if (codeNum > 47) return (HANTRO_NOK); if (isIntra) *value = codedBlockPatternIntra4x4[codeNum]; else *value = codedBlockPatternInter[codeNum]; return(HANTRO_OK); } } /*------------------------------------------------------------------------------ 5.4 Function: h264bsdDecodeExpGolombTruncated Functional description: Decode truncated Exp-Golomb code. greaterThanOne flag indicates the range of the symbol to be decoded as follows: FALSE -> [0,1] TRUE -> [0,2^32-1] If flag is false the decoding is performed by reading one bit from the stream with h264bsdGetBits and mapping this to decoded symbol as symbol = bit ? 0 : 1 Otherwise, i.e. when flag is TRUE, code num is determined by h264bsdDecodeExpGolombUnsigned and this is used as the decoded symbol. Inputs: pStrmData pointer to stream data structure greaterThanOne flag to indicate if range is wider than [0,1] Outputs: value decoded code word is stored here Returns: HANTRO_OK success HANTRO_NOK failure, no valid code word found ------------------------------------------------------------------------------*/ u32 h264bsdDecodeExpGolombTruncated( strmData_t *pStrmData, u32 *value, u32 greaterThanOne) { /* Variables */ /* Code */ ASSERT(pStrmData); ASSERT(value); if (greaterThanOne) { return(h264bsdDecodeExpGolombUnsigned(pStrmData, value)); } else { *value = h264bsdGetBits(pStrmData,1); if (*value == END_OF_STREAM) return (HANTRO_NOK); *value ^= 0x1; } return (HANTRO_OK); }