mirror of https://github.com/axmolengine/axmol.git
336 lines
9.9 KiB
C++
336 lines
9.9 KiB
C++
/**
|
|
* @author cesarpachon
|
|
*/
|
|
#include <cstring>
|
|
#include <cstdint>
|
|
#include "audio/linux/AudioEngine-linux.h"
|
|
|
|
#include "base/CCDirector.h"
|
|
#include "base/CCScheduler.h"
|
|
#include "platform/CCFileUtils.h"
|
|
|
|
using namespace cocos2d;
|
|
using namespace cocos2d::experimental;
|
|
|
|
AudioEngineImpl * g_AudioEngineImpl = nullptr;
|
|
|
|
void ERRCHECKWITHEXIT(FMOD_RESULT result)
|
|
{
|
|
if (result != FMOD_OK) {
|
|
printf("FMOD error! (%d) %s\n", result, FMOD_ErrorString(result));
|
|
}
|
|
}
|
|
|
|
bool ERRCHECK(FMOD_RESULT result)
|
|
{
|
|
if (result != FMOD_OK) {
|
|
printf("FMOD error! (%d) %s\n", result, FMOD_ErrorString(result));
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
FMOD_RESULT F_CALLBACK channelCallback(FMOD_CHANNELCONTROL *channelcontrol,
|
|
FMOD_CHANNELCONTROL_TYPE controltype,
|
|
FMOD_CHANNELCONTROL_CALLBACK_TYPE callbacktype,
|
|
void *commandData1, void *commandData2)
|
|
{
|
|
if (controltype == FMOD_CHANNELCONTROL_CHANNEL && callbacktype == FMOD_CHANNELCONTROL_CALLBACK_END) {
|
|
g_AudioEngineImpl->onSoundFinished((FMOD::Channel *)channelcontrol);
|
|
}
|
|
return FMOD_OK;
|
|
}
|
|
|
|
AudioEngineImpl::AudioEngineImpl()
|
|
{
|
|
}
|
|
|
|
AudioEngineImpl::~AudioEngineImpl()
|
|
{
|
|
FMOD_RESULT result;
|
|
result = pSystem->close();
|
|
ERRCHECKWITHEXIT(result);
|
|
result = pSystem->release();
|
|
ERRCHECKWITHEXIT(result);
|
|
}
|
|
|
|
bool AudioEngineImpl::init()
|
|
{
|
|
FMOD_RESULT result;
|
|
/*
|
|
Create a System object and initialize.
|
|
*/
|
|
result = FMOD::System_Create(&pSystem);
|
|
ERRCHECKWITHEXIT(result);
|
|
|
|
result = pSystem->setOutput(FMOD_OUTPUTTYPE_PULSEAUDIO);
|
|
ERRCHECKWITHEXIT(result);
|
|
|
|
result = pSystem->init(32, FMOD_INIT_NORMAL, 0);
|
|
ERRCHECKWITHEXIT(result);
|
|
|
|
mapChannelInfo.clear();
|
|
mapSound.clear();
|
|
|
|
auto scheduler = cocos2d::Director::getInstance()->getScheduler();
|
|
scheduler->schedule(schedule_selector(AudioEngineImpl::update), this, 0.05f, false);
|
|
|
|
g_AudioEngineImpl = this;
|
|
|
|
return true;
|
|
}
|
|
|
|
int AudioEngineImpl::play2d(const std::string &fileFullPath, bool loop, float volume)
|
|
{
|
|
int id = preload(fileFullPath, nullptr);
|
|
if (id >= 0) {
|
|
mapChannelInfo[id].loop=loop;
|
|
mapChannelInfo[id].channel->setPaused(true);
|
|
mapChannelInfo[id].volume = volume;
|
|
AudioEngine::_audioIDInfoMap[id].state = AudioEngine::AudioState::PAUSED;
|
|
resume(id);
|
|
}
|
|
return id;
|
|
}
|
|
|
|
void AudioEngineImpl::setVolume(int audioID, float volume)
|
|
{
|
|
try {
|
|
mapChannelInfo[audioID].channel->setVolume(volume);
|
|
}
|
|
catch (const std::out_of_range& oor) {
|
|
printf("AudioEngineImpl::setVolume: invalid audioID: %d\n", audioID);
|
|
}
|
|
}
|
|
|
|
void AudioEngineImpl::setLoop(int audioID, bool loop)
|
|
{
|
|
try {
|
|
mapChannelInfo[audioID].channel->setLoopCount(loop ? -1 : 0);
|
|
}
|
|
catch (const std::out_of_range& oor) {
|
|
printf("AudioEngineImpl::setLoop: invalid audioID: %d\n", audioID);
|
|
}
|
|
}
|
|
|
|
bool AudioEngineImpl::pause(int audioID)
|
|
{
|
|
try {
|
|
mapChannelInfo[audioID].channel->setPaused(true);
|
|
AudioEngine::_audioIDInfoMap[audioID].state = AudioEngine::AudioState::PAUSED;
|
|
return true;
|
|
}
|
|
catch (const std::out_of_range& oor) {
|
|
printf("AudioEngineImpl::pause: invalid audioID: %d\n", audioID);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool AudioEngineImpl::resume(int audioID)
|
|
{
|
|
try {
|
|
if (!mapChannelInfo[audioID].channel) {
|
|
FMOD::Channel *channel = nullptr;
|
|
FMOD::ChannelGroup *channelgroup = nullptr;
|
|
//starts the sound in pause mode, use the channel to unpause
|
|
FMOD_RESULT result = pSystem->playSound(mapChannelInfo[audioID].sound, channelgroup, true, &channel);
|
|
if (ERRCHECK(result)) {
|
|
return false;
|
|
}
|
|
channel->setMode(mapChannelInfo[audioID].loop ? FMOD_LOOP_NORMAL : FMOD_LOOP_OFF);
|
|
channel->setLoopCount(mapChannelInfo[audioID].loop ? -1 : 0);
|
|
channel->setVolume(mapChannelInfo[audioID].volume);
|
|
channel->setUserData(reinterpret_cast<void *>(static_cast<std::intptr_t>(mapChannelInfo[audioID].id)));
|
|
mapChannelInfo[audioID].channel = channel;
|
|
}
|
|
|
|
mapChannelInfo[audioID].channel->setPaused(false);
|
|
AudioEngine::_audioIDInfoMap[audioID].state = AudioEngine::AudioState::PLAYING;
|
|
|
|
return true;
|
|
}
|
|
catch (const std::out_of_range& oor) {
|
|
printf("AudioEngineImpl::resume: invalid audioID: %d\n", audioID);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool AudioEngineImpl::stop(int audioID)
|
|
{
|
|
try {
|
|
mapChannelInfo[audioID].channel->stop();
|
|
mapChannelInfo[audioID].channel = nullptr;
|
|
return true;
|
|
}
|
|
catch (const std::out_of_range& oor) {
|
|
printf("AudioEngineImpl::stop: invalid audioID: %d\n", audioID);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
void AudioEngineImpl::stopAll()
|
|
{
|
|
for (auto it = mapChannelInfo.begin(); it != mapChannelInfo.end(); ++it) {
|
|
ChannelInfo & audioRef = it->second;
|
|
audioRef.channel->stop();
|
|
audioRef.channel = nullptr;
|
|
}
|
|
}
|
|
|
|
float AudioEngineImpl::getDuration(int audioID)
|
|
{
|
|
try {
|
|
FMOD::Sound * sound = mapChannelInfo[audioID].sound;
|
|
unsigned int length;
|
|
FMOD_RESULT result = sound->getLength(&length, FMOD_TIMEUNIT_MS);
|
|
ERRCHECK(result);
|
|
float duration = (float)length / 1000.0f;
|
|
return duration;
|
|
}
|
|
catch (const std::out_of_range& oor) {
|
|
printf("AudioEngineImpl::getDuration: invalid audioID: %d\n", audioID);
|
|
return AudioEngine::TIME_UNKNOWN;
|
|
}
|
|
}
|
|
|
|
float AudioEngineImpl::getCurrentTime(int audioID)
|
|
{
|
|
try {
|
|
unsigned int position;
|
|
FMOD_RESULT result = mapChannelInfo[audioID].channel->getPosition(&position, FMOD_TIMEUNIT_MS);
|
|
ERRCHECK(result);
|
|
float currenttime = position /1000.0f;
|
|
return currenttime;
|
|
}
|
|
catch (const std::out_of_range& oor) {
|
|
printf("AudioEngineImpl::getCurrentTime: invalid audioID: %d\n", audioID);
|
|
return AudioEngine::TIME_UNKNOWN;
|
|
}
|
|
}
|
|
|
|
bool AudioEngineImpl::setCurrentTime(int audioID, float time)
|
|
{
|
|
try {
|
|
unsigned int position = (unsigned int)(time * 1000.0f);
|
|
FMOD_RESULT result = mapChannelInfo[audioID].channel->setPosition(position, FMOD_TIMEUNIT_MS);
|
|
ERRCHECK(result);
|
|
}
|
|
catch (const std::out_of_range& oor) {
|
|
printf("AudioEngineImpl::setCurrentTime: invalid audioID: %d\n", audioID);
|
|
}
|
|
}
|
|
|
|
void AudioEngineImpl::setFinishCallback(int audioID, const std::function<void (int, const std::string &)> &callback)
|
|
{
|
|
try {
|
|
FMOD::Channel * channel = mapChannelInfo[audioID].channel;
|
|
mapChannelInfo[audioID].callback = callback;
|
|
FMOD_RESULT result = channel->setCallback(channelCallback);
|
|
ERRCHECK(result);
|
|
}
|
|
catch (const std::out_of_range& oor) {
|
|
printf("AudioEngineImpl::setFinishCallback: invalid audioID: %d\n", audioID);
|
|
}
|
|
}
|
|
|
|
void AudioEngineImpl::onSoundFinished(FMOD::Channel * channel)
|
|
{
|
|
int id = 0;
|
|
try {
|
|
void * data;
|
|
channel->getUserData(&data);
|
|
id = static_cast<int>(reinterpret_cast<std::intptr_t>(data));
|
|
if (mapChannelInfo[id].callback) {
|
|
mapChannelInfo[id].callback(id, mapChannelInfo[id].path);
|
|
}
|
|
mapChannelInfo[id].channel = nullptr;
|
|
}
|
|
catch (const std::out_of_range& oor) {
|
|
printf("AudioEngineImpl::onSoundFinished: invalid audioID: %d\n", id);
|
|
}
|
|
}
|
|
|
|
void AudioEngineImpl::uncache(const std::string& path)
|
|
{
|
|
std::string fullPath = FileUtils::getInstance()->fullPathForFilename(path);
|
|
std::map<std::string, FMOD::Sound *>::const_iterator it = mapSound.find(fullPath);
|
|
if (it!=mapSound.end()) {
|
|
FMOD::Sound * sound = it->second;
|
|
if (sound) {
|
|
sound->release();
|
|
}
|
|
mapSound.erase(it);
|
|
}
|
|
if (mapId.find(path) != mapId.end())
|
|
mapId.erase(path);
|
|
}
|
|
|
|
void AudioEngineImpl::uncacheAll()
|
|
{
|
|
for (auto it = mapSound.cbegin(); it != mapSound.cend(); ++it) {
|
|
auto sound = it->second;
|
|
if (sound) {
|
|
sound->release();
|
|
}
|
|
}
|
|
mapSound.clear();
|
|
mapId.clear();
|
|
}
|
|
|
|
int AudioEngineImpl::preload(const std::string& filePath, std::function<void(bool isSuccess)> callback)
|
|
{
|
|
FMOD::Sound * sound = findSound(filePath);
|
|
if (!sound) {
|
|
std::string fullPath = FileUtils::getInstance()->fullPathForFilename(filePath);
|
|
FMOD_RESULT result = pSystem->createSound(fullPath.c_str(), FMOD_LOOP_OFF, 0, &sound);
|
|
if (ERRCHECK(result)) {
|
|
printf("sound effect in %s could not be preload\n", filePath.c_str());
|
|
if (callback) {
|
|
callback(false);
|
|
}
|
|
return -1;
|
|
}
|
|
mapSound[fullPath] = sound;
|
|
}
|
|
|
|
int id = static_cast<int>(mapChannelInfo.size()) + 1;
|
|
if (mapId.find(filePath) == mapId.end())
|
|
mapId.insert({filePath, id});
|
|
else
|
|
id = mapId.at(filePath);
|
|
|
|
auto& chanelInfo = mapChannelInfo[id];
|
|
chanelInfo.sound = sound;
|
|
chanelInfo.id = id;
|
|
chanelInfo.channel = nullptr;
|
|
chanelInfo.callback = nullptr;
|
|
chanelInfo.path = filePath;
|
|
//we are going to use UserData to store pointer to Channel when playing
|
|
chanelInfo.sound->setUserData(reinterpret_cast<void *>(static_cast<std::intptr_t>(id)));
|
|
|
|
if (callback) {
|
|
callback(true);
|
|
}
|
|
return id;
|
|
}
|
|
|
|
void AudioEngineImpl::update(float dt)
|
|
{
|
|
pSystem->update();
|
|
}
|
|
|
|
FMOD::Sound * AudioEngineImpl::findSound(const std::string &path)
|
|
{
|
|
std::string fullPath = FileUtils::getInstance()->fullPathForFilename(path);
|
|
std::map<std::string, FMOD::Sound *>::const_iterator it = mapSound.find(fullPath);
|
|
return (it != mapSound.end()) ? (it->second) : nullptr;
|
|
}
|
|
|
|
FMOD::Channel * AudioEngineImpl::getChannel(FMOD::Sound *sound)
|
|
{
|
|
void * data;
|
|
sound->getUserData(&data);
|
|
int id = static_cast<int>(reinterpret_cast<std::intptr_t>(data));
|
|
return mapChannelInfo[id].channel;
|
|
}
|