MCL/sf/mw/qt: comparison src/multimedia/audio/qaudioinput_mac

equal deleted inserted replaced

-:dee5afe5301f
+:3f74d0d4af4c
 #include <QtCore/qendian.h>
 #include <QtCore/qtimer.h>
 #include <QtCore/qdebug.h>
-#include <QtMultimedia/qaudiodeviceinfo.h>
 #include <QtMultimedia/qaudioinput.h>
 #include "qaudio_mac_p.h"
 #include "qaudioinput_mac_p.h"
+#include "qaudiodeviceinfo_mac_p.h"
 QT_BEGIN_NAMESPACE
-namespace
+namespace QtMultimediaInternal
 {
 static const int default_buffer_size = 4 * 1024;
 class QAudioBufferList
 return sf.mBytesPerPacket;
 }
 void reset()
 {
-for (UInt32 i = 0; i < bfs->mNumberBuffers; ++i)
+for (UInt32 i = 0; i < bfs->mNumberBuffers; ++i) {
 bfs->mBuffers[i].mDataByteSize = dataSize;
+bfs->mBuffers[i].mData = 0;
+}
 }
 private:
 bool    owner;
 int     dataSize;
 AudioStreamBasicDescription const& inputFormat,
 AudioStreamBasicDescription const& outputFormat,
 QObject* parent):
 QObject(parent),
 m_deviceError(false),
+m_audioConverter(0),
 m_inputFormat(inputFormat),
 m_outputFormat(outputFormat)
 {
 m_maxPeriodSize = maxPeriodSize;
 m_periodTime = m_maxPeriodSize / m_outputFormat.mBytesPerFrame * 1000 / m_outputFormat.mSampleRate;
 m_inputBufferList = new QAudioBufferList(m_inputFormat);
 m_flushTimer = new QTimer(this);
 connect(m_flushTimer, SIGNAL(timeout()), SLOT(flushBuffer()));
-if (inputFormat.mSampleRate != outputFormat.mSampleRate) {
+if (toQAudioFormat(inputFormat) != toQAudioFormat(outputFormat)) {
 if (AudioConverterNew(&m_inputFormat, &m_outputFormat, &m_audioConverter) != noErr) {
 qWarning() << "QAudioInput: Unable to create an Audio Converter";
 m_audioConverter = 0;
 }
 }
 ds >> did >> mode;
 if (QAudio::Mode(mode) == QAudio::AudioOutput)
 errorCode = QAudio::OpenError;
 else {
+audioDeviceInfo = new QAudioDeviceInfoInternal(device, QAudio::AudioInput);
 isOpen = false;
 audioDeviceId = AudioDeviceID(did);
 audioUnit = 0;
 startTime = 0;
 totalFrames = 0;
 audioBuffer = 0;
-internalBufferSize = default_buffer_size;
+internalBufferSize = QtMultimediaInternal::default_buffer_size;
 clockFrequency = AudioGetHostClockFrequency() / 1000;
 errorCode = QAudio::NoError;
 stateCode = QAudio::StoppedState;
 intervalTimer = new QTimer(this);
 }
 QAudioInputPrivate::~QAudioInputPrivate()
 {
 close();
+delete audioDeviceInfo;
 }
 bool QAudioInputPrivate::open()
 {
 UInt32  size = 0;
 kAudioOutputUnitProperty_EnableIO,
 kAudioUnitScope_Input,
 1,
 &enable,
 sizeof(enable)) != noErr) {
-qWarning() << "QAudioInput: Unabled to switch to input mode (Enable Input)";
+qWarning() << "QAudioInput: Unable to switch to input mode (Enable Input)";
 return false;
 }
 enable = 0;
 if (AudioUnitSetProperty(audioUnit,
 kAudioOutputUnitProperty_EnableIO,
 kAudioUnitScope_Output,
 0,
 &enable,
 sizeof(enable)) != noErr) {
-qWarning() << "QAudioInput: Unabled to switch to input mode (Disable output)";
+qWarning() << "QAudioInput: Unable to switch to input mode (Disable output)";
 return false;
 }
 // register callback
 AURenderCallbackStruct cb;
 qWarning() << "QAudioInput: Unable to use configured device";
 return false;
 }
 // Set format
+// Wanted
 streamFormat = toAudioStreamBasicDescription(audioFormat);
-size = sizeof(deviceFormat);
+// Required on unit
-if (AudioUnitGetProperty(audioUnit,
+if (audioFormat == audioDeviceInfo->preferredFormat()) {
-kAudioUnitProperty_StreamFormat,
+deviceFormat = streamFormat;
-kAudioUnitScope_Input,
+AudioUnitSetProperty(audioUnit,
-1,
-&deviceFormat,
-&size) != noErr) {
-qWarning() << "QAudioInput: Unable to retrieve device format";
-return false;
-}
-// If the device frequency is different to the requested use a converter
-if (deviceFormat.mSampleRate != streamFormat.mSampleRate) {
-AudioUnitSetProperty(audioUnit,
 kAudioUnitProperty_StreamFormat,
 kAudioUnitScope_Output,
 1,
 &deviceFormat,
-sizeof(streamFormat));
+sizeof(deviceFormat));
 }
 else {
-AudioUnitSetProperty(audioUnit,
+size = sizeof(deviceFormat);
-kAudioUnitProperty_StreamFormat,
+if (AudioUnitGetProperty(audioUnit,
-kAudioUnitScope_Output,
+kAudioUnitProperty_StreamFormat,
-1,
+kAudioUnitScope_Input,
-&streamFormat,
+1,
-sizeof(streamFormat));
+&deviceFormat,
+&size) != noErr) {
+qWarning() << "QAudioInput: Unable to retrieve device format";
+return false;
+}
+if (AudioUnitSetProperty(audioUnit,
+kAudioUnitProperty_StreamFormat,
+kAudioUnitScope_Output,
+1,
+&deviceFormat,
+sizeof(deviceFormat)) != noErr) {
+qWarning() << "QAudioInput: Unable to set device format";
+return false;
+}
 }
 // Setup buffers
 UInt32 numberOfFrames;
 size = sizeof(UInt32);
 qWarning() << "QAudioInput: Failed to get audio period size";
 return false;
 }
 // Allocate buffer
-periodSizeBytes = (numberOfFrames * streamFormat.mSampleRate / deviceFormat.mSampleRate) *
+periodSizeBytes = numberOfFrames * streamFormat.mBytesPerFrame;
-streamFormat.mBytesPerFrame;
 if (internalBufferSize < periodSizeBytes * 2)
 internalBufferSize = periodSizeBytes * 2;
 else
 internalBufferSize -= internalBufferSize % streamFormat.mBytesPerFrame;
-audioBuffer = new QAudioInputBuffer(internalBufferSize,
+audioBuffer = new QtMultimediaInternal::QAudioInputBuffer(internalBufferSize,
 periodSizeBytes,
 deviceFormat,
 streamFormat,
 this);
-audioIO = new MacInputDevice(audioBuffer, this);
+audioIO = new QtMultimediaInternal::MacInputDevice(audioBuffer, this);
 // Init
 if (AudioUnitInitialize(audioUnit) != noErr) {
 qWarning() << "QAudioInput: Failed to initialize AudioUnit";
 return false;
 QIODevice* QAudioInputPrivate::start(QIODevice* device)
 {
 QIODevice*  op = device;
-if (!open()) {
+if (!audioFormat.isValid() || !open()) {
 stateCode = QAudio::StoppedState;
 errorCode = QAudio::OpenError;
 return audioIO;
 }
 return internalBufferSize;
 }
 void QAudioInputPrivate::setNotifyInterval(int milliSeconds)
 {
+if (intervalTimer->interval() == milliSeconds)
+return;
+if (milliSeconds <= 0)
+milliSeconds = 0;
 intervalTimer->setInterval(milliSeconds);
 }
 int QAudioInputPrivate::notifyInterval() const
 {
 }
 void QAudioInputPrivate::startTimers()
 {
 audioBuffer->startFlushTimer();
-intervalTimer->start();
+if (intervalTimer->interval() > 0)
+intervalTimer->start();
 }
 void QAudioInputPrivate::stopTimers()
 {
 audioBuffer->stopFlushTimer();

branch	RCL_3
changeset 7	3f74d0d4af4c
parent 4	3b1da2848fc7