mirror of
https://github.com/mudler/LocalAI.git
synced 2026-07-31 02:18:50 -04:00
fe70b21139
Both emit float seconds, converted from the runtime's sample-index spans, and both take a counted reference to the loaded model through snapshot() and hold it for the whole call: a Free arriving mid-request drops only the global's reference, so whichever request finishes last destroys the model instead of one of them running on freed weights. An AddressSanitizer build reproduces exactly that heap-use-after-free inside ggml_vec_dot_f32 when the handler keeps a raw pointer instead, which is why the shape is what it is. The inference lane is taken before session_for, not after. session_for reads and writes an unsynchronised session cache and the offline run calls prepare(), which mutates the session, so both belong inside the lane. Diarize routes before it reads the input file, so a family that cannot diarize at all says so rather than complaining about the audio first. Its per-segment text stays empty because audio.cpp's SpeakerTurn carries a span and a speaker label only, and nested or overlapping turns are passed through untouched: a sortformer turn inside another speaker's turn is correct output for overlapped speech, and LocalAI is overlap-tolerant downstream. Duration counts frames rather than floats, so a stereo input does not report twice its length. Verified end to end against upstream's bundled silero_vad, which needs no download, using the bundled 16 kHz speech asset: a synthetic tone returns nothing, correctly, because silero detects speech and a sine is not speech. Assisted-by: Claude:claude-opus-5 [Claude Code] Signed-off-by: Ettore Di Giacinto <mudler@localai.io>
73 lines
2.6 KiB
C++
73 lines
2.6 KiB
C++
#include "audio_io.h"
|
|
|
|
#include "loaded_model.h"
|
|
|
|
#include "engine/framework/audio/wav_reader.h"
|
|
#include "engine/framework/audio/wav_writer.h"
|
|
|
|
#include <filesystem>
|
|
#include <utility>
|
|
|
|
namespace audiocpp_backend {
|
|
|
|
engine::runtime::AudioBuffer read_audio_file(const std::string &path) {
|
|
if (path.empty()) {
|
|
throw ConfigError("audio-cpp: no input audio path was supplied");
|
|
}
|
|
std::error_code ec;
|
|
if (!std::filesystem::exists(std::filesystem::path(path), ec)) {
|
|
throw ConfigError("audio-cpp: input audio does not exist: " + path);
|
|
}
|
|
engine::runtime::AudioBuffer buffer;
|
|
try {
|
|
const engine::audio::WavData wav =
|
|
engine::audio::read_wav_f32(std::filesystem::path(path));
|
|
buffer.sample_rate = wav.sample_rate;
|
|
// AudioBuffer's own default is 1, and a reader that reports 0 channels
|
|
// still gave us an interleaving of one.
|
|
buffer.channels = wav.channels > 0 ? wav.channels : 1;
|
|
buffer.samples = wav.samples;
|
|
} catch (const std::exception &err) {
|
|
throw ConfigError("audio-cpp: cannot read " + path +
|
|
" as WAV: " + err.what());
|
|
}
|
|
if (buffer.sample_rate <= 0) {
|
|
throw ConfigError("audio-cpp: " + path +
|
|
" declares a non-positive sample rate; every "
|
|
"timestamp derived from it would be zero");
|
|
}
|
|
return buffer;
|
|
}
|
|
|
|
void write_audio_file(const std::string &path,
|
|
const engine::runtime::AudioBuffer &audio) {
|
|
if (path.empty()) {
|
|
throw ConfigError("audio-cpp: no output path was supplied");
|
|
}
|
|
const std::filesystem::path destination(path);
|
|
if (destination.has_parent_path()) {
|
|
// Best effort: a failure here shows up as a write failure below, with a
|
|
// message naming the file the caller actually asked for.
|
|
std::error_code ec;
|
|
std::filesystem::create_directories(destination.parent_path(), ec);
|
|
}
|
|
try {
|
|
engine::audio::write_pcm16_wav(destination, audio.sample_rate,
|
|
audio.channels > 0 ? audio.channels : 1,
|
|
audio.samples);
|
|
} catch (const std::exception &err) {
|
|
throw ConfigError("audio-cpp: cannot write " + path + ": " + err.what());
|
|
}
|
|
}
|
|
|
|
engine::runtime::AudioBuffer buffer_from_mono(std::vector<float> samples,
|
|
int sample_rate) {
|
|
engine::runtime::AudioBuffer buffer;
|
|
buffer.sample_rate = sample_rate;
|
|
buffer.channels = 1;
|
|
buffer.samples = std::move(samples);
|
|
return buffer;
|
|
}
|
|
|
|
} // namespace audiocpp_backend
|