25 #include "xaaudiodecodercapabilitiesitf.h" |
25 #include "xaaudiodecodercapabilitiesitf.h" |
26 #include "xacapabilitiesmgr.h" |
26 #include "xacapabilitiesmgr.h" |
27 /* XAAudioDecoderCapabilitiesItfImpl* GetImpl |
27 /* XAAudioDecoderCapabilitiesItfImpl* GetImpl |
28 * Description: Validate interface pointer and cast it to implementation pointer. |
28 * Description: Validate interface pointer and cast it to implementation pointer. |
29 */ |
29 */ |
30 static XAAudioDecoderCapabilitiesItfImpl* GetImpl(XAAudioDecoderCapabilitiesItf self) |
30 static XAAudioDecoderCapabilitiesItfImpl* GetImpl( |
31 { |
31 XAAudioDecoderCapabilitiesItf self) |
32 if( self ) |
32 { |
33 { |
33 if (self) |
34 XAAudioDecoderCapabilitiesItfImpl* impl = (XAAudioDecoderCapabilitiesItfImpl*)(*self); |
34 { |
35 if( impl && (impl == impl->self) ) |
35 XAAudioDecoderCapabilitiesItfImpl* impl = |
36 { |
36 (XAAudioDecoderCapabilitiesItfImpl*) (*self); |
|
37 if (impl && (impl == impl->self)) |
|
38 { |
37 return impl; |
39 return impl; |
38 } |
40 } |
39 } |
41 } |
40 return NULL; |
42 return NULL; |
41 } |
43 } |
42 |
44 |
43 /***************************************************************************** |
45 /***************************************************************************** |
44 * Base interface XAAudioDecoderCapabilitiesItf implementation |
46 * Base interface XAAudioDecoderCapabilitiesItf implementation |
45 *****************************************************************************/ |
47 *****************************************************************************/ |
46 |
48 |
47 /* XAresult XAAudioDecoderCapabilitiesItfImpl_GetAudioDecoders |
49 /* XAresult XAAudioDecoderCapabilitiesItfImpl_GetAudioDecoders |
48 * Description: Retrieves the available audio decoders. |
50 * Description: Retrieves the available audio decoders. |
49 */ |
51 */ |
50 XAresult XAAudioDecoderCapabilitiesItfImpl_GetAudioDecoders( |
52 XAresult XAAudioDecoderCapabilitiesItfImpl_GetAudioDecoders( |
51 XAAudioDecoderCapabilitiesItf self, |
53 XAAudioDecoderCapabilitiesItf self, XAuint32* pNumDecoders, |
52 XAuint32* pNumDecoders, |
54 XAuint32* pDecoderIds) |
53 XAuint32* pDecoderIds) |
55 { |
54 { |
|
55 XAAudioDecoderCapabilitiesItfImpl* impl = GetImpl(self); |
56 XAAudioDecoderCapabilitiesItfImpl* impl = GetImpl(self); |
56 XAresult res = XA_RESULT_SUCCESS; |
57 XAresult res = XA_RESULT_SUCCESS; |
57 |
58 |
58 DEBUG_API("->XAAudioDecoderCapabilitiesItfImpl_GetAudioDecoders"); |
59 DEBUG_API("->XAAudioDecoderCapabilitiesItfImpl_GetAudioDecoders"); |
59 |
60 |
60 if( !impl || !pNumDecoders ) |
61 if (!impl || !pNumDecoders) |
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( pDecoderIds ) |
68 if (pDecoderIds) |
68 { /* query array of decoders */ |
69 { /* query array of decoders */ |
69 if( *pNumDecoders < impl->numCodecs ) |
70 if (*pNumDecoders < 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 decoder id from adaptation using index value */ |
82 /* query decoder id from adaptation using index value */ |
82 XACapabilitiesMgr_GetCapsByIdx(NULL, (XACapsType)(XACAP_DECODER|XACAP_AUDIO), i, &temp); |
83 XACapabilitiesMgr_GetCapsByIdx(NULL, |
|
84 (XACapsType) (XACAP_DECODER | XACAP_AUDIO), i, |
|
85 &temp); |
83 pDecoderIds[i] = temp.xaid; |
86 pDecoderIds[i] = temp.xaid; |
84 } |
87 } |
85 |
88 |
86 } |
89 } |
87 } |
90 } |
88 /* return number of decoders */ |
91 /* return number of decoders */ |
89 *pNumDecoders = impl->numCodecs; |
92 *pNumDecoders = impl->numCodecs; |
90 } |
93 }DEBUG_API("<-XAAudioDecoderCapabilitiesItfImpl_GetAudioDecoders"); |
91 DEBUG_API("<-XAAudioDecoderCapabilitiesItfImpl_GetAudioDecoders"); |
|
92 return res; |
94 return res; |
93 } |
95 } |
94 |
96 |
95 /* XAresult XAAudioDecoderCapabilitiesItfImpl_GetAudioDecoderCapabilities |
97 /* XAresult XAAudioDecoderCapabilitiesItfImpl_GetAudioDecoderCapabilities |
96 * Description: Queries for the audio decoder�s capabilities. |
98 * Description: Queries for the audio decoder�s capabilities. |
97 */ |
99 */ |
98 XAresult XAAudioDecoderCapabilitiesItfImpl_GetAudioDecoderCapabilities( |
100 XAresult XAAudioDecoderCapabilitiesItfImpl_GetAudioDecoderCapabilities( |
99 XAAudioDecoderCapabilitiesItf self, |
101 XAAudioDecoderCapabilitiesItf self, XAuint32 decoderId, |
100 XAuint32 decoderId, |
102 XAuint32* pIndex, XAAudioCodecDescriptor* pDescriptor) |
101 XAuint32* pIndex, |
103 { |
102 XAAudioCodecDescriptor* pDescriptor) |
|
103 { |
|
104 XAAudioDecoderCapabilitiesItfImpl* impl = GetImpl(self); |
104 XAAudioDecoderCapabilitiesItfImpl* impl = GetImpl(self); |
105 XAresult res = XA_RESULT_SUCCESS; |
105 XAresult res = XA_RESULT_SUCCESS; |
106 |
106 |
107 DEBUG_API("->XAAudioDecoderCapabilitiesItfImpl_GetAudioDecoderCapabilities"); |
107 DEBUG_API("->XAAudioDecoderCapabilitiesItfImpl_GetAudioDecoderCapabilities"); |
108 |
108 |
109 if( !impl || !pIndex ) |
109 if (!impl || !pIndex) |
110 { |
110 { |
111 DEBUG_ERR("XA_RESULT_PARAMETER_INVALID"); |
111 DEBUG_ERR("XA_RESULT_PARAMETER_INVALID"); |
112 res = XA_RESULT_PARAMETER_INVALID; |
112 res = XA_RESULT_PARAMETER_INVALID; |
113 } |
113 } |
114 else |
114 else |
115 { |
115 { |
116 if( !pDescriptor ) |
116 if (!pDescriptor) |
117 { /* query number of capa structures */ |
117 { /* query number of capa structures */ |
118 *pIndex = 1; |
118 *pIndex = 1; |
119 } |
119 } |
120 else |
120 else |
121 { /* query capabilities */ |
121 { /* query capabilities */ |
122 if( *pIndex >= 1 ) |
122 if (*pIndex >= 1) |
123 { |
123 { |
124 DEBUG_ERR("XA_RESULT_PARAMETER_INVALID"); |
124 DEBUG_ERR("XA_RESULT_PARAMETER_INVALID"); |
125 res = XA_RESULT_PARAMETER_INVALID; |
125 res = XA_RESULT_PARAMETER_INVALID; |
126 } |
126 } |
127 else |
127 else |
128 { |
128 { |
129 |
129 |
130 /* query capabilities from adaptation using codec id */ |
130 /* query capabilities from adaptation using codec id */ |
131 XACapabilities temp; |
131 XACapabilities temp; |
132 memset(pDescriptor,0,sizeof(XAAudioCodecDescriptor)); |
132 memset(pDescriptor, 0, sizeof(XAAudioCodecDescriptor)); |
133 res = XACapabilitiesMgr_GetCapsById(NULL, (XACapsType)(XACAP_DECODER|XACAP_AUDIO), decoderId, &temp); |
133 res = XACapabilitiesMgr_GetCapsById(NULL, |
134 if( res == XA_RESULT_SUCCESS ) |
134 (XACapsType) (XACAP_DECODER | XACAP_AUDIO), |
135 { |
135 decoderId, &temp); |
136 XAAudioCodecDescriptor* desc = ((XAAudioCodecDescriptor*)(temp.pEntry)); |
136 if (res == XA_RESULT_SUCCESS) |
|
137 { |
|
138 XAAudioCodecDescriptor* desc = |
|
139 ((XAAudioCodecDescriptor*) (temp.pEntry)); |
137 /* map applicable values to XAAudioCodecCapabilities */ |
140 /* map applicable values to XAAudioCodecCapabilities */ |
138 pDescriptor->maxChannels = desc->maxChannels; |
141 pDescriptor->maxChannels = desc->maxChannels; |
139 pDescriptor->minSampleRate= desc->minSampleRate*1000; /* milliHz */ |
142 pDescriptor->minSampleRate = desc->minSampleRate * 1000; /* milliHz */ |
140 if (desc->maxSampleRate < (0xFFFFFFFF / 1000)) |
143 if (desc->maxSampleRate < (0xFFFFFFFF / 1000)) |
141 { |
144 { |
142 pDescriptor->maxSampleRate = desc->maxSampleRate*1000; |
145 pDescriptor->maxSampleRate = desc->maxSampleRate |
|
146 * 1000; |
|
147 } |
|
148 else |
|
149 { |
|
150 pDescriptor->maxSampleRate = 0xFFFFFFFF; |
|
151 } |
|
152 pDescriptor->minBitsPerSample = desc->minBitsPerSample; |
|
153 pDescriptor->maxBitsPerSample = desc->maxBitsPerSample; |
|
154 pDescriptor->isFreqRangeContinuous = XA_BOOLEAN_TRUE; |
|
155 pDescriptor->minBitRate = desc->minBitRate; |
|
156 pDescriptor->maxBitRate = desc->maxBitRate; |
|
157 pDescriptor->numBitratesSupported |
|
158 = desc->numBitratesSupported; |
|
159 pDescriptor->isBitrateRangeContinuous = XA_BOOLEAN_TRUE; |
|
160 if (temp.xaid == XA_AUDIOCODEC_PCM) |
|
161 { |
|
162 pDescriptor->profileSetting = XA_AUDIOPROFILE_PCM; |
|
163 pDescriptor->modeSetting = 0; /* no chanmode for pcm defined */ |
|
164 } |
|
165 else if (temp.xaid == XA_ADAPTID_VORBIS) /* for ogg */ |
|
166 { |
|
167 if (desc->maxChannels == 1) |
|
168 { |
|
169 pDescriptor->profileSetting |
|
170 =XA_AUDIOPROFILE_MPEG1_L3; |
|
171 pDescriptor->modeSetting |
|
172 =XA_AUDIOCHANMODE_MP3_MONO; |
|
173 } |
|
174 else |
|
175 { |
|
176 pDescriptor->profileSetting |
|
177 =XA_AUDIOPROFILE_MPEG2_L3; |
|
178 pDescriptor->modeSetting |
|
179 =XA_AUDIOCHANMODE_MP3_STEREO; |
|
180 } |
|
181 } |
|
182 else |
|
183 { |
|
184 /* do nothing */ |
|
185 } |
|
186 /*other caps undefined*/ |
143 } |
187 } |
144 else |
188 |
145 { |
189 } |
146 pDescriptor->maxSampleRate = 0xFFFFFFFF; |
190 } |
147 } |
191 } |
148 pDescriptor->minBitsPerSample=desc->minBitsPerSample; |
|
149 pDescriptor->maxBitsPerSample=desc->maxBitsPerSample; |
|
150 pDescriptor->isFreqRangeContinuous=XA_BOOLEAN_TRUE; |
|
151 pDescriptor->minBitRate=desc->minBitRate; |
|
152 pDescriptor->maxBitRate=desc->maxBitRate; |
|
153 pDescriptor->numBitratesSupported = desc->numBitratesSupported; |
|
154 pDescriptor->isBitrateRangeContinuous=XA_BOOLEAN_TRUE; |
|
155 if (temp.xaid == XA_AUDIOCODEC_PCM ) |
|
156 { |
|
157 pDescriptor->profileSetting=XA_AUDIOPROFILE_PCM; |
|
158 pDescriptor->modeSetting=0; /* no chanmode for pcm defined */ |
|
159 } |
|
160 else if (temp.xaid == XA_ADAPTID_VORBIS) /* for ogg */ |
|
161 { |
|
162 if (desc->maxChannels == 1) |
|
163 { |
|
164 pDescriptor->profileSetting=XA_AUDIOPROFILE_MPEG1_L3; |
|
165 pDescriptor->modeSetting=XA_AUDIOCHANMODE_MP3_MONO; |
|
166 } |
|
167 else |
|
168 { |
|
169 pDescriptor->profileSetting=XA_AUDIOPROFILE_MPEG2_L3; |
|
170 pDescriptor->modeSetting=XA_AUDIOCHANMODE_MP3_STEREO; |
|
171 } |
|
172 } |
|
173 else |
|
174 { |
|
175 /* do nothing */ |
|
176 } |
|
177 /*other caps undefined*/ |
|
178 } |
|
179 |
|
180 } |
|
181 } |
|
182 } |
|
183 |
192 |
184 DEBUG_API("<-XAAudioDecoderCapabilitiesItfImpl_GetAudioDecoderCapabilities"); |
193 DEBUG_API("<-XAAudioDecoderCapabilitiesItfImpl_GetAudioDecoderCapabilities"); |
185 return res; |
194 return res; |
186 } |
195 } |
187 |
|
188 |
196 |
189 /***************************************************************************** |
197 /***************************************************************************** |
190 * XAAudioDecoderCapabilitiesItfImpl -specific methods |
198 * XAAudioDecoderCapabilitiesItfImpl -specific methods |
191 *****************************************************************************/ |
199 *****************************************************************************/ |
192 |
200 |
193 /* XAAudioDecoderCapabilitiesItfImpl_Create |
201 /* XAAudioDecoderCapabilitiesItfImpl_Create |
194 * Description: Allocate and initialize XAAudioDecoderCapabilitiesItfImpl |
202 * Description: Allocate and initialize XAAudioDecoderCapabilitiesItfImpl |
195 */ |
203 */ |
196 XAAudioDecoderCapabilitiesItfImpl* XAAudioDecoderCapabilitiesItfImpl_Create() |
204 XAAudioDecoderCapabilitiesItfImpl* XAAudioDecoderCapabilitiesItfImpl_Create() |
197 { |
205 { |
198 XAAudioDecoderCapabilitiesItfImpl* self = (XAAudioDecoderCapabilitiesItfImpl*) |
206 XAAudioDecoderCapabilitiesItfImpl* self = |
199 calloc(1,sizeof(XAAudioDecoderCapabilitiesItfImpl)); |
207 (XAAudioDecoderCapabilitiesItfImpl*) calloc(1, |
|
208 sizeof(XAAudioDecoderCapabilitiesItfImpl)); |
200 |
209 |
201 DEBUG_API("->XAAudioDecoderCapabilitiesItfImpl_Create"); |
210 DEBUG_API("->XAAudioDecoderCapabilitiesItfImpl_Create"); |
202 |
211 |
203 if( self ) |
212 if (self) |
204 { |
213 { |
205 /* init itf default implementation */ |
214 /* init itf default implementation */ |
206 self->itf.GetAudioDecoders = |
215 self->itf.GetAudioDecoders |
207 XAAudioDecoderCapabilitiesItfImpl_GetAudioDecoders; |
216 = XAAudioDecoderCapabilitiesItfImpl_GetAudioDecoders; |
208 self->itf.GetAudioDecoderCapabilities = |
217 self->itf.GetAudioDecoderCapabilities |
209 XAAudioDecoderCapabilitiesItfImpl_GetAudioDecoderCapabilities; |
218 = XAAudioDecoderCapabilitiesItfImpl_GetAudioDecoderCapabilities; |
210 |
219 |
211 /* init variables */ |
220 /* init variables */ |
212 |
221 |
213 assert( XACapabilitiesMgr_GetCapsCount(NULL, (XACapsType)(XACAP_DECODER|XACAP_AUDIO), |
222 assert( XACapabilitiesMgr_GetCapsCount(NULL, (XACapsType)(XACAP_DECODER|XACAP_AUDIO), |
214 &(self->numCodecs) ) == XA_RESULT_SUCCESS ); |
223 &(self->numCodecs) ) == XA_RESULT_SUCCESS ); |
215 |
224 |
216 self->self = self; |
225 self->self = self; |
217 } |
226 }DEBUG_API("<-XAAudioDecoderCapabilitiesItfImpl_Create"); |
218 DEBUG_API("<-XAAudioDecoderCapabilitiesItfImpl_Create"); |
|
219 return self; |
227 return self; |
220 } |
228 } |
221 |
229 |
222 /* void XAAudioDecoderCapabilitiesItfImpl_Free |
230 /* void XAAudioDecoderCapabilitiesItfImpl_Free |
223 * Description: Free all resources reserved at XAAudioDecoderCapabilitiesItfImpl_Create |
231 * Description: Free all resources reserved at XAAudioDecoderCapabilitiesItfImpl_Create |
224 */ |
232 */ |
225 void XAAudioDecoderCapabilitiesItfImpl_Free(XAAudioDecoderCapabilitiesItfImpl* self) |
233 void XAAudioDecoderCapabilitiesItfImpl_Free( |
226 { |
234 XAAudioDecoderCapabilitiesItfImpl* self) |
|
235 { |
227 DEBUG_API("->XAAudioDecoderCapabilitiesItfImpl_Free"); |
236 DEBUG_API("->XAAudioDecoderCapabilitiesItfImpl_Free"); |
228 assert(self==self->self); |
237 assert(self==self->self); |
229 free(self); |
238 free(self); |
230 DEBUG_API("<-XAAudioDecoderCapabilitiesItfImpl_Free"); |
239 DEBUG_API("<-XAAudioDecoderCapabilitiesItfImpl_Free"); |
231 } |
240 } |