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