FCL/sf/mw/qtextensions: comparison qtmobility/plugins/multimedia/symbian/openmaxal/mediarecorder/qxarecordsession.cpp

equal deleted inserted replaced

-:06b8e2af4411
+:6fbed849b4f4
 * and returns from function immediately with value 's'.
 */
 #define RETURN_s_IF_m_impl_IS_NULL(s) \
 if (!m_impl) { \
-emit error(QMediaRecorder::ResourceError, tr("Service has not been started")); \
+emit error(QMediaRecorder::ResourceError, QXARecordSession::tr("Service has not been started")); \
 SIGNAL_EMIT_TRACE1("emit error(QMediaRecorder::ResourceError, tr(\"Service has not been started\"))"); \
 return s; \
 }
 /* This macro checks for m_impl null pointer. If it is, emits an error signal
 * error(QMediaRecorder::ResourceError, tr("Service has not been started"));
 * and returns from function immediately.
 */
 #define RETURN_IF_m_impl_IS_NULL \
 if (!m_impl) { \
-emit error(QMediaRecorder::ResourceError, tr("Service has not been started")); \
+emit error(QMediaRecorder::ResourceError, QXARecordSession::tr("Service has not been started")); \
 SIGNAL_EMIT_TRACE1("emit error(QMediaRecorder::ResourceError, tr(\"Service has not been started\"))"); \
 return; \
 }
 QXARecordSession::QXARecordSession(QObject *parent)
 :QObject(parent),
-m_state(QMediaRecorder::StoppedState)
+m_state(QMediaRecorder::StoppedState),
+m_previousState(QMediaRecorder::StoppedState)
 {
 QT_TRACE_FUNCTION_ENTRY;
 m_impl = NULL;
 m_impl = new XARecordSessionImpl(*this);
 if (m_impl) {
 if (m_impl->postConstruct() == KErrNone) {
 initCodecsList();
 initContainersList();
-m_containerMimeType = QString();
+m_containerMimeType = QString("audio/wav");
+m_audioencodersettings.setCodec("pcm");
 m_audioencodersettings.setBitRate(0);
 m_audioencodersettings.setChannelCount(-1);
-m_audioencodersettings.setEncodingMode(QtMediaServices::ConstantQualityEncoding);
+m_audioencodersettings.setEncodingMode(QtMultimedia::ConstantQualityEncoding);
-m_audioencodersettings.setQuality(QtMediaServices::NormalQuality);
+m_audioencodersettings.setQuality(QtMultimedia::NormalQuality);
 m_audioencodersettings.setSampleRate(-1);
 QT_TRACE1("Initialized implementation");
 }
 else {
 delete m_impl;
 QT_TRACE_FUNCTION_ENTRY;
 RETURN_s_IF_m_impl_IS_NULL(false);
 // Location can be set only when recorder is in stopped state.
-if (state() != QMediaRecorder::StoppedState )
+if (state() != QMediaRecorder::StoppedState) {
 return false;
+}
 // Validate URL
 if (!location.isValid())
 return false;
 // If old and new locations are same, do nothing.
 return true;
 bool retVal = false;
 TPtrC16 tempPtr(reinterpret_cast<const TUint16 *>(newUrlStr.utf16()));
 if (m_impl->setURI(tempPtr) == 0) {
+QT_TRACE2("Location:", newUrlStr);
 m_outputLocation = location;
+/* New file, so user can set new settings */
+m_previousState = QMediaRecorder::StoppedState;
 retVal = true;
 }
 else {
 emit error(QMediaRecorder::ResourceError, tr("Generic error"));
 SIGNAL_EMIT_TRACE1("emit error(QMediaRecorder::ResourceError, tr(\"Generic error\"))");
 return (qint64)dur;
 }
 void QXARecordSession::applySettings()
 {
-if (m_appliedaudioencodersettings != m_audioencodersettings)
+/* Settings can only be applied when the recorder is in the stopped
-setEncoderSettingsToImpl();
+* state after creation. */
+if ((state() == QMediaRecorder::StoppedState) && (m_state == m_previousState)) {
+if (m_appliedaudioencodersettings != m_audioencodersettings)
+setEncoderSettingsToImpl();
+}
+else {
+emit error(QMediaRecorder::FormatError, tr("Settings cannot be changed once recording started"));
+SIGNAL_EMIT_TRACE1("emit error(QMediaRecorder::FormatError, tr(\"Settings cannot be changed once recording started\"))");
+}
 }
 void QXARecordSession::record()
 {
 QT_TRACE_FUNCTION_ENTRY;
 RETURN_IF_m_impl_IS_NULL;
+/* No op if object is already in recording state */
+if (state() == QMediaRecorder::RecordingState)
+return;
 /* 1. Set encoder settings here */
 if (m_appliedaudioencodersettings != m_audioencodersettings)
 RET_IF_FALSE(setEncoderSettingsToImpl());
 {
 QT_TRACE_FUNCTION_ENTRY;
 RETURN_IF_m_impl_IS_NULL;
+/* No op if object is already in paused/stopped state */
+if ((state() == QMediaRecorder::PausedState) || (state() == QMediaRecorder::StoppedState)) {
+return;
+}
 if (m_impl->pause() == KErrNone) {
 setRecorderState(QMediaRecorder::PausedState);
 }
 else {
 emit error(QMediaRecorder::ResourceError, tr("Unable to pause"));
 {
 QT_TRACE_FUNCTION_ENTRY;
 RETURN_IF_m_impl_IS_NULL;
+/* No op if object is already in paused state */
+if (state() == QMediaRecorder::StoppedState)
+return;
 if ((m_impl->stop() == KErrNone)) {
 setRecorderState(QMediaRecorder::StoppedState);
 }
 else {
 emit error(QMediaRecorder::ResourceError, tr("Unable to stop"));
 QT_TRACE_FUNCTION_EXIT;
 }
 void QXARecordSession::cbDurationChanged(TInt64 new_pos)
 {
+QT_TRACE_FUNCTION_ENTRY;
 emit durationChanged((qint64)new_pos);
 SIGNAL_EMIT_TRACE1("emit durationChanged((qint64)new_pos);");
+QT_TRACE_FUNCTION_EXIT;
 }
 void QXARecordSession::cbAvailableAudioInputsChanged()
 {
+QT_TRACE_FUNCTION_ENTRY;
 emit availableAudioInputsChanged();
 SIGNAL_EMIT_TRACE1("emit availableAudioInputsChanged();");
+QT_TRACE_FUNCTION_EXIT;
 }
 void QXARecordSession::cbRecordingStarted()
 {
+QT_TRACE_FUNCTION_ENTRY;
 setRecorderState(QMediaRecorder::RecordingState);
+QT_TRACE_FUNCTION_EXIT;
 }
 void QXARecordSession::cbRecordingStopped()
 {
+QT_TRACE_FUNCTION_ENTRY;
 emit error(QMediaRecorder::ResourceError, tr("Resources Unavailable"));
 SIGNAL_EMIT_TRACE1("emit error(QMediaRecorder::ResourceError, tr(\"Resources Unavailable\"))");
 setRecorderState(QMediaRecorder::StoppedState);
+/* Set record state to Stopped */
+if (m_impl)
+m_impl->stop();
+QT_TRACE_FUNCTION_EXIT;
 }
 /* For QAudioEndpointSelector begin */
 QList<QString> QXARecordSession::availableEndpoints()
 {
 TPtrC16 tempPtr(reinterpret_cast<const TUint16*>(selectedCodec.utf16()));
 if (m_impl->getSampleRates(tempPtr, sampleRates, isContinuous) == KErrNone) {
 for (TInt index = 0; index < sampleRates.Count(); index++)
 srList.append(sampleRates[index]);
 sampleRates.Close();
-*continuous = false;
+if (continuous)
-if (isContinuous == true)
+{
-*continuous = true;
+*continuous = false;
+if (isContinuous == true)
+*continuous = true;
+}
 }
 }
 QT_TRACE_FUNCTION_EXIT;
 return srList;
 return m_audioencodersettings;
 }
 void QXARecordSession::setAudioSettings(const QAudioEncoderSettings &settings)
 {
-m_audioencodersettings = settings;
+/* Settings can only be set when the recorder is in the stopped
+* state after creation. */
+if ((state() == QMediaRecorder::StoppedState) && (m_state == m_previousState)) {
+m_audioencodersettings = settings;
+}
+else {
+emit error(QMediaRecorder::FormatError, tr("Settings cannot be changed once recording started"));
+SIGNAL_EMIT_TRACE1("emit error(QMediaRecorder::FormatError, tr(\"Settings cannot be changed once recording started\"))");
+}
 }
 QStringList QXARecordSession::supportedEncodingOptions(const QString &codec)
 {
 QT_TRACE_FUNCTION_ENTRY;
 Q_UNUSED(codec);
 QStringList options;
-options << "bitrate";
+if ((codec.compare("aac") == 0) ||
+(codec.compare("amr") == 0))
+{
+options << "bitrate";
+}
 QT_TRACE_FUNCTION_EXIT;
 return options;
 }
 }
 void QXARecordSession::setRecorderState(QMediaRecorder::State state)
 {
 if (state != m_state) {
+m_previousState = m_state;
 m_state = state;
 emit stateChanged(m_state);
 SIGNAL_EMIT_TRACE1("emit stateChanged(m_state);");
 }
 }
 QString tempStr = m_containerMimeType.toLower();
 TPtrC16 tempPtr(reinterpret_cast<const TUint16 *>(tempStr.utf16()));
 m_impl->setContainerType(tempPtr);
 /* Validate and set bitrate only if encoding mode is other than quality encoding */
-if (m_audioencodersettings.encodingMode() != QtMediaServices::ConstantQualityEncoding) {
+if (m_audioencodersettings.encodingMode() != QtMultimedia::ConstantQualityEncoding) {
-if (m_audioencodersettings.bitRate() < 0 ) {
+if (m_audioencodersettings.bitRate() == -1) {
+m_impl->setOptimalBitRate();
+}
+else if (m_audioencodersettings.bitRate() < 0 ) {
 emit error(QMediaRecorder::FormatError, tr("Invalid bitrate"));
 SIGNAL_EMIT_TRACE1("emit error(QMediaRecorder::FormatError, tr(\"Invalid bitrate\"))");
 return false;
 }
 else {
 tempPtr.Set(reinterpret_cast<const TUint16*>(tempStr.utf16()));
 /* We already did validation above, so function always returns true */
 m_impl->setCodec(tempPtr);
 }
 else {
+QT_TRACE2("Codec selected is :", m_audioencodersettings.codec().toLower());
 emit error(QMediaRecorder::FormatError, tr("Invalid codec"));
 SIGNAL_EMIT_TRACE1("emit error(QMediaRecorder::FormatError, tr(\"Invalid codec\"));");
 return false;
 }
 switch (m_audioencodersettings.encodingMode()) {
-case QtMediaServices::ConstantQualityEncoding: {
+case QtMultimedia::ConstantQualityEncoding: {
 switch (m_audioencodersettings.quality()) {
-case QtMediaServices::VeryLowQuality:
+case QtMultimedia::VeryLowQuality:
 m_impl->setVeryLowQuality();
 break;
-case QtMediaServices::LowQuality:
+case QtMultimedia::LowQuality:
 m_impl->setLowQuality();
 break;
-case QtMediaServices::NormalQuality:
+case QtMultimedia::NormalQuality:
 m_impl->setNormalQuality();
 break;
-case QtMediaServices::HighQuality:
+case QtMultimedia::HighQuality:
 m_impl->setHighQuality();
 break;
-case QtMediaServices::VeryHighQuality:
+case QtMultimedia::VeryHighQuality:
 m_impl->setVeryHighQuality();
 break;
 default:
 emit error(QMediaRecorder::FormatError, tr("Invalid encoding quality setting"));
 SIGNAL_EMIT_TRACE1("emit error(QMediaRecorder::FormatError, tr(\"Invalid encoding quality setting\"));");
 return false;
 }; /* end of switch (m_audioencodersettings.quality())*/
 }
 break;
-case QtMediaServices::ConstantBitRateEncoding: {
+case QtMultimedia::ConstantBitRateEncoding: {
 TInt32 status = m_impl->setCBRMode();
 if (status == KErrNotSupported) {
 emit error(QMediaRecorder::FormatError, tr("Invalid encoding mode setting"));
 SIGNAL_EMIT_TRACE1("emit error(QMediaRecorder::FormatError, tr(\"Invalid encoding mode setting\"));");
 return false;
 SIGNAL_EMIT_TRACE1("emit error(QMediaRecorder::ResourceError, tr(\"Internal error\"));");
 return false;
 }
 }
 break;
-case QtMediaServices::AverageBitRateEncoding: {
+case QtMultimedia::AverageBitRateEncoding: {
 TInt32 status = m_impl->setVBRMode();
 if (status == KErrNotSupported) {
 emit error(QMediaRecorder::FormatError, tr("Invalid encoding mode setting"));
 SIGNAL_EMIT_TRACE1("emit error(QMediaRecorder::FormatError, tr(\"Invalid encoding mode setting\"));");
 return false;
 SIGNAL_EMIT_TRACE1("emit error(QMediaRecorder::ResourceError, tr(\"Internal error\"));");
 return false;
 }
 }
 break;
-case QtMediaServices::TwoPassEncoding:
+case QtMultimedia::TwoPassEncoding:
 // fall through
 default: {
 emit error(QMediaRecorder::FormatError, tr("Invalid encoding mode setting"));
 SIGNAL_EMIT_TRACE1("emit error(QMediaRecorder::FormatError, tr(\"Invalid encoding mode setting\"));");
 return false;
 }
 }; /* switch (m_audioencodersettings.encodingMode()) */
-if (m_audioencodersettings.sampleRate() == -1) {
+/* Validate and set bitrate only if encoding mode is other than quality encoding */
-m_impl->setOptimalSampleRate();
+if (m_audioencodersettings.encodingMode() != QtMultimedia::ConstantQualityEncoding) {
-}
+if (m_audioencodersettings.sampleRate() == -1) {
-else if (m_audioencodersettings.sampleRate() <= 0) {
+m_impl->setOptimalSampleRate();
-emit error(QMediaRecorder::FormatError, tr("Invalid sample rate"));
+}
-SIGNAL_EMIT_TRACE1("emit error(QMediaRecorder::FormatError, tr(\"Invalid sample rate\"));");
+else if (m_audioencodersettings.sampleRate() <= 0) {
-return false;
+emit error(QMediaRecorder::FormatError, tr("Invalid sample rate"));
-}
+SIGNAL_EMIT_TRACE1("emit error(QMediaRecorder::FormatError, tr(\"Invalid sample rate\"));");
-else {
+return false;
-m_impl->setSampleRate(m_audioencodersettings.sampleRate());
+}
+else {
+m_impl->setSampleRate(m_audioencodersettings.sampleRate());
+}
 }
 m_appliedaudioencodersettings = m_audioencodersettings;
 QT_TRACE_FUNCTION_EXIT;
 return true;
 }

changeset 14	6fbed849b4f4
parent 11	06b8e2af4411
child 15	1f895d8a5b2b