MediaPlayer_to_android.cpp revision 01e4a8ff63523bba5c8f919a72e0adb66daf4b98
17d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt/* 27d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt * Copyright (C) 2010 The Android Open Source Project 37d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt * 47d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt * Licensed under the Apache License, Version 2.0 (the "License"); 57d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt * you may not use this file except in compliance with the License. 67d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt * You may obtain a copy of the License at 77d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt * 87d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt * http://www.apache.org/licenses/LICENSE-2.0 97d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt * 107d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt * Unless required by applicable law or agreed to in writing, software 117d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt * distributed under the License is distributed on an "AS IS" BASIS, 127d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 137d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt * See the License for the specific language governing permissions and 147d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt * limitations under the License. 157d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt */ 167d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt 177d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt#include <system/window.h> 187d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt#include <utils/StrongPointer.h> 197d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt#include <gui/Surface.h> 207d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt 217d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt#include "sles_allinclusive.h" 227d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt#include "android_prompts.h" 237d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt// LocAVPlayer and StreamPlayer derive from GenericMediaPlayer, 247d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt// so no need to #include "android_GenericMediaPlayer.h" 25df883eb1575a740bf91e01cbe2eaa4dbc1f9f154Chad Versace#include "android_LocAVPlayer.h" 267d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt#include "android_StreamPlayer.h" 277d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt 287d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt//----------------------------------------------------------------------------- 297d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholtstatic void player_handleMediaPlayerEventNotifications(int event, int data1, int data2, void* user) 307d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt{ 317d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt 32d72edc4dddb6dd7908ef0d3f2cec353b028bf6c5Eric Anholt // FIXME This code is derived from similar code in sfplayer_handlePrefetchEvent. The two 337d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt // versions are quite similar, but still different enough that they need to be separate. 347d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt // At some point they should be re-factored and merged if feasible. 353bd7e70bf7c4a9a52b425284c9f23689f00de93cEric Anholt // As with other OpenMAX AL implementation code, this copy mostly uses SL_ symbols 363bd7e70bf7c4a9a52b425284c9f23689f00de93cEric Anholt // rather than XA_ unless the difference is significant. 377d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt 387d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt if (NULL == user) { 397d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt return; 407d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt } 417d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt 427d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt CMediaPlayer* mp = (CMediaPlayer*) user; 437d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt if (!android::CallbackProtector::enterCbIfOk(mp->mCallbackProtector)) { 447d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt // it is not safe to enter the callback (the media player is about to go away) 451d5d67f8adac9f94715de9804adb536d9a7ec5eeIan Romanick return; 467d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt } 47d72edc4dddb6dd7908ef0d3f2cec353b028bf6c5Eric Anholt union { 487d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt char c[sizeof(int)]; 497d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt int i; 50b5a7cf93442c2def485dcfd05df46abcd78b5d21Ian Romanick } u; 517d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt u.i = event; 527d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt SL_LOGV("player_handleMediaPlayerEventNotifications(event='%c%c%c%c' (%d), data1=%d, data2=%d, " 53e3b520049675f78065eccbc25c001ea77861c129Kenneth Graunke "user=%p) from AVPlayer", u.c[3], u.c[2], u.c[1], u.c[0], event, data1, data2, user); 547d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt switch(event) { 55b5a7cf93442c2def485dcfd05df46abcd78b5d21Ian Romanick 56b5a7cf93442c2def485dcfd05df46abcd78b5d21Ian Romanick case android::GenericPlayer::kEventPrepared: { 57b5a7cf93442c2def485dcfd05df46abcd78b5d21Ian Romanick SL_LOGV("Received GenericPlayer::kEventPrepared for CMediaPlayer %p", mp); 58b5a7cf93442c2def485dcfd05df46abcd78b5d21Ian Romanick 59b5a7cf93442c2def485dcfd05df46abcd78b5d21Ian Romanick // assume no callback 60b5a7cf93442c2def485dcfd05df46abcd78b5d21Ian Romanick slPrefetchCallback callback = NULL; 61b5a7cf93442c2def485dcfd05df46abcd78b5d21Ian Romanick void* callbackPContext; 62b5a7cf93442c2def485dcfd05df46abcd78b5d21Ian Romanick XAuint32 events; 63b5a7cf93442c2def485dcfd05df46abcd78b5d21Ian Romanick 64b5a7cf93442c2def485dcfd05df46abcd78b5d21Ian Romanick object_lock_exclusive(&mp->mObject); 653bd7e70bf7c4a9a52b425284c9f23689f00de93cEric Anholt 663bd7e70bf7c4a9a52b425284c9f23689f00de93cEric Anholt // mark object as prepared; same state is used for successful or unsuccessful prepare 679f9386d22aca8d14d1b1e6d4de9b24dcb183ca10Brian Paul assert(mp->mAndroidObjState == ANDROID_PREPARING); 683bd7e70bf7c4a9a52b425284c9f23689f00de93cEric Anholt mp->mAndroidObjState = ANDROID_READY; 693bd7e70bf7c4a9a52b425284c9f23689f00de93cEric Anholt 703bd7e70bf7c4a9a52b425284c9f23689f00de93cEric Anholt if (PLAYER_SUCCESS == data1) { 713bd7e70bf7c4a9a52b425284c9f23689f00de93cEric Anholt // Most of successful prepare completion for mp->mAVPlayer 72b5a7cf93442c2def485dcfd05df46abcd78b5d21Ian Romanick // is handled by GenericPlayer and its subclasses. 73b5a7cf93442c2def485dcfd05df46abcd78b5d21Ian Romanick } else { 747d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt // AVPlayer prepare() failed prefetching, there is no event in XAPrefetchStatus to 757d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt // indicate a prefetch error, so we signal it by sending simultaneously two events: 767d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt // - SL_PREFETCHEVENT_FILLLEVELCHANGE with a level of 0 777d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt // - SL_PREFETCHEVENT_STATUSCHANGE with a status of SL_PREFETCHSTATUS_UNDERFLOW 787d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt SL_LOGE(ERROR_PLAYER_PREFETCH_d, data1); 797d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt if (IsInterfaceInitialized(&mp->mObject, MPH_XAPREFETCHSTATUS)) { 80046bef235744e891e4a48076e1a3ff9a61a63092Eric Anholt mp->mPrefetchStatus.mLevel = 0; 81d884f60861f270cdcf7d9d47765efcf1e1de30b6Kenneth Graunke mp->mPrefetchStatus.mStatus = SL_PREFETCHSTATUS_UNDERFLOW; 827d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt if (!(~mp->mPrefetchStatus.mCallbackEventsMask & 837d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt (SL_PREFETCHEVENT_FILLLEVELCHANGE | SL_PREFETCHEVENT_STATUSCHANGE))) { 843bd7e70bf7c4a9a52b425284c9f23689f00de93cEric Anholt callback = mp->mPrefetchStatus.mCallback; 853bd7e70bf7c4a9a52b425284c9f23689f00de93cEric Anholt callbackPContext = mp->mPrefetchStatus.mContext; 863bd7e70bf7c4a9a52b425284c9f23689f00de93cEric Anholt events = SL_PREFETCHEVENT_FILLLEVELCHANGE | SL_PREFETCHEVENT_STATUSCHANGE; 879f9386d22aca8d14d1b1e6d4de9b24dcb183ca10Brian Paul } 883bd7e70bf7c4a9a52b425284c9f23689f00de93cEric Anholt } 897d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt } 907d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt 917d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt object_unlock_exclusive(&mp->mObject); 927d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt 937d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt // callback with no lock held 947de4d8fe11c53e59265b8a4252ab9940ffcc9929Eric Anholt if (NULL != callback) { 957de4d8fe11c53e59265b8a4252ab9940ffcc9929Eric Anholt (*callback)(&mp->mPrefetchStatus.mItf, callbackPContext, events); 961d5d67f8adac9f94715de9804adb536d9a7ec5eeIan Romanick } 971d5d67f8adac9f94715de9804adb536d9a7ec5eeIan Romanick 980cea8a56b627cea297e4213266b57b7a1085dccaEric Anholt break; 990cea8a56b627cea297e4213266b57b7a1085dccaEric Anholt } 1000cea8a56b627cea297e4213266b57b7a1085dccaEric Anholt 1010cea8a56b627cea297e4213266b57b7a1085dccaEric Anholt case android::GenericPlayer::kEventHasVideoSize: { 1027de4d8fe11c53e59265b8a4252ab9940ffcc9929Eric Anholt SL_LOGV("Received AVPlayer::kEventHasVideoSize (%d,%d) for CMediaPlayer %p", 1037de4d8fe11c53e59265b8a4252ab9940ffcc9929Eric Anholt data1, data2, mp); 1040cea8a56b627cea297e4213266b57b7a1085dccaEric Anholt 1050cea8a56b627cea297e4213266b57b7a1085dccaEric Anholt object_lock_exclusive(&mp->mObject); 1060cea8a56b627cea297e4213266b57b7a1085dccaEric Anholt 1077de4d8fe11c53e59265b8a4252ab9940ffcc9929Eric Anholt // remove an existing video info entry (here we only have one video stream) 1087de4d8fe11c53e59265b8a4252ab9940ffcc9929Eric Anholt for(size_t i=0 ; i < mp->mStreamInfo.mStreamInfoTable.size() ; i++) { 1097d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt if (XA_DOMAINTYPE_VIDEO == mp->mStreamInfo.mStreamInfoTable.itemAt(i).domain) { 1107d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt mp->mStreamInfo.mStreamInfoTable.removeAt(i); 1113bd7e70bf7c4a9a52b425284c9f23689f00de93cEric Anholt break; 1123bd7e70bf7c4a9a52b425284c9f23689f00de93cEric Anholt } 1133bd7e70bf7c4a9a52b425284c9f23689f00de93cEric Anholt } 1149f9386d22aca8d14d1b1e6d4de9b24dcb183ca10Brian Paul // update the stream information with a new video info entry 1153bd7e70bf7c4a9a52b425284c9f23689f00de93cEric Anholt StreamInfo streamInfo; 1167d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt streamInfo.domain = XA_DOMAINTYPE_VIDEO; 1177d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt streamInfo.videoInfo.codecId = 0;// unknown, we don't have that info FIXME 11866d4c65ee2c311ea0c71c39a28456d0c11798d6bEric Anholt streamInfo.videoInfo.width = (XAuint32)data1; 1197d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt streamInfo.videoInfo.height = (XAuint32)data2; 1207d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt streamInfo.videoInfo.bitRate = 0;// unknown, we don't have that info FIXME 1217d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt streamInfo.videoInfo.frameRate = 0; 1227d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt streamInfo.videoInfo.duration = XA_TIME_UNKNOWN; 1237d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt StreamInfo &contInfo = mp->mStreamInfo.mStreamInfoTable.editItemAt(0); 1247d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt contInfo.containerInfo.numStreams = 1; 1257d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt ssize_t index = mp->mStreamInfo.mStreamInfoTable.add(streamInfo); 1267d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt 1277d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt // callback is unconditional; there is no bitmask of enabled events 1287d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt xaStreamEventChangeCallback callback = mp->mStreamInfo.mCallback; 1297d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt void* callbackPContext = mp->mStreamInfo.mContext; 13066d4c65ee2c311ea0c71c39a28456d0c11798d6bEric Anholt 1317d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt object_unlock_exclusive(&mp->mObject); 1327d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt 1337d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt // enqueue notification (outside of lock) that the stream information has been updated 1347d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt if ((NULL != callback) && (index >= 0)) { 1357d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt#ifndef USE_ASYNCHRONOUS_STREAMCBEVENT_PROPERTYCHANGE_CALLBACK 1366202cbfe3614141e330501959a7322522b35f4e4Kenneth Graunke (*callback)(&mp->mStreamInfo.mItf, XA_STREAMCBEVENT_PROPERTYCHANGE /*eventId*/, 1376202cbfe3614141e330501959a7322522b35f4e4Kenneth Graunke 1 /*streamIndex, only one stream supported here, 0 is reserved*/, 1386202cbfe3614141e330501959a7322522b35f4e4Kenneth Graunke NULL /*pEventData, always NULL in OpenMAX AL 1.0.1*/, 1396202cbfe3614141e330501959a7322522b35f4e4Kenneth Graunke callbackPContext /*pContext*/); 1406202cbfe3614141e330501959a7322522b35f4e4Kenneth Graunke#else 1411d5d67f8adac9f94715de9804adb536d9a7ec5eeIan Romanick SLresult res = EnqueueAsyncCallback_piipp(mp, callback, 1421d5d67f8adac9f94715de9804adb536d9a7ec5eeIan Romanick /*p1*/ &mp->mStreamInfo.mItf, 1431d5d67f8adac9f94715de9804adb536d9a7ec5eeIan Romanick /*i1*/ XA_STREAMCBEVENT_PROPERTYCHANGE /*eventId*/, 1441d5d67f8adac9f94715de9804adb536d9a7ec5eeIan Romanick /*i2*/ 1 /*streamIndex, only one stream supported here, 0 is reserved*/, 1451d5d67f8adac9f94715de9804adb536d9a7ec5eeIan Romanick /*p2*/ NULL /*pEventData, always NULL in OpenMAX AL 1.0.1*/, 1461d5d67f8adac9f94715de9804adb536d9a7ec5eeIan Romanick /*p3*/ callbackPContext /*pContext*/); 1476202cbfe3614141e330501959a7322522b35f4e4Kenneth Graunke ALOGW_IF(SL_RESULT_SUCCESS != res, 1486202cbfe3614141e330501959a7322522b35f4e4Kenneth Graunke "Callback %p(%p, XA_STREAMCBEVENT_PROPERTYCHANGE, 1, NULL, %p) dropped", 1497d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt callback, &mp->mStreamInfo.mItf, callbackPContext); 1507d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt#endif 1517d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt } 1527d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt break; 1537d21104a8b92c139051e9a224c5d863802a8ade6Eric Anholt } 154 155 case android::GenericPlayer::kEventEndOfStream: { 156 SL_LOGV("Received AVPlayer::kEventEndOfStream for CMediaPlayer %p", mp); 157 158 object_lock_exclusive(&mp->mObject); 159 // should be xaPlayCallback but we're sharing the itf between SL and AL 160 slPlayCallback playCallback = NULL; 161 void * playContext = NULL; 162 // XAPlayItf callback or no callback? 163 if (mp->mPlay.mEventFlags & XA_PLAYEVENT_HEADATEND) { 164 playCallback = mp->mPlay.mCallback; 165 playContext = mp->mPlay.mContext; 166 } 167 mp->mPlay.mState = XA_PLAYSTATE_PAUSED; 168 object_unlock_exclusive(&mp->mObject); 169 170 // enqueue callback with no lock held 171 if (NULL != playCallback) { 172#ifndef USE_ASYNCHRONOUS_PLAY_CALLBACK 173 (*playCallback)(&mp->mPlay.mItf, playContext, XA_PLAYEVENT_HEADATEND); 174#else 175 SLresult res = EnqueueAsyncCallback_ppi(mp, playCallback, &mp->mPlay.mItf, playContext, 176 XA_PLAYEVENT_HEADATEND); 177 ALOGW_IF(SL_RESULT_SUCCESS != res, 178 "Callback %p(%p, %p, SL_PLAYEVENT_HEADATEND) dropped", playCallback, 179 &mp->mPlay.mItf, playContext); 180#endif 181 } 182 break; 183 } 184 185 case android::GenericPlayer::kEventChannelCount: { 186 SL_LOGV("kEventChannelCount channels = %d", data1); 187 object_lock_exclusive(&mp->mObject); 188 if (UNKNOWN_NUMCHANNELS == mp->mNumChannels && UNKNOWN_NUMCHANNELS != data1) { 189 mp->mNumChannels = data1; 190 android_Player_volumeUpdate(mp); 191 } 192 object_unlock_exclusive(&mp->mObject); 193 } 194 break; 195 196 case android::GenericPlayer::kEventPrefetchFillLevelUpdate: { 197 SL_LOGV("kEventPrefetchFillLevelUpdate"); 198 if (!IsInterfaceInitialized(&mp->mObject, MPH_XAPREFETCHSTATUS)) { 199 break; 200 } 201 slPrefetchCallback callback = NULL; 202 void* callbackPContext = NULL; 203 204 // SLPrefetchStatusItf callback or no callback? 205 interface_lock_exclusive(&mp->mPrefetchStatus); 206 if (mp->mPrefetchStatus.mCallbackEventsMask & SL_PREFETCHEVENT_FILLLEVELCHANGE) { 207 callback = mp->mPrefetchStatus.mCallback; 208 callbackPContext = mp->mPrefetchStatus.mContext; 209 } 210 mp->mPrefetchStatus.mLevel = (SLpermille)data1; 211 interface_unlock_exclusive(&mp->mPrefetchStatus); 212 213 // callback with no lock held 214 if (NULL != callback) { 215 (*callback)(&mp->mPrefetchStatus.mItf, callbackPContext, 216 SL_PREFETCHEVENT_FILLLEVELCHANGE); 217 } 218 } 219 break; 220 221 case android::GenericPlayer::kEventPrefetchStatusChange: { 222 SL_LOGV("kEventPrefetchStatusChange"); 223 if (!IsInterfaceInitialized(&mp->mObject, MPH_XAPREFETCHSTATUS)) { 224 break; 225 } 226 slPrefetchCallback callback = NULL; 227 void* callbackPContext = NULL; 228 229 // SLPrefetchStatusItf callback or no callback? 230 object_lock_exclusive(&mp->mObject); 231 if (mp->mPrefetchStatus.mCallbackEventsMask & SL_PREFETCHEVENT_STATUSCHANGE) { 232 callback = mp->mPrefetchStatus.mCallback; 233 callbackPContext = mp->mPrefetchStatus.mContext; 234 } 235 if (data1 >= android::kStatusIntermediate) { 236 mp->mPrefetchStatus.mStatus = SL_PREFETCHSTATUS_SUFFICIENTDATA; 237 } else if (data1 < android::kStatusIntermediate) { 238 mp->mPrefetchStatus.mStatus = SL_PREFETCHSTATUS_UNDERFLOW; 239 } 240 object_unlock_exclusive(&mp->mObject); 241 242 // callback with no lock held 243 if (NULL != callback) { 244 (*callback)(&mp->mPrefetchStatus.mItf, callbackPContext, SL_PREFETCHEVENT_STATUSCHANGE); 245 } 246 } 247 break; 248 249 case android::GenericPlayer::kEventPlay: { 250 SL_LOGV("kEventPlay"); 251 252 interface_lock_shared(&mp->mPlay); 253 slPlayCallback callback = mp->mPlay.mCallback; 254 void* callbackPContext = mp->mPlay.mContext; 255 interface_unlock_shared(&mp->mPlay); 256 257 if (NULL != callback) { 258 (*callback)(&mp->mPlay.mItf, callbackPContext, (SLuint32) data1); // SL_PLAYEVENT_HEAD* 259 } 260 } 261 break; 262 263 case android::GenericPlayer::kEventErrorAfterPrepare: { 264 SL_LOGV("kEventErrorAfterPrepare"); 265 266 // assume no callback 267 slPrefetchCallback callback = NULL; 268 void* callbackPContext = NULL; 269 270 object_lock_exclusive(&mp->mObject); 271 if (IsInterfaceInitialized(&mp->mObject, MPH_XAPREFETCHSTATUS)) { 272 mp->mPrefetchStatus.mLevel = 0; 273 mp->mPrefetchStatus.mStatus = SL_PREFETCHSTATUS_UNDERFLOW; 274 if (!(~mp->mPrefetchStatus.mCallbackEventsMask & 275 (SL_PREFETCHEVENT_FILLLEVELCHANGE | SL_PREFETCHEVENT_STATUSCHANGE))) { 276 callback = mp->mPrefetchStatus.mCallback; 277 callbackPContext = mp->mPrefetchStatus.mContext; 278 } 279 } 280 object_unlock_exclusive(&mp->mObject); 281 282 // FIXME there's interesting information in data1, but no API to convey it to client 283 SL_LOGE("Error after prepare: %d", data1); 284 285 // callback with no lock held 286 if (NULL != callback) { 287 (*callback)(&mp->mPrefetchStatus.mItf, callbackPContext, 288 SL_PREFETCHEVENT_FILLLEVELCHANGE | SL_PREFETCHEVENT_STATUSCHANGE); 289 } 290 291 } 292 break; 293 294 default: { 295 SL_LOGE("Received unknown event %d, data %d from AVPlayer", event, data1); 296 } 297 } 298 299 mp->mCallbackProtector->exitCb(); 300} 301 302 303//----------------------------------------------------------------------------- 304XAresult android_Player_checkSourceSink(CMediaPlayer *mp) { 305 306 XAresult result = XA_RESULT_SUCCESS; 307 308 const SLDataSource *pSrc = &mp->mDataSource.u.mSource; 309 const SLDataSink *pAudioSnk = &mp->mAudioSink.u.mSink; 310 311 // format check: 312 const SLuint32 sourceLocatorType = *(SLuint32 *)pSrc->pLocator; 313 const SLuint32 sourceFormatType = *(SLuint32 *)pSrc->pFormat; 314 const SLuint32 audioSinkLocatorType = *(SLuint32 *)pAudioSnk->pLocator; 315 //const SLuint32 sinkFormatType = *(SLuint32 *)pAudioSnk->pFormat; 316 317 // Source check 318 switch(sourceLocatorType) { 319 320 case XA_DATALOCATOR_ANDROIDBUFFERQUEUE: { 321 switch (sourceFormatType) { 322 case XA_DATAFORMAT_MIME: { 323 SLDataFormat_MIME *df_mime = (SLDataFormat_MIME *) pSrc->pFormat; 324 if (SL_CONTAINERTYPE_MPEG_TS != df_mime->containerType) { 325 SL_LOGE("Cannot create player with XA_DATALOCATOR_ANDROIDBUFFERQUEUE data source " 326 "that is not fed MPEG-2 TS data"); 327 return SL_RESULT_CONTENT_UNSUPPORTED; 328 } 329 } break; 330 default: 331 SL_LOGE("Cannot create player with XA_DATALOCATOR_ANDROIDBUFFERQUEUE data source " 332 "without SL_DATAFORMAT_MIME format"); 333 return XA_RESULT_CONTENT_UNSUPPORTED; 334 } 335 } break; 336 337 case XA_DATALOCATOR_URI: // intended fall-through 338 case XA_DATALOCATOR_ANDROIDFD: 339 break; 340 341 default: 342 SL_LOGE("Cannot create media player with data locator type 0x%x", 343 (unsigned) sourceLocatorType); 344 return SL_RESULT_PARAMETER_INVALID; 345 }// switch (locatorType) 346 347 // Audio sink check: only playback is supported here 348 switch(audioSinkLocatorType) { 349 350 case XA_DATALOCATOR_OUTPUTMIX: 351 break; 352 353 default: 354 SL_LOGE("Cannot create media player with audio sink data locator of type 0x%x", 355 (unsigned) audioSinkLocatorType); 356 return XA_RESULT_PARAMETER_INVALID; 357 }// switch (locaaudioSinkLocatorTypeorType) 358 359 return result; 360} 361 362 363//----------------------------------------------------------------------------- 364XAresult android_Player_create(CMediaPlayer *mp) { 365 366 XAresult result = XA_RESULT_SUCCESS; 367 368 // FIXME verify data source 369 const SLDataSource *pDataSrc = &mp->mDataSource.u.mSource; 370 // FIXME verify audio data sink 371 const SLDataSink *pAudioSnk = &mp->mAudioSink.u.mSink; 372 // FIXME verify image data sink 373 const SLDataSink *pVideoSnk = &mp->mImageVideoSink.u.mSink; 374 375 XAuint32 sourceLocator = *(XAuint32 *)pDataSrc->pLocator; 376 switch(sourceLocator) { 377 // FIXME support Android simple buffer queue as well 378 case XA_DATALOCATOR_ANDROIDBUFFERQUEUE: 379 mp->mAndroidObjType = AUDIOVIDEOPLAYER_FROM_TS_ANDROIDBUFFERQUEUE; 380 break; 381 case XA_DATALOCATOR_URI: // intended fall-through 382 case SL_DATALOCATOR_ANDROIDFD: 383 mp->mAndroidObjType = AUDIOVIDEOPLAYER_FROM_URIFD; 384 break; 385 case XA_DATALOCATOR_ADDRESS: // intended fall-through 386 default: 387 mp->mAndroidObjType = INVALID_TYPE; 388 SL_LOGE("Unable to create MediaPlayer for data source locator 0x%x", sourceLocator); 389 result = XA_RESULT_PARAMETER_INVALID; 390 break; 391 } 392 393 // FIXME duplicates an initialization also done by higher level 394 mp->mAndroidObjState = ANDROID_UNINITIALIZED; 395 mp->mStreamType = ANDROID_DEFAULT_OUTPUT_STREAM_TYPE; 396 mp->mSessionId = android::AudioSystem::newAudioSessionId(); 397 398 // placeholder: not necessary yet as session ID lifetime doesn't extend beyond player 399 // android::AudioSystem::acquireAudioSessionId(mp->mSessionId); 400 401 mp->mCallbackProtector = new android::CallbackProtector(); 402 403 return result; 404} 405 406 407//----------------------------------------------------------------------------- 408// FIXME abstract out the diff between CMediaPlayer and CAudioPlayer 409XAresult android_Player_realize(CMediaPlayer *mp, SLboolean async) { 410 SL_LOGV("android_Player_realize_l(%p)", mp); 411 XAresult result = XA_RESULT_SUCCESS; 412 413 const SLDataSource *pDataSrc = &mp->mDataSource.u.mSource; 414 const SLuint32 sourceLocator = *(SLuint32 *)pDataSrc->pLocator; 415 416 AudioPlayback_Parameters ap_params; 417 ap_params.sessionId = mp->mSessionId; 418 ap_params.streamType = mp->mStreamType; 419 420 switch(mp->mAndroidObjType) { 421 case AUDIOVIDEOPLAYER_FROM_TS_ANDROIDBUFFERQUEUE: { 422 mp->mAVPlayer = new android::StreamPlayer(&ap_params, true /*hasVideo*/, 423 &mp->mAndroidBufferQueue, mp->mCallbackProtector); 424 mp->mAVPlayer->init(player_handleMediaPlayerEventNotifications, (void*)mp); 425 } 426 break; 427 case AUDIOVIDEOPLAYER_FROM_URIFD: { 428 mp->mAVPlayer = new android::LocAVPlayer(&ap_params, true /*hasVideo*/); 429 mp->mAVPlayer->init(player_handleMediaPlayerEventNotifications, (void*)mp); 430 switch (mp->mDataSource.mLocator.mLocatorType) { 431 case XA_DATALOCATOR_URI: 432 ((android::LocAVPlayer*)mp->mAVPlayer.get())->setDataSource( 433 (const char*)mp->mDataSource.mLocator.mURI.URI); 434 break; 435 case XA_DATALOCATOR_ANDROIDFD: { 436 int64_t offset = (int64_t)mp->mDataSource.mLocator.mFD.offset; 437 ((android::LocAVPlayer*)mp->mAVPlayer.get())->setDataSource( 438 (int)mp->mDataSource.mLocator.mFD.fd, 439 offset == SL_DATALOCATOR_ANDROIDFD_USE_FILE_SIZE ? 440 (int64_t)PLAYER_FD_FIND_FILE_SIZE : offset, 441 (int64_t)mp->mDataSource.mLocator.mFD.length); 442 } 443 break; 444 default: 445 SL_LOGE("Invalid or unsupported data locator type %u for data source", 446 mp->mDataSource.mLocator.mLocatorType); 447 result = XA_RESULT_PARAMETER_INVALID; 448 } 449 } 450 break; 451 case INVALID_TYPE: // intended fall-through 452 default: 453 SL_LOGE("Unable to realize MediaPlayer, invalid internal Android object type"); 454 result = XA_RESULT_PARAMETER_INVALID; 455 break; 456 } 457 458 if (XA_RESULT_SUCCESS == result) { 459 460 // if there is a video sink 461 if (XA_DATALOCATOR_NATIVEDISPLAY == 462 mp->mImageVideoSink.mLocator.mLocatorType) { 463 ANativeWindow *nativeWindow = (ANativeWindow *) 464 mp->mImageVideoSink.mLocator.mNativeDisplay.hWindow; 465 // we already verified earlier that hWindow is non-NULL 466 assert(nativeWindow != NULL); 467 result = android_Player_setNativeWindow(mp, nativeWindow); 468 } 469 470 } 471 472 return result; 473} 474 475// Called with a lock on MediaPlayer, and blocks until safe to destroy 476XAresult android_Player_preDestroy(CMediaPlayer *mp) { 477 SL_LOGV("android_Player_preDestroy(%p)", mp); 478 479 // Not yet clear why this order is important, but it reduces detected deadlocks 480 object_unlock_exclusive(&mp->mObject); 481 if (mp->mCallbackProtector != 0) { 482 mp->mCallbackProtector->requestCbExitAndWait(); 483 } 484 object_lock_exclusive(&mp->mObject); 485 486 if (mp->mAVPlayer != 0) { 487 mp->mAVPlayer->preDestroy(); 488 } 489 SL_LOGV("android_Player_preDestroy(%p) after mAVPlayer->preDestroy()", mp); 490 491 return XA_RESULT_SUCCESS; 492} 493 494//----------------------------------------------------------------------------- 495XAresult android_Player_destroy(CMediaPlayer *mp) { 496 SL_LOGV("android_Player_destroy(%p)", mp); 497 498 mp->mAVPlayer.clear(); 499 500 // placeholder: not necessary yet as session ID lifetime doesn't extend beyond player 501 // android::AudioSystem::releaseAudioSessionId(mp->mSessionId); 502 503 mp->mCallbackProtector.clear(); 504 505 // explicit destructor 506 mp->mAVPlayer.~sp(); 507 mp->mCallbackProtector.~sp(); 508 509 return XA_RESULT_SUCCESS; 510} 511 512 513void android_Player_usePlayEventMask(CMediaPlayer *mp) { 514 if (mp->mAVPlayer != 0) { 515 IPlay *pPlayItf = &mp->mPlay; 516 mp->mAVPlayer->setPlayEvents((int32_t) pPlayItf->mEventFlags, 517 (int32_t) pPlayItf->mMarkerPosition, (int32_t) pPlayItf->mPositionUpdatePeriod); 518 } 519} 520 521 522XAresult android_Player_getDuration(IPlay *pPlayItf, XAmillisecond *pDurMsec) { 523 CMediaPlayer *avp = (CMediaPlayer *)pPlayItf->mThis; 524 525 switch (avp->mAndroidObjType) { 526 527 case AUDIOVIDEOPLAYER_FROM_URIFD: { 528 int dur = ANDROID_UNKNOWN_TIME; 529 if (avp->mAVPlayer != 0) { 530 avp->mAVPlayer->getDurationMsec(&dur); 531 } 532 if (dur == ANDROID_UNKNOWN_TIME) { 533 *pDurMsec = XA_TIME_UNKNOWN; 534 } else { 535 *pDurMsec = (XAmillisecond)dur; 536 } 537 } break; 538 539 case AUDIOVIDEOPLAYER_FROM_TS_ANDROIDBUFFERQUEUE: // intended fall-through 540 default: 541 *pDurMsec = XA_TIME_UNKNOWN; 542 break; 543 } 544 545 return XA_RESULT_SUCCESS; 546} 547 548 549XAresult android_Player_getPosition(IPlay *pPlayItf, XAmillisecond *pPosMsec) { 550 SL_LOGD("android_Player_getPosition()"); 551 XAresult result = XA_RESULT_SUCCESS; 552 CMediaPlayer *avp = (CMediaPlayer *)pPlayItf->mThis; 553 554 switch (avp->mAndroidObjType) { 555 556 case AUDIOVIDEOPLAYER_FROM_TS_ANDROIDBUFFERQUEUE: // intended fall-through 557 case AUDIOVIDEOPLAYER_FROM_URIFD: { 558 int pos = ANDROID_UNKNOWN_TIME; 559 if (avp->mAVPlayer != 0) { 560 avp->mAVPlayer->getPositionMsec(&pos); 561 } 562 if (pos == ANDROID_UNKNOWN_TIME) { 563 *pPosMsec = 0; 564 } else { 565 *pPosMsec = (XAmillisecond)pos; 566 } 567 } break; 568 569 default: 570 // we shouldn't be here 571 assert(false); 572 break; 573 } 574 575 return result; 576} 577 578 579//----------------------------------------------------------------------------- 580/** 581 * pre-condition: mp != NULL 582 */ 583void android_Player_volumeUpdate(CMediaPlayer* mp) 584{ 585 android::GenericPlayer* avp = mp->mAVPlayer.get(); 586 if (avp != NULL) { 587 float volumes[2]; 588 // MediaPlayer does not currently support EffectSend or MuteSolo 589 android_player_volumeUpdate(volumes, &mp->mVolume, mp->mNumChannels, 1.0f, NULL); 590 float leftVol = volumes[0], rightVol = volumes[1]; 591 avp->setVolume(leftVol, rightVol); 592 } 593} 594 595//----------------------------------------------------------------------------- 596/** 597 * pre-condition: gp != 0 598 */ 599XAresult android_Player_setPlayState(const android::sp<android::GenericPlayer> &gp, 600 SLuint32 playState, 601 AndroidObjectState* pObjState) 602{ 603 XAresult result = XA_RESULT_SUCCESS; 604 AndroidObjectState objState = *pObjState; 605 606 switch (playState) { 607 case SL_PLAYSTATE_STOPPED: { 608 SL_LOGV("setting AVPlayer to SL_PLAYSTATE_STOPPED"); 609 gp->stop(); 610 } 611 break; 612 case SL_PLAYSTATE_PAUSED: { 613 SL_LOGV("setting AVPlayer to SL_PLAYSTATE_PAUSED"); 614 switch(objState) { 615 case ANDROID_UNINITIALIZED: 616 *pObjState = ANDROID_PREPARING; 617 gp->prepare(); 618 break; 619 case ANDROID_PREPARING: 620 break; 621 case ANDROID_READY: 622 gp->pause(); 623 break; 624 default: 625 SL_LOGE("Android object in invalid state"); 626 break; 627 } 628 } 629 break; 630 case SL_PLAYSTATE_PLAYING: { 631 SL_LOGV("setting AVPlayer to SL_PLAYSTATE_PLAYING"); 632 switch(objState) { 633 case ANDROID_UNINITIALIZED: 634 *pObjState = ANDROID_PREPARING; 635 gp->prepare(); 636 // intended fall through 637 case ANDROID_PREPARING: 638 // intended fall through 639 case ANDROID_READY: 640 gp->play(); 641 break; 642 default: 643 SL_LOGE("Android object in invalid state"); 644 break; 645 } 646 } 647 break; 648 default: 649 // checked by caller, should not happen 650 break; 651 } 652 653 return result; 654} 655 656 657/** 658 * pre-condition: mp != NULL 659 */ 660XAresult android_Player_seek(CMediaPlayer *mp, SLmillisecond posMsec) { 661 XAresult result = XA_RESULT_SUCCESS; 662 switch (mp->mAndroidObjType) { 663 case AUDIOVIDEOPLAYER_FROM_URIFD: 664 if (mp->mAVPlayer !=0) { 665 mp->mAVPlayer->seek(posMsec); 666 } 667 break; 668 case AUDIOVIDEOPLAYER_FROM_TS_ANDROIDBUFFERQUEUE: // intended fall-through 669 default: { 670 result = XA_RESULT_FEATURE_UNSUPPORTED; 671 } 672 } 673 return result; 674} 675 676 677/** 678 * pre-condition: mp != NULL 679 */ 680XAresult android_Player_loop(CMediaPlayer *mp, SLboolean loopEnable) { 681 XAresult result = XA_RESULT_SUCCESS; 682 switch (mp->mAndroidObjType) { 683 case AUDIOVIDEOPLAYER_FROM_URIFD: 684 if (mp->mAVPlayer !=0) { 685 mp->mAVPlayer->loop(loopEnable); 686 } 687 break; 688 case AUDIOVIDEOPLAYER_FROM_TS_ANDROIDBUFFERQUEUE: // intended fall-through 689 default: { 690 result = XA_RESULT_FEATURE_UNSUPPORTED; 691 } 692 } 693 return result; 694} 695 696 697//----------------------------------------------------------------------------- 698void android_Player_androidBufferQueue_clear_l(CMediaPlayer *mp) { 699 if ((mp->mAndroidObjType == AUDIOVIDEOPLAYER_FROM_TS_ANDROIDBUFFERQUEUE) 700 && (mp->mAVPlayer != 0)) { 701 android::StreamPlayer* splr = static_cast<android::StreamPlayer*>(mp->mAVPlayer.get()); 702 splr->appClear_l(); 703 } 704} 705 706 707void android_Player_androidBufferQueue_onRefilled_l(CMediaPlayer *mp) { 708 if ((mp->mAndroidObjType == AUDIOVIDEOPLAYER_FROM_TS_ANDROIDBUFFERQUEUE) 709 && (mp->mAVPlayer != 0)) { 710 android::StreamPlayer* splr = static_cast<android::StreamPlayer*>(mp->mAVPlayer.get()); 711 splr->queueRefilled(); 712 } 713} 714 715 716/* 717 * pre-conditions: 718 * mp != NULL 719 * mp->mAVPlayer != 0 (player is realized) 720 * nativeWindow can be NULL, but if NULL it is treated as an error 721 */ 722SLresult android_Player_setNativeWindow(CMediaPlayer *mp, ANativeWindow *nativeWindow) 723{ 724 assert(mp != NULL); 725 assert(mp->mAVPlayer != 0); 726 if (nativeWindow == NULL) { 727 SL_LOGE("ANativeWindow is NULL"); 728 return SL_RESULT_PARAMETER_INVALID; 729 } 730 SLresult result; 731 int err; 732 int value; 733 // this could crash if app passes in a bad parameter, but that's OK 734 err = (*nativeWindow->query)(nativeWindow, NATIVE_WINDOW_CONCRETE_TYPE, &value); 735 if (0 != err) { 736 SL_LOGE("Query NATIVE_WINDOW_CONCRETE_TYPE on ANativeWindow * %p failed; " 737 "errno %d", nativeWindow, err); 738 result = SL_RESULT_PARAMETER_INVALID; 739 } else { 740 switch (value) { 741 case NATIVE_WINDOW_SURFACE: { // Surface 742 SL_LOGV("Displaying on ANativeWindow of type NATIVE_WINDOW_SURFACE"); 743 android::sp<android::Surface> nativeSurface( 744 static_cast<android::Surface *>(nativeWindow)); 745 mp->mAVPlayer->setVideoSurfaceTexture( 746 nativeSurface->getSurfaceTexture()); 747 result = SL_RESULT_SUCCESS; 748 } break; 749 case NATIVE_WINDOW_SURFACE_TEXTURE_CLIENT: { // SurfaceTextureClient 750 SL_LOGV("Displaying on ANativeWindow of type NATIVE_WINDOW_SURFACE_TEXTURE_CLIENT"); 751 android::sp<android::SurfaceTextureClient> surfaceTextureClient( 752 static_cast<android::SurfaceTextureClient *>(nativeWindow)); 753 android::sp<android::ISurfaceTexture> nativeSurfaceTexture( 754 surfaceTextureClient->getISurfaceTexture()); 755 mp->mAVPlayer->setVideoSurfaceTexture(nativeSurfaceTexture); 756 result = SL_RESULT_SUCCESS; 757 } break; 758 case NATIVE_WINDOW_FRAMEBUFFER: // FramebufferNativeWindow 759 // fall through 760 default: 761 SL_LOGE("ANativeWindow * %p has unknown or unsupported concrete type %d", 762 nativeWindow, value); 763 result = SL_RESULT_PARAMETER_INVALID; 764 break; 765 } 766 } 767 return result; 768} 769