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