QAudioFormat format;
// set up the format you want, eg.
- format.setFrequency(8000);
- format.setChannels(1);
+ format.setSampleRate(8000);
+ format.setChannelCount(1);
format.setSampleSize(8);
format.setCodec("audio/pcm");
format.setByteOrder(QAudioFormat::LittleEndian);
QAudioFormat format;
// Set up the format, eg.
- format.setFrequency(8000);
- format.setChannels(1);
+ format.setSampleRate(8000);
+ format.setChannelCount(1);
format.setSampleSize(8);
format.setCodec("audio/pcm");
format.setByteOrder(QAudioFormat::LittleEndian);
{
//! [Setting audio format]
QAudioFormat format;
- format.setFrequency(44100);
+ format.setSampleRate(44100);
// ... other format parameters
format.setSampleType(QAudioFormat::SignedInt);
// Make sure the data we receive is in correct PCM format.
// Our wav file writer only supports SignedInt sample type.
QAudioFormat format;
- format.setChannels(2);
+ format.setChannelCount(2);
format.setSampleSize(16);
- format.setFrequency(48000);
+ format.setSampleRate(48000);
format.setCodec("audio/pcm");
format.setSampleType(QAudioFormat::SignedInt);
m_decoder.setAudioFormat(format);
memcpy(header.wave.descriptor.id, "fmt ", 4);
header.wave.descriptor.size = quint32(16);
header.wave.audioFormat = quint16(1);
- header.wave.numChannels = quint16(format.channels());
+ header.wave.numChannels = quint16(format.channelCount());
header.wave.sampleRate = quint32(format.sampleRate());
- header.wave.byteRate = quint32(format.sampleRate() * format.channels() * format.sampleSize() / 8);
- header.wave.blockAlign = quint16(format.channels() * format.sampleSize() / 8);
+ header.wave.byteRate = quint32(format.sampleRate() * format.channelCount() * format.sampleSize() / 8);
+ header.wave.blockAlign = quint16(format.channelCount() * format.sampleSize() / 8);
header.wave.bitsPerSample = quint16(format.sampleSize());
// DATA header
connect(testButton, SIGNAL(clicked()), SLOT(test()));
connect(modeBox, SIGNAL(activated(int)), SLOT(modeChanged(int)));
connect(deviceBox, SIGNAL(activated(int)), SLOT(deviceChanged(int)));
- connect(frequencyBox, SIGNAL(activated(int)), SLOT(freqChanged(int)));
+ connect(sampleRateBox, SIGNAL(activated(int)), SLOT(sampleRateChanged(int)));
connect(channelsBox, SIGNAL(activated(int)), SLOT(channelChanged(int)));
connect(codecsBox, SIGNAL(activated(int)), SLOT(codecChanged(int)));
connect(sampleSizesBox, SIGNAL(activated(int)), SLOT(sampleSizeChanged(int)));
if (!deviceInfo.isNull()) {
if (deviceInfo.isFormatSupported(settings)) {
testResult->setText(tr("Success"));
- nearestFreq->setText("");
+ nearestSampleRate->setText("");
nearestChannel->setText("");
nearestCodec->setText("");
nearestSampleSize->setText("");
} else {
QAudioFormat nearest = deviceInfo.nearestFormat(settings);
testResult->setText(tr("Failed"));
- nearestFreq->setText(QString("%1").arg(nearest.frequency()));
- nearestChannel->setText(QString("%1").arg(nearest.channels()));
+ nearestSampleRate->setText(QString("%1").arg(nearest.sampleRate()));
+ nearestChannel->setText(QString("%1").arg(nearest.channelCount()));
nearestCodec->setText(nearest.codec());
nearestSampleSize->setText(QString("%1").arg(nearest.sampleSize()));
nearestSampleType->setText(toString(nearest.sampleType()));
// device has changed
deviceInfo = deviceBox->itemData(idx).value<QAudioDeviceInfo>();
- frequencyBox->clear();
- QList<int> freqz = deviceInfo.supportedFrequencies();
- for(int i = 0; i < freqz.size(); ++i)
- frequencyBox->addItem(QString("%1").arg(freqz.at(i)));
- if(freqz.size())
- settings.setFrequency(freqz.at(0));
+ sampleRateBox->clear();
+ QList<int> sampleRatez = deviceInfo.supportedSampleRates();
+ for (int i = 0; i < sampleRatez.size(); ++i)
+ sampleRateBox->addItem(QString("%1").arg(sampleRatez.at(i)));
+ if (sampleRatez.size())
+ settings.setSampleRate(sampleRatez.at(0));
channelsBox->clear();
- QList<int> chz = deviceInfo.supportedChannels();
- for(int i = 0; i < chz.size(); ++i)
+ QList<int> chz = deviceInfo.supportedChannelCounts();
+ for (int i = 0; i < chz.size(); ++i)
channelsBox->addItem(QString("%1").arg(chz.at(i)));
- if(chz.size())
- settings.setChannels(chz.at(0));
+ if (chz.size())
+ settings.setChannelCount(chz.at(0));
codecsBox->clear();
QStringList codecz = deviceInfo.supportedCodecs();
QAudioFormat format;
foreach (QString codec, deviceInfo.supportedCodecs()) {
format.setCodec(codec);
- foreach (int frequency, deviceInfo.supportedFrequencies()) {
- format.setFrequency(frequency);
- foreach (int channels, deviceInfo.supportedChannels()) {
- format.setChannels(channels);
+ foreach (int sampleRate, deviceInfo.supportedSampleRates()) {
+ format.setSampleRate(sampleRate);
+ foreach (int channels, deviceInfo.supportedChannelCounts()) {
+ format.setChannelCount(channels);
foreach (QAudioFormat::SampleType sampleType, deviceInfo.supportedSampleTypes()) {
format.setSampleType(sampleType);
foreach (int sampleSize, deviceInfo.supportedSampleSizes()) {
QTableWidgetItem *codecItem = new QTableWidgetItem(format.codec());
allFormatsTable->setItem(row, 0, codecItem);
- QTableWidgetItem *frequencyItem = new QTableWidgetItem(QString("%1").arg(format.frequency()));
- allFormatsTable->setItem(row, 1, frequencyItem);
+ QTableWidgetItem *sampleRateItem = new QTableWidgetItem(QString("%1").arg(format.sampleRate()));
+ allFormatsTable->setItem(row, 1, sampleRateItem);
- QTableWidgetItem *channelsItem = new QTableWidgetItem(QString("%1").arg(format.channels()));
+ QTableWidgetItem *channelsItem = new QTableWidgetItem(QString("%1").arg(format.channelCount()));
allFormatsTable->setItem(row, 2, channelsItem);
QTableWidgetItem *sampleTypeItem = new QTableWidgetItem(toString(format.sampleType()));
}
}
-void AudioTest::freqChanged(int idx)
+void AudioTest::sampleRateChanged(int idx)
{
- // freq has changed
- settings.setFrequency(frequencyBox->itemText(idx).toInt());
+ // sample rate has changed
+ settings.setSampleRate(sampleRateBox->itemText(idx).toInt());
}
void AudioTest::channelChanged(int idx)
{
- settings.setChannels(channelsBox->itemText(idx).toInt());
+ settings.setChannelCount(channelsBox->itemText(idx).toInt());
}
void AudioTest::codecChanged(int idx)
private slots:
void modeChanged(int idx);
void deviceChanged(int idx);
- void freqChanged(int idx);
+ void sampleRateChanged(int idx);
void channelChanged(int idx);
void codecChanged(int idx);
void sampleSizeChanged(int idx);
</widget>
</item>
<item row="3" column="1">
- <widget class="QComboBox" name="frequencyBox">
+ <widget class="QComboBox" name="sampleRateBox">
<property name="sizePolicy">
<sizepolicy hsizetype="Expanding" vsizetype="Fixed">
<horstretch>0</horstretch>
</widget>
</item>
<item row="3" column="2">
- <widget class="QLineEdit" name="nearestFreq">
+ <widget class="QLineEdit" name="nearestSampleRate">
<property name="enabled">
<bool>false</bool>
</property>
<attribute name="verticalHeaderHighlightSections">
<bool>false</bool>
</attribute>
- <attribute name="verticalHeaderVisible">
- <bool>false</bool>
- </attribute>
- <attribute name="horizontalHeaderHighlightSections">
- <bool>false</bool>
- </attribute>
- <attribute name="verticalHeaderHighlightSections">
- <bool>false</bool>
- </attribute>
<column>
<property name="text">
<string>Codec</string>
if (m_maxAmplitude) {
Q_ASSERT(m_format.sampleSize() % 8 == 0);
const int channelBytes = m_format.sampleSize() / 8;
- const int sampleBytes = m_format.channels() * channelBytes;
+ const int sampleBytes = m_format.channelCount() * channelBytes;
Q_ASSERT(len % sampleBytes == 0);
const int numSamples = len / sampleBytes;
const unsigned char *ptr = reinterpret_cast<const unsigned char *>(data);
for (int i = 0; i < numSamples; ++i) {
- for(int j = 0; j < m_format.channels(); ++j) {
+ for (int j = 0; j < m_format.channelCount(); ++j) {
quint16 value = 0;
if (m_format.sampleSize() == 8 && m_format.sampleType() == QAudioFormat::UnSignedInt) {
{
m_pullMode = true;
- m_format.setFrequency(8000);
- m_format.setChannels(1);
+ m_format.setSampleRate(8000);
+ m_format.setChannelCount(1);
m_format.setSampleSize(16);
m_format.setSampleType(QAudioFormat::SignedInt);
m_format.setByteOrder(QAudioFormat::LittleEndian);
#define VOLUME_LABEL "Volume:"
const int DurationSeconds = 1;
-const int ToneFrequencyHz = 600;
-const int DataFrequencyHz = 44100;
+const int ToneSampleRateHz = 600;
+const int DataSampleRateHz = 44100;
const int BufferSize = 32768;
Generator::Generator(const QAudioFormat &format,
qint64 durationUs,
- int frequency,
+ int sampleRate,
QObject *parent)
: QIODevice(parent)
, m_pos(0)
{
- generateData(format, durationUs, frequency);
+ generateData(format, durationUs, sampleRate);
}
Generator::~Generator()
close();
}
-void Generator::generateData(const QAudioFormat &format, qint64 durationUs, int frequency)
+void Generator::generateData(const QAudioFormat &format, qint64 durationUs, int sampleRate)
{
const int channelBytes = format.sampleSize() / 8;
- const int sampleBytes = format.channels() * channelBytes;
+ const int sampleBytes = format.channelCount() * channelBytes;
- qint64 length = (format.frequency() * format.channels() * (format.sampleSize() / 8))
+ qint64 length = (format.sampleRate() * format.channelCount() * (format.sampleSize() / 8))
* durationUs / 100000;
Q_ASSERT(length % sampleBytes == 0);
int sampleIndex = 0;
while (length) {
- const qreal x = qSin(2 * M_PI * frequency * qreal(sampleIndex % format.frequency()) / format.frequency());
- for (int i=0; i<format.channels(); ++i) {
+ const qreal x = qSin(2 * M_PI * sampleRate * qreal(sampleIndex % format.sampleRate()) / format.sampleRate());
+ for (int i=0; i<format.channelCount(); ++i) {
if (format.sampleSize() == 8 && format.sampleType() == QAudioFormat::UnSignedInt) {
const quint8 value = static_cast<quint8>((1.0 + x) / 2 * 255);
*reinterpret_cast<quint8*>(ptr) = value;
m_pullMode = true;
- m_format.setFrequency(DataFrequencyHz);
- m_format.setChannels(1);
+ m_format.setSampleRate(DataSampleRateHz);
+ m_format.setChannelCount(1);
m_format.setSampleSize(16);
m_format.setCodec("audio/pcm");
m_format.setByteOrder(QAudioFormat::LittleEndian);
m_format = info.nearestFormat(m_format);
}
- m_generator = new Generator(m_format, DurationSeconds*1000000, ToneFrequencyHz, this);
+ m_generator = new Generator(m_format, DurationSeconds*1000000, ToneSampleRateHz, this);
createAudioOutput();
}
{
Q_OBJECT
public:
- Generator(const QAudioFormat &format, qint64 durationUs, int frequency, QObject *parent);
+ Generator(const QAudioFormat &format, qint64 durationUs, int sampleRate, QObject *parent);
~Generator();
void start();
qint64 bytesAvailable() const;
private:
- void generateData(const QAudioFormat &format, qint64 durationUs, int frequency);
+ void generateData(const QAudioFormat &format, qint64 durationUs, int sampleRate);
private:
qint64 m_pos;
}
} else {
- QList<int> frequenciesList;
+ QList<int> sampleRatesList;
#ifdef Q_OS_WIN
// The Windows audio backend does not correctly report format support
// (see QTBUG-9100). Furthermore, although the audio subsystem captures
// at 11025Hz, the resulting audio is corrupted.
- frequenciesList += 8000;
+ sampleRatesList += 8000;
#endif
if (!m_generateTone)
- frequenciesList += m_audioInputDevice.supportedFrequencies();
+ sampleRatesList += m_audioInputDevice.supportedSampleRates();
- frequenciesList += m_audioOutputDevice.supportedFrequencies();
- frequenciesList = frequenciesList.toSet().toList(); // remove duplicates
- qSort(frequenciesList);
- ENGINE_DEBUG << "Engine::initialize frequenciesList" << frequenciesList;
+ sampleRatesList += m_audioOutputDevice.supportedSampleRates();
+ sampleRatesList = sampleRatesList.toSet().toList(); // remove duplicates
+ qSort(sampleRatesList);
+ ENGINE_DEBUG << "Engine::initialize frequenciesList" << sampleRatesList;
QList<int> channelsList;
- channelsList += m_audioInputDevice.supportedChannels();
- channelsList += m_audioOutputDevice.supportedChannels();
+ channelsList += m_audioInputDevice.supportedChannelCounts();
+ channelsList += m_audioOutputDevice.supportedChannelCounts();
channelsList = channelsList.toSet().toList();
qSort(channelsList);
ENGINE_DEBUG << "Engine::initialize channelsList" << channelsList;
format.setCodec("audio/pcm");
format.setSampleSize(16);
format.setSampleType(QAudioFormat::SignedInt);
- int frequency, channels;
- foreach (frequency, frequenciesList) {
+ int sampleRate, channels;
+ foreach (sampleRate, sampleRatesList) {
if (foundSupportedFormat)
break;
- format.setFrequency(frequency);
+ format.setSampleRate(sampleRate);
foreach (channels, channelsList) {
- format.setChannels(channels);
+ format.setChannelCount(channels);
const bool inputSupport = m_generateTone ||
m_audioInputDevice.isFormatSupported(format);
const bool outputSupport = m_audioOutputDevice.isFormatSupported(format);
m_format = format;
m_levelBufferLength = audioLength(m_format, LevelWindowUs);
m_spectrumBufferLength = SpectrumLengthSamples *
- (m_format.sampleSize() / 8) * m_format.channels();
+ (m_format.sampleSize() / 8) * m_format.channelCount();
if (changed)
emit formatChanged(m_format);
}
if (isReady()) {
Q_ASSERT(isPCMS16LE(format));
- const int bytesPerSample = format.sampleSize() * format.channels() / 8;
+ const int bytesPerSample = format.sampleSize() * format.channelCount() / 8;
#ifdef DUMP_SPECTRUMANALYSER
m_count++;
const bool b = QMetaObject::invokeMethod(m_thread, "calculateSpectrum",
Qt::AutoConnection,
Q_ARG(QByteArray, buffer),
- Q_ARG(int, format.frequency()),
+ Q_ARG(int, format.sampleRate()),
Q_ARG(int, bytesPerSample));
Q_ASSERT(b);
Q_UNUSED(b) // suppress warnings in release builds
Q_ASSERT(isPCMS16LE(format));
const int channelBytes = format.sampleSize() / 8;
- const int sampleBytes = format.channels() * channelBytes;
+ const int sampleBytes = format.channelCount() * channelBytes;
int length = buffer.size();
const int numSamples = buffer.size() / sampleBytes;
qreal phase = 0.0;
- const qreal d = 2 * M_PI / format.frequency();
+ const qreal d = 2 * M_PI / format.sampleRate();
// We can't generate a zero-frequency sine wave
const qreal startFreq = tone.startFreq ? tone.startFreq : 1.0;
while (length) {
const qreal x = tone.amplitude * qSin(phase);
const qint16 value = realToPcm(x);
- for (int i=0; i<format.channels(); ++i) {
+ for (int i=0; i<format.channelCount(); ++i) {
qToLittleEndian<qint16>(value, ptr);
ptr += channelBytes;
length -= channelBytes;
qint64 audioDuration(const QAudioFormat &format, qint64 bytes)
{
return (bytes * 1000000) /
- (format.frequency() * format.channels() * (format.sampleSize() / 8));
+ (format.sampleRate() * format.channelCount() * (format.sampleSize() / 8));
}
qint64 audioLength(const QAudioFormat &format, qint64 microSeconds)
{
- qint64 result = (format.frequency() * format.channels() * (format.sampleSize() / 8))
+ qint64 result = (format.sampleRate() * format.channelCount() * (format.sampleSize() / 8))
* microSeconds / 1000000;
result -= result % (format.channelCount() * format.sampleSize());
return result;
qreal nyquistFrequency(const QAudioFormat &format)
{
- return format.frequency() / 2;
+ return format.sampleRate() / 2;
}
QString formatToString(const QAudioFormat &format)
break;
}
- QString formatChannels = QString("%1 channels").arg(format.channels());
- switch (format.channels()) {
+ QString formatChannels = QString("%1 channels").arg(format.channelCount());
+ switch (format.channelCount()) {
case 1:
formatChannels = "mono";
break;
}
result = QString("%1 Hz %2 bit %3 %4 %5")
- .arg(format.frequency())
+ .arg(format.sampleRate())
.arg(format.sampleSize())
.arg(formatType)
.arg(formatEndian)
const qint16* base = reinterpret_cast<const qint16*>(m_buffer.constData());
const qint16* buffer = base + ((tileStart - m_bufferPosition) / 2);
- const int numSamples = m_tileLength / (2 * m_format.channels());
+ const int numSamples = m_tileLength / (2 * m_format.channelCount());
QPainter painter(tile.pixmap);
// Calculate initial PCM value
qint16 previousPcmValue = 0;
if (buffer > base)
- previousPcmValue = *(buffer - m_format.channels());
+ previousPcmValue = *(buffer - m_format.channelCount());
// Calculate initial point
const qreal previousRealValue = pcmToReal(previousPcmValue);
QLine line(origin, origin);
for (int i=0; i<numSamples; ++i) {
- const qint16* ptr = buffer + i * m_format.channels();
+ const qint16* ptr = buffer + i * m_format.channelCount();
const int offset = reinterpret_cast<const char*>(ptr) - m_buffer.constData();
Q_ASSERT(offset >= 0);
const qint16 pcmValue = *ptr;
const qreal realValue = pcmToReal(pcmValue);
- const int x = tilePixelOffset(i * 2 * m_format.channels());
+ const int x = tilePixelOffset(i * 2 * m_format.channelCount());
const int y = ((realValue + 1.0) / 2) * m_pixmapSize.height();
line.setP2(QPoint(x, y));
m_fileFormat.setByteOrder(QAudioFormat::BigEndian);
int bps = qFromLittleEndian<quint16>(header.wave.bitsPerSample);
- m_fileFormat.setChannels(qFromLittleEndian<quint16>(header.wave.numChannels));
+ m_fileFormat.setChannelCount(qFromLittleEndian<quint16>(header.wave.numChannels));
m_fileFormat.setCodec("audio/pcm");
- m_fileFormat.setFrequency(qFromLittleEndian<quint32>(header.wave.sampleRate));
+ m_fileFormat.setSampleRate(qFromLittleEndian<quint32>(header.wave.sampleRate));
m_fileFormat.setSampleSize(qFromLittleEndian<quint16>(header.wave.bitsPerSample));
m_fileFormat.setSampleType(bps == 8 ? QAudioFormat::UnSignedInt : QAudioFormat::SignedInt);
} else {
return;
}
alBufferData(m_alBuffer, alFormat, m_sample->data().data(),
- m_sample->data().size(), m_sample->format().frequency());
+ m_sample->data().size(), m_sample->format().sampleRate());
if (!QAudioEnginePrivate::checkNoError("fill buffer")) {
return;
{
QAudioFormat audioFormat;
- audioFormat.setFrequency(sf.mSampleRate);
- audioFormat.setChannels(sf.mChannelsPerFrame);
+ audioFormat.setSampleRate(sf.mSampleRate);
+ audioFormat.setChannelCount(sf.mChannelsPerFrame);
audioFormat.setSampleSize(sf.mBitsPerChannel);
audioFormat.setCodec(QString::fromLatin1("audio/pcm"));
audioFormat.setByteOrder((sf.mFormatFlags & kAudioFormatFlagIsBigEndian) != 0 ? QAudioFormat::BigEndian : QAudioFormat::LittleEndian);
AudioStreamBasicDescription sf;
sf.mFormatFlags = kAudioFormatFlagIsPacked;
- sf.mSampleRate = audioFormat.frequency();
+ sf.mSampleRate = audioFormat.sampleRate();
sf.mFramesPerPacket = 1;
- sf.mChannelsPerFrame = audioFormat.channels();
+ sf.mChannelsPerFrame = audioFormat.channelCount();
sf.mBitsPerChannel = audioFormat.sampleSize();
sf.mBytesPerFrame = sf.mChannelsPerFrame * (sf.mBitsPerChannel / 8);
sf.mBytesPerPacket = sf.mFramesPerPacket * sf.mBytesPerFrame;
QAudioFormat nearest = settings;
QList<QString> testCodecs = supportedCodecs();
- QList<int> testChannels = supportedChannels();
+ QList<int> testChannels = supportedChannelCounts();
QList<QAudioFormat::Endian> testByteOrders = supportedByteOrders();
QList<QAudioFormat::SampleType> testSampleTypes;
QList<QAudioFormat::SampleType> sampleTypesAvailable = supportedSampleTypes();
- QMap<int,int> testFrequencies;
- QList<int> frequenciesAvailable = supportedFrequencies();
+ QMap<int,int> testSampleRates;
+ QList<int> sampleRatesAvailable = supportedSampleRates();
QMap<int,int> testSampleSizes;
QList<int> sampleSizesAvailable = supportedSampleSizes();
testCodecs.removeAll(settings.codec());
testCodecs.insert(0, settings.codec());
}
- testChannels.removeAll(settings.channels());
- testChannels.insert(0, settings.channels());
+ testChannels.removeAll(settings.channelCount());
+ testChannels.insert(0, settings.channelCount());
testByteOrders.removeAll(settings.byteOrder());
testByteOrders.insert(0, settings.byteOrder());
int diff = larger - smaller;
testSampleSizes.insert((isMultiple ? diff : diff+100000), size);
}
- if (frequenciesAvailable.contains(settings.frequency()))
- testFrequencies.insert(0,settings.frequency());
- frequenciesAvailable.removeAll(settings.frequency());
- foreach (int frequency, frequenciesAvailable) {
- int larger = (frequency > settings.frequency()) ? frequency : settings.frequency();
- int smaller = (frequency > settings.frequency()) ? settings.frequency() : frequency;
+ if (sampleRatesAvailable.contains(settings.sampleRate()))
+ testSampleRates.insert(0,settings.sampleRate());
+ sampleRatesAvailable.removeAll(settings.sampleRate());
+ foreach (int sampleRate, sampleRatesAvailable) {
+ int larger = (sampleRate > settings.sampleRate()) ? sampleRate : settings.sampleRate();
+ int smaller = (sampleRate > settings.sampleRate()) ? settings.sampleRate() : sampleRate;
bool isMultiple = ( 0 == (larger % smaller));
int diff = larger - smaller;
- testFrequencies.insert((isMultiple ? diff : diff+100000), frequency);
+ testSampleRates.insert((isMultiple ? diff : diff+100000), sampleRate);
}
// Try to find nearest
sz.next();
nearest.setSampleSize(sz.value());
foreach (int channel, testChannels) {
- nearest.setChannels(channel);
- QMapIterator<int, int> i(testFrequencies);
+ nearest.setChannelCount(channel);
+ QMapIterator<int, int> i(testSampleRates);
while (i.hasNext()) {
i.next();
- nearest.setFrequency(i.value());
+ nearest.setSampleRate(i.value());
if (isFormatSupported(nearest))
return nearest;
}
*/
QList<int> QAudioDeviceInfo::supportedSampleRates() const
-{
- return supportedFrequencies();
-}
-
-/*!
- \obsolete
-
- Use supportedSampleRates() instead.
-*/
-QList<int> QAudioDeviceInfo::supportedFrequencies() const
{
return isNull() ? QList<int>() : d->info->supportedSampleRates();
}
*/
QList<int> QAudioDeviceInfo::supportedChannelCounts() const
-{
- return supportedChannels();
-}
-
-/*!
- \obsolete
-
- Use supportedChannelCount() instead.
-*/
-QList<int> QAudioDeviceInfo::supportedChannels() const
{
return isNull() ? QList<int>() : d->info->supportedChannelCounts();
}
QAudioFormat nearestFormat(const QAudioFormat &format) const;
QStringList supportedCodecs() const;
- QList<int> supportedFrequencies() const;
QList<int> supportedSampleRates() const;
- QList<int> supportedChannels() const;
QList<int> supportedChannelCounts() const;
QList<int> supportedSampleSizes() const;
QList<QAudioFormat::Endian> supportedByteOrders() const;
{
QAudioFormat nearest;
if(mode == QAudio::AudioOutput) {
- nearest.setFrequency(44100);
- nearest.setChannels(2);
+ nearest.setSampleRate(44100);
+ nearest.setChannelCount(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.setSampleRate(8000);
+ nearest.setChannelCount(1);
nearest.setSampleType(QAudioFormat::UnSignedInt);
nearest.setSampleSize(8);
nearest.setCodec(QLatin1String("audio/pcm"));
if(!testSettings(nearest)) {
- nearest.setChannels(2);
+ nearest.setChannelCount(2);
nearest.setSampleSize(16);
nearest.setSampleType(QAudioFormat::SignedInt);
}
QList<int> QAudioDeviceInfoInternal::supportedSampleRates()
{
updateLists();
- return freqz;
+ return sampleRatez;
}
QList<int> QAudioDeviceInfoInternal::supportedChannelCounts()
bool testChannel = false;
bool testCodec = false;
- bool testFreq = false;
+ bool testSampleRate = false;
bool testType = false;
bool testSize = false;
snd_pcm_hw_params_any( handle, params );
// set the values!
- snd_pcm_hw_params_set_channels(handle,params,format.channels());
- snd_pcm_hw_params_set_rate(handle,params,format.frequency(),dir);
+ snd_pcm_hw_params_set_channels(handle,params,format.channelCount());
+ snd_pcm_hw_params_set_rate(handle,params,format.sampleRate(),dir);
err = -1;
} else
testCodec = true;
- if(err>=0 && format.channels() != -1) {
- err = snd_pcm_hw_params_test_channels(handle,params,format.channels());
+ if (err>=0 && format.channelCount() != -1) {
+ err = snd_pcm_hw_params_test_channels(handle,params,format.channelCount());
if(err>=0)
- err = snd_pcm_hw_params_set_channels(handle,params,format.channels());
+ err = snd_pcm_hw_params_set_channels(handle,params,format.channelCount());
if(err>=0)
testChannel = true;
}
- if(err>=0 && format.frequency() != -1) {
- err = snd_pcm_hw_params_test_rate(handle,params,format.frequency(),0);
+ if (err>=0 && format.sampleRate() != -1) {
+ err = snd_pcm_hw_params_test_rate(handle,params,format.sampleRate(),0);
if(err>=0)
- err = snd_pcm_hw_params_set_rate(handle,params,format.frequency(),dir);
+ err = snd_pcm_hw_params_set_rate(handle,params,format.sampleRate(),dir);
if(err>=0)
- testFreq = true;
+ testSampleRate = true;
}
if((err>=0 && format.sampleSize() != -1) &&
void QAudioDeviceInfoInternal::updateLists()
{
// redo all lists based on current settings
- freqz.clear();
+ sampleRatez.clear();
channelz.clear();
sizez.clear();
byteOrderz.clear();
for(int i=0; i<(int)MAX_SAMPLE_RATES; i++) {
//if(snd_pcm_hw_params_test_rate(handle, params, SAMPLE_RATES[i], dir) == 0)
- freqz.append(SAMPLE_RATES[i]);
+ sampleRatez.append(SAMPLE_RATES[i]);
}
channelz.append(1);
channelz.append(2);
void QAudioDeviceInfoInternal::checkSurround()
{
- QList<QByteArray> devices;
surround40 = false;
surround51 = false;
surround71 = false;
QString device;
QAudio::Mode mode;
QAudioFormat nearest;
- QList<int> freqz;
+ QList<int> sampleRatez;
QList<int> channelz;
QList<int> sizez;
QList<QAudioFormat::Endian> byteOrderz;
QAudioFormat QAudioDeviceInfoInternal::preferredFormat() const
{
QAudioFormat nearest;
- if(mode == QAudio::AudioOutput) {
- nearest.setFrequency(44100);
+ if (mode == QAudio::AudioOutput) {
+ nearest.setSampleRate(44100);
nearest.setChannelCount(2);
nearest.setByteOrder(QAudioFormat::LittleEndian);
nearest.setSampleType(QAudioFormat::SignedInt);
nearest.setSampleSize(16);
nearest.setCodec(QLatin1String("audio/pcm"));
} else {
- nearest.setFrequency(11025);
+ nearest.setSampleRate(11025);
nearest.setChannelCount(1);
nearest.setByteOrder(QAudioFormat::LittleEndian);
nearest.setSampleType(QAudioFormat::SignedInt);
QList<int> QAudioDeviceInfoInternal::supportedSampleRates()
{
updateLists();
- return freqz;
+ return sampleRatez;
}
QList<int> QAudioDeviceInfoInternal::supportedChannelCounts()
// check channel
match = false;
if (!failed) {
- for( int i = 0; i < channelz.count(); i++) {
- if (format.channels() == channelz.at(i)) {
+ for (int i = 0; i < channelz.count(); i++) {
+ if (format.channelCount() == channelz.at(i)) {
match = true;
break;
}
failed = true;
}
- // check frequency
+ // check sampleRate
match = false;
if (!failed) {
- for( int i = 0; i < freqz.count(); i++) {
- if (format.frequency() == freqz.at(i)) {
+ for (int i = 0; i < sampleRatez.count(); i++) {
+ if (format.sampleRate() == sampleRatez.at(i)) {
match = true;
break;
}
}
}
sizez.clear();
- freqz.clear();
+ sampleRatez.clear();
channelz.clear();
byteOrderz.clear();
typez.clear();
|| (fmt & WAVE_FORMAT_1S08)
|| (fmt & WAVE_FORMAT_1M16)
|| (fmt & WAVE_FORMAT_1S16)) {
- freqz.append(11025);
+ sampleRatez.append(11025);
}
if ((fmt & WAVE_FORMAT_2M08)
|| (fmt & WAVE_FORMAT_2S08)
|| (fmt & WAVE_FORMAT_2M16)
|| (fmt & WAVE_FORMAT_2S16)) {
- freqz.append(22050);
+ sampleRatez.append(22050);
}
if ((fmt & WAVE_FORMAT_4M08)
|| (fmt & WAVE_FORMAT_4S08)
|| (fmt & WAVE_FORMAT_4M16)
|| (fmt & WAVE_FORMAT_4S16)) {
- freqz.append(44100);
+ sampleRatez.append(44100);
}
if ((fmt & WAVE_FORMAT_48M08)
|| (fmt & WAVE_FORMAT_48S08)
|| (fmt & WAVE_FORMAT_48M16)
|| (fmt & WAVE_FORMAT_48S16)) {
- freqz.append(48000);
+ sampleRatez.append(48000);
}
if ((fmt & WAVE_FORMAT_96M08)
|| (fmt & WAVE_FORMAT_96S08)
|| (fmt & WAVE_FORMAT_96M16)
|| (fmt & WAVE_FORMAT_96S16)) {
- freqz.append(96000);
+ sampleRatez.append(96000);
}
channelz.append(1);
channelz.append(2);
codecz.append(QLatin1String("audio/pcm"));
}
- if (freqz.count() > 0)
- freqz.prepend(8000);
+ if (sampleRatez.count() > 0)
+ sampleRatez.prepend(8000);
}
QList<QByteArray> QAudioDeviceInfoInternal::availableDevices(QAudio::Mode mode)
QString device;
quint32 devId;
QAudioFormat nearest;
- QList<int> freqz;
+ QList<int> sampleRatez;
QList<int> channelz;
QList<int> sizez;
QList<QAudioFormat::Endian> byteOrderz;
public:
QAudioFormatPrivate()
{
- frequency = -1;
+ sampleRate = -1;
channels = -1;
sampleSize = -1;
byteOrder = QAudioFormat::Endian(QSysInfo::ByteOrder);
codec(other.codec),
byteOrder(other.byteOrder),
sampleType(other.sampleType),
- frequency(other.frequency),
+ sampleRate(other.sampleRate),
channels(other.channels),
sampleSize(other.sampleSize)
{
codec = other.codec;
byteOrder = other.byteOrder;
sampleType = other.sampleType;
- frequency = other.frequency;
+ sampleRate = other.sampleRate;
channels = other.channels;
sampleSize = other.sampleSize;
QString codec;
QAudioFormat::Endian byteOrder;
QAudioFormat::SampleType sampleType;
- int frequency;
+ int sampleRate;
int channels;
int sampleSize;
};
*/
bool QAudioFormat::operator==(const QAudioFormat &other) const
{
- return d->frequency == other.d->frequency &&
+ return d->sampleRate == other.d->sampleRate &&
d->channels == other.d->channels &&
d->sampleSize == other.d->sampleSize &&
d->byteOrder == other.d->byteOrder &&
*/
bool QAudioFormat::isValid() const
{
- return d->frequency != -1 && d->channels != -1 && d->sampleSize != -1 &&
+ return d->sampleRate != -1 && d->channels != -1 && d->sampleSize != -1 &&
d->sampleType != QAudioFormat::Unknown && !d->codec.isEmpty();
}
*/
void QAudioFormat::setSampleRate(int samplerate)
{
- d->frequency = samplerate;
-}
-
-/*!
- \obsolete
-
- Use setSampleRate() instead.
-*/
-void QAudioFormat::setFrequency(int frequency)
-{
- d->frequency = frequency;
+ d->sampleRate = samplerate;
}
/*!
*/
int QAudioFormat::sampleRate() const
{
- return d->frequency;
-}
-
-/*!
- \obsolete
-
- Use sampleRate() instead.
-*/
-int QAudioFormat::frequency() const
-{
- return d->frequency;
+ return d->sampleRate;
}
/*!
d->channels = channels;
}
-/*!
- \obsolete
-
- Use setChannelCount() instead.
-*/
-void QAudioFormat::setChannels(int channels)
-{
- d->channels = channels;
-}
-
/*!
Returns the current channel count value.
return d->channels;
}
-/*!
- \obsolete
-
- Use channelCount() instead.
-*/
-int QAudioFormat::channels() const
-{
- return d->channels;
-}
-
/*!
Sets the sample size to the \a sampleSize specified, in bits.
bool isValid() const;
- void setFrequency(int frequency);
- int frequency() const;
void setSampleRate(int sampleRate);
int sampleRate() const;
- void setChannels(int channels);
- int channels() const;
void setChannelCount(int channelCount);
int channelCount() const;
int dir;
int err = 0;
int count=0;
- unsigned int freakuency=settings.frequency();
+ unsigned int sampleRate=settings.sampleRate();
if (!settings.isValid()) {
qWarning("QAudioOutput: open error, invalid format.");
}
}
if ( !fatal ) {
- err = snd_pcm_hw_params_set_channels( handle, hwparams, (unsigned int)settings.channels() );
+ err = snd_pcm_hw_params_set_channels( handle, hwparams, (unsigned int)settings.channelCount() );
if ( err < 0 ) {
fatal = true;
errMessage = QString::fromLatin1("QAudioInput: snd_pcm_hw_params_set_channels: err = %1").arg(err);
}
}
if ( !fatal ) {
- err = snd_pcm_hw_params_set_rate_near( handle, hwparams, &freakuency, 0 );
+ err = snd_pcm_hw_params_set_rate_near( handle, hwparams, &sampleRate, 0 );
if ( err < 0 ) {
fatal = true;
errMessage = QString::fromLatin1("QAudioInput: snd_pcm_hw_params_set_rate_near: err = %1").arg(err);
qint64 QAudioInputPrivate::processedUSecs() const
{
qint64 result = qint64(1000000) * totalTimeValue /
- (settings.channels()*(settings.sampleSize()/8)) /
- settings.frequency();
+ (settings.channelCount()*(settings.sampleSize()/8)) /
+ settings.sampleRate();
return result;
}
qint64 QAudioInputPrivate::processedUSecs() const
{
- return totalFrames * 1000000 / audioFormat.frequency();
+ return totalFrames * 1000000 / audioFormat.sampleRate();
}
qint64 QAudioInputPrivate::elapsedUSecs() const
} else if (settings.sampleSize() <= 0) {
qWarning("QAudioInput: open error, invalid sample size (%d).",
settings.sampleSize());
- } else if (settings.frequency() < 8000 || settings.frequency() > 96000) {
- qWarning("QAudioInput: open error, frequency out of range (%d).", settings.frequency());
+ } else if (settings.sampleRate() < 8000 || settings.sampleRate() > 96000) {
+ qWarning("QAudioInput: open error, sample rate out of range (%d).", settings.sampleRate());
} else if (buffer_size == 0) {
buffer_size
- = (settings.frequency()
+ = (settings.sampleRate()
* settings.channelCount()
* settings.sampleSize()
+ 39) / 40;
timeStamp.restart();
elapsedTimeOffset = 0;
- wfx.nSamplesPerSec = settings.frequency();
+ wfx.nSamplesPerSec = settings.sampleRate();
wfx.wBitsPerSample = settings.sampleSize();
- wfx.nChannels = settings.channels();
+ wfx.nChannels = settings.channelCount();
wfx.cbSize = 0;
wfx.wFormatTag = WAVE_FORMAT_PCM;
if (deviceState == QAudio::StoppedState)
return 0;
qint64 result = qint64(1000000) * totalTimeValue /
- (settings.channels()*(settings.sampleSize()/8)) /
- settings.frequency();
+ (settings.channelCount()*(settings.sampleSize()/8)) /
+ settings.sampleRate();
return result;
}
int dir;
int err = 0;
int count=0;
- unsigned int freakuency=settings.frequency();
+ unsigned int sampleRate=settings.sampleRate();
if (!settings.isValid()) {
qWarning("QAudioOutput: open error, invalid format.");
}
}
if ( !fatal ) {
- err = snd_pcm_hw_params_set_channels( handle, hwparams, (unsigned int)settings.channels() );
+ err = snd_pcm_hw_params_set_channels( handle, hwparams, (unsigned int)settings.channelCount() );
if ( err < 0 ) {
fatal = true;
errMessage = QString::fromLatin1("QAudioOutput: snd_pcm_hw_params_set_channels: err = %1").arg(err);
}
}
if ( !fatal ) {
- err = snd_pcm_hw_params_set_rate_near( handle, hwparams, &freakuency, 0 );
+ err = snd_pcm_hw_params_set_rate_near( handle, hwparams, &sampleRate, 0 );
if ( err < 0 ) {
fatal = true;
errMessage = QString::fromLatin1("QAudioOutput: snd_pcm_hw_params_set_rate_near: err = %1").arg(err);
qint64 QAudioOutputPrivate::processedUSecs() const
{
- return qint64(1000000) * totalTimeValue / settings.frequency();
+ return qint64(1000000) * totalTimeValue / settings.sampleRate();
}
void QAudioOutputPrivate::resume()
m_device(0)
{
m_buffer = new QAudioRingBuffer(bufferSize + (bufferSize % maxPeriodSize == 0 ? 0 : maxPeriodSize - (bufferSize % maxPeriodSize)));
- m_bytesPerFrame = (audioFormat.sampleSize() / 8) * audioFormat.channels();
- m_periodTime = m_maxPeriodSize / m_bytesPerFrame * 1000 / audioFormat.frequency();
+ m_bytesPerFrame = (audioFormat.sampleSize() / 8) * audioFormat.channelCount();
+ m_periodTime = m_maxPeriodSize / m_bytesPerFrame * 1000 / audioFormat.sampleRate();
m_fillTimer = new QTimer(this);
connect(m_fillTimer, SIGNAL(timeout()), SLOT(fillBuffer()));
qint64 QAudioOutputPrivate::processedUSecs() const
{
- return totalFrames * 1000000 / audioFormat.frequency();
+ return totalFrames * 1000000 / audioFormat.sampleRate();
}
qint64 QAudioOutputPrivate::elapsedUSecs() const
} else if (settings.sampleSize() <= 0) {
qWarning("QAudioOutput: open error, invalid sample size (%d).",
settings.sampleSize());
- } else if (settings.frequency() < 8000 || settings.frequency() > 96000) {
- qWarning("QAudioOutput: open error, frequency out of range (%d).", settings.frequency());
+ } else if (settings.sampleRate() < 8000 || settings.sampleRate() > 96000) {
+ qWarning("QAudioOutput: open error, sample rate out of range (%d).", settings.sampleRate());
} else if (buffer_size == 0) {
// Default buffer size, 200ms, default period size is 40ms
buffer_size
- = (settings.frequency()
+ = (settings.sampleRate()
* settings.channelCount()
* settings.sampleSize()
+ 39) / 40;
timeStamp.restart();
elapsedTimeOffset = 0;
- wfx.nSamplesPerSec = settings.frequency();
+ wfx.nSamplesPerSec = settings.sampleRate();
wfx.wBitsPerSample = settings.sampleSize();
- wfx.nChannels = settings.channels();
+ wfx.nChannels = settings.channelCount();
wfx.cbSize = 0;
bool surround = false;
- if (settings.channels() > 2)
+ if (settings.channelCount() > 2)
surround = true;
wfx.wFormatTag = WAVE_FORMAT_PCM;
} else {
WAVEFORMATEXTENSIBLE wfex;
wfex.Format.wFormatTag = WAVE_FORMAT_EXTENSIBLE;
- wfex.Format.nChannels = settings.channels();
+ wfex.Format.nChannels = settings.channelCount();
wfex.Format.wBitsPerSample = settings.sampleSize();
- wfex.Format.nSamplesPerSec = settings.frequency();
+ wfex.Format.nSamplesPerSec = settings.sampleRate();
wfex.Format.nBlockAlign = wfex.Format.nChannels*wfex.Format.wBitsPerSample/8;
wfex.Format.nAvgBytesPerSec=wfex.Format.nSamplesPerSec*wfex.Format.nBlockAlign;
wfex.Samples.wValidBitsPerSample=wfex.Format.wBitsPerSample;
wfex.Format.cbSize=22;
wfex.dwChannelMask = SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT;
- if (settings.channels() >= 4)
+ if (settings.channelCount() >= 4)
wfex.dwChannelMask |= SPEAKER_BACK_LEFT | SPEAKER_BACK_RIGHT;
- if (settings.channels() >= 6)
+ if (settings.channelCount() >= 6)
wfex.dwChannelMask |= SPEAKER_FRONT_CENTER | SPEAKER_LOW_FREQUENCY;
- if (settings.channels() == 8)
+ if (settings.channelCount() == 8)
wfex.dwChannelMask |= SPEAKER_SIDE_LEFT | SPEAKER_SIDE_RIGHT;
if (waveOutOpen(&hWaveOut, UINT_PTR(deviceId), &wfex.Format,
deviceState = QAudio::StoppedState;
errorState = QAudio::NoError;
- int delay = (buffer_size-bytesFree())*1000/(settings.frequency()
- *settings.channels()*(settings.sampleSize()/8));
+ int delay = (buffer_size-bytesFree())*1000/(settings.sampleRate()
+ *settings.channelCount()*(settings.sampleSize()/8));
waveOutReset(hWaveOut);
Sleep(delay+10);
if (deviceState == QAudio::StoppedState)
return 0;
qint64 result = qint64(1000000) * totalTimeValue /
- (settings.channels()*(settings.sampleSize()/8)) /
- settings.frequency();
+ (settings.channelCount()*(settings.sampleSize()/8)) /
+ settings.sampleRate();
return result;
}
void QAudioOutputPrivate::suspend()
{
if(deviceState == QAudio::ActiveState || deviceState == QAudio::IdleState) {
- int delay = (buffer_size-bytesFree())*1000/(settings.frequency()
- *settings.channels()*(settings.sampleSize()/8));
+ int delay = (buffer_size-bytesFree())*1000/(settings.sampleRate()
+ *settings.channelCount()*(settings.sampleSize()/8));
waveOutPause(hWaveOut);
Sleep(delay+10);
deviceState = QAudio::SuspendedState;
{
pa_sample_spec spec;
- spec.rate = format.frequency();
- spec.channels = format.channels();
+ spec.rate = format.sampleRate();
+ spec.channels = format.channelCount();
if (format.sampleSize() == 8)
spec.format = PA_SAMPLE_U8;
int QWaveDecoder::duration() const
{
- return size() * 1000 / (format.sampleSize() / 8) / format.channels() / format.frequency();
+ return size() * 1000 / (format.sampleSize() / 8) / format.channelCount() / format.sampleRate();
}
qint64 QWaveDecoder::size() const
format.setSampleType(bps == 8 ? QAudioFormat::UnSignedInt : QAudioFormat::SignedInt);
format.setByteOrder(QAudioFormat::BigEndian);
- format.setFrequency(qFromBigEndian<quint32>(wave.sampleRate));
+ format.setSampleRate(qFromBigEndian<quint32>(wave.sampleRate));
format.setSampleSize(bps);
- format.setChannels(qFromBigEndian<quint16>(wave.numChannels));
+ format.setChannelCount(qFromBigEndian<quint16>(wave.numChannels));
} else {
int bps = qFromLittleEndian<quint16>(wave.bitsPerSample);
format.setSampleType(bps == 8 ? QAudioFormat::UnSignedInt : QAudioFormat::SignedInt);
format.setByteOrder(QAudioFormat::LittleEndian);
- format.setFrequency(qFromLittleEndian<quint32>(wave.sampleRate));
+ format.setSampleRate(qFromLittleEndian<quint32>(wave.sampleRate));
format.setSampleSize(bps);
- format.setChannels(qFromLittleEndian<quint16>(wave.numChannels));
+ format.setChannelCount(qFromLittleEndian<quint16>(wave.numChannels));
}
state = QWaveDecoder::WaitingForDataState;
m_position = 0;
m_state = QMediaRecorder::StoppedState;
- m_format.setFrequency(8000);
- m_format.setChannels(1);
+ m_format.setSampleRate(8000);
+ m_format.setChannelCount(1);
m_format.setSampleSize(8);
m_format.setSampleType(QAudioFormat::UnSignedInt);
m_format.setCodec("audio/pcm");
memcpy(header.wave.descriptor.id,"fmt ",4);
header.wave.descriptor.size = 16;
header.wave.audioFormat = 1; // for PCM data
- header.wave.numChannels = m_format.channels();
- header.wave.sampleRate = m_format.frequency();
- header.wave.byteRate = m_format.frequency()*m_format.channels()*m_format.sampleSize()/8;
- header.wave.blockAlign = m_format.channels()*m_format.sampleSize()/8;
+ header.wave.numChannels = m_format.channelCount();
+ header.wave.sampleRate = m_format.sampleRate();
+ header.wave.byteRate = m_format.sampleRate()*m_format.channelCount()*m_format.sampleSize()/8;
+ header.wave.blockAlign = m_format.channelCount()*m_format.sampleSize()/8;
header.wave.bitsPerSample = m_format.sampleSize();
memcpy(header.data.descriptor.id,"data",4);
header.data.descriptor.size = 0xFFFFFFFF; // This should be updated on stop(),samples*channels*sampleSize/8
QT_PREPEND_NAMESPACE(QAudioFormat) fmt;
fmt.setSampleSize(8);
- fmt.setChannels(1);
- fmt.setFrequency(8000);
+ fmt.setChannelCount(1);
+ fmt.setSampleRate(8000);
fmt.setSampleType(QT_PREPEND_NAMESPACE(QAudioFormat)::SignedInt);
fmt.setCodec("audio/pcm");
fmt.setByteOrder(QAudioFormat::LittleEndian);
if (continuous)
*continuous = false;
- return m_session->deviceInfo()->supportedFrequencies();
+ return m_session->deviceInfo()->supportedSampleRates();
}
QAudioEncoderSettings AudioEncoderControl::audioSettings() const
if (settings.encodingMode() == QtMultimedia::ConstantQualityEncoding) {
if (settings.quality() == QtMultimedia::LowQuality) {
fmt.setSampleSize(8);
- fmt.setChannels(1);
- fmt.setFrequency(8000);
+ fmt.setChannelCount(1);
+ fmt.setSampleRate(8000);
fmt.setSampleType(QAudioFormat::UnSignedInt);
} else if (settings.quality() == QtMultimedia::NormalQuality) {
fmt.setSampleSize(16);
- fmt.setChannels(1);
- fmt.setFrequency(22050);
+ fmt.setChannelCount(1);
+ fmt.setSampleRate(22050);
fmt.setSampleType(QAudioFormat::SignedInt);
} else {
fmt.setSampleSize(16);
- fmt.setChannels(1);
- fmt.setFrequency(44100);
+ fmt.setChannelCount(1);
+ fmt.setSampleRate(44100);
fmt.setSampleType(QAudioFormat::SignedInt);
}
} else {
- fmt.setChannels(settings.channelCount());
- fmt.setFrequency(settings.sampleRate());
+ fmt.setChannelCount(settings.channelCount());
+ fmt.setSampleRate(settings.sampleRate());
if (settings.sampleRate() == 8000 && settings.bitRate() == 8000) {
fmt.setSampleType(QAudioFormat::UnSignedInt);
fmt.setSampleSize(8);
QPulseAudioEngine *pulseEngine = QPulseAudioEngine::instance();
pa_threaded_mainloop_lock(pulseEngine->mainloop());
- qint64 bytesPerSecond = m_format.sampleRate() * m_format.channels() * m_format.sampleSize() / 8;
+ qint64 bytesPerSecond = m_format.sampleRate() * m_format.channelCount() * m_format.sampleSize() / 8;
pa_proplist *propList = pa_proplist_new();
if (m_category.isNull()) {
qint64 QPulseAudioOutput::processedUSecs() const
{
qint64 result = qint64(1000000) * m_totalTimeValue /
- (m_format.channels() * (m_format.sampleSize() / 8)) /
- m_format.frequency();
+ (m_format.channelCount() * (m_format.sampleSize() / 8)) /
+ m_format.sampleRate();
return result;
}
{
pa_sample_spec spec;
- spec.rate = format.frequency();
- spec.channels = format.channels();
+ spec.rate = format.sampleRate();
+ spec.channels = format.channelCount();
if (format.sampleSize() == 8) {
spec.format = PA_SAMPLE_U8;
QAudioFormat sampleSpecToAudioFormat(pa_sample_spec spec)
{
QAudioFormat format;
- format.setFrequency(spec.rate);
+ format.setSampleRate(spec.rate);
format.setChannelCount(spec.channels);
format.setCodec("audio/pcm");
// change output audio format
QAudioFormat format;
- format.setChannels(2);
+ format.setChannelCount(2);
format.setSampleSize(8);
- format.setFrequency(11050);
+ format.setSampleRate(11050);
format.setCodec("audio/pcm");
format.setSampleType(QAudioFormat::SignedInt);
// Now try changing formats
QAudioFormat format;
- format.setChannels(2);
+ format.setChannelCount(2);
format.setSampleSize(8);
- format.setFrequency(8000);
+ format.setSampleRate(8000);
format.setCodec("audio/pcm");
format.setSampleType(QAudioFormat::SignedInt);
void sampleSizes();
void byteOrders();
void sampleTypes();
- void frequencies();
+ void sampleRates();
void isFormatSupported();
void preferred();
void nearest();
void tst_QAudioDeviceInfo::channels()
{
- QList<int> avail = device->supportedChannels();
+ QList<int> avail = device->supportedChannelCounts();
QVERIFY(avail.size() > 0);
}
QVERIFY(avail.size() > 0);
}
-void tst_QAudioDeviceInfo::frequencies()
+void tst_QAudioDeviceInfo::sampleRates()
{
- QList<int> avail = device->supportedFrequencies();
+ QList<int> avail = device->supportedSampleRates();
QVERIFY(avail.size() > 0);
}
void tst_QAudioDeviceInfo::isFormatSupported()
{
QAudioFormat format;
- format.setFrequency(44100);
- format.setChannels(2);
+ format.setSampleRate(44100);
+ format.setChannelCount(2);
format.setSampleType(QAudioFormat::SignedInt);
format.setByteOrder(QAudioFormat::LittleEndian);
format.setSampleSize(16);
{
/*
QAudioFormat format1, format2;
- format1.setFrequency(8000);
+ format1.setSampleRate(8000);
format2 = device->nearestFormat(format1);
- QVERIFY(format2.frequency() == 44100);
+ QVERIFY(format2.sampleRate() == 44100);
*/
QAudioFormat format;
- format.setFrequency(44100);
- format.setChannels(2);
+ format.setSampleRate(44100);
+ format.setChannelCount(2);
format.setSampleType(QAudioFormat::SignedInt);
format.setByteOrder(QAudioFormat::LittleEndian);
format.setSampleSize(16);
QAudioFormat format2 = device->nearestFormat(format);
// This is definitely dependent on platform support (but isFormatSupported tests that above)
- QVERIFY(format2.frequency() == 44100);
+ QVERIFY(format2.sampleRate() == 44100);
}
// Returns a list of supported channel counts.
? QString("signed") : QString("unsigned");
return QString("%1_%2_%3_%4_%5")
- .arg(format.frequency())
+ .arg(format.sampleRate())
.arg(format.sampleSize())
.arg(formatSigned)
.arg(formatEndian)
- .arg(format.channels());
+ .arg(format.channelCount());
}
void tst_QAudioInput::initTestCase()
testFormats.append(audioDevice.preferredFormat());
// PCM 8000 mono S8
- format.setFrequency(8000);
+ format.setSampleRate(8000);
format.setSampleSize(8);
format.setSampleType(QAudioFormat::SignedInt);
format.setByteOrder(QAudioFormat::LittleEndian);
- format.setChannels(1);
+ format.setChannelCount(1);
if (audioDevice.isFormatSupported(format))
testFormats.append(format);
// PCM 11025 mono S16LE
- format.setFrequency(11025);
+ format.setSampleRate(11025);
format.setSampleSize(16);
if (audioDevice.isFormatSupported(format))
testFormats.append(format);
// PCM 22050 mono S16LE
- format.setFrequency(22050);
+ format.setSampleRate(22050);
if (audioDevice.isFormatSupported(format))
testFormats.append(format);
// PCM 22050 stereo S16LE
- format.setChannels(2);
+ format.setChannelCount(2);
if (audioDevice.isFormatSupported(format))
testFormats.append(format);
// PCM 44100 stereo S16LE
- format.setFrequency(44100);
+ format.setSampleRate(44100);
if (audioDevice.isFormatSupported(format))
testFormats.append(format);
// PCM 48000 stereo S16LE
- format.setFrequency(48000);
+ format.setSampleRate(48000);
if (audioDevice.isFormatSupported(format))
testFormats.append(format);
QAudioFormat requested = audioDevice.preferredFormat();
QAudioFormat actual = audioInput.format();
- QVERIFY2((requested.channels() == actual.channels()),
- QString("channels: requested=%1, actual=%2").arg(requested.channels()).arg(actual.channels()).toLocal8Bit().constData());
- QVERIFY2((requested.frequency() == actual.frequency()),
- QString("frequency: requested=%1, actual=%2").arg(requested.frequency()).arg(actual.frequency()).toLocal8Bit().constData());
+ QVERIFY2((requested.channelCount() == actual.channelCount()),
+ QString("channels: requested=%1, actual=%2").arg(requested.channelCount()).arg(actual.channelCount()).toLocal8Bit().constData());
+ QVERIFY2((requested.sampleRate() == actual.sampleRate()),
+ QString("sampleRate: requested=%1, actual=%2").arg(requested.sampleRate()).arg(actual.sampleRate()).toLocal8Bit().constData());
QVERIFY2((requested.sampleSize() == actual.sampleSize()),
QString("sampleSize: requested=%1, actual=%2").arg(requested.sampleSize()).arg(actual.sampleSize()).toLocal8Bit().constData());
QVERIFY2((requested.codec() == actual.codec()),
qint64 totalBytesRead = 0;
bool firstBuffer = true;
QByteArray buffer(AUDIO_BUFFER, 0);
- qint64 len = (testFormats.at(i).frequency()*testFormats.at(i).channels()*(testFormats.at(i).sampleSize()/8)*2); // 2 seconds
+ qint64 len = (testFormats.at(i).sampleRate()*testFormats.at(i).channelCount()*(testFormats.at(i).sampleSize()/8)*2); // 2 seconds
while (totalBytesRead < len) {
if (audioInput.bytesReady() >= audioInput.periodSize()) {
qint64 bytesRead = feed->read(buffer.data(), audioInput.periodSize());
qint64 totalBytesRead = 0;
bool firstBuffer = true;
QByteArray buffer(AUDIO_BUFFER, 0);
- qint64 len = (testFormats.at(i).frequency()*testFormats.at(i).channels()*(testFormats.at(i).sampleSize()/8)); // 1 seconds
+ qint64 len = (testFormats.at(i).sampleRate()*testFormats.at(i).channelCount()*(testFormats.at(i).sampleSize()/8)); // 1 seconds
while (totalBytesRead < len) {
if (audioInput.bytesReady() >= audioInput.periodSize()) {
qint64 bytesRead = feed->read(buffer.data(), audioInput.periodSize());
else
m_format.setByteOrder(QAudioFormat::BigEndian);
- m_format.setChannels(qFromLittleEndian<quint16>(header.wave.numChannels));
+ m_format.setChannelCount(qFromLittleEndian<quint16>(header.wave.numChannels));
m_format.setCodec("audio/pcm");
- m_format.setFrequency(qFromLittleEndian<quint32>(header.wave.sampleRate));
+ m_format.setSampleRate(qFromLittleEndian<quint32>(header.wave.sampleRate));
m_format.setSampleSize(qFromLittleEndian<quint16>(header.wave.bitsPerSample));
switch(header.wave.bitsPerSample) {
reinterpret_cast<unsigned char*>(&header.wave.descriptor.size));
qToLittleEndian<quint16>(quint16(1),
reinterpret_cast<unsigned char*>(&header.wave.audioFormat));
- qToLittleEndian<quint16>(quint16(m_format.channels()),
+ qToLittleEndian<quint16>(quint16(m_format.channelCount()),
reinterpret_cast<unsigned char*>(&header.wave.numChannels));
- qToLittleEndian<quint32>(quint32(m_format.frequency()),
+ qToLittleEndian<quint32>(quint32(m_format.sampleRate()),
reinterpret_cast<unsigned char*>(&header.wave.sampleRate));
- qToLittleEndian<quint32>(quint32(m_format.frequency() * m_format.channels() * m_format.sampleSize() / 8),
+ qToLittleEndian<quint32>(quint32(m_format.sampleRate() * m_format.channelCount() * m_format.sampleSize() / 8),
reinterpret_cast<unsigned char*>(&header.wave.byteRate));
- qToLittleEndian<quint16>(quint16(m_format.channels() * m_format.sampleSize() / 8),
+ qToLittleEndian<quint16>(quint16(m_format.channelCount() * m_format.sampleSize() / 8),
reinterpret_cast<unsigned char*>(&header.wave.blockAlign));
qToLittleEndian<quint16>(quint16(m_format.sampleSize()),
reinterpret_cast<unsigned char*>(&header.wave.bitsPerSample));
typedef QSharedPointer<QFile> FilePtr;
QString formatToFileName(const QAudioFormat &format);
- void createSineWaveData(const QAudioFormat &format, qint64 length, int frequency = 440);
+ void createSineWaveData(const QAudioFormat &format, qint64 length, int sampleRate = 440);
QAudioDeviceInfo audioDevice;
QList<QAudioFormat> testFormats;
? QString("signed") : QString("unsigned");
return QString("%1_%2_%3_%4_%5")
- .arg(format.frequency())
+ .arg(format.sampleRate())
.arg(format.sampleSize())
.arg(formatSigned)
.arg(formatEndian)
- .arg(format.channels());
+ .arg(format.channelCount());
}
-void tst_QAudioOutput::createSineWaveData(const QAudioFormat &format, qint64 length, int frequency)
+void tst_QAudioOutput::createSineWaveData(const QAudioFormat &format, qint64 length, int sampleRate)
{
const int channelBytes = format.sampleSize() / 8;
- const int sampleBytes = format.channels() * channelBytes;
+ const int sampleBytes = format.channelCount() * channelBytes;
Q_ASSERT(length % sampleBytes == 0);
Q_UNUSED(sampleBytes) // suppress warning in release builds
int sampleIndex = 0;
while (length) {
- const qreal x = qSin(2 * M_PI * frequency * qreal(sampleIndex % format.frequency()) / format.frequency());
- for (int i=0; i<format.channels(); ++i) {
+ const qreal x = qSin(2 * M_PI * sampleRate * qreal(sampleIndex % format.sampleRate()) / format.sampleRate());
+ for (int i=0; i<format.channelCount(); ++i) {
if (format.sampleSize() == 8 && format.sampleType() == QAudioFormat::UnSignedInt) {
const quint8 value = static_cast<quint8>((1.0 + x) / 2 * 255);
*reinterpret_cast<quint8*>(ptr) = value;
testFormats.append(audioDevice.preferredFormat());
// PCM 8000 mono S8
- format.setFrequency(8000);
+ format.setSampleRate(8000);
format.setSampleSize(8);
format.setSampleType(QAudioFormat::SignedInt);
format.setByteOrder(QAudioFormat::LittleEndian);
- format.setChannels(1);
+ format.setChannelCount(1);
if (audioDevice.isFormatSupported(format))
testFormats.append(format);
// PCM 11025 mono S16LE
- format.setFrequency(11025);
+ format.setSampleRate(11025);
format.setSampleSize(16);
if (audioDevice.isFormatSupported(format))
testFormats.append(format);
// PCM 22050 mono S16LE
- format.setFrequency(22050);
+ format.setSampleRate(22050);
if (audioDevice.isFormatSupported(format))
testFormats.append(format);
// PCM 22050 stereo S16LE
- format.setChannels(2);
+ format.setChannelCount(2);
if (audioDevice.isFormatSupported(format))
testFormats.append(format);
// PCM 44100 stereo S16LE
- format.setFrequency(44100);
+ format.setSampleRate(44100);
if (audioDevice.isFormatSupported(format))
testFormats.append(format);
// PCM 48000 stereo S16LE
- format.setFrequency(48000);
+ format.setSampleRate(48000);
if (audioDevice.isFormatSupported(format))
testFormats.append(format);
const QString temporaryAudioPath = m_temporaryDir->path() + slash;
foreach (const QAudioFormat &format, testFormats) {
- qint64 len = (format.frequency()*format.channels()*(format.sampleSize()/8)*2); // 2 seconds
+ qint64 len = (format.sampleRate()*format.channelCount()*(format.sampleSize()/8)*2); // 2 seconds
createSineWaveData(format, len);
// Write generate sine wave data to file
const QString fileName = temporaryAudioPath + QStringLiteral("generated")
QAudioFormat requested = audioDevice.preferredFormat();
QAudioFormat actual = audioOutput.format();
- QVERIFY2((requested.channels() == actual.channels()),
- QString("channels: requested=%1, actual=%2").arg(requested.channels()).arg(actual.channels()).toLocal8Bit().constData());
- QVERIFY2((requested.frequency() == actual.frequency()),
- QString("frequency: requested=%1, actual=%2").arg(requested.frequency()).arg(actual.frequency()).toLocal8Bit().constData());
+ QVERIFY2((requested.channelCount() == actual.channelCount()),
+ QString("channels: requested=%1, actual=%2").arg(requested.channelCount()).arg(actual.channelCount()).toLocal8Bit().constData());
+ QVERIFY2((requested.sampleRate() == actual.sampleRate()),
+ QString("sampleRate: requested=%1, actual=%2").arg(requested.sampleRate()).arg(actual.sampleRate()).toLocal8Bit().constData());
QVERIFY2((requested.sampleSize() == actual.sampleSize()),
QString("sampleSize: requested=%1, actual=%2").arg(requested.sampleSize()).arg(actual.sampleSize()).toLocal8Bit().constData());
QVERIFY2((requested.codec() == actual.codec()),
else
m_format.setByteOrder(QAudioFormat::BigEndian);
- m_format.setChannels(qFromLittleEndian<quint16>(header.wave.numChannels));
+ m_format.setChannelCount(qFromLittleEndian<quint16>(header.wave.numChannels));
m_format.setCodec("audio/pcm");
- m_format.setFrequency(qFromLittleEndian<quint32>(header.wave.sampleRate));
+ m_format.setSampleRate(qFromLittleEndian<quint32>(header.wave.sampleRate));
m_format.setSampleSize(qFromLittleEndian<quint16>(header.wave.bitsPerSample));
switch(header.wave.bitsPerSample) {
reinterpret_cast<unsigned char*>(&header.wave.descriptor.size));
qToLittleEndian<quint16>(quint16(1),
reinterpret_cast<unsigned char*>(&header.wave.audioFormat));
- qToLittleEndian<quint16>(quint16(m_format.channels()),
+ qToLittleEndian<quint16>(quint16(m_format.channelCount()),
reinterpret_cast<unsigned char*>(&header.wave.numChannels));
- qToLittleEndian<quint32>(quint32(m_format.frequency()),
+ qToLittleEndian<quint32>(quint32(m_format.sampleRate()),
reinterpret_cast<unsigned char*>(&header.wave.sampleRate));
- qToLittleEndian<quint32>(quint32(m_format.frequency() * m_format.channels() * m_format.sampleSize() / 8),
+ qToLittleEndian<quint32>(quint32(m_format.sampleRate() * m_format.channelCount() * m_format.sampleSize() / 8),
reinterpret_cast<unsigned char*>(&header.wave.byteRate));
- qToLittleEndian<quint16>(quint16(m_format.channels() * m_format.sampleSize() / 8),
+ qToLittleEndian<quint16>(quint16(m_format.channelCount() * m_format.sampleSize() / 8),
reinterpret_cast<unsigned char*>(&header.wave.blockAlign));
qToLittleEndian<quint16>(quint16(m_format.sampleSize()),
reinterpret_cast<unsigned char*>(&header.wave.bitsPerSample));
QVERIFY(d.sourceDevice() == 0);
QAudioFormat format;
- format.setChannels(2);
+ format.setChannelCount(2);
QVERIFY(!d.audioFormat().isValid());
d.setAudioFormat(format);
QVERIFY(!d.audioFormat().isValid());
QVERIFY(d.sourceDevice() == 0);
QAudioFormat format;
- format.setChannels(2);
+ format.setChannelCount(2);
QVERIFY(!d.audioFormat().isValid());
d.setAudioFormat(format);
QVERIFY(!d.audioFormat().isValid());
private slots:
void checkNull();
- void checkFrequency();
void checkSampleSize();
void checkCodec();
void checkByteOrder();
QAudioFormat audioFormat1(audioFormat0);
QVERIFY(!audioFormat1.isValid());
- audioFormat0.setFrequency(44100);
- audioFormat0.setChannels(2);
+ audioFormat0.setSampleRate(44100);
+ audioFormat0.setChannelCount(2);
audioFormat0.setSampleSize(16);
audioFormat0.setCodec("audio/pcm");
audioFormat0.setSampleType(QAudioFormat::SignedInt);
QVERIFY(audioFormat0.isValid());
}
-void tst_QAudioFormat::checkFrequency()
-{
- QAudioFormat audioFormat;
- audioFormat.setFrequency(44100);
- QVERIFY(audioFormat.frequency() == 44100);
-}
-
void tst_QAudioFormat::checkSampleSize()
{
QAudioFormat audioFormat;
QVERIFY(!(audioFormat0 != audioFormat1));
// on filled formats
- audioFormat0.setFrequency(8000);
- audioFormat0.setChannels(1);
+ audioFormat0.setSampleRate(8000);
+ audioFormat0.setChannelCount(1);
audioFormat0.setSampleSize(8);
audioFormat0.setCodec("audio/pcm");
audioFormat0.setByteOrder(QAudioFormat::LittleEndian);
audioFormat0.setSampleType(QAudioFormat::UnSignedInt);
- audioFormat1.setFrequency(8000);
- audioFormat1.setChannels(1);
+ audioFormat1.setSampleRate(8000);
+ audioFormat1.setChannelCount(1);
audioFormat1.setSampleSize(8);
audioFormat1.setCodec("audio/pcm");
audioFormat1.setByteOrder(QAudioFormat::LittleEndian);
QVERIFY(audioFormat0 == audioFormat1);
QVERIFY(!(audioFormat0 != audioFormat1));
- audioFormat0.setFrequency(44100);
+ audioFormat0.setSampleRate(44100);
QVERIFY(audioFormat0 != audioFormat1);
QVERIFY(!(audioFormat0 == audioFormat1));
}
QAudioFormat audioFormat0;
QAudioFormat audioFormat1;
- audioFormat0.setFrequency(8000);
- audioFormat0.setChannels(1);
+ audioFormat0.setSampleRate(8000);
+ audioFormat0.setChannelCount(1);
audioFormat0.setSampleSize(8);
audioFormat0.setCodec("audio/pcm");
audioFormat0.setByteOrder(QAudioFormat::LittleEndian);
// they should always be equal
QAudioFormat audioFormat;
QVERIFY(audioFormat.channelCount() == -1);
- QVERIFY(audioFormat.channels() == -1);
+ QVERIFY(audioFormat.channelCount() == -1);
audioFormat.setChannelCount(123);
QVERIFY(audioFormat.channelCount() == 123);
- QVERIFY(audioFormat.channels() == 123);
+ QVERIFY(audioFormat.channelCount() == 123);
- audioFormat.setChannels(5);
+ audioFormat.setChannelCount(5);
+ QVERIFY(audioFormat.channelCount() == 5);
QVERIFY(audioFormat.channelCount() == 5);
- QVERIFY(audioFormat.channels() == 5);
}
void tst_QAudioFormat::debugOperator_data()
, mPosition(-1)
, mSerial(0)
{
- mFormat.setChannels(1);
+ mFormat.setChannelCount(1);
mFormat.setSampleSize(8);
- mFormat.setFrequency(1000);
+ mFormat.setSampleRate(1000);
mFormat.setCodec("audio/x-raw");
mFormat.setSampleType(QAudioFormat::UnSignedInt);
}
qint64 duration() const
{
- return (sizeof(mSerial) * MOCK_DECODER_MAX_BUFFERS * qint64(1000)) / (mFormat.sampleRate() * mFormat.channels());
+ return (sizeof(mSerial) * MOCK_DECODER_MAX_BUFFERS * qint64(1000)) / (mFormat.sampleRate() * mFormat.channelCount());
}
private slots:
if (mBuffers.length() < 3) {
QByteArray b(sizeof(mSerial), 0);
memcpy(b.data(), &mSerial, sizeof(mSerial));
- qint64 position = (sizeof(mSerial) * mSerial * qint64(1000000)) / (mFormat.sampleRate() * mFormat.channels());
+ qint64 position = (sizeof(mSerial) * mSerial * qint64(1000000)) / (mFormat.sampleRate() * mFormat.channelCount());
mSerial++;
mBuffers.push_back(QAudioBuffer(b, mFormat, position));
emit bufferReady();
QVERIFY(waveDecoder.duration() == 250);
QAudioFormat format = waveDecoder.audioFormat();
QVERIFY(format.isValid());
- QVERIFY(format.channels() == channels);
+ QVERIFY(format.channelCount() == channels);
QVERIFY(format.sampleSize() == samplesize);
QVERIFY(format.sampleRate() == samplerate);
if (format.sampleSize() != 8) {
QVERIFY(waveDecoder.duration() == 250);
QAudioFormat format = waveDecoder.audioFormat();
QVERIFY(format.isValid());
- QVERIFY(format.channels() == channels);
+ QVERIFY(format.channelCount() == channels);
QVERIFY(format.sampleSize() == samplesize);
QVERIFY(format.sampleRate() == samplerate);
if (format.sampleSize() != 8) {
projects / platform / upstream / qtmultimedia.git / commitdiff