jackaudio
/
jack2
mirror of https://github.com/jackaudio/jack2
1
0
Fork 0
Code Releases 45 Activity
Browse Source

More client debug code: check if the client is still valid in every JackDebugClient method, check if the library context is still valid in every API call. 

git-svn-id: http://subversion.jackaudio.org/jack/jack2/trunk/jackmp@1358 0c269be4-1314-0410-8aa9-9f06e86f4224
tags/0.62
sletz 18 years ago
parent
145b67bb0b
commit
e9269c34bf
5 changed files with 314 additions and 55 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +4
    -0
      ChangeLog
  2. +205
    -0
      common/JackAPI.cpp
  3. +96
    -54
      common/JackDebugClient.cpp
  4. +3
    -1
      common/JackDebugClient.h
  5. +6
    -0
      common/JackLibGlobals.h

+ 4
- 0
ChangeLog View File

@@ -2,6 +2,10 @@
Jackdmp changes log
---------------------------

2007-01-21 Stephane Letz <letz@grame.fr>

* More client debug code: check if the client is still valid in every JackDebugClient method, check if the library context is still valid in every API call.

2007-01-14 Stephane Letz <letz@grame.fr>

* Implement thread.h API.


+ 205
- 0
common/JackAPI.cpp View File

@@ -35,6 +35,10 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
#endif
#include <math.h>

#ifdef __CLIENTDEBUG__
#include "JackLibGlobals.h"
#endif

using namespace Jack;

#ifdef __cplusplus
@@ -234,6 +238,9 @@ EXPORT void jack_set_error_function (void (*func)(const char *))

EXPORT void* jack_port_get_buffer(jack_port_t* port, jack_nframes_t frames)
{
#ifdef __CLIENTDEBUG__
JackLibGlobals::CheckContext();
#endif
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);
@@ -245,6 +252,9 @@ EXPORT void* jack_port_get_buffer(jack_port_t* port, jack_nframes_t frames)

EXPORT const char* jack_port_name(const jack_port_t* port)
{
#ifdef __CLIENTDEBUG__
JackLibGlobals::CheckContext();
#endif
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);
@@ -256,6 +266,9 @@ EXPORT const char* jack_port_name(const jack_port_t* port)

EXPORT const char* jack_port_short_name(const jack_port_t* port)
{
#ifdef __CLIENTDEBUG__
JackLibGlobals::CheckContext();
#endif
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);
@@ -267,6 +280,9 @@ EXPORT const char* jack_port_short_name(const jack_port_t* port)

EXPORT int jack_port_flags(const jack_port_t* port)
{
#ifdef __CLIENTDEBUG__
JackLibGlobals::CheckContext();
#endif
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);
@@ -278,6 +294,9 @@ EXPORT int jack_port_flags(const jack_port_t* port)

EXPORT const char* jack_port_type(const jack_port_t* port)
{
#ifdef __CLIENTDEBUG__
JackLibGlobals::CheckContext();
#endif
jack_port_id_t myport = (jack_port_id_t)port;
if (!CheckPort(myport)) {
jack_error("jack_port_flags called an incorrect port %ld", myport);
@@ -289,6 +308,9 @@ EXPORT const char* jack_port_type(const jack_port_t* port)

EXPORT int jack_port_connected(const jack_port_t* port)
{
#ifdef __CLIENTDEBUG__
JackLibGlobals::CheckContext();
#endif
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);
@@ -301,6 +323,9 @@ EXPORT int jack_port_connected(const jack_port_t* port)

EXPORT int jack_port_connected_to(const jack_port_t* port, const char* portname)
{
#ifdef __CLIENTDEBUG__
JackLibGlobals::CheckContext();
#endif
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);
@@ -316,6 +341,9 @@ EXPORT int jack_port_connected_to(const jack_port_t* port, const char* portname)

EXPORT int jack_port_tie(jack_port_t* src, jack_port_t* dst)
{
#ifdef __CLIENTDEBUG__
JackLibGlobals::CheckContext();
#endif
jack_port_id_t mysrc = (jack_port_id_t)src;
if (!CheckPort(mysrc)) {
jack_error("jack_port_tie called with a NULL src port");
@@ -335,6 +363,9 @@ EXPORT int jack_port_tie(jack_port_t* src, jack_port_t* dst)

EXPORT int jack_port_untie(jack_port_t* port)
{
#ifdef __CLIENTDEBUG__
JackLibGlobals::CheckContext();
#endif
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);
@@ -346,6 +377,9 @@ EXPORT int jack_port_untie(jack_port_t* port)

EXPORT jack_nframes_t jack_port_get_latency(jack_port_t* port)
{
#ifdef __CLIENTDEBUG__
JackLibGlobals::CheckContext();
#endif
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);
@@ -358,6 +392,9 @@ EXPORT jack_nframes_t jack_port_get_latency(jack_port_t* port)

EXPORT void jack_port_set_latency(jack_port_t* port, jack_nframes_t frames)
{
#ifdef __CLIENTDEBUG__
JackLibGlobals::CheckContext();
#endif
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);
@@ -374,6 +411,9 @@ EXPORT int jack_recompute_total_latencies(jack_client_t* ext_client)

EXPORT int jack_port_set_name(jack_port_t* port, const char* name)
{
#ifdef __CLIENTDEBUG__
JackLibGlobals::CheckContext();
#endif
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);
@@ -388,6 +428,9 @@ EXPORT int jack_port_set_name(jack_port_t* port, const char* name)

EXPORT int jack_port_request_monitor(jack_port_t* port, int onoff)
{
#ifdef __CLIENTDEBUG__
JackLibGlobals::CheckContext();
#endif
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);
@@ -399,6 +442,9 @@ EXPORT int jack_port_request_monitor(jack_port_t* port, int onoff)

EXPORT int jack_port_request_monitor_by_name(jack_client_t* ext_client, const char* port_name, int onoff)
{
#ifdef __CLIENTDEBUG__
JackLibGlobals::CheckContext();
#endif
JackClient* client = (JackClient*)ext_client;
if (client == NULL) {
jack_error("jack_port_request_monitor_by_name called with a NULL client");
@@ -416,6 +462,9 @@ EXPORT int jack_port_request_monitor_by_name(jack_client_t* ext_client, const ch

EXPORT int jack_port_ensure_monitor(jack_port_t* port, int onoff)
{
#ifdef __CLIENTDEBUG__
JackLibGlobals::CheckContext();
#endif
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);
@@ -427,6 +476,9 @@ EXPORT int jack_port_ensure_monitor(jack_port_t* port, int onoff)

EXPORT int jack_port_monitoring_input(jack_port_t* port)
{
#ifdef __CLIENTDEBUG__
JackLibGlobals::CheckContext();
#endif
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);
@@ -438,6 +490,9 @@ EXPORT int jack_port_monitoring_input(jack_port_t* port)

EXPORT int jack_is_realtime(jack_client_t* ext_client)
{
#ifdef __CLIENTDEBUG__
JackLibGlobals::CheckContext();
#endif
JackClient* client = (JackClient*)ext_client;
if (client == NULL) {
jack_error("jack_is_realtime called with a NULL client");
@@ -449,6 +504,9 @@ EXPORT int jack_is_realtime(jack_client_t* ext_client)

EXPORT void jack_on_shutdown(jack_client_t* ext_client, void (*function)(void* arg), void* arg)
{
#ifdef __CLIENTDEBUG__
JackLibGlobals::CheckContext();
#endif
JackClient* client = (JackClient*)ext_client;
if (client == NULL) {
jack_error("jack_on_shutdown called with a NULL client");
@@ -459,6 +517,9 @@ EXPORT void jack_on_shutdown(jack_client_t* ext_client, void (*function)(void* a

EXPORT int jack_set_process_callback(jack_client_t* ext_client, JackProcessCallback callback, void* arg)
{
#ifdef __CLIENTDEBUG__
JackLibGlobals::CheckContext();
#endif
JackClient* client = (JackClient*)ext_client;
if (client == NULL) {
jack_error("jack_set_process_callback called with a NULL client");
@@ -470,6 +531,9 @@ EXPORT int jack_set_process_callback(jack_client_t* ext_client, JackProcessCallb

EXPORT int jack_set_freewheel_callback(jack_client_t* ext_client, JackFreewheelCallback freewheel_callback, void* arg)
{
#ifdef __CLIENTDEBUG__
JackLibGlobals::CheckContext();
#endif
JackClient* client = (JackClient*)ext_client;
if (client == NULL) {
jack_error("jack_set_freewheel_callback called with a NULL client");
@@ -481,6 +545,9 @@ EXPORT int jack_set_freewheel_callback(jack_client_t* ext_client, JackFreewheelC

EXPORT int jack_set_freewheel(jack_client_t* ext_client, int onoff)
{
#ifdef __CLIENTDEBUG__
JackLibGlobals::CheckContext();
#endif
JackClient* client = (JackClient*)ext_client;
if (client == NULL) {
jack_error("jack_set_freewheel called with a NULL client");
@@ -492,6 +559,9 @@ EXPORT int jack_set_freewheel(jack_client_t* ext_client, int onoff)

EXPORT int jack_set_buffer_size(jack_client_t* ext_client, jack_nframes_t buffer_size)
{
#ifdef __CLIENTDEBUG__
JackLibGlobals::CheckContext();
#endif
JackClient* client = (JackClient*)ext_client;
if (client == NULL) {
jack_error("jack_set_buffer_size called with a NULL client");
@@ -505,6 +575,9 @@ EXPORT int jack_set_buffer_size(jack_client_t* ext_client, jack_nframes_t buffer

EXPORT int jack_set_buffer_size_callback(jack_client_t* ext_client, JackBufferSizeCallback bufsize_callback, void* arg)
{
#ifdef __CLIENTDEBUG__
JackLibGlobals::CheckContext();
#endif
JackClient* client = (JackClient*)ext_client;
if (client == NULL) {
jack_error("jack_set_buffer_size_callback called with a NULL client");
@@ -516,6 +589,9 @@ EXPORT int jack_set_buffer_size_callback(jack_client_t* ext_client, JackBufferSi

EXPORT int jack_set_sample_rate_callback(jack_client_t* ext_client, JackSampleRateCallback srate_callback, void* arg)
{
#ifdef __CLIENTDEBUG__
JackLibGlobals::CheckContext();
#endif
JackClient* client = (JackClient*)ext_client;
JackLog("jack_set_sample_rate_callback ext_client %x client %x \n", ext_client, client);
if (client == NULL) {
@@ -529,6 +605,9 @@ EXPORT int jack_set_sample_rate_callback(jack_client_t* ext_client, JackSampleRa

EXPORT int jack_set_port_registration_callback(jack_client_t* ext_client, JackPortRegistrationCallback registration_callback, void* arg)
{
#ifdef __CLIENTDEBUG__
JackLibGlobals::CheckContext();
#endif
JackClient* client = (JackClient*)ext_client;
if (client == NULL) {
jack_error("jack_set_port_registration_callback called with a NULL client");
@@ -540,6 +619,9 @@ EXPORT int jack_set_port_registration_callback(jack_client_t* ext_client, JackPo

EXPORT int jack_set_graph_order_callback(jack_client_t* ext_client, JackGraphOrderCallback graph_callback, void* arg)
{
#ifdef __CLIENTDEBUG__
JackLibGlobals::CheckContext();
#endif
JackClient* client = (JackClient*)ext_client;
JackLog("jack_set_graph_order_callback ext_client %x client %x \n", ext_client, client);
if (client == NULL) {
@@ -552,6 +634,9 @@ EXPORT int jack_set_graph_order_callback(jack_client_t* ext_client, JackGraphOrd

EXPORT int jack_set_xrun_callback(jack_client_t* ext_client, JackXRunCallback xrun_callback, void* arg)
{
#ifdef __CLIENTDEBUG__
JackLibGlobals::CheckContext();
#endif
JackClient* client = (JackClient*)ext_client;
if (client == NULL) {
jack_error("jack_set_xrun_callback called with a NULL client");
@@ -563,6 +648,9 @@ EXPORT int jack_set_xrun_callback(jack_client_t* ext_client, JackXRunCallback xr

EXPORT int jack_set_thread_init_callback(jack_client_t* ext_client, JackThreadInitCallback init_callback, void *arg)
{
#ifdef __CLIENTDEBUG__
JackLibGlobals::CheckContext();
#endif
JackClient* client = (JackClient*)ext_client;
JackLog("jack_set_thread_init_callback ext_client %x client %x \n", ext_client, client);
if (client == NULL) {
@@ -575,6 +663,9 @@ EXPORT int jack_set_thread_init_callback(jack_client_t* ext_client, JackThreadIn

EXPORT int jack_activate(jack_client_t* ext_client)
{
#ifdef __CLIENTDEBUG__
JackLibGlobals::CheckContext();
#endif
JackClient* client = (JackClient*)ext_client;
if (client == NULL) {
jack_error("jack_activate called with a NULL client");
@@ -586,6 +677,9 @@ EXPORT int jack_activate(jack_client_t* ext_client)

EXPORT int jack_deactivate(jack_client_t* ext_client)
{
#ifdef __CLIENTDEBUG__
JackLibGlobals::CheckContext();
#endif
JackClient* client = (JackClient*)ext_client;
if (client == NULL) {
jack_error("jack_deactivate called with a NULL client");
@@ -597,6 +691,9 @@ EXPORT int jack_deactivate(jack_client_t* ext_client)

EXPORT jack_port_t* jack_port_register(jack_client_t* ext_client, const char* port_name, const char* port_type, unsigned long flags, unsigned long buffer_size)
{
#ifdef __CLIENTDEBUG__
JackLibGlobals::CheckContext();
#endif
JackClient* client = (JackClient*)ext_client;
if (client == NULL) {
jack_error("jack_port_register called with a NULL client");
@@ -611,6 +708,9 @@ EXPORT jack_port_t* jack_port_register(jack_client_t* ext_client, const char* po

EXPORT int jack_port_unregister(jack_client_t* ext_client, jack_port_t* port)
{
#ifdef __CLIENTDEBUG__
JackLibGlobals::CheckContext();
#endif
JackClient* client = (JackClient*)ext_client;
if (client == NULL) {
jack_error("jack_port_unregister called with a NULL client");
@@ -626,6 +726,9 @@ EXPORT int jack_port_unregister(jack_client_t* ext_client, jack_port_t* port)

EXPORT int jack_port_is_mine(const jack_client_t* ext_client, const jack_port_t* port)
{
#ifdef __CLIENTDEBUG__
JackLibGlobals::CheckContext();
#endif
JackClient* client = (JackClient*)ext_client;
if (client == NULL) {
jack_error("jack_port_is_mine called with a NULL client");
@@ -641,6 +744,9 @@ EXPORT int jack_port_is_mine(const jack_client_t* ext_client, const jack_port_t*

EXPORT const char** jack_port_get_connections(const jack_port_t* port)
{
#ifdef __CLIENTDEBUG__
JackLibGlobals::CheckContext();
#endif
jack_port_id_t myport = (jack_port_id_t)port;
if (!CheckPort(myport)) {
jack_error("jack_port_get_connections called with an incorrect port %ld", myport);
@@ -654,6 +760,9 @@ EXPORT const char** jack_port_get_connections(const jack_port_t* port)
// Calling client does not need to "own" the port
EXPORT const char** jack_port_get_all_connections(const jack_client_t* ext_client, const jack_port_t* port)
{
#ifdef __CLIENTDEBUG__
JackLibGlobals::CheckContext();
#endif
JackClient* client = (JackClient*)ext_client;
if (client == NULL) {
jack_error("jack_port_get_all_connections called with a NULL client");
@@ -673,6 +782,9 @@ EXPORT const char** jack_port_get_all_connections(const jack_client_t* ext_clien
// Does not use the client parameter
EXPORT int jack_port_lock(jack_client_t* ext_client, jack_port_t* port)
{
#ifdef __CLIENTDEBUG__
JackLibGlobals::CheckContext();
#endif
JackClient* client = (JackClient*)ext_client;
if (client == NULL) {
jack_error("jack_port_lock called with a NULL client");
@@ -691,6 +803,9 @@ EXPORT int jack_port_lock(jack_client_t* ext_client, jack_port_t* port)
// Does not use the client parameter
EXPORT int jack_port_unlock(jack_client_t* ext_client, jack_port_t* port)
{
#ifdef __CLIENTDEBUG__
JackLibGlobals::CheckContext();
#endif
JackClient* client = (JackClient*)ext_client;
if (client == NULL) {
jack_error("jack_port_unlock called with a NULL client");
@@ -708,6 +823,9 @@ EXPORT int jack_port_unlock(jack_client_t* ext_client, jack_port_t* port)

EXPORT jack_nframes_t jack_port_get_total_latency(jack_client_t* ext_client, jack_port_t* port)
{
#ifdef __CLIENTDEBUG__
JackLibGlobals::CheckContext();
#endif
JackClient* client = (JackClient*)ext_client;
if (client == NULL) {
jack_error("jack_port_get_total_latency called with a NULL client");
@@ -727,6 +845,9 @@ EXPORT jack_nframes_t jack_port_get_total_latency(jack_client_t* ext_client, jac

EXPORT int jack_connect(jack_client_t* ext_client, const char* src, const char* dst)
{
#ifdef __CLIENTDEBUG__
JackLibGlobals::CheckContext();
#endif
JackClient* client = (JackClient*)ext_client;
if (client == NULL) {
jack_error("jack_connect called with a NULL client");
@@ -741,6 +862,9 @@ EXPORT int jack_connect(jack_client_t* ext_client, const char* src, const char*

EXPORT int jack_disconnect(jack_client_t* ext_client, const char* src, const char* dst)
{
#ifdef __CLIENTDEBUG__
JackLibGlobals::CheckContext();
#endif
JackClient* client = (JackClient*)ext_client;
if (client == NULL) {
jack_error("jack_disconnect called with a NULL client");
@@ -755,6 +879,9 @@ EXPORT int jack_disconnect(jack_client_t* ext_client, const char* src, const cha

EXPORT int jack_port_connect(jack_client_t* ext_client, jack_port_t* src, jack_port_t* dst)
{
#ifdef __CLIENTDEBUG__
JackLibGlobals::CheckContext();
#endif
JackClient* client = (JackClient*)ext_client;
if (client == NULL) {
jack_error("jack_port_connect called with a NULL client");
@@ -775,6 +902,9 @@ EXPORT int jack_port_connect(jack_client_t* ext_client, jack_port_t* src, jack_p

EXPORT int jack_port_disconnect(jack_client_t* ext_client, jack_port_t* src)
{
#ifdef __CLIENTDEBUG__
JackLibGlobals::CheckContext();
#endif
JackClient* client = (JackClient*)ext_client;
if (client == NULL) {
jack_error("jack_port_disconnect called with a NULL client");
@@ -790,6 +920,9 @@ EXPORT int jack_port_disconnect(jack_client_t* ext_client, jack_port_t* src)

EXPORT jack_nframes_t jack_get_sample_rate(jack_client_t* ext_client)
{
#ifdef __CLIENTDEBUG__
JackLibGlobals::CheckContext();
#endif
JackClient* client = (JackClient*)ext_client;
if (client == NULL) {
jack_error("jack_get_sample_rate called with a NULL client");
@@ -801,6 +934,9 @@ EXPORT jack_nframes_t jack_get_sample_rate(jack_client_t* ext_client)

EXPORT jack_nframes_t jack_get_buffer_size(jack_client_t* ext_client)
{
#ifdef __CLIENTDEBUG__
JackLibGlobals::CheckContext();
#endif
JackClient* client = (JackClient*)ext_client;
if (client == NULL) {
jack_error("jack_get_buffer_size called with a NULL client");
@@ -812,6 +948,9 @@ EXPORT jack_nframes_t jack_get_buffer_size(jack_client_t* ext_client)

EXPORT const char** jack_get_ports(jack_client_t* ext_client, const char* port_name_pattern, const char* type_name_pattern, unsigned long flags)
{
#ifdef __CLIENTDEBUG__
JackLibGlobals::CheckContext();
#endif
JackClient* client = (JackClient*)ext_client;
if (client == NULL) {
jack_error("jack_get_ports called with a NULL client");
@@ -822,6 +961,9 @@ EXPORT const char** jack_get_ports(jack_client_t* ext_client, const char* port_n

EXPORT jack_port_t* jack_port_by_name(jack_client_t* ext_client, const char* portname)
{
#ifdef __CLIENTDEBUG__
JackLibGlobals::CheckContext();
#endif
JackClient* client = (JackClient*)ext_client;
if (client == NULL) {
jack_error("jack_get_ports called with a NULL client");
@@ -839,12 +981,18 @@ EXPORT jack_port_t* jack_port_by_name(jack_client_t* ext_client, const char* por

EXPORT jack_port_t* jack_port_by_id(const jack_client_t* ext_client, jack_port_id_t id)
{
#ifdef __CLIENTDEBUG__
JackLibGlobals::CheckContext();
#endif
/* jack_port_t* type is actually the port index */
return (jack_port_t*)id;
}

EXPORT int jack_engine_takeover_timebase(jack_client_t* ext_client)
{
#ifdef __CLIENTDEBUG__
JackLibGlobals::CheckContext();
#endif
JackClient* client = (JackClient*)ext_client;
if (client == NULL) {
jack_error("jack_engine_takeover_timebase called with a NULL client");
@@ -857,6 +1005,9 @@ EXPORT int jack_engine_takeover_timebase(jack_client_t* ext_client)

EXPORT jack_nframes_t jack_frames_since_cycle_start(const jack_client_t* ext_client)
{
#ifdef __CLIENTDEBUG__
JackLibGlobals::CheckContext();
#endif
JackTimer timer;
GetEngineControl()->ReadFrameTime(&timer);
return (jack_nframes_t) floor((((float)GetEngineControl()->fSampleRate) / 1000000.0f) * (GetMicroSeconds() - timer.fCurrentCallback));
@@ -864,6 +1015,9 @@ EXPORT jack_nframes_t jack_frames_since_cycle_start(const jack_client_t* ext_cli

EXPORT jack_nframes_t jack_frame_time(const jack_client_t* ext_client)
{
#ifdef __CLIENTDEBUG__
JackLibGlobals::CheckContext();
#endif
JackClient* client = (JackClient*)ext_client;
if (client == NULL) {
jack_error("jack_frame_time called with a NULL client");
@@ -883,6 +1037,9 @@ EXPORT jack_nframes_t jack_frame_time(const jack_client_t* ext_client)

EXPORT jack_nframes_t jack_last_frame_time(const jack_client_t* ext_client)
{
#ifdef __CLIENTDEBUG__
JackLibGlobals::CheckContext();
#endif
JackTimer timer;
GetEngineControl()->ReadFrameTime(&timer);
return timer.fFrames;
@@ -890,6 +1047,9 @@ EXPORT jack_nframes_t jack_last_frame_time(const jack_client_t* ext_client)

EXPORT float jack_cpu_load(jack_client_t* ext_client)
{
#ifdef __CLIENTDEBUG__
JackLibGlobals::CheckContext();
#endif
JackClient* client = (JackClient*)ext_client;
if (client == NULL) {
jack_error("jack_cpu_load called with a NULL client");
@@ -901,6 +1061,9 @@ EXPORT float jack_cpu_load(jack_client_t* ext_client)

EXPORT pthread_t jack_client_thread_id(jack_client_t* ext_client)
{
#ifdef __CLIENTDEBUG__
JackLibGlobals::CheckContext();
#endif
JackClient* client = (JackClient*)ext_client;
if (client == NULL) {
jack_error("jack_client_thread_id called with a NULL client");
@@ -912,6 +1075,9 @@ EXPORT pthread_t jack_client_thread_id(jack_client_t* ext_client)

EXPORT char* jack_get_client_name (jack_client_t* ext_client)
{
#ifdef __CLIENTDEBUG__
JackLibGlobals::CheckContext();
#endif
JackClient* client = (JackClient*)ext_client;
if (client == NULL) {
jack_error("jack_get_client_name called with a NULL client");
@@ -935,6 +1101,9 @@ EXPORT int jack_port_name_size(void)

EXPORT int jack_release_timebase(jack_client_t* ext_client)
{
#ifdef __CLIENTDEBUG__
JackLibGlobals::CheckContext();
#endif
JackClient* client = (JackClient*)ext_client;
if (client == NULL) {
jack_error("jack_release_timebase called with a NULL client");
@@ -946,6 +1115,9 @@ EXPORT int jack_release_timebase(jack_client_t* ext_client)

EXPORT int jack_set_sync_callback(jack_client_t* ext_client, JackSyncCallback sync_callback, void *arg)
{
#ifdef __CLIENTDEBUG__
JackLibGlobals::CheckContext();
#endif
JackClient* client = (JackClient*)ext_client;
if (client == NULL) {
jack_error("jack_set_sync_callback called with a NULL client");
@@ -957,6 +1129,9 @@ EXPORT int jack_set_sync_callback(jack_client_t* ext_client, JackSyncCallback sy

EXPORT int jack_set_sync_timeout(jack_client_t* ext_client, jack_time_t timeout)
{
#ifdef __CLIENTDEBUG__
JackLibGlobals::CheckContext();
#endif
JackClient* client = (JackClient*)ext_client;
if (client == NULL) {
jack_error("jack_set_sync_timeout called with a NULL client");
@@ -968,6 +1143,9 @@ EXPORT int jack_set_sync_timeout(jack_client_t* ext_client, jack_time_t timeout)

EXPORT int jack_set_timebase_callback(jack_client_t* ext_client, int conditional, JackTimebaseCallback timebase_callback, void* arg)
{
#ifdef __CLIENTDEBUG__
JackLibGlobals::CheckContext();
#endif
JackClient* client = (JackClient*)ext_client;
if (client == NULL) {
jack_error("jack_set_timebase_callback called with a NULL client");
@@ -979,6 +1157,9 @@ EXPORT int jack_set_timebase_callback(jack_client_t* ext_client, int conditional

EXPORT int jack_transport_locate(jack_client_t* ext_client, jack_nframes_t frame)
{
#ifdef __CLIENTDEBUG__
JackLibGlobals::CheckContext();
#endif
JackClient* client = (JackClient*)ext_client;
if (client == NULL) {
jack_error("jack_transport_locate called with a NULL client");
@@ -990,6 +1171,9 @@ EXPORT int jack_transport_locate(jack_client_t* ext_client, jack_nframes_t frame

EXPORT jack_transport_state_t jack_transport_query(const jack_client_t* ext_client, jack_position_t* pos)
{
#ifdef __CLIENTDEBUG__
JackLibGlobals::CheckContext();
#endif
JackClient* client = (JackClient*)ext_client;
if (client == NULL) {
jack_error("jack_transport_query called with a NULL client");
@@ -1001,6 +1185,9 @@ EXPORT jack_transport_state_t jack_transport_query(const jack_client_t* ext_clie

EXPORT jack_nframes_t jack_get_current_transport_frame(const jack_client_t* ext_client)
{
#ifdef __CLIENTDEBUG__
JackLibGlobals::CheckContext();
#endif
JackClient* client = (JackClient*)ext_client;
if (client == NULL) {
jack_error("jack_get_current_transport_frame called with a NULL client");
@@ -1012,6 +1199,9 @@ EXPORT jack_nframes_t jack_get_current_transport_frame(const jack_client_t* ext_

EXPORT int jack_transport_reposition(jack_client_t* ext_client, jack_position_t* pos)
{
#ifdef __CLIENTDEBUG__
JackLibGlobals::CheckContext();
#endif
JackClient* client = (JackClient*)ext_client;
if (client == NULL) {
jack_error("jack_transport_reposition called with a NULL client");
@@ -1023,6 +1213,9 @@ EXPORT int jack_transport_reposition(jack_client_t* ext_client, jack_position_t*

EXPORT void jack_transport_start(jack_client_t* ext_client)
{
#ifdef __CLIENTDEBUG__
JackLibGlobals::CheckContext();
#endif
JackClient* client = (JackClient*)ext_client;
if (client == NULL) {
jack_error("jack_transport_start called with a NULL client");
@@ -1033,6 +1226,9 @@ EXPORT void jack_transport_start(jack_client_t* ext_client)

EXPORT void jack_transport_stop(jack_client_t* ext_client)
{
#ifdef __CLIENTDEBUG__
JackLibGlobals::CheckContext();
#endif
JackClient* client = (JackClient*)ext_client;
if (client == NULL) {
jack_error("jack_transport_stop called with a NULL client");
@@ -1061,18 +1257,27 @@ EXPORT void jack_set_transport_info(jack_client_t* ext_client, jack_transport_in

EXPORT float jack_get_max_delayed_usecs(jack_client_t* ext_client)
{
#ifdef __CLIENTDEBUG__
JackLibGlobals::CheckContext();
#endif
JackLog("jack_get_max_delayed_usecs: not yet implemented\n");
return 0.f;
}

EXPORT float jack_get_xrun_delayed_usecs(jack_client_t* ext_client)
{
#ifdef __CLIENTDEBUG__
JackLibGlobals::CheckContext();
#endif
JackLog("jack_get_xrun_delayed_usecs: not yet implemented\n");
return 0.f;
}

EXPORT void jack_reset_max_delayed_usecs(jack_client_t* ext_client)
{
#ifdef __CLIENTDEBUG__
JackLibGlobals::CheckContext();
#endif
JackLog("jack_reset_max_delayed_usecs: not yet implemented\n");
}



+ 96
- 54
common/JackDebugClient.cpp View File

@@ -76,8 +76,8 @@ JackDebugClient::~JackDebugClient()

int JackDebugClient::Open(const char* name)
{
int Tidport;
Tidport = fClient->Open(name);
int res;
res = fClient->Open(name);
char provstr[256];
char buffer[256];
time_t curtime;
@@ -90,36 +90,47 @@ int JackDebugClient::Open(const char* name)
sprintf(provstr, "JackClientDebug-%s-%s.log", name, buffer);
fStream = new ofstream(provstr, ios_base::ate);
if (fStream->is_open()) {
if (Tidport == -1) {
*fStream << "Trying to Open Client with name '" << name << "' with bad result (client not opened)." << Tidport << endl;
if (res == -1) {
*fStream << "Trying to open client with name '" << name << "' with bad result (client not opened)." << res << endl;
} else {
*fStream << "Open Client with name '" << name << "'." << endl;
*fStream << "Open client with name '" << name << "'." << endl;
}
} else {
JackLog("JackDebugClient::Open : cannot open log file\n");
}
strcpy(fClientName, name);
return Tidport;
return res;
}

int JackDebugClient::Close()
{
fIsClosed++;
*fStream << "Client '" << fClientName << "' was Closed" << endl;
*fStream << "Client '" << fClientName << "' was closed" << endl;
return fClient->Close();
}

void JackDebugClient::CheckClient() const
{
if (fIsClosed > 0) {
*fStream << "!!! ERROR !!! : Accessing a client '" << fClientName << "' already closed !" << endl;
*fStream << "This is likely to cause crash !'" << endl;
}
}

pthread_t JackDebugClient::GetThreadID()
{
CheckClient();
return fClient->GetThreadID();
}

JackGraphManager* JackDebugClient::GetGraphManager() const
{
CheckClient();
return fClient->GetGraphManager();
}
JackEngineControl* JackDebugClient::GetEngineControl() const
{
CheckClient();
return fClient->GetEngineControl();
}
/*!
@@ -128,33 +139,36 @@ JackEngineControl* JackDebugClient::GetEngineControl() const

int JackDebugClient::ClientNotify(int refnum, const char* name, int notify, int sync, int value)
{
CheckClient();
return fClient->ClientNotify( refnum, name, notify, sync, value);
}

int JackDebugClient::Activate()
{
int Tidport;
Tidport = fClient->Activate();
CheckClient();
int res;
res = fClient->Activate();
fIsActivated++;
if (fIsDeactivated)
*fStream << "Client '" << fClientName << "' call activate a new time (it already call 'activate' previously)." << endl;
*fStream << "Client '" << fClientName << "' Activated" << endl;
if (Tidport != 0)
*fStream << "Client '" << fClientName << "' try to activate but server return " << Tidport << " ." << endl;
return Tidport;
if (res != 0)
*fStream << "Client '" << fClientName << "' try to activate but server return " << res << " ." << endl;
return res;
}

int JackDebugClient::Deactivate()
{
int Tidport;
Tidport = fClient->Deactivate();
CheckClient();
int res;
res = fClient->Deactivate();
fIsDeactivated++;
if (fIsActivated == 0)
*fStream << "Client '" << fClientName << "' deactivate while it hasn't been previoulsy activated !" << endl;
*fStream << "Client '" << fClientName << "' Deactivated" << endl;
if (Tidport != 0)
*fStream << "Client '" << fClientName << "' try to deactivate but server return " << Tidport << " ." << endl;
return Tidport;
if (res != 0)
*fStream << "Client '" << fClientName << "' try to deactivate but server return " << res << " ." << endl;
return res;
}

//-----------------
@@ -163,13 +177,14 @@ int JackDebugClient::Deactivate()

int JackDebugClient::PortRegister(const char* port_name, const char* port_type, unsigned long flags, unsigned long buffer_size)
{
int Tidport;
Tidport = fClient->PortRegister(port_name, port_type, flags, buffer_size);
if (Tidport <= 0) {
*fStream << "Client '" << fClientName << "' try port Register ('" << port_name << "') and server return error " << Tidport << " ." << endl;
CheckClient();
int res;
res = fClient->PortRegister(port_name, port_type, flags, buffer_size);
if (res <= 0) {
*fStream << "Client '" << fClientName << "' try port register ('" << port_name << "') and server return error " << res << " ." << endl;
} else {
if (fTotalPortNumber < MAX_PORT_HISTORY) {
fPortList[fTotalPortNumber].idport = Tidport;
fPortList[fTotalPortNumber].idport = res;
strcpy(fPortList[fTotalPortNumber].name, port_name);
fPortList[fTotalPortNumber].IsConnected = 0;
fPortList[fTotalPortNumber].IsUnregistrated = 0;
@@ -178,15 +193,16 @@ int JackDebugClient::PortRegister(const char* port_name, const char* port_type,
}
fTotalPortNumber++;
fOpenPortNumber++;
*fStream << "Client '" << fClientName << "' port Register with portname '" << port_name << " port " << Tidport << "' ." << endl;
*fStream << "Client '" << fClientName << "' port register with portname '" << port_name << " port " << res << "' ." << endl;
}
return Tidport;
return res;
}

int JackDebugClient::PortUnRegister(jack_port_id_t port_index)
{
int Tidport;
Tidport = fClient->PortUnRegister(port_index);
CheckClient();
int res;
res = fClient->PortUnRegister(port_index);
fOpenPortNumber--;
int i;
for (i = (fTotalPortNumber - 1); i >= 0; i--) { // We search the record into the history
@@ -199,19 +215,20 @@ int JackDebugClient::PortUnRegister(jack_port_id_t port_index)
}
if (i == 0) // Port is not found
*fStream << "JackClientDebug : PortUnregister : port " << port_index << " was not previously registered !" << endl;
if (Tidport != 0)
*fStream << "Client '" << fClientName << "' try to do PortUnregister and server return " << Tidport << " )." << endl;
if (res != 0)
*fStream << "Client '" << fClientName << "' try to do PortUnregister and server return " << res << " )." << endl;
*fStream << "Client '" << fClientName << "' unregister port '" << port_index << "'." << endl;
return Tidport;
return res;
}

int JackDebugClient::PortConnect(const char* src, const char* dst)
{
if (!(fIsActivated))
CheckClient();
if (!fIsActivated)
*fStream << "!!! ERROR !!! Trying to connect a port ( " << src << " to " << dst << ") while the client has not been activated !" << endl;
int Tidport;
int res;
int i;
Tidport = fClient->PortConnect( src, dst);
res = fClient->PortConnect( src, dst);
for (i = (fTotalPortNumber - 1); i >= 0; i--) { // We search the record into the history
if (strcmp(fPortList[i].name, src) == 0) { // We found the last record in sources
if (fPortList[i].IsUnregistrated != 0)
@@ -229,18 +246,19 @@ int JackDebugClient::PortConnect(const char* src, const char* dst)
}
if (i == 0) // Port is not found
*fStream << "JackClientDebug : PortConnect : port was not found in debug database !" << endl;
if (Tidport != 0)
*fStream << "Client '" << fClientName << "' try to do PortConnect but server return " << Tidport << " ." << endl;
if (res != 0)
*fStream << "Client '" << fClientName << "' try to do PortConnect but server return " << res << " ." << endl;
//*fStream << "Client Port Connect done with names" << endl;
return Tidport;
return res;
}

int JackDebugClient::PortDisconnect(const char* src, const char* dst)
{
if (!(fIsActivated))
CheckClient();
if (!fIsActivated)
*fStream << "!!! ERROR !!! Trying to disconnect a port ( " << src << " to " << dst << ") while the client has not been activated !" << endl;
int Tidport;
Tidport = fClient->PortDisconnect( src, dst);
int res;
res = fClient->PortDisconnect( src, dst);
int i;
for (i = (fTotalPortNumber - 1); i >= 0; i--) { // We search the record into the history
if (strcmp(fPortList[i].name, src) == 0) { // We found the record in sources
@@ -259,18 +277,19 @@ int JackDebugClient::PortDisconnect(const char* src, const char* dst)
}
if (i == 0) // Port is not found
*fStream << "JackClientDebug : PortDisConnect : port was not found in debug database !" << endl;
if (Tidport != 0)
*fStream << "Client '" << fClientName << "' try to do PortDisconnect but server return " << Tidport << " ." << endl;
if (res != 0)
*fStream << "Client '" << fClientName << "' try to do PortDisconnect but server return " << res << " ." << endl;
//*fStream << "Client Port Disconnect done." << endl;
return Tidport;
return res;
}

int JackDebugClient::PortConnect(jack_port_id_t src, jack_port_id_t dst)
{
if (!(fIsActivated))
{
CheckClient();
if (!fIsActivated)
*fStream << "!!! ERROR !!! : Trying to connect port " << src << " to " << dst << " while the client has not been activated !" << endl;
int Tidport;
Tidport = fClient->PortConnect(src, dst);
int res;
res = fClient->PortConnect(src, dst);
int i;
for (i = (fTotalPortNumber - 1); i >= 0; i--) { // We search the record into the history
if (fPortList[i].idport == src) { // We found the record in sources
@@ -289,18 +308,19 @@ int JackDebugClient::PortConnect(jack_port_id_t src, jack_port_id_t dst)
}
if (i == 0) // Port is not found
*fStream << "JackClientDebug : PortConnect : port was not found in debug database !" << endl;
if (Tidport == -1)
*fStream << "Client '" << fClientName << "' try to do Portconnect but server return " << Tidport << " ." << endl;
if (res == -1)
*fStream << "Client '" << fClientName << "' try to do Portconnect but server return " << res << " ." << endl;
//*fStream << "Client Port Connect with ID done." << endl;
return Tidport;
return res;
}

int JackDebugClient::PortDisconnect(jack_port_id_t src)
{
if (!(fIsActivated))
CheckClient();
if (!fIsActivated)
*fStream << "!!! ERROR !!! : Trying to disconnect port " << src << " while that client has not been activated !" << endl;
int Tidport;
Tidport = fClient->PortDisconnect(src);
int res;
res = fClient->PortDisconnect(src);
int i;
for (i = (fTotalPortNumber - 1); i >= 0; i--) { // We search the record into the history
if (fPortList[i].idport == src) { // We found the record in sources
@@ -313,14 +333,15 @@ int JackDebugClient::PortDisconnect(jack_port_id_t src)
}
if (i == 0) // Port is not found
*fStream << "JackClientDebug : PortDisconnect : port was not found in debug database !" << endl;
if (Tidport != 0)
*fStream << "Client '" << fClientName << "' try to do PortDisconnect but server return " << Tidport << " ." << endl;
if (res != 0)
*fStream << "Client '" << fClientName << "' try to do PortDisconnect but server return " << res << " ." << endl;
//*fStream << "Client Port Disconnect with ID done." << endl;
return Tidport;
return res;
}

int JackDebugClient::PortIsMine(jack_port_id_t port_index)
{
CheckClient();
return fClient->PortIsMine(port_index);
}

@@ -330,11 +351,13 @@ int JackDebugClient::PortIsMine(jack_port_id_t port_index)

int JackDebugClient::SetBufferSize(jack_nframes_t buffer_size)
{
CheckClient();
return fClient->SetBufferSize(buffer_size);
}

int JackDebugClient::SetFreeWheel(int onoff)
{
CheckClient();
return fClient->SetFreeWheel(onoff);
}

@@ -356,51 +379,61 @@ void JackDebugClient::ShutDown()

int JackDebugClient::ReleaseTimebase()
{
CheckClient();
return fClient->ReleaseTimebase();
}

int JackDebugClient::SetSyncCallback(JackSyncCallback sync_callback, void* arg)
{
CheckClient();
return fClient->SetSyncCallback(sync_callback, arg);
}

int JackDebugClient::SetSyncTimeout(jack_time_t timeout)
{
CheckClient();
return fClient->SetSyncTimeout(timeout);
}

int JackDebugClient::SetTimebaseCallback(int conditional, JackTimebaseCallback timebase_callback, void* arg)
{
CheckClient();
return fClient->SetTimebaseCallback( conditional, timebase_callback, arg);
}

int JackDebugClient::TransportLocate(jack_nframes_t frame)
{
CheckClient();
return fClient->TransportLocate(frame);
}

jack_transport_state_t JackDebugClient::TransportQuery(jack_position_t* pos)
{
CheckClient();
return fClient->TransportQuery(pos);
}

jack_nframes_t JackDebugClient::GetCurrentTransportFrame()
{
CheckClient();
return fClient->GetCurrentTransportFrame();
}

int JackDebugClient::TransportReposition(jack_position_t* pos)
{
CheckClient();
return fClient->TransportReposition(pos);
}

void JackDebugClient::TransportStart()
{
CheckClient();
fClient->TransportStart();
}

void JackDebugClient::TransportStop()
{
CheckClient();
fClient->TransportStop();
}

@@ -410,46 +443,55 @@ void JackDebugClient::TransportStop()

void JackDebugClient::OnShutdown(JackShutdownCallback callback, void *arg)
{
CheckClient();
fClient->OnShutdown(callback, arg);
}

int JackDebugClient::SetProcessCallback(JackProcessCallback callback, void *arg)
{
CheckClient();
return fClient->SetProcessCallback( callback, arg);
}

int JackDebugClient::SetXRunCallback(JackXRunCallback callback, void *arg)
{
CheckClient();
return fClient->SetXRunCallback(callback, arg);
}

int JackDebugClient::SetInitCallback(JackThreadInitCallback callback, void *arg)
{
CheckClient();
return fClient->SetInitCallback(callback, arg);
}

int JackDebugClient::SetGraphOrderCallback(JackGraphOrderCallback callback, void *arg)
{
CheckClient();
return fClient->SetGraphOrderCallback(callback, arg);
}

int JackDebugClient::SetBufferSizeCallback(JackBufferSizeCallback callback, void *arg)
{
CheckClient();
return fClient->SetBufferSizeCallback(callback, arg);
}

int JackDebugClient::SetFreewheelCallback(JackFreewheelCallback callback, void *arg)
{
CheckClient();
return fClient->SetFreewheelCallback(callback, arg);
}

int JackDebugClient::SetPortRegistrationCallback(JackPortRegistrationCallback callback, void *arg)
{
CheckClient();
return fClient->SetPortRegistrationCallback(callback, arg);
}

JackClientControl* JackDebugClient::GetClientControl() const
{
CheckClient();
return fClient->GetClientControl();
}



+ 3
- 1
common/JackDebugClient.h View File

@@ -53,6 +53,7 @@ class JackDebugClient : public JackClient
std::ofstream* fStream;

protected:
PortFollower fPortList[MAX_PORT_HISTORY]; // Arbitrary value... To be tuned...
int fTotalPortNumber; // The total number of port opened and maybe closed. Historical view.
int fOpenPortNumber; // The current number of opened port.
@@ -64,7 +65,6 @@ class JackDebugClient : public JackClient
public:

JackDebugClient(JackClient *fTheClient);

virtual ~JackDebugClient();

virtual int Open(const char* name);
@@ -118,6 +118,8 @@ class JackDebugClient : public JackClient
int SetFreewheelCallback(JackFreewheelCallback callback, void* arg);
int SetPortRegistrationCallback(JackPortRegistrationCallback callback, void* arg);
JackClientControl* GetClientControl() const;
void CheckClient() const;

};



+ 6
- 0
common/JackLibGlobals.h View File

@@ -88,6 +88,12 @@ struct JackLibGlobals
JackGlobals::Destroy();
}
}
static void CheckContext()
{
if (!(fClientCount > 0 && fGlobals))
jack_error("Error !!! : client accessing an already desallocated library context");
}

};



Write Preview
Loading…
Cancel
Save