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 /** \file CEngine.c Engine class */ 18 19 #include "sles_allinclusive.h" 20 21 22 /* This implementation supports at most one engine, identical for both OpenSL ES and OpenMAX AL */ 23 24 CEngine *theOneTrueEngine = NULL; 25 pthread_mutex_t theOneTrueMutex = PTHREAD_MUTEX_INITIALIZER; 26 unsigned theOneTrueRefCount = 0; 27 // incremented by slCreateEngine or xaCreateEngine, decremented by Object::Destroy on engine 28 29 30 /** \brief Called by dlopen when .so is loaded */ 31 32 __attribute__((constructor)) static void onDlOpen(void) 33 { 34 } 35 36 37 /** \brief Called by dlclose when .so is unloaded */ 38 39 __attribute__((destructor)) static void onDlClose(void) 40 { 41 // a memory barrier would be sufficient, but the mutex is easier 42 (void) pthread_mutex_lock(&theOneTrueMutex); 43 if ((NULL != theOneTrueEngine) || (0 < theOneTrueRefCount)) { 44 SL_LOGE("Object::Destroy omitted for engine %p", theOneTrueEngine); 45 } 46 (void) pthread_mutex_unlock(&theOneTrueMutex); 47 } 48 49 50 /** \brief Hook called by Object::Realize when an engine is realized */ 51 52 SLresult CEngine_Realize(void *self, SLboolean async) 53 { 54 CEngine *thiz = (CEngine *) self; 55 SLresult result; 56 #ifndef ANDROID 57 // create the sync thread 58 int err = pthread_create(&thiz->mSyncThread, (const pthread_attr_t *) NULL, sync_start, thiz); 59 result = err_to_result(err); 60 if (SL_RESULT_SUCCESS != result) 61 return result; 62 #endif 63 // initialize the thread pool for asynchronous operations 64 result = ThreadPool_init(&thiz->mThreadPool, 0, 0); 65 if (SL_RESULT_SUCCESS != result) { 66 thiz->mEngine.mShutdown = SL_BOOLEAN_TRUE; 67 (void) pthread_join(thiz->mSyncThread, (void **) NULL); 68 return result; 69 } 70 #ifdef USE_SDL 71 SDL_open(&thiz->mEngine); 72 #endif 73 return SL_RESULT_SUCCESS; 74 } 75 76 77 /** \brief Hook called by Object::Resume when an engine is resumed */ 78 79 SLresult CEngine_Resume(void *self, SLboolean async) 80 { 81 return SL_RESULT_SUCCESS; 82 } 83 84 85 /** \brief Hook called by Object::Destroy when an engine is destroyed */ 86 87 void CEngine_Destroy(void *self) 88 { 89 CEngine *thiz = (CEngine *) self; 90 91 // Verify that there are no extant objects 92 unsigned instanceCount = thiz->mEngine.mInstanceCount; 93 unsigned instanceMask = thiz->mEngine.mInstanceMask; 94 if ((0 < instanceCount) || (0 != instanceMask)) { 95 SL_LOGE("Object::Destroy(%p) for engine ignored; %u total active objects", 96 thiz, instanceCount); 97 while (0 != instanceMask) { 98 unsigned i = ctz(instanceMask); 99 assert(MAX_INSTANCE > i); 100 SL_LOGE("Object::Destroy(%p) for engine ignored; active object ID %u at %p", 101 thiz, i + 1, thiz->mEngine.mInstances[i]); 102 instanceMask &= ~(1 << i); 103 } 104 } 105 106 // If engine was created but not realized, there will be no sync thread yet 107 pthread_t zero; 108 memset(&zero, 0, sizeof(pthread_t)); 109 if (0 != memcmp(&zero, &thiz->mSyncThread, sizeof(pthread_t))) { 110 111 // Announce to the sync thread that engine is shutting down; it polls so should see it soon 112 thiz->mEngine.mShutdown = SL_BOOLEAN_TRUE; 113 // Wait for the sync thread to acknowledge the shutdown 114 while (!thiz->mEngine.mShutdownAck) { 115 object_cond_wait(&thiz->mObject); 116 } 117 // The sync thread should have exited by now, so collect it by joining 118 (void) pthread_join(thiz->mSyncThread, (void **) NULL); 119 120 } 121 122 // Shutdown the thread pool used for asynchronous operations (there should not be any) 123 ThreadPool_deinit(&thiz->mThreadPool); 124 125 #if defined(ANDROID) 126 // free equalizer preset names 127 if (NULL != thiz->mEqPresetNames) { 128 for (unsigned i = 0; i < thiz->mEqNumPresets; ++i) { 129 if (NULL != thiz->mEqPresetNames[i]) { 130 delete[] thiz->mEqPresetNames[i]; 131 thiz->mEqPresetNames[i] = NULL; 132 } 133 } 134 delete[] thiz->mEqPresetNames; 135 thiz->mEqPresetNames = NULL; 136 } 137 thiz->mEqNumPresets = 0; 138 #endif 139 140 #ifdef USE_SDL 141 SDL_close(); 142 #endif 143 144 } 145 146 147 /** \brief Hook called by Object::Destroy before an engine is about to be destroyed */ 148 149 predestroy_t CEngine_PreDestroy(void *self) 150 { 151 predestroy_t ret; 152 (void) pthread_mutex_lock(&theOneTrueMutex); 153 assert(self == theOneTrueEngine); 154 switch (theOneTrueRefCount) { 155 case 0: 156 assert(false); 157 ret = predestroy_error; 158 break; 159 case 1: 160 ret = predestroy_ok; 161 break; 162 default: 163 --theOneTrueRefCount; 164 ret = predestroy_again; 165 break; 166 } 167 (void) pthread_mutex_unlock(&theOneTrueMutex); 168 return ret; 169 } 170 171 172 /** \brief Called by IObject::Destroy after engine is destroyed. The parameter refers to the 173 * previous engine, which is now undefined memory. 174 */ 175 176 void CEngine_Destroyed(CEngine *self) 177 { 178 int ok; 179 ok = pthread_mutex_lock(&theOneTrueMutex); 180 assert(0 == ok); 181 assert(self == theOneTrueEngine); 182 theOneTrueEngine = NULL; 183 assert(1 == theOneTrueRefCount); 184 theOneTrueRefCount = 0; 185 ok = pthread_mutex_unlock(&theOneTrueMutex); 186 assert(0 == ok); 187 } 188
