mediaplayer.cpp revision 4e92c7efc68b5d7635a32dbd283ab8558ad9bdd6
1/* mediaplayer.cpp 2** 3** Copyright 2006, The Android Open Source Project 4** 5** Licensed under the Apache License, Version 2.0 (the "License"); 6** you may not use this file except in compliance with the License. 7** You may obtain a copy of the License at 8** 9** http://www.apache.org/licenses/LICENSE-2.0 10** 11** Unless required by applicable law or agreed to in writing, software 12** distributed under the License is distributed on an "AS IS" BASIS, 13** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14** See the License for the specific language governing permissions and 15** limitations under the License. 16*/ 17 18//#define LOG_NDEBUG 0 19#define LOG_TAG "MediaPlayer" 20#include <utils/Log.h> 21 22#include <sys/types.h> 23#include <sys/stat.h> 24#include <unistd.h> 25#include <fcntl.h> 26 27#include <binder/IServiceManager.h> 28#include <binder/IPCThreadState.h> 29 30#include <media/mediaplayer.h> 31#include <media/AudioTrack.h> 32 33#include <surfaceflinger/Surface.h> 34 35#include <binder/MemoryBase.h> 36 37#include <utils/KeyedVector.h> 38#include <utils/String8.h> 39 40namespace android { 41 42MediaPlayer::MediaPlayer() 43{ 44 LOGV("constructor"); 45 mListener = NULL; 46 mCookie = NULL; 47 mDuration = -1; 48 mStreamType = AudioSystem::MUSIC; 49 mCurrentPosition = -1; 50 mSeekPosition = -1; 51 mCurrentState = MEDIA_PLAYER_IDLE; 52 mPrepareSync = false; 53 mPrepareStatus = NO_ERROR; 54 mLoop = false; 55 mLeftVolume = mRightVolume = 1.0; 56 mVideoWidth = mVideoHeight = 0; 57 mLockThreadId = 0; 58} 59 60MediaPlayer::~MediaPlayer() 61{ 62 LOGV("destructor"); 63 disconnect(); 64 IPCThreadState::self()->flushCommands(); 65} 66 67void MediaPlayer::disconnect() 68{ 69 LOGV("disconnect"); 70 sp<IMediaPlayer> p; 71 { 72 Mutex::Autolock _l(mLock); 73 p = mPlayer; 74 mPlayer.clear(); 75 } 76 77 if (p != 0) { 78 p->disconnect(); 79 } 80} 81 82// always call with lock held 83void MediaPlayer::clear_l() 84{ 85 mDuration = -1; 86 mCurrentPosition = -1; 87 mSeekPosition = -1; 88 mVideoWidth = mVideoHeight = 0; 89} 90 91status_t MediaPlayer::setListener(const sp<MediaPlayerListener>& listener) 92{ 93 LOGV("setListener"); 94 Mutex::Autolock _l(mLock); 95 mListener = listener; 96 return NO_ERROR; 97} 98 99 100status_t MediaPlayer::setDataSource(const sp<IMediaPlayer>& player) 101{ 102 status_t err = UNKNOWN_ERROR; 103 sp<IMediaPlayer> p; 104 { // scope for the lock 105 Mutex::Autolock _l(mLock); 106 107 if ( !( mCurrentState & ( MEDIA_PLAYER_IDLE | MEDIA_PLAYER_STATE_ERROR ) ) ) { 108 LOGE("setDataSource called in state %d", mCurrentState); 109 return INVALID_OPERATION; 110 } 111 112 clear_l(); 113 p = mPlayer; 114 mPlayer = player; 115 if (player != 0) { 116 mCurrentState = MEDIA_PLAYER_INITIALIZED; 117 err = NO_ERROR; 118 } else { 119 LOGE("Unable to to create media player"); 120 } 121 } 122 123 if (p != 0) { 124 p->disconnect(); 125 } 126 127 return err; 128} 129 130status_t MediaPlayer::setDataSource( 131 const char *url, const KeyedVector<String8, String8> *headers) 132{ 133 LOGV("setDataSource(%s)", url); 134 status_t err = BAD_VALUE; 135 if (url != NULL) { 136 const sp<IMediaPlayerService>& service(getMediaPlayerService()); 137 if (service != 0) { 138 sp<IMediaPlayer> player( 139 service->create(getpid(), this, url, headers)); 140 err = setDataSource(player); 141 } 142 } 143 return err; 144} 145 146status_t MediaPlayer::setDataSource(int fd, int64_t offset, int64_t length) 147{ 148 LOGV("setDataSource(%d, %lld, %lld)", fd, offset, length); 149 status_t err = UNKNOWN_ERROR; 150 const sp<IMediaPlayerService>& service(getMediaPlayerService()); 151 if (service != 0) { 152 sp<IMediaPlayer> player(service->create(getpid(), this, fd, offset, length)); 153 err = setDataSource(player); 154 } 155 return err; 156} 157 158status_t MediaPlayer::invoke(const Parcel& request, Parcel *reply) 159{ 160 Mutex::Autolock _l(mLock); 161 if ((mPlayer != NULL) && ( mCurrentState & MEDIA_PLAYER_INITIALIZED )) 162 { 163 LOGV("invoke %d", request.dataSize()); 164 return mPlayer->invoke(request, reply); 165 } 166 LOGE("invoke failed: wrong state %X", mCurrentState); 167 return INVALID_OPERATION; 168} 169 170status_t MediaPlayer::suspend() { 171 Mutex::Autolock _l(mLock); 172 return mPlayer->suspend(); 173} 174 175status_t MediaPlayer::resume() { 176 Mutex::Autolock _l(mLock); 177 return mPlayer->resume(); 178} 179 180status_t MediaPlayer::setMetadataFilter(const Parcel& filter) 181{ 182 LOGD("setMetadataFilter"); 183 Mutex::Autolock lock(mLock); 184 if (mPlayer == NULL) { 185 return NO_INIT; 186 } 187 return mPlayer->setMetadataFilter(filter); 188} 189 190status_t MediaPlayer::getMetadata(bool update_only, bool apply_filter, Parcel *metadata) 191{ 192 LOGD("getMetadata"); 193 Mutex::Autolock lock(mLock); 194 if (mPlayer == NULL) { 195 return NO_INIT; 196 } 197 return mPlayer->getMetadata(update_only, apply_filter, metadata); 198} 199 200status_t MediaPlayer::setVideoSurface(const sp<Surface>& surface) 201{ 202 LOGV("setVideoSurface"); 203 Mutex::Autolock _l(mLock); 204 if (mPlayer == 0) return NO_INIT; 205 if (surface != NULL) 206 return mPlayer->setVideoSurface(surface->getISurface()); 207 else 208 return mPlayer->setVideoSurface(NULL); 209} 210 211// must call with lock held 212status_t MediaPlayer::prepareAsync_l() 213{ 214 if ( (mPlayer != 0) && ( mCurrentState & ( MEDIA_PLAYER_INITIALIZED | MEDIA_PLAYER_STOPPED) ) ) { 215 mPlayer->setAudioStreamType(mStreamType); 216 mCurrentState = MEDIA_PLAYER_PREPARING; 217 return mPlayer->prepareAsync(); 218 } 219 LOGE("prepareAsync called in state %d", mCurrentState); 220 return INVALID_OPERATION; 221} 222 223// TODO: In case of error, prepareAsync provides the caller with 2 error codes, 224// one defined in the Android framework and one provided by the implementation 225// that generated the error. The sync version of prepare returns only 1 error 226// code. 227status_t MediaPlayer::prepare() 228{ 229 LOGV("prepare"); 230 Mutex::Autolock _l(mLock); 231 mLockThreadId = getThreadId(); 232 if (mPrepareSync) { 233 mLockThreadId = 0; 234 return -EALREADY; 235 } 236 mPrepareSync = true; 237 status_t ret = prepareAsync_l(); 238 if (ret != NO_ERROR) { 239 mLockThreadId = 0; 240 return ret; 241 } 242 243 if (mPrepareSync) { 244 mSignal.wait(mLock); // wait for prepare done 245 mPrepareSync = false; 246 } 247 LOGV("prepare complete - status=%d", mPrepareStatus); 248 mLockThreadId = 0; 249 return mPrepareStatus; 250} 251 252status_t MediaPlayer::prepareAsync() 253{ 254 LOGV("prepareAsync"); 255 Mutex::Autolock _l(mLock); 256 return prepareAsync_l(); 257} 258 259status_t MediaPlayer::start() 260{ 261 LOGV("start"); 262 Mutex::Autolock _l(mLock); 263 if (mCurrentState & MEDIA_PLAYER_STARTED) 264 return NO_ERROR; 265 if ( (mPlayer != 0) && ( mCurrentState & ( MEDIA_PLAYER_PREPARED | 266 MEDIA_PLAYER_PLAYBACK_COMPLETE | MEDIA_PLAYER_PAUSED ) ) ) { 267 mPlayer->setLooping(mLoop); 268 mPlayer->setVolume(mLeftVolume, mRightVolume); 269 mCurrentState = MEDIA_PLAYER_STARTED; 270 status_t ret = mPlayer->start(); 271 if (ret != NO_ERROR) { 272 mCurrentState = MEDIA_PLAYER_STATE_ERROR; 273 } else { 274 if (mCurrentState == MEDIA_PLAYER_PLAYBACK_COMPLETE) { 275 LOGV("playback completed immediately following start()"); 276 } 277 } 278 return ret; 279 } 280 LOGE("start called in state %d", mCurrentState); 281 return INVALID_OPERATION; 282} 283 284status_t MediaPlayer::stop() 285{ 286 LOGV("stop"); 287 Mutex::Autolock _l(mLock); 288 if (mCurrentState & MEDIA_PLAYER_STOPPED) return NO_ERROR; 289 if ( (mPlayer != 0) && ( mCurrentState & ( MEDIA_PLAYER_STARTED | MEDIA_PLAYER_PREPARED | 290 MEDIA_PLAYER_PAUSED | MEDIA_PLAYER_PLAYBACK_COMPLETE ) ) ) { 291 status_t ret = mPlayer->stop(); 292 if (ret != NO_ERROR) { 293 mCurrentState = MEDIA_PLAYER_STATE_ERROR; 294 } else { 295 mCurrentState = MEDIA_PLAYER_STOPPED; 296 } 297 return ret; 298 } 299 LOGE("stop called in state %d", mCurrentState); 300 return INVALID_OPERATION; 301} 302 303status_t MediaPlayer::pause() 304{ 305 LOGV("pause"); 306 Mutex::Autolock _l(mLock); 307 if (mCurrentState & MEDIA_PLAYER_PAUSED) 308 return NO_ERROR; 309 if ((mPlayer != 0) && (mCurrentState & MEDIA_PLAYER_STARTED)) { 310 status_t ret = mPlayer->pause(); 311 if (ret != NO_ERROR) { 312 mCurrentState = MEDIA_PLAYER_STATE_ERROR; 313 } else { 314 mCurrentState = MEDIA_PLAYER_PAUSED; 315 } 316 return ret; 317 } 318 LOGE("pause called in state %d", mCurrentState); 319 return INVALID_OPERATION; 320} 321 322bool MediaPlayer::isPlaying() 323{ 324 Mutex::Autolock _l(mLock); 325 if (mPlayer != 0) { 326 bool temp = false; 327 mPlayer->isPlaying(&temp); 328 LOGV("isPlaying: %d", temp); 329 if ((mCurrentState & MEDIA_PLAYER_STARTED) && ! temp) { 330 LOGE("internal/external state mismatch corrected"); 331 mCurrentState = MEDIA_PLAYER_PAUSED; 332 } 333 return temp; 334 } 335 LOGV("isPlaying: no active player"); 336 return false; 337} 338 339status_t MediaPlayer::getVideoWidth(int *w) 340{ 341 LOGV("getVideoWidth"); 342 Mutex::Autolock _l(mLock); 343 if (mPlayer == 0) return INVALID_OPERATION; 344 *w = mVideoWidth; 345 return NO_ERROR; 346} 347 348status_t MediaPlayer::getVideoHeight(int *h) 349{ 350 LOGV("getVideoHeight"); 351 Mutex::Autolock _l(mLock); 352 if (mPlayer == 0) return INVALID_OPERATION; 353 *h = mVideoHeight; 354 return NO_ERROR; 355} 356 357status_t MediaPlayer::getCurrentPosition(int *msec) 358{ 359 LOGV("getCurrentPosition"); 360 Mutex::Autolock _l(mLock); 361 if (mPlayer != 0) { 362 if (mCurrentPosition >= 0) { 363 LOGV("Using cached seek position: %d", mCurrentPosition); 364 *msec = mCurrentPosition; 365 return NO_ERROR; 366 } 367 return mPlayer->getCurrentPosition(msec); 368 } 369 return INVALID_OPERATION; 370} 371 372status_t MediaPlayer::getDuration_l(int *msec) 373{ 374 LOGV("getDuration"); 375 bool isValidState = (mCurrentState & (MEDIA_PLAYER_PREPARED | MEDIA_PLAYER_STARTED | MEDIA_PLAYER_PAUSED | MEDIA_PLAYER_STOPPED | MEDIA_PLAYER_PLAYBACK_COMPLETE)); 376 if (mPlayer != 0 && isValidState) { 377 status_t ret = NO_ERROR; 378 if (mDuration <= 0) 379 ret = mPlayer->getDuration(&mDuration); 380 if (msec) 381 *msec = mDuration; 382 return ret; 383 } 384 LOGE("Attempt to call getDuration without a valid mediaplayer"); 385 return INVALID_OPERATION; 386} 387 388status_t MediaPlayer::getDuration(int *msec) 389{ 390 Mutex::Autolock _l(mLock); 391 return getDuration_l(msec); 392} 393 394status_t MediaPlayer::seekTo_l(int msec) 395{ 396 LOGV("seekTo %d", msec); 397 if ((mPlayer != 0) && ( mCurrentState & ( MEDIA_PLAYER_STARTED | MEDIA_PLAYER_PREPARED | MEDIA_PLAYER_PAUSED | MEDIA_PLAYER_PLAYBACK_COMPLETE) ) ) { 398 if ( msec < 0 ) { 399 LOGW("Attempt to seek to invalid position: %d", msec); 400 msec = 0; 401 } else if ((mDuration > 0) && (msec > mDuration)) { 402 LOGW("Attempt to seek to past end of file: request = %d, EOF = %d", msec, mDuration); 403 msec = mDuration; 404 } 405 // cache duration 406 mCurrentPosition = msec; 407 if (mSeekPosition < 0) { 408 getDuration_l(NULL); 409 mSeekPosition = msec; 410 return mPlayer->seekTo(msec); 411 } 412 else { 413 LOGV("Seek in progress - queue up seekTo[%d]", msec); 414 return NO_ERROR; 415 } 416 } 417 LOGE("Attempt to perform seekTo in wrong state: mPlayer=%p, mCurrentState=%u", mPlayer.get(), mCurrentState); 418 return INVALID_OPERATION; 419} 420 421status_t MediaPlayer::seekTo(int msec) 422{ 423 mLockThreadId = getThreadId(); 424 Mutex::Autolock _l(mLock); 425 status_t result = seekTo_l(msec); 426 mLockThreadId = 0; 427 428 return result; 429} 430 431status_t MediaPlayer::reset() 432{ 433 LOGV("reset"); 434 Mutex::Autolock _l(mLock); 435 mLoop = false; 436 if (mCurrentState == MEDIA_PLAYER_IDLE) return NO_ERROR; 437 mPrepareSync = false; 438 if (mPlayer != 0) { 439 status_t ret = mPlayer->reset(); 440 if (ret != NO_ERROR) { 441 LOGE("reset() failed with return code (%d)", ret); 442 mCurrentState = MEDIA_PLAYER_STATE_ERROR; 443 } else { 444 mCurrentState = MEDIA_PLAYER_IDLE; 445 } 446 return ret; 447 } 448 clear_l(); 449 return NO_ERROR; 450} 451 452status_t MediaPlayer::setAudioStreamType(int type) 453{ 454 LOGV("MediaPlayer::setAudioStreamType"); 455 Mutex::Autolock _l(mLock); 456 if (mStreamType == type) return NO_ERROR; 457 if (mCurrentState & ( MEDIA_PLAYER_PREPARED | MEDIA_PLAYER_STARTED | 458 MEDIA_PLAYER_PAUSED | MEDIA_PLAYER_PLAYBACK_COMPLETE ) ) { 459 // Can't change the stream type after prepare 460 LOGE("setAudioStream called in state %d", mCurrentState); 461 return INVALID_OPERATION; 462 } 463 // cache 464 mStreamType = type; 465 return OK; 466} 467 468status_t MediaPlayer::setLooping(int loop) 469{ 470 LOGV("MediaPlayer::setLooping"); 471 Mutex::Autolock _l(mLock); 472 mLoop = (loop != 0); 473 if (mPlayer != 0) { 474 return mPlayer->setLooping(loop); 475 } 476 return OK; 477} 478 479bool MediaPlayer::isLooping() { 480 LOGV("isLooping"); 481 Mutex::Autolock _l(mLock); 482 if (mPlayer != 0) { 483 return mLoop; 484 } 485 LOGV("isLooping: no active player"); 486 return false; 487} 488 489status_t MediaPlayer::setVolume(float leftVolume, float rightVolume) 490{ 491 LOGV("MediaPlayer::setVolume(%f, %f)", leftVolume, rightVolume); 492 Mutex::Autolock _l(mLock); 493 mLeftVolume = leftVolume; 494 mRightVolume = rightVolume; 495 if (mPlayer != 0) { 496 return mPlayer->setVolume(leftVolume, rightVolume); 497 } 498 return OK; 499} 500 501void MediaPlayer::notify(int msg, int ext1, int ext2) 502{ 503 LOGV("message received msg=%d, ext1=%d, ext2=%d", msg, ext1, ext2); 504 bool send = true; 505 bool locked = false; 506 507 // TODO: In the future, we might be on the same thread if the app is 508 // running in the same process as the media server. In that case, 509 // this will deadlock. 510 // 511 // The threadId hack below works around this for the care of prepare 512 // and seekTo within the same process. 513 // FIXME: Remember, this is a hack, it's not even a hack that is applied 514 // consistently for all use-cases, this needs to be revisited. 515 if (mLockThreadId != getThreadId()) { 516 mLock.lock(); 517 locked = true; 518 } 519 520 if (mPlayer == 0) { 521 LOGV("notify(%d, %d, %d) callback on disconnected mediaplayer", msg, ext1, ext2); 522 if (locked) mLock.unlock(); // release the lock when done. 523 return; 524 } 525 526 switch (msg) { 527 case MEDIA_NOP: // interface test message 528 break; 529 case MEDIA_PREPARED: 530 LOGV("prepared"); 531 mCurrentState = MEDIA_PLAYER_PREPARED; 532 if (mPrepareSync) { 533 LOGV("signal application thread"); 534 mPrepareSync = false; 535 mPrepareStatus = NO_ERROR; 536 mSignal.signal(); 537 } 538 break; 539 case MEDIA_PLAYBACK_COMPLETE: 540 LOGV("playback complete"); 541 if (!mLoop) { 542 mCurrentState = MEDIA_PLAYER_PLAYBACK_COMPLETE; 543 } 544 break; 545 case MEDIA_ERROR: 546 // Always log errors. 547 // ext1: Media framework error code. 548 // ext2: Implementation dependant error code. 549 LOGE("error (%d, %d)", ext1, ext2); 550 mCurrentState = MEDIA_PLAYER_STATE_ERROR; 551 if (mPrepareSync) 552 { 553 LOGV("signal application thread"); 554 mPrepareSync = false; 555 mPrepareStatus = ext1; 556 mSignal.signal(); 557 send = false; 558 } 559 break; 560 case MEDIA_INFO: 561 // ext1: Media framework error code. 562 // ext2: Implementation dependant error code. 563 LOGW("info/warning (%d, %d)", ext1, ext2); 564 break; 565 case MEDIA_SEEK_COMPLETE: 566 LOGV("Received seek complete"); 567 if (mSeekPosition != mCurrentPosition) { 568 LOGV("Executing queued seekTo(%d)", mSeekPosition); 569 mSeekPosition = -1; 570 seekTo_l(mCurrentPosition); 571 } 572 else { 573 LOGV("All seeks complete - return to regularly scheduled program"); 574 mCurrentPosition = mSeekPosition = -1; 575 } 576 break; 577 case MEDIA_BUFFERING_UPDATE: 578 LOGV("buffering %d", ext1); 579 break; 580 case MEDIA_SET_VIDEO_SIZE: 581 LOGV("New video size %d x %d", ext1, ext2); 582 mVideoWidth = ext1; 583 mVideoHeight = ext2; 584 break; 585 default: 586 LOGV("unrecognized message: (%d, %d, %d)", msg, ext1, ext2); 587 break; 588 } 589 590 sp<MediaPlayerListener> listener = mListener; 591 if (locked) mLock.unlock(); 592 593 // this prevents re-entrant calls into client code 594 if ((listener != 0) && send) { 595 Mutex::Autolock _l(mNotifyLock); 596 LOGV("callback application"); 597 listener->notify(msg, ext1, ext2); 598 LOGV("back from callback"); 599 } 600} 601 602/*static*/ sp<IMemory> MediaPlayer::decode(const char* url, uint32_t *pSampleRate, int* pNumChannels, int* pFormat) 603{ 604 LOGV("decode(%s)", url); 605 sp<IMemory> p; 606 const sp<IMediaPlayerService>& service = getMediaPlayerService(); 607 if (service != 0) { 608 p = service->decode(url, pSampleRate, pNumChannels, pFormat); 609 } else { 610 LOGE("Unable to locate media service"); 611 } 612 return p; 613 614} 615 616void MediaPlayer::died() 617{ 618 LOGV("died"); 619 notify(MEDIA_ERROR, MEDIA_ERROR_SERVER_DIED, 0); 620} 621 622/*static*/ sp<IMemory> MediaPlayer::decode(int fd, int64_t offset, int64_t length, uint32_t *pSampleRate, int* pNumChannels, int* pFormat) 623{ 624 LOGV("decode(%d, %lld, %lld)", fd, offset, length); 625 sp<IMemory> p; 626 const sp<IMediaPlayerService>& service = getMediaPlayerService(); 627 if (service != 0) { 628 p = service->decode(fd, offset, length, pSampleRate, pNumChannels, pFormat); 629 } else { 630 LOGE("Unable to locate media service"); 631 } 632 return p; 633 634} 635 636extern "C" { 637#define FLOATING_POINT 1 638#include "fftwrap.h" 639} 640 641static void *ffttable = NULL; 642 643// peeks at the audio data and fills 'data' with the requested kind 644// (currently kind=0 returns mono 16 bit PCM data, and kind=1 returns 645// 256 point FFT data). Return value is number of samples returned, 646// which may be 0. 647/*static*/ int MediaPlayer::snoop(short* data, int len, int kind) { 648 649 sp<IMemory> p; 650 const sp<IMediaPlayerService>& service = getMediaPlayerService(); 651 if (service != 0) { 652 // Take a peek at the waveform. The returned data consists of 16 bit mono PCM data. 653 p = service->snoop(); 654 655 if (p == NULL) { 656 return 0; 657 } 658 659 if (kind == 0) { // return waveform data 660 int plen = p->size(); 661 len *= 2; // number of shorts -> number of bytes 662 short *src = (short*) p->pointer(); 663 if (plen > len) { 664 plen = len; 665 } 666 memcpy(data, src, plen); 667 return plen / sizeof(short); // return number of samples 668 } else if (kind == 1) { 669 // TODO: use a more efficient FFT 670 // Right now this uses the speex library, which is compiled to do a float FFT 671 if (!ffttable) ffttable = spx_fft_init(512); 672 short *usrc = (short*) p->pointer(); 673 float fsrc[512]; 674 for (int i=0;i<512;i++) 675 fsrc[i] = usrc[i]; 676 float fdst[512]; 677 spx_fft_float(ffttable, fsrc, fdst); 678 if (len > 512) { 679 len = 512; 680 } 681 len /= 2; // only half the output data is valid 682 for (int i=0; i < len; i++) 683 data[i] = fdst[i]; 684 return len; 685 } 686 687 } else { 688 LOGE("Unable to locate media service"); 689 } 690 return 0; 691} 692 693}; // namespace android 694