diff -r a36789189b53 -r 095bea5f582e khronosfws/openmax_al/src/common/xaplatform.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/khronosfws/openmax_al/src/common/xaplatform.c	Tue Aug 31 15:43:02 2010 +0300
@@ -0,0 +1,276 @@
+/*
+ * 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: Platform Specific Utility Functions
+ *
+ */
+
+#include <pthread.h>
+#include <semaphore.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+#include <errno.h>
+
+#include "xaplatform.h"
+
+/** MACROS **/
+
+/**********************************************************************
+ * mutex management
+ **********************************************************************/
+/* define next if platform supports posix error checking mutex type */
+#undef _MUTEXERRORSUPPORT
+
+#ifdef _MUTEXERRORSUPPORT
+typedef pthread_mutex_t XA_MTX;
+#else
+typedef struct
+    {
+    pthread_mutex_t mutex;
+    pthread_t owner;
+    } XA_MTX;
+#endif
+
+XAresult XAImpl_CreateMutex(XAImplMutexHandle *mtx)
+    {
+    XA_MTX *pMtx = (XA_MTX *) malloc(sizeof(XA_MTX));
+    assert(mtx);
+    if (pMtx)
+        {
+        pthread_mutexattr_t *pAttr = NULL;
+#ifdef _MUTEXERRORSUPPORT
+        pthread_mutexattr_t attr;
+        pAttr = &attr;
+        pthread_mutexattr_init(pAttr);
+        pthread_mutexattr_settype(pAttr, PTHREAD_MUTEX_ERRORCHECK);
+        if(pthread_mutex_init(pMtx, pAttr))
+#else
+        if (pthread_mutex_init(&(pMtx->mutex), pAttr))
+#endif
+            {
+            free(pMtx);
+            *mtx = NULL;
+            return XA_RESULT_INTERNAL_ERROR;
+            }
+        *mtx = (XAImplMutexHandle) pMtx;
+        return XA_RESULT_SUCCESS;
+        }
+    else
+        {
+        return XA_RESULT_MEMORY_FAILURE;
+        }
+    }
+
+XAresult XAImpl_LockMutex(XAImplMutexHandle mtx)
+    {
+    XA_MTX *pMtx = (XA_MTX*) mtx;
+    assert(pMtx);
+#ifdef _MUTEXERRORSUPPORT
+    if(pthread_mutex_lock(pMtx))
+        {
+        return XA_RESULT_PRECONDITIONS_VIOLATED;
+        }
+#else
+    if (pthread_self() == pMtx->owner || pthread_mutex_unlock(&(pMtx->mutex)))
+        {
+        return XA_RESULT_PRECONDITIONS_VIOLATED;
+        }
+    pMtx->owner = pthread_self();
+#endif
+    return XA_RESULT_SUCCESS;
+    }
+
+XAresult XAImpl_TryLockMutex(XAImplMutexHandle mtx)
+    {
+    XA_MTX *pMtx = (XA_MTX*) mtx;
+    XAint32 mutexRet;
+    XAresult ret = XA_RESULT_SUCCESS;
+    assert(pMtx);
+
+#ifdef _MUTEXERRORSUPPORT
+    mutexRet = pthread_ mutex_trylock(pMtx);
+    switch (mutexRet)
+        {
+        case EBUSY:
+        /* if mutex is already locked, return permission denied */
+        ret = XA_RESULT_PERMISSION_DENIED;
+        break;
+        case 0:
+        ret = XA_RESULT_SUCCESS;
+        break;
+        default:
+        ret = XA_RESULT_PRECONDITIONS_VIOLATED;
+        break;
+        }
+#else
+    if (pthread_self() == pMtx->owner)
+        {
+        return XA_RESULT_PRECONDITIONS_VIOLATED;
+        }
+
+    mutexRet = pthread_mutex_trylock(&(pMtx->mutex));
+    switch (mutexRet)
+        {
+        case EBUSY:
+            /* if mutex is already locked, return permission denied */
+            ret = XA_RESULT_PERMISSION_DENIED;
+            break;
+        case 0:
+            pMtx->owner = pthread_self();
+            ret = XA_RESULT_SUCCESS;
+            break;
+        default:
+            ret = XA_RESULT_PRECONDITIONS_VIOLATED;
+            break;
+        }
+#endif
+    return ret;
+    }
+
+XAresult XAImpl_UnlockMutex(XAImplMutexHandle mtx)
+    {
+    XA_MTX *pMtx = (XA_MTX*) mtx;
+    assert(pMtx);
+#ifdef _MUTEXERRORSUPPORT
+    if(pthread_mutex_lock(pMtx))
+        {
+        return XA_RESULT_PRECONDITIONS_VIOLATED;
+        }
+#else
+    if (pthread_self() != pMtx->owner || pthread_mutex_unlock(&(pMtx->mutex)))
+        {
+        return XA_RESULT_PRECONDITIONS_VIOLATED;
+        }
+    // Changing the below value to 0 since owner is an unsigned int.
+    // pMtx->owner = -1;
+    pMtx->owner = 0;
+#endif
+    return XA_RESULT_SUCCESS;
+    }
+
+void XAImpl_DeleteMutex(XAImplMutexHandle mtx)
+    {
+    XA_MTX *pMtx = (XA_MTX*) mtx;
+    if (pMtx)
+        {
+#ifdef _MUTEXERRORSUPPORT
+        pthread_mutex_destroy(pMtx);
+#else
+        pthread_mutex_destroy(&(pMtx->mutex));
+#endif
+        free(pMtx);
+        }
+    }
+
+/**********************************************************************
+ * semaphores
+ **********************************************************************/
+
+XAresult XAImpl_CreateSemaphore(XAImplSemHandle *sem)
+    {
+    sem_t *pSem = (sem_t*) malloc(sizeof(sem_t));
+    assert(sem);
+    if (pSem)
+        {
+        if (sem_init(pSem, 0, 0))
+            {
+            free(pSem);
+            *sem = NULL;
+            return XA_RESULT_INTERNAL_ERROR;
+            }
+        *sem = (XAImplSemHandle) pSem;
+        return XA_RESULT_SUCCESS;
+        }
+    else
+        {
+        return XA_RESULT_MEMORY_FAILURE;
+        }
+    }
+
+XAresult XAImpl_WaitSemaphore(XAImplSemHandle sem)
+    {
+    sem_t* pSem = (sem_t*) sem;
+    assert(pSem);
+    sem_wait(pSem);
+    return XA_RESULT_SUCCESS;
+    }
+
+XAresult XAImpl_PostSemaphore(XAImplSemHandle sem)
+    {
+    sem_t *pSem = (sem_t*) sem;
+    assert(pSem);
+    sem_post(pSem);
+    return XA_RESULT_SUCCESS;
+    }
+
+void XAImpl_DeleteSemaphore(XAImplSemHandle sem)
+    {
+    sem_t *pSem = (sem_t*) sem;
+    if (pSem)
+        {
+        sem_destroy(pSem);
+        free(pSem);
+        }
+    }
+
+/**********************************************************************
+ * THREADS
+ **********************************************************************/
+
+XAresult XAImpl_CreateThreadHandle(XAImplThreadHandle *thd)
+    {
+    pthread_t *pThd = (pthread_t*) malloc(sizeof(pthread_t));
+    assert(thd);
+    if (!pThd)
+        {
+        return XA_RESULT_MEMORY_FAILURE;
+        }
+    *thd = (XAImplThreadHandle) pThd;
+    return XA_RESULT_SUCCESS;
+    }
+
+XAresult XAImpl_StartThread(XAImplThreadHandle thd, void *thdattrib,
+        XAImplThreadFunction thdfunc, void* thdfuncargs)
+    {
+    pthread_t *pThd = (pthread_t*) thd;
+    assert(thd);
+    if (pthread_create(pThd, thdattrib, thdfunc, thdfuncargs))
+        {
+        return XA_RESULT_INTERNAL_ERROR;
+        }
+    return XA_RESULT_SUCCESS;
+    }
+
+void XAImpl_CancelThread(XAImplThreadHandle thd)
+    {
+    // int res;
+    // TL: TODO: There is no pthread_cancel API in S60, need to replace
+    //res = pthread_cancel(*pThd);
+
+    }
+
+void XAImpl_ExitThread(XAImplThreadHandle thd)
+    {
+    pthread_exit(NULL);
+    }
+
+void XAImpl_DeleteThreadHandle(XAImplThreadHandle thd)
+    {
+    pthread_t *pThd = (pthread_t*) thd;
+    if (pThd)
+        {
+        free(pThd);
+        }
+    }
+