jack2/common/JackAudioAdapter.cpp

/*
Copyright (C) 2008 Grame

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

*/

#include "JackAudioAdapter.h"
#include "JackLibSampleRateResampler.h"
#include "JackError.h"
#include "JackCompilerDeps.h"
#include "JackTools.h"
#include "jslist.h"
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

using namespace std;

namespace Jack
{

//static methods ***********************************************************
    int JackAudioAdapter::Process(jack_nframes_t frames, void* arg)
    {
        JackAudioAdapter* adapter = static_cast<JackAudioAdapter*>(arg);
        float* buffer;
        bool failure = false;
        int i;

        if (!adapter->fAudioAdapter->IsRunning())
            return 0;

        // DLL
        adapter->fAudioAdapter->SetCallbackTime(jack_get_time());

        // Push/pull from ringbuffer
        for (i = 0; i < adapter->fCaptureChannels; i++)
        {
            buffer = static_cast<float*>(jack_port_get_buffer(adapter->fCapturePortList[i], frames));
            if (adapter->fCaptureRingBuffer[i]->Read(buffer, frames) < frames)
                failure = true;
        }

        for (i = 0; i < adapter->fPlaybackChannels; i++)
        {
            buffer = static_cast<float*>(jack_port_get_buffer(adapter->fPlaybackPortList[i], frames));
            if (adapter->fPlaybackRingBuffer[i]->Write(buffer, frames) < frames)
                failure = true;
        }

        // Reset all ringbuffers in case of failure
        if (failure)
        {
            jack_error("JackCallbackAudioAdapter::Process ringbuffer failure... reset");
            adapter->Reset();
        }
        return 0;
    }

    int JackAudioAdapter::BufferSize ( jack_nframes_t buffer_size, void* arg )
    {
        JackAudioAdapter* adapter = static_cast<JackAudioAdapter*>(arg);
        adapter->Reset();
        adapter->fAudioAdapter->SetHostBufferSize ( buffer_size );
        return 0;
    }

    int JackAudioAdapter::SampleRate ( jack_nframes_t sample_rate, void* arg )
    {
        JackAudioAdapter* adapter = static_cast<JackAudioAdapter*>(arg);
        adapter->Reset();
        adapter->fAudioAdapter->SetHostSampleRate(sample_rate);
        return 0;
    }

//JackAudioAdapter *********************************************************
    JackAudioAdapter::~JackAudioAdapter()
    {
        // When called, Close has already been used for the client, thus ports are already unregistered.
        int i;
        for (i = 0; i < fCaptureChannels; i++)
            delete(fCaptureRingBuffer[i]);
        for (i = 0; i < fPlaybackChannels; i++)
            delete(fPlaybackRingBuffer[i]);

        delete[] fCaptureRingBuffer;
        delete[] fPlaybackRingBuffer;
        delete fAudioAdapter;
    }

    void JackAudioAdapter::FreePorts()
    {
        int i;
        for ( i = 0; i < fCaptureChannels; i++ )
            if ( fCapturePortList[i] )
                jack_port_unregister ( fJackClient, fCapturePortList[i] );
        for (i = 0; i < fCaptureChannels; i++)
            if ( fPlaybackPortList[i] )
                jack_port_unregister  (fJackClient, fPlaybackPortList[i] );

        delete[] fCapturePortList;
        delete[] fPlaybackPortList;
    }

    void JackAudioAdapter::Reset()
    {
        int i;
        for (i = 0; i < fCaptureChannels; i++)
            fCaptureRingBuffer[i]->Reset();
        for (i = 0; i < fPlaybackChannels; i++)
            fPlaybackRingBuffer[i]->Reset();
        fAudioAdapter->Reset();
    }

    int JackAudioAdapter::Open()
    {
        int i;
        char name[32];

        fCaptureChannels = fAudioAdapter->GetInputs();
        fPlaybackChannels = fAudioAdapter->GetOutputs();
        
        jack_log("JackAudioAdapter::Open fCaptureChannels %d fPlaybackChannels %d", fCaptureChannels, fPlaybackChannels);

        //ringbuffers
        fCaptureRingBuffer = new JackResampler*[fCaptureChannels];
        fPlaybackRingBuffer = new JackResampler*[fPlaybackChannels];
        for ( i = 0; i < fCaptureChannels; i++ )
            fCaptureRingBuffer[i] = new JackLibSampleRateResampler();
        for ( i = 0; i < fPlaybackChannels; i++ )
            fPlaybackRingBuffer[i] = new JackLibSampleRateResampler();
        fAudioAdapter->SetRingBuffers(fCaptureRingBuffer, fPlaybackRingBuffer);
        if ( fCaptureChannels )
			jack_log ( "ReadSpace = %ld", fCaptureRingBuffer[0]->ReadSpace() );
		if ( fPlaybackChannels )
			jack_log ( "WriteSpace = %ld", fPlaybackRingBuffer[0]->WriteSpace() );

        //jack ports
        fCapturePortList = new jack_port_t* [fCaptureChannels];
        fPlaybackPortList = new jack_port_t* [fPlaybackChannels];

        for (i = 0; i < fCaptureChannels; i++)
        {
            sprintf(name, "capture_%d", i+1);
            if ( ( fCapturePortList[i] = jack_port_register ( fJackClient, name, JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0 ) ) == NULL )
                goto fail;
        }

        for (i = 0; i < fPlaybackChannels; i++)
        {
            sprintf(name, "playback_%d", i+1);
            if ( ( fPlaybackPortList[i] = jack_port_register ( fJackClient, name, JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0 ) ) == NULL )
                goto fail;
        }

        //callbacks and activation
        if ( jack_set_process_callback ( fJackClient, Process, this ) < 0 )
            goto fail;
        if ( jack_set_buffer_size_callback ( fJackClient, BufferSize, this ) < 0 )
            goto fail;
        if ( jack_set_sample_rate_callback ( fJackClient, SampleRate, this ) < 0 )
            goto fail;
        if ( jack_activate ( fJackClient ) < 0 )
            goto fail;

        //ringbuffers and jack clients are ok, we can now open the adapter driver interface
        return fAudioAdapter->Open();

fail:
        FreePorts();
        return -1;
    }

    int JackAudioAdapter::Close()
    {
        return fAudioAdapter->Close();
    }

} //namespace