void ColorScale::draw(sf::Image& img,const sf::Vector2f& start,const sf::Vector2f& end,GradientStyle::GradientStyle style, int size) const { sf::Color (*pFunction)(sf::Color*,int,const sf::Vector2f&,const sf::Vector2f&,int,int); sf::Color* tab =new sf::Color[size]; fillTab(tab,size); switch (style) { case GradientStyle::Linear : pFunction = GradientLinear; break; case GradientStyle::Circle : pFunction = GradientCircle; break; case GradientStyle::Radial : pFunction = GradientRadial; break; case GradientStyle::Reflex : pFunction = GradientReflex; break; default: pFunction = GradientLinear; break; } for(int i=0;i<img.GetWidth();i++) { for(int j=0;j<img.GetHeight();j++) { img.SetPixel(i,j,pFunction(tab,size,start,end,i,j)); } } delete[] tab; }
/* Traverse Bucket Set and execute a supplied function */ static void ProcessBucketGroup(Bucket_Group *pBucketGroup, void (*pFunction)(Bucket_Group *pBucketGroup,Bucket_Data *pBucketData)) { int nIndex = 0; int nStart = 0; Bucket *pBucket = 0; Bucket_Data *pBucketData = 0; Bucket_Data *pLower = 0; Bucket_Data *pUpper = 0; Dwarf_Bool bFound = FALSE; /* Sanity checks */ assert(pBucketGroup); /* No sentinels present; do nothing */ if (!pBucketGroup->pFirst || !pBucketGroup->pLast) { return; } /* Find bucket that contains the first sentinel */ for (pBucket = pBucketGroup->pHead; pBucket && pBucket->nEntries; pBucket = pBucket->pNext) { pLower = &pBucket->Entries[0]; pUpper = &pBucket->Entries[pBucket->nEntries - 1]; /* Check if the first sentinel is in this bucket */ if (pBucketGroup->pFirst >= pLower && pBucketGroup->pFirst <= pUpper) { /* Low sentinel is in this bucket */ bFound = TRUE; break; } } /* Invalid sentinel; do nothing */ if (!bFound) { return; } /* Calculate index for first sentinel */ nStart = pBucketGroup->pFirst - pLower; /* Start traversing from found bucket */ for (; pBucket && pBucket->nEntries; pBucket = pBucket->pNext) { for (nIndex = nStart; nIndex < pBucket->nEntries; ++nIndex) { pBucketData = &pBucket->Entries[nIndex]; if (pBucketData > pBucketGroup->pLast) { return; } /* Call the user supplied function */ if (pFunction) { pFunction(pBucketGroup,pBucketData); } } /* For next bucket start with first entry */ nStart = 0; } }
void ColorScale::fillTab(sf::Color* colorTab, int size,InterpolationFunction::InterpolationFunction function) const { ColorScale::const_iterator start = std::map<double,sf::Color>::begin(); ColorScale::const_iterator last = std::map<double,sf::Color>::end(); last--; double pos = 0.0; double distance = last->first - start->first; ColorScale::const_iterator it = start; double(*pFunction)(double,double,double); switch (function) { case InterpolationFunction::Cosinus: pFunction = interpolateCosinus; break; case InterpolationFunction::Linear : pFunction = linearInterpolation; break; default: pFunction = interpolateCosinus; break; } while(it!=last) { sf::Color startColor = it->second; double startPos = it->first; it++; sf::Color endColor = it->second; double endPos = it->first; double nb_color = ((endPos-startPos)*(double)size/distance); for(int i = (int)pos;i<(int)(pos+nb_color);i++) { colorTab[i].r = (unsigned char)pFunction(startColor.r,endColor.r,std::abs((double)i-pos)/(nb_color-1.0)); colorTab[i].g = (unsigned char)pFunction(startColor.g,endColor.g,std::abs((double)i-pos)/(nb_color-1.0)); colorTab[i].b = (unsigned char)pFunction(startColor.b,endColor.b,std::abs((double)i-pos)/(nb_color-1.0)); colorTab[i].a = (unsigned char)pFunction(startColor.a,endColor.a,std::abs((double)i-pos)/(nb_color-1.0)); } pos+=nb_color; } }
//! //! Helper to do something on each instance of a given list //! //! @param[in] ppHead a pointer to the pointer to the head of the list //! @param[in] pFunction a pointer to the function to execute on each node //! @param[in] pParam a transparent pointer to provide to pFunction //! //! @return EUCA_OK on success or the following error code: //! \li EUCA_INVALID_ERROR: if any of our parameters do not meet the pre-conditions //! //! @pre Both \p ppHead and \p pFunction fields must not be NULL //! //! @post The function \p pFunction is applied to each member of the instance list. //! int for_each_instance(bunchOfInstances ** ppHead, void (*pFunction) (bunchOfInstances **, ncInstance *, void *), void *pParam) { bunchOfInstances *pHead = NULL; // Make sure our parameters aren't NULL if (ppHead && pFunction) { for (pHead = *ppHead; pHead; pHead = pHead->next) { pFunction(ppHead, pHead->instance, pParam); } return (EUCA_OK); } return (EUCA_INVALID_ERROR); }
int32_t dvbfe_setParam(uint32_t adapter, int32_t wait_for_lock, EIT_media_config_t *media, dvbfe_cancelFunctionDef* pFunction) { uint8_t needTune = 0; fe_delivery_system_t delSys; uint32_t frequency; int32_t ret; int32_t hasLock; int32_t hasSignal; int32_t timeout; if(media == NULL) { eprintf("%s(): Error on tuning adapter%d, bad params!\n", __func__, adapter); return -1; } delSys = dvbfe_getDelSysFromMedia(media); frequency = media->frequency; if(g_adapterInfo[adapter].state.forceSetDelSys || (g_adapterInfo[adapter].state.curDelSys != delSys)) { if(dvbfe_setFrontendType(adapter, delSys) != 0) { eprintf("%s[%d]: Failed to set frontend delSys for current service\n", __func__, adapter); return -1; } g_adapterInfo[adapter].state.forceSetDelSys = 0; needTune = 1; } if(g_adapterInfo[adapter].state.frequency != frequency) { g_adapterInfo[adapter].state.frequency = frequency; needTune = 1; } switch(delSys) { case SYS_DVBT2: { uint8_t plp_id = media->dvb_t.plp_id; //check if tune needed if(g_adapterInfo[adapter].state.dvbtInfo.plp_id != plp_id) { g_adapterInfo[adapter].state.dvbtInfo.plp_id = plp_id; needTune = 1; } //no break!!! } case SYS_DVBT: // g_adapterInfo[adapter].state.dvbtInfo.generation = generation; // g_adapterInfo[adapter].state.dvbtInfo.bandwidth = bandwidth; break; case SYS_DVBC_ANNEX_AC: if((g_adapterInfo[adapter].state.dvbcInfo.symbolRate != media->dvb_c.symbol_rate) || (g_adapterInfo[adapter].state.dvbcInfo.modulation != media->dvb_c.modulation)) { g_adapterInfo[adapter].state.dvbcInfo.symbolRate = media->dvb_c.symbol_rate; g_adapterInfo[adapter].state.dvbcInfo.modulation = media->dvb_c.modulation; needTune = 1; } break; case SYS_DVBS: case SYS_DVBS2: { uint32_t polarization = media->dvb_s.polarization; if(g_adapterInfo[adapter].state.dvbsInfo.polarization != polarization) { g_adapterInfo[adapter].state.dvbsInfo.polarization = polarization; needTune = 1; } // g_adapterInfo[adapter].state.dvbsInfo.band = appControlInfo.dvbsInfo.band; // g_adapterInfo[adapter].state.dvbsInfo.diseqc = appControlInfo.dvbsInfo.diseqc; // g_adapterInfo[adapter].state.dvbsInfo.symbolRate = symbol_rate; break; } case SYS_ATSC: case SYS_DVBC_ANNEX_B: // g_adapterInfo[adapter].state.atscInfo.modulation = modulation; break; default: needTune = 1; break; } if(needTune == 0) { //check if tuner locked tunerState_t state; memset(&state, 0, sizeof(state)); dvbfe_getSignalInfo(adapter, &state); if(state.fe_status & FE_HAS_LOCK) { //no need to reconfigure tuner return 0; } } ret = -1; eprintf("%s(): Tune adapter=%d tuner, frequency=%uHz\n", __func__, adapter, frequency); switch(g_adapterInfo[adapter].driverType) { case eTunerDriver_linuxDVBapi: ret = dvbfe_setParamLinuxDVBapi(adapter, delSys, frequency, media); break; case eTunerDriver_STAPISDK: ret = dvbfe_setParamSTAPISDK(adapter, delSys, frequency, media); break; default: break; } if(ret != 0) { eprintf("%s(): Tuner %d not tuned on %u\n", __func__, adapter, frequency); } if(appControlInfo.dvbCommonInfo.adapterSpeed < 0) {//is this can happen? wait_for_lock = 0; } if(wait_for_lock == 0) { // eprintf("%s(): g_adapterInfo[%d].fd=%d\n", __func__, adapter, g_adapterInfo[adapter].fd); return 1;//1 mean 'no lock' } hasLock = 0; hasSignal = 0; timeout = (appControlInfo.dvbCommonInfo.adapterSpeed + 1); #ifdef STBTI timeout *= 10; #endif do { tunerState_t state; uint32_t us; uint32_t i; memset(&state, 0, sizeof(state)); state.ber = BER_THRESHOLD; dvbfe_getSignalInfo(adapter, &state); if(state.fe_status & FE_HAS_LOCK) { if(!hasLock) { // locked, give adapter even more time... dprintf("%s()[%d]: L\n", __func__, adapter); } else { break; } hasLock = 1; } else if(state.fe_status & FE_HAS_SIGNAL) { if(hasSignal == 0) { eprintf("%s()[%d]: Has signal\n", __func__, adapter); // found something above the noise level, increase timeout time timeout += appControlInfo.dvbCommonInfo.adapterSpeed; hasSignal = 1; } dprintf("%s()[%d]: S (%d)\n", __func__, adapter, timeout); } else { dprintf("%s()[%d]: N (%d)\n", __func__, adapter, timeout); // there's no and never was any signal, reach timeout faster if(hasSignal == 0) { eprintf("%s()[%d]: Skip\n", __func__, adapter); --timeout; } } // If ber is not -1, then wait a bit more // if(state.ber == 0xffffffff) { dprintf("%s()[%d]: All clear...\n", __func__, adapter); us = 100000; // } else { // eprintf("%s()[%d]: Something is out there... (ber %u)\n", __func__, adapter, state.ber); // us = 500000; // } usleep(appControlInfo.dvbCommonInfo.adapterSpeed*10000); for(i = 0; i < us; i += SLEEP_QUANTUM) { if(pFunction && (pFunction() == -1)) { return -1; } if(dvbfe_getSignalInfo(adapter, NULL) == 1) { break; } usleep(SLEEP_QUANTUM); } // if((state.ber > 0) && (state.ber < BER_THRESHOLD)) { // break; // } } while(--timeout > 0); dprintf("%s[%d]: %u timeout %d, ber %u\n", __func__, adapter, frequency, timeout, ber); eprintf("%s(): Frequency set: adapter=%d, frequency=%ud, hasLock=%d, wait_for_lock=%d\n", __func__, adapter, frequency, hasLock, wait_for_lock); return !hasLock; }
pStatement Statement::parse() { if (currentToken().type == TT_NAMESPACE) { nextToken(); _namespace = new_Namespace()->parse(); } else if(currentToken().type == TT_TYPEDEF) { } else if(currentToken().type == TT_STRUCT || currentToken().type == TT_CLASS) { isClass = true; if(currentToken().type == TT_STRUCT) { isStruct = true; } nextToken(); _namespace = new_Namespace(); _namespace->statementsBlock = new_StatementsBlock(); _namespace->id = currentToken().strVal; pType newType = pType(new Type(owner, false) ); pExprResult res = owner->new_ExprResult(); res->evalType = ERT_TYPE; res->type = newType; newType->definition = this; owner->parsingStatementsBlockStack.back()->vars[_namespace->id] = res; _namespace->parse(); if(currentToken().type != TT_SEMICOLON) { Parser::get()->parsingException(__FUNCTION__, __FILE__, __LINE__, currentToken(), "Expected semicolon"); } nextToken(); } else if (currentToken().type == TT_BRACE_OPEN) { this->sb = new_StatementsBlock()->parse(); } else if (currentToken().type == TT_BREAK || currentToken().type == TT_RETURN || currentToken().type == TT_ECHO || currentToken().type == TT_CONTINUE) { isSpecial = true; specialType = currentToken().type; nextToken(); if (specialType == TT_RETURN || specialType == TT_ECHO) { expr = new_Expr()->parse(); } if (currentToken().type != TT_SEMICOLON) { throwTokenExpected(TT_SEMICOLON); } nextToken(); } else if (currentToken().type == TT_IF) { isSpecial = true; specialType = currentToken().type; nextToken(); expr = new_Expr()->parse(); statement1 = new_Statement()->parse(); if (currentToken().type == TT_ELSE) { nextToken(); statement2 = new_Statement()->parse(); } } else if (currentToken().type == TT_WHILE) { localStatementsBlock = new_StatementsBlock(); owner->parsingStatementsBlockStack.push_back(localStatementsBlock); isSpecial = true; specialType = currentToken().type; if (nextToken().type != TT_PARENTHESIS_OPEN) { Parser::get()->parsingException(__FUNCTION__, __FILE__, __LINE__, currentToken() ); } nextToken(); expr = new_Expr()->parse(); if (currentToken().type != TT_PARENTHESIS_CLOSE) { Parser::get()->parsingException(__FUNCTION__, __FILE__, __LINE__, currentToken() ); } nextToken(); statement1 = new_Statement()->parse(); owner->parsingStatementsBlockStack.pop_back(); } else if (currentToken().type == TT_FOR) { localStatementsBlock = new_StatementsBlock(); owner->parsingStatementsBlockStack.push_back(localStatementsBlock); isSpecial = true; specialType = currentToken().type; if (nextToken().type != TT_PARENTHESIS_OPEN) { Parser::get()->parsingException(__FUNCTION__, __FILE__, __LINE__, currentToken() ); } nextToken(); statement1 = new_Statement()->parse(); expr = new_Expr()->parse(); if (currentToken().type != TT_SEMICOLON) { Parser::get()->parsingException(__FUNCTION__, __FILE__, __LINE__, currentToken() ); } nextToken(); expr2 = new_Expr()->parse(); if (currentToken().type != TT_PARENTHESIS_CLOSE) { Parser::get()->parsingException(__FUNCTION__, __FILE__, __LINE__, currentToken() ); } nextToken(); statement2 = new_Statement()->parse(); owner->parsingStatementsBlockStack.pop_back(); } else { tryParse([this]() { tn = new_Typename()->parse(); pVarDeclarationAllowDefault vd = new_VarDeclarationAllowDefault()->parse(); if (owner->currentToken().type == TT_PARENTHESIS_OPEN) { if (!vd->canBeFunctionDeclaration() ) { Parser::get()->parsingException(__FUNCTION__, __FILE__, __LINE__, currentToken() ); } nextToken(); this->function = pFunction(new Function(owner, vd->vd->id) ); this->function->args = new_FunctionArgs()->parse(); if (currentToken().type == TT_PARENTHESIS_CLOSE) { if (nextToken().type == ';') { this->function->statementsBlock = nullptr; } else { this->function->statementsBlock = new_StatementsBlock()->parse(); for (auto vd: this->function->args->vds) { this->function->statementsBlock->vars[vd->vd->id] = nullptr; } } } else { Parser::get()->parsingException(__FUNCTION__, __FILE__, __LINE__, currentToken(), "Unexpeted token"); } } else { if (currentToken().type == TT_COMMA || currentToken().type == TT_SEMICOLON) { vds.push_back(vd); } while (currentToken().type == TT_COMMA) { nextToken(); vds.push_back(new_VarDeclarationAllowDefault()->parse() ); } if (currentToken().type != TT_SEMICOLON) { Parser::get()->parsingException(__FUNCTION__, __FILE__, __LINE__, currentToken() ); } nextToken(); } }, [this](exception &e) { vds.clear(); tn = nullptr; expr = new_Expr()->parse(); this->function = nullptr; if (currentToken().type != TT_SEMICOLON) { Parser::get()->parsingException(__FUNCTION__, __FILE__, __LINE__, currentToken() ); } nextToken(); }); } return pStatement(this); }