tmmp.c

用于TM1300/PNX1300系列DSP（主要用于视频处理）的设备库的源码

  tmAssert(!((unsigned long) readaddr  & 3), MP_ERR_BIT_CNT_OVERFLOW);
    
  LOCK_MPEG_PIPE(instance);

  /* keep some state information around for context save and restore */

  curr_bit_cnt = mpGetBIT_CNT();

  /* Number of bits consumed by VLD since last mpinput */
  if (curr_bit_cnt < MpInfo[instance].mpContext.prevBitCnt)
    bits_consumed = (curr_bit_cnt - MpInfo[instance].mpContext.prevBitCnt) + (1 << 18);  
  else
    bits_consumed = (curr_bit_cnt - MpInfo[instance].mpContext.prevBitCnt);
  
  MpInfo[instance].mpContext.prevVldOcc += 
    (MpInfo[instance].mpContext.prevInputCnt<<3) - bits_consumed;

  /*
  DP(("curr_bit_cnt %u  prevBitCnt %u bits_consumed %u prevInputCnt %u prevVldOcc %u\n",
      curr_bit_cnt,MpInfo[instance].mpContext.prevBitCnt,bits_consumed,MpInfo[instance].mpContext.prevInputCnt,
      MpInfo[instance].mpContext.prevVldOcc));
  */
  MpInfo[instance].mpContext.prevBitCnt = curr_bit_cnt;

  /*
  DP(("tmMP.c %04d: clearing DMA DONE bit stat 0x%x new count %d curr count %d\n",__LINE__,mpGetSTATUS(),readcount,mpGetINP_CNT()));
  */

  if(readcount > 0) {
    mpSetSTATUS(MP_VLD_MC_STATUS_DMA_IN_DONE);
  }

  mpSetINP_ADR((UInt32) readaddr);
  MpInfo[instance].mpContext.prevInputAddr = readaddr;
  mpSetINP_CNT(readcount);
  MpInfo[instance].mpContext.prevInputCnt  = readcount;

  UNLOCK_MPEG_PIPE();

  MPEXT(instance);
  return TMLIBDEV_OK;
}
/****************************************************************************
    tmLibdevErr_t mpReset(Int instance)

    Reset MP
****************************************************************************/
extern tmLibdevErr_t 
mpReset(Int instance)
{
    tmLibdevErr_t status;

    MPENT(instance);
    STD_ASSERTS(instance);
    LOCK_MPEG_PIPE(instance);
    status = _mpIntReset();
    MpInfo[instance].mpContext.prevInputCnt = 0;
    MpInfo[instance].mpContext.prevBitCnt = mpGetBIT_CNT();
    MpInfo[instance].mpContext.prevVldOcc = 0;
    MpInfo[_mpCurInstance].suspended = False; 
    MpInfo[_mpCurInstance].aSyncPending = False;
    _mpErrorCon1Pending = False;
    _mpErrorCon2Pending = False;    
    UNLOCK_MPEG_PIPE();
    MPEXT(instance);
    return status;
}

/****************************************************************************
    tmLibdevErr_t mpResetAndRecover(Int instance)

    Reset MP and repositions the VLD to the point at which it stopped.
    I.E.  VLD_SR before reset == VLD_SR after reset
****************************************************************************/
extern tmLibdevErr_t 
mpResetAndRecover(Int instance)
{

#ifdef WORKING_BIT_CNT
  unsigned long *dma_addr,dma_cnt,saveVldOcc;
  long dma_consumed;
#endif
  unsigned long bits_in_vld;
  tmLibdevErr_t status = TMLIBDEV_OK;
  
  MPENT(instance);
  STD_ASSERTS(instance);

  LOCK_MPEG_PIPE(instance);

  mpDisableIE_DMA_IN_DONE();
  mpGetVldOcc(instance,&bits_in_vld);

#ifdef WORKING_BIT_CNT
  /* Save current position of VLD */
  dma_consumed = MpInfo[instance].mpContext.prevInputCnt - mpGetINP_CNT();
  dma_addr     = MpInfo[instance].mpContext.prevInputAddr + 
    ((dma_consumed - ((bits_in_vld >> 5) << 2) - 4)>>2);
  dma_cnt      = MpInfo[instance].mpContext.prevInputCnt - 
    (dma_consumed - ((bits_in_vld >> 5) << 2) - 4);


  MpInfo[instance].mpContext.inputAddr = (UInt32 *) mpGetINP_ADR();
  MpInfo[instance].mpContext.inputCnt  = mpGetINP_CNT();

  MPDBG(bits_in_vld,MpInfo[instance].mpContext.inputCnt,MpInfo[instance].mpContext.inputAddr);
  MPDBG(dma_addr,MpInfo[instance].mpContext.prevInputAddr,MpInfo[instance].mpContext.fifoLength);


  if(dma_addr >= MpInfo[instance].mpContext.prevInputAddr){
    MPDBG(bits_in_vld,MpInfo[instance].mpContext.inputCnt,MpInfo[instance].mpContext.prevInputAddr);
    RETURN_IF_NOT_OK(_mpIntReset());
    MpInfo[instance].mpContext.prevBitCnt = mpGetBIT_CNT();
    MpInfo[instance].mpContext.prevInputCnt = 0;
    mpInput(instance,dma_addr, dma_cnt);
    MpInfo[instance].mpContext.prevVldOcc = 0;
    mpEnableIE_DMA_IN_DONE();
    mpFlushBits(instance,32 - (bits_in_vld & 0x1f));
  }
  else{
    MPDBG(bits_in_vld,MpInfo[instance].mpContext.inputCnt,MpInfo[instance].mpContext.prevInputAddr);
    _mpSaveFifoData(instance);
    
    RETURN_IF_NOT_OK(_mpIntReset());
    MpInfo[instance].mpContext.prevBitCnt = mpGetBIT_CNT();
    MpInfo[instance].mpContext.prevInputCnt = 0;    
    if (MpInfo[instance].mpContext.fifoLength == 0){
      MPDBG(bits_in_vld,MpInfo[instance].mpContext.inputCnt,MpInfo[instance].mpContext.prevInputAddr);
      mpInput(instance,MpInfo[instance].mpContext.inputAddr,MpInfo[instance].mpContext.inputCnt);

      saveVldOcc = MpInfo[instance].mpContext.prevVldOcc;
      MpInfo[instance].mpContext.prevVldOcc = 0;
      mpEnableIE_DMA_IN_DONE();
      mpFlushBits(instance,32 - (saveVldOcc & 0x1f));
    }
    else{
      MPDBG(bits_in_vld,MpInfo[instance].mpContext.inputCnt,MpInfo[instance].mpContext.prevInputAddr);
      if(MpInfo[instance].mpContext.inputCnt != 0){
	DP(("Installing temporary emptyFunc installed\n"));
	MpInfo[instance].mpContext.mpEmptyFunc = (pFnMpCallback_t)_mpRestoreInputAddr;
      }
      MpInfo[instance].mpContext.prevVldOcc = 0;
      _mpRestoreFifoData(instance);
      mpEnableIE_DMA_IN_DONE();

    }
    
  }
  MPDBG(0,mpGetINP_CNT(),mpGetINP_ADR());
#else
  RETURN_IF_NOT_OK(_mpIntReset());
  if(TMMPCALLBACK_OK != 
     (MpInfo[instance].callBackStatus =
      (*MpInfo[instance].mpContext.mpEmptyFunc) (MpInfo[instance].mpSetup.parentID))) {
  }
#endif
  /* reset error related state variables */
  MpInfo[_mpCurInstance].suspended = False; 
  MpInfo[_mpCurInstance].aSyncPending = False;
  _mpErrorCon1Pending = False;
  _mpErrorCon2Pending = False;
  
localExit:  
  UNLOCK_MPEG_PIPE();

  MPEXT(instance);
  return status;
}

/****************************************************************************
    tmLibdevErr_t mpGetBits(Int instance, Int32 numBits, UInt32 *bits)

     Parse off the input bitstream with numBits number of bits
     No more than 32 bits
****************************************************************************/
extern tmLibdevErr_t 
mpGetBits(Int instance, Int32 numBits, UInt32 * bits)
{
  tmLibdevErr_t status = TMLIBDEV_OK;
  
  MPENT(instance);
  STD_ASSERTS(instance);
  

  if(numBits > 32 || numBits < 0)
    return MP_ERR_SR_OVERFLOW;

  LOCK_MPEG_PIPE(instance);
  
#ifdef WORKING_BIT_CNT
  {
    UInt32 vldOcc;

    /* check for sufficient data */
    if(mpGetINP_CNT() == 0){
      mpGetVldOcc(instance, &vldOcc);
      if(vldOcc < numBits){
	UNLOCK_MPEG_PIPE();
	return MP_ERR_INSUFFICIENT_DATA;
      }
    }
  }
#endif

  mpSetIE(MP_VLD_MC_STATUS_DMA_IN_DONE);
  RETURN_IF_NOT_OK(_mpGetBits(instance, numBits, bits));
  
  
 localExit:
  mpSetIE(0);

  UNLOCK_MPEG_PIPE();

  MPEXT(instance);
  return status;
}

/****************************************************************************
    tmLibdevErr_t mpShowBits(Int instance, Int32 numBits, UInt32 *bits)

    Read the bits in MP Shift Register with 16 bit limit and does
    not shift any bit in MP
****************************************************************************/
extern tmLibdevErr_t 
mpShowBits(Int instance, Int32 numBits, UInt32 * bits)
{
    MPENT(instance);
    STD_ASSERTS(instance);

    if(numBits < 0 || numBits > 16)
      return MP_ERR_SR_OVERFLOW;

    LOCK_MPEG_PIPE(instance);

    *bits = (mpGetSR_VALUE()) >> (16 - numBits);

    UNLOCK_MPEG_PIPE();

    MPEXT(instance);
    return TMLIBDEV_OK;
}

/****************************************************************************
    tmLibdevErr_t mpFlushBits(Int instance, Int32 numBits)

    Parse off and throw away numBits bits
****************************************************************************/
extern tmLibdevErr_t 
mpFlushBits(Int instance, Int32 numBits)
{
    tmLibdevErr_t status = TMLIBDEV_OK;
    UInt32 dummy;

    MPENT(instance);
    STD_ASSERTS(instance);

    if (numBits < 0)
      return MP_ERR_SR_OVERFLOW;

    LOCK_MPEG_PIPE(instance);

#ifdef WORKING_BIT_CNT
    {
      UInt32 vldOcc;
      /* check for sufficient data */
      if((mpGetINP_CNT()<<3) < numBits){
	mpGetVldOcc(instance, &vldOcc);
	if(vldOcc < (numBits + (mpGetINP_CNT()<<3))){
	  UNLOCK_MPEG_PIPE();
	  MPEXT(instance);
	  return MP_ERR_INSUFFICIENT_DATA;
	}
      }
    }
#endif

    mpSetIE(MP_VLD_MC_STATUS_DMA_IN_DONE);
    RETURN_IF_NOT_OK(_mpGetBits(instance, numBits, &dummy));

  localExit:
    mpSetIE(0);

    UNLOCK_MPEG_PIPE();

    MPEXT(instance);
    return status;
}

/****************************************************************************
    tmLibdevErr_t mpNextStartCode(Int instance, UInt32 *startcode)

    Search for the next start code
****************************************************************************/
extern tmLibdevErr_t 
mpNextStartCode(Int instance, Bool exSync)
{
    tmLibdevErr_t status = TMLIBDEV_OK;

    MPENT(instance);
    STD_ASSERTS(instance);

    LOCK_MPEG_PIPE(instance);

    MpInfo[instance].endRow = 0;

    mpSetCOMMAND(MP_VLD_COMMAND_STARTCODE);
    mpSetIE(MP_VLD_IE_DMA_IN_DONE | MP_VLD_IE_SUCCESS);
    
    if(False == exSync){
      MpInfo[instance].aSyncPending = True;
      MPEXT(instance);
      return TMLIBDEV_OK;
    }
    MpInfo[_mpCurInstance].suspended = True;

    SUSPEND_SELF();

    /* clear start code since this could trigger an interrupt */
    DP(("%d: clearing Start code bit 0x%x\n",__LINE__,mpGetSTATUS()));
    mpSetSTATUS(MP_VLD_MC_STATUS_STARTCODE);

    mpSetIE(0);

    UNLOCK_MPEG_PIPE();

    MPEXT(instance);
    return status;
}

/****************************************************************************
    tmLibdevErr_t mpNextGivenStartCode(Int instance, UInt32 *startcode)

    Search for the next start code
****************************************************************************/
extern tmLibdevErr_t 
mpNextGivenStartCode(Int instance, UInt8 startcode, Bool exSync)
{
    tmLibdevErr_t status = TMLIBDEV_OK;

    MPENT(instance);
    STD_ASSERTS(instance);
    LOCK_MPEG_PIPE(instance);

    MpInfo[instance].endRow = 0;

    mpSetCOMMAND((MP_VLD_COMMAND_GIVEN_START_CODE | (startcode & 0xff)));
    mpSetIE(MP_VLD_IE_DMA_IN_DONE | MP_VLD_IE_SUCCESS);
    
    if(False == exSync){
      MpInfo[instance].aSyncPending = True;
      MPEXT(instance);
      return (TMLIBDEV_OK);
    }
    MpInfo[_mpCurInstance].suspended = True;

    SUSPEND_SELF();

    /* clear start code since this could trigger an interrupt */
    DP(("%d: clearing Start code bit 0x%x\n",__LINE__,mpGetSTATUS()));
    mpSetSTATUS(MP_VLD_MC_STATUS_STARTCODE);

    mpSetIE(0);

    UNLOCK_MPEG_PIPE();

    MPEXT(instance);
    return status;
}

/****************************************************************************
    tmLibdevErr_t mpSetPictureInfo(Int instance, mpPictureInfo_t *pictinfo)

    Set the picture information parameters
****************************************************************************/
extern tmLibdevErr_t 
mpSetPictureInfo(Int instance, mpPictureInfo_t * pictinfo)
{
    UInt32      mp_pict_info_reg,mp_pict_info_mc,i,iq_pic_info;
    UInt32      err;

    MPENT(instance);
    STD_ASSERTS(instance);
    
    mp_pict_info_reg =
        ((pictinfo->pictureType     << MP_VLD_PI_PICT_TYPE_SHIFT)   & MP_VLD_PI_PICT_TYPE)   |
        ((pictinfo->pictureStruct   << MP_VLD_PI_PICT_STRUCT_SHIFT) & MP_VLD_PI_PICT_STRUCT) |
        ((pictinfo->framePFrameD    << MP_VLD_PI_FPFD_SHIFT)        & MP_VLD_PI_FPFD)        |
        ((pictinfo->intraVLC        << MP_VLD_PI_INTRA_VLC_SHIFT)   & MP_VLD_PI_INTRA_VLC)   |
        ((pictinfo->concealMV       << MP_VLD_PI_CONCEAL_MV_SHIFT)  & MP_VLD_PI_CONCEAL_MV)  |
        ((pictinfo->halfResMode     << MP_VLD_PI_HALF_RES_SHIFT)    & MP_VLD_PI_HALF_RES)    |
        ((pictinfo->fullPelForward  << MP_VLD_PI_FULL_PELF_SHIFT)   & MP_VLD_PI_FULL_PELF)   |
        ((pictinfo->fullPelBackward << MP_VLD_PI_FULL_PELB_SHIFT)   & MP_VLD_PI_FULL_PELB)   |
        ((pictinfo->topFieldFirst   << MP_VLD_PI_TOP_FIRST_SHIFT)   & MP_VLD_PI_TOP_FIRST)   |
        ((pictinfo->noYVertHalf     << MP_VLD_PI_NO_Y_HALF_SHIFT)   & MP_VLD_PI_NO_Y_HALF)   |
        ((pictinfo->noUVVertHalf    << MP_VLD_PI_NO_UV_HALF_SHIFT)  & MP_VLD_PI_NO_UV_HALF)  |
        ((pictinfo->mpeg2Mode       << MP_VLD_PI_MPEG2_SHIFT)       & MP_VLD_PI_MPEG2)       |
        ((pictinfo->noBackwardMC    << MP_VLD_PI_NO_BACK_MC_SHIFT)  & MP_VLD_PI_NO_BACK_MC)  |
        ((pictinfo->hForwRSize      << MP_VLD_PI_HFRS_SHIFT)        & MP_VLD_PI_HFRS)        |
        ((pictinfo->vForwRSize      << MP_VLD_PI_VFRS_SHIFT)        & MP_VLD_PI_VFRS)        |
        ((pictinfo->hBackRSize      << MP_VLD_PI_HBRS_SHIFT)        & MP_VLD_PI_HBRS)        |
        ((pictinfo->vBackRSize      << MP_VLD_PI_VBRS_SHIFT)        & MP_VLD_PI_VBRS);

    MpInfo[instance].mpPictInfo = mp_pict_info_reg;

    mp_pict_info_mc =
#ifdef __BIG_ENDIAN__
        (1 << 31) |           /* turn on byte swapping in MC SU for BIG endian*/
#endif
        ((0xf                     << MP_MC_PI0_TIMEOUT_SHIFT)   & MP_MC_PI0_TIMEOUT)   |
        ((pictinfo->MBWidth       << MP_MC_PI0_MB_WIDTH_SHIFT)  & MP_MC_PI0_MB_WIDTH)  |
        ((pictinfo->MBHeight      << MP_MC_PI0_MB_HEIGHT_SHIFT) & MP_MC_PI0_MB_HEIGHT) |
        ((pictinfo->MBRowOffset   << MP_MC_PI0_MB_ROW_SHIFT)    & MP_MC_PI0_MB_ROW);

    MpInfo[instance].mpMCPictInfo0 = mp_pict_info_mc;

    iq_pic_info =
        ((pictinfo->quantScaleType     << IQ_EXT_QSCALE_TYPE_SHIFT)     & IQ_EXT_QSCALE_TYPE) |
        ((pictinfo->altScan            << IQ_EXT_ALT_SCAN_SHIFT)        & IQ_EXT_ALT_SCAN) |
        ((!pictinfo->loadIntraQuant    << IQ_EXT_LD_INTRA_MAT_SHIFT)    & IQ_EXT_LD_INTRA_MAT)  |
        ((!pictinfo->loadNonIntraQuant << IQ_EXT_LD_NONINTRA_MAT_SHIFT) & IQ_EXT_LD_NONINTRA_MAT) |
        ((pictinfo->intraDCPrecision   << IQ_EXT_INTRA_DC_PREC_SHIFT)   & IQ_EXT_INTRA_DC_PREC);

    MpInfo[instance].mpIQPictInfo = iq_pic_info;

    if(pictinfo->loadIntraQuant) {
      unsigned long value;
      for(i=0; i < 16; i++) {
 	value  = (pictinfo->intraQuantMatrix[(i<<2)+0] & 0xff);
	value += (pictinfo->intraQuantMatrix[(i<<2)+1] & 0xff)<<8;
	value += (pictinfo->intraQuantMatrix[(i<<2)+2] & 0xff)<<16;
	value += (pictinfo->intraQuantMatrix[(i<<2)+3] & 0xff)<<24;
	MpInfo[instance].mpIQIntraQuantMatrix[i] = value;
	if(_mpCurInstance == instance)
	  mpSetW_TBL0(value,(i<<2));
      }
    }    
    if(pictinfo->loadNonIntraQuant) {
      unsigned long value;
      for(i=0; i < 16; i++) {
	value  = (pictinfo->nonIntraQuantMatrix[(i<<2)+0] & 0xff);
	value += (pictinfo->nonIntraQuantMatrix[(i<<2)+1] & 0xff)<<8;
	value += (pictinfo->nonIntraQuantMatrix[(i<<2)+2] & 0xff)<<16;
	value += (pictinfo->nonIntraQuantMatrix[(i<<2)+3] & 0xff)<<24;
	MpInfo[instance].mpIQNonIntraQuantMatrix[i] = value;
	if(_mpCurInstance == instance)
	  mpSetW_TBL1(value,(i<<2));
      }
    }