38 #include <string.h> |
38 #include <string.h> |
39 #include "xacapabilitiesmgr.h" |
39 #include "xacapabilitiesmgr.h" |
40 #include "xamediarecorderadaptctxmmf.h" |
40 #include "xamediarecorderadaptctxmmf.h" |
41 #include "xamediarecorderadaptctx.h" |
41 #include "xamediarecorderadaptctx.h" |
42 /* Static mapping of enumeration XAMediaRecorderInterfaces to interface iids */ |
42 /* Static mapping of enumeration XAMediaRecorderInterfaces to interface iids */ |
43 static const XAInterfaceID* xaMediaRecorderItfIIDs[MR_ITFCOUNT]= |
43 static const XAInterfaceID* xaMediaRecorderItfIIDs[MR_ITFCOUNT] = |
44 { |
44 { |
45 &XA_IID_OBJECT, |
45 &XA_IID_OBJECT, |
46 &XA_IID_AUDIOENCODER, |
46 &XA_IID_AUDIOENCODER, |
47 &XA_IID_CONFIGEXTENSION, |
47 &XA_IID_CONFIGEXTENSION, |
48 &XA_IID_DYNAMICINTERFACEMANAGEMENT, |
48 &XA_IID_DYNAMICINTERFACEMANAGEMENT, |
49 &XA_IID_EQUALIZER, |
49 &XA_IID_EQUALIZER, |
50 &XA_IID_IMAGECONTROLS, |
50 &XA_IID_IMAGECONTROLS, |
51 &XA_IID_IMAGEEFFECTS, |
51 &XA_IID_IMAGEEFFECTS, |
52 &XA_IID_IMAGEENCODER, |
52 &XA_IID_IMAGEENCODER, |
53 &XA_IID_METADATAINSERTION, |
53 &XA_IID_METADATAINSERTION, |
54 &XA_IID_RECORD, |
54 &XA_IID_RECORD, |
55 &XA_IID_SNAPSHOT, |
55 &XA_IID_SNAPSHOT, |
56 &XA_IID_VIDEOENCODER, |
56 &XA_IID_VIDEOENCODER, |
57 &XA_IID_VIDEOPOSTPROCESSING, |
57 &XA_IID_VIDEOPOSTPROCESSING, |
58 &XA_IID_VOLUME, |
58 &XA_IID_VOLUME, |
59 &XA_IID_METADATAEXTRACTION, |
59 &XA_IID_METADATAEXTRACTION, |
60 &XA_IID_METADATATRAVERSAL |
60 &XA_IID_METADATATRAVERSAL |
61 }; |
61 }; |
62 |
62 |
63 /* Global methods */ |
63 /* Global methods */ |
64 |
64 |
65 /* XAResult XAMediaRecorderImpl_Create |
65 /* XAResult XAMediaRecorderImpl_Create |
66 * Create object |
66 * Create object |
67 */ |
67 */ |
68 XAresult XAMediaRecorderImpl_CreateMediaRecorder(FrameworkMap* mapper, |
68 XAresult XAMediaRecorderImpl_CreateMediaRecorder(FrameworkMap* mapper, |
69 XACapabilities* capabilities, |
69 XACapabilities* capabilities, XAObjectItf* pRecorder, |
70 XAObjectItf* pRecorder, |
70 XADataSource* pAudioSrc, XADataSource* pImageVideoSrc, |
71 XADataSource* pAudioSrc, |
71 XADataSink* pDataSnk, XAuint32 numInterfaces, |
72 XADataSource* pImageVideoSrc, |
72 const XAInterfaceID *pInterfaceIds, |
73 XADataSink* pDataSnk, |
73 const XAboolean *pInterfaceRequired) |
74 XAuint32 numInterfaces, |
74 { |
75 const XAInterfaceID *pInterfaceIds, |
|
76 const XAboolean *pInterfaceRequired) |
|
77 { |
|
78 XAMediaRecorderImpl* pImpl = NULL; |
75 XAMediaRecorderImpl* pImpl = NULL; |
79 XAObjectItfImpl* pBaseObj = NULL; |
76 XAObjectItfImpl* pBaseObj = NULL; |
80 FWMgrFwType fwType; |
77 FWMgrFwType fwType; |
81 XAuint8 itfIdx; |
78 XAuint8 itfIdx; |
82 XAMediaType mediaType = XA_MEDIATYPE_UNKNOWN; |
79 XAMediaType mediaType = XA_MEDIATYPE_UNKNOWN; |
83 XAresult ret=XA_RESULT_SUCCESS; |
80 XAresult ret = XA_RESULT_SUCCESS; |
84 const char *uri = NULL; |
81 const char *uri = NULL; |
85 |
82 |
86 DEBUG_API("->XAMediaRecorderImpl_CreateMediaRecorder"); |
83 DEBUG_API("->XAMediaRecorderImpl_CreateMediaRecorder"); |
87 XA_IMPL_THREAD_SAFETY_ENTRY( XATSMediaRecorder ); |
84 XA_IMPL_THREAD_SAFETY_ENTRY( XATSMediaRecorder ); |
88 |
85 |
89 if( !pRecorder ) |
86 if (!pRecorder) |
90 { |
87 { |
91 /* invalid parameter */ |
88 /* invalid parameter */ |
92 XA_IMPL_THREAD_SAFETY_EXIT( XATSMediaRecorder ); |
89 XA_IMPL_THREAD_SAFETY_EXIT( XATSMediaRecorder ); |
93 DEBUG_ERR("XA_RESULT_PARAMETER_INVALID"); |
90 DEBUG_ERR("XA_RESULT_PARAMETER_INVALID"); |
94 DEBUG_API("<-XAMediaRecorderImpl_CreateMediaRecorder"); |
91 DEBUG_API("<-XAMediaRecorderImpl_CreateMediaRecorder"); |
95 return XA_RESULT_PARAMETER_INVALID; |
92 return XA_RESULT_PARAMETER_INVALID; |
96 } |
93 } |
97 |
94 |
98 /* check sink&source parameters */ |
95 /* check sink&source parameters */ |
99 ret = XACommon_ValidateDataLocator(3, pAudioSrc, pImageVideoSrc, pDataSnk); |
96 ret |
100 if(ret!=XA_RESULT_SUCCESS) |
97 = XACommon_ValidateDataLocator(3, pAudioSrc, pImageVideoSrc, |
101 { |
98 pDataSnk); |
|
99 if (ret != XA_RESULT_SUCCESS) |
|
100 { |
102 XA_IMPL_THREAD_SAFETY_EXIT( XATSMediaRecorder ); |
101 XA_IMPL_THREAD_SAFETY_EXIT( XATSMediaRecorder ); |
103 DEBUG_API("<-XAMediaRecorderImpl_CreateMediaRecorder"); |
102 DEBUG_API("<-XAMediaRecorderImpl_CreateMediaRecorder"); |
104 return ret; |
103 return ret; |
105 } |
104 } |
106 |
105 |
107 /* instantiate object implementation */ |
106 /* instantiate object implementation */ |
108 pImpl = (XAMediaRecorderImpl*)calloc(1,sizeof(XAMediaRecorderImpl)); |
107 pImpl = (XAMediaRecorderImpl*) calloc(1, sizeof(XAMediaRecorderImpl)); |
109 if( !pImpl ) |
108 if (!pImpl) |
110 { |
109 { |
111 |
110 |
112 /* memory allocation failed */ |
111 /* memory allocation failed */ |
113 XA_IMPL_THREAD_SAFETY_EXIT( XATSMediaRecorder ); |
112 XA_IMPL_THREAD_SAFETY_EXIT( XATSMediaRecorder ); |
114 DEBUG_ERR("XA_RESULT_MEMORY_FAILURE"); |
113 DEBUG_ERR("XA_RESULT_MEMORY_FAILURE"); |
115 DEBUG_API("<-XAMediaRecorderImpl_CreateMediaRecorder"); |
114 DEBUG_API("<-XAMediaRecorderImpl_CreateMediaRecorder"); |
116 return XA_RESULT_MEMORY_FAILURE; |
115 return XA_RESULT_MEMORY_FAILURE; |
117 } |
116 } |
118 pBaseObj = &pImpl->baseObj; |
117 pBaseObj = &pImpl->baseObj; |
119 |
118 |
120 /* Initialize base object default implementation */ |
119 /* Initialize base object default implementation */ |
121 XAObjectItfImpl_Init(pBaseObj, |
120 XAObjectItfImpl_Init(pBaseObj, MR_ITFCOUNT, xaMediaRecorderItfIIDs, |
122 MR_ITFCOUNT, |
121 XAMediaRecorderImpl_DoRealize, XAMediaRecorderImpl_DoResume, |
123 xaMediaRecorderItfIIDs, |
122 XAMediaRecorderImpl_FreeResources); |
124 XAMediaRecorderImpl_DoRealize, |
|
125 XAMediaRecorderImpl_DoResume, |
|
126 XAMediaRecorderImpl_FreeResources); |
|
127 |
123 |
128 /* Mark interfaces that need to be exposed */ |
124 /* Mark interfaces that need to be exposed */ |
129 /* Implicit and mandated interfaces */ |
125 /* Implicit and mandated interfaces */ |
130 pBaseObj->interfaceMap[MR_RECORDITF].required = XA_BOOLEAN_TRUE; |
126 pBaseObj->interfaceMap[MR_RECORDITF].required = XA_BOOLEAN_TRUE; |
131 if(pAudioSrc && mediaType!=XA_MEDIATYPE_IMAGE) |
127 if (pAudioSrc && mediaType != XA_MEDIATYPE_IMAGE) |
132 { |
128 { |
133 pBaseObj->interfaceMap[MR_AUDIOENCODERITF].required = XA_BOOLEAN_TRUE; |
129 pBaseObj->interfaceMap[MR_AUDIOENCODERITF].required = XA_BOOLEAN_TRUE; |
134 } |
130 } |
135 if(pImageVideoSrc && mediaType!=XA_MEDIATYPE_AUDIO) |
131 if (pImageVideoSrc && mediaType != XA_MEDIATYPE_AUDIO) |
136 { |
132 { |
137 pBaseObj->interfaceMap[MR_VIDEOENCODER].required = XA_BOOLEAN_TRUE; |
133 pBaseObj->interfaceMap[MR_VIDEOENCODER].required = XA_BOOLEAN_TRUE; |
138 pBaseObj->interfaceMap[MR_IMAGEENCODERITF].required = XA_BOOLEAN_TRUE; |
134 pBaseObj->interfaceMap[MR_IMAGEENCODERITF].required = XA_BOOLEAN_TRUE; |
139 pBaseObj->interfaceMap[MR_SNAPSHOTITF].required = XA_BOOLEAN_TRUE; |
135 pBaseObj->interfaceMap[MR_SNAPSHOTITF].required = XA_BOOLEAN_TRUE; |
140 } |
136 } |
141 pBaseObj->interfaceMap[MR_DIMITF].required = XA_BOOLEAN_TRUE; |
137 pBaseObj->interfaceMap[MR_DIMITF].required = XA_BOOLEAN_TRUE; |
142 |
138 |
143 /* Explicit interfaces */ |
139 /* Explicit interfaces */ |
144 if((numInterfaces != 0) && pInterfaceIds && pInterfaceRequired) |
140 if ((numInterfaces != 0) && pInterfaceIds && pInterfaceRequired) |
145 { |
141 { |
146 /* check only sink media type, do not care about return value (availability) */ |
142 /* check only sink media type, do not care about return value (availability) */ |
147 XACommon_CheckDataSource((XADataSource*)pDataSnk,&mediaType); |
143 XACommon_CheckDataSource((XADataSource*) pDataSnk, &mediaType); |
148 /* Check required interfaces */ |
144 /* Check required interfaces */ |
149 for( itfIdx = 0; itfIdx < numInterfaces; itfIdx++) |
145 for (itfIdx = 0; itfIdx < numInterfaces; itfIdx++) |
150 { |
146 { |
151 /* If mapEntry is null then required interface is not supported.*/ |
147 /* If mapEntry is null then required interface is not supported.*/ |
152 XAObjItfMapEntry *entry = |
148 XAObjItfMapEntry *entry = XAObjectItfImpl_GetItfEntry( |
153 XAObjectItfImpl_GetItfEntry((XAObjectItf)&(pBaseObj), pInterfaceIds[itfIdx]); |
149 (XAObjectItf) &(pBaseObj), pInterfaceIds[itfIdx]); |
154 if( !entry ) |
150 if (!entry) |
155 { |
|
156 if( pInterfaceRequired[itfIdx] ) |
|
157 { |
151 { |
|
152 if (pInterfaceRequired[itfIdx]) |
|
153 { |
158 /* required interface cannot be accommodated - fail creation */ |
154 /* required interface cannot be accommodated - fail creation */ |
159 DEBUG_ERR("Required interface not found - abort creation!"); |
155 DEBUG_ERR("Required interface not found - abort creation!"); |
160 ret = XA_RESULT_FEATURE_UNSUPPORTED; |
156 ret = XA_RESULT_FEATURE_UNSUPPORTED; |
161 break; |
157 break; |
|
158 } |
|
159 else |
|
160 { |
|
161 DEBUG_INFO("Requested (not required) interface not found - continue creation"); |
|
162 } |
162 } |
163 } |
163 else |
|
164 { |
|
165 DEBUG_INFO("Requested (not required) interface not found - continue creation"); |
|
166 } |
|
167 } |
|
168 else |
164 else |
169 { /* weed out unsupported content-aware itf's */ |
165 { /* weed out unsupported content-aware itf's */ |
170 if( ( (mediaType==XA_MEDIATYPE_IMAGE || !pAudioSrc) && |
166 if (((mediaType == XA_MEDIATYPE_IMAGE || !pAudioSrc) |
171 (entry->mapIdx==MR_EQUALIZERITF || |
167 && (entry->mapIdx == MR_EQUALIZERITF || entry->mapIdx |
172 entry->mapIdx==MR_VOLUMEITF || |
168 == MR_VOLUMEITF || entry->mapIdx |
173 entry->mapIdx==MR_AUDIOENCODERITF)) |
169 == MR_AUDIOENCODERITF)) || ((mediaType |
174 || |
170 == XA_MEDIATYPE_AUDIO || !pImageVideoSrc) |
175 ( (mediaType==XA_MEDIATYPE_AUDIO || !pImageVideoSrc) && |
171 && (entry->mapIdx == MR_IMAGECONTROLSITF |
176 (entry->mapIdx==MR_IMAGECONTROLSITF || |
172 || entry->mapIdx == MR_IMAGEEFFECTSITF |
177 entry->mapIdx==MR_IMAGEEFFECTSITF || |
173 || entry->mapIdx == MR_VIDEOPOSTPROCESSINGITF |
178 entry->mapIdx==MR_VIDEOPOSTPROCESSINGITF || |
174 || entry->mapIdx == MR_VIDEOENCODER |
179 entry->mapIdx==MR_VIDEOENCODER || |
175 || entry->mapIdx == MR_IMAGEENCODERITF |
180 entry->mapIdx==MR_IMAGEENCODERITF || |
176 || entry->mapIdx == MR_SNAPSHOTITF))) |
181 entry->mapIdx==MR_SNAPSHOTITF)) ) |
177 { |
182 { |
|
183 entry->required = XA_BOOLEAN_FALSE; |
178 entry->required = XA_BOOLEAN_FALSE; |
184 if( pInterfaceRequired[itfIdx] ) |
179 if (pInterfaceRequired[itfIdx]) |
185 { |
180 { |
186 DEBUG_ERR("Required interface not supported for given media - abort creation!"); |
181 DEBUG_ERR("Required interface not supported for given media - abort creation!"); |
187 ret = XA_RESULT_FEATURE_UNSUPPORTED; |
182 ret = XA_RESULT_FEATURE_UNSUPPORTED; |
188 break; |
183 break; |
|
184 } |
|
185 } |
|
186 else |
|
187 { |
|
188 entry->required = XA_BOOLEAN_TRUE; |
|
189 } |
|
190 |
|
191 if (entry->mapIdx == MR_SNAPSHOTITF) |
|
192 { |
|
193 DEBUG_ERR("SnapshotItf requested - support still mode"); |
|
194 pImpl->recModes |= XA_RECMODE_STILL; |
|
195 } |
|
196 if (entry->mapIdx == MR_RECORDITF) |
|
197 { |
|
198 DEBUG_ERR("RecordItf requested - support stream mode"); |
|
199 pImpl->recModes |= XA_RECMODE_STREAM; |
189 } |
200 } |
190 } |
201 } |
191 else |
202 } |
192 { |
203 } |
193 entry->required = XA_BOOLEAN_TRUE; |
204 if (pImpl->recModes == 0) |
194 } |
205 { |
195 |
|
196 if(entry->mapIdx==MR_SNAPSHOTITF) |
|
197 { |
|
198 DEBUG_ERR("SnapshotItf requested - support still mode"); |
|
199 pImpl->recModes |= XA_RECMODE_STILL; |
|
200 } |
|
201 if(entry->mapIdx==MR_RECORDITF) |
|
202 { |
|
203 DEBUG_ERR("RecordItf requested - support stream mode"); |
|
204 pImpl->recModes |= XA_RECMODE_STREAM; |
|
205 } |
|
206 } |
|
207 } |
|
208 } |
|
209 if( pImpl->recModes ==0 ) |
|
210 { |
|
211 DEBUG_ERR("Warning!!! No recording interfaces requested - unable to record!!"); |
206 DEBUG_ERR("Warning!!! No recording interfaces requested - unable to record!!"); |
212 } |
207 } |
213 /*check sink and src parameters*/ |
208 /*check sink and src parameters*/ |
214 if(ret==XA_RESULT_SUCCESS) |
209 if (ret == XA_RESULT_SUCCESS) |
215 { |
210 { |
216 ret = XACommon_ValidateDataLocator(3, pDataSnk, pAudioSrc, pImageVideoSrc); |
211 ret = XACommon_ValidateDataLocator(3, pDataSnk, pAudioSrc, |
|
212 pImageVideoSrc); |
217 /*datasink ignored if only snapshotitf is used*/ |
213 /*datasink ignored if only snapshotitf is used*/ |
218 if(!pDataSnk && (pImpl->recModes & XA_RECMODE_STREAM)) |
214 if (!pDataSnk && (pImpl->recModes & XA_RECMODE_STREAM)) |
219 { |
215 { |
220 DEBUG_ERR("No datasink to record to!"); |
216 DEBUG_ERR("No datasink to record to!"); |
221 ret = XA_RESULT_PARAMETER_INVALID; |
217 ret = XA_RESULT_PARAMETER_INVALID; |
222 } |
218 } |
223 if(!pAudioSrc && !pImageVideoSrc) |
219 if (!pAudioSrc && !pImageVideoSrc) |
224 { |
220 { |
225 DEBUG_ERR("No data sources set!"); |
221 DEBUG_ERR("No data sources set!"); |
226 ret = XA_RESULT_PARAMETER_INVALID; |
222 ret = XA_RESULT_PARAMETER_INVALID; |
227 } |
223 } |
228 } |
224 } |
229 |
225 |
230 if(ret!=XA_RESULT_SUCCESS) |
226 if (ret != XA_RESULT_SUCCESS) |
231 { /* creation fails */ |
227 { /* creation fails */ |
232 XAObjectItfImpl_Destroy((XAObjectItf)&(pBaseObj)); |
228 XAObjectItfImpl_Destroy((XAObjectItf) &(pBaseObj)); |
233 XA_IMPL_THREAD_SAFETY_EXIT( XATSMediaRecorder ); |
229 XA_IMPL_THREAD_SAFETY_EXIT( XATSMediaRecorder ); |
234 DEBUG_API("<-XAMediaRecorderImpl_CreateMediaRecorder"); |
230 DEBUG_API("<-XAMediaRecorderImpl_CreateMediaRecorder"); |
235 return ret; |
231 return ret; |
236 } |
232 } |
237 |
233 |
238 /* Mark interfaces that can be handled dynamically */ |
234 /* Mark interfaces that can be handled dynamically */ |
239 /* Mandated dynamic itfs */ |
235 /* Mandated dynamic itfs */ |
240 pBaseObj->interfaceMap[MR_METADATAINSERTIONITF].isDynamic = XA_BOOLEAN_TRUE; |
236 pBaseObj->interfaceMap[MR_METADATAINSERTIONITF].isDynamic |
|
237 = XA_BOOLEAN_TRUE; |
241 pBaseObj->interfaceMap[MR_EQUALIZERITF].isDynamic = XA_BOOLEAN_TRUE; |
238 pBaseObj->interfaceMap[MR_EQUALIZERITF].isDynamic = XA_BOOLEAN_TRUE; |
242 pBaseObj->interfaceMap[MR_IMAGEEFFECTSITF].isDynamic = XA_BOOLEAN_TRUE; |
239 pBaseObj->interfaceMap[MR_IMAGEEFFECTSITF].isDynamic = XA_BOOLEAN_TRUE; |
243 |
|
244 |
240 |
245 /* Initialize XAMediaRecorderImpl variables */ |
241 /* Initialize XAMediaRecorderImpl variables */ |
246 pImpl->audioSrc = pAudioSrc; |
242 pImpl->audioSrc = pAudioSrc; |
247 pImpl->dataSnk = pDataSnk; |
243 pImpl->dataSnk = pDataSnk; |
248 pImpl->imageVideoSrc = pImageVideoSrc; |
244 pImpl->imageVideoSrc = pImageVideoSrc; |
249 /* Determine framework type that can handle recording */ |
245 /* Determine framework type that can handle recording */ |
250 fwType = (FWMgrFwType)FWMgrMOUnknown; |
246 fwType = (FWMgrFwType) FWMgrMOUnknown; |
251 /**/ |
247 /**/ |
252 if (pDataSnk->pLocator) |
248 if (pDataSnk->pLocator) |
253 { |
249 { |
254 XADataLocator_URI* dataLoc = (XADataLocator_URI*)pDataSnk->pLocator; |
250 XADataLocator_URI* dataLoc = (XADataLocator_URI*) pDataSnk->pLocator; |
255 if (dataLoc->locatorType == XA_DATALOCATOR_URI) |
251 if (dataLoc->locatorType == XA_DATALOCATOR_URI) |
256 { |
252 { |
257 uri = (char*)dataLoc->URI; |
253 uri = (char*) dataLoc->URI; |
258 } |
254 } |
259 } |
255 } |
260 fwType = XAFrameworkMgr_GetFramework( |
256 fwType = XAFrameworkMgr_GetFramework(mapper, uri, FWMgrMORecorder); |
261 mapper, |
|
262 uri, |
|
263 FWMgrMORecorder); |
|
264 |
257 |
265 if (fwType == FWMgrMOUnknown) |
258 if (fwType == FWMgrMOUnknown) |
266 { |
259 { |
267 ret = XA_RESULT_CONTENT_UNSUPPORTED; |
260 ret = XA_RESULT_CONTENT_UNSUPPORTED; |
268 XAObjectItfImpl_Destroy((XAObjectItf)&(pBaseObj)); |
261 XAObjectItfImpl_Destroy((XAObjectItf) &(pBaseObj)); |
269 XA_IMPL_THREAD_SAFETY_EXIT( XATSMediaRecorder ); |
262 XA_IMPL_THREAD_SAFETY_EXIT( XATSMediaRecorder ); |
270 DEBUG_API("<-XAMediaRecorderImpl_CreateMediaRecorder"); |
263 DEBUG_API("<-XAMediaRecorderImpl_CreateMediaRecorder"); |
271 return ret; |
264 return ret; |
272 } |
265 } |
273 |
266 |
274 /* Set ObjectItf to point to newly created object */ |
267 /* Set ObjectItf to point to newly created object */ |
275 *pRecorder = (XAObjectItf)&(pBaseObj->self); |
268 *pRecorder = (XAObjectItf) &(pBaseObj->self); |
276 |
269 |
277 if(fwType == FWMgrFWMMF) |
270 if (fwType == FWMgrFWMMF) |
278 { |
271 { |
279 |
272 |
280 pImpl->adaptationCtx = XAMediaRecorderAdaptMMF_Create(pImpl->audioSrc, |
273 pImpl->adaptationCtx = XAMediaRecorderAdaptMMF_Create( |
281 pImpl->imageVideoSrc, pImpl->dataSnk, pImpl->recModes); |
274 pImpl->audioSrc, pImpl->imageVideoSrc, pImpl->dataSnk, |
282 } |
275 pImpl->recModes); |
|
276 } |
283 else |
277 else |
284 { |
278 { |
285 |
279 |
286 pImpl->adaptationCtx = XAMediaRecorderAdapt_Create(pImpl->audioSrc, |
280 pImpl->adaptationCtx = XAMediaRecorderAdapt_Create(pImpl->audioSrc, |
287 pImpl->imageVideoSrc, |
281 pImpl->imageVideoSrc, pImpl->dataSnk, pImpl->recModes); |
288 pImpl->dataSnk, |
282 } |
289 pImpl->recModes); |
283 |
290 } |
284 if (pImpl->adaptationCtx) |
291 |
|
292 if(pImpl->adaptationCtx) |
|
293 { |
285 { |
294 pImpl->adaptationCtx->capslist = capabilities; |
286 pImpl->adaptationCtx->capslist = capabilities; |
295 pImpl->adaptationCtx->fwtype = fwType; |
287 pImpl->adaptationCtx->fwtype = fwType; |
296 } |
288 } |
297 else |
289 else |
298 { |
290 { |
299 ret = XA_RESULT_MEMORY_FAILURE; |
291 ret = XA_RESULT_MEMORY_FAILURE; |
300 XAObjectItfImpl_Destroy((XAObjectItf)&(pBaseObj)); |
292 XAObjectItfImpl_Destroy((XAObjectItf) &(pBaseObj)); |
301 XA_IMPL_THREAD_SAFETY_EXIT( XATSMediaRecorder ); |
293 XA_IMPL_THREAD_SAFETY_EXIT( XATSMediaRecorder ); |
302 DEBUG_API("<-XAMediaRecorderImpl_CreateMediaRecorder"); |
294 DEBUG_API("<-XAMediaRecorderImpl_CreateMediaRecorder"); |
303 return ret; |
295 return ret; |
304 } |
296 } |
305 |
297 |
306 XA_IMPL_THREAD_SAFETY_EXIT( XATSMediaRecorder ); |
298 XA_IMPL_THREAD_SAFETY_EXIT( XATSMediaRecorder ); |
307 DEBUG_API("<-XAMediaRecorderImpl_CreateMediaRecorder"); |
299 DEBUG_API("<-XAMediaRecorderImpl_CreateMediaRecorder"); |
308 return XA_RESULT_SUCCESS; |
300 return XA_RESULT_SUCCESS; |
309 } |
301 } |
310 |
302 |
311 /* XAResult XAMediaRecorderImpl_QueryNumSupportedInterfaces |
303 /* XAResult XAMediaRecorderImpl_QueryNumSupportedInterfaces |
312 * Statically query supported interfaces |
304 * Statically query supported interfaces |
313 */ |
305 */ |
314 XAresult XAMediaRecorderImpl_QueryNumSupportedInterfaces(XAuint32 *pNumSupportedInterfaces) |
306 XAresult XAMediaRecorderImpl_QueryNumSupportedInterfaces( |
315 { |
307 XAuint32 *pNumSupportedInterfaces) |
|
308 { |
316 DEBUG_API("->XAMediaRecorderImpl_QueryNumSupportedInterfaces"); |
309 DEBUG_API("->XAMediaRecorderImpl_QueryNumSupportedInterfaces"); |
317 if( pNumSupportedInterfaces ) |
310 if (pNumSupportedInterfaces) |
318 { |
311 { |
319 *pNumSupportedInterfaces = MR_ITFCOUNT; |
312 *pNumSupportedInterfaces = MR_ITFCOUNT; |
320 |
313 |
321 DEBUG_API("<-XAMediaRecorderImpl_QueryNumSupportedInterfaces"); |
314 DEBUG_API("<-XAMediaRecorderImpl_QueryNumSupportedInterfaces"); |
322 return XA_RESULT_SUCCESS; |
315 return XA_RESULT_SUCCESS; |
323 } |
316 } |
324 else |
317 else |
325 { |
318 { |
326 DEBUG_ERR("XA_RESULT_PARAMETER_INVALID"); |
319 DEBUG_ERR("XA_RESULT_PARAMETER_INVALID"); |
327 return XA_RESULT_PARAMETER_INVALID; |
320 return XA_RESULT_PARAMETER_INVALID; |
328 } |
321 } |
329 } |
322 } |
330 /* XAResult XAMediaRecorderImpl_QuerySupportedInterfaces |
323 /* XAResult XAMediaRecorderImpl_QuerySupportedInterfaces |
331 * Statically query supported interfaces |
324 * Statically query supported interfaces |
332 */ |
325 */ |
333 XAresult XAMediaRecorderImpl_QuerySupportedInterfaces(XAuint32 index, |
326 XAresult XAMediaRecorderImpl_QuerySupportedInterfaces(XAuint32 index, |
334 XAInterfaceID *pInterfaceId) |
327 XAInterfaceID *pInterfaceId) |
335 { |
328 { |
336 DEBUG_API("->XAMediaRecorderImpl_QuerySupportedInterfaces"); |
329 DEBUG_API("->XAMediaRecorderImpl_QuerySupportedInterfaces"); |
337 if( index >= MR_ITFCOUNT || !pInterfaceId ) |
330 if (index >= MR_ITFCOUNT || !pInterfaceId) |
338 { |
331 { |
339 DEBUG_ERR("XA_RESULT_PARAMETER_INVALID"); |
332 DEBUG_ERR("XA_RESULT_PARAMETER_INVALID"); |
340 return XA_RESULT_PARAMETER_INVALID; |
333 return XA_RESULT_PARAMETER_INVALID; |
341 } |
334 } |
342 else |
335 else |
343 { |
336 { |
344 *pInterfaceId = *(xaMediaRecorderItfIIDs[index]); |
337 *pInterfaceId = *(xaMediaRecorderItfIIDs[index]); |
345 |
338 |
346 DEBUG_API("<-XAMediaRecorderImpl_QuerySupportedInterfaces"); |
339 DEBUG_API("<-XAMediaRecorderImpl_QuerySupportedInterfaces"); |
347 return XA_RESULT_SUCCESS; |
340 return XA_RESULT_SUCCESS; |
348 } |
341 } |
349 } |
342 } |
350 |
343 |
351 /***************************************************************************** |
344 /***************************************************************************** |
352 * base object XAObjectItfImpl methods |
345 * base object XAObjectItfImpl methods |
353 *****************************************************************************/ |
346 *****************************************************************************/ |
354 |
347 |
355 /* XAresult XAMediaRecorderImpl_DoRealize( XAObjectItf self ) |
348 /* XAresult XAMediaRecorderImpl_DoRealize( XAObjectItf self ) |
356 * Description: Realize all implicit and explicitly wanted interfaces. |
349 * Description: Realize all implicit and explicitly wanted interfaces. |
357 * Create and initialize implementation-specific variables. |
350 * Create and initialize implementation-specific variables. |
358 * Called from base object XAObjectItfImpl |
351 * Called from base object XAObjectItfImpl |
359 */ |
352 */ |
360 XAresult XAMediaRecorderImpl_DoRealize( XAObjectItf self ) |
353 XAresult XAMediaRecorderImpl_DoRealize(XAObjectItf self) |
361 { |
354 { |
362 XAuint8 itfIdx; |
355 XAuint8 itfIdx; |
363 XAObjectItfImpl* pObj = (XAObjectItfImpl*)(*self); |
356 XAObjectItfImpl* pObj = (XAObjectItfImpl*) (*self); |
364 XAMediaRecorderImpl* pObjImpl = (XAMediaRecorderImpl*)(pObj); |
357 XAMediaRecorderImpl* pObjImpl = (XAMediaRecorderImpl*) (pObj); |
365 XAresult ret = XA_RESULT_SUCCESS; |
358 XAresult ret = XA_RESULT_SUCCESS; |
366 |
|
367 |
359 |
368 DEBUG_API("->XAMediaRecorderImpl_DoRealize"); |
360 DEBUG_API("->XAMediaRecorderImpl_DoRealize"); |
369 XA_IMPL_THREAD_SAFETY_ENTRY( XATSMediaRecorder ); |
361 XA_IMPL_THREAD_SAFETY_ENTRY( XATSMediaRecorder ); |
370 |
362 |
371 /* check casting from correct pointer type */ |
363 /* check casting from correct pointer type */ |
372 if( !pObjImpl || pObj != pObjImpl->baseObj.self ) |
364 if (!pObjImpl || pObj != pObjImpl->baseObj.self) |
373 { |
365 { |
374 DEBUG_ERR("XA_RESULT_PARAMETER_INVALID"); |
366 DEBUG_ERR("XA_RESULT_PARAMETER_INVALID"); |
375 /* invalid parameter */ |
367 /* invalid parameter */ |
376 XA_IMPL_THREAD_SAFETY_EXIT( XATSMediaRecorder ); |
368 XA_IMPL_THREAD_SAFETY_EXIT( XATSMediaRecorder ); |
377 return XA_RESULT_PARAMETER_INVALID; |
369 return XA_RESULT_PARAMETER_INVALID; |
378 } |
370 } |
379 |
371 |
380 /* init adaptation */ |
372 /* init adaptation */ |
381 if(pObjImpl->adaptationCtx->fwtype == FWMgrFWMMF) |
373 if (pObjImpl->adaptationCtx->fwtype == FWMgrFWMMF) |
382 { |
374 { |
383 ret = XAMediaRecorderAdaptMMF_PostInit( (XAAdaptationMMFCtx*)pObjImpl->adaptationCtx ); |
375 ret = XAMediaRecorderAdaptMMF_PostInit( |
384 } |
376 (XAAdaptationMMFCtx*) pObjImpl->adaptationCtx); |
|
377 } |
385 else |
378 else |
386 { |
379 { |
387 ret = XAMediaRecorderAdapt_PostInit( (XAAdaptationGstCtx*)pObjImpl->adaptationCtx ); |
380 ret = XAMediaRecorderAdapt_PostInit( |
388 } |
381 (XAAdaptationGstCtx*) pObjImpl->adaptationCtx); |
389 |
382 } |
390 if( ret != XA_RESULT_SUCCESS ) |
383 |
391 { |
384 if (ret != XA_RESULT_SUCCESS) |
|
385 { |
392 XA_IMPL_THREAD_SAFETY_EXIT( XATSMediaRecorder ); |
386 XA_IMPL_THREAD_SAFETY_EXIT( XATSMediaRecorder ); |
393 return ret; |
387 return ret; |
394 } |
388 } |
395 |
389 |
396 /* Realize all implicit and explicitly wanted interfaces */ |
390 /* Realize all implicit and explicitly wanted interfaces */ |
397 for( itfIdx = 0; itfIdx < MR_ITFCOUNT; itfIdx++ ) |
391 for (itfIdx = 0; itfIdx < MR_ITFCOUNT; itfIdx++) |
398 { |
392 { |
399 if( !(pObj->interfaceMap[itfIdx].pItf) && |
393 if (!(pObj->interfaceMap[itfIdx].pItf) |
400 pObj->interfaceMap[itfIdx].required ) |
394 && pObj->interfaceMap[itfIdx].required) |
401 { |
395 { |
402 void *pItf = NULL; |
396 void *pItf = NULL; |
403 switch( itfIdx ) |
397 switch (itfIdx) |
404 { |
398 { |
405 case MR_DIMITF: |
399 case MR_DIMITF: |
406 pItf = XADIMItfImpl_Create(); |
400 pItf = XADIMItfImpl_Create(); |
407 if(pItf) |
401 if (pItf) |
408 { |
402 { |
409 XADIMItfImpl_Init(pItf, self, |
403 XADIMItfImpl_Init(pItf, self, |
410 XAMediaRecorderImpl_DoAddItf, |
404 XAMediaRecorderImpl_DoAddItf, |
411 XAMediaRecorderImpl_DoResumeItf, |
405 XAMediaRecorderImpl_DoResumeItf, |
412 XAMediaRecorderImpl_DoRemoveItf); |
406 XAMediaRecorderImpl_DoRemoveItf); |
413 } |
407 } |
414 break; |
408 break; |
415 case MR_RECORDITF: |
409 case MR_RECORDITF: |
416 pItf = XARecordItfImpl_Create( pObjImpl ); |
410 pItf = XARecordItfImpl_Create(pObjImpl); |
417 break; |
411 break; |
418 case MR_AUDIOENCODERITF: |
412 case MR_AUDIOENCODERITF: |
419 pItf = XAAudioEncoderItfImpl_Create(pObjImpl); |
413 pItf = XAAudioEncoderItfImpl_Create(pObjImpl); |
420 break; |
414 break; |
421 case MR_SNAPSHOTITF: |
415 #ifdef OMAX_CAMERABIN |
|
416 case MR_SNAPSHOTITF: |
422 pItf = XASnapshotItfImpl_Create(pObjImpl); |
417 pItf = XASnapshotItfImpl_Create(pObjImpl); |
423 break; |
418 break; |
424 case MR_VIDEOENCODER: |
419 case MR_VIDEOENCODER: |
425 pItf = XAVideoEncoderItfImpl_Create(pObjImpl); |
420 pItf = XAVideoEncoderItfImpl_Create(pObjImpl); |
426 break; |
421 break; |
427 case MR_IMAGEENCODERITF: |
422 case MR_IMAGEENCODERITF: |
428 pItf = XAImageEncoderItfImpl_Create(pObjImpl); |
423 pItf = XAImageEncoderItfImpl_Create(pObjImpl); |
429 break; |
424 break; |
|
425 #endif |
430 case MR_METADATAINSERTIONITF: |
426 case MR_METADATAINSERTIONITF: |
431 pItf = XAMetadataInsertionItfImpl_Create(pObjImpl); |
427 pItf = XAMetadataInsertionItfImpl_Create(pObjImpl); |
432 break; |
428 break; |
433 |
429 |
434 case MR_CONFIGEXTENSIONITF: |
430 case MR_CONFIGEXTENSIONITF: |
435 pItf = XAConfigExtensionsItfImpl_Create(); |
431 pItf = XAConfigExtensionsItfImpl_Create(); |
436 XAConfigExtensionsItfImpl_SetContext( pItf, pObjImpl->adaptationCtx); |
432 XAConfigExtensionsItfImpl_SetContext(pItf, |
|
433 pObjImpl->adaptationCtx); |
437 break; |
434 break; |
438 case MR_EQUALIZERITF: |
435 case MR_EQUALIZERITF: |
439 pItf = XAEqualizerItfImpl_Create( pObjImpl->adaptationCtx ); |
436 pItf = XAEqualizerItfImpl_Create(pObjImpl->adaptationCtx); |
440 break; |
437 break; |
441 case MR_IMAGECONTROLSITF: |
438 #ifdef OMAX_CAMERABIN |
|
439 case MR_IMAGECONTROLSITF: |
442 pItf = XAImageControlsItfImpl_Create( pObjImpl->adaptationCtx ); |
440 pItf = XAImageControlsItfImpl_Create( pObjImpl->adaptationCtx ); |
443 break; |
441 break; |
444 case MR_IMAGEEFFECTSITF: |
442 case MR_IMAGEEFFECTSITF: |
445 pItf = XAImageEffectsItfImpl_Create( pObjImpl->adaptationCtx ); |
443 pItf = XAImageEffectsItfImpl_Create( pObjImpl->adaptationCtx ); |
446 break; |
444 break; |
447 case MR_VIDEOPOSTPROCESSINGITF: |
445 case MR_VIDEOPOSTPROCESSINGITF: |
448 pItf = XAVideoPostProcessingItfImpl_Create( pObjImpl->adaptationCtx ); |
446 pItf = XAVideoPostProcessingItfImpl_Create( pObjImpl->adaptationCtx ); |
449 break; |
447 break; |
|
448 #endif |
450 case MR_VOLUMEITF: |
449 case MR_VOLUMEITF: |
451 pItf = XAVolumeItfImpl_Create( pObjImpl->adaptationCtx ); |
450 pItf = XAVolumeItfImpl_Create(pObjImpl->adaptationCtx); |
452 break; |
451 break; |
453 case MR_METADATAEXTRACTIONITF: |
452 case MR_METADATAEXTRACTIONITF: |
454 pItf = XAMetadataExtractionItfImpl_Create( pObjImpl->adaptationCtx ); |
453 pItf = XAMetadataExtractionItfImpl_Create( |
|
454 pObjImpl->adaptationCtx); |
455 break; |
455 break; |
456 case MR_METADATATRAVERSALITF: |
456 case MR_METADATATRAVERSALITF: |
457 pItf = XAMetadataTraversalItfImpl_Create( pObjImpl->adaptationCtx ); |
457 pItf = XAMetadataTraversalItfImpl_Create( |
458 break; |
458 pObjImpl->adaptationCtx); |
459 |
459 break; |
|
460 |
460 default: |
461 default: |
461 break; |
462 break; |
462 } |
463 } |
463 if( !pItf ) |
464 if (!pItf) |
464 { |
465 { |
465 DEBUG_ERR("XA_RESULT_MEMORY_FAILURE"); |
466 DEBUG_ERR("XA_RESULT_MEMORY_FAILURE"); |
466 /* memory allocation failed */ |
467 /* memory allocation failed */ |
467 XA_IMPL_THREAD_SAFETY_EXIT( XATSMediaRecorder ); |
468 XA_IMPL_THREAD_SAFETY_EXIT( XATSMediaRecorder ); |
468 return XA_RESULT_MEMORY_FAILURE; |
469 return XA_RESULT_MEMORY_FAILURE; |
469 } |
470 } |
470 else |
471 else |
471 { |
472 { |
472 pObj->interfaceMap[itfIdx].pItf = pItf; |
473 pObj->interfaceMap[itfIdx].pItf = pItf; |
473 } |
474 } |
474 } |
475 } |
475 } |
476 } |
476 |
477 |
477 pObj->state = XA_OBJECT_STATE_REALIZED; |
478 pObj->state = XA_OBJECT_STATE_REALIZED; |
478 DEBUG_API("<-XAMediaRecorderImpl_DoRealize"); |
479 DEBUG_API("<-XAMediaRecorderImpl_DoRealize"); |
479 XA_IMPL_THREAD_SAFETY_EXIT( XATSMediaRecorder ); |
480 XA_IMPL_THREAD_SAFETY_EXIT( XATSMediaRecorder ); |
480 return XA_RESULT_SUCCESS; |
481 return XA_RESULT_SUCCESS; |
481 } |
482 } |
482 |
483 |
483 /* XAresult XAMediaRecorderImpl_DoResume |
484 /* XAresult XAMediaRecorderImpl_DoResume |
484 * Description: Resume object from suspended state |
485 * Description: Resume object from suspended state |
485 */ |
486 */ |
486 XAresult XAMediaRecorderImpl_DoResume(XAObjectItf self) |
487 XAresult XAMediaRecorderImpl_DoResume(XAObjectItf self) |
487 { |
488 { |
488 DEBUG_API("->XAMediaRecorderImpl_DoResume"); |
489 DEBUG_API("->XAMediaRecorderImpl_DoResume"); |
489 DEBUG_API("<-XAMediaRecorderImpl_DoResume"); |
490 DEBUG_API("<-XAMediaRecorderImpl_DoResume"); |
490 /* This implementation does not support suspended state */ |
491 /* This implementation does not support suspended state */ |
491 return XA_RESULT_PRECONDITIONS_VIOLATED; |
492 return XA_RESULT_PRECONDITIONS_VIOLATED; |
492 } |
493 } |
493 |
494 |
494 /* void XAMediaRecorderImpl_FreeResources |
495 /* void XAMediaRecorderImpl_FreeResources |
495 * Description: Free all resources reserved at XAMediaRecorderImpl_DoRealize() |
496 * Description: Free all resources reserved at XAMediaRecorderImpl_DoRealize() |
496 */ |
497 */ |
497 void XAMediaRecorderImpl_FreeResources(XAObjectItf self) |
498 void XAMediaRecorderImpl_FreeResources(XAObjectItf self) |
498 { |
499 { |
499 XAObjectItfImpl* pObj = (XAObjectItfImpl*)(*self); |
500 XAObjectItfImpl* pObj = (XAObjectItfImpl*) (*self); |
500 XAMediaRecorderImpl* pObjImpl = (XAMediaRecorderImpl*)(pObj); |
501 XAMediaRecorderImpl* pObjImpl = (XAMediaRecorderImpl*) (pObj); |
501 XAuint8 itfIdx; |
502 XAuint8 itfIdx; |
502 XAMediaRecorderImpl* pImpl = (XAMediaRecorderImpl*)(*self); |
503 XAMediaRecorderImpl* pImpl = (XAMediaRecorderImpl*) (*self); |
503 DEBUG_API("->XAMediaRecorderImpl_FreeResources"); |
504 DEBUG_API("->XAMediaRecorderImpl_FreeResources"); |
504 XA_IMPL_THREAD_SAFETY_ENTRY_FOR_VOID_FUNCTIONS( XATSMediaRecorder ); |
505 XA_IMPL_THREAD_SAFETY_ENTRY_FOR_VOID_FUNCTIONS( XATSMediaRecorder ); |
505 assert( pObj && pImpl && pObj == pObj->self ); |
506 assert( pObj && pImpl && pObj == pObj->self ); |
506 |
507 |
507 /* free all allocated interfaces */ |
508 /* free all allocated interfaces */ |
508 for(itfIdx = 0; itfIdx < MR_ITFCOUNT; itfIdx++) |
509 for (itfIdx = 0; itfIdx < MR_ITFCOUNT; itfIdx++) |
509 { |
510 { |
510 void *pItf = pObj->interfaceMap[itfIdx].pItf; |
511 void *pItf = pObj->interfaceMap[itfIdx].pItf; |
511 if(pItf) |
512 if (pItf) |
512 { |
513 { |
513 switch(itfIdx) |
514 switch (itfIdx) |
514 { |
515 { |
515 case MR_AUDIOENCODERITF: |
516 case MR_AUDIOENCODERITF: |
516 XAAudioEncoderItfImpl_Free(pItf); |
517 XAAudioEncoderItfImpl_Free(pItf); |
517 break; |
518 break; |
518 case MR_CONFIGEXTENSIONITF: |
519 case MR_CONFIGEXTENSIONITF: |
519 XAConfigExtensionsItfImpl_Free(pItf); |
520 XAConfigExtensionsItfImpl_Free(pItf); |
557 case MR_METADATATRAVERSALITF: |
562 case MR_METADATATRAVERSALITF: |
558 XAMetadataTraversalItfImpl_Free(pItf); |
563 XAMetadataTraversalItfImpl_Free(pItf); |
559 break; |
564 break; |
560 default: |
565 default: |
561 break; |
566 break; |
562 } |
567 } |
563 pObj->interfaceMap[itfIdx].pItf = NULL; |
568 pObj->interfaceMap[itfIdx].pItf = NULL; |
564 } |
569 } |
565 } |
570 } |
566 |
571 |
567 if ( pImpl->adaptationCtx != NULL ) |
572 if (pImpl->adaptationCtx != NULL) |
568 { |
573 { |
569 if(pImpl->adaptationCtx->fwtype == FWMgrFWMMF) |
574 if (pImpl->adaptationCtx->fwtype == FWMgrFWMMF) |
570 { |
575 { |
571 XAMediaRecorderAdaptMMF_Destroy( (XAAdaptationMMFCtx*)pObjImpl->adaptationCtx ); |
576 XAMediaRecorderAdaptMMF_Destroy( |
|
577 (XAAdaptationMMFCtx*) pObjImpl->adaptationCtx); |
572 } |
578 } |
573 else |
579 else |
574 { |
580 { |
575 XAMediaRecorderAdapt_Destroy( (XAAdaptationGstCtx*)pImpl->adaptationCtx ); |
581 XAMediaRecorderAdapt_Destroy( |
|
582 (XAAdaptationGstCtx*) pImpl->adaptationCtx); |
576 } |
583 } |
577 pImpl->adaptationCtx = NULL; |
584 pImpl->adaptationCtx = NULL; |
578 } |
585 } |
579 |
586 |
580 /* free all other allocated resources*/ |
587 /* free all other allocated resources*/ |
581 |
588 |
582 DEBUG_API("<-XAMediaRecorderImpl_FreeResources"); |
589 DEBUG_API("<-XAMediaRecorderImpl_FreeResources"); |
583 XA_IMPL_THREAD_SAFETY_EXIT_FOR_VOID_FUNCTIONS( XATSMediaRecorder ); |
590 XA_IMPL_THREAD_SAFETY_EXIT_FOR_VOID_FUNCTIONS( XATSMediaRecorder ); |
584 return; |
591 return; |
585 } |
592 } |
586 |
593 |
587 /***************************************************************************** |
594 /***************************************************************************** |
588 * MediaRecorderImpl -specific methods |
595 * MediaRecorderImpl -specific methods |
589 *****************************************************************************/ |
596 *****************************************************************************/ |
590 |
597 |
591 /* XAMediaRecorderImpl_DoAddItf |
598 /* XAMediaRecorderImpl_DoAddItf |
592 * Dynamically add an interface, object specific parts |
599 * Dynamically add an interface, object specific parts |
593 */ |
600 */ |
594 XAresult XAMediaRecorderImpl_DoAddItf(XAObjectItf self, XAObjItfMapEntry *mapEntry ) |
601 XAresult XAMediaRecorderImpl_DoAddItf(XAObjectItf self, |
595 { |
602 XAObjItfMapEntry *mapEntry) |
596 |
603 { |
597 XAObjectItfImpl* pObj = (XAObjectItfImpl*)(*self); |
604 |
598 XAMediaRecorderImpl* pImpl = (XAMediaRecorderImpl*)(pObj); |
605 XAObjectItfImpl* pObj = (XAObjectItfImpl*) (*self); |
|
606 XAMediaRecorderImpl* pImpl = (XAMediaRecorderImpl*) (pObj); |
599 |
607 |
600 XAresult ret = XA_RESULT_SUCCESS; |
608 XAresult ret = XA_RESULT_SUCCESS; |
601 |
609 |
602 DEBUG_API("->XAMediaRecorderImpl_DoAddItf"); |
610 DEBUG_API("->XAMediaRecorderImpl_DoAddItf"); |
603 XA_IMPL_THREAD_SAFETY_ENTRY( XATSMediaRecorder ); |
611 XA_IMPL_THREAD_SAFETY_ENTRY( XATSMediaRecorder ); |
604 |
612 |
605 if(mapEntry) |
613 if (mapEntry) |
606 { |
614 { |
607 switch( mapEntry->mapIdx ) |
615 switch (mapEntry->mapIdx) |
608 { |
616 { |
609 |
617 |
610 case MR_METADATAINSERTIONITF: |
618 case MR_METADATAINSERTIONITF: |
611 mapEntry->pItf = XAMetadataInsertionItfImpl_Create(pImpl); |
619 mapEntry->pItf = XAMetadataInsertionItfImpl_Create(pImpl); |
612 break; |
620 break; |
613 case MR_EQUALIZERITF: |
621 case MR_EQUALIZERITF: |
614 mapEntry->pItf = XAEqualizerItfImpl_Create( pImpl->adaptationCtx ); |
622 mapEntry->pItf = XAEqualizerItfImpl_Create( |
615 break; |
623 pImpl->adaptationCtx); |
616 case MR_IMAGEEFFECTSITF: |
624 break; |
617 mapEntry->pItf = XAImageEffectsItfImpl_Create( pImpl->adaptationCtx ); |
625 #ifdef OMAX_CAMERABIN |
618 break; |
626 case MR_IMAGEEFFECTSITF: |
619 |
627 mapEntry->pItf = XAImageEffectsItfImpl_Create( pImpl->adaptationCtx ); |
620 default: |
628 break; |
621 DEBUG_ERR("XAMediaRecorderImpl_DoAddItf unknown id"); |
629 #endif |
622 ret = XA_RESULT_FEATURE_UNSUPPORTED; |
630 default: |
623 break; |
631 DEBUG_ERR("XAMediaRecorderImpl_DoAddItf unknown id") |
624 } |
632 ; |
625 |
633 ret = XA_RESULT_FEATURE_UNSUPPORTED; |
626 if( !mapEntry->pItf && ret == XA_RESULT_SUCCESS) |
634 break; |
627 { |
635 } |
|
636 |
|
637 if (!mapEntry->pItf && ret == XA_RESULT_SUCCESS) |
|
638 { |
628 DEBUG_ERR("XAMediaRecorderImpl_DoAddItf itf creation failed"); |
639 DEBUG_ERR("XAMediaRecorderImpl_DoAddItf itf creation failed"); |
629 ret = XA_RESULT_MEMORY_FAILURE; |
640 ret = XA_RESULT_MEMORY_FAILURE; |
630 } |
641 } |
631 } |
642 } |
632 else |
643 else |
633 { |
644 { |
634 ret = XA_RESULT_PARAMETER_INVALID; |
645 ret = XA_RESULT_PARAMETER_INVALID; |
635 } |
646 } |
636 |
647 |
637 XA_IMPL_THREAD_SAFETY_EXIT( XATSMediaRecorder ); |
648 XA_IMPL_THREAD_SAFETY_EXIT( XATSMediaRecorder ); |
638 DEBUG_API("<-XAMediaRecorderImpl_DoAddItf"); |
649 DEBUG_API("<-XAMediaRecorderImpl_DoAddItf"); |
639 return ret; |
650 return ret; |
640 } |
651 } |
641 |
652 |
642 /* XAMediaRecorderImpl_DoResumeItf |
653 /* XAMediaRecorderImpl_DoResumeItf |
643 * Try to resume lost interface, object specific parts |
654 * Try to resume lost interface, object specific parts |
644 */ |
655 */ |
645 XAresult XAMediaRecorderImpl_DoResumeItf(XAObjectItf self, XAObjItfMapEntry *mapEntry ) |
656 XAresult XAMediaRecorderImpl_DoResumeItf(XAObjectItf self, |
646 { |
657 XAObjItfMapEntry *mapEntry) |
|
658 { |
647 XAresult ret; |
659 XAresult ret; |
648 /* For now, no difference between suspended and unrealised itfs */ |
660 /* For now, no difference between suspended and unrealised itfs */ |
649 DEBUG_API("->XAMediaRecorderImpl_DoResumeItf"); |
661 DEBUG_API("->XAMediaRecorderImpl_DoResumeItf"); |
650 XA_IMPL_THREAD_SAFETY_ENTRY( XATSMediaRecorder ); |
662 XA_IMPL_THREAD_SAFETY_ENTRY( XATSMediaRecorder ); |
651 ret = XAMediaRecorderImpl_DoAddItf(self,mapEntry); |
663 ret = XAMediaRecorderImpl_DoAddItf(self, mapEntry); |
652 XA_IMPL_THREAD_SAFETY_EXIT( XATSMediaRecorder ); |
664 XA_IMPL_THREAD_SAFETY_EXIT( XATSMediaRecorder ); |
653 DEBUG_API("<-XAMediaRecorderImpl_DoResumeItf"); |
665 DEBUG_API("<-XAMediaRecorderImpl_DoResumeItf"); |
654 return ret; |
666 return ret; |
655 } |
667 } |
656 |
668 |
657 /* XAMediaRecorderImpl_DoRemoveItf |
669 /* XAMediaRecorderImpl_DoRemoveItf |
658 * Dynamically remove an interface, object specific parts |
670 * Dynamically remove an interface, object specific parts |
659 */ |
671 */ |
660 XAresult XAMediaRecorderImpl_DoRemoveItf(XAObjectItf self, XAObjItfMapEntry *mapEntry ) |
672 XAresult XAMediaRecorderImpl_DoRemoveItf(XAObjectItf self, |
661 { |
673 XAObjItfMapEntry *mapEntry) |
|
674 { |
662 XAresult ret = XA_RESULT_SUCCESS; |
675 XAresult ret = XA_RESULT_SUCCESS; |
663 DEBUG_API("->XAMediaRecorderImpl_DoRemoveItf"); |
676 DEBUG_API("->XAMediaRecorderImpl_DoRemoveItf"); |
664 XA_IMPL_THREAD_SAFETY_ENTRY( XATSMediaRecorder ); |
677 XA_IMPL_THREAD_SAFETY_ENTRY( XATSMediaRecorder ); |
665 if(mapEntry) |
678 if (mapEntry) |
666 { |
679 { |
667 switch( mapEntry->mapIdx ) |
680 switch (mapEntry->mapIdx) |
668 { |
681 { |
669 case MR_METADATAINSERTIONITF: |
682 case MR_METADATAINSERTIONITF: |
670 XAMetadataInsertionItfImpl_Free( mapEntry->pItf ); |
683 XAMetadataInsertionItfImpl_Free(mapEntry->pItf); |
671 break; |
684 break; |
672 case MR_EQUALIZERITF: |
685 case MR_EQUALIZERITF: |
673 XAEqualizerItfImpl_Free( mapEntry->pItf ); |
686 XAEqualizerItfImpl_Free(mapEntry->pItf); |
674 break; |
687 break; |
675 case MR_IMAGEEFFECTSITF: |
688 #ifdef OMAX_CAMERABIN |
676 XAImageEffectsItfImpl_Free( mapEntry->pItf ); |
689 case MR_IMAGEEFFECTSITF: |
677 break; |
690 XAImageEffectsItfImpl_Free( mapEntry->pItf ); |
678 default: |
691 break; |
679 DEBUG_ERR("XAMediaRecorderImpl_DoRemoveItf unknown id"); |
692 #endif |
680 ret = XA_RESULT_FEATURE_UNSUPPORTED; |
693 default: |
681 break; |
694 DEBUG_ERR("XAMediaRecorderImpl_DoRemoveItf unknown id") |
682 } |
695 ; |
|
696 ret = XA_RESULT_FEATURE_UNSUPPORTED; |
|
697 break; |
|
698 } |
683 mapEntry->pItf = NULL; |
699 mapEntry->pItf = NULL; |
684 } |
700 } |
685 else |
701 else |
686 { |
702 { |
687 ret = XA_RESULT_PARAMETER_INVALID; |
703 ret = XA_RESULT_PARAMETER_INVALID; |
688 } |
704 } |
689 |
705 |
690 XA_IMPL_THREAD_SAFETY_EXIT( XATSMediaRecorder ); |
706 XA_IMPL_THREAD_SAFETY_EXIT( XATSMediaRecorder ); |
691 DEBUG_API("<-XAMediaRecorderImpl_DoRemoveItf"); |
707 DEBUG_API("<-XAMediaRecorderImpl_DoRemoveItf"); |
692 return ret; |
708 return ret; |
693 } |
709 } |
694 |
|
695 |
710 |
696 /* END OF FILE */ |
711 /* END OF FILE */ |