WORK-IN-PROGRESS commit: threads working in symbian s60
[spandex:spandex.git] / sct / common / modules / openvg / sct_openvgmaskaction.c
1 /*
2  * Spandex benchmark and test framework.
3  *
4  * Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
5  *
6  * Contact: Kari J. Kangas <kari.j.kangas@nokia.com>
7  *
8  *   This framework is free software; you can redistribute it and/or modify it
9  * under the terms of the GNU Lesser General Public License as published by the
10  * Free Software Foundation, version 2.1 of the License.
11  *
12  *   This framework is distributed in the hope that it will be useful, but
13  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
15  * for more details.
16  *
17  *   You should have received a copy of the GNU Lesser General Public License
18  * along with this framework; if not, see <http://www.gnu.org/licenses/>.
19  *
20  */
21
22 #include "sct_openvgmaskaction.h"
23 #include "sct_sicommon.h"
24 #include "sct_utils.h"
25
26 #include "sct_vg.h"
27
28 #include <stdio.h>
29 #include <string.h>
30
31 /*!
32  *
33  *
34  */
35 void* sctiCreateOpenVGMaskActionContext( void* moduleContext, SCTAttributeList* attributes )
36 {
37     SCTOpenVGMaskActionContext* context;
38     SCTOpenVGModuleContext*     mc;
39
40     SCT_ASSERT_ALWAYS( moduleContext != NULL );
41     SCT_ASSERT_ALWAYS( attributes != NULL );
42
43     mc      = ( SCTOpenVGModuleContext* )( moduleContext );
44     context = ( SCTOpenVGMaskActionContext* )( siCommonMemoryAlloc( NULL, sizeof( SCTOpenVGMaskActionContext ) ) );
45     if( context == NULL )
46     {
47         SCT_LOG_ERROR( "Allocation failed in Mask@OpenVG action context creation." );
48         return NULL;
49     }
50     memset( context, 0, sizeof( SCTOpenVGMaskActionContext ) );
51
52     context->moduleContext = mc;
53
54     if( sctiParseOpenVGMaskActionAttributes( &( context->data ), attributes ) == SCT_FALSE )
55     {
56         sctiDestroyOpenVGMaskActionContext( context );
57         return NULL;
58     }
59
60     if( context->data.handleIndex >= 0 )
61     {
62         if( context->data.handleType == MASK_HANDLETYPE_IMAGE )
63         {
64             if( sctiOpenVGModuleIsValidImageIndex( context->moduleContext, context->data.handleIndex ) == SCT_FALSE )
65             {
66                 sctiDestroyOpenVGMaskActionContext( context );
67                 SCT_LOG_ERROR( "Invalid handle index in Mask@OpenVG action context creation." );
68                 return NULL;
69             }
70         }
71         else if( context->data.handleType == MASK_HANDLETYPE_MASK_LAYER )
72         {
73 #if defined( OPENVG_VERSION_1_1 )
74             if( sctiOpenVGModuleIsValidMaskLayerIndex( context->moduleContext, context->data.handleIndex ) == SCT_FALSE )
75             {
76                 sctiDestroyOpenVGMaskActionContext( context );
77                 SCT_LOG_ERROR( "Invalid handle index in Mask@OpenVG action context creation." );
78                 return NULL;
79             }
80 #endif  /* !defined( OPENVG_VERSION_1_1 ) */
81         }
82         else
83         {
84             sctiDestroyOpenVGMaskActionContext( context );
85             SCT_LOG_ERROR( "Invalid handle type in Mask@OpenVG action context creation." );
86             return NULL;
87         }
88     } 
89     else 
90     {
91         if( context->data.operation != VG_CLEAR_MASK && context->data.operation != VG_FILL_MASK )
92         {
93             sctiDestroyOpenVGMaskActionContext( context );
94             SCT_LOG_ERROR( "Unspecified handle index in Mask@OpenVG action context creation." );
95             return NULL;
96         }
97     }
98
99     return context;
100 }
101
102 /*!
103  *
104  *
105  */
106 void sctiDestroyOpenVGMaskActionContext( void* context )
107 {
108     if( context == NULL )
109     {
110         return;
111     }
112     siCommonMemoryFree( NULL, context );
113 }
114
115 /*!
116  *
117  *
118  */
119 SCTBoolean sctiOpenVGMaskActionInit( SCTAction* action, SCTBenchmark* benchmark )
120 {
121     SCTOpenVGMaskActionContext* context;
122     
123     SCT_ASSERT_ALWAYS( action != NULL );
124     SCT_ASSERT_ALWAYS( action->context != NULL );
125     SCT_ASSERT_ALWAYS( benchmark != NULL );
126
127     context = ( SCTOpenVGMaskActionContext* )( action->context );
128    
129 #if !defined( OPENVG_VERSION_1_1 )   
130     if( context->data.handleType == MASK_HANDLETYPE_MASK_LAYER )
131     {
132         SCT_LOG_ERROR( "Mask@OpenVG action init MaskLayer handle type not supported in OpenVG 1.0." );
133         return SCT_FALSE;
134     }
135 #else   /* !defined( OPENVG_VERSION_1_1 ) */
136     SCT_USE_VARIABLE( context );
137 #endif  /* !defined( OPENVG_VERSION_1_1 ) */
138
139     return SCT_TRUE;
140 }
141
142
143 /*!
144  *
145  *
146  */
147 SCTBoolean sctiOpenVGMaskActionExecute( SCTAction* action, int framenumber )
148 {
149     SCTOpenVGMaskActionContext* context;
150     OpenVGMaskActionData*       data;
151     VGErrorCode                 err;
152     VGHandle                    handle;
153
154     SCT_ASSERT( action != NULL );
155     SCT_ASSERT( action->context != NULL );
156     SCT_USE_VARIABLE( framenumber );
157
158     context = ( SCTOpenVGMaskActionContext* )( action->context );
159     data    = &( context->data );
160
161     if( data->handleIndex < 0 )
162     {
163         handle = VG_INVALID_HANDLE;
164     }
165     else
166     {
167         if( data->handleType == MASK_HANDLETYPE_IMAGE )
168         {
169             SCTOpenVGImage* image = sctiOpenVGModuleGetImage( context->moduleContext, data->handleIndex );
170             if( image == NULL )
171             {
172                 SCT_LOG_ERROR( "Invalid image in Mask@OpenVG action execute." );
173                 return SCT_FALSE;
174             }
175             SCT_ASSERT( image->image != VG_INVALID_HANDLE );
176
177             handle = ( VGHandle )( image->image );
178         }
179         else
180         {
181 #if !defined( OPENVG_VERSION_1_1 )
182             SCT_ASSERT_ALWAYS( 0 );
183             return SCT_FALSE;
184 #else   /* !defined( OPENVG_VERSION_1_1 ) */
185             SCTOpenVGMaskLayer* maskLayer = sctiOpenVGModuleGetMaskLayer( context->moduleContext, data->handleIndex );
186             if( maskLayer == NULL )
187             {
188                 SCT_LOG_ERROR( "Invalid mask layer in Mask@OpenVG action execute." );
189                 return SCT_FALSE;
190             }
191             SCT_ASSERT( maskLayer->maskLayer != VG_INVALID_HANDLE );
192
193             handle = ( VGHandle )( maskLayer->maskLayer );
194 #endif  /* !defined( OPENVG_VERSION_1_1 ) */
195         }
196     }
197
198 #if !defined( OPENVG_VERSION_1_1 )
199     vgMask( ( VGImage )( handle ),
200             data->operation, 
201             data->x,
202             data->y,
203             data->width,
204             data->height );
205 #else   /* !defined( OPENVG_VERSION_1_1 ) */
206     vgMask( handle, 
207             data->operation, 
208             data->x,
209             data->y,
210             data->width,
211             data->height );
212 #endif  /* !defined( OPENVG_VERSION_1_1 ) */
213
214 #if defined( SCT_OPENVG_MODULE_CHECK_ERRORS )
215     /* Check for errors. */
216     err = vgGetError();
217     if( err != VG_NO_ERROR )
218     {
219         char buf[ 256 ];
220         sprintf( buf, "VG error %s in Mask@OpenVG action execute.", sctiOpenVGGetErrorString( err ) );
221         SCT_LOG_ERROR( buf );
222         sctiOpenVGClearVGError();
223
224         return SCT_FALSE;
225     }
226 #else   /* defined( SCT_OPENVG_MODULE_CHECK_ERRORS ) */
227     SCT_USE_VARIABLE( err );
228 #endif  /* defined( SCT_OPENVG_MODULE_CHECK_ERRORS ) */
229
230     return SCT_TRUE;
231 }
232
233 /*!
234  *
235  *
236  */
237 void sctiOpenVGMaskActionTerminate( SCTAction* action )
238 {
239     SCT_USE_VARIABLE( action );
240 }
241
242 /*!
243  *
244  *
245  */
246 void sctiOpenVGMaskActionDestroy( SCTAction* action )
247 {
248     SCT_ASSERT_ALWAYS( action != NULL );
249
250     sctiDestroyOpenVGMaskActionContext( action->context );
251     action->context = NULL;
252 }