s32 cellMusicInitialize2(s32 mode, s32 spuPriority, vm::ptr<CellMusic2Callback> func, vm::ptr<void> userData)
{
cellMusic.Todo("cellMusicInitialize2(mode=%d, spuPriority=%d, func=*0x%x, userData=*0x%x)", mode, spuPriority, func, userData);
if (mode != CELL_MUSIC2_PLAYER_MODE_NORMAL)
{
cellMusic.Todo("Unknown player mode: 0x%x", mode);
return CELL_MUSIC2_ERROR_PARAM;
}
named_thread_t(WRAP_EXPR("CellMusicInit"), [=]()
{
const auto music = fxm::make_always<music2_t>();
music->func = func;
music->userData = userData;
Emu.GetCallbackManager().Register([=](CPUThread& CPU) -> s32
{
vm::var<u32> ret(CPU);
*ret = CELL_OK;
func(static_cast<PPUThread&>(CPU), CELL_MUSIC2_EVENT_INITIALIZE_RESULT, ret, userData);
return CELL_OK;
});
}).detach();
return CELL_OK;
}
s32 cellFontGetFontIdCode(vm::ptr<CellFont> font, u32 code, vm::ptr<u32> fontId, vm::ptr<u32> fontCode)
{
cellFont.Todo("cellFontGetFontIdCode(font=*0x%x, code=0x%x, fontId=*0x%x, fontCode=*0x%x)", font, code, fontId, fontCode);
// TODO: ?
return CELL_OK;
}
s32 cellPadPeriphGetInfo(vm::ptr<CellPadPeriphInfo> info)
{
sys_io.Todo("cellPadPeriphGetInfo(info=*0x%x)", info);
if (!Emu.GetPadManager().IsInited())
{
return CELL_PAD_ERROR_UNINITIALIZED;
}
const PadInfo& rinfo = Emu.GetPadManager().GetInfo();
info->max_connect = rinfo.max_connect;
info->now_connect = rinfo.now_connect;
info->system_info = rinfo.system_info;
std::vector<Pad>& pads = Emu.GetPadManager().GetPads();
// TODO: Support other types of controllers
for (u32 i = 0; i < CELL_PAD_MAX_PORT_NUM; ++i)
{
if (i >= pads.size())
break;
info->port_status[i] = pads[i].m_port_status;
info->port_setting[i] = pads[i].m_port_setting;
info->device_capability[i] = pads[i].m_device_capability;
info->device_type[i] = pads[i].m_device_type;
info->pclass_type[i] = CELL_PAD_PCLASS_TYPE_STANDARD;
info->pclass_profile[i] = 0x0;
}
return CELL_OK;
}
s32 cellSaveDataUserFixedDelete(PPUThread& ppu, u32 userId, PSetList setList, PSetBuf setBuf, PFuncFixed funcFixed, PFuncDone funcDone, u32 container, vm::ptr<void> userdata)
{
cellSysutil.Todo("cellSaveDataUserFixedDelete(userId=%d, setList=*0x%x, setBuf=*0x%x, funcFixed=*0x%x, funcDone=*0x%x, container=0x%x, userdata=*0x%x)",
userId, setList, setBuf, funcFixed, funcDone, container, userdata);
return CELL_OK;
}
s32 sceNpMatching2Init2(u32 poolsize, s32 priority, vm::ptr<SceNpMatching2UtilityInitParam> param)
{
sceNp2.Todo("sceNpMatching2Init2(poolsize=%d, priority=%d, param_addr=0x%x)", poolsize, priority, param.addr());
if (!sceNp2Instance.m_bSceNp2Initialized)
{
sceNp2.Error("sceNpMatching2Init2(): sceNp2 has not been intialized.");
return SCE_NP_ERROR_NOT_INITIALIZED;
}
if (sceNp2Instance.m_bSceNp2Matching2Initialized2)
{
sceNp2.Error("sceNpMatching2Init2(): new sceNpMatching2 has already been intialized.");
return SCE_NP_MATCHING2_ERROR_ALREADY_INITIALIZED;
}
sceNp2Instance.m_bSceNp2Matching2Initialized2 = true;
// TODO:
// 1. Create an internal thread
// 2. Create heap area to be used by the NP matching 2 utility
// 3. Set maximum lengths for the event data queues in the system
return CELL_OK;
}
s32 sceNpSnsFbInit(vm::ptr<const SceNpSnsFbInitParams> params)
{
sceNpSns.Todo("sceNpSnsFbInit(params=*0x%x)", params);
// TODO: Use the initialization parameters somewhere
return CELL_OK;
}
s32 cellFsSdataOpenByFd(u32 mself_fd, s32 flags, vm::ptr<u32> sdata_fd, u64 offset, vm::cptr<void> arg, u64 size)
{
cellFs.Todo("cellFsSdataOpenByFd(mself_fd=0x%x, flags=%#o, sdata_fd=*0x%x, offset=0x%llx, arg=*0x%x, size=0x%llx)", mself_fd, flags, sdata_fd, offset, arg, size);
// TODO:
return CELL_OK;
}
s32 _sys_printf(vm::ptr<const char> fmt) // va_args...
{
sysPrxForUser.Todo("_sys_printf(fmt=*0x%x, ...)", fmt);
// probably, assertion failed
sysPrxForUser.Fatal("_sys_printf: \n%s", fmt.get_ptr());
Emu.Pause();
return CELL_OK;
}
s32 cellGameGetBootGameInfo(vm::ptr<u32> type, vm::ptr<char> dirName, vm::ptr<u32> execData)
{
cellGameExec.Todo("cellGameGetBootGameInfo(type=*0x%x, dirName=*0x%x, execData=*0x%x)");
// TODO: Support more boot types
*type = CELL_GAME_GAMETYPE_SYS;
return CELL_OK;
}
s32 cellPadLddUnregisterController(s32 handle)
{
sys_io.Todo("cellPadLddUnregisterController(handle=%d)", handle);
if (!Emu.GetPadManager().IsInited())
return CELL_PAD_ERROR_UNINITIALIZED;
return CELL_OK;
}
s32 cellGemGetInfo(vm::ptr<CellGemInfo> info)
{
cellGem.Todo("cellGemGetInfo(info=*0x%x)", info);
// TODO: Support many controllers to be connected
*info = {};
return CELL_OK;
}
s32 cellPadLddGetPortNo(s32 handle)
{
sys_io.Todo("cellPadLddGetPortNo(handle=%d)", handle);
if (!Emu.GetPadManager().IsInited())
return CELL_PAD_ERROR_UNINITIALIZED;
return CELL_OK;
}
s32 cellPadLddDataInsert(s32 handle, vm::ptr<CellPadData> data)
{
sys_io.Todo("cellPadLddDataInsert(handle=%d, data=*0x%x)", handle, data);
if (!Emu.GetPadManager().IsInited())
return CELL_PAD_ERROR_UNINITIALIZED;
return CELL_OK;
}
s32 cellPadLddRegisterController()
{
sys_io.Todo("cellPadLddRegisterController()");
if (!Emu.GetPadManager().IsInited())
return CELL_PAD_ERROR_UNINITIALIZED;
return CELL_OK;
}
s32 cellSailPlayerDestroyDescriptor(vm::ptr<CellSailPlayer> pSelf, vm::ptr<CellSailDescriptor> pDesc)
{
cellSail.Todo("cellSailPlayerAddDescriptor(pSelf_addr=0x%x, pDesc_addr=0x%x)", pSelf.addr(), pDesc.addr());
if (pDesc->registered)
return CELL_SAIL_ERROR_INVALID_STATE;
return CELL_OK;
}
int cellNetCtlGetInfo(s32 code, vm::ptr<CellNetCtlInfo> info)
{
cellNetCtl.Todo("cellNetCtlGetInfo(code=0x%x, info_addr=0x%x)", code, info.addr());
if (code == CELL_NET_CTL_INFO_IP_ADDRESS)
{
strcpy_trunc(info->ip_address, "192.168.1.1");
}
return CELL_OK;
}
s32 cellSailPlayerGetParameter(vm::ptr<CellSailPlayer> pSelf, s32 parameterType, vm::ptr<u64> pParam0, vm::ptr<u64> pParam1)
{
cellSail.Todo("cellSailPlayerGetParameter(pSelf=*0x%x, parameterType=0x%x, param0=*0x%x, param1=*0x%x)", pSelf, parameterType, pParam0, pParam1);
switch (parameterType)
{
default: cellSail.Error("cellSailPlayerGetParameter(): unimplemented parameter %s", ParameterCodeToName(parameterType));
}
return CELL_OK;
}
s32 sceNpClansCreateRequest(vm::ptr<SceNpClansRequestHandle> handle, u64 flags)
{
sceNpClans.Todo("sceNpClansCreateRequest(handle=*0x%x, flags=0x%llx)", handle, flags);
if (flags != 0)
{
return SCE_NP_CLANS_ERROR_NOT_SUPPORTED;
}
return CELL_OK;
}
s32 sceNpMatching2Init2(u32 poolsize, s32 priority, vm::ptr<SceNpMatching2UtilityInitParam> param)
{
sceNp2.Todo("sceNpMatching2Init2(poolsize=0x%x, priority=%d, param=*0x%x)", poolsize, priority, param);
// TODO:
// 1. Create an internal thread
// 2. Create heap area to be used by the NP matching 2 utility
// 3. Set maximum lengths for the event data queues in the system
return CELL_OK;
}
s32 cellNetCtlGetNatInfo(vm::ptr<CellNetCtlNatInfo> natInfo)
{
cellNetCtl.Todo("cellNetCtlGetNatInfo(natInfo=*0x%x)", natInfo);
if (natInfo->size == 0)
{
cellNetCtl.Error("cellNetCtlGetNatInfo : CELL_NET_CTL_ERROR_INVALID_SIZE");
return CELL_NET_CTL_ERROR_INVALID_SIZE;
}
return CELL_OK;
}
s32 cellFontSetupRenderScalePixel(vm::ptr<CellFont> font, float w, float h)
{
cellFont.Todo("cellFontSetupRenderScalePixel(font=*0x%x, w=%f, h=%f)", font, w, h);
if (!font->renderer_addr)
{
return CELL_FONT_ERROR_RENDERER_UNBIND;
}
// TODO: ?
return CELL_OK;
}
s32 cellSailPlayerCreateDescriptor(vm::ptr<CellSailPlayer> pSelf, s32 streamType, vm::ptr<void> pMediaInfo, vm::cptr<char> pUri, vm::pptr<CellSailDescriptor> ppDesc)
{
cellSail.Todo("cellSailPlayerCreateDescriptor(pSelf=*0x%x, streamType=%d, pMediaInfo=*0x%x, pUri=*0x%x, ppDesc=**0x%x)", pSelf, streamType, pMediaInfo, pUri, ppDesc);
u32 descriptorAddress = vm::alloc(sizeof(CellSailDescriptor), vm::main);
auto descriptor = vm::ptr<CellSailDescriptor>::make(descriptorAddress);
*ppDesc = descriptor;
descriptor->streamType = streamType;
descriptor->registered = false;
//pSelf->descriptors = 0;
pSelf->repeatMode = 0;
switch (streamType)
{
case CELL_SAIL_STREAM_PAMF:
{
std::string uri = pUri.get_ptr();
if (uri.substr(0, 12) == "x-cell-fs://")
{
std::string path = uri.substr(12);
vfsFile f;
if (f.Open(path))
{
u64 size = f.GetSize();
u32 buffer = vm::alloc(size, vm::main);
auto bufPtr = vm::cptr<PamfHeader>::make(buffer);
PamfHeader *buf = const_cast<PamfHeader*>(bufPtr.get_ptr());
assert(f.Read(buf, size) == size);
u32 sp_ = vm::alloc(sizeof(CellPamfReader), vm::main);
auto sp = vm::ptr<CellPamfReader>::make(sp_);
u32 reader = cellPamfReaderInitialize(sp, bufPtr, size, 0);
descriptor->buffer = buffer;
descriptor->sp_ = sp_;
}
else
{
cellSail.Warning("Couldn't open PAMF: %s", uri.c_str());
}
}
else
{
cellSail.Warning("Unhandled uri: %s", uri.c_str());
}
break;
}
default:
cellSail.Error("Unhandled stream type: %d", streamType);
}
return CELL_OK;
}
s32 cellFontGetRenderCharGlyphMetrics(vm::ptr<CellFont> font, u32 code, vm::ptr<CellFontGlyphMetrics> metrics)
{
cellFont.Todo("cellFontGetRenderCharGlyphMetrics(font=*0x%x, code=0x%x, metrics=*0x%x)", font, code, metrics);
if (!font->renderer_addr)
{
return CELL_FONT_ERROR_RENDERER_UNBIND;
}
// TODO: ?
return CELL_OK;
}
s32 cellFsSetIoBufferFromDefaultContainer(u32 fd, u32 buffer_size, u32 page_type)
{
cellFs.Todo("cellFsSetIoBufferFromDefaultContainer(fd=%d, buffer_size=%d, page_type=%d)", fd, buffer_size, page_type);
const auto file = idm::get<lv2_file_t>(fd);
if (!file)
{
return CELL_FS_EBADF;
}
return CELL_OK;
}
s32 cellMusicInitialize2(s32 mode, s32 spuPriority, vm::ptr<CellMusic2Callback> func, vm::ptr<void> userData)
{
cellMusic.Todo("cellMusicInitialize2(mode=%d, spuPriority=%d, func=*0x%x, userData=*0x%x)", mode, spuPriority, func, userData);
if (mode != CELL_MUSIC2_PLAYER_MODE_NORMAL)
{
cellMusic.Todo("Unknown player mode: 0x%x", mode);
return CELL_MUSIC2_ERROR_PARAM;
}
const auto music = fxm::make_always<music2_t>();
music->func = func;
music->userData = userData;
Emu.GetCallbackManager().Register([=](PPUThread& ppu) -> s32
{
func(ppu, CELL_MUSIC2_EVENT_INITIALIZE_RESULT, vm::make_var<s32>(CELL_OK), userData);
return CELL_OK;
});
return CELL_OK;
}
s32 cellFontCreateRenderer(vm::ptr<CellFontLibrary> library, vm::ptr<CellFontRendererConfig> config, vm::ptr<CellFontRenderer> Renderer)
{
cellFont.Todo("cellFontCreateRenderer(library=*0x%x, config=*0x%x, Renderer=*0x%x)", library, config, Renderer);
if (!g_font->m_bInitialized)
{
return CELL_FONT_ERROR_UNINITIALIZED;
}
//Write data in Renderer
return CELL_OK;
}
s32 sceNpTrophyAbortHandle(u32 handle)
{
sceNpTrophy.Todo("sceNpTrophyAbortHandle(handle=0x%x)", handle);
const auto hndl = idm::get<trophy_handle_t>(handle);
if (!hndl)
{
return SCE_NP_TROPHY_ERROR_UNKNOWN_HANDLE;
}
return CELL_OK;
}
s32 cellSaveDataFixedDelete(
PPUThread& CPU,
vm::ptr<CellSaveDataSetList> setList,
vm::ptr<CellSaveDataSetBuf> setBuf,
vm::ptr<CellSaveDataFixedCallback> funcFixed,
vm::ptr<CellSaveDataDoneCallback> funcDone,
u32 container,
vm::ptr<void> userdata)
{
cellSysutil.Todo("cellSaveDataFixedDelete(setList=*0x%x, setBuf=*0x%x, funcFixed=*0x%x, funcDone=*0x%x, container=0x%x, userdata=*0x%x)",
setList, setBuf, funcFixed, funcDone, container, userdata);
return CELL_OK;
}
s32 cellSailPlayerSetParameter(vm::ptr<CellSailPlayer> pSelf, s32 parameterType, u64 param0, u64 param1)
{
cellSail.Warning("cellSailPlayerSetParameter(pSelf=*0x%x, parameterType=0x%x, param0=0x%llx, param1=0x%llx)", pSelf, parameterType, param0, param1);
switch (parameterType)
{
case CELL_SAIL_PARAMETER_GRAPHICS_ADAPTER_BUFFER_RELEASE_DELAY: pSelf->graphics_adapter_buffer_release_delay = param1; break; // TODO: Stream index
case CELL_SAIL_PARAMETER_CONTROL_PPU_THREAD_STACK_SIZE: pSelf->control_ppu_thread_stack_size = param0; break;
case CELL_SAIL_PARAMETER_ENABLE_APOST_SRC: pSelf->enable_apost_src = param1; break; // TODO: Stream index
default: cellSail.Todo("cellSailPlayerSetParameter(): unimplemented parameter %s", ParameterCodeToName(parameterType));
}
return CELL_OK;
}
s32 cellRudpSetEventHandler(vm::ptr<CellRudpEventHandler> handler, vm::ptr<void> arg)
{
cellRudp.Todo("cellRudpSetEventHandler(handler=*0x%x, arg=*0x%x)", handler, arg);
if (!g_rudp.init.load())
{
return CELL_RUDP_ERROR_NOT_INITIALIZED;
}
g_rudp.handler = handler;
g_rudp.handler_arg = arg;
return CELL_OK;
}
