diff -r 2ed61feeead6 -r 6f7ceef7b1d1 khronosfws/openmax_al/src/common/xaobjectitf.c
--- a/khronosfws/openmax_al/src/common/xaobjectitf.c	Fri May 28 19:26:28 2010 -0500
+++ b/khronosfws/openmax_al/src/common/xaobjectitf.c	Fri Jun 11 19:59:23 2010 -0500
@@ -1,19 +1,19 @@
 /*
-* 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: 
-*
-*/
+ * 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: Object Interface Implementation
+ *
+ */
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -25,311 +25,305 @@
  * Base interface XAObjectItf implementation
  */
 XAresult XAObjectItfImpl_Realize(XAObjectItf self, XAboolean async)
-{
-    XAObjectItfImpl* pObjImp = (XAObjectItfImpl*)(*self);
+    {
+    XAObjectItfImpl* pObjImp = (XAObjectItfImpl*) (*self);
     XAresult retval = XA_RESULT_SUCCESS;
 
     DEBUG_API("->XAObjectItfImpl_Realize");
-    if( !pObjImp || pObjImp != pObjImp->self)
-    {
+    if (!pObjImp || pObjImp != pObjImp->self)
+        {
         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
         DEBUG_API("<-XAObjectItfImpl_Realize");
         /* invalid parameter */
         return XA_RESULT_PARAMETER_INVALID;
-    }
+        }
 
-    if( async )
-    {
-        /* invoke asynchronously */
-        if( !pObjImp->callBack )
+    if (async)
         {
+        /* invoke asynchronously */
+        if (!pObjImp->callBack)
+            {
             retval = XA_RESULT_PARAMETER_INVALID;
-        }
+            }
         else
-        {
+            {
             /* check if another async operation is processed */
-            if(pObjImp->asyncOngoing)
-            {
+            if (pObjImp->asyncOngoing)
+                {
                 /* abort ongoing operation */
                 XAImpl_CancelThread(pObjImp->asyncThr);
-            }
+                }
             pObjImp->asyncOngoing = XA_BOOLEAN_TRUE;
-            if(XAImpl_StartThread(pObjImp->asyncThr, NULL,
-                    XAObjectItfImpl_AsyncRealize,(void*)(self)))
-            {
+            if (XAImpl_StartThread(pObjImp->asyncThr, NULL,
+                    XAObjectItfImpl_AsyncRealize, (void*) (self)))
+                {
                 pObjImp->asyncOngoing = XA_BOOLEAN_FALSE;
                 retval = XA_RESULT_RESOURCE_ERROR;
-            }
+                }
             else
-            {
+                {
                 retval = XA_RESULT_SUCCESS;
+                }
             }
         }
-    }
     else
-    {
+        {
         /* Check if the object is in unrealized state */
-        if(pObjImp->state != XA_OBJECT_STATE_UNREALIZED)
-        {
+        if (pObjImp->state != XA_OBJECT_STATE_UNREALIZED)
+            {
             DEBUG_ERR("XA_RESULT_PRECONDITIONS_VIOLATED");
             DEBUG_API("<-XAObjectItfImpl_Realize");
             return XA_RESULT_PRECONDITIONS_VIOLATED;
-        }
+            }
         /* invoke synchronously */
-        if( pObjImp->DoRealizeImpl )
-        {
+        if (pObjImp->DoRealizeImpl)
+            {
             retval = pObjImp->DoRealizeImpl(self);
-        }
+            }
+        }DEBUG_API("<-XAObjectItfImpl_Realize");
+    return retval;
     }
-    DEBUG_API("<-XAObjectItfImpl_Realize");
-    return retval;
-}
 
 XAresult XAObjectItfImpl_Resume(XAObjectItf self, XAboolean async)
-{
+    {
     XAresult retval = XA_RESULT_SUCCESS;
-    XAObjectItfImpl* pObjImp = (XAObjectItfImpl*)(*self);
+    XAObjectItfImpl* pObjImp = (XAObjectItfImpl*) (*self);
     DEBUG_API("->XAObjectItfImpl_Resume");
 
-    if( !pObjImp || pObjImp != pObjImp->self )
-    {
+    if (!pObjImp || pObjImp != pObjImp->self)
+        {
         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
         DEBUG_API("<-XAObjectItfImpl_Resume");
         /* invalid parameter */
         return XA_RESULT_PARAMETER_INVALID;
-    }
-    if( async )
-    {
+        }
+    if (async)
+        {
         /* invoke asynchronously */
-        if( !pObjImp->callBack )
-        {
+        if (!pObjImp->callBack)
+            {
             retval = XA_RESULT_PARAMETER_INVALID;
-        }
+            }
         else
-        {
+            {
             /* check if another async operation is processed */
-            if(pObjImp->asyncOngoing)
-            {
+            if (pObjImp->asyncOngoing)
+                {
                 /* abort ongoing operation */
                 XAImpl_CancelThread(pObjImp->asyncThr);
-            }
+                }
             pObjImp->asyncOngoing = XA_BOOLEAN_TRUE;
-            if(XAImpl_StartThread(pObjImp->asyncThr, NULL,
-                    XAObjectItfImpl_AsyncResume,(void*)(self)))
-            {
+            if (XAImpl_StartThread(pObjImp->asyncThr, NULL,
+                    XAObjectItfImpl_AsyncResume, (void*) (self)))
+                {
                 pObjImp->asyncOngoing = XA_BOOLEAN_FALSE;
                 retval = XA_RESULT_RESOURCE_ERROR;
-            }
+                }
             else
-            {
+                {
                 retval = XA_RESULT_SUCCESS;
+                }
             }
         }
-    }
     else
-    {
-        /* invoke synchronously */
-        if( pObjImp->DoResumeImpl )
         {
+        /* invoke synchronously */
+        if (pObjImp->DoResumeImpl)
+            {
             retval = pObjImp->DoResumeImpl(self);
-        }
+            }
+        }DEBUG_API("<-XAObjectItfImpl_Resume");
+    return retval;
     }
-    DEBUG_API("<-XAObjectItfImpl_Resume");
-    return retval;
-}
 
 XAresult XAObjectItfImpl_GetState(XAObjectItf self, XAuint32 *pState)
-{
-    XAObjectItfImpl* pObjImp = (XAObjectItfImpl*)(*self);
+    {
+    XAObjectItfImpl* pObjImp = (XAObjectItfImpl*) (*self);
     DEBUG_API("->XAObjectItfImpl_GetState");
-    if( !pObjImp || pObjImp != pObjImp->self || !pState )
-    {
+    if (!pObjImp || pObjImp != pObjImp->self || !pState)
+        {
         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
         DEBUG_API("<-XAObjectItfImpl_GetState");
         /* invalid parameter */
         return XA_RESULT_PARAMETER_INVALID;
-    }
+        }
     *pState = pObjImp->state;
 
     DEBUG_API("<-XAObjectItfImpl_GetState");
     return XA_RESULT_SUCCESS;
-}
+    }
 
-XAresult XAObjectItfImpl_GetInterface(XAObjectItf self, const XAInterfaceID iid,
-                                       void *pInterface)
-{
-    XAObjectItfImpl* pObjImp = (XAObjectItfImpl*)(*self);
+XAresult XAObjectItfImpl_GetInterface(XAObjectItf self,
+        const XAInterfaceID iid, void *pInterface)
+    {
+    XAObjectItfImpl* pObjImp = (XAObjectItfImpl*) (*self);
     XAObjItfMapEntry *mapEntry = NULL;
     DEBUG_API("->XAObjectItfImpl_GetInterface");
 
-    if( !pObjImp || pObjImp != pObjImp->self || !pInterface || !iid )
-    {
+    if (!pObjImp || pObjImp != pObjImp->self || !pInterface || !iid)
+        {
         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
         DEBUG_API("<-XAObjectItfImpl_GetInterface");
         /* invalid parameter */
         return XA_RESULT_PARAMETER_INVALID;
-    }
+        }
 
-    if(pObjImp->state != XA_OBJECT_STATE_REALIZED)
-    {
+    if (pObjImp->state != XA_OBJECT_STATE_REALIZED)
+        {
         DEBUG_ERR("XA_RESULT_PRECONDITIONS_VIOLATED");
         DEBUG_API("<-XAObjectItfImpl_GetInterface");
         /*state is not correct */
         return XA_RESULT_PRECONDITIONS_VIOLATED;
-    }
+        }
 
     mapEntry = XAObjectItfImpl_GetItfEntry(self, iid);
-    if( mapEntry && mapEntry->pItf )
-    {
-        *(void**)pInterface = &(mapEntry->pItf);
+    if (mapEntry && mapEntry->pItf)
+        {
+        *(void**) pInterface = &(mapEntry->pItf);
         DEBUG_API("<-XAObjectItfImpl_GetInterface");
         return XA_RESULT_SUCCESS;
-    }
+        }
     else
-    {
+        {
         DEBUG_ERR("XA_RESULT_FEATURE_UNSUPPORTED");
         DEBUG_API("<-XAObjectItfImpl_GetInterface");
         return XA_RESULT_FEATURE_UNSUPPORTED;
+        }
     }
-}
-
 
 XAresult XAObjectItfImpl_RegisterCallback(XAObjectItf self,
-                                       xaObjectCallback callback,
-                                       void *pContext)
-{
-    XAObjectItfImpl* pObjImp = (XAObjectItfImpl*)(*self);
+        xaObjectCallback callback, void *pContext)
+    {
+    XAObjectItfImpl* pObjImp = (XAObjectItfImpl*) (*self);
     DEBUG_API("->XAObjectItfImpl_RegisterCallback");
 
-    if( !pObjImp || pObjImp != pObjImp->self )
-    {
+    if (!pObjImp || pObjImp != pObjImp->self)
+        {
         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
         DEBUG_API("<-XAObjectItfImpl_RegisterCallback");
         /* invalid parameter */
         return XA_RESULT_PARAMETER_INVALID;
-    }
+        }
     pObjImp->callBack = callback;
     pObjImp->context = pContext;
     pObjImp->cbPtrToSelf = self;
 
     DEBUG_API("<-XAObjectItfImpl_RegisterCallback");
     return XA_RESULT_SUCCESS;
-}
+    }
 
 void XAObjectItfImpl_AbortAsyncOperation(XAObjectItf self)
-{
-    XAObjectItfImpl* pObjImp = (XAObjectItfImpl*)(*self);
+    {
+    XAObjectItfImpl* pObjImp = (XAObjectItfImpl*) (*self);
     DEBUG_API("->XAObjectItfImpl_AbortAsyncOperation");
 
-    if( pObjImp &&
-       (pObjImp == pObjImp->self) &&
-        pObjImp->callBack &&
-        pObjImp->asyncOngoing )
-    {
+    if (pObjImp && (pObjImp == pObjImp->self) && pObjImp->callBack
+            && pObjImp->asyncOngoing)
+        {
         /* abort ongoing operation */
         XAImpl_CancelThread(pObjImp->asyncThr);
-    }
+        }
 
     DEBUG_API("<-XAObjectItfImpl_AbortAsyncOperation");
-}
+    }
 
 void XAObjectItfImpl_Destroy(XAObjectItf self)
-{
-    XAObjectItfImpl* pObjImp = (XAObjectItfImpl*)(*self);
+    {
+    XAObjectItfImpl* pObjImp = (XAObjectItfImpl*) (*self);
     DEBUG_API("->XAObjectItfImpl_Destroy");
 
-    if( pObjImp && pObjImp == pObjImp->self )
-    {
-        if( pObjImp->asyncOngoing )
+    if (pObjImp && pObjImp == pObjImp->self)
         {
+        if (pObjImp->asyncOngoing)
+            {
             /* abort ongoing operation */
             XAImpl_CancelThread(pObjImp->asyncThr);
-        }
+            }
         /* free object specific resources */
-        if( pObjImp->FreeResourcesImpl )
-        {
+        if (pObjImp->FreeResourcesImpl)
+            {
             pObjImp->FreeResourcesImpl(self);
-        }
+            }
         free(pObjImp->interfaceMap);
         XAImpl_DeleteThreadHandle(pObjImp->asyncThr);
         free(pObjImp);
-    }
+        }
 
     DEBUG_API("<-XAObjectItfImpl_Destroy");
-}
+    }
 
 XAresult XAObjectItfImpl_SetPriority(XAObjectItf self, XAint32 priority,
-                                  XAboolean preemptable)
-{
-    XAObjectItfImpl* pObjImp = (XAObjectItfImpl*)(*self);
+        XAboolean preemptable)
+    {
+    XAObjectItfImpl* pObjImp = (XAObjectItfImpl*) (*self);
     DEBUG_API("->XAObjectItfImpl_SetPriority");
 
-    if( !pObjImp || pObjImp != pObjImp->self )
-    {
+    if (!pObjImp || pObjImp != pObjImp->self)
+        {
         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
         DEBUG_API("<-XAObjectItfImpl_SetPriority");
         /* invalid parameter */
         return XA_RESULT_PARAMETER_INVALID;
-    }
+        }
     pObjImp->priority = priority;
     pObjImp->preemptable = preemptable;
 
     DEBUG_API("<-XAObjectItfImpl_SetPriority");
     return XA_RESULT_SUCCESS;
-}
+    }
 
 XAresult XAObjectItfImpl_GetPriority(XAObjectItf self, XAint32 *pPriority,
-                                  XAboolean *pPreemptable)
-{
-    XAObjectItfImpl* pObjImp = (XAObjectItfImpl*)(*self);
+        XAboolean *pPreemptable)
+    {
+    XAObjectItfImpl* pObjImp = (XAObjectItfImpl*) (*self);
     DEBUG_API("->XAObjectItfImpl_GetPriority");
 
-    if( !pObjImp || pObjImp != pObjImp->self )
-    {
+    if (!pObjImp || pObjImp != pObjImp->self)
+        {
         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
         DEBUG_API("<-XAObjectItfImpl_GetPriority");
         /* invalid parameter */
         return XA_RESULT_PARAMETER_INVALID;
-    }
+        }
     *pPriority = pObjImp->priority;
     *pPreemptable = pObjImp->preemptable;
 
     DEBUG_API("<-XAObjectItfImpl_GetPriority");
     return XA_RESULT_SUCCESS;
-}
+    }
 
 XAresult XAObjectItfImpl_SetLossOfControlInterfaces(XAObjectItf self,
-                                              XAint16 numInterfaces,
-                                              XAInterfaceID *pInterfaceIDs,
-                                              XAboolean enabled)
-{
-    XAObjectItfImpl* pObjImp = (XAObjectItfImpl*)(*self);
+        XAint16 numInterfaces, XAInterfaceID *pInterfaceIDs,
+        XAboolean enabled)
+    {
+    XAObjectItfImpl* pObjImp = (XAObjectItfImpl*) (*self);
     XAint32 itfIndex = 0;
     XAObjItfMapEntry *mapEntry = NULL;
     DEBUG_API("->XAObjectItfImpl_SetLossOfControlInterfaces");
 
-    if( !pObjImp || pObjImp != pObjImp->self || !pInterfaceIDs )
-    {
+    if (!pObjImp || pObjImp != pObjImp->self || !pInterfaceIDs)
+        {
         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
         DEBUG_API("<-XAObjectItfImpl_SetLossOfControlInterfaces");
         /* invalid parameter */
         return XA_RESULT_PARAMETER_INVALID;
-    }
-    if( pInterfaceIDs )
-    {
-        for(itfIndex = 0; itfIndex < numInterfaces; itfIndex++)
+        }
+    if (pInterfaceIDs)
         {
-            mapEntry = XAObjectItfImpl_GetItfEntry(self, pInterfaceIDs[itfIndex]);
-            if( mapEntry )
+        for (itfIndex = 0; itfIndex < numInterfaces; itfIndex++)
             {
+            mapEntry = XAObjectItfImpl_GetItfEntry(self,
+                    pInterfaceIDs[itfIndex]);
+            if (mapEntry)
+                {
                 mapEntry->locEnabled = enabled;
+                }
             }
         }
-    }
 
     DEBUG_API("<-XAObjectItfImpl_SetLossOfControlInterfaces");
     return XA_RESULT_SUCCESS;
-}
+    }
 
 /**
  * XAObjectItfImpl -specific methods
@@ -338,43 +332,40 @@
 /*
  * Allocate and init new object itf instance
  */
-XAresult XAObjectItfImpl_Init(XAObjectItfImpl* self,
-                              XAuint32 itfCount,
-                              const XAInterfaceID** itfIIDs,
-                              xaDoRealizeImpl doRealizeImpl,
-                              xaDoResumeImpl doResumeImpl,
-                              xaFreeResourcesImpl freeResourcesImpl)
-{
+XAresult XAObjectItfImpl_Init(XAObjectItfImpl* self, XAuint32 itfCount,
+        const XAInterfaceID** itfIIDs, xaDoRealizeImpl doRealizeImpl,
+        xaDoResumeImpl doResumeImpl, xaFreeResourcesImpl freeResourcesImpl)
+    {
     XAuint32 i = 0;
     DEBUG_API("->XAObjectItfImpl_Init");
 
     assert( self && itfIIDs && doRealizeImpl && doResumeImpl && freeResourcesImpl );
 
-    self->interfaceMap =
-       (XAObjItfMapEntry*)calloc(itfCount, sizeof(XAObjItfMapEntry));
-    if( !self->interfaceMap )
-    {
+    self->interfaceMap = (XAObjItfMapEntry*) calloc(itfCount,
+            sizeof(XAObjItfMapEntry));
+    if (!self->interfaceMap)
+        {
         free(self);
         DEBUG_ERR("XA_RESULT_MEMORY_FAILURE");
         DEBUG_API("<-XAObjectItfImpl_Init");
         return XA_RESULT_MEMORY_FAILURE;
-    }
-    if( XAImpl_CreateThreadHandle(&(self->asyncThr)) != XA_RESULT_SUCCESS )
-    {
+        }
+    if (XAImpl_CreateThreadHandle(&(self->asyncThr)) != XA_RESULT_SUCCESS)
+        {
         free(self);
         DEBUG_ERR("XA_RESULT_MEMORY_FAILURE");
         DEBUG_API("<-XAObjectItfImpl_Init");
         return XA_RESULT_MEMORY_FAILURE;
-    }
-    for(i=0;i<itfCount;i++)
-    {
+        }
+    for (i = 0; i < itfCount; i++)
+        {
         self->interfaceMap[i].mapIdx = i;
         self->interfaceMap[i].iid = *(itfIIDs[i]);
         self->interfaceMap[i].pItf = NULL;
         self->interfaceMap[i].locEnabled = XA_BOOLEAN_FALSE;
         self->interfaceMap[i].required = XA_BOOLEAN_FALSE;
         self->interfaceMap[i].isDynamic = XA_BOOLEAN_FALSE;
-    }
+        }
     self->interfaceMap[0].pItf = self;
     self->interfaceMap[0].required = XA_BOOLEAN_TRUE;
 
@@ -401,111 +392,106 @@
     self->itf.Destroy = XAObjectItfImpl_Destroy;
     self->itf.SetPriority = XAObjectItfImpl_SetPriority;
     self->itf.GetPriority = XAObjectItfImpl_GetPriority;
-    self->itf.SetLossOfControlInterfaces  = XAObjectItfImpl_SetLossOfControlInterfaces;
+    self->itf.SetLossOfControlInterfaces
+            = XAObjectItfImpl_SetLossOfControlInterfaces;
     self->self = self;
 
     DEBUG_API("<-XAObjectItfImpl_Init");
     return XA_RESULT_SUCCESS;
-}
+    }
 
 /*
  * Asynchronous invocation of Realize
  */
 void* XAObjectItfImpl_AsyncRealize(void* args)
-{
+    {
     XAresult retval = XA_RESULT_SUCCESS;
-    XAObjectItfImpl* pObjImp = (XAObjectItfImpl*)(*(XAObjectItf)(args));
+    XAObjectItfImpl* pObjImp = (XAObjectItfImpl*) (*(XAObjectItf) (args));
     DEBUG_API("->XAObjectItfImpl_AsyncRealize");
 
-    if( pObjImp && pObjImp == pObjImp->self)
-    {
-        /* Check if the object is in unrealized state */
-        if(pObjImp->state != XA_OBJECT_STATE_UNREALIZED)
-        {
-            retval = XA_RESULT_PRECONDITIONS_VIOLATED;
-        }
-        else if( pObjImp->DoRealizeImpl )
+    if (pObjImp && pObjImp == pObjImp->self)
         {
-            retval = pObjImp->DoRealizeImpl((XAObjectItf)(args));
-        }
-        if( pObjImp->callBack )
-        {
+        /* Check if the object is in unrealized state */
+        if (pObjImp->state != XA_OBJECT_STATE_UNREALIZED)
+            {
+            retval = XA_RESULT_PRECONDITIONS_VIOLATED;
+            }
+        else if (pObjImp->DoRealizeImpl)
+            {
+            retval = pObjImp->DoRealizeImpl((XAObjectItf) (args));
+            }
+        if (pObjImp->callBack)
+            {
             pObjImp->callBack(pObjImp->cbPtrToSelf, pObjImp->context,
-                              XA_OBJECT_EVENT_ASYNC_TERMINATION,
-                              retval, pObjImp->state, NULL);
-        }
+                    XA_OBJECT_EVENT_ASYNC_TERMINATION, retval,
+                    pObjImp->state, NULL);
+            }
         pObjImp->asyncOngoing = XA_BOOLEAN_FALSE;
         XAImpl_ExitThread(pObjImp->asyncThr);
-    }
+        }
     else
-    {
+        {
         DEBUG_API("XAObjectItfImpl_AsyncRealize: INVALID args");
-    }
-    
+        }
 
     DEBUG_API("<-XAObjectItfImpl_AsyncRealize");
     return NULL;
-}
-
+    }
 
 /*
  * Asynchronous invocation of Resume
  */
 void* XAObjectItfImpl_AsyncResume(void* args)
-{
+    {
     XAresult retval = XA_RESULT_SUCCESS;
-    XAObjectItfImpl* pObjImp = (XAObjectItfImpl*)(*(XAObjectItf)(args));
+    XAObjectItfImpl* pObjImp = (XAObjectItfImpl*) (*(XAObjectItf) (args));
     DEBUG_API("->XAObjectItfImpl_AsyncResume");
 
-    if( pObjImp && pObjImp == pObjImp->self )
-    {
-        if( pObjImp->DoResumeImpl )
+    if (pObjImp && pObjImp == pObjImp->self)
         {
-            retval = pObjImp->DoResumeImpl((XAObjectItf)(args));
-        }
-        if( pObjImp->callBack )
-        {
+        if (pObjImp->DoResumeImpl)
+            {
+            retval = pObjImp->DoResumeImpl((XAObjectItf) (args));
+            }
+        if (pObjImp->callBack)
+            {
             pObjImp->callBack(pObjImp->cbPtrToSelf, pObjImp->context,
-                              XA_OBJECT_EVENT_ASYNC_TERMINATION,
-                              retval, pObjImp->state, NULL);
-        }
+                    XA_OBJECT_EVENT_ASYNC_TERMINATION, retval,
+                    pObjImp->state, NULL);
+            }
         pObjImp->asyncOngoing = XA_BOOLEAN_FALSE;
         XAImpl_ExitThread(pObjImp->asyncThr);
-    }
+        }
     else
-    {
+        {
         DEBUG_API("XAObjectItfImpl_AsyncResume: INVALID args");
-    }
-    
+        }
 
     DEBUG_API("<-XAObjectItfImpl_AsyncResume");
     return NULL;
-}
+    }
 
 XAObjItfMapEntry* XAObjectItfImpl_GetItfEntry(const XAObjectItf self,
-                                              const XAInterfaceID iid)
-{
+        const XAInterfaceID iid)
+    {
     XAuint32 mapIndex = 0;
-    XAObjectItfImpl* pObjImp = (XAObjectItfImpl*)(*self);
+    XAObjectItfImpl* pObjImp = (XAObjectItfImpl*) (*self);
     DEBUG_API("->XAObjectItfImpl_GetItfEntry");
 
-    if( pObjImp &&
-       (pObjImp == pObjImp->self) &&
-        pObjImp->interfaceMap &&
-        iid )
-    {
+    if (pObjImp && (pObjImp == pObjImp->self) && pObjImp->interfaceMap && iid)
+        {
         /* Check interface */
-        for(mapIndex = 0; mapIndex < pObjImp->interfaceCount; mapIndex++)
-        {
-            if(XACommon_EqualIIds(pObjImp->interfaceMap[mapIndex].iid, iid))
+        for (mapIndex = 0; mapIndex < pObjImp->interfaceCount; mapIndex++)
             {
+            if (XACommon_EqualIIds(pObjImp->interfaceMap[mapIndex].iid, iid))
+                {
                 DEBUG_API("<-XAObjectItfImpl_GetItfEntry");
                 return &(pObjImp->interfaceMap[mapIndex]);
+                }
             }
         }
-    }
 
     DEBUG_API("<-XAObjectItfImpl_GetItfEntry");
     return NULL;
-}
+    }