umc_vc1_enc_debug.cpp

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

/* /////////////////////////////////////////////////////////////////////////////
//
//                  INTEL CORPORATION PROPRIETARY INFORMATION
//     This software is supplied under the terms of a license agreement or
//     nondisclosure agreement with Intel Corporation and may not be copied
//     or disclosed except in accordance with the terms of that agreement.
//          Copyright(c) 2007 Intel Corporation. All Rights Reserved.
//
//
//          VC-1 (VC1) encoder, debug functionality
//
*/

#include "umc_defs.h"

#if defined (UMC_ENABLE_VC1_VIDEO_ENCODER)

#include "umc_vc1_enc_debug.h"
#include "vm_debug.h"
#include "umc_vc1_enc_def.h"

namespace UMC_VC1_ENCODER
{
#ifdef VC1_ENC_DEBUG_ON

VC1EncDebug *pDebug;

const Ipp32u  VC1_ENC_POSITION     = 0x00000001;  //Frame num, frame type, frame size,
                                                  //MB, Block positions, skip info
const Ipp32u  VC1_ENC_COEFFS       = 0x00000080;  // DC, AC coefficiens
const Ipp32u  VC1_ENC_AC_PRED      = 0x00004000;  // AC prediction
const Ipp32u  VC1_ENC_QUANT        = 0x00000008;  // quant info
const Ipp32u  VC1_ENC_CBP          = 0x00000002;  // coded block patern info
const Ipp32u  VC1_ENC_MV           = 0x00000020;  // motion vectors info
const Ipp32u  VC1_ENC_PRED         = 0x00000040;  //interpolation info

const Ipp32u  VC1_ENC_FRAME_DEBUG  = 0;           //on/off frame debug
const Ipp32u  VC1_ENC_FRAME_MIN    = 45;           //first frame to debug
const Ipp32u  VC1_ENC_FRAME_MAX    = 50;           //last frame to debug

const Ipp32u  VC1_ENC_DEBUG     = 0x00000000;  //current debug output


VC1EncDebug::VC1EncDebug()
{
    LogFile     = NULL;
    FrameCount  = 0;
    FrameType   = 0;
    FrameSize   = 0;
    MBWidth   = 0;
    MBHeight  = 0;
    XPos      = 0;
    YPos      = 0;
    MBs          = NULL;
    pCurrMB      = NULL;
};

VC1EncDebug::~VC1EncDebug()
{
    Close();
};

void VC1EncDebug::Init(Ipp32s Width, Ipp32s Height)
{
    VM_ASSERT(Width <= 0);
    VM_ASSERT(Height <= 0);

    MBHeight = Height;
    MBWidth  = Width;

    //open log file
    LogFile = vm_file_open("enc_log.txt","w");
    VM_ASSERT(LogFile != NULL);

    MBs = (VC1MBDebugInfo*)ippsMalloc_8u(sizeof(VC1MBDebugInfo) * MBWidth * MBHeight);

    VM_ASSERT(MBs == NULL);
    memset(MBs, 0, sizeof(VC1MBDebugInfo) * MBWidth * MBHeight);

    pCurrMB = MBs;
};

void VC1EncDebug::Close()
{
    //close log file
    if(LogFile)
    {
        vm_file_close(LogFile);
        LogFile = NULL;
    }

    FrameCount  = 0;
    FrameType   = 0;
    FrameSize   = 0;
    MBWidth   = 0;
    MBHeight  = 0;
    XPos      = 0;
    YPos      = 0;

    if(MBs != NULL)
    {
        ippsFree(MBs);
        MBs = NULL;
    }
    pCurrMB      = NULL;
};

void VC1EncDebug::SetPicType(Ipp32s picType)
{
    FrameType = picType;
};

void VC1EncDebug::SetFrameSize(Ipp32s frameSize)
{
    FrameSize = frameSize;
};

void VC1EncDebug::WriteParams(Ipp32s _cur_frame, Ipp32s level,  vm_char *format,...)
{
    vm_char line[1024];
    va_list args;

    if (!(level & VC1_ENC_DEBUG))
       return;

   va_start(args, format);
   vm_string_vsprintf(line, format, args);
   vm_string_fprintf(LogFile, line);
   //printf(line);
};

void VC1EncDebug::SetRunLevelCoefs(Ipp8u* run, Ipp16s* level, Ipp8u* pairs, Ipp32s blk_num)
{
    Ipp32s i = 0;
    Ipp32s j = 0;
    Ipp32s pairNum = 0;
    Ipp32s coefNum = 0;

    pCurrMB->Block[blk_num].Pairs[0] = pairs[0];
    pCurrMB->Block[blk_num].Pairs[1] = pairs[1];
    pCurrMB->Block[blk_num].Pairs[2] = pairs[2];
    pCurrMB->Block[blk_num].Pairs[3] = pairs[3];

    for(i = 0; i < 4; i++)
    {
        pairNum =  pairs[i];

        for(j = 0; j < pairNum; j++)
        {
            pCurrMB->Block[blk_num].Run[coefNum]   = run[coefNum];
            pCurrMB->Block[blk_num].Level[coefNum] = level[coefNum];
            coefNum++;
        }
    }

     VM_ASSERT(coefNum > 64);
};

void VC1EncDebug::NextMB()
{
    pCurrMB++;

    XPos++;

    if(XPos >= MBWidth)
    {
        XPos = 0;
        YPos++;
    }
};

void VC1EncDebug::SetRLMode(Ipp8u mode, Ipp32s blk_num, Ipp32s coef_num)
{
    assert(mode < 65);
    pCurrMB->Block[blk_num].Mode[coef_num] = mode;
};


void VC1EncDebug::SetBlockAsIntra(Ipp32s blk_num)
{
    pCurrMB->Block[blk_num].intra = 1;
};

void VC1EncDebug::SetBlockDifference(Ipp16s** pBlock, Ipp32u* step)
{
    Ipp32s blk_num = 0;
    Ipp32s i = 0;
    Ipp32s j = 0;

    for(blk_num = 0; blk_num < 6; blk_num++)
    {
        for(i = 0; i < 8; i++)
        {
            for (j = 0; j < 8; j++)
            {
                pCurrMB->Block[blk_num].BlockDiff[i*8 + j] = pBlock[blk_num][i * step[blk_num]/2 + j];
            }
        }
    }

};

void VC1EncDebug::SetMBAsSkip()
{
    pCurrMB->skip = 1;
};

void VC1EncDebug::SetDCACInfo(Ipp32s ACPred, Ipp16s* pBlock, Ipp32s BlockStep,
                              Ipp16s* pPredBlock, Ipp32s PredBlockStep,
                              Ipp32s direction, Ipp32s blk_num)
{
    Ipp32s i = 0;
    Ipp32s j = 0;

    pCurrMB->Block[blk_num].DC = pBlock[0];
    pCurrMB->Block[blk_num].DCDiff = pPredBlock[0];
    pCurrMB->Block[blk_num].DCDirection = direction;

    pCurrMB->Block[blk_num].ACPred = ACPred;

    if(ACPred)
    {
        if(direction == VC1_ENC_LEFT)
        {
            //AC left prediction
            for(i = 1; i < 8; i++)
            {
                pCurrMB->Block[blk_num].AC[i - 1] = pBlock[i * BlockStep/2] - pPredBlock[i * PredBlockStep/2];
            }
        }
        else
        {
            //AC top prediction
            for(i = 1; i < 8; i++)
            {
                pCurrMB->Block[blk_num].AC[i - 1] = pBlock[i] - pPredBlock[i];
            }
        }
    }
};

void VC1EncDebug::SetCPB(Ipp32s predcbp, Ipp32s cbp)
{
    pCurrMB->PredCBP = predcbp;
    pCurrMB->CBP = cbp;
};

void VC1EncDebug::SetMVInfo(Ipp16s X, Ipp16s Y, Ipp16s XPred, Ipp16s YPred, Ipp32s forward, Ipp32s blk_num)
{
    if(blk_num == -1)
    {
        for(blk_num = 0; blk_num < 4; blk_num++)
        {
            pCurrMB->Block[blk_num].MV[0][forward]    = X;
            pCurrMB->Block[blk_num].MV[1][forward]    = Y;
            pCurrMB->Block[blk_num].PredMV[0][forward] = XPred;
            pCurrMB->Block[blk_num].PredMV[1][forward] = YPred;
        }
    }
    else
    {
            pCurrMB->Block[blk_num].MV[0][forward]    = X;
            pCurrMB->Block[blk_num].MV[1][forward]    = Y;
            pCurrMB->Block[blk_num].PredMV[0][forward] = XPred;
            pCurrMB->Block[blk_num].PredMV[1][forward] = YPred;
    }
};

void VC1EncDebug::SetMVDiff(Ipp16s DiffX, Ipp16s DiffY, Ipp32s forward, Ipp32s blk_num)
{
    if(blk_num == -1)
    {
        for(blk_num = 0; blk_num < 6; blk_num++)
        {
            pCurrMB->Block[blk_num].difMV[0][forward]    = DiffX;
            pCurrMB->Block[blk_num].difMV[1][forward]    = DiffY;
        }
    }
    else
    {
            pCurrMB->Block[blk_num].difMV[0][forward]    = DiffX;
            pCurrMB->Block[blk_num].difMV[1][forward]    = DiffY;
    }
};

void VC1EncDebug::SetMBType(Ipp32s type)
{
    pCurrMB->MBType = type;
};

void  VC1EncDebug::SetInterpInfo(Ipp8u* pBlock, Ipp32s step, Ipp32s blk_num, Ipp32s forward, Ipp8u src)
{
    Ipp32s i = 0;
    Ipp32s j = 0;


    if(!forward)
    {
        pCurrMB->Block[blk_num].FSrc = src;
        for(i = 0; i < 8; i++)
        {
            for(j = 0; j < 8; j++)
            {
                pCurrMB->Block[blk_num].FDst[i*8 + j] = pBlock[j + i * step];
            }
        }
    }
    else
    {
        pCurrMB->Block[blk_num].BSrc = src;
        for(i = 0; i < 8; i++)
        {
            for(j = 0; j < 8; j++)
            {
                pCurrMB->Block[blk_num].BDst[i*8 + j] = pBlock[j + i * step];
            }
        }
    }

};

void VC1EncDebug::PrintBlockDifference(Ipp32s blk_num)
{
    Ipp32s i = 0;
    Ipp32s j = 0;

    WriteParams(-1,VC1_ENC_COEFFS|VC1_ENC_AC_PRED, "Block %d\n", blk_num);
    for(i = 0; i < 8; i++)
    {
        for (j = 0; j < 8; j++)
        {
            WriteParams(-1,VC1_ENC_COEFFS|VC1_ENC_AC_PRED, "%d  ", pCurrMB->Block[blk_num].BlockDiff[i * 8 + j]);
        }
        WriteParams(-1,VC1_ENC_COEFFS|VC1_ENC_AC_PRED, "\n");
    }
};

void VC1EncDebug::PrintInterpolationInfo()
{
    Ipp32s i = 0;
    Ipp32s j = 0;
    Ipp32s blk_num = 0;

    Ipp8u Xshift[6] = {0, 8, 0, 8, 0, 0};
    Ipp8u Yshift[6] = {0, 0, 8, 8, 0, 0};
    Ipp8u pixelInBlk[6] = {16, 16, 16, 16, 8, 8};

    switch(pCurrMB->MBType)
    {
        case (VC1_ENC_I_MB):