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