static t_int *vline_tilde_perform(t_int *w) { t_vline *x = (t_vline *)(w[1]); t_sample *out = (t_sample *)(w[2]); int n = (int)(w[3]), i; t_sample f = x->x_value; t_sample inc = x->x_inc; t_time msecpersamp = x->x_msecpersamp; #ifndef ROCKBOX t_time samppermsec = x->x_samppermsec; #endif t_time timenow = clock_gettimesince(x->x_referencetime) - n * msecpersamp; t_vseg *s = x->x_list; for (i = 0; i < n; i++) { t_time timenext = timenow + msecpersamp; checknext: if (s) { /* has starttime elapsed? If so update value and increment */ if (s->s_starttime < timenext) { if (x->x_targettime <= timenext) f = x->x_target, inc = 0; /* if zero-length segment bash output value */ if (s->s_targettime <= s->s_starttime) { f = s->s_target; inc = 0; } else { t_time incpermsec = idiv((s->s_target - f), (s->s_targettime - s->s_starttime)); f = mult(f + incpermsec,(timenext - s->s_starttime)); inc = mult(incpermsec,msecpersamp); } x->x_inc = inc; x->x_target = s->s_target; x->x_targettime = s->s_targettime; x->x_list = s->s_next; t_freebytes(s, sizeof(*s)); s = x->x_list; goto checknext; } } if (x->x_targettime <= timenext) f = x->x_target, inc = 0; *out++ = f; f = f + inc; timenow = timenext; } x->x_value = f; return (w+4); }
int main(int argc, const char *argv[]) { int i; int *mem = malloc(1100000); capture_stdio(); for (i = 0;; ++i) { int32_t t0[2], t1[2]; char *msg; int n; gp_get_usertime(t0); switch (i) { case 0: iadd(0, n = 10000000, &msg); break; case 1: imul(1, n = 1000000, &msg); break; case 2: idiv(1, n = 1000000, &msg); break; case 3: fadd(3.14, n = 10000000, &msg); break; case 4: fmul(1.0000001, n = 10000000, &msg); break; case 5: fdiv(1.0000001, n = 1000000, &msg); break; case 6: fconv(12345, n = 10000000, &msg); break; case 7: mfast(mem, n = 10000000, &msg); break; case 8: mslow(mem, n = 1000000, &msg); break; default: free(mem); exit(0); } gp_get_usertime(t1); fprintf(stdout, "Time for %9d %s = %g ms\n", n, msg, (t1[0] - t0[0]) * 1000.0 + (t1[1] - t0[1]) / 1000000.0); fflush(stdout); } }
// for: _iadd, _imul, _isub, _idiv, _irem void LIRGenerator::do_ArithmeticOp_Int(ArithmeticOp* x) { bool is_div_rem = x->op() == Bytecodes::_idiv || x->op() == Bytecodes::_irem; LIRItem left(x->x(), this); LIRItem right(x->y(), this); // missing test if instr is commutative and if we should swap right.load_nonconstant(); assert(right.is_constant() || right.is_register(), "wrong state of right"); left.load_item(); rlock_result(x); if (is_div_rem) { CodeEmitInfo* info = state_for(x); LIR_Opr tmp = FrameMap::G1_opr; if (x->op() == Bytecodes::_irem) { __ irem(left.result(), right.result(), x->operand(), tmp, info); } else if (x->op() == Bytecodes::_idiv) { __ idiv(left.result(), right.result(), x->operand(), tmp, info); } } else { arithmetic_op_int(x->op(), x->operand(), left.result(), right.result(), FrameMap::G1_opr); } }
// for: _iadd, _imul, _isub, _idiv, _irem void LIRGenerator::do_ArithmeticOp_Int(ArithmeticOp* x) { if (x->op() == Bytecodes::_idiv || x->op() == Bytecodes::_irem) { // The requirements for division and modulo // input : rax,: dividend min_int // reg: divisor (may not be rax,/rdx) -1 // // output: rax,: quotient (= rax, idiv reg) min_int // rdx: remainder (= rax, irem reg) 0 // rax, and rdx will be destroyed // Note: does this invalidate the spec ??? LIRItem right(x->y(), this); LIRItem left(x->x() , this); // visit left second, so that the is_register test is valid // call state_for before load_item_force because state_for may // force the evaluation of other instructions that are needed for // correct debug info. Otherwise the live range of the fix // register might be too long. CodeEmitInfo* info = state_for(x); left.load_item_force(divInOpr()); right.load_item(); LIR_Opr result = rlock_result(x); LIR_Opr result_reg; if (x->op() == Bytecodes::_idiv) { result_reg = divOutOpr(); } else { result_reg = remOutOpr(); } if (!ImplicitDiv0Checks) { __ cmp(lir_cond_equal, right.result(), LIR_OprFact::intConst(0)); __ branch(lir_cond_equal, T_INT, new DivByZeroStub(info)); } LIR_Opr tmp = FrameMap::rdx_opr; // idiv and irem use rdx in their implementation if (x->op() == Bytecodes::_irem) { __ irem(left.result(), right.result(), result_reg, tmp, info); } else if (x->op() == Bytecodes::_idiv) { __ idiv(left.result(), right.result(), result_reg, tmp, info); } else { ShouldNotReachHere(); } __ move(result_reg, result); } else { // missing test if instr is commutative and if we should swap LIRItem left(x->x(), this); LIRItem right(x->y(), this); LIRItem* left_arg = &left; LIRItem* right_arg = &right; if (x->is_commutative() && left.is_stack() && right.is_register()) { // swap them if left is real stack (or cached) and right is real register(not cached) left_arg = &right; right_arg = &left; } left_arg->load_item(); // do not need to load right, as we can handle stack and constants if (x->op() == Bytecodes::_imul ) { // check if we can use shift instead bool use_constant = false; bool use_tmp = false; if (right_arg->is_constant()) { int iconst = right_arg->get_jint_constant(); if (iconst > 0) { if (is_power_of_2(iconst)) { use_constant = true; } else if (is_power_of_2(iconst - 1) || is_power_of_2(iconst + 1)) { use_constant = true; use_tmp = true; } } } if (use_constant) { right_arg->dont_load_item(); } else { right_arg->load_item(); } LIR_Opr tmp = LIR_OprFact::illegalOpr; if (use_tmp) { tmp = new_register(T_INT); } rlock_result(x); arithmetic_op_int(x->op(), x->operand(), left_arg->result(), right_arg->result(), tmp); } else { right_arg->dont_load_item(); rlock_result(x); LIR_Opr tmp = LIR_OprFact::illegalOpr; arithmetic_op_int(x->op(), x->operand(), left_arg->result(), right_arg->result(), tmp); } } }
static void vline_tilde_dsp(t_vline *x, t_signal **sp) { dsp_add(vline_tilde_perform, 3, x, sp[0]->s_vec, sp[0]->s_n); x->x_samppermsec = idiv(ftofix(sp[0]->s_sr),ftofix(1000)); x->x_msecpersamp = idiv(ftofix(1000),ftofix(sp[0]->s_sr)); }
void QRFinder::FindFinderPatterns(cv::Mat& inputImg, Rect regionOfInterest, vector<FinderPattern*> & finderPatterns, vector<Drawable*> & debugVector) { struct timespec start,end; SET_TIME(&start); //Get parameters from config edgeThreshold = config->GetIntegerParameter("EdgeThreshold"); debugLevel = config->GetIntegerParameter("QR Debug Level"); int verticalResolution = config->GetIntegerParameter("YResolution"); nonMaxEnabled = config->GetBooleanParameter("EdgeNonMax"); minimumFinderPatternScore = config->GetIntegerParameter("MinimumFPScore"); detectorSize = config->GetIntegerParameter("DetectorSize"); int yBorder = detectorSize; vector<Point3i> exclusionZones; //Calculate limits int maxColumn = regionOfInterest.x + regionOfInterest.width; maxColumn -= detectorSize; int maxRow = regionOfInterest.y + regionOfInterest.height; int xStart = regionOfInterest.x; int yStart = regionOfInterest.y; xStart += detectorSize; yStart += detectorSize; maxColumn -= detectorSize; maxRow -= detectorSize; if (debugLevel > 0) debugVector.push_back(new DebugRectangle(Rect(Point2i(xStart,yStart),Point2i(maxColumn,maxRow)),Colors::Aqua,1)); //Find horizontal edges SET_TIME(&start); FindEdgesClosed(inputImg,regionOfInterest,edgeArray,edgeThreshold,nonMaxEnabled,detectorSize); SET_TIME(&end); double edgeTime_local = calc_time_double(start,end); edgeTime = (edgeTime + edgeTime_local)/2.0; config->SetLabelValue("EdgeTime",(float)edgeTime/1000.0f); //If debug level set, find all vertical edges and draw them if (debugLevel <= -2) { for (int x = 1; x < verticalEdgeArray.rows-1; x ++) { FindEdgesVerticalClosed(inputImg,x); const short * verticalEdgePtr = verticalEdgeArray.ptr<short>(x); for (int y = 0; y < (verticalEdgeArray.cols);y++) { short transition = verticalEdgePtr[y]; if (transition < 0) { debugVector.push_back(new DebugCircle(Point2i(x,y),0,Colors::Fuchsia,true)); } else if (transition > 0) { debugVector.push_back(new DebugCircle(Point2i(x,y),0,Colors::Cyan,true)); } } } } //END int bw[6] = { 0 }; int k = 0; //LOGV(LOGTAG_QR,"ImgSize=[%d,%d] EdgeSize=[%d,%d]",inputImg.rows,inputImg.cols,edgeArray.rows,edgeArray.cols); int yDirection = 1; int yCenter = yStart + (maxRow - yStart)/2; int y = yStart, absOffset = 0; LOGV(LOGTAG_QR,"Beginning search. y[%d->%d], Center=%d, x[%d->%d]",yStart,maxRow,yCenter,xStart,maxColumn); while (y < maxRow && y >= yStart) { y = yCenter + absOffset * yDirection; if (yDirection == 1) absOffset += verticalResolution; //Increment every other frame yDirection = -yDirection; //Change direction every frame k = 0; bw[0] = bw[1] = bw[2] = bw[3] = bw[4] = bw[5] = 0; const short * edgeRowPtr = edgeArray.ptr<short>(y); for (int x = xStart; x < maxColumn; x++) { if (isInRadius(exclusionZones,Point2i(x,y))) continue; int transition = edgeRowPtr[x]; //getTransition(Mi,x,threshold); if (k == 0) //Haven't found edge yet { if (transition < 0) /* Light->dark transistion */ { k++; } } else //Found at least one edge { if ((k & 1) == 1) //Counting dark { if (transition > 0) //dark to light { ++k; } } else //Counting light { if (transition < 0) //light to dark { ++k; } } } if (k > 0) ++bw[k-1]; if (FP_DEBUG_ENABLED && (debugLevel == -1 || debugLevel == -2)) { if (transition < 0) debugVector.push_back(new DebugCircle(Point2i(x,y),0,Colors::Lime,true)); else if (transition > 0) debugVector.push_back(new DebugCircle(Point2i(x,y),0,Colors::Yellow,true)); } if (k == 6) { int result = 0; result = CheckRatios(bw,NULL); if (result == 1) { //LOGV(LOGTAG_QR,"Ratio check pass"); //Center based on initial ratio float patternCenterWidth = (float)bw[2]; int tempXCenter = (x - bw[4] - bw[3]) - (int)round(patternCenterWidth/2.0f); float xOffset = (patternCenterWidth/6.0f); //y coordinate of center. If check fails, returns 0. int tempYCenterArray[] = {0,0,0}; int * verticalPatternSizes[3]; for (int i = 0;i < 3;i++) verticalPatternSizes[i] = new int[5]; tempYCenterArray[0] = FindCenterVertical(inputImg, tempXCenter, y, bw, debugVector,verticalPatternSizes[0]); tempYCenterArray[1] = FindCenterVertical(inputImg, tempXCenter - xOffset, y, bw, debugVector,verticalPatternSizes[1]); tempYCenterArray[2] = FindCenterVertical(inputImg, tempXCenter + xOffset, y, bw, debugVector,verticalPatternSizes[2]); int tempYCenter = 0; int passCount = 0; float avgYSize = 0; int averageVerticalSize[5] = {0,0,0,0,0}; for (int yTest = 0; yTest < 3; yTest++) { if (tempYCenterArray[yTest] > 0) { passCount++; tempYCenter += tempYCenterArray[yTest]; for (int i=0;i<5;i++) { averageVerticalSize[i] += (verticalPatternSizes[yTest])[i]; avgYSize += (verticalPatternSizes[yTest])[i]; } } } if (passCount >= 2) { //LOGV(LOGTAG_QR,"Vertical test pass-1"); tempYCenter = (int)round((float)tempYCenter / (float)passCount); avgYSize = (float)avgYSize / (float)passCount; int allowedVariance = (int)avgYSize >> 2; bool yVarianceTest = true; for (int yTest = 0; yTest < 3; yTest++) { if (tempYCenterArray[yTest] > 0) { if (abs(tempYCenterArray[yTest] - tempYCenter) > allowedVariance) { yVarianceTest = false; break; } } } if (yVarianceTest) { //LOGV(LOGTAG_QR,"Vertical test pass-2. Passcount=%d",passCount); //Average the vertical pattern sizes for (int i=0;i<5;i++) { averageVerticalSize[i] = idiv(averageVerticalSize[i],passCount); } //LOGV(LOGTAG_QR,"Averaged sizes. Center=%d",averageVerticalSize[2]); int tempXCenterArray[] = {0,0,0}; int xSizeArray[] = {0,0,0}; int yOffset = idiv(averageVerticalSize[2],6.0f); //LOGV(LOGTAG_QR,"Yoffset=%d,yCenter=%d",yOffset,tempYCenter); tempXCenterArray[0] = FindCenterHorizontal(tempXCenter, tempYCenter-yOffset, bw, xSizeArray[0], debugVector); tempXCenterArray[1] = FindCenterHorizontal(tempXCenter, tempYCenter, bw, xSizeArray[1], debugVector); tempXCenterArray[2] = FindCenterHorizontal(tempXCenter, tempYCenter+yOffset, bw, xSizeArray[2], debugVector); tempXCenter = 0; passCount = 0; float avgXSize = 0; for (int xTest = 0; xTest < 3; xTest++) { if (tempXCenterArray[xTest] > 0) { passCount++; tempXCenter += tempXCenterArray[xTest]; avgXSize += xSizeArray[xTest]; } } if (passCount >= 2) { //LOGV(LOGTAG_QR,"Horizontal test pass"); tempXCenter = (int)round((float)tempXCenter / (float)passCount); avgXSize = (float)avgXSize/(float)passCount; //allowedVariance = (int)round((float)avgYSize/1.5f); float aspectRatio = avgXSize/avgYSize; if (aspectRatio > 0.33f && aspectRatio < 3.0f) { //LOGV(LOGTAG_QR,"Size test pass"); Point2i finderPatternCenter = Point2i(tempXCenter,tempYCenter); //Center of finder pattern int finderPatternSize = MAX(avgXSize,avgYSize); int fpRadius = (int)round((float)finderPatternSize/2.0f); int fpRadiusExclude = ipow(finderPatternSize,2); //LOGD(LOGTAG_QR,"Creating new pattern[%d,%d]",avgXSize,avgYSize); //Create a new pattern FinderPattern * newPattern = new FinderPattern(finderPatternCenter,Size2i(avgXSize,avgYSize)); Size2f patternSearchSize = Size2f(avgXSize,avgYSize); vector<Point2i> corners; struct timespec fastStart,fastEnd; SET_TIME(&fastStart); fastQRFinder->LocateFPCorners(inputImg,newPattern,corners,debugVector); // fastQRFinder->CheckAlignmentPattern(inputImg,finderPatternCenter,patternSearchSize,corners,debugVector); SET_TIME(&fastEnd); double fastFPTime_Local = calc_time_double(fastStart,fastEnd); fastFPTime += fastFPTime_Local; if (corners.size() == 4) { //if (validatePattern(newPattern,finderPatterns)) //{ newPattern->patternCorners = corners; exclusionZones.push_back(Point3i(finderPatternCenter.x,finderPatternCenter.y, fpRadiusExclude)); finderPatterns.push_back(newPattern); if (FP_DEBUG_ENABLED && debugLevel > 0) { debugVector.push_back(new DebugCircle(finderPatternCenter,fpRadius,Colors::MediumSpringGreen,1,true)); for (int i=0;i<corners.size();i++) { if (FP_DEBUG_ENABLED && debugLevel > 0) debugVector.push_back(new DebugCircle(corners[i],10,Colors::DodgerBlue,2)); } } //} //else //{ // //LOGV(LOGTAG_QR,"Compare check failed"); // if (FP_DEBUG_ENABLED && debugLevel > 0) // debugVector.push_back(new DebugCircle(finderPatternCenter,fpRadius,Colors::HotPink,2)); //} } else { //LOGV(LOGTAG_QR,"FAST check failed"); if (FP_DEBUG_ENABLED && debugLevel > 0) debugVector.push_back(new DebugCircle(finderPatternCenter,fpRadius,Colors::Red,2)); delete newPattern; } } else { //LOGV(LOGTAG_QR,"Size check failed"); //Size check failed if (FP_DEBUG_ENABLED && debugLevel > 1) debugVector.push_back(new DebugCircle(Point2i(tempXCenter,tempYCenter),13, Colors::HotPink,1)); } } else { //LOGV(LOGTAG_QR,"Horizontal check failed"); //Vertical check succeeded, but horizontal re-check failed if (FP_DEBUG_ENABLED && debugLevel > 1) debugVector.push_back(new DebugCircle(Point2i(tempXCenter,tempYCenter),12, Colors::OrangeRed,1)); } } else { //LOGV(LOGTAG_QR,"Variance test failed. AllowedVariance = %d, yCenters = %d,%d,%d [avg=%d], AvgYSize=%d",allowedVariance,tempYCenterArray[0],tempYCenterArray[1],tempYCenterArray[2],tempYCenter,avgYSize); //Vertical variance test failed if (FP_DEBUG_ENABLED && debugLevel > 1) debugVector.push_back(new DebugCircle(Point2i(tempXCenter,tempYCenter),14, Colors::MediumSpringGreen,1)); } } else { //Ratios were correct but vertical check failed if (FP_DEBUG_ENABLED && debugLevel > 2) { if (tempYCenter == 0) //ratio fail debugVector.push_back(new DebugCircle(Point2i(tempXCenter,y),10,Colors::Aqua,1)); else if (tempYCenter == -1) //topcheck fail debugVector.push_back(new DebugCircle(Point2i(tempXCenter,y),10,Colors::Orange,1)); else if (tempYCenter == -2) //bottomcheck fail debugVector.push_back(new DebugCircle(Point2i(tempXCenter,y),10,Colors::Lime,1)); } } }
/* FlvScreen.blit_rgba(x,y,w,h,data) * copy the rgba data. */ static PyObject* FlvScreen_blit_rgba(PyFlvScreen* self, PyObject* args) { PyObject* data; int px, py, pw, ph; int changes = 0; int blk_size = self->blk_size; if (!PyArg_ParseTuple(args, "iiiiO", &px, &py, &pw, &ph, &data)) { return NULL; } /* check the data type */ if (!PyString_CheckExact(data)) { PyErr_SetString(PyExc_TypeError, "must be string"); return NULL; } /* check the data size */ if (PyString_Size(data) != pw*ph*sizeof(RGBAPixel)) { PyErr_SetString(PyExc_FlvError, "invalid data size"); return NULL; } /* copy the image data */ { RGBAPixel* src = (RGBAPixel*)PyString_AsString(data); int bx0 = idiv(px, blk_size); int bx1 = idiv(px+pw-1, blk_size); for (; 0 < ph; ph--, py++, src += pw) { int bx; int by = idiv(py, blk_size); int changed = 0; if (by < 0 || self->blk_height <= by) continue; for (bx = bx0; bx <= bx1; bx++) { int px0 = bx * blk_size; int px1 = (bx+1) * blk_size; unsigned char* blk = &self->blocks[by*self->blk_width + bx]; RGBAPixel* dst = &self->pixels[py*self->pix_width + px0]; int i, j, n; if (bx < 0 || self->blk_width <= bx) continue; if (px0 < px) { i = 0; j = px-px0; if (px+pw < px1) { /* px * |<-pw->| * +--|------|-+ * | |<====>| | * px0 px1 */ n = pw; } else { /* px * |<-pw-|--> * +--|-----+ * | |<===>| * px0 px1 */ n = px1-px; } } else { i = px0-px; j = 0; if (px+pw < px1) { /* px * |<--|-pw->| * +-----|-+ * |<===>| | * px0 px1 */ n = px+pw-px0; } else { /* px * |<--|-pw-|-->| * +----+ * |<==>| * px0 px1 */ n = blk_size; } } n *= sizeof(RGBAPixel); if (memcmp(&dst[j], &src[i], n)) { *blk = 1; changed = 1; } memcpy(&dst[j], &src[i], n); } if (changed) { changes++; } } } return PyInt_FromLong(changes); }