encodevop.c

adi bf533视频编码程序

    Ipp16s         dcA, dcB, dcC;
    Ipp16s         *predAcA, *predAcC;
    int  sum0 = 0, sum1 = 0;
    dcA = *mbCurr->predDcA[blockNum];
    dcB = *mbCurr->predDcB[blockNum];
    dcC = *mbCurr->predDcC[blockNum];
    dc = *dcCurr;
    if (abs(dcA - dcB) < abs(dcB - dcC)) {
        predDir = IPP_VIDEO_VERTICAL;
        *dcCurr = (Ipp16s)(dc / dcScaler - (dcC + (dcScaler >> 1)) / dcScaler);
        mbCurr->dct_dc[blockNum] = (Ipp16s)((dc / dcScaler) * dcScaler);
    } else {
        predDir = IPP_VIDEO_HORIZONTAL;
        *dcCurr = (Ipp16s)(dc / dcScaler - (dcA + (dcScaler >> 1)) / dcScaler);
        mbCurr->dct_dc[blockNum] = (Ipp16s)((dc / dcScaler) * dcScaler);
    }
    zC = zA = 0;
    for (k = 1; k < 8; k ++) {
        mbCurr->dct_acC[blockNum][k] = dcCurr[k];
        if (dcCurr[k])
            zC = 1;
        mbCurr->dct_acA[blockNum][k] = dcCurr[k*8];
        if (dcCurr[k*8])
            zA = 1;
    }
    mbCurr->dct_acC[blockNum][0] = (Ipp16s)zC;
    mbCurr->dct_acA[blockNum][0] = (Ipp16s)zA;
    if (predAC) {
        predAcA = mbCurr->predAcA[blockNum];
        predAcC = mbCurr->predAcC[blockNum];
//        predQuantA = *mbCurr->predQuantA[blockNum];
//        predQuantC = *mbCurr->predQuantC[blockNum];
        
        if (predDir == IPP_VIDEO_VERTICAL && predAcC) {
            if (predAcC[0])
                for (k = 1; k < 8; k ++) {
                    sum0 += abs(dcCurr[k]);
                    dcCurr[k] = (Ipp16s)(dcCurr[k] - predAcC[k]);
                    sum1 += abs(dcCurr[k]);
                }
        }
        
        if (predDir == IPP_VIDEO_HORIZONTAL && predAcA) {
            if (predAcA[0])
                for (k = 1; k < 8; k ++) {
                    sum0 += abs(dcCurr[k*8]);
                    dcCurr[k*8] = (Ipp16s)(dcCurr[k*8] - predAcA[k]);
                    sum1 += abs(dcCurr[k*8]);
                }
        }
        *pSum0 += sum0;
        *pSum1 += sum1;
    } else
        predDir = IPP_VIDEO_NONE;
    *predictDir = predDir;
}
*************************************/
#if 0
static void mp4_PredictIntraDCAC(struct mp4_MacroBlock *mbCurr, short left, short topleft, short top, short *mbdc, Ipp16s *dcCurr, int dcScaler, int blockNum, int *predictDir, int predAC, int *pSum0, int *pSum1)
{
    int            predDir, dc, k, zC, zA;
//    Ipp16s         dcA, dcB, dcC;
    Ipp16s         *predAcA, *predAcC;
    int  sum0 = 0, sum1 = 0;
//    dcA = *mbCurr->predDcA[blockNum];
//    dcB = *mbCurr->predDcB[blockNum];
//    dcC = *mbCurr->predDcC[blockNum];
    dc = *dcCurr;
    if (abs(left - topleft) < abs(topleft - top)) {
        predDir = IPP_VIDEO_VERTICAL;
        *dcCurr = (Ipp16s)(dc / dcScaler - (top + (dcScaler >> 1)) / dcScaler);
//        mbCurr->dct_dc[blockNum] = (Ipp16s)((dc / dcScaler) * dcScaler);
    } else {
        predDir = IPP_VIDEO_HORIZONTAL;
        *dcCurr = (Ipp16s)(dc / dcScaler - (left + (dcScaler >> 1)) / dcScaler);
//        mbCurr->dct_dc[blockNum] = (Ipp16s)((dc / dcScaler) * dcScaler);
    }
	mbdc[blockNum] = (Ipp16s)((dc / dcScaler) * dcScaler);
	
    zC = zA = 0;
    for (k = 1; k < 8; k ++) {
        mbCurr->dct_acC[blockNum][k] = dcCurr[k];
        if (dcCurr[k])
            zC = 1;
        mbCurr->dct_acA[blockNum][k] = dcCurr[k*8];
        if (dcCurr[k*8])
            zA = 1;
    }
    mbCurr->dct_acC[blockNum][0] = (Ipp16s)zC;
    mbCurr->dct_acA[blockNum][0] = (Ipp16s)zA;
    if (predAC) {
        predAcA = mbCurr->predAcA[blockNum];
        predAcC = mbCurr->predAcC[blockNum];
//        predQuantA = *mbCurr->predQuantA[blockNum];
//        predQuantC = *mbCurr->predQuantC[blockNum];
        
        if (predDir == IPP_VIDEO_VERTICAL && predAcC) {
            if (predAcC[0])
                for (k = 1; k < 8; k ++) {
                    sum0 += abs(dcCurr[k]);
                    dcCurr[k] = (Ipp16s)(dcCurr[k] - predAcC[k]);
                    sum1 += abs(dcCurr[k]);
                }
        }
        
        if (predDir == IPP_VIDEO_HORIZONTAL && predAcA) {
            if (predAcA[0])
                for (k = 1; k < 8; k ++) {
                    sum0 += abs(dcCurr[k*8]);
                    dcCurr[k*8] = (Ipp16s)(dcCurr[k*8] - predAcA[k]);
                    sum1 += abs(dcCurr[k*8]);
                }
        }
        *pSum0 += sum0;
        *pSum1 += sum1;
    } else
        predDir = IPP_VIDEO_NONE;
    *predictDir = predDir;
}
#endif	//end of if 0

static void mp4_PredictIntraDCAC1(short leftDC, short topleftDC, short topDC, short *cur_mbdc, 
								 short *leftAC, short *topAC, short *mbacA, short *mbacC,
								 short *dcCurr, int dcScaler, int *predictDir, int predAC, int *pSum0, int *pSum1)
{
    int  predDir, dc, k, zC, zA;
    int  sum0 = 0, sum1 = 0;
    dc = *dcCurr;
    if (abs(leftDC - topleftDC) < abs(topleftDC - topDC)) {
        predDir = IPP_VIDEO_VERTICAL;
        *dcCurr = (Ipp16s)(dc / dcScaler - (topDC + (dcScaler >> 1)) / dcScaler);
    } else {
        predDir = IPP_VIDEO_HORIZONTAL;
        *dcCurr = (Ipp16s)(dc / dcScaler - (leftDC + (dcScaler >> 1)) / dcScaler);
    }
	*cur_mbdc = (Ipp16s)((dc / dcScaler) * dcScaler);
	
    zC = zA = 0;
    for (k = 1; k < 8; k ++) {
        mbacC[k] = dcCurr[k];
        if (dcCurr[k])
            zC = 1;
        mbacA[k] = dcCurr[k*8];
        if (dcCurr[k*8])
            zA = 1;
    }
    mbacC[0] = (Ipp16s)zC;
    mbacA[0] = (Ipp16s)zA;
    if (predAC) {
        
        if (predDir == IPP_VIDEO_VERTICAL) {
            if (topAC[0])
                for (k = 1; k < 8; k ++) {
                    sum0 += abs(dcCurr[k]);
                    dcCurr[k] = (Ipp16s)(dcCurr[k] - topAC[k]);
                    sum1 += abs(dcCurr[k]);
                }
        }
        
        if (predDir == IPP_VIDEO_HORIZONTAL) {
            if (leftAC[0])
                for (k = 1; k < 8; k ++) {
                    sum0 += abs(dcCurr[k*8]);
                    dcCurr[k*8] = (Ipp16s)(dcCurr[k*8] - leftAC[k]);
                    sum1 += abs(dcCurr[k*8]);
                }
        }
        *pSum0 += sum0;
        *pSum1 += sum1;
    } else
        predDir = IPP_VIDEO_NONE;
    *predictDir = predDir;
}


static void mp4_PredictIntraDC(short left, short topleft, short top, short *mbdc, Ipp16s *dcCurr, int dcScaler, int *predictDir)
{
    int  predDir, dc, k;
    dc = *dcCurr;
    
    if (abs(left - topleft) < abs(topleft - top)) {
        predDir = IPP_VIDEO_VERTICAL;
        *dcCurr = (Ipp16s)(dc / dcScaler - (top + (dcScaler >> 1)) / dcScaler);
    } else {
        predDir = IPP_VIDEO_HORIZONTAL;
        *dcCurr = (Ipp16s)(dc / dcScaler - (left + (dcScaler >> 1)) / dcScaler);
    }
	*mbdc = (Ipp16s)((dc / dcScaler) * dcScaler);
	
	predDir = IPP_VIDEO_NONE;
    *predictDir = predDir;
}


/***********************
static void mp4_RestoreAC(struct mp4_MacroBlock *mbCurr, Ipp16s *dcCurr, int blockNum, int predDir)
{
    int            k, predQuantA, predQuantC;
    Ipp16s         *predAcA, *predAcC;

    predAcA = mbCurr->predAcA[blockNum];
    predAcC = mbCurr->predAcC[blockNum];
    predQuantA = *mbCurr->predQuantA[blockNum];
    predQuantC = *mbCurr->predQuantC[blockNum];
    if (predDir == IPP_VIDEO_VERTICAL && predAcC) {
        if (predAcC[0] != 0)
            if (predQuantC == mbCurr->quant)
                for (k = 1; k < 8; k ++)
                    dcCurr[k] = (Ipp16s)(dcCurr[k] + predAcC[k]);
            else
                for (k = 1; k < 8; k ++)
                    dcCurr[k] = (Ipp16s)(dcCurr[k] + (predAcC[k] * predQuantC + ((mbCurr->quant) >> 1)) / mbCurr->quant);
    }
    if (predDir == IPP_VIDEO_HORIZONTAL && predAcA) {
        if (predAcA[0] != 0)
            if (predQuantA == mbCurr->quant)
                for (k = 1; k < 8; k ++)
                    dcCurr[k*8] = (Ipp16s)(dcCurr[k*8] + predAcA[k]);
            else
                for (k = 1; k < 8; k ++)
                    dcCurr[k*8] = (Ipp16s)(dcCurr[k*8] + (predAcA[k] * predQuantA + ((mbCurr->quant) >> 1)) / mbCurr->quant);
    }
}
*************************/

#if 0
static void mp4_RestoreAC(struct mp4_MacroBlock *mbCurr, Ipp16s *dcCurr, int blockNum, int predDir)
{
    int            k;
    Ipp16s         *predAcA, *predAcC;

    predAcA = mbCurr->predAcA[blockNum];
    predAcC = mbCurr->predAcC[blockNum];
    if (predDir == IPP_VIDEO_VERTICAL && predAcC) {
        if (predAcC[0] != 0)
            for (k = 1; k < 8; k ++)
                dcCurr[k] = (Ipp16s)(dcCurr[k] + predAcC[k]);
    }
    if (predDir == IPP_VIDEO_HORIZONTAL && predAcA) {
        if (predAcA[0] != 0)
            for (k = 1; k < 8; k ++)
                dcCurr[k*8] = (Ipp16s)(dcCurr[k*8] + predAcA[k]);
    }
}
#endif

static void mp4_RestoreAC(short *leftAC, short *topAC, Ipp16s *dcCurr, int predDir)
{
    int k;
    
    if (predDir == IPP_VIDEO_VERTICAL) {
        if (topAC[0] != 0)
            for (k = 1; k < 8; k ++)
                dcCurr[k] = (Ipp16s)(dcCurr[k] + topAC[k]);
    }
    if (predDir == IPP_VIDEO_HORIZONTAL) {
        if (leftAC[0] != 0)
            for (k = 1; k < 8; k ++)
                dcCurr[k*8] = (Ipp16s)(dcCurr[k*8] + leftAC[k]);
    }
}





void EncodeBlockIntra_MPEG4(Ipp16s *coeffs, int use_dc_vlc, int numBlock, int pat, int predDir)
{
    if (use_dc_vlc) {
	    xhEncode_IntraDCVLC_MPEG4_16s1u(coeffs[0], numBlock < 4 ? IPP_VIDEO_LUMINANCE : IPP_VIDEO_CHROMINANCE);

              if (!pat)
            return;
    }
      xhEncode_IntraACVLC_MPEG4_16s1u(coeffs, predDir, use_dc_vlc);
    
}


void EncodeBlockInter_MPEG4(Ipp16s *coeffs, int pat)
{
    if (pat)
        xhEncode_InterVLC_MPEG4_16s1u (coeffs);
}


// for iDCT with DC only
static void mp4_Set8x8(Ipp8u *p, int step, int level)
{
    int    i, j;
    if (level < 0) level = 0; if (level > 255) level = 255;
    for (i = 0; i < 8; i ++) {
       for (j = 0; j < 8; j ++)
           p[j] = (Ipp8u)level;
       p += step;
    }
}



#if 1
#define mp4_DCT_Quant_Intra_MPEG4(p, step, numBlock) \
	convert_8u16s(p, coeffMB + numBlock*64, step); \
    xhDCT8x8Fwd_16s_C1I(coeffMB+numBlock*64,coeff,temp); \
    if (VOL.quant_type) \