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