feat(ajm): parse the original file length in sceAjmDecMp3ParseFrame
Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
Adrià Franch
parent
bc24783e5b
commit
fc96f96ac5
|
|
@ -492,6 +492,134 @@ bool ParseMp3Frame(const std::uint8_t* data, std::size_t size, Mp3Frame& frame)
|
|||
return true;
|
||||
}
|
||||
|
||||
constexpr std::uint32_t MP3_OFL_NONE = 0;
|
||||
constexpr std::uint32_t MP3_OFL_LAME = 1;
|
||||
constexpr std::uint32_t MP3_OFL_VBRI = 2;
|
||||
constexpr std::uint32_t MP3_OFL_FGH = 3;
|
||||
constexpr std::uint32_t MP3_OFL_VBRI_AND_FGH = 4;
|
||||
|
||||
std::uint32_t ReadBigEndian(const std::uint8_t* data, std::size_t bytes) {
|
||||
std::uint32_t value = 0;
|
||||
for (std::size_t i = 0; i < bytes; ++i) value = (value << 8u) | data[i];
|
||||
return value;
|
||||
}
|
||||
|
||||
int ParseMp3Header(const std::uint8_t* stream, std::uint32_t streamSize, int parseOfl, AjmDecMp3ParseFrame* frame);
|
||||
|
||||
void ParseMp3Ofl(const std::uint8_t* stream, std::uint32_t streamSize, std::uint32_t header, AjmDecMp3ParseFrame* frame) {
|
||||
const std::size_t end = std::min<std::size_t>(streamSize, frame->frame_size);
|
||||
if (end <= 4) return;
|
||||
const std::size_t available = end - 4;
|
||||
std::size_t bit = 0;
|
||||
const auto readBits = [&](std::uint32_t count) {
|
||||
std::uint32_t value = 0;
|
||||
for (std::uint32_t i = 0; i < count; ++i, ++bit) value = (value << 1u) | (bit / 8 < available ? (stream[4 + bit / 8] >> (7 - bit % 8)) & 1u : 0u);
|
||||
return value;
|
||||
};
|
||||
const bool mpeg1 = ((header >> 19u) & 3u) == 3u;
|
||||
const bool mono = ((header >> 6u) & 3u) == 3u;
|
||||
bit += mpeg1 ? (mono ? 18 : 20) : (mono ? 9 : 10);
|
||||
std::uint32_t mainDataBits = 0;
|
||||
for (std::uint32_t granule = 0; granule < (mpeg1 ? 2u : 1u); ++granule) {
|
||||
for (std::uint32_t channel = 0; channel < frame->num_channels; ++channel) {
|
||||
mainDataBits += readBits(12);
|
||||
bit += mpeg1 ? 47 : 51;
|
||||
}
|
||||
}
|
||||
bit += mainDataBits;
|
||||
std::size_t at = 4 + std::min<std::size_t>((bit + 7) / 8, available);
|
||||
|
||||
if (at + 8 <= end && (std::memcmp(stream + at, "Xing", 4) == 0 || std::memcmp(stream + at, "Info", 4) == 0)) {
|
||||
const std::uint8_t flags = stream[at + 7];
|
||||
std::size_t field = at + 8;
|
||||
std::uint32_t frames = 0;
|
||||
if (flags & 0x01u) {
|
||||
if (field + 4 > end) return;
|
||||
frames = ReadBigEndian(stream + field, 4);
|
||||
frame->num_frames = frames;
|
||||
field += 4;
|
||||
}
|
||||
if (flags & 0x02u) {
|
||||
field += 4;
|
||||
if (field > end) return;
|
||||
}
|
||||
if (flags & 0x04u) {
|
||||
field += 100;
|
||||
if (field > end) return;
|
||||
}
|
||||
if (flags & 0x08u) {
|
||||
field += 4;
|
||||
if (field > end) return;
|
||||
}
|
||||
if (field + 0x18 <= end && std::memcmp(stream + field, "LAME", 4) == 0) {
|
||||
const std::uint32_t delay = (std::uint32_t{stream[field + 0x15]} << 4u) | (stream[field + 0x16] >> 4u);
|
||||
const std::uint32_t padding = ((std::uint32_t{stream[field + 0x16]} & 0x0Fu) << 8u) | stream[field + 0x17];
|
||||
if ((flags & 0x01u) && frames > 0) frame->total_samples = frames * frame->samples_per_channel - (delay + padding);
|
||||
frame->encoder_delay = frame->samples_per_channel + delay + 529;
|
||||
frame->ofl_type = MP3_OFL_LAME;
|
||||
}
|
||||
} else if (at != 36 && end >= 40 && std::memcmp(stream + 36, "VBRI", 4) == 0) {
|
||||
NotImplemented_nid_no_patch("sceAjmDecMp3ParseFrame (VBRI header outside MPEG-1 stereo)");
|
||||
} else if (at + 26 <= end && std::memcmp(stream + at, "VBRI", 4) == 0) {
|
||||
frame->encoder_delay = ReadBigEndian(stream + at + 6, 2);
|
||||
frame->ofl_type = MP3_OFL_VBRI;
|
||||
if (frame->frame_size <= streamSize) {
|
||||
AjmDecMp3ParseFrame next{};
|
||||
if (ParseMp3Header(stream + frame->frame_size, streamSize - static_cast<std::uint32_t>(frame->frame_size), 1, &next) == 0 && next.ofl_type == MP3_OFL_FGH) {
|
||||
frame->encoder_delay += next.encoder_delay;
|
||||
frame->total_samples = next.total_samples;
|
||||
frame->ofl_type = MP3_OFL_VBRI_AND_FGH;
|
||||
}
|
||||
}
|
||||
} else if (at + 10 <= end) {
|
||||
while (at + 9 < end && stream[at] != 0xB4u) ++at;
|
||||
if (at + 9 >= end) return;
|
||||
std::uint8_t crc = 0xFF;
|
||||
for (std::size_t i = 0; i < 9; ++i) {
|
||||
for (int shift = 7; shift >= 0; --shift) {
|
||||
const bool same = ((crc >> 7u) & 1u) == ((stream[at + i] >> shift) & 1u);
|
||||
crc = static_cast<std::uint8_t>(same ? (crc << 1u) ^ 0x45u : crc << 1u);
|
||||
}
|
||||
}
|
||||
if (stream[at + 9] != crc) return;
|
||||
frame->encoder_delay = ReadBigEndian(stream + at + 1, 2);
|
||||
frame->total_samples = ReadBigEndian(stream + at + 3, 4);
|
||||
frame->ofl_type = MP3_OFL_FGH;
|
||||
}
|
||||
}
|
||||
|
||||
int ParseMp3Header(const std::uint8_t* stream, std::uint32_t streamSize, int parseOfl, AjmDecMp3ParseFrame* frame) {
|
||||
if (!stream || streamSize < 4 || !frame) return SCE_AJM_ERROR_INVALID_PARAMETER;
|
||||
static constexpr std::uint32_t sampleRates[4][4] = {{11025, 12000, 8000, 0}, {0, 0, 0, 0}, {22050, 24000, 16000, 0}, {44100, 48000, 32000, 0}};
|
||||
static constexpr std::uint32_t kbps[4][16] = {
|
||||
{0, 8, 16, 24, 32, 40, 48, 56, 64, 0, 0, 0, 0, 0, 0, 0},
|
||||
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
|
||||
{0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, 0},
|
||||
{0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 0},
|
||||
};
|
||||
const std::uint32_t header = (std::uint32_t{stream[0]} << 24u) | (std::uint32_t{stream[1]} << 16u) | (std::uint32_t{stream[2]} << 8u) | stream[3];
|
||||
const std::uint32_t version = (header >> 19u) & 3u;
|
||||
const std::uint32_t sampleRate = sampleRates[version][(header >> 10u) & 3u];
|
||||
const std::uint32_t bitrate = kbps[version][(header >> 12u) & 15u] * 1000u;
|
||||
const bool valid = (header >> 21u) == 0x7FFu && sampleRate != 0 && bitrate != 0;
|
||||
AJM_TRACE("[ajm] parse mp3 frame %02x %02x %02x %02x (%u bytes, parse ofl %d) -> %s, %u Hz, %u bps\n", stream[0], stream[1], stream[2], stream[3], streamSize, parseOfl, valid ? "ok" : "invalid", sampleRate, bitrate);
|
||||
if (!valid) return SCE_AJM_ERROR_INVALID_PARAMETER;
|
||||
if (parseOfl && ((header >> 17u) & 3u) != 1u) NotImplemented_nid_no_patch("sceAjmDecMp3ParseFrame (original file length lookup outside layer III)");
|
||||
if (parseOfl && ((header >> 16u) & 1u) == 0) NotImplemented_nid_no_patch("sceAjmDecMp3ParseFrame (original file length lookup in a CRC-protected frame)");
|
||||
const bool mpeg1 = version == 3;
|
||||
frame->frame_size = (mpeg1 ? 144u : 72u) * bitrate / sampleRate + ((header >> 9u) & 1u);
|
||||
frame->num_channels = ((header >> 6u) & 3u) == 3u ? 1u : 2u;
|
||||
frame->samples_per_channel = mpeg1 ? 1152u : 576u;
|
||||
frame->bitrate = bitrate;
|
||||
frame->sample_rate = sampleRate;
|
||||
frame->encoder_delay = 0;
|
||||
frame->num_frames = 0;
|
||||
frame->total_samples = 0;
|
||||
frame->ofl_type = MP3_OFL_NONE;
|
||||
if (parseOfl) ParseMp3Ofl(stream, streamSize, header, frame);
|
||||
return 0;
|
||||
}
|
||||
|
||||
void OpenMp3(Instance& instance) {
|
||||
static const bool quiet = (av_log_set_level(TraceEnabled() ? AV_LOG_WARNING : AV_LOG_QUIET), true);
|
||||
(void)quiet;
|
||||
|
|
@ -870,33 +998,7 @@ int APS5_VABI sceAjmDecAt9ParseConfigData(const void* config_data, AjmDecAt9Conf
|
|||
}
|
||||
|
||||
int APS5_VABI sceAjmDecMp3ParseFrame(const uint8_t* stream, uint32_t streamSize, int parseOfl, AjmDecMp3ParseFrame* frame) {
|
||||
if (!stream || streamSize < 4 || !frame) return SCE_AJM_ERROR_INVALID_PARAMETER;
|
||||
static constexpr std::uint32_t sampleRates[4][4] = {{11025, 12000, 8000, 0}, {0, 0, 0, 0}, {22050, 24000, 16000, 0}, {44100, 48000, 32000, 0}};
|
||||
static constexpr std::uint32_t kbps[4][16] = {
|
||||
{0, 8, 16, 24, 32, 40, 48, 56, 64, 0, 0, 0, 0, 0, 0, 0},
|
||||
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
|
||||
{0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, 0},
|
||||
{0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 0},
|
||||
};
|
||||
const std::uint32_t header = (std::uint32_t{stream[0]} << 24u) | (std::uint32_t{stream[1]} << 16u) | (std::uint32_t{stream[2]} << 8u) | stream[3];
|
||||
const std::uint32_t version = (header >> 19u) & 3u;
|
||||
const std::uint32_t sampleRate = sampleRates[version][(header >> 10u) & 3u];
|
||||
const std::uint32_t bitrate = kbps[version][(header >> 12u) & 15u] * 1000u;
|
||||
const bool valid = (header >> 21u) == 0x7FFu && sampleRate != 0 && bitrate != 0;
|
||||
AJM_TRACE("[ajm] parse mp3 frame %02x %02x %02x %02x (%u bytes, parse ofl %d) -> %s, %u Hz, %u bps\n", stream[0], stream[1], stream[2], stream[3], streamSize, parseOfl, valid ? "ok" : "invalid", sampleRate, bitrate);
|
||||
if (!valid) return SCE_AJM_ERROR_INVALID_PARAMETER;
|
||||
if (parseOfl) NotImplemented_nid_no_patch("sceAjmDecMp3ParseFrame (original file length lookup)");
|
||||
const bool mpeg1 = version == 3;
|
||||
frame->frame_size = (mpeg1 ? 144u : 72u) * bitrate / sampleRate + ((header >> 9u) & 1u);
|
||||
frame->num_channels = ((header >> 6u) & 3u) == 3u ? 1u : 2u;
|
||||
frame->samples_per_channel = mpeg1 ? 1152u : 576u;
|
||||
frame->bitrate = bitrate;
|
||||
frame->sample_rate = sampleRate;
|
||||
frame->encoder_delay = 0;
|
||||
frame->num_frames = 0;
|
||||
frame->total_samples = 0;
|
||||
frame->ofl_type = 0;
|
||||
return 0;
|
||||
return ParseMp3Header(stream, streamSize, parseOfl, frame);
|
||||
}
|
||||
|
||||
int APS5_VABI sceAjmBatchInitialize(void* buffer, size_t size, AjmBatchInfo* info) {
|
||||
|
|
|
|||
|
|
@ -201,6 +201,111 @@ void TestMp3ParseFrame() {
|
|||
Require(sceAjmDecMp3ParseFrame(mpeg25Above64Kbps, 4, 0, &frame) == invalidParameter);
|
||||
}
|
||||
|
||||
const std::uint8_t LAME_MPEG1_STEREO_VBR[] = {
|
||||
0xFF, 0xFB, 0x90, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x58, 0x69, 0x6E, 0x67, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x0A,
|
||||
0x00, 0x00, 0x09, 0x28, 0x00, 0x53, 0x53, 0x53, 0x53, 0x53, 0x53, 0x53, 0x53, 0x53, 0x6E, 0x6E, 0x6E, 0x6E, 0x6E, 0x6E, 0x6E, 0x6E, 0x6E, 0x6E,
|
||||
0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x8D, 0x8D, 0x8D, 0x8D, 0x8D, 0x8D, 0x8D, 0x8D, 0x8D, 0x8D, 0x9F, 0x9F, 0x9F, 0x9F,
|
||||
0x9F, 0x9F, 0x9F, 0x9F, 0x9F, 0x9F, 0xAC, 0xAC, 0xAC, 0xAC, 0xAC, 0xAC, 0xAC, 0xAC, 0xAC, 0xAC, 0xBE, 0xBE, 0xBE, 0xBE, 0xBE, 0xBE, 0xBE, 0xBE,
|
||||
0xBE, 0xBE, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xDD, 0xDD, 0xDD, 0xDD, 0xDD, 0xDD, 0xDD, 0xDD, 0xDD, 0xDD, 0xFF, 0xFF,
|
||||
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x0A, 0x4C, 0x41, 0x4D, 0x45, 0x34, 0x2E, 0x30, 0x20, 0x00, 0x04, 0x48, 0x00,
|
||||
0x00, 0x00, 0x00, 0x2E, 0x1A, 0x00, 0x00, 0x15, 0x20, 0x24, 0x03, 0xB0, 0x45, 0x00, 0x01, 0x9A, 0x00, 0x00, 0x09, 0x28, 0x06, 0x5C, 0x53, 0xC5,
|
||||
};
|
||||
|
||||
const std::uint8_t LAME_MPEG1_MONO_CBR[] = {
|
||||
0xFF, 0xFB, 0x98, 0xC4, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x49, 0x6E, 0x66,
|
||||
0x6F, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x18, 0xC0, 0x00, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x33,
|
||||
0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x4C, 0x4C, 0x4C, 0x4C, 0x4C, 0x4C, 0x4C, 0x4C, 0x4C, 0x4C, 0x66, 0x66, 0x66, 0x66, 0x66,
|
||||
0x66, 0x66, 0x66, 0x66, 0x66, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,
|
||||
0x99, 0xB3, 0xB3, 0xB3, 0xB3, 0xB3, 0xB3, 0xB3, 0xB3, 0xB3, 0xB3, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xE6, 0xE6, 0xE6,
|
||||
0xE6, 0xE6, 0xE6, 0xE6, 0xE6, 0xE6, 0xE6, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x38, 0x4C, 0x41, 0x4D,
|
||||
0x45, 0x34, 0x2E, 0x30, 0x20, 0x00, 0x01, 0xA0, 0x00, 0x00, 0x00, 0x00, 0x2E, 0x15, 0x00, 0x00, 0x14, 0x80, 0x24, 0x03, 0xB0, 0x22, 0x00, 0x00,
|
||||
0x80, 0x00, 0x00, 0x18, 0xC0, 0x9A, 0x66, 0xF0, 0x95,
|
||||
};
|
||||
|
||||
const std::uint8_t LAME_MPEG2_MONO_CBR[] = {
|
||||
0xFF, 0xF3, 0x80, 0xC4, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x49, 0x6E, 0x66, 0x6F, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00,
|
||||
0x14, 0x00, 0x00, 0x11, 0x23, 0x00, 0x0C, 0x0C, 0x0C, 0x0C, 0x19, 0x19, 0x19, 0x19, 0x19, 0x26, 0x26, 0x26, 0x26, 0x26, 0x33, 0x33, 0x33, 0x33,
|
||||
0x33, 0x40, 0x40, 0x40, 0x40, 0x40, 0x4C, 0x4C, 0x4C, 0x4C, 0x4C, 0x59, 0x59, 0x59, 0x59, 0x59, 0x66, 0x66, 0x66, 0x66, 0x66, 0x73, 0x73, 0x73,
|
||||
0x73, 0x73, 0x80, 0x80, 0x80, 0x80, 0x80, 0x8C, 0x8C, 0x8C, 0x8C, 0x8C, 0x99, 0x99, 0x99, 0x99, 0x99, 0xA6, 0xA6, 0xA6, 0xA6, 0xA6, 0xB3, 0xB3,
|
||||
0xB3, 0xB3, 0xB3, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xD9, 0xD9, 0xD9, 0xD9, 0xD9, 0xE6, 0xE6, 0xE6, 0xE6, 0xE6, 0xF3,
|
||||
0xF3, 0xF3, 0xF3, 0xF3, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x38, 0x4C, 0x41, 0x4D, 0x45, 0x34, 0x2E, 0x30, 0x20, 0x00, 0x01, 0x6E,
|
||||
0x00, 0x00, 0x00, 0x00, 0x2E, 0x1E, 0x00, 0x00, 0x14, 0x40, 0x24, 0x03, 0xB0, 0x22, 0x00, 0x00, 0x40, 0x00, 0x00, 0x11, 0x23, 0xF6, 0xE8, 0xE2,
|
||||
0xEB,
|
||||
};
|
||||
|
||||
const std::uint8_t FGH_FRAME[] = {
|
||||
0xFF, 0xFB, 0x90, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xB4, 0x04, 0x51, 0x00, 0x06, 0xBA, 0xA8, 0x00, 0x00, 0xA0,
|
||||
};
|
||||
|
||||
const std::uint8_t VBRI_FRAME[] = {
|
||||
0xFF, 0xFB, 0x90, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x56, 0x42, 0x52, 0x49, 0x00, 0x01, 0x02, 0x40, 0x00, 0x4B, 0x00, 0x00,
|
||||
0x10, 0x4A, 0x00, 0x00, 0x00, 0x0A,
|
||||
};
|
||||
|
||||
const std::uint8_t FGH_BAD_CRC_FRAME[] = {
|
||||
0xFF, 0xFB, 0x90, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xB4, 0x04, 0x51, 0x00, 0x06, 0xBA, 0xA8, 0x00, 0x00, 0xA1,
|
||||
};
|
||||
|
||||
std::vector<std::uint8_t> Mp3Frame(const std::uint8_t* prefix, std::size_t prefixSize, std::size_t frameSize) {
|
||||
std::vector<std::uint8_t> frame(frameSize, 0);
|
||||
std::memcpy(frame.data(), prefix, prefixSize);
|
||||
return frame;
|
||||
}
|
||||
|
||||
bool OflParsesTo(const std::vector<std::uint8_t>& stream, std::uint32_t streamSize, std::uint32_t frames, std::uint32_t delay, std::uint32_t total, std::uint32_t type) {
|
||||
AjmDecMp3ParseFrame frame;
|
||||
std::memset(&frame, 0xFF, sizeof(frame));
|
||||
if (sceAjmDecMp3ParseFrame(stream.data(), streamSize, 1, &frame) != 0) return false;
|
||||
return frame.num_frames == frames && frame.encoder_delay == delay && frame.total_samples == total && frame.ofl_type == type;
|
||||
}
|
||||
|
||||
bool OflThrows(const std::vector<std::uint8_t>& stream) {
|
||||
AjmDecMp3ParseFrame frame{};
|
||||
try {
|
||||
sceAjmDecMp3ParseFrame(stream.data(), static_cast<std::uint32_t>(stream.size()), 1, &frame);
|
||||
} catch (const std::runtime_error&) {
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
void TestMp3ParseOfl() {
|
||||
const auto stereo = Mp3Frame(LAME_MPEG1_STEREO_VBR, sizeof(LAME_MPEG1_STEREO_VBR), 417);
|
||||
Require(OflParsesTo(stereo, 417, 10, 1152 + 576 + 529, 10000, 1));
|
||||
Require(ParsesTo(stereo.data(), 417, 417, 2, 1152, 128000, 44100));
|
||||
Require(OflParsesTo(stereo, 48, 10, 0, 0, 0));
|
||||
Require(OflParsesTo(stereo, 46, 0, 0, 0, 0));
|
||||
const auto mono = Mp3Frame(LAME_MPEG1_MONO_CBR, sizeof(LAME_MPEG1_MONO_CBR), 576);
|
||||
Require(OflParsesTo(mono, 576, 10, 1152 + 576 + 529, 10000, 1));
|
||||
const auto mpeg2 = Mp3Frame(LAME_MPEG2_MONO_CBR, sizeof(LAME_MPEG2_MONO_CBR), 208);
|
||||
Require(OflParsesTo(mpeg2, 208, 20, 576 + 576 + 529, 10000, 1));
|
||||
|
||||
const auto fgh = Mp3Frame(FGH_FRAME, sizeof(FGH_FRAME), 417);
|
||||
Require(OflParsesTo(fgh, 417, 0, 1105, 441000, 3));
|
||||
Require(OflParsesTo(Mp3Frame(FGH_BAD_CRC_FRAME, sizeof(FGH_BAD_CRC_FRAME), 417), 417, 0, 0, 0, 0));
|
||||
auto vbri = Mp3Frame(VBRI_FRAME, sizeof(VBRI_FRAME), 417);
|
||||
Require(OflParsesTo(vbri, 417, 0, 576, 0, 2));
|
||||
vbri.insert(vbri.end(), fgh.begin(), fgh.end());
|
||||
Require(OflParsesTo(vbri, 834, 0, 576 + 1105, 441000, 4));
|
||||
Require(OflParsesTo(vbri, 480, 0, 576, 0, 2));
|
||||
|
||||
auto protectedFrame = stereo;
|
||||
protectedFrame[1] = 0xFA;
|
||||
Require(OflThrows(protectedFrame));
|
||||
auto layer2 = stereo;
|
||||
layer2[1] = 0xFD;
|
||||
Require(OflThrows(layer2));
|
||||
auto monoVbri = Mp3Frame(VBRI_FRAME, sizeof(VBRI_FRAME), 417);
|
||||
monoVbri[3] = 0xC4;
|
||||
Require(OflThrows(monoVbri));
|
||||
}
|
||||
|
||||
struct GaplessDecode {
|
||||
std::uint32_t totalSamples;
|
||||
std::uint16_t skipSamples;
|
||||
|
|
@ -356,6 +461,7 @@ int main() {
|
|||
Require(sceAjmDecAt9ParseConfigData(badHeader, &info) == invalidParameter);
|
||||
Require(sceAjmDecAt9ParseConfigData(nullptr, &info) == invalidParameter);
|
||||
TestMp3ParseFrame();
|
||||
TestMp3ParseOfl();
|
||||
TestMp3(context);
|
||||
TestOpus(context);
|
||||
TestDecodeSingle(context);
|
||||
|
|
|
|||
|
|
@ -75,7 +75,7 @@ Throughout the project, every function at every stage either **does exactly what
|
|||
- [sceAvPlayerInit / sceAvPlayerInitEx](../../core/libs/prx/libSceAvPlayer/src/Player.cpp) (libSceAvPlayer) - behaviour without a memory replacement unknown; frame and sample buffers then come from the guest heap
|
||||
- [SceAvPlayerVideoEx](../../core/libs/SceTypes.hpp) (libSceAvPlayer) - frame rate field and encoding unknown; it is left zero in frame and stream info
|
||||
- [sceRazorCpuPushMarkerStatic, sceRazorCpuPopMarker](../../core/libs/prx/libSceRazorCpu/Export.cpp) (libSceRazorCpu) - signatures from PPSA26344's calls; (name, color, flags) assumed for the push; both do nothing without a capture
|
||||
- [sceAjmDecMp3ParseFrame](../../core/libs/prx/libSceAjm.native/src/Ajm.cpp) (libSceAjm.native) - signature, result layout and rate tables taken from the [shadPS4](https://github.com/shadps4-emu/shadPS4) reimplementation of the PS4 library, not confirmed on a PS5 title: the layer field is not checked and MPEG-2.5 stops at 64 kbps
|
||||
- [sceAjmDecMp3ParseFrame](../../core/libs/prx/libSceAjm.native/src/Ajm.cpp) (libSceAjm.native) - signature, result layout and rate tables taken from the [shadPS4](https://github.com/shadps4-emu/shadPS4) reimplementation of the PS4 library, not confirmed on a PS5 title: the layer field is not checked and MPEG-2.5 stops at 64 kbps; the original file length (`parse_ofl`) layout (Xing/Info + LAME tag, VBRI, Fraunhofer `0xB4` block with its CRC, encoder delay = samples per frame + LAME delay + 529) also comes from shadPS4 only, and the Fraunhofer block has no other public description
|
||||
- [sceAjmBatchJobGetCodecInfo, sceAjmBatchJobGetGaplessDecode](../../core/libs/prx/libSceAjm.native/src/Ajm.cpp) (libSceAjm.native) - the `RUN_GET_CODEC_INFO` flag (0x800), the ATRAC9 codec info layout and its next frame size are taken from the [shadPS4](https://github.com/shadps4-emu/shadPS4) and [RPCSX](https://github.com/RPCSX/rpcsx) reimplementations, not confirmed on a PS5 title; a run job without buffers returns result 0, as in shadPS4. The gapless sideband reports the total and skip counts the title set and does not count them down: RPCSX does the same, shadPS4 counts them down and BryKytyPS5 returns its current counts
|
||||
- [AJM Opus decoder](../../core/libs/prx/libSceAjm.native/src/Ajm.cpp) (libSceAjm.native, codec 24) - the initialize parameter layout (`u32 channels, u32 sample rate, u32`, seen as `2, 48000, 0`) and the little-endian `u16` byte count before each packet come from one title (The Smurfs Dreams); only 48000 Hz and a zero third word are accepted
|
||||
- [sceHttpParseResponseHeader](../../core/libs/prx/libSceHttp/Export.cpp) (libSceHttp) - unknown signature
|
||||
|
|
@ -121,7 +121,7 @@ Throughout the project, every function at every stage either **does exactly what
|
|||
- [sceKeyboardGetKey2Char](../../core/libs/prx/libSceKeyboard/src/keyboard_impl.cpp) (libSceKeyboard) translates only the 101-key (US) arrangement and throws for the 106-key (Japanese) one; Ctrl and Alt do not change the character.
|
||||
- [sceAudioOut2Set3DLatency](../../core/libs/prx/libSceAudioOut/src/AudioOut2System.cpp) and [sceAudioOut2MasteringInit](../../core/libs/prx/libSceAudioOut/src/AudioOut2Mastering.cpp) (libSceAudioOut) have no effect: there is no 3D rendering or mastering stage.
|
||||
- [libSceAudiodec](../../core/libs/prx/libSceAudiodec/Export.cpp) throws for the 24-bit PCM word size (`iBwPcm` 0): its sample layout is unknown. ATRAC9 decoding is covered only by configuration and error tests, as no ATRAC9 encoder is available for a fixture.
|
||||
- [sceAjmDecMp3ParseFrame](../../core/libs/prx/libSceAjm.native/src/Ajm.cpp) (libSceAjm.native) throws when the original file length is requested (`parse_ofl` non-zero): reading it from the frame's Xing/Info, VBRI or Fraunhofer data is not implemented.
|
||||
- [sceAjmDecMp3ParseFrame](../../core/libs/prx/libSceAjm.native/src/Ajm.cpp) (libSceAjm.native) throws when the original file length is requested (`parse_ofl` non-zero) for a layer other than III, for a CRC-protected frame, or for a VBRI header outside MPEG-1 stereo: shadPS4 looks for the tag after the CRC and after the side information, while LAME and FFmpeg place it without the CRC and VBRI always at byte 36.
|
||||
- The [output modifier](../../core/shader/recompiler/Translation/src/TranslationContext/OperandAccess.cpp) (`mul:2`, `mul:4`, `div:2`) follows the hardware with the IEEE mode off and f32 denormals flushed, the LLVM graphics default; the shader's MODE register is not read, and the hardware ignores the modifier in the other modes. On f16 results it is ignored, as on the hardware while f16 denormals are enabled; with them flushed the hardware applies it.
|
||||
- [libScePlayerInvitationDialog](../../core/libs/prx/libScePlayerInvitationDialog/libScePlayerInvitationDialog.cpp) simulates dialog completion without displaying UI or sending invitations; its parameter ABI remains unverified.
|
||||
- [64-bit LDS atomics](../../core/shader/recompiler/SpirvBackend/src/SpirvMemory/SpirvMemoryInstructions.cpp) (`ds_*_u64`, `ds_*_b64`, `ds_*_f64`) read and write the two dwords under a workgroup lock stored after the guest LDS, as LDS is a 32-bit array without 64-bit atomics. They are atomic with respect to each other only: 32-bit accesses to the same dwords issued concurrently are not ordered by the lock. 64-bit GDS atomics throw. `ds_min/max(_rtn)_f64` and `ds_cmpst(_rtn)_f64` follow the NaN and signed-zero rules measured for the f32 forms; the f64 forms were not measured on hardware.
|
||||
|
|
|
|||
Loading…
Reference in New Issue