evotest.c

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

    voInstSup.videoStandard = (tmVideoAnalogStandard_t) videoStandard;
    voInstSup.adapterType = vaaNone;

    voFrequencyToDDS(27000000, &voInstSup.ddsFrequency);
    voInstSup.hbeEnable = True;
    voInstSup.underrunEnable = True;
    if (retVal = voInstanceSetup(voInst, &voInstSup))
        my_abort("voInstanceSetup", retVal);
}

void 
voYUVAPI(voYUVModes_t mode,
     Int imageWidth, Int imageHeight, Int imageStride,
     Int imageVertOffset, Int imageHorzOffset,
     Pointer yBase, Pointer uBase, Pointer vBase)
{
    tmLibdevErr_t retVal;

    memset((char *) (&voYUVSup), 0, sizeof (voYUVSetup_t));
    voYUVSup.mode = mode;
    voYUVSup.buf1emptyEnable = True;
    voYUVSup.yThresholdEnable = False;
    voYUVSup.yThreshold = False;
    voYUVSup.yBase = yBase;
    voYUVSup.uBase = uBase;
    voYUVSup.vBase = vBase;

    voYUVSup.imageVertOffset = imageVertOffset;
    voYUVSup.imageHorzOffset = imageHorzOffset;
    voYUVSup.imageHeight = (imageHeight >> 1);
    voYUVSup.yStride = (2 * imageStride);
    voYUVSup.uStride = imageStride;
    voYUVSup.vStride = imageStride;

    switch (mode) {
    case vo422_COSITED_UNSCALED:
    case vo422_INTERSPERSED_UNSCALED:
    case vo420_UNSCALED:
        voYUVSup.imageWidth = imageWidth;
        break;
    case vo422_COSITED_SCALED:
    case vo422_INTERSPERSED_SCALED:
    case vo420_SCALED:
    default:
        voYUVSup.imageWidth = imageWidth << 1;
        break;
    }

    if (retVal = voYUVSetup(voInst, &voYUVSup))
        my_abort("viYUVSetup", retVal);
}

void evoChrKeyAPI(Bool ckEnable, UInt8 keyY, UInt8 keyU, UInt8 keyV,
     UInt8 maskY, UInt8 maskUV)
{
    tmLibdevErr_t retVal;

    memset((char *) (&evoChrKeySup), 0, sizeof(voenhChromaKeyingSetup_t));
    evoChrKeySup.keyEnable = ckEnable;
    evoChrKeySup.keyY = keyY;
    evoChrKeySup.keyU = keyU;
    evoChrKeySup.keyV = keyV;
    evoChrKeySup.maskY = maskY;
    evoChrKeySup.maskUV = maskUV;

    if (retVal = voenhChromaKeyingSetup(voInst, &evoChrKeySup))
        my_abort("voenhChromaKeyingSetup", retVal);
}


void evoClipAPI(Bool clipEnable, 
    UInt8 hClipUV, UInt8 lClipUV, UInt8 hClipY, UInt8 lClipY)
{
    tmLibdevErr_t retVal;

    memset((char *) (&evoClipSup), 0, sizeof(voenhClipSetup_t));
    evoClipSup.clipEnable = clipEnable;
    evoClipSup.highClipUV = hClipUV;
    evoClipSup.lowClipUV = lClipUV;
    evoClipSup.highClipY = hClipY;
    evoClipSup.lowClipY = lClipY;

    if (retVal = voenhClipSetup(voInst, &evoClipSup))
        my_abort("voenhClipetup", retVal);
}

void
voOverlayAPI(Int sLine, Int sPixel, Int width, Int height,
         UInt alpha0, UInt alpha1, Int offset, Pointer base)
{
    tmLibdevErr_t err;

    memset((char *) (&voOverlaySup), 0, sizeof (voOverlaySetup_t));
    voOverlaySup.overlayEnable = True;
    voOverlaySup.overlayStartY = sLine;
    voOverlaySup.overlayStartX = sPixel;
    voOverlaySup.overlayWidth = width;
    voOverlaySup.overlayHeight = height;
    voOverlaySup.alpha0 = alpha0;
    voOverlaySup.alpha1 = alpha1;
    voOverlaySup.overlayStride = offset;
    voOverlaySup.overlayBase = base;
 
    if (err = voOverlaySetup(voInst, &voOverlaySup))
        my_abort("voOverlaySetup", err);
}


void evoRunClip()
{
    myHClipUV=0xff; myLClipUV=0x00; myHClipY = 0xff; myLClipY = 0x00;
    printf("Clipping: Increasing LowClipUV value: HUV=%x LUV=%x HY=%x LY=%x.\n", 
	myHClipUV, myLClipUV, myHClipY, myLClipY);
    for ( ; myLClipUV < 0xe5; myLClipUV+=0x10) {		
	printf("LClipUV = %x \n", myLClipUV);
	evoClipAPI(True, myHClipUV, myLClipUV, myHClipY, myLClipY);
	for (voISRCount = 0; voISRCount < SMALLNUMBER;) {
	    ;
	}
    }  
	
    myHClipUV=0xff; myLClipUV=0x00; myHClipY = 0xff; myLClipY = 0x00;
    printf("Clipping: Increasing LowClipY value: HUV=%x LUV=%x HY=%x LY=%x.\n", 
	myHClipUV, myLClipUV, myHClipY, myLClipY);
    for ( ; myLClipY < 0xe5; myLClipY+=0x10) {		
	printf("LClipY = %x \n", myLClipY);
	evoClipAPI(True, myHClipUV, myLClipUV, myHClipY, myLClipY);
	for (voISRCount = 0; voISRCount < SMALLNUMBER;) {
		;
	}
    } 
	
    myHClipUV = 0xff; myLClipUV = 0x00; myHClipY = 0xff; myLClipY = 0x00;
    evoClipAPI(False, myHClipUV, myLClipUV, myHClipY, myLClipY);
}

void evoRunKey()
{
    /* reset chroma key and zero out key, mask values first */
    evoChrKeyAPI(False, 0, 0, 0, 0, 0);

    myKeyY = 0x14; myKeyU = 0x96; myKeyV = 0x79; myMaskY=0xf; myMaskUV=0xf;
    printf("Displaying Tinker with keyY=%x keyU=%x keyV=%x maskY=%x maskUV=%x \n", 
	myKeyY, myKeyU, myKeyV, myMaskY, myMaskUV);
    evoChrKeyAPI(True, myKeyY, myKeyU, myKeyV, myMaskY, myMaskUV);
    for (voISRCount = 0; voISRCount < SMALLNUMBER;) {
        ;
    }

    myKeyY = 0x1A; myKeyU = 0xAC; myKeyV = 0x79; myMaskY=0xf; myMaskUV=0xf;
    printf("Displaying Tinker with keyY=%x keyU=%x keyV=%x maskY=%x maskUV=%x \n", 
	myKeyY, myKeyU, myKeyV, myMaskY, myMaskUV);
    evoChrKeyAPI(True, myKeyY, myKeyU, myKeyV, myMaskY, myMaskUV);
    for (voISRCount = 0; voISRCount < SMALLNUMBER;) {
        ;
    }

	evoChrKeyAPI(False, 0, 0, 0, 0, 0);
}


void evoRunBlend()
{
    overlayNum = 2;
    overlayFieldStride = tinkerWidth << 1; 

    getTinkerToOverlay();
    printf("Display Tinker Bell with background color on top of clouds.\n");
    voenhSetFULL_BLENDING__CHECK(1);

    for (myAlpha0=0, myAlpha1=0; myAlpha0 < 0xff; myAlpha0+=0x10, myAlpha1+=0x10) {
	printf("Alpha0=%x Alpha1=%x\n", myAlpha0, myAlpha1);
	voOverlayAPI(myStartLine, myStartPixel, tinkerWidth, (tinkerHeight >> 1), 
		myAlpha0, myAlpha1, tinkerWidth << 2, (Pointer)voBuf[2].Y);
	for (voISRCount = 0; voISRCount < SMALLNUMBER;) {
		;
	}
    }

    voenhSetFULL_BLENDING__CHECK(0);
}

void evoClear()
{
    /* reset chroma key and zero out key, mask values first */
    evoChrKeyAPI(False, 0, 0, 0, 0, 0);

    myHClipUV = 0; myLClipUV = 0; myHClipY = 0; myLClipY = 0;
    evoClipAPI(False, myHClipUV, myLClipUV, myHClipY, myLClipY);
}

void voRunClouds()
{
    tmLibdevErr_t retVal;

    displayNum = 0;
    yFieldStride = cloudsStride;
    uvFieldStride = (cloudsStride >> 1);

#ifndef __TCS_nohost__
    if (retVal = readYUVFiles("clouds720x480", cloudsWidth, cloudsHeight,
                  voBuf[0].Y, voBuf[0].U, voBuf[0].V, YUV422)) {
        my_abort("readYUVFiles cloouds720x480", retVal);
    }
#endif

    voYUVAPI(vo422_COSITED_UNSCALED, 
         cloudsWidth, cloudsHeight, cloudsStride, 0, 0,
         (Pointer) voBuf[0].Y, (Pointer) voBuf[0].U, (Pointer) voBuf[0].V);

    if (retVal = voStart(voInst))
        my_abort("voStart", retVal);

	printf("Display clouds for 2 seconds.\n");
    for (voISRCount = 0; voISRCount < SMALLNUMBER;) {
        ;
    }
}

void evoRunExample()
{
    tmLibdevErr_t retVal;

    voOpenInstAPI();
    voRunClouds();

    evoClear();
    if (retVal = voenhStart(voInst))
        my_abort("voenhStart", retVal);

    evoRunBlend();
    evoRunKey();
    evoRunClip();

    if (retVal = voenhStop(voInst))
        my_abort("voenhStop", retVal);
    if (retVal = voStop(voInst))
        my_abort("voStop", retVal);
    voClose(voInst);
}


UInt32 allocSz(Int bufSz)
{
    UInt32      temp;

    if ((temp = (UInt32) _cache_malloc(bufSz, -1)) == Null)
        my_abort("_cache_malloc", 0);

    _cache_copyback((Pointer) temp, bufSz);

    return temp;
}

void voAllocBuf()
{
    Int         i, szY, szUV;

    szY = (bufWidth * (bufHeight + 4));
    szUV = ((bufWidth >> 1) * (bufHeight + 4));
    for (i = 0; i < NUM_VO_BUF; i++) {
        voBuf[i].Y = allocSz(szY);
        voBuf[i].U = allocSz(szUV);
        voBuf[i].V = allocSz(szUV);
        voBuf[i].flag = 0;
        DP(("Allocate voBuf i %d Y %x U %x V %x\n",
            i, voBuf[i].Y, voBuf[i].U, voBuf[i].V));
    }
}

void 
voFreeBuf()
{
    Int         i;

    for (i = 0; i < NUM_VO_BUF; i++) {
        _cache_free((Pointer) voBuf[i].Y);
        _cache_free((Pointer) voBuf[i].U);
        _cache_free((Pointer) voBuf[i].V);
    }
}



void 
voSetDP()
{
    DPsize(32000);    /* for debugging */
}

/***************************************************************************/
Int 
main(Int argc, char **argv)
{
    printf("TriMedia EVO Example Program Version 1.0 \n\n");

    voSetDP();

    DP((Header));
    printf(Header);

    DP(("Running on ")); tmHelpReportSystem(Null);
    printf("Running on "); tmHelpReportSystem(stdout);

#ifndef __TCS_nohost__
    evoCheckArgcv(argc, argv);
#else
    argc = 0;
    argv = NULL;
#endif

    voAllocBuf();
    evoRunExample();
    voFreeBuf();
    exit(0);
}