h263decframep.c

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

                      h263_MC(cbpbPrev & 32, pRefY, stepLum, pYn, stepYn, coeffMB_b);
                      h263_MC(cbpbPrev & 16, pRefY+8, stepLum, pYn+8, stepYn, coeffMB_b + 64);
                      h263_MC(cbpbPrev & 8, pRefY+8*stepLum, stepLum, pYn+8*stepYn, stepYn, coeffMB_b + 2*64);
                      h263_MC(cbpbPrev & 4, pRefY+8+8*stepLum, stepLum, pYn+8+8*stepYn, stepYn, coeffMB_b + 3*64);
                      h263_MC(cbpbPrev & 2, pRefCb, stepChr, pCbn, stepCbn, coeffMB_b + 4*64);
                      h263_MC(cbpbPrev & 1, pRefCr, stepChr, pCrn, stepCrn, coeffMB_b + 5*64);

                    } else {
                      h263_MC_HP(cbpbPrev & 32, pYr, stepYr, pYn, stepYn, coeffMB_b, &mvForwPrev[0], 0);
                      h263_MC_HP(cbpbPrev & 16, pYr+8, stepYr, pYn+8, stepYn, coeffMB_b + 64, &mvForwPrev[0], 0);
                      h263_MC_HP(cbpbPrev & 8, pYr+8*stepYr, stepYr, pYn+8*stepYn, stepYn, coeffMB_b + 2*64, &mvForwPrev[0], 0);
                      h263_MC_HP(cbpbPrev & 4, pYr+8+8*stepYr, stepYr, pYn+8+8*stepYn, stepYn, coeffMB_b + 3*64, &mvForwPrev[0], 0);
                      h263_MC_HP(cbpbPrev & 2, pCbr, stepCbr, pCbn, stepCbn, coeffMB_b + 4*64, &mvFCbCrPrev, 0);
                      h263_MC_HP(cbpbPrev & 1, pCrr, stepCrr, pCrn, stepCrn, coeffMB_b + 5*64, &mvFCbCrPrev, 0);
                    }
                  }
                }
              }
            }
          }

          h263_StatisticInc_(&pInfo->VideoSequence.Statistic.nMB);

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

          pYc += 16; pCrc += 8; pCbc += 8;
          pYr += 16; pCrr += 8; pCbr += 8;
          if (pbFlag) {
            pYn += 16; pCrn += 8; pCbn += 8;
          }
          pMBinfo++;
        }
        pYc += 2 * H263_NUM_EXT_MB * 16 + (stepYc << 4) - stepYc;
        pCbc += 2 * H263_NUM_EXT_MB * 8 + (stepCbc << 3) - stepCbc;
        pCrc += 2 * H263_NUM_EXT_MB * 8 + (stepCrc << 3) - stepCrc;
        pYr += 2 * H263_NUM_EXT_MB * 16 + (stepYr << 4) - stepYr;
        pCbr += 2 * H263_NUM_EXT_MB * 8 + (stepCbr << 3) - stepCbr;
        pCrr += 2 * H263_NUM_EXT_MB * 8 + (stepCrr << 3) - stepCrr;
        if (pbFlag) {
          pYn += 2 * H263_NUM_EXT_MB * 16 + (stepYn << 4) - stepYn;
          pCbn += 2 * H263_NUM_EXT_MB * 8 + (stepCbn << 3) - stepCbn;
          pCrn += 2 * H263_NUM_EXT_MB * 8 + (stepCrn << 3) - stepCrn;
        }
      }
    }
    h263_AlignBits(pInfo);

    /* Deblocking filtering */
    if (VPic->oppmodes.deblockFilt)
      h263_DeblockingFilter_P(pInfo, &pInfo->VideoSequence.cFrame);

    return H263_STATUS_OK;

Err_1:
    sts = H263_STATUS_ERROR;
    if (pInfo->stopOnErr)
      return sts;
    if (!h263_SeekGOBStartCodePtr(pInfo)) {
      h263_CopyMacroBlocks(&pInfo->VideoSequence.rFrame, &pInfo->VideoSequence.cFrame, mbPerRow, rowNum, colNum,  (mbPerCol - rowNum) * mbPerRow - colNum);
      return sts;
    }
    goto ErrRet_1;
  }
}

#ifdef _OMP_KARABAS

static h263_Status h263_DecodeFrame_P_DecodeSlice(h263_Info* pInfo, Ipp32s curRow, h263_MacroBlockMT* pMBinfoMT)
{
  Ipp32s          quant, quant_c, bquant, bquant_c;
  Ipp32s          mb_not_coded, mb_type = 0, cbpc = 0, cbpy = 0;
  Ipp32s          mbPerRow;
  h263_MacroBlock *pMBinfo;
  IppMotionVector mvForwPred;
  h263_VideoPicture *VPic = &pInfo->VideoSequence.VideoPicture;
  Ipp32s cbpb = 0, mvdb, bmb_type = 0;
  Ipp32s predMode = 0;
  h263_Status status;
  Ipp32s k;
  Ipp32s fourMVmode = VPic->modes.advPred | VPic->oppmodes.advPred | VPic->oppmodes.deblockFilt;
  Ipp32s pbFlag = VPic->picture_coding_type == H263_PIC_TYPE_PB || VPic->picture_coding_type == H263_PIC_TYPE_iPB;
  Ipp32s trd = VPic->temporal_reference - VPic->prev_temporal_reference;
  Ipp32s trb = VPic->temporal_reference_B;
  Ipp32s frGOB;
  h263_IntraPredBlock *b = pInfo->VideoSequence.IntraPredBuff.block;
  Ipp32s colNum;
  Ipp32s fourMVmb;

  if (trd < 0)
    trd += VPic->PCF ? 1024 : 256;

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

  frGOB = pInfo->VideoSequence.GOBboundary[curRow] ? curRow : 0;

  quant = quant_c = VPic->pic_quant;
  if (VPic->oppmodes.modQuant)
    quant_c = h263_quant_c[quant];

  if (VPic->picture_coding_type == H263_PIC_TYPE_PB || VPic->picture_coding_type == H263_PIC_TYPE_iPB) {
    bquant_c = bquant = (VPic->dbquant + 5)*quant >> 2;
    h263_CLIPR(bquant, 31);
    if (VPic->oppmodes.modQuant)
      bquant_c = h263_quant_c[bquant];
  }

  for (colNum = 0; colNum < mbPerRow; colNum++) {
    do {
      mb_not_coded = h263_GetBit(pInfo);
      if (mb_not_coded)
        break;
      if (h263_DecodeMCBPC_P(pInfo, &mb_type, &cbpc, 1) != H263_STATUS_OK)
        return H263_STATUS_ERROR;
    } while (mb_type == IPPVC_MB_STUFFING);

    if (mb_not_coded) {

      mb_type = pMBinfo->type = IPPVC_MB_STUFFING; /* to indicate mb_not_coded */

      h263_Zero4MV(pMBinfo->mv);
      mvForwPred.dx = mvForwPred.dy = 0;
      if (VPic->oppmodes.advIntra) {
        for (k = 0; k < 6; k++)
          b[(colNum + 1)*6 + k].dct_dc = -1;
      }
      h263_StatisticInc_(&pInfo->VideoSequence.Statistic.nMB_NOTCODED);
    } else {

      if (VPic->oppmodes.advIntra && (mb_type == IPPVC_MBTYPE_INTRA || mb_type == IPPVC_MBTYPE_INTRA_Q))
        h263_AdvI_PredMode(pInfo, predMode);

      mvdb = cbpb = 0;
      if (VPic->picture_coding_type == H263_PIC_TYPE_PB) {
        if (h263_GetBit(pInfo)) {
          mvdb = 1;
          cbpb = h263_GetBit(pInfo);
        } else {
          pMBinfoMT->mvF[0].dx = pMBinfoMT->mvF[0].dy = pMBinfoMT->mvB[0].dx = pMBinfoMT->mvB[0].dy = 0;
        }
        bmb_type = -1;
      } else if (VPic->picture_coding_type == H263_PIC_TYPE_iPB) {
        h263_DecodeMODB_iPB(pInfo, &bmb_type, &cbpb, &mvdb);
        if (!mvdb || colNum == 0)
          mvForwPred.dx = mvForwPred.dy = 0;
      }
      if (cbpb)
        cbpb = h263_GetBits9(pInfo, 6);

      if (VPic->oppmodes.altInterVLC && cbpc == 3) {
        if (h263_DecodeCBPY_I(pInfo, &cbpy) != H263_STATUS_OK)
          return H263_STATUS_ERROR;
      } else {
        if (h263_DecodeCBPY_P(pInfo, &cbpy, mb_type) != H263_STATUS_OK)
          return H263_STATUS_ERROR;
      }

      pMBinfo->type = (Ipp8u)mb_type;
      pMBinfoMT->cbpc = cbpc;
      pMBinfoMT->cbpy = cbpy;
      pMBinfoMT->cbpb = cbpb;
      pMBinfoMT->bmb_type = bmb_type;
      fourMVmb = (mb_type == IPPVC_MBTYPE_INTER4V || mb_type == IPPVC_MBTYPE_INTER4V_Q);

      if (mb_type == IPPVC_MBTYPE_INTRA_Q || mb_type == IPPVC_MBTYPE_INTER_Q || mb_type == IPPVC_MBTYPE_INTER4V_Q) {
        if (!VPic->oppmodes.modQuant) {
          h263_UpdateQuant(pInfo, VPic->pic_quant);
          quant_c = VPic->pic_quant;
        } else {
          quant_c = h263_UpdateQuant_Mod(pInfo);
        }
        quant = VPic->pic_quant;
        if (VPic->picture_coding_type == H263_PIC_TYPE_PB || VPic->picture_coding_type == H263_PIC_TYPE_iPB) {
          bquant_c = bquant = (VPic->dbquant + 5)*quant >> 2;
          h263_CLIPR(bquant, 31);
          if (VPic->oppmodes.modQuant)
            bquant_c = h263_quant_c[bquant];
        }
      }
      pMBinfo->quant = (Ipp8u)quant;

      if (mb_type == IPPVC_MBTYPE_INTRA || mb_type == IPPVC_MBTYPE_INTRA_Q) {
        if (VPic->picture_coding_type == H263_PIC_TYPE_PB || (VPic->picture_coding_type == H263_PIC_TYPE_iPB && bmb_type == IPPVC_MBTYPE_INTERPOLATE)) {
          if (h263_PredictDecodeMV(pInfo, pMBinfo, frGOB, curRow, colNum, fourMVmode) != H263_STATUS_OK) {
            h263_Error("Error when decoding motion vector");
            return H263_STATUS_ERROR;
          }
          if (fourMVmode) {
            pMBinfo->mv[1] = pMBinfo->mv[2] = pMBinfo->mv[3] = pMBinfo->mv[0];
          }
        } else {
          if (!fourMVmode)
            pMBinfo->mv[0].dx = pMBinfo->mv[0].dy = 0;
          else {
            h263_Zero4MV(pMBinfo->mv);
            pMBinfo->type |= 0x80;
          }
        }

        if (pbFlag && bmb_type != IPPVC_MBTYPE_BACKWARD) {
          if (h263_PredictDecode4MV_PB(pInfo, &pMBinfo->mv[0], &pMBinfoMT->mvF[0], &pMBinfoMT->mvB[0], &mvForwPred,
              bmb_type, mvdb, trd, trb, 0) != H263_STATUS_OK) {
            h263_Error("Error when decoding MVDB");
            return H263_STATUS_ERROR;
          }
        }

        status = h263_DecodeDequantMacroBlockIntra(pInfo, colNum, (cbpy << 2) + cbpc, quant, quant_c, predMode,
                                                   pMBinfoMT->dctCoeffs, pMBinfoMT->lnz);
        if (status != H263_STATUS_OK) {
          h263_Error("Error when decoding coefficients of Intra block");
          return H263_STATUS_ERROR;
        }

        if (pbFlag) {
          status = h263_DecodeDequantMacroBlockInter(pInfo, cbpb, bquant, bquant_c,
                                                     pMBinfoMT->dctCoeffs_B, &pMBinfoMT->lnz[6]);
          if (status != H263_STATUS_OK) {
            h263_Error("Error when decoding coefficients of a B-block");
            return H263_STATUS_ERROR;
          }
        }
      } else { /* INTER MB */

        if (VPic->oppmodes.advIntra) {
          for (k = 0; k < 6; k++)
            b[(colNum + 1)*6 + k].dct_dc = -1;
        }

        if (!fourMVmb) {
          if (h263_PredictDecodeMV(pInfo, pMBinfo, frGOB, curRow, colNum, fourMVmode) != H263_STATUS_OK) {
            h263_Error("Error when decoding motion vector");
            return H263_STATUS_ERROR;
          }
          if (fourMVmode) {
            pMBinfo->mv[1] = pMBinfo->mv[2] = pMBinfo->mv[3] = pMBinfo->mv[0];
          }

          if (pbFlag && bmb_type != IPPVC_MBTYPE_BACKWARD) {
            if (h263_PredictDecode4MV_PB(pInfo, &pMBinfo->mv[0], &pMBinfoMT->mvF[0], &pMBinfoMT->mvB[0], &mvForwPred,
                bmb_type, mvdb, trd, trb, 0) != H263_STATUS_OK) {
              h263_Error("Error when decoding MVDB");
              return H263_STATUS_ERROR;
            }
          }
        } else {
          if (h263_PredictDecode4MV(pInfo, pMBinfo, frGOB, curRow, colNum) != H263_STATUS_OK) {
            h263_Error("Error when decoding motion vectors");
            return H263_STATUS_ERROR;
          }

          if (pbFlag && bmb_type != IPPVC_MBTYPE_BACKWARD) {
            if (h263_PredictDecode4MV_PB(pInfo, &pMBinfo->mv[0], &pMBinfoMT->mvF[0], &pMBinfoMT->mvB[0], &mvForwPred,
                bmb_type, mvdb, trd, trb, 1) != H263_STATUS_OK) {
              h263_Error("Error when decoding MVDB");
              return H263_STATUS_ERROR;
            }
          }
        }

        status = h263_DecodeDequantMacroBlockInter(pInfo, (cbpy << 2) | cbpc, quant, quant_c,
                                                    pMBinfoMT->dctCoeffs, &pMBinfoMT->lnz[0]);
        if (status != H263_STATUS_OK) {
          h263_Error("Error when decoding coefficients of a P-block");
          return H263_STATUS_ERROR;
        }

        if (pbFlag) {
          status = h263_DecodeDequantMacroBlockInter(pInfo, cbpb, bquant, bquant_c,
                                                     pMBinfoMT->dctCoeffs_B, &pMBinfoMT->lnz[6]);
          if (status != H263_STATUS_OK) {
            h263_Error("Error when decoding coefficients of a B-block");
            return H263_STATUS_ERROR;
          }
        }

      }
    }

    h263_StatisticInc_(&pInfo->VideoSequence.Statistic.nMB);
    pMBinfo++;
    pMBinfoMT++;
  }
  // skip stuffing
  while (h263_ShowBits(pInfo, 10) == 1)
    h263_FlushBits(pInfo, 10);
  return H263_STATUS_OK;
}

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

static void h263_DecodeFrame_P_ReconSlice(h263_Info* pInfo, Ipp32s curRow, h263_MacroBlockMT* pMBinfoMT, h263_Frame *rFrame)
{
  __ALIGN16(Ipp8u, predMB, 64*6);
  Ipp32s          i, j, dx, dy;
  Ipp32s          stepYr, stepYc, stepCbr, stepCbc, stepCrr, stepCrc, mbPerRow;
  Ipp32s          stepF[6];
  Ipp8u           *pYc, *pCbc, *pCrc, *pYr, *pCbr, *pCrr, *pF[6];
  Ipp8u           *pYn, *pCbn, *pCrn;
  Ipp32s          stepYn, stepCbn, stepCrn;
  Ipp32s          mb_not_coded, mb_type, cbpc, cbpy;
  h263_MacroBlock *pMBinfo;
  Ipp32s          rt;
  IppiRect        limitRectL, limitRectC;
  IppMotionVector mvCur[4], mvCbCr;
  IppMotionVector *mvBack, *mvForw, mvFCbCr, mvBCbCr;
  h263_VideoPicture *VPic = &pInfo->VideoSequence.VideoPicture;
  Ipp32s cbpb, bmb_type;
  Ipp32s fourMVmode = VPic->modes.advPred | VPic->oppmodes.advPred | VPic->oppmodes.deblockFilt;
  Ipp32s obmcFlag = VPic->modes.advPred | VPic->oppmodes.advPred;
  Ipp32s pbFlag = VPic->picture_coding_type == H263_PIC_TYPE_PB || VPic->picture_coding_type == H263_PIC_TYPE_iPB;
  Ipp16s* coeffMB;
  Ipp32s fourMVmb;

  stepYc = pInfo->VideoSequence.cFrame.stepY;
  stepYr = rFrame->stepY;
  stepCbc = pInfo->VideoSequence.cFrame.stepCb;
  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;