mirror/rpcs3
1
0
Fork 0
mirror of https://github.com/RPCS3/rpcs3.git synced 2025-01-29 00:33:01 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #239 from Bigpet/splitproj

Browse Source 
Split gui and emulation core into seperate projects
This commit is contained in:
Hykem 2014-06-09 01:22:04 +01:00
commit 93481fe27d
153 changed files with 6547 additions and 4394 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
Utilities/BEType.h
View File

@ -2,12 +2,24 @@
#include "Utilities/GNU.h"
#include <algorithm>
using std::min;
using std::max;
//#define re(val) MemoryBase::Reverse(val)
#define re64(val) MemoryBase::Reverse64(val)
#define re32(val) MemoryBase::Reverse32(val)
#define re16(val) MemoryBase::Reverse16(val)
template<typename T, int size = sizeof(T)> struct se_t;
template<typename T> struct se_t<T, 1> { static __forceinline void func(T& dst, const T src) { (u8&)dst = (u8&)src; } };
template<typename T> struct se_t<T, 2> { static __forceinline void func(T& dst, const T src) { (u16&)dst = _byteswap_ushort((u16&)src); } };
template<typename T> struct se_t<T, 4> { static __forceinline void func(T& dst, const T src) { (u32&)dst = _byteswap_ulong((u32&)src); } };
template<typename T> struct se_t<T, 8> { static __forceinline void func(T& dst, const T src) { (u64&)dst = _byteswap_uint64((u64&)src); } };
template<typename T> T re(const T val) { T res; se_t<T>::func(res, val); return res; }
template<typename T1, typename T2> void re(T1& dst, const T2 val) { se_t<T1>::func(dst, val); }
template<typename T, s64 _value, int size = sizeof(T)> struct const_se_t;
template<typename T, s64 _value> struct const_se_t<T, _value, 1>

4
Utilities/IdManager.h
View File

@ -1,6 +1,8 @@
#pragma once
#include <unordered_map>
#define rID_ANY -1 // was wxID_ANY
typedef u32 ID_TYPE;
class IDData
@ -154,7 +156,7 @@ public:
{
std::lock_guard<std::mutex> lock(m_mtx_main);
if(id == wxID_ANY)
if(id == rID_ANY)
return m_id_map.begin() != m_id_map.end();
}

45
Utilities/StrFmt.cpp
View File

@ -54,11 +54,12 @@ std::string replace_all(std::string src, const std::string& from, const std::str
return src;
}
//TODO: move this wx Stuff somewhere else
//convert a wxString to a std::string encoded in utf8
//CAUTION, only use this to interface with wxWidgets classes
std::string fmt::ToUTF8(const wxString& right)
{
auto ret = std::string(((const char *) right.utf8_str()));
auto ret = std::string(((const char *)right.utf8_str()));
return ret;
}
@ -86,4 +87,46 @@ int fmt::CmpNoCase(const std::string& a, const std::string& b)
[](const char& a, const char& b){return tolower(a) == tolower(b); })
? 0 : -1;
}
}
//TODO: remove this after every snippet that uses it is gone
//WARNING: not fully compatible with CmpNoCase from wxString
void fmt::Replace(std::string &str, const std::string &searchterm, const std::string& replaceterm)
{
size_t cursor = 0;
do
{
cursor = str.find(searchterm, cursor);
if (cursor != std::string::npos)
{
str.replace(cursor, searchterm.size(), replaceterm);
cursor += replaceterm.size();
}
else
{
break;
}
} while (true);
}
std::vector<std::string> fmt::rSplit(const std::string& source, const std::string& delim)
{
std::vector<std::string> ret;
size_t cursor = 0;
do
{
size_t prevcurs = cursor;
cursor = source.find(delim, cursor);
if (cursor != std::string::npos)
{
ret.push_back(source.substr(prevcurs,cursor-prevcurs));
cursor += delim.size();
}
else
{
ret.push_back(source.substr(prevcurs));
break;
}
} while (true);
return ret;
}

60
Utilities/StrFmt.h
View File

@ -9,6 +9,29 @@
#define snprintf _snprintf
#endif
//int CmpNoCase(const std::string &str, const std::string &str2)
//{
// bool same;
// if (str.size() > str2.size())
// {
// same = std::equal(str.cbegin(), str.cend(), str2.cbegin(), [](const char a, const char b) -> bool{ return tolower(a) == tolower(b); });
// }
// else
// {
// same = std::equal(str2.cbegin(), str2.cend(), str.cbegin(), [](const char a, const char b) -> bool{ return tolower(a) == tolower(b); });
// }
// if (same)
// {
// return 0;
// }
// else
// {
// return 1;
// }
//}
namespace fmt{
using std::string;
using std::ostream;
@ -18,6 +41,38 @@ namespace fmt{
extern const string placeholder;
template <typename T>
std::string AfterLast(const std::string& source, T searchstr)
{
size_t search_pos = source.rfind(searchstr);
search_pos = search_pos == std::string::npos ? 0 : search_pos;
return source.substr(search_pos);
}
template <typename T>
std::string BeforeLast(const std::string& source, T searchstr)
{
size_t search_pos = source.rfind(searchstr);
search_pos = search_pos == std::string::npos ? 0 : search_pos;
return source.substr(0, search_pos);
}
template <typename T>
std::string AfterFirst(const std::string& source, T searchstr)
{
size_t search_pos = source.find(searchstr);
search_pos = search_pos == std::string::npos ? 0 : search_pos;
return source.substr(search_pos);
}
template <typename T>
std::string BeforeFirst(const std::string& source, T searchstr)
{
size_t search_pos = source.find(searchstr);
search_pos = search_pos == std::string::npos ? 0 : search_pos;
return source.substr(0, search_pos);
}
// write `fmt` from `pos` to the first occurence of `fmt::placeholder` to
// the stream `os`. Then write `arg` to to the stream. If there's no
// `fmt::placeholder` after `pos` everything in `fmt` after pos is written
@ -161,4 +216,9 @@ namespace fmt{
//WARNING: not fully compatible with CmpNoCase from wxString
int CmpNoCase(const std::string& a, const std::string& b);
//TODO: remove this after every snippet that uses it is gone
//WARNING: not fully compatible with Replace from wxString
void Replace(std::string &str, const std::string &searchterm, const std::string& replaceterm);
std::vector<std::string> rSplit(const std::string& source, const std::string& delim);
}

4
Utilities/Thread.h
View File

@ -124,9 +124,9 @@ public:
bool IsBusy() const { return m_busy; }
};
static __forceinline bool SemaphorePostAndWait(wxSemaphore& sem)
static __forceinline bool SemaphorePostAndWait(rSemaphore& sem)
{
if(sem.TryWait() != wxSEMA_BUSY) return false;
if(sem.TryWait() != rSEMA_BUSY) return false;
sem.Post();
sem.Wait();

130
Utilities/rConcurrency.cpp Normal file
View File

@ -0,0 +1,130 @@
#include "stdafx.h"
rSemaphore::rSemaphore()
{
handle = reinterpret_cast<void*>(new wxSemaphore());
}
//rSemaphore::rSemaphore(rSemaphore& other)
//{
// handle = reinterpret_cast<void*>(new wxSemaphore(*reinterpret_cast<wxSemaphore*>(other.handle)));
//}
rSemaphore::~rSemaphore()
{
delete reinterpret_cast<wxSemaphore*>(handle);
}
rSemaphore::rSemaphore(int initial_count, int max_count)
{
handle = reinterpret_cast<void*>(new wxSemaphore(initial_count,max_count));
}
void rSemaphore::Wait()
{
reinterpret_cast<wxSemaphore*>(handle)->Wait();
}
rSemaStatus rSemaphore::TryWait()
{
wxSemaError err = reinterpret_cast<wxSemaphore*>(handle)->TryWait();
if (err == wxSEMA_BUSY)
{
return rSEMA_BUSY;
}
else
{
return rSEMA_OTHER;
}
}
void rSemaphore::Post()
{
reinterpret_cast<wxSemaphore*>(handle)->Post();
}
void rSemaphore::WaitTimeout(u64 timeout)
{
reinterpret_cast<wxSemaphore*>(handle)->WaitTimeout(timeout);
}
rCriticalSection::rCriticalSection()
{
handle = reinterpret_cast<void*>(new wxCriticalSection());
}
//rCriticalSection::rCriticalSection(rCriticalSection&)
//{
// handle = reinterpret_cast<void*>(new wxCriticalSection(*reinterpret_cast<wxCriticalSection*>(other.handle)));
//}
rCriticalSection::~rCriticalSection()
{
delete reinterpret_cast<wxCriticalSection*>(handle);
}
void rCriticalSection::Enter()
{
reinterpret_cast<wxCriticalSection*>(handle)->Enter();
}
void rCriticalSection::Leave()
{
reinterpret_cast<wxCriticalSection*>(handle)->Leave();
}
rTimer::rTimer()
{
handle = reinterpret_cast<void*>(new wxTimer());
}
//rTimer::rTimer(rTimer&)
//{
// handle = reinterpret_cast<void*>(new wxTimer(*reinterpret_cast<wxTimer*>(other.handle)));
//}
rTimer::~rTimer()
{
delete reinterpret_cast<wxTimer*>(handle);
}
void rTimer::Start()
{
reinterpret_cast<wxTimer*>(handle)->Start();
}
void rTimer::Stop()
{
reinterpret_cast<wxTimer*>(handle)->Stop();
}
void rSleep(u32 time)
{
wxSleep(time);
}
void rMicroSleep(u64 time)
{
wxMicroSleep(time);
}
rCriticalSectionLocker::rCriticalSectionLocker(const rCriticalSection &sec)
{
handle = reinterpret_cast<void*>(new wxCriticalSectionLocker(*reinterpret_cast<wxCriticalSection*>(sec.handle)));
}
rCriticalSectionLocker::~rCriticalSectionLocker()
{
delete reinterpret_cast<wxCriticalSectionLocker*>(handle);
}
bool rThread::IsMain()
{
return wxThread::IsMain();
}
void rYieldIfNeeded()
{
wxYieldIfNeeded();
}

59
Utilities/rConcurrency.h Normal file
View File

@ -0,0 +1,59 @@
#pragma once
enum rSemaStatus
{
rSEMA_BUSY,
rSEMA_OTHER
};
struct rSemaphore
{
rSemaphore();
rSemaphore(const rSemaphore& other) = delete;
~rSemaphore();
rSemaphore(int initial_count, int max_count);
void Wait();
rSemaStatus TryWait();
void Post();
void WaitTimeout(u64 timeout);
private:
void *handle;
};
struct rCriticalSection
{
rCriticalSection();
rCriticalSection(const rCriticalSection& other) = delete;
~rCriticalSection();
void Enter();
void Leave();
void *handle;
};
struct rTimer
{
rTimer();
rTimer(const rTimer& other) = delete;
~rTimer();
void Start();
void Stop();
private:
void *handle;
};
void rSleep(u32 time);
void rMicroSleep(u64 time);
struct rCriticalSectionLocker
{
rCriticalSectionLocker(const rCriticalSection& other);
~rCriticalSectionLocker();
private:
void *handle;
};
struct rThread
{
static bool IsMain();
};
void rYieldIfNeeded();

327
Utilities/rFile.cpp Normal file
View File

@ -0,0 +1,327 @@
#include "stdafx.h"
const int rPATH_MKDIR_FULL = wxPATH_MKDIR_FULL;
//enum rSeekMode
//{
// rFromStart,
// rFromCurrent,
// rFromEnd
//};
//
// enum OpenMode
// {
// read,
// write,
// read_write,
// write_append,
// write_excl
// };
wxFile::OpenMode convertOpenMode(rFile::OpenMode open)
{
wxFile::OpenMode mode;
switch (open)
{
case rFile::read:
mode = wxFile::read;
break;
case rFile::write:
mode = wxFile::write;
break;
case rFile::read_write:
mode = wxFile::read_write;
break;
case rFile::write_append:
mode = wxFile::write_append;
break;
case rFile::write_excl:
mode = wxFile::write_excl;
break;
}
return mode;
}
rFile::OpenMode rConvertOpenMode(wxFile::OpenMode open)
{
rFile::OpenMode mode;
switch (open)
{
case wxFile::read:
mode = rFile::read;
break;
case wxFile::write:
mode = rFile::write;
break;
case wxFile::read_write:
mode = rFile::read_write;
break;
case wxFile::write_append:
mode = rFile::write_append;
break;
case wxFile::write_excl:
mode = rFile::write_excl;
break;
}
return mode;
}
wxSeekMode convertSeekMode(rSeekMode mode)
{
wxSeekMode ret;
switch (mode)
{
case rFromStart:
ret = wxFromStart;
break;
case rFromCurrent:
ret = wxFromCurrent;
break;
case rFromEnd:
ret = wxFromEnd;
break;
}
return ret;
}
rSeekMode rConvertSeekMode(wxSeekMode mode)
{
rSeekMode ret;
switch (mode)
{
case wxFromStart:
ret = rFromStart;
break;
case wxFromCurrent:
ret = rFromCurrent;
break;
case wxFromEnd:
ret = rFromEnd;
break;
}
return ret;
}
rFile::rFile()
{
handle = reinterpret_cast<void*>(new wxFile());
}
rFile::rFile(const std::string& filename, rFile::OpenMode open)
{
handle = reinterpret_cast<void*>(new wxFile(fmt::FromUTF8(filename), convertOpenMode(open)));
}
rFile::rFile(int fd)
{
handle = reinterpret_cast<void*>(new wxFile(fd));
}
rFile::~rFile()
{
delete reinterpret_cast<wxFile*>(handle);
}
bool rFile::Access(const std::string &filename, rFile::OpenMode mode)
{
return wxFile::Access(fmt::FromUTF8(filename), convertOpenMode(mode));
}
size_t rFile::Write(const void *buffer, size_t count)
{
return reinterpret_cast<wxFile*>(handle)->Write(buffer,count);
}
bool rFile::Write(const std::string &text)
{
return reinterpret_cast<wxFile*>(handle)->Write(fmt::FromUTF8(text));
}
bool rFile::Close()
{
return reinterpret_cast<wxFile*>(handle)->Close();
}
bool rFile::Create(const std::string &filename, bool overwrite, int access)
{
return reinterpret_cast<wxFile*>(handle)->Create(fmt::FromUTF8(filename),overwrite,access);
}
bool rFile::Open(const std::string &filename, rFile::OpenMode mode, int access)
{
return reinterpret_cast<wxFile*>(handle)->Open(fmt::FromUTF8(filename), convertOpenMode(mode), access);
}
bool rFile::Exists(const std::string &file)
{
return wxFile::Exists(fmt::FromUTF8(file));
}
bool rFile::IsOpened() const
{
return reinterpret_cast<wxFile*>(handle)->IsOpened();
}
size_t rFile::Length() const
{
return reinterpret_cast<wxFile*>(handle)->Length();
}
size_t rFile::Read(void *buffer, size_t count)
{
return reinterpret_cast<wxFile*>(handle)->Read(buffer,count);
}
size_t rFile::Seek(size_t ofs, rSeekMode mode)
{
return reinterpret_cast<wxFile*>(handle)->Seek(ofs, convertSeekMode(mode));
}
size_t rFile::Tell() const
{
return reinterpret_cast<wxFile*>(handle)->Tell();
}
std::string rGetCwd()
{
return fmt::ToUTF8(wxGetCwd());
}
bool rMkdir(const std::string &path)
{
return wxMkdir(fmt::FromUTF8(path));
}
bool rRmdir(const std::string &path)
{
return wxRmdir(fmt::FromUTF8(path));
}
bool rDirExists(const std::string &path)
{
return wxDirExists(fmt::FromUTF8(path));
}
bool rFileExists(const std::string &path)
{
return wxFileExists(fmt::FromUTF8(path));
}
bool rRemoveFile(const std::string &path)
{
return wxRemoveFile(fmt::FromUTF8(path));
}
bool rIsWritable(const std::string& path)
{
return wxIsWritable(fmt::FromUTF8(path));
}
bool rIsReadable(const std::string& path)
{
return wxIsReadable(fmt::FromUTF8(path));
}
bool rIsExecutable(const std::string& path)
{
return wxIsExecutable(fmt::FromUTF8(path));
}
rDir::rDir()
{
handle = reinterpret_cast<void*>(new wxDir());
}
rDir::~rDir()
{
delete reinterpret_cast<wxDir*>(handle);
}
rDir::rDir(const std::string &path)
{
handle = reinterpret_cast<void*>(new wxDir(fmt::FromUTF8(path)));
}
bool rDir::Open(const std::string& path)
{
return reinterpret_cast<wxDir*>(handle)->Open(fmt::FromUTF8(path));
}
bool rDir::Exists(const std::string &path)
{
return wxDir::Exists(fmt::FromUTF8(path));
}
bool rDir::GetFirst(std::string *filename) const
{
wxString str;
bool res;
res = reinterpret_cast<wxDir*>(handle)->GetFirst(&str);
*filename = str.ToStdString();
return res;
}
bool rDir::GetNext(std::string *filename) const
{
wxString str;
bool res;
res = reinterpret_cast<wxDir*>(handle)->GetNext(&str);
*filename = str.ToStdString();
return res;
}
rFileName::rFileName()
{
handle = reinterpret_cast<void*>(new wxFileName());
}
rFileName::~rFileName()
{
delete reinterpret_cast<wxFileName*>(handle);
}
rFileName::rFileName(const rFileName& filename)
{
handle = reinterpret_cast<void*>(new wxFileName(*reinterpret_cast<wxFileName*>(filename.handle)));
}
rFileName::rFileName(const std::string& name)
{
handle = reinterpret_cast<void*>(new wxFileName(fmt::FromUTF8(name)));
}
std::string rFileName::GetFullPath()
{
return fmt::ToUTF8(reinterpret_cast<wxFileName*>(handle)->GetFullPath());
}
std::string rFileName::GetPath()
{
return fmt::ToUTF8(reinterpret_cast<wxFileName*>(handle)->GetPath());
}
std::string rFileName::GetName()
{
return fmt::ToUTF8(reinterpret_cast<wxFileName*>(handle)->GetName());
}
std::string rFileName::GetFullName()
{
return fmt::ToUTF8(reinterpret_cast<wxFileName*>(handle)->GetFullName());
}
bool rFileName::Mkdir(const std::string& name, int permissions , int flags )
{
return wxFileName::Mkdir(fmt::FromUTF8(name), permissions, flags);
}
bool rFileName::Normalize()
{
return reinterpret_cast<wxFileName*>(handle)->Normalize();
}

84
Utilities/rFile.h Normal file
View File

@ -0,0 +1,84 @@
#pragma once
#include <string>
extern const int rPATH_MKDIR_FULL;
enum rSeekMode
{
rFromStart,
rFromCurrent,
rFromEnd
};
class rFile
{
public:
enum OpenMode
{
read,
write,
read_write,
write_append,
write_excl
};
rFile();
rFile(const rFile& other) = delete;
~rFile();
rFile(const std::string& filename, rFile::OpenMode open = rFile::read);
rFile(int fd);
static bool Access(const std::string &filename, rFile::OpenMode mode);
size_t Write(const void *buffer, size_t count);
bool Write(const std::string &text);
bool Close();
bool Create(const std::string &filename, bool overwrite = false, int access = 0666);
bool Open(const std::string &filename, rFile::OpenMode mode = rFile::read, int access = 0666);
static bool Exists(const std::string&);
bool IsOpened() const;
size_t Length() const;
size_t Read(void *buffer, size_t count);
size_t Seek(size_t ofs, rSeekMode mode = rFromStart);
size_t Tell() const;
void *handle;
};
std::string rGetCwd();
bool rMkdir(const std::string &path);
bool rRmdir(const std::string &path);
bool rDirExists(const std::string &path);
bool rFileExists(const std::string &path);
bool rRemoveFile(const std::string &path);
bool rIsWritable(const std::string& path);
bool rIsReadable(const std::string& path);
bool rIsExecutable(const std::string& path);
struct rDir
{
rDir();
~rDir();
rDir(const rDir& other) = delete;
rDir(const std::string &path);
bool Open(const std::string& path);
static bool Exists(const std::string &path);
bool GetFirst(std::string *filename) const;
bool GetNext(std::string *filename) const;
void *handle;
};
struct rFileName
{
rFileName();
rFileName(const rFileName& other);
~rFileName();
rFileName(const std::string& name);
std::string GetFullPath();
std::string GetPath();
std::string GetName();
std::string GetFullName();
static bool Mkdir(const std::string& name, int permissions=0777, int flags=0);
bool Normalize();
void *handle;
};

51
Utilities/rMsgBox.cpp Normal file
View File

@ -0,0 +1,51 @@
#include "stdafx.h"
std::string rMessageBoxCaptionStr = "Message";
rMessageDialog::rMessageDialog(void *parent, const std::string& msg, const std::string& title , long style )
{
handle = reinterpret_cast<void*>(new wxMessageDialog(
reinterpret_cast<wxWindow*>(parent)
, fmt::FromUTF8(msg)
, fmt::FromUTF8(title)
, style
));
}
rMessageDialog::~rMessageDialog()
{
delete reinterpret_cast<wxMessageDialog*>(handle);
}
long rMessageDialog::ShowModal()
{
return reinterpret_cast<wxMessageDialog*>(handle)->ShowModal();
}
long rMessageBox(const std::string& message, const std::string& title, long style)
{
return wxMessageBox(fmt::FromUTF8(message), fmt::FromUTF8(title),style);
}
std::string dummyApp::GetAppName()
{
if (handle)
{
return fmt::ToUTF8(reinterpret_cast<wxApp*>(handle)->GetAppName());
}
else
{
return "NULL";
}
}
dummyApp::dummyApp() : handle(nullptr)
{
}
static dummyApp app;
dummyApp& rGetApp()
{
return app;
}

47
Utilities/rMsgBox.h Normal file
View File

@ -0,0 +1,47 @@
#pragma once
extern std::string rMessageBoxCaptionStr;// = "Message";
enum MsgBoxParams : unsigned long
{
rOK = 0x4
, rYES =0x2//res
, rNO = 0x8 //res
, rID_YES = 5103 //resDialog
, rCANCEL = 0x10
, rYES_NO = 0xA
, rHELP = 0x1000
, rNO_DEFAULT = 0x80
, rCANCEL_DEFAULT = 0x80000000
, rYES_DEFAULT = 0x0
, rOK_DEFAULT = 0x0
, rICON_NONE = 0x40000
, rICON_EXCLAMATION = 0x100
, rICON_ERROR = 0x200
, rICON_HAND = 0x200
, rICON_QUESTION = 0x400
, rICON_INFORMATION = 0x800
, rICON_AUTH_NEEDED = 0x80000
, rSTAY_ON_TOP = 0x8000
, rCENTRE = 0x1
};
struct rMessageDialog
{
rMessageDialog(void *parent, const std::string& msg, const std::string& title = rMessageBoxCaptionStr, long style = rOK | rCENTRE);
rMessageDialog(const rMessageDialog& other) = delete;
~rMessageDialog();
long ShowModal();
void *handle;
};
long rMessageBox(const std::string& message, const std::string& title,long style);
struct dummyApp
{
dummyApp();
std::string GetAppName();
void* handle;
};
dummyApp& rGetApp();

187
Utilities/rPlatform.cpp Normal file
View File

@ -0,0 +1,187 @@
#include "stdafx.h"
#include <wx/glcanvas.h>
#include "Gui/GLGSFrame.h"
#include "Emu/Io/Null/NullKeyboardHandler.h"
#include "Emu/Io/Windows/WindowsKeyboardHandler.h"
#include "Emu/Io/Null/NullMouseHandler.h"
#include "Emu/Io/Windows/WindowsMouseHandler.h"
#include "Emu/Io/Null/NullPadHandler.h"
#include "Emu/Io/Windows/WindowsPadHandler.h"
#if defined(_WIN32)
#include "Emu/Io/XInput/XInputPadHandler.h"
#endif
rCanvas::rCanvas(void *parent)
{
handle = static_cast<void*>(new wxGLCanvas(static_cast<wxWindow *>(parent),wxID_ANY,NULL));
}
rCanvas::~rCanvas()
{
delete static_cast<wxGLCanvas*>(handle);
}
//void *rCanvas::GetCurrent()
//{
// static_cast<wxGLCanvas*>(handle)->GetCur;
//}
bool rCanvas::SetCurrent(void *ctx)
{
return static_cast<wxGLCanvas*>(handle)->SetCurrent(*static_cast<wxGLContext *>(ctx));
}
rGLFrame::rGLFrame()
{
handle = static_cast<void*>(new GLGSFrame());
}
rGLFrame::~rGLFrame()
{
delete static_cast<GLGSFrame*>(handle);
}
void rGLFrame::Close()
{
static_cast<GLGSFrame*>(handle)->Close();
}
bool rGLFrame::IsShown()
{
return static_cast<GLGSFrame*>(handle)->IsShown();
}
void rGLFrame::Hide()
{
static_cast<GLGSFrame*>(handle)->Hide();
}
void rGLFrame::Show()
{
static_cast<GLGSFrame*>(handle)->Show();
}
void *rGLFrame::GetNewContext()
{
return static_cast<void *>(new wxGLContext(
static_cast<GLGSFrame*>(handle)->GetCanvas()
));
}
void rGLFrame::Flip(void *ctx)
{
static_cast<GLGSFrame*>(handle)->Flip(
static_cast<wxGLContext*>(ctx));
}
void rGLFrame::SetCurrent(void *ctx)
{
static_cast<GLGSFrame*>(handle)->GetCanvas()->SetCurrent(*static_cast<wxGLContext*>(ctx));
}
rImage::rImage()
{
handle = static_cast<void*>(new wxImage());
}
rImage::~rImage()
{
delete static_cast<wxImage*>(handle);
}
void rImage::Create(int width, int height, void *data, void *alpha)
{
static_cast<wxImage*>(handle)->Create(width, height, static_cast<unsigned char*>(data), static_cast<unsigned char*>(alpha));
}
void rImage::SaveFile(const std::string& name, rImageType type)
{
if (type == rBITMAP_TYPE_PNG)
{
static_cast<wxImage*>(handle)->SaveFile(fmt::FromUTF8(name),wxBITMAP_TYPE_PNG);
}
else
{
throw std::string("unsupported type");
}
}
int rPlatform::getKeyboardHandlerCount()
{
return 2;
}
KeyboardHandlerBase *rPlatform::getKeyboardHandler(int i)
{
switch (i)
{
case 0:
return new NullKeyboardHandler();
break;
case 1:
return new WindowsKeyboardHandler();
break;
default:
return new NullKeyboardHandler();
}
}
int rPlatform::getMouseHandlerCount()
{
return 2;
}
MouseHandlerBase *rPlatform::getMouseHandler(int i)
{
switch (i)
{
case 0:
return new NullMouseHandler();
break;
case 1:
return new WindowsMouseHandler();
break;
default:
return new NullMouseHandler();
}
}
int rPlatform::getPadHandlerCount()
{
#if defined(_WIN32)
return 3;
#else
return 2;
#endif
}
PadHandlerBase *rPlatform::getPadHandler(int i)
{
switch (i)
{
case 0:
return new NullPadHandler();
break;
case 1:
return new WindowsPadHandler();
break;
#if defined(_WIN32)
case 2:
return new XInputPadHandler();
break;
#endif
default:
return new NullPadHandler();
}
}

114
Utilities/rPlatform.h Normal file
View File

@ -0,0 +1,114 @@
#pragma once
#include <vector>
#include <string>
//struct rGLContext;
#include "Emu/Io/Null/NullKeyboardHandler.h"
#include "Emu/Io/Null/NullMouseHandler.h"
#include "Emu/Io/Null/NullPadHandler.h"
struct rCanvas
{
rCanvas(void *parent);
rCanvas(const rCanvas &) = delete;
~rCanvas();
/*rGLContext*/void *GetCurrent();
bool SetCurrent(/*rGLContext &*/ void *ctx);
void *handle;
};
//struct rGLContext
//{
// rGLContext();
// rGLContext(rGLContext &) = delete;
// rGLContext(rCanvas *canvas);
// ~rGLContext();
//
// void *handle;
//};
//struct rFrame
//{
// rFrame();
// rFrame(rFrame &) = delete;
// ~rFrame();
//
// void Close();
// bool IsShown();
// void Hide();
// void Show();
//
// void *handle;
//};
struct rGLFrame/*: public rFrame*/
{
rGLFrame();
rGLFrame(const rGLFrame &) = delete;
~rGLFrame();
void Close();
bool IsShown();
void Hide();
void Show();
void *handle;
void SetCurrent( void *ctx);
//rCanvas *GetCanvas();
void *GetNewContext();
void Flip(/*rGLContext*/void *ctx);
};
struct rPlatform
{
rGLFrame *getGLGSFrame();
static rPlatform &getPlatform();
static int getKeyboardHandlerCount();
static KeyboardHandlerBase *getKeyboardHandler(int i);
static int getMouseHandlerCount();
static MouseHandlerBase *getMouseHandler(int i);
static int getPadHandlerCount();
static PadHandlerBase *getPadHandler(int i);
};
/**********************************************************************
*********** RSX Debugger
************************************************************************/
struct RSXDebuggerProgram
{
u32 id;
u32 vp_id;
u32 fp_id;
std::string vp_shader;
std::string fp_shader;
bool modified;
RSXDebuggerProgram()
: modified(false)
{
}
};
extern std::vector<RSXDebuggerProgram> m_debug_programs;
/**********************************************************************
*********** Image stuff
************************************************************************/
enum rImageType
{
rBITMAP_TYPE_PNG
};
struct rImage
{
rImage();
rImage(const rImage &) = delete;
~rImage();
void Create(int width , int height, void *data, void *alpha);
void SaveFile(const std::string& name, rImageType type);
void *handle;
};

261
Utilities/rTime.cpp Normal file
View File

@ -0,0 +1,261 @@
#include "stdafx.h"
#include <wx/datetime.h>
std::string rDefaultDateTimeFormat = "%c";
rTimeSpan::rTimeSpan()
{
handle = static_cast<void *>(new wxTimeSpan());
}
rTimeSpan::~rTimeSpan()
{
delete static_cast<wxTimeSpan*>(handle);
}
rTimeSpan::rTimeSpan(const rTimeSpan& other)
{
handle = static_cast<void *>(new wxTimeSpan(*static_cast<wxTimeSpan*>(other.handle)));
}
rTimeSpan::rTimeSpan(int a, int b , int c, int d)
{
handle = static_cast<void *>(new wxTimeSpan(a,b,c,d));
}
rDateSpan::rDateSpan()
{
handle = static_cast<void *>(new wxDateSpan());
}
rDateSpan::~rDateSpan()
{
delete static_cast<wxDateSpan*>(handle);
}
rDateSpan::rDateSpan(const rDateSpan& other)
{
handle = static_cast<void *>(new wxDateSpan(*static_cast<wxDateSpan*>(other.handle)));
}
rDateSpan::rDateSpan(int a, int b, int c, int d)
{
handle = static_cast<void *>(new wxDateSpan(a,b,c,d));
}
//enum TZ
//{
// Local, GMT, UTC
//};
//enum Calender
//{
// Gregorian
//};
//struct rTimeZone
//{
// rTimeZone();
// rTimeZone(rDateTime::TZ timezone);
//};
//struct WeekDay
//{
// WeekDay();
// WeekDay(int a);
//};
//struct Month
//{
// Month();
// Month(int a);
//};
rDateTime::rDateTime()
{
handle = static_cast<void *>(new wxDateTime());
}
rDateTime::~rDateTime()
{
delete static_cast<wxDateTime*>(handle);
}
rDateTime::rDateTime(const rDateTime& other)
{
handle = static_cast<void *>(new wxDateTime(*static_cast<wxDateTime*>(other.handle)));
}
rDateTime::rDateTime(const time_t& time)
{
handle = static_cast<void *>(new wxDateTime(time));
}
rDateTime::rDateTime(u16 day, rDateTime::Month month, u16 year, u16 hour, u16 minute, u16 second, u32 millisecond)
{
handle = static_cast<void *>(new wxDateTime(day,(wxDateTime::Month)month,year,hour,minute,second,millisecond));
}
rDateTime rDateTime::UNow()
{
rDateTime time;
delete static_cast<wxDateTime*>(time.handle);
time.handle = static_cast<void *>(new wxDateTime(wxDateTime::UNow()));
return time;
}
rDateTime rDateTime::FromUTC(bool val)
{
rDateTime time(*this);
void *temp = time.handle;
time.handle = static_cast<void *>(new wxDateTime(static_cast<wxDateTime*>(temp)->FromTimezone(wxDateTime::GMT0, val)));
delete static_cast<wxDateTime*>(temp);
return time;
}
rDateTime rDateTime::ToUTC(bool val)
{
rDateTime time(*this);
void *temp = time.handle;
time.handle = static_cast<void *>(new wxDateTime(static_cast<wxDateTime*>(temp)->ToTimezone(wxDateTime::GMT0, val)));
delete static_cast<wxDateTime*>(temp);
return time;
}
time_t rDateTime::GetTicks()
{
return static_cast<wxDateTime*>(handle)->GetTicks();
}
void rDateTime::Add(const rTimeSpan& span)
{
static_cast<wxDateTime*>(handle)->Add(*static_cast<wxTimeSpan*>(span.handle));
}
void rDateTime::Add(const rDateSpan& span)
{
static_cast<wxDateTime*>(handle)->Add(*static_cast<wxDateSpan*>(span.handle));
}
//void rDateTime::Close()
//{
// static_cast<wxDateTime*>(handle)->Close();
//}
wxDateTime::TimeZone convertTZ(rDateTime::rTimeZone tz)
{
switch (tz)
{
case rDateTime::Local:
return wxDateTime::Local;
case rDateTime::GMT0:
return wxDateTime::GMT0;
case rDateTime::UTC:
return wxDateTime::UTC;
default:
throw std::string("WRONG DATETIME");
}
}
std::string rDateTime::Format(const std::string &format, const rTimeZone &tz) const
{
return fmt::ToUTF8(static_cast<wxDateTime*>(handle)->Format(fmt::FromUTF8(format),convertTZ(tz)));
}
void rDateTime::ParseDateTime(const std::string & format)
{
/*return fmt::ToUTF8(*/static_cast<wxDateTime*>(handle)->ParseDateTime(fmt::FromUTF8(format));
}
u32 rDateTime::GetAsDOS()
{
return static_cast<wxDateTime*>(handle)->GetAsDOS();
}
rDateTime &rDateTime::SetFromDOS(u32 fromdos)
{
static_cast<wxDateTime*>(handle)->SetFromDOS(fromdos);
return *this;
}
bool rDateTime::IsLeapYear(int year, rDateTime::Calender cal)
{
if (cal == Gregorian)
{
return wxDateTime::IsLeapYear(year, wxDateTime::Gregorian);
}
else
{
return wxDateTime::IsLeapYear(year, wxDateTime::Julian);
}
}
int rDateTime::GetNumberOfDays(rDateTime::Month month, int year, rDateTime::Calender cal)
{
if (cal == Gregorian)
{
return wxDateTime::GetNumberOfDays(static_cast<wxDateTime::Month>(month), year, wxDateTime::Gregorian);
}
else
{
return wxDateTime::GetNumberOfDays(static_cast<wxDateTime::Month>(month), year, wxDateTime::Julian);
}
}
void rDateTime::SetToWeekDay(rDateTime::WeekDay day, int n, rDateTime::Month month, int year)
{
static_cast<wxDateTime*>(handle)->SetToWeekDay(
static_cast<wxDateTime::WeekDay>(day)
, n
, static_cast<wxDateTime::Month>(month)
, year
);
}
int rDateTime::GetWeekDay()
{
return static_cast<wxDateTime*>(handle)->GetWeekDay();
}
u16 rDateTime::GetYear(rDateTime::TZ timezone)
{
return static_cast<wxDateTime*>(handle)->GetYear(convertTZ(timezone));
}
u16 rDateTime::GetMonth(rDateTime::TZ timezone)
{
return static_cast<wxDateTime*>(handle)->GetMonth(convertTZ(timezone));
}
u16 rDateTime::GetDay(rDateTime::TZ timezone)
{
return static_cast<wxDateTime*>(handle)->GetDay(convertTZ(timezone));
}
u16 rDateTime::GetHour(rDateTime::TZ timezone)
{
return static_cast<wxDateTime*>(handle)->GetHour(convertTZ(timezone));
}
u16 rDateTime::GetMinute(rDateTime::TZ timezone)
{
return static_cast<wxDateTime*>(handle)->GetMinute(convertTZ(timezone));
}
u16 rDateTime::GetSecond(rDateTime::TZ timezone)
{
return static_cast<wxDateTime*>(handle)->GetSecond(convertTZ(timezone));
}
u32 rDateTime::GetMillisecond(rDateTime::TZ timezone)
{
return static_cast<wxDateTime*>(handle)->GetMillisecond(convertTZ(timezone));
}

102
Utilities/rTime.h Normal file
View File

@ -0,0 +1,102 @@
#pragma once
extern std::string rDefaultDateTimeFormat;
struct rTimeSpan
{
rTimeSpan();
~rTimeSpan();
rTimeSpan(const rTimeSpan& other);
rTimeSpan(int, int, int, int);
void *handle;
};
struct rDateSpan
{
rDateSpan();
~rDateSpan();
rDateSpan(const rDateSpan& other);
rDateSpan(int, int, int, int);
void *handle;
};
struct rDateTime
{
enum TZ
{
Local, GMT0,UTC
};
enum Calender
{
Gregorian, Julian
};
using rTimeZone = TZ;
enum WeekDay
{
Sun = 0,
Mon,
Tue,
Wed,
Thu,
Fri,
Sat,
Inv_WeekDay
};
enum Month {
Jan = 0,
Feb = 1,
Mar = 2,
Apr = 3,
May = 4,
Jun = 5,
Jul = 6,
Aug = 7,
Sep = 8,
Oct = 9,
Nov = 10,
Dec = 11,
Inv_Month = 12
};
rDateTime();
~rDateTime();
rDateTime(const rDateTime& other);
rDateTime(const time_t &time);
rDateTime(u16 day, rDateTime::Month month, u16 year, u16 hour, u16 minute, u16 second, u32 millisecond);
static rDateTime UNow();
rDateTime FromUTC(bool val);
rDateTime ToUTC(bool val);
time_t GetTicks();
void Add(const rTimeSpan& span);
void Add(const rDateSpan& span);
void Close();
std::string Format(const std::string &format = rDefaultDateTimeFormat, const rTimeZone &tz = Local) const;
void ParseDateTime(const std::string & format);
u32 GetAsDOS();
rDateTime &SetFromDOS(u32 fromdos);
static bool IsLeapYear(int year, rDateTime::Calender cal);
static int GetNumberOfDays(rDateTime::Month month, int year, rDateTime::Calender cal);
void SetToWeekDay(rDateTime::WeekDay day, int n, rDateTime::Month month, int year);
int GetWeekDay();
u16 GetYear( rDateTime::TZ timezone);
u16 GetMonth(rDateTime::TZ timezone);
u16 GetDay(rDateTime::TZ timezone);
u16 GetHour(rDateTime::TZ timezone);
u16 GetMinute(rDateTime::TZ timezone);
u16 GetSecond(rDateTime::TZ timezone);
u32 GetMillisecond(rDateTime::TZ timezone);
void *handle;
};

115
Utilities/rXml.cpp Normal file
View File

@ -0,0 +1,115 @@
#include "stdafx.h"
#include <memory>
#include <wx/xml/xml.h>
rXmlNode::rXmlNode()
{
ownPtr = true;
handle = reinterpret_cast<void *>(new wxXmlNode());
}
rXmlNode::rXmlNode(void *ptr)
{
ownPtr = false;
handle = ptr;
}
rXmlNode::rXmlNode(const rXmlNode& other)
{
ownPtr = true;
handle = reinterpret_cast<void *>(new wxXmlNode(*reinterpret_cast<wxXmlNode*>(other.handle)));
}
rXmlNode &rXmlNode::operator=(const rXmlNode& other)
{
if (ownPtr)
{
delete reinterpret_cast<wxXmlNode*>(handle);
}
handle = reinterpret_cast<void *>(new wxXmlNode(*reinterpret_cast<wxXmlNode*>(other.handle)));
ownPtr = true;
return *this;
}
rXmlNode::~rXmlNode()
{
if (ownPtr)
{
delete reinterpret_cast<wxXmlNode*>(handle);
}
}
std::shared_ptr<rXmlNode> rXmlNode::GetChildren()
{
wxXmlNode* result = reinterpret_cast<wxXmlNode*>(handle)->GetChildren();
if (result)
{
return std::make_shared<rXmlNode>(reinterpret_cast<void*>(result));
}
else
{
return std::shared_ptr<rXmlNode>(nullptr);
}
}
std::shared_ptr<rXmlNode> rXmlNode::GetNext()
{
wxXmlNode* result = reinterpret_cast<wxXmlNode*>(handle)->GetNext();
if (result)
{
return std::make_shared<rXmlNode>(reinterpret_cast<void*>(result));
}
else
{
return std::shared_ptr<rXmlNode>(nullptr);
}
}
std::string rXmlNode::GetName()
{
return fmt::ToUTF8(reinterpret_cast<wxXmlNode*>(handle)->GetName());
}
std::string rXmlNode::GetAttribute(const std::string &name)
{
return fmt::ToUTF8(reinterpret_cast<wxXmlNode*>(handle)->GetAttribute(fmt::FromUTF8(name)));
}
std::string rXmlNode::GetNodeContent()
{
return fmt::ToUTF8(reinterpret_cast<wxXmlNode*>(handle)->GetNodeContent());
}
rXmlDocument::rXmlDocument()
{
handle = reinterpret_cast<void *>(new wxXmlDocument());
}
rXmlDocument::rXmlDocument(const rXmlDocument& other)
{
handle = reinterpret_cast<void *>(new wxXmlDocument(*reinterpret_cast<wxXmlDocument*>(other.handle)));
}
rXmlDocument &rXmlDocument::operator = (const rXmlDocument& other)
{
delete reinterpret_cast<wxXmlDocument*>(handle);
handle = reinterpret_cast<void *>(new wxXmlDocument(*reinterpret_cast<wxXmlDocument*>(other.handle)));
return *this;
}
rXmlDocument::~rXmlDocument()
{
delete reinterpret_cast<wxXmlDocument*>(handle);
}
void rXmlDocument::Load(const std::string & path)
{
reinterpret_cast<wxXmlDocument*>(handle)->Load(fmt::FromUTF8(path));
}
std::shared_ptr<rXmlNode> rXmlDocument::GetRoot()
{
return std::make_shared<rXmlNode>(reinterpret_cast<void*>(reinterpret_cast<wxXmlDocument*>(handle)->GetRoot()));
}

30
Utilities/rXml.h Normal file
View File

@ -0,0 +1,30 @@
#pragma once
struct rXmlNode
{
rXmlNode();
rXmlNode(void *);
rXmlNode(const rXmlNode& other);
rXmlNode &operator=(const rXmlNode& other);
~rXmlNode();
std::shared_ptr<rXmlNode> GetChildren();
std::shared_ptr<rXmlNode> GetNext();
std::string GetName();
std::string GetAttribute( const std::string &name);
std::string GetNodeContent();
void *handle;
bool ownPtr;
};
struct rXmlDocument
{
rXmlDocument();
rXmlDocument(const rXmlDocument& other);
rXmlDocument &operator=(const rXmlDocument& other);
~rXmlDocument();
void Load(const std::string & path);
std::shared_ptr<rXmlNode> GetRoot();
void *handle;
};

10
asmjitsrc/asmjit.vcxproj
View File

@ -69,14 +69,14 @@
<ConfigurationType>StaticLibrary</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
<PlatformToolset>v120</PlatformToolset>
<WholeProgramOptimization>true</WholeProgramOptimization>
<WholeProgramOptimization>false</WholeProgramOptimization>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
<PlatformToolset>v120</PlatformToolset>
<WholeProgramOptimization>true</WholeProgramOptimization>
<WholeProgramOptimization>false</WholeProgramOptimization>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
@ -151,6 +151,9 @@
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
</Link>
<Lib>
<LinkTimeCodeGeneration>false</LinkTimeCodeGeneration>
</Lib>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<ClCompile>
@ -166,6 +169,9 @@
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
</Link>
<Lib>
<LinkTimeCodeGeneration>false</LinkTimeCodeGeneration>
</Lib>
</ItemDefinitionGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">

13
rpcs3.sln
View File

@ -1,11 +1,14 @@
Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio 2013
VisualStudioVersion = 12.0.21005.1
# Visual Studio Express 2013 for Windows Desktop
VisualStudioVersion = 12.0.30501.0
MinimumVisualStudioVersion = 10.0.40219.1
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "rpcs3", "rpcs3\rpcs3.vcxproj", "{70CD65B0-91D6-4FAE-9A7B-4AF55D0D1B12}"
ProjectSection(ProjectDependencies) = postProject
{CD478F02-7550-58A5-E085-CE4BC0C0AD23} = {CD478F02-7550-58A5-E085-CE4BC0C0AD23}
{067D9406-2A93-DACA-9449-93A2D356357D} = {067D9406-2A93-DACA-9449-93A2D356357D}
{C4A10229-4712-4BD2-B63E-50D93C67A038} = {C4A10229-4712-4BD2-B63E-50D93C67A038}
{5C363C34-4741-7036-861C-2E2279CF552E} = {5C363C34-4741-7036-861C-2E2279CF552E}
{23E1C437-A951-5943-8639-A17F3CF2E606} = {23E1C437-A951-5943-8639-A17F3CF2E606}
{22B14659-C5B6-B775-868D-A49198FEAD4A} = {22B14659-C5B6-B775-868D-A49198FEAD4A}
@ -135,6 +138,8 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "asmjit", "asmjitsrc\asmjit.
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "asmjit", "asmjit", "{E2A982F2-4B1A-48B1-8D77-A17A589C58D7}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "emucore", "rpcs3\emucore.vcxproj", "{C4A10229-4712-4BD2-B63E-50D93C67A038}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug - MemLeak|x64 = Debug - MemLeak|x64
@ -186,6 +191,7 @@ Global
{99C9EB95-DB4C-1996-490E-5212EFBF07C3}.Release|x64.Build.0 = Release|x64
{6EDC3B79-D217-F11A-406F-F11D856493F9}.Debug - MemLeak|x64.ActiveCfg = Debug|x64
{6EDC3B79-D217-F11A-406F-F11D856493F9}.Debug - MemLeak|x64.Build.0 = Debug|x64
{6EDC3B79-D217-F11A-406F-F11D856493F9}.Debug - MemLeak|x64.Deploy.0 = Debug|x64
{6EDC3B79-D217-F11A-406F-F11D856493F9}.Debug|x64.ActiveCfg = Debug|x64
{6EDC3B79-D217-F11A-406F-F11D856493F9}.Debug|x64.Build.0 = Debug|x64
{6EDC3B79-D217-F11A-406F-F11D856493F9}.Release|x64.ActiveCfg = Release|x64
@ -281,10 +287,17 @@ Global
{74827EBD-93DC-5110-BA95-3F2AB029B6B0}.Release|x64.ActiveCfg = Release|x64
{74827EBD-93DC-5110-BA95-3F2AB029B6B0}.Release|x64.Build.0 = Release|x64
{AC40FF01-426E-4838-A317-66354CEFAE88}.Debug - MemLeak|x64.ActiveCfg = Debug|x64
{AC40FF01-426E-4838-A317-66354CEFAE88}.Debug - MemLeak|x64.ActiveCfg = Debug|x64
{AC40FF01-426E-4838-A317-66354CEFAE88}.Debug|x64.ActiveCfg = Debug|x64
{AC40FF01-426E-4838-A317-66354CEFAE88}.Debug|x64.Build.0 = Debug|x64
{AC40FF01-426E-4838-A317-66354CEFAE88}.Release|x64.ActiveCfg = Release|x64
{AC40FF01-426E-4838-A317-66354CEFAE88}.Release|x64.Build.0 = Release|x64
{C4A10229-4712-4BD2-B63E-50D93C67A038}.Debug - MemLeak|x64.ActiveCfg = Debug - MemLeak|x64
{C4A10229-4712-4BD2-B63E-50D93C67A038}.Debug - MemLeak|x64.Build.0 = Debug - MemLeak|x64
{C4A10229-4712-4BD2-B63E-50D93C67A038}.Debug|x64.ActiveCfg = Debug|x64
{C4A10229-4712-4BD2-B63E-50D93C67A038}.Debug|x64.Build.0 = Debug|x64
{C4A10229-4712-4BD2-B63E-50D93C67A038}.Release|x64.ActiveCfg = Release|x64
{C4A10229-4712-4BD2-B63E-50D93C67A038}.Release|x64.Build.0 = Release|x64
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE

2
rpcs3/CMakeLists.txt
View File

@ -11,6 +11,7 @@ if (CMAKE_COMPILER_IS_GNUCXX)
else()
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
endif()
add_definitions(-DwxGUI)
#add_definitions(-D__WXGTK__)
#add_definitions(-Wfatal-errors)
add_definitions(-w) # TODO: remove me
@ -19,6 +20,7 @@ if (CMAKE_COMPILER_IS_GNUCXX)
add_definitions(-g) # Debugging!!
add_definitions(-msse2)
elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
add_definitions(-DwxGUI)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++0x")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fexceptions")
endif()

14
rpcs3/Crypto/unedat.cpp
View File

@ -133,7 +133,7 @@ unsigned char* get_block_key(int block, NPD_HEADER *npd)
}
// EDAT/SDAT functions.
int decrypt_data(wxFile *in, wxFile *out, EDAT_SDAT_HEADER *edat, NPD_HEADER *npd, unsigned char* crypt_key, bool verbose)
int decrypt_data(rFile *in, rFile *out, EDAT_SDAT_HEADER *edat, NPD_HEADER *npd, unsigned char* crypt_key, bool verbose)
{
// Get metadata info and setup buffers.
int block_num = (int) ((edat->file_size + edat->block_size - 1) / edat->block_size);
@ -338,7 +338,7 @@ static bool check_flags(EDAT_SDAT_HEADER *edat, NPD_HEADER *npd)
return true;
}
int check_data(unsigned char *key, EDAT_SDAT_HEADER *edat, NPD_HEADER *npd, wxFile *f, bool verbose)
int check_data(unsigned char *key, EDAT_SDAT_HEADER *edat, NPD_HEADER *npd, rFile *f, bool verbose)
{
f->Seek(0);
unsigned char *header = new unsigned char[0xA0];
@ -490,7 +490,7 @@ void validate_data(const char* file_name, unsigned char *klicensee, NPD_HEADER *
delete[] buf;
}
bool extract_data(wxFile *input, wxFile *output, const char* input_file_name, unsigned char* devklic, unsigned char* rifkey, bool verbose)
bool extract_data(rFile *input, rFile *output, const char* input_file_name, unsigned char* devklic, unsigned char* rifkey, bool verbose)
{
// Setup NPD and EDAT/SDAT structs.
NPD_HEADER *NPD = new NPD_HEADER();
@ -604,9 +604,9 @@ bool extract_data(wxFile *input, wxFile *output, const char* input_file_name, un
int DecryptEDAT(const std::string& input_file_name, const std::string& output_file_name, int mode, const std::string& rap_file_name, unsigned char *custom_klic, bool verbose)
{
// Prepare the files.
wxFile input(input_file_name.c_str());
wxFile output(output_file_name.c_str(), wxFile::write);
wxFile rap(rap_file_name.c_str());
rFile input(input_file_name.c_str());
rFile output(output_file_name.c_str(), rFile::write);
rFile rap(rap_file_name.c_str());
// Set keys (RIF and DEVKLIC).
unsigned char rifkey[0x10];
@ -682,7 +682,7 @@ int DecryptEDAT(const std::string& input_file_name, const std::string& output_fi
{
input.Close();
output.Close();
wxRemoveFile(output_file_name);
rRemoveFile(output_file_name);
return 0;
}

24
rpcs3/Crypto/unpkg.cpp
View File

@ -5,7 +5,7 @@
#include "Emu/ConLog.h"
// Decryption.
bool CheckHeader(wxFile& pkg_f, PKGHeader* m_header)
bool CheckHeader(rFile& pkg_f, PKGHeader* m_header)
{
if (m_header->pkg_magic != 0x7F504B47) {
ConLog.Error("PKG: Not a package file!");
@ -48,7 +48,7 @@ bool CheckHeader(wxFile& pkg_f, PKGHeader* m_header)
return true;
}
bool LoadHeader(wxFile& pkg_f, PKGHeader* m_header)
bool LoadHeader(rFile& pkg_f, PKGHeader* m_header)
{
pkg_f.Seek(0);
@ -63,7 +63,7 @@ bool LoadHeader(wxFile& pkg_f, PKGHeader* m_header)
return true;
}
int Decrypt(wxFile& pkg_f, wxFile& dec_pkg_f, PKGHeader* m_header)
int Decrypt(rFile& pkg_f, rFile& dec_pkg_f, PKGHeader* m_header)
{
if (!LoadHeader(pkg_f, m_header))
return -1;
@ -135,7 +135,7 @@ int Decrypt(wxFile& pkg_f, wxFile& dec_pkg_f, PKGHeader* m_header)
}
// Unpacking.
bool LoadEntries(wxFile& dec_pkg_f, PKGHeader* m_header, PKGEntry *m_entries)
bool LoadEntries(rFile& dec_pkg_f, PKGHeader* m_header, PKGEntry *m_entries)
{
dec_pkg_f.Seek(0);
dec_pkg_f.Read(m_entries, sizeof(PKGEntry) * m_header->file_count);
@ -148,7 +148,7 @@ bool LoadEntries(wxFile& dec_pkg_f, PKGHeader* m_header, PKGEntry *m_entries)
return true;
}
bool UnpackEntry(wxFile& dec_pkg_f, const PKGEntry& entry, std::string dir)
bool UnpackEntry(rFile& dec_pkg_f, const PKGEntry& entry, std::string dir)
{
u8 buf[BUF_SIZE];
@ -163,8 +163,8 @@ bool UnpackEntry(wxFile& dec_pkg_f, const PKGEntry& entry, std::string dir)
case PKG_FILE_ENTRY_SDAT:
case PKG_FILE_ENTRY_REGULAR:
{
wxFile out;
out.Create(dir + buf);
rFile out;
out.Create(dir + std::string(reinterpret_cast<char *>(buf), entry.name_size));
dec_pkg_f.Seek(entry.file_offset);
for (u64 size = 0; size < entry.file_size; ) {
@ -179,18 +179,18 @@ bool UnpackEntry(wxFile& dec_pkg_f, const PKGEntry& entry, std::string dir)
break;
case PKG_FILE_ENTRY_FOLDER:
wxMkdir(dir + buf);
rMkdir(dir + std::string(reinterpret_cast<char *>(buf), entry.name_size));
break;
}
return true;
}
int Unpack(wxFile& pkg_f, std::string src, std::string dst)
int Unpack(rFile& pkg_f, std::string src, std::string dst)
{
PKGHeader* m_header = (PKGHeader*) malloc (sizeof(PKGHeader));
wxFile dec_pkg_f;
std::string decryptedFile = wxGetCwd().ToStdString() + "/dev_hdd1/" + src + ".dec";
rFile dec_pkg_f;
std::string decryptedFile = rGetCwd() + "/dev_hdd1/" + src + ".dec";
dec_pkg_f.Create(decryptedFile, true);
@ -199,7 +199,7 @@ int Unpack(wxFile& pkg_f, std::string src, std::string dst)
dec_pkg_f.Close();
wxFile n_dec_pkg_f(decryptedFile, wxFile::read);
rFile n_dec_pkg_f(decryptedFile, rFile::read);
std::vector<PKGEntry> m_entries;
m_entries.resize(m_header->file_count);

2
rpcs3/Crypto/unpkg.h
View File

@ -47,4 +47,4 @@ struct PKGEntry
be_t<u32> pad; // Padding (zeros)
};
extern int Unpack(wxFile& dec_pkg_f, std::string src, std::string dst);
extern int Unpack(rFile& dec_pkg_f, std::string src, std::string dst);

12
rpcs3/Crypto/unself.cpp
View File

@ -389,7 +389,7 @@ bool SELFDecrypter::DecryptData()
bool SELFDecrypter::MakeElf(const std::string& elf, bool isElf32)
{
// Create a new ELF file.
wxFile e(elf.c_str(), wxFile::write);
rFile e(elf.c_str(), rFile::write);
if(!e.IsOpened())
{
ConLog.Error("Could not create ELF file! (%s)", elf.c_str());
@ -505,17 +505,17 @@ bool SELFDecrypter::GetKeyFromRap(u8 *content_id, u8 *npdrm_key)
// Try to find a matching RAP file under dev_usb000.
std::string ci_str((const char *)content_id);
std::string rap_path(fmt::ToUTF8(wxGetCwd()) + "/dev_usb000/" + ci_str + ".rap");
std::string rap_path(rGetCwd() + "/dev_usb000/" + ci_str + ".rap");
// Check if we have a valid RAP file.
if (!wxFile::Exists(fmt::FromUTF8(rap_path)))
if (!rFile::Exists(rap_path))
{
ConLog.Error("This application requires a valid RAP file for decryption!");
return false;
}
// Open the RAP file and read the key.
wxFile rap_file(fmt::FromUTF8(rap_path), wxFile::read);
rFile rap_file(rap_path, rFile::read);
if (!rap_file.IsOpened())
{
@ -569,7 +569,7 @@ bool IsSelfElf32(const std::string& path)
bool CheckDebugSelf(const std::string& self, const std::string& elf)
{
// Open the SELF file.
wxFile s(fmt::FromUTF8(self));
rFile s(self);
if(!s.IsOpened())
{
@ -597,7 +597,7 @@ bool CheckDebugSelf(const std::string& self, const std::string& elf)
s.Seek(elf_offset);
// Write the real ELF file back.
wxFile e(fmt::FromUTF8(elf), wxFile::write);
rFile e(elf, rFile::write);
if(!e.IsOpened())
{
ConLog.Error("Could not create ELF file! (%s)", elf.c_str());

1
rpcs3/Emu/ARMv7/ARMv7DisAsm.h
View File

@ -1,7 +1,6 @@
#pragma once
#include "Emu/ARMv7/ARMv7Opcodes.h"
#include "Emu/CPU/CPUDisAsm.h"
#include "Gui/DisAsmFrame.h"
#include "Emu/Memory/Memory.h"
static const char* g_arm_cond_name[16] =

2
rpcs3/Emu/Audio/AudioDumper.cpp
View File

@ -11,7 +11,7 @@ AudioDumper::~AudioDumper()
bool AudioDumper::Init()
{
return m_output.Open("audio.wav", wxFile::write);
return m_output.Open("audio.wav", rFile::write);
}
void AudioDumper::WriteHeader()

2
rpcs3/Emu/Audio/AudioDumper.h
View File

@ -55,7 +55,7 @@ class AudioDumper
{
private:
WAVHeader m_header;
wxFile m_output;
rFile m_output;
public:
AudioDumper(u8 ch);

58
rpcs3/Emu/CPU/CPUThread.cpp
View File

@ -4,7 +4,6 @@
#include "Emu/Memory/Memory.h"
#include "Emu/System.h"
#include "rpcs3/Ini.h"
#include "rpcs3.h"
#include "CPUThread.h"
@ -86,13 +85,13 @@ void CPUThread::SetName(const std::string& name)
void CPUThread::Wait(bool wait)
{
wxCriticalSectionLocker lock(m_cs_sync);
rCriticalSectionLocker lock(m_cs_sync);
m_sync_wait = wait;
}
void CPUThread::Wait(const CPUThread& thr)
{
wxCriticalSectionLocker lock(m_cs_sync);
rCriticalSectionLocker lock(m_cs_sync);
m_wait_thread_id = thr.GetId();
m_sync_wait = true;
}
@ -178,13 +177,13 @@ void CPUThread::SetError(const u32 error)
}
}
wxArrayString CPUThread::ErrorToString(const u32 error)
std::vector<std::string> CPUThread::ErrorToString(const u32 error)
{
wxArrayString earr;
std::vector<std::string> earr;
if(error == 0) return earr;
earr.Add("Unknown error");
earr.push_back("Unknown error");
return earr;
}
@ -196,9 +195,7 @@ void CPUThread::Run()
Reset();
#ifndef QT_UI
wxGetApp().SendDbgCommand(DID_START_THREAD, this);
#endif
SendDbgCommand(DID_START_THREAD, this);
m_status = Running;
@ -208,18 +205,14 @@ void CPUThread::Run()
DoRun();
Emu.CheckStatus();
#ifndef QT_UI
wxGetApp().SendDbgCommand(DID_STARTED_THREAD, this);
#endif
SendDbgCommand(DID_STARTED_THREAD, this);
}
void CPUThread::Resume()
{
if(!IsPaused()) return;
#ifndef QT_UI
wxGetApp().SendDbgCommand(DID_RESUME_THREAD, this);
#endif
SendDbgCommand(DID_RESUME_THREAD, this);
m_status = Running;
DoResume();
@ -227,36 +220,28 @@ void CPUThread::Resume()
ThreadBase::Start();
#ifndef QT_UI
wxGetApp().SendDbgCommand(DID_RESUMED_THREAD, this);
#endif
SendDbgCommand(DID_RESUMED_THREAD, this);
}
void CPUThread::Pause()
{
if(!IsRunning()) return;
#ifndef QT_UI
wxGetApp().SendDbgCommand(DID_PAUSE_THREAD, this);
#endif
SendDbgCommand(DID_PAUSE_THREAD, this);
m_status = Paused;
DoPause();
Emu.CheckStatus();
// ThreadBase::Stop(); // "Abort() called" exception
#ifndef QT_UI
wxGetApp().SendDbgCommand(DID_PAUSED_THREAD, this);
#endif
SendDbgCommand(DID_PAUSED_THREAD, this);
}
void CPUThread::Stop()
{
if(IsStopped()) return;
#ifndef QT_UI
wxGetApp().SendDbgCommand(DID_STOP_THREAD, this);
#endif
SendDbgCommand(DID_STOP_THREAD, this);
m_status = Stopped;
@ -270,17 +255,13 @@ void CPUThread::Stop()
Emu.CheckStatus();
#ifndef QT_UI
wxGetApp().SendDbgCommand(DID_STOPED_THREAD, this);
#endif
SendDbgCommand(DID_STOPED_THREAD, this);
}
void CPUThread::Exec()
{
m_is_step = false;
#ifndef QT_UI
wxGetApp().SendDbgCommand(DID_EXEC_THREAD, this);
#endif
SendDbgCommand(DID_EXEC_THREAD, this);
if(IsRunning())
ThreadBase::Start();
@ -289,17 +270,14 @@ void CPUThread::Exec()
void CPUThread::ExecOnce()
{
m_is_step = true;
#ifndef QT_UI
wxGetApp().SendDbgCommand(DID_EXEC_THREAD, this);
#endif
SendDbgCommand(DID_EXEC_THREAD, this);
m_status = Running;
ThreadBase::Start();
ThreadBase::Stop(true,false);
m_status = Paused;
#ifndef QT_UI
wxGetApp().SendDbgCommand(DID_PAUSE_THREAD, this);
wxGetApp().SendDbgCommand(DID_PAUSED_THREAD, this);
#endif
SendDbgCommand(DID_PAUSE_THREAD, this);
SendDbgCommand(DID_PAUSED_THREAD, this);
}
void CPUThread::Task()

6
rpcs3/Emu/CPU/CPUThread.h
View File

@ -133,7 +133,7 @@ public:
u32 m_wait_thread_id;
wxCriticalSection m_cs_sync;
rCriticalSection m_cs_sync;
bool m_sync_wait;
void Wait(bool wait);
void Wait(const CPUThread& thr);
@ -157,8 +157,8 @@ public:
void SetError(const u32 error);
static wxArrayString ErrorToString(const u32 error);
wxArrayString ErrorToString() { return ErrorToString(m_error); }
static std::vector<std::string> ErrorToString(const u32 error);
std::vector<std::string> ErrorToString() { return ErrorToString(m_error); }
bool IsOk() const { return m_error == 0; }
bool IsRunning() const { return m_status == Running; }

8
rpcs3/Emu/CPU/CPUThreadManager.cpp
View File

@ -43,9 +43,7 @@ CPUThread& CPUThreadManager::AddThread(CPUThreadType type)
new_thread->SetId(Emu.GetIdManager().GetNewID(fmt::Format("%s Thread", new_thread->GetTypeString().c_str()), new_thread));
m_threads.push_back(new_thread);
#ifndef QT_UI
wxGetApp().SendDbgCommand(DID_CREATE_THREAD, new_thread);
#endif
SendDbgCommand(DID_CREATE_THREAD, new_thread);
return *new_thread;
}
@ -73,9 +71,7 @@ void CPUThreadManager::RemoveThread(const u32 id)
if (thr)
{
#ifndef QT_UI
wxGetApp().SendDbgCommand(DID_REMOVE_THREAD, thr);
#endif
SendDbgCommand(DID_REMOVE_THREAD, thr);
thr->Close();
m_threads.erase(m_threads.begin() + thread_index);

2
rpcs3/Emu/CPU/CPUThreadManager.h
View File

@ -6,7 +6,7 @@ class CPUThreadManager
{
std::vector<CPUThread*> m_threads;
std::mutex m_mtx_thread;
wxSemaphore m_sem_task;
rSemaphore m_sem_task;
u32 m_raw_spu_num;
public:

1
rpcs3/Emu/Cell/PPCDisAsm.h
View File

@ -1,7 +1,6 @@
#pragma once
#include "Emu/CPU/CPUDisAsm.h"
#include "Gui/DisAsmFrame.h"
#include "Emu/Memory/Memory.h"
class PPCDisAsm : public CPUDisAsm

1
rpcs3/Emu/Cell/PPCThread.cpp
View File

@ -3,7 +3,6 @@
#include "Emu/Memory/Memory.h"
#include "Emu/System.h"
#include "PPCThread.h"
#include "Gui/InterpreterDisAsm.h"
PPCThread* GetCurrentPPCThread()
{

1
rpcs3/Emu/Cell/PPUDisAsm.h
View File

@ -3,7 +3,6 @@
#include "Emu/Cell/PPUOpcodes.h"
#include "Emu/Cell/PPCDisAsm.h"
#include "Emu/Cell/PPCThread.h"
#include "Gui/DisAsmFrame.h"
#include "Emu/Memory/Memory.h"
class PPUDisAsm

6
rpcs3/Emu/Cell/PPUInterpreter.h
View File

@ -4,7 +4,7 @@
#include "Emu/Memory/Memory.h"
#include "Emu/Cell/PPUThread.h"
#include "Emu/SysCalls/SysCalls.h"
#include "rpcs3.h"
//#include "rpcs3.h" //GUI dependency
#include <stdint.h>
#ifdef _MSC_VER
#include <intrin.h>
@ -2095,11 +2095,11 @@ private:
case 0x1: UNK(fmt::Format("HyperCall %d", CPU.GPR[0])); break;
case 0x2: SysCall(); break;
case 0x3:
StaticExecute(CPU.GPR[11]);
Emu.GetSFuncManager().StaticExecute(CPU.GPR[11]);
if (Ini.HLELogging.GetValue())
{
ConLog.Write("'%s' done with code[0x%llx]! #pc: 0x%llx",
g_static_funcs_list[CPU.GPR[11]]->name, CPU.GPR[3], CPU.PC);
Emu.GetSFuncManager()[CPU.GPR[11]]->name, CPU.GPR[3], CPU.PC);
}
break;
case 0x22: UNK("HyperCall LV1"); break;

12
rpcs3/Emu/Cell/PPUProgramCompiler.cpp
View File

@ -1495,7 +1495,7 @@ void CompilePPUProgram::Compile()
s_shstrtab.sh_size = section_name_offset;
section_offset += s_shstrtab.sh_size;
wxFile f(fmt::FromUTF8(m_file_path), wxFile::write);
rFile f(m_file_path, rFile::write);
elf_info.e_magic = 0x7F454C46;
elf_info.e_class = 2; //ELF64
@ -1585,7 +1585,7 @@ void CompilePPUProgram::Compile()
}
f.Seek(s_lib_stub_top.sh_offset);
f.Seek(s_lib_stub_top.sh_size, wxFromCurrent);
f.Seek(s_lib_stub_top.sh_size, rFromCurrent);
f.Seek(s_lib_stub.sh_offset);
for(u32 i=0, nameoffs=4, dataoffs=0; i<modules.size(); ++i)
@ -1608,7 +1608,7 @@ void CompilePPUProgram::Compile()
}
f.Seek(s_lib_stub_btm.sh_offset);
f.Seek(s_lib_stub_btm.sh_size, wxFromCurrent);
f.Seek(s_lib_stub_btm.sh_size, rFromCurrent);
f.Seek(s_data_sceFStub.sh_offset);
for(const Module& module : modules)
@ -1638,13 +1638,13 @@ void CompilePPUProgram::Compile()
f.Write(&prx_param, sizeof(sys_proc_prx_param));
f.Seek(s_lib_ent_top.sh_offset);
f.Seek(s_lib_ent_top.sh_size, wxFromCurrent);
f.Seek(s_lib_ent_top.sh_size, rFromCurrent);
f.Seek(s_lib_ent_btm.sh_offset);
f.Seek(s_lib_ent_btm.sh_size, wxFromCurrent);
f.Seek(s_lib_ent_btm.sh_size, rFromCurrent);
f.Seek(s_tbss.sh_offset);
f.Seek(s_tbss.sh_size, wxFromCurrent);
f.Seek(s_tbss.sh_size, rFromCurrent);
f.Seek(s_shstrtab.sh_offset + 1);
for(u32 i=0; i<sections_names.size(); ++i)

2
rpcs3/Emu/Cell/PPUThread.cpp
View File

@ -191,7 +191,7 @@ bool FPRdouble::IsINF(PPCdouble d)
bool FPRdouble::IsNaN(PPCdouble d)
{
return wxIsNaN(d) ? 1 : 0;
return isnan(d) ? 1 : 0;
}
bool FPRdouble::IsQNaN(PPCdouble d)

2
rpcs3/Emu/Cell/PPUThread.h
View File

@ -2,7 +2,7 @@
#define PPUTHREAD_H
#include "Emu/Cell/PPCThread.h"
#include "Emu/SysCalls/SysCalls.h"
#include "rpcs3.h"
//#include "rpcs3.h" //GUI dependency
#include <cmath>
enum

1
rpcs3/Emu/Cell/SPUDisAsm.h
View File

@ -3,7 +3,6 @@
#include "Emu/Cell/SPUOpcodes.h"
#include "Emu/Cell/PPCDisAsm.h"
#include "Emu/Cell/SPUThread.h"
#include "Gui/DisAsmFrame.h"
#include "Emu/Memory/Memory.h"
class SPUDisAsm

10
rpcs3/Emu/Cell/SPURecompilerCore.cpp
View File

@ -142,11 +142,11 @@ void SPURecompilerCore::Compile(u16 pos)
entry[start].pointer = compiler.make();
compiler.setLogger(nullptr); // crashes without it
wxFile log;
log.Open(wxString::Format("SPUjit_%d.log", GetCurrentSPUThread().GetId()), first ? wxFile::write : wxFile::write_append);
log.Write(wxString::Format("========== START POSITION 0x%x ==========\n\n", start * 4));
log.Write(wxString(stringLogger.getString()));
log.Write(wxString::Format("========== COMPILED %d (excess %d), time: [start=%lld (decoding=%lld), finalize=%lld]\n\n",
rFile log;
log.Open(fmt::Format("SPUjit_%d.log", GetCurrentSPUThread().GetId()), first ? rFile::write : rFile::write_append);
log.Write(fmt::Format("========== START POSITION 0x%x ==========\n\n", start * 4));
log.Write(std::string(stringLogger.getString()));
log.Write(fmt::Format("========== COMPILED %d (excess %d), time: [start=%lld (decoding=%lld), finalize=%lld]\n\n",
entry[start].count, excess, stamp1 - stamp0, time0, get_system_time() - stamp1));
log.Close();
m_enc->compiler = nullptr;

14
rpcs3/Emu/ConLog.h
View File

@ -1,15 +1,8 @@
#pragma once
#include <wx/listctrl.h>
#include "Ini.h"
#include "Gui/FrameBase.h"
class LogWriter
{
wxFile m_logfile;
wxColour m_txtcolour;
//wxString m_prefix;
//wxString m_value;
rFile m_logfile;
void WriteToLog(const std::string& prefix, const std::string& value, u8 lvl);
@ -43,8 +36,9 @@ public:
std::string frmt = fmt::Format(fmt, std::forward<Arg>(args)...);
WriteToLog("S", frmt, 1);
}
virtual void SkipLn();
virtual void SkipLn();
};
extern LogWriter ConLog;

6
rpcs3/Emu/DbgCommand.cpp Normal file
View File

@ -0,0 +1,6 @@
#include "stdafx.h"
void SendDbgCommand(DbgCommand id, CPUThread* thr )
{
wxGetApp().SendDbgCommand(id, thr);
}

40
rpcs3/Emu/DbgCommand.h Normal file
View File

@ -0,0 +1,40 @@
#pragma once
class CPUThread;
enum DbgCommand
{
DID_FIRST_COMMAND = 0x500,
DID_START_EMU,
DID_STARTED_EMU,
DID_STOP_EMU,
DID_STOPPED_EMU,
DID_PAUSE_EMU,
DID_PAUSED_EMU,
DID_RESUME_EMU,
DID_RESUMED_EMU,
DID_READY_EMU,
DID_CREATE_THREAD,
DID_CREATED_THREAD,
DID_REMOVE_THREAD,
DID_REMOVED_THREAD,
DID_RENAME_THREAD,
DID_RENAMED_THREAD,
DID_START_THREAD,
DID_STARTED_THREAD,
DID_STOP_THREAD,
DID_STOPED_THREAD,
DID_PAUSE_THREAD,
DID_PAUSED_THREAD,
DID_RESUME_THREAD,
DID_RESUMED_THREAD,
DID_EXEC_THREAD,
DID_REGISTRED_CALLBACK,
DID_UNREGISTRED_CALLBACK,
DID_EXIT_THR_SYSCALL,
DID_LAST_COMMAND,
};
void SendDbgCommand(DbgCommand id, CPUThread* thr = nullptr);

16
rpcs3/Emu/DbgConsole.cpp
View File

@ -5,13 +5,13 @@
#include "DbgConsole.h"
BEGIN_EVENT_TABLE(DbgConsole, FrameBase)
EVT_CLOSE(DbgConsole::OnQuit)
EVT_CLOSE(DbgConsole::OnQuit)
END_EVENT_TABLE()
DbgConsole::DbgConsole()
: FrameBase(nullptr, wxID_ANY, "Debug Console", "", wxDefaultSize, wxDefaultPosition, wxDEFAULT_FRAME_STYLE, true)
, ThreadBase("DbgConsole thread")
, m_output(nullptr)
: FrameBase(nullptr, wxID_ANY, "Debug Console", "", wxDefaultSize, wxDefaultPosition, wxDEFAULT_FRAME_STYLE, true)
, ThreadBase("DbgConsole thread")
, m_output(nullptr)
{
m_console = new wxTextCtrl(this, wxID_ANY, wxEmptyString, wxDefaultPosition,
wxSize(500, 500), wxTE_MULTILINE | wxTE_READONLY | wxTE_RICH2);
@ -48,7 +48,7 @@ void DbgConsole::Write(int ch, const std::string& text)
}
m_dbg_buffer.Push(DbgPacket(ch, text));
if(!IsAlive()) Start();
if (!IsAlive()) Start();
}
void DbgConsole::Clear()
@ -58,9 +58,9 @@ void DbgConsole::Clear()
void DbgConsole::Task()
{
while(!TestDestroy())
while (!TestDestroy())
{
if(!m_dbg_buffer.HasNewPacket())
if (!m_dbg_buffer.HasNewPacket())
{
if (Emu.IsStopped())
{
@ -78,7 +78,7 @@ void DbgConsole::Task()
if (m_output && Ini.HLESaveTTY.GetValue())
m_output->Write(fmt::FromUTF8(packet.m_text));
if(!DbgConsole::IsShown()) Show();
if (!DbgConsole::IsShown()) Show();
}
}

64
rpcs3/Emu/DbgConsole.h
View File

@ -1,5 +1,63 @@
#pragma once
#include <cstring> //for memset
//struct _DbgBuffer : public MTPacketBuffer<DbgPacket>
//{
// _DbgBuffer() : MTPacketBuffer<DbgPacket>(1024)
// {
// }
//
// void _push(const DbgPacket& data)
// {
// const u32 stext = data.m_text.length();
//
// m_buffer.resize(m_buffer.size() + sizeof(int) + sizeof(u32) + stext);
//
// u32 c_put = m_put;
//
// memcpy(&m_buffer[c_put], &data.m_ch, sizeof(int));
// c_put += sizeof(int);
//
// memcpy(&m_buffer[c_put], &stext, sizeof(u32));
// c_put += sizeof(u32);
// memcpy(&m_buffer[c_put], data.m_text.data(), stext);
// c_put += stext;
//
// m_put = c_put;
// CheckBusy();
// }
//
// DbgPacket _pop()
// {
// DbgPacket ret;
//
// u32 c_get = m_get;
//
// ret.m_ch = *(int*)&m_buffer[c_get];
// c_get += sizeof(int);
//
// const u32& stext = *(u32*)&m_buffer[c_get];
// c_get += sizeof(u32);
// if (stext) ret.m_text = std::string(reinterpret_cast<const char*>(&m_buffer[c_get]), stext );
// c_get += stext;
//
// m_get = c_get;
// if(!HasNewPacket()) Flush();
//
// return ret;
// }
//};
//
//struct DbgConsole
//{
// void *congui;
// DbgConsole();
// void Close();
// void Clear();
// void Write(int ch, const std::string &msg);
//};
struct DbgPacket
{
int m_ch;
@ -58,11 +116,11 @@ struct _DbgBuffer : public MTPacketBuffer<DbgPacket>
const u32& stext = *(u32*)&m_buffer[c_get];
c_get += sizeof(u32);
if (stext) ret.m_text = std::string(reinterpret_cast<const char*>(&m_buffer[c_get]), stext );
if (stext) ret.m_text = std::string(reinterpret_cast<const char*>(&m_buffer[c_get]), stext);
c_get += stext;
m_get = c_get;
if(!HasNewPacket()) Flush();
if (!HasNewPacket()) Flush();
return ret;
}
@ -88,4 +146,4 @@ public:
private:
void OnQuit(wxCloseEvent& event);
DECLARE_EVENT_TABLE();
};
};

12
rpcs3/Emu/FS/VFS.cpp
View File

@ -243,9 +243,9 @@ vfsDevice* VFS::GetDeviceLocal(const std::string& local_path, std::string& path)
u32 max_eq;
s32 max_i=-1;
wxFileName file_path(fmt::FromUTF8(local_path));
rFileName file_path(local_path);
file_path.Normalize();
std::string mormalized_path = fmt::ToUTF8(file_path.GetFullPath());
std::string mormalized_path = file_path.GetFullPath();
for(u32 i=0; i<m_devices.size(); ++i)
{
@ -289,10 +289,10 @@ void VFS::Init(const std::string& path)
continue;
}
wxString mpath = entry.path;
mpath.Replace("$(EmulatorDir)", wxGetCwd());
mpath.Replace("$(GameDir)", fmt::FromUTF8(vfsDevice::GetRoot(path)));
Mount(entry.mount, fmt::ToUTF8(mpath), dev);
std::string mpath = entry.path;
fmt::Replace(mpath,"$(EmulatorDir)", rGetCwd());
fmt::Replace(mpath,"$(GameDir)", vfsDevice::GetRoot(path));
Mount(entry.mount, mpath, dev);
}
}

20
rpcs3/Emu/FS/vfsDevice.cpp
View File

@ -46,24 +46,24 @@ u32 vfsDevice::CmpLocalPath(const std::string& local_path)
if(local_path.length() < m_local_path.length())
return 0;
wxFileName path0(fmt::FromUTF8(m_local_path));
rFileName path0(m_local_path);
path0.Normalize();
#ifdef _WIN32
#define DL '\\'
#define DL "\\"
#else
#define DL '/'
#define DL "/"
#endif
wxArrayString arr0 = wxSplit(path0.GetFullPath(), DL);
wxArrayString arr1 = wxSplit(fmt::FromUTF8(local_path), DL);
std::vector<std::string> arr0 = fmt::rSplit(path0.GetFullPath(), DL);
std::vector<std::string> arr1 = fmt::rSplit(local_path, DL);
const u32 lim = std::min(arr0.GetCount(), arr1.GetCount());
const u32 lim = std::min(arr0.size(), arr1.size());
u32 ret = 0;
for(u32 i=0; i<lim; ret += arr0[i++].Len() + 1)
for(u32 i=0; i<lim; ret += arr0[i++].size() + 1)
{
if(arr0[i].CmpNoCase(arr1[i]) != 0)
if(fmt::CmpNoCase(arr0[i],arr1[i]) != 0)
{
break;
}
@ -188,9 +188,9 @@ std::string vfsDevice::GetWinPath(const std::string& p, bool is_dir)
if(is_dir && ret[ret.length() - 1] != '/' && ret[ret.length() - 1] != '\\') ret += '/'; // ???
wxFileName res(fmt::FromUTF8(ret));
rFileName res(ret);
res.Normalize();
return fmt::ToUTF8(res.GetFullPath());
return res.GetFullPath();
}
std::string vfsDevice::GetWinPath(const std::string& l, const std::string& r)

2
rpcs3/Emu/FS/vfsDirBase.cpp
View File

@ -32,7 +32,7 @@ bool vfsDirBase::IsOpened() const
bool vfsDirBase::IsExists(const std::string& path) const
{
return wxDirExists(fmt::FromUTF8(path));
return rDirExists(path);
}
const std::vector<DirEntryInfo>& vfsDirBase::GetEntries() const

18
rpcs3/Emu/FS/vfsLocalDir.cpp
View File

@ -15,24 +15,24 @@ bool vfsLocalDir::Open(const std::string& path)
if(!vfsDirBase::Open(path))
return false;
wxDir dir;
rDir dir;
if(!dir.Open(path))
return false;
wxString name;
std::string name;
for(bool is_ok = dir.GetFirst(&name); is_ok; is_ok = dir.GetNext(&name))
{
wxString dir_path = fmt::FromUTF8(path) + name;
std::string dir_path = path + name;
m_entries.emplace_back();
DirEntryInfo& info = m_entries.back();
info.name = fmt::ToUTF8(name);
info.name = name;
info.flags |= dir.Exists(dir_path) ? DirEntry_TypeDir : DirEntry_TypeFile;
if(wxIsWritable(dir_path)) info.flags |= DirEntry_PermWritable;
if(wxIsReadable(dir_path)) info.flags |= DirEntry_PermReadable;
if(wxIsExecutable(dir_path)) info.flags |= DirEntry_PermExecutable;
if(rIsWritable(dir_path)) info.flags |= DirEntry_PermWritable;
if(rIsReadable(dir_path)) info.flags |= DirEntry_PermReadable;
if(rIsExecutable(dir_path)) info.flags |= DirEntry_PermExecutable;
}
return true;
@ -40,7 +40,7 @@ bool vfsLocalDir::Open(const std::string& path)
bool vfsLocalDir::Create(const std::string& path)
{
return wxFileName::Mkdir(fmt::FromUTF8(path), 0777, wxPATH_MKDIR_FULL);
return rFileName::Mkdir(path, 0777, rPATH_MKDIR_FULL);
}
bool vfsLocalDir::Rename(const std::string& from, const std::string& to)
@ -50,5 +50,5 @@ bool vfsLocalDir::Rename(const std::string& from, const std::string& to)
bool vfsLocalDir::Remove(const std::string& path)
{
return wxRmdir(fmt::FromUTF8(path));
return rRmdir(path);
}

38
rpcs3/Emu/FS/vfsLocalFile.cpp
View File

@ -2,30 +2,30 @@
#include "Emu/ConLog.h"
#include "vfsLocalFile.h"
static const wxFile::OpenMode vfs2wx_mode(vfsOpenMode mode)
static const rFile::OpenMode vfs2wx_mode(vfsOpenMode mode)
{
switch(mode)
{
case vfsRead: return wxFile::read;
case vfsWrite: return wxFile::write;
case vfsReadWrite: return wxFile::read_write;
case vfsWriteExcl: return wxFile::write_excl;
case vfsWriteAppend: return wxFile::write_append;
case vfsRead: return rFile::read;
case vfsWrite: return rFile::write;
case vfsReadWrite: return rFile::read_write;
case vfsWriteExcl: return rFile::write_excl;
case vfsWriteAppend: return rFile::write_append;
}
return wxFile::read;
return rFile::read;
}
static const wxSeekMode vfs2wx_seek(vfsSeekMode mode)
static const rSeekMode vfs2wx_seek(vfsSeekMode mode)
{
switch(mode)
{
case vfsSeekSet: return wxFromStart;
case vfsSeekCur: return wxFromCurrent;
case vfsSeekEnd: return wxFromEnd;
case vfsSeekSet: return rFromStart;
case vfsSeekCur: return rFromCurrent;
case vfsSeekEnd: return rFromEnd;
}
return wxFromStart;
return rFromStart;
}
vfsLocalFile::vfsLocalFile(vfsDevice* device) : vfsFileBase(device)
@ -45,9 +45,9 @@ bool vfsLocalFile::Open(const std::string& path, vfsOpenMode mode)
// }
// else
// {
if(!m_file.Access(fmt::FromUTF8(path), vfs2wx_mode(mode))) return false;
if(!m_file.Access(path, vfs2wx_mode(mode))) return false;
return m_file.Open(fmt::FromUTF8(path), vfs2wx_mode(mode)) && vfsFileBase::Open(path, mode);
return m_file.Open(path, vfs2wx_mode(mode)) && vfsFileBase::Open(path, mode);
// }
}
@ -63,19 +63,19 @@ bool vfsLocalFile::Create(const std::string& path)
break;
const std::string& dir = path.substr(0, p);
if(!wxDirExists(fmt::FromUTF8(dir)))
if(!rDirExists(dir))
{
ConLog.Write("create dir: %s", dir.c_str());
wxMkdir(fmt::FromUTF8(dir));
rMkdir(dir);
}
}
//create file
const char m = path[path.length() - 1];
if(m != '/' && m != '\\' && !wxFileExists(fmt::FromUTF8(path))) // ???
if(m != '/' && m != '\\' && !rFileExists(path)) // ???
{
wxFile f;
return f.Create(fmt::FromUTF8(path));
rFile f;
return f.Create(path);
}
return true;

2
rpcs3/Emu/FS/vfsLocalFile.h
View File

@ -4,7 +4,7 @@
class vfsLocalFile : public vfsFileBase
{
private:
wxFile m_file;
rFile m_file;
public:
vfsLocalFile(vfsDevice* device);

2
rpcs3/Emu/GS/GCM.h
View File

@ -1269,7 +1269,7 @@ static const std::string GetMethodName(const u32 id)
{ NV4097_SET_TRANSFORM_BRANCH_BITS, "SetTransformBranchBits" } ,
};
for(u32 i = 0; i < WXSIZEOF(METHOD_NAME_LIST); ++i)
for (u32 i = 0; i < SARRSIZEOF(METHOD_NAME_LIST); ++i)
{
if(METHOD_NAME_LIST[i].id == id) return "cellGcm" + METHOD_NAME_LIST[i].name;
}

62
rpcs3/Emu/GS/GL/GLGSRender.cpp
View File

@ -4,7 +4,6 @@
#include "Emu/System.h"
#include "GLGSRender.h"
#include "Emu/Cell/PPCInstrTable.h"
#include "Gui/RSXDebugger.h"
#define CMD_DEBUG 0
#define DUMP_VERTEX_DATA 0
@ -39,53 +38,6 @@ void printGlError(GLenum err, const std::string& situation)
#define checkForGlError(x) /*x*/
#endif
GLGSFrame::GLGSFrame()
: GSFrame(nullptr, "GSFrame[OpenGL]")
, m_frames(0)
{
canvas = new wxGLCanvas(this, wxID_ANY, NULL);
canvas->SetSize(GetClientSize());
canvas->Bind(wxEVT_LEFT_DCLICK, &GSFrame::OnLeftDclick, this);
}
void GLGSFrame::Flip(wxGLContext *context)
{
if(!canvas) return;
canvas->SetCurrent(*context);
static Timer fps_t;
canvas->SwapBuffers();
m_frames++;
if(fps_t.GetElapsedTimeInSec() >= 0.5)
{
SetTitle(wxString::Format("FPS: %.2f", (double)m_frames / fps_t.GetElapsedTimeInSec()));
m_frames = 0;
fps_t.Start();
}
}
void GLGSFrame::OnSize(wxSizeEvent& event)
{
if(canvas) canvas->SetSize(GetClientSize());
event.Skip();
}
void GLGSFrame::SetViewport(int x, int y, u32 w, u32 h)
{
/*
//ConLog.Warning("SetViewport(x=%d, y=%d, w=%d, h=%d)", x, y, w, h);
const wxSize client = GetClientSize();
const wxSize viewport = AspectRatio(client, wxSize(w, h));
const int vx = (client.GetX() - viewport.GetX()) / 2;
const int vy = (client.GetY() - viewport.GetY()) / 2;
glViewport(vx + x, vy + y, viewport.GetWidth(), viewport.GetHeight());
*/
}
GLGSRender::GLGSRender()
: GSRender()
@ -94,7 +46,7 @@ GLGSRender::GLGSRender()
, m_vp_buf_num(-1)
, m_context(nullptr)
{
m_frame = new GLGSFrame();
m_frame = new rGLFrame();// new GLGSFrame();
}
GLGSRender::~GLGSRender()
@ -164,7 +116,7 @@ void GLGSRender::EnableVertexData(bool indexed_draw)
checkForGlError("initializing vbo");
#if DUMP_VERTEX_DATA
wxFile dump("VertexDataArray.dump", wxFile::write);
rFile dump("VertexDataArray.dump", rFile::write);
#endif
for(u32 i=0; i<m_vertex_count; ++i)
@ -406,7 +358,7 @@ bool GLGSRender::LoadProgram()
m_shader_prog.Compile();
checkForGlError("m_shader_prog.Compile");
wxFile f(wxGetCwd() + "/FragmentProgram.txt", wxFile::write);
rFile f(rGetCwd() + "/FragmentProgram.txt", rFile::write);
f.Write(m_shader_prog.GetShaderText());
}
@ -418,7 +370,7 @@ bool GLGSRender::LoadProgram()
m_vertex_prog.Compile();
checkForGlError("m_vertex_prog.Compile");
wxFile f(wxGetCwd() + "/VertexProgram.txt", wxFile::write);
rFile f(rGetCwd() + "/VertexProgram.txt", rFile::write);
f.Write(m_vertex_prog.shader);
}
@ -656,9 +608,11 @@ void GLGSRender::OnInit()
void GLGSRender::OnInitThread()
{
m_context = new wxGLContext(m_frame->GetCanvas());
m_context = m_frame->GetNewContext();//new rGLContext(m_frame->GetCanvas());
//m_frame->GetCanvas()->SetCurrent(*m_context);
m_frame->SetCurrent(m_context);
m_frame->GetCanvas()->SetCurrent(*m_context);
InitProcTable();
glEnable(GL_TEXTURE_2D);

47
rpcs3/Emu/GS/GL/GLGSRender.h
View File

@ -3,7 +3,6 @@
#include "Emu/GS/RSXThread.h"
#include "GLBuffers.h"
#include "GLProgramBuffer.h"
#include <wx/glcanvas.h>
#pragma comment(lib, "opengl32.lib")
@ -501,7 +500,7 @@ public:
}
}
void Save(RSXTexture& tex, const wxString& name)
void Save(RSXTexture& tex, const std::string& name)
{
if(!m_id || !tex.GetOffset() || !tex.GetWidth() || !tex.GetHeight()) return;
@ -527,7 +526,7 @@ public:
}
{
wxFile f(name + ".raw", wxFile::write);
rFile f(name + ".raw", rFile::write);
f.Write(alldata, texPixelCount * 4);
}
u8* data = new u8[texPixelCount * 3];
@ -544,9 +543,9 @@ public:
*dst_a++ = *src++;
}
wxImage out;
rImage out;
out.Create(tex.GetWidth(), tex.GetHeight(), data, alpha);
out.SaveFile(name, wxBITMAP_TYPE_PNG);
out.SaveFile(name, rBITMAP_TYPE_PNG);
delete[] alldata;
//free(data);
@ -555,14 +554,14 @@ public:
void Save(RSXTexture& tex)
{
static const wxString& dir_path = "textures";
static const wxString& file_fmt = dir_path + "/" + "tex[%d].png";
static const std::string& dir_path = "textures";
static const std::string& file_fmt = dir_path + "/" + "tex[%d].png";
if(!wxDirExists(dir_path)) wxMkdir(dir_path);
if(!rDirExists(dir_path)) rMkdir(dir_path);
u32 count = 0;
while(wxFileExists(wxString::Format(file_fmt, count))) count++;
Save(tex, wxString::Format(file_fmt, count));
while(rFileExists(fmt::Format(file_fmt, count))) count++;
Save(tex, fmt::Format(file_fmt, count));
}
void Bind()
@ -585,24 +584,6 @@ public:
}
};
struct GLGSFrame : public GSFrame
{
wxGLCanvas* canvas;
u32 m_frames;
GLGSFrame();
~GLGSFrame() {}
void Flip(wxGLContext *context);
wxGLCanvas* GetCanvas() const { return canvas; }
virtual void SetViewport(int x, int y, u32 w, u32 h);
private:
virtual void OnSize(wxSizeEvent& event);
};
class PostDrawObj
{
protected:
@ -787,9 +768,9 @@ public:
}
};
class GLGSRender
: public wxWindow
, public GSRender
class GLGSRender //TODO: find out why this used to inherit from wxWindow
: //public wxWindow
/*,*/ public GSRender
{
private:
std::vector<u8> m_vdata;
@ -810,10 +791,10 @@ private:
GLrbo m_rbo;
GLfbo m_fbo;
wxGLContext* m_context;
void* m_context;
public:
GLGSFrame* m_frame;
rGLFrame* m_frame;
u32 m_draw_frames;
u32 m_skip_frames;

2
rpcs3/Emu/GS/GL/GLVertexProgram.cpp
View File

@ -77,7 +77,7 @@ std::string GLVertexDecompilerThread::GetSRC(const u32 n)
ret += m_parr.AddParam(PARAM_NONE, "vec4", "tmp" + std::to_string(src[n].tmp_src));
break;
case 2: //input
if(d1.input_src < WXSIZEOF(reg_table))
if (d1.input_src < SARRSIZEOF(reg_table))
{
ret += m_parr.AddParam(PARAM_IN, "vec4", reg_table[d1.input_src], d1.input_src);
}

5
rpcs3/Emu/GS/GSManager.cpp
View File

@ -7,11 +7,6 @@
#include "Null/NullGSRender.h"
#include "GL/GLGSRender.h"
BEGIN_EVENT_TABLE(GSFrame, wxFrame)
EVT_PAINT(GSFrame::OnPaint)
EVT_SIZE(GSFrame::OnSize)
END_EVENT_TABLE()
GSManager::GSManager() : m_render(nullptr)
{
}

76
rpcs3/Emu/GS/GSRender.cpp
View File

@ -2,85 +2,9 @@
#include "Emu/ConLog.h"
#include "Emu/Memory/Memory.h"
#include "Emu/System.h"
#include "rpcs3/rpcs3.h"
#include "GSRender.h"
wxSize AspectRatio(wxSize rs, const wxSize as)
{
const double aq = (double)as.x / as.y;
const double rq = (double)rs.x / rs.y;
const double q = aq / rq;
if(q > 1.0)
{
rs.y /= q;
}
else if(q < 1.0)
{
rs.x *= q;
}
return rs;
}
GSFrame::GSFrame(wxWindow* parent, const wxString& title) : wxFrame(parent, wxID_ANY, title)
{
CellVideoOutResolution res = ResolutionTable[ResolutionIdToNum(Ini.GSResolution.GetValue())];
SetClientSize(res.width, res.height);
wxGetApp().Bind(wxEVT_KEY_DOWN, &GSFrame::OnKeyDown, this);
Bind(wxEVT_CLOSE_WINDOW, &GSFrame::OnClose, this);
}
void GSFrame::OnPaint(wxPaintEvent& event)
{
wxPaintDC(this);
}
void GSFrame::OnClose(wxCloseEvent& event)
{
Emu.Stop();
}
/*
void GSFrame::OnSize(wxSizeEvent&)
{
const wxSize client = GetClientSize();
const wxSize viewport = AspectRatio(client, m_size);
const int x = (client.GetX() - viewport.GetX()) / 2;
const int y = (client.GetY() - viewport.GetY()) / 2;
SetViewport(wxPoint(x, y), viewport);
}
*/
void GSFrame::OnKeyDown(wxKeyEvent& event)
{
switch(event.GetKeyCode())
{
case WXK_RETURN: if(event.AltDown()) { OnFullScreen(); return; } break;
case WXK_ESCAPE: if(IsFullScreen()) { ShowFullScreen(false); return; } break;
}
event.Skip();
}
void GSFrame::OnFullScreen()
{
ShowFullScreen(!IsFullScreen());
}
/*
void GSFrame::SetSize(int width, int height)
{
m_size.SetWidth(width);
m_size.SetHeight(height);
//wxFrame::SetSize(width, height);
OnSize(wxSizeEvent());
}
*/
GSLockCurrent::GSLockCurrent(GSLockType type) : GSLock(Emu.GetGSManager().GetRender(), type)
{
}

28
rpcs3/Emu/GS/GSRender.h
View File

@ -2,34 +2,6 @@
#include "Emu/GS/GCM.h"
#include "Emu/GS/RSXThread.h"
wxSize AspectRatio(wxSize rs, const wxSize as);
class GSFrame : public wxFrame
{
protected:
GSFrame(wxWindow* parent, const wxString& title);
virtual void SetViewport(int x, int y, u32 w, u32 h) {}
virtual void OnPaint(wxPaintEvent& event);
virtual void OnClose(wxCloseEvent& event);
//virtual void OnSize(wxSizeEvent&);
void OnKeyDown(wxKeyEvent& event);
void OnFullScreen();
public:
void OnLeftDclick(wxMouseEvent&)
{
OnFullScreen();
}
//void SetSize(int width, int height);
private:
DECLARE_EVENT_TABLE();
};
struct GSRender : public RSXThread
{
virtual ~GSRender()

43
rpcs3/Emu/GS/Null/NullGSRender.h
View File

@ -1,58 +1,22 @@
#pragma once
#include "Emu/GS/GSRender.h"
struct NullGSFrame : public GSFrame
{
NullGSFrame() : GSFrame(nullptr, "GSFrame[Null]")
{
Bind(wxEVT_LEFT_DCLICK, &GSFrame::OnLeftDclick, this);
}
void Draw()
{
wxClientDC dc(this);
Draw(&dc);
}
private:
virtual void OnPaint(wxPaintEvent& event)
{
wxPaintDC dc(this);
Draw(&dc);
}
virtual void OnSize(wxSizeEvent& event)
{
GSFrame::OnSize(event);
Draw();
}
void Draw(wxDC* dc)
{
dc->DrawText("Null GS output", 0, 0);
}
};
class NullGSRender
: public wxWindow
, public GSRender
: public GSRender
{
public:
NullGSFrame* m_frame;
NullGSRender() : m_frame(nullptr)
NullGSRender()
{
m_frame = new NullGSFrame();
}
virtual ~NullGSRender()
{
m_frame->Close();
}
private:
virtual void OnInit()
{
m_frame->Show();
}
virtual void OnInitThread()
@ -77,8 +41,5 @@ private:
virtual void Close()
{
Stop();
if(m_frame->IsShown()) m_frame->Hide();
}
};

2
rpcs3/Emu/GS/RSXThread.cpp
View File

@ -1833,7 +1833,7 @@ void RSXThread::Task()
while(!TestDestroy())
{
wxCriticalSectionLocker lock(m_cs_main);
rCriticalSectionLocker lock(m_cs_main);
inc=1;

6
rpcs3/Emu/GS/RSXThread.h
View File

@ -142,9 +142,9 @@ public:
u32 m_draw_array_first;
public:
wxCriticalSection m_cs_main;
wxSemaphore m_sem_flush;
wxSemaphore m_sem_flip;
rCriticalSection m_cs_main;
rSemaphore m_sem_flush;
rSemaphore m_sem_flip;
Callback m_flip_handler;
public:

2
rpcs3/Emu/HDD/HDD.h
View File

@ -63,7 +63,7 @@ public:
static void CreateHDD(const std::string& path, u64 size, u64 block_size)
{
wxFile f(fmt::FromUTF8(path), wxFile::write);
rFile f(path, rFile::write);
static const u64 cur_dir_block = 1;

16
rpcs3/Emu/Io/Keyboard.cpp
View File

@ -1,10 +1,8 @@
#include "stdafx.h"
#include "Emu/ConLog.h"
#include "rpcs3/Ini.h"
#include "rpcs3.h"
#include "Keyboard.h"
#include "Null/NullKeyboardHandler.h"
#include "Windows/WindowsKeyboardHandler.h"
KeyboardManager::KeyboardManager()
: m_keyboard_handler(nullptr)
@ -22,17 +20,13 @@ void KeyboardManager::Init(const u32 max_connect)
return;
// NOTE: Change these to std::make_unique assignments when C++14 comes out.
switch(Ini.KeyboardHandlerMode.GetValue())
int numHandlers = rPlatform::getKeyboardHandlerCount();
int selectedHandler = Ini.KeyboardHandlerMode.GetValue();
if (selectedHandler > numHandlers)
{
case 1:
m_keyboard_handler.reset(new WindowsKeyboardHandler());
break;
default:
case 0:
m_keyboard_handler.reset(new NullKeyboardHandler());
break;
selectedHandler = 0;
}
m_keyboard_handler.reset(rPlatform::getKeyboardHandler(selectedHandler));
m_keyboard_handler->Init(max_connect);
m_inited = true;

16
rpcs3/Emu/Io/Mouse.cpp
View File

@ -1,10 +1,8 @@
#include "stdafx.h"
#include "Emu/ConLog.h"
#include "rpcs3/Ini.h"
#include "rpcs3.h"
#include "Mouse.h"
#include "Null/NullMouseHandler.h"
#include "Windows/WindowsMouseHandler.h"
MouseManager::MouseManager()
: m_mouse_handler(nullptr)
@ -22,17 +20,13 @@ void MouseManager::Init(const u32 max_connect)
return;
// NOTE: Change these to std::make_unique assignments when C++14 is available.
switch(Ini.MouseHandlerMode.GetValue())
int numHandlers = rPlatform::getMouseHandlerCount();
int selectedHandler = Ini.MouseHandlerMode.GetValue();
if (selectedHandler > numHandlers)
{
case 1:
m_mouse_handler.reset(new WindowsMouseHandler());
break;
default:
case 0:
m_mouse_handler.reset(new NullMouseHandler());
break;
selectedHandler = 0;
}
m_mouse_handler.reset(rPlatform::getMouseHandler(selectedHandler));
m_mouse_handler->Init(max_connect);
m_inited = true;

1
rpcs3/Emu/Io/Null/NullKeyboardHandler.h
View File

@ -1,6 +1,7 @@
#pragma once
#include "Emu/Io/KeyboardHandler.h"
#include <cstring> //for memset
class NullKeyboardHandler final : public KeyboardHandlerBase
{

1
rpcs3/Emu/Io/Null/NullMouseHandler.h
View File

@ -1,6 +1,7 @@
#pragma once
#include "Emu/Io/MouseHandler.h"
#include <cstring> //for memset
class NullMouseHandler final : public MouseHandlerBase
{

1
rpcs3/Emu/Io/Null/NullPadHandler.h
View File

@ -1,6 +1,7 @@
#pragma once
#include "Emu/Io/PadHandler.h"
#include <cstring> //for memset
class NullPadHandler final : public PadHandlerBase
{

25
rpcs3/Emu/Io/Pad.cpp
View File

@ -1,13 +1,16 @@
#include "stdafx.h"
#include "Emu/ConLog.h"
#include "rpcs3/Ini.h"
#include "rpcs3.h"
#include "Pad.h"
#include "Null/NullPadHandler.h"
#ifdef wxGUI
#include "Windows/WindowsPadHandler.h"
#include "rpcs3.h"
#if defined(_WIN32)
#include "XInput/XInputPadHandler.h"
#endif
#endif
PadManager::PadManager()
: m_pad_handler(nullptr)
@ -25,23 +28,13 @@ void PadManager::Init(const u32 max_connect)
return;
// NOTE: Change these to std::make_unique assignments when C++14 is available.
switch(Ini.PadHandlerMode.GetValue())
int numHandlers = rPlatform::getPadHandlerCount();
int selectedHandler = Ini.PadHandlerMode.GetValue();
if (selectedHandler > numHandlers)
{
case 1:
m_pad_handler.reset(new WindowsPadHandler());
break;
#if defined(_WIN32)
case 2:
m_pad_handler.reset(new XInputPadHandler());
break;
#endif
default:
case 0:
m_pad_handler.reset(new NullPadHandler());
break;
selectedHandler = 0;
}
m_pad_handler.reset(rPlatform::getPadHandler(selectedHandler));
m_pad_handler->Init(max_connect);
m_inited = true;

7
rpcs3/Emu/Memory/Memory.h
View File

@ -1136,10 +1136,3 @@ typedef mem_list_ptr_t<u16, u32> mem16_ptr_t;
typedef mem_list_ptr_t<u32, u32> mem32_ptr_t;
typedef mem_list_ptr_t<u64, u32> mem64_ptr_t;
//#define re(val) MemoryBase::Reverse(val)
#define re64(val) MemoryBase::Reverse64(val)
#define re32(val) MemoryBase::Reverse32(val)
#define re16(val) MemoryBase::Reverse16(val)
template<typename T> T re(const T val) { T res; se_t<T>::func(res, val); return res; }
template<typename T1, typename T2> void re(T1& dst, const T2 val) { se_t<T1>::func(dst, val); }

450
rpcs3/Emu/SysCalls/ModuleManager.cpp Normal file
View File

@ -0,0 +1,450 @@
#include "stdafx.h"
#include "ModuleManager.h"
extern void cellAdec_init();
extern Module* cellAdec;
extern void cellAtrac_init();
extern Module *cellAtrac;
extern void cellAudio_init();
extern Module *cellAudio;
extern void cellDmux_init();
extern Module *cellDmux;
extern void cellFont_init();
extern void cellFont_load();
extern void cellFont_unload();
extern Module *cellFont;
extern void sys_net_init();
extern Module *sys_net;
extern void sceNpTrophy_unload();
extern void sceNpTrophy_init();
extern Module *sceNpTrophy;
extern void sceNp_init();
extern Module *sceNp;
extern void cellUserInfo_init();
extern Module *cellUserInfo;
extern void cellSysutil_init();
extern Module *cellSysutil;
extern void cellSysutilAp_init();
extern Module *cellSysutilAp;
extern void cellPngDec_init();
extern Module *cellPngDec;
extern void cellNetCtl_init();
extern Module *cellNetCtl;
extern void cellJpgDec_init();
extern Module *cellJpgDec;
extern void cellFontFT_init();
extern void cellFontFT_load();
extern void cellFontFT_unload();
extern Module *cellFontFT;
extern void cellGifDec_init();
extern Module *cellGifDec;
extern void cellGcmSys_init();
extern void cellGcmSys_load();
extern void cellGcmSys_unload();
extern Module *cellGcmSys;
extern void cellGame_init();
extern Module *cellGame;
extern void sys_io_init();
extern Module *sys_io;
extern void cellL10n_init();
extern Module *cellL10n;
extern void cellPamf_init();
extern Module *cellPamf;
extern void cellResc_init();
extern void cellResc_load();
extern void cellResc_unload();
extern Module *cellResc;
extern void cellRtc_init();
extern Module *cellRtc;
extern void cellSpurs_init();
extern Module *cellSpurs;
extern void cellSync_init();
extern Module *cellSync;
extern void cellSysmodule_init();
extern Module *cellSysmodule;
extern void cellVdec_init();
extern Module *cellVdec;
extern void cellVpost_init();
extern Module *cellVpost;
extern void libmixer_init();
extern Module *libmixer;
extern void sysPrxForUser_init();
extern Module *sysPrxForUser;
extern void sys_fs_init();
extern Module *sys_fs;
struct ModuleInfo
{
u32 id;
const char* name;
}
static const g_module_list[] =
{
{ 0x0000, "sys_net" },
{ 0x0001, "sys_http" },
{ 0x0002, "cellHttpUtil" },
{ 0x0003, "cellSsl" },
{ 0x0004, "cellHttps" },
{ 0x0005, "libvdec" },
{ 0x0006, "cellAdec" },
{ 0x0007, "cellDmux" },
{ 0x0008, "cellVpost" },
{ 0x0009, "cellRtc" },
{ 0x000a, "cellSpurs" },
{ 0x000b, "cellOvis" },
{ 0x000c, "cellSheap" },
{ 0x000d, "sys_sync" },
{ 0x000e, "sys_fs" },
{ 0x000f, "cellJpgDec" },
{ 0x0010, "cellGcmSys" },
{ 0x0011, "cellAudio" },
{ 0x0012, "cellPamf" },
{ 0x0013, "cellAtrac" },
{ 0x0014, "cellNetCtl" },
{ 0x0015, "cellSysutil" },
{ 0x0016, "sceNp" },
{ 0x0017, "sys_io" },
{ 0x0018, "cellPngDec" },
{ 0x0019, "cellFont" },
{ 0x001a, "cellFontFT" },
{ 0x001b, "cellFreetype" },
{ 0x001c, "cellUsbd" },
{ 0x001d, "cellSail" },
{ 0x001e, "cellL10n" },
{ 0x001f, "cellResc" },
{ 0x0020, "cellDaisy" },
{ 0x0021, "cellKey2char" },
{ 0x0022, "cellMic" },
{ 0x0023, "cellCamera" },
{ 0x0024, "cellVdecMpeg2" },
{ 0x0025, "cellVdecAvc" },
{ 0x0026, "cellAdecLpcm" },
{ 0x0027, "cellAdecAc3" },
{ 0x0028, "cellAdecAtx" },
{ 0x0029, "cellAdecAt3" },
{ 0x002a, "cellDmuxPamf" },
{ 0x002e, "cellLv2dbg" },
{ 0x0030, "cellUsbpspcm" },
{ 0x0031, "cellAvconfExt" },
{ 0x0032, "cellUserInfo" },
{ 0x0033, "cellSysutilSavedata" },
{ 0x0034, "cellSubdisplay" },
{ 0x0035, "cellSysutilRec" },
{ 0x0036, "cellVideoExport" },
{ 0x0037, "cellGameExec" },
{ 0x0038, "sceNp2" },
{ 0x0039, "cellSysutilAp" },
{ 0x003a, "cellSysutilNpClans" },
{ 0x003b, "cellSysutilOskExt" },
{ 0x003c, "cellVdecDivx" },
{ 0x003d, "cellJpgEnc" },
{ 0x003e, "cellGame" },
{ 0x003f, "cellBgdl" },
{ 0x0040, "cellFreetypeTT" },
{ 0x0041, "cellSysutilVideoUpload" },
{ 0x0042, "cellSysutilSysconfExt" },
{ 0x0043, "cellFiber" },
{ 0x0044, "cellNpCommerce2" },
{ 0x0045, "cellNpTus" },
{ 0x0046, "cellVoice" },
{ 0x0047, "cellAdecCelp8" },
{ 0x0048, "cellCelp8Enc" },
{ 0x0049, "cellLicenseArea" },
{ 0x004a, "cellMusic2" },
{ 0x004e, "cellScreenshot" },
{ 0x004f, "cellMusicDecode" },
{ 0x0050, "cellSpursJq" },
{ 0x0052, "cellPngEnc" },
{ 0x0053, "cellMusicDecode2" },
{ 0x0055, "cellSync2" },
{ 0x0056, "cellNpUtil" },
{ 0x0057, "cellRudp" },
{ 0x0059, "cellNpSns" },
{ 0x005a, "cellGem" },
{ 0xf00a, "cellCelpEnc" },
{ 0xf010, "cellGifDec" },
{ 0xf019, "cellAdecCelp" },
{ 0xf01b, "cellAdecM2bc" },
{ 0xf01d, "cellAdecM4aac" },
{ 0xf01e, "cellAdecMp3" },
{ 0xf023, "cellImejp" },
{ 0xf028, "cellMusic" },
{ 0xf029, "cellPhotoExport" },
{ 0xf02a, "cellPrint" },
{ 0xf02b, "cellPhotoImport" },
{ 0xf02c, "cellMusicExport" },
{ 0xf02e, "cellPhotoDecode" },
{ 0xf02f, "cellSearch" },
{ 0xf030, "cellAvchat2" },
{ 0xf034, "cellSailRec" },
{ 0xf035, "sceNpTrophy" },
{ 0xf053, "cellAdecAt3multi" },
{ 0xf054, "cellLibatrac3multi" }
};
void ModuleManager::init()
{
//this is a really bad hack and the whole idea of Modules and how they're implemented should probably be changed
//the contruction of the modules accessses the global variable for that module.
//For example cellAdec needs to be set before cellAdec_init is called but it would be called in the constructor of
//cellAdec, so we need to point cellAdec to where we will construct it in the future
if (!initialized)
{
m_mod_init.reserve(m_mod_init.size() + 160);//currently 131
for (auto& m : g_module_list)
{
m_mod_init.emplace_back(m.id, m.name);
}
cellAdec = static_cast <Module*>(&(m_mod_init.back())) + 1;
m_mod_init.emplace_back(0x0006, cellAdec_init);
cellAtrac = static_cast <Module*>(&(m_mod_init.back())) + 1;
m_mod_init.emplace_back(0x0013, cellAtrac_init);
cellAudio = static_cast <Module*>(&(m_mod_init.back())) + 1;
m_mod_init.emplace_back(0x0011, cellAudio_init);
cellDmux = static_cast <Module*>(&(m_mod_init.back())) + 1;
m_mod_init.emplace_back(0x0007, cellDmux_init);
cellFont = static_cast <Module*>(&(m_mod_init.back())) + 1;
m_mod_init.emplace_back(0x0019, cellFont_init, cellFont_load, cellFont_unload);
sys_net = static_cast <Module*>(&(m_mod_init.back())) + 1;
m_mod_init.emplace_back((u16)0x0000, sys_net_init);
sceNpTrophy = static_cast <Module*>(&(m_mod_init.back())) + 1;
m_mod_init.emplace_back(0xf035, sceNpTrophy_init, nullptr, sceNpTrophy_unload);
sceNp = static_cast <Module*>(&(m_mod_init.back())) + 1;
m_mod_init.emplace_back(0x0016, sceNp_init);
cellUserInfo = static_cast <Module*>(&(m_mod_init.back())) + 1;
m_mod_init.emplace_back(0x0032, cellUserInfo_init);
cellSysutil = static_cast <Module*>(&(m_mod_init.back())) + 1;
m_mod_init.emplace_back(0x0015, cellSysutil_init);
cellSysutilAp = static_cast <Module*>(&(m_mod_init.back())) + 1;
m_mod_init.emplace_back(0x0039, cellSysutilAp_init);
cellPngDec = static_cast <Module*>(&(m_mod_init.back())) + 1;
m_mod_init.emplace_back(0x0018, cellPngDec_init);
cellNetCtl = static_cast <Module*>(&(m_mod_init.back())) + 1;
m_mod_init.emplace_back(0x0014, cellNetCtl_init);
cellJpgDec = static_cast <Module*>(&(m_mod_init.back())) + 1;
m_mod_init.emplace_back(0x000f, cellJpgDec_init);
cellFontFT = static_cast <Module*>(&(m_mod_init.back())) + 1;
m_mod_init.emplace_back(0x001a, cellFontFT_init, cellFontFT_load, cellFontFT_unload);
cellGifDec = static_cast <Module*>(&(m_mod_init.back())) + 1;
m_mod_init.emplace_back(0xf010, cellGifDec_init);
cellGcmSys = static_cast <Module*>(&(m_mod_init.back())) + 1;
m_mod_init.emplace_back(0x0010, cellGcmSys_init, cellGcmSys_load, cellGcmSys_unload);
cellGame = static_cast <Module*>(&(m_mod_init.back())) + 1;
m_mod_init.emplace_back(0x003e, cellGame_init);
sys_io = static_cast <Module*>(&(m_mod_init.back())) + 1;
m_mod_init.emplace_back(0x0017, sys_io_init);
cellL10n = static_cast <Module*>(&(m_mod_init.back())) + 1;
m_mod_init.emplace_back(0x001e, cellL10n_init);
cellPamf = static_cast <Module*>(&(m_mod_init.back())) + 1;
m_mod_init.emplace_back(0x0012, cellPamf_init);
cellResc = static_cast <Module*>(&(m_mod_init.back())) + 1;
m_mod_init.emplace_back(0x001f, cellResc_init, cellResc_load, cellResc_unload);
cellRtc = static_cast <Module*>(&(m_mod_init.back())) + 1;
m_mod_init.emplace_back(0x0009, cellRtc_init);
cellSpurs = static_cast <Module*>(&(m_mod_init.back())) + 1;
m_mod_init.emplace_back(0x000a, cellSpurs_init);
cellSync = static_cast <Module*>(&(m_mod_init.back())) + 1;
m_mod_init.emplace_back("cellSync", cellSync_init);
cellSysmodule = static_cast <Module*>(&(m_mod_init.back())) + 1;
m_mod_init.emplace_back("cellSysmodule", cellSysmodule_init);
cellVdec = static_cast <Module*>(&(m_mod_init.back())) + 1;
m_mod_init.emplace_back(0x0005, cellVdec_init);
cellVpost = static_cast <Module*>(&(m_mod_init.back())) + 1;
m_mod_init.emplace_back(0x0008, cellVpost_init);
libmixer = static_cast <Module*>(&(m_mod_init.back())) + 1;
m_mod_init.emplace_back("libmixer", libmixer_init);
sysPrxForUser = static_cast <Module*>(&(m_mod_init.back())) + 1;
m_mod_init.emplace_back("sysPrxForUser", sysPrxForUser_init);
sys_fs = static_cast <Module*>(&(m_mod_init.back())) + 1;
m_mod_init.emplace_back(0x000e, sys_fs_init);
initialized = true;
}
}
ModuleManager::ModuleManager() :
m_max_module_id(0),
m_module_2_count(0),
initialized(false)
{
memset(m_modules, 0, 3 * 0xFF * sizeof(Module*));
}
ModuleManager::~ModuleManager()
{
m_mod_init.clear();
}
bool ModuleManager::IsLoadedFunc(u32 id)
{
for (u32 i = 0; i<m_modules_funcs_list.size(); ++i)
{
if (m_modules_funcs_list[i]->id == id)
{
return true;
}
}
return false;
}
bool ModuleManager::CallFunc(u32 num)
{
func_caller* func = nullptr;
{
std::lock_guard<std::mutex> lock(m_funcs_lock);
for (u32 i = 0; i<m_modules_funcs_list.size(); ++i)
{
if (m_modules_funcs_list[i]->id == num)
{
func = m_modules_funcs_list[i]->func;
break;
}
}
}
if (func)
{
(*func)();
return true;
}
return false;
}
bool ModuleManager::UnloadFunc(u32 id)
{
std::lock_guard<std::mutex> lock(m_funcs_lock);
for (u32 i = 0; i<m_modules_funcs_list.size(); ++i)
{
if (m_modules_funcs_list[i]->id == id)
{
m_modules_funcs_list.erase(m_modules_funcs_list.begin() + i);
return true;
}
}
return false;
}
u32 ModuleManager::GetFuncNumById(u32 id)
{
return id;
}
void ModuleManager::UnloadModules()
{
for (u32 i = 0; i<3; ++i)
{
for (u32 j = 0; j<m_max_module_id; ++j)
{
if (m_modules[i][j])
{
m_modules[i][j]->UnLoad();
}
}
}
std::lock_guard<std::mutex> lock(m_funcs_lock);
m_modules_funcs_list.clear();
}
Module* ModuleManager::GetModuleByName(const std::string& name)
{
for (u32 i = 0; i<m_max_module_id; ++i)
{
if (m_modules[0][i] && m_modules[0][i]->GetName() == name)
{
return m_modules[0][i];
}
if (m_modules[1][i] && m_modules[1][i]->GetName() == name)
{
return m_modules[1][i];
}
if (m_modules[2][i] && m_modules[2][i]->GetName() == name)
{
return m_modules[2][i];
}
}
return nullptr;
}
Module* ModuleManager::GetModuleById(u16 id)
{
for (u32 i = 0; i<m_max_module_id; ++i)
{
if (m_modules[0][i] && m_modules[0][i]->GetID() == id)
{
return m_modules[0][i];
}
if (m_modules[1][i] && m_modules[1][i]->GetID() == id)
{
return m_modules[1][i];
}
}
return nullptr;
}
void ModuleManager::SetModule(int id, Module* module, bool with_data)
{
if (id != 0xffff)
{
if (u16((u8)id + 1) > m_max_module_id)
{
m_max_module_id = u16((u8)id + 1);
}
int index;
switch (id >> 8)
{
case 0x00: index = 0; break;
case 0xf0: index = 1; break;
default: assert(0); return;
}
if (m_modules[index][(u8)id])
{
if (with_data)
{
module->SetName(m_modules[index][(u8)id]->GetName());
// delete m_modules[index][(u8)id];
m_modules[index][(u8)id] = module;
}
else
{
m_modules[index][(u8)id]->SetName(module->GetName());
// delete module;
}
}
else
{
m_modules[index][(u8)id] = module;
}
}
else
{
m_modules[2][m_module_2_count++] = module;
if (m_module_2_count > m_max_module_id)
{
m_max_module_id = m_module_2_count;
}
}
}
void ModuleManager::AddFunc(ModuleFunc *func)
{
std::lock_guard<std::mutex> guard(m_funcs_lock);
if (!IsLoadedFunc(func->id))
{
m_modules_funcs_list.push_back(func);
}
}

28
rpcs3/Emu/SysCalls/ModuleManager.h Normal file
View File

@ -0,0 +1,28 @@
#pragma once
#include "Modules.h"
class ModuleManager
{
Module* m_modules[3][0xff];
uint m_max_module_id;
uint m_module_2_count;
std::mutex m_funcs_lock;
std::vector<ModuleFunc *> m_modules_funcs_list;
std::vector<Module> m_mod_init;
bool initialized;
public:
ModuleManager();
~ModuleManager();
void init();
void AddFunc(ModuleFunc *func);
void SetModule(int id, Module* module, bool with_data);
bool IsLoadedFunc(u32 id);
bool CallFunc(u32 num);
bool UnloadFunc(u32 id);
void UnloadModules();
u32 GetFuncNumById(u32 id);
Module* GetModuleByName(const std::string& name);
Module* GetModuleById(u16 id);
};

364
rpcs3/Emu/SysCalls/Modules.cpp
View File

@ -6,322 +6,11 @@
#include "Emu/SysCalls/SC_FUNC.h"
#include "Emu/SysCalls/Modules.h"
#include <mutex>
#include "Emu/System.h"
#include "ModuleManager.h"
Module* g_modules[3][0xff] = {0};
uint g_max_module_id = 0;
uint g_module_2_count = 0;
std::vector<ModuleFunc *> g_modules_funcs_list;
std::mutex g_funcs_lock;
std::vector<SFunc *> g_static_funcs_list;
struct ModuleInfo
{
u32 id;
const char* name;
}
static const g_module_list[] =
{
{0x0000, "sys_net"},
{0x0001, "sys_http"},
{0x0002, "cellHttpUtil"},
{0x0003, "cellSsl"},
{0x0004, "cellHttps"},
{0x0005, "libvdec"},
{0x0006, "cellAdec"},
{0x0007, "cellDmux"},
{0x0008, "cellVpost"},
{0x0009, "cellRtc"},
{0x000a, "cellSpurs"},
{0x000b, "cellOvis"},
{0x000c, "cellSheap"},
{0x000d, "sys_sync"},
{0x000e, "sys_fs"},
{0x000f, "cellJpgDec"},
{0x0010, "cellGcmSys"},
{0x0011, "cellAudio"},
{0x0012, "cellPamf"},
{0x0013, "cellAtrac"},
{0x0014, "cellNetCtl"},
{0x0015, "cellSysutil"},
{0x0016, "sceNp"},
{0x0017, "sys_io"},
{0x0018, "cellPngDec"},
{0x0019, "cellFont"},
{0x001a, "cellFontFT"},
{0x001b, "cellFreetype"},
{0x001c, "cellUsbd"},
{0x001d, "cellSail"},
{0x001e, "cellL10n"},
{0x001f, "cellResc"},
{0x0020, "cellDaisy"},
{0x0021, "cellKey2char"},
{0x0022, "cellMic"},
{0x0023, "cellCamera"},
{0x0024, "cellVdecMpeg2"},
{0x0025, "cellVdecAvc"},
{0x0026, "cellAdecLpcm"},
{0x0027, "cellAdecAc3"},
{0x0028, "cellAdecAtx"},
{0x0029, "cellAdecAt3"},
{0x002a, "cellDmuxPamf"},
{0x002e, "cellLv2dbg"},
{0x0030, "cellUsbpspcm"},
{0x0031, "cellAvconfExt"},
{0x0032, "cellUserInfo"},
{0x0033, "cellSysutilSavedata"},
{0x0034, "cellSubdisplay"},
{0x0035, "cellSysutilRec"},
{0x0036, "cellVideoExport"},
{0x0037, "cellGameExec"},
{0x0038, "sceNp2"},
{0x0039, "cellSysutilAp"},
{0x003a, "cellSysutilNpClans"},
{0x003b, "cellSysutilOskExt"},
{0x003c, "cellVdecDivx"},
{0x003d, "cellJpgEnc"},
{0x003e, "cellGame"},
{0x003f, "cellBgdl"},
{0x0040, "cellFreetypeTT"},
{0x0041, "cellSysutilVideoUpload"},
{0x0042, "cellSysutilSysconfExt"},
{0x0043, "cellFiber"},
{0x0044, "cellNpCommerce2"},
{0x0045, "cellNpTus"},
{0x0046, "cellVoice"},
{0x0047, "cellAdecCelp8"},
{0x0048, "cellCelp8Enc"},
{0x0049, "cellLicenseArea"},
{0x004a, "cellMusic2"},
{0x004e, "cellScreenshot"},
{0x004f, "cellMusicDecode"},
{0x0050, "cellSpursJq"},
{0x0052, "cellPngEnc"},
{0x0053, "cellMusicDecode2"},
{0x0055, "cellSync2"},
{0x0056, "cellNpUtil"},
{0x0057, "cellRudp"},
{0x0059, "cellNpSns"},
{0x005a, "cellGem"},
{0xf00a, "cellCelpEnc"},
{0xf010, "cellGifDec"},
{0xf019, "cellAdecCelp"},
{0xf01b, "cellAdecM2bc"},
{0xf01d, "cellAdecM4aac"},
{0xf01e, "cellAdecMp3"},
{0xf023, "cellImejp"},
{0xf028, "cellMusic"},
{0xf029, "cellPhotoExport"},
{0xf02a, "cellPrint"},
{0xf02b, "cellPhotoImport"},
{0xf02c, "cellMusicExport"},
{0xf02e, "cellPhotoDecode"},
{0xf02f, "cellSearch"},
{0xf030, "cellAvchat2"},
{0xf034, "cellSailRec"},
{0xf035, "sceNpTrophy"},
{0xf053, "cellAdecAt3multi"},
{0xf054, "cellLibatrac3multi"}
};
struct _InitNullModules
{
std::vector<Module*> m_modules;
_InitNullModules()
{
for(auto& m : g_module_list)
{
m_modules.push_back(new Module(m.id, m.name));
}
}
~_InitNullModules()
{
for (int i = 0; i < m_modules.size(); ++i)
{
delete m_modules[i];
}
}
} InitNullModules;
/** HACK: Used to delete SFunc objects that get added to the global static function array (g_static_funcs_list).
* The destructor of this static object gets called when the program shuts down.
*/
struct StaticFunctionListCleaner_t
{
StaticFunctionListCleaner_t() {}
~StaticFunctionListCleaner_t()
{
for (int i = 0; i < g_static_funcs_list.size(); ++i)
{
delete g_static_funcs_list[i];
}
}
} StaticFunctionListCleaner;
bool IsLoadedFunc(u32 id)
{
for(u32 i=0; i<g_modules_funcs_list.size(); ++i)
{
if(g_modules_funcs_list[i]->id == id)
{
return true;
}
}
return false;
}
bool CallFunc(u32 num)
{
func_caller* func = nullptr;
{
std::lock_guard<std::mutex> lock(g_funcs_lock);
for(u32 i=0; i<g_modules_funcs_list.size(); ++i)
{
if(g_modules_funcs_list[i]->id == num)
{
func = g_modules_funcs_list[i]->func;
break;
}
}
}
if (func)
{
(*func)();
return true;
}
return false;
}
bool UnloadFunc(u32 id)
{
std::lock_guard<std::mutex> lock(g_funcs_lock);
for(u32 i=0; i<g_modules_funcs_list.size(); ++i)
{
if(g_modules_funcs_list[i]->id == id)
{
g_modules_funcs_list.erase(g_modules_funcs_list.begin() +i);
return true;
}
}
return false;
}
u32 GetFuncNumById(u32 id)
{
return id;
}
void UnloadModules()
{
for(u32 i=0; i<3; ++i)
{
for(u32 j=0; j<g_max_module_id; ++j)
{
if(g_modules[i][j])
{
g_modules[i][j]->UnLoad();
}
}
}
std::lock_guard<std::mutex> lock(g_funcs_lock);
g_modules_funcs_list.clear();
}
Module* GetModuleByName(const std::string& name)
{
for(u32 i=0; i<g_max_module_id; ++i)
{
if(g_modules[0][i] && g_modules[0][i]->GetName() == name)
{
return g_modules[0][i];
}
if(g_modules[1][i] && g_modules[1][i]->GetName() == name)
{
return g_modules[1][i];
}
if(g_modules[2][i] && g_modules[2][i]->GetName() == name)
{
return g_modules[2][i];
}
}
return nullptr;
}
Module* GetModuleById(u16 id)
{
for(u32 i=0; i<g_max_module_id; ++i)
{
if(g_modules[0][i] && g_modules[0][i]->GetID() == id)
{
return g_modules[0][i];
}
if(g_modules[1][i] && g_modules[1][i]->GetID() == id)
{
return g_modules[1][i];
}
}
return nullptr;
}
void SetModule(int id, Module* module, bool with_data)
{
if(id != 0xffff)
{
if(u16((u8)id + 1) > g_max_module_id)
{
g_max_module_id = u16((u8)id + 1);
}
int index;
switch(id >> 8)
{
case 0x00: index = 0; break;
case 0xf0: index = 1; break;
default: assert(0); return;
}
if(g_modules[index][(u8)id])
{
if(with_data)
{
module->SetName(g_modules[index][(u8)id]->GetName());
// delete g_modules[index][(u8)id];
g_modules[index][(u8)id] = module;
}
else
{
g_modules[index][(u8)id]->SetName(module->GetName());
// delete module;
}
}
else
{
g_modules[index][(u8)id] = module;
}
}
else
{
g_modules[2][g_module_2_count++] = module;
if(g_module_2_count > g_max_module_id)
{
g_max_module_id = g_module_2_count;
}
}
}
Module::Module(u16 id, const char* name)
: m_is_loaded(false)
@ -330,7 +19,7 @@ Module::Module(u16 id, const char* name)
, m_load_func(nullptr)
, m_unload_func(nullptr)
{
SetModule(m_id, this, false);
Emu.GetModuleManager().SetModule(m_id, this, false);
}
Module::Module(const char* name, void (*init)(), void (*load)(), void (*unload)())
@ -340,7 +29,7 @@ Module::Module(const char* name, void (*init)(), void (*load)(), void (*unload)(
, m_load_func(load)
, m_unload_func(unload)
{
SetModule(m_id, this, init != nullptr);
Emu.GetModuleManager().SetModule(m_id, this, init != nullptr);
if(init) init();
}
@ -350,10 +39,35 @@ Module::Module(u16 id, void (*init)(), void (*load)(), void (*unload)())
, m_load_func(load)
, m_unload_func(unload)
{
SetModule(m_id, this, init != nullptr);
Emu.GetModuleManager().SetModule(m_id, this, init != nullptr);
if(init) init();
}
Module::Module(Module &&other)
: m_is_loaded(false)
, m_id(0)
, m_load_func(nullptr)
, m_unload_func(nullptr)
{
std::swap(this->m_name,other.m_name);
std::swap(this->m_id, other.m_id);
std::swap(this->m_is_loaded, other.m_is_loaded);
std::swap(this->m_load_func, other.m_load_func);
std::swap(this->m_unload_func, other.m_unload_func);
std::swap(this->m_funcs_list, other.m_funcs_list);
}
Module &Module::operator =(Module &&other)
{
std::swap(this->m_name, other.m_name);
std::swap(this->m_id, other.m_id);
std::swap(this->m_is_loaded, other.m_is_loaded);
std::swap(this->m_load_func, other.m_load_func);
std::swap(this->m_unload_func, other.m_unload_func);
std::swap(this->m_funcs_list, other.m_funcs_list);
return *this;
}
Module::~Module()
{
UnLoad();
@ -373,11 +87,7 @@ void Module::Load()
for(u32 i=0; i<m_funcs_list.size(); ++i)
{
std::lock_guard<std::mutex> lock(g_funcs_lock);
if(IsLoadedFunc(m_funcs_list[i]->id)) continue;
g_modules_funcs_list.push_back(m_funcs_list[i]);
Emu.GetModuleManager().AddFunc(m_funcs_list[i]);
}
SetLoaded(true);
@ -392,7 +102,7 @@ void Module::UnLoad()
for(u32 i=0; i<m_funcs_list.size(); ++i)
{
UnloadFunc(m_funcs_list[i]->id);
Emu.GetModuleManager().UnloadFunc(m_funcs_list[i]->id);
}
SetLoaded(false);
@ -400,16 +110,16 @@ void Module::UnLoad()
bool Module::Load(u32 id)
{
std::lock_guard<std::mutex> lock(g_funcs_lock);
//std::lock_guard<std::mutex> lock(g_funcs_lock);
if(IsLoadedFunc(id)) return false;
if(Emu.GetModuleManager().IsLoadedFunc(id)) return false;
for(u32 i=0; i<m_funcs_list.size(); ++i)
{
if(m_funcs_list[i]->id == id)
{
g_modules_funcs_list.push_back(m_funcs_list[i]);
//g_modules_funcs_list.push_back(m_funcs_list[i]);
Emu.GetModuleManager().AddFunc(m_funcs_list[i]);
return true;
}
}
@ -419,7 +129,7 @@ bool Module::Load(u32 id)
bool Module::UnLoad(u32 id)
{
return UnloadFunc(id);
return Emu.GetModuleManager().UnloadFunc(id);
}
void Module::SetLoaded(bool loaded)

20
rpcs3/Emu/SysCalls/Modules.h
View File

@ -42,12 +42,10 @@ struct SFunc
}
};
extern std::vector<SFunc *> g_static_funcs_list;
class Module
{
std::string m_name;
const u16 m_id;
u16 m_id;
bool m_is_loaded;
void (*m_load_func)();
void (*m_unload_func)();
@ -59,6 +57,12 @@ public:
Module(const char* name, void (*init)(), void (*load)() = nullptr, void (*unload)() = nullptr);
Module(u16 id, void (*init)(), void (*load)() = nullptr, void (*unload)() = nullptr);
Module(Module &other) = delete;
Module(Module &&other);
Module &operator =(Module &other) = delete;
Module &operator =(Module &&other);
~Module();
void Load();
@ -151,14 +155,6 @@ __forceinline void Module::AddFuncSub(const char group[8], const u64 ops[], cons
op.crc = re(op.crc);
sf->ops.push_back(op);
}
g_static_funcs_list.push_back(sf);
Emu.GetSFuncManager().push_back(sf);
}
bool IsLoadedFunc(u32 id);
bool CallFunc(u32 num);
bool UnloadFunc(u32 id);
void UnloadModules();
u32 GetFuncNumById(u32 id);
Module* GetModuleByName(const std::string& name);
Module* GetModuleById(u16 id);

47
rpcs3/Emu/SysCalls/Modules/cellAdec.cpp
View File

@ -19,8 +19,9 @@ extern "C"
#include "cellAdec.h"
void cellAdec_init();
Module cellAdec(0x0006, cellAdec_init);
//void cellAdec_init();
//Module cellAdec(0x0006, cellAdec_init);
extern Module *cellAdec=nullptr;
int adecRawRead(void* opaque, u8* buf, int buf_size)
{
@ -189,7 +190,7 @@ u32 adecOpen(AudioDecoder* data)
adec.adecCb = &Emu.GetCPU().AddThread(CPU_THREAD_PPU);
u32 adec_id = cellAdec.GetNewId(data);
u32 adec_id = cellAdec->GetNewId(data);
adec.id = adec_id;
@ -530,7 +531,7 @@ bool adecCheckType(AudioCodecType type)
case CELL_ADEC_TYPE_CELP:
case CELL_ADEC_TYPE_M4AAC:
case CELL_ADEC_TYPE_CELP8:
cellAdec.Error("Unimplemented audio codec type (%d)", type);
cellAdec->Error("Unimplemented audio codec type (%d)", type);
break;
default:
return false;
@ -541,7 +542,7 @@ bool adecCheckType(AudioCodecType type)
int cellAdecQueryAttr(mem_ptr_t<CellAdecType> type, mem_ptr_t<CellAdecAttr> attr)
{
cellAdec.Warning("cellAdecQueryAttr(type_addr=0x%x, attr_addr=0x%x)", type.GetAddr(), attr.GetAddr());
cellAdec->Warning("cellAdecQueryAttr(type_addr=0x%x, attr_addr=0x%x)", type.GetAddr(), attr.GetAddr());
if (!type.IsGood() || !attr.IsGood())
{
@ -560,7 +561,7 @@ int cellAdecQueryAttr(mem_ptr_t<CellAdecType> type, mem_ptr_t<CellAdecAttr> attr
int cellAdecOpen(mem_ptr_t<CellAdecType> type, mem_ptr_t<CellAdecResource> res, mem_ptr_t<CellAdecCb> cb, mem32_t handle)
{
cellAdec.Warning("cellAdecOpen(type_addr=0x%x, res_addr=0x%x, cb_addr=0x%x, handle_addr=0x%x)",
cellAdec->Warning("cellAdecOpen(type_addr=0x%x, res_addr=0x%x, cb_addr=0x%x, handle_addr=0x%x)",
type.GetAddr(), res.GetAddr(), cb.GetAddr(), handle.GetAddr());
if (!type.IsGood() || !res.IsGood() || !cb.IsGood() || !handle.IsGood())
@ -577,7 +578,7 @@ int cellAdecOpen(mem_ptr_t<CellAdecType> type, mem_ptr_t<CellAdecResource> res,
int cellAdecOpenEx(mem_ptr_t<CellAdecType> type, mem_ptr_t<CellAdecResourceEx> res, mem_ptr_t<CellAdecCb> cb, mem32_t handle)
{
cellAdec.Warning("cellAdecOpenEx(type_addr=0x%x, res_addr=0x%x, cb_addr=0x%x, handle_addr=0x%x)",
cellAdec->Warning("cellAdecOpenEx(type_addr=0x%x, res_addr=0x%x, cb_addr=0x%x, handle_addr=0x%x)",
type.GetAddr(), res.GetAddr(), cb.GetAddr(), handle.GetAddr());
if (!type.IsGood() || !res.IsGood() || !cb.IsGood() || !handle.IsGood())
@ -594,7 +595,7 @@ int cellAdecOpenEx(mem_ptr_t<CellAdecType> type, mem_ptr_t<CellAdecResourceEx> r
int cellAdecClose(u32 handle)
{
cellAdec.Warning("cellAdecClose(handle=%d)", handle);
cellAdec->Warning("cellAdecClose(handle=%d)", handle);
AudioDecoder* adec;
if (!Emu.GetIdManager().GetIDData(handle, adec))
@ -621,7 +622,7 @@ int cellAdecClose(u32 handle)
int cellAdecStartSeq(u32 handle, u32 param_addr)
{
cellAdec.Log("cellAdecStartSeq(handle=%d, param_addr=0x%x)", handle, param_addr);
cellAdec->Log("cellAdecStartSeq(handle=%d, param_addr=0x%x)", handle, param_addr);
AudioDecoder* adec;
if (!Emu.GetIdManager().GetIDData(handle, adec))
@ -636,7 +637,7 @@ int cellAdecStartSeq(u32 handle, u32 param_addr)
}
else*/
{
cellAdec.Warning("cellAdecStartSeq: (TODO) initialization");
cellAdec->Warning("cellAdecStartSeq: (TODO) initialization");
}
adec->job.Push(task);
@ -645,7 +646,7 @@ int cellAdecStartSeq(u32 handle, u32 param_addr)
int cellAdecEndSeq(u32 handle)
{
cellAdec.Warning("cellAdecEndSeq(handle=%d)", handle);
cellAdec->Warning("cellAdecEndSeq(handle=%d)", handle);
AudioDecoder* adec;
if (!Emu.GetIdManager().GetIDData(handle, adec))
@ -659,7 +660,7 @@ int cellAdecEndSeq(u32 handle)
int cellAdecDecodeAu(u32 handle, mem_ptr_t<CellAdecAuInfo> auInfo)
{
cellAdec.Log("cellAdecDecodeAu(handle=%d, auInfo_addr=0x%x)", handle, auInfo.GetAddr());
cellAdec->Log("cellAdecDecodeAu(handle=%d, auInfo_addr=0x%x)", handle, auInfo.GetAddr());
AudioDecoder* adec;
if (!Emu.GetIdManager().GetIDData(handle, adec))
@ -685,7 +686,7 @@ int cellAdecDecodeAu(u32 handle, mem_ptr_t<CellAdecAuInfo> auInfo)
int cellAdecGetPcm(u32 handle, u32 outBuffer_addr)
{
cellAdec.Log("cellAdecGetPcm(handle=%d, outBuffer_addr=0x%x)", handle, outBuffer_addr);
cellAdec->Log("cellAdecGetPcm(handle=%d, outBuffer_addr=0x%x)", handle, outBuffer_addr);
AudioDecoder* adec;
if (!Emu.GetIdManager().GetIDData(handle, adec))
@ -775,7 +776,7 @@ int cellAdecGetPcm(u32 handle, u32 outBuffer_addr)
int cellAdecGetPcmItem(u32 handle, mem32_t pcmItem_ptr)
{
cellAdec.Log("cellAdecGetPcmItem(handle=%d, pcmItem_ptr_addr=0x%x)", handle, pcmItem_ptr.GetAddr());
cellAdec->Log("cellAdecGetPcmItem(handle=%d, pcmItem_ptr_addr=0x%x)", handle, pcmItem_ptr.GetAddr());
AudioDecoder* adec;
if (!Emu.GetIdManager().GetIDData(handle, adec))
@ -828,15 +829,15 @@ int cellAdecGetPcmItem(u32 handle, mem32_t pcmItem_ptr)
void cellAdec_init()
{
cellAdec.AddFunc(0x7e4a4a49, cellAdecQueryAttr);
cellAdec.AddFunc(0xd00a6988, cellAdecOpen);
cellAdec.AddFunc(0x8b5551a4, cellAdecOpenEx);
cellAdec.AddFunc(0x847d2380, cellAdecClose);
cellAdec.AddFunc(0x487b613e, cellAdecStartSeq);
cellAdec.AddFunc(0xe2ea549b, cellAdecEndSeq);
cellAdec.AddFunc(0x1529e506, cellAdecDecodeAu);
cellAdec.AddFunc(0x97ff2af1, cellAdecGetPcm);
cellAdec.AddFunc(0xbd75f78b, cellAdecGetPcmItem);
cellAdec->AddFunc(0x7e4a4a49, cellAdecQueryAttr);
cellAdec->AddFunc(0xd00a6988, cellAdecOpen);
cellAdec->AddFunc(0x8b5551a4, cellAdecOpenEx);
cellAdec->AddFunc(0x847d2380, cellAdecClose);
cellAdec->AddFunc(0x487b613e, cellAdecStartSeq);
cellAdec->AddFunc(0xe2ea549b, cellAdecEndSeq);
cellAdec->AddFunc(0x1529e506, cellAdecDecodeAu);
cellAdec->AddFunc(0x97ff2af1, cellAdecGetPcm);
cellAdec->AddFunc(0xbd75f78b, cellAdecGetPcmItem);
av_register_all();
avcodec_register_all();

95
rpcs3/Emu/SysCalls/Modules/cellAtrac.cpp
View File

@ -7,14 +7,13 @@
#include "Emu/SysCalls/Modules.h"
#include "Emu/SysCalls/SysCalls.h"
void cellAtrac_init();
Module cellAtrac(0x0013, cellAtrac_init);
extern Module *cellAtrac = nullptr;
#include "cellAtrac.h"
int cellAtracSetDataAndGetMemSize(mem_ptr_t<CellAtracHandle> pHandle, u32 pucBufferAddr, u32 uiReadByte, u32 uiBufferByte, mem32_t puiWorkMemByte)
{
cellAtrac.Error("cellAtracSetDataAndGetMemSize(pHandle=0x%x, pucBufferAddr=0x%x, uiReadByte=0x%x, uiBufferByte=0x%x, puiWorkMemByte_addr=0x%x)",
cellAtrac->Error("cellAtracSetDataAndGetMemSize(pHandle=0x%x, pucBufferAddr=0x%x, uiReadByte=0x%x, uiBufferByte=0x%x, puiWorkMemByte_addr=0x%x)",
pHandle.GetAddr(), pucBufferAddr, uiReadByte, uiBufferByte, puiWorkMemByte.GetAddr());
puiWorkMemByte = 0x1000; // unproved
@ -23,7 +22,7 @@ int cellAtracSetDataAndGetMemSize(mem_ptr_t<CellAtracHandle> pHandle, u32 pucBuf
int cellAtracCreateDecoder(mem_ptr_t<CellAtracHandle> pHandle, u32 pucWorkMem_addr, u32 uiPpuThreadPriority, u32 uiSpuThreadPriority)
{
cellAtrac.Error("cellAtracCreateDecoder(pHandle=0x%x, pucWorkMem_addr=0x%x, uiPpuThreadPriority=%d, uiSpuThreadPriority=%d)",
cellAtrac->Error("cellAtracCreateDecoder(pHandle=0x%x, pucWorkMem_addr=0x%x, uiPpuThreadPriority=%d, uiSpuThreadPriority=%d)",
pHandle.GetAddr(), pucWorkMem_addr, uiPpuThreadPriority, uiSpuThreadPriority);
pHandle->data.pucWorkMem_addr = pucWorkMem_addr;
@ -32,7 +31,7 @@ int cellAtracCreateDecoder(mem_ptr_t<CellAtracHandle> pHandle, u32 pucWorkMem_ad
int cellAtracCreateDecoderExt(mem_ptr_t<CellAtracHandle> pHandle, u32 pucWorkMem_addr, u32 uiPpuThreadPriority, mem_ptr_t<CellAtracExtRes> pExtRes)
{
cellAtrac.Error("cellAtracCreateDecoderExt(pHandle=0x%x, pucWorkMem_addr=0x%x, uiPpuThreadPriority=%d, pExtRes_addr=0x%x)",
cellAtrac->Error("cellAtracCreateDecoderExt(pHandle=0x%x, pucWorkMem_addr=0x%x, uiPpuThreadPriority=%d, pExtRes_addr=0x%x)",
pHandle.GetAddr(), pucWorkMem_addr, uiPpuThreadPriority, pExtRes.GetAddr());
pHandle->data.pucWorkMem_addr = pucWorkMem_addr;
@ -41,13 +40,13 @@ int cellAtracCreateDecoderExt(mem_ptr_t<CellAtracHandle> pHandle, u32 pucWorkMem
int cellAtracDeleteDecoder(mem_ptr_t<CellAtracHandle> pHandle)
{
cellAtrac.Error("cellAtracDeleteDecoder(pHandle=0x%x)", pHandle.GetAddr());
cellAtrac->Error("cellAtracDeleteDecoder(pHandle=0x%x)", pHandle.GetAddr());
return CELL_OK;
}
int cellAtracDecode(mem_ptr_t<CellAtracHandle> pHandle, u32 pfOutAddr, mem32_t puiSamples, mem32_t puiFinishflag, mem32_t piRemainFrame)
{
cellAtrac.Error("cellAtracDecode(pHandle=0x%x, pfOutAddr=0x%x, puiSamples_addr=0x%x, puiFinishFlag_addr=0x%x, piRemainFrame_addr=0x%x)",
cellAtrac->Error("cellAtracDecode(pHandle=0x%x, pfOutAddr=0x%x, puiSamples_addr=0x%x, puiFinishFlag_addr=0x%x, piRemainFrame_addr=0x%x)",
pHandle.GetAddr(), pfOutAddr, puiSamples.GetAddr(), puiFinishflag.GetAddr(), piRemainFrame.GetAddr());
puiSamples = 0;
@ -58,7 +57,7 @@ int cellAtracDecode(mem_ptr_t<CellAtracHandle> pHandle, u32 pfOutAddr, mem32_t p
int cellAtracGetStreamDataInfo(mem_ptr_t<CellAtracHandle> pHandle, mem32_t ppucWritePointer, mem32_t puiWritableByte, mem32_t puiReadPosition)
{
cellAtrac.Error("cellAtracGetStreamDataInfo(pHandle=0x%x, ppucWritePointer_addr=0x%x, puiWritableByte_addr=0x%x, puiReadPosition_addr=0x%x)",
cellAtrac->Error("cellAtracGetStreamDataInfo(pHandle=0x%x, ppucWritePointer_addr=0x%x, puiWritableByte_addr=0x%x, puiReadPosition_addr=0x%x)",
pHandle.GetAddr(), ppucWritePointer.GetAddr(), puiWritableByte.GetAddr(), puiReadPosition.GetAddr());
ppucWritePointer = pHandle->data.pucWorkMem_addr;
@ -69,13 +68,13 @@ int cellAtracGetStreamDataInfo(mem_ptr_t<CellAtracHandle> pHandle, mem32_t ppucW
int cellAtracAddStreamData(mem_ptr_t<CellAtracHandle> pHandle, u32 uiAddByte)
{
cellAtrac.Error("cellAtracAddStreamData(pHandle=0x%x, uiAddByte=0x%x)", pHandle.GetAddr(), uiAddByte);
cellAtrac->Error("cellAtracAddStreamData(pHandle=0x%x, uiAddByte=0x%x)", pHandle.GetAddr(), uiAddByte);
return CELL_OK;
}
int cellAtracGetRemainFrame(mem_ptr_t<CellAtracHandle> pHandle, mem32_t piRemainFrame)
{
cellAtrac.Error("cellAtracGetRemainFrame(pHandle=0x%x, piRemainFrame_addr=0x%x)", pHandle.GetAddr(), piRemainFrame.GetAddr());
cellAtrac->Error("cellAtracGetRemainFrame(pHandle=0x%x, piRemainFrame_addr=0x%x)", pHandle.GetAddr(), piRemainFrame.GetAddr());
piRemainFrame = CELL_ATRAC_ALLDATA_IS_ON_MEMORY;
return CELL_OK;
@ -83,7 +82,7 @@ int cellAtracGetRemainFrame(mem_ptr_t<CellAtracHandle> pHandle, mem32_t piRemain
int cellAtracGetVacantSize(mem_ptr_t<CellAtracHandle> pHandle, mem32_t puiVacantSize)
{
cellAtrac.Error("cellAtracGetVacantSize(pHandle=0x%x, puiVacantSize_addr=0x%x)", pHandle.GetAddr(), puiVacantSize.GetAddr());
cellAtrac->Error("cellAtracGetVacantSize(pHandle=0x%x, puiVacantSize_addr=0x%x)", pHandle.GetAddr(), puiVacantSize.GetAddr());
puiVacantSize = 0x1000;
return CELL_OK;
@ -91,13 +90,13 @@ int cellAtracGetVacantSize(mem_ptr_t<CellAtracHandle> pHandle, mem32_t puiVacant
int cellAtracIsSecondBufferNeeded(mem_ptr_t<CellAtracHandle> pHandle)
{
cellAtrac.Error("cellAtracIsSecondBufferNeeded(pHandle=0x%x)", pHandle.GetAddr());
cellAtrac->Error("cellAtracIsSecondBufferNeeded(pHandle=0x%x)", pHandle.GetAddr());
return CELL_OK;
}
int cellAtracGetSecondBufferInfo(mem_ptr_t<CellAtracHandle> pHandle, mem32_t puiReadPosition, mem32_t puiDataByte)
{
cellAtrac.Error("cellAtracGetSecondBufferInfo(pHandle=0x%x, puiReadPosition_addr=0x%x, puiDataByte_addr=0x%x)",
cellAtrac->Error("cellAtracGetSecondBufferInfo(pHandle=0x%x, puiReadPosition_addr=0x%x, puiDataByte_addr=0x%x)",
pHandle.GetAddr(), puiReadPosition.GetAddr(), puiDataByte.GetAddr());
puiReadPosition = 0;
@ -107,14 +106,14 @@ int cellAtracGetSecondBufferInfo(mem_ptr_t<CellAtracHandle> pHandle, mem32_t pui
int cellAtracSetSecondBuffer(mem_ptr_t<CellAtracHandle> pHandle, u32 pucSecondBufferAddr, u32 uiSecondBufferByte)
{
cellAtrac.Error("cellAtracSetSecondBuffer(pHandle=0x%x, pucSecondBufferAddr=0x%x, uiSecondBufferByte=0x%x)",
cellAtrac->Error("cellAtracSetSecondBuffer(pHandle=0x%x, pucSecondBufferAddr=0x%x, uiSecondBufferByte=0x%x)",
pHandle.GetAddr(), pucSecondBufferAddr, uiSecondBufferByte);
return CELL_OK;
}
int cellAtracGetChannel(mem_ptr_t<CellAtracHandle> pHandle, mem32_t puiChannel)
{
cellAtrac.Error("cellAtracGetChannel(pHandle=0x%x, puiChannel_addr=0x%x)", pHandle.GetAddr(), puiChannel.GetAddr());
cellAtrac->Error("cellAtracGetChannel(pHandle=0x%x, puiChannel_addr=0x%x)", pHandle.GetAddr(), puiChannel.GetAddr());
puiChannel = 2;
return CELL_OK;
@ -122,7 +121,7 @@ int cellAtracGetChannel(mem_ptr_t<CellAtracHandle> pHandle, mem32_t puiChannel)
int cellAtracGetMaxSample(mem_ptr_t<CellAtracHandle> pHandle, mem32_t puiMaxSample)
{
cellAtrac.Error("cellAtracGetMaxSample(pHandle=0x%x, puiMaxSample_addr=0x%x)", pHandle.GetAddr(), puiMaxSample.GetAddr());
cellAtrac->Error("cellAtracGetMaxSample(pHandle=0x%x, puiMaxSample_addr=0x%x)", pHandle.GetAddr(), puiMaxSample.GetAddr());
puiMaxSample = 512;
return CELL_OK;
@ -130,7 +129,7 @@ int cellAtracGetMaxSample(mem_ptr_t<CellAtracHandle> pHandle, mem32_t puiMaxSamp
int cellAtracGetNextSample(mem_ptr_t<CellAtracHandle> pHandle, mem32_t puiNextSample)
{
cellAtrac.Error("cellAtracGetNextSample(pHandle=0x%x, puiNextSample_addr=0x%x)", pHandle.GetAddr(), puiNextSample.GetAddr());
cellAtrac->Error("cellAtracGetNextSample(pHandle=0x%x, puiNextSample_addr=0x%x)", pHandle.GetAddr(), puiNextSample.GetAddr());
puiNextSample = 0;
return CELL_OK;
@ -138,7 +137,7 @@ int cellAtracGetNextSample(mem_ptr_t<CellAtracHandle> pHandle, mem32_t puiNextSa
int cellAtracGetSoundInfo(mem_ptr_t<CellAtracHandle> pHandle, mem32_t piEndSample, mem32_t piLoopStartSample, mem32_t piLoopEndSample)
{
cellAtrac.Error("cellAtracGetSoundInfo(pHandle=0x%x, piEndSample_addr=0x%x, piLoopStartSample_addr=0x%x, piLoopEndSample_addr=0x%x)",
cellAtrac->Error("cellAtracGetSoundInfo(pHandle=0x%x, piEndSample_addr=0x%x, piLoopStartSample_addr=0x%x, piLoopEndSample_addr=0x%x)",
pHandle.GetAddr(), piEndSample.GetAddr(), piLoopStartSample.GetAddr(), piLoopEndSample.GetAddr());
piEndSample = 0;
@ -149,7 +148,7 @@ int cellAtracGetSoundInfo(mem_ptr_t<CellAtracHandle> pHandle, mem32_t piEndSampl
int cellAtracGetNextDecodePosition(mem_ptr_t<CellAtracHandle> pHandle, mem32_t puiSamplePosition)
{
cellAtrac.Error("cellAtracGetNextDecodePosition(pHandle=0x%x, puiSamplePosition_addr=0x%x)",
cellAtrac->Error("cellAtracGetNextDecodePosition(pHandle=0x%x, puiSamplePosition_addr=0x%x)",
pHandle.GetAddr(), puiSamplePosition.GetAddr());
puiSamplePosition = 0;
@ -158,7 +157,7 @@ int cellAtracGetNextDecodePosition(mem_ptr_t<CellAtracHandle> pHandle, mem32_t p
int cellAtracGetBitrate(mem_ptr_t<CellAtracHandle> pHandle, mem32_t puiBitrate)
{
cellAtrac.Error("cellAtracGetBitrate(pHandle=0x%x, puiBitrate_addr=0x%x)",
cellAtrac->Error("cellAtracGetBitrate(pHandle=0x%x, puiBitrate_addr=0x%x)",
pHandle.GetAddr(), puiBitrate.GetAddr());
puiBitrate = 128;
@ -167,7 +166,7 @@ int cellAtracGetBitrate(mem_ptr_t<CellAtracHandle> pHandle, mem32_t puiBitrate)
int cellAtracGetLoopInfo(mem_ptr_t<CellAtracHandle> pHandle, mem32_t piLoopNum, mem32_t puiLoopStatus)
{
cellAtrac.Error("cellAtracGetLoopInfo(pHandle=0x%x, piLoopNum_addr=0x%x, puiLoopStatus_addr=0x%x)",
cellAtrac->Error("cellAtracGetLoopInfo(pHandle=0x%x, piLoopNum_addr=0x%x, puiLoopStatus_addr=0x%x)",
pHandle.GetAddr(), piLoopNum.GetAddr(), puiLoopStatus.GetAddr());
piLoopNum = 0;
@ -177,13 +176,13 @@ int cellAtracGetLoopInfo(mem_ptr_t<CellAtracHandle> pHandle, mem32_t piLoopNum,
int cellAtracSetLoopNum(mem_ptr_t<CellAtracHandle> pHandle, int iLoopNum)
{
cellAtrac.Error("cellAtracSetLoopNum(pHandle=0x%x, iLoopNum=0x%x)", pHandle.GetAddr(), iLoopNum);
cellAtrac->Error("cellAtracSetLoopNum(pHandle=0x%x, iLoopNum=0x%x)", pHandle.GetAddr(), iLoopNum);
return CELL_OK;
}
int cellAtracGetBufferInfoForResetting(mem_ptr_t<CellAtracHandle> pHandle, u32 uiSample, mem_ptr_t<CellAtracBufferInfo> pBufferInfo)
{
cellAtrac.Error("cellAtracGetBufferInfoForResetting(pHandle=0x%x, uiSample=0x%x, pBufferInfo_addr=0x%x)",
cellAtrac->Error("cellAtracGetBufferInfoForResetting(pHandle=0x%x, uiSample=0x%x, pBufferInfo_addr=0x%x)",
pHandle.GetAddr(), uiSample, pBufferInfo.GetAddr());
pBufferInfo->pucWriteAddr = pHandle->data.pucWorkMem_addr;
@ -195,14 +194,14 @@ int cellAtracGetBufferInfoForResetting(mem_ptr_t<CellAtracHandle> pHandle, u32 u
int cellAtracResetPlayPosition(mem_ptr_t<CellAtracHandle> pHandle, u32 uiSample, u32 uiWriteByte)
{
cellAtrac.Error("cellAtracResetPlayPosition(pHandle=0x%x, uiSample=0x%x, uiWriteByte=0x%x)",
cellAtrac->Error("cellAtracResetPlayPosition(pHandle=0x%x, uiSample=0x%x, uiWriteByte=0x%x)",
pHandle.GetAddr(), uiSample, uiWriteByte);
return CELL_OK;
}
int cellAtracGetInternalErrorInfo(mem_ptr_t<CellAtracHandle> pHandle, mem32_t piResult)
{
cellAtrac.Error("cellAtracGetInternalErrorInfo(pHandle=0x%x, piResult_addr=0x%x)",
cellAtrac->Error("cellAtracGetInternalErrorInfo(pHandle=0x%x, piResult_addr=0x%x)",
pHandle.GetAddr(), piResult.GetAddr());
piResult = 0;
@ -211,34 +210,34 @@ int cellAtracGetInternalErrorInfo(mem_ptr_t<CellAtracHandle> pHandle, mem32_t pi
void cellAtrac_init()
{
cellAtrac.AddFunc(0x66afc68e, cellAtracSetDataAndGetMemSize);
cellAtrac->AddFunc(0x66afc68e, cellAtracSetDataAndGetMemSize);
cellAtrac.AddFunc(0xfa293e88, cellAtracCreateDecoder);
cellAtrac.AddFunc(0x2642d4cc, cellAtracCreateDecoderExt);
cellAtrac.AddFunc(0x761cb9be, cellAtracDeleteDecoder);
cellAtrac->AddFunc(0xfa293e88, cellAtracCreateDecoder);
cellAtrac->AddFunc(0x2642d4cc, cellAtracCreateDecoderExt);
cellAtrac->AddFunc(0x761cb9be, cellAtracDeleteDecoder);
cellAtrac.AddFunc(0x8eb0e65f, cellAtracDecode);
cellAtrac->AddFunc(0x8eb0e65f, cellAtracDecode);
cellAtrac.AddFunc(0x2bfff084, cellAtracGetStreamDataInfo);
cellAtrac.AddFunc(0x46cfc013, cellAtracAddStreamData);
cellAtrac.AddFunc(0xdfab73aa, cellAtracGetRemainFrame);
cellAtrac.AddFunc(0xc9a95fcb, cellAtracGetVacantSize);
cellAtrac.AddFunc(0x99efe171, cellAtracIsSecondBufferNeeded);
cellAtrac.AddFunc(0xbe07f05e, cellAtracGetSecondBufferInfo);
cellAtrac.AddFunc(0x06ddb53e, cellAtracSetSecondBuffer);
cellAtrac->AddFunc(0x2bfff084, cellAtracGetStreamDataInfo);
cellAtrac->AddFunc(0x46cfc013, cellAtracAddStreamData);
cellAtrac->AddFunc(0xdfab73aa, cellAtracGetRemainFrame);
cellAtrac->AddFunc(0xc9a95fcb, cellAtracGetVacantSize);
cellAtrac->AddFunc(0x99efe171, cellAtracIsSecondBufferNeeded);
cellAtrac->AddFunc(0xbe07f05e, cellAtracGetSecondBufferInfo);
cellAtrac->AddFunc(0x06ddb53e, cellAtracSetSecondBuffer);
cellAtrac.AddFunc(0x0f9667b6, cellAtracGetChannel);
cellAtrac.AddFunc(0x5f62d546, cellAtracGetMaxSample);
cellAtrac.AddFunc(0x4797d1ff, cellAtracGetNextSample);
cellAtrac.AddFunc(0xcf01d5d4, cellAtracGetSoundInfo);
cellAtrac.AddFunc(0x7b22e672, cellAtracGetNextDecodePosition);
cellAtrac.AddFunc(0x006016da, cellAtracGetBitrate);
cellAtrac->AddFunc(0x0f9667b6, cellAtracGetChannel);
cellAtrac->AddFunc(0x5f62d546, cellAtracGetMaxSample);
cellAtrac->AddFunc(0x4797d1ff, cellAtracGetNextSample);
cellAtrac->AddFunc(0xcf01d5d4, cellAtracGetSoundInfo);
cellAtrac->AddFunc(0x7b22e672, cellAtracGetNextDecodePosition);
cellAtrac->AddFunc(0x006016da, cellAtracGetBitrate);
cellAtrac.AddFunc(0xab6b6dbf, cellAtracGetLoopInfo);
cellAtrac.AddFunc(0x78ba5c41, cellAtracSetLoopNum);
cellAtrac->AddFunc(0xab6b6dbf, cellAtracGetLoopInfo);
cellAtrac->AddFunc(0x78ba5c41, cellAtracSetLoopNum);
cellAtrac.AddFunc(0x99fb73d1, cellAtracGetBufferInfoForResetting);
cellAtrac.AddFunc(0x7772eb2b, cellAtracResetPlayPosition);
cellAtrac->AddFunc(0x99fb73d1, cellAtracGetBufferInfoForResetting);
cellAtrac->AddFunc(0x7772eb2b, cellAtracResetPlayPosition);
cellAtrac.AddFunc(0xb5c11938, cellAtracGetInternalErrorInfo);
cellAtrac->AddFunc(0xb5c11938, cellAtracGetInternalErrorInfo);
}

91
rpcs3/Emu/SysCalls/Modules/cellAudio.cpp
View File

@ -11,8 +11,9 @@
#include "Emu/Audio/AudioManager.h"
#include "Emu/Audio/AudioDumper.h"
void cellAudio_init();
Module cellAudio(0x0011, cellAudio_init);
//void cellAudio_init();
//Module cellAudio(0x0011, cellAudio_init);
extern Module *cellAudio = nullptr;
static SMutexGeneral audioMutex;
@ -24,7 +25,7 @@ static const bool g_is_u16 = Ini.AudioConvertToU16.GetValue();
int cellAudioInit()
{
cellAudio.Warning("cellAudioInit()");
cellAudio->Warning("cellAudioInit()");
if (m_config.m_is_audio_initialized)
{
@ -490,7 +491,7 @@ abort:
int cellAudioQuit()
{
cellAudio.Warning("cellAudioQuit()");
cellAudio->Warning("cellAudioQuit()");
if (!m_config.m_is_audio_initialized)
{
@ -517,7 +518,7 @@ int cellAudioQuit()
int cellAudioPortOpen(mem_ptr_t<CellAudioPortParam> audioParam, mem32_t portNum)
{
cellAudio.Warning("cellAudioPortOpen(audioParam_addr=0x%x, portNum_addr=0x%x)", audioParam.GetAddr(), portNum.GetAddr());
cellAudio->Warning("cellAudioPortOpen(audioParam_addr=0x%x, portNum_addr=0x%x)", audioParam.GetAddr(), portNum.GetAddr());
if(!audioParam.IsGood() || !portNum.IsGood())
{
@ -553,7 +554,7 @@ int cellAudioPortOpen(mem_ptr_t<CellAudioPortParam> audioParam, mem32_t portNum)
}
portNum = i;
cellAudio.Warning("*** audio port opened(nChannel=%d, nBlock=%d, attr=0x%llx, level=%f): port = %d",
cellAudio->Warning("*** audio port opened(nChannel=%d, nBlock=%d, attr=0x%llx, level=%f): port = %d",
port.channel, port.block, port.attr, port.level, i);
port.m_is_audio_port_opened = true;
@ -570,7 +571,7 @@ int cellAudioPortOpen(mem_ptr_t<CellAudioPortParam> audioParam, mem32_t portNum)
int cellAudioGetPortConfig(u32 portNum, mem_ptr_t<CellAudioPortConfig> portConfig)
{
cellAudio.Warning("cellAudioGetPortConfig(portNum=0x%x, portConfig_addr=0x%x)", portNum, portConfig.GetAddr());
cellAudio->Warning("cellAudioGetPortConfig(portNum=0x%x, portConfig_addr=0x%x)", portNum, portConfig.GetAddr());
if (!portConfig.IsGood() || portNum >= m_config.AUDIO_PORT_COUNT)
{
@ -598,7 +599,7 @@ int cellAudioGetPortConfig(u32 portNum, mem_ptr_t<CellAudioPortConfig> portConfi
portConfig->portAddr = m_config.m_buffer + (128 * 1024 * portNum); // 0x20020000
portConfig->readIndexAddr = m_config.m_indexes + (sizeof(u64) * portNum); // 0x20010010 on ps3
cellAudio.Log("*** port config: nChannel=%d, nBlock=%d, portSize=0x%x, portAddr=0x%x, readIndexAddr=0x%x",
cellAudio->Log("*** port config: nChannel=%d, nBlock=%d, portSize=0x%x, portAddr=0x%x, readIndexAddr=0x%x",
(u32)portConfig->nChannel, (u32)portConfig->nBlock, (u32)portConfig->portSize, (u32)portConfig->portAddr, (u32)portConfig->readIndexAddr);
// portAddr - readIndexAddr == 0xFFF0 on ps3
@ -607,7 +608,7 @@ int cellAudioGetPortConfig(u32 portNum, mem_ptr_t<CellAudioPortConfig> portConfi
int cellAudioPortStart(u32 portNum)
{
cellAudio.Warning("cellAudioPortStart(portNum=0x%x)", portNum);
cellAudio->Warning("cellAudioPortStart(portNum=0x%x)", portNum);
if (portNum >= m_config.AUDIO_PORT_COUNT)
{
@ -631,7 +632,7 @@ int cellAudioPortStart(u32 portNum)
int cellAudioPortClose(u32 portNum)
{
cellAudio.Warning("cellAudioPortClose(portNum=0x%x)", portNum);
cellAudio->Warning("cellAudioPortClose(portNum=0x%x)", portNum);
if (portNum >= m_config.AUDIO_PORT_COUNT)
{
@ -651,7 +652,7 @@ int cellAudioPortClose(u32 portNum)
int cellAudioPortStop(u32 portNum)
{
cellAudio.Warning("cellAudioPortStop(portNum=0x%x)",portNum);
cellAudio->Warning("cellAudioPortStop(portNum=0x%x)",portNum);
if (portNum >= m_config.AUDIO_PORT_COUNT)
{
@ -674,7 +675,7 @@ int cellAudioPortStop(u32 portNum)
int cellAudioGetPortTimestamp(u32 portNum, u64 tag, mem64_t stamp)
{
cellAudio.Log("cellAudioGetPortTimestamp(portNum=0x%x, tag=0x%llx, stamp_addr=0x%x)", portNum, tag, stamp.GetAddr());
cellAudio->Log("cellAudioGetPortTimestamp(portNum=0x%x, tag=0x%llx, stamp_addr=0x%x)", portNum, tag, stamp.GetAddr());
if (portNum >= m_config.AUDIO_PORT_COUNT)
{
@ -702,7 +703,7 @@ int cellAudioGetPortTimestamp(u32 portNum, u64 tag, mem64_t stamp)
int cellAudioGetPortBlockTag(u32 portNum, u64 blockNo, mem64_t tag)
{
cellAudio.Log("cellAudioGetPortBlockTag(portNum=0x%x, blockNo=0x%llx, tag_addr=0x%x)", portNum, blockNo, tag.GetAddr());
cellAudio->Log("cellAudioGetPortBlockTag(portNum=0x%x, blockNo=0x%llx, tag_addr=0x%x)", portNum, blockNo, tag.GetAddr());
if (portNum >= m_config.AUDIO_PORT_COUNT)
{
@ -723,7 +724,7 @@ int cellAudioGetPortBlockTag(u32 portNum, u64 blockNo, mem64_t tag)
if (blockNo >= port.block)
{
cellAudio.Error("cellAudioGetPortBlockTag: wrong blockNo(%lld)", blockNo);
cellAudio->Error("cellAudioGetPortBlockTag: wrong blockNo(%lld)", blockNo);
return CELL_AUDIO_ERROR_PARAM;
}
@ -746,14 +747,14 @@ int cellAudioGetPortBlockTag(u32 portNum, u64 blockNo, mem64_t tag)
int cellAudioSetPortLevel(u32 portNum, float level)
{
cellAudio.Error("cellAudioSetPortLevel(portNum=0x%x, level=%f)", portNum, level);
cellAudio->Error("cellAudioSetPortLevel(portNum=0x%x, level=%f)", portNum, level);
return CELL_OK;
}
// Utility Functions
int cellAudioCreateNotifyEventQueue(mem32_t id, mem64_t key)
{
cellAudio.Warning("cellAudioCreateNotifyEventQueue(id_addr=0x%x, key_addr=0x%x)", id.GetAddr(), key.GetAddr());
cellAudio->Warning("cellAudioCreateNotifyEventQueue(id_addr=0x%x, key_addr=0x%x)", id.GetAddr(), key.GetAddr());
SMutexGeneralLocker lock(audioMutex);
@ -773,7 +774,7 @@ int cellAudioCreateNotifyEventQueue(mem32_t id, mem64_t key)
return CELL_AUDIO_ERROR_EVENT_QUEUE;
}
id = cellAudio.GetNewId(eq);
id = cellAudio->GetNewId(eq);
key = event_key;
return CELL_OK;
@ -781,13 +782,13 @@ int cellAudioCreateNotifyEventQueue(mem32_t id, mem64_t key)
int cellAudioCreateNotifyEventQueueEx(mem32_t id, mem64_t key, u32 iFlags)
{
cellAudio.Error("cellAudioCreateNotifyEventQueueEx(id_addr=0x%x, key_addr=0x%x, iFlags=0x%x)", id.GetAddr(), key.GetAddr(), iFlags);
cellAudio->Error("cellAudioCreateNotifyEventQueueEx(id_addr=0x%x, key_addr=0x%x, iFlags=0x%x)", id.GetAddr(), key.GetAddr(), iFlags);
return CELL_OK;
}
int cellAudioSetNotifyEventQueue(u64 key)
{
cellAudio.Warning("cellAudioSetNotifyEventQueue(key=0x%llx)", key);
cellAudio->Warning("cellAudioSetNotifyEventQueue(key=0x%llx)", key);
SMutexGeneralLocker lock(audioMutex);
@ -813,13 +814,13 @@ int cellAudioSetNotifyEventQueue(u64 key)
int cellAudioSetNotifyEventQueueEx(u64 key, u32 iFlags)
{
cellAudio.Error("cellAudioSetNotifyEventQueueEx(key=0x%llx, iFlags=0x%x)", key, iFlags);
cellAudio->Error("cellAudioSetNotifyEventQueueEx(key=0x%llx, iFlags=0x%x)", key, iFlags);
return CELL_OK;
}
int cellAudioRemoveNotifyEventQueue(u64 key)
{
cellAudio.Warning("cellAudioRemoveNotifyEventQueue(key=0x%llx)", key);
cellAudio->Warning("cellAudioRemoveNotifyEventQueue(key=0x%llx)", key);
SMutexGeneralLocker lock(audioMutex);
@ -853,68 +854,68 @@ int cellAudioRemoveNotifyEventQueue(u64 key)
int cellAudioRemoveNotifyEventQueueEx(u64 key, u32 iFlags)
{
cellAudio.Error("cellAudioRemoveNotifyEventQueueEx(key=0x%llx, iFlags=0x%x)", key, iFlags);
cellAudio->Error("cellAudioRemoveNotifyEventQueueEx(key=0x%llx, iFlags=0x%x)", key, iFlags);
return CELL_OK;
}
int cellAudioAddData(u32 portNum, mem32_t src, u32 samples, float volume)
{
cellAudio.Error("cellAudioAddData(portNum=0x%x, src_addr=0x%x, samples=%d, volume=%f)", portNum, src.GetAddr(), samples, volume);
cellAudio->Error("cellAudioAddData(portNum=0x%x, src_addr=0x%x, samples=%d, volume=%f)", portNum, src.GetAddr(), samples, volume);
return CELL_OK;
}
int cellAudioAdd2chData(u32 portNum, mem32_t src, u32 samples, float volume)
{
cellAudio.Error("cellAudioAdd2chData(portNum=0x%x, src_addr=0x%x, samples=%d, volume=%f)", portNum, src.GetAddr(), samples, volume);
cellAudio->Error("cellAudioAdd2chData(portNum=0x%x, src_addr=0x%x, samples=%d, volume=%f)", portNum, src.GetAddr(), samples, volume);
return CELL_OK;
}
int cellAudioAdd6chData(u32 portNum, mem32_t src, float volume)
{
cellAudio.Error("cellAudioAdd6chData(portNum=0x%x, src_addr=0x%x, volume=%f)", portNum, src.GetAddr(), volume);
cellAudio->Error("cellAudioAdd6chData(portNum=0x%x, src_addr=0x%x, volume=%f)", portNum, src.GetAddr(), volume);
return CELL_OK;
}
int cellAudioMiscSetAccessoryVolume(u32 devNum, float volume)
{
cellAudio.Error("cellAudioMiscSetAccessoryVolume(devNum=0x%x, volume=%f)", devNum, volume);
cellAudio->Error("cellAudioMiscSetAccessoryVolume(devNum=0x%x, volume=%f)", devNum, volume);
return CELL_OK;
}
int cellAudioSendAck(u64 data3)
{
cellAudio.Error("cellAudioSendAck(data3=0x%llx)", data3);
cellAudio->Error("cellAudioSendAck(data3=0x%llx)", data3);
return CELL_OK;
}
int cellAudioSetPersonalDevice(int iPersonalStream, int iDevice)
{
cellAudio.Error("cellAudioSetPersonalDevice(iPersonalStream=0x%x, iDevice=0x%x)", iPersonalStream, iDevice);
cellAudio->Error("cellAudioSetPersonalDevice(iPersonalStream=0x%x, iDevice=0x%x)", iPersonalStream, iDevice);
return CELL_OK;
}
int cellAudioUnsetPersonalDevice(int iPersonalStream)
{
cellAudio.Error("cellAudioUnsetPersonalDevice(iPersonalStream=0x%x)", iPersonalStream);
cellAudio->Error("cellAudioUnsetPersonalDevice(iPersonalStream=0x%x)", iPersonalStream);
return CELL_OK;
}
void cellAudio_init()
{
cellAudio.AddFunc(0x0b168f92, cellAudioInit);
cellAudio.AddFunc(0x4129fe2d, cellAudioPortClose);
cellAudio.AddFunc(0x5b1e2c73, cellAudioPortStop);
cellAudio.AddFunc(0x74a66af0, cellAudioGetPortConfig);
cellAudio.AddFunc(0x89be28f2, cellAudioPortStart);
cellAudio.AddFunc(0xca5ac370, cellAudioQuit);
cellAudio.AddFunc(0xcd7bc431, cellAudioPortOpen);
cellAudio.AddFunc(0x56dfe179, cellAudioSetPortLevel);
cellAudio.AddFunc(0x04af134e, cellAudioCreateNotifyEventQueue);
cellAudio.AddFunc(0x31211f6b, cellAudioMiscSetAccessoryVolume);
cellAudio.AddFunc(0x377e0cd9, cellAudioSetNotifyEventQueue);
cellAudio.AddFunc(0x4109d08c, cellAudioGetPortTimestamp);
cellAudio.AddFunc(0x9e4b1db8, cellAudioAdd2chData);
cellAudio.AddFunc(0xdab029aa, cellAudioAddData);
cellAudio.AddFunc(0xe4046afe, cellAudioGetPortBlockTag);
cellAudio.AddFunc(0xff3626fd, cellAudioRemoveNotifyEventQueue);
cellAudio->AddFunc(0x0b168f92, cellAudioInit);
cellAudio->AddFunc(0x4129fe2d, cellAudioPortClose);
cellAudio->AddFunc(0x5b1e2c73, cellAudioPortStop);
cellAudio->AddFunc(0x74a66af0, cellAudioGetPortConfig);
cellAudio->AddFunc(0x89be28f2, cellAudioPortStart);
cellAudio->AddFunc(0xca5ac370, cellAudioQuit);
cellAudio->AddFunc(0xcd7bc431, cellAudioPortOpen);
cellAudio->AddFunc(0x56dfe179, cellAudioSetPortLevel);
cellAudio->AddFunc(0x04af134e, cellAudioCreateNotifyEventQueue);
cellAudio->AddFunc(0x31211f6b, cellAudioMiscSetAccessoryVolume);
cellAudio->AddFunc(0x377e0cd9, cellAudioSetNotifyEventQueue);
cellAudio->AddFunc(0x4109d08c, cellAudioGetPortTimestamp);
cellAudio->AddFunc(0x9e4b1db8, cellAudioAdd2chData);
cellAudio->AddFunc(0xdab029aa, cellAudioAddData);
cellAudio->AddFunc(0xe4046afe, cellAudioGetPortBlockTag);
cellAudio->AddFunc(0xff3626fd, cellAudioRemoveNotifyEventQueue);
}

2
rpcs3/Emu/SysCalls/Modules/cellCelpEnc.cpp
View File

@ -83,4 +83,4 @@ void cellCelpEnc_init()
cellCelpEnc.AddFunc(0x9b244272, cellCelpEncWaitForOutput);
cellCelpEnc.AddFunc(0x3773692f, cellCelpEncGetAu);
}
#endif
#endif

99
rpcs3/Emu/SysCalls/Modules/cellDmux.cpp
View File

@ -10,8 +10,9 @@
#include "cellPamf.h"
#include "cellDmux.h"
void cellDmux_init();
Module cellDmux(0x0007, cellDmux_init);
//void cellDmux_init();
//Module cellDmux(0x0007, cellDmux_init);
Module *cellDmux = nullptr;
void dmuxQueryAttr(u32 info_addr /* may be 0 */, mem_ptr_t<CellDmuxAttr> attr)
{
@ -28,7 +29,7 @@ void dmuxQueryEsAttr(u32 info_addr /* may be 0 */, const mem_ptr_t<CellCodecEsFi
else
attr->memSize = 0x8000; // 0x73d9 from ps3
cellDmux.Warning("*** filter(0x%x, 0x%x, 0x%x, 0x%x)", (u32)esFilterId->filterIdMajor, (u32)esFilterId->filterIdMinor,
cellDmux->Warning("*** filter(0x%x, 0x%x, 0x%x, 0x%x)", (u32)esFilterId->filterIdMajor, (u32)esFilterId->filterIdMinor,
(u32)esFilterId->supplementalInfo1, (u32)esFilterId->supplementalInfo2);
}
@ -38,7 +39,7 @@ u32 dmuxOpen(Demuxer* data)
dmux.dmuxCb = &Emu.GetCPU().AddThread(CPU_THREAD_PPU);
u32 dmux_id = cellDmux.GetNewId(data);
u32 dmux_id = cellDmux->GetNewId(data);
dmux.id = dmux_id;
@ -463,7 +464,7 @@ u32 dmuxOpen(Demuxer* data)
int cellDmuxQueryAttr(const mem_ptr_t<CellDmuxType> demuxerType, mem_ptr_t<CellDmuxAttr> demuxerAttr)
{
cellDmux.Warning("cellDmuxQueryAttr(demuxerType_addr=0x%x, demuxerAttr_addr=0x%x)", demuxerType.GetAddr(), demuxerAttr.GetAddr());
cellDmux->Warning("cellDmuxQueryAttr(demuxerType_addr=0x%x, demuxerAttr_addr=0x%x)", demuxerType.GetAddr(), demuxerAttr.GetAddr());
if (!demuxerType.IsGood() || !demuxerAttr.IsGood())
{
@ -481,7 +482,7 @@ int cellDmuxQueryAttr(const mem_ptr_t<CellDmuxType> demuxerType, mem_ptr_t<CellD
int cellDmuxQueryAttr2(const mem_ptr_t<CellDmuxType2> demuxerType2, mem_ptr_t<CellDmuxAttr> demuxerAttr)
{
cellDmux.Warning("cellDmuxQueryAttr2(demuxerType2_addr=0x%x, demuxerAttr_addr=0x%x)", demuxerType2.GetAddr(), demuxerAttr.GetAddr());
cellDmux->Warning("cellDmuxQueryAttr2(demuxerType2_addr=0x%x, demuxerAttr_addr=0x%x)", demuxerType2.GetAddr(), demuxerAttr.GetAddr());
if (!demuxerType2.IsGood() || !demuxerAttr.IsGood())
{
@ -500,7 +501,7 @@ int cellDmuxQueryAttr2(const mem_ptr_t<CellDmuxType2> demuxerType2, mem_ptr_t<Ce
int cellDmuxOpen(const mem_ptr_t<CellDmuxType> demuxerType, const mem_ptr_t<CellDmuxResource> demuxerResource,
const mem_ptr_t<CellDmuxCb> demuxerCb, mem32_t demuxerHandle)
{
cellDmux.Warning("cellDmuxOpen(demuxerType_addr=0x%x, demuxerResource_addr=0x%x, demuxerCb_addr=0x%x, demuxerHandle_addr=0x%x)",
cellDmux->Warning("cellDmuxOpen(demuxerType_addr=0x%x, demuxerResource_addr=0x%x, demuxerCb_addr=0x%x, demuxerHandle_addr=0x%x)",
demuxerType.GetAddr(), demuxerResource.GetAddr(), demuxerCb.GetAddr(), demuxerHandle.GetAddr());
if (!demuxerType.IsGood() || !demuxerResource.IsGood() || !demuxerCb.IsGood() || !demuxerHandle.IsGood())
@ -528,7 +529,7 @@ int cellDmuxOpen(const mem_ptr_t<CellDmuxType> demuxerType, const mem_ptr_t<Cell
int cellDmuxOpenEx(const mem_ptr_t<CellDmuxType> demuxerType, const mem_ptr_t<CellDmuxResourceEx> demuxerResourceEx,
const mem_ptr_t<CellDmuxCb> demuxerCb, mem32_t demuxerHandle)
{
cellDmux.Warning("cellDmuxOpenEx(demuxerType_addr=0x%x, demuxerResourceEx_addr=0x%x, demuxerCb_addr=0x%x, demuxerHandle_addr=0x%x)",
cellDmux->Warning("cellDmuxOpenEx(demuxerType_addr=0x%x, demuxerResourceEx_addr=0x%x, demuxerCb_addr=0x%x, demuxerHandle_addr=0x%x)",
demuxerType.GetAddr(), demuxerResourceEx.GetAddr(), demuxerCb.GetAddr(), demuxerHandle.GetAddr());
if (!demuxerType.IsGood() || !demuxerResourceEx.IsGood() || !demuxerCb.IsGood() || !demuxerHandle.IsGood())
@ -556,7 +557,7 @@ int cellDmuxOpenEx(const mem_ptr_t<CellDmuxType> demuxerType, const mem_ptr_t<Ce
int cellDmuxOpen2(const mem_ptr_t<CellDmuxType2> demuxerType2, const mem_ptr_t<CellDmuxResource2> demuxerResource2,
const mem_ptr_t<CellDmuxCb> demuxerCb, mem32_t demuxerHandle)
{
cellDmux.Warning("cellDmuxOpen2(demuxerType2_addr=0x%x, demuxerResource2_addr=0x%x, demuxerCb_addr=0x%x, demuxerHandle_addr=0x%x)",
cellDmux->Warning("cellDmuxOpen2(demuxerType2_addr=0x%x, demuxerResource2_addr=0x%x, demuxerCb_addr=0x%x, demuxerHandle_addr=0x%x)",
demuxerType2.GetAddr(), demuxerResource2.GetAddr(), demuxerCb.GetAddr(), demuxerHandle.GetAddr());
if (!demuxerType2.IsGood() || !demuxerResource2.IsGood() || !demuxerCb.IsGood() || !demuxerHandle.IsGood())
@ -583,7 +584,7 @@ int cellDmuxOpen2(const mem_ptr_t<CellDmuxType2> demuxerType2, const mem_ptr_t<C
int cellDmuxClose(u32 demuxerHandle)
{
cellDmux.Warning("cellDmuxClose(demuxerHandle=%d)", demuxerHandle);
cellDmux->Warning("cellDmuxClose(demuxerHandle=%d)", demuxerHandle);
Demuxer* dmux;
if (!Emu.GetIdManager().GetIDData(demuxerHandle, dmux))
@ -611,7 +612,7 @@ int cellDmuxClose(u32 demuxerHandle)
int cellDmuxSetStream(u32 demuxerHandle, const u32 streamAddress, u32 streamSize, bool discontinuity, u64 userData)
{
cellDmux.Log("cellDmuxSetStream(demuxerHandle=%d, streamAddress=0x%x, streamSize=%d, discontinuity=%d, userData=0x%llx",
cellDmux->Log("cellDmuxSetStream(demuxerHandle=%d, streamAddress=0x%x, streamSize=%d, discontinuity=%d, userData=0x%llx",
demuxerHandle, streamAddress, streamSize, discontinuity, userData);
Demuxer* dmux;
@ -661,7 +662,7 @@ int cellDmuxSetStream(u32 demuxerHandle, const u32 streamAddress, u32 streamSize
int cellDmuxResetStream(u32 demuxerHandle)
{
cellDmux.Warning("cellDmuxResetStream(demuxerHandle=%d)", demuxerHandle);
cellDmux->Warning("cellDmuxResetStream(demuxerHandle=%d)", demuxerHandle);
Demuxer* dmux;
if (!Emu.GetIdManager().GetIDData(demuxerHandle, dmux))
@ -676,7 +677,7 @@ int cellDmuxResetStream(u32 demuxerHandle)
int cellDmuxResetStreamAndWaitDone(u32 demuxerHandle)
{
cellDmux.Warning("cellDmuxResetStreamAndWaitDone(demuxerHandle=%d)", demuxerHandle);
cellDmux->Warning("cellDmuxResetStreamAndWaitDone(demuxerHandle=%d)", demuxerHandle);
Demuxer* dmux;
if (!Emu.GetIdManager().GetIDData(demuxerHandle, dmux))
@ -703,7 +704,7 @@ int cellDmuxResetStreamAndWaitDone(u32 demuxerHandle)
int cellDmuxQueryEsAttr(const mem_ptr_t<CellDmuxType> demuxerType, const mem_ptr_t<CellCodecEsFilterId> esFilterId,
const u32 esSpecificInfo_addr, mem_ptr_t<CellDmuxEsAttr> esAttr)
{
cellDmux.Warning("cellDmuxQueryEsAttr(demuxerType_addr=0x%x, esFilterId_addr=0x%x, esSpecificInfo_addr=0x%x, esAttr_addr=0x%x)",
cellDmux->Warning("cellDmuxQueryEsAttr(demuxerType_addr=0x%x, esFilterId_addr=0x%x, esSpecificInfo_addr=0x%x, esAttr_addr=0x%x)",
demuxerType.GetAddr(), esFilterId.GetAddr(), esSpecificInfo_addr, esAttr.GetAddr());
if (!demuxerType.IsGood() || !esFilterId.IsGood() || !esAttr.IsGood())
@ -713,7 +714,7 @@ int cellDmuxQueryEsAttr(const mem_ptr_t<CellDmuxType> demuxerType, const mem_ptr
if (!Memory.IsGoodAddr(esSpecificInfo_addr, 12))
{
cellDmux.Error("cellDmuxQueryEsAttr: invalid specific info addr (0x%x)", esSpecificInfo_addr);
cellDmux->Error("cellDmuxQueryEsAttr: invalid specific info addr (0x%x)", esSpecificInfo_addr);
return CELL_DMUX_ERROR_FATAL;
}
@ -731,7 +732,7 @@ int cellDmuxQueryEsAttr(const mem_ptr_t<CellDmuxType> demuxerType, const mem_ptr
int cellDmuxQueryEsAttr2(const mem_ptr_t<CellDmuxType2> demuxerType2, const mem_ptr_t<CellCodecEsFilterId> esFilterId,
const u32 esSpecificInfo_addr, mem_ptr_t<CellDmuxEsAttr> esAttr)
{
cellDmux.Warning("cellDmuxQueryEsAttr2(demuxerType2_addr=0x%x, esFilterId_addr=0x%x, esSpecificInfo_addr=0x%x, esAttr_addr=0x%x)",
cellDmux->Warning("cellDmuxQueryEsAttr2(demuxerType2_addr=0x%x, esFilterId_addr=0x%x, esSpecificInfo_addr=0x%x, esAttr_addr=0x%x)",
demuxerType2.GetAddr(), esFilterId.GetAddr(), esSpecificInfo_addr, esAttr.GetAddr());
if (!demuxerType2.IsGood() || !esFilterId.IsGood() || !esAttr.IsGood())
@ -741,7 +742,7 @@ int cellDmuxQueryEsAttr2(const mem_ptr_t<CellDmuxType2> demuxerType2, const mem_
if (!Memory.IsGoodAddr(esSpecificInfo_addr, 12))
{
cellDmux.Error("cellDmuxQueryEsAttr2: invalid specific info addr (0x%x)", esSpecificInfo_addr);
cellDmux->Error("cellDmuxQueryEsAttr2: invalid specific info addr (0x%x)", esSpecificInfo_addr);
return CELL_DMUX_ERROR_FATAL;
}
@ -760,7 +761,7 @@ int cellDmuxEnableEs(u32 demuxerHandle, const mem_ptr_t<CellCodecEsFilterId> esF
const mem_ptr_t<CellDmuxEsResource> esResourceInfo, const mem_ptr_t<CellDmuxEsCb> esCb,
const u32 esSpecificInfo_addr, mem32_t esHandle)
{
cellDmux.Warning("cellDmuxEnableEs(demuxerHandle=%d, esFilterId_addr=0x%x, esResourceInfo_addr=0x%x, esCb_addr=0x%x, "
cellDmux->Warning("cellDmuxEnableEs(demuxerHandle=%d, esFilterId_addr=0x%x, esResourceInfo_addr=0x%x, esCb_addr=0x%x, "
"esSpecificInfo_addr=0x%x, esHandle_addr=0x%x)", demuxerHandle, esFilterId.GetAddr(), esResourceInfo.GetAddr(),
esCb.GetAddr(), esSpecificInfo_addr, esHandle.GetAddr());
@ -771,7 +772,7 @@ int cellDmuxEnableEs(u32 demuxerHandle, const mem_ptr_t<CellCodecEsFilterId> esF
if (!Memory.IsGoodAddr(esSpecificInfo_addr, 12))
{
cellDmux.Error("cellDmuxEnableEs: invalid specific info addr (0x%x)", esSpecificInfo_addr);
cellDmux->Error("cellDmuxEnableEs: invalid specific info addr (0x%x)", esSpecificInfo_addr);
return CELL_DMUX_ERROR_FATAL;
}
@ -792,11 +793,11 @@ int cellDmuxEnableEs(u32 demuxerHandle, const mem_ptr_t<CellCodecEsFilterId> esF
esFilterId->filterIdMajor, esFilterId->filterIdMinor, esFilterId->supplementalInfo1, esFilterId->supplementalInfo2,
esCb->cbEsMsgFunc, esCb->cbArg_addr, esSpecificInfo_addr);
u32 id = cellDmux.GetNewId(es);
u32 id = cellDmux->GetNewId(es);
es->id = id;
esHandle = id;
cellDmux.Warning("*** New ES(dmux=%d, addr=0x%x, size=0x%x, filter(0x%x, 0x%x, 0x%x, 0x%x), cb=0x%x(arg=0x%x), spec=0x%x): id = %d",
cellDmux->Warning("*** New ES(dmux=%d, addr=0x%x, size=0x%x, filter(0x%x, 0x%x, 0x%x, 0x%x), cb=0x%x(arg=0x%x), spec=0x%x): id = %d",
demuxerHandle, es->memAddr, es->memSize, es->fidMajor, es->fidMinor, es->sup1, es->sup2, (u32)esCb->cbEsMsgFunc, es->cbArg, es->spec, id);
DemuxerTask task(dmuxEnableEs);
@ -809,7 +810,7 @@ int cellDmuxEnableEs(u32 demuxerHandle, const mem_ptr_t<CellCodecEsFilterId> esF
int cellDmuxDisableEs(u32 esHandle)
{
cellDmux.Warning("cellDmuxDisableEs(esHandle=0x%x)", esHandle);
cellDmux->Warning("cellDmuxDisableEs(esHandle=0x%x)", esHandle);
ElementaryStream* es;
if (!Emu.GetIdManager().GetIDData(esHandle, es))
@ -827,7 +828,7 @@ int cellDmuxDisableEs(u32 esHandle)
int cellDmuxResetEs(u32 esHandle)
{
cellDmux.Log("cellDmuxResetEs(esHandle=0x%x)", esHandle);
cellDmux->Log("cellDmuxResetEs(esHandle=0x%x)", esHandle);
ElementaryStream* es;
if (!Emu.GetIdManager().GetIDData(esHandle, es))
@ -845,7 +846,7 @@ int cellDmuxResetEs(u32 esHandle)
int cellDmuxGetAu(u32 esHandle, mem32_t auInfo_ptr, mem32_t auSpecificInfo_ptr)
{
cellDmux.Log("cellDmuxGetAu(esHandle=0x%x, auInfo_ptr_addr=0x%x, auSpecificInfo_ptr_addr=0x%x)",
cellDmux->Log("cellDmuxGetAu(esHandle=0x%x, auInfo_ptr_addr=0x%x, auSpecificInfo_ptr_addr=0x%x)",
esHandle, auInfo_ptr.GetAddr(), auSpecificInfo_ptr.GetAddr());
ElementaryStream* es;
@ -873,7 +874,7 @@ int cellDmuxGetAu(u32 esHandle, mem32_t auInfo_ptr, mem32_t auSpecificInfo_ptr)
int cellDmuxPeekAu(u32 esHandle, mem32_t auInfo_ptr, mem32_t auSpecificInfo_ptr)
{
cellDmux.Log("cellDmuxPeekAu(esHandle=0x%x, auInfo_ptr_addr=0x%x, auSpecificInfo_ptr_addr=0x%x)",
cellDmux->Log("cellDmuxPeekAu(esHandle=0x%x, auInfo_ptr_addr=0x%x, auSpecificInfo_ptr_addr=0x%x)",
esHandle, auInfo_ptr.GetAddr(), auSpecificInfo_ptr.GetAddr());
ElementaryStream* es;
@ -901,7 +902,7 @@ int cellDmuxPeekAu(u32 esHandle, mem32_t auInfo_ptr, mem32_t auSpecificInfo_ptr)
int cellDmuxGetAuEx(u32 esHandle, mem32_t auInfoEx_ptr, mem32_t auSpecificInfo_ptr)
{
cellDmux.Log("cellDmuxGetAuEx(esHandle=0x%x, auInfoEx_ptr_addr=0x%x, auSpecificInfo_ptr_addr=0x%x)",
cellDmux->Log("cellDmuxGetAuEx(esHandle=0x%x, auInfoEx_ptr_addr=0x%x, auSpecificInfo_ptr_addr=0x%x)",
esHandle, auInfoEx_ptr.GetAddr(), auSpecificInfo_ptr.GetAddr());
ElementaryStream* es;
@ -929,7 +930,7 @@ int cellDmuxGetAuEx(u32 esHandle, mem32_t auInfoEx_ptr, mem32_t auSpecificInfo_p
int cellDmuxPeekAuEx(u32 esHandle, mem32_t auInfoEx_ptr, mem32_t auSpecificInfo_ptr)
{
cellDmux.Log("cellDmuxPeekAuEx(esHandle=0x%x, auInfoEx_ptr_addr=0x%x, auSpecificInfo_ptr_addr=0x%x)",
cellDmux->Log("cellDmuxPeekAuEx(esHandle=0x%x, auInfoEx_ptr_addr=0x%x, auSpecificInfo_ptr_addr=0x%x)",
esHandle, auInfoEx_ptr.GetAddr(), auSpecificInfo_ptr.GetAddr());
ElementaryStream* es;
@ -957,7 +958,7 @@ int cellDmuxPeekAuEx(u32 esHandle, mem32_t auInfoEx_ptr, mem32_t auSpecificInfo_
int cellDmuxReleaseAu(u32 esHandle)
{
cellDmux.Log("cellDmuxReleaseAu(esHandle=0x%x)", esHandle);
cellDmux->Log("cellDmuxReleaseAu(esHandle=0x%x)", esHandle);
ElementaryStream* es;
if (!Emu.GetIdManager().GetIDData(esHandle, es))
@ -974,7 +975,7 @@ int cellDmuxReleaseAu(u32 esHandle)
int cellDmuxFlushEs(u32 esHandle)
{
cellDmux.Warning("cellDmuxFlushEs(esHandle=0x%x)", esHandle);
cellDmux->Warning("cellDmuxFlushEs(esHandle=0x%x)", esHandle);
ElementaryStream* es;
if (!Emu.GetIdManager().GetIDData(esHandle, es))
@ -992,24 +993,24 @@ int cellDmuxFlushEs(u32 esHandle)
void cellDmux_init()
{
cellDmux.AddFunc(0xa2d4189b, cellDmuxQueryAttr);
cellDmux.AddFunc(0x3f76e3cd, cellDmuxQueryAttr2);
cellDmux.AddFunc(0x68492de9, cellDmuxOpen);
cellDmux.AddFunc(0xf6c23560, cellDmuxOpenEx);
cellDmux.AddFunc(0x11bc3a6c, cellDmuxOpen2);
cellDmux.AddFunc(0x8c692521, cellDmuxClose);
cellDmux.AddFunc(0x04e7499f, cellDmuxSetStream);
cellDmux.AddFunc(0x5d345de9, cellDmuxResetStream);
cellDmux.AddFunc(0xccff1284, cellDmuxResetStreamAndWaitDone);
cellDmux.AddFunc(0x02170d1a, cellDmuxQueryEsAttr);
cellDmux.AddFunc(0x52911bcf, cellDmuxQueryEsAttr2);
cellDmux.AddFunc(0x7b56dc3f, cellDmuxEnableEs);
cellDmux.AddFunc(0x05371c8d, cellDmuxDisableEs);
cellDmux.AddFunc(0x21d424f0, cellDmuxResetEs);
cellDmux.AddFunc(0x42c716b5, cellDmuxGetAu);
cellDmux.AddFunc(0x2750c5e0, cellDmuxPeekAu);
cellDmux.AddFunc(0x2c9a5857, cellDmuxGetAuEx);
cellDmux.AddFunc(0x002e8da2, cellDmuxPeekAuEx);
cellDmux.AddFunc(0x24ea6474, cellDmuxReleaseAu);
cellDmux.AddFunc(0xebb3b2bd, cellDmuxFlushEs);
cellDmux->AddFunc(0xa2d4189b, cellDmuxQueryAttr);
cellDmux->AddFunc(0x3f76e3cd, cellDmuxQueryAttr2);
cellDmux->AddFunc(0x68492de9, cellDmuxOpen);
cellDmux->AddFunc(0xf6c23560, cellDmuxOpenEx);
cellDmux->AddFunc(0x11bc3a6c, cellDmuxOpen2);
cellDmux->AddFunc(0x8c692521, cellDmuxClose);
cellDmux->AddFunc(0x04e7499f, cellDmuxSetStream);
cellDmux->AddFunc(0x5d345de9, cellDmuxResetStream);
cellDmux->AddFunc(0xccff1284, cellDmuxResetStreamAndWaitDone);
cellDmux->AddFunc(0x02170d1a, cellDmuxQueryEsAttr);
cellDmux->AddFunc(0x52911bcf, cellDmuxQueryEsAttr2);
cellDmux->AddFunc(0x7b56dc3f, cellDmuxEnableEs);
cellDmux->AddFunc(0x05371c8d, cellDmuxDisableEs);
cellDmux->AddFunc(0x21d424f0, cellDmuxResetEs);
cellDmux->AddFunc(0x42c716b5, cellDmuxGetAu);
cellDmux->AddFunc(0x2750c5e0, cellDmuxPeekAu);
cellDmux->AddFunc(0x2c9a5857, cellDmuxGetAuEx);
cellDmux->AddFunc(0x002e8da2, cellDmuxPeekAuEx);
cellDmux->AddFunc(0x24ea6474, cellDmuxReleaseAu);
cellDmux->AddFunc(0xebb3b2bd, cellDmuxFlushEs);
}

2
rpcs3/Emu/SysCalls/Modules/cellFiber.cpp
View File

@ -360,4 +360,4 @@ void cellFiber_init()
cellFiber.AddFunc(0xea6dc1ad, cellFiberPpuUtilWorkerControlCheckFlags);
cellFiber.AddFunc(0xf2ccad4f, cellFiberPpuUtilWorkerControlInitializeWithAttribute);
}
#endif
#endif

167
rpcs3/Emu/SysCalls/Modules/cellFont.cpp
View File

@ -10,10 +10,11 @@
#include "cellFont.h"
#include "stblib/stb_truetype.h"
void cellFont_init();
void cellFont_load();
void cellFont_unload();
Module cellFont(0x0019, cellFont_init, cellFont_load, cellFont_unload);
//void cellFont_init();
//void cellFont_load();
//void cellFont_unload();
//Module cellFont(0x0019, cellFont_init, cellFont_load, cellFont_unload);
Module *cellFont = nullptr;
// Font Set Types
enum
@ -238,7 +239,7 @@ CCellFontInternal* s_fontInternalInstance = nullptr;
// Functions
int cellFontInitializeWithRevision(u64 revisionFlags, mem_ptr_t<CellFontConfig> config)
{
cellFont.Warning("cellFontInitializeWithRevision(revisionFlags=0x%llx, config=0x%x)", revisionFlags, config.GetAddr());
cellFont->Warning("cellFontInitializeWithRevision(revisionFlags=0x%llx, config=0x%x)", revisionFlags, config.GetAddr());
if (s_fontInternalInstance->m_bInitialized)
return CELL_FONT_ERROR_ALREADY_INITIALIZED;
@ -249,7 +250,7 @@ int cellFontInitializeWithRevision(u64 revisionFlags, mem_ptr_t<CellFontConfig>
if (config->FileCache.size < 24)
return CELL_FONT_ERROR_INVALID_PARAMETER;
if (config->flags != 0)
cellFont.Warning("cellFontInitializeWithRevision: Unknown flags (0x%x)", config->flags);
cellFont->Warning("cellFontInitializeWithRevision: Unknown flags (0x%x)", config->flags);
s_fontInternalInstance->m_buffer_addr = config->FileCache.buffer_addr;
s_fontInternalInstance->m_buffer_size = config->FileCache.size;
@ -267,7 +268,7 @@ int cellFontGetRevisionFlags(mem64_t revisionFlags)
int cellFontInit(mem_ptr_t<CellFontConfig> config)
{
cellFont.Log("cellFontInit(config=0x%x)", config.GetAddr());
cellFont->Log("cellFontInit(config=0x%x)", config.GetAddr());
MemoryAllocator<u64> revisionFlags = 0;
cellFontGetRevisionFlags(revisionFlags.GetAddr());
@ -276,7 +277,7 @@ int cellFontInit(mem_ptr_t<CellFontConfig> config)
int cellFontEnd()
{
cellFont.Log("cellFontEnd()");
cellFont->Log("cellFontEnd()");
if (!s_fontInternalInstance->m_bInitialized)
return CELL_FONT_ERROR_UNINITIALIZED;
@ -287,14 +288,14 @@ int cellFontEnd()
s32 cellFontSetFontsetOpenMode(u32 openMode)
{
cellFont.Log("cellFontSetFontsetOpenMode(openMode=0x%x)", openMode);
cellFont->Log("cellFontSetFontsetOpenMode(openMode=0x%x)", openMode);
UNIMPLEMENTED_FUNC(cellFont);
return CELL_FONT_OK;
}
int cellFontOpenFontMemory(mem_ptr_t<CellFontLibrary> library, u32 fontAddr, u32 fontSize, u32 subNum, u32 uniqueId, mem_ptr_t<CellFont> font)
{
cellFont.Warning("cellFontOpenFontMemory(library_addr=0x%x, fontAddr=0x%x, fontSize=%d, subNum=%d, uniqueId=%d, font_addr=0x%x)",
cellFont->Warning("cellFontOpenFontMemory(library_addr=0x%x, fontAddr=0x%x, fontSize=%d, subNum=%d, uniqueId=%d, font_addr=0x%x)",
library.GetAddr(), fontAddr, fontSize, subNum, uniqueId, font.GetAddr());
if (!s_fontInternalInstance->m_bInitialized)
@ -316,7 +317,7 @@ int cellFontOpenFontMemory(mem_ptr_t<CellFontLibrary> library, u32 fontAddr, u32
int cellFontOpenFontFile(mem_ptr_t<CellFontLibrary> library, mem8_ptr_t fontPath, u32 subNum, s32 uniqueId, mem_ptr_t<CellFont> font)
{
std::string fp(fontPath.GetString());
cellFont.Warning("cellFontOpenFontFile(library_addr=0x%x, fontPath=\"%s\", subNum=%d, uniqueId=%d, font_addr=0x%x)",
cellFont->Warning("cellFontOpenFontFile(library_addr=0x%x, fontPath=\"%s\", subNum=%d, uniqueId=%d, font_addr=0x%x)",
library.GetAddr(), fp.c_str(), subNum, uniqueId, font.GetAddr());
vfsFile f(fp);
@ -333,7 +334,7 @@ int cellFontOpenFontFile(mem_ptr_t<CellFontLibrary> library, mem8_ptr_t fontPath
int cellFontOpenFontset(mem_ptr_t<CellFontLibrary> library, mem_ptr_t<CellFontType> fontType, mem_ptr_t<CellFont> font)
{
cellFont.Log("cellFontOpenFontset(library_addr=0x%x, fontType_addr=0x%x, font_addr=0x%x)",
cellFont->Log("cellFontOpenFontset(library_addr=0x%x, fontType_addr=0x%x, font_addr=0x%x)",
library.GetAddr(), fontType.GetAddr(), font.GetAddr());
if (!library.IsGood() || !fontType.IsGood() || !font.IsGood())
@ -341,7 +342,7 @@ int cellFontOpenFontset(mem_ptr_t<CellFontLibrary> library, mem_ptr_t<CellFontTy
if (!s_fontInternalInstance->m_bInitialized)
return CELL_FONT_ERROR_UNINITIALIZED;
if (fontType->map != CELL_FONT_MAP_UNICODE)
cellFont.Warning("cellFontOpenFontset: Only Unicode is supported");
cellFont->Warning("cellFontOpenFontset: Only Unicode is supported");
std::string file;
switch((u32)fontType->type)
@ -400,12 +401,12 @@ int cellFontOpenFontset(mem_ptr_t<CellFontLibrary> library, mem_ptr_t<CellFontTy
case CELL_FONT_TYPE_SEURAT_CAPIE_MARU_GOTHIC_YG_DFHEI5_RSANS2_SET:
case CELL_FONT_TYPE_SEURAT_CAPIE_MARU_GOTHIC_YG_DFHEI5_VAGR2_SET:
case CELL_FONT_TYPE_SEURAT_CAPIE_MARU_GOTHIC_VAGR2_SET:
cellFont.Warning("cellFontOpenFontset: fontType->type = %d not supported yet. RD-R-LATIN.TTF will be used instead.", fontType->type);
cellFont->Warning("cellFontOpenFontset: fontType->type = %d not supported yet. RD-R-LATIN.TTF will be used instead.", fontType->type);
file = "/dev_flash/data/font/SCE-PS3-RD-R-LATIN.TTF";
break;
default:
cellFont.Warning("cellFontOpenFontset: fontType->type = %d not supported.", fontType->type);
cellFont->Warning("cellFontOpenFontset: fontType->type = %d not supported.", fontType->type);
return CELL_FONT_ERROR_NO_SUPPORT_FONTSET;
}
@ -419,7 +420,7 @@ int cellFontOpenFontset(mem_ptr_t<CellFontLibrary> library, mem_ptr_t<CellFontTy
int cellFontOpenFontInstance(mem_ptr_t<CellFont> openedFont, mem_ptr_t<CellFont> font)
{
cellFont.Warning("cellFontOpenFontInstance(openedFont=0x%x, font=0x%x)", openedFont.GetAddr(), font.GetAddr());
cellFont->Warning("cellFontOpenFontInstance(openedFont=0x%x, font=0x%x)", openedFont.GetAddr(), font.GetAddr());
if (!openedFont.IsGood() || !font.IsGood())
return CELL_FONT_ERROR_INVALID_PARAMETER;
@ -436,14 +437,14 @@ int cellFontOpenFontInstance(mem_ptr_t<CellFont> openedFont, mem_ptr_t<CellFont>
s32 cellFontSetFontOpenMode(u32 openMode)
{
cellFont.Log("cellFontSetFontOpenMode(openMode=0x%x)", openMode);
cellFont->Log("cellFontSetFontOpenMode(openMode=0x%x)", openMode);
UNIMPLEMENTED_FUNC(cellFont);
return CELL_FONT_OK;
}
int cellFontCreateRenderer(mem_ptr_t<CellFontLibrary> library, mem_ptr_t<CellFontRendererConfig> config, mem_ptr_t<CellFontRenderer> Renderer)
{
cellFont.Warning("cellFontCreateRenderer(library_addr=0x%x, config_addr=0x%x, Renderer_addr=0x%x)",
cellFont->Warning("cellFontCreateRenderer(library_addr=0x%x, config_addr=0x%x, Renderer_addr=0x%x)",
library.GetAddr(), config.GetAddr(), Renderer.GetAddr());
if (!library.IsGood() || !config.IsGood() || !Renderer.IsGood())
@ -458,7 +459,7 @@ int cellFontCreateRenderer(mem_ptr_t<CellFontLibrary> library, mem_ptr_t<CellFon
void cellFontRenderSurfaceInit(mem_ptr_t<CellFontRenderSurface> surface, u32 buffer_addr, s32 bufferWidthByte, s32 pixelSizeByte, s32 w, s32 h)
{
cellFont.Warning("cellFontRenderSurfaceInit(surface_addr=0x%x, buffer_addr=0x%x, bufferWidthByte=%d, pixelSizeByte=%d, w=%d, h=%d)",
cellFont->Warning("cellFontRenderSurfaceInit(surface_addr=0x%x, buffer_addr=0x%x, bufferWidthByte=%d, pixelSizeByte=%d, w=%d, h=%d)",
surface.GetAddr(), buffer_addr, bufferWidthByte, pixelSizeByte, w, h);
surface->buffer_addr = buffer_addr;
@ -473,7 +474,7 @@ void cellFontRenderSurfaceInit(mem_ptr_t<CellFontRenderSurface> surface, u32 buf
void cellFontRenderSurfaceSetScissor(mem_ptr_t<CellFontRenderSurface> surface, s32 x0, s32 y0, s32 w, s32 h)
{
cellFont.Warning("cellFontRenderSurfaceSetScissor(surface_addr=0x%x, x0=%d, y0=%d, w=%d, h=%d)",
cellFont->Warning("cellFontRenderSurfaceSetScissor(surface_addr=0x%x, x0=%d, y0=%d, w=%d, h=%d)",
surface.GetAddr(), x0, y0, w, h);
surface->Scissor.x0 = x0;
@ -486,7 +487,7 @@ int cellFontSetScalePixel(mem_ptr_t<CellFont> font, float w, float h)
{
w = GetCurrentPPUThread().FPR[1]; // TODO: Something is wrong with the float arguments
h = GetCurrentPPUThread().FPR[2]; // TODO: Something is wrong with the float arguments
cellFont.Log("cellFontSetScalePixel(font_addr=0x%x, w=%f, h=%f)", font.GetAddr(), w, h);
cellFont->Log("cellFontSetScalePixel(font_addr=0x%x, w=%f, h=%f)", font.GetAddr(), w, h);
if (!font.IsGood())
return CELL_FONT_ERROR_INVALID_PARAMETER;
@ -498,7 +499,7 @@ int cellFontSetScalePixel(mem_ptr_t<CellFont> font, float w, float h)
int cellFontGetHorizontalLayout(mem_ptr_t<CellFont> font, mem_ptr_t<CellFontHorizontalLayout> layout)
{
cellFont.Log("cellFontGetHorizontalLayout(font_addr=0x%x, layout_addr=0x%x)",
cellFont->Log("cellFontGetHorizontalLayout(font_addr=0x%x, layout_addr=0x%x)",
font.GetAddr(), layout.GetAddr());
if (!font.IsGood() || !layout.IsGood())
@ -516,7 +517,7 @@ int cellFontGetHorizontalLayout(mem_ptr_t<CellFont> font, mem_ptr_t<CellFontHori
int cellFontBindRenderer(mem_ptr_t<CellFont> font, mem_ptr_t<CellFontRenderer> renderer)
{
cellFont.Warning("cellFontBindRenderer(font_addr=0x%x, renderer_addr=0x%x)",
cellFont->Warning("cellFontBindRenderer(font_addr=0x%x, renderer_addr=0x%x)",
font.GetAddr(), renderer.GetAddr());
if (!font.IsGood() || !renderer.IsGood())
@ -530,7 +531,7 @@ int cellFontBindRenderer(mem_ptr_t<CellFont> font, mem_ptr_t<CellFontRenderer> r
int cellFontUnbindRenderer(mem_ptr_t<CellFont> font)
{
cellFont.Warning("cellFontBindRenderer(font_addr=0x%x)", font.GetAddr());
cellFont->Warning("cellFontBindRenderer(font_addr=0x%x)", font.GetAddr());
if (!font.IsGood())
return CELL_FONT_ERROR_INVALID_PARAMETER;
@ -551,7 +552,7 @@ int cellFontSetupRenderScalePixel(mem_ptr_t<CellFont> font, float w, float h)
{
w = GetCurrentPPUThread().FPR[1]; // TODO: Something is wrong with the float arguments
h = GetCurrentPPUThread().FPR[2]; // TODO: Something is wrong with the float arguments
cellFont.Log("cellFontSetupRenderScalePixel(font_addr=0x%x, w=%f, h=%f)", font.GetAddr(), w, h);
cellFont->Log("cellFontSetupRenderScalePixel(font_addr=0x%x, w=%f, h=%f)", font.GetAddr(), w, h);
if (!font.IsGood())
return CELL_FONT_ERROR_INVALID_PARAMETER;
@ -564,7 +565,7 @@ int cellFontSetupRenderScalePixel(mem_ptr_t<CellFont> font, float w, float h)
int cellFontGetRenderCharGlyphMetrics(mem_ptr_t<CellFont> font, u32 code, mem_ptr_t<CellFontGlyphMetrics> metrics)
{
cellFont.Log("cellFontGetRenderCharGlyphMetrics(font_addr=0x%x, code=0x%x, metrics_addr=0x%x)",
cellFont->Log("cellFontGetRenderCharGlyphMetrics(font_addr=0x%x, code=0x%x, metrics_addr=0x%x)",
font.GetAddr(), code, metrics.GetAddr());
if (!font.IsGood() || !metrics.IsGood())
@ -580,7 +581,7 @@ int cellFontRenderCharGlyphImage(mem_ptr_t<CellFont> font, u32 code, mem_ptr_t<C
{
x = GetCurrentPPUThread().FPR[1]; // TODO: Something is wrong with the float arguments
y = GetCurrentPPUThread().FPR[2]; // TODO: Something is wrong with the float arguments
cellFont.Log("cellFontRenderCharGlyphImage(font_addr=0x%x, code=0x%x, surface_addr=0x%x, x=%f, y=%f, metrics_addr=0x%x, trans_addr=0x%x)",
cellFont->Log("cellFontRenderCharGlyphImage(font_addr=0x%x, code=0x%x, surface_addr=0x%x, x=%f, y=%f, metrics_addr=0x%x, trans_addr=0x%x)",
font.GetAddr(), code, surface.GetAddr(), x, y, metrics.GetAddr(), transInfo.GetAddr());
if (!font.IsGood() || !surface.IsGood() || !metrics.IsGood() || !transInfo.IsGood())
@ -627,7 +628,7 @@ int cellFontEndLibrary()
int cellFontSetEffectSlant(mem_ptr_t<CellFont> font, float slantParam)
{
slantParam = GetCurrentPPUThread().FPR[1]; // TODO: Something is wrong with the float arguments
cellFont.Log("cellFontSetEffectSlant(font_addr=0x%x, slantParam=%f)", font.GetAddr(), slantParam);
cellFont->Log("cellFontSetEffectSlant(font_addr=0x%x, slantParam=%f)", font.GetAddr(), slantParam);
if (!font.IsGood() || slantParam < -1.0 || slantParam > 1.0)
return CELL_FONT_ERROR_INVALID_PARAMETER;
@ -638,7 +639,7 @@ int cellFontSetEffectSlant(mem_ptr_t<CellFont> font, float slantParam)
int cellFontGetEffectSlant(mem_ptr_t<CellFont> font, mem32_t slantParam)
{
cellFont.Warning("cellFontSetEffectSlant(font_addr=0x%x, slantParam_addr=0x%x)", font.GetAddr(), slantParam.GetAddr());
cellFont->Warning("cellFontSetEffectSlant(font_addr=0x%x, slantParam_addr=0x%x)", font.GetAddr(), slantParam.GetAddr());
if (!font.IsGood() || !slantParam.IsGood())
return CELL_FONT_ERROR_INVALID_PARAMETER;
@ -649,7 +650,7 @@ int cellFontGetEffectSlant(mem_ptr_t<CellFont> font, mem32_t slantParam)
int cellFontGetFontIdCode(mem_ptr_t<CellFont> font, u32 code, mem32_t fontId, mem32_t fontCode)
{
cellFont.Log("cellFontGetFontIdCode(font_addr=0x%x, code=0x%x, fontId_addr=0x%x, fontCode_addr=0x%x",
cellFont->Log("cellFontGetFontIdCode(font_addr=0x%x, code=0x%x, fontId_addr=0x%x, fontCode_addr=0x%x",
font.GetAddr(), code, fontId.GetAddr(), fontCode.GetAddr());
if (!font.IsGood() || !fontId.IsGood()) //fontCode isn't used
@ -661,7 +662,7 @@ int cellFontGetFontIdCode(mem_ptr_t<CellFont> font, u32 code, mem32_t fontId, me
int cellFontCloseFont(mem_ptr_t<CellFont> font)
{
cellFont.Warning("cellFontCloseFont(font_addr=0x%x)", font.GetAddr());
cellFont->Warning("cellFontCloseFont(font_addr=0x%x)", font.GetAddr());
if (!font.IsGood())
return CELL_FONT_ERROR_INVALID_PARAMETER;
@ -676,7 +677,7 @@ int cellFontCloseFont(mem_ptr_t<CellFont> font)
int cellFontGetCharGlyphMetrics(mem_ptr_t<CellFont> font, u32 code, mem_ptr_t<CellFontGlyphMetrics> metrics)
{
cellFont.Log("cellFontGetCharGlyphMetrics(font_addr=0x%x, code=0x%x, metrics_addr=0x%x",
cellFont->Log("cellFontGetCharGlyphMetrics(font_addr=0x%x, code=0x%x, metrics_addr=0x%x",
font.GetAddr(), code, metrics.GetAddr());
if (!font.IsGood() || metrics.IsGood())
@ -816,7 +817,7 @@ int cellFontDeleteGlyph()
int cellFontExtend(u32 a1, u32 a2, u32 a3)
{
cellFont.Warning("cellFontExtend(a1=0x%x, a2=0x%x, a3=0x%x)", a1, a2, a3);
cellFont->Warning("cellFontExtend(a1=0x%x, a2=0x%x, a3=0x%x)", a1, a2, a3);
//In a test I did: a1=0xcfe00000, a2=0x0, a3=(pointer to something)
if (a1 == 0xcfe00000)
{
@ -854,56 +855,56 @@ int cellFontGetCharGlyphMetricsVertical()
void cellFont_init()
{
cellFont.AddFunc(0x25c107e6, cellFontInit);
cellFont.AddFunc(0x6bf6f832, cellFontSetFontsetOpenMode);
cellFont.AddFunc(0x6cfada83, cellFontSetFontOpenMode);
cellFont.AddFunc(0x042e74e3, cellFontCreateRenderer);
cellFont.AddFunc(0x1387c45c, cellFontGetHorizontalLayout);
cellFont.AddFunc(0x21ebb248, cellFontDestroyRenderer);
cellFont.AddFunc(0x227e1e3c, cellFontSetupRenderScalePixel);
cellFont.AddFunc(0x29329541, cellFontOpenFontInstance);
cellFont.AddFunc(0x297f0e93, cellFontSetScalePixel);
cellFont.AddFunc(0x2da9fd9d, cellFontGetRenderCharGlyphMetrics);
cellFont.AddFunc(0x40d40544, cellFontEndLibrary);
cellFont.AddFunc(0x66a23100, cellFontBindRenderer);
cellFont.AddFunc(0x7ab47f7e, cellFontEnd);
cellFont.AddFunc(0x8657c8f5, cellFontSetEffectSlant);
cellFont.AddFunc(0xe16e679a, cellFontGetEffectSlant);
cellFont.AddFunc(0x88be4799, cellFontRenderCharGlyphImage);
cellFont.AddFunc(0x90b9465e, cellFontRenderSurfaceInit);
cellFont.AddFunc(0x98ac5524, cellFontGetFontIdCode);
cellFont.AddFunc(0xa885cc9b, cellFontOpenFontset);
cellFont.AddFunc(0xb276f1f6, cellFontCloseFont);
cellFont.AddFunc(0xb422b005, cellFontRenderSurfaceSetScissor);
cellFont.AddFunc(0xd8eaee9f, cellFontGetCharGlyphMetrics);
cellFont.AddFunc(0xf03dcc29, cellFontInitializeWithRevision);
cellFont.AddFunc(0x061049ad, cellFontGraphicsSetFontRGBA);
cellFont.AddFunc(0x073fa321, cellFontOpenFontsetOnMemory);
cellFont.AddFunc(0x0a7306a4, cellFontOpenFontFile);
cellFont.AddFunc(0x16322df1, cellFontGraphicsSetScalePixel);
cellFont.AddFunc(0x2388186c, cellFontGraphicsGetScalePixel);
cellFont.AddFunc(0x25253fe4, cellFontSetEffectWeight);
cellFont.AddFunc(0x53f529fe, cellFontGlyphSetupVertexesGlyph);
cellFont.AddFunc(0x698897f8, cellFontGetVerticalLayout);
cellFont.AddFunc(0x700e6223, cellFontGetRenderCharGlyphMetricsVertical);
cellFont.AddFunc(0x70f3e728, cellFontSetScalePoint);
cellFont.AddFunc(0x78d05e08, cellFontSetupRenderEffectSlant);
cellFont.AddFunc(0x7c83bc15, cellFontGraphicsSetLineRGBA);
cellFont.AddFunc(0x87bd650f, cellFontGraphicsSetDrawType);
cellFont.AddFunc(0x8a35c887, cellFontEndGraphics);
cellFont.AddFunc(0x970d4c22, cellFontGraphicsSetupDrawContext);
cellFont.AddFunc(0x9e19072b, cellFontOpenFontMemory);
cellFont.AddFunc(0xa6dc25d1, cellFontSetupRenderEffectWeight);
cellFont.AddFunc(0xa8fae920, cellFontGlyphGetOutlineControlDistance);
cellFont.AddFunc(0xb4d112af, cellFontGlyphGetVertexesGlyphSize);
cellFont.AddFunc(0xc17259de, cellFontGenerateCharGlyph);
cellFont.AddFunc(0xd62f5d76, cellFontDeleteGlyph);
cellFont.AddFunc(0xdee0836c, cellFontExtend);
cellFont.AddFunc(0xe857a0ca, cellFontRenderCharGlyphImageVertical);
cellFont.AddFunc(0xfb3341ba, cellFontSetResolutionDpi);
cellFont.AddFunc(0xfe9a6dd7, cellFontGetCharGlyphMetricsVertical);
cellFont.AddFunc(0xf16379fa, cellFontUnbindRenderer);
cellFont.AddFunc(0xb015a84e, cellFontGetRevisionFlags);
cellFont->AddFunc(0x25c107e6, cellFontInit);
cellFont->AddFunc(0x6bf6f832, cellFontSetFontsetOpenMode);
cellFont->AddFunc(0x6cfada83, cellFontSetFontOpenMode);
cellFont->AddFunc(0x042e74e3, cellFontCreateRenderer);
cellFont->AddFunc(0x1387c45c, cellFontGetHorizontalLayout);
cellFont->AddFunc(0x21ebb248, cellFontDestroyRenderer);
cellFont->AddFunc(0x227e1e3c, cellFontSetupRenderScalePixel);
cellFont->AddFunc(0x29329541, cellFontOpenFontInstance);
cellFont->AddFunc(0x297f0e93, cellFontSetScalePixel);
cellFont->AddFunc(0x2da9fd9d, cellFontGetRenderCharGlyphMetrics);
cellFont->AddFunc(0x40d40544, cellFontEndLibrary);
cellFont->AddFunc(0x66a23100, cellFontBindRenderer);
cellFont->AddFunc(0x7ab47f7e, cellFontEnd);
cellFont->AddFunc(0x8657c8f5, cellFontSetEffectSlant);
cellFont->AddFunc(0xe16e679a, cellFontGetEffectSlant);
cellFont->AddFunc(0x88be4799, cellFontRenderCharGlyphImage);
cellFont->AddFunc(0x90b9465e, cellFontRenderSurfaceInit);
cellFont->AddFunc(0x98ac5524, cellFontGetFontIdCode);
cellFont->AddFunc(0xa885cc9b, cellFontOpenFontset);
cellFont->AddFunc(0xb276f1f6, cellFontCloseFont);
cellFont->AddFunc(0xb422b005, cellFontRenderSurfaceSetScissor);
cellFont->AddFunc(0xd8eaee9f, cellFontGetCharGlyphMetrics);
cellFont->AddFunc(0xf03dcc29, cellFontInitializeWithRevision);
cellFont->AddFunc(0x061049ad, cellFontGraphicsSetFontRGBA);
cellFont->AddFunc(0x073fa321, cellFontOpenFontsetOnMemory);
cellFont->AddFunc(0x0a7306a4, cellFontOpenFontFile);
cellFont->AddFunc(0x16322df1, cellFontGraphicsSetScalePixel);
cellFont->AddFunc(0x2388186c, cellFontGraphicsGetScalePixel);
cellFont->AddFunc(0x25253fe4, cellFontSetEffectWeight);
cellFont->AddFunc(0x53f529fe, cellFontGlyphSetupVertexesGlyph);
cellFont->AddFunc(0x698897f8, cellFontGetVerticalLayout);
cellFont->AddFunc(0x700e6223, cellFontGetRenderCharGlyphMetricsVertical);
cellFont->AddFunc(0x70f3e728, cellFontSetScalePoint);
cellFont->AddFunc(0x78d05e08, cellFontSetupRenderEffectSlant);
cellFont->AddFunc(0x7c83bc15, cellFontGraphicsSetLineRGBA);
cellFont->AddFunc(0x87bd650f, cellFontGraphicsSetDrawType);
cellFont->AddFunc(0x8a35c887, cellFontEndGraphics);
cellFont->AddFunc(0x970d4c22, cellFontGraphicsSetupDrawContext);
cellFont->AddFunc(0x9e19072b, cellFontOpenFontMemory);
cellFont->AddFunc(0xa6dc25d1, cellFontSetupRenderEffectWeight);
cellFont->AddFunc(0xa8fae920, cellFontGlyphGetOutlineControlDistance);
cellFont->AddFunc(0xb4d112af, cellFontGlyphGetVertexesGlyphSize);
cellFont->AddFunc(0xc17259de, cellFontGenerateCharGlyph);
cellFont->AddFunc(0xd62f5d76, cellFontDeleteGlyph);
cellFont->AddFunc(0xdee0836c, cellFontExtend);
cellFont->AddFunc(0xe857a0ca, cellFontRenderCharGlyphImageVertical);
cellFont->AddFunc(0xfb3341ba, cellFontSetResolutionDpi);
cellFont->AddFunc(0xfe9a6dd7, cellFontGetCharGlyphMetricsVertical);
cellFont->AddFunc(0xf16379fa, cellFontUnbindRenderer);
cellFont->AddFunc(0xb015a84e, cellFontGetRevisionFlags);
}
void cellFont_load()

17
rpcs3/Emu/SysCalls/Modules/cellFontFT.cpp
View File

@ -8,10 +8,11 @@
#include "Emu/SysCalls/SysCalls.h"
#include "cellFont.h"
void cellFontFT_init();
void cellFontFT_load();
void cellFontFT_unload();
Module cellFontFT(0x001a, cellFontFT_init, cellFontFT_load, cellFontFT_unload);
//void cellFontFT_init();
//void cellFontFT_load();
//void cellFontFT_unload();
//Module cellFontFT(0x001a, cellFontFT_init, cellFontFT_load, cellFontFT_unload);
extern Module *cellFontFT = nullptr;
struct CellFontLibraryConfigFT
{
@ -44,7 +45,7 @@ CCellFontFTInternal* s_fontFtInternalInstance = nullptr;
int cellFontInitLibraryFreeTypeWithRevision(u64 revisionFlags, mem_ptr_t<CellFontLibraryConfigFT> config, u32 lib_addr_addr)
{
cellFontFT.Warning("cellFontInitLibraryFreeTypeWithRevision(revisionFlags=0x%llx, config_addr=0x%x, lib_addr_addr=0x%x",
cellFontFT->Warning("cellFontInitLibraryFreeTypeWithRevision(revisionFlags=0x%llx, config_addr=0x%x, lib_addr_addr=0x%x",
revisionFlags, config.GetAddr(), lib_addr_addr);
if (!config.IsGood() || !Memory.IsGoodAddr(lib_addr_addr))
@ -71,9 +72,9 @@ int cellFontFTGetInitializedRevisionFlags()
void cellFontFT_init()
{
cellFontFT.AddFunc(0x7a0a83c4, cellFontInitLibraryFreeTypeWithRevision);
cellFontFT.AddFunc(0xec89a187, cellFontFTGetRevisionFlags);
cellFontFT.AddFunc(0xfa0c2de0, cellFontFTGetInitializedRevisionFlags);
cellFontFT->AddFunc(0x7a0a83c4, cellFontInitLibraryFreeTypeWithRevision);
cellFontFT->AddFunc(0xec89a187, cellFontFTGetRevisionFlags);
cellFontFT->AddFunc(0xfa0c2de0, cellFontFTGetInitializedRevisionFlags);
}
void cellFontFT_load()

53
rpcs3/Emu/SysCalls/Modules/cellGame.cpp
View File

@ -10,8 +10,9 @@
#include "Loader/PSF.h"
void cellGame_init();
Module cellGame(0x003e, cellGame_init);
//void cellGame_init();
//Module cellGame(0x003e, cellGame_init);
extern Module *cellGame = nullptr;
// Return Codes
enum
@ -118,12 +119,12 @@ struct CellGameContentSize
int cellGameBootCheck(mem32_t type, mem32_t attributes, mem_ptr_t<CellGameContentSize> size, mem_list_ptr_t<u8> dirName)
{
cellGame.Warning("cellGameBootCheck(type_addr=0x%x, attributes_addr=0x%x, size_addr=0x%x, dirName_addr=0x%x)",
cellGame->Warning("cellGameBootCheck(type_addr=0x%x, attributes_addr=0x%x, size_addr=0x%x, dirName_addr=0x%x)",
type.GetAddr(), attributes.GetAddr(), size.GetAddr(), dirName.GetAddr());
if (!type.IsGood() || !attributes.IsGood() || !size.IsGood() || !dirName.IsGood())
{
cellGame.Warning("cellGameBootCheck returns CELL_GAME_ERROR_PARAM. As a result size->hddFreeSizeKB may be 0.");
cellGame->Warning("cellGameBootCheck returns CELL_GAME_ERROR_PARAM. As a result size->hddFreeSizeKB may be 0.");
return CELL_GAME_ERROR_PARAM;
}
@ -159,7 +160,7 @@ int cellGameDataCheck()
int cellGameContentPermit(mem_list_ptr_t<u8> contentInfoPath, mem_list_ptr_t<u8> usrdirPath)
{
cellGame.Warning("cellGameContentPermit(contentInfoPath_addr=0x%x, usrdirPath_addr=0x%x)",
cellGame->Warning("cellGameContentPermit(contentInfoPath_addr=0x%x, usrdirPath_addr=0x%x)",
contentInfoPath.GetAddr(), usrdirPath.GetAddr());
if (!contentInfoPath.IsGood() || !usrdirPath.IsGood())
@ -192,7 +193,7 @@ int cellGameDeleteGameData()
int cellGameGetParamInt(u32 id, mem32_t value)
{
cellGame.Warning("cellGameGetParamInt(id=%d, value_addr=0x%x)", id, value.GetAddr());
cellGame->Warning("cellGameGetParamInt(id=%d, value_addr=0x%x)", id, value.GetAddr());
if(!value.IsGood())
return CELL_GAME_ERROR_PARAM;
@ -218,7 +219,7 @@ int cellGameGetParamInt(u32 id, mem32_t value)
int cellGameGetParamString(u32 id, u32 buf_addr, u32 bufsize)
{
cellGame.Warning("cellGameGetParamString(id=%d, buf_addr=0x%x, bufsize=%d)", id, buf_addr, bufsize);
cellGame->Warning("cellGameGetParamString(id=%d, buf_addr=0x%x, bufsize=%d)", id, buf_addr, bufsize);
if(!Memory.IsGoodAddr(buf_addr))
return CELL_GAME_ERROR_PARAM;
@ -293,7 +294,7 @@ int cellGameGetLocalWebContentPath()
int cellGameContentErrorDialog(s32 type, s32 errNeedSizeKB, u32 dirName_addr)
{
cellGame.Warning("cellGameContentErrorDialog(type=%d, errNeedSizeKB=%d, dirName_addr=0x%x)", type, errNeedSizeKB, dirName_addr);
cellGame->Warning("cellGameContentErrorDialog(type=%d, errNeedSizeKB=%d, dirName_addr=0x%x)", type, errNeedSizeKB, dirName_addr);
if (Memory.IsGoodAddr(dirName_addr))
return CELL_GAME_ERROR_PARAM;
@ -313,7 +314,7 @@ int cellGameContentErrorDialog(s32 type, s32 errNeedSizeKB, u32 dirName_addr)
std::string errorMsg = fmt::Format("%s\nSpace needed: %d KB\nDirectory name: %s",
errorName.c_str(), errNeedSizeKB, dirName);
wxMessageBox(fmt::FromUTF8(errorMsg), wxGetApp().GetAppName(), wxICON_ERROR | wxOK);
rMessageBox(errorMsg, rGetApp().GetAppName(), rICON_ERROR | rOK);
return CELL_OK;
}
@ -333,25 +334,25 @@ void cellGame_init()
{
// (TODO: Disc Exchange functions missing)
cellGame.AddFunc(0xf52639ea, cellGameBootCheck);
cellGame.AddFunc(0xce4374f6, cellGamePatchCheck);
cellGame.AddFunc(0xdb9819f3, cellGameDataCheck);
cellGame.AddFunc(0x70acec67, cellGameContentPermit);
cellGame->AddFunc(0xf52639ea, cellGameBootCheck);
cellGame->AddFunc(0xce4374f6, cellGamePatchCheck);
cellGame->AddFunc(0xdb9819f3, cellGameDataCheck);
cellGame->AddFunc(0x70acec67, cellGameContentPermit);
cellGame.AddFunc(0x42a2e133, cellGameCreateGameData);
cellGame.AddFunc(0xb367c6e3, cellGameDeleteGameData);
cellGame->AddFunc(0x42a2e133, cellGameCreateGameData);
cellGame->AddFunc(0xb367c6e3, cellGameDeleteGameData);
cellGame.AddFunc(0xb7a45caf, cellGameGetParamInt);
//cellGame.AddFunc(, cellGameSetParamInt);
cellGame.AddFunc(0x3a5d726a, cellGameGetParamString);
cellGame.AddFunc(0xdaa5cd20, cellGameSetParamString);
cellGame.AddFunc(0xef9d42d5, cellGameGetSizeKB);
cellGame.AddFunc(0x2a8e6b92, cellGameGetDiscContentInfoUpdatePath);
cellGame.AddFunc(0xa80bf223, cellGameGetLocalWebContentPath);
cellGame->AddFunc(0xb7a45caf, cellGameGetParamInt);
//cellGame->AddFunc(, cellGameSetParamInt);
cellGame->AddFunc(0x3a5d726a, cellGameGetParamString);
cellGame->AddFunc(0xdaa5cd20, cellGameSetParamString);
cellGame->AddFunc(0xef9d42d5, cellGameGetSizeKB);
cellGame->AddFunc(0x2a8e6b92, cellGameGetDiscContentInfoUpdatePath);
cellGame->AddFunc(0xa80bf223, cellGameGetLocalWebContentPath);
cellGame.AddFunc(0xb0a1f8c6, cellGameContentErrorDialog);
cellGame->AddFunc(0xb0a1f8c6, cellGameContentErrorDialog);
cellGame.AddFunc(0xd24e3928, cellGameThemeInstall);
cellGame.AddFunc(0x87406734, cellGameThemeInstallFromBuffer);
//cellGame.AddFunc(, CellGameThemeInstallCallback);
cellGame->AddFunc(0xd24e3928, cellGameThemeInstall);
cellGame->AddFunc(0x87406734, cellGameThemeInstallFromBuffer);
//cellGame->AddFunc(, CellGameThemeInstallCallback);
}

358
rpcs3/Emu/SysCalls/Modules/cellGcmSys.cpp
View File

@ -8,10 +8,11 @@
#include "Emu/SysCalls/SysCalls.h"
#include "Emu/GS/GCM.h"
void cellGcmSys_init();
void cellGcmSys_load();
void cellGcmSys_unload();
Module cellGcmSys(0x0010, cellGcmSys_init, cellGcmSys_load, cellGcmSys_unload);
//void cellGcmSys_init();
//void cellGcmSys_load();
//void cellGcmSys_unload();
//Module cellGcmSys(0x0010, cellGcmSys_init, cellGcmSys_load, cellGcmSys_unload);
extern Module *cellGcmSys = nullptr;
u32 local_size = 0;
u32 local_addr = 0;
@ -67,17 +68,17 @@ u32 map_offset_pos = 0;
u32 cellGcmGetLabelAddress(u8 index)
{
cellGcmSys.Log("cellGcmGetLabelAddress(index=%d)", index);
cellGcmSys->Log("cellGcmGetLabelAddress(index=%d)", index);
return Memory.RSXCMDMem.GetStartAddr() + 0x10 * index;
}
u32 cellGcmGetReportDataAddressLocation(u32 index, u32 location)
{
cellGcmSys.Warning("cellGcmGetReportDataAddressLocation(index=%d, location=%d)", index, location);
cellGcmSys->Warning("cellGcmGetReportDataAddressLocation(index=%d, location=%d)", index, location);
if (location == CELL_GCM_LOCATION_LOCAL) {
if (index >= 2048) {
cellGcmSys.Error("cellGcmGetReportDataAddressLocation: Wrong local index (%d)", index);
cellGcmSys->Error("cellGcmGetReportDataAddressLocation: Wrong local index (%d)", index);
return 0;
}
return Memory.RSXFBMem.GetStartAddr() + index * 0x10;
@ -85,23 +86,23 @@ u32 cellGcmGetReportDataAddressLocation(u32 index, u32 location)
if (location == CELL_GCM_LOCATION_MAIN) {
if (index >= 1024*1024) {
cellGcmSys.Error("cellGcmGetReportDataAddressLocation: Wrong main index (%d)", index);
cellGcmSys->Error("cellGcmGetReportDataAddressLocation: Wrong main index (%d)", index);
return 0;
}
// TODO: It seems m_report_main_addr is not initialized
return Emu.GetGSManager().GetRender().m_report_main_addr + index * 0x10;
}
cellGcmSys.Error("cellGcmGetReportDataAddressLocation: Wrong location (%d)", location);
cellGcmSys->Error("cellGcmGetReportDataAddressLocation: Wrong location (%d)", location);
return 0;
}
u64 cellGcmGetTimeStamp(u32 index)
{
cellGcmSys.Log("cellGcmGetTimeStamp(index=%d)", index);
cellGcmSys->Log("cellGcmGetTimeStamp(index=%d)", index);
if (index >= 2048) {
cellGcmSys.Error("cellGcmGetTimeStamp: Wrong local index (%d)", index);
cellGcmSys->Error("cellGcmGetTimeStamp: Wrong local index (%d)", index);
return 0;
}
return Memory.Read64(Memory.RSXFBMem.GetStartAddr() + index * 0x10);
@ -121,10 +122,10 @@ int cellGcmGetNotifyDataAddress()
u32 cellGcmGetReport(u32 type, u32 index)
{
cellGcmSys.Warning("cellGcmGetReport(type=%d, index=%d)", type, index);
cellGcmSys->Warning("cellGcmGetReport(type=%d, index=%d)", type, index);
if (index >= 2048) {
cellGcmSys.Error("cellGcmGetReport: Wrong local index (%d)", index);
cellGcmSys->Error("cellGcmGetReport: Wrong local index (%d)", index);
return 0;
}
// TODO: What does the argument type do?
@ -133,10 +134,10 @@ u32 cellGcmGetReport(u32 type, u32 index)
u32 cellGcmGetReportDataAddress(u32 index)
{
cellGcmSys.Warning("cellGcmGetReportDataAddress(index=%d)", index);
cellGcmSys->Warning("cellGcmGetReportDataAddress(index=%d)", index);
if (index >= 2048) {
cellGcmSys.Error("cellGcmGetReportDataAddress: Wrong local index (%d)", index);
cellGcmSys->Error("cellGcmGetReportDataAddress: Wrong local index (%d)", index);
return 0;
}
return Memory.RSXFBMem.GetStartAddr() + index * 0x10;
@ -144,11 +145,11 @@ u32 cellGcmGetReportDataAddress(u32 index)
u32 cellGcmGetReportDataLocation(u32 index, u32 location)
{
cellGcmSys.Warning("cellGcmGetReportDataLocation(index=%d, location=%d)", index, location);
cellGcmSys->Warning("cellGcmGetReportDataLocation(index=%d, location=%d)", index, location);
if (location == CELL_GCM_LOCATION_LOCAL) {
if (index >= 2048) {
cellGcmSys.Error("cellGcmGetReportDataLocation: Wrong local index (%d)", index);
cellGcmSys->Error("cellGcmGetReportDataLocation: Wrong local index (%d)", index);
return 0;
}
return Memory.Read32(Memory.RSXFBMem.GetStartAddr() + index * 0x10 + 0x8);
@ -156,24 +157,24 @@ u32 cellGcmGetReportDataLocation(u32 index, u32 location)
if (location == CELL_GCM_LOCATION_MAIN) {
if (index >= 1024*1024) {
cellGcmSys.Error("cellGcmGetReportDataLocation: Wrong main index (%d)", index);
cellGcmSys->Error("cellGcmGetReportDataLocation: Wrong main index (%d)", index);
return 0;
}
// TODO: It seems m_report_main_addr is not initialized
return Memory.Read32(Emu.GetGSManager().GetRender().m_report_main_addr + index * 0x10 + 0x8);
}
cellGcmSys.Error("cellGcmGetReportDataLocation: Wrong location (%d)", location);
cellGcmSys->Error("cellGcmGetReportDataLocation: Wrong location (%d)", location);
return 0;
}
u64 cellGcmGetTimeStampLocation(u32 index, u32 location)
{
cellGcmSys.Warning("cellGcmGetTimeStampLocation(index=%d, location=%d)", index, location);
cellGcmSys->Warning("cellGcmGetTimeStampLocation(index=%d, location=%d)", index, location);
if (location == CELL_GCM_LOCATION_LOCAL) {
if (index >= 2048) {
cellGcmSys.Error("cellGcmGetTimeStampLocation: Wrong local index (%d)", index);
cellGcmSys->Error("cellGcmGetTimeStampLocation: Wrong local index (%d)", index);
return 0;
}
return Memory.Read64(Memory.RSXFBMem.GetStartAddr() + index * 0x10);
@ -181,14 +182,14 @@ u64 cellGcmGetTimeStampLocation(u32 index, u32 location)
if (location == CELL_GCM_LOCATION_MAIN) {
if (index >= 1024*1024) {
cellGcmSys.Error("cellGcmGetTimeStampLocation: Wrong main index (%d)", index);
cellGcmSys->Error("cellGcmGetTimeStampLocation: Wrong main index (%d)", index);
return 0;
}
// TODO: It seems m_report_main_addr is not initialized
return Memory.Read64(Emu.GetGSManager().GetRender().m_report_main_addr + index * 0x10);
}
cellGcmSys.Error("cellGcmGetTimeStampLocation: Wrong location (%d)", location);
cellGcmSys->Error("cellGcmGetTimeStampLocation: Wrong location (%d)", location);
return 0;
}
@ -198,32 +199,32 @@ u64 cellGcmGetTimeStampLocation(u32 index, u32 location)
u32 cellGcmGetControlRegister()
{
cellGcmSys.Log("cellGcmGetControlRegister()");
cellGcmSys->Log("cellGcmGetControlRegister()");
return gcm_info.control_addr;
}
u32 cellGcmGetDefaultCommandWordSize()
{
cellGcmSys.Log("cellGcmGetDefaultCommandWordSize()");
cellGcmSys->Log("cellGcmGetDefaultCommandWordSize()");
return 0x400;
}
u32 cellGcmGetDefaultSegmentWordSize()
{
cellGcmSys.Log("cellGcmGetDefaultSegmentWordSize()");
cellGcmSys->Log("cellGcmGetDefaultSegmentWordSize()");
return 0x100;
}
int cellGcmInitDefaultFifoMode(s32 mode)
{
cellGcmSys.Warning("cellGcmInitDefaultFifoMode(mode=%d)", mode);
cellGcmSys->Warning("cellGcmInitDefaultFifoMode(mode=%d)", mode);
return CELL_OK;
}
int cellGcmSetDefaultFifoSize(u32 bufferSize, u32 segmentSize)
{
cellGcmSys.Warning("cellGcmSetDefaultFifoSize(bufferSize=0x%x, segmentSize=0x%x)", bufferSize, segmentSize);
cellGcmSys->Warning("cellGcmSetDefaultFifoSize(bufferSize=0x%x, segmentSize=0x%x)", bufferSize, segmentSize);
return CELL_OK;
}
@ -233,11 +234,11 @@ int cellGcmSetDefaultFifoSize(u32 bufferSize, u32 segmentSize)
int cellGcmBindTile(u8 index)
{
cellGcmSys.Warning("cellGcmBindTile(index=%d)", index);
cellGcmSys->Warning("cellGcmBindTile(index=%d)", index);
if (index >= RSXThread::m_tiles_count)
{
cellGcmSys.Error("cellGcmBindTile : CELL_GCM_ERROR_INVALID_VALUE");
cellGcmSys->Error("cellGcmBindTile : CELL_GCM_ERROR_INVALID_VALUE");
return CELL_GCM_ERROR_INVALID_VALUE;
}
@ -249,11 +250,11 @@ int cellGcmBindTile(u8 index)
int cellGcmBindZcull(u8 index)
{
cellGcmSys.Warning("cellGcmBindZcull(index=%d)", index);
cellGcmSys->Warning("cellGcmBindZcull(index=%d)", index);
if (index >= RSXThread::m_zculls_count)
{
cellGcmSys.Error("cellGcmBindZcull : CELL_GCM_ERROR_INVALID_VALUE");
cellGcmSys->Error("cellGcmBindZcull : CELL_GCM_ERROR_INVALID_VALUE");
return CELL_GCM_ERROR_INVALID_VALUE;
}
@ -265,11 +266,11 @@ int cellGcmBindZcull(u8 index)
int cellGcmGetConfiguration(mem_ptr_t<CellGcmConfig> config)
{
cellGcmSys.Log("cellGcmGetConfiguration(config_addr=0x%x)", config.GetAddr());
cellGcmSys->Log("cellGcmGetConfiguration(config_addr=0x%x)", config.GetAddr());
if (!config.IsGood())
{
cellGcmSys.Error("cellGcmGetConfiguration : CELL_EFAULT");
cellGcmSys->Error("cellGcmGetConfiguration : CELL_EFAULT");
return CELL_EFAULT;
}
@ -280,15 +281,14 @@ int cellGcmGetConfiguration(mem_ptr_t<CellGcmConfig> config)
int cellGcmGetFlipStatus()
{
cellGcmSys.Log("cellGcmGetFlipStatus()");
cellGcmSys->Log("cellGcmGetFlipStatus()");
return Emu.GetGSManager().GetRender().m_flip_status;
}
u32 cellGcmGetTiledPitchSize(u32 size)
{
cellGcmSys.Warning("cellGcmGetTiledPitchSize(size=%d)", size);
cellGcmSys->Warning("cellGcmGetTiledPitchSize(size=%d)", size);
// TODO:
return size;
@ -296,10 +296,10 @@ u32 cellGcmGetTiledPitchSize(u32 size)
int cellGcmInit(u32 context_addr, u32 cmdSize, u32 ioSize, u32 ioAddress)
{
cellGcmSys.Warning("cellGcmInit(context_addr=0x%x,cmdSize=0x%x,ioSize=0x%x,ioAddress=0x%x)", context_addr, cmdSize, ioSize, ioAddress);
cellGcmSys->Warning("cellGcmInit(context_addr=0x%x,cmdSize=0x%x,ioSize=0x%x,ioAddress=0x%x)", context_addr, cmdSize, ioSize, ioAddress);
if(!cellGcmSys.IsLoaded())
cellGcmSys.Load();
if(!cellGcmSys->IsLoaded())
cellGcmSys->Load();
if(!local_size && !local_addr)
{
@ -308,14 +308,14 @@ int cellGcmInit(u32 context_addr, u32 cmdSize, u32 ioSize, u32 ioAddress)
Memory.RSXFBMem.AllocAlign(local_size);
}
cellGcmSys.Warning("*** local memory(addr=0x%x, size=0x%x)", local_addr, local_size);
cellGcmSys->Warning("*** local memory(addr=0x%x, size=0x%x)", local_addr, local_size);
InitOffsetTable();
Memory.MemoryBlocks.push_back(Memory.RSXIOMem.SetRange(0x50000000, 0x10000000/*256MB*/));//TODO: implement allocateAdressSpace in memoryBase
if(cellGcmMapEaIoAddress(ioAddress, 0, ioSize) != CELL_OK)
{
Memory.MemoryBlocks.pop_back();
cellGcmSys.Error("cellGcmInit : CELL_GCM_ERROR_FAILURE");
cellGcmSys->Error("cellGcmInit : CELL_GCM_ERROR_FAILURE");
return CELL_GCM_ERROR_FAILURE;
}
@ -363,7 +363,7 @@ int cellGcmInit(u32 context_addr, u32 cmdSize, u32 ioSize, u32 ioAddress)
int cellGcmResetFlipStatus()
{
cellGcmSys.Log("cellGcmResetFlipStatus()");
cellGcmSys->Log("cellGcmResetFlipStatus()");
Emu.GetGSManager().GetRender().m_flip_status = CELL_GCM_DISPLAY_FLIP_STATUS_WAITING;
@ -372,7 +372,7 @@ int cellGcmResetFlipStatus()
int cellGcmSetDebugOutputLevel(int level)
{
cellGcmSys.Warning("cellGcmSetDebugOutputLevel(level=%d)", level);
cellGcmSys->Warning("cellGcmSetDebugOutputLevel(level=%d)", level);
switch (level)
{
@ -390,11 +390,11 @@ int cellGcmSetDebugOutputLevel(int level)
int cellGcmSetDisplayBuffer(u32 id, u32 offset, u32 pitch, u32 width, u32 height)
{
cellGcmSys.Log("cellGcmSetDisplayBuffer(id=0x%x,offset=0x%x,pitch=%d,width=%d,height=%d)", id, offset, width ? pitch / width : pitch, width, height);
cellGcmSys->Log("cellGcmSetDisplayBuffer(id=0x%x,offset=0x%x,pitch=%d,width=%d,height=%d)", id, offset, width ? pitch / width : pitch, width, height);
if (id > 7)
{
cellGcmSys.Error("cellGcmSetDisplayBuffer : CELL_EINVAL");
cellGcmSys->Error("cellGcmSetDisplayBuffer : CELL_EINVAL");
return CELL_EINVAL;
}
@ -415,7 +415,7 @@ int cellGcmSetDisplayBuffer(u32 id, u32 offset, u32 pitch, u32 width, u32 height
int cellGcmSetFlip(mem_ptr_t<CellGcmContextData> ctxt, u32 id)
{
cellGcmSys.Log("cellGcmSetFlip(ctx=0x%x, id=0x%x)", ctxt.GetAddr(), id);
cellGcmSys->Log("cellGcmSetFlip(ctx=0x%x, id=0x%x)", ctxt.GetAddr(), id);
int res = cellGcmSetPrepareFlip(ctxt, id);
return res < 0 ? CELL_GCM_ERROR_FAILURE : CELL_OK;
@ -423,11 +423,11 @@ int cellGcmSetFlip(mem_ptr_t<CellGcmContextData> ctxt, u32 id)
int cellGcmSetFlipHandler(u32 handler_addr)
{
cellGcmSys.Warning("cellGcmSetFlipHandler(handler_addr=%d)", handler_addr);
cellGcmSys->Warning("cellGcmSetFlipHandler(handler_addr=%d)", handler_addr);
if (handler_addr != 0 && !Memory.IsGoodAddr(handler_addr))
{
cellGcmSys.Error("cellGcmSetFlipHandler : CELL_EFAULT");
cellGcmSys->Error("cellGcmSetFlipHandler : CELL_EFAULT");
return CELL_EFAULT;
}
@ -437,7 +437,7 @@ int cellGcmSetFlipHandler(u32 handler_addr)
int cellGcmSetFlipMode(u32 mode)
{
cellGcmSys.Warning("cellGcmSetFlipMode(mode=%d)", mode);
cellGcmSys->Warning("cellGcmSetFlipMode(mode=%d)", mode);
switch (mode)
{
@ -456,18 +456,18 @@ int cellGcmSetFlipMode(u32 mode)
void cellGcmSetFlipStatus()
{
cellGcmSys.Warning("cellGcmSetFlipStatus()");
cellGcmSys->Warning("cellGcmSetFlipStatus()");
Emu.GetGSManager().GetRender().m_flip_status = 0;
}
int cellGcmSetPrepareFlip(mem_ptr_t<CellGcmContextData> ctxt, u32 id)
{
cellGcmSys.Log("cellGcmSetPrepareFlip(ctx=0x%x, id=0x%x)", ctxt.GetAddr(), id);
cellGcmSys->Log("cellGcmSetPrepareFlip(ctx=0x%x, id=0x%x)", ctxt.GetAddr(), id);
if(id >= 8)
{
cellGcmSys.Error("cellGcmSetPrepareFlip : CELL_GCM_ERROR_FAILURE");
cellGcmSys->Error("cellGcmSetPrepareFlip : CELL_GCM_ERROR_FAILURE");
return CELL_GCM_ERROR_FAILURE;
}
@ -508,7 +508,7 @@ int cellGcmSetPrepareFlip(mem_ptr_t<CellGcmContextData> ctxt, u32 id)
int cellGcmSetSecondVFrequency(u32 freq)
{
cellGcmSys.Warning("cellGcmSetSecondVFrequency(level=%d)", freq);
cellGcmSys->Warning("cellGcmSetSecondVFrequency(level=%d)", freq);
switch (freq)
{
@ -526,30 +526,30 @@ int cellGcmSetSecondVFrequency(u32 freq)
int cellGcmSetTileInfo(u8 index, u8 location, u32 offset, u32 size, u32 pitch, u8 comp, u16 base, u8 bank)
{
cellGcmSys.Warning("cellGcmSetTileInfo(index=%d, location=%d, offset=%d, size=%d, pitch=%d, comp=%d, base=%d, bank=%d)",
cellGcmSys->Warning("cellGcmSetTileInfo(index=%d, location=%d, offset=%d, size=%d, pitch=%d, comp=%d, base=%d, bank=%d)",
index, location, offset, size, pitch, comp, base, bank);
if (index >= RSXThread::m_tiles_count || base >= 800 || bank >= 4)
{
cellGcmSys.Error("cellGcmSetTileInfo : CELL_GCM_ERROR_INVALID_VALUE");
cellGcmSys->Error("cellGcmSetTileInfo : CELL_GCM_ERROR_INVALID_VALUE");
return CELL_GCM_ERROR_INVALID_VALUE;
}
if (offset & 0xffff || size & 0xffff || pitch & 0xf)
{
cellGcmSys.Error("cellGcmSetTileInfo : CELL_GCM_ERROR_INVALID_ALIGNMENT");
cellGcmSys->Error("cellGcmSetTileInfo : CELL_GCM_ERROR_INVALID_ALIGNMENT");
return CELL_GCM_ERROR_INVALID_ALIGNMENT;
}
if (location >= 2 || (comp != 0 && (comp < 7 || comp > 12)))
{
cellGcmSys.Error("cellGcmSetTileInfo : CELL_GCM_ERROR_INVALID_ALIGNMENT");
cellGcmSys->Error("cellGcmSetTileInfo : CELL_GCM_ERROR_INVALID_ALIGNMENT");
return CELL_GCM_ERROR_INVALID_ENUM;
}
if (comp)
{
cellGcmSys.Error("cellGcmSetTileInfo: bad compression mode! (%d)", comp);
cellGcmSys->Error("cellGcmSetTileInfo: bad compression mode! (%d)", comp);
}
auto& tile = Emu.GetGSManager().GetRender().m_tiles[index];
@ -567,7 +567,7 @@ int cellGcmSetTileInfo(u8 index, u8 location, u32 offset, u32 size, u32 pitch, u
u32 cellGcmSetUserHandler(u32 handler)
{
cellGcmSys.Warning("cellGcmSetUserHandler(handler=0x%x)", handler);
cellGcmSys->Warning("cellGcmSetUserHandler(handler=0x%x)", handler);
return handler;
}
@ -579,7 +579,7 @@ int cellGcmSetVBlankHandler()
int cellGcmSetWaitFlip(mem_ptr_t<CellGcmContextData> ctxt)
{
cellGcmSys.Log("cellGcmSetWaitFlip(ctx=0x%x)", ctxt.GetAddr());
cellGcmSys->Log("cellGcmSetWaitFlip(ctx=0x%x)", ctxt.GetAddr());
GSLockCurrent lock(GS_LOCK_WAIT_FLIP);
return CELL_OK;
@ -587,12 +587,12 @@ int cellGcmSetWaitFlip(mem_ptr_t<CellGcmContextData> ctxt)
int cellGcmSetZcull(u8 index, u32 offset, u32 width, u32 height, u32 cullStart, u32 zFormat, u32 aaFormat, u32 zCullDir, u32 zCullFormat, u32 sFunc, u32 sRef, u32 sMask)
{
cellGcmSys.Warning("TODO: cellGcmSetZcull(index=%d, offset=0x%x, width=%d, height=%d, cullStart=0x%x, zFormat=0x%x, aaFormat=0x%x, zCullDir=0x%x, zCullFormat=0x%x, sFunc=0x%x, sRef=0x%x, sMask=0x%x)",
cellGcmSys->Warning("TODO: cellGcmSetZcull(index=%d, offset=0x%x, width=%d, height=%d, cullStart=0x%x, zFormat=0x%x, aaFormat=0x%x, zCullDir=0x%x, zCullFormat=0x%x, sFunc=0x%x, sRef=0x%x, sMask=0x%x)",
index, offset, width, height, cullStart, zFormat, aaFormat, zCullDir, zCullFormat, sFunc, sRef, sMask);
if (index >= RSXThread::m_zculls_count)
{
cellGcmSys.Error("cellGcmSetZcull : CELL_GCM_ERROR_INVALID_VALUE");
cellGcmSys->Error("cellGcmSetZcull : CELL_GCM_ERROR_INVALID_VALUE");
return CELL_GCM_ERROR_INVALID_VALUE;
}
@ -616,11 +616,11 @@ int cellGcmSetZcull(u8 index, u32 offset, u32 width, u32 height, u32 cullStart,
int cellGcmUnbindTile(u8 index)
{
cellGcmSys.Warning("cellGcmUnbindTile(index=%d)", index);
cellGcmSys->Warning("cellGcmUnbindTile(index=%d)", index);
if (index >= RSXThread::m_tiles_count)
{
cellGcmSys.Error("cellGcmUnbindTile : CELL_GCM_ERROR_INVALID_VALUE");
cellGcmSys->Error("cellGcmUnbindTile : CELL_GCM_ERROR_INVALID_VALUE");
return CELL_GCM_ERROR_INVALID_VALUE;
}
@ -632,11 +632,11 @@ int cellGcmUnbindTile(u8 index)
int cellGcmUnbindZcull(u8 index)
{
cellGcmSys.Warning("cellGcmUnbindZcull(index=%d)", index);
cellGcmSys->Warning("cellGcmUnbindZcull(index=%d)", index);
if (index >= 8)
{
cellGcmSys.Error("cellGcmUnbindZcull : CELL_EINVAL");
cellGcmSys->Error("cellGcmUnbindZcull : CELL_EINVAL");
return CELL_EINVAL;
}
@ -648,29 +648,29 @@ int cellGcmUnbindZcull(u8 index)
u32 cellGcmGetTileInfo()
{
cellGcmSys.Warning("cellGcmGetTileInfo()");
cellGcmSys->Warning("cellGcmGetTileInfo()");
return Emu.GetGSManager().GetRender().m_tiles_addr;
}
u32 cellGcmGetZcullInfo()
{
cellGcmSys.Warning("cellGcmGetZcullInfo()");
cellGcmSys->Warning("cellGcmGetZcullInfo()");
return Emu.GetGSManager().GetRender().m_zculls_addr;
}
u32 cellGcmGetDisplayInfo()
{
cellGcmSys.Warning("cellGcmGetDisplayInfo() = 0x%x", Emu.GetGSManager().GetRender().m_gcm_buffers_addr);
cellGcmSys->Warning("cellGcmGetDisplayInfo() = 0x%x", Emu.GetGSManager().GetRender().m_gcm_buffers_addr);
return Emu.GetGSManager().GetRender().m_gcm_buffers_addr;
}
int cellGcmGetCurrentDisplayBufferId(u32 id_addr)
{
cellGcmSys.Warning("cellGcmGetCurrentDisplayBufferId(id_addr=0x%x)", id_addr);
cellGcmSys->Warning("cellGcmGetCurrentDisplayBufferId(id_addr=0x%x)", id_addr);
if (!Memory.IsGoodAddr(id_addr))
{
cellGcmSys.Error("cellGcmGetCurrentDisplayBufferId : CELL_EFAULT");
cellGcmSys->Error("cellGcmGetCurrentDisplayBufferId : CELL_EFAULT");
return CELL_EFAULT;
}
@ -780,7 +780,7 @@ void InitOffsetTable()
int32_t cellGcmAddressToOffset(u64 address, mem32_t offset)
{
cellGcmSys.Log("cellGcmAddressToOffset(address=0x%x,offset_addr=0x%x)", address, offset.GetAddr());
cellGcmSys->Log("cellGcmAddressToOffset(address=0x%x,offset_addr=0x%x)", address, offset.GetAddr());
if (address >= 0xD0000000/*not on main memory or local*/)
return CELL_GCM_ERROR_FAILURE;
@ -838,7 +838,7 @@ int32_t cellGcmIoOffsetToAddress(u32 ioOffset, u64 address)
int32_t cellGcmMapEaIoAddress(const u32 ea, const u32 io, const u32 size)
{
cellGcmSys.Warning("cellGcmMapEaIoAddress(ea=0x%x, io=0x%x, size=0x%x)", ea, io, size);
cellGcmSys->Warning("cellGcmMapEaIoAddress(ea=0x%x, io=0x%x, size=0x%x)", ea, io, size);
if ((ea & 0xFFFFF) || (io & 0xFFFFF) || (size & 0xFFFFF)) return CELL_GCM_ERROR_FAILURE;
@ -854,7 +854,7 @@ int32_t cellGcmMapEaIoAddress(const u32 ea, const u32 io, const u32 size)
}
else
{
cellGcmSys.Error("cellGcmMapEaIoAddress : CELL_GCM_ERROR_FAILURE");
cellGcmSys->Error("cellGcmMapEaIoAddress : CELL_GCM_ERROR_FAILURE");
return CELL_GCM_ERROR_FAILURE;
}
@ -863,7 +863,7 @@ int32_t cellGcmMapEaIoAddress(const u32 ea, const u32 io, const u32 size)
int32_t cellGcmMapEaIoAddressWithFlags(const u32 ea, const u32 io, const u32 size, const u32 flags)
{
cellGcmSys.Warning("cellGcmMapEaIoAddressWithFlags(ea=0x%x, io=0x%x, size=0x%x, flags=0x%x)", ea, io, size, flags);
cellGcmSys->Warning("cellGcmMapEaIoAddressWithFlags(ea=0x%x, io=0x%x, size=0x%x, flags=0x%x)", ea, io, size, flags);
return cellGcmMapEaIoAddress(ea, io, size); // TODO: strict ordering
}
@ -879,7 +879,7 @@ int32_t cellGcmMapLocalMemory(u64 address, u64 size)
}
else
{
cellGcmSys.Error("RSX local memory already mapped");
cellGcmSys->Error("RSX local memory already mapped");
return CELL_GCM_ERROR_FAILURE;
}
@ -888,7 +888,7 @@ int32_t cellGcmMapLocalMemory(u64 address, u64 size)
int32_t cellGcmMapMainMemory(u64 ea, u32 size, mem32_t offset)
{
cellGcmSys.Warning("cellGcmMapMainMemory(ea=0x%x,size=0x%x,offset_addr=0x%x)", ea, size, offset.GetAddr());
cellGcmSys->Warning("cellGcmMapMainMemory(ea=0x%x,size=0x%x,offset_addr=0x%x)", ea, size, offset.GetAddr());
u64 io;
@ -911,7 +911,7 @@ int32_t cellGcmMapMainMemory(u64 ea, u32 size, mem32_t offset)
}
else
{
cellGcmSys.Error("cellGcmMapMainMemory : CELL_GCM_ERROR_NO_IO_PAGE_TABLE");
cellGcmSys->Error("cellGcmMapMainMemory : CELL_GCM_ERROR_NO_IO_PAGE_TABLE");
return CELL_GCM_ERROR_NO_IO_PAGE_TABLE;
}
@ -924,13 +924,13 @@ int32_t cellGcmReserveIoMapSize(const u32 size)
{
if (size & 0xFFFFF)
{
cellGcmSys.Error("cellGcmReserveIoMapSize : CELL_GCM_ERROR_INVALID_ALIGNMENT");
cellGcmSys->Error("cellGcmReserveIoMapSize : CELL_GCM_ERROR_INVALID_ALIGNMENT");
return CELL_GCM_ERROR_INVALID_ALIGNMENT;
}
if (size > cellGcmGetMaxIoMapSize())
{
cellGcmSys.Error("cellGcmReserveIoMapSize : CELL_GCM_ERROR_INVALID_VALUE");
cellGcmSys->Error("cellGcmReserveIoMapSize : CELL_GCM_ERROR_INVALID_VALUE");
return CELL_GCM_ERROR_INVALID_VALUE;
}
@ -955,7 +955,7 @@ int32_t cellGcmUnmapEaIoAddress(u64 ea)
}
else
{
cellGcmSys.Error("cellGcmUnmapEaIoAddress : CELL_GCM_ERROR_FAILURE");
cellGcmSys->Error("cellGcmUnmapEaIoAddress : CELL_GCM_ERROR_FAILURE");
return CELL_GCM_ERROR_FAILURE;
}
@ -979,7 +979,7 @@ int32_t cellGcmUnmapIoAddress(u64 io)
}
else
{
cellGcmSys.Error("cellGcmUnmapIoAddress : CELL_GCM_ERROR_FAILURE");
cellGcmSys->Error("cellGcmUnmapIoAddress : CELL_GCM_ERROR_FAILURE");
return CELL_GCM_ERROR_FAILURE;
}
@ -991,13 +991,13 @@ int32_t cellGcmUnreserveIoMapSize(u32 size)
if (size & 0xFFFFF)
{
cellGcmSys.Error("cellGcmReserveIoMapSize : CELL_GCM_ERROR_INVALID_ALIGNMENT");
cellGcmSys->Error("cellGcmReserveIoMapSize : CELL_GCM_ERROR_INVALID_ALIGNMENT");
return CELL_GCM_ERROR_INVALID_ALIGNMENT;
}
if (size > Memory.RSXIOMem.GetReservedAmount())
{
cellGcmSys.Error("cellGcmReserveIoMapSize : CELL_GCM_ERROR_INVALID_VALUE");
cellGcmSys->Error("cellGcmReserveIoMapSize : CELL_GCM_ERROR_INVALID_VALUE");
return CELL_GCM_ERROR_INVALID_VALUE;
}
@ -1051,7 +1051,7 @@ int cellGcmSetCursorImageOffset(u32 offset)
void cellGcmSetDefaultCommandBuffer()
{
cellGcmSys.Warning("cellGcmSetDefaultCommandBuffer()");
cellGcmSys->Warning("cellGcmSetDefaultCommandBuffer()");
Memory.Write32(Emu.GetGSManager().GetRender().m_ctxt_addr, gcm_info.context_addr);
}
@ -1066,7 +1066,7 @@ int cellGcmSetFlipCommand(u32 ctx, u32 id)
s64 cellGcmFunc15()
{
cellGcmSys.Error("cellGcmFunc15()");
cellGcmSys->Error("cellGcmFunc15()");
return 0;
}
@ -1079,31 +1079,31 @@ int cellGcmSetFlipCommandWithWaitLabel(u32 ctx, u32 id, u32 label_index, u32 lab
int cellGcmSetTile(u8 index, u8 location, u32 offset, u32 size, u32 pitch, u8 comp, u16 base, u8 bank)
{
cellGcmSys.Warning("cellGcmSetTile(index=%d, location=%d, offset=%d, size=%d, pitch=%d, comp=%d, base=%d, bank=%d)",
cellGcmSys->Warning("cellGcmSetTile(index=%d, location=%d, offset=%d, size=%d, pitch=%d, comp=%d, base=%d, bank=%d)",
index, location, offset, size, pitch, comp, base, bank);
// Copied form cellGcmSetTileInfo
if(index >= RSXThread::m_tiles_count || base >= 800 || bank >= 4)
{
cellGcmSys.Error("cellGcmSetTile : CELL_GCM_ERROR_INVALID_VALUE");
cellGcmSys->Error("cellGcmSetTile : CELL_GCM_ERROR_INVALID_VALUE");
return CELL_GCM_ERROR_INVALID_VALUE;
}
if(offset & 0xffff || size & 0xffff || pitch & 0xf)
{
cellGcmSys.Error("cellGcmSetTile : CELL_GCM_ERROR_INVALID_ALIGNMENT");
cellGcmSys->Error("cellGcmSetTile : CELL_GCM_ERROR_INVALID_ALIGNMENT");
return CELL_GCM_ERROR_INVALID_ALIGNMENT;
}
if(location >= 2 || (comp != 0 && (comp < 7 || comp > 12)))
{
cellGcmSys.Error("cellGcmSetTile : CELL_GCM_ERROR_INVALID_ENUM");
cellGcmSys->Error("cellGcmSetTile : CELL_GCM_ERROR_INVALID_ENUM");
return CELL_GCM_ERROR_INVALID_ENUM;
}
if(comp)
{
cellGcmSys.Error("cellGcmSetTile: bad comp! (%d)", comp);
cellGcmSys->Error("cellGcmSetTile: bad comp! (%d)", comp);
}
auto& tile = Emu.GetGSManager().GetRender().m_tiles[index];
@ -1124,105 +1124,105 @@ int cellGcmSetTile(u8 index, u8 location, u32 offset, u32 size, u32 pitch, u8 co
void cellGcmSys_init()
{
// Data Retrieval
cellGcmSys.AddFunc(0xc8f3bd09, cellGcmGetCurrentField);
cellGcmSys.AddFunc(0xf80196c1, cellGcmGetLabelAddress);
cellGcmSys.AddFunc(0x21cee035, cellGcmGetNotifyDataAddress);
cellGcmSys.AddFunc(0x99d397ac, cellGcmGetReport);
cellGcmSys.AddFunc(0x9a0159af, cellGcmGetReportDataAddress);
cellGcmSys.AddFunc(0x8572bce2, cellGcmGetReportDataAddressLocation);
cellGcmSys.AddFunc(0xa6b180ac, cellGcmGetReportDataLocation);
cellGcmSys.AddFunc(0x5a41c10f, cellGcmGetTimeStamp);
cellGcmSys.AddFunc(0x2ad4951b, cellGcmGetTimeStampLocation);
cellGcmSys->AddFunc(0xc8f3bd09, cellGcmGetCurrentField);
cellGcmSys->AddFunc(0xf80196c1, cellGcmGetLabelAddress);
cellGcmSys->AddFunc(0x21cee035, cellGcmGetNotifyDataAddress);
cellGcmSys->AddFunc(0x99d397ac, cellGcmGetReport);
cellGcmSys->AddFunc(0x9a0159af, cellGcmGetReportDataAddress);
cellGcmSys->AddFunc(0x8572bce2, cellGcmGetReportDataAddressLocation);
cellGcmSys->AddFunc(0xa6b180ac, cellGcmGetReportDataLocation);
cellGcmSys->AddFunc(0x5a41c10f, cellGcmGetTimeStamp);
cellGcmSys->AddFunc(0x2ad4951b, cellGcmGetTimeStampLocation);
// Command Buffer Control
cellGcmSys.AddFunc(0xa547adde, cellGcmGetControlRegister);
cellGcmSys.AddFunc(0x5e2ee0f0, cellGcmGetDefaultCommandWordSize);
cellGcmSys.AddFunc(0x8cdf8c70, cellGcmGetDefaultSegmentWordSize);
cellGcmSys.AddFunc(0xcaabd992, cellGcmInitDefaultFifoMode);
cellGcmSys.AddFunc(0x9ba451e4, cellGcmSetDefaultFifoSize);
//cellGcmSys.AddFunc(, cellGcmReserveMethodSize);
//cellGcmSys.AddFunc(, cellGcmResetDefaultCommandBuffer);
//cellGcmSys.AddFunc(, cellGcmSetupContextData);
//cellGcmSys.AddFunc(, cellGcmCallbackForSnc);
//cellGcmSys.AddFunc(, cellGcmFinish);
//cellGcmSys.AddFunc(, cellGcmFlush);
cellGcmSys->AddFunc(0xa547adde, cellGcmGetControlRegister);
cellGcmSys->AddFunc(0x5e2ee0f0, cellGcmGetDefaultCommandWordSize);
cellGcmSys->AddFunc(0x8cdf8c70, cellGcmGetDefaultSegmentWordSize);
cellGcmSys->AddFunc(0xcaabd992, cellGcmInitDefaultFifoMode);
cellGcmSys->AddFunc(0x9ba451e4, cellGcmSetDefaultFifoSize);
//cellGcmSys->AddFunc(, cellGcmReserveMethodSize);
//cellGcmSys->AddFunc(, cellGcmResetDefaultCommandBuffer);
//cellGcmSys->AddFunc(, cellGcmSetupContextData);
//cellGcmSys->AddFunc(, cellGcmCallbackForSnc);
//cellGcmSys->AddFunc(, cellGcmFinish);
//cellGcmSys->AddFunc(, cellGcmFlush);
// Hardware Resource Management
cellGcmSys.AddFunc(0x4524cccd, cellGcmBindTile);
cellGcmSys.AddFunc(0x9dc04436, cellGcmBindZcull);
cellGcmSys.AddFunc(0x1f61b3ff, cellGcmDumpGraphicsError);
cellGcmSys.AddFunc(0xe315a0b2, cellGcmGetConfiguration);
cellGcmSys.AddFunc(0x371674cf, cellGcmGetDisplayBufferByFlipIndex);
cellGcmSys.AddFunc(0x72a577ce, cellGcmGetFlipStatus);
cellGcmSys.AddFunc(0x63387071, cellGcmgetLastFlipTime);
cellGcmSys.AddFunc(0x23ae55a3, cellGcmGetLastSecondVTime);
cellGcmSys.AddFunc(0x055bd74d, cellGcmGetTiledPitchSize);
cellGcmSys.AddFunc(0x723bbc7e, cellGcmGetVBlankCount);
cellGcmSys.AddFunc(0x15bae46b, cellGcmInit);
cellGcmSys.AddFunc(0xfce9e764, cellGcmInitSystemMode);
cellGcmSys.AddFunc(0xb2e761d4, cellGcmResetFlipStatus);
cellGcmSys.AddFunc(0x51c9d62b, cellGcmSetDebugOutputLevel);
cellGcmSys.AddFunc(0xa53d12ae, cellGcmSetDisplayBuffer);
cellGcmSys.AddFunc(0xdc09357e, cellGcmSetFlip);
cellGcmSys.AddFunc(0xa41ef7e8, cellGcmSetFlipHandler);
cellGcmSys.AddFunc(0xacee8542, cellGcmSetFlipImmediate);
cellGcmSys.AddFunc(0x4ae8d215, cellGcmSetFlipMode);
cellGcmSys.AddFunc(0xa47c09ff, cellGcmSetFlipStatus);
cellGcmSys.AddFunc(0xd01b570d, cellGcmSetGraphicsHandler);
cellGcmSys.AddFunc(0x0b4b62d5, cellGcmSetPrepareFlip);
cellGcmSys.AddFunc(0x0a862772, cellGcmSetQueueHandler);
cellGcmSys.AddFunc(0x4d7ce993, cellGcmSetSecondVFrequency);
cellGcmSys.AddFunc(0xdc494430, cellGcmSetSecondVHandler);
cellGcmSys.AddFunc(0xbd100dbc, cellGcmSetTileInfo);
cellGcmSys.AddFunc(0x06edea9e, cellGcmSetUserHandler);
cellGcmSys.AddFunc(0xffe0160e, cellGcmSetVBlankFrequency);
cellGcmSys.AddFunc(0xa91b0402, cellGcmSetVBlankHandler);
cellGcmSys.AddFunc(0x983fb9aa, cellGcmSetWaitFlip);
cellGcmSys.AddFunc(0xd34a420d, cellGcmSetZcull);
cellGcmSys.AddFunc(0x25b40ab4, cellGcmSortRemapEaIoAddress);
cellGcmSys.AddFunc(0xd9b7653e, cellGcmUnbindTile);
cellGcmSys.AddFunc(0xa75640e8, cellGcmUnbindZcull);
cellGcmSys.AddFunc(0x657571f7, cellGcmGetTileInfo);
cellGcmSys.AddFunc(0xd9a0a879, cellGcmGetZcullInfo);
cellGcmSys.AddFunc(0x0e6b0dae, cellGcmGetDisplayInfo);
cellGcmSys.AddFunc(0x93806525, cellGcmGetCurrentDisplayBufferId);
cellGcmSys.AddFunc(0xbd6d60d9, cellGcmSetInvalidateTile);
//cellGcmSys.AddFunc(, cellGcmSetFlipWithWaitLabel);
cellGcmSys->AddFunc(0x4524cccd, cellGcmBindTile);
cellGcmSys->AddFunc(0x9dc04436, cellGcmBindZcull);
cellGcmSys->AddFunc(0x1f61b3ff, cellGcmDumpGraphicsError);
cellGcmSys->AddFunc(0xe315a0b2, cellGcmGetConfiguration);
cellGcmSys->AddFunc(0x371674cf, cellGcmGetDisplayBufferByFlipIndex);
cellGcmSys->AddFunc(0x72a577ce, cellGcmGetFlipStatus);
cellGcmSys->AddFunc(0x63387071, cellGcmgetLastFlipTime);
cellGcmSys->AddFunc(0x23ae55a3, cellGcmGetLastSecondVTime);
cellGcmSys->AddFunc(0x055bd74d, cellGcmGetTiledPitchSize);
cellGcmSys->AddFunc(0x723bbc7e, cellGcmGetVBlankCount);
cellGcmSys->AddFunc(0x15bae46b, cellGcmInit);
cellGcmSys->AddFunc(0xfce9e764, cellGcmInitSystemMode);
cellGcmSys->AddFunc(0xb2e761d4, cellGcmResetFlipStatus);
cellGcmSys->AddFunc(0x51c9d62b, cellGcmSetDebugOutputLevel);
cellGcmSys->AddFunc(0xa53d12ae, cellGcmSetDisplayBuffer);
cellGcmSys->AddFunc(0xdc09357e, cellGcmSetFlip);
cellGcmSys->AddFunc(0xa41ef7e8, cellGcmSetFlipHandler);
cellGcmSys->AddFunc(0xacee8542, cellGcmSetFlipImmediate);
cellGcmSys->AddFunc(0x4ae8d215, cellGcmSetFlipMode);
cellGcmSys->AddFunc(0xa47c09ff, cellGcmSetFlipStatus);
cellGcmSys->AddFunc(0xd01b570d, cellGcmSetGraphicsHandler);
cellGcmSys->AddFunc(0x0b4b62d5, cellGcmSetPrepareFlip);
cellGcmSys->AddFunc(0x0a862772, cellGcmSetQueueHandler);
cellGcmSys->AddFunc(0x4d7ce993, cellGcmSetSecondVFrequency);
cellGcmSys->AddFunc(0xdc494430, cellGcmSetSecondVHandler);
cellGcmSys->AddFunc(0xbd100dbc, cellGcmSetTileInfo);
cellGcmSys->AddFunc(0x06edea9e, cellGcmSetUserHandler);
cellGcmSys->AddFunc(0xffe0160e, cellGcmSetVBlankFrequency);
cellGcmSys->AddFunc(0xa91b0402, cellGcmSetVBlankHandler);
cellGcmSys->AddFunc(0x983fb9aa, cellGcmSetWaitFlip);
cellGcmSys->AddFunc(0xd34a420d, cellGcmSetZcull);
cellGcmSys->AddFunc(0x25b40ab4, cellGcmSortRemapEaIoAddress);
cellGcmSys->AddFunc(0xd9b7653e, cellGcmUnbindTile);
cellGcmSys->AddFunc(0xa75640e8, cellGcmUnbindZcull);
cellGcmSys->AddFunc(0x657571f7, cellGcmGetTileInfo);
cellGcmSys->AddFunc(0xd9a0a879, cellGcmGetZcullInfo);
cellGcmSys->AddFunc(0x0e6b0dae, cellGcmGetDisplayInfo);
cellGcmSys->AddFunc(0x93806525, cellGcmGetCurrentDisplayBufferId);
cellGcmSys->AddFunc(0xbd6d60d9, cellGcmSetInvalidateTile);
//cellGcmSys->AddFunc(, cellGcmSetFlipWithWaitLabel);
// Memory Mapping
cellGcmSys.AddFunc(0x21ac3697, cellGcmAddressToOffset);
cellGcmSys.AddFunc(0xfb81c03e, cellGcmGetMaxIoMapSize);
cellGcmSys.AddFunc(0x2922aed0, cellGcmGetOffsetTable);
cellGcmSys.AddFunc(0x2a6fba9c, cellGcmIoOffsetToAddress);
cellGcmSys.AddFunc(0x63441cb4, cellGcmMapEaIoAddress);
cellGcmSys.AddFunc(0x626e8518, cellGcmMapEaIoAddressWithFlags);
cellGcmSys.AddFunc(0xdb769b32, cellGcmMapLocalMemory);
cellGcmSys.AddFunc(0xa114ec67, cellGcmMapMainMemory);
cellGcmSys.AddFunc(0xa7ede268, cellGcmReserveIoMapSize);
cellGcmSys.AddFunc(0xefd00f54, cellGcmUnmapEaIoAddress);
cellGcmSys.AddFunc(0xdb23e867, cellGcmUnmapIoAddress);
cellGcmSys.AddFunc(0x3b9bd5bd, cellGcmUnreserveIoMapSize);
cellGcmSys->AddFunc(0x21ac3697, cellGcmAddressToOffset);
cellGcmSys->AddFunc(0xfb81c03e, cellGcmGetMaxIoMapSize);
cellGcmSys->AddFunc(0x2922aed0, cellGcmGetOffsetTable);
cellGcmSys->AddFunc(0x2a6fba9c, cellGcmIoOffsetToAddress);
cellGcmSys->AddFunc(0x63441cb4, cellGcmMapEaIoAddress);
cellGcmSys->AddFunc(0x626e8518, cellGcmMapEaIoAddressWithFlags);
cellGcmSys->AddFunc(0xdb769b32, cellGcmMapLocalMemory);
cellGcmSys->AddFunc(0xa114ec67, cellGcmMapMainMemory);
cellGcmSys->AddFunc(0xa7ede268, cellGcmReserveIoMapSize);
cellGcmSys->AddFunc(0xefd00f54, cellGcmUnmapEaIoAddress);
cellGcmSys->AddFunc(0xdb23e867, cellGcmUnmapIoAddress);
cellGcmSys->AddFunc(0x3b9bd5bd, cellGcmUnreserveIoMapSize);
// Cursor
cellGcmSys.AddFunc(0x107bf3a1, cellGcmInitCursor);
cellGcmSys.AddFunc(0xc47d0812, cellGcmSetCursorEnable);
cellGcmSys.AddFunc(0x69c6cc82, cellGcmSetCursorDisable);
cellGcmSys.AddFunc(0xf9bfdc72, cellGcmSetCursorImageOffset);
cellGcmSys.AddFunc(0x1a0de550, cellGcmSetCursorPosition);
cellGcmSys.AddFunc(0xbd2fa0a7, cellGcmUpdateCursor);
cellGcmSys->AddFunc(0x107bf3a1, cellGcmInitCursor);
cellGcmSys->AddFunc(0xc47d0812, cellGcmSetCursorEnable);
cellGcmSys->AddFunc(0x69c6cc82, cellGcmSetCursorDisable);
cellGcmSys->AddFunc(0xf9bfdc72, cellGcmSetCursorImageOffset);
cellGcmSys->AddFunc(0x1a0de550, cellGcmSetCursorPosition);
cellGcmSys->AddFunc(0xbd2fa0a7, cellGcmUpdateCursor);
// Functions for Maintaining Compatibility
cellGcmSys.AddFunc(0xbc982946, cellGcmSetDefaultCommandBuffer);
//cellGcmSys.AddFunc(, cellGcmGetCurrentBuffer);
//cellGcmSys.AddFunc(, cellGcmSetCurrentBuffer);
//cellGcmSys.AddFunc(, cellGcmSetDefaultCommandBufferAndSegmentWordSize);
//cellGcmSys.AddFunc(, cellGcmSetUserCallback);
cellGcmSys->AddFunc(0xbc982946, cellGcmSetDefaultCommandBuffer);
//cellGcmSys->AddFunc(, cellGcmGetCurrentBuffer);
//cellGcmSys->AddFunc(, cellGcmSetCurrentBuffer);
//cellGcmSys->AddFunc(, cellGcmSetDefaultCommandBufferAndSegmentWordSize);
//cellGcmSys->AddFunc(, cellGcmSetUserCallback);
// Other
cellGcmSys.AddFunc(0x21397818, cellGcmSetFlipCommand);
cellGcmSys.AddFunc(0x3a33c1fd, cellGcmFunc15);
cellGcmSys.AddFunc(0xd8f88e1a, cellGcmSetFlipCommandWithWaitLabel);
cellGcmSys.AddFunc(0xd0b1d189, cellGcmSetTile);
cellGcmSys->AddFunc(0x21397818, cellGcmSetFlipCommand);
cellGcmSys->AddFunc(0x3a33c1fd, cellGcmFunc15);
cellGcmSys->AddFunc(0xd8f88e1a, cellGcmSetFlipCommandWithWaitLabel);
cellGcmSys->AddFunc(0xd0b1d189, cellGcmSetTile);
}
void cellGcmSys_load()

2
rpcs3/Emu/SysCalls/Modules/cellGem.cpp
View File

@ -283,4 +283,4 @@ void cellGem_init()
cellGem.AddFunc(0x1f6328d8, cellGemWriteExternalPort);
}
#endif
#endif

39
rpcs3/Emu/SysCalls/Modules/cellGifDec.cpp
View File

@ -11,8 +11,9 @@
#include "stblib/stb_image.h"
#include "stblib/stb_image.c" // (TODO: Should we put this elsewhere?)
void cellGifDec_init();
Module cellGifDec(0xf010, cellGifDec_init);
//void cellGifDec_init();
//Module cellGifDec(0xf010, cellGifDec_init);
extern Module *cellGifDec = nullptr;
int cellGifDecCreate(u32 mainHandle, u32 threadInParam, u32 threadOutParam)
{
@ -73,7 +74,7 @@ int cellGifDecOpen(u32 mainHandle, mem32_t subHandle, const mem_ptr_t<CellGifDec
current_subHandle->fileSize = sb->st_size; // Get CellFsStat.st_size
// From now, every u32 subHandle argument is a pointer to a CellPngDecSubHandle struct.
subHandle = cellGifDec.GetNewId(current_subHandle);
subHandle = cellGifDec->GetNewId(current_subHandle);
return CELL_OK;
}
@ -84,7 +85,7 @@ int cellGifDecReadHeader(u32 mainHandle, u32 subHandle, mem_ptr_t<CellGifDecInfo
return CELL_GIFDEC_ERROR_ARG;
CellGifDecSubHandle* subHandle_data;
if(!cellGifDec.CheckId(subHandle, subHandle_data))
if(!cellGifDec->CheckId(subHandle, subHandle_data))
return CELL_GIFDEC_ERROR_FATAL;
const u32& fd = subHandle_data->fd;
@ -125,7 +126,7 @@ int cellGifDecSetParameter(u32 mainHandle, u32 subHandle, const mem_ptr_t<CellGi
return CELL_GIFDEC_ERROR_ARG;
CellGifDecSubHandle* subHandle_data;
if(!cellGifDec.CheckId(subHandle, subHandle_data))
if(!cellGifDec->CheckId(subHandle, subHandle_data))
return CELL_GIFDEC_ERROR_FATAL;
CellGifDecInfo& current_info = subHandle_data->info;
@ -157,7 +158,7 @@ int cellGifDecDecodeData(u32 mainHandle, u32 subHandle, mem8_ptr_t data, const m
dataOutInfo->status = CELL_GIFDEC_DEC_STATUS_STOP;
CellGifDecSubHandle* subHandle_data;
if(!cellGifDec.CheckId(subHandle, subHandle_data))
if(!cellGifDec->CheckId(subHandle, subHandle_data))
return CELL_GIFDEC_ERROR_FATAL;
const u32& fd = subHandle_data->fd;
@ -206,7 +207,7 @@ int cellGifDecDecodeData(u32 mainHandle, u32 subHandle, mem8_ptr_t data, const m
int cellGifDecClose(u32 mainHandle, u32 subHandle)
{
CellGifDecSubHandle* subHandle_data;
if(!cellGifDec.CheckId(subHandle, subHandle_data))
if(!cellGifDec->CheckId(subHandle, subHandle_data))
return CELL_GIFDEC_ERROR_FATAL;
cellFsClose(subHandle_data->fd);
@ -223,17 +224,17 @@ int cellGifDecDestroy(u32 mainHandle)
void cellGifDec_init()
{
cellGifDec.AddFunc(0xb60d42a5, cellGifDecCreate);
cellGifDec.AddFunc(0x4711cb7f, cellGifDecExtCreate);
cellGifDec.AddFunc(0x75745079, cellGifDecOpen);
cellGifDec.AddFunc(0xf0da95de, cellGifDecReadHeader);
cellGifDec.AddFunc(0x41a90dc4, cellGifDecSetParameter);
cellGifDec.AddFunc(0x44b1bc61, cellGifDecDecodeData);
cellGifDec.AddFunc(0x116a7da9, cellGifDecClose);
cellGifDec.AddFunc(0xe74b2cb1, cellGifDecDestroy);
cellGifDec->AddFunc(0xb60d42a5, cellGifDecCreate);
cellGifDec->AddFunc(0x4711cb7f, cellGifDecExtCreate);
cellGifDec->AddFunc(0x75745079, cellGifDecOpen);
cellGifDec->AddFunc(0xf0da95de, cellGifDecReadHeader);
cellGifDec->AddFunc(0x41a90dc4, cellGifDecSetParameter);
cellGifDec->AddFunc(0x44b1bc61, cellGifDecDecodeData);
cellGifDec->AddFunc(0x116a7da9, cellGifDecClose);
cellGifDec->AddFunc(0xe74b2cb1, cellGifDecDestroy);
/*cellGifDec.AddFunc(0x17fb83c1, cellGifDecExtOpen);
cellGifDec.AddFunc(0xe53f91f2, cellGifDecExtReadHeader);
cellGifDec.AddFunc(0x95cae771, cellGifDecExtSetParameter);
cellGifDec.AddFunc(0x02e7e03e, cellGifDecExtDecodeData);*/
/*cellGifDec->AddFunc(0x17fb83c1, cellGifDecExtOpen);
cellGifDec->AddFunc(0xe53f91f2, cellGifDecExtReadHeader);
cellGifDec->AddFunc(0x95cae771, cellGifDecExtSetParameter);
cellGifDec->AddFunc(0x02e7e03e, cellGifDecExtDecodeData);*/
}

45
rpcs3/Emu/SysCalls/Modules/cellJpgDec.cpp
View File

@ -8,8 +8,9 @@
#include "cellJpgDec.h"
#include "stblib/stb_image.h"
void cellJpgDec_init();
Module cellJpgDec(0x000f, cellJpgDec_init);
//void cellJpgDec_init();
//Module cellJpgDec(0x000f, cellJpgDec_init);
extern Module *cellJpgDec = nullptr;
int cellJpgDecCreate(u32 mainHandle, u32 threadInParam, u32 threadOutParam)
{
@ -31,7 +32,7 @@ int cellJpgDecDestroy(u32 mainHandle)
int cellJpgDecOpen(u32 mainHandle, mem32_t subHandle, mem_ptr_t<CellJpgDecSrc> src, mem_ptr_t<CellJpgDecOpnInfo> openInfo)
{
cellJpgDec.Warning("cellJpgDecOpen(mainHandle=0x%x, subHandle=0x%x, src_addr=0x%x, openInfo=0x%x)",
cellJpgDec->Warning("cellJpgDecOpen(mainHandle=0x%x, subHandle=0x%x, src_addr=0x%x, openInfo=0x%x)",
mainHandle, subHandle.GetAddr(), src.GetAddr(), openInfo);
if (!subHandle.IsGood() || !src.IsGood() || !openInfo.IsGood())
@ -52,7 +53,7 @@ int cellJpgDecOpen(u32 mainHandle, mem32_t subHandle, mem_ptr_t<CellJpgDecSrc> s
current_subHandle->fileSize = sb->st_size; // Get CellFsStat.st_size
// From now, every u32 subHandle argument is a pointer to a CellPngDecSubHandle struct.
subHandle = cellJpgDec.GetNewId(current_subHandle);
subHandle = cellJpgDec->GetNewId(current_subHandle);
return CELL_OK;
}
@ -60,7 +61,7 @@ int cellJpgDecOpen(u32 mainHandle, mem32_t subHandle, mem_ptr_t<CellJpgDecSrc> s
int cellJpgDecClose(u32 mainHandle, u32 subHandle)
{
CellJpgDecSubHandle* subHandle_data;
if(!cellJpgDec.CheckId(subHandle, subHandle_data))
if(!cellJpgDec->CheckId(subHandle, subHandle_data))
return CELL_JPGDEC_ERROR_FATAL;
cellFsClose(subHandle_data->fd);
@ -71,13 +72,13 @@ int cellJpgDecClose(u32 mainHandle, u32 subHandle)
int cellJpgDecReadHeader(u32 mainHandle, u32 subHandle, mem_ptr_t<CellJpgDecInfo> info)
{
cellJpgDec.Log("cellJpgDecReadHeader(mainHandle=0x%x, subHandle=0x%x, info_addr=0x%llx)", mainHandle, subHandle, info.GetAddr());
cellJpgDec->Log("cellJpgDecReadHeader(mainHandle=0x%x, subHandle=0x%x, info_addr=0x%llx)", mainHandle, subHandle, info.GetAddr());
if (!info.IsGood())
return CELL_JPGDEC_ERROR_ARG;
CellJpgDecSubHandle* subHandle_data;
if(!cellJpgDec.CheckId(subHandle, subHandle_data))
if(!cellJpgDec->CheckId(subHandle, subHandle_data))
return CELL_JPGDEC_ERROR_FATAL;
const u32& fd = subHandle_data->fd;
@ -137,7 +138,7 @@ int cellJpgDecDecodeData(u32 mainHandle, u32 subHandle, mem8_ptr_t data, const m
dataOutInfo->status = CELL_JPGDEC_DEC_STATUS_STOP;
CellJpgDecSubHandle* subHandle_data;
if(!cellJpgDec.CheckId(subHandle, subHandle_data))
if(!cellJpgDec->CheckId(subHandle, subHandle_data))
return CELL_JPGDEC_ERROR_FATAL;
const u32& fd = subHandle_data->fd;
@ -182,7 +183,7 @@ int cellJpgDecDecodeData(u32 mainHandle, u32 subHandle, mem8_ptr_t data, const m
case CELL_JPG_UPSAMPLE_ONLY:
case CELL_JPG_GRAYSCALE_TO_ALPHA_RGBA:
case CELL_JPG_GRAYSCALE_TO_ALPHA_ARGB:
cellJpgDec.Error("cellJpgDecDecodeData: Unsupported color space (%d)", current_outParam.outputColorSpace.ToLE());
cellJpgDec->Error("cellJpgDecDecodeData: Unsupported color space (%d)", current_outParam.outputColorSpace.ToLE());
break;
default:
@ -203,7 +204,7 @@ int cellJpgDecSetParameter(u32 mainHandle, u32 subHandle, const mem_ptr_t<CellJp
return CELL_JPGDEC_ERROR_ARG;
CellJpgDecSubHandle* subHandle_data;
if(!cellJpgDec.CheckId(subHandle, subHandle_data))
if(!cellJpgDec->CheckId(subHandle, subHandle_data))
return CELL_JPGDEC_ERROR_FATAL;
CellJpgDecInfo& current_info = subHandle_data->info;
@ -243,17 +244,17 @@ int cellJpgDecSetParameter(u32 mainHandle, u32 subHandle, const mem_ptr_t<CellJp
void cellJpgDec_init()
{
cellJpgDec.AddFunc(0xa7978f59, cellJpgDecCreate);
cellJpgDec.AddFunc(0x8b300f66, cellJpgDecExtCreate);
cellJpgDec.AddFunc(0x976ca5c2, cellJpgDecOpen);
cellJpgDec.AddFunc(0x6d9ebccf, cellJpgDecReadHeader);
cellJpgDec.AddFunc(0xe08f3910, cellJpgDecSetParameter);
cellJpgDec.AddFunc(0xaf8bb012, cellJpgDecDecodeData);
cellJpgDec.AddFunc(0x9338a07a, cellJpgDecClose);
cellJpgDec.AddFunc(0xd8ea91f8, cellJpgDecDestroy);
cellJpgDec->AddFunc(0xa7978f59, cellJpgDecCreate);
cellJpgDec->AddFunc(0x8b300f66, cellJpgDecExtCreate);
cellJpgDec->AddFunc(0x976ca5c2, cellJpgDecOpen);
cellJpgDec->AddFunc(0x6d9ebccf, cellJpgDecReadHeader);
cellJpgDec->AddFunc(0xe08f3910, cellJpgDecSetParameter);
cellJpgDec->AddFunc(0xaf8bb012, cellJpgDecDecodeData);
cellJpgDec->AddFunc(0x9338a07a, cellJpgDecClose);
cellJpgDec->AddFunc(0xd8ea91f8, cellJpgDecDestroy);
/*cellJpgDec.AddFunc(0xa9f703e3, cellJpgDecExtOpen);
cellJpgDec.AddFunc(0xb91eb3d2, cellJpgDecExtReadHeader);
cellJpgDec.AddFunc(0x65cbbb16, cellJpgDecExtSetParameter);
cellJpgDec.AddFunc(0x716f8792, cellJpgDecExtDecodeData);*/
/*cellJpgDec->AddFunc(0xa9f703e3, cellJpgDecExtOpen);
cellJpgDec->AddFunc(0xb91eb3d2, cellJpgDecExtReadHeader);
cellJpgDec->AddFunc(0x65cbbb16, cellJpgDecExtSetParameter);
cellJpgDec->AddFunc(0x716f8792, cellJpgDecExtDecodeData);*/
}

344
rpcs3/Emu/SysCalls/Modules/cellL10n.cpp
View File

@ -11,8 +11,10 @@
#include <codecvt>
#endif
void cellL10n_init();
Module cellL10n(0x001e, cellL10n_init);
//void cellL10n_init();
//Module cellL10n(0x001e, cellL10n_init);
Module *cellL10n = nullptr;
// L10nResult
enum
@ -38,7 +40,7 @@ enum
int UTF16stoUTF8s(mem16_ptr_t utf16, mem64_t utf16_len, mem8_ptr_t utf8, mem64_t utf8_len)
{
cellL10n.Warning("UTF16stoUTF8s(utf16_addr=0x%x, utf16_len_addr=0x%x, utf8_addr=0x%x, utf8_len_addr=0x%x)",
cellL10n->Warning("UTF16stoUTF8s(utf16_addr=0x%x, utf16_len_addr=0x%x, utf8_addr=0x%x, utf8_len_addr=0x%x)",
utf16.GetAddr(), utf16_len.GetAddr(), utf8.GetAddr(), utf8_len.GetAddr());
if (!utf16.IsGood() || !utf16_len.IsGood() || !utf8_len.IsGood())
@ -65,11 +67,11 @@ int UTF16stoUTF8s(mem16_ptr_t utf16, mem64_t utf16_len, mem8_ptr_t utf8, mem64_t
int jstrchk(mem8_ptr_t jstr)
{
if (!jstr.IsGood())
cellL10n.Error("jstrchk(jstr_addr=0x%x): invalid address", jstr.GetAddr());
cellL10n->Error("jstrchk(jstr_addr=0x%x): invalid address", jstr.GetAddr());
else if (jstr[0])
cellL10n.Log("jstrchk(jstr_addr=0x%x): utf-8: [%s]", jstr.GetAddr(), Memory.ReadString(jstr.GetAddr()).c_str());
cellL10n->Log("jstrchk(jstr_addr=0x%x): utf-8: [%s]", jstr.GetAddr(), Memory.ReadString(jstr.GetAddr()).c_str());
else
cellL10n.Log("jstrchk(jstr_addr=0x%x): empty string", jstr.GetAddr());
cellL10n->Log("jstrchk(jstr_addr=0x%x): empty string", jstr.GetAddr());
return L10N_STR_UTF8;
}
@ -78,169 +80,169 @@ void cellL10n_init()
{
// NOTE: I think this module should be LLE'd instead of implementing all its functions
// cellL10n.AddFunc(0x005200e6, UCS2toEUCJP);
// cellL10n.AddFunc(0x01b0cbf4, l10n_convert);
// cellL10n.AddFunc(0x0356038c, UCS2toUTF32);
// cellL10n.AddFunc(0x05028763, jis2kuten);
// cellL10n.AddFunc(0x058addc8, UTF8toGB18030);
// cellL10n.AddFunc(0x060ee3b2, JISstoUTF8s);
// cellL10n.AddFunc(0x07168a83, SjisZen2Han);
// cellL10n.AddFunc(0x0bc386c8, ToSjisLower);
// cellL10n.AddFunc(0x0bedf77d, UCS2toGB18030);
// cellL10n.AddFunc(0x0bf867e2, HZstoUCS2s);
// cellL10n.AddFunc(0x0ce278fd, UCS2stoHZs);
// cellL10n.AddFunc(0x0d90a48d, UCS2stoSJISs);
// cellL10n.AddFunc(0x0f624540, kuten2eucjp);
// cellL10n.AddFunc(0x14ee3649, sjis2jis);
// cellL10n.AddFunc(0x14f504b8, EUCKRstoUCS2s);
// cellL10n.AddFunc(0x16eaf5f1, UHCstoEUCKRs);
// cellL10n.AddFunc(0x1758053c, jis2sjis);
// cellL10n.AddFunc(0x1906ce6b, jstrnchk);
// cellL10n.AddFunc(0x1ac0d23d, L10nConvert);
// cellL10n.AddFunc(0x1ae2acee, EUCCNstoUTF8s);
// cellL10n.AddFunc(0x1cb1138f, GBKstoUCS2s);
// cellL10n.AddFunc(0x1da42d70, eucjphan2zen);
// cellL10n.AddFunc(0x1ec712e0, ToSjisHira);
// cellL10n.AddFunc(0x1fb50183, GBKtoUCS2);
// cellL10n.AddFunc(0x21948c03, eucjp2jis);
// cellL10n.AddFunc(0x21aa3045, UTF32stoUTF8s);
// cellL10n.AddFunc(0x24fd32a9, sjishan2zen);
// cellL10n.AddFunc(0x256b6861, UCS2toSBCS);
// cellL10n.AddFunc(0x262a5ae2, UTF8stoGBKs);
// cellL10n.AddFunc(0x28724522, UTF8toUCS2);
// cellL10n.AddFunc(0x2ad091c6, UCS2stoUTF8s);
// cellL10n.AddFunc(0x2b84030c, EUCKRstoUTF8s);
// cellL10n.AddFunc(0x2efa7294, UTF16stoUTF32s);
// cellL10n.AddFunc(0x2f9eb543, UTF8toEUCKR);
// cellL10n.AddFunc(0x317ab7c2, UTF16toUTF8);
// cellL10n.AddFunc(0x32689828, ARIBstoUTF8s);
// cellL10n.AddFunc(0x33435818, SJISstoUTF8s);
// cellL10n.AddFunc(0x33f8b35c, sjiszen2han);
// cellL10n.AddFunc(0x3968f176, ToEucJpLower);
// cellL10n.AddFunc(0x398a3dee, MSJIStoUTF8);
// cellL10n.AddFunc(0x3a20bc34, UCS2stoMSJISs);
// cellL10n.AddFunc(0x3dabd5a7, EUCJPtoUTF8);
// cellL10n.AddFunc(0x3df65b64, eucjp2sjis);
// cellL10n.AddFunc(0x408a622b, ToEucJpHira);
// cellL10n.AddFunc(0x41b4a5ae, UHCstoUCS2s);
// cellL10n.AddFunc(0x41ccf033, ToEucJpKata);
// cellL10n.AddFunc(0x42838145, HZstoUTF8s);
// cellL10n.AddFunc(0x4931b44e, UTF8toMSJIS);
// cellL10n.AddFunc(0x4b3bbacb, BIG5toUTF8);
// cellL10n.AddFunc(0x511d386b, EUCJPstoSJISs);
// cellL10n.AddFunc(0x52b7883f, UTF8stoBIG5s);
// cellL10n.AddFunc(0x53558b6b, UTF16stoUCS2s);
// cellL10n.AddFunc(0x53764725, UCS2stoGB18030s);
// cellL10n.AddFunc(0x53c71ac2, EUCJPtoSJIS);
// cellL10n.AddFunc(0x54f59807, EUCJPtoUCS2);
// cellL10n.AddFunc(0x55f6921c, UCS2stoGBKs);
// cellL10n.AddFunc(0x58246762, EUCKRtoUHC);
// cellL10n.AddFunc(0x596df41c, UCS2toSJIS);
// cellL10n.AddFunc(0x5a4ab223, MSJISstoUTF8s);
// cellL10n.AddFunc(0x5ac783dc, EUCJPstoUTF8s);
// cellL10n.AddFunc(0x5b684dfb, UCS2toBIG5);
// cellL10n.AddFunc(0x5cd29270, UTF8stoEUCKRs);
// cellL10n.AddFunc(0x5e1d9330, UHCstoUTF8s);
// cellL10n.AddFunc(0x60ffa0ec, GB18030stoUCS2s);
// cellL10n.AddFunc(0x6122e000, SJIStoUTF8);
// cellL10n.AddFunc(0x6169f205, JISstoSJISs);
// cellL10n.AddFunc(0x61fb9442, UTF8toUTF16);
// cellL10n.AddFunc(0x62b36bcf, UTF8stoMSJISs);
// cellL10n.AddFunc(0x63219199, EUCKRtoUTF8);
// cellL10n.AddFunc(0x638c2fc1, SjisHan2Zen);
// cellL10n.AddFunc(0x64a10ec8, UCS2toUTF16);
// cellL10n.AddFunc(0x65444204, UCS2toMSJIS);
// cellL10n.AddFunc(0x6621a82c, sjis2kuten);
// cellL10n.AddFunc(0x6a6f25d1, UCS2toUHC);
// cellL10n.AddFunc(0x6c62d879, UTF32toUCS2);
// cellL10n.AddFunc(0x6de4b508, ToSjisUpper);
// cellL10n.AddFunc(0x6e0705c4, UTF8toEUCJP);
// cellL10n.AddFunc(0x6e5906fd, UCS2stoEUCJPs);
// cellL10n.AddFunc(0x6fc530b3, UTF16toUCS2);
// cellL10n.AddFunc(0x714a9b4a, UCS2stoUTF16s);
// cellL10n.AddFunc(0x71804d64, UCS2stoEUCCNs);
// cellL10n.AddFunc(0x72632e53, SBCSstoUTF8s);
// cellL10n.AddFunc(0x73f2cd21, SJISstoJISs);
// cellL10n.AddFunc(0x74496718, SBCStoUTF8);
// cellL10n.AddFunc(0x74871fe0, UTF8toUTF32);
cellL10n.AddFunc(0x750c363d, jstrchk);
// cellL10n.AddFunc(0x7c5bde1c, UHCtoEUCKR);
// cellL10n.AddFunc(0x7c912bda, kuten2jis);
// cellL10n.AddFunc(0x7d07a1c2, UTF8toEUCCN);
// cellL10n.AddFunc(0x8171c1cc, EUCCNtoUTF8);
// cellL10n.AddFunc(0x82d5ecdf, EucJpZen2Han);
// cellL10n.AddFunc(0x8555fe15, UTF32stoUTF16s);
// cellL10n.AddFunc(0x860fc741, GBKtoUTF8);
// cellL10n.AddFunc(0x867f7b8b, ToEucJpUpper);
// cellL10n.AddFunc(0x88f8340b, UCS2stoJISs);
// cellL10n.AddFunc(0x89236c86, UTF8stoGB18030s);
// cellL10n.AddFunc(0x8a56f148, EUCKRstoUHCs);
// cellL10n.AddFunc(0x8ccdba38, UTF8stoUTF32s);
// cellL10n.AddFunc(0x8f472054, UTF8stoEUCCNs);
// cellL10n.AddFunc(0x90e9b5d2, EUCJPstoUCS2s);
// cellL10n.AddFunc(0x91a99765, UHCtoUCS2);
// cellL10n.AddFunc(0x931ff25a, L10nConvertStr);
// cellL10n.AddFunc(0x949bb14c, GBKstoUTF8s);
// cellL10n.AddFunc(0x9557ac9b, UTF8toUHC);
// cellL10n.AddFunc(0x9768b6d3, UTF32toUTF8);
// cellL10n.AddFunc(0x9874020d, sjis2eucjp);
// cellL10n.AddFunc(0x9a0e7d23, UCS2toEUCCN);
// cellL10n.AddFunc(0x9a13d6b8, UTF8stoUHCs);
// cellL10n.AddFunc(0x9a72059d, EUCKRtoUCS2);
// cellL10n.AddFunc(0x9b1210c6, UTF32toUTF16);
// cellL10n.AddFunc(0x9cd8135b, EUCCNstoUCS2s);
// cellL10n.AddFunc(0x9ce52809, SBCSstoUCS2s);
// cellL10n.AddFunc(0x9cf1ab77, UTF8stoJISs);
// cellL10n.AddFunc(0x9d14dc46, ToSjisKata);
// cellL10n.AddFunc(0x9dcde367, jis2eucjp);
// cellL10n.AddFunc(0x9ec52258, BIG5toUCS2);
// cellL10n.AddFunc(0xa0d463c0, UCS2toGBK);
// cellL10n.AddFunc(0xa19fb9de, UTF16toUTF32);
// cellL10n.AddFunc(0xa298cad2, l10n_convert_str);
// cellL10n.AddFunc(0xa34fa0eb, EUCJPstoJISs);
// cellL10n.AddFunc(0xa5146299, UTF8stoARIBs);
// cellL10n.AddFunc(0xa609f3e9, JISstoEUCJPs);
// cellL10n.AddFunc(0xa60ff5c9, EucJpHan2Zen);
// cellL10n.AddFunc(0xa963619c, isEucJpKigou);
// cellL10n.AddFunc(0xa9a76fb8, UCS2toUTF8);
// cellL10n.AddFunc(0xaf18d499, GB18030toUCS2);
// cellL10n.AddFunc(0xb3361be6, UHCtoUTF8);
// cellL10n.AddFunc(0xb6e45343, MSJIStoUCS2);
// cellL10n.AddFunc(0xb7cef4a6, UTF8toGBK);
// cellL10n.AddFunc(0xb7e08f7a, kuten2sjis);
// cellL10n.AddFunc(0xb9cf473d, UTF8toSBCS);
// cellL10n.AddFunc(0xbdd44ee3, SJIStoUCS2);
// cellL10n.AddFunc(0xbe42e661, eucjpzen2han);
// cellL10n.AddFunc(0xbe8d5485, UCS2stoARIBs);
// cellL10n.AddFunc(0xbefe3869, isSjisKigou);
// cellL10n.AddFunc(0xc62b758d, UTF8stoEUCJPs);
// cellL10n.AddFunc(0xc7bdcb4c, UCS2toEUCKR);
// cellL10n.AddFunc(0xc944fa56, SBCStoUCS2);
// cellL10n.AddFunc(0xc9b78f58, MSJISstoUCS2s);
// cellL10n.AddFunc(0xcc1633cc, l10n_get_converter);
// cellL10n.AddFunc(0xd02ef83d, GB18030stoUTF8s);
// cellL10n.AddFunc(0xd8721e2c, SJISstoEUCJPs);
// cellL10n.AddFunc(0xd8cb24cb, UTF32stoUCS2s);
// cellL10n.AddFunc(0xd990858b, BIG5stoUTF8s);
// cellL10n.AddFunc(0xd9fb1224, EUCCNtoUCS2);
// cellL10n.AddFunc(0xda67b37f, UTF8stoSBCSs);
// cellL10n.AddFunc(0xdc54886c, UCS2stoEUCKRs);
// cellL10n.AddFunc(0xdd5ebdeb, UTF8stoSJISs);
// cellL10n.AddFunc(0xdefa1c17, UTF8stoHZs);
// cellL10n.AddFunc(0xe2eabb32, eucjp2kuten);
// cellL10n.AddFunc(0xe6d9e234, UTF8toBIG5);
cellL10n.AddFunc(0xe6f5711b, UTF16stoUTF8s);
// cellL10n.AddFunc(0xe956dc64, JISstoUCS2s);
// cellL10n.AddFunc(0xeabc3d00, GB18030toUTF8);
// cellL10n.AddFunc(0xeb3dc670, UTF8toSJIS);
// cellL10n.AddFunc(0xeb41cc68, ARIBstoUCS2s);
// cellL10n.AddFunc(0xeb685b83, UCS2stoUTF32s);
// cellL10n.AddFunc(0xebae29c0, UCS2stoSBCSs);
// cellL10n.AddFunc(0xee6c6a39, UCS2stoBIG5s);
// cellL10n.AddFunc(0xf1dcfa71, UCS2stoUHCs);
// cellL10n.AddFunc(0xf439728e, SJIStoEUCJP);
// cellL10n.AddFunc(0xf7681b9a, UTF8stoUTF16s);
// cellL10n.AddFunc(0xf9b1896d, SJISstoUCS2s);
// cellL10n.AddFunc(0xfa4a675a, BIG5stoUCS2s);
// cellL10n.AddFunc(0xfdbf6ac5, UTF8stoUCS2s);
// cellL10n->AddFunc(0x005200e6, UCS2toEUCJP);
// cellL10n->AddFunc(0x01b0cbf4, l10n_convert);
// cellL10n->AddFunc(0x0356038c, UCS2toUTF32);
// cellL10n->AddFunc(0x05028763, jis2kuten);
// cellL10n->AddFunc(0x058addc8, UTF8toGB18030);
// cellL10n->AddFunc(0x060ee3b2, JISstoUTF8s);
// cellL10n->AddFunc(0x07168a83, SjisZen2Han);
// cellL10n->AddFunc(0x0bc386c8, ToSjisLower);
// cellL10n->AddFunc(0x0bedf77d, UCS2toGB18030);
// cellL10n->AddFunc(0x0bf867e2, HZstoUCS2s);
// cellL10n->AddFunc(0x0ce278fd, UCS2stoHZs);
// cellL10n->AddFunc(0x0d90a48d, UCS2stoSJISs);
// cellL10n->AddFunc(0x0f624540, kuten2eucjp);
// cellL10n->AddFunc(0x14ee3649, sjis2jis);
// cellL10n->AddFunc(0x14f504b8, EUCKRstoUCS2s);
// cellL10n->AddFunc(0x16eaf5f1, UHCstoEUCKRs);
// cellL10n->AddFunc(0x1758053c, jis2sjis);
// cellL10n->AddFunc(0x1906ce6b, jstrnchk);
// cellL10n->AddFunc(0x1ac0d23d, L10nConvert);
// cellL10n->AddFunc(0x1ae2acee, EUCCNstoUTF8s);
// cellL10n->AddFunc(0x1cb1138f, GBKstoUCS2s);
// cellL10n->AddFunc(0x1da42d70, eucjphan2zen);
// cellL10n->AddFunc(0x1ec712e0, ToSjisHira);
// cellL10n->AddFunc(0x1fb50183, GBKtoUCS2);
// cellL10n->AddFunc(0x21948c03, eucjp2jis);
// cellL10n->AddFunc(0x21aa3045, UTF32stoUTF8s);
// cellL10n->AddFunc(0x24fd32a9, sjishan2zen);
// cellL10n->AddFunc(0x256b6861, UCS2toSBCS);
// cellL10n->AddFunc(0x262a5ae2, UTF8stoGBKs);
// cellL10n->AddFunc(0x28724522, UTF8toUCS2);
// cellL10n->AddFunc(0x2ad091c6, UCS2stoUTF8s);
// cellL10n->AddFunc(0x2b84030c, EUCKRstoUTF8s);
// cellL10n->AddFunc(0x2efa7294, UTF16stoUTF32s);
// cellL10n->AddFunc(0x2f9eb543, UTF8toEUCKR);
// cellL10n->AddFunc(0x317ab7c2, UTF16toUTF8);
// cellL10n->AddFunc(0x32689828, ARIBstoUTF8s);
// cellL10n->AddFunc(0x33435818, SJISstoUTF8s);
// cellL10n->AddFunc(0x33f8b35c, sjiszen2han);
// cellL10n->AddFunc(0x3968f176, ToEucJpLower);
// cellL10n->AddFunc(0x398a3dee, MSJIStoUTF8);
// cellL10n->AddFunc(0x3a20bc34, UCS2stoMSJISs);
// cellL10n->AddFunc(0x3dabd5a7, EUCJPtoUTF8);
// cellL10n->AddFunc(0x3df65b64, eucjp2sjis);
// cellL10n->AddFunc(0x408a622b, ToEucJpHira);
// cellL10n->AddFunc(0x41b4a5ae, UHCstoUCS2s);
// cellL10n->AddFunc(0x41ccf033, ToEucJpKata);
// cellL10n->AddFunc(0x42838145, HZstoUTF8s);
// cellL10n->AddFunc(0x4931b44e, UTF8toMSJIS);
// cellL10n->AddFunc(0x4b3bbacb, BIG5toUTF8);
// cellL10n->AddFunc(0x511d386b, EUCJPstoSJISs);
// cellL10n->AddFunc(0x52b7883f, UTF8stoBIG5s);
// cellL10n->AddFunc(0x53558b6b, UTF16stoUCS2s);
// cellL10n->AddFunc(0x53764725, UCS2stoGB18030s);
// cellL10n->AddFunc(0x53c71ac2, EUCJPtoSJIS);
// cellL10n->AddFunc(0x54f59807, EUCJPtoUCS2);
// cellL10n->AddFunc(0x55f6921c, UCS2stoGBKs);
// cellL10n->AddFunc(0x58246762, EUCKRtoUHC);
// cellL10n->AddFunc(0x596df41c, UCS2toSJIS);
// cellL10n->AddFunc(0x5a4ab223, MSJISstoUTF8s);
// cellL10n->AddFunc(0x5ac783dc, EUCJPstoUTF8s);
// cellL10n->AddFunc(0x5b684dfb, UCS2toBIG5);
// cellL10n->AddFunc(0x5cd29270, UTF8stoEUCKRs);
// cellL10n->AddFunc(0x5e1d9330, UHCstoUTF8s);
// cellL10n->AddFunc(0x60ffa0ec, GB18030stoUCS2s);
// cellL10n->AddFunc(0x6122e000, SJIStoUTF8);
// cellL10n->AddFunc(0x6169f205, JISstoSJISs);
// cellL10n->AddFunc(0x61fb9442, UTF8toUTF16);
// cellL10n->AddFunc(0x62b36bcf, UTF8stoMSJISs);
// cellL10n->AddFunc(0x63219199, EUCKRtoUTF8);
// cellL10n->AddFunc(0x638c2fc1, SjisHan2Zen);
// cellL10n->AddFunc(0x64a10ec8, UCS2toUTF16);
// cellL10n->AddFunc(0x65444204, UCS2toMSJIS);
// cellL10n->AddFunc(0x6621a82c, sjis2kuten);
// cellL10n->AddFunc(0x6a6f25d1, UCS2toUHC);
// cellL10n->AddFunc(0x6c62d879, UTF32toUCS2);
// cellL10n->AddFunc(0x6de4b508, ToSjisUpper);
// cellL10n->AddFunc(0x6e0705c4, UTF8toEUCJP);
// cellL10n->AddFunc(0x6e5906fd, UCS2stoEUCJPs);
// cellL10n->AddFunc(0x6fc530b3, UTF16toUCS2);
// cellL10n->AddFunc(0x714a9b4a, UCS2stoUTF16s);
// cellL10n->AddFunc(0x71804d64, UCS2stoEUCCNs);
// cellL10n->AddFunc(0x72632e53, SBCSstoUTF8s);
// cellL10n->AddFunc(0x73f2cd21, SJISstoJISs);
// cellL10n->AddFunc(0x74496718, SBCStoUTF8);
// cellL10n->AddFunc(0x74871fe0, UTF8toUTF32);
cellL10n->AddFunc(0x750c363d, jstrchk);
// cellL10n->AddFunc(0x7c5bde1c, UHCtoEUCKR);
// cellL10n->AddFunc(0x7c912bda, kuten2jis);
// cellL10n->AddFunc(0x7d07a1c2, UTF8toEUCCN);
// cellL10n->AddFunc(0x8171c1cc, EUCCNtoUTF8);
// cellL10n->AddFunc(0x82d5ecdf, EucJpZen2Han);
// cellL10n->AddFunc(0x8555fe15, UTF32stoUTF16s);
// cellL10n->AddFunc(0x860fc741, GBKtoUTF8);
// cellL10n->AddFunc(0x867f7b8b, ToEucJpUpper);
// cellL10n->AddFunc(0x88f8340b, UCS2stoJISs);
// cellL10n->AddFunc(0x89236c86, UTF8stoGB18030s);
// cellL10n->AddFunc(0x8a56f148, EUCKRstoUHCs);
// cellL10n->AddFunc(0x8ccdba38, UTF8stoUTF32s);
// cellL10n->AddFunc(0x8f472054, UTF8stoEUCCNs);
// cellL10n->AddFunc(0x90e9b5d2, EUCJPstoUCS2s);
// cellL10n->AddFunc(0x91a99765, UHCtoUCS2);
// cellL10n->AddFunc(0x931ff25a, L10nConvertStr);
// cellL10n->AddFunc(0x949bb14c, GBKstoUTF8s);
// cellL10n->AddFunc(0x9557ac9b, UTF8toUHC);
// cellL10n->AddFunc(0x9768b6d3, UTF32toUTF8);
// cellL10n->AddFunc(0x9874020d, sjis2eucjp);
// cellL10n->AddFunc(0x9a0e7d23, UCS2toEUCCN);
// cellL10n->AddFunc(0x9a13d6b8, UTF8stoUHCs);
// cellL10n->AddFunc(0x9a72059d, EUCKRtoUCS2);
// cellL10n->AddFunc(0x9b1210c6, UTF32toUTF16);
// cellL10n->AddFunc(0x9cd8135b, EUCCNstoUCS2s);
// cellL10n->AddFunc(0x9ce52809, SBCSstoUCS2s);
// cellL10n->AddFunc(0x9cf1ab77, UTF8stoJISs);
// cellL10n->AddFunc(0x9d14dc46, ToSjisKata);
// cellL10n->AddFunc(0x9dcde367, jis2eucjp);
// cellL10n->AddFunc(0x9ec52258, BIG5toUCS2);
// cellL10n->AddFunc(0xa0d463c0, UCS2toGBK);
// cellL10n->AddFunc(0xa19fb9de, UTF16toUTF32);
// cellL10n->AddFunc(0xa298cad2, l10n_convert_str);
// cellL10n->AddFunc(0xa34fa0eb, EUCJPstoJISs);
// cellL10n->AddFunc(0xa5146299, UTF8stoARIBs);
// cellL10n->AddFunc(0xa609f3e9, JISstoEUCJPs);
// cellL10n->AddFunc(0xa60ff5c9, EucJpHan2Zen);
// cellL10n->AddFunc(0xa963619c, isEucJpKigou);
// cellL10n->AddFunc(0xa9a76fb8, UCS2toUTF8);
// cellL10n->AddFunc(0xaf18d499, GB18030toUCS2);
// cellL10n->AddFunc(0xb3361be6, UHCtoUTF8);
// cellL10n->AddFunc(0xb6e45343, MSJIStoUCS2);
// cellL10n->AddFunc(0xb7cef4a6, UTF8toGBK);
// cellL10n->AddFunc(0xb7e08f7a, kuten2sjis);
// cellL10n->AddFunc(0xb9cf473d, UTF8toSBCS);
// cellL10n->AddFunc(0xbdd44ee3, SJIStoUCS2);
// cellL10n->AddFunc(0xbe42e661, eucjpzen2han);
// cellL10n->AddFunc(0xbe8d5485, UCS2stoARIBs);
// cellL10n->AddFunc(0xbefe3869, isSjisKigou);
// cellL10n->AddFunc(0xc62b758d, UTF8stoEUCJPs);
// cellL10n->AddFunc(0xc7bdcb4c, UCS2toEUCKR);
// cellL10n->AddFunc(0xc944fa56, SBCStoUCS2);
// cellL10n->AddFunc(0xc9b78f58, MSJISstoUCS2s);
// cellL10n->AddFunc(0xcc1633cc, l10n_get_converter);
// cellL10n->AddFunc(0xd02ef83d, GB18030stoUTF8s);
// cellL10n->AddFunc(0xd8721e2c, SJISstoEUCJPs);
// cellL10n->AddFunc(0xd8cb24cb, UTF32stoUCS2s);
// cellL10n->AddFunc(0xd990858b, BIG5stoUTF8s);
// cellL10n->AddFunc(0xd9fb1224, EUCCNtoUCS2);
// cellL10n->AddFunc(0xda67b37f, UTF8stoSBCSs);
// cellL10n->AddFunc(0xdc54886c, UCS2stoEUCKRs);
// cellL10n->AddFunc(0xdd5ebdeb, UTF8stoSJISs);
// cellL10n->AddFunc(0xdefa1c17, UTF8stoHZs);
// cellL10n->AddFunc(0xe2eabb32, eucjp2kuten);
// cellL10n->AddFunc(0xe6d9e234, UTF8toBIG5);
cellL10n->AddFunc(0xe6f5711b, UTF16stoUTF8s);
// cellL10n->AddFunc(0xe956dc64, JISstoUCS2s);
// cellL10n->AddFunc(0xeabc3d00, GB18030toUTF8);
// cellL10n->AddFunc(0xeb3dc670, UTF8toSJIS);
// cellL10n->AddFunc(0xeb41cc68, ARIBstoUCS2s);
// cellL10n->AddFunc(0xeb685b83, UCS2stoUTF32s);
// cellL10n->AddFunc(0xebae29c0, UCS2stoSBCSs);
// cellL10n->AddFunc(0xee6c6a39, UCS2stoBIG5s);
// cellL10n->AddFunc(0xf1dcfa71, UCS2stoUHCs);
// cellL10n->AddFunc(0xf439728e, SJIStoEUCJP);
// cellL10n->AddFunc(0xf7681b9a, UTF8stoUTF16s);
// cellL10n->AddFunc(0xf9b1896d, SJISstoUCS2s);
// cellL10n->AddFunc(0xfa4a675a, BIG5stoUCS2s);
// cellL10n->AddFunc(0xfdbf6ac5, UTF8stoUCS2s);
}

27
rpcs3/Emu/SysCalls/Modules/cellNetCtl.cpp
View File

@ -6,8 +6,9 @@
#include "Emu/SysCalls/SC_FUNC.h"
#include "Emu/SysCalls/Modules.h"
void cellNetCtl_init();
Module cellNetCtl(0x0014, cellNetCtl_init);
//void cellNetCtl_init();
//Module cellNetCtl(0x0014, cellNetCtl_init);
Module *cellNetCtl;
// Error Codes
enum
@ -72,7 +73,7 @@ int cellNetCtlTerm()
int cellNetCtlGetState(mem32_t state)
{
cellNetCtl.Log("cellNetCtlGetState(state_addr=0x%x)", state.GetAddr());
cellNetCtl->Log("cellNetCtlGetState(state_addr=0x%x)", state.GetAddr());
if (!state.IsGood())
return CELL_NET_CTL_ERROR_INVALID_ADDR;
@ -125,18 +126,18 @@ int cellNetCtlGetNatInfo()
void cellNetCtl_init()
{
cellNetCtl.AddFunc(0xbd5a59fc, cellNetCtlInit);
cellNetCtl.AddFunc(0x105ee2cb, cellNetCtlTerm);
cellNetCtl->AddFunc(0xbd5a59fc, cellNetCtlInit);
cellNetCtl->AddFunc(0x105ee2cb, cellNetCtlTerm);
cellNetCtl.AddFunc(0x8b3eba69, cellNetCtlGetState);
cellNetCtl.AddFunc(0x0ce13c6b, cellNetCtlAddHandler);
cellNetCtl.AddFunc(0x901815c3, cellNetCtlDelHandler);
cellNetCtl->AddFunc(0x8b3eba69, cellNetCtlGetState);
cellNetCtl->AddFunc(0x0ce13c6b, cellNetCtlAddHandler);
cellNetCtl->AddFunc(0x901815c3, cellNetCtlDelHandler);
cellNetCtl.AddFunc(0x1e585b5d, cellNetCtlGetInfo);
cellNetCtl->AddFunc(0x1e585b5d, cellNetCtlGetInfo);
cellNetCtl.AddFunc(0x04459230, cellNetCtlNetStartDialogLoadAsync);
cellNetCtl.AddFunc(0x71d53210, cellNetCtlNetStartDialogAbortAsync);
cellNetCtl.AddFunc(0x0f1f13d3, cellNetCtlNetStartDialogUnloadAsync);
cellNetCtl->AddFunc(0x04459230, cellNetCtlNetStartDialogLoadAsync);
cellNetCtl->AddFunc(0x71d53210, cellNetCtlNetStartDialogAbortAsync);
cellNetCtl->AddFunc(0x0f1f13d3, cellNetCtlNetStartDialogUnloadAsync);
cellNetCtl.AddFunc(0x3a12865f, cellNetCtlGetNatInfo);
cellNetCtl->AddFunc(0x3a12865f, cellNetCtlGetNatInfo);
}

2
rpcs3/Emu/SysCalls/Modules/cellOvis.cpp
View File

@ -45,4 +45,4 @@ void cellOvis_init()
cellOvis.AddFunc(0xce6cb776, cellOvisFixSpuSegments);
cellOvis.AddFunc(0x629ba0c0, cellOvisInvalidateOverlappedSegments);
}
#endif
#endif

133
rpcs3/Emu/SysCalls/Modules/cellPamf.cpp
View File

@ -7,8 +7,10 @@
#include "Emu/SysCalls/Modules.h"
#include "cellPamf.h"
void cellPamf_init();
Module cellPamf(0x0012, cellPamf_init);
//void cellPamf_init();
//Module cellPamf(0x0012, cellPamf_init);
Module *cellPamf = nullptr;
int pamfStreamTypeToEsFilterId(u8 type, u8 ch, mem_ptr_t<CellCodecEsFilterId> pEsFilterId)
{
@ -30,7 +32,7 @@ int pamfStreamTypeToEsFilterId(u8 type, u8 ch, mem_ptr_t<CellCodecEsFilterId> pE
pEsFilterId->supplementalInfo2 = 0;
}
else
cellPamf.Error("pamfStreamTypeToEsFilterId: invalid CELL_PAMF_STREAM_TYPE_AVC channel (ch=%d)", ch);
cellPamf->Error("pamfStreamTypeToEsFilterId: invalid CELL_PAMF_STREAM_TYPE_AVC channel (ch=%d)", ch);
}
break;
case CELL_PAMF_STREAM_TYPE_ATRAC3PLUS:
@ -42,7 +44,7 @@ int pamfStreamTypeToEsFilterId(u8 type, u8 ch, mem_ptr_t<CellCodecEsFilterId> pE
pEsFilterId->supplementalInfo2 = 0;
}
else
cellPamf.Error("*** TODO: pamfStreamTypeToEsFilterId: CELL_PAMF_STREAM_TYPE_ATRAC3PLUS (ch=%d)", ch);
cellPamf->Error("*** TODO: pamfStreamTypeToEsFilterId: CELL_PAMF_STREAM_TYPE_ATRAC3PLUS (ch=%d)", ch);
break;
case CELL_PAMF_STREAM_TYPE_PAMF_LPCM:
if (ch == 0)
@ -53,7 +55,7 @@ int pamfStreamTypeToEsFilterId(u8 type, u8 ch, mem_ptr_t<CellCodecEsFilterId> pE
pEsFilterId->supplementalInfo2 = 0;
}
else
cellPamf.Error("*** TODO: pamfStreamTypeToEsFilterId: CELL_PAMF_STREAM_TYPE_LPCM (ch=%d)", ch);
cellPamf->Error("*** TODO: pamfStreamTypeToEsFilterId: CELL_PAMF_STREAM_TYPE_LPCM (ch=%d)", ch);
break;
case CELL_PAMF_STREAM_TYPE_USER_DATA:
if (ch == 0)
@ -64,13 +66,13 @@ int pamfStreamTypeToEsFilterId(u8 type, u8 ch, mem_ptr_t<CellCodecEsFilterId> pE
pEsFilterId->supplementalInfo2 = 0;
}
else
cellPamf.Error("*** TODO: pamfStreamTypeToEsFilterId: CELL_PAMF_STREAM_TYPE_USER_DATA (ch=%d)", ch);
cellPamf->Error("*** TODO: pamfStreamTypeToEsFilterId: CELL_PAMF_STREAM_TYPE_USER_DATA (ch=%d)", ch);
break;
case CELL_PAMF_STREAM_TYPE_AC3:
cellPamf.Error("*** TODO: pamfStreamTypeToEsFilterId: CELL_PAMF_STREAM_TYPE_AC3 (ch=%d)", ch);
cellPamf->Error("*** TODO: pamfStreamTypeToEsFilterId: CELL_PAMF_STREAM_TYPE_AC3 (ch=%d)", ch);
break;
case CELL_PAMF_STREAM_TYPE_M2V:
cellPamf.Error("*** TODO: pamfStreamTypeToEsFilterId: CELL_PAMF_STREAM_TYPE_M2V (ch=%d)", ch);
cellPamf->Error("*** TODO: pamfStreamTypeToEsFilterId: CELL_PAMF_STREAM_TYPE_M2V (ch=%d)", ch);
break;
default:
return CELL_PAMF_ERROR_INVALID_ARG;
@ -90,7 +92,7 @@ u8 pamfGetStreamType(mem_ptr_t<CellPamfReader> pSelf, u8 stream)
case 0x80: return CELL_PAMF_STREAM_TYPE_PAMF_LPCM;
case 0xdd: return CELL_PAMF_STREAM_TYPE_USER_DATA;
default:
cellPamf.Error("pamfGetStreamType: (TODO) unsupported stream type found(0x%x)",
cellPamf->Error("pamfGetStreamType: (TODO) unsupported stream type found(0x%x)",
pAddr->stream_headers[stream].type);
return 0;
}
@ -107,13 +109,13 @@ u8 pamfGetStreamChannel(mem_ptr_t<CellPamfReader> pSelf, u8 stream)
{
return pAddr->stream_headers[stream].stream_id - 0xe0;
}
cellPamf.Error("TODO: pamfGetStreamChannel (-> 0)");
cellPamf->Error("TODO: pamfGetStreamChannel (-> 0)");
return 0;
}
int cellPamfGetHeaderSize(mem_ptr_t<PamfHeader> pAddr, u64 fileSize, mem64_t pSize)
{
cellPamf.Warning("cellPamfGetHeaderSize(pAddr=0x%x, fileSize=%d, pSize_addr=0x%x)",
cellPamf->Warning("cellPamfGetHeaderSize(pAddr=0x%x, fileSize=%d, pSize_addr=0x%x)",
pAddr.GetAddr(), fileSize, pSize.GetAddr());
if (!Memory.IsGoodAddr(pAddr.GetAddr(), 2048) || !pSize.IsGood())
@ -129,7 +131,7 @@ int cellPamfGetHeaderSize(mem_ptr_t<PamfHeader> pAddr, u64 fileSize, mem64_t pSi
int cellPamfGetHeaderSize2(mem_ptr_t<PamfHeader> pAddr, u64 fileSize, u32 attribute, mem64_t pSize)
{
cellPamf.Warning("cellPamfGetHeaderSize2(pAddr=0x%x, fileSize=%d, attribute=0x%x, pSize_addr=0x%x)",
cellPamf->Warning("cellPamfGetHeaderSize2(pAddr=0x%x, fileSize=%d, attribute=0x%x, pSize_addr=0x%x)",
pAddr.GetAddr(), fileSize, attribute, pSize.GetAddr());
if (!Memory.IsGoodAddr(pAddr.GetAddr(), 2048) || !pSize.IsGood())
@ -145,7 +147,7 @@ int cellPamfGetHeaderSize2(mem_ptr_t<PamfHeader> pAddr, u64 fileSize, u32 attrib
int cellPamfGetStreamOffsetAndSize(mem_ptr_t<PamfHeader> pAddr, u64 fileSize, mem64_t pOffset, mem64_t pSize)
{
cellPamf.Warning("cellPamfGetStreamOffsetAndSize(pAddr=0x%x, fileSize=%d, pOffset_addr=0x%x, pSize_addr=0x%x)",
cellPamf->Warning("cellPamfGetStreamOffsetAndSize(pAddr=0x%x, fileSize=%d, pOffset_addr=0x%x, pSize_addr=0x%x)",
pAddr.GetAddr(), fileSize, pOffset.GetAddr(), pSize.GetAddr());
if (!Memory.IsGoodAddr(pAddr.GetAddr(), 2048) || !pOffset.IsGood() || !pSize.IsGood())
@ -163,7 +165,7 @@ int cellPamfGetStreamOffsetAndSize(mem_ptr_t<PamfHeader> pAddr, u64 fileSize, me
int cellPamfVerify(mem_ptr_t<PamfHeader> pAddr, u64 fileSize)
{
cellPamf.Warning("cellPamfVerify(pAddr=0x%x, fileSize=%d)", pAddr.GetAddr(), fileSize);
cellPamf->Warning("cellPamfVerify(pAddr=0x%x, fileSize=%d)", pAddr.GetAddr(), fileSize);
if (!Memory.IsGoodAddr(pAddr.GetAddr(), 2048))
return CELL_PAMF_ERROR_INVALID_ARG;
@ -177,7 +179,7 @@ int cellPamfReaderInitialize(mem_ptr_t<CellPamfReader> pSelf, mem_ptr_t<PamfHead
if (Ini.SkipPamf.GetValue())
return -1;
cellPamf.Warning("cellPamfReaderInitialize(pSelf=0x%x, pAddr=0x%x, fileSize=%d, attribute=0x%x)",
cellPamf->Warning("cellPamfReaderInitialize(pSelf=0x%x, pAddr=0x%x, fileSize=%d, attribute=0x%x)",
pSelf.GetAddr(), pAddr.GetAddr(), fileSize, attribute);
if (!pSelf.IsGood() || !Memory.IsGoodAddr(pAddr.GetAddr(), 2048))
@ -204,7 +206,7 @@ int cellPamfReaderInitialize(mem_ptr_t<CellPamfReader> pSelf, mem_ptr_t<PamfHead
int cellPamfReaderGetPresentationStartTime(mem_ptr_t<CellPamfReader> pSelf, mem_ptr_t<CellCodecTimeStamp> pTimeStamp)
{
cellPamf.Warning("cellPamfReaderGetPresentationStartTime(pSelf=0x%x, pTimeStamp_addr=0x%x)",
cellPamf->Warning("cellPamfReaderGetPresentationStartTime(pSelf=0x%x, pTimeStamp_addr=0x%x)",
pSelf.GetAddr(), pTimeStamp.GetAddr());
if (!pSelf.IsGood() || !Memory.IsGoodAddr(pSelf->pAddr))
@ -219,7 +221,7 @@ int cellPamfReaderGetPresentationStartTime(mem_ptr_t<CellPamfReader> pSelf, mem_
int cellPamfReaderGetPresentationEndTime(mem_ptr_t<CellPamfReader> pSelf, mem_ptr_t<CellCodecTimeStamp> pTimeStamp)
{
cellPamf.Warning("cellPamfReaderGetPresentationEndTime(pSelf=0x%x, pTimeStamp_addr=0x%x)",
cellPamf->Warning("cellPamfReaderGetPresentationEndTime(pSelf=0x%x, pTimeStamp_addr=0x%x)",
pSelf.GetAddr(), pTimeStamp.GetAddr());
if (!pSelf.IsGood() || !Memory.IsGoodAddr(pSelf->pAddr))
@ -234,7 +236,7 @@ int cellPamfReaderGetPresentationEndTime(mem_ptr_t<CellPamfReader> pSelf, mem_pt
int cellPamfReaderGetMuxRateBound(mem_ptr_t<CellPamfReader> pSelf)
{
cellPamf.Warning("cellPamfReaderGetMuxRateBound(pSelf=0x%x)", pSelf.GetAddr());
cellPamf->Warning("cellPamfReaderGetMuxRateBound(pSelf=0x%x)", pSelf.GetAddr());
if (!pSelf.IsGood() || !Memory.IsGoodAddr(pSelf->pAddr))
return CELL_PAMF_ERROR_INVALID_ARG;
@ -245,7 +247,7 @@ int cellPamfReaderGetMuxRateBound(mem_ptr_t<CellPamfReader> pSelf)
int cellPamfReaderGetNumberOfStreams(mem_ptr_t<CellPamfReader> pSelf)
{
cellPamf.Warning("cellPamfReaderGetNumberOfStreams(pSelf=0x%x)", pSelf.GetAddr());
cellPamf->Warning("cellPamfReaderGetNumberOfStreams(pSelf=0x%x)", pSelf.GetAddr());
if (!pSelf.IsGood() || !Memory.IsGoodAddr(pSelf->pAddr))
return CELL_PAMF_ERROR_INVALID_ARG;
@ -256,7 +258,7 @@ int cellPamfReaderGetNumberOfStreams(mem_ptr_t<CellPamfReader> pSelf)
int cellPamfReaderGetNumberOfSpecificStreams(mem_ptr_t<CellPamfReader> pSelf, u8 streamType)
{
cellPamf.Warning("cellPamfReaderGetNumberOfSpecificStreams(pSelf=0x%x, streamType=%d)",
cellPamf->Warning("cellPamfReaderGetNumberOfSpecificStreams(pSelf=0x%x, streamType=%d)",
pSelf.GetAddr(), streamType);
if (!pSelf.IsGood() || !Memory.IsGoodAddr(pSelf->pAddr))
@ -292,7 +294,7 @@ int cellPamfReaderGetNumberOfSpecificStreams(mem_ptr_t<CellPamfReader> pSelf, u8
int cellPamfReaderSetStreamWithIndex(mem_ptr_t<CellPamfReader> pSelf, u8 streamIndex)
{
cellPamf.Warning("cellPamfReaderSetStreamWithIndex(pSelf=0x%x, streamIndex=%d)",
cellPamf->Warning("cellPamfReaderSetStreamWithIndex(pSelf=0x%x, streamIndex=%d)",
pSelf.GetAddr(), streamIndex);
if (!pSelf.IsGood() || !Memory.IsGoodAddr(pSelf->pAddr))
@ -313,7 +315,7 @@ int cellPamfReaderSetStreamWithIndex(mem_ptr_t<CellPamfReader> pSelf, u8 streamI
int cellPamfReaderSetStreamWithTypeAndChannel(mem_ptr_t<CellPamfReader> pSelf, u8 streamType, u8 ch)
{
cellPamf.Warning("cellPamfReaderSetStreamWithTypeAndChannel(pSelf=0x%x, streamType=%d, ch=%d)",
cellPamf->Warning("cellPamfReaderSetStreamWithTypeAndChannel(pSelf=0x%x, streamType=%d, ch=%d)",
pSelf.GetAddr(), streamType, ch);
if (!pSelf.IsGood() || !Memory.IsGoodAddr(pSelf->pAddr))
@ -323,7 +325,7 @@ int cellPamfReaderSetStreamWithTypeAndChannel(mem_ptr_t<CellPamfReader> pSelf, u
if (streamType > 5)
{
cellPamf.Error("cellPamfReaderSetStreamWithTypeAndChannel: invalid stream type(%d)", streamType);
cellPamf->Error("cellPamfReaderSetStreamWithTypeAndChannel: invalid stream type(%d)", streamType);
//it probably doesn't support "any audio" or "any video" argument
return CELL_PAMF_ERROR_INVALID_ARG;
}
@ -345,7 +347,7 @@ int cellPamfReaderSetStreamWithTypeAndChannel(mem_ptr_t<CellPamfReader> pSelf, u
int cellPamfReaderSetStreamWithTypeAndIndex(mem_ptr_t<CellPamfReader> pSelf, u8 streamType, u8 streamIndex)
{
cellPamf.Warning("cellPamfReaderSetStreamWithTypeAndIndex(pSelf=0x%x, streamType=%d, streamIndex=%d)",
cellPamf->Warning("cellPamfReaderSetStreamWithTypeAndIndex(pSelf=0x%x, streamType=%d, streamIndex=%d)",
pSelf.GetAddr(), streamType, streamIndex);
if (!pSelf.IsGood() || !Memory.IsGoodAddr(pSelf->pAddr))
@ -396,7 +398,7 @@ int cellPamfReaderSetStreamWithTypeAndIndex(mem_ptr_t<CellPamfReader> pSelf, u8
int cellPamfStreamTypeToEsFilterId(u8 type, u8 ch, mem_ptr_t<CellCodecEsFilterId> pEsFilterId)
{
cellPamf.Warning("cellPamfStreamTypeToEsFilterId(type=%d, ch=%d, pEsFilterId_addr=0x%x)",
cellPamf->Warning("cellPamfStreamTypeToEsFilterId(type=%d, ch=%d, pEsFilterId_addr=0x%x)",
type, ch, pEsFilterId.GetAddr());
if (!pEsFilterId.IsGood())
@ -407,7 +409,7 @@ int cellPamfStreamTypeToEsFilterId(u8 type, u8 ch, mem_ptr_t<CellCodecEsFilterId
int cellPamfReaderGetStreamIndex(mem_ptr_t<CellPamfReader> pSelf)
{
cellPamf.Log("cellPamfReaderGetStreamIndex(pSelf=0x%x)", pSelf.GetAddr());
cellPamf->Log("cellPamfReaderGetStreamIndex(pSelf=0x%x)", pSelf.GetAddr());
if (!pSelf.IsGood())
return CELL_PAMF_ERROR_INVALID_ARG;
@ -417,7 +419,7 @@ int cellPamfReaderGetStreamIndex(mem_ptr_t<CellPamfReader> pSelf)
int cellPamfReaderGetStreamTypeAndChannel(mem_ptr_t<CellPamfReader> pSelf, mem8_t pType, mem8_t pCh)
{
cellPamf.Warning("cellPamfReaderGetStreamTypeAndChannel(pSelf=0x%x (stream=%d), pType_addr=0x%x, pCh_addr=0x%x",
cellPamf->Warning("cellPamfReaderGetStreamTypeAndChannel(pSelf=0x%x (stream=%d), pType_addr=0x%x, pCh_addr=0x%x",
pSelf.GetAddr(), pSelf->stream, pType.GetAddr(), pCh.GetAddr());
if (!pSelf.IsGood() || !pCh.IsGood())
@ -430,7 +432,7 @@ int cellPamfReaderGetStreamTypeAndChannel(mem_ptr_t<CellPamfReader> pSelf, mem8_
int cellPamfReaderGetEsFilterId(mem_ptr_t<CellPamfReader> pSelf, mem_ptr_t<CellCodecEsFilterId> pEsFilterId)
{
cellPamf.Warning("cellPamfReaderGetEsFilterId(pSelf=0x%x (stream=%d), pEsFilterId_addr=0x%x)",
cellPamf->Warning("cellPamfReaderGetEsFilterId(pSelf=0x%x (stream=%d), pEsFilterId_addr=0x%x)",
pSelf.GetAddr(), pSelf->stream, pEsFilterId.GetAddr());
if (!pSelf.IsGood() || !pEsFilterId.IsGood())
@ -442,7 +444,7 @@ int cellPamfReaderGetEsFilterId(mem_ptr_t<CellPamfReader> pSelf, mem_ptr_t<CellC
int cellPamfReaderGetStreamInfo(mem_ptr_t<CellPamfReader> pSelf, u32 pInfo_addr, u32 size)
{
cellPamf.Warning("cellPamfReaderGetStreamInfo(pSelf=0x%x (stream=%d), pInfo_addr=0x%x, size=%d)",
cellPamf->Warning("cellPamfReaderGetStreamInfo(pSelf=0x%x (stream=%d), pInfo_addr=0x%x, size=%d)",
pSelf.GetAddr(), pSelf->stream, pInfo_addr, size);
if (!pSelf.IsGood() || !Memory.IsGoodAddr(pSelf->pAddr))
@ -461,7 +463,7 @@ int cellPamfReaderGetStreamInfo(mem_ptr_t<CellPamfReader> pSelf, u32 pInfo_addr,
if (size != sizeof(CellPamfAvcInfo))
{
cellPamf.Error("cellPamfReaderGetStreamInfo: wrong AVC data size(%d)", size);
cellPamf->Error("cellPamfReaderGetStreamInfo: wrong AVC data size(%d)", size);
return CELL_PAMF_ERROR_INVALID_ARG;
}
@ -481,13 +483,13 @@ int cellPamfReaderGetStreamInfo(mem_ptr_t<CellPamfReader> pSelf, u32 pInfo_addr,
pInfo->matrixCoefficients = 1; //fake
//pInfo->deblockingFilterFlag = 1; //???
cellPamf.Warning("cellPamfReaderGetStreamInfo: CELL_PAMF_STREAM_TYPE_AVC");
cellPamf->Warning("cellPamfReaderGetStreamInfo: CELL_PAMF_STREAM_TYPE_AVC");
}
break;
case CELL_PAMF_STREAM_TYPE_M2V:
{
//TODO
cellPamf.Error("TODO: cellPamfReaderGetStreamInfo: CELL_PAMF_STREAM_TYPE_M2V");
cellPamf->Error("TODO: cellPamfReaderGetStreamInfo: CELL_PAMF_STREAM_TYPE_M2V");
}
break;
case CELL_PAMF_STREAM_TYPE_ATRAC3PLUS:
@ -497,7 +499,7 @@ int cellPamfReaderGetStreamInfo(mem_ptr_t<CellPamfReader> pSelf, u32 pInfo_addr,
if (size != sizeof(CellPamfAtrac3plusInfo))
{
cellPamf.Error("cellPamfReaderGetStreamInfo: wrong ATRAC3+ data size(%d)", size);
cellPamf->Error("cellPamfReaderGetStreamInfo: wrong ATRAC3+ data size(%d)", size);
return CELL_PAMF_ERROR_INVALID_ARG;
}
@ -512,7 +514,7 @@ int cellPamfReaderGetStreamInfo(mem_ptr_t<CellPamfReader> pSelf, u32 pInfo_addr,
if (size != sizeof(CellPamfAc3Info))
{
cellPamf.Error("cellPamfReaderGetStreamInfo: wrong AC3 data size(%d)", size);
cellPamf->Error("cellPamfReaderGetStreamInfo: wrong AC3 data size(%d)", size);
return CELL_PAMF_ERROR_INVALID_ARG;
}
@ -527,7 +529,7 @@ int cellPamfReaderGetStreamInfo(mem_ptr_t<CellPamfReader> pSelf, u32 pInfo_addr,
if (size != sizeof(CellPamfLpcmInfo))
{
cellPamf.Error("cellPamfReaderGetStreamInfo: wrong LPCM data size(%d)", size);
cellPamf->Error("cellPamfReaderGetStreamInfo: wrong LPCM data size(%d)", size);
return CELL_PAMF_ERROR_INVALID_ARG;
}
@ -538,12 +540,12 @@ int cellPamfReaderGetStreamInfo(mem_ptr_t<CellPamfReader> pSelf, u32 pInfo_addr,
pInfo->bitsPerSample = CELL_PAMF_BIT_LENGTH_16;
else
//TODO: CELL_PAMF_BIT_LENGTH_24
cellPamf.Error("cellPamfReaderGetStreamInfo: unknown bps(0x%x)", (u8)pAudio->bps);
cellPamf->Error("cellPamfReaderGetStreamInfo: unknown bps(0x%x)", (u8)pAudio->bps);
}
break;
case CELL_PAMF_STREAM_TYPE_USER_DATA:
{
cellPamf.Error("cellPamfReaderGetStreamInfo: CELL_PAMF_STREAM_TYPE_USER_DATA");
cellPamf->Error("cellPamfReaderGetStreamInfo: CELL_PAMF_STREAM_TYPE_USER_DATA");
return CELL_PAMF_ERROR_INVALID_ARG;
}
}
@ -553,7 +555,7 @@ int cellPamfReaderGetStreamInfo(mem_ptr_t<CellPamfReader> pSelf, u32 pInfo_addr,
int cellPamfReaderGetNumberOfEp(mem_ptr_t<CellPamfReader> pSelf)
{
cellPamf.Warning("cellPamfReaderGetNumberOfEp(pSelf=0x%x (stream=%d))",
cellPamf->Warning("cellPamfReaderGetNumberOfEp(pSelf=0x%x (stream=%d))",
pSelf.GetAddr(), pSelf->stream);
if (!pSelf.IsGood() || !Memory.IsGoodAddr(pSelf->pAddr))
@ -565,7 +567,7 @@ int cellPamfReaderGetNumberOfEp(mem_ptr_t<CellPamfReader> pSelf)
int cellPamfReaderGetEpIteratorWithIndex(mem_ptr_t<CellPamfReader> pSelf, u32 epIndex, mem_ptr_t<CellPamfEpIterator> pIt)
{
cellPamf.Error("cellPamfReaderGetEpIteratorWithIndex(pSelf=0x%x (stream=%d), epIndex=%d, pIt_addr=0x%x)",
cellPamf->Error("cellPamfReaderGetEpIteratorWithIndex(pSelf=0x%x (stream=%d), epIndex=%d, pIt_addr=0x%x)",
pSelf.GetAddr(), pSelf->stream, epIndex, pIt.GetAddr());
if (!pSelf.IsGood() || !Memory.IsGoodAddr(pSelf->pAddr))
@ -578,7 +580,7 @@ int cellPamfReaderGetEpIteratorWithIndex(mem_ptr_t<CellPamfReader> pSelf, u32 ep
int cellPamfReaderGetEpIteratorWithTimeStamp(mem_ptr_t<CellPamfReader> pSelf, mem_ptr_t<CellCodecTimeStamp> pTimeStamp, mem_ptr_t<CellPamfEpIterator> pIt)
{
cellPamf.Error("cellPamfReaderGetEpIteratorWithTimeStamp(pSelf=0x%x, pTimeStamp_addr=0x%x, pIt_addr=0x%x)",
cellPamf->Error("cellPamfReaderGetEpIteratorWithTimeStamp(pSelf=0x%x, pTimeStamp_addr=0x%x, pIt_addr=0x%x)",
pSelf.GetAddr(), pTimeStamp.GetAddr(), pIt.GetAddr());
const mem_ptr_t<PamfHeader> pAddr(pSelf->pAddr);
@ -588,41 +590,42 @@ int cellPamfReaderGetEpIteratorWithTimeStamp(mem_ptr_t<CellPamfReader> pSelf, me
int cellPamfEpIteratorGetEp(mem_ptr_t<CellPamfEpIterator> pIt, mem_ptr_t<CellPamfEp> pEp)
{
cellPamf.Error("cellPamfEpIteratorGetEp(pIt_addr=0x%x, pEp_addr=0x%x)", pIt.GetAddr(), pEp.GetAddr());
cellPamf->Error("cellPamfEpIteratorGetEp(pIt_addr=0x%x, pEp_addr=0x%x)", pIt.GetAddr(), pEp.GetAddr());
//TODO:
return CELL_OK;
}
int cellPamfEpIteratorMove(mem_ptr_t<CellPamfEpIterator> pIt, s32 steps, mem_ptr_t<CellPamfEp> pEp)
{
cellPamf.Error("cellPamfEpIteratorMove(pIt_addr=0x%x, steps=%d, pEp_addr=0x%x)", pIt.GetAddr(), steps, pEp.GetAddr());
cellPamf->Error("cellPamfEpIteratorMove(pIt_addr=0x%x, steps=%d, pEp_addr=0x%x)", pIt.GetAddr(), steps, pEp.GetAddr());
//TODO:
return CELL_OK;
}
void cellPamf_init()
{
cellPamf.AddFunc(0xca8181c1, cellPamfGetHeaderSize);
cellPamf.AddFunc(0x90fc9a59, cellPamfGetHeaderSize2);
cellPamf.AddFunc(0x44f5c9e3, cellPamfGetStreamOffsetAndSize);
cellPamf.AddFunc(0xd1a40ef4, cellPamfVerify);
cellPamf.AddFunc(0xb8436ee5, cellPamfReaderInitialize);
cellPamf.AddFunc(0x4de501b1, cellPamfReaderGetPresentationStartTime);
cellPamf.AddFunc(0xf61609d6, cellPamfReaderGetPresentationEndTime);
cellPamf.AddFunc(0xdb70296c, cellPamfReaderGetMuxRateBound);
cellPamf.AddFunc(0x37f723f7, cellPamfReaderGetNumberOfStreams);
cellPamf.AddFunc(0xd0230671, cellPamfReaderGetNumberOfSpecificStreams);
cellPamf.AddFunc(0x461534b4, cellPamfReaderSetStreamWithIndex);
cellPamf.AddFunc(0x03fd2caa, cellPamfReaderSetStreamWithTypeAndChannel);
cellPamf.AddFunc(0x28b4e2c1, cellPamfReaderSetStreamWithTypeAndIndex);
cellPamf.AddFunc(0x01067e22, cellPamfStreamTypeToEsFilterId);
cellPamf.AddFunc(0x041cc708, cellPamfReaderGetStreamIndex);
cellPamf.AddFunc(0x9ab20793, cellPamfReaderGetStreamTypeAndChannel);
cellPamf.AddFunc(0x71df326a, cellPamfReaderGetEsFilterId);
cellPamf.AddFunc(0x67fd273b, cellPamfReaderGetStreamInfo);
cellPamf.AddFunc(0xd9ea3457, cellPamfReaderGetNumberOfEp);
cellPamf.AddFunc(0xe8586ec6, cellPamfReaderGetEpIteratorWithIndex);
cellPamf.AddFunc(0x439fba17, cellPamfReaderGetEpIteratorWithTimeStamp);
cellPamf.AddFunc(0x1abeb9d6, cellPamfEpIteratorGetEp);
cellPamf.AddFunc(0x50b83205, cellPamfEpIteratorMove);
cellPamf->AddFunc(0xca8181c1, cellPamfGetHeaderSize);
cellPamf->AddFunc(0x90fc9a59, cellPamfGetHeaderSize2);
cellPamf->AddFunc(0x44f5c9e3, cellPamfGetStreamOffsetAndSize);
cellPamf->AddFunc(0xd1a40ef4, cellPamfVerify);
cellPamf->AddFunc(0xb8436ee5, cellPamfReaderInitialize);
cellPamf->AddFunc(0x4de501b1, cellPamfReaderGetPresentationStartTime);
cellPamf->AddFunc(0xf61609d6, cellPamfReaderGetPresentationEndTime);
cellPamf->AddFunc(0xdb70296c, cellPamfReaderGetMuxRateBound);
cellPamf->AddFunc(0x37f723f7, cellPamfReaderGetNumberOfStreams);
cellPamf->AddFunc(0xd0230671, cellPamfReaderGetNumberOfSpecificStreams);
cellPamf->AddFunc(0x461534b4, cellPamfReaderSetStreamWithIndex);
cellPamf->AddFunc(0x03fd2caa, cellPamfReaderSetStreamWithTypeAndChannel);
cellPamf->AddFunc(0x28b4e2c1, cellPamfReaderSetStreamWithTypeAndIndex);
cellPamf->AddFunc(0x01067e22, cellPamfStreamTypeToEsFilterId);
cellPamf->AddFunc(0x041cc708, cellPamfReaderGetStreamIndex);
cellPamf->AddFunc(0x9ab20793, cellPamfReaderGetStreamTypeAndChannel);
cellPamf->AddFunc(0x71df326a, cellPamfReaderGetEsFilterId);
cellPamf->AddFunc(0x67fd273b, cellPamfReaderGetStreamInfo);
cellPamf->AddFunc(0xd9ea3457, cellPamfReaderGetNumberOfEp);
cellPamf->AddFunc(0xe8586ec6, cellPamfReaderGetEpIteratorWithIndex);
cellPamf->AddFunc(0x439fba17, cellPamfReaderGetEpIteratorWithTimeStamp);
cellPamf->AddFunc(0x1abeb9d6, cellPamfEpIteratorGetEp);
cellPamf->AddFunc(0x50b83205, cellPamfEpIteratorMove);
}

2
rpcs3/Emu/SysCalls/Modules/cellPhotoDecode.cpp
View File

@ -65,4 +65,4 @@ void cellPhotoDecode_init()
cellPhotoDecode.AddFunc(0xad7d8f38, cellPhotoDecodeFinalize);
cellPhotoDecode.AddFunc(0x28b22e44, cellPhotoDecodeFromFile);
}
#endif
#endif

88
rpcs3/Emu/SysCalls/Modules/cellPngDec.cpp
View File

@ -9,8 +9,9 @@
#include "stblib/stb_image.h"
#include <map>
void cellPngDec_init();
Module cellPngDec(0x0018, cellPngDec_init);
//void cellPngDec_init();
//Module cellPngDec(0x0018, cellPngDec_init);
extern Module *cellPngDec = nullptr;
static std::map<u32, CellPngDecMainHandle *> cellPngDecMap;
@ -23,7 +24,7 @@ CellPngDecMainHandle *getCellPngDecCtx(u32 mainHandle) {
int cellPngDecCreate(u32 mainHandle, u32 threadInParam, u32 threadOutParam)
{
cellPngDec.Warning("cellPngDecCreate(mainHandle=0x%x, threadInParam=0x%x, threadOutParam=0x%x)", mainHandle, threadInParam, threadOutParam);
cellPngDec->Warning("cellPngDecCreate(mainHandle=0x%x, threadInParam=0x%x, threadOutParam=0x%x)", mainHandle, threadInParam, threadOutParam);
CellPngDecMainHandle *ctx = new CellPngDecMainHandle;
if (cellPngDecMap.find(mainHandle) != cellPngDecMap.end()) {
delete cellPngDecMap[mainHandle];
@ -39,10 +40,10 @@ int cellPngDecCreate(u32 mainHandle, u32 threadInParam, u32 threadOutParam)
int cellPngDecDestroy(u32 mainHandle)
{
cellPngDec.Warning("cellPngDecDestroy(mainHandle=0x%x)", mainHandle);
cellPngDec->Warning("cellPngDecDestroy(mainHandle=0x%x)", mainHandle);
CellPngDecMainHandle *ctx = getCellPngDecCtx(mainHandle);
if (!ctx) {
cellPngDec.Warning("cellPngDecDestroy(mainHandle=0x%x): bad handle", mainHandle);
cellPngDec->Warning("cellPngDecDestroy(mainHandle=0x%x): bad handle", mainHandle);
return -1;
}
@ -54,7 +55,7 @@ int cellPngDecDestroy(u32 mainHandle)
int cellPngDecOpen(u32 mainHandle, mem32_t subHandle, mem_ptr_t<CellPngDecSrc> src, u32 openInfo)
{
cellPngDec.Warning("cellPngDecOpen(mainHandle=0x%x, subHandle=0x%x, src_addr=0x%x, openInfo=0x%x)",
cellPngDec->Warning("cellPngDecOpen(mainHandle=0x%x, subHandle=0x%x, src_addr=0x%x, openInfo=0x%x)",
mainHandle, subHandle.GetAddr(), src.GetAddr(), openInfo);
if (!subHandle.IsGood() || !src.IsGood())
@ -87,17 +88,17 @@ int cellPngDecOpen(u32 mainHandle, mem32_t subHandle, mem_ptr_t<CellPngDecSrc> s
}
// From now, every u32 subHandle argument is a pointer to a CellPngDecSubHandle struct.
subHandle = cellPngDec.GetNewId(current_subHandle);
subHandle = cellPngDec->GetNewId(current_subHandle);
return CELL_OK;
}
int cellPngDecClose(u32 mainHandle, u32 subHandle)
{
cellPngDec.Warning("cellPngDecClose(mainHandle=0x%x,subHandle=0x%x)", mainHandle, subHandle);
cellPngDec->Warning("cellPngDecClose(mainHandle=0x%x,subHandle=0x%x)", mainHandle, subHandle);
CellPngDecSubHandle* subHandle_data;
if(!cellPngDec.CheckId(subHandle, subHandle_data))
if(!cellPngDec->CheckId(subHandle, subHandle_data))
return CELL_PNGDEC_ERROR_FATAL;
cellFsClose(subHandle_data->fd);
@ -111,9 +112,9 @@ int cellPngDecReadHeader(u32 mainHandle, u32 subHandle, mem_ptr_t<CellPngDecInfo
if (!info.IsGood())
return CELL_PNGDEC_ERROR_ARG;
cellPngDec.Warning("cellPngDecReadHeader(mainHandle=0x%x, subHandle=0x%x, info_addr=0x%llx)", mainHandle, subHandle, info.GetAddr());
cellPngDec->Warning("cellPngDecReadHeader(mainHandle=0x%x, subHandle=0x%x, info_addr=0x%llx)", mainHandle, subHandle, info.GetAddr());
CellPngDecSubHandle* subHandle_data;
if(!cellPngDec.CheckId(subHandle, subHandle_data))
if(!cellPngDec->CheckId(subHandle, subHandle_data))
return CELL_PNGDEC_ERROR_FATAL;
const u32& fd = subHandle_data->fd;
@ -173,7 +174,7 @@ int cellPngDecDecodeData(u32 mainHandle, u32 subHandle, mem8_ptr_t data, const m
dataOutInfo->status = CELL_PNGDEC_DEC_STATUS_STOP;
CellPngDecSubHandle* subHandle_data;
if(!cellPngDec.CheckId(subHandle, subHandle_data))
if(!cellPngDec->CheckId(subHandle, subHandle_data))
return CELL_PNGDEC_ERROR_FATAL;
const u32& fd = subHandle_data->fd;
@ -211,6 +212,7 @@ int cellPngDecDecodeData(u32 mainHandle, u32 subHandle, mem8_ptr_t data, const m
switch((u32)current_outParam.outputColorSpace)
{
case CELL_PNGDEC_RGB:
image_size = width * height;
case CELL_PNGDEC_RGBA:
{
const char nComponents = current_outParam.outputColorSpace == CELL_PNGDEC_RGBA ? 4 : 3;
@ -278,7 +280,7 @@ int cellPngDecDecodeData(u32 mainHandle, u32 subHandle, mem8_ptr_t data, const m
case CELL_PNGDEC_GRAYSCALE:
case CELL_PNGDEC_PALETTE:
case CELL_PNGDEC_GRAYSCALE_ALPHA:
cellPngDec.Error("cellPngDecDecodeData: Unsupported color space (%d)", current_outParam.outputColorSpace.ToLE());
cellPngDec->Error("cellPngDecDecodeData: Unsupported color space (%d)", current_outParam.outputColorSpace.ToLE());
break;
default:
@ -296,7 +298,7 @@ int cellPngDecSetParameter(u32 mainHandle, u32 subHandle, const mem_ptr_t<CellPn
return CELL_PNGDEC_ERROR_ARG;
CellPngDecSubHandle* subHandle_data;
if(!cellPngDec.CheckId(subHandle, subHandle_data))
if(!cellPngDec->CheckId(subHandle, subHandle_data))
return CELL_PNGDEC_ERROR_FATAL;
CellPngDecInfo& current_info = subHandle_data->info;
@ -333,34 +335,34 @@ int cellPngDecSetParameter(u32 mainHandle, u32 subHandle, const mem_ptr_t<CellPn
void cellPngDec_init()
{
cellPngDec.AddFunc(0x157d30c5, cellPngDecCreate);
cellPngDec.AddFunc(0x820dae1a, cellPngDecDestroy);
cellPngDec.AddFunc(0xd2bc5bfd, cellPngDecOpen);
cellPngDec.AddFunc(0x5b3d1ff1, cellPngDecClose);
cellPngDec.AddFunc(0x9ccdcc95, cellPngDecReadHeader);
cellPngDec.AddFunc(0x2310f155, cellPngDecDecodeData);
cellPngDec.AddFunc(0xe97c9bd4, cellPngDecSetParameter);
cellPngDec->AddFunc(0x157d30c5, cellPngDecCreate);
cellPngDec->AddFunc(0x820dae1a, cellPngDecDestroy);
cellPngDec->AddFunc(0xd2bc5bfd, cellPngDecOpen);
cellPngDec->AddFunc(0x5b3d1ff1, cellPngDecClose);
cellPngDec->AddFunc(0x9ccdcc95, cellPngDecReadHeader);
cellPngDec->AddFunc(0x2310f155, cellPngDecDecodeData);
cellPngDec->AddFunc(0xe97c9bd4, cellPngDecSetParameter);
/*cellPngDec.AddFunc(0x48436b2d, cellPngDecExtCreate);
cellPngDec.AddFunc(0x0c515302, cellPngDecExtOpen);
cellPngDec.AddFunc(0x8b33f863, cellPngDecExtReadHeader);
cellPngDec.AddFunc(0x726fc1d0, cellPngDecExtDecodeData);
cellPngDec.AddFunc(0x9e9d7d42, cellPngDecExtSetParameter);
cellPngDec.AddFunc(0x7585a275, cellPngDecGetbKGD);
cellPngDec.AddFunc(0x7a062d26, cellPngDecGetcHRM);
cellPngDec.AddFunc(0xb153629c, cellPngDecGetgAMA);
cellPngDec.AddFunc(0xb905ebb7, cellPngDecGethIST);
cellPngDec.AddFunc(0xf44b6c30, cellPngDecGetiCCP);
cellPngDec.AddFunc(0x27c921b5, cellPngDecGetoFFs);
cellPngDec.AddFunc(0xb4fe75e1, cellPngDecGetpCAL);
cellPngDec.AddFunc(0x3d50016a, cellPngDecGetpHYs);
cellPngDec.AddFunc(0x30cb334a, cellPngDecGetsBIT);
cellPngDec.AddFunc(0xc41e1198, cellPngDecGetsCAL);
cellPngDec.AddFunc(0xa5cdf57e, cellPngDecGetsPLT);
cellPngDec.AddFunc(0xe4416e82, cellPngDecGetsRGB);
cellPngDec.AddFunc(0x35a6846c, cellPngDecGettIME);
cellPngDec.AddFunc(0xb96fb26e, cellPngDecGettRNS);
cellPngDec.AddFunc(0xe163977f, cellPngDecGetPLTE);
cellPngDec.AddFunc(0x609ec7d5, cellPngDecUnknownChunks);
cellPngDec.AddFunc(0xb40ca175, cellPngDecGetTextChunk);*/
/*cellPngDec->AddFunc(0x48436b2d, cellPngDecExtCreate);
cellPngDec->AddFunc(0x0c515302, cellPngDecExtOpen);
cellPngDec->AddFunc(0x8b33f863, cellPngDecExtReadHeader);
cellPngDec->AddFunc(0x726fc1d0, cellPngDecExtDecodeData);
cellPngDec->AddFunc(0x9e9d7d42, cellPngDecExtSetParameter);
cellPngDec->AddFunc(0x7585a275, cellPngDecGetbKGD);
cellPngDec->AddFunc(0x7a062d26, cellPngDecGetcHRM);
cellPngDec->AddFunc(0xb153629c, cellPngDecGetgAMA);
cellPngDec->AddFunc(0xb905ebb7, cellPngDecGethIST);
cellPngDec->AddFunc(0xf44b6c30, cellPngDecGetiCCP);
cellPngDec->AddFunc(0x27c921b5, cellPngDecGetoFFs);
cellPngDec->AddFunc(0xb4fe75e1, cellPngDecGetpCAL);
cellPngDec->AddFunc(0x3d50016a, cellPngDecGetpHYs);
cellPngDec->AddFunc(0x30cb334a, cellPngDecGetsBIT);
cellPngDec->AddFunc(0xc41e1198, cellPngDecGetsCAL);
cellPngDec->AddFunc(0xa5cdf57e, cellPngDecGetsPLT);
cellPngDec->AddFunc(0xe4416e82, cellPngDecGetsRGB);
cellPngDec->AddFunc(0x35a6846c, cellPngDecGettIME);
cellPngDec->AddFunc(0xb96fb26e, cellPngDecGettRNS);
cellPngDec->AddFunc(0xe163977f, cellPngDecGetPLTE);
cellPngDec->AddFunc(0x609ec7d5, cellPngDecUnknownChunks);
cellPngDec->AddFunc(0xb40ca175, cellPngDecGetTextChunk);*/
}

155
rpcs3/Emu/SysCalls/Modules/cellResc.cpp
View File

@ -7,10 +7,11 @@
#include "Emu/SysCalls/Modules.h"
#include "cellResc.h"
void cellResc_init();
void cellResc_load();
void cellResc_unload();
Module cellResc(0x001f, cellResc_init, cellResc_load, cellResc_unload);
//void cellResc_init();
//void cellResc_load();
//void cellResc_unload();
//Module cellResc(0x001f, cellResc_init, cellResc_load, cellResc_unload);
Module *cellResc = nullptr;
// Error Codes
enum
@ -419,16 +420,16 @@ void InitVertex(mem_ptr_t<CellGcmContextData>& cntxt)
// Module Functions
int cellRescInit(mem_ptr_t<CellRescInitConfig> initConfig)
{
cellResc.Warning("cellRescInit(initConfig_addr=0x%x)", initConfig.GetAddr());
cellResc->Warning("cellRescInit(initConfig_addr=0x%x)", initConfig.GetAddr());
if (s_rescInternalInstance->m_bInitialized)
{
cellResc.Error("cellRescInit : CELL_RESC_ERROR_REINITIALIZED");
cellResc->Error("cellRescInit : CELL_RESC_ERROR_REINITIALIZED");
return CELL_RESC_ERROR_REINITIALIZED;
}
if (!initConfig.IsGood() || InternalVersion(initConfig.GetAddr()) == -1 || !CheckInitConfig(initConfig))
{
cellResc.Error("cellRescInit : CELL_RESC_ERROR_BAD_ARGUMENT");
cellResc->Error("cellRescInit : CELL_RESC_ERROR_BAD_ARGUMENT");
return CELL_RESC_ERROR_BAD_ARGUMENT;
}
@ -441,11 +442,11 @@ int cellRescInit(mem_ptr_t<CellRescInitConfig> initConfig)
void cellRescExit()
{
cellResc.Warning("cellRescExit()");
cellResc->Warning("cellRescExit()");
if(!s_rescInternalInstance->m_bInitialized)
{
cellResc.Error("cellRescExit()");
cellResc->Error("cellRescExit()");
return;
}
@ -456,11 +457,11 @@ void cellRescExit()
int cellRescVideoOutResolutionId2RescBufferMode(u32 resolutionId, mem32_t bufferMode)
{
cellResc.Log("cellRescVideoOutResolutionId2RescBufferMode(resolutionId=%d, bufferMode_addr=0x%x)", resolutionId, bufferMode.GetAddr());
cellResc->Log("cellRescVideoOutResolutionId2RescBufferMode(resolutionId=%d, bufferMode_addr=0x%x)", resolutionId, bufferMode.GetAddr());
if (!bufferMode.IsGood())
{
cellResc.Error("cellRescVideoOutResolutionId2RescBufferMode : CELL_RESC_ERROR_BAD_ARGUMENT");
cellResc->Error("cellRescVideoOutResolutionId2RescBufferMode : CELL_RESC_ERROR_BAD_ARGUMENT");
return CELL_RESC_ERROR_BAD_ARGUMENT;
}
@ -471,7 +472,7 @@ int cellRescVideoOutResolutionId2RescBufferMode(u32 resolutionId, mem32_t buffer
case CELL_VIDEO_OUT_RESOLUTION_480: bufferMode = CELL_RESC_720x480; break;
case CELL_VIDEO_OUT_RESOLUTION_576: bufferMode = CELL_RESC_720x576; break;
default:
cellResc.Error("cellRescVideoOutResolutionId2RescBufferMod : CELL_RESC_ERROR_BAD_ARGUMENT");
cellResc->Error("cellRescVideoOutResolutionId2RescBufferMod : CELL_RESC_ERROR_BAD_ARGUMENT");
return CELL_RESC_ERROR_BAD_ARGUMENT;
}
@ -480,24 +481,24 @@ int cellRescVideoOutResolutionId2RescBufferMode(u32 resolutionId, mem32_t buffer
int cellRescSetDsts(u32 dstsMode, mem_ptr_t<CellRescDsts> dsts)
{
cellResc.Log("cellRescSetDsts(dstsMode=%d, CellRescDsts_addr=0x%x)", dstsMode, dsts.GetAddr());
cellResc->Log("cellRescSetDsts(dstsMode=%d, CellRescDsts_addr=0x%x)", dstsMode, dsts.GetAddr());
if (!s_rescInternalInstance->m_bInitialized)
{
cellResc.Error("cellRescSetDst : CELL_RESC_ERROR_NOT_INITIALIZED");
cellResc->Error("cellRescSetDst : CELL_RESC_ERROR_NOT_INITIALIZED");
return CELL_RESC_ERROR_NOT_INITIALIZED;
}
if (!dsts.IsGood())
{
cellResc.Error("cellRescSetDst : CELL_RESC_ERROR_BAD_ARGUMENT");
cellResc->Error("cellRescSetDst : CELL_RESC_ERROR_BAD_ARGUMENT");
return CELL_RESC_ERROR_BAD_ARGUMENT;
}
if ((dstsMode != CELL_RESC_720x480) && (dstsMode != CELL_RESC_720x576) &&
(dstsMode != CELL_RESC_1280x720) && (dstsMode != CELL_RESC_1920x1080))
{
cellResc.Error("cellRescSetDsts : CELL_RESC_ERROR_BAD_ARGUMENT");
cellResc->Error("cellRescSetDsts : CELL_RESC_ERROR_BAD_ARGUMENT");
return CELL_RESC_ERROR_BAD_ARGUMENT;
}
@ -508,24 +509,24 @@ int cellRescSetDsts(u32 dstsMode, mem_ptr_t<CellRescDsts> dsts)
int cellRescSetDisplayMode(u32 displayMode)
{
cellResc.Warning("cellRescSetDisplayMode(displayMode=%d)", displayMode);
cellResc->Warning("cellRescSetDisplayMode(displayMode=%d)", displayMode);
if (!s_rescInternalInstance->m_bInitialized)
{
cellResc.Error("cellRescSetDisplayMode : CELL_RESC_ERROR_NOT_INITIALIZED");
cellResc->Error("cellRescSetDisplayMode : CELL_RESC_ERROR_NOT_INITIALIZED");
return CELL_RESC_ERROR_NOT_INITIALIZED;
}
if (!(s_rescInternalInstance->m_initConfig.supportModes & displayMode))
{
cellResc.Error("cellRescSetDisplayMode : CELL_RESC_ERROR_BAD_ARGUMENT");
cellResc->Error("cellRescSetDisplayMode : CELL_RESC_ERROR_BAD_ARGUMENT");
return CELL_RESC_ERROR_BAD_ARGUMENT;
}
if ((displayMode != CELL_RESC_720x480) && (displayMode != CELL_RESC_720x576) &&
(displayMode != CELL_RESC_1280x720) && (displayMode != CELL_RESC_1920x1080))
{
cellResc.Error("cellRescSetDisplayMode : CELL_RESC_ERROR_BAD_ARGUMENT");
cellResc->Error("cellRescSetDisplayMode : CELL_RESC_ERROR_BAD_ARGUMENT");
return CELL_RESC_ERROR_BAD_ARGUMENT;
}
@ -533,13 +534,13 @@ int cellRescSetDisplayMode(u32 displayMode)
if ((IsPalInterpolate() || IsPalDrop()) && s_rescInternalInstance->m_initConfig.flipMode == CELL_RESC_DISPLAY_HSYNC)
{
cellResc.Error("cellRescSetDisplayMode : CELL_RESC_ERROR_BAD_COMBINATIONT");
cellResc->Error("cellRescSetDisplayMode : CELL_RESC_ERROR_BAD_COMBINATIONT");
return CELL_RESC_ERROR_BAD_COMBINATION;
}
if(IsPal60Hsync() && s_rescInternalInstance->m_initConfig.flipMode==CELL_RESC_DISPLAY_VSYNC)
{
cellResc.Error("cellRescSetDisplayMode : CELL_RESC_ERROR_BAD_COMBINATIONT");
cellResc->Error("cellRescSetDisplayMode : CELL_RESC_ERROR_BAD_COMBINATIONT");
return CELL_RESC_ERROR_BAD_COMBINATION;
}
@ -598,17 +599,17 @@ int cellRescSetDisplayMode(u32 displayMode)
int cellRescAdjustAspectRatio(float horizontal, float vertical)
{
cellResc.Warning("cellRescAdjustAspectRatio(horizontal=%f, vertical=%f)", horizontal, vertical);
cellResc->Warning("cellRescAdjustAspectRatio(horizontal=%f, vertical=%f)", horizontal, vertical);
if(!s_rescInternalInstance->m_bInitialized)
{
cellResc.Error("cellRescAdjustAspectRatio : CELL_RESC_ERROR_NOT_INITIALIZED");
cellResc->Error("cellRescAdjustAspectRatio : CELL_RESC_ERROR_NOT_INITIALIZED");
return CELL_RESC_ERROR_NOT_INITIALIZED;
}
if((horizontal < 0.5f || 2.f < horizontal) || (vertical < 0.5f || 2.f < vertical))
{
cellResc.Error("cellRescAdjustAspectRatio : CELL_RESC_ERROR_BAD_ARGUMENT");
cellResc->Error("cellRescAdjustAspectRatio : CELL_RESC_ERROR_BAD_ARGUMENT");
return CELL_RESC_ERROR_BAD_ARGUMENT;
}
@ -628,17 +629,17 @@ int cellRescAdjustAspectRatio(float horizontal, float vertical)
int cellRescSetPalInterpolateDropFlexRatio(float ratio)
{
cellResc.Warning("cellRescSetPalInterpolateDropFlexRatio(ratio=%f)", ratio);
cellResc->Warning("cellRescSetPalInterpolateDropFlexRatio(ratio=%f)", ratio);
if(!s_rescInternalInstance->m_bInitialized)
{
cellResc.Error("cellRescSetPalInterpolateDropFlexRatio : CELL_RESC_ERROR_NOT_INITIALIZED");
cellResc->Error("cellRescSetPalInterpolateDropFlexRatio : CELL_RESC_ERROR_NOT_INITIALIZED");
return CELL_RESC_ERROR_NOT_INITIALIZED;
}
if(ratio < 0.f || 1.f < ratio)
{
cellResc.Error("cellRescSetPalInterpolateDropFlexRatio : CELL_RESC_ERROR_BAD_ARGUMENT");
cellResc->Error("cellRescSetPalInterpolateDropFlexRatio : CELL_RESC_ERROR_BAD_ARGUMENT");
return CELL_RESC_ERROR_BAD_ARGUMENT;
}
@ -649,11 +650,11 @@ int cellRescSetPalInterpolateDropFlexRatio(float ratio)
int cellRescGetBufferSize(mem32_t colorBuffers, mem32_t vertexArray, mem32_t fragmentShader)
{
cellResc.Warning("cellRescGetBufferSize(colorBuffers_addr=0x%x, vertexArray_addr=0x%x, fragmentShader_addr=0x%x)", colorBuffers.GetAddr(), vertexArray.GetAddr(), fragmentShader.GetAddr());
cellResc->Warning("cellRescGetBufferSize(colorBuffers_addr=0x%x, vertexArray_addr=0x%x, fragmentShader_addr=0x%x)", colorBuffers.GetAddr(), vertexArray.GetAddr(), fragmentShader.GetAddr());
if (!s_rescInternalInstance->m_bInitialized)
{
cellResc.Error("cellRescGetBufferSize : CELL_RESC_ERROR_NOT_INITIALIZED");
cellResc->Error("cellRescGetBufferSize : CELL_RESC_ERROR_NOT_INITIALIZED");
return CELL_RESC_ERROR_NOT_INITIALIZED;
}
@ -681,11 +682,11 @@ int cellRescGetBufferSize(mem32_t colorBuffers, mem32_t vertexArray, mem32_t fra
int cellRescGetNumColorBuffers(u32 dstMode, u32 palTemporalMode, u32 reserved)
{
cellResc.Log("cellRescGetNumColorBuffers(dstMode=%d, palTemporalMode=%d, reserved=%d)", dstMode, palTemporalMode, reserved);
cellResc->Log("cellRescGetNumColorBuffers(dstMode=%d, palTemporalMode=%d, reserved=%d)", dstMode, palTemporalMode, reserved);
if (reserved != 0)
{
cellResc.Error("cellRescGetNumColorBuffers : CELL_RESC_ERROR_BAD_ARGUMENT");
cellResc->Error("cellRescGetNumColorBuffers : CELL_RESC_ERROR_BAD_ARGUMENT");
return CELL_RESC_ERROR_BAD_ARGUMENT;
}
@ -702,11 +703,11 @@ int cellRescGetNumColorBuffers(u32 dstMode, u32 palTemporalMode, u32 reserved)
int cellRescGcmSurface2RescSrc(mem_ptr_t<CellGcmSurface> gcmSurface, mem_ptr_t<CellRescSrc> rescSrc)
{
cellResc.Log("cellRescGcmSurface2RescSrc(gcmSurface_addr=0x%x, rescSrc_addr=0x%x)", gcmSurface.GetAddr(), rescSrc.GetAddr());
cellResc->Log("cellRescGcmSurface2RescSrc(gcmSurface_addr=0x%x, rescSrc_addr=0x%x)", gcmSurface.GetAddr(), rescSrc.GetAddr());
if(!gcmSurface.IsGood() || !rescSrc.IsGood())
{
cellResc.Error("cellRescGcmSurface2RescSrc : CELL_RESC_ERROR_BAD_ARGUMENT");
cellResc->Error("cellRescGcmSurface2RescSrc : CELL_RESC_ERROR_BAD_ARGUMENT");
return CELL_RESC_ERROR_BAD_ARGUMENT;
}
@ -732,32 +733,32 @@ int cellRescGcmSurface2RescSrc(mem_ptr_t<CellGcmSurface> gcmSurface, mem_ptr_t<C
int cellRescSetSrc(s32 idx, mem_ptr_t<CellRescSrc> src)
{
cellResc.Log("cellRescSetSrc(idx=0x%x, src_addr=0x%x)", idx, src.GetAddr());
cellResc->Log("cellRescSetSrc(idx=0x%x, src_addr=0x%x)", idx, src.GetAddr());
if(!s_rescInternalInstance->m_bInitialized)
{
cellResc.Error("cellRescSetSrc : CELL_RESC_ERROR_NOT_INITIALIZED");
cellResc->Error("cellRescSetSrc : CELL_RESC_ERROR_NOT_INITIALIZED");
return CELL_RESC_ERROR_NOT_INITIALIZED;
}
if(idx < 0 || SRC_BUFFER_NUM <= idx || !src.IsGood())
{
cellResc.Error("cellRescSetSrc : CELL_RESC_ERROR_BAD_ARGUMENT");
cellResc->Error("cellRescSetSrc : CELL_RESC_ERROR_BAD_ARGUMENT");
return CELL_RESC_ERROR_BAD_ARGUMENT;
}
if(src->width < 1 || 4096 < src->width || src->height < 1 || 4096 < src->height)
{
cellResc.Error("cellRescSetSrc : CELL_RESC_ERROR_BAD_ARGUMENT");
cellResc->Error("cellRescSetSrc : CELL_RESC_ERROR_BAD_ARGUMENT");
return CELL_RESC_ERROR_BAD_ARGUMENT;
}
cellResc.Log(" *** format=0x%x", src->format.ToLE());
cellResc.Log(" *** pitch=%d", src->pitch.ToLE());
cellResc.Log(" *** width=%d", src->width.ToLE());
cellResc.Log(" *** height=%d", src->height.ToLE());
cellResc.Log(" *** offset=0x%x", src->offset.ToLE());
cellResc->Log(" *** format=0x%x", src->format.ToLE());
cellResc->Log(" *** pitch=%d", src->pitch.ToLE());
cellResc->Log(" *** width=%d", src->width.ToLE());
cellResc->Log(" *** height=%d", src->height.ToLE());
cellResc->Log(" *** offset=0x%x", src->offset.ToLE());
//Emu.GetGSManager().GetRender().SetData(src.offset, 800, 600);
//Emu.GetGSManager().GetRender().Draw();
@ -770,17 +771,17 @@ int cellRescSetSrc(s32 idx, mem_ptr_t<CellRescSrc> src)
int cellRescSetConvertAndFlip(mem_ptr_t<CellGcmContextData> cntxt, s32 idx)
{
cellResc.Log("cellRescSetConvertAndFlip(cntxt_addr=0x%x, indx=0x%x)", cntxt.GetAddr(), idx);
cellResc->Log("cellRescSetConvertAndFlip(cntxt_addr=0x%x, indx=0x%x)", cntxt.GetAddr(), idx);
if(!s_rescInternalInstance->m_bInitialized)
{
cellResc.Error("cellRescSetConvertAndFlip : CELL_RESC_ERROR_NOT_INITIALIZED");
cellResc->Error("cellRescSetConvertAndFlip : CELL_RESC_ERROR_NOT_INITIALIZED");
return CELL_RESC_ERROR_NOT_INITIALIZED;
}
if(idx < 0 || SRC_BUFFER_NUM <= idx)
{
cellResc.Error("cellRescSetConvertAndFlip : CELL_RESC_ERROR_BAD_ARGUMENT");
cellResc->Error("cellRescSetConvertAndFlip : CELL_RESC_ERROR_BAD_ARGUMENT");
return CELL_RESC_ERROR_BAD_ARGUMENT;
}
@ -800,7 +801,7 @@ int cellRescSetConvertAndFlip(mem_ptr_t<CellGcmContextData> cntxt, s32 idx)
int cellRescSetWaitFlip()
{
cellResc.Log("cellRescSetWaitFlip()");
cellResc->Log("cellRescSetWaitFlip()");
GSLockCurrent lock(GS_LOCK_WAIT_FLIP); // could stall on exit
return CELL_OK;
@ -808,17 +809,17 @@ int cellRescSetWaitFlip()
int cellRescSetBufferAddress(mem32_t colorBuffers, mem32_t vertexArray, mem32_t fragmentShader)
{
cellResc.Warning("cellRescSetBufferAddress(colorBuffers_addr=0x%x, vertexArray_addr=0x%x, fragmentShader_addr=0x%x)", colorBuffers.GetAddr(), vertexArray.GetAddr(), fragmentShader.GetAddr());
cellResc->Warning("cellRescSetBufferAddress(colorBuffers_addr=0x%x, vertexArray_addr=0x%x, fragmentShader_addr=0x%x)", colorBuffers.GetAddr(), vertexArray.GetAddr(), fragmentShader.GetAddr());
if(!s_rescInternalInstance->m_bInitialized)
{
cellResc.Error("cellRescSetBufferAddress : CELL_RESC_ERROR_NOT_INITIALIZED");
cellResc->Error("cellRescSetBufferAddress : CELL_RESC_ERROR_NOT_INITIALIZED");
return CELL_RESC_ERROR_NOT_INITIALIZED;
}
if(!colorBuffers.IsGood() || !vertexArray.IsGood() || !fragmentShader.IsGood())
{
cellResc.Error("cellRescSetBufferAddress : CELL_RESC_ERROR_BAD_ARGUMENT");
cellResc->Error("cellRescSetBufferAddress : CELL_RESC_ERROR_BAD_ARGUMENT");
return CELL_RESC_ERROR_BAD_ARGUMENT;
}
@ -826,7 +827,7 @@ int cellRescSetBufferAddress(mem32_t colorBuffers, mem32_t vertexArray, mem32_t
vertexArray.GetAddr() % VERTEX_BUFFER_ALIGNMENT ||
fragmentShader.GetAddr() % FRAGMENT_SHADER_ALIGNMENT)
{
cellResc.Error("cellRescSetBufferAddress : CELL_RESC_ERROR_BAD_ARGUMENT");
cellResc->Error("cellRescSetBufferAddress : CELL_RESC_ERROR_BAD_ARGUMENT");
return CELL_RESC_ERROR_BAD_ARGUMENT;
}
@ -858,11 +859,11 @@ int cellRescSetBufferAddress(mem32_t colorBuffers, mem32_t vertexArray, mem32_t
int cellRescSetFlipHandler(u32 handler_addr)
{
cellResc.Warning("cellRescSetFlipHandler(handler_addr=0x%x)", handler_addr);
cellResc->Warning("cellRescSetFlipHandler(handler_addr=0x%x)", handler_addr);
if (handler_addr != 0 && !Memory.IsGoodAddr(handler_addr))
{
cellResc.Error("cellRescSetFlipHandler : CELL_EFAULT");
cellResc->Error("cellRescSetFlipHandler : CELL_EFAULT");
return CELL_EFAULT;
}
@ -873,14 +874,14 @@ int cellRescSetFlipHandler(u32 handler_addr)
void cellRescResetFlipStatus()
{
cellResc.Log("cellRescResetFlipStatus()");
cellResc->Log("cellRescResetFlipStatus()");
Emu.GetGSManager().GetRender().m_flip_status = 1;
}
int cellRescGetFlipStatus()
{
cellResc.Log("cellRescGetFlipStatus()");
cellResc->Log("cellRescGetFlipStatus()");
return Emu.GetGSManager().GetRender().m_flip_status;
}
@ -918,28 +919,28 @@ int cellRescCreateInterlaceTable()
void cellResc_init()
{
cellResc.AddFunc(0x25c107e6, cellRescSetConvertAndFlip);
cellResc.AddFunc(0x0d3c22ce, cellRescSetWaitFlip);
cellResc.AddFunc(0x2ea94661, cellRescSetFlipHandler);
cellResc.AddFunc(0x01220224, cellRescGcmSurface2RescSrc);
cellResc.AddFunc(0x0a2069c7, cellRescGetNumColorBuffers);
cellResc.AddFunc(0x10db5b1a, cellRescSetDsts);
cellResc.AddFunc(0x129922a0, cellRescResetFlipStatus);
cellResc.AddFunc(0x19a2a967, cellRescSetPalInterpolateDropFlexRatio);
cellResc.AddFunc(0x1dd3c4cd, cellRescGetRegisterCount);
cellResc.AddFunc(0x22ae06d8, cellRescAdjustAspectRatio);
cellResc.AddFunc(0x23134710, cellRescSetDisplayMode);
cellResc.AddFunc(0x2ea3061e, cellRescExit);
cellResc.AddFunc(0x516ee89e, cellRescInit);
cellResc.AddFunc(0x5a338cdb, cellRescGetBufferSize);
cellResc.AddFunc(0x66f5e388, cellRescGetLastFlipTime);
cellResc.AddFunc(0x6cd0f95f, cellRescSetSrc);
cellResc.AddFunc(0x7af8a37f, cellRescSetRegisterCount);
cellResc.AddFunc(0x8107277c, cellRescSetBufferAddress);
cellResc.AddFunc(0xc47c5c22, cellRescGetFlipStatus);
cellResc.AddFunc(0xd1ca0503, cellRescVideoOutResolutionId2RescBufferMode);
cellResc.AddFunc(0xd3758645, cellRescSetVBlankHandler);
cellResc.AddFunc(0xe0cef79e, cellRescCreateInterlaceTable);
cellResc->AddFunc(0x25c107e6, cellRescSetConvertAndFlip);
cellResc->AddFunc(0x0d3c22ce, cellRescSetWaitFlip);
cellResc->AddFunc(0x2ea94661, cellRescSetFlipHandler);
cellResc->AddFunc(0x01220224, cellRescGcmSurface2RescSrc);
cellResc->AddFunc(0x0a2069c7, cellRescGetNumColorBuffers);
cellResc->AddFunc(0x10db5b1a, cellRescSetDsts);
cellResc->AddFunc(0x129922a0, cellRescResetFlipStatus);
cellResc->AddFunc(0x19a2a967, cellRescSetPalInterpolateDropFlexRatio);
cellResc->AddFunc(0x1dd3c4cd, cellRescGetRegisterCount);
cellResc->AddFunc(0x22ae06d8, cellRescAdjustAspectRatio);
cellResc->AddFunc(0x23134710, cellRescSetDisplayMode);
cellResc->AddFunc(0x2ea3061e, cellRescExit);
cellResc->AddFunc(0x516ee89e, cellRescInit);
cellResc->AddFunc(0x5a338cdb, cellRescGetBufferSize);
cellResc->AddFunc(0x66f5e388, cellRescGetLastFlipTime);
cellResc->AddFunc(0x6cd0f95f, cellRescSetSrc);
cellResc->AddFunc(0x7af8a37f, cellRescSetRegisterCount);
cellResc->AddFunc(0x8107277c, cellRescSetBufferAddress);
cellResc->AddFunc(0xc47c5c22, cellRescGetFlipStatus);
cellResc->AddFunc(0xd1ca0503, cellRescVideoOutResolutionId2RescBufferMode);
cellResc->AddFunc(0xd3758645, cellRescSetVBlankHandler);
cellResc->AddFunc(0xe0cef79e, cellRescCreateInterlaceTable);
}
void cellResc_load()

335
rpcs3/Emu/SysCalls/Modules/cellRtc.cpp
View File

@ -8,8 +8,9 @@
#include "cellRtc.h"
void cellRtc_init();
Module cellRtc(0x0009, cellRtc_init);
//void cellRtc_init();
//Module cellRtc(0x0009, cellRtc_init);
Module *cellRtc = nullptr;
long convertToUNIXTime(u16 seconds, u16 minutes, u16 hours, u16 days, int years)
{
@ -26,76 +27,76 @@ u64 convertToWin32FILETIME(u16 seconds, u16 minutes, u16 hours, u16 days, int ye
int cellRtcGetCurrentTick(mem_ptr_t<CellRtcTick> pTick)
{
cellRtc.Log("cellRtcGetCurrentTick(pTick=0x%x)", pTick.GetAddr());
cellRtc->Log("cellRtcGetCurrentTick(pTick=0x%x)", pTick.GetAddr());
if (!pTick.IsGood())
return CELL_RTC_ERROR_INVALID_POINTER;
wxDateTime unow = wxDateTime::UNow();
rDateTime unow = rDateTime::UNow();
pTick->tick = unow.GetTicks();
return CELL_OK;
}
int cellRtcGetCurrentClock(mem_ptr_t<CellRtcDateTime> pClock, s32 iTimeZone)
{
cellRtc.Log("cellRtcGetCurrentClock(pClock=0x%x, time_zone=%d)", pClock.GetAddr(), iTimeZone);
cellRtc->Log("cellRtcGetCurrentClock(pClock=0x%x, time_zone=%d)", pClock.GetAddr(), iTimeZone);
if (!pClock.IsGood())
return CELL_RTC_ERROR_INVALID_POINTER;
wxDateTime unow = wxDateTime::UNow();
rDateTime unow = rDateTime::UNow();
// Add time_zone as offset in minutes.
wxTimeSpan tz = wxTimeSpan(0, (long) iTimeZone, 0, 0);
rTimeSpan tz = rTimeSpan(0, (long) iTimeZone, 0, 0);
unow.Add(tz);
pClock->year = unow.GetYear(wxDateTime::TZ::UTC);
pClock->month = unow.GetMonth(wxDateTime::TZ::UTC);
pClock->day = unow.GetDay(wxDateTime::TZ::UTC);
pClock->hour = unow.GetHour(wxDateTime::TZ::UTC);
pClock->minute = unow.GetMinute(wxDateTime::TZ::UTC);
pClock->second = unow.GetSecond(wxDateTime::TZ::UTC);
pClock->microsecond = unow.GetMillisecond(wxDateTime::TZ::UTC) * 1000;
pClock->year = unow.GetYear(rDateTime::TZ::UTC);
pClock->month = unow.GetMonth(rDateTime::TZ::UTC);
pClock->day = unow.GetDay(rDateTime::TZ::UTC);
pClock->hour = unow.GetHour(rDateTime::TZ::UTC);
pClock->minute = unow.GetMinute(rDateTime::TZ::UTC);
pClock->second = unow.GetSecond(rDateTime::TZ::UTC);
pClock->microsecond = unow.GetMillisecond(rDateTime::TZ::UTC) * 1000;
return CELL_OK;
}
int cellRtcGetCurrentClockLocalTime(mem_ptr_t<CellRtcDateTime> pClock)
{
cellRtc.Log("cellRtcGetCurrentClockLocalTime(pClock=0x%x)", pClock.GetAddr());
cellRtc->Log("cellRtcGetCurrentClockLocalTime(pClock=0x%x)", pClock.GetAddr());
if (!pClock.IsGood())
return CELL_RTC_ERROR_INVALID_POINTER;
wxDateTime unow = wxDateTime::UNow();
rDateTime unow = rDateTime::UNow();
pClock->year = unow.GetYear(wxDateTime::TZ::Local);
pClock->month = unow.GetMonth(wxDateTime::TZ::Local);
pClock->day = unow.GetDay(wxDateTime::TZ::Local);
pClock->hour = unow.GetHour(wxDateTime::TZ::Local);
pClock->minute = unow.GetMinute(wxDateTime::TZ::Local);
pClock->second = unow.GetSecond(wxDateTime::TZ::Local);
pClock->microsecond = unow.GetMillisecond(wxDateTime::TZ::Local) * 1000;
pClock->year = unow.GetYear(rDateTime::TZ::Local);
pClock->month = unow.GetMonth(rDateTime::TZ::Local);
pClock->day = unow.GetDay(rDateTime::TZ::Local);
pClock->hour = unow.GetHour(rDateTime::TZ::Local);
pClock->minute = unow.GetMinute(rDateTime::TZ::Local);
pClock->second = unow.GetSecond(rDateTime::TZ::Local);
pClock->microsecond = unow.GetMillisecond(rDateTime::TZ::Local) * 1000;
return CELL_OK;
}
int cellRtcFormatRfc2822(u32 pszDateTime_addr, mem_ptr_t<CellRtcTick> pUtc, s32 iTimeZone)
{
cellRtc.Log("cellRtcFormatRfc2822(pszDateTime_addr=0x%x, pUtc=0x%x, time_zone=%d)", pszDateTime_addr, pUtc.GetAddr(), iTimeZone);
cellRtc->Log("cellRtcFormatRfc2822(pszDateTime_addr=0x%x, pUtc=0x%x, time_zone=%d)", pszDateTime_addr, pUtc.GetAddr(), iTimeZone);
if (!pUtc.IsGood() || !Memory.IsGoodAddr(pszDateTime_addr))
return CELL_RTC_ERROR_INVALID_POINTER;
// Add time_zone as offset in minutes.
wxTimeSpan tz = wxTimeSpan(0, (long) iTimeZone, 0, 0);
rTimeSpan tz = rTimeSpan(0, (long) iTimeZone, 0, 0);
// Get date from ticks + tz.
wxDateTime date = wxDateTime((time_t)pUtc->tick);
rDateTime date = rDateTime((time_t)pUtc->tick);
date.Add(tz);
// Format date string in RFC2822 format (e.g.: Mon, 01 Jan 1990 12:00:00 +0000).
const std::string& str = fmt::ToUTF8(date.Format("%a, %d %b %Y %T %z", wxDateTime::TZ::UTC));
const std::string& str = date.Format("%a, %d %b %Y %T %z", rDateTime::TZ::UTC);
Memory.WriteString(pszDateTime_addr, str);
return CELL_OK;
@ -103,16 +104,16 @@ int cellRtcFormatRfc2822(u32 pszDateTime_addr, mem_ptr_t<CellRtcTick> pUtc, s32
int cellRtcFormatRfc2822LocalTime(u32 pszDateTime_addr, mem_ptr_t<CellRtcTick> pUtc)
{
cellRtc.Log("cellRtcFormatRfc2822LocalTime(pszDateTime_addr=0x%x, pUtc=0x%x)", pszDateTime_addr, pUtc.GetAddr());
cellRtc->Log("cellRtcFormatRfc2822LocalTime(pszDateTime_addr=0x%x, pUtc=0x%x)", pszDateTime_addr, pUtc.GetAddr());
if (!pUtc.IsGood() || !Memory.IsGoodAddr(pszDateTime_addr))
return CELL_RTC_ERROR_INVALID_POINTER;
// Get date from ticks.
wxDateTime date = wxDateTime((time_t)pUtc->tick);
rDateTime date = rDateTime((time_t)pUtc->tick);
// Format date string in RFC2822 format (e.g.: Mon, 01 Jan 1990 12:00:00 +0000).
const std::string& str = fmt::ToUTF8(date.Format("%a, %d %b %Y %T %z", wxDateTime::TZ::Local));
const std::string& str = date.Format("%a, %d %b %Y %T %z", rDateTime::TZ::Local);
Memory.WriteString(pszDateTime_addr, str);
return CELL_OK;
@ -120,20 +121,20 @@ int cellRtcFormatRfc2822LocalTime(u32 pszDateTime_addr, mem_ptr_t<CellRtcTick> p
int cellRtcFormatRfc3339(u32 pszDateTime_addr, mem_ptr_t<CellRtcTick> pUtc, s32 iTimeZone)
{
cellRtc.Log("cellRtcFormatRfc3339(pszDateTime_addr=0x%x, pUtc=0x%x, iTimeZone=%d)", pszDateTime_addr, pUtc.GetAddr(), iTimeZone);
cellRtc->Log("cellRtcFormatRfc3339(pszDateTime_addr=0x%x, pUtc=0x%x, iTimeZone=%d)", pszDateTime_addr, pUtc.GetAddr(), iTimeZone);
if (!pUtc.IsGood() || !Memory.IsGoodAddr(pszDateTime_addr))
return CELL_RTC_ERROR_INVALID_POINTER;
// Add time_zone as offset in minutes.
wxTimeSpan tz = wxTimeSpan(0, (long) iTimeZone, 0, 0);
rTimeSpan tz = rTimeSpan(0, (long) iTimeZone, 0, 0);
// Get date from ticks + tz.
wxDateTime date = wxDateTime((time_t)pUtc->tick);
rDateTime date = rDateTime((time_t)pUtc->tick);
date.Add(tz);
// Format date string in RFC3339 format (e.g.: 1990-01-01T12:00:00.00Z).
const std::string& str = fmt::ToUTF8(date.Format("%FT%T.%zZ", wxDateTime::TZ::UTC));
const std::string& str = date.Format("%FT%T.%zZ", rDateTime::TZ::UTC);
Memory.WriteString(pszDateTime_addr, str);
return CELL_OK;
@ -141,16 +142,16 @@ int cellRtcFormatRfc3339(u32 pszDateTime_addr, mem_ptr_t<CellRtcTick> pUtc, s32
int cellRtcFormatRfc3339LocalTime(u32 pszDateTime_addr, mem_ptr_t<CellRtcTick> pUtc)
{
cellRtc.Log("cellRtcFormatRfc3339LocalTime(pszDateTime_addr=0x%x, pUtc=0x%x)", pszDateTime_addr, pUtc.GetAddr());
cellRtc->Log("cellRtcFormatRfc3339LocalTime(pszDateTime_addr=0x%x, pUtc=0x%x)", pszDateTime_addr, pUtc.GetAddr());
if (!pUtc.IsGood() || !Memory.IsGoodAddr(pszDateTime_addr))
return CELL_RTC_ERROR_INVALID_POINTER;
// Get date from ticks.
wxDateTime date = wxDateTime((time_t) pUtc->tick);
rDateTime date = rDateTime((time_t) pUtc->tick);
// Format date string in RFC3339 format (e.g.: 1990-01-01T12:00:00.00Z).
const std::string& str = fmt::ToUTF8(date.Format("%FT%T.%zZ", wxDateTime::TZ::Local));
const std::string& str = date.Format("%FT%T.%zZ", rDateTime::TZ::Local);
Memory.WriteString(pszDateTime_addr, str);
return CELL_OK;
@ -158,15 +159,15 @@ int cellRtcFormatRfc3339LocalTime(u32 pszDateTime_addr, mem_ptr_t<CellRtcTick> p
int cellRtcParseDateTime(mem_ptr_t<CellRtcTick> pUtc, u32 pszDateTime_addr)
{
cellRtc.Log("cellRtcParseDateTime(pUtc=0x%x, pszDateTime_addr=0x%x)", pUtc.GetAddr(), pszDateTime_addr);
cellRtc->Log("cellRtcParseDateTime(pUtc=0x%x, pszDateTime_addr=0x%x)", pUtc.GetAddr(), pszDateTime_addr);
if (!pUtc.IsGood() || !Memory.IsGoodAddr(pszDateTime_addr))
return CELL_RTC_ERROR_INVALID_POINTER;
// Get date from formatted string.
wxDateTime date;
rDateTime date;
const std::string& format = Memory.ReadString(pszDateTime_addr);
date.ParseDateTime(fmt::FromUTF8(format));
date.ParseDateTime(format);
pUtc->tick = date.GetTicks();
@ -175,15 +176,15 @@ int cellRtcParseDateTime(mem_ptr_t<CellRtcTick> pUtc, u32 pszDateTime_addr)
int cellRtcParseRfc3339(mem_ptr_t<CellRtcTick> pUtc, u32 pszDateTime_addr)
{
cellRtc.Log("cellRtcParseRfc3339(pUtc=0x%x, pszDateTime_addr=0x%x)", pUtc.GetAddr(), pszDateTime_addr);
cellRtc->Log("cellRtcParseRfc3339(pUtc=0x%x, pszDateTime_addr=0x%x)", pUtc.GetAddr(), pszDateTime_addr);
if (!pUtc.IsGood() || !Memory.IsGoodAddr(pszDateTime_addr))
return CELL_RTC_ERROR_INVALID_POINTER;
// Get date from RFC3339 formatted string.
wxDateTime date;
rDateTime date;
const std::string& format = Memory.ReadString(pszDateTime_addr);
date.ParseDateTime(fmt::FromUTF8(format));
date.ParseDateTime(format);
pUtc->tick = date.GetTicks();
@ -192,12 +193,12 @@ int cellRtcParseRfc3339(mem_ptr_t<CellRtcTick> pUtc, u32 pszDateTime_addr)
int cellRtcGetTick(mem_ptr_t<CellRtcDateTime> pTime, mem_ptr_t<CellRtcTick> pTick)
{
cellRtc.Log("cellRtcGetTick(pTime=0x%x, pTick=0x%x)", pTime.GetAddr(), pTick.GetAddr());
cellRtc->Log("cellRtcGetTick(pTime=0x%x, pTick=0x%x)", pTime.GetAddr(), pTick.GetAddr());
if (!pTime.IsGood() || !pTick.IsGood())
return CELL_RTC_ERROR_INVALID_POINTER;
wxDateTime datetime = wxDateTime(pTime->day, (wxDateTime::Month)pTime->month.ToLE(), pTime->year, pTime->hour, pTime->minute, pTime->second, (pTime->microsecond / 1000));
rDateTime datetime = rDateTime(pTime->day, (rDateTime::Month)pTime->month.ToLE(), pTime->year, pTime->hour, pTime->minute, pTime->second, (pTime->microsecond / 1000));
pTick->tick = datetime.GetTicks();
return CELL_OK;
@ -205,27 +206,27 @@ int cellRtcGetTick(mem_ptr_t<CellRtcDateTime> pTime, mem_ptr_t<CellRtcTick> pTic
int cellRtcSetTick(mem_ptr_t<CellRtcDateTime> pTime, mem_ptr_t<CellRtcTick> pTick)
{
cellRtc.Log("cellRtcSetTick(pTime=0x%x, pTick=0x%x)", pTime.GetAddr(), pTick.GetAddr());
cellRtc->Log("cellRtcSetTick(pTime=0x%x, pTick=0x%x)", pTime.GetAddr(), pTick.GetAddr());
if (!pTime.IsGood() || !pTick.IsGood())
return CELL_RTC_ERROR_INVALID_POINTER;
wxDateTime date = wxDateTime((time_t)pTick->tick);
rDateTime date = rDateTime((time_t)pTick->tick);
pTime->year = date.GetYear(wxDateTime::TZ::UTC);
pTime->month = date.GetMonth(wxDateTime::TZ::UTC);
pTime->day = date.GetDay(wxDateTime::TZ::UTC);
pTime->hour = date.GetHour(wxDateTime::TZ::UTC);
pTime->minute = date.GetMinute(wxDateTime::TZ::UTC);
pTime->second = date.GetSecond(wxDateTime::TZ::UTC);
pTime->microsecond = date.GetMillisecond(wxDateTime::TZ::UTC) * 1000;
pTime->year = date.GetYear(rDateTime::TZ::UTC);
pTime->month = date.GetMonth(rDateTime::TZ::UTC);
pTime->day = date.GetDay(rDateTime::TZ::UTC);
pTime->hour = date.GetHour(rDateTime::TZ::UTC);
pTime->minute = date.GetMinute(rDateTime::TZ::UTC);
pTime->second = date.GetSecond(rDateTime::TZ::UTC);
pTime->microsecond = date.GetMillisecond(rDateTime::TZ::UTC) * 1000;
return CELL_OK;
}
int cellRtcTickAddTicks(mem_ptr_t<CellRtcTick> pTick0, mem_ptr_t<CellRtcTick> pTick1, s64 lAdd)
{
cellRtc.Log("cellRtcTickAddTicks(pTick0=0x%x, pTick1=0x%x, lAdd=%lld)", pTick0.GetAddr(), pTick1.GetAddr(), lAdd);
cellRtc->Log("cellRtcTickAddTicks(pTick0=0x%x, pTick1=0x%x, lAdd=%lld)", pTick0.GetAddr(), pTick1.GetAddr(), lAdd);
if (!pTick0.IsGood() || !pTick1.IsGood())
return CELL_RTC_ERROR_INVALID_POINTER;
@ -236,13 +237,13 @@ int cellRtcTickAddTicks(mem_ptr_t<CellRtcTick> pTick0, mem_ptr_t<CellRtcTick> pT
int cellRtcTickAddMicroseconds(mem_ptr_t<CellRtcTick> pTick0, mem_ptr_t<CellRtcTick> pTick1, s64 lAdd)
{
cellRtc.Log("cellRtcTickAddMicroseconds(pTick0=0x%x, pTick1=0x%x, lAdd=%lld)", pTick0.GetAddr(), pTick1.GetAddr(), lAdd);
cellRtc->Log("cellRtcTickAddMicroseconds(pTick0=0x%x, pTick1=0x%x, lAdd=%lld)", pTick0.GetAddr(), pTick1.GetAddr(), lAdd);
if (!pTick0.IsGood() || !pTick1.IsGood())
return CELL_RTC_ERROR_INVALID_POINTER;
wxDateTime date = wxDateTime((time_t)pTick1->tick);
wxTimeSpan microseconds = wxTimeSpan(0, 0, 0, lAdd / 1000);
rDateTime date = rDateTime((time_t)pTick1->tick);
rTimeSpan microseconds = rTimeSpan(0, 0, 0, lAdd / 1000);
date.Add(microseconds);
pTick0->tick = date.GetTicks();
@ -251,13 +252,13 @@ int cellRtcTickAddMicroseconds(mem_ptr_t<CellRtcTick> pTick0, mem_ptr_t<CellRtcT
int cellRtcTickAddSeconds(mem_ptr_t<CellRtcTick> pTick0, mem_ptr_t<CellRtcTick> pTick1, s64 lAdd)
{
cellRtc.Log("cellRtcTickAddSeconds(pTick0=0x%x, pTick1=0x%x, lAdd=%lld)", pTick0.GetAddr(), pTick1.GetAddr(), lAdd);
cellRtc->Log("cellRtcTickAddSeconds(pTick0=0x%x, pTick1=0x%x, lAdd=%lld)", pTick0.GetAddr(), pTick1.GetAddr(), lAdd);
if (!pTick0.IsGood() || !pTick1.IsGood())
return CELL_RTC_ERROR_INVALID_POINTER;
wxDateTime date = wxDateTime((time_t)pTick1->tick);
wxTimeSpan seconds = wxTimeSpan(0, 0, lAdd, 0);
rDateTime date = rDateTime((time_t)pTick1->tick);
rTimeSpan seconds = rTimeSpan(0, 0, lAdd, 0);
date.Add(seconds);
pTick0->tick = date.GetTicks();
@ -266,13 +267,13 @@ int cellRtcTickAddSeconds(mem_ptr_t<CellRtcTick> pTick0, mem_ptr_t<CellRtcTick>
int cellRtcTickAddMinutes(mem_ptr_t<CellRtcTick> pTick0, mem_ptr_t<CellRtcTick> pTick1, s64 lAdd)
{
cellRtc.Log("cellRtcTickAddMinutes(pTick0=0x%x, pTick1=0x%x, lAdd=%lld)", pTick0.GetAddr(), pTick1.GetAddr(), lAdd);
cellRtc->Log("cellRtcTickAddMinutes(pTick0=0x%x, pTick1=0x%x, lAdd=%lld)", pTick0.GetAddr(), pTick1.GetAddr(), lAdd);
if (!pTick0.IsGood() || !pTick1.IsGood())
return CELL_RTC_ERROR_INVALID_POINTER;
wxDateTime date = wxDateTime((time_t)pTick1->tick);
wxTimeSpan minutes = wxTimeSpan(0, lAdd, 0, 0);
rDateTime date = rDateTime((time_t)pTick1->tick);
rTimeSpan minutes = rTimeSpan(0, lAdd, 0, 0);
date.Add(minutes);
pTick0->tick = date.GetTicks();
@ -281,13 +282,13 @@ int cellRtcTickAddMinutes(mem_ptr_t<CellRtcTick> pTick0, mem_ptr_t<CellRtcTick>
int cellRtcTickAddHours(mem_ptr_t<CellRtcTick> pTick0, mem_ptr_t<CellRtcTick> pTick1, s32 iAdd)
{
cellRtc.Log("cellRtcTickAddHours(pTick0=0x%x, pTick1=0x%x, iAdd=%d)", pTick0.GetAddr(), pTick1.GetAddr(), iAdd);
cellRtc->Log("cellRtcTickAddHours(pTick0=0x%x, pTick1=0x%x, iAdd=%d)", pTick0.GetAddr(), pTick1.GetAddr(), iAdd);
if (!pTick0.IsGood() || !pTick1.IsGood())
return CELL_RTC_ERROR_INVALID_POINTER;
wxDateTime date = wxDateTime((time_t)pTick1->tick);
wxTimeSpan hours = wxTimeSpan(iAdd, 0, 0, 0);
rDateTime date = rDateTime((time_t)pTick1->tick);
rTimeSpan hours = rTimeSpan(iAdd, 0, 0, 0);
date.Add(hours);
pTick0->tick = date.GetTicks();
@ -296,13 +297,13 @@ int cellRtcTickAddHours(mem_ptr_t<CellRtcTick> pTick0, mem_ptr_t<CellRtcTick> pT
int cellRtcTickAddDays(mem_ptr_t<CellRtcTick> pTick0, mem_ptr_t<CellRtcTick> pTick1, s32 iAdd)
{
cellRtc.Log("cellRtcTickAddDays(pTick0=0x%x, pTick1=0x%x, iAdd=%d)", pTick0.GetAddr(), pTick1.GetAddr(), iAdd);
cellRtc->Log("cellRtcTickAddDays(pTick0=0x%x, pTick1=0x%x, iAdd=%d)", pTick0.GetAddr(), pTick1.GetAddr(), iAdd);
if (!pTick0.IsGood() || !pTick1.IsGood())
return CELL_RTC_ERROR_INVALID_POINTER;
wxDateTime date = wxDateTime((time_t)pTick1->tick);
wxDateSpan days = wxDateSpan(0, 0, 0, iAdd);
rDateTime date = rDateTime((time_t)pTick1->tick);
rDateSpan days = rDateSpan(0, 0, 0, iAdd);
date.Add(days);
pTick0->tick = date.GetTicks();
@ -311,13 +312,13 @@ int cellRtcTickAddDays(mem_ptr_t<CellRtcTick> pTick0, mem_ptr_t<CellRtcTick> pTi
int cellRtcTickAddWeeks(mem_ptr_t<CellRtcTick> pTick0, mem_ptr_t<CellRtcTick> pTick1, s32 iAdd)
{
cellRtc.Log("cellRtcTickAddWeeks(pTick0=0x%x, pTick1=0x%x, iAdd=%d)", pTick0.GetAddr(), pTick1.GetAddr(), iAdd);
cellRtc->Log("cellRtcTickAddWeeks(pTick0=0x%x, pTick1=0x%x, iAdd=%d)", pTick0.GetAddr(), pTick1.GetAddr(), iAdd);
if (!pTick0.IsGood() || !pTick1.IsGood())
return CELL_RTC_ERROR_INVALID_POINTER;
wxDateTime date = wxDateTime((time_t)pTick1->tick);
wxDateSpan weeks = wxDateSpan(0, 0, iAdd, 0);
rDateTime date = rDateTime((time_t)pTick1->tick);
rDateSpan weeks = rDateSpan(0, 0, iAdd, 0);
date.Add(weeks);
pTick0->tick = date.GetTicks();
@ -326,13 +327,13 @@ int cellRtcTickAddWeeks(mem_ptr_t<CellRtcTick> pTick0, mem_ptr_t<CellRtcTick> pT
int cellRtcTickAddMonths(mem_ptr_t<CellRtcTick> pTick0, mem_ptr_t<CellRtcTick> pTick1, s32 iAdd)
{
cellRtc.Log("cellRtcTickAddMonths(pTick0=0x%x, pTick1=0x%x, iAdd=%d)", pTick0.GetAddr(), pTick1.GetAddr(), iAdd);
cellRtc->Log("cellRtcTickAddMonths(pTick0=0x%x, pTick1=0x%x, iAdd=%d)", pTick0.GetAddr(), pTick1.GetAddr(), iAdd);
if (!pTick0.IsGood() || !pTick1.IsGood())
return CELL_RTC_ERROR_INVALID_POINTER;
wxDateTime date = wxDateTime((time_t)pTick1->tick);
wxDateSpan months = wxDateSpan(0, iAdd, 0, 0);
rDateTime date = rDateTime((time_t)pTick1->tick);
rDateSpan months = rDateSpan(0, iAdd, 0, 0);
date.Add(months);
pTick0->tick = date.GetTicks();
@ -341,13 +342,13 @@ int cellRtcTickAddMonths(mem_ptr_t<CellRtcTick> pTick0, mem_ptr_t<CellRtcTick> p
int cellRtcTickAddYears(mem_ptr_t<CellRtcTick> pTick0, mem_ptr_t<CellRtcTick> pTick1, s32 iAdd)
{
cellRtc.Log("cellRtcTickAddYears(pTick0=0x%x, pTick1=0x%x, iAdd=%d)", pTick0.GetAddr(), pTick1.GetAddr(), iAdd);
cellRtc->Log("cellRtcTickAddYears(pTick0=0x%x, pTick1=0x%x, iAdd=%d)", pTick0.GetAddr(), pTick1.GetAddr(), iAdd);
if (!pTick0.IsGood() || !pTick1.IsGood())
return CELL_RTC_ERROR_INVALID_POINTER;
wxDateTime date = wxDateTime((time_t)pTick1->tick);
wxDateSpan years = wxDateSpan(iAdd, 0, 0, 0);
rDateTime date = rDateTime((time_t)pTick1->tick);
rDateSpan years = rDateSpan(iAdd, 0, 0, 0);
date.Add(years);
pTick0->tick = date.GetTicks();
@ -356,39 +357,39 @@ int cellRtcTickAddYears(mem_ptr_t<CellRtcTick> pTick0, mem_ptr_t<CellRtcTick> pT
int cellRtcConvertUtcToLocalTime(mem_ptr_t<CellRtcTick> pUtc, mem_ptr_t<CellRtcTick> pLocalTime)
{
cellRtc.Log("cellRtcConvertUtcToLocalTime(pUtc=0x%x, pLocalTime=0x%x)", pUtc.GetAddr(), pLocalTime.GetAddr());
cellRtc->Log("cellRtcConvertUtcToLocalTime(pUtc=0x%x, pLocalTime=0x%x)", pUtc.GetAddr(), pLocalTime.GetAddr());
if (!pUtc.IsGood() || !pLocalTime.IsGood())
return CELL_RTC_ERROR_INVALID_POINTER;
wxDateTime time = wxDateTime((time_t)pUtc->tick);
wxDateTime local_time = time.FromUTC(false);
rDateTime time = rDateTime((time_t)pUtc->tick);
rDateTime local_time = time.FromUTC(false);
pLocalTime->tick = local_time.GetTicks();
return CELL_OK;
}
int cellRtcConvertLocalTimeToUtc(mem_ptr_t<CellRtcTick> pLocalTime, mem_ptr_t<CellRtcTick> pUtc)
{
cellRtc.Log("cellRtcConvertLocalTimeToUtc(pLocalTime=0x%x, pUtc=0x%x)", pLocalTime.GetAddr(), pUtc.GetAddr());
cellRtc->Log("cellRtcConvertLocalTimeToUtc(pLocalTime=0x%x, pUtc=0x%x)", pLocalTime.GetAddr(), pUtc.GetAddr());
if (!pLocalTime.IsGood() || !pUtc.IsGood())
return CELL_RTC_ERROR_INVALID_POINTER;
wxDateTime time = wxDateTime((time_t)pLocalTime->tick);
wxDateTime utc_time = time.ToUTC(false);
rDateTime time = rDateTime((time_t)pLocalTime->tick);
rDateTime utc_time = time.ToUTC(false);
pUtc->tick = utc_time.GetTicks();
return CELL_OK;
}
int cellRtcGetDosTime(mem_ptr_t<CellRtcDateTime> pDateTime, mem32_t puiDosTime)
{
cellRtc.Log("cellRtcGetDosTime(pDateTime=0x%x, puiDosTime=0x%x)", pDateTime.GetAddr(), puiDosTime.GetAddr());
cellRtc->Log("cellRtcGetDosTime(pDateTime=0x%x, puiDosTime=0x%x)", pDateTime.GetAddr(), puiDosTime.GetAddr());
if (!pDateTime.IsGood() || !puiDosTime.IsGood())
return CELL_RTC_ERROR_INVALID_POINTER;
// Convert to DOS time.
wxDateTime date_time = wxDateTime(pDateTime->day, (wxDateTime::Month)pDateTime->month.ToLE(), pDateTime->year, pDateTime->hour, pDateTime->minute, pDateTime->second, (pDateTime->microsecond / 1000));
rDateTime date_time = rDateTime(pDateTime->day, (rDateTime::Month)pDateTime->month.ToLE(), pDateTime->year, pDateTime->hour, pDateTime->minute, pDateTime->second, (pDateTime->microsecond / 1000));
puiDosTime = date_time.GetAsDOS();
return CELL_OK;
@ -396,123 +397,123 @@ int cellRtcGetDosTime(mem_ptr_t<CellRtcDateTime> pDateTime, mem32_t puiDosTime)
int cellRtcGetTime_t(mem_ptr_t<CellRtcDateTime> pDateTime, mem64_t piTime)
{
cellRtc.Log("cellRtcGetTime_t(pDateTime=0x%x, piTime=0x%x)", pDateTime.GetAddr(), piTime.GetAddr());
cellRtc->Log("cellRtcGetTime_t(pDateTime=0x%x, piTime=0x%x)", pDateTime.GetAddr(), piTime.GetAddr());
if (!pDateTime.IsGood() || !piTime.IsGood())
return CELL_RTC_ERROR_INVALID_POINTER;
// Convert to POSIX time_t.
wxDateTime date_time = wxDateTime(pDateTime->day, (wxDateTime::Month)pDateTime->month.ToLE(), pDateTime->year, pDateTime->hour, pDateTime->minute, pDateTime->second, (pDateTime->microsecond / 1000));
piTime = convertToUNIXTime(date_time.GetSecond(wxDateTime::TZ::UTC), date_time.GetMinute(wxDateTime::TZ::UTC),
date_time.GetHour(wxDateTime::TZ::UTC), date_time.GetDay(wxDateTime::TZ::UTC), date_time.GetYear(wxDateTime::TZ::UTC));
rDateTime date_time = rDateTime(pDateTime->day, (rDateTime::Month)pDateTime->month.ToLE(), pDateTime->year, pDateTime->hour, pDateTime->minute, pDateTime->second, (pDateTime->microsecond / 1000));
piTime = convertToUNIXTime(date_time.GetSecond(rDateTime::TZ::UTC), date_time.GetMinute(rDateTime::TZ::UTC),
date_time.GetHour(rDateTime::TZ::UTC), date_time.GetDay(rDateTime::TZ::UTC), date_time.GetYear(rDateTime::TZ::UTC));
return CELL_OK;
}
int cellRtcGetWin32FileTime(mem_ptr_t<CellRtcDateTime> pDateTime, mem64_t pulWin32FileTime)
{
cellRtc.Log("cellRtcGetWin32FileTime(pDateTime=0x%x, pulWin32FileTime=0x%x)", pDateTime.GetAddr(), pulWin32FileTime.GetAddr());
cellRtc->Log("cellRtcGetWin32FileTime(pDateTime=0x%x, pulWin32FileTime=0x%x)", pDateTime.GetAddr(), pulWin32FileTime.GetAddr());
if (!pDateTime.IsGood() || !pulWin32FileTime.IsGood())
return CELL_RTC_ERROR_INVALID_POINTER;
// Convert to WIN32 FILETIME.
wxDateTime date_time = wxDateTime(pDateTime->day, (wxDateTime::Month)pDateTime->month.ToLE(), pDateTime->year, pDateTime->hour, pDateTime->minute, pDateTime->second, (pDateTime->microsecond / 1000));
pulWin32FileTime = convertToWin32FILETIME(date_time.GetSecond(wxDateTime::TZ::UTC), date_time.GetMinute(wxDateTime::TZ::UTC),
date_time.GetHour(wxDateTime::TZ::UTC), date_time.GetDay(wxDateTime::TZ::UTC), date_time.GetYear(wxDateTime::TZ::UTC));
rDateTime date_time = rDateTime(pDateTime->day, (rDateTime::Month)pDateTime->month.ToLE(), pDateTime->year, pDateTime->hour, pDateTime->minute, pDateTime->second, (pDateTime->microsecond / 1000));
pulWin32FileTime = convertToWin32FILETIME(date_time.GetSecond(rDateTime::TZ::UTC), date_time.GetMinute(rDateTime::TZ::UTC),
date_time.GetHour(rDateTime::TZ::UTC), date_time.GetDay(rDateTime::TZ::UTC), date_time.GetYear(rDateTime::TZ::UTC));
return CELL_OK;
}
int cellRtcSetDosTime(mem_ptr_t<CellRtcDateTime> pDateTime, u32 uiDosTime)
{
cellRtc.Log("cellRtcSetDosTime(pDateTime=0x%x, uiDosTime=0x%x)", pDateTime.GetAddr(), uiDosTime);
cellRtc->Log("cellRtcSetDosTime(pDateTime=0x%x, uiDosTime=0x%x)", pDateTime.GetAddr(), uiDosTime);
if (!pDateTime.IsGood())
return CELL_RTC_ERROR_INVALID_POINTER;
wxDateTime date_time;
wxDateTime dos_time = date_time.SetFromDOS(uiDosTime);
rDateTime date_time;
rDateTime dos_time = date_time.SetFromDOS(uiDosTime);
pDateTime->year = dos_time.GetYear(wxDateTime::TZ::UTC);
pDateTime->month = dos_time.GetMonth(wxDateTime::TZ::UTC);
pDateTime->day = dos_time.GetDay(wxDateTime::TZ::UTC);
pDateTime->hour = dos_time.GetHour(wxDateTime::TZ::UTC);
pDateTime->minute = dos_time.GetMinute(wxDateTime::TZ::UTC);
pDateTime->second = dos_time.GetSecond(wxDateTime::TZ::UTC);
pDateTime->microsecond = dos_time.GetMillisecond(wxDateTime::TZ::UTC) * 1000;
pDateTime->year = dos_time.GetYear(rDateTime::TZ::UTC);
pDateTime->month = dos_time.GetMonth(rDateTime::TZ::UTC);
pDateTime->day = dos_time.GetDay(rDateTime::TZ::UTC);
pDateTime->hour = dos_time.GetHour(rDateTime::TZ::UTC);
pDateTime->minute = dos_time.GetMinute(rDateTime::TZ::UTC);
pDateTime->second = dos_time.GetSecond(rDateTime::TZ::UTC);
pDateTime->microsecond = dos_time.GetMillisecond(rDateTime::TZ::UTC) * 1000;
return CELL_OK;
}
int cellRtcSetTime_t(mem_ptr_t<CellRtcDateTime> pDateTime, u64 iTime)
{
cellRtc.Log("cellRtcSetTime_t(pDateTime=0x%x, iTime=0x%llx)", pDateTime.GetAddr(), iTime);
cellRtc->Log("cellRtcSetTime_t(pDateTime=0x%x, iTime=0x%llx)", pDateTime.GetAddr(), iTime);
if (!pDateTime.IsGood())
return CELL_RTC_ERROR_INVALID_POINTER;
wxDateTime date_time = wxDateTime((time_t)iTime);
rDateTime date_time = rDateTime((time_t)iTime);
pDateTime->year = date_time.GetYear(wxDateTime::TZ::UTC);
pDateTime->month = date_time.GetMonth(wxDateTime::TZ::UTC);
pDateTime->day = date_time.GetDay(wxDateTime::TZ::UTC);
pDateTime->hour = date_time.GetHour(wxDateTime::TZ::UTC);
pDateTime->minute = date_time.GetMinute(wxDateTime::TZ::UTC);
pDateTime->second = date_time.GetSecond(wxDateTime::TZ::UTC);
pDateTime->microsecond = date_time.GetMillisecond(wxDateTime::TZ::UTC) * 1000;
pDateTime->year = date_time.GetYear(rDateTime::TZ::UTC);
pDateTime->month = date_time.GetMonth(rDateTime::TZ::UTC);
pDateTime->day = date_time.GetDay(rDateTime::TZ::UTC);
pDateTime->hour = date_time.GetHour(rDateTime::TZ::UTC);
pDateTime->minute = date_time.GetMinute(rDateTime::TZ::UTC);
pDateTime->second = date_time.GetSecond(rDateTime::TZ::UTC);
pDateTime->microsecond = date_time.GetMillisecond(rDateTime::TZ::UTC) * 1000;
return CELL_OK;
}
int cellRtcSetWin32FileTime(mem_ptr_t<CellRtcDateTime> pDateTime, u64 ulWin32FileTime)
{
cellRtc.Log("cellRtcSetWin32FileTime(pDateTime=0x%x, ulWin32FileTime=0x%llx)", pDateTime, ulWin32FileTime);
cellRtc->Log("cellRtcSetWin32FileTime(pDateTime=0x%x, ulWin32FileTime=0x%llx)", pDateTime, ulWin32FileTime);
if (!pDateTime.IsGood())
return CELL_RTC_ERROR_INVALID_POINTER;
wxDateTime date_time = wxDateTime((time_t)ulWin32FileTime);
rDateTime date_time = rDateTime((time_t)ulWin32FileTime);
pDateTime->year = date_time.GetYear(wxDateTime::TZ::UTC);
pDateTime->month = date_time.GetMonth(wxDateTime::TZ::UTC);
pDateTime->day = date_time.GetDay(wxDateTime::TZ::UTC);
pDateTime->hour = date_time.GetHour(wxDateTime::TZ::UTC);
pDateTime->minute = date_time.GetMinute(wxDateTime::TZ::UTC);
pDateTime->second = date_time.GetSecond(wxDateTime::TZ::UTC);
pDateTime->microsecond = date_time.GetMillisecond(wxDateTime::TZ::UTC) * 1000;
pDateTime->year = date_time.GetYear(rDateTime::TZ::UTC);
pDateTime->month = date_time.GetMonth(rDateTime::TZ::UTC);
pDateTime->day = date_time.GetDay(rDateTime::TZ::UTC);
pDateTime->hour = date_time.GetHour(rDateTime::TZ::UTC);
pDateTime->minute = date_time.GetMinute(rDateTime::TZ::UTC);
pDateTime->second = date_time.GetSecond(rDateTime::TZ::UTC);
pDateTime->microsecond = date_time.GetMillisecond(rDateTime::TZ::UTC) * 1000;
return CELL_OK;
}
int cellRtcIsLeapYear(s32 year)
{
cellRtc.Log("cellRtcIsLeapYear(year=%d)", year);
cellRtc->Log("cellRtcIsLeapYear(year=%d)", year);
wxDateTime datetime;
return datetime.IsLeapYear(year, wxDateTime::Gregorian);
rDateTime datetime;
return datetime.IsLeapYear(year, rDateTime::Gregorian);
}
int cellRtcGetDaysInMonth(s32 year, s32 month)
{
cellRtc.Log("cellRtcGetDaysInMonth(year=%d, month=%d)", year, month);
cellRtc->Log("cellRtcGetDaysInMonth(year=%d, month=%d)", year, month);
wxDateTime datetime;
return datetime.GetNumberOfDays((wxDateTime::Month) month, year, wxDateTime::Gregorian);
rDateTime datetime;
return datetime.GetNumberOfDays((rDateTime::Month) month, year, rDateTime::Gregorian);
}
int cellRtcGetDayOfWeek(s32 year, s32 month, s32 day)
{
cellRtc.Log("cellRtcGetDayOfWeek(year=%d, month=%d, day=%d)", year, month, day);
cellRtc->Log("cellRtcGetDayOfWeek(year=%d, month=%d, day=%d)", year, month, day);
wxDateTime datetime;
datetime.SetToWeekDay((wxDateTime::WeekDay) day, 1, (wxDateTime::Month) month, year);
rDateTime datetime;
datetime.SetToWeekDay((rDateTime::WeekDay) day, 1, (rDateTime::Month) month, year);
return datetime.GetWeekDay();
}
int cellRtcCheckValid(mem_ptr_t<CellRtcDateTime> pTime)
{
cellRtc.Log("cellRtcCheckValid(pTime=0x%x)", pTime.GetAddr());
cellRtc->Log("cellRtcCheckValid(pTime=0x%x)", pTime.GetAddr());
if (!pTime.IsGood())
return CELL_RTC_ERROR_INVALID_POINTER;
@ -529,7 +530,7 @@ int cellRtcCheckValid(mem_ptr_t<CellRtcDateTime> pTime)
int cellRtcCompareTick(mem_ptr_t<CellRtcTick> pTick0, mem_ptr_t<CellRtcTick> pTick1)
{
cellRtc.Log("cellRtcCompareTick(pTick0=0x%x, pTick1=0x%x)", pTick0.GetAddr(), pTick1.GetAddr());
cellRtc->Log("cellRtcCompareTick(pTick0=0x%x, pTick1=0x%x)", pTick0.GetAddr(), pTick1.GetAddr());
if (!pTick0.IsGood() || !pTick1.IsGood())
return CELL_RTC_ERROR_INVALID_POINTER;
@ -541,44 +542,44 @@ int cellRtcCompareTick(mem_ptr_t<CellRtcTick> pTick0, mem_ptr_t<CellRtcTick> pTi
void cellRtc_init()
{
cellRtc.AddFunc(0x9dafc0d9, cellRtcGetCurrentTick);
cellRtc.AddFunc(0x32c941cf, cellRtcGetCurrentClock);
cellRtc.AddFunc(0x2cce9cf5, cellRtcGetCurrentClockLocalTime);
cellRtc->AddFunc(0x9dafc0d9, cellRtcGetCurrentTick);
cellRtc->AddFunc(0x32c941cf, cellRtcGetCurrentClock);
cellRtc->AddFunc(0x2cce9cf5, cellRtcGetCurrentClockLocalTime);
cellRtc.AddFunc(0x5491b9d5, cellRtcFormatRfc2822);
cellRtc.AddFunc(0xa07c3d2f, cellRtcFormatRfc2822LocalTime);
cellRtc.AddFunc(0xd9c0b463, cellRtcFormatRfc3339);
cellRtc.AddFunc(0x1324948a, cellRtcFormatRfc3339LocalTime);
cellRtc.AddFunc(0xc5bc0fac, cellRtcParseDateTime);
cellRtc.AddFunc(0xcf11c3d6, cellRtcParseRfc3339);
cellRtc->AddFunc(0x5491b9d5, cellRtcFormatRfc2822);
cellRtc->AddFunc(0xa07c3d2f, cellRtcFormatRfc2822LocalTime);
cellRtc->AddFunc(0xd9c0b463, cellRtcFormatRfc3339);
cellRtc->AddFunc(0x1324948a, cellRtcFormatRfc3339LocalTime);
cellRtc->AddFunc(0xc5bc0fac, cellRtcParseDateTime);
cellRtc->AddFunc(0xcf11c3d6, cellRtcParseRfc3339);
cellRtc.AddFunc(0xc7bdb7eb, cellRtcGetTick);
cellRtc.AddFunc(0x99b13034, cellRtcSetTick);
cellRtc.AddFunc(0x269a1882, cellRtcTickAddTicks);
cellRtc.AddFunc(0xf8509925, cellRtcTickAddMicroseconds);
cellRtc.AddFunc(0xccce71bd, cellRtcTickAddSeconds);
cellRtc.AddFunc(0x2f010bfa, cellRtcTickAddMinutes);
cellRtc.AddFunc(0xd41d3bd2, cellRtcTickAddHours);
cellRtc.AddFunc(0x75744e2a, cellRtcTickAddDays);
cellRtc.AddFunc(0x64c63fd5, cellRtcTickAddWeeks);
cellRtc.AddFunc(0xe0ecbb45, cellRtcTickAddMonths);
cellRtc.AddFunc(0x332a74dd, cellRtcTickAddYears);
cellRtc.AddFunc(0xc48d5002, cellRtcConvertUtcToLocalTime);
cellRtc.AddFunc(0x46ca7fe0, cellRtcConvertLocalTimeToUtc);
cellRtc->AddFunc(0xc7bdb7eb, cellRtcGetTick);
cellRtc->AddFunc(0x99b13034, cellRtcSetTick);
cellRtc->AddFunc(0x269a1882, cellRtcTickAddTicks);
cellRtc->AddFunc(0xf8509925, cellRtcTickAddMicroseconds);
cellRtc->AddFunc(0xccce71bd, cellRtcTickAddSeconds);
cellRtc->AddFunc(0x2f010bfa, cellRtcTickAddMinutes);
cellRtc->AddFunc(0xd41d3bd2, cellRtcTickAddHours);
cellRtc->AddFunc(0x75744e2a, cellRtcTickAddDays);
cellRtc->AddFunc(0x64c63fd5, cellRtcTickAddWeeks);
cellRtc->AddFunc(0xe0ecbb45, cellRtcTickAddMonths);
cellRtc->AddFunc(0x332a74dd, cellRtcTickAddYears);
cellRtc->AddFunc(0xc48d5002, cellRtcConvertUtcToLocalTime);
cellRtc->AddFunc(0x46ca7fe0, cellRtcConvertLocalTimeToUtc);
// (TODO: Time Information Manipulation Functions missing)
cellRtc.AddFunc(0xdfff32cf, cellRtcGetDosTime);
cellRtc.AddFunc(0xcb90c761, cellRtcGetTime_t);
cellRtc.AddFunc(0xe7086f05, cellRtcGetWin32FileTime);
cellRtc.AddFunc(0x9598d4b3, cellRtcSetDosTime);
cellRtc.AddFunc(0xbb543189, cellRtcSetTime_t);
cellRtc.AddFunc(0x5f68c268, cellRtcSetWin32FileTime);
cellRtc->AddFunc(0xdfff32cf, cellRtcGetDosTime);
cellRtc->AddFunc(0xcb90c761, cellRtcGetTime_t);
cellRtc->AddFunc(0xe7086f05, cellRtcGetWin32FileTime);
cellRtc->AddFunc(0x9598d4b3, cellRtcSetDosTime);
cellRtc->AddFunc(0xbb543189, cellRtcSetTime_t);
cellRtc->AddFunc(0x5f68c268, cellRtcSetWin32FileTime);
cellRtc.AddFunc(0x5316b4a8, cellRtcIsLeapYear);
cellRtc.AddFunc(0x5b6a0a1d, cellRtcGetDaysInMonth);
cellRtc.AddFunc(0xc2d8cf95, cellRtcGetDayOfWeek);
cellRtc.AddFunc(0x7f1086e6, cellRtcCheckValid);
cellRtc->AddFunc(0x5316b4a8, cellRtcIsLeapYear);
cellRtc->AddFunc(0x5b6a0a1d, cellRtcGetDaysInMonth);
cellRtc->AddFunc(0xc2d8cf95, cellRtcGetDayOfWeek);
cellRtc->AddFunc(0x7f1086e6, cellRtcCheckValid);
cellRtc.AddFunc(0xfb51fc61, cellRtcCompareTick);
cellRtc->AddFunc(0xfb51fc61, cellRtcCompareTick);
}

478
rpcs3/Emu/SysCalls/Modules/cellSpurs.cpp
View File

File diff suppressed because it is too large Load Diff

21
rpcs3/Emu/SysCalls/Modules/cellSync.cpp
View File

@ -6,8 +6,9 @@
#include "Emu/SysCalls/SC_FUNC.h"
#include "Emu/SysCalls/Modules.h"
void cellSync_init();
Module cellSync("cellSync", cellSync_init);
//void cellSync_init();
//Module cellSync("cellSync", cellSync_init);
Module *cellSync = nullptr;
// Return Codes
enum
@ -47,7 +48,7 @@ static_assert(sizeof(CellSyncMutex) == 4, "CellSyncMutex: wrong sizeof");
int cellSyncMutexInitialize(mem_ptr_t<CellSyncMutex> mutex)
{
cellSync.Log("cellSyncMutexInitialize(mutex=0x%x)", mutex.GetAddr());
cellSync->Log("cellSyncMutexInitialize(mutex=0x%x)", mutex.GetAddr());
if (!mutex.IsGood())
{
@ -64,7 +65,7 @@ int cellSyncMutexInitialize(mem_ptr_t<CellSyncMutex> mutex)
int cellSyncMutexLock(mem_ptr_t<CellSyncMutex> mutex)
{
cellSync.Log("cellSyncMutexLock(mutex=0x%x)", mutex.GetAddr());
cellSync->Log("cellSyncMutexLock(mutex=0x%x)", mutex.GetAddr());
if (!mutex.IsGood())
{
@ -102,7 +103,7 @@ int cellSyncMutexLock(mem_ptr_t<CellSyncMutex> mutex)
int cellSyncMutexTryLock(mem_ptr_t<CellSyncMutex> mutex)
{
cellSync.Log("cellSyncMutexTryLock(mutex=0x%x)", mutex.GetAddr());
cellSync->Log("cellSyncMutexTryLock(mutex=0x%x)", mutex.GetAddr());
if (!mutex.IsGood())
{
@ -138,7 +139,7 @@ int cellSyncMutexTryLock(mem_ptr_t<CellSyncMutex> mutex)
int cellSyncMutexUnlock(mem_ptr_t<CellSyncMutex> mutex)
{
cellSync.Log("cellSyncMutexUnlock(mutex=0x%x)", mutex.GetAddr());
cellSync->Log("cellSyncMutexUnlock(mutex=0x%x)", mutex.GetAddr());
if (!mutex.IsGood())
{
@ -164,8 +165,8 @@ int cellSyncMutexUnlock(mem_ptr_t<CellSyncMutex> mutex)
void cellSync_init()
{
cellSync.AddFunc(0xa9072dee, cellSyncMutexInitialize);
cellSync.AddFunc(0x1bb675c2, cellSyncMutexLock);
cellSync.AddFunc(0xd06918c4, cellSyncMutexTryLock);
cellSync.AddFunc(0x91f2b7b0, cellSyncMutexUnlock);
cellSync->AddFunc(0xa9072dee, cellSyncMutexInitialize);
cellSync->AddFunc(0x1bb675c2, cellSyncMutexLock);
cellSync->AddFunc(0xd06918c4, cellSyncMutexTryLock);
cellSync->AddFunc(0x91f2b7b0, cellSyncMutexUnlock);
}

38
rpcs3/Emu/SysCalls/Modules/cellSysmodule.cpp
View File

@ -4,10 +4,12 @@
#include "Emu/System.h"
#include "Emu/Cell/PPUThread.h"
#include "Emu/SysCalls/SC_FUNC.h"
#include "Emu/SysCalls/ModuleManager.h"
#include "Emu/SysCalls/Modules.h"
void cellSysmodule_init();
Module cellSysmodule("cellSysmodule", cellSysmodule_init);
//void cellSysmodule_init();
//Module cellSysmodule("cellSysmodule", cellSysmodule_init);
Module *cellSysmodule = nullptr;
enum
{
@ -144,19 +146,19 @@ const char *getModuleName(int id) {
int cellSysmoduleInitialize()
{
cellSysmodule.Log("cellSysmoduleInitialize()");
cellSysmodule->Log("cellSysmoduleInitialize()");
return CELL_OK;
}
int cellSysmoduleFinalize()
{
cellSysmodule.Log("cellSysmoduleFinalize()");
cellSysmodule->Log("cellSysmoduleFinalize()");
return CELL_OK;
}
int cellSysmoduleSetMemcontainer(u32 ct_id)
{
cellSysmodule.Warning("TODO: cellSysmoduleSetMemcontainer(ct_id=0x%x)", ct_id);
cellSysmodule->Warning("TODO: cellSysmoduleSetMemcontainer(ct_id=0x%x)", ct_id);
return CELL_OK;
}
@ -164,10 +166,10 @@ int cellSysmoduleLoadModule(u16 id)
{
if (id == 0xf054)
{
cellSysmodule.Error("cellSysmoduleLoadModule: TODO: CELL_SYSMODULE_LIBATRAC3MULTI");
cellSysmodule->Error("cellSysmoduleLoadModule: TODO: CELL_SYSMODULE_LIBATRAC3MULTI");
}
cellSysmodule.Warning("cellSysmoduleLoadModule(%s)", getModuleName(id));
Module* m = GetModuleById(id);
cellSysmodule->Warning("cellSysmoduleLoadModule(%s)", getModuleName(id));
Module* m = Emu.GetModuleManager().GetModuleById(id);
if(!m)
{
@ -185,8 +187,8 @@ int cellSysmoduleLoadModule(u16 id)
int cellSysmoduleUnloadModule(u16 id)
{
cellSysmodule.Warning("cellSysmoduleUnloadModule(%s)", getModuleName(id));
Module* m = GetModuleById(id);
cellSysmodule->Warning("cellSysmoduleUnloadModule(%s)", getModuleName(id));
Module* m = Emu.GetModuleManager().GetModuleById(id);
if(!m)
{
@ -204,8 +206,8 @@ int cellSysmoduleUnloadModule(u16 id)
int cellSysmoduleIsLoaded(u16 id)
{
cellSysmodule.Warning("cellSysmoduleIsLoaded(%s)", getModuleName(id));
Module* m = GetModuleById(id);
cellSysmodule->Warning("cellSysmoduleIsLoaded(%s)", getModuleName(id));
Module* m = Emu.GetModuleManager().GetModuleById(id);
if(!m)
{
@ -217,10 +219,10 @@ int cellSysmoduleIsLoaded(u16 id)
void cellSysmodule_init()
{
cellSysmodule.AddFunc(0x63ff6ff9, cellSysmoduleInitialize);
cellSysmodule.AddFunc(0x96c07adf, cellSysmoduleFinalize);
cellSysmodule.AddFunc(0xa193143c, cellSysmoduleSetMemcontainer);
cellSysmodule.AddFunc(0x32267a31, cellSysmoduleLoadModule);
cellSysmodule.AddFunc(0x112a5ee9, cellSysmoduleUnloadModule);
cellSysmodule.AddFunc(0x5a59e258, cellSysmoduleIsLoaded);
cellSysmodule->AddFunc(0x63ff6ff9, cellSysmoduleInitialize);
cellSysmodule->AddFunc(0x96c07adf, cellSysmoduleFinalize);
cellSysmodule->AddFunc(0xa193143c, cellSysmoduleSetMemcontainer);
cellSysmodule->AddFunc(0x32267a31, cellSysmoduleLoadModule);
cellSysmodule->AddFunc(0x112a5ee9, cellSysmoduleUnloadModule);
cellSysmodule->AddFunc(0x5a59e258, cellSysmoduleIsLoaded);
}

305
rpcs3/Emu/SysCalls/Modules/cellSysutil.cpp
View File

@ -17,12 +17,13 @@ typedef void (*CellMsgDialogCallback)(int buttonType, mem_ptr_t<void> userData);
typedef void (*CellHddGameStatCallback)(mem_ptr_t<CellHddGameCBResult> cbResult, mem_ptr_t<CellHddGameStatGet> get, mem_ptr_t<CellHddGameStatSet> set);
void cellSysutil_init();
Module cellSysutil(0x0015, cellSysutil_init);
//void cellSysutil_init();
//Module cellSysutil(0x0015, cellSysutil_init);
Module *cellSysutil;
int cellSysutilGetSystemParamInt(int id, mem32_t value)
{
cellSysutil.Log("cellSysutilGetSystemParamInt(id=0x%x, value_addr=0x%x)", id, value.GetAddr());
cellSysutil->Log("cellSysutilGetSystemParamInt(id=0x%x, value_addr=0x%x)", id, value.GetAddr());
if(!value.IsGood())
{
@ -32,77 +33,77 @@ int cellSysutilGetSystemParamInt(int id, mem32_t value)
switch(id)
{
case CELL_SYSUTIL_SYSTEMPARAM_ID_LANG:
cellSysutil.Warning("cellSysutilGetSystemParamInt: CELL_SYSUTIL_SYSTEMPARAM_ID_LANG");
cellSysutil->Warning("cellSysutilGetSystemParamInt: CELL_SYSUTIL_SYSTEMPARAM_ID_LANG");
value = Ini.SysLanguage.GetValue();
break;
case CELL_SYSUTIL_SYSTEMPARAM_ID_ENTER_BUTTON_ASSIGN:
cellSysutil.Warning("cellSysutilGetSystemParamInt: CELL_SYSUTIL_SYSTEMPARAM_ID_ENTER_BUTTON_ASSIGN");
cellSysutil->Warning("cellSysutilGetSystemParamInt: CELL_SYSUTIL_SYSTEMPARAM_ID_ENTER_BUTTON_ASSIGN");
value = CELL_SYSUTIL_ENTER_BUTTON_ASSIGN_CROSS;
break;
case CELL_SYSUTIL_SYSTEMPARAM_ID_DATE_FORMAT:
cellSysutil.Warning("cellSysutilGetSystemParamInt: CELL_SYSUTIL_SYSTEMPARAM_ID_DATE_FORMAT");
cellSysutil->Warning("cellSysutilGetSystemParamInt: CELL_SYSUTIL_SYSTEMPARAM_ID_DATE_FORMAT");
value = CELL_SYSUTIL_DATE_FMT_DDMMYYYY;
break;
case CELL_SYSUTIL_SYSTEMPARAM_ID_TIME_FORMAT:
cellSysutil.Warning("cellSysutilGetSystemParamInt: CELL_SYSUTIL_SYSTEMPARAM_ID_TIME_FORMAT");
cellSysutil->Warning("cellSysutilGetSystemParamInt: CELL_SYSUTIL_SYSTEMPARAM_ID_TIME_FORMAT");
value = CELL_SYSUTIL_TIME_FMT_CLOCK24;
break;
case CELL_SYSUTIL_SYSTEMPARAM_ID_TIMEZONE:
cellSysutil.Warning("cellSysutilGetSystemParamInt: CELL_SYSUTIL_SYSTEMPARAM_ID_TIMEZONE");
cellSysutil->Warning("cellSysutilGetSystemParamInt: CELL_SYSUTIL_SYSTEMPARAM_ID_TIMEZONE");
value = 3;
break;
case CELL_SYSUTIL_SYSTEMPARAM_ID_SUMMERTIME:
cellSysutil.Warning("cellSysutilGetSystemParamInt: CELL_SYSUTIL_SYSTEMPARAM_ID_SUMMERTIME");
cellSysutil->Warning("cellSysutilGetSystemParamInt: CELL_SYSUTIL_SYSTEMPARAM_ID_SUMMERTIME");
value = 1;
break;
case CELL_SYSUTIL_SYSTEMPARAM_ID_GAME_PARENTAL_LEVEL:
cellSysutil.Warning("cellSysutilGetSystemParamInt: CELL_SYSUTIL_SYSTEMPARAM_ID_GAME_PARENTAL_LEVEL");
cellSysutil->Warning("cellSysutilGetSystemParamInt: CELL_SYSUTIL_SYSTEMPARAM_ID_GAME_PARENTAL_LEVEL");
value = CELL_SYSUTIL_GAME_PARENTAL_OFF;
break;
case CELL_SYSUTIL_SYSTEMPARAM_ID_GAME_PARENTAL_LEVEL0_RESTRICT:
cellSysutil.Warning("cellSysutilGetSystemParamInt: CELL_SYSUTIL_SYSTEMPARAM_ID_GAME_PARENTAL_LEVEL0_RESTRICT");
cellSysutil->Warning("cellSysutilGetSystemParamInt: CELL_SYSUTIL_SYSTEMPARAM_ID_GAME_PARENTAL_LEVEL0_RESTRICT");
value = CELL_SYSUTIL_GAME_PARENTAL_LEVEL0_RESTRICT_OFF;
break;
case CELL_SYSUTIL_SYSTEMPARAM_ID_CURRENT_USER_HAS_NP_ACCOUNT:
cellSysutil.Warning("cellSysutilGetSystemParamInt: CELL_SYSUTIL_SYSTEMPARAM_ID_CURRENT_USER_HAS_NP_ACCOUNT");
cellSysutil->Warning("cellSysutilGetSystemParamInt: CELL_SYSUTIL_SYSTEMPARAM_ID_CURRENT_USER_HAS_NP_ACCOUNT");
value = 0;
break;
case CELL_SYSUTIL_SYSTEMPARAM_ID_CAMERA_PLFREQ:
cellSysutil.Warning("cellSysutilGetSystemParamInt: CELL_SYSUTIL_SYSTEMPARAM_ID_CAMERA_PLFREQ");
cellSysutil->Warning("cellSysutilGetSystemParamInt: CELL_SYSUTIL_SYSTEMPARAM_ID_CAMERA_PLFREQ");
value = CELL_SYSUTIL_CAMERA_PLFREQ_DISABLED;
break;
case CELL_SYSUTIL_SYSTEMPARAM_ID_PAD_RUMBLE:
cellSysutil.Warning("cellSysutilGetSystemParamInt: CELL_SYSUTIL_SYSTEMPARAM_ID_PAD_RUMBLE");
cellSysutil->Warning("cellSysutilGetSystemParamInt: CELL_SYSUTIL_SYSTEMPARAM_ID_PAD_RUMBLE");
value = CELL_SYSUTIL_PAD_RUMBLE_OFF;
break;
case CELL_SYSUTIL_SYSTEMPARAM_ID_KEYBOARD_TYPE:
cellSysutil.Warning("cellSysutilGetSystemParamInt: CELL_SYSUTIL_SYSTEMPARAM_ID_KEYBOARD_TYPE");
cellSysutil->Warning("cellSysutilGetSystemParamInt: CELL_SYSUTIL_SYSTEMPARAM_ID_KEYBOARD_TYPE");
value = 0;
break;
case CELL_SYSUTIL_SYSTEMPARAM_ID_JAPANESE_KEYBOARD_ENTRY_METHOD:
cellSysutil.Warning("cellSysutilGetSystemParamInt: CELL_SYSUTIL_SYSTEMPARAM_ID_JAPANESE_KEYBOARD_ENTRY_METHOD");
cellSysutil->Warning("cellSysutilGetSystemParamInt: CELL_SYSUTIL_SYSTEMPARAM_ID_JAPANESE_KEYBOARD_ENTRY_METHOD");
value = 0;
break;
case CELL_SYSUTIL_SYSTEMPARAM_ID_CHINESE_KEYBOARD_ENTRY_METHOD:
cellSysutil.Warning("cellSysutilGetSystemParamInt: CELL_SYSUTIL_SYSTEMPARAM_ID_CHINESE_KEYBOARD_ENTRY_METHOD");
cellSysutil->Warning("cellSysutilGetSystemParamInt: CELL_SYSUTIL_SYSTEMPARAM_ID_CHINESE_KEYBOARD_ENTRY_METHOD");
value = 0;
break;
case CELL_SYSUTIL_SYSTEMPARAM_ID_PAD_AUTOOFF:
cellSysutil.Warning("cellSysutilGetSystemParamInt: CELL_SYSUTIL_SYSTEMPARAM_ID_PAD_AUTOOFF");
cellSysutil->Warning("cellSysutilGetSystemParamInt: CELL_SYSUTIL_SYSTEMPARAM_ID_PAD_AUTOOFF");
value = 0;
break;
@ -115,7 +116,7 @@ int cellSysutilGetSystemParamInt(int id, mem32_t value)
int cellSysutilGetSystemParamString(s32 id, mem_list_ptr_t<u8> buf, u32 bufsize)
{
cellSysutil.Log("cellSysutilGetSystemParamString(id=%d, buf_addr=0x%x, bufsize=%d)", id, buf.GetAddr(), bufsize);
cellSysutil->Log("cellSysutilGetSystemParamString(id=%d, buf_addr=0x%x, bufsize=%d)", id, buf.GetAddr(), bufsize);
if (!buf.IsGood())
return CELL_EFAULT;
@ -125,12 +126,12 @@ int cellSysutilGetSystemParamString(s32 id, mem_list_ptr_t<u8> buf, u32 bufsize)
switch(id)
{
case CELL_SYSUTIL_SYSTEMPARAM_ID_NICKNAME:
cellSysutil.Warning("cellSysutilGetSystemParamString: CELL_SYSUTIL_SYSTEMPARAM_ID_NICKNAME");
cellSysutil->Warning("cellSysutilGetSystemParamString: CELL_SYSUTIL_SYSTEMPARAM_ID_NICKNAME");
memcpy(buf, "Unknown", 8); //for example
break;
case CELL_SYSUTIL_SYSTEMPARAM_ID_CURRENT_USERNAME:
cellSysutil.Warning("cellSysutilGetSystemParamString: CELL_SYSUTIL_SYSTEMPARAM_ID_CURRENT_USERNAME");
cellSysutil->Warning("cellSysutilGetSystemParamString: CELL_SYSUTIL_SYSTEMPARAM_ID_CURRENT_USERNAME");
memcpy(buf, "Unknown", 8);
break;
@ -143,7 +144,7 @@ int cellSysutilGetSystemParamString(s32 id, mem_list_ptr_t<u8> buf, u32 bufsize)
int cellVideoOutGetState(u32 videoOut, u32 deviceIndex, u32 state_addr)
{
cellSysutil.Log("cellVideoOutGetState(videoOut=0x%x, deviceIndex=0x%x, state_addr=0x%x)", videoOut, deviceIndex, state_addr);
cellSysutil->Log("cellVideoOutGetState(videoOut=0x%x, deviceIndex=0x%x, state_addr=0x%x)", videoOut, deviceIndex, state_addr);
if(deviceIndex) return CELL_VIDEO_OUT_ERROR_DEVICE_NOT_FOUND;
@ -181,7 +182,7 @@ int cellVideoOutGetState(u32 videoOut, u32 deviceIndex, u32 state_addr)
int cellVideoOutGetResolution(u32 resolutionId, mem_ptr_t<CellVideoOutResolution> resolution)
{
cellSysutil.Log("cellVideoOutGetResolution(resolutionId=%d, resolution_addr=0x%x)",
cellSysutil->Log("cellVideoOutGetResolution(resolutionId=%d, resolution_addr=0x%x)",
resolutionId, resolution.GetAddr());
if (!resolution.IsGood())
@ -199,7 +200,7 @@ int cellVideoOutGetResolution(u32 resolutionId, mem_ptr_t<CellVideoOutResolution
int cellVideoOutConfigure(u32 videoOut, u32 config_addr, u32 option_addr, u32 waitForEvent)
{
cellSysutil.Warning("cellVideoOutConfigure(videoOut=%d, config_addr=0x%x, option_addr=0x%x, waitForEvent=0x%x)",
cellSysutil->Warning("cellVideoOutConfigure(videoOut=%d, config_addr=0x%x, option_addr=0x%x, waitForEvent=0x%x)",
videoOut, config_addr, option_addr, waitForEvent);
if(!Memory.IsGoodAddr(config_addr, sizeof(CellVideoOutConfiguration)))
@ -240,7 +241,7 @@ int cellVideoOutConfigure(u32 videoOut, u32 config_addr, u32 option_addr, u32 wa
int cellVideoOutGetConfiguration(u32 videoOut, u32 config_addr, u32 option_addr)
{
cellSysutil.Warning("cellVideoOutGetConfiguration(videoOut=%d, config_addr=0x%x, option_addr=0x%x)",
cellSysutil->Warning("cellVideoOutGetConfiguration(videoOut=%d, config_addr=0x%x, option_addr=0x%x)",
videoOut, config_addr, option_addr);
if(!Memory.IsGoodAddr(config_addr, sizeof(CellVideoOutConfiguration))) return CELL_EFAULT;
@ -271,7 +272,7 @@ int cellVideoOutGetConfiguration(u32 videoOut, u32 config_addr, u32 option_addr)
int cellVideoOutGetDeviceInfo(u32 videoOut, u32 deviceIndex, mem_ptr_t<CellVideoOutDeviceInfo> info)
{
cellSysutil.Warning("cellVideoOutGetDeviceInfo(videoOut=%u, deviceIndex=%u, info_addr=0x%x)",
cellSysutil->Warning("cellVideoOutGetDeviceInfo(videoOut=%u, deviceIndex=%u, info_addr=0x%x)",
videoOut, deviceIndex, info.GetAddr());
if(deviceIndex) return CELL_VIDEO_OUT_ERROR_DEVICE_NOT_FOUND;
@ -303,7 +304,7 @@ int cellVideoOutGetDeviceInfo(u32 videoOut, u32 deviceIndex, mem_ptr_t<CellVideo
int cellVideoOutGetNumberOfDevice(u32 videoOut)
{
cellSysutil.Warning("cellVideoOutGetNumberOfDevice(videoOut=%d)", videoOut);
cellSysutil->Warning("cellVideoOutGetNumberOfDevice(videoOut=%d)", videoOut);
switch(videoOut)
{
@ -316,7 +317,7 @@ int cellVideoOutGetNumberOfDevice(u32 videoOut)
int cellVideoOutGetResolutionAvailability(u32 videoOut, u32 resolutionId, u32 aspect, u32 option)
{
cellSysutil.Warning("cellVideoOutGetResolutionAvailability(videoOut=%d, resolutionId=0x%x, option_addr=0x%x, aspect=0x%x, option=0x%x)",
cellSysutil->Warning("cellVideoOutGetResolutionAvailability(videoOut=%d, resolutionId=0x%x, option_addr=0x%x, aspect=0x%x, option=0x%x)",
videoOut, resolutionId, aspect, option);
if(!ResolutionIdToNum(resolutionId))
@ -338,7 +339,7 @@ extern std::atomic<u32> g_FsAioReadCur;
int cellSysutilCheckCallback()
{
cellSysutil.Log("cellSysutilCheckCallback()");
cellSysutil->Log("cellSysutilCheckCallback()");
Emu.GetCallbackManager().m_exit_callback.Check();
@ -359,22 +360,22 @@ int cellSysutilCheckCallback()
int cellSysutilRegisterCallback(int slot, u64 func_addr, u64 userdata)
{
cellSysutil.Warning("cellSysutilRegisterCallback(slot=%d, func_addr=0x%llx, userdata=0x%llx)", slot, func_addr, userdata);
cellSysutil->Warning("cellSysutilRegisterCallback(slot=%d, func_addr=0x%llx, userdata=0x%llx)", slot, func_addr, userdata);
Emu.GetCallbackManager().m_exit_callback.Register(slot, func_addr, userdata);
wxGetApp().SendDbgCommand(DID_REGISTRED_CALLBACK);
SendDbgCommand(DID_REGISTRED_CALLBACK);
return CELL_OK;
}
int cellSysutilUnregisterCallback(int slot)
{
cellSysutil.Warning("cellSysutilUnregisterCallback(slot=%d)", slot);
cellSysutil->Warning("cellSysutilUnregisterCallback(slot=%d)", slot);
Emu.GetCallbackManager().m_exit_callback.Unregister(slot);
wxGetApp().SendDbgCommand(DID_UNREGISTRED_CALLBACK);
SendDbgCommand(DID_UNREGISTRED_CALLBACK);
return CELL_OK;
}
@ -385,31 +386,31 @@ int cellMsgDialogOpen2(u32 type, char* msgString, mem_func_ptr_t<CellMsgDialogCa
if(type & CELL_MSGDIALOG_DIALOG_TYPE_NORMAL)
{
style |= wxICON_EXCLAMATION;
style |= rICON_EXCLAMATION;
}
else
{
style |= wxICON_ERROR;
style |= rICON_ERROR;
}
if(type & CELL_MSGDIALOG_BUTTON_TYPE_YESNO)
{
style |= wxYES_NO;
style |= rYES_NO;
}
else
{
style |= wxOK;
style |= rOK;
}
int res = wxMessageBox(wxString(msgString, wxConvUTF8), wxGetApp().GetAppName(), style);
int res = rMessageBox(std::string(msgString), rGetApp().GetAppName(), style);
u64 status;
switch(res)
{
case wxOK: status = CELL_MSGDIALOG_BUTTON_OK; break;
case wxYES: status = CELL_MSGDIALOG_BUTTON_YES; break;
case wxNO: status = CELL_MSGDIALOG_BUTTON_NO; break;
case rOK: status = CELL_MSGDIALOG_BUTTON_OK; break;
case rYES: status = CELL_MSGDIALOG_BUTTON_YES; break;
case rNO: status = CELL_MSGDIALOG_BUTTON_NO; break;
default:
if(res)
@ -430,7 +431,7 @@ int cellMsgDialogOpen2(u32 type, char* msgString, mem_func_ptr_t<CellMsgDialogCa
int cellMsgDialogOpenErrorCode(u32 errorCode, mem_func_ptr_t<CellMsgDialogCallback> callback, mem_ptr_t<void> userData, u32 extParam)
{
cellSysutil.Warning("cellMsgDialogOpenErrorCode(errorCode=0x%x, callback_addr=0x%x, userData=%d, extParam=%d)",
cellSysutil->Warning("cellMsgDialogOpenErrorCode(errorCode=0x%x, callback_addr=0x%x, userData=%d, extParam=%d)",
errorCode, callback.GetAddr(), userData, extParam);
std::string errorMessage;
@ -508,10 +509,10 @@ int cellMsgDialogOpenErrorCode(u32 errorCode, mem_func_ptr_t<CellMsgDialogCallba
errorMessage.append(")\n");
u64 status;
int res = wxMessageBox(errorMessage, wxGetApp().GetAppName(), wxICON_ERROR | wxOK);
int res = rMessageBox(errorMessage, rGetApp().GetAppName(), rICON_ERROR | rOK);
switch(res)
{
case wxOK: status = CELL_MSGDIALOG_BUTTON_OK; break;
case rOK: status = CELL_MSGDIALOG_BUTTON_OK; break;
default:
if(res)
{
@ -532,7 +533,7 @@ int cellMsgDialogOpenErrorCode(u32 errorCode, mem_func_ptr_t<CellMsgDialogCallba
int cellAudioOutGetSoundAvailability(u32 audioOut, u32 type, u32 fs, u32 option)
{
cellSysutil.Warning("cellAudioOutGetSoundAvailability(audioOut=%d, type=%d, fs=0x%x, option=%d)",
cellSysutil->Warning("cellAudioOutGetSoundAvailability(audioOut=%d, type=%d, fs=0x%x, option=%d)",
audioOut, type, fs, option);
option = 0;
@ -573,7 +574,7 @@ int cellAudioOutGetSoundAvailability(u32 audioOut, u32 type, u32 fs, u32 option)
int cellAudioOutGetSoundAvailability2(u32 audioOut, u32 type, u32 fs, u32 ch, u32 option)
{
cellSysutil.Warning("cellAudioOutGetSoundAvailability2(audioOut=%d, type=%d, fs=0x%x, ch=%d, option=%d)",
cellSysutil->Warning("cellAudioOutGetSoundAvailability2(audioOut=%d, type=%d, fs=0x%x, ch=%d, option=%d)",
audioOut, type, fs, ch, option);
option = 0;
@ -623,7 +624,7 @@ int cellAudioOutGetSoundAvailability2(u32 audioOut, u32 type, u32 fs, u32 ch, u3
int cellAudioOutGetState(u32 audioOut, u32 deviceIndex, u32 state_addr)
{
cellSysutil.Warning("cellAudioOutGetState(audioOut=0x%x,deviceIndex=0x%x,state_addr=0x%x)",audioOut,deviceIndex,state_addr);
cellSysutil->Warning("cellAudioOutGetState(audioOut=0x%x,deviceIndex=0x%x,state_addr=0x%x)",audioOut,deviceIndex,state_addr);
CellAudioOutState state;
memset(&state, 0, sizeof(CellAudioOutState));
@ -655,7 +656,7 @@ int cellAudioOutGetState(u32 audioOut, u32 deviceIndex, u32 state_addr)
int cellAudioOutConfigure(u32 audioOut, mem_ptr_t<CellAudioOutConfiguration> config, mem_ptr_t<CellAudioOutOption> option, u32 waitForEvent)
{
cellSysutil.Warning("cellAudioOutConfigure(audioOut=%d, config_addr=0x%x, option_addr=0x%x, (!)waitForEvent=%d)",
cellSysutil->Warning("cellAudioOutConfigure(audioOut=%d, config_addr=0x%x, option_addr=0x%x, (!)waitForEvent=%d)",
audioOut, config.GetAddr(), option.GetAddr(), waitForEvent);
if (!config.IsGood())
@ -689,7 +690,7 @@ int cellAudioOutConfigure(u32 audioOut, mem_ptr_t<CellAudioOutConfiguration> con
int cellAudioOutGetConfiguration(u32 audioOut, u32 config_addr, u32 option_addr)
{
cellSysutil.Warning("cellAudioOutGetConfiguration(audioOut=%d, config_addr=0x%x, option_addr=0x%x)",
cellSysutil->Warning("cellAudioOutGetConfiguration(audioOut=%d, config_addr=0x%x, option_addr=0x%x)",
audioOut, config_addr, option_addr);
if(!Memory.IsGoodAddr(config_addr, sizeof(CellAudioOutConfiguration))) return CELL_EFAULT;
@ -719,7 +720,7 @@ int cellAudioOutGetConfiguration(u32 audioOut, u32 config_addr, u32 option_addr)
int cellAudioOutGetNumberOfDevice(u32 audioOut)
{
cellSysutil.Warning("cellAudioOutGetNumberOfDevice(videoOut=%d)",audioOut);
cellSysutil->Warning("cellAudioOutGetNumberOfDevice(videoOut=%d)",audioOut);
switch(audioOut)
{
@ -732,7 +733,7 @@ int cellAudioOutGetNumberOfDevice(u32 audioOut)
int cellAudioOutGetDeviceInfo(u32 audioOut, u32 deviceIndex, mem_ptr_t<CellAudioOutDeviceInfo> info)
{
cellSysutil.Error("Unimplemented function: cellAudioOutGetDeviceInfo(audioOut=%u, deviceIndex=%u, info_addr=0x%x)",
cellSysutil->Error("Unimplemented function: cellAudioOutGetDeviceInfo(audioOut=%u, deviceIndex=%u, info_addr=0x%x)",
audioOut, deviceIndex, info.GetAddr());
if(deviceIndex) return CELL_AUDIO_OUT_ERROR_DEVICE_NOT_FOUND;
@ -751,7 +752,7 @@ int cellAudioOutGetDeviceInfo(u32 audioOut, u32 deviceIndex, mem_ptr_t<CellAudio
int cellAudioOutSetCopyControl(u32 audioOut, u32 control)
{
cellSysutil.Warning("cellAudioOutSetCopyControl(audioOut=%d,control=%d)",audioOut,control);
cellSysutil->Warning("cellAudioOutSetCopyControl(audioOut=%d,control=%d)",audioOut,control);
switch(audioOut)
{
@ -785,28 +786,28 @@ typedef struct{
} CellSysCacheParam;
class WxDirDeleteTraverser : public wxDirTraverser
{
public:
virtual wxDirTraverseResult OnFile(const wxString& filename)
{
if (!wxRemoveFile(filename)){
cellSysutil.Error("Couldn't delete File: %s", fmt::ToUTF8(filename).c_str());
}
return wxDIR_CONTINUE;
}
virtual wxDirTraverseResult OnDir(const wxString& dirname)
{
wxDir dir(dirname);
dir.Traverse(*this);
if (!wxRmDir(dirname)){
//this get triggered a few times while clearing folders
//but if this gets reimplented we should probably warn
//if directories can't be removed
}
return wxDIR_CONTINUE;
}
};
//class WxDirDeleteTraverser : public wxDirTraverser
//{
//public:
// virtual wxDirTraverseResult OnFile(const wxString& filename)
// {
// if (!wxRemoveFile(filename)){
// cellSysutil->Error("Couldn't delete File: %s", fmt::ToUTF8(filename).c_str());
// }
// return wxDIR_CONTINUE;
// }
// virtual wxDirTraverseResult OnDir(const wxString& dirname)
// {
// wxDir dir(dirname);
// dir.Traverse(*this);
// if (!wxRmDir(dirname)){
// //this get triggered a few times while clearing folders
// //but if this gets reimplented we should probably warn
// //if directories can't be removed
// }
// return wxDIR_CONTINUE;
// }
//};
int cellSysCacheClear(void)
{
@ -816,21 +817,23 @@ int cellSysCacheClear(void)
std::string localPath;
Emu.GetVFS().GetDevice(std::string("/dev_hdd1/cache/"), localPath);
//TODO: replace wxWidgetsSpecific filesystem stuff
if (wxDirExists(fmt::FromUTF8(localPath))){
WxDirDeleteTraverser deleter;
wxString f = wxFindFirstFile(fmt::FromUTF8(localPath+"\\*"),wxDIR);
while (!f.empty())
{
wxDir dir(f);
dir.Traverse(deleter);
f = wxFindNextFile();
}
return CELL_SYSCACHE_RET_OK_CLEARED;
}
else{
return CELL_SYSCACHE_ERROR_ACCESS_ERROR;
}
//TODO: implement
//if (rDirExists(localPath)){
// WxDirDeleteTraverser deleter;
// wxString f = wxFindFirstFile(fmt::FromUTF8(localPath+"\\*"),wxDIR);
// while (!f.empty())
// {
// wxDir dir(f);
// dir.Traverse(deleter);
// f = wxFindNextFile();
// }
// return CELL_SYSCACHE_RET_OK_CLEARED;
//}
//else{
// return CELL_SYSCACHE_ERROR_ACCESS_ERROR;
//}
return CELL_SYSCACHE_RET_OK_CLEARED;
}
int cellSysCacheMount(mem_ptr_t<CellSysCacheParam> param)
@ -847,7 +850,7 @@ int cellSysCacheMount(mem_ptr_t<CellSysCacheParam> param)
int cellHddGameCheck(u32 version, u32 dirName_addr, u32 errDialog, mem_func_ptr_t<CellHddGameStatCallback> funcStat, u32 container)
{
cellSysutil.Warning("cellHddGameCheck(version=%d, dirName_addr=0x%xx, errDialog=%d, funcStat_addr=0x%x, container=%d)",
cellSysutil->Warning("cellHddGameCheck(version=%d, dirName_addr=0x%xx, errDialog=%d, funcStat_addr=0x%x, container=%d)",
version, dirName_addr, errDialog, funcStat, container);
if (!Memory.IsGoodAddr(dirName_addr) || !funcStat.IsGood())
@ -918,7 +921,7 @@ int cellHddGameCheck(u32 version, u32 dirName_addr, u32 errDialog, mem_func_ptr_
int cellSysutilGetBgmPlaybackStatus(mem_ptr_t<CellBgmPlaybackStatus> status)
{
cellSysutil.Warning("cellSysutilGetBgmPlaybackStatus(status=0x%x)", status.GetAddr());
cellSysutil->Warning("cellSysutilGetBgmPlaybackStatus(status=0x%x)", status.GetAddr());
// non-essential, so always assume background music is stopped/disabled
status->playbackState = CELL_BGMPLAYBACK_STATUS_STOP;
@ -939,74 +942,74 @@ int cellWebBrowserEstimate2(mem8_ptr_t _config, mem32_ptr_t memSize)
void cellSysutil_init()
{
cellSysutil.AddFunc(0x40e895d3, cellSysutilGetSystemParamInt);
cellSysutil.AddFunc(0x938013a0, cellSysutilGetSystemParamString);
cellSysutil->AddFunc(0x40e895d3, cellSysutilGetSystemParamInt);
cellSysutil->AddFunc(0x938013a0, cellSysutilGetSystemParamString);
cellSysutil.AddFunc(0x887572d5, cellVideoOutGetState);
cellSysutil.AddFunc(0xe558748d, cellVideoOutGetResolution);
cellSysutil.AddFunc(0x0bae8772, cellVideoOutConfigure);
cellSysutil.AddFunc(0x15b0b0cd, cellVideoOutGetConfiguration);
cellSysutil.AddFunc(0x1e930eef, cellVideoOutGetDeviceInfo);
cellSysutil.AddFunc(0x75bbb672, cellVideoOutGetNumberOfDevice);
cellSysutil.AddFunc(0xa322db75, cellVideoOutGetResolutionAvailability);
cellSysutil->AddFunc(0x887572d5, cellVideoOutGetState);
cellSysutil->AddFunc(0xe558748d, cellVideoOutGetResolution);
cellSysutil->AddFunc(0x0bae8772, cellVideoOutConfigure);
cellSysutil->AddFunc(0x15b0b0cd, cellVideoOutGetConfiguration);
cellSysutil->AddFunc(0x1e930eef, cellVideoOutGetDeviceInfo);
cellSysutil->AddFunc(0x75bbb672, cellVideoOutGetNumberOfDevice);
cellSysutil->AddFunc(0xa322db75, cellVideoOutGetResolutionAvailability);
cellSysutil.AddFunc(0x189a74da, cellSysutilCheckCallback);
cellSysutil.AddFunc(0x9d98afa0, cellSysutilRegisterCallback);
cellSysutil.AddFunc(0x02ff3c1b, cellSysutilUnregisterCallback);
cellSysutil->AddFunc(0x189a74da, cellSysutilCheckCallback);
cellSysutil->AddFunc(0x9d98afa0, cellSysutilRegisterCallback);
cellSysutil->AddFunc(0x02ff3c1b, cellSysutilUnregisterCallback);
cellSysutil.AddFunc(0x7603d3db, cellMsgDialogOpen2);
cellSysutil.AddFunc(0x3e22cb4b, cellMsgDialogOpenErrorCode);
cellSysutil->AddFunc(0x7603d3db, cellMsgDialogOpen2);
cellSysutil->AddFunc(0x3e22cb4b, cellMsgDialogOpenErrorCode);
cellSysutil.AddFunc(0xf4e3caa0, cellAudioOutGetState);
cellSysutil.AddFunc(0x4692ab35, cellAudioOutConfigure);
cellSysutil.AddFunc(0xc01b4e7c, cellAudioOutGetSoundAvailability);
cellSysutil.AddFunc(0x2beac488, cellAudioOutGetSoundAvailability2);
cellSysutil.AddFunc(0x7663e368, cellAudioOutGetDeviceInfo);
cellSysutil.AddFunc(0xe5e2b09d, cellAudioOutGetNumberOfDevice);
cellSysutil.AddFunc(0xed5d96af, cellAudioOutGetConfiguration);
cellSysutil.AddFunc(0xc96e89e9, cellAudioOutSetCopyControl);
cellSysutil->AddFunc(0xf4e3caa0, cellAudioOutGetState);
cellSysutil->AddFunc(0x4692ab35, cellAudioOutConfigure);
cellSysutil->AddFunc(0xc01b4e7c, cellAudioOutGetSoundAvailability);
cellSysutil->AddFunc(0x2beac488, cellAudioOutGetSoundAvailability2);
cellSysutil->AddFunc(0x7663e368, cellAudioOutGetDeviceInfo);
cellSysutil->AddFunc(0xe5e2b09d, cellAudioOutGetNumberOfDevice);
cellSysutil->AddFunc(0xed5d96af, cellAudioOutGetConfiguration);
cellSysutil->AddFunc(0xc96e89e9, cellAudioOutSetCopyControl);
cellSysutil.AddFunc(0xa11552f6, cellSysutilGetBgmPlaybackStatus);
cellSysutil->AddFunc(0xa11552f6, cellSysutilGetBgmPlaybackStatus);
cellSysutil.AddFunc(0x1e7bff94, cellSysCacheMount);
cellSysutil.AddFunc(0x744c1544, cellSysCacheClear);
cellSysutil->AddFunc(0x1e7bff94, cellSysCacheMount);
cellSysutil->AddFunc(0x744c1544, cellSysCacheClear);
cellSysutil.AddFunc(0x9117df20, cellHddGameCheck);
//cellSysutil.AddFunc(0x4bdec82a, cellHddGameCheck2);
//cellSysutil.AddFunc(0xf82e2ef7, cellHddGameGetSizeKB);
//cellSysutil.AddFunc(0x9ca9ffa7, cellHddGameSetSystemVer);
//cellSysutil.AddFunc(0xafd605b3, cellHddGameExitBroken);
cellSysutil->AddFunc(0x9117df20, cellHddGameCheck);
//cellSysutil->AddFunc(0x4bdec82a, cellHddGameCheck2);
//cellSysutil->AddFunc(0xf82e2ef7, cellHddGameGetSizeKB);
//cellSysutil->AddFunc(0x9ca9ffa7, cellHddGameSetSystemVer);
//cellSysutil->AddFunc(0xafd605b3, cellHddGameExitBroken);
//cellSysutil_SaveData
//cellSysutil.AddFunc(0x04c06fc2, cellSaveDataGetListItem);
//cellSysutil.AddFunc(0x273d116a, cellSaveDataUserListExport);
//cellSysutil.AddFunc(0x27cb8bc2, cellSaveDataListDelete);
//cellSysutil.AddFunc(0x39d6ee43, cellSaveDataUserListImport);
//cellSysutil.AddFunc(0x46a2d878, cellSaveDataFixedExport);
//cellSysutil.AddFunc(0x491cc554, cellSaveDataListExport);
//cellSysutil.AddFunc(0x52541151, cellSaveDataFixedImport);
//cellSysutil.AddFunc(0x529231b0, cellSaveDataUserFixedImport);
//cellSysutil.AddFunc(0x6b4e0de6, cellSaveDataListImport);
//cellSysutil.AddFunc(0x7048a9ba, cellSaveDataUserListDelete);
//cellSysutil.AddFunc(0x95ae2cde, cellSaveDataUserFixedExport);
//cellSysutil.AddFunc(0xf6482036, cellSaveDataUserGetListItem);
cellSysutil.AddFunc(0x2de0d663, cellSaveDataListSave2);
cellSysutil.AddFunc(0x1dfbfdd6, cellSaveDataListLoad2);
cellSysutil.AddFunc(0x2aae9ef5, cellSaveDataFixedSave2);
cellSysutil.AddFunc(0x2a8eada2, cellSaveDataFixedLoad2);
cellSysutil.AddFunc(0x8b7ed64b, cellSaveDataAutoSave2);
cellSysutil.AddFunc(0xfbd5c856, cellSaveDataAutoLoad2);
//cellSysutil.AddFunc(0x4dd03a4e, cellSaveDataListAutoSave);
//cellSysutil.AddFunc(0x21425307, cellSaveDataListAutoLoad);
//cellSysutil.AddFunc(0xedadd797, cellSaveDataDelete2);
//cellSysutil.AddFunc(0x0f03cfb0, cellSaveDataUserListSave);
//cellSysutil.AddFunc(0x39dd8425, cellSaveDataUserListLoad);
//cellSysutil.AddFunc(0x40b34847, cellSaveDataUserFixedSave);
//cellSysutil.AddFunc(0x6e7264ed, cellSaveDataUserFixedLoad);
//cellSysutil.AddFunc(0x52aac4fa, cellSaveDataUserAutoSave);
//cellSysutil.AddFunc(0xcdc6aefd, cellSaveDataUserAutoLoad);
//cellSysutil.AddFunc(0x0e091c36, cellSaveDataUserListAutoSave);
//cellSysutil.AddFunc(0xe7fa820b, cellSaveDataEnableOverlay);
//cellSysutil->AddFunc(0x04c06fc2, cellSaveDataGetListItem);
//cellSysutil->AddFunc(0x273d116a, cellSaveDataUserListExport);
//cellSysutil->AddFunc(0x27cb8bc2, cellSaveDataListDelete);
//cellSysutil->AddFunc(0x39d6ee43, cellSaveDataUserListImport);
//cellSysutil->AddFunc(0x46a2d878, cellSaveDataFixedExport);
//cellSysutil->AddFunc(0x491cc554, cellSaveDataListExport);
//cellSysutil->AddFunc(0x52541151, cellSaveDataFixedImport);
//cellSysutil->AddFunc(0x529231b0, cellSaveDataUserFixedImport);
//cellSysutil->AddFunc(0x6b4e0de6, cellSaveDataListImport);
//cellSysutil->AddFunc(0x7048a9ba, cellSaveDataUserListDelete);
//cellSysutil->AddFunc(0x95ae2cde, cellSaveDataUserFixedExport);
//cellSysutil->AddFunc(0xf6482036, cellSaveDataUserGetListItem);
cellSysutil->AddFunc(0x2de0d663, cellSaveDataListSave2);
cellSysutil->AddFunc(0x1dfbfdd6, cellSaveDataListLoad2);
cellSysutil->AddFunc(0x2aae9ef5, cellSaveDataFixedSave2);
cellSysutil->AddFunc(0x2a8eada2, cellSaveDataFixedLoad2);
cellSysutil->AddFunc(0x8b7ed64b, cellSaveDataAutoSave2);
cellSysutil->AddFunc(0xfbd5c856, cellSaveDataAutoLoad2);
//cellSysutil->AddFunc(0x4dd03a4e, cellSaveDataListAutoSave);
//cellSysutil->AddFunc(0x21425307, cellSaveDataListAutoLoad);
//cellSysutil->AddFunc(0xedadd797, cellSaveDataDelete2);
//cellSysutil->AddFunc(0x0f03cfb0, cellSaveDataUserListSave);
//cellSysutil->AddFunc(0x39dd8425, cellSaveDataUserListLoad);
//cellSysutil->AddFunc(0x40b34847, cellSaveDataUserFixedSave);
//cellSysutil->AddFunc(0x6e7264ed, cellSaveDataUserFixedLoad);
//cellSysutil->AddFunc(0x52aac4fa, cellSaveDataUserAutoSave);
//cellSysutil->AddFunc(0xcdc6aefd, cellSaveDataUserAutoLoad);
//cellSysutil->AddFunc(0x0e091c36, cellSaveDataUserListAutoSave);
//cellSysutil->AddFunc(0xe7fa820b, cellSaveDataEnableOverlay);
cellSysutil.AddFunc(0x6d087930, cellWebBrowserEstimate2);
cellSysutil->AddFunc(0x6d087930, cellWebBrowserEstimate2);
}

13
rpcs3/Emu/SysCalls/Modules/cellSysutilAp.cpp
View File

@ -6,8 +6,9 @@
#include "Emu/SysCalls/SC_FUNC.h"
#include "Emu/SysCalls/Modules.h"
void cellSysutilAp_init();
Module cellSysutilAp(0x0039, cellSysutilAp_init);
//void cellSysutilAp_init();
//Module cellSysutilAp(0x0039, cellSysutilAp_init);
extern Module *cellSysutilAp = nullptr;
// Return Codes
enum
@ -24,7 +25,7 @@ enum
s32 cellSysutilApGetRequiredMemSize()
{
cellSysutilAp.Log("cellSysutilApGetRequiredMemSize()");
cellSysutilAp->Log("cellSysutilApGetRequiredMemSize()");
return 1024*1024; // Return 1 MB as required size
}
@ -42,7 +43,7 @@ int cellSysutilApOff()
void cellSysutilAp_init()
{
cellSysutilAp.AddFunc(0x9e67e0dd, cellSysutilApGetRequiredMemSize);
cellSysutilAp.AddFunc(0x3343824c, cellSysutilApOn);
cellSysutilAp.AddFunc(0x90c2bb19, cellSysutilApOff);
cellSysutilAp->AddFunc(0x9e67e0dd, cellSysutilApGetRequiredMemSize);
cellSysutilAp->AddFunc(0x3343824c, cellSysutilApOn);
cellSysutilAp->AddFunc(0x90c2bb19, cellSysutilApOff);
}

14
rpcs3/Emu/SysCalls/Modules/cellSysutil_SaveData.cpp
View File

@ -12,7 +12,7 @@
#include "cellSysutil_SaveData.h"
#include "Loader/PSF.h"
extern Module cellSysutil;
extern Module *cellSysutil;
// Auxiliary Classes
class sortSaveDataEntry
@ -294,7 +294,7 @@ int cellSaveDataListSave2(u32 version, mem_ptr_t<CellSaveDataSetList> setList, m
mem_func_ptr_t<CellSaveDataListCallback> funcList, mem_func_ptr_t<CellSaveDataStatCallback> funcStat, mem_func_ptr_t<CellSaveDataFileCallback> funcFile,
u32 container, u32 userdata_addr)
{
cellSysutil.Warning("cellSaveDataListSave2(version=%d, setList_addr=0x%x, setBuf_addr=0x%x, funcList_addr=0x%x, funcStat_addr=0x%x, funcFile_addr=0x%x, container=%d, userdata_addr=0x%x)",
cellSysutil->Warning("cellSaveDataListSave2(version=%d, setList_addr=0x%x, setBuf_addr=0x%x, funcList_addr=0x%x, funcStat_addr=0x%x, funcFile_addr=0x%x, container=%d, userdata_addr=0x%x)",
version, setList.GetAddr(), setBuf.GetAddr(), funcList.GetAddr(), funcStat.GetAddr(), funcFile.GetAddr(), container, userdata_addr);
if (!setList.IsGood() || !setBuf.IsGood() || !funcList.IsGood() || !funcStat.IsGood() || !funcFile.IsGood())
@ -379,7 +379,7 @@ int cellSaveDataListLoad2(u32 version, mem_ptr_t<CellSaveDataSetList> setList, m
mem_func_ptr_t<CellSaveDataListCallback> funcList, mem_func_ptr_t<CellSaveDataStatCallback> funcStat, mem_func_ptr_t<CellSaveDataFileCallback> funcFile,
u32 container, u32 userdata_addr)
{
cellSysutil.Warning("cellSaveDataListLoad2(version=%d, setList_addr=0x%x, setBuf_addr=0x%x, funcList_addr=0x%x, funcStat_addr=0x%x, funcFile_addr=0x%x, container=%d, userdata_addr=0x%x)",
cellSysutil->Warning("cellSaveDataListLoad2(version=%d, setList_addr=0x%x, setBuf_addr=0x%x, funcList_addr=0x%x, funcStat_addr=0x%x, funcFile_addr=0x%x, container=%d, userdata_addr=0x%x)",
version, setList.GetAddr(), setBuf.GetAddr(), funcList.GetAddr(), funcStat.GetAddr(), funcFile.GetAddr(), container, userdata_addr);
if (!setList.IsGood() || !setBuf.IsGood() || !funcList.IsGood() || !funcStat.IsGood() || !funcFile.IsGood())
@ -464,7 +464,7 @@ int cellSaveDataFixedSave2(u32 version, mem_ptr_t<CellSaveDataSetList> setList,
mem_func_ptr_t<CellSaveDataFixedCallback> funcFixed, mem_func_ptr_t<CellSaveDataStatCallback> funcStat, mem_func_ptr_t<CellSaveDataFileCallback> funcFile,
u32 container, u32 userdata_addr)
{
cellSysutil.Warning("cellSaveDataFixedSave2(version=%d, setList_addr=0x%x, setBuf_addr=0x%x, funcFixed_addr=0x%x, funcStat_addr=0x%x, funcFile_addr=0x%x, container=%d, userdata_addr=0x%x)",
cellSysutil->Warning("cellSaveDataFixedSave2(version=%d, setList_addr=0x%x, setBuf_addr=0x%x, funcFixed_addr=0x%x, funcStat_addr=0x%x, funcFile_addr=0x%x, container=%d, userdata_addr=0x%x)",
version, setList.GetAddr(), setBuf.GetAddr(), funcFixed.GetAddr(), funcStat.GetAddr(), funcFile.GetAddr(), container, userdata_addr);
if (!setList.IsGood() || !setBuf.IsGood() || !funcFixed.IsGood() || !funcStat.IsGood() || !funcFile.IsGood())
@ -536,7 +536,7 @@ int cellSaveDataFixedLoad2(u32 version, mem_ptr_t<CellSaveDataSetList> setList,
mem_func_ptr_t<CellSaveDataFixedCallback> funcFixed, mem_func_ptr_t<CellSaveDataStatCallback> funcStat, mem_func_ptr_t<CellSaveDataFileCallback> funcFile,
u32 container, u32 userdata_addr)
{
cellSysutil.Warning("cellSaveDataFixedLoad2(version=%d, setList_addr=0x%x, setBuf=0x%x, funcList=0x%x, funcStat=0x%x, funcFile=0x%x, container=%d, userdata_addr=0x%x)",
cellSysutil->Warning("cellSaveDataFixedLoad2(version=%d, setList_addr=0x%x, setBuf=0x%x, funcList=0x%x, funcStat=0x%x, funcFile=0x%x, container=%d, userdata_addr=0x%x)",
version, setList.GetAddr(), setBuf.GetAddr(), funcFixed.GetAddr(), funcStat.GetAddr(), funcFile.GetAddr(), container, userdata_addr);
if (!setList.IsGood() || !setBuf.IsGood() || !funcFixed.IsGood() || !funcStat.IsGood() || !funcFile.IsGood())
@ -608,7 +608,7 @@ int cellSaveDataAutoSave2(u32 version, u32 dirName_addr, u32 errDialog, mem_ptr_
mem_func_ptr_t<CellSaveDataStatCallback> funcStat, mem_func_ptr_t<CellSaveDataFileCallback> funcFile,
u32 container, u32 userdata_addr)
{
cellSysutil.Warning("cellSaveDataAutoSave2(version=%d, dirName_addr=0x%x, errDialog=%d, setBuf=0x%x, funcList=0x%x, funcStat=0x%x, funcFile=0x%x, container=%d, userdata_addr=0x%x)",
cellSysutil->Warning("cellSaveDataAutoSave2(version=%d, dirName_addr=0x%x, errDialog=%d, setBuf=0x%x, funcList=0x%x, funcStat=0x%x, funcFile=0x%x, container=%d, userdata_addr=0x%x)",
version, dirName_addr, errDialog, setBuf.GetAddr(), funcStat.GetAddr(), funcFile.GetAddr(), container, userdata_addr);
if (!setBuf.IsGood() || !funcStat.IsGood() || !funcFile.IsGood())
@ -664,7 +664,7 @@ int cellSaveDataAutoLoad2(u32 version, u32 dirName_addr, u32 errDialog, mem_ptr_
mem_func_ptr_t<CellSaveDataStatCallback> funcStat, mem_func_ptr_t<CellSaveDataFileCallback> funcFile,
u32 container, u32 userdata_addr)
{
cellSysutil.Warning("cellSaveDataAutoLoad2(version=%d, dirName_addr=0x%x, errDialog=%d, setBuf=0x%x, funcList=0x%x, funcStat=0x%x, funcFile=0x%x, container=%d, userdata_addr=0x%x)",
cellSysutil->Warning("cellSaveDataAutoLoad2(version=%d, dirName_addr=0x%x, errDialog=%d, setBuf=0x%x, funcList=0x%x, funcStat=0x%x, funcFile=0x%x, container=%d, userdata_addr=0x%x)",
version, dirName_addr, errDialog, setBuf.GetAddr(), funcStat.GetAddr(), funcFile.GetAddr(), container, userdata_addr);
if (!setBuf.IsGood() || !funcStat.IsGood() || !funcFile.IsGood())

Some files were not shown because too many files have changed in this diff Show More