Emulation/ppsspp
1
0
Fork 0
mirror of https://github.com/hrydgard/ppsspp.git synced 2025-04-02 11:01:50 -04:00
Code Issues Projects Releases Packages Wiki Activity

Rename the Atrac errors to match the pattern

Browse source
This commit is contained in:
Henrik Rydgård 2025-02-24 12:12:48 -06:00
parent 59a4eb0ea5
commit 5ac7b8b9ee
6 changed files with 125 additions and 120 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
Core/Core.vcxproj
View file

@ -1188,6 +1188,7 @@
<ClInclude Include="FrameTiming.h" />
<ClInclude Include="HLE\AtracCtx.h" />
<ClInclude Include="HLE\AtracCtx2.h" />
<ClInclude Include="HLE\ErrorCodes.h" />
<ClInclude Include="HLE\KernelThreadDebugInterface.h" />
<ClInclude Include="HLE\KUBridge.h" />
<ClInclude Include="HLE\NetInetConstants.h" />

3
Core/Core.vcxproj.filters
View file

@ -2163,6 +2163,9 @@
<ClInclude Include="HLE\sceAac.h">
<Filter>HLE\Libraries</Filter>
</ClInclude>
<ClInclude Include="HLE\ErrorCodes.h">
<Filter>HLE</Filter>
</ClInclude>
</ItemGroup>
<ItemGroup>
<None Include="..\LICENSE.TXT" />

66
Core/HLE/AtracCtx.cpp
View file

@ -249,7 +249,7 @@ int Atrac::Analyze(u32 addr, u32 size) {
// 72 is about the size of the minimum required data to even be valid.
if (size < 72) {
return hleReportError(Log::ME, ATRAC_ERROR_SIZE_TOO_SMALL, "buffer too small");
return hleReportError(Log::ME, SCE_ERROR_ATRAC_SIZE_TOO_SMALL, "buffer too small");
}
// TODO: Check the range (addr, size) instead.
@ -259,7 +259,7 @@ int Atrac::Analyze(u32 addr, u32 size) {
// TODO: Validate stuff.
if (Memory::ReadUnchecked_U32(addr) != RIFF_CHUNK_MAGIC) {
return hleReportError(Log::ME, ATRAC_ERROR_UNKNOWN_FORMAT, "invalid RIFF header");
return hleReportError(Log::ME, SCE_ERROR_ATRAC_UNKNOWN_FORMAT, "invalid RIFF header");
}
int retval = AnalyzeAtracTrack(addr, size, &track_);
@ -286,10 +286,10 @@ int AnalyzeAtracTrack(u32 addr, u32 size, Track *track) {
// Round the chunk size up to the nearest 2.
offset += chunk + (chunk & 1);
if (offset + 12 > size) {
return hleReportError(Log::ME, ATRAC_ERROR_SIZE_TOO_SMALL, "too small for WAVE chunk at %d", offset);
return hleReportError(Log::ME, SCE_ERROR_ATRAC_SIZE_TOO_SMALL, "too small for WAVE chunk at %d", offset);
}
if (Memory::Read_U32(addr + offset) != RIFF_CHUNK_MAGIC) {
return hleReportError(Log::ME, ATRAC_ERROR_UNKNOWN_FORMAT, "RIFF chunk did not contain WAVE");
return hleReportError(Log::ME, SCE_ERROR_ATRAC_UNKNOWN_FORMAT, "RIFF chunk did not contain WAVE");
}
offset += 8;
}
@ -324,12 +324,12 @@ int AnalyzeAtracTrack(u32 addr, u32 size, Track *track) {
case FMT_CHUNK_MAGIC:
{
if (track->codecType != 0) {
return hleReportError(Log::ME, ATRAC_ERROR_UNKNOWN_FORMAT, "multiple fmt definitions");
return hleReportError(Log::ME, SCE_ERROR_ATRAC_UNKNOWN_FORMAT, "multiple fmt definitions");
}
auto at3fmt = PSPPointer<const RIFFFmtChunk>::Create(addr + offset);
if (chunkSize < 32 || (at3fmt->fmtTag == AT3_PLUS_MAGIC && chunkSize < 52)) {
return hleReportError(Log::ME, ATRAC_ERROR_UNKNOWN_FORMAT, "fmt definition too small (%d)", chunkSize);
return hleReportError(Log::ME, SCE_ERROR_ATRAC_UNKNOWN_FORMAT, "fmt definition too small (%d)", chunkSize);
}
if (at3fmt->fmtTag == AT3_MAGIC)
@ -337,19 +337,19 @@ int AnalyzeAtracTrack(u32 addr, u32 size, Track *track) {
else if (at3fmt->fmtTag == AT3_PLUS_MAGIC)
track->codecType = PSP_MODE_AT_3_PLUS;
else {
return hleReportError(Log::ME, ATRAC_ERROR_UNKNOWN_FORMAT, "invalid fmt magic: %04x", at3fmt->fmtTag);
return hleReportError(Log::ME, SCE_ERROR_ATRAC_UNKNOWN_FORMAT, "invalid fmt magic: %04x", at3fmt->fmtTag);
}
track->channels = at3fmt->channels;
if (track->channels != 1 && track->channels != 2) {
return hleReportError(Log::ME, ATRAC_ERROR_UNKNOWN_FORMAT, "invalid channel count: %d", track->channels);
return hleReportError(Log::ME, SCE_ERROR_ATRAC_UNKNOWN_FORMAT, "invalid channel count: %d", track->channels);
}
if (at3fmt->samplerate != 44100) {
return hleReportError(Log::ME, ATRAC_ERROR_UNKNOWN_FORMAT, "unsupported sample rate: %d", at3fmt->samplerate);
return hleReportError(Log::ME, SCE_ERROR_ATRAC_UNKNOWN_FORMAT, "unsupported sample rate: %d", at3fmt->samplerate);
}
track->bitrate = at3fmt->avgBytesPerSec * 8;
track->bytesPerFrame = at3fmt->blockAlign;
if (track->bytesPerFrame == 0) {
return hleReportError(Log::ME, ATRAC_ERROR_UNKNOWN_FORMAT, "invalid bytes per frame: %d", track->bytesPerFrame);
return hleReportError(Log::ME, SCE_ERROR_ATRAC_UNKNOWN_FORMAT, "invalid bytes per frame: %d", track->bytesPerFrame);
}
// TODO: There are some format specific bytes here which seem to have fixed values?
@ -391,14 +391,14 @@ int AnalyzeAtracTrack(u32 addr, u32 size, Track *track) {
case SMPL_CHUNK_MAGIC:
{
if (chunkSize < 32) {
return hleReportError(Log::ME, ATRAC_ERROR_UNKNOWN_FORMAT, "smpl chunk too small (%d)", chunkSize);
return hleReportError(Log::ME, SCE_ERROR_ATRAC_UNKNOWN_FORMAT, "smpl chunk too small (%d)", chunkSize);
}
int checkNumLoops = Memory::Read_U32(addr + offset + 28);
if (checkNumLoops != 0 && chunkSize < 36 + 20) {
return hleReportError(Log::ME, ATRAC_ERROR_UNKNOWN_FORMAT, "smpl chunk too small for loop (%d, %d)", checkNumLoops, chunkSize);
return hleReportError(Log::ME, SCE_ERROR_ATRAC_UNKNOWN_FORMAT, "smpl chunk too small for loop (%d, %d)", checkNumLoops, chunkSize);
}
if (checkNumLoops < 0) {
return hleReportError(Log::ME, ATRAC_ERROR_UNKNOWN_FORMAT, "bad checkNumLoops (%d)", checkNumLoops);
return hleReportError(Log::ME, SCE_ERROR_ATRAC_UNKNOWN_FORMAT, "bad checkNumLoops (%d)", checkNumLoops);
}
track->loopinfo.resize(checkNumLoops);
@ -414,7 +414,7 @@ int AnalyzeAtracTrack(u32 addr, u32 size, Track *track) {
track->loopinfo[i].playCount = Memory::Read_U32(loopinfoAddr + 20);
if (track->loopinfo[i].startSample >= track->loopinfo[i].endSample) {
return hleReportError(Log::ME, ATRAC_ERROR_BAD_CODEC_PARAMS, "loop starts after it ends");
return hleReportError(Log::ME, SCE_ERROR_ATRAC_BAD_CODEC_PARAMS, "loop starts after it ends");
}
}
break;
@ -435,11 +435,11 @@ int AnalyzeAtracTrack(u32 addr, u32 size, Track *track) {
}
if (track->codecType == 0) {
return hleReportError(Log::ME, ATRAC_ERROR_UNKNOWN_FORMAT, "could not detect codec");
return hleReportError(Log::ME, SCE_ERROR_ATRAC_UNKNOWN_FORMAT, "could not detect codec");
}
if (!bfoundData) {
return hleReportError(Log::ME, ATRAC_ERROR_SIZE_TOO_SMALL, "no data chunk");
return hleReportError(Log::ME, SCE_ERROR_ATRAC_SIZE_TOO_SMALL, "no data chunk");
}
// set the loopStartSample_ and loopEndSample_ by loopinfo_
@ -459,7 +459,7 @@ int AnalyzeAtracTrack(u32 addr, u32 size, Track *track) {
track->endSample -= 1;
if (track->loopEndSample != -1 && track->loopEndSample > track->endSample + track->FirstSampleOffsetFull()) {
return hleReportError(Log::ME, ATRAC_ERROR_BAD_CODEC_PARAMS, "loop after end of data");
return hleReportError(Log::ME, SCE_ERROR_ATRAC_BAD_CODEC_PARAMS, "loop after end of data");
}
return 0;
@ -477,25 +477,25 @@ int Atrac::AnalyzeAA3(u32 addr, u32 size, u32 fileSize) {
int AnalyzeAA3Track(u32 addr, u32 size, u32 fileSize, Track *track) {
if (size < 10) {
return hleReportError(Log::ME, ATRAC_ERROR_AA3_SIZE_TOO_SMALL, "buffer too small");
return hleReportError(Log::ME, SCE_ERROR_ATRAC_AA3_SIZE_TOO_SMALL, "buffer too small");
}
// TODO: Make sure this validation is correct, more testing.
const u8 *buffer = Memory::GetPointer(addr);
if (buffer[0] != 'e' || buffer[1] != 'a' || buffer[2] != '3') {
return hleReportError(Log::ME, ATRAC_ERROR_AA3_INVALID_DATA, "invalid ea3 magic bytes");
return hleReportError(Log::ME, SCE_ERROR_ATRAC_AA3_INVALID_DATA, "invalid ea3 magic bytes");
}
// It starts with an id3 header (replaced with ea3.) This is the size.
u32 tagSize = buffer[9] | (buffer[8] << 7) | (buffer[7] << 14) | (buffer[6] << 21);
if (size < tagSize + 36) {
return hleReportError(Log::ME, ATRAC_ERROR_AA3_SIZE_TOO_SMALL, "truncated before id3 end");
return hleReportError(Log::ME, SCE_ERROR_ATRAC_AA3_SIZE_TOO_SMALL, "truncated before id3 end");
}
// EA3 header starts at id3 header (10) + tagSize.
buffer = Memory::GetPointer(addr + 10 + tagSize);
if (buffer[0] != 'E' || buffer[1] != 'A' || buffer[2] != '3') {
return hleReportError(Log::ME, ATRAC_ERROR_AA3_INVALID_DATA, "invalid EA3 magic bytes");
return hleReportError(Log::ME, SCE_ERROR_ATRAC_AA3_INVALID_DATA, "invalid EA3 magic bytes");
}
track->fileSize = fileSize;
@ -521,9 +521,9 @@ int AnalyzeAA3Track(u32 addr, u32 size, u32 fileSize, Track *track) {
case 3:
case 4:
case 5:
return hleReportError(Log::ME, ATRAC_ERROR_AA3_INVALID_DATA, "unsupported codec type %d", buffer[32]);
return hleReportError(Log::ME, SCE_ERROR_ATRAC_AA3_INVALID_DATA, "unsupported codec type %d", buffer[32]);
default:
return hleReportError(Log::ME, ATRAC_ERROR_AA3_INVALID_DATA, "invalid codec type %d", buffer[32]);
return hleReportError(Log::ME, SCE_ERROR_ATRAC_AA3_INVALID_DATA, "invalid codec type %d", buffer[32]);
}
track->dataByteOffset = 10 + tagSize + 96;
@ -689,7 +689,7 @@ int Atrac::SetData(u32 buffer, u32 readSize, u32 bufferSize, int outputChannels,
if (track_.codecType != PSP_MODE_AT_3 && track_.codecType != PSP_MODE_AT_3_PLUS) {
// Shouldn't have gotten here, Analyze() checks this.
bufferState_ = ATRAC_STATUS_NO_DATA;
return hleReportError(Log::ME, ATRAC_ERROR_UNKNOWN_FORMAT, "unexpected codec type in set data");
return hleReportError(Log::ME, SCE_ERROR_ATRAC_UNKNOWN_FORMAT, "unexpected codec type in set data");
}
if (bufferState_ == ATRAC_STATUS_ALL_DATA_LOADED || bufferState_ == ATRAC_STATUS_HALFWAY_BUFFER) {
@ -726,10 +726,10 @@ u32 Atrac::SetSecondBuffer(u32 secondBuffer, u32 secondBufferSize) {
// 3 seems to be the number of frames required to handle a loop.
if (secondBufferSize < desiredSize && secondBufferSize < (u32)track_.BytesPerFrame() * 3) {
return hleReportError(Log::ME, ATRAC_ERROR_SIZE_TOO_SMALL, "too small");
return hleReportError(Log::ME, SCE_ERROR_ATRAC_SIZE_TOO_SMALL, "too small");
}
if (BufferState() != ATRAC_STATUS_STREAMED_LOOP_WITH_TRAILER) {
return hleReportError(Log::ME, ATRAC_ERROR_SECOND_BUFFER_NOT_NEEDED, "not needed");
return hleReportError(Log::ME, SCE_ERROR_ATRAC_SECOND_BUFFER_NOT_NEEDED, "not needed");
}
second_.addr = secondBuffer;
@ -743,7 +743,7 @@ int AtracBase::GetSecondBufferInfo(u32 *fileOffset, u32 *desiredSize) {
// Writes zeroes in this error case.
*fileOffset = 0;
*desiredSize = 0;
return hleLogWarning(Log::ME, ATRAC_ERROR_SECOND_BUFFER_NOT_NEEDED, "not needed");
return hleLogWarning(Log::ME, SCE_ERROR_ATRAC_SECOND_BUFFER_NOT_NEEDED, "not needed");
}
*fileOffset = track_.FileOffsetBySample(track_.loopEndSample - track_.firstSampleOffset);
@ -785,7 +785,7 @@ int Atrac::AddStreamData(u32 bytesToAdd) {
u32 readOffset;
CalculateStreamInfo(&readOffset);
if (bytesToAdd > first_.writableBytes)
return hleLogWarning(Log::ME, ATRAC_ERROR_ADD_DATA_IS_TOO_BIG, "too many bytes");
return hleLogWarning(Log::ME, SCE_ERROR_ATRAC_ADD_DATA_IS_TOO_BIG, "too many bytes");
if (bytesToAdd > 0) {
first_.fileoffset = readOffset;
@ -948,7 +948,7 @@ u32 Atrac::DecodeData(u8 *outbuf, u32 outbufPtr, u32 *SamplesNum, u32 *finish, i
*finish = 1;
// refresh context_
WriteContextToPSPMem();
return ATRAC_ERROR_ALL_DATA_DECODED;
return SCE_ERROR_ATRAC_ALL_DATA_DECODED;
}
// TODO: This isn't at all right, but at least it makes the music "last" some time.
@ -998,7 +998,7 @@ u32 Atrac::DecodeData(u8 *outbuf, u32 outbufPtr, u32 *SamplesNum, u32 *finish, i
// Decode failed.
*SamplesNum = 0;
*finish = 1;
return ATRAC_ERROR_ALL_DATA_DECODED;
return SCE_ERROR_ATRAC_ALL_DATA_DECODED;
}
if (packetAddr != 0 && MemBlockInfoDetailed()) {
@ -1085,10 +1085,10 @@ u32 Atrac::ResetPlayPosition(int sample, int bytesWrittenFirstBuf, int bytesWrit
GetResetBufferInfo(&bufferInfo, sample);
if ((u32)bytesWrittenFirstBuf < bufferInfo.first.minWriteBytes || (u32)bytesWrittenFirstBuf > bufferInfo.first.writableBytes) {
return hleLogError(Log::ME, ATRAC_ERROR_BAD_FIRST_RESET_SIZE, "first byte count not in valid range");
return hleLogError(Log::ME, SCE_ERROR_ATRAC_BAD_FIRST_RESET_SIZE, "first byte count not in valid range");
}
if ((u32)bytesWrittenSecondBuf < bufferInfo.second.minWriteBytes || (u32)bytesWrittenSecondBuf > bufferInfo.second.writableBytes) {
return hleLogError(Log::ME, ATRAC_ERROR_BAD_SECOND_RESET_SIZE, "second byte count not in valid range");
return hleLogError(Log::ME, SCE_ERROR_ATRAC_BAD_SECOND_RESET_SIZE, "second byte count not in valid range");
}
if (bufferState_ == ATRAC_STATUS_ALL_DATA_LOADED) {
@ -1111,7 +1111,7 @@ u32 Atrac::ResetPlayPosition(int sample, int bytesWrittenFirstBuf, int bytesWrit
}
} else {
if (bufferInfo.first.filePos > track_.fileSize) {
return hleDelayResult(hleLogError(Log::ME, ATRAC_ERROR_API_FAIL, "invalid file position"), "reset play pos", 200);
return hleDelayResult(hleLogError(Log::ME, SCE_ERROR_ATRAC_API_FAIL, "invalid file position"), "reset play pos", 200);
}
// Move the offset to the specified position.

50
Core/HLE/ErrorCodes.h
View file

@ -381,29 +381,29 @@ enum : u32 {
SCE_ERROR_PGD_INVALID_HEADER = 0x80510204,
ATRAC_ERROR_API_FAIL = 0x80630002,
ATRAC_ERROR_NO_ATRACID = 0x80630003,
ATRAC_ERROR_INVALID_CODECTYPE = 0x80630004,
ATRAC_ERROR_BAD_ATRACID = 0x80630005,
ATRAC_ERROR_UNKNOWN_FORMAT = 0x80630006,
ATRAC_ERROR_WRONG_CODECTYPE = 0x80630007,
ATRAC_ERROR_BAD_CODEC_PARAMS = 0x80630008,
ATRAC_ERROR_ALL_DATA_LOADED = 0x80630009,
ATRAC_ERROR_NO_DATA = 0x80630010,
ATRAC_ERROR_SIZE_TOO_SMALL = 0x80630011,
ATRAC_ERROR_SECOND_BUFFER_NEEDED = 0x80630012,
ATRAC_ERROR_INCORRECT_READ_SIZE = 0x80630013,
ATRAC_ERROR_BAD_SAMPLE = 0x80630015,
ATRAC_ERROR_BAD_FIRST_RESET_SIZE = 0x80630016,
ATRAC_ERROR_BAD_SECOND_RESET_SIZE = 0x80630017,
ATRAC_ERROR_ADD_DATA_IS_TOO_BIG = 0x80630018,
ATRAC_ERROR_NOT_MONO = 0x80630019,
ATRAC_ERROR_NO_LOOP_INFORMATION = 0x80630021,
ATRAC_ERROR_SECOND_BUFFER_NOT_NEEDED = 0x80630022,
ATRAC_ERROR_BUFFER_IS_EMPTY = 0x80630023,
ATRAC_ERROR_ALL_DATA_DECODED = 0x80630024,
ATRAC_ERROR_IS_LOW_LEVEL = 0x80630031,
ATRAC_ERROR_IS_FOR_SCESAS = 0x80630040,
ATRAC_ERROR_AA3_INVALID_DATA = 0x80631003,
ATRAC_ERROR_AA3_SIZE_TOO_SMALL = 0x80631004,
SCE_ERROR_ATRAC_API_FAIL = 0x80630002,
SCE_ERROR_ATRAC_NO_ATRACID = 0x80630003,
SCE_ERROR_ATRAC_INVALID_CODECTYPE = 0x80630004,
SCE_ERROR_ATRAC_BAD_ATRACID = 0x80630005,
SCE_ERROR_ATRAC_UNKNOWN_FORMAT = 0x80630006,
SCE_ERROR_ATRAC_WRONG_CODECTYPE = 0x80630007,
SCE_ERROR_ATRAC_BAD_CODEC_PARAMS = 0x80630008,
SCE_ERROR_ATRAC_ALL_DATA_LOADED = 0x80630009,
SCE_ERROR_ATRAC_NO_DATA = 0x80630010,
SCE_ERROR_ATRAC_SIZE_TOO_SMALL = 0x80630011,
SCE_ERROR_ATRAC_SECOND_BUFFER_NEEDED = 0x80630012,
SCE_ERROR_ATRAC_INCORRECT_READ_SIZE = 0x80630013,
SCE_ERROR_ATRAC_BAD_SAMPLE = 0x80630015,
SCE_ERROR_ATRAC_BAD_FIRST_RESET_SIZE = 0x80630016,
SCE_ERROR_ATRAC_BAD_SECOND_RESET_SIZE = 0x80630017,
SCE_ERROR_ATRAC_ADD_DATA_IS_TOO_BIG = 0x80630018,
SCE_ERROR_ATRAC_NOT_MONO = 0x80630019,
SCE_ERROR_ATRAC_NO_LOOP_INFORMATION = 0x80630021,
SCE_ERROR_ATRAC_SECOND_BUFFER_NOT_NEEDED = 0x80630022,
SCE_ERROR_ATRAC_BUFFER_IS_EMPTY = 0x80630023,
SCE_ERROR_ATRAC_ALL_DATA_DECODED = 0x80630024,
SCE_ERROR_ATRAC_IS_LOW_LEVEL = 0x80630031,
SCE_ERROR_ATRAC_IS_FOR_SCESAS = 0x80630040,
SCE_ERROR_ATRAC_AA3_INVALID_DATA = 0x80631003,
SCE_ERROR_ATRAC_AA3_SIZE_TOO_SMALL = 0x80631004,
};

75
Core/HLE/sceAtrac.cpp
View file

@ -171,7 +171,7 @@ static int createAtrac(AtracBase *atrac) {
return i;
}
}
return ATRAC_ERROR_NO_ATRACID;
return SCE_ERROR_ATRAC_NO_ATRACID;
}
static int deleteAtrac(int atracID) {
@ -182,14 +182,14 @@ static int deleteAtrac(int atracID) {
return 0;
}
}
return ATRAC_ERROR_BAD_ATRACID;
return SCE_ERROR_ATRAC_BAD_ATRACID;
}
// Really, allocate an Atrac context of a specific codec type.
// Useful to initialize a context for low level decode.
static u32 sceAtracGetAtracID(int codecType) {
if (codecType != PSP_MODE_AT_3 && codecType != PSP_MODE_AT_3_PLUS) {
return hleReportError(Log::ME, ATRAC_ERROR_INVALID_CODECTYPE, "invalid codecType");
return hleReportError(Log::ME, SCE_ERROR_ATRAC_INVALID_CODECTYPE, "invalid codecType");
}
AtracBase *atrac = allocAtrac();
@ -205,9 +205,9 @@ static u32 sceAtracGetAtracID(int codecType) {
static int AtracValidateData(const AtracBase *atrac) {
if (!atrac) {
return hleLogError(Log::ME, ATRAC_ERROR_BAD_ATRACID, "bad atrac ID");
return hleLogError(Log::ME, SCE_ERROR_ATRAC_BAD_ATRACID, "bad atrac ID");
} else if (atrac->BufferState() == ATRAC_STATUS_NO_DATA) {
return hleLogError(Log::ME, ATRAC_ERROR_NO_DATA, "no data");
return hleLogError(Log::ME, SCE_ERROR_ATRAC_NO_DATA, "no data");
} else {
return hleNoLog(0);
}
@ -215,13 +215,13 @@ static int AtracValidateData(const AtracBase *atrac) {
static int AtracValidateManaged(const AtracBase *atrac) {
if (!atrac) {
return hleLogError(Log::ME, ATRAC_ERROR_BAD_ATRACID, "bad atrac ID");
return hleLogError(Log::ME, SCE_ERROR_ATRAC_BAD_ATRACID, "bad atrac ID");
} else if (atrac->BufferState() == ATRAC_STATUS_NO_DATA) {
return hleLogError(Log::ME, ATRAC_ERROR_NO_DATA, "no data");
return hleLogError(Log::ME, SCE_ERROR_ATRAC_NO_DATA, "no data");
} else if (atrac->BufferState() == ATRAC_STATUS_LOW_LEVEL) {
return hleLogError(Log::ME, ATRAC_ERROR_IS_LOW_LEVEL, "low level stream, can't use");
return hleLogError(Log::ME, SCE_ERROR_ATRAC_IS_LOW_LEVEL, "low level stream, can't use");
} else if (atrac->BufferState() == ATRAC_STATUS_FOR_SCESAS) {
return hleLogError(Log::ME, ATRAC_ERROR_IS_FOR_SCESAS, "SAS stream, can't use");
return hleLogError(Log::ME, SCE_ERROR_ATRAC_IS_FOR_SCESAS, "SAS stream, can't use");
} else {
return hleNoLog(0);
}
@ -242,8 +242,8 @@ static u32 sceAtracAddStreamData(int atracID, u32 bytesToAdd) {
if (atrac->BufferState() == ATRAC_STATUS_ALL_DATA_LOADED) {
// Let's avoid spurious warnings. Some games call this with 0 which is pretty harmless.
if (bytesToAdd == 0)
return hleLogDebug(Log::ME, ATRAC_ERROR_ALL_DATA_LOADED, "stream entirely loaded");
return hleLogWarning(Log::ME, ATRAC_ERROR_ALL_DATA_LOADED, "stream entirely loaded");
return hleLogDebug(Log::ME, SCE_ERROR_ATRAC_ALL_DATA_LOADED, "stream entirely loaded");
return hleLogWarning(Log::ME, SCE_ERROR_ATRAC_ALL_DATA_LOADED, "stream entirely loaded");
}
int ret = atrac->AddStreamData(bytesToAdd);
@ -266,7 +266,7 @@ static u32 sceAtracDecodeData(int atracID, u32 outAddr, u32 numSamplesAddr, u32
u32 finish = 0;
int remains = 0;
int ret = atrac->DecodeData(Memory::GetPointerWrite(outAddr), outAddr, &numSamples, &finish, &remains);
if (ret != (int)ATRAC_ERROR_BAD_ATRACID && ret != (int)ATRAC_ERROR_NO_DATA) {
if (ret != (int)SCE_ERROR_ATRAC_BAD_ATRACID && ret != (int)SCE_ERROR_ATRAC_NO_DATA) {
if (Memory::IsValidAddress(numSamplesAddr))
Memory::WriteUnchecked_U32(numSamples, numSamplesAddr);
if (Memory::IsValidAddress(finishFlagAddr))
@ -306,10 +306,10 @@ static u32 sceAtracGetBufferInfoForResetting(int atracID, int sample, u32 buffer
if (!bufferInfo.IsValid()) {
return hleReportError(Log::ME, SCE_KERNEL_ERROR_ILLEGAL_ADDR, "invalid buffer, should crash");
} else if (atrac->BufferState() == ATRAC_STATUS_STREAMED_LOOP_WITH_TRAILER && atrac->SecondBufferSize() == 0) {
return hleReportError(Log::ME, ATRAC_ERROR_SECOND_BUFFER_NEEDED, "no second buffer");
return hleReportError(Log::ME, SCE_ERROR_ATRAC_SECOND_BUFFER_NEEDED, "no second buffer");
} else if ((u32)sample + atrac->GetTrack().firstSampleOffset > (u32)atrac->GetTrack().endSample + atrac->GetTrack().firstSampleOffset) {
// NOTE: Above we have to add firstSampleOffset to both sides - we seem to rely on wraparound.
return hleLogWarning(Log::ME, ATRAC_ERROR_BAD_SAMPLE, "invalid sample position");
return hleLogWarning(Log::ME, SCE_ERROR_ATRAC_BAD_SAMPLE, "invalid sample position");
} else {
atrac->GetResetBufferInfo(bufferInfo, sample);
return hleLogInfo(Log::ME, 0);
@ -412,7 +412,7 @@ static u32 sceAtracGetNextDecodePosition(int atracID, u32 outposAddr) {
if (Memory::IsValidAddress(outposAddr)) {
if (atrac->CurrentSample() >= atrac->GetTrack().endSample) {
Memory::WriteUnchecked_U32(0, outposAddr);
return hleLogDebug(Log::ME, ATRAC_ERROR_ALL_DATA_DECODED, "all data decoded - beyond endSample");
return hleLogDebug(Log::ME, SCE_ERROR_ATRAC_ALL_DATA_DECODED, "all data decoded - beyond endSample");
} else {
Memory::WriteUnchecked_U32(atrac->CurrentSample(), outposAddr);
return hleLogDebug(Log::ME, 0);
@ -556,10 +556,10 @@ static u32 sceAtracResetPlayPosition(int atracID, int sample, int bytesWrittenFi
}
if (atrac->BufferState() == ATRAC_STATUS_STREAMED_LOOP_WITH_TRAILER && atrac->SecondBufferSize() == 0) {
return hleReportError(Log::ME, ATRAC_ERROR_SECOND_BUFFER_NEEDED, "no second buffer");
return hleReportError(Log::ME, SCE_ERROR_ATRAC_SECOND_BUFFER_NEEDED, "no second buffer");
} else if ((u32)sample + atrac->GetTrack().firstSampleOffset > (u32)atrac->GetTrack().endSample + atrac->GetTrack().firstSampleOffset) {
// NOTE: Above we have to add firstSampleOffset to both sides - we seem to rely on wraparound.
return hleLogWarning(Log::ME, ATRAC_ERROR_BAD_SAMPLE, "invalid sample position");
return hleLogWarning(Log::ME, SCE_ERROR_ATRAC_BAD_SAMPLE, "invalid sample position");
}
u32 res = atrac->ResetPlayPosition(sample, bytesWrittenFirstBuf, bytesWrittenSecondBuf);
@ -575,8 +575,9 @@ static u32 sceAtracResetPlayPosition(int atracID, int sample, int bytesWrittenFi
static int _AtracSetData(int atracID, u32 buffer, u32 readSize, u32 bufferSize, int outputChannels, bool needReturnAtracID) {
AtracBase *atrac = getAtrac(atracID);
// Don't use AtracValidateManaged here.
if (!atrac)
return hleLogError(Log::ME, ATRAC_ERROR_BAD_ATRACID, "invalid atrac ID");
if (!atrac) {
return hleLogError(Log::ME, SCE_ERROR_ATRAC_BAD_ATRACID, "invalid atrac ID");
}
// SetData logs like a hle function.
int ret = atrac->SetData(buffer, readSize, bufferSize, outputChannels, needReturnAtracID ? atracID : 0);
// not sure the real delay time
@ -587,11 +588,11 @@ static u32 sceAtracSetHalfwayBuffer(int atracID, u32 buffer, u32 readSize, u32 b
AtracBase *atrac = getAtrac(atracID);
// Don't use AtracValidateManaged here.
if (!atrac) {
return hleLogError(Log::ME, ATRAC_ERROR_BAD_ATRACID, "invalid atrac ID");
return hleLogError(Log::ME, SCE_ERROR_ATRAC_BAD_ATRACID, "invalid atrac ID");
}
if (readSize > bufferSize) {
return hleLogError(Log::ME, ATRAC_ERROR_INCORRECT_READ_SIZE, "read size too large");
return hleLogError(Log::ME, SCE_ERROR_ATRAC_INCORRECT_READ_SIZE, "read size too large");
}
int ret = atrac->Analyze(buffer, readSize);
@ -617,7 +618,7 @@ static u32 sceAtracSetSecondBuffer(int atracID, u32 secondBuffer, u32 secondBuff
static u32 sceAtracSetData(int atracID, u32 buffer, u32 bufferSize) {
AtracBase *atrac = getAtrac(atracID);
if (!atrac) {
return hleLogError(Log::ME, ATRAC_ERROR_BAD_ATRACID, "bad atrac ID");
return hleLogError(Log::ME, SCE_ERROR_ATRAC_BAD_ATRACID, "bad atrac ID");
}
int ret = atrac->Analyze(buffer, bufferSize);
@ -628,7 +629,7 @@ static u32 sceAtracSetData(int atracID, u32 buffer, u32 bufferSize) {
if (atrac->GetTrack().codecType != atracContextTypes[atracID]) {
// TODO: Should this not change the buffer size?
return hleReportError(Log::ME, ATRAC_ERROR_WRONG_CODECTYPE, "atracID uses different codec type than data");
return hleReportError(Log::ME, SCE_ERROR_ATRAC_WRONG_CODECTYPE, "atracID uses different codec type than data");
}
return _AtracSetData(atracID, buffer, bufferSize, bufferSize, 2, false);
@ -660,7 +661,7 @@ static int sceAtracSetDataAndGetID(u32 buffer, int bufferSize) {
static int sceAtracSetHalfwayBufferAndGetID(u32 buffer, u32 readSize, u32 bufferSize) {
if (readSize > bufferSize) {
return hleLogError(Log::ME, ATRAC_ERROR_INCORRECT_READ_SIZE, "read size too large");
return hleLogError(Log::ME, SCE_ERROR_ATRAC_INCORRECT_READ_SIZE, "read size too large");
}
AtracBase *atrac = allocAtrac();
int ret = atrac->Analyze(buffer, readSize);
@ -692,9 +693,9 @@ static u32 sceAtracSetLoopNum(int atracID, int loopNum) {
if (atrac->GetTrack().loopinfo.size() == 0) {
if (loopNum == -1) {
// This is very common and not really a problem.
return hleLogDebug(Log::ME, ATRAC_ERROR_NO_LOOP_INFORMATION, "no loop information to write to!");
return hleLogDebug(Log::ME, SCE_ERROR_ATRAC_NO_LOOP_INFORMATION, "no loop information to write to!");
} else {
return hleLogError(Log::ME, ATRAC_ERROR_NO_LOOP_INFORMATION, "no loop information to write to!");
return hleLogError(Log::ME, SCE_ERROR_ATRAC_NO_LOOP_INFORMATION, "no loop information to write to!");
}
}
@ -778,10 +779,10 @@ static int sceAtracSetMOutHalfwayBuffer(int atracID, u32 buffer, u32 readSize, u
AtracBase *atrac = getAtrac(atracID);
// Don't use AtracValidate* here.
if (!atrac) {
return hleLogError(Log::ME, ATRAC_ERROR_BAD_ATRACID, "bad atrac ID");
return hleLogError(Log::ME, SCE_ERROR_ATRAC_BAD_ATRACID, "bad atrac ID");
}
if (readSize > bufferSize) {
return hleLogError(Log::ME, ATRAC_ERROR_INCORRECT_READ_SIZE, "read size too large");
return hleLogError(Log::ME, SCE_ERROR_ATRAC_INCORRECT_READ_SIZE, "read size too large");
}
int ret = atrac->Analyze(buffer, readSize);
@ -792,7 +793,7 @@ static int sceAtracSetMOutHalfwayBuffer(int atracID, u32 buffer, u32 readSize, u
if (atrac->GetTrack().channels != 1) {
// It seems it still sets the data.
atrac->SetData(buffer, readSize, bufferSize, 2, 0);
return hleReportError(Log::ME, ATRAC_ERROR_NOT_MONO, "not mono data");
return hleReportError(Log::ME, SCE_ERROR_ATRAC_NOT_MONO, "not mono data");
} else {
return _AtracSetData(atracID, buffer, readSize, bufferSize, 1, false);
}
@ -803,7 +804,7 @@ static u32 sceAtracSetMOutData(int atracID, u32 buffer, u32 bufferSize) {
AtracBase *atrac = getAtrac(atracID);
// Don't use AtracValidate* here.
if (!atrac) {
return hleLogError(Log::ME, ATRAC_ERROR_BAD_ATRACID, "bad atrac ID");
return hleLogError(Log::ME, SCE_ERROR_ATRAC_BAD_ATRACID, "bad atrac ID");
}
int ret = atrac->Analyze(buffer, bufferSize);
@ -814,7 +815,7 @@ static u32 sceAtracSetMOutData(int atracID, u32 buffer, u32 bufferSize) {
if (atrac->GetTrack().channels != 1) {
// It seems it still sets the data.
atrac->SetData(buffer, bufferSize, bufferSize, 2, 0);
return hleReportError(Log::ME, ATRAC_ERROR_NOT_MONO, "not mono data");
return hleReportError(Log::ME, SCE_ERROR_ATRAC_NOT_MONO, "not mono data");
} else {
return _AtracSetData(atracID, buffer, bufferSize, bufferSize, 1, false);
}
@ -831,7 +832,7 @@ static int sceAtracSetMOutDataAndGetID(u32 buffer, u32 bufferSize) {
}
if (atrac->GetTrack().channels != 1) {
delete atrac;
return hleReportError(Log::ME, ATRAC_ERROR_NOT_MONO, "not mono data");
return hleReportError(Log::ME, SCE_ERROR_ATRAC_NOT_MONO, "not mono data");
}
int atracID = createAtrac(atrac);
if (atracID < 0) {
@ -844,7 +845,7 @@ static int sceAtracSetMOutDataAndGetID(u32 buffer, u32 bufferSize) {
static int sceAtracSetMOutHalfwayBufferAndGetID(u32 buffer, u32 readSize, u32 bufferSize) {
if (readSize > bufferSize) {
return hleLogError(Log::ME, ATRAC_ERROR_INCORRECT_READ_SIZE, "read size too large");
return hleLogError(Log::ME, SCE_ERROR_ATRAC_INCORRECT_READ_SIZE, "read size too large");
}
AtracBase *atrac = allocAtrac();
int ret = atrac->Analyze(buffer, readSize);
@ -855,7 +856,7 @@ static int sceAtracSetMOutHalfwayBufferAndGetID(u32 buffer, u32 readSize, u32 bu
}
if (atrac->GetTrack().channels != 1) {
delete atrac;
return hleReportError(Log::ME, ATRAC_ERROR_NOT_MONO, "not mono data");
return hleReportError(Log::ME, SCE_ERROR_ATRAC_NOT_MONO, "not mono data");
}
int atracID = createAtrac(atrac);
if (atracID < 0) {
@ -927,7 +928,7 @@ static const At3HeaderMap at3HeaderMap[] = {
static int sceAtracLowLevelInitDecoder(int atracID, u32 paramsAddr) {
AtracBase *atrac = getAtrac(atracID);
if (!atrac) {
return hleLogError(Log::ME, ATRAC_ERROR_BAD_ATRACID, "bad atrac ID");
return hleLogError(Log::ME, SCE_ERROR_ATRAC_BAD_ATRACID, "bad atrac ID");
}
if (!Memory::IsValidAddress(paramsAddr)) {
@ -966,7 +967,7 @@ static int sceAtracLowLevelDecode(int atracID, u32 sourceAddr, u32 sourceBytesCo
AtracBase *atrac = getAtrac(atracID);
if (!atrac) {
return hleLogError(Log::ME, ATRAC_ERROR_BAD_ATRACID, "bad atrac ID");
return hleLogError(Log::ME, SCE_ERROR_ATRAC_BAD_ATRACID, "bad atrac ID");
}
if (!srcp.IsValid() || !srcConsumed.IsValid() || !outp.IsValid() || !outWritten.IsValid()) {
@ -988,7 +989,7 @@ static int sceAtracLowLevelDecode(int atracID, u32 sourceAddr, u32 sourceBytesCo
static int sceAtracSetAA3HalfwayBufferAndGetID(u32 buffer, u32 readSize, u32 bufferSize, u32 fileSize) {
if (readSize > bufferSize) {
return hleLogError(Log::ME, ATRAC_ERROR_INCORRECT_READ_SIZE, "read size too large");
return hleLogError(Log::ME, SCE_ERROR_ATRAC_INCORRECT_READ_SIZE, "read size too large");
}
AtracBase *atrac = allocAtrac();

50
Core/HLE/sceKernel.cpp
View file

@ -1398,31 +1398,31 @@ const char *KernelErrorToString(u32 err) {
case SCE_ERROR_PGD_INVALID_HEADER: return "PGD_INVALID_HEADER";
case ATRAC_ERROR_API_FAIL: return "SCE_ERROR_ATRAC_API_FAIL";
case ATRAC_ERROR_NO_ATRACID: return "SCE_ERROR_ATRAC_NO_ATRACID";
case ATRAC_ERROR_INVALID_CODECTYPE: return "SCE_ERROR_ATRAC_INVALID_CODECTYPE";
case ATRAC_ERROR_BAD_ATRACID: return "SCE_ERROR_ATRAC_BAD_ATRACID";
case ATRAC_ERROR_UNKNOWN_FORMAT: return "SCE_ERROR_ATRAC_UNKNOWN_FORMAT";
case ATRAC_ERROR_WRONG_CODECTYPE: return "SCE_ERROR_ATRAC_WRONG_CODECTYPE";
case ATRAC_ERROR_BAD_CODEC_PARAMS: return "SCE_ERROR_ATRAC_BAD_CODEC_PARAMS";
case ATRAC_ERROR_ALL_DATA_LOADED: return "SCE_ERROR_ATRAC_ALL_DATA_LOADED";
case ATRAC_ERROR_NO_DATA: return "SCE_ERROR_ATRAC_NO_DATA";
case ATRAC_ERROR_SIZE_TOO_SMALL: return "SCE_ERROR_ATRAC_SIZE_TOO_SMALL";
case ATRAC_ERROR_SECOND_BUFFER_NEEDED: return "SCE_ERROR_ATRAC_SECOND_BUFFER_NEEDED";
case ATRAC_ERROR_INCORRECT_READ_SIZE: return "SCE_ERROR_ATRAC_INCORRECT_READ_SIZE";
case ATRAC_ERROR_BAD_SAMPLE: return "SCE_ERROR_ATRAC_BAD_SAMPLE";
case ATRAC_ERROR_BAD_FIRST_RESET_SIZE: return "SCE_ERROR_ATRAC_BAD_FIRST_RESET_SIZE";
case ATRAC_ERROR_BAD_SECOND_RESET_SIZE: return "SCE_ERROR_ATRAC_BAD_SECOND_RESET_SIZE";
case ATRAC_ERROR_ADD_DATA_IS_TOO_BIG: return "SCE_ERROR_ATRAC_ADD_DATA_IS_TOO_BIG";
case ATRAC_ERROR_NOT_MONO: return "SCE_ERROR_ATRAC_NOT_MONO";
case ATRAC_ERROR_NO_LOOP_INFORMATION: return "SCE_ERROR_ATRAC_NO_LOOP_INFORMATION";
case ATRAC_ERROR_SECOND_BUFFER_NOT_NEEDED: return "SCE_ERROR_ATRAC_SECOND_BUFFER_NOT_NEEDED";
case ATRAC_ERROR_BUFFER_IS_EMPTY: return "SCE_ERROR_ATRAC_BUFFER_IS_EMPTY";
case ATRAC_ERROR_ALL_DATA_DECODED: return "SCE_ERROR_ATRAC_ALL_DATA_DECODED";
case ATRAC_ERROR_IS_LOW_LEVEL: return "SCE_ERROR_ATRAC_IS_LOW_LEVEL";
case ATRAC_ERROR_IS_FOR_SCESAS: return "SCE_ERROR_ATRAC_IS_FOR_SCESAS";
case ATRAC_ERROR_AA3_INVALID_DATA: return "SCE_ERROR_ATRAC_AA3_INVALID_DATA";
case ATRAC_ERROR_AA3_SIZE_TOO_SMALL: return "SCE_ERROR_ATRAC_AA3_SIZE_TOO_SMALL";
case SCE_ERROR_ATRAC_API_FAIL: return "SCE_ERROR_ATRAC_API_FAIL";
case SCE_ERROR_ATRAC_NO_ATRACID: return "SCE_ERROR_ATRAC_NO_ATRACID";
case SCE_ERROR_ATRAC_INVALID_CODECTYPE: return "SCE_ERROR_ATRAC_INVALID_CODECTYPE";
case SCE_ERROR_ATRAC_BAD_ATRACID: return "SCE_ERROR_ATRAC_BAD_ATRACID";
case SCE_ERROR_ATRAC_UNKNOWN_FORMAT: return "SCE_ERROR_ATRAC_UNKNOWN_FORMAT";
case SCE_ERROR_ATRAC_WRONG_CODECTYPE: return "SCE_ERROR_ATRAC_WRONG_CODECTYPE";
case SCE_ERROR_ATRAC_BAD_CODEC_PARAMS: return "SCE_ERROR_ATRAC_BAD_CODEC_PARAMS";
case SCE_ERROR_ATRAC_ALL_DATA_LOADED: return "SCE_ERROR_ATRAC_ALL_DATA_LOADED";
case SCE_ERROR_ATRAC_NO_DATA: return "SCE_ERROR_ATRAC_NO_DATA";
case SCE_ERROR_ATRAC_SIZE_TOO_SMALL: return "SCE_ERROR_ATRAC_SIZE_TOO_SMALL";
case SCE_ERROR_ATRAC_SECOND_BUFFER_NEEDED: return "SCE_ERROR_ATRAC_SECOND_BUFFER_NEEDED";
case SCE_ERROR_ATRAC_INCORRECT_READ_SIZE: return "SCE_ERROR_ATRAC_INCORRECT_READ_SIZE";
case SCE_ERROR_ATRAC_BAD_SAMPLE: return "SCE_ERROR_ATRAC_BAD_SAMPLE";
case SCE_ERROR_ATRAC_BAD_FIRST_RESET_SIZE: return "SCE_ERROR_ATRAC_BAD_FIRST_RESET_SIZE";
case SCE_ERROR_ATRAC_BAD_SECOND_RESET_SIZE: return "SCE_ERROR_ATRAC_BAD_SECOND_RESET_SIZE";
case SCE_ERROR_ATRAC_ADD_DATA_IS_TOO_BIG: return "SCE_ERROR_ATRAC_ADD_DATA_IS_TOO_BIG";
case SCE_ERROR_ATRAC_NOT_MONO: return "SCE_ERROR_ATRAC_NOT_MONO";
case SCE_ERROR_ATRAC_NO_LOOP_INFORMATION: return "SCE_ERROR_ATRAC_NO_LOOP_INFORMATION";
case SCE_ERROR_ATRAC_SECOND_BUFFER_NOT_NEEDED: return "SCE_ERROR_ATRAC_SECOND_BUFFER_NOT_NEEDED";
case SCE_ERROR_ATRAC_BUFFER_IS_EMPTY: return "SCE_ERROR_ATRAC_BUFFER_IS_EMPTY";
case SCE_ERROR_ATRAC_ALL_DATA_DECODED: return "SCE_ERROR_ATRAC_ALL_DATA_DECODED";
case SCE_ERROR_ATRAC_IS_LOW_LEVEL: return "SCE_ERROR_ATRAC_IS_LOW_LEVEL";
case SCE_ERROR_ATRAC_IS_FOR_SCESAS: return "SCE_ERROR_ATRAC_IS_FOR_SCESAS";
case SCE_ERROR_ATRAC_AA3_INVALID_DATA: return "SCE_ERROR_ATRAC_AA3_INVALID_DATA";
case SCE_ERROR_ATRAC_AA3_SIZE_TOO_SMALL: return "SCE_ERROR_ATRAC_AA3_SIZE_TOO_SMALL";
default:
return nullptr;