h263decframe.c

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

            pDst2 += step;
        }
    } else if (expandPels == 16) {
        for (i = 0; i < frameHeight; i ++) {
            t1 = pDst1[16] + (pDst1[16] << 8);
            t2 = pDst2[-1] + (pDst2[-1] << 8);
            t1 = (t1 << 16) + t1;
            t2 = (t2 << 16) + t2;
            ((Ipp32u*)pDst1)[0] = t1;
            ((Ipp32u*)pDst1)[1] = t1;
            ((Ipp32u*)pDst1)[2] = t1;
            ((Ipp32u*)pDst1)[3] = t1;
            ((Ipp32u*)pDst2)[0] = t2;
            ((Ipp32u*)pDst2)[1] = t2;
            ((Ipp32u*)pDst2)[2] = t2;
            ((Ipp32u*)pDst2)[3] = t2;
            pDst1 += step;
            pDst2 += step;
        }
    } else {
        for (i = 0; i < frameHeight; i ++) {
            ippsSet_8u(pDst1[expandPels], pDst1, expandPels);
            ippsSet_8u(pDst2[-1], pDst2, expandPels);
            pDst1 += step;
            pDst2 += step;
        }
    }
    pDst1 = pSrcDstPlane;
    pSrc1 = pSrcDstPlane + expandPels * step;
    pDst2 = pSrc1 + frameHeight * step;
    pSrc2 = pDst2 - step;
    j = frameWidth + 2 * expandPels;
    for (i = 0; i < expandPels; i ++) {
        ippsCopy_8u(pSrc1, pDst1, j);
        ippsCopy_8u(pSrc2, pDst2, j);
        pDst1 += step;
        pDst2 += step;
    }
}

/*
//  padding Picture: replication
*/

static void h263_PadFrame(h263_Frame *frame)
{
  int  wL, hL, wC, hC;
  wL = frame->mbPerRow * 16;
  hL = frame->mbPerCol * 16;
  wC = frame->mbPerRow * 8;
  hC = frame->mbPerCol * 8;
  h263_ExpandFrameReplicate(frame->apY, wL, hL, 16, frame->stepY);
  h263_ExpandFrameReplicate(frame->apCb, wC, hC, 8, frame->stepCb);
  h263_ExpandFrameReplicate(frame->apCr, wC, hC, 8, frame->stepCr);
}

#define H263_COMPARE_RESAMPLE_PARAMS(flag, VSeq, VPic) \
{ \
  int i; \
  flag = 0; \
  for (i = 0; i < 4; i++) { \
    if ((VSeq)->warpParams[i].dx != (VPic)->warpParams[i].dx || (VSeq)->warpParams[i].dy != (VPic)->warpParams[i].dy) { \
      flag = 1; \
      break; \
    } \
  } \
  if ((VSeq)->fillMode != (VPic)->fillMode) \
    flag = 1; \
  if ((VPic)->fillMode == 0) { \
    for (i = 0; i < 3; i++) { \
      if ((VSeq)->fillColor[i] != (VPic)->fillColor[i]) { \
        flag = 1; \
        break; \
      } \
    } \
  } \
}

#define H263_UPDATE_RESAMPLE_PARAMS(VPic, VSeq) \
{ \
  int i; \
  for (i = 0; i < 4; i++) { \
   (VSeq)->warpParams[i].dx = (VPic)->warpParams[i].dx; \
   (VSeq)->warpParams[i].dy = (VPic)->warpParams[i].dy; \
  } \
  (VSeq)->fillMode = (VPic)->fillMode; \
  if ((VPic)->fillMode == 0) { \
    for (i = 0; i < 3; i++) { \
      (VSeq)->fillColor[i] = (VPic)->fillColor[i]; \
    } \
  } \
}

static void h263_PadResampledFrame(h263_Frame *frame, int fillMode, int fillColor[3])
{
  int i, j;
  Ipp8u colorY, colorCb, colorCr;
  Ipp8u *p0, *p1;
  int width, height;
  Ipp32u tY;
  Ipp16u tCb, tCr;

  /* frame width and height are always divisible by 4 */

  if (fillMode == 0) {
    colorY = (Ipp8u)fillColor[0];
    colorCb = (Ipp8u)fillColor[1];
    colorCr = (Ipp8u)fillColor[2];
    tY = (colorY << 8) | colorY;
    tY = (tY << 16) | tY;
    tCb = (colorCb << 8) | colorCb;
    tCr = (colorCr << 8) | colorCr;
  } else if (fillMode == 1) {
    tY = 0x10101010; /* 16 */
    tCb = tCr = 0x8080; /* 128 */
  } else if (fillMode == 2) {
    tY = 0x80808080;
    tCb = tCr = 0x8080;
  }

  width = frame->width;
  height = frame->height;

  if (width & 15) {
    for (i = 0; i < height; i++) {
      p0 = frame->pY + width;
      if (fillMode == 3) {
        tY = (p0[-1] << 8) | p0[-1];
        tY = (tY << 16) | tY;
      }
      for (j = 0; j < (16 - (width & 15)) >> 2; j++)
        ((Ipp32u *)p0)[j] = tY;
    }

    width >>= 1;
    height >>= 1;
    for (i = 0; i < height; i++) {
      p0 = frame->pCb + width;
      p1 = frame->pCr + width;

      if (fillMode == 3) {
        tCb = (p0[-1] << 8) | p0[-1];
        tCr = (p1[-1] << 8) | p1[-1];
      }
      for (j = 0; j < (8 - (width & 7)) >> 1; j++) {
        ((Ipp16u *)p0)[j] = tCb;
        ((Ipp16u *)p1)[j] = tCr;
      }
    }
  }

  if (frame->height & 15) {
    width = frame->width;
    height = frame->height;

    p0 = frame->pY + height * frame->stepY;
    for (i = 0; i < 16 - (height & 15); i++) {
      if (fillMode == 3) {
        ippsCopy_8u(p0 - frame->stepY, p0, (width + 15) &~ 15);
      } else {
        ippsSet_8u((Ipp8u)tY, p0, (width + 15) &~ 15);
      }
      p0 += frame->stepY;
    }

    width >>= 1;
    height >>= 1;

    p0 = frame->pCb + height * frame->stepCb;
    p1 = frame->pCr + height * frame->stepCr;

    for (i = 0; i < 8 - (height & 7); i++) {
      if (fillMode == 3) {
        ippsCopy_8u(p0 - frame->stepCb, p0, (width + 7) &~ 7);
        ippsCopy_8u(p1 - frame->stepCr, p1, (width + 7) &~ 7);
      } else {
        ippsSet_8u((Ipp8u)tCb, p0, (width + 7) &~ 7);
        ippsSet_8u((Ipp8u)tCr, p1, (width + 7) &~ 7);
      }
    }
    p0 += frame->stepCb;
    p1 += frame->stepCr;
  }
}

static h263_Status h263_Resample(h263_Info* pInfo, h263_Frame *srcFr, h263_Frame *dstFr, int implicit)
{
  h263_VideoPicture* VPic = &pInfo->VideoSequence.VideoPicture;
  IppMotionVector *warps = VPic->warpParams;
  IppiSize  srcRoi, dstRoi;

  srcRoi.height = srcFr->height;
  srcRoi.width = srcFr->width;
  dstRoi.height = dstFr->height;
  dstRoi.width = dstFr->width;

  if (implicit || (warps[0].dx | warps[0].dy | warps[1].dx | warps[1].dy | warps[2].dx | warps[2].dy | warps[3].dx | warps[3].dy) == 0) {
    if (srcFr->width == 2*dstFr->width && srcFr->height == 2*dstFr->height) {
      ippiDownsampleFour_H263_8u_C1R(srcFr->pY, srcFr->stepY, srcRoi, dstFr->pY, dstFr->stepY, VPic->rtype);
      srcRoi.height >>= 1;
      srcRoi.width >>= 1;
      ippiDownsampleFour_H263_8u_C1R(srcFr->pCb, srcFr->stepCb, srcRoi, dstFr->pCb, dstFr->stepCb, VPic->rtype);
      ippiDownsampleFour_H263_8u_C1R(srcFr->pCr, srcFr->stepCr, srcRoi, dstFr->pCr, dstFr->stepCr, VPic->rtype);
    } else if (2*srcFr->width == dstFr->width && 2*srcFr->height == dstFr->height) {
      ippiUpsampleFour_H263_8u_C1R(srcFr->pY, srcFr->stepY, srcRoi, dstFr->pY, dstFr->stepY, VPic->rtype, VPic->fillMode == 3 ? -1 : VPic->fillColor[0]);
      srcRoi.height >>= 1;
      srcRoi.width >>= 1;
      ippiUpsampleFour_H263_8u_C1R(srcFr->pCb, srcFr->stepCb, srcRoi, dstFr->pCb, dstFr->stepCb, VPic->rtype, VPic->fillMode == 3 ? -1 : VPic->fillColor[1]);
      ippiUpsampleFour_H263_8u_C1R(srcFr->pCr, srcFr->stepCr, srcRoi, dstFr->pCr, dstFr->stepCr, VPic->rtype, VPic->fillMode == 3 ? -1 : VPic->fillColor[2]);
    } else {
      ippiResample_H263_8u_P3R(srcFr->pY, srcFr->stepY, srcRoi, srcFr->pCb, srcFr->stepCb, srcFr->pCr, srcFr->stepCr,
                                dstFr->pY, dstFr->stepY, dstRoi, dstFr->pCb, dstFr->stepCb, dstFr->pCr, dstFr->stepCr,
                                warps, VPic->wda, VPic->rtype, VPic->fillMode, VPic->fillColor);
    }
  } else {
    ippiResample_H263_8u_P3R(srcFr->pY, srcFr->stepY, srcRoi, srcFr->pCb, srcFr->stepCb, srcFr->pCr, srcFr->stepCr,
                              dstFr->pY, dstFr->stepY, dstRoi, dstFr->pCb, dstFr->stepCb, dstFr->pCr, dstFr->stepCr,
                              warps, VPic->wda, VPic->rtype, VPic->fillMode, VPic->fillColor);
  }

  if ((dstFr->width | dstFr->height) & 15)
    h263_PadResampledFrame(dstFr, VPic->fillMode, VPic->fillColor);

  h263_PadFrame(dstFr);

  H263_UPDATE_RESAMPLE_PARAMS(VPic, &pInfo->VideoSequence);

  return H263_STATUS_OK;
}


#define H263_FRAME_CHECK_RESIZE(VPic, frame) \
  if ((VPic->MacroBlockPerCol + 2*H263_NUM_EXT_MB) * (VPic->MacroBlockPerRow + 2*H263_NUM_EXT_MB) > \
    (frame.mbPerRow + 2 * H263_NUM_EXT_MB) * (frame.mbPerCol + 2 * H263_NUM_EXT_MB)) { \
    h263_FreeFrame(&frame); \
    status = h263_InitFrame(&frame, VPic->MacroBlockPerRow, VPic->MacroBlockPerCol); \
    if (status != H263_STATUS_OK) return status; \
    frame.mbPerRow = VPic->MacroBlockPerRow; \
    frame.mbPerCol = VPic->MacroBlockPerCol; \
    frame.width = VPic->width; \
    frame.height = VPic->height; \
  }


#define H263_MBINFO_CHECK_RESIZE(VPic, VSeq) \
  if ((VPic)->MacroBlockPerRow * (VPic)->MacroBlockPerCol > (VSeq)->num_of_MBs) { \
    ippsFree((VSeq)->MBinfo); \
    (VSeq)->MBinfo = (h263_MacroBlock*)ippsMalloc_8u((VPic)->MacroBlockPerRow * (VPic)->MacroBlockPerCol * sizeof(h263_MacroBlock)); \
    if (!(VSeq)->MBinfo) \
      return H263_STATUS_NO_MEM; \
   (VSeq)->num_of_MBs = (VPic)->MacroBlockPerRow * (VPic)->MacroBlockPerCol; \
  }



/**************************************************************************/
/*                    Main "interface" function                           */
/**************************************************************************/

h263_Status h263_DecodeVideoPicture(h263_Info* pInfo)
{
  h263_Status  status = H263_STATUS_OK;
  Ipp64s      pic_time;
  h263_VideoPicture* VPic = &pInfo->VideoSequence.VideoPicture;
  int temp_ref_delta;
  Ipp32s time_factor;
  h263_EnhancedLayer *enh_layer = NULL, *ref_layer = NULL;
  h263_Frame *refFrame, *lowFrame, *curFrame, *auxFrame;
  int implicit_resample = 0;

  if (pInfo->VideoSequence.Ppics_to_show > 0) {  /* two P-frames/parts already pending */
    pInfo->VideoSequence.vFrame = &pInfo->VideoSequence.rFrame;
    pInfo->VideoSequence.Ppics_to_show--;
    return H263_STATUS_OK;
  }

  /* set picture time */
  if (VPic->picture_coding_type != H263_PIC_TYPE_B)
    temp_ref_delta = VPic->temporal_reference - pInfo->VideoSequence.prevP_temporal_reference;
  else
    temp_ref_delta = VPic->temporal_reference - pInfo->VideoSequence.ref_temporal_reference;

  if (temp_ref_delta < 0) {
    if (VPic->PCF)
      temp_ref_delta += 1024;
    else
      temp_ref_delta += 256;
  }

  /* real time = pInfo->VideoSequence.pic_time/1800000 */
  if (VPic->prev_clock_divisor) {
    time_factor = VPic->prev_clock_divisor * (1000 + VPic->prev_clock_conversion_code);
  } else {
    time_factor = 60 * 1001;
  }

  if (VPic->picture_coding_type == H263_PIC_TYPE_PB || VPic->picture_coding_type == H263_PIC_TYPE_iPB)
    pInfo->VideoSequence.pic_time_pb = pInfo->VideoSequence.prevP_pic_time + VPic->temporal_reference_B * time_factor;

  if (VPic->picture_coding_type != H263_PIC_TYPE_B) {
    pic_time = pInfo->VideoSequence.pic_time = pInfo->VideoSequence.prevP_pic_time + temp_ref_delta * time_factor;

    pInfo->VideoSequence.ref_temporal_reference = pInfo->VideoSequence.prevP_temporal_reference;
    pInfo->VideoSequence.prevP_temporal_reference = VPic->temporal_reference;

    pInfo->VideoSequence.ref_pic_time = pInfo->VideoSequence.prevP_pic_time;
    pInfo->VideoSequence.prevP_pic_time = pInfo->VideoSequence.pic_time;
  } else