26 #include "xacapabilitiesmgr.h" |
26 #include "xacapabilitiesmgr.h" |
27 |
27 |
28 /* XAAudioEncoderCapabilitiesItfImpl* GetImpl |
28 /* XAAudioEncoderCapabilitiesItfImpl* GetImpl |
29 * Description: Validate interface pointer and cast it to implementation pointer. |
29 * Description: Validate interface pointer and cast it to implementation pointer. |
30 */ |
30 */ |
31 static XAAudioEncoderCapabilitiesItfImpl* GetImpl(XAAudioEncoderCapabilitiesItf self) |
31 static XAAudioEncoderCapabilitiesItfImpl* GetImpl( |
32 { |
32 XAAudioEncoderCapabilitiesItf self) |
33 if( self ) |
33 { |
34 { |
34 if (self) |
35 XAAudioEncoderCapabilitiesItfImpl* impl = (XAAudioEncoderCapabilitiesItfImpl*)(*self); |
35 { |
36 if( impl && (impl == impl->self) ) |
36 XAAudioEncoderCapabilitiesItfImpl* impl = |
37 { |
37 (XAAudioEncoderCapabilitiesItfImpl*) (*self); |
|
38 if (impl && (impl == impl->self)) |
|
39 { |
38 return impl; |
40 return impl; |
39 } |
41 } |
40 } |
42 } |
41 return NULL; |
43 return NULL; |
42 } |
44 } |
43 |
45 |
44 /***************************************************************************** |
46 /***************************************************************************** |
45 * Base interface XAAudioEncoderCapabilitiesItf implementation |
47 * Base interface XAAudioEncoderCapabilitiesItf implementation |
46 *****************************************************************************/ |
48 *****************************************************************************/ |
47 |
49 |
48 /* XAresult XAAudioEncoderCapabilitiesItfImpl_GetAudioEncoders |
50 /* XAresult XAAudioEncoderCapabilitiesItfImpl_GetAudioEncoders |
49 * Description: Retrieves the available audio encoders. |
51 * Description: Retrieves the available audio encoders. |
50 */ |
52 */ |
51 XAresult XAAudioEncoderCapabilitiesItfImpl_GetAudioEncoders( |
53 XAresult XAAudioEncoderCapabilitiesItfImpl_GetAudioEncoders( |
52 XAAudioEncoderCapabilitiesItf self, |
54 XAAudioEncoderCapabilitiesItf self, XAuint32* pNumEncoders, |
53 XAuint32* pNumEncoders, |
55 XAuint32* pEncoderIds) |
54 XAuint32* pEncoderIds) |
56 { |
55 { |
|
56 XAAudioEncoderCapabilitiesItfImpl* impl = GetImpl(self); |
57 XAAudioEncoderCapabilitiesItfImpl* impl = GetImpl(self); |
57 XAresult res = XA_RESULT_SUCCESS; |
58 XAresult res = XA_RESULT_SUCCESS; |
58 DEBUG_API("->XAAudioEncoderCapabilitiesItfImpl_GetAudioEncoders"); |
59 DEBUG_API("->XAAudioEncoderCapabilitiesItfImpl_GetAudioEncoders"); |
59 |
60 |
60 if( !impl || !pNumEncoders ) |
61 if (!impl || !pNumEncoders) |
61 { |
62 { |
62 DEBUG_ERR("XA_RESULT_PARAMETER_INVALID"); |
63 DEBUG_ERR("XA_RESULT_PARAMETER_INVALID"); |
63 res = XA_RESULT_PARAMETER_INVALID; |
64 res = XA_RESULT_PARAMETER_INVALID; |
64 } |
65 } |
65 else |
66 else |
66 { |
67 { |
67 if( pEncoderIds ) |
68 if (pEncoderIds) |
68 { /* query array of encoders */ |
69 { /* query array of encoders */ |
69 if( *pNumEncoders < impl->numCodecs ) |
70 if (*pNumEncoders < impl->numCodecs) |
70 { |
71 { |
71 DEBUG_ERR("XA_RESULT_BUFFER_INSUFFICIENT"); |
72 DEBUG_ERR("XA_RESULT_BUFFER_INSUFFICIENT"); |
72 res = XA_RESULT_BUFFER_INSUFFICIENT; |
73 res = XA_RESULT_BUFFER_INSUFFICIENT; |
73 } |
74 } |
74 else |
75 else |
75 { |
76 { |
76 |
77 |
77 XAuint32 i = 0; |
78 XAuint32 i = 0; |
78 XACapabilities temp; |
79 XACapabilities temp; |
79 for( i=0; i<impl->numCodecs; i++ ) |
80 for (i = 0; i < impl->numCodecs; i++) |
80 { |
81 { |
81 /* query encoder id from adaptation using index value */ |
82 /* query encoder id from adaptation using index value */ |
82 XACapabilitiesMgr_GetCapsByIdx(impl->capslist, (XACapsType)(XACAP_ENCODER|XACAP_AUDIO), i, &temp); |
83 XACapabilitiesMgr_GetCapsByIdx(impl->capslist, |
|
84 (XACapsType) (XACAP_ENCODER | XACAP_AUDIO), i, |
|
85 &temp); |
83 pEncoderIds[i] = temp.xaid; |
86 pEncoderIds[i] = temp.xaid; |
|
87 } |
|
88 |
|
89 pEncoderIds[0] = XA_AUDIOCODEC_AMR; |
|
90 pEncoderIds[1] = XA_AUDIOCODEC_AAC; |
|
91 pEncoderIds[2] = XA_AUDIOCODEC_PCM; |
84 } |
92 } |
85 |
93 } |
86 pEncoderIds[0] = XA_AUDIOCODEC_AMR; |
94 |
87 pEncoderIds[1] = XA_AUDIOCODEC_AAC; |
95 /* return number of encoders */ |
88 pEncoderIds[2] = XA_AUDIOCODEC_PCM; |
96 *pNumEncoders = impl->numCodecs; |
89 } |
97 }DEBUG_API("<-XAAudioEncoderCapabilitiesItfImpl_GetAudioEncoders"); |
90 } |
|
91 |
|
92 /* return number of encoders */ |
|
93 *pNumEncoders = impl->numCodecs; |
|
94 } |
|
95 DEBUG_API("<-XAAudioEncoderCapabilitiesItfImpl_GetAudioEncoders"); |
|
96 return res; |
98 return res; |
97 } |
99 } |
98 |
100 |
99 /* XAresult XAAudioEncoderCapabilitiesItfImpl_GetAudioEncoderCapabilities |
101 /* XAresult XAAudioEncoderCapabilitiesItfImpl_GetAudioEncoderCapabilities |
100 * Description: Queries for the audio encoders capabilities. |
102 * Description: Queries for the audio encoders capabilities. |
101 */ |
103 */ |
102 XAresult XAAudioEncoderCapabilitiesItfImpl_GetAudioEncoderCapabilities( |
104 XAresult XAAudioEncoderCapabilitiesItfImpl_GetAudioEncoderCapabilities( |
103 XAAudioEncoderCapabilitiesItf self, |
105 XAAudioEncoderCapabilitiesItf self, XAuint32 encoderId, |
104 XAuint32 encoderId, |
106 XAuint32 *pIndex, XAAudioCodecDescriptor *pDescriptor) |
105 XAuint32 *pIndex, |
107 { |
106 XAAudioCodecDescriptor *pDescriptor) |
|
107 { |
|
108 XAAudioEncoderCapabilitiesItfImpl* impl = GetImpl(self); |
108 XAAudioEncoderCapabilitiesItfImpl* impl = GetImpl(self); |
109 XAresult res = XA_RESULT_SUCCESS; |
109 XAresult res = XA_RESULT_SUCCESS; |
110 |
110 |
111 |
|
112 XACapabilities temp; |
111 XACapabilities temp; |
113 |
112 |
114 DEBUG_API("->XAAudioEncoderCapabilitiesItfImpl_GetAudioEncoderCapabilities"); |
113 DEBUG_API("->XAAudioEncoderCapabilitiesItfImpl_GetAudioEncoderCapabilities"); |
115 |
114 |
116 /*if( !impl || !pIndex || !pDescriptor )*/ |
115 /*if( !impl || !pIndex || !pDescriptor )*/ |
117 /*Removing the pDescriptor because the client can pass |
116 /*Removing the pDescriptor because the client can pass |
118 * it as NULL to query the pIndex for number of Codec/Mode |
117 * it as NULL to query the pIndex for number of Codec/Mode |
119 * pair capabilities for each encoder */ |
118 * pair capabilities for each encoder */ |
120 if( !impl || !pIndex ) |
119 if (!impl || !pIndex) |
121 { |
120 { |
122 DEBUG_ERR("XA_RESULT_PARAMETER_INVALID"); |
121 DEBUG_ERR("XA_RESULT_PARAMETER_INVALID"); |
123 res = XA_RESULT_PARAMETER_INVALID; |
122 res = XA_RESULT_PARAMETER_INVALID; |
124 return res; |
123 return res; |
125 } |
124 } |
126 else |
125 else |
127 { |
126 { |
128 *pIndex = 1; |
127 *pIndex = 1; |
129 if(!pDescriptor) |
128 if (!pDescriptor) |
130 { |
129 { |
131 return res; |
130 return res; |
132 } |
131 } |
133 } |
132 } |
134 |
133 |
135 /* query capabilities from adaptation using codec id */ |
134 /* query capabilities from adaptation using codec id */ |
136 memset(pDescriptor,0,sizeof(XAAudioCodecDescriptor)); |
135 memset(pDescriptor, 0, sizeof(XAAudioCodecDescriptor)); |
137 |
136 |
138 switch (encoderId) |
137 switch (encoderId) |
139 { |
138 { |
140 case XA_AUDIOCODEC_AMR: |
139 case XA_AUDIOCODEC_AMR: |
141 { |
140 { |
142 impl->sampleRateArray[0] = 8000000; |
141 impl->sampleRateArray[0] = 8000000; |
143 |
142 |
144 impl->bitRateArray[0] = 4750; |
143 impl->bitRateArray[0] = 4750; |
145 impl->bitRateArray[1] = 5150; |
144 impl->bitRateArray[1] = 5150; |
146 impl->bitRateArray[2] = 5900; |
145 impl->bitRateArray[2] = 5900; |
147 impl->bitRateArray[3] = 6700; |
146 impl->bitRateArray[3] = 6700; |
148 impl->bitRateArray[4] = 7400; |
147 impl->bitRateArray[4] = 7400; |
149 impl->bitRateArray[5] = 7950; |
148 impl->bitRateArray[5] = 7950; |
150 impl->bitRateArray[6] = 10200; |
149 impl->bitRateArray[6] = 10200; |
151 impl->bitRateArray[7] = 12200; |
150 impl->bitRateArray[7] = 12200; |
152 |
151 |
153 pDescriptor->maxChannels = 1; |
152 pDescriptor->maxChannels = 1; |
154 pDescriptor->minBitsPerSample = 8; |
153 pDescriptor->minBitsPerSample = 8; |
155 pDescriptor->maxBitsPerSample = 8; |
154 pDescriptor->maxBitsPerSample = 8; |
156 pDescriptor->minSampleRate = 8000000; /*milliHz*/ |
155 pDescriptor->minSampleRate = 8000000; /*milliHz*/ |
157 pDescriptor->maxSampleRate = 8000000; |
156 pDescriptor->maxSampleRate = 8000000; |
158 pDescriptor->isFreqRangeContinuous=XA_BOOLEAN_FALSE; |
157 pDescriptor->isFreqRangeContinuous = XA_BOOLEAN_FALSE; |
159 pDescriptor->pSampleRatesSupported = (XAmilliHertz*)(&(impl->sampleRateArray)); |
158 pDescriptor->pSampleRatesSupported |
|
159 = (XAmilliHertz*) (&(impl->sampleRateArray)); |
160 pDescriptor->numSampleRatesSupported = 1; |
160 pDescriptor->numSampleRatesSupported = 1; |
161 pDescriptor->minBitRate=4750; |
161 pDescriptor->minBitRate = 4750; |
162 pDescriptor->maxBitRate=12200; |
162 pDescriptor->maxBitRate = 12200; |
163 pDescriptor->isBitrateRangeContinuous=XA_BOOLEAN_FALSE; |
163 pDescriptor->isBitrateRangeContinuous = XA_BOOLEAN_FALSE; |
164 pDescriptor->pBitratesSupported = (XAuint32*)(&(impl->bitRateArray)); |
164 pDescriptor->pBitratesSupported |
|
165 = (XAuint32*) (&(impl->bitRateArray)); |
165 pDescriptor->numBitratesSupported = 8; |
166 pDescriptor->numBitratesSupported = 8; |
166 pDescriptor->profileSetting = XA_AUDIOPROFILE_AMR; |
167 pDescriptor->profileSetting = XA_AUDIOPROFILE_AMR; |
167 pDescriptor->modeSetting = 0; |
168 pDescriptor->modeSetting = 0; |
168 } |
169 } |
169 break; |
170 break; |
170 case XA_AUDIOCODEC_AAC: |
171 case XA_AUDIOCODEC_AAC: |
171 { |
172 { |
172 impl->sampleRateArray[0] = 8000000; |
173 impl->sampleRateArray[0] = 8000000; |
173 impl->sampleRateArray[1] = 11025000; |
174 impl->sampleRateArray[1] = 11025000; |
174 impl->sampleRateArray[2] = 16000000; |
175 impl->sampleRateArray[2] = 16000000; |
175 impl->sampleRateArray[3] = 22050000; |
176 impl->sampleRateArray[3] = 22050000; |
181 impl->bitRateArray[1] = 64000; |
182 impl->bitRateArray[1] = 64000; |
182 impl->bitRateArray[2] = 96000; |
183 impl->bitRateArray[2] = 96000; |
183 impl->bitRateArray[3] = 128000; |
184 impl->bitRateArray[3] = 128000; |
184 impl->bitRateArray[4] = 160000; |
185 impl->bitRateArray[4] = 160000; |
185 impl->bitRateArray[5] = 192000; |
186 impl->bitRateArray[5] = 192000; |
186 impl->bitRateArray[6] = 224000; |
187 impl->bitRateArray[6] = 224000; |
187 impl->bitRateArray[7] = 256000; |
188 impl->bitRateArray[7] = 256000; |
188 |
189 |
189 pDescriptor->maxChannels = 2; |
190 pDescriptor->maxChannels = 2; |
190 pDescriptor->minBitsPerSample = 16; |
191 pDescriptor->minBitsPerSample = 16; |
191 pDescriptor->maxBitsPerSample = 16; |
192 pDescriptor->maxBitsPerSample = 16; |
192 pDescriptor->minSampleRate = 8000*1000; /*milliHz*/ |
193 pDescriptor->minSampleRate = 8000 * 1000; /*milliHz*/ |
193 pDescriptor->maxSampleRate = 48000 * 1000; |
194 pDescriptor->maxSampleRate = 48000 * 1000; |
194 pDescriptor->isFreqRangeContinuous=XA_BOOLEAN_FALSE; |
195 pDescriptor->isFreqRangeContinuous = XA_BOOLEAN_FALSE; |
195 pDescriptor->pSampleRatesSupported = (XAmilliHertz*)(&(impl->sampleRateArray)); |
196 pDescriptor->pSampleRatesSupported |
|
197 = (XAmilliHertz*) (&(impl->sampleRateArray)); |
196 pDescriptor->numSampleRatesSupported = 7; |
198 pDescriptor->numSampleRatesSupported = 7; |
197 pDescriptor->minBitRate=32000; |
199 pDescriptor->minBitRate = 32000; |
198 pDescriptor->maxBitRate=256000; |
200 pDescriptor->maxBitRate = 256000; |
199 pDescriptor->isBitrateRangeContinuous=XA_BOOLEAN_FALSE; |
201 pDescriptor->isBitrateRangeContinuous = XA_BOOLEAN_FALSE; |
200 pDescriptor->pBitratesSupported = (XAuint32*)(&(impl->bitRateArray)); |
202 pDescriptor->pBitratesSupported |
|
203 = (XAuint32*) (&(impl->bitRateArray)); |
201 pDescriptor->numBitratesSupported = 8; |
204 pDescriptor->numBitratesSupported = 8; |
202 pDescriptor->profileSetting = XA_AUDIOPROFILE_AAC_AAC; |
205 pDescriptor->profileSetting = XA_AUDIOPROFILE_AAC_AAC; |
203 pDescriptor->modeSetting = XA_AUDIOMODE_AAC_LC; |
206 pDescriptor->modeSetting = XA_AUDIOMODE_AAC_LC; |
204 } |
207 } |
205 break; |
208 break; |
206 case XA_AUDIOCODEC_PCM: |
209 case XA_AUDIOCODEC_PCM: |
207 { |
210 { |
208 impl->sampleRateArray[0] = 12000000; |
211 impl->sampleRateArray[0] = 12000000; |
209 impl->sampleRateArray[1] = 16000000; |
212 impl->sampleRateArray[1] = 16000000; |
210 impl->sampleRateArray[2] = 22050000; |
213 impl->sampleRateArray[2] = 22050000; |
211 impl->sampleRateArray[3] = 24000000; |
214 impl->sampleRateArray[3] = 24000000; |
217 impl->sampleRateArray[9] = 96000000; |
220 impl->sampleRateArray[9] = 96000000; |
218 |
221 |
219 pDescriptor->maxChannels = 2; |
222 pDescriptor->maxChannels = 2; |
220 pDescriptor->minBitsPerSample = 16; |
223 pDescriptor->minBitsPerSample = 16; |
221 pDescriptor->maxBitsPerSample = 16; |
224 pDescriptor->maxBitsPerSample = 16; |
222 pDescriptor->minSampleRate = 8000000; /*milliHz*/ |
225 pDescriptor->minSampleRate = 8000000; /*milliHz*/ |
223 pDescriptor->maxSampleRate = 96000000; |
226 pDescriptor->maxSampleRate = 96000000; |
224 pDescriptor->isFreqRangeContinuous=XA_BOOLEAN_FALSE; |
227 pDescriptor->isFreqRangeContinuous = XA_BOOLEAN_FALSE; |
225 pDescriptor->pSampleRatesSupported = (XAmilliHertz*)(&(impl->sampleRateArray)); |
228 pDescriptor->pSampleRatesSupported |
|
229 = (XAmilliHertz*) (&(impl->sampleRateArray)); |
226 pDescriptor->numSampleRatesSupported = 10; |
230 pDescriptor->numSampleRatesSupported = 10; |
227 pDescriptor->minBitRate= 0; |
231 pDescriptor->minBitRate = 0; |
228 pDescriptor->maxBitRate= 0; |
232 pDescriptor->maxBitRate = 0; |
229 pDescriptor->isBitrateRangeContinuous=XA_BOOLEAN_FALSE; |
233 pDescriptor->isBitrateRangeContinuous = XA_BOOLEAN_FALSE; |
230 pDescriptor->pBitratesSupported = NULL; |
234 pDescriptor->pBitratesSupported = NULL; |
231 pDescriptor->numBitratesSupported = 0; |
235 pDescriptor->numBitratesSupported = 0; |
232 pDescriptor->profileSetting = XA_AUDIOPROFILE_PCM ; |
236 pDescriptor->profileSetting = XA_AUDIOPROFILE_PCM; |
233 pDescriptor->modeSetting = 0; |
237 pDescriptor->modeSetting = 0; |
234 } |
238 } |
235 break; |
239 break; |
236 } |
240 } |
237 |
241 |
238 |
242 res = XACapabilitiesMgr_GetCapsById(impl->capslist, |
239 |
243 (XACapsType) (XACAP_ENCODER | XACAP_AUDIO), encoderId, &temp); |
240 res = XACapabilitiesMgr_GetCapsById(impl->capslist, (XACapsType)(XACAP_ENCODER|XACAP_AUDIO), encoderId, &temp); |
244 if (res == XA_RESULT_SUCCESS) |
241 if( res == XA_RESULT_SUCCESS ) |
245 { |
242 { |
246 XAAudioCodecDescriptor* desc = |
243 XAAudioCodecDescriptor* desc = ((XAAudioCodecDescriptor*)(temp.pEntry)); |
247 ((XAAudioCodecDescriptor*) (temp.pEntry)); |
244 /* map applicable values to XAAudioCodecCapabilities */ |
248 /* map applicable values to XAAudioCodecCapabilities */ |
245 pDescriptor->maxChannels = desc->maxChannels; |
249 pDescriptor->maxChannels = desc->maxChannels; |
246 pDescriptor->minSampleRate= desc->minSampleRate*1000; /* milliHz */ |
250 pDescriptor->minSampleRate = desc->minSampleRate * 1000; /* milliHz */ |
247 if (desc->maxSampleRate < (0xFFFFFFFF / 1000)) |
251 if (desc->maxSampleRate < (0xFFFFFFFF / 1000)) |
248 { |
252 { |
249 pDescriptor->maxSampleRate = desc->maxSampleRate*1000; |
253 pDescriptor->maxSampleRate = desc->maxSampleRate * 1000; |
250 } |
254 } |
251 else |
255 else |
252 { |
256 { |
253 pDescriptor->maxSampleRate = 0xFFFFFFFF; |
257 pDescriptor->maxSampleRate = 0xFFFFFFFF; |
254 } |
258 } |
255 pDescriptor->minBitsPerSample=desc->minBitsPerSample; |
259 pDescriptor->minBitsPerSample = desc->minBitsPerSample; |
256 pDescriptor->maxBitsPerSample=desc->maxBitsPerSample; |
260 pDescriptor->maxBitsPerSample = desc->maxBitsPerSample; |
257 pDescriptor->isFreqRangeContinuous=XA_BOOLEAN_TRUE; |
261 pDescriptor->isFreqRangeContinuous = XA_BOOLEAN_TRUE; |
258 pDescriptor->minBitRate=desc->minBitRate; |
262 pDescriptor->minBitRate = desc->minBitRate; |
259 pDescriptor->maxBitRate=desc->maxBitRate; |
263 pDescriptor->maxBitRate = desc->maxBitRate; |
260 pDescriptor->numBitratesSupported = desc->numBitratesSupported; |
264 pDescriptor->numBitratesSupported = desc->numBitratesSupported; |
261 pDescriptor->isBitrateRangeContinuous=XA_BOOLEAN_TRUE; |
265 pDescriptor->isBitrateRangeContinuous = XA_BOOLEAN_TRUE; |
262 if (temp.xaid == XA_AUDIOCODEC_PCM ) |
266 if (temp.xaid == XA_AUDIOCODEC_PCM) |
263 { |
267 { |
264 pDescriptor->profileSetting=XA_AUDIOPROFILE_PCM; |
268 pDescriptor->profileSetting = XA_AUDIOPROFILE_PCM; |
265 pDescriptor->modeSetting=0; /* no chanmode for pcm defined */ |
269 pDescriptor->modeSetting = 0; /* no chanmode for pcm defined */ |
266 } |
270 } |
267 else if (temp.xaid == XA_ADAPTID_VORBIS) /* for ogg */ |
271 else if (temp.xaid == XA_ADAPTID_VORBIS) /* for ogg */ |
268 { |
272 { |
269 if (desc->maxChannels == 1) |
273 if (desc->maxChannels == 1) |
270 { |
274 { |
271 pDescriptor->profileSetting=XA_AUDIOPROFILE_MPEG1_L3; |
275 pDescriptor->profileSetting = XA_AUDIOPROFILE_MPEG1_L3; |
272 pDescriptor->modeSetting=XA_AUDIOCHANMODE_MP3_MONO; |
276 pDescriptor->modeSetting = XA_AUDIOCHANMODE_MP3_MONO; |
273 } |
277 } |
274 else |
278 else |
275 { |
279 { |
276 pDescriptor->profileSetting=XA_AUDIOPROFILE_MPEG2_L3; |
280 pDescriptor->profileSetting = XA_AUDIOPROFILE_MPEG2_L3; |
277 pDescriptor->modeSetting=XA_AUDIOCHANMODE_MP3_STEREO; |
281 pDescriptor->modeSetting = XA_AUDIOCHANMODE_MP3_STEREO; |
278 } |
282 } |
279 } |
283 } |
280 else |
284 else |
281 { |
285 { |
282 /* do nothing */ |
286 /* do nothing */ |
283 } |
287 } |
284 |
288 |
285 } |
289 } |
286 |
290 |
287 DEBUG_API("<-XAAudioEncoderCapabilitiesItfImpl_GetAudioEncoderCapabilities"); |
291 DEBUG_API("<-XAAudioEncoderCapabilitiesItfImpl_GetAudioEncoderCapabilities"); |
288 return res; |
292 return res; |
289 } |
293 } |
290 |
|
291 |
294 |
292 /***************************************************************************** |
295 /***************************************************************************** |
293 * XAAudioEncoderCapabilitiesItfImpl -specific methods |
296 * XAAudioEncoderCapabilitiesItfImpl -specific methods |
294 *****************************************************************************/ |
297 *****************************************************************************/ |
295 |
298 |
296 /* XAAudioEncoderCapabilitiesItfImpl_Create |
299 /* XAAudioEncoderCapabilitiesItfImpl_Create |
297 * Description: Allocate and initialize XAAudioEncoderCapabilitiesItfImpl |
300 * Description: Allocate and initialize XAAudioEncoderCapabilitiesItfImpl |
298 */ |
301 */ |
299 XAAudioEncoderCapabilitiesItfImpl* XAAudioEncoderCapabilitiesItfImpl_Create(XACapabilities* caps) |
302 XAAudioEncoderCapabilitiesItfImpl* XAAudioEncoderCapabilitiesItfImpl_Create( |
300 { |
303 XACapabilities* caps) |
301 XAAudioEncoderCapabilitiesItfImpl* self = (XAAudioEncoderCapabilitiesItfImpl*) |
304 { |
302 calloc(1,sizeof(XAAudioEncoderCapabilitiesItfImpl)); |
305 XAAudioEncoderCapabilitiesItfImpl* self = |
|
306 (XAAudioEncoderCapabilitiesItfImpl*) calloc(1, |
|
307 sizeof(XAAudioEncoderCapabilitiesItfImpl)); |
303 |
308 |
304 DEBUG_API("->XAAudioEncoderCapabilitiesItfImpl_Create"); |
309 DEBUG_API("->XAAudioEncoderCapabilitiesItfImpl_Create"); |
305 |
310 |
306 if( self ) |
311 if (self) |
307 { |
312 { |
308 /* init itf default implementation */ |
313 /* init itf default implementation */ |
309 self->itf.GetAudioEncoders = |
314 self->itf.GetAudioEncoders |
310 XAAudioEncoderCapabilitiesItfImpl_GetAudioEncoders; |
315 = XAAudioEncoderCapabilitiesItfImpl_GetAudioEncoders; |
311 self->itf.GetAudioEncoderCapabilities = |
316 self->itf.GetAudioEncoderCapabilities |
312 XAAudioEncoderCapabilitiesItfImpl_GetAudioEncoderCapabilities; |
317 = XAAudioEncoderCapabilitiesItfImpl_GetAudioEncoderCapabilities; |
313 self->capslist = caps; |
318 self->capslist = caps; |
314 |
319 |
315 /* init variables */ |
320 /* init variables */ |
316 assert( XACapabilitiesMgr_GetCapsCount( caps, (XACapsType)((XACapsType)(XACAP_ENCODER|XACAP_AUDIO)), |
321 assert( XACapabilitiesMgr_GetCapsCount( caps, (XACapsType)((XACapsType)(XACAP_ENCODER|XACAP_AUDIO)), |
317 &(self->numCodecs) ) == XA_RESULT_SUCCESS ); |
322 &(self->numCodecs) ) == XA_RESULT_SUCCESS ); |
318 |
323 |
319 /*self->mmfEngine = (void*)mmf_capability_engine_init();*/ |
324 /*self->mmfEngine = (void*)mmf_capability_engine_init();*/ |
320 self->numCodecs = 3; |
325 self->numCodecs = 3; |
321 self->self = self; |
326 self->self = self; |
322 |
327 |
323 } |
328 }DEBUG_API("<-XAAudioEncoderCapabilitiesItfImpl_Create"); |
324 DEBUG_API("<-XAAudioEncoderCapabilitiesItfImpl_Create"); |
|
325 return self; |
329 return self; |
326 } |
330 } |
327 |
331 |
328 /* void XAAudioEncoderCapabilitiesItfImpl_Free |
332 /* void XAAudioEncoderCapabilitiesItfImpl_Free |
329 * Description: Free all resources reserved at XAAudioEncoderCapabilitiesItfImpl_Create |
333 * Description: Free all resources reserved at XAAudioEncoderCapabilitiesItfImpl_Create |
330 */ |
334 */ |
331 void XAAudioEncoderCapabilitiesItfImpl_Free(XAAudioEncoderCapabilitiesItfImpl* self) |
335 void XAAudioEncoderCapabilitiesItfImpl_Free( |
332 { |
336 XAAudioEncoderCapabilitiesItfImpl* self) |
|
337 { |
333 DEBUG_API("->XAAudioEncoderCapabilitiesItfImpl_Free"); |
338 DEBUG_API("->XAAudioEncoderCapabilitiesItfImpl_Free"); |
334 assert(self==self->self); |
339 assert(self==self->self); |
335 free(self); |
340 free(self); |
336 DEBUG_API("<-XAAudioEncoderCapabilitiesItfImpl_Free"); |
341 DEBUG_API("<-XAAudioEncoderCapabilitiesItfImpl_Free"); |
337 } |
342 } |