void JackClient::GetPortNames(std::vector<std::string> &InputNames, std::vector<std::string> &OutputNames) {
InputNames.clear();
OutputNames.clear();
if(!m_Attached) return;
//Outputs first
const char **PortNameList = jack_get_ports(m_Client, NULL, NULL, JackPortIsOutput);
int n = 0;
while(PortNameList[n] != NULL) {
OutputNames.push_back(PortNameList[n]);
n++;
}
delete PortNameList;
//Inputs second
PortNameList = jack_get_ports(m_Client, NULL, NULL, JackPortIsInput);
n = 0;
while(PortNameList[n] != NULL) {
InputNames.push_back(PortNameList[n]);
n++;
}
delete PortNameList;
}
static int ja_connect_client(void)
{
char **ports;
int i;
ports = (char **) jack_get_ports(client, NULL, NULL,
JackPortIsPhysical | JackPortIsOutput);
if (ports == NULL)
return 1;
for (i = 0; i < ja_in_channels && ports[i] != NULL; i++)
jack_connect(client, ports[i], jack_port_name(input_ports[i]));
jack_free(ports);
ports = (char **) jack_get_ports(client, NULL, NULL,
JackPortIsPhysical | JackPortIsInput);
if (ports == NULL)
return 1;
for (i = 0; i < ja_out_channels && ports[i] != NULL; i++)
jack_connect(client, jack_port_name(output_ports[i]), ports[i]);
jack_free(ports);
return 0;
}
static int _list_ports(ClientData clientData, Tcl_Interp *interp, int argc, Tcl_Obj* const *objv) {
if (argc != 2) return fw_error_str(interp, "jack-client list-ports");
_t *dp = (_t *)clientData;
Tcl_Obj *dict = Tcl_NewDictObj();
const char **portv[] = {
jack_get_ports (dp->fw.client, NULL, JACK_DEFAULT_AUDIO_TYPE, 0),
jack_get_ports (dp->fw.client, NULL, JACK_DEFAULT_MIDI_TYPE, 0)
};
for (int p = 0; p < 2; p += 1)
if (portv[p] != NULL) {
for (int i = 0; portv[p][i] != NULL; i += 1) {
jack_port_t *port = jack_port_by_name(dp->fw.client, portv[p][i]);
if (port != NULL) {
Tcl_Obj *pdict = Tcl_NewDictObj();
int flags = jack_port_flags(port);
Tcl_DictObjPut(interp, pdict, Tcl_NewStringObj("direction", -1), flags & JackPortIsInput ? Tcl_NewStringObj("input", -1) : Tcl_NewStringObj("output", -1) );
Tcl_DictObjPut(interp, pdict, Tcl_NewStringObj("physical", -1), Tcl_NewIntObj(flags & JackPortIsPhysical ? 1 : 0));
Tcl_DictObjPut(interp, pdict, Tcl_NewStringObj("type", -1), p == 0 ? Tcl_NewStringObj("audio", -1) : Tcl_NewStringObj("midi", -1));
const char **connv = jack_port_get_all_connections(dp->fw.client, port);
Tcl_Obj *list = Tcl_NewListObj(0, NULL);
if (connv != NULL) {
for (int j = 0; connv[j] != NULL; j += 1)
Tcl_ListObjAppendElement(interp, list, Tcl_NewStringObj(connv[j], -1));
jack_free(connv);
}
Tcl_DictObjPut(interp, pdict, Tcl_NewStringObj("connections", -1), list);
Tcl_DictObjPut(interp, dict, Tcl_NewStringObj(portv[p][i], -1), pdict);
}
}
jack_free(portv[p]);
}
Tcl_SetObjResult(interp, dict);
return TCL_OK;
}
static int jack_connect_ports(char* client)
{
char regex_pattern[100]; /* its always the same, ... */
int i;
const char **jack_ports;
if (strlen(client) > 96) return -1;
sprintf( regex_pattern, "%s:.*", client );
jack_ports = jack_get_ports( jack_client, regex_pattern,
NULL, JackPortIsOutput);
if (jack_ports)
{
for (i=0;jack_ports[i] != NULL && i < sys_inchannels;i++)
if (jack_connect (jack_client, jack_ports[i],
jack_port_name (input_port[i])))
error ("JACK: cannot connect input ports %s -> %s",
jack_ports[i],jack_port_name (input_port[i]));
free(jack_ports);
}
jack_ports = jack_get_ports( jack_client, regex_pattern,
NULL, JackPortIsInput);
if (jack_ports)
{
for (i=0;jack_ports[i] != NULL && i < sys_outchannels;i++)
if (jack_connect (jack_client, jack_port_name (output_port[i]),
jack_ports[i]))
error( "JACK: cannot connect output ports %s -> %s",
jack_port_name (output_port[i]),jack_ports[i]);
free(jack_ports);
}
return 0;
}
int JackSapaProxy::Setup(jack_client_t* client)
{
jack_log("JackSapaProxy::Setup");
//refer to system ports and create sapaproxy ports
unsigned int i = 0, j = 0;
const char **ports_system_capture;
const char **ports_system_playback;
unsigned int ports_system_capture_cnt = 0;
unsigned int ports_system_playback_cnt = 0;
char port_name[JACK_PORT_NAME_SIZE] = {0,};
ports_system_capture = jack_get_ports(client, "system:.*", NULL, JackPortIsPhysical | JackPortIsOutput);
if (ports_system_capture != NULL) {
for (i = 0; i < fCapturePorts && ports_system_capture[i]; i++) {
sprintf(port_name, "__system_capture_%d", i + 1);
fInputPorts[i] = jack_port_register(client, port_name, JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0);
sprintf(port_name, "capture_%d", i + 1);
fOutputPorts[i] = jack_port_register(client, port_name, JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0);
ports_system_capture_cnt++;
}
jack_free(ports_system_capture);
}
ports_system_playback = jack_get_ports(client, "system:.*", NULL, JackPortIsPhysical | JackPortIsInput);
if (ports_system_playback != NULL) {
for (j = 0; j < fPlaybackPorts && ports_system_playback[j]; j++, i++) {
sprintf(port_name, "playback_%d", j + 1);
fInputPorts[i] = jack_port_register(client, port_name, JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0);
sprintf(port_name, "__system_playback_%d", j + 1);
fOutputPorts[i] = jack_port_register(client, port_name, JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0);
ports_system_playback_cnt++;
}
jack_free(ports_system_playback);
}
//store actual number of system ports
fCapturePorts = ports_system_capture_cnt;
fPlaybackPorts = ports_system_playback_cnt;
jack_set_process_callback(client, Process, this);
jack_activate(client);
//conenct between sapaproxy and system ports
for (unsigned int i = 0; i < ports_system_capture_cnt; i++) {
sprintf(port_name, "system:capture_%d", i + 1);
jack_connect(client, port_name, jack_port_name(fInputPorts[i]));
}
for (unsigned int i = 0; i < ports_system_playback_cnt; i++) {
sprintf(port_name, "system:playback_%d", i + 1);
jack_connect(client, jack_port_name(fOutputPorts[ports_system_capture_cnt + i]), port_name);
}
return 0;
}
bool JackClient::autoConnectPortsToMPG123()
{
const char **pp_ports;
int retval;
// connect left channel
pp_ports = jack_get_ports(m_p_jackClient,
s_portNameToConnectLeftChannelRegex.c_str(),
NULL, JackPortIsOutput);
if (pp_ports == NULL) {
DEBUG_PRINT("[!] no output port with name %s found (regex)",
s_portNameToConnectLeftChannelRegex.c_str());
return false;
}
retval = jack_connect(m_p_jackClient, pp_ports[0],
jack_port_name(m_p_leftChannelInputPort));
free(pp_ports);
if (retval) {
DEBUG_PRINT("[!] cannot connect input port %s (%d)",
jack_port_name(m_p_leftChannelInputPort), retval);
return false;
} else {
DEBUG_PRINT("successfully connected %s to %s",
s_portNameToConnectLeftChannelRegex.c_str(),
jack_port_name(m_p_leftChannelInputPort));
}
// connect right channel
pp_ports = jack_get_ports(m_p_jackClient,
s_portNameToConnectRightChannelRegex.c_str(),
NULL, JackPortIsOutput);
if (pp_ports == NULL) {
DEBUG_PRINT("[!] no output port with name %s found (regex)",
s_portNameToConnectRightChannelRegex.c_str());
return false;
}
retval = jack_connect(m_p_jackClient, pp_ports[0],
jack_port_name(m_p_rightChannelInputPort));
free(pp_ports);
if (retval) {
DEBUG_PRINT("[!] cannot connect input port %s (%d)",
jack_port_name(m_p_rightChannelInputPort), retval);
return false;
} else {
DEBUG_PRINT("successfully connected %s to %s",
s_portNameToConnectRightChannelRegex.c_str(),
jack_port_name(m_p_rightChannelInputPort));
}
return true;
}
/**
* This required entry point is called after the client is loaded by
* jack_internal_client_load().
*
* @param client pointer to JACK client structure.
* @param load_init character string passed to the load operation.
*
* @return 0 if successful; otherwise jack_finish() will be called and
* the client terminated immediately.
*/
int
jack_initialize (jack_client_t *client, const char *load_init)
{
port_pair_t *pp = malloc (sizeof (port_pair_t));
const char **ports;
if (pp == NULL)
return 1; /* heap exhausted */
jack_set_process_callback (client, inprocess, pp);
/* create a pair of ports */
pp->input_port = jack_port_register (client, "input",
JACK_DEFAULT_AUDIO_TYPE,
JackPortIsInput, 0);
pp->output_port = jack_port_register (client, "output",
JACK_DEFAULT_AUDIO_TYPE,
JackPortIsOutput, 0);
/* join the process() cycle */
jack_activate (client);
ports = jack_get_ports (client, NULL, NULL,
JackPortIsPhysical|JackPortIsOutput);
if (ports == NULL) {
fprintf(stderr, "no physical capture ports\n");
return 1; /* terminate client */
}
if (jack_connect (client, ports[0], jack_port_name (pp->input_port))) {
fprintf (stderr, "cannot connect input ports\n");
}
free (ports);
ports = jack_get_ports (client, NULL, NULL,
JackPortIsPhysical|JackPortIsInput);
if (ports == NULL) {
fprintf(stderr, "no physical playback ports\n");
return 1; /* terminate client */
}
if (jack_connect (client, jack_port_name (pp->output_port), ports[0])) {
fprintf (stderr, "cannot connect output ports\n");
}
free (ports);
return 0; /* success */
}
// Crude way of automatically connecting up jack ports
int autoconnect_jack_ports( jack_client_t* client )
{
const char **all_ports;
unsigned int ch=0;
int i;
// Get a list of all the jack ports
all_ports = jack_get_ports(client, NULL, NULL, JackPortIsOutput);
if (!all_ports) {
rotter_fatal("autoconnect_jack_ports(): jack_get_ports() returned NULL.");
return -1;
}
// Step through each port name
for (i = 0; all_ports[i]; ++i) {
// Connect the port
if (connect_jack_port( all_ports[i], inport[ch] )) {
return -1;
}
// Found enough ports ?
if (++ch >= channels) break;
}
free( all_ports );
return 0;
}
static int attach_input_ports(struct state_jack *s)
{
int i = 0;
const char **ports;
if ((ports = jack_get_ports (s->client, s->in_port_pattern, NULL, JackPortIsOutput)) == NULL) {
fprintf(stderr, "Cannot find any ports matching pattern '%s'\n", s->in_port_pattern);
return FALSE;
}
while (ports[i]) ++i;
if(i < s->record.ch_count) {
fprintf(stderr, "Not enought input ports found matching pattern '%s': "
"%d requested, %d found\n", s->in_port_pattern, s->record.ch_count, i);
fprintf(stderr, "Reducing port count to %d\n", i);
s->record.ch_count = i;
}
for(i = 0; i < s->in_ch_count; ++i) {
if (jack_connect (s->client, ports[i], jack_port_name (s->input_port[i]))) {
fprintf (stderr, "cannot connect input ports\n");
}
}
free (ports);
return TRUE;
}
// Crude way of automatically connecting up jack ports
static void autoconnect_jack_ports( jack_client_t* client, int port_count )
{
const char **all_ports;
int ch=0, err = 0;
int i;
// Get a list of all the jack ports
all_ports = jack_get_ports(client, NULL, NULL, JackPortIsOutput);
if (!all_ports) {
MAST_FATAL("autoconnect_jack_ports(): jack_get_ports() returned NULL");
}
// Step through each port name
for (i = 0; all_ports[i]; ++i) {
const char* local_port = jack_port_name( g_jackport[ch] );
// Connect the port
MAST_INFO("Connecting '%s' => '%s'", all_ports[i], local_port);
err = jack_connect(client, all_ports[i], local_port);
if (err != 0) MAST_FATAL("connect_jack_port(): failed to jack_connect() ports: %d", err);
// Found enough ports ?
if (++ch >= port_count) break;
}
free( all_ports );
}
std::string RtMidiOutJack :: getPortName( unsigned int portNumber )
{
JackMidiData *data = static_cast<JackMidiData *> (apiData_);
std::ostringstream ost;
std::string retStr("");
// List of available ports
const char **ports = jack_get_ports( data->client, NULL,
JACK_DEFAULT_MIDI_TYPE, JackPortIsInput );
// Check port validity
if ( ports == NULL) {
errorString_ = "RtMidiOut::getPortName: no ports available!";
error( RtError::WARNING );
return retStr;
}
if ( ports[portNumber] == NULL) {
ost << "RtMidiOut::getPortName: the 'portNumber' argument (" << portNumber << ") is invalid.";
errorString_ = ost.str();
error( RtError::WARNING );
}
else retStr.assign( ports[portNumber] );
free( ports );
return retStr;
}
int main (int argc, char* argv[]) {
jack_client_t* client;
char const default_name[] = "connector";
// this is moderately retarded
aliases[0] = (char *) malloc (jack_port_name_size());
aliases[1] = (char *) malloc (jack_port_name_size());
client = jack_client_open(default_name, JackNullOption, NULL);
while (1) {
const char **portnames;
const char **orig;
orig = portnames = jack_get_ports(client, "", "", 0);
desired_connection *desired = desired_connections;
while (desired->from_port) {
ensure_connected(client, orig, desired);
desired++;
}
printf("\n");
sleep(5);
jack_free(orig);
}
}
// Returns a list of all port names registered in the Jack system
static PyObject* get_ports(PyObject* self, PyObject* args)
{
PyObject* plist;
const char** jplist;
int i;
pyjack_client_t * client = self_or_global_client(self);
if(client->pjc == NULL) {
PyErr_SetString(JackNotConnectedError, "Jack connection has not yet been established.");
return NULL;
}
jplist = jack_get_ports(client->pjc, NULL, NULL, 0);
i = 0;
plist = PyList_New(0);
if(jplist != NULL) {
while(jplist[i] != NULL) {
PyList_Append(plist, Py_BuildValue("s", jplist[i]));
//free(jplist[i]); // Memory leak or not??
i++;
}
}
Py_INCREF(plist);
return plist;
}
/* 0 on error */
static int autoconnect_jack_ports(out123_handle *ao, jack_handle_t* handle)
{
const char **all_ports;
unsigned int ch=0;
int err,i;
/* Get a list of all the jack ports*/
all_ports = jack_get_ports (handle->client, NULL, NULL, JackPortIsInput);
if(!all_ports)
{
if(!AOQUIET)
error("connect_jack_ports(): jack_get_ports() returned NULL.");
return 0;
}
/* Step through each port name*/
for (i = 0; all_ports[i]; ++i)
{
const char* in = jack_port_name( handle->ports[ch] );
const char* out = all_ports[i];
if ((err = jack_connect(handle->client, in, out)) != 0 && err != EEXIST)
{
if(!AOQUIET)
error1("connect_jack_ports(): failed to jack_connect() ports: %d",err);
return 0;
}
/* Found enough ports ?*/
if (++ch >= handle->channels) break;
}
jack_free(all_ports);
return 1;
}
void
createPorts(jack_client_t *client, std::vector<jack_port_t *> &ports,
bool playback, std::vector<jack_ringbuffer_t *> &ringbuffers)
{
const char **physical_ports = jack_get_ports(client, NULL, NULL,
playback ? JackPortIsInput : JackPortIsOutput | JackPortIsPhysical);
for (unsigned i = 0; physical_ports[i]; ++i) {
char port_name[32] = {0};
if (playback)
snprintf(port_name, sizeof(port_name), "out_%d", i + 1);
else
snprintf(port_name, sizeof(port_name), "in_%d", i + 1);
port_name[sizeof(port_name) - 1] = '\0';
jack_port_t *port = jack_port_register(client,
port_name, JACK_DEFAULT_AUDIO_TYPE, playback ? JackPortIsOutput : JackPortIsInput, 0);
if (port == nullptr)
throw std::runtime_error("Could not register JACK output port");
ports.push_back(port);
static const unsigned RB_SIZE = 16384;
jack_ringbuffer_t *rb = jack_ringbuffer_create(RB_SIZE);
if (rb == nullptr)
throw std::runtime_error("Could not create JACK ringbuffer");
if (jack_ringbuffer_mlock(rb))
throw std::runtime_error("Could not lock JACK ringbuffer in memory");
ringbuffers.push_back(rb);
}
free(physical_ports);
}
//-------------------------------------------------------------------------------
void JMess::setConnectedPorts()
{
mConnectedPorts.clear();
const char **ports, **connections; //vector of ports and connections
QVector<QString> OutputInput(2); //helper variable
//Get active output ports.
ports = jack_get_ports (mClient, NULL, NULL, JackPortIsOutput);
for (unsigned int out_i = 0; ports[out_i]; ++out_i) {
if ((connections = jack_port_get_all_connections
(mClient, jack_port_by_name(mClient, ports[out_i]))) != 0) {
for (unsigned int in_i = 0; connections[in_i]; ++in_i) {
OutputInput[0] = ports[out_i];
//cout << "Output ===> " <<qPrintable(OutputInput[0]) << endl;
OutputInput[1] = connections[in_i];
//cout << "Input ===> " << qPrintable(OutputInput[1]) << endl;
mConnectedPorts.append(OutputInput);
}
}
}
free(ports);
}
/*------------------------------------------------------------------------------
* Attempt to connect up the JACK ports automatically
* - Just connect left&right to the first two output ports we find
*----------------------------------------------------------------------------*/
void
JackDspSource :: do_auto_connect ( void ) throw ( Exception )
{
const char **all_ports;
unsigned int ch = 0;
int i;
Reporter::reportEvent( 10, "JackDspSource :: do_auto_connect");
// Get a list of all the jack ports
all_ports = jack_get_ports (client, NULL, NULL, JackPortIsOutput);
if (!ports) {
throw Exception( __FILE__, __LINE__, "jack_get_ports() returned NULL.");
}
// Step through each port name
for (i = 0; all_ports[i]; ++i) {
const char* in = all_ports[i];
const char* out = jack_port_name( ports[ch] );
Reporter::reportEvent( 2, "Connecting", in, "to", out);
if (jack_connect(client, in, out)) {
throw Exception( __FILE__, __LINE__,
"Failed to jack_connect() ports", in, out);
}
// Found enough ports ?
if (++ch >= getChannel()) break;
}
free( all_ports );
}
void
setup_notebook_out(void) {
const char ** ports_out;
int i, j, k;
char client_name[MAXLEN];
char client_name_prev[MAXLEN];
char port_name[MAXLEN];
GtkTreeIter iter;
ports_out = jack_get_ports(jack_client, NULL, NULL, JackPortIsInput);
for (j = 0; j < MAXLEN; j++) {
client_name[j] = '\0';
client_name_prev[j] = '\0';
}
i = 0;
n_clients = -1;
if (ports_out) {
while (ports_out[i] != NULL) {
/* get the client name */
j = 0;
while ((ports_out[i][j] != ':') && (ports_out[i][j] != '\0')) {
client_name[j] = ports_out[i][j];
j++;
}
client_name[j] = '\0';
/* create a new notebook page if needed */
if (strcmp(client_name, client_name_prev) != 0) {
n_clients++;
store_out_nb[n_clients] = gtk_list_store_new(1, G_TYPE_STRING);
nb_out_labels[n_clients] = gtk_label_new(client_name);
gtk_widget_show(nb_out_labels[n_clients]);
gtk_notebook_insert_page(GTK_NOTEBOOK(nb_outs), GTK_WIDGET(setup_tree_out()),
GTK_WIDGET(nb_out_labels[n_clients]), n_clients);
}
/* add the port to the list */
j = 0;
while ((ports_out[i][j] != ':') && (ports_out[i][j] != '\0'))
j++;
if (ports_out[i][j] == '\0')
fprintf(stderr, "ERROR: bad JACK port string: %s\n", ports_out[i]);
else {
k = 0;
j++;
while (ports_out[i][j] != '\0')
port_name[k++] = ports_out[i][j++];
port_name[k] = '\0';
gtk_list_store_append(store_out_nb[n_clients], &iter);
gtk_list_store_set(store_out_nb[n_clients], &iter, 0, port_name, -1);
}
strcpy(client_name_prev, client_name);
i++;
}
free(ports_out);
}
}
std::vector<String> AudioOutputDeviceJack::AudioChannelJack::ParameterJackBindings::PossibilitiesAsString() {
const char** pPortNames = jack_get_ports(pChannel->pDevice->hJackClient, NULL, NULL, JackPortIsInput);
if (!pPortNames) return std::vector<String>();
std::vector<String> result;
for (int i = 0; pPortNames[i]; i++) result.push_back(pPortNames[i]);
//free(pPortNames); FIXME: pPortNames should be freed here
return result;
}
// return 0: ok
// return 1: cannot activate client
// return 2: cannot connect output port
// return 3: Jack server not running
// return 4: output port = NULL
int JackOutput::connect()
{
INFOLOG( "connect" );
if ( jack_activate ( client ) ) {
Hydrogen::get_instance()->raiseError( Hydrogen::JACK_CANNOT_ACTIVATE_CLIENT );
return 1;
}
bool connect_output_ports = m_bConnectOutFlag;
memset( track_output_ports_L, 0, sizeof(track_output_ports_L) );
memset( track_output_ports_R, 0, sizeof(track_output_ports_R) );
#ifdef H2CORE_HAVE_LASH
if ( Preferences::get_instance()->useLash() ){
LashClient* lashClient = LashClient::get_instance();
if (lashClient && lashClient->isConnected())
{
// infoLog("[LASH] Sending Jack client name to LASH server");
lashClient->sendJackClientName();
if (!lashClient->isNewProject())
{
connect_output_ports = false;
}
}
}
#endif
if ( connect_output_ports ) {
// if ( m_bConnectOutFlag ) {
// connect the ports
if ( jack_connect( client, jack_port_name( output_port_1 ), output_port_name_1.toLocal8Bit() ) == 0 &&
jack_connect ( client, jack_port_name( output_port_2 ), output_port_name_2.toLocal8Bit() ) == 0 ) {
return 0;
}
INFOLOG( "Could not connect so saved out-ports. Connecting to first pair of in-ports" );
const char ** portnames = jack_get_ports ( client, NULL, NULL, JackPortIsInput );
if ( !portnames || !portnames[0] || !portnames[1] ) {
ERRORLOG( "Could't locate two Jack input port" );
Hydrogen::get_instance()->raiseError( Hydrogen::JACK_CANNOT_CONNECT_OUTPUT_PORT );
return 2;
}
if ( jack_connect( client, jack_port_name( output_port_1 ), portnames[0] ) != 0 ||
jack_connect( client, jack_port_name( output_port_2 ), portnames[1] ) != 0 ) {
ERRORLOG( "Could't connect to first pair of Jack input ports" );
Hydrogen::get_instance()->raiseError( Hydrogen::JACK_CANNOT_CONNECT_OUTPUT_PORT );
return 2;
}
free( portnames );
}
return 0;
}
static GstCaps *
gst_jack_audio_src_getcaps (GstBaseSrc * bsrc)
{
GstJackAudioSrc *src = GST_JACK_AUDIO_SRC (bsrc);
const char **ports;
gint min, max;
gint rate;
jack_client_t *client;
if (src->client == NULL)
goto no_client;
client = gst_jack_audio_client_get_client (src->client);
if (src->connect == GST_JACK_CONNECT_AUTO) {
/* get a port count, this is the number of channels we can automatically
* connect. */
ports = jack_get_ports (client, NULL, NULL,
JackPortIsPhysical | JackPortIsOutput);
max = 0;
if (ports != NULL) {
for (; ports[max]; max++);
free (ports);
} else
max = 0;
} else {
/* we allow any number of pads, something else is going to connect the
* pads. */
max = G_MAXINT;
}
min = MIN (1, max);
rate = jack_get_sample_rate (client);
GST_DEBUG_OBJECT (src, "got %d-%d ports, samplerate: %d", min, max, rate);
if (!src->caps) {
src->caps = gst_caps_new_simple ("audio/x-raw-float",
"endianness", G_TYPE_INT, G_BYTE_ORDER,
"width", G_TYPE_INT, 32,
"rate", G_TYPE_INT, rate,
"channels", GST_TYPE_INT_RANGE, min, max, NULL);
}
GST_INFO_OBJECT (src, "returning caps %" GST_PTR_FORMAT, src->caps);
return gst_caps_ref (src->caps);
/* ERRORS */
no_client:
{
GST_DEBUG_OBJECT (src, "device not open, using template caps");
/* base class will get template caps for us when we return NULL */
return NULL;
}
}
int JackProxyDriver::CountIO(const char* type, int flags)
{
int count = 0;
const char** ports = jack_get_ports(fClient, NULL, type, flags);
if (ports != NULL) {
while (ports[count]) { count++; }
jack_free(ports);
}
return count;
}
void JackProxyDriver::ConnectPorts()
{
jack_log("JackProxyDriver::ConnectPorts");
const char** ports = jack_get_ports(fClient, NULL, JACK_DEFAULT_AUDIO_TYPE, JackPortIsPhysical | JackPortIsOutput);
if (ports != NULL) {
for (int i = 0; i < fCaptureChannels && ports[i]; i++) {
jack_connect(fClient, ports[i], jack_port_name(fUpstreamPlaybackPorts[i]));
}
jack_free(ports);
}
ports = jack_get_ports(fClient, NULL, JACK_DEFAULT_AUDIO_TYPE, JackPortIsPhysical | JackPortIsInput);
if (ports != NULL) {
for (int i = 0; i < fPlaybackChannels && ports[i]; i++) {
jack_connect(fClient, jack_port_name(fUpstreamCapturePorts[i]), ports[i]);
}
jack_free(ports);
}
}
static void connect_to_outports(jack_client_t *client) {
const char **ports;
ports = jack_get_ports(client, NULL, NULL, JackPortIsPhysical | JackPortIsInput);
if( ports != NULL ) {
jack_connect(client, jack_port_name(outport_l), ports[0]);
jack_connect(client, jack_port_name(outport_r), ports[1]);
}
free(ports);
}
unsigned int JackCpp::AudioIO::numPhysicalDestinationPorts(){
const char **ports;
unsigned int cnt = 0;
ports = jack_get_ports (mJackClient, NULL, NULL, JackPortIsPhysical|JackPortIsInput);
if (ports != NULL){
while(ports[cnt] != NULL)
cnt++;
free(ports);
return cnt;
} else
return 0;
}
void jack_start() {
jack_set_error_function(error);
client = jack_client_open("MicToMIDI", JackNullOption, NULL);
if (client == 0) {
fprintf(stderr, "jack server not running?\n");
exit(1);
}
jack_set_process_callback(client, process, 0);
jack_set_sample_rate_callback(client, sample_rate, 0);
jack_on_shutdown(client, jack_shutdown, 0);
input_port = jack_port_register(client, "input", JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0);
output_port = jack_port_register(client, "output", JACK_DEFAULT_MIDI_TYPE, JackPortIsOutput, 0);
if(jack_activate(client)) {
fprintf(stderr, "cannot activate client");
exit(1);
}
atexit(jack_stop);
const char **ports;
if((ports = jack_get_ports(client, NULL, NULL, JackPortIsPhysical | JackPortIsOutput)) == NULL)
{
fprintf(stderr, "cannot find any physical capture ports\n");
exit(1);
}
if(jack_connect(client, ports[0], jack_port_name(input_port)))
fprintf(stderr, "cannot connect to physical capture port\n");
jack_free(ports);
if((ports = jack_get_ports(client, NULL, "midi", JackPortIsInput)) == NULL)
{
fprintf(stderr, "cannot find any MIDI playback ports\n");
exit(1);
}
if(jack_connect(client, jack_port_name(output_port), ports[0]))
fprintf(stderr, "cannot connect to MIDI playback port\n");
}
int listDevices(CSOUND *csound, CS_AUDIODEVICE *list, int isOutput){
char **portNames = (char**) NULL, port[64];
unsigned long portFlags;
int i, n, cnt=0;
jack_client_t *jackClient;
RtJackGlobals* p =
(RtJackGlobals*) csound->QueryGlobalVariableNoCheck(csound,
"_rtjackGlobals");
if(p->listclient == NULL)
p->listclient = jack_client_open("list", JackNoStartServer, NULL);
jackClient = p->listclient;
if(jackClient == NULL) return 0;
portFlags = (isOutput ? (unsigned long) JackPortIsInput
: (unsigned long) JackPortIsOutput);
portNames = (char**) jack_get_ports(jackClient,
(char*) NULL,
JACK_DEFAULT_AUDIO_TYPE,
portFlags);
if(portNames == NULL) {
jack_client_close(jackClient);
p->listclient = NULL;
return 0;
}
memset(port, '\0', 64);
for(i=0; portNames[i] != NULL; i++) {
n = (int) strlen(portNames[i]);
do {
n--;
} while (n > 0 && isdigit(portNames[i][n]));
n++;
if(strncmp(portNames[i], port, n)==0) continue;
strncpy(port, portNames[i], n);
port[n] = '\0';
if (list != NULL) {
strncpy(list[cnt].device_name, port, 63);
snprintf(list[cnt].device_id, 63, "%s%s",
isOutput ? "dac:" : "adc:",port);
list[cnt].max_nchnls = -1;
list[cnt].isOutput = isOutput;
}
cnt++;
}
jack_client_close(jackClient);
p->listclient = NULL;
return cnt;
}
unsigned int JackCpp::AudioIO::numPhysicalSourcePorts(){
const char **ports;
unsigned int cnt = 0;
//XXX is this really correct? we should get the naming right...
ports = jack_get_ports (mJackClient, NULL, NULL, JackPortIsPhysical|JackPortIsOutput);
if (ports != NULL){
while(ports[cnt] != NULL)
cnt++;
free(ports);
return cnt;
} else
return 0;
}
int main(int argc, char *argv[]) {
jack_client_t *client;
const char **ports;
const char* name = (argc>1) ? argv[1] : "StereoDecoder";
char s[63];
int i;
if ((client = jack_client_open(name, JackNullOption, NULL)) == 0) {
fprintf(stderr, "jack server not running?\n");
return 1;
}
jack_set_process_callback(client, process, 0);
jack_on_shutdown(client, jack_shutdown, 0);
for(i=0; i<INPORTS; i++) {
sprintf(s, "input_%d", i);
input_ports[i] = jack_port_register(client, s,
JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0);
}
for(i=0; i<OUTPORTS; i++) {
sprintf(s, "output_%d", i);
output_ports[i] = jack_port_register(client, s,
JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0);
}
if (jack_activate(client)) {
fprintf(stderr, "cannot activate client");
return 1;
}
if ((ports = jack_get_ports(client, NULL, NULL, JackPortIsPhysical|JackPortIsInput)) == NULL) {
fprintf(stderr, "Cannot find any physical playback ports\n");
return 1;
}
for(i=0; i<OUTPORTS; i++) {
if (ports[i]==NULL ||
jack_connect(client, jack_port_name(output_ports[i]), ports[i])) {
fprintf(stderr, "cannot connect output ports\n");
}
}
free(ports);
while (1) {
sleep(10);
}
}
static void connect_jack_ports() {
int i;
int c=0;
for (i = 0; i < AUDIO_CHANNELS; i++) {
if (!jack_port[i]) continue;
if (jack_connect(j_client, jack_port_name(j_output_port[i]), jack_port[i] )) {
fprintf(stderr, "cannot connect port %s to %s\n", jack_port_name(j_output_port[i]), jack_port[i]);
}
c++;
}
if (c==0 && jack_ports && strlen(jack_ports)>0) {
/* all of jack_port[] were NULL, try regexp */
const char **found_ports = jack_get_ports(j_client, jack_ports, JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput);
if (found_ports) {
for (i = 0; found_ports[i] && i < AUDIO_CHANNELS; ++i) {
if (jack_connect(j_client, jack_port_name(j_output_port[i]), found_ports[i])) {
fprintf(stderr, "JACK: cannot connect port %s to %s\n", jack_port_name(j_output_port[i]), found_ports[i]);
}
}
jack_free(found_ports);
}
}
/* Midi Port */
if (use_jack_midi && midi_port && strlen(midi_port)>0) {
const char **found_ports = jack_get_ports(j_client, midi_port, JACK_DEFAULT_MIDI_TYPE, JackPortIsOutput);
if (found_ports) {
for (i = 0; found_ports[i]; ++i) {
if (jack_connect(j_client, found_ports[i], jack_port_name(jack_midi_port))) {
fprintf(stderr, "JACK: cannot connect port %s to %s\n", found_ports[i], jack_port_name(jack_midi_port));
}
}
jack_free(found_ports);
}
}
}
