object.c revision e047d27324083628b51bad0661a184f6cb96c56d 
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
24int 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_19";
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