diff --git a/Core/Core.vcxproj b/Core/Core.vcxproj
index c38fb0c628da..94f7e4e92abf 100644
--- a/Core/Core.vcxproj
+++ b/Core/Core.vcxproj
@@ -1188,6 +1188,7 @@
+
diff --git a/Core/Core.vcxproj.filters b/Core/Core.vcxproj.filters
index 9771b9d34dae..18d7b6dd6cc6 100644
--- a/Core/Core.vcxproj.filters
+++ b/Core/Core.vcxproj.filters
@@ -2163,6 +2163,9 @@
HLE\Libraries
+
+ HLE
+
diff --git a/Core/HLE/AtracCtx.cpp b/Core/HLE/AtracCtx.cpp
index c867ab94c020..f112ff2347ec 100644
--- a/Core/HLE/AtracCtx.cpp
+++ b/Core/HLE/AtracCtx.cpp
@@ -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::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,16 +726,16 @@ 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 SCE_ERROR_ATRAC_SIZE_TOO_SMALL;
}
if (BufferState() != ATRAC_STATUS_STREAMED_LOOP_WITH_TRAILER) {
- return hleReportError(Log::ME, ATRAC_ERROR_SECOND_BUFFER_NOT_NEEDED, "not needed");
+ return SCE_ERROR_ATRAC_SECOND_BUFFER_NOT_NEEDED;
}
second_.addr = secondBuffer;
second_.size = secondBufferSize;
second_.fileoffset = secondFileOffset;
- return hleLogDebug(Log::ME, 0);
+ return 0;
}
int AtracBase::GetSecondBufferInfo(u32 *fileOffset, u32 *desiredSize) {
@@ -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 SCE_ERROR_ATRAC_ADD_DATA_IS_TOO_BIG;
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.
@@ -1136,7 +1136,7 @@ u32 Atrac::ResetPlayPosition(int sample, int bytesWrittenFirstBuf, int bytesWrit
}
WriteContextToPSPMem();
- return 0;
+ return hleNoLog(0);
}
void Atrac::InitLowLevel(u32 paramsAddr, bool jointStereo) {
diff --git a/Core/HLE/AtracCtx.h b/Core/HLE/AtracCtx.h
index 0212aa088414..c5b90fdf1795 100644
--- a/Core/HLE/AtracCtx.h
+++ b/Core/HLE/AtracCtx.h
@@ -42,32 +42,6 @@ struct AtracResetBufferInfo {
#define PSP_MODE_AT_3_PLUS 0x00001000
#define PSP_MODE_AT_3 0x00001001
-#define ATRAC_ERROR_API_FAIL 0x80630002
-#define ATRAC_ERROR_NO_ATRACID 0x80630003
-#define ATRAC_ERROR_INVALID_CODECTYPE 0x80630004
-#define ATRAC_ERROR_BAD_ATRACID 0x80630005
-#define ATRAC_ERROR_UNKNOWN_FORMAT 0x80630006
-#define ATRAC_ERROR_WRONG_CODECTYPE 0x80630007
-#define ATRAC_ERROR_BAD_CODEC_PARAMS 0x80630008
-#define ATRAC_ERROR_ALL_DATA_LOADED 0x80630009
-#define ATRAC_ERROR_NO_DATA 0x80630010
-#define ATRAC_ERROR_SIZE_TOO_SMALL 0x80630011
-#define ATRAC_ERROR_SECOND_BUFFER_NEEDED 0x80630012
-#define ATRAC_ERROR_INCORRECT_READ_SIZE 0x80630013
-#define ATRAC_ERROR_BAD_SAMPLE 0x80630015
-#define ATRAC_ERROR_BAD_FIRST_RESET_SIZE 0x80630016
-#define ATRAC_ERROR_BAD_SECOND_RESET_SIZE 0x80630017
-#define ATRAC_ERROR_ADD_DATA_IS_TOO_BIG 0x80630018
-#define ATRAC_ERROR_NOT_MONO 0x80630019
-#define ATRAC_ERROR_NO_LOOP_INFORMATION 0x80630021
-#define ATRAC_ERROR_SECOND_BUFFER_NOT_NEEDED 0x80630022
-#define ATRAC_ERROR_BUFFER_IS_EMPTY 0x80630023
-#define ATRAC_ERROR_ALL_DATA_DECODED 0x80630024
-#define ATRAC_ERROR_IS_LOW_LEVEL 0x80630031
-#define ATRAC_ERROR_IS_FOR_SCESAS 0x80630040
-#define ATRAC_ERROR_AA3_INVALID_DATA 0x80631003
-#define ATRAC_ERROR_AA3_SIZE_TOO_SMALL 0x80631004
-
const u32 ATRAC3_MAX_SAMPLES = 0x400;
const u32 ATRAC3PLUS_MAX_SAMPLES = 0x800;
diff --git a/Core/HLE/ErrorCodes.h b/Core/HLE/ErrorCodes.h
index f39bcc4eee6f..3a9b49b6ac36 100644
--- a/Core/HLE/ErrorCodes.h
+++ b/Core/HLE/ErrorCodes.h
@@ -380,4 +380,30 @@ enum : u32 {
SCE_ERROR_MEMSTICK_DEVCTL_TOO_MANY_CALLBACKS = 0x80220082,
SCE_ERROR_PGD_INVALID_HEADER = 0x80510204,
+
+ 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,
};
diff --git a/Core/HLE/sceAtrac.cpp b/Core/HLE/sceAtrac.cpp
index 894ccbce863b..5a7849c5dc76 100644
--- a/Core/HLE/sceAtrac.cpp
+++ b/Core/HLE/sceAtrac.cpp
@@ -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();
@@ -203,27 +203,27 @@ static u32 sceAtracGetAtracID(int codecType) {
return hleLogInfo(Log::ME, atracID);
}
-static u32 AtracValidateData(const AtracBase *atrac) {
+static int AtracValidateData(const AtracBase *atrac) {
if (!atrac) {
- return hleLogError(Log::ME, ATRAC_ERROR_BAD_ATRACID, "bad atrac ID");
+ return SCE_ERROR_ATRAC_BAD_ATRACID;
} else if (atrac->BufferState() == ATRAC_STATUS_NO_DATA) {
- return hleLogError(Log::ME, ATRAC_ERROR_NO_DATA, "no data");
+ return SCE_ERROR_ATRAC_NO_DATA;
} else {
- return hleNoLog(0);
+ return 0;
}
}
-static u32 AtracValidateManaged(const AtracBase *atrac) {
+static int AtracValidateManaged(const AtracBase *atrac) {
if (!atrac) {
- return hleLogError(Log::ME, ATRAC_ERROR_BAD_ATRACID, "bad atrac ID");
+ return SCE_ERROR_ATRAC_BAD_ATRACID;
} else if (atrac->BufferState() == ATRAC_STATUS_NO_DATA) {
- return hleLogError(Log::ME, ATRAC_ERROR_NO_DATA, "no data");
+ return SCE_ERROR_ATRAC_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 SCE_ERROR_ATRAC_IS_LOW_LEVEL;
} else if (atrac->BufferState() == ATRAC_STATUS_FOR_SCESAS) {
- return hleLogError(Log::ME, ATRAC_ERROR_IS_FOR_SCESAS, "SAS stream, can't use");
+ return SCE_ERROR_ATRAC_IS_FOR_SCESAS;
} else {
- return hleNoLog(0);
+ return 0;
}
}
@@ -233,24 +233,20 @@ static u32 AtracValidateManaged(const AtracBase *atrac) {
// The total size of the buffer is atrac->bufferMaxSize_.
static u32 sceAtracAddStreamData(int atracID, u32 bytesToAdd) {
AtracBase *atrac = getAtrac(atracID);
- u32 err = AtracValidateManaged(atrac);
+ int err = AtracValidateManaged(atrac);
if (err != 0) {
- // Already logged.
- return err;
+ return hleLogError(Log::ME, err);
}
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);
- if (ret < 0) {
- return ret;
- }
- return hleLogDebug(Log::ME, 0);
+ return hleLogDebugOrError(Log::ME, ret);
}
// Note that outAddr being null is completely valid here, used to skip data.
@@ -258,15 +254,14 @@ static u32 sceAtracDecodeData(int atracID, u32 outAddr, u32 numSamplesAddr, u32
AtracBase *atrac = getAtrac(atracID);
u32 err = AtracValidateData(atrac);
if (err != 0) {
- // Already logged.
- return err;
+ return hleLogError(Log::ME, err);
}
u32 numSamples = 0;
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))
@@ -299,17 +294,16 @@ static u32 sceAtracGetBufferInfoForResetting(int atracID, int sample, u32 buffer
AtracBase *atrac = getAtrac(atracID);
u32 err = AtracValidateManaged(atrac);
if (err != 0) {
- // Already logged.
- return err;
+ return hleLogError(Log::ME, err);
}
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);
@@ -320,8 +314,7 @@ static u32 sceAtracGetBitrate(int atracID, u32 outBitrateAddr) {
AtracBase *atrac = getAtrac(atracID);
u32 err = AtracValidateData(atrac);
if (err != 0) {
- // Already logged.
- return err;
+ return hleLogError(Log::ME, err);
}
atrac->GetTrackMut().UpdateBitrate();
@@ -338,8 +331,7 @@ static u32 sceAtracGetChannel(int atracID, u32 channelAddr) {
AtracBase *atrac = getAtrac(atracID);
u32 err = AtracValidateData(atrac);
if (err != 0) {
- // Already logged.
- return err;
+ return hleLogError(Log::ME, err);
}
if (Memory::IsValidAddress(channelAddr)){
@@ -354,8 +346,7 @@ static u32 sceAtracGetLoopStatus(int atracID, u32 loopNumAddr, u32 statusAddr) {
AtracBase *atrac = getAtrac(atracID);
u32 err = AtracValidateData(atrac);
if (err != 0) {
- // Already logged.
- return err;
+ return hleLogError(Log::ME, err);
}
if (Memory::IsValidAddress(loopNumAddr))
@@ -376,8 +367,7 @@ static u32 sceAtracGetInternalErrorInfo(int atracID, u32 errorAddr) {
AtracBase *atrac = getAtrac(atracID);
u32 err = AtracValidateData(atrac);
if (err != 0) {
- // Already logged.
- return err;
+ return hleLogError(Log::ME, err);
}
ERROR_LOG(Log::ME, "UNIMPL sceAtracGetInternalErrorInfo(%i, %08x)", atracID, errorAddr);
if (Memory::IsValidAddress(errorAddr))
@@ -389,8 +379,7 @@ static u32 sceAtracGetMaxSample(int atracID, u32 maxSamplesAddr) {
AtracBase *atrac = getAtrac(atracID);
u32 err = AtracValidateData(atrac);
if (err != 0) {
- // Already logged.
- return err;
+ return hleLogError(Log::ME, err);
}
if (Memory::IsValidAddress(maxSamplesAddr)) {
@@ -405,14 +394,13 @@ static u32 sceAtracGetNextDecodePosition(int atracID, u32 outposAddr) {
AtracBase *atrac = getAtrac(atracID);
u32 err = AtracValidateData(atrac);
if (err != 0) {
- // Already logged.
- return err;
+ return hleLogError(Log::ME, err);
}
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);
@@ -426,8 +414,7 @@ static u32 sceAtracGetNextSample(int atracID, u32 outNAddr) {
AtracBase *atrac = getAtrac(atracID);
u32 err = AtracValidateData(atrac);
if (err != 0) {
- // Already logged.
- return err;
+ return hleLogError(Log::ME, err);
}
if (atrac->CurrentSample() >= atrac->GetTrack().endSample) {
if (Memory::IsValidAddress(outNAddr))
@@ -450,8 +437,7 @@ static u32 sceAtracGetRemainFrame(int atracID, u32 remainAddr) {
AtracBase *atrac = getAtrac(atracID);
u32 err = AtracValidateManaged(atrac);
if (err != 0) {
- // Already logged.
- return err;
+ return hleLogError(Log::ME, err);
}
if (!remainingFrames.IsValid()) {
@@ -470,8 +456,7 @@ static u32 sceAtracGetSecondBufferInfo(int atracID, u32 fileOffsetAddr, u32 desi
AtracBase *atrac = getAtrac(atracID);
u32 err = AtracValidateManaged(atrac);
if (err != 0) {
- // Already logged.
- return err;
+ return hleLogError(Log::ME, err);
}
if (!fileOffset.IsValid() || !desiredSize.IsValid()) {
@@ -486,8 +471,7 @@ static u32 sceAtracGetSoundSample(int atracID, u32 outEndSampleAddr, u32 outLoop
AtracBase *atrac = getAtrac(atracID);
u32 err = AtracValidateManaged(atrac);
if (err != 0) {
- // Already logged.
- return err;
+ return hleLogError(Log::ME, err);
}
auto outEndSample = PSPPointer::Create(outEndSampleAddr);
@@ -513,8 +497,7 @@ static u32 sceAtracGetStreamDataInfo(int atracID, u32 writePtrAddr, u32 writable
AtracBase *atrac = getAtrac(atracID);
u32 err = AtracValidateManaged(atrac);
if (err != 0) {
- // Already logged.
- return err;
+ return hleLogError(Log::ME, err);
}
u32 writePtr;
@@ -551,15 +534,14 @@ static u32 sceAtracResetPlayPosition(int atracID, int sample, int bytesWrittenFi
AtracBase *atrac = getAtrac(atracID);
u32 err = AtracValidateManaged(atrac);
if (err != 0) {
- // Already logged.
- return err;
+ return hleLogError(Log::ME, err);
}
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 +557,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 +570,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);
@@ -607,17 +590,16 @@ static u32 sceAtracSetSecondBuffer(int atracID, u32 secondBuffer, u32 secondBuff
AtracBase *atrac = getAtrac(atracID);
u32 err = AtracValidateManaged(atrac);
if (err != 0) {
- // Already logged.
- return err;
+ return hleLogError(Log::ME, err);
}
- return atrac->SetSecondBuffer(secondBuffer, secondBufferSize);
+ return hleLogDebugOrError(Log::ME, atrac->SetSecondBuffer(secondBuffer, secondBufferSize));
}
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 +610,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 +642,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);
@@ -686,15 +668,14 @@ static u32 sceAtracSetLoopNum(int atracID, int loopNum) {
AtracBase *atrac = getAtrac(atracID);
u32 err = AtracValidateData(atrac);
if (err != 0) {
- // Already logged.
- return err;
+ return hleLogError(Log::ME, err);
}
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!");
}
}
@@ -750,8 +731,7 @@ static int sceAtracGetOutputChannel(int atracID, u32 outputChanPtr) {
AtracBase *atrac = getAtrac(atracID);
u32 err = AtracValidateData(atrac);
if (err != 0) {
- // Already logged.
- return err;
+ return hleLogError(Log::ME, err);
}
if (Memory::IsValidAddress(outputChanPtr)) {
Memory::WriteUnchecked_U32(atrac->GetOutputChannels(), outputChanPtr);
@@ -765,8 +745,7 @@ static int sceAtracIsSecondBufferNeeded(int atracID) {
AtracBase *atrac = getAtrac(atracID);
u32 err = AtracValidateManaged(atrac);
if (err != 0) {
- // Already logged.
- return err;
+ return hleLogError(Log::ME, err);
}
// Note that this returns true whether the buffer is already set or not.
@@ -778,10 +757,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 +771,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 +782,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 +793,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 +810,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 +823,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 +834,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 +906,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 +945,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 +967,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();
diff --git a/Core/HLE/sceKernel.cpp b/Core/HLE/sceKernel.cpp
index 6185f39d0383..f227b272c982 100644
--- a/Core/HLE/sceKernel.cpp
+++ b/Core/HLE/sceKernel.cpp
@@ -1398,6 +1398,32 @@ const char *KernelErrorToString(u32 err) {
case SCE_ERROR_PGD_INVALID_HEADER: return "PGD_INVALID_HEADER";
+ 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;
}