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