[svn] / branches / dev-api-4 / xvidcore / src / bitstream / mbcoding.c Repository:
ViewVC logotype

Annotation of /branches/dev-api-4/xvidcore/src/bitstream/mbcoding.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 78 - (view) (download)
Original Path: trunk/xvidcore/src/bitstream/mbcoding.c

1 : Isibaar 3 #include "../portab.h"
2 :     #include "bitstream.h"
3 :     #include "zigzag.h"
4 :     #include "vlc_codes.h"
5 :    
6 :     #include "../utils/mbfunctions.h"
7 :    
8 : edgomez 17 #include <stdlib.h> /* malloc, free */
9 :    
10 : Isibaar 3 #define ESCAPE 7167
11 :     #define ABS(X) (((X)>0)?(X):-(X))
12 :     #define CLIP(X,A) (X > A) ? (A) : (X)
13 :    
14 :     static VLC *DCT3D[2];
15 :    
16 :     VLC *intra_table, *inter_table;
17 :     static short clip_table[4096];
18 :    
19 :     void create_vlc_tables(void)
20 :     {
21 : edgomez 78
22 : Isibaar 3 int32_t k, l, i, intra, last;
23 :     VLC *vlc[2];
24 :     VLC **coeff_ptr;
25 :     VLC *vlc1, *vlc2;
26 :    
27 :     VLC *DCT3Dintra;
28 :     VLC *DCT3Dinter;
29 :    
30 :     DCT3Dintra = (VLC *) malloc(sizeof(VLC) * 4096);
31 :     DCT3Dinter = (VLC *) malloc(sizeof(VLC) * 4096);
32 :    
33 :     vlc1 = DCT3Dintra;
34 :     vlc2 = DCT3Dinter;
35 :    
36 :     vlc[0] = intra_table = (VLC *) malloc(128 * 511 * sizeof(VLC));
37 :     vlc[1] = inter_table = (VLC *) malloc(128 * 511 * sizeof(VLC));
38 :    
39 :     // initialize the clipping table
40 :     for(i = -2048; i < 2048; i++) {
41 :     clip_table[i + 2048] = i;
42 :     if(i < -255)
43 :     clip_table[i + 2048] = -255;
44 :     if(i > 255)
45 :     clip_table[i + 2048] = 255;
46 :     }
47 :    
48 :     // generate intra/inter vlc lookup table
49 :     for(i = 0; i < 4; i++) {
50 :     intra = i % 2;
51 :     last = i >> 1;
52 :    
53 :     coeff_ptr = coeff_vlc[last + (intra << 1)];
54 :    
55 :     for(k = -255; k < 256; k++) { // level
56 :     char *max_level_ptr = max_level[last + (intra << 1)];
57 :     char *max_run_ptr = max_run[last + (intra << 1)];
58 :    
59 :     for(l = 0; l < 64; l++) { // run
60 : Isibaar 35 int32_t level = k;
61 :     uint32_t run = l;
62 : Isibaar 3
63 :     if(abs(level) <= max_level_ptr[run] && run <= max_run_ptr[abs(level)]) {
64 :    
65 :     if(level > 0) {
66 :     vlc[intra]->code = (coeff_ptr[run][level - 1].code) << 1;
67 :     vlc[intra]->len = coeff_ptr[run][level - 1].len + 1;
68 :     }
69 :     else if(level < 0) {
70 :     vlc[intra]->code = ((coeff_ptr[run][-level - 1].code) << 1) + 1;
71 :     vlc[intra]->len = coeff_ptr[run][-level - 1].len + 1;
72 :     }
73 :     else {
74 :     vlc[intra]->code = 0;
75 :     vlc[intra]->len = 0;
76 :     }
77 :     } else {
78 :     if(level > 0)
79 :     level -= max_level_ptr[run];
80 :     else
81 :     level += max_level_ptr[run];
82 :    
83 :     if(abs(level) <= max_level_ptr[run] &&
84 :     run <= max_run_ptr[abs(level)]) {
85 :    
86 :     if(level > 0) {
87 :     vlc[intra]->code = (0x06 << (coeff_ptr[run][level - 1].len + 1)) |
88 :     (coeff_ptr[run][level - 1].code << 1);
89 :     vlc[intra]->len = (coeff_ptr[run][level - 1].len + 1) + 8;
90 :     }
91 :     else if(level < 0) {
92 :     vlc[intra]->code = (0x06 << (coeff_ptr[run][-level - 1].len + 1)) |
93 :     ((coeff_ptr[run][-level - 1].code << 1) + 1);
94 :     vlc[intra]->len = (coeff_ptr[run][-level - 1].len + 1) + 8;
95 :     }
96 :     else {
97 :     vlc[intra]->code = 0x06;
98 :     vlc[intra]->len = 8;
99 :     }
100 :     } else {
101 :     if(level > 0)
102 :     level += max_level_ptr[run];
103 :     else
104 :     level -= max_level_ptr[run];
105 : Isibaar 35
106 : Isibaar 3 run -= max_run_ptr[abs(level)] + 1;
107 : Isibaar 28
108 : Isibaar 3 if(abs(level) <= max_level_ptr[run] &&
109 :     run <= max_run_ptr[abs(level)]) {
110 :    
111 :     if(level > 0) {
112 :     vlc[intra]->code = (0x0e << (coeff_ptr[run][level - 1].len + 1)) |
113 :     (coeff_ptr[run][level - 1].code << 1);
114 :     vlc[intra]->len = (coeff_ptr[run][level - 1].len + 1) + 9;
115 :     }
116 :     else if(level < 0) {
117 :     vlc[intra]->code = (0x0e << (coeff_ptr[run][-level - 1].len + 1)) |
118 :     ((coeff_ptr[run][-level - 1].code << 1) + 1);
119 :     vlc[intra]->len = (coeff_ptr[run][-level - 1].len + 1) + 9;
120 :     }
121 :     else {
122 :     vlc[intra]->code = 0x0e;
123 :     vlc[intra]->len = 9;
124 :     }
125 :     } else {
126 :     if(level != 0)
127 :     run += max_run_ptr[abs(level)] + 1;
128 :     else
129 :     run++;
130 :    
131 :     vlc[intra]->code = (uint32_t) ((0x1e + last) << 20) |
132 :     (l << 14) | (1 << 13) | ((k & 0xfff) << 1) | 1;
133 :    
134 :     vlc[intra]->len = 30;
135 :     }
136 :     }
137 :     }
138 :     vlc[intra]++;
139 :     }
140 :     }
141 :     }
142 : edgomez 78
143 : Isibaar 3 intra_table += 64*255; // center vlc tables
144 :     inter_table += 64*255; // center vlc tables
145 :    
146 :     for(i = 0; i < 4096; i++) {
147 :     if(i >= 512) {
148 :     *vlc1 = DCT3Dtab3[(i >> 5) - 16];
149 :     *vlc2 = DCT3Dtab0[(i >> 5) - 16];
150 :     }
151 :     else if(i >= 128) {
152 :     *vlc1 = DCT3Dtab4[(i >> 2) - 32];
153 :     *vlc2 = DCT3Dtab1[(i >> 2) - 32];
154 :     }
155 :     else if(i >= 8) {
156 :     *vlc1 = DCT3Dtab5[i - 8];
157 :     *vlc2 = DCT3Dtab2[i - 8];
158 :     }
159 :     else {
160 :     *vlc1 = ERRtab[i];
161 :     *vlc2 = ERRtab[i];
162 :     }
163 :    
164 :     vlc1++;
165 :     vlc2++;
166 :     }
167 :     DCT3D[0] = DCT3Dinter;
168 :     DCT3D[1] = DCT3Dintra;
169 :    
170 :     }
171 :    
172 :     void destroy_vlc_tables(void) {
173 :    
174 :     if(intra_table != NULL && inter_table != NULL) {
175 :     intra_table -= 64*255; // uncenter vlc tables
176 :     inter_table -= 64*255; // uncenter vlc tables
177 :    
178 :     free(intra_table);
179 :     free(inter_table);
180 :     }
181 :    
182 :     if(DCT3D[0] != NULL && DCT3D[1] != NULL) {
183 :     free(DCT3D[0]);
184 :     free(DCT3D[1]);
185 :     }
186 :    
187 :     }
188 :    
189 : edgomez 78 static __inline void CodeVector(Bitstream *bs,
190 :     int16_t value,
191 :     int16_t f_code,
192 :     Statistics *pStat)
193 : Isibaar 3 {
194 : edgomez 78
195 : Isibaar 3 const int scale_factor = 1 << (f_code - 1);
196 :     const int cmp = scale_factor << 5;
197 :    
198 :     if(value < (-1 * cmp))
199 :     value += 64 * scale_factor;
200 :    
201 :     if(value > (cmp - 1))
202 :     value -= 64 * scale_factor;
203 :    
204 : edgomez 78 pStat->iMvSum += value * value;
205 :     pStat->iMvCount++;
206 : Isibaar 3
207 : edgomez 78 if (value == 0) {
208 : Isibaar 3 BitstreamPutBits(bs, mb_motion_table[32].code, mb_motion_table[32].len);
209 : edgomez 78 } else {
210 : Isibaar 3 uint16_t length, code, mv_res, sign;
211 :    
212 :     length = 16 << f_code;
213 :     f_code--;
214 :    
215 :     sign = (value < 0);
216 :    
217 :     if(value >= length)
218 :     value -= 2 * length;
219 :     else if(value < -length)
220 :     value += 2 * length;
221 :    
222 :     if(sign)
223 :     value = -value;
224 :    
225 :     value--;
226 :     mv_res = value & ((1 << f_code) - 1);
227 :     code = ((value - mv_res) >> f_code) + 1;
228 :    
229 :     if(sign)
230 :     code = -code;
231 :    
232 :     code += 32;
233 :     BitstreamPutBits(bs, mb_motion_table[code].code, mb_motion_table[code].len);
234 :    
235 :     if(f_code)
236 :     BitstreamPutBits(bs, mv_res, f_code);
237 : edgomez 78 }
238 :    
239 : Isibaar 3 }
240 :    
241 :    
242 : edgomez 78 static __inline void CodeCoeff(Bitstream *bs,
243 :     int16_t qcoeff[64],
244 :     VLC *table,
245 :     const uint16_t *zigzag,
246 :     uint16_t intra)
247 :     {
248 :    
249 : Isibaar 3 uint32_t j, last;
250 :     short v;
251 :     VLC *vlc;
252 :    
253 :     j = intra;
254 :     last = 1 + intra;
255 :    
256 :     while((v = qcoeff[zigzag[j++]]) == 0);
257 :    
258 :     do {
259 :     // count zeroes
260 :     vlc = table + (clip_table[2048+v] << 6) + j - last;
261 :     last = j + 1;
262 :     while(j < 64 && (v = qcoeff[zigzag[j++]]) == 0);
263 :    
264 :     // write code
265 :     if(j != 64) {
266 :     BitstreamPutBits(bs, vlc->code, vlc->len);
267 :     } else {
268 :     vlc += 64*511;
269 :     BitstreamPutBits(bs, vlc->code, vlc->len);
270 :     break;
271 :     }
272 :     } while(1);
273 : edgomez 78
274 : Isibaar 3 }
275 :    
276 :    
277 : edgomez 78 static void CodeBlockIntra(const MBParam * pParam,
278 :     const MACROBLOCK *pMB,
279 :     int16_t qcoeff[6*64],
280 :     Bitstream * bs,
281 :     Statistics * pStat)
282 : Isibaar 3 {
283 : edgomez 78
284 : Isibaar 3 uint32_t i, mcbpc, cbpy, bits;
285 :    
286 :     cbpy = pMB->cbp >> 2;
287 :    
288 : edgomez 78 // write mcbpc
289 : Isibaar 28 if(pParam->coding_type == I_VOP) {
290 : edgomez 78 mcbpc = ((pMB->mode >> 1) & 3) | ((pMB->cbp & 3) << 2);
291 : Isibaar 28 BitstreamPutBits(bs, mcbpc_intra_tab[mcbpc].code, mcbpc_intra_tab[mcbpc].len);
292 :     }
293 :     else {
294 : edgomez 78 mcbpc = (pMB->mode & 7) | ((pMB->cbp & 3) << 3);
295 : Isibaar 28 BitstreamPutBits(bs, mcbpc_inter_tab[mcbpc].code, mcbpc_inter_tab[mcbpc].len);
296 :     }
297 : Isibaar 3
298 :     // ac prediction flag
299 :     if(pMB->acpred_directions[0])
300 : edgomez 78 BitstreamPutBits(bs, 1, 1);
301 : Isibaar 3 else
302 : edgomez 78 BitstreamPutBits(bs, 0, 1);
303 : Isibaar 3
304 : edgomez 78 // write cbpy
305 : Isibaar 3 BitstreamPutBits (bs, cbpy_tab[cbpy].code, cbpy_tab[cbpy].len);
306 :    
307 :     // write dquant
308 : edgomez 78 if(pMB->mode == MODE_INTRA_Q)
309 : Isibaar 3 BitstreamPutBits(bs, pMB->dquant, 2);
310 :    
311 : h 69 // write interlacing
312 :     if (pParam->global_flags & XVID_INTERLACING)
313 :     {
314 :     BitstreamPutBit(bs, pMB->field_dct);
315 :     }
316 :    
317 : Isibaar 3 // code block coeffs
318 :     for(i = 0; i < 6; i++)
319 :     {
320 :     if(i < 4)
321 : edgomez 78 BitstreamPutBits(bs,
322 :     dcy_tab[qcoeff[i*64 + 0] + 255].code,
323 :     dcy_tab[qcoeff[i*64 + 0] + 255].len);
324 : Isibaar 3 else
325 : edgomez 78 BitstreamPutBits(bs,
326 :     dcc_tab[qcoeff[i*64 + 0] + 255].code,
327 :     dcc_tab[qcoeff[i*64 + 0] + 255].len);
328 : Isibaar 3
329 :     if(pMB->cbp & (1 << (5 - i)))
330 :     {
331 :     bits = BitstreamPos(bs);
332 :    
333 : edgomez 78 CodeCoeff(bs,
334 :     &qcoeff[i*64],
335 :     intra_table,
336 :     scan_tables[pMB->acpred_directions[i]],
337 :     1);
338 : Isibaar 3
339 :     bits = BitstreamPos(bs) - bits;
340 :     pStat->iTextBits += bits;
341 :     }
342 :     }
343 : edgomez 78
344 : Isibaar 3 }
345 :    
346 :    
347 : edgomez 78 static void CodeBlockInter(const MBParam * pParam,
348 :     const MACROBLOCK *pMB,
349 :     int16_t qcoeff[6*64],
350 :     Bitstream * bs,
351 :     Statistics * pStat)
352 : Isibaar 3 {
353 : edgomez 78
354 : Isibaar 3 int32_t i;
355 :     uint32_t bits, mcbpc, cbpy;
356 :    
357 : edgomez 78 mcbpc = (pMB->mode & 7) | ((pMB->cbp & 3) << 3);
358 : Isibaar 3 cbpy = 15 - (pMB->cbp >> 2);
359 :    
360 :     // write mcbpc
361 : edgomez 78 BitstreamPutBits(bs, mcbpc_inter_tab[mcbpc].code, mcbpc_inter_tab[mcbpc].len);
362 : Isibaar 3
363 :     // write cbpy
364 :     BitstreamPutBits(bs, cbpy_tab[cbpy].code, cbpy_tab[cbpy].len);
365 :    
366 :     // write dquant
367 : edgomez 78 if(pMB->mode == MODE_INTER_Q)
368 : Isibaar 3 BitstreamPutBits(bs, pMB->dquant, 2);
369 :    
370 : h 69 // interlacing
371 :     if (pParam->global_flags & XVID_INTERLACING)
372 :     {
373 :     BitstreamPutBit(bs, pMB->field_dct);
374 :     DEBUG1("codep: field_dct: ", pMB->field_dct);
375 :    
376 :     // if inter block, write field ME flag
377 :     if (pMB->mode == MODE_INTER || pMB->mode == MODE_INTER_Q)
378 :     {
379 :     BitstreamPutBit(bs, pMB->field_pred);
380 :     DEBUG1("codep: field_pred: ", pMB->field_pred);
381 :    
382 :     // write field prediction references
383 :     if (pMB->field_pred)
384 :     {
385 :     BitstreamPutBit(bs, pMB->field_for_top);
386 :     BitstreamPutBit(bs, pMB->field_for_bot);
387 :     }
388 :     }
389 :     }
390 :    
391 : Isibaar 3 // code motion vector(s)
392 :     for(i = 0; i < (pMB->mode == MODE_INTER4V ? 4 : 1); i++)
393 :     {
394 :     CodeVector(bs, pMB->pmvs[i].x, pParam->fixed_code, pStat);
395 :     CodeVector(bs, pMB->pmvs[i].y, pParam->fixed_code, pStat);
396 :     }
397 :    
398 :     bits = BitstreamPos(bs);
399 :    
400 :     // code block coeffs
401 :     for(i = 0; i < 6; i++)
402 :     if(pMB->cbp & (1 << (5 - i)))
403 : edgomez 78 CodeCoeff(bs, &qcoeff[i*64], inter_table, scan_tables[0], 0);
404 : Isibaar 3
405 :     bits = BitstreamPos(bs) - bits;
406 :     pStat->iTextBits += bits;
407 : edgomez 78
408 : Isibaar 3 }
409 :    
410 :    
411 : edgomez 78 void MBCoding(const MBParam * pParam,
412 :     MACROBLOCK *pMB,
413 :     int16_t qcoeff[6*64],
414 :     Bitstream * bs,
415 :     Statistics * pStat)
416 : Isibaar 3 {
417 : edgomez 78
418 : Isibaar 3 int intra = (pMB->mode == MODE_INTRA || pMB->mode == MODE_INTRA_Q);
419 :    
420 : edgomez 78 if(pParam->coding_type == P_VOP) {
421 : Isibaar 3 if(pMB->cbp == 0 && pMB->mode == MODE_INTER &&
422 : edgomez 78 pMB->mvs[0].x == 0 && pMB->mvs[0].y == 0)
423 : Isibaar 3 {
424 :     BitstreamPutBit(bs, 1); // not_coded
425 :     return;
426 :     }
427 :     else
428 :     BitstreamPutBit(bs, 0); // coded
429 :     }
430 :    
431 :     if(intra)
432 :     CodeBlockIntra(pParam, pMB, qcoeff, bs, pStat);
433 :     else
434 :     CodeBlockInter(pParam, pMB, qcoeff, bs, pStat);
435 : edgomez 78
436 : Isibaar 3 }
437 :    
438 :    
439 :     /***************************************************************
440 : edgomez 15 * decoding stuff starts here *
441 :     ***************************************************************/
442 : Isibaar 3
443 :     int get_mcbpc_intra(Bitstream * bs)
444 :     {
445 : edgomez 78
446 : Isibaar 3 uint32_t index;
447 :    
448 :     while((index = BitstreamShowBits(bs, 9)) == 1)
449 :     BitstreamSkip(bs, 9);
450 :    
451 :     index >>= 3;
452 :    
453 :     BitstreamSkip(bs, mcbpc_intra_table[index].len);
454 : edgomez 78
455 : Isibaar 3 return mcbpc_intra_table[index].code;
456 : edgomez 78
457 : Isibaar 3 }
458 :    
459 :     int get_mcbpc_inter(Bitstream * bs)
460 :     {
461 : edgomez 78
462 : Isibaar 3 uint32_t index;
463 :    
464 :     while((index = CLIP(BitstreamShowBits(bs, 9), 256)) == 1)
465 :     BitstreamSkip(bs, 9);
466 :    
467 : edgomez 78 BitstreamSkip(bs, mcbpc_inter_table[index].len);
468 :    
469 : Isibaar 3 return mcbpc_inter_table[index].code;
470 : edgomez 78
471 : Isibaar 3 }
472 :    
473 :     int get_cbpy(Bitstream * bs, int intra)
474 :     {
475 : edgomez 78
476 : Isibaar 3 int cbpy;
477 :     uint32_t index = BitstreamShowBits(bs, 6);
478 :    
479 :     BitstreamSkip(bs, cbpy_table[index].len);
480 :     cbpy = cbpy_table[index].code;
481 :    
482 :     if(!intra)
483 :     cbpy = 15 - cbpy;
484 :    
485 :     return cbpy;
486 : edgomez 78
487 : Isibaar 3 }
488 :    
489 :     int get_mv_data(Bitstream * bs)
490 :     {
491 : edgomez 78
492 : Isibaar 3 uint32_t index;
493 :    
494 :     if(BitstreamGetBit(bs))
495 :     return 0;
496 :    
497 :     index = BitstreamShowBits(bs, 12);
498 :    
499 :     if(index >= 512)
500 :     {
501 :     index = (index >> 8) - 2;
502 :     BitstreamSkip(bs, TMNMVtab0[index].len);
503 :     return TMNMVtab0[index].code;
504 :     }
505 :    
506 :     if(index >= 128)
507 :     {
508 :     index = (index >> 2) - 32;
509 :     BitstreamSkip(bs, TMNMVtab1[index].len);
510 :     return TMNMVtab1[index].code;
511 :     }
512 :    
513 :     index -= 4;
514 :    
515 :     BitstreamSkip(bs, TMNMVtab2[index].len);
516 :     return TMNMVtab2[index].code;
517 : edgomez 78
518 : Isibaar 3 }
519 :    
520 :     int get_mv(Bitstream * bs, int fcode)
521 :     {
522 : edgomez 78
523 : Isibaar 3 int data;
524 :     int res;
525 :     int mv;
526 :     int scale_fac = 1 << (fcode - 1);
527 :    
528 :     data = get_mv_data(bs);
529 :    
530 :     if(scale_fac == 1 || data == 0)
531 :     return data;
532 :    
533 :     res = BitstreamGetBits(bs, fcode - 1);
534 :     mv = ((ABS(data) - 1) * scale_fac) + res + 1;
535 :    
536 :     return data < 0 ? -mv : mv;
537 : edgomez 78
538 : Isibaar 3 }
539 :    
540 :     int get_dc_dif(Bitstream * bs, uint32_t dc_size)
541 :     {
542 : edgomez 78
543 : Isibaar 3 int code = BitstreamGetBits(bs, dc_size);
544 :     int msb = code >> (dc_size - 1);
545 :    
546 :     if(msb == 0)
547 :     return (-1 * (code^((1 << dc_size) - 1)));
548 :    
549 :     return code;
550 : edgomez 78
551 : Isibaar 3 }
552 :    
553 :     int get_dc_size_lum(Bitstream * bs)
554 :     {
555 : edgomez 78
556 : Isibaar 3 int code, i;
557 :     code = BitstreamShowBits(bs, 11);
558 :    
559 :     for(i = 11; i > 3; i--) {
560 :     if(code == 1) {
561 :     BitstreamSkip(bs, i);
562 :     return i + 1;
563 :     }
564 :     code >>= 1;
565 :     }
566 :    
567 :     BitstreamSkip(bs, dc_lum_tab[code].len);
568 :     return dc_lum_tab[code].code;
569 : edgomez 78
570 : Isibaar 3 }
571 :    
572 :    
573 :     int get_dc_size_chrom(Bitstream * bs)
574 :     {
575 : edgomez 78
576 : Isibaar 3 uint32_t code, i;
577 :     code = BitstreamShowBits(bs, 12);
578 :    
579 :     for(i = 12; i > 2; i--) {
580 :     if(code == 1) {
581 :     BitstreamSkip(bs, i);
582 :     return i;
583 :     }
584 :     code >>= 1;
585 :     }
586 :    
587 :     return 3 - BitstreamGetBits(bs, 2);
588 : edgomez 78
589 : Isibaar 3 }
590 :    
591 :     int get_coeff(Bitstream * bs, int *run, int *last, int intra, int short_video_header)
592 :     {
593 : edgomez 78
594 :     uint32_t mode;
595 :     const VLC *tab;
596 : Isibaar 3 int32_t level;
597 :    
598 :     if(short_video_header) // inter-VLCs will be used for both intra and inter blocks
599 :     intra = 0;
600 :    
601 :     tab = &DCT3D[intra][BitstreamShowBits(bs, 12)];
602 :    
603 :     if(tab->code == -1)
604 :     goto error;
605 :    
606 :     BitstreamSkip(bs, tab->len);
607 :    
608 :     if(tab->code != ESCAPE) {
609 :     if(!intra)
610 :     {
611 :     *run = (tab->code >> 4) & 255;
612 :     level = tab->code & 15;
613 :     *last = (tab->code >> 12) & 1;
614 :     }
615 : edgomez 78 else
616 : Isibaar 3 {
617 :     *run = (tab->code >> 8) & 255;
618 :     level = tab->code & 255;
619 :     *last = (tab->code >> 16) & 1;
620 :     }
621 :     return BitstreamGetBit(bs) ? -level : level;
622 :     }
623 :    
624 :     if(short_video_header)
625 :     {
626 :     // escape mode 4 - H.263 type, only used if short_video_header = 1
627 :     *last = BitstreamGetBit(bs);
628 :     *run = BitstreamGetBits(bs, 6);
629 :     level = BitstreamGetBits(bs, 8);
630 :    
631 :     if (level == 0 || level == 128)
632 :     DEBUG1("Illegal LEVEL for ESCAPE mode 4:", level);
633 :    
634 :     return (level >= 128 ? -(256 - level) : level);
635 :     }
636 :    
637 :     mode = BitstreamShowBits(bs, 2);
638 :    
639 :     if(mode < 3) {
640 :     BitstreamSkip(bs, (mode == 2) ? 2 : 1);
641 :    
642 :     tab = &DCT3D[intra][BitstreamShowBits(bs, 12)];
643 :     if (tab->code == -1)
644 :     goto error;
645 :    
646 :     BitstreamSkip(bs, tab->len);
647 :    
648 :     if (!intra) {
649 :     *run = (tab->code >> 4) & 255;
650 :     level = tab->code & 15;
651 :     *last = (tab->code >> 12) & 1;
652 :     }
653 :     else
654 :     {
655 :     *run = (tab->code >> 8) & 255;
656 :     level = tab->code & 255;
657 :     *last = (tab->code >> 16) & 1;
658 :     }
659 :    
660 :     if(mode < 2) // first escape mode, level is offset
661 :     level += max_level[*last + (!intra<<1)][*run]; // need to add back the max level
662 :     else if(mode == 2) // second escape mode, run is offset
663 :     *run += max_run[*last + (!intra<<1)][level] + 1;
664 :    
665 :     return BitstreamGetBit(bs) ? -level : level;
666 :     }
667 :    
668 :     // third escape mode - fixed length codes
669 :     BitstreamSkip(bs, 2);
670 :     *last = BitstreamGetBits(bs, 1);
671 :     *run = BitstreamGetBits(bs, 6);
672 :     BitstreamSkip(bs, 1); // marker
673 :     level = BitstreamGetBits(bs, 12);
674 :     BitstreamSkip(bs, 1); // marker
675 :    
676 :     return (level & 0x800) ? (level | (-1 ^ 0xfff)) : level;
677 :    
678 : edgomez 78 error:
679 : Isibaar 3 *run = VLC_ERROR;
680 :     return 0;
681 : edgomez 78
682 : Isibaar 3 }
683 :    
684 :    
685 :     void get_intra_block(Bitstream * bs, int16_t * block, int direction, int coeff)
686 :     {
687 : edgomez 78
688 : Isibaar 3 const uint16_t * scan = scan_tables[ direction ];
689 :     int level;
690 :     int run;
691 :     int last;
692 :    
693 :     do
694 :     {
695 :     level = get_coeff(bs, &run, &last, 1, 0);
696 :     if (run == -1)
697 :     {
698 :     DEBUG("fatal: invalid run");
699 :     break;
700 :     }
701 :     coeff += run;
702 :     block[ scan[coeff] ] = level;
703 :     if (level < -127 || level > 127)
704 :     {
705 :     DEBUG1("warning: intra_overflow", level);
706 :     }
707 :     coeff++;
708 :     } while (!last);
709 : edgomez 78
710 : Isibaar 3 }
711 :    
712 :     void get_inter_block(Bitstream * bs, int16_t * block)
713 :     {
714 : edgomez 78
715 : Isibaar 3 const uint16_t * scan = scan_tables[0];
716 :     int p;
717 :     int level;
718 :     int run;
719 :     int last;
720 :    
721 :     p = 0;
722 :     do
723 :     {
724 :     level = get_coeff(bs, &run, &last, 0, 0);
725 :     if (run == -1)
726 :     {
727 :     DEBUG("fatal: invalid run");
728 :     break;
729 :     }
730 :     p += run;
731 :     block[ scan[p] ] = level;
732 :     if (level < -127 || level > 127)
733 :     {
734 :     DEBUG1("warning: inter_overflow", level);
735 :     }
736 :     p++;
737 :     } while (!last);
738 : edgomez 78
739 : Isibaar 3 }

No admin address has been configured
ViewVC Help
Powered by ViewVC 1.0.4