archive/rpcs3
1
0
Fork 0
mirror of https://github.com/RPCS3/rpcs3.git synced 2025-07-06 23:11:25 +12:00
Code Issues Projects Releases Packages Wiki Activity Actions

cellPngDec fixes and some rewritings

Browse source 
* This commit solves the cellPngDec GetMemFromAddr(0x0) error when
loading PNGs from files.
* cellVideoOutGetResolution, cellRtc* syscalls rewritten to use the use
the mem*_t data types.
* Replaced int/uint with s32/u32 in some syscall arguments and structs.
This commit is contained in:
Alexandro Sánchez Bach 2014-04-02 19:53:44 +02:00
parent c294f5318f
commit 81cdaa883a
12 changed files with 344 additions and 334 deletions
Download patch file Download diff file Expand all files Collapse all files

4
rpcs3/Emu/GS/sysutil_video.h
View file

@ -165,8 +165,8 @@ struct CellVideoOutDisplayMode
struct CellVideoOutResolution struct CellVideoOutResolution
{ {
u16 width; be_t<u16> width;
u16 height; be_t<u16> height;
}; };
struct CellVideoOutDeviceInfo struct CellVideoOutDeviceInfo

2
rpcs3/Emu/SysCalls/Modules/cellGcmSys.cpp
View file

@ -101,7 +101,7 @@ u32 cellGcmGetDefaultSegmentWordSize()
return 0x100; return 0x100;
} }
int cellGcmInitDefaultFifoMode(int mode) int cellGcmInitDefaultFifoMode(s32 mode)
{ {
cellGcmSys.Warning("cellGcmInitDefaultFifoMode(mode=%d)", mode); cellGcmSys.Warning("cellGcmInitDefaultFifoMode(mode=%d)", mode);
return CELL_OK; return CELL_OK;

2
rpcs3/Emu/SysCalls/Modules/cellPamf.cpp
View file

@ -524,7 +524,7 @@ int cellPamfEpIteratorGetEp(mem_ptr_t<CellPamfEpIterator> pIt, mem_ptr_t<CellPam
return CELL_OK; return CELL_OK;
} }
int cellPamfEpIteratorMove(mem_ptr_t<CellPamfEpIterator> pIt, int steps, mem_ptr_t<CellPamfEp> pEp) 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: //TODO:

10
rpcs3/Emu/SysCalls/Modules/cellPngDec.cpp
View file

@ -38,7 +38,7 @@ int cellPngDecOpen(u32 mainHandle, mem32_t subHandle, mem_ptr_t<CellPngDecSrc> s
case const_se_t<u32, CELL_PNGDEC_FILE>::value: case const_se_t<u32, CELL_PNGDEC_FILE>::value:
// Get file descriptor // Get file descriptor
MemoryAllocator<be_t<u32>> fd; MemoryAllocator<be_t<u32>> fd;
int ret = cellFsOpen(src->fileName, 0, fd, NULL, 0); int ret = cellFsOpen(src->fileName_addr, 0, fd.GetAddr(), NULL, 0);
current_subHandle->fd = fd->ToLE(); current_subHandle->fd = fd->ToLE();
if(ret != CELL_OK) return CELL_PNGDEC_ERROR_OPEN_FILE; if(ret != CELL_OK) return CELL_PNGDEC_ERROR_OPEN_FILE;
@ -94,8 +94,8 @@ int cellPngDecReadHeader(u32 mainHandle, u32 subHandle, mem_ptr_t<CellPngDecInfo
Memory.Copy(buffer.GetAddr(), subHandle_data->src.streamPtr.ToLE(), buffer.GetSize()); Memory.Copy(buffer.GetAddr(), subHandle_data->src.streamPtr.ToLE(), buffer.GetSize());
break; break;
case CELL_PNGDEC_FILE: case CELL_PNGDEC_FILE:
cellFsLseek(fd, 0, CELL_SEEK_SET, pos); cellFsLseek(fd, 0, CELL_SEEK_SET, pos.GetAddr());
cellFsRead(fd, buffer.GetAddr(), buffer.GetSize(), nread); cellFsRead(fd, buffer.GetAddr(), buffer.GetSize(), nread.GetAddr());
break; break;
} }
@ -148,8 +148,8 @@ int cellPngDecDecodeData(u32 mainHandle, u32 subHandle, mem8_ptr_t data, const m
Memory.Copy(png.GetAddr(), subHandle_data->src.streamPtr.ToLE(), png.GetSize()); Memory.Copy(png.GetAddr(), subHandle_data->src.streamPtr.ToLE(), png.GetSize());
break; break;
case CELL_PNGDEC_FILE: case CELL_PNGDEC_FILE:
cellFsLseek(fd, 0, CELL_SEEK_SET, pos); cellFsLseek(fd, 0, CELL_SEEK_SET, pos.GetAddr());
cellFsRead(fd, png.GetAddr(), png.GetSize(), nread); cellFsRead(fd, png.GetAddr(), png.GetSize(), nread.GetAddr());
break; break;
} }

20
rpcs3/Emu/SysCalls/Modules/cellPngDec.h
View file

@ -37,6 +37,19 @@ enum CellPngDecStreamSrcSel
CELL_PNGDEC_BUFFER = 1, CELL_PNGDEC_BUFFER = 1,
}; };
enum CellPngDecInterlaceMode
{
CELL_PNGDEC_NO_INTERLACE = 0,
CELL_PNGDEC_ADAM7_INTERLACE = 1,
};
enum CellPngDecOutputMode
{
CELL_PNGDEC_TOP_TO_BOTTOM = 0,
CELL_PNGDEC_BOTTOM_TO_TOP = 1,
};
// Structs
struct CellPngDecDataOutInfo struct CellPngDecDataOutInfo
{ {
be_t<u32> chunkInformation; be_t<u32> chunkInformation;
@ -64,8 +77,8 @@ struct CellPngDecInfo
struct CellPngDecSrc struct CellPngDecSrc
{ {
be_t<u32> srcSelect; // CellPngDecStreamSrcSel be_t<u32> srcSelect; // CellPngDecStreamSrcSel
be_t<u32> fileName; // const char* be_t<u32> fileName_addr; // const char*
be_t<u64> fileOffset; // int64_t be_t<s64> fileOffset;
be_t<u32> fileSize; be_t<u32> fileSize;
be_t<u32> streamPtr; be_t<u32> streamPtr;
be_t<u32> streamSize; be_t<u32> streamSize;
@ -95,7 +108,8 @@ struct CellPngDecOutParam
be_t<u32> useMemorySpace; be_t<u32> useMemorySpace;
}; };
struct CellPngDecSubHandle //Custom struct //Custom structs
struct CellPngDecSubHandle
{ {
u32 fd; u32 fd;
u64 fileSize; u64 fileSize;

516
rpcs3/Emu/SysCalls/Modules/cellRtc.cpp
View file

@ -20,460 +20,468 @@ u64 convertToWin32FILETIME(u16 seconds, u16 minutes, u16 hours, u16 days, int ye
return win32filetime; return win32filetime;
} }
int cellRtcGetCurrentTick(mem64_t tick) int cellRtcGetCurrentTick(mem_ptr_t<CellRtcTick> pTick)
{ {
cellRtc.Log("cellRtcGetCurrentTick(tick_addr=0x%x)", tick.GetAddr()); cellRtc.Log("cellRtcGetCurrentTick(pTick=0x%x)", pTick.GetAddr());
if (!pTick.IsGood())
return CELL_RTC_ERROR_INVALID_POINTER;
wxDateTime unow = wxDateTime::UNow(); wxDateTime unow = wxDateTime::UNow();
tick = unow.GetTicks(); pTick->tick = unow.GetTicks();
return CELL_OK; return CELL_OK;
} }
int cellRtcGetCurrentClock(u32 clock_addr, int time_zone) int cellRtcGetCurrentClock(mem_ptr_t<CellRtcDateTime> pClock, s32 iTimeZone)
{ {
cellRtc.Log("cellRtcGetCurrentClock(clock_addr=0x%x, time_zone=%d)", clock_addr, time_zone); 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(); wxDateTime unow = wxDateTime::UNow();
// Add time_zone as offset in minutes. // Add time_zone as offset in minutes.
wxTimeSpan tz = wxTimeSpan::wxTimeSpan(0, (long) time_zone, 0, 0); wxTimeSpan tz = wxTimeSpan::wxTimeSpan(0, (long) iTimeZone, 0, 0);
unow.Add(tz); unow.Add(tz);
Memory.Write16(clock_addr, unow.GetYear(wxDateTime::TZ::UTC)); pClock->year = unow.GetYear(wxDateTime::TZ::UTC);
Memory.Write16(clock_addr + 2, unow.GetMonth(wxDateTime::TZ::UTC)); pClock->month = unow.GetMonth(wxDateTime::TZ::UTC);
Memory.Write16(clock_addr + 4, unow.GetDay(wxDateTime::TZ::UTC)); pClock->day = unow.GetDay(wxDateTime::TZ::UTC);
Memory.Write16(clock_addr + 6, unow.GetHour(wxDateTime::TZ::UTC)); pClock->hour = unow.GetHour(wxDateTime::TZ::UTC);
Memory.Write16(clock_addr + 8, unow.GetMinute(wxDateTime::TZ::UTC)); pClock->minute = unow.GetMinute(wxDateTime::TZ::UTC);
Memory.Write16(clock_addr + 10, unow.GetSecond(wxDateTime::TZ::UTC)); pClock->second = unow.GetSecond(wxDateTime::TZ::UTC);
Memory.Write32(clock_addr + 12, unow.GetMillisecond(wxDateTime::TZ::UTC) * 1000); pClock->microsecond = unow.GetMillisecond(wxDateTime::TZ::UTC) * 1000;
return CELL_OK; return CELL_OK;
} }
int cellRtcGetCurrentClockLocalTime(u32 clock_addr) int cellRtcGetCurrentClockLocalTime(mem_ptr_t<CellRtcDateTime> pClock)
{ {
cellRtc.Log("cellRtcGetCurrentClockLocalTime(clock_addr=0x%x)", clock_addr); cellRtc.Log("cellRtcGetCurrentClockLocalTime(pClock=0x%x)", pClock.GetAddr());
if (!pClock.IsGood())
return CELL_RTC_ERROR_INVALID_POINTER;
wxDateTime unow = wxDateTime::UNow(); wxDateTime unow = wxDateTime::UNow();
Memory.Write16(clock_addr, unow.GetYear(wxDateTime::TZ::Local)); pClock->year = unow.GetYear(wxDateTime::TZ::Local);
Memory.Write16(clock_addr + 2, unow.GetMonth(wxDateTime::TZ::Local)); pClock->month = unow.GetMonth(wxDateTime::TZ::Local);
Memory.Write16(clock_addr + 4, unow.GetDay(wxDateTime::TZ::Local)); pClock->day = unow.GetDay(wxDateTime::TZ::Local);
Memory.Write16(clock_addr + 6, unow.GetHour(wxDateTime::TZ::Local)); pClock->hour = unow.GetHour(wxDateTime::TZ::Local);
Memory.Write16(clock_addr + 8, unow.GetMinute(wxDateTime::TZ::Local)); pClock->minute = unow.GetMinute(wxDateTime::TZ::Local);
Memory.Write16(clock_addr + 10, unow.GetSecond(wxDateTime::TZ::Local)); pClock->second = unow.GetSecond(wxDateTime::TZ::Local);
Memory.Write32(clock_addr + 12, unow.GetMillisecond(wxDateTime::TZ::Local) * 1000); pClock->microsecond = unow.GetMillisecond(wxDateTime::TZ::Local) * 1000;
return CELL_OK; return CELL_OK;
} }
int cellRtcFormatRfc2822(u32 rfc_addr, u32 tick_addr, int time_zone) int cellRtcFormatRfc2822(u32 pszDateTime_addr, mem_ptr_t<CellRtcTick> pUtc, s32 iTimeZone)
{ {
cellRtc.Log("cellRtcFormatRfc2822(rfc_addr=0x%x, tick_addr=0x%x, time_zone=%d)", rfc_addr, tick_addr, time_zone); cellRtc.Log("cellRtcFormatRfc2822(pszDateTime_addr=0x%x, pUtc=0x%x, time_zone=%d)", pszDateTime_addr, pUtc.GetAddr(), iTimeZone);
CellRtcTick current_tick;
current_tick.tick = Memory.Read64(tick_addr); if (!pUtc.IsGood() || !Memory.IsGoodAddr(pszDateTime_addr))
return CELL_RTC_ERROR_INVALID_POINTER;
// Add time_zone as offset in minutes. // Add time_zone as offset in minutes.
wxTimeSpan tz = wxTimeSpan::wxTimeSpan(0, (long) time_zone, 0, 0); wxTimeSpan tz = wxTimeSpan::wxTimeSpan(0, (long) iTimeZone, 0, 0);
// Get date from ticks + tz. // Get date from ticks + tz.
wxDateTime date = wxDateTime::wxDateTime((time_t)current_tick.tick); wxDateTime date = wxDateTime::wxDateTime((time_t)pUtc->tick);
date.Add(tz); date.Add(tz);
// Format date string in RFC2822 format (e.g.: Mon, 01 Jan 1990 12:00:00 +0000). // 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 = fmt::ToUTF8(date.Format("%a, %d %b %Y %T %z", wxDateTime::TZ::UTC));
Memory.WriteString(rfc_addr, str); Memory.WriteString(pszDateTime_addr, str);
return CELL_OK; return CELL_OK;
} }
int cellRtcFormatRfc2822LocalTime(u32 rfc_addr, u32 tick_addr) int cellRtcFormatRfc2822LocalTime(u32 pszDateTime_addr, mem_ptr_t<CellRtcTick> pUtc)
{ {
cellRtc.Log("cellRtcFormatRfc2822LocalTime(rfc_addr=0x%x, tick_addr=0x%x)", rfc_addr, tick_addr); cellRtc.Log("cellRtcFormatRfc2822LocalTime(pszDateTime_addr=0x%x, pUtc=0x%x)", pszDateTime_addr, pUtc.GetAddr());
CellRtcTick current_tick;
current_tick.tick = Memory.Read64(tick_addr); if (!pUtc.IsGood() || !Memory.IsGoodAddr(pszDateTime_addr))
return CELL_RTC_ERROR_INVALID_POINTER;
// Get date from ticks. // Get date from ticks.
wxDateTime date = wxDateTime::wxDateTime((time_t)current_tick.tick); wxDateTime date = wxDateTime::wxDateTime((time_t)pUtc->tick);
// Format date string in RFC2822 format (e.g.: Mon, 01 Jan 1990 12:00:00 +0000). // 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 = fmt::ToUTF8(date.Format("%a, %d %b %Y %T %z", wxDateTime::TZ::Local));
Memory.WriteString(rfc_addr, str); Memory.WriteString(pszDateTime_addr, str);
return CELL_OK; return CELL_OK;
} }
int cellRtcFormatRfc3339(u32 rfc_addr, u32 tick_addr, int time_zone) int cellRtcFormatRfc3339(u32 pszDateTime_addr, mem_ptr_t<CellRtcTick> pUtc, s32 iTimeZone)
{ {
cellRtc.Log("cellRtcFormatRfc3339(rfc_addr=0x%x, tick_addr=0x%x, time_zone=%d)", rfc_addr, tick_addr, time_zone); cellRtc.Log("cellRtcFormatRfc3339(pszDateTime_addr=0x%x, pUtc=0x%x, iTimeZone=%d)", pszDateTime_addr, pUtc.GetAddr(), iTimeZone);
CellRtcTick current_tick;
current_tick.tick = Memory.Read64(tick_addr); if (!pUtc.IsGood() || !Memory.IsGoodAddr(pszDateTime_addr))
return CELL_RTC_ERROR_INVALID_POINTER;
// Add time_zone as offset in minutes. // Add time_zone as offset in minutes.
wxTimeSpan tz = wxTimeSpan::wxTimeSpan(0, (long) time_zone, 0, 0); wxTimeSpan tz = wxTimeSpan::wxTimeSpan(0, (long) iTimeZone, 0, 0);
// Get date from ticks + tz. // Get date from ticks + tz.
wxDateTime date = wxDateTime::wxDateTime((time_t)current_tick.tick); wxDateTime date = wxDateTime::wxDateTime((time_t)pUtc->tick);
date.Add(tz); date.Add(tz);
// Format date string in RFC3339 format (e.g.: 1990-01-01T12:00:00.00Z). // 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 = fmt::ToUTF8(date.Format("%FT%T.%zZ", wxDateTime::TZ::UTC));
Memory.WriteString(rfc_addr, str); Memory.WriteString(pszDateTime_addr, str);
return CELL_OK; return CELL_OK;
} }
int cellRtcFormatRfc3339LocalTime(u32 rfc_addr, u32 tick_addr) int cellRtcFormatRfc3339LocalTime(u32 pszDateTime_addr, mem_ptr_t<CellRtcTick> pUtc)
{ {
cellRtc.Log("cellRtcFormatRfc3339LocalTime(rfc_addr=0x%x, tick_addr=0x%x)", rfc_addr, tick_addr); cellRtc.Log("cellRtcFormatRfc3339LocalTime(pszDateTime_addr=0x%x, pUtc=0x%x)", pszDateTime_addr, pUtc.GetAddr());
CellRtcTick current_tick;
current_tick.tick = Memory.Read64(tick_addr); if (!pUtc.IsGood() || !Memory.IsGoodAddr(pszDateTime_addr))
return CELL_RTC_ERROR_INVALID_POINTER;
// Get date from ticks. // Get date from ticks.
wxDateTime date = wxDateTime::wxDateTime((time_t)current_tick.tick); wxDateTime date = wxDateTime::wxDateTime((time_t) pUtc->tick);
// Format date string in RFC3339 format (e.g.: 1990-01-01T12:00:00.00Z). // 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 = fmt::ToUTF8(date.Format("%FT%T.%zZ", wxDateTime::TZ::Local));
Memory.WriteString(rfc_addr, str); Memory.WriteString(pszDateTime_addr, str);
return CELL_OK; return CELL_OK;
} }
int cellRtcParseDateTime(mem64_t tick, u32 datetime_addr) int cellRtcParseDateTime(mem_ptr_t<CellRtcTick> pUtc, u32 pszDateTime_addr)
{ {
cellRtc.Log("cellRtcParseDateTime(tick_addr=0x%x, datetime_addr=0x%x)", tick.GetAddr(), datetime_addr); cellRtc.Log("cellRtcParseDateTime(pUtc=0x%x, pszDateTime_addr=0x%x)", pUtc.GetAddr(), pszDateTime_addr);
const std::string& format = Memory.ReadString(datetime_addr); if (!pUtc.IsGood() || !Memory.IsGoodAddr(pszDateTime_addr))
return CELL_RTC_ERROR_INVALID_POINTER;
// Get date from formatted string. // Get date from formatted string.
wxDateTime date; wxDateTime date;
const std::string& format = Memory.ReadString(pszDateTime_addr);
date.ParseDateTime(fmt::FromUTF8(format)); date.ParseDateTime(fmt::FromUTF8(format));
tick = date.GetTicks(); pUtc->tick = date.GetTicks();
return CELL_OK; return CELL_OK;
} }
int cellRtcParseRfc3339(mem64_t tick, u32 datetime_addr) int cellRtcParseRfc3339(mem_ptr_t<CellRtcTick> pUtc, u32 pszDateTime_addr)
{ {
cellRtc.Log("cellRtcParseRfc3339(tick_addr=0x%x, datetime_addr=0x%x)", tick.GetAddr(), datetime_addr); cellRtc.Log("cellRtcParseRfc3339(pUtc=0x%x, pszDateTime_addr=0x%x)", pUtc.GetAddr(), pszDateTime_addr);
const std::string& format = Memory.ReadString(datetime_addr); if (!pUtc.IsGood() || !Memory.IsGoodAddr(pszDateTime_addr))
return CELL_RTC_ERROR_INVALID_POINTER;
// Get date from RFC3339 formatted string. // Get date from RFC3339 formatted string.
wxDateTime date; wxDateTime date;
const std::string& format = Memory.ReadString(pszDateTime_addr);
date.ParseDateTime(fmt::FromUTF8(format)); date.ParseDateTime(fmt::FromUTF8(format));
tick = date.GetTicks(); pUtc->tick = date.GetTicks();
return CELL_OK; return CELL_OK;
} }
int cellRtcGetTick(u32 clock_addr, mem64_t tick) int cellRtcGetTick(mem_ptr_t<CellRtcDateTime> pTime, mem_ptr_t<CellRtcTick> pTick)
{ {
cellRtc.Log("cellRtcGetTick(clock_addr=0x%x, tick_addr=0x%x)", clock_addr, tick.GetAddr()); cellRtc.Log("cellRtcGetTick(pTime=0x%x, pTick=0x%x)", pTime.GetAddr(), pTick.GetAddr());
CellRtcDateTime clock; if (!pTime.IsGood() || !pTime.IsGood())
clock.year = Memory.Read16(clock_addr); return CELL_RTC_ERROR_INVALID_POINTER;
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)); wxDateTime datetime = wxDateTime::wxDateTime(pTime->day, (wxDateTime::Month)pTime->month.ToLE(), pTime->year, pTime->hour, pTime->minute, pTime->second, (pTime->microsecond / 1000));
tick = datetime.GetTicks(); pTick->tick = datetime.GetTicks();
return CELL_OK; return CELL_OK;
} }
int cellRtcSetTick(u32 clock_addr, u32 tick_addr) int cellRtcSetTick(mem_ptr_t<CellRtcDateTime> pTime, mem_ptr_t<CellRtcTick> pTick)
{ {
cellRtc.Log("cellRtcSetTick(clock_addr=0x%x, tick_addr=0x%x)", clock_addr, tick_addr); cellRtc.Log("cellRtcSetTick(pTime=0x%x, pTick=0x%x)", pTime.GetAddr(), pTick.GetAddr());
CellRtcTick current_tick;
current_tick.tick = Memory.Read64(tick_addr);
wxDateTime date = wxDateTime::wxDateTime((time_t)current_tick.tick); if (!pTime.IsGood() || !pTime.IsGood())
return CELL_RTC_ERROR_INVALID_POINTER;
CellRtcDateTime clock; wxDateTime date = wxDateTime::wxDateTime((time_t)pTick->tick);
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); pTime->year = date.GetYear(wxDateTime::TZ::UTC);
Memory.Write16(clock_addr + 2, clock.month); pTime->month = date.GetMonth(wxDateTime::TZ::UTC);
Memory.Write16(clock_addr + 4, clock.day); pTime->day = date.GetDay(wxDateTime::TZ::UTC);
Memory.Write16(clock_addr + 6, clock.hour); pTime->hour = date.GetHour(wxDateTime::TZ::UTC);
Memory.Write16(clock_addr + 8, clock.minute); pTime->minute = date.GetMinute(wxDateTime::TZ::UTC);
Memory.Write16(clock_addr + 10, clock.second); pTime->second = date.GetSecond(wxDateTime::TZ::UTC);
Memory.Write32(clock_addr + 12, clock.microsecond); pTime->microsecond = date.GetMillisecond(wxDateTime::TZ::UTC) * 1000;
return CELL_OK; return CELL_OK;
} }
int cellRtcTickAddTicks(mem64_t tick, u32 tick_add_addr, long add) int cellRtcTickAddTicks(mem_ptr_t<CellRtcTick> pTick0, mem_ptr_t<CellRtcTick> pTick1, s64 lAdd)
{ {
cellRtc.Log("cellRtcTickAddTicks(tick_addr=0x%x, tick_add_addr=0x%x, add=%l)", tick.GetAddr(), tick_add_addr, add); cellRtc.Log("cellRtcTickAddTicks(pTick0=0x%x, pTick1=0x%x, lAdd=%lld)", pTick0.GetAddr(), pTick1.GetAddr(), lAdd);
tick = Memory.Read64(tick_add_addr) + add;
if (!pTick0.IsGood() || !pTick1.IsGood())
return CELL_RTC_ERROR_INVALID_POINTER;
pTick0->tick = pTick1->tick + lAdd;
return CELL_OK; return CELL_OK;
} }
int cellRtcTickAddMicroseconds(mem64_t tick, u32 tick_add_addr, long add) int cellRtcTickAddMicroseconds(mem_ptr_t<CellRtcTick> pTick0, mem_ptr_t<CellRtcTick> pTick1, s64 lAdd)
{ {
cellRtc.Log("cellRtcTickAddMicroseconds(tick_addr=0x%x, tick_add_addr=0x%x, add=%l)", tick.GetAddr(), tick_add_addr, add); cellRtc.Log("cellRtcTickAddMicroseconds(pTick0=0x%x, pTick1=0x%x, lAdd=%lld)", pTick0.GetAddr(), pTick1.GetAddr(), lAdd);
wxDateTime date = wxDateTime::wxDateTime((time_t)Memory.Read64(tick_add_addr)); if (!pTick0.IsGood() || !pTick1.IsGood())
wxTimeSpan microseconds = wxTimeSpan::wxTimeSpan(0, 0, 0, add / 1000); return CELL_RTC_ERROR_INVALID_POINTER;
wxDateTime date = wxDateTime::wxDateTime((time_t)pTick1->tick);
wxTimeSpan microseconds = wxTimeSpan::wxTimeSpan(0, 0, 0, lAdd / 1000);
date.Add(microseconds); date.Add(microseconds);
tick = date.GetTicks(); pTick0->tick = date.GetTicks();
return CELL_OK; return CELL_OK;
} }
int cellRtcTickAddSeconds(mem64_t tick, u32 tick_add_addr, long add) int cellRtcTickAddSeconds(mem_ptr_t<CellRtcTick> pTick0, mem_ptr_t<CellRtcTick> pTick1, s64 lAdd)
{ {
cellRtc.Log("cellRtcTickAddSeconds(tick_addr=0x%x, tick_add_addr=0x%x, add=%l)", tick.GetAddr(), tick_add_addr, add); cellRtc.Log("cellRtcTickAddSeconds(pTick0=0x%x, pTick1=0x%x, lAdd=%lld)", pTick0.GetAddr(), pTick1.GetAddr(), lAdd);
wxDateTime date = wxDateTime::wxDateTime((time_t)Memory.Read64(tick_add_addr)); if (!pTick0.IsGood() || !pTick1.IsGood())
wxTimeSpan seconds = wxTimeSpan::wxTimeSpan(0, 0, add, 0); return CELL_RTC_ERROR_INVALID_POINTER;
wxDateTime date = wxDateTime::wxDateTime((time_t)pTick1->tick);
wxTimeSpan seconds = wxTimeSpan::wxTimeSpan(0, 0, lAdd, 0);
date.Add(seconds); date.Add(seconds);
tick = date.GetTicks(); pTick0->tick = date.GetTicks();
return CELL_OK; return CELL_OK;
} }
int cellRtcTickAddMinutes(mem64_t tick, u32 tick_add_addr, long add) int cellRtcTickAddMinutes(mem_ptr_t<CellRtcTick> pTick0, mem_ptr_t<CellRtcTick> pTick1, s64 lAdd)
{ {
cellRtc.Log("cellRtcTickAddMinutes(tick_addr=0x%x, tick_add_addr=0x%x, add=%l)", tick.GetAddr(), tick_add_addr, add); cellRtc.Log("cellRtcTickAddMinutes(pTick0=0x%x, pTick1=0x%x, lAdd=%lld)", pTick0.GetAddr(), pTick1.GetAddr(), lAdd);
wxDateTime date = wxDateTime::wxDateTime((time_t)Memory.Read64(tick_add_addr)); if (!pTick0.IsGood() || !pTick1.IsGood())
wxTimeSpan minutes = wxTimeSpan::wxTimeSpan(0, add, 0, 0); return CELL_RTC_ERROR_INVALID_POINTER;
wxDateTime date = wxDateTime::wxDateTime((time_t)pTick1->tick);
wxTimeSpan minutes = wxTimeSpan::wxTimeSpan(0, lAdd, 0, 0);
date.Add(minutes); date.Add(minutes);
tick = date.GetTicks(); pTick0->tick = date.GetTicks();
return CELL_OK; return CELL_OK;
} }
int cellRtcTickAddHours(mem64_t tick, u32 tick_add_addr, int add) int cellRtcTickAddHours(mem_ptr_t<CellRtcTick> pTick0, mem_ptr_t<CellRtcTick> pTick1, s32 iAdd)
{ {
cellRtc.Log("cellRtcTickAddHours(tick_addr=0x%x, tick_add_addr=0x%x, add=%l)", tick.GetAddr(), tick_add_addr, add); cellRtc.Log("cellRtcTickAddHours(pTick0=0x%x, pTick1=0x%x, iAdd=%d)", pTick0.GetAddr(), pTick1.GetAddr(), iAdd);
wxDateTime date = wxDateTime::wxDateTime((time_t)Memory.Read64(tick_add_addr)); if (!pTick0.IsGood() || !pTick1.IsGood())
wxTimeSpan hours = wxTimeSpan::wxTimeSpan(add, 0, 0, 0); return CELL_RTC_ERROR_INVALID_POINTER;
wxDateTime date = wxDateTime::wxDateTime((time_t)pTick1->tick);
wxTimeSpan hours = wxTimeSpan::wxTimeSpan(iAdd, 0, 0, 0);
date.Add(hours); date.Add(hours);
tick = date.GetTicks(); pTick0->tick = date.GetTicks();
return CELL_OK; return CELL_OK;
} }
int cellRtcTickAddDays(mem64_t tick, u32 tick_add_addr, int add) int cellRtcTickAddDays(mem_ptr_t<CellRtcTick> pTick0, mem_ptr_t<CellRtcTick> pTick1, s32 iAdd)
{ {
cellRtc.Log("cellRtcTickAddDays(tick_addr=0x%x, tick_add_addr=0x%x, add=%l)", tick.GetAddr(), tick_add_addr, add); cellRtc.Log("cellRtcTickAddDays(pTick0=0x%x, pTick1=0x%x, iAdd=%d)", pTick0.GetAddr(), pTick1.GetAddr(), iAdd);
wxDateTime date = wxDateTime::wxDateTime((time_t)Memory.Read64(tick_add_addr)); if (!pTick0.IsGood() || !pTick1.IsGood())
wxDateSpan days = wxDateSpan::wxDateSpan(0, 0, 0, add); return CELL_RTC_ERROR_INVALID_POINTER;
wxDateTime date = wxDateTime::wxDateTime((time_t)pTick1->tick);
wxDateSpan days = wxDateSpan::wxDateSpan(0, 0, 0, iAdd);
date.Add(days); date.Add(days);
tick = date.GetTicks(); pTick0->tick = date.GetTicks();
return CELL_OK; return CELL_OK;
} }
int cellRtcTickAddWeeks(mem64_t tick, u32 tick_add_addr, int add) int cellRtcTickAddWeeks(mem_ptr_t<CellRtcTick> pTick0, mem_ptr_t<CellRtcTick> pTick1, s32 iAdd)
{ {
cellRtc.Log("cellRtcTickAddWeeks(tick_addr=0x%x, tick_add_addr=0x%x, add=%l)", tick.GetAddr(), tick_add_addr, add); cellRtc.Log("cellRtcTickAddWeeks(pTick0=0x%x, pTick1=0x%x, iAdd=%d)", pTick0.GetAddr(), pTick1.GetAddr(), iAdd);
wxDateTime date = wxDateTime::wxDateTime((time_t)Memory.Read64(tick_add_addr)); if (!pTick0.IsGood() || !pTick1.IsGood())
wxDateSpan weeks = wxDateSpan::wxDateSpan(0, 0, add, 0); return CELL_RTC_ERROR_INVALID_POINTER;
wxDateTime date = wxDateTime::wxDateTime((time_t)pTick1->tick);
wxDateSpan weeks = wxDateSpan::wxDateSpan(0, 0, iAdd, 0);
date.Add(weeks); date.Add(weeks);
tick = date.GetTicks(); pTick0->tick = date.GetTicks();
return CELL_OK; return CELL_OK;
} }
int cellRtcTickAddMonths(mem64_t tick, u32 tick_add_addr, int add) int cellRtcTickAddMonths(mem_ptr_t<CellRtcTick> pTick0, mem_ptr_t<CellRtcTick> pTick1, s32 iAdd)
{ {
cellRtc.Log("cellRtcTickAddMonths(tick_addr=0x%x, tick_add_addr=0x%x, add=%l)", tick.GetAddr(), tick_add_addr, add); cellRtc.Log("cellRtcTickAddMonths(pTick0=0x%x, pTick1=0x%x, iAdd=%d)", pTick0.GetAddr(), pTick1.GetAddr(), iAdd);
wxDateTime date = wxDateTime::wxDateTime((time_t)Memory.Read64(tick_add_addr)); if (!pTick0.IsGood() || !pTick1.IsGood())
wxDateSpan months = wxDateSpan::wxDateSpan(0, add, 0, 0); return CELL_RTC_ERROR_INVALID_POINTER;
wxDateTime date = wxDateTime::wxDateTime((time_t)pTick1->tick);
wxDateSpan months = wxDateSpan::wxDateSpan(0, iAdd, 0, 0);
date.Add(months); date.Add(months);
tick = date.GetTicks(); pTick0->tick = date.GetTicks();
return CELL_OK; return CELL_OK;
} }
int cellRtcTickAddYears(mem64_t tick, u32 tick_add_addr, int add) int cellRtcTickAddYears(mem_ptr_t<CellRtcTick> pTick0, mem_ptr_t<CellRtcTick> pTick1, s32 iAdd)
{ {
cellRtc.Log("cellRtcTickAddYears(tick_addr=0x%x, tick_add_addr=0x%x, add=%l)", tick.GetAddr(), tick_add_addr, add); cellRtc.Log("cellRtcTickAddYears(pTick0=0x%x, pTick1=0x%x, iAdd=%d)", pTick0.GetAddr(), pTick1.GetAddr(), iAdd);
wxDateTime date = wxDateTime::wxDateTime((time_t)Memory.Read64(tick_add_addr)); if (!pTick0.IsGood() || !pTick1.IsGood())
wxDateSpan years = wxDateSpan::wxDateSpan(add, 0, 0, 0); return CELL_RTC_ERROR_INVALID_POINTER;
wxDateTime date = wxDateTime::wxDateTime((time_t)pTick1->tick);
wxDateSpan years = wxDateSpan::wxDateSpan(iAdd, 0, 0, 0);
date.Add(years); date.Add(years);
tick = date.GetTicks(); pTick0->tick = date.GetTicks();
return CELL_OK; return CELL_OK;
} }
int cellRtcConvertUtcToLocalTime(u32 tick_utc_addr, mem64_t tick_local) int cellRtcConvertUtcToLocalTime(mem_ptr_t<CellRtcTick> pUtc, mem_ptr_t<CellRtcTick> pLocalTime)
{ {
cellRtc.Log("cellRtcConvertUtcToLocalTime(tick_utc_addr=0x%x, tick_local_addr=0x%x)", tick_utc_addr, tick_local.GetAddr()); cellRtc.Log("cellRtcConvertUtcToLocalTime(pUtc=0x%x, pLocalTime=0x%x)", pUtc.GetAddr(), pLocalTime.GetAddr());
wxDateTime time = wxDateTime::wxDateTime((time_t)Memory.Read64(tick_utc_addr));
if (!pUtc.IsGood() || !pLocalTime.IsGood())
return CELL_RTC_ERROR_INVALID_POINTER;
wxDateTime time = wxDateTime::wxDateTime((time_t)pUtc->tick);
wxDateTime local_time = time.FromUTC(false); wxDateTime local_time = time.FromUTC(false);
tick_local = local_time.GetTicks(); pLocalTime->tick = local_time.GetTicks();
return CELL_OK; return CELL_OK;
} }
int cellRtcConvertLocalTimeToUtc(u32 tick_local_addr, mem64_t tick_utc) int cellRtcConvertLocalTimeToUtc(mem_ptr_t<CellRtcTick> pLocalTime, mem_ptr_t<CellRtcTick> pUtc)
{ {
cellRtc.Log("cellRtcConvertLocalTimeToUtc(tick_local_addr=0x%x, tick_utc_addr=0x%x)", tick_local_addr, tick_utc.GetAddr()); cellRtc.Log("cellRtcConvertLocalTimeToUtc(pLocalTime=0x%x, pUtc=0x%x)", pLocalTime.GetAddr(), pUtc.GetAddr());
wxDateTime time = wxDateTime::wxDateTime((time_t)Memory.Read64(tick_local_addr));
if (!pLocalTime.IsGood() || !pUtc.IsGood())
return CELL_RTC_ERROR_INVALID_POINTER;
wxDateTime time = wxDateTime::wxDateTime((time_t)pLocalTime->tick);
wxDateTime utc_time = time.ToUTC(false); wxDateTime utc_time = time.ToUTC(false);
tick_utc = utc_time.GetTicks(); pUtc->tick = utc_time.GetTicks();
return CELL_OK; return CELL_OK;
} }
int cellRtcGetDosTime(u32 datetime_addr, mem64_t dos_time) int cellRtcGetDosTime(mem_ptr_t<CellRtcDateTime> pDateTime, mem32_t puiDosTime)
{ {
cellRtc.Log("cellRtcGetDosTime(datetime_addr=0x%x, dos_time_addr=0x%x)", datetime_addr, dos_time.GetAddr()); cellRtc.Log("cellRtcGetDosTime(pDateTime=0x%x, puiDosTime=0x%x)", pDateTime.GetAddr(), puiDosTime.GetAddr());
CellRtcDateTime datetime;
datetime.year = Memory.Read16(datetime_addr); if (!pDateTime.IsGood() || !puiDosTime.IsGood())
datetime.month = Memory.Read16(datetime_addr + 2); return CELL_RTC_ERROR_INVALID_POINTER;
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. // 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)); wxDateTime date_time = wxDateTime::wxDateTime(pDateTime->day, (wxDateTime::Month)pDateTime->month.ToLE(), pDateTime->year, pDateTime->hour, pDateTime->minute, pDateTime->second, (pDateTime->microsecond / 1000));
dos_time = date_time.GetAsDOS(); puiDosTime = date_time.GetAsDOS();
return CELL_OK; return CELL_OK;
} }
int cellRtcGetTime_t(u32 datetime_addr, mem64_t posix_time) int cellRtcGetTime_t(mem_ptr_t<CellRtcDateTime> pDateTime, mem64_t piTime)
{ {
cellRtc.Log("cellRtcGetTime_t(datetime_addr=0x%x, posix_time_addr=0x%x)", datetime_addr, posix_time.GetAddr()); cellRtc.Log("cellRtcGetTime_t(pDateTime=0x%x, piTime=0x%x)", pDateTime.GetAddr(), piTime.GetAddr());
CellRtcDateTime datetime;
datetime.year = Memory.Read16(datetime_addr); if (!pDateTime.IsGood() || !piTime.IsGood())
datetime.month = Memory.Read16(datetime_addr + 2); return CELL_RTC_ERROR_INVALID_POINTER;
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. // 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)); wxDateTime date_time = wxDateTime::wxDateTime(pDateTime->day, (wxDateTime::Month)pDateTime->month.ToLE(), pDateTime->year, pDateTime->hour, pDateTime->minute, pDateTime->second, (pDateTime->microsecond / 1000));
posix_time = convertToUNIXTime(date_time.GetSecond(wxDateTime::TZ::UTC), date_time.GetMinute(wxDateTime::TZ::UTC), 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)); date_time.GetHour(wxDateTime::TZ::UTC), date_time.GetDay(wxDateTime::TZ::UTC), date_time.GetYear(wxDateTime::TZ::UTC));
return CELL_OK; return CELL_OK;
} }
int cellRtcGetWin32FileTime(u32 datetime_addr, mem64_t win32_time) int cellRtcGetWin32FileTime(mem_ptr_t<CellRtcDateTime> pDateTime, mem64_t pulWin32FileTime)
{ {
cellRtc.Log("cellRtcGetWin32FileTime(datetime_addr=0x%x, win32_time_addr=0x%x)", datetime_addr, win32_time.GetAddr()); cellRtc.Log("cellRtcGetWin32FileTime(pDateTime=0x%x, pulWin32FileTime=0x%x)", pDateTime.GetAddr(), pulWin32FileTime.GetAddr());
CellRtcDateTime datetime;
datetime.year = Memory.Read16(datetime_addr); if (!pDateTime.IsGood() || !pulWin32FileTime.IsGood())
datetime.month = Memory.Read16(datetime_addr + 2); return CELL_RTC_ERROR_INVALID_POINTER;
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. // 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)); wxDateTime date_time = wxDateTime::wxDateTime(pDateTime->day, (wxDateTime::Month)pDateTime->month.ToLE(), pDateTime->year, pDateTime->hour, pDateTime->minute, pDateTime->second, (pDateTime->microsecond / 1000));
win32_time = convertToWin32FILETIME(date_time.GetSecond(wxDateTime::TZ::UTC), date_time.GetMinute(wxDateTime::TZ::UTC), 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)); date_time.GetHour(wxDateTime::TZ::UTC), date_time.GetDay(wxDateTime::TZ::UTC), date_time.GetYear(wxDateTime::TZ::UTC));
return CELL_OK; return CELL_OK;
} }
int cellRtcSetDosTime(u32 datetime_addr, u32 dos_time_addr) int cellRtcSetDosTime(mem_ptr_t<CellRtcDateTime> pDateTime, u32 uiDosTime)
{ {
cellRtc.Log("cellRtcSetDosTime(datetime_addr=0x%x, dos_time_addr=0x%x)", datetime_addr, dos_time_addr); 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 date_time;
wxDateTime dos_time = date_time.SetFromDOS(Memory.Read32(dos_time_addr)); wxDateTime dos_time = date_time.SetFromDOS(uiDosTime);
CellRtcDateTime datetime; pDateTime->year = dos_time.GetYear(wxDateTime::TZ::UTC);
datetime.year = dos_time.GetYear(wxDateTime::TZ::UTC); pDateTime->month = dos_time.GetMonth(wxDateTime::TZ::UTC);
datetime.month = dos_time.GetMonth(wxDateTime::TZ::UTC); pDateTime->day = dos_time.GetDay(wxDateTime::TZ::UTC);
datetime.day = dos_time.GetDay(wxDateTime::TZ::UTC); pDateTime->hour = dos_time.GetHour(wxDateTime::TZ::UTC);
datetime.hour = dos_time.GetHour(wxDateTime::TZ::UTC); pDateTime->minute = dos_time.GetMinute(wxDateTime::TZ::UTC);
datetime.minute = dos_time.GetMinute(wxDateTime::TZ::UTC); pDateTime->second = dos_time.GetSecond(wxDateTime::TZ::UTC);
datetime.second = dos_time.GetSecond(wxDateTime::TZ::UTC); pDateTime->microsecond = dos_time.GetMillisecond(wxDateTime::TZ::UTC) * 1000;
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; return CELL_OK;
} }
int cellRtcSetTime_t(u32 datetime_addr, u32 posix_time_addr) int cellRtcSetTime_t(mem_ptr_t<CellRtcDateTime> pDateTime, u64 iTime)
{ {
cellRtc.Log("cellRtcSetTime_t(datetime_addr=0x%x, posix_time_addr=0x%x)", datetime_addr, posix_time_addr); cellRtc.Log("cellRtcSetTime_t(pDateTime=0x%x, iTime=0x%llx)", pDateTime.GetAddr(), iTime);
wxDateTime date_time = wxDateTime::wxDateTime((time_t)Memory.Read64(posix_time_addr)); if (!pDateTime.IsGood())
return CELL_RTC_ERROR_INVALID_POINTER;
CellRtcDateTime datetime; wxDateTime date_time = wxDateTime::wxDateTime((time_t)iTime);
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); pDateTime->year = date_time.GetYear(wxDateTime::TZ::UTC);
Memory.Write16(datetime_addr + 2, datetime.month); pDateTime->month = date_time.GetMonth(wxDateTime::TZ::UTC);
Memory.Write16(datetime_addr + 4, datetime.day); pDateTime->day = date_time.GetDay(wxDateTime::TZ::UTC);
Memory.Write16(datetime_addr + 6, datetime.hour); pDateTime->hour = date_time.GetHour(wxDateTime::TZ::UTC);
Memory.Write16(datetime_addr + 8, datetime.minute); pDateTime->minute = date_time.GetMinute(wxDateTime::TZ::UTC);
Memory.Write16(datetime_addr + 10, datetime.second); pDateTime->second = date_time.GetSecond(wxDateTime::TZ::UTC);
Memory.Write32(datetime_addr + 12, datetime.microsecond); pDateTime->microsecond = date_time.GetMillisecond(wxDateTime::TZ::UTC) * 1000;
return CELL_OK; return CELL_OK;
} }
int cellRtcSetWin32FileTime(u32 datetime_addr, u32 win32_time_addr) int cellRtcSetWin32FileTime(mem_ptr_t<CellRtcDateTime> pDateTime, u64 ulWin32FileTime)
{ {
cellRtc.Log("cellRtcSetWin32FileTime(datetime_addr=0x%x, win32_time_addr=0x%x)", datetime_addr, win32_time_addr); cellRtc.Log("cellRtcSetWin32FileTime(pDateTime=0x%x, ulWin32FileTime=0x%llx)", pDateTime, ulWin32FileTime);
wxDateTime date_time = wxDateTime::wxDateTime((time_t)Memory.Read64(win32_time_addr)); if (!pDateTime.IsGood())
return CELL_RTC_ERROR_INVALID_POINTER;
CellRtcDateTime datetime; wxDateTime date_time = wxDateTime::wxDateTime((time_t)ulWin32FileTime);
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); pDateTime->year = date_time.GetYear(wxDateTime::TZ::UTC);
Memory.Write16(datetime_addr + 2, datetime.month); pDateTime->month = date_time.GetMonth(wxDateTime::TZ::UTC);
Memory.Write16(datetime_addr + 4, datetime.day); pDateTime->day = date_time.GetDay(wxDateTime::TZ::UTC);
Memory.Write16(datetime_addr + 6, datetime.hour); pDateTime->hour = date_time.GetHour(wxDateTime::TZ::UTC);
Memory.Write16(datetime_addr + 8, datetime.minute); pDateTime->minute = date_time.GetMinute(wxDateTime::TZ::UTC);
Memory.Write16(datetime_addr + 10, datetime.second); pDateTime->second = date_time.GetSecond(wxDateTime::TZ::UTC);
Memory.Write32(datetime_addr + 12, datetime.microsecond); pDateTime->microsecond = date_time.GetMillisecond(wxDateTime::TZ::UTC) * 1000;
return CELL_OK; return CELL_OK;
} }
int cellRtcIsLeapYear(int year) int cellRtcIsLeapYear(s32 year)
{ {
cellRtc.Log("cellRtcIsLeapYear(year=%d)", year); cellRtc.Log("cellRtcIsLeapYear(year=%d)", year);
@ -481,7 +489,7 @@ int cellRtcIsLeapYear(int year)
return datetime.IsLeapYear(year, wxDateTime::Gregorian); return datetime.IsLeapYear(year, wxDateTime::Gregorian);
} }
int cellRtcGetDaysInMonth(int year, int month) int cellRtcGetDaysInMonth(s32 year, s32 month)
{ {
cellRtc.Log("cellRtcGetDaysInMonth(year=%d, month=%d)", year, month); cellRtc.Log("cellRtcGetDaysInMonth(year=%d, month=%d)", year, month);
@ -489,7 +497,7 @@ int cellRtcGetDaysInMonth(int year, int month)
return datetime.GetNumberOfDays((wxDateTime::Month) month, year, wxDateTime::Gregorian); return datetime.GetNumberOfDays((wxDateTime::Month) month, year, wxDateTime::Gregorian);
} }
int cellRtcGetDayOfWeek(int year, int month, int day) 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);
@ -498,36 +506,32 @@ int cellRtcGetDayOfWeek(int year, int month, int day)
return datetime.GetWeekDay(); return datetime.GetWeekDay();
} }
int cellRtcCheckValid(u32 datetime_addr) int cellRtcCheckValid(mem_ptr_t<CellRtcDateTime> pTime)
{ {
cellRtc.Log("cellRtcCheckValid(datetime_addr=0x%x)", datetime_addr); cellRtc.Log("cellRtcCheckValid(pTime=0x%x)", pTime.GetAddr());
CellRtcDateTime datetime;
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; if (!pTime.IsGood())
else if((datetime.month < 1) || (datetime.month > 12)) return CELL_RTC_ERROR_INVALID_MONTH; return CELL_RTC_ERROR_INVALID_POINTER;
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; if ((pTime->year < 1) || (pTime->year > 9999)) return CELL_RTC_ERROR_INVALID_YEAR;
else if((datetime.minute < 0) || (datetime.minute > 59)) return CELL_RTC_ERROR_INVALID_MINUTE; else if ((pTime->month < 1) || (pTime->month > 12)) return CELL_RTC_ERROR_INVALID_MONTH;
else if((datetime.second < 0) || (datetime.second > 59)) return CELL_RTC_ERROR_INVALID_SECOND; else if ((pTime->day < 1) || (pTime->day > 31)) return CELL_RTC_ERROR_INVALID_DAY;
else if((datetime.microsecond < 0) || (datetime.microsecond > 999999)) return CELL_RTC_ERROR_INVALID_MICROSECOND; else if ((pTime->hour < 0) || (pTime->hour > 23)) return CELL_RTC_ERROR_INVALID_HOUR;
else if ((pTime->minute < 0) || (pTime->minute > 59)) return CELL_RTC_ERROR_INVALID_MINUTE;
else if ((pTime->second < 0) || (pTime->second > 59)) return CELL_RTC_ERROR_INVALID_SECOND;
else if ((pTime->microsecond < 0) || (pTime->microsecond > 999999)) return CELL_RTC_ERROR_INVALID_MICROSECOND;
else return CELL_OK; else return CELL_OK;
} }
int cellRtcCompareTick(u32 tick_addr_1, u32 tick_addr_2) int cellRtcCompareTick(mem_ptr_t<CellRtcTick> pTick0, mem_ptr_t<CellRtcTick> pTick1)
{ {
cellRtc.Log("cellRtcCompareTick(tick_addr_1=0x%x, tick_addr_2=0x%x)", tick_addr_1, tick_addr_2); cellRtc.Log("cellRtcCompareTick(pTick0=0x%x, pTick1=0x%x)", pTick0.GetAddr(), pTick1.GetAddr());
u64 tick1 = Memory.Read64(tick_addr_1);
u64 tick2 = Memory.Read64(tick_addr_2);
if(tick1 < tick2) return -1; if (!pTick0.IsGood() || !pTick1.IsGood())
else if(tick1 > tick2) return 1; return CELL_RTC_ERROR_INVALID_POINTER;
if (pTick0->tick < pTick1->tick) return -1;
else if (pTick0->tick > pTick1->tick) return 1;
else return CELL_OK; else return CELL_OK;
} }

16
rpcs3/Emu/SysCalls/Modules/cellRtc.h
View file

@ -21,16 +21,16 @@ enum
struct CellRtcTick struct CellRtcTick
{ {
u64 tick; be_t<u64> tick;
}; };
struct CellRtcDateTime struct CellRtcDateTime
{ {
u16 year; be_t<u16> year;
u16 month; be_t<u16> month;
u16 day; be_t<u16> day;
u16 hour; be_t<u16> hour;
u16 minute; be_t<u16> minute;
u16 second; be_t<u16> second;
u32 microsecond; be_t<u32> microsecond;
}; };

18
rpcs3/Emu/SysCalls/Modules/cellSpurs.h
View file

@ -51,9 +51,9 @@ struct CellSpursAttribute
struct CellSpursInfo struct CellSpursInfo
{ {
be_t<int> nSpus; be_t<s32> nSpus;
be_t<int> spuThreadGroupPriority; be_t<s32> spuThreadGroupPriority;
be_t<int> ppuThreadPriority; be_t<s32> ppuThreadPriority;
bool exitIfNoWork; bool exitIfNoWork;
bool spurs2; bool spurs2;
be_t<u32> traceBuffer_addr; //void *traceBuffer; be_t<u32> traceBuffer_addr; //void *traceBuffer;
@ -63,7 +63,7 @@ struct CellSpursInfo
be_t<u32> spuThreads[8]; //typedef u32 sys_spu_thread_t; be_t<u32> spuThreads[8]; //typedef u32 sys_spu_thread_t;
be_t<u32> spursHandlerThread0; be_t<u32> spursHandlerThread0;
be_t<u32> spursHandlerThread1; be_t<u32> spursHandlerThread1;
char namePrefix[CELL_SPURS_NAME_MAX_LENGTH+1]; s8 namePrefix[CELL_SPURS_NAME_MAX_LENGTH+1];
be_t<u64> namePrefixLength; be_t<u64> namePrefixLength;
be_t<u32> deadlineMissCounter; be_t<u32> deadlineMissCounter;
be_t<u32> deadlineMeetCounter; be_t<u32> deadlineMeetCounter;
@ -125,7 +125,7 @@ struct CellSpursTracePacket
struct start_struct struct start_struct
{ {
char module[4]; s8 module[4];
be_t<u16> level; be_t<u16> level;
be_t<u16> ls; be_t<u16> ls;
} start; } start;
@ -143,17 +143,17 @@ struct CellSpursTaskset
// Exception handlers. // Exception handlers.
typedef void (*CellSpursGlobalExceptionEventHandler)(mem_ptr_t<CellSpurs> spurs, const mem_ptr_t<CellSpursExceptionInfo> info, typedef void (*CellSpursGlobalExceptionEventHandler)(mem_ptr_t<CellSpurs> spurs, const mem_ptr_t<CellSpursExceptionInfo> info,
uint id, mem_ptr_t<void> arg); u32 id, mem_ptr_t<void> arg);
typedef void (*CellSpursTasksetExceptionEventHandler)(mem_ptr_t<CellSpurs> spurs, mem_ptr_t<CellSpursTaskset> taskset, typedef void (*CellSpursTasksetExceptionEventHandler)(mem_ptr_t<CellSpurs> spurs, mem_ptr_t<CellSpursTaskset> taskset,
uint idTask, const mem_ptr_t<CellSpursExceptionInfo> info, mem_ptr_t<void> arg); u32 idTask, const mem_ptr_t<CellSpursExceptionInfo> info, mem_ptr_t<void> arg);
struct CellSpursTasksetInfo struct CellSpursTasksetInfo
{ {
//CellSpursTaskInfo taskInfo[CELL_SPURS_MAX_TASK]; //CellSpursTaskInfo taskInfo[CELL_SPURS_MAX_TASK];
be_t<u64> argument; be_t<u64> argument;
be_t<uint> idWorkload; be_t<u32> idWorkload;
be_t<uint> idLastScheduledTask; //typedef unsigned CellSpursTaskId be_t<u32> idLastScheduledTask; //typedef unsigned CellSpursTaskId
be_t<u32> name_addr; be_t<u32> name_addr;
CellSpursTasksetExceptionEventHandler exceptionEventHandler; CellSpursTasksetExceptionEventHandler exceptionEventHandler;
be_t<u32> exceptionEventHandlerArgument_addr; //void *exceptionEventHandlerArgument be_t<u32> exceptionEventHandlerArgument_addr; //void *exceptionEventHandlerArgument

20
rpcs3/Emu/SysCalls/Modules/cellSysutil.cpp
View file

@ -174,28 +174,20 @@ int cellVideoOutGetState(u32 videoOut, u32 deviceIndex, u32 state_addr)
return CELL_VIDEO_OUT_ERROR_UNSUPPORTED_VIDEO_OUT; return CELL_VIDEO_OUT_ERROR_UNSUPPORTED_VIDEO_OUT;
} }
int cellVideoOutGetResolution(u32 resolutionId, u32 resolution_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_addr); resolutionId, resolution.GetAddr());
if(!Memory.IsGoodAddr(resolution_addr, sizeof(CellVideoOutResolution))) if (!resolution.IsGood())
{ return CELL_VIDEO_OUT_ERROR_ILLEGAL_PARAMETER;
return CELL_EFAULT;
}
u32 num = ResolutionIdToNum(resolutionId); u32 num = ResolutionIdToNum(resolutionId);
if(!num) if(!num)
{
return CELL_EINVAL; return CELL_EINVAL;
}
CellVideoOutResolution res; resolution->width = ResolutionTable[num].width;
re(res.width, ResolutionTable[num].width); resolution->height = ResolutionTable[num].height;
re(res.height, ResolutionTable[num].height);
Memory.WriteData(resolution_addr, res);
return CELL_VIDEO_OUT_SUCCEEDED; return CELL_VIDEO_OUT_SUCCEEDED;
} }

8
rpcs3/Emu/SysCalls/Modules/cellSysutil.h
View file

@ -215,14 +215,14 @@ struct CellHddGameStatGet
struct CellHddGameStatSet struct CellHddGameStatSet
{ {
CellHddGameSystemFileParam *setParam; mem_beptr_t<CellHddGameSystemFileParam> setParam;
u32 reserved_addr; // void* be_t<u32> reserved_addr; // void*
}; };
struct CellHddGameCBResult struct CellHddGameCBResult
{ {
be_t<u32> result; be_t<u32> result;
be_t<s32> errNeedSizeKB; be_t<s32> errNeedSizeKB;
u8 *invalidMsg; be_t<u32> invalidMsg_addr; // char*
u32 reserved_addr; // void* be_t<u32> reserved_addr; // void*
}; };

2
rpcs3/Emu/SysCalls/SysCalls.h
View file

@ -294,7 +294,7 @@ extern int cellFsStReadWaitCallback(u32 fd, u64 size, mem_func_ptr_t<void (*)(in
//cellVideo //cellVideo
extern int cellVideoOutGetState(u32 videoOut, u32 deviceIndex, u32 state_addr); extern int cellVideoOutGetState(u32 videoOut, u32 deviceIndex, u32 state_addr);
extern int cellVideoOutGetResolution(u32 resolutionId, u32 resolution_addr); extern int cellVideoOutGetResolution(u32 resolutionId, mem_ptr_t<CellVideoOutResolution> resolution);
extern int cellVideoOutConfigure(u32 videoOut, u32 config_addr, u32 option_addr, u32 waitForEvent); extern int cellVideoOutConfigure(u32 videoOut, u32 config_addr, u32 option_addr, u32 waitForEvent);
extern int cellVideoOutGetConfiguration(u32 videoOut, u32 config_addr, u32 option_addr); extern int cellVideoOutGetConfiguration(u32 videoOut, u32 config_addr, u32 option_addr);
extern int cellVideoOutGetNumberOfDevice(u32 videoOut); extern int cellVideoOutGetNumberOfDevice(u32 videoOut);

2
rpcs3/Gui/MainFrame.cpp
View file

@ -398,7 +398,7 @@ void MainFrame::Config(wxCommandEvent& WXUNUSED(event))
for(int i=1; i<WXSIZEOF(ResolutionTable); ++i) for(int i=1; i<WXSIZEOF(ResolutionTable); ++i)
{ {
cbox_gs_resolution->Append(wxString::Format("%dx%d", ResolutionTable[i].width, ResolutionTable[i].height)); cbox_gs_resolution->Append(wxString::Format("%dx%d", ResolutionTable[i].width.ToLE(), ResolutionTable[i].height.ToLE()));
} }
cbox_gs_aspect->Append("4:3"); cbox_gs_aspect->Append("4:3");