mxstreamer.cpp

Go to the documentation of this file.

#include "mxstreamer.h"
 
#include "mxdebug.h"
#include "mxdiskstreamcontroller.h"
#include "mxdsaction.h"
#include "mxmisc.h"
#include "mxnotificationmanager.h"
#include "mxramstreamcontroller.h"
 
#include <algorithm>
#include <assert.h>
 
DECOMP_SIZE_ASSERT(MxStreamer, 0x2c);
DECOMP_SIZE_ASSERT(MxMemoryPool64, 0x0c);
DECOMP_SIZE_ASSERT(MxMemoryPool128, 0x0c);
DECOMP_SIZE_ASSERT(MxBitset<22>, 0x04);
DECOMP_SIZE_ASSERT(MxBitset<2>, 0x04);
 
// FUNCTION: LEGO1 0x100b8f00
// FUNCTION: BETA10 0x10145150
MxStreamer::MxStreamer()
{
    NotificationManager()->Register(this);
}
 
// FUNCTION: LEGO1 0x100b9190
// FUNCTION: BETA10 0x10145220
MxResult MxStreamer::Create()
{
    if (m_pool64.Allocate() || m_pool128.Allocate()) {
        return FAILURE;
    }
 
    return SUCCESS;
}
 
// FUNCTION: LEGO1 0x100b91d0
// FUNCTION: BETA10 0x10145268
MxStreamer::~MxStreamer()
{
    while (!m_controllers.empty()) {
        MxStreamController* controller = m_controllers.front();
 
#ifdef COMPAT_MODE
        {
            MxDSAction action;
            assert(controller->IsStoped(&action));
        }
#else
        assert(controller->IsStoped(&MxDSAction()));
#endif
 
        m_controllers.pop_front();
        delete controller;
    }
 
    NotificationManager()->Unregister(this);
}
 
// FUNCTION: LEGO1 0x100b92c0
// FUNCTION: BETA10 0x1014542d
MxStreamController* MxStreamer::Open(const char* p_name, MxU16 p_lookupType)
{
    MxTrace("Open %s as %s controller\n", p_name, !p_lookupType ? "disk" : "RAM");
    MxTrace("Heap before: %d\n", DebugHeapState());
 
    MxStreamController* stream = NULL;
 
    if (GetOpenStream(p_name)) {
        goto done;
    }
 
    switch (p_lookupType) {
    case e_diskStream:
        stream = new MxDiskStreamController();
        break;
    case e_RAMStream:
        stream = new MxRAMStreamController();
        break;
    }
 
    if (stream == NULL) {
        goto done;
    }
 
    if (stream->Open(p_name) != SUCCESS || AddStreamControllerToOpenList(stream) != SUCCESS) {
        delete stream;
        stream = NULL;
    }
 
done:
    MxTrace("Heap after: %d\n", DebugHeapState());
    return stream;
}
 
// FUNCTION: LEGO1 0x100b9570
// FUNCTION: BETA10 0x10145638
MxLong MxStreamer::Close(const char* p_name)
{
    MxDSAction ds;
    ds.SetUnknown24(-2);
 
    for (list<MxStreamController*>::iterator it = m_controllers.begin(); it != m_controllers.end(); it++) {
        MxStreamController* c = *it;
 
        if (!p_name || c->GetAtom() == p_name) {
            m_controllers.erase(it);
 
            if (c->IsStoped(&ds)) {
                delete c;
            }
            else {
                NotificationManager()->Send(this, MxStreamerNotification(c_notificationStreamer, NULL, c));
            }
 
            return SUCCESS;
        }
    }
 
    return FAILURE;
}
 
// FUNCTION: LEGO1 0x100b9700
// FUNCTION: BETA10 0x10146ed0
MxNotificationParam* MxStreamerNotification::Clone() const
{
    return new MxStreamerNotification(m_type, m_sender, m_controller);
}
 
// FUNCTION: LEGO1 0x100b9870
// FUNCTION: BETA10 0x1014584b
MxStreamController* MxStreamer::GetOpenStream(const char* p_name)
{
    for (list<MxStreamController*>::iterator it = m_controllers.begin(); it != m_controllers.end(); it++) {
        if ((*it)->GetAtom() == p_name) {
            return *it;
        }
    }
 
    return NULL;
}
 
// FUNCTION: LEGO1 0x100b98f0
void MxStreamer::FUN_100b98f0(MxDSAction* p_action)
{
    MxStreamController* controller = GetOpenStream(p_action->GetAtomId().GetInternal());
    if (controller && controller->IsA("MxDiskStreamController")) {
        ((MxDiskStreamController*) controller)->FUN_100c8120(p_action);
    }
}
 
// FUNCTION: LEGO1 0x100b9930
// FUNCTION: BETA10 0x101458e5
MxResult MxStreamer::AddStreamControllerToOpenList(MxStreamController* p_stream)
{
    list<MxStreamController*>::iterator i = find(m_controllers.begin(), m_controllers.end(), p_stream);
 
    assert(i == m_controllers.end());
 
    // DECOMP: Retail is missing the optimization that skips this check if find() reaches the end.
    if (i == m_controllers.end()) {
        m_controllers.push_back(p_stream);
        return SUCCESS;
    }
 
    return FAILURE;
}
 
// FUNCTION: LEGO1 0x100b99b0
// FUNCTION: BETA10 0x101459ad
MxResult MxStreamer::FUN_100b99b0(MxDSAction* p_action)
{
    // TODO: MxAtomId operator== used here for NULL test. BETA10 0x1007dc20
    if (p_action == NULL || p_action->GetAtomId().GetInternal() == NULL || p_action->GetObjectId() == -1) {
        return FAILURE;
    }
 
    MxStreamController* controller = GetOpenStream(p_action->GetAtomId().GetInternal());
    if (controller == NULL) {
        return FAILURE;
    }
 
    return controller->VTable0x20(p_action);
}
 
// FUNCTION: LEGO1 0x100b99f0
// FUNCTION: BETA10 0x10145a54
MxResult MxStreamer::DeleteObject(MxDSAction* p_dsAction)
{
    MxDSAction tempAction;
 
    if (p_dsAction) {
        tempAction.SetObjectId(p_dsAction->GetObjectId());
        tempAction.SetAtomId(p_dsAction->GetAtomId());
        tempAction.SetUnknown24(p_dsAction->GetUnknown24());
    }
    else {
        tempAction.SetUnknown24(-2);
    }
 
    MxResult result = FAILURE;
    for (list<MxStreamController*>::iterator it = m_controllers.begin(); it != m_controllers.end(); it++) {
        // TODO: MxAtomId operator== used here for NULL test. BETA10 0x1007dc20
        if (p_dsAction->GetAtomId().GetInternal() == NULL || p_dsAction->GetAtomId() == (*it)->GetAtom()) {
            tempAction.SetAtomId((*it)->GetAtom());
            result = (*it)->VTable0x24(&tempAction);
        }
    }
 
    return result;
}
 
// FUNCTION: LEGO1 0x100b9b30
// FUNCTION: BETA10 0x10145d01
MxBool MxStreamer::FUN_100b9b30(MxDSObject& p_dsObject)
{
    MxStreamController* controller = GetOpenStream(p_dsObject.GetAtomId().GetInternal());
    if (controller) {
        return controller->IsStoped(&p_dsObject);
    }
    return TRUE;
}
 
// FUNCTION: LEGO1 0x100b9b60
// FUNCTION: BETA10 0x10145d51
MxLong MxStreamer::Notify(MxParam& p_param)
{
    MxStreamerNotification& s = static_cast<MxStreamerNotification&>(p_param);
 
    switch (s.GetNotification()) {
    case c_notificationStreamer: {
        // DECOMP: Beta does not use a variable, but this matches retail better.
        MxStreamController* c = s.GetController();
 
        MxDSAction ds;
        ds.SetUnknown24(-2);
 
        if (c->IsStoped(&ds)) {
            delete c;
        }
        else {
            NotificationManager()->Send(this, MxStreamerNotification(c_notificationStreamer, NULL, c));
        }
 
        break;
    }
    default:
        assert(0);
        break;
    }
 
    return 0;
}