1 /* 2 * Copyright (C) 2009 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 LOG_NDEBUG 0 18 #define LOG_TAG "AudioPlayer" 19 #include <utils/Log.h> 20 21 #include <binder/IPCThreadState.h> 22 #include <media/AudioTrack.h> 23 #include <media/stagefright/foundation/ADebug.h> 24 #include <media/stagefright/foundation/ALooper.h> 25 #include <media/stagefright/AudioPlayer.h> 26 #include <media/stagefright/MediaDefs.h> 27 #include <media/stagefright/MediaErrors.h> 28 #include <media/stagefright/MediaSource.h> 29 #include <media/stagefright/MetaData.h> 30 31 #include "include/AwesomePlayer.h" 32 33 namespace android { 34 35 AudioPlayer::AudioPlayer( 36 const sp<MediaPlayerBase::AudioSink> &audioSink, 37 bool allowDeepBuffering, 38 AwesomePlayer *observer) 39 : mAudioTrack(NULL), 40 mInputBuffer(NULL), 41 mSampleRate(0), 42 mLatencyUs(0), 43 mFrameSize(0), 44 mNumFramesPlayed(0), 45 mNumFramesPlayedSysTimeUs(ALooper::GetNowUs()), 46 mPositionTimeMediaUs(-1), 47 mPositionTimeRealUs(-1), 48 mSeeking(false), 49 mReachedEOS(false), 50 mFinalStatus(OK), 51 mStarted(false), 52 mIsFirstBuffer(false), 53 mFirstBufferResult(OK), 54 mFirstBuffer(NULL), 55 mAudioSink(audioSink), 56 mAllowDeepBuffering(allowDeepBuffering), 57 mObserver(observer), 58 mPinnedTimeUs(-1ll) { 59 } 60 61 AudioPlayer::~AudioPlayer() { 62 if (mStarted) { 63 reset(); 64 } 65 } 66 67 void AudioPlayer::setSource(const sp<MediaSource> &source) { 68 CHECK(mSource == NULL); 69 mSource = source; 70 } 71 72 status_t AudioPlayer::start(bool sourceAlreadyStarted) { 73 CHECK(!mStarted); 74 CHECK(mSource != NULL); 75 76 status_t err; 77 if (!sourceAlreadyStarted) { 78 err = mSource->start(); 79 80 if (err != OK) { 81 return err; 82 } 83 } 84 85 // We allow an optional INFO_FORMAT_CHANGED at the very beginning 86 // of playback, if there is one, getFormat below will retrieve the 87 // updated format, if there isn't, we'll stash away the valid buffer 88 // of data to be used on the first audio callback. 89 90 CHECK(mFirstBuffer == NULL); 91 92 MediaSource::ReadOptions options; 93 if (mSeeking) { 94 options.setSeekTo(mSeekTimeUs); 95 mSeeking = false; 96 } 97 98 mFirstBufferResult = mSource->read(&mFirstBuffer, &options); 99 if (mFirstBufferResult == INFO_FORMAT_CHANGED) { 100 ALOGV("INFO_FORMAT_CHANGED!!!"); 101 102 CHECK(mFirstBuffer == NULL); 103 mFirstBufferResult = OK; 104 mIsFirstBuffer = false; 105 } else { 106 mIsFirstBuffer = true; 107 } 108 109 sp<MetaData> format = mSource->getFormat(); 110 const char *mime; 111 bool success = format->findCString(kKeyMIMEType, &mime); 112 CHECK(success); 113 CHECK(!strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_RAW)); 114 115 success = format->findInt32(kKeySampleRate, &mSampleRate); 116 CHECK(success); 117 118 int32_t numChannels, channelMask; 119 success = format->findInt32(kKeyChannelCount, &numChannels); 120 CHECK(success); 121 122 if(!format->findInt32(kKeyChannelMask, &channelMask)) { 123 // log only when there's a risk of ambiguity of channel mask selection 124 ALOGI_IF(numChannels > 2, 125 "source format didn't specify channel mask, using (%d) channel order", numChannels); 126 channelMask = CHANNEL_MASK_USE_CHANNEL_ORDER; 127 } 128 129 if (mAudioSink.get() != NULL) { 130 131 status_t err = mAudioSink->open( 132 mSampleRate, numChannels, channelMask, AUDIO_FORMAT_PCM_16_BIT, 133 DEFAULT_AUDIOSINK_BUFFERCOUNT, 134 &AudioPlayer::AudioSinkCallback, 135 this, 136 (mAllowDeepBuffering ? 137 AUDIO_OUTPUT_FLAG_DEEP_BUFFER : 138 AUDIO_OUTPUT_FLAG_NONE)); 139 if (err != OK) { 140 if (mFirstBuffer != NULL) { 141 mFirstBuffer->release(); 142 mFirstBuffer = NULL; 143 } 144 145 if (!sourceAlreadyStarted) { 146 mSource->stop(); 147 } 148 149 return err; 150 } 151 152 mLatencyUs = (int64_t)mAudioSink->latency() * 1000; 153 mFrameSize = mAudioSink->frameSize(); 154 155 mAudioSink->start(); 156 } else { 157 // playing to an AudioTrack, set up mask if necessary 158 audio_channel_mask_t audioMask = channelMask == CHANNEL_MASK_USE_CHANNEL_ORDER ? 159 audio_channel_out_mask_from_count(numChannels) : channelMask; 160 if (0 == audioMask) { 161 return BAD_VALUE; 162 } 163 164 mAudioTrack = new AudioTrack( 165 AUDIO_STREAM_MUSIC, mSampleRate, AUDIO_FORMAT_PCM_16_BIT, audioMask, 166 0, AUDIO_OUTPUT_FLAG_NONE, &AudioCallback, this, 0); 167 168 if ((err = mAudioTrack->initCheck()) != OK) { 169 delete mAudioTrack; 170 mAudioTrack = NULL; 171 172 if (mFirstBuffer != NULL) { 173 mFirstBuffer->release(); 174 mFirstBuffer = NULL; 175 } 176 177 if (!sourceAlreadyStarted) { 178 mSource->stop(); 179 } 180 181 return err; 182 } 183 184 mLatencyUs = (int64_t)mAudioTrack->latency() * 1000; 185 mFrameSize = mAudioTrack->frameSize(); 186 187 mAudioTrack->start(); 188 } 189 190 mStarted = true; 191 mPinnedTimeUs = -1ll; 192 193 return OK; 194 } 195 196 void AudioPlayer::pause(bool playPendingSamples) { 197 CHECK(mStarted); 198 199 if (playPendingSamples) { 200 if (mAudioSink.get() != NULL) { 201 mAudioSink->stop(); 202 } else { 203 mAudioTrack->stop(); 204 } 205 206 mNumFramesPlayed = 0; 207 mNumFramesPlayedSysTimeUs = ALooper::GetNowUs(); 208 } else { 209 if (mAudioSink.get() != NULL) { 210 mAudioSink->pause(); 211 } else { 212 mAudioTrack->pause(); 213 } 214 215 mPinnedTimeUs = ALooper::GetNowUs(); 216 } 217 } 218 219 void AudioPlayer::resume() { 220 CHECK(mStarted); 221 222 if (mAudioSink.get() != NULL) { 223 mAudioSink->start(); 224 } else { 225 mAudioTrack->start(); 226 } 227 } 228 229 void AudioPlayer::reset() { 230 CHECK(mStarted); 231 232 if (mAudioSink.get() != NULL) { 233 mAudioSink->stop(); 234 mAudioSink->close(); 235 } else { 236 mAudioTrack->stop(); 237 238 delete mAudioTrack; 239 mAudioTrack = NULL; 240 } 241 242 // Make sure to release any buffer we hold onto so that the 243 // source is able to stop(). 244 245 if (mFirstBuffer != NULL) { 246 mFirstBuffer->release(); 247 mFirstBuffer = NULL; 248 } 249 250 if (mInputBuffer != NULL) { 251 ALOGV("AudioPlayer releasing input buffer."); 252 253 mInputBuffer->release(); 254 mInputBuffer = NULL; 255 } 256 257 mSource->stop(); 258 259 // The following hack is necessary to ensure that the OMX 260 // component is completely released by the time we may try 261 // to instantiate it again. 262 wp<MediaSource> tmp = mSource; 263 mSource.clear(); 264 while (tmp.promote() != NULL) { 265 usleep(1000); 266 } 267 IPCThreadState::self()->flushCommands(); 268 269 mNumFramesPlayed = 0; 270 mNumFramesPlayedSysTimeUs = ALooper::GetNowUs(); 271 mPositionTimeMediaUs = -1; 272 mPositionTimeRealUs = -1; 273 mSeeking = false; 274 mReachedEOS = false; 275 mFinalStatus = OK; 276 mStarted = false; 277 } 278 279 // static 280 void AudioPlayer::AudioCallback(int event, void *user, void *info) { 281 static_cast<AudioPlayer *>(user)->AudioCallback(event, info); 282 } 283 284 bool AudioPlayer::isSeeking() { 285 Mutex::Autolock autoLock(mLock); 286 return mSeeking; 287 } 288 289 bool AudioPlayer::reachedEOS(status_t *finalStatus) { 290 *finalStatus = OK; 291 292 Mutex::Autolock autoLock(mLock); 293 *finalStatus = mFinalStatus; 294 return mReachedEOS; 295 } 296 297 status_t AudioPlayer::setPlaybackRatePermille(int32_t ratePermille) { 298 if (mAudioSink.get() != NULL) { 299 return mAudioSink->setPlaybackRatePermille(ratePermille); 300 } else if (mAudioTrack != NULL){ 301 return mAudioTrack->setSampleRate(ratePermille * mSampleRate / 1000); 302 } else { 303 return NO_INIT; 304 } 305 } 306 307 // static 308 size_t AudioPlayer::AudioSinkCallback( 309 MediaPlayerBase::AudioSink *audioSink, 310 void *buffer, size_t size, void *cookie) { 311 AudioPlayer *me = (AudioPlayer *)cookie; 312 313 return me->fillBuffer(buffer, size); 314 } 315 316 void AudioPlayer::AudioCallback(int event, void *info) { 317 if (event != AudioTrack::EVENT_MORE_DATA) { 318 return; 319 } 320 321 AudioTrack::Buffer *buffer = (AudioTrack::Buffer *)info; 322 size_t numBytesWritten = fillBuffer(buffer->raw, buffer->size); 323 324 buffer->size = numBytesWritten; 325 } 326 327 uint32_t AudioPlayer::getNumFramesPendingPlayout() const { 328 uint32_t numFramesPlayedOut; 329 status_t err; 330 331 if (mAudioSink != NULL) { 332 err = mAudioSink->getPosition(&numFramesPlayedOut); 333 } else { 334 err = mAudioTrack->getPosition(&numFramesPlayedOut); 335 } 336 337 if (err != OK || mNumFramesPlayed < numFramesPlayedOut) { 338 return 0; 339 } 340 341 // mNumFramesPlayed is the number of frames submitted 342 // to the audio sink for playback, but not all of them 343 // may have played out by now. 344 return mNumFramesPlayed - numFramesPlayedOut; 345 } 346 347 size_t AudioPlayer::fillBuffer(void *data, size_t size) { 348 if (mNumFramesPlayed == 0) { 349 ALOGV("AudioCallback"); 350 } 351 352 if (mReachedEOS) { 353 return 0; 354 } 355 356 bool postSeekComplete = false; 357 bool postEOS = false; 358 int64_t postEOSDelayUs = 0; 359 360 size_t size_done = 0; 361 size_t size_remaining = size; 362 while (size_remaining > 0) { 363 MediaSource::ReadOptions options; 364 365 { 366 Mutex::Autolock autoLock(mLock); 367 368 if (mSeeking) { 369 if (mIsFirstBuffer) { 370 if (mFirstBuffer != NULL) { 371 mFirstBuffer->release(); 372 mFirstBuffer = NULL; 373 } 374 mIsFirstBuffer = false; 375 } 376 377 options.setSeekTo(mSeekTimeUs); 378 379 if (mInputBuffer != NULL) { 380 mInputBuffer->release(); 381 mInputBuffer = NULL; 382 } 383 384 mSeeking = false; 385 if (mObserver) { 386 postSeekComplete = true; 387 } 388 } 389 } 390 391 if (mInputBuffer == NULL) { 392 status_t err; 393 394 if (mIsFirstBuffer) { 395 mInputBuffer = mFirstBuffer; 396 mFirstBuffer = NULL; 397 err = mFirstBufferResult; 398 399 mIsFirstBuffer = false; 400 } else { 401 err = mSource->read(&mInputBuffer, &options); 402 } 403 404 CHECK((err == OK && mInputBuffer != NULL) 405 || (err != OK && mInputBuffer == NULL)); 406 407 Mutex::Autolock autoLock(mLock); 408 409 if (err != OK) { 410 if (mObserver && !mReachedEOS) { 411 // We don't want to post EOS right away but only 412 // after all frames have actually been played out. 413 414 // These are the number of frames submitted to the 415 // AudioTrack that you haven't heard yet. 416 uint32_t numFramesPendingPlayout = 417 getNumFramesPendingPlayout(); 418 419 // These are the number of frames we're going to 420 // submit to the AudioTrack by returning from this 421 // callback. 422 uint32_t numAdditionalFrames = size_done / mFrameSize; 423 424 numFramesPendingPlayout += numAdditionalFrames; 425 426 int64_t timeToCompletionUs = 427 (1000000ll * numFramesPendingPlayout) / mSampleRate; 428 429 ALOGV("total number of frames played: %lld (%lld us)", 430 (mNumFramesPlayed + numAdditionalFrames), 431 1000000ll * (mNumFramesPlayed + numAdditionalFrames) 432 / mSampleRate); 433 434 ALOGV("%d frames left to play, %lld us (%.2f secs)", 435 numFramesPendingPlayout, 436 timeToCompletionUs, timeToCompletionUs / 1E6); 437 438 postEOS = true; 439 if (mAudioSink->needsTrailingPadding()) { 440 postEOSDelayUs = timeToCompletionUs + mLatencyUs; 441 } else { 442 postEOSDelayUs = 0; 443 } 444 } 445 446 mReachedEOS = true; 447 mFinalStatus = err; 448 break; 449 } 450 451 if (mAudioSink != NULL) { 452 mLatencyUs = (int64_t)mAudioSink->latency() * 1000; 453 } else { 454 mLatencyUs = (int64_t)mAudioTrack->latency() * 1000; 455 } 456 457 CHECK(mInputBuffer->meta_data()->findInt64( 458 kKeyTime, &mPositionTimeMediaUs)); 459 460 mPositionTimeRealUs = 461 ((mNumFramesPlayed + size_done / mFrameSize) * 1000000) 462 / mSampleRate; 463 464 ALOGV("buffer->size() = %d, " 465 "mPositionTimeMediaUs=%.2f mPositionTimeRealUs=%.2f", 466 mInputBuffer->range_length(), 467 mPositionTimeMediaUs / 1E6, mPositionTimeRealUs / 1E6); 468 } 469 470 if (mInputBuffer->range_length() == 0) { 471 mInputBuffer->release(); 472 mInputBuffer = NULL; 473 474 continue; 475 } 476 477 size_t copy = size_remaining; 478 if (copy > mInputBuffer->range_length()) { 479 copy = mInputBuffer->range_length(); 480 } 481 482 memcpy((char *)data + size_done, 483 (const char *)mInputBuffer->data() + mInputBuffer->range_offset(), 484 copy); 485 486 mInputBuffer->set_range(mInputBuffer->range_offset() + copy, 487 mInputBuffer->range_length() - copy); 488 489 size_done += copy; 490 size_remaining -= copy; 491 } 492 493 { 494 Mutex::Autolock autoLock(mLock); 495 mNumFramesPlayed += size_done / mFrameSize; 496 mNumFramesPlayedSysTimeUs = ALooper::GetNowUs(); 497 498 if (mReachedEOS) { 499 mPinnedTimeUs = mNumFramesPlayedSysTimeUs; 500 } else { 501 mPinnedTimeUs = -1ll; 502 } 503 } 504 505 if (postEOS) { 506 mObserver->postAudioEOS(postEOSDelayUs); 507 } 508 509 if (postSeekComplete) { 510 mObserver->postAudioSeekComplete(); 511 } 512 513 return size_done; 514 } 515 516 int64_t AudioPlayer::getRealTimeUs() { 517 Mutex::Autolock autoLock(mLock); 518 return getRealTimeUsLocked(); 519 } 520 521 int64_t AudioPlayer::getRealTimeUsLocked() const { 522 CHECK(mStarted); 523 CHECK_NE(mSampleRate, 0); 524 int64_t result = -mLatencyUs + (mNumFramesPlayed * 1000000) / mSampleRate; 525 526 // Compensate for large audio buffers, updates of mNumFramesPlayed 527 // are less frequent, therefore to get a "smoother" notion of time we 528 // compensate using system time. 529 int64_t diffUs; 530 if (mPinnedTimeUs >= 0ll) { 531 diffUs = mPinnedTimeUs; 532 } else { 533 diffUs = ALooper::GetNowUs(); 534 } 535 536 diffUs -= mNumFramesPlayedSysTimeUs; 537 538 return result + diffUs; 539 } 540 541 int64_t AudioPlayer::getMediaTimeUs() { 542 Mutex::Autolock autoLock(mLock); 543 544 if (mPositionTimeMediaUs < 0 || mPositionTimeRealUs < 0) { 545 if (mSeeking) { 546 return mSeekTimeUs; 547 } 548 549 return 0; 550 } 551 552 int64_t realTimeOffset = getRealTimeUsLocked() - mPositionTimeRealUs; 553 if (realTimeOffset < 0) { 554 realTimeOffset = 0; 555 } 556 557 return mPositionTimeMediaUs + realTimeOffset; 558 } 559 560 bool AudioPlayer::getMediaTimeMapping( 561 int64_t *realtime_us, int64_t *mediatime_us) { 562 Mutex::Autolock autoLock(mLock); 563 564 *realtime_us = mPositionTimeRealUs; 565 *mediatime_us = mPositionTimeMediaUs; 566 567 return mPositionTimeRealUs != -1 && mPositionTimeMediaUs != -1; 568 } 569 570 status_t AudioPlayer::seekTo(int64_t time_us) { 571 Mutex::Autolock autoLock(mLock); 572 573 mSeeking = true; 574 mPositionTimeRealUs = mPositionTimeMediaUs = -1; 575 mReachedEOS = false; 576 mSeekTimeUs = time_us; 577 578 // Flush resets the number of played frames 579 mNumFramesPlayed = 0; 580 mNumFramesPlayedSysTimeUs = ALooper::GetNowUs(); 581 582 if (mAudioSink != NULL) { 583 mAudioSink->flush(); 584 } else { 585 mAudioTrack->flush(); 586 } 587 588 return OK; 589 } 590 591 } 592
