mirror of
https://github.com/isledecomp/isle.git
synced 2025-10-25 09:24:17 +00:00
491 lines
10 KiB
C++
491 lines
10 KiB
C++
#include "mxdiskstreamcontroller.h"
|
|
|
|
#include "mxactionnotificationparam.h"
|
|
#include "mxautolock.h"
|
|
#include "mxdiskstreamprovider.h"
|
|
#include "mxdsstreamingaction.h"
|
|
#include "mxmisc.h"
|
|
#include "mxomni.h"
|
|
#include "mxticklemanager.h"
|
|
|
|
#include <assert.h>
|
|
|
|
DECOMP_SIZE_ASSERT(MxDiskStreamController, 0xc8);
|
|
|
|
// FUNCTION: LEGO1 0x100c7120
|
|
MxDiskStreamController::MxDiskStreamController()
|
|
{
|
|
m_unk0x8c = 0;
|
|
}
|
|
|
|
// FUNCTION: LEGO1 0x100c7530
|
|
// FUNCTION: BETA10 0x10153a2d
|
|
MxDiskStreamController::~MxDiskStreamController()
|
|
{
|
|
AUTOLOCK(m_criticalSection);
|
|
|
|
m_unk0xc4 = FALSE;
|
|
m_unk0x70 = FALSE;
|
|
|
|
if (m_provider) {
|
|
#ifdef COMPAT_MODE
|
|
{
|
|
MxDSAction action;
|
|
m_provider->VTable0x20(&action);
|
|
}
|
|
#else
|
|
m_provider->VTable0x20(&MxDSAction());
|
|
#endif
|
|
}
|
|
|
|
assert(m_subscribers.size() == 0);
|
|
|
|
MxDSObject* object;
|
|
while (m_unk0x3c.PopFront(object)) {
|
|
delete object;
|
|
}
|
|
|
|
if (m_provider) {
|
|
delete m_provider;
|
|
m_provider = NULL;
|
|
}
|
|
|
|
FUN_100c8720();
|
|
|
|
while (m_list0x80.PopFront(object)) {
|
|
FUN_100c7cb0((MxDSStreamingAction*) object);
|
|
}
|
|
|
|
while (m_list0x64.PopFront(object)) {
|
|
FUN_100c7cb0((MxDSStreamingAction*) object);
|
|
}
|
|
|
|
while (!m_list0x74.empty()) {
|
|
MxDSBuffer* buffer = m_list0x74.front();
|
|
m_list0x74.pop_front();
|
|
FUN_100c7ce0(buffer);
|
|
}
|
|
|
|
TickleManager()->UnregisterClient(this);
|
|
}
|
|
|
|
// FUNCTION: LEGO1 0x100c7790
|
|
// FUNCTION: BETA10 0x10153ea8
|
|
MxResult MxDiskStreamController::Open(const char* p_filename)
|
|
{
|
|
AUTOLOCK(m_criticalSection);
|
|
MxResult result = MxStreamController::Open(p_filename);
|
|
|
|
if (result != SUCCESS) {
|
|
goto done;
|
|
}
|
|
|
|
m_provider = new MxDiskStreamProvider();
|
|
if (m_provider == NULL) {
|
|
result = FAILURE;
|
|
goto done;
|
|
}
|
|
|
|
result = m_provider->SetResourceToGet(this);
|
|
if (result != SUCCESS) {
|
|
delete m_provider;
|
|
m_provider = NULL;
|
|
goto done;
|
|
}
|
|
|
|
TickleManager()->RegisterClient(this, 10);
|
|
|
|
done:
|
|
return result;
|
|
}
|
|
|
|
// FUNCTION: LEGO1 0x100c7880
|
|
MxResult MxDiskStreamController::VTable0x18(undefined4, undefined4)
|
|
{
|
|
return SUCCESS;
|
|
}
|
|
|
|
// FUNCTION: LEGO1 0x100c7890
|
|
// FUNCTION: BETA10 0x101543bb
|
|
MxResult MxDiskStreamController::FUN_100c7890(MxDSStreamingAction* p_action)
|
|
{
|
|
AUTOLOCK(m_criticalSection);
|
|
if (p_action == NULL) {
|
|
return FAILURE;
|
|
}
|
|
|
|
m_list0x80.PushBack(p_action);
|
|
FUN_100c7970();
|
|
return SUCCESS;
|
|
}
|
|
|
|
// FUNCTION: LEGO1 0x100c7960
|
|
MxResult MxDiskStreamController::VTable0x34(undefined4)
|
|
{
|
|
return FAILURE;
|
|
}
|
|
|
|
// FUNCTION: LEGO1 0x100c7970
|
|
void MxDiskStreamController::FUN_100c7970()
|
|
{
|
|
// Empty
|
|
}
|
|
|
|
// FUNCTION: LEGO1 0x100c7980
|
|
// FUNCTION: BETA10 0x10154848
|
|
void MxDiskStreamController::FUN_100c7980()
|
|
{
|
|
MxDSBuffer* buffer;
|
|
MxDSStreamingAction* action = NULL;
|
|
|
|
{
|
|
AUTOLOCK(m_criticalSection);
|
|
|
|
if (m_unk0x3c.size() && m_unk0x8c < m_provider->GetStreamBuffersNum()) {
|
|
buffer = new MxDSBuffer();
|
|
|
|
if (buffer->AllocateBuffer(m_provider->GetFileSize(), MxDSBuffer::e_chunk) != SUCCESS) {
|
|
if (buffer) {
|
|
delete buffer;
|
|
}
|
|
return;
|
|
}
|
|
|
|
action = VTable0x28();
|
|
if (!action) {
|
|
if (buffer) {
|
|
delete buffer;
|
|
}
|
|
return;
|
|
}
|
|
|
|
action->SetUnknowna0(buffer);
|
|
m_unk0x8c++;
|
|
}
|
|
}
|
|
|
|
if (action) {
|
|
((MxDiskStreamProvider*) m_provider)->FUN_100d1780(action);
|
|
}
|
|
}
|
|
|
|
// FUNCTION: LEGO1 0x100c7ac0
|
|
// FUNCTION: BETA10 0x10154abb
|
|
MxDSStreamingAction* MxDiskStreamController::VTable0x28()
|
|
{
|
|
AUTOLOCK(m_criticalSection);
|
|
MxDSObject* oldAction;
|
|
|
|
assert(m_provider);
|
|
MxDSStreamingAction* request = NULL;
|
|
MxU32 filesize = m_provider->GetFileSize();
|
|
|
|
if (!m_unk0x3c.PopFront(oldAction)) {
|
|
goto done;
|
|
}
|
|
|
|
request = new MxDSStreamingAction((MxDSStreamingAction&) *oldAction);
|
|
assert(request);
|
|
|
|
if (!request) {
|
|
goto done;
|
|
}
|
|
|
|
((MxDSStreamingAction*) oldAction)->SetUnknown94(request->GetBufferOffset() + filesize);
|
|
((MxDSStreamingAction*) oldAction)->SetBufferOffset(((MxDSStreamingAction*) oldAction)->GetUnknown94());
|
|
m_unk0x3c.PushBack(oldAction);
|
|
|
|
done:
|
|
return request;
|
|
}
|
|
|
|
// FUNCTION: LEGO1 0x100c7c00
|
|
MxResult MxDiskStreamController::VTable0x30(MxDSAction* p_action)
|
|
{
|
|
AUTOLOCK(m_criticalSection);
|
|
MxResult result = MxStreamController::VTable0x30(p_action);
|
|
|
|
MxDSStreamingAction* item;
|
|
while (TRUE) {
|
|
item = (MxDSStreamingAction*) m_list0x90.FindAndErase(p_action);
|
|
if (item == NULL) {
|
|
break;
|
|
}
|
|
FUN_100c7cb0(item);
|
|
}
|
|
|
|
while (TRUE) {
|
|
item = (MxDSStreamingAction*) m_list0x64.FindAndErase(p_action);
|
|
if (item == NULL) {
|
|
break;
|
|
}
|
|
FUN_100c7cb0(item);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
// FUNCTION: LEGO1 0x100c7cb0
|
|
void MxDiskStreamController::FUN_100c7cb0(MxDSStreamingAction* p_action)
|
|
{
|
|
if (p_action->GetUnknowna0()) {
|
|
FUN_100c7ce0(p_action->GetUnknowna0());
|
|
}
|
|
p_action->SetUnknowna0(NULL);
|
|
delete p_action;
|
|
}
|
|
|
|
// FUNCTION: LEGO1 0x100c7ce0
|
|
void MxDiskStreamController::FUN_100c7ce0(MxDSBuffer* p_buffer)
|
|
{
|
|
switch (p_buffer->GetMode()) {
|
|
case MxDSBuffer::e_chunk:
|
|
m_unk0x8c--;
|
|
case MxDSBuffer::e_allocate:
|
|
case MxDSBuffer::e_unknown:
|
|
delete p_buffer;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// FUNCTION: LEGO1 0x100c7d10
|
|
MxResult MxDiskStreamController::FUN_100c7d10()
|
|
{
|
|
AUTOLOCK(m_criticalSection);
|
|
MxDSStreamingAction* action = FUN_100c7db0();
|
|
|
|
if (!action) {
|
|
return FAILURE;
|
|
}
|
|
|
|
if (FUN_100c8360(action) != SUCCESS) {
|
|
VTable0x24(action);
|
|
FUN_100c7cb0(action);
|
|
return FAILURE;
|
|
}
|
|
|
|
return SUCCESS;
|
|
}
|
|
|
|
// FUNCTION: LEGO1 0x100c7db0
|
|
// FUNCTION: BETA10 0x101551d0
|
|
MxDSStreamingAction* MxDiskStreamController::FUN_100c7db0()
|
|
{
|
|
AUTOLOCK(m_criticalSection);
|
|
|
|
for (MxNextActionDataStartList::iterator it = m_nextActionList.begin(); it != m_nextActionList.end(); it++) {
|
|
MxNextActionDataStart* data = *it;
|
|
|
|
for (MxDSObjectList::iterator it2 = m_list0x64.begin(); it2 != m_list0x64.end(); it2++) {
|
|
MxDSStreamingAction* streamingAction = (MxDSStreamingAction*) *it2;
|
|
|
|
if (streamingAction->GetObjectId() == data->GetObjectId() &&
|
|
streamingAction->GetUnknown24() == data->GetUnknown24() &&
|
|
streamingAction->GetBufferOffset() == data->GetData()) {
|
|
m_nextActionList.erase(it);
|
|
|
|
data->SetData(m_provider->GetFileSize() + data->GetData());
|
|
m_nextActionList.PushBack(data);
|
|
|
|
m_list0x64.erase(it2);
|
|
return streamingAction;
|
|
}
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
// FUNCTION: LEGO1 0x100c7f40
|
|
// FUNCTION: BETA10 0x101553e0
|
|
void MxDiskStreamController::FUN_100c7f40(MxDSStreamingAction* p_streamingaction)
|
|
{
|
|
AUTOLOCK(m_criticalSection);
|
|
if (p_streamingaction) {
|
|
m_list0x64.PushBack(p_streamingaction);
|
|
}
|
|
}
|
|
|
|
// FUNCTION: LEGO1 0x100c7ff0
|
|
// FUNCTION: BETA10 0x10155471
|
|
MxResult MxDiskStreamController::VTable0x20(MxDSAction* p_action)
|
|
{
|
|
AUTOLOCK(m_criticalSection);
|
|
MxDSStreamingAction* entry = (MxDSStreamingAction*) m_list0x80.Find(p_action); // TODO: is this a seperate class?
|
|
|
|
if (entry) {
|
|
MxDSStreamingAction* action = new MxDSStreamingAction(*p_action, 0);
|
|
action->SetUnknown28(entry->GetUnknown28());
|
|
action->SetUnknown84(entry->GetUnknown84());
|
|
action->SetOrigin(entry->GetOrigin());
|
|
action->SetUnknowna0(entry->GetUnknowna4());
|
|
|
|
FUN_100c7f40(action);
|
|
|
|
if (VTable0x2c(p_action, entry->GetUnknown94()) != SUCCESS) {
|
|
return FAILURE;
|
|
}
|
|
}
|
|
else if (MxStreamController::VTable0x20(p_action) != SUCCESS) {
|
|
return FAILURE;
|
|
}
|
|
|
|
m_unk0x70 = TRUE;
|
|
m_unk0xc4 = TRUE;
|
|
return SUCCESS;
|
|
}
|
|
|
|
// FUNCTION: LEGO1 0x100c8120
|
|
void MxDiskStreamController::FUN_100c8120(MxDSAction* p_action)
|
|
{
|
|
VTable0x30(p_action);
|
|
|
|
if (m_provider) {
|
|
m_provider->VTable0x20(p_action);
|
|
}
|
|
|
|
while (TRUE) {
|
|
MxDSObject* found = m_unk0x54.FindAndErase(p_action);
|
|
if (!found) {
|
|
break;
|
|
}
|
|
delete found;
|
|
}
|
|
}
|
|
|
|
// FUNCTION: LEGO1 0x100c8160
|
|
MxResult MxDiskStreamController::VTable0x24(MxDSAction* p_action)
|
|
{
|
|
AUTOLOCK(m_criticalSection);
|
|
if (m_unk0x54.Find(p_action) == NULL) {
|
|
if (VTable0x30(p_action) == SUCCESS) {
|
|
MxOmni::GetInstance()->NotifyCurrentEntity(
|
|
MxEndActionNotificationParam(c_notificationEndAction, NULL, p_action, TRUE)
|
|
);
|
|
}
|
|
}
|
|
|
|
MxDSAction action;
|
|
if (m_provider) {
|
|
m_provider->VTable0x20(p_action);
|
|
}
|
|
|
|
do {
|
|
if (m_action0x60 != NULL) {
|
|
delete m_action0x60;
|
|
m_action0x60 = NULL;
|
|
}
|
|
|
|
action = *p_action;
|
|
MxStreamController::VTable0x24(&action);
|
|
} while (m_action0x60 != NULL);
|
|
|
|
if (m_unk0x3c.empty()) {
|
|
m_unk0x70 = FALSE;
|
|
m_unk0xc4 = FALSE;
|
|
}
|
|
|
|
return SUCCESS;
|
|
}
|
|
|
|
// FUNCTION: LEGO1 0x100c8360
|
|
MxResult MxDiskStreamController::FUN_100c8360(MxDSStreamingAction* p_action)
|
|
{
|
|
AUTOLOCK(m_criticalSection);
|
|
MxDSBuffer* buffer = p_action->GetUnknowna0();
|
|
MxDSStreamingAction* action2 = (MxDSStreamingAction*) m_list0x90.FindAndErase(p_action);
|
|
buffer->FUN_100c6f80(p_action->GetUnknown94() - p_action->GetBufferOffset());
|
|
buffer->FUN_100c67b0(this, p_action, &action2);
|
|
|
|
if (buffer->GetRefCount()) {
|
|
p_action->SetUnknowna0(NULL);
|
|
InsertToList74(buffer);
|
|
}
|
|
|
|
if (action2) {
|
|
if (action2->GetUnknowna0() == NULL) {
|
|
FUN_100c7cb0(action2);
|
|
}
|
|
else {
|
|
if (action2->GetObjectId() == -1) {
|
|
action2->SetObjectId(p_action->GetObjectId());
|
|
}
|
|
|
|
m_list0x90.PushBack(action2);
|
|
}
|
|
}
|
|
|
|
FUN_100c7cb0(p_action);
|
|
return SUCCESS;
|
|
}
|
|
|
|
// FUNCTION: LEGO1 0x100c84a0
|
|
void MxDiskStreamController::InsertToList74(MxDSBuffer* p_buffer)
|
|
{
|
|
AUTOLOCK(m_criticalSection);
|
|
m_list0x74.push_back(p_buffer);
|
|
}
|
|
|
|
// FUNCTION: LEGO1 0x100c8540
|
|
// FUNCTION: BETA10 0x10155a05
|
|
void MxDiskStreamController::FUN_100c8540()
|
|
{
|
|
AUTOLOCK(m_criticalSection);
|
|
for (list<MxDSBuffer*>::iterator it = m_list0x74.begin(); it != m_list0x74.end();) {
|
|
MxDSBuffer* buf = *it;
|
|
if (buf->GetRefCount() == 0) {
|
|
m_list0x74.erase(it++);
|
|
FUN_100c7ce0(buf);
|
|
}
|
|
else {
|
|
it++;
|
|
}
|
|
}
|
|
|
|
if (m_nextActionList.empty()) {
|
|
while (!m_list0x64.empty()) {
|
|
MxDSStreamingAction* action = (MxDSStreamingAction*) m_list0x64.front();
|
|
m_list0x64.pop_front();
|
|
FUN_100c7cb0(action);
|
|
}
|
|
}
|
|
}
|
|
|
|
// FUNCTION: LEGO1 0x100c8640
|
|
// FUNCTION: BETA10 0x10155ba0
|
|
MxResult MxDiskStreamController::Tickle()
|
|
{
|
|
if (m_unk0xc4) {
|
|
FUN_100c7d10();
|
|
}
|
|
|
|
FUN_100c8540();
|
|
FUN_100c8720();
|
|
|
|
if (m_unk0x70) {
|
|
FUN_100c7980();
|
|
}
|
|
|
|
return SUCCESS;
|
|
}
|
|
|
|
// FUNCTION: LEGO1 0x100c8670
|
|
void MxDiskStreamController::FUN_100c8670(MxDSStreamingAction* p_streamingAction)
|
|
{
|
|
AUTOLOCK(m_critical9c);
|
|
m_list0xb8.push_back(p_streamingAction);
|
|
}
|
|
|
|
// FUNCTION: LEGO1 0x100c8720
|
|
void MxDiskStreamController::FUN_100c8720()
|
|
{
|
|
AUTOLOCK(m_critical9c);
|
|
|
|
MxDSStreamingAction* action;
|
|
while (!m_list0xb8.empty()) {
|
|
action = (MxDSStreamingAction*) m_list0xb8.front();
|
|
m_list0xb8.pop_front();
|
|
FUN_100c7cb0(action);
|
|
}
|
|
}
|