VirtualBox

source: vbox/trunk/src/libs/ffmpeg-20060710/libavcodec/msmpeg4.c@ 11551

Last change on this file since 11551 was 5776, checked in by vboxsync, 17 years ago

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

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette