bool Engine::selectFormat()
{
bool foundSupportedFormat = false;
if (m_file || QAudioFormat() != m_format) {
QAudioFormat format = m_format;
if (m_file)
// Header is read from the WAV file; just need to check whether
// it is supported by the audio output device
format = m_file->fileFormat();
if (m_audioOutputDevice.isFormatSupported(format)) {
setFormat(format);
foundSupportedFormat = true;
}
} else {
QList<int> sampleRatesList;
if (!m_generateTone)
sampleRatesList += m_audioOutputDevice.supportedSampleRates();
sampleRatesList = sampleRatesList.toSet().toList(); // remove duplicates
qSort(sampleRatesList);
ENGINE_DEBUG << "Engine::initialize frequenciesList" << sampleRatesList;
QList<int> channelsList;
channelsList += m_audioOutputDevice.supportedChannelCounts();
channelsList = channelsList.toSet().toList();
qSort(channelsList);
ENGINE_DEBUG << "Engine::initialize channelsList" << channelsList;
QAudioFormat format;
format.setByteOrder(QAudioFormat::LittleEndian);
format.setCodec("audio/pcm");
format.setSampleSize(16);
format.setSampleType(QAudioFormat::SignedInt);
int sampleRate, channels;
foreach (sampleRate, sampleRatesList) {
if (foundSupportedFormat)
break;
format.setSampleRate(sampleRate);
foreach (channels, channelsList) {
format.setChannelCount(channels);
const bool outputSupport = m_audioOutputDevice.isFormatSupported(format);
ENGINE_DEBUG << "Engine::initialize checking " << format
<< "output" << outputSupport;
if (outputSupport)
{
foundSupportedFormat = true;
break;
}
}
}
if (!foundSupportedFormat)
format = QAudioFormat();
setFormat(format);
}
QMemoryAudioBufferProvider(const void *data, int frameCount, const QAudioFormat &format, qint64 startTime)
: mStartTime(startTime)
, mFrameCount(frameCount)
, mFormat(format)
{
int numBytes = format.bytesForFrames(frameCount);
if (numBytes > 0) {
mBuffer = malloc(numBytes);
if (!mBuffer) {
// OOM, if that's likely
mStartTime = -1;
mFrameCount = 0;
mFormat = QAudioFormat();
} else {
// Allocated, see if we have data to copy
if (data) {
memcpy(mBuffer, data, numBytes);
} else {
// We have to fill with the zero value..
switch (format.sampleType()) {
case QAudioFormat::SignedInt:
// Signed int means 0x80, 0x8000 is zero
// XXX this is not right for > 8 bits(0x8080 vs 0x8000)
memset(mBuffer, 0x80, numBytes);
break;
default:
memset(mBuffer, 0x0, numBytes);
}
}
}
} else
mBuffer = 0;
}
void MainWindow::stopRecord()
{
if (m_audio_recorder)
{
disconnect(m_audio_lib, &AudioStreamingLibCore::veryInputData, this, &MainWindow::writeToFile);
m_audio_recorder->deleteLater();
}
else if (m_audio_recorder_mp3)
{
disconnect(m_audio_lib, &AudioStreamingLibCore::veryInputData, this, &MainWindow::writeToFile);
m_audio_recorder_mp3->deleteLater();
}
m_total_size = 0;
linerecordpath->setEnabled(true);
buttonsearch->setEnabled(true);
buttonrecord->setText("Record");
buttonrecordstop->setEnabled(false);
m_paused = true;
lcdtime->display("--:--");
m_format = QAudioFormat();
}
/*!
Returns audio format for a sample.
If the buffer doesn't have a valid audio format, an empty QAudioFormat is returned.
*/
QAudioFormat QGstUtils::audioFormatForSample(GstSample *sample)
{
GstCaps* caps = gst_sample_get_caps(sample);
if (!caps)
return QAudioFormat();
return QGstUtils::audioFormatForCaps(caps);
}
QAudioFormat audioFormat( const int channels, const int sampleRate, AVSampleFormat sampleFormat )
{
QAudioFormat format;
format.setChannelCount( channels );
format.setCodec( "audio/pcm" );
switch (sampleFormat)
{
case AV_SAMPLE_FMT_U8: ///< unsigned 8 bits
format.setSampleSize(8);
format.setSampleType( QAudioFormat::UnSignedInt );
break;
case AV_SAMPLE_FMT_S16: ///< signed 16 bits
format.setSampleSize(16);
format.setSampleType( QAudioFormat::SignedInt );
break;
case AV_SAMPLE_FMT_S32: ///< signed 32 bits
format.setSampleSize(32);
format.setSampleType( QAudioFormat::SignedInt );
break;
case AV_SAMPLE_FMT_FLT: ///< float
format.setSampleSize(16);
format.setSampleType( QAudioFormat::Float );
break;
case AV_SAMPLE_FMT_DBL: ///< double
format.setSampleSize(32);
format.setSampleType( QAudioFormat::Float );
break;
case AV_SAMPLE_FMT_U8P: ///< unsigned 8 bits: planar
format.setSampleSize(8);
format.setSampleType( QAudioFormat::UnSignedInt );
break;
case AV_SAMPLE_FMT_S16P: ///< signed 16 bits: planar
format.setSampleSize(16);
format.setSampleType( QAudioFormat::SignedInt );
break;
case AV_SAMPLE_FMT_S32P: ///< signed 32 bits: planar
format.setSampleSize(32);
format.setSampleType( QAudioFormat::SignedInt );
break;
case AV_SAMPLE_FMT_FLTP: ///< float: planar
format.setSampleSize(16);
format.setSampleType( QAudioFormat::SignedInt );
break;
case AV_SAMPLE_FMT_DBLP: ///< double, planar
format.setSampleSize(32);
format.setSampleType( QAudioFormat::SignedInt );
break;
default:
qWarning() << "codec format: " << sampleFormat << AV_SAMPLE_FMT_NONE;
return QAudioFormat();
}
format.setSampleRate( sampleRate );
return format;
}
/*!
Returns audio format for a buffer.
If the buffer doesn't have a valid audio format, an empty QAudioFormat is returned.
*/
QAudioFormat QGstUtils::audioFormatForBuffer(GstBuffer *buffer)
{
GstCaps* caps = gst_buffer_get_caps(buffer);
if (!caps)
return QAudioFormat();
QAudioFormat format = QGstUtils::audioFormatForCaps(caps);
gst_caps_unref(caps);
return format;
}
QtBattleSounds::QtBattleSounds(QObject* parent) : BattleSounds(parent) {
audio = new QMediaPlayer(this);
cry = new QAudioOutput(QAudioFormat(), this);
connect(audio, &QMediaPlayer::stateChanged,
this, &QtBattleSounds::enqueueMusic);
connect(cry, &QAudioOutput::stateChanged,
this, &QtBattleSounds::cryStateChanged);
}
QString formatToString(const QAudioFormat &format)
{
QString result;
if (QAudioFormat() != format) {
if (format.codec() == "audio/pcm") {
Q_ASSERT(format.sampleType() == QAudioFormat::SignedInt);
const QString formatEndian = (format.byteOrder() == QAudioFormat::LittleEndian)
? QString("LE") : QString("BE");
QString formatType;
switch (format.sampleType()) {
case QAudioFormat::SignedInt:
formatType = "signed";
break;
case QAudioFormat::UnSignedInt:
formatType = "unsigned";
break;
case QAudioFormat::Float:
formatType = "float";
break;
case QAudioFormat::Unknown:
formatType = "unknown";
break;
}
QString formatChannels = QString("%1 channels").arg(format.channelCount());
switch (format.channelCount()) {
case 1:
formatChannels = "mono";
break;
case 2:
formatChannels = "stereo";
break;
}
result = QString("%1 Hz %2 bit %3 %4 %5")
.arg(format.sampleRate())
.arg(format.sampleSize())
.arg(formatType)
.arg(formatEndian)
.arg(formatChannels);
} else {
result = format.codec();
}
}
return result;
}
void Waveform::reset()
{
WAVEFORM_DEBUG << "Waveform::reset";
m_bufferPosition = 0;
m_buffer = QByteArray();
m_audioPosition = 0;
m_format = QAudioFormat();
m_active = false;
deletePixmaps();
m_tiles.clear();
m_tileLength = 0;
m_tileArrayStart = 0;
m_windowPosition = 0;
m_windowLength = 0;
}
QAudioFormat QAudioDeviceInfoInternal::preferredFormat() const
{
QAudioFormat format;
switch (m_mode) {
case QAudio::AudioOutput:
format.setFrequency(44100);
format.setChannels(2);
format.setSampleSize(16);
format.setByteOrder(QAudioFormat::LittleEndian);
format.setSampleType(QAudioFormat::SignedInt);
format.setCodec(QLatin1String("audio/pcm"));
break;
case QAudio::AudioInput:
format.setFrequency(8000);
format.setChannels(1);
format.setSampleSize(16);
format.setByteOrder(QAudioFormat::LittleEndian);
format.setSampleType(QAudioFormat::SignedInt);
format.setCodec(QLatin1String("audio/pcm"));
break;
default:
Q_ASSERT_X(false, Q_FUNC_INFO, "Invalid mode");
}
if (!isFormatSupported(format)) {
format = QAudioFormat();
format.setCodec(QLatin1String("audio/pcm"));
if (m_capabilities.contains(format.codec())) {
const Capabilities &codecCaps = m_capabilities[format.codec()];
if (codecCaps.m_frequencies.size())
format.setFrequency(codecCaps.m_frequencies[0]);
if (codecCaps.m_channels.size())
format.setChannels(codecCaps.m_channels[0]);
if (codecCaps.m_sampleSizes.size())
format.setSampleSize(codecCaps.m_sampleSizes[0]);
if (codecCaps.m_byteOrders.size())
format.setByteOrder(codecCaps.m_byteOrders[0]);
if (codecCaps.m_sampleTypes.size())
format.setSampleType(codecCaps.m_sampleTypes[0]);
}
}
return format;
}
void FTSound::load(int channelid){
if(channelid>1)
throw QString("built-in WAV file reader: Can read only the first and unique channel of the file.");
m_fileaudioformat = QAudioFormat(); // Clear the format
// Create the file reader and read the format
WavFile* pfile = new WavFile(this);
if(!pfile->open(fileFullPath))
throw QString("built-in WAV file reader: Cannot open the file.");
m_fileaudioformat = pfile->fileFormat();
// Check if the format is currently supported
if(!m_fileaudioformat.isValid())
throw QString("built-in WAV file reader: Format is invalid.");
if(m_fileaudioformat.channelCount()>1)
throw QString("built-in WAV file reader: This audio file has multiple audio channel, whereas the built-in reader can read files with only a single channel. Please convert this file into a mono audio file before re-opening it.");
if(!((m_fileaudioformat.codec() == "audio/pcm") &&
m_fileaudioformat.sampleType() == QAudioFormat::SignedInt &&
m_fileaudioformat.sampleSize() == 16 &&
m_fileaudioformat.byteOrder() == QAudioFormat::LittleEndian))
throw QString("built-in WAV file reader: Supports only 16 bit signed LE mono format, whereas current format is "+formatToString(m_fileaudioformat));
setSamplingRate(m_fileaudioformat.sampleRate());
// Load the waveform data from the file
pfile->seek(pfile->headerLength());
QByteArray buffer;
qint64 toread = m_fileaudioformat.sampleSize()/8;
qint64 red;
buffer.resize(toread);
while((red = pfile->read(buffer.data(),toread))) {
if(red<toread)
throw QString("built-in WAV file reader: The data are corrupted");
// Decode the data for 16 bit signed LE mono format
const qint16 value = *reinterpret_cast<const qint16*>(buffer.constData());
wav.push_back(value/32767.0);
}
delete pfile;
}
void Engine::reset()
{
stopPlayback();
setState(QAudio::AudioInput, QAudio::StoppedState);
setFormat(QAudioFormat());
m_generateTone = false;
delete m_file;
m_file = 0;
delete m_analysisFile;
m_analysisFile = 0;
m_buffer.clear();
m_bufferPosition = 0;
m_bufferLength = 0;
m_dataLength = 0;
emit dataLengthChanged(0);
resetAudioDevices();
}
QAudioFormat QGstUtils::audioFormatForCaps(const GstCaps *caps)
{
QAudioFormat format;
#if GST_CHECK_VERSION(1,0,0)
GstAudioInfo info;
if (gst_audio_info_from_caps(&info, caps)) {
for (int i = 0; i < lengthOf(qt_audioLookup); ++i) {
if (qt_audioLookup[i].format != info.finfo->format)
continue;
format.setSampleType(qt_audioLookup[i].sampleType);
format.setByteOrder(qt_audioLookup[i].byteOrder);
format.setSampleSize(qt_audioLookup[i].sampleSize);
format.setSampleRate(info.rate);
format.setChannelCount(info.channels);
format.setCodec(QStringLiteral("audio/pcm"));
return format;
}
}
#else
const GstStructure *structure = gst_caps_get_structure(caps, 0);
if (qstrcmp(gst_structure_get_name(structure), "audio/x-raw-int") == 0) {
format.setCodec("audio/pcm");
int endianness = 0;
gst_structure_get_int(structure, "endianness", &endianness);
if (endianness == 1234)
format.setByteOrder(QAudioFormat::LittleEndian);
else if (endianness == 4321)
format.setByteOrder(QAudioFormat::BigEndian);
gboolean isSigned = FALSE;
gst_structure_get_boolean(structure, "signed", &isSigned);
if (isSigned)
format.setSampleType(QAudioFormat::SignedInt);
else
format.setSampleType(QAudioFormat::UnSignedInt);
// Number of bits allocated per sample.
int width = 0;
gst_structure_get_int(structure, "width", &width);
// The number of bits used per sample. This must be less than or equal to the width.
int depth = 0;
gst_structure_get_int(structure, "depth", &depth);
if (width != depth) {
// Unsupported sample layout.
return QAudioFormat();
}
format.setSampleSize(width);
int rate = 0;
gst_structure_get_int(structure, "rate", &rate);
format.setSampleRate(rate);
int channels = 0;
gst_structure_get_int(structure, "channels", &channels);
format.setChannelCount(channels);
} else if (qstrcmp(gst_structure_get_name(structure), "audio/x-raw-float") == 0) {
format.setCodec("audio/pcm");
int endianness = 0;
gst_structure_get_int(structure, "endianness", &endianness);
if (endianness == 1234)
format.setByteOrder(QAudioFormat::LittleEndian);
else if (endianness == 4321)
format.setByteOrder(QAudioFormat::BigEndian);
format.setSampleType(QAudioFormat::Float);
int width = 0;
gst_structure_get_int(structure, "width", &width);
format.setSampleSize(width);
int rate = 0;
gst_structure_get_int(structure, "rate", &rate);
format.setSampleRate(rate);
int channels = 0;
gst_structure_get_int(structure, "channels", &channels);
format.setChannelCount(channels);
} else {
return QAudioFormat();
}
#endif
return format;
}
bool Engine::selectFormat()
{
bool foundSupportedFormat = false;
if (m_file || QAudioFormat() != m_format) {
QAudioFormat format = m_format;
if (m_file)
// Header is read from the WAV file; just need to check whether
// it is supported by the audio output device
format = m_file->fileFormat();
if (m_audioOutputDevice.isFormatSupported(format)) {
setFormat(format);
foundSupportedFormat = true;
}
} else {
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.
sampleRatesList += 8000;
#endif
if (!m_generateTone)
sampleRatesList += m_audioInputDevice.supportedSampleRates();
sampleRatesList += m_audioOutputDevice.supportedSampleRates();
sampleRatesList = sampleRatesList.toSet().toList(); // remove duplicates
qSort(sampleRatesList);
ENGINE_DEBUG << "Engine::initialize frequenciesList" << sampleRatesList;
QList<int> channelsList;
channelsList += m_audioInputDevice.supportedChannelCounts();
channelsList += m_audioOutputDevice.supportedChannelCounts();
channelsList = channelsList.toSet().toList();
qSort(channelsList);
ENGINE_DEBUG << "Engine::initialize channelsList" << channelsList;
QAudioFormat format;
format.setByteOrder(QAudioFormat::LittleEndian);
format.setCodec("audio/pcm");
format.setSampleSize(16);
format.setSampleType(QAudioFormat::SignedInt);
int sampleRate, channels;
foreach (sampleRate, sampleRatesList) {
if (foundSupportedFormat)
break;
format.setSampleRate(sampleRate);
foreach (channels, channelsList) {
format.setChannelCount(channels);
const bool inputSupport = m_generateTone ||
m_audioInputDevice.isFormatSupported(format);
const bool outputSupport = m_audioOutputDevice.isFormatSupported(format);
ENGINE_DEBUG << "Engine::initialize checking " << format
<< "input" << inputSupport
<< "output" << outputSupport;
if (inputSupport && outputSupport) {
foundSupportedFormat = true;
break;
}
}
}
if (!foundSupportedFormat)
format = QAudioFormat();
setFormat(format);
}
void tst_QAudioDecoderBackend::deviceTest()
{
QAudioDecoder d;
QAudioBuffer buffer;
quint64 duration = 0;
int sampleCount = 0;
QSignalSpy readySpy(&d, SIGNAL(bufferReady()));
QSignalSpy bufferChangedSpy(&d, SIGNAL(bufferAvailableChanged(bool)));
QSignalSpy errorSpy(&d, SIGNAL(error(QAudioDecoder::Error)));
QSignalSpy stateSpy(&d, SIGNAL(stateChanged(QAudioDecoder::State)));
QSignalSpy durationSpy(&d, SIGNAL(durationChanged(qint64)));
QSignalSpy finishedSpy(&d, SIGNAL(finished()));
QSignalSpy positionSpy(&d, SIGNAL(positionChanged(qint64)));
QVERIFY(d.state() == QAudioDecoder::StoppedState);
QVERIFY(d.bufferAvailable() == false);
QCOMPARE(d.sourceFilename(), QString(""));
QVERIFY(d.audioFormat() == QAudioFormat());
QFileInfo fileInfo(QFINDTESTDATA(TEST_FILE_NAME));
QFile file(fileInfo.absoluteFilePath());
QVERIFY(file.open(QIODevice::ReadOnly));
d.setSourceDevice(&file);
QVERIFY(d.sourceDevice() == &file);
QVERIFY(d.sourceFilename().isEmpty());
// We haven't set the format yet
QVERIFY(d.audioFormat() == QAudioFormat());
d.start();
QTRY_VERIFY(d.state() == QAudioDecoder::DecodingState);
QTRY_VERIFY(!stateSpy.isEmpty());
QTRY_VERIFY(!readySpy.isEmpty());
QTRY_VERIFY(!bufferChangedSpy.isEmpty());
QVERIFY(d.bufferAvailable());
QTRY_VERIFY(!durationSpy.isEmpty());
QVERIFY(qAbs(d.duration() - 1000) < 20);
buffer = d.read();
QVERIFY(buffer.isValid());
// Test file is 44.1K 16bit mono
QCOMPARE(buffer.format().channelCount(), 1);
QCOMPARE(buffer.format().sampleRate(), 44100);
QCOMPARE(buffer.format().sampleSize(), 16);
QCOMPARE(buffer.format().sampleType(), QAudioFormat::SignedInt);
QCOMPARE(buffer.format().codec(), QString("audio/pcm"));
QVERIFY(errorSpy.isEmpty());
duration += buffer.duration();
sampleCount += buffer.sampleCount();
// Now drain the decoder
if (sampleCount < 44094) {
QTRY_COMPARE(d.bufferAvailable(), true);
}
while (d.bufferAvailable()) {
buffer = d.read();
QVERIFY(buffer.isValid());
QTRY_VERIFY(!positionSpy.isEmpty());
QVERIFY(positionSpy.takeLast().at(0).toLongLong() == qint64(duration / 1000));
QVERIFY(d.position() - (duration / 1000) < 20);
duration += buffer.duration();
sampleCount += buffer.sampleCount();
if (sampleCount < 44094) {
QTRY_COMPARE(d.bufferAvailable(), true);
}
}
// Make sure the duration is roughly correct (+/- 20ms)
QCOMPARE(sampleCount, 44094);
QVERIFY(qAbs(qint64(duration) - 1000000) < 20000);
QVERIFY(qAbs((d.position() + (buffer.duration() / 1000)) - 1000) < 20);
QTRY_COMPARE(finishedSpy.count(), 1);
QVERIFY(!d.bufferAvailable());
QTRY_COMPARE(d.state(), QAudioDecoder::StoppedState);
d.stop();
QTRY_COMPARE(d.state(), QAudioDecoder::StoppedState);
QVERIFY(!d.bufferAvailable());
QTRY_COMPARE(durationSpy.count(), 2);
QCOMPARE(d.duration(), qint64(-1));
readySpy.clear();
bufferChangedSpy.clear();
stateSpy.clear();
durationSpy.clear();
finishedSpy.clear();
positionSpy.clear();
// Now try changing formats
QAudioFormat format;
format.setChannelCount(2);
format.setSampleSize(8);
format.setSampleRate(8000);
format.setCodec("audio/pcm");
format.setSampleType(QAudioFormat::SignedInt);
d.setAudioFormat(format);
// Make sure it stuck
QVERIFY(d.audioFormat() == format);
d.start();
QTRY_VERIFY(d.state() == QAudioDecoder::DecodingState);
QTRY_VERIFY(!stateSpy.isEmpty());
QTRY_VERIFY(!readySpy.isEmpty());
QTRY_VERIFY(!bufferChangedSpy.isEmpty());
QVERIFY(d.bufferAvailable());
QTRY_VERIFY(!durationSpy.isEmpty());
QVERIFY(qAbs(d.duration() - 1000) < 20);
buffer = d.read();
QVERIFY(buffer.isValid());
// See if we got the right format
QVERIFY(buffer.format() == format);
// The decoder should still have the same format
QVERIFY(d.audioFormat() == format);
QVERIFY(errorSpy.isEmpty());
d.stop();
QTRY_COMPARE(d.state(), QAudioDecoder::StoppedState);
QVERIFY(!d.bufferAvailable());
QTRY_COMPARE(durationSpy.count(), 2);
QCOMPARE(d.duration(), qint64(-1));
}
void tst_QAudioDecoderBackend::fileTest()
{
QAudioDecoder d;
QAudioBuffer buffer;
quint64 duration = 0;
int byteCount = 0;
int sampleCount = 0;
QVERIFY(d.state() == QAudioDecoder::StoppedState);
QVERIFY(d.bufferAvailable() == false);
QCOMPARE(d.sourceFilename(), QString(""));
QVERIFY(d.audioFormat() == QAudioFormat());
// Test local file
QFileInfo fileInfo(QFINDTESTDATA(TEST_FILE_NAME));
d.setSourceFilename(fileInfo.absoluteFilePath());
QVERIFY(d.state() == QAudioDecoder::StoppedState);
QVERIFY(!d.bufferAvailable());
QCOMPARE(d.sourceFilename(), fileInfo.absoluteFilePath());
QSignalSpy readySpy(&d, SIGNAL(bufferReady()));
QSignalSpy bufferChangedSpy(&d, SIGNAL(bufferAvailableChanged(bool)));
QSignalSpy errorSpy(&d, SIGNAL(error(QAudioDecoder::Error)));
QSignalSpy stateSpy(&d, SIGNAL(stateChanged(QAudioDecoder::State)));
QSignalSpy durationSpy(&d, SIGNAL(durationChanged(qint64)));
QSignalSpy finishedSpy(&d, SIGNAL(finished()));
QSignalSpy positionSpy(&d, SIGNAL(positionChanged(qint64)));
d.start();
QTRY_VERIFY(d.state() == QAudioDecoder::DecodingState);
QTRY_VERIFY(!stateSpy.isEmpty());
QTRY_VERIFY(!readySpy.isEmpty());
QTRY_VERIFY(!bufferChangedSpy.isEmpty());
QVERIFY(d.bufferAvailable());
QTRY_VERIFY(!durationSpy.isEmpty());
QVERIFY(qAbs(d.duration() - 1000) < 20);
buffer = d.read();
QVERIFY(buffer.isValid());
// Test file is 44.1K 16bit mono, 44094 samples
QCOMPARE(buffer.format().channelCount(), 1);
QCOMPARE(buffer.format().sampleRate(), 44100);
QCOMPARE(buffer.format().sampleSize(), 16);
QCOMPARE(buffer.format().sampleType(), QAudioFormat::SignedInt);
QCOMPARE(buffer.format().codec(), QString("audio/pcm"));
QCOMPARE(buffer.byteCount(), buffer.sampleCount() * 2); // 16bit mono
// The decoder should still have no format set
QVERIFY(d.audioFormat() == QAudioFormat());
QVERIFY(errorSpy.isEmpty());
duration += buffer.duration();
sampleCount += buffer.sampleCount();
byteCount += buffer.byteCount();
// Now drain the decoder
if (sampleCount < 44094) {
QTRY_COMPARE(d.bufferAvailable(), true);
}
while (d.bufferAvailable()) {
buffer = d.read();
QVERIFY(buffer.isValid());
QTRY_VERIFY(!positionSpy.isEmpty());
QVERIFY(positionSpy.takeLast().at(0).toLongLong() == qint64(duration / 1000));
duration += buffer.duration();
sampleCount += buffer.sampleCount();
byteCount += buffer.byteCount();
if (sampleCount < 44094) {
QTRY_COMPARE(d.bufferAvailable(), true);
}
}
// Make sure the duration is roughly correct (+/- 20ms)
QCOMPARE(sampleCount, 44094);
QCOMPARE(byteCount, 44094 * 2);
QVERIFY(qAbs(qint64(duration) - 1000000) < 20000);
QVERIFY(qAbs((d.position() + (buffer.duration() / 1000)) - 1000) < 20);
QTRY_COMPARE(finishedSpy.count(), 1);
QVERIFY(!d.bufferAvailable());
QTRY_COMPARE(d.state(), QAudioDecoder::StoppedState);
d.stop();
QTRY_COMPARE(d.state(), QAudioDecoder::StoppedState);
QTRY_COMPARE(durationSpy.count(), 2);
QCOMPARE(d.duration(), qint64(-1));
QVERIFY(!d.bufferAvailable());
readySpy.clear();
bufferChangedSpy.clear();
stateSpy.clear();
durationSpy.clear();
finishedSpy.clear();
positionSpy.clear();
// change output audio format
QAudioFormat format;
format.setChannelCount(2);
format.setSampleSize(8);
format.setSampleRate(11050);
format.setCodec("audio/pcm");
format.setSampleType(QAudioFormat::SignedInt);
d.setAudioFormat(format);
// We expect 1 second still, at 11050 * 2 samples == 22k samples.
// (at 1 byte/sample -> 22kb)
// Make sure it stuck
QVERIFY(d.audioFormat() == format);
duration = 0;
sampleCount = 0;
byteCount = 0;
d.start();
QTRY_VERIFY(d.state() == QAudioDecoder::DecodingState);
QTRY_VERIFY(!stateSpy.isEmpty());
QTRY_VERIFY(!readySpy.isEmpty());
QTRY_VERIFY(!bufferChangedSpy.isEmpty());
QVERIFY(d.bufferAvailable());
QTRY_VERIFY(!durationSpy.isEmpty());
QVERIFY(qAbs(d.duration() - 1000) < 20);
buffer = d.read();
QVERIFY(buffer.isValid());
// See if we got the right format
QVERIFY(buffer.format() == format);
// The decoder should still have the same format
QVERIFY(d.audioFormat() == format);
QVERIFY(errorSpy.isEmpty());
duration += buffer.duration();
sampleCount += buffer.sampleCount();
byteCount += buffer.byteCount();
// Now drain the decoder
if (duration < 998000) {
QTRY_COMPARE(d.bufferAvailable(), true);
}
while (d.bufferAvailable()) {
buffer = d.read();
QVERIFY(buffer.isValid());
QTRY_VERIFY(!positionSpy.isEmpty());
QVERIFY(positionSpy.takeLast().at(0).toLongLong() == qint64(duration / 1000));
QVERIFY(d.position() - (duration / 1000) < 20);
duration += buffer.duration();
sampleCount += buffer.sampleCount();
byteCount += buffer.byteCount();
if (duration < 998000) {
QTRY_COMPARE(d.bufferAvailable(), true);
}
}
// Resampling might end up with fewer or more samples
// so be a bit sloppy
QVERIFY(qAbs(sampleCount - 22047) < 100);
QVERIFY(qAbs(byteCount - 22047) < 100);
QVERIFY(qAbs(qint64(duration) - 1000000) < 20000);
QVERIFY(qAbs((d.position() + (buffer.duration() / 1000)) - 1000) < 20);
QTRY_COMPARE(finishedSpy.count(), 1);
QVERIFY(!d.bufferAvailable());
QTRY_COMPARE(d.state(), QAudioDecoder::StoppedState);
d.stop();
QTRY_COMPARE(d.state(), QAudioDecoder::StoppedState);
QTRY_COMPARE(durationSpy.count(), 2);
QCOMPARE(d.duration(), qint64(-1));
QVERIFY(!d.bufferAvailable());
}
QAudioFormat nearestFormat(const QAudioFormat& ) const { return QAudioFormat(); }
/*
The corrupted file is generated by copying a few random numbers
from /dev/random on a linux machine.
*/
void tst_QAudioDecoderBackend::corruptedFileTest()
{
QAudioDecoder d;
QAudioBuffer buffer;
QVERIFY(d.state() == QAudioDecoder::StoppedState);
QVERIFY(d.bufferAvailable() == false);
QCOMPARE(d.sourceFilename(), QString(""));
QVERIFY(d.audioFormat() == QAudioFormat());
// Test local file
QFileInfo fileInfo(QFINDTESTDATA(TEST_CORRUPTED_FILE_NAME));
d.setSourceFilename(fileInfo.absoluteFilePath());
QVERIFY(d.state() == QAudioDecoder::StoppedState);
QVERIFY(!d.bufferAvailable());
QCOMPARE(d.sourceFilename(), fileInfo.absoluteFilePath());
QSignalSpy readySpy(&d, SIGNAL(bufferReady()));
QSignalSpy bufferChangedSpy(&d, SIGNAL(bufferAvailableChanged(bool)));
QSignalSpy errorSpy(&d, SIGNAL(error(QAudioDecoder::Error)));
QSignalSpy stateSpy(&d, SIGNAL(stateChanged(QAudioDecoder::State)));
QSignalSpy durationSpy(&d, SIGNAL(durationChanged(qint64)));
QSignalSpy finishedSpy(&d, SIGNAL(finished()));
QSignalSpy positionSpy(&d, SIGNAL(positionChanged(qint64)));
d.start();
QTRY_VERIFY(d.state() == QAudioDecoder::StoppedState);
QVERIFY(!d.bufferAvailable());
QCOMPARE(d.audioFormat(), QAudioFormat());
QCOMPARE(d.duration(), qint64(-1));
QCOMPARE(d.position(), qint64(-1));
// Check the error code.
QTRY_VERIFY(!errorSpy.isEmpty());
// Have to use qvariant_cast, toInt will return 0 because unrecognized type;
QAudioDecoder::Error errorCode = qvariant_cast<QAudioDecoder::Error>(errorSpy.takeLast().at(0));
QCOMPARE(errorCode, QAudioDecoder::FormatError);
QCOMPARE(d.error(), QAudioDecoder::FormatError);
// Check all other spies.
QVERIFY(readySpy.isEmpty());
QVERIFY(bufferChangedSpy.isEmpty());
QVERIFY(stateSpy.isEmpty());
QVERIFY(finishedSpy.isEmpty());
QVERIFY(positionSpy.isEmpty());
QVERIFY(durationSpy.isEmpty());
errorSpy.clear();
// Try read even if the file is corrupted to test the robustness.
buffer = d.read();
QTRY_VERIFY(d.state() == QAudioDecoder::StoppedState);
QVERIFY(!buffer.isValid());
QVERIFY(!d.bufferAvailable());
QCOMPARE(d.position(), qint64(-1));
QVERIFY(errorSpy.isEmpty());
QVERIFY(readySpy.isEmpty());
QVERIFY(bufferChangedSpy.isEmpty());
QVERIFY(stateSpy.isEmpty());
QVERIFY(finishedSpy.isEmpty());
QVERIFY(positionSpy.isEmpty());
QVERIFY(durationSpy.isEmpty());
d.stop();
QTRY_COMPARE(d.state(), QAudioDecoder::StoppedState);
QCOMPARE(d.duration(), qint64(-1));
QVERIFY(!d.bufferAvailable());
}
QAudioFormat format() const { return QAudioFormat(); }
QAudioFormat preferredFormat() const { qWarning()<<"using null deviceinfo, none available"; return QAudioFormat(); }
QAudioFormat QAudioDeviceInfo::preferredFormat() const
{
return isNull() ? QAudioFormat() : d->info->preferredFormat();
}
/*!
Returns the \l {QAudioFormat}{format} of this buffer.
Several properties of this format influence how
the \l duration() or \l byteCount() are calculated
from the \l frameCount().
*/
QAudioFormat QAudioBuffer::format() const
{
if (!isValid())
return QAudioFormat();
return d->mProvider->format();
}
void FileProbeProxy::stopProbes()
{
m_format = QAudioFormat();
}
QAudioFormat QAudioDeviceInfo::nearestFormat(const QAudioFormat &settings) const
{
return isNull() ? QAudioFormat() : d->info->nearestFormat(settings);
}
//Carson
AudioManager::AudioManager(QObject * par) : parent(par) {
audio = new QAudioOutput(QAudioFormat(), par);
songState = Stopped;
}