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 |
21 |
22 #include "xavolumeitf.h" |
22 #include "xavolumeitf.h" |
23 #ifdef _GSTREAMER_BACKEND_ |
23 |
24 #include "XAVolumeItfAdaptation.h" |
24 #include "xavolumeitfadaptation.h" |
25 #endif |
25 #include "xanokiavolumeextitfadaptationmmf.h" |
26 /** |
26 /** |
27 * XAVolumeItfImpl* GetImpl(XAVolumeItf self) |
27 * XAVolumeItfImpl* GetImpl(XAVolumeItf self) |
28 * Description: Validated interface pointer and cast it to implementations pointer. |
28 * Description: Validated interface pointer and cast it to implementations pointer. |
29 **/ |
29 **/ |
30 static XAVolumeItfImpl* GetImpl(XAVolumeItf self) |
30 static XAVolumeItfImpl* GetImpl(XAVolumeItf self) |
71 DEBUG_API("<-XAVolumeItfImpl_SetVolumeLevel"); |
71 DEBUG_API("<-XAVolumeItfImpl_SetVolumeLevel"); |
72 /* invalid parameter */ |
72 /* invalid parameter */ |
73 return XA_RESULT_PARAMETER_INVALID; |
73 return XA_RESULT_PARAMETER_INVALID; |
74 } |
74 } |
75 |
75 |
76 #ifdef _GSTREAMER_BACKEND_ |
76 |
77 ret = XAVolumeItfAdapt_ThreadEntry(impl->adapCtx); |
77 ret = XAAdaptationBase_ThreadEntry(impl->adapCtx); |
78 if( ret == XA_RESULT_PARAMETER_INVALID || ret == XA_RESULT_PRECONDITIONS_VIOLATED ) |
78 if( ret == XA_RESULT_PARAMETER_INVALID || ret == XA_RESULT_PRECONDITIONS_VIOLATED ) |
79 { |
79 { |
80 DEBUG_API("<-XAVolumeItfImpl_SetVolumeLevel"); |
80 DEBUG_API("<-XAVolumeItfImpl_SetVolumeLevel"); |
81 return ret; |
81 return ret; |
82 } |
82 } |
83 |
83 if(impl->adapCtx->fwtype == FWMgrFWGST) |
84 ret = XAVolumeItfAdapt_SetVolumeLevel(impl->adapCtx, level); |
84 { |
85 |
85 ret = XAVolumeItfAdapt_SetVolumeLevel((XAAdaptationGstCtx*)impl->adapCtx, level); |
|
86 } |
|
87 else |
|
88 { |
|
89 impl->volumeLevel = level; |
|
90 } |
|
91 |
86 if(ret == XA_RESULT_SUCCESS) |
92 if(ret == XA_RESULT_SUCCESS) |
87 { |
93 { |
88 impl->volumeLevel = level; |
94 impl->volumeLevel = level; |
89 } |
95 } |
90 |
96 |
91 XAVolumeItfAdapt_ThreadExit(impl->adapCtx); |
97 XAAdaptationBase_ThreadExit(impl->adapCtx); |
92 #endif |
98 |
93 DEBUG_API("<-XAVolumeItfImpl_SetVolumeLevel"); |
99 DEBUG_API("<-XAVolumeItfImpl_SetVolumeLevel"); |
94 return ret ; |
100 return ret ; |
95 } |
101 } |
96 |
102 |
97 /** |
103 /** |
134 DEBUG_API("<-XAVolumeItfImpl_GetMaxVolumeLevel"); |
140 DEBUG_API("<-XAVolumeItfImpl_GetMaxVolumeLevel"); |
135 /* invalid parameter */ |
141 /* invalid parameter */ |
136 return XA_RESULT_PARAMETER_INVALID; |
142 return XA_RESULT_PARAMETER_INVALID; |
137 } |
143 } |
138 |
144 |
139 #ifdef _GSTREAMER_BACKEND_ |
145 |
140 ret = XAVolumeItfAdapt_ThreadEntry(impl->adapCtx); |
146 ret = XAAdaptationBase_ThreadEntry(impl->adapCtx); |
141 if( ret == XA_RESULT_PARAMETER_INVALID || ret == XA_RESULT_PRECONDITIONS_VIOLATED ) |
147 if( ret == XA_RESULT_PARAMETER_INVALID || ret == XA_RESULT_PRECONDITIONS_VIOLATED ) |
142 { |
148 { |
143 DEBUG_API("<-XAVolumeItfImpl_GetMaxVolumeLevel"); |
149 DEBUG_API("<-XAVolumeItfImpl_GetMaxVolumeLevel"); |
144 return ret; |
150 return ret; |
145 } |
151 } |
146 ret = XAVolumeItfAdapt_GetMaxVolumeLevel(impl->adapCtx, |
152 if(impl->adapCtx->fwtype == FWMgrFWGST) |
147 pMaxLevel); |
153 { |
148 |
154 ret = XAVolumeItfAdapt_GetMaxVolumeLevel((XAAdaptationGstCtx*)impl->adapCtx, |
149 XAVolumeItfAdapt_ThreadExit(impl->adapCtx); |
155 pMaxLevel); |
150 #endif |
156 } |
|
157 else |
|
158 { |
|
159 *pMaxLevel = MAX_SUPPORT_VOLUME_LEVEL; |
|
160 } |
|
161 |
|
162 XAAdaptationBase_ThreadExit(impl->adapCtx); |
|
163 |
151 DEBUG_API("<-XAVolumeItfImpl_GetMaxVolumeLevel"); |
164 DEBUG_API("<-XAVolumeItfImpl_GetMaxVolumeLevel"); |
152 return ret; |
165 return ret; |
153 } |
166 } |
154 |
167 |
155 /** |
168 /** |
168 DEBUG_API("<-XAVolumeItfImpl_SetMute"); |
181 DEBUG_API("<-XAVolumeItfImpl_SetMute"); |
169 /* invalid parameter */ |
182 /* invalid parameter */ |
170 return XA_RESULT_PARAMETER_INVALID; |
183 return XA_RESULT_PARAMETER_INVALID; |
171 } |
184 } |
172 |
185 |
173 #ifdef _GSTREAMER_BACKEND_ |
186 |
174 ret = XAVolumeItfAdapt_ThreadEntry(impl->adapCtx); |
187 ret = XAAdaptationBase_ThreadEntry(impl->adapCtx); |
175 if( ret == XA_RESULT_PARAMETER_INVALID || ret == XA_RESULT_PRECONDITIONS_VIOLATED ) |
188 if( ret == XA_RESULT_PARAMETER_INVALID || ret == XA_RESULT_PRECONDITIONS_VIOLATED ) |
176 { |
189 { |
177 DEBUG_API("<-XAVolumeItfImpl_SetMute"); |
190 DEBUG_API("<-XAVolumeItfImpl_SetMute"); |
178 return ret; |
191 return ret; |
179 } |
192 } |
180 /* check is mute state changed */ |
193 /* check is mute state changed */ |
181 if(mute != impl->mute) |
194 if(mute != impl->mute) |
182 { |
195 { |
183 ret = XAVolumeItfAdapt_SetMute(impl->adapCtx, mute); |
196 if(impl->adapCtx->fwtype == FWMgrFWMMF) |
|
197 { |
|
198 ret = XANokiaVolumeExtItfAdapt_SetMute((XAAdaptationMMFCtx*)impl->adapCtx, mute); |
|
199 } |
|
200 else |
|
201 { |
|
202 ret = XAVolumeItfAdapt_SetMute((XAAdaptationGstCtx*)impl->adapCtx, mute); |
|
203 } |
184 |
204 |
185 if(ret == XA_RESULT_SUCCESS) |
205 if(ret == XA_RESULT_SUCCESS) |
186 { |
206 { |
187 impl->mute = mute; |
207 impl->mute = mute; |
188 } |
208 } |
189 } |
209 } |
190 |
210 |
191 XAVolumeItfAdapt_ThreadExit(impl->adapCtx); |
211 XAAdaptationBase_ThreadExit(impl->adapCtx); |
192 #endif |
212 |
193 DEBUG_API("<-XAVolumeItfImpl_SetMute"); |
213 DEBUG_API("<-XAVolumeItfImpl_SetMute"); |
194 return ret; |
214 return ret; |
195 } |
215 } |
196 |
216 |
197 /** |
217 /** |
234 DEBUG_API("<-XAVolumeItfImpl_EnableStereoPosition"); |
254 DEBUG_API("<-XAVolumeItfImpl_EnableStereoPosition"); |
235 /* invalid parameter */ |
255 /* invalid parameter */ |
236 return XA_RESULT_PARAMETER_INVALID; |
256 return XA_RESULT_PARAMETER_INVALID; |
237 } |
257 } |
238 |
258 |
239 #ifdef _GSTREAMER_BACKEND_ |
259 |
240 ret = XAVolumeItfAdapt_ThreadEntry(impl->adapCtx); |
260 ret = XAAdaptationBase_ThreadEntry(impl->adapCtx); |
241 if( ret == XA_RESULT_PARAMETER_INVALID || ret == XA_RESULT_PRECONDITIONS_VIOLATED ) |
261 if( ret == XA_RESULT_PARAMETER_INVALID || ret == XA_RESULT_PRECONDITIONS_VIOLATED ) |
242 { |
262 { |
243 DEBUG_API("<-XAVolumeItfImpl_EnableStereoPosition"); |
263 DEBUG_API("<-XAVolumeItfImpl_EnableStereoPosition"); |
244 return ret; |
264 return ret; |
245 } |
265 } |
246 /* Check is stereo position state changed */ |
266 /* Check is stereo position state changed */ |
247 if(enable != impl->enableStereoPos) |
267 if(enable != impl->enableStereoPos) |
248 { |
268 { |
249 ret = XAVolumeItfAdapt_EnableStereoPosition(impl->adapCtx, |
269 if(impl->adapCtx->fwtype == FWMgrFWGST) |
|
270 { |
|
271 ret = XAVolumeItfAdapt_EnableStereoPosition((XAAdaptationGstCtx*)impl->adapCtx, |
250 enable); |
272 enable); |
251 |
273 } |
|
274 else |
|
275 { |
|
276 ret = XANokiaVolumeExtItfAdapt_EnableStereoPosition((XAAdaptationMMFCtx*)impl->adapCtx, |
|
277 enable); |
|
278 } |
252 if(ret == XA_RESULT_SUCCESS) |
279 if(ret == XA_RESULT_SUCCESS) |
253 { |
280 { |
254 impl->enableStereoPos = enable; |
281 impl->enableStereoPos = enable; |
255 } |
282 } |
256 } |
283 } |
257 |
284 |
258 XAVolumeItfAdapt_ThreadExit(impl->adapCtx); |
285 XAAdaptationBase_ThreadExit(impl->adapCtx); |
259 #endif |
286 |
260 DEBUG_API("<-XAVolumeItfImpl_EnableStereoPosition"); |
287 DEBUG_API("<-XAVolumeItfImpl_EnableStereoPosition"); |
261 return ret; |
288 return ret; |
262 } |
289 } |
263 |
290 |
264 /** |
291 /** |
308 return XA_RESULT_PARAMETER_INVALID; |
335 return XA_RESULT_PARAMETER_INVALID; |
309 } |
336 } |
310 |
337 |
311 impl->stereoPosition = stereoPosition; |
338 impl->stereoPosition = stereoPosition; |
312 |
339 |
313 #ifdef _GSTREAMER_BACKEND_ |
340 |
314 ret = XAVolumeItfAdapt_ThreadEntry(impl->adapCtx); |
341 ret = XAAdaptationBase_ThreadEntry(impl->adapCtx); |
315 if( ret == XA_RESULT_PARAMETER_INVALID || ret == XA_RESULT_PRECONDITIONS_VIOLATED ) |
342 if( ret == XA_RESULT_PARAMETER_INVALID || ret == XA_RESULT_PRECONDITIONS_VIOLATED ) |
316 { |
343 { |
317 DEBUG_API("<-XAVolumeItfImpl_SetStereoPosition"); |
344 DEBUG_API("<-XAVolumeItfImpl_SetStereoPosition"); |
318 return ret; |
345 return ret; |
319 } |
346 } |
320 /* check is stereo position effect enabled if is then handle effect */ |
347 /* check is stereo position effect enabled if is then handle effect */ |
321 if(impl->enableStereoPos) |
348 if(impl->enableStereoPos) |
322 { |
349 { |
323 ret = XAVolumeItfAdapt_SetStereoPosition(impl->adapCtx, |
350 if(impl->adapCtx->fwtype == FWMgrFWGST) |
|
351 { |
|
352 ret = XAVolumeItfAdapt_SetStereoPosition((XAAdaptationGstCtx*)impl->adapCtx, |
324 stereoPosition); |
353 stereoPosition); |
325 } |
354 } |
326 |
355 else |
327 XAVolumeItfAdapt_ThreadExit(impl->adapCtx); |
356 { |
328 #endif |
357 ret = XANokiaVolumeExtItfAdapt_SetStereoPosition((XAAdaptationMMFCtx*)impl->adapCtx, |
|
358 stereoPosition); |
|
359 } |
|
360 } |
|
361 |
|
362 XAAdaptationBase_ThreadExit(impl->adapCtx); |
|
363 |
329 DEBUG_API("<-XAVolumeItfImpl_SetStereoPosition"); |
364 DEBUG_API("<-XAVolumeItfImpl_SetStereoPosition"); |
330 return ret; |
365 return ret; |
331 } |
366 } |
332 |
367 |
333 /** |
368 /** |