tmvld.c

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

        /*
         * When done, always clear the status register since if it
         * stays on your next command may not work correctly.  Except
         * for VLD_STATUS_SUCCESS bit. 
         */
         vldClearSTATUS();

         if (!vldSTATUS_SUCCESS(status)) {
            if (vldSTATUS_ERROR(status)) {
                return VLD_ERR_STATUS_ERROR;
            }

            if (vldSTATUS_STARTCODE(status)) {
                return VLD_ERR_UNEXPECTED_START_CODE;
            }
        }
   }

    return TMLIBDEV_OK;
}



/****************************************************************************
    tmLibdevErr_t vldInput(Int instance, Pointer readaddr, UInt32 readcount)

    Supply VLD more data by giving addr and cnt.
    This should normally be called only when the count is zero.

    readcount should be 12 bits
****************************************************************************/
tmLibdevErr_t 
vldInput(Int instance, Pointer readaddr, UInt32 readcount)
{
    tmAssert((instance >= 0 && instance < VLD_MAX_INSTANCES), TMLIBDEV_ERR_NOT_OWNER);   
    tmAssert(readcount < 4096, VLD_ERR_BIT_CNT_OVERFLOW);

    vldSetBIT_ADR((UInt32) readaddr);
    vldSetBIT_CNT(readcount);

    return TMLIBDEV_OK;
}




/****************************************************************************
    tmLibdevErr_t vldReset(Int instance)

    Reset VLD
****************************************************************************/
tmLibdevErr_t 
vldReset(Int instance)
{
    Int         success = 0;
    Int         trial = 0;

    tmAssert((instance >= 0 && instance < VLD_MAX_INSTANCES), TMLIBDEV_ERR_NOT_OWNER);
    
    while (success == 0 && trial < 10) {
        vldSetCOMMAND(VLD_COMMAND_RESET);
        success = vldCheckSTATUS_SUCCESS();
        trial++;
    }

    if (trial == 10) {
        return VLD_ERR_RESET_FAIL;
    }

    vldSetQS(0);
    vldSetPI(0);
    vldSetIMASK(0);
    vldSetBIT_ADR(0);
    vldSetBIT_CNT(0);
    vldSetMBH_ADR(0);
    vldSetMBH_CNT(0);
    vldSetRL_ADR(0);
    vldSetRL_CNT(0);

#ifdef __LITTLE_ENDIAN__
    vldSetCTL(VLD_CTL_LITTLE_END);
#else
    vldSetCTL(0);
#endif

    vldClearSTATUS();

    return TMLIBDEV_OK;
}



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

     Parse off the input bitstream with numBits number of bits
     No more than 32 bits
****************************************************************************/
tmLibdevErr_t 
vldGetBits(Int instance, Int32 numBits, UInt32 * bits)
{
    UInt32      temp = 0;

    tmAssert((instance >= 0 && instance < VLD_MAX_INSTANCES), TMLIBDEV_ERR_NOT_OWNER);   
    tmAssert(numBits <= 32, VLD_ERR_NUM_BITS_OVERFLOW);

    /*
     * The hw VLD can only shift 15 bits at a time, so read only 15 bits
     * at a time
     */

    while (numBits >= 15) {
        /* read left most 15 bits */
        temp = (temp << 15) | (vldGetSR_VALUE() >> 1);
        numBits -= 15;
        RETURN_IF_NOT_OK(vldCommand(instance, VLD_COMMAND_SHIFT | 15));
    }

    if (numBits) {
        temp = (temp << numBits) | (vldGetSR_VALUE() >> (16 - numBits));
        RETURN_IF_NOT_OK(vldCommand(instance, VLD_COMMAND_SHIFT | numBits));
    }

    *bits = temp;

    return TMLIBDEV_OK;
}



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

    Read the bits in VLD Shift Register with 16 bit limit and does
    not shift any bit in VLD
****************************************************************************/
tmLibdevErr_t 
vldShowBits(Int instance, Int32 numBits, UInt32 * bits)
{
    tmAssert((instance >= 0 && instance < VLD_MAX_INSTANCES), TMLIBDEV_ERR_NOT_OWNER);   
    tmAssert(numBits <= 16, VLD_ERR_SR_OVERFLOW);

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

    return TMLIBDEV_OK;
}



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

    Parse off and throw away numBits bits
****************************************************************************/
tmLibdevErr_t 
vldFlushBits(Int instance, Int32 numBits)
{
    tmAssert((instance >= 0 && instance < VLD_MAX_INSTANCES), TMLIBDEV_ERR_NOT_OWNER);   

    while (numBits >= 15) {
        numBits -= 15;
        RETURN_IF_NOT_OK(vldCommand(instance, VLD_COMMAND_SHIFT | 15));
    }

    if (numBits) {
        return vldCommand(instance, VLD_COMMAND_SHIFT | numBits);
    }

    return TMLIBDEV_OK;
}



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

    Search for the next start code
****************************************************************************/
tmLibdevErr_t 
vldNextStartCode(Int instance, UInt32 * startcode)
{
    UInt32      data;

    tmAssert((instance >= 0 && instance < VLD_MAX_INSTANCES), TMLIBDEV_ERR_NOT_OWNER);   
    RETURN_IF_NOT_OK(vldCommand(instance, VLD_COMMAND_STARTCODE));

    vldShowBits(instance, 8, &data);

    *startcode = 0x00000100 | data;

    return TMLIBDEV_OK;
}



/****************************************************************************
    tmLibdevErr_t vldSetPictureInfo(Int instance, vldPictureInfo_t *pictinfo)

    Set the picture information parameters
****************************************************************************/
tmLibdevErr_t 
vldSetPictureInfo(Int instance, vldPictureInfo_t * pictinfo)
{
    UInt32      vld_pict_info_reg;

    tmAssert((instance >= 0 && instance < VLD_MAX_INSTANCES), TMLIBDEV_ERR_NOT_OWNER);   

    vld_pict_info_reg =
        ((pictinfo->pictureType   << VLD_PI_PICT_TYPE_SHIFT)   & VLD_PI_PICT_TYPE)   |
        ((pictinfo->pictureStruct << VLD_PI_PICT_STRUCT_SHIFT) & VLD_PI_PICT_STRUCT) |
        ((pictinfo->framePFrameD  << VLD_PI_FPFD_SHIFT)        & VLD_PI_FPFD)        |
        ((pictinfo->intraVLC      << VLD_PI_INTRA_VLC_SHIFT)   & VLD_PI_INTRA_VLC)   |
        ((pictinfo->concealMV     << VLD_PI_CONCEAL_MV_SHIFT)  & VLD_PI_CONCEAL_MV)  |
        ((pictinfo->mpeg2Mode     << VLD_PI_MPEG2_SHIFT)       & VLD_PI_MPEG2)       |
        ((pictinfo->hForwRSize    << VLD_PI_HFRS_SHIFT)        & VLD_PI_HFRS)        |
        ((pictinfo->vForwRSize    << VLD_PI_VFRS_SHIFT)        & VLD_PI_VFRS)        |
        ((pictinfo->hBackRSize    << VLD_PI_HBRS_SHIFT)        & VLD_PI_HBRS)        |
        ((pictinfo->vBackRSize    << VLD_PI_VBRS_SHIFT)        & VLD_PI_VBRS);

    VldInfo[instance].mpeg2Mode = pictinfo->mpeg2Mode;
    vldSetPI(vld_pict_info_reg);

    /*
     * Record into global for later use
     */
    VldInfo[instance].vldPictInfo = *pictinfo;

    return TMLIBDEV_OK;
}



/****************************************************************************
    tmLibdevErr_t vldGetPictureInfo(Int instance, vldPictureInfo_t *pictinfo)

    Get the picture information parameters
****************************************************************************/
tmLibdevErr_t 
vldGetPictureInfo(Int instance, vldPictureInfo_t * pictinfo)
{
    UInt32      vld_pictinfo_reg = vldGetPI();

    tmAssert((instance >= 0 && instance < VLD_MAX_INSTANCES), TMLIBDEV_ERR_NOT_OWNER);   

    pictinfo->pictureType   = vldExtractPI_PICT_TYPE   (vld_pictinfo_reg);
    pictinfo->pictureStruct = vldExtractPI_PICT_STRUCT (vld_pictinfo_reg);
    pictinfo->framePFrameD  = vldExtractPI_FPFD        (vld_pictinfo_reg);
    pictinfo->intraVLC      = vldExtractPI_INTRA_VLC   (vld_pictinfo_reg);
    pictinfo->concealMV     = vldExtractPI_CONCEAL_MV  (vld_pictinfo_reg);
    pictinfo->mpeg2Mode     = vldExtractPI_MPEG2       (vld_pictinfo_reg);
    pictinfo->hForwRSize    = vldExtractPI_HFRS        (vld_pictinfo_reg);
    pictinfo->vForwRSize    = vldExtractPI_VFRS        (vld_pictinfo_reg);
    pictinfo->hBackRSize    = vldExtractPI_HBRS        (vld_pictinfo_reg);
    pictinfo->vBackRSize    = vldExtractPI_VBRS        (vld_pictinfo_reg);

    return TMLIBDEV_OK;
}



/****************************************************************************
    tmLibdevErr_t vldParseMacroblocks(Int instance, Int32 count, 
                                      Pointer *mbhAddr, Pointer rltokenAddr,
                                      Int32 mbhBufSize, Int32 rlBufSize)

    Parse count number of MacroBlocks.
    mbhBufSize is the size of mbh buffer (starting from mbhAddr)
    in 32 bit words.  9 bits.   Corresponding VLD_STATUS register bit
    is set when this buffer is full.
    rlBufSize is the size of rl buffer (starting from rltokenAddr)
    in 32 bit words.  12 bits.   Corresponding VLD_STATUS register bit
    is set when this buffer is full.
****************************************************************************/
tmLibdevErr_t 
vldParseMacroblocks(Int instance, Int32 count, Pointer mbhAddr, Pointer rltokenAddr,
           Int32 mbhBufSize, Int32 rlBufSize)
{
    tmAssert((instance >= 0 && instance < VLD_MAX_INSTANCES), TMLIBDEV_ERR_NOT_OWNER);   
    tmAssert(mbhBufSize < 512, VLD_ERR_MBH_CNT_OVERFLOW);
    tmAssert(rlBufSize < 4096, VLD_ERR_RL_CNT_OVERFLOW);

    vldSetMBH_ADR((UInt32) mbhAddr);
    vldSetMBH_CNT(mbhBufSize);
    vldSetRL_ADR((UInt32) rltokenAddr);
    vldSetRL_CNT(rlBufSize);

    /*
     * VLD_COMMAND_PARSE never returns error
     */
    
    vldCommand(instance, VLD_COMMAND_PARSE | count);
    return TMLIBDEV_OK;
}



/* The shift left and right is to signextend the 6 bits registers */
#define vldGetMotionVector(mv, mbhWord, hRSize, vRSize) \
  \
  (mv).hCode = (((Int32)((mbhWord) & VLD_MVOUT_MC0 )) << VLD_MVOUT_MC0_NEG_SHIFT) \
               >> (VLD_MVOUT_MC0_SHIFT + VLD_MVOUT_MC0_NEG_SHIFT); \
  (mv).vCode = (((Int32)((mbhWord) & VLD_MVOUT_MC1 )) << VLD_MVOUT_MC1_NEG_SHIFT) \
               >> (VLD_MVOUT_MC1_SHIFT + VLD_MVOUT_MC1_NEG_SHIFT); \
  (mv).hRes  = ((mbhWord) & VLD_MVOUT_MR0 ) \
               >> (VLD_MVOUT_MR0_SHIFT + VLD_MVOUT_MR0_SIZE - (hRSize)); \
  (mv).vRes  = ((mbhWord) & VLD_MVOUT_MR1 ) \
               >> (VLD_MVOUT_MR1_SHIFT + VLD_MVOUT_MR1_SIZE - (vRSize))



/****************************************************************************
    tmLibdevErr_t vldGetMBHeader(Int instance, vldMBHField_t *mbhField, Pointer mbhAddr)

    get macroblock header parameters
****************************************************************************/
tmLibdevErr_t 
vldGetMBHeader(Int instance, vldMBHField_t * mbhField, Pointer mbhAddr)
{

    UInt32     *restrict mbhWord = (UInt32 *) (((vldMBHMpeg1_t *) mbhAddr)->word);
    vldMBHField_t *restrict field = mbhField;
    vldMV_t    *restrict mv = mbhField->mv;
    vldPictureInfo_t *restrict pictinfo = &VldInfo[instance].vldPictInfo;