Next-Gen Audio Subsystem for Discord

#include <napi.h>
#include <opus/opus.h>
#include <opus/opus_projection.h>
#include <vector>
#include <string>
#include <cmath>

class OpusHDEncoder : public Napi::ObjectWrap<OpusHDEncoder> {
public:
    static Napi::Object Init(Napi::Env env, Napi::Object exports);
    OpusHDEncoder(const Napi::CallbackInfo& info);
    ~OpusHDEncoder();
private:
    OpusProjectionEncoder* proj_enc_ = nullptr;
    int sample_rate_ = 48000;
    int channels_ = 225;
    int frame_size_ = 11520;
    bool int24_ = false;
    Napi::Value Encode(const Napi::CallbackInfo& info);
    Napi::Value Encode24(const Napi::CallbackInfo& info);
    Napi::Value Destroy(const Napi::CallbackInfo& info);
    Napi::Value CTL(const Napi::CallbackInfo& info);
    Napi::Value GetVersion(const Napi::CallbackInfo& info);
};

static bool valid_frame(int sr, int fs) {
    static const int base[] = {120, 240, 480, 960, 1920, 2880, 5760, 11520};
    for (int v : base) {
        if (fs == v) return true;
        if (sr == 48000 && fs == v * 2) return true;
    }
    return false;
}

static int get_application(const std::string& app) {
    if (app == "voip") return OPUS_APPLICATION_VOIP;
    if (app == "lowdelay") return OPUS_APPLICATION_RESTRICTED_LOWDELAY;
    return OPUS_APPLICATION_AUDIO;
}

OpusHDEncoder::OpusHDEncoder(const Napi::CallbackInfo& info)
    : Napi::ObjectWrap<OpusHDEncoder>(info) {
    Napi::Env env = info.Env();
    if (info.Length() < 1 || !info[0].IsObject()) {
        Napi::TypeError::New(env, "Options object required").ThrowAsJavaScriptException();
        return;
    }
    Napi::Object opts = info[0].As<Napi::Object>();
    sample_rate_ = opts.Get("sampleRate").As<Napi::Number>().Int32Value();
    channels_ = opts.Get("channels").As<Napi::Number>().Int32Value();
    frame_size_ = opts.Get("frameSize").As<Napi::Number>().Int32Value();
    int24_ = opts.Get("int24").As<Napi::Boolean>().Value();
    std::string app = opts.Get("application").As<Napi::String>().Utf8Value();
    int application = get_application(app);
    if (channels_ < 1 || channels_ > 255) {
        Napi::RangeError::New(env, "Channels must be 1-255").ThrowAsJavaScriptException();
        return;
    }
    if (!valid_frame(48000, frame_size_)) {
        Napi::RangeError::New(env, "Invalid frame size").ThrowAsJavaScriptException();
        return;
    }
    const int opus_sample_rate = 48000;
    int order = static_cast<int>(std::sqrt(channels_) - 1);
    if ((order + 1) * (order + 1) != channels_) {
        Napi::RangeError::New(env, "Channel count must be a perfect square").ThrowAsJavaScriptException();
        return;
    }
    int streams = 0, coupled_streams = 0, error = OPUS_OK;
    proj_enc_ = opus_projection_ambisonics_encoder_create(
        opus_sample_rate, channels_, order,
        &streams, &coupled_streams, application, &error);
    if (!proj_enc_ || error != OPUS_OK) {
        Napi::Error::New(env, std::string("Projection encoder creation failed: ") + opus_strerror(error)).ThrowAsJavaScriptException();
        return;
    }
    opus_projection_encoder_ctl(proj_enc_, OPUS_SET_BITRATE(2000000));
    opus_projection_encoder_ctl(proj_enc_, OPUS_SET_COMPLEXITY(10));
    opus_projection_encoder_ctl(proj_enc_, OPUS_SET_LSB_DEPTH(int24_ ? 24 : 16));
    opus_projection_encoder_ctl(proj_enc_, OPUS_SET_SIGNAL(OPUS_SIGNAL_MUSIC));
}

OpusHDEncoder::~OpusHDEncoder() {
    if (proj_enc_) { opus_projection_encoder_destroy(proj_enc_); proj_enc_ = nullptr; }
}

Napi::Value OpusHDEncoder::Encode(const Napi::CallbackInfo& info) {
    Napi::Env env = info.Env();
    if (info.Length() < 1 || !info[0].IsTypedArray()) {
        Napi::TypeError::New(env, "Float32Array required").ThrowAsJavaScriptException();
        return env.Null();
    }
    auto pcm = info[0].As<Napi::Float32Array>();
    size_t expected_length = static_cast<size_t>(frame_size_ * channels_);
    if (pcm.ElementLength() != expected_length) {
        Napi::RangeError::New(env, "PCM buffer length mismatch").ThrowAsJavaScriptException();
        return env.Null();
    }
    std::vector<unsigned char> out(65536);
    int ret = opus_projection_encode_float(proj_enc_, pcm.Data(), frame_size_, out.data(), static_cast<opus_int32>(out.size()));
    if (ret < 0) {
        Napi::Error::New(env, std::string("Encode failed: ") + opus_strerror(ret)).ThrowAsJavaScriptException();
        return env.Null();
    }
    return Napi::Buffer<unsigned char>::Copy(env, out.data(), ret);
}

Napi::Value OpusHDEncoder::CTL(const Napi::CallbackInfo& info) {
    Napi::Env env = info.Env();
    if (info.Length() < 2 || !info[0].IsString()) {
        Napi::TypeError::New(env, "CTL name and value required").ThrowAsJavaScriptException();
        return env.Null();
    }
    std::string ctl = info[0].As<Napi::String>().Utf8Value();
    int val = info[1].As<Napi::Number>().Int32Value();
    int ret = OPUS_OK;
    if (ctl == "SET_BITRATE") ret = opus_projection_encoder_ctl(proj_enc_, OPUS_SET_BITRATE(val));
    else if (ctl == "SET_COMPLEXITY") ret = opus_projection_encoder_ctl(proj_enc_, OPUS_SET_COMPLEXITY(val));
    else if (ctl == "SET_LSB_DEPTH") ret = opus_projection_encoder_ctl(proj_enc_, OPUS_SET_LSB_DEPTH(val));
    else if (ctl == "SET_SIGNAL") ret = opus_projection_encoder_ctl(proj_enc_, OPUS_SET_SIGNAL(val));
    else { Napi::TypeError::New(env, "Unsupported CTL command").ThrowAsJavaScriptException(); return env.Null(); }
    if (ret != OPUS_OK) { Napi::Error::New(env, std::string("CTL failed: ") + opus_strerror(ret)).ThrowAsJavaScriptException(); return env.Null(); }
    return Napi::Boolean::New(env, true);
}

Napi::Value OpusHDEncoder::GetVersion(const Napi::CallbackInfo& info) {
    return Napi::String::New(info.Env(), opus_get_version_string());
}

Napi::Value OpusHDEncoder::Destroy(const Napi::CallbackInfo& info) {
    if (proj_enc_) { opus_projection_encoder_destroy(proj_enc_); proj_enc_ = nullptr; }
    return info.Env().Undefined();
}

Napi::Object OpusHDEncoder::Init(Napi::Env env, Napi::Object exports) {
    Napi::Function func = DefineClass(env, "OpusHDEncoder", {
        InstanceMethod("encode", &OpusHDEncoder::Encode),
        InstanceMethod("ctl", &OpusHDEncoder::CTL),
        InstanceMethod("getVersion", &OpusHDEncoder::GetVersion),
        InstanceMethod("destroy", &OpusHDEncoder::Destroy)
    });
    exports.Set("OpusHDEncoder", func);
    exports.Set("OPUS_APPLICATION_AUDIO", Napi::Number::New(env, OPUS_APPLICATION_AUDIO));
    exports.Set("OPUS_APPLICATION_VOIP", Napi::Number::New(env, OPUS_APPLICATION_VOIP));
    exports.Set("OPUS_OK", Napi::Number::New(env, OPUS_OK));
    return exports;
}

Napi::Object InitAll(Napi::Env env, Napi::Object exports) {
    return OpusHDEncoder::Init(env, exports);
}

NODE_API_MODULE(experimental, InitAll)