android_StreamPlayer.cpp revision 4ee246c55533bdab8ab5fa0f0581744fe58e7c91
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//#define USE_LOG SLAndroidLogLevel_Verbose 18 19#include "sles_allinclusive.h" 20#include "android_StreamPlayer.h" 21 22#include <media/IStreamSource.h> 23#include <media/IMediaPlayerService.h> 24#include <media/stagefright/foundation/ADebug.h> 25 26//-------------------------------------------------------------------------------------------------- 27// FIXME abstract out the diff between CMediaPlayer and CAudioPlayer 28 29void android_StreamPlayer_realize_l(CAudioPlayer *ap, const notif_cbf_t cbf, void* notifUser) { 30 SL_LOGI("android_StreamPlayer_realize_l(%p)", ap); 31 32 AudioPlayback_Parameters ap_params; 33 ap_params.sessionId = ap->mSessionId; 34 ap_params.streamType = ap->mStreamType; 35 ap_params.trackcb = NULL; 36 ap_params.trackcbUser = NULL; 37 android::StreamPlayer* splr = new android::StreamPlayer(&ap_params, false /*hasVideo*/); 38 ap->mAPlayer = splr; 39 splr->init(cbf, notifUser); 40} 41 42 43//-------------------------------------------------------------------------------------------------- 44namespace android { 45 46StreamSourceAppProxy::StreamSourceAppProxy( 47 const void* user, bool userIsAudioPlayer, 48 void *context, const void *caller) : 49 mUser(user), 50 mUserIsAudioPlayer(userIsAudioPlayer), 51 mAndroidBufferQueue(NULL), 52 mAppContext(context), 53 mCaller(caller) 54{ 55 SL_LOGI("StreamSourceAppProxy::StreamSourceAppProxy()"); 56 57 if (mUserIsAudioPlayer) { 58 mAndroidBufferQueue = &((CAudioPlayer*)mUser)->mAndroidBufferQueue; 59 } else { 60 mAndroidBufferQueue = &((CMediaPlayer*)mUser)->mAndroidBufferQueue; 61 } 62} 63 64StreamSourceAppProxy::~StreamSourceAppProxy() { 65 SL_LOGD("StreamSourceAppProxy::~StreamSourceAppProxy()"); 66 mListener.clear(); 67 mBuffers.clear(); 68} 69 70const SLuint32 StreamSourceAppProxy::kItemProcessed[NB_BUFFEREVENT_ITEM_FIELDS] = { 71 SL_ANDROID_ITEMKEY_BUFFERQUEUEEVENT, // item key 72 sizeof(SLuint32), // item size 73 SL_ANDROIDBUFFERQUEUEEVENT_PROCESSED // item data 74}; 75 76//-------------------------------------------------- 77// IStreamSource implementation 78void StreamSourceAppProxy::setListener(const sp<IStreamListener> &listener) { 79 Mutex::Autolock _l(mLock); 80 mListener = listener; 81} 82 83void StreamSourceAppProxy::setBuffers(const Vector<sp<IMemory> > &buffers) { 84 mBuffers = buffers; 85} 86 87void StreamSourceAppProxy::onBufferAvailable(size_t index) { 88 //SL_LOGD("StreamSourceAppProxy::onBufferAvailable(%d)", index); 89 90 CHECK_LT(index, mBuffers.size()); 91 sp<IMemory> mem = mBuffers.itemAt(index); 92 SLAint64 length = (SLAint64) mem->size(); 93 94 { 95 Mutex::Autolock _l(mLock); 96 mAvailableBuffers.push_back(index); 97 } 98//SL_LOGD("onBufferAvailable() now %d buffers available in queue", mAvailableBuffers.size()); 99 100 // a new shared mem buffer is available: let's try to fill immediately 101 pullFromBuffQueue(); 102} 103 104void StreamSourceAppProxy::receivedCmd_l(IStreamListener::Command cmd, const sp<AMessage> &msg) { 105 if (mListener != 0) { 106 mListener->issueCommand(cmd, false /* synchronous */, msg); 107 } 108} 109 110void StreamSourceAppProxy::receivedBuffer_l(size_t buffIndex, size_t buffLength) { 111 if (mListener != 0) { 112 mListener->queueBuffer(buffIndex, buffLength); 113 } 114} 115 116//-------------------------------------------------- 117// consumption from ABQ 118void StreamSourceAppProxy::pullFromBuffQueue() { 119 120 size_t bufferId; 121 void* bufferLoc; 122 size_t buffSize; 123 124 slAndroidBufferQueueCallback callback = NULL; 125 void* callbackPContext = NULL; 126 AdvancedBufferHeader *oldFront = NULL; 127 128 // retrieve data from the buffer queue 129 interface_lock_exclusive(mAndroidBufferQueue); 130 131 if (mAndroidBufferQueue->mState.count != 0) { 132 // SL_LOGD("nbBuffers in ABQ = %lu, buffSize=%lu",abq->mState.count, buffSize); 133 assert(mAndroidBufferQueue->mFront != mAndroidBufferQueue->mRear); 134 135 oldFront = mAndroidBufferQueue->mFront; 136 AdvancedBufferHeader *newFront = &oldFront[1]; 137 138 // consume events when starting to read data from a buffer for the first time 139 if (oldFront->mDataSizeConsumed == 0) { 140 if (oldFront->mItems.mTsCmdData.mTsCmdCode & ANDROID_MP2TSEVENT_EOS) { 141 receivedCmd_l(IStreamListener::EOS); 142 } else if (oldFront->mItems.mTsCmdData.mTsCmdCode & ANDROID_MP2TSEVENT_DISCONTINUITY) { 143 receivedCmd_l(IStreamListener::DISCONTINUITY); 144 } else if (oldFront->mItems.mTsCmdData.mTsCmdCode & ANDROID_MP2TSEVENT_DISCON_NEWPTS) { 145 sp<AMessage> msg = new AMessage(); 146 msg->setInt64(IStreamListener::kKeyResumeAtPTS, 147 (int64_t)oldFront->mItems.mTsCmdData.mPts); 148 receivedCmd_l(IStreamListener::DISCONTINUITY, msg /*msg*/); 149 } 150 oldFront->mItems.mTsCmdData.mTsCmdCode = ANDROID_MP2TSEVENT_NONE; 151 } 152 153 { 154 // we're going to change the shared mem buffer queue, so lock it 155 Mutex::Autolock _l(mLock); 156 if (!mAvailableBuffers.empty()) { 157 bufferId = *mAvailableBuffers.begin(); 158 CHECK_LT(bufferId, mBuffers.size()); 159 sp<IMemory> mem = mBuffers.itemAt(bufferId); 160 bufferLoc = mem->pointer(); 161 buffSize = mem->size(); 162 163 char *pSrc = ((char*)oldFront->mDataBuffer) + oldFront->mDataSizeConsumed; 164 if (oldFront->mDataSizeConsumed + buffSize < oldFront->mDataSize) { 165 // more available than requested, copy as much as requested 166 // consume data: 1/ copy to given destination 167 memcpy(bufferLoc, pSrc, buffSize); 168 // 2/ keep track of how much has been consumed 169 oldFront->mDataSizeConsumed += buffSize; 170 // 3/ notify shared mem listener that new data is available 171 receivedBuffer_l(bufferId, buffSize); 172 mAvailableBuffers.erase(mAvailableBuffers.begin()); 173 } else { 174 // requested as much available or more: consume the whole of the current 175 // buffer and move to the next 176 size_t consumed = oldFront->mDataSize - oldFront->mDataSizeConsumed; 177 //SL_LOGD("consuming rest of buffer: enqueueing=%ld", consumed); 178 oldFront->mDataSizeConsumed = oldFront->mDataSize; 179 180 // move queue to next 181 if (newFront == &mAndroidBufferQueue-> 182 mBufferArray[mAndroidBufferQueue->mNumBuffers + 1]) { 183 // reached the end, circle back 184 newFront = mAndroidBufferQueue->mBufferArray; 185 } 186 mAndroidBufferQueue->mFront = newFront; 187 mAndroidBufferQueue->mState.count--; 188 mAndroidBufferQueue->mState.index++; 189 190 if (consumed > 0) { 191 // consume data: 1/ copy to given destination 192 memcpy(bufferLoc, pSrc, consumed); 193 // 2/ keep track of how much has been consumed 194 // here nothing to do because we are done with this buffer 195 // 3/ notify StreamPlayer that new data is available 196 receivedBuffer_l(bufferId, consumed); 197 mAvailableBuffers.erase(mAvailableBuffers.begin()); 198 } 199 200 // data has been consumed, and the buffer queue state has been updated 201 // we will notify the client if applicable 202 if (mAndroidBufferQueue->mCallbackEventsMask & 203 SL_ANDROIDBUFFERQUEUEEVENT_PROCESSED) { 204 callback = mAndroidBufferQueue->mCallback; 205 // save callback data 206 callbackPContext = mAndroidBufferQueue->mContext; 207 } 208 } 209 //SL_LOGD("onBufferAvailable() %d buffers available after enqueue", 210 // mAvailableBuffers.size()); 211 } 212 } 213 214 215 } else { // empty queue 216 SL_LOGD("ABQ empty, starving!"); 217 // signal we're at the end of the content, but don't pause (see note in function) 218 if (mUserIsAudioPlayer) { 219 // FIXME declare this external 220 //audioPlayer_dispatch_headAtEnd_lockPlay((CAudioPlayer*)user, 221 // false /*set state to paused?*/, false); 222 } else { 223 // FIXME implement headAtEnd dispatch for CMediaPlayer 224 } 225 } 226 227 interface_unlock_exclusive(mAndroidBufferQueue); 228 229 // notify client 230 if (NULL != callback) { 231 (*callback)(&mAndroidBufferQueue->mItf, callbackPContext, 232 // oldFront was only initialized in the code path where callback is initialized 233 // so no need to check if it's valid 234 (void *)oldFront->mBufferContext, /* pBufferContext */ 235 (void *)oldFront->mDataBuffer,/* pBufferData */ 236 oldFront->mDataSize, /* dataSize */ 237 // here a buffer is only dequeued when fully consumed 238 oldFront->mDataSize, /* dataUsed */ 239 // no messages during playback other than marking the buffer as processed 240 (SLAndroidBufferItem*)(&kItemProcessed) /* pItems */, 241 3*sizeof(SLuint32) /* itemsLength */ ); 242 } 243} 244 245 246//-------------------------------------------------------------------------------------------------- 247StreamPlayer::StreamPlayer(AudioPlayback_Parameters* params, bool hasVideo) : 248 GenericMediaPlayer(params, hasVideo), 249 mAppProxy(0) 250{ 251 SL_LOGD("StreamPlayer::StreamPlayer()"); 252 253 mPlaybackParams = *params; 254 255} 256 257StreamPlayer::~StreamPlayer() { 258 SL_LOGD("StreamPlayer::~StreamPlayer()"); 259 260 mAppProxy.clear(); 261} 262 263 264void StreamPlayer::onMessageReceived(const sp<AMessage> &msg) { 265 switch (msg->what()) { 266 case kWhatQueueRefilled: 267 onQueueRefilled(); 268 break; 269 270 default: 271 GenericMediaPlayer::onMessageReceived(msg); 272 break; 273 } 274} 275 276 277void StreamPlayer::registerQueueCallback( 278 const void* user, bool userIsAudioPlayer, 279 void *context, 280 const void *caller) { 281 SL_LOGD("StreamPlayer::registerQueueCallback"); 282 Mutex::Autolock _l(mAppProxyLock); 283 284 mAppProxy = new StreamSourceAppProxy( 285 user, userIsAudioPlayer, 286 context, caller); 287 288 CHECK(mAppProxy != 0); 289 SL_LOGD("StreamPlayer::registerQueueCallback end"); 290} 291 292 293/** 294 * Called with a lock on ABQ 295 */ 296void StreamPlayer::queueRefilled_l() { 297 // async notification that the ABQ was refilled 298 (new AMessage(kWhatQueueRefilled, id()))->post(); 299} 300 301 302void StreamPlayer::appClear_l() { 303 // the user of StreamPlayer has cleared its AndroidBufferQueue: 304 // there's no clear() for the shared memory queue, so this is a no-op 305} 306 307 308//-------------------------------------------------- 309// Event handlers 310void StreamPlayer::onPrepare() { 311 SL_LOGD("StreamPlayer::onPrepare()"); 312 Mutex::Autolock _l(mAppProxyLock); 313 if (mAppProxy != 0) { 314 mPlayer = mMediaPlayerService->create(getpid(), mPlayerClient /*IMediaPlayerClient*/, 315 mAppProxy /*IStreamSource*/, mPlaybackParams.sessionId); 316 // blocks until mPlayer is prepared 317 GenericMediaPlayer::onPrepare(); 318 SL_LOGD("StreamPlayer::onPrepare() done"); 319 } else { 320 SL_LOGE("Nothing to do here because there is no registered callback"); 321 } 322} 323 324 325void StreamPlayer::onQueueRefilled() { 326 //SL_LOGD("StreamPlayer::onQueueRefilled()"); 327 Mutex::Autolock _l(mAppProxyLock); 328 if (mAppProxy != 0) { 329 mAppProxy->pullFromBuffQueue(); 330 } 331} 332 333} // namespace android 334