mirror of
https://github.com/isledecomp/isle-portable.git
synced 2024-11-26 17:36:12 -05:00
428 lines
9.5 KiB
C++
428 lines
9.5 KiB
C++
#include "mxdiskstreamcontroller.h"
|
|
|
|
#include "mxactionnotificationparam.h"
|
|
#include "mxautolocker.h"
|
|
#include "mxdiskstreamprovider.h"
|
|
#include "mxdsstreamingaction.h"
|
|
#include "mxomni.h"
|
|
#include "mxticklemanager.h"
|
|
|
|
DECOMP_SIZE_ASSERT(MxDiskStreamController, 0xc8);
|
|
|
|
// FUNCTION: LEGO1 0x100c7120
|
|
MxDiskStreamController::MxDiskStreamController()
|
|
{
|
|
m_unk0x8c = 0;
|
|
}
|
|
|
|
// FUNCTION: LEGO1 0x100c7530
|
|
MxDiskStreamController::~MxDiskStreamController()
|
|
{
|
|
MxAutoLocker lock(&this->m_criticalSection);
|
|
|
|
m_unk0xc4 = FALSE;
|
|
m_unk0x70 = FALSE;
|
|
|
|
if (m_provider)
|
|
m_provider->VTable0x20(&MxDSAction());
|
|
|
|
MxDSAction* action;
|
|
while (m_unk0x3c.PopFront(action))
|
|
delete action;
|
|
|
|
if (m_provider) {
|
|
delete m_provider;
|
|
m_provider = NULL;
|
|
}
|
|
|
|
FUN_100c8720();
|
|
|
|
while (m_list0x80.PopFront(action))
|
|
FUN_100c7cb0((MxDSStreamingAction*) action);
|
|
|
|
while (m_list0x64.PopFront(action))
|
|
FUN_100c7cb0((MxDSStreamingAction*) action);
|
|
|
|
while (!m_list0x74.empty()) {
|
|
MxDSBuffer* buffer = m_list0x74.front();
|
|
m_list0x74.pop_front();
|
|
FUN_100c7ce0(buffer);
|
|
}
|
|
|
|
TickleManager()->UnregisterClient(this);
|
|
}
|
|
|
|
// FUNCTION: LEGO1 0x100c7790
|
|
MxResult MxDiskStreamController::Open(const char* p_filename)
|
|
{
|
|
MxAutoLocker lock(&this->m_criticalSection);
|
|
MxResult result = MxStreamController::Open(p_filename);
|
|
|
|
if (result == SUCCESS) {
|
|
m_provider = new MxDiskStreamProvider();
|
|
if (m_provider == NULL) {
|
|
result = FAILURE;
|
|
}
|
|
else {
|
|
result = m_provider->SetResourceToGet(this);
|
|
if (result != SUCCESS) {
|
|
delete m_provider;
|
|
m_provider = NULL;
|
|
}
|
|
else {
|
|
TickleManager()->RegisterClient(this, 10);
|
|
}
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
// FUNCTION: LEGO1 0x100c7880
|
|
MxResult MxDiskStreamController::VTable0x18(undefined4, undefined4)
|
|
{
|
|
return SUCCESS;
|
|
}
|
|
|
|
// FUNCTION: LEGO1 0x100c7890
|
|
MxResult MxDiskStreamController::FUN_100c7890(MxDSStreamingAction* p_action)
|
|
{
|
|
MxAutoLocker lock(&this->m_criticalSection);
|
|
if (p_action == NULL) {
|
|
return FAILURE;
|
|
}
|
|
|
|
m_list0x80.push_back(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
|
|
void MxDiskStreamController::FUN_100c7980()
|
|
{
|
|
MxDSBuffer* buffer;
|
|
MxDSStreamingAction* action = NULL;
|
|
|
|
{
|
|
MxAutoLocker lock(&this->m_criticalSection);
|
|
|
|
if (m_unk0x3c.size() && m_unk0x8c < m_provider->GetStreamBuffersNum()) {
|
|
buffer = new MxDSBuffer();
|
|
|
|
if (buffer->AllocateBuffer(m_provider->GetFileSize(), MxDSBufferType_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
|
|
MxDSStreamingAction* MxDiskStreamController::VTable0x28()
|
|
{
|
|
MxAutoLocker lock(&this->m_criticalSection);
|
|
MxDSAction* oldAction;
|
|
MxDSStreamingAction* result = NULL;
|
|
MxU32 filesize = m_provider->GetFileSize();
|
|
|
|
if (m_unk0x3c.PopFront(oldAction)) {
|
|
result = new MxDSStreamingAction((MxDSStreamingAction&) *oldAction);
|
|
if (result) {
|
|
MxU32 offset = result->GetBufferOffset() + filesize;
|
|
((MxDSStreamingAction*) oldAction)->SetUnknown94(offset);
|
|
((MxDSStreamingAction*) oldAction)->SetBufferOffset(offset);
|
|
m_unk0x3c.push_back(oldAction);
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
// FUNCTION: LEGO1 0x100c7c00
|
|
MxResult MxDiskStreamController::VTable0x30(MxDSAction* p_action)
|
|
{
|
|
MxAutoLocker lock(&this->m_criticalSection);
|
|
MxResult result = MxStreamController::VTable0x30(p_action);
|
|
|
|
MxDSStreamingAction* item;
|
|
while (TRUE) {
|
|
item = (MxDSStreamingAction*) m_list0x90.Find(p_action, TRUE);
|
|
if (item == NULL) {
|
|
break;
|
|
}
|
|
FUN_100c7cb0(item);
|
|
}
|
|
|
|
while (TRUE) {
|
|
item = (MxDSStreamingAction*) m_list0x64.Find(p_action, TRUE);
|
|
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 MxDSBufferType_Chunk:
|
|
m_unk0x8c--;
|
|
case MxDSBufferType_Allocate:
|
|
case MxDSBufferType_Unknown:
|
|
delete p_buffer;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// FUNCTION: LEGO1 0x100c7d10
|
|
MxResult MxDiskStreamController::FUN_100c7d10()
|
|
{
|
|
MxAutoLocker lock(&this->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
|
|
MxDSStreamingAction* MxDiskStreamController::FUN_100c7db0()
|
|
{
|
|
MxAutoLocker lock(&this->m_criticalSection);
|
|
|
|
for (MxStreamListMxNextActionDataStart::iterator it = m_nextActionList.begin(); it != m_nextActionList.end();
|
|
it++) {
|
|
MxNextActionDataStart* data = *it;
|
|
for (MxStreamListMxDSAction::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.push_back(data);
|
|
|
|
m_list0x64.erase(it2);
|
|
return streamingAction;
|
|
}
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
// FUNCTION: LEGO1 0x100c7f40
|
|
void MxDiskStreamController::FUN_100c7f40(MxDSStreamingAction* p_streamingaction)
|
|
{
|
|
MxAutoLocker lock(&this->m_criticalSection);
|
|
if (p_streamingaction) {
|
|
m_list0x64.push_back(p_streamingaction);
|
|
}
|
|
}
|
|
|
|
// FUNCTION: LEGO1 0x100c7ff0
|
|
MxResult MxDiskStreamController::VTable0x20(MxDSAction* p_action)
|
|
{
|
|
MxAutoLocker lock(&this->m_criticalSection);
|
|
MxDSStreamingAction* entry =
|
|
(MxDSStreamingAction*) m_list0x80.Find(p_action, FALSE); // 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 0x100c8160
|
|
MxResult MxDiskStreamController::VTable0x24(MxDSAction* p_action)
|
|
{
|
|
MxAutoLocker lock(&this->m_criticalSection);
|
|
if (m_unk0x54.Find(p_action, FALSE) == 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)
|
|
{
|
|
MxAutoLocker lock(&this->m_criticalSection);
|
|
MxDSBuffer* buffer = p_action->GetUnknowna0();
|
|
MxDSStreamingAction* action2 = (MxDSStreamingAction*) m_list0x90.Find(p_action, TRUE);
|
|
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.push_back(action2);
|
|
}
|
|
}
|
|
|
|
FUN_100c7cb0(p_action);
|
|
return SUCCESS;
|
|
}
|
|
|
|
// FUNCTION: LEGO1 0x100c84a0
|
|
void MxDiskStreamController::InsertToList74(MxDSBuffer* p_buffer)
|
|
{
|
|
MxAutoLocker lock(&this->m_criticalSection);
|
|
m_list0x74.push_back(p_buffer);
|
|
}
|
|
|
|
// FUNCTION: LEGO1 0x100c8540
|
|
void MxDiskStreamController::FUN_100c8540()
|
|
{
|
|
MxAutoLocker lock(&this->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
|
|
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)
|
|
{
|
|
MxAutoLocker lock(&this->m_critical9c);
|
|
m_list0xb8.push_back(p_streamingAction);
|
|
}
|
|
|
|
// FUNCTION: LEGO1 0x100c8720
|
|
void MxDiskStreamController::FUN_100c8720()
|
|
{
|
|
MxAutoLocker lock(&this->m_critical9c);
|
|
|
|
MxDSStreamingAction* action;
|
|
while (!m_list0xb8.empty()) {
|
|
action = (MxDSStreamingAction*) m_list0xb8.front();
|
|
m_list0xb8.pop_front();
|
|
|
|
FUN_100c7cb0(action);
|
|
}
|
|
}
|