FCL/sf/mw/qt: comparison src/multimedia/audio/qaudioinput_symbian

equal deleted inserted replaced

-:89e065397ea6
+:e24348a560a6
 ,   m_internalState(SymbianAudio::ClosedState)
 ,   m_externalState(QAudio::StoppedState)
 ,   m_pullMode(false)
 ,   m_sink(0)
 ,   m_pullTimer(new QTimer(this))
+,   m_devSound(0)
 ,   m_devSoundBuffer(0)
 ,   m_devSoundBufferSize(0)
 ,   m_totalBytesReady(0)
 ,   m_devSoundBufferPos(0)
 ,   m_totalSamplesRecorded(0)
 {
+qRegisterMetaType<CMMFBuffer *>("CMMFBuffer *");
 connect(m_notifyTimer.data(), SIGNAL(timeout()), this, SIGNAL(notify()));
-SymbianAudio::Utils::formatQtToNative(m_format, m_nativeFourCC,
-m_nativeFormat);
 m_pullTimer->setInterval(PushInterval);
 connect(m_pullTimer.data(), SIGNAL(timeout()), this, SLOT(pullData()));
 }
 }
 void QAudioInputPrivate::reset()
 {
 m_totalSamplesRecorded += getSamplesRecorded();
-m_devSound->Stop();
+m_devSound->stop();
 startRecording();
 }
 void QAudioInputPrivate::suspend()
 {
 if (SymbianAudio::ActiveState == m_internalState
 || SymbianAudio::IdleState == m_internalState) {
 m_notifyTimer->stop();
 m_pullTimer->stop();
-m_devSound->Pause();
+m_devSound->pause();
 const qint64 samplesRecorded = getSamplesRecorded();
 m_totalSamplesRecorded += samplesRecorded;
 if (m_devSoundBuffer) {
 m_devSoundBufferQ.append(m_devSoundBuffer);
 }
 }
 void QAudioInputPrivate::resume()
 {
-if (SymbianAudio::SuspendedState == m_internalState)
+if (SymbianAudio::SuspendedState == m_internalState) {
+if (!m_pullMode && !bytesReady())
+m_devSound->start();
 startDataTransfer();
+}
 }
 int QAudioInputPrivate::bytesReady() const
 {
 Q_ASSERT(m_devSoundBufferPos <= m_totalBytesReady);
 return m_devSoundBufferSize ? m_devSoundBufferSize : m_clientBufferSize;
 }
 void QAudioInputPrivate::setNotifyInterval(int ms)
 {
-if (ms > 0) {
+if (ms >= 0) {
 const int oldNotifyInterval = m_notifyInterval;
 m_notifyInterval = ms;
-if (m_notifyTimer->isActive() && ms != oldNotifyInterval)
+if (m_notifyInterval && (SymbianAudio::ActiveState == m_internalState ||
+SymbianAudio::IdleState == m_internalState))
 m_notifyTimer->start(m_notifyInterval);
+else
+m_notifyTimer->stop();
 }
 }
 int QAudioInputPrivate::notifyInterval() const
 {
 QAudioFormat QAudioInputPrivate::format() const
 {
 return m_format;
 }
-//-----------------------------------------------------------------------------
-// MDevSoundObserver implementation
-//-----------------------------------------------------------------------------
-void QAudioInputPrivate::InitializeComplete(TInt aError)
-{
-Q_ASSERT_X(SymbianAudio::InitializingState == m_internalState,
-Q_FUNC_INFO, "Invalid state");
-if (KErrNone == aError)
-startRecording();
-}
-void QAudioInputPrivate::ToneFinished(TInt aError)
-{
-Q_UNUSED(aError)
-// This class doesn't use DevSound's tone playback functions, so should
-// never receive this callback.
-Q_ASSERT_X(false, Q_FUNC_INFO, "Unexpected callback");
-}
-void QAudioInputPrivate::BufferToBeFilled(CMMFBuffer *aBuffer)
-{
-Q_UNUSED(aBuffer)
-// This class doesn't use DevSound in play mode, so should never receive
-// this callback.
-Q_ASSERT_X(false, Q_FUNC_INFO, "Unexpected callback");
-}
-void QAudioInputPrivate::PlayError(TInt aError)
-{
-Q_UNUSED(aError)
-// This class doesn't use DevSound in play mode, so should never receive
-// this callback.
-Q_ASSERT_X(false, Q_FUNC_INFO, "Unexpected callback");
-}
-void QAudioInputPrivate::BufferToBeEmptied(CMMFBuffer *aBuffer)
-{
-// Following receipt of this callback, DevSound should not provide another
-// buffer until we have returned the current one.
-Q_ASSERT_X(!m_devSoundBuffer, Q_FUNC_INFO, "Buffer already held");
-CMMFDataBuffer *const buffer = static_cast<CMMFDataBuffer*>(aBuffer);
-if (!m_devSoundBufferSize)
-m_devSoundBufferSize = buffer->Data().MaxLength();
-m_totalBytesReady += buffer->Data().Length();
-if (SymbianAudio::SuspendedState == m_internalState) {
-m_devSoundBufferQ.append(buffer);
-} else {
-// Will be returned to DevSound by bufferEmptied().
-m_devSoundBuffer = buffer;
-m_devSoundBufferPos = 0;
-if (bytesReady() && !m_pullMode)
-pushData();
-}
-}
-void QAudioInputPrivate::RecordError(TInt aError)
-{
-Q_UNUSED(aError)
-setError(QAudio::IOError);
-}
-void QAudioInputPrivate::ConvertError(TInt aError)
-{
-Q_UNUSED(aError)
-// This class doesn't use DevSound's format conversion functions, so
-// should never receive this callback.
-Q_ASSERT_X(false, Q_FUNC_INFO, "Unexpected callback");
-}
-void QAudioInputPrivate::DeviceMessage(TUid aMessageType, const TDesC8 &aMsg)
-{
-Q_UNUSED(aMessageType)
-Q_UNUSED(aMsg)
-// Ignore this callback.
-}
 //-----------------------------------------------------------------------------
 // Private functions
 //-----------------------------------------------------------------------------
 void QAudioInputPrivate::open()
 {
 Q_ASSERT_X(SymbianAudio::ClosedState == m_internalState,
 Q_FUNC_INFO, "DevSound already opened");
-QT_TRAP_THROWING( m_devSound.reset(CMMFDevSound::NewL()) )
+Q_ASSERT(!m_devSound);
+m_devSound = new SymbianAudio::DevSoundWrapper(QAudio::AudioInput, this);
-QScopedPointer<SymbianAudio::DevSoundCapabilities> caps(
-new SymbianAudio::DevSoundCapabilities(*m_devSound, QAudio::AudioInput));
+connect(m_devSound, SIGNAL(initializeComplete(int)),
+this, SLOT(devsoundInitializeComplete(int)));
-int err = SymbianAudio::Utils::isFormatSupported(m_format, *caps) ?
+connect(m_devSound, SIGNAL(bufferToBeProcessed(CMMFBuffer *)),
-KErrNone : KErrNotSupported;
+this, SLOT(devsoundBufferToBeEmptied(CMMFBuffer *)));
+connect(m_devSound, SIGNAL(processingError(int)),
-if (KErrNone == err) {
+this, SLOT(devsoundRecordError(int)));
-setState(SymbianAudio::InitializingState);
-TRAP(err, m_devSound->InitializeL(*this, m_nativeFourCC,
+setState(SymbianAudio::InitializingState);
-EMMFStateRecording));
+m_devSound->initialize(m_format.codec());
-}
-if (KErrNone != err) {
-setError(QAudio::OpenError);
-m_devSound.reset();
-}
 }
 void QAudioInputPrivate::startRecording()
 {
-const int samplesRecorded = m_devSound->SamplesRecorded();
+const int samplesRecorded = m_devSound->samplesProcessed();
 Q_ASSERT(samplesRecorded == 0);
-TRAPD(err, startDevSoundL());
+bool ok = m_devSound->setFormat(m_format);
-if (KErrNone == err) {
+if (ok)
+ok = m_devSound->start();
+if (ok) {
 startDataTransfer();
 } else {
 setError(QAudio::OpenError);
 close();
 }
 }
-void QAudioInputPrivate::startDevSoundL()
-{
-TMMFCapabilities nativeFormat = m_devSound->Config();
-m_nativeFormat.iBufferSize = nativeFormat.iBufferSize;
-m_devSound->SetConfigL(m_nativeFormat);
-m_devSound->RecordInitL();
-}
 void QAudioInputPrivate::startDataTransfer()
 {
-m_notifyTimer->start(m_notifyInterval);
+if (m_notifyInterval)
+m_notifyTimer->start(m_notifyInterval);
 if (m_pullMode)
 m_pullTimer->start();
 if (bytesReady()) {
 if (!bytesPushed)
 break;
 }
 }
+void QAudioInputPrivate::devsoundInitializeComplete(int err)
+{
+Q_ASSERT_X(SymbianAudio::InitializingState == m_internalState,
+Q_FUNC_INFO, "Invalid state");
+if (!err && m_devSound->isFormatSupported(m_format))
+startRecording();
+else
+setError(QAudio::OpenError);
+}
+void QAudioInputPrivate::devsoundBufferToBeEmptied(CMMFBuffer *baseBuffer)
+{
+// Following receipt of this signal, DevSound should not provide another
+// buffer until we have returned the current one.
+Q_ASSERT_X(!m_devSoundBuffer, Q_FUNC_INFO, "Buffer already held");
+CMMFDataBuffer *const buffer = static_cast<CMMFDataBuffer*>(baseBuffer);
+if (!m_devSoundBufferSize)
+m_devSoundBufferSize = buffer->Data().MaxLength();
+m_totalBytesReady += buffer->Data().Length();
+if (SymbianAudio::SuspendedState == m_internalState) {
+m_devSoundBufferQ.append(buffer);
+} else {
+// Will be returned to DevSoundWrapper by bufferProcessed().
+m_devSoundBuffer = buffer;
+m_devSoundBufferPos = 0;
+if (bytesReady() && !m_pullMode)
+pushData();
+}
+}
+void QAudioInputPrivate::devsoundRecordError(int err)
+{
+Q_UNUSED(err)
+setError(QAudio::IOError);
+}
 void QAudioInputPrivate::bufferEmptied()
 {
 m_devSoundBufferPos = 0;
 if (m_devSoundBuffer) {
 m_totalBytesReady -= m_devSoundBuffer->Data().Length();
 m_devSoundBuffer = 0;
-m_devSound->RecordData();
+m_devSound->bufferProcessed();
 } else {
 Q_ASSERT(!m_devSoundBufferQ.empty());
 m_totalBytesReady -= m_devSoundBufferQ.front()->Data().Length();
 m_devSoundBufferQ.erase(m_devSoundBufferQ.begin());
 // If the queue has been emptied, resume transfer from the hardware
 if (m_devSoundBufferQ.empty())
-m_devSound->RecordInitL();
+if (!m_devSound->start())
+setError(QAudio::IOError);
 }
 Q_ASSERT(m_totalBytesReady >= 0);
 }
 m_pullTimer->stop();
 m_error = QAudio::NoError;
 if (m_devSound)
-m_devSound->Stop();
+m_devSound->stop();
-m_devSound.reset();
+delete m_devSound;
+m_devSound = 0;
 m_devSoundBuffer = 0;
 m_devSoundBufferSize = 0;
 m_totalBytesReady = 0;
 if (!m_pullMode) // m_sink is owned
 qint64 QAudioInputPrivate::getSamplesRecorded() const
 {
 qint64 result = 0;
 if (m_devSound)
-result = qint64(m_devSound->SamplesRecorded());
+result = qint64(m_devSound->samplesProcessed());
 return result;
 }
 void QAudioInputPrivate::setError(QAudio::Error error)
 {
 m_error = error;
 // Although no state transition actually occurs here, a stateChanged event
 // must be emitted to inform the client that the call to start() was
 // unsuccessful.
-if (QAudio::OpenError == error)
+if (QAudio::OpenError == error) {
 emit stateChanged(QAudio::StoppedState);
+} else {
-// Close the DevSound instance.  This causes a transition to StoppedState.
+if (QAudio::UnderrunError == error)
-// This must be done asynchronously in case the current function was called
+setState(SymbianAudio::IdleState);
-// from a DevSound event handler, in which case deleting the DevSound
+else
-// instance may cause an exception.
+// Close the DevSound instance.  This causes a transition to
-QMetaObject::invokeMethod(this, "close", Qt::QueuedConnection);
+// StoppedState.  This must be done asynchronously in case the
+// current function was called from a DevSound event handler, in which
+// case deleting the DevSound instance may cause an exception.
+QMetaObject::invokeMethod(this, "close", Qt::QueuedConnection);
+}
 }
 void QAudioInputPrivate::setState(SymbianAudio::State newInternalState)
 {
 const QAudio::State oldExternalState = m_externalState;
 m_internalState = newInternalState;
-m_externalState = SymbianAudio::Utils::stateNativeToQt(
+m_externalState = SymbianAudio::Utils::stateNativeToQt(m_internalState);
-m_internalState, initializingState());
 if (m_externalState != oldExternalState)
 emit stateChanged(m_externalState);
 }
-QAudio::State QAudioInputPrivate::initializingState() const
-{
-return QAudio::IdleState;
-}
 QT_END_NAMESPACE

changeset 25	e24348a560a6
parent 19	fcece45ef507