diff -r 095bea5f582e -r 0ac9a5310753 khronosfws/openmax_al/src/common/xaplatform.c
--- a/khronosfws/openmax_al/src/common/xaplatform.c	Tue Aug 31 15:43:02 2010 +0300
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,276 +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: 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);
-        }
-    }
-