1 /*

     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description: 

    15 *

    16 */

    17 

    18 #include <assert.h>

    19 #include <string.h>

    20 #include "xaadptbasectx.h"

    21 #include "xathreadsafety.h"

    22 

    23 /*

    24  * XAAdaptationBaseCtx* XAAdaptationBase_Create()

    25  * 1st phase initialization function for Adaptation Base context structure.

    26  * Reserves memory for base context and initializes GStreamer FW.

    27  */

    28 XAresult XAAdaptationBase_Init( XAAdaptationBaseCtx* pSelf, XAuint32 ctxId )

    29 {

    30     DEBUG_API("->XAAdaptationBase_Init");

    31 

    32     if ( pSelf )

    33     {

    34     if(!pSelf->evtHdlrs)

    35         {

    36         pSelf->evtHdlrs = g_array_new (FALSE, FALSE, sizeof (XAAdaptEvtHdlr));

    37         if(!pSelf->evtHdlrs)

    38             {

    39             DEBUG_ERR("Memory allocation failure in Base Ctx.")

    40             return XA_RESULT_MEMORY_FAILURE;

    41             }

    42         }

    43     pSelf->ctxId = ctxId;

    44     }

    45     else

    46     {

    47         DEBUG_ERR("Invalid Adaptation Base Context.")

    48         return XA_RESULT_PARAMETER_INVALID;

    49     }

    50 

    51     DEBUG_API("<-XAAdaptationBase_Init");

    52     return XA_RESULT_SUCCESS;

    53 }

    54 

    55 /*

    56  * XAresult XAAdaptationBase_PostInit()

    57  * 2nd phase initialization for Adaptation Base.

    58  */

    59 XAresult XAAdaptationBase_PostInit( XAAdaptationBaseCtx* ctx )

    60 {

    61     XAresult ret = XA_RESULT_SUCCESS;

    62     DEBUG_API("->XAAdaptationBase_PostInit");

    63     DEBUG_API("<-XAAdaptationBase_PostInit");

    64     return ret;

    65 }

    66 

    67 /*

    68  * void XAAdaptationBase_Free( XAAdaptationBaseCtx* ctx )

    69  * Frees all Base context variables .

    70  */

    71 void XAAdaptationBase_Free( XAAdaptationBaseCtx* ctx )

    72 {

    73     g_array_free(ctx->evtHdlrs, TRUE);

    74     ctx->evtHdlrs = NULL;

    75     DEBUG_API("<-XAAdaptationBase_Free");

    76 }

    77 

    78 /*

    79  * XAresult XAAdaptationBase_AddEventHandler

    80  * Adds event handler for certain event types.

    81  */

    82 XAresult XAAdaptationBase_AddEventHandler( XAAdaptationBaseCtx* ctx, xaAdaptEventHandler evtHandler,

    83                                     XAuint32 evtTypes, void *pHandlerCtx )

    84 {

    85     XAuint32 i;

    86     XAAdaptEvtHdlr tmp;

    87     DEBUG_API("->XAAdaptationBase_AddEventHandler");

    88     if(!ctx)

    89     {

    90         DEBUG_ERR("no context");

    91         return XA_RESULT_PARAMETER_INVALID;

    92     }

    93 

    94     for(i=0; i<ctx->evtHdlrs->len; i++)

    95     {

    96         if( (g_array_index(ctx->evtHdlrs, XAAdaptEvtHdlr, i)).handlerfunc == evtHandler )

    97         {

    98             return XA_RESULT_PARAMETER_INVALID;

    99         }

   100     }

   101     tmp.handlerfunc = evtHandler;

   102     tmp.handlercontext = pHandlerCtx;

   103     tmp.eventtypes = evtTypes;

   104     g_array_append_val(ctx->evtHdlrs, tmp);

   105     DEBUG_API("<-XAAdaptationBase_AddEventHandler");

   106     return XA_RESULT_SUCCESS;

   107 }

   108 

   109 /*

   110  * XAresult XAAdaptationBase_RemoveEventHandler

   111  * Removes event handler for certain event types.

   112  */

   113 XAresult XAAdaptationBase_RemoveEventHandler( XAAdaptationBaseCtx* ctx, xaAdaptEventHandler evtHandler)

   114 {

   115     XAuint32 i;

   116     DEBUG_API("->XAAdaptationBase_RemoveEventHandler");

   117     if(!ctx)

   118     {

   119         DEBUG_ERR("no context");

   120         return XA_RESULT_PARAMETER_INVALID;

   121     }

   122     for(i=0; i<ctx->evtHdlrs->len; i++)

   123     {

   124         if( (g_array_index(ctx->evtHdlrs, XAAdaptEvtHdlr, i)).handlerfunc == evtHandler )

   125         {

   126             g_array_remove_index(ctx->evtHdlrs, i);

   127             return XA_RESULT_SUCCESS;

   128         }

   129     }

   130     DEBUG_API("<-XAAdaptationBase_RemoveEventHandler");

   131     /*did not find, return error*/

   132     return XA_RESULT_PARAMETER_INVALID;

   133 }

   134 

   135 void XAAdaptationBase_SendAdaptEvents(XAAdaptationBaseCtx* ctx, XAAdaptEvent* event)

   136 {

   137     XAuint32 i;

   138     XAAdaptEvtHdlr* tmp;

   139     for(i=0; i<ctx->evtHdlrs->len; i++)

   140     {

   141         tmp = &g_array_index(ctx->evtHdlrs, XAAdaptEvtHdlr, i);

   142         if( tmp->eventtypes & event->eventtype )

   143         {

   144             (tmp->handlerfunc)(tmp->handlercontext, event);

   145         }

   146     }

   147 }

   148 

   149 /*

   150  * XAresult XAEqualizerItfAdapt_ThreadEntry(XAAdaptationGstCtx *adapCtx)

   151  * Description: Safety thread entry

   152  */

   153 XAresult XAAdaptationBase_ThreadEntry(XAAdaptationBaseCtx *adaptCtx)

   154 {

   155     XAresult res = XA_RESULT_SUCCESS;

   156     DEBUG_API("->XAAdaptationBase_ThreadEntry");

   157     if(!adaptCtx )

   158     {

   159         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   160         DEBUG_API("<-XAAdaptationBase_ThreadEntry");

   161         /* invalid parameter */

   162         return XA_RESULT_PARAMETER_INVALID;

   163 

   164     }

   165     

   166     switch(adaptCtx->ctxId)

   167         {

   168         case XAMediaPlayerAdaptation:

   169             XA_IMPL_THREAD_SAFETY_ENTRY(XATSMediaPlayer);

   170             break;

   171         case XAMediaRecorderAdaptation:

   172             XA_IMPL_THREAD_SAFETY_ENTRY(XATSMediaRecorder);

   173             break;

   174         case XARadioAdaptation:

   175             XA_IMPL_THREAD_SAFETY_ENTRY(XATSRadio);

   176             break;

   177         case XACameraAdaptation:

   178             XA_IMPL_THREAD_SAFETY_ENTRY(XATSCamera);

   179             break;

   180         case XAOutputMixAdaptation:

   181             XA_IMPL_THREAD_SAFETY_ENTRY(XATSOutputMix);

   182             break;

   183         case XAVibraAdaptation:

   184             XA_IMPL_THREAD_SAFETY_ENTRY(XATSVibra);

   185             break;

   186         case XALedArrayAdaptation:

   187             XA_IMPL_THREAD_SAFETY_ENTRY(XATSLEDArray);

   188             break;

   189         case XAMDAdaptation:

   190             XA_IMPL_THREAD_SAFETY_ENTRY(XATSMetaDataExtractor);

   191             break;

   192         case XAEngineAdaptation:

   193             XA_IMPL_THREAD_SAFETY_ENTRY(XATSEngine);

   194             break;

   195         default:

   196             DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   197             /* invalid parameter */

   198             res = XA_RESULT_PARAMETER_INVALID;

   199             break;

   200         }

   201 

   202     DEBUG_API("<-XAAdaptationBase_ThreadEntry");

   203     return res;

   204 }

   205 /*

   206  * XAresult XAEqualizerItfAdapt_ThreadExit(XAAdaptationGstCtx *adaptCtx)

   207  * Description: Safety thread exit

   208  */

   209 XAresult XAAdaptationBase_ThreadExit(XAAdaptationBaseCtx *adaptCtx)

   210 {

   211     XAresult res = XA_RESULT_SUCCESS;

   212     DEBUG_API("->XAAdaptationBase_ThreadExit");

   213     if(!adaptCtx )

   214     {

   215         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   216         DEBUG_API("<-XAAdaptationBase_ThreadExit");

   217         /* invalid parameter */

   218         return XA_RESULT_PARAMETER_INVALID;

   219 

   220     }

   221 

   222     switch(adaptCtx->ctxId)

   223         {

   224         case XAMediaPlayerAdaptation:

   225             XA_IMPL_THREAD_SAFETY_EXIT(XATSMediaPlayer);

   226             break;

   227         case XAMediaRecorderAdaptation:

   228             XA_IMPL_THREAD_SAFETY_EXIT(XATSMediaRecorder);

   229             break;

   230         case XARadioAdaptation:

   231             XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);

   232             break;

   233         case XACameraAdaptation:

   234             XA_IMPL_THREAD_SAFETY_EXIT(XATSCamera);

   235             break;

   236         case XAOutputMixAdaptation:

   237             XA_IMPL_THREAD_SAFETY_EXIT(XATSOutputMix);

   238             break;

   239         case XAVibraAdaptation:

   240             XA_IMPL_THREAD_SAFETY_EXIT(XATSVibra);

   241             break;

   242         case XALedArrayAdaptation:

   243             XA_IMPL_THREAD_SAFETY_EXIT(XATSLEDArray);

   244             break;

   245         case XAMDAdaptation:

   246             XA_IMPL_THREAD_SAFETY_EXIT(XATSMetaDataExtractor);

   247             break;

   248         case XAEngineAdaptation:

   249             XA_IMPL_THREAD_SAFETY_EXIT(XATSEngine);

   250             break;

   251         default:

   252             DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   253             /* invalid parameter */

   254             res = XA_RESULT_PARAMETER_INVALID;

   255             break;

   256         }

   257 

   258     DEBUG_API("<-XAAdaptationBase_ThreadExit");

   259     return res;

   260 }