void SoundManager::loadSounds(void){
//load default sound effects
if(debug){
std::cout<<"Entered loadSounds()"<<std::endl;
std::cout<<"success:"<<successId<<
", failure:"<<failureId<<
",bounce:"<<bounceId<<
std::endl;
}
if(successId<0){
successId = LoadChunk(SUCCESS.c_str());
}
if(failureId<0){
failureId = LoadChunk(FAILURE.c_str());
}
if(bounceId<0){
bounceId = LoadChunk(BOUNCE.c_str());
}
if(backgroundMusic==NULL){
backgroundMusic=Mix_LoadMUS(BACKGROUND.c_str());
}
if(debug){
std::cout<<"Exiting loadSounds()"<<std::endl;
std::cout<<"success:"<<successId<<
", failure:"<<failureId<<
",bounce:"<<bounceId<<
std::endl;
}
}
void C_Game::InitCubes()
{
_cube = new C_Cube[NB_TYPE_CUBE];
_cube[0].Create(0, 1.002f);
for(int i=1;i<NB_TYPE_CUBE;i++)
_cube[i].Create(i);
_bSelectedCube = false;
for(int i=0;i<10;i++)
_cubeBreakAnim[i].Create(CUBE_BREAK_ANIM0+i, 1.001f);
_frameBreakAnim = CUBE_BREAK_ANIM0;
_boolBreakAnim = false;
/// INIT MAP
for(int i=-(_fogStart/CHUNK_SIZE);i< (_fogStart/CHUNK_SIZE)+1;i++)
{
for(int j=-(_fogStart/CHUNK_SIZE);j < (_fogStart/CHUNK_SIZE)+1;j++)
{
if( !LoadChunk(i, j))
CreateRandomChunk(i, j);
CheckChunksCubesVisibility(i, j);
}
}
_actuelCubeInHand = CUBE_AIR;
_actualChunkX = 0;
_actualChunkY = 0;
}
// For reading the triangle-mesh-data chunk
static bool ReadTrimesh(OpenedFile& OFile, int32 ParentChunkEnd)
{
int32 Location = 0;
OFile.GetPosition(Location);
assert(ModelPtr);
while(Location < ParentChunkEnd)
{
ChunkHeaderData ChunkHeader;
if (!ReadChunkHeader(OFile,ChunkHeader)) return false;
switch(ChunkHeader.ID)
{
case VERTICES:
if (!LoadChunk(OFile,ChunkHeader)) return false;
LoadVertices();
break;
case TXTR_COORDS:
if (!LoadChunk(OFile,ChunkHeader)) return false;
LoadTextureCoordinates();
break;
case FACE_DATA:
if (!ReadContainer(OFile,ChunkHeader,ReadFaceData)) return false;
break;
default:
if (!SkipChunk(OFile,ChunkHeader)) return false;
}
// Where are we now?
OFile.GetPosition(Location);
}
if (Location > ParentChunkEnd)
{
if (DBOut)
fprintf(DBOut,"ERROR: Overran parent chunk: %ld > %ld\n",Location,ParentChunkEnd);
return false;
}
return true;
}
/*
** load one chunk from a file or buffer
** return main if ok and NULL at EOF
*/
Proto* luaU_undump (lua_State* L, ZIO* Z)
{
Proto* tf=NULL;
int c=zgetc(Z);
if (c==ID_CHUNK)
tf=LoadChunk(L,Z);
c=zgetc(Z);
if (c!=EOZ)
luaO_verror(L,"`%.99s' apparently contains more than one chunk",ZNAME(Z));
return tf;
}
bool cWorldStorage::LoadOneChunk(void)
{
cChunkCoords ToLoad(0, 0);
bool ShouldLoad = m_LoadQueue.TryDequeueItem(ToLoad);
if (ShouldLoad)
{
return LoadChunk(ToLoad.m_ChunkX, ToLoad.m_ChunkZ);
}
return false;
}
int main(int argc, char** argv) {
try{
auto lua = std::make_shared<Lunar::Lua>();
lua->LoadChunk("print('\\tHello from Lua!')");
std::cout << "Lua says: " << lua->Exec<std::string>() << std::endl;
lua->LoadChunk("return string.upper('Hello!')");
std::cout << "Lua says: " << lua->Exec<std::string>() << std::endl;
lua->LoadChunk("function dots(x) return string.rep('.', x) end");
std::cout << "Lua says: " << lua->Exec<std::string>("dots", [&lua]() {
lua->Push(42);
return 1;
})
<< std::endl;
lua->LoadChunk("function mul(a, b) return a * b end");
std::cout << "Lua says: " << lua->Exec<std::string>("mul", [&lua]() {
lua->Push(3.0);
lua->Push(5.0);
return 2;
})
<< std::endl;
lua->Register("cmul", Lunar::LunarExports::Cmul);
lua->LoadFile("bootstraper.lua");
std::cout << "Lua says: " << lua->Exec<std::string>("l_bootstrap")
<< std::endl;
}
catch(std::exception & e) {
std::cout << "Exception: " << e.what() << std::endl;
}
return EXIT_SUCCESS;
}
/*
** load precompiled chunk
*/
Proto* luaU_undump (lua_State* L, ZIO* Z, Mbuffer* buff)
{
LoadState S;
const char* s=zname(Z);
if (*s=='@' || *s=='=')
S.name=s+1;
else if (*s==LUA_SIGNATURE[0])
S.name="binary string";
else
S.name=s;
S.L=L;
S.Z=Z;
S.b=buff;
return LoadChunk(&S);
}
bool cWorldStorage::LoadOneChunk(void)
{
sChunkLoad ToLoad(0, 0, 0, false);
bool ShouldLoad = m_LoadQueue.TryDequeueItem(ToLoad);
if (ShouldLoad && !LoadChunk(ToLoad.m_ChunkX, ToLoad.m_ChunkY, ToLoad.m_ChunkZ))
{
if (ToLoad.m_Generate)
{
// The chunk couldn't be loaded, generate it:
m_World->GetGenerator().QueueGenerateChunk(ToLoad.m_ChunkX, ToLoad.m_ChunkY, ToLoad.m_ChunkZ);
}
else
{
// TODO: Notify the world that the load has failed:
// m_World->ChunkLoadFailed(ToLoad.m_ChunkX, ToLoad.m_ChunkY, ToLoad.m_ChunkZ);
}
}
return ShouldLoad;
}
bool cWorldStorage::LoadOneChunk(void)
{
// Dequeue an item, bail out if there's none left:
cChunkCoordsWithCallback ToLoad(0, 0, nullptr);
bool ShouldLoad = m_LoadQueue.TryDequeueItem(ToLoad);
if (!ShouldLoad)
{
return false;
}
// Load the chunk:
bool res = LoadChunk(ToLoad.m_ChunkX, ToLoad.m_ChunkZ);
// Call the callback, if specified:
if (ToLoad.m_Callback != nullptr)
{
ToLoad.m_Callback->Call(ToLoad.m_ChunkX, ToLoad.m_ChunkZ);
}
return res;
}
bool LuaFile::LoadAndExecute(lua_State* luaState)
{
if (hasExecuted_)
return true;
if (!LoadChunk(luaState))
return false;
int top = lua_gettop(luaState);
if (lua_pcall(luaState, 0, 0, 0))
{
const char* message = lua_tostring(luaState, -1);
LOGERROR("Lua Execute failed for " + GetName() + ": " + String(message));
lua_settop(luaState, top);
return false;
}
hasExecuted_ = true;
return true;
}
void Composite::Serialize(Archive * pArchv)
{
pArchv->Transfer(m_idData);
if (pArchv->m_bIsLoading)
{
DeleteAllChildren();
while (pArchv->GetSize())
{
Chunk * pChunk = LoadChunk(pArchv);
InsertChildLast(pChunk);
pChunk->Release();
}
}
else
{
for (ChildNode * pNode = m_pFirst; pNode; pNode = GetNextChild(pNode))
{
pNode->GetChunk()->Write(pArchv);
}
}
}
void C_Game::Run() // Thread Function !
{
while(continuer)
{
Vector3D v = _cam->getPosition();
int a = v.X / CHUNK_SIZE;
int b = v.Y / CHUNK_SIZE;
int marge = (_fogStart / CHUNK_SIZE) + 1;
if(v.X < 0) a--;
if(v.Y < 0) b--;
if(_actualChunkX != a)
{
if( (_actualChunkX - a) > 0)
{
for(int i=b-marge; i<b+marge+1; i++)
{
if(!LoadChunk(_actualChunkX-marge, i)) //If the chunk can't be founded in the save
CreateRandomChunk(_actualChunkX-marge, i); // A random chunk is created
CheckChunksCubesVisibility(_actualChunkX-marge, i);
DeleteChunkFromMemory(_actualChunkX+marge, i); // Delete the chunk which is too far to be displayed
}
}
else
{
for(int i=b-marge; i<b+marge+1; i++)
{
if(!LoadChunk(_actualChunkX+marge, i))
CreateRandomChunk(_actualChunkX+marge, i);
CheckChunksCubesVisibility(_actualChunkX+marge, i);
DeleteChunkFromMemory(_actualChunkX-marge, i);
}
}
}
if(_actualChunkY != b)
{
if( (_actualChunkY - b) > 0)
{
for(int i=a-marge; i<a+marge+1; i++)
{
if(!LoadChunk(i, _actualChunkY-marge))
CreateRandomChunk(i, _actualChunkY-marge);
CheckChunksCubesVisibility(i, _actualChunkY-marge);
DeleteChunkFromMemory(i, _actualChunkY+marge);
}
}
else
{
for(int i=a-marge; i<a+marge+1; i++)
{
if(!LoadChunk(i, _actualChunkY+marge))
CreateRandomChunk(i, _actualChunkY+marge);
CheckChunksCubesVisibility(i, _actualChunkY+marge);
DeleteChunkFromMemory(i, _actualChunkY-marge);
}
}
}
_actualChunkX = a;
_actualChunkY = b;
}
}
// _type: 0=Post-Fader (Post-Pan), 1=Pre-FX, 2=deprecated, 3=Pre-Fader (Post-FX)
// _undoMsg: NULL=no undo
bool CueBuss(const char* _undoMsg, const char* _busName, int _type, bool _showRouting,
int _soloDefeat, char* _trTemplatePath, bool _sendToMaster, int* _hwOuts)
{
if (!SNM_CountSelectedTracks(NULL, false))
return false;
WDL_FastString tmplt;
if (_trTemplatePath && (!FileOrDirExists(_trTemplatePath) || !LoadChunk(_trTemplatePath, &tmplt) || !tmplt.GetLength()))
{
char msg[SNM_MAX_PATH] = "";
lstrcpyn(msg, __LOCALIZE("Cue buss not created!\nNo track template file defined","sws_DLG_149"), sizeof(msg));
if (*_trTemplatePath)
_snprintfSafe(msg, sizeof(msg), __LOCALIZE_VERFMT("Cue buss not created!\nTrack template not found (or empty): %s","sws_DLG_149"), _trTemplatePath);
MessageBox(GetMainHwnd(), msg, __LOCALIZE("S&M - Error","sws_DLG_149"), MB_OK);
return false;
}
bool updated = false;
MediaTrack * cueTr = NULL;
SNM_SendPatcher* p = NULL;
for (int i=1; i <= GetNumTracks(); i++) // skip master
{
MediaTrack* tr = CSurf_TrackFromID(i, false);
if (tr && *(int*)GetSetMediaTrackInfo(tr, "I_SELECTED", NULL))
{
GetSetMediaTrackInfo(tr, "I_SELECTED", &g_i0);
// add the buss track, done once!
if (!cueTr)
{
InsertTrackAtIndex(GetNumTracks(), false);
TrackList_AdjustWindows(false);
cueTr = CSurf_TrackFromID(GetNumTracks(), false);
GetSetMediaTrackInfo(cueTr, "P_NAME", (void*)_busName);
p = new SNM_SendPatcher(cueTr);
if (tmplt.GetLength())
{
WDL_FastString chunk;
MakeSingleTrackTemplateChunk(&tmplt, &chunk, true, true, false);
ApplyTrackTemplate(cueTr, &chunk, false, false, p);
}
updated = true;
}
// add a send
if (cueTr && p && tr != cueTr)
AddReceiveWithVolPan(tr, cueTr, _type, p);
}
}
if (cueTr && p)
{
// send to master/parent init
if (!tmplt.GetLength())
{
// solo defeat
if (_soloDefeat) {
char one[2] = "1";
updated |= (p->ParsePatch(SNM_SET_CHUNK_CHAR, 1, "TRACK", "MUTESOLO", 0, 3, one) > 0);
}
// master/parend send
WDL_FastString mainSend;
mainSend.SetFormatted(SNM_MAX_CHUNK_LINE_LENGTH, "MAINSEND %d 0", _sendToMaster?1:0);
// adds hw outputs
if (_hwOuts)
{
int monoHWCount=0;
while (GetOutputChannelName(monoHWCount)) monoHWCount++;
bool cr = false;
for(int i=0; i<SNM_MAX_HW_OUTS; i++)
{
if (_hwOuts[i])
{
if (!cr) {
mainSend.Append("\n");
cr = true;
}
if (_hwOuts[i] >= monoHWCount)
mainSend.AppendFormatted(32, "HWOUT %d ", (_hwOuts[i]-monoHWCount) | 1024);
else
mainSend.AppendFormatted(32, "HWOUT %d ", _hwOuts[i]-1);
mainSend.Append("0 ");
mainSend.AppendFormatted(20, "%.14f ", *(double*)GetConfigVar("defhwvol"));
mainSend.Append("0.00000000000000 0 0 0 -1.00000000000000 -1\n");
}
}
if (!cr)
mainSend.Append("\n"); // hot
}
// patch both updates (no break keyword here: new empty track)
updated |= p->ReplaceLine("TRACK", "MAINSEND", 1, 0, mainSend.Get());
}
p->Commit();
delete p;
if (updated)
{
GetSetMediaTrackInfo(cueTr, "I_SELECTED", &g_i1);
UpdateTimeline();
ScrollSelTrack(true, true);
if (_showRouting)
Main_OnCommand(40293, 0);
if (_undoMsg)
Undo_OnStateChangeEx2(NULL, _undoMsg, UNDO_STATE_ALL, -1);
}
}
return updated;
}
bool DataPipe::Move(const vector3di shf)
{
vector3di rgp;
//Check shift vector first
if ( (abs(shf.X) > 1) || (abs(shf.Y) > 1) || (abs(shf.Z) > 1) )
return false;
#ifdef DPDEBUG
dbg_print("[DP] Move(): shift = [%d %d %d]",shf.X,shf.Y,shf.Z);
#endif
rgp = GP + shf;
if (rgp.Z == 0) {
//TODO: Z-thru
}
if (wgen)
wgen->WrapCoords(&rgp);
#if HOLDCHUNKS == 1
SetGP(rgp);
return true;
#else /* 9, 18, 27 */
int l,nl,x,y,z,nx,ny;
PChunk swa;
SChunkState swb;
#if HOLDCHUNKS == 9
if (shf.Z) {
SetGP(GP+shf);
return true;
}
#else /* 18, 27 */
int nz;
#if HOLDCHUNKS == 18
if (shf.Z > 0) {
SetGP(GP+shf);
return true;
}
#endif
#endif
//Lock everything
WriteLock();
status = DPIPE_BUSY;
GP = rgp;
//Swap remaining chunks and mark new ones
for (x = 0; x < 3; x++) {
for (y = 0; y < 3; y++) {
#if HOLDCHUNKS == 18
for (z = 0; z < 2; z++) {
#else
for (z = 0; z < 3; z++) {
#endif
nx = (shf.X < 0)? 2-x:x;
ny = (shf.Y < 0)? 2-y:y;
#if HOLDCHUNKS > 9
#if HOLDCHUNKS == 27
nz = (shf.Z < 0)? 2-z:z;
#else
nz = (shf.Z < 0)? 1-z:z;
#endif
l = nz * 9 + ny * 3 + nx;
nl = (nz + shf.Z) * 9 + (ny + shf.Y) * 3 + nx + shf.X;
#else
l = ny * 3 + nx;
nl = (ny + shf.Y) * 3 + nx + shf.X;
#endif /* 9 chunks */
if ( ((shf.X > 0) && (nx > 1)) ||
((shf.X < 0) && (nx < 1)) ||
((shf.Y > 0) && (ny > 1)) ||
((shf.Y < 0) && (ny < 1)) ||
#if HOLDCHUNKS > 9
((shf.Z > 0) && (nz > 1)) ||
((shf.Z < 0) && (nz < 1)) ||
#endif
(nl < 0) || (nl >= HOLDCHUNKS)) {
//new chunk
chstat[l].s = DPCHK_QUEUE;
#ifdef DPDEBUG
dbg_print("[DP] Marking chunk %d",l);
#endif
continue;
}
#ifdef DPDEBUG
dbg_print("[DP] Swapping chunks %d <-> %d",l,nl);
#endif
//swap chunks
swa = chunks[l];
chunks[l] = chunks[nl];
chunks[nl] = swa;
swb = chstat[l];
chstat[l] = chstat[nl];
chstat[nl] = swb;
}
}
}
//Update models root
UpdateModelsSceneRoot();
//Release everything
status = DPIPE_IDLE;
WriteUnlock();
return true;
#endif
}
void DataPipe::ChunkQueue()
{
if (status != DPIPE_IDLE) return;
#if HOLDCHUNKS == 1
/* Do nothing */
return;
#else
vector3di cur;
bool fnd = false;
unsigned l;
/* Apply soft-lock to not interfere with rendering
* while time-consuming loading or generation is
* processing.
*/
ReadLock();
#if HOLDCHUNKS == 9
int i,j;
cur.Z = GP.Z;
for (i = -1, l = 0; i < 2; i++) {
cur.Y = GP.Y + i;
for (j = -1; j < 2; j++, l++) {
cur.X = GP.X + j;
if (chstat[l].s == DPCHK_QUEUE) {
fnd = true;
goto chunk_found;
}
}
}
#elif HOLDCHUNKS == 18
int i,j,k;
for (i = -1, l = 0; i <= 0; i++) {
cur.Z = GP.Z + i;
for (j = -1; j < 2; j++) {
cur.Y = GP.Y + j;
for (k = -1; k < 2; k++, l++) {
cur.X = GP.X + k;
if (chstat[l].s == DPCHK_QUEUE) {
fnd = true;
goto chunk_found;
}
}
}
}
#elif HOLDCHUNKS == 27
int i,j,k;
for (i = -1, l = 0; i < 2; i++) {
cur.Z = GP.Z + i;
for (j = -1; j < 2; j++) {
cur.Y = GP.Y + j;
for (k = -1; k < 2; k++, l++) {
cur.X = GP.X + k;
if (chstat[l].s == DPCHK_QUEUE) {
fnd = true;
goto chunk_found;
}
}
}
}
#endif
chunk_found:
if (fnd) {
chstat[l].s = DPCHK_LOADING;
MakeChunk(l,cur);
}
ReadUnlock();
#endif
}
void DataPipe::MakeChunk(const unsigned l, const vector3di pos)
{
SDataPlacement plc;
if (chstat[l].changed) SaveChunk(l);
if (!FindChunk(pos,&plc)) {
if (wgen) {
wgen->GenerateChunk(chunks[l],pos);
chstat[l].s = DPCHK_READY;
chstat[l].pos = pos.ToSimVecInt();
#ifdef DPDEBUG
dbg_print("[DP] Chunk %u generated at [%d %d %d]",l,pos.X,pos.Y,pos.Z);
#endif
} else {
chstat[l].s = DPCHK_ERROR;
chstat[l].changed = false;
#ifdef DPDEBUG
dbg_print("[DP] No WorldGen instance to generate chunk at [%d %d %d]",l,pos.X,pos.Y,pos.Z);
#endif
}
} else if (!LoadChunk(&plc,chunks[l])) {
chstat[l].s = DPCHK_ERROR;
chstat[l].changed = false;
#ifdef DPDEBUG
dbg_print("[DP] Error loading chunk %u at [%d %d %d]",l,pos.X,pos.Y,pos.Z);
#endif
} else {
chstat[l].s = DPCHK_READY;
chstat[l].pos = pos.ToSimVecInt();
#ifdef DPDEBUG
dbg_print("[DP] Chunk %u loaded at [%d %d %d]",l,pos.X,pos.Y,pos.Z);
#endif
}
}
void JVideoServer::Init()
{return;
memset( &m_StreamState, 0, sizeof( m_StreamState ) );
memset( &m_SyncState, 0, sizeof( m_SyncState ) );
memset( &m_Page, 0, sizeof( m_Page ) );
memset( &m_Packet, 0, sizeof( m_Packet ) );
memset( &m_Comment, 0, sizeof( m_Comment ) );
memset( &m_Info, 0, sizeof( m_Info ) );
memset( &m_State, 0, sizeof( m_State ) );
memset( &m_YUVBuffer, 0, sizeof( m_YUVBuffer ) );
ogg_stream_clear( &m_StreamState );
ogg_sync_init( &m_SyncState );
theora_comment_init( &m_Comment );
theora_info_init( &m_Info );
// теперь ищем начало логического потока theora
bool bStartHeader = true;
int nHeaderPackets = 0; // число обработанных пакетов заголовков theora
do
{
if (LoadChunk( m_File, &m_SyncState ) ==0)
{
// кончился файл, на данном этапе это ошибка
assert( "!eof searched, terminate...");
}
// ogg_sync_pageout - формирует страницу
while (ogg_sync_pageout( &m_SyncState, &m_Page ) > 0)
// 1-больше данных не требуется
// 0-требуется больше данных для создания страницы
{
// что страница сформирована успешно
// это страница заголовков? если нет, кончаем искать заголовки
if (ogg_page_bos( &m_Page ) == false)
{
// нет, это не страница заголовков
// значит, страницы заголовков всех логических потоков кончились
// и начались данные этих потоков
// таким образом надо переходить к чтению страниц данных
// закидываем эту страничку в логический видеопоток
PushPage( &m_Page );
// PushPage - закидывает страничку
// в логический поток theora, если
// совпадает идентификатор логического потока
// в противном случае страница игнорируется
// выходим из циклов
bStartHeader = false;
break;
}
else
{
// да, это страница заголовков
// тестовый логический поток
ogg_stream_state m_StreamStateTest;
memset(&m_StreamStateTest, 0x00, sizeof(ogg_stream_state));
// инициализируем тестовый поток на тот же поток с таким же
// идентификатором потока, как и у текущей странички
if(0!= ogg_stream_init(&m_StreamStateTest,ogg_page_serialno(&m_Page)) )
assert( "!error during ogg_stream_init");
// добавляем страницу в тестовый поток
if(0!= ogg_stream_pagein(&m_StreamStateTest,&m_Page) )
assert( "!error during ogg_stream_pagein");
// декодируем данные из этого тестового потока в пакет
if( ogg_stream_packetout(&m_StreamStateTest,&m_Packet) ==-1)
assert( "!error during ogg_stream_packetout");
// nHeaderPackets - число прочитанных
// заголовочных ПАКЕТОВ theora (не страниц)
// по спецификации theora таких пакетов должно быть три
if(nHeaderPackets==0)
{
int dhr = theora_decode_header (&m_Info, &m_Comment, &m_Packet);
// декодируем заголовок theora
if(dhr<0)
{
// это не заголовок theora
// очищаем структуру тестового потока
ogg_stream_clear(&m_StreamStateTest);
//и продолжаем цикл в поисках заголовков theora
}
else
{
// это заголовок theora!
// вот таким образом "инициализируем" логический поток theora:
memcpy(&m_StreamState, &m_StreamStateTest,
sizeof(m_StreamStateTest));
// теперь из этого потока будут всегда сыпаться пакеты theora
nHeaderPackets++;
// после того, как мы нашли заголовочную страницу логического потока theora,
// нам необходимо прочитать все остальные заголовочные страницы
// других потоков и отбросить их (если таковые, конечно, имеются)
}
}
}
}
}
while (bStartHeader);
// сейчас надо получить еще два пакета заголовков theora (см. её документацию)
// и можно переходить к потоковому воспроизведению
while(nHeaderPackets<3)
{
int result=ogg_stream_packetout(&m_StreamState,&m_Packet);
// если функция возвращает нуль, значит не хватает данных для декодирования
// почему то этого НЕТ в спецификации libogg, или я плохо искал
if (result < 0)
{
// ошибка декодирования, поврежденный поток
assert( "!error during ogg_stream_packetout");
}
if (result > 0)
{
// удалось успешно извлечь пакет информации theora
int result2 = theora_decode_header( &m_Info, &m_Comment, &m_Packet );
if(result2<0)
{
// ошибка декодирования, поврежденный поток
rlog.err("VIDEO: error during theora_decode_header (corrupt stream)");
}
++nHeaderPackets;
}
// эту страничку обработали, надо извлечь новую
// для этого проверяем буфер чтения, вдруг там осталось что-нить похожее
// на страничку. Если не осталось, тогда просто читаем эти данные из файла:
if (ogg_sync_pageout( &m_SyncState, &m_Page ) > 0)
// ogg_sync_pageout - функция, берет данные из буфера приема ogg
// и записывает их в ogg_page
{
//мы нашли страничку в буфере и...
PushPage( &m_Page );
// ...пихаем эти данные в подходящий поток
}
else
{
// ничего мы в буфере не нашли
int ret = LoadChunk( m_File, &m_SyncState );
// надо больше данных! читаем их из файла
if (ret == 0)
{
// опять файл кончился!
rlog.err("VIDEO: eof searched. terminate...");
}
}
}
// init videostream
theora_decode_init( &m_State, &m_Info );
switch(m_Info.colorspace)
{
case OC_CS_UNSPECIFIED:
// nothing to report
break;
case OC_CS_ITU_REC_470M:
rlog.msg("Encoder specified ITU Rec 470M (NTSC) color.");
// выводим в лог информацию о цветовом пространстве
break;
case OC_CS_ITU_REC_470BG:
rlog.msg("Encoder specified ITU Rec 470BG (PAL) color.");
break;
default:
rlog.msg("Warning: encoder specified unknown colorspace.");
break;
}
// theora processing...
while (ogg_stream_packetout( &m_StreamState, &m_Packet ) <= 0)
{
// не хватает данных в логическом потоке theora
// надо надергать данных из физического потока и затолкать их в логический поток
// читаем данные из файла
int ret = LoadChunk( m_File, &m_SyncState );
if (ret == 0)
{
// файл кончился, необходимо выполнить закрывающие действия
// и выйти из приложения
TheoraClose();
return;
}
while (ogg_sync_pageout( &m_SyncState, &m_Page ) > 0)
// декодируем данные из буфера в страницы (ogg_page)
// пока они не кончатся в буфере
{
// пихаем эти страницы в соотв. логические потоки
PushPage( &m_Page );
}
}
// удачно декодировали. в пакете содержится декодированная ogg-информация
// (то бишь закодированная theora-информация)
// загружаем пакет в декодер theora
if (theora_decode_packetin(&m_State,&m_Packet) == OC_BADPACKET)
{
// ошибка декодирования
rlog.err( "error during theora_decode_packetin..." );
}
// все данные получены, готовим кадр
// декодируем страничку в YUV-виде в спец. структуру yuv_buffer
if (theora_decode_YUVout( &m_State, &m_YUVBuffer ) != 0)
{
// ошибка декодирования
rlog.err( "error during theora_decode_YUVout...");
}
// если это первый кадр, то создаем буфер кадра
BYTE* frame = new BYTE[m_YUVBuffer.y_height*m_YUVBuffer.y_width*4];
// yuv to rgb
for (int cy = 0; cy < m_YUVBuffer.y_height; cy++)
{
int nYShift = m_YUVBuffer.y_stride*cy;
int nUVShift = m_YUVBuffer.uv_stride*(cy >> 1);
for (int cx = 0; cx < m_YUVBuffer.y_width; cx++)
{
int nHX = (cx >> 1);
BYTE nY = *(BYTE*)(m_YUVBuffer.y + nYShift + cx );
BYTE nU = *(BYTE*)(m_YUVBuffer.u + nUVShift + nHX );
BYTE nV = *(BYTE*)(m_YUVBuffer.v + nUVShift + nHX );
int index = (cy*m_YUVBuffer.y_width + cx)*4;
float r = nY + 1.371f*(nV - 128);
float g = nY - 0.698f*(nV - 128) - 0.336f*(nU - 128);
float b = nY + 1.732f*(nU - 128);
frame[index + 0] = (BYTE)clamp( r, 0.0f, 255.0f );
frame[index + 1] = (BYTE)clamp( g, 0.0f, 255.0f );
frame[index + 2] = (BYTE)clamp( b, 0.0f, 255.0f );
frame[index + 3] = 255;
}
}
} // JVideoServer::Init
void Context::LoadFile(const std::string &filename)
{
LoadChunk(filename);
}
void Context::LoadString(const std::string &program)
{
LoadChunk(program, false);
}
// Construct chunk from filename
// Negative duration if invalid
SndEffect::SndEffect(std::string name):
m_Chunk(LoadChunk(name)),
m_fDuration(GetChunkDur(m_Chunk.get()))
{}
