Attachment #83902 for bug #119014

View | Details | Raw Unified | Return to bug 119014 | Differences between
Collapse All | Expand All




    return val;
}

static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
{
    int cbp, code, i;
    
    if (s->pict_type == P_TYPE) {
        if (s->use_skip_mb_code) {
            if (get_bits1(&s->gb)) {
                /* skip mb */
                s->mb_intra = 0;
                for(i=0;i<6;i++)
                    s->block_last_index[i] = -1;
                s->mv_dir = MV_DIR_FORWARD;
                s->mv_type = MV_TYPE_16X16;
                s->mv[0][0][0] = 0;
                s->mv[0][0][1] = 0;
                s->mb_skipped = 1;
                return 0;
            }
        }

        if(s->msmpeg4_version==2)
            code = get_vlc2(&s->gb, v2_mb_type_vlc.table, V2_MB_TYPE_VLC_BITS, 1);
        else
            code = get_vlc2(&s->gb, v1_inter_cbpc_vlc.table, V1_INTER_CBPC_VLC_BITS, 3);
        if(code<0 || code>7){
            av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", code, s->mb_x, s->mb_y);
            return -1;
        }

        s->mb_intra = code >>2;
    
        cbp = code & 0x3;
    } else {
        s->mb_intra = 1;
        if(s->msmpeg4_version==2)
            cbp= get_vlc2(&s->gb, v2_intra_cbpc_vlc.table, V2_INTRA_CBPC_VLC_BITS, 1);
        else
            cbp= get_vlc2(&s->gb, v1_intra_cbpc_vlc.table, V1_INTRA_CBPC_VLC_BITS, 1);
        if(cbp<0 || cbp>3){
            av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
            return -1;
        }
    }

    if (!s->mb_intra) {
        int mx, my, cbpy;
        
        cbpy= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
        if(cbpy<0){
            av_log(s->avctx, AV_LOG_ERROR, "cbpy %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
            return -1;
        }

        cbp|= cbpy<<2;
        if(s->msmpeg4_version==1 || (cbp&3) != 3) cbp^= 0x3C;
        
        h263_pred_motion(s, 0, 0, &mx, &my);
        mx= msmpeg4v2_decode_motion(s, mx, 1);
        my= msmpeg4v2_decode_motion(s, my, 1);
        
        s->mv_dir = MV_DIR_FORWARD;
        s->mv_type = MV_TYPE_16X16;
        s->mv[0][0][0] = mx;
        s->mv[0][0][1] = my;
    } else {
        if(s->msmpeg4_version==2){
            s->ac_pred = get_bits1(&s->gb);
            cbp|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
        } else{
            s->ac_pred = 0;
            cbp|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
            if(s->pict_type==P_TYPE) cbp^=0x3C;
        }
    }

    s->dsp.clear_blocks(s->block[0]);
    for (i = 0; i < 6; i++) {
        if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
	{
             av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
             return -1;
	}
    }
    return 0;
}

static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
{
    int cbp, code, i;
    uint8_t *coded_val;
    uint32_t * const mb_type_ptr= &s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ];

    if (s->pict_type == P_TYPE) {
        set_stat(ST_INTER_MB);
        if (s->use_skip_mb_code) {
            if (get_bits1(&s->gb)) {
                /* skip mb */
                s->mb_intra = 0;
                for(i=0;i<6;i++)
                    s->block_last_index[i] = -1;
                s->mv_dir = MV_DIR_FORWARD;
                s->mv_type = MV_TYPE_16X16;
                s->mv[0][0][0] = 0;
                s->mv[0][0][1] = 0;
                s->mb_skipped = 1;
                *mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;

                return 0;
            }
        }
        
        code = get_vlc2(&s->gb, mb_non_intra_vlc[DEFAULT_INTER_INDEX].table, MB_NON_INTRA_VLC_BITS, 3);
        if (code < 0)
            return -1;
	//s->mb_intra = (code & 0x40) ? 0 : 1;
	s->mb_intra = (~code & 0x40) >> 6;
            
        cbp = code & 0x3f;
    } else {
        set_stat(ST_INTRA_MB);
        s->mb_intra = 1;
        code = get_vlc2(&s->gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
        if (code < 0)
            return -1;
        /* predict coded block pattern */
        cbp = 0;
        for(i=0;i<6;i++) {
            int val = ((code >> (5 - i)) & 1);
            if (i < 4) {
                int pred = coded_block_pred(s, i, &coded_val);
                val = val ^ pred;
                *coded_val = val;
            }
            cbp |= val << (5 - i);
        }
    }

    if (!s->mb_intra) {
        int mx, my;
//printf("P at %d %d\n", s->mb_x, s->mb_y);
        if(s->per_mb_rl_table && cbp){
            s->rl_table_index = decode012(&s->gb);
            s->rl_chroma_table_index = s->rl_table_index;
        }
        set_stat(ST_MV);
        h263_pred_motion(s, 0, 0, &mx, &my);
        if (msmpeg4_decode_motion(s, &mx, &my) < 0)
            return -1;
        s->mv_dir = MV_DIR_FORWARD;
        s->mv_type = MV_TYPE_16X16;
        s->mv[0][0][0] = mx;
        s->mv[0][0][1] = my;
        *mb_type_ptr = MB_TYPE_L0 | MB_TYPE_16x16;
    } else {
//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));
        set_stat(ST_INTRA_MB);
        s->ac_pred = get_bits1(&s->gb);
        *mb_type_ptr = MB_TYPE_INTRA;
        if(s->inter_intra_pred){
            s->h263_aic_dir= get_vlc2(&s->gb, inter_intra_vlc.table, INTER_INTRA_VLC_BITS, 1);
//            printf("%d%d %d %d/", s->ac_pred, s->h263_aic_dir, s->mb_x, s->mb_y);
        }
        if(s->per_mb_rl_table && cbp){
            s->rl_table_index = decode012(&s->gb);
            s->rl_chroma_table_index = s->rl_table_index;
        }
    }

    s->dsp.clear_blocks(s->block[0]);
    for (i = 0; i < 6; i++) {
        if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
	{
	    av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
	    return -1;
	}
    }
    
    return 0;
}
//#define ERROR_DETAILS
static inline int msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
                              int n, int coded, const uint8_t *scan_table)
{

    return 0;
}

static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
{
    int cbp, code, i;
    
    if (s->pict_type == P_TYPE) {
        if (s->use_skip_mb_code) {
            if (get_bits1(&s->gb)) {
                /* skip mb */
                s->mb_intra = 0;
                for(i=0;i<6;i++)
                    s->block_last_index[i] = -1;
                s->mv_dir = MV_DIR_FORWARD;
                s->mv_type = MV_TYPE_16X16;
                s->mv[0][0][0] = 0;
                s->mv[0][0][1] = 0;
                s->mb_skipped = 1;
                return 0;
            }
        }

        if(s->msmpeg4_version==2)
            code = get_vlc2(&s->gb, v2_mb_type_vlc.table, V2_MB_TYPE_VLC_BITS, 1);
        else
            code = get_vlc2(&s->gb, v1_inter_cbpc_vlc.table, V1_INTER_CBPC_VLC_BITS, 3);
        if(code<0 || code>7){
            av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", code, s->mb_x, s->mb_y);
            return -1;
        }

        s->mb_intra = code >>2;
    
        cbp = code & 0x3;
    } else {
        s->mb_intra = 1;
        if(s->msmpeg4_version==2)
            cbp= get_vlc2(&s->gb, v2_intra_cbpc_vlc.table, V2_INTRA_CBPC_VLC_BITS, 1);
        else
            cbp= get_vlc2(&s->gb, v1_intra_cbpc_vlc.table, V1_INTRA_CBPC_VLC_BITS, 1);
        if(cbp<0 || cbp>3){
            av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
            return -1;
        }
    }

    if (!s->mb_intra) {
        int mx, my, cbpy;
        
        cbpy= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
        if(cbpy<0){
            av_log(s->avctx, AV_LOG_ERROR, "cbpy %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
            return -1;
        }

        cbp|= cbpy<<2;
        if(s->msmpeg4_version==1 || (cbp&3) != 3) cbp^= 0x3C;
        
        h263_pred_motion(s, 0, 0, &mx, &my);
        mx= msmpeg4v2_decode_motion(s, mx, 1);
        my= msmpeg4v2_decode_motion(s, my, 1);
        
        s->mv_dir = MV_DIR_FORWARD;
        s->mv_type = MV_TYPE_16X16;
        s->mv[0][0][0] = mx;
        s->mv[0][0][1] = my;
    } else {
        if(s->msmpeg4_version==2){
            s->ac_pred = get_bits1(&s->gb);
            cbp|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
        } else{
            s->ac_pred = 0;
            cbp|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
            if(s->pict_type==P_TYPE) cbp^=0x3C;
        }
    }

    s->dsp.clear_blocks(s->block[0]);
    for (i = 0; i < 6; i++) {
        if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
	{
             av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
             return -1;
	}
    }
    return 0;
}

static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
{
    int cbp, code, i;
    uint8_t *coded_val;
    uint32_t * const mb_type_ptr= &s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ];

    if (s->pict_type == P_TYPE) {
        set_stat(ST_INTER_MB);
        if (s->use_skip_mb_code) {
            if (get_bits1(&s->gb)) {
                /* skip mb */
                s->mb_intra = 0;
                for(i=0;i<6;i++)
                    s->block_last_index[i] = -1;
                s->mv_dir = MV_DIR_FORWARD;
                s->mv_type = MV_TYPE_16X16;
                s->mv[0][0][0] = 0;
                s->mv[0][0][1] = 0;
                s->mb_skipped = 1;
                *mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;

                return 0;
            }
        }
        
        code = get_vlc2(&s->gb, mb_non_intra_vlc[DEFAULT_INTER_INDEX].table, MB_NON_INTRA_VLC_BITS, 3);
        if (code < 0)
            return -1;
	//s->mb_intra = (code & 0x40) ? 0 : 1;
	s->mb_intra = (~code & 0x40) >> 6;
            
        cbp = code & 0x3f;
    } else {
        set_stat(ST_INTRA_MB);
        s->mb_intra = 1;
        code = get_vlc2(&s->gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
        if (code < 0)
            return -1;
        /* predict coded block pattern */
        cbp = 0;
        for(i=0;i<6;i++) {
            int val = ((code >> (5 - i)) & 1);
            if (i < 4) {
                int pred = coded_block_pred(s, i, &coded_val);
                val = val ^ pred;
                *coded_val = val;
            }
            cbp |= val << (5 - i);
        }
    }

    if (!s->mb_intra) {
        int mx, my;
//printf("P at %d %d\n", s->mb_x, s->mb_y);
        if(s->per_mb_rl_table && cbp){
            s->rl_table_index = decode012(&s->gb);
            s->rl_chroma_table_index = s->rl_table_index;
        }
        set_stat(ST_MV);
        h263_pred_motion(s, 0, 0, &mx, &my);
        if (msmpeg4_decode_motion(s, &mx, &my) < 0)
            return -1;
        s->mv_dir = MV_DIR_FORWARD;
        s->mv_type = MV_TYPE_16X16;
        s->mv[0][0][0] = mx;
        s->mv[0][0][1] = my;
        *mb_type_ptr = MB_TYPE_L0 | MB_TYPE_16x16;
    } else {
//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));
        set_stat(ST_INTRA_MB);
        s->ac_pred = get_bits1(&s->gb);
        *mb_type_ptr = MB_TYPE_INTRA;
        if(s->inter_intra_pred){
            s->h263_aic_dir= get_vlc2(&s->gb, inter_intra_vlc.table, INTER_INTRA_VLC_BITS, 1);
//            printf("%d%d %d %d/", s->ac_pred, s->h263_aic_dir, s->mb_x, s->mb_y);
        }
        if(s->per_mb_rl_table && cbp){
            s->rl_table_index = decode012(&s->gb);
            s->rl_chroma_table_index = s->rl_table_index;
        }
    }

    s->dsp.clear_blocks(s->block[0]);
    for (i = 0; i < 6; i++) {
        if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
	{
	    av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
	    return -1;
	}
    }
    
    return 0;
}
//#define ERROR_DETAILS

static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
{
    int level, pred;

Return to bug 119014

Lines 1479-1664 Link Here

(-)msmpeg4.c (-180 / +181 lines)
1479	return val;	1479	return val;
1480	}	1480	}
1481		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	}
1661	//#define ERROR_DETAILS
1662	static inline int msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,	1482	static inline int msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
1663	int n, int coded, const uint8_t *scan_table)	1483	int n, int coded, const uint8_t *scan_table)
1664	{	1484	{
Lines 1909-1914 Link Here
1909	return 0;	1729	return 0;
1910	}	1730	}
1911		1731
		1732	static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
		1733	{
		1734	int cbp, code, i;
		1735
		1736	if (s->pict_type == P_TYPE) {
		1737	if (s->use_skip_mb_code) {
		1738	if (get_bits1(&s->gb)) {
		1739	/* skip mb */
		1740	s->mb_intra = 0;
		1741	for(i=0;i<6;i++)
		1742	s->block_last_index[i] = -1;
		1743	s->mv_dir = MV_DIR_FORWARD;
		1744	s->mv_type = MV_TYPE_16X16;
		1745	s->mv[0][0][0] = 0;
		1746	s->mv[0][0][1] = 0;
		1747	s->mb_skipped = 1;
		1748	return 0;
		1749	}
		1750	}
		1751
		1752	if(s->msmpeg4_version==2)
		1753	code = get_vlc2(&s->gb, v2_mb_type_vlc.table, V2_MB_TYPE_VLC_BITS, 1);
		1754	else
		1755	code = get_vlc2(&s->gb, v1_inter_cbpc_vlc.table, V1_INTER_CBPC_VLC_BITS, 3);
		1756	if(code<0 \|\| code>7){
		1757	av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", code, s->mb_x, s->mb_y);
		1758	return -1;
		1759	}
		1760
		1761	s->mb_intra = code >>2;
		1762
		1763	cbp = code & 0x3;
		1764	} else {
		1765	s->mb_intra = 1;
		1766	if(s->msmpeg4_version==2)
		1767	cbp= get_vlc2(&s->gb, v2_intra_cbpc_vlc.table, V2_INTRA_CBPC_VLC_BITS, 1);
		1768	else
		1769	cbp= get_vlc2(&s->gb, v1_intra_cbpc_vlc.table, V1_INTRA_CBPC_VLC_BITS, 1);
		1770	if(cbp<0 \|\| cbp>3){
		1771	av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
		1772	return -1;
		1773	}
		1774	}
		1775
		1776	if (!s->mb_intra) {
		1777	int mx, my, cbpy;
		1778
		1779	cbpy= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
		1780	if(cbpy<0){
		1781	av_log(s->avctx, AV_LOG_ERROR, "cbpy %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
		1782	return -1;
		1783	}
		1784
		1785	cbp\|= cbpy<<2;
		1786	if(s->msmpeg4_version==1 \|\| (cbp&3) != 3) cbp^= 0x3C;
		1787
		1788	h263_pred_motion(s, 0, 0, &mx, &my);
		1789	mx= msmpeg4v2_decode_motion(s, mx, 1);
		1790	my= msmpeg4v2_decode_motion(s, my, 1);
		1791
		1792	s->mv_dir = MV_DIR_FORWARD;
		1793	s->mv_type = MV_TYPE_16X16;
		1794	s->mv[0][0][0] = mx;
		1795	s->mv[0][0][1] = my;
1796	} else {
1797	if(s->msmpeg4_version==2){
1798	s->ac_pred = get_bits1(&s->gb);
1799	cbp\|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
1800	} else{
1801	s->ac_pred = 0;
1802	cbp\|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
1803	if(s->pict_type==P_TYPE) cbp^=0x3C;
1804	}
1805	}
1806
1807	s->dsp.clear_blocks(s->block[0]);
1808	for (i = 0; i < 6; i++) {
1809	if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
1810	{
1811	av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1812	return -1;
1813	}
1814	}
1815	return 0;
1816	}
1817
1818	static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1819	{
1820	int cbp, code, i;
1821	uint8_t *coded_val;
1822	uint32_t * const mb_type_ptr= &s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ];
1823
1824	if (s->pict_type == P_TYPE) {
1825	set_stat(ST_INTER_MB);
1826	if (s->use_skip_mb_code) {
1827	if (get_bits1(&s->gb)) {
1828	/* skip mb */
1829	s->mb_intra = 0;
1830	for(i=0;i<6;i++)
1831	s->block_last_index[i] = -1;
1832	s->mv_dir = MV_DIR_FORWARD;
1833	s->mv_type = MV_TYPE_16X16;
1834	s->mv[0][0][0] = 0;
1835	s->mv[0][0][1] = 0;
1836	s->mb_skipped = 1;
1837	*mb_type_ptr = MB_TYPE_SKIP \| MB_TYPE_L0 \| MB_TYPE_16x16;
1838
1839	return 0;
1840	}
1841	}
1842
1843	code = get_vlc2(&s->gb, mb_non_intra_vlc[DEFAULT_INTER_INDEX].table, MB_NON_INTRA_VLC_BITS, 3);
1844	if (code < 0)
1845	return -1;
1846	//s->mb_intra = (code & 0x40) ? 0 : 1;
1847	s->mb_intra = (~code & 0x40) >> 6;
1848
1849	cbp = code & 0x3f;
1850	} else {
1851	set_stat(ST_INTRA_MB);
1852	s->mb_intra = 1;
1853	code = get_vlc2(&s->gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
1854	if (code < 0)
1855	return -1;
1856	/* predict coded block pattern */
1857	cbp = 0;
1858	for(i=0;i<6;i++) {
1859	int val = ((code >> (5 - i)) & 1);
1860	if (i < 4) {
1861	int pred = coded_block_pred(s, i, &coded_val);
1862	val = val ^ pred;
1863	*coded_val = val;
1864	}
1865	cbp \|= val << (5 - i);
1866	}
1867	}
1868
1869	if (!s->mb_intra) {
1870	int mx, my;
1871	//printf("P at %d %d\n", s->mb_x, s->mb_y);
1872	if(s->per_mb_rl_table && cbp){
1873	s->rl_table_index = decode012(&s->gb);
1874	s->rl_chroma_table_index = s->rl_table_index;
1875	}
1876	set_stat(ST_MV);
1877	h263_pred_motion(s, 0, 0, &mx, &my);
1878	if (msmpeg4_decode_motion(s, &mx, &my) < 0)
1879	return -1;
1880	s->mv_dir = MV_DIR_FORWARD;
1881	s->mv_type = MV_TYPE_16X16;
1882	s->mv[0][0][0] = mx;
1883	s->mv[0][0][1] = my;
1884	*mb_type_ptr = MB_TYPE_L0 \| MB_TYPE_16x16;
1885	} else {
1886	//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));
1887	set_stat(ST_INTRA_MB);
1888	s->ac_pred = get_bits1(&s->gb);
1889	*mb_type_ptr = MB_TYPE_INTRA;
1890	if(s->inter_intra_pred){
1891	s->h263_aic_dir= get_vlc2(&s->gb, inter_intra_vlc.table, INTER_INTRA_VLC_BITS, 1);
1892	// printf("%d%d %d %d/", s->ac_pred, s->h263_aic_dir, s->mb_x, s->mb_y);
1893	}
1894	if(s->per_mb_rl_table && cbp){
1895	s->rl_table_index = decode012(&s->gb);
1896	s->rl_chroma_table_index = s->rl_table_index;
1897	}
1898	}
1899
1900	s->dsp.clear_blocks(s->block[0]);
1901	for (i = 0; i < 6; i++) {
1902	if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
1903	{
1904	av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1905	return -1;
1906	}
1907	}
1908
1909	return 0;
1910	}
1911	//#define ERROR_DETAILS
1912
1912	static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)	1913	static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
1913	{	1914	{
1914	int level, pred;	1915	int level, pred;