← Back to branch summary

~siretart/xine-lib/ubuntu

« back to all changes in this revision

Viewing changes to src/libffmpeg/libavcodec/msmpeg4.c

  • Committer: Bazaar Package Importer
  • Author(s): Martin Pitt
  • Date: 2005-12-15 13:13:45 UTC
  • mfrom: (0.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20051215131345-8n4osv1j7fy9c1s1
* SECURITY UPDATE: Fix arbitrary code execution with crafted PNG images in
  embedded ffmpeg copy.
* src/libffmpeg/libavcodec/utils.c, avcodec_default_get_buffer(): Apply
  upstream patch to fix buffer overflow on decoding of small PIX_FMT_PAL8
  PNG files.
* References:
  CVE-2005-4048
  http://mplayerhq.hu/pipermail/ffmpeg-devel/2005-November/005333.html
  http://www1.mplayerhq.hu/cgi-bin/cvsweb.cgi/ffmpeg/libavcodec/
  utils.c.diff?r1=1.161&r2=1.162&cvsroot=FFMpeg

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/libffmpeg/libavcodec/msmpeg4.c
59
59
static uint32_t v2_dc_lum_table[512][2];
60
60
static uint32_t v2_dc_chroma_table[512][2];
61
61
 
 
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);
62
65
static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr);
63
66
static int msmpeg4_decode_motion(MpegEncContext * s, 
64
67
                                 int *mx_ptr, int *my_ptr);
67
70
static inline void msmpeg4_memsetw(short *tab, int val, int n);
68
71
#ifdef CONFIG_ENCODERS
69
72
static int get_size_of_code(MpegEncContext * s, RLTable *rl, int last, int run, int level, int intra);
70
 
static void msmpeg4_encode_dc(MpegEncContext * s, int level, int n, int *dir_ptr);
71
73
#endif //CONFIG_ENCODERS
72
74
static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64]);
73
75
static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64]);
74
76
static int wmv2_decode_mb(MpegEncContext *s, DCTELEM block[6][64]);
75
77
 
 
78
/* vc9 externs */
 
79
extern uint8_t wmv3_dc_scale_table[32];
76
80
 
77
81
#ifdef DEBUG
78
82
int intra_count = 0;
173
177
        s->y_dc_scale_table= wmv1_y_dc_scale_table;
174
178
        s->c_dc_scale_table= wmv1_c_dc_scale_table;
175
179
        break;
 
180
#if defined(CONFIG_WMV3_DECODER)||defined(CONFIG_VC9_DECODER)
 
181
    case 6:
 
182
        s->y_dc_scale_table= wmv3_dc_scale_table;
 
183
        s->c_dc_scale_table= wmv3_dc_scale_table;
 
184
        break;
 
185
#endif
 
186
 
176
187
    }
177
188
 
178
189
    
237
248
        init_mv_table(&mv_tables[0]);
238
249
        init_mv_table(&mv_tables[1]);
239
250
        for(i=0;i<NB_RL_TABLES;i++)
240
 
            init_rl(&rl_table[i]);
 
251
            init_rl(&rl_table[i], 1);
241
252
 
242
253
        for(i=0; i<NB_RL_TABLES; i++){
243
254
            int level;
429
440
 
430
441
void msmpeg4_encode_ext_header(MpegEncContext * s)
431
442
{
432
 
        put_bits(&s->pb, 5, s->avctx->frame_rate / s->avctx->frame_rate_base); //yes 29.97 -> 29
 
443
        put_bits(&s->pb, 5, s->avctx->time_base.den / s->avctx->time_base.num); //yes 29.97 -> 29
433
444
 
434
445
        put_bits(&s->pb, 11, FFMIN(s->bit_rate/1024, 2047));
435
446
 
522
533
    }
523
534
}
524
535
 
525
 
/* Encoding of a block. Very similar to MPEG4 except for a different
526
 
   escape coding (same as H263) and more vlc tables.
527
 
 */
528
 
static inline void msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n)
529
 
{
530
 
    int level, run, last, i, j, last_index;
531
 
    int last_non_zero, sign, slevel;
532
 
    int code, run_diff, dc_pred_dir;
533
 
    const RLTable *rl;
534
 
    const uint8_t *scantable;
535
 
 
536
 
    if (s->mb_intra) {
537
 
        set_stat(ST_DC);
538
 
        msmpeg4_encode_dc(s, block[0], n, &dc_pred_dir);
539
 
        i = 1;
540
 
        if (n < 4) {
541
 
            rl = &rl_table[s->rl_table_index];
542
 
        } else {
543
 
            rl = &rl_table[3 + s->rl_chroma_table_index];
544
 
        }
545
 
        run_diff = 0;
546
 
        scantable= s->intra_scantable.permutated;
547
 
        set_stat(ST_INTRA_AC);
548
 
    } else {
549
 
        i = 0;
550
 
        rl = &rl_table[3 + s->rl_table_index];
551
 
        if(s->msmpeg4_version<=2)
552
 
            run_diff = 0;
553
 
        else
554
 
            run_diff = 1;
555
 
        scantable= s->inter_scantable.permutated;
556
 
        set_stat(ST_INTER_AC);
557
 
    }
558
 
 
559
 
    /* recalculate block_last_index for M$ wmv1 */
560
 
    if(s->msmpeg4_version>=4 && s->block_last_index[n]>0){
561
 
        for(last_index=63; last_index>=0; last_index--){
562
 
            if(block[scantable[last_index]]) break;
563
 
        }
564
 
        s->block_last_index[n]= last_index;
565
 
    }else
566
 
        last_index = s->block_last_index[n];
567
 
    /* AC coefs */
568
 
    last_non_zero = i - 1;
569
 
    for (; i <= last_index; i++) {
570
 
        j = scantable[i];
571
 
        level = block[j];
572
 
        if (level) {
573
 
            run = i - last_non_zero - 1;
574
 
            last = (i == last_index);
575
 
            sign = 0;
576
 
            slevel = level;
577
 
            if (level < 0) {
578
 
                sign = 1;
579
 
                level = -level;
580
 
            }
581
 
 
582
 
            if(level<=MAX_LEVEL && run<=MAX_RUN){
583
 
                s->ac_stats[s->mb_intra][n>3][level][run][last]++;
584
 
            }
585
 
#if 0
586
 
else
587
 
    s->ac_stats[s->mb_intra][n>3][40][63][0]++; //esc3 like
588
 
#endif
589
 
            code = get_rl_index(rl, last, run, level);
590
 
            put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
591
 
            if (code == rl->n) {
592
 
                int level1, run1;
593
 
 
594
 
                level1 = level - rl->max_level[last][run];
595
 
                if (level1 < 1) 
596
 
                    goto esc2;
597
 
                code = get_rl_index(rl, last, run, level1);
598
 
                if (code == rl->n) {
599
 
                esc2:
600
 
                    put_bits(&s->pb, 1, 0);
601
 
                    if (level > MAX_LEVEL)
602
 
                        goto esc3;
603
 
                    run1 = run - rl->max_run[last][level] - run_diff;
604
 
                    if (run1 < 0)
605
 
                        goto esc3;
606
 
                    code = get_rl_index(rl, last, run1, level);
607
 
                    if (code == rl->n) {
608
 
                    esc3:
609
 
                        /* third escape */
610
 
                        put_bits(&s->pb, 1, 0);
611
 
                        put_bits(&s->pb, 1, last);
612
 
                        if(s->msmpeg4_version>=4){
613
 
                            if(s->esc3_level_length==0){
614
 
                                s->esc3_level_length=8;
615
 
                                s->esc3_run_length= 6;
616
 
                                if(s->qscale<8)
617
 
                                    put_bits(&s->pb, 6, 3);
618
 
                                else
619
 
                                    put_bits(&s->pb, 8, 3);
620
 
                            }
621
 
                            put_bits(&s->pb, s->esc3_run_length, run);
622
 
                            put_bits(&s->pb, 1, sign);
623
 
                            put_bits(&s->pb, s->esc3_level_length, level);
624
 
                        }else{
625
 
                            put_bits(&s->pb, 6, run);
626
 
                            put_bits(&s->pb, 8, slevel & 0xff);
627
 
                        }
628
 
                    } else {
629
 
                        /* second escape */
630
 
                        put_bits(&s->pb, 1, 1);
631
 
                        put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
632
 
                        put_bits(&s->pb, 1, sign);
633
 
                    }
634
 
                } else {
635
 
                    /* first escape */
636
 
                    put_bits(&s->pb, 1, 1);
637
 
                    put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
638
 
                    put_bits(&s->pb, 1, sign);
639
 
                }
640
 
            } else {
641
 
                put_bits(&s->pb, 1, sign);
642
 
            }
643
 
            last_non_zero = i;
644
 
        }
645
 
    }
646
 
}
647
 
 
648
536
void msmpeg4_encode_mb(MpegEncContext * s, 
649
537
                       DCTELEM block[6][64],
650
538
                       int motion_x, int motion_y)
750
638
            if (s->pict_type == I_TYPE) {
751
639
                set_stat(ST_INTRA_MB);
752
640
                put_bits(&s->pb, 
753
 
                         table_mb_intra[coded_cbp][1], table_mb_intra[coded_cbp][0]);
 
641
                         ff_msmp4_mb_i_table[coded_cbp][1], ff_msmp4_mb_i_table[coded_cbp][0]);
754
642
            } else {
755
643
                if (s->use_skip_mb_code)
756
644
                    put_bits(&s->pb, 1, 0);     /* mb coded */
837
725
       necessitate to modify mpegvideo.c. The problem comes from the
838
726
       fact they decided to store the quantized DC (which would lead
839
727
       to problems if Q could vary !) */
840
 
#if defined ARCH_X86 && !defined PIC
 
728
#if (defined(ARCH_X86) || defined(ARCH_X86_64)) && !defined PIC
841
729
    asm volatile(
842
730
        "movl %3, %%eax         \n\t"
843
731
        "shrl $1, %%eax         \n\t"
1003
891
 
1004
892
        if (s->dc_table_index == 0) {
1005
893
            if (n < 4) {
1006
 
                put_bits(&s->pb, table0_dc_lum[code][1], table0_dc_lum[code][0]);
 
894
                put_bits(&s->pb, ff_table0_dc_lum[code][1], ff_table0_dc_lum[code][0]);
1007
895
            } else {
1008
 
                put_bits(&s->pb, table0_dc_chroma[code][1], table0_dc_chroma[code][0]);
 
896
                put_bits(&s->pb, ff_table0_dc_chroma[code][1], ff_table0_dc_chroma[code][0]);
1009
897
            }
1010
898
        } else {
1011
899
            if (n < 4) {
1012
 
                put_bits(&s->pb, table1_dc_lum[code][1], table1_dc_lum[code][0]);
 
900
                put_bits(&s->pb, ff_table1_dc_lum[code][1], ff_table1_dc_lum[code][0]);
1013
901
            } else {
1014
 
                put_bits(&s->pb, table1_dc_chroma[code][1], table1_dc_chroma[code][0]);
 
902
                put_bits(&s->pb, ff_table1_dc_chroma[code][1], ff_table1_dc_chroma[code][0]);
1015
903
            }
1016
904
        }
1017
905
            
1024
912
    }
1025
913
}
1026
914
 
 
915
/* Encoding of a block. Very similar to MPEG4 except for a different
 
916
   escape coding (same as H263) and more vlc tables.
 
917
 */
 
918
static inline void msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n)
 
919
{
 
920
    int level, run, last, i, j, last_index;
 
921
    int last_non_zero, sign, slevel;
 
922
    int code, run_diff, dc_pred_dir;
 
923
    const RLTable *rl;
 
924
    const uint8_t *scantable;
 
925
 
 
926
    if (s->mb_intra) {
 
927
        set_stat(ST_DC);
 
928
        msmpeg4_encode_dc(s, block[0], n, &dc_pred_dir);
 
929
        i = 1;
 
930
        if (n < 4) {
 
931
            rl = &rl_table[s->rl_table_index];
 
932
        } else {
 
933
            rl = &rl_table[3 + s->rl_chroma_table_index];
 
934
        }
 
935
        run_diff = 0;
 
936
        scantable= s->intra_scantable.permutated;
 
937
        set_stat(ST_INTRA_AC);
 
938
    } else {
 
939
        i = 0;
 
940
        rl = &rl_table[3 + s->rl_table_index];
 
941
        if(s->msmpeg4_version<=2)
 
942
            run_diff = 0;
 
943
        else
 
944
            run_diff = 1;
 
945
        scantable= s->inter_scantable.permutated;
 
946
        set_stat(ST_INTER_AC);
 
947
    }
 
948
 
 
949
    /* recalculate block_last_index for M$ wmv1 */
 
950
    if(s->msmpeg4_version>=4 && s->block_last_index[n]>0){
 
951
        for(last_index=63; last_index>=0; last_index--){
 
952
            if(block[scantable[last_index]]) break;
 
953
        }
 
954
        s->block_last_index[n]= last_index;
 
955
    }else
 
956
        last_index = s->block_last_index[n];
 
957
    /* AC coefs */
 
958
    last_non_zero = i - 1;
 
959
    for (; i <= last_index; i++) {
 
960
        j = scantable[i];
 
961
        level = block[j];
 
962
        if (level) {
 
963
            run = i - last_non_zero - 1;
 
964
            last = (i == last_index);
 
965
            sign = 0;
 
966
            slevel = level;
 
967
            if (level < 0) {
 
968
                sign = 1;
 
969
                level = -level;
 
970
            }
 
971
 
 
972
            if(level<=MAX_LEVEL && run<=MAX_RUN){
 
973
                s->ac_stats[s->mb_intra][n>3][level][run][last]++;
 
974
            }
 
975
#if 0
 
976
else
 
977
    s->ac_stats[s->mb_intra][n>3][40][63][0]++; //esc3 like
 
978
#endif
 
979
            code = get_rl_index(rl, last, run, level);
 
980
            put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
 
981
            if (code == rl->n) {
 
982
                int level1, run1;
 
983
 
 
984
                level1 = level - rl->max_level[last][run];
 
985
                if (level1 < 1) 
 
986
                    goto esc2;
 
987
                code = get_rl_index(rl, last, run, level1);
 
988
                if (code == rl->n) {
 
989
                esc2:
 
990
                    put_bits(&s->pb, 1, 0);
 
991
                    if (level > MAX_LEVEL)
 
992
                        goto esc3;
 
993
                    run1 = run - rl->max_run[last][level] - run_diff;
 
994
                    if (run1 < 0)
 
995
                        goto esc3;
 
996
                    code = get_rl_index(rl, last, run1, level);
 
997
                    if (code == rl->n) {
 
998
                    esc3:
 
999
                        /* third escape */
 
1000
                        put_bits(&s->pb, 1, 0);
 
1001
                        put_bits(&s->pb, 1, last);
 
1002
                        if(s->msmpeg4_version>=4){
 
1003
                            if(s->esc3_level_length==0){
 
1004
                                s->esc3_level_length=8;
 
1005
                                s->esc3_run_length= 6;
 
1006
                                if(s->qscale<8)
 
1007
                                    put_bits(&s->pb, 6, 3);
 
1008
                                else
 
1009
                                    put_bits(&s->pb, 8, 3);
 
1010
                            }
 
1011
                            put_bits(&s->pb, s->esc3_run_length, run);
 
1012
                            put_bits(&s->pb, 1, sign);
 
1013
                            put_bits(&s->pb, s->esc3_level_length, level);
 
1014
                        }else{
 
1015
                            put_bits(&s->pb, 6, run);
 
1016
                            put_bits(&s->pb, 8, slevel & 0xff);
 
1017
                        }
 
1018
                    } else {
 
1019
                        /* second escape */
 
1020
                        put_bits(&s->pb, 1, 1);
 
1021
                        put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
 
1022
                        put_bits(&s->pb, 1, sign);
 
1023
                    }
 
1024
                } else {
 
1025
                    /* first escape */
 
1026
                    put_bits(&s->pb, 1, 1);
 
1027
                    put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
 
1028
                    put_bits(&s->pb, 1, sign);
 
1029
                }
 
1030
            } else {
 
1031
                put_bits(&s->pb, 1, sign);
 
1032
            }
 
1033
            last_non_zero = i;
 
1034
        }
 
1035
    }
 
1036
}
1027
1037
 
1028
1038
/****************************************/
1029
1039
/* decoding stuff */
1030
1040
 
1031
1041
static VLC mb_non_intra_vlc[4];
1032
 
static VLC mb_intra_vlc;
1033
 
static VLC dc_lum_vlc[2];
1034
 
static VLC dc_chroma_vlc[2];
 
1042
VLC ff_msmp4_mb_i_vlc;
 
1043
VLC ff_msmp4_dc_luma_vlc[2];
 
1044
VLC ff_msmp4_dc_chroma_vlc[2];
1035
1045
static VLC v2_dc_lum_vlc;
1036
1046
static VLC v2_dc_chroma_vlc;
1037
1047
static VLC cbpy_vlc;
1110
1120
        done = 1;
1111
1121
 
1112
1122
        for(i=0;i<NB_RL_TABLES;i++) {
1113
 
            init_rl(&rl_table[i]);
1114
 
            init_vlc_rl(&rl_table[i]);
 
1123
            init_rl(&rl_table[i], 1);
 
1124
            init_vlc_rl(&rl_table[i], 1);
1115
1125
        }
1116
1126
        for(i=0;i<2;i++) {
1117
1127
            mv = &mv_tables[i];
1118
1128
            init_vlc(&mv->vlc, MV_VLC_BITS, mv->n + 1, 
1119
1129
                     mv->table_mv_bits, 1, 1,
1120
 
                     mv->table_mv_code, 2, 2);
 
1130
                     mv->table_mv_code, 2, 2, 1);
1121
1131
        }
1122
1132
 
1123
 
        init_vlc(&dc_lum_vlc[0], DC_VLC_BITS, 120, 
1124
 
                 &table0_dc_lum[0][1], 8, 4,
1125
 
                 &table0_dc_lum[0][0], 8, 4);
1126
 
        init_vlc(&dc_chroma_vlc[0], DC_VLC_BITS, 120, 
1127
 
                 &table0_dc_chroma[0][1], 8, 4,
1128
 
                 &table0_dc_chroma[0][0], 8, 4);
1129
 
        init_vlc(&dc_lum_vlc[1], DC_VLC_BITS, 120, 
1130
 
                 &table1_dc_lum[0][1], 8, 4,
1131
 
                 &table1_dc_lum[0][0], 8, 4);
1132
 
        init_vlc(&dc_chroma_vlc[1], DC_VLC_BITS, 120, 
1133
 
                 &table1_dc_chroma[0][1], 8, 4,
1134
 
                 &table1_dc_chroma[0][0], 8, 4);
 
1133
        init_vlc(&ff_msmp4_dc_luma_vlc[0], DC_VLC_BITS, 120, 
 
1134
                 &ff_table0_dc_lum[0][1], 8, 4,
 
1135
                 &ff_table0_dc_lum[0][0], 8, 4, 1);
 
1136
        init_vlc(&ff_msmp4_dc_chroma_vlc[0], DC_VLC_BITS, 120, 
 
1137
                 &ff_table0_dc_chroma[0][1], 8, 4,
 
1138
                 &ff_table0_dc_chroma[0][0], 8, 4, 1);
 
1139
        init_vlc(&ff_msmp4_dc_luma_vlc[1], DC_VLC_BITS, 120, 
 
1140
                 &ff_table1_dc_lum[0][1], 8, 4,
 
1141
                 &ff_table1_dc_lum[0][0], 8, 4, 1);
 
1142
        init_vlc(&ff_msmp4_dc_chroma_vlc[1], DC_VLC_BITS, 120, 
 
1143
                 &ff_table1_dc_chroma[0][1], 8, 4,
 
1144
                 &ff_table1_dc_chroma[0][0], 8, 4, 1);
1135
1145
    
1136
1146
        init_vlc(&v2_dc_lum_vlc, DC_VLC_BITS, 512, 
1137
1147
                 &v2_dc_lum_table[0][1], 8, 4,
1138
 
                 &v2_dc_lum_table[0][0], 8, 4);
 
1148
                 &v2_dc_lum_table[0][0], 8, 4, 1);
1139
1149
        init_vlc(&v2_dc_chroma_vlc, DC_VLC_BITS, 512, 
1140
1150
                 &v2_dc_chroma_table[0][1], 8, 4,
1141
 
                 &v2_dc_chroma_table[0][0], 8, 4);
 
1151
                 &v2_dc_chroma_table[0][0], 8, 4, 1);
1142
1152
    
1143
1153
        init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
1144
1154
                 &cbpy_tab[0][1], 2, 1,
1145
 
                 &cbpy_tab[0][0], 2, 1);
 
1155
                 &cbpy_tab[0][0], 2, 1, 1);
1146
1156
        init_vlc(&v2_intra_cbpc_vlc, V2_INTRA_CBPC_VLC_BITS, 4,
1147
1157
                 &v2_intra_cbpc[0][1], 2, 1,
1148
 
                 &v2_intra_cbpc[0][0], 2, 1);
 
1158
                 &v2_intra_cbpc[0][0], 2, 1, 1);
1149
1159
        init_vlc(&v2_mb_type_vlc, V2_MB_TYPE_VLC_BITS, 8,
1150
1160
                 &v2_mb_type[0][1], 2, 1,
1151
 
                 &v2_mb_type[0][0], 2, 1);
 
1161
                 &v2_mb_type[0][0], 2, 1, 1);
1152
1162
        init_vlc(&v2_mv_vlc, V2_MV_VLC_BITS, 33,
1153
1163
                 &mvtab[0][1], 2, 1,
1154
 
                 &mvtab[0][0], 2, 1);
 
1164
                 &mvtab[0][0], 2, 1, 1);
1155
1165
 
1156
1166
        for(i=0; i<4; i++){
1157
1167
            init_vlc(&mb_non_intra_vlc[i], MB_NON_INTRA_VLC_BITS, 128, 
1158
1168
                     &wmv2_inter_table[i][0][1], 8, 4,
1159
 
                     &wmv2_inter_table[i][0][0], 8, 4); //FIXME name?
 
1169
                     &wmv2_inter_table[i][0][0], 8, 4, 1); //FIXME name?
1160
1170
        }
1161
1171
        
1162
 
        init_vlc(&mb_intra_vlc, MB_INTRA_VLC_BITS, 64, 
1163
 
                 &table_mb_intra[0][1], 4, 2,
1164
 
                 &table_mb_intra[0][0], 4, 2);
 
1172
        init_vlc(&ff_msmp4_mb_i_vlc, MB_INTRA_VLC_BITS, 64, 
 
1173
                 &ff_msmp4_mb_i_table[0][1], 4, 2,
 
1174
                 &ff_msmp4_mb_i_table[0][0], 4, 2, 1);
1165
1175
        
1166
1176
        init_vlc(&v1_intra_cbpc_vlc, V1_INTRA_CBPC_VLC_BITS, 8, 
1167
1177
                 intra_MCBPC_bits, 1, 1,
1168
 
                 intra_MCBPC_code, 1, 1);
 
1178
                 intra_MCBPC_code, 1, 1, 1);
1169
1179
        init_vlc(&v1_inter_cbpc_vlc, V1_INTER_CBPC_VLC_BITS, 25, 
1170
1180
                 inter_MCBPC_bits, 1, 1,
1171
 
                 inter_MCBPC_code, 1, 1);
 
1181
                 inter_MCBPC_code, 1, 1, 1);
1172
1182
        
1173
1183
        init_vlc(&inter_intra_vlc, INTER_INTRA_VLC_BITS, 4, 
1174
1184
                 &table_inter_intra[0][1], 2, 1,
1175
 
                 &table_inter_intra[0][0], 2, 1);
 
1185
                 &table_inter_intra[0][0], 2, 1, 1);
1176
1186
    }
1177
1187
    
1178
1188
    switch(s->msmpeg4_version){
1186
1196
        break;
1187
1197
    case 5:
1188
1198
        s->decode_mb= wmv2_decode_mb;
 
1199
    case 6:
 
1200
        //FIXME + TODO VC9 decode mb
1189
1201
        break;
1190
1202
    }
1191
1203
    
1194
1206
    return 0;
1195
1207
}
1196
1208
 
1197
 
static int decode012(GetBitContext *gb)
1198
 
{
1199
 
    int n;
1200
 
    n = get_bits1(gb);
1201
 
    if (n == 0)
1202
 
        return 0;
1203
 
    else
1204
 
        return get_bits1(gb) + 1;
1205
 
}
1206
 
 
1207
1209
int msmpeg4_decode_picture_header(MpegEncContext * s)
1208
1210
{
1209
1211
    int code;
1477
1479
    return val;
1478
1480
}
1479
1481
 
 
1482
static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
 
1483
{
 
1484
    int cbp, code, i;
 
1485
    
 
1486
    if (s->pict_type == P_TYPE) {
 
1487
        if (s->use_skip_mb_code) {
 
1488
            if (get_bits1(&s->gb)) {
 
1489
                /* skip mb */
 
1490
                s->mb_intra = 0;
 
1491
                for(i=0;i<6;i++)
 
1492
                    s->block_last_index[i] = -1;
 
1493
                s->mv_dir = MV_DIR_FORWARD;
 
1494
                s->mv_type = MV_TYPE_16X16;
 
1495
                s->mv[0][0][0] = 0;
 
1496
                s->mv[0][0][1] = 0;
 
1497
                s->mb_skipped = 1;
 
1498
                return 0;
 
1499
            }
 
1500
        }
 
1501
 
 
1502
        if(s->msmpeg4_version==2)
 
1503
            code = get_vlc2(&s->gb, v2_mb_type_vlc.table, V2_MB_TYPE_VLC_BITS, 1);
 
1504
        else
 
1505
            code = get_vlc2(&s->gb, v1_inter_cbpc_vlc.table, V1_INTER_CBPC_VLC_BITS, 3);
 
1506
        if(code<0 || code>7){
 
1507
            av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", code, s->mb_x, s->mb_y);
 
1508
            return -1;
 
1509
        }
 
1510
 
 
1511
        s->mb_intra = code >>2;
 
1512
    
 
1513
        cbp = code & 0x3;
 
1514
    } else {
 
1515
        s->mb_intra = 1;
 
1516
        if(s->msmpeg4_version==2)
 
1517
            cbp= get_vlc2(&s->gb, v2_intra_cbpc_vlc.table, V2_INTRA_CBPC_VLC_BITS, 1);
 
1518
        else
 
1519
            cbp= get_vlc2(&s->gb, v1_intra_cbpc_vlc.table, V1_INTRA_CBPC_VLC_BITS, 1);
 
1520
        if(cbp<0 || cbp>3){
 
1521
            av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
 
1522
            return -1;
 
1523
        }
 
1524
    }
 
1525
 
 
1526
    if (!s->mb_intra) {
 
1527
        int mx, my, cbpy;
 
1528
        
 
1529
        cbpy= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
 
1530
        if(cbpy<0){
 
1531
            av_log(s->avctx, AV_LOG_ERROR, "cbpy %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
 
1532
            return -1;
 
1533
        }
 
1534
 
 
1535
        cbp|= cbpy<<2;
 
1536
        if(s->msmpeg4_version==1 || (cbp&3) != 3) cbp^= 0x3C;
 
1537
        
 
1538
        h263_pred_motion(s, 0, 0, &mx, &my);
 
1539
        mx= msmpeg4v2_decode_motion(s, mx, 1);
 
1540
        my= msmpeg4v2_decode_motion(s, my, 1);
 
1541
        
 
1542
        s->mv_dir = MV_DIR_FORWARD;
 
1543
        s->mv_type = MV_TYPE_16X16;
 
1544
        s->mv[0][0][0] = mx;
 
1545
        s->mv[0][0][1] = my;
 
1546
    } else {
 
1547
        if(s->msmpeg4_version==2){
 
1548
            s->ac_pred = get_bits1(&s->gb);
 
1549
            cbp|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
 
1550
        } else{
 
1551
            s->ac_pred = 0;
 
1552
            cbp|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
 
1553
            if(s->pict_type==P_TYPE) cbp^=0x3C;
 
1554
        }
 
1555
    }
 
1556
 
 
1557
    s->dsp.clear_blocks(s->block[0]);
 
1558
    for (i = 0; i < 6; i++) {
 
1559
        if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
 
1560
        {
 
1561
             av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
 
1562
             return -1;
 
1563
        }
 
1564
    }
 
1565
    return 0;
 
1566
}
 
1567
 
 
1568
static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
 
1569
{
 
1570
    int cbp, code, i;
 
1571
    uint8_t *coded_val;
 
1572
    uint32_t * const mb_type_ptr= &s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ];
 
1573
 
 
1574
    if (s->pict_type == P_TYPE) {
 
1575
        set_stat(ST_INTER_MB);
 
1576
        if (s->use_skip_mb_code) {
 
1577
            if (get_bits1(&s->gb)) {
 
1578
                /* skip mb */
 
1579
                s->mb_intra = 0;
 
1580
                for(i=0;i<6;i++)
 
1581
                    s->block_last_index[i] = -1;
 
1582
                s->mv_dir = MV_DIR_FORWARD;
 
1583
                s->mv_type = MV_TYPE_16X16;
 
1584
                s->mv[0][0][0] = 0;
 
1585
                s->mv[0][0][1] = 0;
 
1586
                s->mb_skipped = 1;
 
1587
                *mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
 
1588
 
 
1589
                return 0;
 
1590
            }
 
1591
        }
 
1592
        
 
1593
        code = get_vlc2(&s->gb, mb_non_intra_vlc[DEFAULT_INTER_INDEX].table, MB_NON_INTRA_VLC_BITS, 3);
 
1594
        if (code < 0)
 
1595
            return -1;
 
1596
        //s->mb_intra = (code & 0x40) ? 0 : 1;
 
1597
        s->mb_intra = (~code & 0x40) >> 6;
 
1598
            
 
1599
        cbp = code & 0x3f;
 
1600
    } else {
 
1601
        set_stat(ST_INTRA_MB);
 
1602
        s->mb_intra = 1;
 
1603
        code = get_vlc2(&s->gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
 
1604
        if (code < 0)
 
1605
            return -1;
 
1606
        /* predict coded block pattern */
 
1607
        cbp = 0;
 
1608
        for(i=0;i<6;i++) {
 
1609
            int val = ((code >> (5 - i)) & 1);
 
1610
            if (i < 4) {
 
1611
                int pred = coded_block_pred(s, i, &coded_val);
 
1612
                val = val ^ pred;
 
1613
                *coded_val = val;
 
1614
            }
 
1615
            cbp |= val << (5 - i);
 
1616
        }
 
1617
    }
 
1618
 
 
1619
    if (!s->mb_intra) {
 
1620
        int mx, my;
 
1621
//printf("P at %d %d\n", s->mb_x, s->mb_y);
 
1622
        if(s->per_mb_rl_table && cbp){
 
1623
            s->rl_table_index = decode012(&s->gb);
 
1624
            s->rl_chroma_table_index = s->rl_table_index;
 
1625
        }
 
1626
        set_stat(ST_MV);
 
1627
        h263_pred_motion(s, 0, 0, &mx, &my);
 
1628
        if (msmpeg4_decode_motion(s, &mx, &my) < 0)
 
1629
            return -1;
 
1630
        s->mv_dir = MV_DIR_FORWARD;
 
1631
        s->mv_type = MV_TYPE_16X16;
 
1632
        s->mv[0][0][0] = mx;
 
1633
        s->mv[0][0][1] = my;
 
1634
        *mb_type_ptr = MB_TYPE_L0 | MB_TYPE_16x16;
 
1635
    } else {
 
1636
//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));
 
1637
        set_stat(ST_INTRA_MB);
 
1638
        s->ac_pred = get_bits1(&s->gb);
 
1639
        *mb_type_ptr = MB_TYPE_INTRA;
 
1640
        if(s->inter_intra_pred){
 
1641
            s->h263_aic_dir= get_vlc2(&s->gb, inter_intra_vlc.table, INTER_INTRA_VLC_BITS, 1);
 
1642
//            printf("%d%d %d %d/", s->ac_pred, s->h263_aic_dir, s->mb_x, s->mb_y);
 
1643
        }
 
1644
        if(s->per_mb_rl_table && cbp){
 
1645
            s->rl_table_index = decode012(&s->gb);
 
1646
            s->rl_chroma_table_index = s->rl_table_index;
 
1647
        }
 
1648
    }
 
1649
 
 
1650
    s->dsp.clear_blocks(s->block[0]);
 
1651
    for (i = 0; i < 6; i++) {
 
1652
        if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
 
1653
        {
 
1654
            av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
 
1655
            return -1;
 
1656
        }
 
1657
    }
 
1658
    
 
1659
    return 0;
 
1660
}
1480
1661
//#define ERROR_DETAILS
1481
1662
static inline int msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
1482
1663
                              int n, int coded, const uint8_t *scan_table)
1554
1735
    OPEN_READER(re, &s->gb);
1555
1736
    for(;;) {
1556
1737
        UPDATE_CACHE(re, &s->gb);
1557
 
        GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
 
1738
        GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
1558
1739
        if (level==0) {
1559
1740
            int cache;
1560
1741
            cache= GET_CACHE(re, &s->gb);
1640
1821
                    if(last) i+=192;
1641
1822
#ifdef ERROR_DETAILS
1642
1823
                if(run==66)
1643
 
                    fprintf(stderr, "illegal vlc code in ESC3 level=%d\n", level);
 
1824
                    av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC3 level=%d\n", level);
1644
1825
                else if((i>62 && i<192) || i>192+63)
1645
 
                    fprintf(stderr, "run overflow in ESC3 i=%d run=%d level=%d\n", i, run, level);
 
1826
                    av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC3 i=%d run=%d level=%d\n", i, run, level);
1646
1827
#endif
1647
1828
                } else {
1648
1829
                    /* second escape */
1652
1833
#else
1653
1834
                    SKIP_BITS(re, &s->gb, 2);
1654
1835
#endif
1655
 
                    GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
 
1836
                    GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
1656
1837
                    i+= run + rl->max_run[run>>7][level/qmul] + run_diff; //FIXME opt indexing
1657
1838
                    level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1658
1839
                    LAST_SKIP_BITS(re, &s->gb, 1);
1659
1840
#ifdef ERROR_DETAILS
1660
1841
                if(run==66)
1661
 
                    fprintf(stderr, "illegal vlc code in ESC2 level=%d\n", level);
 
1842
                    av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC2 level=%d\n", level);
1662
1843
                else if((i>62 && i<192) || i>192+63)
1663
 
                    fprintf(stderr, "run overflow in ESC2 i=%d run=%d level=%d\n", i, run, level);
 
1844
                    av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC2 i=%d run=%d level=%d\n", i, run, level);
1664
1845
#endif
1665
1846
                }
1666
1847
            } else {
1671
1852
#else
1672
1853
                SKIP_BITS(re, &s->gb, 1);
1673
1854
#endif
1674
 
                GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
 
1855
                GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
1675
1856
                i+= run;
1676
1857
                level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
1677
1858
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1678
1859
                LAST_SKIP_BITS(re, &s->gb, 1);
1679
1860
#ifdef ERROR_DETAILS
1680
1861
                if(run==66)
1681
 
                    fprintf(stderr, "illegal vlc code in ESC1 level=%d\n", level);
 
1862
                    av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC1 level=%d\n", level);
1682
1863
                else if((i>62 && i<192) || i>192+63)
1683
 
                    fprintf(stderr, "run overflow in ESC1 i=%d run=%d level=%d\n", i, run, level);
 
1864
                    av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC1 i=%d run=%d level=%d\n", i, run, level);
1684
1865
#endif
1685
1866
            }
1686
1867
        } else {
1689
1870
            LAST_SKIP_BITS(re, &s->gb, 1);
1690
1871
#ifdef ERROR_DETAILS
1691
1872
                if(run==66)
1692
 
                    fprintf(stderr, "illegal vlc code level=%d\n", level);
 
1873
                    av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code level=%d\n", level);
1693
1874
                else if((i>62 && i<192) || i>192+63)
1694
 
                    fprintf(stderr, "run overflow i=%d run=%d level=%d\n", i, run, level);
 
1875
                    av_log(s->avctx, AV_LOG_ERROR, "run overflow i=%d run=%d level=%d\n", i, run, level);
1695
1876
#endif
1696
1877
        }
1697
1878
        if (i > 62){
1728
1909
    return 0;
1729
1910
}
1730
1911
 
1731
 
static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1732
 
{
1733
 
    int cbp, code, i;
1734
 
    
1735
 
    if (s->pict_type == P_TYPE) {
1736
 
        if (s->use_skip_mb_code) {
1737
 
            if (get_bits1(&s->gb)) {
1738
 
                /* skip mb */
1739
 
                s->mb_intra = 0;
1740
 
                for(i=0;i<6;i++)
1741
 
                    s->block_last_index[i] = -1;
1742
 
                s->mv_dir = MV_DIR_FORWARD;
1743
 
                s->mv_type = MV_TYPE_16X16;
1744
 
                s->mv[0][0][0] = 0;
1745
 
                s->mv[0][0][1] = 0;
1746
 
                s->mb_skiped = 1;
1747
 
                return 0;
1748
 
            }
1749
 
        }
1750
 
 
1751
 
        if(s->msmpeg4_version==2)
1752
 
            code = get_vlc2(&s->gb, v2_mb_type_vlc.table, V2_MB_TYPE_VLC_BITS, 1);
1753
 
        else
1754
 
            code = get_vlc2(&s->gb, v1_inter_cbpc_vlc.table, V1_INTER_CBPC_VLC_BITS, 3);
1755
 
        if(code<0 || code>7){
1756
 
            av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", code, s->mb_x, s->mb_y);
1757
 
            return -1;
1758
 
        }
1759
 
 
1760
 
        s->mb_intra = code >>2;
1761
 
    
1762
 
        cbp = code & 0x3;
1763
 
    } else {
1764
 
        s->mb_intra = 1;
1765
 
        if(s->msmpeg4_version==2)
1766
 
            cbp= get_vlc2(&s->gb, v2_intra_cbpc_vlc.table, V2_INTRA_CBPC_VLC_BITS, 1);
1767
 
        else
1768
 
            cbp= get_vlc2(&s->gb, v1_intra_cbpc_vlc.table, V1_INTRA_CBPC_VLC_BITS, 1);
1769
 
        if(cbp<0 || cbp>3){
1770
 
            av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
1771
 
            return -1;
1772
 
        }
1773
 
    }
1774
 
 
1775
 
    if (!s->mb_intra) {
1776
 
        int mx, my, cbpy;
1777
 
        
1778
 
        cbpy= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
1779
 
        if(cbpy<0){
1780
 
            av_log(s->avctx, AV_LOG_ERROR, "cbpy %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
1781
 
            return -1;
1782
 
        }
1783
 
 
1784
 
        cbp|= cbpy<<2;
1785
 
        if(s->msmpeg4_version==1 || (cbp&3) != 3) cbp^= 0x3C;
1786
 
        
1787
 
        h263_pred_motion(s, 0, 0, &mx, &my);
1788
 
        mx= msmpeg4v2_decode_motion(s, mx, 1);
1789
 
        my= msmpeg4v2_decode_motion(s, my, 1);
1790
 
        
1791
 
        s->mv_dir = MV_DIR_FORWARD;
1792
 
        s->mv_type = MV_TYPE_16X16;
1793
 
        s->mv[0][0][0] = mx;
1794
 
        s->mv[0][0][1] = my;
1795
 
    } else {
1796
 
        if(s->msmpeg4_version==2){
1797
 
            s->ac_pred = get_bits1(&s->gb);
1798
 
            cbp|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
1799
 
        } else{
1800
 
            s->ac_pred = 0;
1801
 
            cbp|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
1802
 
            if(s->pict_type==P_TYPE) cbp^=0x3C;
1803
 
        }
1804
 
    }
1805
 
 
1806
 
    for (i = 0; i < 6; i++) {
1807
 
        if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
1808
 
        {
1809
 
             av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1810
 
             return -1;
1811
 
        }
1812
 
    }
1813
 
    return 0;
1814
 
}
1815
 
 
1816
 
static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1817
 
{
1818
 
    int cbp, code, i;
1819
 
    uint8_t *coded_val;
1820
 
    uint32_t * const mb_type_ptr= &s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ];
1821
 
 
1822
 
    if (s->pict_type == P_TYPE) {
1823
 
        set_stat(ST_INTER_MB);
1824
 
        if (s->use_skip_mb_code) {
1825
 
            if (get_bits1(&s->gb)) {
1826
 
                /* skip mb */
1827
 
                s->mb_intra = 0;
1828
 
                for(i=0;i<6;i++)
1829
 
                    s->block_last_index[i] = -1;
1830
 
                s->mv_dir = MV_DIR_FORWARD;
1831
 
                s->mv_type = MV_TYPE_16X16;
1832
 
                s->mv[0][0][0] = 0;
1833
 
                s->mv[0][0][1] = 0;
1834
 
                s->mb_skiped = 1;
1835
 
                *mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
1836
 
 
1837
 
                return 0;
1838
 
            }
1839
 
        }
1840
 
        
1841
 
        code = get_vlc2(&s->gb, mb_non_intra_vlc[DEFAULT_INTER_INDEX].table, MB_NON_INTRA_VLC_BITS, 3);
1842
 
        if (code < 0)
1843
 
            return -1;
1844
 
        //s->mb_intra = (code & 0x40) ? 0 : 1;
1845
 
        s->mb_intra = (~code & 0x40) >> 6;
1846
 
            
1847
 
        cbp = code & 0x3f;
1848
 
    } else {
1849
 
        set_stat(ST_INTRA_MB);
1850
 
        s->mb_intra = 1;
1851
 
        code = get_vlc2(&s->gb, mb_intra_vlc.table, MB_INTRA_VLC_BITS, 2);
1852
 
        if (code < 0)
1853
 
            return -1;
1854
 
        /* predict coded block pattern */
1855
 
        cbp = 0;
1856
 
        for(i=0;i<6;i++) {
1857
 
            int val = ((code >> (5 - i)) & 1);
1858
 
            if (i < 4) {
1859
 
                int pred = coded_block_pred(s, i, &coded_val);
1860
 
                val = val ^ pred;
1861
 
                *coded_val = val;
1862
 
            }
1863
 
            cbp |= val << (5 - i);
1864
 
        }
1865
 
    }
1866
 
 
1867
 
    if (!s->mb_intra) {
1868
 
        int mx, my;
1869
 
//printf("P at %d %d\n", s->mb_x, s->mb_y);
1870
 
        if(s->per_mb_rl_table && cbp){
1871
 
            s->rl_table_index = decode012(&s->gb);
1872
 
            s->rl_chroma_table_index = s->rl_table_index;
1873
 
        }
1874
 
        set_stat(ST_MV);
1875
 
        h263_pred_motion(s, 0, 0, &mx, &my);
1876
 
        if (msmpeg4_decode_motion(s, &mx, &my) < 0)
1877
 
            return -1;
1878
 
        s->mv_dir = MV_DIR_FORWARD;
1879
 
        s->mv_type = MV_TYPE_16X16;
1880
 
        s->mv[0][0][0] = mx;
1881
 
        s->mv[0][0][1] = my;
1882
 
        *mb_type_ptr = MB_TYPE_L0 | MB_TYPE_16x16;
1883
 
    } else {
1884
 
//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));
1885
 
        set_stat(ST_INTRA_MB);
1886
 
        s->ac_pred = get_bits1(&s->gb);
1887
 
        *mb_type_ptr = MB_TYPE_INTRA;
1888
 
        if(s->inter_intra_pred){
1889
 
            s->h263_aic_dir= get_vlc2(&s->gb, inter_intra_vlc.table, INTER_INTRA_VLC_BITS, 1);
1890
 
//            printf("%d%d %d %d/", s->ac_pred, s->h263_aic_dir, s->mb_x, s->mb_y);
1891
 
        }
1892
 
        if(s->per_mb_rl_table && cbp){
1893
 
            s->rl_table_index = decode012(&s->gb);
1894
 
            s->rl_chroma_table_index = s->rl_table_index;
1895
 
        }
1896
 
    }
1897
 
 
1898
 
    for (i = 0; i < 6; i++) {
1899
 
        if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
1900
 
        {
1901
 
            av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1902
 
            return -1;
1903
 
        }
1904
 
    }
1905
 
    
1906
 
    return 0;
1907
 
}
1908
 
 
1909
1912
static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
1910
1913
{
1911
1914
    int level, pred;
1921
1924
        level-=256;
1922
1925
    }else{  //FIXME optimize use unified tables & index
1923
1926
        if (n < 4) {
1924
 
            level = get_vlc2(&s->gb, dc_lum_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
 
1927
            level = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1925
1928
        } else {
1926
 
            level = get_vlc2(&s->gb, dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
 
1929
            level = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1927
1930
        }
1928
1931
        if (level < 0){
1929
1932
            av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");