RPCS3/rpcs3
1
0
Fork 0
mirror of https://github.com/RPCS3/rpcs3.git synced 2024-11-22 10:42:36 +01:00
Code Issues Releases Wiki Activity

Fixed OpenGL error 0x0502.

Browse Source 
Implemented cellRtc module.

Added module name list in cellSysmodule to aid debugging.
This commit is contained in:
Hykem 2013-11-09 01:27:37 +00:00
parent 60261408c2
commit 3076571b6f
6 changed files with 1533 additions and 1046 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -13,6 +13,8 @@
gcmBuffer gcmBuffers[8];
int last_width = 0, last_height = 0, last_depth_format = 0;
void printGlError(GLenum err, const char* situation)
{
if(err != GL_NO_ERROR)
@ -224,6 +226,10 @@ void GLGSRender::Init(const u32 ioAddress, const u32 ioSize, const u32 ctrlAddre
m_width = 720;
m_height = 576;
last_width = 0;
last_height = 0;
last_depth_format = 0;
m_frame->Show();
m_ioAddress = ioAddress;
@ -1981,8 +1987,6 @@ void GLGSRender::ExecCMD()
{
if(LoadProgram())
{
static int last_width = 0, last_height = 0, last_depth_format = 0;
if(m_width != last_width || m_height != last_height || last_depth_format != m_surface_depth_format)
{
ConLog.Warning("New FBO (%dx%d)", m_width, m_height);

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

@ -24,202 +24,561 @@ enum
CELL_RTC_ERROR_INVALID_MICROSECOND = 0x80010627,
};
int cellRtcGetCurrentTick()
struct CellRtcTick
{
UNIMPLEMENTED_FUNC(cellRtc);
u64 tick;
};
struct CellRtcDateTime {
u16 year;
u16 month;
u16 day;
u16 hour;
u16 minute;
u16 second;
u32 microsecond;
};
long convertToUNIXTime(u16 seconds, u16 minutes, u16 hours, u16 days, int years) {
return (seconds + minutes*60 + hours*3600 + days*86400 + (years-70)*31536000 + ((years-69)/4)*86400 - ((years-1)/100)*86400 + ((years+299)/400)*86400);
}
u64 convertToWin32FILETIME(u16 seconds, u16 minutes, u16 hours, u16 days, int years) {
long unixtime = convertToUNIXTime(seconds, minutes, hours, days, years);
LONGLONG win32time = Int32x32To64(unixtime, 10000000) + 116444736000000000;
u64 win32filetime = (u64) win32time | win32time >> 32;
return win32filetime;
}
int cellRtcGetCurrentTick(mem64_t tick)
{
cellRtc.Log("cellRtcGetCurrentTick(tick_addr=0x%x)", tick.GetAddr());
CellRtcTick *current_tick = new CellRtcTick;
wxDateTime unow = wxDateTime::UNow();
current_tick->tick = unow.GetTicks();
tick = current_tick->tick;
return CELL_OK;
}
int cellRtcGetCurrentClock()
int cellRtcGetCurrentClock(u32 clock_addr, int time_zone)
{
UNIMPLEMENTED_FUNC(cellRtc);
cellRtc.Log("cellRtcGetCurrentClock(clock_addr=0x%x, time_zone=%d)", clock_addr, time_zone);
CellRtcDateTime *current_clock = new CellRtcDateTime;
wxDateTime unow = wxDateTime::UNow();
// Add time_zone as offset in minutes.
wxTimeSpan tz = wxTimeSpan::wxTimeSpan(0, (long) time_zone, 0, 0);
unow.Add(tz);
current_clock->year = unow.GetYear(wxDateTime::TZ::UTC);
current_clock->month = unow.GetMonth(wxDateTime::TZ::UTC);
current_clock->day = unow.GetDay(wxDateTime::TZ::UTC);
current_clock->hour = unow.GetHour(wxDateTime::TZ::UTC);
current_clock->minute = unow.GetMinute(wxDateTime::TZ::UTC);
current_clock->second = unow.GetSecond(wxDateTime::TZ::UTC);
current_clock->microsecond = unow.GetMillisecond(wxDateTime::TZ::UTC) * 1000;
Memory.Write16(clock_addr, current_clock->year);
Memory.Write16(clock_addr + 2, current_clock->month);
Memory.Write16(clock_addr + 4, current_clock->day);
Memory.Write16(clock_addr + 6, current_clock->hour);
Memory.Write16(clock_addr + 8, current_clock->minute);
Memory.Write16(clock_addr + 10, current_clock->second);
Memory.Write32(clock_addr + 12, current_clock->microsecond);
return CELL_OK;
}
int cellRtcGetCurrentClockLocalTime()
int cellRtcGetCurrentClockLocalTime(u32 clock_addr)
{
UNIMPLEMENTED_FUNC(cellRtc);
cellRtc.Log("cellRtcGetCurrentClockLocalTime(clock_addr=0x%x)", clock_addr);
CellRtcDateTime *current_clock = new CellRtcDateTime;
wxDateTime unow = wxDateTime::UNow();
current_clock->year = unow.GetYear(wxDateTime::TZ::Local);
current_clock->month = unow.GetMonth(wxDateTime::TZ::Local);
current_clock->day = unow.GetDay(wxDateTime::TZ::Local);
current_clock->hour = unow.GetHour(wxDateTime::TZ::Local);
current_clock->minute = unow.GetMinute(wxDateTime::TZ::Local);
current_clock->second = unow.GetSecond(wxDateTime::TZ::Local);
current_clock->microsecond = unow.GetMillisecond(wxDateTime::TZ::Local) * 1000;
Memory.Write16(clock_addr, current_clock->year);
Memory.Write16(clock_addr + 2, current_clock->month);
Memory.Write16(clock_addr + 4, current_clock->day);
Memory.Write16(clock_addr + 6, current_clock->hour);
Memory.Write16(clock_addr + 8, current_clock->minute);
Memory.Write16(clock_addr + 10, current_clock->second);
Memory.Write32(clock_addr + 12, current_clock->microsecond);
return CELL_OK;
}
int cellRtcFormatRfc2822()
int cellRtcFormatRfc2822(u32 rfc_addr, u32 tick_addr, int time_zone)
{
UNIMPLEMENTED_FUNC(cellRtc);
cellRtc.Log("cellRtcFormatRfc2822(rfc_addr=0x%x, tick_addr=0x%x, time_zone=%d)", rfc_addr, tick_addr, time_zone);
CellRtcTick *current_tick = new CellRtcTick;
current_tick->tick = Memory.Read64(tick_addr);
// Add time_zone as offset in minutes.
wxTimeSpan tz = wxTimeSpan::wxTimeSpan(0, (long) time_zone, 0, 0);
// Get date from ticks + tz.
wxDateTime date = wxDateTime::wxDateTime((time_t)current_tick->tick);
date.Add(tz);
// Format date string in RFC2822 format (e.g.: Mon, 01 Jan 1990 12:00:00 +0000).
const wxString& str = date.Format("%a, %d %b %Y %T %z", wxDateTime::TZ::UTC);
Memory.WriteString(rfc_addr, str);
return CELL_OK;
}
int cellRtcFormatRfc2822LocalTime()
int cellRtcFormatRfc2822LocalTime(u32 rfc_addr, u32 tick_addr)
{
UNIMPLEMENTED_FUNC(cellRtc);
cellRtc.Log("cellRtcFormatRfc2822LocalTime(rfc_addr=0x%x, tick_addr=0x%x)", rfc_addr, tick_addr);
CellRtcTick *current_tick = new CellRtcTick;
current_tick->tick = Memory.Read64(tick_addr);
// Get date from ticks.
wxDateTime date = wxDateTime::wxDateTime((time_t)current_tick->tick);
// Format date string in RFC2822 format (e.g.: Mon, 01 Jan 1990 12:00:00 +0000).
const wxString& str = date.Format("%a, %d %b %Y %T %z", wxDateTime::TZ::Local);
Memory.WriteString(rfc_addr, str);
return CELL_OK;
}
int cellRtcFormatRfc3339()
int cellRtcFormatRfc3339(u32 rfc_addr, u32 tick_addr, int time_zone)
{
UNIMPLEMENTED_FUNC(cellRtc);
cellRtc.Log("cellRtcFormatRfc3339(rfc_addr=0x%x, tick_addr=0x%x, time_zone=%d)", rfc_addr, tick_addr, time_zone);
CellRtcTick *current_tick = new CellRtcTick;
current_tick->tick = Memory.Read64(tick_addr);
// Add time_zone as offset in minutes.
wxTimeSpan tz = wxTimeSpan::wxTimeSpan(0, (long) time_zone, 0, 0);
// Get date from ticks + tz.
wxDateTime date = wxDateTime::wxDateTime((time_t)current_tick->tick);
date.Add(tz);
// Format date string in RFC3339 format (e.g.: 1990-01-01T12:00:00.00Z).
const wxString& str = date.Format("%FT%T.%zZ", wxDateTime::TZ::UTC);
Memory.WriteString(rfc_addr, str);
return CELL_OK;
}
int cellRtcFormatRfc3339LocalTime()
int cellRtcFormatRfc3339LocalTime(u32 rfc_addr, u32 tick_addr)
{
UNIMPLEMENTED_FUNC(cellRtc);
cellRtc.Log("cellRtcFormatRfc3339LocalTime(rfc_addr=0x%x, tick_addr=0x%x)", rfc_addr, tick_addr);
CellRtcTick *current_tick = new CellRtcTick;
current_tick->tick = Memory.Read64(tick_addr);
// Get date from ticks.
wxDateTime date = wxDateTime::wxDateTime((time_t)current_tick->tick);
// Format date string in RFC3339 format (e.g.: 1990-01-01T12:00:00.00Z).
const wxString& str = date.Format("%FT%T.%zZ", wxDateTime::TZ::Local);
Memory.WriteString(rfc_addr, str);
return CELL_OK;
}
int cellRtcParseDateTime()
int cellRtcParseDateTime(mem64_t tick, u32 datetime_addr)
{
UNIMPLEMENTED_FUNC(cellRtc);
cellRtc.Log("cellRtcParseDateTime(tick_addr=0x%x, datetime_addr=0x%x)", tick.GetAddr(), datetime_addr);
const wxString& format = Memory.ReadString(datetime_addr);
// Get date from formatted string.
wxDateTime date;
date.ParseDateTime(format);
tick = date.GetTicks();
return CELL_OK;
}
int cellRtcParseRfc3339()
int cellRtcParseRfc3339(mem64_t tick, u32 datetime_addr)
{
UNIMPLEMENTED_FUNC(cellRtc);
cellRtc.Log("cellRtcParseRfc3339(tick_addr=0x%x, datetime_addr=0x%x)", tick.GetAddr(), datetime_addr);
const wxString& format = Memory.ReadString(datetime_addr);
// Get date from RFC3339 formatted string.
wxDateTime date;
date.ParseDateTime(format);
tick = date.GetTicks();
return CELL_OK;
}
int cellRtcGetTick()
int cellRtcGetTick(u32 clock_addr, mem64_t tick)
{
UNIMPLEMENTED_FUNC(cellRtc);
cellRtc.Log("cellRtcGetTick(clock_addr=0x%x, tick_addr=0x%x)", clock_addr, tick.GetAddr());
CellRtcDateTime *clock = new CellRtcDateTime;
clock->year = Memory.Read16(clock_addr);
clock->month = Memory.Read16(clock_addr + 2);
clock->day = Memory.Read16(clock_addr + 4);
clock->hour = Memory.Read16(clock_addr + 6);
clock->minute = Memory.Read16(clock_addr + 8);
clock->second = Memory.Read16(clock_addr + 10);
clock->microsecond = Memory.Read32(clock_addr + 12);
wxDateTime datetime = wxDateTime::wxDateTime(clock->day, (wxDateTime::Month)clock->month, clock->year, clock->hour, clock->minute, clock->second, (clock->microsecond / 1000));
tick = datetime.GetTicks();
return CELL_OK;
}
int cellRtcSetTick()
int cellRtcSetTick(u32 clock_addr, u32 tick_addr)
{
UNIMPLEMENTED_FUNC(cellRtc);
cellRtc.Log("cellRtcSetTick(clock_addr=0x%x, tick_addr=0x%x)", clock_addr, tick_addr);
CellRtcTick *current_tick = new CellRtcTick;
current_tick->tick = Memory.Read64(tick_addr);
wxDateTime date = wxDateTime::wxDateTime((time_t)current_tick->tick);
CellRtcDateTime *clock = new CellRtcDateTime;
clock->year = date.GetYear(wxDateTime::TZ::UTC);
clock->month = date.GetMonth(wxDateTime::TZ::UTC);
clock->day = date.GetDay(wxDateTime::TZ::UTC);
clock->hour = date.GetHour(wxDateTime::TZ::UTC);
clock->minute = date.GetMinute(wxDateTime::TZ::UTC);
clock->second = date.GetSecond(wxDateTime::TZ::UTC);
clock->microsecond = date.GetMillisecond(wxDateTime::TZ::UTC) * 1000;
Memory.Write16(clock_addr, clock->year);
Memory.Write16(clock_addr + 2, clock->month);
Memory.Write16(clock_addr + 4, clock->day);
Memory.Write16(clock_addr + 6, clock->hour);
Memory.Write16(clock_addr + 8, clock->minute);
Memory.Write16(clock_addr + 10, clock->second);
Memory.Write32(clock_addr + 12, clock->microsecond);
return CELL_OK;
}
int cellRtcTickAddTicks()
int cellRtcTickAddTicks(mem64_t tick, u32 tick_add_addr, long add)
{
UNIMPLEMENTED_FUNC(cellRtc);
cellRtc.Log("cellRtcTickAddTicks(tick_addr=0x%x, tick_add_addr=0x%x, add=%l)", tick.GetAddr(), tick_add_addr, add);
tick = Memory.Read64(tick_add_addr) + add;
return CELL_OK;
}
int cellRtcTickAddMicroseconds()
int cellRtcTickAddMicroseconds(mem64_t tick, u32 tick_add_addr, long add)
{
UNIMPLEMENTED_FUNC(cellRtc);
cellRtc.Log("cellRtcTickAddMicroseconds(tick_addr=0x%x, tick_add_addr=0x%x, add=%l)", tick.GetAddr(), tick_add_addr, add);
wxDateTime date = wxDateTime::wxDateTime((time_t)Memory.Read64(tick_add_addr));
wxTimeSpan microseconds = wxTimeSpan::wxTimeSpan(0, 0, 0, add / 1000);
date.Add(microseconds);
tick = date.GetTicks();
return CELL_OK;
}
int cellRtcTickAddSeconds()
int cellRtcTickAddSeconds(mem64_t tick, u32 tick_add_addr, long add)
{
UNIMPLEMENTED_FUNC(cellRtc);
cellRtc.Log("cellRtcTickAddSeconds(tick_addr=0x%x, tick_add_addr=0x%x, add=%l)", tick.GetAddr(), tick_add_addr, add);
wxDateTime date = wxDateTime::wxDateTime((time_t)Memory.Read64(tick_add_addr));
wxTimeSpan seconds = wxTimeSpan::wxTimeSpan(0, 0, add, 0);
date.Add(seconds);
tick = date.GetTicks();
return CELL_OK;
}
int cellRtcTickAddMinutes()
int cellRtcTickAddMinutes(mem64_t tick, u32 tick_add_addr, long add)
{
UNIMPLEMENTED_FUNC(cellRtc);
cellRtc.Log("cellRtcTickAddMinutes(tick_addr=0x%x, tick_add_addr=0x%x, add=%l)", tick.GetAddr(), tick_add_addr, add);
wxDateTime date = wxDateTime::wxDateTime((time_t)Memory.Read64(tick_add_addr));
wxTimeSpan minutes = wxTimeSpan::wxTimeSpan(0, add, 0, 0);
date.Add(minutes);
tick = date.GetTicks();
return CELL_OK;
}
int cellRtcTickAddHours()
int cellRtcTickAddHours(mem64_t tick, u32 tick_add_addr, int add)
{
UNIMPLEMENTED_FUNC(cellRtc);
cellRtc.Log("cellRtcTickAddHours(tick_addr=0x%x, tick_add_addr=0x%x, add=%l)", tick.GetAddr(), tick_add_addr, add);
wxDateTime date = wxDateTime::wxDateTime((time_t)Memory.Read64(tick_add_addr));
wxTimeSpan hours = wxTimeSpan::wxTimeSpan(add, 0, 0, 0);
date.Add(hours);
tick = date.GetTicks();
return CELL_OK;
}
int cellRtcTickAddDays()
int cellRtcTickAddDays(mem64_t tick, u32 tick_add_addr, int add)
{
UNIMPLEMENTED_FUNC(cellRtc);
cellRtc.Log("cellRtcTickAddDays(tick_addr=0x%x, tick_add_addr=0x%x, add=%l)", tick.GetAddr(), tick_add_addr, add);
wxDateTime date = wxDateTime::wxDateTime((time_t)Memory.Read64(tick_add_addr));
wxDateSpan days = wxDateSpan::wxDateSpan(0, 0, 0, add);
date.Add(days);
tick = date.GetTicks();
return CELL_OK;
}
int cellRtcTickAddWeeks()
int cellRtcTickAddWeeks(mem64_t tick, u32 tick_add_addr, int add)
{
UNIMPLEMENTED_FUNC(cellRtc);
cellRtc.Log("cellRtcTickAddWeeks(tick_addr=0x%x, tick_add_addr=0x%x, add=%l)", tick.GetAddr(), tick_add_addr, add);
wxDateTime date = wxDateTime::wxDateTime((time_t)Memory.Read64(tick_add_addr));
wxDateSpan weeks = wxDateSpan::wxDateSpan(0, 0, add, 0);
date.Add(weeks);
tick = date.GetTicks();
return CELL_OK;
}
int cellRtcTickAddMonths()
int cellRtcTickAddMonths(mem64_t tick, u32 tick_add_addr, int add)
{
UNIMPLEMENTED_FUNC(cellRtc);
cellRtc.Log("cellRtcTickAddMonths(tick_addr=0x%x, tick_add_addr=0x%x, add=%l)", tick.GetAddr(), tick_add_addr, add);
wxDateTime date = wxDateTime::wxDateTime((time_t)Memory.Read64(tick_add_addr));
wxDateSpan months = wxDateSpan::wxDateSpan(0, add, 0, 0);
date.Add(months);
tick = date.GetTicks();
return CELL_OK;
}
int cellRtcTickAddYears()
int cellRtcTickAddYears(mem64_t tick, u32 tick_add_addr, int add)
{
UNIMPLEMENTED_FUNC(cellRtc);
cellRtc.Log("cellRtcTickAddYears(tick_addr=0x%x, tick_add_addr=0x%x, add=%l)", tick.GetAddr(), tick_add_addr, add);
wxDateTime date = wxDateTime::wxDateTime((time_t)Memory.Read64(tick_add_addr));
wxDateSpan years = wxDateSpan::wxDateSpan(add, 0, 0, 0);
date.Add(years);
tick = date.GetTicks();
return CELL_OK;
}
int cellRtcConvertUtcToLocalTime()
int cellRtcConvertUtcToLocalTime(u32 tick_utc_addr, mem64_t tick_local)
{
UNIMPLEMENTED_FUNC(cellRtc);
cellRtc.Log("cellRtcConvertUtcToLocalTime(tick_utc_addr=0x%x, tick_local_addr=0x%x)", tick_utc_addr, tick_local.GetAddr());
wxDateTime time = wxDateTime::wxDateTime((time_t)Memory.Read64(tick_utc_addr));
wxDateTime local_time = time.FromUTC(false);
tick_local = local_time.GetTicks();
return CELL_OK;
}
int cellRtcConvertLocalTimeToUtc()
int cellRtcConvertLocalTimeToUtc(u32 tick_local_addr, mem64_t tick_utc)
{
UNIMPLEMENTED_FUNC(cellRtc);
cellRtc.Log("cellRtcConvertLocalTimeToUtc(tick_local_addr=0x%x, tick_utc_addr=0x%x)", tick_local_addr, tick_utc.GetAddr());
wxDateTime time = wxDateTime::wxDateTime((time_t)Memory.Read64(tick_local_addr));
wxDateTime utc_time = time.ToUTC(false);
tick_utc = utc_time.GetTicks();
return CELL_OK;
}
int cellRtcGetDosTime()
int cellRtcGetDosTime(u32 datetime_addr, mem64_t dos_time)
{
UNIMPLEMENTED_FUNC(cellRtc);
cellRtc.Log("cellRtcGetDosTime(datetime_addr=0x%x, dos_time_addr=0x%x)", datetime_addr, dos_time.GetAddr());
CellRtcDateTime *datetime = new CellRtcDateTime;
datetime->year = Memory.Read16(datetime_addr);
datetime->month = Memory.Read16(datetime_addr + 2);
datetime->day = Memory.Read16(datetime_addr + 4);
datetime->hour = Memory.Read16(datetime_addr + 6);
datetime->minute = Memory.Read16(datetime_addr + 8);
datetime->second = Memory.Read16(datetime_addr + 10);
datetime->microsecond = Memory.Read32(datetime_addr + 12);
// Convert to DOS time.
wxDateTime date_time = wxDateTime::wxDateTime(datetime->day, (wxDateTime::Month)datetime->month, datetime->year, datetime->hour, datetime->minute, datetime->second, (datetime->microsecond / 1000));
dos_time = date_time.GetAsDOS();
return CELL_OK;
}
int cellRtcGetTime_t()
int cellRtcGetTime_t(u32 datetime_addr, mem64_t posix_time)
{
UNIMPLEMENTED_FUNC(cellRtc);
cellRtc.Log("cellRtcGetTime_t(datetime_addr=0x%x, posix_time_addr=0x%x)", datetime_addr, posix_time.GetAddr());
CellRtcDateTime *datetime = new CellRtcDateTime;
datetime->year = Memory.Read16(datetime_addr);
datetime->month = Memory.Read16(datetime_addr + 2);
datetime->day = Memory.Read16(datetime_addr + 4);
datetime->hour = Memory.Read16(datetime_addr + 6);
datetime->minute = Memory.Read16(datetime_addr + 8);
datetime->second = Memory.Read16(datetime_addr + 10);
datetime->microsecond = Memory.Read32(datetime_addr + 12);
// Convert to POSIX time_t.
wxDateTime date_time = wxDateTime::wxDateTime(datetime->day, (wxDateTime::Month)datetime->month, datetime->year, datetime->hour, datetime->minute, datetime->second, (datetime->microsecond / 1000));
posix_time = 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));
return CELL_OK;
}
int cellRtcGetWin32FileTime()
int cellRtcGetWin32FileTime(u32 datetime_addr, mem64_t win32_time)
{
UNIMPLEMENTED_FUNC(cellRtc);
cellRtc.Log("cellRtcGetWin32FileTime(datetime_addr=0x%x, win32_time_addr=0x%x)", datetime_addr, win32_time.GetAddr());
CellRtcDateTime *datetime = new CellRtcDateTime;
datetime->year = Memory.Read16(datetime_addr);
datetime->month = Memory.Read16(datetime_addr + 2);
datetime->day = Memory.Read16(datetime_addr + 4);
datetime->hour = Memory.Read16(datetime_addr + 6);
datetime->minute = Memory.Read16(datetime_addr + 8);
datetime->second = Memory.Read16(datetime_addr + 10);
datetime->microsecond = Memory.Read32(datetime_addr + 12);
// Convert to WIN32 FILETIME.
wxDateTime date_time = wxDateTime::wxDateTime(datetime->day, (wxDateTime::Month)datetime->month, datetime->year, datetime->hour, datetime->minute, datetime->second, (datetime->microsecond / 1000));
win32_time = 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));
return CELL_OK;
}
int cellRtcSetDosTime()
int cellRtcSetDosTime(u32 datetime_addr, u32 dos_time_addr)
{
UNIMPLEMENTED_FUNC(cellRtc);
cellRtc.Log("cellRtcSetDosTime(datetime_addr=0x%x, dos_time_addr=0x%x)", datetime_addr, dos_time_addr);
wxDateTime date_time;
wxDateTime dos_time = date_time.SetFromDOS(Memory.Read32(dos_time_addr));
CellRtcDateTime *datetime = new CellRtcDateTime;
datetime->year = dos_time.GetYear(wxDateTime::TZ::UTC);
datetime->month = dos_time.GetMonth(wxDateTime::TZ::UTC);
datetime->day = dos_time.GetDay(wxDateTime::TZ::UTC);
datetime->hour = dos_time.GetHour(wxDateTime::TZ::UTC);
datetime->minute = dos_time.GetMinute(wxDateTime::TZ::UTC);
datetime->second = dos_time.GetSecond(wxDateTime::TZ::UTC);
datetime->microsecond = dos_time.GetMillisecond(wxDateTime::TZ::UTC) * 1000;
Memory.Write16(datetime_addr, datetime->year);
Memory.Write16(datetime_addr + 2, datetime->month);
Memory.Write16(datetime_addr + 4, datetime->day);
Memory.Write16(datetime_addr + 6, datetime->hour);
Memory.Write16(datetime_addr + 8, datetime->minute);
Memory.Write16(datetime_addr + 10, datetime->second);
Memory.Write32(datetime_addr + 12, datetime->microsecond);
return CELL_OK;
}
int cellRtcSetTime_t()
int cellRtcSetTime_t(u32 datetime_addr, u32 posix_time_addr)
{
UNIMPLEMENTED_FUNC(cellRtc);
cellRtc.Log("cellRtcSetTime_t(datetime_addr=0x%x, posix_time_addr=0x%x)", datetime_addr, posix_time_addr);
wxDateTime date_time = wxDateTime::wxDateTime((time_t)Memory.Read64(posix_time_addr));
CellRtcDateTime *datetime = new CellRtcDateTime;
datetime->year = date_time.GetYear(wxDateTime::TZ::UTC);
datetime->month = date_time.GetMonth(wxDateTime::TZ::UTC);
datetime->day = date_time.GetDay(wxDateTime::TZ::UTC);
datetime->hour = date_time.GetHour(wxDateTime::TZ::UTC);
datetime->minute = date_time.GetMinute(wxDateTime::TZ::UTC);
datetime->second = date_time.GetSecond(wxDateTime::TZ::UTC);
datetime->microsecond = date_time.GetMillisecond(wxDateTime::TZ::UTC) * 1000;
Memory.Write16(datetime_addr, datetime->year);
Memory.Write16(datetime_addr + 2, datetime->month);
Memory.Write16(datetime_addr + 4, datetime->day);
Memory.Write16(datetime_addr + 6, datetime->hour);
Memory.Write16(datetime_addr + 8, datetime->minute);
Memory.Write16(datetime_addr + 10, datetime->second);
Memory.Write32(datetime_addr + 12, datetime->microsecond);
return CELL_OK;
}
int cellRtcSetWin32FileTime()
int cellRtcSetWin32FileTime(u32 datetime_addr, u32 win32_time_addr)
{
UNIMPLEMENTED_FUNC(cellRtc);
cellRtc.Log("cellRtcSetWin32FileTime(datetime_addr=0x%x, win32_time_addr=0x%x)", datetime_addr, win32_time_addr);
wxDateTime date_time = wxDateTime::wxDateTime((time_t)Memory.Read64(win32_time_addr));
CellRtcDateTime *datetime = new CellRtcDateTime;
datetime->year = date_time.GetYear(wxDateTime::TZ::UTC);
datetime->month = date_time.GetMonth(wxDateTime::TZ::UTC);
datetime->day = date_time.GetDay(wxDateTime::TZ::UTC);
datetime->hour = date_time.GetHour(wxDateTime::TZ::UTC);
datetime->minute = date_time.GetMinute(wxDateTime::TZ::UTC);
datetime->second = date_time.GetSecond(wxDateTime::TZ::UTC);
datetime->microsecond = date_time.GetMillisecond(wxDateTime::TZ::UTC) * 1000;
Memory.Write16(datetime_addr, datetime->year);
Memory.Write16(datetime_addr + 2, datetime->month);
Memory.Write16(datetime_addr + 4, datetime->day);
Memory.Write16(datetime_addr + 6, datetime->hour);
Memory.Write16(datetime_addr + 8, datetime->minute);
Memory.Write16(datetime_addr + 10, datetime->second);
Memory.Write32(datetime_addr + 12, datetime->microsecond);
return CELL_OK;
}
int cellRtcIsLeapYear()
int cellRtcIsLeapYear(int year)
{
UNIMPLEMENTED_FUNC(cellRtc);
return CELL_OK;
cellRtc.Log("cellRtcIsLeapYear(year=%d)", year);
wxDateTime datetime;
return datetime.IsLeapYear(year, wxDateTime::Gregorian);
}
int cellRtcGetDaysInMonth()
int cellRtcGetDaysInMonth(int year, int month)
{
UNIMPLEMENTED_FUNC(cellRtc);
return CELL_OK;
cellRtc.Log("cellRtcGetDaysInMonth(year=%d, month=%d)", year, month);
wxDateTime datetime;
return datetime.GetNumberOfDays((wxDateTime::Month) month, year, wxDateTime::Gregorian);
}
int cellRtcGetDayOfWeek()
int cellRtcGetDayOfWeek(int year, int month, int day)
{
UNIMPLEMENTED_FUNC(cellRtc);
return CELL_OK;
cellRtc.Log("cellRtcGetDayOfWeek(year=%d, month=%d, day=%d)", year, month, day);
wxDateTime datetime;
datetime.SetToWeekDay((wxDateTime::WeekDay) day, 1, (wxDateTime::Month) month, year);
return datetime.GetWeekDay();
}
int cellRtcCheckValid()
int cellRtcCheckValid(u32 datetime_addr)
{
UNIMPLEMENTED_FUNC(cellRtc);
return CELL_OK;
cellRtc.Log("cellRtcCheckValid(datetime_addr=0x%x)", datetime_addr);
CellRtcDateTime *datetime = new CellRtcDateTime;
datetime->year = Memory.Read16(datetime_addr);
datetime->month = Memory.Read16(datetime_addr + 2);
datetime->day = Memory.Read16(datetime_addr + 4);
datetime->hour = Memory.Read16(datetime_addr + 6);
datetime->minute = Memory.Read16(datetime_addr + 8);
datetime->second = Memory.Read16(datetime_addr + 10);
datetime->microsecond = Memory.Read32(datetime_addr + 12);
if((datetime->year < 1) || (datetime->year > 9999)) return CELL_RTC_ERROR_INVALID_YEAR;
else if((datetime->month < 1) || (datetime->month > 12)) return CELL_RTC_ERROR_INVALID_MONTH;
else if((datetime->day < 1) || (datetime->day > 31)) return CELL_RTC_ERROR_INVALID_DAY;
else if((datetime->hour < 0) || (datetime->hour > 23)) return CELL_RTC_ERROR_INVALID_HOUR;
else if((datetime->minute < 0) || (datetime->minute > 59)) return CELL_RTC_ERROR_INVALID_MINUTE;
else if((datetime->second < 0) || (datetime->second > 59)) return CELL_RTC_ERROR_INVALID_SECOND;
else if((datetime->microsecond < 0) || (datetime->microsecond > 999999)) return CELL_RTC_ERROR_INVALID_MICROSECOND;
else return CELL_OK;
}
int cellRtcCompareTick()
int cellRtcCompareTick(u32 tick_addr_1, u32 tick_addr_2)
{
UNIMPLEMENTED_FUNC(cellRtc);
return CELL_OK;
cellRtc.Log("cellRtcCompareTick(tick_addr_1=0x%x, tick_addr_2=0x%x)", tick_addr_1, tick_addr_2);
long tick1 = Memory.Read64(tick_addr_1);
long tick2 = Memory.Read64(tick_addr_2);
if(tick1 < tick2) return -1;
else if(tick1 > tick2) return 1;
else return CELL_OK;
}
void cellRtc_init()

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

@ -15,6 +15,125 @@ enum
CELL_SYSMODULE_ERROR_FATAL = 0x800120ff,
};
const char *getModuleName(int id) {
struct Entry {
const char *name;
int id;
};
static const Entry entries[] = {
{"CELL_SYSMODULE_INVALID", 0x0000ffff},
{"CELL_SYSMODULE_NET", 0x00000000},
{"CELL_SYSMODULE_HTTP", 0x00000001},
{"CELL_SYSMODULE_HTTP_UTIL", 0x00000002},
{"CELL_SYSMODULE_SSL", 0x00000003},
{"CELL_SYSMODULE_HTTPS", 0x00000004},
{"CELL_SYSMODULE_VDEC", 0x00000005},
{"CELL_SYSMODULE_ADEC", 0x00000006},
{"CELL_SYSMODULE_DMUX", 0x00000007},
{"CELL_SYSMODULE_VPOST", 0x00000008},
{"CELL_SYSMODULE_RTC", 0x00000009},
{"CELL_SYSMODULE_SPURS", 0x0000000a},
{"CELL_SYSMODULE_OVIS", 0x0000000b},
{"CELL_SYSMODULE_SHEAP", 0x0000000c},
{"CELL_SYSMODULE_SYNC", 0x0000000d},
{"CELL_SYSMODULE_FS", 0x0000000e},
{"CELL_SYSMODULE_JPGDEC", 0x0000000f},
{"CELL_SYSMODULE_GCM_SYS", 0x00000010},
{"CELL_SYSMODULE_GCM", 0x00000010},
{"CELL_SYSMODULE_AUDIO", 0x00000011},
{"CELL_SYSMODULE_PAMF", 0x00000012},
{"CELL_SYSMODULE_ATRAC3PLUS", 0x00000013},
{"CELL_SYSMODULE_NETCTL", 0x00000014},
{"CELL_SYSMODULE_SYSUTIL", 0x00000015},
{"CELL_SYSMODULE_SYSUTIL_NP", 0x00000016},
{"CELL_SYSMODULE_IO", 0x00000017},
{"CELL_SYSMODULE_PNGDEC", 0x00000018},
{"CELL_SYSMODULE_FONT", 0x00000019},
{"CELL_SYSMODULE_FONTFT", 0x0000001a},
{"CELL_SYSMODULE_FREETYPE", 0x0000001b},
{"CELL_SYSMODULE_USBD", 0x0000001c},
{"CELL_SYSMODULE_SAIL", 0x0000001d},
{"CELL_SYSMODULE_L10N", 0x0000001e},
{"CELL_SYSMODULE_RESC", 0x0000001f},
{"CELL_SYSMODULE_DAISY", 0x00000020},
{"CELL_SYSMODULE_KEY2CHAR", 0x00000021},
{"CELL_SYSMODULE_MIC", 0x00000022},
{"CELL_SYSMODULE_CAMERA", 0x00000023},
{"CELL_SYSMODULE_VDEC_MPEG2", 0x00000024},
{"CELL_SYSMODULE_VDEC_AVC", 0x00000025},
{"CELL_SYSMODULE_ADEC_LPCM", 0x00000026},
{"CELL_SYSMODULE_ADEC_AC3", 0x00000027},
{"CELL_SYSMODULE_ADEC_ATX", 0x00000028},
{"CELL_SYSMODULE_ADEC_AT3", 0x00000029},
{"CELL_SYSMODULE_DMUX_PAMF", 0x0000002a},
{"CELL_SYSMODULE_VDEC_AL", 0x0000002b},
{"CELL_SYSMODULE_ADEC_AL", 0x0000002c},
{"CELL_SYSMODULE_DMUX_AL", 0x0000002d},
{"CELL_SYSMODULE_LV2DBG", 0x0000002e},
{"CELL_SYSMODULE_USBPSPCM", 0x00000030},
{"CELL_SYSMODULE_AVCONF_EXT", 0x00000031},
{"CELL_SYSMODULE_SYSUTIL_USERINFO", 0x00000032},
{"CELL_SYSMODULE_SYSUTIL_SAVEDATA", 0x00000033},
{"CELL_SYSMODULE_SUBDISPLAY", 0x00000034},
{"CELL_SYSMODULE_SYSUTIL_REC", 0x00000035},
{"CELL_SYSMODULE_VIDEO_EXPORT", 0x00000036},
{"CELL_SYSMODULE_SYSUTIL_GAME_EXEC", 0x00000037},
{"CELL_SYSMODULE_SYSUTIL_NP2", 0x00000038},
{"CELL_SYSMODULE_SYSUTIL_AP", 0x00000039},
{"CELL_SYSMODULE_SYSUTIL_NP_CLANS", 0x0000003a},
{"CELL_SYSMODULE_SYSUTIL_OSK_EXT", 0x0000003b},
{"CELL_SYSMODULE_VDEC_DIVX", 0x0000003c},
{"CELL_SYSMODULE_JPGENC", 0x0000003d},
{"CELL_SYSMODULE_SYSUTIL_GAME", 0x0000003e},
{"CELL_SYSMODULE_BGDL", 0x0000003f},
{"CELL_SYSMODULE_FREETYPE_TT", 0x00000040},
{"CELL_SYSMODULE_SYSUTIL_VIDEO_UPLOAD", 0x00000041},
{"CELL_SYSMODULE_SYSUTIL_SYSCONF_EXT", 0x00000042},
{"CELL_SYSMODULE_FIBER", 0x00000043},
{"CELL_SYSMODULE_SYSUTIL_NP_COMMERCE2", 0x00000044},
{"CELL_SYSMODULE_SYSUTIL_NP_TUS", 0x00000045},
{"CELL_SYSMODULE_VOICE", 0x00000046},
{"CELL_SYSMODULE_ADEC_CELP8", 0x00000047},
{"CELL_SYSMODULE_CELP8ENC", 0x00000048},
{"CELL_SYSMODULE_SYSUTIL_LICENSEAREA", 0x00000049},
{"CELL_SYSMODULE_SYSUTIL_MUSIC2", 0x0000004a},
{"CELL_SYSMODULE_SYSUTIL_SCREENSHOT", 0x0000004e},
{"CELL_SYSMODULE_SYSUTIL_MUSIC_DECODE", 0x0000004f},
{"CELL_SYSMODULE_SPURS_JQ", 0x00000050},
{"CELL_SYSMODULE_PNGENC", 0x00000052},
{"CELL_SYSMODULE_SYSUTIL_MUSIC_DECODE2", 0x00000053},
{"CELL_SYSMODULE_SYNC2", 0x00000055},
{"CELL_SYSMODULE_SYSUTIL_NP_UTIL", 0x00000056},
{"CELL_SYSMODULE_RUDP", 0x00000057},
{"CELL_SYSMODULE_SYSUTIL_NP_SNS", 0x00000059},
{"CELL_SYSMODULE_GEM", 0x0000005a},
{"CELL_SYSMODULE_CELPENC", 0x0000f00a},
{"CELL_SYSMODULE_GIFDEC", 0x0000f010},
{"CELL_SYSMODULE_ADEC_CELP", 0x0000f019},
{"CELL_SYSMODULE_ADEC_M2BC", 0x0000f01b},
{"CELL_SYSMODULE_ADEC_M4AAC", 0x0000f01d},
{"CELL_SYSMODULE_ADEC_MP3", 0x0000f01e},
{"CELL_SYSMODULE_IMEJP", 0x0000f023},
{"CELL_SYSMODULE_SYSUTIL_MUSIC", 0x0000f028},
{"CELL_SYSMODULE_PHOTO_EXPORT", 0x0000f029},
{"CELL_SYSMODULE_PRINT", 0x0000f02a},
{"CELL_SYSMODULE_PHOTO_IMPORT", 0x0000f02b},
{"CELL_SYSMODULE_MUSIC_EXPORT", 0x0000f02c},
{"CELL_SYSMODULE_PHOTO_DECODE", 0x0000f02e},
{"CELL_SYSMODULE_SYSUTIL_SEARCH", 0x0000f02f},
{"CELL_SYSMODULE_SYSUTIL_AVCHAT2", 0x0000f030},
{"CELL_SYSMODULE_SAIL_REC", 0x0000f034},
{"CELL_SYSMODULE_SYSUTIL_NP_TROPHY", 0x0000f035},
{"CELL_SYSMODULE_LIBATRAC3MULTI", 0x0000f054},
};
for (int i = 0; i < 103; ++i) {
if (entries[i].id == id) {
return entries[i].name;
}
}
return 0;
}
int cellSysmoduleInitialize()
{
cellSysmodule.Log("cellSysmoduleInitialize()");
@ -35,7 +154,7 @@ int cellSysmoduleSetMemcontainer(u32 ct_id)
int cellSysmoduleLoadModule(u16 id)
{
cellSysmodule.Warning("cellSysmoduleLoadModule(id=0x%04x)", id);
cellSysmodule.Warning("cellSysmoduleLoadModule(%s)", getModuleName(id));
Module* m = GetModuleById(id);
if(!m)
@ -54,7 +173,7 @@ int cellSysmoduleLoadModule(u16 id)
int cellSysmoduleUnloadModule(u16 id)
{
cellSysmodule.Warning("cellSysmoduleUnloadModule(id=0x%04x)", id);
cellSysmodule.Warning("cellSysmoduleUnloadModule(%s)", getModuleName(id));
Module* m = GetModuleById(id);
if(!m)
@ -73,7 +192,7 @@ int cellSysmoduleUnloadModule(u16 id)
int cellSysmoduleIsLoaded(u16 id)
{
cellSysmodule.Warning("cellSysmoduleIsLoaded(id=0x%04x)", id);
cellSysmodule.Warning("cellSysmoduleIsLoaded(%s)", getModuleName(id));
Module* m = GetModuleById(id);
if(!m)

3
rpcs3/rpcs3.vcxproj
View File

@ -1,4 +1,4 @@
<?xml version="1.0" encoding="utf-8"?>
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup Label="ProjectConfigurations">
<ProjectConfiguration Include="Debug|Win32">
@ -267,6 +267,7 @@
<ClCompile Include="Emu\SysCalls\Modules\cellJpgDec.cpp" />
<ClCompile Include="Emu\SysCalls\Modules\cellPngDec.cpp" />
<ClCompile Include="Emu\SysCalls\Modules\cellResc.cpp" />
<ClCompile Include="Emu\SysCalls\Modules\cellRtc.cpp" />
<ClCompile Include="Emu\SysCalls\Modules\cellSysmodule.cpp" />
<ClCompile Include="Emu\SysCalls\Modules\cellSysutil.cpp" />
<ClCompile Include="Emu\SysCalls\Modules\sysPrxForUser.cpp" />

5
rpcs3/rpcs3.vcxproj.filters
View File

@ -1,4 +1,4 @@
<?xml version="1.0" encoding="utf-8"?>
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup>
<Filter Include="Emu">
@ -340,6 +340,9 @@
<ClCompile Include="Emu\SysCalls\Modules\cellAudio.cpp">
<Filter>Emu\SysCalls\Modules</Filter>
</ClCompile>
<ClCompile Include="Emu\SysCalls\Modules\cellRtc.cpp">
<Filter>Emu\SysCalls\Modules</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
<ResourceCompile Include="rpcs3.rc" />

1
rpcs3/stdafx.h
View File

@ -13,6 +13,7 @@
#include <wx/dir.h>
#include <wx/generic/progdlgg.h>
#include <wx/spinctrl.h>
#include <wx/datetime.h>
#include <wx/filepicker.h>
#include <wx/wxprec.h>