tmvo.c

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

    return err;
}

/*--------------------- general action functions -----------------------------*/

/*
 * Function         : Start or stop video out unit.
 * Parameters       : instance  (I)  instance to start/stop
 *                    start     (I)  if True, video out unit will be started
 *                                   if False, video out unit will be stopped
 * Function Result  : resulting error condition
 * NB               : this function is redundant, since its
 *                    effects can also be achieved using timInstanceControl
 */

extern tmLibdevErr_t 
voStart(Int instance)
{
    pvoInstVars_t pinst = (pvoInstVars_t)instance;
    
    IS_VALID(instance);
    
    if (pinst->setupCalled == voNoSetupCalled)
        return VO_ERR_INITIALIZATION_NOT_COMPLETE;
    
    voEnableENABLE();
    return TMLIBDEV_OK;
}

extern tmLibdevErr_t 
voStop(Int instance)
{
    IS_VALID(instance);
    
    voDisableENABLE();
    return TMLIBDEV_OK;
}

/*----------------- YUV setup related functions -------------*/

/*
 * Function         : Set YUV related parameters.
 * Parameters       : instance (I)  instance to set parameters for
 *                    setup    (I)  pointer to buffer
 *                                  holding new parameters
 * Function Result  : resulting error condition
 */


extern tmLibdevErr_t 
voYUVSetup(Int instance, voYUVSetup_t * setup)
{
    pvoInstVars_t pinst = (pvoInstVars_t)instance;
    
    IS_VALID(instance);
    printf("\nvoYUVSetup\n");
    puts_vo();
    tmAssert(setup != Null, TMLIBDEV_ERR_NULL_PARAMETER);

    tmAssert((setup->mode <= vo420_SCALED) && (setup->mode != 3),
         VO_ERR_MODE_SIZE);
    tmAssert((setup->imageWidth + setup->imageHorzOffset +
          voGetVIDEO_PIXEL_START()) <= voGetFRAME_WIDTH(),
         VO_ERR_IMAGE_HOFF_SIZE);
    tmAssert((setup->imageHeight + setup->imageVertOffset +
          voGetF1VIDEO_LINE()) <= voGetFRAME_FIELD2_START(),
         VO_ERR_IMAGE_VOFF_SIZE);

    voSetMODE__CHECK(setup->mode);
    voSetIMAGE_WIDTH__CHECK(setup->imageWidth);
    voSetIMAGE_HOFF__CHECK(setup->imageHorzOffset);
    voSetIMAGE_HEIGHT__CHECK(setup->imageHeight);
    voSetIMAGE_VOFF__CHECK(setup->imageVertOffset);

    voSetY_THRESHOLD__CHECK(setup->yThreshold);
    voSetY_OFFSET__CHECK(setup->yStride);
    voSetU_OFFSET__CHECK(setup->uStride);
    voSetV_OFFSET__CHECK(setup->vStride);
    voSetY_BASE_ADR__CHECK((UInt) setup->yBase);
    voSetU_BASE_ADR__CHECK((UInt) setup->uBase);
    voSetV_BASE_ADR__CHECK((UInt) setup->vBase);

    voSetBFR1_IEN__CHECK(setup->buf1emptyEnable);
    voSetYTR_IEN__CHECK(setup->yThresholdEnable);

    pinst->setupCalled = voYUVSetupCalled;
    
    return TMLIBDEV_OK;
}


/*----------------- Overlay setup related functions -------------*/

/*
 * Function         : Set Overlay related parameters.
 * Parameters       : instance (I)  instance to set parameters for
 *                    setup    (I)  pointer to buffer
 *                                  holding new parameters
 * Function Result  : resulting error condition
 */

extern tmLibdevErr_t 
voOverlaySetup(Int instance, voOverlaySetup_t * setup)
{
    IS_VALID(instance);
    tmAssert(setup != Null, TMLIBDEV_ERR_NULL_PARAMETER);

    tmAssert((setup->overlayStartX + setup->overlayWidth) <=
         (voGetIMAGE_WIDTH()), VO_ERR_OL_WIDTH_SIZE);
    tmAssert(((setup->overlayWidth & 0x1) == 0), VO_ERR_OL_WIDTH_SIZE);
    tmAssert((setup->overlayStartY + setup->overlayHeight) <=
         (voGetIMAGE_HEIGHT()), VO_ERR_OL_HEIGHT_SIZE);

    voSetOL_START_PIXEL__CHECK(setup->overlayStartX);
    voSetOL_WIDTH__CHECK(setup->overlayWidth);
    voSetOL_START_LINE__CHECK(setup->overlayStartY);
    voSetOL_HEIGHT__CHECK(setup->overlayHeight);

    voSetALPHA0__CHECK(setup->alpha0);
    voSetALPHA1__CHECK(setup->alpha1);
    voSetOL_BASE_ADR__CHECK((UInt) setup->overlayBase);
    voSetOL_OFFSET__CHECK(setup->overlayStride);
    voSetOL_EN__CHECK(setup->overlayEnable);

    return TMLIBDEV_OK;
}

/*----------------- Raw setup related functions -------------*/

/*
 * Function         : Set Raw related parameters.
 * Parameters       : instance (I)  instance to set parameters for
 *                    setup    (I)  pointer to buffer
 *                                  holding new parameters
 * Function Result  : resulting error condition
 */

extern tmLibdevErr_t 
voRawSetup(Int instance, voRawSetup_t * setup)
{
    pvoInstVars_t pinst = (pvoInstVars_t)instance;

    IS_VALID(instance);
    tmAssert(setup != Null, TMLIBDEV_ERR_NULL_PARAMETER);
    tmAssert((setup->mode == voSTREAM8) || (setup->mode == voMESSAGE), VO_ERR_MODE_SIZE);

    tmAssert((((UInt32) setup->base1 & 0x3f) == 0), VO_ERR_BASE1_SIZE);
    tmAssert((((UInt32) setup->base2 & 0x3f) == 0), VO_ERR_BASE2_SIZE);
    tmAssert(((setup->size1 & 0x3f) == 0), VO_ERR_SIZE1_SIZE);
    tmAssert(((setup->size2 & 0x3f) == 0), VO_ERR_SIZE2_SIZE);

    voSetMODE__CHECK(setup->mode);
    voSetBASE1__CHECK((UInt) setup->base1);
    voSetBASE2__CHECK((UInt) setup->base2);
    voSetSIZE1__CHECK((UInt) setup->size1);
    voSetSIZE2__CHECK((UInt) setup->size2);
    voSetBFR1_IEN__CHECK(setup->buf1emptyEnable);
    voSetBFR2_IEN__CHECK(setup->buf2emptyEnable);

    pinst->setupCalled = voRawSetupCalled;

    return TMLIBDEV_OK;
}


/*------------------------- encoder related functions -----------------------*/

/*
 * Function         : Configure encoder according to the data passed in.
 * Parameters       : instance  (I)  calling user's instance
 *            subaddr   (I)  iicsubaddress of the decoder.
 *            value (I)  new value.
 * Function Result  : resulting error condition
 */

extern tmLibdevErr_t
voConfigureEncoder(Int instance, UInt32 subaddr, UInt32 value)
{
    boardVOConfig_t *boardVOConfig = ((pvoInstVars_t)instance)->boardVOConfig;
    
    IS_VALID(instance);
    tmAssert(boardVOConfig != Null, VO_ERR_UNINIT_ENCODER);
    
    if (boardVOConfig->Configure)
        return (boardVOConfig->Configure(subaddr, value));
    else
        return BOARD_ERR_NULL_FUNCTION;
}

/*
 * Function         : Set brightness of the encoder.
 * Parameters       : instance    (I) instance
 *                    Level       (I) brightness level
 * Function Result  : resulting error condition
 */

extern tmLibdevErr_t 
voSetBrightness(Int instance, UInt level)
{
    boardVOConfig_t *boardVOConfig = ((pvoInstVars_t)instance)->boardVOConfig;

    IS_VALID(instance);
    tmAssert(boardVOConfig != Null, VO_ERR_UNINIT_ENCODER);

    if (boardVOConfig->setBrightness)
        return boardVOConfig->setBrightness(level);
    else
        return BOARD_ERR_NULL_FUNCTION;
}

/*
 * Function         : Set Contrast of the encoder.
 * Parameters       : instance  (I) instance
 *                    Level     (I) contrast level
 * Function Result  : resulting error condition
 */

extern tmLibdevErr_t 
voSetContrast(Int instance, UInt level)
{
    boardVOConfig_t *boardVOConfig = ((pvoInstVars_t)instance)->boardVOConfig;

    IS_VALID(instance);
    tmAssert(boardVOConfig != Null, VO_ERR_UNINIT_ENCODER);

    if (boardVOConfig->setContrast)
        return boardVOConfig->setContrast(level);
    else
        return BOARD_ERR_NULL_FUNCTION;
}

/*
 * Function         : Set hue of the encoder.
 * Parameters       : instance  (I) instance
 *                    Level     (I) hue level
 * Function Result  : resulting error condition
 */

extern tmLibdevErr_t 
voSetHue(Int instance, UInt level)
{
    boardVOConfig_t *boardVOConfig = ((pvoInstVars_t)instance)->boardVOConfig;

    IS_VALID(instance);
    tmAssert(boardVOConfig != Null, VO_ERR_UNINIT_ENCODER);
    
    if (boardVOConfig->setHue)
        return boardVOConfig->setHue(level);
    else
        return BOARD_ERR_NULL_FUNCTION;
}

/*
 * Function         : Set saturation of the encoder.
 * Parameters       : instance  (I) instance
 *                    Level     (I) saturation level
 * Function Result  : resulting error condition
 */

extern tmLibdevErr_t 
voSetSaturation(Int instance, UInt level)
{
    boardVOConfig_t *boardVOConfig = ((pvoInstVars_t)instance)->boardVOConfig;

    IS_VALID(instance);
    tmAssert(boardVOConfig != Null, VO_ERR_UNINIT_ENCODER);

    if (boardVOConfig->setSaturation)
        return boardVOConfig->setSaturation(level);
    else
        return BOARD_ERR_NULL_FUNCTION;
}


/*
 * Function         : Set output standard and adapter type of the encoder.
 * Parameters       : instance      (I) instance
 *                    videoStandard (I) the wanted standard vasNTSC/vasPAL etc.
 *                    adapterType   (I) the wanted adapter type vaaCVBS etc.
 * Function Result  : resulting error condition
 */

#define        TMLIBDEV_ERR_NOT_STOPPED           ( Err_base_LIBDEV + 0x6 )


extern tmLibdevErr_t
voSetOutput(Int instance, tmVideoAnalogStandard_t videoStandard, tmVideoAnalogAdapter_t adapterType)
{
    boardVOConfig_t *boardVOConfig = ((pvoInstVars_t)instance)->boardVOConfig;
    pvoInstVars_t    pinst = (pvoInstVars_t) instance;
    boardVOParam_t   param;
    
    IS_VALID(instance);
    tmAssert(boardVOConfig != Null, TMLIBDEV_ERR_NOT_AVAILABLE_IN_HW);
    tmAssert(voGetENABLE() == 0, TMLIBDEV_ERR_NOT_STOPPED);
    
    pinst->setupCalled = voNoSetupCalled;

    param.videoStandard = videoStandard;
    param.adapterType   = adapterType;
    param.mmioBase      = boardVOConfig->mmioBase;

    return VOsetup_board(pinst, &param);
}

/* ------------- Helper function ------------------------------------------- */

/* Since the settings of the interpretation of the VO_CLOCK register is      
 * different from chip to chip, this function takes care of converting       
 * from a human understandable value in hertz to the VO_CLK format           
 * This value can then be used to fill the ddsFrequency field in a           
 * voInstanceSetup_t structure
 */
extern tmLibdevErr_t
voFrequencyToDDS(float hertz, UInt32 *control)
{
    pprocCapabilities_t procCap;
    tmLibdevErr_t       err;
    
    err = procGetCapabilities(&procCap);
    if (err != TMLIBDEV_OK)
        return err;
    
    switch(procCap->deviceID)
    {
    case PROC_DEVICE_TM1100:
    case PROC_DEVICE_TM1300:
    case PROC_DEVICE_TM2500:
    case PROC_DEVICE_TM2600:
    case PROC_DEVICE_TM2700:
    case PROC_DEVICE_TM2800:
        /* New calculation, more accurate */
        *control = ((UInt32) (0.5 + ( 477218588.0 * hertz /
                                      procCap->cpuClockFrequency))) |
            (1U << 31); /* ensures that VO is aware of new calculation method*/
        break;

        /* old method. Less accurate with higher frequencies */
    case PROC_DEVICE_TM1000:
    default:
        
        *control = (UInt32) (0.5 + (1431655765.0 * hertz /
                                    (float) procCap->cpuClockFrequency));
        break;
    }
    return TMLIBDEV_OK;
}

/*-------------- Enhanced Video Out : Start and Stop functions ---------------*/

/*
 * Function         : Start or stop enhanced video out unit.
 * Parameters       : instance  (I)  instance to start/stop
 *                    start     (I)  if True, evo unit will be started
 *                                   if False, evo unit will be stopped
 * Function Result  : resulting error condition
 */

extern tmLibdevErr_t
voenhStart(Int instance)
{
    static pprocCapabilities_t procCap;

    IS_VALID(instance);
    
    /* 
     * Verify that we have EVO, ie. we are not on a TM1000
     */
    
    if (procCap == Null) {
        tmLibdevErr_t err;

        err = procGetCapabilities(&procCap);
        if (err != TMLIBDEV_OK) {
            return err;
        }
    }

    if (procCap->deviceID == PROC_DEVICE_TM1000)
        return TMLIBDEV_ERR_NOT_AVAILABLE_IN_HW;
    
    voenhEnableEVO_ENABLE();
    return TMLIBDEV_OK;
}

extern tmLibdevErr_t 
voenhStop(Int instance)
{
    IS_VALID(instance);
 
    voenhDisableEVO_ENABLE();
    return TMLIBDEV_OK;
}
 
/*-------------- Enhanced Video Out : Clipping Setup functions----------------*/
 
/*
 * Function         : Set up clip related parameters.
 * Parameters       : instance (I)  instance to set parameters for
 *                    setup    (I)  pointer to buffer
 *                                  holding new parameters
 * Function Result  : resulting error condition
 */
 
extern tmLibdevErr_t 
voenhClipSetup(Int instance, voenhClipSetup_t  *setup)
{
    IS_VALID(instance);
 
    voenhSetCLIPPING_ENABLE__CHECK(setup->clipEnable);
    voenhSetHIGHER_CLIPUV__CHECK(setup->highClipUV);
    voenhSetLOWER_CLIPUV__CHECK(setup->lowClipUV);
    voenhSetHIGHER_CLIPY__CHECK(setup->highClipY);
    voenhSetLOWER_CLIPY__CHECK(setup->lowClipY);
    return TMLIBDEV_OK;
}
 
/*-------------- Enhanced Video Out : Chroma Keying Setup functions ----------*/
 
/*
 * Function         : Set up chroma keying related parameters.
 * Parameters       : instance (I)  instance to set parameters for
 *                    setup    (I)  pointer to buffer
 *                                  holding new parameters
 * Function Result  : resulting error condition
 */
 
extern tmLibdevErr_t 
voenhChromaKeyingSetup(Int instance, voenhChromaKeyingSetup_t *setup)
{
    IS_VALID(instance);
 
    voenhSetKEY_ENABLE__CHECK(setup->keyEnable);
    voenhSetKEY_Y__CHECK(setup->keyY);
    voenhSetKEY_U__CHECK(setup->keyU);
    voenhSetKEY_V__CHECK(setup->keyV);
    voenhSetMASK_Y__CHECK(setup->maskY);
    voenhSetMASK_UV__CHECK(setup->maskUV);
    return TMLIBDEV_OK;
}
 
/*-------------- Enhanced Video Out : GenLock Setup functions ----------------*/
 
/*
 * Function         : Set up GenLock related parameters.
 * Parameters       : instance (I)  instance to set parameters for
 *                    setup    (I)  pointer to buffer
 *                                  holding new parameters
 * Function Result  : resulting error condition
 */
 
extern tmLibdevErr_t 
voenhGenLockSetup(Int instance, voenhGenLockSetup_t  *setup)
{
    IS_VALID(instance);
 
    voenhSetGENLOCK__CHECK(setup->genLockEnable);
    voenhSetSLAVE_DLY__CHECK(setup->slaveDelay);
    return TMLIBDEV_OK;
}