void main(void)
{
unsigned char difficulty = 0;
unsigned char input = 0;
P1_4 = 1;
/* init hardware */
fb_init();
keyboard_init();
EA = 1; // enable global interrupts
/* show our startdisplay */
display_start(difficulty);
while(1) {
input = readBuf();
/* change difficulty which results in changing speed */
if(input == SHIFT_KEY) {
difficulty++;
if(difficulty > 2) {
difficulty = 0;
}
display_start(difficulty);
}
/* start game with space */
if(input == SPACE_KEY) {
clearDisplay();
start_game(15000 - difficulty*5000);
display_start(difficulty);
}
}
}
/*
* Read and "Consume" the messages in Buffer.
*/
DWORD
PALAPI
consumer( LPVOID lpParam )
{
int n = 0;
char c;
consumerSleep();
while (n < PRODUCTION_TOTAL)
{
down(hSemaphoreF);
down(hSemaphoreM);
if (readBuf((BufferStructure*)lpParam, &c))
{
Trace("\tConsumer consumes %c.\n", c);
fflush(stdout);
consumerItems[n++] = c;
}
up(hSemaphoreM);
up(hSemaphoreE);
consumerSleep();
}
return 0;
}
/* Reads data from file. Returns 0 on success. Contents of the file
must adhere to the same format readBuf() expects. */
int readFile(const char *path)
{
File file(path);
const char *bytes = (const char *)file.getBytes();
if(bytes)
{
readBuf(bytes);
return 0;
}
return 1;
}
void readData(char *dest, int len)
{
int result = 0;
if(file)
{
result = file->read((unsigned char*)dest,len);
}
else
result = readBuf(ops, dest, 1, len);
if (result < len)
CCAssert(false,"dump format error");
}
void SerialReadBuf(){
int n;
for(n = 0; n < 100; n++){
char** buf = readBuf();
if(*buf!='\n'){
printf("%s",*buf);
}
else{
continue;
}
//free(buf);
//free(*buf);
freeBuf(buf);
}
}
char readByte()
{
char byte;
int result = 0;
if(file)
{
result = file->read((unsigned char*)&byte,1);
}
else
result = readBuf(ops, &byte, 1, 1);
if (result < 1)
CCAssert(false,"dump format error");
return byte;
}
intptr_t RenderThread::main() {
RenderThreadInfo tInfo;
//
// initialize decoders
//
tInfo.m_glDec.initGL(gles1_dispatch_get_proc_func, NULL);
tInfo.m_gl2Dec.initGL(gles2_dispatch_get_proc_func, NULL);
initRenderControlContext(&tInfo.m_rcDec);
ReadBuffer readBuf(m_stream, STREAM_BUFFER_SIZE);
int stats_totalBytes = 0;
long long stats_t0 = GetCurrentTimeMS();
//
// open dump file if RENDER_DUMP_DIR is defined
//
const char *dump_dir = getenv("RENDERER_DUMP_DIR");
FILE *dumpFP = NULL;
if (dump_dir) {
size_t bsize = strlen(dump_dir) + 32;
char *fname = new char[bsize];
snprintf(fname,bsize,"%s/stream_%p", dump_dir, this);
dumpFP = fopen(fname, "wb");
if (!dumpFP) {
fprintf(stderr,"Warning: stream dump failed to open file %s\n",fname);
}
delete [] fname;
}
while (1) {
int stat = readBuf.getData();
if (stat <= 0) {
break;
}
//
// log received bandwidth statistics
//
stats_totalBytes += readBuf.validData();
long long dt = GetCurrentTimeMS() - stats_t0;
if (dt > 1000) {
//float dts = (float)dt / 1000.0f;
//printf("Used Bandwidth %5.3f MB/s\n", ((float)stats_totalBytes / dts) / (1024.0f*1024.0f));
stats_totalBytes = 0;
stats_t0 = GetCurrentTimeMS();
}
//
// dump stream to file if needed
//
if (dumpFP) {
int skip = readBuf.validData() - stat;
fwrite(readBuf.buf()+skip, 1, readBuf.validData()-skip, dumpFP);
fflush(dumpFP);
}
bool progress;
do {
progress = false;
m_lock->lock();
//
// try to process some of the command buffer using the GLESv1 decoder
//
size_t last = tInfo.m_glDec.decode(readBuf.buf(), readBuf.validData(), m_stream);
if (last > 0) {
progress = true;
readBuf.consume(last);
}
//
// try to process some of the command buffer using the GLESv2 decoder
//
last = tInfo.m_gl2Dec.decode(readBuf.buf(), readBuf.validData(), m_stream);
if (last > 0) {
progress = true;
readBuf.consume(last);
}
//
// try to process some of the command buffer using the
// renderControl decoder
//
last = tInfo.m_rcDec.decode(readBuf.buf(), readBuf.validData(), m_stream);
if (last > 0) {
readBuf.consume(last);
progress = true;
}
m_lock->unlock();
} while( progress );
}
if (dumpFP) {
fclose(dumpFP);
}
//
// Release references to the current thread's context/surfaces if any
//
FrameBuffer::getFB()->bindContext(0, 0, 0);
if (tInfo.currContext || tInfo.currDrawSurf || tInfo.currReadSurf) {
fprintf(stderr, "ERROR: RenderThread exiting with current context/surfaces\n");
}
FrameBuffer::getFB()->drainWindowSurface();
FrameBuffer::getFB()->drainRenderContext();
return 0;
}
void *RenderingThread::thread()
{
// initialize our decoders;
m_glDec.initGL();
#ifdef PVR_WAR
m_glTexParameteriv = m_glDec.set_glTexParameteriv(s_glTexParameteriv);
m_glDrawTexfOES = m_glDec.set_glDrawTexfOES(s_glDrawTexfOES);
m_glDrawTexsOES = m_glDec.set_glDrawTexsOES(s_glDrawTexsOES);
m_glDrawTexiOES = m_glDec.set_glDrawTexiOES(s_glDrawTexiOES);
m_glDrawTexxOES = m_glDec.set_glDrawTexxOES(s_glDrawTexxOES);
m_glDrawTexfvOES = m_glDec.set_glDrawTexfvOES(s_glDrawTexfvOES);
m_glDrawTexsvOES = m_glDec.set_glDrawTexsvOES(s_glDrawTexsvOES);
m_glDrawTexivOES = m_glDec.set_glDrawTexivOES(s_glDrawTexivOES);
m_glDrawTexxvOES = m_glDec.set_glDrawTexxvOES(s_glDrawTexxvOES);
m_glActiveTexture = m_glDec.set_glActiveTexture(s_glActiveTexture);
m_glBindTexture = m_glDec.set_glBindTexture(s_glBindTexture);
m_glEnable = m_glDec.set_glEnable(s_glEnable);
m_glDisable = m_glDec.set_glDisable(s_glDisable);
m_glClientActiveTexture = m_glDec.set_glClientActiveTexture(s_glClientActiveTexture);
m_glEnableClientState = m_glDec.set_glEnableClientState(s_glEnableClientState);
m_glDisableClientState = m_glDec.set_glDisableClientState(s_glDisableClientState);
#endif
m_gl2Dec.initGL();
m_utDec.set_swapBuffers(s_swapBuffers);
m_utDec.set_createContext(s_createContext);
m_utDec.set_destroyContext(s_destroyContext);
m_utDec.set_createSurface(s_createSurface);
m_utDec.set_destroySurface(s_destroySurface);
m_utDec.set_makeCurrentContext(s_makeCurrent);
ReadBuffer readBuf(m_stream, DECODER_BUF_SIZE);
int stats_totalBytes = 0;
long long stats_t0 = GetCurrentTimeMS();
while (1) {
int stat = readBuf.getData();
if (stat == 0) {
fprintf(stderr, "client shutdown\n");
break;
} else if (stat < 0) {
perror("getData");
break;
}
//
// log received bandwidth statistics
//
stats_totalBytes += readBuf.validData();
long long dt = GetCurrentTimeMS() - stats_t0;
if (dt > 1000) {
float dts = (float)dt / 1000.0f;
printf("Used Bandwidth %5.3f MB/s\n", ((float)stats_totalBytes / dts) / (1024.0f*1024.0f));
stats_totalBytes = 0;
stats_t0 = GetCurrentTimeMS();
}
bool progress = true;
while (progress) {
progress = false;
// we need at least one header (8 bytes) in our buffer
if (readBuf.validData() >= 8) {
size_t last = m_glDec.decode(readBuf.buf(), readBuf.validData(), m_stream);
if (last > 0) {
progress = true;
readBuf.consume(last);
}
}
if (readBuf.validData() >= 8) {
size_t last = m_gl2Dec.decode(readBuf.buf(), readBuf.validData(), m_stream);
if (last > 0) {
readBuf.consume(last);
progress = true;
}
}
if (readBuf.validData() >= 8) {
size_t last = m_utDec.decode(readBuf.buf(), readBuf.validData(), m_stream);
if (last > 0) {
readBuf.consume(last);
progress = true;
}
}
}
}
// shutdown
if (m_currentContext != NULL) {
m_currentContext->unref();
}
return NULL;
}
void BufferedSocket::threadSendFile(InputStream* file) throw(Exception) {
dcassert(sock);
if(!sock)
return;
dcassert(file != NULL);
size_t sockSize = (size_t)sock->getSocketOptInt(SO_SNDBUF);
size_t bufSize = max(sockSize, (size_t)64*1024);
vector<uint8_t> readBuf(bufSize);
vector<uint8_t> writeBuf(bufSize);
size_t readPos = 0;
bool readDone = false;
dcdebug("Starting threadSend\n");
while(true) {
if(!readDone && readBuf.size() > readPos) {
// Fill read buffer
size_t bytesRead = readBuf.size() - readPos;
size_t actual = file->read(&readBuf[readPos], bytesRead);
if(bytesRead > 0) {
fire(BufferedSocketListener::BytesSent(), bytesRead, 0);
}
if(actual == 0) {
readDone = true;
} else {
readPos += actual;
}
}
if(readDone && readPos == 0) {
fire(BufferedSocketListener::TransmitDone());
return;
}
readBuf.swap(writeBuf);
readBuf.resize(bufSize);
writeBuf.resize(readPos);
readPos = 0;
size_t writePos = 0;
while(writePos < writeBuf.size()) {
if(disconnecting)
return;
size_t writeSize = min(sockSize / 2, writeBuf.size() - writePos);
int written = sock->write(&writeBuf[writePos], writeSize);
if(written > 0) {
writePos += written;
fire(BufferedSocketListener::BytesSent(), 0, written);
} else if(written == -1) {
if(!readDone && readPos < readBuf.size()) {
// Read a little since we're blocking anyway...
size_t bytesRead = min(readBuf.size() - readPos, readBuf.size() / 2);
size_t actual = file->read(&readBuf[readPos], bytesRead);
if(bytesRead > 0) {
fire(BufferedSocketListener::BytesSent(), bytesRead, 0);
}
if(actual == 0) {
readDone = true;
} else {
readPos += actual;
}
} else {
while(!disconnecting) {
int w = sock->wait(POLL_TIMEOUT, Socket::WAIT_WRITE | Socket::WAIT_READ);
if(w & Socket::WAIT_READ) {
threadRead();
}
if(w & Socket::WAIT_WRITE) {
break;
}
}
}
}
}
}
}
// called by hal ext IRQ handler
// (radio goes to stanby mode after tx/rx operations)
void radio_irq_handler (u1_t dio) {
ostime_t now = os_getTime();
if( (readReg(RegOpMode) & OPMODE_LORA) != 0) { // LORA modem
u1_t flags = readReg(LORARegIrqFlags);
if( flags & IRQ_LORA_TXDONE_MASK ) {
// save exact tx time
LMIC.txend = now - us2osticks(43); // TXDONE FIXUP
} else if( flags & IRQ_LORA_RXDONE_MASK ) {
// save exact rx time
if(getBw(LMIC.rps) == BW125) {
now -= LORA_RXDONE_FIXUP[getSf(LMIC.rps)];
}
LMIC.rxtime = now;
// read the PDU and inform the MAC that we received something
LMIC.dataLen = (readReg(LORARegModemConfig1) & SX1272_MC1_IMPLICIT_HEADER_MODE_ON) ?
readReg(LORARegPayloadLength) : readReg(LORARegRxNbBytes);
// set FIFO read address pointer
writeReg(LORARegFifoAddrPtr, readReg(LORARegFifoRxCurrentAddr));
// now read the FIFO
readBuf(RegFifo, LMIC.frame, LMIC.dataLen);
// read rx quality parameters
LMIC.snr = readReg(LORARegPktSnrValue); // SNR [dB] * 4
LMIC.rssi = readReg(LORARegPktRssiValue) - 125 + 64; // RSSI [dBm] (-196...+63)
} else if( flags & IRQ_LORA_RXTOUT_MASK ) {
// indicate timeout
LMIC.dataLen = 0;
}
// mask all radio IRQs
writeReg(LORARegIrqFlagsMask, 0xFF);
// clear radio IRQ flags
writeReg(LORARegIrqFlags, 0xFF);
} else { // FSK modem
u1_t flags1 = readReg(FSKRegIrqFlags1);
u1_t flags2 = readReg(FSKRegIrqFlags2);
if( flags2 & IRQ_FSK2_PACKETSENT_MASK ) {
// save exact tx time
LMIC.txend = now;
} else if( flags2 & IRQ_FSK2_PAYLOADREADY_MASK ) {
// save exact rx time
LMIC.rxtime = now;
// read the PDU and inform the MAC that we received something
LMIC.dataLen = readReg(FSKRegPayloadLength);
// now read the FIFO
readBuf(RegFifo, LMIC.frame, LMIC.dataLen);
// read rx quality parameters
LMIC.snr = 0; // determine snr
LMIC.rssi = 0; // determine rssi
} else if( flags1 & IRQ_FSK1_TIMEOUT_MASK ) {
// indicate timeout
LMIC.dataLen = 0;
} else {
//while(1);
// Do not infinite loop when interrupt triggers unexpectedly
// Instead, call ASSERT, which calls hal_failed, so there is at least a
// traceable error. (MK)
ASSERT(0);
}
}
// go from stanby to sleep
opmode(OPMODE_SLEEP);
// run os job (use preset func ptr)
os_setCallback(&LMIC.osjob, LMIC.osjob.func);
}
int RenderThread::Main()
{
RenderThreadInfo * tInfo = getRenderThreadInfo();
//
// initialize decoders
//
tInfo->m_glDec.initGL( gl_dispatch_get_proc_func, NULL );
tInfo->m_gl2Dec.initGL( gl2_dispatch_get_proc_func, NULL );
initRenderControlContext( &m_rcDec );
ReadBuffer readBuf(m_stream, STREAM_BUFFER_SIZE);
int stats_totalBytes = 0;
long long stats_t0 = GetCurrentTimeMS();
//
// open dump file if RENDER_DUMP_DIR is defined
//
const char *dump_dir = getenv("RENDERER_DUMP_DIR");
FILE *dumpFP = NULL;
if (dump_dir) {
size_t bsize = strlen(dump_dir) + 32;
char *fname = new char[bsize];
snprintf(fname,bsize,"%s/stream_%p", dump_dir, this);
dumpFP = fopen(fname, "wb");
if (!dumpFP) {
fprintf(stderr,"Warning: stream dump failed to open file %s\n",fname);
}
delete [] fname;
}
while (1) {
int stat = readBuf.getData();
if (stat <= 0) {
break;
}
//
// log received bandwidth statistics
//
stats_totalBytes += readBuf.validData();
long long dt = GetCurrentTimeMS() - stats_t0;
if (dt > 1000) {
float dts = (float)dt / 1000.0f;
//printf("Used Bandwidth %5.3f MB/s\n", ((float)stats_totalBytes / dts) / (1024.0f*1024.0f));
stats_totalBytes = 0;
stats_t0 = GetCurrentTimeMS();
}
//
// dump stream to file if needed
//
if (dumpFP) {
int skip = readBuf.validData() - stat;
fwrite(readBuf.buf()+skip, 1, readBuf.validData()-skip, dumpFP);
fflush(dumpFP);
}
bool progress;
do {
progress = false;
//
// try to process some of the command buffer using the GLESv1 decoder
//
size_t last = tInfo->m_glDec.decode(readBuf.buf(), readBuf.validData(), m_stream);
if (last > 0) {
progress = true;
readBuf.consume(last);
}
//
// try to process some of the command buffer using the GLESv2 decoder
//
last = tInfo->m_gl2Dec.decode(readBuf.buf(), readBuf.validData(), m_stream);
if (last > 0) {
progress = true;
readBuf.consume(last);
}
//
// try to process some of the command buffer using the
// renderControl decoder
//
last = m_rcDec.decode(readBuf.buf(), readBuf.validData(), m_stream);
if (last > 0) {
readBuf.consume(last);
progress = true;
}
} while( progress );
}
if (dumpFP) {
fclose(dumpFP);
}
//
// release the thread from any EGL context
// if bound to context.
//
EGLDisplay eglDpy = s_egl.eglGetCurrentDisplay();
if (eglDpy != EGL_NO_DISPLAY) {
s_egl.eglMakeCurrent(eglDpy,
EGL_NO_SURFACE,
EGL_NO_SURFACE,
EGL_NO_CONTEXT);
}
//
// flag that this thread has finished execution
m_finished = true;
return 0;
}
/**
* アニメーションを読み込む
*/
void loadAnimation(ANIME_SET* graphic,ARCHIVE* archive,const char* file_name){
BUF* gfx_file = getFile(archive,file_name);
//ヘッダを飛ばす。
seekBuf(gfx_file,(long)strlen(ANIME_HEADER),SEEK_SET);
//ファイル名取得
int filename_size;
readBuf(gfx_file,&filename_size,sizeof(filename_size));
graphic->filename_size = filename_size;
graphic->filename = malloc(filename_size+1);
readBuf(gfx_file,graphic->filename,filename_size);
graphic->filename[filename_size] = '\0';
//スプライト取得
SDL_RWops* frame_ops = getGraphixFile(archive,graphic->filename);
getSpriteFromOPS(&graphic->sprite,frame_ops);
frame_ops->close(frame_ops); //メモリ開放は忘れずに
//スプライトエリア用スプライト
SPRITE* anime_sprite = &graphic->sprite;
//モード、フラグ、アニメ数。
readBuf(gfx_file,&graphic->mode,sizeof(graphic->mode));
readBuf(gfx_file,&graphic->flag,sizeof(graphic->flag));
readBuf(gfx_file,&graphic->anime_num,sizeof(graphic->anime_num));
int anime_num = graphic->anime_num;
graphic->anime = malloc( sizeof(ANIMATION*) * anime_num );
int i=0;
for(;i<anime_num;i++){
//アニメ番号
int num = 0;
readBuf(gfx_file,&num,sizeof(num));
if(anime_num < num) raiseError("invalid animation file:",file_name);
//メモリ確保。
graphic->anime[num] = malloc(sizeof(ANIMATION));
ANIMATION* anime = graphic->anime[num];
anime->num = num;
//フレーム番号取得
int frame_num;
readBuf(gfx_file,&frame_num,sizeof(frame_num));
anime->frame_num = frame_num;
anime->frame = malloc(sizeof(ANIMATION_FRAME)*frame_num);
int j;
for(j=0;i<frame_num;j++){
//フレームへのポインタの設定
ANIMATION_FRAME* frame = &anime->frame[j];
//持続時間
readBuf(gfx_file,&frame->frame_time,sizeof(frame->frame_time));
//スプライトの設定
frame->sprite_area.sprite = anime_sprite;
readBuf(gfx_file,&frame->sprite_area.x,sizeof(frame->sprite_area.x));
readBuf(gfx_file,&frame->sprite_area.y,sizeof(frame->sprite_area.y));
readBuf(gfx_file,&frame->sprite_area.width,sizeof(frame->sprite_area.width));
readBuf(gfx_file,&frame->sprite_area.height,sizeof(frame->sprite_area.height));
}
}
deleteBuf(gfx_file);
}
void BufferedSocket::threadSendFile(InputStream* file) throw(Exception) {
if(state != RUNNING)
return;
if(disconnecting)
return;
dcassert(file != NULL);
size_t sockSize = (size_t)sock->getSocketOptInt(SO_SNDBUF);
size_t bufSize = max(sockSize, (size_t)64*1024);
ByteVector readBuf(bufSize);
ByteVector writeBuf(bufSize);
size_t readPos = 0;
bool readDone = false;
dcdebug("Starting threadSend\n");
UploadManager *um = UploadManager::getInstance();
size_t sendMaximum, start = 0, current= 0;
bool throttling;
while(true) {
if(!readDone && readBuf.size() > readPos) {
// Fill read buffer
size_t bytesRead = readBuf.size() - readPos;
size_t actual = file->read(&readBuf[readPos], bytesRead);
if(bytesRead > 0) {
fire(BufferedSocketListener::BytesSent(), bytesRead, 0);
}
if(actual == 0) {
readDone = true;
} else {
readPos += actual;
}
}
if(readDone && readPos == 0) {
fire(BufferedSocketListener::TransmitDone());
return;
}
readBuf.swap(writeBuf);
readBuf.resize(bufSize);
writeBuf.resize(readPos);
readPos = 0;
size_t writePos = 0;
while(writePos < writeBuf.size()) {
if(disconnecting)
return;
throttling = BOOLSETTING(THROTTLE_ENABLE);
size_t writeSize;
if(throttling) {
start = TimerManager::getTick();
sendMaximum = um->throttleGetSlice();
if(sendMaximum < 0) {
throttling = false;
writeSize = min(sockSize / 2, writeBuf.size() - writePos);
} else {
writeSize = min(min(sockSize / 2, writeBuf.size() - writePos), sendMaximum);
}
} else {
writeSize = min(sockSize / 2, writeBuf.size() - writePos);
}
int written = sock->write(&writeBuf[writePos], writeSize);
if(written > 0) {
writePos += written;
fire(BufferedSocketListener::BytesSent(), 0, written);
if(throttling) {
int32_t cycle_time = um->throttleCycleTime();
current = TimerManager::getTick();
int32_t sleep_time = cycle_time - (current - start);
if (sleep_time > 0 && sleep_time <= cycle_time) {
Thread::sleep(sleep_time);
}
}
} else if(written == -1) {
if(!readDone && readPos < readBuf.size()) {
// Read a little since we're blocking anyway...
size_t bytesRead = min(readBuf.size() - readPos, readBuf.size() / 2);
size_t actual = file->read(&readBuf[readPos], bytesRead);
if(bytesRead > 0) {
fire(BufferedSocketListener::BytesSent(), bytesRead, 0);
}
if(actual == 0) {
readDone = true;
} else {
readPos += actual;
}
} else {
while(!disconnecting) {
int w = sock->wait(POLL_TIMEOUT, Socket::WAIT_WRITE | Socket::WAIT_READ);
if(w & Socket::WAIT_READ) {
threadRead();
}
if(w & Socket::WAIT_WRITE) {
break;
}
}
}
}
}
}
}
static word readWordBE() {
word w;
readBuf(sizeof(w),(byte*)&w);
return w;
}
static word readWordLE() {
word w;
readBuf(1,(byte*)&w+1);
readBuf(1,(byte*)(&w));
return w;
}
static byte readByte() {
byte b;
readBuf(sizeof(b),&b);
return b;
}
