mp4decvopi.c

这是在PCA下的基于IPP库示例代码例子,在网上下了IPP的库之后,设置相关参数就可以编译该代码.

                            // dc_vlc_thr is not used for Aux
                            dcVLC = 1;
                            if (mp4_GetBit(pInfo)) {
                                mp4_Set16x16_8u(pA[k], stepY, 255);
                            } else {
                                int  cbpa;
                                MacroBlock.ac_pred_flag = mp4_GetBit(pInfo);
                                if (mp4_DecodeCBPY_I_Shape(pInfo, nOpaq, &cbpa) != MP4_STATUS_OK)
                                    return MP4_STATUS_ERROR;
                                cbpa = 15 - cbpa;
                                nOpaq = (curShapeInfo->opaque & 1) + ((curShapeInfo->opaque & 2) >> 1) + ((curShapeInfo->opaque & 4) >> 2) + ((curShapeInfo->opaque & 8) >> 3);
                                nOpaq --;
                                if (curShapeInfo->opaque & 1) {
                                    mp4_DecodeBlockIntra_MPEG4(MacroBlock.ac_pred_flag, cbpa & (1 << nOpaq), pA[k], stepY, ppbrA[k], ppbcA[k], 0);
                                    nOpaq --;
                                } else {
                                    ppbcA[k][0] = ppbrA[k][0];
                                    ppbrA[k][0] = -1;
                                }
                                if (curShapeInfo->opaque & 2) {
                                    mp4_DecodeBlockIntra_MPEG4(MacroBlock.ac_pred_flag, cbpa & (1 << nOpaq), pA[k]+8, stepY, ppbrA[k]+8, ppbcA[k], 1);
                                    nOpaq --;
                                } else {
                                    {
                                        Ipp16s tmp;
                                        tmp = ppbcA[k][8];
                                        ppbcA[k][8] = ppbrA[k][8-16];
                                        ppbrA[k][8-16] = tmp;
                                    }
                                    ppbcA[k][0] = ppbrA[k][8];
                                    ppbrA[k][8] = -1;
                                }
                                if (curShapeInfo->opaque & 4) {
                                    mp4_DecodeBlockIntra_MPEG4(MacroBlock.ac_pred_flag, cbpa & (1 << nOpaq), pA[k]+pYoff2, stepY, ppbrA[k], ppbcA[k]+8, 2);
                                    nOpaq --;
                                } else {
                                    ppbcA[k][8] = ppbrA[k][0];
                                    ppbrA[k][0] = -1;
                                }
                                if (curShapeInfo->opaque & 8) {
                                    mp4_DecodeBlockIntra_MPEG4(MacroBlock.ac_pred_flag, cbpa & (1 << nOpaq), pA[k]+pYoff3, stepY, ppbrA[k]+8, ppbcA[k]+8, 3);
                                    nOpaq --;
                                } else {
                                    ppbcA[k][8] = -1;
                                }
                            }
                        }
                    }
                }
                mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nMB);
                mbCurr ++;
                if (mbCurr == nmb) {
                    // skip stuffing
                    while (mp4_ShowBits9(pInfo, 9) == 1)
                        mp4_FlushBits(pInfo, 9);
                    return MP4_STATUS_OK;
                }
                // update predict buffers
                ppbq ++; ppbq[0] = (Ipp8u)quant;
                ppbrY += 16;
                mbInVideoPacket ++;
                colNum ++;
                if (colNum == mbPerRow) {
                    colNum = 0;
                    rowNum ++;
                    // needed for ippVC predict mechanism
                    ppbrY[-8] = ppbcY[8];   / * Update DC part of last MB per line * /
                    for (k = 0; k < nAux; k ++)
                        ppbrA[k][-8] = ppbcA[k][8];   / * Update DC part of last MB per line * /
                } else {
                    pY += 16; pCr += 8; pCb += 8;
                    ppbrCb += 8; ppbrCr += 8;
                    pB += 16;
                    for (k = 0; k < nAux; k ++)
                        pA[k] += 16;
                }
                curShapeInfo ++;
                if (!pInfo->VisualObject.VideoObject.resync_marker_disable)
                    if (mp4_DecodeVideoPacket(pInfo, &quant))
                        break;
            }
        }
    }
*/
    return MP4_STATUS_OK;
}


/*
//  decode IVOP
*/
mp4_Status mp4_DecodeVOP_I(mp4_Info* pInfo)
{
    int     quant, quantPred, dcVLC, mb_type, cbpc, cbpy, ac_pred_flag;
    int     i, j, nmb, stepYc, stepCbc, stepCrc, stepFc[6], mbCurr, mbInVideoPacket, colNum, rowNum, mbPerRow, mbPerCol;
    Ipp8u  *pFc[6];

    stepYc = pInfo->VisualObject.cFrame.stepY;
    stepCbc = pInfo->VisualObject.cFrame.stepCb;
    stepCrc = pInfo->VisualObject.cFrame.stepCr;
    mbPerRow = pInfo->VisualObject.VideoObject.MacroBlockPerRow;
    mbPerCol = pInfo->VisualObject.VideoObject.MacroBlockPerCol;
    stepFc[0] = stepFc[1] = stepFc[2] = stepFc[3] = stepYc; stepFc[4] = stepCbc; stepFc[5] = stepCrc;
    pFc[0] = pInfo->VisualObject.cFrame.pY; pFc[1] = pInfo->VisualObject.cFrame.pY + 8;
    pFc[2] = pInfo->VisualObject.cFrame.pY + 8 * stepYc; pFc[3] = pInfo->VisualObject.cFrame.pY + 8 * stepYc + 8;
    pFc[4] = pInfo->VisualObject.cFrame.pCb; pFc[5] = pInfo->VisualObject.cFrame.pCr;
// decode short_video_header I-VOP
    if (pInfo->VisualObject.VideoObject.short_video_header) {
        quant = pInfo->VisualObject.VideoObject.VideoObjectPlaneH263.vop_quant;
        nmb = 0;
        pInfo->VisualObject.VideoObject.VideoObjectPlaneH263.gob_number = 0;
        for (i = 0; i < mbPerCol; i ++) {
            for (j = 0; j < mbPerRow; j ++) {
                do {
                    if (mp4_DecodeMCBPC_I(pInfo, &mb_type, &cbpc) != MP4_STATUS_OK)
                        return MP4_STATUS_ERROR;
                } while (mb_type == IPPVC_MB_STUFFING);
                if (mp4_DecodeCBPY_I(pInfo, &cbpy) != MP4_STATUS_OK)
                    return MP4_STATUS_ERROR;
                if (mb_type == IPPVC_MBTYPE_INTRA_Q)
                    mp4_UpdateQuant(pInfo, quant);
                if (mp4_DecodeIntraMB_SVH(pInfo, (cbpy << 2) + cbpc, quant, pFc, stepFc) != MP4_STATUS_OK) {
                    mp4_Error("Error when decode coefficients of Intra block");
                    return MP4_STATUS_ERROR;
                }
                pFc[0] += 16; pFc[1] += 16; pFc[2] += 16; pFc[3] += 16; pFc[4] += 8; pFc[5] += 8;
                mp4_CheckDecodeGOB_SVH(pInfo, nmb, nmb, i, quant);
                mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nMB);
            }
            pFc[0] += 2 * MP4_NUM_EXT_MB * 16 + (stepYc << 4) - stepYc;
            pFc[1] += 2 * MP4_NUM_EXT_MB * 16 + (stepYc << 4) - stepYc;
            pFc[2] += 2 * MP4_NUM_EXT_MB * 16 + (stepYc << 4) - stepYc;
            pFc[3] += 2 * MP4_NUM_EXT_MB * 16 + (stepYc << 4) - stepYc;
            pFc[4] += 2 * MP4_NUM_EXT_MB * 8 + (stepCbc << 3) - stepCbc;
            pFc[5] += 2 * MP4_NUM_EXT_MB * 8 + (stepCrc << 3) - stepCrc;
        }
        mp4_AlignBits(pInfo);
        return MP4_STATUS_OK;
    }
    quant = pInfo->VisualObject.VideoObject.VideoObjectPlane.quant;
    nmb = pInfo->VisualObject.VideoObject.MacroBlockPerVOP;
    mbCurr = 0;
    colNum = rowNum = 0;
    if (pInfo->VisualObject.VideoObject.sprite_enable != MP4_SPRITE_STATIC)
        ippsZero_8u((Ipp8u*)pInfo->VisualObject.VideoObject.MBinfo, nmb * sizeof(mp4_MacroBlock));
// decode data_partitioned I-VOP
    if (pInfo->VisualObject.VideoObject.data_partitioned) {
        for (;;) {
            mp4_DataPartMacroBlock *pMBdp;
            // reset Intra prediction buffer on new Video_packet
            mp4_ResetIntraPredBuffer(pInfo);
            mbInVideoPacket = 0;
            pMBdp = &pInfo->VisualObject.VideoObject.DataPartBuff[mbCurr];
            // decode mb_type/cbpc/dquant/DC part
            for (;;) {
                if (mp4_DecodeMCBPC_I(pInfo, &mb_type, &cbpc) != MP4_STATUS_OK)
                    return MP4_STATUS_ERROR;
                if (mb_type != IPPVC_MB_STUFFING) {
                    quantPred = quant;
                    if (mb_type == IPPVC_MBTYPE_INTRA_Q)
                        mp4_UpdateQuant(pInfo, quant);
                    if (mbInVideoPacket == 0)
                        quantPred = quant;
                    dcVLC = (quantPred < mp4_DC_vlc_Threshold[pInfo->VisualObject.VideoObject.VideoObjectPlane.intra_dc_vlc_thr]) ? 1 : 0;
                    if (dcVLC) {
                        for (i = 0; i < 6; i ++) {
                            if (ippiDecodeDCIntra_MPEG4_1u16s(&pInfo->bufptr, &pInfo->bitoff, &pMBdp->dct_dc[i], (i < 4) ? IPPVC_BLOCK_LUMA : IPPVC_BLOCK_CHROMA) != ippStsNoErr) {
                                mp4_Error("Error when decode coefficients of Intra block");
                                return MP4_STATUS_ERROR;
                            }
                        }
                    }
                    pMBdp->quant = (Ipp8u)quant;
                    pMBdp->type = (Ipp8u)mb_type;
                    pMBdp->pat = (Ipp8u)cbpc;
                    pMBdp ++;
                    mbInVideoPacket ++;
                }
                if (mp4_ShowBits(pInfo, 19) == MP4_DC_MARKER) {
                    mp4_GetBits(pInfo, 19);
                    break;
                }
            }
            pMBdp = &pInfo->VisualObject.VideoObject.DataPartBuff[mbCurr];
            // decode ac_pred_flag/cbpy part
            for (i = 0; i < mbInVideoPacket; i ++) {
                pMBdp[i].ac_pred_flag = (Ipp8u)mp4_GetBit(pInfo);
                if (mp4_DecodeCBPY_I(pInfo, &cbpy) != MP4_STATUS_OK)
                    return MP4_STATUS_ERROR;
                pMBdp[i].pat = (Ipp8u)((cbpy << 2) + pMBdp[i].pat);
            }
            // decode AC part and reconstruct macroblocks
            for (i = 0; i < mbInVideoPacket; i ++) {
                if (colNum == 0) {
                    // reset B-prediction blocks on new row
                    mp4_ResetIntraPredBblock(pInfo);
                }
                quant = pMBdp[i].quant;
                quantPred = (i == 0) ? quant : pMBdp[i-1].quant;
                dcVLC = (quantPred < mp4_DC_vlc_Threshold[pInfo->VisualObject.VideoObject.VideoObjectPlane.intra_dc_vlc_thr]) ? 1 : 0;
                ac_pred_flag = pMBdp[i].ac_pred_flag;
                if (mp4_DecodeIntraMB_DP(pInfo, pMBdp[i].dct_dc, colNum, pMBdp[i].pat, quant, dcVLC, ac_pred_flag, pFc, stepFc) != MP4_STATUS_OK) {
                    mp4_Error("Error when decode coefficients of Intra block");
                    return MP4_STATUS_ERROR;
                }
                mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nMB);
                colNum ++;
                if (colNum == mbPerRow) {
                    colNum = 0;
                    rowNum ++;
                    pFc[0] += 3 * MP4_NUM_EXT_MB * 16 + (stepYc << 4) - stepYc;
                    pFc[1] += 3 * MP4_NUM_EXT_MB * 16 + (stepYc << 4) - stepYc;
                    pFc[2] += 3 * MP4_NUM_EXT_MB * 16 + (stepYc << 4) - stepYc;
                    pFc[3] += 3 * MP4_NUM_EXT_MB * 16 + (stepYc << 4) - stepYc;
                    pFc[4] += 3 * MP4_NUM_EXT_MB * 8 + (stepCbc << 3) - stepCbc;
                    pFc[5] += 3 * MP4_NUM_EXT_MB * 8 + (stepCrc << 3) - stepCrc;
                } else {
                    pFc[0] += 16; pFc[1] += 16; pFc[2] += 16; pFc[3] += 16; pFc[4] += 8; pFc[5] += 8;
                }
            }
            mbCurr += mbInVideoPacket;
            if (mbCurr == nmb)
                break;
            if (!pInfo->VisualObject.VideoObject.resync_marker_disable) {
                int  found;
                if (mp4_DecodeVideoPacket(pInfo, &quant, &found) == MP4_STATUS_OK) {
                    if (!found)
                        break;
                } else
                    return MP4_STATUS_ERROR;
            }
        }
        return MP4_STATUS_OK;
    }
// decode not data partitioned I-VOP
    else {
        int     stepY = stepYc, dct_type = 0, pYoff23 = 8 * stepYc;
        for (;;) {
            // reset Intra prediction buffer on new Video_packet
            mp4_ResetIntraPredBuffer(pInfo);
            mbInVideoPacket = 0;
            // decode blocks
            for (;;) {
                if (colNum == 0) {