/**
* Print the final statistics for the given file
*/
void print_status(const struct finfo_t *finfo, struct timeval start_time)
{
struct timeval done_time;
double elapsed_time;
int i;
if (sync_mode) {
print_sync_status(finfo, start_time);
return;
}
if (finfo->file_id == 0) {
log0(0, 0, "Group complete");
return;
}
log0(0, 0, "Transfer status:");
for (done_time = start_time, i = 0; i < destcount; i++) {
if (destlist[i].clientcnt >= 0) {
continue;
}
clog0(0, 0, "Host: %-15s Status: ", destlist[i].name);
switch (destlist[i].status) {
case DEST_MUTE:
slog0("Mute");
break;
case DEST_LOST:
slog0("Lost connection");
break;
case DEST_ABORT:
slog0("Aborted");
break;
case DEST_DONE:
if (destlist[i].comp_status == COMP_STAT_REJECTED) {
slog0("Rejected");
break;
}
if (diff_usec(finfo->deststate[i].time, done_time) > 0) {
done_time = finfo->deststate[i].time;
}
elapsed_time = (double)diff_usec(finfo->deststate[i].time,
start_time) / 1000000;
slog0("Completed time: %7.3f seconds NAKs: %d",
elapsed_time, finfo->deststate[i].naks);
break;
default:
slog0("Unknown code: %d", destlist[i].status);
break;
}
}
elapsed_time = (double)diff_usec(done_time, start_time) / 1000000;
log1(0, 0, "Total elapsed time: %.3f seconds", elapsed_time);
log1(0, 0, "Overall throughput: %.2f KB/s",
(elapsed_time != 0) ? (finfo->size / elapsed_time / 1024) : 0);
}
bool GuiTrigger::Down()
{
u32 wiibtn = GCSettings.WiimoteOrientation ? WPAD_BUTTON_LEFT : WPAD_BUTTON_DOWN;
if(((wpad->btns_d | wpad->btns_h) & (wiibtn | WPAD_CLASSIC_BUTTON_DOWN))
|| ((wupcdata.btns_d | wupcdata.btns_h) & (wiibtn | WPAD_CLASSIC_BUTTON_DOWN))
|| (pad.btns_d | pad.btns_h) & PAD_BUTTON_DOWN
|| pad.stickY < -PADCAL
|| WPAD_StickY(0) < -PADCAL
|| wupcdata.stickY < -WUPCCAL)
{
if((wpad->btns_d & (wiibtn | WPAD_CLASSIC_BUTTON_DOWN))
|| wupcdata.btns_d & (wiibtn | WPAD_CLASSIC_BUTTON_DOWN)
|| pad.btns_d & PAD_BUTTON_DOWN)
{
prev[chan] = gettime();
delay[chan] = SCROLL_DELAY_INITIAL; // reset scroll delay
return true;
}
now[chan] = gettime();
if(diff_usec(prev[chan], now[chan]) > delay[chan])
{
prev[chan] = now[chan];
if(delay[chan] == SCROLL_DELAY_INITIAL)
delay[chan] = SCROLL_DELAY_LOOP;
else if(delay[chan] > SCROLL_DELAY_DECREASE)
delay[chan] -= SCROLL_DELAY_DECREASE;
return true;
}
}
return false;
}
long long dbg_time_usec()
{
long long t = gettime();
long long d = diff_usec(dbg_t, t);
dbg_t = t;
return d;
}
/**
* Returns the current congestion control rate in bytes / second.
* As specified in RFC 4654
*/
unsigned current_cc_rate(struct group_list_t *group)
{
double p, rtt;
int i, bytes, thresh;
if (group->rtt != 0.0) {
rtt = group->rtt;
} else {
rtt = group->grtt;
}
p = loss_event_rate(group);
if (p == 0.0) {
thresh = (int)(group->grtt * 1000000 * 4);
bytes = 0;
i = group->max_txseq;
while ((i != group->start_txseq) &&
(diff_usec(group->loss_history[group->max_txseq].t,
group->loss_history[i].t) < thresh)) {
bytes += group->loss_history[i--].size;
}
return (unsigned)(2.0 * bytes / (4.0 * group->grtt));
} else {
glog5(group, "getting cc rate, p=%f, rtt=%f", p, rtt);
return (unsigned)(group->datapacketsize /
(rtt * (sqrt(p * 2.0 / 3.0) +
(12 * sqrt(p * 3.0 / 8.0) * p * (1 + (32 * p * p))))));
}
}
bool GuiTrigger::Up()
{
u32 wiibtn = WPAD_BUTTON_UP;
if((wpad->btns_d | wpad->btns_h) & (wiibtn | WPAD_CLASSIC_BUTTON_UP)
|| (pad.btns_d | pad.btns_h) & PAD_BUTTON_UP
|| pad.stickY > PADCAL
|| WPAD_StickY(0) > PADCAL)
{
if(wpad->btns_d & (wiibtn | WPAD_CLASSIC_BUTTON_UP)
|| pad.btns_d & PAD_BUTTON_UP)
{
prev[chan] = gettime();
delay[chan] = SCROLL_DELAY_INITIAL; // reset scroll delay
return true;
}
now[chan] = gettime();
if(diff_usec(prev[chan], now[chan]) > delay[chan])
{
prev[chan] = now[chan];
if(delay[chan] == SCROLL_DELAY_INITIAL)
delay[chan] = SCROLL_DELAY_LOOP;
else if(delay[chan] > SCROLL_DELAY_DECREASE)
delay[chan] -= SCROLL_DELAY_DECREASE;
return true;
}
}
return false;
}
void S9xSyncSpeed ()
{
unsigned int timediffallowed = Settings.TurboMode ? 0 : Settings.FrameTime;
while (!S9xSyncSound())
usleep(10);
uint32 skipFrms = Settings.SkipFrames;
if (Settings.TurboMode)
skipFrms = Settings.TurboSkipFrames;
now = gettime();
if (diff_usec(prev, now) > timediffallowed)
{
/* Timer has already expired */
if (IPPU.SkippedFrames < skipFrms)
{
IPPU.SkippedFrames++;
IPPU.RenderThisFrame = FALSE;
}
else
{
IPPU.SkippedFrames = 0;
IPPU.RenderThisFrame = TRUE;
}
}
else
{
/*** Ahead - so hold up ***/
while (diff_usec(prev, now) < timediffallowed)
{
now = gettime();
usleep(50);
}
IPPU.RenderThisFrame = TRUE;
IPPU.SkippedFrames = 0;
}
prev = now;
return;
}
void DoRumble(int i)
{
if(rumbleOn[i])
{
now[i] = gettime();
if(diff_usec(prev[i], now[i]) > RUMBLE_MAX)
ShutoffRumble(i, RUMBLE_COOLOFF);
}
}
static void run() {
solutions = alist_new();
gettimeofday(&startTime, NULL);
gamestate_t *gs = gamestate_new(5, coord_new(3, 2));
search(gs, alist_new());
gettimeofday(&endTime, NULL);
printf("Games played: %6ld\n", gamesPlayed);
printf("Solutions found: %6d\n", solutions->size);
printf("Time elapsed: %6ldms\n", diff_usec(startTime, endTime) / 1000);
}
void system10Frames(int rate)
{
u32 time = gettime();
u32 diff = diff_usec(lastTime, time);
// expected diff - actual diff
u32 timeOff = RATE60HZ - diff;
if(timeOff > 0 && timeOff < 100000) // we're running ahead!
usleep(timeOff); // let's take a nap
else
timeOff = 0; // timeoff was not valid
int speed = (RATE60HZ/diff)*100;
if (cartridgeType == 2) // GBA games require frameskipping
{
if (!GCSettings.gbaFrameskip)
{
systemFrameSkip = 0;
}
else
{
// consider increasing skip
if(speed < 60)
systemFrameSkip += 4;
else if(speed < 70)
systemFrameSkip += 3;
else if(speed < 80)
systemFrameSkip += 2;
else if(speed < 98)
++systemFrameSkip;
// consider decreasing skip
else if(speed > 185)
systemFrameSkip -= 3;
else if(speed > 145)
systemFrameSkip -= 2;
else if(speed > 125)
systemFrameSkip -= 1;
// correct invalid frame skip values
if(systemFrameSkip > 20)
systemFrameSkip = 20;
else if(systemFrameSkip < 0)
systemFrameSkip = 0;
}
}
lastTime = gettime();
}
void RequestRumble(int i)
{
if(CONF_GetPadMotorMode() == 0 || rumbleDisabled || i < 0) // !WiiSettings.rumble
return;
now[i] = gettime();
if(prev[i] > now[i])
return;
if(diff_usec(prev[i], now[i]) > RUMBLE_MAX)
{
rumbleOn[i] = 1;
WPAD_Rumble(i, 1); // rumble on
prev[i] = now[i];
}
}
static s32 __exi_probe(s32 nChn)
{
u64 time;
s32 ret = 1;
u32 level;
u32 val;
exibus_priv *exi = &eximap[nChn];
#ifdef _EXI_DEBUG
printf("__exi_probe(%d)\n",nChn);
#endif
_CPU_ISR_Disable(level);
val = _exiReg[nChn*5];
if(!(exi->flags&EXI_FLAG_ATTACH)) {
if(val&EXI_EXT_IRQ) {
__exi_clearirqs(nChn,0,0,1);
exi->exi_idtime = 0;
last_exi_idtime[nChn] = 0;
}
if(_exiReg[nChn*5]&EXI_EXT_BIT) {
time = gettime();
if(last_exi_idtime[nChn]==0) last_exi_idtime[nChn] = time;
if((val=diff_usec(last_exi_idtime[nChn],time)+10)<30) ret = 0;
else ret = 1;
#ifdef _EXI_DEBUG
printf("val = %u, ret = %d, last_exi_idtime[chn] = %llu\n",val,ret,last_exi_idtime[nChn]);
#endif
_CPU_ISR_Restore(level);
return ret;
} else {
exi->exi_idtime = 0;
last_exi_idtime[nChn] = 0;
_CPU_ISR_Restore(level);
return 0;
}
}
if(!(_exiReg[nChn*5]&EXI_EXT_BIT) || (_exiReg[nChn*5]&EXI_EXT_IRQ)) {
exi->exi_idtime = 0;
last_exi_idtime[nChn] = 0;
ret = 0;
}
_CPU_ISR_Restore(level);
return ret;
}
/**
* Gets the current timeout value to use for the main loop
*
* First check to see if any active groups have an expired timeout, and
* handle that timeout. Once all expired timeouts have been handled, find
* the active group with the earliest timeout and return the time until that
* timeout. If there are no active groups, return NULL.
*/
struct timeval *getrecenttimeout()
{
static struct timeval tv = {0,0};
struct timeval current_timestamp, min_timestamp;
int i, j, found_timeout, recheck, pending;
int32_t usecs;
gettimeofday(¤t_timestamp, NULL);
recheck = 1;
while (recheck) {
found_timeout = 0;
recheck = 0;
// First check group timeouts
for (i = 0; i < MAXLIST; i++) {
if (group_list[i].group_id != 0) {
if ((group_list[i].phase == PR_PHASE_REGISTERED) ||
(group_list[i].phase == PR_PHASE_READY)) {
if ((group_list[i].phase == PR_PHASE_READY) &&
(cmptimestamp(current_timestamp,
group_list[i].phase_timeout_time) >= 0)) {
send_keyinfo(i, NULL, 0);
recheck = 1;
}
if (cmptimestamp(current_timestamp,
group_list[i].phase_expire_time) >= 0) {
group_list[i].phase = PR_PHASE_RECEIVING;
check_unfinished_clients(i, 1);
}
}
if (cmptimestamp(current_timestamp,
group_list[i].timeout_time) >= 0) {
// If at least one message is pending, timeout_time is
// time to next send of the specified message.
// Otherwise it's the overall timeout.
for (pending = 0, j = 0; (j < MAX_PEND) && !pending; j++) {
if (group_list[i].pending[j].msg != 0) {
pending = 1;
}
}
if (pending) {
send_all_pending(i);
} else {
log(group_list[i].group_id, 0, "Group timed out");
group_cleanup(i);
}
recheck = 1;
}
if (!recheck && ((!found_timeout) ||
(cmptimestamp(group_list[i].timeout_time,
min_timestamp) < 0))) {
min_timestamp = group_list[i].timeout_time;
found_timeout = 1;
}
}
}
// Then check timeout for sending heartbeat
if (hbhost_count) {
if (cmptimestamp(current_timestamp, next_hb_time) >= 0) {
send_hb_request(listener, hb_hosts, hbhost_count,
&next_hb_time, hb_interval);
recheck = 1;
} else if ((!found_timeout) ||
(cmptimestamp(next_hb_time, min_timestamp) < 0)) {
min_timestamp = next_hb_time;
found_timeout = 1;
}
}
}
if (found_timeout) {
usecs = (int32_t)diff_usec(min_timestamp, current_timestamp);
tv.tv_sec = usecs / 1000000;
tv.tv_usec = usecs % 1000000;
return &tv;
} else {
return NULL;
}
}
/**
* Gets the current timeout value to use for the main loop
*
* First check to see if any active groups have an expired timeout, and
* handle that timeout. Once all expired timeouts have been handled, find
* the active group with the earliest timeout and return the time until that
* timeout. If there are no active groups, return NULL.
*/
struct timeval *getrecenttimeout()
{
static struct timeval tv = {0,0};
struct timeval current_timestamp, min_timestamp;
int i, found_timeout, done;
int32_t usecs;
gettimeofday(¤t_timestamp, NULL);
done = 0;
while (!done) {
found_timeout = 0;
done = 1;
for (i = 0; i < MAXLIST; i++) {
if (group_list[i].group_id != 0) {
if (cmptimestamp(current_timestamp,
group_list[i].timeout_time) >= 0) {
switch (group_list[i].phase) {
case PHASE_REGISTERED:
send_register(i);
break;
case PHASE_RECEIVING:
case PHASE_MIDGROUP:
log1(group_list[i].group_id, group_list[i].file_id,
"Transfer timed out");
send_abort(i, "Transfer timed out");
break;
case PHASE_COMPLETE:
send_complete(i);
break;
}
done = 0;
} else if (!found_timeout) {
min_timestamp = group_list[i].timeout_time;
found_timeout = 1;
} else if (cmptimestamp(group_list[i].timeout_time,
min_timestamp) < 0) {
min_timestamp = group_list[i].timeout_time;
}
}
}
// Check timeout for proxy key request
if (has_proxy && (proxy_key == (RSA_key_t)NULL)) {
if (cmptimestamp(current_timestamp, next_keyreq_time) >= 0) {
send_key_req();
done = 0;
} else if ((!found_timeout) ||
(cmptimestamp(next_keyreq_time, min_timestamp) < 0)) {
min_timestamp = next_keyreq_time;
found_timeout = 1;
}
}
// Check timeout for sending heartbeat
if (hbhost_count) {
if (cmptimestamp(current_timestamp, next_hb_time) >= 0) {
send_hb_request(listener, hb_hosts, hbhost_count,
&next_hb_time, hb_interval);
done = 0;
} else if ((!found_timeout) ||
(cmptimestamp(next_hb_time, min_timestamp) < 0)) {
min_timestamp = next_hb_time;
found_timeout = 1;
}
}
}
if (found_timeout) {
usecs = (int32_t)diff_usec(min_timestamp, current_timestamp);
tv.tv_sec = usecs / 1000000;
tv.tv_usec = usecs % 1000000;
return &tv;
} else {
return NULL;
}
}
/**
* Updates the group's loss history
*
* Packets older than MAXMISORDER sequence numbers don't change the loss
* history, and packets aren't considered lost unless the sequence number is
* more than MAXMISORDER sequence numbers old. Works under the assumption
* that no more than 32K packets in a row get lost.
*/
void update_loss_history(struct group_list_t *group, uint16_t txseq, int size,
int ecn)
{
uint16_t i;
int tdiff, grtt_usec;
struct timeval tvdiff;
group->loss_history[txseq].found = 1;
gettimeofday(&group->loss_history[txseq].t, NULL);
if (group->multi.ss.ss_family == AF_INET6) {
group->loss_history[txseq].size = size + 8 + 40;
} else {
group->loss_history[txseq].size = size + 8 + 20;
}
if ((int16_t)(txseq - group->max_txseq) > 0) {
glog4(group, "Got seq %d, max was %d", txseq, group->max_txseq);
grtt_usec = (int)(group->grtt * 1000000);
if (txseq < group->max_txseq) {
glog5(group, "increasing seq_wrap, txseq=%u, maxseq=%u",
txseq, group->max_txseq);
group->seq_wrap++;
}
// First set nominal arrival times of missed packets
for (i = group->max_txseq + 1; i != txseq; i++) {
tdiff = (int)diff_usec(group->loss_history[txseq].t,
group->loss_history[group->max_txseq].t) *
((i - group->max_txseq) / (txseq - group->max_txseq));
tvdiff.tv_sec = 0;
tvdiff.tv_usec = tdiff;
while (tvdiff.tv_usec >= 1000000) {
tvdiff.tv_usec -= 1000000;
tvdiff.tv_sec++;
}
group->loss_history[i].found = 0;
group->loss_history[i].t =
add_timeval(group->loss_history[group->max_txseq].t,tvdiff);
}
// Then check for missed packets up to MAXMISORDER less than the current
// Don't do this part unless we have at least MAXMISORDER packets
// TODO: address issue of start_txseq being within MAXMISORDER sequence
// numbers from the maximum
if (group->seq_wrap ||((uint16_t)(group->max_txseq -
group->start_txseq) >= MAXMISORDER)) {
for (i = group->max_txseq - MAXMISORDER;
i != (uint16_t)(txseq - MAXMISORDER); i++) {
if (!group->loss_history[i].found &&
((diff_usec(group->loss_history[i].t,
group->loss_events[0].t) > grtt_usec) ||
group->slowstart)) {
new_loss_event(group, i);
}
}
}
group->max_txseq = txseq;
if (ecn) {
glog4(group, "Seq %d marked by ECN", txseq);
if ((diff_usec(group->loss_history[txseq].t,
group->loss_events[0].t) > grtt_usec) || group->slowstart) {
new_loss_event(group, txseq);
}
}
}
group->loss_events[0].len = ((group->seq_wrap << 16) | group->max_txseq) -
group->loss_events[0].start_seq;
glog5(group, "current cc len = %d", group->loss_events[0].len);
glog5(group, "seq_wrap=%d, max_txseq=%u, start_seq=%u",
group->seq_wrap, group->max_txseq, group->loss_events[0].start_seq);
}
int main (int argc, char *argv[])
{
#ifdef HW_RVL
/* initialize DVD device */
DI_Init();
#endif
u16 usBetweenFrames;
long long now, prev;
/* Initialize OGC subsystems */
ogc_video__init();
ogc_input__init();
ogc_audio__init();
#ifdef HW_DOL
/* Initialize GC DVD interface */
DVD_Init ();
dvd_drive_detect();
#endif
#ifdef HW_RVL
/* Power Button callback */
SYS_SetPowerCallback(Power_Off);
#endif
/* Initialize FAT Interface */
if (fatInitDefault() == true)
{
fat_enabled = 1;
}
/* Default Config */
legal();
set_option_defaults ();
config_load();
#ifdef HW_RVL
/* Load SMB Settings */
loadSettings();
#endif
/* Restore Recent Files list */
set_history_defaults();
history_load();
/* Initialize Virtual Machine */
init_machine ();
/* Show Menu */
MainMenu();
ConfigRequested = 0;
/* Initialize Frame timings */
frameticker = 0;
usBetweenFrames = sms.display ? 20000 : 16666;
prev = gettime();
/* Emulation Loop */
while (1)
{
/* update inputs */
ogc_input__update();
/* Frame synchronization */
if (gc_pal != sms.display)
{
/* use timers */
now = gettime();
if (diff_usec(prev, now) > usBetweenFrames)
{
/* Frame skipping */
prev = now;
system_frame(1);
}
else
{
/* Delay */
while (diff_usec(prev, now) < usBetweenFrames) now = gettime();
/* Render Frame */
prev = now;
system_frame(0);
}
}
else
{
/* use VSync */
if (frameticker > 1)
{
/* Frame skipping */
frameticker--;
system_frame (1);
}
else
{
/* Delay */
while (!frameticker) usleep(10);
system_frame (0);
}
frameticker--;
}
/* update video & audio */
ogc_video__update();
ogc_audio__update();
/* Check for Menu request */
if (ConfigRequested)
{
/* reset AUDIO */
ogc_audio__reset();
/* go to menu */
MainMenu ();
ConfigRequested = 0;
ogc_video__reset();
/* reset frame timings */
frameticker = 0;
usBetweenFrames = sms.display ? 20000 : 16666;
prev = gettime();
}
}
return 0;
}
static void
compute_difference(pmytime pt) {
pt->interval+= diff_usec(pt->start, pt->stop);
}
/****************************************************************************
* systemGetClock
*
* Returns number of milliseconds since program start
****************************************************************************/
u32 systemGetClock( void )
{
u32 now = gettime();
return diff_usec(start, now) / 1000;
}
inline bool
nubot::Time::operator> (const nubot::Time& src) const throw () {
return (diff_usec (src)>0);
}
void MPlayerInput()
{
bool ir = false;
bool inDVDMenu = wiiInDVDMenu();
static bool volumeUpdated = false;
if(userInput[0].wpad->ir.valid)
ir = true;
if(userInput[0].wpad->btns_d & WPAD_BUTTON_1)
osdLevel ^= 1;
else if(ExitRequested || userInput[0].wpad->btns_d & WPAD_BUTTON_HOME)
wiiGotoGui();
if(!inDVDMenu)
{
if(userInput[0].wpad->btns_d & WPAD_BUTTON_A)
{
// Hack to allow people to unpause while the OSD GUI is visible by
// pointing above the button bar and pressing A. We also need to be outside
// the boundaries of the volume bar area, when it is visible
int x = userInput[0].wpad->ir.x;
int y = userInput[0].wpad->ir.y;
int xoffset = 20;
if(screenwidth == 768)
xoffset = 80;
if(!drawGui || (y < 360 &&
(!VideoVolumeLevelBarVisible() || !(x > xoffset && x < xoffset+100 && y > 180))))
{
wiiPause();
}
}
else if(userInput[0].wpad->btns_h & WPAD_BUTTON_PLUS)
{
volnow = gettime();
if(diff_usec(volprev, volnow) > VOL_DELAY)
{
volprev = volnow;
WiiSettings.volume++;
if(WiiSettings.volume > 100) WiiSettings.volume = 100;
wiiSetVolume(WiiSettings.volume);
volumeUpdated = true;
ShowVideoVolumeLevelBar();
}
}
else if(userInput[0].wpad->btns_h & WPAD_BUTTON_MINUS)
{
volnow = gettime();
if(diff_usec(volprev, volnow) > VOL_DELAY)
{
volprev = volnow;
WiiSettings.volume--;
if(WiiSettings.volume < 0) WiiSettings.volume = 0;
wiiSetVolume(WiiSettings.volume);
volumeUpdated = true;
ShowVideoVolumeLevelBar();
}
}
else if (userInput[0].wpad->btns_h & WPAD_BUTTON_B)
{
unsigned int delay = (resizeinitial == 1) ? RESIZE_INITIAL_DELAY : RESIZE_DELAY;
int resizenow = gettime();
if(userInput[0].wpad->btns_h & WPAD_BUTTON_RIGHT)
{
if(diff_usec(resizeprev, resizenow) > delay)
{
resizeinitial++;
resizeprev = resizenow;
MPlayerResize(+0.003F, 0.00F);
}
}
else if(userInput[0].wpad->btns_h & WPAD_BUTTON_LEFT)
{
if(diff_usec(resizeprev, resizenow) > delay)
{
resizeinitial++;
resizeprev = resizenow;
MPlayerResize(-0.003F, 0.00F);
}
}
else if(userInput[0].wpad->btns_h & WPAD_BUTTON_UP)
{
if(diff_usec(resizeprev, resizenow) > delay)
{
resizeinitial++;
resizeprev = resizenow;
MPlayerResize(0.00F, +0.003F);
}
}
else if(userInput[0].wpad->btns_h & WPAD_BUTTON_DOWN)
{
if(diff_usec(resizeprev, resizenow) > delay)
{
resizeinitial++;
resizeprev = resizenow;
MPlayerResize(0.00F, -0.003F);
}
}
if(userInput[0].wpad->btns_d & (WPAD_BUTTON_RIGHT | WPAD_BUTTON_LEFT |
WPAD_BUTTON_UP | WPAD_BUTTON_DOWN))
{
resizeinitial = 0;
}
}
else if(userInput[0].wpad->btns_d & WPAD_BUTTON_RIGHT)
{
wiiFastForward();
}
else if(userInput[0].wpad->btns_d & WPAD_BUTTON_LEFT)
{
wiiRewind();
}
else if(userInput[0].wpad->btns_d & WPAD_BUTTON_UP)
{
if(!wiiIsPaused())
wiiSetProperty(MP_CMD_SUB_SELECT, 0);
}
else if(userInput[0].wpad->btns_d & WPAD_BUTTON_DOWN)
{
if(!wiiIsPaused())
wiiSetProperty(MP_CMD_SWITCH_AUDIO, 0);
}
else if(userInput[0].wpad->btns_d & WPAD_BUTTON_2)
{
wiiDVDNav(MP_CMD_DVDNAV_MENU);
}
}
else
{
if(userInput[0].wpad->ir.valid)
wiiUpdatePointer((int)userInput[0].wpad->ir.x, (int)userInput[0].wpad->ir.y);
if(userInput[0].wpad->btns_d & WPAD_BUTTON_A)
{
if(userInput[0].wpad->ir.valid)
wiiDVDNav(MP_CMD_DVDNAV_MOUSECLICK);
else
wiiDVDNav(MP_CMD_DVDNAV_SELECT);
}
else if (userInput[0].wpad->btns_h & WPAD_BUTTON_B)
{
unsigned int delay = (resizeinitial == 1) ? RESIZE_INITIAL_DELAY : RESIZE_DELAY;
int resizenow = gettime();
if(userInput[0].wpad->btns_h & WPAD_BUTTON_RIGHT)
{
if(diff_usec(resizeprev, resizenow) > delay)
{
resizeinitial++;
resizeprev = resizenow;
MPlayerResize(+0.003F, 0.00F);
}
}
else if(userInput[0].wpad->btns_h & WPAD_BUTTON_LEFT)
{
if(diff_usec(resizeprev, resizenow) > delay)
{
resizeinitial++;
resizeprev = resizenow;
MPlayerResize(-0.003F, 0.00F);
}
}
else if(userInput[0].wpad->btns_h & WPAD_BUTTON_UP)
{
if(diff_usec(resizeprev, resizenow) > delay)
{
resizeinitial++;
resizeprev = resizenow;
MPlayerResize(0.00F, +0.003F);
}
}
else if(userInput[0].wpad->btns_h & WPAD_BUTTON_DOWN)
{
if(diff_usec(resizeprev, resizenow) > delay)
{
resizeinitial++;
resizeprev = resizenow;
MPlayerResize(0.00F, -0.003F);
}
}
if(userInput[0].wpad->btns_d & (WPAD_BUTTON_RIGHT | WPAD_BUTTON_LEFT |
WPAD_BUTTON_UP | WPAD_BUTTON_DOWN))
{
resizeinitial = 0;
}
}
else if(userInput[0].wpad->btns_d & WPAD_BUTTON_UP)
{
wiiDVDNav(MP_CMD_DVDNAV_UP);
}
else if(userInput[0].wpad->btns_d & WPAD_BUTTON_DOWN)
{
wiiDVDNav(MP_CMD_DVDNAV_DOWN);
}
else if(userInput[0].wpad->btns_d & WPAD_BUTTON_RIGHT)
{
wiiDVDNav(MP_CMD_DVDNAV_RIGHT);
}
else if(userInput[0].wpad->btns_d & WPAD_BUTTON_LEFT)
{
wiiDVDNav(MP_CMD_DVDNAV_LEFT);
}
}
if(volumeUpdated)
{
volnow = gettime();
if(volnow > volprev && diff_usec(volprev, volnow) > VOLDISP_MAX)
volumeUpdated = false;
else
ir = true; // trigger display
}
if(ir || BufferingStatusSet() || osdLevel)
{
drawGui = true;
}
else if(drawGui)
{
drawGui = false;
HideVideoVolumeLevelBar();
ShutoffRumble();
}
}
/**
* Performs the Transfer phase for a particular file
* Returns 1 if at least one client finished, 0 if all are dropped or aborted
*/
int transfer_phase(struct finfo_t *finfo)
{
unsigned char *packet, *encpacket, *data;
char path[MAXPATHNAME];
struct uftp_h *header;
struct fileseg_h *fileseg;
int max_time, alldone, numbytes, sent_blocks, current_naks;
unsigned int pass, section, numnaks, block;
struct timeval start_time, last_sent, current_sent;
int64_t avgwait, waitcnt, overage, tdiff;
f_offset_t offset, curr_offset;
int file, i;
if (finfo->file_id != 0) {
// First check to see if all clients are already done for this file.
// This can happen on a restart when the file finished on the
// last attempt and responded to the FILEINFO with a COMPLETE
for (i = 0, alldone = 1; (i < destcount) && alldone; i++) {
alldone = alldone && ((destlist[i].status == DEST_DONE) ||
(client_error(i)) || (destlist[i].clientcnt != -1));
}
if (alldone) {
gettimeofday(&start_time, NULL);
print_status(finfo, start_time);
return 1;
}
}
// If rate is -1, use 100Mbps for purpose of calculating max time
max_time = (int)floor(((double)weight / 100) *
((double)finfo->size / (((rate == -1) ? 100000 : rate) / 8) / 1024));
if (max_time < min_time) {
max_time = min_time;
}
if ((finfo->file_id != 0) && (finfo->ftype == FTYPE_REG)) {
log(0, 0, "Maximum file transfer time: %d seconds", max_time);
snprintf(path, sizeof(path), "%s%c%s", finfo->basedir, PATH_SEP,
finfo->filename);
if ((file = open(path, OPENREAD, 0)) == -1) {
syserror(0, 0, "Error opening file");
return 1;
}
} else {
// At end of group, all non-errored client are DEST_DONE from the
// last file, so reset them to DEST_ACTIVE to get the final COMPLETE.
for (i = 0; i < destcount; i++) {
if (!client_error(i)) {
destlist[i].status = DEST_ACTIVE;
}
}
}
packet = calloc(mtu, 1);
encpacket = calloc(mtu, 1);
if ((packet == NULL) || (encpacket == NULL)) {
syserror(0, 0, "calloc failed!");
exit(1);
}
header = (struct uftp_h *)packet;
fileseg = (struct fileseg_h *)(packet + sizeof(struct uftp_h));
data = (unsigned char *)fileseg + sizeof(struct fileseg_h);
set_uftp_header(header, FILESEG, finfo, &receive_dest);
pass = 1;
alldone = 0;
gettimeofday(&start_time, NULL);
do {
avgwait = 0;
waitcnt = 0;
numnaks = 0;
overage = 0;
section = 1;
curr_offset = 0;
sent_blocks = 0;
gettimeofday(&last_sent, NULL);
if (finfo->file_id != 0) {
log(0, 0, "Sending file...pass %d", pass);
lseek_func(file, 0, SEEK_SET);
} else {
log(0, 0, "Finishing group");
}
fileseg->func = FILESEG;
fileseg->file_id = htons(finfo->file_id);
fileseg->pass = pass;
fileseg->section = htons(section);
for (block = 0; block < finfo->blocks; block++) {
// If all clients received this file partially on a prior attempt
// and it's the first pass, request NAKs for all sections
// right away and don't send any data packets.
if (((pass == 1) || finfo->naklist[block]) &&
!((pass == 1) && finfo->partial)) {
if (diff_sec(last_sent, start_time) > max_time) {
log0(0, 0, "Max file transfer time exceeded");
send_abort(finfo, "Max file transfer time exceeded",
&receive_dest, NULL, (keytype != KEY_NONE),
!quit_on_error);
alldone = 1;
for (i = 0; i < destcount; i++) {
if (quit_on_error || ((destlist[i].status == DEST_ACTIVE) &&
destlist[i].clientcnt == -1 )) {
destlist[i].status = DEST_ABORT;
}
}
break;
}
// On the first pass, go straight through the file.
// On later passes, seek to the next packet.
if (pass != 1) {
log4(0, 0, "Resending %d", block);
if (!seek_block(file, block, &offset, curr_offset)) {
continue;
}
}
if ((numbytes = read(file, data, blocksize)) == -1) {
syserror(0, 0, "read failed");
continue;
}
if (pass != 1) {
curr_offset = offset + numbytes;
}
// Keep track of how long we really slept compared to how
// long we expected to sleep. If we went over, subtract the
// time over from the next sleep time. This way we maintain
// the proper average sleep time. This can result in multiple
// packets going out at once, potentially losing packets.
if (packet_wait > overage) {
usleep(packet_wait - (int32_t)overage);
}
gettimeofday(¤t_sent, NULL);
tdiff = diff_usec(current_sent, last_sent);
avgwait += tdiff;
waitcnt++;
if (packet_wait) overage += tdiff - packet_wait;
last_sent = current_sent;
fileseg->seq_num = htonl(block);
send_data(finfo, packet, numbytes, encpacket);
sent_blocks++;
}
if ((block % (blocksize * 8) == (blocksize * 8) - 1) ||
(block == finfo->blocks - 1)) {
if ((pass == 1) || sent_blocks) {
current_naks = get_naks(finfo, pass, section, &alldone);
numnaks += current_naks;
if ((rate != -1) && (cc_count > 0)) {
if (!read_cc_config(cc_config)) {
log1(0, 0, "Error rereading congestion control "
"config, using prior values");
}
adjust_rate(current_naks, sent_blocks);
}
overage = 0;
if (alldone) break;
}
sent_blocks = 0;
gettimeofday(&last_sent, NULL);
fileseg->section = htons(++section);
}
}
if ((finfo->size == 0) && !alldone) {
// If it's the end of the group, or an empty file, a DONE was
// never sent, so send it now
numnaks += get_naks(finfo, pass, section, &alldone);
}
if (finfo->file_id != 0) {
log(0, 0, "Average wait time = %.2f us",
(waitcnt == 0) ? 0 : (float)avgwait / waitcnt);
log(0, 0, "Received %d distinct NAKs for pass %d", numnaks, pass);
}
pass++;
} while (!alldone);
if ((finfo->file_id != 0) && (finfo->ftype == FTYPE_REG)) {
close(file);
}
print_status(finfo, start_time);
free(packet);
free(encpacket);
for (i = 0; i < destcount; i++) {
if (quit_on_error) {
// Check to see that all finished
if ((destlist[i].status != DEST_DONE) &&
(destlist[i].clientcnt == -1)) {
return 0;
}
} else {
// Check to see if at least one finished
if (destlist[i].status == DEST_DONE) {
return 1;
}
}
}
if (quit_on_error) {
return 1;
} else {
return 0;
}
}
//end of game, check to see if we have won
++games;
if(won(games_state[curr_iteration]))
{
//use backtrack to create solution list
prev=backtrack[curr_iteration];
i=12;
while(i>=0)
{
solutions_data[(solutions*13)+i]=prev>>24;
prev=backtrack[prev%524288];
--i;
}
++solutions;
}
}
++curr_iteration;
}
free(games_state);
free(backtrack);
free(solutions_data);
gettimeofday(&endTime, NULL);
printf("Games played: %6u \n", (unsigned int)games);
printf("Solutions found: %6u\n", (unsigned int)solutions);
printf("Time elapsed: %6ldms\n", diff_usec(startTime, endTime) / 1000);
}
/**
* Print the final statistics for the given file while in sync mode
*/
void print_sync_status(const struct finfo_t *finfo, struct timeval start_time)
{
double elapsed_time, throughput;
int i;
if (finfo->file_id == 0) {
log0(0, 0, "- Status -");
log0(0, 0, "HSTATS;target;copy;overwrite;"
"skip;totalMB;time;speedKB/s");
for (i = 0; i < destcount; i++) {
if (destlist[i].clientcnt >= 0) {
continue;
}
if (destlist[i].total_time > 0) {
throughput = destlist[i].total_size /
destlist[i].total_time / 1024;
} else {
throughput = 0;
}
log0(0, 0, "STATS;%s;%d;%d;%d;%sMB;%.3f;%.2fKB/s",
destlist[i].name, destlist[i].num_copy,
destlist[i].num_overwrite, destlist[i].num_skip,
printll(destlist[i].total_size / 1048576),
destlist[i].total_time,
throughput);
}
return;
}
for (i = 0; i < destcount; i++) {
if (destlist[i].clientcnt >= 0) {
continue;
}
clog0(0, 0, "RESULT;%s;%s;%sKB;", destlist[i].name,
finfo->destfname, printll(finfo->size / 1024));
switch (destlist[i].status) {
case DEST_MUTE:
slog0("mute;");
break;
case DEST_LOST:
slog0("lost;");
break;
case DEST_ABORT:
slog0("aborted;");
break;
case DEST_DONE:
if (sync_preview) {
throughput = rate / 8;
elapsed_time = finfo->size / (throughput * 1024);
} else {
elapsed_time = (double)diff_usec(finfo->deststate[i].time,
start_time) / 1000000;
if (elapsed_time > 0) {
throughput = finfo->size / elapsed_time / 1024;
} else {
throughput = 0;
}
}
switch (destlist[i].comp_status) {
case COMP_STAT_NORMAL:
slog0("copy;%.2fKB/s", throughput);
destlist[i].num_copy++;
destlist[i].total_time += elapsed_time;
destlist[i].total_size += finfo->size;
break;
case COMP_STAT_SKIPPED:
slog0("skipped;");
destlist[i].num_skip++;
break;
case COMP_STAT_OVERWRITE:
slog0("overwritten;%.2fKB/s", throughput);
destlist[i].num_overwrite++;
destlist[i].total_time += elapsed_time;
destlist[i].total_size += finfo->size;
break;
case COMP_STAT_REJECTED:
slog0("rejected;");
break;
default:
slog0("Unknown;");
break;
}
break;
default:
slog0("Unknown;");
break;
}
}
}
/**
* Creates all directories in the given file's path, removing existing files.
* Returns 1 on success, 0 on failure
*/
int create_path_to_file(struct group_list_t *group, const char *filename)
{
char *dir, *base;
stat_struct statbuf;
int rval;
split_path(filename, &dir, &base);
if (!dir) {
glog1(group, "Invalid path element %s", filename);
rval = 0;
goto end;
}
#ifdef WINDOWS
if ((base == NULL) || ((strlen(dir) == 2) && (dir[1] == ':'))) {
#else
if ((!strcmp(dir, ".")) || (!strcmp(dir, "/"))) {
#endif
// At top level directory, so stop recursion
rval = 1;
goto end;
}
if (lstat_func(dir, &statbuf) != -1) {
if (!S_ISDIR(statbuf.st_mode)) {
if (unlink(dir) == -1) {
gsyserror(group, "Failed to delete path element %s", dir);
rval = 0;
goto end;
}
if (mkdir(dir, 0755) == -1) {
gsyserror(group, "Failed to create path element %s", dir);
rval = 0;
goto end;
}
}
} else {
// If the file's directory does not exist, recurse first to make sure
// all parent directories exist
if (!create_path_to_file(group, dir)) {
rval = 0;
goto end;
}
if (mkdir(dir, 0755) == -1) {
gsyserror(group, "Failed to create path element %s", dir);
rval = 0;
goto end;
}
}
rval = 1;
end:
free(dir);
free(base);
return rval;
}
void new_loss_event(struct group_list_t *group, uint16_t txseq)
{
uint32_t seq_long;
uint16_t count;
int bytes, avgbytes, rate, grtt_usec;
glog4(group, "Seq %d starts new loss event", txseq);
// Found a new loss event
if (txseq < group->max_txseq - MAXMISORDER) {
glog5(group, "wrap check, i=%u, maxseq=%u", txseq, group->max_txseq);
seq_long = ((group->seq_wrap - 1) << 16) | txseq;
} else {
seq_long = (group->seq_wrap << 16) | txseq;
}
if (group->slowstart) {
group->slowstart = 0;
// Initialize loss history
count = group->max_txseq;
bytes = 0;
grtt_usec = (int)(group->grtt * 1000000);
while ((count != group->start_txseq) &&
(diff_usec(group->loss_history[txseq].t,
group->loss_history[count].t) < grtt_usec)) {
bytes += group->loss_history[count--].size;
}
rate = (int)(bytes / group->grtt);
glog4(group, "End slowstart, calculated rate = %d", rate);
avgbytes= bytes / ((int16_t)(group->max_txseq - count));
group->loss_events[0].len = (int)(0 + pow(
(rate * ((group->rtt != 0) ? group->rtt : group->grtt)) /
(sqrt(1.5) * 8 * avgbytes), 2));
glog4(group, "Calculated prior event len = %d (rtt=%f, avgbytes=%d)",
group->loss_events[0].len, group->rtt,avgbytes);
} else {
group->loss_events[0].len = seq_long - group->loss_events[0].start_seq;
glog4(group, "Prior event length = %d (i=%u, start=%u)",
group->loss_events[0].len,
seq_long, group->loss_events[0].start_seq);
}
memmove(&group->loss_events[1], &group->loss_events[0],
sizeof(struct loss_event_t) * 8);
group->loss_events[0].start_seq = seq_long;
group->loss_events[0].len = 0;
group->loss_events[0].t = group->loss_history[txseq].t;
}
