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