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 #ifdef _GSTREAMER_BACKEND_  

    23 #include "XAPlaybackRateItfAdaptation.h"

    24 #endif

    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 #ifdef _GSTREAMER_BACKEND_

    60     res = XAPlaybackRateItfAdapt_SetRate(impl->adaptCtx, rate);

    61 #endif

    62     if(res == XA_RESULT_SUCCESS)

    63     {

    64         impl->currentRate = rate;

    65     }

    66 

    67     XA_IMPL_THREAD_SAFETY_EXIT( XATSMediaPlayer );

    68     DEBUG_API("<-XAPlaybackRateItfImpl_SetRate");

    69     return res;

    70 }

    71 

    72 XAresult XAPlaybackRateItfImpl_GetRate(XAPlaybackRateItf self, XApermille *pRate)

    73 {

    74     XAresult res = XA_RESULT_SUCCESS;

    75     XAPlaybackRateItfImpl *impl = GetImpl(self);

    76     DEBUG_API("->XAPlaybackRateItfImpl_GetRate");

    77 

    78     if( !impl || !pRate )

    79     {

    80         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

    81         DEBUG_API("<-XAPlaybackRateItfImpl_GetRate");

    82         return XA_RESULT_PARAMETER_INVALID;

    83     }

    84     *pRate = impl->currentRate;

    85 

    86     DEBUG_API("<-XAPlaybackRateItfImpl_GetRate");

    87     return res;

    88 }

    89 

    90 XAresult XAPlaybackRateItfImpl_SetPropertyConstraints(XAPlaybackRateItf self,

    91                                                         XAuint32 constraints)

    92 {

    93     XAresult res = XA_RESULT_SUCCESS;

    94     XAPlaybackRateItfImpl *impl = GetImpl(self);

    95     DEBUG_API("->XAPlaybackRateItfImpl_SetPropertyConstraints");

    96 

    97     XA_IMPL_THREAD_SAFETY_ENTRY( XATSMediaPlayer );

    98     if( !impl )

    99     {

   100         XA_IMPL_THREAD_SAFETY_EXIT( XATSMediaPlayer );

   101         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   102         DEBUG_API("<-XAPlaybackRateItfImpl_SetPropertyConstraints");

   103         return XA_RESULT_PARAMETER_INVALID;

   104     }

   105     

   106 #ifdef _GSTREAMER_BACKEND_

   107     /* set to adaptation */

   108     res = XAPlaybackRateItfAdapt_SetPropertyConstraints(impl->adaptCtx, constraints);

   109 #endif

   110     XA_IMPL_THREAD_SAFETY_EXIT( XATSMediaPlayer );

   111     DEBUG_API("<-XAPlaybackRateItfImpl_SetPropertyConstraints");

   112     return res;

   113 }

   114 

   115 XAresult XAPlaybackRateItfImpl_GetProperties(XAPlaybackRateItf self,

   116                                                XAuint32 *pProperties)

   117 {

   118     XAresult res = XA_RESULT_SUCCESS;

   119     XAPlaybackRateItfImpl *impl = GetImpl(self);

   120     DEBUG_API("->XAPlaybackRateItfImpl_GetProperties");

   121 

   122     if( !impl || !pProperties )

   123     {

   124         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   125         DEBUG_API("<-XAPlaybackRateItfImpl_GetProperties");

   126         return XA_RESULT_PARAMETER_INVALID;

   127     }

   128    

   129 #ifdef _GSTREAMER_BACKEND_

   130     /* needs to be queried from adaptation */

   131     res = XAPlaybackRateItfAdapt_GetProperties(impl->adaptCtx, pProperties);

   132 #endif

   133     DEBUG_API("<-XAPlaybackRateItfImpl_GetProperties");

   134     return res;

   135 }

   136 

   137 XAresult XAPlaybackRateItfImpl_GetCapabilitiesOfRate(XAPlaybackRateItf self,

   138                                                        XApermille rate,

   139                                                        XAuint32 *pCapabilities)

   140 {

   141     XAresult res = XA_RESULT_SUCCESS;

   142     XAPlaybackRateItfImpl *impl = GetImpl(self);

   143     DEBUG_API("->XAPlaybackRateItfImpl_GetCapabilitiesOfRate");

   144 

   145     XA_IMPL_THREAD_SAFETY_ENTRY( XATSMediaPlayer );

   146     if( !impl || !pCapabilities )

   147     {

   148 

   149         XA_IMPL_THREAD_SAFETY_EXIT( XATSMediaPlayer );

   150         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   151         DEBUG_API("<-XAPlaybackRateItfImpl_GetCapabilitiesOfRate");

   152         return XA_RESULT_PARAMETER_INVALID;

   153     }

   154     

   155 #ifdef _GSTREAMER_BACKEND_

   156     /* needs to be queried from adaptation */

   157     res = XAPlaybackRateItfAdapt_GetCapabilitiesOfRate(impl->adaptCtx, rate, pCapabilities);

   158 #endif

   159     XA_IMPL_THREAD_SAFETY_EXIT( XATSMediaPlayer );

   160     DEBUG_API("<-XAPlaybackRateItfImpl_GetCapabilitiesOfRate");

   161     return res;

   162 }

   163 

   164 XAresult XAPlaybackRateItfImpl_GetRateRange(XAPlaybackRateItf self,

   165                                               XAuint8 index,

   166                                               XApermille *pMinRate,

   167                                               XApermille *pMaxRate,

   168                                               XApermille *pStepSize,

   169                                               XAuint32 *pCapabilities)

   170 {

   171     XAresult res = XA_RESULT_SUCCESS;

   172     XAPlaybackRateItfImpl *impl = GetImpl(self);

   173     DEBUG_API("->XAPlaybackRateItfImpl_GetRateRange");

   174 

   175     XA_IMPL_THREAD_SAFETY_ENTRY( XATSMediaPlayer );

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

   177     {

   178         XA_IMPL_THREAD_SAFETY_EXIT( XATSMediaPlayer );

   179         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   180         DEBUG_API("<-XAPlaybackRateItfImpl_GetRateRange");

   181         return XA_RESULT_PARAMETER_INVALID;

   182     }

   183     

   184 #ifdef _GSTREAMER_BACKEND_

   185     /* needs to be queried from adaptation */

   186     res = XAPlaybackRateItfAdapt_GetRateRange(impl->adaptCtx, index, pMinRate,

   187                                               pMaxRate,pStepSize, pCapabilities);

   188 #endif

   189     XA_IMPL_THREAD_SAFETY_EXIT( XATSMediaPlayer );

   190     DEBUG_API("<-XAPlaybackRateItfImpl_GetRateRange");

   191     return res;

   192 }

   193 

   194 /**

   195  * XAPlaybackRateItfImpl -specific methods

   196  **/

   197 #ifdef _GSTREAMER_BACKEND_

   198 

   199 /**

   200  * XAPlaybackRateItfImpl* XAPlaybackRateItfImpl_Create();

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

   202  **/

   203 XAPlaybackRateItfImpl* XAPlaybackRateItfImpl_Create( XAAdaptationBaseCtx *adaptCtx )

   204 {

   205     XAPlaybackRateItfImpl *self = (XAPlaybackRateItfImpl*)

   206         calloc(1,sizeof(XAPlaybackRateItfImpl));

   207     DEBUG_API("->XAPlaybackRateItfImpl_Create");

   208 

   209     if(self)

   210     {

   211         /* init itf default implementation */

   212         self->itf.GetCapabilitiesOfRate = XAPlaybackRateItfImpl_GetCapabilitiesOfRate;

   213         self->itf.GetProperties = XAPlaybackRateItfImpl_GetProperties;

   214         self->itf.GetRate = XAPlaybackRateItfImpl_GetRate;

   215         self->itf.GetRateRange = XAPlaybackRateItfImpl_GetRateRange;

   216         self->itf.SetPropertyConstraints = XAPlaybackRateItfImpl_SetPropertyConstraints;

   217         self->itf.SetRate = XAPlaybackRateItfImpl_SetRate;

   218 

   219         /* init variables */

   220         self->adaptCtx = adaptCtx;

   221         self->currentRate = 1000;

   222         self->self = self;

   223     }

   224 

   225     DEBUG_API("<-XAPlaybackRateItfImpl_Create");

   226     return self;

   227 }

   228 #endif

   229 /**

   230  * void XAPlaybackRateItfImpl_Free(XAPlaybackRateItfImpl* self);

   231  * @param  XAPlaybackRateItfImpl* self -

   232  **/

   233 void XAPlaybackRateItfImpl_Free(XAPlaybackRateItfImpl* self)

   234 {

   235     DEBUG_API("->XAPlaybackRateItfImpl_Free");

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

   237     free(self);

   238     DEBUG_API("<-XAPlaybackRateItfImpl_Free");

   239 }