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 /* BufferQueue implementation */ 18 19 #include "sles_allinclusive.h" 20 21 22 /** Determine the state of the audio player or audio recorder associated with a buffer queue. 23 * Note that PLAYSTATE and RECORDSTATE values are equivalent (where PLAYING == RECORDING). 24 */ 25 26 static SLuint32 getAssociatedState(IBufferQueue *thiz) 27 { 28 SLuint32 state; 29 switch (InterfaceToObjectID(thiz)) { 30 case SL_OBJECTID_AUDIOPLAYER: 31 state = ((CAudioPlayer *) thiz->mThis)->mPlay.mState; 32 break; 33 case SL_OBJECTID_AUDIORECORDER: 34 state = ((CAudioRecorder *) thiz->mThis)->mRecord.mState; 35 break; 36 default: 37 // unreachable, but just in case we will assume it is stopped 38 assert(SL_BOOLEAN_FALSE); 39 state = SL_PLAYSTATE_STOPPED; 40 break; 41 } 42 return state; 43 } 44 45 46 SLresult IBufferQueue_Enqueue(SLBufferQueueItf self, const void *pBuffer, SLuint32 size) 47 { 48 SL_ENTER_INTERFACE 49 //SL_LOGV("IBufferQueue_Enqueue(%p, %p, %u)", self, pBuffer, size); 50 51 // Note that Enqueue while a Clear is pending is equivalent to Enqueue followed by Clear 52 53 if (NULL == pBuffer || 0 == size) { 54 result = SL_RESULT_PARAMETER_INVALID; 55 } else { 56 IBufferQueue *thiz = (IBufferQueue *) self; 57 interface_lock_exclusive(thiz); 58 BufferHeader *oldRear = thiz->mRear, *newRear; 59 if ((newRear = oldRear + 1) == &thiz->mArray[thiz->mNumBuffers + 1]) { 60 newRear = thiz->mArray; 61 } 62 if (newRear == thiz->mFront) { 63 result = SL_RESULT_BUFFER_INSUFFICIENT; 64 } else { 65 oldRear->mBuffer = pBuffer; 66 oldRear->mSize = size; 67 thiz->mRear = newRear; 68 ++thiz->mState.count; 69 result = SL_RESULT_SUCCESS; 70 } 71 // set enqueue attribute if state is PLAYING and the first buffer is enqueued 72 interface_unlock_exclusive_attributes(thiz, ((SL_RESULT_SUCCESS == result) && 73 (1 == thiz->mState.count) && (SL_PLAYSTATE_PLAYING == getAssociatedState(thiz))) ? 74 ATTR_BQ_ENQUEUE : ATTR_NONE); 75 } 76 SL_LEAVE_INTERFACE 77 } 78 79 80 SLresult IBufferQueue_Clear(SLBufferQueueItf self) 81 { 82 SL_ENTER_INTERFACE 83 84 result = SL_RESULT_SUCCESS; 85 IBufferQueue *thiz = (IBufferQueue *) self; 86 interface_lock_exclusive(thiz); 87 88 #ifdef ANDROID 89 if (SL_OBJECTID_AUDIOPLAYER == InterfaceToObjectID(thiz)) { 90 CAudioPlayer *audioPlayer = (CAudioPlayer *) thiz->mThis; 91 // flush associated audio player 92 result = android_audioPlayer_bufferQueue_onClear(audioPlayer); 93 if (SL_RESULT_SUCCESS == result) { 94 thiz->mFront = &thiz->mArray[0]; 95 thiz->mRear = &thiz->mArray[0]; 96 thiz->mState.count = 0; 97 thiz->mState.playIndex = 0; 98 thiz->mSizeConsumed = 0; 99 thiz->mCallbackPending = false; 100 } 101 } 102 #endif 103 104 #ifdef USE_OUTPUTMIXEXT 105 // mixer might be reading from the front buffer, so tread carefully here 106 // NTH asynchronous cancel instead of blocking until mixer acknowledges 107 thiz->mClearRequested = SL_BOOLEAN_TRUE; 108 do { 109 interface_cond_wait(thiz); 110 } while (thiz->mClearRequested); 111 #endif 112 113 interface_unlock_exclusive(thiz); 114 115 SL_LEAVE_INTERFACE 116 } 117 118 119 static SLresult IBufferQueue_GetState(SLBufferQueueItf self, SLBufferQueueState *pState) 120 { 121 SL_ENTER_INTERFACE 122 123 // Note that GetState while a Clear is pending is equivalent to GetState before the Clear 124 125 if (NULL == pState) { 126 result = SL_RESULT_PARAMETER_INVALID; 127 } else { 128 IBufferQueue *thiz = (IBufferQueue *) self; 129 SLBufferQueueState state; 130 interface_lock_shared(thiz); 131 #ifdef __cplusplus // FIXME Is this a compiler bug? 132 state.count = thiz->mState.count; 133 state.playIndex = thiz->mState.playIndex; 134 #else 135 state = thiz->mState; 136 #endif 137 interface_unlock_shared(thiz); 138 *pState = state; 139 result = SL_RESULT_SUCCESS; 140 } 141 142 SL_LEAVE_INTERFACE 143 } 144 145 146 SLresult IBufferQueue_RegisterCallback(SLBufferQueueItf self, 147 slBufferQueueCallback callback, void *pContext) 148 { 149 SL_ENTER_INTERFACE 150 151 IBufferQueue *thiz = (IBufferQueue *) self; 152 interface_lock_exclusive(thiz); 153 // verify pre-condition that media object is in the SL_PLAYSTATE_STOPPED state 154 if (SL_PLAYSTATE_STOPPED == getAssociatedState(thiz)) { 155 thiz->mCallback = callback; 156 thiz->mContext = pContext; 157 result = SL_RESULT_SUCCESS; 158 } else { 159 result = SL_RESULT_PRECONDITIONS_VIOLATED; 160 } 161 interface_unlock_exclusive(thiz); 162 163 SL_LEAVE_INTERFACE 164 } 165 166 167 static const struct SLBufferQueueItf_ IBufferQueue_Itf = { 168 IBufferQueue_Enqueue, 169 IBufferQueue_Clear, 170 IBufferQueue_GetState, 171 IBufferQueue_RegisterCallback 172 }; 173 174 void IBufferQueue_init(void *self) 175 { 176 IBufferQueue *thiz = (IBufferQueue *) self; 177 thiz->mItf = &IBufferQueue_Itf; 178 thiz->mState.count = 0; 179 thiz->mState.playIndex = 0; 180 thiz->mCallback = NULL; 181 thiz->mContext = NULL; 182 thiz->mNumBuffers = 0; 183 thiz->mClearRequested = SL_BOOLEAN_FALSE; 184 thiz->mArray = NULL; 185 thiz->mFront = NULL; 186 thiz->mRear = NULL; 187 #ifdef ANDROID 188 thiz->mSizeConsumed = 0; 189 thiz->mCallbackPending = false; 190 #endif 191 BufferHeader *bufferHeader = thiz->mTypical; 192 unsigned i; 193 for (i = 0; i < BUFFER_HEADER_TYPICAL+1; ++i, ++bufferHeader) { 194 bufferHeader->mBuffer = NULL; 195 bufferHeader->mSize = 0; 196 } 197 } 198 199 200 /** \brief Interface deinitialization hook called by IObject::Destroy. 201 * Free the buffer queue, if it was larger than typical. 202 */ 203 204 void IBufferQueue_deinit(void *self) 205 { 206 IBufferQueue *thiz = (IBufferQueue *) self; 207 if ((NULL != thiz->mArray) && (thiz->mArray != thiz->mTypical)) { 208 free(thiz->mArray); 209 thiz->mArray = NULL; 210 } 211 } 212