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