h263decframep.c

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

                else {
                  pMBinfo->type |= 0x80; /* to indicate to OBMC that no MV is present */
                  h263_Zero4MV(pMBinfo->mv);
                }
              }

              if (pbFlag && bmb_type != IPPVC_MBTYPE_BACKWARD) {
                if (h263_PredictDecode4MV_PB(pInfo, &pMBinfo->mv[0], &mvForw[0], &mvBack[0], &mvForwPred,
                    bmb_type, mvdb, trd, trb, 0) != H263_STATUS_OK) {
                  h263_Error("Error when decoding MVDB");
                  return H263_STATUS_ERROR;
                }
                h263_LimitMV(mvForw, mvForw, &limitRectL, dx, dy, 16);
                h263_ComputeChromaMV(&mvForw[0], &mvFCbCr);
                if (bmb_type != IPPVC_MBTYPE_FORWARD) {
                  h263_LimitMV(mvBack, mvBack, &limitRectL, dx, dy, 16);
                  h263_ComputeChromaMV(&mvBack[0], &mvBCbCr);
                }
              }

              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");
                return H263_STATUS_ERROR;
              }
              if (pbFlag) {
                Ipp8u *pRefY, *pRefCb, *pRefCr;
                int  stepLum, stepChr;

                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, 0);

                    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_DecodeMCBlockInter_B(pInfo, bquant, cbpb & 32, pRefY, stepLum, pYn, stepYn, coeffMB_bI);
                  h263_DecodeMCBlockInter_B(pInfo, bquant, cbpb & 16, pRefY+8, stepLum, pYn+8, stepYn, coeffMB_bI);
                  h263_DecodeMCBlockInter_B(pInfo, bquant, cbpb & 8, pRefY+8*stepLum, stepLum, pYn+8*stepYn, stepYn, coeffMB_bI);
                  h263_DecodeMCBlockInter_B(pInfo, bquant, cbpb & 4, pRefY+8+8*stepLum, stepLum, pYn+8+8*stepYn, stepYn, coeffMB_bI);
                  h263_DecodeMCBlockInter_B(pInfo, bquant_c, cbpb & 2, pRefCb, stepChr, pCbn, stepCbn, coeffMB_bI);
                  h263_DecodeMCBlockInter_B(pInfo, bquant_c, cbpb & 1, pRefCr, stepChr, pCrn, stepCrn, coeffMB_bI);

                } else {
                  if (cbpb & 60) {
                    h263_DecodeMCBlockInter(pInfo, bquant, cbpb & 32, pYr, pYn, stepYr, coeffMB_bI, &mvForw[0], 0);
                    h263_DecodeMCBlockInter(pInfo, bquant, cbpb & 16, pYr+8, pYn+8, stepYr, coeffMB_bI, &mvForw[0], 0);
                    h263_DecodeMCBlockInter(pInfo, bquant, cbpb & 8, pYr+stepYr*8, pYn+stepYn*8, stepYr, coeffMB_bI, &mvForw[0], 0);
                    h263_DecodeMCBlockInter(pInfo, bquant, cbpb & 4, pYr+8+stepYr*8, pYn+8+stepYn*8, stepYr, coeffMB_bI, &mvForw[0], 0);
                  } else {
                    h263_Copy16x16HP_8u(pYr, stepYr, pYn, stepYn, &mvForw[0], 0);
                    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, bquant_c, cbpb & 2, pCbr, pCbn, stepCbr, coeffMB_bI, &mvFCbCr, 0);
                  h263_DecodeMCBlockInter(pInfo, bquant_c, cbpb & 1, pCrr, pCrn, stepCrr, coeffMB_bI, &mvFCbCr, 0);
                }
              }
            } else { /* INTER MB */

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

              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, rowNum, colNum, fourMVmode) != H263_STATUS_OK) {
                  h263_Error("Error when decoding motion vector");
                  return H263_STATUS_ERROR;
                }
                h263_LimitMV(&pMBinfo->mv[0], &mvCur[0], &limitRectL, dx, dy, 16);
                h263_ComputeChromaMV(&mvCur[0], &mvCbCr);
                if (fourMVmode) {
                  mvCur[1] = mvCur[2] = mvCur[3] = mvCur[0];
                  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], &mvForw[0], &mvBack[0], &mvForwPred,
                      bmb_type, mvdb, trd, trb, 0) != H263_STATUS_OK) {
                    h263_Error("Error when decoding MVDB");
                    return H263_STATUS_ERROR;
                  }
                  h263_LimitMV(mvForw, mvForw, &limitRectL, dx, dy, 16);
                  h263_ComputeChromaMV(&mvForw[0], &mvFCbCr);
                  if (bmb_type != IPPVC_MBTYPE_FORWARD) {
                    h263_LimitMV(mvBack, mvBack, &limitRectL, dx, dy, 16);
                    h263_ComputeChromaMV(&mvBack[0], &mvBCbCr);
                  }
                }
              } else {
                if (h263_PredictDecode4MV(pInfo, pMBinfo, frGOB, rowNum, colNum) != H263_STATUS_OK) {
                  h263_Error("Error when decoding motion vectors");
                  return H263_STATUS_ERROR;
                }
                h263_Limit4MV(pMBinfo->mv, mvCur, &limitRectL, dx, dy, 8);
                h263_ComputeChroma4MV(pMBinfo->mv, &mvCbCr);
                h263_LimitMV(&mvCbCr, &mvCbCr, &limitRectC, dx >> 1, dy >> 1, 8);

                if (pbFlag && bmb_type != IPPVC_MBTYPE_BACKWARD) {
                  if (h263_PredictDecode4MV_PB(pInfo, &pMBinfo->mv[0], &mvForw[0], &mvBack[0], &mvForwPred,
                      bmb_type, mvdb, trd, trb, 1) != H263_STATUS_OK) {
                    h263_Error("Error when decoding MVDB");
                    return H263_STATUS_ERROR;
                  }
                  h263_Limit4MV(mvForw, mvForw, &limitRectL, dx, dy, 8);
                  if (bmb_type != IPPVC_MBTYPE_FORWARD) {
                    h263_Limit4MV(mvBack, mvBack, &limitRectL, dx, dy, 8);
                    h263_ComputeChroma4MV(&mvBack[0], &mvBCbCr);
                    h263_LimitMV(&mvBCbCr, &mvBCbCr, &limitRectC, dx >> 1, dy >> 1, 8);
                    h263_ComputeChroma4MV(&mvForw[0], &mvFCbCr);
                  } else
                    h263_ComputeChromaMV(&mvForw[0], &mvFCbCr);
                  h263_LimitMV(&mvFCbCr, &mvFCbCr, &limitRectC, dx >> 1, dy >> 1, 8);
                }
              }

              /* decode and MC blocks */
              if (!obmcFlag) {
                if (fourMVmb) {
                  h263_DecodeMCBlockInter(pInfo, quant, cbpy & 8, pYr, pYc, stepYr, coeffMB, &mvCur[0], rt);
                  h263_DecodeMCBlockInter(pInfo, quant, cbpy & 4, pYr+8, pYc+8, stepYr, coeffMB, &mvCur[1], rt);
                  h263_DecodeMCBlockInter(pInfo, quant, cbpy & 2, pYr+stepYr*8, pYc+stepYc*8, stepYr, coeffMB, &mvCur[2], rt);
                  h263_DecodeMCBlockInter(pInfo, quant, cbpy & 1, pYr+8+stepYr*8, pYc+8+stepYc*8, stepYr, coeffMB, &mvCur[3], rt);
                } else if (cbpy) {
                  h263_DecodeMCBlockInter(pInfo, quant, cbpy & 8, pYr, pYc, stepYr, coeffMB, &mvCur[0], rt);
                  h263_DecodeMCBlockInter(pInfo, quant, cbpy & 4, pYr+8, pYc+8, stepYr, coeffMB, &mvCur[0], rt);
                  h263_DecodeMCBlockInter(pInfo, quant, cbpy & 2, pYr+stepYr*8, pYc+stepYc*8, stepYr, coeffMB, &mvCur[0], rt);
                  h263_DecodeMCBlockInter(pInfo, quant, cbpy & 1, pYr+8+stepYr*8, pYc+8+stepYc*8, stepYr, coeffMB, &mvCur[0], rt);
                } else {
                  h263_Copy16x16HP_8u(pYr, stepYr, pYc, stepYc, &mvCur[0], 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, pCbr, pCbc, stepCbr, coeffMB, &mvCbCr, rt);
                h263_DecodeMCBlockInter(pInfo, quant_c, cbpc & 1, pCrr, pCrc, stepCrr, coeffMB, &mvCbCr, rt);

                if (pbFlag) {
                  Ipp8u *pRefY, *pRefCb, *pRefCr;
                  int  stepLum, stepChr;

                  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_DecodeMCBlockInter_B(pInfo, bquant, cbpb & 32, pRefY, stepLum, pYn, stepYn, coeffMB_b);
                    h263_DecodeMCBlockInter_B(pInfo, bquant, cbpb & 16, pRefY+8, stepLum, pYn+8, stepYn, coeffMB_b);
                    h263_DecodeMCBlockInter_B(pInfo, bquant, cbpb & 8, pRefY+8*stepLum, stepLum, pYn+8*stepYn, stepYn, coeffMB_b);
                    h263_DecodeMCBlockInter_B(pInfo, bquant, cbpb & 4, pRefY+8+8*stepLum, stepLum, pYn+8+8*stepYn, stepYn, coeffMB_b);
                    h263_DecodeMCBlockInter_B(pInfo, bquant_c, cbpb & 2, pRefCb, stepChr, pCbn, stepCbn, coeffMB_b);
                    h263_DecodeMCBlockInter_B(pInfo, bquant_c, cbpb & 1, pRefCr, stepChr, pCrn, stepCrn, coeffMB_b);

                  } else {
                    if (cbpb >> 2) {
                      h263_DecodeMCBlockInter(pInfo, bquant, cbpb & 32, pYr, pYn, stepYr, coeffMB_b, &mvForw[0], 0);
                      h263_DecodeMCBlockInter(pInfo, bquant, cbpb & 16, pYr+8, pYn+8, stepYr, coeffMB_b, &mvForw[0], 0);
                      h263_DecodeMCBlockInter(pInfo, bquant, cbpb & 8, pYr+stepYr*8, pYn+stepYn*8, stepYr, coeffMB_b, &mvForw[0], 0);
                      h263_DecodeMCBlockInter(pInfo, bquant, cbpb & 4, pYr+8+stepYr*8, pYn+8+stepYn*8, stepYr, coeffMB_b, &mvForw[0], 0);
                    } else {
                      h263_Copy16x16HP_8u(pYr, stepYr, pYn, stepYn, &mvForw[0], 0);
                      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, bquant_c, cbpb & 2, pCbr, pCbn, stepCbr, coeffMB_b, &mvFCbCr, 0);
                    h263_DecodeMCBlockInter(pInfo, bquant_c, cbpb & 1, pCrr, pCrn, stepCrr, coeffMB_b, &mvFCbCr, 0);
                  }
                }
              }
            }
          }

         if (obmcFlag) {
            /* OBMC for previous MB */
            if (colNum > 0) {
              if ((pMBinfo[-1].type & 0x7F) != IPPVC_MBTYPE_INTRA && (pMBinfo[-1].type & 0x7F) != IPPVC_MBTYPE_INTRA_Q) { /* type may have been ORed with 0x80 */
                h263_OBMC(pInfo, pMBinfo - 1, mvPrev, colNum - 1, rowNum, limitRectL, pYc - 16, stepYc, pYr - 16, stepYr, cbpyPrev, coeffMB);

                if (pbFlag) {
                  if (pMBinfo[-1].type == IPPVC_MB_STUFFING) {
                    IppiSize roi;
                    roi.height = roi.width = 16;
                    ippiCopy16x16_8u_C1R(pYc - 16, stepYc, pYn - 16, stepYn);
                    ippiAddBackPredPB_H263_8u_C1R(pYr - 16, stepYr, roi, pYn - 16, stepYn, 0);
                    roi.height = roi.width = 8;
                    ippiCopy8x8_8u_C1R(pCbc - 8, stepCbc, pCbn - 8, stepCbn);
                    ippiAddBackPredPB_H263_8u_C1R(pCbr - 8, stepCbr, roi, pCbn - 8, stepCbn, 0);
                    ippiCopy8x8_8u_C1R(pCrc - 8, stepCrc, pCrn - 8, stepCrn);
                    ippiAddBackPredPB_H263_8u_C1R(pCrr - 8, stepCrr, roi, pCrn - 8, stepCrn, 0);
                  } else {
                    Ipp8u *pRefY, *pRefCb, *pRefCr;
                    int  stepLum, stepChr;
                    int prev4MVmb = (pMBinfo[-1].type == IPPVC_MBTYPE_INTER4V || pMBinfo[-1].type == IPPVC_MBTYPE_INTER4V_Q);

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

                        h263_BidirPredMacroblock(pYr - 16, stepYr, pCbr - 8, pCrr - 8, stepCbr, pYc - 16, stepYc, pCbc - 8, pCrc - 8, stepCbc,
                                                predMB, &mvForwPrev[0], &mvFCbCrPrev, &mvBackPrev[0], &mvBCbCrPrev, prev4MVmb);

                        pRefY  =  predMB;         stepLum = 16;
                        pRefCb =  predMB + 4*64;  stepChr = 8;
                        pRefCr =  predMB + 5*64;
                      } else {
                        pRefY  =  pYc - 16;  stepLum = stepYc;
                        pRefCb =  pCbc - 8;  stepChr = stepCbc;
                        pRefCr =  pCrc - 8;
                      }
                      h263_MC(cbpbPrev & 32, pRefY, stepLum, pYn-16, stepYn, coeffMB_b);
                      h263_MC(cbpbPrev & 16, pRefY+8, stepLum, pYn-16+8, stepYn, coeffMB_b + 64);
                      h263_MC(cbpbPrev & 8, pRefY+8*stepLum, stepLum, pYn-16+8*stepYn, stepYn, coeffMB_b + 2*64);
                      h263_MC(cbpbPrev & 4, pRefY+8+8*stepLum, stepLum, pYn-16+8+8*stepYn, stepYn, coeffMB_b + 3*64);
                      h263_MC(cbpbPrev & 2, pRefCb, stepChr, pCbn-8, stepCbn, coeffMB_b + 4*64);
                      h263_MC(cbpbPrev & 1, pRefCr, stepChr, pCrn-8, stepCrn, coeffMB_b + 5*64);
                    } else {
                      h263_MC_HP(cbpbPrev & 32, pYr-16, stepYr, pYn-16, stepYn, coeffMB_b, &mvForwPrev[0], 0);
                      h263_MC_HP(cbpbPrev & 16, pYr-16+8, stepYr, pYn-16+8, stepYn, coeffMB_b + 64, &mvForwPrev[0], 0);
                      h263_MC_HP(cbpbPrev & 8, pYr-16+8*stepYr, stepYr, pYn-16+8*stepYn, stepYn, coeffMB_b + 2*64, &mvForwPrev[0], 0);
                      h263_MC_HP(cbpbPrev & 4, pYr-16+8+8*stepYr, stepYr, pYn-16+8+8*stepYn, stepYn, coeffMB_b + 3*64, &mvForwPrev[0], 0);
                      h263_MC_HP(cbpbPrev & 2, pCbr-8, stepCbr, pCbn-8, stepCbn, coeffMB_b + 4*64, &mvFCbCrPrev, 0);
                      h263_MC_HP(cbpbPrev & 1, pCrr-8, stepCrr, pCrn-8, stepCrn, coeffMB_b + 5*64, &mvFCbCrPrev, 0);
                    }
                  }
                }
              }
            }
            if (mb_type != IPPVC_MBTYPE_INTRA && mb_type != IPPVC_MBTYPE_INTRA_Q) {
              if (mb_not_coded) {
                cbpyPrev = 0;
                h263_Zero4MV(mvPrev);
                ippiCopy8x8_8u_C1R(pCbr, stepCbr, pCbc, stepCbc);
                ippiCopy8x8_8u_C1R(pCrr, stepCrr, pCrc, stepCrc);
              } else {
                cbpyPrev = cbpy;
                mvPrev[0] = mvCur[0]; mvPrev[1] = mvCur[1]; mvPrev[2] = mvCur[2]; mvPrev[3] = mvCur[3];
                if (h263_DecodeMacroBlockInter(pInfo, coeffMB, quant, quant_c, (cbpy << 2) + cbpc) != H263_STATUS_OK) {
                  h263_Error("Error when decoding coefficients of Inter block");
                  return H263_STATUS_ERROR;
                }
                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);

                if (pbFlag) {
                  cbpbPrev = cbpb;
                  bmb_typePrev = bmb_type;
                  if (bmb_type == -1 || bmb_type == IPPVC_MBTYPE_INTERPOLATE) {
                    mvBackPrev[0] = mvBack[0];
                    if (fourMVmb) {
                      mvBackPrev[1] = mvBack[1]; mvBackPrev[2] = mvBack[2]; mvBackPrev[3] = mvBack[3];
                      mvForwPrev[1] = mvForw[1]; mvForwPrev[2] = mvForw[2]; mvForwPrev[3] = mvForw[3];
                    }
                    mvBCbCrPrev = mvBCbCr;
                  }
                  mvForwPrev[0] = mvForw[0];
                  mvFCbCrPrev = mvFCbCr;

                  if (h263_DecodeMacroBlockInter(pInfo, coeffMB_b, bquant, bquant_c, cbpb) != H263_STATUS_OK) {
                    h263_Error("Error when decoding coefficients of Inter block");
                    return H263_STATUS_ERROR;
                  }
                }
              }

              if (colNum == mbPerRow - 1) {
                h263_OBMC(pInfo, pMBinfo, mvPrev, colNum, rowNum, limitRectL, pYc, stepYc, pYr, stepYr, cbpyPrev, coeffMB);

                if (pbFlag) {
                  Ipp8u *pRefY, *pRefCb, *pRefCr;
                  if (mb_not_coded) {
                    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 {
                    int  stepLum, stepChr;
                    if (bmb_typePrev != IPPVC_MBTYPE_FORWARD) {
                      if (bmb_typePrev != IPPVC_MBTYPE_BACKWARD) {

                        h263_BidirPredMacroblock(pYr, stepYr, pCbr, pCrr, stepCbr, pYc, stepYc, pCbc, pCrc, stepCbc,
                                                predMB, &mvForwPrev[0], &mvFCbCrPrev, &mvBackPrev[0], &mvBCbCrPrev, fourMVmb);

                        pRefY  =  predMB;         stepLum = 16;
                        pRefCb =  predMB + 4*64;  stepChr = 8;
                        pRefCr =  predMB + 5*64;