media/libstagefright/AudioPlayer.cpp - platform/frameworks/base - Git at Google

 /*
  * Copyright (C) 2009 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 "AudioPlayer"
 #include <utils/Log.h>

 #include <binder/IPCThreadState.h>
 #include <media/AudioTrack.h>
 #include <media/stagefright/AudioPlayer.h>
 #include <media/stagefright/MediaDebug.h>
 #include <media/stagefright/MediaDefs.h>
 #include <media/stagefright/MediaSource.h>
 #include <media/stagefright/MetaData.h>

 namespace android {

 AudioPlayer::AudioPlayer(const sp<MediaPlayerBase::AudioSink> &audioSink)
     : mAudioTrack(NULL),
       mInputBuffer(NULL),
       mSampleRate(0),
       mLatencyUs(0),
       mFrameSize(0),
       mNumFramesPlayed(0),
       mPositionTimeMediaUs(-1),
       mPositionTimeRealUs(-1),
       mSeeking(false),
       mReachedEOS(false),
       mFinalStatus(OK),
       mStarted(false),
       mAudioSink(audioSink) {
 }

 AudioPlayer::~AudioPlayer() {
     if (mStarted) {
         stop();
     }
 }

 void AudioPlayer::setSource(const sp<MediaSource> &source) {
     CHECK_EQ(mSource, NULL);
     mSource = source;
 }

 status_t AudioPlayer::start(bool sourceAlreadyStarted) {
     CHECK(!mStarted);
     CHECK(mSource != NULL);

     status_t err;
     if (!sourceAlreadyStarted) {
         err = mSource->start();

         if (err != OK) {
             return err;
         }
     }

     sp<MetaData> format = mSource->getFormat();
     const char *mime;
     bool success = format->findCString(kKeyMIMEType, &mime);
     CHECK(success);
     CHECK(!strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_RAW));

     success = format->findInt32(kKeySampleRate, &mSampleRate);
     CHECK(success);

     int32_t numChannels;
     success = format->findInt32(kKeyChannelCount, &numChannels);
     CHECK(success);

     if (mAudioSink.get() != NULL) {
         status_t err = mAudioSink->open(
                 mSampleRate, numChannels, AudioSystem::PCM_16_BIT,
                 DEFAULT_AUDIOSINK_BUFFERCOUNT,
                 &AudioPlayer::AudioSinkCallback, this);
         if (err != OK) {
             if (!sourceAlreadyStarted) {
                 mSource->stop();
             }

             return err;
         }

         mLatencyUs = (int64_t)mAudioSink->latency() * 1000;
         mFrameSize = mAudioSink->frameSize();

         mAudioSink->start();
     } else {
         mAudioTrack = new AudioTrack(
                 AudioSystem::MUSIC, mSampleRate, AudioSystem::PCM_16_BIT,
                 (numChannels == 2)
                     ? AudioSystem::CHANNEL_OUT_STEREO
                     : AudioSystem::CHANNEL_OUT_MONO,
                 0, 0, &AudioCallback, this, 0);

         if ((err = mAudioTrack->initCheck()) != OK) {
             delete mAudioTrack;
             mAudioTrack = NULL;

             if (!sourceAlreadyStarted) {
                 mSource->stop();
             }

             return err;
         }

         mLatencyUs = (int64_t)mAudioTrack->latency() * 1000;
         mFrameSize = mAudioTrack->frameSize();

         mAudioTrack->start();
     }

     mStarted = true;

     return OK;
 }

 void AudioPlayer::pause() {
     CHECK(mStarted);

     if (mAudioSink.get() != NULL) {
         mAudioSink->pause();
     } else {
         mAudioTrack->stop();
     }
 }

 void AudioPlayer::resume() {
     CHECK(mStarted);

     if (mAudioSink.get() != NULL) {
         mAudioSink->start();
     } else {
         mAudioTrack->start();
     }
 }

 void AudioPlayer::stop() {
     CHECK(mStarted);

     if (mAudioSink.get() != NULL) {
         mAudioSink->stop();
         mAudioSink->close();
     } else {
         mAudioTrack->stop();

         delete mAudioTrack;
         mAudioTrack = NULL;
     }

     // Make sure to release any buffer we hold onto so that the
     // source is able to stop().
     if (mInputBuffer != NULL) {
         LOGV("AudioPlayer releasing input buffer.");

         mInputBuffer->release();
         mInputBuffer = NULL;
     }

     mSource->stop();

     // The following hack is necessary to ensure that the OMX
     // component is completely released by the time we may try
     // to instantiate it again.
     wp<MediaSource> tmp = mSource;
     mSource.clear();
     while (tmp.promote() != NULL) {
         usleep(1000);
     }
     IPCThreadState::self()->flushCommands();

     mNumFramesPlayed = 0;
     mPositionTimeMediaUs = -1;
     mPositionTimeRealUs = -1;
     mSeeking = false;
     mReachedEOS = false;
     mFinalStatus = OK;
     mStarted = false;
 }

 // static
 void AudioPlayer::AudioCallback(int event, void *user, void *info) {
     static_cast<AudioPlayer *>(user)->AudioCallback(event, info);
 }

 bool AudioPlayer::isSeeking() {
     Mutex::Autolock autoLock(mLock);
     return mSeeking;
 }

 bool AudioPlayer::reachedEOS(status_t *finalStatus) {
     *finalStatus = OK;

     Mutex::Autolock autoLock(mLock);
     *finalStatus = mFinalStatus;
     return mReachedEOS;
 }

 // static
 size_t AudioPlayer::AudioSinkCallback(
         MediaPlayerBase::AudioSink *audioSink,
         void *buffer, size_t size, void *cookie) {
     AudioPlayer *me = (AudioPlayer *)cookie;

     return me->fillBuffer(buffer, size);
 }

 void AudioPlayer::AudioCallback(int event, void *info) {
     if (event != AudioTrack::EVENT_MORE_DATA) {
         return;
     }

     AudioTrack::Buffer *buffer = (AudioTrack::Buffer *)info;
     size_t numBytesWritten = fillBuffer(buffer->raw, buffer->size);

     buffer->size = numBytesWritten;
 }

 size_t AudioPlayer::fillBuffer(void *data, size_t size) {
     if (mNumFramesPlayed == 0) {
         LOGV("AudioCallback");
     }

     if (mReachedEOS) {
         return 0;
     }

     size_t size_done = 0;
     size_t size_remaining = size;
     while (size_remaining > 0) {
         MediaSource::ReadOptions options;

         {
             Mutex::Autolock autoLock(mLock);

             if (mSeeking) {
                 options.setSeekTo(mSeekTimeUs);

                 if (mInputBuffer != NULL) {
                     mInputBuffer->release();
                     mInputBuffer = NULL;
                 }

                 mSeeking = false;
             }
         }

         if (mInputBuffer == NULL) {
             status_t err = mSource->read(&mInputBuffer, &options);

             CHECK((err == OK && mInputBuffer != NULL)
                    || (err != OK && mInputBuffer == NULL));

             Mutex::Autolock autoLock(mLock);

             if (err != OK) {
                 mReachedEOS = true;
                 mFinalStatus = err;
                 break;
             }

             CHECK(mInputBuffer->meta_data()->findInt64(
                         kKeyTime, &mPositionTimeMediaUs));

             mPositionTimeRealUs =
                 ((mNumFramesPlayed + size_done / mFrameSize) * 1000000)
                     / mSampleRate;

             LOGV("buffer->size() = %d, "
                  "mPositionTimeMediaUs=%.2f mPositionTimeRealUs=%.2f",
                  mInputBuffer->range_length(),
                  mPositionTimeMediaUs / 1E6, mPositionTimeRealUs / 1E6);
         }

         if (mInputBuffer->range_length() == 0) {
             mInputBuffer->release();
             mInputBuffer = NULL;

             continue;
         }

         size_t copy = size_remaining;
         if (copy > mInputBuffer->range_length()) {
             copy = mInputBuffer->range_length();
         }

         memcpy((char *)data + size_done,
                (const char *)mInputBuffer->data() + mInputBuffer->range_offset(),
                copy);

         mInputBuffer->set_range(mInputBuffer->range_offset() + copy,
                                 mInputBuffer->range_length() - copy);

         size_done += copy;
         size_remaining -= copy;
     }

     Mutex::Autolock autoLock(mLock);
     mNumFramesPlayed += size_done / mFrameSize;

     return size_done;
 }

 int64_t AudioPlayer::getRealTimeUs() {
     Mutex::Autolock autoLock(mLock);
     return getRealTimeUsLocked();
 }

 int64_t AudioPlayer::getRealTimeUsLocked() const {
     return -mLatencyUs + (mNumFramesPlayed * 1000000) / mSampleRate;
 }

 int64_t AudioPlayer::getMediaTimeUs() {
     Mutex::Autolock autoLock(mLock);

     if (mPositionTimeMediaUs < 0 || mPositionTimeRealUs < 0) {
         return 0;
     }

     int64_t realTimeOffset = getRealTimeUsLocked() - mPositionTimeRealUs;
     if (realTimeOffset < 0) {
         realTimeOffset = 0;
     }

     return mPositionTimeMediaUs + realTimeOffset;
 }

 bool AudioPlayer::getMediaTimeMapping(
         int64_t *realtime_us, int64_t *mediatime_us) {
     Mutex::Autolock autoLock(mLock);

     *realtime_us = mPositionTimeRealUs;
     *mediatime_us = mPositionTimeMediaUs;

     return mPositionTimeRealUs != -1 && mPositionTimeMediaUs != -1;
 }

 status_t AudioPlayer::seekTo(int64_t time_us) {
     Mutex::Autolock autoLock(mLock);

     mSeeking = true;
     mReachedEOS = false;
     mSeekTimeUs = time_us;

     return OK;
 }

 }
	/*
	* Copyright (C) 2009 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 "AudioPlayer"
	#include <utils/Log.h>

	#include <binder/IPCThreadState.h>
	#include <media/AudioTrack.h>
	#include <media/stagefright/AudioPlayer.h>
	#include <media/stagefright/MediaDebug.h>
	#include <media/stagefright/MediaDefs.h>
	#include <media/stagefright/MediaSource.h>
	#include <media/stagefright/MetaData.h>

	namespace android {

	AudioPlayer::AudioPlayer(const sp<MediaPlayerBase::AudioSink> &audioSink)
	: mAudioTrack(NULL),
	mInputBuffer(NULL),
	mSampleRate(0),
	mLatencyUs(0),
	mFrameSize(0),
	mNumFramesPlayed(0),
	mPositionTimeMediaUs(-1),
	mPositionTimeRealUs(-1),
	mSeeking(false),
	mReachedEOS(false),
	mFinalStatus(OK),
	mStarted(false),
	mAudioSink(audioSink) {
	}

	AudioPlayer::~AudioPlayer() {
	if (mStarted) {
	stop();
	}
	}

	void AudioPlayer::setSource(const sp<MediaSource> &source) {
	CHECK_EQ(mSource, NULL);
	mSource = source;
	}

	status_t AudioPlayer::start(bool sourceAlreadyStarted) {
	CHECK(!mStarted);
	CHECK(mSource != NULL);

	status_t err;
	if (!sourceAlreadyStarted) {
	err = mSource->start();

	if (err != OK) {
	return err;
	}
	}

	sp<MetaData> format = mSource->getFormat();
	const char *mime;
	bool success = format->findCString(kKeyMIMEType, &mime);
	CHECK(success);
	CHECK(!strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_RAW));

	success = format->findInt32(kKeySampleRate, &mSampleRate);
	CHECK(success);

	int32_t numChannels;
	success = format->findInt32(kKeyChannelCount, &numChannels);
	CHECK(success);

	if (mAudioSink.get() != NULL) {
	status_t err = mAudioSink->open(
	mSampleRate, numChannels, AudioSystem::PCM_16_BIT,
	DEFAULT_AUDIOSINK_BUFFERCOUNT,
	&AudioPlayer::AudioSinkCallback, this);
	if (err != OK) {
	if (!sourceAlreadyStarted) {
	mSource->stop();
	}

	return err;
	}

	mLatencyUs = (int64_t)mAudioSink->latency() * 1000;
	mFrameSize = mAudioSink->frameSize();

	mAudioSink->start();
	} else {
	mAudioTrack = new AudioTrack(
	AudioSystem::MUSIC, mSampleRate, AudioSystem::PCM_16_BIT,
	(numChannels == 2)
	? AudioSystem::CHANNEL_OUT_STEREO
	: AudioSystem::CHANNEL_OUT_MONO,
	0, 0, &AudioCallback, this, 0);

	if ((err = mAudioTrack->initCheck()) != OK) {
	delete mAudioTrack;
	mAudioTrack = NULL;

	if (!sourceAlreadyStarted) {
	mSource->stop();
	}

	return err;
	}

	mLatencyUs = (int64_t)mAudioTrack->latency() * 1000;
	mFrameSize = mAudioTrack->frameSize();

	mAudioTrack->start();
	}

	mStarted = true;

	return OK;
	}

	void AudioPlayer::pause() {
	CHECK(mStarted);

	if (mAudioSink.get() != NULL) {
	mAudioSink->pause();
	} else {
	mAudioTrack->stop();
	}
	}

	void AudioPlayer::resume() {
	CHECK(mStarted);

	if (mAudioSink.get() != NULL) {
	mAudioSink->start();
	} else {
	mAudioTrack->start();
	}
	}

	void AudioPlayer::stop() {
	CHECK(mStarted);

	if (mAudioSink.get() != NULL) {
	mAudioSink->stop();
	mAudioSink->close();
	} else {
	mAudioTrack->stop();

	delete mAudioTrack;
	mAudioTrack = NULL;
	}

	// Make sure to release any buffer we hold onto so that the
	// source is able to stop().
	if (mInputBuffer != NULL) {
	LOGV("AudioPlayer releasing input buffer.");

	mInputBuffer->release();
	mInputBuffer = NULL;
	}

	mSource->stop();

	// The following hack is necessary to ensure that the OMX
	// component is completely released by the time we may try
	// to instantiate it again.
	wp<MediaSource> tmp = mSource;
	mSource.clear();
	while (tmp.promote() != NULL) {
	usleep(1000);
	}
	IPCThreadState::self()->flushCommands();

	mNumFramesPlayed = 0;
	mPositionTimeMediaUs = -1;
	mPositionTimeRealUs = -1;
	mSeeking = false;
	mReachedEOS = false;
	mFinalStatus = OK;
	mStarted = false;
	}

	// static
	void AudioPlayer::AudioCallback(int event, void user, void info) {
	static_cast<AudioPlayer *>(user)->AudioCallback(event, info);
	}

	bool AudioPlayer::isSeeking() {
	Mutex::Autolock autoLock(mLock);
	return mSeeking;
	}

	bool AudioPlayer::reachedEOS(status_t *finalStatus) {
	*finalStatus = OK;

	Mutex::Autolock autoLock(mLock);
	*finalStatus = mFinalStatus;
	return mReachedEOS;
	}

	// static
	size_t AudioPlayer::AudioSinkCallback(
	MediaPlayerBase::AudioSink *audioSink,
	void buffer, size_t size, void cookie) {
	AudioPlayer me = (AudioPlayer )cookie;

	return me->fillBuffer(buffer, size);
	}

	void AudioPlayer::AudioCallback(int event, void *info) {
	if (event != AudioTrack::EVENT_MORE_DATA) {
	return;
	}

	AudioTrack::Buffer buffer = (AudioTrack::Buffer )info;
	size_t numBytesWritten = fillBuffer(buffer->raw, buffer->size);

	buffer->size = numBytesWritten;
	}

	size_t AudioPlayer::fillBuffer(void *data, size_t size) {
	if (mNumFramesPlayed == 0) {
	LOGV("AudioCallback");
	}

	if (mReachedEOS) {
	return 0;
	}

	size_t size_done = 0;
	size_t size_remaining = size;
	while (size_remaining > 0) {
	MediaSource::ReadOptions options;

	{
	Mutex::Autolock autoLock(mLock);

	if (mSeeking) {
	options.setSeekTo(mSeekTimeUs);

	if (mInputBuffer != NULL) {
	mInputBuffer->release();
	mInputBuffer = NULL;
	}

	mSeeking = false;
	}
	}

	if (mInputBuffer == NULL) {
	status_t err = mSource->read(&mInputBuffer, &options);

	CHECK((err == OK && mInputBuffer != NULL)
	\|\| (err != OK && mInputBuffer == NULL));

	Mutex::Autolock autoLock(mLock);

	if (err != OK) {
	mReachedEOS = true;
	mFinalStatus = err;
	break;
	}

	CHECK(mInputBuffer->meta_data()->findInt64(
	kKeyTime, &mPositionTimeMediaUs));

	mPositionTimeRealUs =
	((mNumFramesPlayed + size_done / mFrameSize) * 1000000)
	/ mSampleRate;

	LOGV("buffer->size() = %d, "
	"mPositionTimeMediaUs=%.2f mPositionTimeRealUs=%.2f",
	mInputBuffer->range_length(),
	mPositionTimeMediaUs / 1E6, mPositionTimeRealUs / 1E6);
	}

	if (mInputBuffer->range_length() == 0) {
	mInputBuffer->release();
	mInputBuffer = NULL;

	continue;
	}

	size_t copy = size_remaining;
	if (copy > mInputBuffer->range_length()) {
	copy = mInputBuffer->range_length();
	}

	memcpy((char *)data + size_done,
	(const char *)mInputBuffer->data() + mInputBuffer->range_offset(),
	copy);

	mInputBuffer->set_range(mInputBuffer->range_offset() + copy,
	mInputBuffer->range_length() - copy);

	size_done += copy;
	size_remaining -= copy;
	}

	Mutex::Autolock autoLock(mLock);
	mNumFramesPlayed += size_done / mFrameSize;

	return size_done;
	}

	int64_t AudioPlayer::getRealTimeUs() {
	Mutex::Autolock autoLock(mLock);
	return getRealTimeUsLocked();
	}

	int64_t AudioPlayer::getRealTimeUsLocked() const {
	return -mLatencyUs + (mNumFramesPlayed * 1000000) / mSampleRate;
	}

	int64_t AudioPlayer::getMediaTimeUs() {
	Mutex::Autolock autoLock(mLock);

	if (mPositionTimeMediaUs < 0 \|\| mPositionTimeRealUs < 0) {
	return 0;
	}

	int64_t realTimeOffset = getRealTimeUsLocked() - mPositionTimeRealUs;
	if (realTimeOffset < 0) {
	realTimeOffset = 0;
	}

	return mPositionTimeMediaUs + realTimeOffset;
	}

	bool AudioPlayer::getMediaTimeMapping(
	int64_t realtime_us, int64_t mediatime_us) {
	Mutex::Autolock autoLock(mLock);

	*realtime_us = mPositionTimeRealUs;
	*mediatime_us = mPositionTimeMediaUs;

	return mPositionTimeRealUs != -1 && mPositionTimeMediaUs != -1;
	}

	status_t AudioPlayer::seekTo(int64_t time_us) {
	Mutex::Autolock autoLock(mLock);

	mSeeking = true;
	mReachedEOS = false;
	mSeekTimeUs = time_us;

	return OK;
	}

	}