void S60AudioEncoderControl::setAudioSettings(const QAudioEncoderSettings &settings)
{
QAudioFormat fmt = m_session->format();
if (settings.encodingMode() == QtMultimediaKit::ConstantQualityEncoding) {
fmt.setCodec(settings.codec());
setQuality(settings.quality(), fmt);
if (settings.sampleRate() > 0) {
fmt.setFrequency(settings.sampleRate());
}
if (settings.channelCount() > 0)
fmt.setChannels(settings.channelCount());
}else {
if (settings.sampleRate() == 8000) {
fmt.setSampleType(QAudioFormat::UnSignedInt);
fmt.setSampleSize(8);
} else {
fmt.setSampleType(QAudioFormat::SignedInt);
fmt.setSampleSize(16);
}
fmt.setCodec(settings.codec());
fmt.setFrequency(settings.sampleRate());
fmt.setChannels(settings.channelCount());
}
m_session->setFormat(fmt);
m_settings = settings;
}
void S60AudioEncoderControl::setQuality(QtMultimediaKit::EncodingQuality value, QAudioFormat &fmt)
{
switch (value) {
case QtMultimediaKit::VeryLowQuality:
case QtMultimediaKit::LowQuality:
// low, 8000Hz mono U8
fmt.setSampleType(QAudioFormat::UnSignedInt);
fmt.setSampleSize(8);
fmt.setFrequency(8000);
fmt.setChannels(1);
break;
case QtMultimediaKit::NormalQuality:
// medium, 22050Hz mono S16
fmt.setSampleType(QAudioFormat::SignedInt);
fmt.setSampleSize(16);
fmt.setFrequency(22050);
fmt.setChannels(1);
break;
case QtMultimediaKit::HighQuality:
case QtMultimediaKit::VeryHighQuality:
// high, 44100Hz mono S16
fmt.setSampleType(QAudioFormat::SignedInt);
fmt.setSampleSize(16);
fmt.setFrequency(44100);
fmt.setChannels(2);
break;
default:
break;
}
}
void xmppClient::slotConnected()
{
QXmppCall *call = qobject_cast<QXmppCall*>(sender());
Q_ASSERT(call);
qDebug() << "Call connected";
QXmppRtpChannel *channel = call->audioChannel();
// prepare audio format
QAudioFormat format;
format.setFrequency(channel->payloadType().clockrate());
format.setChannels(channel->payloadType().channels());
format.setSampleSize(16);
format.setCodec("audio/pcm");
format.setByteOrder(QAudioFormat::LittleEndian);
format.setSampleType(QAudioFormat::SignedInt);
// the size in bytes of the audio buffers to/from sound devices
// 160 ms seems to be the minimum to work consistently on Linux/Mac/Windows
const int bufferSize = (format.frequency() * format.channels() * (format.sampleSize() / 8) * 160) / 1000;
// initialise audio output
QAudioOutput *audioOutput = new QAudioOutput(format, this);
audioOutput->setBufferSize(bufferSize);
audioOutput->start(channel);
// initialise audio input
QAudioInput *audioInput = new QAudioInput(format, this);
audioInput->setBufferSize(bufferSize);
audioInput->start(channel);
}
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;
}
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(11025);
nearest.setChannels(1);
nearest.setSampleType(QAudioFormat::SignedInt);
nearest.setSampleSize(8);
nearest.setCodec(QLatin1String("audio/pcm"));
}
return nearest;
}
explicit DeviceAudioOutput(int sampleRate) :
AudioOutput(sampleRate) {
format.setChannels(2);
format.setFrequency(sampleRate);
format.setSampleSize(16);
format.setCodec("audio/pcm");
format.setSampleType(QAudioFormat::SignedInt);
out = new QAudioOutput(format);
device = 0;
memset(buffer, 0, sizeof(char) * kUnitBufferLength);
}
MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow), m_timer(), m_totalNeededTime(0,0), m_spentTime(0,0), m_belowAlarmTime(false), m_belowEndTime(false),
m_dbusInterface(0), m_alarmTime(60), m_useLED(true), m_useSounds(true)
{
ui->setupUi(this);
m_topics.push_back(new AgendaTopic("topic #1", QTime(0,5)));
m_topics.push_back(new AgendaTopic("topic #2", QTime(0,15)));
calculateTotalTimes();
m_currentTopic = 1;
mainWindowSetup();
setupMenus();
connect(ui->next, SIGNAL(clicked()), this, SLOT(switchToNextTopic()));
connect(ui->previous, SIGNAL(clicked()), this, SLOT(switchToPreviousTopic()));
connect(ui->start, SIGNAL(clicked()), this, SLOT(startOrStop()));
connect(ui->plus15, SIGNAL(clicked()), this, SLOT(add15m()));
connect(ui->plus5, SIGNAL(clicked()), this, SLOT(add5m()));
connect(ui->plus1, SIGNAL(clicked()), this, SLOT(add1m()));
connect(ui->minus15, SIGNAL(clicked()), this, SLOT(minus15m()));
connect(ui->minus5, SIGNAL(clicked()), this, SLOT(minus5m()));
connect(ui->minus1, SIGNAL(clicked()), this, SLOT(minus1m()));
connect(&m_timer, SIGNAL(timeout()), this, SLOT(timeElapsed()));
#ifdef IS_MAEMO
m_dbusInterface = new QDBusInterface(MCE_SERVICE, MCE_REQUEST_PATH, MCE_REQUEST_IF, QDBusConnection::systemBus(), this);
QDBusMessage reply = m_dbusInterface->call(MCE_ENABLE_LED);
if (reply.type() == QDBusMessage::ErrorMessage)
qDebug() << reply.errorMessage();
#endif
// set up the output audio
QAudioFormat format;
// Set up the format, eg.
format.setFrequency(44100);
format.setChannels(1);
format.setSampleSize(16);
format.setCodec("audio/pcm");
format.setByteOrder(QAudioFormat::LittleEndian);
format.setSampleType(QAudioFormat::SignedInt);
QAudioDeviceInfo info(QAudioDeviceInfo::defaultOutputDevice());
m_audioOut = new QAudioOutput(format);
// connect(m_audioOut,SIGNAL(stateChanged(QAudio::State)),SLOT(finishedPlaying(QAudio::State)));
}
QAudioOutput *
MainWindow::createAudioOutput()
{
QAudioFormat settings;
settings.setFrequency(44100);
settings.setChannels(1);
settings.setSampleSize(16);
settings.setCodec("audio/pcm");
settings.setByteOrder(QAudioFormat::LittleEndian);
settings.setSampleType(QAudioFormat::SignedInt);
m_audioOutput = new QAudioOutput(settings);
return m_audioOutput;
}
void S60AudioEncoderControl::setEncodingOption(
const QString &codec, const QString &name, const QVariant &value)
{
if (codec == "PCM") {
QAudioFormat fmt = m_session->format();
if(qstrcmp(name.toLocal8Bit().constData(), "quality") == 0) {
setQuality((QtMultimediaKit::EncodingQuality)value.toInt(), fmt);
} else if(qstrcmp(name.toLocal8Bit().constData(), "channels") == 0) {
fmt.setChannels(value.toInt());
} else if(qstrcmp(name.toLocal8Bit().constData(), "samplerate") == 0) {
fmt.setFrequency(value.toInt());
}
m_session->setFormat(fmt);
}
}
void S60AudioEncoderControl::setEncodingOption(
const QString &codec, const QString &name, const QVariant &value)
{
TRACE("S60AudioEncoderControl::setEncodingOption" << qtThisPtr()
<< "codec" << codec << "name" << name << "value" << value);
if (codec == "PCM") {
QAudioFormat fmt = m_session->format();
if(qstrcmp(name.toLocal8Bit().constData(), "quality") == 0)
setQuality((QtMultimediaKit::EncodingQuality)value.toInt(), fmt);
else if(qstrcmp(name.toLocal8Bit().constData(), "channels") == 0)
fmt.setChannels(value.toInt());
else if(qstrcmp(name.toLocal8Bit().constData(), "samplerate") == 0)
fmt.setFrequency(value.toInt());
m_session->setFormat(fmt);
}
}
/* channelCount() API property test. */
void tst_QAudioFormat::checkChannelCount()
{
// channels is the old name for channelCount, so
// they should always be equal
QAudioFormat audioFormat;
QVERIFY(audioFormat.channelCount() == -1);
QVERIFY(audioFormat.channels() == -1);
audioFormat.setChannelCount(123);
QVERIFY(audioFormat.channelCount() == 123);
QVERIFY(audioFormat.channels() == 123);
audioFormat.setChannels(5);
QVERIFY(audioFormat.channelCount() == 5);
QVERIFY(audioFormat.channels() == 5);
}
void StreamOutputWidget::startButtonClicked()
{
qDebug("void StreamOutputWidget::startButtonClicked()");
//Get available output devices...
QList<QAudioDeviceInfo> myList = QAudioDeviceInfo::availableDevices(QAudio::AudioOutput);
if (m_audioOutput)
{
delete m_audioOutput;
m_audioOutput = NULL;
}
for (int i =0; i < myList.size(); i++)
{
if (myList[i].deviceName() == m_ui.m_comboDeviceSelection->currentText())
{
//QAudioFormat
QAudioFormat format;
//Set up the format
format.setFrequency(48000);
format.setChannels(1);
format.setSampleSize(16);
format.setCodec("audio/pcm");
format.setByteOrder(QAudioFormat::LittleEndian);
format.setSampleType(QAudioFormat::SignedInt);
m_audioOutput = new QAudioOutput(myList[i],format,this);
//m_audioOutput = new QAudioOutput(QAudioDeviceInfo::defaultOutputDevice(),format,this);
//We have 10ms frames, this should be enough
m_audioOutput->setNotifyInterval(5);
}
}
if (m_audioOutput)
{
connect(m_audioOutput,SIGNAL(stateChanged(QAudio::State)),this,SLOT(audioStateChanged(QAudio::State)));
connect(m_audioOutput,SIGNAL(notify()),this,SLOT(notify()));
m_audioOutput->setBufferSize(1000000);
m_IODevice = m_audioOutput->start();
m_ui.m_controlTextEdit->append("Starting stream... \n");
m_ui.m_startButton->setEnabled(false);
m_ui.m_stopButton->setEnabled(true);
}
}
S60AudioEncoderControl::S60AudioEncoderControl(QObject *session, QObject *parent)
:QAudioEncoderControl(parent), m_quality(QtMultimediaKit::NormalQuality)
{
m_session = qobject_cast<S60AudioCaptureSession*>(session);
QAudioFormat fmt = m_session->format();
// medium, 22050Hz mono S16
fmt.setSampleType(QAudioFormat::SignedInt);
if (fmt.codec().compare("PCM", Qt::CaseInsensitive) == 0) {
fmt.setSampleSize(16);
fmt.setFrequency(22050);
}
fmt.setChannels(1);
m_session->setFormat(fmt);
m_settings.setChannelCount(fmt.channels());
m_settings.setCodec(fmt.codec());
m_settings.setSampleRate(fmt.sampleRate());
}
bool AudioHelper::AudioInputIsOK()
{
QAudioFormat format;
format.setFrequency(22050);
format.setChannels(1);
format.setSampleSize(16);
format.setCodec("audio/pcm");
format.setByteOrder(QAudioFormat::LittleEndian);
format.setSampleType(QAudioFormat::UnSignedInt);
QAudioDeviceInfo info(QAudioDeviceInfo::defaultInputDevice());
if (!info.isFormatSupported(format)) {
AudioHelperDebug("no default input device");
return false;
}
return true;
}
// Conversion
QAudioFormat toQAudioFormat(AudioStreamBasicDescription const& sf)
{
QAudioFormat audioFormat;
audioFormat.setFrequency(sf.mSampleRate);
audioFormat.setChannels(sf.mChannelsPerFrame);
audioFormat.setSampleSize(sf.mBitsPerChannel);
audioFormat.setCodec(QString::fromLatin1("audio/pcm"));
audioFormat.setByteOrder((sf.mFormatFlags & kAudioFormatFlagIsBigEndian) != 0 ? QAudioFormat::BigEndian : QAudioFormat::LittleEndian);
QAudioFormat::SampleType type = QAudioFormat::UnSignedInt;
if ((sf.mFormatFlags & kAudioFormatFlagIsSignedInteger) != 0)
type = QAudioFormat::SignedInt;
else if ((sf.mFormatFlags & kAudioFormatFlagIsFloat) != 0)
type = QAudioFormat::Float;
audioFormat.setSampleType(type);
return audioFormat;
}
int InitAudio(){
QAudioFormat format;
format.setFrequency(22050);
format.setChannels(1);
format.setSampleSize(16);
format.setCodec("audio/pcm");
format.setByteOrder(QAudioFormat::LittleEndian);
format.setSampleType(QAudioFormat::SignedInt);
QAudioDeviceInfo info(QAudioDeviceInfo::defaultOutputDevice());
emuWindow->audioOut = new QAudioOutput(info, format, emuWindow);
if(emuWindow->audioOut){
emuWindow->setDevice();
return 1;
}else{
return 0;
}
}
WLAudio::WLAudio():
m_adLib(false), m_soundBlaster(false), m_soundPositioned(0),
m_numReadySamples(0), m_curAlSound(0), m_curAlSoundPtr(0), m_curAlLengthLeft(0),
m_soundTimeCounter(5), m_originalSampleRate(7042), m_sqMaxTracks(10),
m_alChar(0x20), m_alScale(0x40), m_alAttack(0x60), m_alSus(0x80), m_alWave(0xe0),
m_alFreqL(0xa0), m_alFreqH(0xb0), m_alFeedCon(0xc0), m_alEffects(0xbd),
m_nextSoundPos(false)
{
QAudioFormat format;
#if QT_VERSION >= 0x050000
format.setSampleRate(param_samplerate);
format.setChannelCount(2);
#else
format.setFrequency(param_samplerate);
format.setChannels(2);
#endif
format.setByteOrder(QAudioFormat::LittleEndian);
format.setCodec("audio/pcm");
format.setSampleSize(16);
format.setSampleType(QAudioFormat::SignedInt);
m_soundServer = new GameSoundServer(format);
m_samplesPerMusicTick = param_samplerate / 700;
if(YM3812Init(1,3579545,param_samplerate)) {
printf("Unable to create virtual OPL!!\n");
}
for(int i = 1;i < 0xf6;i++)
YM3812Write(0,i,0);
YM3812Write(0, 1, 0x20); // Set WSE=1
m_adLib = true;
m_soundBlaster = true;
m_alTimeCount = 0;
setSoundMode(sdm_Off);
setMusicMode(smm_Off);
setupDigi();
}
/*!
Constructor.
*/
AudioOut::AudioOut(AudioSource *source, QObject *parent /* = 0 */)
: QThread(parent),
m_audioOutput(0),
m_outTarget(0),
m_source(source),
m_sendBuffer(0),
m_sendBufferSize(0),
m_samplesMixed(0),
m_threadState(NotRunning),
m_usingThread(false)
{
QAudioFormat format;
format.setFrequency(AUDIO_FREQUENCY);
format.setChannels(GEDefaultChannelCount);
format.setSampleSize(AUDIO_SAMPLE_BITS);
format.setCodec(GEDefaultAudioCodec);
format.setByteOrder(GEByteOrder);
format.setSampleType(GESampleType);
QAudioDeviceInfo info(QAudioDeviceInfo::defaultOutputDevice());
if (!info.isFormatSupported(format))
format = info.nearestFormat(format);
m_audioOutput = new QAudioOutput(info, format);
m_audioOutput->setBufferSize(4096 * 8);
m_sendBufferSize = 4096 * 8;
m_outTarget = m_audioOutput->start();
DEBUG_INFO("Buffer size: " << m_audioOutput->bufferSize());
m_sendBuffer = new AUDIO_SAMPLE_TYPE[m_sendBufferSize];
#ifndef Q_OS_SYMBIAN
m_usingThread = true;
start();
#endif
}
bool OutputQtMultimedia::initialize(quint32 freq, ChannelMap map, Qmmp::AudioFormat format)
{
QAudioFormat qformat;
qformat.setCodec("audio/pcm");
qformat.setFrequency(freq);
qformat.setByteOrder(QAudioFormat::LittleEndian);
qformat.setChannels(map.size());
qformat.setSampleType(QAudioFormat::SignedInt);
//Size of sample representation in input data. For 24-bit is 4, high byte is ignored.
qint64 bytes_per_sample = 0;
switch (format)
{
case Qmmp::PCM_S8:
qformat.setSampleSize(8);
bytes_per_sample = 1;
break;
case Qmmp::PCM_S16LE:
qformat.setSampleSize(16);
bytes_per_sample = 2;
break;
case Qmmp::PCM_S24LE:
qformat.setSampleSize(24);
bytes_per_sample = 4;
break;
case Qmmp::PCM_S32LE:
qformat.setSampleSize(32);
bytes_per_sample = 4;
break;
default:
break;
}
if (!qformat.isValid())
return false;
m_bytes_per_second = bytes_per_sample * freq * qformat.channels();
const QSettings settings(Qmmp::configFile(), QSettings::IniFormat);
const QString saved_device_name = settings.value("QTMULTIMEDIA/device").toString();
QAudioDeviceInfo device_info;
if (!saved_device_name.isEmpty())
{
const QList<QAudioDeviceInfo> devices = QAudioDeviceInfo::availableDevices(QAudio::AudioOutput);
foreach (const QAudioDeviceInfo &info, devices)
{
if (info.deviceName()==saved_device_name)
{
if (info.isFormatSupported(qformat))
{
device_info = info;
break;
}
else
qDebug() << "OutputQtMultimedia: Output device: " << saved_device_name << " is not supported";
}
}
}
if (device_info.isNull())
{
device_info = QAudioDeviceInfo::defaultOutputDevice();
if (!device_info.isFormatSupported(qformat))
return false;
}
qDebug() << "OutputQtMultimedia: Using output device: " << device_info.deviceName();
m_output.reset(new QAudioOutput(device_info, qformat));
m_buffer = m_output->start();
configure(freq, map, format);
return true;
}
void tst_QAudioFormat::checkChannels()
{
QAudioFormat audioFormat;
audioFormat.setChannels(2);
QVERIFY(audioFormat.channels() == 2);
}
/*!
Constructor.
*/
PushAudioOut::PushAudioOut(AudioSource *source, QObject *parent /* = 0 */)
: QThread(parent),
m_audioOutput(0),
m_outTarget(0),
m_sendBuffer(0),
m_sendBufferSize(0),
m_samplesMixed(0),
m_threadState(NotRunning),
m_source(source)
{
DEBUG_INFO(this);
QAudioFormat format;
format.setFrequency(AUDIO_FREQUENCY);
format.setChannels(AUDIO_CHANNELS);
format.setSampleSize(AUDIO_SAMPLE_BITS);
format.setCodec(GEDefaultAudioCodec);
switch (GEByteOrder) {
case BigEndian:
format.setByteOrder(QAudioFormat::BigEndian);
break;
case LittleEndian:
format.setByteOrder(QAudioFormat::LittleEndian);
break;
default:
DEBUG_INFO("INVALID BYTE ORDER");
}
switch (GESampleType) {
case Unknown:
format.setSampleType(QAudioFormat::Unknown);
break;
case SignedInt:
format.setSampleType(QAudioFormat::SignedInt);
break;
case UnSignedInt:
format.setSampleType(QAudioFormat::UnSignedInt);
break;
case Float:
format.setSampleType(QAudioFormat::Float);
break;
default:
DEBUG_INFO("INVALID SAMPLE TYPE");
}
QAudioDeviceInfo info(QAudioDeviceInfo::defaultOutputDevice());
if (!info.isFormatSupported(format))
format = info.nearestFormat(format);
m_audioOutput = new QAudioOutput(info, format);
#if defined(Q_WS_MAEMO_5) || defined(MEEGO_EDITION_HARMATTAN)
m_sendBufferSize = 4096 * 4;
#else
m_audioOutput->setBufferSize(4096 * 4);
#endif
#if defined(Q_WS_MAEMO_5) || defined(MEEGO_EDITION_HARMATTAN)
m_audioOutput->setBufferSize(4096 * 16);
m_sendBufferSize = 4096 * 8;
#else
m_audioOutput->setBufferSize(4096 * 4);
m_sendBufferSize = 4096 * 2;
#endif
DEBUG_INFO("Buffer size: " << m_audioOutput->bufferSize());
m_sendBuffer = new AUDIO_SAMPLE_TYPE[m_sendBufferSize];
m_needsTick = false;
#if defined(QTGAMEENABLER_USE_VOLUME_HACK) && defined(Q_OS_SYMBIAN)
DEBUG_INFO("WARNING: Using the volume hack!");
// This really ugly hack is used as the last resort. This allows us to
// adjust the application volume in Symbian. The CMMFDevSound object lies
// deep inside the QAudioOutput in Symbian implementation and it has the
// needed functions. So, we dig the required object accessing it directly
// from memory.
unsigned int *pointer_to_abstract_audio =
(unsigned int*)((unsigned char*)m_audioOutput + 8);
unsigned int *dev_sound_wrapper =
(unsigned int*)(*pointer_to_abstract_audio) + 13;
unsigned int *temp = ((unsigned int*)(*dev_sound_wrapper) + 6);
CMMFDevSound *devSound = (CMMFDevSound*)(*temp);
devSound->SetVolume(devSound->MaxVolume() * 6 / 10);
#endif
}
void PlaybackHandler::PlayFile(QString &filename)
{
// TODO: different thread for module handling?
// destroy old (if any)
delete m_pFileBuffer;
delete m_pModPlayer;
delete m_pFile;
// keep for debugging etc.
//m_currentFilename = filename.right(filename.size() - filename.lastIndexOf('/'));
m_currentFilename = filename;
// open file and use memory-mapping
// (leave buffering to OS)
//
m_pFile = new QFile(filename);
qint64 nSize = m_pFile->size();
uchar *pView = m_pFile->map(0, nSize);
CFileType type(pView, nSize);
if (type.m_enFileCategory == HEADERCAT_ARCHIVE)
{
// need to know which file in archive to decompress for playback..
//m_pArchiveHandler->openArchive(filename);
//m_pArchiveHandler->openArchive(m_pFile);
}
else if (type.m_enFileCategory == HEADERCAT_PACKER)
{
// single-file compression
// -> just decrunch to buffer
//m_pArchiveHandler->openArchive(filename);
//m_pArchiveHandler->openArchive(pView, nSize);
//m_pFileBuffer = m_pArchiveHandler->decrunchToBuffer(pView, nSize);
}
else
{
// module file without compression, just use as-is.
//
// use buffer as interface to accessing memory-mapped file:
// OS will generate pagefaults as needed
//
m_pFileBuffer = new CReadBuffer(pView, nSize);
}
// format-specific handling,
// fileformat, playback-to-buffer etc.
m_pModPlayer = GetPlayer(m_pFileBuffer);
if (m_pModPlayer == nullptr)
{
emit error("Failed to create player");
return;
}
if (m_pModPlayer->ParseFileInfo() == false)
{
emit error("File could not be handled");
return;
}
// get decoding context:
// player should keep position/status information,
// we want it to control position (if possible..)
//
// TODO: determine how we are able to output
// (e.g. 256 tracker channels -> 2 channels in stereo,
// 8/16-bit width?)
// and check that device supports what is possible..
//
m_pCtx = m_pModPlayer->PrepareDecoder();
// TODO: get info on what is suitable format for playing..
// (what is supported by player/format/module..)
//QAudioFormat format = pModPlayer->GetOutputFormat();
// placeholder.. set output format
// these will need changing later:
// due to module-format support
// and device-support we may need something or other..
QAudioFormat format;
format.setByteOrder(QAudioFormat::LittleEndian);
format.setCodec("audio/pcm");
format.setSampleRate(m_pCtx->sampleRate());
format.setChannels(m_pCtx->channelCount());
format.setSampleSize(m_pCtx->sampleSize());
format.setSampleType(QAudioFormat::SignedInt);
QAudioDeviceInfo info(QAudioDeviceInfo::defaultOutputDevice());
if (info.isNull() == true)
{
emit error("Failed to get default audio output");
return;
}
if (info.isFormatSupported(format) == false)
{
emit error("Output format not supported");
return;
}
// expect 2-channels and 8-bit samples at 44.1kHz,
// get proper values later, expecting 1s buffer to be enough for now..
//
size_t nBuffer = (format.sampleRate() * format.channels() * (format.sampleSize()/8));
m_pDecodeBuffer->PrepareBuffer(nBuffer, false);
// get device for output
m_pAudioOut = new QAudioOutput(format, this);
connect(m_pAudioOut, SIGNAL(stateChanged(QAudio::State)), this, SLOT(onAudioState(QAudio::State)));
connect(m_pAudioOut, SIGNAL(notify()), this, SLOT(onPlayNotify()));
if (m_pAudioOut->bufferSize() < nBuffer)
{
m_pAudioOut->setBufferSize(nBuffer);
}
m_pAudioOut->setNotifyInterval(250); // 250ms
// push-mode (we decode to buffer and push to device),
// we might need different thread for no-gaps playback..
m_pDevOut = m_pAudioOut->start();
if (initialOutput() == false)
{
// failed, cleanup
stopPlay(); // status message
emit error("Failed on audiodevice write(): " + filename);
}
}
PullAudioOut::PullAudioOut(AudioSource *source, QObject *parent)
: QIODevice(parent),
m_source(source)
{
DEBUG_INFO(this);
QAudioFormat format;
format.setFrequency(AUDIO_FREQUENCY);
format.setChannels(AUDIO_CHANNELS);
format.setSampleSize(AUDIO_SAMPLE_BITS);
format.setCodec(GEDefaultAudioCodec);
switch (GEByteOrder) {
case BigEndian:
format.setByteOrder(QAudioFormat::BigEndian);
break;
case LittleEndian:
format.setByteOrder(QAudioFormat::LittleEndian);
break;
default:
DEBUG_INFO("INVALID BYTE ORDER");
}
switch (GESampleType) {
case Unknown:
format.setSampleType(QAudioFormat::Unknown);
break;
case SignedInt:
format.setSampleType(QAudioFormat::SignedInt);
break;
case UnSignedInt:
format.setSampleType(QAudioFormat::UnSignedInt);
break;
case Float:
format.setSampleType(QAudioFormat::Float);
break;
default:
DEBUG_INFO("INVALID SAMPLE TYPE");
}
QAudioDeviceInfo info(QAudioDeviceInfo::defaultOutputDevice());
if (!info.isFormatSupported(format))
format = info.nearestFormat(format);
m_sendBufferSize = 4096;
m_audioOutput = new QAudioOutput(info, format);
#if defined(QTGAMEENABLER_USE_VOLUME_HACK) && defined(Q_OS_SYMBIAN)
DEBUG_INFO("WARNING: Using the volume hack!");
// This really ugly hack is used as the last resort. This allows us to
// adjust the application volume in Symbian. The CMMFDevSound object lies
// deep inside the QAudioOutput in Symbian implementation and it has the
// needed functions. So, we get the needed object accessing it directly
// from memory.
unsigned int *pointer_to_abstract_audio =
(unsigned int*)((unsigned char*)m_audioOutput + 8);
unsigned int *dev_sound_wrapper =
(unsigned int*)(*pointer_to_abstract_audio) + 13;
unsigned int *temp = ((unsigned int*)(*dev_sound_wrapper) + 6);
CMMFDevSound *devSound = (CMMFDevSound*)(*temp);
devSound->SetVolume(devSound->MaxVolume() * 6 / 10);
#endif
open(QIODevice::ReadOnly | QIODevice::Unbuffered);
connect(m_audioOutput, SIGNAL(stateChanged(QAudio::State)),
SLOT(audioStateChanged(QAudio::State)));
}
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> frequenciesList;
#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;
#endif
if (!m_generateTone)
frequenciesList += m_audioInputDevice.supportedFrequencies();
frequenciesList += m_audioOutputDevice.supportedFrequencies();
frequenciesList = frequenciesList.toSet().toList(); // remove duplicates
qSort(frequenciesList);
ENGINE_DEBUG << "Engine::initialize frequenciesList" << frequenciesList;
QList<int> channelsList;
channelsList += m_audioInputDevice.supportedChannels();
channelsList += m_audioOutputDevice.supportedChannels();
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 frequency, channels;
foreach (frequency, frequenciesList) {
if (foundSupportedFormat)
break;
format.setFrequency(frequency);
foreach (channels, channelsList) {
format.setChannels(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);
}