JackClient.cpp

Go to the documentation of this file.

//
// File: JackClient.h
// Created by: cc <cc@sony.stanford.edu>
// Created on: Sat Jul 26 13:08:21 2003
//

#include "JackClient.h"
#include "math.h"
#include "string.h"
#include "Snd.h"
jack_port_t **input_port;
jack_port_t **output_port;
jack_default_audio_sample_t **inBufPtr;
jack_default_audio_sample_t **outBufPtr;
double *inFrame;
double *outFrame;
double *iPhase;

int xx_nChans_xx;
unsigned int xx_nFrames_xx;
extern Snd *theSnd;
int
xx_global_process_xx (unsigned int nframes, void *argc)
{
if (nframes!=xx_nFrames_xx)
printf("xx_global_process_xx [%d nframes]\n", nframes);
/* "in" is in from jack, "out" is out to jack */
        for (int i = 0; i < xx_nChans_xx; i++)
        {
                inBufPtr[i] = (jack_default_audio_sample_t *)
                        jack_port_get_buffer (input_port[i], nframes);
                outBufPtr[i] = (jack_default_audio_sample_t *)
                        jack_port_get_buffer (output_port[i], nframes);
        }
//      memcpy (outBufPtr[0], inBufPtr[0], sizeof (jack_default_audio_sample_t) * nframes);
//      memcpy (outBufPtr[1], inBufPtr[1], sizeof (jack_default_audio_sample_t) * nframes);

        for (int j = 0; j < (int)nframes; j++)
        {
                jack_default_audio_sample_t *inBuf;
                jack_default_audio_sample_t *outBuf;
                for (int i = 0; i < xx_nChans_xx; i++)
                {
                        inBuf = inBufPtr[i];
                        inFrame[i] = inBuf[j];
                }

//              for (int i = 0; i < xx_nChans_xx; i++)
//                     outFrame[i] = inFrame[i];
/*              
                  for (int i = 0; i < xx_nChans_xx; i++)
                  {
                  outFrame[i] = sin (iPhase[i]);
                  iPhase[i] += 0.01;
                  }
*/               
      outFrame = theSnd->tickFrame(inFrame);

                for (int i = 0; i < xx_nChans_xx; i++)
                {
                        outBuf = outBufPtr[i];
                        outBuf[j] = outFrame[i];
                }
// printf("xx_global_process_xx [frame %d]\n", j);
        }

        return 0;
}

JackClient::JackClient (QString name, int nChans, int nFrames):Stk ()
{
        xx_nChans_xx = this->nChans = nChans;
        xx_nFrames_xx = nFrames;
        inFrame = new double[nChans];
        outFrame = new double[nChans];
        input_port = new jack_port_t *[nChans];
        output_port = new jack_port_t *[nChans];
        inBufPtr = new jack_default_audio_sample_t *[nChans];
        outBufPtr = new jack_default_audio_sample_t *[nChans];

        iPhase = new double[nChans];    // sample frame of output channels
        for (int i = 0; i < nChans; i++)
                iPhase[i] = 0.0;

        /* tell the JACK server to call error() whenever it
         * experiences an error.  Notice that this callback is
         * global to this process, not specific to each client.
         * 
         * This is set here so that it can catch errors in the
         * connection process
         */
        jack_set_error_function (error);

        /* try to become a client of the JACK server */

        if ((client = jack_client_new (name)) == 0)
        {
                printf ("jack server not running?\n");
//              return 1;
        }

        /* tell the JACK server to call `process()' whenever
         * there is work to be done.
         */

        jack_set_process_callback (client, xx_global_process_xx, 0);

        /* tell the JACK server to call `srate()' whenever
         * the sample rate of the system changes.
         */


        jack_set_sample_rate_callback (client, srate_callback, 0);

        /* tell the JACK server to call `jack_shutdown()' if
         * it ever shuts down, either entirely, or if it
         * just decides to stop calling us.
         */

        jack_on_shutdown (client, jack_shutdown, 0);

        /* display the current sample rate. once the client is activated 
         * (see below), you should rely on your own sample rate
         * callback (see above) for this value.
         */

        printf ("engine sample rate: %u\n", jack_get_sample_rate (client));

        /* create two ports */
        for (int i = 0; i < nChans; i++)
        {
                QString iName, oName;
                QTextOStream (&iName) << "input" << i;
                QTextOStream (&oName) << "output" << i;

                input_port[i] =
                        jack_port_register (client, iName,
                                            JACK_DEFAULT_AUDIO_TYPE,
                                            JackPortIsInput, 0);
                output_port[i] =
                        jack_port_register (client, oName,
                                            JACK_DEFAULT_AUDIO_TYPE,
                                            JackPortIsOutput, 0);
        }
}


void
JackClient::stop ()
{
jack_client_close (client);
        }
        
void
JackClient::start ()
{       /* tell the JACK server that we are ready to roll */

        if (jack_activate (client))
        {
                printf ("cannot activate client");
//              return 1;
        }
        go();
}
void
JackClient::go ()
{       /* tell the JACK server that we are ready to roll */

//      if (jack_activate (client))
//      {
//              printf ("cannot activate client");
//              return 1;
//      }

        /* connect the ports. Note: you can't do this before
         * the client is activated, because we can't allow
         * connections to be made to clients that aren't
         * running.
         */


        if ((ports =
             jack_get_ports (client, NULL, NULL,
                             JackPortIsPhysical | JackPortIsOutput)) == NULL)
        {
                fprintf (stderr, "Cannot find any physical capture ports\n");
                exit (1);
        }
        for (int i = 0; i < nChans; i++)
        {

                if (jack_connect
                    (client, ports[i], jack_port_name (input_port[i])))
                {
                        fprintf (stderr, "cannot connect input ports\n");
                }
        }

        free (ports);

        if ((ports =
             jack_get_ports (client, NULL, NULL,
                             JackPortIsPhysical | JackPortIsInput)) == NULL)
        {
                fprintf (stderr, "Cannot find any physical playback ports\n");
                exit (1);
        }

        for (int i = 0; i < nChans; i++)
        {
                if (jack_connect
                    (client, jack_port_name (output_port[i]), ports[i]))
                {
                        fprintf (stderr, "cannot connect output ports\n");
                }

        }
//      printf ("about to sleep\n");
        free (ports);

        /* Since this is just a toy, run for a few seconds, then finish */

//      sleep (10);
//      printf ("...awake\n");
//      jack_client_close (client);
//      exit (0);
}

JackClient::~JackClient ()
{
        // TODO: put destructor code here
}

---