khronosfws/openmax_al/src/mediaplayer/xaplaybackrateitf.c
changeset 19 4a629bc82c5e
parent 12 5a06f39ad45b
child 28 ebf79c79991a
equal deleted inserted replaced
14:80975da52420 19:4a629bc82c5e
    17 
    17 
    18 #include <stdio.h>
    18 #include <stdio.h>
    19 #include <stdlib.h>
    19 #include <stdlib.h>
    20 #include <assert.h>
    20 #include <assert.h>
    21 #include "xaplaybackrateitf.h"
    21 #include "xaplaybackrateitf.h"
    22 #ifdef _GSTREAMER_BACKEND_  
    22 
    23 #include "XAPlaybackRateItfAdaptation.h"
    23 #include "xaplaybackrateitfadaptation.h"
    24 #endif
    24 
    25 #include "xathreadsafety.h"
    25 #include "xathreadsafety.h"
    26 
    26 
    27 static XAPlaybackRateItfImpl* GetImpl(XAPlaybackRateItf self)
    27 static XAPlaybackRateItfImpl* GetImpl(XAPlaybackRateItf self)
    28 {
    28 {
    29     if(self)
    29     if(self)
    54         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
    54         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
    55         DEBUG_API("<-XAPlaybackRateItfImpl_SetRate");
    55         DEBUG_API("<-XAPlaybackRateItfImpl_SetRate");
    56         return XA_RESULT_PARAMETER_INVALID;
    56         return XA_RESULT_PARAMETER_INVALID;
    57     }
    57     }
    58 
    58 
    59 #ifdef _GSTREAMER_BACKEND_
    59     if(impl->adaptCtx->fwtype == FWMgrFWGST)
    60     res = XAPlaybackRateItfAdapt_SetRate(impl->adaptCtx, rate);
    60         {
    61 #endif
    61         res = XAPlaybackRateItfAdapt_SetRate((XAAdaptationGstCtx*)impl->adaptCtx, rate);
       
    62         }
       
    63     else
       
    64         {
       
    65         DEBUG_ERR("XA_RESULT_FEATURE_UNSUPPORTED");
       
    66         res = XA_RESULT_FEATURE_UNSUPPORTED;          
       
    67         }
       
    68     
    62     if(res == XA_RESULT_SUCCESS)
    69     if(res == XA_RESULT_SUCCESS)
    63     {
    70     {
    64         impl->currentRate = rate;
    71         impl->currentRate = rate;
    65     }
    72     }
    66 
    73 
    79     {
    86     {
    80         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
    87         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
    81         DEBUG_API("<-XAPlaybackRateItfImpl_GetRate");
    88         DEBUG_API("<-XAPlaybackRateItfImpl_GetRate");
    82         return XA_RESULT_PARAMETER_INVALID;
    89         return XA_RESULT_PARAMETER_INVALID;
    83     }
    90     }
    84     *pRate = impl->currentRate;
    91     if(impl->adaptCtx->fwtype == FWMgrFWGST)
       
    92         {
       
    93         *pRate = impl->currentRate;
       
    94         }
       
    95     else
       
    96         {
       
    97         DEBUG_ERR("XA_RESULT_FEATURE_UNSUPPORTED");
       
    98         res = XA_RESULT_FEATURE_UNSUPPORTED;          
       
    99         }
    85 
   100 
    86     DEBUG_API("<-XAPlaybackRateItfImpl_GetRate");
   101     DEBUG_API("<-XAPlaybackRateItfImpl_GetRate");
    87     return res;
   102     return res;
    88 }
   103 }
    89 
   104 
   101         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
   116         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
   102         DEBUG_API("<-XAPlaybackRateItfImpl_SetPropertyConstraints");
   117         DEBUG_API("<-XAPlaybackRateItfImpl_SetPropertyConstraints");
   103         return XA_RESULT_PARAMETER_INVALID;
   118         return XA_RESULT_PARAMETER_INVALID;
   104     }
   119     }
   105     
   120     
   106 #ifdef _GSTREAMER_BACKEND_
   121     if(impl->adaptCtx->fwtype == FWMgrFWGST)
   107     /* set to adaptation */
   122         {
   108     res = XAPlaybackRateItfAdapt_SetPropertyConstraints(impl->adaptCtx, constraints);
   123         /* set to adaptation */
   109 #endif
   124         res = XAPlaybackRateItfAdapt_SetPropertyConstraints((XAAdaptationGstCtx*)impl->adaptCtx, constraints);
       
   125         }
       
   126     else
       
   127         {
       
   128         DEBUG_ERR("XA_RESULT_FEATURE_UNSUPPORTED");
       
   129         res = XA_RESULT_FEATURE_UNSUPPORTED;          
       
   130         }
       
   131     
   110     XA_IMPL_THREAD_SAFETY_EXIT( XATSMediaPlayer );
   132     XA_IMPL_THREAD_SAFETY_EXIT( XATSMediaPlayer );
   111     DEBUG_API("<-XAPlaybackRateItfImpl_SetPropertyConstraints");
   133     DEBUG_API("<-XAPlaybackRateItfImpl_SetPropertyConstraints");
   112     return res;
   134     return res;
   113 }
   135 }
   114 
   136 
   124         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
   146         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
   125         DEBUG_API("<-XAPlaybackRateItfImpl_GetProperties");
   147         DEBUG_API("<-XAPlaybackRateItfImpl_GetProperties");
   126         return XA_RESULT_PARAMETER_INVALID;
   148         return XA_RESULT_PARAMETER_INVALID;
   127     }
   149     }
   128    
   150    
   129 #ifdef _GSTREAMER_BACKEND_
   151     if(impl->adaptCtx->fwtype == FWMgrFWGST)
   130     /* needs to be queried from adaptation */
   152         {
   131     res = XAPlaybackRateItfAdapt_GetProperties(impl->adaptCtx, pProperties);
   153         /* needs to be queried from adaptation */
   132 #endif
   154         res = XAPlaybackRateItfAdapt_GetProperties((XAAdaptationGstCtx*)impl->adaptCtx, pProperties);
       
   155         }
       
   156     else
       
   157         {
       
   158         DEBUG_ERR("XA_RESULT_FEATURE_UNSUPPORTED");
       
   159         res = XA_RESULT_FEATURE_UNSUPPORTED;          
       
   160         }
       
   161     
   133     DEBUG_API("<-XAPlaybackRateItfImpl_GetProperties");
   162     DEBUG_API("<-XAPlaybackRateItfImpl_GetProperties");
   134     return res;
   163     return res;
   135 }
   164 }
   136 
   165 
   137 XAresult XAPlaybackRateItfImpl_GetCapabilitiesOfRate(XAPlaybackRateItf self,
   166 XAresult XAPlaybackRateItfImpl_GetCapabilitiesOfRate(XAPlaybackRateItf self,
   150         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
   179         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
   151         DEBUG_API("<-XAPlaybackRateItfImpl_GetCapabilitiesOfRate");
   180         DEBUG_API("<-XAPlaybackRateItfImpl_GetCapabilitiesOfRate");
   152         return XA_RESULT_PARAMETER_INVALID;
   181         return XA_RESULT_PARAMETER_INVALID;
   153     }
   182     }
   154     
   183     
   155 #ifdef _GSTREAMER_BACKEND_
   184     if(impl->adaptCtx->fwtype == FWMgrFWGST)
   156     /* needs to be queried from adaptation */
   185         {
   157     res = XAPlaybackRateItfAdapt_GetCapabilitiesOfRate(impl->adaptCtx, rate, pCapabilities);
   186         /* needs to be queried from adaptation */
   158 #endif
   187         res = XAPlaybackRateItfAdapt_GetCapabilitiesOfRate((XAAdaptationGstCtx*)impl->adaptCtx, rate, pCapabilities);
       
   188         }
       
   189     else
       
   190         {
       
   191         DEBUG_ERR("XA_RESULT_FEATURE_UNSUPPORTED");
       
   192         res = XA_RESULT_FEATURE_UNSUPPORTED;          
       
   193         }
       
   194 
   159     XA_IMPL_THREAD_SAFETY_EXIT( XATSMediaPlayer );
   195     XA_IMPL_THREAD_SAFETY_EXIT( XATSMediaPlayer );
   160     DEBUG_API("<-XAPlaybackRateItfImpl_GetCapabilitiesOfRate");
   196     DEBUG_API("<-XAPlaybackRateItfImpl_GetCapabilitiesOfRate");
   161     return res;
   197     return res;
   162 }
   198 }
   163 
   199 
   178         XA_IMPL_THREAD_SAFETY_EXIT( XATSMediaPlayer );
   214         XA_IMPL_THREAD_SAFETY_EXIT( XATSMediaPlayer );
   179         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
   215         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
   180         DEBUG_API("<-XAPlaybackRateItfImpl_GetRateRange");
   216         DEBUG_API("<-XAPlaybackRateItfImpl_GetRateRange");
   181         return XA_RESULT_PARAMETER_INVALID;
   217         return XA_RESULT_PARAMETER_INVALID;
   182     }
   218     }
   183     
   219     if(impl->adaptCtx->fwtype == FWMgrFWGST)
   184 #ifdef _GSTREAMER_BACKEND_
   220         {
   185     /* needs to be queried from adaptation */
   221         /* needs to be queried from adaptation */
   186     res = XAPlaybackRateItfAdapt_GetRateRange(impl->adaptCtx, index, pMinRate,
   222         res = XAPlaybackRateItfAdapt_GetRateRange((XAAdaptationGstCtx*)impl->adaptCtx, index, pMinRate,
   187                                               pMaxRate,pStepSize, pCapabilities);
   223                                                   pMaxRate,pStepSize, pCapabilities);
   188 #endif
   224         }
       
   225     else
       
   226         {
       
   227         DEBUG_ERR("XA_RESULT_FEATURE_UNSUPPORTED");
       
   228         res = XA_RESULT_FEATURE_UNSUPPORTED;          
       
   229         }
       
   230     
   189     XA_IMPL_THREAD_SAFETY_EXIT( XATSMediaPlayer );
   231     XA_IMPL_THREAD_SAFETY_EXIT( XATSMediaPlayer );
   190     DEBUG_API("<-XAPlaybackRateItfImpl_GetRateRange");
   232     DEBUG_API("<-XAPlaybackRateItfImpl_GetRateRange");
   191     return res;
   233     return res;
   192 }
   234 }
   193 
   235 
   194 /**
   236 /**
   195  * XAPlaybackRateItfImpl -specific methods
   237  * XAPlaybackRateItfImpl -specific methods
   196  **/
   238  **/
   197 #ifdef _GSTREAMER_BACKEND_
       
   198 
       
   199 /**
   239 /**
   200  * XAPlaybackRateItfImpl* XAPlaybackRateItfImpl_Create();
   240  * XAPlaybackRateItfImpl* XAPlaybackRateItfImpl_Create();
   201  * @return  XAPlaybackRateItfImpl* - Pointer to  PlaybackRateItf interface implementation
   241  * @return  XAPlaybackRateItfImpl* - Pointer to  PlaybackRateItf interface implementation
   202  **/
   242  **/
   203 XAPlaybackRateItfImpl* XAPlaybackRateItfImpl_Create( XAAdaptationBaseCtx *adaptCtx )
   243 XAPlaybackRateItfImpl* XAPlaybackRateItfImpl_Create( XAMediaPlayerImpl *impl )
   204 {
   244 {
   205     XAPlaybackRateItfImpl *self = (XAPlaybackRateItfImpl*)
   245     XAPlaybackRateItfImpl *self = (XAPlaybackRateItfImpl*)
   206         calloc(1,sizeof(XAPlaybackRateItfImpl));
   246         calloc(1,sizeof(XAPlaybackRateItfImpl));
   207     DEBUG_API("->XAPlaybackRateItfImpl_Create");
   247     DEBUG_API("->XAPlaybackRateItfImpl_Create");
   208 
   248 
   215         self->itf.GetRateRange = XAPlaybackRateItfImpl_GetRateRange;
   255         self->itf.GetRateRange = XAPlaybackRateItfImpl_GetRateRange;
   216         self->itf.SetPropertyConstraints = XAPlaybackRateItfImpl_SetPropertyConstraints;
   256         self->itf.SetPropertyConstraints = XAPlaybackRateItfImpl_SetPropertyConstraints;
   217         self->itf.SetRate = XAPlaybackRateItfImpl_SetRate;
   257         self->itf.SetRate = XAPlaybackRateItfImpl_SetRate;
   218 
   258 
   219         /* init variables */
   259         /* init variables */
   220         self->adaptCtx = adaptCtx;
   260         self->adaptCtx = impl->curAdaptCtx;
   221         self->currentRate = 1000;
   261         self->currentRate = 1000;
   222         self->self = self;
   262         self->self = self;
   223     }
   263     }
   224 
   264 
   225     DEBUG_API("<-XAPlaybackRateItfImpl_Create");
   265     DEBUG_API("<-XAPlaybackRateItfImpl_Create");
   226     return self;
   266     return self;
   227 }
   267 }
   228 #endif
   268 
   229 /**
   269 /**
   230  * void XAPlaybackRateItfImpl_Free(XAPlaybackRateItfImpl* self);
   270  * void XAPlaybackRateItfImpl_Free(XAPlaybackRateItfImpl* self);
   231  * @param  XAPlaybackRateItfImpl* self -
   271  * @param  XAPlaybackRateItfImpl* self -
   232  **/
   272  **/
   233 void XAPlaybackRateItfImpl_Free(XAPlaybackRateItfImpl* self)
   273 void XAPlaybackRateItfImpl_Free(XAPlaybackRateItfImpl* self)