QAudioFormat QAudioDeviceInfoInternal::nearestFormat(const QAudioFormat& format) const
{
if(testSettings(format))
return format;
else
return preferredFormat();
}
QAudioFormat QAudioDeviceInfoInternal::preferredFormat() const
{
QAudioFormat nearest;
if(mode == QAudio::AudioOutput) {
nearest.setFrequency(44100);
nearest.setChannels(2);
nearest.setByteOrder(QAudioFormat::LittleEndian);
nearest.setSampleType(QAudioFormat::SignedInt);
nearest.setSampleSize(16);
nearest.setCodec(QLatin1String("audio/pcm"));
} else {
nearest.setFrequency(8000);
nearest.setChannels(1);
nearest.setSampleType(QAudioFormat::UnSignedInt);
nearest.setSampleSize(8);
nearest.setCodec(QLatin1String("audio/pcm"));
if(!testSettings(nearest)) {
nearest.setChannels(2);
nearest.setSampleSize(16);
nearest.setSampleType(QAudioFormat::SignedInt);
}
}
return nearest;
}
// Runs tests for the setting object.
void SettingsTest()
{
// note: settings are modified once load is called, but permanent modifications only occur
// after write is called.
Settings testSettings("options.xml");
std::cout << "constructing Settings object\n";
testSettings.load();
std::cout << "loading settings\n";
//assert( driverName == testSettings.getSetting(driverName) );
//assert( driverName.c_str() == testSettings.getSetting(driverName).c_str() );
//testSettings.setSetting("lol", "bbbb");
testSettings.setSetting("resolution", 45);
//testSettings.setSetting("shoot", 45);
testSettings.save();
std::cout << "saving settings\n";
//testSettings.load();
//testSettings.save();
assert( 45 == testSettings.getSettingAsInteger("resolution") && "resolution setting" );
assert( 0 == testSettings.getSettingAsInteger("fullscreen") && "fullscreen setting" );
assert( fullscreen == testSettings.getSetting("fullscreen") && "fullscreen setting" );
assert( driverName == testSettings.getSetting("driver") && "driver setting" );
//assert( key == testSettings.getSetting("jump") );
//assert( driverName.c_str() == testSettings.getSetting("driver").c_str() );
//// Should return enums of any pressed action.
//testSettings.getAction(JUMP);
//testSettings.setKey(RUN, irr::KEY_SPACE);
//testSettings.save();
//testSettings.getAction();
}
bool QAudioDeviceInfoInternal::isFormatSupported(const QAudioFormat& format) const
{
return testSettings(format);
}
bool QWindowsAudioDeviceInfo::isFormatSupported(const QAudioFormat& format) const
{
return testSettings(format);
}
void QWindowsAudioDeviceInfo::updateLists()
{
if (!sizez.isEmpty())
return;
bool hasCaps = false;
DWORD fmt = 0;
if(mode == QAudio::AudioOutput) {
WAVEOUTCAPS woc;
if (waveOutGetDevCaps(devId, &woc, sizeof(WAVEOUTCAPS)) == MMSYSERR_NOERROR) {
hasCaps = true;
fmt = woc.dwFormats;
}
} else {
WAVEINCAPS woc;
if (waveInGetDevCaps(devId, &woc, sizeof(WAVEINCAPS)) == MMSYSERR_NOERROR) {
hasCaps = true;
fmt = woc.dwFormats;
}
}
sizez.clear();
sampleRatez.clear();
channelz.clear();
typez.clear();
if (hasCaps) {
// Check sample size
if ((fmt & WAVE_FORMAT_1M08)
|| (fmt & WAVE_FORMAT_1S08)
|| (fmt & WAVE_FORMAT_2M08)
|| (fmt & WAVE_FORMAT_2S08)
|| (fmt & WAVE_FORMAT_4M08)
|| (fmt & WAVE_FORMAT_4S08)
|| (fmt & WAVE_FORMAT_48M08)
|| (fmt & WAVE_FORMAT_48S08)
|| (fmt & WAVE_FORMAT_96M08)
|| (fmt & WAVE_FORMAT_96S08)) {
sizez.append(8);
}
if ((fmt & WAVE_FORMAT_1M16)
|| (fmt & WAVE_FORMAT_1S16)
|| (fmt & WAVE_FORMAT_2M16)
|| (fmt & WAVE_FORMAT_2S16)
|| (fmt & WAVE_FORMAT_4M16)
|| (fmt & WAVE_FORMAT_4S16)
|| (fmt & WAVE_FORMAT_48M16)
|| (fmt & WAVE_FORMAT_48S16)
|| (fmt & WAVE_FORMAT_96M16)
|| (fmt & WAVE_FORMAT_96S16)) {
sizez.append(16);
}
// Check sample rate
if ((fmt & WAVE_FORMAT_1M08)
|| (fmt & WAVE_FORMAT_1S08)
|| (fmt & WAVE_FORMAT_1M16)
|| (fmt & WAVE_FORMAT_1S16)) {
sampleRatez.append(11025);
}
if ((fmt & WAVE_FORMAT_2M08)
|| (fmt & WAVE_FORMAT_2S08)
|| (fmt & WAVE_FORMAT_2M16)
|| (fmt & WAVE_FORMAT_2S16)) {
sampleRatez.append(22050);
}
if ((fmt & WAVE_FORMAT_4M08)
|| (fmt & WAVE_FORMAT_4S08)
|| (fmt & WAVE_FORMAT_4M16)
|| (fmt & WAVE_FORMAT_4S16)) {
sampleRatez.append(44100);
}
if ((fmt & WAVE_FORMAT_48M08)
|| (fmt & WAVE_FORMAT_48S08)
|| (fmt & WAVE_FORMAT_48M16)
|| (fmt & WAVE_FORMAT_48S16)) {
sampleRatez.append(48000);
}
if ((fmt & WAVE_FORMAT_96M08)
|| (fmt & WAVE_FORMAT_96S08)
|| (fmt & WAVE_FORMAT_96M16)
|| (fmt & WAVE_FORMAT_96S16)) {
sampleRatez.append(96000);
}
// Check channel count
if (fmt & WAVE_FORMAT_1M08
|| fmt & WAVE_FORMAT_1M16
|| fmt & WAVE_FORMAT_2M08
|| fmt & WAVE_FORMAT_2M16
|| fmt & WAVE_FORMAT_4M08
|| fmt & WAVE_FORMAT_4M16
|| fmt & WAVE_FORMAT_48M08
|| fmt & WAVE_FORMAT_48M16
|| fmt & WAVE_FORMAT_96M08
|| fmt & WAVE_FORMAT_96M16) {
channelz.append(1);
}
if (fmt & WAVE_FORMAT_1S08
|| fmt & WAVE_FORMAT_1S16
|| fmt & WAVE_FORMAT_2S08
|| fmt & WAVE_FORMAT_2S16
|| fmt & WAVE_FORMAT_4S08
|| fmt & WAVE_FORMAT_4S16
|| fmt & WAVE_FORMAT_48S08
|| fmt & WAVE_FORMAT_48S16
|| fmt & WAVE_FORMAT_96S08
|| fmt & WAVE_FORMAT_96S16) {
channelz.append(2);
}
typez.append(QAudioFormat::SignedInt);
typez.append(QAudioFormat::UnSignedInt);
// WAVEOUTCAPS and WAVEINCAPS contains information only for the previously tested parameters.
// WaveOut and WaveInt might actually support more formats, the only way to know is to try
// opening the device with it.
QAudioFormat testFormat;
testFormat.setCodec(QStringLiteral("audio/pcm"));
testFormat.setByteOrder(QAudioFormat::LittleEndian);
testFormat.setSampleType(QAudioFormat::SignedInt);
testFormat.setChannelCount(channelz.first());
testFormat.setSampleRate(sampleRatez.at(sampleRatez.size() / 2));
testFormat.setSampleSize(sizez.last());
const QAudioFormat defaultTestFormat(testFormat);
// Check if float samples are supported
testFormat.setSampleType(QAudioFormat::Float);
testFormat.setSampleSize(32);
if (testSettings(testFormat))
typez.append(QAudioFormat::Float);
// Check channel counts > 2
testFormat = defaultTestFormat;
for (int i = 3; i < 19; ++i) { // <mmreg.h> defines 18 different channels
testFormat.setChannelCount(i);
if (testSettings(testFormat))
channelz.append(i);
}
// Check more sample sizes
testFormat = defaultTestFormat;
QList<int> testSampleSizes = QList<int>() << 24 << 32 << 48 << 64;
Q_FOREACH (int s, testSampleSizes) {
testFormat.setSampleSize(s);
if (testSettings(testFormat))
sizez.append(s);
}
// Check more sample rates
testFormat = defaultTestFormat;
QList<int> testSampleRates = QList<int>() << 8000 << 16000 << 32000 << 88200 << 192000;
Q_FOREACH (int r, testSampleRates) {
testFormat.setSampleRate(r);
if (testSettings(testFormat))
sampleRatez.append(r);
}
