2
* MSMPEG4 backend for ffmpeg encoder and decoder
3
* Copyright (c) 2001 Fabrice Bellard.
4
* Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
6
* This library is free software; you can redistribute it and/or
7
* modify it under the terms of the GNU Lesser General Public
8
* License as published by the Free Software Foundation; either
9
* version 2 of the License, or (at your option) any later version.
11
* This library is distributed in the hope that it will be useful,
12
* but WITHOUT ANY WARRANTY; without even the implied warranty of
13
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14
* Lesser General Public License for more details.
16
* You should have received a copy of the GNU Lesser General Public
17
* License along with this library; if not, write to the Free Software
18
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
* msmpeg4v1 & v2 stuff by Michael Niedermayer <michaelni@gmx.at>
25
* MSMPEG4 backend for ffmpeg encoder and decoder.
30
#include "mpegvideo.h"
33
* You can also call this codec : MPEG4 with a twist !
36
* - (encoding) select best mv table (two choices)
37
* - (encoding) select best vlc/dc table
42
#define CBPY_VLC_BITS 6
43
#define INTER_INTRA_VLC_BITS 3
44
#define V1_INTRA_CBPC_VLC_BITS 6
45
#define V1_INTER_CBPC_VLC_BITS 6
46
#define V2_INTRA_CBPC_VLC_BITS 3
47
#define V2_MB_TYPE_VLC_BITS 7
49
#define V2_MV_VLC_BITS 9
50
#define TEX_VLC_BITS 9
51
#define MB_NON_INTRA_VLC_BITS 9
52
#define MB_INTRA_VLC_BITS 9
54
#define II_BITRATE 128*1024
55
#define MBAC_BITRATE 50*1024
57
#define DEFAULT_INTER_INDEX 3
59
static uint32_t v2_dc_lum_table[512][2];
60
static uint32_t v2_dc_chroma_table[512][2];
62
static inline void msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n);
63
static inline int msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
64
int n, int coded, const uint8_t *scantable);
65
static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr);
66
static int msmpeg4_decode_motion(MpegEncContext * s,
67
int *mx_ptr, int *my_ptr);
68
static void msmpeg4v2_encode_motion(MpegEncContext * s, int val);
69
static void init_h263_dc_for_msmpeg4(void);
70
static inline void msmpeg4_memsetw(short *tab, int val, int n);
71
#ifdef CONFIG_ENCODERS
72
static int get_size_of_code(MpegEncContext * s, RLTable *rl, int last, int run, int level, int intra);
73
#endif //CONFIG_ENCODERS
74
static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64]);
75
static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64]);
76
static int wmv2_decode_mb(MpegEncContext *s, DCTELEM block[6][64]);
79
extern uint8_t wmv3_dc_scale_table[32];
86
#include "msmpeg4data.h"
88
#ifdef CONFIG_ENCODERS //strangely gcc includes this even if its not references
89
static uint8_t rl_length[NB_RL_TABLES][MAX_LEVEL+1][MAX_RUN+1][2];
90
#endif //CONFIG_ENCODERS
92
static void common_init(MpegEncContext * s)
96
switch(s->msmpeg4_version){
100
s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
103
if(s->workaround_bugs){
104
s->y_dc_scale_table= old_ff_y_dc_scale_table;
105
s->c_dc_scale_table= old_ff_c_dc_scale_table;
107
s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table;
108
s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
113
s->y_dc_scale_table= wmv1_y_dc_scale_table;
114
s->c_dc_scale_table= wmv1_c_dc_scale_table;
116
#if defined(CONFIG_WMV3_DECODER)||defined(CONFIG_VC1_DECODER)
118
s->y_dc_scale_table= wmv3_dc_scale_table;
119
s->c_dc_scale_table= wmv3_dc_scale_table;
126
if(s->msmpeg4_version>=4){
127
ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , wmv1_scantable[1]);
128
ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, wmv1_scantable[2]);
129
ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, wmv1_scantable[3]);
130
ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , wmv1_scantable[0]);
132
//Note the default tables are set in common_init in mpegvideo.c
137
init_h263_dc_for_msmpeg4();
141
#ifdef CONFIG_ENCODERS
143
/* build the table which associate a (x,y) motion vector to a vlc */
144
static void init_mv_table(MVTable *tab)
148
tab->table_mv_index = av_malloc(sizeof(uint16_t) * 4096);
149
/* mark all entries as not used */
151
tab->table_mv_index[i] = tab->n;
153
for(i=0;i<tab->n;i++) {
154
x = tab->table_mvx[i];
155
y = tab->table_mvy[i];
156
tab->table_mv_index[(x << 6) | y] = i;
160
static void code012(PutBitContext *pb, int n)
166
put_bits(pb, 1, (n >= 2));
170
void ff_msmpeg4_encode_init(MpegEncContext *s)
172
static int init_done=0;
176
if(s->msmpeg4_version>=4){
182
/* init various encoding tables */
184
init_mv_table(&mv_tables[0]);
185
init_mv_table(&mv_tables[1]);
186
for(i=0;i<NB_RL_TABLES;i++)
187
init_rl(&rl_table[i], 1);
189
for(i=0; i<NB_RL_TABLES; i++){
191
for(level=0; level<=MAX_LEVEL; level++){
193
for(run=0; run<=MAX_RUN; run++){
195
for(last=0; last<2; last++){
196
rl_length[i][level][run][last]= get_size_of_code(s, &rl_table[ i], last, run, level, 0);
204
static int get_size_of_code(MpegEncContext * s, RLTable *rl, int last, int run, int level, int intra){
207
int run_diff= intra ? 0 : 1;
209
code = get_rl_index(rl, last, run, level);
210
size+= rl->table_vlc[code][1];
214
level1 = level - rl->max_level[last][run];
217
code = get_rl_index(rl, last, run, level1);
221
if (level > MAX_LEVEL)
223
run1 = run - rl->max_run[last][level] - run_diff;
226
code = get_rl_index(rl, last, run1, level);
233
size+= 1+1+ rl->table_vlc[code][1];
237
size+= 1+1+ rl->table_vlc[code][1];
245
static void find_best_tables(MpegEncContext * s)
248
int best =-1, best_size =9999999;
249
int chroma_best=-1, best_chroma_size=9999999;
260
for(level=0; level<=MAX_LEVEL; level++){
262
for(run=0; run<=MAX_RUN; run++){
264
const int last_size= size + chroma_size;
265
for(last=0; last<2; last++){
266
int inter_count = s->ac_stats[0][0][level][run][last] + s->ac_stats[0][1][level][run][last];
267
int intra_luma_count = s->ac_stats[1][0][level][run][last];
268
int intra_chroma_count= s->ac_stats[1][1][level][run][last];
270
if(s->pict_type==I_TYPE){
271
size += intra_luma_count *rl_length[i ][level][run][last];
272
chroma_size+= intra_chroma_count*rl_length[i+3][level][run][last];
274
size+= intra_luma_count *rl_length[i ][level][run][last]
275
+intra_chroma_count*rl_length[i+3][level][run][last]
276
+inter_count *rl_length[i+3][level][run][last];
279
if(last_size == size+chroma_size) break;
286
if(chroma_size<best_chroma_size){
287
best_chroma_size= chroma_size;
292
// printf("type:%d, best:%d, qp:%d, var:%d, mcvar:%d, size:%d //\n",
293
// s->pict_type, best, s->qscale, s->mb_var_sum, s->mc_mb_var_sum, best_size);
295
if(s->pict_type==P_TYPE) chroma_best= best;
297
memset(s->ac_stats, 0, sizeof(int)*(MAX_LEVEL+1)*(MAX_RUN+1)*2*2*2);
299
s->rl_table_index = best;
300
s->rl_chroma_table_index= chroma_best;
302
if(s->pict_type != s->last_non_b_pict_type){
303
s->rl_table_index= 2;
304
if(s->pict_type==I_TYPE)
305
s->rl_chroma_table_index= 1;
307
s->rl_chroma_table_index= 2;
312
/* write MSMPEG4 compatible frame header */
313
void msmpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
317
align_put_bits(&s->pb);
318
put_bits(&s->pb, 2, s->pict_type - 1);
320
put_bits(&s->pb, 5, s->qscale);
321
if(s->msmpeg4_version<=2){
322
s->rl_table_index = 2;
323
s->rl_chroma_table_index = 2;
326
s->dc_table_index = 1;
327
s->mv_table_index = 1; /* only if P frame */
328
s->use_skip_mb_code = 1; /* only if P frame */
329
s->per_mb_rl_table = 0;
330
if(s->msmpeg4_version==4)
331
s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE && s->pict_type==P_TYPE);
332
//printf("%d %d %d %d %d\n", s->pict_type, s->bit_rate, s->inter_intra_pred, s->width, s->height);
334
if (s->pict_type == I_TYPE) {
335
s->slice_height= s->mb_height/1;
336
put_bits(&s->pb, 5, 0x16 + s->mb_height/s->slice_height);
338
if(s->msmpeg4_version==4){
339
msmpeg4_encode_ext_header(s);
340
if(s->bit_rate>MBAC_BITRATE)
341
put_bits(&s->pb, 1, s->per_mb_rl_table);
344
if(s->msmpeg4_version>2){
345
if(!s->per_mb_rl_table){
346
code012(&s->pb, s->rl_chroma_table_index);
347
code012(&s->pb, s->rl_table_index);
350
put_bits(&s->pb, 1, s->dc_table_index);
353
put_bits(&s->pb, 1, s->use_skip_mb_code);
355
if(s->msmpeg4_version==4 && s->bit_rate>MBAC_BITRATE)
356
put_bits(&s->pb, 1, s->per_mb_rl_table);
358
if(s->msmpeg4_version>2){
359
if(!s->per_mb_rl_table)
360
code012(&s->pb, s->rl_table_index);
362
put_bits(&s->pb, 1, s->dc_table_index);
364
put_bits(&s->pb, 1, s->mv_table_index);
368
s->esc3_level_length= 0;
369
s->esc3_run_length= 0;
373
av_log(s->avctx, AV_LOG_DEBUG, "*****frame %d:\n", frame_count++);
377
void msmpeg4_encode_ext_header(MpegEncContext * s)
379
put_bits(&s->pb, 5, s->avctx->time_base.den / s->avctx->time_base.num); //yes 29.97 -> 29
381
put_bits(&s->pb, 11, FFMIN(s->bit_rate/1024, 2047));
383
if(s->msmpeg4_version>=3)
384
put_bits(&s->pb, 1, s->flipflop_rounding);
386
assert(s->flipflop_rounding==0);
389
#endif //CONFIG_ENCODERS
391
/* predict coded block */
392
static inline int coded_block_pred(MpegEncContext * s, int n, uint8_t **coded_block_ptr)
394
int xy, wrap, pred, a, b, c;
396
xy = s->block_index[n];
402
a = s->coded_block[xy - 1 ];
403
b = s->coded_block[xy - 1 - wrap];
404
c = s->coded_block[xy - wrap];
413
*coded_block_ptr = &s->coded_block[xy];
418
#ifdef CONFIG_ENCODERS
420
static void msmpeg4_encode_motion(MpegEncContext * s,
426
/* modulo encoding */
427
/* WARNING : you cannot reach all the MVs even with the modulo
428
encoding. This is a somewhat strange compromise they took !!! */
441
if ((unsigned)mx >= 64 ||
443
av_log(s->avctx, AV_LOG_ERROR, "error mx=%d my=%d\n", mx, my);
445
mv = &mv_tables[s->mv_table_index];
447
code = mv->table_mv_index[(mx << 6) | my];
449
mv->table_mv_bits[code],
450
mv->table_mv_code[code]);
452
/* escape : code litterally */
453
put_bits(&s->pb, 6, mx);
454
put_bits(&s->pb, 6, my);
458
static inline void handle_slices(MpegEncContext *s){
460
if (s->slice_height && (s->mb_y % s->slice_height) == 0) {
461
if(s->msmpeg4_version < 4){
462
ff_mpeg4_clean_buffers(s);
464
s->first_slice_line = 1;
466
s->first_slice_line = 0;
471
void msmpeg4_encode_mb(MpegEncContext * s,
472
DCTELEM block[6][64],
473
int motion_x, int motion_y)
475
int cbp, coded_cbp, i;
477
uint8_t *coded_block;
484
for (i = 0; i < 6; i++) {
485
if (s->block_last_index[i] >= 0)
488
if (s->use_skip_mb_code && (cbp | motion_x | motion_y) == 0) {
489
/* skip macroblock */
490
put_bits(&s->pb, 1, 1);
497
if (s->use_skip_mb_code)
498
put_bits(&s->pb, 1, 0); /* mb coded */
500
if(s->msmpeg4_version<=2){
502
v2_mb_type[cbp&3][1],
503
v2_mb_type[cbp&3][0]);
504
if((cbp&3) != 3) coded_cbp= cbp ^ 0x3C;
508
cbpy_tab[coded_cbp>>2][1],
509
cbpy_tab[coded_cbp>>2][0]);
511
s->misc_bits += get_bits_diff(s);
513
h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
514
msmpeg4v2_encode_motion(s, motion_x - pred_x);
515
msmpeg4v2_encode_motion(s, motion_y - pred_y);
518
table_mb_non_intra[cbp + 64][1],
519
table_mb_non_intra[cbp + 64][0]);
521
s->misc_bits += get_bits_diff(s);
524
h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
525
msmpeg4_encode_motion(s, motion_x - pred_x,
529
s->mv_bits += get_bits_diff(s);
531
for (i = 0; i < 6; i++) {
532
msmpeg4_encode_block(s, block[i], i);
534
s->p_tex_bits += get_bits_diff(s);
539
for (i = 0; i < 6; i++) {
541
val = (s->block_last_index[i] >= 1);
542
cbp |= val << (5 - i);
544
/* predict value for close blocks only for luma */
545
pred = coded_block_pred(s, i, &coded_block);
549
coded_cbp |= val << (5 - i);
553
printf("cbp=%x %x\n", cbp, coded_cbp);
556
if(s->msmpeg4_version<=2){
557
if (s->pict_type == I_TYPE) {
559
v2_intra_cbpc[cbp&3][1], v2_intra_cbpc[cbp&3][0]);
561
if (s->use_skip_mb_code)
562
put_bits(&s->pb, 1, 0); /* mb coded */
564
v2_mb_type[(cbp&3) + 4][1],
565
v2_mb_type[(cbp&3) + 4][0]);
567
put_bits(&s->pb, 1, 0); /* no AC prediction yet */
570
cbpy_tab[cbp>>2][0]);
572
if (s->pict_type == I_TYPE) {
574
ff_msmp4_mb_i_table[coded_cbp][1], ff_msmp4_mb_i_table[coded_cbp][0]);
576
if (s->use_skip_mb_code)
577
put_bits(&s->pb, 1, 0); /* mb coded */
579
table_mb_non_intra[cbp][1],
580
table_mb_non_intra[cbp][0]);
582
put_bits(&s->pb, 1, 0); /* no AC prediction yet */
583
if(s->inter_intra_pred){
585
put_bits(&s->pb, table_inter_intra[s->h263_aic_dir][1], table_inter_intra[s->h263_aic_dir][0]);
588
s->misc_bits += get_bits_diff(s);
590
for (i = 0; i < 6; i++) {
591
msmpeg4_encode_block(s, block[i], i);
593
s->i_tex_bits += get_bits_diff(s);
598
#endif //CONFIG_ENCODERS
600
static inline int msmpeg4v1_pred_dc(MpegEncContext * s, int n,
601
int32_t **dc_val_ptr)
611
*dc_val_ptr= &s->last_dc[i];
612
return s->last_dc[i];
615
static int get_dc(uint8_t *src, int stride, int scale)
622
sum+=src[x + y*stride];
625
return FASTDIV((sum + (scale>>1)), scale);
628
/* dir = 0: left, dir = 1: top prediction */
629
static inline int msmpeg4_pred_dc(MpegEncContext * s, int n,
630
uint16_t **dc_val_ptr, int *dir_ptr)
632
int a, b, c, wrap, pred, scale;
635
/* find prediction */
637
scale = s->y_dc_scale;
639
scale = s->c_dc_scale;
642
wrap = s->block_wrap[n];
643
dc_val= s->dc_val[0] + s->block_index[n];
649
b = dc_val[ - 1 - wrap];
652
if(s->first_slice_line && (n&2)==0 && s->msmpeg4_version<4){
656
/* XXX: the following solution consumes divisions, but it does not
657
necessitate to modify mpegvideo.c. The problem comes from the
658
fact they decided to store the quantized DC (which would lead
659
to problems if Q could vary !) */
660
#if (defined(ARCH_X86) || defined(ARCH_X86_64)) && !defined PIC
662
"movl %3, %%eax \n\t"
663
"shrl $1, %%eax \n\t"
664
"addl %%eax, %2 \n\t"
665
"addl %%eax, %1 \n\t"
666
"addl %0, %%eax \n\t"
668
"movl %%edx, %0 \n\t"
669
"movl %1, %%eax \n\t"
671
"movl %%edx, %1 \n\t"
672
"movl %2, %%eax \n\t"
674
"movl %%edx, %2 \n\t"
675
: "+b" (a), "+c" (b), "+D" (c)
676
: "g" (scale), "S" (inverse[scale])
680
/* #elif defined (ARCH_ALPHA) */
681
/* Divisions are extremely costly on Alpha; optimize the most
682
common case. But they are costly everywhere...
685
a = (a + (8 >> 1)) / 8;
686
b = (b + (8 >> 1)) / 8;
687
c = (c + (8 >> 1)) / 8;
689
a = FASTDIV((a + (scale >> 1)), scale);
690
b = FASTDIV((b + (scale >> 1)), scale);
691
c = FASTDIV((c + (scale >> 1)), scale);
694
/* XXX: WARNING: they did not choose the same test as MPEG4. This
695
is very important ! */
696
if(s->msmpeg4_version>3){
697
if(s->inter_intra_pred){
708
if (abs(a - b) < abs(b - c)) {
718
dest= s->current_picture.data[0] + (((n>>1) + 2*s->mb_y) * 8* wrap ) + ((n&1) + 2*s->mb_x) * 8;
721
dest= s->current_picture.data[n-3] + (s->mb_y * 8 * wrap) + s->mb_x * 8;
723
if(s->mb_x==0) a= (1024 + (scale>>1))/scale;
724
else a= get_dc(dest-8, wrap, scale*8);
725
if(s->mb_y==0) c= (1024 + (scale>>1))/scale;
726
else c= get_dc(dest-8*wrap, wrap, scale*8);
728
if (s->h263_aic_dir==0) {
731
}else if (s->h263_aic_dir==1) {
739
}else if (s->h263_aic_dir==2) {
753
if (abs(a - b) < abs(b - c)) {
762
if (abs(a - b) <= abs(b - c)) {
771
/* update predictor */
772
*dc_val_ptr = &dc_val[0];
778
static void msmpeg4_encode_dc(MpegEncContext * s, int level, int n, int *dir_ptr)
783
if(s->msmpeg4_version==1){
785
pred = msmpeg4v1_pred_dc(s, n, &dc_val);
787
/* update predictor */
791
pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
793
/* update predictor */
795
*dc_val = level * s->y_dc_scale;
797
*dc_val = level * s->c_dc_scale;
801
/* do the prediction */
804
if(s->msmpeg4_version<=2){
807
v2_dc_lum_table[level+256][1],
808
v2_dc_lum_table[level+256][0]);
811
v2_dc_chroma_table[level+256][1],
812
v2_dc_chroma_table[level+256][0]);
824
if (s->dc_table_index == 0) {
826
put_bits(&s->pb, ff_table0_dc_lum[code][1], ff_table0_dc_lum[code][0]);
828
put_bits(&s->pb, ff_table0_dc_chroma[code][1], ff_table0_dc_chroma[code][0]);
832
put_bits(&s->pb, ff_table1_dc_lum[code][1], ff_table1_dc_lum[code][0]);
834
put_bits(&s->pb, ff_table1_dc_chroma[code][1], ff_table1_dc_chroma[code][0]);
839
put_bits(&s->pb, 8, level);
842
put_bits(&s->pb, 1, sign);
847
/* Encoding of a block. Very similar to MPEG4 except for a different
848
escape coding (same as H263) and more vlc tables.
850
static inline void msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n)
852
int level, run, last, i, j, last_index;
853
int last_non_zero, sign, slevel;
854
int code, run_diff, dc_pred_dir;
856
const uint8_t *scantable;
859
msmpeg4_encode_dc(s, block[0], n, &dc_pred_dir);
862
rl = &rl_table[s->rl_table_index];
864
rl = &rl_table[3 + s->rl_chroma_table_index];
867
scantable= s->intra_scantable.permutated;
870
rl = &rl_table[3 + s->rl_table_index];
871
if(s->msmpeg4_version<=2)
875
scantable= s->inter_scantable.permutated;
878
/* recalculate block_last_index for M$ wmv1 */
879
if(s->msmpeg4_version>=4 && s->block_last_index[n]>0){
880
for(last_index=63; last_index>=0; last_index--){
881
if(block[scantable[last_index]]) break;
883
s->block_last_index[n]= last_index;
885
last_index = s->block_last_index[n];
887
last_non_zero = i - 1;
888
for (; i <= last_index; i++) {
892
run = i - last_non_zero - 1;
893
last = (i == last_index);
901
if(level<=MAX_LEVEL && run<=MAX_RUN){
902
s->ac_stats[s->mb_intra][n>3][level][run][last]++;
906
s->ac_stats[s->mb_intra][n>3][40][63][0]++; //esc3 like
908
code = get_rl_index(rl, last, run, level);
909
put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
913
level1 = level - rl->max_level[last][run];
916
code = get_rl_index(rl, last, run, level1);
919
put_bits(&s->pb, 1, 0);
920
if (level > MAX_LEVEL)
922
run1 = run - rl->max_run[last][level] - run_diff;
925
code = get_rl_index(rl, last, run1, level);
929
put_bits(&s->pb, 1, 0);
930
put_bits(&s->pb, 1, last);
931
if(s->msmpeg4_version>=4){
932
if(s->esc3_level_length==0){
933
s->esc3_level_length=8;
934
s->esc3_run_length= 6;
936
put_bits(&s->pb, 6, 3);
938
put_bits(&s->pb, 8, 3);
940
put_bits(&s->pb, s->esc3_run_length, run);
941
put_bits(&s->pb, 1, sign);
942
put_bits(&s->pb, s->esc3_level_length, level);
944
put_bits(&s->pb, 6, run);
945
put_bits(&s->pb, 8, slevel & 0xff);
949
put_bits(&s->pb, 1, 1);
950
put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
951
put_bits(&s->pb, 1, sign);
955
put_bits(&s->pb, 1, 1);
956
put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
957
put_bits(&s->pb, 1, sign);
960
put_bits(&s->pb, 1, sign);
967
/****************************************/
970
static VLC mb_non_intra_vlc[4];
971
VLC ff_msmp4_mb_i_vlc;
972
VLC ff_msmp4_dc_luma_vlc[2];
973
VLC ff_msmp4_dc_chroma_vlc[2];
974
static VLC v2_dc_lum_vlc;
975
static VLC v2_dc_chroma_vlc;
977
static VLC v2_intra_cbpc_vlc;
978
static VLC v2_mb_type_vlc;
979
static VLC v2_mv_vlc;
980
static VLC v1_intra_cbpc_vlc;
981
static VLC v1_inter_cbpc_vlc;
982
static VLC inter_intra_vlc;
984
/* this table is practically identical to the one from h263 except that its inverted */
985
static void init_h263_dc_for_msmpeg4(void)
987
int level, uni_code, uni_len;
989
for(level=-256; level<256; level++){
991
/* find number of bits */
1000
l= (-level) ^ ((1 << size) - 1);
1004
/* luminance h263 */
1005
uni_code= DCtab_lum[size][0];
1006
uni_len = DCtab_lum[size][1];
1007
uni_code ^= (1<<uni_len)-1; //M$ doesnt like compatibility
1010
uni_code<<=size; uni_code|=l;
1013
uni_code<<=1; uni_code|=1;
1017
v2_dc_lum_table[level+256][0]= uni_code;
1018
v2_dc_lum_table[level+256][1]= uni_len;
1020
/* chrominance h263 */
1021
uni_code= DCtab_chrom[size][0];
1022
uni_len = DCtab_chrom[size][1];
1023
uni_code ^= (1<<uni_len)-1; //M$ doesnt like compatibility
1026
uni_code<<=size; uni_code|=l;
1029
uni_code<<=1; uni_code|=1;
1033
v2_dc_chroma_table[level+256][0]= uni_code;
1034
v2_dc_chroma_table[level+256][1]= uni_len;
1039
/* init all vlc decoding tables */
1040
int ff_msmpeg4_decode_init(MpegEncContext *s)
1042
static int done = 0;
1051
for(i=0;i<NB_RL_TABLES;i++) {
1052
init_rl(&rl_table[i], 1);
1053
init_vlc_rl(&rl_table[i], 1);
1057
init_vlc(&mv->vlc, MV_VLC_BITS, mv->n + 1,
1058
mv->table_mv_bits, 1, 1,
1059
mv->table_mv_code, 2, 2, 1);
1062
init_vlc(&ff_msmp4_dc_luma_vlc[0], DC_VLC_BITS, 120,
1063
&ff_table0_dc_lum[0][1], 8, 4,
1064
&ff_table0_dc_lum[0][0], 8, 4, 1);
1065
init_vlc(&ff_msmp4_dc_chroma_vlc[0], DC_VLC_BITS, 120,
1066
&ff_table0_dc_chroma[0][1], 8, 4,
1067
&ff_table0_dc_chroma[0][0], 8, 4, 1);
1068
init_vlc(&ff_msmp4_dc_luma_vlc[1], DC_VLC_BITS, 120,
1069
&ff_table1_dc_lum[0][1], 8, 4,
1070
&ff_table1_dc_lum[0][0], 8, 4, 1);
1071
init_vlc(&ff_msmp4_dc_chroma_vlc[1], DC_VLC_BITS, 120,
1072
&ff_table1_dc_chroma[0][1], 8, 4,
1073
&ff_table1_dc_chroma[0][0], 8, 4, 1);
1075
init_vlc(&v2_dc_lum_vlc, DC_VLC_BITS, 512,
1076
&v2_dc_lum_table[0][1], 8, 4,
1077
&v2_dc_lum_table[0][0], 8, 4, 1);
1078
init_vlc(&v2_dc_chroma_vlc, DC_VLC_BITS, 512,
1079
&v2_dc_chroma_table[0][1], 8, 4,
1080
&v2_dc_chroma_table[0][0], 8, 4, 1);
1082
init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
1083
&cbpy_tab[0][1], 2, 1,
1084
&cbpy_tab[0][0], 2, 1, 1);
1085
init_vlc(&v2_intra_cbpc_vlc, V2_INTRA_CBPC_VLC_BITS, 4,
1086
&v2_intra_cbpc[0][1], 2, 1,
1087
&v2_intra_cbpc[0][0], 2, 1, 1);
1088
init_vlc(&v2_mb_type_vlc, V2_MB_TYPE_VLC_BITS, 8,
1089
&v2_mb_type[0][1], 2, 1,
1090
&v2_mb_type[0][0], 2, 1, 1);
1091
init_vlc(&v2_mv_vlc, V2_MV_VLC_BITS, 33,
1093
&mvtab[0][0], 2, 1, 1);
1096
init_vlc(&mb_non_intra_vlc[i], MB_NON_INTRA_VLC_BITS, 128,
1097
&wmv2_inter_table[i][0][1], 8, 4,
1098
&wmv2_inter_table[i][0][0], 8, 4, 1); //FIXME name?
1101
init_vlc(&ff_msmp4_mb_i_vlc, MB_INTRA_VLC_BITS, 64,
1102
&ff_msmp4_mb_i_table[0][1], 4, 2,
1103
&ff_msmp4_mb_i_table[0][0], 4, 2, 1);
1105
init_vlc(&v1_intra_cbpc_vlc, V1_INTRA_CBPC_VLC_BITS, 8,
1106
intra_MCBPC_bits, 1, 1,
1107
intra_MCBPC_code, 1, 1, 1);
1108
init_vlc(&v1_inter_cbpc_vlc, V1_INTER_CBPC_VLC_BITS, 25,
1109
inter_MCBPC_bits, 1, 1,
1110
inter_MCBPC_code, 1, 1, 1);
1112
init_vlc(&inter_intra_vlc, INTER_INTRA_VLC_BITS, 4,
1113
&table_inter_intra[0][1], 2, 1,
1114
&table_inter_intra[0][0], 2, 1, 1);
1117
switch(s->msmpeg4_version){
1120
s->decode_mb= msmpeg4v12_decode_mb;
1124
s->decode_mb= msmpeg4v34_decode_mb;
1127
s->decode_mb= wmv2_decode_mb;
1129
//FIXME + TODO VC1 decode mb
1133
s->slice_height= s->mb_height; //to avoid 1/0 if the first frame isnt a keyframe
1138
int msmpeg4_decode_picture_header(MpegEncContext * s)
1145
for(i=0; i<s->gb.size_in_bits; i++)
1146
av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
1147
// get_bits1(&s->gb);
1148
av_log(s->avctx, AV_LOG_DEBUG, "END\n");
1153
if(s->msmpeg4_version==1){
1154
int start_code, num;
1155
start_code = (get_bits(&s->gb, 16)<<16) | get_bits(&s->gb, 16);
1156
if(start_code!=0x00000100){
1157
av_log(s->avctx, AV_LOG_ERROR, "invalid startcode\n");
1161
num= get_bits(&s->gb, 5); // frame number */
1164
s->pict_type = get_bits(&s->gb, 2) + 1;
1165
if (s->pict_type != I_TYPE &&
1166
s->pict_type != P_TYPE){
1167
av_log(s->avctx, AV_LOG_ERROR, "invalid picture type\n");
1173
if(s->pict_type == I_TYPE) had_i=1;
1174
if(!had_i) return -1;
1177
s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
1179
av_log(s->avctx, AV_LOG_ERROR, "invalid qscale\n");
1183
if (s->pict_type == I_TYPE) {
1184
code = get_bits(&s->gb, 5);
1185
if(s->msmpeg4_version==1){
1186
if(code==0 || code>s->mb_height){
1187
av_log(s->avctx, AV_LOG_ERROR, "invalid slice height %d\n", code);
1191
s->slice_height = code;
1193
/* 0x17: one slice, 0x18: two slices, ... */
1195
av_log(s->avctx, AV_LOG_ERROR, "error, slice code was %X\n", code);
1199
s->slice_height = s->mb_height / (code - 0x16);
1202
switch(s->msmpeg4_version){
1205
s->rl_chroma_table_index = 2;
1206
s->rl_table_index = 2;
1208
s->dc_table_index = 0; //not used
1211
s->rl_chroma_table_index = decode012(&s->gb);
1212
s->rl_table_index = decode012(&s->gb);
1214
s->dc_table_index = get_bits1(&s->gb);
1217
msmpeg4_decode_ext_header(s, (2+5+5+17+7)/8);
1219
if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
1220
else s->per_mb_rl_table= 0;
1222
if(!s->per_mb_rl_table){
1223
s->rl_chroma_table_index = decode012(&s->gb);
1224
s->rl_table_index = decode012(&s->gb);
1227
s->dc_table_index = get_bits1(&s->gb);
1228
s->inter_intra_pred= 0;
1232
if(s->avctx->debug&FF_DEBUG_PICT_INFO)
1233
av_log(s->avctx, AV_LOG_DEBUG, "qscale:%d rlc:%d rl:%d dc:%d mbrl:%d slice:%d \n",
1235
s->rl_chroma_table_index,
1241
switch(s->msmpeg4_version){
1244
if(s->msmpeg4_version==1)
1245
s->use_skip_mb_code = 1;
1247
s->use_skip_mb_code = get_bits1(&s->gb);
1248
s->rl_table_index = 2;
1249
s->rl_chroma_table_index = s->rl_table_index;
1250
s->dc_table_index = 0; //not used
1251
s->mv_table_index = 0;
1254
s->use_skip_mb_code = get_bits1(&s->gb);
1255
s->rl_table_index = decode012(&s->gb);
1256
s->rl_chroma_table_index = s->rl_table_index;
1258
s->dc_table_index = get_bits1(&s->gb);
1260
s->mv_table_index = get_bits1(&s->gb);
1263
s->use_skip_mb_code = get_bits1(&s->gb);
1265
if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
1266
else s->per_mb_rl_table= 0;
1268
if(!s->per_mb_rl_table){
1269
s->rl_table_index = decode012(&s->gb);
1270
s->rl_chroma_table_index = s->rl_table_index;
1273
s->dc_table_index = get_bits1(&s->gb);
1275
s->mv_table_index = get_bits1(&s->gb);
1276
s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE);
1280
if(s->avctx->debug&FF_DEBUG_PICT_INFO)
1281
av_log(s->avctx, AV_LOG_DEBUG, "skip:%d rl:%d rlc:%d dc:%d mv:%d mbrl:%d qp:%d \n",
1282
s->use_skip_mb_code,
1284
s->rl_chroma_table_index,
1290
if(s->flipflop_rounding){
1291
s->no_rounding ^= 1;
1296
//printf("%d %d %d %d %d\n", s->pict_type, s->bit_rate, s->inter_intra_pred, s->width, s->height);
1298
s->esc3_level_length= 0;
1299
s->esc3_run_length= 0;
1302
av_log(s->avctx, AV_LOG_DEBUG, "*****frame %d:\n", frame_count++);
1307
int msmpeg4_decode_ext_header(MpegEncContext * s, int buf_size)
1309
int left= buf_size*8 - get_bits_count(&s->gb);
1310
int length= s->msmpeg4_version>=3 ? 17 : 16;
1311
/* the alt_bitstream reader could read over the end so we need to check it */
1312
if(left>=length && left<length+8)
1316
fps= get_bits(&s->gb, 5);
1317
s->bit_rate= get_bits(&s->gb, 11)*1024;
1318
if(s->msmpeg4_version>=3)
1319
s->flipflop_rounding= get_bits1(&s->gb);
1321
s->flipflop_rounding= 0;
1323
// printf("fps:%2d bps:%2d roundingType:%1d\n", fps, s->bit_rate/1024, s->flipflop_rounding);
1325
else if(left<length+8)
1327
s->flipflop_rounding= 0;
1328
if(s->msmpeg4_version != 2)
1329
av_log(s->avctx, AV_LOG_ERROR, "ext header missing, %d left\n", left);
1333
av_log(s->avctx, AV_LOG_ERROR, "I frame too long, ignoring ext header\n");
1339
static inline void msmpeg4_memsetw(short *tab, int val, int n)
1346
static void msmpeg4v2_encode_motion(MpegEncContext * s, int val)
1348
int range, bit_size, sign, code, bits;
1353
put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
1355
bit_size = s->f_code - 1;
1356
range = 1 << bit_size;
1369
code = (val >> bit_size) + 1;
1370
bits = val & (range - 1);
1372
put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
1374
put_bits(&s->pb, bit_size, bits);
1379
/* this is identical to h263 except that its range is multiplied by 2 */
1380
static int msmpeg4v2_decode_motion(MpegEncContext * s, int pred, int f_code)
1382
int code, val, sign, shift;
1384
code = get_vlc2(&s->gb, v2_mv_vlc.table, V2_MV_VLC_BITS, 2);
1385
// printf("MV code %d at %d %d pred: %d\n", code, s->mb_x,s->mb_y, pred);
1391
sign = get_bits1(&s->gb);
1395
val = (val - 1) << shift;
1396
val |= get_bits(&s->gb, shift);
1411
static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1415
if (s->pict_type == P_TYPE) {
1416
if (s->use_skip_mb_code) {
1417
if (get_bits1(&s->gb)) {
1421
s->block_last_index[i] = -1;
1422
s->mv_dir = MV_DIR_FORWARD;
1423
s->mv_type = MV_TYPE_16X16;
1431
if(s->msmpeg4_version==2)
1432
code = get_vlc2(&s->gb, v2_mb_type_vlc.table, V2_MB_TYPE_VLC_BITS, 1);
1434
code = get_vlc2(&s->gb, v1_inter_cbpc_vlc.table, V1_INTER_CBPC_VLC_BITS, 3);
1435
if(code<0 || code>7){
1436
av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", code, s->mb_x, s->mb_y);
1440
s->mb_intra = code >>2;
1445
if(s->msmpeg4_version==2)
1446
cbp= get_vlc2(&s->gb, v2_intra_cbpc_vlc.table, V2_INTRA_CBPC_VLC_BITS, 1);
1448
cbp= get_vlc2(&s->gb, v1_intra_cbpc_vlc.table, V1_INTRA_CBPC_VLC_BITS, 1);
1450
av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
1458
cbpy= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
1460
av_log(s->avctx, AV_LOG_ERROR, "cbpy %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
1465
if(s->msmpeg4_version==1 || (cbp&3) != 3) cbp^= 0x3C;
1467
h263_pred_motion(s, 0, 0, &mx, &my);
1468
mx= msmpeg4v2_decode_motion(s, mx, 1);
1469
my= msmpeg4v2_decode_motion(s, my, 1);
1471
s->mv_dir = MV_DIR_FORWARD;
1472
s->mv_type = MV_TYPE_16X16;
1473
s->mv[0][0][0] = mx;
1474
s->mv[0][0][1] = my;
1476
if(s->msmpeg4_version==2){
1477
s->ac_pred = get_bits1(&s->gb);
1478
cbp|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
1481
cbp|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
1482
if(s->pict_type==P_TYPE) cbp^=0x3C;
1486
s->dsp.clear_blocks(s->block[0]);
1487
for (i = 0; i < 6; i++) {
1488
if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
1490
av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1497
static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1501
uint32_t * const mb_type_ptr= &s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ];
1503
if (s->pict_type == P_TYPE) {
1504
if (s->use_skip_mb_code) {
1505
if (get_bits1(&s->gb)) {
1509
s->block_last_index[i] = -1;
1510
s->mv_dir = MV_DIR_FORWARD;
1511
s->mv_type = MV_TYPE_16X16;
1515
*mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
1521
code = get_vlc2(&s->gb, mb_non_intra_vlc[DEFAULT_INTER_INDEX].table, MB_NON_INTRA_VLC_BITS, 3);
1524
//s->mb_intra = (code & 0x40) ? 0 : 1;
1525
s->mb_intra = (~code & 0x40) >> 6;
1530
code = get_vlc2(&s->gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
1533
/* predict coded block pattern */
1536
int val = ((code >> (5 - i)) & 1);
1538
int pred = coded_block_pred(s, i, &coded_val);
1542
cbp |= val << (5 - i);
1548
//printf("P at %d %d\n", s->mb_x, s->mb_y);
1549
if(s->per_mb_rl_table && cbp){
1550
s->rl_table_index = decode012(&s->gb);
1551
s->rl_chroma_table_index = s->rl_table_index;
1553
h263_pred_motion(s, 0, 0, &mx, &my);
1554
if (msmpeg4_decode_motion(s, &mx, &my) < 0)
1556
s->mv_dir = MV_DIR_FORWARD;
1557
s->mv_type = MV_TYPE_16X16;
1558
s->mv[0][0][0] = mx;
1559
s->mv[0][0][1] = my;
1560
*mb_type_ptr = MB_TYPE_L0 | MB_TYPE_16x16;
1562
//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));
1563
s->ac_pred = get_bits1(&s->gb);
1564
*mb_type_ptr = MB_TYPE_INTRA;
1565
if(s->inter_intra_pred){
1566
s->h263_aic_dir= get_vlc2(&s->gb, inter_intra_vlc.table, INTER_INTRA_VLC_BITS, 1);
1567
// printf("%d%d %d %d/", s->ac_pred, s->h263_aic_dir, s->mb_x, s->mb_y);
1569
if(s->per_mb_rl_table && cbp){
1570
s->rl_table_index = decode012(&s->gb);
1571
s->rl_chroma_table_index = s->rl_table_index;
1575
s->dsp.clear_blocks(s->block[0]);
1576
for (i = 0; i < 6; i++) {
1577
if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
1579
av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1586
//#define ERROR_DETAILS
1587
static inline int msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
1588
int n, int coded, const uint8_t *scan_table)
1590
int level, i, last, run, run_diff;
1593
RL_VLC_ELEM *rl_vlc;
1601
level = msmpeg4_decode_dc(s, n, &dc_pred_dir);
1604
av_log(s->avctx, AV_LOG_ERROR, "dc overflow- block: %d qscale: %d//\n", n, s->qscale);
1605
if(s->inter_intra_pred) level=0;
1609
rl = &rl_table[s->rl_table_index];
1610
if(level > 256*s->y_dc_scale){
1611
av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ L qscale: %d//\n", s->qscale);
1612
if(!s->inter_intra_pred) return -1;
1615
rl = &rl_table[3 + s->rl_chroma_table_index];
1616
if(level > 256*s->c_dc_scale){
1617
av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ C qscale: %d//\n", s->qscale);
1618
if(!s->inter_intra_pred) return -1;
1629
if (dc_pred_dir == 0)
1630
scan_table = s->intra_v_scantable.permutated; /* left */
1632
scan_table = s->intra_h_scantable.permutated; /* top */
1634
scan_table = s->intra_scantable.permutated;
1636
rl_vlc= rl->rl_vlc[0];
1638
qmul = s->qscale << 1;
1639
qadd = (s->qscale - 1) | 1;
1641
rl = &rl_table[3 + s->rl_table_index];
1643
if(s->msmpeg4_version==2)
1649
s->block_last_index[n] = i;
1653
scan_table = s->inter_scantable.permutated;
1654
rl_vlc= rl->rl_vlc[s->qscale];
1657
OPEN_READER(re, &s->gb);
1659
UPDATE_CACHE(re, &s->gb);
1660
GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
1663
cache= GET_CACHE(re, &s->gb);
1665
if (s->msmpeg4_version==1 || (cache&0x80000000)==0) {
1666
if (s->msmpeg4_version==1 || (cache&0x40000000)==0) {
1668
if(s->msmpeg4_version!=1) LAST_SKIP_BITS(re, &s->gb, 2);
1669
UPDATE_CACHE(re, &s->gb);
1670
if(s->msmpeg4_version<=3){
1671
last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
1672
run= SHOW_UBITS(re, &s->gb, 6); SKIP_CACHE(re, &s->gb, 6);
1673
level= SHOW_SBITS(re, &s->gb, 8); LAST_SKIP_CACHE(re, &s->gb, 8);
1674
SKIP_COUNTER(re, &s->gb, 1+6+8);
1677
last= SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1);
1678
if(!s->esc3_level_length){
1680
//printf("ESC-3 %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y);
1682
ll= SHOW_UBITS(re, &s->gb, 3); SKIP_BITS(re, &s->gb, 3);
1684
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");
1685
SKIP_BITS(re, &s->gb, 1);
1690
while(ll<8 && SHOW_UBITS(re, &s->gb, 1)==0){
1692
SKIP_BITS(re, &s->gb, 1);
1694
if(ll<8) SKIP_BITS(re, &s->gb, 1);
1697
s->esc3_level_length= ll;
1698
s->esc3_run_length= SHOW_UBITS(re, &s->gb, 2) + 3; SKIP_BITS(re, &s->gb, 2);
1699
//printf("level length:%d, run length: %d\n", ll, s->esc3_run_length);
1700
UPDATE_CACHE(re, &s->gb);
1702
run= SHOW_UBITS(re, &s->gb, s->esc3_run_length);
1703
SKIP_BITS(re, &s->gb, s->esc3_run_length);
1705
sign= SHOW_UBITS(re, &s->gb, 1);
1706
SKIP_BITS(re, &s->gb, 1);
1708
level= SHOW_UBITS(re, &s->gb, s->esc3_level_length);
1709
SKIP_BITS(re, &s->gb, s->esc3_level_length);
1710
if(sign) level= -level;
1712
//printf("level: %d, run: %d at %d %d\n", level, run, s->mb_x, s->mb_y);
1713
#if 0 // waste of time / this will detect very few errors
1715
const int abs_level= ABS(level);
1716
const int run1= run - rl->max_run[last][abs_level] - run_diff;
1717
if(abs_level<=MAX_LEVEL && run<=MAX_RUN){
1718
if(abs_level <= rl->max_level[last][run]){
1719
av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n");
1720
return DECODING_AC_LOST;
1722
if(abs_level <= rl->max_level[last][run]*2){
1723
av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 1 encoding possible\n");
1724
return DECODING_AC_LOST;
1726
if(run1>=0 && abs_level <= rl->max_level[last][run1]){
1727
av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 2 encoding possible\n");
1728
return DECODING_AC_LOST;
1733
//level = level * qmul + (level>0) * qadd - (level<=0) * qadd ;
1734
if (level>0) level= level * qmul + qadd;
1735
else level= level * qmul - qadd;
1736
#if 0 // waste of time too :(
1737
if(level>2048 || level<-2048){
1738
av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc\n");
1739
return DECODING_AC_LOST;
1744
#ifdef ERROR_DETAILS
1746
av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC3 level=%d\n", level);
1747
else if((i>62 && i<192) || i>192+63)
1748
av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC3 i=%d run=%d level=%d\n", i, run, level);
1752
#if MIN_CACHE_BITS < 23
1753
LAST_SKIP_BITS(re, &s->gb, 2);
1754
UPDATE_CACHE(re, &s->gb);
1756
SKIP_BITS(re, &s->gb, 2);
1758
GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
1759
i+= run + rl->max_run[run>>7][level/qmul] + run_diff; //FIXME opt indexing
1760
level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1761
LAST_SKIP_BITS(re, &s->gb, 1);
1762
#ifdef ERROR_DETAILS
1764
av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC2 level=%d\n", level);
1765
else if((i>62 && i<192) || i>192+63)
1766
av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC2 i=%d run=%d level=%d\n", i, run, level);
1771
#if MIN_CACHE_BITS < 22
1772
LAST_SKIP_BITS(re, &s->gb, 1);
1773
UPDATE_CACHE(re, &s->gb);
1775
SKIP_BITS(re, &s->gb, 1);
1777
GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
1779
level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
1780
level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1781
LAST_SKIP_BITS(re, &s->gb, 1);
1782
#ifdef ERROR_DETAILS
1784
av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC1 level=%d\n", level);
1785
else if((i>62 && i<192) || i>192+63)
1786
av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC1 i=%d run=%d level=%d\n", i, run, level);
1791
level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1792
LAST_SKIP_BITS(re, &s->gb, 1);
1793
#ifdef ERROR_DETAILS
1795
av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code level=%d\n", level);
1796
else if((i>62 && i<192) || i>192+63)
1797
av_log(s->avctx, AV_LOG_ERROR, "run overflow i=%d run=%d level=%d\n", i, run, level);
1803
const int left= s->gb.size_in_bits - get_bits_count(&s->gb);
1804
if(((i+192 == 64 && level/qmul==-1) || s->error_resilience<=1) && left>=0){
1805
av_log(s->avctx, AV_LOG_ERROR, "ignoring overflow at %d %d\n", s->mb_x, s->mb_y);
1808
av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1813
block[scan_table[i]] = level;
1817
block[scan_table[i]] = level;
1819
CLOSE_READER(re, &s->gb);
1823
mpeg4_pred_ac(s, block, n, dc_pred_dir);
1825
i = 63; /* XXX: not optimal */
1828
if(s->msmpeg4_version>=4 && i>0) i=63; //FIXME/XXX optimize
1829
s->block_last_index[n] = i;
1834
static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
1838
if(s->msmpeg4_version<=2){
1840
level = get_vlc2(&s->gb, v2_dc_lum_vlc.table, DC_VLC_BITS, 3);
1842
level = get_vlc2(&s->gb, v2_dc_chroma_vlc.table, DC_VLC_BITS, 3);
1847
}else{ //FIXME optimize use unified tables & index
1849
level = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1851
level = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1854
av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
1858
if (level == DC_MAX) {
1859
level = get_bits(&s->gb, 8);
1860
if (get_bits1(&s->gb))
1862
} else if (level != 0) {
1863
if (get_bits1(&s->gb))
1868
if(s->msmpeg4_version==1){
1870
pred = msmpeg4v1_pred_dc(s, n, &dc_val);
1873
/* update predictor */
1877
pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
1880
/* update predictor */
1882
*dc_val = level * s->y_dc_scale;
1884
*dc_val = level * s->c_dc_scale;
1891
static int msmpeg4_decode_motion(MpegEncContext * s,
1892
int *mx_ptr, int *my_ptr)
1897
mv = &mv_tables[s->mv_table_index];
1899
code = get_vlc2(&s->gb, mv->vlc.table, MV_VLC_BITS, 2);
1901
av_log(s->avctx, AV_LOG_ERROR, "illegal MV code at %d %d\n", s->mb_x, s->mb_y);
1904
if (code == mv->n) {
1905
//printf("MV ESC %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y);
1906
mx = get_bits(&s->gb, 6);
1907
my = get_bits(&s->gb, 6);
1909
mx = mv->table_mvx[code];
1910
my = mv->table_mvy[code];
1915
/* WARNING : they do not do exactly modulo encoding */
1930
/* cleanest way to support it
1931
* there is too much shared between versions so that we cant have 1 file per version & 1 common
1932
* as allmost everything would be in the common file
added
removed
avidemux/ADM_lavcodec/msmpeg4.c
