mirror of
https://github.com/RPCS3/rpcs3.git
synced 2025-04-28 13:28:01 +03:00
Remove some obsolete pragmas
This commit is contained in:
Megamouse
parent
cd2098fad7
commit
85a4c5eb93
14 changed files with 202 additions and 266 deletions
|
|
@ -61,11 +61,6 @@ void fmt_class_string<CellCameraFormat>::format(std::string& out, u64 arg)
|
|||
});
|
||||
}
|
||||
|
||||
// Temporarily
|
||||
#ifndef _MSC_VER
|
||||
#pragma GCC diagnostic ignored "-Wunused-parameter"
|
||||
#endif
|
||||
|
||||
// **************
|
||||
// * Prototypes *
|
||||
// **************
|
||||
|
|
@ -402,7 +397,7 @@ error_code check_init_and_open(s32 dev_num)
|
|||
}
|
||||
|
||||
// This represents a recurring subfunction throughout libCamera
|
||||
error_code check_resolution(s32 dev_num)
|
||||
error_code check_resolution(s32 /*dev_num*/)
|
||||
{
|
||||
// TODO: Some sort of connection check maybe?
|
||||
//if (error == CELL_CAMERA_ERROR_RESOLUTION_UNKNOWN)
|
||||
|
|
@ -413,7 +408,7 @@ error_code check_resolution(s32 dev_num)
|
|||
return CELL_OK;
|
||||
}
|
||||
|
||||
// This represents a oftenly used sequence in libCamera (usually the beginning of a subfunction).
|
||||
// This represents an often used sequence in libCamera (usually the beginning of a subfunction).
|
||||
// There also exist common sequences for mutex lock/unlock by the way.
|
||||
error_code check_resolution_ex(s32 dev_num)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -26,11 +26,6 @@ void fmt_class_string<CellDaisyError>::format(std::string& out, u64 arg)
|
|||
});
|
||||
}
|
||||
|
||||
// Temporarily
|
||||
#ifndef _MSC_VER
|
||||
#pragma GCC diagnostic ignored "-Wunused-parameter"
|
||||
#endif
|
||||
|
||||
using LFQueue2 = struct CellDaisyLFQueue2;
|
||||
using Lock = struct CellDaisyLock;
|
||||
using ScatterGatherInterlock = struct CellDaisyScatterGatherInterlock;
|
||||
|
|
@ -38,134 +33,134 @@ using AtomicInterlock = volatile struct CellDaisyAtomicInterlock;
|
|||
|
||||
error_code cellDaisyLFQueue2GetPopPointer(vm::ptr<LFQueue2> queue, vm::ptr<s32> pPointer, u32 isBlocking)
|
||||
{
|
||||
cellDaisy.todo("cellDaisyLFQueue2GetPopPointer()");
|
||||
cellDaisy.todo("cellDaisyLFQueue2GetPopPointer(queue=*0x%x, pPointer=*0x%x, isBlocking=%d)", queue, pPointer, isBlocking);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellDaisyLFQueue2CompletePopPointer(vm::ptr<LFQueue2> queue, s32 pointer, vm::ptr<s32(vm::ptr<void>, u32)> fpSendSignal, u32 isQueueFull)
|
||||
{
|
||||
cellDaisy.todo("cellDaisyLFQueue2CompletePopPointer()");
|
||||
cellDaisy.todo("cellDaisyLFQueue2CompletePopPointer(queue=*0x%x, pointer=0x%x, fpSendSignal=*0x%x, isQueueFull=%d)", queue, pointer, fpSendSignal, isQueueFull);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
void cellDaisyLFQueue2PushOpen(vm::ptr<LFQueue2> queue)
|
||||
{
|
||||
cellDaisy.todo("cellDaisyLFQueue2PushOpen()");
|
||||
cellDaisy.todo("cellDaisyLFQueue2PushOpen(queue=*0x%x)", queue);
|
||||
}
|
||||
|
||||
error_code cellDaisyLFQueue2PushClose(vm::ptr<LFQueue2> queue, vm::ptr<s32(vm::ptr<void>, u32)> fpSendSignal)
|
||||
{
|
||||
cellDaisy.todo("cellDaisyLFQueue2PushClose()");
|
||||
cellDaisy.todo("cellDaisyLFQueue2PushClose(queue=*0x%x, fpSendSignal=*0x%x)", queue, fpSendSignal);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
void cellDaisyLFQueue2PopOpen(vm::ptr<LFQueue2> queue)
|
||||
{
|
||||
cellDaisy.todo("cellDaisyLFQueue2PopOpen()");
|
||||
cellDaisy.todo("cellDaisyLFQueue2PopOpen(queue=*0x%x)", queue);
|
||||
}
|
||||
|
||||
error_code cellDaisyLFQueue2PopClose(vm::ptr<LFQueue2> queue, vm::ptr<s32(vm::ptr<void>, u32)> fpSendSignal)
|
||||
{
|
||||
cellDaisy.todo("cellDaisyLFQueue2PopClose()");
|
||||
cellDaisy.todo("cellDaisyLFQueue2PopClose(queue=*0x%x, fpSendSignal=*0x%x)", queue, fpSendSignal);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellDaisyLFQueue2HasUnfinishedConsumer(vm::ptr<LFQueue2> queue, u32 isCancelled)
|
||||
{
|
||||
cellDaisy.todo("cellDaisyLFQueue2HasUnfinishedConsumer()");
|
||||
cellDaisy.todo("cellDaisyLFQueue2HasUnfinishedConsumer(queue=*0x%x, isCancelled=%d)", queue, isCancelled);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellDaisy_snprintf(vm::ptr<char> buffer, u32 count, vm::cptr<char> fmt, ppu_va_args_t fmt_args)
|
||||
{
|
||||
cellDaisy.todo("cellDaisy_snprintf()");
|
||||
cellDaisy.todo("cellDaisy_snprintf(buffer=*0x%x, count=%d, fmt=*0x%x, fmt_args=%d)", buffer, count, fmt, fmt_args.count);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellDaisyLock_initialize(vm::ptr<Lock> _this, u32 depth)
|
||||
{
|
||||
cellDaisy.todo("cellDaisyLock_initialize()");
|
||||
cellDaisy.todo("cellDaisyLock_initialize(_this=*0x%x, depth=%d)", _this, depth);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellDaisyLock_getNextHeadPointer(vm::ptr<Lock> _this)
|
||||
{
|
||||
cellDaisy.todo("cellDaisyLock_getNextHeadPointer()");
|
||||
cellDaisy.todo("cellDaisyLock_getNextHeadPointer(_this=*0x%x)", _this);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellDaisyLock_getNextTailPointer(vm::ptr<Lock> _this)
|
||||
{
|
||||
cellDaisy.todo("cellDaisyLock_getNextTailPointer()");
|
||||
cellDaisy.todo("cellDaisyLock_getNextTailPointer(_this=*0x%x)", _this);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellDaisyLock_completeConsume(vm::ptr<Lock> _this, u32 pointer)
|
||||
{
|
||||
cellDaisy.todo("cellDaisyLock_completeConsume()");
|
||||
cellDaisy.todo("cellDaisyLock_completeConsume(_this=*0x%x, pointer=0x%x)", _this, pointer);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellDaisyLock_completeProduce(vm::ptr<Lock> _this, u32 pointer)
|
||||
{
|
||||
cellDaisy.todo("cellDaisyLock_completeProduce()");
|
||||
cellDaisy.todo("cellDaisyLock_completeProduce(_this=*0x%x, pointer=0x%x)", _this, pointer);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellDaisyLock_pushOpen(vm::ptr<Lock> _this)
|
||||
{
|
||||
cellDaisy.todo("cellDaisyLock_pushOpen()");
|
||||
cellDaisy.todo("cellDaisyLock_pushOpen(_this=*0x%x)", _this);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellDaisyLock_pushClose(vm::ptr<Lock> _this)
|
||||
{
|
||||
cellDaisy.todo("cellDaisyLock_pushClose()");
|
||||
cellDaisy.todo("cellDaisyLock_pushClose(_this=*0x%x)", _this);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellDaisyLock_popOpen(vm::ptr<Lock> _this)
|
||||
{
|
||||
cellDaisy.todo("cellDaisyLock_popOpen()");
|
||||
cellDaisy.todo("cellDaisyLock_popOpen(_this=*0x%x)", _this);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellDaisyLock_popClose(vm::ptr<Lock> _this)
|
||||
{
|
||||
cellDaisy.todo("cellDaisyLock_popClose()");
|
||||
cellDaisy.todo("cellDaisyLock_popClose(_this=*0x%x)", _this);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
void cellDaisyScatterGatherInterlock_1(vm::ptr<ScatterGatherInterlock> _this, vm::ptr<AtomicInterlock> ea, u32 size, vm::ptr<void> eaSignal, vm::ptr<s32(vm::ptr<void>, u32)> fpSendSignal)
|
||||
{
|
||||
cellDaisy.todo("cellDaisyScatterGatherInterlock_1()");
|
||||
cellDaisy.todo("cellDaisyScatterGatherInterlock_1(_this=*0x%x, ea=*0x%x, size=%d, eaSignal=*0x%x, fpSendSignal=*0x%x)", _this, ea, size, eaSignal, fpSendSignal);
|
||||
}
|
||||
|
||||
void cellDaisyScatterGatherInterlock_2(vm::ptr<ScatterGatherInterlock> _this, u32 size, vm::ptr<u32> ids, u32 numSpus, u8 spup)
|
||||
{
|
||||
cellDaisy.todo("cellDaisyScatterGatherInterlock_2()");
|
||||
cellDaisy.todo("cellDaisyScatterGatherInterlock_2(_this=*0x%x, size=%d, ids=*0x%x, numSpus=%d, spup=%d)", _this, size, ids, numSpus, spup);
|
||||
}
|
||||
|
||||
void cellDaisyScatterGatherInterlock_9tor(vm::ptr<ScatterGatherInterlock> _this)
|
||||
{
|
||||
cellDaisy.todo("cellDaisyScatterGatherInterlock_9tor()");
|
||||
cellDaisy.todo("cellDaisyScatterGatherInterlock_9tor(_this=*0x%x)", _this);
|
||||
}
|
||||
|
||||
error_code cellDaisyScatterGatherInterlock_probe(vm::ptr<ScatterGatherInterlock> _this, u32 isBlocking)
|
||||
{
|
||||
cellDaisy.todo("cellDaisyScatterGatherInterlock_probe()");
|
||||
cellDaisy.todo("cellDaisyScatterGatherInterlock_probe(_this=*0x%x, isBlocking=%d)", _this, isBlocking);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellDaisyScatterGatherInterlock_release(vm::ptr<ScatterGatherInterlock> _this)
|
||||
{
|
||||
cellDaisy.todo("cellDaisyScatterGatherInterlock_release()");
|
||||
cellDaisy.todo("cellDaisyScatterGatherInterlock_release(_this=*0x%x)", _this);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
void cellDaisyScatterGatherInterlock_proceedSequenceNumber(vm::ptr<ScatterGatherInterlock> _this)
|
||||
{
|
||||
cellDaisy.todo("cellDaisyScatterGatherInterlock_proceedSequenceNumber()");
|
||||
cellDaisy.todo("cellDaisyScatterGatherInterlock_proceedSequenceNumber(_this=*0x%x)", _this);
|
||||
}
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -11,11 +11,6 @@
|
|||
|
||||
LOG_CHANNEL(cellGifDec);
|
||||
|
||||
// Temporarily
|
||||
#ifndef _MSC_VER
|
||||
#pragma GCC diagnostic ignored "-Wunused-parameter"
|
||||
#endif
|
||||
|
||||
template <>
|
||||
void fmt_class_string<CellGifDecError>::format(std::string& out, u64 arg)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -11,11 +11,6 @@
|
|||
|
||||
LOG_CHANNEL(cellJpgDec);
|
||||
|
||||
// Temporarily
|
||||
#ifndef _MSC_VER
|
||||
#pragma GCC diagnostic ignored "-Wunused-parameter"
|
||||
#endif
|
||||
|
||||
template <>
|
||||
void fmt_class_string<CellJpgDecError>::format(std::string& out, u64 arg)
|
||||
{
|
||||
|
|
@ -40,19 +35,19 @@ void fmt_class_string<CellJpgDecError>::format(std::string& out, u64 arg)
|
|||
|
||||
error_code cellJpgDecCreate(u32 mainHandle, u32 threadInParam, u32 threadOutParam)
|
||||
{
|
||||
UNIMPLEMENTED_FUNC(cellJpgDec);
|
||||
cellJpgDec.todo("cellJpgDecCreate(mainHandle=0x%x, threadInParam=0x%x, threadOutParam=0x%x)", mainHandle, threadInParam, threadOutParam);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellJpgDecExtCreate(u32 mainHandle, u32 threadInParam, u32 threadOutParam, u32 extThreadInParam, u32 extThreadOutParam)
|
||||
{
|
||||
UNIMPLEMENTED_FUNC(cellJpgDec);
|
||||
cellJpgDec.todo("cellJpgDecExtCreate(mainHandle=0x%x, threadInParam=0x%x, threadOutParam=0x%x, extThreadInParam=0x%x, extThreadOutParam=0x%x)", mainHandle, threadInParam, threadOutParam, extThreadInParam, extThreadOutParam);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellJpgDecDestroy(u32 mainHandle)
|
||||
{
|
||||
UNIMPLEMENTED_FUNC(cellJpgDec);
|
||||
cellJpgDec.todo("cellJpgDecDestroy(mainHandle=0x%x)", mainHandle);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
|
|
@ -230,7 +225,7 @@ error_code cellJpgDecDecodeData(u32 mainHandle, u32 subHandle, vm::ptr<u8> data,
|
|||
}
|
||||
|
||||
//Decode JPG file. (TODO: Is there any faster alternative? Can we do it without external libraries?)
|
||||
int width, height, actual_components;
|
||||
int width = 0, height = 0, actual_components = 0;
|
||||
auto image = std::unique_ptr<unsigned char,decltype(&::free)>
|
||||
(
|
||||
stbi_load_from_memory(jpg.get(), ::narrow<int>(fileSize), &width, &height, &actual_components, 4),
|
||||
|
|
@ -275,7 +270,7 @@ error_code cellJpgDecDecodeData(u32 mainHandle, u32 subHandle, vm::ptr<u8> data,
|
|||
{
|
||||
//TODO: Find out if we can't do padding without an extra copy
|
||||
const int linesize = std::min(bytesPerLine, width * nComponents);
|
||||
const auto output = std::make_unique<char[]>(linesize);
|
||||
std::vector<char> output(image_size);
|
||||
for (int i = 0; i < height; i++)
|
||||
{
|
||||
const int dstOffset = i * bytesPerLine;
|
||||
|
|
@ -287,22 +282,22 @@ error_code cellJpgDecDecodeData(u32 mainHandle, u32 subHandle, vm::ptr<u8> data,
|
|||
output[j + 2] = image.get()[srcOffset + j + 1];
|
||||
output[j + 3] = image.get()[srcOffset + j + 2];
|
||||
}
|
||||
std::memcpy(&data[dstOffset], output.get(), linesize);
|
||||
std::memcpy(&data[dstOffset], output.data(), linesize);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
const auto img = std::make_unique<uint[]>(image_size);
|
||||
uint* source_current = reinterpret_cast<uint*>(image.get());
|
||||
uint* dest_current = img.get();
|
||||
for (uint i = 0; i < image_size / nComponents; i++)
|
||||
std::vector<u32> img(image_size);
|
||||
const u32* source_current = reinterpret_cast<const u32*>(image.get());
|
||||
u32* dest_current = img.data();
|
||||
for (u32 i = 0; i < image_size / nComponents; i++)
|
||||
{
|
||||
uint val = *source_current;
|
||||
const u32 val = *source_current;
|
||||
*dest_current = (val >> 24) | (val << 8); // set alpha (A8) as leftmost byte
|
||||
source_current++;
|
||||
dest_current++;
|
||||
}
|
||||
std::memcpy(data.get_ptr(), img.get(), image_size);
|
||||
std::memcpy(data.get_ptr(), img.data(), image_size);
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -19,11 +19,6 @@ typedef png_bytep iCCP_profile_type;
|
|||
typedef png_charp iCCP_profile_type;
|
||||
#endif
|
||||
|
||||
// Temporarily
|
||||
#ifndef _MSC_VER
|
||||
#pragma GCC diagnostic ignored "-Wunused-parameter"
|
||||
#endif
|
||||
|
||||
LOG_CHANNEL(cellPngDec);
|
||||
|
||||
template <>
|
||||
|
|
@ -149,7 +144,7 @@ void pngDecRowCallback(png_structp png_ptr, png_bytep new_row, png_uint_32 row_n
|
|||
png_progressive_combine_row(png_ptr, data, new_row);
|
||||
}
|
||||
|
||||
void pngDecInfoCallback(png_structp png_ptr, png_infop info)
|
||||
void pngDecInfoCallback(png_structp png_ptr, png_infop /*info*/)
|
||||
{
|
||||
PngStream* stream = static_cast<PngStream*>(png_get_progressive_ptr(png_ptr));
|
||||
if (!stream)
|
||||
|
|
@ -162,7 +157,7 @@ void pngDecInfoCallback(png_structp png_ptr, png_infop info)
|
|||
stream->buffer->cursor += (stream->buffer->length - remaining);
|
||||
}
|
||||
|
||||
void pngDecEndCallback(png_structp png_ptr, png_infop info)
|
||||
void pngDecEndCallback(png_structp png_ptr, png_infop /*info*/)
|
||||
{
|
||||
PngStream* stream = static_cast<PngStream*>(png_get_progressive_ptr(png_ptr));
|
||||
if (!stream)
|
||||
|
|
@ -175,17 +170,17 @@ void pngDecEndCallback(png_structp png_ptr, png_infop info)
|
|||
}
|
||||
|
||||
// Custom error handler for libpng
|
||||
[[noreturn]] void pngDecError(png_structp png_ptr, png_const_charp error_message)
|
||||
[[noreturn]] void pngDecError(png_structp /*png_ptr*/, png_const_charp error_message)
|
||||
{
|
||||
cellPngDec.error("%s", error_message);
|
||||
cellPngDec.error("pngDecError: %s", error_message);
|
||||
// we can't return here or libpng blows up
|
||||
fmt::throw_exception("Fatal Error in libpng: %s", error_message);
|
||||
}
|
||||
|
||||
// Custom warning handler for libpng
|
||||
void pngDecWarning(png_structp png_ptr, png_const_charp error_message)
|
||||
void pngDecWarning(png_structp /*png_ptr*/, png_const_charp error_message)
|
||||
{
|
||||
cellPngDec.warning("%s", error_message);
|
||||
cellPngDec.warning("pngDecWarning: %s", error_message);
|
||||
}
|
||||
|
||||
// Get the chunk information of the PNG file. IDAT is marked as existing, only after decoding or reading the header.
|
||||
|
|
@ -337,7 +332,7 @@ be_t<u32> pngDecGetChunkInformation(PngStream* stream, bool IDAT = false)
|
|||
return chunk_information;
|
||||
}
|
||||
|
||||
error_code pngDecCreate(ppu_thread& ppu, PPHandle png_handle, PThreadInParam thread_in_param, PThreadOutParam thread_out_param, PExtThreadInParam extra_thread_in_param = vm::null, PExtThreadOutParam extra_thread_out_param = vm::null)
|
||||
error_code pngDecCreate(ppu_thread& ppu, PPHandle png_handle, PThreadInParam thread_in_param, PThreadOutParam thread_out_param, PExtThreadInParam /*extra_thread_in_param*/ = vm::null, PExtThreadOutParam extra_thread_out_param = vm::null)
|
||||
{
|
||||
// Check if partial image decoding is used
|
||||
if (extra_thread_out_param)
|
||||
|
|
@ -908,103 +903,103 @@ error_code cellPngDecExtDecodeData(ppu_thread& ppu, PHandle handle, PStream stre
|
|||
|
||||
error_code cellPngDecGetUnknownChunks(PHandle handle, PStream stream, vm::pptr<CellPngUnknownChunk> unknownChunk, vm::ptr<u32> unknownChunkNumber)
|
||||
{
|
||||
cellPngDec.todo("cellPngDecGetUnknownChunks()");
|
||||
cellPngDec.todo("cellPngDecGetUnknownChunks(handle=*0x%x, stream=*0x%x, unknownChunk=*0x%x, unknownChunkNumber=*0x%x)", handle, stream, unknownChunk, unknownChunkNumber);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellPngDecGetpCAL(PHandle handle, PStream stream, vm::ptr<CellPngPCAL> pcal)
|
||||
{
|
||||
cellPngDec.todo("cellPngDecGetpCAL()");
|
||||
cellPngDec.todo("cellPngDecGetpCAL(handle=*0x%x, stream=*0x%x, pcal=*0x%x)", handle, stream, pcal);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellPngDecGetcHRM(PHandle handle, PStream stream, vm::ptr<CellPngCHRM> chrm)
|
||||
{
|
||||
cellPngDec.todo("cellPngDecGetcHRM()");
|
||||
cellPngDec.todo("cellPngDecGetcHRM(handle=*0x%x, stream=*0x%x, chrm=*0x%x)", handle, stream, chrm);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellPngDecGetsCAL(PHandle handle, PStream stream, vm::ptr<CellPngSCAL> scal)
|
||||
{
|
||||
cellPngDec.todo("cellPngDecGetsCAL()");
|
||||
cellPngDec.todo("cellPngDecGetsCAL(handle=*0x%x, stream=*0x%x, scal=*0x%x)", handle, stream, scal);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellPngDecGetpHYs(PHandle handle, PStream stream, vm::ptr<CellPngPHYS> phys)
|
||||
{
|
||||
cellPngDec.todo("cellPngDecGetpHYs()");
|
||||
cellPngDec.todo("cellPngDecGetpHYs(handle=*0x%x, stream=*0x%x, phys=*0x%x)", handle, stream, phys);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellPngDecGetoFFs(PHandle handle, PStream stream, vm::ptr<CellPngOFFS> offs)
|
||||
{
|
||||
cellPngDec.todo("cellPngDecGetoFFs()");
|
||||
cellPngDec.todo("cellPngDecGetoFFs(handle=*0x%x, stream=*0x%x, offs=*0x%x)", handle, stream, offs);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellPngDecGetsPLT(PHandle handle, PStream stream, vm::ptr<CellPngSPLT> splt)
|
||||
{
|
||||
cellPngDec.todo("cellPngDecGetsPLT()");
|
||||
cellPngDec.todo("cellPngDecGetsPLT(handle=*0x%x, stream=*0x%x, splt=*0x%x)", handle, stream, splt);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellPngDecGetbKGD(PHandle handle, PStream stream, vm::ptr<CellPngBKGD> bkgd)
|
||||
{
|
||||
cellPngDec.todo("cellPngDecGetbKGD()");
|
||||
cellPngDec.todo("cellPngDecGetbKGD(handle=*0x%x, stream=*0x%x, bkgd=*0x%x)", handle, stream, bkgd);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellPngDecGettIME(PHandle handle, PStream stream, vm::ptr<CellPngTIME> time)
|
||||
{
|
||||
cellPngDec.todo("cellPngDecGettIME()");
|
||||
cellPngDec.todo("cellPngDecGettIME(handle=*0x%x, stream=*0x%x, time=*0x%x)", handle, stream, time);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellPngDecGethIST(PHandle handle, PStream stream, vm::ptr<CellPngHIST> hist)
|
||||
{
|
||||
cellPngDec.todo("cellPngDecGethIST()");
|
||||
cellPngDec.todo("cellPngDecGethIST(handle=*0x%x, stream=*0x%x, hist=*0x%x)", handle, stream, hist);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellPngDecGettRNS(PHandle handle, PStream stream, vm::ptr<CellPngTRNS> trns)
|
||||
{
|
||||
cellPngDec.todo("cellPngDecGettRNS()");
|
||||
cellPngDec.todo("cellPngDecGettRNS(handle=*0x%x, stream=*0x%x, trns=*0x%x)", handle, stream, trns);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellPngDecGetsBIT(PHandle handle, PStream stream, vm::ptr<CellPngSBIT> sbit)
|
||||
{
|
||||
cellPngDec.todo("cellPngDecGetsBIT()");
|
||||
cellPngDec.todo("cellPngDecGetsBIT(handle=*0x%x, stream=*0x%x, sbit=*0x%x)", handle, stream, sbit);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellPngDecGetiCCP(PHandle handle, PStream stream, vm::ptr<CellPngICCP> iccp)
|
||||
{
|
||||
cellPngDec.todo("cellPngDecGetiCCP()");
|
||||
cellPngDec.todo("cellPngDecGetiCCP(handle=*0x%x, stream=*0x%x, iccp=*0x%x)", handle, stream, iccp);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellPngDecGetsRGB(PHandle handle, PStream stream, vm::ptr<CellPngSRGB> srgb)
|
||||
{
|
||||
cellPngDec.todo("cellPngDecGetsRGB()");
|
||||
cellPngDec.todo("cellPngDecGetsRGB(handle=*0x%x, stream=*0x%x, srgb=*0x%x)", handle, stream, srgb);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellPngDecGetgAMA(PHandle handle, PStream stream, vm::ptr<CellPngGAMA> gama)
|
||||
{
|
||||
cellPngDec.todo("cellPngDecGetgAMA()");
|
||||
cellPngDec.todo("cellPngDecGetgAMA(handle=*0x%x, stream=*0x%x, gama=*0x%x)", handle, stream, gama);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellPngDecGetPLTE(PHandle handle, PStream stream, vm::ptr<CellPngPLTE> plte)
|
||||
{
|
||||
cellPngDec.todo("cellPngDecGetPLTE()");
|
||||
cellPngDec.todo("cellPngDecGetPLTE(handle=*0x%x, stream=*0x%x, plte=*0x%x)", handle, stream, plte);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellPngDecGetTextChunk(PHandle handle, PStream stream, vm::ptr<u32> textInfoNum, vm::pptr<CellPngTextInfo> textInfo)
|
||||
{
|
||||
cellPngDec.todo("cellPngDecGetTextChunk()");
|
||||
cellPngDec.todo("cellPngDecGetTextChunk(handle=*0x%x, stream=*0x%x, textInfoNum=*0x%x, textInfo=*0x%x)", handle, stream, textInfoNum, textInfo);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -2500,12 +2500,7 @@ error_code cellSaveDataListDelete(ppu_thread& ppu, PSetList setList, PSetBuf set
|
|||
return savedata_op(ppu, SAVEDATA_OP_LIST_DELETE, 0, vm::null, 0, setList, setBuf, funcList, vm::null, vm::null, vm::null, container, 0x40, userdata, 0, funcDone);
|
||||
}
|
||||
|
||||
// Temporarily
|
||||
#ifndef _MSC_VER
|
||||
#pragma GCC diagnostic ignored "-Wunused-parameter"
|
||||
#endif
|
||||
|
||||
error_code cellSaveDataListImport(ppu_thread& ppu, PSetList setList, u32 maxSizeKB, PFuncDone funcDone, u32 container, vm::ptr<void> userdata)
|
||||
error_code cellSaveDataListImport(ppu_thread& /*ppu*/, PSetList setList, u32 maxSizeKB, PFuncDone funcDone, u32 container, vm::ptr<void> userdata)
|
||||
{
|
||||
cellSaveData.todo("cellSaveDataListImport(setList=*0x%x, maxSizeKB=%d, funcDone=*0x%x, container=0x%x, userdata=*0x%x)", setList, maxSizeKB, funcDone, container, userdata);
|
||||
|
||||
|
|
@ -2520,7 +2515,7 @@ error_code cellSaveDataListImport(ppu_thread& ppu, PSetList setList, u32 maxSize
|
|||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellSaveDataListExport(ppu_thread& ppu, PSetList setList, u32 maxSizeKB, PFuncDone funcDone, u32 container, vm::ptr<void> userdata)
|
||||
error_code cellSaveDataListExport(ppu_thread& /*ppu*/, PSetList setList, u32 maxSizeKB, PFuncDone funcDone, u32 container, vm::ptr<void> userdata)
|
||||
{
|
||||
cellSaveData.todo("cellSaveDataListExport(setList=*0x%x, maxSizeKB=%d, funcDone=*0x%x, container=0x%x, userdata=*0x%x)", setList, maxSizeKB, funcDone, container, userdata);
|
||||
|
||||
|
|
@ -2535,7 +2530,7 @@ error_code cellSaveDataListExport(ppu_thread& ppu, PSetList setList, u32 maxSize
|
|||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellSaveDataFixedImport(ppu_thread& ppu, vm::cptr<char> dirName, u32 maxSizeKB, PFuncDone funcDone, u32 container, vm::ptr<void> userdata)
|
||||
error_code cellSaveDataFixedImport(ppu_thread& /*ppu*/, vm::cptr<char> dirName, u32 maxSizeKB, PFuncDone funcDone, u32 container, vm::ptr<void> userdata)
|
||||
{
|
||||
cellSaveData.todo("cellSaveDataFixedImport(dirName=%s, maxSizeKB=%d, funcDone=*0x%x, container=0x%x, userdata=*0x%x)", dirName, maxSizeKB, funcDone, container, userdata);
|
||||
|
||||
|
|
@ -2550,7 +2545,7 @@ error_code cellSaveDataFixedImport(ppu_thread& ppu, vm::cptr<char> dirName, u32
|
|||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellSaveDataFixedExport(ppu_thread& ppu, vm::cptr<char> dirName, u32 maxSizeKB, PFuncDone funcDone, u32 container, vm::ptr<void> userdata)
|
||||
error_code cellSaveDataFixedExport(ppu_thread& /*ppu*/, vm::cptr<char> dirName, u32 maxSizeKB, PFuncDone funcDone, u32 container, vm::ptr<void> userdata)
|
||||
{
|
||||
cellSaveData.todo("cellSaveDataFixedExport(dirName=%s, maxSizeKB=%d, funcDone=*0x%x, container=0x%x, userdata=*0x%x)", dirName, maxSizeKB, funcDone, container, userdata);
|
||||
|
||||
|
|
@ -2581,7 +2576,7 @@ error_code cellSaveDataUserListDelete(ppu_thread& ppu, u32 userId, PSetList setL
|
|||
return savedata_op(ppu, SAVEDATA_OP_LIST_DELETE, 0, vm::null, 0, setList, setBuf, funcList, vm::null, vm::null, vm::null, container, 0x40, userdata, userId, funcDone);
|
||||
}
|
||||
|
||||
error_code cellSaveDataUserListImport(ppu_thread& ppu, u32 userId, PSetList setList, u32 maxSizeKB, PFuncDone funcDone, u32 container, vm::ptr<void> userdata)
|
||||
error_code cellSaveDataUserListImport(ppu_thread& /*ppu*/, u32 userId, PSetList setList, u32 maxSizeKB, PFuncDone funcDone, u32 container, vm::ptr<void> userdata)
|
||||
{
|
||||
cellSaveData.todo("cellSaveDataUserListImport(userId=%d, setList=*0x%x, maxSizeKB=%d, funcDone=*0x%x, container=0x%x, userdata=*0x%x)", userId, setList, maxSizeKB, funcDone, container, userdata);
|
||||
|
||||
|
|
@ -2596,7 +2591,7 @@ error_code cellSaveDataUserListImport(ppu_thread& ppu, u32 userId, PSetList setL
|
|||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellSaveDataUserListExport(ppu_thread& ppu, u32 userId, PSetList setList, u32 maxSizeKB, PFuncDone funcDone, u32 container, vm::ptr<void> userdata)
|
||||
error_code cellSaveDataUserListExport(ppu_thread& /*ppu*/, u32 userId, PSetList setList, u32 maxSizeKB, PFuncDone funcDone, u32 container, vm::ptr<void> userdata)
|
||||
{
|
||||
cellSaveData.todo("cellSaveDataUserListExport(userId=%d, setList=*0x%x, maxSizeKB=%d, funcDone=*0x%x, container=0x%x, userdata=*0x%x)", userId, setList, maxSizeKB, funcDone, container, userdata);
|
||||
|
||||
|
|
@ -2611,7 +2606,7 @@ error_code cellSaveDataUserListExport(ppu_thread& ppu, u32 userId, PSetList setL
|
|||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellSaveDataUserFixedImport(ppu_thread& ppu, u32 userId, vm::cptr<char> dirName, u32 maxSizeKB, PFuncDone funcDone, u32 container, vm::ptr<void> userdata)
|
||||
error_code cellSaveDataUserFixedImport(ppu_thread& /*ppu*/, u32 userId, vm::cptr<char> dirName, u32 maxSizeKB, PFuncDone funcDone, u32 container, vm::ptr<void> userdata)
|
||||
{
|
||||
cellSaveData.todo("cellSaveDataUserFixedImport(userId=%d, dirName=%s, maxSizeKB=%d, funcDone=*0x%x, container=0x%x, userdata=*0x%x)", userId, dirName, maxSizeKB, funcDone, container, userdata);
|
||||
|
||||
|
|
@ -2626,7 +2621,7 @@ error_code cellSaveDataUserFixedImport(ppu_thread& ppu, u32 userId, vm::cptr<cha
|
|||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellSaveDataUserFixedExport(ppu_thread& ppu, u32 userId, vm::cptr<char> dirName, u32 maxSizeKB, PFuncDone funcDone, u32 container, vm::ptr<void> userdata)
|
||||
error_code cellSaveDataUserFixedExport(ppu_thread& /*ppu*/, u32 userId, vm::cptr<char> dirName, u32 maxSizeKB, PFuncDone funcDone, u32 container, vm::ptr<void> userdata)
|
||||
{
|
||||
cellSaveData.todo("cellSaveDataUserFixedExport(userId=%d, dirName=%s, maxSizeKB=%d, funcDone=*0x%x, container=0x%x, userdata=*0x%x)", userId, dirName, maxSizeKB, funcDone, container, userdata);
|
||||
|
||||
|
|
|
|||
|
|
@ -160,11 +160,6 @@ void fmt_class_string<SpursWorkloadState>::format(std::string& out, u64 arg)
|
|||
|
||||
error_code sys_spu_image_close(ppu_thread&, vm::ptr<sys_spu_image> img);
|
||||
|
||||
// Temporarily
|
||||
#ifndef _MSC_VER
|
||||
#pragma GCC diagnostic ignored "-Wunused-parameter"
|
||||
#endif
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
// Function prototypes
|
||||
//----------------------------------------------------------------------------
|
||||
|
|
@ -738,7 +733,7 @@ void _spurs::handler_entry(ppu_thread& ppu, vm::ptr<CellSpurs> spurs)
|
|||
}
|
||||
}
|
||||
|
||||
s32 _spurs::create_handler(vm::ptr<CellSpurs> spurs, u32 ppuPriority)
|
||||
s32 _spurs::create_handler(vm::ptr<CellSpurs> /*spurs*/, u32 /*ppuPriority*/)
|
||||
{
|
||||
struct handler_thread : ppu_thread
|
||||
{
|
||||
|
|
@ -909,7 +904,7 @@ void _spurs::event_helper_entry(ppu_thread& ppu, vm::ptr<CellSpurs> spurs)
|
|||
}
|
||||
}
|
||||
|
||||
s32 _spurs::create_event_helper(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, u32 ppuPriority)
|
||||
s32 _spurs::create_event_helper(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, u32 /*ppuPriority*/)
|
||||
{
|
||||
if (s32 rc = _spurs::create_lv2_eq(ppu, spurs, spurs.ptr(&CellSpurs::eventQueue), spurs.ptr(&CellSpurs::spuPort), 0x2A, sys_event_queue_attribute_t{SYS_SYNC_PRIORITY, SYS_PPU_QUEUE, {"_spuPrv\0"_u64}}))
|
||||
{
|
||||
|
|
@ -981,7 +976,7 @@ void _spurs::init_event_port_mux(vm::ptr<CellSpurs::EventPortMux> eventPortMux,
|
|||
eventPortMux->x08 = unknown;
|
||||
}
|
||||
|
||||
s32 _spurs::add_default_syswkl(vm::ptr<CellSpurs> spurs, vm::cptr<u8> swlPriority, u32 swlMaxSpu, u32 swlIsPreem)
|
||||
s32 _spurs::add_default_syswkl(vm::ptr<CellSpurs> /*spurs*/, vm::cptr<u8> /*swlPriority*/, u32 /*swlMaxSpu*/, u32 /*swlIsPreem*/)
|
||||
{
|
||||
// TODO: Implement this
|
||||
return CELL_OK;
|
||||
|
|
@ -1859,7 +1854,7 @@ s32 cellSpursSetPriority(vm::ptr<CellSpurs> spurs, u32 wid, u32 spuId, u32 prior
|
|||
/// Set preemption victim SPU
|
||||
s32 cellSpursSetPreemptionVictimHints(vm::ptr<CellSpurs> spurs, vm::cptr<b8> isPreemptible)
|
||||
{
|
||||
UNIMPLEMENTED_FUNC(cellSpurs);
|
||||
cellSpurs.todo("cellSpursSetPreemptionVictimHints(spurs=*0x%x, isPreemptible=*0x%x)", spurs, isPreemptible);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
|
|
@ -2230,7 +2225,7 @@ s32 cellSpursTraceStop(ppu_thread& ppu, vm::ptr<CellSpurs> spurs)
|
|||
//----------------------------------------------------------------------------
|
||||
|
||||
/// Initialize attributes of a workload
|
||||
s32 _cellSpursWorkloadAttributeInitialize(ppu_thread& ppu, vm::ptr<CellSpursWorkloadAttribute> attr, u32 revision, u32 sdkVersion, vm::cptr<void> pm, u32 size, u64 data, vm::cptr<u8[8]> priority, u32 minCnt, u32 maxCnt)
|
||||
s32 _cellSpursWorkloadAttributeInitialize(ppu_thread& /*ppu*/, vm::ptr<CellSpursWorkloadAttribute> attr, u32 revision, u32 sdkVersion, vm::cptr<void> pm, u32 size, u64 data, vm::cptr<u8[8]> priority, u32 minCnt, u32 maxCnt)
|
||||
{
|
||||
cellSpurs.warning("_cellSpursWorkloadAttributeInitialize(attr=*0x%x, revision=%d, sdkVersion=0x%x, pm=*0x%x, size=0x%x, data=0x%llx, priority=*0x%x, minCnt=0x%x, maxCnt=0x%x)",
|
||||
attr, revision, sdkVersion, pm, size, data, priority, minCnt, maxCnt);
|
||||
|
|
@ -2277,7 +2272,7 @@ s32 _cellSpursWorkloadAttributeInitialize(ppu_thread& ppu, vm::ptr<CellSpursWork
|
|||
}
|
||||
|
||||
/// Set the name of a workload
|
||||
s32 cellSpursWorkloadAttributeSetName(ppu_thread& ppu, vm::ptr<CellSpursWorkloadAttribute> attr, vm::cptr<char> nameClass, vm::cptr<char> nameInstance)
|
||||
s32 cellSpursWorkloadAttributeSetName(ppu_thread& /*ppu*/, vm::ptr<CellSpursWorkloadAttribute> attr, vm::cptr<char> nameClass, vm::cptr<char> nameInstance)
|
||||
{
|
||||
cellSpurs.warning("cellSpursWorkloadAttributeSetName(attr=*0x%x, nameClass=%s, nameInstance=%s)", attr, nameClass, nameInstance);
|
||||
|
||||
|
|
@ -2771,7 +2766,7 @@ s32 cellSpursWakeUp(ppu_thread& ppu, vm::ptr<CellSpurs> spurs)
|
|||
}
|
||||
|
||||
/// Send a workload signal
|
||||
s32 cellSpursSendWorkloadSignal(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, u32 wid)
|
||||
s32 cellSpursSendWorkloadSignal(ppu_thread& /*ppu*/, vm::ptr<CellSpurs> spurs, u32 wid)
|
||||
{
|
||||
cellSpurs.warning("cellSpursSendWorkloadSignal(spurs=*0x%x, wid=%d)", spurs, wid);
|
||||
|
||||
|
|
@ -2833,7 +2828,7 @@ s32 cellSpursGetWorkloadFlag(vm::ptr<CellSpurs> spurs, vm::pptr<CellSpursWorkloa
|
|||
}
|
||||
|
||||
/// Set ready count
|
||||
s32 cellSpursReadyCountStore(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, u32 wid, u32 value)
|
||||
s32 cellSpursReadyCountStore(ppu_thread& /*ppu*/, vm::ptr<CellSpurs> spurs, u32 wid, u32 value)
|
||||
{
|
||||
cellSpurs.trace("cellSpursReadyCountStore(spurs=*0x%x, wid=%d, value=0x%x)", spurs, wid, value);
|
||||
|
||||
|
|
@ -2871,7 +2866,7 @@ s32 cellSpursReadyCountStore(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, u32 wid,
|
|||
}
|
||||
|
||||
/// Swap ready count
|
||||
s32 cellSpursReadyCountSwap(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, u32 wid, vm::ptr<u32> old, u32 swap)
|
||||
s32 cellSpursReadyCountSwap(ppu_thread& /*ppu*/, vm::ptr<CellSpurs> spurs, u32 wid, vm::ptr<u32> old, u32 swap)
|
||||
{
|
||||
cellSpurs.trace("cellSpursReadyCountSwap(spurs=*0x%x, wid=%d, old=*0x%x, swap=0x%x)", spurs, wid, old, swap);
|
||||
|
||||
|
|
@ -2909,7 +2904,7 @@ s32 cellSpursReadyCountSwap(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, u32 wid,
|
|||
}
|
||||
|
||||
/// Compare and swap ready count
|
||||
s32 cellSpursReadyCountCompareAndSwap(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, u32 wid, vm::ptr<u32> old, u32 compare, u32 swap)
|
||||
s32 cellSpursReadyCountCompareAndSwap(ppu_thread& /*ppu*/, vm::ptr<CellSpurs> spurs, u32 wid, vm::ptr<u32> old, u32 compare, u32 swap)
|
||||
{
|
||||
cellSpurs.trace("cellSpursReadyCountCompareAndSwap(spurs=*0x%x, wid=%d, old=*0x%x, compare=0x%x, swap=0x%x)", spurs, wid, old, compare, swap);
|
||||
|
||||
|
|
@ -2950,7 +2945,7 @@ s32 cellSpursReadyCountCompareAndSwap(ppu_thread& ppu, vm::ptr<CellSpurs> spurs,
|
|||
}
|
||||
|
||||
/// Increase or decrease ready count
|
||||
s32 cellSpursReadyCountAdd(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, u32 wid, vm::ptr<u32> old, s32 value)
|
||||
s32 cellSpursReadyCountAdd(ppu_thread& /*ppu*/, vm::ptr<CellSpurs> spurs, u32 wid, vm::ptr<u32> old, s32 value)
|
||||
{
|
||||
cellSpurs.trace("cellSpursReadyCountAdd(spurs=*0x%x, wid=%d, old=*0x%x, value=0x%x)", spurs, wid, old, value);
|
||||
|
||||
|
|
@ -3030,7 +3025,7 @@ s32 cellSpursGetWorkloadData(vm::ptr<CellSpurs> spurs, vm::ptr<u64> data, u32 wi
|
|||
}
|
||||
|
||||
/// Get workload information
|
||||
s32 cellSpursGetWorkloadInfo(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, u32 wid, vm::ptr<CellSpursWorkloadInfo> info)
|
||||
s32 cellSpursGetWorkloadInfo(ppu_thread& /*ppu*/, vm::ptr<CellSpurs> spurs, u32 wid, vm::ptr<CellSpursWorkloadInfo> info)
|
||||
{
|
||||
cellSpurs.todo("cellSpursGetWorkloadInfo(spurs=*0x%x, wid=0x%x, info=*0x%x)", spurs, wid, info);
|
||||
return CELL_OK;
|
||||
|
|
@ -3135,7 +3130,7 @@ s32 _cellSpursWorkloadFlagReceiver(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, u3
|
|||
}
|
||||
|
||||
/// Set/unset the recipient of the workload flag
|
||||
s32 _cellSpursWorkloadFlagReceiver2(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, u32 wid, u32 is_set, u32 print_debug_output)
|
||||
s32 _cellSpursWorkloadFlagReceiver2(ppu_thread& /*ppu*/, vm::ptr<CellSpurs> spurs, u32 wid, u32 is_set, u32 print_debug_output)
|
||||
{
|
||||
cellSpurs.warning("_cellSpursWorkloadFlagReceiver2(spurs=*0x%x, wid=%d, is_set=%d, print_debug_output=%d)", spurs, wid, is_set, print_debug_output);
|
||||
|
||||
|
|
@ -3833,19 +3828,19 @@ s32 _cellSpursLFQueueInitialize(vm::ptr<void> pTasksetOrSpurs, vm::ptr<CellSpurs
|
|||
|
||||
s32 _cellSpursLFQueuePushBody()
|
||||
{
|
||||
UNIMPLEMENTED_FUNC(cellSpurs);
|
||||
cellSpurs.todo("_cellSpursLFQueuePushBody()");
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
s32 cellSpursLFQueueAttachLv2EventQueue(vm::ptr<CellSyncLFQueue> queue)
|
||||
{
|
||||
UNIMPLEMENTED_FUNC(cellSpurs);
|
||||
cellSpurs.todo("cellSpursLFQueueAttachLv2EventQueue(queue=*0x%x)", queue);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
s32 cellSpursLFQueueDetachLv2EventQueue(vm::ptr<CellSyncLFQueue> queue)
|
||||
{
|
||||
UNIMPLEMENTED_FUNC(cellSpurs);
|
||||
cellSpurs.todo("cellSpursLFQueueDetachLv2EventQueue(queue=*0x%x)", queue);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
|
|
@ -4571,7 +4566,7 @@ s32 cellSpursTasksetUnsetExceptionEventHandler(vm::ptr<CellSpursTaskset> taskset
|
|||
return CELL_OK;
|
||||
}
|
||||
|
||||
s32 cellSpursLookUpTasksetAddress(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, vm::pptr<CellSpursTaskset> taskset, u32 id)
|
||||
s32 cellSpursLookUpTasksetAddress(ppu_thread& /*ppu*/, vm::ptr<CellSpurs> spurs, vm::pptr<CellSpursTaskset> taskset, u32 id)
|
||||
{
|
||||
cellSpurs.warning("cellSpursLookUpTasksetAddress(spurs=*0x%x, taskset=**0x%x, id=0x%x)", spurs, taskset, id);
|
||||
|
||||
|
|
@ -4653,9 +4648,9 @@ s32 _cellSpursTasksetAttributeInitialize(vm::ptr<CellSpursTasksetAttribute> attr
|
|||
return CELL_OK;
|
||||
}
|
||||
|
||||
s32 _spurs::check_job_chain_attribute(u32 sdkVer, vm::cptr<u64> jcEntry, u16 sizeJobDescr, u16 maxGrabbedJob
|
||||
, u64 priorities, u32 maxContention, u8 autoSpuCount, u32 tag1, u32 tag2
|
||||
, u8 isFixedMemAlloc, u32 maxSizeJob, u32 initSpuCount)
|
||||
s32 _spurs::check_job_chain_attribute(u32 sdkVer, vm::cptr<u64> jcEntry, u16 sizeJobDescr, u16 maxGrabbedJob,
|
||||
u64 priorities, u32 /*maxContention*/, u8 autoSpuCount, u32 tag1, u32 tag2,
|
||||
u8 /*isFixedMemAlloc*/, u32 maxSizeJob, u32 initSpuCount)
|
||||
{
|
||||
if (!jcEntry)
|
||||
return CELL_SPURS_JOB_ERROR_NULL_POINTER;
|
||||
|
|
@ -4686,9 +4681,9 @@ s32 _spurs::check_job_chain_attribute(u32 sdkVer, vm::cptr<u64> jcEntry, u16 siz
|
|||
return CELL_OK;
|
||||
}
|
||||
|
||||
s32 _spurs::create_job_chain(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, vm::ptr<CellSpursJobChain> jobChain, vm::cptr<u64> jobChainEntry, u16 sizeJob
|
||||
, u16 maxGrabbedJob, vm::cptr<u8[8]> prio, u32 maxContention, b8 autoReadyCount
|
||||
, u32 tag1, u32 tag2, u32 HaltOnError, vm::cptr<char> name, u32 param_13, u32 param_14)
|
||||
s32 _spurs::create_job_chain(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, vm::ptr<CellSpursJobChain> jobChain, vm::cptr<u64> jobChainEntry, u16 /*sizeJob*/,
|
||||
u16 maxGrabbedJob, vm::cptr<u8[8]> prio, u32 maxContention, b8 /*autoReadyCount*/,
|
||||
u32 tag1, u32 tag2, u32 /*HaltOnError*/, vm::cptr<char> name, u32 /*param_13*/, u32 /*param_14*/)
|
||||
{
|
||||
const s32 sdkVer = _spurs::get_sdk_version();
|
||||
jobChain->spurs = spurs;
|
||||
|
|
|
|||
|
|
@ -15,7 +15,6 @@ LOG_CHANNEL(cellSpurs);
|
|||
// Temporarily
|
||||
#ifndef _MSC_VER
|
||||
#pragma GCC diagnostic ignored "-Wunused-function"
|
||||
#pragma GCC diagnostic ignored "-Wunused-parameter"
|
||||
#endif
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
|
|
@ -89,7 +88,7 @@ void spursJobchainPopUrgentCommand(spu_thread& spu);
|
|||
//----------------------------------------------------------------------------
|
||||
|
||||
// Output trace information
|
||||
void cellSpursModulePutTrace(CellSpursTracePacket* packet, u32 dmaTagId)
|
||||
void cellSpursModulePutTrace(CellSpursTracePacket* /*packet*/, u32 /*dmaTagId*/)
|
||||
{
|
||||
// TODO: Implement this
|
||||
}
|
||||
|
|
@ -871,7 +870,7 @@ void spursSysServiceIdleHandler(spu_thread& spu, SpursKernelContext* ctxt)
|
|||
}
|
||||
|
||||
// Main function for the system service
|
||||
void spursSysServiceMain(spu_thread& spu, u32 pollStatus)
|
||||
void spursSysServiceMain(spu_thread& spu, u32 /*pollStatus*/)
|
||||
{
|
||||
const auto ctxt = spu._ptr<SpursKernelContext>(0x100);
|
||||
|
||||
|
|
@ -1166,7 +1165,7 @@ void spursSysServiceUpdateShutdownCompletionEvents(spu_thread& spu, SpursKernelC
|
|||
}
|
||||
|
||||
// Update the trace count for this SPU
|
||||
void spursSysServiceTraceSaveCount(spu_thread& spu, SpursKernelContext* ctxt)
|
||||
void spursSysServiceTraceSaveCount(spu_thread& /*spu*/, SpursKernelContext* ctxt)
|
||||
{
|
||||
if (ctxt->traceBuffer)
|
||||
{
|
||||
|
|
@ -2056,7 +2055,7 @@ s32 spursTasksetLoadElf(spu_thread& spu, u32* entryPoint, u32* lowestLoadAddr, u
|
|||
//----------------------------------------------------------------------------
|
||||
// SPURS taskset policy module functions
|
||||
//----------------------------------------------------------------------------
|
||||
bool spursJobChainEntry(spu_thread& spu)
|
||||
bool spursJobChainEntry(spu_thread& /*spu*/)
|
||||
{
|
||||
//const auto ctxt = spu._ptr<SpursJobChainContext>(0x4a00);
|
||||
//auto kernelCtxt = spu._ptr<SpursKernelContext>(spu.gpr[3]._u32[3]);
|
||||
|
|
|
|||
|
|
@ -478,11 +478,6 @@ error_code cellVideoOutGetResolutionAvailability(u32 videoOut, u32 resolutionId,
|
|||
return CELL_VIDEO_OUT_ERROR_UNSUPPORTED_VIDEO_OUT;
|
||||
}
|
||||
|
||||
// Temporarily
|
||||
#ifndef _MSC_VER
|
||||
#pragma GCC diagnostic ignored "-Wunused-parameter"
|
||||
#endif
|
||||
|
||||
error_code cellVideoOutGetConvertCursorColorInfo(vm::ptr<u8> rgbOutputRange)
|
||||
{
|
||||
cellSysutil.todo("cellVideoOutGetConvertCursorColorInfo(rgbOutputRange=*0x%x)", rgbOutputRange);
|
||||
|
|
|
|||
|
|
@ -34,308 +34,303 @@ void fmt_class_string<CellSnd3Error>::format(std::string& out, u64 arg)
|
|||
});
|
||||
}
|
||||
|
||||
// Temporarily
|
||||
#ifndef _MSC_VER
|
||||
#pragma GCC diagnostic ignored "-Wunused-parameter"
|
||||
#endif
|
||||
|
||||
error_code cellSnd3Init(u32 maxVoice, u32 samples, vm::ptr<CellSnd3RequestQueueCtx> queue)
|
||||
{
|
||||
UNIMPLEMENTED_FUNC(libsnd3);
|
||||
libsnd3.todo("cellSnd3Init(maxVoice=%d, samples=%d, queue=*0x%x)", maxVoice, samples, queue);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellSnd3Exit()
|
||||
{
|
||||
UNIMPLEMENTED_FUNC(libsnd3);
|
||||
libsnd3.todo("cellSnd3Exit()");
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
u16 cellSnd3Note2Pitch(u16 center_note, u16 center_fine, u16 note, s16 fine)
|
||||
{
|
||||
libsnd3.todo("cellSnd3Note2Pitch()");
|
||||
libsnd3.todo("cellSnd3Note2Pitch(center_note=%d, center_fine=%d, note=%d, fine=%d)", center_note, center_fine, note, fine);
|
||||
return 0;
|
||||
}
|
||||
|
||||
u16 cellSnd3Pitch2Note(u16 center_note, u16 center_fine, u16 pitch)
|
||||
{
|
||||
libsnd3.todo("cellSnd3Pitch2Note()");
|
||||
libsnd3.todo("cellSnd3Pitch2Note(center_note=%d, center_fine=%d, pitch=%d)", center_note, center_fine, pitch);
|
||||
return 0;
|
||||
}
|
||||
|
||||
error_code cellSnd3SetOutputMode(u32 mode)
|
||||
{
|
||||
UNIMPLEMENTED_FUNC(libsnd3);
|
||||
libsnd3.todo("cellSnd3SetOutputMode(mode=%d)", mode);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellSnd3Synthesis(vm::ptr<f32> pOutL, vm::ptr<f32> pOutR)
|
||||
{
|
||||
UNIMPLEMENTED_FUNC(libsnd3);
|
||||
libsnd3.todo("cellSnd3Synthesis(pOutL=*0x%x, pOutR=*0x%x)", pOutL, pOutR);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellSnd3SynthesisEx(vm::ptr<f32> pOutL, vm::ptr<f32> pOutR, vm::ptr<f32> pOutRL, vm::ptr<f32> pOutRR)
|
||||
{
|
||||
UNIMPLEMENTED_FUNC(libsnd3);
|
||||
libsnd3.todo("cellSnd3SynthesisEx(pOutL=*0x%x, pOutR=*0x%x, pOutRL=*0x%x, pOutRR=*0x%x)", pOutL, pOutR, pOutRL, pOutRR);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellSnd3BindSoundData(vm::ptr<CellSnd3DataCtx> snd3Ctx, vm::ptr<void> hd3, u32 synthMemOffset)
|
||||
{
|
||||
UNIMPLEMENTED_FUNC(libsnd3);
|
||||
libsnd3.todo("cellSnd3BindSoundData(snd3Ctx=*0x%x, hd3=*0x%x, synthMemOffset=0x%x)", snd3Ctx, hd3, synthMemOffset);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellSnd3UnbindSoundData(u32 hd3ID)
|
||||
{
|
||||
UNIMPLEMENTED_FUNC(libsnd3);
|
||||
libsnd3.todo("cellSnd3UnbindSoundData(hd3ID=0x%x)", hd3ID);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellSnd3NoteOnByTone(u32 hd3ID, u32 toneIndex, u32 note, u32 keyOnID, vm::ptr<CellSnd3KeyOnParam> keyOnParam)
|
||||
{
|
||||
libsnd3.todo("cellSnd3NoteOnByTone()");
|
||||
libsnd3.todo("cellSnd3NoteOnByTone(hd3ID=0x%x, toneIndex=%d, note=%d, keyOnID=0x%x, keyOnParam=*0x%x)", hd3ID, toneIndex, note, keyOnID, keyOnParam);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellSnd3KeyOnByTone(u32 hd3ID, u32 toneIndex, u32 pitch, u32 keyOnID, vm::ptr<CellSnd3KeyOnParam> keyOnParam)
|
||||
{
|
||||
libsnd3.todo("cellSnd3KeyOnByTone()");
|
||||
libsnd3.todo("cellSnd3KeyOnByTone(hd3ID=0x%x, toneIndex=%d, pitch=%d, keyOnID=0x%x, keyOnParam=*0x%x)", hd3ID, toneIndex, pitch, keyOnID, keyOnParam);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellSnd3VoiceNoteOnByTone(u32 hd3ID, u32 voiceNum, u32 toneIndex, u32 note, u32 keyOnID, vm::ptr<CellSnd3KeyOnParam> keyOnParam)
|
||||
{
|
||||
libsnd3.todo("cellSnd3VoiceNoteOnByTone()");
|
||||
libsnd3.todo("cellSnd3VoiceNoteOnByTone(hd3ID=0x%x, voiceNum=%d, toneIndex=%d, note=%d, keyOnID=0x%x, keyOnParam=*0x%x)", hd3ID, voiceNum, toneIndex, note, keyOnID, keyOnParam);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellSnd3VoiceKeyOnByTone(u32 hd3ID, u32 voiceNum, u32 toneIndex, u32 pitch, u32 keyOnID, vm::ptr<CellSnd3KeyOnParam> keyOnParam)
|
||||
{
|
||||
libsnd3.todo("cellSnd3VoiceKeyOnByTone()");
|
||||
libsnd3.todo("cellSnd3VoiceKeyOnByTone(hd3ID=0x%x, voiceNum=%d, toneIndex=%d, pitch=%d, keyOnID=0x%x, keyOnParam=*0x%x)", hd3ID, voiceNum, toneIndex, pitch, keyOnID, keyOnParam);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellSnd3VoiceSetReserveMode(u32 voiceNum, u32 reserveMode)
|
||||
{
|
||||
UNIMPLEMENTED_FUNC(libsnd3);
|
||||
libsnd3.todo("cellSnd3VoiceSetReserveMode(voiceNum=%d, reserveMode=%d)", voiceNum, reserveMode);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellSnd3VoiceSetSustainHold(u32 voiceNum, u32 sustainHold)
|
||||
{
|
||||
UNIMPLEMENTED_FUNC(libsnd3);
|
||||
libsnd3.todo("cellSnd3VoiceSetSustainHold(voiceNum=%d, sustainHold=%d)", voiceNum, sustainHold);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellSnd3VoiceKeyOff(u32 voiceNum)
|
||||
{
|
||||
UNIMPLEMENTED_FUNC(libsnd3);
|
||||
libsnd3.todo("cellSnd3VoiceKeyOff(voiceNum=%d)", voiceNum);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellSnd3VoiceSetPitch(u32 voiceNum, s32 addPitch)
|
||||
{
|
||||
UNIMPLEMENTED_FUNC(libsnd3);
|
||||
libsnd3.todo("cellSnd3VoiceSetPitch(voiceNum=%d, addPitch=%d)", voiceNum, addPitch);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellSnd3VoiceSetVelocity(u32 voiceNum, u32 velocity)
|
||||
{
|
||||
UNIMPLEMENTED_FUNC(libsnd3);
|
||||
libsnd3.todo("cellSnd3VoiceSetVelocity(voiceNum=%d, velocity=%d)", voiceNum, velocity);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellSnd3VoiceSetPanpot(u32 voiceNum, u32 panpot)
|
||||
{
|
||||
UNIMPLEMENTED_FUNC(libsnd3);
|
||||
libsnd3.todo("cellSnd3VoiceSetPanpot(voiceNum=%d, panpot=%d)", voiceNum, panpot);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellSnd3VoiceSetPanpotEx(u32 voiceNum, u32 panpotEx)
|
||||
{
|
||||
UNIMPLEMENTED_FUNC(libsnd3);
|
||||
libsnd3.todo("cellSnd3VoiceSetPanpotEx(voiceNum=%d, panpotEx=%d)", voiceNum, panpotEx);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellSnd3VoiceSetPitchBend(u32 voiceNum, u32 bendValue)
|
||||
{
|
||||
UNIMPLEMENTED_FUNC(libsnd3);
|
||||
libsnd3.todo("cellSnd3VoiceSetPitchBend(voiceNum=%d, bendValue=%d)", voiceNum, bendValue);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellSnd3VoiceAllKeyOff()
|
||||
{
|
||||
UNIMPLEMENTED_FUNC(libsnd3);
|
||||
libsnd3.todo("cellSnd3VoiceAllKeyOff()");
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellSnd3VoiceGetEnvelope(u32 voiceNum)
|
||||
{
|
||||
UNIMPLEMENTED_FUNC(libsnd3);
|
||||
libsnd3.todo("cellSnd3VoiceGetEnvelope(voiceNum=%d)", voiceNum);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellSnd3VoiceGetStatus(u32 voiceNum)
|
||||
{
|
||||
libsnd3.todo("cellSnd3VoiceGetStatus()");
|
||||
libsnd3.todo("cellSnd3VoiceGetStatus(voiceNum=%d)", voiceNum);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
u32 cellSnd3KeyOffByID(u32 keyOnID)
|
||||
{
|
||||
UNIMPLEMENTED_FUNC(libsnd3);
|
||||
libsnd3.todo("cellSnd3KeyOffByID(keyOnID=%d)", keyOnID);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellSnd3GetVoice(u32 midiChannel, u32 keyOnID, vm::ptr<CellSnd3VoiceBitCtx> voiceBit)
|
||||
{
|
||||
UNIMPLEMENTED_FUNC(libsnd3);
|
||||
libsnd3.todo("cellSnd3GetVoice(midiChannel=%d, keyOnID=%d, voiceBit=*0x%x)", midiChannel, keyOnID, voiceBit);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellSnd3GetVoiceByID(u32 ID, vm::ptr<CellSnd3VoiceBitCtx> voiceBit)
|
||||
{
|
||||
UNIMPLEMENTED_FUNC(libsnd3);
|
||||
libsnd3.todo("cellSnd3GetVoiceByID(ID=%d, voiceBit=*0x%x)", ID, voiceBit);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellSnd3NoteOn(u32 hd3ID, u32 midiChannel, u32 midiProgram, u32 midiNote, u32 sustain, vm::ptr<CellSnd3KeyOnParam> keyOnParam, u32 keyOnID)
|
||||
{
|
||||
UNIMPLEMENTED_FUNC(libsnd3);
|
||||
libsnd3.todo("cellSnd3NoteOn(hd3ID=%d, midiChannel=%d, midiProgram=%d, midiNote=%d, sustain=%d, keyOnParam=*0x%x, keyOnID=%d)", hd3ID, midiChannel, midiProgram, midiNote, sustain, keyOnParam, keyOnID);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellSnd3NoteOff(u32 midiChannel, u32 midiNote, u32 keyOnID)
|
||||
{
|
||||
UNIMPLEMENTED_FUNC(libsnd3);
|
||||
libsnd3.todo("cellSnd3NoteOff(midiChannel=%d, midiNote=%d, keyOnID=%d)", midiChannel, midiNote, keyOnID);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellSnd3SetSustainHold(u32 midiChannel, u32 sustainHold, u32 keyOnID)
|
||||
{
|
||||
UNIMPLEMENTED_FUNC(libsnd3);
|
||||
libsnd3.todo("cellSnd3SetSustainHold(midiChannel=%d, sustainHold=%d, keyOnID=%d)", midiChannel, sustainHold, keyOnID);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellSnd3SetEffectType(u16 effectType, s16 returnVol, u16 delay, u16 feedback)
|
||||
{
|
||||
UNIMPLEMENTED_FUNC(libsnd3);
|
||||
libsnd3.todo("cellSnd3SetEffectType(effectType=%d, returnVol=%d, delay=%d, feedback=%d)", effectType, returnVol, delay, feedback);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellSnd3SMFBind(vm::ptr<CellSnd3SmfCtx> smfCtx, vm::ptr<void> smf, u32 hd3ID)
|
||||
{
|
||||
libsnd3.todo("cellSnd3SMFBind()");
|
||||
libsnd3.todo("cellSnd3SMFBind(smfCtx=*0x%x, delay=*0x%x, hd3ID=%d)", smfCtx, smf, hd3ID);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellSnd3SMFUnbind(u32 smfID)
|
||||
{
|
||||
libsnd3.todo("cellSnd3SMFUnbind()");
|
||||
libsnd3.todo("cellSnd3SMFUnbind(smfID=%d)", smfID);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellSnd3SMFPlay(u32 smfID, u32 playVelocity, u32 playPan, u32 playCount)
|
||||
{
|
||||
UNIMPLEMENTED_FUNC(libsnd3);
|
||||
libsnd3.todo("cellSnd3SMFPlay(smfID=%d, playVelocity=%d, playPan=%d, playCount=%d)", smfID, playVelocity, playPan, playCount);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellSnd3SMFPlayEx(u32 smfID, u32 playVelocity, u32 playPan, u32 playPanEx, u32 playCount)
|
||||
{
|
||||
UNIMPLEMENTED_FUNC(libsnd3);
|
||||
libsnd3.todo("cellSnd3SMFPlayEx(smfID=%d, playVelocity=%d, playPan=%d, playPanEx=%d, playCount=%d)", smfID, playVelocity, playPan, playPanEx, playCount);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellSnd3SMFPause(u32 smfID)
|
||||
{
|
||||
UNIMPLEMENTED_FUNC(libsnd3);
|
||||
libsnd3.todo("cellSnd3SMFPause(smfID=%d)", smfID);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellSnd3SMFResume(u32 smfID)
|
||||
{
|
||||
UNIMPLEMENTED_FUNC(libsnd3);
|
||||
libsnd3.todo("cellSnd3SMFResume(smfID=%d)", smfID);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellSnd3SMFStop(u32 smfID)
|
||||
{
|
||||
UNIMPLEMENTED_FUNC(libsnd3);
|
||||
libsnd3.todo("cellSnd3SMFStop(smfID=%d)", smfID);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellSnd3SMFAddTempo(u32 smfID, s32 addTempo)
|
||||
{
|
||||
UNIMPLEMENTED_FUNC(libsnd3);
|
||||
libsnd3.todo("cellSnd3SMFAddTempo(smfID=%d, addTempo=%d)", smfID, addTempo);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellSnd3SMFGetTempo(u32 smfID)
|
||||
{
|
||||
libsnd3.todo("cellSnd3SMFGetTempo()");
|
||||
libsnd3.todo("cellSnd3SMFGetTempo(smfID=%d)", smfID);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellSnd3SMFSetPlayVelocity(u32 smfID, u32 playVelocity)
|
||||
{
|
||||
UNIMPLEMENTED_FUNC(libsnd3);
|
||||
libsnd3.todo("cellSnd3SMFSetPlayVelocity(smfID=%d, playVelocity=%d)", smfID, playVelocity);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellSnd3SMFGetPlayVelocity(u32 smfID)
|
||||
{
|
||||
libsnd3.todo("cellSnd3SMFGetPlayVelocity()");
|
||||
libsnd3.todo("cellSnd3SMFGetPlayVelocity(smfID=%d)", smfID);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellSnd3SMFSetPlayPanpot(u32 smfID, u32 playPanpot)
|
||||
{
|
||||
UNIMPLEMENTED_FUNC(libsnd3);
|
||||
libsnd3.todo("cellSnd3SMFSetPlayPanpot(smfID=%d, playPanpot=%d)", smfID, playPanpot);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellSnd3SMFSetPlayPanpotEx(u32 smfID, u32 playPanpotEx)
|
||||
{
|
||||
UNIMPLEMENTED_FUNC(libsnd3);
|
||||
libsnd3.todo("cellSnd3SMFSetPlayPanpotEx(smfID=%d, playPanpotEx=%d)", smfID, playPanpotEx);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellSnd3SMFGetPlayPanpot(u32 smfID)
|
||||
{
|
||||
libsnd3.todo("cellSnd3SMFGetPlayPanpot()");
|
||||
libsnd3.todo("cellSnd3SMFGetPlayPanpot(smfID=%d)", smfID);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellSnd3SMFGetPlayPanpotEx(u32 smfID)
|
||||
{
|
||||
libsnd3.todo("cellSnd3SMFGetPlayPanpotEx()");
|
||||
libsnd3.todo("cellSnd3SMFGetPlayPanpotEx(smfID=%d)", smfID);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellSnd3SMFGetPlayStatus(u32 smfID)
|
||||
{
|
||||
libsnd3.todo("cellSnd3SMFGetPlayStatus()");
|
||||
libsnd3.todo("cellSnd3SMFGetPlayStatus(smfID=%d)", smfID);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellSnd3SMFSetPlayChannel(u32 smfID, u32 playChannelBit)
|
||||
{
|
||||
UNIMPLEMENTED_FUNC(libsnd3);
|
||||
libsnd3.todo("cellSnd3SMFSetPlayChannel(smfID=%d, playChannelBit=%d)", smfID, playChannelBit);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellSnd3SMFGetPlayChannel(u32 smfID, vm::ptr<u32> playChannelBit)
|
||||
{
|
||||
libsnd3.todo("cellSnd3SMFGetPlayChannel()");
|
||||
libsnd3.todo("cellSnd3SMFGetPlayChannel(smfID=%d, playChannelBit=*0x%x)", smfID, playChannelBit);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code cellSnd3SMFGetKeyOnID(u32 smfID, u32 midiChannel, vm::ptr<u32> keyOnID)
|
||||
{
|
||||
UNIMPLEMENTED_FUNC(libsnd3);
|
||||
libsnd3.todo("cellSnd3SMFAddTempo(smfID=%d, midiChannel=%d, keyOnID=*0x%x)", smfID, midiChannel, keyOnID);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -65,38 +65,33 @@ void fmt_class_string<CellLv2DbgError>::format(std::string& out, u64 arg)
|
|||
});
|
||||
}
|
||||
|
||||
// Temporarily
|
||||
#ifndef _MSC_VER
|
||||
#pragma GCC diagnostic ignored "-Wunused-parameter"
|
||||
#endif
|
||||
|
||||
error_code sys_dbg_read_ppu_thread_context(u64 id, vm::ptr<sys_dbg_ppu_thread_context_t> ppu_context)
|
||||
{
|
||||
sys_lv2dbg.todo("sys_dbg_read_ppu_thread_context()");
|
||||
sys_lv2dbg.todo("sys_dbg_read_ppu_thread_context(id=0x%x, ppu_context=*0x%x)", id, ppu_context);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code sys_dbg_read_spu_thread_context(u32 id, vm::ptr<sys_dbg_spu_thread_context_t> spu_context)
|
||||
{
|
||||
sys_lv2dbg.todo("sys_dbg_read_spu_thread_context()");
|
||||
sys_lv2dbg.todo("sys_dbg_read_spu_thread_context(id=0x%x, spu_context=*0x%x)", id, spu_context);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code sys_dbg_read_spu_thread_context2(u32 id, vm::ptr<sys_dbg_spu_thread_context2_t> spu_context)
|
||||
{
|
||||
sys_lv2dbg.todo("sys_dbg_read_spu_thread_context2()");
|
||||
sys_lv2dbg.todo("sys_dbg_read_spu_thread_context2(id=0x%x, spu_context=*0x%x)", id, spu_context);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code sys_dbg_set_stacksize_ppu_exception_handler(u32 stacksize)
|
||||
{
|
||||
sys_lv2dbg.todo("sys_dbg_set_stacksize_ppu_exception_handler()");
|
||||
sys_lv2dbg.todo("sys_dbg_set_stacksize_ppu_exception_handler(stacksize=0x%x)", stacksize);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code sys_dbg_initialize_ppu_exception_handler(s32 prio)
|
||||
{
|
||||
sys_lv2dbg.todo("sys_dbg_initialize_ppu_exception_handler()");
|
||||
sys_lv2dbg.todo("sys_dbg_initialize_ppu_exception_handler(prio=0x%x)", prio);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
|
|
@ -108,7 +103,7 @@ error_code sys_dbg_finalize_ppu_exception_handler()
|
|||
|
||||
error_code sys_dbg_register_ppu_exception_handler(vm::ptr<dbg_exception_handler_t> callback, u64 ctrl_flags)
|
||||
{
|
||||
sys_lv2dbg.todo("sys_dbg_register_ppu_exception_handler()");
|
||||
sys_lv2dbg.todo("sys_dbg_register_ppu_exception_handler(callback=*0x%x, ctrl_flags=0x%x)", callback, ctrl_flags);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
|
|
@ -120,170 +115,163 @@ error_code sys_dbg_unregister_ppu_exception_handler()
|
|||
|
||||
error_code sys_dbg_signal_to_ppu_exception_handler(u64 flags)
|
||||
{
|
||||
sys_lv2dbg.todo("sys_dbg_signal_to_ppu_exception_handler()");
|
||||
sys_lv2dbg.todo("sys_dbg_signal_to_ppu_exception_handler(flags=0x%x)", flags);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code sys_dbg_get_mutex_information(u32 id, vm::ptr<sys_dbg_mutex_information_t> info)
|
||||
{
|
||||
sys_lv2dbg.todo("sys_dbg_get_mutex_information()");
|
||||
sys_lv2dbg.todo("sys_dbg_get_mutex_information(id=0x%x, info=*0x%x)", id, info);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code sys_dbg_get_cond_information(u32 id, vm::ptr<sys_dbg_cond_information_t> info)
|
||||
{
|
||||
sys_lv2dbg.todo("sys_dbg_get_cond_information()");
|
||||
sys_lv2dbg.todo("sys_dbg_get_cond_information(id=0x%x, info=*0x%x)", id, info);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code sys_dbg_get_rwlock_information(u32 id, vm::ptr<sys_dbg_rwlock_information_t> info)
|
||||
{
|
||||
sys_lv2dbg.todo("sys_dbg_get_rwlock_information()");
|
||||
sys_lv2dbg.todo("sys_dbg_get_rwlock_information(id=0x%x, info=*0x%x)", id, info);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code sys_dbg_get_event_queue_information(u32 id, vm::ptr<sys_dbg_event_queue_information_t> info)
|
||||
{
|
||||
sys_lv2dbg.todo("sys_dbg_get_event_queue_information()");
|
||||
sys_lv2dbg.todo("sys_dbg_get_event_queue_information(id=0x%x, info=*0x%x)", id, info);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code sys_dbg_get_semaphore_information(u32 id, vm::ptr<sys_dbg_semaphore_information_t> info)
|
||||
{
|
||||
sys_lv2dbg.todo("sys_dbg_get_semaphore_information()");
|
||||
sys_lv2dbg.todo("sys_dbg_get_semaphore_information(id=0x%x, info=*0x%x)", id, info);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code sys_dbg_get_lwmutex_information(u32 id, vm::ptr<sys_dbg_lwmutex_information_t> info)
|
||||
{
|
||||
sys_lv2dbg.todo("sys_dbg_get_lwmutex_information()");
|
||||
sys_lv2dbg.todo("sys_dbg_get_lwmutex_information(id=0x%x, info=*0x%x)", id, info);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code sys_dbg_get_lwcond_information(u32 id, vm::ptr<sys_dbg_lwcond_information_t> info)
|
||||
{
|
||||
sys_lv2dbg.todo("sys_dbg_get_lwcond_information()");
|
||||
sys_lv2dbg.todo("sys_dbg_get_lwcond_information(id=0x%x, info=*0x%x)", id, info);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code sys_dbg_get_event_flag_information(u32 id, vm::ptr<sys_dbg_event_flag_information_t> info)
|
||||
{
|
||||
sys_lv2dbg.todo("sys_dbg_get_event_flag_information()");
|
||||
sys_lv2dbg.todo("sys_dbg_get_event_flag_information(id=0x%x, info=*0x%x)", id, info);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code sys_dbg_get_ppu_thread_ids(vm::ptr<u64> ids, vm::ptr<u64> ids_num, vm::ptr<u64> all_ids_num)
|
||||
{
|
||||
sys_lv2dbg.todo("sys_dbg_get_ppu_thread_ids()");
|
||||
sys_lv2dbg.todo("sys_dbg_get_ppu_thread_ids(ids=*0x%x, ids_num=*0x%x, all_ids_num=*0x%x)", ids, ids_num, all_ids_num);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code sys_dbg_get_spu_thread_group_ids(vm::ptr<u32> ids, vm::ptr<u64> ids_num, vm::ptr<u64> all_ids_num)
|
||||
{
|
||||
sys_lv2dbg.todo("sys_dbg_get_spu_thread_group_ids()");
|
||||
sys_lv2dbg.todo("sys_dbg_get_spu_thread_group_ids(ids=*0x%x, ids_num=*0x%x, all_ids_num=*0x%x)", ids, ids_num, all_ids_num);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code sys_dbg_get_spu_thread_ids(u32 group_id, vm::ptr<u32> ids, vm::ptr<u64> ids_num, vm::ptr<u64> all_ids_num)
|
||||
{
|
||||
sys_lv2dbg.todo("sys_dbg_get_spu_thread_ids()");
|
||||
sys_lv2dbg.todo("sys_dbg_get_spu_thread_ids(group_id=0x%x, ids=*0x%x, ids_num=*0x%x, all_ids_num=*0x%x)", group_id, ids, ids_num, all_ids_num);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code sys_dbg_get_ppu_thread_name(u64 id, vm::ptr<char> name)
|
||||
{
|
||||
sys_lv2dbg.todo("sys_dbg_get_ppu_thread_name()");
|
||||
sys_lv2dbg.todo("sys_dbg_get_ppu_thread_name(id=0x%x, name=*0x%x)", id, name);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code sys_dbg_get_spu_thread_name(u32 id, vm::ptr<char> name)
|
||||
{
|
||||
sys_lv2dbg.todo("sys_dbg_get_spu_thread_name()");
|
||||
sys_lv2dbg.todo("sys_dbg_get_spu_thread_name(id=0x%x, name=*0x%x)", id, name);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code sys_dbg_get_spu_thread_group_name(u32 id, vm::ptr<char> name)
|
||||
{
|
||||
sys_lv2dbg.todo("sys_dbg_get_spu_thread_group_name()");
|
||||
sys_lv2dbg.todo("sys_dbg_get_spu_thread_group_name(id=0x%x, name=*0x%x)", id, name);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
|
||||
error_code sys_dbg_get_ppu_thread_status(u64 id, vm::ptr<u32> status)
|
||||
{
|
||||
sys_lv2dbg.todo("sys_dbg_get_ppu_thread_status()");
|
||||
sys_lv2dbg.todo("sys_dbg_get_ppu_thread_status(id=0x%x, status=*0x%x)", id, status);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code sys_dbg_get_spu_thread_group_status(u32 id, vm::ptr<u32> status)
|
||||
{
|
||||
sys_lv2dbg.todo("sys_dbg_get_spu_thread_group_status()");
|
||||
sys_lv2dbg.todo("sys_dbg_get_spu_thread_group_status(id=0x%x, status=*0x%x)", id, status);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
|
||||
error_code sys_dbg_enable_floating_point_enabled_exception(u64 id, u64 flags, u64 opt1, u64 opt2)
|
||||
{
|
||||
sys_lv2dbg.todo("sys_dbg_enable_floating_point_enabled_exception()");
|
||||
sys_lv2dbg.todo("sys_dbg_enable_floating_point_enabled_exception(id=0x%x, flags=0x%x, opt1=0x%x, opt2=0x%x)", id, flags, opt1, opt2);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code sys_dbg_disable_floating_point_enabled_exception(u64 id, u64 flags, u64 opt1, u64 opt2)
|
||||
{
|
||||
sys_lv2dbg.todo("sys_dbg_disable_floating_point_enabled_exception()");
|
||||
sys_lv2dbg.todo("sys_dbg_disable_floating_point_enabled_exception(id=0x%x, flags=0x%x, opt1=0x%x, opt2=0x%x)", id, flags, opt1, opt2);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
|
||||
error_code sys_dbg_vm_get_page_information(u32 addr, u32 num, vm::ptr<sys_vm_page_information_t> pageinfo)
|
||||
{
|
||||
sys_lv2dbg.todo("sys_dbg_vm_get_page_information()");
|
||||
sys_lv2dbg.todo("sys_dbg_vm_get_page_information(addr=0x%x, num=0x%x, pageinfo=*0x%x)", addr, num, pageinfo);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
|
||||
error_code sys_dbg_set_address_to_dabr(u64 addr, u64 ctrl_flag)
|
||||
{
|
||||
sys_lv2dbg.todo("sys_dbg_set_address_to_dabr()");
|
||||
sys_lv2dbg.todo("sys_dbg_set_address_to_dabr(addr=0x%x, spu_context=0x%x)", addr, ctrl_flag);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code sys_dbg_get_address_from_dabr(vm::ptr<u64> addr, vm::ptr<u64> ctrl_flag)
|
||||
{
|
||||
sys_lv2dbg.todo("sys_dbg_get_address_from_dabr()");
|
||||
sys_lv2dbg.todo("sys_dbg_get_address_from_dabr(addr=*0x%x, spu_context=*0x%x)", addr, ctrl_flag);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
|
||||
error_code sys_dbg_signal_to_coredump_handler(u64 data1, u64 data2, u64 data3)
|
||||
{
|
||||
sys_lv2dbg.todo("sys_dbg_signal_to_coredump_handler()");
|
||||
sys_lv2dbg.todo("sys_dbg_signal_to_coredump_handler(data1=0x%x, data2=0x%x, data3=0x%x)", data1, data2, data3);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
|
||||
error_code sys_dbg_mat_set_condition(u32 addr, u64 cond)
|
||||
{
|
||||
sys_lv2dbg.todo("sys_dbg_mat_set_condition()");
|
||||
sys_lv2dbg.todo("sys_dbg_mat_set_condition(addr=0x%x, cond=0x%x)", addr, cond);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code sys_dbg_mat_get_condition(u32 addr, vm::ptr<u64> condp)
|
||||
{
|
||||
sys_lv2dbg.todo("sys_dbg_mat_get_condition()");
|
||||
sys_lv2dbg.todo("sys_dbg_mat_get_condition(addr=0x%x, condp=*0x%x)", addr, condp);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
|
||||
error_code sys_dbg_get_coredump_params(vm::ptr<s32> param)
|
||||
{
|
||||
sys_lv2dbg.todo("sys_dbg_get_coredump_params()");
|
||||
sys_lv2dbg.todo("sys_dbg_get_coredump_params(param=*0x%x)", param);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
error_code sys_dbg_set_mask_to_ppu_exception_handler(u64 mask, u64 flags)
|
||||
{
|
||||
sys_lv2dbg.todo("sys_dbg_set_mask_to_ppu_exception_handler()");
|
||||
sys_lv2dbg.todo("sys_dbg_set_mask_to_ppu_exception_handler(mask=0x%x, flags=0x%x)", mask, flags);
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -4,11 +4,6 @@
|
|||
|
||||
LOG_CHANNEL(libnet);
|
||||
|
||||
// Temporarily
|
||||
#ifndef _MSC_VER
|
||||
#pragma GCC diagnostic ignored "-Wunused-parameter"
|
||||
#endif
|
||||
|
||||
s32 sys_net_accept(s32 s, vm::ptr<sys_net_sockaddr> addr, vm::ptr<u32> paddrlen)
|
||||
{
|
||||
libnet.todo("accept(s=%d, addr=*0x%x, paddrlen=*0x%x)", s, addr, paddrlen);
|
||||
|
|
@ -44,19 +39,22 @@ s32 sys_net_gethostbyname()
|
|||
|
||||
s32 sys_net_getpeername(s32 s, vm::ptr<sys_net_sockaddr> addr, vm::ptr<u32> paddrlen)
|
||||
{
|
||||
UNIMPLEMENTED_FUNC(libnet);
|
||||
libnet.todo("getpeername(s=%d, addr=*0x%x, paddrlen=*0x%x)", s, addr, paddrlen);
|
||||
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
s32 sys_net_getsockname(s32 s, vm::ptr<sys_net_sockaddr> addr, vm::ptr<u32> paddrlen)
|
||||
{
|
||||
UNIMPLEMENTED_FUNC(libnet);
|
||||
libnet.todo("getsockname(s=%d, addr=*0x%x, paddrlen=*0x%x)", s, addr, paddrlen);
|
||||
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
s32 sys_net_getsockopt(s32 s, s32 level, s32 optname, vm::ptr<void> optval, vm::ptr<u32> optlen)
|
||||
{
|
||||
UNIMPLEMENTED_FUNC(libnet);
|
||||
libnet.todo("getsockopt(s=%d, level=%d, optname=%d, optval=*0x%x, optlen=*0x%x)", s, level, optname, optval, optlen);
|
||||
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
|
|
@ -141,7 +139,8 @@ s32 sys_net_recvfrom(s32 s, vm::ptr<void> buf, u32 len, s32 flags, vm::ptr<sys_n
|
|||
|
||||
s32 sys_net_recvmsg(s32 s, vm::ptr<sys_net_msghdr> msg, s32 flags)
|
||||
{
|
||||
UNIMPLEMENTED_FUNC(libnet);
|
||||
libnet.todo("recvmsg(s=%d, msg=*0x%x, flags=0x%x)", s, msg, flags);
|
||||
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
|
|
@ -154,7 +153,8 @@ s32 sys_net_send(s32 s, vm::cptr<void> buf, u32 len, s32 flags)
|
|||
|
||||
s32 sys_net_sendmsg(s32 s, vm::cptr<sys_net_msghdr> msg, s32 flags)
|
||||
{
|
||||
UNIMPLEMENTED_FUNC(libnet);
|
||||
libnet.todo("sendmsg(s=%d, msg=*0x%x, flags=0x%x)", s, msg, flags);
|
||||
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
|
|
@ -195,7 +195,8 @@ s32 sys_net_socketclose(s32 s)
|
|||
|
||||
s32 sys_net_socketpoll(vm::ptr<sys_net_pollfd> fds, s32 nfds, s32 ms)
|
||||
{
|
||||
UNIMPLEMENTED_FUNC(libnet);
|
||||
libnet.todo("socketpoll(fds=*0x%x, nfds=%d, ms=%d)", fds, nfds, ms);
|
||||
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
|
|
@ -270,7 +271,8 @@ s32 sys_net_get_sockinfo(s32 s, vm::ptr<sys_net_sockinfo_t> p, s32 n)
|
|||
|
||||
s32 sys_net_close_dump(s32 id, vm::ptr<s32> pflags)
|
||||
{
|
||||
UNIMPLEMENTED_FUNC(libnet);
|
||||
libnet.todo("sys_net_close_dump(id=%d, pflags=*0x%x)", id, pflags);
|
||||
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
|
|
@ -308,7 +310,8 @@ s32 sys_net_show_route()
|
|||
|
||||
s32 sys_net_read_dump(s32 id, vm::ptr<void> buf, s32 len, vm::ptr<s32> pflags)
|
||||
{
|
||||
UNIMPLEMENTED_FUNC(libnet);
|
||||
libnet.todo("sys_net_read_dump(id=%d, buf=*0x%x, len=%d, pflags=*0x%x)", id, buf, len, pflags);
|
||||
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
|
|
@ -344,7 +347,8 @@ s32 sys_net_get_sockinfo_ex()
|
|||
|
||||
s32 sys_net_open_dump(s32 len, s32 flags)
|
||||
{
|
||||
UNIMPLEMENTED_FUNC(libnet);
|
||||
libnet.todo("sys_net_open_dump(len=%d, flags=0x%x)", len, flags);
|
||||
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -307,16 +307,11 @@ void usb_device_emulated::control_transfer(u8 bmRequestType, u8 bRequest, u16 wV
|
|||
}
|
||||
}
|
||||
|
||||
// Temporarily
|
||||
#ifndef _MSC_VER
|
||||
#pragma GCC diagnostic ignored "-Wunused-parameter"
|
||||
#endif
|
||||
|
||||
void usb_device_emulated::interrupt_transfer(u32 buf_size, u8* buf, u32 endpoint, UsbTransfer* transfer)
|
||||
void usb_device_emulated::interrupt_transfer(u32 /*buf_size*/, u8* /*buf*/, u32 /*endpoint*/, UsbTransfer* /*transfer*/)
|
||||
{
|
||||
}
|
||||
|
||||
void usb_device_emulated::isochronous_transfer(UsbTransfer* transfer)
|
||||
void usb_device_emulated::isochronous_transfer(UsbTransfer* /*transfer*/)
|
||||
{
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -235,14 +235,9 @@ namespace vk
|
|||
return false;
|
||||
}
|
||||
|
||||
// Temporarily
|
||||
#ifndef _MSC_VER
|
||||
#pragma GCC diagnostic ignored "-Wunused-parameter"
|
||||
#endif
|
||||
|
||||
VkBool32 BreakCallback(VkFlags msgFlags, VkDebugReportObjectTypeEXT objType,
|
||||
u64 srcObject, usz location, s32 msgCode,
|
||||
const char* pLayerPrefix, const char* pMsg, void* pUserData)
|
||||
VkBool32 BreakCallback(VkFlags /*msgFlags*/, VkDebugReportObjectTypeEXT /*objType*/,
|
||||
u64 /*srcObject*/, usz /*location*/, s32 /*msgCode*/,
|
||||
const char* /*pLayerPrefix*/, const char* /*pMsg*/, void* /*pUserData*/)
|
||||
{
|
||||
#ifdef _WIN32
|
||||
DebugBreak();
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue