1 /* ------------------------------------------------------------------
2 * Copyright (C) 1998-2009 PacketVideo
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
13 * express or implied.
14 * See the License for the specific language governing permissions
15 * and limitations under the License.
16 * -------------------------------------------------------------------
17 */
18 #include "avcdec_lib.h"
19 #include "avcdec_bitstream.h"
20
21 //#define PV_ARM_V5
22 #ifdef PV_ARM_V5
23 #define PV_CLZ(A,B) __asm{CLZ (A),(B)} \
24 A -= 16;
25 #else
26 #define PV_CLZ(A,B) while (((B) & 0x8000) == 0) {(B) <<=1; A++;}
27 #endif
28
29
30 #define PV_NO_CLZ
31
32 #ifndef PV_NO_CLZ
33 typedef struct tagVLCNumCoeffTrail
34 {
35 int trailing;
36 int total_coeff;
37 int length;
38 } VLCNumCoeffTrail;
39
40 typedef struct tagShiftOffset
41 {
42 int shift;
43 int offset;
44 } ShiftOffset;
45
46 const VLCNumCoeffTrail NumCoeffTrailOnes[3][67] =
47 {
48 {{0, 0, 1}, {1, 1, 2}, {2, 2, 3}, {1, 2, 6}, {0, 1, 6}, {3, 3, 5}, {3, 3, 5}, {3, 5, 7},
49 {2, 3, 7}, {3, 4, 6}, {3, 4, 6}, {3, 6, 8}, {2, 4, 8}, {1, 3, 8}, {0, 2, 8}, {3, 7, 9},
50 {2, 5, 9}, {1, 4, 9}, {0, 3, 9}, {3, 8, 10}, {2, 6, 10}, {1, 5, 10}, {0, 4, 10}, {3, 9, 11},
51 {2, 7, 11}, {1, 6, 11}, {0, 5, 11}, {0, 8, 13}, {2, 9, 13}, {1, 8, 13}, {0, 7, 13}, {3, 10, 13},
52 {2, 8, 13}, {1, 7, 13}, {0, 6, 13}, {3, 12, 14}, {2, 11, 14}, {1, 10, 14}, {0, 10, 14}, {3, 11, 14},
53 {2, 10, 14}, {1, 9, 14}, {0, 9, 14}, {3, 14, 15}, {2, 13, 15}, {1, 12, 15}, {0, 12, 15}, {3, 13, 15},
54 {2, 12, 15}, {1, 11, 15}, {0, 11, 15}, {3, 16, 16}, {2, 15, 16}, {1, 15, 16}, {0, 14, 16}, {3, 15, 16},
55 {2, 14, 16}, {1, 14, 16}, {0, 13, 16}, {0, 16, 16}, {2, 16, 16}, {1, 16, 16}, {0, 15, 16}, {1, 13, 15},
56 { -1, -1, -1}, { -1, -1, -1}, { -1, -1, -1}},
57
58 {{1, 1, 2}, {0, 0, 2}, {3, 4, 4}, {3, 3, 4}, {2, 2, 3}, {2, 2, 3}, {3, 6, 6}, {2, 3, 6},
59 {1, 3, 6}, {0, 1, 6}, {3, 5, 5}, {3, 5, 5}, {1, 2, 5}, {1, 2, 5}, {3, 7, 6}, {2, 4, 6},
60 {1, 4, 6}, {0, 2, 6}, {3, 8, 7}, {2, 5, 7}, {1, 5, 7}, {0, 3, 7}, {0, 5, 8}, {2, 6, 8},
61 {1, 6, 8}, {0, 4, 8}, {3, 9, 9}, {2, 7, 9}, {1, 7, 9}, {0, 6, 9}, {3, 11, 11}, {2, 9, 11},
62 {1, 9, 11}, {0, 8, 11}, {3, 10, 11}, {2, 8, 11}, {1, 8, 11}, {0, 7, 11}, {0, 11, 12}, {2, 11, 12},
63 {1, 11, 12}, {0, 10, 12}, {3, 12, 12}, {2, 10, 12}, {1, 10, 12}, {0, 9, 12}, {3, 14, 13}, {2, 13, 13},
64 {1, 13, 13}, {0, 13, 13}, {3, 13, 13}, {2, 12, 13}, {1, 12, 13}, {0, 12, 13}, {1, 15, 14}, {0, 15, 14},
65 {2, 15, 14}, {1, 14, 14}, {2, 14, 13}, {2, 14, 13}, {0, 14, 13}, {0, 14, 13}, {3, 16, 14}, {2, 16, 14},
66 {1, 16, 14}, {0, 16, 14}, {3, 15, 13}},
67
68 {{3, 7, 4}, {3, 6, 4}, {3, 5, 4}, {3, 4, 4}, {3, 3, 4}, {2, 2, 4}, {1, 1, 4}, {0, 0, 4},
69 {1, 5, 5}, {2, 5, 5}, {1, 4, 5}, {2, 4, 5}, {1, 3, 5}, {3, 8, 5}, {2, 3, 5}, {1, 2, 5},
70 {0, 3, 6}, {2, 7, 6}, {1, 7, 6}, {0, 2, 6}, {3, 9, 6}, {2, 6, 6}, {1, 6, 6}, {0, 1, 6},
71 {0, 7, 7}, {0, 6, 7}, {2, 9, 7}, {0, 5, 7}, {3, 10, 7}, {2, 8, 7}, {1, 8, 7}, {0, 4, 7},
72 {3, 12, 8}, {2, 11, 8}, {1, 10, 8}, {0, 9, 8}, {3, 11, 8}, {2, 10, 8}, {1, 9, 8}, {0, 8, 8},
73 {0, 12, 9}, {2, 13, 9}, {1, 12, 9}, {0, 11, 9}, {3, 13, 9}, {2, 12, 9}, {1, 11, 9}, {0, 10, 9},
74 {1, 15, 10}, {0, 14, 10}, {3, 14, 10}, {2, 14, 10}, {1, 14, 10}, {0, 13, 10}, {1, 13, 9}, {1, 13, 9},
75 {1, 16, 10}, {0, 15, 10}, {3, 15, 10}, {2, 15, 10}, {3, 16, 10}, {2, 16, 10}, {0, 16, 10}, { -1, -1, -1},
76 { -1, -1, -1}, { -1, -1, -1}, { -1, -1, -1}}
77 };
78
79
80 const ShiftOffset NumCoeffTrailOnes_indx[3][15] =
81 {
82 {{15, -1}, {14, 0}, {13, 1}, {10, -1}, {9, 3}, {8, 7}, {7, 11}, {6, 15},
83 {5, 19}, {3, 19}, {2, 27}, {1, 35}, {0, 43}, {0, 55}, {1, 62}},
84
85 {{14, -2}, {12, -2}, {10, -2}, {10, 10}, {9, 14}, {8, 18}, {7, 22}, {5, 22},
86 {4, 30}, {3, 38}, {2, 46}, {2, 58}, {3, 65}, {16, 0}, {16, 0}},
87
88 {{12, -8}, {11, 0}, {10, 8}, {9, 16}, {8, 24}, {7, 32}, {6, 40}, {6, 52},
89 {6, 58}, {6, 61}, {16, 0}, {16, 0}, {16, 0}, {16, 0}, {16, 0}}
90 };
91
92 const static int nC_table[8] = {0, 0, 1, 1, 2, 2, 2, 2};
93
94 #endif
95 /**
96 See algorithm in subclause 9.1, Table 9-1, Table 9-2. */
ue_v(AVCDecBitstream * bitstream,uint * codeNum)97 AVCDec_Status ue_v(AVCDecBitstream *bitstream, uint *codeNum)
98 {
99 uint temp, tmp_cnt;
100 int leading_zeros = 0;
101 BitstreamShowBits(bitstream, 16, &temp);
102 tmp_cnt = temp | 0x1;
103
104 PV_CLZ(leading_zeros, tmp_cnt)
105
106 if (leading_zeros < 8)
107 {
108 *codeNum = (temp >> (15 - (leading_zeros << 1))) - 1;
109 BitstreamFlushBits(bitstream, (leading_zeros << 1) + 1);
110 }
111 else
112 {
113 BitstreamReadBits(bitstream, (leading_zeros << 1) + 1, &temp);
114 *codeNum = temp - 1;
115 }
116
117 return AVCDEC_SUCCESS;
118 }
119
120 /**
121 See subclause 9.1.1, Table 9-3 */
se_v(AVCDecBitstream * bitstream,int * value)122 AVCDec_Status se_v(AVCDecBitstream *bitstream, int *value)
123 {
124 uint temp, tmp_cnt;
125 int leading_zeros = 0;
126 BitstreamShowBits(bitstream, 16, &temp);
127 tmp_cnt = temp | 0x1;
128
129 PV_CLZ(leading_zeros, tmp_cnt)
130
131 if (leading_zeros < 8)
132 {
133 temp >>= (15 - (leading_zeros << 1));
134 BitstreamFlushBits(bitstream, (leading_zeros << 1) + 1);
135 }
136 else
137 {
138 BitstreamReadBits(bitstream, (leading_zeros << 1) + 1, &temp);
139 }
140
141 *value = temp >> 1;
142
143 if (temp & 0x01) // lsb is signed bit
144 *value = -(*value);
145
146 // leading_zeros = temp >> 1;
147 // *value = leading_zeros - (leading_zeros*2*(temp&1));
148
149 return AVCDEC_SUCCESS;
150 }
151
se_v32bit(AVCDecBitstream * bitstream,int32 * value)152 AVCDec_Status se_v32bit(AVCDecBitstream *bitstream, int32 *value)
153 {
154 int leadingZeros;
155 uint32 infobits;
156 uint32 codeNum;
157
158 if (AVCDEC_SUCCESS != GetEGBitstring32bit(bitstream, &leadingZeros, &infobits))
159 return AVCDEC_FAIL;
160
161 codeNum = (1 << leadingZeros) - 1 + infobits;
162
163 *value = (codeNum + 1) / 2;
164
165 if ((codeNum & 0x01) == 0) // lsb is signed bit
166 *value = -(*value);
167
168 return AVCDEC_SUCCESS;
169 }
170
171
te_v(AVCDecBitstream * bitstream,uint * value,uint range)172 AVCDec_Status te_v(AVCDecBitstream *bitstream, uint *value, uint range)
173 {
174 if (range > 1)
175 {
176 ue_v(bitstream, value);
177 }
178 else
179 {
180 BitstreamRead1Bit(bitstream, value);
181 *value = 1 - (*value);
182 }
183 return AVCDEC_SUCCESS;
184 }
185
186
187
188 /* This function is only used for syntax with range from -2^31 to 2^31-1 */
189 /* only a few of them in the SPS and PPS */
GetEGBitstring32bit(AVCDecBitstream * bitstream,int * leadingZeros,uint32 * infobits)190 AVCDec_Status GetEGBitstring32bit(AVCDecBitstream *bitstream, int *leadingZeros, uint32 *infobits)
191 {
192 int bit_value;
193 uint info_temp;
194
195 *leadingZeros = 0;
196
197 BitstreamRead1Bit(bitstream, (uint*)&bit_value);
198
199 while (!bit_value)
200 {
201 (*leadingZeros)++;
202 BitstreamRead1Bit(bitstream, (uint*)&bit_value);
203 }
204
205 if (*leadingZeros > 0)
206 {
207 if (sizeof(uint) == 4) /* 32 bit machine */
208 {
209 BitstreamReadBits(bitstream, *leadingZeros, (uint*)&info_temp);
210 *infobits = (uint32)info_temp;
211 }
212 else if (sizeof(uint) == 2) /* 16 bit machine */
213 {
214 *infobits = 0;
215 if (*leadingZeros > 16)
216 {
217 BitstreamReadBits(bitstream, 16, (uint*)&info_temp);
218 (*leadingZeros) -= 16;
219 *infobits = ((uint32)info_temp) << (*leadingZeros);
220 }
221
222 BitstreamReadBits(bitstream, *leadingZeros, (uint*)&info_temp);
223 *infobits |= (uint32)info_temp ;
224 }
225 }
226 else
227 *infobits = 0;
228
229 return AVCDEC_SUCCESS;
230 }
231
232 /* see Table 9-4 assignment of codeNum to values of coded_block_pattern. */
233 const static uint8 MapCBP[48][2] =
234 {
235 {47, 0}, {31, 16}, {15, 1}, { 0, 2}, {23, 4}, {27, 8}, {29, 32}, {30, 3}, { 7, 5}, {11, 10}, {13, 12}, {14, 15},
236 {39, 47}, {43, 7}, {45, 11}, {46, 13}, {16, 14}, { 3, 6}, { 5, 9}, {10, 31}, {12, 35}, {19, 37}, {21, 42}, {26, 44},
237 {28, 33}, {35, 34}, {37, 36}, {42, 40}, {44, 39}, { 1, 43}, { 2, 45}, { 4, 46}, { 8, 17}, {17, 18}, {18, 20}, {20, 24},
238 {24, 19}, { 6, 21}, { 9, 26}, {22, 28}, {25, 23}, {32, 27}, {33, 29}, {34, 30}, {36, 22}, {40, 25}, {38, 38}, {41, 41},
239 };
240
DecodeCBP(AVCMacroblock * currMB,AVCDecBitstream * stream)241 AVCDec_Status DecodeCBP(AVCMacroblock *currMB, AVCDecBitstream *stream)
242 {
243 uint codeNum;
244 uint coded_block_pattern;
245
246 ue_v(stream, &codeNum);
247
248 if (codeNum > 47)
249 {
250 return AVCDEC_FAIL;
251 }
252
253 /* can get rid of the if _OPTIMIZE */
254 if (currMB->mbMode == AVC_I4)
255 {
256 coded_block_pattern = MapCBP[codeNum][0];
257 }
258 else
259 {
260 coded_block_pattern = MapCBP[codeNum][1];
261 }
262
263 // currMB->cbpL = coded_block_pattern&0xF; /* modulo 16 */
264 // currMB->cbpC = coded_block_pattern>>4; /* divide 16 */
265 currMB->CBP = coded_block_pattern;
266
267 return AVCDEC_SUCCESS;
268 }
269
270
271 /* TO BE OPTIMIZED !!!!! */
ce_TotalCoeffTrailingOnes(AVCDecBitstream * stream,int * TrailingOnes,int * TotalCoeff,int nC)272 AVCDec_Status ce_TotalCoeffTrailingOnes(AVCDecBitstream *stream, int *TrailingOnes, int *TotalCoeff, int nC)
273 {
274 #ifdef PV_NO_CLZ
275 const static uint8 TotCofNTrail1[75][3] = {{0, 0, 16}/*error */, {0, 0, 16}/*error */, {1, 13, 15}, {1, 13, 15}, {0, 16, 16}, {2, 16, 16}, {1, 16, 16}, {0, 15, 16},
276 {3, 16, 16}, {2, 15, 16}, {1, 15, 16}, {0, 14, 16}, {3, 15, 16}, {2, 14, 16}, {1, 14, 16}, {0, 13, 16},
277 {3, 14, 15}, {2, 13, 15}, {1, 12, 15}, {0, 12, 15}, {3, 13, 15}, {2, 12, 15}, {1, 11, 15}, {0, 11, 15},
278 {3, 12, 14}, {2, 11, 14}, {1, 10, 14}, {0, 10, 14}, {3, 11, 14}, {2, 10, 14}, {1, 9, 14}, {0, 9, 14},
279 {0, 8, 13}, {2, 9, 13}, {1, 8, 13}, {0, 7, 13}, {3, 10, 13}, {2, 8, 13}, {1, 7, 13}, {0, 6, 13},
280 {3, 9, 11}, {2, 7, 11}, {1, 6, 11}, {0, 5, 11}, {3, 8, 10},
281 {2, 6, 10}, {1, 5, 10}, {0, 4, 10}, {3, 7, 9}, {2, 5, 9}, {1, 4, 9}, {0, 3, 9}, {3, 6, 8},
282 {2, 4, 8}, {1, 3, 8}, {0, 2, 8}, {3, 5, 7}, {2, 3, 7}, {3, 4, 6}, {3, 4, 6}, {1, 2, 6},
283 {1, 2, 6}, {0, 1, 6}, {0, 1, 6}, {3, 3, 5}, {3, 3, 5}, {3, 3, 5}, {3, 3, 5}, {2, 2, 3},
284 {1, 1, 2}, {1, 1, 2}, {0, 0, 1}, {0, 0, 1}, {0, 0, 1}, {0, 0, 1}
285 };
286
287 const static uint8 TotCofNTrail2[84][3] = {{0, 0, 14 /* error */}, {0, 0, 14/*error */}, {3, 15, 13}, {3, 15, 13}, {3, 16, 14}, {2, 16, 14}, {1, 16, 14}, {0, 16, 14},
288 {1, 15, 14}, {0, 15, 14}, {2, 15, 14}, {1, 14, 14}, {2, 14, 13}, {2, 14, 13}, {0, 14, 13}, {0, 14, 13},
289 {3, 14, 13}, {2, 13, 13}, {1, 13, 13}, {0, 13, 13}, {3, 13, 13}, {2, 12, 13}, {1, 12, 13}, {0, 12, 13},
290 {0, 11, 12}, {2, 11, 12}, {1, 11, 12}, {0, 10, 12}, {3, 12, 12}, {2, 10, 12}, {1, 10, 12}, {0, 9, 12},
291 {3, 11, 11}, {2, 9, 11}, {1, 9, 11}, {0, 8, 11}, {3, 10, 11}, {2, 8, 11}, {1, 8, 11}, {0, 7, 11},
292 {3, 9, 9}, {2, 7, 9}, {1, 7, 9}, {0, 6, 9}, {0, 5, 8}, {0, 5, 8}, {2, 6, 8}, {2, 6, 8},
293 {1, 6, 8}, {1, 6, 8}, {0, 4, 8}, {0, 4, 8}, {3, 8, 7}, {2, 5, 7}, {1, 5, 7}, {0, 3, 7},
294 {3, 7, 6}, {3, 7, 6}, {2, 4, 6}, {2, 4, 6}, {1, 4, 6}, {1, 4, 6}, {0, 2, 6}, {0, 2, 6},
295 {3, 6, 6}, {2, 3, 6}, {1, 3, 6}, {0, 1, 6}, {3, 5, 5}, {3, 5, 5}, {1, 2, 5}, {1, 2, 5},
296 {3, 4, 4}, {3, 3, 4}, {2, 2, 3}, {2, 2, 3}, {1, 1, 2}, {1, 1, 2}, {1, 1, 2}, {1, 1, 2},
297 {0, 0, 2}, {0, 0, 2}, {0, 0, 2}, {0, 0, 2}
298 };
299
300 const static uint8 TotCofNTrail3[64][3] = {{0, 0, 10/*error*/}, {0, 16, 10}, {3, 16, 10}, {2, 16, 10}, {1, 16, 10}, {0, 15, 10}, {3, 15, 10},
301 {2, 15, 10}, {1, 15, 10}, {0, 14, 10}, {3, 14, 10}, {2, 14, 10}, {1, 14, 10}, {0, 13, 10}, {1, 13, 9},
302 {1, 13, 9}, {0, 12, 9}, {2, 13, 9}, {1, 12, 9}, {0, 11, 9}, {3, 13, 9}, {2, 12, 9}, {1, 11, 9},
303 {0, 10, 9}, {3, 12, 8}, {2, 11, 8}, {1, 10, 8}, {0, 9, 8}, {3, 11, 8}, {2, 10, 8}, {1, 9, 8},
304 {0, 8, 8}, {0, 7, 7}, {0, 6, 7}, {2, 9, 7}, {0, 5, 7}, {3, 10, 7}, {2, 8, 7}, {1, 8, 7},
305 {0, 4, 7}, {0, 3, 6}, {2, 7, 6}, {1, 7, 6}, {0, 2, 6}, {3, 9, 6}, {2, 6, 6}, {1, 6, 6},
306 {0, 1, 6}, {1, 5, 5}, {2, 5, 5}, {1, 4, 5}, {2, 4, 5}, {1, 3, 5}, {3, 8, 5}, {2, 3, 5},
307 {1, 2, 5}, {3, 7, 4}, {3, 6, 4}, {3, 5, 4}, {3, 4, 4}, {3, 3, 4}, {2, 2, 4}, {1, 1, 4},
308 {0, 0, 4}
309 };
310 #endif
311 uint code;
312
313 #ifdef PV_NO_CLZ
314 uint8 *pcode;
315 if (nC < 2)
316 {
317 BitstreamShowBits(stream, 16, &code);
318
319 if (code >= 8192)
320 {
321 pcode = (uint8*) & (TotCofNTrail1[(code>>13)+65+2][0]);
322 }
323 else if (code >= 2048)
324 {
325 pcode = (uint8*) & (TotCofNTrail1[(code>>9)+50+2][0]);
326 }
327 else if (code >= 1024)
328 {
329 pcode = (uint8*) & (TotCofNTrail1[(code>>8)+46+2][0]);
330 }
331 else if (code >= 512)
332 {
333 pcode = (uint8*) & (TotCofNTrail1[(code>>7)+42+2][0]);
334 }
335 else if (code >= 256)
336 {
337 pcode = (uint8*) & (TotCofNTrail1[(code>>6)+38+2][0]);
338 }
339 else if (code >= 128)
340 {
341 pcode = (uint8*) & (TotCofNTrail1[(code>>5)+34+2][0]);
342 }
343 else if (code >= 64)
344 {
345 pcode = (uint8*) & (TotCofNTrail1[(code>>3)+22+2][0]);
346 }
347 else if (code >= 32)
348 {
349 pcode = (uint8*) & (TotCofNTrail1[(code>>2)+14+2][0]);
350 }
351 else if (code >= 16)
352 {
353 pcode = (uint8*) & (TotCofNTrail1[(code>>1)+6+2][0]);
354 }
355 else
356 {
357 pcode = (uint8*) & (TotCofNTrail1[(code-2)+2][0]);
358 }
359
360 *TrailingOnes = pcode[0];
361 *TotalCoeff = pcode[1];
362
363 BitstreamFlushBits(stream, pcode[2]);
364 }
365 else if (nC < 4)
366 {
367 BitstreamShowBits(stream, 14, &code);
368
369 if (code >= 4096)
370 {
371 pcode = (uint8*) & (TotCofNTrail2[(code>>10)+66+2][0]);
372 }
373 else if (code >= 2048)
374 {
375 pcode = (uint8*) & (TotCofNTrail2[(code>>8)+54+2][0]);
376 }
377 else if (code >= 512)
378 {
379 pcode = (uint8*) & (TotCofNTrail2[(code>>7)+46+2][0]);
380 }
381 else if (code >= 128)
382 {
383 pcode = (uint8*) & (TotCofNTrail2[(code>>5)+34+2][0]);
384 }
385 else if (code >= 64)
386 {
387 pcode = (uint8*) & (TotCofNTrail2[(code>>3)+22+2][0]);
388 }
389 else if (code >= 32)
390 {
391 pcode = (uint8*) & (TotCofNTrail2[(code>>2)+14+2][0]);
392 }
393 else if (code >= 16)
394 {
395 pcode = (uint8*) & (TotCofNTrail2[(code>>1)+6+2][0]);
396 }
397 else
398 {
399 pcode = (uint8*) & (TotCofNTrail2[code-2+2][0]);
400 }
401 *TrailingOnes = pcode[0];
402 *TotalCoeff = pcode[1];
403
404 BitstreamFlushBits(stream, pcode[2]);
405 }
406 else if (nC < 8)
407 {
408 BitstreamShowBits(stream, 10, &code);
409
410 if (code >= 512)
411 {
412 pcode = (uint8*) & (TotCofNTrail3[(code>>6)+47+1][0]);
413 }
414 else if (code >= 256)
415 {
416 pcode = (uint8*) & (TotCofNTrail3[(code>>5)+39+1][0]);
417 }
418 else if (code >= 128)
419 {
420 pcode = (uint8*) & (TotCofNTrail3[(code>>4)+31+1][0]);
421 }
422 else if (code >= 64)
423 {
424 pcode = (uint8*) & (TotCofNTrail3[(code>>3)+23+1][0]);
425 }
426 else if (code >= 32)
427 {
428 pcode = (uint8*) & (TotCofNTrail3[(code>>2)+15+1][0]);
429 }
430 else if (code >= 16)
431 {
432 pcode = (uint8*) & (TotCofNTrail3[(code>>1)+7+1][0]);
433 }
434 else
435 {
436 pcode = (uint8*) & (TotCofNTrail3[code-1+1][0]);
437 }
438 *TrailingOnes = pcode[0];
439 *TotalCoeff = pcode[1];
440
441 BitstreamFlushBits(stream, pcode[2]);
442 }
443 else
444 {
445 /* read 6 bit FLC */
446 BitstreamReadBits(stream, 6, &code);
447
448
449 *TrailingOnes = code & 3;
450 *TotalCoeff = (code >> 2) + 1;
451
452 if (*TotalCoeff > 16)
453 {
454 *TotalCoeff = 16; // _ERROR
455 }
456
457 if (code == 3)
458 {
459 *TrailingOnes = 0;
460 (*TotalCoeff)--;
461 }
462 }
463 #else
464 const VLCNumCoeffTrail *ptr;
465 const ShiftOffset *ptr_indx;
466 uint temp, leading_zeros = 0;
467
468 if (nC < 8)
469 {
470
471 BitstreamShowBits(stream, 16, &code);
472 temp = code | 1;
473
474 PV_CLZ(leading_zeros, temp)
475
476 temp = nC_table[nC];
477 ptr_indx = &NumCoeffTrailOnes_indx[temp][leading_zeros];
478 ptr = &NumCoeffTrailOnes[temp][(code >> ptr_indx->shift) + ptr_indx->offset];
479 *TrailingOnes = ptr->trailing;
480 *TotalCoeff = ptr->total_coeff;
481 BitstreamFlushBits(stream, ptr->length);
482 }
483 else
484 {
485 /* read 6 bit FLC */
486 BitstreamReadBits(stream, 6, &code);
487
488
489 *TrailingOnes = code & 3;
490 *TotalCoeff = (code >> 2) + 1;
491
492 if (*TotalCoeff > 16)
493 {
494 *TotalCoeff = 16; // _ERROR
495 }
496
497 if (code == 3)
498 {
499 *TrailingOnes = 0;
500 (*TotalCoeff)--;
501 }
502 }
503 #endif
504 return AVCDEC_SUCCESS;
505 }
506
507 /* TO BE OPTIMIZED !!!!! */
ce_TotalCoeffTrailingOnesChromaDC(AVCDecBitstream * stream,int * TrailingOnes,int * TotalCoeff)508 AVCDec_Status ce_TotalCoeffTrailingOnesChromaDC(AVCDecBitstream *stream, int *TrailingOnes, int *TotalCoeff)
509 {
510 AVCDec_Status status;
511
512 const static uint8 TotCofNTrail5[21][3] =
513 {
514 {3, 4, 7}, {3, 4, 7}, {2, 4, 8}, {1, 4, 8}, {2, 3, 7}, {2, 3, 7}, {1, 3, 7},
515 {1, 3, 7}, {0, 4, 6}, {0, 3, 6}, {0, 2, 6}, {3, 3, 6}, {1, 2, 6}, {0, 1, 6},
516 {2, 2, 3}, {0, 0, 2}, {0, 0, 2}, {1, 1, 1}, {1, 1, 1}, {1, 1, 1}, {1, 1, 1}
517 };
518
519 uint code;
520 uint8 *pcode;
521
522 status = BitstreamShowBits(stream, 8, &code);
523
524 if (code >= 32)
525 {
526 pcode = (uint8*) & (TotCofNTrail5[(code>>5)+13][0]);
527 }
528 else if (code >= 8)
529 {
530 pcode = (uint8*) & (TotCofNTrail5[(code>>2)+6][0]);
531 }
532 else
533 {
534 pcode = (uint8*) & (TotCofNTrail5[code][0]);
535 }
536
537 *TrailingOnes = pcode[0];
538 *TotalCoeff = pcode[1];
539
540 BitstreamFlushBits(stream, pcode[2]);
541
542 return status;
543 }
544
545 /* see Table 9-6 */
ce_LevelPrefix(AVCDecBitstream * stream,uint * code)546 AVCDec_Status ce_LevelPrefix(AVCDecBitstream *stream, uint *code)
547 {
548 uint temp;
549 uint leading_zeros = 0;
550 BitstreamShowBits(stream, 16, &temp);
551 temp |= 1 ;
552
553 PV_CLZ(leading_zeros, temp)
554
555 BitstreamFlushBits(stream, leading_zeros + 1);
556 *code = leading_zeros;
557 return AVCDEC_SUCCESS;
558 }
559
560 /* see Table 9-7 and 9-8 */
ce_TotalZeros(AVCDecBitstream * stream,int * code,int TotalCoeff)561 AVCDec_Status ce_TotalZeros(AVCDecBitstream *stream, int *code, int TotalCoeff)
562 {
563 const static uint8 TotZero1[28][2] = {{15, 9}, {14, 9}, {13, 9}, {12, 8},
564 {12, 8}, {11, 8}, {11, 8}, {10, 7}, {9, 7}, {8, 6}, {8, 6}, {7, 6}, {7, 6}, {6, 5}, {6, 5},
565 {6, 5}, {6, 5}, {5, 5}, {5, 5}, {5, 5}, {5, 5}, {4, 4}, {3, 4},
566 {2, 3}, {2, 3}, {1, 3}, {1, 3}, {0, 1}
567 };
568
569 const static uint8 TotZero2n3[2][18][2] = {{{14, 6}, {13, 6}, {12, 6}, {11, 6},
570 {10, 5}, {10, 5}, {9, 5}, {9, 5}, {8, 4}, {7, 4}, {6, 4}, {5, 4}, {4, 3}, {4, 3},
571 {3, 3}, {2, 3}, {1, 3}, {0, 3}},
572
573 /*const static uint8 TotZero3[18][2]=*/{{13, 6}, {11, 6}, {12, 5}, {12, 5}, {10, 5},
574 {10, 5}, {9, 5}, {9, 5}, {8, 4}, {5, 4}, {4, 4}, {0, 4}, {7, 3}, {7, 3}, {6, 3}, {3, 3},
575 {2, 3}, {1, 3}}
576 };
577
578 const static uint8 TotZero4[17][2] = {{12, 5}, {11, 5}, {10, 5}, {0, 5}, {9, 4},
579 {9, 4}, {7, 4}, {7, 4}, {3, 4}, {3, 4}, {2, 4}, {2, 4}, {8, 3}, {6, 3}, {5, 3}, {4, 3}, {1, 3}
580 };
581
582 const static uint8 TotZero5[13][2] = {{11, 5}, {9, 5}, {10, 4}, {8, 4}, {2, 4},
583 {1, 4}, {0, 4}, {7, 3}, {7, 3}, {6, 3}, {5, 3}, {4, 3}, {3, 3}
584 };
585
586 const static uint8 TotZero6to10[5][15][2] = {{{10, 6}, {0, 6}, {1, 5}, {1, 5}, {8, 4},
587 {8, 4}, {8, 4}, {8, 4}, {9, 3}, {7, 3}, {6, 3}, {5, 3}, {4, 3}, {3, 3}, {2, 3}},
588
589 /*const static uint8 TotZero7[15][2]=*/{{9, 6}, {0, 6}, {1, 5}, {1, 5}, {7, 4},
590 {7, 4}, {7, 4}, {7, 4}, {8, 3}, {6, 3}, {4, 3}, {3, 3}, {2, 3}, {5, 2}, {5, 2}},
591
592 /*const static uint8 TotZero8[15][2]=*/{{8, 6}, {0, 6}, {2, 5}, {2, 5}, {1, 4},
593 {1, 4}, {1, 4}, {1, 4}, {7, 3}, {6, 3}, {3, 3}, {5, 2}, {5, 2}, {4, 2}, {4, 2}},
594
595 /*const static uint8 TotZero9[15][2]=*/{{1, 6}, {0, 6}, {7, 5}, {7, 5}, {2, 4},
596 {2, 4}, {2, 4}, {2, 4}, {5, 3}, {6, 2}, {6, 2}, {4, 2}, {4, 2}, {3, 2}, {3, 2}},
597
598 /*const static uint8 TotZero10[11][2]=*/{{1, 5}, {0, 5}, {6, 4}, {6, 4}, {2, 3},
599 {2, 3}, {2, 3}, {2, 3}, {5, 2}, {4, 2}, {3, 2}, {0, 0}, {0, 0}, {0, 0}, {0, 0}}
600 };
601
602 const static uint8 TotZero11[7][2] = {{0, 4}, {1, 4}, {2, 3}, {2, 3}, {3, 3}, {5, 3}, {4, 1}};
603
604 const static uint8 TotZero12to15[4][5][2] =
605 {
606 {{3, 1}, {2, 2}, {4, 3}, {1, 4}, {0, 4}},
607 {{2, 1}, {3, 2}, {1, 3}, {0, 3}, {0, 0}},
608 {{2, 1}, {1, 2}, {0, 2}, {0, 0}, {0, 0}},
609 {{1, 1}, {0, 1}, {0, 0}, {0, 0}, {0, 0}}
610 };
611
612 uint temp, mask;
613 int indx;
614 uint8 *pcode;
615
616 if (TotalCoeff == 1)
617 {
618 BitstreamShowBits(stream, 9, &temp);
619
620 if (temp >= 256)
621 {
622 pcode = (uint8*) & (TotZero1[27][0]);
623 }
624 else if (temp >= 64)
625 {
626 pcode = (uint8*) & (TotZero1[(temp>>5)+19][0]);
627 }
628 else if (temp >= 8)
629 {
630 pcode = (uint8*) & (TotZero1[(temp>>2)+5][0]);
631 }
632 else
633 {
634 pcode = (uint8*) & (TotZero1[temp-1][0]);
635 }
636
637 }
638 else if (TotalCoeff == 2 || TotalCoeff == 3)
639 {
640 BitstreamShowBits(stream, 6, &temp);
641
642 if (temp >= 32)
643 {
644 pcode = (uint8*) & (TotZero2n3[TotalCoeff-2][(temp>>3)+10][0]);
645 }
646 else if (temp >= 8)
647 {
648 pcode = (uint8*) & (TotZero2n3[TotalCoeff-2][(temp>>2)+6][0]);
649 }
650 else
651 {
652 pcode = (uint8*) & (TotZero2n3[TotalCoeff-2][temp][0]);
653 }
654 }
655 else if (TotalCoeff == 4)
656 {
657 BitstreamShowBits(stream, 5, &temp);
658
659 if (temp >= 12)
660 {
661 pcode = (uint8*) & (TotZero4[(temp>>2)+9][0]);
662 }
663 else
664 {
665 pcode = (uint8*) & (TotZero4[temp][0]);
666 }
667 }
668 else if (TotalCoeff == 5)
669 {
670 BitstreamShowBits(stream, 5, &temp);
671
672 if (temp >= 16)
673 {
674 pcode = (uint8*) & (TotZero5[(temp>>2)+5][0]);
675 }
676 else if (temp >= 2)
677 {
678 pcode = (uint8*) & (TotZero5[(temp>>1)+1][0]);
679 }
680 else
681 {
682 pcode = (uint8*) & (TotZero5[temp][0]);
683 }
684 }
685 else if (TotalCoeff >= 6 && TotalCoeff <= 10)
686 {
687 if (TotalCoeff == 10)
688 {
689 BitstreamShowBits(stream, 5, &temp);
690 }
691 else
692 {
693 BitstreamShowBits(stream, 6, &temp);
694 }
695
696
697 if (temp >= 8)
698 {
699 pcode = (uint8*) & (TotZero6to10[TotalCoeff-6][(temp>>3)+7][0]);
700 }
701 else
702 {
703 pcode = (uint8*) & (TotZero6to10[TotalCoeff-6][temp][0]);
704 }
705 }
706 else if (TotalCoeff == 11)
707 {
708 BitstreamShowBits(stream, 4, &temp);
709
710
711 if (temp >= 8)
712 {
713 pcode = (uint8*) & (TotZero11[6][0]);
714 }
715 else if (temp >= 4)
716 {
717 pcode = (uint8*) & (TotZero11[(temp>>1)+2][0]);
718 }
719 else
720 {
721 pcode = (uint8*) & (TotZero11[temp][0]);
722 }
723 }
724 else
725 {
726 BitstreamShowBits(stream, (16 - TotalCoeff), &temp);
727 mask = 1 << (15 - TotalCoeff);
728 indx = 0;
729 while ((temp&mask) == 0 && indx < (16 - TotalCoeff)) /* search location of 1 bit */
730 {
731 mask >>= 1;
732 indx++;
733 }
734
735 pcode = (uint8*) & (TotZero12to15[TotalCoeff-12][indx]);
736 }
737
738 *code = pcode[0];
739 BitstreamFlushBits(stream, pcode[1]);
740
741 return AVCDEC_SUCCESS;
742 }
743
744 /* see Table 9-9 */
ce_TotalZerosChromaDC(AVCDecBitstream * stream,int * code,int TotalCoeff)745 AVCDec_Status ce_TotalZerosChromaDC(AVCDecBitstream *stream, int *code, int TotalCoeff)
746 {
747 const static uint8 TotZeroChrom1to3[3][8][2] =
748 {
749 {{3, 3}, {2, 3}, {1, 2}, {1, 2}, {0, 1}, {0, 1}, {0, 1}, {0, 1}},
750 {{2, 2}, {2, 2}, {1, 2}, {1, 2}, {0, 1}, {0, 1}, {0, 1}, {0, 1}},
751 {{1, 1}, {1, 1}, {1, 1}, {1, 1}, {0, 1}, {0, 1}, {0, 1}, {0, 1}},
752 };
753
754
755 uint temp;
756 uint8 *pcode;
757
758 BitstreamShowBits(stream, 3, &temp);
759 pcode = (uint8*) & (TotZeroChrom1to3[TotalCoeff-1][temp]);
760
761 *code = pcode[0];
762
763 BitstreamFlushBits(stream, pcode[1]);
764
765 return AVCDEC_SUCCESS;
766 }
767
768 /* see Table 9-10 */
ce_RunBefore(AVCDecBitstream * stream,int * code,int zerosLeft)769 AVCDec_Status ce_RunBefore(AVCDecBitstream *stream, int *code, int zerosLeft)
770 {
771 const static int codlen[6] = {1, 2, 2, 3, 3, 3}; /* num bits to read */
772 const static uint8 RunBeforeTab[6][8][2] = {{{1, 1}, {0, 1}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}},
773 /*const static int RunBefore2[4][2]=*/{{2, 2}, {1, 2}, {0, 1}, {0, 1}, {0, 0}, {0, 0}, {0, 0}, {0, 0}},
774 /*const static int RunBefore3[4][2]=*/{{3, 2}, {2, 2}, {1, 2}, {0, 2}, {0, 0}, {0, 0}, {0, 0}, {0, 0}},
775 /*const static int RunBefore4[7][2]=*/{{4, 3}, {3, 3}, {2, 2}, {2, 2}, {1, 2}, {1, 2}, {0, 2}, {0, 2}},
776 /*const static int RunBefore5[7][2]=*/{{5, 3}, {4, 3}, {3, 3}, {2, 3}, {1, 2}, {1, 2}, {0, 2}, {0, 2}},
777 /*const static int RunBefore6[7][2]=*/{{1, 3}, {2, 3}, {4, 3}, {3, 3}, {6, 3}, {5, 3}, {0, 2}, {0, 2}}
778 };
779
780 uint temp;
781 uint8 *pcode;
782 int indx;
783
784 if (zerosLeft <= 6)
785 {
786 BitstreamShowBits(stream, codlen[zerosLeft-1], &temp);
787
788 pcode = (uint8*) & (RunBeforeTab[zerosLeft-1][temp][0]);
789
790 *code = pcode[0];
791
792 BitstreamFlushBits(stream, pcode[1]);
793 }
794 else
795 {
796 BitstreamReadBits(stream, 3, &temp);
797 if (temp)
798 {
799 *code = 7 - temp;
800 }
801 else
802 {
803 BitstreamShowBits(stream, 9, &temp);
804 temp <<= 7;
805 temp |= 1;
806 indx = 0;
807 PV_CLZ(indx, temp)
808 *code = 7 + indx;
809 BitstreamFlushBits(stream, indx + 1);
810 }
811 }
812
813
814 return AVCDEC_SUCCESS;
815 }
816