Bool rfbIsCongested(rfbClientPtr cl) { int offset; time_t sockIdleTime; if (!cl->enableFence) return FALSE; sockIdleTime = msSince(&cl->lastWrite); /* Idle for too long? (and no data on the wire) FIXME: This should really just be one baseRTT, but we're getting problems with triggering the idle timeout on each update. Maybe we need to use a moving average for the wire latency instead of baseRTT. */ if ((cl->sentOffset == cl->ackedOffset) && (sockIdleTime > 2 * cl->baseRTT)) { #ifdef CONGESTION_DEBUG if (cl->congWindow > INITIAL_WINDOW) rfbLog("Reverting to initial window (%d KB) after %d ms\n", INITIAL_WINDOW / 1024, sockIdleTime); #endif /* Close congestion window and allow a transfer FIXME: Reset baseRTT like Linux Vegas? */ cl->congWindow = min(INITIAL_WINDOW, cl->congWindow); return FALSE; } offset = cl->sockOffset; /* FIXME: Should we compensate for non-update data? (i.e. use sentOffset instead of offset) */ if ((offset - cl->ackedOffset) < cl->congWindow) return FALSE; /* If we just have one outstanding "ping", then that means the client has started receiving our update. In order to provide backward compatibility with viewers that don't support the flow control extensions, we allow another update here. This could further clog up the tubes, but if we reach this point, congestion control isn't really working properly anyhow, as the wire would otherwise be idle for at least RTT/2. */ if (cl->pingCounter == 1) return FALSE; return TRUE; }
void rgbPoll() { if (_error) { LED_ON(PIN_R); return; } _pollCounter += 1; if (msSince(_lastms) > MS_PER_UNIT_DURATION) { _lastms = _elapsedTime.ms; _duration -= 1; _r = adjIntensity(_r, _dr); _g = adjIntensity(_g, _dg); _b = adjIntensity(_b, _db); } pwm(_pollCounter, _r, PIN_R); pwm(_pollCounter, _g, PIN_G); pwm(_pollCounter, _b, PIN_B); if (_duration == 0) { // first set ourselves to the value the control block specified, since we // probably didn't hit it due to founding errors. ControlBlock *cb = ctrBlockCurrent(); copyColors(cb); cb = ctrBlockNext(); _duration = cb->duration; if (_duration) { _dr = calcColorDelta(_r, cb->r, _duration); _dg = calcColorDelta(_g, cb->g, _duration); _db = calcColorDelta(_b, cb->b, _duration); if (_dr == 0) _r = (cb->r+_r)/2; if (_dg == 0) _g = (cb->g+_g)/2; if (_db == 0) _b = (cb->b+_b)/2; } else copyColors(cb); } }
static void HandleRTTPong(rfbClientPtr cl, RTTInfo *rttInfo) { unsigned rtt, delay; cl->pingCounter--; rtt = msSince(&rttInfo->tv); if (rtt < 1) rtt = 1; cl->ackedOffset = rttInfo->offset; /* Try to estimate wire latency by tracking lowest latency seen */ if (rtt < cl->baseRTT) cl->baseRTT = rtt; if (rttInfo->inFlight > cl->congWindow) { cl->seenCongestion = TRUE; /* Estimate added delay because of overtaxed buffers */ delay = (rttInfo->inFlight - cl->congWindow) * cl->baseRTT / cl->congWindow; if (delay < rtt) rtt -= delay; else rtt = 1; /* If we underestimate the congestion window, then we'll get a latency that's less than the wire latency, which will confuse other portions of the code. */ if (rtt < cl->baseRTT) rtt = cl->baseRTT; } /* We only keep track of the minimum latency seen (for a given interval) because we want to avoid issuing buffers continously, but we don't mind (and even approve of) bursts. */ if (rtt < cl->minRTT) cl->minRTT = rtt; }
void gameloop() { srand( time(NULL)); root = (struct node *) malloc(sizeof(struct node)); body = (struct node *) malloc(sizeof(struct node)); tail = (struct node *) malloc(sizeof(struct node)); head = (struct node *) malloc(sizeof(struct node)); temp = (struct node *) malloc(sizeof(struct node)); apple = (struct node *) malloc(sizeof(struct node)); int h = 5; int x = 100; int y = 120; root->x = 160; root->y = 120; body->x = 154; body->y = 120; tail->x = 0; tail->y = 0; head->x = 0; head->y = 0; // apple->x = 130; // apple ->y = 120; tail->next = root; head->next = body; root->next = body; bool go = true; int moving = 1; drawRect(0,0,320, 240, &white); drawRect(4,6, 306, 228, &black); drawRect(root->x, root->y, h, h, &green); drawRect(body->x, body->y, h, h, &green); drawApple(tail); struct timespec lastTime; clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &lastTime); //while (nanosleep(&sleeptime, &sleeptime) && errno == EINTR); getGpio(); while(go){ while (msSince(lastTime)<50); clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &lastTime); head->next->next = (struct node *) malloc(sizeof(struct node)); if (direction == 5){ break; } if(direction != moving+2 && direction != moving-2 && direction != moving){ if (direction != 0){ moving = direction; } } if (moving == 1){ head->next->next->x = head->next->x-6; head->next->next->y = head->next->y; } else if(moving == 2){ head->next->next->x = head->next->x; head->next->next->y = head->next->y-6; } else if(moving == 3){ head->next->next->x = head->next->x+6; head->next->next->y = head->next->y; } else if(moving == 4){ head->next->next->x = head->next->x; head->next->next->y = head->next->y+6; } if (checkScreen(head->next->next->x, head->next->next->y) == green) { printf("You f****n wanku55\n"); break; } head->next = head->next->next; drawRect(head->next->x, head->next->y, h, h, &green); if(head->next->x >=308 || head->next->y >=235 || head->next->x <= 2 || head->next->y <= 5){ printf("you f*****g wankuh\n"); break; } if(head->next->x != apple->x || head->next->y != apple->y){ drawRect(tail->next->x, tail->next->y, h, h, &black); temp = tail->next->next; free(tail->next); tail->next = temp; } else{ drawApple(tail); } } }