Commit ae9a0281 authored by sletz's avatar sletz
Browse files

Tagging the 0.58 release of the 'jackmp' project.

git-svn-id: http://subversion.jackaudio.org/jack/jack2/tags/release-0.58@1229 0c269be4-1314-0410-8aa9-9f06e86f4224
parents 6dd5decc 46ab6341
---------------------------
Jackdmp changes log
---------------------------
---------------------------
2006-09-06 Stephane Letz <letz@grame.fr>
* Correct coreaudio driver (input was not working since 0.55 version).
2006-09-04 Stephane Letz <letz@grame.fr>
......
---------------------------
Jackdmp changes log
---------------------------
2006-09-06 Stephane Letz <letz@grame.fr>
* Correct coreaudio driver (input was not working since 0.55 version).
2006-09-04 Stephane Letz <letz@grame.fr>
* Correct Windows VC++ projects.
2006-09-03 Stephane Letz <letz@grame.fr>
* First import of version 0.58 code
/*
Copyright (C) 2001-2003 Paul Davis
Copyright (C) 2004-2006 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 "JackClient.h"
#include "JackError.h"
#include "JackGraphManager.h"
#include "JackEngineControl.h"
#include "JackClientControl.h"
#include "JackGlobals.h"
#include "JackTime.h"
#include "JackExports.h"
#include <math.h>
using namespace Jack;
#ifdef __cplusplus
extern "C"
{
#endif
EXPORT int jack_client_name_size (void);
EXPORT char* jack_get_client_name (jack_client_t *client);
EXPORT int jack_internal_client_new (const char *client_name,
const char *load_name,
const char *load_init);
EXPORT jack_client_t* my_jack_internal_client_new(const char* client_name);
EXPORT void jack_internal_client_close (const char *client_name);
EXPORT void my_jack_internal_client_close (jack_client_t* client);
EXPORT int jack_is_realtime (jack_client_t *client);
EXPORT void jack_on_shutdown (jack_client_t *client,
void (*function)(void *arg), void *arg);
EXPORT int jack_set_process_callback (jack_client_t *client,
JackProcessCallback process_callback,
void *arg);
EXPORT int jack_set_thread_init_callback (jack_client_t *client,
JackThreadInitCallback thread_init_callback,
void *arg);
EXPORT int jack_set_freewheel_callback (jack_client_t *client,
JackFreewheelCallback freewheel_callback,
void *arg);
EXPORT int jack_set_freewheel(jack_client_t* client, int onoff);
EXPORT int jack_set_buffer_size (jack_client_t *client, jack_nframes_t nframes);
EXPORT int jack_set_buffer_size_callback (jack_client_t *client,
JackBufferSizeCallback bufsize_callback,
void *arg);
EXPORT int jack_set_sample_rate_callback (jack_client_t *client,
JackSampleRateCallback srate_callback,
void *arg);
EXPORT int jack_set_port_registration_callback (jack_client_t *,
JackPortRegistrationCallback
registration_callback, void *arg);
EXPORT int jack_set_graph_order_callback (jack_client_t *,
JackGraphOrderCallback graph_callback,
void *);
EXPORT int jack_set_xrun_callback (jack_client_t *,
JackXRunCallback xrun_callback, void *arg);
EXPORT int jack_activate (jack_client_t *client);
EXPORT int jack_deactivate (jack_client_t *client);
EXPORT jack_port_t * jack_port_register (jack_client_t *client,
const char *port_name,
const char *port_type,
unsigned long flags,
unsigned long buffer_size);
EXPORT int jack_port_unregister (jack_client_t *, jack_port_t *);
EXPORT void * jack_port_get_buffer (jack_port_t *, jack_nframes_t);
EXPORT const char * jack_port_name (const jack_port_t *port);
EXPORT const char * jack_port_short_name (const jack_port_t *port);
EXPORT int jack_port_flags (const jack_port_t *port);
EXPORT const char * jack_port_type (const jack_port_t *port);
EXPORT int jack_port_is_mine (const jack_client_t *, const jack_port_t *port);
EXPORT int jack_port_connected (const jack_port_t *port);
EXPORT int jack_port_connected_to (const jack_port_t *port,
const char *port_name);
EXPORT const char ** jack_port_get_connections (const jack_port_t *port);
EXPORT const char ** jack_port_get_all_connections (const jack_client_t *client,
const jack_port_t *port);
EXPORT int jack_port_tie (jack_port_t *src, jack_port_t *dst);
EXPORT int jack_port_untie (jack_port_t *port);
EXPORT int jack_port_lock (jack_client_t *, jack_port_t *);
EXPORT int jack_port_unlock (jack_client_t *, jack_port_t *);
EXPORT jack_nframes_t jack_port_get_latency (jack_port_t *port);
EXPORT jack_nframes_t jack_port_get_total_latency (jack_client_t *,
jack_port_t *port);
EXPORT void jack_port_set_latency (jack_port_t *, jack_nframes_t);
EXPORT int jack_recompute_total_latencies (jack_client_t*);
EXPORT int jack_port_set_name (jack_port_t *port, const char *port_name);
EXPORT int jack_port_request_monitor (jack_port_t *port, int onoff);
EXPORT int jack_port_request_monitor_by_name (jack_client_t *client,
const char *port_name, int onoff);
EXPORT int jack_port_ensure_monitor (jack_port_t *port, int onoff);
EXPORT int jack_port_monitoring_input (jack_port_t *port);
EXPORT int jack_connect (jack_client_t *,
const char *source_port,
const char *destination_port);
EXPORT int jack_disconnect (jack_client_t *,
const char *source_port,
const char *destination_port);
EXPORT int jack_port_disconnect (jack_client_t *, jack_port_t *);
EXPORT int jack_port_name_size(void);
EXPORT int jack_port_type_size(void);
EXPORT jack_nframes_t jack_get_sample_rate (jack_client_t *);
EXPORT jack_nframes_t jack_get_buffer_size (jack_client_t *);
EXPORT const char ** jack_get_ports (jack_client_t *,
const char *port_name_pattern,
const char *type_name_pattern,
unsigned long flags);
EXPORT jack_port_t * jack_port_by_name (jack_client_t *, const char *port_name);
EXPORT jack_port_t * jack_port_by_id (jack_client_t *client,
jack_port_id_t port_id);
EXPORT int jack_engine_takeover_timebase (jack_client_t *);
EXPORT jack_nframes_t jack_frames_since_cycle_start (const jack_client_t *);
EXPORT jack_nframes_t jack_frame_time (const jack_client_t *);
EXPORT jack_nframes_t jack_last_frame_time (const jack_client_t *client);
EXPORT float jack_cpu_load (jack_client_t *client);
EXPORT pthread_t jack_client_thread_id (jack_client_t *);
EXPORT void jack_set_error_function (void (*func)(const char *));
EXPORT float jack_get_max_delayed_usecs (jack_client_t *client);
EXPORT float jack_get_xrun_delayed_usecs (jack_client_t *client);
EXPORT void jack_reset_max_delayed_usecs (jack_client_t *client);
EXPORT int jack_release_timebase (jack_client_t *client);
EXPORT int jack_set_sync_callback (jack_client_t *client,
JackSyncCallback sync_callback,
void *arg);
EXPORT int jack_set_sync_timeout (jack_client_t *client,
jack_time_t timeout);
EXPORT int jack_set_timebase_callback (jack_client_t *client,
int conditional,
JackTimebaseCallback timebase_callback,
void *arg);
EXPORT int jack_transport_locate (jack_client_t *client,
jack_nframes_t frame);
EXPORT jack_transport_state_t jack_transport_query (const jack_client_t *client,
jack_position_t *pos);
EXPORT jack_nframes_t jack_get_current_transport_frame (const jack_client_t *client);
EXPORT int jack_transport_reposition (jack_client_t *client,
jack_position_t *pos);
EXPORT void jack_transport_start (jack_client_t *client);
EXPORT void jack_transport_stop (jack_client_t *client);
EXPORT void jack_get_transport_info (jack_client_t *client,
jack_transport_info_t *tinfo);
EXPORT void jack_set_transport_info (jack_client_t *client,
jack_transport_info_t *tinfo);
EXPORT int jack_acquire_real_time_scheduling (pthread_t thread, int priority);
EXPORT int jack_client_create_thread (jack_client_t* client,
pthread_t *thread,
int priority,
int realtime, // boolean
void *(*start_routine)(void*),
void *arg);
EXPORT int jack_drop_real_time_scheduling (pthread_t thread);
EXPORT char * jack_get_internal_client_name (jack_client_t *client,
jack_intclient_t intclient);
EXPORT jack_intclient_t jack_internal_client_handle (jack_client_t *client,
const char *client_name,
jack_status_t *status);
EXPORT jack_intclient_t jack_internal_client_load (jack_client_t *client,
const char *client_name,
jack_options_t options,
jack_status_t *status, ...);
EXPORT jack_status_t jack_internal_client_unload (jack_client_t *client,
jack_intclient_t intclient);
#ifdef __cplusplus
}
#endif
#ifdef WIN32
/* missing on Windows : see http://bugs.mysql.com/bug.php?id=15936 */
inline double rint(double nr)
{
double f = floor(nr);
double c = ceil(nr);
return (((c -nr) >= (nr - f)) ? f : c);
}
#endif
static inline bool CheckPort(jack_port_id_t port_index)
{
return (port_index < PORT_NUM);
}
static inline void WaitGraphChange()
{
if (GetGraphManager()->IsPendingChange()) {
JackLog("WaitGraphChange...\n");
JackSleep(GetEngineControl()->fPeriodUsecs * 2);
}
}
static void default_jack_error_callback (const char *desc)
{
fprintf(stderr, "%s\n", desc);
}
void (*jack_error_callback)(const char *desc) = &default_jack_error_callback;
EXPORT void jack_set_error_function (void (*func)(const char *))
{
jack_error_callback = func;
}
EXPORT void* jack_port_get_buffer(jack_port_t* port, jack_nframes_t frames)
{
jack_port_id_t myport = (jack_port_id_t)port;
if (!CheckPort(myport)) {
jack_error("jack_port_get_buffer called with an incorrect port %ld", myport);
return NULL;
} else {
return GetGraphManager()->GetBuffer(myport, frames);
}
}
EXPORT const char* jack_port_name(const jack_port_t* port)
{
jack_port_id_t myport = (jack_port_id_t)port;
if (!CheckPort(myport)) {
jack_error("jack_port_name called with an incorrect port %ld", myport);
return NULL;
} else {
return GetGraphManager()->GetPort(myport)->GetName();
}
}
EXPORT const char* jack_port_short_name(const jack_port_t* port)
{
jack_port_id_t myport = (jack_port_id_t)port;
if (!CheckPort(myport)) {
jack_error("jack_port_short_name called with an incorrect port %ld", myport);
return NULL;
} else {
return GetGraphManager()->GetPort(myport)->GetShortName();
}
}
EXPORT int jack_port_flags(const jack_port_t* port)
{
jack_port_id_t myport = (jack_port_id_t)port;
if (!CheckPort(myport)) {
jack_error("jack_port_flags called with an incorrect port %ld", myport);
return -1;
} else {
return GetGraphManager()->GetPort(myport)->Flags();
}
}
EXPORT const char* jack_port_type(const jack_port_t* port)
{
jack_port_id_t myport = (jack_port_id_t)port;
if (!CheckPort(myport)) {
jack_error("jack_port_flags called an incorrect port %ld", myport);
return NULL;
} else {
return GetGraphManager()->GetPort(myport)->Type();
}
}
EXPORT int jack_port_connected(const jack_port_t* port)
{
jack_port_id_t myport = (jack_port_id_t)port;
if (!CheckPort(myport)) {
jack_error("jack_port_connected called with an incorrect port %ld", myport);
return -1;
} else {
WaitGraphChange();
return GetGraphManager()->GetConnectionsNum(myport);
}
}
EXPORT int jack_port_connected_to(const jack_port_t* port, const char* portname)
{
jack_port_id_t myport = (jack_port_id_t)port;
if (!CheckPort(myport)) {
jack_error("jack_port_connected_to called with an incorrect port %ld", myport);
return -1;
} else if (portname == NULL) {
jack_error("jack_port_connected_to called with a NULL port name");
return -1;
} else {
WaitGraphChange();
return GetGraphManager()->ConnectedTo(myport, portname);
}
}
EXPORT int jack_port_tie(jack_port_t* src, jack_port_t* dst)
{
jack_port_id_t mysrc = (jack_port_id_t)src;
if (!CheckPort(mysrc)) {
jack_error("jack_port_tie called with a NULL src port");
return -1;
}
jack_port_id_t mydst = (jack_port_id_t)dst;
if (!CheckPort(mydst)) {
jack_error("jack_port_tie called with a NULL dst port");
return -1;
}
if (GetGraphManager()->GetPort(mysrc)->GetRefNum() != GetGraphManager()->GetPort(mydst)->GetRefNum()) {
jack_error("jack_port_tie called with ports not belonging to the same client");
return -1;
}
return GetGraphManager()->GetPort(mydst)->Tie(mysrc);
}
EXPORT int jack_port_untie(jack_port_t* port)
{
jack_port_id_t myport = (jack_port_id_t)port;
if (!CheckPort(myport)) {
jack_error("jack_port_untie called with an incorrect port %ld", myport);
return -1;
} else {
return GetGraphManager()->GetPort(myport)->UnTie();
}
}
EXPORT jack_nframes_t jack_port_get_latency(jack_port_t* port)
{
jack_port_id_t myport = (jack_port_id_t)port;
if (!CheckPort(myport)) {
jack_error("jack_port_get_latency called with an incorrect port %ld", myport);
return 0;
} else {
WaitGraphChange();
return GetGraphManager()->GetPort(myport)->GetLatency();
}
}
EXPORT void jack_port_set_latency(jack_port_t* port, jack_nframes_t frames)
{
jack_port_id_t myport = (jack_port_id_t)port;
if (!CheckPort(myport)) {
jack_error("jack_port_set_latency called with an incorrect port %ld", myport);
} else {
GetGraphManager()->GetPort(myport)->SetLatency(frames);
}
}
EXPORT int jack_recompute_total_latencies(jack_client_t* ext_client)
{
// The latency computation is done each time jack_port_get_total_latency is called
return 0;
}
EXPORT int jack_port_set_name(jack_port_t* port, const char* name)
{
jack_port_id_t myport = (jack_port_id_t)port;
if (!CheckPort(myport)) {
jack_error("jack_port_set_name called with an incorrect port %ld", myport);
return -1;
} else if (name == NULL) {
jack_error("jack_port_set_name called with a NULL port name");
return -1;
} else {
return GetGraphManager()->GetPort(myport)->SetName(name);
}
}
EXPORT int jack_port_request_monitor(jack_port_t* port, int onoff)
{
jack_port_id_t myport = (jack_port_id_t)port;
if (!CheckPort(myport)) {
jack_error("jack_port_request_monitor called with an incorrect port %ld", myport);
return -1;
} else {
return GetGraphManager()->RequestMonitor(myport, onoff);
}
}
EXPORT int jack_port_request_monitor_by_name(jack_client_t* ext_client, const char* port_name, int onoff)
{
JackClient* client = (JackClient*)ext_client;
if (client == NULL) {
jack_error("jack_port_request_monitor_by_name called with a NULL client");
return -1;
} else {
jack_port_id_t myport = GetGraphManager()->GetPort(port_name);
if (!CheckPort(myport)) {
jack_error("jack_port_request_monitor_by_name called with an incorrect port %s", port_name);
return -1;
} else {
return GetGraphManager()->RequestMonitor(myport, onoff);
}
}
}
EXPORT int jack_port_ensure_monitor(jack_port_t* port, int onoff)
{
jack_port_id_t myport = (jack_port_id_t)port;
if (!CheckPort(myport)) {
jack_error("jack_port_ensure_monitor called with an incorrect port %ld", myport);
return -1;
} else {
return GetGraphManager()->GetPort(myport)->EnsureMonitor(onoff);
}
}
EXPORT int jack_port_monitoring_input(jack_port_t* port)
{
jack_port_id_t myport = (jack_port_id_t)port;
if (!CheckPort(myport)) {
jack_error("jack_port_monitoring_input called with an incorrect port %ld", myport);
return -1;
} else {
return GetGraphManager()->GetPort(myport)->MonitoringInput();
}
}
EXPORT int jack_is_realtime(jack_client_t* ext_client)
{
JackClient* client = (JackClient*)ext_client;
if (client == NULL) {
jack_error("jack_is_realtime called with a NULL client");
return -1;
} else {
return GetEngineControl()->fRealTime;
}
}
EXPORT void jack_on_shutdown(jack_client_t* ext_client, void (*function)(void* arg), void* arg)
{
JackClient* client = (JackClient*)ext_client;
if (client == NULL) {
jack_error("jack_on_shutdown called with a NULL client");
} else {
client->OnShutdown(function, arg);
}
}
EXPORT int jack_set_process_callback(jack_client_t* ext_client, JackProcessCallback callback, void* arg)
{
JackClient* client = (JackClient*)ext_client;
if (client == NULL) {
jack_error("jack_set_process_callback called with a NULL client");
return -1;
} else {
return client->SetProcessCallback(callback, arg);
}
}
EXPORT int jack_set_freewheel_callback(jack_client_t* ext_client, JackFreewheelCallback freewheel_callback, void* arg)
{
JackClient* client = (JackClient*)ext_client;
if (client == NULL) {
jack_error("jack_set_freewheel_callback called with a NULL client");
return -1;
} else {
return client->SetFreewheelCallback(freewheel_callback, arg);
}
}
EXPORT int jack_set_freewheel(jack_client_t* ext_client, int onoff)
{
JackClient* client = (JackClient*)ext_client;
if (client == NULL) {
jack_error("jack_set_freewheel called with a NULL client");
return -1;
} else {
return client->SetFreeWheel(onoff);
}
}
EXPORT int jack_set_buffer_size(jack_client_t* ext_client, jack_nframes_t nframes)
{
JackClient* client = (JackClient*)ext_client;
if (client == NULL) {
jack_error("jack_set_buffer_size called with a NULL client");
return -1;
} else {
return client->SetBufferSize(nframes);
}
}
EXPORT int jack_set_buffer_size_callback(jack_client_t* ext_client, JackBufferSizeCallback bufsize_callback, void* arg)
{
JackClient* client = (JackClient*)ext_client;
if (client == NULL) {
jack_error("jack_set_buffer_size_callback called with a NULL client");
return -1;
} else {
return client->SetBufferSizeCallback(bufsize_callback, arg);
}
}
EXPORT int jack_set_sample_rate_callback(jack_client_t* ext_client, JackSampleRateCallback srate_callback, void* arg)
{
JackClient* client = (JackClient*)ext_client;
JackLog("jack_set_sample_rate_callback ext_client %x client %x \n", ext_client, client);
if (client == NULL) {
jack_error("jack_set_sample_rate_callback called with a NULL client");
return -1;
} else {
JackLog("jack_set_sample_rate_callback: deprecated\n");
return -1;
}
}
EXPORT int jack_set_port_registration_callback(jack_client_t* ext_client, JackPortRegistrationCallback registration_callback, void* arg)
{
JackClient* client = (JackClient*)ext_client;
if (client == NULL) {
jack_error("jack_set_port_registration_callback called with a NULL client");
return -1;
} else {
return client->SetPortRegistrationCallback(registration_callback, arg);
}
}
EXPORT int jack_set_graph_order_callback(jack_client_t* ext_client, JackGraphOrderCallback graph_callback, void* arg)
{
JackClient* client = (JackClient*)ext_client;
JackLog("jack_set_graph_order_callback ext_client %x client %x \n", ext_client, client);
if (client == NULL) {
jack_error("jack_set_graph_order_callback called with a NULL client");
return -1;
} else {
return client->SetGraphOrderCallback(graph_callback, arg);
}
}
EXPORT int jack_set_xrun_callback(jack_client_t* ext_client, JackXRunCallback callback, void* arg)
{
JackClient* client = (JackClient*)ext_client;
if (client == NULL) {
jack_error("jack_set_xrun_callback called with a NULL client");
return -1;
} else {
return client->SetXRunCallback(callback, arg);
}
}
EXPORT int jack_set_thread_init_callback(jack_client_t* ext_client, JackThreadInitCallback callback, void *arg)
{
JackClient* client = (JackClient*)ext_client;
JackLog("jack_set_thread_init_callback ext_client %x client %x \n", ext_client, client);
if (client == NULL) {
jack_error("jack_set_thread_init_callback called with a NULL client");
return -1;
} else {
return client->SetInitCallback(callback, arg);
}
}
EXPORT int jack_activate(jack_client_t* ext_client)
{
JackClient* client = (JackClient*)ext_client;
if (client == NULL) {
jack_error("jack_activate called with a NULL client");
return -1;
} else {
return client->Activate();
}
}
EXPORT int jack_deactivate(jack_client_t* ext_client)
{
JackClient* client = (JackClient*)ext_client;
if (client == NULL) {