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 // output mix interface tests
18 
19 #include <SLES/OpenSLES.h>
20 #include "OpenSLESUT.h"
21 #include <assert.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 
main(int argc __unused,char ** argv __unused)26 int main(int argc __unused, char **argv __unused)
27 {
28     // create engine
29     SLObjectItf engineObject;
30     SLresult result;
31     result = slCreateEngine(&engineObject, 0, NULL, 0, NULL, NULL);
32     assert(SL_RESULT_SUCCESS == result);
33     printf("Engine object %p\n", engineObject);
34     // realize engine
35     result = (*engineObject)->Realize(engineObject, SL_BOOLEAN_FALSE);
36     assert(SL_RESULT_SUCCESS == result);
37     // get engine interface
38     SLEngineItf engineEngine;
39     result = (*engineObject)->GetInterface(engineObject, SL_IID_ENGINE, &engineEngine);
40     assert(SL_RESULT_SUCCESS == result);
41     // query supported interfaces on output mix object ID and display their IDs
42     SLuint32 numSupportedInterfaces;
43     result = (*engineEngine)->QueryNumSupportedInterfaces(engineEngine, SL_OBJECTID_OUTPUTMIX,
44             &numSupportedInterfaces);
45     assert(SL_RESULT_SUCCESS == result);
46     printf("Output mix supports %u interfaces:\n", numSupportedInterfaces);
47     SLuint32 i;
48     for (i = 0; i < numSupportedInterfaces; ++i) {
49         SLInterfaceID interfaceID;
50         result = (*engineEngine)->QuerySupportedInterfaces(engineEngine, SL_OBJECTID_OUTPUTMIX, i,
51                 &interfaceID);
52         assert(SL_RESULT_SUCCESS == result);
53         printf(" [%u] = ", i);
54         slesutPrintIID(interfaceID);
55     }
56     // create output mix, with no place to put the new object
57     result = (*engineEngine)->CreateOutputMix(engineEngine, NULL, 0, NULL, NULL);
58     assert(SL_RESULT_PARAMETER_INVALID == result);
59     // create output mix, requesting no explicit interfaces
60     SLObjectItf outputMixObject;
61     result = (*engineEngine)->CreateOutputMix(engineEngine, &outputMixObject, 0, NULL, NULL);
62     assert(SL_RESULT_SUCCESS == result);
63     printf("Output mix object %p\n", outputMixObject);
64     // get object interface before realization
65     SLObjectItf outputMixObject2;
66     result = (*outputMixObject)->GetInterface(outputMixObject, SL_IID_OBJECT, &outputMixObject2);
67     assert(SL_RESULT_SUCCESS == result);
68     assert(outputMixObject2 == outputMixObject);
69     // get any other interface before realization should fail
70     SLOutputMixItf outputMixOutputMix;
71     result = (*outputMixObject)->GetInterface(outputMixObject, SL_IID_OUTPUTMIX,
72             &outputMixOutputMix);
73     assert(SL_RESULT_PRECONDITIONS_VIOLATED == result);
74     // realize the output mix
75     result = (*outputMixObject)->Realize(outputMixObject, SL_BOOLEAN_FALSE);
76     assert(SL_RESULT_SUCCESS == result);
77     // get each expected implicit interface
78     outputMixObject2 = NULL;
79     result = (*outputMixObject)->GetInterface(outputMixObject, SL_IID_OBJECT, &outputMixObject2);
80     assert(SL_RESULT_SUCCESS == result);
81     assert(outputMixObject2 == outputMixObject);
82     SLDynamicInterfaceManagementItf outputMixDynamicInterfaceManagement;
83     result = (*outputMixObject)->GetInterface(outputMixObject, SL_IID_DYNAMICINTERFACEMANAGEMENT,
84             &outputMixDynamicInterfaceManagement);
85     assert((SL_RESULT_SUCCESS == result) || (SL_RESULT_FEATURE_UNSUPPORTED) == result);
86     if (SL_RESULT_SUCCESS == result) {
87         printf("Output mix supports dynamic interface management\n");
88     } else {
89         printf("Output mix does not support dynamic interface management\n");
90     }
91     result = (*outputMixObject)->GetInterface(outputMixObject, SL_IID_OUTPUTMIX,
92             &outputMixOutputMix);
93     assert(SL_RESULT_SUCCESS == result);
94     // get explicit and optional interfaces should fail since not requested at creation
95     SLEnvironmentalReverbItf outputMixEnvironmentalReverb;
96     result = (*outputMixObject)->GetInterface(outputMixObject, SL_IID_ENVIRONMENTALREVERB,
97             &outputMixEnvironmentalReverb);
98     assert(SL_RESULT_FEATURE_UNSUPPORTED == result);
99     SLEqualizerItf outputMixEqualizer;
100     result = (*outputMixObject)->GetInterface(outputMixObject, SL_IID_EQUALIZER,
101             &outputMixEqualizer);
102     assert(SL_RESULT_FEATURE_UNSUPPORTED == result);
103     SLPresetReverbItf outputMixPresetReverb;
104     result = (*outputMixObject)->GetInterface(outputMixObject, SL_IID_PRESETREVERB,
105             &outputMixPresetReverb);
106     assert(SL_RESULT_FEATURE_UNSUPPORTED == result);
107     SLVirtualizerItf outputMixVirtualizer;
108     result = (*outputMixObject)->GetInterface(outputMixObject, SL_IID_VIRTUALIZER,
109             &outputMixVirtualizer);
110     assert(SL_RESULT_FEATURE_UNSUPPORTED == result);
111     SLVolumeItf outputMixVolume;
112     result = (*outputMixObject)->GetInterface(outputMixObject, SL_IID_VOLUME,
113             &outputMixVolume);
114     assert(SL_RESULT_FEATURE_UNSUPPORTED == result);
115     SLBassBoostItf outputMixBassBoost;
116     result = (*outputMixObject)->GetInterface(outputMixObject, SL_IID_BASSBOOST,
117             &outputMixBassBoost);
118     assert(SL_RESULT_FEATURE_UNSUPPORTED == result);
119     SLVisualizationItf outputMixVisualization;
120     result = (*outputMixObject)->GetInterface(outputMixObject, SL_IID_VISUALIZATION,
121             &outputMixVisualization);
122     assert(SL_RESULT_FEATURE_UNSUPPORTED == result);
123     // destroy output mix
124     (*outputMixObject)->Destroy(outputMixObject);
125     // re-create output mix, this time requesting implicit interfaces as "hard" requirements (must
126     // be there), and explicit interfaces as "soft" requirements (OK if not available)
127     SLInterfaceID ids[10] = {SL_IID_OBJECT, SL_IID_DYNAMICINTERFACEMANAGEMENT, SL_IID_OUTPUTMIX,
128             SL_IID_ENVIRONMENTALREVERB, SL_IID_EQUALIZER, SL_IID_PRESETREVERB, SL_IID_VIRTUALIZER,
129             SL_IID_VOLUME, SL_IID_BASSBOOST, SL_IID_VISUALIZATION};
130     SLboolean req[10] = {SL_BOOLEAN_TRUE, SL_BOOLEAN_FALSE /*SL_BOOLEAN_TRUE*/, SL_BOOLEAN_TRUE,
131             SL_BOOLEAN_TRUE/*FALSE*/, SL_BOOLEAN_FALSE, SL_BOOLEAN_FALSE, SL_BOOLEAN_FALSE,
132             SL_BOOLEAN_FALSE, SL_BOOLEAN_FALSE, SL_BOOLEAN_FALSE};
133     result = (*engineEngine)->CreateOutputMix(engineEngine, &outputMixObject, 10, ids, req);
134     assert(SL_RESULT_SUCCESS == result);
135     printf("Output mix object %p\n", outputMixObject);
136     // realize the output mix
137     result = (*outputMixObject)->Realize(outputMixObject, SL_BOOLEAN_FALSE);
138     assert(SL_RESULT_SUCCESS == result);
139     // get implicit interfaces
140     result = (*outputMixObject)->GetInterface(outputMixObject, SL_IID_OBJECT,
141             &outputMixObject2);
142     assert(SL_RESULT_SUCCESS == result);
143     result = (*outputMixObject)->GetInterface(outputMixObject, SL_IID_DYNAMICINTERFACEMANAGEMENT,
144             &outputMixDynamicInterfaceManagement);
145     assert((SL_RESULT_SUCCESS == result) || (SL_RESULT_FEATURE_UNSUPPORTED) == result);
146     result = (*outputMixObject)->GetInterface(outputMixObject, SL_IID_OUTPUTMIX,
147             &outputMixOutputMix);
148     assert(SL_RESULT_SUCCESS == result);
149     // get explicit and optional interfaces should succeed since they were requested at creation
150     result = (*outputMixObject)->GetInterface(outputMixObject, SL_IID_ENVIRONMENTALREVERB,
151             &outputMixEnvironmentalReverb);
152     assert(SL_RESULT_SUCCESS == result);
153     result = (*outputMixObject)->GetInterface(outputMixObject, SL_IID_EQUALIZER,
154             &outputMixEqualizer);
155     assert(SL_RESULT_SUCCESS == result);
156     result = (*outputMixObject)->GetInterface(outputMixObject, SL_IID_PRESETREVERB,
157             &outputMixPresetReverb);
158     assert(SL_RESULT_SUCCESS == result);
159     result = (*outputMixObject)->GetInterface(outputMixObject, SL_IID_VIRTUALIZER,
160             &outputMixVirtualizer);
161     assert(SL_RESULT_SUCCESS == result);
162     result = (*outputMixObject)->GetInterface(outputMixObject, SL_IID_VOLUME,
163             &outputMixVolume);
164     assert((SL_RESULT_SUCCESS == result) || (SL_RESULT_FEATURE_UNSUPPORTED) == result);
165     if (SL_RESULT_SUCCESS == result) {
166         printf("Output mix supports volume\n");
167     } else {
168         printf("Output mix does not support volume\n");
169     }
170     result = (*outputMixObject)->GetInterface(outputMixObject, SL_IID_BASSBOOST,
171             &outputMixBassBoost);
172     assert(SL_RESULT_SUCCESS == result);
173     result = (*outputMixObject)->GetInterface(outputMixObject, SL_IID_VISUALIZATION,
174             &outputMixVisualization);
175     assert((SL_RESULT_SUCCESS == result) || (SL_RESULT_FEATURE_UNSUPPORTED) == result);
176     if (SL_RESULT_SUCCESS == result) {
177         printf("Output mix supports visualization\n");
178     } else {
179         printf("Output mix does not support visualization\n");
180     }
181     // use the OutputMix interface on output mix object, in order to get code coverage
182     SLint32 numDevices = 1;
183     SLuint32 deviceIDs[1];
184     result = (*outputMixOutputMix)->GetDestinationOutputDeviceIDs(outputMixOutputMix, &numDevices,
185             deviceIDs);
186     assert(SL_RESULT_SUCCESS == result);
187     assert(1 == numDevices);
188     assert(SL_DEFAULTDEVICEID_AUDIOOUTPUT == deviceIDs[0]);
189     result = (*outputMixOutputMix)->RegisterDeviceChangeCallback(outputMixOutputMix, NULL, NULL);
190     assert(SL_RESULT_SUCCESS == result);
191     result = (*outputMixOutputMix)->ReRoute(outputMixOutputMix, 1, deviceIDs);
192     assert(SL_RESULT_SUCCESS == result);
193     // destroy output mix
194     (*outputMixObject)->Destroy(outputMixObject);
195     // destroy engine
196     (*engineObject)->Destroy(engineObject);
197     return EXIT_SUCCESS;
198 }
199