?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
use ber4 length for descriptors preferred by specs
[ffmpeg-lucabe.git] / libavcodec / msmpeg4.c
blob11d5ea4a0adfe0a01cec8d76ec0713463f1fe16a
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 libavcodec/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 #if 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 #if CONFIG_ENCODERS //strangely gcc includes this even if it is not referenced
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 av_cold 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= wmv1_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 CONFIG_WMV3_DECODER || 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 #if 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 av_cold 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 static void 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==FF_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==FF_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==FF_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 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==FF_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 == FF_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 #if 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 == FF_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 == FF_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 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 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_sbits(&s->pb, 8, slevel);
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 av_cold 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 av_cold 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 }
1067 INIT_VLC_RL(rl_table[0], 642);
1068 INIT_VLC_RL(rl_table[1], 1104);
1069 INIT_VLC_RL(rl_table[2], 554);
1070 INIT_VLC_RL(rl_table[3], 940);
1071 INIT_VLC_RL(rl_table[4], 962);
1072 INIT_VLC_RL(rl_table[5], 554);
1073
1074 mv = &mv_tables[0];
1075 INIT_VLC_STATIC(&mv->vlc, MV_VLC_BITS, mv->n + 1,
1076 mv->table_mv_bits, 1, 1,
1077 mv->table_mv_code, 2, 2, 3714);
1078 mv = &mv_tables[1];
1079 INIT_VLC_STATIC(&mv->vlc, MV_VLC_BITS, mv->n + 1,
1080 mv->table_mv_bits, 1, 1,
1081 mv->table_mv_code, 2, 2, 2694);
1082
1083 INIT_VLC_STATIC(&ff_msmp4_dc_luma_vlc[0], DC_VLC_BITS, 120,
1084 &ff_table0_dc_lum[0][1], 8, 4,
1085 &ff_table0_dc_lum[0][0], 8, 4, 1158);
1086 INIT_VLC_STATIC(&ff_msmp4_dc_chroma_vlc[0], DC_VLC_BITS, 120,
1087 &ff_table0_dc_chroma[0][1], 8, 4,
1088 &ff_table0_dc_chroma[0][0], 8, 4, 1118);
1089 INIT_VLC_STATIC(&ff_msmp4_dc_luma_vlc[1], DC_VLC_BITS, 120,
1090 &ff_table1_dc_lum[0][1], 8, 4,
1091 &ff_table1_dc_lum[0][0], 8, 4, 1476);
1092 INIT_VLC_STATIC(&ff_msmp4_dc_chroma_vlc[1], DC_VLC_BITS, 120,
1093 &ff_table1_dc_chroma[0][1], 8, 4,
1094 &ff_table1_dc_chroma[0][0], 8, 4, 1216);
1095
1096 INIT_VLC_STATIC(&v2_dc_lum_vlc, DC_VLC_BITS, 512,
1097 &v2_dc_lum_table[0][1], 8, 4,
1098 &v2_dc_lum_table[0][0], 8, 4, 1472);
1099 INIT_VLC_STATIC(&v2_dc_chroma_vlc, DC_VLC_BITS, 512,
1100 &v2_dc_chroma_table[0][1], 8, 4,
1101 &v2_dc_chroma_table[0][0], 8, 4, 1506);
1102
1103 INIT_VLC_STATIC(&cbpy_vlc, CBPY_VLC_BITS, 16,
1104 &cbpy_tab[0][1], 2, 1,
1105 &cbpy_tab[0][0], 2, 1, 64);
1106 INIT_VLC_STATIC(&v2_intra_cbpc_vlc, V2_INTRA_CBPC_VLC_BITS, 4,
1107 &v2_intra_cbpc[0][1], 2, 1,
1108 &v2_intra_cbpc[0][0], 2, 1, 8);
1109 INIT_VLC_STATIC(&v2_mb_type_vlc, V2_MB_TYPE_VLC_BITS, 8,
1110 &v2_mb_type[0][1], 2, 1,
1111 &v2_mb_type[0][0], 2, 1, 128);
1112 INIT_VLC_STATIC(&v2_mv_vlc, V2_MV_VLC_BITS, 33,
1113 &mvtab[0][1], 2, 1,
1114 &mvtab[0][0], 2, 1, 538);
1115
1116 INIT_VLC_STATIC(&ff_mb_non_intra_vlc[0], MB_NON_INTRA_VLC_BITS, 128,
1117 &wmv2_inter_table[0][0][1], 8, 4,
1118 &wmv2_inter_table[0][0][0], 8, 4, 1636);
1119 INIT_VLC_STATIC(&ff_mb_non_intra_vlc[1], MB_NON_INTRA_VLC_BITS, 128,
1120 &wmv2_inter_table[1][0][1], 8, 4,
1121 &wmv2_inter_table[1][0][0], 8, 4, 2648);
1122 INIT_VLC_STATIC(&ff_mb_non_intra_vlc[2], MB_NON_INTRA_VLC_BITS, 128,
1123 &wmv2_inter_table[2][0][1], 8, 4,
1124 &wmv2_inter_table[2][0][0], 8, 4, 1532);
1125 INIT_VLC_STATIC(&ff_mb_non_intra_vlc[3], MB_NON_INTRA_VLC_BITS, 128,
1126 &wmv2_inter_table[3][0][1], 8, 4,
1127 &wmv2_inter_table[3][0][0], 8, 4, 2488);
1128
1129 INIT_VLC_STATIC(&ff_msmp4_mb_i_vlc, MB_INTRA_VLC_BITS, 64,
1130 &ff_msmp4_mb_i_table[0][1], 4, 2,
1131 &ff_msmp4_mb_i_table[0][0], 4, 2, 536);
1132
1133 INIT_VLC_STATIC(&v1_intra_cbpc_vlc, V1_INTRA_CBPC_VLC_BITS, 8,
1134 intra_MCBPC_bits, 1, 1,
1135 intra_MCBPC_code, 1, 1, 64);
1136 INIT_VLC_STATIC(&v1_inter_cbpc_vlc, V1_INTER_CBPC_VLC_BITS, 25,
1137 inter_MCBPC_bits, 1, 1,
1138 inter_MCBPC_code, 1, 1, 104);
1139
1140 INIT_VLC_STATIC(&ff_inter_intra_vlc, INTER_INTRA_VLC_BITS, 4,
1141 &table_inter_intra[0][1], 2, 1,
1142 &table_inter_intra[0][0], 2, 1, 8);
1143 }
1144
1145 switch(s->msmpeg4_version){
1146 case 1:
1147 case 2:
1148 s->decode_mb= msmpeg4v12_decode_mb;
1149 break;
1150 case 3:
1151 case 4:
1152 s->decode_mb= msmpeg4v34_decode_mb;
1153 break;
1154 case 5:
1155 if (CONFIG_WMV2_DECODER)
1156 s->decode_mb= ff_wmv2_decode_mb;
1157 case 6:
1158 //FIXME + TODO VC1 decode mb
1159 break;
1160 }
1161
1162 s->slice_height= s->mb_height; //to avoid 1/0 if the first frame is not a keyframe
1163
1164 return 0;
1165 }
1166
1167 int msmpeg4_decode_picture_header(MpegEncContext * s)
1168 {
1169 int code;
1170
1171 #if 0
1172 {
1173 int i;
1174 for(i=0; i<s->gb.size_in_bits; i++)
1175 av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
1176 // get_bits1(&s->gb);
1177 av_log(s->avctx, AV_LOG_DEBUG, "END\n");
1178 return -1;
1179 }
1180 #endif
1181
1182 if(s->msmpeg4_version==1){
1183 int start_code;
1184 start_code = (get_bits(&s->gb, 16)<<16) | get_bits(&s->gb, 16);
1185 if(start_code!=0x00000100){
1186 av_log(s->avctx, AV_LOG_ERROR, "invalid startcode\n");
1187 return -1;
1188 }
1189
1190 skip_bits(&s->gb, 5); // frame number */
1191 }
1192
1193 s->pict_type = get_bits(&s->gb, 2) + 1;
1194 if (s->pict_type != FF_I_TYPE &&
1195 s->pict_type != FF_P_TYPE){
1196 av_log(s->avctx, AV_LOG_ERROR, "invalid picture type\n");
1197 return -1;
1198 }
1199 #if 0
1200 {
1201 static int had_i=0;
1202 if(s->pict_type == FF_I_TYPE) had_i=1;
1203 if(!had_i) return -1;
1204 }
1205 #endif
1206 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
1207 if(s->qscale==0){
1208 av_log(s->avctx, AV_LOG_ERROR, "invalid qscale\n");
1209 return -1;
1210 }
1211
1212 if (s->pict_type == FF_I_TYPE) {
1213 code = get_bits(&s->gb, 5);
1214 if(s->msmpeg4_version==1){
1215 if(code==0 || code>s->mb_height){
1216 av_log(s->avctx, AV_LOG_ERROR, "invalid slice height %d\n", code);
1217 return -1;
1218 }
1219
1220 s->slice_height = code;
1221 }else{
1222 /* 0x17: one slice, 0x18: two slices, ... */
1223 if (code < 0x17){
1224 av_log(s->avctx, AV_LOG_ERROR, "error, slice code was %X\n", code);
1225 return -1;
1226 }
1227
1228 s->slice_height = s->mb_height / (code - 0x16);
1229 }
1230
1231 switch(s->msmpeg4_version){
1232 case 1:
1233 case 2:
1234 s->rl_chroma_table_index = 2;
1235 s->rl_table_index = 2;
1236
1237 s->dc_table_index = 0; //not used
1238 break;
1239 case 3:
1240 s->rl_chroma_table_index = decode012(&s->gb);
1241 s->rl_table_index = decode012(&s->gb);
1242
1243 s->dc_table_index = get_bits1(&s->gb);
1244 break;
1245 case 4:
1246 msmpeg4_decode_ext_header(s, (2+5+5+17+7)/8);
1247
1248 if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
1249 else s->per_mb_rl_table= 0;
1250
1251 if(!s->per_mb_rl_table){
1252 s->rl_chroma_table_index = decode012(&s->gb);
1253 s->rl_table_index = decode012(&s->gb);
1254 }
1255
1256 s->dc_table_index = get_bits1(&s->gb);
1257 s->inter_intra_pred= 0;
1258 break;
1259 }
1260 s->no_rounding = 1;
1261 if(s->avctx->debug&FF_DEBUG_PICT_INFO)
1262 av_log(s->avctx, AV_LOG_DEBUG, "qscale:%d rlc:%d rl:%d dc:%d mbrl:%d slice:%d \n",
1263 s->qscale,
1264 s->rl_chroma_table_index,
1265 s->rl_table_index,
1266 s->dc_table_index,
1267 s->per_mb_rl_table,
1268 s->slice_height);
1269 } else {
1270 switch(s->msmpeg4_version){
1271 case 1:
1272 case 2:
1273 if(s->msmpeg4_version==1)
1274 s->use_skip_mb_code = 1;
1275 else
1276 s->use_skip_mb_code = get_bits1(&s->gb);
1277 s->rl_table_index = 2;
1278 s->rl_chroma_table_index = s->rl_table_index;
1279 s->dc_table_index = 0; //not used
1280 s->mv_table_index = 0;
1281 break;
1282 case 3:
1283 s->use_skip_mb_code = get_bits1(&s->gb);
1284 s->rl_table_index = decode012(&s->gb);
1285 s->rl_chroma_table_index = s->rl_table_index;
1286
1287 s->dc_table_index = get_bits1(&s->gb);
1288
1289 s->mv_table_index = get_bits1(&s->gb);
1290 break;
1291 case 4:
1292 s->use_skip_mb_code = get_bits1(&s->gb);
1293
1294 if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
1295 else s->per_mb_rl_table= 0;
1296
1297 if(!s->per_mb_rl_table){
1298 s->rl_table_index = decode012(&s->gb);
1299 s->rl_chroma_table_index = s->rl_table_index;
1300 }
1301
1302 s->dc_table_index = get_bits1(&s->gb);
1303
1304 s->mv_table_index = get_bits1(&s->gb);
1305 s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE);
1306 break;
1307 }
1308
1309 if(s->avctx->debug&FF_DEBUG_PICT_INFO)
1310 av_log(s->avctx, AV_LOG_DEBUG, "skip:%d rl:%d rlc:%d dc:%d mv:%d mbrl:%d qp:%d \n",
1311 s->use_skip_mb_code,
1312 s->rl_table_index,
1313 s->rl_chroma_table_index,
1314 s->dc_table_index,
1315 s->mv_table_index,
1316 s->per_mb_rl_table,
1317 s->qscale);
1318
1319 if(s->flipflop_rounding){
1320 s->no_rounding ^= 1;
1321 }else{
1322 s->no_rounding = 0;
1323 }
1324 }
1325 //printf("%d %d %d %d %d\n", s->pict_type, s->bit_rate, s->inter_intra_pred, s->width, s->height);
1326
1327 s->esc3_level_length= 0;
1328 s->esc3_run_length= 0;
1329
1330 #ifdef DEBUG
1331 av_log(s->avctx, AV_LOG_DEBUG, "*****frame %d:\n", frame_count++);
1332 #endif
1333 return 0;
1334 }
1335
1336 int msmpeg4_decode_ext_header(MpegEncContext * s, int buf_size)
1337 {
1338 int left= buf_size*8 - get_bits_count(&s->gb);
1339 int length= s->msmpeg4_version>=3 ? 17 : 16;
1340 /* the alt_bitstream reader could read over the end so we need to check it */
1341 if(left>=length && left<length+8)
1342 {
1343 int fps;
1344
1345 fps= get_bits(&s->gb, 5);
1346 s->bit_rate= get_bits(&s->gb, 11)*1024;
1347 if(s->msmpeg4_version>=3)
1348 s->flipflop_rounding= get_bits1(&s->gb);
1349 else
1350 s->flipflop_rounding= 0;
1351
1352 // printf("fps:%2d bps:%2d roundingType:%1d\n", fps, s->bit_rate/1024, s->flipflop_rounding);
1353 }
1354 else if(left<length+8)
1355 {
1356 s->flipflop_rounding= 0;
1357 if(s->msmpeg4_version != 2)
1358 av_log(s->avctx, AV_LOG_ERROR, "ext header missing, %d left\n", left);
1359 }
1360 else
1361 {
1362 av_log(s->avctx, AV_LOG_ERROR, "I frame too long, ignoring ext header\n");
1363 }
1364
1365 return 0;
1366 }
1367
1368 static inline void msmpeg4_memsetw(short *tab, int val, int n)
1369 {
1370 int i;
1371 for(i=0;i<n;i++)
1372 tab[i] = val;
1373 }
1374
1375 #if CONFIG_ENCODERS
1376 static void msmpeg4v2_encode_motion(MpegEncContext * s, int val)
1377 {
1378 int range, bit_size, sign, code, bits;
1379
1380 if (val == 0) {
1381 /* zero vector */
1382 code = 0;
1383 put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
1384 } else {
1385 bit_size = s->f_code - 1;
1386 range = 1 << bit_size;
1387 if (val <= -64)
1388 val += 64;
1389 else if (val >= 64)
1390 val -= 64;
1391
1392 if (val >= 0) {
1393 sign = 0;
1394 } else {
1395 val = -val;
1396 sign = 1;
1397 }
1398 val--;
1399 code = (val >> bit_size) + 1;
1400 bits = val & (range - 1);
1401
1402 put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
1403 if (bit_size > 0) {
1404 put_bits(&s->pb, bit_size, bits);
1405 }
1406 }
1407 }
1408 #endif
1409
1410 /* This is identical to h263 except that its range is multiplied by 2. */
1411 static int msmpeg4v2_decode_motion(MpegEncContext * s, int pred, int f_code)
1412 {
1413 int code, val, sign, shift;
1414
1415 code = get_vlc2(&s->gb, v2_mv_vlc.table, V2_MV_VLC_BITS, 2);
1416 // printf("MV code %d at %d %d pred: %d\n", code, s->mb_x,s->mb_y, pred);
1417 if (code < 0)
1418 return 0xffff;
1419
1420 if (code == 0)
1421 return pred;
1422 sign = get_bits1(&s->gb);
1423 shift = f_code - 1;
1424 val = code;
1425 if (shift) {
1426 val = (val - 1) << shift;
1427 val |= get_bits(&s->gb, shift);
1428 val++;
1429 }
1430 if (sign)
1431 val = -val;
1432
1433 val += pred;
1434 if (val <= -64)
1435 val += 64;
1436 else if (val >= 64)
1437 val -= 64;
1438
1439 return val;
1440 }
1441
1442 static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1443 {
1444 int cbp, code, i;
1445
1446 if (s->pict_type == FF_P_TYPE) {
1447 if (s->use_skip_mb_code) {
1448 if (get_bits1(&s->gb)) {
1449 /* skip mb */
1450 s->mb_intra = 0;
1451 for(i=0;i<6;i++)
1452 s->block_last_index[i] = -1;
1453 s->mv_dir = MV_DIR_FORWARD;
1454 s->mv_type = MV_TYPE_16X16;
1455 s->mv[0][0][0] = 0;
1456 s->mv[0][0][1] = 0;
1457 s->mb_skipped = 1;
1458 return 0;
1459 }
1460 }
1461
1462 if(s->msmpeg4_version==2)
1463 code = get_vlc2(&s->gb, v2_mb_type_vlc.table, V2_MB_TYPE_VLC_BITS, 1);
1464 else
1465 code = get_vlc2(&s->gb, v1_inter_cbpc_vlc.table, V1_INTER_CBPC_VLC_BITS, 3);
1466 if(code<0 || code>7){
1467 av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", code, s->mb_x, s->mb_y);
1468 return -1;
1469 }
1470
1471 s->mb_intra = code >>2;
1472
1473 cbp = code & 0x3;
1474 } else {
1475 s->mb_intra = 1;
1476 if(s->msmpeg4_version==2)
1477 cbp= get_vlc2(&s->gb, v2_intra_cbpc_vlc.table, V2_INTRA_CBPC_VLC_BITS, 1);
1478 else
1479 cbp= get_vlc2(&s->gb, v1_intra_cbpc_vlc.table, V1_INTRA_CBPC_VLC_BITS, 1);
1480 if(cbp<0 || cbp>3){
1481 av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
1482 return -1;
1483 }
1484 }
1485
1486 if (!s->mb_intra) {
1487 int mx, my, cbpy;
1488
1489 cbpy= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
1490 if(cbpy<0){
1491 av_log(s->avctx, AV_LOG_ERROR, "cbpy %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
1492 return -1;
1493 }
1494
1495 cbp|= cbpy<<2;
1496 if(s->msmpeg4_version==1 || (cbp&3) != 3) cbp^= 0x3C;
1497
1498 h263_pred_motion(s, 0, 0, &mx, &my);
1499 mx= msmpeg4v2_decode_motion(s, mx, 1);
1500 my= msmpeg4v2_decode_motion(s, my, 1);
1501
1502 s->mv_dir = MV_DIR_FORWARD;
1503 s->mv_type = MV_TYPE_16X16;
1504 s->mv[0][0][0] = mx;
1505 s->mv[0][0][1] = my;
1506 } else {
1507 if(s->msmpeg4_version==2){
1508 s->ac_pred = get_bits1(&s->gb);
1509 cbp|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
1510 } else{
1511 s->ac_pred = 0;
1512 cbp|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
1513 if(s->pict_type==FF_P_TYPE) cbp^=0x3C;
1514 }
1515 }
1516
1517 s->dsp.clear_blocks(s->block[0]);
1518 for (i = 0; i < 6; i++) {
1519 if (ff_msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
1520 {
1521 av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1522 return -1;
1523 }
1524 }
1525 return 0;
1526 }
1527
1528 static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1529 {
1530 int cbp, code, i;
1531 uint8_t *coded_val;
1532 uint32_t * const mb_type_ptr= &s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ];
1533
1534 if (s->pict_type == FF_P_TYPE) {
1535 if (s->use_skip_mb_code) {
1536 if (get_bits1(&s->gb)) {
1537 /* skip mb */
1538 s->mb_intra = 0;
1539 for(i=0;i<6;i++)
1540 s->block_last_index[i] = -1;
1541 s->mv_dir = MV_DIR_FORWARD;
1542 s->mv_type = MV_TYPE_16X16;
1543 s->mv[0][0][0] = 0;
1544 s->mv[0][0][1] = 0;
1545 s->mb_skipped = 1;
1546 *mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
1547
1548 return 0;
1549 }
1550 }
1551
1552 code = get_vlc2(&s->gb, ff_mb_non_intra_vlc[DEFAULT_INTER_INDEX].table, MB_NON_INTRA_VLC_BITS, 3);
1553 if (code < 0)
1554 return -1;
1555 //s->mb_intra = (code & 0x40) ? 0 : 1;
1556 s->mb_intra = (~code & 0x40) >> 6;
1557
1558 cbp = code & 0x3f;
1559 } else {
1560 s->mb_intra = 1;
1561 code = get_vlc2(&s->gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
1562 if (code < 0)
1563 return -1;
1564 /* predict coded block pattern */
1565 cbp = 0;
1566 for(i=0;i<6;i++) {
1567 int val = ((code >> (5 - i)) & 1);
1568 if (i < 4) {
1569 int pred = ff_msmpeg4_coded_block_pred(s, i, &coded_val);
1570 val = val ^ pred;
1571 *coded_val = val;
1572 }
1573 cbp |= val << (5 - i);
1574 }
1575 }
1576
1577 if (!s->mb_intra) {
1578 int mx, my;
1579 //printf("P at %d %d\n", s->mb_x, s->mb_y);
1580 if(s->per_mb_rl_table && cbp){
1581 s->rl_table_index = decode012(&s->gb);
1582 s->rl_chroma_table_index = s->rl_table_index;
1583 }
1584 h263_pred_motion(s, 0, 0, &mx, &my);
1585 if (ff_msmpeg4_decode_motion(s, &mx, &my) < 0)
1586 return -1;
1587 s->mv_dir = MV_DIR_FORWARD;
1588 s->mv_type = MV_TYPE_16X16;
1589 s->mv[0][0][0] = mx;
1590 s->mv[0][0][1] = my;
1591 *mb_type_ptr = MB_TYPE_L0 | MB_TYPE_16x16;
1592 } else {
1593 //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));
1594 s->ac_pred = get_bits1(&s->gb);
1595 *mb_type_ptr = MB_TYPE_INTRA;
1596 if(s->inter_intra_pred){
1597 s->h263_aic_dir= get_vlc2(&s->gb, ff_inter_intra_vlc.table, INTER_INTRA_VLC_BITS, 1);
1598 // printf("%d%d %d %d/", s->ac_pred, s->h263_aic_dir, s->mb_x, s->mb_y);
1599 }
1600 if(s->per_mb_rl_table && cbp){
1601 s->rl_table_index = decode012(&s->gb);
1602 s->rl_chroma_table_index = s->rl_table_index;
1603 }
1604 }
1605
1606 s->dsp.clear_blocks(s->block[0]);
1607 for (i = 0; i < 6; i++) {
1608 if (ff_msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
1609 {
1610 av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1611 return -1;
1612 }
1613 }
1614
1615 return 0;
1616 }
1617 //#define ERROR_DETAILS
1618 int ff_msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
1619 int n, int coded, const uint8_t *scan_table)
1620 {
1621 int level, i, last, run, run_diff;
1622 int av_uninit(dc_pred_dir);
1623 RLTable *rl;
1624 RL_VLC_ELEM *rl_vlc;
1625 int qmul, qadd;
1626
1627 if (s->mb_intra) {
1628 qmul=1;
1629 qadd=0;
1630
1631 /* DC coef */
1632 level = msmpeg4_decode_dc(s, n, &dc_pred_dir);
1633
1634 if (level < 0){
1635 av_log(s->avctx, AV_LOG_ERROR, "dc overflow- block: %d qscale: %d//\n", n, s->qscale);
1636 if(s->inter_intra_pred) level=0;
1637 else return -1;
1638 }
1639 if (n < 4) {
1640 rl = &rl_table[s->rl_table_index];
1641 if(level > 256*s->y_dc_scale){
1642 av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ L qscale: %d//\n", s->qscale);
1643 if(!s->inter_intra_pred) return -1;
1644 }
1645 } else {
1646 rl = &rl_table[3 + s->rl_chroma_table_index];
1647 if(level > 256*s->c_dc_scale){
1648 av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ C qscale: %d//\n", s->qscale);
1649 if(!s->inter_intra_pred) return -1;
1650 }
1651 }
1652 block[0] = level;
1653
1654 run_diff = s->msmpeg4_version >= 4;
1655 i = 0;
1656 if (!coded) {
1657 goto not_coded;
1658 }
1659 if (s->ac_pred) {
1660 if (dc_pred_dir == 0)
1661 scan_table = s->intra_v_scantable.permutated; /* left */
1662 else
1663 scan_table = s->intra_h_scantable.permutated; /* top */
1664 } else {
1665 scan_table = s->intra_scantable.permutated;
1666 }
1667 rl_vlc= rl->rl_vlc[0];
1668 } else {
1669 qmul = s->qscale << 1;
1670 qadd = (s->qscale - 1) | 1;
1671 i = -1;
1672 rl = &rl_table[3 + s->rl_table_index];
1673
1674 if(s->msmpeg4_version==2)
1675 run_diff = 0;
1676 else
1677 run_diff = 1;
1678
1679 if (!coded) {
1680 s->block_last_index[n] = i;
1681 return 0;
1682 }
1683 if(!scan_table)
1684 scan_table = s->inter_scantable.permutated;
1685 rl_vlc= rl->rl_vlc[s->qscale];
1686 }
1687 {
1688 OPEN_READER(re, &s->gb);
1689 for(;;) {
1690 UPDATE_CACHE(re, &s->gb);
1691 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
1692 if (level==0) {
1693 int cache;
1694 cache= GET_CACHE(re, &s->gb);
1695 /* escape */
1696 if (s->msmpeg4_version==1 || (cache&0x80000000)==0) {
1697 if (s->msmpeg4_version==1 || (cache&0x40000000)==0) {
1698 /* third escape */
1699 if(s->msmpeg4_version!=1) LAST_SKIP_BITS(re, &s->gb, 2);
1700 UPDATE_CACHE(re, &s->gb);
1701 if(s->msmpeg4_version<=3){
1702 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
1703 run= SHOW_UBITS(re, &s->gb, 6); SKIP_CACHE(re, &s->gb, 6);
1704 level= SHOW_SBITS(re, &s->gb, 8); LAST_SKIP_CACHE(re, &s->gb, 8);
1705 SKIP_COUNTER(re, &s->gb, 1+6+8);
1706 }else{
1707 int sign;
1708 last= SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1);
1709 if(!s->esc3_level_length){
1710 int ll;
1711 //printf("ESC-3 %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y);
1712 if(s->qscale<8){
1713 ll= SHOW_UBITS(re, &s->gb, 3); SKIP_BITS(re, &s->gb, 3);
1714 if(ll==0){
1715 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");
1716 SKIP_BITS(re, &s->gb, 1);
1717 ll=8;
1718 }
1719 }else{
1720 ll=2;
1721 while(ll<8 && SHOW_UBITS(re, &s->gb, 1)==0){
1722 ll++;
1723 SKIP_BITS(re, &s->gb, 1);
1724 }
1725 if(ll<8) SKIP_BITS(re, &s->gb, 1);
1726 }
1727
1728 s->esc3_level_length= ll;
1729 s->esc3_run_length= SHOW_UBITS(re, &s->gb, 2) + 3; SKIP_BITS(re, &s->gb, 2);
1730 //printf("level length:%d, run length: %d\n", ll, s->esc3_run_length);
1731 UPDATE_CACHE(re, &s->gb);
1732 }
1733 run= SHOW_UBITS(re, &s->gb, s->esc3_run_length);
1734 SKIP_BITS(re, &s->gb, s->esc3_run_length);
1735
1736 sign= SHOW_UBITS(re, &s->gb, 1);
1737 SKIP_BITS(re, &s->gb, 1);
1738
1739 level= SHOW_UBITS(re, &s->gb, s->esc3_level_length);
1740 SKIP_BITS(re, &s->gb, s->esc3_level_length);
1741 if(sign) level= -level;
1742 }
1743 //printf("level: %d, run: %d at %d %d\n", level, run, s->mb_x, s->mb_y);
1744 #if 0 // waste of time / this will detect very few errors
1745 {
1746 const int abs_level= FFABS(level);
1747 const int run1= run - rl->max_run[last][abs_level] - run_diff;
1748 if(abs_level<=MAX_LEVEL && run<=MAX_RUN){
1749 if(abs_level <= rl->max_level[last][run]){
1750 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n");
1751 return DECODING_AC_LOST;
1752 }
1753 if(abs_level <= rl->max_level[last][run]*2){
1754 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 1 encoding possible\n");
1755 return DECODING_AC_LOST;
1756 }
1757 if(run1>=0 && abs_level <= rl->max_level[last][run1]){
1758 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 2 encoding possible\n");
1759 return DECODING_AC_LOST;
1760 }
1761 }
1762 }
1763 #endif
1764 //level = level * qmul + (level>0) * qadd - (level<=0) * qadd ;
1765 if (level>0) level= level * qmul + qadd;
1766 else level= level * qmul - qadd;
1767 #if 0 // waste of time too :(
1768 if(level>2048 || level<-2048){
1769 av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc\n");
1770 return DECODING_AC_LOST;
1771 }
1772 #endif
1773 i+= run + 1;
1774 if(last) i+=192;
1775 #ifdef ERROR_DETAILS
1776 if(run==66)
1777 av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC3 level=%d\n", level);
1778 else if((i>62 && i<192) || i>192+63)
1779 av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC3 i=%d run=%d level=%d\n", i, run, level);
1780 #endif
1781 } else {
1782 /* second escape */
1783 #if MIN_CACHE_BITS < 23
1784 LAST_SKIP_BITS(re, &s->gb, 2);
1785 UPDATE_CACHE(re, &s->gb);
1786 #else
1787 SKIP_BITS(re, &s->gb, 2);
1788 #endif
1789 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
1790 i+= run + rl->max_run[run>>7][level/qmul] + run_diff; //FIXME opt indexing
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 in ESC2 level=%d\n", level);
1796 else if((i>62 && i<192) || i>192+63)
1797 av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC2 i=%d run=%d level=%d\n", i, run, level);
1798 #endif
1799 }
1800 } else {
1801 /* first escape */
1802 #if MIN_CACHE_BITS < 22
1803 LAST_SKIP_BITS(re, &s->gb, 1);
1804 UPDATE_CACHE(re, &s->gb);
1805 #else
1806 SKIP_BITS(re, &s->gb, 1);
1807 #endif
1808 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
1809 i+= run;
1810 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
1811 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1812 LAST_SKIP_BITS(re, &s->gb, 1);
1813 #ifdef ERROR_DETAILS
1814 if(run==66)
1815 av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC1 level=%d\n", level);
1816 else if((i>62 && i<192) || i>192+63)
1817 av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC1 i=%d run=%d level=%d\n", i, run, level);
1818 #endif
1819 }
1820 } else {
1821 i+= run;
1822 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1823 LAST_SKIP_BITS(re, &s->gb, 1);
1824 #ifdef ERROR_DETAILS
1825 if(run==66)
1826 av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code level=%d\n", level);
1827 else if((i>62 && i<192) || i>192+63)
1828 av_log(s->avctx, AV_LOG_ERROR, "run overflow i=%d run=%d level=%d\n", i, run, level);
1829 #endif
1830 }
1831 if (i > 62){
1832 i-= 192;
1833 if(i&(~63)){
1834 const int left= s->gb.size_in_bits - get_bits_count(&s->gb);
1835 if(((i+192 == 64 && level/qmul==-1) || s->error_recognition<=1) && left>=0){
1836 av_log(s->avctx, AV_LOG_ERROR, "ignoring overflow at %d %d\n", s->mb_x, s->mb_y);
1837 break;
1838 }else{
1839 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1840 return -1;
1841 }
1842 }
1843
1844 block[scan_table[i]] = level;
1845 break;
1846 }
1847
1848 block[scan_table[i]] = level;
1849 }
1850 CLOSE_READER(re, &s->gb);
1851 }
1852 not_coded:
1853 if (s->mb_intra) {
1854 mpeg4_pred_ac(s, block, n, dc_pred_dir);
1855 if (s->ac_pred) {
1856 i = 63; /* XXX: not optimal */
1857 }
1858 }
1859 if(s->msmpeg4_version>=4 && i>0) i=63; //FIXME/XXX optimize
1860 s->block_last_index[n] = i;
1861
1862 return 0;
1863 }
1864
1865 static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
1866 {
1867 int level, pred;
1868
1869 if(s->msmpeg4_version<=2){
1870 if (n < 4) {
1871 level = get_vlc2(&s->gb, v2_dc_lum_vlc.table, DC_VLC_BITS, 3);
1872 } else {
1873 level = get_vlc2(&s->gb, v2_dc_chroma_vlc.table, DC_VLC_BITS, 3);
1874 }
1875 if (level < 0)
1876 return -1;
1877 level-=256;
1878 }else{ //FIXME optimize use unified tables & index
1879 if (n < 4) {
1880 level = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1881 } else {
1882 level = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1883 }
1884 if (level < 0){
1885 av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
1886 return -1;
1887 }
1888
1889 if (level == DC_MAX) {
1890 level = get_bits(&s->gb, 8);
1891 if (get_bits1(&s->gb))
1892 level = -level;
1893 } else if (level != 0) {
1894 if (get_bits1(&s->gb))
1895 level = -level;
1896 }
1897 }
1898
1899 if(s->msmpeg4_version==1){
1900 int32_t *dc_val;
1901 pred = msmpeg4v1_pred_dc(s, n, &dc_val);
1902 level += pred;
1903
1904 /* update predictor */
1905 *dc_val= level;
1906 }else{
1907 int16_t *dc_val;
1908 pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
1909 level += pred;
1910
1911 /* update predictor */
1912 if (n < 4) {
1913 *dc_val = level * s->y_dc_scale;
1914 } else {
1915 *dc_val = level * s->c_dc_scale;
1916 }
1917 }
1918
1919 return level;
1920 }
1921
1922 int ff_msmpeg4_decode_motion(MpegEncContext * s,
1923 int *mx_ptr, int *my_ptr)
1924 {
1925 MVTable *mv;
1926 int code, mx, my;
1927
1928 mv = &mv_tables[s->mv_table_index];
1929
1930 code = get_vlc2(&s->gb, mv->vlc.table, MV_VLC_BITS, 2);
1931 if (code < 0){
1932 av_log(s->avctx, AV_LOG_ERROR, "illegal MV code at %d %d\n", s->mb_x, s->mb_y);
1933 return -1;
1934 }
1935 if (code == mv->n) {
1936 //printf("MV ESC %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y);
1937 mx = get_bits(&s->gb, 6);
1938 my = get_bits(&s->gb, 6);
1939 } else {
1940 mx = mv->table_mvx[code];
1941 my = mv->table_mvy[code];
1942 }
1943
1944 mx += *mx_ptr - 32;
1945 my += *my_ptr - 32;
1946 /* WARNING : they do not do exactly modulo encoding */
1947 if (mx <= -64)
1948 mx += 64;
1949 else if (mx >= 64)
1950 mx -= 64;
1951
1952 if (my <= -64)
1953 my += 64;
1954 else if (my >= 64)
1955 my -= 64;
1956 *mx_ptr = mx;
1957 *my_ptr = my;
1958 return 0;
1959 }
lucabe's unfinished and experimental patches for ffmpeg