[cvs] / xvidcore / src / bitstream / mbcoding.c Repository:
ViewVC logotype

Annotation of /xvidcore/src/bitstream/mbcoding.c

Parent Directory Parent Directory | Revision Log Revision Log

Revision 1.25.2.10 - (view) (download)

1 : suxen_drol 1.11 /******************************************************************************
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 1.15 * mbcoding.c *
33 : suxen_drol 1.11 * *
34 : Isibaar 1.15 * Copyright (C) 2002 - Michael Militzer <isibaar@xvid.org> *
35 : suxen_drol 1.11 * *
36 :     * For more information visit the XviD homepage: http://www.xvid.org *
37 :     * *
38 :     ******************************************************************************/
39 :    
40 :     /******************************************************************************
41 :     * *
42 :     * Revision history: *
43 :     * *
44 : chl 1.25.2.10 * 04.01.2003 GMC support - gruel *
45 : suxen_drol 1.19 * 28.06.2002 added check_resync_marker() *
46 : Isibaar 1.15 * 14.04.2002 bframe encoding *
47 : suxen_drol 1.11 * 08.03.2002 initial version; isibaar *
48 :     * *
49 :     ******************************************************************************/
50 :    
51 :    
52 : chl 1.25.2.10 #include <stdio.h>
53 : Isibaar 1.8 #include <stdlib.h>
54 : Isibaar 1.1 #include "../portab.h"
55 : suxen_drol 1.25.2.9 #include "../global.h"
56 : Isibaar 1.1 #include "bitstream.h"
57 :     #include "zigzag.h"
58 :     #include "vlc_codes.h"
59 : Isibaar 1.8 #include "mbcoding.h"
60 : Isibaar 1.1
61 :     #include "../utils/mbfunctions.h"
62 :    
63 : suxen_drol 1.25.2.7 VLC intra_table[4*2048*64];
64 :     VLC inter_table[4*2048*64];
65 : Isibaar 1.9
66 : Isibaar 1.8 VLC DCT3Dintra[4096];
67 :     VLC DCT3Dinter[4096];
68 : Isibaar 1.1
69 : chl 1.25.2.3 /* not really MB related, but VLCs are only available here */
70 : suxen_drol 1.25.2.4 void bs_put_spritetrajectory(Bitstream * bs, const int val)
71 : chl 1.25.2.3 {
72 :     const int code = sprite_trajectory_code[val+16384].code;
73 :     const int len = sprite_trajectory_code[val+16384].len;
74 :     const int code2 = sprite_trajectory_len[len].code;
75 :     const int len2 = sprite_trajectory_len[len].len;
76 :    
77 :     // printf("GMC=%d Code/Len = %d / %d ",val, code,len);
78 :     // printf("Code2 / Len2 = %d / %d \n",code2,len2);
79 :    
80 :     BitstreamPutBits(bs, code2, len2);
81 :     if (len) BitstreamPutBits(bs, code, len);
82 :     }
83 :    
84 : suxen_drol 1.25.2.5 int bs_get_spritetrajectory(Bitstream * bs)
85 :     {
86 :     int i;
87 :     for (i = 0; i < 12; i++)
88 :     {
89 :     if (BitstreamShowBits(bs, sprite_trajectory_len[i].len) == sprite_trajectory_len[i].code)
90 :     {
91 :     BitstreamSkip(bs, sprite_trajectory_len[i].len);
92 :     return i;
93 :     }
94 :     }
95 :     return -1;
96 :     }
97 : chl 1.25.2.3
98 : edgomez 1.17 void
99 :     init_vlc_tables(void)
100 : Isibaar 1.1 {
101 : edgomez 1.7
102 : Isibaar 1.1 int32_t k, l, i, intra, last;
103 :     VLC *vlc[2];
104 :     VLC **coeff_ptr;
105 :     VLC *vlc1, *vlc2;
106 :    
107 :     vlc1 = DCT3Dintra;
108 :     vlc2 = DCT3Dinter;
109 : edgomez 1.17
110 : Isibaar 1.8 vlc[0] = intra_table;
111 :     vlc[1] = inter_table;
112 : edgomez 1.17
113 : Isibaar 1.8 // generate encoding vlc lookup tables
114 : Isibaar 1.15 // the lookup table idea is taken from the excellent fame project by Vivien Chapellier
115 : edgomez 1.17 for (i = 0; i < 4; i++) {
116 : Isibaar 1.1 intra = i % 2;
117 : Isibaar 1.8 last = i / 2;
118 : Isibaar 1.1
119 : Isibaar 1.8 coeff_ptr = coeff_vlc[last + 2 * intra];
120 : edgomez 1.17
121 :     for (k = -2047; k < 2048; k++) { // level
122 : Isibaar 1.8 int8_t *max_level_ptr = max_level[last + 2 * intra];
123 :     int8_t *max_run_ptr = max_run[last + 2 * intra];
124 : edgomez 1.17
125 :     for (l = 0; l < 64; l++) { // run
126 : Isibaar 1.5 int32_t level = k;
127 : Isibaar 1.18 ptr_t run = l;
128 : edgomez 1.17
129 :     if ((abs(level) <= max_level_ptr[run]) && (run <= (uint32_t) max_run_ptr[abs(level)])) { // level < max_level and run < max_run
130 :    
131 :     vlc[intra]->code = 0;
132 :     vlc[intra]->len = 0;
133 :     goto loop_end;
134 :     } else {
135 :     if (level > 0) // correct level
136 : Isibaar 1.1 level -= max_level_ptr[run];
137 :     else
138 :     level += max_level_ptr[run];
139 : Isibaar 1.5
140 : edgomez 1.17 if ((abs(level) <= max_level_ptr[run]) &&
141 :     (run <= (uint32_t) max_run_ptr[abs(level)])) {
142 :    
143 : Isibaar 1.8 vlc[intra]->code = 0x06;
144 :     vlc[intra]->len = 8;
145 :     goto loop_end;
146 :     }
147 :    
148 : edgomez 1.17 if (level > 0) // still here?
149 :     level += max_level_ptr[run]; // restore level
150 : Isibaar 1.8 else
151 :     level -= max_level_ptr[run];
152 :    
153 : edgomez 1.17 run -= max_run_ptr[abs(level)] + 1; // and change run
154 :    
155 :     if ((abs(level) <= max_level_ptr[run]) &&
156 :     (run <= (uint32_t) max_run_ptr[abs(level)])) {
157 : Isibaar 1.8
158 :     vlc[intra]->code = 0x0e;
159 :     vlc[intra]->len = 9;
160 :     goto loop_end;
161 : Isibaar 1.1 }
162 : Isibaar 1.8 run += max_run_ptr[abs(level)] + 1;
163 : Isibaar 1.1 }
164 : Isibaar 1.8
165 : edgomez 1.17 vlc[intra]->code =
166 :     (uint32_t) ((l << 14) | (0x1e + last) << 20) | (1 << 13) |
167 :     ((k & 0xfff) << 1) | 1;
168 : Isibaar 1.8
169 :     vlc[intra]->len = 30;
170 :     vlc[intra]++;
171 :     continue;
172 :    
173 : edgomez 1.17 loop_end:
174 :     if (level != 0) {
175 :     vlc[intra]->code =
176 :     (vlc[intra]->
177 :     code << (coeff_ptr[run][abs(level) - 1].len +
178 :     1)) | (coeff_ptr[run][abs(level) -
179 :     1].code << 1);
180 :     vlc[intra]->len =
181 :     (coeff_ptr[run][abs(level) - 1].len + 1) +
182 :     vlc[intra]->len;
183 : Isibaar 1.8
184 : edgomez 1.17 if (level < 0)
185 : Isibaar 1.8 vlc[intra]->code += 1;
186 :     }
187 :    
188 : Isibaar 1.1 vlc[intra]++;
189 :     }
190 :     }
191 :     }
192 : edgomez 1.7
193 : edgomez 1.17 for (i = 0; i < 4096; i++) {
194 :     if (i >= 512) {
195 : Isibaar 1.1 *vlc1 = DCT3Dtab3[(i >> 5) - 16];
196 :     *vlc2 = DCT3Dtab0[(i >> 5) - 16];
197 : edgomez 1.17 } else if (i >= 128) {
198 : Isibaar 1.1 *vlc1 = DCT3Dtab4[(i >> 2) - 32];
199 :     *vlc2 = DCT3Dtab1[(i >> 2) - 32];
200 : edgomez 1.17 } else if (i >= 8) {
201 : Isibaar 1.1 *vlc1 = DCT3Dtab5[i - 8];
202 :     *vlc2 = DCT3Dtab2[i - 8];
203 : edgomez 1.17 } else {
204 : Isibaar 1.1 *vlc1 = ERRtab[i];
205 :     *vlc2 = ERRtab[i];
206 :     }
207 :    
208 :     vlc1++;
209 :     vlc2++;
210 :     }
211 :     DCT3D[0] = DCT3Dinter;
212 :     DCT3D[1] = DCT3Dintra;
213 :    
214 : chl 1.25.2.3
215 :     /* init sprite_trajectory tables */
216 :     /* even if GMC is not specified (it might be used later...) */
217 :    
218 :     sprite_trajectory_code[0+16384].code = 0;
219 :     sprite_trajectory_code[0+16384].len = 0;
220 :     for (k=0;k<14;k++)
221 :     {
222 :     int limit = (1<<k);
223 :    
224 :     for (i=-(2*limit-1); i<= -limit; i++)
225 :     {
226 :     sprite_trajectory_code[i+16384].code = (2*limit-1)+i;
227 :     sprite_trajectory_code[i+16384].len = k+1;
228 :     }
229 :    
230 :     for (i=limit; i<= 2*limit-1; i++)
231 :     {
232 :     sprite_trajectory_code[i+16384].code = i;
233 :     sprite_trajectory_code[i+16384].len = k+1;
234 :     }
235 :     }
236 : Isibaar 1.1 }
237 :    
238 : edgomez 1.17 static __inline void
239 :     CodeVector(Bitstream * bs,
240 :     int32_t value,
241 :     int32_t f_code,
242 :     Statistics * pStat)
243 : Isibaar 1.1 {
244 : edgomez 1.7
245 : Isibaar 1.1 const int scale_factor = 1 << (f_code - 1);
246 :     const int cmp = scale_factor << 5;
247 :    
248 : edgomez 1.17 if (value < (-1 * cmp))
249 : Isibaar 1.1 value += 64 * scale_factor;
250 : edgomez 1.17
251 :     if (value > (cmp - 1))
252 : Isibaar 1.1 value -= 64 * scale_factor;
253 :    
254 : edgomez 1.7 pStat->iMvSum += value * value;
255 :     pStat->iMvCount++;
256 : Isibaar 1.1
257 : edgomez 1.7 if (value == 0) {
258 : edgomez 1.17 BitstreamPutBits(bs, mb_motion_table[32].code,
259 :     mb_motion_table[32].len);
260 : edgomez 1.7 } else {
261 : Isibaar 1.1 uint16_t length, code, mv_res, sign;
262 : edgomez 1.17
263 : Isibaar 1.1 length = 16 << f_code;
264 :     f_code--;
265 : edgomez 1.17
266 : Isibaar 1.1 sign = (value < 0);
267 :    
268 : edgomez 1.17 if (value >= length)
269 : Isibaar 1.1 value -= 2 * length;
270 : edgomez 1.17 else if (value < -length)
271 : Isibaar 1.1 value += 2 * length;
272 :    
273 : edgomez 1.17 if (sign)
274 : Isibaar 1.1 value = -value;
275 :    
276 :     value--;
277 :     mv_res = value & ((1 << f_code) - 1);
278 :     code = ((value - mv_res) >> f_code) + 1;
279 :    
280 : edgomez 1.17 if (sign)
281 : Isibaar 1.1 code = -code;
282 :    
283 :     code += 32;
284 : edgomez 1.17 BitstreamPutBits(bs, mb_motion_table[code].code,
285 :     mb_motion_table[code].len);
286 :    
287 :     if (f_code)
288 : Isibaar 1.1 BitstreamPutBits(bs, mv_res, f_code);
289 : edgomez 1.7 }
290 :    
291 : Isibaar 1.1 }
292 :    
293 :    
294 : edgomez 1.17 static __inline void
295 :     CodeCoeff(Bitstream * bs,
296 :     const int16_t qcoeff[64],
297 :     VLC * table,
298 :     const uint16_t * zigzag,
299 :     uint16_t intra)
300 : edgomez 1.7 {
301 :    
302 : Isibaar 1.1 uint32_t j, last;
303 :     short v;
304 :     VLC *vlc;
305 : edgomez 1.17
306 : Isibaar 1.1 j = intra;
307 : Isibaar 1.10 last = intra;
308 : Isibaar 1.1
309 : edgomez 1.17 while (j < 64 && (v = qcoeff[zigzag[j]]) == 0)
310 :     j++;
311 :    
312 : Isibaar 1.1 do {
313 : Isibaar 1.15 vlc = table + 64 * 2047 + (v << 6) + j - last;
314 :     last = ++j;
315 :    
316 : Isibaar 1.1 // count zeroes
317 : edgomez 1.17 while (j < 64 && (v = qcoeff[zigzag[j]]) == 0)
318 :     j++;
319 :    
320 : Isibaar 1.1 // write code
321 : edgomez 1.17 if (j != 64) {
322 : Isibaar 1.1 BitstreamPutBits(bs, vlc->code, vlc->len);
323 :     } else {
324 : Isibaar 1.15 vlc += 64 * 4095;
325 : Isibaar 1.1 BitstreamPutBits(bs, vlc->code, vlc->len);
326 :     break;
327 :     }
328 : edgomez 1.17 } while (1);
329 : edgomez 1.7
330 : Isibaar 1.1 }
331 :    
332 :    
333 : chl 1.25.2.1 static __inline void
334 : chl 1.25.2.3 CodeBlockIntra(const FRAMEINFO * const frame,
335 : edgomez 1.17 const MACROBLOCK * pMB,
336 :     int16_t qcoeff[6 * 64],
337 : edgomez 1.7 Bitstream * bs,
338 :     Statistics * pStat)
339 : Isibaar 1.1 {
340 : edgomez 1.7
341 : Isibaar 1.1 uint32_t i, mcbpc, cbpy, bits;
342 :    
343 :     cbpy = pMB->cbp >> 2;
344 :    
345 : edgomez 1.7 // write mcbpc
346 : edgomez 1.17 if (frame->coding_type == I_VOP) {
347 : edgomez 1.7 mcbpc = ((pMB->mode >> 1) & 3) | ((pMB->cbp & 3) << 2);
348 : edgomez 1.17 BitstreamPutBits(bs, mcbpc_intra_tab[mcbpc].code,
349 :     mcbpc_intra_tab[mcbpc].len);
350 :     } else {
351 : edgomez 1.7 mcbpc = (pMB->mode & 7) | ((pMB->cbp & 3) << 3);
352 : edgomez 1.17 BitstreamPutBits(bs, mcbpc_inter_tab[mcbpc].code,
353 :     mcbpc_inter_tab[mcbpc].len);
354 : Isibaar 1.4 }
355 : Isibaar 1.1
356 :     // ac prediction flag
357 : edgomez 1.17 if (pMB->acpred_directions[0])
358 : edgomez 1.7 BitstreamPutBits(bs, 1, 1);
359 : Isibaar 1.1 else
360 : edgomez 1.7 BitstreamPutBits(bs, 0, 1);
361 : Isibaar 1.1
362 : edgomez 1.7 // write cbpy
363 : edgomez 1.17 BitstreamPutBits(bs, cbpy_tab[cbpy].code, cbpy_tab[cbpy].len);
364 : Isibaar 1.1
365 :     // write dquant
366 : edgomez 1.17 if (pMB->mode == MODE_INTRA_Q)
367 : Isibaar 1.1 BitstreamPutBits(bs, pMB->dquant, 2);
368 :    
369 : h 1.6 // write interlacing
370 : edgomez 1.17 if (frame->global_flags & XVID_INTERLACING) {
371 : h 1.6 BitstreamPutBit(bs, pMB->field_dct);
372 :     }
373 : Isibaar 1.1 // code block coeffs
374 : edgomez 1.17 for (i = 0; i < 6; i++) {
375 :     if (i < 4)
376 :     BitstreamPutBits(bs, dcy_tab[qcoeff[i * 64 + 0] + 255].code,
377 :     dcy_tab[qcoeff[i * 64 + 0] + 255].len);
378 : Isibaar 1.1 else
379 : edgomez 1.17 BitstreamPutBits(bs, dcc_tab[qcoeff[i * 64 + 0] + 255].code,
380 :     dcc_tab[qcoeff[i * 64 + 0] + 255].len);
381 :    
382 :     if (pMB->cbp & (1 << (5 - i))) {
383 : h 1.25.2.2 const uint16_t *scan_table =
384 :     frame->global_flags & XVID_ALTERNATESCAN ?
385 :     scan_tables[2] : scan_tables[pMB->acpred_directions[i]];
386 :    
387 : Isibaar 1.1 bits = BitstreamPos(bs);
388 :    
389 : h 1.25.2.2 CodeCoeff(bs, &qcoeff[i * 64], intra_table, scan_table, 1);
390 : Isibaar 1.1
391 :     bits = BitstreamPos(bs) - bits;
392 :     pStat->iTextBits += bits;
393 :     }
394 :     }
395 : edgomez 1.7
396 : Isibaar 1.1 }
397 :    
398 :    
399 : edgomez 1.17 static void
400 : chl 1.25.2.3 CodeBlockInter(const FRAMEINFO * const frame,
401 : edgomez 1.17 const MACROBLOCK * pMB,
402 :     int16_t qcoeff[6 * 64],
403 : edgomez 1.7 Bitstream * bs,
404 :     Statistics * pStat)
405 : Isibaar 1.1 {
406 : edgomez 1.7
407 : Isibaar 1.1 int32_t i;
408 :     uint32_t bits, mcbpc, cbpy;
409 :    
410 : edgomez 1.7 mcbpc = (pMB->mode & 7) | ((pMB->cbp & 3) << 3);
411 : Isibaar 1.1 cbpy = 15 - (pMB->cbp >> 2);
412 :    
413 :     // write mcbpc
414 : edgomez 1.17 BitstreamPutBits(bs, mcbpc_inter_tab[mcbpc].code,
415 :     mcbpc_inter_tab[mcbpc].len);
416 : Isibaar 1.1
417 : chl 1.25.2.3 if ( (frame->coding_type == S_VOP) && (pMB->mode == MODE_INTER || pMB->mode == MODE_INTER_Q) )
418 :     {
419 : chl 1.25.2.10 /* decision on GMC is done in encoder.c now */
420 :     BitstreamPutBit(bs, pMB->mcsel); // mcsel: '0'=local motion, '1'=GMC
421 : chl 1.25.2.3 }
422 :    
423 : Isibaar 1.1 // write cbpy
424 :     BitstreamPutBits(bs, cbpy_tab[cbpy].code, cbpy_tab[cbpy].len);
425 :    
426 :     // write dquant
427 : edgomez 1.17 if (pMB->mode == MODE_INTER_Q)
428 : Isibaar 1.1 BitstreamPutBits(bs, pMB->dquant, 2);
429 : edgomez 1.17
430 : h 1.6 // interlacing
431 : edgomez 1.17 if (frame->global_flags & XVID_INTERLACING) {
432 : h 1.25 if (pMB->cbp) {
433 :     BitstreamPutBit(bs, pMB->field_dct);
434 : suxen_drol 1.25.2.6 DPRINTF(DPRINTF_MB,"codep: field_dct: %i", pMB->field_dct);
435 : h 1.25 }
436 : h 1.6
437 :     // if inter block, write field ME flag
438 : edgomez 1.17 if (pMB->mode == MODE_INTER || pMB->mode == MODE_INTER_Q) {
439 : h 1.6 BitstreamPutBit(bs, pMB->field_pred);
440 : suxen_drol 1.25.2.6 DPRINTF(DPRINTF_MB,"codep: field_pred: %i", pMB->field_pred);
441 : h 1.6
442 :     // write field prediction references
443 : edgomez 1.17 if (pMB->field_pred) {
444 : h 1.6 BitstreamPutBit(bs, pMB->field_for_top);
445 :     BitstreamPutBit(bs, pMB->field_for_bot);
446 :     }
447 :     }
448 :     }
449 : chl 1.25.2.3 // code motion vector(s) if motion is local
450 : chl 1.25.2.10 if (!pMB->mcsel)
451 : chl 1.25.2.3 for (i = 0; i < (pMB->mode == MODE_INTER4V ? 4 : 1); i++) {
452 :     CodeVector(bs, pMB->pmvs[i].x, frame->fcode, pStat);
453 :     CodeVector(bs, pMB->pmvs[i].y, frame->fcode, pStat);
454 :     }
455 : Isibaar 1.1
456 :     bits = BitstreamPos(bs);
457 : edgomez 1.17
458 : Isibaar 1.1 // code block coeffs
459 : edgomez 1.17 for (i = 0; i < 6; i++)
460 :     if (pMB->cbp & (1 << (5 - i)))
461 : h 1.25.2.2 {
462 :     const uint16_t *scan_table =
463 :     frame->global_flags & XVID_ALTERNATESCAN ?
464 :     scan_tables[2] : scan_tables[0];
465 :    
466 :     CodeCoeff(bs, &qcoeff[i * 64], inter_table, scan_table, 0);
467 :     }
468 : Isibaar 1.1
469 :     bits = BitstreamPos(bs) - bits;
470 :     pStat->iTextBits += bits;
471 :     }
472 :    
473 :    
474 : edgomez 1.17 void
475 : chl 1.25.2.3 MBCoding(const FRAMEINFO * const frame,
476 : edgomez 1.17 MACROBLOCK * pMB,
477 :     int16_t qcoeff[6 * 64],
478 :     Bitstream * bs,
479 :     Statistics * pStat)
480 : Isibaar 1.1 {
481 : chl 1.25.2.3 if (frame->coding_type != I_VOP)
482 :     BitstreamPutBit(bs, 0); // not_coded
483 :    
484 : chl 1.22 if (pMB->mode == MODE_INTRA || pMB->mode == MODE_INTRA_Q)
485 : suxen_drol 1.13 CodeBlockIntra(frame, pMB, qcoeff, bs, pStat);
486 : Isibaar 1.1 else
487 : suxen_drol 1.13 CodeBlockInter(frame, pMB, qcoeff, bs, pStat);
488 : edgomez 1.7
489 : Isibaar 1.1 }
490 : chl 1.24
491 : chl 1.25.2.1 /*
492 :     // moved to mbcoding.h so that in can be 'static __inline'
493 : chl 1.24 void
494 :     MBSkip(Bitstream * bs)
495 :     {
496 :     BitstreamPutBit(bs, 1); // not coded
497 :     }
498 : chl 1.25.2.1 */
499 : suxen_drol 1.11
500 :     /***************************************************************
501 :     * bframe encoding start
502 :     ***************************************************************/
503 :    
504 :     /*
505 :     mbtype
506 :     0 1b direct(h263) mvdb
507 :     1 01b interpolate mc+q dbquant, mvdf, mvdb
508 :     2 001b backward mc+q dbquant, mvdb
509 :     3 0001b forward mc+q dbquant, mvdf
510 :     */
511 :    
512 : chl 1.25.2.1 static __inline void
513 : edgomez 1.17 put_bvop_mbtype(Bitstream * bs,
514 :     int value)
515 :     {
516 :     switch (value) {
517 : chl 1.25.2.1 case MODE_FORWARD:
518 :     BitstreamPutBit(bs, 0);
519 :     case MODE_BACKWARD:
520 :     BitstreamPutBit(bs, 0);
521 :     case MODE_INTERPOLATE:
522 :     BitstreamPutBit(bs, 0);
523 :     case MODE_DIRECT:
524 :     BitstreamPutBit(bs, 1);
525 :     default:
526 :     break;
527 : suxen_drol 1.11 }
528 :     }
529 :    
530 :     /*
531 :     dbquant
532 :     -2 10b
533 :     0 0b
534 :     +2 11b
535 :     */
536 :    
537 : chl 1.25.2.1 static __inline void
538 : edgomez 1.17 put_bvop_dbquant(Bitstream * bs,
539 :     int value)
540 :     {
541 :     switch (value) {
542 :     case 0:
543 :     BitstreamPutBit(bs, 0);
544 :     return;
545 :    
546 :     case -2:
547 :     BitstreamPutBit(bs, 1);
548 :     BitstreamPutBit(bs, 0);
549 :     return;
550 : suxen_drol 1.11
551 : edgomez 1.17 case 2:
552 :     BitstreamPutBit(bs, 1);
553 :     BitstreamPutBit(bs, 1);
554 :     return;
555 : suxen_drol 1.11
556 : edgomez 1.17 default:; // invalid
557 : suxen_drol 1.11 }
558 :     }
559 :    
560 :    
561 :    
562 : edgomez 1.17 void
563 :     MBCodingBVOP(const MACROBLOCK * mb,
564 :     const int16_t qcoeff[6 * 64],
565 :     const int32_t fcode,
566 :     const int32_t bcode,
567 :     Bitstream * bs,
568 : h 1.25.2.2 Statistics * pStat,
569 :     int direction)
570 : suxen_drol 1.11 {
571 : chl 1.25.2.1 int vcode = fcode;
572 :     unsigned int i;
573 : suxen_drol 1.11
574 :     /* ------------------------------------------------------------------
575 : chl 1.21 when a block is skipped it is decoded DIRECT(0,0)
576 :     hence is interpolated from forward & backward frames
577 : suxen_drol 1.11 ------------------------------------------------------------------ */
578 :    
579 : chl 1.21 if (mb->mode == MODE_DIRECT_NONE_MV) {
580 : edgomez 1.17 BitstreamPutBit(bs, 1); // skipped
581 : suxen_drol 1.11 return;
582 :     }
583 :    
584 :     BitstreamPutBit(bs, 0); // not skipped
585 :    
586 : edgomez 1.17 if (mb->cbp == 0) {
587 :     BitstreamPutBit(bs, 1); // cbp == 0
588 :     } else {
589 :     BitstreamPutBit(bs, 0); // cbp == xxx
590 : suxen_drol 1.11 }
591 :    
592 :     put_bvop_mbtype(bs, mb->mode);
593 :    
594 : edgomez 1.17 if (mb->cbp) {
595 : suxen_drol 1.11 BitstreamPutBits(bs, mb->cbp, 6);
596 :     }
597 :    
598 : edgomez 1.17 if (mb->mode != MODE_DIRECT && mb->cbp != 0) {
599 :     put_bvop_dbquant(bs, 0); // todo: mb->dquant = 0
600 : suxen_drol 1.11 }
601 :    
602 : chl 1.25.2.1 switch (mb->mode) {
603 :     case MODE_INTERPOLATE:
604 :     CodeVector(bs, mb->pmvs[1].x, vcode, pStat); //forward vector of interpolate mode
605 :     CodeVector(bs, mb->pmvs[1].y, vcode, pStat);
606 :     case MODE_BACKWARD:
607 :     vcode = bcode;
608 :     case MODE_FORWARD:
609 :     CodeVector(bs, mb->pmvs[0].x, vcode, pStat);
610 :     CodeVector(bs, mb->pmvs[0].y, vcode, pStat);
611 :     break;
612 :     case MODE_DIRECT:
613 :     CodeVector(bs, mb->pmvs[3].x, 1, pStat); // fcode is always 1 for delta vector
614 :     CodeVector(bs, mb->pmvs[3].y, 1, pStat); // prediction is always (0,0)
615 :     default: break;
616 : suxen_drol 1.11 }
617 : edgomez 1.17
618 :     for (i = 0; i < 6; i++) {
619 :     if (mb->cbp & (1 << (5 - i))) {
620 : h 1.25.2.2 CodeCoeff(bs, &qcoeff[i * 64], inter_table, scan_tables[direction], 0);
621 : suxen_drol 1.11 }
622 : edgomez 1.17 }
623 : suxen_drol 1.11 }
624 :    
625 : Isibaar 1.1
626 :    
627 :     /***************************************************************
628 : edgomez 1.2 * decoding stuff starts here *
629 :     ***************************************************************/
630 : Isibaar 1.1
631 : suxen_drol 1.19
632 :     // for IVOP addbits == 0
633 :     // for PVOP addbits == fcode - 1
634 :     // for BVOP addbits == max(fcode,bcode) - 1
635 :     // returns true or false
636 :     int
637 :     check_resync_marker(Bitstream * bs, int addbits)
638 :     {
639 :     uint32_t nbits;
640 :     uint32_t code;
641 :     uint32_t nbitsresyncmarker = NUMBITS_VP_RESYNC_MARKER + addbits;
642 :    
643 :     nbits = BitstreamNumBitsToByteAlign(bs);
644 :     code = BitstreamShowBits(bs, nbits);
645 :    
646 :     if (code == (((uint32_t)1 << (nbits - 1)) - 1))
647 :     {
648 :     return BitstreamShowBitsFromByteAlign(bs, nbitsresyncmarker) == RESYNC_MARKER;
649 :     }
650 :    
651 :     return 0;
652 :     }
653 :    
654 :    
655 :    
656 : edgomez 1.17 int
657 :     get_mcbpc_intra(Bitstream * bs)
658 : Isibaar 1.1 {
659 : edgomez 1.7
660 : Isibaar 1.1 uint32_t index;
661 : edgomez 1.17
662 : suxen_drol 1.19 index = BitstreamShowBits(bs, 9);
663 : Isibaar 1.1 index >>= 3;
664 :    
665 :     BitstreamSkip(bs, mcbpc_intra_table[index].len);
666 : edgomez 1.7
667 : Isibaar 1.1 return mcbpc_intra_table[index].code;
668 : edgomez 1.7
669 : Isibaar 1.1 }
670 :    
671 : edgomez 1.17 int
672 :     get_mcbpc_inter(Bitstream * bs)
673 : Isibaar 1.1 {
674 : edgomez 1.7
675 : Isibaar 1.1 uint32_t index;
676 : suxen_drol 1.19
677 : suxen_drol 1.25.2.9 index = MIN(BitstreamShowBits(bs, 9), 256);
678 : Isibaar 1.1
679 : edgomez 1.17 BitstreamSkip(bs, mcbpc_inter_table[index].len);
680 : edgomez 1.7
681 : Isibaar 1.1 return mcbpc_inter_table[index].code;
682 : edgomez 1.7
683 : Isibaar 1.1 }
684 :    
685 : edgomez 1.17 int
686 :     get_cbpy(Bitstream * bs,
687 :     int intra)
688 : Isibaar 1.1 {
689 : edgomez 1.7
690 : Isibaar 1.1 int cbpy;
691 :     uint32_t index = BitstreamShowBits(bs, 6);
692 :    
693 :     BitstreamSkip(bs, cbpy_table[index].len);
694 :     cbpy = cbpy_table[index].code;
695 :    
696 : edgomez 1.17 if (!intra)
697 : Isibaar 1.1 cbpy = 15 - cbpy;
698 :    
699 :     return cbpy;
700 : edgomez 1.7
701 : Isibaar 1.1 }
702 :    
703 : chl 1.25.2.1 static __inline int
704 : edgomez 1.17 get_mv_data(Bitstream * bs)
705 : Isibaar 1.1 {
706 : edgomez 1.7
707 : Isibaar 1.1 uint32_t index;
708 :    
709 : edgomez 1.17 if (BitstreamGetBit(bs))
710 : Isibaar 1.1 return 0;
711 : edgomez 1.17
712 : Isibaar 1.1 index = BitstreamShowBits(bs, 12);
713 :    
714 : edgomez 1.17 if (index >= 512) {
715 : Isibaar 1.1 index = (index >> 8) - 2;
716 :     BitstreamSkip(bs, TMNMVtab0[index].len);
717 :     return TMNMVtab0[index].code;
718 :     }
719 : edgomez 1.17
720 :     if (index >= 128) {
721 : Isibaar 1.1 index = (index >> 2) - 32;
722 :     BitstreamSkip(bs, TMNMVtab1[index].len);
723 :     return TMNMVtab1[index].code;
724 :     }
725 :    
726 : edgomez 1.17 index -= 4;
727 : Isibaar 1.1
728 :     BitstreamSkip(bs, TMNMVtab2[index].len);
729 :     return TMNMVtab2[index].code;
730 : edgomez 1.7
731 : Isibaar 1.1 }
732 :    
733 : edgomez 1.17 int
734 :     get_mv(Bitstream * bs,
735 :     int fcode)
736 : Isibaar 1.1 {
737 : edgomez 1.7
738 : Isibaar 1.1 int data;
739 :     int res;
740 :     int mv;
741 :     int scale_fac = 1 << (fcode - 1);
742 :    
743 :     data = get_mv_data(bs);
744 : edgomez 1.17
745 :     if (scale_fac == 1 || data == 0)
746 : Isibaar 1.1 return data;
747 :    
748 :     res = BitstreamGetBits(bs, fcode - 1);
749 :     mv = ((ABS(data) - 1) * scale_fac) + res + 1;
750 : edgomez 1.17
751 : Isibaar 1.1 return data < 0 ? -mv : mv;
752 : edgomez 1.7
753 : Isibaar 1.1 }
754 :    
755 : edgomez 1.17 int
756 :     get_dc_dif(Bitstream * bs,
757 :     uint32_t dc_size)
758 : Isibaar 1.1 {
759 : edgomez 1.7
760 : Isibaar 1.1 int code = BitstreamGetBits(bs, dc_size);
761 :     int msb = code >> (dc_size - 1);
762 :    
763 : edgomez 1.17 if (msb == 0)
764 :     return (-1 * (code ^ ((1 << dc_size) - 1)));
765 : Isibaar 1.1
766 :     return code;
767 : edgomez 1.7
768 : Isibaar 1.1 }
769 :    
770 : edgomez 1.17 int
771 :     get_dc_size_lum(Bitstream * bs)
772 : Isibaar 1.1 {
773 : edgomez 1.7
774 : Isibaar 1.1 int code, i;
775 : edgomez 1.17
776 : Isibaar 1.1 code = BitstreamShowBits(bs, 11);
777 :    
778 : edgomez 1.17 for (i = 11; i > 3; i--) {
779 :     if (code == 1) {
780 : Isibaar 1.1 BitstreamSkip(bs, i);
781 :     return i + 1;
782 :     }
783 :     code >>= 1;
784 :     }
785 :    
786 :     BitstreamSkip(bs, dc_lum_tab[code].len);
787 :     return dc_lum_tab[code].code;
788 : edgomez 1.7
789 : Isibaar 1.1 }
790 :    
791 :    
792 : edgomez 1.17 int
793 :     get_dc_size_chrom(Bitstream * bs)
794 : Isibaar 1.1 {
795 : edgomez 1.7
796 : Isibaar 1.1 uint32_t code, i;
797 : edgomez 1.17
798 : Isibaar 1.1 code = BitstreamShowBits(bs, 12);
799 :    
800 : edgomez 1.17 for (i = 12; i > 2; i--) {
801 :     if (code == 1) {
802 : Isibaar 1.1 BitstreamSkip(bs, i);
803 :     return i;
804 :     }
805 :     code >>= 1;
806 :     }
807 :    
808 :     return 3 - BitstreamGetBits(bs, 2);
809 : edgomez 1.7
810 : Isibaar 1.1 }
811 :    
812 : edgomez 1.17 void
813 :     get_intra_block(Bitstream * bs,
814 :     int16_t * block,
815 :     int direction,
816 :     int coeff)
817 : Isibaar 1.1 {
818 : edgomez 1.7
819 : edgomez 1.17 const uint16_t *scan = scan_tables[direction];
820 : chl 1.25.2.1 int level, run, last;
821 : Isibaar 1.1
822 : edgomez 1.17 do {
823 : Isibaar 1.1 level = get_coeff(bs, &run, &last, 1, 0);
824 : edgomez 1.17 if (run == -1) {
825 : suxen_drol 1.25.2.6 DPRINTF(DPRINTF_ERROR,"fatal: invalid run");
826 : Isibaar 1.1 break;
827 :     }
828 :     coeff += run;
829 : edgomez 1.17 block[scan[coeff]] = level;
830 : suxen_drol 1.20
831 :     DPRINTF(DPRINTF_COEFF,"block[%i] %i", scan[coeff], level);
832 :     //DPRINTF(DPRINTF_COEFF,"block[%i] %i %08x", scan[coeff], level, BitstreamShowBits(bs, 32));
833 :    
834 : suxen_drol 1.25.2.8 if (level < -2047 || level > 2047) {
835 : suxen_drol 1.25.2.6 DPRINTF(DPRINTF_ERROR,"warning: intra_overflow %i", level);
836 : Isibaar 1.1 }
837 :     coeff++;
838 :     } while (!last);
839 : edgomez 1.7
840 : Isibaar 1.1 }
841 :    
842 : edgomez 1.17 void
843 :     get_inter_block(Bitstream * bs,
844 : h 1.25.2.2 int16_t * block,
845 :     int direction)
846 : Isibaar 1.1 {
847 : edgomez 1.7
848 : h 1.25.2.2 const uint16_t *scan = scan_tables[direction];
849 : Isibaar 1.1 int p;
850 :     int level;
851 :     int run;
852 :     int last;
853 :    
854 :     p = 0;
855 : edgomez 1.17 do {
856 : Isibaar 1.1 level = get_coeff(bs, &run, &last, 0, 0);
857 : edgomez 1.17 if (run == -1) {
858 : suxen_drol 1.25.2.6 DPRINTF(DPRINTF_ERROR,"fatal: invalid run");
859 : Isibaar 1.1 break;
860 :     }
861 :     p += run;
862 : chenm001 1.16
863 : edgomez 1.17 block[scan[p]] = level;
864 : suxen_drol 1.20
865 :     DPRINTF(DPRINTF_COEFF,"block[%i] %i", scan[p], level);
866 :     // DPRINTF(DPRINTF_COEFF,"block[%i] %i %08x", scan[p], level, BitstreamShowBits(bs, 32));
867 :    
868 : suxen_drol 1.25.2.8 if (level < -2047 || level > 2047) {
869 : suxen_drol 1.25.2.6 DPRINTF(DPRINTF_ERROR,"warning: inter overflow %i", level);
870 : Isibaar 1.1 }
871 :     p++;
872 :     } while (!last);
873 : edgomez 1.7
874 : Isibaar 1.1 }
No admin address has been configured
 ViewVC Help
Powered by ViewVC 1.0.4