frameworks/base/media/libstagefright/AudioPlayer.cpp

   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/AudioPlayer.h>
  24 #include <media/stagefright/MediaDebug.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
  32 namespace android {
  33
  34 AudioPlayer::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
  56 AudioPlayer::~AudioPlayer() {
  57     if (mStarted) {
  58         reset();
  59     }
  60 }
  61
  62 void AudioPlayer::setSource(const sp<MediaSource> &source) {
  63     CHECK_EQ(mSource, NULL);
  64     mSource = source;
  65 }
  66
  67 status_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     mFirstBufferResult = mSource->read(&mFirstBuffer);
  88     if (mFirstBufferResult == INFO_FORMAT_CHANGED) {
  89         LOGV("INFO_FORMAT_CHANGED!!!");
  90
  91         CHECK(mFirstBuffer == NULL);
  92         mFirstBufferResult = OK;
  93         mIsFirstBuffer = false;
  94     } else {
  95         mIsFirstBuffer = true;
  96     }
  97
  98     sp<MetaData> format = mSource->getFormat();
  99     const char *mime;
 100     bool success = format->findCString(kKeyMIMEType, &mime);
 101     CHECK(success);
 102     CHECK(!strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_RAW));
 103
 104     success = format->findInt32(kKeySampleRate, &mSampleRate);
 105     CHECK(success);
 106
 107     int32_t numChannels;
 108     success = format->findInt32(kKeyChannelCount, &numChannels);
 109     CHECK(success);
 110
 111     if (mAudioSink.get() != NULL) {
 112         status_t err = mAudioSink->open(
 113                 mSampleRate, numChannels, AudioSystem::PCM_16_BIT,
 114                 DEFAULT_AUDIOSINK_BUFFERCOUNT,
 115                 &AudioPlayer::AudioSinkCallback, this);
 116         if (err != OK) {
 117             if (mFirstBuffer != NULL) {
 118                 mFirstBuffer->release();
 119                 mFirstBuffer = NULL;
 120             }
 121
 122             if (!sourceAlreadyStarted) {
 123                 mSource->stop();
 124             }
 125
 126             return err;
 127         }
 128
 129         mLatencyUs = (int64_t)mAudioSink->latency() * 1000;
 130         mFrameSize = mAudioSink->frameSize();
 131
 132         mAudioSink->start();
 133     } else {
 134         mAudioTrack = new AudioTrack(
 135                 AudioSystem::MUSIC, mSampleRate, AudioSystem::PCM_16_BIT,
 136                 (numChannels == 2)
 137                     ? AudioSystem::CHANNEL_OUT_STEREO
 138                     : AudioSystem::CHANNEL_OUT_MONO,
 139                 0, 0, &AudioCallback, this, 0);
 140
 141         if ((err = mAudioTrack->initCheck()) != OK) {
 142             delete mAudioTrack;
 143             mAudioTrack = NULL;
 144
 145             if (mFirstBuffer != NULL) {
 146                 mFirstBuffer->release();
 147                 mFirstBuffer = NULL;
 148             }
 149
 150             if (!sourceAlreadyStarted) {
 151                 mSource->stop();
 152             }
 153
 154             return err;
 155         }
 156
 157         mLatencyUs = (int64_t)mAudioTrack->latency() * 1000;
 158         mFrameSize = mAudioTrack->frameSize();
 159
 160         mAudioTrack->start();
 161     }
 162
 163     mStarted = true;
 164
 165     return OK;
 166 }
 167
 168 void AudioPlayer::pause(bool playPendingSamples) {
 169     CHECK(mStarted);
 170
 171     if (playPendingSamples) {
 172         if (mAudioSink.get() != NULL) {
 173             mAudioSink->stop();
 174         } else {
 175             mAudioTrack->stop();
 176         }
 177     } else {
 178         if (mAudioSink.get() != NULL) {
 179             mAudioSink->pause();
 180         } else {
 181             mAudioTrack->pause();
 182         }
 183     }
 184 }
 185
 186 void AudioPlayer::resume() {
 187     CHECK(mStarted);
 188
 189     if (mAudioSink.get() != NULL) {
 190         mAudioSink->start();
 191     } else {
 192         mAudioTrack->start();
 193     }
 194 }
 195
 196 void AudioPlayer::reset() {
 197     CHECK(mStarted);
 198
 199     if (mAudioSink.get() != NULL) {
 200         mAudioSink->stop();
 201         mAudioSink->close();
 202     } else {
 203         mAudioTrack->stop();
 204
 205         delete mAudioTrack;
 206         mAudioTrack = NULL;
 207     }
 208
 209     // Make sure to release any buffer we hold onto so that the
 210     // source is able to stop().
 211
 212     if (mFirstBuffer != NULL) {
 213         mFirstBuffer->release();
 214         mFirstBuffer = NULL;
 215     }
 216
 217     if (mInputBuffer != NULL) {
 218         LOGV("AudioPlayer releasing input buffer.");
 219
 220         mInputBuffer->release();
 221         mInputBuffer = NULL;
 222     }
 223
 224     mSource->stop();
 225
 226     // The following hack is necessary to ensure that the OMX
 227     // component is completely released by the time we may try
 228     // to instantiate it again.
 229     wp<MediaSource> tmp = mSource;
 230     mSource.clear();
 231     while (tmp.promote() != NULL) {
 232         usleep(1000);
 233     }
 234     IPCThreadState::self()->flushCommands();
 235
 236     mNumFramesPlayed = 0;
 237     mPositionTimeMediaUs = -1;
 238     mPositionTimeRealUs = -1;
 239     mSeeking = false;
 240     mReachedEOS = false;
 241     mFinalStatus = OK;
 242     mStarted = false;
 243 }
 244
 245 // static
 246 void AudioPlayer::AudioCallback(int event, void *user, void *info) {
 247     static_cast<AudioPlayer *>(user)->AudioCallback(event, info);
 248 }
 249
 250 bool AudioPlayer::isSeeking() {
 251     Mutex::Autolock autoLock(mLock);
 252     return mSeeking;
 253 }
 254
 255 bool AudioPlayer::reachedEOS(status_t *finalStatus) {
 256     *finalStatus = OK;
 257
 258     Mutex::Autolock autoLock(mLock);
 259     *finalStatus = mFinalStatus;
 260     return mReachedEOS;
 261 }
 262
 263 // static
 264 size_t AudioPlayer::AudioSinkCallback(
 265         MediaPlayerBase::AudioSink *audioSink,
 266         void *buffer, size_t size, void *cookie) {
 267     AudioPlayer *me = (AudioPlayer *)cookie;
 268
 269     return me->fillBuffer(buffer, size);
 270 }
 271
 272 void AudioPlayer::AudioCallback(int event, void *info) {
 273     if (event != AudioTrack::EVENT_MORE_DATA) {
 274         return;
 275     }
 276
 277     AudioTrack::Buffer *buffer = (AudioTrack::Buffer *)info;
 278     size_t numBytesWritten = fillBuffer(buffer->raw, buffer->size);
 279
 280     buffer->size = numBytesWritten;
 281 }
 282
 283 size_t AudioPlayer::fillBuffer(void *data, size_t size) {
 284     if (mNumFramesPlayed == 0) {
 285         LOGV("AudioCallback");
 286     }
 287
 288     if (mReachedEOS) {
 289         return 0;
 290     }
 291
 292     size_t size_done = 0;
 293     size_t size_remaining = size;
 294     while (size_remaining > 0) {
 295         MediaSource::ReadOptions options;
 296
 297         {
 298             Mutex::Autolock autoLock(mLock);
 299
 300             if (mSeeking) {
 301                 if (mIsFirstBuffer) {
 302                     if (mFirstBuffer != NULL) {
 303                         mFirstBuffer->release();
 304                         mFirstBuffer = NULL;
 305                     }
 306                     mIsFirstBuffer = false;
 307                 }
 308
 309                 options.setSeekTo(mSeekTimeUs);
 310
 311                 if (mInputBuffer != NULL) {
 312                     mInputBuffer->release();
 313                     mInputBuffer = NULL;
 314                 }
 315
 316                 mSeeking = false;
 317                 if (mObserver) {
 318                     mObserver->postAudioSeekComplete();
 319                 }
 320             }
 321         }
 322
 323         if (mInputBuffer == NULL) {
 324             status_t err;
 325
 326             if (mIsFirstBuffer) {
 327                 mInputBuffer = mFirstBuffer;
 328                 mFirstBuffer = NULL;
 329                 err = mFirstBufferResult;
 330
 331                 mIsFirstBuffer = false;
 332             } else {
 333                 err = mSource->read(&mInputBuffer, &options);
 334             }
 335
 336             CHECK((err == OK && mInputBuffer != NULL)
 337                    || (err != OK && mInputBuffer == NULL));
 338
 339             Mutex::Autolock autoLock(mLock);
 340
 341             if (err != OK) {
 342                 if (mObserver && !mReachedEOS) {
 343                     mObserver->postAudioEOS();
 344                 }
 345
 346                 mReachedEOS = true;
 347                 mFinalStatus = err;
 348                 break;
 349             }
 350
 351             CHECK(mInputBuffer->meta_data()->findInt64(
 352                         kKeyTime, &mPositionTimeMediaUs));
 353
 354             mPositionTimeRealUs =
 355                 ((mNumFramesPlayed + size_done / mFrameSize) * 1000000)
 356                     / mSampleRate;
 357
 358             LOGV("buffer->size() = %d, "
 359                  "mPositionTimeMediaUs=%.2f mPositionTimeRealUs=%.2f",
 360                  mInputBuffer->range_length(),
 361                  mPositionTimeMediaUs / 1E6, mPositionTimeRealUs / 1E6);
 362         }
 363
 364         if (mInputBuffer->range_length() == 0) {
 365             mInputBuffer->release();
 366             mInputBuffer = NULL;
 367
 368             continue;
 369         }
 370
 371         size_t copy = size_remaining;
 372         if (copy > mInputBuffer->range_length()) {
 373             copy = mInputBuffer->range_length();
 374         }
 375
 376         memcpy((char *)data + size_done,
 377                (const char *)mInputBuffer->data() + mInputBuffer->range_offset(),
 378                copy);
 379
 380         mInputBuffer->set_range(mInputBuffer->range_offset() + copy,
 381                                 mInputBuffer->range_length() - copy);
 382
 383         size_done += copy;
 384         size_remaining -= copy;
 385     }
 386
 387     Mutex::Autolock autoLock(mLock);
 388     mNumFramesPlayed += size_done / mFrameSize;
 389
 390     return size_done;
 391 }
 392
 393 int64_t AudioPlayer::getRealTimeUs() {
 394     Mutex::Autolock autoLock(mLock);
 395     return getRealTimeUsLocked();
 396 }
 397
 398 int64_t AudioPlayer::getRealTimeUsLocked() const {
 399     return -mLatencyUs + (mNumFramesPlayed * 1000000) / mSampleRate;
 400 }
 401
 402 int64_t AudioPlayer::getMediaTimeUs() {
 403     Mutex::Autolock autoLock(mLock);
 404
 405     if (mPositionTimeMediaUs < 0 || mPositionTimeRealUs < 0) {
 406         return 0;
 407     }
 408
 409     int64_t realTimeOffset = getRealTimeUsLocked() - mPositionTimeRealUs;
 410     if (realTimeOffset < 0) {
 411         realTimeOffset = 0;
 412     }
 413
 414     return mPositionTimeMediaUs + realTimeOffset;
 415 }
 416
 417 bool AudioPlayer::getMediaTimeMapping(
 418         int64_t *realtime_us, int64_t *mediatime_us) {
 419     Mutex::Autolock autoLock(mLock);
 420
 421     *realtime_us = mPositionTimeRealUs;
 422     *mediatime_us = mPositionTimeMediaUs;
 423
 424     return mPositionTimeRealUs != -1 && mPositionTimeMediaUs != -1;
 425 }
 426
 427 status_t AudioPlayer::seekTo(int64_t time_us) {
 428     Mutex::Autolock autoLock(mLock);
 429
 430     mSeeking = true;
 431     mReachedEOS = false;
 432     mSeekTimeUs = time_us;
 433
 434     if (mAudioSink != NULL) {
 435         mAudioSink->flush();
 436     } else {
 437         mAudioTrack->flush();
 438     }
 439
 440     return OK;
 441 }
 442
 443 }