mirror of
https://github.com/hrydgard/ppsspp.git
synced 2026-11-17 03:14:34 +01:00
Merge pull request #20256 from hrydgard/misc-fixes
Minor debugger fixes
This commit is contained in:
6 files changed
+93
-79
No files matched your search
+16
-10
@@ -111,8 +111,8 @@ void __AudioInit() {
|
||||
CoreTiming::ScheduleEvent(audioIntervalCycles, eventAudioUpdate, 0);
|
||||
CoreTiming::ScheduleEvent(audioHostIntervalCycles, eventHostAudioUpdate, 0);
|
||||
for (u32 i = 0; i < PSP_AUDIO_CHANNEL_MAX + 1; i++) {
|
||||
chans[i].index = i;
|
||||
chans[i].clear();
|
||||
g_audioChans[i].index = i;
|
||||
g_audioChans[i].clear();
|
||||
}
|
||||
|
||||
mixBuffer = new s32[hwBlockSize * 2];
|
||||
@@ -156,17 +156,17 @@ void __AudioDoState(PointerWrap &p) {
|
||||
System_AudioClear();
|
||||
}
|
||||
|
||||
int chanCount = ARRAY_SIZE(chans);
|
||||
int chanCount = ARRAY_SIZE(g_audioChans);
|
||||
Do(p, chanCount);
|
||||
if (chanCount != ARRAY_SIZE(chans))
|
||||
if (chanCount != ARRAY_SIZE(g_audioChans))
|
||||
{
|
||||
ERROR_LOG(Log::sceAudio, "Savestate failure: different number of audio channels.");
|
||||
p.SetError(p.ERROR_FAILURE);
|
||||
return;
|
||||
}
|
||||
for (int i = 0; i < chanCount; ++i) {
|
||||
chans[i].index = i;
|
||||
chans[i].DoState(p);
|
||||
g_audioChans[i].index = i;
|
||||
g_audioChans[i].DoState(p);
|
||||
}
|
||||
|
||||
__AudioCPUMHzChange();
|
||||
@@ -178,8 +178,8 @@ void __AudioShutdown() {
|
||||
|
||||
mixBuffer = 0;
|
||||
for (u32 i = 0; i < PSP_AUDIO_CHANNEL_MAX + 1; i++) {
|
||||
chans[i].index = i;
|
||||
chans[i].clear();
|
||||
g_audioChans[i].index = i;
|
||||
g_audioChans[i].clear();
|
||||
}
|
||||
|
||||
#ifndef MOBILE_DEVICE
|
||||
@@ -338,10 +338,11 @@ void __AudioUpdate(bool resetRecording) {
|
||||
int16_t srcBuffer[srcBufferSize];
|
||||
|
||||
for (u32 i = 0; i < PSP_AUDIO_CHANNEL_MAX + 1; i++) {
|
||||
if (!chans[i].reserved)
|
||||
if (!g_audioChans[i].reserved) {
|
||||
continue;
|
||||
}
|
||||
|
||||
__AudioWakeThreads(chans[i], 0, hwBlockSize);
|
||||
__AudioWakeThreads(g_audioChans[i], 0, hwBlockSize);
|
||||
|
||||
if (!chanSampleQueues[i].size()) {
|
||||
continue;
|
||||
@@ -358,6 +359,11 @@ void __AudioUpdate(bool resetRecording) {
|
||||
|
||||
chanSampleQueues[i].popPointers(sz, &buf1, &sz1, &buf2, &sz2);
|
||||
|
||||
// We do this check as the very last thing before mixing, to maximize compatibility.
|
||||
if (g_audioChans[i].mute) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (needsResample) {
|
||||
auto read = [&](size_t i) {
|
||||
if (i < sz1)
|
||||
|
||||
+46
-46
@@ -40,7 +40,7 @@ int defaultRoutingVolMode = AUDIO_ROUTING_SPEAKER_ON;
|
||||
extern FixedSizeQueue<s16, 32768 * 8> chanSampleQueues[PSP_AUDIO_CHANNEL_MAX + 1];
|
||||
|
||||
// The extra channel is for SRC/Output2/Vaudio.
|
||||
AudioChannel chans[PSP_AUDIO_CHANNEL_MAX + 1];
|
||||
AudioChannel g_audioChans[PSP_AUDIO_CHANNEL_MAX + 1];
|
||||
|
||||
void AudioChannel::DoState(PointerWrap &p)
|
||||
{
|
||||
@@ -90,16 +90,16 @@ static u32 sceAudioOutputBlocking(u32 chan, int vol, u32 samplePtr) {
|
||||
return hleLogError(Log::sceAudio, SCE_ERROR_AUDIO_INVALID_VOLUME, "invalid volume");
|
||||
} else if (chan >= PSP_AUDIO_CHANNEL_MAX) {
|
||||
return hleLogError(Log::sceAudio, SCE_ERROR_AUDIO_INVALID_CHANNEL, "bad channel");
|
||||
} else if (!chans[chan].reserved) {
|
||||
} else if (!g_audioChans[chan].reserved) {
|
||||
return hleLogError(Log::sceAudio, SCE_ERROR_AUDIO_CHANNEL_NOT_INIT, "channel not reserved");
|
||||
}
|
||||
|
||||
if (vol >= 0) {
|
||||
chans[chan].leftVolume = vol;
|
||||
chans[chan].rightVolume = vol;
|
||||
g_audioChans[chan].leftVolume = vol;
|
||||
g_audioChans[chan].rightVolume = vol;
|
||||
}
|
||||
chans[chan].sampleAddress = samplePtr;
|
||||
return hleLogDebug(Log::sceAudio, __AudioEnqueue(chans[chan], chan, true));
|
||||
g_audioChans[chan].sampleAddress = samplePtr;
|
||||
return hleLogDebug(Log::sceAudio, __AudioEnqueue(g_audioChans[chan], chan, true));
|
||||
}
|
||||
|
||||
static u32 sceAudioOutputPannedBlocking(u32 chan, int leftvol, int rightvol, u32 samplePtr) {
|
||||
@@ -108,18 +108,18 @@ static u32 sceAudioOutputPannedBlocking(u32 chan, int leftvol, int rightvol, u32
|
||||
return hleLogError(Log::sceAudio, SCE_ERROR_AUDIO_INVALID_VOLUME, "invalid volume");
|
||||
} else if (chan >= PSP_AUDIO_CHANNEL_MAX) {
|
||||
return hleLogError(Log::sceAudio, SCE_ERROR_AUDIO_INVALID_CHANNEL, "bad channel");
|
||||
} else if (!chans[chan].reserved) {
|
||||
} else if (!g_audioChans[chan].reserved) {
|
||||
return hleLogError(Log::sceAudio, SCE_ERROR_AUDIO_CHANNEL_NOT_INIT, "channel not reserved");
|
||||
}
|
||||
|
||||
if (leftvol >= 0) {
|
||||
chans[chan].leftVolume = leftvol;
|
||||
g_audioChans[chan].leftVolume = leftvol;
|
||||
}
|
||||
if (rightvol >= 0) {
|
||||
chans[chan].rightVolume = rightvol;
|
||||
g_audioChans[chan].rightVolume = rightvol;
|
||||
}
|
||||
chans[chan].sampleAddress = samplePtr;
|
||||
u32 result = __AudioEnqueue(chans[chan], chan, true);
|
||||
g_audioChans[chan].sampleAddress = samplePtr;
|
||||
u32 result = __AudioEnqueue(g_audioChans[chan], chan, true);
|
||||
return hleLogDebug(Log::sceAudio, result);
|
||||
}
|
||||
|
||||
@@ -128,16 +128,16 @@ static u32 sceAudioOutput(u32 chan, int vol, u32 samplePtr) {
|
||||
return hleLogError(Log::sceAudio, SCE_ERROR_AUDIO_INVALID_VOLUME, "invalid volume");
|
||||
} else if (chan >= PSP_AUDIO_CHANNEL_MAX) {
|
||||
return hleLogError(Log::sceAudio, SCE_ERROR_AUDIO_INVALID_CHANNEL, "bad channel");
|
||||
} else if (!chans[chan].reserved) {
|
||||
} else if (!g_audioChans[chan].reserved) {
|
||||
return hleLogError(Log::sceAudio, SCE_ERROR_AUDIO_CHANNEL_NOT_INIT, "channel not reserved");
|
||||
}
|
||||
|
||||
if (vol >= 0) {
|
||||
chans[chan].leftVolume = vol;
|
||||
chans[chan].rightVolume = vol;
|
||||
g_audioChans[chan].leftVolume = vol;
|
||||
g_audioChans[chan].rightVolume = vol;
|
||||
}
|
||||
chans[chan].sampleAddress = samplePtr;
|
||||
u32 result = __AudioEnqueue(chans[chan], chan, false);
|
||||
g_audioChans[chan].sampleAddress = samplePtr;
|
||||
u32 result = __AudioEnqueue(g_audioChans[chan], chan, false);
|
||||
return hleLogDebug(Log::sceAudio, result);
|
||||
}
|
||||
|
||||
@@ -146,17 +146,17 @@ static u32 sceAudioOutputPanned(u32 chan, int leftvol, int rightvol, u32 sampleP
|
||||
return hleLogError(Log::sceAudio, SCE_ERROR_AUDIO_INVALID_VOLUME, "invalid volume");
|
||||
} else if (chan >= PSP_AUDIO_CHANNEL_MAX) {
|
||||
return hleLogError(Log::sceAudio, SCE_ERROR_AUDIO_INVALID_CHANNEL, "bad channel");
|
||||
} else if (!chans[chan].reserved) {
|
||||
} else if (!g_audioChans[chan].reserved) {
|
||||
return hleLogError(Log::sceAudio, SCE_ERROR_AUDIO_CHANNEL_NOT_INIT, "channel not reserved");
|
||||
} else {
|
||||
if (leftvol >= 0) {
|
||||
chans[chan].leftVolume = leftvol;
|
||||
g_audioChans[chan].leftVolume = leftvol;
|
||||
}
|
||||
if (rightvol >= 0) {
|
||||
chans[chan].rightVolume = rightvol;
|
||||
g_audioChans[chan].rightVolume = rightvol;
|
||||
}
|
||||
chans[chan].sampleAddress = samplePtr;
|
||||
u32 result = __AudioEnqueue(chans[chan], chan, false);
|
||||
g_audioChans[chan].sampleAddress = samplePtr;
|
||||
u32 result = __AudioEnqueue(g_audioChans[chan], chan, false);
|
||||
return hleLogDebug(Log::sceAudio, result);
|
||||
}
|
||||
}
|
||||
@@ -179,7 +179,7 @@ static int sceAudioGetChannelRestLength(u32 chan) {
|
||||
|
||||
static u32 GetFreeChannel() {
|
||||
for (u32 i = PSP_AUDIO_CHANNEL_MAX - 1; i > 0; --i) {
|
||||
if (!chans[i].reserved)
|
||||
if (!g_audioChans[i].reserved)
|
||||
return i;
|
||||
}
|
||||
return -1;
|
||||
@@ -201,52 +201,52 @@ static u32 sceAudioChReserve(int chan, u32 sampleCount, u32 format) {
|
||||
if (format != PSP_AUDIO_FORMAT_MONO && format != PSP_AUDIO_FORMAT_STEREO) {
|
||||
return hleLogError(Log::sceAudio, SCE_ERROR_AUDIO_INVALID_FORMAT, "invalid format");
|
||||
}
|
||||
if (chans[chan].reserved) {
|
||||
if (g_audioChans[chan].reserved) {
|
||||
return hleLogError(Log::sceAudio, SCE_ERROR_AUDIO_INVALID_CHANNEL, "reserve channel failed");
|
||||
}
|
||||
|
||||
chans[chan].sampleCount = sampleCount;
|
||||
chans[chan].format = format;
|
||||
chans[chan].reserved = true;
|
||||
chans[chan].leftVolume = 0;
|
||||
chans[chan].rightVolume = 0;
|
||||
g_audioChans[chan].sampleCount = sampleCount;
|
||||
g_audioChans[chan].format = format;
|
||||
g_audioChans[chan].reserved = true;
|
||||
g_audioChans[chan].leftVolume = 0;
|
||||
g_audioChans[chan].rightVolume = 0;
|
||||
return hleLogDebug(Log::sceAudio, chan);
|
||||
}
|
||||
|
||||
static u32 sceAudioChRelease(u32 chan) {
|
||||
if (chan >= PSP_AUDIO_CHANNEL_MAX) {
|
||||
return hleLogError(Log::sceAudio, SCE_ERROR_AUDIO_INVALID_CHANNEL, "bad channel %d", chan);
|
||||
} else if (!chans[chan].reserved) {
|
||||
} else if (!g_audioChans[chan].reserved) {
|
||||
return hleLogError(Log::sceAudio, SCE_ERROR_AUDIO_CHANNEL_NOT_INIT, "channel %d not reserved", chan);
|
||||
}
|
||||
|
||||
// TODO: Does this error if busy?
|
||||
chans[chan].reset();
|
||||
chans[chan].reserved = false;
|
||||
g_audioChans[chan].reset();
|
||||
g_audioChans[chan].reserved = false;
|
||||
return hleLogDebug(Log::sceAudio, 0);
|
||||
}
|
||||
|
||||
static u32 sceAudioSetChannelDataLen(u32 chan, u32 len) {
|
||||
if (chan >= PSP_AUDIO_CHANNEL_MAX) {
|
||||
return hleLogError(Log::sceAudio, SCE_ERROR_AUDIO_INVALID_CHANNEL, "bad channel %d", chan);
|
||||
} else if (!chans[chan].reserved) {
|
||||
} else if (!g_audioChans[chan].reserved) {
|
||||
return hleLogError(Log::sceAudio, SCE_ERROR_AUDIO_CHANNEL_NOT_INIT, "channel %d not reserved", chan);
|
||||
} else if ((len & 63) != 0 || len == 0 || len > PSP_AUDIO_SAMPLE_MAX) {
|
||||
return hleLogError(Log::sceAudio, SCE_ERROR_AUDIO_OUTPUT_SAMPLE_DATA_SIZE_NOT_ALIGNED, "invalid sample count");
|
||||
}
|
||||
|
||||
chans[chan].sampleCount = len;
|
||||
g_audioChans[chan].sampleCount = len;
|
||||
return hleLogDebug(Log::sceAudio, 0);
|
||||
}
|
||||
|
||||
static u32 sceAudioChangeChannelConfig(u32 chan, u32 format) {
|
||||
if (chan >= PSP_AUDIO_CHANNEL_MAX) {
|
||||
return hleLogError(Log::sceAudio, SCE_ERROR_AUDIO_INVALID_CHANNEL, "invalid channel number %d", chan);
|
||||
} else if (!chans[chan].reserved) {
|
||||
} else if (!g_audioChans[chan].reserved) {
|
||||
return hleLogError(Log::sceAudio, SCE_ERROR_AUDIO_CHANNEL_NOT_RESERVED, "channel %d not reserved", chan);
|
||||
}
|
||||
|
||||
chans[chan].format = format;
|
||||
g_audioChans[chan].format = format;
|
||||
return hleLogDebug(Log::sceAudio, 0);
|
||||
}
|
||||
|
||||
@@ -255,12 +255,12 @@ static u32 sceAudioChangeChannelVolume(u32 chan, u32 leftvol, u32 rightvol) {
|
||||
return hleLogError(Log::sceAudio, SCE_ERROR_AUDIO_INVALID_VOLUME, "invalid chan %d volume %d %d", chan, leftvol, rightvol);
|
||||
} else if (chan >= PSP_AUDIO_CHANNEL_MAX) {
|
||||
return hleLogError(Log::sceAudio, SCE_ERROR_AUDIO_INVALID_CHANNEL, "invalid channel %d", chan);
|
||||
} else if (!chans[chan].reserved) {
|
||||
} else if (!g_audioChans[chan].reserved) {
|
||||
return hleLogError(Log::sceAudio, SCE_ERROR_AUDIO_CHANNEL_NOT_RESERVED, "channel %d not reserved", chan);
|
||||
}
|
||||
|
||||
chans[chan].leftVolume = leftvol;
|
||||
chans[chan].rightVolume = rightvol;
|
||||
g_audioChans[chan].leftVolume = leftvol;
|
||||
g_audioChans[chan].rightVolume = rightvol;
|
||||
return hleLogDebug(Log::sceAudio, 0);
|
||||
}
|
||||
|
||||
@@ -275,7 +275,7 @@ static u32 sceAudioEnd() {
|
||||
}
|
||||
|
||||
static u32 sceAudioOutput2Reserve(u32 sampleCount) {
|
||||
auto &chan = chans[PSP_AUDIO_CHANNEL_OUTPUT2];
|
||||
auto &chan = g_audioChans[PSP_AUDIO_CHANNEL_OUTPUT2];
|
||||
// This seems to ignore the MSB, for some reason.
|
||||
sampleCount &= 0x7FFFFFFF;
|
||||
if (sampleCount < 17 || sampleCount > 4111) {
|
||||
@@ -297,7 +297,7 @@ static u32 sceAudioOutput2OutputBlocking(u32 vol, u32 dataPtr) {
|
||||
return hleLogError(Log::sceAudio, SCE_ERROR_AUDIO_INVALID_VOLUME, "invalid volume");
|
||||
}
|
||||
|
||||
auto &chan = chans[PSP_AUDIO_CHANNEL_OUTPUT2];
|
||||
auto &chan = g_audioChans[PSP_AUDIO_CHANNEL_OUTPUT2];
|
||||
if (!chan.reserved) {
|
||||
return hleLogError(Log::sceAudio, SCE_ERROR_AUDIO_CHANNEL_NOT_RESERVED, "channel not reserved");
|
||||
}
|
||||
@@ -314,7 +314,7 @@ static u32 sceAudioOutput2OutputBlocking(u32 vol, u32 dataPtr) {
|
||||
}
|
||||
|
||||
static u32 sceAudioOutput2ChangeLength(u32 sampleCount) {
|
||||
auto &chan = chans[PSP_AUDIO_CHANNEL_OUTPUT2];
|
||||
auto &chan = g_audioChans[PSP_AUDIO_CHANNEL_OUTPUT2];
|
||||
if (!chan.reserved) {
|
||||
return hleLogError(Log::sceAudio, SCE_ERROR_AUDIO_CHANNEL_NOT_RESERVED, "channel not reserved");
|
||||
}
|
||||
@@ -323,7 +323,7 @@ static u32 sceAudioOutput2ChangeLength(u32 sampleCount) {
|
||||
}
|
||||
|
||||
static u32 sceAudioOutput2GetRestSample() {
|
||||
auto &chan = chans[PSP_AUDIO_CHANNEL_OUTPUT2];
|
||||
auto &chan = g_audioChans[PSP_AUDIO_CHANNEL_OUTPUT2];
|
||||
if (!chan.reserved) {
|
||||
return hleLogError(Log::sceAudio, SCE_ERROR_AUDIO_CHANNEL_NOT_RESERVED, "channel not reserved");
|
||||
}
|
||||
@@ -336,7 +336,7 @@ static u32 sceAudioOutput2GetRestSample() {
|
||||
}
|
||||
|
||||
static u32 sceAudioOutput2Release() {
|
||||
auto &chan = chans[PSP_AUDIO_CHANNEL_OUTPUT2];
|
||||
auto &chan = g_audioChans[PSP_AUDIO_CHANNEL_OUTPUT2];
|
||||
if (!chan.reserved)
|
||||
return hleLogError(Log::sceAudio, SCE_ERROR_AUDIO_CHANNEL_NOT_RESERVED, "channel not reserved");
|
||||
if (!chanSampleQueues[PSP_AUDIO_CHANNEL_OUTPUT2].empty())
|
||||
@@ -373,7 +373,7 @@ static bool SRCFrequencyAllowed(int freq) {
|
||||
}
|
||||
|
||||
static u32 sceAudioSRCChReserve(u32 sampleCount, u32 freq, u32 format) {
|
||||
auto &chan = chans[PSP_AUDIO_CHANNEL_SRC];
|
||||
auto &chan = g_audioChans[PSP_AUDIO_CHANNEL_SRC];
|
||||
// This seems to ignore the MSB, for some reason.
|
||||
sampleCount &= 0x7FFFFFFF;
|
||||
if (format == 4) {
|
||||
@@ -397,7 +397,7 @@ static u32 sceAudioSRCChReserve(u32 sampleCount, u32 freq, u32 format) {
|
||||
}
|
||||
|
||||
static u32 sceAudioSRCChRelease() {
|
||||
auto &chan = chans[PSP_AUDIO_CHANNEL_SRC];
|
||||
auto &chan = g_audioChans[PSP_AUDIO_CHANNEL_SRC];
|
||||
if (!chan.reserved)
|
||||
return hleLogError(Log::sceAudio, SCE_ERROR_AUDIO_CHANNEL_NOT_RESERVED, "channel not reserved");
|
||||
if (!chanSampleQueues[PSP_AUDIO_CHANNEL_SRC].empty())
|
||||
@@ -413,7 +413,7 @@ static u32 sceAudioSRCOutputBlocking(u32 vol, u32 buf) {
|
||||
return hleLogError(Log::sceAudio, SCE_ERROR_AUDIO_INVALID_VOLUME, "invalid volume");
|
||||
}
|
||||
|
||||
auto &chan = chans[PSP_AUDIO_CHANNEL_SRC];
|
||||
auto &chan = g_audioChans[PSP_AUDIO_CHANNEL_SRC];
|
||||
if (!chan.reserved) {
|
||||
return hleLogError(Log::sceAudio, SCE_ERROR_AUDIO_CHANNEL_NOT_RESERVED, "channel not reserved");
|
||||
}
|
||||
|
||||
+4
-1
@@ -49,6 +49,9 @@ struct AudioChannel {
|
||||
u32 rightVolume = 0;
|
||||
u32 format = 0;
|
||||
|
||||
// For the debugger only. Not saved.
|
||||
bool mute = false;
|
||||
|
||||
std::vector<AudioChannelWaitInfo> waitingThreads;
|
||||
|
||||
void DoState(PointerWrap &p);
|
||||
@@ -58,7 +61,7 @@ struct AudioChannel {
|
||||
};
|
||||
|
||||
// The extra channel is for SRC/Output2/Vaudio (who all share, apparently.)
|
||||
extern AudioChannel chans[PSP_AUDIO_CHANNEL_MAX + 1];
|
||||
extern AudioChannel g_audioChans[PSP_AUDIO_CHANNEL_MAX + 1];
|
||||
|
||||
void Register_sceAudio();
|
||||
|
||||
+13
-13
@@ -47,16 +47,16 @@ static u32 sceVaudioChReserve(int sampleCount, int freq, int format) {
|
||||
return SCE_KERNEL_ERROR_BUSY;
|
||||
}
|
||||
// We still have to check the channel also, which gives a different error.
|
||||
if (chans[PSP_AUDIO_CHANNEL_VAUDIO].reserved) {
|
||||
if (g_audioChans[PSP_AUDIO_CHANNEL_VAUDIO].reserved) {
|
||||
ERROR_LOG(Log::sceAudio, "sceVaudioChReserve(%i, %i, %i) - channel already reserved", sampleCount, freq, format);
|
||||
return SCE_ERROR_AUDIO_CHANNEL_ALREADY_RESERVED;
|
||||
}
|
||||
DEBUG_LOG(Log::sceAudio, "sceVaudioChReserve(%i, %i, %i)", sampleCount, freq, format);
|
||||
chans[PSP_AUDIO_CHANNEL_VAUDIO].reserved = true;
|
||||
chans[PSP_AUDIO_CHANNEL_VAUDIO].sampleCount = sampleCount;
|
||||
chans[PSP_AUDIO_CHANNEL_VAUDIO].format = format == 2 ? PSP_AUDIO_FORMAT_STEREO : PSP_AUDIO_FORMAT_MONO;
|
||||
chans[PSP_AUDIO_CHANNEL_VAUDIO].leftVolume = 0;
|
||||
chans[PSP_AUDIO_CHANNEL_VAUDIO].rightVolume = 0;
|
||||
g_audioChans[PSP_AUDIO_CHANNEL_VAUDIO].reserved = true;
|
||||
g_audioChans[PSP_AUDIO_CHANNEL_VAUDIO].sampleCount = sampleCount;
|
||||
g_audioChans[PSP_AUDIO_CHANNEL_VAUDIO].format = format == 2 ? PSP_AUDIO_FORMAT_STEREO : PSP_AUDIO_FORMAT_MONO;
|
||||
g_audioChans[PSP_AUDIO_CHANNEL_VAUDIO].leftVolume = 0;
|
||||
g_audioChans[PSP_AUDIO_CHANNEL_VAUDIO].rightVolume = 0;
|
||||
vaudioReserved = true;
|
||||
__AudioSetSRCFrequency(freq);
|
||||
return 0;
|
||||
@@ -64,11 +64,11 @@ static u32 sceVaudioChReserve(int sampleCount, int freq, int format) {
|
||||
|
||||
static u32 sceVaudioChRelease() {
|
||||
DEBUG_LOG(Log::sceAudio, "sceVaudioChRelease(...)");
|
||||
if (!chans[PSP_AUDIO_CHANNEL_VAUDIO].reserved) {
|
||||
if (!g_audioChans[PSP_AUDIO_CHANNEL_VAUDIO].reserved) {
|
||||
return SCE_ERROR_AUDIO_CHANNEL_NOT_RESERVED;
|
||||
} else {
|
||||
chans[PSP_AUDIO_CHANNEL_VAUDIO].reset();
|
||||
chans[PSP_AUDIO_CHANNEL_VAUDIO].reserved = false;
|
||||
g_audioChans[PSP_AUDIO_CHANNEL_VAUDIO].reset();
|
||||
g_audioChans[PSP_AUDIO_CHANNEL_VAUDIO].reserved = false;
|
||||
vaudioReserved = false;
|
||||
return 0;
|
||||
}
|
||||
@@ -76,11 +76,11 @@ static u32 sceVaudioChRelease() {
|
||||
|
||||
static u32 sceVaudioOutputBlocking(int vol, u32 buffer) {
|
||||
DEBUG_LOG(Log::sceAudio, "sceVaudioOutputBlocking(%i, %08x)", vol, buffer);
|
||||
chans[PSP_AUDIO_CHANNEL_VAUDIO].leftVolume = vol;
|
||||
chans[PSP_AUDIO_CHANNEL_VAUDIO].rightVolume = vol;
|
||||
g_audioChans[PSP_AUDIO_CHANNEL_VAUDIO].leftVolume = vol;
|
||||
g_audioChans[PSP_AUDIO_CHANNEL_VAUDIO].rightVolume = vol;
|
||||
// TODO: This may be wrong, not sure if's in a different format?
|
||||
chans[PSP_AUDIO_CHANNEL_VAUDIO].sampleAddress = buffer;
|
||||
return __AudioEnqueue(chans[PSP_AUDIO_CHANNEL_VAUDIO], PSP_AUDIO_CHANNEL_VAUDIO, true);
|
||||
g_audioChans[PSP_AUDIO_CHANNEL_VAUDIO].sampleAddress = buffer;
|
||||
return __AudioEnqueue(g_audioChans[PSP_AUDIO_CHANNEL_VAUDIO], PSP_AUDIO_CHANNEL_VAUDIO, true);
|
||||
}
|
||||
|
||||
static u32 sceVaudioSetEffectType(int effectType, int vol) {
|
||||
|
||||
@@ -1,3 +1,4 @@
|
||||
#include <algorithm>
|
||||
#include <cstdio>
|
||||
#include "Common/Common.h"
|
||||
#include "Common/StringUtils.h"
|
||||
@@ -907,10 +908,9 @@ bool GetPrimPreview(u32 op, GEPrimitiveType &prim, std::vector<GPUDebugVertex> &
|
||||
u16 minIndex = 0;
|
||||
u16 maxIndex = count - 1;
|
||||
if (!indices.empty()) {
|
||||
_dbg_assert_(count <= indices.size());
|
||||
minIndex = 0xFFFF;
|
||||
maxIndex = 0;
|
||||
for (int i = 0; i < count; ++i) {
|
||||
for (int i = 0; i < std::min((size_t)count, indices.size()); ++i) {
|
||||
if (minIndex > indices[i]) {
|
||||
minIndex = indices[i];
|
||||
}
|
||||
|
||||
@@ -1245,8 +1245,9 @@ void DrawAudioChannels(ImConfig &cfg, ImControl &control) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (ImGui::BeginTable("audios", 6, ImGuiTableFlags_RowBg | ImGuiTableFlags_BordersH)) {
|
||||
if (ImGui::BeginTable("audios", 7, ImGuiTableFlags_RowBg | ImGuiTableFlags_BordersH)) {
|
||||
ImGui::TableSetupColumn("Index", ImGuiTableColumnFlags_WidthFixed);
|
||||
ImGui::TableSetupColumn("Mute", ImGuiTableColumnFlags_WidthFixed);
|
||||
ImGui::TableSetupColumn("SampleAddr", ImGuiTableColumnFlags_WidthFixed);
|
||||
ImGui::TableSetupColumn("SampleCount", ImGuiTableColumnFlags_WidthFixed);
|
||||
ImGui::TableSetupColumn("Volume", ImGuiTableColumnFlags_WidthFixed);
|
||||
@@ -1257,26 +1258,29 @@ void DrawAudioChannels(ImConfig &cfg, ImControl &control) {
|
||||
|
||||
// vaudio / output2 uses channel 8.
|
||||
for (int i = 0; i < PSP_AUDIO_CHANNEL_MAX + 1; i++) {
|
||||
if (!chans[i].reserved) {
|
||||
if (!g_audioChans[i].reserved) {
|
||||
continue;
|
||||
}
|
||||
ImGui::TableNextRow();
|
||||
ImGui::TableNextColumn();
|
||||
ImGui::PushID(i);
|
||||
if (i == 8) {
|
||||
ImGui::TextUnformatted("audio2");
|
||||
} else {
|
||||
ImGui::Text("%d", i);
|
||||
}
|
||||
ImGui::TableNextColumn();
|
||||
ImGui::Checkbox("", &g_audioChans[i].mute);
|
||||
ImGui::TableNextColumn();
|
||||
char id[2]{};
|
||||
id[0] = i + 1;
|
||||
ImClickableValue(id, chans[i].sampleAddress, control, ImCmd::SHOW_IN_MEMORY_VIEWER);
|
||||
ImClickableValue(id, g_audioChans[i].sampleAddress, control, ImCmd::SHOW_IN_MEMORY_VIEWER);
|
||||
ImGui::TableNextColumn();
|
||||
ImGui::Text("%08x", chans[i].sampleCount);
|
||||
ImGui::Text("%08x", g_audioChans[i].sampleCount);
|
||||
ImGui::TableNextColumn();
|
||||
ImGui::Text("%d | %d", chans[i].leftVolume, chans[i].rightVolume);
|
||||
ImGui::Text("%d | %d", g_audioChans[i].leftVolume, g_audioChans[i].rightVolume);
|
||||
ImGui::TableNextColumn();
|
||||
switch (chans[i].format) {
|
||||
switch (g_audioChans[i].format) {
|
||||
case PSP_AUDIO_FORMAT_STEREO:
|
||||
ImGui::TextUnformatted("Stereo");
|
||||
break;
|
||||
@@ -1288,12 +1292,13 @@ void DrawAudioChannels(ImConfig &cfg, ImControl &control) {
|
||||
break;
|
||||
}
|
||||
ImGui::TableNextColumn();
|
||||
for (auto t : chans[i].waitingThreads) {
|
||||
for (auto t : g_audioChans[i].waitingThreads) {
|
||||
KernelObject *thread = kernelObjects.GetFast<KernelObject>(t.threadID);
|
||||
if (thread) {
|
||||
ImGui::Text("%s: %d", thread->GetName(), t.numSamples);
|
||||
}
|
||||
}
|
||||
ImGui::PopID();
|
||||
}
|
||||
|
||||
ImGui::EndTable();
|
||||
|
||||
Reference in new issue
Block a user