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 #include "xaplaybackrateitf.h"

    22 

    23 #include "xaplaybackrateitfadaptationmmf.h"

    24 

    25 #include "xathreadsafety.h"

    26 

    27 static XAPlaybackRateItfImpl* GetImpl(XAPlaybackRateItf self)

    28 {

    29     if(self)

    30     {

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

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

    33         {

    34             return impl;

    35         }

    36     }

    37     return NULL;

    38 }

    39 

    40 /**

    41  * Base interface XAPlaybackRateItf implementation

    42  */

    43 XAresult XAPlaybackRateItfImpl_SetRate(XAPlaybackRateItf self, XApermille rate)

    44 {

    45     XAresult res = XA_RESULT_SUCCESS;

    46     XAPlaybackRateItfImpl *impl = GetImpl(self);

    47     DEBUG_API("->XAPlaybackRateItfImpl_SetRate");

    48     XA_IMPL_THREAD_SAFETY_ENTRY( XATSMediaPlayer );

    49 

    50     if( !impl )

    51     {

    52 

    53         XA_IMPL_THREAD_SAFETY_EXIT( XATSMediaPlayer );

    54         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

    55         DEBUG_API("<-XAPlaybackRateItfImpl_SetRate");

    56         return XA_RESULT_PARAMETER_INVALID;

    57     }

    58 

    59     if(impl->adaptCtx->fwtype == FWMgrFWMMF)

    60         {

    61         res = XAPlaybackRateItfAdaptMMF_SetRate((XAAdaptationMMFCtx*)impl->adaptCtx, rate);

    62         }

    63     else

    64         {

    65         DEBUG_ERR("XA_RESULT_FEATURE_UNSUPPORTED");

    66         res = XA_RESULT_FEATURE_UNSUPPORTED;          

    67         }

    68     

    69     if(res == XA_RESULT_SUCCESS)

    70     {

    71         impl->currentRate = rate;

    72     }

    73 

    74     XA_IMPL_THREAD_SAFETY_EXIT( XATSMediaPlayer );

    75     DEBUG_API("<-XAPlaybackRateItfImpl_SetRate");

    76     return res;

    77 }

    78 

    79 XAresult XAPlaybackRateItfImpl_GetRate(XAPlaybackRateItf self, XApermille *pRate)

    80 {

    81     XAresult res = XA_RESULT_SUCCESS;

    82     XAPlaybackRateItfImpl *impl = GetImpl(self);

    83     DEBUG_API("->XAPlaybackRateItfImpl_GetRate");

    84 

    85     if( !impl || !pRate )

    86     {

    87         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

    88         DEBUG_API("<-XAPlaybackRateItfImpl_GetRate");

    89         return XA_RESULT_PARAMETER_INVALID;

    90     }

    91     

    92     if(impl->adaptCtx->fwtype == FWMgrFWMMF)

    93         {

    94         *pRate = impl->currentRate;

    95         }

    96     else

    97         {

    98         DEBUG_ERR("XA_RESULT_FEATURE_UNSUPPORTED");

    99         res = XA_RESULT_FEATURE_UNSUPPORTED;          

   100         }

   101 

   102     DEBUG_API("<-XAPlaybackRateItfImpl_GetRate");

   103     return res;

   104 }

   105 

   106 XAresult XAPlaybackRateItfImpl_SetPropertyConstraints(XAPlaybackRateItf self,

   107                                                         XAuint32 constraints)

   108 {

   109     XAresult res = XA_RESULT_SUCCESS;

   110     XAPlaybackRateItfImpl *impl = GetImpl(self);

   111     DEBUG_API("->XAPlaybackRateItfImpl_SetPropertyConstraints");

   112 

   113     XA_IMPL_THREAD_SAFETY_ENTRY( XATSMediaPlayer );

   114     if( !impl )

   115     {

   116         XA_IMPL_THREAD_SAFETY_EXIT( XATSMediaPlayer );

   117         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   118         DEBUG_API("<-XAPlaybackRateItfImpl_SetPropertyConstraints");

   119         return XA_RESULT_PARAMETER_INVALID;

   120     }

   121     

   122     if(impl->adaptCtx->fwtype == FWMgrFWMMF)

   123         {

   124         /* set to adaptation */

   125         res = XAPlaybackRateItfAdaptMMF_SetPropertyConstraints((XAAdaptationMMFCtx*)impl->adaptCtx, constraints);

   126         }

   127     else

   128         {

   129         DEBUG_ERR("XA_RESULT_FEATURE_UNSUPPORTED");

   130         res = XA_RESULT_FEATURE_UNSUPPORTED;          

   131         }

   132     

   133     XA_IMPL_THREAD_SAFETY_EXIT( XATSMediaPlayer );

   134     DEBUG_API("<-XAPlaybackRateItfImpl_SetPropertyConstraints");

   135     return res;

   136 }

   137 

   138 XAresult XAPlaybackRateItfImpl_GetProperties(XAPlaybackRateItf self,

   139                                                XAuint32 *pProperties)

   140 {

   141     XAresult res = XA_RESULT_SUCCESS;

   142     XAPlaybackRateItfImpl *impl = GetImpl(self);

   143     DEBUG_API("->XAPlaybackRateItfImpl_GetProperties");

   144 

   145     if( !impl || !pProperties )

   146     {

   147         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   148         DEBUG_API("<-XAPlaybackRateItfImpl_GetProperties");

   149         return XA_RESULT_PARAMETER_INVALID;

   150     }

   151    

   152     if(impl->adaptCtx->fwtype == FWMgrFWMMF)

   153         {

   154         /* needs to be queried from adaptation */

   155         res = XAPlaybackRateItfAdaptMMF_GetProperties((XAAdaptationMMFCtx*)impl->adaptCtx, pProperties);

   156         }

   157     else

   158         {

   159         DEBUG_ERR("XA_RESULT_FEATURE_UNSUPPORTED");

   160         res = XA_RESULT_FEATURE_UNSUPPORTED;          

   161         }

   162     

   163     DEBUG_API("<-XAPlaybackRateItfImpl_GetProperties");

   164     return res;

   165 }

   166 

   167 XAresult XAPlaybackRateItfImpl_GetCapabilitiesOfRate(XAPlaybackRateItf self,

   168                                                        XApermille rate,

   169                                                        XAuint32 *pCapabilities)

   170 {

   171     XAresult res = XA_RESULT_SUCCESS;

   172     XAPlaybackRateItfImpl *impl = GetImpl(self);

   173     DEBUG_API("->XAPlaybackRateItfImpl_GetCapabilitiesOfRate");

   174 

   175     XA_IMPL_THREAD_SAFETY_ENTRY( XATSMediaPlayer );

   176     if( !impl || !pCapabilities )

   177     {

   178 

   179         XA_IMPL_THREAD_SAFETY_EXIT( XATSMediaPlayer );

   180         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   181         DEBUG_API("<-XAPlaybackRateItfImpl_GetCapabilitiesOfRate");

   182         return XA_RESULT_PARAMETER_INVALID;

   183     }

   184     

   185     if(impl->adaptCtx->fwtype == FWMgrFWMMF)

   186         {

   187         /* needs to be queried from adaptation */

   188         res = XAPlaybackRateItfAdaptMMF_GetCapabilitiesOfRate((XAAdaptationMMFCtx*)impl->adaptCtx, rate, pCapabilities);

   189         }

   190     else

   191         {

   192         DEBUG_ERR("XA_RESULT_FEATURE_UNSUPPORTED");

   193         res = XA_RESULT_FEATURE_UNSUPPORTED;          

   194         }

   195 

   196     XA_IMPL_THREAD_SAFETY_EXIT( XATSMediaPlayer );

   197     DEBUG_API("<-XAPlaybackRateItfImpl_GetCapabilitiesOfRate");

   198     return res;

   199 }

   200 

   201 XAresult XAPlaybackRateItfImpl_GetRateRange(XAPlaybackRateItf self,

   202                                               XAuint8 index,

   203                                               XApermille *pMinRate,

   204                                               XApermille *pMaxRate,

   205                                               XApermille *pStepSize,

   206                                               XAuint32 *pCapabilities)

   207 {

   208     XAresult res = XA_RESULT_SUCCESS;

   209     XAPlaybackRateItfImpl *impl = GetImpl(self);

   210     DEBUG_API("->XAPlaybackRateItfImpl_GetRateRange");

   211 

   212     XA_IMPL_THREAD_SAFETY_ENTRY( XATSMediaPlayer );

   213     if( !impl || !pMinRate || !pMaxRate || !pStepSize || !pCapabilities )

   214     {

   215         XA_IMPL_THREAD_SAFETY_EXIT( XATSMediaPlayer );

   216         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   217         DEBUG_API("<-XAPlaybackRateItfImpl_GetRateRange");

   218         return XA_RESULT_PARAMETER_INVALID;

   219     }

   220     

   221     if(impl->adaptCtx->fwtype == FWMgrFWMMF)

   222         {

   223         /* needs to be queried from adaptation */

   224         res = XAPlaybackRateItfAdaptMMF_GetRateRange((XAAdaptationMMFCtx*)impl->adaptCtx, index, pMinRate,

   225                                                   pMaxRate,pStepSize, pCapabilities);

   226         }

   227     else

   228         {

   229         DEBUG_ERR("XA_RESULT_FEATURE_UNSUPPORTED");

   230         res = XA_RESULT_FEATURE_UNSUPPORTED;          

   231         }

   232     

   233     XA_IMPL_THREAD_SAFETY_EXIT( XATSMediaPlayer );

   234     DEBUG_API("<-XAPlaybackRateItfImpl_GetRateRange");

   235     return res;

   236 }

   237 

   238 /**

   239  * XAPlaybackRateItfImpl -specific methods

   240  **/

   241 /**

   242  * XAPlaybackRateItfImpl* XAPlaybackRateItfImpl_Create();

   243  * @return  XAPlaybackRateItfImpl* - Pointer to  PlaybackRateItf interface implementation

   244  **/

   245 XAPlaybackRateItfImpl* XAPlaybackRateItfImpl_Create( XAMediaPlayerImpl *impl )

   246 {

   247     XAPlaybackRateItfImpl *self = (XAPlaybackRateItfImpl*)

   248         calloc(1,sizeof(XAPlaybackRateItfImpl));

   249     DEBUG_API("->XAPlaybackRateItfImpl_Create");

   250 

   251     if(self)

   252     {

   253         /* init itf default implementation */

   254         self->itf.GetCapabilitiesOfRate = XAPlaybackRateItfImpl_GetCapabilitiesOfRate;

   255         self->itf.GetProperties = XAPlaybackRateItfImpl_GetProperties;

   256         self->itf.GetRate = XAPlaybackRateItfImpl_GetRate;

   257         self->itf.GetRateRange = XAPlaybackRateItfImpl_GetRateRange;

   258         self->itf.SetPropertyConstraints = XAPlaybackRateItfImpl_SetPropertyConstraints;

   259         self->itf.SetRate = XAPlaybackRateItfImpl_SetRate;

   260 

   261         /* init variables */

   262         self->adaptCtx = impl->curAdaptCtx;

   263         self->currentRate = 1000;

   264         self->self = self;

   265     }

   266 

   267     DEBUG_API("<-XAPlaybackRateItfImpl_Create");

   268     return self;

   269 }

   270 

   271 /**

   272  * void XAPlaybackRateItfImpl_Free(XAPlaybackRateItfImpl* self);

   273  * @param  XAPlaybackRateItfImpl* self -

   274  **/

   275 void XAPlaybackRateItfImpl_Free(XAPlaybackRateItfImpl* self)

   276 {

   277     DEBUG_API("->XAPlaybackRateItfImpl_Free");

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

   279     free(self);

   280     DEBUG_API("<-XAPlaybackRateItfImpl_Free");

   281 }