[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 195 - (view) (download)
Original Path: trunk/xvidcore/src/bitstream/mbcoding.c

1 : suxen_drol 118 /******************************************************************************
2 :     * *
3 :     * This file is part of XviD, a free MPEG-4 video encoder/decoder *
4 :     * *
5 :     * XviD is an implementation of a part of one or more MPEG-4 Video tools *
6 :     * as specified in ISO/IEC 14496-2 standard. Those intending to use this *
7 :     * software module in hardware or software products are advised that its *
8 :     * use may infringe existing patents or copyrights, and any such use *
9 :     * would be at such party's own risk. The original developer of this *
10 :     * software module and his/her company, and subsequent editors and their *
11 :     * companies, will have no liability for use of this software or *
12 :     * modifications or derivatives thereof. *
13 :     * *
14 :     * XviD is free software; you can redistribute it and/or modify it *
15 :     * under the terms of the GNU General Public License as published by *
16 :     * the Free Software Foundation; either version 2 of the License, or *
17 :     * (at your option) any later version. *
18 :     * *
19 :     * XviD is distributed in the hope that it will be useful, but *
20 :     * WITHOUT ANY WARRANTY; without even the implied warranty of *
21 :     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
22 :     * GNU General Public License for more details. *
23 :     * *
24 :     * You should have received a copy of the GNU General Public License *
25 :     * along with this program; if not, write to the Free Software *
26 :     * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA *
27 :     * *
28 :     ******************************************************************************/
29 :    
30 :     /******************************************************************************
31 :     * *
32 : Isibaar 153 * mbcoding.c *
33 : suxen_drol 118 * *
34 : Isibaar 153 * Copyright (C) 2002 - Michael Militzer <isibaar@xvid.org> *
35 : suxen_drol 118 * *
36 :     * For more information visit the XviD homepage: http://www.xvid.org *
37 :     * *
38 :     ******************************************************************************/
39 :    
40 :     /******************************************************************************
41 :     * *
42 :     * Revision history: *
43 :     * *
44 : Isibaar 153 * 14.04.2002 bframe encoding *
45 : suxen_drol 118 * 08.03.2002 initial version; isibaar *
46 :     * *
47 :     ******************************************************************************/
48 :    
49 :    
50 :    
51 : Isibaar 100 #include <stdlib.h>
52 : Isibaar 3 #include "../portab.h"
53 :     #include "bitstream.h"
54 :     #include "zigzag.h"
55 :     #include "vlc_codes.h"
56 : Isibaar 100 #include "mbcoding.h"
57 : Isibaar 3
58 :     #include "../utils/mbfunctions.h"
59 :    
60 :     #define ABS(X) (((X)>0)?(X):-(X))
61 :     #define CLIP(X,A) (X > A) ? (A) : (X)
62 :    
63 : edgomez 195 VLC intra_table[524032];
64 : Isibaar 153 VLC inter_table[524032];
65 : Isibaar 100
66 : Isibaar 114 VLC DCT3Dintra[4096];
67 :     VLC DCT3Dinter[4096];
68 : Isibaar 3
69 : edgomez 195 void
70 :     init_vlc_tables(void)
71 : Isibaar 3 {
72 : edgomez 78
73 : Isibaar 3 int32_t k, l, i, intra, last;
74 :     VLC *vlc[2];
75 :     VLC **coeff_ptr;
76 :     VLC *vlc1, *vlc2;
77 :    
78 :     vlc1 = DCT3Dintra;
79 :     vlc2 = DCT3Dinter;
80 : edgomez 195
81 : Isibaar 100 vlc[0] = intra_table;
82 :     vlc[1] = inter_table;
83 : edgomez 195
84 : Isibaar 100 // generate encoding vlc lookup tables
85 : Isibaar 153 // the lookup table idea is taken from the excellent fame project by Vivien Chapellier
86 : edgomez 195 for (i = 0; i < 4; i++) {
87 : Isibaar 3 intra = i % 2;
88 : Isibaar 100 last = i / 2;
89 : Isibaar 3
90 : Isibaar 100 coeff_ptr = coeff_vlc[last + 2 * intra];
91 : edgomez 195
92 :     for (k = -2047; k < 2048; k++) { // level
93 : Isibaar 100 int8_t *max_level_ptr = max_level[last + 2 * intra];
94 :     int8_t *max_run_ptr = max_run[last + 2 * intra];
95 : edgomez 195
96 :     for (l = 0; l < 64; l++) { // run
97 : Isibaar 35 int32_t level = k;
98 :     uint32_t run = l;
99 : edgomez 195
100 :     if ((abs(level) <= max_level_ptr[run]) && (run <= (uint32_t) max_run_ptr[abs(level)])) { // level < max_level and run < max_run
101 :    
102 :     vlc[intra]->code = 0;
103 :     vlc[intra]->len = 0;
104 :     goto loop_end;
105 :     } else {
106 :     if (level > 0) // correct level
107 : Isibaar 3 level -= max_level_ptr[run];
108 :     else
109 :     level += max_level_ptr[run];
110 : Isibaar 35
111 : edgomez 195 if ((abs(level) <= max_level_ptr[run]) &&
112 :     (run <= (uint32_t) max_run_ptr[abs(level)])) {
113 :    
114 : Isibaar 100 vlc[intra]->code = 0x06;
115 :     vlc[intra]->len = 8;
116 :     goto loop_end;
117 :     }
118 : Isibaar 3
119 : edgomez 195 if (level > 0) // still here?
120 :     level += max_level_ptr[run]; // restore level
121 : Isibaar 100 else
122 :     level -= max_level_ptr[run];
123 :    
124 : edgomez 195 run -= max_run_ptr[abs(level)] + 1; // and change run
125 : Isibaar 100
126 : edgomez 195 if ((abs(level) <= max_level_ptr[run]) &&
127 :     (run <= (uint32_t) max_run_ptr[abs(level)])) {
128 :    
129 : Isibaar 100 vlc[intra]->code = 0x0e;
130 :     vlc[intra]->len = 9;
131 :     goto loop_end;
132 : Isibaar 3 }
133 : Isibaar 100 run += max_run_ptr[abs(level)] + 1;
134 : Isibaar 3 }
135 : Isibaar 100
136 : edgomez 195 vlc[intra]->code =
137 :     (uint32_t) ((l << 14) | (0x1e + last) << 20) | (1 << 13) |
138 :     ((k & 0xfff) << 1) | 1;
139 : Isibaar 100
140 :     vlc[intra]->len = 30;
141 : Isibaar 3 vlc[intra]++;
142 : Isibaar 100 continue;
143 :    
144 : edgomez 195 loop_end:
145 :     if (level != 0) {
146 :     vlc[intra]->code =
147 :     (vlc[intra]->
148 :     code << (coeff_ptr[run][abs(level) - 1].len +
149 :     1)) | (coeff_ptr[run][abs(level) -
150 :     1].code << 1);
151 :     vlc[intra]->len =
152 :     (coeff_ptr[run][abs(level) - 1].len + 1) +
153 :     vlc[intra]->len;
154 : Isibaar 100
155 : edgomez 195 if (level < 0)
156 : Isibaar 100 vlc[intra]->code += 1;
157 :     }
158 :    
159 :     vlc[intra]++;
160 : Isibaar 3 }
161 :     }
162 :     }
163 : edgomez 78
164 : edgomez 195 for (i = 0; i < 4096; i++) {
165 :     if (i >= 512) {
166 : Isibaar 3 *vlc1 = DCT3Dtab3[(i >> 5) - 16];
167 :     *vlc2 = DCT3Dtab0[(i >> 5) - 16];
168 : edgomez 195 } else if (i >= 128) {
169 : Isibaar 3 *vlc1 = DCT3Dtab4[(i >> 2) - 32];
170 :     *vlc2 = DCT3Dtab1[(i >> 2) - 32];
171 : edgomez 195 } else if (i >= 8) {
172 : Isibaar 3 *vlc1 = DCT3Dtab5[i - 8];
173 :     *vlc2 = DCT3Dtab2[i - 8];
174 : edgomez 195 } else {
175 : Isibaar 3 *vlc1 = ERRtab[i];
176 :     *vlc2 = ERRtab[i];
177 :     }
178 :    
179 :     vlc1++;
180 :     vlc2++;
181 :     }
182 :     DCT3D[0] = DCT3Dinter;
183 :     DCT3D[1] = DCT3Dintra;
184 :    
185 :     }
186 :    
187 : edgomez 195 static __inline void
188 :     CodeVector(Bitstream * bs,
189 :     int32_t value,
190 :     int32_t f_code,
191 :     Statistics * pStat)
192 : Isibaar 3 {
193 : edgomez 78
194 : Isibaar 3 const int scale_factor = 1 << (f_code - 1);
195 :     const int cmp = scale_factor << 5;
196 :    
197 : edgomez 195 if (value < (-1 * cmp))
198 : Isibaar 3 value += 64 * scale_factor;
199 : edgomez 195
200 :     if (value > (cmp - 1))
201 : Isibaar 3 value -= 64 * scale_factor;
202 :    
203 : edgomez 78 pStat->iMvSum += value * value;
204 :     pStat->iMvCount++;
205 : Isibaar 3
206 : edgomez 78 if (value == 0) {
207 : edgomez 195 BitstreamPutBits(bs, mb_motion_table[32].code,
208 :     mb_motion_table[32].len);
209 : edgomez 78 } else {
210 : Isibaar 3 uint16_t length, code, mv_res, sign;
211 : edgomez 195
212 : Isibaar 3 length = 16 << f_code;
213 :     f_code--;
214 : edgomez 195
215 : Isibaar 3 sign = (value < 0);
216 :    
217 : edgomez 195 if (value >= length)
218 : Isibaar 3 value -= 2 * length;
219 : edgomez 195 else if (value < -length)
220 : Isibaar 3 value += 2 * length;
221 :    
222 : edgomez 195 if (sign)
223 : Isibaar 3 value = -value;
224 :    
225 :     value--;
226 :     mv_res = value & ((1 << f_code) - 1);
227 :     code = ((value - mv_res) >> f_code) + 1;
228 :    
229 : edgomez 195 if (sign)
230 : Isibaar 3 code = -code;
231 :    
232 :     code += 32;
233 : edgomez 195 BitstreamPutBits(bs, mb_motion_table[code].code,
234 :     mb_motion_table[code].len);
235 :    
236 :     if (f_code)
237 : Isibaar 3 BitstreamPutBits(bs, mv_res, f_code);
238 : edgomez 78 }
239 :    
240 : Isibaar 3 }
241 :    
242 :    
243 : edgomez 195 static __inline void
244 :     CodeCoeff(Bitstream * bs,
245 :     const int16_t qcoeff[64],
246 :     VLC * table,
247 :     const uint16_t * zigzag,
248 :     uint16_t intra)
249 : edgomez 78 {
250 :    
251 : Isibaar 3 uint32_t j, last;
252 :     short v;
253 :     VLC *vlc;
254 : edgomez 195
255 : Isibaar 3 j = intra;
256 : Isibaar 116 last = intra;
257 : Isibaar 3
258 : edgomez 195 while (j < 64 && (v = qcoeff[zigzag[j]]) == 0)
259 :     j++;
260 :    
261 : Isibaar 3 do {
262 : Isibaar 153 vlc = table + 64 * 2047 + (v << 6) + j - last;
263 : Isibaar 116 last = ++j;
264 : Isibaar 153
265 :     // count zeroes
266 : edgomez 195 while (j < 64 && (v = qcoeff[zigzag[j]]) == 0)
267 :     j++;
268 :    
269 : Isibaar 3 // write code
270 : edgomez 195 if (j != 64) {
271 : Isibaar 3 BitstreamPutBits(bs, vlc->code, vlc->len);
272 :     } else {
273 : Isibaar 153 vlc += 64 * 4095;
274 : Isibaar 3 BitstreamPutBits(bs, vlc->code, vlc->len);
275 :     break;
276 :     }
277 : edgomez 195 } while (1);
278 : edgomez 78
279 : Isibaar 3 }
280 :    
281 :    
282 : edgomez 195 static void
283 :     CodeBlockIntra(const FRAMEINFO * frame,
284 :     const MACROBLOCK * pMB,
285 :     int16_t qcoeff[6 * 64],
286 : edgomez 78 Bitstream * bs,
287 :     Statistics * pStat)
288 : Isibaar 3 {
289 : edgomez 78
290 : Isibaar 3 uint32_t i, mcbpc, cbpy, bits;
291 :    
292 :     cbpy = pMB->cbp >> 2;
293 :    
294 : edgomez 78 // write mcbpc
295 : edgomez 195 if (frame->coding_type == I_VOP) {
296 : edgomez 78 mcbpc = ((pMB->mode >> 1) & 3) | ((pMB->cbp & 3) << 2);
297 : edgomez 195 BitstreamPutBits(bs, mcbpc_intra_tab[mcbpc].code,
298 :     mcbpc_intra_tab[mcbpc].len);
299 :     } else {
300 : edgomez 78 mcbpc = (pMB->mode & 7) | ((pMB->cbp & 3) << 3);
301 : edgomez 195 BitstreamPutBits(bs, mcbpc_inter_tab[mcbpc].code,
302 :     mcbpc_inter_tab[mcbpc].len);
303 : Isibaar 28 }
304 : Isibaar 3
305 :     // ac prediction flag
306 : edgomez 195 if (pMB->acpred_directions[0])
307 : edgomez 78 BitstreamPutBits(bs, 1, 1);
308 : Isibaar 3 else
309 : edgomez 78 BitstreamPutBits(bs, 0, 1);
310 : Isibaar 3
311 : edgomez 78 // write cbpy
312 : edgomez 195 BitstreamPutBits(bs, cbpy_tab[cbpy].code, cbpy_tab[cbpy].len);
313 : Isibaar 3
314 :     // write dquant
315 : edgomez 195 if (pMB->mode == MODE_INTRA_Q)
316 : Isibaar 3 BitstreamPutBits(bs, pMB->dquant, 2);
317 :    
318 : h 69 // write interlacing
319 : edgomez 195 if (frame->global_flags & XVID_INTERLACING) {
320 : h 69 BitstreamPutBit(bs, pMB->field_dct);
321 :     }
322 : Isibaar 3 // code block coeffs
323 : edgomez 195 for (i = 0; i < 6; i++) {
324 :     if (i < 4)
325 :     BitstreamPutBits(bs, dcy_tab[qcoeff[i * 64 + 0] + 255].code,
326 :     dcy_tab[qcoeff[i * 64 + 0] + 255].len);
327 : Isibaar 3 else
328 : edgomez 195 BitstreamPutBits(bs, dcc_tab[qcoeff[i * 64 + 0] + 255].code,
329 :     dcc_tab[qcoeff[i * 64 + 0] + 255].len);
330 :    
331 :     if (pMB->cbp & (1 << (5 - i))) {
332 : Isibaar 3 bits = BitstreamPos(bs);
333 :    
334 : edgomez 195 CodeCoeff(bs, &qcoeff[i * 64], intra_table,
335 :     scan_tables[pMB->acpred_directions[i]], 1);
336 : Isibaar 3
337 :     bits = BitstreamPos(bs) - bits;
338 :     pStat->iTextBits += bits;
339 :     }
340 :     }
341 : edgomez 78
342 : Isibaar 3 }
343 :    
344 :    
345 : edgomez 195 static void
346 :     CodeBlockInter(const FRAMEINFO * frame,
347 :     const MACROBLOCK * pMB,
348 :     int16_t qcoeff[6 * 64],
349 : edgomez 78 Bitstream * bs,
350 :     Statistics * pStat)
351 : Isibaar 3 {
352 : edgomez 78
353 : Isibaar 3 int32_t i;
354 :     uint32_t bits, mcbpc, cbpy;
355 :    
356 : edgomez 78 mcbpc = (pMB->mode & 7) | ((pMB->cbp & 3) << 3);
357 : Isibaar 3 cbpy = 15 - (pMB->cbp >> 2);
358 :    
359 :     // write mcbpc
360 : edgomez 195 BitstreamPutBits(bs, mcbpc_inter_tab[mcbpc].code,
361 :     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 195 if (pMB->mode == MODE_INTER_Q)
368 : Isibaar 3 BitstreamPutBits(bs, pMB->dquant, 2);
369 : edgomez 195
370 : h 69 // interlacing
371 : edgomez 195 if (frame->global_flags & XVID_INTERLACING) {
372 : h 69 BitstreamPutBit(bs, pMB->field_dct);
373 :     DEBUG1("codep: field_dct: ", pMB->field_dct);
374 :    
375 :     // if inter block, write field ME flag
376 : edgomez 195 if (pMB->mode == MODE_INTER || pMB->mode == MODE_INTER_Q) {
377 : h 69 BitstreamPutBit(bs, pMB->field_pred);
378 :     DEBUG1("codep: field_pred: ", pMB->field_pred);
379 :    
380 :     // write field prediction references
381 : edgomez 195 if (pMB->field_pred) {
382 : h 69 BitstreamPutBit(bs, pMB->field_for_top);
383 :     BitstreamPutBit(bs, pMB->field_for_bot);
384 :     }
385 :     }
386 :     }
387 : Isibaar 3 // code motion vector(s)
388 : edgomez 195 for (i = 0; i < (pMB->mode == MODE_INTER4V ? 4 : 1); i++) {
389 : suxen_drol 136 CodeVector(bs, pMB->pmvs[i].x, frame->fcode, pStat);
390 :     CodeVector(bs, pMB->pmvs[i].y, frame->fcode, pStat);
391 : Isibaar 3 }
392 :    
393 :     bits = BitstreamPos(bs);
394 : edgomez 195
395 : Isibaar 3 // code block coeffs
396 : edgomez 195 for (i = 0; i < 6; i++)
397 :     if (pMB->cbp & (1 << (5 - i)))
398 :     CodeCoeff(bs, &qcoeff[i * 64], inter_table, scan_tables[0], 0);
399 : Isibaar 3
400 :     bits = BitstreamPos(bs) - bits;
401 :     pStat->iTextBits += bits;
402 : edgomez 78
403 : Isibaar 3 }
404 :    
405 :    
406 : edgomez 195 void
407 :     MBCoding(const FRAMEINFO * frame,
408 :     MACROBLOCK * pMB,
409 :     int16_t qcoeff[6 * 64],
410 :     Bitstream * bs,
411 :     Statistics * pStat)
412 : Isibaar 3 {
413 : edgomez 78
414 : Isibaar 3 int intra = (pMB->mode == MODE_INTRA || pMB->mode == MODE_INTRA_Q);
415 :    
416 : edgomez 195 if (frame->coding_type == P_VOP) {
417 :     if (pMB->cbp == 0 && pMB->mode == MODE_INTER && pMB->mvs[0].x == 0 &&
418 :     pMB->mvs[0].y == 0) {
419 :     BitstreamPutBit(bs, 1); // not_coded
420 : Isibaar 3 return;
421 : edgomez 195 } else
422 :     BitstreamPutBit(bs, 0); // coded
423 : Isibaar 3 }
424 :    
425 : edgomez 195 if (intra)
426 : suxen_drol 136 CodeBlockIntra(frame, pMB, qcoeff, bs, pStat);
427 : Isibaar 3 else
428 : suxen_drol 136 CodeBlockInter(frame, pMB, qcoeff, bs, pStat);
429 : edgomez 78
430 : Isibaar 3 }
431 :    
432 : suxen_drol 118 /***************************************************************
433 :     * bframe encoding start
434 :     ***************************************************************/
435 : Isibaar 3
436 : suxen_drol 118 /*
437 :     mbtype
438 :     0 1b direct(h263) mvdb
439 :     1 01b interpolate mc+q dbquant, mvdf, mvdb
440 :     2 001b backward mc+q dbquant, mvdb
441 :     3 0001b forward mc+q dbquant, mvdf
442 :     */
443 :    
444 : edgomez 195 void
445 :     put_bvop_mbtype(Bitstream * bs,
446 :     int value)
447 : suxen_drol 118 {
448 : edgomez 195 switch (value) {
449 :     case 0:
450 :     BitstreamPutBit(bs, 1);
451 :     return;
452 : suxen_drol 118
453 : edgomez 195 case 1:
454 :     BitstreamPutBit(bs, 0);
455 :     BitstreamPutBit(bs, 1);
456 :     return;
457 : suxen_drol 118
458 : edgomez 195 case 2:
459 :     BitstreamPutBit(bs, 0);
460 :     BitstreamPutBit(bs, 0);
461 :     BitstreamPutBit(bs, 1);
462 :     return;
463 : suxen_drol 118
464 : edgomez 195 case 3:
465 :     BitstreamPutBit(bs, 0);
466 :     BitstreamPutBit(bs, 0);
467 :     BitstreamPutBit(bs, 0);
468 :     BitstreamPutBit(bs, 1);
469 :     return;
470 :    
471 :     default:; // invalid!
472 :    
473 : suxen_drol 118 }
474 : edgomez 195
475 : suxen_drol 118 }
476 :    
477 :     /*
478 :     dbquant
479 :     -2 10b
480 :     0 0b
481 :     +2 11b
482 :     */
483 :    
484 : edgomez 195 void
485 :     put_bvop_dbquant(Bitstream * bs,
486 :     int value)
487 : suxen_drol 118 {
488 : edgomez 195 switch (value) {
489 :     case 0:
490 :     BitstreamPutBit(bs, 0);
491 :     return;
492 : suxen_drol 118
493 : edgomez 195 case -2:
494 :     BitstreamPutBit(bs, 1);
495 :     BitstreamPutBit(bs, 0);
496 :     return;
497 : suxen_drol 118
498 : edgomez 195 case 2:
499 :     BitstreamPutBit(bs, 1);
500 :     BitstreamPutBit(bs, 1);
501 :     return;
502 :    
503 :     default:; // invalid
504 : suxen_drol 118 }
505 :     }
506 :    
507 :    
508 :    
509 : edgomez 195 void
510 :     MBCodingBVOP(const MACROBLOCK * mb,
511 :     const int16_t qcoeff[6 * 64],
512 :     const int32_t fcode,
513 :     const int32_t bcode,
514 :     Bitstream * bs,
515 :     Statistics * pStat)
516 : suxen_drol 118 {
517 :     int i;
518 :    
519 :     /* ------------------------------------------------------------------
520 :     when a block is skipped it is decoded DIRECT(0,)
521 :     hence are interpolated from forward & backward frames
522 :     ------------------------------------------------------------------ */
523 :    
524 : edgomez 195 if (mb->mode == 5) {
525 :     BitstreamPutBit(bs, 1); // skipped
526 : suxen_drol 118 return;
527 :     }
528 :    
529 :     BitstreamPutBit(bs, 0); // not skipped
530 :    
531 : edgomez 195 if (mb->cbp == 0) {
532 :     BitstreamPutBit(bs, 1); // cbp == 0
533 :     } else {
534 :     BitstreamPutBit(bs, 0); // cbp == xxx
535 : suxen_drol 118 }
536 :    
537 :     put_bvop_mbtype(bs, mb->mode);
538 :    
539 : edgomez 195 if (mb->cbp) {
540 : suxen_drol 118 BitstreamPutBits(bs, mb->cbp, 6);
541 :     }
542 :    
543 : edgomez 195 if (mb->mode != MODE_DIRECT && mb->cbp != 0) {
544 :     put_bvop_dbquant(bs, 0); // todo: mb->dquant = 0
545 : suxen_drol 118 }
546 :    
547 : edgomez 195 if (mb->mode == MODE_INTERPOLATE || mb->mode == MODE_FORWARD) {
548 :     CodeVector(bs, mb->pmvs[0].x, fcode, pStat);
549 :     CodeVector(bs, mb->pmvs[0].y, fcode, pStat);
550 : suxen_drol 118 }
551 :    
552 : edgomez 195 if (mb->mode == MODE_INTERPOLATE || mb->mode == MODE_BACKWARD) {
553 :     CodeVector(bs, mb->b_pmvs[0].x, bcode, pStat);
554 :     CodeVector(bs, mb->b_pmvs[0].y, bcode, pStat);
555 : suxen_drol 118 }
556 :    
557 : edgomez 195 if (mb->mode == MODE_DIRECT) {
558 : suxen_drol 118 // TODO: direct
559 :     }
560 : edgomez 195
561 :     for (i = 0; i < 6; i++) {
562 :     if (mb->cbp & (1 << (5 - i))) {
563 :     CodeCoeff(bs, &qcoeff[i * 64], inter_table, scan_tables[0], 0);
564 : suxen_drol 118 }
565 : edgomez 195 }
566 : suxen_drol 118 }
567 :    
568 :    
569 :    
570 : Isibaar 3 /***************************************************************
571 : edgomez 15 * decoding stuff starts here *
572 :     ***************************************************************/
573 : Isibaar 3
574 : edgomez 195 int
575 :     get_mcbpc_intra(Bitstream * bs)
576 : Isibaar 3 {
577 : edgomez 78
578 : Isibaar 3 uint32_t index;
579 : edgomez 195
580 :     while ((index = BitstreamShowBits(bs, 9)) == 1)
581 : Isibaar 3 BitstreamSkip(bs, 9);
582 :    
583 :     index >>= 3;
584 :    
585 :     BitstreamSkip(bs, mcbpc_intra_table[index].len);
586 : edgomez 78
587 : Isibaar 3 return mcbpc_intra_table[index].code;
588 : edgomez 78
589 : Isibaar 3 }
590 :    
591 : edgomez 195 int
592 :     get_mcbpc_inter(Bitstream * bs)
593 : Isibaar 3 {
594 : edgomez 78
595 : Isibaar 3 uint32_t index;
596 : edgomez 195
597 :     while ((index = CLIP(BitstreamShowBits(bs, 9), 256)) == 1)
598 : Isibaar 3 BitstreamSkip(bs, 9);
599 :    
600 : edgomez 195 BitstreamSkip(bs, mcbpc_inter_table[index].len);
601 : edgomez 78
602 : Isibaar 3 return mcbpc_inter_table[index].code;
603 : edgomez 78
604 : Isibaar 3 }
605 :    
606 : edgomez 195 int
607 :     get_cbpy(Bitstream * bs,
608 :     int intra)
609 : Isibaar 3 {
610 : edgomez 78
611 : Isibaar 3 int cbpy;
612 :     uint32_t index = BitstreamShowBits(bs, 6);
613 :    
614 :     BitstreamSkip(bs, cbpy_table[index].len);
615 :     cbpy = cbpy_table[index].code;
616 :    
617 : edgomez 195 if (!intra)
618 : Isibaar 3 cbpy = 15 - cbpy;
619 :    
620 :     return cbpy;
621 : edgomez 78
622 : Isibaar 3 }
623 :    
624 : edgomez 195 int
625 :     get_mv_data(Bitstream * bs)
626 : Isibaar 3 {
627 : edgomez 78
628 : Isibaar 3 uint32_t index;
629 :    
630 : edgomez 195 if (BitstreamGetBit(bs))
631 : Isibaar 3 return 0;
632 : edgomez 195
633 : Isibaar 3 index = BitstreamShowBits(bs, 12);
634 :    
635 : edgomez 195 if (index >= 512) {
636 : Isibaar 3 index = (index >> 8) - 2;
637 :     BitstreamSkip(bs, TMNMVtab0[index].len);
638 :     return TMNMVtab0[index].code;
639 :     }
640 : edgomez 195
641 :     if (index >= 128) {
642 : Isibaar 3 index = (index >> 2) - 32;
643 :     BitstreamSkip(bs, TMNMVtab1[index].len);
644 :     return TMNMVtab1[index].code;
645 :     }
646 :    
647 : edgomez 195 index -= 4;
648 : Isibaar 3
649 :     BitstreamSkip(bs, TMNMVtab2[index].len);
650 :     return TMNMVtab2[index].code;
651 : edgomez 78
652 : Isibaar 3 }
653 :    
654 : edgomez 195 int
655 :     get_mv(Bitstream * bs,
656 :     int fcode)
657 : Isibaar 3 {
658 : edgomez 78
659 : Isibaar 3 int data;
660 :     int res;
661 :     int mv;
662 :     int scale_fac = 1 << (fcode - 1);
663 :    
664 :     data = get_mv_data(bs);
665 : edgomez 195
666 :     if (scale_fac == 1 || data == 0)
667 : Isibaar 3 return data;
668 :    
669 :     res = BitstreamGetBits(bs, fcode - 1);
670 :     mv = ((ABS(data) - 1) * scale_fac) + res + 1;
671 : edgomez 195
672 : Isibaar 3 return data < 0 ? -mv : mv;
673 : edgomez 78
674 : Isibaar 3 }
675 :    
676 : edgomez 195 int
677 :     get_dc_dif(Bitstream * bs,
678 :     uint32_t dc_size)
679 : Isibaar 3 {
680 : edgomez 78
681 : Isibaar 3 int code = BitstreamGetBits(bs, dc_size);
682 :     int msb = code >> (dc_size - 1);
683 :    
684 : edgomez 195 if (msb == 0)
685 :     return (-1 * (code ^ ((1 << dc_size) - 1)));
686 : Isibaar 3
687 :     return code;
688 : edgomez 78
689 : Isibaar 3 }
690 :    
691 : edgomez 195 int
692 :     get_dc_size_lum(Bitstream * bs)
693 : Isibaar 3 {
694 : edgomez 78
695 : Isibaar 3 int code, i;
696 : edgomez 195
697 : Isibaar 3 code = BitstreamShowBits(bs, 11);
698 :    
699 : edgomez 195 for (i = 11; i > 3; i--) {
700 :     if (code == 1) {
701 : Isibaar 3 BitstreamSkip(bs, i);
702 :     return i + 1;
703 :     }
704 :     code >>= 1;
705 :     }
706 :    
707 :     BitstreamSkip(bs, dc_lum_tab[code].len);
708 :     return dc_lum_tab[code].code;
709 : edgomez 78
710 : Isibaar 3 }
711 :    
712 :    
713 : edgomez 195 int
714 :     get_dc_size_chrom(Bitstream * bs)
715 : Isibaar 3 {
716 : edgomez 78
717 : Isibaar 3 uint32_t code, i;
718 : edgomez 195
719 : Isibaar 3 code = BitstreamShowBits(bs, 12);
720 :    
721 : edgomez 195 for (i = 12; i > 2; i--) {
722 :     if (code == 1) {
723 : Isibaar 3 BitstreamSkip(bs, i);
724 :     return i;
725 :     }
726 :     code >>= 1;
727 :     }
728 :    
729 :     return 3 - BitstreamGetBits(bs, 2);
730 : edgomez 78
731 : Isibaar 3 }
732 :    
733 : edgomez 195 void
734 :     get_intra_block(Bitstream * bs,
735 :     int16_t * block,
736 :     int direction,
737 :     int coeff)
738 : Isibaar 3 {
739 : edgomez 78
740 : edgomez 195 const uint16_t *scan = scan_tables[direction];
741 : Isibaar 3 int level;
742 :     int run;
743 :     int last;
744 :    
745 : edgomez 195 do {
746 : Isibaar 3 level = get_coeff(bs, &run, &last, 1, 0);
747 : edgomez 195 if (run == -1) {
748 : Isibaar 3 DEBUG("fatal: invalid run");
749 :     break;
750 :     }
751 :     coeff += run;
752 : edgomez 195 block[scan[coeff]] = level;
753 :     if (level < -127 || level > 127) {
754 : Isibaar 3 DEBUG1("warning: intra_overflow", level);
755 :     }
756 :     coeff++;
757 :     } while (!last);
758 : edgomez 78
759 : Isibaar 3 }
760 :    
761 : edgomez 195 void
762 :     get_inter_block(Bitstream * bs,
763 :     int16_t * block)
764 : Isibaar 3 {
765 : edgomez 78
766 : edgomez 195 const uint16_t *scan = scan_tables[0];
767 : Isibaar 3 int p;
768 :     int level;
769 :     int run;
770 :     int last;
771 :    
772 :     p = 0;
773 : edgomez 195 do {
774 : Isibaar 3 level = get_coeff(bs, &run, &last, 0, 0);
775 : edgomez 195 if (run == -1) {
776 : Isibaar 3 DEBUG("fatal: invalid run");
777 :     break;
778 :     }
779 :     p += run;
780 : chenm001 161
781 : edgomez 195 block[scan[p]] = level;
782 :     if (level < -127 || level > 127) {
783 : Isibaar 3 DEBUG1("warning: inter_overflow", level);
784 :     }
785 :     p++;
786 :     } while (!last);
787 : edgomez 78
788 : Isibaar 3 }

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