JackPort.cpp

Go to the documentation of this file.

/*******************************************************************************
 * JackPort.cpp (JackFX) 
 ******************************************************************************/

#include "JackPort.h"
#include "JackClient.h"

JackPort::JackPort(const string& name, bool writer, const char* type) : m_writer(writer)
{
    m_port = jack_port_register(JackClient::GetSingleton()->GetClient(), name.c_str(), 
            type, (m_writer ? JackPortIsOutput : JackPortIsInput) | JackPortIsTerminal, 0);
}

JackPort::~JackPort()
{
    try {
        jack_port_unregister(JackClient::GetSingleton()->GetClient(), m_port);
    }
    catch(...) {} //Ignore.
}

bool JackPort::ConnectTo(const string& destport)
{
    const char* in = m_writer ? destport.c_str() : jack_port_name(GetPort());
    const char* out = m_writer ? jack_port_name(GetPort()) : destport.c_str();

    int result = jack_connect(JackClient::GetSingleton()->GetClient(), out, in);
    
    if (result == 0) {
        return true;
    }
    else if (result == EEXIST) {
        return false;
    }
    else {
        throw runtime_error("Could not connect to port `" + destport + "'.");
    }
}

void JackPort::DisconnectFrom(const string& destport)
{
    int result = jack_disconnect(JackClient::GetSingleton()->GetClient(),
        jack_port_name(GetPort()), destport.c_str());
    
    if (result != 0) {
        throw runtime_error("Could not disconnect from port `" + destport + "'.");
    }
}

JackMidiPort::JackMidiPort(const string& name, bool writer) :
        JackPort(name, writer, JACK_DEFAULT_MIDI_TYPE)
{
    pthread_mutex_init(&m_mtx, NULL);
    JackClient::GetSingleton()->m_midiports.push_back(this);
}

JackMidiPort::~JackMidiPort()
{
    pthread_mutex_destroy(&m_mtx);
    if (JackClient::GetSingleton()) {
        JackClient::GetSingleton()->m_midiports.remove(this);
    }
}

queue<jack_midi_event_t>& JackMidiPort::GetEventQueue()
{
    return m_eventqueue;
}

python::object JackMidiPort::GetPyEventQueue()
{
    pthread_mutex_lock(&m_mtx);
    python::list ret;
    while (m_eventqueue.size()) {
        jack_midi_event_t& evt = m_eventqueue.front();

        //I don't know a better way of doing this.
        //using namespace boost::python;
        switch(evt.size) {
            case 1:
                ret.append(python::make_tuple(evt.buffer[0]));
                break;
            case 2:
                ret.append(python::make_tuple(evt.buffer[0], evt.buffer[1]));
                break;
            case 3:
                ret.append(python::make_tuple(evt.buffer[0], evt.buffer[1], evt.buffer[2]));
                break;
            case 4:
                ret.append(python::make_tuple(evt.buffer[0], evt.buffer[1], evt.buffer[2], evt.buffer[3]));
                break;
            default:
                ret.append(python::make_tuple(evt.buffer[0], evt.buffer[1], evt.buffer[2], evt.buffer[3], evt.buffer[4]));
                break;
        }

        m_eventqueue.pop();
    }
    pthread_mutex_unlock(&m_mtx);

    return ret;
}

void JackMidiPort::Read(jack_nframes_t nframes)
{
    pthread_mutex_lock(&m_mtx);
    void* port_buf = jack_port_get_buffer(GetPort(), nframes);

    jack_nframes_t eventcount = jack_midi_get_event_count(port_buf);
    for (int i = 0; i < eventcount; ++i) {
        jack_midi_event_t in_evt;
        jack_midi_event_get(&in_evt, port_buf, i);
        m_eventqueue.push(in_evt);
        /*cout << "Event " << i << " time is " << in_evt.time << ". 1st byte is " << (int)*(in_evt.buffer) << endl;
        for (unsigned int x = 0; x < in_evt.size; ++x) {
            cout << "\tByte " << x << " is " << (int)(in_evt.buffer[x]) << endl;
        }*/
    }
    pthread_mutex_unlock(&m_mtx);
}

void JackAudioPort::GetFrame(SoundFrame& frame, jack_nframes_t nframes)
{
    frame.Set((jack_default_audio_sample_t*)jack_port_get_buffer(GetPort(), nframes), nframes);
}

void JackAudioPort::PutFrame(const SoundFrame& frame)
{
    void* out = jack_port_get_buffer(GetPort(), frame.SampleCount());
    memcpy(out, frame.GetSamples(), sizeof(jack_default_audio_sample_t) * frame.SampleCount());
}

JackInput::JackInput(const string& name) : JackAudioPort(name, false)
{
}

JackInput::~JackInput()
{
}

void JackInput::Process(jack_nframes_t samples)
{
    //Fill our pipe with our jack port input.
    GetFrame(GetPipe(), samples);
}

JackOutput::JackOutput(const string& name) : JackAudioPort(name, true)
{
}

JackOutput::~JackOutput()
{
}

void JackOutput::Process(jack_nframes_t count)
{
    GetPipe().Zero();
    ISoundElement::Process(count);
    //cout << GetPipe() << endl;
    PutFrame(GetPipe());
}