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 h264bsdDecodeExpGolombUnsigned 27 h264bsdDecodeExpGolombSigned 28 h264bsdDecodeExpGolombMapped 29 h264bsdDecodeExpGolombTruncated 30 31 ------------------------------------------------------------------------------*/ 32 33 /*------------------------------------------------------------------------------ 34 1. Include headers 35 ------------------------------------------------------------------------------*/ 36 37 #include "h264bsd_vlc.h" 38 #include "basetype.h" 39 #include "h264bsd_stream.h" 40 #include "h264bsd_util.h" 41 42 /*------------------------------------------------------------------------------ 43 2. External compiler flags 44 -------------------------------------------------------------------------------- 45 46 -------------------------------------------------------------------------------- 47 3. Module defines 48 ------------------------------------------------------------------------------*/ 49 50 /* definition of special code num, this along with the return value is used 51 * to handle code num in the range [0, 2^32] in the DecodeExpGolombUnsigned 52 * function */ 53 #define BIG_CODE_NUM 0xFFFFFFFFU 54 55 /* Mapping tables for coded_block_pattern, used for decoding of mapped 56 * Exp-Golomb codes */ 57 static const u8 codedBlockPatternIntra4x4[48] = { 58 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, 59 37,42,44,1,2,4,8,17,18,20,24,6,9,22,25,32,33,34,36,40,38,41}; 60 61 static const u8 codedBlockPatternInter[48] = { 62 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, 63 39,43,45,46,17,18,20,24,19,21,26,28,23,27,29,30,22,25,38,41}; 64 65 /*------------------------------------------------------------------------------ 66 4. Local function prototypes 67 ------------------------------------------------------------------------------*/ 68 69 /*------------------------------------------------------------------------------ 70 71 5.1 Function: h264bsdDecodeExpGolombUnsigned 72 73 Functional description: 74 Decode unsigned Exp-Golomb code. This is the same as codeNum used 75 in other Exp-Golomb code mappings. Code num (i.e. the decoded 76 symbol) is determined as 77 78 codeNum = 2^leadingZeros - 1 + GetBits(leadingZeros) 79 80 Normal decoded symbols are in the range [0, 2^32 - 2]. Symbol 81 2^32-1 is indicated by BIG_CODE_NUM with return value HANTRO_OK 82 while symbol 2^32 is indicated by BIG_CODE_NUM with return value 83 HANTRO_NOK. These two symbols are special cases with code length 84 of 65, i.e. 32 '0' bits, a '1' bit, and either 0 or 1 represented 85 by 32 bits. 86 87 Symbol 2^32 is out of unsigned 32-bit range but is needed for 88 DecodeExpGolombSigned to express value -2^31. 89 90 Inputs: 91 pStrmData pointer to stream data structure 92 93 Outputs: 94 codeNum decoded code word is stored here 95 96 Returns: 97 HANTRO_OK success 98 HANTRO_NOK failure, no valid code word found, note exception 99 with BIG_CODE_NUM 100 101 ------------------------------------------------------------------------------*/ 102 103 u32 h264bsdDecodeExpGolombUnsigned(strmData_t *pStrmData, u32 *codeNum) 104 { 105 106 /* Variables */ 107 108 u32 bits, numZeros; 109 110 /* Code */ 111 112 ASSERT(pStrmData); 113 ASSERT(codeNum); 114 115 bits = h264bsdShowBits32(pStrmData); 116 117 /* first bit is 1 -> code length 1 */ 118 if (bits >= 0x80000000) 119 { 120 h264bsdFlushBits(pStrmData, 1); 121 *codeNum = 0; 122 return(HANTRO_OK); 123 } 124 /* second bit is 1 -> code length 3 */ 125 else if (bits >= 0x40000000) 126 { 127 if (h264bsdFlushBits(pStrmData, 3) == END_OF_STREAM) 128 return(HANTRO_NOK); 129 *codeNum = 1 + ((bits >> 29) & 0x1); 130 return(HANTRO_OK); 131 } 132 /* third bit is 1 -> code length 5 */ 133 else if (bits >= 0x20000000) 134 { 135 if (h264bsdFlushBits(pStrmData, 5) == END_OF_STREAM) 136 return(HANTRO_NOK); 137 *codeNum = 3 + ((bits >> 27) & 0x3); 138 return(HANTRO_OK); 139 } 140 /* fourth bit is 1 -> code length 7 */ 141 else if (bits >= 0x10000000) 142 { 143 if (h264bsdFlushBits(pStrmData, 7) == END_OF_STREAM) 144 return(HANTRO_NOK); 145 *codeNum = 7 + ((bits >> 25) & 0x7); 146 return(HANTRO_OK); 147 } 148 /* other code lengths */ 149 else 150 { 151 #ifndef H264DEC_NEON 152 numZeros = 4 + h264bsdCountLeadingZeros(bits, 28); 153 #else 154 numZeros = h264bsdCountLeadingZeros(bits); 155 #endif 156 /* all 32 bits are zero */ 157 if (numZeros == 32) 158 { 159 *codeNum = 0; 160 h264bsdFlushBits(pStrmData,32); 161 bits = h264bsdGetBits(pStrmData, 1); 162 /* check 33rd bit, must be 1 */ 163 if (bits == 1) 164 { 165 /* cannot use h264bsdGetBits, limited to 31 bits */ 166 bits = h264bsdShowBits32(pStrmData); 167 if (h264bsdFlushBits(pStrmData, 32) == END_OF_STREAM) 168 return(HANTRO_NOK); 169 /* code num 2^32 - 1, needed for unsigned mapping */ 170 if (bits == 0) 171 { 172 *codeNum = BIG_CODE_NUM; 173 return(HANTRO_OK); 174 } 175 /* code num 2^32, needed for unsigned mapping 176 * (results in -2^31) */ 177 else if (bits == 1) 178 { 179 *codeNum = BIG_CODE_NUM; 180 return(HANTRO_NOK); 181 } 182 } 183 /* if more zeros than 32, it is an error */ 184 return(HANTRO_NOK); 185 } 186 else 187 h264bsdFlushBits(pStrmData,numZeros+1); 188 189 bits = h264bsdGetBits(pStrmData, numZeros); 190 if (bits == END_OF_STREAM) 191 return(HANTRO_NOK); 192 193 *codeNum = (1 << numZeros) - 1 + bits; 194 195 } 196 197 return(HANTRO_OK); 198 199 } 200 201 /*------------------------------------------------------------------------------ 202 203 5.2 Function: h264bsdDecodeExpGolombSigned 204 205 Functional description: 206 Decode signed Exp-Golomb code. Code num is determined by 207 h264bsdDecodeExpGolombUnsigned and then mapped to signed 208 representation as 209 210 symbol = (-1)^(codeNum+1) * (codeNum+1)/2 211 212 Signed symbols shall be in the range [-2^31, 2^31 - 1]. Symbol 213 -2^31 is obtained when codeNum is 2^32, which cannot be expressed 214 by unsigned 32-bit value. This is signaled as a special case from 215 the h264bsdDecodeExpGolombUnsigned by setting codeNum to 216 BIG_CODE_NUM and returning HANTRO_NOK status. 217 218 Inputs: 219 pStrmData pointer to stream data structure 220 221 Outputs: 222 value decoded code word is stored here 223 224 Returns: 225 HANTRO_OK success 226 HANTRO_NOK failure, no valid code word found 227 228 ------------------------------------------------------------------------------*/ 229 230 u32 h264bsdDecodeExpGolombSigned(strmData_t *pStrmData, i32 *value) 231 { 232 233 /* Variables */ 234 235 u32 status, codeNum = 0; 236 237 /* Code */ 238 239 ASSERT(pStrmData); 240 ASSERT(value); 241 242 status = h264bsdDecodeExpGolombUnsigned(pStrmData, &codeNum); 243 244 if (codeNum == BIG_CODE_NUM) 245 { 246 /* BIG_CODE_NUM and HANTRO_OK status means codeNum 2^32-1 which would 247 * result in signed integer valued 2^31 (i.e. out of 32-bit signed 248 * integer range) */ 249 if (status == HANTRO_OK) 250 return(HANTRO_NOK); 251 /* BIG_CODE_NUM and HANTRO_NOK status means codeNum 2^32 which results 252 * in signed integer valued -2^31 */ 253 else 254 { 255 *value = (i32)(2147483648U); 256 return (HANTRO_OK); 257 } 258 } 259 else if (status == HANTRO_OK) 260 { 261 /* (-1)^(codeNum+1) results in positive sign if codeNum is odd, 262 * negative when it is even. (codeNum+1)/2 is obtained as 263 * (codeNum+1)>>1 when value is positive and as (-codeNum)>>1 for 264 * negative value */ 265 /*lint -e702 */ 266 *value = (codeNum & 0x1) ? (i32)((codeNum + 1) >> 1) : 267 -(i32)((codeNum + 1) >> 1); 268 /*lint +e702 */ 269 return(HANTRO_OK); 270 } 271 272 return(HANTRO_NOK); 273 274 } 275 276 /*------------------------------------------------------------------------------ 277 278 5.3 Function: h264bsdDecodeExpGolombMapped 279 280 Functional description: 281 Decode mapped Exp-Golomb code. Code num is determined by 282 h264bsdDecodeExpGolombUnsigned and then mapped to codedBlockPattern 283 either for intra or inter macroblock. The mapping is implemented by 284 look-up tables defined in the beginning of the file. 285 286 Inputs: 287 pStrmData pointer to stream data structure 288 isIntra flag to indicate if intra or inter mapping is to 289 be used 290 291 Outputs: 292 value decoded code word is stored here 293 294 Returns: 295 HANTRO_OK success 296 HANTRO_NOK failure, no valid code word found 297 298 ------------------------------------------------------------------------------*/ 299 300 u32 h264bsdDecodeExpGolombMapped(strmData_t *pStrmData, u32 *value, 301 u32 isIntra) 302 { 303 304 /* Variables */ 305 306 u32 status, codeNum; 307 308 /* Code */ 309 310 ASSERT(pStrmData); 311 ASSERT(value); 312 313 status = h264bsdDecodeExpGolombUnsigned(pStrmData, &codeNum); 314 315 if (status != HANTRO_OK) 316 return (HANTRO_NOK); 317 else 318 { 319 /* range of valid codeNums [0,47] */ 320 if (codeNum > 47) 321 return (HANTRO_NOK); 322 if (isIntra) 323 *value = codedBlockPatternIntra4x4[codeNum]; 324 else 325 *value = codedBlockPatternInter[codeNum]; 326 return(HANTRO_OK); 327 } 328 329 } 330 331 /*------------------------------------------------------------------------------ 332 333 5.4 Function: h264bsdDecodeExpGolombTruncated 334 335 Functional description: 336 Decode truncated Exp-Golomb code. greaterThanOne flag indicates 337 the range of the symbol to be decoded as follows: 338 FALSE -> [0,1] 339 TRUE -> [0,2^32-1] 340 341 If flag is false the decoding is performed by reading one bit 342 from the stream with h264bsdGetBits and mapping this to decoded 343 symbol as 344 symbol = bit ? 0 : 1 345 346 Otherwise, i.e. when flag is TRUE, code num is determined by 347 h264bsdDecodeExpGolombUnsigned and this is used as the decoded 348 symbol. 349 350 Inputs: 351 pStrmData pointer to stream data structure 352 greaterThanOne flag to indicate if range is wider than [0,1] 353 354 Outputs: 355 value decoded code word is stored here 356 357 Returns: 358 HANTRO_OK success 359 HANTRO_NOK failure, no valid code word found 360 361 ------------------------------------------------------------------------------*/ 362 363 u32 h264bsdDecodeExpGolombTruncated( 364 strmData_t *pStrmData, 365 u32 *value, 366 u32 greaterThanOne) 367 { 368 369 /* Variables */ 370 371 /* Code */ 372 373 ASSERT(pStrmData); 374 ASSERT(value); 375 376 if (greaterThanOne) 377 { 378 return(h264bsdDecodeExpGolombUnsigned(pStrmData, value)); 379 } 380 else 381 { 382 *value = h264bsdGetBits(pStrmData,1); 383 if (*value == END_OF_STREAM) 384 return (HANTRO_NOK); 385 *value ^= 0x1; 386 } 387 388 return (HANTRO_OK); 389 390 } 391 392
