Use common define for x86_32 and x86_64.
[libav.git] / libavcodec / msmpeg4.c
1 /*
2 * MSMPEG4 backend for ffmpeg encoder and decoder
3 * Copyright (c) 2001 Fabrice Bellard.
4 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
5 *
6 * This file is part of FFmpeg.
7 *
8 * FFmpeg is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12 *
13 * FFmpeg 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 GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with FFmpeg; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21 *
22 * msmpeg4v1 & v2 stuff by Michael Niedermayer <michaelni@gmx.at>
23 */
24
25 /**
26 * @file msmpeg4.c
27 * MSMPEG4 backend for ffmpeg encoder and decoder.
28 */
29
30 #include "avcodec.h"
31 #include "dsputil.h"
32 #include "mpegvideo.h"
33
34 /*
35 * You can also call this codec : MPEG4 with a twist !
36 *
37 * TODO:
38 * - (encoding) select best mv table (two choices)
39 * - (encoding) select best vlc/dc table
40 */
41 //#define DEBUG
42
43 #define DC_VLC_BITS 9
44 #define CBPY_VLC_BITS 6
45 #define INTER_INTRA_VLC_BITS 3
46 #define V1_INTRA_CBPC_VLC_BITS 6
47 #define V1_INTER_CBPC_VLC_BITS 6
48 #define V2_INTRA_CBPC_VLC_BITS 3
49 #define V2_MB_TYPE_VLC_BITS 7
50 #define MV_VLC_BITS 9
51 #define V2_MV_VLC_BITS 9
52 #define TEX_VLC_BITS 9
53 #define MB_NON_INTRA_VLC_BITS 9
54 #define MB_INTRA_VLC_BITS 9
55
56 #define II_BITRATE 128*1024
57 #define MBAC_BITRATE 50*1024
58
59 #define DEFAULT_INTER_INDEX 3
60
61 static uint32_t v2_dc_lum_table[512][2];
62 static uint32_t v2_dc_chroma_table[512][2];
63
64 static inline void msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n);
65 static inline int msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
66 int n, int coded, const uint8_t *scantable);
67 static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr);
68 static int msmpeg4_decode_motion(MpegEncContext * s,
69 int *mx_ptr, int *my_ptr);
70 static void init_h263_dc_for_msmpeg4(void);
71 static inline void msmpeg4_memsetw(short *tab, int val, int n);
72 #ifdef CONFIG_ENCODERS
73 static void msmpeg4v2_encode_motion(MpegEncContext * s, int val);
74 static int get_size_of_code(MpegEncContext * s, RLTable *rl, int last, int run, int level, int intra);
75 #endif //CONFIG_ENCODERS
76 static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64]);
77 static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64]);
78 static int wmv2_decode_mb(MpegEncContext *s, DCTELEM block[6][64]);
79
80 /* vc1 externs */
81 extern uint8_t wmv3_dc_scale_table[32];
82
83 #ifdef DEBUG
84 int intra_count = 0;
85 int frame_count = 0;
86 #endif
87
88 #include "msmpeg4data.h"
89
90 #ifdef CONFIG_ENCODERS //strangely gcc includes this even if its not references
91 static uint8_t rl_length[NB_RL_TABLES][MAX_LEVEL+1][MAX_RUN+1][2];
92 #endif //CONFIG_ENCODERS
93
94 static void common_init(MpegEncContext * s)
95 {
96 static int inited=0;
97
98 switch(s->msmpeg4_version){
99 case 1:
100 case 2:
101 s->y_dc_scale_table=
102 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
103 break;
104 case 3:
105 if(s->workaround_bugs){
106 s->y_dc_scale_table= old_ff_y_dc_scale_table;
107 s->c_dc_scale_table= old_ff_c_dc_scale_table;
108 } else{
109 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table;
110 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
111 }
112 break;
113 case 4:
114 case 5:
115 s->y_dc_scale_table= wmv1_y_dc_scale_table;
116 s->c_dc_scale_table= wmv1_c_dc_scale_table;
117 break;
118 #if defined(CONFIG_WMV3_DECODER)||defined(CONFIG_VC1_DECODER)
119 case 6:
120 s->y_dc_scale_table= wmv3_dc_scale_table;
121 s->c_dc_scale_table= wmv3_dc_scale_table;
122 break;
123 #endif
124
125 }
126
127
128 if(s->msmpeg4_version>=4){
129 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , wmv1_scantable[1]);
130 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, wmv1_scantable[2]);
131 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, wmv1_scantable[3]);
132 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , wmv1_scantable[0]);
133 }
134 //Note the default tables are set in common_init in mpegvideo.c
135
136 if(!inited){
137 inited=1;
138
139 init_h263_dc_for_msmpeg4();
140 }
141 }
142
143 #ifdef CONFIG_ENCODERS
144
145 /* build the table which associate a (x,y) motion vector to a vlc */
146 static void init_mv_table(MVTable *tab)
147 {
148 int i, x, y;
149
150 tab->table_mv_index = av_malloc(sizeof(uint16_t) * 4096);
151 /* mark all entries as not used */
152 for(i=0;i<4096;i++)
153 tab->table_mv_index[i] = tab->n;
154
155 for(i=0;i<tab->n;i++) {
156 x = tab->table_mvx[i];
157 y = tab->table_mvy[i];
158 tab->table_mv_index[(x << 6) | y] = i;
159 }
160 }
161
162 static void code012(PutBitContext *pb, int n)
163 {
164 if (n == 0) {
165 put_bits(pb, 1, 0);
166 } else {
167 put_bits(pb, 1, 1);
168 put_bits(pb, 1, (n >= 2));
169 }
170 }
171
172 void ff_msmpeg4_encode_init(MpegEncContext *s)
173 {
174 static int init_done=0;
175 int i;
176
177 common_init(s);
178 if(s->msmpeg4_version>=4){
179 s->min_qcoeff= -255;
180 s->max_qcoeff= 255;
181 }
182
183 if (!init_done) {
184 /* init various encoding tables */
185 init_done = 1;
186 init_mv_table(&mv_tables[0]);
187 init_mv_table(&mv_tables[1]);
188 for(i=0;i<NB_RL_TABLES;i++)
189 init_rl(&rl_table[i], 1);
190
191 for(i=0; i<NB_RL_TABLES; i++){
192 int level;
193 for(level=0; level<=MAX_LEVEL; level++){
194 int run;
195 for(run=0; run<=MAX_RUN; run++){
196 int last;
197 for(last=0; last<2; last++){
198 rl_length[i][level][run][last]= get_size_of_code(s, &rl_table[ i], last, run, level, 0);
199 }
200 }
201 }
202 }
203 }
204 }
205
206 static int get_size_of_code(MpegEncContext * s, RLTable *rl, int last, int run, int level, int intra){
207 int size=0;
208 int code;
209 int run_diff= intra ? 0 : 1;
210
211 code = get_rl_index(rl, last, run, level);
212 size+= rl->table_vlc[code][1];
213 if (code == rl->n) {
214 int level1, run1;
215
216 level1 = level - rl->max_level[last][run];
217 if (level1 < 1)
218 goto esc2;
219 code = get_rl_index(rl, last, run, level1);
220 if (code == rl->n) {
221 esc2:
222 size++;
223 if (level > MAX_LEVEL)
224 goto esc3;
225 run1 = run - rl->max_run[last][level] - run_diff;
226 if (run1 < 0)
227 goto esc3;
228 code = get_rl_index(rl, last, run1, level);
229 if (code == rl->n) {
230 esc3:
231 /* third escape */
232 size+=1+1+6+8;
233 } else {
234 /* second escape */
235 size+= 1+1+ rl->table_vlc[code][1];
236 }
237 } else {
238 /* first escape */
239 size+= 1+1+ rl->table_vlc[code][1];
240 }
241 } else {
242 size++;
243 }
244 return size;
245 }
246
247 static void find_best_tables(MpegEncContext * s)
248 {
249 int i;
250 int best =-1, best_size =9999999;
251 int chroma_best=-1, best_chroma_size=9999999;
252
253 for(i=0; i<3; i++){
254 int level;
255 int chroma_size=0;
256 int size=0;
257
258 if(i>0){// ;)
259 size++;
260 chroma_size++;
261 }
262 for(level=0; level<=MAX_LEVEL; level++){
263 int run;
264 for(run=0; run<=MAX_RUN; run++){
265 int last;
266 const int last_size= size + chroma_size;
267 for(last=0; last<2; last++){
268 int inter_count = s->ac_stats[0][0][level][run][last] + s->ac_stats[0][1][level][run][last];
269 int intra_luma_count = s->ac_stats[1][0][level][run][last];
270 int intra_chroma_count= s->ac_stats[1][1][level][run][last];
271
272 if(s->pict_type==I_TYPE){
273 size += intra_luma_count *rl_length[i ][level][run][last];
274 chroma_size+= intra_chroma_count*rl_length[i+3][level][run][last];
275 }else{
276 size+= intra_luma_count *rl_length[i ][level][run][last]
277 +intra_chroma_count*rl_length[i+3][level][run][last]
278 +inter_count *rl_length[i+3][level][run][last];
279 }
280 }
281 if(last_size == size+chroma_size) break;
282 }
283 }
284 if(size<best_size){
285 best_size= size;
286 best= i;
287 }
288 if(chroma_size<best_chroma_size){
289 best_chroma_size= chroma_size;
290 chroma_best= i;
291 }
292 }
293
294 // printf("type:%d, best:%d, qp:%d, var:%d, mcvar:%d, size:%d //\n",
295 // s->pict_type, best, s->qscale, s->mb_var_sum, s->mc_mb_var_sum, best_size);
296
297 if(s->pict_type==P_TYPE) chroma_best= best;
298
299 memset(s->ac_stats, 0, sizeof(int)*(MAX_LEVEL+1)*(MAX_RUN+1)*2*2*2);
300
301 s->rl_table_index = best;
302 s->rl_chroma_table_index= chroma_best;
303
304 if(s->pict_type != s->last_non_b_pict_type){
305 s->rl_table_index= 2;
306 if(s->pict_type==I_TYPE)
307 s->rl_chroma_table_index= 1;
308 else
309 s->rl_chroma_table_index= 2;
310 }
311
312 }
313
314 /* write MSMPEG4 compatible frame header */
315 void msmpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
316 {
317 find_best_tables(s);
318
319 align_put_bits(&s->pb);
320 put_bits(&s->pb, 2, s->pict_type - 1);
321
322 put_bits(&s->pb, 5, s->qscale);
323 if(s->msmpeg4_version<=2){
324 s->rl_table_index = 2;
325 s->rl_chroma_table_index = 2;
326 }
327
328 s->dc_table_index = 1;
329 s->mv_table_index = 1; /* only if P frame */
330 s->use_skip_mb_code = 1; /* only if P frame */
331 s->per_mb_rl_table = 0;
332 if(s->msmpeg4_version==4)
333 s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE && s->pict_type==P_TYPE);
334 //printf("%d %d %d %d %d\n", s->pict_type, s->bit_rate, s->inter_intra_pred, s->width, s->height);
335
336 if (s->pict_type == I_TYPE) {
337 s->slice_height= s->mb_height/1;
338 put_bits(&s->pb, 5, 0x16 + s->mb_height/s->slice_height);
339
340 if(s->msmpeg4_version==4){
341 msmpeg4_encode_ext_header(s);
342 if(s->bit_rate>MBAC_BITRATE)
343 put_bits(&s->pb, 1, s->per_mb_rl_table);
344 }
345
346 if(s->msmpeg4_version>2){
347 if(!s->per_mb_rl_table){
348 code012(&s->pb, s->rl_chroma_table_index);
349 code012(&s->pb, s->rl_table_index);
350 }
351
352 put_bits(&s->pb, 1, s->dc_table_index);
353 }
354 } else {
355 put_bits(&s->pb, 1, s->use_skip_mb_code);
356
357 if(s->msmpeg4_version==4 && s->bit_rate>MBAC_BITRATE)
358 put_bits(&s->pb, 1, s->per_mb_rl_table);
359
360 if(s->msmpeg4_version>2){
361 if(!s->per_mb_rl_table)
362 code012(&s->pb, s->rl_table_index);
363
364 put_bits(&s->pb, 1, s->dc_table_index);
365
366 put_bits(&s->pb, 1, s->mv_table_index);
367 }
368 }
369
370 s->esc3_level_length= 0;
371 s->esc3_run_length= 0;
372
373 #ifdef DEBUG
374 intra_count = 0;
375 av_log(s->avctx, AV_LOG_DEBUG, "*****frame %d:\n", frame_count++);
376 #endif
377 }
378
379 void msmpeg4_encode_ext_header(MpegEncContext * s)
380 {
381 put_bits(&s->pb, 5, s->avctx->time_base.den / s->avctx->time_base.num); //yes 29.97 -> 29
382
383 put_bits(&s->pb, 11, FFMIN(s->bit_rate/1024, 2047));
384
385 if(s->msmpeg4_version>=3)
386 put_bits(&s->pb, 1, s->flipflop_rounding);
387 else
388 assert(s->flipflop_rounding==0);
389 }
390
391 #endif //CONFIG_ENCODERS
392
393 /* predict coded block */
394 static inline int coded_block_pred(MpegEncContext * s, int n, uint8_t **coded_block_ptr)
395 {
396 int xy, wrap, pred, a, b, c;
397
398 xy = s->block_index[n];
399 wrap = s->b8_stride;
400
401 /* B C
402 * A X
403 */
404 a = s->coded_block[xy - 1 ];
405 b = s->coded_block[xy - 1 - wrap];
406 c = s->coded_block[xy - wrap];
407
408 if (b == c) {
409 pred = a;
410 } else {
411 pred = c;
412 }
413
414 /* store value */
415 *coded_block_ptr = &s->coded_block[xy];
416
417 return pred;
418 }
419
420 #ifdef CONFIG_ENCODERS
421
422 static void msmpeg4_encode_motion(MpegEncContext * s,
423 int mx, int my)
424 {
425 int code;
426 MVTable *mv;
427
428 /* modulo encoding */
429 /* WARNING : you cannot reach all the MVs even with the modulo
430 encoding. This is a somewhat strange compromise they took !!! */
431 if (mx <= -64)
432 mx += 64;
433 else if (mx >= 64)
434 mx -= 64;
435 if (my <= -64)
436 my += 64;
437 else if (my >= 64)
438 my -= 64;
439
440 mx += 32;
441 my += 32;
442 #if 0
443 if ((unsigned)mx >= 64 ||
444 (unsigned)my >= 64)
445 av_log(s->avctx, AV_LOG_ERROR, "error mx=%d my=%d\n", mx, my);
446 #endif
447 mv = &mv_tables[s->mv_table_index];
448
449 code = mv->table_mv_index[(mx << 6) | my];
450 put_bits(&s->pb,
451 mv->table_mv_bits[code],
452 mv->table_mv_code[code]);
453 if (code == mv->n) {
454 /* escape : code litterally */
455 put_bits(&s->pb, 6, mx);
456 put_bits(&s->pb, 6, my);
457 }
458 }
459
460 static inline void handle_slices(MpegEncContext *s){
461 if (s->mb_x == 0) {
462 if (s->slice_height && (s->mb_y % s->slice_height) == 0) {
463 if(s->msmpeg4_version < 4){
464 ff_mpeg4_clean_buffers(s);
465 }
466 s->first_slice_line = 1;
467 } else {
468 s->first_slice_line = 0;
469 }
470 }
471 }
472
473 void msmpeg4_encode_mb(MpegEncContext * s,
474 DCTELEM block[6][64],
475 int motion_x, int motion_y)
476 {
477 int cbp, coded_cbp, i;
478 int pred_x, pred_y;
479 uint8_t *coded_block;
480
481 handle_slices(s);
482
483 if (!s->mb_intra) {
484 /* compute cbp */
485 cbp = 0;
486 for (i = 0; i < 6; i++) {
487 if (s->block_last_index[i] >= 0)
488 cbp |= 1 << (5 - i);
489 }
490 if (s->use_skip_mb_code && (cbp | motion_x | motion_y) == 0) {
491 /* skip macroblock */
492 put_bits(&s->pb, 1, 1);
493 s->last_bits++;
494 s->misc_bits++;
495 s->skip_count++;
496
497 return;
498 }
499 if (s->use_skip_mb_code)
500 put_bits(&s->pb, 1, 0); /* mb coded */
501
502 if(s->msmpeg4_version<=2){
503 put_bits(&s->pb,
504 v2_mb_type[cbp&3][1],
505 v2_mb_type[cbp&3][0]);
506 if((cbp&3) != 3) coded_cbp= cbp ^ 0x3C;
507 else coded_cbp= cbp;
508
509 put_bits(&s->pb,
510 cbpy_tab[coded_cbp>>2][1],
511 cbpy_tab[coded_cbp>>2][0]);
512
513 s->misc_bits += get_bits_diff(s);
514
515 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
516 msmpeg4v2_encode_motion(s, motion_x - pred_x);
517 msmpeg4v2_encode_motion(s, motion_y - pred_y);
518 }else{
519 put_bits(&s->pb,
520 table_mb_non_intra[cbp + 64][1],
521 table_mb_non_intra[cbp + 64][0]);
522
523 s->misc_bits += get_bits_diff(s);
524
525 /* motion vector */
526 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
527 msmpeg4_encode_motion(s, motion_x - pred_x,
528 motion_y - pred_y);
529 }
530
531 s->mv_bits += get_bits_diff(s);
532
533 for (i = 0; i < 6; i++) {
534 msmpeg4_encode_block(s, block[i], i);
535 }
536 s->p_tex_bits += get_bits_diff(s);
537 } else {
538 /* compute cbp */
539 cbp = 0;
540 coded_cbp = 0;
541 for (i = 0; i < 6; i++) {
542 int val, pred;
543 val = (s->block_last_index[i] >= 1);
544 cbp |= val << (5 - i);
545 if (i < 4) {
546 /* predict value for close blocks only for luma */
547 pred = coded_block_pred(s, i, &coded_block);
548 *coded_block = val;
549 val = val ^ pred;
550 }
551 coded_cbp |= val << (5 - i);
552 }
553 #if 0
554 if (coded_cbp)
555 printf("cbp=%x %x\n", cbp, coded_cbp);
556 #endif
557
558 if(s->msmpeg4_version<=2){
559 if (s->pict_type == I_TYPE) {
560 put_bits(&s->pb,
561 v2_intra_cbpc[cbp&3][1], v2_intra_cbpc[cbp&3][0]);
562 } else {
563 if (s->use_skip_mb_code)
564 put_bits(&s->pb, 1, 0); /* mb coded */
565 put_bits(&s->pb,
566 v2_mb_type[(cbp&3) + 4][1],
567 v2_mb_type[(cbp&3) + 4][0]);
568 }
569 put_bits(&s->pb, 1, 0); /* no AC prediction yet */
570 put_bits(&s->pb,
571 cbpy_tab[cbp>>2][1],
572 cbpy_tab[cbp>>2][0]);
573 }else{
574 if (s->pict_type == I_TYPE) {
575 put_bits(&s->pb,
576 ff_msmp4_mb_i_table[coded_cbp][1], ff_msmp4_mb_i_table[coded_cbp][0]);
577 } else {
578 if (s->use_skip_mb_code)
579 put_bits(&s->pb, 1, 0); /* mb coded */
580 put_bits(&s->pb,
581 table_mb_non_intra[cbp][1],
582 table_mb_non_intra[cbp][0]);
583 }
584 put_bits(&s->pb, 1, 0); /* no AC prediction yet */
585 if(s->inter_intra_pred){
586 s->h263_aic_dir=0;
587 put_bits(&s->pb, table_inter_intra[s->h263_aic_dir][1], table_inter_intra[s->h263_aic_dir][0]);
588 }
589 }
590 s->misc_bits += get_bits_diff(s);
591
592 for (i = 0; i < 6; i++) {
593 msmpeg4_encode_block(s, block[i], i);
594 }
595 s->i_tex_bits += get_bits_diff(s);
596 s->i_count++;
597 }
598 }
599
600 #endif //CONFIG_ENCODERS
601
602 static inline int msmpeg4v1_pred_dc(MpegEncContext * s, int n,
603 int32_t **dc_val_ptr)
604 {
605 int i;
606
607 if (n < 4) {
608 i= 0;
609 } else {
610 i= n-3;
611 }
612
613 *dc_val_ptr= &s->last_dc[i];
614 return s->last_dc[i];
615 }
616
617 static int get_dc(uint8_t *src, int stride, int scale)
618 {
619 int y;
620 int sum=0;
621 for(y=0; y<8; y++){
622 int x;
623 for(x=0; x<8; x++){
624 sum+=src[x + y*stride];
625 }
626 }
627 return FASTDIV((sum + (scale>>1)), scale);
628 }
629
630 /* dir = 0: left, dir = 1: top prediction */
631 static inline int msmpeg4_pred_dc(MpegEncContext * s, int n,
632 int16_t **dc_val_ptr, int *dir_ptr)
633 {
634 int a, b, c, wrap, pred, scale;
635 int16_t *dc_val;
636
637 /* find prediction */
638 if (n < 4) {
639 scale = s->y_dc_scale;
640 } else {
641 scale = s->c_dc_scale;
642 }
643
644 wrap = s->block_wrap[n];
645 dc_val= s->dc_val[0] + s->block_index[n];
646
647 /* B C
648 * A X
649 */
650 a = dc_val[ - 1];
651 b = dc_val[ - 1 - wrap];
652 c = dc_val[ - wrap];
653
654 if(s->first_slice_line && (n&2)==0 && s->msmpeg4_version<4){
655 b=c=1024;
656 }
657
658 /* XXX: the following solution consumes divisions, but it does not
659 necessitate to modify mpegvideo.c. The problem comes from the
660 fact they decided to store the quantized DC (which would lead
661 to problems if Q could vary !) */
662 #if (defined(ARCH_X86)) && !defined PIC
663 asm volatile(
664 "movl %3, %%eax \n\t"
665 "shrl $1, %%eax \n\t"
666 "addl %%eax, %2 \n\t"
667 "addl %%eax, %1 \n\t"
668 "addl %0, %%eax \n\t"
669 "mull %4 \n\t"
670 "movl %%edx, %0 \n\t"
671 "movl %1, %%eax \n\t"
672 "mull %4 \n\t"
673 "movl %%edx, %1 \n\t"
674 "movl %2, %%eax \n\t"
675 "mull %4 \n\t"
676 "movl %%edx, %2 \n\t"
677 : "+b" (a), "+c" (b), "+D" (c)
678 : "g" (scale), "S" (inverse[scale])
679 : "%eax", "%edx"
680 );
681 #else
682 /* #elif defined (ARCH_ALPHA) */
683 /* Divisions are extremely costly on Alpha; optimize the most
684 common case. But they are costly everywhere...
685 */
686 if (scale == 8) {
687 a = (a + (8 >> 1)) / 8;
688 b = (b + (8 >> 1)) / 8;
689 c = (c + (8 >> 1)) / 8;
690 } else {
691 a = FASTDIV((a + (scale >> 1)), scale);
692 b = FASTDIV((b + (scale >> 1)), scale);
693 c = FASTDIV((c + (scale >> 1)), scale);
694 }
695 #endif
696 /* XXX: WARNING: they did not choose the same test as MPEG4. This
697 is very important ! */
698 if(s->msmpeg4_version>3){
699 if(s->inter_intra_pred){
700 uint8_t *dest;
701 int wrap;
702
703 if(n==1){
704 pred=a;
705 *dir_ptr = 0;
706 }else if(n==2){
707 pred=c;
708 *dir_ptr = 1;
709 }else if(n==3){
710 if (abs(a - b) < abs(b - c)) {
711 pred = c;
712 *dir_ptr = 1;
713 } else {
714 pred = a;
715 *dir_ptr = 0;
716 }
717 }else{
718 if(n<4){
719 wrap= s->linesize;
720 dest= s->current_picture.data[0] + (((n>>1) + 2*s->mb_y) * 8* wrap ) + ((n&1) + 2*s->mb_x) * 8;
721 }else{
722 wrap= s->uvlinesize;
723 dest= s->current_picture.data[n-3] + (s->mb_y * 8 * wrap) + s->mb_x * 8;
724 }
725 if(s->mb_x==0) a= (1024 + (scale>>1))/scale;
726 else a= get_dc(dest-8, wrap, scale*8);
727 if(s->mb_y==0) c= (1024 + (scale>>1))/scale;
728 else c= get_dc(dest-8*wrap, wrap, scale*8);
729
730 if (s->h263_aic_dir==0) {
731 pred= a;
732 *dir_ptr = 0;
733 }else if (s->h263_aic_dir==1) {
734 if(n==0){
735 pred= c;
736 *dir_ptr = 1;
737 }else{
738 pred= a;
739 *dir_ptr = 0;
740 }
741 }else if (s->h263_aic_dir==2) {
742 if(n==0){
743 pred= a;
744 *dir_ptr = 0;
745 }else{
746 pred= c;
747 *dir_ptr = 1;
748 }
749 } else {
750 pred= c;
751 *dir_ptr = 1;
752 }
753 }
754 }else{
755 if (abs(a - b) < abs(b - c)) {
756 pred = c;
757 *dir_ptr = 1;
758 } else {
759 pred = a;
760 *dir_ptr = 0;
761 }
762 }
763 }else{
764 if (abs(a - b) <= abs(b - c)) {
765 pred = c;
766 *dir_ptr = 1;
767 } else {
768 pred = a;
769 *dir_ptr = 0;
770 }
771 }
772
773 /* update predictor */
774 *dc_val_ptr = &dc_val[0];
775 return pred;
776 }
777
778 #define DC_MAX 119
779
780 static void msmpeg4_encode_dc(MpegEncContext * s, int level, int n, int *dir_ptr)
781 {
782 int sign, code;
783 int pred;
784
785 if(s->msmpeg4_version==1){
786 int32_t *dc_val;
787 pred = msmpeg4v1_pred_dc(s, n, &dc_val);
788
789 /* update predictor */
790 *dc_val= level;
791 }else{
792 int16_t *dc_val;
793 pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
794
795 /* update predictor */
796 if (n < 4) {
797 *dc_val = level * s->y_dc_scale;
798 } else {
799 *dc_val = level * s->c_dc_scale;
800 }
801 }
802
803 /* do the prediction */
804 level -= pred;
805
806 if(s->msmpeg4_version<=2){
807 if (n < 4) {
808 put_bits(&s->pb,
809 v2_dc_lum_table[level+256][1],
810 v2_dc_lum_table[level+256][0]);
811 }else{
812 put_bits(&s->pb,
813 v2_dc_chroma_table[level+256][1],
814 v2_dc_chroma_table[level+256][0]);
815 }
816 }else{
817 sign = 0;
818 if (level < 0) {
819 level = -level;
820 sign = 1;
821 }
822 code = level;
823 if (code > DC_MAX)
824 code = DC_MAX;
825
826 if (s->dc_table_index == 0) {
827 if (n < 4) {
828 put_bits(&s->pb, ff_table0_dc_lum[code][1], ff_table0_dc_lum[code][0]);
829 } else {
830 put_bits(&s->pb, ff_table0_dc_chroma[code][1], ff_table0_dc_chroma[code][0]);
831 }
832 } else {
833 if (n < 4) {
834 put_bits(&s->pb, ff_table1_dc_lum[code][1], ff_table1_dc_lum[code][0]);
835 } else {
836 put_bits(&s->pb, ff_table1_dc_chroma[code][1], ff_table1_dc_chroma[code][0]);
837 }
838 }
839
840 if (code == DC_MAX)
841 put_bits(&s->pb, 8, level);
842
843 if (level != 0) {
844 put_bits(&s->pb, 1, sign);
845 }
846 }
847 }
848
849 /* Encoding of a block. Very similar to MPEG4 except for a different
850 escape coding (same as H263) and more vlc tables.
851 */
852 static inline void msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n)
853 {
854 int level, run, last, i, j, last_index;
855 int last_non_zero, sign, slevel;
856 int code, run_diff, dc_pred_dir;
857 const RLTable *rl;
858 const uint8_t *scantable;
859
860 if (s->mb_intra) {
861 msmpeg4_encode_dc(s, block[0], n, &dc_pred_dir);
862 i = 1;
863 if (n < 4) {
864 rl = &rl_table[s->rl_table_index];
865 } else {
866 rl = &rl_table[3 + s->rl_chroma_table_index];
867 }
868 run_diff = 0;
869 scantable= s->intra_scantable.permutated;
870 } else {
871 i = 0;
872 rl = &rl_table[3 + s->rl_table_index];
873 if(s->msmpeg4_version<=2)
874 run_diff = 0;
875 else
876 run_diff = 1;
877 scantable= s->inter_scantable.permutated;
878 }
879
880 /* recalculate block_last_index for M$ wmv1 */
881 if(s->msmpeg4_version>=4 && s->block_last_index[n]>0){
882 for(last_index=63; last_index>=0; last_index--){
883 if(block[scantable[last_index]]) break;
884 }
885 s->block_last_index[n]= last_index;
886 }else
887 last_index = s->block_last_index[n];
888 /* AC coefs */
889 last_non_zero = i - 1;
890 for (; i <= last_index; i++) {
891 j = scantable[i];
892 level = block[j];
893 if (level) {
894 run = i - last_non_zero - 1;
895 last = (i == last_index);
896 sign = 0;
897 slevel = level;
898 if (level < 0) {
899 sign = 1;
900 level = -level;
901 }
902
903 if(level<=MAX_LEVEL && run<=MAX_RUN){
904 s->ac_stats[s->mb_intra][n>3][level][run][last]++;
905 }
906 #if 0
907 else
908 s->ac_stats[s->mb_intra][n>3][40][63][0]++; //esc3 like
909 #endif
910 code = get_rl_index(rl, last, run, level);
911 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
912 if (code == rl->n) {
913 int level1, run1;
914
915 level1 = level - rl->max_level[last][run];
916 if (level1 < 1)
917 goto esc2;
918 code = get_rl_index(rl, last, run, level1);
919 if (code == rl->n) {
920 esc2:
921 put_bits(&s->pb, 1, 0);
922 if (level > MAX_LEVEL)
923 goto esc3;
924 run1 = run - rl->max_run[last][level] - run_diff;
925 if (run1 < 0)
926 goto esc3;
927 code = get_rl_index(rl, last, run1, level);
928 if (code == rl->n) {
929 esc3:
930 /* third escape */
931 put_bits(&s->pb, 1, 0);
932 put_bits(&s->pb, 1, last);
933 if(s->msmpeg4_version>=4){
934 if(s->esc3_level_length==0){
935 s->esc3_level_length=8;
936 s->esc3_run_length= 6;
937 if(s->qscale<8)
938 put_bits(&s->pb, 6, 3);
939 else
940 put_bits(&s->pb, 8, 3);
941 }
942 put_bits(&s->pb, s->esc3_run_length, run);
943 put_bits(&s->pb, 1, sign);
944 put_bits(&s->pb, s->esc3_level_length, level);
945 }else{
946 put_bits(&s->pb, 6, run);
947 put_bits(&s->pb, 8, slevel & 0xff);
948 }
949 } else {
950 /* second escape */
951 put_bits(&s->pb, 1, 1);
952 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
953 put_bits(&s->pb, 1, sign);
954 }
955 } else {
956 /* first escape */
957 put_bits(&s->pb, 1, 1);
958 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
959 put_bits(&s->pb, 1, sign);
960 }
961 } else {
962 put_bits(&s->pb, 1, sign);
963 }
964 last_non_zero = i;
965 }
966 }
967 }
968
969 /****************************************/
970 /* decoding stuff */
971
972 static VLC mb_non_intra_vlc[4];
973 VLC ff_msmp4_mb_i_vlc;
974 VLC ff_msmp4_dc_luma_vlc[2];
975 VLC ff_msmp4_dc_chroma_vlc[2];
976 static VLC v2_dc_lum_vlc;
977 static VLC v2_dc_chroma_vlc;
978 static VLC cbpy_vlc;
979 static VLC v2_intra_cbpc_vlc;
980 static VLC v2_mb_type_vlc;
981 static VLC v2_mv_vlc;
982 static VLC v1_intra_cbpc_vlc;
983 static VLC v1_inter_cbpc_vlc;
984 static VLC inter_intra_vlc;
985
986 /* this table is practically identical to the one from h263 except that its inverted */
987 static void init_h263_dc_for_msmpeg4(void)
988 {
989 int level, uni_code, uni_len;
990
991 for(level=-256; level<256; level++){
992 int size, v, l;
993 /* find number of bits */
994 size = 0;
995 v = abs(level);
996 while (v) {
997 v >>= 1;
998 size++;
999 }
1000
1001 if (level < 0)
1002 l= (-level) ^ ((1 << size) - 1);
1003 else
1004 l= level;
1005
1006 /* luminance h263 */
1007 uni_code= DCtab_lum[size][0];
1008 uni_len = DCtab_lum[size][1];
1009 uni_code ^= (1<<uni_len)-1; //M$ doesnt like compatibility
1010
1011 if (size > 0) {
1012 uni_code<<=size; uni_code|=l;
1013 uni_len+=size;
1014 if (size > 8){
1015 uni_code<<=1; uni_code|=1;
1016 uni_len++;
1017 }
1018 }
1019 v2_dc_lum_table[level+256][0]= uni_code;
1020 v2_dc_lum_table[level+256][1]= uni_len;
1021
1022 /* chrominance h263 */
1023 uni_code= DCtab_chrom[size][0];
1024 uni_len = DCtab_chrom[size][1];
1025 uni_code ^= (1<<uni_len)-1; //M$ doesnt like compatibility
1026
1027 if (size > 0) {
1028 uni_code<<=size; uni_code|=l;
1029 uni_len+=size;
1030 if (size > 8){
1031 uni_code<<=1; uni_code|=1;
1032 uni_len++;
1033 }
1034 }
1035 v2_dc_chroma_table[level+256][0]= uni_code;
1036 v2_dc_chroma_table[level+256][1]= uni_len;
1037
1038 }
1039 }
1040
1041 /* init all vlc decoding tables */
1042 int ff_msmpeg4_decode_init(MpegEncContext *s)
1043 {
1044 static int done = 0;
1045 int i;
1046 MVTable *mv;
1047
1048 common_init(s);
1049
1050 if (!done) {
1051 done = 1;
1052
1053 for(i=0;i<NB_RL_TABLES;i++) {
1054 init_rl(&rl_table[i], 1);
1055 init_vlc_rl(&rl_table[i], 1);
1056 }
1057 for(i=0;i<2;i++) {
1058 mv = &mv_tables[i];
1059 init_vlc(&mv->vlc, MV_VLC_BITS, mv->n + 1,
1060 mv->table_mv_bits, 1, 1,
1061 mv->table_mv_code, 2, 2, 1);
1062 }
1063
1064 init_vlc(&ff_msmp4_dc_luma_vlc[0], DC_VLC_BITS, 120,
1065 &ff_table0_dc_lum[0][1], 8, 4,
1066 &ff_table0_dc_lum[0][0], 8, 4, 1);
1067 init_vlc(&ff_msmp4_dc_chroma_vlc[0], DC_VLC_BITS, 120,
1068 &ff_table0_dc_chroma[0][1], 8, 4,
1069 &ff_table0_dc_chroma[0][0], 8, 4, 1);
1070 init_vlc(&ff_msmp4_dc_luma_vlc[1], DC_VLC_BITS, 120,
1071 &ff_table1_dc_lum[0][1], 8, 4,
1072 &ff_table1_dc_lum[0][0], 8, 4, 1);
1073 init_vlc(&ff_msmp4_dc_chroma_vlc[1], DC_VLC_BITS, 120,
1074 &ff_table1_dc_chroma[0][1], 8, 4,
1075 &ff_table1_dc_chroma[0][0], 8, 4, 1);
1076
1077 init_vlc(&v2_dc_lum_vlc, DC_VLC_BITS, 512,
1078 &v2_dc_lum_table[0][1], 8, 4,
1079 &v2_dc_lum_table[0][0], 8, 4, 1);
1080 init_vlc(&v2_dc_chroma_vlc, DC_VLC_BITS, 512,
1081 &v2_dc_chroma_table[0][1], 8, 4,
1082 &v2_dc_chroma_table[0][0], 8, 4, 1);
1083
1084 init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
1085 &cbpy_tab[0][1], 2, 1,
1086 &cbpy_tab[0][0], 2, 1, 1);
1087 init_vlc(&v2_intra_cbpc_vlc, V2_INTRA_CBPC_VLC_BITS, 4,
1088 &v2_intra_cbpc[0][1], 2, 1,
1089 &v2_intra_cbpc[0][0], 2, 1, 1);
1090 init_vlc(&v2_mb_type_vlc, V2_MB_TYPE_VLC_BITS, 8,
1091 &v2_mb_type[0][1], 2, 1,
1092 &v2_mb_type[0][0], 2, 1, 1);
1093 init_vlc(&v2_mv_vlc, V2_MV_VLC_BITS, 33,
1094 &mvtab[0][1], 2, 1,
1095 &mvtab[0][0], 2, 1, 1);
1096
1097 for(i=0; i<4; i++){
1098 init_vlc(&mb_non_intra_vlc[i], MB_NON_INTRA_VLC_BITS, 128,
1099 &wmv2_inter_table[i][0][1], 8, 4,
1100 &wmv2_inter_table[i][0][0], 8, 4, 1); //FIXME name?
1101 }
1102
1103 init_vlc(&ff_msmp4_mb_i_vlc, MB_INTRA_VLC_BITS, 64,
1104 &ff_msmp4_mb_i_table[0][1], 4, 2,
1105 &ff_msmp4_mb_i_table[0][0], 4, 2, 1);
1106
1107 init_vlc(&v1_intra_cbpc_vlc, V1_INTRA_CBPC_VLC_BITS, 8,
1108 intra_MCBPC_bits, 1, 1,
1109 intra_MCBPC_code, 1, 1, 1);
1110 init_vlc(&v1_inter_cbpc_vlc, V1_INTER_CBPC_VLC_BITS, 25,
1111 inter_MCBPC_bits, 1, 1,
1112 inter_MCBPC_code, 1, 1, 1);
1113
1114 init_vlc(&inter_intra_vlc, INTER_INTRA_VLC_BITS, 4,
1115 &table_inter_intra[0][1], 2, 1,
1116 &table_inter_intra[0][0], 2, 1, 1);
1117 }
1118
1119 switch(s->msmpeg4_version){
1120 case 1:
1121 case 2:
1122 s->decode_mb= msmpeg4v12_decode_mb;
1123 break;
1124 case 3:
1125 case 4:
1126 s->decode_mb= msmpeg4v34_decode_mb;
1127 break;
1128 case 5:
1129 s->decode_mb= wmv2_decode_mb;
1130 case 6:
1131 //FIXME + TODO VC1 decode mb
1132 break;
1133 }
1134
1135 s->slice_height= s->mb_height; //to avoid 1/0 if the first frame isnt a keyframe
1136
1137 return 0;
1138 }
1139
1140 int msmpeg4_decode_picture_header(MpegEncContext * s)
1141 {
1142 int code;
1143
1144 #if 0
1145 {
1146 int i;
1147 for(i=0; i<s->gb.size_in_bits; i++)
1148 av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
1149 // get_bits1(&s->gb);
1150 av_log(s->avctx, AV_LOG_DEBUG, "END\n");
1151 return -1;
1152 }
1153 #endif
1154
1155 if(s->msmpeg4_version==1){
1156 int start_code, num;
1157 start_code = (get_bits(&s->gb, 16)<<16) | get_bits(&s->gb, 16);
1158 if(start_code!=0x00000100){
1159 av_log(s->avctx, AV_LOG_ERROR, "invalid startcode\n");
1160 return -1;
1161 }
1162
1163 num= get_bits(&s->gb, 5); // frame number */
1164 }
1165
1166 s->pict_type = get_bits(&s->gb, 2) + 1;
1167 if (s->pict_type != I_TYPE &&
1168 s->pict_type != P_TYPE){
1169 av_log(s->avctx, AV_LOG_ERROR, "invalid picture type\n");
1170 return -1;
1171 }
1172 #if 0
1173 {
1174 static int had_i=0;
1175 if(s->pict_type == I_TYPE) had_i=1;
1176 if(!had_i) return -1;
1177 }
1178 #endif
1179 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
1180 if(s->qscale==0){
1181 av_log(s->avctx, AV_LOG_ERROR, "invalid qscale\n");
1182 return -1;
1183 }
1184
1185 if (s->pict_type == I_TYPE) {
1186 code = get_bits(&s->gb, 5);
1187 if(s->msmpeg4_version==1){
1188 if(code==0 || code>s->mb_height){
1189 av_log(s->avctx, AV_LOG_ERROR, "invalid slice height %d\n", code);
1190 return -1;
1191 }
1192
1193 s->slice_height = code;
1194 }else{
1195 /* 0x17: one slice, 0x18: two slices, ... */
1196 if (code < 0x17){
1197 av_log(s->avctx, AV_LOG_ERROR, "error, slice code was %X\n", code);
1198 return -1;
1199 }
1200
1201 s->slice_height = s->mb_height / (code - 0x16);
1202 }
1203
1204 switch(s->msmpeg4_version){
1205 case 1:
1206 case 2:
1207 s->rl_chroma_table_index = 2;
1208 s->rl_table_index = 2;
1209
1210 s->dc_table_index = 0; //not used
1211 break;
1212 case 3:
1213 s->rl_chroma_table_index = decode012(&s->gb);
1214 s->rl_table_index = decode012(&s->gb);
1215
1216 s->dc_table_index = get_bits1(&s->gb);
1217 break;
1218 case 4:
1219 msmpeg4_decode_ext_header(s, (2+5+5+17+7)/8);
1220
1221 if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
1222 else s->per_mb_rl_table= 0;
1223
1224 if(!s->per_mb_rl_table){
1225 s->rl_chroma_table_index = decode012(&s->gb);
1226 s->rl_table_index = decode012(&s->gb);
1227 }
1228
1229 s->dc_table_index = get_bits1(&s->gb);
1230 s->inter_intra_pred= 0;
1231 break;
1232 }
1233 s->no_rounding = 1;
1234 if(s->avctx->debug&FF_DEBUG_PICT_INFO)
1235 av_log(s->avctx, AV_LOG_DEBUG, "qscale:%d rlc:%d rl:%d dc:%d mbrl:%d slice:%d \n",
1236 s->qscale,
1237 s->rl_chroma_table_index,
1238 s->rl_table_index,
1239 s->dc_table_index,
1240 s->per_mb_rl_table,
1241 s->slice_height);
1242 } else {
1243 switch(s->msmpeg4_version){
1244 case 1:
1245 case 2:
1246 if(s->msmpeg4_version==1)
1247 s->use_skip_mb_code = 1;
1248 else
1249 s->use_skip_mb_code = get_bits1(&s->gb);
1250 s->rl_table_index = 2;
1251 s->rl_chroma_table_index = s->rl_table_index;
1252 s->dc_table_index = 0; //not used
1253 s->mv_table_index = 0;
1254 break;
1255 case 3:
1256 s->use_skip_mb_code = get_bits1(&s->gb);
1257 s->rl_table_index = decode012(&s->gb);
1258 s->rl_chroma_table_index = s->rl_table_index;
1259
1260 s->dc_table_index = get_bits1(&s->gb);
1261
1262 s->mv_table_index = get_bits1(&s->gb);
1263 break;
1264 case 4:
1265 s->use_skip_mb_code = get_bits1(&s->gb);
1266
1267 if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
1268 else s->per_mb_rl_table= 0;
1269
1270 if(!s->per_mb_rl_table){
1271 s->rl_table_index = decode012(&s->gb);
1272 s->rl_chroma_table_index = s->rl_table_index;
1273 }
1274
1275 s->dc_table_index = get_bits1(&s->gb);
1276
1277 s->mv_table_index = get_bits1(&s->gb);
1278 s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE);
1279 break;
1280 }
1281
1282 if(s->avctx->debug&FF_DEBUG_PICT_INFO)
1283 av_log(s->avctx, AV_LOG_DEBUG, "skip:%d rl:%d rlc:%d dc:%d mv:%d mbrl:%d qp:%d \n",
1284 s->use_skip_mb_code,
1285 s->rl_table_index,
1286 s->rl_chroma_table_index,
1287 s->dc_table_index,
1288 s->mv_table_index,
1289 s->per_mb_rl_table,
1290 s->qscale);
1291
1292 if(s->flipflop_rounding){
1293 s->no_rounding ^= 1;
1294 }else{
1295 s->no_rounding = 0;
1296 }
1297 }
1298 //printf("%d %d %d %d %d\n", s->pict_type, s->bit_rate, s->inter_intra_pred, s->width, s->height);
1299
1300 s->esc3_level_length= 0;
1301 s->esc3_run_length= 0;
1302
1303 #ifdef DEBUG
1304 av_log(s->avctx, AV_LOG_DEBUG, "*****frame %d:\n", frame_count++);
1305 #endif
1306 return 0;
1307 }
1308
1309 int msmpeg4_decode_ext_header(MpegEncContext * s, int buf_size)
1310 {
1311 int left= buf_size*8 - get_bits_count(&s->gb);
1312 int length= s->msmpeg4_version>=3 ? 17 : 16;
1313 /* the alt_bitstream reader could read over the end so we need to check it */
1314 if(left>=length && left<length+8)
1315 {
1316 int fps;
1317
1318 fps= get_bits(&s->gb, 5);
1319 s->bit_rate= get_bits(&s->gb, 11)*1024;
1320 if(s->msmpeg4_version>=3)
1321 s->flipflop_rounding= get_bits1(&s->gb);
1322 else
1323 s->flipflop_rounding= 0;
1324
1325 // printf("fps:%2d bps:%2d roundingType:%1d\n", fps, s->bit_rate/1024, s->flipflop_rounding);
1326 }
1327 else if(left<length+8)
1328 {
1329 s->flipflop_rounding= 0;
1330 if(s->msmpeg4_version != 2)
1331 av_log(s->avctx, AV_LOG_ERROR, "ext header missing, %d left\n", left);
1332 }
1333 else
1334 {
1335 av_log(s->avctx, AV_LOG_ERROR, "I frame too long, ignoring ext header\n");
1336 }
1337
1338 return 0;
1339 }
1340
1341 static inline void msmpeg4_memsetw(short *tab, int val, int n)
1342 {
1343 int i;
1344 for(i=0;i<n;i++)
1345 tab[i] = val;
1346 }
1347
1348 #ifdef CONFIG_ENCODERS
1349 static void msmpeg4v2_encode_motion(MpegEncContext * s, int val)
1350 {
1351 int range, bit_size, sign, code, bits;
1352
1353 if (val == 0) {
1354 /* zero vector */
1355 code = 0;
1356 put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
1357 } else {
1358 bit_size = s->f_code - 1;
1359 range = 1 << bit_size;
1360 if (val <= -64)
1361 val += 64;
1362 else if (val >= 64)
1363 val -= 64;
1364
1365 if (val >= 0) {
1366 sign = 0;
1367 } else {
1368 val = -val;
1369 sign = 1;
1370 }
1371 val--;
1372 code = (val >> bit_size) + 1;
1373 bits = val & (range - 1);
1374
1375 put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
1376 if (bit_size > 0) {
1377 put_bits(&s->pb, bit_size, bits);
1378 }
1379 }
1380 }
1381 #endif
1382
1383 /* this is identical to h263 except that its range is multiplied by 2 */
1384 static int msmpeg4v2_decode_motion(MpegEncContext * s, int pred, int f_code)
1385 {
1386 int code, val, sign, shift;
1387
1388 code = get_vlc2(&s->gb, v2_mv_vlc.table, V2_MV_VLC_BITS, 2);
1389 // printf("MV code %d at %d %d pred: %d\n", code, s->mb_x,s->mb_y, pred);
1390 if (code < 0)
1391 return 0xffff;
1392
1393 if (code == 0)
1394 return pred;
1395 sign = get_bits1(&s->gb);
1396 shift = f_code - 1;
1397 val = code;
1398 if (shift) {
1399 val = (val - 1) << shift;
1400 val |= get_bits(&s->gb, shift);
1401 val++;
1402 }
1403 if (sign)
1404 val = -val;
1405
1406 val += pred;
1407 if (val <= -64)
1408 val += 64;
1409 else if (val >= 64)
1410 val -= 64;
1411
1412 return val;
1413 }
1414
1415 static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1416 {
1417 int cbp, code, i;
1418
1419 if (s->pict_type == P_TYPE) {
1420 if (s->use_skip_mb_code) {
1421 if (get_bits1(&s->gb)) {
1422 /* skip mb */
1423 s->mb_intra = 0;
1424 for(i=0;i<6;i++)
1425 s->block_last_index[i] = -1;
1426 s->mv_dir = MV_DIR_FORWARD;
1427 s->mv_type = MV_TYPE_16X16;
1428 s->mv[0][0][0] = 0;
1429 s->mv[0][0][1] = 0;
1430 s->mb_skipped = 1;
1431 return 0;
1432 }
1433 }
1434
1435 if(s->msmpeg4_version==2)
1436 code = get_vlc2(&s->gb, v2_mb_type_vlc.table, V2_MB_TYPE_VLC_BITS, 1);
1437 else
1438 code = get_vlc2(&s->gb, v1_inter_cbpc_vlc.table, V1_INTER_CBPC_VLC_BITS, 3);
1439 if(code<0 || code>7){
1440 av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", code, s->mb_x, s->mb_y);
1441 return -1;
1442 }
1443
1444 s->mb_intra = code >>2;
1445
1446 cbp = code & 0x3;
1447 } else {
1448 s->mb_intra = 1;
1449 if(s->msmpeg4_version==2)
1450 cbp= get_vlc2(&s->gb, v2_intra_cbpc_vlc.table, V2_INTRA_CBPC_VLC_BITS, 1);
1451 else
1452 cbp= get_vlc2(&s->gb, v1_intra_cbpc_vlc.table, V1_INTRA_CBPC_VLC_BITS, 1);
1453 if(cbp<0 || cbp>3){
1454 av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
1455 return -1;
1456 }
1457 }
1458
1459 if (!s->mb_intra) {
1460 int mx, my, cbpy;
1461
1462 cbpy= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
1463 if(cbpy<0){
1464 av_log(s->avctx, AV_LOG_ERROR, "cbpy %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
1465 return -1;
1466 }
1467
1468 cbp|= cbpy<<2;
1469 if(s->msmpeg4_version==1 || (cbp&3) != 3) cbp^= 0x3C;
1470
1471 h263_pred_motion(s, 0, 0, &mx, &my);
1472 mx= msmpeg4v2_decode_motion(s, mx, 1);
1473 my= msmpeg4v2_decode_motion(s, my, 1);
1474
1475 s->mv_dir = MV_DIR_FORWARD;
1476 s->mv_type = MV_TYPE_16X16;
1477 s->mv[0][0][0] = mx;
1478 s->mv[0][0][1] = my;
1479 } else {
1480 if(s->msmpeg4_version==2){
1481 s->ac_pred = get_bits1(&s->gb);
1482 cbp|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
1483 } else{
1484 s->ac_pred = 0;
1485 cbp|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
1486 if(s->pict_type==P_TYPE) cbp^=0x3C;
1487 }
1488 }
1489
1490 s->dsp.clear_blocks(s->block[0]);
1491 for (i = 0; i < 6; i++) {
1492 if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
1493 {
1494 av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1495 return -1;
1496 }
1497 }
1498 return 0;
1499 }
1500
1501 static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1502 {
1503 int cbp, code, i;
1504 uint8_t *coded_val;
1505 uint32_t * const mb_type_ptr= &s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ];
1506
1507 if (s->pict_type == P_TYPE) {
1508 if (s->use_skip_mb_code) {
1509 if (get_bits1(&s->gb)) {
1510 /* skip mb */
1511 s->mb_intra = 0;
1512 for(i=0;i<6;i++)
1513 s->block_last_index[i] = -1;
1514 s->mv_dir = MV_DIR_FORWARD;
1515 s->mv_type = MV_TYPE_16X16;
1516 s->mv[0][0][0] = 0;
1517 s->mv[0][0][1] = 0;
1518 s->mb_skipped = 1;
1519 *mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
1520
1521 return 0;
1522 }
1523 }
1524
1525 code = get_vlc2(&s->gb, mb_non_intra_vlc[DEFAULT_INTER_INDEX].table, MB_NON_INTRA_VLC_BITS, 3);
1526 if (code < 0)
1527 return -1;
1528 //s->mb_intra = (code & 0x40) ? 0 : 1;
1529 s->mb_intra = (~code & 0x40) >> 6;
1530
1531 cbp = code & 0x3f;
1532 } else {
1533 s->mb_intra = 1;
1534 code = get_vlc2(&s->gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
1535 if (code < 0)
1536 return -1;
1537 /* predict coded block pattern */
1538 cbp = 0;
1539 for(i=0;i<6;i++) {
1540 int val = ((code >> (5 - i)) & 1);
1541 if (i < 4) {
1542 int pred = coded_block_pred(s, i, &coded_val);
1543 val = val ^ pred;
1544 *coded_val = val;
1545 }
1546 cbp |= val << (5 - i);
1547 }
1548 }
1549
1550 if (!s->mb_intra) {
1551 int mx, my;
1552 //printf("P at %d %d\n", s->mb_x, s->mb_y);
1553 if(s->per_mb_rl_table && cbp){
1554 s->rl_table_index = decode012(&s->gb);
1555 s->rl_chroma_table_index = s->rl_table_index;
1556 }
1557 h263_pred_motion(s, 0, 0, &mx, &my);
1558 if (msmpeg4_decode_motion(s, &mx, &my) < 0)
1559 return -1;
1560 s->mv_dir = MV_DIR_FORWARD;
1561 s->mv_type = MV_TYPE_16X16;
1562 s->mv[0][0][0] = mx;
1563 s->mv[0][0][1] = my;
1564 *mb_type_ptr = MB_TYPE_L0 | MB_TYPE_16x16;
1565 } else {
1566 //printf("I at %d %d %d %06X\n", s->mb_x, s->mb_y, ((cbp&3)? 1 : 0) +((cbp&0x3C)? 2 : 0), show_bits(&s->gb, 24));
1567 s->ac_pred = get_bits1(&s->gb);
1568 *mb_type_ptr = MB_TYPE_INTRA;
1569 if(s->inter_intra_pred){
1570 s->h263_aic_dir= get_vlc2(&s->gb, inter_intra_vlc.table, INTER_INTRA_VLC_BITS, 1);
1571 // printf("%d%d %d %d/", s->ac_pred, s->h263_aic_dir, s->mb_x, s->mb_y);
1572 }
1573 if(s->per_mb_rl_table && cbp){
1574 s->rl_table_index = decode012(&s->gb);
1575 s->rl_chroma_table_index = s->rl_table_index;
1576 }
1577 }
1578
1579 s->dsp.clear_blocks(s->block[0]);
1580 for (i = 0; i < 6; i++) {
1581 if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
1582 {
1583 av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1584 return -1;
1585 }
1586 }
1587
1588 return 0;
1589 }
1590 //#define ERROR_DETAILS
1591 static inline int msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
1592 int n, int coded, const uint8_t *scan_table)
1593 {
1594 int level, i, last, run, run_diff;
1595 int dc_pred_dir;
1596 RLTable *rl;
1597 RL_VLC_ELEM *rl_vlc;
1598 int qmul, qadd;
1599
1600 if (s->mb_intra) {
1601 qmul=1;
1602 qadd=0;
1603
1604 /* DC coef */
1605 level = msmpeg4_decode_dc(s, n, &dc_pred_dir);
1606
1607 if (level < 0){
1608 av_log(s->avctx, AV_LOG_ERROR, "dc overflow- block: %d qscale: %d//\n", n, s->qscale);
1609 if(s->inter_intra_pred) level=0;
1610 else return -1;
1611 }
1612 if (n < 4) {
1613 rl = &rl_table[s->rl_table_index];
1614 if(level > 256*s->y_dc_scale){
1615 av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ L qscale: %d//\n", s->qscale);
1616 if(!s->inter_intra_pred) return -1;
1617 }
1618 } else {
1619 rl = &rl_table[3 + s->rl_chroma_table_index];
1620 if(level > 256*s->c_dc_scale){
1621 av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ C qscale: %d//\n", s->qscale);
1622 if(!s->inter_intra_pred) return -1;
1623 }
1624 }
1625 block[0] = level;
1626
1627 run_diff = 0;
1628 i = 0;
1629 if (!coded) {
1630 goto not_coded;
1631 }
1632 if (s->ac_pred) {
1633 if (dc_pred_dir == 0)
1634 scan_table = s->intra_v_scantable.permutated; /* left */
1635 else
1636 scan_table = s->intra_h_scantable.permutated; /* top */
1637 } else {
1638 scan_table = s->intra_scantable.permutated;
1639 }
1640 rl_vlc= rl->rl_vlc[0];
1641 } else {
1642 qmul = s->qscale << 1;
1643 qadd = (s->qscale - 1) | 1;
1644 i = -1;
1645 rl = &rl_table[3 + s->rl_table_index];
1646
1647 if(s->msmpeg4_version==2)
1648 run_diff = 0;
1649 else
1650 run_diff = 1;
1651
1652 if (!coded) {
1653 s->block_last_index[n] = i;
1654 return 0;
1655 }
1656 if(!scan_table)
1657 scan_table = s->inter_scantable.permutated;
1658 rl_vlc= rl->rl_vlc[s->qscale];
1659 }
1660 {
1661 OPEN_READER(re, &s->gb);
1662 for(;;) {
1663 UPDATE_CACHE(re, &s->gb);
1664 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
1665 if (level==0) {
1666 int cache;
1667 cache= GET_CACHE(re, &s->gb);
1668 /* escape */
1669 if (s->msmpeg4_version==1 || (cache&0x80000000)==0) {
1670 if (s->msmpeg4_version==1 || (cache&0x40000000)==0) {
1671 /* third escape */
1672 if(s->msmpeg4_version!=1) LAST_SKIP_BITS(re, &s->gb, 2);
1673 UPDATE_CACHE(re, &s->gb);
1674 if(s->msmpeg4_version<=3){
1675 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
1676 run= SHOW_UBITS(re, &s->gb, 6); SKIP_CACHE(re, &s->gb, 6);
1677 level= SHOW_SBITS(re, &s->gb, 8); LAST_SKIP_CACHE(re, &s->gb, 8);
1678 SKIP_COUNTER(re, &s->gb, 1+6+8);
1679 }else{
1680 int sign;
1681 last= SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1);
1682 if(!s->esc3_level_length){
1683 int ll;
1684 //printf("ESC-3 %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y);
1685 if(s->qscale<8){
1686 ll= SHOW_UBITS(re, &s->gb, 3); SKIP_BITS(re, &s->gb, 3);
1687 if(ll==0){
1688 if(SHOW_UBITS(re, &s->gb, 1)) av_log(s->avctx, AV_LOG_ERROR, "cool a new vlc code ,contact the ffmpeg developers and upload the file\n");
1689 SKIP_BITS(re, &s->gb, 1);
1690 ll=8;
1691 }
1692 }else{
1693 ll=2;
1694 while(ll<8 && SHOW_UBITS(re, &s->gb, 1)==0){
1695 ll++;
1696 SKIP_BITS(re, &s->gb, 1);
1697 }
1698 if(ll<8) SKIP_BITS(re, &s->gb, 1);
1699 }
1700
1701 s->esc3_level_length= ll;
1702 s->esc3_run_length= SHOW_UBITS(re, &s->gb, 2) + 3; SKIP_BITS(re, &s->gb, 2);
1703 //printf("level length:%d, run length: %d\n", ll, s->esc3_run_length);
1704 UPDATE_CACHE(re, &s->gb);
1705 }
1706 run= SHOW_UBITS(re, &s->gb, s->esc3_run_length);
1707 SKIP_BITS(re, &s->gb, s->esc3_run_length);
1708
1709 sign= SHOW_UBITS(re, &s->gb, 1);
1710 SKIP_BITS(re, &s->gb, 1);
1711
1712 level= SHOW_UBITS(re, &s->gb, s->esc3_level_length);
1713 SKIP_BITS(re, &s->gb, s->esc3_level_length);
1714 if(sign) level= -level;
1715 }
1716 //printf("level: %d, run: %d at %d %d\n", level, run, s->mb_x, s->mb_y);
1717 #if 0 // waste of time / this will detect very few errors
1718 {
1719 const int abs_level= FFABS(level);
1720 const int run1= run - rl->max_run[last][abs_level] - run_diff;
1721 if(abs_level<=MAX_LEVEL && run<=MAX_RUN){
1722 if(abs_level <= rl->max_level[last][run]){
1723 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n");
1724 return DECODING_AC_LOST;
1725 }
1726 if(abs_level <= rl->max_level[last][run]*2){
1727 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 1 encoding possible\n");
1728 return DECODING_AC_LOST;
1729 }
1730 if(run1>=0 && abs_level <= rl->max_level[last][run1]){
1731 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 2 encoding possible\n");
1732 return DECODING_AC_LOST;
1733 }
1734 }
1735 }
1736 #endif
1737 //level = level * qmul + (level>0) * qadd - (level<=0) * qadd ;
1738 if (level>0) level= level * qmul + qadd;
1739 else level= level * qmul - qadd;
1740 #if 0 // waste of time too :(
1741 if(level>2048 || level<-2048){
1742 av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc\n");
1743 return DECODING_AC_LOST;
1744 }
1745 #endif
1746 i+= run + 1;
1747 if(last) i+=192;
1748 #ifdef ERROR_DETAILS
1749 if(run==66)
1750 av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC3 level=%d\n", level);
1751 else if((i>62 && i<192) || i>192+63)
1752 av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC3 i=%d run=%d level=%d\n", i, run, level);
1753 #endif
1754 } else {
1755 /* second escape */
1756 #if MIN_CACHE_BITS < 23
1757 LAST_SKIP_BITS(re, &s->gb, 2);
1758 UPDATE_CACHE(re, &s->gb);
1759 #else
1760 SKIP_BITS(re, &s->gb, 2);
1761 #endif
1762 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
1763 i+= run + rl->max_run[run>>7][level/qmul] + run_diff; //FIXME opt indexing
1764 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1765 LAST_SKIP_BITS(re, &s->gb, 1);
1766 #ifdef ERROR_DETAILS
1767 if(run==66)
1768 av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC2 level=%d\n", level);
1769 else if((i>62 && i<192) || i>192+63)
1770 av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC2 i=%d run=%d level=%d\n", i, run, level);
1771 #endif
1772 }
1773 } else {
1774 /* first escape */
1775 #if MIN_CACHE_BITS < 22
1776 LAST_SKIP_BITS(re, &s->gb, 1);
1777 UPDATE_CACHE(re, &s->gb);
1778 #else
1779 SKIP_BITS(re, &s->gb, 1);
1780 #endif
1781 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
1782 i+= run;
1783 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
1784 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1785 LAST_SKIP_BITS(re, &s->gb, 1);
1786 #ifdef ERROR_DETAILS
1787 if(run==66)
1788 av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC1 level=%d\n", level);
1789 else if((i>62 && i<192) || i>192+63)
1790 av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC1 i=%d run=%d level=%d\n", i, run, level);
1791 #endif
1792 }
1793 } else {
1794 i+= run;
1795 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1796 LAST_SKIP_BITS(re, &s->gb, 1);
1797 #ifdef ERROR_DETAILS
1798 if(run==66)
1799 av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code level=%d\n", level);
1800 else if((i>62 && i<192) || i>192+63)
1801 av_log(s->avctx, AV_LOG_ERROR, "run overflow i=%d run=%d level=%d\n", i, run, level);
1802 #endif
1803 }
1804 if (i > 62){
1805 i-= 192;
1806 if(i&(~63)){
1807 const int left= s->gb.size_in_bits - get_bits_count(&s->gb);
1808 if(((i+192 == 64 && level/qmul==-1) || s->error_resilience<=1) && left>=0){
1809 av_log(s->avctx, AV_LOG_ERROR, "ignoring overflow at %d %d\n", s->mb_x, s->mb_y);
1810 break;
1811 }else{
1812 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1813 return -1;
1814 }
1815 }
1816
1817 block[scan_table[i]] = level;
1818 break;
1819 }
1820
1821 block[scan_table[i]] = level;
1822 }
1823 CLOSE_READER(re, &s->gb);
1824 }
1825 not_coded:
1826 if (s->mb_intra) {
1827 mpeg4_pred_ac(s, block, n, dc_pred_dir);
1828 if (s->ac_pred) {
1829 i = 63; /* XXX: not optimal */
1830 }
1831 }
1832 if(s->msmpeg4_version>=4 && i>0) i=63; //FIXME/XXX optimize
1833 s->block_last_index[n] = i;
1834
1835 return 0;
1836 }
1837
1838 static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
1839 {
1840 int level, pred;
1841
1842 if(s->msmpeg4_version<=2){
1843 if (n < 4) {
1844 level = get_vlc2(&s->gb, v2_dc_lum_vlc.table, DC_VLC_BITS, 3);
1845 } else {
1846 level = get_vlc2(&s->gb, v2_dc_chroma_vlc.table, DC_VLC_BITS, 3);
1847 }
1848 if (level < 0)
1849 return -1;
1850 level-=256;
1851 }else{ //FIXME optimize use unified tables & index
1852 if (n < 4) {
1853 level = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1854 } else {
1855 level = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1856 }
1857 if (level < 0){
1858 av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
1859 return -1;
1860 }
1861
1862 if (level == DC_MAX) {
1863 level = get_bits(&s->gb, 8);
1864 if (get_bits1(&s->gb))
1865 level = -level;
1866 } else if (level != 0) {
1867 if (get_bits1(&s->gb))
1868 level = -level;
1869 }
1870 }
1871
1872 if(s->msmpeg4_version==1){
1873 int32_t *dc_val;
1874 pred = msmpeg4v1_pred_dc(s, n, &dc_val);
1875 level += pred;
1876
1877 /* update predictor */
1878 *dc_val= level;
1879 }else{
1880 int16_t *dc_val;
1881 pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
1882 level += pred;
1883
1884 /* update predictor */
1885 if (n < 4) {
1886 *dc_val = level * s->y_dc_scale;
1887 } else {
1888 *dc_val = level * s->c_dc_scale;
1889 }
1890 }
1891
1892 return level;
1893 }
1894
1895 static int msmpeg4_decode_motion(MpegEncContext * s,
1896 int *mx_ptr, int *my_ptr)
1897 {
1898 MVTable *mv;
1899 int code, mx, my;
1900
1901 mv = &mv_tables[s->mv_table_index];
1902
1903 code = get_vlc2(&s->gb, mv->vlc.table, MV_VLC_BITS, 2);
1904 if (code < 0){
1905 av_log(s->avctx, AV_LOG_ERROR, "illegal MV code at %d %d\n", s->mb_x, s->mb_y);
1906 return -1;
1907 }
1908 if (code == mv->n) {
1909 //printf("MV ESC %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y);
1910 mx = get_bits(&s->gb, 6);
1911 my = get_bits(&s->gb, 6);
1912 } else {
1913 mx = mv->table_mvx[code];
1914 my = mv->table_mvy[code];
1915 }
1916
1917 mx += *mx_ptr - 32;
1918 my += *my_ptr - 32;
1919 /* WARNING : they do not do exactly modulo encoding */
1920 if (mx <= -64)
1921 mx += 64;
1922 else if (mx >= 64)
1923 mx -= 64;
1924
1925 if (my <= -64)
1926 my += 64;
1927 else if (my >= 64)
1928 my -= 64;
1929 *mx_ptr = mx;
1930 *my_ptr = my;
1931 return 0;
1932 }
1933
1934 /* cleanest way to support it
1935 * there is too much shared between versions so that we cant have 1 file per version & 1 common
1936 * as allmost everything would be in the common file
1937 */
1938 #include "wmv2.c"