Play-/Source/ui_android/SH_OpenSL.cpp

#include <cassert>
#include "SH_OpenSL.h"

CSH_OpenSL::CSH_OpenSL()
{
	SLresult result = SL_RESULT_SUCCESS;
	
	result = slCreateEngine(&m_engineObject, 0, nullptr, 0, nullptr, nullptr);
	assert(result == SL_RESULT_SUCCESS);
	
	result = (*m_engineObject)->Realize(m_engineObject, SL_BOOLEAN_FALSE);
	assert(result == SL_RESULT_SUCCESS);
	
	result = (*m_engineObject)->GetInterface(m_engineObject, SL_IID_ENGINE, &m_engine);
	assert(result == SL_RESULT_SUCCESS);
	
	CreateOutputMix();
	CreateAudioPlayer();
}

CSH_OpenSL::~CSH_OpenSL()
{
	Reset();
	(*m_playerObject)->Destroy(m_playerObject);
	(*m_outputMixObject)->Destroy(m_outputMixObject);
	(*m_engineObject)->Destroy(m_engineObject);
}

CSoundHandler* CSH_OpenSL::HandlerFactory()
{
	return new CSH_OpenSL();
}

void CSH_OpenSL::CreateOutputMix()
{
	assert(m_outputMixObject == nullptr);
	
	SLresult result = SL_RESULT_SUCCESS;
	
	static const SLInterfaceID interfaceIds[] = { SL_IID_VOLUME };
	static const SLboolean required[] = { SL_BOOLEAN_FALSE };
	result = (*m_engine)->CreateOutputMix(m_engine, &m_outputMixObject, 1, interfaceIds, required);
	assert(result == SL_RESULT_SUCCESS);
	
	result = (*m_outputMixObject)->Realize(m_outputMixObject, SL_BOOLEAN_FALSE);
	assert(result == SL_RESULT_SUCCESS);
}

void CSH_OpenSL::CreateAudioPlayer()
{
	assert(m_playerObject == nullptr);
	
	SLresult result = SL_RESULT_SUCCESS;
	
	SLDataLocator_AndroidSimpleBufferQueue bufferQueueLocator = {};
	bufferQueueLocator.locatorType = SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE;
	bufferQueueLocator.numBuffers  = BUFFER_COUNT;
	
	SLDataFormat_PCM dataFormat = {};
	dataFormat.formatType    = SL_DATAFORMAT_PCM;
	dataFormat.numChannels   = 2;
	dataFormat.samplesPerSec = SL_SAMPLINGRATE_44_1;
	dataFormat.bitsPerSample = SL_PCMSAMPLEFORMAT_FIXED_16;
	dataFormat.containerSize = SL_PCMSAMPLEFORMAT_FIXED_16;
	dataFormat.channelMask   = SL_SPEAKER_FRONT_LEFT | SL_SPEAKER_FRONT_RIGHT;
	dataFormat.endianness    = SL_BYTEORDER_LITTLEENDIAN;
	
	SLDataSource dataSource = {};
	dataSource.pLocator = &bufferQueueLocator;
	dataSource.pFormat  = &dataFormat;
	
	SLDataLocator_OutputMix outputMixLocator = {};
	outputMixLocator.locatorType = SL_DATALOCATOR_OUTPUTMIX;
	outputMixLocator.outputMix   = m_outputMixObject;
	
	SLDataSink dataSink = {};
	dataSink.pLocator = &outputMixLocator;
	
	static const SLInterfaceID interfaceIds[] = { SL_IID_ANDROIDSIMPLEBUFFERQUEUE };
	static const SLboolean required[] = { SL_BOOLEAN_TRUE };
	result = (*m_engine)->CreateAudioPlayer(m_engine, &m_playerObject, &dataSource, &dataSink, 
		1, interfaceIds, required);
	assert(result == SL_RESULT_SUCCESS);
	
	result = (*m_playerObject)->Realize(m_playerObject, SL_BOOLEAN_FALSE);
	assert(result == SL_RESULT_SUCCESS);
	
	result = (*m_playerObject)->GetInterface(m_playerObject, SL_IID_PLAY, &m_playerPlay);
	assert(result == SL_RESULT_SUCCESS);
	
	result = (*m_playerObject)->GetInterface(m_playerObject, SL_IID_ANDROIDSIMPLEBUFFERQUEUE, &m_playerQueue);
	assert(result == SL_RESULT_SUCCESS);
	
	result = (*m_playerQueue)->RegisterCallback(m_playerQueue, &CSH_OpenSL::QueueCallback, this);
	assert(result == SL_RESULT_SUCCESS);
	
	result = (*m_playerPlay)->SetPlayState(m_playerPlay, SL_PLAYSTATE_PLAYING);
	assert(result == SL_RESULT_SUCCESS);
}

void CSH_OpenSL::QueueCallback(SLAndroidSimpleBufferQueueItf, void* context)
{
	reinterpret_cast<CSH_OpenSL*>(context)->QueueCallbackImpl();
}

void CSH_OpenSL::QueueCallbackImpl()
{
	assert(m_bufferCount != BUFFER_COUNT);
	m_bufferCount++;
}

void CSH_OpenSL::Reset()
{
	assert(m_playerQueue != nullptr);
	
	SLresult result = SL_RESULT_SUCCESS;
	
	result = (*m_playerQueue)->Clear(m_playerQueue);
	assert(result == SL_RESULT_SUCCESS);
	
	m_bufferCount = BUFFER_COUNT;
}

void CSH_OpenSL::Write(int16* buffer, unsigned int sampleCount, unsigned int)
{
	if(m_bufferCount == 0) return;
	
	assert(m_playerQueue != nullptr);
	
	SLresult result = SL_RESULT_SUCCESS;
	
	result = (*m_playerQueue)->Enqueue(m_playerQueue, buffer, sampleCount * sizeof(int16));
	assert(result == SL_RESULT_SUCCESS);
	
	m_bufferCount--;
}

bool CSH_OpenSL::HasFreeBuffers()
{
	return false;
}

void CSH_OpenSL::RecycleBuffers()
{
	
}