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 #include <assert.h> 18 #include <stdio.h> 19 #include <stdlib.h> 20 #include <string.h> 21 #include <SLES/OpenSLES.h> 22 #include "OpenSLESUT.h" 23 24 int main(int arg, char **argv) 25 { 26 SLresult result; 27 28 printf("Create engine\n"); 29 SLObjectItf engineObject; 30 // create engine 31 result = slCreateEngine(&engineObject, 0, NULL, 0, NULL, NULL); 32 assert(SL_RESULT_SUCCESS == result); 33 result = (*engineObject)->Realize(engineObject, SL_BOOLEAN_FALSE); 34 assert(SL_RESULT_SUCCESS == result); 35 SLEngineItf engineEngine; 36 result = (*engineObject)->GetInterface(engineObject, SL_IID_ENGINE, &engineEngine); 37 assert(SL_RESULT_SUCCESS == result); 38 SLuint32 i; 39 // loop through both valid and invalid object IDs 40 SLuint32 objectID; 41 // Test object IDs from one less than the first valid object 42 // ID, up to one more than the last valid object ID. This way 43 // we can test for both valid and invalid object IDs at both 44 // ends. If more objects are added, be sure to update the macros. 45 #define FIRST_VALID SL_OBJECTID_ENGINE 46 #define LAST_VALID SL_OBJECTID_METADATAEXTRACTOR 47 for (objectID = FIRST_VALID - 1; objectID <= LAST_VALID + 1; ++objectID) { 48 printf("object ID %x", objectID); 49 const char *string = slesutObjectIDToString(objectID); 50 if (NULL != string) 51 printf(" (%s)", string); 52 printf(":\n"); 53 result = (*engineEngine)->QueryNumSupportedInterfaces(engineEngine, objectID, NULL); 54 assert(SL_RESULT_PARAMETER_INVALID == result); 55 SLuint32 numSupportedInterfaces = 12345; 56 result = (*engineEngine)->QueryNumSupportedInterfaces(engineEngine, objectID, 57 &numSupportedInterfaces); 58 SLInterfaceID interfaceID; 59 if (SL_RESULT_FEATURE_UNSUPPORTED == result) { 60 printf(" unsupported\n"); 61 result = (*engineEngine)->QuerySupportedInterfaces(engineEngine, objectID, 0, 62 &interfaceID); 63 assert(SL_RESULT_FEATURE_UNSUPPORTED == result); 64 assert(NULL == interfaceID); 65 continue; 66 } 67 assert(SL_RESULT_SUCCESS == result); 68 printf("numSupportedInterfaces %u\n", numSupportedInterfaces); 69 for (i = 0; i < numSupportedInterfaces + 1; ++i) { 70 result = (*engineEngine)->QuerySupportedInterfaces(engineEngine, objectID, i, NULL); 71 assert(SL_RESULT_PARAMETER_INVALID == result); 72 result = (*engineEngine)->QuerySupportedInterfaces(engineEngine, objectID, i, 73 &interfaceID); 74 if (i < numSupportedInterfaces) { 75 assert(SL_RESULT_SUCCESS == result); 76 printf(" interface %u ", i); 77 slesutPrintIID(interfaceID); 78 } else { 79 assert(SL_RESULT_PARAMETER_INVALID == result); 80 } 81 } 82 } 83 // query number of extensions 84 result = (*engineEngine)->QueryNumSupportedExtensions(engineEngine, NULL); 85 assert(SL_RESULT_PARAMETER_INVALID == result); 86 SLuint32 numExtensions = 0x12345; 87 result = (*engineEngine)->QueryNumSupportedExtensions(engineEngine, &numExtensions); 88 assert(SL_RESULT_SUCCESS == result); 89 printf("numExtensions = %u\n", numExtensions); 90 // query names of the extensions 91 for (i = 0; i < numExtensions + 1; ++i) { 92 SLchar extensionName[32]; 93 result = (*engineEngine)->QuerySupportedExtension(engineEngine, i, extensionName, NULL); 94 assert(SL_RESULT_PARAMETER_INVALID == result); 95 SLint16 nameLength = -1; 96 result = (*engineEngine)->QuerySupportedExtension(engineEngine, i, NULL, &nameLength); 97 if (i < numExtensions) { 98 assert(SL_RESULT_SUCCESS == result); 99 printf(" extension[%u] length = %u\n", i, nameLength); 100 } else { 101 assert(SL_RESULT_PARAMETER_INVALID == result); 102 assert(0 == nameLength); 103 } 104 memset(extensionName, 'X', sizeof(extensionName)); 105 nameLength = -1; 106 result = (*engineEngine)->QuerySupportedExtension(engineEngine, i, extensionName, 107 &nameLength); 108 if (i < numExtensions) { 109 assert(SL_RESULT_BUFFER_INSUFFICIENT == result); 110 } else { 111 assert(SL_RESULT_PARAMETER_INVALID == result); 112 } 113 assert('X' == extensionName[0]); 114 nameLength = 0; 115 result = (*engineEngine)->QuerySupportedExtension(engineEngine, i, extensionName, 116 &nameLength); 117 if (i < numExtensions) { 118 assert(SL_RESULT_BUFFER_INSUFFICIENT == result); 119 } else { 120 assert(SL_RESULT_PARAMETER_INVALID == result); 121 } 122 assert('X' == extensionName[0]); 123 nameLength = 1; 124 result = (*engineEngine)->QuerySupportedExtension(engineEngine, i, extensionName, 125 &nameLength); 126 if (i < numExtensions) { 127 assert(SL_RESULT_BUFFER_INSUFFICIENT == result); 128 assert('\0' == extensionName[0]); 129 } else { 130 assert(SL_RESULT_PARAMETER_INVALID == result); 131 } 132 assert('X' == extensionName[1]); 133 nameLength = sizeof(extensionName); 134 result = (*engineEngine)->QuerySupportedExtension(engineEngine, i, extensionName, 135 &nameLength); 136 if (i < numExtensions) { 137 assert(SL_RESULT_SUCCESS == result); 138 assert((1 <= nameLength) && (nameLength <= (SLint16) sizeof(extensionName))); 139 printf(" extension[%u] = \"%.*s\"\n", i, nameLength, extensionName); 140 } else { 141 assert(SL_RESULT_PARAMETER_INVALID == result); 142 assert(0 == nameLength); 143 } 144 } 145 // check if extension is supported 146 SLboolean isSupported = SL_BOOLEAN_TRUE; 147 result = (*engineEngine)->IsExtensionSupported(engineEngine, NULL, &isSupported); 148 assert(SL_RESULT_PARAMETER_INVALID == result); 149 assert(SL_BOOLEAN_FALSE == isSupported); 150 SLchar *unsupportedExt = (SLchar *) "fish"; 151 result = (*engineEngine)->IsExtensionSupported(engineEngine, unsupportedExt, NULL); 152 assert(SL_RESULT_PARAMETER_INVALID == result); 153 isSupported = SL_BOOLEAN_TRUE; 154 result = (*engineEngine)->IsExtensionSupported(engineEngine, unsupportedExt, &isSupported); 155 assert(SL_RESULT_SUCCESS == result); 156 assert(SL_BOOLEAN_FALSE == isSupported); 157 SLchar *supportedExt; 158 #ifdef ANDROID 159 // whereas the implementation uses PLATFORM_SDK_VERSION, use a hard-coded value here 160 // so that we're actually testing for a particular expected value 161 supportedExt = (SLchar *) "ANDROID_SDK_LEVEL_13"; 162 #else 163 supportedExt = (SLchar *) "WILHELM_DESKTOP"; 164 #endif 165 isSupported = SL_BOOLEAN_FALSE; 166 result = (*engineEngine)->IsExtensionSupported(engineEngine, supportedExt, &isSupported); 167 assert(SL_RESULT_SUCCESS == result); 168 assert(SL_BOOLEAN_TRUE == isSupported); 169 // create an extension object with no place to put the new object 170 result = (*engineEngine)->CreateExtensionObject(engineEngine, NULL, NULL, 0x123, 0, NULL, NULL); 171 assert(SL_RESULT_PARAMETER_INVALID == result); 172 // create an extension object, which is unsupported 173 SLObjectItf extensionObject; 174 result = (*engineEngine)->CreateExtensionObject(engineEngine, &extensionObject, NULL, 0x123, 0, 175 NULL, NULL); 176 assert(SL_RESULT_FEATURE_UNSUPPORTED == result); 177 assert(NULL == extensionObject); 178 // destroy engine 179 (*engineObject)->Destroy(engineObject); 180 return EXIT_SUCCESS; 181 } 182
