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

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

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