diff -r 80975da52420 -r 43d09473c595 khronosfws/openmax_al/src/adptcommon/xaframeworkmgr.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/khronosfws/openmax_al/src/adptcommon/xaframeworkmgr.c	Fri May 14 16:22:35 2010 +0300
@@ -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;
+}