h263decframep.c

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

  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;
        Ipp32s  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) {
      Ipp32s 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)
{
  Ipp32s     i;
  h263_VideoPicture *VPic = &pInfo->VideoSequence.VideoPicture;
  Ipp32s     mbPerCol = VPic->MacroBlockPerCol;
  Ipp32s     mbPerRow = VPic->MacroBlockPerRow;
  h263_Status sts = H263_STATUS_OK;
  Ipp32s num_rows_per_gob = VPic->RowsPerGOB;
  h263_IntraPredBlock *b;
  Ipp32s     sBitOff, sQuant;
  Ipp8u      *sBufPtr;

  sBufPtr = pInfo->bufptr;
  sBitOff = pInfo->bitoff;
  sQuant  = pInfo->VideoSequence.VideoPicture.pic_quant;

  // 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
  {
    Ipp32s             idThread = 0;   /* the thread id of the calling thread. */
    Ipp32s             curRow;
    h263_MacroBlockMT* pMBinfoMT;

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

    for (;;) {
#ifdef _OPENMP
#pragma omp critical(DECODE_SLICE)
#endif
      {
        Ipp32s gob_header_present;
        Ipp32s k;

        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 (gob_header_present && VPic->oppmodes.advIntra) {
              for (k = 0; k <= mbPerRow; k++) {
                b[k*6+0].dct_dc = b[k*6+1].dct_dc = b[k*6+2].dct_dc = b[k*6+3].dct_dc = b[k*6+4].dct_dc = b[k*6+5].dct_dc = -1;
              }
            }
          }
          if (sts == H263_STATUS_OK)
            if (h263_DecodeFrame_P_DecodeSlice(pInfo, curRow, pMBinfoMT) != H263_STATUS_OK) {
              i = curRow = mbPerCol;
              sts = H263_STATUS_ERROR;
            }
        }
      }
      if ((curRow >= mbPerCol) || (sts != H263_STATUS_OK))
        break;
      h263_DecodeFrame_P_ReconSlice(pInfo, curRow, pMBinfoMT, rFrame);
    }
  }

  if (sts != H263_STATUS_OK && !pInfo->stopOnErr) {
    pInfo->bufptr = sBufPtr;
    pInfo->bitoff = sBitOff;
    pInfo->VideoSequence.VideoPicture.pic_quant = sQuant;

    sts = h263_DecodeFrame_P(pInfo, rFrame);
  } else {
    h263_AlignBits(pInfo);
    if (VPic->oppmodes.deblockFilt) {
      Ipp32s 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 */