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 <stdio.h>

    19 #include <stdlib.h>

    20 #include <assert.h>

    21 

    22 #include "xaprefetchstatusitf.h"

    23 #ifdef _GSTREAMER_BACKEND_

    24 #include "XAAdaptationContextBase.h"

    25 #endif

    26 

    27 static XAPrefetchStatusItfImpl* GetImpl(XAPrefetchStatusItf self)

    28 {

    29     if(self)

    30     {

    31         XAPrefetchStatusItfImpl* impl = (XAPrefetchStatusItfImpl*)(*self);

    32         if(impl && impl == impl->self)

    33         {

    34             return impl;

    35         }

    36     }

    37     return NULL;

    38 }

    39 

    40 XAresult XAPrefetchStatusItfImpl_GetPrefetchStatus(XAPrefetchStatusItf self,

    41                                                    XAuint32 *pStatus)

    42 {

    43     XAresult ret = XA_RESULT_SUCCESS;

    44     XAPrefetchStatusItfImpl *impl = GetImpl(self);

    45     DEBUG_API("->XAPrefetchStatusItfImpl_GetPrefetchStatus");

    46 

    47     if(!impl || !pStatus )

    48     {

    49         /* invalid parameter */

    50         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

    51         DEBUG_API("<-XAPrefetchStatusItfImpl_GetPrefetchStatus");

    52         return XA_RESULT_PARAMETER_INVALID;

    53     }

    54 

    55     *pStatus = impl->pStatus;

    56 

    57     DEBUG_API("<-XAPrefetchStatusItfImpl_GetPrefetchStatus");

    58     return ret;

    59 }

    60 

    61 XAresult XAPrefetchStatusItfImpl_GetFillLevel(XAPrefetchStatusItf self,

    62                                               XApermille *pLevel)

    63 {

    64     XAresult ret = XA_RESULT_SUCCESS;

    65     XAPrefetchStatusItfImpl *impl = GetImpl(self);

    66     DEBUG_API("->XAPrefetchStatusItfImpl_GetFillLevel");

    67 

    68     if(!impl || !pLevel)

    69     {

    70         /* invalid parameter */

    71         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

    72         DEBUG_API("<-XAPrefetchStatusItfImpl_GetFillLevel");

    73         return XA_RESULT_PARAMETER_INVALID;

    74     }

    75 

    76     *pLevel = impl->pLevel;

    77 

    78     DEBUG_API("<-XAPrefetchStatusItfImpl_GetFillLevel");

    79     return ret;

    80 }

    81 

    82 XAresult XAPrefetchStatusItfImpl_RegisterCallback(XAPrefetchStatusItf self,

    83                                                   xaPrefetchCallback callback,

    84                                                   void *pContext)

    85 {

    86     XAresult ret = XA_RESULT_SUCCESS;

    87     XAPrefetchStatusItfImpl *impl = GetImpl(self);

    88     DEBUG_API("->XAPrefetchStatusItfImpl_RegisterCallback");

    89 

    90     if(!impl)

    91     {

    92         /* invalid parameter */

    93         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

    94         DEBUG_API("<-XAPrefetchStatusItfImpl_RegisterCallback");

    95         return XA_RESULT_PARAMETER_INVALID;

    96     }

    97 

    98     /* Can be null to reset callback */

    99     impl->callback = callback;

   100     impl->cbcontext = pContext;

   101     impl->cbPtrToSelf = self;

   102 

   103     DEBUG_API("<-XAPrefetchStatusItfImpl_RegisterCallback");

   104     return ret;

   105 }

   106 

   107 XAresult XAPrefetchStatusItfImpl_SetCallbackEventsMask(XAPrefetchStatusItf self,

   108                                                        XAuint32 eventFlags)

   109 {

   110     XAresult ret = XA_RESULT_SUCCESS;

   111     XAPrefetchStatusItfImpl *impl = GetImpl(self);

   112     DEBUG_API("->XAPrefetchStatusItfImpl_SetCallbackEventsMask");

   113 

   114     if(!impl  )

   115     {

   116         /* invalid parameter */

   117         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   118         DEBUG_API("<-XAPrefetchStatusItfImpl_SetCallbackEventsMask");

   119         return XA_RESULT_PARAMETER_INVALID;

   120     }

   121 

   122     impl->eventFlags = eventFlags;

   123 

   124     DEBUG_API("<-XAPrefetchStatusItfImpl_SetCallbackEventsMask");

   125     return ret;

   126 }

   127 

   128 XAresult XAPrefetchStatusItfImpl_GetCallbackEventsMask(XAPrefetchStatusItf self,

   129                                                        XAuint32 *pEventFlags)

   130 {

   131     XAresult ret = XA_RESULT_SUCCESS;

   132     XAPrefetchStatusItfImpl *impl = GetImpl(self);

   133     DEBUG_API("->XAPrefetchStatusItfImpl_GetCallbackEventsMask");

   134 

   135     if(!impl || !pEventFlags)

   136     {

   137         /* invalid parameter */

   138         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   139         DEBUG_API("<-XAPrefetchStatusItfImpl_GetCallbackEventsMask");

   140         return XA_RESULT_PARAMETER_INVALID;

   141     }

   142 

   143     *pEventFlags = impl->eventFlags;

   144 

   145     DEBUG_API("<-XAPrefetchStatusItfImpl_GetCallbackEventsMask");

   146     return ret;

   147 }

   148 

   149 XAresult XAPrefetchStatusItfImpl_SetFillUpdatePeriod(XAPrefetchStatusItf self,

   150                                                      XApermille period)

   151 {

   152     XAresult ret = XA_RESULT_SUCCESS;

   153     XAPrefetchStatusItfImpl *impl = GetImpl(self);

   154     DEBUG_API("->XAPrefetchStatusItfImpl_SetFillUpdatePeriod");

   155 

   156     if(!impl || period == 0 || period > 1000 )

   157     {

   158         /* invalid parameter */

   159         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   160         DEBUG_API("<-XAPrefetchStatusItfImpl_SetFillUpdatePeriod");

   161         return XA_RESULT_PARAMETER_INVALID;

   162     }

   163 

   164     impl->fillUpdatePeriod = period;

   165 

   166     DEBUG_API("<-XAPrefetchStatusItfImpl_SetFillUpdatePeriod");

   167     return ret;

   168 }

   169 

   170 XAresult XAPrefetchStatusItfImpl_GetFillUpdatePeriod(XAPrefetchStatusItf self,

   171                                                      XApermille *pPeriod)

   172 {

   173     XAresult ret = XA_RESULT_SUCCESS;

   174     XAPrefetchStatusItfImpl *impl = GetImpl(self);

   175     DEBUG_API("->XAPrefetchStatusItfImpl_GetFillUpdatePeriod");

   176 

   177     if(!impl || !pPeriod)

   178     {

   179         /* invalid parameter */

   180         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   181         DEBUG_API("<-XAPrefetchStatusItfImpl_GetFillUpdatePeriod");

   182         return XA_RESULT_PARAMETER_INVALID;

   183     }

   184 

   185     *pPeriod = impl->fillUpdatePeriod;

   186 

   187     DEBUG_API("<-XAPrefetchStatusItfImpl_GetFillUpdatePeriod");

   188     return ret;

   189 }

   190 

   191 #ifdef _GSTREAMER_BACKEND_

   192 

   193 /*

   194  * implementation-specific methods

   195  */

   196 XAPrefetchStatusItfImpl* XAPrefetchStatusItfImpl_Create( XAAdaptationBaseCtx* adaptationCtx )

   197 {

   198     XAPrefetchStatusItfImpl *self = (XAPrefetchStatusItfImpl*)

   199         calloc(1,sizeof(XAPrefetchStatusItfImpl));

   200     DEBUG_API("->XAPrefetchStatusItfImpl_Create");

   201 

   202     if(self)

   203     {

   204         /* init itf default implementation */

   205         self->itf.GetCallbackEventsMask = XAPrefetchStatusItfImpl_GetCallbackEventsMask;

   206         self->itf.GetFillLevel = XAPrefetchStatusItfImpl_GetFillLevel;

   207         self->itf.GetFillUpdatePeriod = XAPrefetchStatusItfImpl_GetFillUpdatePeriod;

   208         self->itf.GetPrefetchStatus = XAPrefetchStatusItfImpl_GetPrefetchStatus;

   209         self->itf.RegisterCallback = XAPrefetchStatusItfImpl_RegisterCallback;

   210         self->itf.SetCallbackEventsMask = XAPrefetchStatusItfImpl_SetCallbackEventsMask;

   211         self->itf.SetFillUpdatePeriod = XAPrefetchStatusItfImpl_SetFillUpdatePeriod;

   212 

   213         self->callback = NULL;

   214         self->cbcontext = NULL;

   215         self->eventFlags = 0;

   216         self->fillUpdatePeriod = PREFETCHSTATUSITF_DEFAULT_UPDATE_PERIOD;

   217         self->pStatus = XA_PREFETCHSTATUS_SUFFICIENTDATA;

   218         self->adaptationCtx = adaptationCtx;

   219         self->cbPtrToSelf = NULL;

   220 

   221         XAAdaptationBase_AddEventHandler( adaptationCtx, &XAPrefetchStatusItfImpl_AdaptCb, XA_PREFETCHITFEVENTS, self );

   222 

   223         self->self = self;

   224     }

   225 

   226     DEBUG_API("<-XAPrefetchStatusItfImpl_Create");

   227     return self;

   228 }

   229 #endif

   230 

   231 void XAPrefetchStatusItfImpl_Free(XAPrefetchStatusItfImpl* self)

   232 {

   233     DEBUG_API("->XAPrefetchStatusItfImpl_Free");

   234     assert(self==self->self);

   235 #ifdef _GSTREAMER_BACKEND_

   236     XAAdaptationBase_RemoveEventHandler( (XAAdaptationBaseCtx*)self->adaptationCtx, &XAPrefetchStatusItfImpl_AdaptCb );

   237 #endif    

   238     free(self);

   239     DEBUG_API("<-XAPrefetchStatusItfImpl_Free");

   240 }

   241 

   242 #ifdef _GSTREAMER_BACKEND_

   243 

   244 /* void XAPrefetchStatusItfImpl_AdaptCb

   245  * Description: Listen changes in adaptation

   246  */

   247 void XAPrefetchStatusItfImpl_AdaptCb( void *pHandlerCtx, XAAdaptEvent *event )

   248 {

   249     XAPrefetchStatusItfImpl* impl = (XAPrefetchStatusItfImpl*)pHandlerCtx;

   250     DEBUG_API("->XAPrefetchStatusItfImpl_AdaptCb");

   251     if(!impl)

   252     {

   253         DEBUG_ERR("XAPrefetchStatusItfImpl_AdaptCb, invalid context pointer!");

   254         DEBUG_API("<-XAPrefetchStatusItfImpl_AdaptCb");

   255         return;

   256     }

   257     assert(event);

   258     if( event->eventid == XA_ADAPT_BUFFERING )

   259     {

   260         /* Adaptation sends percents convert it to permille */

   261         impl->fillUpdatePeriod = ((*(XAint32*)(event->data))*10);

   262 

   263         /*Check do we have to send event */

   264         if( impl->callback && impl->eventFlags & XA_PREFETCHEVENT_FILLLEVELCHANGE )

   265         {

   266             if ( (*(XAint32*)event->data) >  impl->fillUpdatePeriod / 10 )

   267             {

   268                 impl->callback(impl->cbPtrToSelf, impl->cbcontext, XA_PREFETCHEVENT_FILLLEVELCHANGE);

   269             }

   270         }

   271     }

   272 

   273     DEBUG_API("<-XAPrefetchStatusItfImpl_AdaptCb");

   274 }

   275 #endif

   276