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

1 : edgomez 451 /*****************************************************************************
2 :     *
3 :     * XVID MPEG-4 VIDEO CODEC
4 : edgomez 453 * - Macro Block coding functions -
5 : edgomez 451 *
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 : suxen_drol 497 * $Id: mbcoding.c,v 1.31 2002-09-21 02:26:12 suxen_drol Exp $
33 : edgomez 451 *
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 : suxen_drol 497 /* msvc sp5+pp gets confused if they globals are made static */
53 :     VLC intra_table[524032];
54 :     VLC inter_table[524032];
55 : Isibaar 3
56 : edgomez 451 static VLC DCT3Dintra[4096];
57 :     static VLC DCT3Dinter[4096];
58 :    
59 :     /*****************************************************************************
60 : edgomez 453 * Vector Length Coding Initialization
61 : edgomez 451 ****************************************************************************/
62 :    
63 : edgomez 195 void
64 :     init_vlc_tables(void)
65 : Isibaar 3 {
66 : edgomez 78
67 : Isibaar 3 int32_t k, l, i, intra, last;
68 :     VLC *vlc[2];
69 : edgomez 465 VLC const **coeff_ptr;
70 : Isibaar 3 VLC *vlc1, *vlc2;
71 :    
72 :     vlc1 = DCT3Dintra;
73 :     vlc2 = DCT3Dinter;
74 : edgomez 195
75 : Isibaar 100 vlc[0] = intra_table;
76 :     vlc[1] = inter_table;
77 : edgomez 195
78 : edgomez 451 /*
79 :     * Generate encoding vlc lookup tables
80 :     * the lookup table idea is taken from the excellent fame project
81 :     * by Vivien Chapellier
82 :     */
83 : edgomez 195 for (i = 0; i < 4; i++) {
84 : Isibaar 3 intra = i % 2;
85 : Isibaar 100 last = i / 2;
86 : Isibaar 3
87 : Isibaar 100 coeff_ptr = coeff_vlc[last + 2 * intra];
88 : edgomez 195
89 :     for (k = -2047; k < 2048; k++) { // level
90 : edgomez 465 int8_t const *max_level_ptr = max_level[last + 2 * intra];
91 :     int8_t const *max_run_ptr = max_run[last + 2 * intra];
92 : edgomez 195
93 :     for (l = 0; l < 64; l++) { // run
94 : Isibaar 35 int32_t level = k;
95 : Isibaar 209 ptr_t run = l;
96 : edgomez 195
97 :     if ((abs(level) <= max_level_ptr[run]) && (run <= (uint32_t) max_run_ptr[abs(level)])) { // level < max_level and run < max_run
98 :    
99 :     vlc[intra]->code = 0;
100 :     vlc[intra]->len = 0;
101 :     goto loop_end;
102 :     } else {
103 :     if (level > 0) // correct level
104 : Isibaar 3 level -= max_level_ptr[run];
105 :     else
106 :     level += max_level_ptr[run];
107 : Isibaar 35
108 : edgomez 195 if ((abs(level) <= max_level_ptr[run]) &&
109 :     (run <= (uint32_t) max_run_ptr[abs(level)])) {
110 :    
111 : Isibaar 100 vlc[intra]->code = 0x06;
112 :     vlc[intra]->len = 8;
113 :     goto loop_end;
114 :     }
115 : Isibaar 3
116 : edgomez 195 if (level > 0) // still here?
117 :     level += max_level_ptr[run]; // restore level
118 : Isibaar 100 else
119 :     level -= max_level_ptr[run];
120 :    
121 : edgomez 195 run -= max_run_ptr[abs(level)] + 1; // and change run
122 : Isibaar 100
123 : edgomez 195 if ((abs(level) <= max_level_ptr[run]) &&
124 :     (run <= (uint32_t) max_run_ptr[abs(level)])) {
125 :    
126 : Isibaar 100 vlc[intra]->code = 0x0e;
127 :     vlc[intra]->len = 9;
128 :     goto loop_end;
129 : Isibaar 3 }
130 : Isibaar 100 run += max_run_ptr[abs(level)] + 1;
131 : Isibaar 3 }
132 : Isibaar 100
133 : edgomez 195 vlc[intra]->code =
134 :     (uint32_t) ((l << 14) | (0x1e + last) << 20) | (1 << 13) |
135 :     ((k & 0xfff) << 1) | 1;
136 : Isibaar 100
137 :     vlc[intra]->len = 30;
138 : Isibaar 3 vlc[intra]++;
139 : Isibaar 100 continue;
140 :    
141 : edgomez 195 loop_end:
142 :     if (level != 0) {
143 :     vlc[intra]->code =
144 :     (vlc[intra]->
145 :     code << (coeff_ptr[run][abs(level) - 1].len +
146 :     1)) | (coeff_ptr[run][abs(level) -
147 :     1].code << 1);
148 :     vlc[intra]->len =
149 :     (coeff_ptr[run][abs(level) - 1].len + 1) +
150 :     vlc[intra]->len;
151 : Isibaar 100
152 : edgomez 195 if (level < 0)
153 : Isibaar 100 vlc[intra]->code += 1;
154 :     }
155 :    
156 :     vlc[intra]++;
157 : Isibaar 3 }
158 :     }
159 :     }
160 : edgomez 78
161 : edgomez 195 for (i = 0; i < 4096; i++) {
162 :     if (i >= 512) {
163 : Isibaar 3 *vlc1 = DCT3Dtab3[(i >> 5) - 16];
164 :     *vlc2 = DCT3Dtab0[(i >> 5) - 16];
165 : edgomez 195 } else if (i >= 128) {
166 : Isibaar 3 *vlc1 = DCT3Dtab4[(i >> 2) - 32];
167 :     *vlc2 = DCT3Dtab1[(i >> 2) - 32];
168 : edgomez 195 } else if (i >= 8) {
169 : Isibaar 3 *vlc1 = DCT3Dtab5[i - 8];
170 :     *vlc2 = DCT3Dtab2[i - 8];
171 : edgomez 195 } else {
172 : Isibaar 3 *vlc1 = ERRtab[i];
173 :     *vlc2 = ERRtab[i];
174 :     }
175 :    
176 :     vlc1++;
177 :     vlc2++;
178 :     }
179 :     DCT3D[0] = DCT3Dinter;
180 :     DCT3D[1] = DCT3Dintra;
181 :    
182 :     }
183 :    
184 : edgomez 453 /*****************************************************************************
185 :     * Local inlined functions for MB coding
186 :     ****************************************************************************/
187 :    
188 : edgomez 195 static __inline void
189 :     CodeVector(Bitstream * bs,
190 :     int32_t value,
191 :     int32_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 : edgomez 195 if (value < (-1 * cmp))
199 : Isibaar 3 value += 64 * scale_factor;
200 : edgomez 195
201 :     if (value > (cmp - 1))
202 : Isibaar 3 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 : edgomez 195 BitstreamPutBits(bs, mb_motion_table[32].code,
209 :     mb_motion_table[32].len);
210 : edgomez 78 } else {
211 : Isibaar 3 uint16_t length, code, mv_res, sign;
212 : edgomez 195
213 : Isibaar 3 length = 16 << f_code;
214 :     f_code--;
215 : edgomez 195
216 : Isibaar 3 sign = (value < 0);
217 :    
218 : edgomez 195 if (value >= length)
219 : Isibaar 3 value -= 2 * length;
220 : edgomez 195 else if (value < -length)
221 : Isibaar 3 value += 2 * length;
222 :    
223 : edgomez 195 if (sign)
224 : Isibaar 3 value = -value;
225 :    
226 :     value--;
227 :     mv_res = value & ((1 << f_code) - 1);
228 :     code = ((value - mv_res) >> f_code) + 1;
229 :    
230 : edgomez 195 if (sign)
231 : Isibaar 3 code = -code;
232 :    
233 :     code += 32;
234 : edgomez 195 BitstreamPutBits(bs, mb_motion_table[code].code,
235 :     mb_motion_table[code].len);
236 :    
237 :     if (f_code)
238 : Isibaar 3 BitstreamPutBits(bs, mv_res, f_code);
239 : edgomez 78 }
240 :    
241 : Isibaar 3 }
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 : edgomez 453 /*****************************************************************************
282 :     * Local functions
283 :     ****************************************************************************/
284 : Isibaar 3
285 : edgomez 195 static void
286 :     CodeBlockIntra(const FRAMEINFO * frame,
287 :     const MACROBLOCK * pMB,
288 :     int16_t qcoeff[6 * 64],
289 : edgomez 78 Bitstream * bs,
290 :     Statistics * pStat)
291 : Isibaar 3 {
292 : edgomez 78
293 : Isibaar 3 uint32_t i, mcbpc, cbpy, bits;
294 :    
295 :     cbpy = pMB->cbp >> 2;
296 :    
297 : edgomez 78 // write mcbpc
298 : edgomez 195 if (frame->coding_type == I_VOP) {
299 : edgomez 78 mcbpc = ((pMB->mode >> 1) & 3) | ((pMB->cbp & 3) << 2);
300 : edgomez 195 BitstreamPutBits(bs, mcbpc_intra_tab[mcbpc].code,
301 :     mcbpc_intra_tab[mcbpc].len);
302 :     } else {
303 : edgomez 78 mcbpc = (pMB->mode & 7) | ((pMB->cbp & 3) << 3);
304 : edgomez 195 BitstreamPutBits(bs, mcbpc_inter_tab[mcbpc].code,
305 :     mcbpc_inter_tab[mcbpc].len);
306 : Isibaar 28 }
307 : Isibaar 3
308 :     // ac prediction flag
309 : edgomez 195 if (pMB->acpred_directions[0])
310 : edgomez 78 BitstreamPutBits(bs, 1, 1);
311 : Isibaar 3 else
312 : edgomez 78 BitstreamPutBits(bs, 0, 1);
313 : Isibaar 3
314 : edgomez 78 // write cbpy
315 : edgomez 195 BitstreamPutBits(bs, cbpy_tab[cbpy].code, cbpy_tab[cbpy].len);
316 : Isibaar 3
317 :     // write dquant
318 : edgomez 195 if (pMB->mode == MODE_INTRA_Q)
319 : Isibaar 3 BitstreamPutBits(bs, pMB->dquant, 2);
320 :    
321 : h 69 // write interlacing
322 : edgomez 195 if (frame->global_flags & XVID_INTERLACING) {
323 : h 69 BitstreamPutBit(bs, pMB->field_dct);
324 :     }
325 : Isibaar 3 // code block coeffs
326 : edgomez 195 for (i = 0; i < 6; i++) {
327 :     if (i < 4)
328 :     BitstreamPutBits(bs, dcy_tab[qcoeff[i * 64 + 0] + 255].code,
329 :     dcy_tab[qcoeff[i * 64 + 0] + 255].len);
330 : Isibaar 3 else
331 : edgomez 195 BitstreamPutBits(bs, dcc_tab[qcoeff[i * 64 + 0] + 255].code,
332 :     dcc_tab[qcoeff[i * 64 + 0] + 255].len);
333 :    
334 :     if (pMB->cbp & (1 << (5 - i))) {
335 : Isibaar 3 bits = BitstreamPos(bs);
336 :    
337 : edgomez 195 CodeCoeff(bs, &qcoeff[i * 64], intra_table,
338 :     scan_tables[pMB->acpred_directions[i]], 1);
339 : Isibaar 3
340 :     bits = BitstreamPos(bs) - bits;
341 :     pStat->iTextBits += bits;
342 :     }
343 :     }
344 : edgomez 78
345 : Isibaar 3 }
346 :    
347 :    
348 : edgomez 195 static void
349 :     CodeBlockInter(const FRAMEINFO * frame,
350 :     const MACROBLOCK * pMB,
351 :     int16_t qcoeff[6 * 64],
352 : edgomez 78 Bitstream * bs,
353 :     Statistics * pStat)
354 : Isibaar 3 {
355 : edgomez 78
356 : Isibaar 3 int32_t i;
357 :     uint32_t bits, mcbpc, cbpy;
358 :    
359 : edgomez 78 mcbpc = (pMB->mode & 7) | ((pMB->cbp & 3) << 3);
360 : Isibaar 3 cbpy = 15 - (pMB->cbp >> 2);
361 :    
362 :     // write mcbpc
363 : edgomez 195 BitstreamPutBits(bs, mcbpc_inter_tab[mcbpc].code,
364 :     mcbpc_inter_tab[mcbpc].len);
365 : Isibaar 3
366 :     // write cbpy
367 :     BitstreamPutBits(bs, cbpy_tab[cbpy].code, cbpy_tab[cbpy].len);
368 :    
369 :     // write dquant
370 : edgomez 195 if (pMB->mode == MODE_INTER_Q)
371 : Isibaar 3 BitstreamPutBits(bs, pMB->dquant, 2);
372 : edgomez 195
373 : h 69 // interlacing
374 : edgomez 195 if (frame->global_flags & XVID_INTERLACING) {
375 : h 388 if (pMB->cbp) {
376 :     BitstreamPutBit(bs, pMB->field_dct);
377 :     DEBUG1("codep: field_dct: ", pMB->field_dct);
378 :     }
379 : h 69
380 :     // if inter block, write field ME flag
381 : edgomez 195 if (pMB->mode == MODE_INTER || pMB->mode == MODE_INTER_Q) {
382 : h 69 BitstreamPutBit(bs, pMB->field_pred);
383 :     DEBUG1("codep: field_pred: ", pMB->field_pred);
384 :    
385 :     // write field prediction references
386 : edgomez 195 if (pMB->field_pred) {
387 : h 69 BitstreamPutBit(bs, pMB->field_for_top);
388 :     BitstreamPutBit(bs, pMB->field_for_bot);
389 :     }
390 :     }
391 :     }
392 : Isibaar 3 // code motion vector(s)
393 : edgomez 195 for (i = 0; i < (pMB->mode == MODE_INTER4V ? 4 : 1); i++) {
394 : suxen_drol 136 CodeVector(bs, pMB->pmvs[i].x, frame->fcode, pStat);
395 :     CodeVector(bs, pMB->pmvs[i].y, frame->fcode, pStat);
396 : Isibaar 3 }
397 :    
398 :     bits = BitstreamPos(bs);
399 : edgomez 195
400 : Isibaar 3 // code block coeffs
401 : edgomez 195 for (i = 0; i < 6; i++)
402 :     if (pMB->cbp & (1 << (5 - i)))
403 :     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 : edgomez 453 /*****************************************************************************
411 :     * Macro Block bitstream encoding functions
412 :     ****************************************************************************/
413 : Isibaar 3
414 : edgomez 195 void
415 :     MBCoding(const FRAMEINFO * frame,
416 :     MACROBLOCK * pMB,
417 :     int16_t qcoeff[6 * 64],
418 :     Bitstream * bs,
419 :     Statistics * pStat)
420 : Isibaar 3 {
421 : edgomez 78
422 : edgomez 195 if (frame->coding_type == P_VOP) {
423 :     BitstreamPutBit(bs, 0); // coded
424 : Isibaar 3 }
425 :    
426 : chl 335 if (pMB->mode == MODE_INTRA || pMB->mode == MODE_INTRA_Q)
427 : suxen_drol 136 CodeBlockIntra(frame, pMB, qcoeff, bs, pStat);
428 : Isibaar 3 else
429 : suxen_drol 136 CodeBlockInter(frame, pMB, qcoeff, bs, pStat);
430 : edgomez 78
431 : Isibaar 3 }
432 :    
433 : chl 347
434 :     void
435 :     MBSkip(Bitstream * bs)
436 :     {
437 :     BitstreamPutBit(bs, 1); // not coded
438 :     return;
439 :     }
440 :    
441 : edgomez 453 /*****************************************************************************
442 :     * decoding stuff starts here
443 :     ****************************************************************************/
444 : suxen_drol 118
445 : edgomez 453 /*
446 :     * For IVOP addbits == 0
447 :     * For PVOP addbits == fcode - 1
448 :     * For BVOP addbits == max(fcode,bcode) - 1
449 :     * returns true or false
450 :     */
451 : Isibaar 3
452 : suxen_drol 248 int
453 :     check_resync_marker(Bitstream * bs, int addbits)
454 :     {
455 :     uint32_t nbits;
456 :     uint32_t code;
457 :     uint32_t nbitsresyncmarker = NUMBITS_VP_RESYNC_MARKER + addbits;
458 :    
459 :     nbits = BitstreamNumBitsToByteAlign(bs);
460 :     code = BitstreamShowBits(bs, nbits);
461 :    
462 :     if (code == (((uint32_t)1 << (nbits - 1)) - 1))
463 :     {
464 :     return BitstreamShowBitsFromByteAlign(bs, nbitsresyncmarker) == RESYNC_MARKER;
465 :     }
466 :    
467 :     return 0;
468 :     }
469 :    
470 :    
471 :    
472 : edgomez 195 int
473 :     get_mcbpc_intra(Bitstream * bs)
474 : Isibaar 3 {
475 : edgomez 78
476 : Isibaar 3 uint32_t index;
477 : edgomez 195
478 : suxen_drol 248 index = BitstreamShowBits(bs, 9);
479 : Isibaar 3 index >>= 3;
480 :    
481 :     BitstreamSkip(bs, mcbpc_intra_table[index].len);
482 : edgomez 78
483 : Isibaar 3 return mcbpc_intra_table[index].code;
484 : edgomez 78
485 : Isibaar 3 }
486 :    
487 : edgomez 195 int
488 :     get_mcbpc_inter(Bitstream * bs)
489 : Isibaar 3 {
490 : edgomez 78
491 : Isibaar 3 uint32_t index;
492 : suxen_drol 248
493 :     index = CLIP(BitstreamShowBits(bs, 9), 256);
494 : edgomez 195
495 :     BitstreamSkip(bs, mcbpc_inter_table[index].len);
496 : edgomez 78
497 : Isibaar 3 return mcbpc_inter_table[index].code;
498 : edgomez 78
499 : Isibaar 3 }
500 :    
501 : edgomez 195 int
502 :     get_cbpy(Bitstream * bs,
503 :     int intra)
504 : Isibaar 3 {
505 : edgomez 78
506 : Isibaar 3 int cbpy;
507 :     uint32_t index = BitstreamShowBits(bs, 6);
508 :    
509 :     BitstreamSkip(bs, cbpy_table[index].len);
510 :     cbpy = cbpy_table[index].code;
511 :    
512 : edgomez 195 if (!intra)
513 : Isibaar 3 cbpy = 15 - cbpy;
514 :    
515 :     return cbpy;
516 : edgomez 78
517 : Isibaar 3 }
518 :    
519 : edgomez 195 int
520 :     get_mv_data(Bitstream * bs)
521 : Isibaar 3 {
522 : edgomez 78
523 : Isibaar 3 uint32_t index;
524 :    
525 : edgomez 195 if (BitstreamGetBit(bs))
526 : Isibaar 3 return 0;
527 : edgomez 195
528 : Isibaar 3 index = BitstreamShowBits(bs, 12);
529 :    
530 : edgomez 195 if (index >= 512) {
531 : Isibaar 3 index = (index >> 8) - 2;
532 :     BitstreamSkip(bs, TMNMVtab0[index].len);
533 :     return TMNMVtab0[index].code;
534 :     }
535 : edgomez 195
536 :     if (index >= 128) {
537 : Isibaar 3 index = (index >> 2) - 32;
538 :     BitstreamSkip(bs, TMNMVtab1[index].len);
539 :     return TMNMVtab1[index].code;
540 :     }
541 :    
542 : edgomez 195 index -= 4;
543 : Isibaar 3
544 :     BitstreamSkip(bs, TMNMVtab2[index].len);
545 :     return TMNMVtab2[index].code;
546 : edgomez 78
547 : Isibaar 3 }
548 :    
549 : edgomez 195 int
550 :     get_mv(Bitstream * bs,
551 :     int fcode)
552 : Isibaar 3 {
553 : edgomez 78
554 : Isibaar 3 int data;
555 :     int res;
556 :     int mv;
557 :     int scale_fac = 1 << (fcode - 1);
558 :    
559 :     data = get_mv_data(bs);
560 : edgomez 195
561 :     if (scale_fac == 1 || data == 0)
562 : Isibaar 3 return data;
563 :    
564 :     res = BitstreamGetBits(bs, fcode - 1);
565 :     mv = ((ABS(data) - 1) * scale_fac) + res + 1;
566 : edgomez 195
567 : Isibaar 3 return data < 0 ? -mv : mv;
568 : edgomez 78
569 : Isibaar 3 }
570 :    
571 : edgomez 195 int
572 :     get_dc_dif(Bitstream * bs,
573 :     uint32_t dc_size)
574 : Isibaar 3 {
575 : edgomez 78
576 : Isibaar 3 int code = BitstreamGetBits(bs, dc_size);
577 :     int msb = code >> (dc_size - 1);
578 :    
579 : edgomez 195 if (msb == 0)
580 :     return (-1 * (code ^ ((1 << dc_size) - 1)));
581 : Isibaar 3
582 :     return code;
583 : edgomez 78
584 : Isibaar 3 }
585 :    
586 : edgomez 195 int
587 :     get_dc_size_lum(Bitstream * bs)
588 : Isibaar 3 {
589 : edgomez 78
590 : Isibaar 3 int code, i;
591 : edgomez 195
592 : Isibaar 3 code = BitstreamShowBits(bs, 11);
593 :    
594 : edgomez 195 for (i = 11; i > 3; i--) {
595 :     if (code == 1) {
596 : Isibaar 3 BitstreamSkip(bs, i);
597 :     return i + 1;
598 :     }
599 :     code >>= 1;
600 :     }
601 :    
602 :     BitstreamSkip(bs, dc_lum_tab[code].len);
603 :     return dc_lum_tab[code].code;
604 : edgomez 78
605 : Isibaar 3 }
606 :    
607 :    
608 : edgomez 195 int
609 :     get_dc_size_chrom(Bitstream * bs)
610 : Isibaar 3 {
611 : edgomez 78
612 : Isibaar 3 uint32_t code, i;
613 : edgomez 195
614 : Isibaar 3 code = BitstreamShowBits(bs, 12);
615 :    
616 : edgomez 195 for (i = 12; i > 2; i--) {
617 :     if (code == 1) {
618 : Isibaar 3 BitstreamSkip(bs, i);
619 :     return i;
620 :     }
621 :     code >>= 1;
622 :     }
623 :    
624 :     return 3 - BitstreamGetBits(bs, 2);
625 : edgomez 78
626 : Isibaar 3 }
627 :    
628 : edgomez 453 /*****************************************************************************
629 :     * Local inlined function to "decode" written vlc codes
630 :     ****************************************************************************/
631 :    
632 :     static __inline int
633 :     get_coeff(Bitstream * bs,
634 :     int *run,
635 :     int *last,
636 :     int intra,
637 :     int short_video_header)
638 :     {
639 :    
640 :     uint32_t mode;
641 :     const VLC *tab;
642 :     int32_t level;
643 :    
644 :     if (short_video_header) // inter-VLCs will be used for both intra and inter blocks
645 :     intra = 0;
646 :    
647 :     tab = &DCT3D[intra][BitstreamShowBits(bs, 12)];
648 :    
649 :     if (tab->code == -1)
650 :     goto error;
651 :    
652 :     BitstreamSkip(bs, tab->len);
653 :    
654 :     if (tab->code != ESCAPE) {
655 :     if (!intra) {
656 :     *run = (tab->code >> 4) & 255;
657 :     level = tab->code & 15;
658 :     *last = (tab->code >> 12) & 1;
659 :     } else {
660 :     *run = (tab->code >> 8) & 255;
661 :     level = tab->code & 255;
662 :     *last = (tab->code >> 16) & 1;
663 :     }
664 :     return BitstreamGetBit(bs) ? -level : level;
665 :     }
666 :    
667 :     if (short_video_header) {
668 :     // escape mode 4 - H.263 type, only used if short_video_header = 1
669 :     *last = BitstreamGetBit(bs);
670 :     *run = BitstreamGetBits(bs, 6);
671 :     level = BitstreamGetBits(bs, 8);
672 :    
673 :     if (level == 0 || level == 128)
674 :     DEBUG1("Illegal LEVEL for ESCAPE mode 4:", level);
675 :    
676 :     return (level >= 128 ? -(256 - level) : level);
677 :     }
678 :    
679 :     mode = BitstreamShowBits(bs, 2);
680 :    
681 :     if (mode < 3) {
682 :     BitstreamSkip(bs, (mode == 2) ? 2 : 1);
683 :    
684 :     tab = &DCT3D[intra][BitstreamShowBits(bs, 12)];
685 :     if (tab->code == -1)
686 :     goto error;
687 :    
688 :     BitstreamSkip(bs, tab->len);
689 :    
690 :     if (!intra) {
691 :     *run = (tab->code >> 4) & 255;
692 :     level = tab->code & 15;
693 :     *last = (tab->code >> 12) & 1;
694 :     } else {
695 :     *run = (tab->code >> 8) & 255;
696 :     level = tab->code & 255;
697 :     *last = (tab->code >> 16) & 1;
698 :     }
699 :    
700 :     if (mode < 2) // first escape mode, level is offset
701 :     level += max_level[*last + (!intra << 1)][*run]; // need to add back the max level
702 :     else if (mode == 2) // second escape mode, run is offset
703 :     *run += max_run[*last + (!intra << 1)][level] + 1;
704 :    
705 :     return BitstreamGetBit(bs) ? -level : level;
706 :     }
707 :     // third escape mode - fixed length codes
708 :     BitstreamSkip(bs, 2);
709 :     *last = BitstreamGetBits(bs, 1);
710 :     *run = BitstreamGetBits(bs, 6);
711 :     BitstreamSkip(bs, 1); // marker
712 :     level = BitstreamGetBits(bs, 12);
713 :     BitstreamSkip(bs, 1); // marker
714 :    
715 :     return (level & 0x800) ? (level | (-1 ^ 0xfff)) : level;
716 :    
717 :     error:
718 :     *run = VLC_ERROR;
719 :     return 0;
720 :    
721 :     }
722 :    
723 :     /*****************************************************************************
724 :     * MB reading functions
725 :     ****************************************************************************/
726 :    
727 : edgomez 195 void
728 :     get_intra_block(Bitstream * bs,
729 :     int16_t * block,
730 :     int direction,
731 :     int coeff)
732 : Isibaar 3 {
733 : edgomez 78
734 : edgomez 195 const uint16_t *scan = scan_tables[direction];
735 : Isibaar 3 int level;
736 :     int run;
737 :     int last;
738 :    
739 : edgomez 195 do {
740 : Isibaar 3 level = get_coeff(bs, &run, &last, 1, 0);
741 : edgomez 195 if (run == -1) {
742 : Isibaar 3 DEBUG("fatal: invalid run");
743 :     break;
744 :     }
745 :     coeff += run;
746 : edgomez 195 block[scan[coeff]] = level;
747 : suxen_drol 252
748 :     DPRINTF(DPRINTF_COEFF,"block[%i] %i", scan[coeff], level);
749 :     //DPRINTF(DPRINTF_COEFF,"block[%i] %i %08x", scan[coeff], level, BitstreamShowBits(bs, 32));
750 :    
751 : edgomez 195 if (level < -127 || level > 127) {
752 : Isibaar 3 DEBUG1("warning: intra_overflow", level);
753 :     }
754 :     coeff++;
755 :     } while (!last);
756 : edgomez 78
757 : Isibaar 3 }
758 :    
759 : edgomez 195 void
760 :     get_inter_block(Bitstream * bs,
761 :     int16_t * block)
762 : Isibaar 3 {
763 : edgomez 78
764 : edgomez 195 const uint16_t *scan = scan_tables[0];
765 : Isibaar 3 int p;
766 :     int level;
767 :     int run;
768 :     int last;
769 :    
770 :     p = 0;
771 : edgomez 195 do {
772 : Isibaar 3 level = get_coeff(bs, &run, &last, 0, 0);
773 : edgomez 195 if (run == -1) {
774 : Isibaar 3 DEBUG("fatal: invalid run");
775 :     break;
776 :     }
777 :     p += run;
778 : chenm001 161
779 : edgomez 195 block[scan[p]] = level;
780 : suxen_drol 252
781 :     DPRINTF(DPRINTF_COEFF,"block[%i] %i", scan[p], level);
782 :     // DPRINTF(DPRINTF_COEFF,"block[%i] %i %08x", scan[p], level, BitstreamShowBits(bs, 32));
783 :    
784 : edgomez 195 if (level < -127 || level > 127) {
785 : Isibaar 3 DEBUG1("warning: inter_overflow", level);
786 :     }
787 :     p++;
788 :     } while (!last);
789 : edgomez 78
790 : Isibaar 3 }

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