--- a/khronosfws/openmax_al/bwins/openmaxalu.def	Mon May 03 12:59:52 2010 +0300
+++ b/khronosfws/openmax_al/bwins/openmaxalu.def	Fri Apr 30 19:18:45 2010 -0500
@@ -42,4 +42,6 @@
 	XA_IID_VIDEOENCODERCAPABILITIES @ 41 NONAME
 	XA_IID_VIDEOPOSTPROCESSING @ 42 NONAME
 	XA_IID_VOLUME @ 43 NONAME
+	XA_IID_NOKIALINEARVOLUME @ 44 NONAME
+	XA_IID_NOKIAVOLUMEEXT @ 45 NONAME
 

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/khronosfws/openmax_al/data/openmaxal.cfg	Fri Apr 30 19:18:45 2010 -0500
@@ -0,0 +1,62 @@
+#/*
+#* Copyright (c) 2009 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: 
+#*
+#*/
+#============================================================================>|
+# Must not exceed 80 chars each line=========================================>|
+#============================================================================>|
+<mediaplayer>
+<mmf>
+<urischeme>
+# Num of entries followed by actual entries all ending with a comma
+3,file,http,rtsp,
+</urischeme>
+<fileext>
+15,3gp,wma,wmv,wav,amr,mp3,mp4,rm,ra,avi,mkv,aac,mid,awb,3g2,
+</fileext>
+</mmf>
+
+<gst>
+<urischeme>
+# Num of entries followed by actual entries all ending with a comma
+0,
+</urischeme>
+<fileext>
+0,
+</fileext>
+</gst>
+</mediaplayer>
+
+<mediarecorder>
+#<mmf>
+#<urischeme>
+# Num of entries followed by actual entries all ending with a comma
+#1,file,
+#</urischeme>
+#<fileext>
+#2,amr,mp4,
+#</fileext>
+#</mmf>
+
+<gst>
+<urischeme>
+# Num of entries followed by actual entries all ending with a comma
+1,file,
+</urischeme>
+<fileext>
+3,wav,amr,mp4,
+</fileext>
+</gst>
+</mediarecorder>
\ No newline at end of file

--- a/khronosfws/openmax_al/eabi/openmaxalu.def	Mon May 03 12:59:52 2010 +0300
+++ b/khronosfws/openmax_al/eabi/openmaxalu.def	Fri Apr 30 19:18:45 2010 -0500
@@ -42,4 +42,6 @@
 	XA_IID_VIDEOENCODERCAPABILITIES @ 41 NONAME DATA 4
 	XA_IID_VIDEOPOSTPROCESSING @ 42 NONAME DATA 4
 	XA_IID_VOLUME @ 43 NONAME DATA 4
+	XA_IID_NOKIALINEARVOLUME @ 44 NONAME DATA 4
+	XA_IID_NOKIAVOLUMEEXT @ 45 NONAME DATA 4
 

--- a/khronosfws/openmax_al/group/bld.inf	Mon May 03 12:59:52 2010 +0300
+++ b/khronosfws/openmax_al/group/bld.inf	Fri Apr 30 19:18:45 2010 -0500
@@ -26,6 +26,8 @@
 #ifdef FF_OPENMAX_AL
 ../data/openmax_al_stub.sis /epoc32/data/z/system/install/openmax_al_stub.sis
 ../rom/openmax_al.iby       CORE_MW_LAYER_IBY_EXPORT_PATH(openmax_al.iby)
+../data/openmaxal.cfg       /epoc32/winscw/c/openmaxal/openmaxal.cfg
+
 #endif
 
 PRJ_MMPFILES

--- a/khronosfws/openmax_al/group/openmaxal.mmp	Mon May 03 12:59:52 2010 +0300
+++ b/khronosfws/openmax_al/group/openmaxal.mmp	Fri Apr 30 19:18:45 2010 -0500
@@ -31,47 +31,53 @@
 CAPABILITY ALL -TCB
 
 MACRO   USE_NGA_SURFACES
-//MACRO   _GSTREAMER_BACKEND_
+//MACRO 	MARKERPOSITIONTIMERLOG
+//MACRO		POSITIONUPDATETIMERLOG
+//MACRO 	USE_LOCAL_WINDOW_RESOURCES
+//MACRO           PROFILE_TIME
+//MACRO           PRINT_TO_CONSOLE_TIME_DIFF
 
-#ifdef _GSTREAMER_BACKEND_
-SOURCEPATH      ../Src/adaptation
-SOURCE	XAAdaptationContextBase.c
-SOURCE	XAAudioEncoderItfAdaptation.c
-SOURCE	XACameraAdaptCtx.c
-SOURCE	XACameraItfAdaptation.c
-SOURCE	XADeviceVolumeItfAdaptation.c
-SOURCE	XADynamicSourceItfAdaptation.c
-SOURCE	XAEngineAdaptCtx.c
-SOURCE	XAEqualizerItfAdaptation.c
-SOURCE	XAImageControlsItfAdaptation.c
-SOURCE	XAImageEffectsItfAdaptation.c
-SOURCE	XAImageEncoderItfAdaptation.c
-SOURCE	XALEDArrayAdaptCtx.c
-SOURCE	XALEDArrayItfAdaptation.c
-SOURCE	XAMediaPlayerAdaptCtx.c
-SOURCE	XAMediaRecorderAdaptCtx.c
-SOURCE	XAMetadataAdaptation.c
-SOURCE	XAMetadataAdaptCtx.c
-SOURCE	XAOutputMixAdaptCtx.c
-SOURCE	XAOutputMixItfAdaptation.c
-SOURCE	XAPlaybackRateItfAdaptation.c
-SOURCE	XAPlayItfAdaptation.c
-SOURCE	XARadioAdaptCtx.c
-SOURCE	XARadioItfAdaptation.c
-SOURCE	XARDSItfAdaptation.c
-SOURCE	XARecordItfAdaptation.c
-SOURCE	XASeekItfAdaptation.c
-SOURCE	XASnapShotItfAdaptation.c
-SOURCE	XAStaticCameraCapsAdaptation.c
-SOURCE	XAStaticCapsAdaptation.c
-SOURCE	XAVibraAdaptCtx.c
-SOURCE	XAVibraItfAdaptation.c
-SOURCE	XAVideoEncoderItfAdaptation.c
-SOURCE	XAVideoPostProsessingItfAdaptation.c
-SOURCE	XAVolumeItfAdaptation.c
-// 9.2 only (Exclude on other platforms)
-SOURCE  XANGAVideoSink.cpp
-#endif
+SOURCEPATH      ../src/gst_adaptation
+SOURCE	        xaadaptationgst.c
+SOURCE 	        xagstcapabilitiesmgr.c
+SOURCE	        xaaudioencoderitfadaptation.c
+SOURCE	        xacameraadaptctx.c
+SOURCE	        xacameraitfadaptation.c
+SOURCE	        xadevicevolumeitfadaptation.c
+SOURCE	        xadynamicsourceitfadaptation.c
+SOURCE	        xaengineadaptctx.c
+SOURCE	        xaequalizeritfadaptation.c
+SOURCE	        xaimagecontrolsitfadaptation.c
+SOURCE	        xaimageeffectsitfadaptation.c
+SOURCE	        xaimageencoderitfadaptation.c
+SOURCE	        xaledarrayadaptctx.c
+SOURCE	        xaledarrayitfadaptation.c
+SOURCE	        xamediaplayeradaptctx.c
+SOURCE	        xamediarecorderadaptctx.c
+SOURCE	        xametadataadaptation.c
+SOURCE	        xametadataadaptctx.c
+SOURCE	        xaoutputmixadaptctx.c
+SOURCE	        xaoutputmixitfadaptation.c
+SOURCE	        xaplaybackrateitfadaptation.c
+SOURCE	        xaplayitfadaptation.c
+SOURCE	        xaradioadaptctx.c
+SOURCE	        xaradioitfadaptation.c
+SOURCE	        xardsitfadaptation.c
+SOURCE	        xarecorditfadaptation.c
+SOURCE	        xaseekitfadaptation.c
+SOURCE	        xasnapshotitfadaptation.c
+SOURCE	        xastaticcameracapsadaptation.c
+SOURCE	        xavibraadaptctx.c
+SOURCE	        xavibraitfadaptation.c
+SOURCE	        xavideoencoderitfadaptation.c
+SOURCE	        xavideopostprosessingitfadaptation.c
+SOURCE	        xavolumeitfadaptation.c
+SOURCE 	        xastreaminformationitfadaptation.c
+
+SOURCEPATH ../src/adptcommon
+SOURCE 	        xaframeworkmgr.c
+SOURCE 	        xacapabilitiesmgr.c
+SOURCE 	        xaadptbasectx.c
 
 SOURCEPATH      ../src/camera
 SOURCE          xacameradevice.c
@@ -93,6 +99,11 @@
 SOURCE          xathreadsafety.c
 SOURCE          xavideopostprocessingitf.c
 SOURCE          xavolumeitf.c
+SOURCE 		xastreaminformationitf.c
+SOURCE          xanokialinearvolume_iid.c
+SOURCE          xanokiavolumeext_iid.c
+SOURCE          xanokialinearvolumeitf.c
+SOURCE          xanokiavolumeextitf.c
 
 SOURCEPATH      ../src/engine
 SOURCE          xaaudiodecodercapabilitiesitf.c
@@ -133,34 +144,45 @@
 
 SOURCEPATH      ../src/outputmix
 SOURCE          xaoutputmix.c
-SOURCE		    xaoutputmixitf.c
+SOURCE		xaoutputmixitf.c
 
 SOURCEPATH      ../src/radio
 SOURCE          xaradiodevice.c
-SOURCE		    xaradioitf.c
-SOURCE		    xardsitf.c
+SOURCE		xaradioitf.c
+SOURCE		xardsitf.c
 
 SOURCEPATH      ../src/vibra
 SOURCE          xavibradevice.c
-SOURCE		    xavibraitf.c
+SOURCE		xavibraitf.c
 
 SOURCEPATH      ../src/mmf_adaptation
-SOURCE	xaengineadaptctxmmf.c
-SOURCE	xamediaplayeradaptctxmmf.c
-SOURCE	xaplayitfadaptationmmf.c
-SOURCE	xaadaptationcontextbasemmf.c
-SOURCE  cmmfbackendengine.cpp
-SOURCE  xamediarecorderadaptctxmmf.c
-SOURCE  xarecorditfadaptationmmf.c
-SOURCE 	sfmrlocaltimer.cpp
+//	Removing below file since currently there is no Engine related
+// 	mmf adaptation
+//SOURCE          xaengineadaptctxmmf.c
+SOURCE	        xamediaplayeradaptctxmmf.c
+SOURCE	        xaplayitfadaptationmmf.c
+SOURCE	        xaadaptationmmf.c
+SOURCE          cmmfbackendengine.cpp
+SOURCE          xamediarecorderadaptctxmmf.c
+SOURCE          xarecorditfadaptationmmf.c
+SOURCE 	        sfmrlocaltimer.cpp
+SOURCE          xanokialinearvolumeitfadaptationmmf.c
+SOURCE          xanokiavolumeextitfadaptationmmf.c
+SOURCE 	        xammfcapabilitiesmgr.c
+//SOURCE          xangavideosink.cpp
+SOURCE          markerpositiontimer.cpp
+SOURCE          positionupdatetimer.cpp 
+SOURCE          xaseekitfadaptationmmf.c
+SOURCE          xadynamicsourceitfadaptationmmf.c
+SOURCE 	        xastreaminformationitfadaptationmmf.c
+SOURCE  	cmetadatautilityitf.cpp
+SOURCE		xametadataadaptctxmmf.c
 
 USERINCLUDE     ../inc
 USERINCLUDE     ../src
 USERINCLUDE     ../src/khronos
 USERINCLUDE     ../src/mmf_adaptation
-#ifdef _GSTREAMER_BACKEND_
-USERINCLUDE     ../Src/adaptation
-#endif
+USERINCLUDE     ../src/gst_adaptation
 USERINCLUDE     ../src/camera
 USERINCLUDE     ../src/common
 USERINCLUDE     ../src/engine
@@ -170,19 +192,18 @@
 USERINCLUDE     ../src/outputmix
 USERINCLUDE     ../src/radio
 USERINCLUDE     ../src/vibra
+USERINCLUDE	../src/adptcommon
 
 MW_LAYER_SYSTEMINCLUDE
 OS_LAYER_LIBC_SYSTEMINCLUDE
 OS_LAYER_GLIB_SYSTEMINCLUDE
 SYSTEMINCLUDE /epoc32/include/platform/mw/khronos 
-// 9.2
-#ifdef _GSTREAMER_BACKEND_
+
 SYSTEMINCLUDE  	/sf/mw/gstreamer/include/gstreamer
 SYSTEMINCLUDE  	/sf/mw/gstreamer/include/gstreamer/gst
 SYSTEMINCLUDE  	/sf/mw/gstreamer/include/gstreamer/gst/interfaces
 SYSTEMINCLUDE  	/sf/mw/gstreamer/include/gstreamer/gst/app
 SYSTEMINCLUDE  	/sf/mw/gstreamer/include/gstreamer/gst/video
-#endif
 
 LIBRARY         euser.lib
 LIBRARY         libc.lib
@@ -191,23 +212,21 @@
 
 LIBRARY         mediaclientvideodisplay.lib
 LIBRARY         ws32.lib
-LIBRARY			inetprotutil.lib
+LIBRARY		inetprotutil.lib
 LIBRARY         mediaclientaudio.lib
 LIBRARY         MMFControllerFramework.lib
 LIBRARY         mediaclientvideo.lib
-
-#ifdef _GSTREAMER_BACKEND_
+LIBRARY         AudioInputRouting.lib
 LIBRARY         libgmodule.lib
 LIBRARY         libgobject.lib
 LIBRARY         libgstreamer.lib
 LIBRARY         libgstapp.lib
-LIBRARY		    libgstphotography.lib
-LIBRARY 	    libgstinterfaces.lib 
-LIBRARY		    libgstvideo.lib
-LIBRARY 	    libgstbase.lib
-LIBRARY 	    libgstcoreelements.lib
-LIBRARY		    libgstcoreindexers.lib
-#endif 
+LIBRARY		libgstphotography.lib
+LIBRARY 	libgstinterfaces.lib 
+LIBRARY		libgstvideo.lib
+LIBRARY 	libgstbase.lib
+LIBRARY 	libgstcoreelements.lib
+LIBRARY		libgstcoreindexers.lib
+LIBRARY 	MetaDataUtility.lib
+STATICLIBRARY   hxmetadatautil.lib
 
-
-

--- a/khronosfws/openmax_al/inc/openmaxalwrapper.h	Mon May 03 12:59:52 2010 +0300
+++ b/khronosfws/openmax_al/inc/openmaxalwrapper.h	Fri Apr 30 19:18:45 2010 -0500
@@ -23,5 +23,7 @@
 #define XA_API __declspec(dllexport)
  
 #include <OpenMAXAL.h>
+#include <xanokiavolumeextitf.h>
+#include <xanokialinearvolumeitf.h>
 
 #endif

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/khronosfws/openmax_al/inc/profileutilmacro.h	Fri Apr 30 19:18:45 2010 -0500
@@ -0,0 +1,132 @@
+/*
+* Copyright (c) 2009 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: 
+*
+*/
+
+#ifndef PROFILEUTILMACRO_H
+#define PROFILEUTILMACRO_H
+/*
+// MACROS to be defined to use profiling
+PROFILE_TIME
+PROFILE_RAM_USAGE
+PROFILE_HEAP_USAGE
+PRINT_TO_CONSOLE_TIME_DIFF
+PRINT_TO_CONSOLE_RAM_DIFF
+PRINT_TO_CONSOLE_HEAP_DIFF
+*/
+
+#if defined(PROFILE_TIME) || defined(PROFILE_RAM_USAGE) || defined(PROFILE_HEAP_USAGE)
+#include <e32debug.h>
+#include <hal.h>
+#endif
+
+#ifdef PROFILE_TIME
+#define TAG_TIME_PROFILING_BEGIN \
+    TTime beginProfilingTime; \
+    beginProfilingTime.HomeTime()
+
+#define TAG_TIME_PROFILING_BEGIN_NO_VAR_DEF \
+    beginProfilingTime.HomeTime()
+
+#define TAG_TIME_PROFILING_END \
+    TTime endProfilingTime; \
+    endProfilingTime.HomeTime(); \
+    TTimeIntervalMicroSeconds diffInMicroSecs = endProfilingTime.MicroSecondsFrom(beginProfilingTime)
+
+#define TAG_TIME_PROFILING_END_NO_VAR_DEF \
+    endProfilingTime.HomeTime(); \
+    diffInMicroSecs = endProfilingTime.MicroSecondsFrom(beginProfilingTime)
+
+#define PRINT_TO_CONSOLE_TIME_DIFF \
+    RDebug::Printf("VPROFILEDAT: %s : Time taken[%u]microseconds ", __PRETTY_FUNCTION__, diffInMicroSecs.Int64())
+
+#define PRINT_TO_CONSOLE_HOME_TIME \
+    TTime homeTime; \
+    homeTime.HomeTime(); \
+    RDebug::Printf("VPROFILEDAT: %s : Home Time [%u]microseconds ", __PRETTY_FUNCTION__, homeTime.Int64())
+
+#define PRINT_TO_CONSOLE_HOME_TIME_NO_VAR_DEF \
+    homeTime.HomeTime(); \
+    RDebug::Printf("VPROFILEDAT: %s : Home Time [%u]microseconds ", __PRETTY_FUNCTION__, homeTime.Int64())
+
+#else /* Empty macros */
+#define TAG_TIME_PROFILING_BEGIN
+#define TAG_TIME_PROFILING_BEGIN_NO_VAR_DEF
+#define TAG_TIME_PROFILING_END
+#define TAG_TIME_PROFILING_END_NO_VAR_DEF
+#define PRINT_TO_CONSOLE_TIME_DIFF
+#define PRINT_TO_CONSOLE_HOME_TIME
+#define PRINT_TO_CONSOLE_HOME_TIME_NO_VAR_DEF
+#endif /*PROFILE_TIME*/
+
+#ifdef PROFILE_RAM_USAGE
+#define TAG_RAM_PROFILING_BEGIN \
+    TInt beginProfilingRAM; \
+    TInt err1 = HAL::Get(HALData::EMemoryRAMFree, beginProfilingRAM)
+
+#define TAG_RAM_PROFILING_END \
+    TInt endProfilingRAM; \
+    TInt err2 = HAL::Get(HALData::EMemoryRAMFree, endProfilingRAM)
+
+#define PRINT_TO_CONSOLE_RAM_DIFF \
+    if ((err1 == KErrNone) && (err2 == KErrNone)) \
+        { \
+        TInt diffRAM = (beginProfilingRAM - endProfilingRAM); \
+        if ( diffRAM > 0 ) \
+            { \
+            RDebug::Printf("VPROFILEDAT: %s : RAM used[%u]bytes ", __PRETTY_FUNCTION__, diffRAM); \
+            } \
+        else \
+            { \
+            RDebug::Printf("VPROFILEDAT: %s : RAM freed[%u]bytes ", __PRETTY_FUNCTION__, (-diffRAM)); \
+            } \
+        } \
+    else \
+        { \
+        RDebug::Printf("VPROFILEDAT: %s : Error1[%d] Error2[%d] ", __PRETTY_FUNCTION__, err1, err2); \
+        }
+
+#else /* Empty macros */
+#define TAG_RAM_PROFILING_BEGIN
+#define TAG_RAM_PROFILING_END
+#define PRINT_TO_CONSOLE_RAM_DIFF
+#endif /*PROFILE_RAM_USAGE*/
+
+#ifdef PROFILE_HEAP_USAGE
+#define TAG_DEFAULT_HEAP_PROFILING_BEGIN \
+    TInt beginProfilingHEAPBiggestBlock; \
+    TInt beginProfilingHEAP = User::Available(beginProfilingHEAPBiggestBlock) \
+
+#define TAG_DEFAULT_HEAP_PROFILING_END \
+    TInt endProfilingHEAPBiggestBlock; \
+    TInt endProfilingHEAP = User::Available(endProfilingHEAPBiggestBlock) \
+
+#define PRINT_TO_CONSOLE_HEAP_DIFF \
+    TInt diffHEAP = beginProfilingHEAP - endProfilingHEAP; \
+    if ( diffHEAP > 0 ) \
+        { \
+        RDebug::Printf("VPROFILEDAT: %s : HEAP used[%u]bytes ", __PRETTY_FUNCTION__, diffHEAP); \
+        } \
+    else \
+        { \
+        RDebug::Printf("VPROFILEDAT: %s : HEAP freed[%u]bytes ", __PRETTY_FUNCTION__, (-diffHEAP)); \
+        }
+#else /* Empty macros */
+#define TAG_DEFAULT_HEAP_PROFILING_BEGIN
+#define TAG_DEFAULT_HEAP_PROFILING_END
+#define PRINT_TO_CONSOLE_HEAP_DIFF
+#endif /*PROFILE_HEAP_USAGE*/
+
+#endif /* PROFILEUTILMACRO_H */

--- a/khronosfws/openmax_al/rom/openmax_al.iby	Mon May 03 12:59:52 2010 +0300
+++ b/khronosfws/openmax_al/rom/openmax_al.iby	Fri Apr 30 19:18:45 2010 -0500
@@ -29,6 +29,7 @@
 
 //OpenMAX_AL_Stub
 data=ZSYSTEM/install/openmax_al_stub.sis         System/Install/openmax_al_stub.sis
+data=/epoc32/winscw/c/openmaxal/openmaxal.cfg           openmaxal/openmaxal.cfg
 
 #endif //FF_OPENMAX_AL
 

--- a/khronosfws/openmax_al/sis/openmax_al.pkg	Mon May 03 12:59:52 2010 +0300
+++ b/khronosfws/openmax_al/sis/openmax_al.pkg	Fri Apr 30 19:18:45 2010 -0500
@@ -11,7 +11,7 @@
 ;
 ; Contributors:
 ;
-; Description: OpenMAX AL - UDEB build
+; Description: OpenMAX AL - UREL build
 ;
 ;File: openmax_al.pkg
 
@@ -31,5 +31,6 @@
 :"Nokia"
 
 ;Files To Copy...<src> <destination>
-"/epoc32/release/armv5/udeb/openmaxal.dll"         -"!:/sys/bin/openmaxal.dll"
+"/epoc32/release/armv5/urel/openmaxal.dll"         -"!:/sys/bin/openmaxal.dll"
+"../data/openmaxal.cfg"                             -   "c:/openmaxal/openmaxal.cfg"
 

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/khronosfws/openmax_al/sis/openmax_al_udeb.pkg	Fri Apr 30 19:18:45 2010 -0500
@@ -0,0 +1,36 @@
+;
+; Copyright (c) 2009 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: OpenMAX AL - UDEB build
+;
+;File: openmax_al.pkg
+
+;Languages
+&EN
+
+;Header
+#{"OpenMax_AL"},(0x10207CAF),1,0,0, TYPE=SA, RU
+
+;Series 60 v5.0
+[0x101F7961], 0,0,0, {"Series60ProductID"}
+
+;Localised Vendor name
+%{"Nokia"}
+
+;Unique Vendor name
+:"Nokia"
+
+;Files To Copy...<src> <destination>
+"/epoc32/release/armv5/udeb/openmaxal.dll"          -   "!:/sys/bin/openmaxal.dll"
+"../data/openmaxal.cfg"                             -   "c:/openmaxal/openmaxal.cfg"
+

--- a/khronosfws/openmax_al/sis/openmax_al_urel.pkg	Mon May 03 12:59:52 2010 +0300
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,35 +0,0 @@
-;
-; Copyright (c) 2009 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: OpenMAX AL - UREL build
-;
-;File: openmax_al.pkg
-
-;Languages
-&EN
-
-;Header
-#{"OpenMax_AL"},(0x10207CAF),1,0,0, TYPE=SA, RU
-
-;Series 60 v5.0
-[0x101F7961], 0,0,0, {"Series60ProductID"}
-
-;Localised Vendor name
-%{"Nokia"}
-
-;Unique Vendor name
-:"Nokia"
-
-;Files To Copy...<src> <destination>
-"/epoc32/release/armv5/urel/openmaxal.dll"         -"!:/sys/bin/openmaxal.dll"
-

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/khronosfws/openmax_al/src/adptcommon/xaadptbasectx.c	Fri Apr 30 19:18:45 2010 -0500
@@ -0,0 +1,260 @@
+/*
+* Copyright (c) 2009 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: 
+*
+*/
+
+#include <assert.h>
+#include <string.h>
+#include "xaadptbasectx.h"
+#include "xathreadsafety.h"
+
+/*
+ * XAAdaptationBaseCtx* XAAdaptationBase_Create()
+ * 1st phase initialization function for Adaptation Base context structure.
+ * Reserves memory for base context and initializes GStreamer FW.
+ */
+XAresult XAAdaptationBase_Init( XAAdaptationBaseCtx* pSelf, XAuint32 ctxId )
+{
+    DEBUG_API("->XAAdaptationBase_Init");
+
+    if ( pSelf )
+    {
+    if(!pSelf->evtHdlrs)
+        {
+        pSelf->evtHdlrs = g_array_new (FALSE, FALSE, sizeof (XAAdaptEvtHdlr));
+        if(!pSelf->evtHdlrs)
+            {
+            DEBUG_ERR("Memory allocation failure in Base Ctx.")
+            return XA_RESULT_MEMORY_FAILURE;
+            }
+        }
+    pSelf->ctxId = ctxId;
+    }
+    else
+    {
+        DEBUG_ERR("Invalid Adaptation Base Context.")
+        return XA_RESULT_PARAMETER_INVALID;
+    }
+
+    DEBUG_API("<-XAAdaptationBase_Init");
+    return XA_RESULT_SUCCESS;
+}
+
+/*
+ * XAresult XAAdaptationBase_PostInit()
+ * 2nd phase initialization for Adaptation Base.
+ */
+XAresult XAAdaptationBase_PostInit( XAAdaptationBaseCtx* ctx )
+{
+    XAresult ret = XA_RESULT_SUCCESS;
+    DEBUG_API("->XAAdaptationBase_PostInit");
+    DEBUG_API("<-XAAdaptationBase_PostInit");
+    return ret;
+}
+
+/*
+ * void XAAdaptationBase_Free( XAAdaptationBaseCtx* ctx )
+ * Frees all Base context variables .
+ */
+void XAAdaptationBase_Free( XAAdaptationBaseCtx* ctx )
+{
+    g_array_free(ctx->evtHdlrs, TRUE);
+    ctx->evtHdlrs = NULL;
+    DEBUG_API("<-XAAdaptationBase_Free");
+}
+
+/*
+ * XAresult XAAdaptationBase_AddEventHandler
+ * Adds event handler for certain event types.
+ */
+XAresult XAAdaptationBase_AddEventHandler( XAAdaptationBaseCtx* ctx, xaAdaptEventHandler evtHandler,
+                                    XAuint32 evtTypes, void *pHandlerCtx )
+{
+    XAuint32 i;
+    XAAdaptEvtHdlr tmp;
+    DEBUG_API("->XAAdaptationBase_AddEventHandler");
+    if(!ctx)
+    {
+        DEBUG_ERR("no context");
+        return XA_RESULT_PARAMETER_INVALID;
+    }
+
+    for(i=0; i<ctx->evtHdlrs->len; i++)
+    {
+        if( (g_array_index(ctx->evtHdlrs, XAAdaptEvtHdlr, i)).handlerfunc == evtHandler )
+        {
+            return XA_RESULT_PARAMETER_INVALID;
+        }
+    }
+    tmp.handlerfunc = evtHandler;
+    tmp.handlercontext = pHandlerCtx;
+    tmp.eventtypes = evtTypes;
+    g_array_append_val(ctx->evtHdlrs, tmp);
+    DEBUG_API("<-XAAdaptationBase_AddEventHandler");
+    return XA_RESULT_SUCCESS;
+}
+
+/*
+ * XAresult XAAdaptationBase_RemoveEventHandler
+ * Removes event handler for certain event types.
+ */
+XAresult XAAdaptationBase_RemoveEventHandler( XAAdaptationBaseCtx* ctx, xaAdaptEventHandler evtHandler)
+{
+    XAuint32 i;
+    DEBUG_API("->XAAdaptationBase_RemoveEventHandler");
+    if(!ctx)
+    {
+        DEBUG_ERR("no context");
+        return XA_RESULT_PARAMETER_INVALID;
+    }
+    for(i=0; i<ctx->evtHdlrs->len; i++)
+    {
+        if( (g_array_index(ctx->evtHdlrs, XAAdaptEvtHdlr, i)).handlerfunc == evtHandler )
+        {
+            g_array_remove_index(ctx->evtHdlrs, i);
+            return XA_RESULT_SUCCESS;
+        }
+    }
+    DEBUG_API("<-XAAdaptationBase_RemoveEventHandler");
+    /*did not find, return error*/
+    return XA_RESULT_PARAMETER_INVALID;
+}
+
+void XAAdaptationBase_SendAdaptEvents(XAAdaptationBaseCtx* ctx, XAAdaptEvent* event)
+{
+    XAuint32 i;
+    XAAdaptEvtHdlr* tmp;
+    for(i=0; i<ctx->evtHdlrs->len; i++)
+    {
+        tmp = &g_array_index(ctx->evtHdlrs, XAAdaptEvtHdlr, i);
+        if( tmp->eventtypes & event->eventtype )
+        {
+            (tmp->handlerfunc)(tmp->handlercontext, event);
+        }
+    }
+}
+
+/*
+ * XAresult XAEqualizerItfAdapt_ThreadEntry(XAAdaptationGstCtx *adapCtx)
+ * Description: Safety thread entry
+ */
+XAresult XAAdaptationBase_ThreadEntry(XAAdaptationBaseCtx *adaptCtx)
+{
+    XAresult res = XA_RESULT_SUCCESS;
+    DEBUG_API("->XAAdaptationBase_ThreadEntry");
+    if(!adaptCtx )
+    {
+        DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
+        DEBUG_API("<-XAAdaptationBase_ThreadEntry");
+        /* invalid parameter */
+        return XA_RESULT_PARAMETER_INVALID;
+
+    }
+    
+    switch(adaptCtx->ctxId)
+        {
+        case XAMediaPlayerAdaptation:
+            XA_IMPL_THREAD_SAFETY_ENTRY(XATSMediaPlayer);
+            break;
+        case XAMediaRecorderAdaptation:
+            XA_IMPL_THREAD_SAFETY_ENTRY(XATSMediaRecorder);
+            break;
+        case XARadioAdaptation:
+            XA_IMPL_THREAD_SAFETY_ENTRY(XATSRadio);
+            break;
+        case XACameraAdaptation:
+            XA_IMPL_THREAD_SAFETY_ENTRY(XATSCamera);
+            break;
+        case XAOutputMixAdaptation:
+            XA_IMPL_THREAD_SAFETY_ENTRY(XATSOutputMix);
+            break;
+        case XAVibraAdaptation:
+            XA_IMPL_THREAD_SAFETY_ENTRY(XATSVibra);
+            break;
+        case XALedArrayAdaptation:
+            XA_IMPL_THREAD_SAFETY_ENTRY(XATSLEDArray);
+            break;
+        case XAMDAdaptation:
+            XA_IMPL_THREAD_SAFETY_ENTRY(XATSMetaDataExtractor);
+            break;
+        case XAEngineAdaptation:
+            XA_IMPL_THREAD_SAFETY_ENTRY(XATSEngine);
+            break;
+        default:
+            DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
+            /* invalid parameter */
+            res = XA_RESULT_PARAMETER_INVALID;
+            break;
+        }
+
+    DEBUG_API("<-XAAdaptationBase_ThreadEntry");
+    return res;
+}
+/*
+ * XAresult XAEqualizerItfAdapt_ThreadExit(XAAdaptationGstCtx *adaptCtx)
+ * Description: Safety thread exit
+ */
+XAresult XAAdaptationBase_ThreadExit(XAAdaptationBaseCtx *adaptCtx)
+{
+    XAresult res = XA_RESULT_SUCCESS;
+    DEBUG_API("->XAAdaptationBase_ThreadExit");
+    if(!adaptCtx )
+    {
+        DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
+        DEBUG_API("<-XAAdaptationBase_ThreadExit");
+        /* invalid parameter */
+        return XA_RESULT_PARAMETER_INVALID;
+
+    }
+
+    switch(adaptCtx->ctxId)
+        {
+        case XAMediaPlayerAdaptation:
+            XA_IMPL_THREAD_SAFETY_EXIT(XATSMediaPlayer);
+            break;
+        case XAMediaRecorderAdaptation:
+            XA_IMPL_THREAD_SAFETY_EXIT(XATSMediaRecorder);
+            break;
+        case XARadioAdaptation:
+            XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
+            break;
+        case XACameraAdaptation:
+            XA_IMPL_THREAD_SAFETY_EXIT(XATSCamera);
+            break;
+        case XAOutputMixAdaptation:
+            XA_IMPL_THREAD_SAFETY_EXIT(XATSOutputMix);
+            break;
+        case XAVibraAdaptation:
+            XA_IMPL_THREAD_SAFETY_EXIT(XATSVibra);
+            break;
+        case XALedArrayAdaptation:
+            XA_IMPL_THREAD_SAFETY_EXIT(XATSLEDArray);
+            break;
+        case XAMDAdaptation:
+            XA_IMPL_THREAD_SAFETY_EXIT(XATSMetaDataExtractor);
+            break;
+        case XAEngineAdaptation:
+            XA_IMPL_THREAD_SAFETY_EXIT(XATSEngine);
+            break;
+        default:
+            DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
+            /* invalid parameter */
+            res = XA_RESULT_PARAMETER_INVALID;
+            break;
+        }
+
+    DEBUG_API("<-XAAdaptationBase_ThreadExit");
+    return res;
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/khronosfws/openmax_al/src/adptcommon/xaadptbasectx.h	Fri Apr 30 19:18:45 2010 -0500
@@ -0,0 +1,168 @@
+/*
+* Copyright (c) 2009 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: 
+*
+*/
+
+#ifndef XAADPTBASECTX_H_
+#define XAADPTBASECTX_H_
+
+#include <glib.h>
+#include "openmaxalwrapper.h"
+#include "xaglobals.h"
+#include "xaframeworkmgr.h"
+#include "xacapabilitiesmgr.h"
+#include "xaplatform.h"
+/* ENUMERATIONS */
+
+/**
+GLOBAL ENUMERATIONS
+ */
+
+typedef enum {
+    XAMediaPlayerAdaptation = 0,
+    XAMediaRecorderAdaptation,
+    XARadioAdaptation,
+    XACameraAdaptation,
+    XAOutputMixAdaptation,
+    XAVibraAdaptation,
+    XALedArrayAdaptation,
+    XAMDAdaptation,
+    XAEngineAdaptation
+}AdaptationContextIDS;
+
+#define XA_ADAPT_PU_INTERVAL 50                     /* position update interval */
+#define XA_ADAPT_ASYNC_TIMEOUT 3000                 /* timeout to wait async events */
+#define XA_ADAPT_ASYNC_TIMEOUT_SHORT 1000           /* timeout to wait async events */
+#define XA_ADAPT_ASYNC_TIMEOUT_SHORT_NSEC 1000000   /* timeout to wait async events */
+
+#define XA_ADAPT_POSITION_UPDATE_EVT 0xf0           /* position update event */
+#define XA_ADAPT_SNAPSHOT_TAKEN 0xf1                /* snapshot taken event */
+#define XA_ADAPT_SNAPSHOT_INITIATED 0xf2            /* snapshot intitiated event */
+#define XA_ADAPT_MDE_TAGS_AVAILABLE 0xf3            /* metadata taglist changed */
+#define XA_ADAPT_OMIX_DEVICESET_CHANGED 0xf4        /* Output mix device changed event */
+#define XA_ADAPT_RADIO_FREQUENCY_CHANGED 0xf6       /* Radio frequency changed event */
+#define XA_ADAPT_RADIO_FREQUENCY_RANGE_CHANGED 0xf7 /* Radio frequency range changed event */
+#define XA_ADAPT_RADIO_SEEK_COMPLETE 0xf8           /* Radio seek complete changed event */
+#define XA_ADAPT_RDS_GET_ODA_GROUP_DONE 0xf9        /* RDS get oda group done event */
+#define XA_ADAPT_BUFFERING 0xfa
+#define XA_ADAPT_MDE_TAGS_WRITTEN 0xfb
+/* TYPEDEFS */
+
+#define RADIO_DEFAULT_FREQ_RANGE XA_FREQRANGE_FMEUROAMERICA
+#define RADIO_DEFAULT_FREQ 88000000
+
+
+/* TYPEDEFS */
+
+/* Adaptation device IDs */
+//#define XA_ADAPTID_ALSASRC          0xAD7E5001  //Krishna commented
+#define XA_ADAPTID_DEVSOUNDSRC          0xAD7E5001
+//#define XA_ADAPTID_ALSASINK         0xAD7E5002
+#define XA_ADAPTID_DEVSOUNDSINK     0xAD7E5002
+#define XA_ADAPTID_AUTOAUDIOSINK    0xAD7E5003
+#define XA_ADAPTID_AUDIOTESTSRC     0xAD7E5004
+#define XA_ADAPTID_AUTOVIDEOSINK    0xAD7E5005
+#define XA_ADAPTID_VIDEOTESTSRC     0xAD7E5006
+#define XA_ADAPTID_V4L2SRC          0xAD7E5007
+#define XA_ADAPTID_JACKSINK         0xAD7E5008
+#define XA_ADAPTID_MOTIONJPEG       0xAD7E5009
+#define XA_ADAPTID_THEORA           0xAD7E500A
+#define XA_ADAPTID_VORBIS           0xAD7E500B
+
+#define XA_ADAPTID_VIBRA            0xAD7E500C
+#define XA_ADAPTID_LEDARRAY         0xAD7E500D
+
+#define XA_ADAPTID_RAWVIDEO         0xAD7E500E
+
+//#define XA_ADAPT_DEFAULTAUDIOOUTPUT XA_ADAPTID_ALSASINK
+#define XA_ADAPT_DEFAULTAUDIOOUTPUT XA_ADAPTID_DEVSOUNDSINK
+
+#ifdef XA_USE_TEST_PLUGINS
+#define XA_ADAPT_DEFAULTAUDIOINPUT  XA_ADAPTID_AUDIOTESTSRC
+#else
+#define XA_ADAPT_DEFAULTAUDIOINPUT  XA_ADAPTID_DEVSOUNDSRC
+#endif
+
+
+#define XA_ADAPT_OGGPROFILE_UNKNOWN 0x1
+
+#define XA_ADAPT_PCMSAMPLEFORMAT_SUPPORTED_8   0x1
+#define XA_ADAPT_PCMSAMPLEFORMAT_SUPPORTED_16  0x2
+#define XA_ADAPT_PCMSAMPLEFORMAT_SUPPORTED_20  0x4
+#define XA_ADAPT_PCMSAMPLEFORMAT_SUPPORTED_24  0x8
+#define XA_ADAPT_PCMSAMPLEFORMAT_SUPPORTED_28  0x10
+#define XA_ADAPT_PCMSAMPLEFORMAT_SUPPORTED_32  0x20
+
+#define XA_ADAPT_MAX_BITRATE_COUNT 10
+
+#define XA_ADAPTID_UNINITED 0
+
+#define XA_ADAPT_VOLUME_VOLUME_CHANGED          0xfb			 /* volume changed */
+#define XA_ADAPT_VOLUME_MUTE_CHANGED            0xfc         	/* mute changed */
+#define XA_ADAPT_VULOME_STEREOPOSITION_CHANGED  0xfd
+
+/* Adaptation event structure */
+typedef struct XAAdaptEvent_
+{
+    XAAdaptEventTypes  eventtype; /* what kind of event, e.g. playitf event  */
+    XAuint8            eventid;   /* eventtype-specific event, e.g. XA_PLAYEVENT macro */
+    XAuint32           datasize;  /* event data size */
+    void*              data;      /* event data if needed */
+} XAAdaptEvent;
+
+/* Forward declaration of adaptation basecontext */
+typedef struct XAAdaptationBaseCtx_ XAAdaptationBaseCtx;
+
+/*
+ * Structure that holds all common variables for every
+ * Gst-Adaptation context structures.
+ */
+typedef struct XAAdaptationBaseCtx_
+{
+/*     Common Variables for all adaptation elements */
+    XAuint32        ctxId;
+    GArray*         evtHdlrs;     /*array of event handlers */
+    FrameworkMap*   fwkmapper;
+    FWMgrFwType     fwtype;
+    XACapabilities* capslist;
+    
+} XAAdaptationBaseCtx_;
+
+
+/* Adaptation event callback */
+typedef void (*xaAdaptEventHandler) ( void *pHandlerCtx, XAAdaptEvent* event );
+
+typedef struct XAAdaptEvtHdlr_
+{
+    xaAdaptEventHandler handlerfunc;    /* function handling the callback */
+    void               *handlercontext; /* context of handler */
+    XAuint32            eventtypes;     /* what kind of events this handles */
+} XAAdaptEvtHdlr;
+
+
+
+
+/* FUNCTIONS */
+XAresult XAAdaptationBase_Init( XAAdaptationBaseCtx* pSelf, XAuint32 ctxId );
+XAresult XAAdaptationBase_PostInit( XAAdaptationBaseCtx* ctx );
+XAresult XAAdaptationBase_AddEventHandler( XAAdaptationBaseCtx* ctx, xaAdaptEventHandler evtHandler,
+                                    XAuint32 evtTypes,void *pHandlerCtx );
+XAresult XAAdaptationBase_RemoveEventHandler( XAAdaptationBaseCtx* ctx, xaAdaptEventHandler evtHandler );
+void XAAdaptationBase_SendAdaptEvents(XAAdaptationBaseCtx* ctx, XAAdaptEvent* event);
+XAresult XAAdaptationBase_ThreadEntry(XAAdaptationBaseCtx *adaptCtx);
+XAresult XAAdaptationBase_ThreadExit(XAAdaptationBaseCtx *adaptCtx);
+void XAAdaptationBase_Free( XAAdaptationBaseCtx* ctx );
+
+#endif /* XAADPTBASE_H_ */

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/khronosfws/openmax_al/src/adptcommon/xacapabilitiesmgr.c	Fri Apr 30 19:18:45 2010 -0500
@@ -0,0 +1,525 @@
+/*
+* Copyright (c) 2009 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:
+*
+*/
+
+#include "xacapabilitiesmgr.h"
+#include "xammfcapabilitiesmgr.h"
+#include "xagstcapabilitiesmgr.h"
+#include <stdio.h>
+#include <string.h>
+
+static XAresult XACapabilitiesMgr_GetAudioInputDeviceCapabilities(XACapabilities **ppNode);
+static XAresult XACapabilitiesMgr_GetAudioOutputDeviceCapabilities(XACapabilities **ppNode);
+
+/* XAresult XAGSTCapabilitiesMgr_UpdateAudioIOCapabilitieList
+ * Description: Update the capabilities list supported by GStreamer framework.
+ */
+XAresult XACapabilitiesMgr_UpdateAudioIOCapabilitieList(
+                FrameworkMap *frameworkMap,
+                XACapabilities **ppListHead)
+
+{
+    XAresult res = XA_RESULT_SUCCESS;
+    XACapabilities *lastNode;
+    XACapabilities *firstNode ;
+    XACapabilities *newNode = NULL;
+    
+    if(!frameworkMap || !ppListHead)
+    {
+        res = XA_RESULT_PARAMETER_INVALID;
+        return res;
+    }
+    
+     lastNode = *ppListHead;
+     firstNode = *ppListHead;
+     
+
+    DEBUG_API("->XACapabilitiesMgr_UpdateAudioIOCapabilitieList");
+
+
+
+    /* traverse and point to the last node in the list */
+    while(lastNode && lastNode->next)
+    {
+        lastNode = lastNode->next;
+    }
+
+    /* If no input devices are supported, the function returns
+     * XA_RESULT_SUCCESS and newNode will be NULL*/
+    newNode = NULL;
+    res = XACapabilitiesMgr_GetAudioInputDeviceCapabilities(&newNode);
+    if (res != XA_RESULT_SUCCESS)
+        {
+        return res;
+        }
+    
+    if (lastNode)
+    {
+        lastNode->next = newNode;
+    }
+    if (newNode)
+    { /* if a new node is created move lastNode to the new item */
+        if (!firstNode)
+            firstNode = newNode;
+        lastNode = newNode;
+    }
+    
+    /* If no input devices are supported, the function returns
+     * XA_RESULT_SUCCESS and newNode will be NULL*/
+    newNode = NULL;
+    res = XACapabilitiesMgr_GetAudioOutputDeviceCapabilities(&newNode);
+    if (res != XA_RESULT_SUCCESS)
+        {
+        return res;
+        }
+    
+    if (lastNode)
+    {
+        lastNode->next = newNode;
+    }
+    if (newNode)
+    { /* if a new node is created move lastNode to the new item */
+        if (!firstNode)
+            firstNode = newNode;
+        lastNode = newNode;
+    }
+    /* if empty list, then append first node as the head */
+    if (!(*ppListHead))
+        {
+        *ppListHead = firstNode;
+        }
+    DEBUG_API("<-XACapabilitiesMgr_UpdateAudioIOCapabilitieList");
+    return res;
+}
+
+XAresult XACapabilitiesMgr_CreateCapabilitieList(
+            FrameworkMap* frameworkMap,
+            XACapabilities** ppListHead)
+{
+    XACapabilities* list = NULL;
+    XAresult res = XA_RESULT_SUCCESS;
+    if(!ppListHead)
+    {
+        res = XA_RESULT_PARAMETER_INVALID;
+        return res;
+    }
+
+    *ppListHead = NULL;
+
+    res = XACapabilitiesMgr_UpdateAudioIOCapabilitieList(frameworkMap, &list);
+    if (res != XA_RESULT_SUCCESS)
+    {
+        XACapabilitiesMgr_DeleteCapabilitieList(&list);
+        return res;
+    }
+    
+    res = XAGSTCapabilitiesMgr_UpdateCapabilitieList(frameworkMap, &list);
+    if (res != XA_RESULT_SUCCESS)
+    {
+        XACapabilitiesMgr_DeleteCapabilitieList(&list);
+        return res;
+    }
+
+    res = XAMMFCapabilitiesMgr_UpdateCapabilitieList(frameworkMap, &list);
+    if (res != XA_RESULT_SUCCESS)
+    {
+        XACapabilitiesMgr_DeleteCapabilitieList(&list);
+        return res;
+    }
+
+    *ppListHead = list;
+    return res;
+}
+
+XAresult XACapabilitiesMgr_DeleteCapabilitieList(XACapabilities** ppListHead)
+{
+    XACapabilities* currNode = NULL;
+    XACapabilities* nextNode = NULL;
+    XAresult res = XA_RESULT_SUCCESS;
+    
+    if(!ppListHead)
+    {
+        res = XA_RESULT_PARAMETER_INVALID;
+        return res;
+    }
+
+    currNode = *ppListHead;
+    while (currNode)
+    {
+        if (currNode->capsType == AUD_I)
+        {
+            XAAudioInputDescriptor* entries = (XAAudioInputDescriptor*)currNode->pEntry;
+            XAint32 i;
+            for(i=0;i< currNode->noOfEntries;i++)
+            {
+                free(entries[i].samplingRatesSupported);
+                free(entries[i].deviceName);
+            }
+            free(entries);
+        }
+        else if (currNode->capsType == AUD_O)
+        {
+            XAAudioOutputDescriptor* entries = (XAAudioOutputDescriptor*)currNode->pEntry;
+            XAint32 i;
+            for(i=0;i< currNode->noOfEntries;i++)
+            {
+                free(entries[i].samplingRatesSupported);
+                free(entries[i].pDeviceName);
+            }
+            free(entries);
+        }
+        else if (currNode->capsType == AUD_E)
+        {
+            XAAudioCodecDescriptor* entries = (XAAudioCodecDescriptor*)currNode->pEntry;
+            XAint32 i;
+            for(i=0;i< currNode->noOfEntries;i++)
+            {
+                free(entries[i].pSampleRatesSupported);
+                free(entries[i].pBitratesSupported);
+            }
+            free(entries);
+
+        }
+
+        if(currNode->adaptId)
+            {
+            free(currNode->adaptId);
+            }
+        
+        nextNode = currNode->next;
+        free(currNode);
+        currNode = nextNode;
+    }
+
+    *ppListHead = NULL;
+    return res;
+}
+
+
+/* XAresult XACapabilitiesMgr_GetCapsCount
+ * Description: Count capabilities of certain type. Filter is specified by
+ *              bitmasking XACapsType values.
+ */
+XAresult XACapabilitiesMgr_GetCapsCount(XACapabilities* pListHead, XACapsType filter, XAuint32* count)
+{
+    XAresult res = XA_RESULT_SUCCESS;
+    XACapabilities* currNode = pListHead;
+
+    DEBUG_API("->XACapabilitiesMgr_GetCapsCount");
+    if(!currNode || !count)
+    {
+        res = XA_RESULT_PARAMETER_INVALID;
+        return res;
+    }
+
+    (*count)=0;
+    while (currNode)
+    {
+        if ( (currNode->capsType & filter) == filter )
+        {
+            (*count)++;
+        }
+        currNode = currNode->next;
+    }
+
+    DEBUG_API("<-XACapabilitiesMgr_GetCapsCount");
+    return res;
+}
+
+/* XAresult XACapabilitiesMgr_GetCapsById
+ * Description: Get capabilities of type XACapsType and matching id
+ */
+XAresult XACapabilitiesMgr_GetCapsById(XACapabilities* pListHead, XACapsType filter, XAuint32 maxId, XACapabilities* data)
+{
+    XAresult res = XA_RESULT_SUCCESS;
+    XACapabilities* currNode = pListHead;
+    XAboolean found = XA_BOOLEAN_FALSE;
+
+    DEBUG_API("->XACapabilitiesMgr_GetCapsById");
+
+    if(!currNode)
+    {
+        res = XA_RESULT_PARAMETER_INVALID;
+        return res;
+    }
+
+    while (currNode)
+    {
+        if (((currNode->capsType & filter) == filter ) && (maxId==currNode->xaid))
+        {
+            memcpy(data, currNode, sizeof(XACapabilities));
+            found = XA_BOOLEAN_TRUE;
+            break;
+        }
+        currNode = currNode->next;
+    }
+
+    if(!found)
+    {
+       res = XA_RESULT_FEATURE_UNSUPPORTED;
+       return res;
+    }
+
+    DEBUG_API("<-XACapabilitiesMgr_GetCapsById");
+    return res;
+}
+
+/* XAresult XACapabilitiesMgr_GetCapsByIdx
+ * Description: Get n'th capabilities of type XACapsType
+ */
+XAresult XACapabilitiesMgr_GetCapsByIdx(XACapabilities* pListHead, XACapsType filter, XAuint32 idx, XACapabilities* data)
+{
+    XAresult res = XA_RESULT_SUCCESS;
+    XACapabilities* currNode = pListHead;
+    XAboolean found = XA_BOOLEAN_FALSE;
+    XAuint32 j = 0;
+
+
+    DEBUG_API("->XACapabilitiesMgr_GetCapsByIdx");
+
+    if(!currNode)
+    {
+        res = XA_RESULT_PARAMETER_INVALID;
+        return res;
+    }
+
+
+    while (currNode)
+    {
+        if ((currNode->capsType & filter) == filter )
+        {
+            if( idx == j++ )
+            {
+                memcpy(data, currNode, sizeof(XACapabilities));
+                found = XA_BOOLEAN_TRUE;
+                break;
+            }
+        }
+        currNode = currNode->next;
+    }
+
+    if(!found)
+    {
+       res = XA_RESULT_PARAMETER_INVALID;
+       return res;
+    }
+
+    DEBUG_API("<-XACapabilitiesMgr_GetCapsByIdx");
+    return res;
+}
+
+/* XAresult XACapabilitiesMgr_QueryColorFormats
+ * Description: Get color formats associated with the XA_IMAGECODEC_RAW codec.
+ */
+XAresult XACapabilitiesMgr_QueryColorFormats(XACapabilities* pListHead, XAuint32* pIndex, XAuint32* pColorFormats)
+{
+    XAresult res = XA_RESULT_SUCCESS;
+    XACapabilities temp;
+
+    DEBUG_API("->XACapabilitiesMgr_QueryColorFormats");
+
+    if( !pIndex )
+    {
+        DEBUG_ERR("illegal NULL parameter");
+        res = XA_RESULT_PARAMETER_INVALID;
+        return res;
+    }
+
+    res = XACapabilitiesMgr_GetCapsById(pListHead, (XACapsType)((XACapsType)(XACAP_ENCODER|XACAP_IMAGE)), XA_IMAGECODEC_RAW, &temp);
+    if( res == XA_RESULT_SUCCESS )
+    {
+        if( !pColorFormats )
+        {   /* query number of color formats */
+            *pIndex = 1; /* one used by camera context */
+        }
+        else
+        {   /* query color format */
+            if( *pIndex >= 1 ) /* one used by camera context */
+            {
+                DEBUG_ERR("index parameter invalid");
+                res = XA_RESULT_PARAMETER_INVALID;
+            }
+            else
+            {   /* internal format used by pipeline, look camera context for details  */
+                *pColorFormats = XA_COLORFORMAT_YUV420PLANAR;
+            }
+        }
+    }
+    else
+    {
+        *pIndex = 0;
+    }
+
+    DEBUG_API("<-XACapabilitiesMgr_QueryColorFormats");
+    return res;
+}
+
+/* Add AudioInputDeviceCaps */
+XAresult XACapabilitiesMgr_GetAudioInputDeviceCapabilities(XACapabilities** ppNode)
+{
+    XAresult res = XA_RESULT_SUCCESS;
+    XACapabilities *newNode = NULL;
+    XAAudioInputDescriptor *entries = NULL;
+/*    XAAudioInputDescriptor *entries = NULL;*/
+    XAchar micDeviceName[] = "Default Mic";
+    int strLen = 0;
+
+    newNode = (XACapabilities *)calloc(1, sizeof(XACapabilities));
+    if (!newNode)
+    {
+        res = XA_RESULT_MEMORY_FAILURE;
+        return res;
+    }
+
+    newNode->capsType = AUD_I;
+    newNode->xaid = 0xAD7E5001;
+    newNode->noOfEntries = 1;
+
+    /* Allocate array */
+    entries = (XAAudioInputDescriptor*) calloc(1 , sizeof(XAAudioInputDescriptor));
+    if (!entries)
+    {
+        res = XA_RESULT_MEMORY_FAILURE;
+        XACapabilitiesMgr_DeleteCapabilitieList(&newNode);
+        return res;
+    }
+
+    newNode->pEntry = (void*)entries;
+ 
+    strLen = strlen((char*)micDeviceName);
+    entries->deviceName = (XAchar *)calloc(strLen + 1, sizeof(XAchar));
+    if (!entries->deviceName)
+    {
+        res = XA_RESULT_MEMORY_FAILURE;
+        XACapabilitiesMgr_DeleteCapabilitieList(&newNode);
+        return res;
+    }
+
+    strncpy((char*)entries->deviceName, (char*)micDeviceName, strLen);
+    entries->deviceName[strLen] = '\0'; /*Null terminate it*/
+    entries->deviceConnection = XA_DEVCONNECTION_INTEGRATED;
+    entries->deviceScope = XA_DEVSCOPE_ENVIRONMENT;
+    entries->deviceLocation = XA_DEVLOCATION_HANDSET;
+    entries->isForTelephony = XA_BOOLEAN_FALSE;
+    entries->minSampleRate=8000000; /* milliHz */
+    entries->maxSampleRate = 96000000; /* milliHz */
+    entries->isFreqRangeContinuous=XA_BOOLEAN_FALSE;
+    entries->numOfSamplingRatesSupported = 12;
+    entries->samplingRatesSupported = (XAmilliHertz*)calloc(entries->numOfSamplingRatesSupported, sizeof(XAmilliHertz));
+    if (!entries->samplingRatesSupported)
+    {
+        res = XA_RESULT_MEMORY_FAILURE;
+        XACapabilitiesMgr_DeleteCapabilitieList(&newNode);
+        return res;
+    }
+    /* entries in milliHz */
+    entries->samplingRatesSupported[0] = 8000000;
+    entries->samplingRatesSupported[1] = 11025000;
+    entries->samplingRatesSupported[2] = 12000000;
+    entries->samplingRatesSupported[3] = 16000000;
+    entries->samplingRatesSupported[4] = 22050000;
+    entries->samplingRatesSupported[5] = 24000000;
+    entries->samplingRatesSupported[6] = 32000000;
+    entries->samplingRatesSupported[7] = 44100000;
+    entries->samplingRatesSupported[8] = 48000000;
+    entries->samplingRatesSupported[9] = 64000000;
+    entries->samplingRatesSupported[10] = 88200000;
+    entries->samplingRatesSupported[11] = 96000000;
+    entries->maxChannels = 2;
+
+    newNode->pEntry = (void*)entries;
+
+    *ppNode = newNode;
+    return res;
+}
+
+XAresult XACapabilitiesMgr_GetAudioOutputDeviceCapabilities(XACapabilities **ppNode)
+{
+    XAresult res = XA_RESULT_SUCCESS;
+    XACapabilities *newNode = NULL;
+    XAAudioOutputDescriptor *entries = NULL;
+/*    XAAudioOutputDescriptor *entries = NULL;*/
+    XAchar outputDeviceName[] = "Default Speaker";
+    int strLen = 0;
+
+    newNode = (XACapabilities *)calloc(1, sizeof(XACapabilities));
+    if (!newNode)
+    {
+        res = XA_RESULT_MEMORY_FAILURE;
+        return res;
+    }
+
+    newNode->capsType = AUD_O;
+    newNode->xaid = 0xAD7E5002;
+    newNode->noOfEntries = 1;
+
+    /* Allocate array */
+    entries = (XAAudioOutputDescriptor*)calloc(1, sizeof(XAAudioOutputDescriptor));
+    if (!entries)
+    {
+        res = XA_RESULT_MEMORY_FAILURE;
+        XACapabilitiesMgr_DeleteCapabilitieList(&newNode);
+        return res;
+    }
+
+    newNode->pEntry = (void*)entries;
+
+    strLen = strlen((char*)outputDeviceName);
+    entries->pDeviceName = (XAchar *)calloc(strLen + 1, sizeof(XAchar));
+    if (!entries->pDeviceName)
+    {
+        res = XA_RESULT_MEMORY_FAILURE;
+        XACapabilitiesMgr_DeleteCapabilitieList(&newNode);
+        return res;
+    }
+    strncpy((char*)entries->pDeviceName, (char*)outputDeviceName, strLen);
+    entries->pDeviceName[strLen] = '\0'; /*Null terminate it*/
+    entries->deviceConnection = XA_DEVCONNECTION_INTEGRATED;
+    entries->deviceScope = XA_DEVSCOPE_ENVIRONMENT;
+    entries->deviceLocation = XA_DEVLOCATION_HANDSET;
+    entries->isForTelephony = XA_BOOLEAN_FALSE;
+    entries->minSampleRate = 8000000; /* milliHz */
+    entries->maxSampleRate = 96000000; /* milliHz */
+    entries->isFreqRangeContinuous = XA_BOOLEAN_FALSE;
+    entries->numOfSamplingRatesSupported = 12;
+    entries->samplingRatesSupported = (XAmilliHertz*)calloc(entries->numOfSamplingRatesSupported, sizeof(XAmilliHertz));
+    if (!entries->samplingRatesSupported)
+    {
+        res = XA_RESULT_MEMORY_FAILURE;
+        XACapabilitiesMgr_DeleteCapabilitieList(&newNode);
+        return res;
+    }
+    /* entries in milliHz */
+    entries->samplingRatesSupported[0] = 8000000;
+    entries->samplingRatesSupported[1] = 11025000;
+    entries->samplingRatesSupported[2] = 12000000;
+    entries->samplingRatesSupported[3] = 16000000;
+    entries->samplingRatesSupported[4] = 22050000;
+    entries->samplingRatesSupported[5] = 24000000;
+    entries->samplingRatesSupported[6] = 32000000;
+    entries->samplingRatesSupported[7] = 44100000;
+    entries->samplingRatesSupported[8] = 48000000;
+    entries->samplingRatesSupported[9] = 64000000;
+    entries->samplingRatesSupported[10] = 88200000;
+    entries->samplingRatesSupported[11] = 96000000;
+    entries->maxChannels = 2;
+
+    newNode->pEntry = (void*)entries;
+
+    *ppNode = newNode;
+    return res;
+}
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/khronosfws/openmax_al/src/adptcommon/xacapabilitiesmgr.h	Fri Apr 30 19:18:45 2010 -0500
@@ -0,0 +1,84 @@
+/*
+* Copyright (c) 2009 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:
+*
+*/
+
+#ifndef XACAPABILITIESMGR_H
+#define XACAPABILITIESMGR_H
+
+#include "xaframeworkmgr.h"
+#include "openmaxalwrapper.h"
+#include "xaglobals.h"
+
+
+#define AUD_D (XACAP_DECODER|XACAP_AUDIO)
+#define AUD_E (XACAP_ENCODER|XACAP_AUDIO)
+#define VID_D (XACAP_DECODER|XACAP_VIDEO)
+#define VID_E ((XACapsType)(XACAP_ENCODER|XACAP_VIDEO))
+#define IMG_D (XACAP_DECODER|XACAP_IMAGE)
+#define IMG_E ((XACapsType)(XACAP_ENCODER|XACAP_IMAGE))
+#define AUD_O ((XACapsType)(XACAP_DEVSNK|XACAP_AUDIO))
+#define AUD_I (XACAP_DEVSRC|XACAP_AUDIO)
+#define VID_O (XACAP_DEVSNK|XACAP_VIDEO)
+#define VID_I (XACAP_DEVSRC|XACAP_VIDEO)
+#define ANY 0x7FFFFFFF
+
+/* Structure to hold commonly used capabilities of codec/device.
+ */
+typedef struct XACapabilities_ XACapabilities;
+
+struct XACapabilities_
+{
+    XAuint32    capsType;
+    XAuint32    xaid;       /* OpenMAX id (e.g. XA_VIDEOCODEC macro) */
+    XAchar*    adaptId;    /* TODO fill this */
+    /* TODO Do we need a flag for default device id? */
+    XAuint32    noOfEntries;
+    void*       pEntry;
+
+    /*add if/when needed*/
+    XACapabilities* next;
+};
+
+
+XAresult XACapabilitiesMgr_CreateCapabilitieList(
+            FrameworkMap* frameworkMap,
+            XACapabilities** ppListHead);
+
+XAresult XACapabilitiesMgr_DeleteCapabilitieList(XACapabilities** ppListHead);
+
+XAresult XACapabilitiesMgr_GetCapsCount(
+                XACapabilities* pListHead,
+                XACapsType filter,
+                XAuint32* count);
+
+XAresult XACapabilitiesMgr_GetCapsById(
+                XACapabilities* pListHead,
+                XACapsType filter,
+                XAuint32 maxId,
+                XACapabilities* data);
+
+XAresult XACapabilitiesMgr_GetCapsByIdx(
+                XACapabilities* pListHead,
+                XACapsType filter,
+                XAuint32 idx,
+                XACapabilities* data);
+
+XAresult XACapabilitiesMgr_QueryColorFormats(
+                XACapabilities* pListHead,
+                XAuint32* pIndex,
+                XAuint32* pColorFormats);
+
+#endif /* XACAPABILITIESMGR_H */

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/khronosfws/openmax_al/src/adptcommon/xaframeworkmgr.c	Fri Apr 30 19:18:45 2010 -0500
@@ -0,0 +1,579 @@
+/*
+* Copyright (c) 2009 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:
+*
+*/
+
+#include "xaframeworkmgr.h"
+#include <stdio.h>
+#include <string.h>
+
+/* Default line width permitted in the cfg file + 2 to hold "\r\n"*/
+#define LINEWIDTH 82
+
+typedef enum
+{
+    FWMgrTagNone,
+    FWMgrTagURIScheme,
+    FWMgrTagFileExt
+} FWMgrTagType;
+
+
+/* Config file location */
+const char configFileLocation[] = "c:/openmaxal/openmaxal.cfg";
+
+/* Tags used for parsing */
+const char mediaPlayerBeginTag[] = "<mediaplayer>";
+const char mediaPlayerEndTag[] = "</mediaplayer>";
+const char mediaRecorderBeginTag[] = "<mediarecorder>";
+const char mediaRecorderEndTag[] = "</mediarecorder>";
+const char mediaFrameworkMmfBeginTag[] = "<mmf>";
+const char mediaFrameworkMmfEndTag[] = "</mmf>";
+const char mediaFrameworkGstBeginTag[] = "<gst>";
+const char uriSchemeBeginTag[] = "<urischeme>";
+const char uriSchemeEndTag[] = "</urischeme>";
+const char mediaFrameworkGstEndTag[] = "</gst>";
+const char fileExtBeginTag[] = "<fileext>";
+const char fileExtEndTag[] = "</fileext>";
+
+/* Local function definitions */
+/* returns FWMgrTrue if processed successfully */
+static FWMgrBool processConfigEntry(
+        const char* buffer,
+        FWMgrMOType *mediaType,
+        FWMgrFwType *frameworkType,
+        FWMgrTagType *tagType,
+        FWMgrBool *newNode,
+        FrameworkMap **node);
+
+/* returns FWMgrTrue if processed successfully */
+static FWMgrBool processTagType(
+        const char* buffer,
+        FWMgrFwType *frameworkType,
+        FWMgrTagType *tagType,
+        FrameworkMap **node);
+
+/* returns FWMgrTrue if processed successfully */
+static FWMgrBool tokenizeTag(FWMgrTagType tagType, const char* buffer, FrameworkMap **node);
+
+/* Crates a default rules config file */
+static int createDefaultRules(const char * filename);
+
+/* Global functions from header file */
+
+/* FrameworkMap* XAFrameworkMgr_CreateFrameworkMap
+ * Description: Creates a list of framework and use-case map.
+ */
+FrameworkMap* XAFrameworkMgr_CreateFrameworkMap()
+{
+    char buffer[LINEWIDTH];
+    int readSize;
+    int lineNumber = 0;
+    FWMgrBool processedEntry = FWMgrTrue;
+    FWMgrMOType currentMediaType = FWMgrMOUnknown;
+    FWMgrFwType currentFrameworkType = FWMgrFWUknown;
+    FWMgrTagType currentTagType = FWMgrTagNone;
+    FrameworkMap *curNode = NULL;
+    FWMgrBool newNode;
+    FrameworkMap *frameworkMap = NULL;
+    FILE* fp = fopen(configFileLocation, "r");
+    
+    if (fp == NULL)
+        {
+        createDefaultRules(configFileLocation);
+        }
+
+    fp = fopen(configFileLocation, "r");
+    if (fp != NULL)
+    {
+        while((fgets(buffer, LINEWIDTH, fp) != NULL) && processedEntry)
+        {
+            /* keep looping until NULL pointer OR error... */
+            lineNumber++;
+            readSize = strlen(buffer);
+            /* Ignore comments line */
+            if (buffer[0] == '#')
+                continue;
+
+            /* Ignore replace "\r\n" with '\0' */
+            if ((readSize >= 2) && (buffer[readSize-2]=='\r') && (buffer[readSize-1]=='\n'))
+                buffer[readSize-2]='\0';
+
+            /* Ignore new line... */
+            if (readSize == 2)
+                continue;
+
+            processedEntry = processConfigEntry(
+                                buffer,
+                                &currentMediaType,
+                                &currentFrameworkType,
+                                &currentTagType,
+                                &newNode,
+                                &curNode);
+            if (newNode)
+            {
+                /*Just link to the last element in the chain*/
+                if (!frameworkMap)
+                {
+                    frameworkMap = curNode;
+                }
+                else
+                {
+                    FrameworkMap *lastNode = frameworkMap;
+                    while (lastNode->next)
+                    {
+                        lastNode = lastNode->next;
+                    }
+                    lastNode->next = curNode;
+                }
+            }
+        }
+        fclose(fp);
+    }
+    else
+    {
+        printf("unable to open config file!\n");
+    }
+    return frameworkMap;
+}
+
+#ifdef _DEBUG
+/* void XAFrameworkMgr_DumpFrameworkMap
+ * Description: Prints map to std console.
+ */
+void XAFrameworkMgr_DumpFrameworkMap(FrameworkMap *map)
+{
+    FrameworkMap *node = map;
+    int i;
+    int loopIndex = 0;
+    while (node)
+    {
+        loopIndex++;
+        printf("%d>", loopIndex);
+        if (node->moType == FWMgrMOPlayer)
+            printf("MediaPlayer-");
+        else if (node->moType == FWMgrMORecorder)
+            printf("MediaRecrdr-");
+        else
+            printf("UKNOWN-");
+        if (node->fwType == FWMgrFWMMF)
+            printf("MMF-");
+        else if (node->fwType == FWMgrFWGST)
+            printf("GST-");
+        else
+            printf("UKNOWN-");
+        printf("Scheme[");
+        for(i=0;i<node->uriSchemeCount;i++)
+            printf(" %s", node->uriSchemes[i]);
+        printf("]FileExt[");
+        for(i=0;i<node->fileExtCount;i++)
+            printf(" %s", node->fileExts[i]);
+        printf("]\n");
+        node = node->next;
+    }
+}
+#endif
+
+/* void XAFrameworkMgr_DeleteFrameworkMap
+ * Description: Deletes the list of framework and use-case map.
+ */
+void XAFrameworkMgr_DeleteFrameworkMap(FrameworkMap **map)
+{
+    FrameworkMap *node = *map;
+    FrameworkMap *nextNode = NULL;
+    int i;
+    while (node)
+    {
+        for(i=0;i<node->uriSchemeCount;i++)
+            free (node->uriSchemes[i]);
+        free (node->uriSchemes);
+
+        for(i=0;i<node->fileExtCount;i++)
+            free (node->fileExts[i]);
+        free (node->fileExts);
+
+        nextNode = node->next;
+        free (node);
+        node = nextNode;
+    }
+    *map = NULL;
+}
+
+/* FWMgrFwType XAFrameworkMgr_GetFramework
+ * Description: Returns the framework enum that handles uri.
+ */
+FWMgrFwType XAFrameworkMgr_GetFramework(
+                    FrameworkMap *map,
+                    const char *uri,
+                    FWMgrMOType mediaObject)
+{
+    FWMgrFwType retVal = FWMgrFWUknown;
+    char fileScheme[] = "file";
+    char *uriScheme = NULL;
+    char *fileExt = NULL;
+    FrameworkMap *node = map;
+    FWMgrBool uriMatchFound = FWMgrFalse;
+    FWMgrBool fileExtMatchFound = FWMgrFalse;
+    int i = 0;
+    int copyLen = 0;
+
+    if (!map || !uri)
+    {
+        /* TODO Log invalid uri */
+        return retVal;
+    }
+
+    /* Get uri scheme */
+    uriScheme = strchr(uri, ':');
+    if ( uriScheme == NULL)
+    {
+        /* TODO Log invalid uri */
+        return retVal;
+    }
+
+    copyLen = (uriScheme - uri);
+    uriScheme = (char*)calloc(copyLen + 1, sizeof(char));
+    strncpy(uriScheme, uri, copyLen);
+    uriScheme[copyLen] = '\0'; /*Null terminate it*/
+
+    if (strcasecmp(uriScheme, fileScheme) == 0)
+    {
+        /* Get uri extension */
+        char* dotLoc = strrchr(uri, '.');
+        if ( dotLoc == NULL)
+        {
+            /* TODO Log invalid uri */
+            free(uriScheme);
+            return retVal;
+        }
+        /* We need to add 1 to exclude '.'*/
+        copyLen = strlen(uri) - (dotLoc + 1 - uri);
+        fileExt = (char*)calloc(copyLen + 1, sizeof(char));
+        strncpy(fileExt, dotLoc + 1, copyLen);
+        fileExt[copyLen] = '\0'; /*Null terminate it*/
+    }
+
+    while (node)
+    {
+        if (mediaObject == node->moType)
+            {
+            uriMatchFound = FWMgrFalse;
+            fileExtMatchFound = FWMgrFalse;
+            /* Match for uri*/
+            for(i = 0; i < node->uriSchemeCount; i++)
+            {
+                if (strcasecmp(uriScheme, node->uriSchemes[i]) == 0)
+                    {
+                        uriMatchFound = FWMgrTrue;
+                        break;
+                    }
+            }
+            /* if uri scheme is not file, we only need to check for uri */
+            if (!fileExt)
+            {
+                fileExtMatchFound = FWMgrTrue;
+            }
+            else
+            {
+                for(i = 0; i < node->fileExtCount; i++)
+                {
+                    if (strcasecmp(fileExt, node->fileExts[i]) == 0)
+                    {
+                        fileExtMatchFound = FWMgrTrue;
+                        break;
+                    }
+                }
+            }
+
+            if ((uriMatchFound == FWMgrTrue) &&
+                (fileExtMatchFound == FWMgrTrue))
+                {
+                    retVal = node->fwType;
+                    break;
+                }
+            }
+        node = node->next;
+    }
+    free(uriScheme);
+    free(fileExt);
+    return retVal;
+}
+
+/* Local functions */
+
+/* FWMgrBool processConfigEntry
+ * Description: Processes a single line entry from the config file.
+ */
+FWMgrBool processConfigEntry(
+        const char* buffer,
+        FWMgrMOType *mediaType,
+        FWMgrFwType *frameworkType,
+        FWMgrTagType *tagType,
+        FWMgrBool *newNode,
+        FrameworkMap **node)
+{
+    FWMgrBool processedSuccessfully = FWMgrTrue;
+    *newNode = FWMgrFalse;
+    switch (*mediaType)
+    {
+        case FWMgrMOUnknown:
+        {
+            if (strcmp(buffer, mediaPlayerBeginTag) == 0)
+            {
+                *mediaType = FWMgrMOPlayer;
+                *frameworkType = FWMgrFWUknown;
+                *tagType = FWMgrTagNone;
+                *node = NULL;
+            }
+            else if (strcmp(buffer, mediaRecorderBeginTag) == 0)
+            {
+                *mediaType = FWMgrMORecorder;
+                *frameworkType = FWMgrFWUknown;
+                *tagType = FWMgrTagNone;
+                *node = NULL;
+            }
+        }
+            break;
+        case FWMgrMOPlayer:
+        case FWMgrMORecorder:
+        {
+            switch (*frameworkType)
+            {
+                case FWMgrFWUknown:
+                {
+                    if ((*mediaType == FWMgrMOPlayer) && (strcmp(buffer, mediaPlayerEndTag) == 0))
+                        *mediaType = FWMgrMOUnknown;
+                    else if ((*mediaType == FWMgrMORecorder) && (strcmp(buffer, mediaRecorderEndTag) == 0))
+                        *mediaType = FWMgrMOUnknown;
+                    else if ( (strcmp(buffer, mediaFrameworkMmfBeginTag) == 0) ||
+                              (strcmp(buffer, mediaFrameworkGstBeginTag) == 0) )
+                    {
+                        *frameworkType = FWMgrFWMMF;
+                        if (strcmp(buffer, mediaFrameworkGstBeginTag) == 0)
+                            *frameworkType = FWMgrFWGST;
+                        if (*node)
+                        {
+                            printf("Fatal error error. Entry already exists and creating another one!!!");
+                            return FWMgrFalse;
+                        }
+                        *node = (FrameworkMap*)calloc(1, sizeof(FrameworkMap));
+                        if (!(*node))
+                        {
+                            printf("Fatal error. No memory to create an Entry!!!");
+                            return FWMgrFalse;
+                        }
+                        *newNode = FWMgrTrue;
+                        (*node)->moType = *mediaType;
+                        (*node)->fwType = *frameworkType;
+                    }
+                }
+                    break;
+                case FWMgrFWMMF:
+                {
+                    processedSuccessfully = processTagType(
+                                                buffer,
+                                                frameworkType,
+                                                tagType,
+                                                node);
+                }
+                    break;
+                case FWMgrFWGST:
+                {
+                    processedSuccessfully = processTagType(
+                                                buffer,
+                                                frameworkType,
+                                                tagType,
+                                                node);
+                }
+                    break;
+                default:
+                    processedSuccessfully = FWMgrFalse;
+                    break;
+            };
+        }
+            break;
+        default:
+            processedSuccessfully = FWMgrFalse;
+            break;
+    };
+    return processedSuccessfully;
+}
+
+/* FWMgrBool processTagType
+ * Description: Processes a framework type, uri, file tags entry from the config file.
+ */
+FWMgrBool processTagType(const char* buffer,
+        FWMgrFwType *frameworkType,
+        FWMgrTagType *tagType,
+        FrameworkMap **node)
+{
+    FWMgrBool processedSuccessfully = FWMgrTrue;
+    switch (*tagType)
+    {
+        case FWMgrTagNone:
+        {
+            if (((*frameworkType == FWMgrFWMMF) && (strcmp(buffer, mediaFrameworkMmfEndTag) == 0)) ||
+                ((*frameworkType == FWMgrFWGST) && (strcmp(buffer, mediaFrameworkGstEndTag) == 0)))
+            {
+                *node = NULL;
+                *frameworkType = FWMgrFWUknown;
+            }
+            else if (strcmp(buffer, uriSchemeBeginTag) == 0)
+                *tagType = FWMgrTagURIScheme;
+            else if (strcmp(buffer, fileExtBeginTag) == 0)
+                *tagType = FWMgrTagFileExt;
+        }
+            break;
+        case FWMgrTagURIScheme:
+        {
+            if (strcmp(buffer, uriSchemeEndTag) == 0)
+                *tagType = FWMgrTagNone;
+            else
+            {
+                processedSuccessfully = FWMgrFalse;
+                if (*node)
+                    processedSuccessfully = tokenizeTag(FWMgrTagURIScheme, buffer, node);
+            }
+        }
+            break;
+        case FWMgrTagFileExt:
+        {
+            if (strcmp(buffer, fileExtEndTag) == 0)
+                *tagType = FWMgrTagNone;
+            else
+            {
+                processedSuccessfully = FWMgrFalse;
+                if (*node)
+                    processedSuccessfully = tokenizeTag(FWMgrTagFileExt, buffer, node);
+            }
+        }
+            break;
+        default:
+            break;
+    };
+    return processedSuccessfully;
+}
+
+/* FWMgrBool processTagType
+ * Description: Processes a framework type, uri, file tags entry from the config file.
+ */
+FWMgrBool tokenizeTag(FWMgrTagType tagType, const char* buffer, FrameworkMap **node)
+{
+    char* tempStartPtr = /*const_cast<char*>*/(char*)(buffer);
+    char* tempEndPtr = /*const_cast<char*>*/(char*)(buffer);
+    int index = 0;
+    int strLen = 0;
+
+    if (tagType == FWMgrTagURIScheme)
+    {
+        (*node)->uriSchemeCount = atoi(buffer);
+        (*node)->uriSchemes =  (char**)calloc((*node)->uriSchemeCount,  sizeof (*((*node)->uriSchemes)));
+        if (!(*node)->uriSchemes)
+        {
+            printf("Fatal error. No memory to create an Entry!!!");
+            return FWMgrFalse;
+        }
+    }
+    else if (tagType == FWMgrTagFileExt)
+    {
+        (*node)->fileExtCount = atoi(buffer);
+        (*node)->fileExts =  (char**)calloc((*node)->fileExtCount,  sizeof (*((*node)->fileExts)));
+        if (!(*node)->fileExts)
+        {
+            printf("Fatal error. No memory to create an Entry!!!");
+            return FWMgrFalse;
+        }
+    }
+    else
+        return FWMgrFalse;
+
+    /*Find the index of :*/
+    tempStartPtr = strchr(tempStartPtr, ',');
+    index = 0;
+    while (tempStartPtr && (strlen(tempStartPtr) > 1))
+    {
+        tempStartPtr++; /* Ignore separator ','*/
+        tempEndPtr = strchr(tempStartPtr, ',');
+        strLen = (tempEndPtr - tempStartPtr) + 1; /* To hold null terminator */
+        if (strLen > 0)
+        {
+            if (tagType == FWMgrTagURIScheme)
+            {
+                (*node)->uriSchemes[index] = (char*)calloc(strLen, sizeof(char));
+                strncpy((*node)->uriSchemes[index], tempStartPtr, strLen);
+                (*node)->uriSchemes[index][strLen-1] = '\0'; /*Null terminate it*/
+                index++;
+            }
+            else if (tagType == FWMgrTagFileExt)
+            {
+                (*node)->fileExts[index] = (char*)calloc(strLen, sizeof(char));
+                strncpy((*node)->fileExts[index], tempStartPtr, strLen);
+                (*node)->fileExts[index][strLen-1] = '\0'; /*Null terminate it*/
+                index++;
+            }
+        }
+        tempStartPtr = tempEndPtr;
+    }
+    return FWMgrTrue;
+}
+
+int createDefaultRules(const char * filename)
+{
+    FILE* fp = fopen(filename, "w");
+    if (fp == NULL)
+        return /*KErrAccessDenied*/-21;
+    fputs("#/*\r\n", fp);
+    fputs("#* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).\r\n", fp);
+    fputs("#* All rights reserved.\r\n", fp);
+    fputs("#* This component and the accompanying materials are made available\r\n", fp);
+    fputs("#* under the terms of \"Eclipse Public License v1.0\"\r\n", fp);
+    fputs("#* which accompanies this distribution, and is available\r\n", fp);
+    fputs("#* at the URL \"http://www.eclipse.org/legal/epl-v10.html\".\r\n", fp);
+    fputs("#*\r\n", fp);
+    fputs("#* Initial Contributors:\r\n", fp);
+    fputs("#* Nokia Corporation - initial contribution.\r\n", fp);
+    fputs("#*\r\n", fp);
+    fputs("#* Contributors:\r\n", fp);
+    fputs("#*\r\n", fp);
+    fputs("#* Description:\r\n", fp); 
+    fputs("#*\r\n", fp);
+    fputs("#*/\r\n", fp);
+    fputs("#============================================================================>|\r\n", fp);
+    fputs("# Must not exceed 80 chars each line=========================================>|\r\n", fp);
+    fputs("#============================================================================>|\r\n", fp);
+    fputs("<mediaplayer>\r\n", fp);
+    fputs("<mmf>\r\n", fp);
+    fputs("<urischeme>\r\n", fp);
+    fputs("# Num of entries followed by actual entries all ending with a comma\r\n", fp);
+    fputs("3,file,http,rtsp,\r\n", fp);
+    fputs("</urischeme>\r\n", fp);
+    fputs("<fileext>\r\n", fp);
+    fputs("15,3gp,wma,wmv,wav,amr,mp3,mp4,rm,ra,avi,mkv,aac,mid,awb,3g2,\r\n", fp);
+    fputs("</fileext>\r\n", fp);
+    fputs("</mmf>\r\n", fp);
+    fputs("</mediaplayer>\r\n", fp);
+    fputs("<mediarecorder>\r\n", fp);
+    fputs("<gst>\r\n", fp);
+    fputs("<urischeme>\r\n", fp);
+    fputs("# Num of entries followed by actual entries all ending with a comma\r\n", fp);
+    fputs("1,file,\r\n", fp);
+    fputs("</urischeme>\r\n", fp);
+    fputs("<fileext>\r\n", fp);
+    fputs("3,wav,amr,mp4,\r\n", fp);
+    fputs("</fileext>\r\n", fp);
+    fputs("</gst>\r\n", fp);
+    fputs("</mediarecorder>\r\n", fp);
+    fclose(fp);
+    return 0;
+}