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 for Opus (must be 120–11520, multiples allowed)").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 (e.g., 225 = (14+1)^2)").ThrowAsJavaScriptException();
        return;
    }

    int streams = 0;
    int coupled_streams = 0;
    int 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;
    }

    // Configure high-quality settings
    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::Encode24(const Napi::CallbackInfo& info) {
    Napi::Env env = info.Env();
    if (info.Length() < 1 || !info[0].IsTypedArray()) {
        Napi::TypeError::New(env, "Int32Array required for 24-bit PCM").ThrowAsJavaScriptException();
        return env.Null();
    }

    auto pcm = info[0].As<Napi::Int32Array>();
    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_encode24(
        proj_enc_,
        reinterpret_cast<const opus_int32*>(pcm.Data()),
        frame_size_,
        out.data(),
        static_cast<opus_int32>(out.size())
    );

    if (ret < 0) {
        Napi::Error::New(env, std::string("Encode24 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 (string) and value (number) 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("encode24", &OpusHDEncoder::Encode24),
        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_APPLICATION_RESTRICTED_LOWDELAY", Napi::Number::New(env, OPUS_APPLICATION_RESTRICTED_LOWDELAY));
    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)