コード例 #1
0
/*!
  subt_ttx_ctrl_set_dr
  \param[in] p_pmt: pmt data received from pmt.c
  \return SUCCESS if no error
  */  
RET_CODE subt_ttx_ctrl_set_pmt(void *p_pmt)
{
    RET_CODE ret     = ERR_FAILURE;       
    pmt_t    *p_data = (pmt_t *)p_pmt;

    do
    {
        ERR_POINT(p_data);
        
        ret = _subt_ctrl_process(p_data);
        ERR_CHECK(ret);
        
        ret = _ttx_ctrl_process(p_data);
        ERR_CHECK(ret);

        if(p_data != NULL)
        {
          _subt_ctrl_auto();
          _ttx_ctrl_auto();
          _auto_notify();
        }
        return SUCCESS;
     }while(0);

     return ret;
}
コード例 #2
0
ファイル: MacInstallWizard.c プロジェクト: rn10950/RetroZilla
void CleanTemp(void)
{
    OSErr   err = noErr;
    short   vRefNum;
    long    dirID;
    FSSpec  viewerFSp;
    XPISpec *xpiList, *currXPI = 0, *nextXPI = 0;
#ifdef MIW_DEBUG
    Boolean isDir = false;
#endif
    
#ifndef MIW_DEBUG
    /* get "viewer" in "Temporary Items" folder */
    ERR_CHECK(FindFolder(kOnSystemDisk, kTemporaryFolderType, kCreateFolder, &vRefNum, &dirID));
    err = FSMakeFSSpec(vRefNum, dirID, kViewerFolder, &viewerFSp);
#else
    /* for DEBUG builds temp is "<currProcessVolume>:Temp NSInstall:" */
    ERR_CHECK(GetCWD(&dirID, &vRefNum));
 	err = FSMakeFSSpec(vRefNum, 0, kTempFolder, &viewerFSp);
	if (err == fnfErr)
	    return; /* no debug temp exists */
	err = FSpGetDirectoryID(&viewerFSp, &dirID, &isDir);
	if (err != noErr || !isDir)
	    return;
    err = FSMakeFSSpec(vRefNum, dirID, kViewerFolder, &viewerFSp);
#endif
    
    /* whack the viewer folder if it exists */
    if (err == noErr)
    {
        ERR_CHECK(DeleteDirectory(viewerFSp.vRefNum, viewerFSp.parID, viewerFSp.name));
    }
    
    /* clean out the zippies (.xpi's) */
    xpiList = (XPISpec *) NewPtrClear(sizeof(XPISpec));
    if (!xpiList)
        return;
    IterateDirectory(vRefNum, dirID, "\p", 1, CheckIfXPI, (void*)&xpiList);
    
    if (xpiList)
    {
        currXPI = xpiList;
        while(currXPI)
        {
            nextXPI = currXPI->next; /* save nextXPI before we blow away currXPI */
            if (currXPI->FSp)
            {
                FSpDelete(currXPI->FSp);
                DisposePtr((Ptr)currXPI->FSp);
            }
            DisposePtr((Ptr)currXPI);
            currXPI = nextXPI;
        }
    }
}
コード例 #3
0
M4OSA_ERR M4MP4W_putBE24(M4OSA_UInt32 val, M4OSA_FileWriterPointer* fileFunction,
                         M4OSA_Context context)
/*******************************************************************************/
{
    M4OSA_ERR err;
    err = M4MP4W_putByte((M4OSA_UChar)(val >> 16), fileFunction, context);
    ERR_CHECK(err == M4NO_ERROR, err);
    err = M4MP4W_putByte((M4OSA_UChar)(val >> 8), fileFunction, context);
    ERR_CHECK(err == M4NO_ERROR, err);
    err = M4MP4W_putByte((M4OSA_UChar)val, fileFunction, context);
    return err;
}
コード例 #4
0
static RET_CODE _ttx_ctrl_start(ttx_ctrl_t *p_ttx, teletext_descr_t *p_ttx_dr)
{
    RET_CODE ret = ERR_FAILURE;

    do
    {
        /*!
         * First time use start decode interface, otherwise use reset pid interface
         */
        if(FALSE == p_ttx->m_start)
        {
            if(p_ttx_dr != NULL)
            {
              OS_PRINTF("lubin: _ttx_ctrl_start  PID %d\n", p_ttx_dr->pid);
             ret = mul_teletext_start_decode(p_ttx_dr->pid);
            }
            else
            {
              ret = mul_teletext_start_decode(0);
              OS_PRINTF("lubin: _ttx_ctrl_start  0 ret %d\n", ret);
            }
            ERR_CHECK(ret);
            
            p_ttx->m_start = TRUE;
        }
        
        return SUCCESS;
        
    }while(0);

    return ret;
}
コード例 #5
0
/*!
  ttx_ctrl_show
  \param[in] lang_idx: language index of teletext
  \return SUCCESS if no error
  */  
RET_CODE ttx_ctrl_start(u8 *p_lang)
{
    RET_CODE              ret      = ERR_FAILURE;
    teletext_descr_t     *p_dr     = NULL;
    subt_ttx_ctrl_priv_t *p_this   = NULL;
    
    do
    {
        ERR_POINT(p_lang);
        
        p_this = get_priv();
        ERR_POINT(p_this);

        memcpy(p_this->m_ttx_ctrl.m_ui_lang, p_lang, SUBT_TTX_CTRL_LANG_LEN);
        p_dr = _ttx_ctrl_match_dr(&p_this->m_ttx_ctrl, p_lang);
//        ERR_POINT(p_dr);
        OS_PRINTF("lubin: ttx_ctrl_start 863\n");
        ret = _ttx_ctrl_start(&p_this->m_ttx_ctrl, p_dr);
        ERR_CHECK(ret);
        
        return ret;        
    }while(0);

    return ERR_FAILURE;
}
コード例 #6
0
ファイル: lcaDebugOn.c プロジェクト: Sangil-Lee/Work
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
LcaError theErr;
	
	lcaErrorInit(&theErr);

	LHSCHECK(nlhs, plhs);

	if ( 1 < nlhs ) {
		lcaSetError(&theErr, EZCA_INVALIDARG, "Need one output arg");
		goto cleanup;
	}

	if ( 0 != nrhs ) {
		lcaSetError(&theErr, EZCA_INVALIDARG, "Expected no rhs argument");
		goto cleanup;
	}

	ezcaDebugOn();

	nlhs = 0;

cleanup:
	ERR_CHECK(nlhs, plhs, &theErr);
}
コード例 #7
0
ファイル: MacInstallWizard.c プロジェクト: rn10950/RetroZilla
void MakeMenus(void)
{
    Handle 		mbarHdl;
	MenuHandle	menuHdl;
	OSErr		err;
	
	if ( !(mbarHdl = GetNewMBar( rMBar)) )
	{
        ErrorHandler(eMem, nil);
		return;
	}
	
	SetMenuBar(mbarHdl);
	
	if ( (menuHdl = GetMenuHandle(mApple)) != nil) 
	{
		AppendResMenu(menuHdl, 'DRVR');
	}
	else
        ErrorHandler(eMenuHdl, nil); 

	ERR_CHECK(HMGetHelpMenuHandle(&menuHdl));
	DisableItem(menuHdl, 1);

	DrawMenuBar();
}
コード例 #8
0
ファイル: lcaGetTimeout.c プロジェクト: lnls-fac/code
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
LcaError theErr;

	lcaErrorInit(&theErr);

	LHSCHECK(nlhs, plhs);

	if ( 1 < nlhs ) {
		lcaSetError(&theErr, EZCA_INVALIDARG, "Need one output arg");
		goto cleanup;
	}

	if ( 0 != nrhs ) {
		lcaSetError(&theErr, EZCA_INVALIDARG, "Expected no rhs argument");
		goto cleanup;
	}


	if ( ! (plhs[0] = mxCreateDoubleMatrix( 1, 1, mxREAL )) ) {
		lcaSetError(&theErr, EZCA_FAILEDMALLOC, "Not enough memory");
		goto cleanup;
	}

	*mxGetPr(plhs[0]) = ezcaGetTimeout();

	nlhs = 0;

cleanup:
	ERR_CHECK(nlhs, plhs, &theErr);
}
コード例 #9
0
ファイル: lcaGetAlarmLimits.c プロジェクト: Sangil-Lee/Work
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
PVs     pvs = { {0} };
MultiArgRec args[]={ { sizeof(double), 0, (void**)0 }, { sizeof(double), 0, (void**)0 } };
void	*pres[NumberOf(args)];
int     i;
LcaError theErr;

	lcaErrorInit(&theErr);

	LHSCHECK(nlhs, plhs);

	if ( NumberOf(args) < nlhs ) {
		lcaSetError(&theErr, EZCA_INVALIDARG, "Too many output args");
		goto cleanup;
	}

	if ( 1 != nrhs ) {
		lcaSetError(&theErr, EZCA_INVALIDARG, "Expected one rhs argument");
		goto cleanup;
	}

	for ( i=0; i<NumberOf(args); i++) {
		args[i].pres = &pres[i];
		plhs[i]=0;
	}

	if ( buildPVs(prhs[0], &pvs, &theErr) )
		goto cleanup;
	
	if ( !multi_ezca_get_misc(pvs.names, pvs.m, (MultiEzcaFunc)ezcaGetAlarmLimits, NumberOf(args), args, &theErr) )
		goto cleanup;

	for ( i=0; i<nlhs; i++ ) {
		if ( !(plhs[i]=mxCreateDoubleMatrix(pvs.m, 1, mxREAL)) ) {
			lcaSetError(&theErr, EZCA_FAILEDMALLOC, "Not enough memory");
			goto cleanup;
		}
		memcpy(mxGetPr(plhs[i]), *args[i].pres, pvs.m * args[i].size);
	}

	nlhs = 0; /* prevent array destruction if everything is OK */

cleanup:
	for ( i=0; i<nlhs; i++ ) {
		if ( plhs[i] ) {
			mxDestroyArray(plhs[i]);
			plhs[i] = 0;
		}
	}
	for ( i=0; i<NumberOf(args); i++ ) {
		if ( args[i].pres )
			lcaFree(*args[i].pres);
	}
	releasePVs(&pvs);
	/* do this LAST (in case mexErrMsgTxt is called) */
	ERR_CHECK(nlhs, plhs, &theErr);
}
コード例 #10
0
ファイル: lcaGetUnits.c プロジェクト: lnls-fac/code
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
PVs     pvs = { {0} };
int     i,j;
LcaError theErr;
MultiArgRec	args[1];
units_string *strbuf MAY_ALIAS = 0;
mxArray *tmp;

	lcaErrorInit(&theErr);

	LHSCHECK(nlhs, plhs);

	if ( nlhs > 1 ) {
		lcaSetError(&theErr, EZCA_INVALIDARG, "Too many output args");
		goto cleanup;
	}

	if ( nrhs < 1 || nrhs > 1 ) {
		lcaSetError(&theErr, EZCA_INVALIDARG, "Expected 1 rhs argument");
		goto cleanup;
	}

	if ( buildPVs(prhs[0], &pvs, &theErr) )
		goto cleanup;

	MSetArg(args[0], sizeof(units_string), 0, &strbuf);

	if ( !multi_ezca_get_misc(pvs.names, pvs.m, (MultiEzcaFunc)ezcaGetUnits, NumberOf(args), args, &theErr) )
		goto cleanup;

	/* convert string array to a matlab cell array of matlab strings */
	if ( !(plhs[0] = mxCreateCellMatrix(pvs.m, 1)) ) {
		lcaSetError(&theErr, EZCA_FAILEDMALLOC, "Not enough memory");
		goto cleanup;
	}
	for ( i = 0; i < pvs.m; i++ ) {
		if ( !(tmp = mxCreateString((char*)&strbuf[i])) ) {
			for ( j=0; j<i; j++ ) {
				mxDestroyArray(mxGetCell(plhs[0],i));
			}
			mxDestroyArray(plhs[0]);
			plhs[0] = 0;
			lcaSetError(&theErr, EZCA_FAILEDMALLOC, "Not enough memory");
			goto cleanup;
		}
		mxSetCell(plhs[0], i, (mxArray*)tmp);
	}

	nlhs = 0;

cleanup:
	if ( strbuf )
		lcaFree( strbuf );
	releasePVs(&pvs);
	/* do this LAST (in case mexErrMsgTxt is called) */
	ERR_CHECK(nlhs, plhs, &theErr);
}
コード例 #11
0
ファイル: twi_advertising.c プロジェクト: Books305/twiz-fw
void advertising_start(void) {
  ble_gap_adv_params_t adv_params;

  memset(&adv_params, 0, sizeof(adv_params));
  adv_params.type        = BLE_GAP_ADV_TYPE_ADV_IND;
  adv_params.p_peer_addr = NULL;
  adv_params.fp          = BLE_GAP_ADV_FP_ANY;
  adv_params.interval    = APP_ADV_INTERVAL;
  adv_params.timeout     = APP_ADV_TIMEOUT_IN_SECONDS;

  ERR_CHECK(sd_ble_gap_adv_start(&adv_params));
}
コード例 #12
0
static RET_CODE _subt_ctrl_show_teletext(subt_ttx_ctrl_priv_t *p_this, teletext_descr_t *p_ttx_dr)

{
    RET_CODE ret = ERR_FAILURE;
    
    do
    {
        subt_ctrl_hide();
        OS_PRINTF("lubin: start ttx from subt\n");
        ret = _ttx_ctrl_start(&p_this->m_ttx_ctrl, p_ttx_dr);
        ERR_CHECK(ret);
        ret = mul_teletext_display_teletext(NULL, TRUE, p_ttx_dr->magazien, p_ttx_dr->page);
        ERR_CHECK(ret);

        p_this->m_subt_ctrl.m_ttx_start = TRUE;
        
        return SUCCESS;
    }while(0);

    return ret;
}
コード例 #13
0
ファイル: lcaSetMonitor.c プロジェクト: lnls-fac/code
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
int     i,n = 0;
const mxArray *tmp;
PVs     pvs = { {0} };
char	type = ezcaNative;
LcaError theErr;

	lcaErrorInit(&theErr);

	LHSCHECK(nlhs, plhs);

	if ( nlhs > 1 ) {
		lcaSetError(&theErr, EZCA_INVALIDARG, "Too many output args");
		goto cleanup;
	}

	if ( nrhs < 1 || nrhs > 3 ) {
		lcaSetError(&theErr, EZCA_INVALIDARG, "Expected 1..3 rhs argument");
		goto cleanup;
	}

	/* check for an optional 'column dimension' argument */
	if ( nrhs > 1 ) {
		if ( ! mxIsNumeric(tmp = prhs[1]) || 1 != mxGetM(tmp) || 1 != mxGetN(tmp) ) {
			lcaSetError(&theErr, EZCA_INVALIDARG, "2nd argument must be a numeric scalar");
			goto cleanup;
		}
		n = (int)mxGetScalar( tmp );
	}

	/* check for an optional data type argument */
	if ( nrhs > 2 ) {
		if ( ezcaInvalid == (type = marg2ezcaType( prhs[2], &theErr )) ) {
			goto cleanup;
		}
	}

	if ( buildPVs(prhs[0], &pvs, &theErr) )
		goto cleanup;

    if ( 0 == multi_ezca_set_mon( pvs.names, pvs.m, type, n, &theErr ) ) {
		nlhs = 0;
	}

cleanup:
	releasePVs(&pvs);
	/* do this LAST (in case mexErrMsgTxt is called) */
	ERR_CHECK(nlhs, plhs, &theErr);
}
コード例 #14
0
ファイル: prFontGlyph.cpp プロジェクト: pmac1965/proteus
/// ---------------------------------------------------------------------------
/// Draws this glyph
/// ---------------------------------------------------------------------------
void prFontGlyph::Draw()
{
    // Move to offset
    glTranslatef(mOffset.x, mOffset.y, 0);

    // Bind texture for character
    glBindTexture(GL_TEXTURE_2D, mTextureID);
    ERR_CHECK();

    // Draw
    glVertexPointer(2, GL_FLOAT, sizeof(QuadData), &quadData->x);
    ERR_CHECK();
    glTexCoordPointer(2, GL_FLOAT, sizeof(QuadData), &quadData->u);
    ERR_CHECK();
    glDrawArrays(GL_TRIANGLE_STRIP, 0, 6);
    ERR_CHECK();

    // Undo offset
    glTranslatef(-mOffset.x, -mOffset.y, 0);

    // Advance
    glTranslatef(mAdvance.x, mAdvance.y, 0);
}
コード例 #15
0
ファイル: main.cpp プロジェクト: eclipse0922/cbench-cis565s11
bool check(BS_test_t *t)
{
	float EPSILON = 2.0f;
	cl_int errcode_ret;

	BS_gold(t);
	cl_float * CallResult = (cl_float *) malloc (t->num * sizeof(cl_float));
	cl_float * PutResult = (cl_float *) malloc (t->num * sizeof(cl_float));
	errcode_ret = clEnqueueReadBuffer(t->hCmdQueue, t->d_CallResult, CL_TRUE, 0, t->num * sizeof(cl_float),
		CallResult, 0, NULL, NULL);
	ERR_CHECK(errcode_ret, "clEnqueueReadBuffer");
	errcode_ret = clEnqueueReadBuffer(t->hCmdQueue, t->d_PutResult, CL_TRUE, 0, t->num * sizeof(cl_float),
		PutResult, 0, NULL, NULL);
	ERR_CHECK(errcode_ret, "clEnqueueReadBuffer");
	//print_arr(t, CallResult);
	//print_arr(t, PutResult);

	for (unsigned int i = 0; i < t->num; i++) {
		cl_float hstCall = t->h_CallResult[i];
		cl_float hstPut = t->h_PutResult[i];
		cl_float devCall = CallResult[i];
		cl_float devPut = PutResult[i];
		if (abs(hstCall - devCall) >= EPSILON ||
			abs(hstPut - devPut) >= EPSILON ) {
				fprintf(stderr, "check failed at %d: [%f, %f] != [%f, %f]\n", 
					i,
					hstCall, hstPut,
					devCall, devPut);
				free(CallResult);
				free(PutResult);
				return false;
		}
	}
	free(CallResult);
	free(PutResult);
	return true;
}
コード例 #16
0
int main(void)
{
trx_regval_t rval;

    /* This will stop the application before initializing the radio transceiver
     * (ISP issue with MISO pin, see FAQ)
     */
    trap_if_key_pressed();

    /* Step 0: init MCU peripherals */
    LED_INIT();
    trx_io_init(SPI_RATE_1_2);
    LED_SET_VALUE(LED_MAX_VALUE);
    LED_SET_VALUE(0);

    /* Step 1: initialize the transceiver */
    TRX_RESET_LOW();
    TRX_SLPTR_LOW();
    DELAY_US(TRX_RESET_TIME_US);
    TRX_RESET_HIGH();
    trx_reg_write(RG_TRX_STATE,CMD_TRX_OFF);
    DELAY_US(TRX_INIT_TIME_US);
    rval = trx_bit_read(SR_TRX_STATUS);
    ERR_CHECK(TRX_OFF!=rval);
    LED_SET_VALUE(1);

    /* Step 2: setup transmitter
     * - configure radio channel
     * - go into RX state,
     * - enable "receive end" IRQ
     */
    trx_bit_write(SR_CHANNEL,CHANNEL);
    trx_reg_write(RG_TRX_STATE,CMD_RX_ON);
#if defined(TRX_IRQ_TRX_END)
    trx_reg_write(RG_IRQ_MASK,TRX_IRQ_TRX_END);
#elif defined(TRX_IRQ_RX_END)
    trx_reg_write(RG_IRQ_MASK,TRX_IRQ_RX_END);
#else
#  error "Unknown IRQ bits"
#endif
    sei();
    LED_SET_VALUE(2);

    /* Step 3: Going to receive frames */
    rxcnt = 0;

    LED_SET_VALUE(0);
    while(1);
}
コード例 #17
0
ファイル: main.cpp プロジェクト: eclipse0922/cbench-cis565s11
void cleanup(BS_test_t * t)
{
	cl_int errcode_ret;

	printf("Freeing Host and Device buffers...\n");
	free(t->h_CallResult);
	free(t->h_PutResult);
	free(t->h_StockPrice);
	free(t->h_OptionStrike);
	free(t->h_OptionYears);
	clFinish(t->hCmdQueue);

	errcode_ret = clReleaseMemObject(t->d_CallResult);
	ERR_CHECK(errcode_ret, "clReleaseMemObject d_CallResult");
	errcode_ret = clReleaseMemObject(t->d_PutResult);
	ERR_CHECK(errcode_ret, "clReleaseMemObject d_PutResult");
	errcode_ret = clReleaseMemObject(t->d_StockPrice);
	ERR_CHECK(errcode_ret, "clReleaseMemObject d_StockPrice");
	errcode_ret = clReleaseMemObject(t->d_OptionStrike);
	ERR_CHECK(errcode_ret, "clReleaseMemObject d_OptionStrike");
	errcode_ret = clReleaseMemObject(t->d_OptionYears);
	ERR_CHECK(errcode_ret, "clReleaseMemObject d_OptionYears");
	clFlush(t->hCmdQueue);
}
コード例 #18
0
ファイル: lcaLastError.c プロジェクト: Sangil-Lee/Work
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
int      i;
int      *src;
int      *dst;
LcaError *ptheErr = lcaGetLastError();
LcaError theErr;

	lcaErrorInit(&theErr);

	LHSCHECK(nlhs, plhs);

	if ( nlhs > 1 ) {
		lcaSetError(&theErr, EZCA_INVALIDARG, "Too many output args");
		goto cleanup;
	}

	if ( nrhs ) {
		lcaSetError(&theErr, EZCA_INVALIDARG, "Expected no rhs argument");
		goto cleanup;
	}

	if ( (i=ptheErr->nerrs) ) {
		src = ptheErr->errs;
	} else {
		i   = 1;
		src = &ptheErr->err;
	}

	if ( ! (plhs[0] = mxCreateNumericMatrix( i, 1, mxINT32_CLASS, mxREAL )) ) {
		lcaSetError(&theErr, EZCA_FAILEDMALLOC, "Not enough memory");
		goto cleanup;
	}

	dst = (int*)mxGetData(plhs[0]);

	while ( i-- ) {
		*dst++ = *src++;
	}

	nlhs = 0;

cleanup:

	/* do this LAST (in case mexErrMsgTxt is called) */
	ERR_CHECK(nlhs, plhs, &theErr);
}
コード例 #19
0
ファイル: main.cpp プロジェクト: eclipse0922/cbench-cis565s11
void setup_buffers(BS_test_t * t, cl_float(*gen)(cl_float low, cl_float high))
{
	// malloc host memory
	t->h_CallResult = (cl_float *) malloc (t->num * sizeof(cl_float));
	t->h_PutResult = (cl_float *) malloc (t->num * sizeof(cl_float));
	t->h_StockPrice = (cl_float *) malloc (t->num * sizeof(cl_float));
	t->h_OptionStrike = (cl_float *) malloc (t->num * sizeof(cl_float));
	t->h_OptionYears = (cl_float *) malloc (t->num * sizeof(cl_float));

	
	cl_int errcode_ret;
	// malloc device memory
	t->d_CallResult = clCreateBuffer(t->hContext, CL_MEM_WRITE_ONLY, t->num * sizeof(cl_float), NULL, &errcode_ret);
	ERR_CHECK(errcode_ret, "clCreateBuffer");
	t->d_PutResult = clCreateBuffer(t->hContext, CL_MEM_WRITE_ONLY, t->num * sizeof(cl_float), NULL, &errcode_ret);
	ERR_CHECK(errcode_ret, "clCreateBuffer");
	t->d_StockPrice = clCreateBuffer(t->hContext, CL_MEM_READ_ONLY, t->num * sizeof(cl_float), NULL, &errcode_ret);
	ERR_CHECK(errcode_ret, "clCreateBuffer");
	t->d_OptionStrike = clCreateBuffer(t->hContext, CL_MEM_READ_ONLY, t->num * sizeof(cl_float), NULL, &errcode_ret);
	ERR_CHECK(errcode_ret, "clCreateBuffer");
	t->d_OptionYears = clCreateBuffer(t->hContext, CL_MEM_READ_ONLY, t->num * sizeof(cl_float), NULL, &errcode_ret);
	ERR_CHECK(errcode_ret, "clCreateBuffer");

	// init host memory
	for (unsigned int i = 0; i < t->num; i++) {
		t->h_CallResult[i] = -1.0f;
		t->h_PutResult[i]  = -1.0f;
		t->h_StockPrice[i] = gen(5.0f, 30.0f);
		t->h_OptionStrike[i] = gen(1.0f, 100.0f);
		t->h_OptionYears[i] = gen(0.25f, 10.0f);
	}

	// copy to device memory
	printf("Copying input matrices to GPU...\n");
	errcode_ret = clEnqueueWriteBuffer(t->hCmdQueue, t->d_StockPrice, CL_TRUE, 0, t->num * sizeof(cl_float),
		t->h_StockPrice, 0, NULL, NULL);
	ERR_CHECK(errcode_ret, "clEnqueueWriteBuffer");
	errcode_ret = clEnqueueWriteBuffer(t->hCmdQueue, t->d_OptionStrike, CL_TRUE, 0, t->num * sizeof(cl_float),
		t->h_OptionStrike, 0, NULL, NULL);
	ERR_CHECK(errcode_ret, "clEnqueueWriteBuffer");
	errcode_ret = clEnqueueWriteBuffer(t->hCmdQueue, t->d_OptionYears, CL_TRUE, 0, t->num * sizeof(cl_float),
		t->h_OptionYears, 0, NULL, NULL);
	ERR_CHECK(errcode_ret, "clEnqueueWriteBuffer");
}
コード例 #20
0
RET_CODE ttx_ctrl_show(void)
{
    RET_CODE              ret      = ERR_FAILURE;
    subt_ttx_ctrl_priv_t *p_this   = NULL;
    
    do
    {
        p_this = get_priv();
        ERR_POINT(p_this);

        if(p_this->m_ttx_ctrl.m_start != TRUE)
        {
          return ERR_FAILURE;
        }
        ret = mul_teletext_display_teletext(NULL, FALSE, 1, 0);
        ERR_CHECK(ret);
        return ret;        
    }while(0);

    return ERR_FAILURE;
}
コード例 #21
0
ファイル: lcaSetTimeout.c プロジェクト: lnls-fac/code
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
LcaError theErr;
float    timeout;

	lcaErrorInit(&theErr);

	LHSCHECK(nlhs, plhs);

	if ( 1 < nlhs ) {
		lcaSetError(&theErr, EZCA_INVALIDARG, "Need one output arg");
		goto cleanup;
	}

	if ( 1 != nrhs ) {
		lcaSetError(&theErr, EZCA_INVALIDARG, "Expected one rhs argument");
		goto cleanup;
	}

	if ( !mxIsDouble(prhs[0]) || 1 != mxGetM(prhs[0]) || 1 != mxGetN(prhs[0]) ) {
		lcaSetError(&theErr, EZCA_INVALIDARG, "Need a single numeric argument");
		goto cleanup;
	}

	timeout = mxGetScalar(prhs[0]);

	if ( timeout < 0.001 ) {
		lcaSetError(&theErr, EZCA_INVALIDARG, "Timeout arg must be >= 0.001");
		goto cleanup;
	}

	ezcaSetTimeout(timeout);

	nlhs = 0;

cleanup:
	ERR_CHECK(nlhs, plhs, &theErr);
}
コード例 #22
0
static RET_CODE _subt_ctrl_show_subtitle(subt_ctrl_t *p_subt, subtitle_descr_t *p_subt_dr)
{
    RET_CODE ret = ERR_FAILURE;
    
    do
    {
        /*!
         * Hide subtitle, maybe teletext subtitle show last time, subtitle show this time 
         */
        subt_ctrl_hide();
              
        ret = mul_subtitle_start_decode(p_subt_dr->pid, 
                                        p_subt_dr->cmps_page_id, 
                                        p_subt_dr->ancl_page_id); 
        ERR_CHECK(ret);

        p_subt->m_subt_start = TRUE;

        return SUCCESS;
    }while(0);
    
    return ret;
}
コード例 #23
0
M4OSA_ERR M4MP4W_freeContext(M4OSA_Context context)
/*******************************************************************************/
{
#ifdef _M4MP4W_MOOV_FIRST
    M4OSA_UInt32 i;
#endif /*_M4MP4W_MOOV_FIRST*/
    M4MP4W_Mp4FileData* mMp4FileDataPtr = (M4MP4W_Mp4FileData*)context;
    ERR_CHECK(context != M4OSA_NULL, M4ERR_PARAMETER);

    /*freeContext is now called after closeWrite*/
    ERR_CHECK( mMp4FileDataPtr->state == M4MP4W_closed, M4ERR_STATE);
    mMp4FileDataPtr->state = M4MP4W_closed;

    if (mMp4FileDataPtr->audioTrackPtr != M4OSA_NULL)
    {
        /*delete also other chunks if any*/
        /*for (i=0; i<=mMp4FileDataPtr->audioTrackPtr->currentChunk; i++)*/

#ifdef _M4MP4W_MOOV_FIRST
        for (i=0; i<=mMp4FileDataPtr->audioTrackPtr->LastAllocatedChunk; i++)
        {
            free(mMp4FileDataPtr->audioTrackPtr->Chunk[i]);
        }
#else
        if ((M4OSA_NULL != mMp4FileDataPtr->audioTrackPtr->Chunk) &&
                (M4OSA_NULL != mMp4FileDataPtr->audioTrackPtr->Chunk[0]))
        {
            free(mMp4FileDataPtr->audioTrackPtr->Chunk[0]);
        }
        if (M4OSA_NULL != mMp4FileDataPtr->audioTrackPtr->chunkOffsetTable)
        {
            free(mMp4FileDataPtr->audioTrackPtr->chunkOffsetTable);
        }
#endif /*_M4MP4W_MOOV_FIRST*/

        /*now dynamic*/
        if (M4OSA_NULL != mMp4FileDataPtr->audioTrackPtr->Chunk)
        {
            free(mMp4FileDataPtr->audioTrackPtr->Chunk);
        }
        if (M4OSA_NULL != mMp4FileDataPtr->audioTrackPtr->chunkSizeTable)
        {
            free(mMp4FileDataPtr->audioTrackPtr->chunkSizeTable);
        }
        if (M4OSA_NULL != mMp4FileDataPtr->audioTrackPtr->chunkSampleNbTable)
        {
            free(mMp4FileDataPtr->audioTrackPtr->chunkSampleNbTable);
        }
        if (M4OSA_NULL != mMp4FileDataPtr->audioTrackPtr->chunkTimeMsTable)
        {
            free(mMp4FileDataPtr->audioTrackPtr->chunkTimeMsTable);
        }

        if (mMp4FileDataPtr->audioTrackPtr->TABLE_STTS != M4OSA_NULL)
        {
            free(mMp4FileDataPtr->audioTrackPtr->TABLE_STTS);
        }

        if (mMp4FileDataPtr->audioTrackPtr->TABLE_STSZ != M4OSA_NULL)
        {
            free(mMp4FileDataPtr->audioTrackPtr->TABLE_STSZ);
        }

        if (mMp4FileDataPtr->audioTrackPtr->DSI != M4OSA_NULL)
        {
            free(mMp4FileDataPtr->audioTrackPtr->DSI);
            mMp4FileDataPtr->audioTrackPtr->DSI = M4OSA_NULL;
        }

        free(mMp4FileDataPtr->audioTrackPtr);
        mMp4FileDataPtr->audioTrackPtr = M4OSA_NULL;
    }
    if (mMp4FileDataPtr->videoTrackPtr != M4OSA_NULL)
    {
        /*delete also other chunks if any*/
        /*for (i=0; i<=mMp4FileDataPtr->videoTrackPtr->currentChunk; i++)*/

#ifdef _M4MP4W_MOOV_FIRST
        for (i=0; i<=mMp4FileDataPtr->videoTrackPtr->LastAllocatedChunk; i++)
        {
            free(mMp4FileDataPtr->videoTrackPtr->Chunk[i]);
        }
#else
        if ((M4OSA_NULL != mMp4FileDataPtr->videoTrackPtr->Chunk) &&
                (M4OSA_NULL != mMp4FileDataPtr->videoTrackPtr->Chunk[0]))
        {
            free(mMp4FileDataPtr->videoTrackPtr->Chunk[0]);
        }
        if (M4OSA_NULL != mMp4FileDataPtr->videoTrackPtr->chunkOffsetTable)
        {
            free(mMp4FileDataPtr->videoTrackPtr->chunkOffsetTable);
        }
#endif /*_M4MP4W_MOOV_FIRST*/

        /*now dynamic*/
        if (M4OSA_NULL != mMp4FileDataPtr->videoTrackPtr->Chunk)
        {
            free(mMp4FileDataPtr->videoTrackPtr->Chunk);
        }
        if (M4OSA_NULL != mMp4FileDataPtr->videoTrackPtr->chunkSizeTable)
        {
            free(mMp4FileDataPtr->videoTrackPtr->chunkSizeTable);
        }
        if (M4OSA_NULL != mMp4FileDataPtr->videoTrackPtr->chunkSampleNbTable)
        {
            free(mMp4FileDataPtr->videoTrackPtr->chunkSampleNbTable);
        }
        if (M4OSA_NULL != mMp4FileDataPtr->videoTrackPtr->chunkTimeMsTable)
        {
            free(mMp4FileDataPtr->videoTrackPtr->chunkTimeMsTable);
        }

        if (mMp4FileDataPtr->videoTrackPtr->DSI != M4OSA_NULL)
        {
            free(mMp4FileDataPtr->videoTrackPtr->DSI);
            mMp4FileDataPtr->videoTrackPtr->DSI = M4OSA_NULL;
        }

        /*now dynamic*/
        if (M4OSA_NULL != mMp4FileDataPtr->videoTrackPtr->TABLE_STTS)
        {
            free(mMp4FileDataPtr->videoTrackPtr->TABLE_STTS);
        }
        if (M4OSA_NULL != mMp4FileDataPtr->videoTrackPtr->TABLE_STSZ)
        {
            free(mMp4FileDataPtr->videoTrackPtr->TABLE_STSZ);
        }
        if (M4OSA_NULL != mMp4FileDataPtr->videoTrackPtr->TABLE_STSS)
        {
            free(mMp4FileDataPtr->videoTrackPtr->TABLE_STSS);
        }

        free(mMp4FileDataPtr->videoTrackPtr);
        mMp4FileDataPtr->videoTrackPtr = M4OSA_NULL;
    }

    if (mMp4FileDataPtr->embeddedString != M4OSA_NULL)
    {
        free(mMp4FileDataPtr->embeddedString);
        mMp4FileDataPtr->embeddedString = M4OSA_NULL;
    }

    free(mMp4FileDataPtr);

    return M4NO_ERROR;
}
コード例 #24
0
ファイル: LicenseWin.c プロジェクト: rn10950/RetroZilla
void
InitLicTxt(void)
{
	Rect	destRect, viewRect;
	FSSpec	licFile;
	long 	dirID, dataSize;
	short 	vRefNum, dataRef, resRef;
	unsigned char* 	cLicFName;
	Str255			pLicFName;
	OSErr	err;
	Handle 	text, stylHdl;
	
	ERR_CHECK(GetCWD(&dirID, &vRefNum));
	
	/* open and read license file */
	HLock(gControls->cfg->licFileName);
	if(**gControls->cfg->licFileName != nil)
	{
		cLicFName = CToPascal(*gControls->cfg->licFileName);
		
		ERR_CHECK(FSMakeFSSpec(vRefNum, dirID, cLicFName, &licFile));
		if (cLicFName)
			DisposePtr((char*)cLicFName);
	}
	else /* assume default license filename from str rsrc */
	{	
		GetResourcedString(pLicFName, rInstList, sLicenseFName);
		ERR_CHECK(FSMakeFSSpec(vRefNum, dirID, pLicFName, &licFile));
	}
	HUnlock(gControls->cfg->licFileName);
	
	/* read license text */
	ERR_CHECK(FSpOpenDF( &licFile, fsRdPerm, &dataRef));
	ERR_CHECK(GetEOF(dataRef, &dataSize));

	if (dataSize > 0)
	{
		if (!(text = NewHandle(dataSize)))
		{
			ErrorHandler(eMem, nil);
			return;
		}
		ERR_CHECK(FSRead(dataRef, &dataSize, *text));
	}
	else
		text = nil;
	ERR_CHECK(FSClose(dataRef));

	/* get 'styl' if license is multistyled */
	resRef = FSpOpenResFile( &licFile, fsRdPerm);
	ERR_CHECK(ResError());

	UseResFile(resRef);
	stylHdl = RGetResource('styl', 128);
	ERR_CHECK(ResError());
	
	if(stylHdl)
		DetachResource(stylHdl);
	else
		stylHdl = nil;
	CloseResFile(resRef);
	
	/* TE specific init */
	HLock( (Handle) gControls->lw->licBox);
	SetRect(&viewRect, 	(*(gControls->lw->licBox))->contrlRect.left, 
						(*(gControls->lw->licBox))->contrlRect.top, 
						(*(gControls->lw->licBox))->contrlRect.right, 
						(*(gControls->lw->licBox))->contrlRect.bottom);
	HUnlock( (Handle) gControls->lw->licBox);

	destRect.left = viewRect.left;
		viewRect.right = (*(gControls->lw->scrollBar))->contrlRect.left; 
	destRect.right = viewRect.right;
	destRect.top = viewRect.top;
	destRect.bottom = viewRect.bottom * kNumLicScrns;
	
	// gControls->lw->licTxt = (TEHandle) NewPtrClear(sizeof(TEPtr));
	
	TextFont(applFont);
	TextFace(normal);
	TextSize(9);
	
	HLock(text);
	if (stylHdl)
	{
		gControls->lw->licTxt = TEStyleNew( &destRect, &viewRect );
		TEStyleInsert( *text, dataSize, (StScrpRec ** )stylHdl, 
						gControls->lw->licTxt);
	}
	else
	{
		gControls->lw->licTxt = TENew( &destRect, &viewRect);
		TEInsert( *text, dataSize, gControls->lw->licTxt);
	}
	HUnlock(text);
	
	TextFont(systemFont);
	TextSize(12);
	
	TESetAlignment(teFlushDefault, gControls->lw->licTxt);
}
コード例 #25
0
void ChatServer::send_to_all(char *msg, int len) {
	for (auto client_fd = clients.begin(); client_fd != clients.end(); client_fd++) {
		ERR_CHECK(send(client_fd->first, msg, len, MSG_NOSIGNAL));
	}
}
コード例 #26
0
int ChatServer::run(short port) {
	try {
		ERR_CHECK(listener_fd = socket(PF_INET, SOCK_STREAM, 0));

		bzero(&my_addr, sizeof(struct sockaddr_in));
		my_addr.sin_family = AF_INET;
		my_addr.sin_port = htons(port);
		my_addr.sin_addr.s_addr = htonl(INADDR_ANY);

		int yes = 1;
		ERR_CHECK(setsockopt(listener_fd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int)));

		ERR_CHECK(bind(listener_fd, (struct sockaddr *)&my_addr, sizeof(struct sockaddr)));

		ERR_CHECK(make_socket_non_blocking(listener_fd));

		ERR_CHECK(listen(listener_fd, SOMAXCONN));



		ERR_CHECK(epoll_fd = epoll_create1(0));

		event.data.fd = listener_fd;
		event.events = EPOLLIN | EPOLLET;
		ERR_CHECK(epoll_ctl(epoll_fd, EPOLL_CTL_ADD, listener_fd, &event));

		events = (epoll_event *)calloc(MAXEVENTS, sizeof(event));

		while (1) {
			int n_events;
			n_events = epoll_wait(epoll_fd, events, MAXEVENTS, -1);
			for (int i = 0; i < n_events; i++) {
				if ((events[i].events & EPOLLERR) || (events[i].events & EPOLLHUP)) {
					//throw std::system_error(errno, std::system_category());
					close_socket(events[i].data.fd);
					clients.erase(events[i].data.fd);
				}
				else if (listener_fd == events[i].data.fd) {
					while (1) {
						struct sockaddr new_addr;
						socklen_t in_len = sizeof(new_addr);
						int new_fd;
						if ((new_fd = accept(listener_fd, &new_addr, &in_len)) == -1) {
							if ((errno == EAGAIN) || (errno == EWOULDBLOCK)) {
								// we have no new connections
								break;
							}
							else {
								throw std::system_error(errno, std::system_category());
							}
						}
						printf("accepted connection\n");
						ERR_CHECK(make_socket_non_blocking(new_fd));

						// adding new desciptor to epoll
						event.data.fd = new_fd;
						event.events = EPOLLIN | EPOLLET;
						ERR_CHECK(epoll_ctl(epoll_fd, EPOLL_CTL_ADD, new_fd, &event));
						clients.insert(std::pair<int, ClientBuffer>(new_fd, ClientBuffer()));
						ERR_CHECK(send(new_fd, "Welcome\n", 8, MSG_NOSIGNAL));
					}
				}
				else {
					// we read from some socket
					//printf("reading from socket\n");
					ssize_t n_read;
					bool close_conn = false;
					// reading one less, so that we
					while (1) {
						n_read = recv(events[i].data.fd, buf, BUF_SIZE, 0);
						if (n_read == -1) {
							if ((errno != EAGAIN) && (errno != EWOULDBLOCK)) {
								close_conn = true;
							}
							// or else everything is ok, we just read everything we could
							break;
						}
						else if (n_read == 0) {
							// connection is closed
							close_conn = true;
							break;
						}
						write(1, buf, n_read);
						process_input_buffer(events[i].data.fd, n_read);
					}
					if (close_conn) {
						clients.erase(events[i].data.fd);
						close_socket(events[i].data.fd);
					}
				}
			}
		}
	}
	catch (const std::system_error& e) {
		std::cout << "Caught system_error with code " << e.code() << " meaning " << e.what() << '\n';
		if (events != nullptr) {
			free(events);
		}
		return -1;
	}
	if (events != nullptr) {
		free(events);
	}
	return 0;
}
コード例 #27
0
/// ---------------------------------------------------------------------------
/// Draws this layer
/// ---------------------------------------------------------------------------
void prBackgroundLayer::Draw()
{
    // TODO: Add screen offset for positioning

    if (mpTexture)
    {
        mpTexture->Bind();

        s32 tile = 0;
        //f32 posX;

        glEnable(GL_BLEND);
        ERR_CHECK();

        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
        ERR_CHECK();

   //         glPushMatrix();
     //       ERR_CHECK();

            //// translate to quad center, then translate for position
            //glTranslatef((GLfloat)(mTileWidth >> 1), (GLfloat)(mTileHeight >> 1), 0);
            //ERR_CHECK();

            //glTranslatef(0, 28, 0);
            //ERR_CHECK();

            //glScalef((GLfloat)mTileWidth, (GLfloat)mTileHeight, 0);
            //ERR_CHECK();

            
            //glTranslatef(mTileWidth, 0, 0);

            for (s32 y=0; y<mLayerHeight; y++)
            {
                s32 row = y*mLayerWidth;

                for (s32 x=0; x<mLayerWidth; x++)
                {
                    tile = mMapData[row + x];

                    if (tile == -1)
                        continue;
        //// Set the frame source rect position indices
        //s32 x = frame % m_framesAcross;
        //s32 y = frame / m_framesAcross;

                    // Set the tile image source rect
                    s32 xpos = tile % mTilesAcross;
                    s32 ypos = tile / mTilesAcross;
                    f32 m_u0 = xpos * mTileWidthInPixels;
                    f32 m_u1 = m_u0 + mTileWidthInPixels;            
                    f32 m_v0 = 1.0f - ((ypos * mTileHeightInPixels) + mTileHeightInPixels);
                    f32 m_v1 = m_v0 + mTileHeightInPixels;

                    prRenderer *pRenderer = static_cast<prRenderer *>(prCoreGetComponent(PRSYSTEM_RENDERER));
                    if (pRenderer)
                    {
                        glPushMatrix();
                        ERR_CHECK();

            // translate to quad center, then translate for position
            glTranslatef((GLfloat)(mTileWidth >> 1), (GLfloat)(mTileHeight >> 1), 0);
            ERR_CHECK();

            glTranslatef(0, 28, 0);
            ERR_CHECK();

                        glTranslatef((GLfloat)mTileWidth * x, (GLfloat)mTileHeight * y, 0.f);
                        glScalef((GLfloat)mTileWidth, (GLfloat)mTileHeight, 0);

                        pRenderer->DrawQuad(m_u0, m_v0, m_u1, m_v1, prColour::White);// m_colour);

    //                    prTrace(LogError, "Tile size %i, %i\n", mTileWidth , mTileHeight);
    //                    prTrace(LogError, "Tile %i, at (%i,  %i)\n", tile, mTileWidth * x, mTileHeight * y);
                
                        glPopMatrix();
                        ERR_CHECK();
                    }


    //#if defined(PLATFORM_PC)
    //        m_v0 += (m_ph / 2);             // Sub half pixel to stop blurring
    //#endif
                }
            }

//            glPopMatrix();
  //          ERR_CHECK();

        glDisable(GL_BLEND);
        ERR_CHECK();

    }
}
コード例 #28
0
int main(void)
{
trx_regval_t rval;

    /* This will stop the application before initializing the radio transceiver
     * (ISP issue with MISO pin, see FAQ)
     */
    trap_if_key_pressed();

    /* Step 0: init MCU peripherals */
    LED_INIT();
    trx_io_init(SPI_RATE_1_2);
    LED_SET_VALUE(LED_MAX_VALUE);
    LED_SET_VALUE(0);

    /* Step 1: initialize the transceiver */
    TRX_RESET_LOW();
    TRX_SLPTR_LOW();
    DELAY_US(TRX_RESET_TIME_US);
    TRX_RESET_HIGH();
    trx_reg_write(RG_TRX_STATE,CMD_TRX_OFF);
    DELAY_MS(TRX_INIT_TIME_US);
    rval = trx_bit_read(SR_TRX_STATUS);
    ERR_CHECK(TRX_OFF!=rval);
    LED_SET_VALUE(1);

    /* Step 2: setup transmitter
     * - configure radio channel
     * - enable transmitters automatic crc16 generation
     * - go into RX AACK state,
     * - configure address filter
     * - enable "receive end" IRQ
     */
    trx_bit_write(SR_CHANNEL,CHANNEL);
    trx_bit_write(SR_TX_AUTO_CRC_ON,1);

    trx_reg_write(RG_PAN_ID_0,(PANID&0xff));
    trx_reg_write(RG_PAN_ID_1,(PANID>>8));

    trx_reg_write(RG_SHORT_ADDR_0,(SHORT_ADDR&0xff));
    trx_reg_write(RG_SHORT_ADDR_1,(SHORT_ADDR>>8));

    trx_reg_write(RG_TRX_STATE,CMD_RX_AACK_ON);
#if defined(TRX_IRQ_TRX_END)
    trx_reg_write(RG_IRQ_MASK,TRX_IRQ_TRX_END);
#elif defined(TRX_IRQ_RX_END)
    trx_reg_write(RG_IRQ_MASK,TRX_IRQ_RX_END);
#else
#  error "Unknown IRQ bits"
#endif
    sei();
    LED_SET_VALUE(2);

    /* Step 3: send a frame each 500ms */
    tx_cnt = 0;
    tx_in_progress = false;
    LED_SET_VALUE(0);

    while(1);

}
コード例 #29
0
ファイル: main.cpp プロジェクト: eclipse0922/cbench-cis565s11
void setup_cl(BS_test_t *t)
{
	cl_int errcode_ret;

	// Get OpenCL platform count
	cl_uint NumPlatforms;
	clGetPlatformIDs (0, NULL, &NumPlatforms);

	// Get all OpenCL platform IDs
	cl_platform_id* PlatformIDs;
	PlatformIDs = new cl_platform_id[NumPlatforms];
	clGetPlatformIDs (NumPlatforms, PlatformIDs, NULL);

	// find NVIDIA & AMD platforms
	char cBuffer[1024];
	cl_int NvPlatform = -1;
	cl_int AMDPlatform = -1;
	for(cl_uint i = 0; i < NumPlatforms; ++i)
	{
		clGetPlatformInfo (PlatformIDs[i], CL_PLATFORM_NAME, 1024, cBuffer, NULL);
		printf("%s\n", cBuffer);
		if(strstr(cBuffer, "NVIDIA") != NULL) {
			NvPlatform = i;
		}
		else if (strstr(cBuffer, "AMD") != NULL) {
			AMDPlatform = i;
		}
	}

	// check for AMD and NVIDIA GPU devices
	cl_device_id cdDevice;
	cl_uint NvNumDevices = 0;
	cl_uint AMDNumDevices = 0;
	if (AMDPlatform != -1)
		clGetDeviceIDs(PlatformIDs[AMDPlatform], CL_DEVICE_TYPE_GPU, 0, NULL, &AMDNumDevices);
	if (NvPlatform != -1)
		clGetDeviceIDs(PlatformIDs[NvPlatform], CL_DEVICE_TYPE_GPU, 0, NULL, &NvNumDevices);

	// if there is an AMD GPU, take it, or take an NVIDIA GPU if it is there
	if (AMDNumDevices > 0)
		clGetDeviceIDs(PlatformIDs[AMDPlatform], CL_DEVICE_TYPE_GPU, 1, &cdDevice, NULL);
	else if (NvNumDevices > 0)
		clGetDeviceIDs(PlatformIDs[NvPlatform], CL_DEVICE_TYPE_GPU, 1, &cdDevice, NULL);
	else {
		fprintf(stderr, "could not find any GPU devices, exiting\n");
		delete [] PlatformIDs;
		exit(-1);
	}

	delete [] PlatformIDs;

	// get max work group size, just in case
	clGetDeviceInfo(cdDevice, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof(size_t), &(t->maxBlockSize), NULL);
	
	//Create a context
	printf("Creating context for %s GPU...\n", (AMDNumDevices > 0) ? "AMD" : "NVIDIA");
	t->hContext = clCreateContext(NULL, 1, &cdDevice, NULL, NULL, &errcode_ret);
	ERR_CHECK(errcode_ret, "clCreateContext");

	size_t nContextDescriptorSize; 
	clGetContextInfo(t->hContext, CL_CONTEXT_DEVICES, 0, 0, &nContextDescriptorSize); 
	cl_device_id * aDevices = (cl_device_id *) malloc(nContextDescriptorSize); 
	clGetContextInfo(t->hContext, CL_CONTEXT_DEVICES, nContextDescriptorSize, aDevices, 0);

	// create a command queue for first
	// device the context reported  
	t->hCmdQueue = clCreateCommandQueue(t->hContext, aDevices[0], CL_QUEUE_PROFILING_ENABLE, &errcode_ret);
	ERR_CHECK(errcode_ret, "clCreateCommandQueue");
	free(aDevices);
	
	// create & compile Black-Scholes program
	cl_program hBSProg; 
	char * BSCode;
	size_t BSLen;
	
	printf("Compiling Black-Scholes program...\n");
	BSCode = oclLoadProgSource("bs_kernel.cl", "", &BSLen);
	hBSProg = clCreateProgramWithSource(t->hContext,1, (const char **)&BSCode, &BSLen, &errcode_ret); 
	ERR_CHECK(errcode_ret, "clCreateProgramWithSource BS");
	errcode_ret = clBuildProgram(hBSProg, 0, NULL, NULL, NULL, NULL);
	ERR_CHECK(errcode_ret, "clBuildProgram BS");
	free(BSCode);

#ifdef PTX_OUTPUT
	size_t progSize;
	errcode_ret = clGetProgramInfo(hBSProg, CL_PROGRAM_BINARY_SIZES, sizeof(size_t), &progSize, NULL);
	ERR_CHECK(errcode_ret, "clGetProgramInfo");
	char ** prog = (char **) malloc (sizeof(char **));
	prog[0] = (char *) malloc(progSize * sizeof(char *));
	errcode_ret = clGetProgramInfo(hBSProg, CL_PROGRAM_BINARIES, sizeof(char **) * progSize, prog, NULL);
	ERR_CHECK(errcode_ret, "clGetProgramInfo");
	FILE * f = fopen("bs_cl.ptx", "w");
	fprintf(f, "%s\n", prog[0]);
	fclose(f);
#endif

	// create BS kernel 
	printf("Creating Black-Scholes kernel...\n");
	t->hBSKernel = clCreateKernel(hBSProg, "BlackScholes", &errcode_ret);
	ERR_CHECK(errcode_ret, "clCreateKernel BlackScholes");
} 
コード例 #30
0
ファイル: TerminalWin.c プロジェクト: rn10950/RetroZilla
void 
ShowTerminalWin(void)
{
	Str255		next, back;
	Handle		rectH;
	Rect		viewRect;
	short		reserr;
	MenuHandle 			popupMenu;
	PopupPrivateData ** pvtDataHdl;
	unsigned char *		currMenuItem;
	short 				i, vRefNum;
	long 				cwdDirID, dirID;
	Boolean				isDir = false;
	Str255				pModulesDir;
	OSErr 				err = noErr;
	GrafPtr		oldPort;
	GetPort(&oldPort);

	if (gWPtr != NULL)
	{
		SetPort(gWPtr);
	
		gCurrWin = kTerminalID; 
		/* gControls->tw = (TermWin*) NewPtrClear(sizeof(TermWin)); */
	
		GetResourcedString(next, rInstList, sInstallBtn);
		GetResourcedString(back, rInstList, sBackBtn);
	
		// malloc and get control
		rectH = Get1Resource('RECT', rStartMsgBox);
		reserr = ResError();
		if (reserr == noErr && rectH != NULL)
		{
			viewRect = (Rect) **((Rect **)rectH);
			ReleaseResource(rectH);
        }
		else
		{
			ErrorHandler(reserr, nil);
			return;
		}
		
		gControls->tw->siteSelector = NULL;
		gControls->tw->saveBitsCheckbox = NULL;
		
		gControls->tw->startMsgBox = viewRect;
	
		gControls->tw->startMsg = TENew(&viewRect, &viewRect);
        if (gControls->tw->startMsg == NULL)
        {
        	ErrorHandler(eMem, nil);
        	return;
        }
    
		// save bits after download and install
	
		/* get the "Installer Modules" relative subdir */
		ERR_CHECK(GetCWD(&cwdDirID, &vRefNum));
		GetIndString(pModulesDir, rStringList, sInstModules);
		GetDirectoryID(vRefNum, cwdDirID, pModulesDir, &dirID, &isDir);
		if (isDir)
		{
			if (!ExistArchives(vRefNum, dirID))  // going to download
			{			    
        		if (gControls->cfg->numSites > 0)
        		{
                    // download settings groupbox
                    Str255 dlSettingsGBTitle;
                    gControls->tw->dlSettingsGB = GetNewControl(rDLSettingsGB, gWPtr);
                    if (gControls->tw->dlSettingsGB)
                    {
                        GetResourcedString(dlSettingsGBTitle, rInstList, sDLSettings);
                        SetControlTitle(gControls->tw->dlSettingsGB, dlSettingsGBTitle);
                        ShowControl(gControls->tw->dlSettingsGB);
                    }
                    
                    // site selector label
                    Str255 siteSelMsgStr;
                    gControls->tw->siteSelMsg = GetNewControl(rSiteSelMsg, gWPtr);
                    if (gControls->tw->siteSelMsg)
                    {
                        GetResourcedString(siteSelMsgStr, rInstList, sSiteSelMsg);
                        SetControlData(gControls->tw->siteSelMsg, kControlNoPart, 
                            kControlStaticTextTextTag, siteSelMsgStr[0], (Ptr)&siteSelMsgStr[1]); 
                        ShowControl(gControls->tw->siteSelMsg);
                    }
                    
    		        // site selector
        			gControls->tw->siteSelector = GetNewControl( rSiteSelector, gWPtr );
        			if (!gControls->tw->siteSelector)
        			{
        				ErrorHandler(eMem, nil);
        				return;
        			}
        			
        			// populate popup button menus
        			HLock((Handle)gControls->tw->siteSelector);
        			pvtDataHdl = (PopupPrivateData **) (*(gControls->tw->siteSelector))->contrlData;
        			HLock((Handle)pvtDataHdl);
        			popupMenu = (MenuHandle) (**pvtDataHdl).mHandle;
        			for (i=0; i<gControls->cfg->numSites; i++)
        			{
        				HLock(gControls->cfg->site[i].desc);
        				currMenuItem = CToPascal(*gControls->cfg->site[i].desc);		
        				HUnlock(gControls->cfg->site[i].desc);
        				InsertMenuItem( popupMenu, currMenuItem, i );
        			}
        			HUnlock((Handle)pvtDataHdl);
        			HUnlock((Handle)gControls->tw->siteSelector);
        			SetControlMaximum(gControls->tw->siteSelector, gControls->cfg->numSites);
        			SetControlValue(gControls->tw->siteSelector, gControls->opt->siteChoice);
        			ShowControl(gControls->tw->siteSelector);
        		}
		
				// show check box and message
				gControls->tw->saveBitsCheckbox = GetNewControl( rSaveCheckbox, gWPtr );
				if (!gControls->tw->saveBitsCheckbox)
				{
					ErrorHandler(eMem, nil);
					return;
				}
				if (gControls->opt->saveBits)
				    SetControlValue(gControls->tw->saveBitsCheckbox, 1);
				ShowControl(gControls->tw->saveBitsCheckbox);
				
				// get rect for save bits message
				rectH = Get1Resource('RECT', rSaveBitsMsgBox);
				reserr = ResError();
				if (reserr == noErr && rectH != NULL)
				{
					 gControls->tw->saveBitsMsgBox  = (Rect) **((Rect **)rectH);
					 DisposeHandle(rectH);
			    }
				else
				{
					ErrorHandler(reserr, nil);
					return;
				}
				
				// get text edit record for save bits message
				gControls->tw->saveBitsMsg = TENew(&gControls->tw->saveBitsMsgBox,
												   &gControls->tw->saveBitsMsgBox );
			    if (gControls->tw->saveBitsMsg == NULL)
			    {
			    	ErrorHandler(eMem, nil);
			    	return;
			    }
			    HLock(gControls->cfg->saveBitsMsg);
				TESetText(*gControls->cfg->saveBitsMsg, strlen(*gControls->cfg->saveBitsMsg),
					gControls->tw->saveBitsMsg);
				HUnlock(gControls->cfg->saveBitsMsg);
				
				// show save bits msg
				TEUpdate(&gControls->tw->saveBitsMsgBox, gControls->tw->saveBitsMsg);
				
				// proxy settings button
				gControls->tw->proxySettingsBtn = GetNewControl(rProxySettgBtn, gWPtr);
				if (!gControls->tw->proxySettingsBtn)
				{
					ErrorHandler(eMem, nil);
					return;
				}
				Str255 proxySettingsTitle;
				GetResourcedString(proxySettingsTitle, rInstList, sProxySettings);
				SetControlTitle(gControls->tw->proxySettingsBtn, proxySettingsTitle);
				ShowControl(gControls->tw->proxySettingsBtn);
            }
		}
				
		// populate control
		HLock(gControls->cfg->startMsg);
		TESetText(*gControls->cfg->startMsg, strlen(*gControls->cfg->startMsg), 
					gControls->tw->startMsg);
		HUnlock(gControls->cfg->startMsg);
	
		// show controls
		TEUpdate(&viewRect, gControls->tw->startMsg);
		ShowNavButtons( back, next );
	}
	
	SetPort(oldPort);
}