mirror of https://github.com/AxioDL/amuse.git
Work on Voice state and SurroundProfiles
This commit is contained in:
parent
60f873e76e
commit
1102d50f8f
|
@ -16,7 +16,9 @@ set(SOURCES
|
|||
lib/EffectReverbHi.cpp
|
||||
lib/EffectReverbStd.cpp
|
||||
lib/EffectChorus.cpp
|
||||
lib/EffectDelay.cpp)
|
||||
lib/EffectDelay.cpp
|
||||
lib/SurroundProfiles.cpp
|
||||
lib/dsp.c)
|
||||
|
||||
set(HEADERS
|
||||
include/amuse/AudioGroup.hpp
|
||||
|
@ -41,12 +43,14 @@ set(HEADERS
|
|||
include/amuse/EffectReverbStd.hpp
|
||||
include/amuse/EffectChorus.hpp
|
||||
include/amuse/EffectDelay.hpp
|
||||
include/amuse/SurroundProfiles.hpp
|
||||
include/amuse/Common.hpp
|
||||
include/amuse/amuse.hpp)
|
||||
include/amuse/amuse.hpp
|
||||
include/amuse/dsp.h)
|
||||
|
||||
unset(EXTRAS)
|
||||
if(TARGET boo)
|
||||
include_directories(${BOO_INCLUDE_DIR} ${LOGVISOR_INCLUDE_DIR})
|
||||
include_directories(${BOO_INCLUDE_DIR} ${LOGVISOR_INCLUDE_DIR} ${ATHENA_INCLUDE_DIR})
|
||||
list(APPEND EXTRAS lib/BooBackend.cpp include/amuse/BooBackend.hpp)
|
||||
endif()
|
||||
|
||||
|
@ -59,6 +63,6 @@ add_library(amuse
|
|||
${EXTRAS})
|
||||
|
||||
if(TARGET boo)
|
||||
add_executable(amusetool driver/main.cpp)
|
||||
target_link_libraries(amusetool amuse boo ${BOO_SYS_LIBS} logvisor)
|
||||
add_executable(amusetool WIN32 driver/main.cpp)
|
||||
target_link_libraries(amusetool amuse boo ${BOO_SYS_LIBS} logvisor athena-core)
|
||||
endif()
|
||||
|
|
501
driver/main.cpp
501
driver/main.cpp
|
@ -1,110 +1,423 @@
|
|||
#include "amuse/amuse.hpp"
|
||||
#include "amuse/BooBackend.hpp"
|
||||
#include "athena/FileReader.hpp"
|
||||
#include "boo/boo.hpp"
|
||||
#include "boo/audiodev/IAudioVoiceEngine.hpp"
|
||||
#include "logvisor/logvisor.hpp"
|
||||
#include "optional.hpp"
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#ifndef _WIN32
|
||||
#include <sys/select.h>
|
||||
#include <termios.h>
|
||||
#include <unistd.h>
|
||||
#else
|
||||
#include <conio.h>
|
||||
#endif
|
||||
#include <thread>
|
||||
#include <map>
|
||||
|
||||
static logvisor::Module Log("amusetool");
|
||||
|
||||
static amuse::IntrusiveAudioGroupData LoadFromArgs(int argc, char* argv[],
|
||||
static amuse::IntrusiveAudioGroupData LoadFromArgs(int argc, const boo::SystemChar** argv,
|
||||
std::string& descOut, bool& good)
|
||||
{
|
||||
if (argc > 1)
|
||||
{
|
||||
/* First attempt single-file case */
|
||||
std::experimental::optional<athena::io::FileReader> r;
|
||||
r.emplace(argv[1], 32 * 1024, false);
|
||||
if (!r->hasError())
|
||||
{
|
||||
char testBuf[6];
|
||||
if (r->readBytesToBuf(testBuf, 6) == 6)
|
||||
{
|
||||
if (!memcmp(testBuf, "Audio/", 6))
|
||||
{
|
||||
/* Metroid Prime 1 container */
|
||||
r->seek(0, athena::SeekOrigin::Begin);
|
||||
r->readString();
|
||||
descOut = "Metroid Prime (" + r->readString() + ")";
|
||||
|
||||
std::unique_ptr<uint8_t[]> pool = r->readUBytes(r->readUint32Big());
|
||||
std::unique_ptr<uint8_t[]> proj = r->readUBytes(r->readUint32Big());
|
||||
std::unique_ptr<uint8_t[]> samp = r->readUBytes(r->readUint32Big());
|
||||
std::unique_ptr<uint8_t[]> sdir = r->readUBytes(r->readUint32Big());
|
||||
|
||||
good = true;
|
||||
return {proj.release(), pool.release(), sdir.release(), samp.release()};
|
||||
}
|
||||
else if (amuse::SBig(*reinterpret_cast<uint32_t*>(testBuf)) == 0x1)
|
||||
{
|
||||
/* Metroid Prime 2 container */
|
||||
r->seek(0, athena::SeekOrigin::Begin);
|
||||
r->readUint32Big();
|
||||
descOut = "Metroid Prime 2 (" + r->readString() + ")";
|
||||
|
||||
r->readUint16Big();
|
||||
uint32_t poolSz = r->readUint32Big();
|
||||
uint32_t projSz = r->readUint32Big();
|
||||
uint32_t sdirSz = r->readUint32Big();
|
||||
uint32_t sampSz = r->readUint32Big();
|
||||
|
||||
std::unique_ptr<uint8_t[]> pool = r->readUBytes(poolSz);
|
||||
std::unique_ptr<uint8_t[]> proj = r->readUBytes(projSz);
|
||||
std::unique_ptr<uint8_t[]> sdir = r->readUBytes(sdirSz);
|
||||
std::unique_ptr<uint8_t[]> samp = r->readUBytes(sampSz);
|
||||
|
||||
good = true;
|
||||
return {proj.release(), pool.release(), sdir.release(), samp.release()};
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
/* Now attempt multi-file case */
|
||||
char path[1024];
|
||||
|
||||
/* Project */
|
||||
snprintf(path, 1024, "%s.pro", argv[1]);
|
||||
r.emplace(path, 32 * 1024, false);
|
||||
if (r->hasError())
|
||||
{
|
||||
snprintf(path, 1024, "%s.proj", argv[1]);
|
||||
r.emplace(path, 32 * 1024, false);
|
||||
if (r->hasError())
|
||||
return {nullptr, nullptr, nullptr, nullptr};
|
||||
}
|
||||
std::unique_ptr<uint8_t[]> proj = r->readUBytes(r->length());
|
||||
|
||||
/* Pool */
|
||||
snprintf(path, 1024, "%s.poo", argv[1]);
|
||||
r.emplace(path, 32 * 1024, false);
|
||||
if (r->hasError())
|
||||
{
|
||||
snprintf(path, 1024, "%s.pool", argv[1]);
|
||||
r.emplace(path, 32 * 1024, false);
|
||||
if (r->hasError())
|
||||
return {nullptr, nullptr, nullptr, nullptr};
|
||||
}
|
||||
std::unique_ptr<uint8_t[]> pool = r->readUBytes(r->length());
|
||||
|
||||
/* Sdir */
|
||||
snprintf(path, 1024, "%s.sdi", argv[1]);
|
||||
r.emplace(path, 32 * 1024, false);
|
||||
if (r->hasError())
|
||||
{
|
||||
snprintf(path, 1024, "%s.sdir", argv[1]);
|
||||
r.emplace(path, 32 * 1024, false);
|
||||
if (r->hasError())
|
||||
return {nullptr, nullptr, nullptr, nullptr};
|
||||
}
|
||||
std::unique_ptr<uint8_t[]> sdir = r->readUBytes(r->length());
|
||||
|
||||
/* Samp */
|
||||
snprintf(path, 1024, "%s.sam", argv[1]);
|
||||
r.emplace(path, 32 * 1024, false);
|
||||
if (r->hasError())
|
||||
{
|
||||
snprintf(path, 1024, "%s.samp", argv[1]);
|
||||
r.emplace(path, 32 * 1024, false);
|
||||
if (r->hasError())
|
||||
return {nullptr, nullptr, nullptr, nullptr};
|
||||
}
|
||||
std::unique_ptr<uint8_t[]> samp = r->readUBytes(r->length());
|
||||
|
||||
descOut = "4 RAW Chunk Files";
|
||||
good = true;
|
||||
return {proj.release(), pool.release(), sdir.release(), samp.release()};
|
||||
}
|
||||
}
|
||||
|
||||
return {nullptr, nullptr, nullptr, nullptr};
|
||||
}
|
||||
|
||||
int main(int argc, char* argv[])
|
||||
struct AppCallback;
|
||||
|
||||
struct EventCallback : boo::IWindowCallback
|
||||
{
|
||||
AppCallback& m_app;
|
||||
public:
|
||||
void charKeyDown(unsigned long charCode, boo::EModifierKey mods, bool isRepeat);
|
||||
void charKeyUp(unsigned long charCode, boo::EModifierKey mods);
|
||||
void specialKeyDown(boo::ESpecialKey key, boo::EModifierKey mods, bool isRepeat);
|
||||
void specialKeyUp(boo::ESpecialKey key, boo::EModifierKey mods);
|
||||
void resized(const boo::SWindowRect&, const boo::SWindowRect&) {}
|
||||
|
||||
EventCallback(AppCallback& app) : m_app(app) {}
|
||||
};
|
||||
|
||||
struct AppCallback : boo::IApplicationCallback
|
||||
{
|
||||
int m_argc;
|
||||
const boo::SystemChar** m_argv;
|
||||
|
||||
/* Boo window and events */
|
||||
EventCallback m_eventRec;
|
||||
boo::DeferredWindowEvents<EventCallback> m_events;
|
||||
boo::IWindow* m_win = nullptr;
|
||||
|
||||
/* Amuse engine */
|
||||
std::experimental::optional<amuse::Engine> m_engine;
|
||||
int m_groupId;
|
||||
bool m_sfxGroup;
|
||||
|
||||
/* Song playback selection */
|
||||
int m_setupId = -1;
|
||||
int m_chanId = -1;
|
||||
|
||||
/* SFX playback selection */
|
||||
int m_sfxId = -1;
|
||||
amuse::Voice* m_vox = nullptr;
|
||||
|
||||
/* Control state */
|
||||
bool m_running = true;
|
||||
bool m_wantsNext = false;
|
||||
bool m_wantsPrev = false;
|
||||
|
||||
void SongLoop(const amuse::AudioGroup& group,
|
||||
const amuse::SongGroupIndex& index)
|
||||
{
|
||||
printf("░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░\n"
|
||||
"░░░ ████ ████ ┃ ████ ████ ████ ┃ ████ ████ ░░░\n"
|
||||
"░░░ ████ ████ ┃ ████ ████ ████ ┃ ████ ████ ░░░\n"
|
||||
"░░░ ▌W▐█ ▌E▐█ ┃ ▌T▐█ ▌Y▐█ ▌U▐█ ┃ ▌O▐█ ▌P▐█ ░░░\n"
|
||||
"░░░ │ │ ┃ │ │ │ ┃ │ │ ░░░\n"
|
||||
"░░░ A │ S │ D ┃ F │ G │ H │ J ┃ K │ L │ ; ░░░\n"
|
||||
"░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░\n"
|
||||
"<left/right>: cycle MIDI setup / channel, <up/down>: volume\n"
|
||||
"<tab>: sustain pedal, <1/2>: pitch wheel, <3-8>: mod wheel\n"
|
||||
"<Z/X>: octave, <C/V>: velocity\n"
|
||||
"<Q>: quit\n");
|
||||
|
||||
std::map<int, const std::array<amuse::SongGroupIndex::MIDISetup, 16>*> sortEntries
|
||||
(index.m_midiSetups.cbegin(), index.m_midiSetups.cend());
|
||||
auto setupIt = sortEntries.cbegin();
|
||||
if (setupIt != sortEntries.cend())
|
||||
{
|
||||
m_setupId = setupIt->first;
|
||||
m_chanId = 0;
|
||||
}
|
||||
|
||||
while (m_running)
|
||||
{
|
||||
m_events.dispatchEvents();
|
||||
|
||||
if (m_wantsNext)
|
||||
{
|
||||
m_wantsNext = false;
|
||||
|
||||
}
|
||||
|
||||
m_engine->pumpEngine();
|
||||
m_win->waitForRetrace();
|
||||
}
|
||||
}
|
||||
|
||||
void SFXLoop(const amuse::AudioGroup& group,
|
||||
const amuse::SFXGroupIndex& index)
|
||||
{
|
||||
printf("<space>: keyon/keyon, <left/right>: cycle SFX, <up/down>: volume\n"
|
||||
"<Q>: quit\n");
|
||||
|
||||
std::map<uint16_t, const amuse::SFXGroupIndex::SFXEntry*> sortEntries
|
||||
(index.m_sfxEntries.cbegin(), index.m_sfxEntries.cend());
|
||||
auto sfxIt = sortEntries.cbegin();
|
||||
if (sfxIt != sortEntries.cend())
|
||||
{
|
||||
m_sfxId = sfxIt->first;
|
||||
m_vox = m_engine->fxStart(m_sfxId, 1.f, 0.f);
|
||||
}
|
||||
|
||||
while (m_running)
|
||||
{
|
||||
m_events.dispatchEvents();
|
||||
m_engine->pumpEngine();
|
||||
m_win->waitForRetrace();
|
||||
}
|
||||
}
|
||||
|
||||
void charKeyDown(unsigned long charCode)
|
||||
{
|
||||
if (m_sfxGroup)
|
||||
{
|
||||
switch (charCode)
|
||||
{
|
||||
case ' ':
|
||||
if (m_vox && m_vox->state() == amuse::VoiceState::Playing)
|
||||
m_vox->keyOff();
|
||||
else if (m_sfxId != -1)
|
||||
m_vox = m_engine->fxStart(m_sfxId, 1.f, 0.f);
|
||||
default: break;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
}
|
||||
}
|
||||
|
||||
void charKeyUp(unsigned long charCode)
|
||||
{
|
||||
}
|
||||
|
||||
int appMain(boo::IApplication* app)
|
||||
{
|
||||
/* Event window */
|
||||
m_win = app->newWindow("amusetool", 1);
|
||||
m_win->setWindowFrame(100, 100, 100, 100);
|
||||
m_win->setCallback(&m_events);
|
||||
m_win->showWindow();
|
||||
|
||||
/* Load data */
|
||||
std::string desc;
|
||||
bool good = false;
|
||||
amuse::IntrusiveAudioGroupData data = LoadFromArgs(m_argc, m_argv, desc, good);
|
||||
if (!good)
|
||||
Log.report(logvisor::Fatal, "incomplete data in args");
|
||||
printf("Found '%s' Audio Group data\n", desc.c_str());
|
||||
|
||||
/* Load project to assemble group list */
|
||||
amuse::AudioGroupProject proj(data.getProj());
|
||||
|
||||
/* Get group selection from user */
|
||||
size_t totalGroups = proj.sfxGroups().size() + proj.songGroups().size();
|
||||
if (totalGroups > 1)
|
||||
{
|
||||
/* Ask user to specify which group in project */
|
||||
printf("Multiple Audio Groups discovered:\n");
|
||||
for (const auto& pair : proj.songGroups())
|
||||
{
|
||||
printf(" %d (SongGroup) %" PRISize " normal-pages, %" PRISize " drum-pages\n",
|
||||
pair.first, pair.second.m_normPages.size(), pair.second.m_drumPages.size());
|
||||
}
|
||||
for (const auto& pair : proj.sfxGroups())
|
||||
{
|
||||
printf(" %d (SFXGroup) %" PRISize " sfx-entries\n",
|
||||
pair.first, pair.second.m_sfxEntries.size());
|
||||
}
|
||||
|
||||
int userSel = 0;
|
||||
printf("Enter Group Number: ");
|
||||
if (scanf("%d", &userSel) <= 0)
|
||||
Log.report(logvisor::Fatal, "unable to parse prompt");
|
||||
|
||||
if (proj.getSongGroupIndex(userSel))
|
||||
{
|
||||
m_groupId = userSel;
|
||||
m_sfxGroup = false;
|
||||
}
|
||||
else if (proj.getSFXGroupIndex(userSel))
|
||||
{
|
||||
m_groupId = userSel;
|
||||
m_sfxGroup = true;
|
||||
}
|
||||
else
|
||||
Log.report(logvisor::Fatal, "unable to find Group %d", userSel);
|
||||
}
|
||||
else if (totalGroups == 1)
|
||||
{
|
||||
/* Load one and only group */
|
||||
if (proj.songGroups().size())
|
||||
{
|
||||
const auto& pair = *proj.songGroups().cbegin();
|
||||
m_groupId = pair.first;
|
||||
m_sfxGroup = false;
|
||||
}
|
||||
else
|
||||
{
|
||||
const auto& pair = *proj.sfxGroups().cbegin();
|
||||
m_groupId = pair.first;
|
||||
m_sfxGroup = true;
|
||||
}
|
||||
}
|
||||
else
|
||||
Log.report(logvisor::Fatal, "empty project");
|
||||
|
||||
/* Build voice engine */
|
||||
std::unique_ptr<boo::IAudioVoiceEngine> voxEngine = boo::NewAudioVoiceEngine();
|
||||
amuse::BooBackendVoiceAllocator booBackend(*voxEngine);
|
||||
m_engine.emplace(booBackend);
|
||||
|
||||
/* Load group into engine */
|
||||
const amuse::AudioGroup* group = m_engine->addAudioGroup(m_groupId, data);
|
||||
if (!group)
|
||||
Log.report(logvisor::Fatal, "unable to add audio group");
|
||||
|
||||
/* Enter playback loop */
|
||||
if (m_sfxGroup)
|
||||
SFXLoop(*group, *proj.getSFXGroupIndex(m_groupId));
|
||||
else
|
||||
SongLoop(*group, *proj.getSongGroupIndex(m_groupId));
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
void appQuitting(boo::IApplication*)
|
||||
{
|
||||
m_running = false;
|
||||
}
|
||||
|
||||
AppCallback(int argc, const boo::SystemChar** argv)
|
||||
: m_argc(argc), m_argv(argv), m_eventRec(*this), m_events(m_eventRec) {}
|
||||
};
|
||||
|
||||
void EventCallback::charKeyDown(unsigned long charCode, boo::EModifierKey mods, bool isRepeat)
|
||||
{
|
||||
if (isRepeat)
|
||||
return;
|
||||
m_app.charKeyDown(charCode);
|
||||
}
|
||||
|
||||
void EventCallback::charKeyUp(unsigned long charCode, boo::EModifierKey mods)
|
||||
{
|
||||
m_app.charKeyUp(charCode);
|
||||
}
|
||||
|
||||
void EventCallback::specialKeyDown(boo::ESpecialKey key, boo::EModifierKey mods, bool isRepeat)
|
||||
{
|
||||
switch (key)
|
||||
{
|
||||
case boo::ESpecialKey::Left:
|
||||
m_app.m_wantsPrev = true;
|
||||
break;
|
||||
case boo::ESpecialKey::Right:
|
||||
m_app.m_wantsNext = true;
|
||||
break;
|
||||
default: break;
|
||||
}
|
||||
}
|
||||
|
||||
void EventCallback::specialKeyUp(boo::ESpecialKey key, boo::EModifierKey mods)
|
||||
{
|
||||
}
|
||||
|
||||
#if _WIN32
|
||||
int wmain(int argc, const boo::SystemChar** argv)
|
||||
#else
|
||||
int main(int argc, const boo::SystemChar** argv)
|
||||
#endif
|
||||
{
|
||||
logvisor::RegisterConsoleLogger();
|
||||
|
||||
/* Load data */
|
||||
std::string desc;
|
||||
bool good = false;
|
||||
amuse::IntrusiveAudioGroupData data = LoadFromArgs(argc, argv, desc, good);
|
||||
if (!good)
|
||||
Log.report(logvisor::Fatal, "incomplete data in args");
|
||||
printf("Found '%s' Audio Group data\n", desc.c_str());
|
||||
|
||||
/* Load project to assemble group list */
|
||||
amuse::AudioGroupProject proj(data.getProj());
|
||||
|
||||
/* Get group selection from user */
|
||||
int groupId;
|
||||
bool sfxGroup;
|
||||
size_t totalGroups = proj.sfxGroups().size() + proj.songGroups().size();
|
||||
if (totalGroups > 1)
|
||||
{
|
||||
/* Ask user to specify which group in project */
|
||||
printf("Multiple Audio Groups discovered:\n");
|
||||
for (const auto& pair : proj.songGroups())
|
||||
{
|
||||
printf(" %d (SongGroup) %" PRISize " normal-pages, %" PRISize " drum-pages\n",
|
||||
pair.first, pair.second.m_normPages.size(), pair.second.m_drumPages.size());
|
||||
}
|
||||
for (const auto& pair : proj.sfxGroups())
|
||||
{
|
||||
printf(" %d (SFXGroup) %" PRISize " sfx-entries\n",
|
||||
pair.first, pair.second.m_sfxEntries.size());
|
||||
}
|
||||
|
||||
int userSel = 0;
|
||||
printf("Enter Group Number: ");
|
||||
if (scanf("%d", &userSel) <= 0)
|
||||
Log.report(logvisor::Fatal, "unable to parse prompt");
|
||||
|
||||
if (proj.getSongGroupIndex(userSel))
|
||||
{
|
||||
groupId = userSel;
|
||||
sfxGroup = false;
|
||||
}
|
||||
else if (proj.getSFXGroupIndex(userSel))
|
||||
{
|
||||
groupId = userSel;
|
||||
sfxGroup = true;
|
||||
}
|
||||
else
|
||||
Log.report(logvisor::Fatal, "unable to find Group %d", userSel);
|
||||
}
|
||||
else if (totalGroups == 1)
|
||||
{
|
||||
/* Load one and only group */
|
||||
if (proj.songGroups().size())
|
||||
{
|
||||
const auto& pair = *proj.songGroups().cbegin();
|
||||
groupId = pair.first;
|
||||
sfxGroup = false;
|
||||
}
|
||||
else
|
||||
{
|
||||
const auto& pair = *proj.sfxGroups().cbegin();
|
||||
groupId = pair.first;
|
||||
sfxGroup = true;
|
||||
}
|
||||
}
|
||||
else
|
||||
Log.report(logvisor::Fatal, "empty project");
|
||||
|
||||
/* Build voice engine */
|
||||
std::unique_ptr<boo::IAudioVoiceEngine> voxEngine = boo::NewAudioVoiceEngine();
|
||||
amuse::BooBackendVoiceAllocator booBackend(*voxEngine);
|
||||
amuse::Engine engine(booBackend);
|
||||
|
||||
engine.addAudioGroup(groupId, data);
|
||||
|
||||
amuse::Voice* vox = engine.fxStart(1, 1.f, 0.f);
|
||||
|
||||
for (int f=0 ; f<300 ; ++f)
|
||||
{
|
||||
engine.pumpEngine();
|
||||
std::this_thread::sleep_for(std::chrono::milliseconds(15));
|
||||
}
|
||||
|
||||
vox->keyOff();
|
||||
|
||||
for (int f=0 ; f<120 ; ++f)
|
||||
{
|
||||
engine.pumpEngine();
|
||||
std::this_thread::sleep_for(std::chrono::milliseconds(15));
|
||||
}
|
||||
|
||||
return 0;
|
||||
AppCallback app(argc, argv);
|
||||
int ret = boo::ApplicationRun(boo::IApplication::EPlatformType::Auto,
|
||||
app, _S("amusetool"), _S("Amuse Tool"), argc, argv);
|
||||
printf("IM DYING!!\n");
|
||||
return ret;
|
||||
}
|
||||
|
||||
#if _WIN32
|
||||
int APIENTRY wWinMain(HINSTANCE hInstance, HINSTANCE, LPWSTR lpCmdLine, int)
|
||||
{
|
||||
int argc = 0;
|
||||
const boo::SystemChar** argv = (const wchar_t**)(CommandLineToArgvW(lpCmdLine, &argc));
|
||||
static boo::SystemChar selfPath[1024];
|
||||
GetModuleFileNameW(nullptr, selfPath, 1024);
|
||||
static const boo::SystemChar* booArgv[32] = {};
|
||||
booArgv[0] = selfPath;
|
||||
for (int i=0 ; i<argc ; ++i)
|
||||
booArgv[i+1] = argv[i];
|
||||
|
||||
logvisor::CreateWin32Console();
|
||||
return wmain(argc+1, booArgv);
|
||||
}
|
||||
#endif
|
||||
|
|
|
@ -9,11 +9,14 @@ namespace amuse
|
|||
{
|
||||
class AudioGroupData;
|
||||
|
||||
using Sample = std::pair<AudioGroupSampleDirectory::Entry,
|
||||
AudioGroupSampleDirectory::ADPCMParms>;
|
||||
|
||||
class AudioGroup
|
||||
{
|
||||
int m_groupId;
|
||||
AudioGroupPool m_pool;
|
||||
AudioGroupProject m_proj;
|
||||
AudioGroupPool m_pool;
|
||||
AudioGroupSampleDirectory m_sdir;
|
||||
const unsigned char* m_samp;
|
||||
bool m_valid;
|
||||
|
@ -25,8 +28,10 @@ public:
|
|||
bool sfxInGroup(int sfxId) const;
|
||||
bool songInGroup(int songId) const;
|
||||
|
||||
const AudioGroupPool& getPool() const;
|
||||
const AudioGroupSampleDirectory::Entry* getSfxEntry(int sfxId) const;
|
||||
const Sample* getSample(int sfxId) const;
|
||||
const unsigned char* getSampleData(uint32_t offset) const;
|
||||
const AudioGroupProject& getProj() const {return m_proj;}
|
||||
const AudioGroupPool& getPool() const {return m_pool;}
|
||||
};
|
||||
|
||||
}
|
||||
|
|
|
@ -9,7 +9,14 @@
|
|||
namespace amuse
|
||||
{
|
||||
|
||||
struct AudioGroupIndex {};
|
||||
/** Common index members of SongGroups and SFXGroups */
|
||||
struct AudioGroupIndex
|
||||
{
|
||||
const uint16_t* m_soundMacroIndex;
|
||||
const uint16_t* m_tablesIndex;
|
||||
const uint16_t* m_keymapsIndex;
|
||||
const uint16_t* m_layersIndex;
|
||||
};
|
||||
|
||||
/** Root index of SongGroup */
|
||||
struct SongGroupIndex : AudioGroupIndex
|
||||
|
|
|
@ -1,7 +1,7 @@
|
|||
#ifndef __AMUSE_AUDIOGROUPSAMPLEDIR_HPP__
|
||||
#define __AMUSE_AUDIOGROUPSAMPLEDIR_HPP__
|
||||
|
||||
#include <vector>
|
||||
#include <unordered_map>
|
||||
#include <stdint.h>
|
||||
|
||||
namespace amuse
|
||||
|
@ -31,11 +31,11 @@ public:
|
|||
uint8_t m_lps;
|
||||
int16_t m_hist1;
|
||||
int16_t m_hist2;
|
||||
int16_t m_coefs[16];
|
||||
int16_t m_coefs[8][2];
|
||||
void swapBig();
|
||||
};
|
||||
private:
|
||||
std::vector<std::pair<Entry, ADPCMParms>> m_entries;
|
||||
std::unordered_map<uint16_t, std::pair<Entry, ADPCMParms>> m_entries;
|
||||
public:
|
||||
AudioGroupSampleDirectory(const unsigned char* data);
|
||||
};
|
||||
|
|
|
@ -27,6 +27,7 @@ public:
|
|||
double sampleRate, bool dynamicPitch);
|
||||
BooBackendVoice(boo::IAudioSubmix& submix, Voice& clientVox,
|
||||
double sampleRate, bool dynamicPitch);
|
||||
void resetSampleRate(double sampleRate);
|
||||
void setMatrixCoefficients(const float coefs[8]);
|
||||
void setPitchRatio(double ratio);
|
||||
void start();
|
||||
|
@ -66,6 +67,7 @@ public:
|
|||
BooBackendVoiceAllocator(boo::IAudioVoiceEngine& booEngine);
|
||||
std::unique_ptr<IBackendVoice> allocateVoice(Voice& clientVox, double sampleRate, bool dynamicPitch);
|
||||
std::unique_ptr<IBackendSubmix> allocateSubmix(Submix& clientSmx);
|
||||
AudioChannelSet getAvailableSet();
|
||||
};
|
||||
|
||||
}
|
||||
|
|
|
@ -28,6 +28,7 @@ class Engine
|
|||
std::list<Emitter> m_activeEmitters;
|
||||
std::list<Sequencer> m_activeSequencers;
|
||||
std::list<Submix> m_activeSubmixes;
|
||||
std::unordered_map<uint16_t, std::pair<AudioGroup*, ObjectId>> m_sfxLookup;
|
||||
std::linear_congruential_engine<uint32_t, 0x41c64e6d, 0x3039, UINT32_MAX> m_random;
|
||||
int m_nextVid = 0;
|
||||
Voice* _allocateVoice(const AudioGroup& group, double sampleRate,
|
||||
|
@ -35,8 +36,6 @@ class Engine
|
|||
Submix* _allocateSubmix(Submix* smx);
|
||||
std::list<Voice>::iterator _destroyVoice(Voice* voice);
|
||||
std::list<Submix>::iterator _destroySubmix(Submix* smx);
|
||||
AudioGroup* _findGroupFromSfxId(int sfxId, const AudioGroupSampleDirectory::Entry*& entOut) const;
|
||||
AudioGroup* _findGroupFromSongId(int songId) const;
|
||||
public:
|
||||
Engine(IBackendVoiceAllocator& backend);
|
||||
|
||||
|
@ -64,7 +63,7 @@ public:
|
|||
Submix* smx=nullptr);
|
||||
|
||||
/** Start song playing from loaded audio groups */
|
||||
Sequencer* seqPlay(int songId, const unsigned char* arrData);
|
||||
Sequencer* seqPlay(int groupId, int songId, const unsigned char* arrData);
|
||||
|
||||
/** Find voice from VoiceId */
|
||||
Voice* findVoice(int vid);
|
||||
|
|
|
@ -21,15 +21,7 @@ enum class ObjectType : uint8_t
|
|||
|
||||
/** Common ID structure statically tagging
|
||||
* SoundMacros, Tables, Keymaps, Layers */
|
||||
struct ObjectId
|
||||
{
|
||||
ObjectType type = ObjectType::Invalid;
|
||||
uint8_t id = 0xff;
|
||||
bool operator ==(const ObjectId& other) const
|
||||
{return *reinterpret_cast<const uint16_t*>(this) == reinterpret_cast<const uint16_t&>(other);}
|
||||
bool operator !=(const ObjectId& other) const
|
||||
{return *reinterpret_cast<const uint16_t*>(this) != reinterpret_cast<const uint16_t&>(other);}
|
||||
};
|
||||
using ObjectId = uint16_t;
|
||||
|
||||
/** Common 'engine child' class */
|
||||
class Entity
|
||||
|
@ -65,13 +57,4 @@ using Curve = uint8_t[128];
|
|||
|
||||
}
|
||||
|
||||
namespace std
|
||||
{
|
||||
template <> struct hash<amuse::ObjectId>
|
||||
{
|
||||
size_t operator()(const amuse::ObjectId& val) const noexcept
|
||||
{return std::hash<uint16_t>()(reinterpret_cast<const uint16_t&>(val));}
|
||||
};
|
||||
}
|
||||
|
||||
#endif // __AMUSE_ENTITY_HPP__
|
||||
|
|
|
@ -33,6 +33,9 @@ class IBackendVoice
|
|||
public:
|
||||
virtual ~IBackendVoice() = default;
|
||||
|
||||
/** Set new sample rate into platform voice (may result in artifacts while playing) */
|
||||
virtual void resetSampleRate(double sampleRate)=0;
|
||||
|
||||
/** Set channel-gains for audio source (AudioChannel enum for array index) */
|
||||
virtual void setMatrixCoefficients(const float coefs[8])=0;
|
||||
|
||||
|
|
|
@ -10,6 +10,16 @@ class IBackendSubmix;
|
|||
class Voice;
|
||||
class Submix;
|
||||
|
||||
/** Same enum as boo for describing speaker-configuration */
|
||||
enum class AudioChannelSet
|
||||
{
|
||||
Stereo,
|
||||
Quad,
|
||||
Surround51,
|
||||
Surround71,
|
||||
Unknown = 0xff
|
||||
};
|
||||
|
||||
/**
|
||||
* @brief Client-implemented voice allocator
|
||||
*/
|
||||
|
@ -19,10 +29,15 @@ public:
|
|||
virtual ~IBackendVoiceAllocator() = default;
|
||||
|
||||
/** Amuse obtains a new voice from the platform this way */
|
||||
virtual std::unique_ptr<IBackendVoice> allocateVoice(Voice& clientVox, double sampleRate, bool dynamicPitch)=0;
|
||||
virtual std::unique_ptr<IBackendVoice> allocateVoice(Voice& clientVox,
|
||||
double sampleRate,
|
||||
bool dynamicPitch)=0;
|
||||
|
||||
/** Amuse obtains a new submix from the platform this way */
|
||||
virtual std::unique_ptr<IBackendSubmix> allocateSubmix(Submix& clientSmx)=0;
|
||||
|
||||
/** Amuse obtains speaker-configuration from the platform this way */
|
||||
virtual AudioChannelSet getAvailableSet()=0;
|
||||
};
|
||||
|
||||
}
|
||||
|
|
|
@ -0,0 +1,24 @@
|
|||
#ifndef __AMUSE_SURROUNDPROFILES_HPP__
|
||||
#define __AMUSE_SURROUNDPROFILES_HPP__
|
||||
|
||||
#include "IBackendVoice.hpp"
|
||||
#include "IBackendVoiceAllocator.hpp"
|
||||
#include "Emitter.hpp"
|
||||
|
||||
namespace amuse
|
||||
{
|
||||
struct ReferenceVector;
|
||||
|
||||
class SurroundProfiles
|
||||
{
|
||||
static void SetupRefs(float matOut[8], const ChannelMap& map,
|
||||
const Vector3f& listenEmit, const ReferenceVector refs[]);
|
||||
public:
|
||||
static void SetupMatrix(float matOut[8], const ChannelMap& map, AudioChannelSet set,
|
||||
const Vector3f& emitPos, const Vector3f& listenPos,
|
||||
const Vector3f& listenDir, const Vector3f& listenUp);
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#endif // __AMUSE_SURROUNDPROFILES_HPP__
|
|
@ -7,6 +7,8 @@
|
|||
#include <list>
|
||||
#include "SoundMacroState.hpp"
|
||||
#include "Entity.hpp"
|
||||
#include "AudioGroupSampleDirectory.hpp"
|
||||
#include "AudioGroup.hpp"
|
||||
|
||||
namespace amuse
|
||||
{
|
||||
|
@ -35,7 +37,20 @@ class Voice : public Entity
|
|||
uint8_t m_lastNote = 0; /**< Last MIDI semitone played by voice */
|
||||
uint8_t m_keygroup = 0; /**< Keygroup voice is a member of */
|
||||
|
||||
const Sample* m_curSample = nullptr; /**< Current sample entry playing */
|
||||
const unsigned char* m_curSampleData = nullptr; /**< Current sample data playing */
|
||||
uint32_t m_curSamplePos = 0; /**< Current sample position */
|
||||
uint32_t m_lastSamplePos = 0; /**< Last sample position (or last loop sample) */
|
||||
int16_t m_prev1 = 0; /**< DSPADPCM prev sample */
|
||||
int16_t m_prev2 = 0; /**< DSPADPCM prev-prev sample */
|
||||
|
||||
VoiceState m_voxState = VoiceState::Finished; /**< Current high-level state of voice */
|
||||
bool m_sustained = false; /**< Sustain pedal pressed for this voice */
|
||||
bool m_sustainKeyOff = false; /**< Keyoff event occured while sustained */
|
||||
|
||||
void _destroy();
|
||||
bool _checkSamplePos();
|
||||
void _doKeyOff();
|
||||
|
||||
public:
|
||||
Voice(Engine& engine, const AudioGroup& group, int vid, bool emitter, Submix* smx);
|
||||
|
@ -49,7 +64,7 @@ public:
|
|||
Submix* getSubmix() {return m_submix;}
|
||||
|
||||
/** Get current state of voice */
|
||||
VoiceState state() const;
|
||||
VoiceState state() const {return m_voxState;}
|
||||
|
||||
/** Get VoiceId of this voice (unique to all currently-playing voices) */
|
||||
int vid() const {return m_vid;}
|
||||
|
@ -60,34 +75,63 @@ public:
|
|||
/** Load specified SoundMacro ID of within group into voice */
|
||||
bool loadSoundMacro(ObjectId macroId, int macroStep=0, bool pushPc=false);
|
||||
|
||||
/** Signals voice to begin fade-out, eventually reaching silence */
|
||||
/** Signals voice to begin fade-out (or defer if sustained), eventually reaching silence */
|
||||
void keyOff();
|
||||
|
||||
/** Sends numeric message to voice and all siblings */
|
||||
void message(int32_t val);
|
||||
|
||||
/** Start playing specified sample from within group, optionally by sample offset */
|
||||
void startSample(int16_t sampId, int32_t offset);
|
||||
|
||||
/** Stop playing current sample */
|
||||
void stopSample();
|
||||
|
||||
/** Set current voice volume immediately */
|
||||
void setVolume(float vol);
|
||||
|
||||
/** Set current voice panning immediately */
|
||||
void setPanning(float pan);
|
||||
|
||||
/** Set current voice surround-panning immediately */
|
||||
void setSurroundPanning(float span);
|
||||
|
||||
/** Set voice relative-pitch in cents */
|
||||
void setPitchKey(int32_t cents);
|
||||
|
||||
/** Set voice modulation */
|
||||
void setModulation(float mod);
|
||||
|
||||
/** Set sustain status within voice; clearing will trigger a deferred keyoff */
|
||||
void setPedal(bool pedal);
|
||||
|
||||
/** Set doppler factor for voice */
|
||||
void setDoppler(float doppler);
|
||||
|
||||
/** Set reverb mix for voice */
|
||||
void setReverbVol(float rvol);
|
||||
|
||||
/** Set envelope for voice */
|
||||
void setAdsr(ObjectId adsrId);
|
||||
|
||||
/** Set pitch in absolute hertz */
|
||||
void setPitchFrequency(uint32_t hz, uint16_t fine);
|
||||
|
||||
/** Set pitch envelope */
|
||||
void setPitchAdsr(ObjectId adsrId, int32_t cents);
|
||||
|
||||
/** Set effective pitch range via the pitchwheel controller */
|
||||
void setPitchWheelRange(int8_t up, int8_t down);
|
||||
|
||||
/** Assign voice to keygroup for coordinated mass-silencing */
|
||||
void setKeygroup(uint8_t kg) {m_keygroup = kg;}
|
||||
|
||||
uint8_t getLastNote() const {return m_lastNote;}
|
||||
int8_t getCtrlValue(uint8_t ctrl) const;
|
||||
void setCtrlValue(uint8_t ctrl, int8_t val);
|
||||
int8_t getPitchWheel() const;
|
||||
int8_t getModWheel() const;
|
||||
int8_t getAftertouch() const;
|
||||
int8_t getCtrlValue(uint8_t ctrl) const {}
|
||||
void setCtrlValue(uint8_t ctrl, int8_t val) {}
|
||||
int8_t getPitchWheel() const {}
|
||||
int8_t getModWheel() const {}
|
||||
int8_t getAftertouch() const {}
|
||||
|
||||
};
|
||||
|
||||
|
|
|
@ -0,0 +1,34 @@
|
|||
#ifndef _DSP_h
|
||||
#define _DSP_h
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include <stdint.h>
|
||||
|
||||
static inline int16_t DSPSampClamp(int32_t val)
|
||||
{
|
||||
if (val < -32768) val = -32768;
|
||||
else if (val > 32767) val = 32767;
|
||||
return val;
|
||||
}
|
||||
|
||||
unsigned DSPDecompressFrameRanged(int16_t* out, const uint8_t* in,
|
||||
const int16_t coefs[8][2], int16_t* prev1, int16_t* prev2,
|
||||
unsigned firstSample, unsigned lastSample);
|
||||
unsigned DSPDecompressFrame(int16_t* out, const uint8_t* in,
|
||||
const int16_t coefs[8][2], int16_t* prev1, int16_t* prev2,
|
||||
unsigned lastSample);
|
||||
unsigned DSPDecompressFrameStereoStride(int16_t* out, const uint8_t* in,
|
||||
const int16_t coefs[8][2], int16_t* prev1, int16_t* prev2,
|
||||
unsigned lastSample);
|
||||
unsigned DSPDecompressFrameStereoDupe(int16_t* out, const uint8_t* in,
|
||||
const int16_t coefs[8][2], int16_t* prev1, int16_t* prev2,
|
||||
unsigned lastSample);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif // _DSP_h
|
|
@ -20,12 +20,17 @@ bool AudioGroup::songInGroup(int songId) const
|
|||
{
|
||||
}
|
||||
|
||||
const AudioGroupSampleDirectory::Entry* AudioGroup::getSfxEntry(int sfxId) const
|
||||
const Sample* AudioGroup::getSample(int sfxId) const
|
||||
{
|
||||
for (const auto& ent : m_sdir.m_entries)
|
||||
if (ent.first.m_sfxId == sfxId)
|
||||
return &ent.first;
|
||||
if (ent.second.first.m_sfxId == sfxId)
|
||||
return &ent.second;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
const unsigned char* AudioGroup::getSampleData(uint32_t offset) const
|
||||
{
|
||||
return m_samp + offset;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
@ -49,14 +49,17 @@ AudioGroupProject::AudioGroupProject(const unsigned char* data)
|
|||
GroupHeader header = *group;
|
||||
header.swapBig();
|
||||
|
||||
AudioGroupIndex* bIdx = nullptr;
|
||||
|
||||
if (header.type == GroupType::Song)
|
||||
{
|
||||
SongGroupIndex& idx = m_songGroups[header.groupId];
|
||||
bIdx = &idx;
|
||||
|
||||
/* Normal pages */
|
||||
const SongGroupIndex::PageEntry* normEntries =
|
||||
reinterpret_cast<const SongGroupIndex::PageEntry*>(data + header.pageTableOff);
|
||||
while (normEntries->objId.type != ObjectType::Invalid)
|
||||
while (normEntries->objId != 0xffff)
|
||||
{
|
||||
idx.m_normPages[normEntries->programNo] = normEntries;
|
||||
++normEntries;
|
||||
|
@ -65,7 +68,7 @@ AudioGroupProject::AudioGroupProject(const unsigned char* data)
|
|||
/* Drum pages */
|
||||
const SongGroupIndex::PageEntry* drumEntries =
|
||||
reinterpret_cast<const SongGroupIndex::PageEntry*>(data + header.drumTableOff);
|
||||
while (drumEntries->objId.type != ObjectType::Invalid)
|
||||
while (drumEntries->objId != 0xffff)
|
||||
{
|
||||
idx.m_drumPages[drumEntries->programNo] = drumEntries;
|
||||
++drumEntries;
|
||||
|
@ -85,17 +88,26 @@ AudioGroupProject::AudioGroupProject(const unsigned char* data)
|
|||
else if (header.type == GroupType::SFX)
|
||||
{
|
||||
SFXGroupIndex& idx = m_sfxGroups[header.groupId];
|
||||
bIdx = &idx;
|
||||
|
||||
/* SFX entries */
|
||||
const SFXGroupIndex::SFXEntry* entries =
|
||||
reinterpret_cast<const SFXGroupIndex::SFXEntry*>(data + header.pageTableOff);
|
||||
while (entries->objId.type != ObjectType::Invalid)
|
||||
while (entries->objId != 0xffff)
|
||||
{
|
||||
idx.m_sfxEntries[SBig(entries->defineId)] = entries;
|
||||
++entries;
|
||||
}
|
||||
}
|
||||
|
||||
if (bIdx)
|
||||
{
|
||||
bIdx->m_soundMacroIndex = reinterpret_cast<const uint16_t*>(data + header.soundMacroIdsOff);
|
||||
bIdx->m_tablesIndex = reinterpret_cast<const uint16_t*>(data + header.tableIdsOff);
|
||||
bIdx->m_keymapsIndex = reinterpret_cast<const uint16_t*>(data + header.keymapIdsOff);
|
||||
bIdx->m_layersIndex = reinterpret_cast<const uint16_t*>(data + header.layerIdsOff);
|
||||
}
|
||||
|
||||
group = reinterpret_cast<const GroupHeader*>(data + header.groupEndOff);
|
||||
}
|
||||
}
|
||||
|
|
|
@ -21,8 +21,11 @@ void AudioGroupSampleDirectory::ADPCMParms::swapBig()
|
|||
m_bytesPerFrame = SBig(m_bytesPerFrame);
|
||||
m_hist1 = SBig(m_hist1);
|
||||
m_hist2 = SBig(m_hist2);
|
||||
for (int i=0 ; i<16 ; ++i)
|
||||
m_coefs[i] = SBig(m_coefs[i]);
|
||||
for (int i=0 ; i<8 ; ++i)
|
||||
{
|
||||
m_coefs[i][0] = SBig(m_coefs[i][0]);
|
||||
m_coefs[i][1] = SBig(m_coefs[i][1]);
|
||||
}
|
||||
}
|
||||
|
||||
AudioGroupSampleDirectory::AudioGroupSampleDirectory(const unsigned char* data)
|
||||
|
|
|
@ -23,6 +23,11 @@ BooBackendVoice::BooBackendVoice(boo::IAudioSubmix& submix, Voice& clientVox,
|
|||
m_booVoice(submix.allocateNewMonoVoice(sampleRate, &m_cb, dynamicPitch))
|
||||
{}
|
||||
|
||||
void BooBackendVoice::resetSampleRate(double sampleRate)
|
||||
{
|
||||
m_booVoice->resetSampleRate(sampleRate);
|
||||
}
|
||||
|
||||
void BooBackendVoice::setMatrixCoefficients(const float coefs[8])
|
||||
{
|
||||
m_booVoice->setMonoMatrixCoefficients(coefs);
|
||||
|
@ -100,4 +105,9 @@ std::unique_ptr<IBackendSubmix> BooBackendVoiceAllocator::allocateSubmix(Submix&
|
|||
return std::make_unique<BooBackendSubmix>(m_booEngine, clientSmx);
|
||||
}
|
||||
|
||||
AudioChannelSet BooBackendVoiceAllocator::getAvailableSet()
|
||||
{
|
||||
return AudioChannelSet(m_booEngine.getAvailableSet());
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
@ -6,6 +6,7 @@
|
|||
#include "amuse/IBackendVoiceAllocator.hpp"
|
||||
#include "amuse/AudioGroupData.hpp"
|
||||
#include "amuse/AudioGroup.hpp"
|
||||
#include "amuse/Common.hpp"
|
||||
|
||||
namespace amuse
|
||||
{
|
||||
|
@ -50,25 +51,6 @@ std::list<Submix>::iterator Engine::_destroySubmix(Submix* smx)
|
|||
return m_activeSubmixes.erase(smx->m_engineIt);
|
||||
}
|
||||
|
||||
AudioGroup* Engine::_findGroupFromSfxId(int sfxId, const AudioGroupSampleDirectory::Entry*& entOut) const
|
||||
{
|
||||
for (const auto& grp : m_audioGroups)
|
||||
{
|
||||
entOut = grp.second->getSfxEntry(sfxId);
|
||||
if (entOut)
|
||||
return grp.second.get();
|
||||
}
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
AudioGroup* Engine::_findGroupFromSongId(int songId) const
|
||||
{
|
||||
for (const auto& grp : m_audioGroups)
|
||||
if (grp.second->songInGroup(songId))
|
||||
return grp.second.get();
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
/** Update all active audio entities and fill OS audio buffers as needed */
|
||||
void Engine::pumpEngine()
|
||||
{
|
||||
|
@ -88,12 +70,28 @@ const AudioGroup* Engine::addAudioGroup(int groupId, const AudioGroupData& data)
|
|||
return nullptr;
|
||||
AudioGroup* ret = grp.get();
|
||||
m_audioGroups.emplace(std::make_pair(groupId, std::move(grp)));
|
||||
|
||||
/* setup SFX index for contained objects */
|
||||
for (const auto& pair : ret->getProj().sfxGroups())
|
||||
{
|
||||
const SFXGroupIndex& sfxGroup = pair.second;
|
||||
m_sfxLookup.reserve(m_sfxLookup.size() + sfxGroup.m_sfxEntries.size());
|
||||
for (const auto& pair : sfxGroup.m_sfxEntries)
|
||||
m_sfxLookup[pair.first] = std::make_pair(ret, pair.second->objId);
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
/** Remove audio group from engine */
|
||||
void Engine::removeAudioGroup(int groupId)
|
||||
{
|
||||
auto search = m_audioGroups.find(groupId);
|
||||
if (search == m_audioGroups.end())
|
||||
return;
|
||||
AudioGroup* grp = search->second.get();
|
||||
|
||||
/* Destroy runtime entities within group */
|
||||
for (auto it = m_activeVoices.begin() ; it != m_activeVoices.end() ;)
|
||||
{
|
||||
if (it->getAudioGroup().groupId() == groupId)
|
||||
|
@ -127,6 +125,14 @@ void Engine::removeAudioGroup(int groupId)
|
|||
++it;
|
||||
}
|
||||
|
||||
/* teardown SFX index for contained objects */
|
||||
for (const auto& pair : grp->getProj().sfxGroups())
|
||||
{
|
||||
const SFXGroupIndex& sfxGroup = pair.second;
|
||||
for (const auto& pair : sfxGroup.m_sfxEntries)
|
||||
m_sfxLookup.erase(pair.first);
|
||||
}
|
||||
|
||||
m_audioGroups.erase(groupId);
|
||||
}
|
||||
|
||||
|
@ -172,12 +178,15 @@ void Engine::removeSubmix(Submix* smx)
|
|||
/** Start soundFX playing from loaded audio groups */
|
||||
Voice* Engine::fxStart(int sfxId, float vol, float pan, Submix* smx)
|
||||
{
|
||||
const AudioGroupSampleDirectory::Entry* entry;
|
||||
AudioGroup* grp = _findGroupFromSfxId(sfxId, entry);
|
||||
auto search = m_sfxLookup.find(sfxId);
|
||||
if (search == m_sfxLookup.end())
|
||||
return nullptr;
|
||||
|
||||
AudioGroup* grp = search->second.first;
|
||||
if (!grp)
|
||||
return nullptr;
|
||||
|
||||
Voice* ret = _allocateVoice(*grp, entry->m_sampleRate, true, false, smx);
|
||||
Voice* ret = _allocateVoice(*grp, 32000.0, true, false, smx);
|
||||
ret->setVolume(vol);
|
||||
ret->setPanning(pan);
|
||||
return ret;
|
||||
|
@ -187,12 +196,15 @@ Voice* Engine::fxStart(int sfxId, float vol, float pan, Submix* smx)
|
|||
Emitter* Engine::addEmitter(const Vector3f& pos, const Vector3f& dir, float maxDist,
|
||||
float falloff, int sfxId, float minVol, float maxVol, Submix* smx)
|
||||
{
|
||||
const AudioGroupSampleDirectory::Entry* entry;
|
||||
AudioGroup* grp = _findGroupFromSfxId(sfxId, entry);
|
||||
auto search = m_sfxLookup.find(sfxId);
|
||||
if (search == m_sfxLookup.end())
|
||||
return nullptr;
|
||||
|
||||
AudioGroup* grp = search->second.first;
|
||||
if (!grp)
|
||||
return nullptr;
|
||||
|
||||
Voice* vox = _allocateVoice(*grp, entry->m_sampleRate, true, true, smx);
|
||||
Voice* vox = _allocateVoice(*grp, 32000.0, true, true, smx);
|
||||
m_activeEmitters.emplace_back(*this, *grp, *vox);
|
||||
Emitter& ret = m_activeEmitters.back();
|
||||
ret.setPos(pos);
|
||||
|
@ -206,7 +218,7 @@ Emitter* Engine::addEmitter(const Vector3f& pos, const Vector3f& dir, float maxD
|
|||
}
|
||||
|
||||
/** Start song playing from loaded audio groups */
|
||||
Sequencer* Engine::seqPlay(int songId, const unsigned char* arrData)
|
||||
Sequencer* Engine::seqPlay(int groupId, int songId, const unsigned char* arrData)
|
||||
{
|
||||
}
|
||||
|
||||
|
|
|
@ -511,7 +511,7 @@ bool SoundMacroState::advance(Voice& vox, float dt)
|
|||
int32_t eval = int32_t(orgVel ? m_initVel : m_curVel) * scale / 127 + add;
|
||||
eval = std::max(0, std::min(127, eval));
|
||||
|
||||
if (curve.id != 0)
|
||||
if (curve != 0)
|
||||
{
|
||||
const Curve* curveData = vox.getAudioGroup().getPool().tableAsCurves(curve);
|
||||
if (curveData)
|
||||
|
@ -558,7 +558,7 @@ bool SoundMacroState::advance(Voice& vox, float dt)
|
|||
m_envelopeStart = m_curVel;
|
||||
m_envelopeEnd = eval;
|
||||
|
||||
if (curve.id != 0)
|
||||
if (curve != 0)
|
||||
m_envelopeCurve = vox.getAudioGroup().getPool().tableAsCurves(curve);
|
||||
else
|
||||
m_envelopeCurve = nullptr;
|
||||
|
@ -632,7 +632,7 @@ bool SoundMacroState::advance(Voice& vox, float dt)
|
|||
m_envelopeStart = 0.f;
|
||||
m_envelopeEnd = eval;
|
||||
|
||||
if (curve.id != 0)
|
||||
if (curve != 0)
|
||||
m_envelopeCurve = vox.getAudioGroup().getPool().tableAsCurves(curve);
|
||||
else
|
||||
m_envelopeCurve = nullptr;
|
||||
|
@ -1333,7 +1333,7 @@ void SoundMacroState::keyoffNotify(Voice& vox)
|
|||
if (m_inWait && m_keyoffWait)
|
||||
m_inWait = false;
|
||||
|
||||
if (m_keyoffTrap.macroId.id != 0xff)
|
||||
if (m_keyoffTrap.macroId != 0xffff)
|
||||
{
|
||||
if (m_keyoffTrap.macroId == m_header.m_macroId)
|
||||
m_pc.back().second = m_keyoffTrap.macroStep;
|
||||
|
@ -1348,7 +1348,7 @@ void SoundMacroState::sampleEndNotify(Voice& vox)
|
|||
if (m_inWait && m_sampleEndWait)
|
||||
m_inWait = false;
|
||||
|
||||
if (m_sampleEndTrap.macroId.id != 0xff)
|
||||
if (m_sampleEndTrap.macroId != 0xffff)
|
||||
{
|
||||
if (m_sampleEndTrap.macroId == m_header.m_macroId)
|
||||
m_pc.back().second = m_sampleEndTrap.macroStep;
|
||||
|
@ -1361,7 +1361,7 @@ void SoundMacroState::messageNotify(Voice& vox, int32_t val)
|
|||
{
|
||||
m_messageQueue.push_back(val);
|
||||
|
||||
if (m_messageTrap.macroId.id != 0xff)
|
||||
if (m_messageTrap.macroId != 0xffff)
|
||||
{
|
||||
if (m_messageTrap.macroId == m_header.m_macroId)
|
||||
m_pc.back().second = m_messageTrap.macroStep;
|
||||
|
|
|
@ -0,0 +1,172 @@
|
|||
#include "amuse/SurroundProfiles.hpp"
|
||||
#include <cmath>
|
||||
#include <cfloat>
|
||||
|
||||
namespace amuse
|
||||
{
|
||||
|
||||
static float Dot(const Vector3f& a, const Vector3f& b)
|
||||
{
|
||||
return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
|
||||
}
|
||||
|
||||
static float Length(const Vector3f& a)
|
||||
{
|
||||
if (a[0] <= FLT_EPSILON && a[1] <= FLT_EPSILON && a[2] <= FLT_EPSILON)
|
||||
return 0.f;
|
||||
return std::sqrt(Dot(a, a));
|
||||
}
|
||||
|
||||
static float Normalize(Vector3f& out, const Vector3f& in)
|
||||
{
|
||||
out[0] = in[0];
|
||||
out[1] = in[1];
|
||||
out[2] = in[2];
|
||||
float dist = Length(out);
|
||||
out[0] /= dist;
|
||||
out[1] /= dist;
|
||||
out[2] /= dist;
|
||||
return dist;
|
||||
}
|
||||
|
||||
static void Cross(Vector3f& out, const Vector3f& a, const Vector3f& b)
|
||||
{
|
||||
out[0] = a[1] * b[2] - a[2] * b[1];
|
||||
out[1] = a[2] * b[0] - a[0] * b[2];
|
||||
out[2] = a[0] * b[1] - a[1] * b[0];
|
||||
}
|
||||
|
||||
class SimpleMatrix
|
||||
{
|
||||
Vector3f m_mat[3];
|
||||
public:
|
||||
SimpleMatrix(const Vector3f& dir, const Vector3f& up)
|
||||
{
|
||||
Vector3f temp;
|
||||
Normalize(temp, dir);
|
||||
m_mat[0][1] = temp[0];
|
||||
m_mat[1][1] = temp[1];
|
||||
m_mat[2][1] = temp[2];
|
||||
|
||||
Normalize(temp, up);
|
||||
m_mat[0][2] = temp[0];
|
||||
m_mat[1][2] = temp[1];
|
||||
m_mat[2][2] = temp[2];
|
||||
|
||||
Cross(temp, dir, up);
|
||||
m_mat[0][0] = temp[0];
|
||||
m_mat[1][0] = temp[1];
|
||||
m_mat[2][0] = temp[2];
|
||||
}
|
||||
|
||||
void vecMult(Vector3f& out, const Vector3f& in)
|
||||
{
|
||||
out[0] = Dot(m_mat[0], in);
|
||||
out[1] = Dot(m_mat[1], in);
|
||||
out[2] = Dot(m_mat[2], in);
|
||||
}
|
||||
};
|
||||
|
||||
struct ReferenceVector
|
||||
{
|
||||
Vector3f vec;
|
||||
float bias;
|
||||
bool valid = false;
|
||||
ReferenceVector() = default;
|
||||
ReferenceVector(float x, float y, float z, float thres)
|
||||
{
|
||||
vec[0] = x;
|
||||
vec[1] = y;
|
||||
vec[2] = z;
|
||||
bias = thres;
|
||||
valid = true;
|
||||
}
|
||||
};
|
||||
|
||||
static const ReferenceVector StereoVectors[8] =
|
||||
{
|
||||
{-0.80901f, 0.58778f, 0.f, 0.3f},
|
||||
{ 0.80901f, 0.58778f, 0.f, 0.3f},
|
||||
};
|
||||
|
||||
static const ReferenceVector QuadVectors[8] =
|
||||
{
|
||||
{-0.70710f, 0.70710f, 0.f, 0.1f},
|
||||
{ 0.70710f, 0.70710f, 0.f, 0.1f},
|
||||
{-0.70710f, -0.70710f, 0.f, 0.1f},
|
||||
{ 0.70710f, -0.70710f, 0.f, 0.1f},
|
||||
};
|
||||
|
||||
static const ReferenceVector Sur51Vectors[8] =
|
||||
{
|
||||
{-0.70710f, 0.70710f, 0.f, 0.1f},
|
||||
{ 0.70710f, 0.70710f, 0.f, 0.1f},
|
||||
{-0.70710f, -0.70710f, 0.f, 0.1f},
|
||||
{ 0.70710f, -0.70710f, 0.f, 0.1f},
|
||||
{ 0.0f, 1.0f, 0.f, 0.1f},
|
||||
{ 0.0f, 1.0f, 0.f, 1.0f},
|
||||
};
|
||||
|
||||
static const ReferenceVector Sur71Vectors[8] =
|
||||
{
|
||||
{-0.70710f, 0.70710f, 0.f, 0.1f},
|
||||
{ 0.70710f, 0.70710f, 0.f, 0.1f},
|
||||
{-0.70710f, -0.70710f, 0.f, 0.1f},
|
||||
{ 0.70710f, -0.70710f, 0.f, 0.1f},
|
||||
{ 0.0f, 1.0f, 0.f, 0.1f},
|
||||
{ 0.0f, 1.0f, 0.f, 1.0f},
|
||||
{-1.f, 0.0f, 0.f, 0.1f},
|
||||
{ 1.f, 0.0f, 0.f, 0.1f},
|
||||
};
|
||||
|
||||
void SurroundProfiles::SetupRefs(float matOut[8], const ChannelMap& map,
|
||||
const Vector3f& listenEmit, const ReferenceVector refs[])
|
||||
{
|
||||
for (unsigned i=0 ; i<map.m_channelCount && i<8 ; ++i)
|
||||
{
|
||||
matOut[i] = 0.f;
|
||||
if (map.m_channels[i] == AudioChannel::Unknown)
|
||||
continue;
|
||||
const ReferenceVector& refVec = refs[int(map.m_channels[i])];
|
||||
if (!refVec.valid)
|
||||
continue;
|
||||
matOut[i] = std::max(1.f, Dot(listenEmit, refVec.vec) + refVec.bias);
|
||||
}
|
||||
}
|
||||
|
||||
void SurroundProfiles::SetupMatrix(float matOut[8], const ChannelMap& map, AudioChannelSet set,
|
||||
const Vector3f& emitPos, const Vector3f& listenPos,
|
||||
const Vector3f& listenHeading, const Vector3f& listenUp)
|
||||
{
|
||||
Vector3f listenDelta;
|
||||
listenDelta[0] = emitPos[0] - listenPos[0];
|
||||
listenDelta[1] = emitPos[1] - listenPos[1];
|
||||
listenDelta[2] = emitPos[2] - listenPos[2];
|
||||
|
||||
Vector3f listenNorm;
|
||||
float dist = Normalize(listenNorm, listenDelta);
|
||||
|
||||
SimpleMatrix listenerMat(listenHeading, listenUp);
|
||||
Vector3f listenEmit;
|
||||
listenerMat.vecMult(listenEmit, listenNorm);
|
||||
|
||||
/* Factor for each channel in set */
|
||||
switch (set)
|
||||
{
|
||||
case AudioChannelSet::Stereo:
|
||||
default:
|
||||
SetupRefs(matOut, map, listenEmit, StereoVectors);
|
||||
break;
|
||||
case AudioChannelSet::Quad:
|
||||
SetupRefs(matOut, map, listenEmit, QuadVectors);
|
||||
break;
|
||||
case AudioChannelSet::Surround51:
|
||||
SetupRefs(matOut, map, listenEmit, Sur51Vectors);
|
||||
break;
|
||||
case AudioChannelSet::Surround71:
|
||||
SetupRefs(matOut, map, listenEmit, Sur71Vectors);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
}
|
154
lib/Voice.cpp
154
lib/Voice.cpp
|
@ -1,6 +1,9 @@
|
|||
#include "amuse/Voice.hpp"
|
||||
#include "amuse/Submix.hpp"
|
||||
#include "amuse/IBackendVoice.hpp"
|
||||
#include "amuse/AudioGroup.hpp"
|
||||
#include "amuse/dsp.h"
|
||||
#include <string.h>
|
||||
|
||||
namespace amuse
|
||||
{
|
||||
|
@ -26,8 +29,83 @@ Voice::Voice(Engine& engine, const AudioGroup& group, ObjectId oid, int vid, boo
|
|||
m_submix->m_activeVoices.insert(this);
|
||||
}
|
||||
|
||||
size_t Voice::supplyAudio(size_t frames, int16_t* data)
|
||||
bool Voice::_checkSamplePos()
|
||||
{
|
||||
if (m_curSamplePos >= m_lastSamplePos)
|
||||
{
|
||||
if (m_curSample->first.m_loopLengthSamples)
|
||||
{
|
||||
/* Turn over looped sample */
|
||||
m_curSamplePos = m_curSample->first.m_loopStartSample;
|
||||
m_prev1 = m_curSample->second.m_hist1;
|
||||
m_prev2 = m_curSample->second.m_hist2;
|
||||
}
|
||||
else
|
||||
{
|
||||
/* Notify sample end */
|
||||
m_state.sampleEndNotify(*this);
|
||||
m_curSample = nullptr;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
void Voice::_doKeyOff()
|
||||
{
|
||||
}
|
||||
|
||||
size_t Voice::supplyAudio(size_t samples, int16_t* data)
|
||||
{
|
||||
uint32_t samplesRem = samples;
|
||||
if (m_curSample)
|
||||
{
|
||||
uint32_t block = m_curSamplePos / 14;
|
||||
uint32_t rem = m_curSamplePos % 14;
|
||||
|
||||
if (rem)
|
||||
{
|
||||
uint32_t decSamples = DSPDecompressFrameRanged(data, m_curSampleData + 8 * block,
|
||||
m_curSample->second.m_coefs,
|
||||
&m_prev1, &m_prev2, rem,
|
||||
std::min(samplesRem,
|
||||
m_lastSamplePos - block * 14));
|
||||
m_curSamplePos += decSamples;
|
||||
samplesRem -= decSamples;
|
||||
data += decSamples;
|
||||
}
|
||||
|
||||
if (_checkSamplePos())
|
||||
{
|
||||
if (samplesRem)
|
||||
memset(data, 0, sizeof(int16_t) * samplesRem);
|
||||
return samples;
|
||||
}
|
||||
|
||||
while (samplesRem)
|
||||
{
|
||||
block = m_curSamplePos / 14;
|
||||
uint32_t decSamples = DSPDecompressFrame(data, m_curSampleData + 8 * block,
|
||||
m_curSample->second.m_coefs,
|
||||
&m_prev1, &m_prev2,
|
||||
std::min(samplesRem,
|
||||
m_lastSamplePos - block * 14));
|
||||
m_curSamplePos += decSamples;
|
||||
samplesRem -= decSamples;
|
||||
data += decSamples;
|
||||
|
||||
if (_checkSamplePos())
|
||||
{
|
||||
if (samplesRem)
|
||||
memset(data, 0, sizeof(int16_t) * samplesRem);
|
||||
return samples;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
memset(data, 0, sizeof(int16_t) * samples);
|
||||
|
||||
return samples;
|
||||
}
|
||||
|
||||
Voice* Voice::startChildMacro(int8_t addNote, ObjectId macroId, int macroStep)
|
||||
|
@ -40,12 +118,40 @@ bool Voice::loadSoundMacro(ObjectId macroId, int macroStep, bool pushPc)
|
|||
|
||||
void Voice::keyOff()
|
||||
{
|
||||
if (m_sustained)
|
||||
m_sustainKeyOff = true;
|
||||
else
|
||||
_doKeyOff();
|
||||
}
|
||||
|
||||
void Voice::message(int32_t val)
|
||||
{
|
||||
}
|
||||
|
||||
void Voice::startSample(int16_t sampId, int32_t offset)
|
||||
{
|
||||
m_curSample = m_audioGroup.getSample(sampId);
|
||||
if (m_curSample)
|
||||
{
|
||||
m_backendVoice->stop();
|
||||
m_backendVoice->resetSampleRate(m_curSample->first.m_sampleRate);
|
||||
m_backendVoice->start();
|
||||
m_curSamplePos = offset;
|
||||
m_curSampleData = m_audioGroup.getSampleData(m_curSample->first.m_sampleOff);
|
||||
m_prev1 = 0;
|
||||
m_prev2 = 0;
|
||||
m_lastSamplePos = m_curSample->first.m_loopLengthSamples ?
|
||||
(m_curSample->first.m_loopStartSample + m_curSample->first.m_loopLengthSamples) :
|
||||
m_curSample->first.m_numSamples;
|
||||
}
|
||||
}
|
||||
|
||||
void Voice::stopSample()
|
||||
{
|
||||
m_backendVoice->stop();
|
||||
m_curSample = nullptr;
|
||||
}
|
||||
|
||||
void Voice::setVolume(float vol)
|
||||
{
|
||||
}
|
||||
|
@ -54,4 +160,50 @@ void Voice::setPanning(float pan)
|
|||
{
|
||||
}
|
||||
|
||||
void Voice::setSurroundPanning(float span)
|
||||
{
|
||||
}
|
||||
|
||||
void Voice::setPitchKey(int32_t cents)
|
||||
{
|
||||
}
|
||||
|
||||
void Voice::setModulation(float mod)
|
||||
{
|
||||
}
|
||||
|
||||
void Voice::setPedal(bool pedal)
|
||||
{
|
||||
if (m_sustained && !pedal && m_sustainKeyOff)
|
||||
{
|
||||
m_sustainKeyOff = false;
|
||||
_doKeyOff();
|
||||
}
|
||||
m_sustained = pedal;
|
||||
}
|
||||
|
||||
void Voice::setDoppler(float doppler)
|
||||
{
|
||||
}
|
||||
|
||||
void Voice::setReverbVol(float rvol)
|
||||
{
|
||||
}
|
||||
|
||||
void Voice::setAdsr(ObjectId adsrId)
|
||||
{
|
||||
}
|
||||
|
||||
void Voice::setPitchFrequency(uint32_t hz, uint16_t fine)
|
||||
{
|
||||
}
|
||||
|
||||
void Voice::setPitchAdsr(ObjectId adsrId, int32_t cents)
|
||||
{
|
||||
}
|
||||
|
||||
void Voice::setPitchWheelRange(int8_t up, int8_t down)
|
||||
{
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
@ -0,0 +1,124 @@
|
|||
#include "amuse/dsp.h"
|
||||
|
||||
static const int32_t NibbleToInt[16] = {0,1,2,3,4,5,6,7,-8,-7,-6,-5,-4,-3,-2,-1};
|
||||
|
||||
unsigned DSPDecompressFrameRanged(int16_t* out, const uint8_t* in,
|
||||
const int16_t coefs[8][2], int16_t* prev1, int16_t* prev2,
|
||||
unsigned firstSample, unsigned lastSample)
|
||||
{
|
||||
uint8_t cIdx = (in[0]>>4) & 0xf;
|
||||
int32_t factor1 = coefs[cIdx][0];
|
||||
int32_t factor2 = coefs[cIdx][1];
|
||||
uint8_t exp = in[0] & 0xf;
|
||||
unsigned ret = 0;
|
||||
for (int s=firstSample ; s<14 && s<lastSample ; ++s)
|
||||
{
|
||||
int32_t sampleData = (s&1)?
|
||||
NibbleToInt[(in[s/2+1])&0xf]:
|
||||
NibbleToInt[(in[s/2+1]>>4)&0xf];
|
||||
sampleData <<= exp;
|
||||
sampleData <<= 11;
|
||||
sampleData += 1024;
|
||||
sampleData +=
|
||||
factor1 * ((int32_t)(*prev1)) +
|
||||
factor2 * ((int32_t)(*prev2));
|
||||
sampleData >>= 11;
|
||||
sampleData = DSPSampClamp(sampleData);
|
||||
*out++ = sampleData;
|
||||
*prev2 = *prev1;
|
||||
*prev1 = sampleData;
|
||||
++ret;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
unsigned DSPDecompressFrame(int16_t* out, const uint8_t* in,
|
||||
const int16_t coefs[8][2], int16_t* prev1, int16_t* prev2,
|
||||
unsigned lastSample)
|
||||
{
|
||||
uint8_t cIdx = (in[0]>>4) & 0xf;
|
||||
int32_t factor1 = coefs[cIdx][0];
|
||||
int32_t factor2 = coefs[cIdx][1];
|
||||
uint8_t exp = in[0] & 0xf;
|
||||
unsigned ret = 0;
|
||||
for (int s=0 ; s<14 && s<lastSample ; ++s)
|
||||
{
|
||||
int32_t sampleData = (s&1)?
|
||||
NibbleToInt[(in[s/2+1])&0xf]:
|
||||
NibbleToInt[(in[s/2+1]>>4)&0xf];
|
||||
sampleData <<= exp;
|
||||
sampleData <<= 11;
|
||||
sampleData += 1024;
|
||||
sampleData +=
|
||||
factor1 * ((int32_t)(*prev1)) +
|
||||
factor2 * ((int32_t)(*prev2));
|
||||
sampleData >>= 11;
|
||||
sampleData = DSPSampClamp(sampleData);
|
||||
out[s] = sampleData;
|
||||
*prev2 = *prev1;
|
||||
*prev1 = sampleData;
|
||||
++ret;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
unsigned DSPDecompressFrameStereoStride(int16_t* out, const uint8_t* in,
|
||||
const int16_t coefs[8][2], int16_t* prev1, int16_t* prev2,
|
||||
unsigned lastSample)
|
||||
{
|
||||
uint32_t cIdx = (in[0]>>4) & 0xf;
|
||||
int32_t factor1 = coefs[cIdx][0];
|
||||
int32_t factor2 = coefs[cIdx][1];
|
||||
uint32_t exp = in[0] & 0xf;
|
||||
unsigned ret = 0;
|
||||
for (int s=0 ; s<14 && s<lastSample ; ++s)
|
||||
{
|
||||
int sampleData = (s&1)?
|
||||
NibbleToInt[(in[s/2+1])&0xf]:
|
||||
NibbleToInt[(in[s/2+1]>>4)&0xf];
|
||||
sampleData <<= exp;
|
||||
sampleData <<= 11;
|
||||
sampleData += 1024;
|
||||
sampleData +=
|
||||
factor1 * ((int32_t)(*prev1)) +
|
||||
factor2 * ((int32_t)(*prev2));
|
||||
sampleData >>= 11;
|
||||
sampleData = DSPSampClamp(sampleData);
|
||||
out[s*2] = sampleData;
|
||||
*prev2 = *prev1;
|
||||
*prev1 = sampleData;
|
||||
++ret;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
unsigned DSPDecompressFrameStereoDupe(int16_t* out, const uint8_t* in,
|
||||
const int16_t coefs[8][2], int16_t* prev1, int16_t* prev2,
|
||||
unsigned lastSample)
|
||||
{
|
||||
uint8_t cIdx = (in[0]>>4) & 0xf;
|
||||
int32_t factor1 = coefs[cIdx][0];
|
||||
int32_t factor2 = coefs[cIdx][1];
|
||||
uint8_t exp = in[0] & 0xf;
|
||||
unsigned ret = 0;
|
||||
for (int s=0 ; s<14 && s<lastSample ; ++s)
|
||||
{
|
||||
int sampleData = (s&1)?
|
||||
NibbleToInt[(in[s/2+1])&0xf]:
|
||||
NibbleToInt[(in[s/2+1]>>4)&0xf];
|
||||
sampleData <<= exp;
|
||||
sampleData <<= 11;
|
||||
sampleData += 1024;
|
||||
sampleData +=
|
||||
factor1 * ((int32_t)(*prev1)) +
|
||||
factor2 * ((int32_t)(*prev2));
|
||||
sampleData >>= 11;
|
||||
sampleData = DSPSampClamp(sampleData);
|
||||
out[s*2] = sampleData;
|
||||
out[s*2+1] = sampleData;
|
||||
*prev2 = *prev1;
|
||||
*prev1 = sampleData;
|
||||
++ret;
|
||||
}
|
||||
return ret;
|
||||
}
|
Loading…
Reference in New Issue