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