Home | History | Annotate | Download | only in sandbox
      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 
     26 int 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 %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