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