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 Airplay :: start()
{
// read the airplay pipe
file.setFileName("/tmp/shairport-sync-pipe");
file.open(QIODevice::ReadOnly);
// set the audio format
// https://github.com/mikebrady/shairport-sync/issues/126
// Playing raw data 'stdin' : Signed 16 bit Little Endian, Rate 44100 Hz, Stereo
QAudioFormat format;
format.setSampleRate(44100); // rate
format.setChannelCount(2); // stereo
format.setCodec("audio/pcm"); // raw
format.setSampleSize(16); // 16 bit
format.setByteOrder(QAudioFormat::LittleEndian);
format.setSampleType(QAudioFormat::SignedInt);
// check format is supported
if (!deviceInfo.isFormatSupported(format))
qWarning() << "Output format not supported";
// connect signals
audio = new QAudioOutput(deviceInfo, format, this);
connect(audio, SIGNAL(stateChanged(QAudio::State)), this, SLOT(handleStateChange(QAudio::State)));
// start playing
audio->start(&file);
}
BeatController::BeatController(QAudioDeviceInfo inputDevice, uint16_t recordSize, uint32_t sampleRate, uint16_t m_bandCount, QObject *parent) : QObject(parent)
{
m_RecordSize = recordSize;
m_Buffer = new SoundBuffer(recordSize);
m_Analyser = new BeatAnalyser(m_bandCount,sampleRate,recordSize);
m_inputDevice = QAudioDeviceInfo(inputDevice);
m_FFT = new FFT(recordSize);
m_FFT->setSoundBuffer(m_Buffer);
m_Analyser->setFFT(m_FFT);
QAudioFormat audioFormat;
audioFormat.setSampleRate(sampleRate);
audioFormat.setChannelCount(1);
audioFormat.setSampleSize(16);
audioFormat.setSampleType(QAudioFormat::SignedInt);
audioFormat.setByteOrder(QAudioFormat::LittleEndian);
audioFormat.setCodec("audio/pcm");
//QAudioDeviceInfo info(QAudioDeviceInfo::defaultInputDevice());
if (!m_inputDevice.isFormatSupported(audioFormat)) {
qWarning() << "Default format not supported - trying to use nearest";
audioFormat = m_inputDevice.nearestFormat(audioFormat);
}
m_audioInput = new QAudioInput(m_inputDevice, audioFormat, this);
m_ioDevice = m_audioInput->start();
connect(m_ioDevice, SIGNAL(readyRead()), this, SLOT(readAudio()));
}
void RtpAudioStream::startPlaying()
{
if (audio_output_) return;
QAudioFormat format;
format.setSampleRate(audio_out_rate_);
format.setSampleSize(sample_bytes_ * 8); // bits
format.setSampleType(QAudioFormat::SignedInt);
format.setChannelCount(1);
format.setCodec("audio/pcm");
// RTP_STREAM_DEBUG("playing %s %d samples @ %u Hz",
// tempfile_->fileName().toUtf8().constData(),
// (int) tempfile_->size(), audio_out_rate_);
audio_output_ = new QAudioOutput(format, this);
audio_output_->setNotifyInterval(65); // ~15 fps
connect(audio_output_, SIGNAL(stateChanged(QAudio::State)), this, SLOT(outputStateChanged()));
connect(audio_output_, SIGNAL(notify()), this, SLOT(outputNotify()));
tempfile_->seek(0);
audio_output_->start(tempfile_);
emit startedPlaying();
// QTBUG-6548 StoppedState is not always emitted on error, force a cleanup
// in case playback fails immediately.
if (audio_output_ && audio_output_->state() == QAudio::StoppedState) {
outputStateChanged();
}
}
int test_2()
{
qyvlik::FFmpegStream* ffmpegStream = new qyvlik::FFmpegStream();
QAudioFormat format;
// Set up the format, eg.
format.setSampleRate(44100);
format.setChannelCount(2);
format.setCodec("audio/pcm");
format.setSampleType(QAudioFormat::SignedInt);
format.setSampleSize(16);
format.setByteOrder(QAudioFormat::LittleEndian);
QAudioDeviceInfo info(QAudioDeviceInfo::defaultOutputDevice());
if (!info.isFormatSupported(format)) {
qDebug() << "Raw audio format not supported by backend, cannot play audio.";
return -1;
}
ffmpegStream->setFileName("E:/Test/1.mp3");
QAudioOutput *audio;
audio = new QAudioOutput(format);
audio->start(ffmpegStream);
qDebug() << "Play Finished~";
}
void AudioProcessorQt::start() {
if (!input()) {
return;
}
if (!m_device) {
m_device = new AudioDevice(this);
}
if (!m_audioOutput) {
QAudioFormat format;
format.setSampleRate(44100);
format.setChannelCount(2);
format.setSampleSize(16);
format.setCodec("audio/pcm");
format.setByteOrder(QAudioFormat::LittleEndian);
format.setSampleType(QAudioFormat::SignedInt);
m_audioOutput = new QAudioOutput(format, this);
m_audioOutput->setCategory("game");
}
m_device->setInput(input());
m_device->setFormat(m_audioOutput->format());
m_audioOutput->setBufferSize(input()->audioBuffers * 4);
m_audioOutput->start(m_device);
}
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()));
}
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 QAudioDeviceInfo::nearestFormat(const QAudioFormat &settings) const
{
if (isFormatSupported(settings))
return settings;
QAudioFormat nearest = settings;
nearest.setCodec(QLatin1String("audio/pcm"));
if (nearest.sampleType() == QAudioFormat::Unknown) {
QAudioFormat preferred = preferredFormat();
nearest.setSampleType(preferred.sampleType());
}
QMap<int,int> testFrequencies;
QList<int> frequenciesAvailable = supportedFrequencies();
QMap<int,int> testSampleSizes;
QList<int> sampleSizesAvailable = supportedSampleSizes();
// Get sorted sampleSizes (equal to and ascending values only)
if (sampleSizesAvailable.contains(settings.sampleSize()))
testSampleSizes.insert(0,settings.sampleSize());
sampleSizesAvailable.removeAll(settings.sampleSize());
foreach (int size, sampleSizesAvailable) {
int larger = (size > settings.sampleSize()) ? size : settings.sampleSize();
int smaller = (size > settings.sampleSize()) ? settings.sampleSize() : size;
if (size >= settings.sampleSize()) {
int diff = larger - smaller;
testSampleSizes.insert(diff, size);
}
}
AudioDecoder::AudioDecoder(bool isPlayback, bool isDelete)
: m_cout(stdout, QIODevice::WriteOnly)
{
m_isPlayback = isPlayback;
m_isDelete = isDelete;
// Make sure the data we receive is in correct PCM format.
// Our wav file writer only supports SignedInt sample type.
QAudioFormat format;
format.setChannelCount(2);
format.setSampleSize(16);
format.setSampleRate(48000);
format.setCodec("audio/pcm");
format.setSampleType(QAudioFormat::SignedInt);
m_decoder.setAudioFormat(format);
connect(&m_decoder, SIGNAL(bufferReady()), this, SLOT(bufferReady()));
connect(&m_decoder, SIGNAL(error(QAudioDecoder::Error)), this, SLOT(error(QAudioDecoder::Error)));
connect(&m_decoder, SIGNAL(stateChanged(QAudioDecoder::State)), this, SLOT(stateChanged(QAudioDecoder::State)));
connect(&m_decoder, SIGNAL(finished()), this, SLOT(finished()));
connect(&m_decoder, SIGNAL(positionChanged(qint64)), this, SLOT(updateProgress()));
connect(&m_decoder, SIGNAL(durationChanged(qint64)), this, SLOT(updateProgress()));
connect(&m_soundEffect, SIGNAL(statusChanged()), this, SLOT(playbackStatusChanged()));
connect(&m_soundEffect, SIGNAL(playingChanged()), this, SLOT(playingChanged()));
m_progress = -1.0;
}
void AudioCore::recordAudioSample(int t = 500, bool writeToFile = false)
{
latestSampleDuration = t;
writeSampleToFile = writeToFile;
sampleAudioBuffer.open(QBuffer::ReadWrite);
QAudioFormat format;
// Настраиваем желаемый формат, например:
format.setSampleRate(AudioCore::SampleRate);
format.setSampleSize(8 * AudioCore::SampleSize);
format.setChannelCount(1);
format.setCodec("audio/pcm");
format.setByteOrder(QAudioFormat::LittleEndian);
format.setSampleType(QAudioFormat::UnSignedInt);
// ВЫбрать устройство ввода 0:
QAudioDeviceInfo info(QAudioDeviceInfo::availableDevices(QAudio::AudioInput).at(0));
qDebug() << "Selected input device =" << info.deviceName();
if (!info.isFormatSupported(format)) {
qWarning() << "Default format not supported, trying to use the nearest.";
format = info.nearestFormat(format);
}
audio = new QAudioInput(format);
// Очень важно, иначе будут шумы и все картинки ужасно некрасивые.
audio->setVolume(AudioCore::AudioLevel);
connect(audio, SIGNAL(stateChanged(QAudio::State)), this, SLOT(handleStateChanged(QAudio::State)));
QTimer::singleShot(t, this, SLOT(stopRecording()));
audio->start(&sampleAudioBuffer);
}
void xmppClient::slotAudioModeChanged(QIODevice::OpenMode mode)
{
QXmppCall *call = qobject_cast<QXmppCall*>(sender());
Q_ASSERT(call);
QXmppRtpAudioChannel *channel = call->audioChannel();
// prepare audio format
QAudioFormat format;
format.setSampleRate(channel->payloadType().clockrate());
format.setChannelCount(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.sampleRate() * format.channelCount() * (format.sampleSize() / 8) * 160) / 1000;
if (mode & QIODevice::ReadOnly) {
// initialise audio output
QAudioOutput *audioOutput = new QAudioOutput(format, this);
audioOutput->setBufferSize(bufferSize);
audioOutput->start(channel);
}
if (mode & QIODevice::WriteOnly) {
// initialise audio input
QAudioInput *audioInput = new QAudioInput(format, this);
audioInput->setBufferSize(bufferSize);
audioInput->start(channel);
}
}
void InitializeAudio()
{
m_format.setSampleRate(SampleRate); //set frequency to 44100
m_format.setChannelCount(1); //set channels to mono
m_format.setSampleSize(16); //set sample sze to 16 bit
m_format.setSampleType(QAudioFormat::SignedInt ); //Sample type as usigned integer sample UnSignedInt
m_format.setByteOrder(QAudioFormat::LittleEndian); //Byte order
m_format.setCodec("audio/pcm"); //set codec as simple audio/pcm
QAudioDeviceInfo infoIn(QAudioDeviceInfo::defaultInputDevice());
if (!infoIn.isFormatSupported(m_format))
{
//Default format not supported - trying to use nearest
m_format = infoIn.nearestFormat(m_format);
}
QAudioDeviceInfo infoOut(QAudioDeviceInfo::defaultOutputDevice());
if (!infoOut.isFormatSupported(m_format))
{
//Default format not supported - trying to use nearest
m_format = infoOut.nearestFormat(m_format);
}
m_audioInput = new QAudioInput(m_Inputdevice, m_format);
m_audioOutput = new QAudioOutput(m_Outputdevice, m_format);
}
int CRecordData::StartRecord(bool bIsSection)
{
if(true == bIsSection)
{
}
else
{
SetNumofRecDatSec(0);
// 初始化一个buffer储存raw数据
QBuffer* bufRecord = new QBuffer();
bufRecord->open( QIODevice::WriteOnly | QIODevice::Truncate );
SetRecDatSec(m_iNumOfRecDatSec, bufRecord);
SetNumofRecDatSec(m_iNumOfRecDatSec+1);
// 设置录音格式
QAudioFormat format;
format.setSampleRate(8000);
format.setChannelCount(1);
format.setSampleSize(8);
format.setCodec("audio/pcm");
format.setByteOrder(QAudioFormat::LittleEndian);
format.setSampleType(QAudioFormat::UnSignedInt);
// 设置录音设备
audioInput = new QAudioInput(format, this);
audioInput->start(bufRecord);
}
}
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();
}
}
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);
}
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);
}
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 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;
}
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;
}
QAudioFormat format() {
QAudioFormat format;
format.setSampleRate(8000);
format.setChannelCount(1);
format.setSampleSize(8);
format.setCodec("audio/pcm");
format.setByteOrder(QAudioFormat::LittleEndian);
format.setSampleType(QAudioFormat::UnSignedInt);
return format;
}
void TSoundOutputDeviceImp::play(const TSoundTrackP &st, TINT32 s0, TINT32 s1,
bool loop, bool scrubbing) {
if (!doSetStreamFormat(st->getFormat())) return;
MyData *myData = new MyData();
myData->imp = shared_from_this();
myData->totalPacketCount = s1 - s0;
myData->fileByteCount = (s1 - s0) * st->getSampleSize();
myData->entireFileBuffer = new char[myData->fileByteCount];
memcpy(myData->entireFileBuffer, st->getRawData() + s0 * st->getSampleSize(),
myData->fileByteCount);
m_isPlaying = true;
myData->isLooping = loop;
QAudioFormat format;
QAudioDeviceInfo info(QAudioDeviceInfo::defaultOutputDevice());
format.setSampleSize(st->getBitPerSample());
format.setCodec("audio/pcm");
format.setChannelCount(st->getChannelCount());
format.setByteOrder(QAudioFormat::LittleEndian);
format.setSampleType(st->getFormat().m_signedSample
? QAudioFormat::SignedInt
: QAudioFormat::UnSignedInt);
format.setSampleRate(st->getSampleRate());
QList<QAudioFormat::Endian> sbos = info.supportedByteOrders();
QList<int> sccs = info.supportedChannelCounts();
QList<int> ssrs = info.supportedSampleRates();
QList<QAudioFormat::SampleType> sstypes = info.supportedSampleTypes();
QList<int> ssss = info.supportedSampleSizes();
QStringList supCodes = info.supportedCodecs();
if (!info.isFormatSupported((format))) {
format = info.nearestFormat(format);
int newChannels = format.channelCount();
int newBitsPerSample = format.sampleSize();
int newSampleRate = format.sampleRate();
QAudioFormat::SampleType newSampleType = format.sampleType();
QAudioFormat::Endian newBo = format.byteOrder();
}
int test = st->getSampleCount() / st->getSampleRate();
QByteArray *data =
new QByteArray(myData->entireFileBuffer, myData->fileByteCount);
QBuffer *newBuffer = new QBuffer;
newBuffer->setBuffer(data);
newBuffer->open(QIODevice::ReadOnly);
newBuffer->seek(0);
if (m_audioOutput == NULL) {
m_audioOutput = new QAudioOutput(format, NULL);
}
m_audioOutput->start(newBuffer);
m_audioOutput->setVolume(m_volume);
}
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)));
}
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);
}
QAudioFormat MediaCall::GetAudioReadFormat () const
{
const auto& payload = Call_->audioChannel ()->payloadType ();
QAudioFormat result;
result.setSampleRate (payload.clockrate ());
result.setChannelCount (payload.channels ());
result.setSampleSize (16);
result.setCodec ("audio/pcm");
result.setByteOrder (QAudioFormat::LittleEndian);
result.setSampleType (QAudioFormat::SignedInt);
return result;
}
void MainWindow::PlaySound() {
//QSound *sound = new QSound("/home/mike/TediumRemedy/sample.wav", this);
//sound->play();
//return;
sourceFile.setFileName("/home/mike/TediumRemedy/sample.wav");
sourceFile.open(QIODevice::ReadOnly);
QAudioFormat format;
// Set up the format, eg.
format.setSampleRate(44100);
format.setChannelCount(2);
format.setSampleSize(16);
format.setCodec("audio/pcm");
format.setByteOrder(QAudioFormat::LittleEndian);
format.setSampleType(QAudioFormat::SignedInt);
QAudioDeviceInfo info(QAudioDeviceInfo::defaultOutputDevice());
if (!info.isFormatSupported(format)) {
qWarning() << "Raw audio format not supported by backend, cannot play audio.";
return;
}
return;
/*QSound::play(":resources/connected.wav");
return;
*/
QList<QAudioDeviceInfo> l = QAudioDeviceInfo::availableDevices(QAudio::AudioOutput);
foreach(QAudioDeviceInfo i, l) {
qDebug() << i.supportedCodecs();
}
QTextStream out(stdout);
out << "START-OUTPUT" << endl;
QList<QAudioDeviceInfo> outputList = QAudioDeviceInfo::availableDevices(QAudio::AudioOutput);
foreach(QAudioDeviceInfo outputInfo, outputList) {
out << outputInfo.deviceName() << endl;
}
out << "END-OUTPUT" << endl;
return;
/*QMediaPlayer *p = new QMediaPlayer(0);
p->setMedia(QMediaContent(QUrl::fromLocalFile(":/resources/connected.wav")));
p->play();*/
}
QAudioFormat MultimediaWidget::getAudioFormat( AVInfo const & aAvInfo ) const
{
QAudioFormat audioFormat;
audioFormat.setSampleRate( aAvInfo.getAudioSampleRate() );
audioFormat.setChannelCount( aAvInfo.getAudioChannel() );
audioFormat.setSampleSize( aAvInfo.getAudioBitsPerSample() );
audioFormat.setCodec( "audio/pcm" );
audioFormat.setByteOrder(QAudioFormat::LittleEndian);
audioFormat.setSampleType(QAudioFormat::UnSignedInt);
return audioFormat;
}
QAudioFormat Settings::audioFormat() const
{
QAudioFormat format;
format.setByteOrder(QAudioFormat::LittleEndian);
format.setChannelCount(1);
format.setCodec("audio/pcm");
format.setSampleRate(d->sampleRate);
format.setSampleSize(d->sampleSize);
format.setSampleType(QAudioFormat::SignedInt);
return d->inputDevice.nearestFormat(format);
}
QAudioFormat AudioHandler::createFormat() {
QAudioFormat f;
f.setCodec("audio/pcm");
f.setChannelCount(2);
f.setSampleRate(48000);
f.setSampleSize(16);
f.setSampleType(QAudioFormat::UnSignedInt);
f.setByteOrder(QAudioFormat::LittleEndian);
return f;
}
void VideoItem::updateAudioFormat()
{
QAudioFormat format;
format.setSampleSize(16);
format.setSampleRate(core->getSampleRate());
format.setChannelCount(2);
format.setSampleType(QAudioFormat::SignedInt);
format.setByteOrder(QAudioFormat::LittleEndian);
format.setCodec("audio/pcm");
// TODO test format
audio->setFormat(format);
}