pred.cpp

AVS是中国自己推出的视频图像音频编解码标准。包中是AVS 源代码

    }
    else
    {
      mvB = pMbInfo[dwMbIndex-dwMbWidth].mvBw[2];
      BlockDistanceB = pMbInfo[dwMbIndex-dwMbWidth].iBlockDistanceBw[2];
      RefIdxB = pMbInfo[dwMbIndex-dwMbWidth].dwMbReferenceIndexBw[2];
    }
  }
  if(!D_BlockAvailable || pMbInfo[dwMbIndex-dwMbWidth-1].dwMbType == I_8x8 ||
    (pMbInfo[dwMbIndex-dwMbWidth-1].predDir[3] != pMbInfo[dwMbIndex].predDir[0] && 
    pMbInfo[dwMbIndex-dwMbWidth-1].predDir[3] != PREDDIRSYM))
  {
    mvD.x = mvD.y = 0;
    BlockDistanceD = 1;
    RefIdxD = -1;
  }
  else
  {
    if(!dirBw)
    {
      mvD = pMbInfo[dwMbIndex-dwMbWidth-1].mv[3];
      BlockDistanceD = pMbInfo[dwMbIndex-dwMbWidth-1].iBlockDistance[3];
      RefIdxD = pMbInfo[dwMbIndex-dwMbWidth-1].dwMbReferenceIndex[3];
    }
    else
    {
      mvD = pMbInfo[dwMbIndex-dwMbWidth-1].mvBw[3];
      BlockDistanceD = pMbInfo[dwMbIndex-dwMbWidth-1].iBlockDistanceBw[3];
      RefIdxD = pMbInfo[dwMbIndex-dwMbWidth-1].dwMbReferenceIndexBw[3];
    }
  }
  
  if(!C_BlockAvailable)
  {
    mvC = mvD;
    BlockDistanceC = BlockDistanceD;
    RefIdxC = RefIdxD;
  }
  else if(pMbInfo[dwMbIndex-dwMbWidth+1].dwMbType==I_8x8 ||
    (pMbInfo[dwMbIndex-dwMbWidth+1].predDir[2] !=pMbInfo[dwMbIndex].predDir[0]&&
    pMbInfo[dwMbIndex-dwMbWidth+1].predDir[2] != PREDDIRSYM))
  {
    mvC.x = mvC.y = 0;
    BlockDistanceC = 1;
    RefIdxC = -1;
  }
  else
  {
    if(!dirBw)
    {
      mvC = pMbInfo[dwMbIndex-dwMbWidth+1].mv[2];
      BlockDistanceC = pMbInfo[dwMbIndex-dwMbWidth+1].iBlockDistance[2];
      RefIdxC = pMbInfo[dwMbIndex-dwMbWidth+1].dwMbReferenceIndex[2];
    }
    else
    {
      mvC = pMbInfo[dwMbIndex-dwMbWidth+1].mvBw[2];
      BlockDistanceC = pMbInfo[dwMbIndex-dwMbWidth+1].iBlockDistanceBw[2];
      RefIdxC = pMbInfo[dwMbIndex-dwMbWidth+1].dwMbReferenceIndexBw[2];
    }
  }

  if(RefIdxA !=-1 && RefIdxB == -1 && RefIdxC == -1)
  {
    MVEPred = mvA;
  }
  else if(RefIdxA == -1 && RefIdxB != -1 && RefIdxC == -1)
  {
    MVEPred = mvB;
  }
  else if(RefIdxA ==-1 && RefIdxB == -1 && RefIdxC != -1)
  {
    MVEPred = mvC;
  }
  else
  {
    MVEPred = ScalePredMv(&mvA, &mvB, &mvC, iBlockDistance, BlockDistanceA, BlockDistanceB, BlockDistanceC);
  }
  
  if(pMbInfo[dwMbIndex].dwMbType == P_Skip)
  {
    if((!B_BlockAvailable)|| (!A_BlockAvailable))
    {
      mvE.x = mvE.y = 0;
    }
    else if((mvA.x == 0 && mvA.y == 0 && RefIdxA == 0)||
      (mvB.x == 0 && mvB.y == 0 && RefIdxB == 0))
    {
      mvE.x = mvE.y = 0;
    }
    else
    {
      mvE = MVEPred;
    }
  }
  else
  {
    mvE.x = MVEPred.x + pMbInfo[dwMbIndex].iMvDiffX[0];
    mvE.y = MVEPred.y + pMbInfo[dwMbIndex].iMvDiffY[0];
  }
  
  for(AVS_INT block=0; block<4; block++)
  {
    if(!dirBw)
    {
      pMbInfo[dwMbIndex].mv[block] = mvE;
      pMbInfo[dwMbIndex].iBlockDistance[block] = iBlockDistance;
    }
    else
    {
      pMbInfo[dwMbIndex].mvBw[block] = mvE;
      pMbInfo[dwMbIndex].iBlockDistanceBw[block] = iBlockDistance;
    }
    

    //插值，得到4个8x8预测块
    AVS_INT iImgWidth = dwMbWidth*16;
    AVS_INT iImgHeight = dwMbHeight*16;
    AVS_INT iImgX = (dwMbIndex%dwMbWidth)*16 + (block%2)*8;
    AVS_INT iImgY = (dwMbIndex/dwMbWidth)*16 + (block/2)*8;

    if(!dirBw)
    {
      GetBlock(&(pMbInfo[dwMbIndex].mv[block]),iImgX, iImgY, iImgWidth, iImgHeight, pbRefY, pPred+block*64);
    }
    else
    {
      GetBlock(&(pMbInfo[dwMbIndex].mvBw[block]),iImgX, iImgY, iImgWidth, iImgHeight, pbRefY, pPred+block*64);
    }
  }

  return AVS_NOERROR;
}

AVS_HRESULT InterPredLumaBSkipDirect16x16(MBINFO* pMbInfo, AVS_DWORD dwMbIndex, const VIDEODATA** ppRefFrame, AVS_DWORD dwRefNum, AVS_DWORD dwMbWidth, AVS_DWORD dwMbHeight, AVS_DWORD dwCurrDistanceIndex, const BWREFINFO* pBwRefInfo, AVS_BYTE* pPred)
{
  AVS_BOOL A_BlockAvailable = FALSE;
  AVS_BOOL B_BlockAvailable = FALSE;
  AVS_BOOL C_BlockAvailable = FALSE;
  AVS_BOOL D_BlockAvailable = FALSE;

  AVS_INT  BlockDistanceA=1;
  AVS_INT  BlockDistanceB=1;
  AVS_INT  BlockDistanceC=1;
  AVS_INT  BlockDistanceD=1;

  AVS_INT  RefIdxA = -1;
  AVS_INT  RefIdxB = -1;
  AVS_INT  RefIdxC = -1;
  AVS_INT  RefIdxD = -1;

  MOTIONVECTOR mvA={0,0}, mvB={0,0}, mvC={0,0}, mvD={0,0}, mvE={0,0}, mvBw={0,0};
  MOTIONVECTOR MVEPred={0,0};

  AVS_INT MbX = dwMbIndex%dwMbWidth;
  AVS_INT MbY = dwMbIndex/dwMbWidth;
  
  AVS_INT idxFw = 1;
  AVS_INT idxBw = 0;
  AVS_INT dirBw = 1;

  AVS_INT iBlockDistance = ((dwCurrDistanceIndex - ppRefFrame[idxFw]->dwDistanceIndex)+512)%512;
  AVS_INT iBlockDistanceBw = ((ppRefFrame[idxBw]->dwDistanceIndex - dwCurrDistanceIndex)+512)%512;


  if(MbX>0)
    A_BlockAvailable = TRUE;
  if(MbY>0)
    B_BlockAvailable = TRUE;
  if(MbX>0 && MbY>0)
    D_BlockAvailable = TRUE;
  if(MbY>0 && MbX<dwMbWidth-1)
    C_BlockAvailable = TRUE;

  // forward
  if(!A_BlockAvailable || pMbInfo[dwMbIndex-1].dwMbType == I_8x8 || 
    pMbInfo[dwMbIndex-1].predDir[1] == PREDDIRBWD)
  {
    mvA.x = mvA.y = 0;
    BlockDistanceA = 1;
    RefIdxA = -1;
  }
  else
  {
    mvA = pMbInfo[dwMbIndex-1].mv[1];
    BlockDistanceA = pMbInfo[dwMbIndex-1].iBlockDistance[1];
    RefIdxA = pMbInfo[dwMbIndex-1].dwMbReferenceIndex[1];
  }

  if(!B_BlockAvailable || pMbInfo[dwMbIndex-dwMbWidth].dwMbType == I_8x8 ||
    pMbInfo[dwMbIndex-dwMbWidth].predDir[2] == PREDDIRBWD)
  {
    mvB.x = mvB.y = 0;
    BlockDistanceB = 1;
    RefIdxB = -1;
  }
  else
  {
    mvB = pMbInfo[dwMbIndex-dwMbWidth].mv[2];
    BlockDistanceB = pMbInfo[dwMbIndex-dwMbWidth].iBlockDistance[2];
    RefIdxB = pMbInfo[dwMbIndex-dwMbWidth].dwMbReferenceIndex[2];
  }

  if(!D_BlockAvailable || pMbInfo[dwMbIndex-dwMbWidth-1].dwMbType == I_8x8 ||
    pMbInfo[dwMbIndex-dwMbWidth-1].predDir[3] == PREDDIRBWD)
  {
    mvD.x = mvD.y = 0;
    BlockDistanceD = 1;
    RefIdxD = -1;
  }
  else
  {
    mvD = pMbInfo[dwMbIndex-dwMbWidth-1].mv[3];
    BlockDistanceD = pMbInfo[dwMbIndex-dwMbWidth-1].iBlockDistance[3];
    RefIdxD = pMbInfo[dwMbIndex-dwMbWidth-1].dwMbReferenceIndex[3];
  }

  if(!C_BlockAvailable)
  {
    mvC = mvD;
    BlockDistanceC = BlockDistanceD;
    RefIdxC = RefIdxD;
  }
  else if(pMbInfo[dwMbIndex-dwMbWidth+1].dwMbType==I_8x8 || 
    pMbInfo[dwMbIndex-dwMbWidth+1].predDir[2] == PREDDIRBWD)
  {
    mvC.x = mvC.y = 0;
    BlockDistanceC = 1;
    RefIdxC = -1;
  }
  else
  {
    mvC = pMbInfo[dwMbIndex-dwMbWidth+1].mv[2];
    BlockDistanceC = pMbInfo[dwMbIndex-dwMbWidth+1].iBlockDistance[2];
    RefIdxC = pMbInfo[dwMbIndex-dwMbWidth+1].dwMbReferenceIndex[2];
  }

  if(RefIdxA !=-1 && RefIdxB == -1 && RefIdxC == -1)
  {
    MVEPred = mvA;
  }
  else if(RefIdxA == -1 && RefIdxB != -1 && RefIdxC == -1)
  {
    MVEPred = mvB;
  }
  else if(RefIdxA ==-1 && RefIdxB == -1 && RefIdxC != -1)
  {
    MVEPred = mvC;
  }
  else
  {
    MVEPred = ScalePredMv(&mvA, &mvB, &mvC, iBlockDistance, BlockDistanceA, BlockDistanceB, BlockDistanceC);
  }
  
  mvE = MVEPred;
  
  // backward
  A_BlockAvailable = FALSE;
  B_BlockAvailable = FALSE;
  C_BlockAvailable = FALSE;
  D_BlockAvailable = FALSE;

  if(MbX>0)
    A_BlockAvailable = TRUE;
  if(MbY>0)
    B_BlockAvailable = TRUE;
  if(MbX>0 && MbY>0)
    D_BlockAvailable = TRUE;
  if(MbY>0 && MbX<dwMbWidth-1)
    C_BlockAvailable = TRUE;
  if(!A_BlockAvailable || pMbInfo[dwMbIndex-1].dwMbType == I_8x8 ||
    pMbInfo[dwMbIndex-1].predDir[1] == PREDDIRFWD)
  {
    mvA.x = mvA.y = 0;
    BlockDistanceA = 1;
    RefIdxA = -1;
  }
  else
  {
    mvA = pMbInfo[dwMbIndex-1].mvBw[1];
    BlockDistanceA = pMbInfo[dwMbIndex-1].iBlockDistanceBw[1];
    RefIdxA = pMbInfo[dwMbIndex-1].dwMbReferenceIndexBw[1];
  }

  if(!B_BlockAvailable || pMbInfo[dwMbIndex-dwMbWidth].dwMbType == I_8x8 ||
    pMbInfo[dwMbIndex-dwMbWidth].predDir[2] == PREDDIRFWD)
  {
    mvB.x = mvB.y = 0;
    BlockDistanceB = 1;
    RefIdxB = -1;
  }
  else
  {
    mvB = pMbInfo[dwMbIndex-dwMbWidth].mvBw[2];
    BlockDistanceB = pMbInfo[dwMbIndex-dwMbWidth].iBlockDistanceBw[2];
    RefIdxB = pMbInfo[dwMbIndex-dwMbWidth].dwMbReferenceIndexBw[2];
  }

  if(!D_BlockAvailable || pMbInfo[dwMbIndex-dwMbWidth-1].dwMbType == I_8x8 ||
    pMbInfo[dwMbIndex-dwMbWidth-1].predDir[3] == PREDDIRFWD)
  {
    mvD.x = mvD.y = 0;
    BlockDistanceD = 1;
    RefIdxD = -1;
  }
  else
  {
    mvD = pMbInfo[dwMbIndex-dwMbWidth-1].mvBw[3];
    BlockDistanceD = pMbInfo[dwMbIndex-dwMbWidth-1].iBlockDistanceBw[3];
    RefIdxD = pMbInfo[dwMbIndex-dwMbWidth-1].dwMbReferenceIndexBw[3];
  }

  if(!C_BlockAvailable)
  {
    mvC = mvD;
    BlockDistanceC = BlockDistanceD;
    RefIdxC = RefIdxD;
  }
  else if(pMbInfo[dwMbIndex-dwMbWidth+1].dwMbType==I_8x8 ||
    pMbInfo[dwMbIndex-dwMbWidth+1].predDir[2] == PREDDIRFWD)
  {
    mvC.x = mvC.y = 0;
    BlockDistanceC = 1;
    RefIdxC = -1;
  }
  else
  {
    mvC = pMbInfo[dwMbIndex-dwMbWidth+1].mvBw[2];
    BlockDistanceC = pMbInfo[dwMbIndex-dwMbWidth+1].iBlockDistanceBw[2];
    RefIdxC = pMbInfo[dwMbIndex-dwMbWidth+1].dwMbReferenceIndexBw[2];
  }

  if(RefIdxA !=-1 && RefIdxB == -1 && RefIdxC == -1)
  {
    MVEPred = mvA;
  }
  else if(RefIdxA == -1 && RefIdxB != -1 && RefIdxC == -1)
  {
    MVEPred = mvB;
  }
  else if(RefIdxA ==-1 && RefIdxB == -1 && RefIdxC != -1)
  {
    MVEPred = mvC;
  }
  else
  {
    MVEPred = ScalePredMv(&mvA, &mvB, &mvC, iBlockDistanceBw, BlockDistanceA, BlockDistanceB, BlockDistanceC);
  }

  mvBw = MVEPred;
  
  // average
  for(AVS_INT block=0; block<4; block++)
  {
    pMbInfo[dwMbIndex].mv[block] = mvE;
    pMbInfo[dwMbIndex].mvBw[block] = mvBw;
    pMbInfo[dwMbIndex].iBlockDistance[block] = iBlockDistance; 
    pMbInfo[dwMbIndex].iBlockDistanceBw[block] = iBlockDistanceBw; 

    AVS_INT iImgWidth = dwMbWidth*16;
    AVS_INT iImgHeight = dwMbHeight*16;
    AVS_INT iImgX = (dwMbIndex%dwMbWidth)*16 + (block%2)*8;
    AVS_INT iImgY = (dwMbIndex/dwMbWidth)*16 + (block/2)*8;


    AVS_BYTE PredBw[4][8][8];
    GetBlock(&(pMbInfo[dwMbIndex].mv[block]),iImgX, iImgY, iImgWidth, iImgHeight, ppRefFrame[idxFw]->y, pPred+block*64);
    GetBlock(&(pMbInfo[dwMbIndex].mvBw[block]),iImgX, iImgY, iImgWidth, iImgHeight, ppRefFrame[idxBw]->y, &(PredBw[0][0][0])+block*64);

    AVS_BYTE* pDst = pPred+block*64;
    AVS_BYTE* pSrc = &(PredBw[0][0][0])+block*64;
 
    AverageB8x(pDst, pSrc, 8, 8);
  }

  return AVS_NOERROR;
}

AVS_HRESULT InterPredLumaBSkipDirect(MBINFO* pMbInfo,
                                     AVS_DWORD dwMbIndex, 
                                     const VIDEODATA** ppRefFrame, 
                                     AVS_DWORD dwRefNum, 
                                     AVS_DWORD dwMbWidth, 
                                     AVS_DWORD dwMbHeight, 
                                     AVS_DWORD dwCurrDistanceIndex, 
                                     AVS_DWORD dwSubMb, 
                                     const BWREFINFO* pBwRefInfo, 
                                     AVS_BYTE* pPred)
{
  AVS_BOOL A_BlockAvailable = FALSE;
  AVS_BOOL B_BlockAvailable = FALSE;
  AVS_BOOL C_BlockAvailable = FALSE;
  AVS_BOOL D_BlockAvailable = FALSE;

  AVS_INT  BlockDistanceA=1;
  AVS_INT  BlockDistanceB=1;
  AVS_INT  BlockDistanceC=1;
  AVS_INT  BlockDistanceD=1;

  AVS_INT  RefIdxA = -1;
  AVS_INT  RefIdxB = -1;
  AVS_INT  RefIdxC = -1;
  AVS_INT  RefIdxD = -1;

  MOTIONVECTOR mvA={0,0}, mvB={0,0}, mvC={0,0}, mvD={0,0}, mvFw={0,0}, mvBw={0,0};
  MOTIONVECTOR MVEPred={0,0};

  AVS_INT MbX = dwMbIndex%dwMbWidth;
  AVS_INT MbY = dwMbIndex/dwMbWidth;

  AVS_DWORD dwBlockTypeC = 100;

  AVS_INT idxBw = 0;
  AVS_INT idxFw = 1;
  AVS_INT dirBw = 1;

  MOTIONVECTOR mvRef = pBwRefInfo[dwMbIndex].mvRef[dwSubMb];
  AVS_INT BlockDistanceRef = pBwRefInfo[dwMbIndex].iBlockDistanceRef[dwSubMb];

  AVS_INT iBlockDistance = ((dwCurrDistanceIndex - ppRefFrame[idxFw]->dwDistanceIndex)+512)%512;
  AVS_INT iBlockDistanceBw = ((ppRefFrame[idxBw]->dwDistanceIndex - dwCurrDistanceIndex)+512)%512;

  switch(dwSubMb) {
  case 0:
    if(MbX>0)
      A_BlockAvailable = TRUE;
    if(MbY>0)
      B_BlockAvailable = TRUE;
    if(MbY>0)
      C_BlockAvailable = TRUE;
    if(MbX>0 && MbY>0)
      D_BlockAvailable = TRUE;
  
    if(!A_BlockAvailable || pMbInfo[dwMbIndex-1].dwMbType == I_8x8 ||
      (pMbInfo[dwMbIndex-1].predDir[1] != pMbInfo[dwMbIndex].predDir[0]&&
      pMbInfo[dwMbIndex-1].predDir[1] != PREDDIRSYM))
    {