void SoundInput::start(qint32 device)
{
stop();
//---------------------------------------------------- Soundcard Setup
m_callbackData.kin=0; //Buffer pointer
m_callbackData.ncall=0; //Number of callbacks
m_callbackData.bzero=false; //Flag to request reset of kin
m_callbackData.monitoring=m_monitoring;
//### Temporary: hardwired device selection
QAudioDeviceInfo DeviceInfo;
QList<QAudioDeviceInfo> m_InDevices;
QAudioDeviceInfo m_InDeviceInfo;
m_InDevices = DeviceInfo.availableDevices(QAudio::AudioInput);
inputDevice = m_InDevices.at(0);
//###
// qDebug() << "B" << m_InDevices.length() << inputDevice.deviceName();
const char* pcmCodec = "audio/pcm";
QAudioFormat audioFormat = inputDevice.preferredFormat();
audioFormat.setChannelCount(1);
audioFormat.setCodec(pcmCodec);
audioFormat.setSampleRate(12000);
audioFormat.setSampleType(QAudioFormat::SignedInt);
audioFormat.setSampleSize(16);
// qDebug() << "C" << audioFormat << audioFormat.isValid();
if (!audioFormat.isValid()) {
emit error(tr("Requested audio format is not available."));
return;
}
audioInput = new QAudioInput(inputDevice, audioFormat);
// qDebug() << "D" << audioInput->error() << QAudio::NoError;
if (audioInput->error() != QAudio::NoError) {
emit error(reportAudioError(audioInput->error()));
return;
}
stream = audioInput->start();
// qDebug() << "E" << stream->errorString();
m_ntr0 = 99; // initial value higher than any expected
m_nBusy = 0;
m_intervalTimer.start(100);
m_ms0 = QDateTime::currentMSecsSinceEpoch();
m_nsps0 = 0;
}
AudioNotifier::AudioNotifier(QObject *parent)
{
QAudioDeviceInfo info = QAudioDeviceInfo::defaultOutputDevice();
// Set up the format, eg.
format = info.preferredFormat();
format.setCodec("audio/pcm");
#if QT_VERSION >= QT_VERSION_CHECK(5,0,0)
format.setChannelCount(2);
#else
format.setChannels(2);
#endif
format.setSampleRate(44100);
format.setSampleSize(16);
format.setByteOrder(QAudioFormat::LittleEndian);
format.setSampleType(QAudioFormat::SignedInt);
if (!info.isFormatSupported(format)) {
WARNING(tr("Audio format not supported by backend. Trying nearest format."));
format = info.nearestFormat(format);
}
audioOutput = new QAudioOutput(format, this);
connect(audioOutput, SIGNAL(stateChanged(QAudio::State)), this, SLOT(audioStateChanged(QAudio::State)));
if(audioOutput->error() != QAudio::NoError)
{
WARNING(tr("Error while creating audio output. Code: ") + QString::number(audioOutput->error()) + tr(" Device: ") + info.deviceName());
}
}
void MyEngine::recordVoice() {
qDebug() << "Called recordVoice" ;
QAudioDeviceInfo info = QAudioDeviceInfo::defaultInputDevice();
foreach (const QString &str, info.supportedCodecs ())
qDebug() << "Supported codecs: "<< str;
foreach (const QAudioDeviceInfo &audioDeviceInfo, QAudioDeviceInfo::availableDevices ( QAudio::AudioInput ))
qDebug() << "Devices: " << audioDeviceInfo.deviceName();
outputFile.setFileName("test.raw");
outputFile.open( QIODevice::WriteOnly | QIODevice::Truncate )?qDebug() << "file created":qDebug() << "file creation error";
//qDebug() << "Sample rate: " << format.sampleRate();
//QAudioDeviceInfo info = QAudioDeviceInfo::defaultInputDevice();
if (!info.isFormatSupported(format)) {
qWarning()<<"default format not supported try to use nearest";
format = info.nearestFormat(format);
}
audio = new QAudioInput(format, this);
connect(audio, SIGNAL(stateChanged(QAudio::State)),
this, SLOT(stateChanged(QAudio::State)));
QTimer::singleShot(2000, this, SLOT(stopRecording())); // Records audio for 2 sec
audio->start(&outputFile);
}
void MainWindow::on_pushButton_clicked()
{
QIODevice *QID;
//QID->open( QIODevice::WriteOnly);
QBuffer myQB;
//QID(myQB);
//cb(128000,64000);
//dFile.setFileName("../RecordTest.raw");
microphoneBuffer->open( QIODevice::ReadWrite);
QAudioFormat format;
// Set up the desired format, for example:
format.setSampleRate(16000);
format.setChannelCount(1);
format.setSampleSize(16);
format.setCodec("audio/pcm");
format.setByteOrder(QAudioFormat::LittleEndian);
format.setSampleType(QAudioFormat::UnSignedInt);
QAudioDeviceInfo info = QAudioDeviceInfo::defaultInputDevice();
if (!info.isFormatSupported(format))
{
qWarning() << "Default format not supported, trying to use the nearest.";
format = info.nearestFormat(format);
}
audio = new QAudioInput(format, this);
connect(audio, SIGNAL(stateChanged(QAudio::State)), this, SLOT(handleStateChanged(QAudio::State)));
//QTimer::singleShot(5000, this, SLOT(on_pushButton_2_clicked()));
isRecording = true;
audio->start(microphoneBuffer);
}
void QSpotifyAudioThreadWorker::startStreaming(int channels, int sampleRate)
{
qDebug() << "QSpotifyAudioThreadWorker::startStreaming";
if (!m_audioOutput) {
QAudioFormat af;
af.setChannelCount(channels);
af.setCodec("audio/pcm");
af.setSampleRate(sampleRate);
af.setSampleSize(16);
af.setSampleType(QAudioFormat::SignedInt);
QAudioDeviceInfo info(QAudioDeviceInfo::defaultOutputDevice());
if (!info.isFormatSupported(af)) {
QList<QAudioDeviceInfo> devices = QAudioDeviceInfo::availableDevices(QAudio::AudioOutput);
for (int i = 0; i < devices.size(); i++) {
QAudioDeviceInfo dev = devices[i];
qWarning() << dev.deviceName();
}
QCoreApplication::postEvent(QSpotifySession::instance(), new QEvent(QEvent::Type(StopEventType)));
return;
}
m_audioOutput = new QAudioOutput(af);
connect(m_audioOutput, SIGNAL(stateChanged(QAudio::State)), QSpotifySession::instance(), SLOT(audioStateChange(QAudio::State)));
m_audioOutput->setBufferSize(BUF_SIZE);
startAudioOutput();
}
}
FrequencyAnalyzer::FrequencyAnalyzer(QObject *parent) :
QObject(parent),
d_ptr(new FrequencyAnalyzerPrivate(this))
{
Q_D(FrequencyAnalyzer);
QAudioDeviceInfo info = QAudioDeviceInfo::defaultInputDevice();
qDebug() << "device name: " << info.deviceName() << "\n"
<< "supported frequency:" << info.supportedFrequencies() << "\n"
<< "supported codecs" << info.supportedCodecs() << "\n"
<< "supported sample sizes" << info.supportedSampleSizes() << "\n"
<< "supported sample types" << info.supportedSampleTypes() << "\n";
QAudioFormat format = info.preferredFormat();
format.setCodec("audio/pcm");
format.setByteOrder(QAudioFormat::LittleEndian);
format.setSampleType(QAudioFormat::SignedInt);
format.setSampleSize(32);
//format.setFrequency(d->sampling = 11025);
//format.setFrequency(d->sampling = 22050);
format.setFrequency(d->sampling = info.supportedFrequencies().last());
format.setChannelCount(1);
if (!info.isFormatSupported(format)) {
qWarning("Format is unsupported");
return;
}
d->input = new QAudioInput(info, format, this);
connect(d->input, SIGNAL(stateChanged(QAudio::State)), SLOT(_q_onStateChanged()));
}
QAudioFormat AudioReciever::GetStreamAudioFormat(void)
{
QAudioFormat format;
format.setSampleRate(44100);
//format.setChannels(1);
format.setSampleSize(24);
format.setCodec("audio/pcm");
format.setByteOrder(QAudioFormat::LittleEndian);
format.setSampleType(QAudioFormat::UnSignedInt);
QAudioDeviceInfo info = QAudioDeviceInfo::defaultInputDevice();
if (!info.isFormatSupported(format))
format = info.nearestFormat(format);
return format;
}
int main(int argc, char *argv[])
{
QApplication a(argc, argv);
const QAudioDeviceInfo inputDevice = QAudioDeviceInfo::defaultInputDevice();
if (inputDevice.isNull()) {
QMessageBox::warning(nullptr, "audio",
"There is no audio input device available.");
return -1;
}
Widget w(inputDevice);
w.show();
return a.exec();
}
void Engine::setAudioOutputDevice(const QAudioDeviceInfo &device)
{
if (device.deviceName() != m_audioOutputDevice.deviceName()) {
m_audioOutputDevice = device;
initialize();
}
}
int main(int argc, char *argv[])
{
QApplication a(argc, argv);
SaveSoundMainWindow w;
w.show();
RingIODevice *r = new RingIODevice(1000);
QByteArray c(1000, 0xff);
//r->writeAtPosition(QByteArray("!ello!"), 0);
//r->writeAtPosition(" world!h", 6);
//qDebug() << r->read(30);
r->writeAtPosition(c, 0);
r->addOrRemoveBytesFromCurrentPosition(100);
QAudioDeviceInfo info = QAudioDeviceInfo::defaultOutputDevice();
qDebug() << info.supportedSampleRates();
return a.exec();
}
AudioNotifier::AudioNotifier(QObject *parent)
{
QAudioDeviceInfo info = QAudioDeviceInfo::defaultOutputDevice();
// Set up the format, eg.
format = info.preferredFormat();
if (!info.isFormatSupported(format)) {
WARNING("Audio format not supported by backend. Trying nearest format.");
format = info.nearestFormat(format);
}
audioOutput = new QAudioOutput(format, this);
if(audioOutput->error() != QAudio::NoError)
{
WARNING("Error while creating audio output. Code: " + QString::number(audioOutput->error()) + " Device: " + info.deviceName());
}
}
void SoundEngine::setAudioInputDevice(const QAudioDeviceInfo &device)
{
if (device.deviceName() != m_audioInputDeviceInfo.deviceName())
{
m_audioInputDeviceInfo = device;
initializeAudio();
}
}
/*! Set a new audio device */
void Engine::SetAudioDevice( const QAudioDeviceInfo& deviceInfo ) {
m_pAudioOutput->stop();
m_pAudioOutput->disconnect(this);
m_pDevice = deviceInfo;
m_format= deviceInfo.preferredFormat();
// Set the use of float data
m_format.setSampleType( QAudioFormat::Float );
m_format.setSampleSize( SAMPLE_SIZE );
// Setup our audio device information
while ( !m_pDevice.isFormatSupported( m_format ) ) {
m_format = m_pDevice.nearestFormat( deviceInfo.preferredFormat() );
}
createAudioOutput();
} // end Engine::setAudioDevice()
bool CSoundCommonQT::isSampleRateSupported(const QAudioDeviceInfo &di, int samplerate) const
{
samplerate = abs(samplerate);
#ifdef QTAUDIO_SAMPLERATE_HACK
(void)di;
return samplerate >= 1 && samplerate <= 192000;
#else
return di.supportedSampleRates().contains(samplerate);
#endif
}
/*!
Returns true if this QAudioDeviceInfo class represents the
same audio device as \a other.
*/
bool QAudioDeviceInfo::operator ==(const QAudioDeviceInfo &other) const
{
if (d == other.d)
return true;
if (d->realm == other.d->realm
&& d->mode == other.d->mode
&& d->handle == other.d->handle
&& deviceName() == other.deviceName())
return true;
return false;
}
bool CSoundCommonQT::isDeviceGood(const QAudioDeviceInfo &di, const int *desiredsamplerates) const
{
bool bSampleRateOk = false;
for (const int* dsr=desiredsamplerates; *dsr; dsr++)
{
int samplerate = abs(*dsr);
if (isSampleRateSupported(di, samplerate))
{
bSampleRateOk = true;
break;
}
}
return
bSampleRateOk &&
di.supportedChannelCounts().contains(2) && // TODO
di.supportedSampleSizes().contains(16) &&
di.supportedSampleTypes().contains(QAudioFormat::SignedInt) &&
di.supportedByteOrders().contains(QAudioFormat::LittleEndian) &&
di.supportedCodecs().contains("audio/pcm");
}
SWipe::SWipe(QWidget *parent) : QMainWindow(parent) {
captureAudio = false;
audioFormat.setFrequency( 48000 );
audioFormat.setChannels( 1 );
audioFormat.setSampleSize( 16 );
audioFormat.setCodec( "audio/pcm" );
audioFormat.setByteOrder( QAudioFormat::LittleEndian );
audioFormat.setSampleType( QAudioFormat::SignedInt );
QAudioDeviceInfo info = QAudioDeviceInfo::defaultInputDevice();
if( !info.isFormatSupported( audioFormat ) ) {
qWarning() << "default format not supported try to use nearest";
audioFormat = info.nearestFormat( audioFormat );
}
magDec = NULL;
mkWindow();
}
QAudioFormat AudioTransmitter::GetStreamAudioFormat(void)
{
QAudioFormat format;
QAudioDeviceInfo info1 = QAudioDeviceInfo::defaultInputDevice();
format.setSampleRate(44100);
//format.setChannels(1);
format.setSampleSize(24);
format.setCodec("audio/pcm");
format.setByteOrder(QAudioFormat::LittleEndian);
format.setSampleType(QAudioFormat::UnSignedInt);
QAudioDeviceInfo info = QAudioDeviceInfo::defaultInputDevice();
if (!info.isFormatSupported(format))
format = info.nearestFormat(format);
QStringList list=info1.supportedCodecs();
foreach (const QString &str, list) {
qDebug()<<"codec: "<<str;
}
return format;
}
void PCMPlayer::handleThreadOnStarted()
{
PCMPlayerDebug("current thread:%x",QThread::currentThreadId());
thread->setObjectName(QString("PCMPlayerThread-")+ QString::number((int)QThread::currentThreadId()));
PCMPlayerDebug("prepare pcmPlayer!");
pcmFormat = new QAudioFormat();
pcmFormat->setSampleRate(samplesPerSec);
pcmFormat->setChannels(channels);
pcmFormat->setSampleSize(bitNumPerSample);
if (bitNumPerSample == 8)
{
pcmFormat->setSampleType(QAudioFormat::SignedInt);
}
else if (bitNumPerSample == 16)
{
pcmFormat->setSampleType(QAudioFormat::UnSignedInt);
}
pcmFormat->setCodec("audio/pcm");
QAudioDeviceInfo devInfo = QAudioDeviceInfo::defaultOutputDevice();
if (!devInfo.isFormatSupported(*pcmFormat))
{
*pcmFormat = devInfo.nearestFormat(*pcmFormat);
PCMPlayerDebug("pcmPlayer prepare failed!");
return;
}
audioOutput = new QAudioOutput(*pcmFormat);
audioOutput->reset();
audioOutput->setBufferSize(dataQueue->getBufferSize() * 2);
PCMPlayerDebug("AudioOutput BufferSize = %d", audioOutput->bufferSize());
QObject::connect(QThread::currentThread(), SIGNAL(finished()),
audioOutput, SLOT(deleteLater()));
connect(QThread::currentThread() , SIGNAL(finished()) , this , SLOT(handleThreadOnFinished()));
audioOutputIODevice = audioOutput->start();
timerID = startTimer(20);
PCMPlayerDebug("pcmPlayer prepare successed!");
}
TaudioIN::TaudioIN(QObject *parent) :
QObject(parent),
m_inDevice(0),
m_buffer(0),
m_pitchFinder(0)
{
QList<QAudioDeviceInfo> devList = QAudioDeviceInfo::availableDevices(QAudio::AudioInput);
for (int i = 0; i < devList.count(); ++i)
qDebug() << i << devList[i].deviceName();
QAudioDeviceInfo defaultIn = QAudioDeviceInfo::defaultInputDevice();
QAudioFormat format;
format.setChannelCount(1);
format.setSampleRate(48000);
format.setSampleType(QAudioFormat::SignedInt);
format.setSampleSize(16);
format.setCodec("audio/pcm");
format.setByteOrder(QAudioFormat::LittleEndian);
if (!defaultIn.isFormatSupported(format)) {
qDebug() << "Format 48000/16 mono is not suported";
format = defaultIn.nearestFormat(format);
qDebug() << "Format is" << format.sampleRate() << format.channelCount() << format.sampleSize();
}
m_lastNote = new Tnote();
m_audioIN = new QAudioInput(defaultIn, format, this);
m_audioIN->setBufferSize(2048);
m_pitchFinder = new TpitchFinder();
m_pitchFinder->setMinimalDuration(0.1f);
m_pitchFinder->setSplitByVolChange(false);
m_pitchFinder->setSplitVolume(0.0);
m_pitchFinder->setSkipStillerVal(0.0);
m_pitchFinder->aGl()->equalLoudness = true;
m_pitchFinder->setSampleRate(m_audioIN->format().sampleRate()); // framesPerChunk is determined here
connect(m_pitchFinder, &TpitchFinder::pitchInChunk, this, &TaudioIN::pitchDetected);
connect(m_pitchFinder, &TpitchFinder::noteStarted, this, &TaudioIN::noteStartedSlot);
connect(m_pitchFinder, &TpitchFinder::noteFinished, this, &TaudioIN::noteFinishedSlot);
}
void Engine::startListening()
{
QAudioFormat format;
// Set up the desired format, for example:
format.setSampleRate(8000);
format.setChannelCount(1);
format.setSampleSize(8);
format.setCodec("audio/pcm");
format.setByteOrder(QAudioFormat::LittleEndian);
format.setSampleType(QAudioFormat::UnSignedInt);
QAudioDeviceInfo info = QAudioDeviceInfo::defaultInputDevice();
if (!info.isFormatSupported(format)) {
qWarning() << "Default format not supported, trying to use the nearest.";
format = info.nearestFormat(format);
}
QAudioInput *audio = new QAudioInput(format, this);
QBuffer buffer;
audio->start(&buffer);
}
/**
* ATTENTION: The default devices give a null-device at second call
*/
QAudioDeviceInfo Client::audioDeviceByName( QString name, QAudio::Mode mode )
{
QList<QAudioDeviceInfo> devices = QAudioDeviceInfo::availableDevices( mode );
while(!devices.isEmpty())
{
QAudioDeviceInfo temp = devices.takeFirst();
if(temp.deviceName() == name)
{
return temp;
}
}
if( mode == QAudio::AudioInput)
{
return QAudioDeviceInfo::defaultInputDevice();
}
else if( mode == QAudio::AudioOutput )
{
return QAudioDeviceInfo::defaultOutputDevice();
}
return QAudioDeviceInfo();
}
bool Lockin2::start(const QAudioDeviceInfo &audioDevice, const QAudioFormat &format)
{
if (_audioInput != 0) {
qDebug() << __FUNCTION__ << ": lockin is already running, please stop is before start";
return false;
}
if (!format.isValid()) {
qDebug() << __FUNCTION__ << ": format not valid";
return false;
}
if (!isFormatSupported(format)) {
qDebug() << __FUNCTION__ << ": format not supported for lockin2";
return false;
}
if (audioDevice.isFormatSupported(format)) {
_audioInput = new QAudioInput(audioDevice, format, this);
_audioInput->setNotifyInterval(_outputPeriod * 1000.0);
connect(_audioInput, SIGNAL(notify()), this, SLOT(interpretInput()));
connect(_audioInput, SIGNAL(stateChanged(QAudio::State)), this, SLOT(audioStateChanged(QAudio::State)));
// pour être au millieu avec le temps
_timeValue = -(_integrationTime / 2.0);
// nombre d'échantillons pour le temps d'integration
_sampleIntegration = format.sampleRate() * _integrationTime;
// nombre d'échantillons pour un affichage de vumeter
_sampleVumeter = _vumeterTime * format.sampleRate();
// nettoyage des variables
_fifo->readAll(); // vide le fifo
_dataXY.clear(); // vide <x,y>
_format = format;
_audioInput->start(_fifo);
} else {
qDebug() << __FUNCTION__ << ": format not supported, can't start";
return false;
}
return true;
}
void SoundInput::start(QAudioDeviceInfo const& device, int framesPerBuffer, AudioDevice * sink, unsigned downSampleFactor, AudioDevice::Channel channel)
{
Q_ASSERT (sink);
stop ();
m_sink = sink;
QAudioFormat format (device.preferredFormat());
format.setChannelCount (AudioDevice::Mono == channel ? 1 : 2);
format.setCodec ("audio/pcm");
format.setSampleRate (12000 * downSampleFactor);
format.setSampleType (QAudioFormat::SignedInt);
format.setSampleSize (16);
if (!format.isValid ())
{
Q_EMIT error (tr ("Requested input audio format is not valid."));
return;
}
// this function lies!
// if (!device.isFormatSupported (format))
// {
// Q_EMIT error (tr ("Requested input audio format is not supported on device."));
// return;
// }
m_stream.reset (new QAudioInput {device, format});
if (audioError ())
{
return;
}
connect (m_stream.data(), &QAudioInput::stateChanged, this, &SoundInput::handleStateChanged);
m_stream->setBufferSize (m_stream->format ().bytesForFrames (framesPerBuffer));
if (sink->initialize (QIODevice::WriteOnly, channel))
{
m_stream->start (sink);
audioError ();
}
else
{
Q_EMIT error (tr ("Failed to initialize audio sink device"));
}
}
foreach (QAudioDeviceInfo info, infos) {
ui->cbAudioOutput->addItem(info.deviceName());
}
void MainWindow::start()
{
if (m_audio_lib)
{
stopRecord();
buttonrecord->setEnabled(false);
m_audio_lib->stop();
#ifdef Q_OS_WIN
if (m_loopback)
m_loopback->deleteLater();
#endif
return;
}
QByteArray password = linepassword->text().toLatin1();
if (comboboxaudioinput->count() == 0)
{
msgBoxCritical("Error", "No input device found", this);
return;
}
bool ok = false;
int port = lineport->text().toInt(&ok);
if (!ok || port < 1 || port > 65535)
{
msgBoxCritical("Error", "Port must have a value between 1 and 65535,\n"
"including these values", this);
return;
}
int max_connections = linemaxconnections->text().toInt(&ok);
if (!ok || max_connections < 1)
{
msgBoxCritical("Error", "Enter a value equal or higher to 1 on maximum connections", this);
return;
}
m_audio_lib = new AudioStreamingLibCore(this);
StreamingInfo info;
info.setWorkMode(StreamingInfo::StreamingWorkMode::BroadcastServer);
info.setEncryptionEnabled(!password.isEmpty());
info.setGetAudioEnabled(true);
info.setListenAudioInputEnabled(boxlisteninput->isChecked());
info.setNegotiationString(QByteArray("BroadcastTCPDemo"));
info.setID(lineid->text().trimmed());
QAudioDeviceInfo inputdevinfo = comboboxaudioinput->currentData().value<QAudioDeviceInfo>();
if (inputdevinfo.isNull())
{
#ifdef Q_OS_WIN
if (comboboxaudioinput->currentData(Qt::UserRole + 1).value<int>() == AudioInputInfo::Loopback)
{
m_loopback = new QWinLoopback(this);
connect(m_loopback, &QObject::destroyed, this, [=]
{
if (isVisible())
m_buffer.clear();
});
bool started = m_loopback->start();
if (!started)
return;
info.setInputDeviceType(StreamingInfo::AudioDeviceType::CustomAudioDevice);
info.setCallBackEnabled(true);
QAudioFormat format = m_loopback->format();
connect(m_loopback, &QWinLoopback::readyRead, this, &MainWindow::loopbackdata);
connect(m_audio_lib, &AudioStreamingLibCore::inputData, this, &MainWindow::process);
info.setInputAudioFormat(format);
}
else //FFMPEG
#endif
{
QAudioFormat format;
format.setSampleSize(32);
format.setSampleRate(48000);
format.setChannelCount(2);
format.setSampleType(QAudioFormat::Float);
format.setByteOrder(QAudioFormat::LittleEndian);
info.setInputDeviceType(StreamingInfo::AudioDeviceType::CustomAudioDevice);
info.setCallBackEnabled(true);
connect(m_audio_lib, &AudioStreamingLibCore::inputData, this, &MainWindow::process);
info.setInputAudioFormat(format);
}
}
else
{
info.setInputDeviceInfo(inputdevinfo);
QAudioFormat format;
format.setSampleSize(32);
format.setSampleRate(linesamplerate->text().toInt());
format.setChannelCount(linechannels->text().toInt());
format.setSampleType(QAudioFormat::Float);
format.setByteOrder(QAudioFormat::LittleEndian);
info.setInputAudioFormat(format);
}
lineport->setEnabled(false);
linemaxconnections->setEnabled(false);
lineid->setEnabled(false);
linepassword->setEnabled(false);
linesamplerate->setEnabled(false);
linechannels->setEnabled(false);
comboboxaudioinput->setEnabled(false);
boxlisteninput->setEnabled(false);
buttonstart->setText("Stop Server");
buttonrecord->setEnabled(true);
connect(m_audio_lib, &AudioStreamingLibCore::adjustSettings, this, &MainWindow::adjustSettings);
connect(m_audio_lib, &AudioStreamingLibCore::inputLevel, level, &LevelWidget::setlevel);
connect(m_audio_lib, &AudioStreamingLibCore::error, this, &MainWindow::error);
connect(m_audio_lib, &AudioStreamingLibCore::finished, this, &MainWindow::finished);
connect(m_audio_lib, &AudioStreamingLibCore::connected, this, &MainWindow::updateConnections);
connect(m_audio_lib, &AudioStreamingLibCore::disconnected, this, &MainWindow::updateConnections);
m_audio_lib->start(info);
if (info.isListenAudioInputEnabled())
m_audio_lib->setVolume(slidervolume->value());
m_audio_lib->listen(quint16(port), true, password, max_connections);
boxautostart->setEnabled(false);
if (boxautostart->isChecked())
startPauseRecord(); //Auto start recording when server starts
#ifndef Q_OS_ANDROID
m_ffmpeg->setReadingEnabled(true);
#endif
QString title = QString("%0 connection(s) - %1").arg(0).arg(TITLE);
setWindowTitle(title);
}
Logger::Logger(QObject *parent) :
QObject(parent)
{
mPort = new SerialPort(this);
mPacketInterface = new PacketInterface(this);
mValueFile = new QFile("Data/BLDC_Values");
mPrintFile = new QFile("Data/BLDC_Print");
mValueFile->open(QIODevice::WriteOnly | QIODevice::Text);
mPrintFile->open(QIODevice::WriteOnly | QIODevice::Text);
mValueStream = new QTextStream(mValueFile);
mPrintStream = new QTextStream(mPrintFile);
mPort->openPort("/dev/ttyACM0");
// Video
mVidW = 1280;
mVidH = 720;
mVidFps = 25.0;
mFAudioSamp = 44100;
mFrameGrabber = new FrameGrabber(mVidW, mVidH, mVidFps, 0, this);
mFrameGrabber->start(QThread::InheritPriority);
mPlotter = new FramePlotter(this);
mPlotter->start(QThread::InheritPriority);
mCoder = new VideoCoder(mVidW, mVidH, mVidFps, "Data/v_video.avi", this);
mCoder->start(QThread::InheritPriority);
// Audio recording
mTimer = 0;
mAudio = 0;
if (QAudioDeviceInfo::availableDevices(QAudio::AudioInput).size() > 0) {
mAudioFile.setFileName("Data/v_audio.raw");
mAudioFile.open(QIODevice::WriteOnly | QIODevice::Truncate);
QAudioFormat format;
// Set up the desired format, for example:
format.setSampleRate(mFAudioSamp);
format.setChannelCount(1);
format.setSampleSize(8);
format.setCodec("audio/pcm");
format.setByteOrder(QAudioFormat::LittleEndian);
format.setSampleType(QAudioFormat::UnSignedInt);
QAudioDeviceInfo info = QAudioDeviceInfo::defaultInputDevice();
if (!info.isFormatSupported(format)) {
qWarning() << "Default format not supported, trying to use the nearest.";
format = info.nearestFormat(format);
}
mAudio = new QAudioInput(format, this);
mAudio->setNotifyInterval(1000 / mVidFps);
mAudio->start(&mAudioFile);
} else {
mTimer = new QTimer(this);
mTimer->setInterval(1000 / mVidFps);
mTimer->start();
}
mConsoleReader = new ConsoleReader(this);
connect(mConsoleReader, SIGNAL(textReceived(QString)),
this, SLOT(consoleLineReceived(QString)));
connect(mPort, SIGNAL(serial_data_available()),
this, SLOT(serialDataAvailable()));
if (mTimer != 0) {
connect(mTimer, SIGNAL(timeout()), this, SLOT(timerSlot()));
}
if (mAudio != 0) {
connect(mAudio, SIGNAL(notify()),
this, SLOT(audioNotify()));
// Lower the volume to avoid clipping. This seems to be passed to
// pulseaudio.
mAudio->setVolume(0.1);
}
connect(mPacketInterface, SIGNAL(dataToSend(QByteArray&)),
this, SLOT(packetDataToSend(QByteArray&)));
connect(mPacketInterface, SIGNAL(valuesReceived(PacketInterface::MC_VALUES)),
this, SLOT(mcValuesReceived(PacketInterface::MC_VALUES)));
connect(mPacketInterface, SIGNAL(printReceived(QString)),
this, SLOT(printReceived(QString)));
connect(mPacketInterface, SIGNAL(samplesReceived(QByteArray)),
this, SLOT(samplesReceived(QByteArray)));
connect(mPacketInterface, SIGNAL(rotorPosReceived(double)),
this, SLOT(rotorPosReceived(double)));
connect(mPacketInterface, SIGNAL(experimentSamplesReceived(QVector<double>)),
this, SLOT(experimentSamplesReceived(QVector<double>)));
connect(mPlotter, SIGNAL(frameReady(QImage)),
mCoder, SLOT(setNextFrame(QImage)));
}
SettingsDialog::SettingsDialog(
const QList<QAudioDeviceInfo> &availableInputDevices,
const QList<QAudioDeviceInfo> &availableOutputDevices,
QWidget *parent)
: QDialog(parent)
, m_windowFunction(DefaultWindowFunction)
, m_inputDeviceComboBox(new QComboBox(this))
, m_outputDeviceComboBox(new QComboBox(this))
, m_windowFunctionComboBox(new QComboBox(this))
{
QVBoxLayout *dialogLayout = new QVBoxLayout(this);
// Populate combo boxes
QAudioDeviceInfo device;
foreach (device, availableInputDevices)
m_inputDeviceComboBox->addItem(device.deviceName(),
qVariantFromValue(device));
foreach (device, availableOutputDevices)
m_outputDeviceComboBox->addItem(device.deviceName(),
qVariantFromValue(device));
m_windowFunctionComboBox->addItem(tr("None"), qVariantFromValue(int(NoWindow)));
m_windowFunctionComboBox->addItem("Hann", qVariantFromValue(int(HannWindow)));
m_windowFunctionComboBox->setCurrentIndex(m_windowFunction);
// Initialize default devices
if (!availableInputDevices.empty())
m_inputDevice = availableInputDevices.front();
if (!availableOutputDevices.empty())
m_outputDevice = availableOutputDevices.front();
// Add widgets to layout
QScopedPointer<QHBoxLayout> inputDeviceLayout(new QHBoxLayout);
QLabel *inputDeviceLabel = new QLabel(tr("Input device"), this);
inputDeviceLayout->addWidget(inputDeviceLabel);
inputDeviceLayout->addWidget(m_inputDeviceComboBox);
dialogLayout->addLayout(inputDeviceLayout.data());
inputDeviceLayout.take(); // ownership transferred to dialogLayout
QScopedPointer<QHBoxLayout> outputDeviceLayout(new QHBoxLayout);
QLabel *outputDeviceLabel = new QLabel(tr("Output device"), this);
outputDeviceLayout->addWidget(outputDeviceLabel);
outputDeviceLayout->addWidget(m_outputDeviceComboBox);
dialogLayout->addLayout(outputDeviceLayout.data());
outputDeviceLayout.take(); // ownership transferred to dialogLayout
QScopedPointer<QHBoxLayout> windowFunctionLayout(new QHBoxLayout);
QLabel *windowFunctionLabel = new QLabel(tr("Window function"), this);
windowFunctionLayout->addWidget(windowFunctionLabel);
windowFunctionLayout->addWidget(m_windowFunctionComboBox);
dialogLayout->addLayout(windowFunctionLayout.data());
windowFunctionLayout.take(); // ownership transferred to dialogLayout
// Connect
CHECKED_CONNECT(m_inputDeviceComboBox, SIGNAL(activated(int)),
this, SLOT(inputDeviceChanged(int)));
CHECKED_CONNECT(m_outputDeviceComboBox, SIGNAL(activated(int)),
this, SLOT(outputDeviceChanged(int)));
CHECKED_CONNECT(m_windowFunctionComboBox, SIGNAL(activated(int)),
this, SLOT(windowFunctionChanged(int)));
// Add standard buttons to layout
QDialogButtonBox *buttonBox = new QDialogButtonBox(this);
buttonBox->setStandardButtons(QDialogButtonBox::Ok | QDialogButtonBox::Cancel);
dialogLayout->addWidget(buttonBox);
// Connect standard buttons
CHECKED_CONNECT(buttonBox->button(QDialogButtonBox::Ok), SIGNAL(clicked()),
this, SLOT(accept()));
CHECKED_CONNECT(buttonBox->button(QDialogButtonBox::Cancel), SIGNAL(clicked()),
this, SLOT(reject()));
setLayout(dialogLayout);
}
/////////////////////////////////////////////////////////////////////
// Starts up soundcard output thread using soundcard at list OutDevIndx
/////////////////////////////////////////////////////////////////////
bool CSoundOut::Start(int OutDevIndx, bool StereoOut, double UsrDataRate, bool BlockingMode)
{
QAudioDeviceInfo DeviceInfo;
long mvolume;
m_StereoOut = StereoOut;
m_BlockingMode = BlockingMode;
//Get required soundcard from list
m_OutDevices = DeviceInfo.availableDevices(QAudio::AudioOutput);
if (-1 == OutDevIndx) GetAlsaMasterVolume(&mvolume);
qDebug()<<"Soundcard volume" << mvolume;
if (-1 == OutDevIndx) m_OutDeviceInfo = QAudioDeviceInfo::defaultOutputDevice();
else m_OutDeviceInfo = m_OutDevices.at(OutDevIndx);
#if 1 //RRK get a list of audio devices and the default
foreach (const QAudioDeviceInfo &deviceInfo, QAudioDeviceInfo::availableDevices(QAudio::AudioOutput)) {
qDebug() << "l:" << deviceInfo.deviceName();
}
QAudioDeviceInfo info = QAudioDeviceInfo::defaultOutputDevice();
qDebug() << "res:" << info.deviceName();
#endif
//Setup fixed format for sound ouput
m_OutAudioFormat.setCodec("audio/pcm");
//m_OutAudioFormat.setFrequency(SOUNDCARD_RATE);
m_OutAudioFormat.setSampleRate(SOUNDCARD_RATE);
m_OutAudioFormat.setSampleSize(16);
m_OutAudioFormat.setSampleType(QAudioFormat::SignedInt);
m_OutAudioFormat.setByteOrder(QAudioFormat::LittleEndian);
if(m_StereoOut)
//RRK m_OutAudioFormat.setChannels(2);
m_OutAudioFormat.setChannelCount(2);
else
m_OutAudioFormat.setChannelCount(1);
m_pAudioOutput = new QAudioOutput(m_OutDeviceInfo, m_OutAudioFormat, this);
if(!m_pAudioOutput)
{
qDebug()<<"Soundcard output error";
return false;
}
if(QAudio::NoError == m_pAudioOutput->error() )
{
//initialize the data queue variables
m_UserDataRate = 1; //force user data rate to be changed
ChangeUserDataRate(UsrDataRate);
m_pOutput = m_pAudioOutput->start(); //start QT AudioOutput
//RRK workaround for default, for some reason choosing default
//sets the master volume to max!
if (-1 == OutDevIndx) SetAlsaMasterVolume(50);
//determine how long to sleep between low level reads based on samplerate and period size
m_BlockTime = ( 250*m_pAudioOutput->periodSize() )/
( SOUNDCARD_RATE*m_OutAudioFormat.channelCount() );
//RRK ( SOUNDCARD_RATE*m_OutAudioFormat.channels() );
//qDebug()<<"periodSize "<<m_pAudioOutput->periodSize();
//qDebug()<<"BlockTime "<<m_BlockTime;
m_ThreadQuit = FALSE;
start(QThread::HighestPriority); //start worker thread and set its priority
// start(QThread::TimeCriticalPriority); //start worker thread and set its priority
return true;
}
else
{
qDebug()<<"Soundcard output error";
return false;
}
}
