bool IntRect::intersects(const IntRect& other) const {
// Checking emptiness handles negative widths as well as zero.
return !isEmpty() && !other.isEmpty() && x() < other.maxX() &&
other.x() < maxX() && y() < other.maxY() && other.y() < maxY();
}
void ProcessorGraphicsItem::saveMeta() {
PositionMetaData* meta = new PositionMetaData(static_cast<int>(x()), static_cast<int>(y()));
processor_->getMetaDataContainer().addMetaData("ProcessorGraphicsItem", meta);
}
void sLinsysRootAug::solveWithBiCGStab( sData *prob, SimpleVector& b)
{
int n = b.length();
const int maxit=500;
const double tol=1e-12, EPS=2e-16;
double iter=0.0;
int myRank; MPI_Comm_rank(mpiComm, &myRank);
SimpleVector r(n); //residual
SimpleVector s(n); //residual associated with half iterate
SimpleVector rt(n); //shadow residual
SimpleVector xmin(n); //minimal residual iterate
SimpleVector x(n); //iterate
SimpleVector xhalf(n); // half iterate of BiCG
SimpleVector p(n),paux(n);
SimpleVector v(n), t(n);
int flag; double imin;
double n2b; //norm of b
double normr, normrmin; //norm of the residual and norm of residual at min-resid iterate
double normr_act;
double tolb; //relative tolerance
double rho, omega, alpha;
int stag, maxmsteps, maxstagsteps, moresteps;
double relres;
//maxit = n/2+1;
//////////////////////////////////////////////////////////////////
// Problem Setup and intialization
//////////////////////////////////////////////////////////////////
n2b = b.twonorm();
tolb = n2b*tol;
#ifdef TIMING
taux = MPI_Wtime();
#endif
//initial guess
x.copyFrom(b);
solver->Dsolve(x);
//initial residual
r.copyFrom(b);
#ifdef TIMING
troot_total += (MPI_Wtime()-taux);
taux = MPI_Wtime();
#endif
//applyA(1.0, r, -1.0, x);
SCmult(1.0,r, -1.0,x, prob);
#ifdef TIMING
tchild_total += (MPI_Wtime()-taux);
#endif
normr=r.twonorm();
#ifdef TIMING
if(myRank==0)
cout << "BiCG: initial rel resid: " << normr/n2b << endl;
#endif
if(normr<tolb) {
//initial guess is good enough
b.copyFrom(x); flag=0; return;
}
rt.copyFrom(r); //Shadow residual
double* resvec = new double[2*maxit+1];
resvec[0] = normr; normrmin=normr;
rho=1.0; omega=1.0;
stag=0; maxmsteps=min(min(n/50, 5), n-maxit);
maxstagsteps=3; moresteps=0;
//////////////////////////////////////////////////////////////////
// loop over maxit iterations
//////////////////////////////////////////////////////////////////
int ii=0; while(ii<maxit) {
//cout << ii << " ";
flag=-1;
///////////////////////////////
// First half of the iterate
///////////////////////////////
double rho1=rho; double beta;
rho = rt.dotProductWith(r);
//printf("rho=%g\n", rho);
if(0.0==rho) { flag=4; break; }
if(ii==0) p.copyFrom(r);
else {
beta = (rho/rho1)*(alpha/omega);
if(beta==0.0) { flag=4; break; }
//-------- p = r + beta*(p - omega*v) --------
p.axpy(-omega, v); p.scale(beta); p.axpy(1.0, r);
}
#ifdef TIMING
taux = MPI_Wtime();
#endif
//------ v = A*(M2inv*(M1inv*p)) and ph=M2inv*(M1inv*p)
//first use v as temp storage
//applyM1(0.0, v, 1.0, p);
//applyM2(0.0, paux, 1.0, v);
//applyA (0.0, v, 1.0, paux);
paux.copyFrom(p);
solver->solve(paux);
#ifdef TIMING
troot_total += (MPI_Wtime()-taux);
#endif
SCmult(0.0,v, 1.0,paux, prob);
SimpleVector& ph = paux;
double rtv = rt.dotProductWith(v);
if(rtv==0.0) { flag=4; break; }
alpha = rho/rtv;
if(fabs(alpha)*ph.twonorm()<EPS*x.twonorm()) stag++;
else stag=0;
// xhalf = x + alpha*ph and the associated residual
xhalf.copyFrom(x); xhalf.axpy( alpha, ph);
s. copyFrom(r); s.axpy(-alpha, v);
normr = s.twonorm(); normr_act = normr;
resvec[2*ii] = normr;
//printf("iter %g normr=%g\n", ii+0.5, normr);
//-------- check for convergence in the middle of the iterate. --------
if(normr<=tolb || stag>=maxstagsteps || moresteps) {
s.copyFrom(b);
//applyA(1.0, s, -1.0, xhalf); // s=b-Ax
SCmult(1.0,s, -1.0,xhalf, prob);
normr_act = s.twonorm();
if(normr<=tolb) {
//converged
x.copyFrom(xhalf);
flag = 0; iter = 0.5+ii;
break;
} else {
if(stag>=maxstagsteps && moresteps==0) {
stag=0;
}
moresteps++;
if(moresteps>=maxmsteps) {
//method stagnated
flag=3; x.copyFrom(xhalf);
break;
}
}
}
if(stag>=maxstagsteps) { flag=3; break;} //stagnation
//update quantities related to minimal norm iterate
if(normr_act<normrmin) {
xmin.copyFrom(xhalf); normrmin=normr_act;
imin=0.5+ii;
}
#ifdef TIMING
taux = MPI_Wtime();
#endif
///////////////////////////////
// Second half of the iterate
//////////////////////////////
//applyM1(0.0, t, 1.0, s); //applyM1(s, stemp);
//applyM2(0.0, paux, 1.0, t); //applyM2(stemp, sh);
//applyA (0.0, t, 1.0, paux); //applyA (sh, t);
//kkt->mult(0.0,paux, 1.0,s);
paux.copyFrom(s);
solver->solve(paux);
#ifdef TIMING
troot_total += (MPI_Wtime()-taux);
#endif
SCmult(0.0,t, 1.0,paux, prob);
SimpleVector& sh = paux;
double tt = t.dotProductWith(t);
if(tt==0.0) { flag=4; break;}
omega=t.dotProductWith(s); omega /= tt;
if(fabs(omega)*sh.twonorm() < EPS*xhalf.twonorm()) stag++;
else stag=0;
x.copyFrom(xhalf); x.axpy( omega, sh); // x=xhalf+omega*sh
r.copyFrom(s); r.axpy(-omega, t ); // r=s-omega*t
normr = r.twonorm(); normr_act = normr;
resvec[2*ii+1] = normr;
//printf("stag=%d maxstagsteps=%d moresteps=%d normr=%g\n",
// stag, maxstagsteps, moresteps, normr);
//-------- check for convergence at the end of the iterate. --------
if(normr<=tolb || stag>=maxstagsteps || moresteps) {
r.copyFrom(b);
//applyA(1.0, r, -1.0, x); //r=b-Ax
SCmult(1.0,r, -1.0,x, prob);
normr_act=r.twonorm();
if(normr<=tolb) { flag = 0; iter = 1.0+ii; break; }
else {
if(stag>=maxstagsteps && moresteps==0) {
stag = 0;
}
moresteps++;
if(moresteps>=maxmsteps) {
//method stagnated
flag=3; break;
}
}
} // end convergence check
if(stag>=maxstagsteps) { flag=3; break;} //stagnation
//update quantities related to minimal norm iterate
if(normr_act<normrmin) {
xmin.copyFrom(x); normrmin=normr_act;
imin=1.5+ii;
}
//printf("iter %g normr=%g\n", ii+1.0, normr);
///////////////////////////////
// Next iterate
///////////////////////////////
ii++;
}//end while
if(ii>=maxit) {
iter=ii;
flag=10;
}
if(flag==0 || flag==-1) {
relres = normr_act/n2b;
#ifdef TIMING
if(myRank==0) {
printf("BiCGStab converged: normResid=%g relResid=%g iter=%g\n",
normr_act, relres, iter);
}
#endif
} else {
if(ii==maxit) flag=10;//aaa
//FAILURE -> return minimum resid-norm iterate
r.copyFrom(b);
//applyA(1.0, r, -1.0, xmin);
SCmult(1.0,r, -1.0,xmin, prob);
normr=r.twonorm();
if(normr >= normr_act) {
x.copyFrom(xmin);
//iter=imin;
relres=normr/n2b;
} else {
iter=1.0+ii;
relres = normr/n2b;
}
#ifdef TIMING
if(myRank==0) {
printf("BiCGStab did not NOT converged after %g[%d] iterations.\n", iter,ii);
printf("\t - Error code %d\n\t - Act res=%g\n\t - Rel res=%g %g\n\n",
flag, normr, relres, normrmin);
}
#endif
}
b.copyFrom(x);
delete[] resvec;
}
Quaternion Quaternion::operator*(const float c) const {
return Quaternion(x() * c, y() * c, z() * c, w() * c);
}
HeapWord* GenCollectorPolicy::satisfy_failed_allocation(size_t size,
bool is_tlab) {
GenCollectedHeap *gch = GenCollectedHeap::heap();
GCCauseSetter x(gch, GCCause::_allocation_failure);
HeapWord* result = NULL;
assert(size != 0, "Precondition violated");
if (GC_locker::is_active_and_needs_gc()) {
// GC locker is active; instead of a collection we will attempt
// to expand the heap, if there's room for expansion.
if (!gch->is_maximal_no_gc()) {
result = expand_heap_and_allocate(size, is_tlab);
}
return result; // could be null if we are out of space
} else if (!gch->incremental_collection_will_fail()) {
// The gc_prologues have not executed yet. The value
// for incremental_collection_will_fail() is the remanent
// of the last collection.
// Do an incremental collection.
gch->do_collection(false /* full */,
false /* clear_all_soft_refs */,
size /* size */,
is_tlab /* is_tlab */,
number_of_generations() - 1 /* max_level */);
} else {
// Try a full collection; see delta for bug id 6266275
// for the original code and why this has been simplified
// with from-space allocation criteria modified and
// such allocation moved out of the safepoint path.
gch->do_collection(true /* full */,
false /* clear_all_soft_refs */,
size /* size */,
is_tlab /* is_tlab */,
number_of_generations() - 1 /* max_level */);
}
result = gch->attempt_allocation(size, is_tlab, false /*first_only*/);
if (result != NULL) {
assert(gch->is_in_reserved(result), "result not in heap");
return result;
}
// OK, collection failed, try expansion.
result = expand_heap_and_allocate(size, is_tlab);
if (result != NULL) {
return result;
}
// If we reach this point, we're really out of memory. Try every trick
// we can to reclaim memory. Force collection of soft references. Force
// a complete compaction of the heap. Any additional methods for finding
// free memory should be here, especially if they are expensive. If this
// attempt fails, an OOM exception will be thrown.
{
IntFlagSetting flag_change(MarkSweepAlwaysCompactCount, 1); // Make sure the heap is fully compacted
gch->do_collection(true /* full */,
true /* clear_all_soft_refs */,
size /* size */,
is_tlab /* is_tlab */,
number_of_generations() - 1 /* max_level */);
}
result = gch->attempt_allocation(size, is_tlab, false /* first_only */);
if (result != NULL) {
assert(gch->is_in_reserved(result), "result not in heap");
return result;
}
// What else? We might try synchronous finalization later. If the total
// space available is large enough for the allocation, then a more
// complete compaction phase than we've tried so far might be
// appropriate.
return NULL;
}
bool SolverSLAM2DLinear::solveOrientation()
{
assert(_optimizer->indexMapping().size() + 1 == _optimizer->vertices().size() && "Needs to operate on full graph");
assert(_optimizer->vertex(0)->fixed() && "Graph is not fixed by vertex 0");
VectorXD b, x; // will be used for theta and x/y update
b.setZero(_optimizer->indexMapping().size());
x.setZero(_optimizer->indexMapping().size());
typedef Eigen::Matrix<double, 1, 1, Eigen::ColMajor> ScalarMatrix;
ScopedArray<int> blockIndeces(new int[_optimizer->indexMapping().size()]);
for (size_t i = 0; i < _optimizer->indexMapping().size(); ++i)
blockIndeces[i] = i+1;
SparseBlockMatrix<ScalarMatrix> H(blockIndeces.get(), blockIndeces.get(), _optimizer->indexMapping().size(), _optimizer->indexMapping().size());
// building the structure, diagonal for each active vertex
for (size_t i = 0; i < _optimizer->indexMapping().size(); ++i) {
OptimizableGraph::Vertex* v = _optimizer->indexMapping()[i];
int poseIdx = v->hessianIndex();
ScalarMatrix* m = H.block(poseIdx, poseIdx, true);
m->setZero();
}
HyperGraph::VertexSet fixedSet;
// off diagonal for each edge
for (SparseOptimizer::EdgeContainer::const_iterator it = _optimizer->activeEdges().begin(); it != _optimizer->activeEdges().end(); ++it) {
# ifndef NDEBUG
EdgeSE2* e = dynamic_cast<EdgeSE2*>(*it);
assert(e && "Active edges contain non-odometry edge"); //
# else
EdgeSE2* e = static_cast<EdgeSE2*>(*it);
# endif
OptimizableGraph::Vertex* from = static_cast<OptimizableGraph::Vertex*>(e->vertices()[0]);
OptimizableGraph::Vertex* to = static_cast<OptimizableGraph::Vertex*>(e->vertices()[1]);
int ind1 = from->hessianIndex();
int ind2 = to->hessianIndex();
if (ind1 == -1 || ind2 == -1) {
if (ind1 == -1) fixedSet.insert(from); // collect the fixed vertices
if (ind2 == -1) fixedSet.insert(to);
continue;
}
bool transposedBlock = ind1 > ind2;
if (transposedBlock){ // make sure, we allocate the upper triangle block
std::swap(ind1, ind2);
}
ScalarMatrix* m = H.block(ind1, ind2, true);
m->setZero();
}
// walk along the Minimal Spanning Tree to compute the guess for the robot orientation
assert(fixedSet.size() == 1);
VertexSE2* root = static_cast<VertexSE2*>(*fixedSet.begin());
VectorXD thetaGuess;
thetaGuess.setZero(_optimizer->indexMapping().size());
UniformCostFunction uniformCost;
HyperDijkstra hyperDijkstra(_optimizer);
hyperDijkstra.shortestPaths(root, &uniformCost);
HyperDijkstra::computeTree(hyperDijkstra.adjacencyMap());
ThetaTreeAction thetaTreeAction(thetaGuess.data());
HyperDijkstra::visitAdjacencyMap(hyperDijkstra.adjacencyMap(), &thetaTreeAction);
// construct for the orientation
for (SparseOptimizer::EdgeContainer::const_iterator it = _optimizer->activeEdges().begin(); it != _optimizer->activeEdges().end(); ++it) {
EdgeSE2* e = static_cast<EdgeSE2*>(*it);
VertexSE2* from = static_cast<VertexSE2*>(e->vertices()[0]);
VertexSE2* to = static_cast<VertexSE2*>(e->vertices()[1]);
double omega = e->information()(2,2);
double fromThetaGuess = from->hessianIndex() < 0 ? 0. : thetaGuess[from->hessianIndex()];
double toThetaGuess = to->hessianIndex() < 0 ? 0. : thetaGuess[to->hessianIndex()];
double error = normalize_theta(-e->measurement().rotation().angle() + toThetaGuess - fromThetaGuess);
bool fromNotFixed = !(from->fixed());
bool toNotFixed = !(to->fixed());
if (fromNotFixed || toNotFixed) {
double omega_r = - omega * error;
if (fromNotFixed) {
b(from->hessianIndex()) -= omega_r;
(*H.block(from->hessianIndex(), from->hessianIndex()))(0,0) += omega;
if (toNotFixed) {
if (from->hessianIndex() > to->hessianIndex())
(*H.block(to->hessianIndex(), from->hessianIndex()))(0,0) -= omega;
else
(*H.block(from->hessianIndex(), to->hessianIndex()))(0,0) -= omega;
}
}
if (toNotFixed ) {
b(to->hessianIndex()) += omega_r;
(*H.block(to->hessianIndex(), to->hessianIndex()))(0,0) += omega;
}
}
}
// solve orientation
typedef LinearSolverCSparse<ScalarMatrix> SystemSolver;
SystemSolver linearSystemSolver;
linearSystemSolver.init();
bool ok = linearSystemSolver.solve(H, x.data(), b.data());
if (!ok) {
cerr << __PRETTY_FUNCTION__ << "Failure while solving linear system" << endl;
return false;
}
// update the orientation of the 2D poses and set translation to 0, GN shall solve that
root->setToOrigin();
for (size_t i = 0; i < _optimizer->indexMapping().size(); ++i) {
VertexSE2* v = static_cast<VertexSE2*>(_optimizer->indexMapping()[i]);
int poseIdx = v->hessianIndex();
SE2 poseUpdate(0, 0, normalize_theta(thetaGuess(poseIdx) + x(poseIdx)));
v->setEstimate(poseUpdate);
}
return true;
}
int main()
{
std::random_device rd;
std::mt19937_64 rng(rd());
const int sawtooth = 1;
const int do_rand = 2;
const int stagger = 3;
const int plateau = 4;
const int shuffle = 5;
for (size_t n : {100, 1023, 1024, 1025, (2 << 16) - 1, 2 << 16, (2 << 16) + 1}) {
std::cerr << "\nSize: " << n << ": ";
for (size_t m = 1; m < 2 * n; m *= 2) {
std::cerr << m;
for (auto dist : {sawtooth, do_rand, stagger, plateau, shuffle}) {
std::cerr << ".";
std::vector<int64_t> x(n);
size_t i = 0, j = 0, k = 1;
switch (dist) {
case sawtooth:
for (; i < n; i++) {
x[i] = i % m;
}
break;
case do_rand:
for (; i < n; i++) {
x[i] = rng() % m;
}
break;
case stagger:
for (; i < n; i++) {
x[i] = (i * m + i) % n;
}
break;
case plateau:
for (; i < n; i++) {
x[i] = std::min(i, m);
}
break;
case shuffle:
for (; i < n; i++) {
x[i] = rng() % m ? (j += 2) : (k += 2);
}
break;
}
Ioss::qsort(x); // Copy of x
assert(verify_sorted(x));
std::reverse(x.begin(), x.end()); // Reversed
Ioss::qsort(x);
assert(verify_sorted(x));
std::reverse(&x[0], &x[n / 2]); // Front half reversed
Ioss::qsort(x);
assert(verify_sorted(x));
std::reverse(&x[n / 2], &x[n]); // Back half reversed
Ioss::qsort(x);
assert(verify_sorted(x));
Ioss::qsort(x); // Already sorted
assert(verify_sorted(x));
for (size_t p = 0; p < n; p++) {
x[p] += p % 5;
}
Ioss::qsort(x); // Dithered
assert(verify_sorted(x));
}
}
}
std::cerr << "\nDone\n";
}
// NB : matrix is passed in Column-Major storage.
void
lod_cn_travelling_wave(double* const inout_matrix,
const int space_nb_x,
const int space_nb_y,
const double final_time,
const double tau,
const double eps)
{
double h_x = 1./((double)space_nb_x-1.), h_y = 1./((double)space_nb_y-1.);
Eigen::VectorXd x_border, y_border, x(space_nb_x), y(space_nb_y);
Eigen::MatrixXd values, after_x, after_y, after_reaction;
Eigen::SparseMatrix<double> operator_x, operator_y, laplace_x, unit_matrix_x, laplace_y, unit_matrix_y;
// Boundaries.
x_border.setLinSpaced(space_nb_x, 0., 1.);
y_border.setLinSpaced(space_nb_y, 0., 1.);
// Initial values.
initial_values(values, x_border, y_border, eps);
// Operators initialization;
laplace_operator_1d(laplace_x, space_nb_x);
identity_operator(unit_matrix_x, space_nb_x);
laplace_operator_1d(laplace_y, space_nb_y);
identity_operator(unit_matrix_y, space_nb_y);
space_operator(operator_x, laplace_x, (tau*eps)/(h_x*h_x), unit_matrix_x);
space_operator(operator_y, laplace_y, (tau*eps)/(h_y*h_y), unit_matrix_y);
#ifdef DEBUG_LOD_CN
debug_print("init values", values, 5, 5);
debug_print("laplace x", laplace_x, 5, 5);
debug_print("I x", unit_matrix_x, 5, 5);
debug_print("laplace y", laplace_y, 5, 5);
debug_print("I y", unit_matrix_y, 5, 5);
debug_print("Op x", operator_x, 5, 5);
debug_print("Op y", operator_y, 5, 5);
#endif
double time = 0.;
const double tcoeff = 1.;
while (time < final_time)
{
// Step in x direction.
// NB. Operators x and y are hermitian, so that we can commute them.
// Apply an operator in x direction.
#ifdef DEBUG_LOD_CN
debug_print("values", values, 5, 5);
#endif
after_x = values*operator_x;
bc_x(y, y_border, time, 0., eps);
after_x.col(0) = y*tcoeff;
bc_x(y, y_border, time, 1., eps);
after_x.col(space_nb_x-1) = y*tcoeff;
#ifdef DEBUG_LOD_CN
debug_print("after_x", after_x, 5, 5);
#endif
// Apply an operator in y direction.
after_y = operator_y*values;
bc_y(x, x_border, time, 0., eps);
after_y.row(0) = x.transpose()*tcoeff;
bc_y(x, x_border, time, 1., eps);
after_y.row(space_nb_y-1) = x.transpose()*tcoeff;
#ifdef DEBUG_LOD_CN
debug_print("after_y", after_y, 5, 5);
#endif
// Apply the reaction operator.
auto transform = ::boost::bind(reaction_operator, _1, tau/eps);
after_reaction = after_y+after_y.unaryExpr(transform);
#ifdef DEBUG_LOD_CN
debug_print("after_reaction", after_reaction, 5, 5);
#endif
// Time advance.
time += tau;
// Second application of an operator in y direction.
after_y = operator_y*after_reaction;
bc_y(x, x_border, time, 0., eps);
after_y.row(0) = x.transpose()*tcoeff;
bc_y(x, x_border, time, 1., eps);
after_y.row(space_nb_y-1) = x.transpose()*tcoeff;
#ifdef DEBUG_LOD_CN
debug_print("after_y", after_y, 5, 5);
#endif
// Second application of an operator in x direction.
values = after_y*operator_x;
bc_x(y, y_border, time, 0., eps);
values.col(0) = y*tcoeff;
bc_x(y, y_border, time, 1., eps);
values.col(space_nb_x-1) = y*tcoeff;
}
// Copy to the return value.
memcpy(inout_matrix, values.data(), space_nb_x*space_nb_y*sizeof(double));
}
void add(int u, int v, int cost, int cap) {
edge x(v, int(ed[v].size()), cost, cap);
edge y(u, int(ed[u].size()), -cost, 0);
ed[u].push_back(x);
ed[v].push_back(y);
}
void console_widget_t::draw()
{
if (console == NULL) {
int x_, y_, w_, h_;
fl_clip_box(x(),y(),w(),h(), x_, y_, w_, h_);
fl_color(FL_BLACK);
fl_rectf(x_, y_, w_, h_);
return;
}
fl_font(font_name, font_size);
int x_, y_, w_, h_, cx, cy;
fl_clip_box(x(), y(), w(), h(), x_, y_, w_, h_);
cx = x();
cy = y();
cx -= (fit_x - w()) / 2;
cy -= (fit_y - h()) / 2;
x_ -= cx;
y_ -= cy;
int x1 = x_ / letter_x;
int x2 = (x_ + w_) / letter_x + 1;
int y1 = y_ / letter_y;
int y2 = (y_ + h_) / letter_y + 1;
int yi = 0;
if (x_ < 0) {
fl_color(FL_BLACK);
fl_rectf(x(), y(), -x_, h_);
x1 = 0;
cx += x1 * letter_x;
}
if (y_ < 0) {
fl_color(FL_BLACK);
fl_rectf(cx, y(), fit_x, -y_);
}
if (x_ + w_ > fit_x) {
fl_color(FL_BLACK);
fl_rectf(cx + fit_x, y(), x_ + w_ - fit_x, h_);
x2 = console->config.x;
}
if (y_ + h_ > fit_y) {
fl_color(FL_BLACK);
fl_rectf(cx, cy + fit_y,
fit_x, y_ + h_ - fit_y);
}
fl_push_clip(x(), y(), w(), h());
for (yi = y1; yi < y2; yi++) {
if (yi < 0)
continue;
if (yi >= console->config.y)
break;
co_console_cell_t* row_start = &console->screen[(yi+scroll_lines) * console->config.x];
co_console_cell_t* cell;
co_console_cell_t* start;
co_console_cell_t* end;
char text_buff[0x100];
start = row_start + x1;
end = row_start + x2;
cell = start;
if (end > cell_limit) {
// co_debug("BUG: end=%p limit=%p row=%p start=%p x1=%d x2=%d y1=%d y2=%d",
// end, limit, row_start, start, x1, x2, y1, y2);
end = cell_limit; // Hack: Fix the overrun!
}
while (cell < end) {
while (cell < end && start->attr == cell->attr &&
cell - start < (int)sizeof(text_buff)) {
text_buff[cell - start] = cell->ch;
cell++;
}
FL_RGB_COLOR((start->attr >> 4) & 0xf);
fl_rectf(cx + letter_x * (start - row_start),
cy + letter_y * (yi),
(cell - start) * letter_x,
letter_y);
FL_RGB_COLOR((start->attr) & 0xf);
fl_draw(text_buff, cell - start,
cx + letter_x * (start - row_start),
cy + letter_y * (yi + 1) - fl_descent());
start = cell;
}
// The cell under the cursor
if(!scroll_lines)
{
if (cursor_blink_state && console->cursor.y == yi &&
console->cursor.x >= x1 && console->cursor.x <= x2 &&
console->cursor.height != CO_CUR_NONE) {
int cursize;
if (console->cursor.height <= CO_CUR_BLOCK &&
console->cursor.height > CO_CUR_NONE)
cursize = cursize_tab[console->cursor.height];
else
cursize = cursize_tab[CO_CUR_DEF];
fl_color(0xff, 0xff, 0xff);
fl_rectf(cx + letter_x * console->cursor.x,
cy + letter_y * console->cursor.y + letter_y - cursize,
letter_x,
cursize);
}
}
}
fl_pop_clip();
}
void RenderSVGRoot::paintReplaced(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
{
// An empty viewport disables rendering.
if (pixelSnappedBorderBoxRect().isEmpty())
return;
// Don't paint, if the context explicitely disabled it.
if (paintInfo.context->paintingDisabled())
return;
Page* page = 0;
if (Frame* frame = this->frame())
page = frame->page();
// Don't paint if we don't have kids, except if we have filters we should paint those.
if (!firstChild()) {
SVGResources* resources = SVGResourcesCache::cachedResourcesForRenderObject(this);
if (!resources || !resources->filter()) {
if (page && paintInfo.phase == PaintPhaseForeground)
page->addRelevantUnpaintedObject(this, visualOverflowRect());
return;
}
}
if (page && paintInfo.phase == PaintPhaseForeground)
page->addRelevantRepaintedObject(this, visualOverflowRect());
// Make a copy of the PaintInfo because applyTransform will modify the damage rect.
PaintInfo childPaintInfo(paintInfo);
childPaintInfo.context->save();
// Apply initial viewport clip - not affected by overflow handling
childPaintInfo.context->clip(pixelSnappedIntRect(overflowClipRect(paintOffset, paintInfo.renderRegion)));
// Convert from container offsets (html renderers) to a relative transform (svg renderers).
// Transform from our paint container's coordinate system to our local coords.
IntPoint adjustedPaintOffset = roundedIntPoint(paintOffset);
childPaintInfo.applyTransform(AffineTransform::translation(adjustedPaintOffset.x() - x(), adjustedPaintOffset.y() - y()) * localToParentTransform());
SVGRenderingContext renderingContext;
bool continueRendering = true;
if (childPaintInfo.phase == PaintPhaseForeground) {
renderingContext.prepareToRenderSVGContent(this, childPaintInfo);
continueRendering = renderingContext.isRenderingPrepared();
}
if (continueRendering)
RenderBox::paint(childPaintInfo, LayoutPoint());
childPaintInfo.context->restore();
}
void QQuickParticleEmitter::burst(int num)
{
m_burstQueue << qMakePair(num, QPointF(x(), y()));
}
void foo() {
X x(1); // { dg-error "incomplete type" }
bar(x); // { dg-error "3:'bar' was not declared" }
}
bool IntRect::contains(const IntRect& other) const {
return x() <= other.x() && maxX() >= other.maxX() && y() <= other.y() &&
maxY() >= other.maxY();
}
auto_ptr<ImageBuffer> SVGMaskElement::drawMaskerContent(const FloatRect& targetRect, FloatRect& maskDestRect) const
{
// Determine specified mask size
float xValue;
float yValue;
float widthValue;
float heightValue;
if (maskUnits() == SVGUnitTypes::SVG_UNIT_TYPE_OBJECTBOUNDINGBOX) {
xValue = x().valueAsPercentage() * targetRect.width();
yValue = y().valueAsPercentage() * targetRect.height();
widthValue = width().valueAsPercentage() * targetRect.width();
heightValue = height().valueAsPercentage() * targetRect.height();
} else {
xValue = x().value(this);
yValue = y().value(this);
widthValue = width().value(this);
heightValue = height().value(this);
}
IntSize imageSize(lroundf(widthValue), lroundf(heightValue));
clampImageBufferSizeToViewport(document()->view(), imageSize);
if (imageSize.width() < static_cast<int>(widthValue))
widthValue = imageSize.width();
if (imageSize.height() < static_cast<int>(heightValue))
heightValue = imageSize.height();
auto_ptr<ImageBuffer> maskImage = ImageBuffer::create(imageSize, false);
if (!maskImage.get())
return maskImage;
maskDestRect = FloatRect(xValue, yValue, widthValue, heightValue);
if (maskUnits() == SVGUnitTypes::SVG_UNIT_TYPE_OBJECTBOUNDINGBOX)
maskDestRect.move(targetRect.x(), targetRect.y());
GraphicsContext* maskImageContext = maskImage->context();
ASSERT(maskImageContext);
maskImageContext->save();
maskImageContext->translate(-xValue, -yValue);
if (maskContentUnits() == SVGUnitTypes::SVG_UNIT_TYPE_OBJECTBOUNDINGBOX) {
maskImageContext->save();
maskImageContext->scale(FloatSize(targetRect.width(), targetRect.height()));
}
// Render subtree into ImageBuffer
for (Node* n = firstChild(); n; n = n->nextSibling()) {
SVGElement* elem = 0;
if (n->isSVGElement())
elem = static_cast<SVGElement*>(n);
if (!elem || !elem->isStyled())
continue;
SVGStyledElement* e = static_cast<SVGStyledElement*>(elem);
RenderObject* item = e->renderer();
if (!item)
continue;
renderSubtreeToImage(maskImage.get(), item);
}
if (maskContentUnits() == SVGUnitTypes::SVG_UNIT_TYPE_OBJECTBOUNDINGBOX)
maskImageContext->restore();
maskImageContext->restore();
return maskImage;
}
void CommercialGraphic::showClock() {
clockStatus = SHOW_CLOCK;
updateClock();
if (show)
scene()->update(x() + CLOCK_X, y(), CLOCK_WIDTH, GRAPHIC_HEIGHT);
}
int foo ()
{
std::decimal::decimal64 x(0);
bar (x);
}
void ADFun<Base>::optimize(void)
{ // place to store the optimized version of the recording
recorder<Base> rec;
// number of independent variables
size_t n = ind_taddr_.size();
# ifndef NDEBUG
size_t i, j, m = dep_taddr_.size();
CppAD::vector<Base> x(n), y(m), check(m);
bool check_zero_order = taylor_per_var_ > 0;
Base max_taylor(0);
if( check_zero_order )
{ // zero order coefficients for independent vars
for(j = 0; j < n; j++)
{ CPPAD_ASSERT_UNKNOWN( play_.GetOp(j+1) == InvOp );
CPPAD_ASSERT_UNKNOWN( ind_taddr_[j] == j+1 );
x[j] = taylor_[ ind_taddr_[j] * taylor_col_dim_ + 0];
}
// zero order coefficients for dependent vars
for(i = 0; i < m; i++)
{ CPPAD_ASSERT_UNKNOWN( dep_taddr_[i] < total_num_var_ );
y[i] = taylor_[ dep_taddr_[i] * taylor_col_dim_ + 0];
}
// maximum zero order coefficient not counting BeginOp at beginning
// (which is correpsonds to uninitialized memory).
for(i = 1; i < total_num_var_; i++)
{ if( abs_geq(taylor_[i*taylor_col_dim_+0] , max_taylor) )
max_taylor = taylor_[i*taylor_col_dim_+0];
}
}
# endif
// create the optimized recording
CppAD::optimize<Base>(n, dep_taddr_, &play_, &rec);
// number of variables in the recording
total_num_var_ = rec.num_rec_var();
// now replace the recording
play_.get(rec);
// free memory allocated for sparse Jacobian calculation
// (the results are no longer valid)
for_jac_sparse_pack_.resize(0, 0);
for_jac_sparse_set_.resize(0,0);
// free old Taylor coefficient memory
taylor_.free();
taylor_per_var_ = 0;
taylor_col_dim_ = 0;
# ifndef NDEBUG
if( check_zero_order )
{
// zero order forward calculation using new operation sequence
check = Forward(0, x);
// check results
Base eps = 10. * epsilon<Base>();
for(i = 0; i < m; i++) CPPAD_ASSERT_KNOWN(
abs_geq( eps * max_taylor , check[i] - y[i] ) ,
"Error during check of f.optimize()."
);
// Erase memory that this calculation was done so NDEBUG gives
// same final state for this object (from users perspective)
taylor_per_var_ = 0;
}
# endif
}
void animation_preview_widget::handle_draw() const
{
graphics::draw_rect(rect(x(),y(),width(),height()), graphics::color(0,0,0,196));
rect image_area(x(), y(), (width()*3)/4, height() - 30);
const graphics::texture image_texture(graphics::texture::get(obj_["image"].as_string()));
if(image_texture.valid()) {
const graphics::clip_scope clipping_scope(image_area.sdl_rect());
const rect focus_area(frame_->area().x(), frame_->area().y(),
(frame_->area().w() + frame_->pad())*frame_->num_frames_per_row(),
(frame_->area().h() + frame_->pad())*(frame_->num_frames()/frame_->num_frames_per_row() + (frame_->num_frames()%frame_->num_frames_per_row() ? 1 : 0)));
GLfloat scale = 2.0;
for(int n = 0; n != abs(scale_); ++n) {
scale *= (scale_ < 0 ? 0.5 : 2.0);
}
while(image_area.w()*scale*2.0 < image_area.w() &&
image_area.h()*scale*2.0 < image_area.h()) {
scale *= 2.0;
scale_++;
update_zoom_label();
}
while(focus_area.w()*scale > image_area.w() ||
focus_area.h()*scale > image_area.h()) {
scale *= 0.5;
scale_--;
update_zoom_label();
}
const int show_width = image_area.w()/scale;
const int show_height = image_area.h()/scale;
int x1 = focus_area.x() + (focus_area.w() - show_width)/2;
int y1 = focus_area.y() + (focus_area.h() - show_height)/2;
int x2 = x1 + show_width;
int y2 = y1 + show_height;
int xpos = image_area.x();
int ypos = image_area.y();
src_rect_ = rect(x1, y1, x2 - x1, y2 - y1);
dst_rect_ = rect(xpos, ypos, (x2-x1)*scale, (y2-y1)*scale);
graphics::blit_texture(image_texture, xpos, ypos,
(x2-x1)*scale, (y2-y1)*scale, 0.0,
GLfloat(x1)/image_texture.width(),
GLfloat(y1)/image_texture.height(),
GLfloat(x2)/image_texture.width(),
GLfloat(y2)/image_texture.height());
for(int n = 0; n != frame_->num_frames(); ++n) {
const int row = n/frame_->num_frames_per_row();
const int col = n%frame_->num_frames_per_row();
const int x = xpos - x1*scale + (frame_->area().x() + col*(frame_->area().w()+frame_->pad()))*scale;
const int y = ypos - y1*scale + (frame_->area().y() + row*(frame_->area().h()+frame_->pad()))*scale;
const rect box(x, y, frame_->area().w()*scale, frame_->area().h()*scale);
graphics::draw_hollow_rect(box.sdl_rect(), n == 0 ? graphics::color_yellow() : graphics::color_white(), frame_->frame_number(cycle_) == n ? 0xFF : 0x88);
}
int mousex, mousey;
if(anchor_x_ != -1 && SDL_GetMouseState(&mousex, &mousey) &&
point_in_rect(point(mousex, mousey), dst_rect_)) {
const point p1 = mouse_point_to_image_loc(point(mousex, mousey));
const point p2 = mouse_point_to_image_loc(point(anchor_x_, anchor_y_));
int xpos1 = xpos - x1*scale + p1.x*scale;
int xpos2 = xpos - x1*scale + p2.x*scale;
int ypos1 = ypos - y1*scale + p1.y*scale;
int ypos2 = ypos - y1*scale + p2.y*scale;
if(xpos2 < xpos1) {
std::swap(xpos1, xpos2);
}
if(ypos2 < ypos1) {
std::swap(ypos1, ypos2);
}
rect area(xpos1, ypos1, xpos2 - xpos1, ypos2 - ypos1);
graphics::draw_hollow_rect(area.sdl_rect(), graphics::color_white());
}
}
rect preview_area(x() + (width()*3)/4, y(), width()/4, height());
GLfloat scale = 1.0;
while(false && (frame_->width()*scale > preview_area.w() || frame_->height()*scale > preview_area.h())) {
scale *= 0.5;
}
frame_->draw(
preview_area.x() + (preview_area.w() - frame_->width()*scale)/2,
preview_area.y() + (preview_area.h() - frame_->height()*scale)/2,
true, false, cycle_, 0, scale);
if(++cycle_ >= frame_->duration()) {
cycle_ = 0;
}
foreach(const_widget_ptr w, widgets_) {
w->draw();
}
}
IntRect::operator SkIRect() const
{
SkIRect rect = { x(), y(), maxX(), maxY() };
return rect;
}
Quaternion Quaternion::inverse() {
normalize();
return Quaternion(-x(), -y(), -z(), w());
}
IntRect::operator SkRect() const
{
SkRect rect;
rect.set(SkIntToScalar(x()), SkIntToScalar(y()), SkIntToScalar(maxX()), SkIntToScalar(maxY()));
return rect;
}
Quaternion Quaternion::operator+(const Quaternion &o) const {
return Quaternion(x() + o.x(), y() + o.y(), z() + o.z(), w() + o.w());
}
QRect MythRect::toQRect() const
{
return QRect(x(),y(),width(),height());
}
bool doigt::operator==(doigt& d) {
if(existe() == d.existe()) return true;
return d.x() == x() && d.y() == y();
}
QPoint MythPoint::toQPoint() const
{
return QPoint(x(),y());
}
void sLinsysRootAug::solveWithIterRef( sData *prob, SimpleVector& r)
{
SimpleVector r2(&r[locnx], locmy);
SimpleVector r1(&r[0], locnx);
//SimpleVector realRhs(&r[0], locnx+locmy);
#ifdef TIMING
taux=MPI_Wtime();
#endif
double rhsNorm=r.twonorm(); //r== the initial rhs of the reduced system here
int myRank; MPI_Comm_rank(mpiComm, &myRank);
SimpleVector rxy(locnx+locmy); rxy.copyFrom(r);
SimpleVector x(locnx+locmy); x.setToZero(); //solution
SimpleVector dx(locnx+locmy); //update from iter refinement
SimpleVector x_prev(locnx+locmy);
int refinSteps=0;
std::vector<double> histResid;
int maxRefinSteps=(gLackOfAccuracy>0?9:8);
do { //iterative refinement
#ifdef TIMING
taux=MPI_Wtime();
#endif
x_prev.copyFrom(x);
//dx = Ainv * r
dx.copyFrom(rxy);
solver->Dsolve(dx);
//update x
x.axpy(1.0,dx);
#ifdef TIMING
troot_total += (MPI_Wtime()-taux);
#endif
if(gLackOfAccuracy<0) break;
if(refinSteps==maxRefinSteps) break;
//////////////////////////////////////////////////////////////////////
//iterative refinement
//////////////////////////////////////////////////////////////////////
//compute residual
//if (iAmDistrib) {
//only one process substracts [ (Q+Dx0+C'*Dz0*C)*xx + A'*xy ] from r
// [ A*xx ]
if(myRank==0) {
rxy.copyFrom(r);
if(locmz>0) {
SparseSymMatrix* CtDC_sp = dynamic_cast<SparseSymMatrix*>(CtDC);
CtDC_sp->mult(1.0,&rxy[0],1, 1.0,&x[0],1);
}
SparseSymMatrix& Q = prob->getLocalQ();
Q.mult(1.0,&rxy[0],1, -1.0,&x[0],1);
SimpleVector& xDiagv = dynamic_cast<SimpleVector&>(*xDiag);
assert(xDiagv.length() == locnx);
for(int i=0; i<xDiagv.length(); i++)
rxy[i] -= xDiagv[i]*x[i];
SparseGenMatrix& A=prob->getLocalB();
A.transMult(1.0,&rxy[0],1, -1.0,&x[locnx],1);
A.mult(1.0,&rxy[locnx],1, -1.0,&x[0],1);
} else {
//other processes set r to zero since they will get this portion from process 0
rxy.setToZero();
}
#ifdef TIMING
taux=MPI_Wtime();
#endif
// now children add [0 A^T C^T ]*inv(KKT)*[0;A;C] x
SimpleVector xx(&x[0], locnx);
for(size_t it=0; it<children.size(); it++) {
children[it]->addTermToSchurResidual(prob->children[it],rxy,xx);
}
#ifdef TIMING
tchild_total += (MPI_Wtime()-taux);
#endif
//~done computing residual
#ifdef TIMING
taux=MPI_Wtime();
#endif
//all-reduce residual
if(iAmDistrib) {
dx.setToZero(); //we use dx as the recv buffer
MPI_Allreduce(rxy.elements(), dx.elements(), locnx+locmy, MPI_DOUBLE, MPI_SUM, mpiComm);
rxy.copyFrom(dx);
}
#ifdef TIMING
tcomm_total += (MPI_Wtime()-taux);
#endif
double relResNorm=rxy.twonorm()/rhsNorm;
if(relResNorm<1.0e-10) {
break;
} else {
double prevRelResNorm=1.0e10;
if(histResid.size())
prevRelResNorm=histResid[histResid.size()-1];
//check for stop, divergence or slow convergence conditions
if(relResNorm>prevRelResNorm) {
// diverging; restore iteration
if(myRank==0) {
cout << "1st stg - iter refinement diverges relResNorm=" << relResNorm
<< " before was " << prevRelResNorm << endl;
cout << "Restoring iterate." << endl;
}
x.copyFrom(x_prev);
break;
}else {
//check slow convergence for the last xxx iterates.
// xxx is 1 for now
//if(relResNorm>0.*prevRelResNorm) {
// if(myRank==0) {
// cout << "1st stg - iter refinement stuck relResNorm=" << relResNorm
// << " before was " << prevRelResNorm << endl;
// cout << "exiting refinement." << endl;
// }
// break;
//
//} else {
// //really nothing, continue
//}
}
histResid.push_back(relResNorm);
if(myRank==0)
cout << "1st stg - sol does NOT have enough accuracy (" << relResNorm << ") after "
<< refinSteps << " refinement steps" << endl;
}
refinSteps++;
}while(refinSteps<=maxRefinSteps);
#ifdef TIMING
taux = MPI_Wtime();
#endif
r1.copyFrom(x);
r2.copyFromArray(&x[locnx]);
#ifdef TIMING
troot_total += (MPI_Wtime()-taux);
#endif
}
void eDVBCIInterfaces::recheckPMTHandlers()
{
eDebugCI("recheckPMTHAndlers()");
for (PMTHandlerList::iterator it(m_pmt_handlers.begin());
it != m_pmt_handlers.end(); ++it)
{
CAID_LIST caids;
ePtr<eDVBService> service;
eServiceReferenceDVB ref;
eDVBCISlot *tmp = it->cislot;
eDVBServicePMTHandler *pmthandler = it->pmthandler;
eDVBServicePMTHandler::program p;
bool plugged_cis_exist = false;
pmthandler->getServiceReference(ref);
pmthandler->getService(service);
eDebugCI("recheck %p %s", pmthandler, ref.toString().c_str());
for (eSmartPtrList<eDVBCISlot>::iterator ci_it(m_slots.begin()); ci_it != m_slots.end(); ++ci_it)
if (ci_it->plugged && ci_it->getCAManager())
{
eDebug("Slot %d plugged", ci_it->getSlotID());
ci_it->plugged = false;
plugged_cis_exist = true;
}
// check if this pmt handler has already assigned CI(s) .. and this CI(s) are already running
if (!plugged_cis_exist)
{
while(tmp)
{
if (!tmp->running_services.empty())
break;
tmp=tmp->linked_next;
}
if (tmp) // we dont like to change tsmux for running services
{
eDebugCI("already assigned and running CI!\n");
continue;
}
}
if (!pmthandler->getProgramInfo(p))
{
int cnt=0;
std::set<eDVBServicePMTHandler::program::capid_pair> set(p.caids.begin(), p.caids.end());
for (std::set<eDVBServicePMTHandler::program::capid_pair>::reverse_iterator x(set.rbegin()); x != set.rend(); ++x, ++cnt)
caids.push_front(x->caid);
if (service && cnt)
service->m_ca = caids;
}
if (service)
caids = service->m_ca;
if (caids.empty())
continue; // unscrambled service
for (eSmartPtrList<eDVBCISlot>::iterator ci_it(m_slots.begin()); ci_it != m_slots.end(); ++ci_it)
{
eDebugCI("check Slot %d", ci_it->getSlotID());
bool useThis=false;
bool user_mapped=true;
eDVBCICAManagerSession *ca_manager = ci_it->getCAManager();
if (ca_manager)
{
int mask=0;
if (!ci_it->possible_services.empty())
{
mask |= 1;
serviceSet::iterator it = ci_it->possible_services.find(ref);
if (it != ci_it->possible_services.end())
{
eDebug("'%s' is in service list of slot %d... so use it", ref.toString().c_str(), ci_it->getSlotID());
useThis = true;
}
else // check parent
{
eServiceReferenceDVB parent_ref = ref.getParentServiceReference();
if (parent_ref)
{
it = ci_it->possible_services.find(ref);
if (it != ci_it->possible_services.end())
{
eDebug("parent '%s' of '%s' is in service list of slot %d... so use it",
parent_ref.toString().c_str(), ref.toString().c_str(), ci_it->getSlotID());
useThis = true;
}
}
}
}
if (!useThis && !ci_it->possible_providers.empty())
{
eDVBNamespace ns = ref.getDVBNamespace();
mask |= 2;
if (!service) // subservice?
{
eServiceReferenceDVB parent_ref = ref.getParentServiceReference();
eDVBDB::getInstance()->getService(parent_ref, service);
}
if (service)
{
providerSet::iterator it = ci_it->possible_providers.find(providerPair(service->m_provider_name, ns.get()));
if (it != ci_it->possible_providers.end())
{
eDebug("'%s/%08x' is in provider list of slot %d... so use it", service->m_provider_name.c_str(), ns.get(), ci_it->getSlotID());
useThis = true;
}
}
}
if (!useThis && !ci_it->possible_caids.empty())
{
mask |= 4;
for (CAID_LIST::iterator ca(caids.begin()); ca != caids.end(); ++ca)
{
caidSet::iterator it = ci_it->possible_caids.find(*ca);
if (it != ci_it->possible_caids.end())
{
eDebug("caid '%04x' is in caid list of slot %d... so use it", *ca, ci_it->getSlotID());
useThis = true;
break;
}
}
}
if (!useThis && !mask)
{
const std::vector<uint16_t> &ci_caids = ca_manager->getCAIDs();
for (CAID_LIST::iterator ca(caids.begin()); ca != caids.end(); ++ca)
{
std::vector<uint16_t>::const_iterator z =
std::lower_bound(ci_caids.begin(), ci_caids.end(), *ca);
if ( z != ci_caids.end() && *z == *ca )
{
eDebug("The CI in Slot %d has said it can handle caid %04x... so use it", ci_it->getSlotID(), *z);
useThis = true;
user_mapped = false;
break;
}
}
}
}
if (useThis)
{
// check if this CI is already assigned to this pmthandler
eDVBCISlot *tmp = it->cislot;
while(tmp)
{
if (tmp == ci_it)
break;
tmp=tmp->linked_next;
}
if (tmp) // ignore already assigned cislots...
{
eDebugCI("already assigned!");
continue;
}
eDebugCI("current slot %d usecount %d", ci_it->getSlotID(), ci_it->use_count);
if (ci_it->use_count) // check if this CI can descramble more than one service
{
bool found = false;
useThis = false;
PMTHandlerList::iterator tmp = m_pmt_handlers.begin();
while (!found && tmp != m_pmt_handlers.end())
{
eDebugCI(".");
eDVBCISlot *tmp_cislot = tmp->cislot;
while (!found && tmp_cislot)
{
eDebugCI("..");
eServiceReferenceDVB ref2;
tmp->pmthandler->getServiceReference(ref2);
if ( tmp_cislot == ci_it && it->pmthandler != tmp->pmthandler )
{
eDebugCI("check pmthandler %s for same service/tp", ref2.toString().c_str());
eDVBChannelID s1, s2;
if (ref != ref2)
{
eDebugCI("different services!");
ref.getChannelID(s1);
ref2.getChannelID(s2);
}
if (ref == ref2 || (s1 == s2 && canDescrambleMultipleServices(tmp_cislot->getSlotID())))
{
found = true;
eDebugCI("found!");
eDVBCISlot *tmpci = it->cislot = tmp->cislot;
while(tmpci)
{
++tmpci->use_count;
eDebug("(2)CISlot %d, usecount now %d", tmpci->getSlotID(), tmpci->use_count);
tmpci=tmpci->linked_next;
}
}
}
tmp_cislot=tmp_cislot->linked_next;
}
eDebugCI("...");
++tmp;
}
}
if (useThis)
{
if (ci_it->user_mapped) // we dont like to link user mapped CIs
{
eDebugCI("user mapped CI already in use... dont link!");
continue;
}
++ci_it->use_count;
eDebug("(1)CISlot %d, usecount now %d", ci_it->getSlotID(), ci_it->use_count);
data_source ci_source=CI_A;
switch(ci_it->getSlotID())
{
case 0: ci_source = CI_A; break;
case 1: ci_source = CI_B; break;
case 2: ci_source = CI_C; break;
case 3: ci_source = CI_D; break;
default:
eDebug("try to get source for CI %d!!\n", ci_it->getSlotID());
break;
}
if (!it->cislot)
{
int tunernum = -1;
eUsePtr<iDVBChannel> channel;
if (!pmthandler->getChannel(channel))
{
ePtr<iDVBFrontend> frontend;
if (!channel->getFrontend(frontend))
{
eDVBFrontend *fe = (eDVBFrontend*) &(*frontend);
tunernum = fe->getSlotID();
}
}
ASSERT(tunernum != -1);
data_source tuner_source = TUNER_A;
switch (tunernum)
{
case 0: tuner_source = TUNER_A; break;
case 1: tuner_source = TUNER_B; break;
case 2: tuner_source = TUNER_C; break;
case 3: tuner_source = TUNER_D; break;
default:
eDebug("try to get source for tuner %d!!\n", tunernum);
break;
}
ci_it->current_tuner = tunernum;
setInputSource(tunernum, ci_source);
ci_it->setSource(tuner_source);
}
else
{
ci_it->current_tuner = it->cislot->current_tuner;
ci_it->linked_next = it->cislot;
ci_it->setSource(ci_it->linked_next->current_source);
ci_it->linked_next->setSource(ci_source);
}
it->cislot = ci_it;
eDebugCI("assigned!");
gotPMT(pmthandler);
}
if (it->cislot && user_mapped) // CI assigned to this pmthandler in this run.. and user mapped? then we break here.. we dont like to link other CIs to user mapped CIs
{
eDebugCI("user mapped CI assigned... dont link CIs!");
break;
}
}
}
}
}
void mainWindow::mouseReleaseEvent(QMouseEvent *e)
{
int dx = e->globalX()-last.x();
int dy = e->globalY()-last.y();
move(x()+dx, y()+dy);
}
IntRect::operator gfx::Rect() const {
return gfx::Rect(x(), y(), width(), height());
}