[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 454 - (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 : edgomez 454 * $Id: mbcoding.c,v 1.28 2002-09-08 15:40:02 edgomez 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 : 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 : edgomez 453 * Vector Length Coding Initialization
60 : edgomez 451 ****************************************************************************/
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 453 /*****************************************************************************
184 :     * Local inlined functions for MB coding
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 : edgomez 195 static __inline void
243 :     CodeCoeff(Bitstream * bs,
244 :     const int16_t qcoeff[64],
245 :     VLC * table,
246 :     const uint16_t * zigzag,
247 :     uint16_t intra)
248 : edgomez 78 {
249 :    
250 : Isibaar 3 uint32_t j, last;
251 :     short v;
252 :     VLC *vlc;
253 : edgomez 195
254 : Isibaar 3 j = intra;
255 : Isibaar 116 last = intra;
256 : Isibaar 3
257 : edgomez 195 while (j < 64 && (v = qcoeff[zigzag[j]]) == 0)
258 :     j++;
259 :    
260 : Isibaar 3 do {
261 : Isibaar 153 vlc = table + 64 * 2047 + (v << 6) + j - last;
262 : Isibaar 116 last = ++j;
263 : Isibaar 153
264 :     // count zeroes
265 : edgomez 195 while (j < 64 && (v = qcoeff[zigzag[j]]) == 0)
266 :     j++;
267 :    
268 : Isibaar 3 // write code
269 : edgomez 195 if (j != 64) {
270 : Isibaar 3 BitstreamPutBits(bs, vlc->code, vlc->len);
271 :     } else {
272 : Isibaar 153 vlc += 64 * 4095;
273 : Isibaar 3 BitstreamPutBits(bs, vlc->code, vlc->len);
274 :     break;
275 :     }
276 : edgomez 195 } while (1);
277 : edgomez 78
278 : Isibaar 3 }
279 :    
280 : edgomez 453 /*****************************************************************************
281 :     * Local functions
282 :     ****************************************************************************/
283 : Isibaar 3
284 : edgomez 195 static void
285 :     CodeBlockIntra(const FRAMEINFO * frame,
286 :     const MACROBLOCK * pMB,
287 :     int16_t qcoeff[6 * 64],
288 : edgomez 78 Bitstream * bs,
289 :     Statistics * pStat)
290 : Isibaar 3 {
291 : edgomez 78
292 : Isibaar 3 uint32_t i, mcbpc, cbpy, bits;
293 :    
294 :     cbpy = pMB->cbp >> 2;
295 :    
296 : edgomez 78 // write mcbpc
297 : edgomez 195 if (frame->coding_type == I_VOP) {
298 : edgomez 78 mcbpc = ((pMB->mode >> 1) & 3) | ((pMB->cbp & 3) << 2);
299 : edgomez 195 BitstreamPutBits(bs, mcbpc_intra_tab[mcbpc].code,
300 :     mcbpc_intra_tab[mcbpc].len);
301 :     } else {
302 : edgomez 78 mcbpc = (pMB->mode & 7) | ((pMB->cbp & 3) << 3);
303 : edgomez 195 BitstreamPutBits(bs, mcbpc_inter_tab[mcbpc].code,
304 :     mcbpc_inter_tab[mcbpc].len);
305 : Isibaar 28 }
306 : Isibaar 3
307 :     // ac prediction flag
308 : edgomez 195 if (pMB->acpred_directions[0])
309 : edgomez 78 BitstreamPutBits(bs, 1, 1);
310 : Isibaar 3 else
311 : edgomez 78 BitstreamPutBits(bs, 0, 1);
312 : Isibaar 3
313 : edgomez 78 // write cbpy
314 : edgomez 195 BitstreamPutBits(bs, cbpy_tab[cbpy].code, cbpy_tab[cbpy].len);
315 : Isibaar 3
316 :     // write dquant
317 : edgomez 195 if (pMB->mode == MODE_INTRA_Q)
318 : Isibaar 3 BitstreamPutBits(bs, pMB->dquant, 2);
319 :    
320 : h 69 // write interlacing
321 : edgomez 195 if (frame->global_flags & XVID_INTERLACING) {
322 : h 69 BitstreamPutBit(bs, pMB->field_dct);
323 :     }
324 : Isibaar 3 // code block coeffs
325 : edgomez 195 for (i = 0; i < 6; i++) {
326 :     if (i < 4)
327 :     BitstreamPutBits(bs, dcy_tab[qcoeff[i * 64 + 0] + 255].code,
328 :     dcy_tab[qcoeff[i * 64 + 0] + 255].len);
329 : Isibaar 3 else
330 : edgomez 195 BitstreamPutBits(bs, dcc_tab[qcoeff[i * 64 + 0] + 255].code,
331 :     dcc_tab[qcoeff[i * 64 + 0] + 255].len);
332 :    
333 :     if (pMB->cbp & (1 << (5 - i))) {
334 : Isibaar 3 bits = BitstreamPos(bs);
335 :    
336 : edgomez 195 CodeCoeff(bs, &qcoeff[i * 64], intra_table,
337 :     scan_tables[pMB->acpred_directions[i]], 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 195 static void
348 :     CodeBlockInter(const FRAMEINFO * frame,
349 :     const MACROBLOCK * pMB,
350 :     int16_t qcoeff[6 * 64],
351 : edgomez 78 Bitstream * bs,
352 :     Statistics * pStat)
353 : Isibaar 3 {
354 : edgomez 78
355 : Isibaar 3 int32_t i;
356 :     uint32_t bits, mcbpc, cbpy;
357 :    
358 : edgomez 78 mcbpc = (pMB->mode & 7) | ((pMB->cbp & 3) << 3);
359 : Isibaar 3 cbpy = 15 - (pMB->cbp >> 2);
360 :    
361 :     // write mcbpc
362 : edgomez 195 BitstreamPutBits(bs, mcbpc_inter_tab[mcbpc].code,
363 :     mcbpc_inter_tab[mcbpc].len);
364 : Isibaar 3
365 :     // write cbpy
366 :     BitstreamPutBits(bs, cbpy_tab[cbpy].code, cbpy_tab[cbpy].len);
367 :    
368 :     // write dquant
369 : edgomez 195 if (pMB->mode == MODE_INTER_Q)
370 : Isibaar 3 BitstreamPutBits(bs, pMB->dquant, 2);
371 : edgomez 195
372 : h 69 // interlacing
373 : edgomez 195 if (frame->global_flags & XVID_INTERLACING) {
374 : h 388 if (pMB->cbp) {
375 :     BitstreamPutBit(bs, pMB->field_dct);
376 :     DEBUG1("codep: field_dct: ", pMB->field_dct);
377 :     }
378 : h 69
379 :     // if inter block, write field ME flag
380 : edgomez 195 if (pMB->mode == MODE_INTER || pMB->mode == MODE_INTER_Q) {
381 : h 69 BitstreamPutBit(bs, pMB->field_pred);
382 :     DEBUG1("codep: field_pred: ", pMB->field_pred);
383 :    
384 :     // write field prediction references
385 : edgomez 195 if (pMB->field_pred) {
386 : h 69 BitstreamPutBit(bs, pMB->field_for_top);
387 :     BitstreamPutBit(bs, pMB->field_for_bot);
388 :     }
389 :     }
390 :     }
391 : Isibaar 3 // code motion vector(s)
392 : edgomez 195 for (i = 0; i < (pMB->mode == MODE_INTER4V ? 4 : 1); i++) {
393 : suxen_drol 136 CodeVector(bs, pMB->pmvs[i].x, frame->fcode, pStat);
394 :     CodeVector(bs, pMB->pmvs[i].y, frame->fcode, pStat);
395 : Isibaar 3 }
396 :    
397 :     bits = BitstreamPos(bs);
398 : edgomez 195
399 : Isibaar 3 // code block coeffs
400 : edgomez 195 for (i = 0; i < 6; i++)
401 :     if (pMB->cbp & (1 << (5 - i)))
402 :     CodeCoeff(bs, &qcoeff[i * 64], inter_table, scan_tables[0], 0);
403 : Isibaar 3
404 :     bits = BitstreamPos(bs) - bits;
405 :     pStat->iTextBits += bits;
406 : edgomez 78
407 : Isibaar 3 }
408 :    
409 : edgomez 453 /*****************************************************************************
410 :     * Macro Block bitstream encoding functions
411 :     ****************************************************************************/
412 : Isibaar 3
413 : edgomez 195 void
414 :     MBCoding(const FRAMEINFO * frame,
415 :     MACROBLOCK * pMB,
416 :     int16_t qcoeff[6 * 64],
417 :     Bitstream * bs,
418 :     Statistics * pStat)
419 : Isibaar 3 {
420 : edgomez 78
421 : edgomez 195 if (frame->coding_type == P_VOP) {
422 :     BitstreamPutBit(bs, 0); // coded
423 : Isibaar 3 }
424 :    
425 : chl 335 if (pMB->mode == MODE_INTRA || pMB->mode == MODE_INTRA_Q)
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 : chl 347
433 :     void
434 :     MBSkip(Bitstream * bs)
435 :     {
436 :     BitstreamPutBit(bs, 1); // not coded
437 :     return;
438 :     }
439 :    
440 : edgomez 454 #if 0
441 : suxen_drol 118 /***************************************************************
442 :     * bframe encoding start
443 :     ***************************************************************/
444 : Isibaar 3
445 : suxen_drol 118 /*
446 :     mbtype
447 :     0 1b direct(h263) mvdb
448 :     1 01b interpolate mc+q dbquant, mvdf, mvdb
449 :     2 001b backward mc+q dbquant, mvdb
450 :     3 0001b forward mc+q dbquant, mvdf
451 :     */
452 :    
453 : edgomez 195 void
454 :     put_bvop_mbtype(Bitstream * bs,
455 :     int value)
456 : suxen_drol 118 {
457 : edgomez 195 switch (value) {
458 :     case 0:
459 :     BitstreamPutBit(bs, 1);
460 :     return;
461 : suxen_drol 118
462 : edgomez 195 case 1:
463 :     BitstreamPutBit(bs, 0);
464 :     BitstreamPutBit(bs, 1);
465 :     return;
466 : suxen_drol 118
467 : edgomez 195 case 2:
468 :     BitstreamPutBit(bs, 0);
469 :     BitstreamPutBit(bs, 0);
470 :     BitstreamPutBit(bs, 1);
471 :     return;
472 : suxen_drol 118
473 : edgomez 195 case 3:
474 :     BitstreamPutBit(bs, 0);
475 :     BitstreamPutBit(bs, 0);
476 :     BitstreamPutBit(bs, 0);
477 :     BitstreamPutBit(bs, 1);
478 :     return;
479 :    
480 :     default:; // invalid!
481 :    
482 : suxen_drol 118 }
483 : edgomez 195
484 : suxen_drol 118 }
485 :    
486 :     /*
487 :     dbquant
488 :     -2 10b
489 :     0 0b
490 :     +2 11b
491 :     */
492 :    
493 : edgomez 195 void
494 :     put_bvop_dbquant(Bitstream * bs,
495 :     int value)
496 : suxen_drol 118 {
497 : edgomez 195 switch (value) {
498 :     case 0:
499 :     BitstreamPutBit(bs, 0);
500 :     return;
501 : suxen_drol 118
502 : edgomez 195 case -2:
503 :     BitstreamPutBit(bs, 1);
504 :     BitstreamPutBit(bs, 0);
505 :     return;
506 : suxen_drol 118
507 : edgomez 195 case 2:
508 :     BitstreamPutBit(bs, 1);
509 :     BitstreamPutBit(bs, 1);
510 :     return;
511 :    
512 :     default:; // invalid
513 : suxen_drol 118 }
514 :     }
515 :    
516 : edgomez 195 void
517 :     MBCodingBVOP(const MACROBLOCK * mb,
518 :     const int16_t qcoeff[6 * 64],
519 :     const int32_t fcode,
520 :     const int32_t bcode,
521 :     Bitstream * bs,
522 :     Statistics * pStat)
523 : suxen_drol 118 {
524 :     int i;
525 :    
526 :     /* ------------------------------------------------------------------
527 : chl 313 when a block is skipped it is decoded DIRECT(0,0)
528 :     hence is interpolated from forward & backward frames
529 : suxen_drol 118 ------------------------------------------------------------------ */
530 :    
531 : chl 313 if (mb->mode == MODE_DIRECT_NONE_MV) {
532 : edgomez 195 BitstreamPutBit(bs, 1); // skipped
533 : suxen_drol 118 return;
534 :     }
535 :    
536 :     BitstreamPutBit(bs, 0); // not skipped
537 :    
538 : edgomez 195 if (mb->cbp == 0) {
539 :     BitstreamPutBit(bs, 1); // cbp == 0
540 :     } else {
541 :     BitstreamPutBit(bs, 0); // cbp == xxx
542 : suxen_drol 118 }
543 :    
544 :     put_bvop_mbtype(bs, mb->mode);
545 :    
546 : edgomez 195 if (mb->cbp) {
547 : suxen_drol 118 BitstreamPutBits(bs, mb->cbp, 6);
548 :     }
549 :    
550 : edgomez 195 if (mb->mode != MODE_DIRECT && mb->cbp != 0) {
551 :     put_bvop_dbquant(bs, 0); // todo: mb->dquant = 0
552 : suxen_drol 118 }
553 :    
554 : edgomez 195 if (mb->mode == MODE_INTERPOLATE || mb->mode == MODE_FORWARD) {
555 :     CodeVector(bs, mb->pmvs[0].x, fcode, pStat);
556 :     CodeVector(bs, mb->pmvs[0].y, fcode, pStat);
557 : suxen_drol 118 }
558 :    
559 : edgomez 195 if (mb->mode == MODE_INTERPOLATE || mb->mode == MODE_BACKWARD) {
560 :     CodeVector(bs, mb->b_pmvs[0].x, bcode, pStat);
561 :     CodeVector(bs, mb->b_pmvs[0].y, bcode, pStat);
562 : suxen_drol 118 }
563 :    
564 : edgomez 195 if (mb->mode == MODE_DIRECT) {
565 : chl 338 CodeVector(bs, mb->deltamv.x, 1, pStat); /* fcode is always 1 for delta vector */
566 :     CodeVector(bs, mb->deltamv.y, 1, pStat); /* prediction is always (0,0) */
567 : suxen_drol 118 }
568 : edgomez 195
569 :     for (i = 0; i < 6; i++) {
570 :     if (mb->cbp & (1 << (5 - i))) {
571 :     CodeCoeff(bs, &qcoeff[i * 64], inter_table, scan_tables[0], 0);
572 : suxen_drol 118 }
573 : edgomez 195 }
574 : suxen_drol 118 }
575 : edgomez 453 #endif
576 : suxen_drol 118
577 :    
578 : edgomez 453 /*****************************************************************************
579 :     * decoding stuff starts here
580 :     ****************************************************************************/
581 : suxen_drol 118
582 : edgomez 453 /*
583 :     * For IVOP addbits == 0
584 :     * For PVOP addbits == fcode - 1
585 :     * For BVOP addbits == max(fcode,bcode) - 1
586 :     * returns true or false
587 :     */
588 : Isibaar 3
589 : suxen_drol 248 int
590 :     check_resync_marker(Bitstream * bs, int addbits)
591 :     {
592 :     uint32_t nbits;
593 :     uint32_t code;
594 :     uint32_t nbitsresyncmarker = NUMBITS_VP_RESYNC_MARKER + addbits;
595 :    
596 :     nbits = BitstreamNumBitsToByteAlign(bs);
597 :     code = BitstreamShowBits(bs, nbits);
598 :    
599 :     if (code == (((uint32_t)1 << (nbits - 1)) - 1))
600 :     {
601 :     return BitstreamShowBitsFromByteAlign(bs, nbitsresyncmarker) == RESYNC_MARKER;
602 :     }
603 :    
604 :     return 0;
605 :     }
606 :    
607 :    
608 :    
609 : edgomez 195 int
610 :     get_mcbpc_intra(Bitstream * bs)
611 : Isibaar 3 {
612 : edgomez 78
613 : Isibaar 3 uint32_t index;
614 : edgomez 195
615 : suxen_drol 248 index = BitstreamShowBits(bs, 9);
616 : Isibaar 3 index >>= 3;
617 :    
618 :     BitstreamSkip(bs, mcbpc_intra_table[index].len);
619 : edgomez 78
620 : Isibaar 3 return mcbpc_intra_table[index].code;
621 : edgomez 78
622 : Isibaar 3 }
623 :    
624 : edgomez 195 int
625 :     get_mcbpc_inter(Bitstream * bs)
626 : Isibaar 3 {
627 : edgomez 78
628 : Isibaar 3 uint32_t index;
629 : suxen_drol 248
630 :     index = CLIP(BitstreamShowBits(bs, 9), 256);
631 : edgomez 195
632 :     BitstreamSkip(bs, mcbpc_inter_table[index].len);
633 : edgomez 78
634 : Isibaar 3 return mcbpc_inter_table[index].code;
635 : edgomez 78
636 : Isibaar 3 }
637 :    
638 : edgomez 195 int
639 :     get_cbpy(Bitstream * bs,
640 :     int intra)
641 : Isibaar 3 {
642 : edgomez 78
643 : Isibaar 3 int cbpy;
644 :     uint32_t index = BitstreamShowBits(bs, 6);
645 :    
646 :     BitstreamSkip(bs, cbpy_table[index].len);
647 :     cbpy = cbpy_table[index].code;
648 :    
649 : edgomez 195 if (!intra)
650 : Isibaar 3 cbpy = 15 - cbpy;
651 :    
652 :     return cbpy;
653 : edgomez 78
654 : Isibaar 3 }
655 :    
656 : edgomez 195 int
657 :     get_mv_data(Bitstream * bs)
658 : Isibaar 3 {
659 : edgomez 78
660 : Isibaar 3 uint32_t index;
661 :    
662 : edgomez 195 if (BitstreamGetBit(bs))
663 : Isibaar 3 return 0;
664 : edgomez 195
665 : Isibaar 3 index = BitstreamShowBits(bs, 12);
666 :    
667 : edgomez 195 if (index >= 512) {
668 : Isibaar 3 index = (index >> 8) - 2;
669 :     BitstreamSkip(bs, TMNMVtab0[index].len);
670 :     return TMNMVtab0[index].code;
671 :     }
672 : edgomez 195
673 :     if (index >= 128) {
674 : Isibaar 3 index = (index >> 2) - 32;
675 :     BitstreamSkip(bs, TMNMVtab1[index].len);
676 :     return TMNMVtab1[index].code;
677 :     }
678 :    
679 : edgomez 195 index -= 4;
680 : Isibaar 3
681 :     BitstreamSkip(bs, TMNMVtab2[index].len);
682 :     return TMNMVtab2[index].code;
683 : edgomez 78
684 : Isibaar 3 }
685 :    
686 : edgomez 195 int
687 :     get_mv(Bitstream * bs,
688 :     int fcode)
689 : Isibaar 3 {
690 : edgomez 78
691 : Isibaar 3 int data;
692 :     int res;
693 :     int mv;
694 :     int scale_fac = 1 << (fcode - 1);
695 :    
696 :     data = get_mv_data(bs);
697 : edgomez 195
698 :     if (scale_fac == 1 || data == 0)
699 : Isibaar 3 return data;
700 :    
701 :     res = BitstreamGetBits(bs, fcode - 1);
702 :     mv = ((ABS(data) - 1) * scale_fac) + res + 1;
703 : edgomez 195
704 : Isibaar 3 return data < 0 ? -mv : mv;
705 : edgomez 78
706 : Isibaar 3 }
707 :    
708 : edgomez 195 int
709 :     get_dc_dif(Bitstream * bs,
710 :     uint32_t dc_size)
711 : Isibaar 3 {
712 : edgomez 78
713 : Isibaar 3 int code = BitstreamGetBits(bs, dc_size);
714 :     int msb = code >> (dc_size - 1);
715 :    
716 : edgomez 195 if (msb == 0)
717 :     return (-1 * (code ^ ((1 << dc_size) - 1)));
718 : Isibaar 3
719 :     return code;
720 : edgomez 78
721 : Isibaar 3 }
722 :    
723 : edgomez 195 int
724 :     get_dc_size_lum(Bitstream * bs)
725 : Isibaar 3 {
726 : edgomez 78
727 : Isibaar 3 int code, i;
728 : edgomez 195
729 : Isibaar 3 code = BitstreamShowBits(bs, 11);
730 :    
731 : edgomez 195 for (i = 11; i > 3; i--) {
732 :     if (code == 1) {
733 : Isibaar 3 BitstreamSkip(bs, i);
734 :     return i + 1;
735 :     }
736 :     code >>= 1;
737 :     }
738 :    
739 :     BitstreamSkip(bs, dc_lum_tab[code].len);
740 :     return dc_lum_tab[code].code;
741 : edgomez 78
742 : Isibaar 3 }
743 :    
744 :    
745 : edgomez 195 int
746 :     get_dc_size_chrom(Bitstream * bs)
747 : Isibaar 3 {
748 : edgomez 78
749 : Isibaar 3 uint32_t code, i;
750 : edgomez 195
751 : Isibaar 3 code = BitstreamShowBits(bs, 12);
752 :    
753 : edgomez 195 for (i = 12; i > 2; i--) {
754 :     if (code == 1) {
755 : Isibaar 3 BitstreamSkip(bs, i);
756 :     return i;
757 :     }
758 :     code >>= 1;
759 :     }
760 :    
761 :     return 3 - BitstreamGetBits(bs, 2);
762 : edgomez 78
763 : Isibaar 3 }
764 :    
765 : edgomez 453 /*****************************************************************************
766 :     * Local inlined function to "decode" written vlc codes
767 :     ****************************************************************************/
768 :    
769 :     static __inline int
770 :     get_coeff(Bitstream * bs,
771 :     int *run,
772 :     int *last,
773 :     int intra,
774 :     int short_video_header)
775 :     {
776 :    
777 :     uint32_t mode;
778 :     const VLC *tab;
779 :     int32_t level;
780 :    
781 :     if (short_video_header) // inter-VLCs will be used for both intra and inter blocks
782 :     intra = 0;
783 :    
784 :     tab = &DCT3D[intra][BitstreamShowBits(bs, 12)];
785 :    
786 :     if (tab->code == -1)
787 :     goto error;
788 :    
789 :     BitstreamSkip(bs, tab->len);
790 :    
791 :     if (tab->code != ESCAPE) {
792 :     if (!intra) {
793 :     *run = (tab->code >> 4) & 255;
794 :     level = tab->code & 15;
795 :     *last = (tab->code >> 12) & 1;
796 :     } else {
797 :     *run = (tab->code >> 8) & 255;
798 :     level = tab->code & 255;
799 :     *last = (tab->code >> 16) & 1;
800 :     }
801 :     return BitstreamGetBit(bs) ? -level : level;
802 :     }
803 :    
804 :     if (short_video_header) {
805 :     // escape mode 4 - H.263 type, only used if short_video_header = 1
806 :     *last = BitstreamGetBit(bs);
807 :     *run = BitstreamGetBits(bs, 6);
808 :     level = BitstreamGetBits(bs, 8);
809 :    
810 :     if (level == 0 || level == 128)
811 :     DEBUG1("Illegal LEVEL for ESCAPE mode 4:", level);
812 :    
813 :     return (level >= 128 ? -(256 - level) : level);
814 :     }
815 :    
816 :     mode = BitstreamShowBits(bs, 2);
817 :    
818 :     if (mode < 3) {
819 :     BitstreamSkip(bs, (mode == 2) ? 2 : 1);
820 :    
821 :     tab = &DCT3D[intra][BitstreamShowBits(bs, 12)];
822 :     if (tab->code == -1)
823 :     goto error;
824 :    
825 :     BitstreamSkip(bs, tab->len);
826 :    
827 :     if (!intra) {
828 :     *run = (tab->code >> 4) & 255;
829 :     level = tab->code & 15;
830 :     *last = (tab->code >> 12) & 1;
831 :     } else {
832 :     *run = (tab->code >> 8) & 255;
833 :     level = tab->code & 255;
834 :     *last = (tab->code >> 16) & 1;
835 :     }
836 :    
837 :     if (mode < 2) // first escape mode, level is offset
838 :     level += max_level[*last + (!intra << 1)][*run]; // need to add back the max level
839 :     else if (mode == 2) // second escape mode, run is offset
840 :     *run += max_run[*last + (!intra << 1)][level] + 1;
841 :    
842 :     return BitstreamGetBit(bs) ? -level : level;
843 :     }
844 :     // third escape mode - fixed length codes
845 :     BitstreamSkip(bs, 2);
846 :     *last = BitstreamGetBits(bs, 1);
847 :     *run = BitstreamGetBits(bs, 6);
848 :     BitstreamSkip(bs, 1); // marker
849 :     level = BitstreamGetBits(bs, 12);
850 :     BitstreamSkip(bs, 1); // marker
851 :    
852 :     return (level & 0x800) ? (level | (-1 ^ 0xfff)) : level;
853 :    
854 :     error:
855 :     *run = VLC_ERROR;
856 :     return 0;
857 :    
858 :     }
859 :    
860 :     /*****************************************************************************
861 :     * MB reading functions
862 :     ****************************************************************************/
863 :    
864 : edgomez 195 void
865 :     get_intra_block(Bitstream * bs,
866 :     int16_t * block,
867 :     int direction,
868 :     int coeff)
869 : Isibaar 3 {
870 : edgomez 78
871 : edgomez 195 const uint16_t *scan = scan_tables[direction];
872 : Isibaar 3 int level;
873 :     int run;
874 :     int last;
875 :    
876 : edgomez 195 do {
877 : Isibaar 3 level = get_coeff(bs, &run, &last, 1, 0);
878 : edgomez 195 if (run == -1) {
879 : Isibaar 3 DEBUG("fatal: invalid run");
880 :     break;
881 :     }
882 :     coeff += run;
883 : edgomez 195 block[scan[coeff]] = level;
884 : suxen_drol 252
885 :     DPRINTF(DPRINTF_COEFF,"block[%i] %i", scan[coeff], level);
886 :     //DPRINTF(DPRINTF_COEFF,"block[%i] %i %08x", scan[coeff], level, BitstreamShowBits(bs, 32));
887 :    
888 : edgomez 195 if (level < -127 || level > 127) {
889 : Isibaar 3 DEBUG1("warning: intra_overflow", level);
890 :     }
891 :     coeff++;
892 :     } while (!last);
893 : edgomez 78
894 : Isibaar 3 }
895 :    
896 : edgomez 195 void
897 :     get_inter_block(Bitstream * bs,
898 :     int16_t * block)
899 : Isibaar 3 {
900 : edgomez 78
901 : edgomez 195 const uint16_t *scan = scan_tables[0];
902 : Isibaar 3 int p;
903 :     int level;
904 :     int run;
905 :     int last;
906 :    
907 :     p = 0;
908 : edgomez 195 do {
909 : Isibaar 3 level = get_coeff(bs, &run, &last, 0, 0);
910 : edgomez 195 if (run == -1) {
911 : Isibaar 3 DEBUG("fatal: invalid run");
912 :     break;
913 :     }
914 :     p += run;
915 : chenm001 161
916 : edgomez 195 block[scan[p]] = level;
917 : suxen_drol 252
918 :     DPRINTF(DPRINTF_COEFF,"block[%i] %i", scan[p], level);
919 :     // DPRINTF(DPRINTF_COEFF,"block[%i] %i %08x", scan[p], level, BitstreamShowBits(bs, 32));
920 :    
921 : edgomez 195 if (level < -127 || level > 127) {
922 : Isibaar 3 DEBUG1("warning: inter_overflow", level);
923 :     }
924 :     p++;
925 :     } while (!last);
926 : edgomez 78
927 : Isibaar 3 }

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