| /* |
| ** |
| ** Copyright 2018, The Android Open Source Project |
| ** |
| ** Licensed under the Apache License, Version 2.0 (the "License"); |
| ** you may not use this file except in compliance with the License. |
| ** You may obtain a copy of the License at |
| ** |
| ** http://www.apache.org/licenses/LICENSE-2.0 |
| ** |
| ** Unless required by applicable law or agreed to in writing, software |
| ** distributed under the License is distributed on an "AS IS" BASIS, |
| ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| ** See the License for the specific language governing permissions and |
| ** limitations under the License. |
| */ |
| |
| //#define LOG_NDEBUG 0 |
| #define LOG_TAG "MediaPlayer2AudioOutput" |
| #include <mediaplayer2/MediaPlayer2AudioOutput.h> |
| |
| #include <cutils/properties.h> // for property_get |
| #include <utils/Log.h> |
| |
| #include <media/AudioPolicyHelper.h> |
| #include <media/AudioTrack.h> |
| #include <media/stagefright/foundation/ADebug.h> |
| |
| namespace { |
| |
| const float kMaxRequiredSpeed = 8.0f; // for PCM tracks allow up to 8x speedup. |
| |
| } // anonymous namespace |
| |
| namespace android { |
| |
| // TODO: Find real cause of Audio/Video delay in PV framework and remove this workaround |
| /* static */ int MediaPlayer2AudioOutput::mMinBufferCount = 4; |
| /* static */ bool MediaPlayer2AudioOutput::mIsOnEmulator = false; |
| |
| status_t MediaPlayer2AudioOutput::dump(int fd, const Vector<String16>& args) const { |
| const size_t SIZE = 256; |
| char buffer[SIZE]; |
| String8 result; |
| |
| result.append(" MediaPlayer2AudioOutput\n"); |
| snprintf(buffer, 255, " stream type(%d), left - right volume(%f, %f)\n", |
| mStreamType, mLeftVolume, mRightVolume); |
| result.append(buffer); |
| snprintf(buffer, 255, " msec per frame(%f), latency (%d)\n", |
| mMsecsPerFrame, (mTrack != 0) ? mTrack->latency() : -1); |
| result.append(buffer); |
| snprintf(buffer, 255, " aux effect id(%d), send level (%f)\n", |
| mAuxEffectId, mSendLevel); |
| result.append(buffer); |
| |
| ::write(fd, result.string(), result.size()); |
| if (mTrack != 0) { |
| mTrack->dump(fd, args); |
| } |
| return NO_ERROR; |
| } |
| |
| MediaPlayer2AudioOutput::MediaPlayer2AudioOutput(audio_session_t sessionId, uid_t uid, int pid, |
| const audio_attributes_t* attr, const sp<AudioSystem::AudioDeviceCallback>& deviceCallback) |
| : mCallback(NULL), |
| mCallbackCookie(NULL), |
| mCallbackData(NULL), |
| mStreamType(AUDIO_STREAM_MUSIC), |
| mLeftVolume(1.0), |
| mRightVolume(1.0), |
| mPlaybackRate(AUDIO_PLAYBACK_RATE_DEFAULT), |
| mSampleRateHz(0), |
| mMsecsPerFrame(0), |
| mFrameSize(0), |
| mSessionId(sessionId), |
| mUid(uid), |
| mPid(pid), |
| mSendLevel(0.0), |
| mAuxEffectId(0), |
| mFlags(AUDIO_OUTPUT_FLAG_NONE), |
| mSelectedDeviceId(AUDIO_PORT_HANDLE_NONE), |
| mRoutedDeviceId(AUDIO_PORT_HANDLE_NONE), |
| mDeviceCallbackEnabled(false), |
| mDeviceCallback(deviceCallback) { |
| ALOGV("MediaPlayer2AudioOutput(%d)", sessionId); |
| if (attr != NULL) { |
| mAttributes = (audio_attributes_t *) calloc(1, sizeof(audio_attributes_t)); |
| if (mAttributes != NULL) { |
| memcpy(mAttributes, attr, sizeof(audio_attributes_t)); |
| mStreamType = audio_attributes_to_stream_type(attr); |
| } |
| } else { |
| mAttributes = NULL; |
| } |
| |
| setMinBufferCount(); |
| } |
| |
| MediaPlayer2AudioOutput::~MediaPlayer2AudioOutput() { |
| close(); |
| free(mAttributes); |
| delete mCallbackData; |
| } |
| |
| //static |
| void MediaPlayer2AudioOutput::setMinBufferCount() { |
| char value[PROPERTY_VALUE_MAX]; |
| if (property_get("ro.kernel.qemu", value, 0)) { |
| mIsOnEmulator = true; |
| mMinBufferCount = 12; // to prevent systematic buffer underrun for emulator |
| } |
| } |
| |
| // static |
| bool MediaPlayer2AudioOutput::isOnEmulator() { |
| setMinBufferCount(); // benign race wrt other threads |
| return mIsOnEmulator; |
| } |
| |
| // static |
| int MediaPlayer2AudioOutput::getMinBufferCount() { |
| setMinBufferCount(); // benign race wrt other threads |
| return mMinBufferCount; |
| } |
| |
| ssize_t MediaPlayer2AudioOutput::bufferSize() const { |
| Mutex::Autolock lock(mLock); |
| if (mTrack == 0) { |
| return NO_INIT; |
| } |
| return mTrack->frameCount() * mFrameSize; |
| } |
| |
| ssize_t MediaPlayer2AudioOutput::frameCount() const { |
| Mutex::Autolock lock(mLock); |
| if (mTrack == 0) { |
| return NO_INIT; |
| } |
| return mTrack->frameCount(); |
| } |
| |
| ssize_t MediaPlayer2AudioOutput::channelCount() const { |
| Mutex::Autolock lock(mLock); |
| if (mTrack == 0) { |
| return NO_INIT; |
| } |
| return mTrack->channelCount(); |
| } |
| |
| ssize_t MediaPlayer2AudioOutput::frameSize() const { |
| Mutex::Autolock lock(mLock); |
| if (mTrack == 0) { |
| return NO_INIT; |
| } |
| return mFrameSize; |
| } |
| |
| uint32_t MediaPlayer2AudioOutput::latency () const { |
| Mutex::Autolock lock(mLock); |
| if (mTrack == 0) { |
| return 0; |
| } |
| return mTrack->latency(); |
| } |
| |
| float MediaPlayer2AudioOutput::msecsPerFrame() const { |
| Mutex::Autolock lock(mLock); |
| return mMsecsPerFrame; |
| } |
| |
| status_t MediaPlayer2AudioOutput::getPosition(uint32_t *position) const { |
| Mutex::Autolock lock(mLock); |
| if (mTrack == 0) { |
| return NO_INIT; |
| } |
| return mTrack->getPosition(position); |
| } |
| |
| status_t MediaPlayer2AudioOutput::getTimestamp(AudioTimestamp &ts) const { |
| Mutex::Autolock lock(mLock); |
| if (mTrack == 0) { |
| return NO_INIT; |
| } |
| return mTrack->getTimestamp(ts); |
| } |
| |
| // TODO: Remove unnecessary calls to getPlayedOutDurationUs() |
| // as it acquires locks and may query the audio driver. |
| // |
| // Some calls could conceivably retrieve extrapolated data instead of |
| // accessing getTimestamp() or getPosition() every time a data buffer with |
| // a media time is received. |
| // |
| // Calculate duration of played samples if played at normal rate (i.e., 1.0). |
| int64_t MediaPlayer2AudioOutput::getPlayedOutDurationUs(int64_t nowUs) const { |
| Mutex::Autolock lock(mLock); |
| if (mTrack == 0 || mSampleRateHz == 0) { |
| return 0; |
| } |
| |
| uint32_t numFramesPlayed; |
| int64_t numFramesPlayedAtUs; |
| AudioTimestamp ts; |
| |
| status_t res = mTrack->getTimestamp(ts); |
| if (res == OK) { // case 1: mixing audio tracks and offloaded tracks. |
| numFramesPlayed = ts.mPosition; |
| numFramesPlayedAtUs = ts.mTime.tv_sec * 1000000LL + ts.mTime.tv_nsec / 1000; |
| //ALOGD("getTimestamp: OK %d %lld", numFramesPlayed, (long long)numFramesPlayedAtUs); |
| } else if (res == WOULD_BLOCK) { // case 2: transitory state on start of a new track |
| numFramesPlayed = 0; |
| numFramesPlayedAtUs = nowUs; |
| //ALOGD("getTimestamp: WOULD_BLOCK %d %lld", |
| // numFramesPlayed, (long long)numFramesPlayedAtUs); |
| } else { // case 3: transitory at new track or audio fast tracks. |
| res = mTrack->getPosition(&numFramesPlayed); |
| CHECK_EQ(res, (status_t)OK); |
| numFramesPlayedAtUs = nowUs; |
| numFramesPlayedAtUs += 1000LL * mTrack->latency() / 2; /* XXX */ |
| //ALOGD("getPosition: %u %lld", numFramesPlayed, (long long)numFramesPlayedAtUs); |
| } |
| |
| // CHECK_EQ(numFramesPlayed & (1 << 31), 0); // can't be negative until 12.4 hrs, test |
| // TODO: remove the (int32_t) casting below as it may overflow at 12.4 hours. |
| int64_t durationUs = (int64_t)((int32_t)numFramesPlayed * 1000000LL / mSampleRateHz) |
| + nowUs - numFramesPlayedAtUs; |
| if (durationUs < 0) { |
| // Occurs when numFramesPlayed position is very small and the following: |
| // (1) In case 1, the time nowUs is computed before getTimestamp() is called and |
| // numFramesPlayedAtUs is greater than nowUs by time more than numFramesPlayed. |
| // (2) In case 3, using getPosition and adding mAudioSink->latency() to |
| // numFramesPlayedAtUs, by a time amount greater than numFramesPlayed. |
| // |
| // Both of these are transitory conditions. |
| ALOGV("getPlayedOutDurationUs: negative duration %lld set to zero", (long long)durationUs); |
| durationUs = 0; |
| } |
| ALOGV("getPlayedOutDurationUs(%lld) nowUs(%lld) frames(%u) framesAt(%lld)", |
| (long long)durationUs, (long long)nowUs, |
| numFramesPlayed, (long long)numFramesPlayedAtUs); |
| return durationUs; |
| } |
| |
| status_t MediaPlayer2AudioOutput::getFramesWritten(uint32_t *frameswritten) const { |
| Mutex::Autolock lock(mLock); |
| if (mTrack == 0) { |
| return NO_INIT; |
| } |
| ExtendedTimestamp ets; |
| status_t status = mTrack->getTimestamp(&ets); |
| if (status == OK || status == WOULD_BLOCK) { |
| *frameswritten = (uint32_t)ets.mPosition[ExtendedTimestamp::LOCATION_CLIENT]; |
| } |
| return status; |
| } |
| |
| status_t MediaPlayer2AudioOutput::setParameters(const String8& keyValuePairs) { |
| Mutex::Autolock lock(mLock); |
| if (mTrack == 0) { |
| return NO_INIT; |
| } |
| return mTrack->setParameters(keyValuePairs); |
| } |
| |
| String8 MediaPlayer2AudioOutput::getParameters(const String8& keys) { |
| Mutex::Autolock lock(mLock); |
| if (mTrack == 0) { |
| return String8::empty(); |
| } |
| return mTrack->getParameters(keys); |
| } |
| |
| void MediaPlayer2AudioOutput::setAudioAttributes(const audio_attributes_t * attributes) { |
| Mutex::Autolock lock(mLock); |
| if (attributes == NULL) { |
| free(mAttributes); |
| mAttributes = NULL; |
| } else { |
| if (mAttributes == NULL) { |
| mAttributes = (audio_attributes_t *) calloc(1, sizeof(audio_attributes_t)); |
| } |
| memcpy(mAttributes, attributes, sizeof(audio_attributes_t)); |
| mStreamType = audio_attributes_to_stream_type(attributes); |
| } |
| } |
| |
| void MediaPlayer2AudioOutput::setAudioStreamType(audio_stream_type_t streamType) { |
| Mutex::Autolock lock(mLock); |
| // do not allow direct stream type modification if attributes have been set |
| if (mAttributes == NULL) { |
| mStreamType = streamType; |
| } |
| } |
| |
| void MediaPlayer2AudioOutput::close_l() { |
| mTrack.clear(); |
| } |
| |
| status_t MediaPlayer2AudioOutput::open( |
| uint32_t sampleRate, int channelCount, audio_channel_mask_t channelMask, |
| audio_format_t format, int bufferCount, |
| AudioCallback cb, void *cookie, |
| audio_output_flags_t flags, |
| const audio_offload_info_t *offloadInfo, |
| bool doNotReconnect, |
| uint32_t suggestedFrameCount) { |
| ALOGV("open(%u, %d, 0x%x, 0x%x, %d, %d 0x%x)", sampleRate, channelCount, channelMask, |
| format, bufferCount, mSessionId, flags); |
| |
| // offloading is only supported in callback mode for now. |
| // offloadInfo must be present if offload flag is set |
| if (((flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) != 0) && |
| ((cb == NULL) || (offloadInfo == NULL))) { |
| return BAD_VALUE; |
| } |
| |
| // compute frame count for the AudioTrack internal buffer |
| size_t frameCount; |
| if ((flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) != 0) { |
| frameCount = 0; // AudioTrack will get frame count from AudioFlinger |
| } else { |
| // try to estimate the buffer processing fetch size from AudioFlinger. |
| // framesPerBuffer is approximate and generally correct, except when it's not :-). |
| uint32_t afSampleRate; |
| size_t afFrameCount; |
| if (AudioSystem::getOutputFrameCount(&afFrameCount, mStreamType) != NO_ERROR) { |
| return NO_INIT; |
| } |
| if (AudioSystem::getOutputSamplingRate(&afSampleRate, mStreamType) != NO_ERROR) { |
| return NO_INIT; |
| } |
| const size_t framesPerBuffer = |
| (unsigned long long)sampleRate * afFrameCount / afSampleRate; |
| |
| if (bufferCount == 0) { |
| // use suggestedFrameCount |
| bufferCount = (suggestedFrameCount + framesPerBuffer - 1) / framesPerBuffer; |
| } |
| // Check argument bufferCount against the mininum buffer count |
| if (bufferCount != 0 && bufferCount < mMinBufferCount) { |
| ALOGV("bufferCount (%d) increased to %d", bufferCount, mMinBufferCount); |
| bufferCount = mMinBufferCount; |
| } |
| // if frameCount is 0, then AudioTrack will get frame count from AudioFlinger |
| // which will be the minimum size permitted. |
| frameCount = bufferCount * framesPerBuffer; |
| } |
| |
| if (channelMask == CHANNEL_MASK_USE_CHANNEL_ORDER) { |
| channelMask = audio_channel_out_mask_from_count(channelCount); |
| if (0 == channelMask) { |
| ALOGE("open() error, can\'t derive mask for %d audio channels", channelCount); |
| return NO_INIT; |
| } |
| } |
| |
| Mutex::Autolock lock(mLock); |
| mCallback = cb; |
| mCallbackCookie = cookie; |
| |
| sp<AudioTrack> t; |
| CallbackData *newcbd = NULL; |
| |
| ALOGV("creating new AudioTrack"); |
| |
| if (mCallback != NULL) { |
| newcbd = new CallbackData(this); |
| t = new AudioTrack( |
| mStreamType, |
| sampleRate, |
| format, |
| channelMask, |
| frameCount, |
| flags, |
| CallbackWrapper, |
| newcbd, |
| 0, // notification frames |
| mSessionId, |
| AudioTrack::TRANSFER_CALLBACK, |
| offloadInfo, |
| mUid, |
| mPid, |
| mAttributes, |
| doNotReconnect, |
| 1.0f, // default value for maxRequiredSpeed |
| mSelectedDeviceId); |
| } else { |
| // TODO: Due to buffer memory concerns, we use a max target playback speed |
| // based on mPlaybackRate at the time of open (instead of kMaxRequiredSpeed), |
| // also clamping the target speed to 1.0 <= targetSpeed <= kMaxRequiredSpeed. |
| const float targetSpeed = |
| std::min(std::max(mPlaybackRate.mSpeed, 1.0f), kMaxRequiredSpeed); |
| ALOGW_IF(targetSpeed != mPlaybackRate.mSpeed, |
| "track target speed:%f clamped from playback speed:%f", |
| targetSpeed, mPlaybackRate.mSpeed); |
| t = new AudioTrack( |
| mStreamType, |
| sampleRate, |
| format, |
| channelMask, |
| frameCount, |
| flags, |
| NULL, // callback |
| NULL, // user data |
| 0, // notification frames |
| mSessionId, |
| AudioTrack::TRANSFER_DEFAULT, |
| NULL, // offload info |
| mUid, |
| mPid, |
| mAttributes, |
| doNotReconnect, |
| targetSpeed, |
| mSelectedDeviceId); |
| } |
| |
| if ((t == 0) || (t->initCheck() != NO_ERROR)) { |
| ALOGE("Unable to create audio track"); |
| delete newcbd; |
| // t goes out of scope, so reference count drops to zero |
| return NO_INIT; |
| } else { |
| // successful AudioTrack initialization implies a legacy stream type was generated |
| // from the audio attributes |
| mStreamType = t->streamType(); |
| } |
| |
| CHECK((t != NULL) && ((mCallback == NULL) || (newcbd != NULL))); |
| |
| mCallbackData = newcbd; |
| ALOGV("setVolume"); |
| t->setVolume(mLeftVolume, mRightVolume); |
| |
| mSampleRateHz = sampleRate; |
| mFlags = flags; |
| mMsecsPerFrame = 1E3f / (mPlaybackRate.mSpeed * sampleRate); |
| mFrameSize = t->frameSize(); |
| mTrack = t; |
| |
| return updateTrack_l(); |
| } |
| |
| status_t MediaPlayer2AudioOutput::updateTrack_l() { |
| if (mTrack == NULL) { |
| return NO_ERROR; |
| } |
| |
| status_t res = NO_ERROR; |
| // Note some output devices may give us a direct track even though we don't specify it. |
| // Example: Line application b/17459982. |
| if ((mTrack->getFlags() |
| & (AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD | AUDIO_OUTPUT_FLAG_DIRECT)) == 0) { |
| res = mTrack->setPlaybackRate(mPlaybackRate); |
| if (res == NO_ERROR) { |
| mTrack->setAuxEffectSendLevel(mSendLevel); |
| res = mTrack->attachAuxEffect(mAuxEffectId); |
| } |
| } |
| mTrack->setOutputDevice(mSelectedDeviceId); |
| if (mDeviceCallbackEnabled) { |
| mTrack->addAudioDeviceCallback(mDeviceCallback.promote()); |
| } |
| ALOGV("updateTrack_l() DONE status %d", res); |
| return res; |
| } |
| |
| status_t MediaPlayer2AudioOutput::start() { |
| ALOGV("start"); |
| Mutex::Autolock lock(mLock); |
| if (mCallbackData != NULL) { |
| mCallbackData->endTrackSwitch(); |
| } |
| if (mTrack != 0) { |
| mTrack->setVolume(mLeftVolume, mRightVolume); |
| mTrack->setAuxEffectSendLevel(mSendLevel); |
| status_t status = mTrack->start(); |
| return status; |
| } |
| return NO_INIT; |
| } |
| |
| ssize_t MediaPlayer2AudioOutput::write(const void* buffer, size_t size, bool blocking) { |
| Mutex::Autolock lock(mLock); |
| LOG_ALWAYS_FATAL_IF(mCallback != NULL, "Don't call write if supplying a callback."); |
| |
| //ALOGV("write(%p, %u)", buffer, size); |
| if (mTrack != 0) { |
| return mTrack->write(buffer, size, blocking); |
| } |
| return NO_INIT; |
| } |
| |
| void MediaPlayer2AudioOutput::stop() { |
| ALOGV("stop"); |
| Mutex::Autolock lock(mLock); |
| if (mTrack != 0) { |
| mTrack->stop(); |
| } |
| } |
| |
| void MediaPlayer2AudioOutput::flush() { |
| ALOGV("flush"); |
| Mutex::Autolock lock(mLock); |
| if (mTrack != 0) { |
| mTrack->flush(); |
| } |
| } |
| |
| void MediaPlayer2AudioOutput::pause() { |
| ALOGV("pause"); |
| Mutex::Autolock lock(mLock); |
| if (mTrack != 0) { |
| mTrack->pause(); |
| } |
| } |
| |
| void MediaPlayer2AudioOutput::close() { |
| ALOGV("close"); |
| sp<AudioTrack> track; |
| { |
| Mutex::Autolock lock(mLock); |
| track = mTrack; |
| close_l(); // clears mTrack |
| } |
| // destruction of the track occurs outside of mutex. |
| } |
| |
| void MediaPlayer2AudioOutput::setVolume(float left, float right) { |
| ALOGV("setVolume(%f, %f)", left, right); |
| Mutex::Autolock lock(mLock); |
| mLeftVolume = left; |
| mRightVolume = right; |
| if (mTrack != 0) { |
| mTrack->setVolume(left, right); |
| } |
| } |
| |
| status_t MediaPlayer2AudioOutput::setPlaybackRate(const AudioPlaybackRate &rate) { |
| ALOGV("setPlaybackRate(%f %f %d %d)", |
| rate.mSpeed, rate.mPitch, rate.mFallbackMode, rate.mStretchMode); |
| Mutex::Autolock lock(mLock); |
| if (mTrack == 0) { |
| // remember rate so that we can set it when the track is opened |
| mPlaybackRate = rate; |
| return OK; |
| } |
| status_t res = mTrack->setPlaybackRate(rate); |
| if (res != NO_ERROR) { |
| return res; |
| } |
| // rate.mSpeed is always greater than 0 if setPlaybackRate succeeded |
| CHECK_GT(rate.mSpeed, 0.f); |
| mPlaybackRate = rate; |
| if (mSampleRateHz != 0) { |
| mMsecsPerFrame = 1E3f / (rate.mSpeed * mSampleRateHz); |
| } |
| return res; |
| } |
| |
| status_t MediaPlayer2AudioOutput::getPlaybackRate(AudioPlaybackRate *rate) { |
| ALOGV("setPlaybackRate"); |
| Mutex::Autolock lock(mLock); |
| if (mTrack == 0) { |
| return NO_INIT; |
| } |
| *rate = mTrack->getPlaybackRate(); |
| return NO_ERROR; |
| } |
| |
| status_t MediaPlayer2AudioOutput::setAuxEffectSendLevel(float level) { |
| ALOGV("setAuxEffectSendLevel(%f)", level); |
| Mutex::Autolock lock(mLock); |
| mSendLevel = level; |
| if (mTrack != 0) { |
| return mTrack->setAuxEffectSendLevel(level); |
| } |
| return NO_ERROR; |
| } |
| |
| status_t MediaPlayer2AudioOutput::attachAuxEffect(int effectId) { |
| ALOGV("attachAuxEffect(%d)", effectId); |
| Mutex::Autolock lock(mLock); |
| mAuxEffectId = effectId; |
| if (mTrack != 0) { |
| return mTrack->attachAuxEffect(effectId); |
| } |
| return NO_ERROR; |
| } |
| |
| status_t MediaPlayer2AudioOutput::setOutputDevice(audio_port_handle_t deviceId) { |
| ALOGV("setOutputDevice(%d)", deviceId); |
| Mutex::Autolock lock(mLock); |
| mSelectedDeviceId = deviceId; |
| if (mTrack != 0) { |
| return mTrack->setOutputDevice(deviceId); |
| } |
| return NO_ERROR; |
| } |
| |
| status_t MediaPlayer2AudioOutput::getRoutedDeviceId(audio_port_handle_t* deviceId) { |
| ALOGV("getRoutedDeviceId"); |
| Mutex::Autolock lock(mLock); |
| if (mTrack != 0) { |
| mRoutedDeviceId = mTrack->getRoutedDeviceId(); |
| } |
| *deviceId = mRoutedDeviceId; |
| return NO_ERROR; |
| } |
| |
| status_t MediaPlayer2AudioOutput::enableAudioDeviceCallback(bool enabled) { |
| ALOGV("enableAudioDeviceCallback, %d", enabled); |
| Mutex::Autolock lock(mLock); |
| mDeviceCallbackEnabled = enabled; |
| if (mTrack != 0) { |
| status_t status; |
| if (enabled) { |
| status = mTrack->addAudioDeviceCallback(mDeviceCallback.promote()); |
| } else { |
| status = mTrack->removeAudioDeviceCallback(mDeviceCallback.promote()); |
| } |
| return status; |
| } |
| return NO_ERROR; |
| } |
| |
| // static |
| void MediaPlayer2AudioOutput::CallbackWrapper( |
| int event, void *cookie, void *info) { |
| //ALOGV("callbackwrapper"); |
| CallbackData *data = (CallbackData*)cookie; |
| // lock to ensure we aren't caught in the middle of a track switch. |
| data->lock(); |
| MediaPlayer2AudioOutput *me = data->getOutput(); |
| AudioTrack::Buffer *buffer = (AudioTrack::Buffer *)info; |
| if (me == NULL) { |
| // no output set, likely because the track was scheduled to be reused |
| // by another player, but the format turned out to be incompatible. |
| data->unlock(); |
| if (buffer != NULL) { |
| buffer->size = 0; |
| } |
| return; |
| } |
| |
| switch(event) { |
| case AudioTrack::EVENT_MORE_DATA: { |
| size_t actualSize = (*me->mCallback)( |
| me, buffer->raw, buffer->size, me->mCallbackCookie, |
| CB_EVENT_FILL_BUFFER); |
| |
| // Log when no data is returned from the callback. |
| // (1) We may have no data (especially with network streaming sources). |
| // (2) We may have reached the EOS and the audio track is not stopped yet. |
| // Note that AwesomePlayer/AudioPlayer will only return zero size when it reaches the EOS. |
| // NuPlayer2Renderer will return zero when it doesn't have data (it doesn't block to fill). |
| // |
| // This is a benign busy-wait, with the next data request generated 10 ms or more later; |
| // nevertheless for power reasons, we don't want to see too many of these. |
| |
| ALOGV_IF(actualSize == 0 && buffer->size > 0, "callbackwrapper: empty buffer returned"); |
| |
| buffer->size = actualSize; |
| } break; |
| |
| case AudioTrack::EVENT_STREAM_END: |
| // currently only occurs for offloaded callbacks |
| ALOGV("callbackwrapper: deliver EVENT_STREAM_END"); |
| (*me->mCallback)(me, NULL /* buffer */, 0 /* size */, |
| me->mCallbackCookie, CB_EVENT_STREAM_END); |
| break; |
| |
| case AudioTrack::EVENT_NEW_IAUDIOTRACK : |
| ALOGV("callbackwrapper: deliver EVENT_TEAR_DOWN"); |
| (*me->mCallback)(me, NULL /* buffer */, 0 /* size */, |
| me->mCallbackCookie, CB_EVENT_TEAR_DOWN); |
| break; |
| |
| case AudioTrack::EVENT_UNDERRUN: |
| // This occurs when there is no data available, typically |
| // when there is a failure to supply data to the AudioTrack. It can also |
| // occur in non-offloaded mode when the audio device comes out of standby. |
| // |
| // If an AudioTrack underruns it outputs silence. Since this happens suddenly |
| // it may sound like an audible pop or glitch. |
| // |
| // The underrun event is sent once per track underrun; the condition is reset |
| // when more data is sent to the AudioTrack. |
| ALOGD("callbackwrapper: EVENT_UNDERRUN (discarded)"); |
| break; |
| |
| default: |
| ALOGE("received unknown event type: %d inside CallbackWrapper !", event); |
| } |
| |
| data->unlock(); |
| } |
| |
| audio_session_t MediaPlayer2AudioOutput::getSessionId() const |
| { |
| Mutex::Autolock lock(mLock); |
| return mSessionId; |
| } |
| |
| uint32_t MediaPlayer2AudioOutput::getSampleRate() const |
| { |
| Mutex::Autolock lock(mLock); |
| if (mTrack == 0) { |
| return 0; |
| } |
| return mTrack->getSampleRate(); |
| } |
| |
| int64_t MediaPlayer2AudioOutput::getBufferDurationInUs() const |
| { |
| Mutex::Autolock lock(mLock); |
| if (mTrack == 0) { |
| return 0; |
| } |
| int64_t duration; |
| if (mTrack->getBufferDurationInUs(&duration) != OK) { |
| return 0; |
| } |
| return duration; |
| } |
| |
| } // namespace android |
