sfizz/clients/jack_client.cpp

// Copyright (c) 2019, Paul Ferrand
// All rights reserved.

// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:

// 1. Redistributions of source code must retain the above copyright notice, this
//    list of conditions and the following disclaimer.
// 2. Redistributions in binary form must reproduce the above copyright notice,
//    this list of conditions and the following disclaimer in the documentation
//    and/or other materials provided with the distribution.

// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

#include "StereoSpan.h"
#include "Synth.h"
#include <absl/flags/parse.h>
#include <absl/types/span.h>
#include <atomic>
#include <cstddef>
#include <ios>
#include <iostream>
#include <jack/jack.h>
#include <jack/midiport.h>
#include <jack/types.h>
#include <ostream>
#include <signal.h>
#include <string_view>
#include <thread>
using namespace std::literals;

static jack_port_t* midiInputPort;
static jack_port_t* outputPort1;
static jack_port_t* outputPort2;
static jack_client_t* client;

namespace midi {
constexpr uint8_t statusMask { 0b11110000 };
constexpr uint8_t channelMask { 0b00001111 };
constexpr uint8_t noteOff { 0x80 };
constexpr uint8_t noteOn { 0x90 };
constexpr uint8_t polyphonicPressure { 0xA0 };
constexpr uint8_t controlChange { 0xB0 };
constexpr uint8_t programChange { 0xC0 };
constexpr uint8_t channelPressure { 0xD0 };
constexpr uint8_t pitchBend { 0xE0 };
constexpr uint8_t systemMessage { 0xF0 };

constexpr uint8_t status(uint8_t midiStatusByte)
{
    return midiStatusByte & statusMask;
}
constexpr uint8_t channel(uint8_t midiStatusByte)
{
    return midiStatusByte & channelMask;
}
}

static std::atomic<bool> keepRunning [[maybe_unused]] { true };

int process(jack_nframes_t numFrames, void* arg [[maybe_unused]])
{
    auto synth = reinterpret_cast<sfz::Synth*>(arg);

    auto buffer = jack_port_get_buffer(midiInputPort, numFrames);
    assert(buffer);

    auto numMidiEvents = jack_midi_get_event_count(buffer);
    jack_midi_event_t event;

    // Midi dispatching
    for (uint32_t i = 0; i < numMidiEvents; ++i) {
        if (jack_midi_event_get(&event, buffer, i) != 0)
            continue;

        if (event.size == 0)
            continue;

        switch (midi::status(event.buffer[0])) {
        case midi::noteOff:
            DBG("[MIDI] Note " << +event.buffer[1] << " OFF at time " << event.time);
            synth->noteOff(event.time, midi::channel(event.buffer[0]) + 1, event.buffer[1], event.buffer[2]);
            break;
        case midi::noteOn:
            DBG("[MIDI] Note " << +event.buffer[1] << " ON at time " << event.time);
            synth->noteOn(event.time, midi::channel(event.buffer[0]) + 1, event.buffer[1], event.buffer[2]);
            break;
        case midi::polyphonicPressure:
            DBG("[MIDI] Polyphonic pressure on at time " << event.time);
            break;
        case midi::controlChange:
            DBG("[MIDI] CC " << +event.buffer[1] << " at time " << event.time);
            synth->cc(event.time, midi::channel(event.buffer[0]) + 1, event.buffer[1], event.buffer[2]);
            break;
        case midi::programChange:
            DBG("[MIDI] Program change at time " << event.time);
            break;
        case midi::channelPressure:
            DBG("[MIDI] Channel pressure at time " << event.time);
            break;
        case midi::pitchBend:
            DBG("[MIDI] Pitch bend at time " << event.time);
            break;
        case midi::systemMessage:
            DBG("[MIDI] System message at time " << event.time);
            break;
        }
    }

    StereoSpan<float> output {
        jack_port_get_buffer(outputPort1, numFrames),
        jack_port_get_buffer(outputPort2, numFrames), 
        numFrames
    };

    synth->renderBlock(output);

    return 0;
}

int sampleBlockChanged(jack_nframes_t nframes, void* arg [[maybe_unused]])
{
    if (arg == nullptr)
        return 0;

    auto synth = reinterpret_cast<sfz::Synth*>(arg);
    DBG("Sample per block changed to " << nframes);
    synth->setSamplesPerBlock(nframes);
    return 0;
}

int sampleRateChanged(jack_nframes_t nframes, void* arg [[maybe_unused]])
{
    if (arg == nullptr)
        return 0;

    auto synth = reinterpret_cast<sfz::Synth*>(arg);
    DBG("Sample rate changed to " << nframes);
    synth->setSampleRate(nframes);
    return 0;
}

static bool shouldClose { false };

static void done(int sig [[maybe_unused]])
{
    std::cout << "Signal received" << '\n';
    shouldClose = true;
    // if (client != nullptr)
        
    // exit(0);
}

int main(int argc, char** argv)
{
    // std::ios::sync_with_stdio(false);
    auto arguments = absl::ParseCommandLine(argc, argv);
    auto filesToParse = absl::MakeConstSpan(arguments).subspan(1);
    std::cout << "Positional arguments:";
    for (auto& file : filesToParse)
        std::cout << " " << file << ',';
    std::cout << '\n';

    sfz::Synth synth;
    std::filesystem::path filename { filesToParse[0] };
    synth.loadSfzFile(filename);
    std::cout << "==========" << '\n';
    std::cout << "Total:" << '\n';
    std::cout << "\tMasters: " << synth.getNumMasters() << '\n';
    std::cout << "\tGroups: " << synth.getNumGroups() << '\n';
    std::cout << "\tRegions: " << synth.getNumRegions() << '\n';
    std::cout << "\tCurves: " << synth.getNumCurves() << '\n';
    std::cout << "\tPreloadedSamples: " << synth.getNumPreloadedSamples() << '\n';
    std::cout << "==========" << '\n';
    std::cout << "Included files:" << '\n';
    for (auto& file : synth.getIncludedFiles())
        std::cout << '\t' << file.string() << '\n';
    std::cout << "==========" << '\n';
    std::cout << "Defines:" << '\n';
    for (auto& define : synth.getDefines())
        std::cout << '\t' << define.first << '=' << define.second << '\n';
    std::cout << "==========" << '\n';
    std::cout << "Unknown opcodes:";
    for (auto& opcode : synth.getUnknownOpcodes())
        std::cout << opcode << ',';
    std::cout << '\n';
    // std::cout << std::flush;

    auto defaultName = "sfizz";
    jack_status_t status;
    client = jack_client_open(defaultName, JackNullOption, &status);
    if (client == nullptr) {
        std::cerr << "Could not open JACK client" << '\n';
        // if (status & JackFailure)
        //     std::cerr << "JackFailure: Overall operation failed" << '\n';
        return 1;
    }

    if (status & JackNameNotUnique) {
        std::cout << "Name was taken: assigned " << jack_get_client_name(client) << "instead" << '\n';
    }
    if (status & JackServerStarted) {
        std::cout << "Connected to JACK" << '\n';
    }

    synth.setSamplesPerBlock(jack_get_buffer_size(client));
    synth.setSampleRate(jack_get_sample_rate(client));

    jack_set_sample_rate_callback(client, sampleRateChanged, &synth);
    jack_set_buffer_size_callback(client, sampleBlockChanged, &synth);
    jack_set_process_callback(client, process, &synth);

    midiInputPort = jack_port_register(client, "input", JACK_DEFAULT_MIDI_TYPE, JackPortIsInput, 0);
    if (midiInputPort == nullptr) {
        std::cerr << "Could not open MIDI input port" << '\n';
        return 1;
    }

    outputPort1 = jack_port_register(client, "output_1", JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0);
    outputPort2 = jack_port_register(client, "output_2", JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0);
    if (outputPort1 == nullptr || outputPort2 == nullptr) {
        std::cerr << "Could not open output ports" << '\n';
        return 1;
    }

    if (jack_activate(client) != 0) {
        std::cerr << "Could not activate client" << '\n';
        return 1;
    }

    auto systemPorts = jack_get_ports(client, nullptr, nullptr, JackPortIsPhysical | JackPortIsInput);
    if (systemPorts == nullptr) {
        std::cerr << "No physical output ports found" << '\n';
        return 1;
    }

    if (jack_connect(client, jack_port_name(outputPort1), systemPorts[0])) {
        std::cerr << "Cannot connect to physical output ports (0)" << '\n';
    }

    if (jack_connect(client, jack_port_name(outputPort2), systemPorts[1])) {
        std::cerr << "Cannot connect to physical output ports (1)" << '\n';
    }
    jack_free(systemPorts);

    signal(SIGHUP, done);
    signal(SIGINT, done);
    signal(SIGTERM, done);
    signal(SIGQUIT, done);

    while (!shouldClose)
        sleep(1);
    
    std::cout << "Closing..." << '\n';
    jack_client_close(client);
    return 0;
}