int main(int argc, char** argv) {
// Initialize the window and the GL components
if (!OnInitInstance() || !GL_Initialize()) {
return 1;
}
// Initialize the application
OnInitialize();
while(mAppRunning == true) {
MSG message = {0};
bool result = PeekMessage(&message, 0, 0, 0, PM_REMOVE);
if (result == true) {
TranslateMessage(&message);
DispatchMessage(&message);
}
OnFrame();
}
system("pause");
OnDestroyInstance();
return 0;
}
int main(int argc, char **argv)
{
if (!Init())
{
LOG::Message("Initialization failed.");
AppRunning = false;
}
for (unsigned i = 0; i < argc; i++)
LOG::Message(argv[i]);
time_t lastTime = time(0);
while(AppRunning)
{
SDL_Event event;
while (SDL_PollEvent(&event))
Listen(event);
time_t newTime = time(0);
if (newTime > lastTime)
{
OnTick();
OnFrame();
lastTime = newTime;
}
}
if (!Uninit())
LOG::Message("Uninitialization failed.");
return 0;
}
void CEnvironment::OnDeviceCreate()
{
//. bNeed_re_create_env = TRUE;
sh_2sky.create (&m_b_skybox,"skybox_2t");
sh_2geom.create (v_skybox_fvf,RCache.Vertex.Buffer(), RCache.Index.Buffer());
clouds_sh.create ("clouds","null");
clouds_geom.create (v_clouds_fvf,RCache.Vertex.Buffer(), RCache.Index.Buffer());
// weathers
{
EnvsMapIt _I,_E;
_I = WeatherCycles.begin();
_E = WeatherCycles.end();
for (; _I!=_E; _I++)
for (EnvIt it=_I->second.begin(); it!=_I->second.end(); it++)
(*it)->on_device_create();
}
// effects
{
EnvsMapIt _I,_E;
_I = WeatherFXs.begin();
_E = WeatherFXs.end();
for (; _I!=_E; _I++)
for (EnvIt it=_I->second.begin(); it!=_I->second.end(); it++)
(*it)->on_device_create();
}
Invalidate ();
OnFrame ();
}
eMsgStatus ScrubBarComponent::OnEvent_Impl( App * app, VrFrame const & vrFrame, OvrVRMenuMgr & menuMgr,
VRMenuObject * self, VRMenuEvent const & event )
{
switch( event.EventType )
{
case VRMENU_EVENT_FOCUS_GAINED:
HasFocus = true;
return MSG_STATUS_ALIVE;
case VRMENU_EVENT_FOCUS_LOST:
HasFocus = false;
return MSG_STATUS_ALIVE;
case VRMENU_EVENT_TOUCH_DOWN:
TouchDown = true;
OnClick( app, vrFrame, event );
return MSG_STATUS_ALIVE;
case VRMENU_EVENT_FRAME_UPDATE:
return OnFrame( app, vrFrame, menuMgr, self, event );
default:
OVR_ASSERT( !"Event flags mismatch!" );
return MSG_STATUS_ALIVE;
}
}
void CEngine::Run()
{
FKeepRunning = true;
OnStartup();
while(FKeepRunning)
{
OnFrame();
}
OnShutDown();
}
void SDLApp::Run()
{
timer_.reset();
while( run_ ) {
PumpEvents();
float dt = timer_.reset() / 1000.f;
OnFrame(dt);
}
}
void nuiAnimation::CallOnFrame()
{
bool ShouldStop = UpdateTime();
OnFrame();
if (ShouldStop)
{
mUpdatingTime = true;
Stop();
mUpdatingTime = false;
}
}
LICECaptureCompressor::~LICECaptureCompressor()
{
// process any pending frames
if (m_file)
{
OnFrame(NULL,0);
deflateEnd(&m_compstream);
}
delete m_file;
m_framelists[0].Empty(true);
m_framelists[1].Empty(true);
}
virtual eMsgStatus OnEvent_Impl( OvrGuiSys & guiSys, ovrFrameInput const & vrFrame,
VRMenuObject * self, VRMenuEvent const & event )
{
switch ( event.EventType )
{
case VRMENU_EVENT_FRAME_UPDATE:
return OnFrame( guiSys, vrFrame, self, event );
case VRMENU_EVENT_OPENING:
return OnOpening( guiSys, vrFrame, self, event );
default:
OVR_ASSERT( !"Event flags mismatch!" ); // the constructor is specifying a flag that's not handled
return MSG_STATUS_ALIVE;
}
}
void TUI::Idle()
{
VERIFY(m_bReady);
EDevice.b_is_Active = Application->Active;
// input
pInput->OnFrame();
Sleep(1);
if (ELog.in_use) return;
OnFrame ();
if (m_Flags.is(flRedraw)) RealRedrawScene();
// test quit
if (m_Flags.is(flNeedQuit)) RealQuit();
}
void LICECaptureCompressor::OnFrame(LICE_IBitmap *fr, int delta_t_ms)
{
if (fr)
{
if (fr->getWidth()!=m_w || fr->getHeight()!=m_h) return;
frameRec *rec = m_framelists[m_which].Get(m_state);
if (!rec)
{
rec = new frameRec(m_w*m_h);
m_framelists[m_which].Add(rec);
}
rec->delta_t_ms=delta_t_ms;
BitmapToFrameRec(fr,rec);
m_state++;
m_inframes++;
}
bool isLastBlock = m_state >= m_interval || !fr;
if (m_framelists[!m_which].GetSize())
{
int compressTo;
if (isLastBlock) compressTo = m_numcols*m_numrows;
else compressTo = (m_state * m_numcols*m_numrows) / m_interval;
frameRec **list = m_framelists[!m_which].GetList();
int list_size = m_framelists[!m_which].GetSize();
// compress some data
int chunkpos = m_outchunkpos;
while (chunkpos < compressTo)
{
int xpos = (chunkpos%m_numcols) * m_bsize_w;
int ypos = (chunkpos/m_numcols) * m_bsize_h;
int wid = m_w-xpos;
int hei = m_h-ypos;
if (wid > m_bsize_w) wid=m_bsize_w;
if (hei > m_bsize_h) hei=m_bsize_h;
int i;
int rdoffs = xpos + ypos*m_w;
int rdspan = m_w;
int repeat_cnt=0;
for(i=0;i<list_size; i++)
{
unsigned short *rd = list[i]->data + rdoffs;
if (i&&repeat_cnt<256)
{
unsigned short *rd1=rd;
unsigned short *rd2=list[i-1]->data+rdoffs;
int a=hei;
while(a--)
{
if (memcmp(rd1,rd2,wid*sizeof(short))) break;
rd1+=rdspan;
rd2+=rdspan;
}
if (a<0)
{
repeat_cnt++;
continue;
}
}
if (i || repeat_cnt)
{
unsigned char c = (unsigned char)repeat_cnt;
DeflateBlock(&c,1,false);
repeat_cnt=0;
}
int a=hei;
while (a--)
{
DeflateBlock(rd,wid*sizeof(short),false);
rd+=rdspan;
}
}
if (repeat_cnt)
{
unsigned char c = (unsigned char)repeat_cnt;
DeflateBlock(&c,1,false);
}
chunkpos++;
}
m_outchunkpos=chunkpos;
}
if (isLastBlock)
{
if (m_framelists[!m_which].GetSize())
{
m_outframes += m_framelists[!m_which].GetSize();
DeflateBlock(NULL,0,true);
deflateReset(&m_compstream);
m_hdrqueue.Clear();
AddHdrInt(LCF_VERSION);
AddHdrInt(16);
AddHdrInt(m_w);
AddHdrInt(m_h);
AddHdrInt(m_bsize_w);
AddHdrInt(m_bsize_h);
int nf = m_framelists[!m_which].GetSize();
AddHdrInt(nf);
int sz = m_current_block.Available();
AddHdrInt(sz);
int uncomp_sz = m_current_block_srcsize;
AddHdrInt(uncomp_sz);
{
int x;
for(x=0;x<nf;x++)
{
AddHdrInt(m_framelists[!m_which].Get(x)->delta_t_ms);
}
}
m_file->Write(m_hdrqueue.Get(),m_hdrqueue.Available());
m_outsize += m_hdrqueue.Available();
m_file->Write(m_current_block.Get(),sz);
m_outsize += sz;
m_current_block.Clear();
m_current_block_srcsize=0;
}
int old_state=m_state;
m_state=0;
m_outchunkpos=0;
m_which=!m_which;
if (old_state>0 && !fr)
{
while (m_framelists[!m_which].GetSize() > old_state)
m_framelists[!m_which].Delete(m_framelists[!m_which].GetSize()-1,true);
OnFrame(NULL,0);
}
if (!fr)
{
m_framelists[0].Empty(true);
m_framelists[1].Empty(true);
}
}
}
int main(int argc, char *argv[]){
init_parse();
// Parses the commandline arguments
parse_opts(argc, argv); // IE: ./server -cserver.cfg --name "My Server"
// server config
ReadServerCfg(cfg_file ? :"server.cfg");
// init sockets
struct sockaddr_in newclient;
unsigned char buffer[MAX_BUF];
int size;
fd_set descriptor; //I don't know
sock = create_socket();
bind_socket(&sock, INADDR_ANY, sv_hostport);
// on termination
atexit(&cleanup);
signal(SIGABRT, &exit);
signal(SIGTERM, &exit);
signal(SIGINT, &exit);
// initialize rest of stuff
OnServerStart();
#ifndef _WIN32
// fps control
const int inc = NS_PER_S / sv_fps;
int frame = 0;
int previous = 0;
struct timespec current, next;
clock_gettime(CLOCK_MONOTONIC, &next);
#endif
// timeval for select
struct timeval timeout;
timeout.tv_sec = 0;
timeout.tv_usec = 0;
//main loop
while (1) {
#ifndef _WIN32
frame++;
next.tv_nsec += inc;
while (next.tv_nsec > NS_PER_S) { //happens exactly once a second
next.tv_nsec -= NS_PER_S;
next.tv_sec++;
fpsnow = frame - previous;
previous = frame;
OnSecond();
}
#endif
OnFrame();
FD_ZERO(&descriptor);
FD_SET(sock, &descriptor);
select(sock + 1, &descriptor, NULL, NULL, &timeout);
if (FD_ISSET(sock, &descriptor)){
size = udp_receive(sock, buffer, MAX_BUF, &newclient);
if (size < 3) {
perror("Invalid packet! (size < 3)\n");
} else {
stream *packet = init_stream(NULL);
Stream.write(packet, buffer+2, size-2);
// There's a chance that the guy left before all of the packet has been processed.
while(1){
int id = IsPlayerKnown(newclient.sin_addr, newclient.sin_port);
if (id){
if (ValidatePacket(buffer,id)){
PacketConfirmation(buffer,id); //If the numbering is even, send a confirmation
player[id].lastpacket = mtime();
int pid = Stream.read_byte(packet);
known_handler h = known_table[pid];
if (!h){
printf("Unhandled packet originating from %s (id:%d)\n", player[id].name, id);
//stream *lolbuf = init_stream(NULL);
//Stream.write(lolbuf, buffer, size);
//unknown(lolbuf, pid);
unknown(packet, pid);
} else
h(packet, id);
}
}else{
int pid = Stream.read_byte(packet);
unknown_handler h = unknown_table[pid];
if (!h)
unknown(packet, pid);
else
h(packet, &newclient);
}
if (EMPTY_STREAM(packet)){
free(packet);
break;
}
}
}
}
check_sendqueue();
#ifdef _WIN32
Sleep(1000 / sv_fps); //who cares about windows :D
#else
clock_gettime(CLOCK_MONOTONIC, ¤t);
if (((current.tv_sec == next.tv_sec) && (current.tv_nsec < next.tv_nsec)) || (current.tv_sec < next.tv_sec)) {
clock_nanosleep(CLOCK_MONOTONIC, TIMER_ABSTIME, &next, NULL);
} else {
next.tv_nsec = current.tv_nsec + (current.tv_sec - next.tv_sec) * NS_PER_S;
}
#endif
}
return EXIT_SUCCESS;
}
BOOL CMbusDataStream::ParseStream(DATASTREAM *pStream, BYTE *pszStream, int nLength, void *pCallData)
{
MBUS_HEADER *pHeader;
MBUS_LONG_HEADER *pLHeader;
MBUS_TAIL *pTail;
int i, nSeek;
BOOL bResult;
BYTE c;
for(i=0; i<nLength; i+=nSeek)
{
nSeek = 1;
c = (pszStream[i] & 0xff);
switch(pStream->nState) {
case STATE_IDENT :
switch(c)
{
case MBUS_FRAME_SINGLE:
CDataStream::AddStream(pStream, c);
bResult = OnFrame(pStream, (BYTE *)pStream->pszBuffer, pStream->nLength, pCallData);
CDataStream::ClearStream(pStream);
pStream->nState = STATE_IDENT;
return bResult;
case MBUS_FRAME_SHORT:
pStream->nSize = sizeof(MBUS_SHORT_HEADER);
pStream->nState = STATE_HEADER;
break;
case MBUS_FRAME_LONG:
pStream->nSize = sizeof(MBUS_LONG_HEADER);
pStream->nState = STATE_HEADER;
break;
default:
// 시작이 틀린 경우 수신된 전체 프레임을 무시한다.
XDEBUG("Receive %0d Byte(s)\xd\xa", nLength);
XDUMP((char *)pszStream, nLength);
XDEBUG(" \033[1;40;31mInvalid Start Flag = 0x%02X\033[0m\r\n", c);
return FALSE;
}
CDataStream::AddStream(pStream, c);
break;
case STATE_HEADER :
nSeek = MIN(pStream->nSize-pStream->nLength, nLength-i);
CDataStream::AddStream(pStream, (const char *)pszStream+i, nSeek);
if (pStream->nLength < pStream->nSize)
break;
pHeader = (MBUS_HEADER *)pStream->pszBuffer;
switch(pHeader->start)
{
case MBUS_FRAME_SHORT:
pStream->nSize += sizeof(MBUS_TAIL);
pStream->nState = STATE_TAIL;
break;
case MBUS_FRAME_LONG:
pLHeader = (MBUS_LONG_HEADER *)pStream->pszBuffer;
if(pLHeader->start != pLHeader->start2 || pLHeader->len != pLHeader->len2 || pLHeader->len < 3)
{
XDEBUG("Receive %0d Byte(s)\xd\xa", nLength);
XDUMP((char *)pszStream, nLength);
XDEBUG(" \033[1;40;31mInvalid Long Header\033[0m\r\n");
CDataStream::ClearStream(pStream);
pStream->nState = STATE_IDENT;
return FALSE;
}
pStream->nSize += pLHeader->len - 3;
pStream->nState = STATE_DATA;
break;
}
break;
case STATE_DATA :
nSeek = MIN(pStream->nSize-pStream->nLength, nLength-i);
if (!CDataStream::AddStream(pStream, (const char *)pszStream+i, nSeek))
return FALSE;
if (pStream->nLength < pStream->nSize)
break;
pStream->nSize += sizeof(MBUS_TAIL);
pStream->nState = STATE_TAIL;
break;
case STATE_TAIL:
nSeek = MIN(pStream->nSize-pStream->nLength, nLength-i);
if (!CDataStream::AddStream(pStream, (const char *)pszStream+i, nSeek))
return FALSE;
if (pStream->nLength < pStream->nSize)
break;
pHeader = (MBUS_HEADER *)pStream->pszBuffer;
pTail = (MBUS_TAIL *)&pStream->pszBuffer[pStream->nLength-2];
switch(pHeader->start)
{
case MBUS_FRAME_SHORT:
if(!VerifyMbusChecksum((BYTE *)(pStream->pszBuffer+1), 2, pTail->checksum))
{
XDEBUG("Receive %0d Byte(s)\xd\xa", pStream->nLength);
XDUMP((char *)pStream->pszBuffer, pStream->nLength);
XDEBUG(" \033[1;40;31mChecksum Error!!\033[0m\xd\xa");
CDataStream::ClearStream(pStream);
pStream->nState = STATE_IDENT;
return FALSE;
}
break;
case MBUS_FRAME_LONG:
pLHeader = (MBUS_LONG_HEADER *)pStream->pszBuffer;
if(!VerifyMbusChecksum((BYTE *)(pStream->pszBuffer+4), pLHeader->len, pTail->checksum))
{
XDEBUG("Receive %0d Byte(s)\xd\xa", pStream->nLength);
XDUMP((char *)pStream->pszBuffer, pStream->nLength);
XDEBUG(" \033[1;40;31mChecksum Error!!\033[0m\xd\xa");
CDataStream::ClearStream(pStream);
pStream->nState = STATE_IDENT;
return FALSE;
}
break;
}
bResult = OnFrame(pStream, (BYTE *)pStream->pszBuffer, pStream->nLength, pCallData);
CDataStream::ClearStream(pStream);
pStream->nState = STATE_IDENT;
return bResult;
}
}
return FALSE;
}
HRESULT CAudioDecFilter::Transform(IMediaSample *pIn, IMediaSample *pOut)
{
// 入力データポインタを取得する
const DWORD InSize = pIn->GetActualDataLength();
BYTE *pInData = NULL;
HRESULT hr = pIn->GetPointer(&pInData);
if (FAILED(hr))
return hr;
{
CAutoLock Lock(&m_cPropLock);
/*
複数の音声フォーマットに対応する場合、この辺りでフォーマットの判定をする
*/
if (!m_pDecoder) {
m_pDecoder = new CAacDecoder();
m_pDecoder->Open();
}
REFERENCE_TIME rtStart, rtEnd;
hr = pIn->GetTime(&rtStart, &rtEnd);
if (FAILED(hr))
rtStart = -1;
if (pIn->IsDiscontinuity() == S_OK) {
m_bDiscontinuity = true;
m_bInputDiscontinuity = true;
} else if (hr == S_OK || hr == VFW_S_NO_STOP_TIME) {
if (!m_bJitterCorrection) {
m_StartTime = rtStart;
} else if (m_StartTime >= 0
&& _abs64(rtStart - m_StartTime) > MAX_JITTER) {
TRACE(TEXT("Resync audio stream time (%lld -> %lld [%f])\n"),
m_StartTime, rtStart,
(double)(rtStart - m_StartTime) / (double)REFERENCE_TIME_SECOND);
m_StartTime = rtStart;
}
}
if (m_StartTime < 0 || m_bDiscontinuity) {
TRACE(TEXT("Initialize audio stream time (%lld)\n"), rtStart);
m_StartTime = rtStart;
}
m_BitRateCalculator.Update(InSize);
}
DWORD InDataPos = 0;
FrameSampleInfo SampleInfo;
SampleInfo.pData = &m_OutData;
hr = S_OK;
while (InDataPos < InSize) {
{
CAutoLock Lock(&m_cPropLock);
CAudioDecoder::DecodeFrameInfo FrameInfo;
const DWORD DataSize = InSize - InDataPos;
DWORD DecodeSize = DataSize;
if (!m_pDecoder->Decode(&pInData[InDataPos], &DecodeSize, &FrameInfo)) {
if (DecodeSize < DataSize) {
InDataPos += DecodeSize;
continue;
}
break;
}
InDataPos += DecodeSize;
if (FrameInfo.bDiscontinuity)
m_bDiscontinuity = true;
SampleInfo.bMediaTypeChanged = false;
hr = OnFrame(FrameInfo.pData, FrameInfo.Samples, FrameInfo.Info,
&SampleInfo);
}
if (SUCCEEDED(hr)) {
if (SampleInfo.bMediaTypeChanged) {
hr = ReconnectOutput(SampleInfo.MediaBufferSize, SampleInfo.MediaType);
if (FAILED(hr))
break;
OutputLog(TEXT("出力メディアタイプを更新します。\r\n"));
hr = m_pOutput->SetMediaType(&SampleInfo.MediaType);
if (FAILED(hr)) {
OutputLog(TEXT("出力メディアタイプを設定できません。(%08x)\r\n"), hr);
break;
}
m_MediaType = SampleInfo.MediaType;
m_bDiscontinuity = true;
m_bInputDiscontinuity = true;
}
IMediaSample *pOutSample = NULL;
hr = m_pOutput->GetDeliveryBuffer(&pOutSample, NULL, NULL, 0);
if (FAILED(hr)) {
OutputLog(TEXT("出力メディアサンプルを取得できません。(%08x)\r\n"), hr);
break;
}
if (SampleInfo.bMediaTypeChanged)
pOutSample->SetMediaType(&m_MediaType);
// 出力ポインタ取得
BYTE *pOutBuff = NULL;
hr = pOutSample->GetPointer(&pOutBuff);
if (FAILED(hr)) {
OutputLog(TEXT("出力サンプルのバッファを取得できません。(%08x)\r\n"), hr);
pOutSample->Release();
break;
}
::CopyMemory(pOutBuff, m_OutData.GetData(), m_OutData.GetSize());
pOutSample->SetActualDataLength(m_OutData.GetSize());
if (m_StartTime >= 0) {
REFERENCE_TIME rtDuration, rtStart, rtEnd;
rtDuration = REFERENCE_TIME_SECOND * (LONGLONG)SampleInfo.Samples / FREQUENCY;
rtStart = m_StartTime;
m_StartTime += rtDuration;
// 音ずれ補正用時間シフト
if (m_DelayAdjustment > 0) {
// 最大2倍まで時間を遅らせる
if (rtDuration >= m_DelayAdjustment) {
rtDuration += m_DelayAdjustment;
m_DelayAdjustment = 0;
} else {
m_DelayAdjustment -= rtDuration;
rtDuration *= 2;
}
} else if (m_DelayAdjustment < 0) {
// 最短1/2まで時間を早める
if (rtDuration >= -m_DelayAdjustment * 2) {
rtDuration += m_DelayAdjustment;
m_DelayAdjustment = 0;
} else {
m_DelayAdjustment += rtDuration;
rtDuration /= 2;
}
} else {
rtStart += m_Delay;
}
rtEnd = rtStart + rtDuration;
pOutSample->SetTime(&rtStart, &rtEnd);
}
pOutSample->SetMediaTime(NULL, NULL);
pOutSample->SetPreroll(FALSE);
#if 0
// Discontinuityを設定すると倍速再生がおかしくなる模様
pOutSample->SetDiscontinuity(m_bDiscontinuity);
#else
pOutSample->SetDiscontinuity(m_bInputDiscontinuity);
#endif
m_bDiscontinuity = false;
m_bInputDiscontinuity = false;
pOutSample->SetSyncPoint(TRUE);
hr = m_pOutput->Deliver(pOutSample);
#ifdef _DEBUG
if (FAILED(hr)) {
OutputLog(TEXT("サンプルを送信できません。(%08x)\r\n"), hr);
if (m_bPassthrough && !m_bPassthroughError) {
m_bPassthroughError = true;
if (m_pEventHandler)
m_pEventHandler->OnSpdifPassthroughError(hr);
}
}
#endif
pOutSample->Release();
if (FAILED(hr))
break;
}
}
return hr;
}
