int SelectHeaviestSequence( CStudioHdr *pstudiohdr, int activity ) { if ( !pstudiohdr ) return 0; VerifySequenceIndex( pstudiohdr ); int maxweight = 0; int seq = ACTIVITY_NOT_AVAILABLE; int weight = 0; for (int i = 0; i < pstudiohdr->GetNumSeq(); i++) { int curActivity = GetSequenceActivity( pstudiohdr, i, &weight ); if (curActivity == activity) { if ( iabs(weight) > maxweight ) { maxweight = iabs(weight); seq = i; } } } return seq; }
void w3j(mpf_t w, long j1, long j2, long j3, long m1, long m2, long m3) { mpq_t delta_sq,r; mpz_t i; mpf_t h; mpq_init(delta_sq); mpq_init(r); mpz_init(i); mpf_init(h); mpq_set_si(r,0,1); if(m1+m2+m3!=0) return; if((iabs(m1)>j1) || (iabs(m2)>j2) || (iabs(m3)>j3)) return; if((j3<iabs(j1-j2)) || ((j1+j2)<j3)) return; w3j_Delta_sq(delta_sq, j1, j2, j3); w3j_intterm(i, j1, j2, j3, m1, m2, m3); if(iabs(j1-j2-m3)%2 == 1) mpz_neg(i,i); w3j_sqrt_sq(r, j1, j2, j3, m1, m2, m3); mpq_mul(r,r,delta_sq); mpf_set_q(w,r); mpf_sqrt(w,w); mpf_set_z(h,i); mpf_mul(w,w,h); mpf_clear(h); mpz_clear(i); mpq_clear(r); mpq_clear(delta_sq); }
void CalculateSumOfSquares(void) { unsigned long GxSquare, GySquare, GzSquare; long temp; // Calculate The Total Force // GForce = sqrt(x**2 + y**2 + z**2) // First set them all positive. Sum of three 15 bits square won't overflow 32 bits unsigned // iabs ~9us GxSquare = (unsigned long) iabs( CurrentData.Gx); GySquare = (unsigned long) iabs(CurrentData.Gy); GzSquare = (unsigned long) iabs(CurrentData.Gz); GxSquare *= GxSquare; GySquare *= GySquare; GzSquare *= GzSquare; CurrentData.SumSquare = GxSquare + GySquare + GzSquare; if(CurrentData.SumSquare > PeakData.SumSquare) PeakData = CurrentData; }
void ui::line(int x0, int y0, int x1, int y1, unsigned char color) { if(y0==y1) { if(!correct(x0, y0, x1, y1, clipping)) return; rmset(ptr(x0, y0), color, x1-x0+1); } else if(x0==x1) { if(!correct(x0, y0, x1, y1, clipping)) return; linev(ptr(x0, y0), scanline, y1-y0+1, color); } else { int dx = iabs(x1-x0), sx = x0<x1 ? 1 : -1; int dy = -iabs(y1-y0), sy = y0<y1 ? 1 : -1; int err = dx+dy, e2; for(;;) { pixel(x0, y0, color); if(x0==x1 && y0==y1) break; e2 = 2*err; if(e2 >= dy) { err += dy; x0 += sx; } if(e2 <= dx) { err += dx; y0 += sy; } } } }
int isqrt(int n){ int sign = signOf(n); n = iabs(n); int cur = n, next = (n+1)/2; while(iabs(next-cur) > 1){ cur = next; next = (cur + n/cur)/2; } return sign*next; }
char FindCrash(void) { // if all absolute acceleration axis are bigger than 1.5 G this is a hit // 1.5 G is equivalent to 1.5 * 32768/16 => 3072 const short OneAndHalfG = 3072; if((iabs(CurrentData.Gx) > OneAndHalfG) || (iabs(CurrentData.Gy) > OneAndHalfG) || (iabs(CurrentData.Gz) > OneAndHalfG)) return 1; return 0; }
static void LogPyramid(int PyramidIndex, const TanPile &Pile, FamData *Fam) { Log("\n"); Log("Pyramid %d\n", PyramidIndex); Log( " Label QStart1 QEnd1 TStart1 TEnd1 QStart1 QEnd1 TStart1 TEnd1 Diag Start End\n"); Log( "---------- -------- -------- -------- -------- -------- -------- -------- -------- ------ ------ ------\n"); for (PtrFamData q1 = Fam->begin(); q1 != Fam->end(); ++q1) { FamMemberData &FamMember1 = *q1; int HitIndex1 = FamMember1.PileIndex; if (HitIndex1 < 0 || HitIndex1 >= Pile.HitCount) Quit("Hit index out of range"); const HitData &Hit1 = Pile.Hits[HitIndex1]; int Diag1Start = Hit1.TargetFrom - Hit1.QueryFrom; int Diag1End = Hit1.TargetTo - Hit1.QueryTo; int Diag1 = (Diag1Start + Diag1End)/2; PtrFamData q2 = q1; for (++q2; q2 != Fam->end(); ++q2) { FamMemberData &FamMember2 = *q2; int HitIndex2 = FamMember2.PileIndex; if (HitIndex2 < 0 || HitIndex2 >= Pile.HitCount) Quit("Hit index out of range"); const HitData &Hit2 = Pile.Hits[HitIndex2]; int Diag2Start = Hit2.TargetFrom - Hit2.QueryFrom; int Diag2End = Hit2.TargetTo - Hit2.QueryTo; int Diag2 = (Diag2Start + Diag2End)/2; int DiagDist = iabs(Diag1 - Diag2); int StartDist = iabs(Hit1.TargetFrom - Hit2.TargetFrom); int EndDist = iabs(Hit1.QueryTo - Hit2.QueryTo); Log("%10.10s %8d %8d %8d %8d %8d %8d %8d %8d %6d", Pile.Label, Hit1.QueryFrom, Hit1.QueryTo, Hit1.TargetFrom, Hit1.TargetTo, Hit2.QueryFrom, Hit2.QueryTo, Hit2.TargetFrom, Hit2.TargetTo, DiagDist); Log(" %6d", StartDist); Log(" %6d", EndDist); Log("\n"); } } }
/************************************************************************* * This function performs a coarse decomposition and determines the * min-cover. * REF: Pothen ACMTrans. on Amth Software **************************************************************************/ void MinCover_Decompose(idx_t *xadj, idx_t *adjncy, idx_t asize, idx_t bsize, idx_t *mate, idx_t *cover, idx_t *csize) { idx_t i, k; idx_t *where; idx_t card[10]; where = imalloc(bsize, "MinCover_Decompose: where"); for (i = 0; i < 10; i++) { card[i] = 0; } for (i = 0; i < asize; i++) { where[i] = SC; } for (; i < bsize; i++) { where[i] = SR; } for (i = 0; i < asize; i++) { if (mate[i] == -1) { MinCover_ColDFS(xadj, adjncy, i, mate, where, INCOL); } } for (; i < bsize; i++) { if (mate[i] == -1) { MinCover_RowDFS(xadj, adjncy, i, mate, where, INROW); } } for (i = 0; i < bsize; i++) { card[where[i]]++; } k = 0; if (iabs(card[VC] + card[SC] - card[HR]) < iabs(card[VC] - card[SR] - card[HR])) { /* S = VC+SC+HR */ /* printf("%"PRIDX" %"PRIDX" ",vc+sc, hr); */ for (i = 0; i < bsize; i++) { if (where[i] == VC || where[i] == SC || where[i] == HR) { cover[k++] = i; } } } else { /* S = VC+SR+HR */ /* printf("%"PRIDX" %"PRIDX" ",vc, hr+sr); */ for (i = 0; i < bsize; i++) { if (where[i] == VC || where[i] == SR || where[i] == HR) { cover[k++] = i; } } } *csize = k; gk_free((void **) &where, LTERM); }
char FindDrop(void) { // if all absolute acceleration axis are less than 0.5 G this is a drop // 0.5 G is equivalent to 0.5 * 32768/16 => 1024 const short HalfG = 1024; if(iabs(CurrentData.Gx) < HalfG) if(iabs(CurrentData.Gy) < HalfG) if(iabs(CurrentData.Gz) < HalfG) return 1; return 0; }
void DiagramItem::shift(QPoint & p, QPoint other, bool contains_other) const { QRect r = rect(); p = r.center(); int x = p.x(); int y = p.y(); int ox = other.x(); int oy = other.y(); if (contains_other) { // move p outside int dx = x - ox; int dy = y - oy; if ((dx == 0) && (dy == 0)) dx = 16; else if ((iabs(dx) < 3) && (iabs(dy) < 3)) { dx *= 16; dy *= 16; } do { x -= dx; y -= dy; } while (contains(x, y)); } // move p to border for (;;) { int mx = (x + ox) / 2; int my = (y + oy) / 2; if (((mx == x) || (mx == ox)) && ((my == y) || (my == oy))) { p.setX(mx); p.setY(my); return; } if (contains(mx, my) == contains_other) { ox = mx; oy = my; } else { x = mx; y = my; } } }
void FrameBuffer::bresenham(int x1, int y1, int x2, int y2, int red, int green, int blue, int line) { int Fx[] = { 1, 0, -1, 0}; int Fy[] = { 0, 1, 0, -1}; int Gx[] = { 1, -1, -1, 1}; int Gy[] = { 1, 1, -1, -1}; int dx = x2 - x1; int dy = y2 - y1; int X = dx > 0; int Y = dy > 0; int Z = (iabs(dx) - iabs(dy)) > 0; int f = F(X, Y, Z); int g = G(X, Y); int m1x = Fx[f]; int m1y = Fy[f]; int m2x = Gx[g]; int m2y = Gy[g]; int da, db; if (Z) { da = iabs(dx); db = iabs(dy); } else { da = iabs(dy); db = iabs(dx); } int D = 2 * db - da; plot(x1, y1, red, green, blue); int x = x1; int y = y1; int** oosElement = &oosMap[line]; *oosElement = (int*) malloc((iabs(y2-y1)+2)*sizeof(int)); (*oosElement)[0] = x1; while ((Z && (x != x2)) || (!Z && (y != y2))) { D = D + 2*db; if (D >= 0) { x += m2x; y += m2y; D = D - 2*da; } else { x += m1x; y += m1y; } (*oosElement)[iabs(y - y1)] = x; plot(x, y, red, green, blue); } }
/*! *********************************************************************** * \brief * Calculate SAD *********************************************************************** */ distblk distortion4x4SAD(short* diff, distblk min_dist) { int distortion = 0, k; for (k = 0; k < 16; k++) { distortion += iabs(*diff++); } return (dist_scale((distblk) distortion)); }
void draw::surface::convert(int new_bpp, color* pallette) { if(bpp == new_bpp) { bpp = iabs(new_bpp); return; } auto old_scanline = scanline; scanline = color::scanline(width, new_bpp); if(iabs(new_bpp) <= bpp) color::convert(bits, width, height, new_bpp, 0, bits, bpp, pallette, old_scanline); else { unsigned char* new_bits = (unsigned char*)rmreserve(0, (height + 1)*scanline); color::convert( new_bits, width, height, new_bpp, pallette, bits, bpp, pallette, old_scanline); rmreserve(bits, 0); bits = new_bits; } bpp = iabs(new_bpp); }
void w3j_intterm(mpz_t sum, long j1, long j2, long j3, long m1, long m2, long m3) { mpz_t term,h; mpz_init(term); mpz_init(h); long I1 = 0; if(j1-j3+m2>I1) I1=j1-j3+m2; if(j2-j3-m1>I1) I1=j2-j3-m1; long I2 = j1+j2-j3; if(j1-m1<I2) I2=j1-m1; if(j2+m2<I2) I2=j2+m2; mpz_set_ui(sum,0); long sgn=1; if(iabs(I1)%2==1) sgn=-1; for(long k=I1; k<=I2; k++) { // sum+=sgn*binomialCoefficient(j1+j2-j3,k)*binomialCoefficient(j1-j2+j3,j1-m1-k) // *binomialCoefficient(-j1+j2+j3,j2+m2-k); binomialCoefficient(term, j1+j2-j3, k); binomialCoefficient(h,j1-j2+j3,j1-m1-k); mpz_mul(term,term,h); binomialCoefficient(h,-j1+j2+j3,j2+m2-k); mpz_mul(term,term,h); mpz_mul_si(term,term,sgn); mpz_add(sum,sum,term); sgn*= -1; } mpz_clear(h); mpz_clear(term); }
/*! ************************************************************************ * \brief * Quantization process for All coefficients for a 2x2 DC block * * \par Input: * * \par Output: * ************************************************************************ */ int quant_dc2x2_normal(int (*tblock)[4], int qp, int* DCLevel, int* DCRun, int **fadjust, int levelscale, int invlevelscale, int **leveloffset, const byte (*pos_scan)[2], int is_cavlc) { static int coeff_ctr; static int *m7; static int scaled_coeff; int level, run = 0; int nonzero = FALSE; int qp_per = qp_per_matrix[qp]; int q_bits = Q_BITS + qp_per + 1; //const byte *p_scan = &pos_scan[0][0]; int* DCL = &DCLevel[0]; int* DCR = &DCRun[0]; m7 = *tblock; // Quantization for (coeff_ctr=0; coeff_ctr < 4; coeff_ctr++) { // we need to update leveloffset to a 4x1 array that would contain offset info for // every 2x2 DC position if (*m7) { scaled_coeff = iabs (*m7) * levelscale; level = (scaled_coeff + (leveloffset[0][0] << 1) ) >> q_bits; if (level != 0) { if (is_cavlc) level = imin(level, CAVLC_LEVEL_LIMIT); level = isignab(level, *m7); *m7++ = ((level * invlevelscale) << qp_per); *DCL++ = level; *DCR++ = run; run = 0; nonzero = TRUE; } else { run++; *m7++ = 0; } } else { run++; m7++; } }
static bool TooClose(const GLIX &HitGlix, const HitData &Hit1, const HitData &Hit2) { const int Hit1From = Hit1.QueryFrom; const int Hit2From = Hit2.QueryFrom; int SeqFrom1; int SeqFrom2; const char *Label1 = HitGlix.GlobalToSeq(Hit1From, &SeqFrom1); const char *Label2 = HitGlix.GlobalToSeq(Hit2From, &SeqFrom2); if (0 != strcmp(Label1, Label2)) return false; return iabs(SeqFrom2 - SeqFrom1) < MIN_DIST_EDGE; }
static bool evalmove(int row, int column) /* evaluate move */ { if (movecount == 1) return (TRUE); else if (board[row][column] == TRUE) { waddstr(msgwin, "\nYou've already been there."); return (FALSE); } else { int rdif = iabs(row - history[movecount - 1].y); int cdif = iabs(column - history[movecount - 1].x); if (!((rdif == 1) && (cdif == 2)) && !((rdif == 2) && (cdif == 1))) { waddstr(msgwin, "\nThat's not a legal knight's move."); return (FALSE); } } return (TRUE); }
void line(struct fb *dst, int x0, int y0, int x1, int y1, int cl) { int len; fixed x, y, dx, dy; len = imax(iabs(x1 - x0), iabs(y1 - y0)); if(!len) { putpixel(dst, x0, y0, cl); return; } x = itofix(x0); y = itofix(y0); dx = frac(x1 - x0, len); dy = frac(y1 - y0, len); for(; len >= 0; len--) { putpixel(dst, fixtoi(x), fixtoi(y), cl); x += dx; y += dy; } }
/*! ************************************************************************ * \brief * Quantization process for All coefficients for a 2x2 DC block * * \par Input: * * \par Output: * ************************************************************************ */ int quant_dc2x2_around(Macroblock *currMB, int **tblock, int qp, int* DCLevel, int* DCRun, LevelQuantParams *q_params_4x4, int **fadjust, const byte (*pos_scan)[2]) { QuantParameters *p_Quant = currMB->p_Vid->p_Quant; Boolean is_cavlc = (Boolean) (currMB->p_Slice->symbol_mode == CAVLC); int coeff_ctr; int *m7; int scaled_coeff; int level, run = 0; int nonzero = FALSE; int qp_per = p_Quant->qp_per_matrix[qp]; int q_bits = Q_BITS + qp_per + 1; //const byte *p_scan = &pos_scan[0][0]; int* DCL = &DCLevel[0]; int* DCR = &DCRun[0]; m7 = *tblock; // Quantization for (coeff_ctr=0; coeff_ctr < 4; ++coeff_ctr) { // we need to update q_params_4x4->OffsetComp to a 4x1 array that would contain offset info for // every 2x2 DC position if (*m7) { scaled_coeff = iabs (*m7) * q_params_4x4->ScaleComp; level = (scaled_coeff + (q_params_4x4->OffsetComp << 1) ) >> q_bits; if (level != 0) { if (is_cavlc) level = imin(level, CAVLC_LEVEL_LIMIT); level = isignab(level, *m7); *m7++ = ((level * q_params_4x4->InvScaleComp) << qp_per); *DCL++ = level; *DCR++ = run; // reset zero level counter run = 0; nonzero = TRUE; } else { ++run; *m7++ = 0; } } else { ++run; ++m7; } }
long labs(long j) { #if defined(__TCS__) return iabs((int)j); /* N.B. assumes int==long */ #else /* defined(__TCS__) */ return (j < 0) ? -j : j; #endif /* defined(__TCS__) */ }
/*! ************************************************************************ * \brief * estimate VLC for Coeff Level ************************************************************************ */ int estSyntaxElement_Level_VLCN(SyntaxElement *se, int vlc)//, DataPartition *this_dataPart) { int level = se->value1; int levabs = iabs(level) - 1; int shift = vlc - 1; int escape = (15 << shift); if (levabs < escape) { se->len = ((levabs) >> shift) + 1 + vlc; }
/*! ************************************************************************ * \brief * Quantization process for All coefficients for a 4x4 block * * \par Input: * * \par Output: * ************************************************************************ */ int quant_4x4_normal(int (*tblock)[16], int block_y, int block_x, int qp, int* ACLevel, int* ACRun, int **fadjust4x4, int **levelscale, int **invlevelscale, int **leveloffset, int *coeff_cost, const byte (*pos_scan)[2], const byte *c_cost, int is_cavlc) { static int i,j, coeff_ctr; static int *m7; static int scaled_coeff; int level, run = 0; int nonzero = FALSE; int qp_per = qp_per_matrix[qp]; int q_bits = Q_BITS + qp_per; const byte *p_scan = &pos_scan[0][0]; int* ACL = &ACLevel[0]; int* ACR = &ACRun[0]; // Quantization for (coeff_ctr = 0; coeff_ctr < 16; coeff_ctr++) { i = *p_scan++; // horizontal position j = *p_scan++; // vertical position m7 = &tblock[j][block_x + i]; if (*m7 != 0) { scaled_coeff = iabs (*m7) * levelscale[j][i]; level = (scaled_coeff + leveloffset[j][i]) >> q_bits; if (level != 0) { if (is_cavlc) level = imin(level, CAVLC_LEVEL_LIMIT); *coeff_cost += (level > 1) ? MAX_VALUE : c_cost[run]; level = isignab(level, *m7); *m7 = rshift_rnd_sf(((level * invlevelscale[j][i]) << qp_per), 4); // inverse scale can be alternative performed as follows to ensure 16bit // arithmetic is satisfied. // *m7 = (qp_per<4) ? rshift_rnd_sf((level*invlevelscale[j][i]),4-qp_per) : (level*invlevelscale[j][i])<<(qp_per-4); *ACL++ = level; *ACR++ = run; // reset zero level counter run = 0; nonzero = TRUE; } else { run++; *m7 = 0; } } else {
/*! ************************************************************************************ * \brief * calculate MAD for the current macroblock * * \return * calculated MAD * ************************************************************************************* */ int ComputeMBMAD(int diffy[16][16]) { int k, l, sum = 0; for (k = 0; k < 16; k++) for (l = 0; l < 16; l++) sum += iabs(diffy[k][l]); return sum; }
void nmethod::moveTo_inner(NCodeBase* p, int32 delta, int32 size) { nmethod* to = (nmethod*)p; if (this == to) return; if (PrintCodeCompaction) { lprintf("*moving nmethod %#lx (", this); printName(0, key.selector); lprintf(") to %#lx\n", to); } OopNCode::moveTo_inner(to, delta, size); assert(iabs((char*)to - (char*)this) >= sizeof(NCodeBase), "nmethods overlap too much"); assert(sizeof(NCodeBase) % oopSize == 0, "should be word-aligned"); // init to's vtable copy_words((int32*)this, (int32*)to, sizeof(NCodeBase) / sizeof(int32)); scopes->_nmethod_backPointer = to; *dBackLinkAddr() = to; flatProfiler->move(insts(), instsEnd(), to->insts()); zoneLink.shift(delta); FOR_MY_CODETABLE_ENTRIES(e) { e->nm= to; } for (nmln *x = linkedSends.next, *y = x->next; x != &linkedSends; x = y, y = y->next) { NCodeBase* s = findThing(x); s->shift_target(x, delta); } linkedSends.shift(delta, this); if (diLink.notEmpty()) { assert(diLink.next->next == &diLink, "diLink should be a pair"); diLink.next->asDIDesc()->shift_jump_addr(delta); } diLink.shift(delta); for (addrDesc* q = locs(), *pend = locsEnd(); q < pend; q++) { if (q->isSendDesc()) { sendDesc* sd = q->asSendDesc(this); sd->shift(delta, this); } else if (q->isDIDesc()) { nmln* l = q->asDIDesc(this)->dependency(); l->shift(delta); } q->shift(this, delta); } if (frame_chain != NoFrameChain && frame_chain != SavedFrameChain) frame_chain->nmethod_moved_by(delta, this); }
int findtorq(int btyp1, int btyp2) { int i; for (i=0; i < BENDATASIZE; i++) { if (iabs(bendata[i].b1typ) == iabs(btyp1) && iabs(bendata[i].b2typ) == iabs(btyp2)) return i; if (iabs(bendata[i].b1typ) == iabs(btyp2) && iabs(bendata[i].b2typ) == iabs(btyp1)) return i; } // fprintf(stderr, "Bend type %d-%d not found\n",btyp1,btyp2); return 0; // the default bend type }
bool TandemPair(const HitData &Hit1, const HitData &Hit2) { int Length1 = (Hit1.QueryTo - Hit1.QueryFrom + Hit1.TargetTo- Hit1.TargetFrom)/2; int Length2 = (Hit2.QueryTo - Hit2.QueryFrom + Hit2.TargetTo - Hit2.TargetFrom)/2; int ShorterLength = min(Length1, Length2); int LongerLength = max(Length1, Length2); if ((double) ShorterLength / (double) LongerLength < MIN_RATIO) return false; int StartDist = iabs(Hit1.TargetFrom - Hit2.TargetFrom); int EndDist = iabs(Hit1.QueryTo - Hit2.QueryTo); double StartMargin = (double) StartDist / (double) ShorterLength; double EndMargin = (double) EndDist / (double) ShorterLength; return StartMargin <= MAX_FRACT_MARGIN && EndMargin <= MAX_FRACT_MARGIN; }
int SelectWeightedSequence( CStudioHdr *pstudiohdr, int activity, int curSequence ) { VPROF( "SelectWeightedSequence" ); if (! pstudiohdr) return 0; if (!pstudiohdr->SequencesAvailable()) return 0; VerifySequenceIndex( pstudiohdr ); #if STUDIO_SEQUENCE_ACTIVITY_LOOKUPS_ARE_SLOW int weighttotal = 0; int seq = ACTIVITY_NOT_AVAILABLE; int weight = 0; for (int i = 0; i < pstudiohdr->GetNumSeq(); i++) { int curActivity = GetSequenceActivity( pstudiohdr, i, &weight ); if (curActivity == activity) { if ( curSequence == i && weight < 0 ) { seq = i; break; } weighttotal += iabs(weight); int randomValue; if ( IsInPrediction() ) randomValue = SharedRandomInt( "SelectWeightedSequence", 0, weighttotal - 1, i ); else randomValue = RandomInt( 0, weighttotal - 1 ); if (!weighttotal || randomValue < iabs(weight)) seq = i; } } return seq; #else return pstudiohdr->SelectWeightedSequence( activity, curSequence ); #endif }
/*! *********************************************************************** * \brief * Calculate SAD for 8x8 *********************************************************************** */ distblk distortion8x8SAD(short* diff, distblk min_dist) { int distortion = 0; int k; for (k = 0; k < 64; k++) { distortion += iabs(*diff++); } return (dist_scale((distblk) distortion)); }
static void add1link(int n, int **grid, int nnodes, BOOL **adj) { int from, to; int x, y; int dx, dy; for(;;) { x = (int)nrand48(xsubi)%n; y = (int)nrand48(xsubi)%n; if(grid[x][y] == UNKNOWN) continue; from = grid[x][y]; if(NP[from].nlinks == MAXDEGREE) continue; do { dx = ((int)nrand48(xsubi)%3)-1; /* dx: -1, 0, +1 */ dy = ((int)nrand48(xsubi)%3)-1; /* dy: -1, 0, +1 */ } #if RANDOM_DIAGONALS while(dx == 0 && dy == 0); #else while(iabs(dx) == iabs(dy)); #endif x += dx; y += dy; while(x>=0 && x<n && y>=0 && y<n) { if(grid[x][y] != UNKNOWN) { to = grid[x][y]; if(NP[to].nlinks == MAXDEGREE || adj[from][to] == TRUE) break; add_link(LT_POINT2POINT, from, to, NULL); adj[from][to] = adj[to][from] = TRUE; return; } x += dx; y += dy; } } }
/*! ************************************************************************ * \brief * 2x2 transform of chroma DC * \par Input: * level and run for coefficients * \par Output: * length and info * \note * see ITU document for bit assignment ************************************************************************ */ void levrun_linfo_c2x2(int level,int run,int *len,int *info) { static const byte NTAB[2][2]= { {1,5}, {3,0} }; static const byte LEVRUN[4]= { 2,1,0,0 }; if (level == 0) // check if the coefficient sign EOB (level=0) { *len=1; return; } else { int levabs = iabs(level); int sign = level <= 0 ? 1 : 0; int n = (levabs <= LEVRUN[run]) ? NTAB[levabs - 1][run] + 1 : (levabs - LEVRUN[run]) * 8 + run * 2; int nn = n >> 1; int i; for (i=0; i < 16 && nn != 0; i++) { nn >>= 1; } *len = (i << 1) + 1; *info = n - (1 << i) + sign; } }