1 /*****************************************************************************
2 *
3 * XVID MPEG-4 VIDEO CODEC
4 * - MB coding -
5 *
6 * Copyright (C) 2002 Michael Militzer <isibaar@xvid.org>
7 *
8 * This program is free software ; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation ; either version 2 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY ; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program ; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 *
22 * $Id: mbcoding.c 2180 2019-11-12 14:48:35Z Isibaar $
23 *
24 ****************************************************************************/
25
26 #include <stdio.h>
27 #include <stdlib.h>
28 #include <string.h>
29
30 #include "../portab.h"
31 #include "../global.h"
32 #include "bitstream.h"
33 #include "zigzag.h"
34 #include "vlc_codes.h"
35 #include "mbcoding.h"
36
37 #include "../utils/mbfunctions.h"
38
39 #ifdef _DEBUG
40 # include "../motion/estimation.h"
41 # include "../motion/motion_inlines.h"
42 # include <assert.h>
43 #endif
44
45
46 #define LEVELOFFSET 32
47
48 /* Initialized once during xvid_global call
49 * RO access is thread safe */
50 static REVERSE_EVENT DCT3D[2][4096];
51 static VLC coeff_VLC[2][2][64][64];
52
53 /* not really MB related, but VLCs are only available here */
bs_put_spritetrajectory(Bitstream * bs,const int val)54 void bs_put_spritetrajectory(Bitstream * bs, const int val)
55 {
56 const int code = sprite_trajectory_code[val+16384].code;
57 const int len = sprite_trajectory_code[val+16384].len;
58 const int code2 = sprite_trajectory_len[len].code;
59 const int len2 = sprite_trajectory_len[len].len;
60
61 #if 0
62 printf("GMC=%d Code/Len = %d / %d ",val, code,len);
63 printf("Code2 / Len2 = %d / %d \n",code2,len2);
64 #endif
65
66 BitstreamPutBits(bs, code2, len2);
67 if (len) BitstreamPutBits(bs, code, len);
68 }
69
bs_get_spritetrajectory(Bitstream * bs)70 int bs_get_spritetrajectory(Bitstream * bs)
71 {
72 int i;
73 for (i = 0; i < 12; i++)
74 {
75 if (BitstreamShowBits(bs, sprite_trajectory_len[i].len) == sprite_trajectory_len[i].code)
76 {
77 BitstreamSkip(bs, sprite_trajectory_len[i].len);
78 return i;
79 }
80 }
81 return -1;
82 }
83
84 void
init_vlc_tables(void)85 init_vlc_tables(void)
86 {
87 uint32_t i, j, k, intra, last, run, run_esc, level, level_esc, escape, escape_len, offset;
88 int32_t l;
89
90 for (intra = 0; intra < 2; intra++)
91 for (i = 0; i < 4096; i++)
92 DCT3D[intra][i].event.level = 0;
93
94 for (intra = 0; intra < 2; intra++) {
95 for (last = 0; last < 2; last++) {
96 for (run = 0; run < 63 + last; run++) {
97 for (level = 0; level < (uint32_t)(32 << intra); level++) {
98 offset = !intra * LEVELOFFSET;
99 coeff_VLC[intra][last][level + offset][run].len = 128;
100 }
101 }
102 }
103 }
104
105 for (intra = 0; intra < 2; intra++) {
106 for (i = 0; i < 102; i++) {
107 offset = !intra * LEVELOFFSET;
108
109 for (j = 0; j < (uint32_t)(1 << (12 - coeff_tab[intra][i].vlc.len)); j++) {
110 DCT3D[intra][(coeff_tab[intra][i].vlc.code << (12 - coeff_tab[intra][i].vlc.len)) | j].len = coeff_tab[intra][i].vlc.len;
111 DCT3D[intra][(coeff_tab[intra][i].vlc.code << (12 - coeff_tab[intra][i].vlc.len)) | j].event = coeff_tab[intra][i].event;
112 }
113
114 coeff_VLC[intra][coeff_tab[intra][i].event.last][coeff_tab[intra][i].event.level + offset][coeff_tab[intra][i].event.run].code
115 = coeff_tab[intra][i].vlc.code << 1;
116 coeff_VLC[intra][coeff_tab[intra][i].event.last][coeff_tab[intra][i].event.level + offset][coeff_tab[intra][i].event.run].len
117 = coeff_tab[intra][i].vlc.len + 1;
118
119 if (!intra) {
120 coeff_VLC[intra][coeff_tab[intra][i].event.last][offset - coeff_tab[intra][i].event.level][coeff_tab[intra][i].event.run].code
121 = (coeff_tab[intra][i].vlc.code << 1) | 1;
122 coeff_VLC[intra][coeff_tab[intra][i].event.last][offset - coeff_tab[intra][i].event.level][coeff_tab[intra][i].event.run].len
123 = coeff_tab[intra][i].vlc.len + 1;
124 }
125 }
126 }
127
128 for (intra = 0; intra < 2; intra++) {
129 for (last = 0; last < 2; last++) {
130 for (run = 0; run < 63 + last; run++) {
131 for (level = 1; level < (uint32_t)(32 << intra); level++) {
132
133 if (level <= max_level[intra][last][run] && run <= max_run[intra][last][level])
134 continue;
135
136 offset = !intra * LEVELOFFSET;
137 level_esc = level - max_level[intra][last][run];
138 run_esc = run - 1 - max_run[intra][last][level];
139
140 if (level_esc <= max_level[intra][last][run] && run <= max_run[intra][last][level_esc]) {
141 escape = ESCAPE1;
142 escape_len = 7 + 1;
143 run_esc = run;
144 } else {
145 if (run_esc <= max_run[intra][last][level] && level <= max_level[intra][last][run_esc]) {
146 escape = ESCAPE2;
147 escape_len = 7 + 2;
148 level_esc = level;
149 } else {
150 if (!intra) {
151 coeff_VLC[intra][last][level + offset][run].code
152 = (ESCAPE3 << 21) | (last << 20) | (run << 14) | (1 << 13) | ((level & 0xfff) << 1) | 1;
153 coeff_VLC[intra][last][level + offset][run].len = 30;
154 coeff_VLC[intra][last][offset - level][run].code
155 = (ESCAPE3 << 21) | (last << 20) | (run << 14) | (1 << 13) | ((-(int32_t)level & 0xfff) << 1) | 1;
156 coeff_VLC[intra][last][offset - level][run].len = 30;
157 }
158 continue;
159 }
160 }
161
162 coeff_VLC[intra][last][level + offset][run].code
163 = (escape << coeff_VLC[intra][last][level_esc + offset][run_esc].len)
164 | coeff_VLC[intra][last][level_esc + offset][run_esc].code;
165 coeff_VLC[intra][last][level + offset][run].len
166 = coeff_VLC[intra][last][level_esc + offset][run_esc].len + escape_len;
167
168 if (!intra) {
169 coeff_VLC[intra][last][offset - level][run].code
170 = (escape << coeff_VLC[intra][last][level_esc + offset][run_esc].len)
171 | coeff_VLC[intra][last][level_esc + offset][run_esc].code | 1;
172 coeff_VLC[intra][last][offset - level][run].len
173 = coeff_VLC[intra][last][level_esc + offset][run_esc].len + escape_len;
174 }
175 }
176
177 if (!intra) {
178 coeff_VLC[intra][last][0][run].code
179 = (ESCAPE3 << 21) | (last << 20) | (run << 14) | (1 << 13) | ((-32 & 0xfff) << 1) | 1;
180 coeff_VLC[intra][last][0][run].len = 30;
181 }
182 }
183 }
184 }
185
186 /* init sprite_trajectory tables
187 * even if GMC is not specified (it might be used later...) */
188
189 sprite_trajectory_code[0+16384].code = 0;
190 sprite_trajectory_code[0+16384].len = 0;
191 for (k=0;k<14;k++) {
192 int limit = (1<<k);
193
194 for (l=-(2*limit-1); l <= -limit; l++) {
195 sprite_trajectory_code[l+16384].code = (2*limit-1)+l;
196 sprite_trajectory_code[l+16384].len = k+1;
197 }
198
199 for (l=limit; l<= 2*limit-1; l++) {
200 sprite_trajectory_code[l+16384].code = l;
201 sprite_trajectory_code[l+16384].len = k+1;
202 }
203 }
204 }
205
206 static __inline void
CodeVector(Bitstream * bs,int32_t value,int32_t f_code)207 CodeVector(Bitstream * bs,
208 int32_t value,
209 int32_t f_code)
210 {
211
212 const int scale_factor = 1 << (f_code - 1);
213 const int cmp = scale_factor << 5;
214
215 if (value < (-1 * cmp))
216 value += 64 * scale_factor;
217
218 if (value > (cmp - 1))
219 value -= 64 * scale_factor;
220
221 if (value == 0) {
222 BitstreamPutBits(bs, mb_motion_table[32].code,
223 mb_motion_table[32].len);
224 } else {
225 uint16_t length, code, mv_res, sign;
226
227 length = 16 << f_code;
228 f_code--;
229
230 sign = (value < 0);
231
232 if (value >= length)
233 value -= 2 * length;
234 else if (value < -length)
235 value += 2 * length;
236
237 if (sign)
238 value = -value;
239
240 value--;
241 mv_res = value & ((1 << f_code) - 1);
242 code = ((value - mv_res) >> f_code) + 1;
243
244 if (sign)
245 code = -code;
246
247 code += 32;
248 BitstreamPutBits(bs, mb_motion_table[code].code,
249 mb_motion_table[code].len);
250
251 if (f_code)
252 BitstreamPutBits(bs, mv_res, f_code);
253 }
254
255 }
256
257 static __inline void
CodeCoeffInter(Bitstream * bs,const int16_t qcoeff[64],const uint16_t * zigzag)258 CodeCoeffInter(Bitstream * bs,
259 const int16_t qcoeff[64],
260 const uint16_t * zigzag)
261 {
262 uint32_t i, run, prev_run, code, len;
263 int32_t level, prev_level, level_shifted;
264
265 i = 0;
266 run = 0;
267
268 while (!(level = qcoeff[zigzag[i++]]))
269 run++;
270
271 prev_level = level;
272 prev_run = run;
273 run = 0;
274
275 while (i < 64)
276 {
277 if ((level = qcoeff[zigzag[i++]]) != 0)
278 {
279 level_shifted = prev_level + 32;
280 if (!(level_shifted & -64))
281 {
282 code = coeff_VLC[0][0][level_shifted][prev_run].code;
283 len = coeff_VLC[0][0][level_shifted][prev_run].len;
284 }
285 else
286 {
287 code = (ESCAPE3 << 21) | (prev_run << 14) | (1 << 13) | ((prev_level & 0xfff) << 1) | 1;
288 len = 30;
289 }
290 BitstreamPutBits(bs, code, len);
291 prev_level = level;
292 prev_run = run;
293 run = 0;
294 }
295 else
296 run++;
297 }
298
299 level_shifted = prev_level + 32;
300 if (!(level_shifted & -64))
301 {
302 code = coeff_VLC[0][1][level_shifted][prev_run].code;
303 len = coeff_VLC[0][1][level_shifted][prev_run].len;
304 }
305 else
306 {
307 code = (ESCAPE3 << 21) | (1 << 20) | (prev_run << 14) | (1 << 13) | ((prev_level & 0xfff) << 1) | 1;
308 len = 30;
309 }
310 BitstreamPutBits(bs, code, len);
311 }
312
313 static __inline void
CodeCoeffIntra(Bitstream * bs,const int16_t qcoeff[64],const uint16_t * zigzag)314 CodeCoeffIntra(Bitstream * bs,
315 const int16_t qcoeff[64],
316 const uint16_t * zigzag)
317 {
318 uint32_t i, abs_level, run, prev_run, code, len;
319 int32_t level, prev_level;
320
321 i = 1;
322 run = 0;
323
324 while (i<64 && !(level = qcoeff[zigzag[i++]]))
325 run++;
326
327 prev_level = level;
328 prev_run = run;
329 run = 0;
330
331 while (i < 64)
332 {
333 if ((level = qcoeff[zigzag[i++]]) != 0)
334 {
335 abs_level = abs(prev_level);
336 abs_level = abs_level < 64 ? abs_level : 0;
337 code = coeff_VLC[1][0][abs_level][prev_run].code;
338 len = coeff_VLC[1][0][abs_level][prev_run].len;
339 if (len != 128)
340 code |= (prev_level < 0);
341 else
342 {
343 code = (ESCAPE3 << 21) | (prev_run << 14) | (1 << 13) | ((prev_level & 0xfff) << 1) | 1;
344 len = 30;
345 }
346 BitstreamPutBits(bs, code, len);
347 prev_level = level;
348 prev_run = run;
349 run = 0;
350 }
351 else
352 run++;
353 }
354
355 abs_level = abs(prev_level);
356 abs_level = abs_level < 64 ? abs_level : 0;
357 code = coeff_VLC[1][1][abs_level][prev_run].code;
358 len = coeff_VLC[1][1][abs_level][prev_run].len;
359 if (len != 128)
360 code |= (prev_level < 0);
361 else
362 {
363 code = (ESCAPE3 << 21) | (1 << 20) | (prev_run << 14) | (1 << 13) | ((prev_level & 0xfff) << 1) | 1;
364 len = 30;
365 }
366 BitstreamPutBits(bs, code, len);
367 }
368
369
370
371 /* returns the number of bits required to encode qcoeff */
372
373 int
CodeCoeffIntra_CalcBits(const int16_t qcoeff[64],const uint16_t * zigzag)374 CodeCoeffIntra_CalcBits(const int16_t qcoeff[64], const uint16_t * zigzag)
375 {
376 int bits = 0;
377 uint32_t i, abs_level, run, prev_run, len;
378 int32_t level, prev_level;
379
380 i = 1;
381 run = 0;
382
383 while (i<64 && !(level = qcoeff[zigzag[i++]]))
384 run++;
385
386 if (i >= 64) return 0; /* empty block */
387
388 prev_level = level;
389 prev_run = run;
390 run = 0;
391
392 while (i < 64)
393 {
394 if ((level = qcoeff[zigzag[i++]]) != 0)
395 {
396 abs_level = abs(prev_level);
397 abs_level = abs_level < 64 ? abs_level : 0;
398 len = coeff_VLC[1][0][abs_level][prev_run].len;
399 bits += len!=128 ? len : 30;
400
401 prev_level = level;
402 prev_run = run;
403 run = 0;
404 }
405 else
406 run++;
407 }
408
409 abs_level = abs(prev_level);
410 abs_level = abs_level < 64 ? abs_level : 0;
411 len = coeff_VLC[1][1][abs_level][prev_run].len;
412 bits += len!=128 ? len : 30;
413
414 return bits;
415 }
416
417 int
CodeCoeffInter_CalcBits(const int16_t qcoeff[64],const uint16_t * zigzag)418 CodeCoeffInter_CalcBits(const int16_t qcoeff[64], const uint16_t * zigzag)
419 {
420 uint32_t i, run, prev_run, len;
421 int32_t level, prev_level, level_shifted;
422 int bits = 0;
423
424 i = 0;
425 run = 0;
426
427 while (!(level = qcoeff[zigzag[i++]]))
428 run++;
429
430 prev_level = level;
431 prev_run = run;
432 run = 0;
433
434 while (i < 64) {
435 if ((level = qcoeff[zigzag[i++]]) != 0) {
436 level_shifted = prev_level + 32;
437 if (!(level_shifted & -64))
438 len = coeff_VLC[0][0][level_shifted][prev_run].len;
439 else
440 len = 30;
441
442 bits += len;
443 prev_level = level;
444 prev_run = run;
445 run = 0;
446 }
447 else
448 run++;
449 }
450
451 level_shifted = prev_level + 32;
452 if (!(level_shifted & -64))
453 len = coeff_VLC[0][1][level_shifted][prev_run].len;
454 else
455 len = 30;
456 bits += len;
457
458 return bits;
459 }
460
461 static const int iDQtab[5] = {
462 1, 0, -1 /* no change */, 2, 3
463 };
464 #define DQ_VALUE2INDEX(value) iDQtab[(value)+2]
465
466
467 static __inline void
CodeBlockIntra(const FRAMEINFO * const frame,const MACROBLOCK * pMB,int16_t qcoeff[6* 64],Bitstream * bs,Statistics * pStat)468 CodeBlockIntra(const FRAMEINFO * const frame,
469 const MACROBLOCK * pMB,
470 int16_t qcoeff[6 * 64],
471 Bitstream * bs,
472 Statistics * pStat)
473 {
474
475 uint32_t i, mcbpc, cbpy, bits;
476
477 cbpy = pMB->cbp >> 2;
478
479 /* write mcbpc */
480 if (frame->coding_type == I_VOP) {
481 mcbpc = ((pMB->mode >> 1) & 3) | ((pMB->cbp & 3) << 2);
482 BitstreamPutBits(bs, mcbpc_intra_tab[mcbpc].code,
483 mcbpc_intra_tab[mcbpc].len);
484 } else {
485 mcbpc = (pMB->mode & 7) | ((pMB->cbp & 3) << 3);
486 BitstreamPutBits(bs, mcbpc_inter_tab[mcbpc].code,
487 mcbpc_inter_tab[mcbpc].len);
488 }
489
490 /* ac prediction flag */
491 if (pMB->acpred_directions[0])
492 BitstreamPutBits(bs, 1, 1);
493 else
494 BitstreamPutBits(bs, 0, 1);
495
496 /* write cbpy */
497 BitstreamPutBits(bs, xvid_cbpy_tab[cbpy].code, xvid_cbpy_tab[cbpy].len);
498
499 /* write dquant */
500 if (pMB->mode == MODE_INTRA_Q)
501 BitstreamPutBits(bs, DQ_VALUE2INDEX(pMB->dquant), 2);
502
503 /* write interlacing */
504 if (frame->vol_flags & XVID_VOL_INTERLACING) {
505 BitstreamPutBit(bs, pMB->field_dct);
506 }
507 /* code block coeffs */
508 for (i = 0; i < 6; i++) {
509 if (i < 4)
510 BitstreamPutBits(bs, dcy_tab[qcoeff[i * 64 + 0] + 255].code,
511 dcy_tab[qcoeff[i * 64 + 0] + 255].len);
512 else
513 BitstreamPutBits(bs, dcc_tab[qcoeff[i * 64 + 0] + 255].code,
514 dcc_tab[qcoeff[i * 64 + 0] + 255].len);
515
516 if (pMB->cbp & (1 << (5 - i))) {
517 const uint16_t *scan_table =
518 frame->vop_flags & XVID_VOP_ALTERNATESCAN ?
519 scan_tables[2] : scan_tables[pMB->acpred_directions[i]];
520
521 bits = BitstreamPos(bs);
522
523 CodeCoeffIntra(bs, &qcoeff[i * 64], scan_table);
524
525 bits = BitstreamPos(bs) - bits;
526 pStat->iTextBits += bits;
527 }
528 }
529
530 }
531
532
533 static void
CodeBlockInter(const FRAMEINFO * const frame,const MACROBLOCK * pMB,int16_t qcoeff[6* 64],Bitstream * bs,Statistics * pStat)534 CodeBlockInter(const FRAMEINFO * const frame,
535 const MACROBLOCK * pMB,
536 int16_t qcoeff[6 * 64],
537 Bitstream * bs,
538 Statistics * pStat)
539 {
540
541 int32_t i;
542 uint32_t bits, mcbpc, cbpy;
543
544 mcbpc = (pMB->mode & 7) | ((pMB->cbp & 3) << 3);
545 cbpy = 15 - (pMB->cbp >> 2);
546
547 /* write mcbpc */
548 BitstreamPutBits(bs, mcbpc_inter_tab[mcbpc].code,
549 mcbpc_inter_tab[mcbpc].len);
550
551 if ( (frame->coding_type == S_VOP) && (pMB->mode == MODE_INTER || pMB->mode == MODE_INTER_Q) )
552 BitstreamPutBit(bs, pMB->mcsel); /* mcsel: '0'=local motion, '1'=GMC */
553
554 /* write cbpy */
555 BitstreamPutBits(bs, xvid_cbpy_tab[cbpy].code, xvid_cbpy_tab[cbpy].len);
556
557 /* write dquant */
558 if (pMB->mode == MODE_INTER_Q)
559 BitstreamPutBits(bs, DQ_VALUE2INDEX(pMB->dquant), 2);
560
561 /* interlacing */
562 if (frame->vol_flags & XVID_VOL_INTERLACING) {
563 if (pMB->cbp) {
564 BitstreamPutBit(bs, pMB->field_dct);
565 DPRINTF(XVID_DEBUG_MB,"codep: field_dct: %i\n", pMB->field_dct);
566 }
567
568 /* if inter block, write field ME flag */
569 if ((pMB->mode == MODE_INTER || pMB->mode == MODE_INTER_Q) && (pMB->mcsel == 0)) {
570 BitstreamPutBit(bs, 0 /*pMB->field_pred*/); /* not implemented yet */
571 DPRINTF(XVID_DEBUG_MB,"codep: field_pred: %i\n", pMB->field_pred);
572
573 /* write field prediction references */
574 #if 0 /* Remove the #if once field_pred is supported */
575 if (pMB->field_pred) {
576 BitstreamPutBit(bs, pMB->field_for_top);
577 BitstreamPutBit(bs, pMB->field_for_bot);
578 }
579 #endif
580 }
581 }
582
583 bits = BitstreamPos(bs);
584
585 /* code motion vector(s) if motion is local */
586 if (!pMB->mcsel)
587 for (i = 0; i < (pMB->mode == MODE_INTER4V ? 4 : 1); i++) {
588 CodeVector(bs, pMB->pmvs[i].x, frame->fcode);
589 CodeVector(bs, pMB->pmvs[i].y, frame->fcode);
590
591 #if 0 /* #ifdef _DEBUG */
592 if (i == 0) /* for simplicity */ {
593 int coded_length = BitstreamPos(bs) - bits;
594 int estimated_length = d_mv_bits(pMB->pmvs[i].x, pMB->pmvs[i].y, zeroMV, frame->fcode, 0);
595 assert(estimated_length == coded_length);
596 d_mv_bits(pMB->pmvs[i].x, pMB->pmvs[i].y, zeroMV, frame->fcode, 0);
597 }
598 #endif
599 }
600
601 bits = BitstreamPos(bs) - bits;
602 pStat->iMVBits += bits;
603
604 bits = BitstreamPos(bs);
605
606 /* code block coeffs */
607 for (i = 0; i < 6; i++)
608 if (pMB->cbp & (1 << (5 - i))) {
609 const uint16_t *scan_table =
610 frame->vop_flags & XVID_VOP_ALTERNATESCAN ?
611 scan_tables[2] : scan_tables[0];
612
613 CodeCoeffInter(bs, &qcoeff[i * 64], scan_table);
614 }
615
616 bits = BitstreamPos(bs) - bits;
617 pStat->iTextBits += bits;
618 }
619
620
621 void
MBCoding(const FRAMEINFO * const frame,MACROBLOCK * pMB,int16_t qcoeff[6* 64],Bitstream * bs,Statistics * pStat)622 MBCoding(const FRAMEINFO * const frame,
623 MACROBLOCK * pMB,
624 int16_t qcoeff[6 * 64],
625 Bitstream * bs,
626 Statistics * pStat)
627 {
628 if (frame->coding_type != I_VOP)
629 BitstreamPutBit(bs, 0); /* not_coded */
630
631 if (frame->vop_flags & XVID_VOP_GREYSCALE) {
632 pMB->cbp &= 0x3C; /* keep only bits 5-2 */
633 qcoeff[4*64+0]=0; /* for INTRA DC value is saved */
634 qcoeff[5*64+0]=0;
635 }
636
637 if (pMB->mode == MODE_INTRA || pMB->mode == MODE_INTRA_Q)
638 CodeBlockIntra(frame, pMB, qcoeff, bs, pStat);
639 else
640 CodeBlockInter(frame, pMB, qcoeff, bs, pStat);
641
642 }
643
644 /***************************************************************
645 * bframe encoding start
646 ***************************************************************/
647
648 /*
649 mbtype
650 0 1b direct(h263) mvdb
651 1 01b interpolate mc+q dbquant, mvdf, mvdb
652 2 001b backward mc+q dbquant, mvdb
653 3 0001b forward mc+q dbquant, mvdf
654 */
655
656 static __inline void
put_bvop_mbtype(Bitstream * bs,int value)657 put_bvop_mbtype(Bitstream * bs,
658 int value)
659 {
660 switch (value) {
661 case MODE_FORWARD:
662 BitstreamPutBit(bs, 0);
663 case MODE_BACKWARD:
664 BitstreamPutBit(bs, 0);
665 case MODE_INTERPOLATE:
666 BitstreamPutBit(bs, 0);
667 case MODE_DIRECT:
668 BitstreamPutBit(bs, 1);
669 default:
670 break;
671 }
672 }
673
674 /*
675 dbquant
676 -2 10b
677 0 0b
678 +2 11b
679 */
680
681 static __inline void
put_bvop_dbquant(Bitstream * bs,int value)682 put_bvop_dbquant(Bitstream * bs,
683 int value)
684 {
685 switch (value) {
686 case 0:
687 BitstreamPutBit(bs, 0);
688 return;
689
690 case -2:
691 BitstreamPutBit(bs, 1);
692 BitstreamPutBit(bs, 0);
693 return;
694
695 case 2:
696 BitstreamPutBit(bs, 1);
697 BitstreamPutBit(bs, 1);
698 return;
699
700 default:; /* invalid */
701 }
702 }
703
704
705
706 void
MBCodingBVOP(const FRAMEINFO * const frame,const MACROBLOCK * mb,const int16_t qcoeff[6* 64],const int32_t fcode,const int32_t bcode,Bitstream * bs,Statistics * pStat)707 MBCodingBVOP(const FRAMEINFO * const frame,
708 const MACROBLOCK * mb,
709 const int16_t qcoeff[6 * 64],
710 const int32_t fcode,
711 const int32_t bcode,
712 Bitstream * bs,
713 Statistics * pStat)
714 {
715 int vcode = fcode;
716 unsigned int i;
717
718 const uint16_t *scan_table =
719 frame->vop_flags & XVID_VOP_ALTERNATESCAN ?
720 scan_tables[2] : scan_tables[0];
721 int bits;
722
723 /* ------------------------------------------------------------------
724 when a block is skipped it is decoded DIRECT(0,0)
725 hence is interpolated from forward & backward frames
726 ------------------------------------------------------------------ */
727
728 if (mb->mode == MODE_DIRECT_NONE_MV) {
729 BitstreamPutBit(bs, 1); /* skipped */
730 return;
731 }
732
733 BitstreamPutBit(bs, 0); /* not skipped */
734
735 if (mb->cbp == 0) {
736 BitstreamPutBit(bs, 1); /* cbp == 0 */
737 } else {
738 BitstreamPutBit(bs, 0); /* cbp == xxx */
739 }
740
741 put_bvop_mbtype(bs, mb->mode);
742
743 if (mb->cbp) {
744 BitstreamPutBits(bs, mb->cbp, 6);
745 }
746
747 if (mb->mode != MODE_DIRECT && mb->cbp != 0) {
748 put_bvop_dbquant(bs, 0); /* todo: mb->dquant = 0 */
749 }
750
751 if (frame->vol_flags & XVID_VOL_INTERLACING) {
752 if (mb->cbp) {
753 BitstreamPutBit(bs, mb->field_dct);
754 DPRINTF(XVID_DEBUG_MB,"codep: field_dct: %i\n", mb->field_dct);
755 }
756
757 /* if not direct block, write field ME flag */
758 if (mb->mode != MODE_DIRECT) {
759 BitstreamPutBit(bs, 0 /*mb->field_pred*/); /* field ME not implemented */
760
761 /* write field prediction references */
762 #if 0 /* Remove the #if once field_pred is supported */
763 if (mb->field_pred) {
764 BitstreamPutBit(bs, mb->field_for_top);
765 BitstreamPutBit(bs, mb->field_for_bot);
766 }
767 #endif
768 }
769 }
770
771 bits = BitstreamPos(bs);
772
773 switch (mb->mode) {
774 case MODE_INTERPOLATE:
775 CodeVector(bs, mb->pmvs[1].x, vcode); /* forward vector of interpolate mode */
776 CodeVector(bs, mb->pmvs[1].y, vcode);
777 case MODE_BACKWARD:
778 vcode = bcode;
779 case MODE_FORWARD:
780 CodeVector(bs, mb->pmvs[0].x, vcode);
781 CodeVector(bs, mb->pmvs[0].y, vcode);
782 break;
783 case MODE_DIRECT:
784 CodeVector(bs, mb->pmvs[3].x, 1); /* fcode is always 1 for delta vector */
785 CodeVector(bs, mb->pmvs[3].y, 1); /* prediction is always (0,0) */
786 default: break;
787 }
788 pStat->iMVBits += BitstreamPos(bs) - bits;
789
790 bits = BitstreamPos(bs);
791 for (i = 0; i < 6; i++) {
792 if (mb->cbp & (1 << (5 - i))) {
793 CodeCoeffInter(bs, &qcoeff[i * 64], scan_table);
794 }
795 }
796 pStat->iTextBits += BitstreamPos(bs) - bits;
797 }
798
799
800
801 /***************************************************************
802 * decoding stuff starts here *
803 ***************************************************************/
804
805
806 /*
807 * for IVOP addbits == 0
808 * for PVOP addbits == fcode - 1
809 * for BVOP addbits == max(fcode,bcode) - 1
810 * returns true or false
811 */
812 int
check_resync_marker(Bitstream * bs,int addbits)813 check_resync_marker(Bitstream * bs, int addbits)
814 {
815 uint32_t nbits;
816 uint32_t code;
817 uint32_t nbitsresyncmarker = NUMBITS_VP_RESYNC_MARKER + addbits;
818
819 nbits = BitstreamNumBitsToByteAlign(bs);
820 code = BitstreamShowBits(bs, nbits);
821
822 if (code == (((uint32_t)1 << (nbits - 1)) - 1))
823 {
824 return BitstreamShowBitsFromByteAlign(bs, nbitsresyncmarker) == RESYNC_MARKER;
825 }
826
827 return 0;
828 }
829
830
831
832 int
get_mcbpc_intra(Bitstream * bs)833 get_mcbpc_intra(Bitstream * bs)
834 {
835
836 uint32_t index;
837
838 index = BitstreamShowBits(bs, 9);
839 index >>= 3;
840
841 BitstreamSkip(bs, mcbpc_intra_table[index].len);
842
843 return mcbpc_intra_table[index].code;
844
845 }
846
847 int
get_mcbpc_inter(Bitstream * bs)848 get_mcbpc_inter(Bitstream * bs)
849 {
850
851 uint32_t index;
852
853 index = MIN(BitstreamShowBits(bs, 9), 256);
854
855 BitstreamSkip(bs, mcbpc_inter_table[index].len);
856
857 return mcbpc_inter_table[index].code;
858
859 }
860
861 int
get_cbpy(Bitstream * bs,int intra)862 get_cbpy(Bitstream * bs,
863 int intra)
864 {
865
866 int cbpy;
867 uint32_t index = BitstreamShowBits(bs, 6);
868
869 BitstreamSkip(bs, cbpy_table[index].len);
870 cbpy = cbpy_table[index].code;
871
872 if (!intra)
873 cbpy = 15 - cbpy;
874
875 return cbpy;
876
877 }
878
879 static __inline int
get_mv_data(Bitstream * bs)880 get_mv_data(Bitstream * bs)
881 {
882
883 uint32_t index;
884
885 if (BitstreamGetBit(bs))
886 return 0;
887
888 index = BitstreamShowBits(bs, 12);
889
890 if (index >= 512) {
891 index = (index >> 8) - 2;
892 BitstreamSkip(bs, TMNMVtab0[index].len);
893 return TMNMVtab0[index].code;
894 }
895
896 if (index >= 128) {
897 index = (index >> 2) - 32;
898 BitstreamSkip(bs, TMNMVtab1[index].len);
899 return TMNMVtab1[index].code;
900 }
901
902 index -= 4;
903
904 BitstreamSkip(bs, TMNMVtab2[index&0x7f].len);
905 return TMNMVtab2[index&0x7f].code;
906
907 }
908
909 int
get_mv(Bitstream * bs,int fcode)910 get_mv(Bitstream * bs,
911 int fcode)
912 {
913
914 int data;
915 int res;
916 int mv;
917 int scale_fac = 1 << (fcode - 1);
918
919 data = get_mv_data(bs);
920
921 if (scale_fac == 1 || data == 0)
922 return data;
923
924 res = BitstreamGetBits(bs, fcode - 1);
925 mv = ((abs(data) - 1) * scale_fac) + res + 1;
926
927 return data < 0 ? -mv : mv;
928
929 }
930
931 int
get_dc_dif(Bitstream * bs,uint32_t dc_size)932 get_dc_dif(Bitstream * bs,
933 uint32_t dc_size)
934 {
935
936 int code = BitstreamGetBits(bs, dc_size);
937 int msb = code >> (dc_size - 1);
938
939 if (msb == 0)
940 return (-1 * (code ^ ((1 << dc_size) - 1)));
941
942 return code;
943
944 }
945
946 int
get_dc_size_lum(Bitstream * bs)947 get_dc_size_lum(Bitstream * bs)
948 {
949
950 int code, i;
951
952 code = BitstreamShowBits(bs, 11);
953
954 for (i = 11; i > 3; i--) {
955 if (code == 1) {
956 BitstreamSkip(bs, i);
957 return i + 1;
958 }
959 code >>= 1;
960 }
961
962 BitstreamSkip(bs, dc_lum_tab[code].len);
963 return dc_lum_tab[code].code;
964
965 }
966
967
968 int
get_dc_size_chrom(Bitstream * bs)969 get_dc_size_chrom(Bitstream * bs)
970 {
971
972 uint32_t code, i;
973
974 code = BitstreamShowBits(bs, 12);
975
976 for (i = 12; i > 2; i--) {
977 if (code == 1) {
978 BitstreamSkip(bs, i);
979 return i;
980 }
981 code >>= 1;
982 }
983
984 return 3 - BitstreamGetBits(bs, 2);
985
986 }
987
988 #define GET_BITS(cache, n) ((cache)>>(32-(n)))
989
990 static __inline int
get_coeff(Bitstream * bs,int * run,int * last,int intra,int short_video_header)991 get_coeff(Bitstream * bs,
992 int *run,
993 int *last,
994 int intra,
995 int short_video_header)
996 {
997
998 uint32_t mode;
999 int32_t level;
1000 REVERSE_EVENT *reverse_event;
1001
1002 uint32_t cache = BitstreamShowBits(bs, 32);
1003
1004 if (short_video_header) /* inter-VLCs will be used for both intra and inter blocks */
1005 intra = 0;
1006
1007 if (GET_BITS(cache, 7) != ESCAPE) {
1008 reverse_event = &DCT3D[intra][GET_BITS(cache, 12)];
1009
1010 if ((level = reverse_event->event.level) == 0)
1011 goto error;
1012
1013 *last = reverse_event->event.last;
1014 *run = reverse_event->event.run;
1015
1016 /* Don't forget to update the bitstream position */
1017 BitstreamSkip(bs, reverse_event->len+1);
1018
1019 return (GET_BITS(cache, reverse_event->len+1)&0x01) ? -level : level;
1020 }
1021
1022 /* flush 7bits of cache */
1023 cache <<= 7;
1024
1025 if (short_video_header) {
1026 /* escape mode 4 - H.263 type, only used if short_video_header = 1 */
1027 *last = GET_BITS(cache, 1);
1028 *run = (GET_BITS(cache, 7) &0x3f);
1029 level = (GET_BITS(cache, 15)&0xff);
1030
1031 if (level == 0 || level == 128)
1032 DPRINTF(XVID_DEBUG_ERROR, "Illegal LEVEL for ESCAPE mode 4: %d\n", level);
1033
1034 /* We've "eaten" 22 bits */
1035 BitstreamSkip(bs, 22);
1036
1037 return (level << 24) >> 24;
1038 }
1039
1040 if ((mode = GET_BITS(cache, 2)) < 3) {
1041 const int skip[3] = {1, 1, 2};
1042 cache <<= skip[mode];
1043
1044 reverse_event = &DCT3D[intra][GET_BITS(cache, 12)];
1045
1046 if ((level = reverse_event->event.level) == 0)
1047 goto error;
1048
1049 *last = reverse_event->event.last;
1050 *run = reverse_event->event.run;
1051
1052 if (mode < 2) {
1053 /* first escape mode, level is offset */
1054 level += max_level[intra][*last][*run];
1055 } else {
1056 /* second escape mode, run is offset */
1057 *run += max_run[intra][*last][level] + 1;
1058 }
1059
1060 /* Update bitstream position */
1061 BitstreamSkip(bs, 7 + skip[mode] + reverse_event->len + 1);
1062
1063 return (GET_BITS(cache, reverse_event->len+1)&0x01) ? -level : level;
1064 }
1065
1066 /* third escape mode - fixed length codes */
1067 cache <<= 2;
1068 *last = GET_BITS(cache, 1);
1069 *run = (GET_BITS(cache, 7)&0x3f);
1070 level = (GET_BITS(cache, 20)&0xfff);
1071
1072 /* Update bitstream position */
1073 BitstreamSkip(bs, 30);
1074
1075 return (level << 20) >> 20;
1076
1077 error:
1078 *run = 64;
1079 return 0;
1080 }
1081
1082 void
get_intra_block(Bitstream * bs,int16_t * block,int direction,int coeff)1083 get_intra_block(Bitstream * bs,
1084 int16_t * block,
1085 int direction,
1086 int coeff)
1087 {
1088
1089 const uint16_t *scan = scan_tables[direction];
1090 int level, run, last = 0;
1091
1092 do {
1093 level = get_coeff(bs, &run, &last, 1, 0);
1094 coeff += run;
1095 if (coeff & ~63) {
1096 DPRINTF(XVID_DEBUG_ERROR,"fatal: invalid run or index");
1097 break;
1098 }
1099
1100 block[scan[coeff]] = level;
1101
1102 DPRINTF(XVID_DEBUG_COEFF,"block[%i] %i\n", scan[coeff], level);
1103 #if 0
1104 DPRINTF(XVID_DEBUG_COEFF,"block[%i] %i %08x\n", scan[coeff], level, BitstreamShowBits(bs, 32));
1105 #endif
1106
1107 if (level < -2047 || level > 2047) {
1108 DPRINTF(XVID_DEBUG_ERROR,"warning: intra_overflow %i\n", level);
1109 }
1110 coeff++;
1111 } while (!last);
1112
1113 }
1114
1115 void
get_inter_block_h263(Bitstream * bs,int16_t * block,int direction,const int quant,const uint16_t * matrix)1116 get_inter_block_h263(
1117 Bitstream * bs,
1118 int16_t * block,
1119 int direction,
1120 const int quant,
1121 const uint16_t *matrix)
1122 {
1123
1124 const uint16_t *scan = scan_tables[direction];
1125 const uint16_t quant_m_2 = quant << 1;
1126 const uint16_t quant_add = (quant & 1 ? quant : quant - 1);
1127 int p;
1128 int level;
1129 int run;
1130 int last = 0;
1131
1132 p = 0;
1133 do {
1134 level = get_coeff(bs, &run, &last, 0, 0);
1135 p += run;
1136 if (p & ~63) {
1137 DPRINTF(XVID_DEBUG_ERROR,"fatal: invalid run or index");
1138 break;
1139 }
1140
1141 if (level < 0) {
1142 level = level*quant_m_2 - quant_add;
1143 block[scan[p]] = (level >= -2048 ? level : -2048);
1144 } else {
1145 level = level * quant_m_2 + quant_add;
1146 block[scan[p]] = (level <= 2047 ? level : 2047);
1147 }
1148 p++;
1149 } while (!last);
1150 }
1151
1152 void
get_inter_block_mpeg(Bitstream * bs,int16_t * block,int direction,const int quant,const uint16_t * matrix)1153 get_inter_block_mpeg(
1154 Bitstream * bs,
1155 int16_t * block,
1156 int direction,
1157 const int quant,
1158 const uint16_t *matrix)
1159 {
1160 const uint16_t *scan = scan_tables[direction];
1161 uint32_t sum = 0;
1162 int p;
1163 int level;
1164 int run;
1165 int last = 0;
1166
1167 p = 0;
1168 do {
1169 level = get_coeff(bs, &run, &last, 0, 0);
1170 p += run;
1171 if (p & ~63) {
1172 DPRINTF(XVID_DEBUG_ERROR,"fatal: invalid run or index");
1173 break;
1174 }
1175
1176 if (level < 0) {
1177 level = ((2 * -level + 1) * matrix[scan[p]] * quant) >> 4;
1178 block[scan[p]] = (level <= 2048 ? -level : -2048);
1179 } else {
1180 level = ((2 * level + 1) * matrix[scan[p]] * quant) >> 4;
1181 block[scan[p]] = (level <= 2047 ? level : 2047);
1182 }
1183
1184 sum ^= block[scan[p]];
1185
1186 p++;
1187 } while (!last);
1188
1189 /* mismatch control */
1190 if ((sum & 1) == 0) {
1191 block[63] ^= 1;
1192 }
1193 }
1194
1195
1196 /*****************************************************************************
1197 * VLC tables and other constant arrays
1198 ****************************************************************************/
1199
1200 VLC_TABLE const coeff_tab[2][102] =
1201 {
1202 /* intra = 0 */
1203 {
1204 {{ 2, 2}, {0, 0, 1}},
1205 {{15, 4}, {0, 0, 2}},
1206 {{21, 6}, {0, 0, 3}},
1207 {{23, 7}, {0, 0, 4}},
1208 {{31, 8}, {0, 0, 5}},
1209 {{37, 9}, {0, 0, 6}},
1210 {{36, 9}, {0, 0, 7}},
1211 {{33, 10}, {0, 0, 8}},
1212 {{32, 10}, {0, 0, 9}},
1213 {{ 7, 11}, {0, 0, 10}},
1214 {{ 6, 11}, {0, 0, 11}},
1215 {{32, 11}, {0, 0, 12}},
1216 {{ 6, 3}, {0, 1, 1}},
1217 {{20, 6}, {0, 1, 2}},
1218 {{30, 8}, {0, 1, 3}},
1219 {{15, 10}, {0, 1, 4}},
1220 {{33, 11}, {0, 1, 5}},
1221 {{80, 12}, {0, 1, 6}},
1222 {{14, 4}, {0, 2, 1}},
1223 {{29, 8}, {0, 2, 2}},
1224 {{14, 10}, {0, 2, 3}},
1225 {{81, 12}, {0, 2, 4}},
1226 {{13, 5}, {0, 3, 1}},
1227 {{35, 9}, {0, 3, 2}},
1228 {{13, 10}, {0, 3, 3}},
1229 {{12, 5}, {0, 4, 1}},
1230 {{34, 9}, {0, 4, 2}},
1231 {{82, 12}, {0, 4, 3}},
1232 {{11, 5}, {0, 5, 1}},
1233 {{12, 10}, {0, 5, 2}},
1234 {{83, 12}, {0, 5, 3}},
1235 {{19, 6}, {0, 6, 1}},
1236 {{11, 10}, {0, 6, 2}},
1237 {{84, 12}, {0, 6, 3}},
1238 {{18, 6}, {0, 7, 1}},
1239 {{10, 10}, {0, 7, 2}},
1240 {{17, 6}, {0, 8, 1}},
1241 {{ 9, 10}, {0, 8, 2}},
1242 {{16, 6}, {0, 9, 1}},
1243 {{ 8, 10}, {0, 9, 2}},
1244 {{22, 7}, {0, 10, 1}},
1245 {{85, 12}, {0, 10, 2}},
1246 {{21, 7}, {0, 11, 1}},
1247 {{20, 7}, {0, 12, 1}},
1248 {{28, 8}, {0, 13, 1}},
1249 {{27, 8}, {0, 14, 1}},
1250 {{33, 9}, {0, 15, 1}},
1251 {{32, 9}, {0, 16, 1}},
1252 {{31, 9}, {0, 17, 1}},
1253 {{30, 9}, {0, 18, 1}},
1254 {{29, 9}, {0, 19, 1}},
1255 {{28, 9}, {0, 20, 1}},
1256 {{27, 9}, {0, 21, 1}},
1257 {{26, 9}, {0, 22, 1}},
1258 {{34, 11}, {0, 23, 1}},
1259 {{35, 11}, {0, 24, 1}},
1260 {{86, 12}, {0, 25, 1}},
1261 {{87, 12}, {0, 26, 1}},
1262 {{ 7, 4}, {1, 0, 1}},
1263 {{25, 9}, {1, 0, 2}},
1264 {{ 5, 11}, {1, 0, 3}},
1265 {{15, 6}, {1, 1, 1}},
1266 {{ 4, 11}, {1, 1, 2}},
1267 {{14, 6}, {1, 2, 1}},
1268 {{13, 6}, {1, 3, 1}},
1269 {{12, 6}, {1, 4, 1}},
1270 {{19, 7}, {1, 5, 1}},
1271 {{18, 7}, {1, 6, 1}},
1272 {{17, 7}, {1, 7, 1}},
1273 {{16, 7}, {1, 8, 1}},
1274 {{26, 8}, {1, 9, 1}},
1275 {{25, 8}, {1, 10, 1}},
1276 {{24, 8}, {1, 11, 1}},
1277 {{23, 8}, {1, 12, 1}},
1278 {{22, 8}, {1, 13, 1}},
1279 {{21, 8}, {1, 14, 1}},
1280 {{20, 8}, {1, 15, 1}},
1281 {{19, 8}, {1, 16, 1}},
1282 {{24, 9}, {1, 17, 1}},
1283 {{23, 9}, {1, 18, 1}},
1284 {{22, 9}, {1, 19, 1}},
1285 {{21, 9}, {1, 20, 1}},
1286 {{20, 9}, {1, 21, 1}},
1287 {{19, 9}, {1, 22, 1}},
1288 {{18, 9}, {1, 23, 1}},
1289 {{17, 9}, {1, 24, 1}},
1290 {{ 7, 10}, {1, 25, 1}},
1291 {{ 6, 10}, {1, 26, 1}},
1292 {{ 5, 10}, {1, 27, 1}},
1293 {{ 4, 10}, {1, 28, 1}},
1294 {{36, 11}, {1, 29, 1}},
1295 {{37, 11}, {1, 30, 1}},
1296 {{38, 11}, {1, 31, 1}},
1297 {{39, 11}, {1, 32, 1}},
1298 {{88, 12}, {1, 33, 1}},
1299 {{89, 12}, {1, 34, 1}},
1300 {{90, 12}, {1, 35, 1}},
1301 {{91, 12}, {1, 36, 1}},
1302 {{92, 12}, {1, 37, 1}},
1303 {{93, 12}, {1, 38, 1}},
1304 {{94, 12}, {1, 39, 1}},
1305 {{95, 12}, {1, 40, 1}}
1306 },
1307 /* intra = 1 */
1308 {
1309 {{ 2, 2}, {0, 0, 1}},
1310 {{15, 4}, {0, 0, 3}},
1311 {{21, 6}, {0, 0, 6}},
1312 {{23, 7}, {0, 0, 9}},
1313 {{31, 8}, {0, 0, 10}},
1314 {{37, 9}, {0, 0, 13}},
1315 {{36, 9}, {0, 0, 14}},
1316 {{33, 10}, {0, 0, 17}},
1317 {{32, 10}, {0, 0, 18}},
1318 {{ 7, 11}, {0, 0, 21}},
1319 {{ 6, 11}, {0, 0, 22}},
1320 {{32, 11}, {0, 0, 23}},
1321 {{ 6, 3}, {0, 0, 2}},
1322 {{20, 6}, {0, 1, 2}},
1323 {{30, 8}, {0, 0, 11}},
1324 {{15, 10}, {0, 0, 19}},
1325 {{33, 11}, {0, 0, 24}},
1326 {{80, 12}, {0, 0, 25}},
1327 {{14, 4}, {0, 1, 1}},
1328 {{29, 8}, {0, 0, 12}},
1329 {{14, 10}, {0, 0, 20}},
1330 {{81, 12}, {0, 0, 26}},
1331 {{13, 5}, {0, 0, 4}},
1332 {{35, 9}, {0, 0, 15}},
1333 {{13, 10}, {0, 1, 7}},
1334 {{12, 5}, {0, 0, 5}},
1335 {{34, 9}, {0, 4, 2}},
1336 {{82, 12}, {0, 0, 27}},
1337 {{11, 5}, {0, 2, 1}},
1338 {{12, 10}, {0, 2, 4}},
1339 {{83, 12}, {0, 1, 9}},
1340 {{19, 6}, {0, 0, 7}},
1341 {{11, 10}, {0, 3, 4}},
1342 {{84, 12}, {0, 6, 3}},
1343 {{18, 6}, {0, 0, 8}},
1344 {{10, 10}, {0, 4, 3}},
1345 {{17, 6}, {0, 3, 1}},
1346 {{ 9, 10}, {0, 8, 2}},
1347 {{16, 6}, {0, 4, 1}},
1348 {{ 8, 10}, {0, 5, 3}},
1349 {{22, 7}, {0, 1, 3}},
1350 {{85, 12}, {0, 1, 10}},
1351 {{21, 7}, {0, 2, 2}},
1352 {{20, 7}, {0, 7, 1}},
1353 {{28, 8}, {0, 1, 4}},
1354 {{27, 8}, {0, 3, 2}},
1355 {{33, 9}, {0, 0, 16}},
1356 {{32, 9}, {0, 1, 5}},
1357 {{31, 9}, {0, 1, 6}},
1358 {{30, 9}, {0, 2, 3}},
1359 {{29, 9}, {0, 3, 3}},
1360 {{28, 9}, {0, 5, 2}},
1361 {{27, 9}, {0, 6, 2}},
1362 {{26, 9}, {0, 7, 2}},
1363 {{34, 11}, {0, 1, 8}},
1364 {{35, 11}, {0, 9, 2}},
1365 {{86, 12}, {0, 2, 5}},
1366 {{87, 12}, {0, 7, 3}},
1367 {{ 7, 4}, {1, 0, 1}},
1368 {{25, 9}, {0, 11, 1}},
1369 {{ 5, 11}, {1, 0, 6}},
1370 {{15, 6}, {1, 1, 1}},
1371 {{ 4, 11}, {1, 0, 7}},
1372 {{14, 6}, {1, 2, 1}},
1373 {{13, 6}, {0, 5, 1}},
1374 {{12, 6}, {1, 0, 2}},
1375 {{19, 7}, {1, 5, 1}},
1376 {{18, 7}, {0, 6, 1}},
1377 {{17, 7}, {1, 3, 1}},
1378 {{16, 7}, {1, 4, 1}},
1379 {{26, 8}, {1, 9, 1}},
1380 {{25, 8}, {0, 8, 1}},
1381 {{24, 8}, {0, 9, 1}},
1382 {{23, 8}, {0, 10, 1}},
1383 {{22, 8}, {1, 0, 3}},
1384 {{21, 8}, {1, 6, 1}},
1385 {{20, 8}, {1, 7, 1}},
1386 {{19, 8}, {1, 8, 1}},
1387 {{24, 9}, {0, 12, 1}},
1388 {{23, 9}, {1, 0, 4}},
1389 {{22, 9}, {1, 1, 2}},
1390 {{21, 9}, {1, 10, 1}},
1391 {{20, 9}, {1, 11, 1}},
1392 {{19, 9}, {1, 12, 1}},
1393 {{18, 9}, {1, 13, 1}},
1394 {{17, 9}, {1, 14, 1}},
1395 {{ 7, 10}, {0, 13, 1}},
1396 {{ 6, 10}, {1, 0, 5}},
1397 {{ 5, 10}, {1, 1, 3}},
1398 {{ 4, 10}, {1, 2, 2}},
1399 {{36, 11}, {1, 3, 2}},
1400 {{37, 11}, {1, 4, 2}},
1401 {{38, 11}, {1, 15, 1}},
1402 {{39, 11}, {1, 16, 1}},
1403 {{88, 12}, {0, 14, 1}},
1404 {{89, 12}, {1, 0, 8}},
1405 {{90, 12}, {1, 5, 2}},
1406 {{91, 12}, {1, 6, 2}},
1407 {{92, 12}, {1, 17, 1}},
1408 {{93, 12}, {1, 18, 1}},
1409 {{94, 12}, {1, 19, 1}},
1410 {{95, 12}, {1, 20, 1}}
1411 }
1412 };
1413
1414 /* constants taken from momusys/vm_common/inlcude/max_level.h */
1415 uint8_t const max_level[2][2][64] = {
1416 {
1417 /* intra = 0, last = 0 */
1418 {
1419 12, 6, 4, 3, 3, 3, 3, 2,
1420 2, 2, 2, 1, 1, 1, 1, 1,
1421 1, 1, 1, 1, 1, 1, 1, 1,
1422 1, 1, 1, 0, 0, 0, 0, 0,
1423 0, 0, 0, 0, 0, 0, 0, 0,
1424 0, 0, 0, 0, 0, 0, 0, 0,
1425 0, 0, 0, 0, 0, 0, 0, 0,
1426 0, 0, 0, 0, 0, 0, 0, 0
1427 },
1428 /* intra = 0, last = 1 */
1429 {
1430 3, 2, 1, 1, 1, 1, 1, 1,
1431 1, 1, 1, 1, 1, 1, 1, 1,
1432 1, 1, 1, 1, 1, 1, 1, 1,
1433 1, 1, 1, 1, 1, 1, 1, 1,
1434 1, 1, 1, 1, 1, 1, 1, 1,
1435 1, 0, 0, 0, 0, 0, 0, 0,
1436 0, 0, 0, 0, 0, 0, 0, 0,
1437 0, 0, 0, 0, 0, 0, 0, 0
1438 }
1439 },
1440 {
1441 /* intra = 1, last = 0 */
1442 {
1443 27, 10, 5, 4, 3, 3, 3, 3,
1444 2, 2, 1, 1, 1, 1, 1, 0,
1445 0, 0, 0, 0, 0, 0, 0, 0,
1446 0, 0, 0, 0, 0, 0, 0, 0,
1447 0, 0, 0, 0, 0, 0, 0, 0,
1448 0, 0, 0, 0, 0, 0, 0, 0,
1449 0, 0, 0, 0, 0, 0, 0, 0,
1450 0, 0, 0, 0, 0, 0, 0, 0
1451 },
1452 /* intra = 1, last = 1 */
1453 {
1454 8, 3, 2, 2, 2, 2, 2, 1,
1455 1, 1, 1, 1, 1, 1, 1, 1,
1456 1, 1, 1, 1, 1, 0, 0, 0,
1457 0, 0, 0, 0, 0, 0, 0, 0,
1458 0, 0, 0, 0, 0, 0, 0, 0,
1459 0, 0, 0, 0, 0, 0, 0, 0,
1460 0, 0, 0, 0, 0, 0, 0, 0,
1461 0, 0, 0, 0, 0, 0, 0, 0
1462 }
1463 }
1464 };
1465
1466 uint8_t const max_run[2][2][64] = {
1467 {
1468 /* intra = 0, last = 0 */
1469 {
1470 0, 26, 10, 6, 2, 1, 1, 0,
1471 0, 0, 0, 0, 0, 0, 0, 0,
1472 0, 0, 0, 0, 0, 0, 0, 0,
1473 0, 0, 0, 0, 0, 0, 0, 0,
1474 0, 0, 0, 0, 0, 0, 0, 0,
1475 0, 0, 0, 0, 0, 0, 0, 0,
1476 0, 0, 0, 0, 0, 0, 0, 0,
1477 0, 0, 0, 0, 0, 0, 0, 0,
1478 },
1479 /* intra = 0, last = 1 */
1480 {
1481 0, 40, 1, 0, 0, 0, 0, 0,
1482 0, 0, 0, 0, 0, 0, 0, 0,
1483 0, 0, 0, 0, 0, 0, 0, 0,
1484 0, 0, 0, 0, 0, 0, 0, 0,
1485 0, 0, 0, 0, 0, 0, 0, 0,
1486 0, 0, 0, 0, 0, 0, 0, 0,
1487 0, 0, 0, 0, 0, 0, 0, 0,
1488 0, 0, 0, 0, 0, 0, 0, 0,
1489 }
1490 },
1491 {
1492 /* intra = 1, last = 0 */
1493 {
1494 0, 14, 9, 7, 3, 2, 1, 1,
1495 1, 1, 1, 0, 0, 0, 0, 0,
1496 0, 0, 0, 0, 0, 0, 0, 0,
1497 0, 0, 0, 0, 0, 0, 0, 0,
1498 0, 0, 0, 0, 0, 0, 0, 0,
1499 0, 0, 0, 0, 0, 0, 0, 0,
1500 0, 0, 0, 0, 0, 0, 0, 0,
1501 0, 0, 0, 0, 0, 0, 0, 0,
1502 },
1503 /* intra = 1, last = 1 */
1504 {
1505 0, 20, 6, 1, 0, 0, 0, 0,
1506 0, 0, 0, 0, 0, 0, 0, 0,
1507 0, 0, 0, 0, 0, 0, 0, 0,
1508 0, 0, 0, 0, 0, 0, 0, 0,
1509 0, 0, 0, 0, 0, 0, 0, 0,
1510 0, 0, 0, 0, 0, 0, 0, 0,
1511 0, 0, 0, 0, 0, 0, 0, 0,
1512 0, 0, 0, 0, 0, 0, 0, 0,
1513 }
1514 }
1515 };
1516
1517 /******************************************************************
1518 * encoder tables *
1519 ******************************************************************/
1520
1521 VLC sprite_trajectory_code[32768];
1522
1523 VLC sprite_trajectory_len[15] = {
1524 { 0x00 , 2},
1525 { 0x02 , 3}, { 0x03, 3}, { 0x04, 3}, { 0x05, 3}, { 0x06, 3},
1526 { 0x0E , 4}, { 0x1E, 5}, { 0x3E, 6}, { 0x7E, 7}, { 0xFE, 8},
1527 { 0x1FE, 9}, {0x3FE,10}, {0x7FE,11}, {0xFFE,12} };
1528
1529
1530 /* DCT coefficients. Four tables, two for last = 0, two for last = 1.
1531 the sign bit must be added afterwards. */
1532
1533 /* MCBPC Indexing by cbpc in first two bits, mode in last two.
1534 CBPC as in table 4/H.263, MB type (mode): 3 = 01, 4 = 10.
1535 Example: cbpc = 01 and mode = 4 gives index = 0110 = 6. */
1536
1537 VLC mcbpc_intra_tab[15] = {
1538 {0x01, 9}, {0x01, 1}, {0x01, 4}, {0x00, 0},
1539 {0x00, 0}, {0x01, 3}, {0x01, 6}, {0x00, 0},
1540 {0x00, 0}, {0x02, 3}, {0x02, 6}, {0x00, 0},
1541 {0x00, 0}, {0x03, 3}, {0x03, 6}
1542 };
1543
1544 /* MCBPC inter.
1545 Addressing: 5 bit ccmmm (cc = CBPC, mmm = mode (1-4 binary)) */
1546
1547 VLC mcbpc_inter_tab[29] = {
1548 {1, 1}, {3, 3}, {2, 3}, {3, 5}, {4, 6}, {1, 9}, {0, 0}, {0, 0},
1549 {3, 4}, {7, 7}, {5, 7}, {4, 8}, {4, 9}, {0, 0}, {0, 0}, {0, 0},
1550 {2, 4}, {6, 7}, {4, 7}, {3, 8}, {3, 9}, {0, 0}, {0, 0}, {0, 0},
1551 {5, 6}, {5, 9}, {5, 8}, {3, 7}, {2, 9}
1552 };
1553
1554 const VLC xvid_cbpy_tab[16] = {
1555 {3, 4}, {5, 5}, {4, 5}, {9, 4}, {3, 5}, {7, 4}, {2, 6}, {11, 4},
1556 {2, 5}, {3, 6}, {5, 4}, {10, 4}, {4, 4}, {8, 4}, {6, 4}, {3, 2}
1557 };
1558
1559 const VLC dcy_tab[511] = {
1560 {0x100, 15}, {0x101, 15}, {0x102, 15}, {0x103, 15},
1561 {0x104, 15}, {0x105, 15}, {0x106, 15}, {0x107, 15},
1562 {0x108, 15}, {0x109, 15}, {0x10a, 15}, {0x10b, 15},
1563 {0x10c, 15}, {0x10d, 15}, {0x10e, 15}, {0x10f, 15},
1564 {0x110, 15}, {0x111, 15}, {0x112, 15}, {0x113, 15},
1565 {0x114, 15}, {0x115, 15}, {0x116, 15}, {0x117, 15},
1566 {0x118, 15}, {0x119, 15}, {0x11a, 15}, {0x11b, 15},
1567 {0x11c, 15}, {0x11d, 15}, {0x11e, 15}, {0x11f, 15},
1568 {0x120, 15}, {0x121, 15}, {0x122, 15}, {0x123, 15},
1569 {0x124, 15}, {0x125, 15}, {0x126, 15}, {0x127, 15},
1570 {0x128, 15}, {0x129, 15}, {0x12a, 15}, {0x12b, 15},
1571 {0x12c, 15}, {0x12d, 15}, {0x12e, 15}, {0x12f, 15},
1572 {0x130, 15}, {0x131, 15}, {0x132, 15}, {0x133, 15},
1573 {0x134, 15}, {0x135, 15}, {0x136, 15}, {0x137, 15},
1574 {0x138, 15}, {0x139, 15}, {0x13a, 15}, {0x13b, 15},
1575 {0x13c, 15}, {0x13d, 15}, {0x13e, 15}, {0x13f, 15},
1576 {0x140, 15}, {0x141, 15}, {0x142, 15}, {0x143, 15},
1577 {0x144, 15}, {0x145, 15}, {0x146, 15}, {0x147, 15},
1578 {0x148, 15}, {0x149, 15}, {0x14a, 15}, {0x14b, 15},
1579 {0x14c, 15}, {0x14d, 15}, {0x14e, 15}, {0x14f, 15},
1580 {0x150, 15}, {0x151, 15}, {0x152, 15}, {0x153, 15},
1581 {0x154, 15}, {0x155, 15}, {0x156, 15}, {0x157, 15},
1582 {0x158, 15}, {0x159, 15}, {0x15a, 15}, {0x15b, 15},
1583 {0x15c, 15}, {0x15d, 15}, {0x15e, 15}, {0x15f, 15},
1584 {0x160, 15}, {0x161, 15}, {0x162, 15}, {0x163, 15},
1585 {0x164, 15}, {0x165, 15}, {0x166, 15}, {0x167, 15},
1586 {0x168, 15}, {0x169, 15}, {0x16a, 15}, {0x16b, 15},
1587 {0x16c, 15}, {0x16d, 15}, {0x16e, 15}, {0x16f, 15},
1588 {0x170, 15}, {0x171, 15}, {0x172, 15}, {0x173, 15},
1589 {0x174, 15}, {0x175, 15}, {0x176, 15}, {0x177, 15},
1590 {0x178, 15}, {0x179, 15}, {0x17a, 15}, {0x17b, 15},
1591 {0x17c, 15}, {0x17d, 15}, {0x17e, 15}, {0x17f, 15},
1592 {0x80, 13}, {0x81, 13}, {0x82, 13}, {0x83, 13},
1593 {0x84, 13}, {0x85, 13}, {0x86, 13}, {0x87, 13},
1594 {0x88, 13}, {0x89, 13}, {0x8a, 13}, {0x8b, 13},
1595 {0x8c, 13}, {0x8d, 13}, {0x8e, 13}, {0x8f, 13},
1596 {0x90, 13}, {0x91, 13}, {0x92, 13}, {0x93, 13},
1597 {0x94, 13}, {0x95, 13}, {0x96, 13}, {0x97, 13},
1598 {0x98, 13}, {0x99, 13}, {0x9a, 13}, {0x9b, 13},
1599 {0x9c, 13}, {0x9d, 13}, {0x9e, 13}, {0x9f, 13},
1600 {0xa0, 13}, {0xa1, 13}, {0xa2, 13}, {0xa3, 13},
1601 {0xa4, 13}, {0xa5, 13}, {0xa6, 13}, {0xa7, 13},
1602 {0xa8, 13}, {0xa9, 13}, {0xaa, 13}, {0xab, 13},
1603 {0xac, 13}, {0xad, 13}, {0xae, 13}, {0xaf, 13},
1604 {0xb0, 13}, {0xb1, 13}, {0xb2, 13}, {0xb3, 13},
1605 {0xb4, 13}, {0xb5, 13}, {0xb6, 13}, {0xb7, 13},
1606 {0xb8, 13}, {0xb9, 13}, {0xba, 13}, {0xbb, 13},
1607 {0xbc, 13}, {0xbd, 13}, {0xbe, 13}, {0xbf, 13},
1608 {0x40, 11}, {0x41, 11}, {0x42, 11}, {0x43, 11},
1609 {0x44, 11}, {0x45, 11}, {0x46, 11}, {0x47, 11},
1610 {0x48, 11}, {0x49, 11}, {0x4a, 11}, {0x4b, 11},
1611 {0x4c, 11}, {0x4d, 11}, {0x4e, 11}, {0x4f, 11},
1612 {0x50, 11}, {0x51, 11}, {0x52, 11}, {0x53, 11},
1613 {0x54, 11}, {0x55, 11}, {0x56, 11}, {0x57, 11},
1614 {0x58, 11}, {0x59, 11}, {0x5a, 11}, {0x5b, 11},
1615 {0x5c, 11}, {0x5d, 11}, {0x5e, 11}, {0x5f, 11},
1616 {0x20, 9}, {0x21, 9}, {0x22, 9}, {0x23, 9},
1617 {0x24, 9}, {0x25, 9}, {0x26, 9}, {0x27, 9},
1618 {0x28, 9}, {0x29, 9}, {0x2a, 9}, {0x2b, 9},
1619 {0x2c, 9}, {0x2d, 9}, {0x2e, 9}, {0x2f, 9},
1620 {0x10, 7}, {0x11, 7}, {0x12, 7}, {0x13, 7},
1621 {0x14, 7}, {0x15, 7}, {0x16, 7}, {0x17, 7},
1622 {0x10, 6}, {0x11, 6}, {0x12, 6}, {0x13, 6},
1623 {0x08, 4}, {0x09, 4}, {0x06, 3}, {0x03, 3},
1624 {0x07, 3}, {0x0a, 4}, {0x0b, 4}, {0x14, 6},
1625 {0x15, 6}, {0x16, 6}, {0x17, 6}, {0x18, 7},
1626 {0x19, 7}, {0x1a, 7}, {0x1b, 7}, {0x1c, 7},
1627 {0x1d, 7}, {0x1e, 7}, {0x1f, 7}, {0x30, 9},
1628 {0x31, 9}, {0x32, 9}, {0x33, 9}, {0x34, 9},
1629 {0x35, 9}, {0x36, 9}, {0x37, 9}, {0x38, 9},
1630 {0x39, 9}, {0x3a, 9}, {0x3b, 9}, {0x3c, 9},
1631 {0x3d, 9}, {0x3e, 9}, {0x3f, 9}, {0x60, 11},
1632 {0x61, 11}, {0x62, 11}, {0x63, 11}, {0x64, 11},
1633 {0x65, 11}, {0x66, 11}, {0x67, 11}, {0x68, 11},
1634 {0x69, 11}, {0x6a, 11}, {0x6b, 11}, {0x6c, 11},
1635 {0x6d, 11}, {0x6e, 11}, {0x6f, 11}, {0x70, 11},
1636 {0x71, 11}, {0x72, 11}, {0x73, 11}, {0x74, 11},
1637 {0x75, 11}, {0x76, 11}, {0x77, 11}, {0x78, 11},
1638 {0x79, 11}, {0x7a, 11}, {0x7b, 11}, {0x7c, 11},
1639 {0x7d, 11}, {0x7e, 11}, {0x7f, 11}, {0xc0, 13},
1640 {0xc1, 13}, {0xc2, 13}, {0xc3, 13}, {0xc4, 13},
1641 {0xc5, 13}, {0xc6, 13}, {0xc7, 13}, {0xc8, 13},
1642 {0xc9, 13}, {0xca, 13}, {0xcb, 13}, {0xcc, 13},
1643 {0xcd, 13}, {0xce, 13}, {0xcf, 13}, {0xd0, 13},
1644 {0xd1, 13}, {0xd2, 13}, {0xd3, 13}, {0xd4, 13},
1645 {0xd5, 13}, {0xd6, 13}, {0xd7, 13}, {0xd8, 13},
1646 {0xd9, 13}, {0xda, 13}, {0xdb, 13}, {0xdc, 13},
1647 {0xdd, 13}, {0xde, 13}, {0xdf, 13}, {0xe0, 13},
1648 {0xe1, 13}, {0xe2, 13}, {0xe3, 13}, {0xe4, 13},
1649 {0xe5, 13}, {0xe6, 13}, {0xe7, 13}, {0xe8, 13},
1650 {0xe9, 13}, {0xea, 13}, {0xeb, 13}, {0xec, 13},
1651 {0xed, 13}, {0xee, 13}, {0xef, 13}, {0xf0, 13},
1652 {0xf1, 13}, {0xf2, 13}, {0xf3, 13}, {0xf4, 13},
1653 {0xf5, 13}, {0xf6, 13}, {0xf7, 13}, {0xf8, 13},
1654 {0xf9, 13}, {0xfa, 13}, {0xfb, 13}, {0xfc, 13},
1655 {0xfd, 13}, {0xfe, 13}, {0xff, 13}, {0x180, 15},
1656 {0x181, 15}, {0x182, 15}, {0x183, 15}, {0x184, 15},
1657 {0x185, 15}, {0x186, 15}, {0x187, 15}, {0x188, 15},
1658 {0x189, 15}, {0x18a, 15}, {0x18b, 15}, {0x18c, 15},
1659 {0x18d, 15}, {0x18e, 15}, {0x18f, 15}, {0x190, 15},
1660 {0x191, 15}, {0x192, 15}, {0x193, 15}, {0x194, 15},
1661 {0x195, 15}, {0x196, 15}, {0x197, 15}, {0x198, 15},
1662 {0x199, 15}, {0x19a, 15}, {0x19b, 15}, {0x19c, 15},
1663 {0x19d, 15}, {0x19e, 15}, {0x19f, 15}, {0x1a0, 15},
1664 {0x1a1, 15}, {0x1a2, 15}, {0x1a3, 15}, {0x1a4, 15},
1665 {0x1a5, 15}, {0x1a6, 15}, {0x1a7, 15}, {0x1a8, 15},
1666 {0x1a9, 15}, {0x1aa, 15}, {0x1ab, 15}, {0x1ac, 15},
1667 {0x1ad, 15}, {0x1ae, 15}, {0x1af, 15}, {0x1b0, 15},
1668 {0x1b1, 15}, {0x1b2, 15}, {0x1b3, 15}, {0x1b4, 15},
1669 {0x1b5, 15}, {0x1b6, 15}, {0x1b7, 15}, {0x1b8, 15},
1670 {0x1b9, 15}, {0x1ba, 15}, {0x1bb, 15}, {0x1bc, 15},
1671 {0x1bd, 15}, {0x1be, 15}, {0x1bf, 15}, {0x1c0, 15},
1672 {0x1c1, 15}, {0x1c2, 15}, {0x1c3, 15}, {0x1c4, 15},
1673 {0x1c5, 15}, {0x1c6, 15}, {0x1c7, 15}, {0x1c8, 15},
1674 {0x1c9, 15}, {0x1ca, 15}, {0x1cb, 15}, {0x1cc, 15},
1675 {0x1cd, 15}, {0x1ce, 15}, {0x1cf, 15}, {0x1d0, 15},
1676 {0x1d1, 15}, {0x1d2, 15}, {0x1d3, 15}, {0x1d4, 15},
1677 {0x1d5, 15}, {0x1d6, 15}, {0x1d7, 15}, {0x1d8, 15},
1678 {0x1d9, 15}, {0x1da, 15}, {0x1db, 15}, {0x1dc, 15},
1679 {0x1dd, 15}, {0x1de, 15}, {0x1df, 15}, {0x1e0, 15},
1680 {0x1e1, 15}, {0x1e2, 15}, {0x1e3, 15}, {0x1e4, 15},
1681 {0x1e5, 15}, {0x1e6, 15}, {0x1e7, 15}, {0x1e8, 15},
1682 {0x1e9, 15}, {0x1ea, 15}, {0x1eb, 15}, {0x1ec, 15},
1683 {0x1ed, 15}, {0x1ee, 15}, {0x1ef, 15}, {0x1f0, 15},
1684 {0x1f1, 15}, {0x1f2, 15}, {0x1f3, 15}, {0x1f4, 15},
1685 {0x1f5, 15}, {0x1f6, 15}, {0x1f7, 15}, {0x1f8, 15},
1686 {0x1f9, 15}, {0x1fa, 15}, {0x1fb, 15}, {0x1fc, 15},
1687 {0x1fd, 15}, {0x1fe, 15}, {0x1ff, 15},
1688 };
1689
1690 const VLC dcc_tab[511] = {
1691 {0x100, 16}, {0x101, 16}, {0x102, 16}, {0x103, 16},
1692 {0x104, 16}, {0x105, 16}, {0x106, 16}, {0x107, 16},
1693 {0x108, 16}, {0x109, 16}, {0x10a, 16}, {0x10b, 16},
1694 {0x10c, 16}, {0x10d, 16}, {0x10e, 16}, {0x10f, 16},
1695 {0x110, 16}, {0x111, 16}, {0x112, 16}, {0x113, 16},
1696 {0x114, 16}, {0x115, 16}, {0x116, 16}, {0x117, 16},
1697 {0x118, 16}, {0x119, 16}, {0x11a, 16}, {0x11b, 16},
1698 {0x11c, 16}, {0x11d, 16}, {0x11e, 16}, {0x11f, 16},
1699 {0x120, 16}, {0x121, 16}, {0x122, 16}, {0x123, 16},
1700 {0x124, 16}, {0x125, 16}, {0x126, 16}, {0x127, 16},
1701 {0x128, 16}, {0x129, 16}, {0x12a, 16}, {0x12b, 16},
1702 {0x12c, 16}, {0x12d, 16}, {0x12e, 16}, {0x12f, 16},
1703 {0x130, 16}, {0x131, 16}, {0x132, 16}, {0x133, 16},
1704 {0x134, 16}, {0x135, 16}, {0x136, 16}, {0x137, 16},
1705 {0x138, 16}, {0x139, 16}, {0x13a, 16}, {0x13b, 16},
1706 {0x13c, 16}, {0x13d, 16}, {0x13e, 16}, {0x13f, 16},
1707 {0x140, 16}, {0x141, 16}, {0x142, 16}, {0x143, 16},
1708 {0x144, 16}, {0x145, 16}, {0x146, 16}, {0x147, 16},
1709 {0x148, 16}, {0x149, 16}, {0x14a, 16}, {0x14b, 16},
1710 {0x14c, 16}, {0x14d, 16}, {0x14e, 16}, {0x14f, 16},
1711 {0x150, 16}, {0x151, 16}, {0x152, 16}, {0x153, 16},
1712 {0x154, 16}, {0x155, 16}, {0x156, 16}, {0x157, 16},
1713 {0x158, 16}, {0x159, 16}, {0x15a, 16}, {0x15b, 16},
1714 {0x15c, 16}, {0x15d, 16}, {0x15e, 16}, {0x15f, 16},
1715 {0x160, 16}, {0x161, 16}, {0x162, 16}, {0x163, 16},
1716 {0x164, 16}, {0x165, 16}, {0x166, 16}, {0x167, 16},
1717 {0x168, 16}, {0x169, 16}, {0x16a, 16}, {0x16b, 16},
1718 {0x16c, 16}, {0x16d, 16}, {0x16e, 16}, {0x16f, 16},
1719 {0x170, 16}, {0x171, 16}, {0x172, 16}, {0x173, 16},
1720 {0x174, 16}, {0x175, 16}, {0x176, 16}, {0x177, 16},
1721 {0x178, 16}, {0x179, 16}, {0x17a, 16}, {0x17b, 16},
1722 {0x17c, 16}, {0x17d, 16}, {0x17e, 16}, {0x17f, 16},
1723 {0x80, 14}, {0x81, 14}, {0x82, 14}, {0x83, 14},
1724 {0x84, 14}, {0x85, 14}, {0x86, 14}, {0x87, 14},
1725 {0x88, 14}, {0x89, 14}, {0x8a, 14}, {0x8b, 14},
1726 {0x8c, 14}, {0x8d, 14}, {0x8e, 14}, {0x8f, 14},
1727 {0x90, 14}, {0x91, 14}, {0x92, 14}, {0x93, 14},
1728 {0x94, 14}, {0x95, 14}, {0x96, 14}, {0x97, 14},
1729 {0x98, 14}, {0x99, 14}, {0x9a, 14}, {0x9b, 14},
1730 {0x9c, 14}, {0x9d, 14}, {0x9e, 14}, {0x9f, 14},
1731 {0xa0, 14}, {0xa1, 14}, {0xa2, 14}, {0xa3, 14},
1732 {0xa4, 14}, {0xa5, 14}, {0xa6, 14}, {0xa7, 14},
1733 {0xa8, 14}, {0xa9, 14}, {0xaa, 14}, {0xab, 14},
1734 {0xac, 14}, {0xad, 14}, {0xae, 14}, {0xaf, 14},
1735 {0xb0, 14}, {0xb1, 14}, {0xb2, 14}, {0xb3, 14},
1736 {0xb4, 14}, {0xb5, 14}, {0xb6, 14}, {0xb7, 14},
1737 {0xb8, 14}, {0xb9, 14}, {0xba, 14}, {0xbb, 14},
1738 {0xbc, 14}, {0xbd, 14}, {0xbe, 14}, {0xbf, 14},
1739 {0x40, 12}, {0x41, 12}, {0x42, 12}, {0x43, 12},
1740 {0x44, 12}, {0x45, 12}, {0x46, 12}, {0x47, 12},
1741 {0x48, 12}, {0x49, 12}, {0x4a, 12}, {0x4b, 12},
1742 {0x4c, 12}, {0x4d, 12}, {0x4e, 12}, {0x4f, 12},
1743 {0x50, 12}, {0x51, 12}, {0x52, 12}, {0x53, 12},
1744 {0x54, 12}, {0x55, 12}, {0x56, 12}, {0x57, 12},
1745 {0x58, 12}, {0x59, 12}, {0x5a, 12}, {0x5b, 12},
1746 {0x5c, 12}, {0x5d, 12}, {0x5e, 12}, {0x5f, 12},
1747 {0x20, 10}, {0x21, 10}, {0x22, 10}, {0x23, 10},
1748 {0x24, 10}, {0x25, 10}, {0x26, 10}, {0x27, 10},
1749 {0x28, 10}, {0x29, 10}, {0x2a, 10}, {0x2b, 10},
1750 {0x2c, 10}, {0x2d, 10}, {0x2e, 10}, {0x2f, 10},
1751 {0x10, 8}, {0x11, 8}, {0x12, 8}, {0x13, 8},
1752 {0x14, 8}, {0x15, 8}, {0x16, 8}, {0x17, 8},
1753 {0x08, 6}, {0x09, 6}, {0x0a, 6}, {0x0b, 6},
1754 {0x04, 4}, {0x05, 4}, {0x04, 3}, {0x03, 2},
1755 {0x05, 3}, {0x06, 4}, {0x07, 4}, {0x0c, 6},
1756 {0x0d, 6}, {0x0e, 6}, {0x0f, 6}, {0x18, 8},
1757 {0x19, 8}, {0x1a, 8}, {0x1b, 8}, {0x1c, 8},
1758 {0x1d, 8}, {0x1e, 8}, {0x1f, 8}, {0x30, 10},
1759 {0x31, 10}, {0x32, 10}, {0x33, 10}, {0x34, 10},
1760 {0x35, 10}, {0x36, 10}, {0x37, 10}, {0x38, 10},
1761 {0x39, 10}, {0x3a, 10}, {0x3b, 10}, {0x3c, 10},
1762 {0x3d, 10}, {0x3e, 10}, {0x3f, 10}, {0x60, 12},
1763 {0x61, 12}, {0x62, 12}, {0x63, 12}, {0x64, 12},
1764 {0x65, 12}, {0x66, 12}, {0x67, 12}, {0x68, 12},
1765 {0x69, 12}, {0x6a, 12}, {0x6b, 12}, {0x6c, 12},
1766 {0x6d, 12}, {0x6e, 12}, {0x6f, 12}, {0x70, 12},
1767 {0x71, 12}, {0x72, 12}, {0x73, 12}, {0x74, 12},
1768 {0x75, 12}, {0x76, 12}, {0x77, 12}, {0x78, 12},
1769 {0x79, 12}, {0x7a, 12}, {0x7b, 12}, {0x7c, 12},
1770 {0x7d, 12}, {0x7e, 12}, {0x7f, 12}, {0xc0, 14},
1771 {0xc1, 14}, {0xc2, 14}, {0xc3, 14}, {0xc4, 14},
1772 {0xc5, 14}, {0xc6, 14}, {0xc7, 14}, {0xc8, 14},
1773 {0xc9, 14}, {0xca, 14}, {0xcb, 14}, {0xcc, 14},
1774 {0xcd, 14}, {0xce, 14}, {0xcf, 14}, {0xd0, 14},
1775 {0xd1, 14}, {0xd2, 14}, {0xd3, 14}, {0xd4, 14},
1776 {0xd5, 14}, {0xd6, 14}, {0xd7, 14}, {0xd8, 14},
1777 {0xd9, 14}, {0xda, 14}, {0xdb, 14}, {0xdc, 14},
1778 {0xdd, 14}, {0xde, 14}, {0xdf, 14}, {0xe0, 14},
1779 {0xe1, 14}, {0xe2, 14}, {0xe3, 14}, {0xe4, 14},
1780 {0xe5, 14}, {0xe6, 14}, {0xe7, 14}, {0xe8, 14},
1781 {0xe9, 14}, {0xea, 14}, {0xeb, 14}, {0xec, 14},
1782 {0xed, 14}, {0xee, 14}, {0xef, 14}, {0xf0, 14},
1783 {0xf1, 14}, {0xf2, 14}, {0xf3, 14}, {0xf4, 14},
1784 {0xf5, 14}, {0xf6, 14}, {0xf7, 14}, {0xf8, 14},
1785 {0xf9, 14}, {0xfa, 14}, {0xfb, 14}, {0xfc, 14},
1786 {0xfd, 14}, {0xfe, 14}, {0xff, 14}, {0x180, 16},
1787 {0x181, 16}, {0x182, 16}, {0x183, 16}, {0x184, 16},
1788 {0x185, 16}, {0x186, 16}, {0x187, 16}, {0x188, 16},
1789 {0x189, 16}, {0x18a, 16}, {0x18b, 16}, {0x18c, 16},
1790 {0x18d, 16}, {0x18e, 16}, {0x18f, 16}, {0x190, 16},
1791 {0x191, 16}, {0x192, 16}, {0x193, 16}, {0x194, 16},
1792 {0x195, 16}, {0x196, 16}, {0x197, 16}, {0x198, 16},
1793 {0x199, 16}, {0x19a, 16}, {0x19b, 16}, {0x19c, 16},
1794 {0x19d, 16}, {0x19e, 16}, {0x19f, 16}, {0x1a0, 16},
1795 {0x1a1, 16}, {0x1a2, 16}, {0x1a3, 16}, {0x1a4, 16},
1796 {0x1a5, 16}, {0x1a6, 16}, {0x1a7, 16}, {0x1a8, 16},
1797 {0x1a9, 16}, {0x1aa, 16}, {0x1ab, 16}, {0x1ac, 16},
1798 {0x1ad, 16}, {0x1ae, 16}, {0x1af, 16}, {0x1b0, 16},
1799 {0x1b1, 16}, {0x1b2, 16}, {0x1b3, 16}, {0x1b4, 16},
1800 {0x1b5, 16}, {0x1b6, 16}, {0x1b7, 16}, {0x1b8, 16},
1801 {0x1b9, 16}, {0x1ba, 16}, {0x1bb, 16}, {0x1bc, 16},
1802 {0x1bd, 16}, {0x1be, 16}, {0x1bf, 16}, {0x1c0, 16},
1803 {0x1c1, 16}, {0x1c2, 16}, {0x1c3, 16}, {0x1c4, 16},
1804 {0x1c5, 16}, {0x1c6, 16}, {0x1c7, 16}, {0x1c8, 16},
1805 {0x1c9, 16}, {0x1ca, 16}, {0x1cb, 16}, {0x1cc, 16},
1806 {0x1cd, 16}, {0x1ce, 16}, {0x1cf, 16}, {0x1d0, 16},
1807 {0x1d1, 16}, {0x1d2, 16}, {0x1d3, 16}, {0x1d4, 16},
1808 {0x1d5, 16}, {0x1d6, 16}, {0x1d7, 16}, {0x1d8, 16},
1809 {0x1d9, 16}, {0x1da, 16}, {0x1db, 16}, {0x1dc, 16},
1810 {0x1dd, 16}, {0x1de, 16}, {0x1df, 16}, {0x1e0, 16},
1811 {0x1e1, 16}, {0x1e2, 16}, {0x1e3, 16}, {0x1e4, 16},
1812 {0x1e5, 16}, {0x1e6, 16}, {0x1e7, 16}, {0x1e8, 16},
1813 {0x1e9, 16}, {0x1ea, 16}, {0x1eb, 16}, {0x1ec, 16},
1814 {0x1ed, 16}, {0x1ee, 16}, {0x1ef, 16}, {0x1f0, 16},
1815 {0x1f1, 16}, {0x1f2, 16}, {0x1f3, 16}, {0x1f4, 16},
1816 {0x1f5, 16}, {0x1f6, 16}, {0x1f7, 16}, {0x1f8, 16},
1817 {0x1f9, 16}, {0x1fa, 16}, {0x1fb, 16}, {0x1fc, 16},
1818 {0x1fd, 16}, {0x1fe, 16}, {0x1ff, 16},
1819 };
1820
1821
1822 const VLC mb_motion_table[65] = {
1823 {0x05, 13}, {0x07, 13}, {0x05, 12}, {0x07, 12},
1824 {0x09, 12}, {0x0b, 12}, {0x0d, 12}, {0x0f, 12},
1825 {0x09, 11}, {0x0b, 11}, {0x0d, 11}, {0x0f, 11},
1826 {0x11, 11}, {0x13, 11}, {0x15, 11}, {0x17, 11},
1827 {0x19, 11}, {0x1b, 11}, {0x1d, 11}, {0x1f, 11},
1828 {0x21, 11}, {0x23, 11}, {0x13, 10}, {0x15, 10},
1829 {0x17, 10}, {0x07, 8}, {0x09, 8}, {0x0b, 8},
1830 {0x07, 7}, {0x03, 5}, {0x03, 4}, {0x03, 3},
1831 {0x01, 1}, {0x02, 3}, {0x02, 4}, {0x02, 5},
1832 {0x06, 7}, {0x0a, 8}, {0x08, 8}, {0x06, 8},
1833 {0x16, 10}, {0x14, 10}, {0x12, 10}, {0x22, 11},
1834 {0x20, 11}, {0x1e, 11}, {0x1c, 11}, {0x1a, 11},
1835 {0x18, 11}, {0x16, 11}, {0x14, 11}, {0x12, 11},
1836 {0x10, 11}, {0x0e, 11}, {0x0c, 11}, {0x0a, 11},
1837 {0x08, 11}, {0x0e, 12}, {0x0c, 12}, {0x0a, 12},
1838 {0x08, 12}, {0x06, 12}, {0x04, 12}, {0x06, 13},
1839 {0x04, 13}
1840 };
1841
1842
1843 /******************************************************************
1844 * decoder tables *
1845 ******************************************************************/
1846
1847 VLC const mcbpc_intra_table[64] = {
1848 {-1, 0}, {20, 6}, {36, 6}, {52, 6}, {4, 4}, {4, 4}, {4, 4}, {4, 4},
1849 {19, 3}, {19, 3}, {19, 3}, {19, 3}, {19, 3}, {19, 3}, {19, 3}, {19, 3},
1850 {35, 3}, {35, 3}, {35, 3}, {35, 3}, {35, 3}, {35, 3}, {35, 3}, {35, 3},
1851 {51, 3}, {51, 3}, {51, 3}, {51, 3}, {51, 3}, {51, 3}, {51, 3}, {51, 3},
1852 {3, 1}, {3, 1}, {3, 1}, {3, 1}, {3, 1}, {3, 1}, {3, 1}, {3, 1},
1853 {3, 1}, {3, 1}, {3, 1}, {3, 1}, {3, 1}, {3, 1}, {3, 1}, {3, 1},
1854 {3, 1}, {3, 1}, {3, 1}, {3, 1}, {3, 1}, {3, 1}, {3, 1}, {3, 1},
1855 {3, 1}, {3, 1}, {3, 1}, {3, 1}, {3, 1}, {3, 1}, {3, 1}, {3, 1}
1856 };
1857
1858 VLC const mcbpc_inter_table[257] = {
1859 {VLC_ERROR, 0}, {255, 9}, {52, 9}, {36, 9}, {20, 9}, {49, 9}, {35, 8}, {35, 8},
1860 {19, 8}, {19, 8}, {50, 8}, {50, 8}, {51, 7}, {51, 7}, {51, 7}, {51, 7},
1861 {34, 7}, {34, 7}, {34, 7}, {34, 7}, {18, 7}, {18, 7}, {18, 7}, {18, 7},
1862 {33, 7}, {33, 7}, {33, 7}, {33, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7},
1863 {4, 6}, {4, 6}, {4, 6}, {4, 6}, {4, 6}, {4, 6}, {4, 6}, {4, 6},
1864 {48, 6}, {48, 6}, {48, 6}, {48, 6}, {48, 6}, {48, 6}, {48, 6}, {48, 6},
1865 {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5},
1866 {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5},
1867 {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4},
1868 {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4},
1869 {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4},
1870 {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4},
1871 {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4},
1872 {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4},
1873 {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4},
1874 {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4},
1875 {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3},
1876 {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3},
1877 {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3},
1878 {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3},
1879 {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3},
1880 {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3},
1881 {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3},
1882 {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3},
1883 {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3},
1884 {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3},
1885 {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3},
1886 {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3},
1887 {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3},
1888 {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3},
1889 {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3},
1890 {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3},
1891 {0, 1}
1892 };
1893
1894 VLC const cbpy_table[64] = {
1895 {-1, 0}, {-1, 0}, {6, 6}, {9, 6}, {8, 5}, {8, 5}, {4, 5}, {4, 5},
1896 {2, 5}, {2, 5}, {1, 5}, {1, 5}, {0, 4}, {0, 4}, {0, 4}, {0, 4},
1897 {12, 4}, {12, 4}, {12, 4}, {12, 4}, {10, 4}, {10, 4}, {10, 4}, {10, 4},
1898 {14, 4}, {14, 4}, {14, 4}, {14, 4}, {5, 4}, {5, 4}, {5, 4}, {5, 4},
1899 {13, 4}, {13, 4}, {13, 4}, {13, 4}, {3, 4}, {3, 4}, {3, 4}, {3, 4},
1900 {11, 4}, {11, 4}, {11, 4}, {11, 4}, {7, 4}, {7, 4}, {7, 4}, {7, 4},
1901 {15, 2}, {15, 2}, {15, 2}, {15, 2}, {15, 2}, {15, 2}, {15, 2}, {15, 2},
1902 {15, 2}, {15, 2}, {15, 2}, {15, 2}, {15, 2}, {15, 2}, {15, 2}, {15, 2}
1903 };
1904
1905 VLC const TMNMVtab0[] = {
1906 {3, 4}, {-3, 4}, {2, 3}, {2, 3}, {-2, 3}, {-2, 3}, {1, 2},
1907 {1, 2}, {1, 2}, {1, 2}, {-1, 2}, {-1, 2}, {-1, 2}, {-1, 2}
1908 };
1909
1910 VLC const TMNMVtab1[] = {
1911 {12, 10}, {-12, 10}, {11, 10}, {-11, 10},
1912 {10, 9}, {10, 9}, {-10, 9}, {-10, 9},
1913 {9, 9}, {9, 9}, {-9, 9}, {-9, 9},
1914 {8, 9}, {8, 9}, {-8, 9}, {-8, 9},
1915 {7, 7}, {7, 7}, {7, 7}, {7, 7},
1916 {7, 7}, {7, 7}, {7, 7}, {7, 7},
1917 {-7, 7}, {-7, 7}, {-7, 7}, {-7, 7},
1918 {-7, 7}, {-7, 7}, {-7, 7}, {-7, 7},
1919 {6, 7}, {6, 7}, {6, 7}, {6, 7},
1920 {6, 7}, {6, 7}, {6, 7}, {6, 7},
1921 {-6, 7}, {-6, 7}, {-6, 7}, {-6, 7},
1922 {-6, 7}, {-6, 7}, {-6, 7}, {-6, 7},
1923 {5, 7}, {5, 7}, {5, 7}, {5, 7},
1924 {5, 7}, {5, 7}, {5, 7}, {5, 7},
1925 {-5, 7}, {-5, 7}, {-5, 7}, {-5, 7},
1926 {-5, 7}, {-5, 7}, {-5, 7}, {-5, 7},
1927 {4, 6}, {4, 6}, {4, 6}, {4, 6},
1928 {4, 6}, {4, 6}, {4, 6}, {4, 6},
1929 {4, 6}, {4, 6}, {4, 6}, {4, 6},
1930 {4, 6}, {4, 6}, {4, 6}, {4, 6},
1931 {-4, 6}, {-4, 6}, {-4, 6}, {-4, 6},
1932 {-4, 6}, {-4, 6}, {-4, 6}, {-4, 6},
1933 {-4, 6}, {-4, 6}, {-4, 6}, {-4, 6},
1934 {-4, 6}, {-4, 6}, {-4, 6}, {-4, 6}
1935 };
1936
1937 VLC const TMNMVtab2[] = {
1938 {32, 12}, {-32, 12}, {31, 12}, {-31, 12},
1939 {30, 11}, {30, 11}, {-30, 11}, {-30, 11},
1940 {29, 11}, {29, 11}, {-29, 11}, {-29, 11},
1941 {28, 11}, {28, 11}, {-28, 11}, {-28, 11},
1942 {27, 11}, {27, 11}, {-27, 11}, {-27, 11},
1943 {26, 11}, {26, 11}, {-26, 11}, {-26, 11},
1944 {25, 11}, {25, 11}, {-25, 11}, {-25, 11},
1945 {24, 10}, {24, 10}, {24, 10}, {24, 10},
1946 {-24, 10}, {-24, 10}, {-24, 10}, {-24, 10},
1947 {23, 10}, {23, 10}, {23, 10}, {23, 10},
1948 {-23, 10}, {-23, 10}, {-23, 10}, {-23, 10},
1949 {22, 10}, {22, 10}, {22, 10}, {22, 10},
1950 {-22, 10}, {-22, 10}, {-22, 10}, {-22, 10},
1951 {21, 10}, {21, 10}, {21, 10}, {21, 10},
1952 {-21, 10}, {-21, 10}, {-21, 10}, {-21, 10},
1953 {20, 10}, {20, 10}, {20, 10}, {20, 10},
1954 {-20, 10}, {-20, 10}, {-20, 10}, {-20, 10},
1955 {19, 10}, {19, 10}, {19, 10}, {19, 10},
1956 {-19, 10}, {-19, 10}, {-19, 10}, {-19, 10},
1957 {18, 10}, {18, 10}, {18, 10}, {18, 10},
1958 {-18, 10}, {-18, 10}, {-18, 10}, {-18, 10},
1959 {17, 10}, {17, 10}, {17, 10}, {17, 10},
1960 {-17, 10}, {-17, 10}, {-17, 10}, {-17, 10},
1961 {16, 10}, {16, 10}, {16, 10}, {16, 10},
1962 {-16, 10}, {-16, 10}, {-16, 10}, {-16, 10},
1963 {15, 10}, {15, 10}, {15, 10}, {15, 10},
1964 {-15, 10}, {-15, 10}, {-15, 10}, {-15, 10},
1965 {14, 10}, {14, 10}, {14, 10}, {14, 10},
1966 {-14, 10}, {-14, 10}, {-14, 10}, {-14, 10},
1967 {13, 10}, {13, 10}, {13, 10}, {13, 10},
1968 {-13, 10}, {-13, 10}, {-13, 10}, {-13, 10},
1969 {0, 0}, {0, 0}, {0, 0}, {0, 0}
1970 };
1971
1972 short const dc_threshold[] = {
1973 26708, 29545, 29472, 26223, 30580, 29281, 8293, 29545,
1974 25632, 29285, 30313, 25701, 26144, 28530, 8301, 26740,
1975 8293, 20039, 8277, 20551, 8268, 30296, 17513, 25376,
1976 25711, 25445, 10272, 11825, 11827, 10544, 2606, 28505,
1977 29301, 29472, 26223, 30580, 29281, 8293, 26980, 29811,
1978 26994, 30050, 28532, 8306, 24936, 8307, 28532, 26400,
1979 30313, 8293, 25441, 25955, 29555, 29728, 8303, 29801,
1980 8307, 28531, 29301, 25955, 25376, 25711, 11877, 10
1981 };
1982
1983 VLC const dc_lum_tab[] = {
1984 {0, 0}, {4, 3}, {3, 3}, {0, 3},
1985 {2, 2}, {2, 2}, {1, 2}, {1, 2},
1986 };
1987