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