1 /*
2 * Copyright (C) 2010 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 /* PlaybackRate implementation */
18
19 #include "sles_allinclusive.h"
20
21
IPlaybackRate_SetRate(SLPlaybackRateItf self,SLpermille rate)22 static SLresult IPlaybackRate_SetRate(SLPlaybackRateItf self, SLpermille rate)
23 {
24 SL_ENTER_INTERFACE
25
26 IPlaybackRate *thiz = (IPlaybackRate *) self;
27 // const, so no lock needed
28 if (!(thiz->mMinRate <= rate && rate <= thiz->mMaxRate)) {
29 result = SL_RESULT_PARAMETER_INVALID;
30 } else {
31 interface_lock_exclusive(thiz);
32 #ifdef ANDROID
33 CAudioPlayer *ap = (SL_OBJECTID_AUDIOPLAYER == InterfaceToObjectID(thiz)) ?
34 (CAudioPlayer *) thiz->mThis : NULL;
35 if (NULL != ap) {
36 result = android_audioPlayer_setPlaybackRateAndConstraints(ap, rate, thiz->mProperties);
37 } else {
38 result = SL_RESULT_FEATURE_UNSUPPORTED;
39 }
40 #else
41 result = SL_RESULT_SUCCESS;
42 #endif
43 if (SL_RESULT_SUCCESS == result) {
44 thiz->mRate = rate;
45 }
46 interface_unlock_exclusive(thiz);
47 }
48
49 SL_LEAVE_INTERFACE
50 }
51
52
IPlaybackRate_GetRate(SLPlaybackRateItf self,SLpermille * pRate)53 static SLresult IPlaybackRate_GetRate(SLPlaybackRateItf self, SLpermille *pRate)
54 {
55 SL_ENTER_INTERFACE
56
57 if (NULL == pRate) {
58 result = SL_RESULT_PARAMETER_INVALID;
59 } else {
60 IPlaybackRate *thiz = (IPlaybackRate *) self;
61 interface_lock_shared(thiz);
62 SLpermille rate = thiz->mRate;
63 interface_unlock_shared(thiz);
64 *pRate = rate;
65 result = SL_RESULT_SUCCESS;
66 }
67
68 SL_LEAVE_INTERFACE
69 }
70
71
IPlaybackRate_SetPropertyConstraints(SLPlaybackRateItf self,SLuint32 constraints)72 static SLresult IPlaybackRate_SetPropertyConstraints(SLPlaybackRateItf self, SLuint32 constraints)
73 {
74 SL_ENTER_INTERFACE
75
76 IPlaybackRate *thiz = (IPlaybackRate *) self;
77 if (constraints & ~(SL_RATEPROP_SILENTAUDIO | SL_RATEPROP_STAGGEREDAUDIO |
78 SL_RATEPROP_NOPITCHCORAUDIO | SL_RATEPROP_PITCHCORAUDIO)) {
79 result = SL_RESULT_PARAMETER_INVALID;
80 // const, so no lock needed
81 } else if (!(thiz->mCapabilities & constraints)) {
82 result = SL_RESULT_FEATURE_UNSUPPORTED;
83 } else {
84 interface_lock_exclusive(thiz);
85 #ifdef ANDROID
86 // verify property support before storing
87 CAudioPlayer *ap = (SL_OBJECTID_AUDIOPLAYER == InterfaceToObjectID(thiz)) ?
88 (CAudioPlayer *) thiz->mThis : NULL;
89 if (NULL != ap) {
90 result = android_audioPlayer_setPlaybackRateAndConstraints(ap, thiz->mRate,
91 constraints);
92 } else {
93 result = SL_RESULT_FEATURE_UNSUPPORTED;
94 }
95 #else
96 result = SL_RESULT_SUCCESS;
97 #endif
98 if (result == SL_RESULT_SUCCESS) {
99 thiz->mProperties = constraints;
100 }
101 interface_unlock_exclusive(thiz);
102 }
103
104 SL_LEAVE_INTERFACE
105 }
106
107
IPlaybackRate_GetProperties(SLPlaybackRateItf self,SLuint32 * pProperties)108 static SLresult IPlaybackRate_GetProperties(SLPlaybackRateItf self, SLuint32 *pProperties)
109 {
110 SL_ENTER_INTERFACE
111
112 if (NULL == pProperties) {
113 result = SL_RESULT_PARAMETER_INVALID;
114 } else {
115 IPlaybackRate *thiz = (IPlaybackRate *) self;
116 interface_lock_shared(thiz);
117 SLuint32 properties = thiz->mProperties;
118 interface_unlock_shared(thiz);
119 *pProperties = properties;
120 result = SL_RESULT_SUCCESS;
121 }
122
123 SL_LEAVE_INTERFACE
124 }
125
126
IPlaybackRate_GetCapabilitiesOfRate(SLPlaybackRateItf self,SLpermille rate,SLuint32 * pCapabilities)127 static SLresult IPlaybackRate_GetCapabilitiesOfRate(SLPlaybackRateItf self,
128 SLpermille rate, SLuint32 *pCapabilities)
129 {
130 SL_ENTER_INTERFACE
131
132 if (NULL == pCapabilities) {
133 result = SL_RESULT_PARAMETER_INVALID;
134 } else {
135 IPlaybackRate *thiz = (IPlaybackRate *) self;
136 SLuint32 capabilities;
137 // const, so no lock needed
138 if (!(thiz->mMinRate <= rate && rate <= thiz->mMaxRate)) {
139 capabilities = 0;
140 result = SL_RESULT_PARAMETER_INVALID;
141 } else {
142 capabilities = thiz->mCapabilities;
143 result = SL_RESULT_SUCCESS;
144 }
145 *pCapabilities = capabilities;
146 }
147
148 SL_LEAVE_INTERFACE
149 }
150
151
IPlaybackRate_GetRateRange(SLPlaybackRateItf self,SLuint8 index,SLpermille * pMinRate,SLpermille * pMaxRate,SLpermille * pStepSize,SLuint32 * pCapabilities)152 static SLresult IPlaybackRate_GetRateRange(SLPlaybackRateItf self, SLuint8 index,
153 SLpermille *pMinRate, SLpermille *pMaxRate, SLpermille *pStepSize, SLuint32 *pCapabilities)
154 {
155 SL_ENTER_INTERFACE
156
157 // only one range
158 if (NULL == pMinRate || NULL == pMaxRate || NULL == pStepSize || NULL == pCapabilities ||
159 (0 < index)) {
160 result = SL_RESULT_PARAMETER_INVALID;
161 } else {
162 IPlaybackRate *thiz = (IPlaybackRate *) self;
163 // const, so no lock needed
164 SLpermille minRate = thiz->mMinRate;
165 SLpermille maxRate = thiz->mMaxRate;
166 SLpermille stepSize = thiz->mStepSize;
167 SLuint32 capabilities = thiz->mCapabilities;
168 *pMinRate = minRate;
169 *pMaxRate = maxRate;
170 *pStepSize = stepSize;
171 *pCapabilities = capabilities;
172 result = SL_RESULT_SUCCESS;
173 }
174
175 SL_LEAVE_INTERFACE
176 }
177
178
179 static const struct SLPlaybackRateItf_ IPlaybackRate_Itf = {
180 IPlaybackRate_SetRate,
181 IPlaybackRate_GetRate,
182 IPlaybackRate_SetPropertyConstraints,
183 IPlaybackRate_GetProperties,
184 IPlaybackRate_GetCapabilitiesOfRate,
185 IPlaybackRate_GetRateRange
186 };
187
IPlaybackRate_init(void * self)188 void IPlaybackRate_init(void *self)
189 {
190 IPlaybackRate *thiz = (IPlaybackRate *) self;
191 thiz->mItf = &IPlaybackRate_Itf;
192 thiz->mProperties = SL_RATEPROP_NOPITCHCORAUDIO;
193 thiz->mRate = 1000;
194 // const after initialization; these are default values which may be overwritten
195 // during object creation but will not be modified after that
196 // (e.g. for an Android AudioPlayer, see sles_to_android_audioPlayerCreate)
197 thiz->mMinRate = 1000;
198 thiz->mMaxRate = 1000;
199 thiz->mStepSize = 0;
200 thiz->mCapabilities = SL_RATEPROP_NOPITCHCORAUDIO;
201 }
202