h263decframeb.c

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

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

    h263_CLIPR(num_rows_per_gob, (mbPerCol - i*num_rows_per_gob));

    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;
      }
    }

    for (row = 0; row < num_rows_per_gob; row++) {
      rowNum = i*num_rows_per_gob + row;
      dy = rowNum * 16;
      for (colNum = 0; colNum < mbPerRow; colNum++) {
        dx = colNum * 16;
        do {
          mb_not_coded = h263_GetBit(pInfo);
          if (mb_not_coded)
            break;
          if (h263_DecodeMBTYPE_B(pInfo, &mb_type, &cbpFlag, &dquantFlag) != H263_STATUS_OK)
            goto Err_1;
        } while (mb_type == IPPVC_MB_STUFFING);

        if (mb_not_coded) {

          h263_CalculateMV_Direct(pMBinfo->mv, mvForw, mvBack, &mvCbCrF, &mvCbCrB, TRD, TRB, pMBinfo->type,
                                  dx, dy, &limitRectL, &limitRectC);

          if (pMBinfo->type == IPPVC_MBTYPE_INTER4V_Q || pMBinfo->type == IPPVC_MBTYPE_INTER4V) {
            h263_Copy8x8HP_8u(pYr, stepYr, tmpMB, 16, &mvForw[0], rt);
            h263_Copy8x8HP_8u(pYc, stepYc, pYn, stepYn, &mvBack[0], rt);
            h263_Copy8x8HP_8u(pYr + 8, stepYr, tmpMB + 8, 16, &mvForw[1], rt);
            h263_Copy8x8HP_8u(pYc + 8, stepYc, pYn + 8, stepYn, &mvBack[1], rt);
            h263_Copy8x8HP_8u(pYr + 8*stepYr, stepYr, tmpMB + 8*16, 16, &mvForw[2], rt);
            h263_Copy8x8HP_8u(pYc + 8*stepYc, stepYc, pYn + 8*stepYn, stepYn, &mvBack[2], rt);
            h263_Copy8x8HP_8u(pYr + 8*stepYr + 8, stepYr, tmpMB + 8 + 8*16, 16, &mvForw[3], rt);
            h263_Copy8x8HP_8u(pYc + 8*stepYc + 8, stepYc, pYn + 8*stepYn + 8, stepYn, &mvBack[3], rt);
          } else {
            h263_Copy16x16HP_8u(pYr, stepYr, tmpMB, 16, &mvForw[0], rt);
            h263_Copy16x16HP_8u(pYc, stepYc, pYn, stepYn, &mvBack[0], rt);
          }

          roiSize.width = roiSize.height = 16;
          ippiAddBackPredPB_H263_8u_C1R(tmpMB, 16, roiSize, pYn, stepYn, 0);

          h263_Copy8x8HP_8u(pCbr, stepCbr, tmpMB, 8, &mvCbCrF, rt);
          h263_Copy8x8HP_8u(pCbc, stepCbc, pCbn, stepCbn, &mvCbCrB, rt);
          roiSize.width = roiSize.height = 8;
          ippiAddBackPredPB_H263_8u_C1R(tmpMB, 8, roiSize, pCbn, stepCbn, 0);

          h263_Copy8x8HP_8u(pCrr, stepCrr, tmpMB, 8, &mvCbCrF, rt);
          h263_Copy8x8HP_8u(pCrc, stepCrc, pCrn, stepCrn, &mvCbCrB, rt);
          ippiAddBackPredPB_H263_8u_C1R(tmpMB, 8, roiSize, pCrn, stepCrn, 0);

          predMVF[colNum].dx = predMVF[colNum].dy = predMVB[colNum].dx = predMVB[colNum].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) {
            if (mb_type == IPPVC_MBTYPE_INTRA || mb_type == IPPVC_MBTYPE_INTRA_Q) {
              h263_AdvI_PredMode(pInfo, predMode);
            } else {
              for (k = 0; k < 6; k++)
                b[(colNum + 1)*6 + k].dct_dc = -1;
            }
          }

          if (cbpFlag) {
            h263_Decode_CBPC_B(pInfo, cbpc);

            if (VPic->oppmodes.altInterVLC && cbpc == 3) { /* ??? */
              if (h263_DecodeCBPY_I(pInfo, &cbpy) != H263_STATUS_OK)
                goto Err_1;
            } else {
              if (h263_DecodeCBPY_B(pInfo, &cbpy, mb_type) != H263_STATUS_OK)
                goto Err_1;
            }

          } else
            cbpc = cbpy = 0;

          if (dquantFlag) {
            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 (mb_type == IPPVC_MBTYPE_FORWARD || mb_type == IPPVC_MBTYPE_INTERPOLATE) {
            if (h263_PredictDecodeMV_B(pInfo, predMVF, &mvForw[0], frGOB, rowNum, colNum) != H263_STATUS_OK) {
              h263_Error("Error when decoding B-frame forward motion vector");
              goto Err_1;
            }
            h263_LimitMV(&mvForw[0], &mvForw[0], &limitRectL, dx, dy, 16);
            h263_ComputeChromaMV(&mvForw[0], &mvCbCrF);
          } else
            predMVF[colNum].dx = predMVF[colNum].dy = 0;

          if (mb_type == IPPVC_MBTYPE_BACKWARD || mb_type == IPPVC_MBTYPE_INTERPOLATE) {
            if (h263_PredictDecodeMV_B(pInfo,  predMVB, &mvBack[0], frGOB, rowNum, colNum) != H263_STATUS_OK) {
              h263_Error("Error when decoding B-frame backward motion vector");
              goto Err_1;
            }
            h263_LimitMV(&mvBack[0], &mvBack[0], &limitRectL, dx, dy, 16);
            h263_ComputeChromaMV(&mvBack[0], &mvCbCrB);
          } else
            predMVB[colNum].dx = predMVB[colNum].dy = 0;

          if (mb_type == IPPVC_MBTYPE_DIRECT) {
            h263_CalculateMV_Direct(pMBinfo->mv, mvForw, mvBack, &mvCbCrF, &mvCbCrB, TRD, TRB, pMBinfo->type,
                                    dx, dy, &limitRectL, &limitRectC);
          }

          if (mb_type == IPPVC_MBTYPE_FORWARD || mb_type == IPPVC_MBTYPE_BACKWARD) {
            IppMotionVector *mvLum, *mvChr;
            Ipp8u *pY, *pCb, *pCr;
            Ipp32s stepY;

            if (mb_type == IPPVC_MBTYPE_FORWARD) {
              pY = pYr; pCb = pCbr; pCr = pCrr;
              stepY = stepYr;
              mvLum = &mvForw[0]; mvChr = &mvCbCrF;
            } else {
              pY = pYc; pCb = pCbc; pCr = pCrc;
              stepY = stepYc;
              mvLum = &mvBack[0]; mvChr = &mvCbCrB;
            }

            if (cbpy) {
              h263_DecodeMCBlockInter(pInfo, quant, cbpy & 8, pY, pYn, stepYn, coeffMB, mvLum, rt);
              h263_DecodeMCBlockInter(pInfo, quant, cbpy & 4, pY+8, pYn+8, stepYn, coeffMB, mvLum, rt);
              h263_DecodeMCBlockInter(pInfo, quant, cbpy & 2, pY+stepY*8, pYn+stepYn*8, stepYn, coeffMB, mvLum, rt);
              h263_DecodeMCBlockInter(pInfo, quant, cbpy & 1, pY+8+stepY*8, pYn+8+stepYn*8, stepYn, coeffMB, mvLum, rt);
            } else {
              h263_Copy16x16HP_8u(pY, stepY, pYn, stepYn, mvLum, rt);
              h263_StatisticInc_(&pInfo->VideoSequence.Statistic.nB_INTER_NC);
              h263_StatisticInc_(&pInfo->VideoSequence.Statistic.nB_INTER_NC);
              h263_StatisticInc_(&pInfo->VideoSequence.Statistic.nB_INTER_NC);
              h263_StatisticInc_(&pInfo->VideoSequence.Statistic.nB_INTER_NC);
            }
            h263_DecodeMCBlockInter(pInfo, quant_c, cbpc & 2, pCb, pCbn, stepCbn, coeffMB, mvChr, rt);
            h263_DecodeMCBlockInter(pInfo, quant_c, cbpc & 1, pCr, pCrn, stepCrn, coeffMB, mvChr, rt);

          } else if (mb_type == IPPVC_MBTYPE_INTERPOLATE || mb_type == IPPVC_MBTYPE_DIRECT) {

            if ((mb_type == IPPVC_MBTYPE_DIRECT) && (pMBinfo->type == IPPVC_MBTYPE_INTER4V_Q || pMBinfo->type == IPPVC_MBTYPE_INTER4V)) {
              h263_Copy8x8HP_8u(pYr, stepYr, tmpMB, 16, &mvForw[0], rt);
              h263_Copy8x8HP_8u(pYc, stepYc, tmpMB + 4*64, 16, &mvBack[0], rt);
              h263_Copy8x8HP_8u(pYr + 8, stepYr, tmpMB + 8, 16, &mvForw[1], rt);
              h263_Copy8x8HP_8u(pYc + 8, stepYc, tmpMB + 4*64 + 8, 16, &mvBack[1], rt);
              h263_Copy8x8HP_8u(pYr + 8*stepYr, stepYr, tmpMB + 8*16, 16, &mvForw[2], rt);
              h263_Copy8x8HP_8u(pYc + 8*stepYc, stepYc, tmpMB + 4*64 + 8*16, 16, &mvBack[2], rt);
              h263_Copy8x8HP_8u(pYr + 8*stepYr + 8, stepYr, tmpMB + 8 + 8*16, 16, &mvForw[3], rt);
              h263_Copy8x8HP_8u(pYc + 8*stepYc + 8, stepYc, tmpMB + 4*64 + 8 + 8*16, 16, &mvBack[3], rt);
            } else {
              h263_Copy16x16HP_8u(pYr, stepYr, tmpMB, 16, &mvForw[0], rt);
              h263_Copy16x16HP_8u(pYc, stepYc, tmpMB + 4*64, 16, &mvBack[0], rt);
            }

            roiSize.width = roiSize.height = 16;
            ippiAddBackPredPB_H263_8u_C1R(tmpMB + 4*64, 16, roiSize, tmpMB, 16, 0);
            h263_DecodeMCBlockInter_B(pInfo, quant, cbpy & 8, tmpMB, 16, pYn, stepYn, coeffMB);
            h263_DecodeMCBlockInter_B(pInfo, quant, cbpy & 4, tmpMB+8, 16, pYn+8, stepYn, coeffMB);
            h263_DecodeMCBlockInter_B(pInfo, quant, cbpy & 2, tmpMB+8*16, 16, pYn+8*stepYn, stepYn, coeffMB);
            h263_DecodeMCBlockInter_B(pInfo, quant, cbpy & 1, tmpMB+8+8*16, 16, pYn+8+8*stepYn, stepYn, coeffMB);

            h263_Copy8x8HP_8u(pCbr, stepCbr, tmpMB, 8, &mvCbCrF, rt);
            h263_Copy8x8HP_8u(pCbc, stepCbc, tmpMB + 64, 8, &mvCbCrB, rt);
            roiSize.width = roiSize.height = 8;
            ippiAddBackPredPB_H263_8u_C1R(tmpMB + 64, 8, roiSize, tmpMB, 8, 0);
            h263_DecodeMCBlockInter_B(pInfo, quant_c, cbpc & 2, tmpMB, 8, pCbn, stepCbn, coeffMB);

            h263_Copy8x8HP_8u(pCrr, stepCrr, tmpMB, 8, &mvCbCrF, rt);
            h263_Copy8x8HP_8u(pCrc, stepCrc, tmpMB + 64, 8, &mvCbCrB, rt);
            ippiAddBackPredPB_H263_8u_C1R(tmpMB + 64, 8, roiSize, tmpMB, 8, 0);
            h263_DecodeMCBlockInter_B(pInfo, quant_c, cbpc & 1, tmpMB, 8, pCrn, stepCrn, coeffMB);

          } else { /* INTRA MB */
            pF[0] = pYn; pF[1] = pYn + 8; pF[2] = pYn + 8 * stepYn; pF[3] = pYn + 8 * stepYn + 8; pF[4] = pCbn; pF[5] = pCrn;

            if (!VPic->oppmodes.advIntra)
              status = h263_DecodeMacroBlockIntra(pInfo, (cbpy << 2) + cbpc, quant, quant_c, pF, stepF);
            else
              status = h263_DecodeMacroBlockIntra_AdvI(pInfo, colNum, (cbpy << 2) + cbpc, quant, quant_c, predMode, pF, stepF);
            if (status != H263_STATUS_OK) {
              h263_Error("Error when decoding coefficients of Intra block");
              goto Err_1;
            }
          }
        }
        pYc += 16; pCrc += 8; pCbc += 8;
        pYr += 16; pCrr += 8; pCbr += 8;
        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;
      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);
  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;
}