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 "xaimagecontrolsitf.h"

    22 #ifdef _GSTREAMER_BACKEND_  

    23 #include "XAImageControlsItfAdaptation.h"

    24 #endif

    25 /**

    26  * XAImageControlsItfImpl* GetImpl(XAVolumeItf self)

    27  * Description: Validated interface pointer and cast it to implementations pointer.

    28  **/

    29 static XAImageControlsItfImpl* GetImpl(XAImageControlsItf self)

    30 {

    31     if(self)

    32     {

    33         XAImageControlsItfImpl* impl = (XAImageControlsItfImpl*)(*self);

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

    35         {

    36             return impl;

    37         }

    38     }

    39     return NULL;

    40 }

    41 

    42 /**

    43  * Base interface XAImageControlsItf implementation

    44  */

    45 

    46 /**

    47  * XAresult XAImageControlsItfImpl_SetBrightness(XAImageControlsItf self,

    48  *                                               XAuint32 brightness)

    49  * Description: Sets the brightness level.

    50  **/

    51 XAresult XAImageControlsItfImpl_SetBrightness(XAImageControlsItf self,

    52                                               XAuint32 brightness)

    53 {

    54     XAresult ret = XA_RESULT_SUCCESS;

    55     XAImageControlsItfImpl* impl = GetImpl(self);

    56     DEBUG_API("->XAImageControlsItfImpl_SetBrightness");

    57 

    58     if(!impl || brightness > MAX_BRIGHTNESS_VALUE)

    59     {

    60         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

    61         /* invalid parameter */

    62         DEBUG_API("<-XAImageControlsItfImpl_SetBrightness");

    63         return XA_RESULT_PARAMETER_INVALID;

    64     }

    65 

    66 #ifdef _GSTREAMER_BACKEND_  

    67     ret = XAImageControlsItfAdapt_ThreadEntry(impl->adapCtx);

    68     if( ret == XA_RESULT_PARAMETER_INVALID || ret == XA_RESULT_PRECONDITIONS_VIOLATED )

    69     {

    70         DEBUG_API("<-XAImageControlsItfImpl_SetBrightness");

    71         return ret;

    72     }

    73     ret = XAImageControlsItfAdapt_SetBrightness(impl->adapCtx, brightness);

    74 

    75     if(ret == XA_RESULT_SUCCESS)

    76     {

    77         impl->brightness = brightness;

    78     }

    79 

    80     XAImageControlsItfAdapt_ThreadExit(impl->adapCtx);

    81 #endif

    82     DEBUG_API("<-XAImageControlsItfImpl_SetBrightness");

    83     return ret;

    84 }

    85 

    86 /**

    87  * XAresult XAImageControlsItfImpl_SetBrightness(XAImageControlsItf self,

    88  *                                               XAuint32 *pBrightness)

    89  * Description: Gets the current brightness level.

    90  **/

    91 XAresult XAImageControlsItfImpl_GetBrightness(XAImageControlsItf self,

    92                                               XAuint32 *pBrightness)

    93 {

    94     XAresult ret = XA_RESULT_SUCCESS;

    95     XAImageControlsItfImpl* impl = GetImpl(self);

    96     DEBUG_API("->XAImageControlsItfImpl_GetBrightness");

    97 

    98     if(!impl || !pBrightness)

    99     {

   100         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   101         /* invalid parameter */

   102         DEBUG_API("<-XAImageControlsItfImpl_GetBrightness");

   103         return XA_RESULT_PARAMETER_INVALID;

   104     }

   105 

   106     *pBrightness = impl->brightness;

   107 

   108     DEBUG_API("<-XAImageControlsItfImpl_GetBrightness");

   109     return ret;

   110 }

   111 

   112 /**

   113  * XAresult XAImageControlsItfImpl_SetContrast(XAImageControlsItf self,

   114  *                                             XAint32 contrast)

   115  * Description: Sets the contrast level.

   116  **/

   117 XAresult XAImageControlsItfImpl_SetContrast(XAImageControlsItf self,

   118                                             XAint32 contrast)

   119 {

   120     XAresult ret = XA_RESULT_SUCCESS;

   121     XAImageControlsItfImpl* impl = GetImpl(self);

   122     DEBUG_API("->XAImageControlsItfImpl_SetContrast");

   123 

   124     if(!impl || (contrast < MIN_CONTRAST_VALUE || contrast > MAX_CONTRAST_VALUE))

   125     {

   126         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   127         /* invalid parameter */

   128         DEBUG_API("<-XAImageControlsItfImpl_SetContrast");

   129         return XA_RESULT_PARAMETER_INVALID;

   130     }

   131 

   132 #ifdef _GSTREAMER_BACKEND_  

   133     ret = XAImageControlsItfAdapt_ThreadEntry(impl->adapCtx);

   134     if( ret == XA_RESULT_PARAMETER_INVALID || ret == XA_RESULT_PRECONDITIONS_VIOLATED)

   135     {

   136         DEBUG_API("<-XAImageControlsItfImpl_SetContrast");

   137         return ret;

   138     }

   139     ret = XAImageControlsItfAdapt_SetContrast(impl->adapCtx, contrast);

   140 

   141     if(ret == XA_RESULT_SUCCESS)

   142     {

   143         impl->contrast = contrast;

   144     }

   145 

   146     XAImageControlsItfAdapt_ThreadExit(impl->adapCtx);

   147 #endif    

   148     DEBUG_API("<-XAImageControlsItfImpl_SetContrast");

   149     return ret;

   150 }

   151 

   152 /**

   153  * XAresult XAImageControlsItfImpl_GetContrast(XAImageControlsItf self,

   154  *                                             XAint32 *pContrast)

   155  * Description: Gets the contrast level.

   156  **/

   157 XAresult XAImageControlsItfImpl_GetContrast(XAImageControlsItf self,

   158                                             XAint32 *pContrast)

   159 {

   160     XAresult ret = XA_RESULT_SUCCESS;

   161     XAImageControlsItfImpl* impl = GetImpl(self);

   162     DEBUG_API("->XAImageControlsItfImpl_GetContrast");

   163 

   164     if(!impl || !pContrast)

   165     {

   166         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   167         /* invalid parameter */

   168         DEBUG_API("<-XAImageControlsItfImpl_GetContrast");

   169         return XA_RESULT_PARAMETER_INVALID;

   170     }

   171 

   172     *pContrast = impl->contrast;

   173 

   174     DEBUG_API("<-XAImageControlsItfImpl_GetContrast");

   175     return ret;

   176 }

   177 

   178 /**

   179  * XAresult XAImageControlsItfImpl_SetGamma(XAImageControlsItf self,

   180  *                                          XApermille gamma)

   181  * Description: Sets the gamma level.

   182  **/

   183 XAresult XAImageControlsItfImpl_SetGamma(XAImageControlsItf self,

   184                                          XApermille gamma)

   185 {

   186     XAresult ret = XA_RESULT_SUCCESS;

   187     XAImageControlsItfImpl* impl = GetImpl(self);

   188     XApermille  minGammaValue = 0;

   189     XApermille  maxGammaValue = 0;

   190     XAuint32    numSettings = 0;

   191     DEBUG_API("->XAImageControlsItfImpl_SetGamma");

   192 

   193     /* check supported min and max gamma levels */

   194     ret = XAImageControlsItfImpl_GetSupportedGammaSettings(self, &minGammaValue,

   195                                                            &maxGammaValue, &numSettings, NULL);

   196 

   197     if(!impl || (gamma < minGammaValue || gamma > maxGammaValue) ||

   198        ret != XA_RESULT_SUCCESS)

   199     {

   200         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   201         /* invalid parameter */

   202         DEBUG_API("<-XAImageControlsItfImpl_SetGamma");

   203         return XA_RESULT_PARAMETER_INVALID;

   204     }

   205 

   206 #ifdef _GSTREAMER_BACKEND_  

   207     ret = XAImageControlsItfAdapt_ThreadEntry(impl->adapCtx);

   208     if( ret == XA_RESULT_PARAMETER_INVALID || ret == XA_RESULT_PRECONDITIONS_VIOLATED )

   209     {

   210         DEBUG_API("<-XAImageControlsItfImpl_SetGamma");

   211         return ret;

   212     }

   213     ret = XAImageControlsItfAdapt_SetGamma(impl->adapCtx, gamma);

   214 

   215     if(ret == XA_RESULT_SUCCESS)

   216     {

   217         impl->gamma = gamma;

   218     }

   219 

   220     XAImageControlsItfAdapt_ThreadExit(impl->adapCtx);

   221 #endif

   222     DEBUG_API("<-XAImageControlsItfImpl_SetGamma");

   223     return ret;

   224 }

   225 

   226 /**

   227  * XAresult XAImageControlsItfImpl_GetGamma(XAImageControlsItf self,

   228  *                                          XApermille *pGamma)

   229  * Description: Gets the gamma level.

   230  **/

   231 XAresult XAImageControlsItfImpl_GetGamma(XAImageControlsItf self,

   232                                          XApermille *pGamma)

   233 {

   234     XAresult ret = XA_RESULT_SUCCESS;

   235     XAImageControlsItfImpl* impl = GetImpl(self);

   236     DEBUG_API("->XAImageControlsItfImpl_GetGamma");

   237 

   238     if(!impl || !pGamma)

   239     {

   240         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   241         /* invalid parameter */

   242         DEBUG_API("<-XAImageControlsItfImpl_GetGamma");

   243         return XA_RESULT_PARAMETER_INVALID;

   244     }

   245 

   246     *pGamma = impl->gamma;

   247 

   248     DEBUG_API("<-XAImageControlsItfImpl_GetGamma");

   249     return ret;

   250 }

   251 

   252 /**

   253  * XAresult XAImageControlsItfImpl_GetSupportedGammaSettings(XAImageControlsItf self,

   254  *                                                           XApermille *pMinValue,

   255  *                                                           XApermille *pMaxValue,

   256  *                                                           XAuint32 *pNumSettings,

   257  *                                                           XApermille **ppSettings)

   258  * Description: This method gets the supported gamma settings.

   259  **/

   260 XAresult XAImageControlsItfImpl_GetSupportedGammaSettings(XAImageControlsItf self,

   261                                                           XApermille *pMinValue,

   262                                                           XApermille *pMaxValue,

   263                                                           XAuint32 *pNumSettings,

   264                                                           XApermille **ppSettings)

   265 {

   266     XAresult ret = XA_RESULT_SUCCESS;

   267     XAImageControlsItfImpl* impl = GetImpl(self);

   268     DEBUG_API("->XAImageControlsItfImpl_GetSupportedGammaSettings");

   269 

   270     if(!impl || !pMinValue || !pMaxValue || !pNumSettings)

   271     {

   272         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   273         /* invalid parameter */

   274         DEBUG_API("<-XAImageControlsItfImpl_GetSupportedGammaSettings");

   275         return XA_RESULT_PARAMETER_INVALID;

   276     }

   277 

   278 #ifdef _GSTREAMER_BACKEND_  

   279     ret = XAImageControlsItfAdapt_ThreadEntry(impl->adapCtx);

   280     if( ret == XA_RESULT_PARAMETER_INVALID || ret == XA_RESULT_PRECONDITIONS_VIOLATED )

   281     {

   282         DEBUG_API("<-XAImageControlsItfImpl_GetSupportedGammaSettings");

   283         return ret;

   284     }

   285     /* if ppSettings is non-null and non-continuos from min and max gamma value is

   286      * supported then pnunSettings is length of the ppSettings array. Else

   287      * pNumSettings returns the number of supported gamma settings. */

   288     if( ppSettings && pNumSettings != 0 )

   289     {

   290         /* solve array of supported gamma settings */

   291         ret = XAImageControlsItfAdapt_GetSupportedGammaSettings(impl->adapCtx,

   292                                                                 pMinValue, pMaxValue,

   293                                                                 pNumSettings, ppSettings);

   294     }

   295     else

   296     {

   297         /* Solve min and max values and numSettings */

   298         ret = XAImageControlsItfAdapt_GetSupportedGammaSettings(impl->adapCtx,

   299                                                                 pMinValue, pMaxValue,

   300                                                                 pNumSettings, NULL);

   301     }

   302 

   303     XAImageControlsItfAdapt_ThreadExit(impl->adapCtx);

   304 #endif

   305     DEBUG_API("<-XAImageControlsItfImpl_GetSupportedGammaSettings");

   306     return ret;

   307 }

   308 

   309 /**

   310  * XAImageControlsItfImpl -specific methods

   311  **/

   312 #ifdef _GSTREAMER_BACKEND_  

   313 

   314 /**

   315  * XAImageControlsItfImplImpl* XAImageControlsItfImpl_Create()

   316  * @return  XAImageControlsItfImplImpl* - Pointer to  ImageControlsItf interface implementation

   317  **/

   318 XAImageControlsItfImpl* XAImageControlsItfImpl_Create(XAAdaptationBaseCtx *adapCtx)

   319 {

   320     XAImageControlsItfImpl* self = (XAImageControlsItfImpl*)

   321         calloc(1,sizeof(XAImageControlsItfImpl));

   322     DEBUG_API("->XAImageControlsItfImpl_Create");

   323 

   324     if(self)

   325     {

   326         /* init itf default implementation */

   327         self->itf.GetBrightness = XAImageControlsItfImpl_GetBrightness;

   328         self->itf.GetContrast = XAImageControlsItfImpl_GetContrast;

   329         self->itf.GetGamma = XAImageControlsItfImpl_GetGamma;

   330         self->itf.GetSupportedGammaSettings = XAImageControlsItfImpl_GetSupportedGammaSettings;

   331         self->itf.SetBrightness = XAImageControlsItfImpl_SetBrightness;

   332         self->itf.SetContrast = XAImageControlsItfImpl_SetContrast;

   333         self->itf.SetGamma = XAImageControlsItfImpl_SetGamma;

   334 

   335         /* init variables */

   336         self->brightness = DEFAULT_BRIGHTNESS_VALUE;

   337         self->contrast = DEFAULT_CONTRAST_VALUE;

   338         self->gamma = DEFAULT_GAMMA_VALUE;

   339 

   340         self->adapCtx = adapCtx;

   341 

   342         self->self = self;

   343     }

   344     DEBUG_API("<-XAImageControlsItfImpl_Create");

   345     return self;

   346 }

   347 #endif

   348 /**

   349  * void XAImageControlsItfImpl_Free(XAImageControlsItfImpl* self)

   350  * @param  XAImageControlsItfImpl* self -

   351  **/

   352 void XAImageControlsItfImpl_Free(XAImageControlsItfImpl* self)

   353 {

   354     DEBUG_API("->XAImageControlsItfImpl_Free");

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

   356     free(self);

   357     DEBUG_API("<-XAImageControlsItfImpl_Free");

   358 }