723 lines
20 KiB
C++
723 lines
20 KiB
C++
#include "StarVoice.hpp"
|
|
#include "StarFormat.hpp"
|
|
#include "StarJsonExtra.hpp"
|
|
#include "StarApplicationController.hpp"
|
|
#include "StarTime.hpp"
|
|
#include "StarRoot.hpp"
|
|
#include "StarLogging.hpp"
|
|
#include "StarInterpolation.hpp"
|
|
#include "opus/include/opus.h"
|
|
|
|
#include "SDL.h"
|
|
|
|
constexpr int VOICE_SAMPLE_RATE = 48000;
|
|
constexpr int VOICE_FRAME_SIZE = 960;
|
|
|
|
constexpr int VOICE_MAX_FRAME_SIZE = 6 * VOICE_FRAME_SIZE;
|
|
constexpr int VOICE_MAX_PACKET_SIZE = 3 * 1276;
|
|
|
|
constexpr uint16_t VOICE_VERSION = 1;
|
|
|
|
namespace Star {
|
|
|
|
EnumMap<VoiceInputMode> const VoiceInputModeNames{
|
|
{VoiceInputMode::VoiceActivity, "VoiceActivity"},
|
|
{VoiceInputMode::PushToTalk, "PushToTalk"}
|
|
};
|
|
|
|
EnumMap<VoiceChannelMode> const VoiceChannelModeNames{
|
|
{VoiceChannelMode::Mono, "Mono"},
|
|
{VoiceChannelMode::Stereo, "Stereo"}
|
|
};
|
|
|
|
inline float getAudioChunkLoudness(int16_t* data, size_t samples, float volume) {
|
|
if (!samples)
|
|
return 0.f;
|
|
|
|
double rms = 0.;
|
|
for (size_t i = 0; i != samples; ++i) {
|
|
float sample = ((float)data[i] / 32767.f) * volume;
|
|
rms += (double)(sample * sample);
|
|
}
|
|
|
|
float fRms = sqrtf((float)(rms / samples));
|
|
|
|
if (fRms > 0)
|
|
return std::clamp<float>(20.f * log10f(fRms), -127.f, 0.f);
|
|
else
|
|
return -127.f;
|
|
}
|
|
|
|
float getAudioLoudness(int16_t* data, size_t samples, float volume = 1.0f) {
|
|
constexpr size_t CHUNK_SIZE = 50;
|
|
|
|
float highest = -127.f;
|
|
for (size_t i = 0; i < samples; i += CHUNK_SIZE) {
|
|
float level = getAudioChunkLoudness(data + i, std::min<size_t>(i + CHUNK_SIZE, samples) - i, volume);
|
|
if (level > highest)
|
|
highest = level;
|
|
}
|
|
|
|
return highest;
|
|
}
|
|
|
|
struct VoiceAudioStream {
|
|
// TODO: This should really be a ring buffer instead.
|
|
std::queue<int16_t> samples;
|
|
SDL_AudioStream* sdlAudioStreamMono;
|
|
SDL_AudioStream* sdlAudioStreamStereo;
|
|
Mutex mutex;
|
|
|
|
VoiceAudioStream()
|
|
: sdlAudioStreamMono (SDL_NewAudioStream(AUDIO_S16, 1, 48000, AUDIO_S16SYS, 1, 44100))
|
|
, sdlAudioStreamStereo(SDL_NewAudioStream(AUDIO_S16, 2, 48000, AUDIO_S16SYS, 2, 44100)) {};
|
|
~VoiceAudioStream() {
|
|
SDL_FreeAudioStream(sdlAudioStreamMono);
|
|
SDL_FreeAudioStream(sdlAudioStreamStereo);
|
|
}
|
|
|
|
inline int16_t take() {
|
|
int16_t sample = 0;
|
|
if (!samples.empty()) {
|
|
sample = samples.front();
|
|
samples.pop();
|
|
}
|
|
return sample;
|
|
}
|
|
|
|
size_t resample(int16_t* in, size_t inSamples, std::vector<int16_t>& out, bool mono) {
|
|
SDL_AudioStream* stream = mono ? sdlAudioStreamMono : sdlAudioStreamStereo;
|
|
SDL_AudioStreamPut(stream, in, inSamples * sizeof(int16_t));
|
|
if (int available = SDL_AudioStreamAvailable(stream)) {
|
|
out.resize(available / 2);
|
|
SDL_AudioStreamGet(stream, out.data(), available);
|
|
return available;
|
|
}
|
|
return 0;
|
|
}
|
|
};
|
|
|
|
Voice::Speaker::Speaker(SpeakerId id)
|
|
: decoderMono (createDecoder(1), opus_decoder_destroy)
|
|
, decoderStereo(createDecoder(2), opus_decoder_destroy) {
|
|
speakerId = id;
|
|
audioStream = make_shared<VoiceAudioStream>();
|
|
}
|
|
|
|
Json Voice::Speaker::toJson() const {
|
|
return JsonObject{
|
|
{"speakerId", speakerId},
|
|
{"entityId", entityId },
|
|
{"name", name },
|
|
{"playing", (bool)playing},
|
|
{"muted", (bool)muted },
|
|
{"decibels", (float)decibelLevel},
|
|
{"smoothDecibels", (float)smoothDb },
|
|
{"position", jsonFromVec2F(position)}
|
|
};
|
|
}
|
|
|
|
Voice* Voice::s_singleton;
|
|
|
|
Voice* Voice::singletonPtr() {
|
|
return s_singleton;
|
|
}
|
|
|
|
Voice& Voice::singleton() {
|
|
if (!s_singleton)
|
|
throw VoiceException("Voice::singleton() called with no Voice instance available");
|
|
else
|
|
return *s_singleton;
|
|
}
|
|
|
|
Voice::Voice(ApplicationControllerPtr appController) : m_encoder(nullptr, opus_encoder_destroy) {
|
|
if (s_singleton)
|
|
throw VoiceException("Singleton Voice has been constructed twice");
|
|
|
|
m_clientSpeaker = make_shared<Speaker>(m_speakerId);
|
|
m_inputMode = VoiceInputMode::PushToTalk;
|
|
m_channelMode = VoiceChannelMode::Mono;
|
|
m_applicationController = appController;
|
|
|
|
m_stopThread = false;
|
|
m_thread = Thread::invoke("Voice::thread", mem_fn(&Voice::thread), this);
|
|
|
|
s_singleton = this;
|
|
}
|
|
|
|
Voice::~Voice() {
|
|
m_stopThread = true;
|
|
|
|
{
|
|
MutexLocker locker(m_threadMutex);
|
|
m_threadCond.broadcast();
|
|
}
|
|
|
|
m_thread.finish();
|
|
|
|
if (m_nextSaveTime)
|
|
save();
|
|
|
|
closeDevice();
|
|
|
|
s_singleton = nullptr;
|
|
}
|
|
|
|
void Voice::init() {
|
|
resetEncoder();
|
|
resetDevice();
|
|
}
|
|
|
|
|
|
template <typename T>
|
|
inline bool change(T& value, T newValue, bool& out) {
|
|
bool changed = value != newValue;
|
|
out |= changed;
|
|
value = move(newValue);
|
|
return changed;
|
|
}
|
|
|
|
void Voice::loadJson(Json const& config, bool skipSave) {
|
|
// Not all keys are required
|
|
|
|
bool changed = false;
|
|
|
|
{
|
|
bool enabled = shouldEnableInput();
|
|
m_enabled = config.getBool("enabled", m_enabled);
|
|
m_inputEnabled = config.getBool("inputEnabled", m_inputEnabled);
|
|
if (shouldEnableInput() != enabled) {
|
|
changed = true;
|
|
resetDevice();
|
|
}
|
|
}
|
|
|
|
if (config.contains("deviceName") // Make sure null-type key exists
|
|
&& change(m_deviceName, config.optString("deviceName"), changed))
|
|
resetDevice();
|
|
|
|
m_threshold = config.getFloat("threshold", m_threshold);
|
|
m_inputVolume = config.getFloat("inputVolume", m_inputVolume);
|
|
m_outputVolume = config.getFloat("outputVolume", m_outputVolume);
|
|
|
|
if (change(m_loopback, config.getBool("loopback", m_loopback), changed))
|
|
m_clientSpeaker->playing = false;
|
|
|
|
if (auto inputMode = config.optString("inputMode")) {
|
|
if (change(m_inputMode, VoiceInputModeNames.getLeft(*inputMode), changed))
|
|
m_lastInputTime = 0;
|
|
}
|
|
|
|
if (auto channelMode = config.optString("channelMode")) {
|
|
if (change(m_channelMode, VoiceChannelModeNames.getLeft(*channelMode), changed)) {
|
|
closeDevice();
|
|
resetEncoder();
|
|
resetDevice();
|
|
}
|
|
}
|
|
|
|
if (changed && !skipSave)
|
|
scheduleSave();
|
|
}
|
|
|
|
|
|
|
|
Json Voice::saveJson() const {
|
|
return JsonObject{
|
|
{"enabled", m_enabled},
|
|
{"inputEnabled", m_inputEnabled},
|
|
{"inputDevice", m_deviceName ? *m_deviceName : Json()},
|
|
{"threshold", m_threshold},
|
|
{"inputVolume", m_inputVolume},
|
|
{"outputVolume", m_outputVolume},
|
|
{"inputMode", VoiceInputModeNames.getRight(m_inputMode)},
|
|
{"channelMode", VoiceChannelModeNames.getRight(m_channelMode)},
|
|
{"loopback", m_loopback},
|
|
{"version", 1}
|
|
};
|
|
}
|
|
|
|
void Voice::save() const {
|
|
if (Root* root = Root::singletonPtr()) {
|
|
if (auto config = root->configuration())
|
|
config->set("voice", saveJson());
|
|
}
|
|
}
|
|
|
|
void Voice::scheduleSave() {
|
|
if (!m_nextSaveTime)
|
|
m_nextSaveTime = Time::monotonicMilliseconds() + 2000;
|
|
}
|
|
|
|
Voice::SpeakerPtr Voice::setLocalSpeaker(SpeakerId speakerId) {
|
|
if (m_speakers.contains(m_speakerId))
|
|
m_speakers.remove(m_speakerId);
|
|
|
|
m_clientSpeaker->speakerId = m_speakerId = speakerId;
|
|
return m_speakers.insert(m_speakerId, m_clientSpeaker).first->second;
|
|
}
|
|
|
|
Voice::SpeakerPtr Voice::localSpeaker() {
|
|
return m_clientSpeaker;
|
|
}
|
|
|
|
Voice::SpeakerPtr Voice::speaker(SpeakerId speakerId) {
|
|
if (m_speakerId == speakerId)
|
|
return m_clientSpeaker;
|
|
else {
|
|
if (SpeakerPtr const* ptr = m_speakers.ptr(speakerId))
|
|
return *ptr;
|
|
else
|
|
return m_speakers.emplace(speakerId, make_shared<Speaker>(speakerId)).first->second;
|
|
}
|
|
}
|
|
|
|
HashMap<Voice::SpeakerId, Voice::SpeakerPtr>& Voice::speakers() {
|
|
return m_speakers;
|
|
}
|
|
|
|
List<Voice::SpeakerPtr> Voice::sortedSpeakers(bool onlyPlaying) {
|
|
List<SpeakerPtr> result;
|
|
|
|
auto sorter = [](SpeakerPtr const& a, SpeakerPtr const& b) -> bool {
|
|
if (a->lastPlayTime != b->lastPlayTime)
|
|
return a->lastPlayTime < b->lastPlayTime;
|
|
else
|
|
return a->speakerId < b->speakerId;
|
|
};
|
|
|
|
for (auto& p : m_speakers) {
|
|
if (!onlyPlaying || p.second->playing)
|
|
result.insertSorted(p.second, sorter);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
void Voice::clearSpeakers() {
|
|
auto it = m_speakers.begin();
|
|
while (it != m_speakers.end()) {
|
|
if (it->second == m_clientSpeaker)
|
|
it = ++it;
|
|
else
|
|
it = m_speakers.erase(it);
|
|
}
|
|
}
|
|
|
|
void Voice::readAudioData(uint8_t* stream, int len) {
|
|
auto now = Time::monotonicMilliseconds();
|
|
bool active = m_encoder && m_encodedChunksLength < 2048
|
|
&& (m_inputMode == VoiceInputMode::VoiceActivity || now < m_lastInputTime);
|
|
|
|
size_t sampleCount = len / 2;
|
|
|
|
if (active) {
|
|
float decibels = getAudioLoudness((int16_t*)stream, sampleCount);
|
|
|
|
if (!m_loopback)
|
|
m_clientSpeaker->decibelLevel = getAudioLoudness((int16_t*)stream, sampleCount, m_inputVolume);
|
|
|
|
if (m_inputMode == VoiceInputMode::VoiceActivity) {
|
|
if (decibels > m_threshold)
|
|
m_lastThresholdTime = now;
|
|
active = now - m_lastThresholdTime < 50;
|
|
}
|
|
}
|
|
else if (!m_loopback)
|
|
m_clientSpeaker->decibelLevel = -96.0f;
|
|
|
|
if (!m_loopback) {
|
|
if (active && !m_clientSpeaker->playing)
|
|
m_clientSpeaker->lastPlayTime = now;
|
|
|
|
m_clientSpeaker->playing = active;
|
|
}
|
|
|
|
if (!active)
|
|
return;
|
|
|
|
MutexLocker captureLock(m_captureMutex);
|
|
if (active) {
|
|
m_capturedChunksFrames += sampleCount / m_deviceChannels;
|
|
auto data = (opus_int16*)malloc(len);
|
|
memcpy(data, stream, len);
|
|
m_capturedChunks.emplace(data, sampleCount); // takes ownership
|
|
m_threadCond.signal();
|
|
}
|
|
else { // Clear out any residual data so they don't manifest at the start of the next encode, whenever that is
|
|
while (!m_capturedChunks.empty())
|
|
m_capturedChunks.pop();
|
|
|
|
m_capturedChunksFrames = 0;
|
|
}
|
|
}
|
|
|
|
void Voice::mix(int16_t* buffer, size_t frameCount, unsigned channels) {
|
|
size_t samples = frameCount * channels;
|
|
static std::vector<int16_t> finalBuffer, speakerBuffer;
|
|
static std::vector<int32_t> sharedBuffer; //int32 to reduce clipping
|
|
speakerBuffer.resize(samples);
|
|
sharedBuffer.resize(samples);
|
|
|
|
bool mix = false;
|
|
{
|
|
MutexLocker lock(m_activeSpeakersMutex);
|
|
auto it = m_activeSpeakers.begin();
|
|
while (it != m_activeSpeakers.end()) {
|
|
SpeakerPtr const& speaker = *it;
|
|
VoiceAudioStream* audio = speaker->audioStream.get();
|
|
MutexLocker audioLock(audio->mutex);
|
|
if (speaker->playing && !audio->samples.empty()) {
|
|
if (!speaker->muted) {
|
|
mix = true;
|
|
for (size_t i = 0; i != samples; ++i)
|
|
speakerBuffer[i] = audio->take();
|
|
|
|
speaker->decibelLevel = getAudioLoudness(speakerBuffer.data(), samples);
|
|
|
|
float volume = speaker->volume;
|
|
Array2F levels = speaker->channelVolumes;
|
|
for (size_t i = 0; i != samples; ++i)
|
|
sharedBuffer[i] += (int32_t)(speakerBuffer[i]) * levels[i % 2] * volume;
|
|
//Blends the weaker channel into the stronger one,
|
|
/* unused, is a bit too strong on stereo music.
|
|
float maxLevel = max(levels[0], levels[1]);
|
|
float leftToRight = maxLevel != 0.0f ? 1.0f - (levels[0] / maxLevel) : 0.0f;
|
|
float rightToLeft = maxLevel != 0.0f ? 1.0f - (levels[1] / maxLevel) : 0.0f;
|
|
|
|
int16_t* speakerData = speakerBuffer.data();
|
|
int32_t* sharedData = sharedBuffer.data();
|
|
for (size_t i = 0; i != frameCount; ++i) {
|
|
auto leftSample = (float)*speakerData++;
|
|
auto rightSample = (float)*speakerData++;
|
|
|
|
if (rightToLeft != 0.0f)
|
|
leftSample = ( leftSample + rightSample * rightToLeft) / (1.0f + rightToLeft);
|
|
if (leftToRight != 0.0f)
|
|
rightSample = (rightSample + leftSample * leftToRight) / (1.0f + leftToRight);
|
|
|
|
*sharedData++ += (int32_t)leftSample * levels[0];
|
|
*sharedData++ += (int32_t)rightSample * levels[1];
|
|
}
|
|
//*/
|
|
}
|
|
else {
|
|
for (size_t i = 0; i != samples; ++i)
|
|
audio->take();
|
|
}
|
|
++it;
|
|
}
|
|
else {
|
|
speaker->playing = false;
|
|
speaker->decibelLevel = -96.0f;
|
|
it = m_activeSpeakers.erase(it);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (mix) {
|
|
finalBuffer.resize(sharedBuffer.size(), 0);
|
|
|
|
float vol = m_outputVolume;
|
|
for (size_t i = 0; i != sharedBuffer.size(); ++i)
|
|
finalBuffer[i] = (int16_t)clamp<int>(sharedBuffer[i] * vol, INT16_MIN, INT16_MAX);
|
|
|
|
SDL_MixAudioFormat((Uint8*)buffer, (Uint8*)finalBuffer.data(), AUDIO_S16, finalBuffer.size() * sizeof(int16_t), SDL_MIX_MAXVOLUME);
|
|
memset(sharedBuffer.data(), 0, sharedBuffer.size() * sizeof(int32_t));
|
|
}
|
|
}
|
|
|
|
void Voice::update(PositionalAttenuationFunction positionalAttenuationFunction) {
|
|
for (auto& entry : m_speakers) {
|
|
if (SpeakerPtr& speaker = entry.second) {
|
|
if (positionalAttenuationFunction) {
|
|
speaker->channelVolumes = {
|
|
1.0f - positionalAttenuationFunction(0, speaker->position, 1.0f),
|
|
1.0f - positionalAttenuationFunction(1, speaker->position, 1.0f)
|
|
};
|
|
}
|
|
else
|
|
speaker->channelVolumes = Vec2F::filled(1.0f);
|
|
|
|
auto& dbHistory = speaker->dbHistory;
|
|
memcpy(&dbHistory[1], &dbHistory[0], (dbHistory.size() - 1) * sizeof(float));
|
|
dbHistory[0] = speaker->decibelLevel;
|
|
float smoothDb = 0.0f;
|
|
for (float dB : dbHistory)
|
|
smoothDb += dB;
|
|
|
|
speaker->smoothDb = smoothDb / dbHistory.size();
|
|
}
|
|
}
|
|
|
|
if (m_nextSaveTime && Time::monotonicMilliseconds() > m_nextSaveTime) {
|
|
m_nextSaveTime = 0;
|
|
save();
|
|
}
|
|
}
|
|
|
|
|
|
void Voice::setDeviceName(Maybe<String> deviceName) {
|
|
if (m_deviceName == deviceName)
|
|
return;
|
|
|
|
m_deviceName = deviceName;
|
|
if (m_deviceOpen)
|
|
openDevice();
|
|
}
|
|
|
|
StringList Voice::availableDevices() {
|
|
int devices = SDL_GetNumAudioDevices(1);
|
|
StringList deviceList;
|
|
if (devices > 0) {
|
|
deviceList.reserve(devices);
|
|
for (size_t i = 0; i != devices; ++i)
|
|
deviceList.emplace_back(SDL_GetAudioDeviceName(i, 1));
|
|
}
|
|
deviceList.sort();
|
|
return deviceList;
|
|
}
|
|
|
|
int Voice::send(DataStreamBuffer& out, size_t budget) {
|
|
out.setByteOrder(ByteOrder::LittleEndian);
|
|
out.write<uint16_t>(VOICE_VERSION);
|
|
|
|
MutexLocker encodeLock(m_encodeMutex);
|
|
|
|
if (m_encodedChunks.empty())
|
|
return 0;
|
|
|
|
std::vector<ByteArray> encodedChunks = move(m_encodedChunks);
|
|
size_t encodedChunksLength = m_encodedChunksLength;
|
|
m_encodedChunksLength = 0;
|
|
|
|
encodeLock.unlock();
|
|
|
|
for (auto& chunk : encodedChunks) {
|
|
out.write<uint32_t>(chunk.size());
|
|
out.writeBytes(chunk);
|
|
if (budget && (budget -= min<size_t>(budget, chunk.size())) == 0)
|
|
break;
|
|
}
|
|
|
|
m_lastSentTime = Time::monotonicMilliseconds();
|
|
if (m_loopback)
|
|
receive(m_clientSpeaker, { out.ptr(), out.size() });
|
|
return 1;
|
|
}
|
|
|
|
bool Voice::receive(SpeakerPtr speaker, std::string_view view) {
|
|
if (!m_enabled || !speaker || view.empty())
|
|
return false;
|
|
|
|
try {
|
|
DataStreamExternalBuffer reader(view.data(), view.size());
|
|
reader.setByteOrder(ByteOrder::LittleEndian);
|
|
|
|
if (reader.read<uint16_t>() > VOICE_VERSION)
|
|
return false;
|
|
|
|
uint32_t opusLength = 0;
|
|
while (!reader.atEnd()) {
|
|
reader >> opusLength;
|
|
if (reader.pos() + opusLength > reader.size())
|
|
throw VoiceException("Opus packet length goes past end of buffer"s, false);
|
|
auto opusData = (unsigned char*)reader.ptr() + reader.pos();
|
|
reader.seek(opusLength, IOSeek::Relative);
|
|
|
|
int channels = opus_packet_get_nb_channels(opusData);
|
|
if (channels == OPUS_INVALID_PACKET)
|
|
continue;
|
|
|
|
bool mono = channels == 1;
|
|
OpusDecoder* decoder = mono ? speaker->decoderMono.get() : speaker->decoderStereo.get();
|
|
int samples = opus_decoder_get_nb_samples(decoder, opusData, opusLength);
|
|
if (samples < 0)
|
|
throw VoiceException(strf("Decoder error: {}", opus_strerror(samples)), false);
|
|
|
|
m_decodeBuffer.resize(samples * (size_t)channels);
|
|
|
|
int decodedSamples = opus_decode(decoder, opusData, opusLength, m_decodeBuffer.data(), m_decodeBuffer.size() * sizeof(int16_t), 0);
|
|
if (decodedSamples <= 0) {
|
|
if (decodedSamples < 0)
|
|
throw VoiceException(strf("Decoder error: {}", opus_strerror(samples)), false);
|
|
return true;
|
|
}
|
|
|
|
//Logger::info("Voice: decoded Opus chunk {} bytes -> {} samples", opusLength, decodedSamples * channels);
|
|
|
|
speaker->audioStream->resample(m_decodeBuffer.data(), (size_t)decodedSamples * channels, m_resampleBuffer, mono);
|
|
|
|
{
|
|
MutexLocker lock(speaker->audioStream->mutex);
|
|
auto& samples = speaker->audioStream->samples;
|
|
|
|
auto now = Time::monotonicMilliseconds();
|
|
if (now - speaker->lastReceiveTime < 1000) {
|
|
auto limit = (size_t)speaker->minimumPlaySamples + 22050;
|
|
if (samples.size() > limit) { // skip ahead if we're getting too far
|
|
for (size_t i = samples.size(); i >= limit; --i)
|
|
samples.pop();
|
|
}
|
|
}
|
|
else
|
|
samples = std::queue<int16_t>();
|
|
|
|
speaker->lastReceiveTime = now;
|
|
|
|
if (mono) {
|
|
for (int16_t sample : m_resampleBuffer) {
|
|
samples.push(sample);
|
|
samples.push(sample);
|
|
}
|
|
}
|
|
else {
|
|
for (int16_t sample : m_resampleBuffer)
|
|
samples.push(sample);
|
|
}
|
|
}
|
|
playSpeaker(speaker, channels);
|
|
}
|
|
return true;
|
|
}
|
|
catch (StarException const& e) {
|
|
Logger::error("Voice: Error receiving voice data for speaker #{} ('{}'): {}", speaker->speakerId, speaker->name, e.what());
|
|
return false;
|
|
}
|
|
}
|
|
|
|
void Voice::setInput(bool input) {
|
|
m_lastInputTime = (m_deviceOpen && input) ? Time::monotonicMilliseconds() + 1000 : 0;
|
|
}
|
|
|
|
OpusDecoder* Voice::createDecoder(int channels) {
|
|
int error;
|
|
OpusDecoder* decoder = opus_decoder_create(VOICE_SAMPLE_RATE, channels, &error);
|
|
if (error != OPUS_OK)
|
|
throw VoiceException::format("Could not create decoder: {}", opus_strerror(error));
|
|
else
|
|
return decoder;
|
|
}
|
|
|
|
OpusEncoder* Voice::createEncoder(int channels) {
|
|
int error;
|
|
OpusEncoder* encoder = opus_encoder_create(VOICE_SAMPLE_RATE, channels, OPUS_APPLICATION_AUDIO, &error);
|
|
if (error != OPUS_OK)
|
|
throw VoiceException::format("Could not create encoder: {}", opus_strerror(error));
|
|
else
|
|
return encoder;
|
|
}
|
|
|
|
void Voice::resetEncoder() {
|
|
int channels = encoderChannels();
|
|
MutexLocker locker(m_threadMutex);
|
|
m_encoder.reset(createEncoder(channels));
|
|
opus_encoder_ctl(m_encoder.get(), OPUS_SET_BITRATE(channels == 2 ? 50000 : 24000));
|
|
}
|
|
|
|
void Voice::resetDevice() {
|
|
if (shouldEnableInput())
|
|
openDevice();
|
|
else
|
|
closeDevice();
|
|
}
|
|
|
|
void Voice::openDevice() {
|
|
closeDevice();
|
|
|
|
m_applicationController->openAudioInputDevice(
|
|
m_deviceName ? m_deviceName->utf8Ptr() : nullptr,
|
|
VOICE_SAMPLE_RATE,
|
|
m_deviceChannels = encoderChannels(),
|
|
this,
|
|
[](void* userdata, uint8_t* stream, int len) {
|
|
((Voice*)(userdata))->readAudioData(stream, len);
|
|
}
|
|
);
|
|
|
|
m_deviceOpen = true;
|
|
}
|
|
|
|
void Voice::closeDevice() {
|
|
if (!m_deviceOpen)
|
|
return;
|
|
|
|
m_applicationController->closeAudioInputDevice();
|
|
m_clientSpeaker->playing = false;
|
|
m_clientSpeaker->decibelLevel = -96.0f;
|
|
m_deviceOpen = false;
|
|
}
|
|
|
|
bool Voice::playSpeaker(SpeakerPtr const& speaker, int channels) {
|
|
if (speaker->playing || speaker->audioStream->samples.size() < speaker->minimumPlaySamples)
|
|
return false;
|
|
|
|
if (!speaker->playing) {
|
|
speaker->lastPlayTime = Time::monotonicMilliseconds();
|
|
speaker->playing = true;
|
|
MutexLocker lock(m_activeSpeakersMutex);
|
|
m_activeSpeakers.insert(speaker);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void Voice::thread() {
|
|
while (true) {
|
|
MutexLocker locker(m_threadMutex);
|
|
|
|
m_threadCond.wait(m_threadMutex);
|
|
if (m_stopThread)
|
|
return;
|
|
|
|
{
|
|
MutexLocker locker(m_captureMutex);
|
|
ByteArray encoded(VOICE_MAX_PACKET_SIZE, 0);
|
|
size_t frameSamples = VOICE_FRAME_SIZE * (size_t)m_deviceChannels;
|
|
while (m_capturedChunksFrames >= VOICE_FRAME_SIZE) {
|
|
std::vector<opus_int16> samples;
|
|
samples.reserve(frameSamples);
|
|
size_t samplesLeft = frameSamples;
|
|
while (samplesLeft && !m_capturedChunks.empty()) {
|
|
auto& front = m_capturedChunks.front();
|
|
if (front.exhausted())
|
|
m_capturedChunks.pop();
|
|
else
|
|
samplesLeft -= front.takeSamples(samples, samplesLeft);
|
|
}
|
|
m_capturedChunksFrames -= VOICE_FRAME_SIZE;
|
|
|
|
if (m_inputVolume != 1.0f) {
|
|
for (size_t i = 0; i != samples.size(); ++i)
|
|
samples[i] *= m_inputVolume;
|
|
}
|
|
|
|
if (int encodedSize = opus_encode(m_encoder.get(), samples.data(), VOICE_FRAME_SIZE, (unsigned char*)encoded.ptr(), encoded.size())) {
|
|
if (encodedSize == 1)
|
|
continue;
|
|
|
|
encoded.resize(encodedSize);
|
|
|
|
{
|
|
MutexLocker lock(m_encodeMutex);
|
|
m_encodedChunks.emplace_back(move(encoded));
|
|
m_encodedChunksLength += encodedSize;
|
|
|
|
encoded = ByteArray(VOICE_MAX_PACKET_SIZE, 0);
|
|
}
|
|
|
|
//Logger::info("Voice: encoded Opus chunk {} samples -> {} bytes", frameSamples, encodedSize);
|
|
}
|
|
else if (encodedSize < 0)
|
|
Logger::error("Voice: Opus encode error {}", opus_strerror(encodedSize));
|
|
}
|
|
}
|
|
|
|
continue;
|
|
|
|
locker.unlock();
|
|
Thread::yield();
|
|
}
|
|
return;
|
|
}
|
|
|
|
} |