Move JetPlayer to JNI (1e7d2e99) · Commits · e / os / android_frameworks_av

media/libmedia/Android.bp

+0 −2

Original line number	Original line	Diff line number	Diff line
	@@ -288,7 +288,6 @@ cc_library {
	"IMediaMetadataRetriever.cpp",		"IMediaMetadataRetriever.cpp",
	"mediametadataretriever.cpp",		"mediametadataretriever.cpp",
	"MidiDeviceInfo.cpp",		"MidiDeviceInfo.cpp",
	"JetPlayer.cpp",
	"MediaScanner.cpp",		"MediaScanner.cpp",
	"MediaScannerClient.cpp",		"MediaScannerClient.cpp",
	"CharacterEncodingDetector.cpp",		"CharacterEncodingDetector.cpp",
	@@ -348,7 +347,6 @@ cc_library {

	static_libs: [		static_libs: [
	"libc_malloc_debug_backtrace", // for memory heap analysis		"libc_malloc_debug_backtrace", // for memory heap analysis
	"libmedia_midiiowrapper",
	],		],

	export_include_dirs: [		export_include_dirs: [

media/libmedia/JetPlayer.cpp

deleted100644 → 0

+0 −471

Original line number	Original line	Diff line number	Diff line
	/*
	* Copyright (C) 2008 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 "JetPlayer-C"

	#include <utils/Log.h>
	#include <media/JetPlayer.h>


	namespace android
	{

	static const int MIX_NUM_BUFFERS = 4;
	static const S_EAS_LIB_CONFIG* pLibConfig = NULL;

	//-------------------------------------------------------------------------------------------------
	JetPlayer::JetPlayer(void *javaJetPlayer, int maxTracks, int trackBufferSize) :
	mEventCallback(NULL),
	mJavaJetPlayerRef(javaJetPlayer),
	mTid(-1),
	mRender(false),
	mPaused(false),
	mMaxTracks(maxTracks),
	mEasData(NULL),
	mIoWrapper(NULL),
	mTrackBufferSize(trackBufferSize)
	{
	ALOGV("JetPlayer constructor");
	mPreviousJetStatus.currentUserID = -1;
	mPreviousJetStatus.segmentRepeatCount = -1;
	mPreviousJetStatus.numQueuedSegments = -1;
	mPreviousJetStatus.paused = true;
	}

	//-------------------------------------------------------------------------------------------------
	JetPlayer::~JetPlayer()
	{
	ALOGV("~JetPlayer");
	release();
	}

	//-------------------------------------------------------------------------------------------------
	int JetPlayer::init()
	{
	//Mutex::Autolock lock(&mMutex);

	EAS_RESULT result;

	// retrieve the EAS library settings
	if (pLibConfig == NULL)
	pLibConfig = EAS_Config();
	if (pLibConfig == NULL) {
	ALOGE("JetPlayer::init(): EAS library configuration could not be retrieved, aborting.");
	return EAS_FAILURE;
	}

	// init the EAS library
	result = EAS_Init(&mEasData);
	if (result != EAS_SUCCESS) {
	ALOGE("JetPlayer::init(): Error initializing Sonivox EAS library, aborting.");
	mState = EAS_STATE_ERROR;
	return result;
	}
	// init the JET library with the default app event controller range
	result = JET_Init(mEasData, NULL, sizeof(S_JET_CONFIG));
	if (result != EAS_SUCCESS) {
	ALOGE("JetPlayer::init(): Error initializing JET library, aborting.");
	mState = EAS_STATE_ERROR;
	return result;
	}

	// create the output AudioTrack
	mAudioTrack = new AudioTrack();
	status_t status = mAudioTrack->set(AUDIO_STREAM_MUSIC, //TODO parameterize this
	pLibConfig->sampleRate,
	AUDIO_FORMAT_PCM_16_BIT,
	audio_channel_out_mask_from_count(pLibConfig->numChannels),
	(size_t) mTrackBufferSize,
	AUDIO_OUTPUT_FLAG_NONE);
	if (status != OK) {
	ALOGE("JetPlayer::init(): Error initializing JET library; AudioTrack error %d", status);
	mAudioTrack.clear();
	mState = EAS_STATE_ERROR;
	return EAS_FAILURE;
	}

	// create render and playback thread
	{
	Mutex::Autolock l(mMutex);
	ALOGV("JetPlayer::init(): trying to start render thread");
	mThread = new JetPlayerThread(this);
	mThread->run("jetRenderThread", ANDROID_PRIORITY_AUDIO);
	mCondition.wait(mMutex);
	}
	if (mTid > 0) {
	// render thread started, we're ready
	ALOGV("JetPlayer::init(): render thread(%d) successfully started.", mTid);
	mState = EAS_STATE_READY;
	} else {
	ALOGE("JetPlayer::init(): failed to start render thread.");
	mState = EAS_STATE_ERROR;
	return EAS_FAILURE;
	}

	return EAS_SUCCESS;
	}

	void JetPlayer::setEventCallback(jetevent_callback eventCallback)
	{
	Mutex::Autolock l(mMutex);
	mEventCallback = eventCallback;
	}

	//-------------------------------------------------------------------------------------------------
	int JetPlayer::release()
	{
	ALOGV("JetPlayer::release()");
	Mutex::Autolock lock(mMutex);
	mPaused = true;
	mRender = false;
	if (mEasData) {
	JET_Pause(mEasData);
	JET_CloseFile(mEasData);
	JET_Shutdown(mEasData);
	EAS_Shutdown(mEasData);
	}
	delete mIoWrapper;
	mIoWrapper = NULL;
	if (mAudioTrack != 0) {
	mAudioTrack->stop();
	mAudioTrack->flush();
	mAudioTrack.clear();
	}
	if (mAudioBuffer) {
	delete mAudioBuffer;
	mAudioBuffer = NULL;
	}
	mEasData = NULL;

	return EAS_SUCCESS;
	}


	//-------------------------------------------------------------------------------------------------
	int JetPlayer::render() {
	EAS_RESULT result = EAS_FAILURE;
	EAS_I32 count;
	int temp;
	bool audioStarted = false;

	ALOGV("JetPlayer::render(): entering");

	// allocate render buffer
	mAudioBuffer =
	new EAS_PCM[pLibConfig->mixBufferSize * pLibConfig->numChannels * MIX_NUM_BUFFERS];

	// signal main thread that we started
	{
	Mutex::Autolock l(mMutex);
	mTid = gettid();
	ALOGV("JetPlayer::render(): render thread(%d) signal", mTid);
	mCondition.signal();
	}

	while (1) {

	mMutex.lock(); // [[[[[[[[ LOCK ---------------------------------------

	if (mEasData == NULL) {
	mMutex.unlock();
	ALOGV("JetPlayer::render(): NULL EAS data, exiting render.");
	goto threadExit;
	}

	// nothing to render, wait for client thread to wake us up
	while (!mRender)
	{
	ALOGV("JetPlayer::render(): signal wait");
	if (audioStarted) {
	mAudioTrack->pause();
	// we have to restart the playback once we start rendering again
	audioStarted = false;
	}
	mCondition.wait(mMutex);
	ALOGV("JetPlayer::render(): signal rx'd");
	}

	// render midi data into the input buffer
	int num_output = 0;
	EAS_PCM* p = mAudioBuffer;
	for (int i = 0; i < MIX_NUM_BUFFERS; i++) {
	result = EAS_Render(mEasData, p, pLibConfig->mixBufferSize, &count);
	if (result != EAS_SUCCESS) {
	ALOGE("JetPlayer::render(): EAS_Render returned error %ld", result);
	}
	p += count * pLibConfig->numChannels;
	num_output += count * pLibConfig->numChannels * sizeof(EAS_PCM);

	// send events that were generated (if any) to the event callback
	fireEventsFromJetQueue();
	}

	// update playback state
	//ALOGV("JetPlayer::render(): updating state");
	JET_Status(mEasData, &mJetStatus);
	fireUpdateOnStatusChange();
	mPaused = mJetStatus.paused;

	mMutex.unlock(); // UNLOCK ]]]]]]]] -----------------------------------

	// check audio output track
	if (mAudioTrack == NULL) {
	ALOGE("JetPlayer::render(): output AudioTrack was not created");
	goto threadExit;
	}

	// Write data to the audio hardware
	//ALOGV("JetPlayer::render(): writing to audio output");
	if ((temp = mAudioTrack->write(mAudioBuffer, num_output)) < 0) {
	ALOGE("JetPlayer::render(): Error in writing:%d",temp);
	return temp;
	}

	// start audio output if necessary
	if (!audioStarted) {
	ALOGV("JetPlayer::render(): starting audio playback");
	mAudioTrack->start();
	audioStarted = true;
	}

	}//while (1)

	threadExit:
	if (mAudioTrack != NULL) {
	mAudioTrack->stop();
	mAudioTrack->flush();
	}
	delete [] mAudioBuffer;
	mAudioBuffer = NULL;
	mMutex.lock();
	mTid = -1;
	mCondition.signal();
	mMutex.unlock();
	return result;
	}


	//-------------------------------------------------------------------------------------------------
	// fire up an update if any of the status fields has changed
	// precondition: mMutex locked
	void JetPlayer::fireUpdateOnStatusChange()
	{
	if ( (mJetStatus.currentUserID != mPreviousJetStatus.currentUserID)
	\|\|(mJetStatus.segmentRepeatCount != mPreviousJetStatus.segmentRepeatCount) ) {
	if (mEventCallback) {
	mEventCallback(
	JetPlayer::JET_USERID_UPDATE,
	mJetStatus.currentUserID,
	mJetStatus.segmentRepeatCount,
	mJavaJetPlayerRef);
	}
	mPreviousJetStatus.currentUserID = mJetStatus.currentUserID;
	mPreviousJetStatus.segmentRepeatCount = mJetStatus.segmentRepeatCount;
	}

	if (mJetStatus.numQueuedSegments != mPreviousJetStatus.numQueuedSegments) {
	if (mEventCallback) {
	mEventCallback(
	JetPlayer::JET_NUMQUEUEDSEGMENT_UPDATE,
	mJetStatus.numQueuedSegments,
	-1,
	mJavaJetPlayerRef);
	}
	mPreviousJetStatus.numQueuedSegments = mJetStatus.numQueuedSegments;
	}

	if (mJetStatus.paused != mPreviousJetStatus.paused) {
	if (mEventCallback) {
	mEventCallback(JetPlayer::JET_PAUSE_UPDATE,
	mJetStatus.paused,
	-1,
	mJavaJetPlayerRef);
	}
	mPreviousJetStatus.paused = mJetStatus.paused;
	}

	}


	//-------------------------------------------------------------------------------------------------
	// fire up all the JET events in the JET engine queue (until the queue is empty)
	// precondition: mMutex locked
	void JetPlayer::fireEventsFromJetQueue()
	{
	if (!mEventCallback) {
	// no callback, just empty the event queue
	while (JET_GetEvent(mEasData, NULL, NULL)) { }
	return;
	}

	EAS_U32 rawEvent;
	while (JET_GetEvent(mEasData, &rawEvent, NULL)) {
	mEventCallback(
	JetPlayer::JET_EVENT,
	rawEvent,
	-1,
	mJavaJetPlayerRef);
	}
	}


	//-------------------------------------------------------------------------------------------------
	int JetPlayer::loadFromFile(const char* path)
	{
	ALOGV("JetPlayer::loadFromFile(): path=%s", path);

	Mutex::Autolock lock(mMutex);

	delete mIoWrapper;
	mIoWrapper = new MidiIoWrapper(path);

	EAS_RESULT result = JET_OpenFile(mEasData, mIoWrapper->getLocator());
	if (result != EAS_SUCCESS)
	mState = EAS_STATE_ERROR;
	else
	mState = EAS_STATE_OPEN;
	return( result );
	}


	//-------------------------------------------------------------------------------------------------
	int JetPlayer::loadFromFD(const int fd, const long long offset, const long long length)
	{
	ALOGV("JetPlayer::loadFromFD(): fd=%d offset=%lld length=%lld", fd, offset, length);

	Mutex::Autolock lock(mMutex);

	delete mIoWrapper;
	mIoWrapper = new MidiIoWrapper(fd, offset, length);

	EAS_RESULT result = JET_OpenFile(mEasData, mIoWrapper->getLocator());
	if (result != EAS_SUCCESS)
	mState = EAS_STATE_ERROR;
	else
	mState = EAS_STATE_OPEN;
	return( result );
	}


	//-------------------------------------------------------------------------------------------------
	int JetPlayer::closeFile()
	{
	Mutex::Autolock lock(mMutex);
	return JET_CloseFile(mEasData);
	}


	//-------------------------------------------------------------------------------------------------
	int JetPlayer::play()
	{
	ALOGV("JetPlayer::play(): entering");
	Mutex::Autolock lock(mMutex);

	EAS_RESULT result = JET_Play(mEasData);

	mPaused = false;
	mRender = true;

	JET_Status(mEasData, &mJetStatus);
	this->dumpJetStatus(&mJetStatus);

	fireUpdateOnStatusChange();

	// wake up render thread
	ALOGV("JetPlayer::play(): wakeup render thread");
	mCondition.signal();

	return result;
	}

	//-------------------------------------------------------------------------------------------------
	int JetPlayer::pause()
	{
	Mutex::Autolock lock(mMutex);
	mPaused = true;
	EAS_RESULT result = JET_Pause(mEasData);

	mRender = false;

	JET_Status(mEasData, &mJetStatus);
	this->dumpJetStatus(&mJetStatus);
	fireUpdateOnStatusChange();


	return result;
	}


	//-------------------------------------------------------------------------------------------------
	int JetPlayer::queueSegment(int segmentNum, int libNum, int repeatCount, int transpose,
	EAS_U32 muteFlags, EAS_U8 userID)
	{
	ALOGV("JetPlayer::queueSegment segmentNum=%d, libNum=%d, repeatCount=%d, transpose=%d",
	segmentNum, libNum, repeatCount, transpose);
	Mutex::Autolock lock(mMutex);
	return JET_QueueSegment(mEasData, segmentNum, libNum, repeatCount, transpose, muteFlags,
	userID);
	}

	//-------------------------------------------------------------------------------------------------
	int JetPlayer::setMuteFlags(EAS_U32 muteFlags, bool sync)
	{
	Mutex::Autolock lock(mMutex);
	return JET_SetMuteFlags(mEasData, muteFlags, sync);
	}

	//-------------------------------------------------------------------------------------------------
	int JetPlayer::setMuteFlag(int trackNum, bool muteFlag, bool sync)
	{
	Mutex::Autolock lock(mMutex);
	return JET_SetMuteFlag(mEasData, trackNum, muteFlag, sync);
	}

	//-------------------------------------------------------------------------------------------------
	int JetPlayer::triggerClip(int clipId)
	{
	ALOGV("JetPlayer::triggerClip clipId=%d", clipId);
	Mutex::Autolock lock(mMutex);
	return JET_TriggerClip(mEasData, clipId);
	}

	//-------------------------------------------------------------------------------------------------
	int JetPlayer::clearQueue()
	{
	ALOGV("JetPlayer::clearQueue");
	Mutex::Autolock lock(mMutex);
	return JET_Clear_Queue(mEasData);
	}

	//-------------------------------------------------------------------------------------------------
	void JetPlayer::dump()
	{
	}

	void JetPlayer::dumpJetStatus(S_JET_STATUS* pJetStatus)
	{
	if (pJetStatus!=NULL)
	ALOGV(">> current JET player status: userID=%d segmentRepeatCount=%d numQueuedSegments=%d "
	"paused=%d",
	pJetStatus->currentUserID, pJetStatus->segmentRepeatCount,
	pJetStatus->numQueuedSegments, pJetStatus->paused);
	else
	ALOGE(">> JET player status is NULL");
	}


	} // end namespace android

media/libmedia/include/media/JetPlayer.h

deleted100644 → 0

+0 −126

Original line number	Original line	Diff line number	Diff line
	/*
	* Copyright (C) 2008 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.
	*/

	#ifndef JETPLAYER_H_
	#define JETPLAYER_H_

	#include <utils/threads.h>

	#include <libsonivox/jet.h>
	#include <libsonivox/eas_types.h>
	#include <media/AudioTrack.h>
	#include <media/MidiIoWrapper.h>


	namespace android {

	typedef void (jetevent_callback)(int eventType, int val1, int val2, void cookie);

	class JetPlayer {

	public:

	// to keep in sync with the JetPlayer class constants
	// defined in frameworks/base/media/java/android/media/JetPlayer.java
	static const int JET_EVENT = 1;
	static const int JET_USERID_UPDATE = 2;
	static const int JET_NUMQUEUEDSEGMENT_UPDATE = 3;
	static const int JET_PAUSE_UPDATE = 4;

	JetPlayer(void *javaJetPlayer,
	int maxTracks = 32,
	int trackBufferSize = 1200);
	~JetPlayer();
	int init();
	int release();

	int loadFromFile(const char* url);
	int loadFromFD(const int fd, const long long offset, const long long length);
	int closeFile();
	int play();
	int pause();
	int queueSegment(int segmentNum, int libNum, int repeatCount, int transpose,
	EAS_U32 muteFlags, EAS_U8 userID);
	int setMuteFlags(EAS_U32 muteFlags, bool sync);
	int setMuteFlag(int trackNum, bool muteFlag, bool sync);
	int triggerClip(int clipId);
	int clearQueue();

	void setEventCallback(jetevent_callback callback);

	int getMaxTracks() { return mMaxTracks; };


	private:
	int render();
	void fireUpdateOnStatusChange();
	void fireEventsFromJetQueue();

	JetPlayer() {} // no default constructor
	void dump();
	void dumpJetStatus(S_JET_STATUS* pJetStatus);

	jetevent_callback mEventCallback;

	void* mJavaJetPlayerRef;
	Mutex mMutex; // mutex to sync the render and playback thread with the JET calls
	pid_t mTid;
	Condition mCondition;
	volatile bool mRender;
	bool mPaused;

	EAS_STATE mState;
	int* mMemFailedVar;

	int mMaxTracks; // max number of MIDI tracks, usually 32
	EAS_DATA_HANDLE mEasData;
	MidiIoWrapper* mIoWrapper;
	EAS_PCM* mAudioBuffer;// EAS renders the MIDI data into this buffer,
	sp<AudioTrack> mAudioTrack; // and we play it in this audio track
	int mTrackBufferSize;
	S_JET_STATUS mJetStatus;
	S_JET_STATUS mPreviousJetStatus;

	class JetPlayerThread : public Thread {
	public:
	JetPlayerThread(JetPlayer *player) : mPlayer(player) {
	}

	protected:
	virtual ~JetPlayerThread() {}

	private:
	JetPlayer *mPlayer;

	bool threadLoop() {
	int result;
	result = mPlayer->render();
	return false;
	}

	JetPlayerThread(const JetPlayerThread &);
	JetPlayerThread &operator=(const JetPlayerThread &);
	};

	sp<JetPlayerThread> mThread;

	}; // end class JetPlayer

	} // end namespace android



	#endif /JETPLAYER_H_/