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