umc_vc1_enc_debug.cpp

audio-video-codecs.rar语音编解码器

        case (VC1_ENC_P_MB_INTRA):
        case (VC1_ENC_B_MB_INTRA):
            break;

        case (VC1_ENC_P_MB_1MV):
        case (VC1_ENC_B_MB_F):
        case (VC1_ENC_P_MB_SKIP):
        case (VC1_ENC_B_MB_SKIP_F):

            for(blk_num = 0; blk_num < 6; blk_num++)
            {
                WriteParams(-1,VC1_ENC_PRED,"Block %d\n", blk_num);

                WriteParams(-1,VC1_ENC_PRED,"Before Interpolation %d, %d, forward %d\n",
                    pCurrMB->Block[blk_num].MV[0][0] + (XPos * pixelInBlk[blk_num] + Xshift[blk_num])*4,
                    pCurrMB->Block[blk_num].MV[1][0] + (YPos * pixelInBlk[blk_num] + Yshift[blk_num])*4 , 0);

                if(blk_num < 4)
                    WriteParams(-1,VC1_ENC_PRED," MVMode1MVHalfPelBilinear\n");

                WriteParams(-1,VC1_ENC_PRED,"%d\t %d\t %d\n",pCurrMB->Block[blk_num].FSrc,
                    (pCurrMB->Block[blk_num].MV[0][0] + (XPos * pixelInBlk[blk_num] + Xshift[blk_num])*4)>>2,
                    (pCurrMB->Block[blk_num].MV[1][0] + (YPos * pixelInBlk[blk_num] + Yshift[blk_num])*4)>>2);

                WriteParams(-1,VC1_ENC_PRED,"Predicted pels\n");
                for (i = 0; i < 8; i ++)
                {
                    for (j = 0; j < 8; j++)
                    {
                        WriteParams(-1,VC1_ENC_PRED,"%d ",pCurrMB->Block[blk_num].FDst[j + i*8]);
                    }
                    WriteParams(-1,VC1_ENC_PRED,"\n");
                }
            }
            break;

        case (VC1_ENC_B_MB_SKIP_B):
        case (VC1_ENC_B_MB_B):
            for(blk_num = 0; blk_num < 6; blk_num++)
            {
                WriteParams(-1,VC1_ENC_PRED,"Block %d\n", blk_num);

                WriteParams(-1,VC1_ENC_PRED,"Before Interpolation %d, %d, forward %d\n",
                    pCurrMB->Block[blk_num].MV[0][1] + (XPos * pixelInBlk[blk_num] + Xshift[blk_num])*4,
                    pCurrMB->Block[blk_num].MV[1][1] + (YPos * pixelInBlk[blk_num] + Yshift[blk_num])*4 , 1);

                if(blk_num < 4)
                    WriteParams(-1,VC1_ENC_PRED," MVMode1MVHalfPelBilinear\n");

                WriteParams(-1,VC1_ENC_PRED,"%d\t %d\t %d\n",pCurrMB->Block[blk_num].BSrc,
                    (pCurrMB->Block[blk_num].MV[0][1] + (XPos * pixelInBlk[blk_num] + Xshift[blk_num])*4)>>2,
                    (pCurrMB->Block[blk_num].MV[1][1] + (YPos * pixelInBlk[blk_num] + Yshift[blk_num])*4)>>2);

                WriteParams(-1,VC1_ENC_PRED,"Predicted pels\n");
                for (i = 0; i < 8; i ++)
                {
                    for (j = 0; j < 8; j++)
                    {
                        WriteParams(-1,VC1_ENC_PRED,"%d ",pCurrMB->Block[blk_num].BDst[j + i*8]);
                    }
                    WriteParams(-1,VC1_ENC_PRED,"\n");
                }
            }
            break;
        case (VC1_ENC_B_MB_SKIP_FB):
        case (VC1_ENC_B_MB_FB):
            for(blk_num = 0; blk_num < 6; blk_num++)
            {
                //forward
                WriteParams(-1,VC1_ENC_PRED,"Block %d\n", blk_num);

                WriteParams(-1,VC1_ENC_PRED,"Before Interpolation %d, %d, forward %d\n",
                    pCurrMB->Block[blk_num].MV[0][0] + (XPos * pixelInBlk[blk_num] + Xshift[blk_num])*4,
                    pCurrMB->Block[blk_num].MV[1][0] + (YPos * pixelInBlk[blk_num] + Yshift[blk_num])*4 , 0);

                if(blk_num < 4)
                    WriteParams(-1,VC1_ENC_PRED," MVMode1MVHalfPelBilinear\n");

                WriteParams(-1,VC1_ENC_PRED,"%d\t %d\t %d\n",pCurrMB->Block[blk_num].FSrc,
                    (pCurrMB->Block[blk_num].MV[0][0] + (XPos * pixelInBlk[blk_num] + Xshift[blk_num])*4)>>2,
                    (pCurrMB->Block[blk_num].MV[1][0] + (YPos * pixelInBlk[blk_num] + Yshift[blk_num])*4)>>2);

                WriteParams(-1,VC1_ENC_PRED,"Predicted pels\n");
                for (i = 0; i < 8; i ++)
                {
                    for (j = 0; j < 8; j++)
                    {
                        WriteParams(-1,VC1_ENC_PRED,"%d ",pCurrMB->Block[blk_num].FDst[j + i*8]);
                    }
                    WriteParams(-1,VC1_ENC_PRED,"\n");
                }



                //backward
                WriteParams(-1,VC1_ENC_PRED,"Block %d\n", blk_num);

                WriteParams(-1,VC1_ENC_PRED,"Before Interpolation %d, %d, forward %d\n",
                    pCurrMB->Block[blk_num].MV[0][1] + (XPos * pixelInBlk[blk_num] + Xshift[blk_num])*4,
                    pCurrMB->Block[blk_num].MV[1][1] + (YPos * pixelInBlk[blk_num] + Yshift[blk_num])*4 , 1);


                if(blk_num < 4)
                    WriteParams(-1,VC1_ENC_PRED," MVMode1MVHalfPelBilinear\n");

                WriteParams(-1,VC1_ENC_PRED,"%d\t %d\t %d\n",pCurrMB->Block[blk_num].BSrc,
                    (pCurrMB->Block[blk_num].MV[0][1] + (XPos * pixelInBlk[blk_num] + Xshift[blk_num])*4)>>2,
                    (pCurrMB->Block[blk_num].MV[1][1] + (YPos * pixelInBlk[blk_num] + Yshift[blk_num])*4)>>2);

                WriteParams(-1,VC1_ENC_PRED,"Predicted pels\n");
                for (i = 0; i < 8; i ++)
                {
                    for (j = 0; j < 8; j++)
                    {
                        WriteParams(-1,VC1_ENC_PRED,"%d ",pCurrMB->Block[blk_num].BDst[j + i*8]);
                    }
                    WriteParams(-1,VC1_ENC_PRED,"\n");
                }

            }
            break;
        case (VC1_ENC_P_MB_4MV):
            break;

        case (VC1_ENC_B_MB_DIRECT):
            break;
    };
};
void VC1EncDebug::PrintMVInfo()
{
    switch(pCurrMB->MBType)
    {
    case (VC1_ENC_I_MB):
    case (VC1_ENC_P_MB_INTRA):
    case (VC1_ENC_B_MB_INTRA):
        break;

    case (VC1_ENC_P_MB_1MV):
    case (VC1_ENC_B_MB_F):
    case (VC1_ENC_P_MB_SKIP):
    case (VC1_ENC_B_MB_SKIP_F):
        //MV diff
        if(!(pCurrMB->skip))
            WriteParams(-1,VC1_ENC_MV, "DMV_X = %d, DMV_Y = %d\n",
                pCurrMB->Block[0].difMV[0][0], pCurrMB->Block[0].difMV[1][0]);

        //MV predictor
        WriteParams(-1,VC1_ENC_MV, "PredictorX = %d, PredictorY = %d\n",
            pCurrMB->Block[0].PredMV[0][0], pCurrMB->Block[0].PredMV[1][0]);

        //MV
        WriteParams(-1,VC1_ENC_MV,  "ApplyPred : MV_X  = %d, MV_Y  = %d\n",
            pCurrMB->Block[0].MV[0][0], pCurrMB->Block[0].MV[1][0]);
        break;
    case (VC1_ENC_B_MB_B):
    case (VC1_ENC_B_MB_SKIP_B):
        //MV diff
        if(!(pCurrMB->skip))
            WriteParams(-1,VC1_ENC_MV, "DMV_X = %d, DMV_Y = %d\n",
                pCurrMB->Block[0].difMV[0][1], pCurrMB->Block[0].difMV[1][1]);

            //MV predictors
            WriteParams(-1,VC1_ENC_MV, "PredictorX = %d, PredictorY = %d\n",
                pCurrMB->Block[0].PredMV[0][1], pCurrMB->Block[0].PredMV[1][1]);

        //MV
        WriteParams(-1,VC1_ENC_MV,  "ApplyPred : MV_X  = %d, MV_Y  = %d\n",
            pCurrMB->Block[0].MV[0][1], pCurrMB->Block[0].MV[1][1]);
        break;
    case (VC1_ENC_B_MB_FB):
    case (VC1_ENC_B_MB_SKIP_FB):

        //MV diff
        if(!(pCurrMB->skip))
        {
            WriteParams(-1,VC1_ENC_MV, "DMV_X = %d, DMV_Y = %d\n",
                pCurrMB->Block[0].difMV[0][1], pCurrMB->Block[0].difMV[1][1]);

            WriteParams(-1,VC1_ENC_MV, "DMV_X = %d, DMV_Y = %d\n",
                pCurrMB->Block[0].difMV[0][0], pCurrMB->Block[0].difMV[1][0]);
        }

        //MV predictors
        WriteParams(-1,VC1_ENC_MV, "PredictorX = %d, PredictorY = %d\n",
            pCurrMB->Block[0].PredMV[0][0], pCurrMB->Block[0].PredMV[1][0]);
        WriteParams(-1,VC1_ENC_MV,  "ApplyPred : MV_X  = %d, MV_Y  = %d\n",
            pCurrMB->Block[0].MV[0][0], pCurrMB->Block[0].MV[1][0]);

        //MV
        WriteParams(-1,VC1_ENC_MV, "PredictorX = %d, PredictorY = %d\n",
            pCurrMB->Block[0].PredMV[0][1], pCurrMB->Block[0].PredMV[1][1]);
        WriteParams(-1,VC1_ENC_MV,  "ApplyPred : MV_X  = %d, MV_Y  = %d\n",
            pCurrMB->Block[0].MV[0][1], pCurrMB->Block[0].MV[1][1]);

        break;

    case (VC1_ENC_P_MB_4MV):
        break;

    case (VC1_ENC_B_MB_DIRECT):
        break;
    };
};
void VC1EncDebug::PrintRunLevel(Ipp32s blk_num)
{
    Ipp32s i = 0;
    Ipp32s SBNum = 0;
    Ipp32s pairsNum = 0;
    Ipp32s last = 0;
    Ipp32s mode = 0;
    Ipp32s coefNum = 0;

    for(SBNum = 0; SBNum < 4; SBNum++)
    {
        pairsNum = pCurrMB->Block[blk_num].Pairs[SBNum];

        for(i = 0; i < pairsNum; i++)
        {
            if(i == (pairsNum - 1)) last = 1;
            mode = pCurrMB->Block[blk_num].Mode[coefNum];

            switch(mode)
            {
            case 0:
                break;
            case 1:
            case 2:
            case 3:
                WriteParams(-1,VC1_ENC_COEFFS,"Index = ESCAPE\n");
                WriteParams(-1,VC1_ENC_COEFFS,"Index = ESCAPE Mode %d\n", mode);
                break;
            };

            WriteParams(-1,VC1_ENC_COEFFS,"AC Run=%2d Level=%c%3d Last=%d\n",
                pCurrMB->Block[blk_num].Run [coefNum],
                (pCurrMB->Block[blk_num].Level[coefNum] < 0) ? '-' : '+',
                (pCurrMB->Block[blk_num].Level[coefNum] < 0) ?
                -pCurrMB->Block[blk_num].Level[coefNum] :
            pCurrMB->Block[blk_num].Level[coefNum],
                last);
            coefNum++;
        }
    }
};
void VC1EncDebug::SetQuant(Ipp32s MQuant, Ipp8u  HalfQP)
{
    pCurrMB->MQuant = MQuant;
    pCurrMB->HalfQP = HalfQP;

};
void VC1EncDebug::WriteFrameInfo()
{
    Ipp32s i = 0;
    Ipp32s j = 0;
    Ipp32s k = 0;
    Ipp32s t = 0;
    Ipp32s blk_num = 0;

    if((!VC1_ENC_FRAME_DEBUG) || (FrameCount >= VC1_ENC_FRAME_MIN) && (FrameCount <= VC1_ENC_FRAME_MAX))
    {
        WriteParams(-1,VC1_ENC_POSITION, "Picture type = %d\n", FrameType);
        WriteParams(-1,VC1_ENC_POSITION, "Frame %d\n", FrameCount);
        WriteParams(-1,VC1_ENC_POSITION, "Frame %d = %d\n\n", FrameCount, FrameSize);
        pCurrMB = MBs;
        XPos = 0;
        YPos = 0;

        for(i = 0; i < MBHeight; i++)
        {
            for(j = 0; j < MBWidth; j++)
            {
                WriteParams(-1,VC1_ENC_POSITION, "\t\t\tX: %d, Y: %d\n", j, i);

                //------MV information----------
                PrintMVInfo();

                //----CBP---------------
                if(!(pCurrMB->skip))
                {
                    WriteParams(-1,VC1_ENC_CBP,"Read CBPCY: 0x%02X\n", pCurrMB->CBP);
                    WriteParams(-1,VC1_ENC_CBP,"Predicted CBPCY = 0x%02X\n", pCurrMB->PredCBP);
                }

                //----quantization parameters
                {
                    WriteParams(-1,VC1_ENC_QUANT, "MB Quant = %d\n", pCurrMB->MQuant);
                    WriteParams(-1,VC1_ENC_QUANT, "HalfQ = %d\n", pCurrMB->HalfQP);
                }

                for(blk_num = 0; blk_num < 6; blk_num++)
                {
                    if(pCurrMB->Block[blk_num].intra)
                    {
                        //---BEGIN---DC coef information--------------
                        if(pCurrMB->Block[blk_num].DCDirection == VC1_ENC_LEFT)
                            WriteParams(-1,VC1_ENC_COEFFS|VC1_ENC_AC_PRED, "DC left prediction\n");
                        else
                            WriteParams(-1,VC1_ENC_COEFFS|VC1_ENC_AC_PRED, "DC top prediction\n");

                        WriteParams(-1,VC1_ENC_COEFFS, "DC diff = %d\n", pCurrMB->Block[blk_num].DCDiff);

                    }

                    //---BEGIN---run - level coefficients--------------
                    PrintRunLevel(blk_num);

                    if(pCurrMB->Block[blk_num].intra)
                    {
                        //---BEGIN---AC coef information--------------
                        if(pCurrMB->Block[blk_num].ACPred)
                        {
                            WriteParams(-1,VC1_ENC_AC_PRED, "Block %d\n", blk_num);
                            WriteParams(-1,VC1_ENC_AC_PRED,"AC prediction\n");

                            for(t = 0; t < 7; t++)
                                WriteParams(-1,VC1_ENC_AC_PRED, "%d ",pCurrMB->Block[blk_num].AC[t]);

                            WriteParams(-1,VC1_ENC_AC_PRED,"\n");
                        }

                        //---BEGIN---DC coef information--------------
                        WriteParams(-1,VC1_ENC_COEFFS, "DC = %d\n", pCurrMB->Block[blk_num].DC);
                    }

                    //----Block difference---------------
                    if(!(pCurrMB->skip))
                       PrintBlockDifference(blk_num);
                }

                //------interpolation---------------
                PrintInterpolationInfo();

                NextMB();
            }
        }
    }

    memset(MBs, 0, sizeof(VC1MBDebugInfo) * MBWidth * MBHeight);
    FrameCount++;
    pCurrMB = MBs;
    XPos = 0;
    YPos = 0;
};


#endif
}
#endif //defined (UMC_ENABLE_VC1_VIDEO_ENCODER)