h263decframep.c

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

  stepCbr = rFrame->stepCb;
  stepCrc = pInfo->VideoSequence.cFrame.stepCr;
  stepCrr = rFrame->stepCr;

  pYc = pInfo->VideoSequence.cFrame.pY + curRow*16*stepYc;
  pCbc = pInfo->VideoSequence.cFrame.pCb + curRow*8*stepCbc;
  pCrc = pInfo->VideoSequence.cFrame.pCr + curRow*8*stepCrc;
  pYr = rFrame->pY + curRow*16*stepYr;
  pCbr = rFrame->pCb + curRow*8*stepCbr;
  pCrr = rFrame->pCr + curRow*8*stepCrr;
  stepF[0] = stepF[1] = stepF[2] = stepF[3] = stepYc; stepF[4] = stepCbc; stepF[5] = stepCrc;

  if (pbFlag) {
    stepYn = pInfo->VideoSequence.nFrame.stepY;
    stepCbn = pInfo->VideoSequence.nFrame.stepCb;
    stepCrn = pInfo->VideoSequence.nFrame.stepCr;
    pYn = pInfo->VideoSequence.nFrame.pY + curRow*16*stepYn;
    pCbn = pInfo->VideoSequence.nFrame.pCb + curRow*8*stepCbn;
    pCrn = pInfo->VideoSequence.nFrame.pCr + curRow*8*stepCrn;
  }

  mbPerRow = VPic->MacroBlockPerRow;
  dy = curRow * 16;
  dx = 0;

  // Bounding rectangles for MV limitation
  limitRectL.x = - 16;
  limitRectL.y = - 16;
  limitRectL.width = VPic->MacroBlockPerRow * 16 + 32;
  limitRectL.height = VPic->MacroBlockPerCol * 16 + 32;
  limitRectC.x = -8;
  limitRectC.y = -8;
  limitRectC.width = VPic->MacroBlockPerRow * 8 + 16;
  limitRectC.height = VPic->MacroBlockPerCol * 8 + 16;

  pMBinfo = pInfo->VideoSequence.MBinfo + curRow * mbPerRow;

  rt = VPic->rtype;

  for (j = 0; j < mbPerRow; j ++) {
    mb_not_coded = (pMBinfo->type == IPPVC_MB_STUFFING);
    mb_type = pMBinfo->type;
    coeffMB = pMBinfoMT->dctCoeffs;
    cbpy = pMBinfoMT->cbpy;
    cbpc = pMBinfoMT->cbpc;

    fourMVmb = (mb_type == IPPVC_MBTYPE_INTER4V || mb_type == IPPVC_MBTYPE_INTER4V_Q);

    if ((mb_type & 0x7F) == IPPVC_MBTYPE_INTRA || (mb_type & 0x7F) == IPPVC_MBTYPE_INTRA_Q) {
      pF[0] = pYc; pF[1] = pYc + 8; pF[2] = pYc + 8 * stepYc; pF[3] = pYc + 8 * stepYc + 8; pF[4] = pCbc; pF[5] = pCrc;
      for (i = 0; i < 6; i ++) {
        if (pMBinfoMT->lnz[i] > 0)
          ippiDCT8x8Inv_16s8u_C1R(&coeffMB[i*64], pF[i], stepF[i]);
        else
          h263_Set8x8_8u(pF[i], stepF[i], (Ipp8u)((coeffMB[i*64] + 4) >> 3));
      }

    } else  {
      if (mb_not_coded && !obmcFlag) {
        ippiCopy16x16_8u_C1R(pYr, stepYr, pYc, stepYc);
        ippiCopy8x8_8u_C1R(pCbr, stepCbr, pCbc, stepCbc);
        ippiCopy8x8_8u_C1R(pCrr, stepCrr, pCrc, stepCrc);
        if (pbFlag) {
          ippiCopy16x16_8u_C1R(pYr, stepYr, pYn, stepYn);
          ippiCopy8x8_8u_C1R(pCbr, stepCbr, pCbn, stepCbn);
          ippiCopy8x8_8u_C1R(pCrr, stepCrr, pCrn, stepCrn);
        }
      } else {
        if (!mb_not_coded) {
          if (!fourMVmb) {
            h263_LimitMV(pMBinfo->mv, mvCur, &limitRectL, dx, dy, 16);
            h263_ComputeChromaMV(mvCur, &mvCbCr);
            if (fourMVmode) {
              mvCur[1] = mvCur[2] = mvCur[3] = mvCur[0];
            }
          } else {
            h263_Limit4MV(pMBinfo->mv, mvCur, &limitRectL, dx, dy, 8);
            h263_ComputeChroma4MV(pMBinfo->mv, &mvCbCr);
            h263_LimitMV(&mvCbCr, &mvCbCr, &limitRectC, dx >> 1, dy >> 1, 8);
          }
          h263_DCT_MacroBlockInter(coeffMB, pMBinfoMT->lnz, (cbpy << 2) + cbpc);


          if (!obmcFlag) {
            if (fourMVmb) {
              h263_MC_HP(cbpy & 8, pYr, stepYr, pYc, stepYc, coeffMB, &mvCur[0], rt);
              h263_MC_HP(cbpy & 4, pYr+8, stepYr, pYc+8, stepYc, coeffMB + 64, &mvCur[1], rt);
              h263_MC_HP(cbpy & 2, pYr+stepYr*8, stepYr, pYc+stepYc*8, stepYc, coeffMB + 2*64, &mvCur[2], rt);
              h263_MC_HP(cbpy & 1, pYr+8+stepYr*8, stepYr, pYc+8+stepYc*8, stepYc, coeffMB + 3*64, &mvCur[3], rt);
            } else if (cbpy) {
              h263_MC_HP(cbpy & 8, pYr, stepYr, pYc, stepYc, coeffMB, &mvCur[0], rt);
              h263_MC_HP(cbpy & 4, pYr+8, stepYr, pYc+8, stepYc, coeffMB + 64, &mvCur[0], rt);
              h263_MC_HP(cbpy & 2, pYr+stepYr*8, stepYr, pYc+stepYc*8, stepYc, coeffMB + 2*64, &mvCur[0], rt);
              h263_MC_HP(cbpy & 1, pYr+8+stepYr*8, stepYr, pYc+8+stepYc*8, stepYc, coeffMB + 3*64, &mvCur[0], rt);
            } else {
              h263_Copy16x16HP_8u(pYr, stepYr, pYc, stepYc, &mvCur[0], rt);
            }
            h263_MC_HP(cbpc & 2, pCbr, stepCbr, pCbc, stepCbc, coeffMB + 4*64, &mvCbCr, rt);
            h263_MC_HP(cbpc & 1, pCrr, stepCrr, pCrc, stepCrc, coeffMB + 5*64, &mvCbCr, rt);
          }
        }
        if (obmcFlag) {
          if (mb_not_coded) {
            ippiCopy8x8_8u_C1R(pCbr, stepCbr, pCbc, stepCbc);
            ippiCopy8x8_8u_C1R(pCrr, stepCrr, pCrc, stepCrc);
            cbpy = 0;
            h263_Zero4MV(mvCur);
          } else {
            h263_MC_HP(cbpc & 2, pCbr, stepCbr, pCbc, stepCbc, coeffMB+256, &mvCbCr, rt);
            h263_MC_HP(cbpc & 1, pCrr, stepCrr, pCrc, stepCrc, coeffMB+320, &mvCbCr, rt);
          }
          h263_OBMC(pInfo, pMBinfo, mvCur, j, curRow, limitRectL, pYc, stepYc, pYr, stepYr, cbpy, coeffMB);
        }
      }
    }

    if (pbFlag) {
      if (mb_not_coded) {
        if (obmcFlag) {
          IppiSize roi;
          roi.height = roi.width = 16;
          ippiCopy16x16_8u_C1R(pYc, stepYc, pYn, stepYn);
          ippiAddBackPredPB_H263_8u_C1R(pYr, stepYr, roi, pYn, stepYn, 0);
          roi.height = roi.width = 8;
          ippiCopy8x8_8u_C1R(pCbc, stepCbc, pCbn, stepCbn);
          ippiAddBackPredPB_H263_8u_C1R(pCbr, stepCbr, roi, pCbn, stepCbn, 0);
          ippiCopy8x8_8u_C1R(pCrc, stepCrc, pCrn, stepCrn);
          ippiAddBackPredPB_H263_8u_C1R(pCrr, stepCrr, roi, pCrn, stepCrn, 0);
        }
      } else {
        Ipp8u *pRefY, *pRefCb, *pRefCr;
        int  stepLum, stepChr;

        cbpb = pMBinfoMT->cbpb;
        bmb_type = pMBinfoMT->bmb_type;
        mvBack = pMBinfoMT->mvB;
        mvForw = pMBinfoMT->mvF;

        if (bmb_type != IPPVC_MBTYPE_BACKWARD) {
          if (bmb_type == IPPVC_MBTYPE_FORWARD) {
            h263_LimitMV(mvForw, mvForw, &limitRectL, dx, dy, 16);
            h263_ComputeChromaMV(&mvForw[0], &mvFCbCr);
          } else {
            if (!fourMVmb) {
              h263_LimitMV(mvForw, mvForw, &limitRectL, dx, dy, 16);
              h263_LimitMV(mvBack, mvBack, &limitRectL, dx, dy, 16);
              h263_ComputeChromaMV(&mvBack[0], &mvBCbCr);
              h263_ComputeChromaMV(&mvForw[0], &mvFCbCr);
            } else {
              h263_Limit4MV(mvForw, mvForw, &limitRectL, dx, dy, 8);
              h263_Limit4MV(mvBack, mvBack, &limitRectL, dx, dy, 8);
              h263_ComputeChroma4MV(&mvForw[0], &mvFCbCr);
              h263_LimitMV(&mvFCbCr, &mvFCbCr, &limitRectC, dx >> 1, dy >> 1, 8);
              h263_ComputeChroma4MV(&mvBack[0], &mvBCbCr);
              h263_LimitMV(&mvBCbCr, &mvBCbCr, &limitRectC, dx >> 1, dy >> 1, 8);
            }
          }
        }

        h263_DCT_MacroBlockInter(pMBinfoMT->dctCoeffs_B, &pMBinfoMT->lnz[6], cbpb);

        if (bmb_type != IPPVC_MBTYPE_FORWARD) {
          if (bmb_type != IPPVC_MBTYPE_BACKWARD) {

            h263_BidirPredMacroblock(pYr, stepYr, pCbr, pCrr, stepCbr, pYc, stepYc, pCbc, pCrc, stepCbc,
                                    predMB, &mvForw[0], &mvFCbCr, &mvBack[0], &mvBCbCr, fourMVmb);


            pRefY  =  predMB;         stepLum = 16;
            pRefCb =  predMB + 4*64;  stepChr = 8;
            pRefCr =  predMB + 5*64;
          } else {
            pRefY  =  pYc;   stepLum = stepYc;
            pRefCb =  pCbc;  stepChr = stepCbc;
            pRefCr =  pCrc;
          }
          h263_MC(cbpb & 32, pRefY, stepLum, pYn, stepYn, pMBinfoMT->dctCoeffs_B);
          h263_MC(cbpb & 16, pRefY+8, stepLum, pYn+8, stepYn, pMBinfoMT->dctCoeffs_B + 64);
          h263_MC(cbpb & 8, pRefY+8*stepLum, stepLum, pYn+8*stepYn, stepYn, pMBinfoMT->dctCoeffs_B + 2*64);
          h263_MC(cbpb & 4, pRefY+8+8*stepLum, stepLum, pYn+8+8*stepYn, stepYn, pMBinfoMT->dctCoeffs_B + 3*64);
          h263_MC(cbpb & 2, pRefCb, stepChr, pCbn, stepCbn, pMBinfoMT->dctCoeffs_B + 4*64);
          h263_MC(cbpb & 1, pRefCr, stepChr, pCrn, stepCrn, pMBinfoMT->dctCoeffs_B + 5*64);
        } else {
          h263_MC_HP(cbpb & 32, pYr, stepYr, pYn, stepYn, pMBinfoMT->dctCoeffs_B, &mvForw[0], 0);
          h263_MC_HP(cbpb & 16, pYr+8, stepYr, pYn+8, stepYn, pMBinfoMT->dctCoeffs_B + 64, &mvForw[0], 0);
          h263_MC_HP(cbpb & 8, pYr+stepYr*8, stepYr, pYn+stepYn*8, stepYn, pMBinfoMT->dctCoeffs_B + 2*64, &mvForw[0], 0);
          h263_MC_HP(cbpb & 4, pYr+8+stepYr*8, stepYr, pYn+8+stepYn*8, stepYn, pMBinfoMT->dctCoeffs_B + 3*64, &mvForw[0], 0);
          h263_MC_HP(cbpb & 2, pCbr, stepCbr, pCbn, stepCbn, pMBinfoMT->dctCoeffs_B + 4*64, &mvFCbCr, 0);
          h263_MC_HP(cbpb & 1, pCrr, stepCrr, pCrn, stepCrn, pMBinfoMT->dctCoeffs_B + 5*64, &mvFCbCr, 0);
        }
      }
    }

    if (VPic->oppmodes.deblockFilt) {
      int quant;
      if (!mb_not_coded) {
        quant = pMBinfo->quant;
        H263_MB_INTERNAL_HOR_DEBLOCKING_LUM(pYc, stepYc, quant);
      }
    }

    pMBinfo++;
    pMBinfoMT++;
    pYc += 16; pCrc += 8; pCbc += 8;
    pYr += 16; pCrr += 8; pCbr += 8;
    if (pbFlag) {
      pYn += 16; pCrn += 8; pCbn += 8;
    }
    dx += 16;
  }
}

/*********************************************************************************/

h263_Status h263_DecodeFrame_P_MT(h263_Info* pInfo, h263_Frame *rFrame)
{
  int        i;
  h263_VideoPicture *VPic = &pInfo->VideoSequence.VideoPicture;
  int        mbPerCol = VPic->MacroBlockPerCol;
  int        mbPerRow = VPic->MacroBlockPerRow;
  h263_Status sts = H263_STATUS_OK;
  int num_rows_per_gob = VPic->RowsPerGOB;
  h263_IntraPredBlock *b;

  // reset Intra prediction buffer
  b = pInfo->VideoSequence.IntraPredBuff.block;
  for (i = 0; i <= mbPerRow; i ++) {
    b[i*6+0].dct_dc = b[i*6+1].dct_dc = b[i*6+2].dct_dc = b[i*6+3].dct_dc = b[i*6+4].dct_dc = b[i*6+5].dct_dc = -1;
  }
  i = 0;

  ippsZero_8u(pInfo->VideoSequence.GOBboundary, mbPerCol);

#ifdef _OPENMP
#pragma  omp parallel shared(pInfo, i, mbPerCol, mbPerRow, sts) num_threads(pInfo->number_threads)
#endif
  {
    int               idThread = 0;   /* the thread id of the calling thread. */
    int               curRow;
    h263_MacroBlockMT* pMBinfoMT;

#ifdef _OPENMP
    idThread = omp_get_thread_num();
#endif
    pMBinfoMT = pInfo->pMBinfoMT + mbPerRow * idThread;
    curRow = i;

    while (curRow < mbPerCol) {

#ifdef _OPENMP
#pragma omp critical(DECODE_SLICE)
#endif
      {
        int gob_header_present;

        curRow = i;
        i++;

        if (curRow < mbPerCol) {
          if (curRow) {
            VPic->gob_number = curRow;
            gob_header_present = h263_ParseGOBHeader(pInfo);

            if (gob_header_present < 0)
              sts = H263_STATUS_PARSE_ERROR;
            else if (gob_header_present) {
              if (VPic->gob_number > 30)
                curRow = mbPerCol; /* EOS or EOSBS */
              else {
                if (VPic->gob_number * num_rows_per_gob - curRow > 0) {
                  ippsSet_8u(127, pInfo->VideoSequence.GOBboundary + curRow, VPic->gob_number * num_rows_per_gob - curRow);
                  curRow = VPic->gob_number * num_rows_per_gob;
                }
                pInfo->VideoSequence.GOBboundary[curRow] = 1;
              }
            }
          }
          if (sts == H263_STATUS_OK)
            if (h263_DecodeFrame_P_DecodeSlice(pInfo, curRow, pMBinfoMT) != H263_STATUS_OK)
              sts = H263_STATUS_ERROR;
        }
      }

      if (curRow < mbPerCol) {
        if (sts == H263_STATUS_OK) {
          h263_DecodeFrame_P_ReconSlice(pInfo, curRow, pMBinfoMT, rFrame);
        }
      }
      curRow++;
    }
  }

  if (sts != H263_STATUS_OK)
    return sts;
  if (VPic->oppmodes.deblockFilt) {
    int curRow;
#ifdef _OPENMP
#pragma  omp parallel for shared(pInfo, mbPerCol) /* num_threads(pInfo->number_threads) */
#endif
    for (curRow = 1; curRow < mbPerCol; curRow++) {
      h263_DeblockingFilterHor_P_MT(pInfo, curRow);
    }

#ifdef _OPENMP
#pragma  omp parallel for shared(pInfo, mbPerCol) /* num_threads(pInfo->number_threads) */
#endif
    for (curRow = 0; curRow < mbPerCol; curRow++) {
      h263_DeblockingFilterVer_P_MT(pInfo, curRow);
    }
  }
  return sts;
}

#endif /* _OMP_KARABAS */