Debug Macros & Doxygen comments

Signed-off-by: hawcroft <derick.hawcroft@nokia.com>

22 files changed, 2399 insertions, 46 deletions

diff --git a/plugins/multimedia/symbian/mmf/audiosource/s60audiocaptureservice.cpp b/plugins/multimedia/symbian/mmf/audiosource/s60audiocaptureservice.cpp
index 7694df0e4a..742ac8f823 100644
--- a/plugins/multimedia/symbian/mmf/audiosource/s60audiocaptureservice.cpp
+++ b/plugins/multimedia/symbian/mmf/audiosource/s60audiocaptureservice.cpp
@@ -38,6 +38,8 @@
 ** $QT_END_LICENSE$
 **
 ****************************************************************************/
+
+#include "DebugMacros.h"
 #include <QDebug>
 
 #include "s60audiocaptureservice.h"
@@ -49,20 +51,28 @@
 
 S60AudioCaptureService::S60AudioCaptureService(QObject *parent):
     QMediaService(parent)
-{    
+{
+    DP0("S60AudioCaptureService::S60AudioCaptureService +++");
+
     m_session = new S60AudioCaptureSession(this);
     m_encoderControl = new S60AudioEncoderControl(m_session,this);
     m_recorderControl = new S60AudioMediaRecorderControl(m_session,this);
     m_endpointSelector = new S60AudioEndpointSelector(m_session,this); 
     m_containerControl = new S60AudioContainerControl(m_session, this);
+
+    DP0("S60AudioCaptureService::S60AudioCaptureService ---");
 }
 
 S60AudioCaptureService::~S60AudioCaptureService()
 {
+    DP0("S60AudioCaptureService::~S60AudioCaptureService +++");
+    DP0("S60AudioCaptureService::~S60AudioCaptureService ---");
 }
 
 QMediaControl *S60AudioCaptureService::requestControl(const char *name)
-{    
+{
+    DP0("S60AudioCaptureService::requestControl");
+
     if (qstrcmp(name,QMediaRecorderControl_iid) == 0)
         return m_recorderControl;
 
@@ -80,5 +90,9 @@ QMediaControl *S60AudioCaptureService::requestControl(const char *name)
 
 void S60AudioCaptureService::releaseControl(QMediaControl *control)
 {
+    DP0("S60AudioCaptureService::releaseControl +++");
+
     Q_UNUSED(control)
+
+    DP0("S60AudioCaptureService::releaseControl ---");
 }
diff --git a/plugins/multimedia/symbian/mmf/audiosource/s60audiocapturesession.cpp b/plugins/multimedia/symbian/mmf/audiosource/s60audiocapturesession.cpp
index d24facdcab..9dc58e11d1 100644
--- a/plugins/multimedia/symbian/mmf/audiosource/s60audiocapturesession.cpp
+++ b/plugins/multimedia/symbian/mmf/audiosource/s60audiocapturesession.cpp
@@ -39,6 +39,8 @@
 **
 ****************************************************************************/
 
+#include "DebugMacros.h"
+
 #include "s60audiocapturesession.h"
 #include <QtCore/qdebug.h>
 #include <QtCore/qurl.h>
@@ -69,6 +71,7 @@ S60AudioCaptureSession::S60AudioCaptureSession(QObject *parent):
     , m_error(QMediaRecorder::NoError)
     , m_isMuted(false)
 {
+   DP0("S60AudioCaptureSession::S60AudioCaptureSession +++");
 #ifdef AUDIOINPUT_ROUTING
     m_audioInput = NULL;
     m_setActiveEndPoint = FALSE;
@@ -76,10 +79,14 @@ S60AudioCaptureSession::S60AudioCaptureSession(QObject *parent):
 #endif //AUDIOINPUT_ROUTING
     TRAPD(err, initializeSessionL());
     setError(err);
+
+    DP0("S60AudioCaptureSession::S60AudioCaptureSession ---");
 }
 
 void S60AudioCaptureSession::initializeSessionL()
 {
+    DP0("S60AudioCaptureSession::initializeSessionL +++");
+
     m_recorderUtility = CMdaAudioRecorderUtility::NewL(*this, 0, EMdaPriorityNormal, EMdaPriorityPreferenceTimeAndQuality);
     updateAudioContainersL();
     populateAudioCodecsDataL();
@@ -90,10 +97,16 @@ void S60AudioCaptureSession::initializeSessionL()
     User::LeaveIfError(m_fsSession.Connect());
     m_captureState = EInitialized;
     emit stateChanged(m_captureState);
+
+    DP0("S60AudioCaptureSession::initializeSessionL ---");
 }
 
 void S60AudioCaptureSession::setError(TInt aError)
 {
+    DP0("S60AudioCaptureSession::setError +++");
+
+    DP1("S60AudioCaptureSession::setError:", aError);
+
     if (aError == KErrNone)
         return;
 
@@ -107,10 +120,16 @@ void S60AudioCaptureSession::setError(TInt aError)
     symbianError.append(QString::number(m_error));
     stop();
     emit error(recorderError, symbianError);
+
+    DP0("S60AudioCaptureSession::setError ---");
 }
 
 QMediaRecorder::Error S60AudioCaptureSession::fromSymbianErrorToMultimediaError(int error)
 {
+    DP0("S60AudioCaptureSession::fromSymbianErrorToMultimediaError +++");
+
+    DP1("S60AudioCaptureSession::fromSymbianErrorToMultimediaError:", error);
+
     switch(error) {
     case KErrNoMemory:
     case KErrNotFound:
@@ -132,58 +151,90 @@ QMediaRecorder::Error S60AudioCaptureSession::fromSymbianErrorToMultimediaError(
         return QMediaRecorder::FormatError;
     case KErrNone:
     default:
+        DP0("S60AudioCaptureSession::fromSymbianErrorToMultimediaError: ---");
         return QMediaRecorder::NoError;
     }
 }
 
 S60AudioCaptureSession::~S60AudioCaptureSession()
 {
+    DP0("S60AudioCaptureSession::~S60AudioCaptureSession +++");
     //stop the utility before deleting it
     stop();
     if (m_recorderUtility)
         delete m_recorderUtility;
     m_fsSession.Close();
+    DP0("S60AudioCaptureSession::~S60AudioCaptureSession ---");
 }
 
 QAudioFormat S60AudioCaptureSession::format() const
 {
+    DP0("S60AudioCaptureSession::format");
+
     return m_format;
 }
 
 bool S60AudioCaptureSession::setFormat(const QAudioFormat &format)
 {
+    DP0("S60AudioCaptureSession::setFormat +++");
+
     m_format = format;
+
+    DP0("S60AudioCaptureSession::setFormat ---");
+
     return true;
 }
 
 QStringList S60AudioCaptureSession::supportedAudioCodecs() const
 {
+    DP0("S60AudioCaptureSession::supportedAudioCodecs");
+
     return m_audioCodeclist.keys();
 }
 
 QStringList S60AudioCaptureSession::supportedAudioContainers() const
 {
+    DP0("S60AudioCaptureSession::supportedAudioContainers");
+
     return m_controllerIdMap.keys();
 }
 
 QString S60AudioCaptureSession::codecDescription(const QString &codecName)
 {
-    if (m_audioCodeclist.keys().contains(codecName))
+    DP0("S60AudioCaptureSession::codecDescription +++");
+
+    if (m_audioCodeclist.keys().contains(codecName)) {
+
+        DP0("S60AudioCaptureSession::codecDescription ---");
         return m_audioCodeclist.value(codecName).codecDescription;
-    else
+    }
+    else {
+        DP0("S60AudioCaptureSession::codecDescription ---");
+
         return QString();
+    }
 }
 
 QString S60AudioCaptureSession::audioContainerDescription(const QString &containerName)
 {
-    if (m_controllerIdMap.keys().contains(containerName))
+    DP0("S60AudioCaptureSession::audioContainerDescription +++");
+
+    if (m_controllerIdMap.keys().contains(containerName)) {
+        DP0("S60AudioCaptureSession::audioContainerDescription ---");
+
         return m_controllerIdMap.value(containerName).destinationFormatDescription;
-    else
+    }
+    else {
+        DP0("S60AudioCaptureSession::audioContainerDescription ---");
+
         return QString();
+    }
 }
 
 bool S60AudioCaptureSession::setAudioCodec(const QString &codecName)
 {
+    DP0("S60AudioCaptureSession::setAudioCodec");
+
     QStringList codecs = supportedAudioCodecs();
     if(codecs.contains(codecName)) {
         m_format.setCodec(codecName);
@@ -194,6 +245,8 @@ bool S60AudioCaptureSession::setAudioCodec(const QString &codecName)
 
 bool S60AudioCaptureSession::setAudioContainer(const QString &containerMimeType)
 {
+    DP0("S60AudioCaptureSession::setAudioContainer");
+
     QStringList containers = supportedAudioContainers();
     if(containers.contains(containerMimeType)) {
         m_container = containerMimeType;
@@ -204,21 +257,29 @@ bool S60AudioCaptureSession::setAudioContainer(const QString &containerMimeType)
 
 QString S60AudioCaptureSession::audioCodec() const
 {
+    DP0("S60AudioCaptureSession::audioCodec");
+
     return m_format.codec();
 }
 
 QString S60AudioCaptureSession::audioContainer() const
 {
+    DP0("S60AudioCaptureSession::audioContainer");
+
     return m_container;
 }
 
 QUrl S60AudioCaptureSession::outputLocation() const
 {
+    DP0("S60AudioCaptureSession::outputLocation");
+
     return m_sink;
 }
 
 bool S60AudioCaptureSession::setOutputLocation(const QUrl& sink)
 {
+    DP0("S60AudioCaptureSession::setOutputLocation");
+
     QString filename = QDir::toNativeSeparators(sink.toString());
     TPtrC16 path(reinterpret_cast<const TUint16*>(filename.utf16()));
     TRAPD(err, BaflUtils::EnsurePathExistsL(m_fsSession,path));
@@ -234,6 +295,8 @@ bool S60AudioCaptureSession::setOutputLocation(const QUrl& sink)
 
 qint64 S60AudioCaptureSession::position() const
 {
+    DP0("S60AudioCaptureSession::position");
+
     if ((m_captureState != ERecording) || !m_recorderUtility)
         return 0;
 
@@ -242,6 +305,8 @@ qint64 S60AudioCaptureSession::position() const
 
 void S60AudioCaptureSession::prepareSinkL()
 {
+    DP0("S60AudioCaptureSession::prepareSinkL +++");
+
     /* If m_outputLocation is null, set a default location */
     if (m_sink.isEmpty()) {
         QDir outputDir(QDir::rootPath());
@@ -268,10 +333,14 @@ void S60AudioCaptureSession::prepareSinkL()
 
     sink.append(m_controllerIdMap.value(m_container).fileExtension);
     m_sink.setUrl(sink);
+
+    DP0("S60AudioCaptureSession::prepareSinkL ---");
 }
 
 void S60AudioCaptureSession::record()
 {
+    DP0("S60AudioCaptureSession::record +++");
+
     if (!m_recorderUtility)
         return;
 
@@ -295,10 +364,14 @@ void S60AudioCaptureSession::record()
         m_captureState = ERecording;
         emit stateChanged(m_captureState);
     }
+
+    DP0("S60AudioCaptureSession::record ---");
 }
 
 void S60AudioCaptureSession::mute(bool muted)
 {
+    DP0("S60AudioCaptureSession::mute +++");
+
     if (!m_recorderUtility)
         return;
 
@@ -308,15 +381,21 @@ void S60AudioCaptureSession::mute(bool muted)
         m_recorderUtility->SetGain(m_recorderUtility->MaxGain());
 
     m_isMuted = muted;
+
+    DP0("S60AudioCaptureSession::mute ---");
 }
 
 bool S60AudioCaptureSession::muted()
 {
+    DP0("S60AudioCaptureSession::muted");
+
     return m_isMuted;
 }
 
 void S60AudioCaptureSession::setDefaultSettings()
 {
+    DP0("S60AudioCaptureSession::setDefaultSettings +++");
+
     // Setting AMR to default format if supported
     if (m_controllerIdMap.count() > 0) {
         if ( m_controllerIdMap.contains("audio/amr"))
@@ -334,10 +413,14 @@ void S60AudioCaptureSession::setDefaultSettings()
         }else
             m_format.setCodec(m_audioCodeclist.keys()[0]);
     }
+
+    DP0("S60AudioCaptureSession::setDefaultSettings ---");
 }
 
 void S60AudioCaptureSession::pause()
 {
+    DP0("S60AudioCaptureSession::pause +++");
+
     if (!m_recorderUtility)
         return;
 
@@ -345,10 +428,14 @@ void S60AudioCaptureSession::pause()
     m_recorderUtility->Stop();
     m_captureState = EPaused;
     emit stateChanged(m_captureState);
+
+    DP0("S60AudioCaptureSession::pause ---");
 }
 
 void S60AudioCaptureSession::stop()
 {
+    DP0("S60AudioCaptureSession::stop +++");
+
     if (!m_recorderUtility)
         return;
 
@@ -372,15 +459,21 @@ void S60AudioCaptureSession::stop()
 
 void S60AudioCaptureSession::initAudioInputs()
 {
+   DP0(" S60AudioCaptureSession::initAudioInputs +++");
+
     m_audioInputs[S60AudioCaptureSession::microPhone] = QString("Microphone associated with the currently active speaker.");
     m_audioInputs[S60AudioCaptureSession::voiceCall] = QString("Audio stream associated with the current phone call.");
     m_audioInputs[S60AudioCaptureSession::fmRadio] = QString("Audio of the currently tuned FM radio station.");
+
+   DP0(" S60AudioCaptureSession::initAudioInputs ---");
 }
 
 #endif //AUDIOINPUT_ROUTING
 
 void S60AudioCaptureSession::setActiveEndpoint(const QString& audioEndpoint)
 {
+  DP0(" S60AudioCaptureSession::setActiveEndpoint +++");
+
     if (!m_audioInputs.keys().contains(audioEndpoint))
         return;
 
@@ -390,15 +483,21 @@ void S60AudioCaptureSession::setActiveEndpoint(const QString& audioEndpoint)
         m_setActiveEndPoint = TRUE;
 #endif
        }
+
+  DP0(" S60AudioCaptureSession::setActiveEndpoint ---");
 }
 
 QList<QString> S60AudioCaptureSession::availableEndpoints() const
 {
+    DP0(" S60AudioCaptureSession::availableEndpoints");
+
     return m_audioInputs.keys();
 }
 
 QString S60AudioCaptureSession::endpointDescription(const QString& name) const
 {
+  DP0(" S60AudioCaptureSession::endpointDescription +++");
+
     if (m_audioInputs.keys().contains(name))
         return m_audioInputs.value(name);
     return QString();
@@ -406,6 +505,8 @@ QString S60AudioCaptureSession::endpointDescription(const QString& name) const
 
 QString S60AudioCaptureSession::activeEndpoint() const
 {
+   DP0(" S60AudioCaptureSession::activeEndpoint");
+
     QString inputSourceName = NULL;
 #ifdef AUDIOINPUT_ROUTING
     if (m_audioInput) {
@@ -418,6 +519,8 @@ QString S60AudioCaptureSession::activeEndpoint() const
 
 QString S60AudioCaptureSession::defaultEndpoint() const
 {
+   DP0(" S60AudioCaptureSession::defaultEndpoint");
+
 #ifdef AUDIOINPUT_ROUTING
     return QString(S60AudioCaptureSession::microPhone);
 #else
@@ -429,6 +532,8 @@ QString S60AudioCaptureSession::defaultEndpoint() const
 
 void S60AudioCaptureSession::doSetAudioInputL(const QString& name)
 {
+   DP0(" S60AudioCaptureSession::doSetAudioInputL +++");
+   DP1(" S60AudioCaptureSession::doSetAudioInputL:", name);
     TInt err(KErrNone);
 
     if (!m_recorderUtility)
@@ -458,11 +563,15 @@ void S60AudioCaptureSession::doSetAudioInputL(const QString& name)
             }
         }
         inputArray.Close();
+
+   DP0(" S60AudioCaptureSession::doSetAudioInputL ---");
 }
 
 
 QString S60AudioCaptureSession::qStringFromTAudioInputPreference(CAudioInput::TAudioInputPreference input) const
 {
+   DP0(" S60AudioCaptureSession::qStringFromTAudioInputPreference");
+
     if (input == CAudioInput::EVoiceCall)
         return S60AudioCaptureSession::voiceCall;
     else if (input == CAudioInput::EFMRadio)
@@ -476,6 +585,8 @@ QString S60AudioCaptureSession::qStringFromTAudioInputPreference(CAudioInput::TA
 void S60AudioCaptureSession::MoscoStateChangeEvent(CBase* aObject,
         TInt aPreviousState, TInt aCurrentState, TInt aErrorCode)
 {
+    DP0("S60AudioCaptureSession::MoscoStateChangeEvent +++");
+
     if (aErrorCode==KErrNone) {
 	    TRAPD(err, MoscoStateChangeEventL(aObject, aPreviousState, aCurrentState, NULL));
 	    setError(err);
@@ -483,11 +594,17 @@ void S60AudioCaptureSession::MoscoStateChangeEvent(CBase* aObject,
     else {
         setError(aErrorCode);
     }
+  DP1("S60AudioCaptureSession::MoscoStateChangeEvent, aErrorCode:", aErrorCode);
+  DP0("S60AudioCaptureSession::MoscoStateChangeEvent ---");
 }
 
 void S60AudioCaptureSession::MoscoStateChangeEventL(CBase* aObject,
         TInt aPreviousState, TInt aCurrentState, TInt aErrorCode)
 {
+    DP0("S60AudioCaptureSession::MoscoStateChangeEventL +++");
+
+    DP5("S60AudioCaptureSession::MoscoStateChangeEventL - aPreviousState:", aPreviousState,
+            "aCurrentState:", aCurrentState, "aErrorCode:", aErrorCode);
 	if (aObject != m_recorderUtility)
 	    return;
 
@@ -517,10 +634,14 @@ void S60AudioCaptureSession::MoscoStateChangeEventL(CBase* aObject,
             break;
         }
 		}
+
+  DP0("S60AudioCaptureSession::MoscoStateChangeEventL ---");
 }
 
 void S60AudioCaptureSession::updateAudioContainersL()
 {
+    DP0("S60AudioCaptureSession::updateAudioContainersL +++");
+
     CMMFControllerPluginSelectionParameters* pluginParameters =
     	CMMFControllerPluginSelectionParameters::NewLC();
 	CMMFFormatSelectionParameters* formatParameters =
@@ -569,12 +690,18 @@ void S60AudioCaptureSession::updateAudioContainersL()
 		}
 	}
 	CleanupStack::PopAndDestroy(4);//controllers, ids, formatParameters, pluginParameters
+
+  DP0("S60AudioCaptureSession::updateAudioContainersL ---");
 }
 
 void S60AudioCaptureSession::retrieveSupportedAudioSampleRatesL()
 {
-    if (!m_recorderUtility)
+    DP0("S60AudioCaptureSession::retrieveSupportedAudioSampleRatesL +++");
+
+    if (!m_recorderUtility) {
+        DP0("No RecorderUtility");
         return;
+    }
 
     m_supportedSampleRates.clear();
 
@@ -585,10 +712,14 @@ void S60AudioCaptureSession::retrieveSupportedAudioSampleRatesL()
         m_supportedSampleRates.append(supportedSampleRates[j]);
 
     CleanupStack::PopAndDestroy(&supportedSampleRates);
+
+    DP0("S60AudioCaptureSession::retrieveSupportedAudioSampleRatesL ---");
 }
 
 QList<int> S60AudioCaptureSession::supportedAudioSampleRates(const QAudioEncoderSettings &settings) const
 {
+    DP0("S60AudioCaptureSession::supportedAudioSampleRates +++");
+
     QList<int> supportedSampleRates;
 
     if (!settings.codec().isEmpty()) {
@@ -599,13 +730,20 @@ QList<int> S60AudioCaptureSession::supportedAudioSampleRates(const QAudioEncoder
     }else
         supportedSampleRates = m_supportedSampleRates;
 
+    DP0("S60AudioCaptureSession::supportedAudioSampleRates ---");
+
     return supportedSampleRates;
 }
 
 void S60AudioCaptureSession::populateAudioCodecsDataL()
 {
-    if (!m_recorderUtility)
+    DP0("S60AudioCaptureSession::populateAudioCodecsDataL +++");
+
+    if (!m_recorderUtility) {
+        DP0("No RecorderUtility");
+
         return;
+    }
 
     if (m_controllerIdMap.contains("audio/amr")) {
         CodecData data;
@@ -633,10 +771,13 @@ void S60AudioCaptureSession::populateAudioCodecsDataL()
 
     // default samplerates
     m_supportedSampleRates << 96000 << 88200 << 64000 << 48000 << 44100 << 32000 << 24000 << 22050 << 16000 << 12000 << 11025 << 8000;
+
+    DP0("S60AudioCaptureSession::populateAudioCodecsDataL ---");
 }
 
 void S60AudioCaptureSession::applyAudioSettingsL()
 {
+   DP0("S60AudioCaptureSession::applyAudioSettingsL +++");
 
     if (!m_recorderUtility)
         return;
@@ -699,10 +840,14 @@ void S60AudioCaptureSession::applyAudioSettingsL()
         }
         CleanupStack::PopAndDestroy(&supportedChannels);
     }
+
+    DP0("S60AudioCaptureSession::applyAudioSettingsL ---");
 }
 
 TFourCC S60AudioCaptureSession::determinePCMFormat()
 {
+    DP0("S60AudioCaptureSession::determinePCMFormat +++");
+
     TFourCC fourCC;
 
     if (m_format.sampleSize() == 8) {
@@ -742,5 +887,8 @@ TFourCC S60AudioCaptureSession::determinePCMFormat()
         }
         }
     }
+
+    DP0("S60AudioCaptureSession::determinePCMFormat ---");
+
     return fourCC;
 }
diff --git a/plugins/multimedia/symbian/mmf/audiosource/s60audiocontainercontrol.cpp b/plugins/multimedia/symbian/mmf/audiosource/s60audiocontainercontrol.cpp
index 9d7495d6fe..d6c2d5db2b 100644
--- a/plugins/multimedia/symbian/mmf/audiosource/s60audiocontainercontrol.cpp
+++ b/plugins/multimedia/symbian/mmf/audiosource/s60audiocontainercontrol.cpp
@@ -39,6 +39,8 @@
 **
 ****************************************************************************/
 
+#include "DebugMacros.h"
+
 #include "s60audiocontainercontrol.h"
 #include "s60audiocapturesession.h"
 #include <QtCore/qdebug.h>
@@ -46,31 +48,49 @@
 S60AudioContainerControl::S60AudioContainerControl(QObject *parent)
     : QMediaContainerControl(parent)
 {
+    DP0("S60AudioContainerControl::S60AudioContainerControl(QObject *parent) +++");
+
+    DP0("S60AudioContainerControl::S60AudioContainerControl(QObject *parent) ---");
+
 }
 
 S60AudioContainerControl::S60AudioContainerControl(QObject *session, QObject *parent)
    : QMediaContainerControl(parent)
 {
-    m_session = qobject_cast<S60AudioCaptureSession*>(session);   
+    DP0("S60AudioContainerControl::S60AudioContainerControl(QObject *session, QObject *parent) +++");
+
+    m_session = qobject_cast<S60AudioCaptureSession*>(session);
+
+    DP0("S60AudioContainerControl::S60AudioContainerControl(QObject *session, QObject *parent) ---");
 }
 
 QStringList S60AudioContainerControl::supportedContainers() const
 {
+    DP0("S60AudioContainerControl::supportedContainers");
+
     return m_session->supportedAudioContainers();
 }
 
 QString S60AudioContainerControl::containerMimeType() const
-{    
-    return m_session->audioContainer();    
+{
+    DP0("S60AudioContainerControl::containerMimeType");
+
+    return m_session->audioContainer();
 }
 
 void S60AudioContainerControl::setContainerMimeType(const QString &containerMimeType)
 {
+    DP0("S60AudioContainerControl::setContainerMimeType +++");
+
     m_session->setAudioContainer(containerMimeType);
+
+    DP0("S60AudioContainerControl::setContainerMimeType ---");
 }
 
 QString S60AudioContainerControl::containerDescription(const QString &containerMimeType) const
 {
+    DP0("S60AudioContainerControl::containerDescription");
+
     return m_session->audioContainerDescription(containerMimeType);
 }
 
diff --git a/plugins/multimedia/symbian/mmf/audiosource/s60audioencodercontrol.cpp b/plugins/multimedia/symbian/mmf/audiosource/s60audioencodercontrol.cpp
index c4ee7cdc6f..762c050ff8 100644
--- a/plugins/multimedia/symbian/mmf/audiosource/s60audioencodercontrol.cpp
+++ b/plugins/multimedia/symbian/mmf/audiosource/s60audioencodercontrol.cpp
@@ -39,6 +39,8 @@
 **
 ****************************************************************************/
 
+#include "DebugMacros.h"
+
 #include "s60audioencodercontrol.h"
 #include "s60audiocapturesession.h"
 
@@ -48,7 +50,9 @@
 
 S60AudioEncoderControl::S60AudioEncoderControl(QObject *session, QObject *parent)
     :QAudioEncoderControl(parent), m_quality(QtMultimediaKit::NormalQuality)
-{   
+{
+    DP0("S60AudioEncoderControl::S60AudioEncoderControl +++");
+
     m_session = qobject_cast<S60AudioCaptureSession*>(session);
     QAudioFormat fmt = m_session->format();
     // medium, 22050Hz mono S16
@@ -62,29 +66,42 @@ S60AudioEncoderControl::S60AudioEncoderControl(QObject *session, QObject *parent
     m_settings.setChannelCount(fmt.channels());
     m_settings.setCodec(fmt.codec());
     m_settings.setSampleRate(fmt.sampleRate());
+
+    DP0("S60AudioEncoderControl::S60AudioEncoderControl ---");
 }
 
 S60AudioEncoderControl::~S60AudioEncoderControl()
 {
+    DP0("S60AudioEncoderControl::~S60AudioEncoderControl +++");
+
+    DP0("S60AudioEncoderControl::~S60AudioEncoderControl ---");
 }
 
 QStringList S60AudioEncoderControl::supportedAudioCodecs() const
 {
+    DP0("S60AudioEncoderControl::supportedAudioCodecs");
+
     return m_session->supportedAudioCodecs();
 }
 
 QString S60AudioEncoderControl::codecDescription(const QString &codecName) const
 {
-	return m_session->codecDescription(codecName);    
+    DP0("S60AudioEncoderControl::codecDescription");
+
+    return m_session->codecDescription(codecName);
 }
 
 QtMultimediaKit::EncodingQuality S60AudioEncoderControl::quality() const
 {
+    DP0("S60AudioEncoderControl::quality");
+
     return m_quality;
 }
 
 void S60AudioEncoderControl::setQuality(QtMultimediaKit::EncodingQuality value, QAudioFormat &fmt)
 {
+    DP0("S60AudioEncoderControl::setQuality +++");
+
     switch (value) {
     case QtMultimediaKit::VeryLowQuality:
     case QtMultimediaKit::LowQuality:
@@ -112,10 +129,14 @@ void S60AudioEncoderControl::setQuality(QtMultimediaKit::EncodingQuality value,
     default:
         break;
     }
+
+    DP0("S60AudioEncoderControl::setQuality ---");
 }
 
 QStringList S60AudioEncoderControl::supportedEncodingOptions(const QString &codec) const
 {
+    DP0("S60AudioEncoderControl::supportedEncodingOptions");
+
     Q_UNUSED(codec)
     QStringList list;
     if (codec == "PCM") 
@@ -125,6 +146,8 @@ QStringList S60AudioEncoderControl::supportedEncodingOptions(const QString &code
 
 QVariant S60AudioEncoderControl::encodingOption(const QString &codec, const QString &name) const
 {
+    DP0("S60AudioEncoderControl::encodingOption");
+
     if (codec == "PCM") {
         QAudioFormat fmt = m_session->format();
         
@@ -144,7 +167,9 @@ QVariant S60AudioEncoderControl::encodingOption(const QString &codec, const QStr
 void S60AudioEncoderControl::setEncodingOption(
         const QString &codec, const QString &name, const QVariant &value)
 {
-    if (codec == "PCM") {        
+    DP0("S60AudioEncoderControl::setEncodingOption +++");
+
+    if (codec == "PCM") {
         QAudioFormat fmt = m_session->format();
 
         if(qstrcmp(name.toLocal8Bit().constData(), "quality") == 0) {
@@ -156,10 +181,14 @@ void S60AudioEncoderControl::setEncodingOption(
         }
         m_session->setFormat(fmt);
     }
+
+    DP0("S60AudioEncoderControl::setEncodingOption ---");
 }
 
 QList<int> S60AudioEncoderControl::supportedSampleRates(const QAudioEncoderSettings &settings, bool *continuous) const
 {
+    DP0("S60AudioEncoderControl::supportedSampleRates");
+
     if (continuous)
         *continuous = false;
     
@@ -168,11 +197,15 @@ QList<int> S60AudioEncoderControl::supportedSampleRates(const QAudioEncoderSetti
 
 QAudioEncoderSettings S60AudioEncoderControl::audioSettings() const
 {
+    DP0("S60AudioEncoderControl::audioSettings");
+
     return m_settings;
 }
 
 void S60AudioEncoderControl::setAudioSettings(const QAudioEncoderSettings &settings)
 {
+    DP0("S60AudioEncoderControl::setAudioSettings +++");
+
     QAudioFormat fmt = m_session->format();
     if (settings.encodingMode() == QtMultimediaKit::ConstantQualityEncoding) {
         fmt.setCodec(settings.codec());
@@ -196,4 +229,6 @@ void S60AudioEncoderControl::setAudioSettings(const QAudioEncoderSettings &setti
     }
     m_session->setFormat(fmt);
     m_settings = settings;
+
+    DP0("S60AudioEncoderControl::setAudioSettings ---");
 }
diff --git a/plugins/multimedia/symbian/mmf/audiosource/s60audioendpointselector.cpp b/plugins/multimedia/symbian/mmf/audiosource/s60audioendpointselector.cpp
index 351114d2b4..a2f9093164 100644
--- a/plugins/multimedia/symbian/mmf/audiosource/s60audioendpointselector.cpp
+++ b/plugins/multimedia/symbian/mmf/audiosource/s60audioendpointselector.cpp
@@ -39,6 +39,8 @@
 **
 ****************************************************************************/
 
+#include "DebugMacros.h"
+
 #include "s60audiocapturesession.h"
 #include "s60audioendpointselector.h"
 
@@ -46,38 +48,53 @@
 
 S60AudioEndpointSelector::S60AudioEndpointSelector(QObject *session, QObject *parent)
     :QAudioEndpointSelector(parent)
-{    
+{
+    DP0("S60AudioEndpointSelector::S60AudioEndpointSelector +++");
     m_session = qobject_cast<S60AudioCaptureSession*>(session); 
 
     connect(m_session, SIGNAL(activeEndpointChanged(const QString &)), this, SIGNAL(activeEndpointChanged(const QString &)));
+
+    DP0("S60AudioEndpointSelector::S60AudioEndpointSelector ---");
 }
 
 S60AudioEndpointSelector::~S60AudioEndpointSelector()
 {
+    DP0("S60AudioEndpointSelector::~S60AudioEndpointSelector +++");
+
+    DP0("S60AudioEndpointSelector::~S60AudioEndpointSelector ---");
 }
 
 QList<QString> S60AudioEndpointSelector::availableEndpoints() const
 {
+    DP0("S60AudioEndpointSelector::availableEndpoints");
+
     return m_session->availableEndpoints();
 }
 
 QString S60AudioEndpointSelector::endpointDescription(const QString& name) const
 {
+    DP0("S60AudioEndpointSelector::endpointDescription");
 
     return m_session->endpointDescription(name);
 }
 
 QString S60AudioEndpointSelector::defaultEndpoint() const
 {
+    DP0("S60AudioEndpointSelector::defaultEndpoint");
+
     return m_session->defaultEndpoint();
 }
 
 QString S60AudioEndpointSelector::activeEndpoint() const
 {
+    DP0("S60AudioEndpointSelector::activeEndpoint");
+
     return m_session->activeEndpoint();
 }
 
 void S60AudioEndpointSelector::setActiveEndpoint(const QString& name)
 {
+   DP0("S60AudioEndpointSelector::setActiveEndpoint +++");
     m_session->setActiveEndpoint(name);
+   DP0("S60AudioEndpointSelector::setActiveEndpoint ---");
 }
diff --git a/plugins/multimedia/symbian/mmf/audiosource/s60audiomediarecordercontrol.cpp b/plugins/multimedia/symbian/mmf/audiosource/s60audiomediarecordercontrol.cpp
index 6fd088a258..5d80033b3f 100644
--- a/plugins/multimedia/symbian/mmf/audiosource/s60audiomediarecordercontrol.cpp
+++ b/plugins/multimedia/symbian/mmf/audiosource/s60audiomediarecordercontrol.cpp
@@ -39,6 +39,8 @@
 **
 ****************************************************************************/
 
+#include "DebugMacros.h"
+
 #include "s60audiomediarecordercontrol.h"
 #include "s60audiocapturesession.h"
 
@@ -47,28 +49,41 @@
 S60AudioMediaRecorderControl::S60AudioMediaRecorderControl(QObject *session, QObject *parent)
     :QMediaRecorderControl(parent), m_state(QMediaRecorder::StoppedState)
 {
+    DP0("S60AudioMediaRecorderControl::S60AudioMediaRecorderControl +++");
+
     m_session = qobject_cast<S60AudioCaptureSession*>(session);
     connect(m_session, SIGNAL(positionChanged(qint64)), this, SIGNAL(durationChanged(qint64)));
     connect(m_session, SIGNAL(stateChanged(S60AudioCaptureSession::TAudioCaptureState)), this, SLOT(updateState(S60AudioCaptureSession::TAudioCaptureState)));
     connect(m_session,SIGNAL(error(int,const QString &)),this,SIGNAL(error(int,const QString &)));
+
+    DP0("S60AudioMediaRecorderControl::S60AudioMediaRecorderControl ---");
 }
 
 S60AudioMediaRecorderControl::~S60AudioMediaRecorderControl()
 {
+    DP0("S60AudioMediaRecorderControl::~S60AudioMediaRecorderControl +++");
+
+    DP0("S60AudioMediaRecorderControl::~S60AudioMediaRecorderControl - - ");
 }
 
 QUrl S60AudioMediaRecorderControl::outputLocation() const
 {
+    DP0("S60AudioMediaRecorderControl::outputLocation");
+
     return m_session->outputLocation();
 }
 
 bool S60AudioMediaRecorderControl::setOutputLocation(const QUrl& sink)
 {
+    DP0("S60AudioMediaRecorderControl::setOutputLocation");
+
     return m_session->setOutputLocation(sink);
 }
 
 QMediaRecorder::State S60AudioMediaRecorderControl::convertState(S60AudioCaptureSession::TAudioCaptureState aState) const
 {
+    DP0("S60AudioMediaRecorderControl::convertState +++");
+
     QMediaRecorder::State state = QMediaRecorder::StoppedState;;
     switch (aState) {
     case S60AudioCaptureSession::ERecording:
@@ -84,49 +99,82 @@ QMediaRecorder::State S60AudioMediaRecorderControl::convertState(S60AudioCapture
         state = QMediaRecorder::StoppedState;
         break;
     }
+
+    DP1("S60AudioMediaRecorderControl::convertState:", state);
+
+    DP0("S60AudioMediaRecorderControl::convertState ---");
+
     return state;
 }
 
 void S60AudioMediaRecorderControl::updateState(S60AudioCaptureSession::TAudioCaptureState aState)
 {
+    DP0("S60AudioMediaRecorderControl::updateState +++");
+
     QMediaRecorder::State newState = convertState(aState);
     if (m_state != newState) {
         m_state = newState;
         emit stateChanged(m_state);
     }
+
+    DP0("S60AudioMediaRecorderControl::updateState ---");
 }
 
 QMediaRecorder::State S60AudioMediaRecorderControl::state() const
 {
+    DP0("S60AudioMediaRecorderControl::state");
+
     return m_state;
 }
 
 qint64 S60AudioMediaRecorderControl::duration() const
 {
+  //  DP0("S60AudioMediaRecorderControl::duration +++");
+
     return m_session->position();
 }
 
 void S60AudioMediaRecorderControl::record()
 {
+    DP0("S60AudioMediaRecorderControl::record +++");
+
     m_session->record();
+
+    DP0("S60AudioMediaRecorderControl::record ---");
 }
 
 void S60AudioMediaRecorderControl::pause()
 {
+    DP0("S60AudioMediaRecorderControl::pause +++");
+
     m_session->pause();
+
+    DP0("S60AudioMediaRecorderControl::pause ---");
 }
 
 void S60AudioMediaRecorderControl::stop()
 {
+    DP0("S60AudioMediaRecorderControl::stop +++");
+
     m_session->stop();
+
+    DP0("S60AudioMediaRecorderControl::stop ---");
 }
 
 bool S60AudioMediaRecorderControl::isMuted() const
 {
+    DP0("S60AudioMediaRecorderControl::isMuted");
+
     return m_session->muted();
 }
 
 void S60AudioMediaRecorderControl::setMuted(bool muted)
 {
+    DP0("S60AudioMediaRecorderControl::setMuted +++");
+
+    DP1("S60AudioMediaRecorderControl::setMuted:", muted);
+
     m_session->mute(muted);
+
+    DP0("S60AudioMediaRecorderControl::setMuted +++");
 }
diff --git a/plugins/multimedia/symbian/mmf/inc/DebugMacros.h b/plugins/multimedia/symbian/mmf/inc/DebugMacros.h
new file mode 100644
index 0000000000..c527ae9d26
--- /dev/null
+++ b/plugins/multimedia/symbian/mmf/inc/DebugMacros.h
@@ -0,0 +1,42 @@
+/*
+* Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:  Debug Macros used by AdvancedAudioController
+*
+*/
+
+#include <QtCore/qdebug.h>
+
+#ifndef __DEBUGMACROS_H__
+#define __DEBUGMACROS_H__
+
+// MACROS
+#ifdef _DEBUG
+#define DP0(string)                                 qDebug()<<string
+#define DP1(string,arg1)                            qDebug()<<string<<arg1
+#define DP2(string,arg1,arg2)                       qDebug()<<string<<arg1<<arg2
+#define DP3(string,arg1,arg2,arg3)                  qDebug()<<string<<arg1<<arg2<<arg3
+#define DP4(string,arg1,arg2,arg3,arg4)             qDebug()<<string<<arg1<<arg2<<arg3<<arg4
+#define DP5(string,arg1,arg2,arg3,arg4,arg5)        qDebug()<<string<<arg1<<arg2<<arg3<<arg4<<arg5
+#define DP6(string,arg1,arg2,arg3,arg4,arg5,arg6)   qDebug()<<string<<arg1<<arg2<<arg3<<arg4<<arg5<<arg6
+#else
+#define DP0(string)
+#define DP1(string,arg1)
+#define DP2(string,arg1,arg2)
+#define DP3(string,arg1,arg2,arg3)
+#define DP4(string,arg1,arg2,arg3,arg4)
+#define DP5(string,arg1,arg2,arg3,arg4,arg5)
+#define DP6(string,arg1,arg2,arg3,arg4,arg5,arg6)
+#endif
+
+#endif //__DEBUGMACROS_H__
diff --git a/plugins/multimedia/symbian/mmf/mediaplayer/s60audioplayersession.cpp b/plugins/multimedia/symbian/mmf/mediaplayer/s60audioplayersession.cpp
index 02bb644619..48cb76272d 100644
--- a/plugins/multimedia/symbian/mmf/mediaplayer/s60audioplayersession.cpp
+++ b/plugins/multimedia/symbian/mmf/mediaplayer/s60audioplayersession.cpp
@@ -39,24 +39,46 @@
 **
 ****************************************************************************/
 
+#include "DebugMacros.h"
+
 #include "s60audioplayersession.h"
 #include <QtCore/qdebug.h>
 #include <QtCore/qvariant.h>
 
+/*!
+    Constructs the CMdaAudioPlayerUtility object with given \a parent QObject.
+
+    And Registers for Audio Loading Notifications.
+
+*/
+
 S60AudioPlayerSession::S60AudioPlayerSession(QObject *parent)
     : S60MediaPlayerSession(parent)
     , m_player(0)
     , m_audioEndpoint("Default")
 {
+    DP0("S60AudioPlayerSession::S60AudioPlayerSession +++");
+
 #ifdef HAS_AUDIOROUTING
     m_audioOutput = 0;
 #endif //HAS_AUDIOROUTING    
     QT_TRAP_THROWING(m_player = CAudioPlayer::NewL(*this, 0, EMdaPriorityPreferenceNone));
     m_player->RegisterForAudioLoadingNotification(*this);
+
+    DP0("S60AudioPlayerSession::S60AudioPlayerSession ---");
 }
 
+
+/*!
+   Destroys the CMdaAudioPlayerUtility object.
+
+    And Unregister the observer.
+
+*/
+
 S60AudioPlayerSession::~S60AudioPlayerSession()
 {
+    DP0("S60AudioPlayerSession::~S60AudioPlayerSession +++");
 #ifdef HAS_AUDIOROUTING
     if (m_audioOutput)
         m_audioOutput->UnregisterObserver(*this);
@@ -64,10 +86,20 @@ S60AudioPlayerSession::~S60AudioPlayerSession()
 #endif
     m_player->Close();
     delete m_player;
+
+    DP0("S60AudioPlayerSession::~S60AudioPlayerSession ---");
 }
 
+/*!
+
+   Opens the a file from \a path.
+
+*/
+
 void S60AudioPlayerSession::doLoadL(const TDesC &path)
 {
+    DP0("S60AudioPlayerSession::doLoadL +++");
+
 #ifdef HAS_AUDIOROUTING
     // m_audioOutput needs to be reinitialized after MapcInitComplete
     if (m_audioOutput)
@@ -76,41 +108,97 @@ void S60AudioPlayerSession::doLoadL(const TDesC &path)
     m_audioOutput = NULL;
 #endif //HAS_AUDIOROUTING
     m_player->OpenFileL(path);
+
+    DP0("S60AudioPlayerSession::doLoadL ---");
 }
 
+/*!
+
+  Returns the duration of the audio sample in microseconds.
+
+*/
+
 qint64 S60AudioPlayerSession::doGetDurationL() const
 {
+ //  DP0("S60AudioPlayerSession::doGetDurationL");
+
     return m_player->Duration().Int64() / qint64(1000);
 }
 
+/*!
+ *  Returns the current playback position in microseconds from the start of the clip.
+
+*/
+
 qint64 S60AudioPlayerSession::doGetPositionL() const
 {
+  //  DP0("S60AudioPlayerSession::doGetPositionL");
+
     TTimeIntervalMicroSeconds ms = 0;
     m_player->GetPosition(ms);
     return ms.Int64() / qint64(1000);
 }
 
+/*!
+   Returns TRUE if Video available or else FALSE
+ */
+
 bool S60AudioPlayerSession::isVideoAvailable()
 {
+    DP0("S60AudioPlayerSession::isVideoAvailable");
+
     return false;
 }
+
+/*!
+   Returns TRUE if Audio available or else FALSE
+ */
 bool S60AudioPlayerSession::isAudioAvailable()
 {
+    DP0("S60AudioPlayerSession::isAudioAvailable");
+
     return true; // this is a bit happy scenario, but we do emit error that we can't play
 }
 
+/*!
+   Starts loading Media and sets media status to Buffering.
+
+ */
+
 void S60AudioPlayerSession::MaloLoadingStarted()
 {
+    DP0("S60AudioPlayerSession::MaloLoadingStarted +++");
+
     buffering();
+
+    DP0("S60AudioPlayerSession::MaloLoadingStarted ---");
 }
 
+
+/*!
+   Indicates loading Media is completed.
+
+   And sets media status to Buffered.
+
+ */
+
 void S60AudioPlayerSession::MaloLoadingComplete()
 {
+    DP0("S60AudioPlayerSession::MaloLoadingComplete +++");
+
     buffered();
+
+    DP0("S60AudioPlayerSession::MaloLoadingComplete ---");
 }
 
+/*!
+    Start or resume playing the current source.
+*/
+
 void S60AudioPlayerSession::doPlay()
 {
+    DP0("S60AudioPlayerSession::doPlay +++");
+
     // For some reason loading progress callback are not called on emulator
     // Same is the case with hardware. Will be fixed as part of QTMOBILITY-782.
         
@@ -121,20 +209,48 @@ void S60AudioPlayerSession::doPlay()
     //#ifdef __WINSCW__
         buffered();
     //#endif
+
+    DP0("S60AudioPlayerSession::doPlay ---");
 }
 
+
+/*!
+    Pause playing the current source.
+*/
+
+
 void S60AudioPlayerSession::doPauseL()
 {
+    DP0("S60AudioPlayerSession::doPauseL +++");
+
     m_player->Pause();
+
+    DP0("S60AudioPlayerSession::doPauseL ---");
 }
 
+
+/*!
+
+    Stop playing, and reset the play position to the beginning.
+*/
+
 void S60AudioPlayerSession::doStop()
 {
+    DP0("S60AudioPlayerSession::doStop +++");
+
     m_player->Stop();
+
+    DP0("S60AudioPlayerSession::doStop ---");
 }
 
+/*!
+    Closes the current audio clip (allowing another clip to be opened)
+*/
+
 void S60AudioPlayerSession::doClose()
 {
+    DP0("S60AudioPlayerSession::doClose +++");
+
 #ifdef HAS_AUDIOROUTING
     if (m_audioOutput) {
         m_audioOutput->UnregisterObserver(*this);
@@ -143,20 +259,50 @@ void S60AudioPlayerSession::doClose()
     }
 #endif
     m_player->Close();
+
+    DP0("S60AudioPlayerSession::doClose ---");
 }
 
+/*!
+
+    Changes the current playback volume to specified \a value.
+*/
+
 void S60AudioPlayerSession::doSetVolumeL(int volume)
 {
+    DP0("S60AudioPlayerSession::doSetVolumeL +++");
+
+    DP1("S60AudioPlayerSession::doSetVolumeL, Volume:", volume);
+
     m_player->SetVolume(volume * m_player->MaxVolume() / 100);
+
+    DP0("S60AudioPlayerSession::doSetVolumeL ---");
 }
 
+/*!
+    Sets the current playback position to \a microSeconds from the start of the clip.
+*/
+
 void S60AudioPlayerSession::doSetPositionL(qint64 microSeconds)
 {
+    DP0("S60AudioPlayerSession::doSetPositionL +++");
+
+    DP1("S60AudioPlayerSession::doSetPositionL, Microseconds:", microSeconds);
+
     m_player->SetPosition(TTimeIntervalMicroSeconds(microSeconds));
+
+    DP0("S60AudioPlayerSession::doSetPositionL ---");
 }
 
+/*!
+
+    Updates meta data entries in the current audio clip.
+*/
+
 void S60AudioPlayerSession::updateMetaDataEntriesL()
 {
+    DP0("S60AudioPlayerSession::updateMetaDataEntriesL +++");
+
     metaDataEntries().clear();
     int numberOfMetaDataEntries = 0;
 
@@ -170,11 +316,18 @@ void S60AudioPlayerSession::updateMetaDataEntriesL()
         delete entry;
     }
     emit metaDataChanged();
+
+    DP0("S60AudioPlayerSession::updateMetaDataEntriesL ---");
 }
 
+/*!
+    Sets the playbackRate with \a rate.
+*/
 
 void S60AudioPlayerSession::setPlaybackRate(qreal rate)
 {
+    DP0("S60AudioPlayerSession::setPlaybackRate +++");
+    DP1("S60AudioPlayerSession::setPlaybackRate, Rate:", rate);
     /*Since AudioPlayerUtility doesn't support set playback rate hence
      * setPlaybackRate emits playbackRateChanged signal for 1.0x ie normal playback.
      * For all other playBackRates it sets and emits error signal.
@@ -186,21 +339,46 @@ void S60AudioPlayerSession::setPlaybackRate(qreal rate)
         int err = KErrNotSupported;
         setAndEmitError(err);
     }
+    DP0("S60AudioPlayerSession::setPlaybackRate ---");
 }
 
+/*!
+
+    Returns the percentage of the audio clip loaded.
+*/
+
 int S60AudioPlayerSession::doGetBufferStatusL() const
 {
+    DP0("S60AudioPlayerSession::doGetBufferStatusL +++");
+
     int progress = 0;
     m_player->GetAudioLoadingProgressL(progress);
+
+    DP0("S60AudioPlayerSession::doGetBufferStatusL ---");
+
     return progress;
 }
 
+/*!
+
+    Defines required client behaviour when an attempt to open and initialise an audio sample has completed,
+    successfully or not.
+
+    \a aError if KErrNone the sample is ready to play or else system wide error.
+
+    \a aDuration The duration of the audio sample.
+*/
+
 #ifdef S60_DRM_SUPPORTED
 void S60AudioPlayerSession::MdapcInitComplete(TInt aError, const TTimeIntervalMicroSeconds& aDuration)
 #else
 void S60AudioPlayerSession::MapcInitComplete(TInt aError, const TTimeIntervalMicroSeconds& aDuration)
 #endif
 {
+    DP0("S60AudioPlayerSession::MdapcInitComplete +++");
+
+    DP1("S60AudioPlayerSession::MdapcInitComplete - aError", aError);
+
     Q_UNUSED(aDuration);
     setError(aError);
     if (KErrNone != aError)
@@ -215,27 +393,62 @@ void S60AudioPlayerSession::MapcInitComplete(TInt aError, const TTimeIntervalMic
 #endif //HAS_AUDIOROUTING
     if (KErrNone == aError)
         loaded();
+
+    DP0("S60AudioPlayerSession::MdapcInitComplete ---");
 }
 
+/*!
+    Defines required client behaviour when an attempt to playback an audio sample has completed,
+    successfully or not.
+
+    \a aError if KErrNone the playback completed or else system wide error.
+*/
+
+
 #ifdef S60_DRM_SUPPORTED
 void S60AudioPlayerSession::MdapcPlayComplete(TInt aError)
 #else
 void S60AudioPlayerSession::MapcPlayComplete(TInt aError)
 #endif
 {
+    DP0("S60AudioPlayerSession::MdapcPlayComplete +++");
+
+    DP1("S60AudioPlayerSession::MdapcPlayComplete", aError);
+
     if (KErrNone == aError)
         endOfMedia();
     else
         setError(aError);
+
+    DP0("S60AudioPlayerSession::MdapcPlayComplete ---");
 }
 
+/*!
+    Defiens which Audio End point to use.
+
+    \a audioEndpoint audioEndpoint name.
+*/
+
 void S60AudioPlayerSession::doSetAudioEndpoint(const QString& audioEndpoint)
 {
+    DP0("S60AudioPlayerSession::doSetAudioEndpoint +++");
+
+    DP1("S60AudioPlayerSession::doSetAudioEndpoint - ", audioEndpoint);
+
     m_audioEndpoint = audioEndpoint;
+
+    DP0("S60AudioPlayerSession::doSetAudioEndpoint ---");
 }
 
+/*!
+
+    Returns audioEndpoint name.
+*/
+
 QString S60AudioPlayerSession::activeEndpoint() const
 {
+    DP0("S60AudioPlayerSession::activeEndpoint +++");
+
     QString outputName = QString("Default");
 #ifdef HAS_AUDIOROUTING
     if (m_audioOutput) {
@@ -243,11 +456,20 @@ QString S60AudioPlayerSession::activeEndpoint() const
         outputName = qStringFromTAudioOutputPreference(output);
     }
 #endif
+    DP1("S60AudioPlayerSession::activeEndpoint is :", outputName);
+
+    DP0("S60AudioPlayerSession::activeEndpoint ---");
     return outputName;
 }
 
+/*!
+ *  Returns default Audio End point in use.
+*/
+
 QString S60AudioPlayerSession::defaultEndpoint() const
 {
+    DP0("S60AudioPlayerSession::defaultEndpoint +++");
+
     QString outputName = QString("Default");
 #ifdef HAS_AUDIOROUTING
     if (m_audioOutput) {
@@ -255,11 +477,22 @@ QString S60AudioPlayerSession::defaultEndpoint() const
         outputName = qStringFromTAudioOutputPreference(output);
     }
 #endif
+    DP1("S60AudioPlayerSession::defaultEndpoint is :", outputName);
+
+    DP0("S60AudioPlayerSession::defaultEndpoint ---");
     return outputName;
 }
 
+/*!
+   Sets active end \a name as an Audio End point.
+*/
+
 void S60AudioPlayerSession::setActiveEndpoint(const QString& name)
 {
+    DP0("S60AudioPlayerSession::setActiveEndpoint +++");
+
+    DP1("S60AudioPlayerSession::setActiveEndpoint - ", name);
+
 #ifdef HAS_AUDIOROUTING
     CAudioOutput::TAudioOutputPreference output = CAudioOutput::ENoPreference;
 
@@ -279,18 +512,44 @@ void S60AudioPlayerSession::setActiveEndpoint(const QString& name)
         setError(err);
     }
 #endif
+
+    DP0("S60AudioPlayerSession::setActiveEndpoint ---");
 }
+
+/*!
+    The default audio ouput has been changed.
+
+    \a aAudioOutput Audio Output object.
+
+    \a aNewDefault is CAudioOutput::TAudioOutputPreference.
+*/
+
+
 #ifdef HAS_AUDIOROUTING
 void S60AudioPlayerSession::DefaultAudioOutputChanged(CAudioOutput& aAudioOutput,
                                         CAudioOutput::TAudioOutputPreference aNewDefault)
 {
+    DP0("S60AudioPlayerSession::DefaultAudioOutputChanged +++");
+
     // Emit already implemented in setActiveEndpoint function
     Q_UNUSED(aAudioOutput)
     Q_UNUSED(aNewDefault)
+
+    DP0("S60AudioPlayerSession::DefaultAudioOutputChanged ---");
 }
 
+
+/*!
+    Converts CAudioOutput::TAudioOutputPreference enum to QString.
+
+    \a output is  CAudioOutput::TAudioOutputPreference enum value.
+
+*/
+
 QString S60AudioPlayerSession::qStringFromTAudioOutputPreference(CAudioOutput::TAudioOutputPreference output) const
 {
+    DP0("S60AudioPlayerSession::qStringFromTAudioOutputPreference");
+
     if (output == CAudioOutput::ENoPreference)
         return QString("Default");
     else if (output == CAudioOutput::EAll)
@@ -305,8 +564,14 @@ QString S60AudioPlayerSession::qStringFromTAudioOutputPreference(CAudioOutput::T
 }
 #endif
 
+/*!
+    Return True if its Seekable or else False.
+*/
+
 bool S60AudioPlayerSession::getIsSeekable() const
 {
+    DP0("S60AudioPlayerSession::getIsSeekable");
+
     return ETrue;
 }
 
diff --git a/plugins/multimedia/symbian/mmf/mediaplayer/s60mediametadataprovider.cpp b/plugins/multimedia/symbian/mmf/mediaplayer/s60mediametadataprovider.cpp
index f7b8e870a1..85bfe65a3d 100644
--- a/plugins/multimedia/symbian/mmf/mediaplayer/s60mediametadataprovider.cpp
+++ b/plugins/multimedia/symbian/mmf/mediaplayer/s60mediametadataprovider.cpp
@@ -39,59 +39,106 @@
 **
 ****************************************************************************/
 
+#include "DebugMacros.h"
+
 #include "s60mediametadataprovider.h"
 #include "s60mediaplayercontrol.h"
 #include "s60mediaplayersession.h"
 #include <QtCore/qdebug.h>
 
+/*!
+ * Typecasts the \a control object to S60MediaPlayerControl object.
+*/
 S60MediaMetaDataProvider::S60MediaMetaDataProvider(QObject *control, QObject *parent)
     : QMetaDataReaderControl(parent)
     , m_control(NULL)
 {
+    DP0("S60MediaMetaDataProvider::S60MediaMetaDataProvider +++");
+
     m_control = qobject_cast<S60MediaPlayerControl*>(control);
+
+    DP0("S60MediaMetaDataProvider::S60MediaMetaDataProvider ---");
 }
 
+/*!
+ * Destructor
+*/
+
 S60MediaMetaDataProvider::~S60MediaMetaDataProvider()
 {
+    DP0("S60MediaMetaDataProvider::~S60MediaMetaDataProvider +++");
+    DP0("S60MediaMetaDataProvider::~S60MediaMetaDataProvider ---");
 }
 
+/*!
+ * Returns TRUE if MetaData is Available or else FALSE.
+*/
+
 bool S60MediaMetaDataProvider::isMetaDataAvailable() const
 {
+    DP0("S60MediaMetaDataProvider::isMetaDataAvailable");
+
     if (m_control->session())
        return m_control->session()->isMetadataAvailable();
     return false;
 }
 
+/*!
+ * Always returns FLASE.
+*/
 bool S60MediaMetaDataProvider::isWritable() const
 {
+    DP0("S60MediaMetaDataProvider::isWritable");
+
     return false;
 }
 
+/*!
+ * Returns when \a key meta data is found in metaData.
+*/
+
 QVariant S60MediaMetaDataProvider::metaData(QtMultimediaKit::MetaData key) const
 {
+    DP0("S60MediaMetaDataProvider::metaData");
 
     if (m_control->session())
         return m_control->session()->metaData(key);
     return QVariant();
 }
 
+/*!
+ * Returns available metaData.
+*/
+
 QList<QtMultimediaKit::MetaData> S60MediaMetaDataProvider::availableMetaData() const
 {
+    DP0("S60MediaMetaDataProvider::availableMetaData");
+
     if (m_control->session())
         return m_control->session()->availableMetaData();
     return QList<QtMultimediaKit::MetaData>();
 }
 
+/*!
+ * Returns when \a key string is found in extended metaData.
+*/
+
 QVariant S60MediaMetaDataProvider::extendedMetaData(const QString &key) const
 {
+    DP0("S60MediaMetaDataProvider::extendedMetaData");
 
     if (m_control->session())
         return m_control->session()->metaData(key);
     return QVariant();
 }
 
+/*!
+ * Returns available Extended MetaData.
+*/
+
 QStringList S60MediaMetaDataProvider::availableExtendedMetaData() const
 {
+    DP0("S60MediaMetaDataProvider::availableExtendedMetaData");
 
     if (m_control->session())
         return m_control->session()->availableExtendedMetaData();
diff --git a/plugins/multimedia/symbian/mmf/mediaplayer/s60mediaplayeraudioendpointselector.cpp b/plugins/multimedia/symbian/mmf/mediaplayer/s60mediaplayeraudioendpointselector.cpp
index 4841fa5bf3..3ad64ef3b2 100644
--- a/plugins/multimedia/symbian/mmf/mediaplayer/s60mediaplayeraudioendpointselector.cpp
+++ b/plugins/multimedia/symbian/mmf/mediaplayer/s60mediaplayeraudioendpointselector.cpp
@@ -39,6 +39,8 @@
 **
 ****************************************************************************/
 
+#include "DebugMacros.h"
+
 #include "s60mediaplayercontrol.h"
 #include "s60mediaplayersession.h"
 #include "s60mediaplayeraudioendpointselector.h"
@@ -46,29 +48,55 @@
 #include <QtGui/QIcon>
 #include <QtCore/QDebug>
 
+/*!
+    Constructs a new audio endpoint selector with the given \a parent.
+*/
+
 S60MediaPlayerAudioEndpointSelector::S60MediaPlayerAudioEndpointSelector(QObject *control, QObject *parent)
    :QAudioEndpointSelector(parent)
     , m_control(0)
 {
+    DP0("S60MediaPlayerAudioEndpointSelector::S60MediaPlayerAudioEndpointSelector +++");
+
     m_control = qobject_cast<S60MediaPlayerControl*>(control);
     m_audioEndpointNames.append("Default");
     m_audioEndpointNames.append("All");
     m_audioEndpointNames.append("None");
     m_audioEndpointNames.append("Earphone");
     m_audioEndpointNames.append("Speaker");
+
+    DP0("S60MediaPlayerAudioEndpointSelector::S60MediaPlayerAudioEndpointSelector ---");
 }
 
+/*!
+    Destroys an audio endpoint selector.
+*/
+
 S60MediaPlayerAudioEndpointSelector::~S60MediaPlayerAudioEndpointSelector()
 {
+    DP0("S60MediaPlayerAudioEndpointSelector::~S60MediaPlayerAudioEndpointSelector +++");
+    DP0("S60MediaPlayerAudioEndpointSelector::~S60MediaPlayerAudioEndpointSelector ---");
 }
 
+/*!
+    \return a list of available audio endpoints.
+*/
+
 QList<QString> S60MediaPlayerAudioEndpointSelector::availableEndpoints() const
 {
+    DP0("S60MediaPlayerAudioEndpointSelector::availableEndpoints");
+
     return m_audioEndpointNames;
 }
 
+/*!
+    \return the description of the endpoint name.
+*/
+
 QString S60MediaPlayerAudioEndpointSelector::endpointDescription(const QString& name) const
 {
+    DP0("S60MediaPlayerAudioEndpointSelector::endpointDescription");
+
     if (name == QString("Default")) //ENoPreference
         return QString("Used to indicate that the playing audio can be routed to"
             "any speaker. This is the default value for audio.");
@@ -88,24 +116,56 @@ QString S60MediaPlayerAudioEndpointSelector::endpointDescription(const QString&
     return QString();
 }
 
+/*!
+    \return the name of the currently selected audio endpoint.
+*/
+
 QString S60MediaPlayerAudioEndpointSelector::activeEndpoint() const
 {
-    if (m_control->session())
+    DP0("S60MediaPlayerAudioEndpointSelector::activeEndpoint");
+
+    if (m_control->session()) {
+        DP1("S60MediaPlayerAudioEndpointSelector::activeEndpoint - ",
+                m_control->session()->activeEndpoint());
         return m_control->session()->activeEndpoint();
-    else
+    }
+    else {
+        DP1("S60MediaPlayerAudioEndpointSelector::activeEndpoint - ",
+                m_control->mediaControlSettings().audioEndpoint());
         return m_control->mediaControlSettings().audioEndpoint();
+    }
 }
 
+/*!
+    \return the name of the default audio endpoint.
+*/
+
 QString S60MediaPlayerAudioEndpointSelector::defaultEndpoint() const
 {
-    if (m_control->session())
+    DP0("S60MediaPlayerAudioEndpointSelector::defaultEndpoint");
+
+    if (m_control->session()) {
+        DP1("S60MediaPlayerAudioEndpointSelector::defaultEndpoint - ",
+                m_control->session()->defaultEndpoint());
         return m_control->session()->defaultEndpoint();
-    else
+    }
+    else {
+        DP1("S60MediaPlayerAudioEndpointSelector::defaultEndpoint - ",
+                m_control->mediaControlSettings().audioEndpoint());
         return m_control->mediaControlSettings().audioEndpoint();
+    }
 }
 
+/*!
+    Set the audio endpoint to \a name.
+*/
+
 void S60MediaPlayerAudioEndpointSelector::setActiveEndpoint(const QString& name)
 {
+    DP0("S60MediaPlayerAudioEndpointSelector::setActiveEndpoin +++");
+
+    DP1("S60MediaPlayerAudioEndpointSelector::setActiveEndpoint - ", name);
+
     QString oldEndpoint = m_control->mediaControlSettings().audioEndpoint();
 
     if (name != oldEndpoint && (name == QString("Default") || name == QString("All") ||
@@ -117,4 +177,6 @@ void S60MediaPlayerAudioEndpointSelector::setActiveEndpoint(const QString& name)
         }
         m_control->setAudioEndpoint(name);
     }
+
+    DP0("S60MediaPlayerAudioEndpointSelector::setActiveEndpoin ---");
 }
diff --git a/plugins/multimedia/symbian/mmf/mediaplayer/s60mediaplayercontrol.cpp b/plugins/multimedia/symbian/mmf/mediaplayer/s60mediaplayercontrol.cpp
index 0282bac19c..391a970a89 100644
--- a/plugins/multimedia/symbian/mmf/mediaplayer/s60mediaplayercontrol.cpp
+++ b/plugins/multimedia/symbian/mmf/mediaplayer/s60mediaplayercontrol.cpp
@@ -40,6 +40,8 @@
 **
 ****************************************************************************/
 
+#include "DebugMacros.h"
+
 #include "s60mediaplayercontrol.h"
 #include "s60mediaplayersession.h"
 
@@ -47,76 +49,151 @@
 #include <QtCore/qurl.h>
 #include <QtCore/qdebug.h>
 
+/*!
+    Constructs a new media player control with the given \a parent.
+*/
+
 S60MediaPlayerControl::S60MediaPlayerControl(MS60MediaPlayerResolver& mediaPlayerResolver, QObject *parent)
     : QMediaPlayerControl(parent),
       m_mediaPlayerResolver(mediaPlayerResolver),
       m_session(NULL),
       m_stream(NULL)
 {
+    DP0("S60MediaPlayerControl::S60MediaPlayerControl +++");
+
+    DP0("S60MediaPlayerControl::S60MediaPlayerControl ---");
+
 }
 
+/*!
+    Destroys a media player control.
+*/
+
 S60MediaPlayerControl::~S60MediaPlayerControl()
 {
+    DP0("S60MediaPlayerControl::~S60MediaPlayerControl +++");
+    DP0("S60MediaPlayerControl::~S60MediaPlayerControl ---");
 }
 
+/*!
+    \return the current playback position in milliseconds.
+*/
+
 qint64 S60MediaPlayerControl::position() const
 {
+   // DP0("S60MediaPlayerControl::position");
+
     if (m_session)
         return m_session->position();
     return 0;
 }
 
+/*!
+   \return the duration of the current media in milliseconds.
+*/
+
 qint64 S60MediaPlayerControl::duration() const
 {
+   // DP0("S60MediaPlayerControl::duration");
+
     if (m_session)
         return m_session->duration();
     return -1;
 }
 
+/*!
+    \return the state of a player control.
+*/
+
 QMediaPlayer::State S60MediaPlayerControl::state() const
 {
+    DP0("S60MediaPlayerControl::state");
+
     if (m_session)
         return m_session->state();
     return QMediaPlayer::StoppedState;
 }
 
+/*!
+    \return the status of the current media.
+*/
+
 QMediaPlayer::MediaStatus S60MediaPlayerControl::mediaStatus() const
-{   
+{
+    DP0("QMediaPlayer::mediaStatus");
+
     if (m_session)
         return m_session->mediaStatus();
     return m_mediaSettings.mediaStatus();
 }
 
+/*!
+    \return the buffering progress of the current media.  Progress is measured in the percentage
+    of the buffer filled.
+*/
+
 int S60MediaPlayerControl::bufferStatus() const
 {
+   // DP0("S60MediaPlayerControl::bufferStatus");
+
     if (m_session)
         return m_session->bufferStatus();
     return 0;
 }
 
+/*!
+    \return the audio volume of a player control.
+*/
+
 int S60MediaPlayerControl::volume() const
 {
+    DP0("S60MediaPlayerControl::volume");
+
     if (m_session)
         return m_session->volume();
     return m_mediaSettings.volume();
 }
 
+/*!
+    \return the mute state of a player control.
+*/
+
 bool S60MediaPlayerControl::isMuted() const
 {
+    DP0("S60MediaPlayerControl::isMuted");
+
    if (m_session)
        return  m_session->isMuted();
    return m_mediaSettings.isMuted();
 }
 
+/*!
+    Identifies if the current media is seekable.
+
+    \return true if it possible to seek within the current media, and false otherwise.
+*/
+
 bool S60MediaPlayerControl::isSeekable() const
 {
+    DP0("S60MediaPlayerControl::isSeekable");
+
     if (m_session)
        return  m_session->isSeekable();
     return false;
 }
 
+/*!
+    \return a range of times in milliseconds that can be played back.
+
+    Usually for local files this is a continuous interval equal to [0..duration()]
+    or an empty time range if seeking is not supported, but for network sources
+    it refers to the buffered parts of the media.
+*/
+
 QMediaTimeRange S60MediaPlayerControl::availablePlaybackRanges() const
 {
+    DP0("S60MediaPlayerControl::availablePlaybackRanges");
+
     QMediaTimeRange ranges;
 
     if(m_session && m_session->isSeekable())
@@ -125,14 +202,28 @@ QMediaTimeRange S60MediaPlayerControl::availablePlaybackRanges() const
     return ranges;
 }
 
+/*!
+    \return the rate of playback.
+*/
+
 qreal S60MediaPlayerControl::playbackRate() const
 {
+    DP0("S60MediaPlayerControl::playbackRate");
+
     return m_mediaSettings.playbackRate();
 }
 
+/*!
+    Sets the \a rate of playback.
+*/
+
 void S60MediaPlayerControl::setPlaybackRate(qreal rate)
 {
-    //getting the current playbackrate    
+    DP0("S60MediaPlayerControl::setPlaybackRate +++");
+
+    DP1("S60MediaPlayerControl::setPlaybackRate - ", rate);
+
+    //getting the current playbackrate
     qreal currentPBrate = m_mediaSettings.playbackRate();
     //checking if we need to change the Playback rate
     if (!qFuzzyCompare(currentPBrate,rate))
@@ -142,34 +233,88 @@ void S60MediaPlayerControl::setPlaybackRate(qreal rate)
 
         m_mediaSettings.setPlaybackRate(rate);
     }
+
+    DP0("S60MediaPlayerControl::setPlaybackRate ---");
 }
 
+/*!
+    Sets the playback \a pos of the current media.  This will initiate a seek and it may take
+    some time for playback to reach the position set.
+*/
+
 void S60MediaPlayerControl::setPosition(qint64 pos)
 {
+    DP0("S60MediaPlayerControl::setPosition +++");
+
+    DP1("S60MediaPlayerControl::setPosition, Position:", pos);
+
     if (m_session)
         m_session->setPosition(pos);
+
+    DP0("S60MediaPlayerControl::setPosition ---");
 }
 
+/*!
+    Starts playback of the current media.
+
+    If successful the player control will immediately enter the \l {QMediaPlayer::PlayingState}
+    {playing} state.
+*/
+
 void S60MediaPlayerControl::play()
 {
+    DP0("S60MediaPlayerControl::play +++");
+
     if (m_session)
         m_session->play();
+
+    DP0("S60MediaPlayerControl::play ---");
 }
 
+/*!
+    Pauses playback of the current media.
+
+    If sucessful the player control will immediately enter the \l {QMediaPlayer::PausedState}
+    {paused} state.
+*/
+
 void S60MediaPlayerControl::pause()
 {
+    DP0("S60MediaPlayerControl::pause +++");
+
     if (m_session)
         m_session->pause();
+
+    DP0("S60MediaPlayerControl::pause ---");
 }
 
+/*!
+    Stops playback of the current media.
+
+    If successful the player control will immediately enter the \l {QMediaPlayer::StoppedState}
+    {stopped} state.
+*/
+
 void S60MediaPlayerControl::stop()
 {
+    DP0("S60MediaPlayerControl::stop +++");
+
     if (m_session)
         m_session->stop();
+
+    DP0("S60MediaPlayerControl::stop ---");
 }
 
+/*!
+    Sets the audio \a volume of a player control.
+*/
+
 void S60MediaPlayerControl::setVolume(int volume)
 {
+    DP0("S60MediaPlayerControl::setVolume +++");
+
+    DP1("S60MediaPlayerControl::setVolume", volume);
+
     int boundVolume = qBound(0, volume, 100);
     if (boundVolume == m_mediaSettings.volume())
         return;
@@ -178,10 +323,20 @@ void S60MediaPlayerControl::setVolume(int volume)
 
     if (m_session)
         m_session->setVolume(boundVolume);
+
+    DP0("S60MediaPlayerControl::setVolume ---");
 }
 
+/*!
+    Sets the \a muted state of a player control.
+*/
+
 void S60MediaPlayerControl::setMuted(bool muted)
 {
+    DP0("S60MediaPlayerControl::setMuted +++");
+
+    DP1("S60MediaPlayerControl::setMuted - ", muted);
+
     if (m_mediaSettings.isMuted() == muted)
         return;
 
@@ -189,20 +344,48 @@ void S60MediaPlayerControl::setMuted(bool muted)
 
     if (m_session)
         m_session->setMuted(muted);
+
+    DP0("S60MediaPlayerControl::setMuted ---");
 }
 
+/*!
+ * \return the current media source.
+*/
+
 QMediaContent S60MediaPlayerControl::media() const
 {
+    DP0("S60MediaPlayerControl::media");
+
     return m_currentResource;
 }
 
+/*!
+    \return the current media stream. This is only a valid if a stream was passed to setMedia().
+
+    \sa setMedia()
+*/
+
 const QIODevice *S60MediaPlayerControl::mediaStream() const
 {
+    DP0("S60MediaPlayerControl::mediaStream");
+
     return m_stream;
 }
 
+/*!
+     Sets the current \a source media source.  If a \a stream is supplied; data will be read from that
+    instead of attempting to resolve the media source.  The media source may still be used to
+    supply media information such as mime type.
+
+    Setting the media to a null QMediaContent will cause the control to discard all
+    information relating to the current media source and to cease all I/O operations related
+    to that media.
+*/
+
 void S60MediaPlayerControl::setMedia(const QMediaContent &source, QIODevice *stream)
 {
+    DP0("S60MediaPlayerControl::setMedia +++");
+
     Q_UNUSED(stream)
     // we don't want to set & load media again when it is already loaded    
     if (m_session && m_currentResource == source)
@@ -233,43 +416,96 @@ void S60MediaPlayerControl::setMedia(const QMediaContent &source, QIODevice *str
         emit mediaStatusChanged(status);
     }
     emit mediaChanged(m_currentResource);
+
+    DP0("S60MediaPlayerControl::setMedia ---");
 }
 
+/*!
+ * \return media player session.
+*/
 S60MediaPlayerSession* S60MediaPlayerControl::session()
 {
+    DP0("S60MediaPlayerControl::session");
+
     return m_session;
 }
 
+/*!
+ *   Sets \a output as a VideoOutput.
+*/
+
 void S60MediaPlayerControl::setVideoOutput(QObject *output)
 {
+    DP0("S60MediaPlayerControl::setVideoOutput +++");
+
    m_mediaPlayerResolver.VideoPlayerSession()->setVideoRenderer(output);
+
+   DP0("S60MediaPlayerControl::setVideoOutput ---");
 }
 
+/*!
+ * \return TRUE if Audio available or else FALSE.
+*/
+
 bool S60MediaPlayerControl::isAudioAvailable() const
 {
+    DP0("S60MediaPlayerControl::isAudioAvailable");
+
     if (m_session)
         return m_session->isAudioAvailable(); 
     return false;
 }
 
+/*!
+ * \return TRUE if Video available or else FALSE.
+*/
+
 bool S60MediaPlayerControl::isVideoAvailable() const
 {
+    DP0("S60MediaPlayerControl::isVideoAvailable");
+
     if (m_session)
         return m_session->isVideoAvailable();
     return false;
 }
 
+/*!
+ * \return media settings.
+ *
+ * Media Settings include volume, muted, playbackRate, mediaStatus, audioEndpoint.
+*/
 const S60MediaSettings& S60MediaPlayerControl::mediaControlSettings() const
 {
+    DP0("S60MediaPlayerControl::mediaControlSettings");
     return m_mediaSettings;
 }
 
+/*!
+ * Set the audio endpoint to \a name.
+*/
+
 void S60MediaPlayerControl::setAudioEndpoint(const QString& name)
 {
+    DP0("S60MediaPlayerControl::setAudioEndpoint +++");
+
+    DP1("S60MediaPlayerControl::setAudioEndpoint - ", name);
+
     m_mediaSettings.setAudioEndpoint(name);
+
+    DP0("S60MediaPlayerControl::setAudioEndpoint ---");
 }
 
+/*!
+ *  Sets media type \a type as Unknown, Video, Audio, Data.
+*/
+
 void S60MediaPlayerControl::setMediaType(S60MediaSettings::TMediaType type)
 {
+    DP0("S60MediaPlayerControl::setMediaType +++");
+
+    DP1("S60MediaPlayerControl::setMediaType - ", type);
+
     m_mediaSettings.setMediaType(type);
+
+    DP0("S60MediaPlayerControl::setMediaType ---");
 }
diff --git a/plugins/multimedia/symbian/mmf/mediaplayer/s60mediaplayerservice.cpp b/plugins/multimedia/symbian/mmf/mediaplayer/s60mediaplayerservice.cpp
index a553c9f4dd..485c22af2d 100644
--- a/plugins/multimedia/symbian/mmf/mediaplayer/s60mediaplayerservice.cpp
+++ b/plugins/multimedia/symbian/mmf/mediaplayer/s60mediaplayerservice.cpp
@@ -39,6 +39,8 @@
 **
 ****************************************************************************/
 
+#include "DebugMacros.h"
+
 #include <QtCore/qvariant.h>
 #include <QtCore/qdebug.h>
 #include <QtGui/qwidget.h>
@@ -60,6 +62,10 @@
 #include <qmediaplaylistnavigator.h>
 #include <qmediaplaylist.h>
 
+/*!
+    Construct a media service with the given \a parent.
+*/
+
 S60MediaPlayerService::S60MediaPlayerService(QObject *parent)
     : QMediaService(parent)
     , m_control(NULL)
@@ -70,18 +76,40 @@ S60MediaPlayerService::S60MediaPlayerService(QObject *parent)
     , m_streamControl(NULL)
     , m_videoOutput(NULL)
 {
+    DP0("S60MediaPlayerService::S60MediaPlayerService +++");
+
     m_control = new S60MediaPlayerControl(*this, this);
     m_metaData = new S60MediaMetaDataProvider(m_control, this);
     m_audioEndpointSelector = new S60MediaPlayerAudioEndpointSelector(m_control, this);
     m_streamControl = new S60MediaStreamControl(m_control, this);
+
+    DP0("S60MediaPlayerService::S60MediaPlayerService ---");
 }
 
+/*!
+    Destroys a media service.
+*/
+
 S60MediaPlayerService::~S60MediaPlayerService()
 {
+    DP0("S60MediaPlayerService::~S60MediaPlayerService +++");
+    DP0("S60MediaPlayerService::~S60MediaPlayerService ---");
 }
 
+/*!
+    \return a pointer to the media control, which matches the controller \a name.
+
+    If the service does not implement the control, or if it is unavailable a
+    null pointer is returned instead.
+
+    Controls must be returned to the service when no longer needed using the
+    releaseControl() function.
+*/
+
 QMediaControl *S60MediaPlayerService::requestControl(const char *name)
 {
+    DP0("S60MediaPlayerService::requestControl");
+
     if (qstrcmp(name, QMediaPlayerControl_iid) == 0)
         return m_control;
 
@@ -123,16 +151,30 @@ QMediaControl *S60MediaPlayerService::requestControl(const char *name)
     return 0;
 }
 
+/*!
+    Releases a \a control back to the service.
+*/
+
 void S60MediaPlayerService::releaseControl(QMediaControl *control)
 {
+    DP0("S60MediaPlayerService::releaseControl ++");
+
     if (control == m_videoOutput) {
         m_videoOutput = 0;
         m_control->setVideoOutput(m_videoOutput);
     }
+
+    DP0("S60MediaPlayerService::releaseControl --");
 }
 
+/*!
+ * \return media player session(audio playersesion/video playersession)
+ *  by recognizing whether media is audio or video and sets it on media type.
+*/
 S60MediaPlayerSession* S60MediaPlayerService::PlayerSession()
 {
+    DP0("S60MediaPlayerService::PlayerSession");
+
     QUrl url = m_control->media().canonicalUrl();
 
     if (url.isEmpty() == true) {
@@ -145,13 +187,11 @@ S60MediaPlayerSession* S60MediaPlayerService::PlayerSession()
 
     switch (mediaType) {
     case S60MediaRecognizer::Video:
-    case S60MediaRecognizer::Url:
-        {
+    case S60MediaRecognizer::Url: {
         m_control->setMediaType(S60MediaSettings::Video);
         return VideoPlayerSession();
         }
-    case S60MediaRecognizer::Audio:
-        {
+    case S60MediaRecognizer::Audio: {
         m_control->setMediaType(S60MediaSettings::Audio);
         return AudioPlayerSession();
         }
@@ -163,8 +203,16 @@ S60MediaPlayerSession* S60MediaPlayerService::PlayerSession()
     return NULL;
 }
 
+/*!
+ *  \return media playersession (videoplayersession).
+ *  constructs the videoplayersession object and connects all the respective signals and slots.
+ *  and initialises all the media settings.
+*/
+
 S60MediaPlayerSession* S60MediaPlayerService::VideoPlayerSession()
 {
+    DP0("S60MediaPlayerService::VideoPlayerSession +++");
+
     if (!m_videoPlayerSession) {
         m_videoPlayerSession = new S60VideoPlayerSession(this);
 
@@ -206,11 +254,22 @@ S60MediaPlayerSession* S60MediaPlayerService::VideoPlayerSession()
         m_videoPlayerSession->setAudioEndpoint(m_control->mediaControlSettings().audioEndpoint());
 
     }
+
+    DP0("S60MediaPlayerService::VideoPlayerSession ---");
+
     return m_videoPlayerSession;
 }
 
+/*!
+ *  \return media playersession (audioplayersession).
+ *  constructs the audioplayersession object and connects all the respective signals and slots.
+ *  and initialises all the media settings.
+*/
+
 S60MediaPlayerSession* S60MediaPlayerService::AudioPlayerSession()
 {
+    DP0("S60MediaPlayerService::AudioPlayerSession +++");
+
     if (!m_audioPlayerSession) {
         m_audioPlayerSession = new S60AudioPlayerSession(this);
 
@@ -251,5 +310,7 @@ S60MediaPlayerSession* S60MediaPlayerService::AudioPlayerSession()
         m_audioPlayerSession->setMuted(m_control->mediaControlSettings().isMuted());
         m_audioPlayerSession->setAudioEndpoint(m_control->mediaControlSettings().audioEndpoint());
     }
+    DP0("S60MediaPlayerService::AudioPlayerSession ---");
+
     return m_audioPlayerSession;
 }
diff --git a/plugins/multimedia/symbian/mmf/mediaplayer/s60mediaplayersession.cpp b/plugins/multimedia/symbian/mmf/mediaplayer/s60mediaplayersession.cpp
index ce5f91be9d..230642aaae 100644
--- a/plugins/multimedia/symbian/mmf/mediaplayer/s60mediaplayersession.cpp
+++ b/plugins/multimedia/symbian/mmf/mediaplayer/s60mediaplayersession.cpp
@@ -39,6 +39,8 @@
 **
 ****************************************************************************/
 
+#include "DebugMacros.h"
+
 #include "s60mediaplayersession.h"
 
 #include <QtCore/qdebug.h>
@@ -48,6 +50,10 @@
 #include <mmf/common/mmferrors.h>
 #include <qmediatimerange.h>
 
+/*!
+    Construct a media playersession with the given \a parent.
+*/
+
 S60MediaPlayerSession::S60MediaPlayerSession(QObject *parent)
     : QObject(parent)
     , m_playbackRate(0)
@@ -61,22 +67,45 @@ S60MediaPlayerSession::S60MediaPlayerSession(QObject *parent)
     , m_play_requested(false)
     , m_stream(false)
     , m_seekable(true)
-{    
+{
+    DP0("S60MediaPlayerSession::S60MediaPlayerSession +++");
+
     connect(m_progressTimer, SIGNAL(timeout()), this, SLOT(tick()));
     connect(m_stalledTimer, SIGNAL(timeout()), this, SLOT(stalled()));
+
+    DP0("S60MediaPlayerSession::S60MediaPlayerSession ---");
 }
 
+/*!
+    Destroys a media playersession.
+*/
+
 S60MediaPlayerSession::~S60MediaPlayerSession()
 {
+    DP0("S60MediaPlayerSession::~S60MediaPlayerSession +++");
+    DP0("S60MediaPlayerSession::~S60MediaPlayerSession ---");
 }
 
+/*!
+ * \return the audio volume of a player session.
+*/
 int S60MediaPlayerSession::volume() const
 {
+    DP1("S60MediaPlayerSession::volume", m_volume);
+
     return m_volume;
 }
 
+/*!
+    Sets the audio \a volume of a player session.
+*/
+
 void S60MediaPlayerSession::setVolume(int volume)
 {
+    DP0("S60MediaPlayerSession::setVolume +++");
+
+    DP1("S60MediaPlayerSession::setVolume - ", volume);
+
     if (m_volume == volume)
         return;
     
@@ -96,20 +125,41 @@ void S60MediaPlayerSession::setVolume(int volume)
         else
             setError(err);
     }
+    DP0("S60MediaPlayerSession::setVolume ---");
 }
 
+/*!
+    \return the mute state of a player session.
+*/
+
 bool S60MediaPlayerSession::isMuted() const
 {
+    DP1("S60MediaPlayerSession::isMuted", m_muted);
+
     return m_muted;
 }
 
+/*!
+    Identifies if the current media is seekable.
+
+    \return true if it possible to seek within the current media, and false otherwise.
+*/
+
 bool S60MediaPlayerSession::isSeekable() const
 {
+    DP1("S60MediaPlayerSession::isSeekable", m_seekable);
+
     return m_seekable;
 }
 
+/*!
+    Sets the \a status of the current media.
+*/
+
 void S60MediaPlayerSession::setMediaStatus(QMediaPlayer::MediaStatus status)
 {
+    DP0("S60MediaPlayerSession::setMediaStatus +++");
+
     if (m_mediaStatus == status)
         return;
     
@@ -119,29 +169,59 @@ void S60MediaPlayerSession::setMediaStatus(QMediaPlayer::MediaStatus status)
     
     if (m_play_requested && m_mediaStatus == QMediaPlayer::LoadedMedia)
         play();
+
+    DP0("S60MediaPlayerSession::setMediaStatus ---");
 }
 
+/*!
+    Sets the \a state on media player.
+*/
+
 void S60MediaPlayerSession::setState(QMediaPlayer::State state)
 {
+    DP0("S60MediaPlayerSession::setState +++");
+
     if (m_state == state)
         return;
     
     m_state = state;
     emit stateChanged(m_state);
+
+    DP0("S60MediaPlayerSession::setState ---");
 }
 
-QMediaPlayer::State S60MediaPlayerSession::state() const 
-{ 
-    return m_state; 
+/*!
+    \return the state of a player session.
+*/
+
+QMediaPlayer::State S60MediaPlayerSession::state() const
+{
+    DP1("S60MediaPlayerSession::state", m_state);
+
+    return m_state;
 }
 
-QMediaPlayer::MediaStatus S60MediaPlayerSession::mediaStatus() const 
-{ 
-    return m_mediaStatus; 
+/*!
+    \return the status of the current media.
+*/
+
+QMediaPlayer::MediaStatus S60MediaPlayerSession::mediaStatus() const
+{
+    DP1("S60MediaPlayerSession::mediaStatus", m_mediaStatus);
+
+    return m_mediaStatus;
 }
 
+/*!
+ *  Loads the \a url for playback.
+ *  If \a url is local file then it loads audio playersesion if its audio file.
+ *  If it is a local video file then loads the video playersession.
+*/
+
 void S60MediaPlayerSession::load(QUrl url)
 {
+    DP0("S60MediaPlayerSession::load +++");
+
     setMediaStatus(QMediaPlayer::LoadingMedia);
     startStalledTimer();
     m_stream = (url.scheme() == "file")?false:true;
@@ -151,10 +231,17 @@ void S60MediaPlayerSession::load(QUrl url)
         else
             doLoadL(QString2TPtrC(QDir::toNativeSeparators(url.toLocalFile()))));
     setError(err);
+
+    DP0("S60MediaPlayerSession::load ---");
 }
 
+/*!
+    Start or resume playing the current source.
+*/
 void S60MediaPlayerSession::play()
 {
+    DP0("S60MediaPlayerSession::play +++");
+
     if (state() == QMediaPlayer::PlayingState
         || mediaStatus() == QMediaPlayer::UnknownMediaStatus
         || mediaStatus() == QMediaPlayer::NoMedia
@@ -175,10 +262,18 @@ void S60MediaPlayerSession::play()
     setState(QMediaPlayer::PlayingState);
     startProgressTimer();
     doPlay();
+
+    DP0("S60MediaPlayerSession::play ---");
 }
 
+/*!
+    Pause playing the current source.
+*/
+
 void S60MediaPlayerSession::pause()
 {
+    DP0("S60MediaPlayerSession::pause +++");
+
     if (state() != QMediaPlayer::PlayingState)
         return;
 
@@ -189,10 +284,18 @@ void S60MediaPlayerSession::pause()
     setState(QMediaPlayer::PausedState);
     stopProgressTimer();
     TRAP_IGNORE(doPauseL());
+
+    DP0("S60MediaPlayerSession::pause ---");
 }
 
+/*!
+    Stop playing, and reset the play position to the beginning.
+*/
+
 void S60MediaPlayerSession::stop()
 {
+    DP0("S60MediaPlayerSession::stop +++");
+
     if (state() == QMediaPlayer::StoppedState)
         return;
 
@@ -208,11 +311,20 @@ void S60MediaPlayerSession::stop()
     stopStalledTimer();
     doStop();
     emit positionChanged(0);
+
+    DP0("S60MediaPlayerSession::stop ---");
 }
 
+/*!
+ * Stops the playback and closes the controllers.
+ * And resets all the flags and status, state to default values.
+*/
+
 void S60MediaPlayerSession::reset()
 {
-    m_play_requested = false;    
+    DP0("S60MediaPlayerSession::reset +++");
+
+    m_play_requested = false;
     setError(KErrNone, QString(), true);
     stopProgressTimer();
     stopStalledTimer();
@@ -220,15 +332,38 @@ void S60MediaPlayerSession::reset()
     doClose();
     setState(QMediaPlayer::StoppedState);
     setMediaStatus(QMediaPlayer::UnknownMediaStatus);
+
+    DP0("S60MediaPlayerSession::reset ---");
 }
 
+/*!
+ * Sets \a renderer as video renderer.
+*/
+
 void S60MediaPlayerSession::setVideoRenderer(QObject *renderer)
 {
+    DP0("S60MediaPlayerSession::setVideoRenderer +++");
+
     Q_UNUSED(renderer);
+
+    DP0("S60MediaPlayerSession::setVideoRenderer ---");
 }
 
+/*!
+ *   the percentage of the temporary buffer filled before playback begins.
+
+    When the player object is buffering; this property holds the percentage of
+    the temporary buffer that is filled. The buffer will need to reach 100%
+    filled before playback can resume, at which time the MediaStatus will be
+    BufferedMedia.
+
+    \sa mediaStatus()
+*/
+
 int S60MediaPlayerSession::bufferStatus()
 {
+    DP0("S60MediaPlayerSession::bufferStatus");
+
     if (state() ==QMediaPlayer::StoppedState)
         return 0;
 
@@ -249,23 +384,46 @@ int S60MediaPlayerSession::bufferStatus()
     return progress;
 }
 
+/*!
+ * return TRUE if Meta data is available in current media source.
+*/
+
 bool S60MediaPlayerSession::isMetadataAvailable() const
 {
-    return !m_metaDataMap.isEmpty();    
+    DP0("S60MediaPlayerSession::isMetadataAvailable");
+
+    return !m_metaDataMap.isEmpty();
 }
 
+/*!
+ * \return the \a key meta data.
+*/
 QVariant S60MediaPlayerSession::metaData(const QString &key) const
 {
-    return m_metaDataMap.value(key);    
+    DP0("S60MediaPlayerSession::metaData (const QString &key) const");
+
+    return m_metaDataMap.value(key);
 }
 
+/*!
+ * \return the \a key meta data as QString.
+*/
+
 QVariant S60MediaPlayerSession::metaData(QtMultimediaKit::MetaData key) const
 {
+    DP0("S60MediaPlayerSession::metaData (QtMultimediaKit::MetaData key) const");
+
     return metaData(metaDataKeyAsString(key));
 }
 
+/*!
+ * \return List of all available meta data from current media source.
+*/
+
 QList<QtMultimediaKit::MetaData> S60MediaPlayerSession::availableMetaData() const
 {
+    DP0("S60MediaPlayerSession::availableMetaData +++");
+
     QList<QtMultimediaKit::MetaData> metaDataTags;
     if (isMetadataAvailable()) {
         for (int i = QtMultimediaKit::Title; i <= QtMultimediaKit::ThumbnailImage; i++) {
@@ -277,16 +435,31 @@ QList<QtMultimediaKit::MetaData> S60MediaPlayerSession::availableMetaData() cons
             }
         }
     }
+
+    DP0("S60MediaPlayerSession::availableMetaData ---");
+
     return metaDataTags;
 }
 
+/*!
+ * \return all available extended meta data of current media source.
+*/
+
 QStringList S60MediaPlayerSession::availableExtendedMetaData() const
 {
+    DP0("S60MediaPlayerSession::availableExtendedMetaData");
+
     return m_metaDataMap.keys();
 }
 
+/*!
+ * \return meta data \a key as QString.
+*/
+
 QString S60MediaPlayerSession::metaDataKeyAsString(QtMultimediaKit::MetaData key) const
 {
+    DP1("S60MediaPlayerSession::metaDataKeyAsString", key);
+
     switch(key) {
     case QtMultimediaKit::Title: return "title";
     case QtMultimediaKit::AlbumArtist: return "artist";
@@ -346,8 +519,15 @@ QString S60MediaPlayerSession::metaDataKeyAsString(QtMultimediaKit::MetaData key
     return QString();
 }
 
+/*!
+    Sets the \a muted state of a player session.
+*/
+
 void S60MediaPlayerSession::setMuted(bool muted)
 {
+    DP0("S60MediaPlayerSession::setMuted +++");
+    DP1("S60MediaPlayerSession::setMuted - ", muted);
+
     m_muted = muted;
     
     if(   m_mediaStatus == QMediaPlayer::LoadedMedia 
@@ -361,10 +541,17 @@ void S60MediaPlayerSession::setMuted(bool muted)
         else
             setError(err);
     }
+    DP0("S60MediaPlayerSession::setMuted ---");
 }
 
+/*!
+   \return the duration of the current media in milliseconds.
+*/
+
 qint64 S60MediaPlayerSession::duration() const
 {
+  //  DP0("S60MediaPlayerSession::duration");
+
     if(   mediaStatus() == QMediaPlayer::LoadingMedia
        || mediaStatus() == QMediaPlayer::UnknownMediaStatus
        || mediaStatus() == QMediaPlayer::NoMedia
@@ -377,8 +564,14 @@ qint64 S60MediaPlayerSession::duration() const
     return pos;
 }
 
+/*!
+    \return the current playback position in milliseconds.
+*/
+
 qint64 S60MediaPlayerSession::position() const
 {
+ //   DP0("S60MediaPlayerSession::position");
+
     if(   mediaStatus() == QMediaPlayer::LoadingMedia
        || mediaStatus() == QMediaPlayer::UnknownMediaStatus
        || mediaStatus() == QMediaPlayer::NoMedia
@@ -391,8 +584,17 @@ qint64 S60MediaPlayerSession::position() const
     return pos;
 }
 
+/*!
+    Sets the playback \a pos of the current media.  This will initiate a seek and it may take
+    some time for playback to reach the position set.
+*/
+
 void S60MediaPlayerSession::setPosition(qint64 pos)
 {
+    DP0("S60MediaPlayerSession::setPosition +++");
+
+    DP1("S60MediaPlayerSession::setPosition - ", pos);
+
     if (position() == pos)
         return;
 
@@ -413,15 +615,35 @@ void S60MediaPlayerSession::setPosition(qint64 pos)
         play();
 
     emit positionChanged(position());
+
+    DP0("S60MediaPlayerSession::setPosition ---");
 }
 
+/*!
+ * Set the audio endpoint to \a audioEndpoint.
+*/
+
 void S60MediaPlayerSession::setAudioEndpoint(const QString& audioEndpoint)
 {
+    DP0("S60MediaPlayerSession::setAudioEndpoint +++");
+
+    DP1("S60MediaPlayerSession::setAudioEndpoint - ", audioEndpoint);
+
     doSetAudioEndpoint(audioEndpoint);
+
+    DP0("S60MediaPlayerSession::setAudioEndpoint ---");
 }
 
+/*!
+ * Loading of media source is completed.
+ * And ready for playback. Updates all the media status, state, settings etc.
+ * And emits the signals.
+*/
+
 void S60MediaPlayerSession::loaded()
 {
+    DP0("S60MediaPlayerSession::loaded +++");
+
     stopStalledTimer();
     if (m_error == KErrNone || m_error == KErrMMPartialPlayback) {
         setMediaStatus(QMediaPlayer::LoadedMedia);
@@ -434,10 +656,17 @@ void S60MediaPlayerSession::loaded()
 
         m_seekable = getIsSeekable();
     }
+
+    DP0("S60MediaPlayerSession::loaded ---");
 }
 
+/*!
+ * Playback is completed as medai source reached end of media.
+*/
 void S60MediaPlayerSession::endOfMedia()
 {
+    DP0("S60MediaPlayerSession::endOfMedia +++");
+
     m_state = QMediaPlayer::StoppedState;
     setMediaStatus(QMediaPlayer::EndOfMedia);
     //there is a chance that user might have called play from EOF callback
@@ -445,31 +674,79 @@ void S60MediaPlayerSession::endOfMedia()
     if(m_state == QMediaPlayer::StoppedState)
         emit stateChanged(QMediaPlayer::StoppedState);
     emit positionChanged(0);
+
+    DP0("S60MediaPlayerSession::endOfMedia ---");
 }
 
+/*!
+ *  The percentage of the temporary buffer filling before playback begins.
+
+    When the player object is buffering; this property holds the percentage of
+    the temporary buffer that is filled. The buffer will need to reach 100%
+    filled before playback can resume, at which time the MediaStatus will be
+    BufferedMedia.
+
+    \sa mediaStatus()
+*/
+
 void S60MediaPlayerSession::buffering()
 {
+    DP0("S60MediaPlayerSession::buffering +++");
+
     startStalledTimer();
     setMediaStatus(QMediaPlayer::BufferingMedia);
+
+    DP0("S60MediaPlayerSession::buffering ---");
 }
 
+/*!
+ * Buffer is filled with data and to for continuing/start playback.
+*/
+
 void S60MediaPlayerSession::buffered()
 {
+    DP0("S60MediaPlayerSession::buffered +++");
+
     stopStalledTimer();
     setMediaStatus(QMediaPlayer::BufferedMedia);
+
+    DP0("S60MediaPlayerSession::buffered ---");
 }
+
+/*!
+ * Sets media status as stalled as waiting for the buffer to be filled to start playback.
+*/
+
 void S60MediaPlayerSession::stalled()
 {
+    DP0("S60MediaPlayerSession::stalled +++");
+
     setMediaStatus(QMediaPlayer::StalledMedia);
+
+    DP0("S60MediaPlayerSession::stalled ---");
 }
 
+/*!
+ * \return all the meta data entries in the current media source.
+*/
+
 QMap<QString, QVariant>& S60MediaPlayerSession::metaDataEntries()
 {
+    DP0("S60MediaPlayerSession::metaDataEntries");
+
     return m_metaDataMap;
 }
 
+/*!
+ * \return Error by converting Symbian specific error to Multimedia error.
+*/
+
 QMediaPlayer::Error S60MediaPlayerSession::fromSymbianErrorToMultimediaError(int error)
 {
+    DP0("S60MediaPlayerSession::fromSymbianErrorToMultimediaError");
+
+    DP1("S60MediaPlayerSession::fromSymbianErrorToMultimediaError - ", error);
+
     switch(error) {
         case KErrNoMemory:
         case KErrNotFound:
@@ -530,13 +807,29 @@ QMediaPlayer::Error S60MediaPlayerSession::fromSymbianErrorToMultimediaError(int
     }
 }
 
+/*!
+ * \return error.
+ */
+
 int S60MediaPlayerSession::error() const
 {
+    DP1("S60MediaPlayerSession::error", m_error);
+
     return m_error;
 }
 
+/*!
+ * Sets the error.
+ * * If playback complete/prepare complete ..., etc with successfull then sets error as ZERO
+ *  else Multimedia error.
+*/
+
 void S60MediaPlayerSession::setError(int error, const QString &errorString, bool forceReset)
 {
+    DP0("S60MediaPlayerSession::setError +++");
+
+    DP5("S60MediaPlayerSession::setError - error:", error,"errorString:", errorString, "forceReset:", forceReset);
+
     if( forceReset ) {
         m_error = KErrNone;
         emit this->error(QMediaPlayer::NoError, QString());
@@ -576,53 +869,164 @@ void S60MediaPlayerSession::setAndEmitError(int error)
     symbianError.append("Symbian:");
     symbianError.append(QString::number(error));
     emit this->error(rateError, symbianError);
+
+    DP0("S60MediaPlayerSession::setError ---");
 }
 
+/*!
+ * emits the signal if there is a changes in position and buffering status.
+ */
+
 void S60MediaPlayerSession::tick()
 {
+    DP0("S60MediaPlayerSession::tick +++");
+
     emit positionChanged(position());
 
     if (bufferStatus() < 100)
         emit bufferStatusChanged(bufferStatus());
+
+    DP0("S60MediaPlayerSession::tick ---");
 }
 
+/*!
+ * Starts the timer once the media source starts buffering.
+*/
+
 void S60MediaPlayerSession::startProgressTimer()
 {
+    DP0("S60MediaPlayerSession::startProgressTimer +++");
+
     m_progressTimer->start(500);
+
+    DP0("S60MediaPlayerSession::startProgressTimer ---");
 }
 
+/*!
+ * Stops the timer once the media source finished buffering.
+*/
+
 void S60MediaPlayerSession::stopProgressTimer()
 {
+    DP0("S60MediaPlayerSession::stopProgressTimer +++");
+
     m_progressTimer->stop();
+
+    DP0("S60MediaPlayerSession::stopProgressTimer ---");
 }
 
+/*!
+ * Starts the timer while waiting for some events to happen like source buffering or call backs etc.
+ * So that if the events doesn't occur before stalled timer stops, it'll set the error/media status etc.
+*/
+
 void S60MediaPlayerSession::startStalledTimer()
 {
+    DP0("S60MediaPlayerSession::startStalledTimer +++");
+
     m_stalledTimer->start(30000);
+
+    DP0("S60MediaPlayerSession::startStalledTimer ---");
 }
 
+/*!
+ *  Stops the timer when some events occured while waiting for them.
+ *  media source started buffering or call back is received etc.
+*/
+
 void S60MediaPlayerSession::stopStalledTimer()
 {
+    DP0("S60MediaPlayerSession::stopStalledTimer +++");
+
     m_stalledTimer->stop();
+
+    DP0("S60MediaPlayerSession::stopStalledTimer ---");
 }
 
+/*!
+ * \return Converted Symbian specific Descriptor to QString.
+*/
+
 QString S60MediaPlayerSession::TDesC2QString(const TDesC& aDescriptor)
 {
+    DP0("S60MediaPlayerSession::TDesC2QString");
+
     return QString::fromUtf16(aDescriptor.Ptr(), aDescriptor.Length());
 }
 
+/*!
+ * \return Converted QString to non-modifiable pointer Descriptor.
+*/
+
 TPtrC S60MediaPlayerSession::QString2TPtrC( const QString& string )
 {
+    DP0("S60MediaPlayerSession::QString2TPtrC");
+
 	// Returned TPtrC is valid as long as the given parameter is valid and unmodified
     return TPtrC16(static_cast<const TUint16*>(string.utf16()), string.length());
 }
 
+/*!
+ * \return Converted Symbian TRect object to QRect object.
+*/
+
 QRect S60MediaPlayerSession::TRect2QRect(const TRect& tr)
 {
+    DP0("S60MediaPlayerSession::TRect2QRect");
+
     return QRect(tr.iTl.iX, tr.iTl.iY, tr.Width(), tr.Height());
 }
 
+/*!
+ * \return converted QRect object to Symbian specific TRec object.
+ */
+
 TRect S60MediaPlayerSession::QRect2TRect(const QRect& qr)
 {
+    DP0("S60MediaPlayerSession::QRect2TRect");
+
     return TRect(TPoint(qr.left(), qr.top()), TSize(qr.width(), qr.height()));
 }
+
+/*!
+    \fn bool S60MediaPlayerSession::isVideoAvailable();
+
+
+    Returns TRUE if Video is available.
+*/
+
+/*!
+    \fn bool S60MediaPlayerSession::isAudioAvailable();
+
+
+    Returns TRUE if Audio is available.
+*/
+
+/*!
+    \fn void S60MediaPlayerSession::setPlaybackRate (qreal rate);
+
+
+    Sets \a rate play back rate on media source. getIsSeekable
+*/
+
+/*!
+    \fn bool S60MediaPlayerSession::getIsSeekable () const;
+
+
+    \return TRUE if Seekable possible on current media source else FALSE.
+*/
+
+/*!
+    \fn QString S60MediaPlayerSession::activeEndpoint () const;
+
+
+    \return active end point name..
+*/
+
+/*!
+    \fn QString S60MediaPlayerSession::defaultEndpoint () const;
+
+
+    \return default end point name.
+*/
+
diff --git a/plugins/multimedia/symbian/mmf/mediaplayer/s60mediarecognizer.cpp b/plugins/multimedia/symbian/mmf/mediaplayer/s60mediarecognizer.cpp
index aefdef7c86..d0f6c8ec11 100644
--- a/plugins/multimedia/symbian/mmf/mediaplayer/s60mediarecognizer.cpp
+++ b/plugins/multimedia/symbian/mmf/mediaplayer/s60mediarecognizer.cpp
@@ -39,6 +39,8 @@
 **
 ****************************************************************************/
 
+#include "DebugMacros.h"
+
 #include "s60mediarecognizer.h"
 #include <e32def.h>
 #include <e32cmn.h>
@@ -52,19 +54,41 @@ static const TInt KMimeTypePrefixLength = 6; // "audio/" or "video/"
 _LIT(KMimeTypePrefixAudio, "audio/");
 _LIT(KMimeTypePrefixVideo, "video/");
 
+/*!
+    Construct a media Recognizer with the given \a parent.
+*/
+
 S60MediaRecognizer::S60MediaRecognizer(QObject *parent) : QObject(parent)
 {
+    DP0("S60MediaRecognizer::S60MediaRecognizer +++");
+    DP0("S60MediaRecognizer::S60MediaRecognizer ---");
 }
 
+/*!
+    Destroys a media Recognizer.
+*/
+
 S60MediaRecognizer::~S60MediaRecognizer()
 {
+    DP0("S60MediaRecognizer::~S60MediaRecognizer +++");
+
     m_file.Close();
     m_fileServer.Close();
     m_recognizer.Close();
+
+    DP0("S60MediaRecognizer::~S60MediaRecognizer ---");
 }
 
+/*!
+ * \return media type of \a url.
+ * \a url may be a streaming link or a local file.
+ * If \a url is local file then identifies the media type and returns it.
+*/
+
 S60MediaRecognizer::MediaType S60MediaRecognizer::mediaType(const QUrl &url)
 {
+    DP0("S60MediaRecognizer::mediaType");
+
     bool isStream = (url.scheme() == "file")?false:true;
 
     if (isStream)
@@ -73,8 +97,16 @@ S60MediaRecognizer::MediaType S60MediaRecognizer::mediaType(const QUrl &url)
         return identifyMediaType(url.toLocalFile());
 }
 
+/*!
+ * \return Media type of \a file name by recognizing its mimetype whether its audio or video.
+*/
+
 S60MediaRecognizer::MediaType S60MediaRecognizer::identifyMediaType(const QString& fileName)
 {
+    DP0("S60MediaRecognizer::identifyMediaType +++");
+
+    DP1("S60MediaRecognizer::identifyMediaType - ", fileName);
+
     S60MediaRecognizer::MediaType result = Video; // default to videoplayer
     bool recognizerOpened = false;
 
@@ -113,11 +145,20 @@ S60MediaRecognizer::MediaType S60MediaRecognizer::identifyMediaType(const QStrin
             }
         }
     }
+
+    DP0("S60MediaRecognizer::identifyMediaType ---");
+
     return result;
 }
 
+/*!
+ * \return Symbian modifiable pointer descriptor from a QString \a string.
+ */
+
 TPtrC S60MediaRecognizer::QString2TPtrC( const QString& string )
 {
+    DP1("S60MediaRecognizer::QString2TPtrC - ", string);
+
     // Returned TPtrC is valid as long as the given parameter is valid and unmodified
     return TPtrC16(static_cast<const TUint16*>(string.utf16()), string.length());
 }
diff --git a/plugins/multimedia/symbian/mmf/mediaplayer/s60mediastreamcontrol.cpp b/plugins/multimedia/symbian/mmf/mediaplayer/s60mediastreamcontrol.cpp
index 3dab3c1843..9a2ce5c02d 100644
--- a/plugins/multimedia/symbian/mmf/mediaplayer/s60mediastreamcontrol.cpp
+++ b/plugins/multimedia/symbian/mmf/mediaplayer/s60mediastreamcontrol.cpp
@@ -39,6 +39,8 @@
 **
 ****************************************************************************/
 
+#include "DebugMacros.h"
+
 #include "s60mediastreamcontrol.h"
 #include "s60mediaplayersession.h"
 #include "s60mediaplayercontrol.h"
@@ -48,32 +50,61 @@
 #include <QtCore/qurl.h>
 #include <QtCore/qdebug.h>
 
+/*!
+    Constructs a new media streams control with the given \a control.
+*/
+
 S60MediaStreamControl::S60MediaStreamControl(QObject *control, QObject *parent)
     : QMediaStreamsControl(parent)
     , m_control(NULL)
     , m_mediaType(S60MediaSettings::Unknown)
 {
+    DP0("S60MediaStreamControl::S60MediaStreamControl +++");
+
     m_control = qobject_cast<S60MediaPlayerControl*>(control);
     m_mediaType = m_control->mediaControlSettings().mediaType();
+
+    DP0("S60MediaStreamControl::S60MediaStreamControl ---");
 }
 
+/*!
+    Destroys a media streams control.
+*/
+
 S60MediaStreamControl::~S60MediaStreamControl()
 {
+    DP0("S60MediaStreamControl::~S60MediaStreamControl +++");
+    DP0("S60MediaStreamControl::~S60MediaStreamControl ---");
 }
 
+/*!
+    \return the number of media streams.
+*/
+
 int S60MediaStreamControl::streamCount()
 {
+    DP0("S60MediaStreamControl::streamCount");
+
     int streamCount = 0;
     if (m_control->isAudioAvailable())
         streamCount++;
     if (m_control->isVideoAvailable())
         streamCount++;
+    DP1("S60MediaStreamControl::streamCount", streamCount);
 
     return streamCount;
 }
 
+/*!
+    \return the type of a media \a streamNumber.
+*/
+
 QMediaStreamsControl::StreamType S60MediaStreamControl::streamType(int streamNumber)
 {
+    DP0("S60MediaStreamControl::streamType +++");
+
+    DP1("S60MediaStreamControl::streamType - ", streamNumber);
+
     Q_UNUSED(streamNumber);
 
     QMediaStreamsControl::StreamType type = QMediaStreamsControl::UnknownStream;
@@ -83,11 +114,21 @@ QMediaStreamsControl::StreamType S60MediaStreamControl::streamType(int streamNum
     else
         type = QMediaStreamsControl::AudioStream;
 
+    DP0("S60MediaStreamControl::streamType ---");
+
     return type;
 }
 
+/*!
+    \return the meta-data value of \a key for a given \a streamNumber.
+
+    Useful metadata keya are QtMultimediaKit::Title, QtMultimediaKit::Description and QtMultimediaKit::Language.
+*/
+
 QVariant S60MediaStreamControl::metaData(int streamNumber, QtMultimediaKit::MetaData key)
 {
+    DP0("S60MediaStreamControl::metaData");
+
     Q_UNUSED(streamNumber);
 
     if (m_control->session()) {
@@ -97,8 +138,16 @@ QVariant S60MediaStreamControl::metaData(int streamNumber, QtMultimediaKit::Meta
     return QVariant();
 }
 
+/*!
+    \return true if the media \a streamNumber is active else false.
+*/
+
 bool S60MediaStreamControl::isActive(int streamNumber)
 {
+    DP0("S60MediaStreamControl::isActive +++");
+
+    DP1("S60MediaStreamControl::isActive - ", streamNumber);
+
     if (m_control->mediaControlSettings().mediaType() ==  S60MediaSettings::Video) {
         switch (streamNumber) {
         case 1:
@@ -109,17 +158,44 @@ bool S60MediaStreamControl::isActive(int streamNumber)
             break;
         }
     }
+
+    DP0("S60MediaStreamControl::isActive ---");
+
     return m_control->isAudioAvailable();
 }
 
+/*!
+    Sets the active \a streamNumber of a media \a state.
+
+    Symbian MMF does not support enabling or disabling specific media streams.
+
+    Setting the active state of a media stream to true will activate it.  If any other stream
+    of the same type was previously active it will be deactivated. Setting the active state fo a
+    media stream to false will deactivate it.
+*/
+
 void S60MediaStreamControl::setActive(int streamNumber, bool state)
 {
+    DP0("S60MediaStreamControl::setActive +++");
+
+    DP2("S60MediaStreamControl::setActive - ", streamNumber, state);
+
     Q_UNUSED(streamNumber);
     Q_UNUSED(state);
     // Symbian MMF does not support enabling or disabling specific media streams
+
+    DP0("S60MediaStreamControl::setActive ---");
 }
 
+/*!
+     The signal is emitted when the available streams list is changed.
+*/
+
 void S60MediaStreamControl::handleStreamsChanged()
 {
+    DP0("S60MediaStreamControl::handleStreamsChanged +++");
+
     emit streamsChanged();
+
+    DP0("S60MediaStreamControl::handleStreamsChanged ---");
 }
diff --git a/plugins/multimedia/symbian/mmf/mediaplayer/s60videoplayersession.cpp b/plugins/multimedia/symbian/mmf/mediaplayer/s60videoplayersession.cpp
index 2501ea8b3a..2ebb00a974 100644
--- a/plugins/multimedia/symbian/mmf/mediaplayer/s60videoplayersession.cpp
+++ b/plugins/multimedia/symbian/mmf/mediaplayer/s60videoplayersession.cpp
@@ -39,6 +39,8 @@
 **
 ****************************************************************************/
 
+#include "DebugMacros.h"
+
 #include "s60videoplayersession.h"
 #include "s60mediaplayerservice.h"
 #include "s60videowidgetcontrol.h"
@@ -58,7 +60,11 @@
 #include <mmf/common/mmfcontrollerframeworkbase.h>
 
 const QString DefaultAudioEndpoint = QLatin1String("Default");
-const TUid KHelixUID = {0x101F8514};
+
+/*!
+    Constructs the CVideoPlayerUtility2 object with given \a service and \a object.
+    And Registers for Video Loading Notifications.
+*/
 
 S60VideoPlayerSession::S60VideoPlayerSession(QMediaService *service)
     : S60MediaPlayerSession(service)
@@ -79,6 +85,7 @@ S60VideoPlayerSession::S60VideoPlayerSession(QMediaService *service)
     , m_audioEndpoint(DefaultAudioEndpoint)
     , m_pendingChanges(0)
 {
+     DP0("S60VideoPlayerSession::S60VideoPlayerSession +++");
 #ifdef VIDEOOUTPUT_GRAPHICS_SURFACES
     QT_TRAP_THROWING(m_player = CVideoPlayerUtility2::NewL(
         *this,
@@ -113,10 +120,20 @@ S60VideoPlayerSession::S60VideoPlayerSession(QMediaService *service)
     m_dsaActive = true;
     m_player->RegisterForVideoLoadingNotification(*this);
 #endif // VIDEOOUTPUT_GRAPHICS_SURFACES
+
+    DP0("S60VideoPlayerSession::S60VideoPlayerSession ---");
 }
 
+/*!
+   Destroys the CVideoPlayerUtility2 object.
+
+  And Unregister the observer.
+*/
+
 S60VideoPlayerSession::~S60VideoPlayerSession()
 {
+    DP0("S60VideoPlayerSession::~S60VideoPlayerSession +++");
+
 #ifdef HAS_AUDIOROUTING_IN_VIDEOPLAYER
     if (m_audioOutput)
         m_audioOutput->UnregisterObserver(*this);
@@ -124,10 +141,19 @@ S60VideoPlayerSession::~S60VideoPlayerSession()
 #endif
     m_player->Close();
     delete m_player;
+
+    DP0("S60VideoPlayerSession::~S60VideoPlayerSession ---");
 }
 
+/*!
+
+   Opens the a file from \a path.
+*/
+
 void S60VideoPlayerSession::doLoadL(const TDesC &path)
 {
+    DP0("S60VideoPlayerSession::doLoadL +++");
+
 #ifdef HAS_AUDIOROUTING_IN_VIDEOPLAYER
     // m_audioOutput needs to be reinitialized after MapcInitComplete
     if (m_audioOutput)
@@ -136,11 +162,21 @@ void S60VideoPlayerSession::doLoadL(const TDesC &path)
     m_audioOutput = NULL;
 #endif
     m_player->OpenFileL(path, KHelixUID);
+
+    DP0("S60VideoPlayerSession::doLoadL ---");
 }
 
+/*!
+    Sets the playbackRate with \a rate.
+*/
+
 void S60VideoPlayerSession::setPlaybackRate(qreal rate)
 {
-    /* 
+    DP0("S60VideoPlayerSession::setPlaybackRate +++");
+
+    DP1("S60VideoPlayerSession::setPlaybackRate - ", rate);
+
+    /*
      * setPlaybackRate is not supported in S60 3.1 and 3.2
      * This flag will be defined for 3.1 and 3.2
     */
@@ -155,10 +191,18 @@ void S60VideoPlayerSession::setPlaybackRate(qreal rate)
         setError(err);
 #endif
 
+    DP0("S60VideoPlayerSession::setPlaybackRate ---");
 }
 
+/*!
+
+   Opens the a Url from \a path for streaming the source.
+*/
+
 void S60VideoPlayerSession::doLoadUrlL(const TDesC &path)
 {
+    DP0("S60VideoPlayerSession::doLoadUrlL +++");
+
 #ifdef HAS_AUDIOROUTING_IN_VIDEOPLAYER
     // m_audioOutput needs to be reinitialized after MapcInitComplete
     if (m_audioOutput)
@@ -167,22 +211,45 @@ void S60VideoPlayerSession::doLoadUrlL(const TDesC &path)
     m_audioOutput = NULL;
 #endif
     m_player->OpenUrlL(path , KUseDefaultIap , KNullDesC8 , KHelixUID);
+
+    DP0("S60VideoPlayerSession::doLoadUrlL ---");
 }
 
+/*!
+
+    Returns the percentage of the video clip loaded.
+*/
+
 int S60VideoPlayerSession::doGetBufferStatusL() const
 {
+ //   DP0("S60VideoPlayerSession::doGetBufferStatusL +++");
+
     int progress = 0;
     m_player->GetVideoLoadingProgressL(progress);
+
+  //  DP0("S60VideoPlayerSession::doGetBufferStatusL ---");
+
     return progress;
 }
 
+/*!
+  Returns the duration of the video sample in microseconds.
+*/
+
 qint64 S60VideoPlayerSession::doGetDurationL() const
 {
+  //  DP0("S60VideoPlayerSession::doGetDurationL");
+
     return m_player->DurationL().Int64() / qint64(1000);
 }
 
+/*!
+ * Sets the \a videooutput for video rendering.
+*/
+
 void S60VideoPlayerSession::setVideoRenderer(QObject *videoOutput)
 {
+    DP0("S60VideoPlayerSession::setVideoRenderer +++");
     if (videoOutput != m_videoOutputControl) {
         if (m_videoOutputDisplay) {
             disconnect(m_videoOutputDisplay);
@@ -207,10 +274,17 @@ void S60VideoPlayerSession::setVideoRenderer(QObject *videoOutput)
         m_videoOutputControl = videoOutput;
         windowHandleChanged();
     }
+
+    DP0("S60VideoPlayerSession::setVideoRenderer ---");
 }
 
+/*!
+ * Apply the pending changes for window.
+*/
 void S60VideoPlayerSession::applyPendingChanges(bool force)
 {
+    DP0("S60VideoPlayerSession::applyPendingChanges +++");
+
     if (   force
         || QMediaPlayer::LoadedMedia == mediaStatus()
         || QMediaPlayer::StalledMedia == mediaStatus()
@@ -280,10 +354,18 @@ void S60VideoPlayerSession::applyPendingChanges(bool force)
         }
         setError(error);
     }
+
+    DP0("S60VideoPlayerSession::applyPendingChanges ---");
 }
 
+/*!
+ * \return TRUE if video is available.
+*/
+
 bool S60VideoPlayerSession::isVideoAvailable()
 {
+    DP0("S60VideoPlayerSession::isVideoAvailable");
+
 #ifdef PRE_S60_50_PLATFORM
     return true; // this is not supported in pre 5th platforms
 #else
@@ -306,8 +388,14 @@ bool S60VideoPlayerSession::isVideoAvailable()
 
 }
 
+/*!
+ * \return TRUE if Audio available.
+*/
+
 bool S60VideoPlayerSession::isAudioAvailable()
 {
+    DP0("S60VideoPlayerSession::isAudioAvailable");
+
     if ( mediaStatus() == QMediaPlayer::LoadingMedia
         || mediaStatus() == QMediaPlayer::UnknownMediaStatus
         || mediaStatus() == QMediaPlayer::NoMedia
@@ -325,23 +413,53 @@ bool S60VideoPlayerSession::isAudioAvailable()
     }
 }
 
+/*!
+    Start or resume playing the current source.
+*/
+
 void S60VideoPlayerSession::doPlay()
 {
+    DP0("S60VideoPlayerSession::doPlay +++");
+
     m_player->Play();
+
+    DP0("S60VideoPlayerSession::doPlay ---");
 }
 
+/*!
+    Pause playing the current source.
+*/
+
 void S60VideoPlayerSession::doPauseL()
 {
+    DP0("S60VideoPlayerSession::doPauseL +++");
+
     m_player->PauseL();
+
+    DP0("S60VideoPlayerSession::doPauseL ---");
 }
 
+/*!
+
+    Stop playing, and reset the play position to the beginning.
+*/
+
 void S60VideoPlayerSession::doStop()
 {
+    DP0("S60VideoPlayerSession::doStop +++");
     m_player->Stop();
+
+    DP0("S60VideoPlayerSession::doStop ---");
 }
 
+/*!
+    Closes the current audio clip (allowing another clip to be opened)
+*/
+
 void S60VideoPlayerSession::doClose()
 {
+    DP0("S60VideoPlayerSession::doClose +++");
+
 #ifdef HAS_AUDIOROUTING_IN_VIDEOPLAYER
     if (m_audioOutput) {
         m_audioOutput->UnregisterObserver(*this);
@@ -355,32 +473,77 @@ void S60VideoPlayerSession::doClose()
 // close will remove the window handle in media clint video.
 // So mark it in pending changes.
     m_pendingChanges |= WindowHandle;
+
+    DP0("S60VideoPlayerSession::doClose ---");
 }
 
+/*!
+ *  Returns the current playback position in microseconds from the start of the clip.
+
+*/
+
 qint64 S60VideoPlayerSession::doGetPositionL() const
 {
+  //  DP0("S60VideoPlayerSession::doGetPositionL");
+
     return m_player->PositionL().Int64() / qint64(1000);
 }
 
+/*!
+    Sets the current playback position to \a microSeconds from the start of the clip.
+*/
+
 void S60VideoPlayerSession::doSetPositionL(qint64 microSeconds)
 {
+ //   DP0("S60VideoPlayerSession::doSetPositionL");
+
     m_player->SetPositionL(TTimeIntervalMicroSeconds(microSeconds));
 }
 
+/*!
+
+    Changes the current playback volume to specified \a value.
+*/
+
 void S60VideoPlayerSession::doSetVolumeL(int volume)
 {
+    DP0("S60VideoPlayerSession::doSetVolumeL +++");
+
+    DP1("S60VideoPlayerSession::doSetVolumeL - ", volume);
+
     m_player->SetVolumeL(volume * m_player->MaxVolume() / 100);
+
+    DP0("S60VideoPlayerSession::doSetVolumeL ---");
 }
 
+/*!
+ * Notification to the client that the opening of the video clip has completed.
+ * If successfull then an \a aError will be ZERO else system wide error.
+*/
+
 void S60VideoPlayerSession::MvpuoOpenComplete(TInt aError)
 {
+    DP0("S60VideoPlayerSession::MvpuoOpenComplete +++");
+
+    DP1("S60VideoPlayerSession::MvpuoOpenComplete - aError:", aError);
+
     setError(aError);
     if (KErrNone == aError)
         m_player->Prepare();
+
+    DP0("S60VideoPlayerSession::MvpuoOpenComplete ---");
 }
 
+/*!
+ * Notification to the client that the opening of the video clip has been preapred.
+ * If successfull then an \a aError will be ZERO else system wide error.
+*/
+
 void S60VideoPlayerSession::MvpuoPrepareComplete(TInt aError)
 {
+    DP0("S60VideoPlayerSession::MvpuoPrepareComplete +++");
+
+    DP1("S60VideoPlayerSession::MvpuoPrepareComplete - aError:", aError);
     TInt error = aError;
     if (KErrNone == error || KErrMMPartialPlayback == error) {
         TSize originalSize;
@@ -407,27 +570,65 @@ void S60VideoPlayerSession::MvpuoPrepareComplete(TInt aError)
     } else {
         setError(error);
     }
+
+    DP0("S60VideoPlayerSession::MvpuoPrepareComplete ---");
 }
 
+/*!
+ * Notification that frame requested by a call to GetFrameL is ready.
+*/
+
 void S60VideoPlayerSession::MvpuoFrameReady(CFbsBitmap &aFrame, TInt aError)
 {
+    DP0("S60VideoPlayerSession::MvpuoFrameReady +++");
+
     Q_UNUSED(aFrame);
     Q_UNUSED(aError);
+
+    DP0("S60VideoPlayerSession::MvpuoFrameReady ---");
 }
 
+/*!
+ * Notification that video playback has completed.
+ * If successfull then \a aError will be ZERO else system wide error.
+ * This not called if playback is explicitly stopped by calling stop.
+*/
+
 void S60VideoPlayerSession::MvpuoPlayComplete(TInt aError)
 {
+    DP0("S60VideoPlayerSession::MvpuoPlayComplete +++");
+
+    DP1("S60VideoPlayerSession::MvpuoPlayComplete - aError", aError);
     endOfMedia();
     setError(aError);
+
+    DP0("S60VideoPlayerSession::MvpuoPlayComplete ---");
 }
 
+
+/*!
+ * General \a event notification from controller.
+ * These events are specified by the supplier of the controller.
+*/
+
 void S60VideoPlayerSession::MvpuoEvent(const TMMFEvent &aEvent)
 {
+    DP0("S60VideoPlayerSession::MvpuoEvent +++");
+
     Q_UNUSED(aEvent);
+
+    DP0("S60VideoPlayerSession::MvpuoEvent ---");
 }
 
+/*!
+
+    Updates meta data entries in the current video clip.
+*/
+
 void S60VideoPlayerSession::updateMetaDataEntriesL()
 {
+    DP0("S60VideoPlayerSession::updateMetaDataEntriesL +++");
+
     metaDataEntries().clear();
     int numberOfMetaDataEntries = 0;
     numberOfMetaDataEntries = m_player->NumberOfMetaDataEntriesL();
@@ -438,52 +639,92 @@ void S60VideoPlayerSession::updateMetaDataEntriesL()
         delete entry;
     }
     emit metaDataChanged();
+
+    DP0("S60VideoPlayerSession::updateMetaDataEntriesL ---");
 }
 
+/*!
+ * Apply the window changes when window handle changes.
+*/
+
 void S60VideoPlayerSession::windowHandleChanged()
 {
+    DP0("S60VideoPlayerSession::windowHandleChanged +++");
+
     m_pendingChanges |= WindowHandle;
     applyPendingChanges();
+
+    DP0("S60VideoPlayerSession::windowHandleChanged ---");
 }
 
+/*!
+ * Apply the window changes when display Rect changes.
+*/
+
 void S60VideoPlayerSession::displayRectChanged()
 {
+    DP0("S60VideoPlayerSession::displayRectChanged +++");
+
     m_pendingChanges |= DisplayRect;
     applyPendingChanges();
+
+    DP0("S60VideoPlayerSession::displayRectChanged ---");
 }
 
+/*!
+ * Apply the window changes when aspect Ratio changes.
+*/
+
 void S60VideoPlayerSession::aspectRatioChanged()
 {
+    DP0("S60VideoPlayerSession::aspectRatioChanged +++");
+
     m_pendingChanges |= ScaleFactors;
     applyPendingChanges();
+
+    DP0("S60VideoPlayerSession::aspectRatioChanged ---");
 }
 
 #ifndef VIDEOOUTPUT_GRAPHICS_SURFACES
 void S60VideoPlayerSession::suspendDirectScreenAccess()
 {
+    DP0("S60VideoPlayerSession::suspendDirectScreenAccess +++");
+
     m_dsaStopped = stopDirectScreenAccess();
+
+    DP0("S60VideoPlayerSession::suspendDirectScreenAccess ---");
 }
 
 void S60VideoPlayerSession::resumeDirectScreenAccess()
 {
+    DP0("S60VideoPlayerSession::resumeDirectScreenAccess +++");
+
     if (!m_dsaStopped)
         return;
     startDirectScreenAccess();
     m_dsaStopped = false;
+
+    DP0("S60VideoPlayerSession::resumeDirectScreenAccess ---");
 }
 
 void S60VideoPlayerSession::startDirectScreenAccess()
 {
+    DP0("S60VideoPlayerSession::startDirectScreenAccess +++");
+
     if (m_dsaActive)
         return;
     TRAPD(err, m_player->StartDirectScreenAccessL());
     if (err == KErrNone)
         m_dsaActive = true;
     setError(err);
+
+    DP0("S60VideoPlayerSession::startDirectScreenAccess ---");
 }
 
 bool S60VideoPlayerSession::stopDirectScreenAccess()
 {
+    DP0("S60VideoPlayerSession::stopDirectScreenAccess");
+
     if (!m_dsaActive)
         return false;
     TRAPD(err, m_player->StopDirectScreenAccessL());
@@ -494,23 +735,58 @@ bool S60VideoPlayerSession::stopDirectScreenAccess()
 }
 #endif
 
+/*!
+ *  The percentage of the temporary buffer filling before playback begins.
+*/
+
 void S60VideoPlayerSession::MvloLoadingStarted()
 {
+    DP0("S60VideoPlayerSession::MvloLoadingStarted +++");
+
     buffering();
+
+    DP0("S60VideoPlayerSession::MvloLoadingStarted ---");
 }
 
+/*!
+ * Buffer is filled with data and to for continuing/start playback.
+*/
+
 void S60VideoPlayerSession::MvloLoadingComplete()
 {
+    DP0("S60VideoPlayerSession::MvloLoadingComplete +++");
+
     buffered();
+
+    DP0("S60VideoPlayerSession::MvloLoadingComplete ---");
 }
 
+/*!
+    Defiens which Audio End point to use.
+
+    \a audioEndpoint audioEndpoint name.
+*/
+
 void S60VideoPlayerSession::doSetAudioEndpoint(const QString& audioEndpoint)
 {
+    DP0("S60VideoPlayerSession::doSetAudioEndpoint +++");
+
+    DP1("S60VideoPlayerSession::doSetAudioEndpoint - ", audioEndpoint);
+
     m_audioEndpoint = audioEndpoint;
+
+    DP0("S60VideoPlayerSession::doSetAudioEndpoint ---");
 }
 
+/*!
+
+    Returns audioEndpoint name.
+*/
+
 QString S60VideoPlayerSession::activeEndpoint() const
 {
+    DP0("S60VideoPlayerSession::activeEndpoint +++");
+
     QString outputName = m_audioEndpoint;
 #ifdef HAS_AUDIOROUTING_IN_VIDEOPLAYER
     if (m_audioOutput) {
@@ -518,11 +794,20 @@ QString S60VideoPlayerSession::activeEndpoint() const
         outputName = qStringFromTAudioOutputPreference(output);
     }
 #endif
+
+    DP1("S60VideoPlayerSession::activeEndpoint- outputName:", outputName);
+    DP0("S60VideoPlayerSession::activeEndpoint ---");
     return outputName;
 }
 
+/*!
+ *  Returns default Audio End point in use.
+*/
+
 QString S60VideoPlayerSession::defaultEndpoint() const
 {
+    DP0("S60VideoPlayerSession::defaultEndpoint +++");
+
     QString outputName = DefaultAudioEndpoint;
 #ifdef HAS_AUDIOROUTING_IN_VIDEOPLAYER
     if (m_audioOutput) {
@@ -530,11 +815,23 @@ QString S60VideoPlayerSession::defaultEndpoint() const
         outputName = qStringFromTAudioOutputPreference(output);
     }
 #endif
+
+    DP1("S60VideoPlayerSession::defaultEndpoint, outputName:", outputName);
+    DP0("S60VideoPlayerSession::defaultEndpoint ---");
+
     return outputName;
 }
 
+/*!
+   Sets active end \a name as an Audio End point.
+*/
+
 void S60VideoPlayerSession::setActiveEndpoint(const QString& name)
 {
+    DP0("S60VideoPlayerSession::setActiveEndpoint +++");
+
+    DP1("S60VideoPlayerSession::setActiveEndpoint - ", name);
+
 #ifdef HAS_AUDIOROUTING_IN_VIDEOPLAYER
     CAudioOutput::TAudioOutputPreference output = CAudioOutput::ENoPreference;
     if (name == DefaultAudioEndpoint)
@@ -552,18 +849,39 @@ void S60VideoPlayerSession::setActiveEndpoint(const QString& name)
         setError(err);
     }
 #endif
+
+    DP0("S60VideoPlayerSession::setActiveEndpoint ---");
 }
+
+/*!
+    The default Audio ouput has been changed.
+
+    \a aAudioOutput Audio Output object.
+
+    \a aNewDefault is CAudioOutput::TAudioOutputPreference.
+*/
+
 #ifdef HAS_AUDIOROUTING_IN_VIDEOPLAYER
 void S60VideoPlayerSession::DefaultAudioOutputChanged( CAudioOutput& aAudioOutput,
                                         CAudioOutput::TAudioOutputPreference aNewDefault)
 {
+    DP0("S60VideoPlayerSession::DefaultAudioOutputChanged +++");
+
     // Emit already implemented in setActiveEndpoint function
     Q_UNUSED(aAudioOutput)
     Q_UNUSED(aNewDefault)
+
+    DP0("S60VideoPlayerSession::DefaultAudioOutputChanged ---");
 }
 
+/*!
+ * \return  CAudioOutput::ENoOutput by converting it to QString.
+*/
+
 QString S60VideoPlayerSession::qStringFromTAudioOutputPreference(CAudioOutput::TAudioOutputPreference output) const
 {
+    DP0("S60VideoPlayerSession::qStringFromTAudioOutputPreference");
+
     if (output == CAudioOutput::ENoPreference)
         return QString("Default");
     else if (output == CAudioOutput::EAll)
@@ -578,9 +896,14 @@ QString S60VideoPlayerSession::qStringFromTAudioOutputPreference(CAudioOutput::T
 }
 #endif //HAS_AUDIOROUTING_IN_VIDEOPLAYER)
 
+/*!
+ * \return TRUE if video is Seekable else FALSE.
+*/
 
 bool S60VideoPlayerSession::getIsSeekable() const
 {
+    DP0("S60VideoPlayerSession::getIsSeekable +++");
+
     bool seekable = ETrue;
     int numberOfMetaDataEntries = 0;
 
@@ -601,6 +924,7 @@ bool S60VideoPlayerSession::getIsSeekable() const
             break;
         }
     }
+    DP0("S60VideoPlayerSession::getIsSeekable ---");
 
     return seekable;
 }
diff --git a/plugins/multimedia/symbian/mmf/mediaplayer/s60videorenderer.cpp b/plugins/multimedia/symbian/mmf/mediaplayer/s60videorenderer.cpp
index 6b433d2cc8..2de6896a0a 100644
--- a/plugins/multimedia/symbian/mmf/mediaplayer/s60videorenderer.cpp
+++ b/plugins/multimedia/symbian/mmf/mediaplayer/s60videorenderer.cpp
@@ -39,28 +39,57 @@
 **
 ****************************************************************************/
 
+#include "DebugMacros.h"
+
 #include "s60videorenderer.h"
 
 #include <QtCore/qcoreevent.h>
 #include <QtGui/qapplication.h>
 
+/*!
+    Constructs a new video renderer media end point with the given \a parent.
+*/
+
 S60VideoRenderer::S60VideoRenderer(QObject *parent)
     : QVideoRendererControl(parent)
 {
+    DP0("S60VideoRenderer::S60VideoRenderer +++");
+
+    DP0("S60VideoRenderer::S60VideoRenderer ---");
+
 }
 
+/*!
+    Destroys a video renderer media end point.
+*/
+
 S60VideoRenderer::~S60VideoRenderer()
 {
+    DP0("S60VideoRenderer::~S60VideoRenderer +++");
+    DP0("S60VideoRenderer::~S60VideoRenderer ---");
 }
 
+/*!
+   \return the surface a video producer renders to.
+*/
 
 QAbstractVideoSurface *S60VideoRenderer::surface() const
 {
+    DP0("S60VideoRenderer::surface");
+
     return m_surface;
 }
 
+/*!
+   Sets the \a surface a video producer renders to.
+*/
+
 void S60VideoRenderer::setSurface(QAbstractVideoSurface *surface)
 {
+    DP0("S60VideoRenderer::setSurface +++");
+
     m_surface = surface;
+
+    DP0("S60VideoRenderer::setSurface ---");
 }
 
diff --git a/plugins/multimedia/symbian/mmf/mediaplayer/s60videosurface.cpp b/plugins/multimedia/symbian/mmf/mediaplayer/s60videosurface.cpp
index 3411565de4..563d33b403 100644
--- a/plugins/multimedia/symbian/mmf/mediaplayer/s60videosurface.cpp
+++ b/plugins/multimedia/symbian/mmf/mediaplayer/s60videosurface.cpp
@@ -39,144 +39,334 @@
 **
 ****************************************************************************/
 
+#include "DebugMacros.h"
+
 #include <qvideosurfaceformat.h>
 
 #include "s60videosurface.h"
+/*!
+ * Constructs a video surface with the given \a parent.
+*/
 
 S60VideoSurface::S60VideoSurface(QObject *parent)
     : QAbstractVideoSurface(parent)
     , m_winId(0)
 {
+    DP0("S60VideoSurface::S60VideoSurface +++");
+    DP0("S60VideoSurface::S60VideoSurface ---");
 }
 
+/*!
+ * Destroys video surface.
+*/
+
 S60VideoSurface::~S60VideoSurface()
 {
-
+    DP0("S60VideoSurface::~S60VideoSurface +++");
+    DP0("S60VideoSurface::~S60VideoSurface ---");
 }
 
+/*!
+    \return the ID of the window a video surface end point renders to.
+*/
+
 WId S60VideoSurface::winId() const
 {
+    DP0("S60VideoSurface::winId");
+
     return m_winId;
 }
 
+/*!
+   Sets the \a id of the window a video surface end point renders to.
+*/
+
 void S60VideoSurface::setWinId(WId id)
 {
+    DP0("S60VideoSurface::setWinId +++");
+
     m_winId = id;
+
+    DP0("S60VideoSurface::setWinId ---");
 }
 
+/*!
+    \return the sub-rect of a window where video is displayed.
+*/
+
 QRect S60VideoSurface::displayRect() const
 {
+    DP0("S60VideoSurface::displayRect");
+
     return m_displayRect;
 }
 
+/*!
+    Sets the sub-\a rect of a window where video is displayed.
+*/
+
 void S60VideoSurface::setDisplayRect(const QRect &rect)
 {
+    DP0("S60VideoSurface::setDisplayRect +++");
+
     m_displayRect = rect;
+
+    DP0("S60VideoSurface::setDisplayRect ---");
 }
 
+/*!
+    \return the brightness adjustment applied to a video surface.
+
+    Valid brightness values range between -100 and 100, the default is 0.
+*/
+
 int S60VideoSurface::brightness() const
 {
+    DP0("S60VideoSurface::brightness");
+
     return 0;
 }
 
+/*!
+    Sets a \a brightness adjustment for a video surface.
+
+    Valid brightness values range between -100 and 100, the default is 0.
+*/
+
 void S60VideoSurface::setBrightness(int brightness)
 {
+    DP0("S60VideoSurface::setBrightness +++");
+
+    DP1("S60VideoSurface::setBrightness - brightness:", brightness);
+
     Q_UNUSED(brightness);
+
+    DP0("S60VideoSurface::setBrightness ---");
 }
 
+/*!
+   \return the contrast adjustment applied to a video surface.
+
+    Valid contrast values range between -100 and 100, the default is 0.
+*/
+
 int S60VideoSurface::contrast() const
 {
+    DP0("S60VideoSurface::contrast");
+
     return 0;
 }
 
+/*!
+    Sets the \a contrast adjustment for a video surface.
+
+    Valid contrast values range between -100 and 100, the default is 0.
+*/
+
 void S60VideoSurface::setContrast(int contrast)
 {
+    DP0("S60VideoSurface::setContrast +++");
+
+    DP1("S60VideoSurface::setContrast - ", contrast);
+
     Q_UNUSED(contrast);
+
+    DP0("S60VideoSurface::setContrast ---");
 }
 
+/*!
+   \return the hue adjustment applied to a video surface.
+
+    Value hue values range between -100 and 100, the default is 0.
+*/
+
 int S60VideoSurface::hue() const
 {
+    DP0("S60VideoSurface::hue");
+
     return 0;
 }
 
+/*!
+    Sets a \a hue adjustment for a video surface.
+
+    Valid hue values range between -100 and 100, the default is 0.
+*/
+
 void S60VideoSurface::setHue(int hue)
 {
+    DP0("S60VideoSurface::setHue +++");
+
+    DP1("S60VideoSurface::setHue - ", hue);
+
     Q_UNUSED(hue);
+
+    DP0("S60VideoSurface::setHue ---");
 }
 
+/*!
+    \return the saturation adjustment applied to a video surface.
+
+    Value saturation values range between -100 and 100, the default is 0.
+*/
+
 int S60VideoSurface::saturation() const
 {
+    DP0("S60VideoSurface::saturation");
+
     return 0;
 }
 
+/*!
+    Sets a \a saturation adjustment for a video surface.
+
+    Valid saturation values range between -100 and 100, the default is 0.
+*/
+
 void S60VideoSurface::setSaturation(int saturation)
 {
+    DP0("S60VideoSurface::setSaturation +++");
+
+    DP1("S60VideoSurface::setSaturation - ", saturation);
+
     Q_UNUSED(saturation);
+
+    DP0("S60VideoSurface::setSaturation ---");
 }
 
+/*!
+ * \return ZERO. \a attribute, \a minimum, \a maximum are not used.
+*/
 int S60VideoSurface::getAttribute(const char *attribute, int minimum, int maximum) const
 {
+    DP0("S60VideoSurface::getAttribute +++");
+
     Q_UNUSED(attribute);
     Q_UNUSED(minimum);
     Q_UNUSED(maximum);
+
+    DP0("S60VideoSurface::getAttribute ---");
+
     return 0;
 }
 
+/*!
+ * Sets the \a attribute, \a minimum, \a maximum.
+ * But never used.
+*/
+
 void S60VideoSurface::setAttribute(const char *attribute, int value, int minimum, int maximum)
 {
+    DP0("S60VideoSurface::setAttribute +++");
+
     Q_UNUSED(attribute);
     Q_UNUSED(value);
     Q_UNUSED(minimum);
     Q_UNUSED(maximum);
 
+    DP0("S60VideoSurface::setAttribute ---");
+
 }
 
+/*!
+ * \return ZERO.
+ * \a value, \a fromLower, \a fromUpper, \a toLower, \a toUpper are never used.
+*/
+
 int S60VideoSurface::redistribute(
         int value, int fromLower, int fromUpper, int toLower, int toUpper)
 {
+    DP0("S60VideoSurface::redistribute +++");
+
     Q_UNUSED(value);
     Q_UNUSED(fromLower);
     Q_UNUSED(fromUpper);
     Q_UNUSED(toLower);
     Q_UNUSED(toUpper);
+
+    DP0("S60VideoSurface::redistribute ---");
+
     return 0;
 }
 
+/*!
+ * \return List of video surface supported Pixel Formats.
+*/
+
 QList<QVideoFrame::PixelFormat> S60VideoSurface::supportedPixelFormats(
         QAbstractVideoBuffer::HandleType handleType) const
 {
+    DP0("S60VideoSurface::supportedPixelFormats +++");
+
     Q_UNUSED(handleType);
     QList<QVideoFrame::PixelFormat> list;
+
+    DP0("S60VideoSurface::supportedPixelFormats ---");
+
     return list;
 }
 
+/*!
+ * \return always FALSE, as \a format never used.
+*/
+
 bool S60VideoSurface::start(const QVideoSurfaceFormat &format)
 {
+    DP0("S60VideoSurface::start");
+
     Q_UNUSED(format);
     return false;
 }
 
+/*!
+ * Stops video surface.
+*/
 void S60VideoSurface::stop()
 {
+    DP0("S60VideoSurface::stop +++");
+
+    DP0("S60VideoSurface::stop ---");
+
 }
 
+/*!
+ * \return always FALS, as \a format is never used.
+*/
 bool S60VideoSurface::present(const QVideoFrame &frame)
 {
+    DP0("S60VideoSurface::present");
+
     Q_UNUSED(frame);
     return false;
 }
 
+/*!
+ * \return always FALSE.
+*/
+
 bool S60VideoSurface::findPort()
 {
+    DP0("S60VideoSurface::findPort");
+
     return false;
 }
 
 void S60VideoSurface::querySupportedFormats()
 {
+    DP0("S60VideoSurface::querySupportedFormats +++");
+
+    DP0("S60VideoSurface::querySupportedFormats ---");
+
 }
 
+/*!
+ * \return always FLASE, as \a format never used.
+*/
+
 bool S60VideoSurface::isFormatSupported(const QVideoSurfaceFormat &format) const
 {
+    DP0("S60VideoSurface::isFormatSupported");
+
     Q_UNUSED(format);
     return false;
 }
diff --git a/plugins/multimedia/symbian/mmf/mmf.pro b/plugins/multimedia/symbian/mmf/mmf.pro
index f8bf3c9965..6b847e95f2 100644
--- a/plugins/multimedia/symbian/mmf/mmf.pro
+++ b/plugins/multimedia/symbian/mmf/mmf.pro
@@ -22,6 +22,7 @@ INCLUDEPATH += . \
     $${SOURCE_DIR}/src/multimedia \
     $${SOURCE_DIR}/src/multimedia/audio \
     $${SOURCE_DIR}/src/multimedia/video \
+    $${SOURCE_DIR}/plugins/multimedia/symbian/mmf/inc \
     $${SOURCE_DIR}
 
 
diff --git a/plugins/multimedia/symbian/mmf/radio/s60radiotunercontrol_31.cpp b/plugins/multimedia/symbian/mmf/radio/s60radiotunercontrol_31.cpp
index faaf3a6953..b7627e3125 100644
--- a/plugins/multimedia/symbian/mmf/radio/s60radiotunercontrol_31.cpp
+++ b/plugins/multimedia/symbian/mmf/radio/s60radiotunercontrol_31.cpp
@@ -39,6 +39,8 @@
 **
 ****************************************************************************/
 
+#include "DebugMacros.h"
+
 #include "s60radiotunercontrol_31.h"
 #include "s60radiotunerservice.h"
 
@@ -65,11 +67,17 @@ S60RadioTunerControl::S60RadioTunerControl(QObject *parent)
     , m_scanning(false)
     , m_vol(50)
 {
-    initRadio();   
+    DP0("S60RadioTunerControl::S60RadioTunerControl +++");
+
+    initRadio();
+
+    DP0("S60RadioTunerControl::S60RadioTunerControl ---");
 }
 
 S60RadioTunerControl::~S60RadioTunerControl()
 {
+    DP0("S60RadioTunerControl::~S60RadioTunerControl +++");
+
 	if (m_tunerUtility) {
 	    m_tunerUtility->Close();
 		m_tunerUtility->CancelNotifyChange();
@@ -80,10 +88,14 @@ S60RadioTunerControl::~S60RadioTunerControl()
 	if (m_audioPlayerUtility) {
 		m_audioPlayerUtility = NULL;
 	}
+
+  DP0("S60RadioTunerControl::~S60RadioTunerControl ---");
 }
 
 bool S60RadioTunerControl::initRadio()
 {
+    DP0("S60RadioTunerControl::initRadio +++");
+
 	m_available = false;
 
 	TRAPD(tunerError, m_tunerUtility = CMMTunerUtility::NewL(*this, CMMTunerUtility::ETunerBandFm, 1, 
@@ -114,12 +126,16 @@ bool S60RadioTunerControl::initRadio()
 	m_tunerUtility->Tune(freq);
 		
 	m_available = true;
-	
+
+  DP0("S60RadioTunerControl::initRadio ---");
+
     return m_available;
 }
 
 void S60RadioTunerControl::start()
 {
+    DP0("S60RadioTunerControl::start +++");
+
 	if (!m_audioInitializationComplete) {
 		TFrequency freq(m_currentFreq);
 		m_tunerUtility->Tune(freq);
@@ -129,29 +145,41 @@ void S60RadioTunerControl::start()
 
 	m_apiTunerState = QRadioTuner::ActiveState;
 	emit stateChanged(m_apiTunerState);
+
+  DP0("S60RadioTunerControl::start ---");
 }
 
 void S60RadioTunerControl::stop()
 {
+    DP0("S60RadioTunerControl::stop +++");
+
     if (m_audioPlayerUtility) {
 		m_audioPlayerUtility->Stop();
 		m_apiTunerState = QRadioTuner::StoppedState;
 		emit stateChanged(m_apiTunerState);
-    }		
+    }
+
+    DP0("S60RadioTunerControl::stop ---");
 }
 
 QRadioTuner::State S60RadioTunerControl::state() const
 {
+    DP0("S60RadioTunerControl::state");
+
     return m_apiTunerState;
 }
 
 QRadioTuner::Band S60RadioTunerControl::band() const
 {
+    DP0("S60RadioTunerControl::band");
+
     return m_currentBand;
 }
 
 bool S60RadioTunerControl::isBandSupported(QRadioTuner::Band b) const
 {
+    DP0("S60RadioTunerControl::isBandSupported");
+
 	if(b == QRadioTuner::FM)
 		return true;
 	else if(b == QRadioTuner::LW)
@@ -166,27 +194,39 @@ bool S60RadioTunerControl::isBandSupported(QRadioTuner::Band b) const
 
 void S60RadioTunerControl::setBand(QRadioTuner::Band b)
 {
-    QRadioTuner::Band tempBand = b; 
+    DP0("S60RadioTunerControl::setBand +++");
+
+    QRadioTuner::Band tempBand = b;
     if (tempBand != m_currentBand) {
         m_currentBand = b;        
         emit bandChanged(m_currentBand);
     }
+
+    DP0("S60RadioTunerControl::setBand ---");
 }
 
 int S60RadioTunerControl::frequency() const
 {
+    DP0("S60RadioTunerControl::frequency");
+
     return m_currentFreq;
 }
 
 void S60RadioTunerControl::setFrequency(int frequency)
 {
+    DP0("S60RadioTunerControl::setFrequency +++");
+
     m_currentFreq = frequency;
     TFrequency freq(m_currentFreq);
     m_tunerUtility->Tune(freq);
+
+    DP0("S60RadioTunerControl::setFrequency ---");
 }
 
 int S60RadioTunerControl::frequencyStep(QRadioTuner::Band b) const
 {
+    DP0("S60RadioTunerControl::frequencyStep +++");
+
     int step = 0;
 
     if(b == QRadioTuner::FM)
@@ -198,11 +238,16 @@ int S60RadioTunerControl::frequencyStep(QRadioTuner::Band b) const
     else if(b == QRadioTuner::SW)
         step = 500; // 500Hz steps
 
+    DP1("S60RadioTunerControl::frequencyStep, Step:", step);
+    DP0("S60RadioTunerControl::frequencyStep ---");
+
     return step;
 }
 
 QPair<int,int> S60RadioTunerControl::frequencyRange(QRadioTuner::Band band) const
 {
+    DP0("S60RadioTunerControl::frequencyRange +++");
+
 	TFrequency bottomFreq;
 	TFrequency topFreq;
 	int bandError = KErrNone;
@@ -212,13 +257,18 @@ QPair<int,int> S60RadioTunerControl::frequencyRange(QRadioTuner::Band band) cons
 		if (!bandError) {
 			return qMakePair<int,int>(bottomFreq.iFrequency, topFreq.iFrequency);
 		}
-	}  
+    }
+
+  DP0("S60RadioTunerControl::frequencyRange ---");
+
    return qMakePair<int,int>(0,0);
 }
 
 CMMTunerUtility::TTunerBand S60RadioTunerControl::getNativeBand(QRadioTuner::Band b) const
 {
-    // api match to native s60 bands    
+    DP0("S60RadioTunerControl::getNativeBand");
+
+    // api match to native s60 bands
     if (b == QRadioTuner::AM)
         return CMMTunerUtility::ETunerBandAm;
     else if (b == QRadioTuner::FM)
@@ -231,27 +281,37 @@ CMMTunerUtility::TTunerBand S60RadioTunerControl::getNativeBand(QRadioTuner::Ban
 
 bool S60RadioTunerControl::isStereo() const
 {
+    DP0("S60RadioTunerControl::isStereo");
+
     return m_isStereo;
 }
 
 QRadioTuner::StereoMode S60RadioTunerControl::stereoMode() const
 {
+    DP0("S60RadioTunerControl::stereoMode");
+
     return m_stereoMode;
 }
 
 void S60RadioTunerControl::setStereoMode(QRadioTuner::StereoMode mode)
 {
+    DP0("S60RadioTunerControl::setStereoMode +++");
+
 	m_stereoMode = mode;
 	if (m_tunerUtility) {	    
 	    if (QRadioTuner::ForceMono == mode)
 	        m_tunerUtility->ForceMonoReception(true);
 	    else 
 	        m_tunerUtility->ForceMonoReception(false);
-	}	
+     }
+
+  DP0("S60RadioTunerControl::setStereoMode ---");
 }
 
 int S60RadioTunerControl::signalStrength() const
 {
+    DP0("S60RadioTunerControl::signalStrength +++");
+
     // return value is a percentage value
     if (m_tunerUtility) {       
         TInt maxSignalStrength;
@@ -267,39 +327,60 @@ int S60RadioTunerControl::signalStrength() const
             }           
         }
     }
+
+    DP1("S60RadioTunerControl::signalStrength, m_signal:", m_signal);
+    DP0("S60RadioTunerControl::signalStrength ---");
+
     return m_signal;
 }
 
 int S60RadioTunerControl::volume() const
 {
+    DP0("S60RadioTunerControl::volume");
+
     return m_vol;
 }
 
 void S60RadioTunerControl::setVolume(int volume)
 {
+    DP0("S60RadioTunerControl::setVolume +++");
+    DP1("S60RadioTunerControl::setVolume: ", volume);
+
     if (m_audioPlayerUtility) {
 		m_vol = volume;
 		TInt error = m_audioPlayerUtility->SetVolume(volume/10);
 		emit volumeChanged(m_vol);
     }
+
+    DP0("S60RadioTunerControl::setVolume ---");
 }
 
 bool S60RadioTunerControl::isMuted() const
 {
+    DP0("S60RadioTunerControl::isMuted");
+
     return m_muted;
 }
 
 void S60RadioTunerControl::setMuted(bool muted)
 {
+    DP0("S60RadioTunerControl::setMuted +++");
+
+    DP1("S60RadioTunerControl::setMuted:", muted);
+
     if (m_audioPlayerUtility && m_audioInitializationComplete) {
         m_muted = muted;
         m_audioPlayerUtility->Mute(m_muted);
         emit mutedChanged(m_muted);           
     }
+
+    DP0("S60RadioTunerControl::setMuted ---");
 }
 
 bool S60RadioTunerControl::isSearching() const
 {
+    DP0("S60RadioTunerControl::isSearching");
+
     if (m_tunerUtility) {
     	TUint32 tempState;
     	m_tunerUtility->GetState(tempState);
@@ -313,39 +394,57 @@ bool S60RadioTunerControl::isSearching() const
 
 void S60RadioTunerControl::cancelSearch()
 {
+    DP0("S60RadioTunerControl::cancelSearch +++");
+
 	m_tunerUtility->CancelRetune();
 	m_scanning = false;
 	emit searchingChanged(false);
+
+  DP0("S60RadioTunerControl::cancelSearch ---");
 }
 
 void S60RadioTunerControl::searchForward()
 {
+    DP0("S60RadioTunerControl::searchForward +++");
+
 	m_scanning = true;
 	setVolume(m_vol);
 	m_tunerUtility->StationSeek(CMMTunerUtility::ESearchDirectionUp);
 	emit searchingChanged(true);
+
+  DP0("S60RadioTunerControl::searchForward ---");
 }
 
 void S60RadioTunerControl::searchBackward()
 {
+    DP0("S60RadioTunerControl::searchBackward +++");
+
 	m_scanning = true;
 	setVolume(m_vol);
 	m_tunerUtility->StationSeek(CMMTunerUtility::ESearchDirectionDown);
 	emit searchingChanged(true);
+
+  DP0("S60RadioTunerControl::searchBackward ---");
 }
 
 bool S60RadioTunerControl::isValid() const
 {
+    DP0("S60RadioTunerControl::isValid");
+
     return m_available;
 }
 
 bool S60RadioTunerControl::isAvailable() const
 {
+    DP0("S60RadioTunerControl::isAvailable");
+
     return m_available;
 }
 
 QtMultimediaKit::AvailabilityError S60RadioTunerControl::availabilityError() const
 {
+    DP0("S60RadioTunerControl::availabilityError");
+
     if (m_available)
         return QtMultimediaKit::NoError;
     else
@@ -354,16 +453,23 @@ QtMultimediaKit::AvailabilityError S60RadioTunerControl::availabilityError() con
 
 QRadioTuner::Error S60RadioTunerControl::error() const
 {
+    DP1("QtMultimediaKit::NoError", m_radioError);
+
     return m_radioError;
 }
 
 QString S60RadioTunerControl::errorString() const
 {
+    DP1("S60RadioTunerControl::errorString", m_errorString);
+
 	return m_errorString;
 }
 
 void S60RadioTunerControl::MToTuneComplete(TInt aError)
 {
+    DP0("S60RadioTunerControl::MToTuneComplete +++");
+    DP1("S60RadioTunerControl::MToTuneComplete, aError:",aError);
+
 	if (aError == KErrNone) {
 		m_scanning = false;
 		m_audioPlayerUtility->Play();
@@ -375,17 +481,25 @@ void S60RadioTunerControl::MToTuneComplete(TInt aError)
 			}
 		}
 	}
+
+    DP0("S60RadioTunerControl::MToTuneComplete ---");
 }
 
 void S60RadioTunerControl::MTcoFrequencyChanged(const TFrequency& aOldFrequency, const TFrequency& aNewFrequency)
 {
+    DP0("S60RadioTunerControl::MTcoFrequencyChanged +++");
+
 	m_currentFreq = aNewFrequency.iFrequency;
 	m_scanning = false;
 	emit frequencyChanged(m_currentFreq);
+
+  DP0("S60RadioTunerControl::MTcoFrequencyChanged ---");
 }
 
 void S60RadioTunerControl::MTcoStateChanged(const TUint32& aOldState, const TUint32& aNewState)
 {
+    DP0("S60RadioTunerControl::MTcoStateChanged +++");
+
 	if (aNewState == CMMTunerUtility::ETunerStateActive) {
 		m_apiTunerState = QRadioTuner::ActiveState;
 	}
@@ -395,44 +509,74 @@ void S60RadioTunerControl::MTcoStateChanged(const TUint32& aOldState, const TUin
 	if (aOldState != aNewState){
 		emit stateChanged(m_apiTunerState);
 	}
+
+  DP0("S60RadioTunerControl::MTcoStateChanged ---");
 }
 
 void S60RadioTunerControl::MTcoAntennaDetached()
 {
+    DP0("S60RadioTunerControl::MTcoAntennaDetached +++");
+
+    DP0("S60RadioTunerControl::MTcoAntennaDetached ---");
+
 	// no actions
 }
 
 void S60RadioTunerControl::MTcoAntennaAttached()
 {
+    DP0("S60RadioTunerControl::MTcoAntennaAttached +++");
+
+    DP0("S60RadioTunerControl::MTcoAntennaAttached ---");
+
 	// no actions
 }
 
 void S60RadioTunerControl::FlightModeChanged(TBool aFlightMode)
 {
+    DP0("S60RadioTunerControl::FlightModeChanged +++");
+
+    DP0("S60RadioTunerControl::FlightModeChanged ---");
+
 	// no actions
 }
 
 void S60RadioTunerControl::MTsoStereoReceptionChanged(TBool aStereo)
 {
+    DP0("S60RadioTunerControl::MTsoStereoReceptionChanged +++");
+    DP1("S60RadioTunerControl::MTsoStereoReceptionChanged, aStereo:", aStereo);
 	m_isStereo = aStereo;
 	emit stereoStatusChanged(aStereo);
+
+  DP0("S60RadioTunerControl::MTsoStereoReceptionChanged ---");
 }
 
 void S60RadioTunerControl::MTsoForcedMonoChanged(TBool aForcedMono)
 {
+    DP0("S60RadioTunerControl::MTsoForcedMonoChanged +++");
+    DP1("S60RadioTunerControl::MTsoForcedMonoChanged, aForcedMono:", aForcedMono);
+
 	if (aForcedMono) {
 		m_stereoMode = QRadioTuner::ForceMono;
 	}
+
+  DP0("S60RadioTunerControl::MTsoForcedMonoChanged ---");
 }
 
 void S60RadioTunerControl::MssoSignalStrengthChanged(TInt aNewSignalStrength)
 {
+    DP0("S60RadioTunerControl::MssoSignalStrengthChanged +++");
+    DP1("S60RadioTunerControl::MssoSignalStrengthChanged, aNewSignalStrength:", aNewSignalStrength);
+
 	m_signal = aNewSignalStrength;
 	emit signalStrengthChanged(m_signal);
+
+  DP0("S60RadioTunerControl::MssoSignalStrengthChanged ---");
 }
 
 void S60RadioTunerControl::MTapoInitializeComplete(TInt aError)
 {
+    DP0("S60RadioTunerControl::MTapoInitializeComplete +++");
+    DP1("S60RadioTunerControl::MTapoInitializeComplete, aError:", aError);
 	if (aError == KErrNone) {
 		m_audioInitializationComplete = true;
 		m_available = true;
@@ -442,10 +586,16 @@ void S60RadioTunerControl::MTapoInitializeComplete(TInt aError)
 	} else if (aError != KErrNone) {
 		m_radioError = QRadioTuner::OpenError;
 	}
+
+  DP0("S60RadioTunerControl::MTapoInitializeComplete ---");
 }
 
 void S60RadioTunerControl::MTapoPlayEvent(TEventType aEvent, TInt aError, TAny* aAdditionalInfo)
 {
+    DP0("S60RadioTunerControl::MTapoPlayEvent +++");
+
+    DP0("S60RadioTunerControl::MTapoPlayEvent ---");
+
 	// no actions
 }
 
diff --git a/plugins/multimedia/symbian/mmf/radio/s60radiotunercontrol_since32.cpp b/plugins/multimedia/symbian/mmf/radio/s60radiotunercontrol_since32.cpp
index 313333128c..991c6b8e49 100644
--- a/plugins/multimedia/symbian/mmf/radio/s60radiotunercontrol_since32.cpp
+++ b/plugins/multimedia/symbian/mmf/radio/s60radiotunercontrol_since32.cpp
@@ -39,6 +39,8 @@
 **
 ****************************************************************************/
 
+#include "DebugMacros.h"
+
 #include "s60radiotunercontrol_since32.h"
 #include "s60radiotunerservice.h"
 
@@ -67,6 +69,7 @@ S60RadioTunerControl::S60RadioTunerControl(QObject *parent)
     , m_volChangeRequired(false)
     , m_signalStrengthTimer(new QTimer(this))
 {
+    DP0("S60RadioTunerControl::S60RadioTunerControl +++");
     bool retValue = initRadio();
     if (!retValue) {
         m_errorString = QString(tr("Initialize Error."));
@@ -74,10 +77,13 @@ S60RadioTunerControl::S60RadioTunerControl(QObject *parent)
     } else {
         connect(m_signalStrengthTimer, SIGNAL(timeout()), this, SLOT(changeSignalStrength()));
     }
+    DP0("S60RadioTunerControl::S60RadioTunerControl ---");
 }
 
 S60RadioTunerControl::~S60RadioTunerControl()
 {
+    DP0("S60RadioTunerControl::~S60RadioTunerControl +++");
+
     if (m_fmTunerUtility) {
         m_fmTunerUtility->Close();
     }
@@ -87,20 +93,27 @@ S60RadioTunerControl::~S60RadioTunerControl()
     }
 
     delete m_radioUtility;
+
+  DP0("S60RadioTunerControl::~S60RadioTunerControl ---");
 }
 
 QRadioTuner::State S60RadioTunerControl::state() const
 {
+    DP0("S60RadioTunerControl::state");
+
     return m_apiTunerState;
 }
 
 QRadioTuner::Band S60RadioTunerControl::band() const
 {
+    DP0("S60RadioTunerControl::band");
+
     return m_currentBand;
 }
 
 bool S60RadioTunerControl::isBandSupported(QRadioTuner::Band b) const
 {
+    DP0("S60RadioTunerControl::isBandSupported");
     if (b == QRadioTuner::FM)
         return true;
     else if (b == QRadioTuner::LW)
@@ -127,6 +140,7 @@ void S60RadioTunerControl::changeSignalStrength()
     }
 void S60RadioTunerControl::setBand(QRadioTuner::Band b)
 {
+    DP0("S60RadioTunerControl::setBand +++");
     QRadioTuner::Band tempBand = b;
     if (tempBand != m_currentBand ) {
         if (isBandSupported(tempBand)){
@@ -159,20 +173,30 @@ void S60RadioTunerControl::setBand(QRadioTuner::Band b)
         }
     }
 
+    DP0("S60RadioTunerControl::setBand ---");
 }
 
 int S60RadioTunerControl::frequency() const
 {
+    DP0("S60RadioTunerControl::frequency");
+
     return m_currentFreq;
 }
 
 void S60RadioTunerControl::setFrequency(int frequency)
 {
+    DP0("S60RadioTunerControl::setFrequency +++");
+    DP1("S60RadioTunerControl::setFrequency, frequency:", frequency);
+
     m_currentFreq = frequency;
     m_fmTunerUtility->SetFrequency(m_currentFreq);
+
+    DP0("S60RadioTunerControl::setFrequency ---");
 }
 int S60RadioTunerControl::frequencyStep(QRadioTuner::Band b) const
 {
+    DP0("S60RadioTunerControl::frequencyStep +++");
+
     int step = 0;
     if (b == QRadioTuner::FM)
         step = 100000; // 100kHz steps
@@ -182,12 +206,16 @@ int S60RadioTunerControl::frequencyStep(QRadioTuner::Band b) const
         step = 1000; // 1kHz steps
     else if(b == QRadioTuner::SW)
         step = 500; // 500Hz steps
+    DP1("S60RadioTunerControl::frequencyStep, Step:", step);
+    DP0("S60RadioTunerControl::frequencyStep ---");
 
     return step;
 }
 
 QPair<int,int> S60RadioTunerControl::frequencyRange(QRadioTuner::Band band) const
 {
+    DP0("S60RadioTunerControl::frequencyRange +++");
+
     int bottomFreq;
     int topFreq;
 
@@ -201,21 +229,29 @@ QPair<int,int> S60RadioTunerControl::frequencyRange(QRadioTuner::Band band) cons
         return qMakePair<int,int>(bottomFreq, topFreq);
     }
 
+    DP0("S60RadioTunerControl::frequencyRange ---");
+
     return qMakePair<int,int>(0,0);
 }
 
 bool S60RadioTunerControl::isStereo() const
 {
+    DP0("S60RadioTunerControl::isStereo");
+
     return m_isStereo;
 }
 
 QRadioTuner::StereoMode S60RadioTunerControl::stereoMode() const
 {
+    DP0("S60RadioTunerControl::stereoMode");
+
     return m_stereoMode;
 }
 
 void S60RadioTunerControl::setStereoMode(QRadioTuner::StereoMode mode)
 {
+    DP0("S60RadioTunerControl::setStereoMode +++");
+
     if (m_fmTunerUtility) {
         if (QRadioTuner::ForceMono == mode) {
             m_fmTunerUtility->ForceMonoReception(true);
@@ -227,10 +263,14 @@ void S60RadioTunerControl::setStereoMode(QRadioTuner::StereoMode mode)
             m_stereoMode = QRadioTuner::ForceStereo;
         }
     }
+
+    DP0("S60RadioTunerControl::setStereoMode ---");
 }
 
 int S60RadioTunerControl::signalStrength() const
 {
+     DP0("S60RadioTunerControl::signalStrength +++");
+
     // return value is a percentage value
     if (m_fmTunerUtility) {
         TInt maxSignalStrength;
@@ -247,16 +287,25 @@ int S60RadioTunerControl::signalStrength() const
             }
         }
     }
+
+    DP1("S60RadioTunerControl::signalStrength, m_signal:", m_signal);
+    DP0("S60RadioTunerControl::signalStrength ---");
+
     return m_signal;
 }
 
 int S60RadioTunerControl::volume() const
 {
+    DP0("S60RadioTunerControl::volume");
+
     return m_vol;
 }
 
 void S60RadioTunerControl::setVolume(int volume)
 {
+    DP0("S60RadioTunerControl::setVolume +++");
+    DP1("S60RadioTunerControl::setVolume, Volume:", volume);
+
     int boundVolume = qBound(0, volume, 100);
 
     if (m_vol == boundVolume )
@@ -273,54 +322,73 @@ void S60RadioTunerControl::setVolume(int volume)
             emit volumeChanged(boundVolume);
         }
     }
+    DP0("S60RadioTunerControl::setVolume ---");
 }
 
 bool S60RadioTunerControl::isMuted() const
 {
+    DP0("S60RadioTunerControl::isMuted");
+
     return m_muted;
 }
 
 void S60RadioTunerControl::setMuted(bool muted)
 {
+    DP0("S60RadioTunerControl::setMuted +++");
+    DP1("S60RadioTunerControl::setMuted, Muted:", muted);
     if (m_playerUtility) {
         m_muted = muted;
         m_playerUtility->Mute(m_muted);
     }
+  DP0("S60RadioTunerControl::setMuted ---");
 }
 
 bool S60RadioTunerControl::isSearching() const
 {
+    DP0("S60RadioTunerControl::isSearching");
+
     return m_scanning;
 }
 
 void S60RadioTunerControl::cancelSearch()
 {
+    DP0("S60RadioTunerControl::cancelSearch +++");
+
     m_fmTunerUtility->CancelStationSeek();
     m_scanning = false;
     emit searchingChanged(false);
+
+  DP0("S60RadioTunerControl::cancelSearch ---");
 }
 
 void S60RadioTunerControl::searchForward()
 {
+    DP0("S60RadioTunerControl::searchForward +++");
     m_fmTunerUtility->StationSeek(true);
     m_scanning = true;
     emit searchingChanged(m_scanning);
+  DP0("S60RadioTunerControl::searchForward ---");
 }
 
 void S60RadioTunerControl::searchBackward()
 {
+    DP0("S60RadioTunerControl::searchBackward +++");
     m_fmTunerUtility->StationSeek(false);
     m_scanning = true;
     emit searchingChanged(m_scanning);
+  DP0("S60RadioTunerControl::searchBackward ---");
 }
 
 bool S60RadioTunerControl::isValid() const
 {
+    DP0("S60RadioTunerControl::isValid");
+
     return m_available;
 }
 
 bool S60RadioTunerControl::initRadio()
 {
+    DP0("S60RadioTunerControl::initRadio +++");
     m_available = false;
     // create an instance of Radio Utility factory and indicate
     // FM Radio is a primary client
@@ -341,16 +409,21 @@ bool S60RadioTunerControl::initRadio()
     m_tunerControl = false;
 
     m_available = true;
+  DP1("S60RadioTunerControl::initRadio, m_available:", m_available);
+  DP0("S60RadioTunerControl::initRadio ---");
     return m_available;
 }
 
 bool S60RadioTunerControl::isAvailable() const
 {
+    DP0("S60RadioTunerControl::isAvailable");
+
     return m_available;
 }
 
 QtMultimediaKit::AvailabilityError S60RadioTunerControl::availabilityError() const
 {
+    DP0("S60RadioTunerControl::availabilityError");
     if (m_available)
         return QtMultimediaKit::NoError;
     else
@@ -359,6 +432,7 @@ QtMultimediaKit::AvailabilityError S60RadioTunerControl::availabilityError() con
 
 void S60RadioTunerControl::start()
 {
+    DP0("S60RadioTunerControl::start +++");
     if (!m_tunerControl) {
         m_fmTunerUtility->RequestTunerControl();
     } else {
@@ -366,27 +440,35 @@ void S60RadioTunerControl::start()
     }
     m_signalStrengthTimer->start(3000);
 
+  DP0("S60RadioTunerControl::start ---");
 }
 
 void S60RadioTunerControl::stop()
 {
+    DP0("S60RadioTunerControl::stop +++");
     if (m_playerUtility) {
         m_playerUtility->Stop();
     }
     m_signalStrengthTimer->stop();
+   DP0("S60RadioTunerControl::stop ---");
 }
 
 QRadioTuner::Error S60RadioTunerControl::error() const
 {
+    DP1("S60RadioTunerControl::error", m_radioError);
+
     return m_radioError;
 }
 QString S60RadioTunerControl::errorString() const
 {
+    DP1("S60RadioTunerControl::errorString", m_errorString);
+
     return m_errorString;
 }
 
 void S60RadioTunerControl::MrpoStateChange(TPlayerState aState, TInt aError)
 {
+    DP0("S60RadioTunerControl::MrpoStateChange +++");
     if (aError == KErrNone){
         m_radioError = QRadioTuner::NoError;
         if (aState == ERadioPlayerIdle) {
@@ -402,10 +484,13 @@ void S60RadioTunerControl::MrpoStateChange(TPlayerState aState, TInt aError)
         m_apiTunerState = QRadioTuner::StoppedState;
     }
     emit stateChanged(m_apiTunerState);
+  DP0("S60RadioTunerControl::MrpoStateChange ---");
 }
 
 void S60RadioTunerControl::MrpoVolumeChange(TInt aVolume)
 {
+    DP0("S60RadioTunerControl::MrpoVolumeChange +++");
+    DP1("S60RadioTunerControl::MrpoVolumeChange, aVolume:", aVolume);
     m_vol = (aVolume/m_volMultiplier);
     if (!m_volChangeRequired) {
         emit volumeChanged(m_vol);
@@ -413,22 +498,31 @@ void S60RadioTunerControl::MrpoVolumeChange(TInt aVolume)
     } else {
         m_volChangeRequired = false;
     }
-
+    DP0("S60RadioTunerControl::MrpoVolumeChange ---");
 }
 
 void S60RadioTunerControl::MrpoMuteChange(TBool aMute)
 {
+    DP0("S60RadioTunerControl::MrpoMuteChange +++");
+    DP1("S60RadioTunerControl::MrpoMuteChange, aMute:", aMute);
     m_muted = aMute;
     emit mutedChanged(m_muted);
+  DP0("S60RadioTunerControl::MrpoMuteChange ---");
 }
 
 void S60RadioTunerControl::MrpoBalanceChange(TInt aLeftPercentage, TInt aRightPercentage)
 {
+    DP0("S60RadioTunerControl::MrpoBalanceChange +++");
+
+    DP0("S60RadioTunerControl::MrpoBalanceChange ---");
+
     // no actions
 }
 
 void S60RadioTunerControl::MrftoRequestTunerControlComplete(TInt aError)
 {
+    DP0("S60RadioTunerControl::MrftoRequestTunerControlComplete +++");
+    DP1("S60RadioTunerControl::MrftoRequestTunerControlComplete, aError:", aError);
     if (aError == KErrNone) {
         m_playerUtility->GetMaxVolume(m_maxVolume);
         m_volMultiplier = float(m_maxVolume)/float(100);
@@ -461,10 +555,13 @@ void S60RadioTunerControl::MrftoRequestTunerControlComplete(TInt aError)
         emit error(m_radioError);
     }
 
+  DP0("S60RadioTunerControl::MrftoRequestTunerControlComplete ---");
 }
 
 void S60RadioTunerControl::MrftoSetFrequencyRangeComplete(TInt aError)
 {
+    DP0("S60RadioTunerControl::MrftoSetFrequencyRangeComplete +++");
+    DP1("S60RadioTunerControl::MrftoSetFrequencyRangeComplete, aError:", aError);
     if (aError == KFmRadioErrFrequencyOutOfBandRange || KFmRadioErrFrequencyNotValid) {
         m_radioError = QRadioTuner::OutOfRangeError;
         m_errorString = QString(tr("Frequency Out of Band Range or Frequency Not Valid"));
@@ -474,10 +571,13 @@ void S60RadioTunerControl::MrftoSetFrequencyRangeComplete(TInt aError)
         m_errorString = QString(tr("Hardware failure or RadioInOfflineMode"));
         emit error(m_radioError);
     }
+  DP0("S60RadioTunerControl::MrftoSetFrequencyRangeComplete ---");
 }
 
 void S60RadioTunerControl::MrftoSetFrequencyComplete(TInt aError)
 {
+    DP0("S60RadioTunerControl::MrftoSetFrequencyComplete +++");
+    DP1("S60RadioTunerControl::MrftoSetFrequencyComplete, aError", aError);
     if (aError == KErrNone) {
         m_radioError = QRadioTuner::NoError;
     } else if (aError == KFmRadioErrFrequencyOutOfBandRange || KFmRadioErrFrequencyNotValid) {
@@ -489,10 +589,13 @@ void S60RadioTunerControl::MrftoSetFrequencyComplete(TInt aError)
         m_errorString = QString("Hardware failure or Radio In Offline Mode");
         emit error(m_radioError);
     }
+  DP0("S60RadioTunerControl::MrftoSetFrequencyComplete ---");
 }
 
 void S60RadioTunerControl::MrftoStationSeekComplete(TInt aError, TInt aFrequency)
 {
+    DP0("S60RadioTunerControl::MrftoStationSeekComplete +++");
+    DP3("S60RadioTunerControl::MrftoStationSeekComplete, aError:", aError, " Frequency:", aFrequency);
     m_scanning = false;
     if (aError == KErrNone) {
         m_radioError = QRadioTuner::NoError;
@@ -504,34 +607,50 @@ void S60RadioTunerControl::MrftoStationSeekComplete(TInt aError, TInt aFrequency
         m_errorString = QString("Scanning Error");
         emit error(m_radioError);
     }
+  DP0("S60RadioTunerControl::MrftoStationSeekComplete ---");
 }
 
 void S60RadioTunerControl::MrftoFmTransmitterStatusChange(TBool aActive)
 {
+    DP0("S60RadioTunerControl::MrftoFmTransmitterStatusChange +++");
+
+    DP0("S60RadioTunerControl::MrftoFmTransmitterStatusChange ---");
+
     //no actions
 }
 
 void S60RadioTunerControl::MrftoAntennaStatusChange(TBool aAttached)
 {
+    DP0("S60RadioTunerControl::MrftoAntennaStatusChange +++");
+    DP1("S60RadioTunerControl::MrftoAntennaStatusChange, aAttached:", aAttached);
     if (aAttached && m_tunerControl) {
         m_playerUtility->Play();
     }
+  DP0("S60RadioTunerControl::MrftoAntennaStatusChange ---");
 }
 
 void S60RadioTunerControl::MrftoOfflineModeStatusChange(TBool /*aOfflineMode*/)
 {
+    DP0("S60RadioTunerControl::MrftoOfflineModeStatusChange +++");
+
+    DP0("S60RadioTunerControl::MrftoOfflineModeStatusChange ---");
+
 
 }
 
 void S60RadioTunerControl::MrftoFrequencyRangeChange(TFmRadioFrequencyRange aBand /*, TInt aMinFreq, TInt aMaxFreq*/)
 {
+    DP0("S60RadioTunerControl::MrftoFrequencyRangeChange +++");
     if (aBand == EFmRangeEuroAmerica) {
         setBand(QRadioTuner::FM);
     }
+  DP0("S60RadioTunerControl::MrftoFrequencyRangeChange ---");
 }
 
 void S60RadioTunerControl::MrftoFrequencyChange(TInt aNewFrequency)
 {
+    DP0("S60RadioTunerControl::MrftoFrequencyChange +++");
+    DP1("S60RadioTunerControl::MrftoFrequencyChange, aNewFrequency:", aNewFrequency);
     m_currentFreq = aNewFrequency;
     emit frequencyChanged(m_currentFreq);
 
@@ -540,19 +659,27 @@ void S60RadioTunerControl::MrftoFrequencyChange(TInt aNewFrequency)
         emit signalStrengthChanged(signal);
         m_signal = signal;
     }
+  DP0("S60RadioTunerControl::MrftoFrequencyChange ---");
 }
 
 void S60RadioTunerControl::MrftoForcedMonoChange(TBool aForcedMono)
 {
+    DP0("S60RadioTunerControl::MrftoForcedMonoChange +++");
+    DP1("S60RadioTunerControl::MrftoForcedMonoChange, aForcedMono:", aForcedMono);
     if (aForcedMono) {
         m_stereoMode = QRadioTuner::ForceMono;
     } else {
         m_stereoMode = QRadioTuner::ForceStereo;
     }
     emit stereoStatusChanged(!aForcedMono);
+  DP0("S60RadioTunerControl::MrftoForcedMonoChange ---");
 }
 
 void S60RadioTunerControl::MrftoSquelchChange(TBool aSquelch)
 {
+    DP0("S60RadioTunerControl::MrftoSquelchChange");
+
+    DP1("S60RadioTunerControl::MrftoSquelchChange, aSquelch:", aSquelch);
+
     // no actions
 }
diff --git a/plugins/multimedia/symbian/mmf/radio/s60radiotunerservice.cpp b/plugins/multimedia/symbian/mmf/radio/s60radiotunerservice.cpp
index 4c462ccea9..99b0bf0d28 100644
--- a/plugins/multimedia/symbian/mmf/radio/s60radiotunerservice.cpp
+++ b/plugins/multimedia/symbian/mmf/radio/s60radiotunerservice.cpp
@@ -39,22 +39,34 @@
 **
 ****************************************************************************/
 
+#include "DebugMacros.h"
+
 #include "s60radiotunerservice.h"
 
 
 S60RadioTunerService::S60RadioTunerService(QObject *parent)
     : QMediaService(parent)
 {
+    DP0("S60RadioTunerService::S60RadioTunerService +++");
+
 	m_playerControl = new S60RadioTunerControl(this);
+
+  DP0("S60RadioTunerService::S60RadioTunerService ---");
 }
 
 S60RadioTunerService::~S60RadioTunerService()
 {
+    DP0("S60RadioTunerService::~S60RadioTunerService +++");
+
 	delete m_playerControl;
+
+  DP0("S60RadioTunerService::~S60RadioTunerService ---");
 }
 
 QMediaControl *S60RadioTunerService::requestControl(const char* name)
 {
+    DP0("S60RadioTunerService::requestControl");
+
 	if (qstrcmp(name, QRadioTunerControl_iid) == 0)
 		return m_playerControl;
 
@@ -63,5 +75,9 @@ QMediaControl *S60RadioTunerService::requestControl(const char* name)
 
 void S60RadioTunerService::releaseControl(QMediaControl *control)
 {
+    DP0("S60RadioTunerService::releaseControl +++");
+
 	Q_UNUSED(control);
+
+  DP0("S60RadioTunerService::releaseControl ---");
 }