mirror of
https://github.com/TwilitRealm/dusklight
synced 2026-05-25 15:05:06 -04:00
PJB3005
511 lines
17 KiB
C++
511 lines
17 KiB
C++
/**
|
|
* m_Do_dvd_thread.cpp
|
|
* DVD Thread Manager
|
|
*/
|
|
|
|
#include "m_Do/m_Do_dvd_thread.h"
|
|
#include "JSystem/JAudio2/JASDvdThread.h"
|
|
#include "JSystem/JKernel/JKRAramArchive.h"
|
|
#include "JSystem/JKernel/JKRAssertHeap.h"
|
|
#include "JSystem/JKernel/JKRDvdRipper.h"
|
|
#include "JSystem/JKernel/JKRExpHeap.h"
|
|
#include "JSystem/JKernel/JKRMemArchive.h"
|
|
#include "dusk/os.h"
|
|
#include "m_Do/m_Do_Reset.h"
|
|
#include "m_Do/m_Do_controller_pad.h"
|
|
#include "m_Do/m_Do_ext.h"
|
|
#include "os_report.h"
|
|
|
|
s32 mDoDvdThd::main(void* param_0) {
|
|
JKRThread(OSGetCurrentThread(), 0);
|
|
#if TARGET_PC
|
|
OSSetCurrentThreadName("DVD thread");
|
|
#endif
|
|
JKRSetCurrentHeap(mDoExt_getAssertHeap());
|
|
mDoDvdThd_param_c* param = static_cast<mDoDvdThd_param_c*>(param_0);
|
|
param->mainLoop();
|
|
return 0;
|
|
}
|
|
|
|
OSThread mDoDvdThd::l_thread;
|
|
|
|
mDoDvdThdStack mDoDvdThd::l_threadStack;
|
|
|
|
mDoDvdThd_param_c mDoDvdThd::l_param;
|
|
|
|
#if DEBUG
|
|
u8 mDoDvdThd::verbose;
|
|
u8 mDoDvdThd::DVDLogoMode;
|
|
bool mDoDvdThd::SyncWidthSound;
|
|
u8 mDoDvdThd::Report_DVDRead;
|
|
OSBootInfo* mDoDvdHack::BootInfo;
|
|
mDoDvdHack::FSTEntry* mDoDvdHack::FstStart;
|
|
const char* mDoDvdHack::FstStringStart;
|
|
u32 mDoDvdHack::MaxEntryNum;
|
|
mDoDvdHack::Manager mDoDvdHack::Manager::sManager;
|
|
#else
|
|
bool mDoDvdThd::SyncWidthSound;
|
|
#endif
|
|
|
|
u8 sDefaultDirection;
|
|
|
|
#pragma push
|
|
#pragma force_active on
|
|
static u8 padding[0x18];
|
|
#pragma pop
|
|
|
|
void mDoDvdThd::create(s32 param_0) {
|
|
OSCreateThread(&l_thread, (void*(*)(void*))mDoDvdThd::main, &l_param,
|
|
l_threadStack.stack + sizeof(l_threadStack), sizeof(l_threadStack), param_0, 1);
|
|
OSResumeThread(&l_thread);
|
|
}
|
|
|
|
void mDoDvdThd::suspend() {
|
|
OS_REPORT("DVD読み込みスレッドを停止しました\n");
|
|
OSSuspendThread(&l_thread);
|
|
}
|
|
|
|
#if DEBUG
|
|
void mDoDvdHack::__DVDFSInit() {
|
|
BootInfo = (OSBootInfo*)OSPhysicalToCached(0);
|
|
FstStart = (FSTEntry*)BootInfo->FSTLocation;
|
|
if (FstStart) {
|
|
MaxEntryNum = FstStart->nextEntryOrLength;
|
|
FstStringStart = (char*)FstStart + (MaxEntryNum* sizeof(FSTEntry));
|
|
}
|
|
}
|
|
|
|
const char* mDoDvdHack::EntryToName(s32 entry) {
|
|
if (entry < 0) {
|
|
return "*ERROR*";
|
|
}
|
|
if (entry == 0) {
|
|
return "/";
|
|
}
|
|
return FstStringStart + (FstStart[entry].isDirAndStringOff & ~0xff000000);
|
|
}
|
|
|
|
const char* mDoDvdHack::ConvertEntrynumToName(s32 entry) {
|
|
__DVDFSInit();
|
|
return EntryToName(entry);
|
|
}
|
|
#endif
|
|
|
|
static void dummy1() {
|
|
OS_REPORT(__FILE__);
|
|
OS_REPORT("DVDConvertEntrynumToPath: specified entrynum(%d) is out of range ");
|
|
OS_REPORT("DVDConvertEntrynumToPath: maxlen should be more than 1 (%d is specified)");
|
|
}
|
|
|
|
|
|
static s32 my_DVDConvertPathToEntrynum(char const* path) {
|
|
s32 entrynum = DVDConvertPathToEntrynum(path);
|
|
#if DEBUG
|
|
if (entrynum < 0) {
|
|
BOOL connected = mDoCPd_c::isConnect(2);
|
|
if (connected) {
|
|
JUT_WARN(437, "can\'t open:[%s]\n", path);
|
|
}
|
|
}
|
|
#endif
|
|
return entrynum;
|
|
}
|
|
|
|
mDoDvdThd_command_c::~mDoDvdThd_command_c() {
|
|
if (!mIsDone) {
|
|
OS_REPORT_ERROR("mDoDvdThd_command_c::~mDoDvdThd_command_c() 完了していないコマンドがデストラクトされました\nきっとカタストロフィが発生することでしょう\n");
|
|
}
|
|
}
|
|
|
|
mDoDvdThd_param_c::mDoDvdThd_param_c() {
|
|
OSInitMessageQueue(&mMessageQueue, &mMessageQueueMessages, 1);
|
|
OSInitMutex(&mMutext);
|
|
cLs_Create(&mNodeList);
|
|
}
|
|
|
|
void mDoDvdThd_param_c::kick() {
|
|
OSSendMessage(&mMessageQueue, NULL, OS_MESSAGE_NOBLOCK);
|
|
}
|
|
|
|
s32 mDoDvdThd_param_c::waitForKick() {
|
|
return OSReceiveMessage(&mMessageQueue, NULL, OS_MESSAGE_BLOCK);
|
|
}
|
|
|
|
mDoDvdThd_command_c* mDoDvdThd_param_c::getFirstCommand() {
|
|
return (mDoDvdThd_command_c*)mNodeList.mpHead;
|
|
}
|
|
|
|
void mDoDvdThd_param_c::addition(mDoDvdThd_command_c* pCommand) {
|
|
OSLockMutex(&mMutext);
|
|
cLs_Addition(&mNodeList, pCommand);
|
|
OSUnlockMutex(&mMutext);
|
|
this->kick();
|
|
}
|
|
|
|
void mDoDvdThd_param_c::cut(mDoDvdThd_command_c* param_0) {
|
|
OSLockMutex(&mMutext);
|
|
cLs_SingleCut(param_0);
|
|
OSUnlockMutex(&mMutext);
|
|
this->kick();
|
|
}
|
|
|
|
static void cb(void* param_0) {
|
|
mDoDvdThd_command_c* pCmd = *(mDoDvdThd_command_c**)param_0;
|
|
s32 result = pCmd->execute();
|
|
if (result != 1) {
|
|
OSReport_Error("mDoDvdThd_param_c::mainLoop() コマンドの実行が失敗しました。\n");
|
|
}
|
|
}
|
|
|
|
void mDoDvdThd_param_c::mainLoop() {
|
|
mDoDvdThd_command_c* command;
|
|
while (this->waitForKick() != 0) {
|
|
while ((command = this->getFirstCommand())) {
|
|
this->cut(command);
|
|
if (mDoDvdThd::SyncWidthSound) {
|
|
#if TARGET_PC
|
|
JASDvd::getThreadPointer()->sendCmdMsg(cb, &command, sizeof(void*));
|
|
#else
|
|
JASDvd::getThreadPointer()->sendCmdMsg(cb, &command, 4);
|
|
#endif
|
|
} else {
|
|
cb(&command);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
mDoDvdThd_command_c::mDoDvdThd_command_c() {
|
|
mIsDone = false;
|
|
cNd_ForcedClear(this);
|
|
}
|
|
|
|
mDoDvdThd_callback_c::~mDoDvdThd_callback_c() {}
|
|
|
|
mDoDvdThd_callback_c::mDoDvdThd_callback_c(mDoDvdThd_callback_func pFunc, void* pData) {
|
|
mFunction = pFunc;
|
|
mData = pData;
|
|
mResult = NULL;
|
|
}
|
|
|
|
mDoDvdThd_callback_c* mDoDvdThd_callback_c::create(mDoDvdThd_callback_func pFunc, void* pData) {
|
|
mDoDvdThd_callback_c* callCmd =
|
|
JKR_NEW_ARGS (mDoExt_getCommandHeap(), -4) mDoDvdThd_callback_c(pFunc, pData);
|
|
if (callCmd != NULL) {
|
|
mDoDvdThd::l_param.addition(callCmd);
|
|
if (mDoDvdThd::DVDLogoMode) {
|
|
OS_REPORT("\x1b[34m<DVD> callback %08x %08x %08x\n\x1b[m", callCmd, pFunc, pData);
|
|
}
|
|
}
|
|
return callCmd;
|
|
}
|
|
|
|
s32 mDoDvdThd_callback_c::execute() {
|
|
mResult = mFunction(mData);
|
|
mIsDone = true;
|
|
return mResult != NULL;
|
|
}
|
|
|
|
mDoDvdThd_mountArchive_c::~mDoDvdThd_mountArchive_c() {}
|
|
|
|
mDoDvdThd_mountArchive_c::mDoDvdThd_mountArchive_c(u8 param_0) {
|
|
mMountDirection = param_0;
|
|
mEntryNumber = -1;
|
|
mArchive = NULL;
|
|
mHeap = NULL;
|
|
if (param_0 == 0) {
|
|
mMountDirection = sDefaultDirection;
|
|
}
|
|
}
|
|
|
|
mDoDvdThd_mountArchive_c* mDoDvdThd_mountArchive_c::create(char const* pArchivePath,
|
|
u8 mountDirection, JKRHeap* pHeap) {
|
|
mDoDvdThd_mountArchive_c* mountArcCmd =
|
|
JKR_NEW_ARGS (mDoExt_getCommandHeap(), -4) mDoDvdThd_mountArchive_c(mountDirection);
|
|
if (mountArcCmd != NULL) {
|
|
mountArcCmd->mEntryNumber = my_DVDConvertPathToEntrynum(pArchivePath);
|
|
if (mountArcCmd->mEntryNumber == -1) {
|
|
mountArcCmd->mIsDone = true;
|
|
JKR_DELETE(mountArcCmd);
|
|
mountArcCmd = NULL;
|
|
} else {
|
|
mountArcCmd->mHeap = pHeap;
|
|
mDoDvdThd::l_param.addition(mountArcCmd);
|
|
if (mDoDvdThd::DVDLogoMode) {
|
|
OS_REPORT("\x1b[34m<DVD> mountArchive(%d:%s)\n\x1b[m", mountArcCmd->mEntryNumber, pArchivePath);
|
|
}
|
|
}
|
|
}
|
|
return mountArcCmd;
|
|
}
|
|
|
|
s32 mDoDvdThd_mountArchive_c::execute() {
|
|
#if PLATFORM_GCN
|
|
bool isZeldaHeap = false;
|
|
bool isGameHeap = false;
|
|
bool isArcHeap = false;
|
|
bool isJ2DHeap = false;
|
|
#endif
|
|
JKRHeap* heap = mHeap != NULL ? mHeap : mDoExt_getArchiveHeap();
|
|
JKRMemArchive* memArchive = NULL;
|
|
#if DEBUG
|
|
OSTime time1 = OSGetTime();
|
|
#endif
|
|
while (true) {
|
|
#if PLATFORM_GCN
|
|
if (heap == mDoExt_getArchiveHeapPtr()) {
|
|
isArcHeap = true;
|
|
} else if (heap == mDoExt_getZeldaHeap()) {
|
|
isZeldaHeap = true;
|
|
} else if (heap == mDoExt_getGameHeap()) {
|
|
isGameHeap = true;
|
|
} else if (heap == mDoExt_getJ2dHeap()) {
|
|
isJ2DHeap = true;
|
|
}
|
|
#endif
|
|
if (mMountDirection == 0) {
|
|
memArchive =
|
|
JKR_NEW_ARGS (heap, 0) JKRMemArchive(mEntryNumber, JKRArchive::MOUNT_DIRECTION_HEAD);
|
|
} else {
|
|
memArchive =
|
|
JKR_NEW_ARGS (heap, -4) JKRMemArchive(mEntryNumber, JKRArchive::MOUNT_DIRECTION_TAIL);
|
|
}
|
|
if (memArchive != NULL && memArchive->isMounted()) {
|
|
mArchive = memArchive;
|
|
#if DEBUG
|
|
OSTime time2 = OSGetTime();
|
|
u32 msec = OS_TICKS_TO_MSEC(time2 - time1);
|
|
if (mArchive && mDoDvdThd::verbose) {
|
|
OS_REPORT("mDoDvdThd_mountArchive_c::execute: mArchive=%08x mArcHeader=%08x mMountDirection=%d Time=%4dms %s\n", mArchive, mArchive->mArcHeader, mMountDirection, msec, mDoDvdHack::ConvertEntrynumToName(mEntryNumber));
|
|
}
|
|
#endif
|
|
break;
|
|
}
|
|
OSReport_Error("mDoDvdThd_mountArchive_c::execute マウント失敗\n");
|
|
OS_REPORT_ERROR("Name = %s\n", mDoDvdHack::ConvertEntrynumToName(mEntryNumber));
|
|
if (memArchive) {
|
|
JKR_DELETE(memArchive);
|
|
}
|
|
memArchive = NULL;
|
|
#if PLATFORM_GCN
|
|
if (!isZeldaHeap) {
|
|
OSReport_Error("mDoDvdThd_mountArchive_c::execute ゼルダヒープで再チャレンジ！\n");
|
|
heap = mDoExt_getZeldaHeap();
|
|
} else if (!isArcHeap) {
|
|
OSReport_Error("mDoDvdThd_mountArchive_c::execute アーカイブヒープで再チャレンジ！\n");
|
|
heap = mDoExt_getArchiveHeapPtr();
|
|
} else if (!isGameHeap) {
|
|
OSReport_Error("mDoDvdThd_mountArchive_c::execute ゲームヒープで再チャレンジ！\n");
|
|
heap = mDoExt_getGameHeap();
|
|
} else if (!isJ2DHeap) {
|
|
OSReport_Error("mDoDvdThd_mountArchive_c::execute J2Dヒープで再チャレンジ！\n");
|
|
heap = mDoExt_getJ2dHeap();
|
|
} else {
|
|
OSReport_FatalError("mDoDvdThd_mountArchive_c::execute ヒープが致命的に足りません！\n");
|
|
break;
|
|
}
|
|
#else
|
|
if (heap != mDoExt_getZeldaHeap()) {
|
|
OSReport_Error("mDoDvdThd_mountArchive_c::execute システムヒープで再チャレンジ！\n");
|
|
heap = mDoExt_getZeldaHeap();
|
|
} else {
|
|
OSReport_FatalError("mDoDvdThd_mountArchive_c::execute ヒープが致命的に足りません！\n");
|
|
break;
|
|
}
|
|
#endif
|
|
}
|
|
mIsDone = true;
|
|
return mArchive != NULL;
|
|
}
|
|
|
|
mDoDvdThd_mountAramArchive_c::~mDoDvdThd_mountAramArchive_c() {}
|
|
|
|
static void dummy_mDoDvdThd_mountAramArchive_c__create() {
|
|
OS_REPORT("<DVD> mountAramArchive(%d:%s)\n");
|
|
}
|
|
|
|
s32 mDoDvdThd_mountAramArchive_c::execute() {
|
|
JKRHeap* heap = mDoExt_getArchiveHeap();
|
|
BOOL result = FALSE;
|
|
if (!mArchive) {
|
|
if (mMountDirection == 0) {
|
|
mArchive = JKR_NEW_ARGS (heap, 0x20) JKRAramArchive;
|
|
} else {
|
|
mArchive = JKR_NEW_ARGS (heap, -0x20) JKRAramArchive;
|
|
}
|
|
#if DEBUG
|
|
if (mDoDvdThd::verbose) {
|
|
OS_REPORT("mDoDvdThd_mountAramArchive_c::execute mArchive=%08x size=%08x\n", mArchive, JKRGetMemBlockSize(heap, mArchive));
|
|
}
|
|
#endif
|
|
JUT_ASSERT(880, mArchive != NULL);
|
|
}
|
|
if (mArchive) {
|
|
JKRArchive::EMountDirection mountDirection = mMountDirection == 0 ? JKRArchive::MOUNT_DIRECTION_HEAD : JKRArchive::MOUNT_DIRECTION_TAIL;
|
|
#if DEBUG
|
|
OSTime time1 = OSGetTime();
|
|
#endif
|
|
result = mArchive->mountFixed(mEntryNum, mountDirection);
|
|
#if DEBUG
|
|
OSTime time2 = OSGetTime();
|
|
u32 msec = OS_TICKS_TO_MSEC(time2 - time1);
|
|
if (mDoDvdThd::verbose) {
|
|
OS_REPORT("mDoDvdThd_mountAramArchive_c::execute: mArchive=%08x ->mAramCache=%08x ->mFileSystem=%08x %s\n", mArchive, mArchive->mBlock, mArchive->mDvdFile, mDoDvdHack::ConvertEntrynumToName(mEntryNum));
|
|
}
|
|
#endif
|
|
}
|
|
mIsDone = true;
|
|
return result;
|
|
}
|
|
|
|
mDoDvdThd_mountXArchive_c::~mDoDvdThd_mountXArchive_c() {}
|
|
|
|
mDoDvdThd_mountXArchive_c::mDoDvdThd_mountXArchive_c(u8 mountDirection, JKRArchive::EMountMode mountMode) {
|
|
mMountDirection = mountDirection;
|
|
mEntryNum = -1;
|
|
mArchive = NULL;
|
|
mMountMode = mountMode;
|
|
mHeap = NULL;
|
|
if (mountDirection == 0) {
|
|
mMountDirection = sDefaultDirection;
|
|
}
|
|
}
|
|
|
|
mDoDvdThd_mountXArchive_c* mDoDvdThd_mountXArchive_c::create(char const* pArchivePath,
|
|
u8 mountDirection,
|
|
JKRArchive::EMountMode mountMode,
|
|
JKRHeap* pHeap) {
|
|
mDoDvdThd_mountXArchive_c* mountXArcCmd =
|
|
JKR_NEW_ARGS (mDoExt_getCommandHeap(), -4) mDoDvdThd_mountXArchive_c(mountDirection, mountMode);
|
|
if (mountXArcCmd != NULL) {
|
|
mountXArcCmd->mEntryNum = my_DVDConvertPathToEntrynum(pArchivePath);
|
|
if (mountXArcCmd->mEntryNum == -1) {
|
|
mountXArcCmd->mIsDone = true;
|
|
JKR_DELETE(mountXArcCmd);
|
|
mountXArcCmd = NULL;
|
|
} else {
|
|
mountXArcCmd->mHeap = pHeap;
|
|
mDoDvdThd::l_param.addition(mountXArcCmd);
|
|
if (mDoDvdThd::DVDLogoMode) {
|
|
OS_WARNING("<DVD> mountXArchive(%d:%s)\n", mountXArcCmd->mEntryNum, pArchivePath);
|
|
}
|
|
}
|
|
}
|
|
return mountXArcCmd;
|
|
}
|
|
|
|
s32 mDoDvdThd_mountXArchive_c::execute() {
|
|
#if DEBUG
|
|
OSTime time1 = OSGetTime();
|
|
#endif
|
|
JKRArchive::EMountDirection mountDirection =
|
|
mMountDirection == 0 ? JKRArchive::MOUNT_DIRECTION_HEAD : JKRArchive::MOUNT_DIRECTION_TAIL;
|
|
JKRHeap* heap = mHeap != NULL ? mHeap : mDoExt_getArchiveHeap();
|
|
s32 result = 0;
|
|
mArchive = JKRArchive::mount(mEntryNum, mMountMode, heap, mountDirection);
|
|
result = mArchive != NULL;
|
|
#if DEBUG
|
|
if (result) {
|
|
OSTime time2 = OSGetTime();
|
|
u32 msec = OS_TICKS_TO_MSEC(time2 - time1);
|
|
if (mDoDvdThd::verbose) {
|
|
OS_REPORT("mDoDvdThd_mountXArchive_c::execute: mArchive=%08x %s\n", mArchive, mDoDvdHack::ConvertEntrynumToName(mEntryNum));
|
|
}
|
|
}
|
|
#endif
|
|
mIsDone = true;
|
|
return result;
|
|
}
|
|
|
|
mDoDvdThd_getResource_c::~mDoDvdThd_getResource_c() {}
|
|
|
|
static void dummy_mDoDvdThd_getResource_c__create() {
|
|
OS_REPORT("<DVD> getResource(%x,%d)\n");
|
|
OSReport("mDoDvdThd_getResource_c::create() クラス生成に失敗\n");
|
|
OSReport("mDoDvdThd_getResource_c::create() リソース取得に失敗\n");
|
|
}
|
|
|
|
s32 mDoDvdThd_getResource_c::execute() {
|
|
#if DEBUG
|
|
OSTime time1 = OSGetTime();
|
|
#endif
|
|
JUT_ASSERT(1080, mArchive);
|
|
mResource = mArchive->getResource(mResourceId);
|
|
#if DEBUG
|
|
OSTime time2 = OSGetTime();
|
|
u32 msec = OS_TICKS_TO_MSEC(time2 - time1);
|
|
if (mArchive && mDoDvdThd::verbose) {
|
|
OS_REPORT("mDoDvdThd_getResource_c::execute: mResouce=%08x Time=%4dms\n", mResource, msec);
|
|
}
|
|
#endif
|
|
if (!mResource) {
|
|
OSReport_Error("mDoDvdThd_getResource_c::execute() リソース取得に失敗\n");
|
|
}
|
|
mIsDone = true;
|
|
return mResource != NULL;
|
|
}
|
|
|
|
static void dummy2() {
|
|
OS_REPORT("mEntryNum != -1");
|
|
OS_REPORT("mDoDvdThd_toMainRam_c(%d:%s)\n");
|
|
}
|
|
|
|
mDoDvdThd_toMainRam_c::mDoDvdThd_toMainRam_c(u8 param_0) {
|
|
mMountDirection = param_0;
|
|
if (param_0 == 0) {
|
|
mMountDirection = sDefaultDirection;
|
|
}
|
|
}
|
|
|
|
mDoDvdThd_toMainRam_c* mDoDvdThd_toMainRam_c::create(char const* pArchivePath, u8 mountDirection,
|
|
JKRHeap* pHeap) {
|
|
mDoDvdThd_toMainRam_c* toMainRAMCmd =
|
|
JKR_NEW_ARGS (mDoExt_getCommandHeap(), -4) mDoDvdThd_toMainRam_c(mountDirection);
|
|
if (toMainRAMCmd != NULL) {
|
|
toMainRAMCmd->mEntryNum = my_DVDConvertPathToEntrynum(pArchivePath);
|
|
if (toMainRAMCmd->mEntryNum == -1) {
|
|
toMainRAMCmd->mIsDone = true;
|
|
JKR_DELETE(toMainRAMCmd);
|
|
toMainRAMCmd = NULL;
|
|
} else {
|
|
toMainRAMCmd->mHeap = pHeap;
|
|
mDoDvdThd::l_param.addition(toMainRAMCmd);
|
|
if (mDoDvdThd::DVDLogoMode) {
|
|
OS_WARNING("<DVD> toMainRam(%d:%s)\n", toMainRAMCmd->mEntryNum, pArchivePath);
|
|
}
|
|
}
|
|
}
|
|
return toMainRAMCmd;
|
|
}
|
|
|
|
mDoDvdThd_toMainRam_c::~mDoDvdThd_toMainRam_c() {}
|
|
|
|
s32 mDoDvdThd_toMainRam_c::execute() {
|
|
#if DEBUG
|
|
OSTime time1 = OSGetTime();
|
|
#endif
|
|
JKRHeap* heap;
|
|
if (mHeap != NULL) {
|
|
heap = mHeap;
|
|
} else {
|
|
heap = mDoExt_getArchiveHeap();
|
|
}
|
|
JKRDvdRipper::EAllocDirection allocDir = mMountDirection == 0 ?
|
|
JKRDvdRipper::ALLOC_DIRECTION_FORWARD :
|
|
JKRDvdRipper::ALLOC_DIRECTION_BACKWARD;
|
|
mData = JKRDvdToMainRam(mEntryNum, NULL, EXPAND_SWITCH_UNKNOWN1, 0, heap, allocDir,
|
|
0, NULL, NULL);
|
|
if (mData != NULL) {
|
|
mDataSize = heap->getSize(mData);
|
|
}
|
|
#if DEBUG
|
|
OSTime time2 = OSGetTime();
|
|
u32 msec = OS_TICKS_TO_MSEC(time2 - time1);
|
|
if (mDoDvdThd::verbose) {
|
|
OS_REPORT("mDoDvdThd_toMainRam_c::execute: mMemAddress=%08x mMemSize=%08x %s\n", mData, mDataSize, mDoDvdHack::ConvertEntrynumToName(mEntryNum));
|
|
}
|
|
#endif
|
|
mIsDone = true;
|
|
return mData != NULL;
|
|
}
|