← Back to branch summary

~ubuntu-branches/ubuntu/quantal/jackd2/quantal

« back to all changes in this revision

Viewing changes to .pc/0000_sync_upstream_VCS.patch/common/JackWeakAPI.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Reinhard Tartler, Adrian Knoth, Reinhard Tartler, Jonas Smedegaard
  • Date: 2010-06-19 18:54:29 UTC
  • Revision ID: james.westby@ubuntu.com-20100619185429-zhbhh0mqvukgzx0l
Tags: 1.9.5~dfsg-15
http://bugs.debian.org/586257
[ Adrian Knoth ]
* Also provide the shlibs file for libjack-jackd2-0
* Fix FTBFS on sparc64 (Closes: #586257)

[ Reinhard Tartler ]
* jackd must not be a virtual package, use 'jack-daemon' for that
* add breaks/replaces on old libjack0
* change shlibsfile to prefer jackd2's libjack
* use conflicts instead of breaks. libjack-jackd2-0 has file conflicts
  with libjack0 and will keep it

[ Jonas Smedegaard ]
* Update control file.

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/0000_sync_upstream_VCS.patch/common/JackWeakAPI.cpp
 
1
/*
 
2
Copyright (C) 2009 Grame
 
3
 
 
4
This program is free software; you can redistribute it and/or modify
 
5
it under the terms of the GNU Lesser General Public License as published by
 
6
the Free Software Foundation; either version 2.1 of the License, or
 
7
(at your option) any later version.
 
8
 
 
9
This program is distributed in the hope that it will be useful,
 
10
but WITHOUT ANY WARRANTY; without even the implied warranty of
 
11
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
12
GNU Lesser General Public License for more details.
 
13
 
 
14
You should have received a copy of the GNU Lesser General Public License
 
15
along with this program; if not, write to the Free Software
 
16
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
17
 
 
18
*/
 
19
 
 
20
/*
 
21
    Completed from Julien Pommier (PianoTeq : http://www.pianoteq.com/) code.
 
22
*/
 
23
 
 
24
#include <jack/jack.h>
 
25
#include <jack/thread.h>
 
26
#include <jack/midiport.h>
 
27
#include <math.h>
 
28
#include <dlfcn.h>
 
29
#include <stdlib.h>
 
30
#include <cassert>
 
31
#include <iostream>
 
32
 
 
33
/* dynamically load libjack and forward all registered calls to libjack 
 
34
   (similar to what relaytool is trying to do, but more portably..)
 
35
*/
 
36
 
 
37
typedef void (*print_function)(const char *);
 
38
typedef void *(*thread_routine)(void*);
 
39
 
 
40
using std::cerr;
 
41
 
 
42
int libjack_is_present = 0;     // public symbol, similar to what relaytool does.
 
43
static void *libjack_handle = 0;
 
44
 
 
45
static void __attribute__((constructor)) tryload_libjack()
 
46
{
 
47
    if (getenv("SKIP_LIBJACK") == 0) { // just in case libjack is causing troubles..
 
48
    #ifdef __APPLE__
 
49
        libjack_handle = dlopen("libjack.0.dylib", RTLD_LAZY);
 
50
    #else
 
51
        libjack_handle = dlopen("libjack.so.0", RTLD_LAZY);
 
52
    #endif
 
53
        
 
54
    }
 
55
    libjack_is_present = (libjack_handle != 0);
 
56
}
 
57
 
 
58
void *load_jack_function(const char *fn_name) 
 
59
{
 
60
    void *fn = 0;
 
61
    if (!libjack_handle) { 
 
62
        std::cerr << "libjack not found, so do not try to load " << fn_name << " ffs !\n";
 
63
        return 0;
 
64
    }
 
65
    fn = dlsym(libjack_handle, fn_name);
 
66
    if (!fn) { 
 
67
        std::cerr << "could not dlsym(" << libjack_handle << "), " << dlerror() << "\n"; 
 
68
    }
 
69
    return fn;
 
70
}
 
71
 
 
72
#define DECL_FUNCTION(return_type, fn_name, arguments_types, arguments) \
 
73
  typedef return_type (*fn_name##_ptr_t)arguments_types;                \
 
74
  return_type fn_name arguments_types {                                 \
 
75
    static fn_name##_ptr_t fn = 0;                                      \
 
76
    if (fn == 0) { fn = (fn_name##_ptr_t)load_jack_function(#fn_name); } \
 
77
    if (fn) return (*fn)arguments;                                      \
 
78
    else return (return_type)-1;                                                      \
 
79
  }
 
80
 
 
81
#define DECL_VOID_FUNCTION(fn_name, arguments_types, arguments)         \
 
82
  typedef void (*fn_name##_ptr_t)arguments_types;                       \
 
83
  void fn_name arguments_types {                                        \
 
84
    static fn_name##_ptr_t fn = 0;                                      \
 
85
    if (fn == 0) { fn = (fn_name##_ptr_t)load_jack_function(#fn_name); } \
 
86
    if (fn) (*fn)arguments;                                             \
 
87
  }
 
88
 
 
89
DECL_VOID_FUNCTION(jack_get_version, (int *major_ptr, int *minor_ptr, int *micro_ptr, int *proto_ptr), (major_ptr, minor_ptr, micro_ptr, proto_ptr));
 
90
DECL_FUNCTION(const char *, jack_get_version_string, (), ());      
 
91
DECL_FUNCTION(jack_client_t *, jack_client_open, (const char *client_name, jack_options_t options, jack_status_t *status, ...), 
 
92
              (client_name, options, status));
 
93
DECL_FUNCTION(int, jack_client_close, (jack_client_t *client), (client));
 
94
DECL_FUNCTION(jack_client_t *, jack_client_new, (const char *client_name), (client_name));
 
95
DECL_FUNCTION(int, jack_client_name_size, (), ());
 
96
DECL_FUNCTION(char*, jack_get_client_name, (jack_client_t *client), (client));
 
97
DECL_FUNCTION(int, jack_internal_client_new, (const char *client_name,
 
98
                                            const char *load_name,
 
99
                                            const char *load_init), (client_name, load_name, load_init));
 
100
DECL_VOID_FUNCTION(jack_internal_client_close, (const char *client_name), (client_name));
 
101
DECL_FUNCTION(int, jack_is_realtime, (jack_client_t *client), (client));
 
102
DECL_VOID_FUNCTION(jack_on_shutdown, (jack_client_t *client, JackShutdownCallback shutdown_callback, void *arg), (client, shutdown_callback, arg));
 
103
DECL_VOID_FUNCTION(jack_on_info_shutdown, (jack_client_t* client, JackInfoShutdownCallback shutdown_callback, void* arg), (client, shutdown_callback, arg));
 
104
DECL_FUNCTION(int, jack_set_process_callback, (jack_client_t *client,
 
105
                                            JackProcessCallback process_callback,
 
106
                                            void *arg), (client, process_callback, arg));
 
107
DECL_FUNCTION(jack_nframes_t, jack_thread_wait, (jack_client_t *client, int status), (client, status));      
 
108
                                      
 
109
//
 
110
DECL_FUNCTION(jack_nframes_t, jack_cycle_wait, (jack_client_t *client), (client));   
 
111
DECL_VOID_FUNCTION(jack_cycle_signal, (jack_client_t *client, int status), (client, status));                                          
 
112
DECL_FUNCTION(int, jack_set_process_thread, (jack_client_t *client,
 
113
                                            JackThreadCallback fun,
 
114
                                            void *arg), (client, fun, arg));
 
115
DECL_FUNCTION(int, jack_set_thread_init_callback, (jack_client_t *client,
 
116
                                            JackThreadInitCallback thread_init_callback,
 
117
                                            void *arg), (client, thread_init_callback, arg));
 
118
DECL_FUNCTION(int, jack_set_freewheel_callback, (jack_client_t *client,
 
119
                                            JackFreewheelCallback freewheel_callback,
 
120
                                            void *arg), (client, freewheel_callback, arg));
 
121
DECL_FUNCTION(int, jack_set_freewheel, (jack_client_t *client, int onoff), (client, onoff));   
 
122
DECL_FUNCTION(int, jack_set_buffer_size, (jack_client_t *client, jack_nframes_t nframes), (client, nframes));   
 
123
DECL_FUNCTION(int, jack_set_buffer_size_callback, (jack_client_t *client,
 
124
                                            JackBufferSizeCallback bufsize_callback,
 
125
                                            void *arg), (client, bufsize_callback, arg));
 
126
DECL_FUNCTION(int, jack_set_sample_rate_callback, (jack_client_t *client,
 
127
                                            JackSampleRateCallback srate_callback,
 
128
                                            void *arg), (client, srate_callback, arg));
 
129
DECL_FUNCTION(int, jack_set_client_registration_callback, (jack_client_t *client,
 
130
                                            JackClientRegistrationCallback registration_callback,
 
131
                                            void *arg), (client, registration_callback, arg));
 
132
DECL_FUNCTION(int, jack_set_port_registration_callback, (jack_client_t *client,
 
133
                                            JackPortRegistrationCallback registration_callback,
 
134
                                            void *arg), (client, registration_callback, arg));
 
135
DECL_FUNCTION(int, jack_set_port_connect_callback, (jack_client_t *client,
 
136
                                            JackPortConnectCallback connect_callback,
 
137
                                            void *arg), (client, connect_callback, arg));
 
138
DECL_FUNCTION(int, jack_set_port_rename_callback, (jack_client_t *client,
 
139
                                            JackPortRenameCallback rename_callback,
 
140
                                            void *arg), (client, rename_callback, arg));
 
141
DECL_FUNCTION(int, jack_set_graph_order_callback, (jack_client_t *client,
 
142
                                            JackGraphOrderCallback graph_callback,
 
143
                                            void *arg), (client, graph_callback, arg));
 
144
DECL_FUNCTION(int, jack_set_xrun_callback, (jack_client_t *client,
 
145
                                            JackXRunCallback xrun_callback,
 
146
                                            void *arg), (client, xrun_callback, arg));
 
147
DECL_FUNCTION(int, jack_activate, (jack_client_t *client), (client));
 
148
DECL_FUNCTION(int, jack_deactivate, (jack_client_t *client), (client));
 
149
DECL_FUNCTION(jack_port_t *, jack_port_register, (jack_client_t *client, const char *port_name, const char *port_type,
 
150
                                                  unsigned long flags, unsigned long buffer_size),
 
151
              (client, port_name, port_type, flags, buffer_size));
 
152
DECL_FUNCTION(int, jack_port_unregister, (jack_client_t *client, jack_port_t* port), (client, port));
 
153
DECL_FUNCTION(void *, jack_port_get_buffer, (jack_port_t *port, jack_nframes_t nframes), (port, nframes));
 
154
DECL_FUNCTION(const char*, jack_port_name, (const jack_port_t *port), (port));
 
155
DECL_FUNCTION(const char*, jack_port_short_name, (const jack_port_t *port), (port));
 
156
DECL_FUNCTION(int, jack_port_flags, (const jack_port_t *port), (port));
 
157
DECL_FUNCTION(const char*, jack_port_type, (const jack_port_t *port), (port));
 
158
DECL_FUNCTION(jack_port_type_id_t, jack_port_type_id, (const jack_port_t *port), (port));
 
159
DECL_FUNCTION(int, jack_port_is_mine, (const jack_client_t *client, const jack_port_t* port), (client, port));
 
160
DECL_FUNCTION(int, jack_port_connected, (const jack_port_t *port), (port));
 
161
DECL_FUNCTION(int, jack_port_connected_to, (const jack_port_t *port, const char *port_name), (port, port_name));
 
162
DECL_FUNCTION(const char**, jack_port_get_connections, (const jack_port_t *port), (port));
 
163
DECL_FUNCTION(const char**, jack_port_get_all_connections, (const jack_client_t *client,const jack_port_t *port), (client, port));
 
164
DECL_FUNCTION(int, jack_port_tie, (jack_port_t *src, jack_port_t *dst), (src, dst));
 
165
DECL_FUNCTION(int, jack_port_untie, (jack_port_t *port), (port));
 
166
DECL_FUNCTION(jack_nframes_t, jack_port_get_latency, (jack_port_t *port), (port));
 
167
DECL_FUNCTION(jack_nframes_t, jack_port_get_total_latency ,(jack_client_t * client, jack_port_t *port), (client, port));
 
168
DECL_VOID_FUNCTION(jack_port_set_latency, (jack_port_t * port, jack_nframes_t frames), (port, frames));
 
169
DECL_FUNCTION(int, jack_recompute_total_latency, (jack_client_t* client, jack_port_t* port), (client, port));
 
170
DECL_FUNCTION(int, jack_recompute_total_latencies, (jack_client_t* client),(client));
 
171
 
 
172
DECL_FUNCTION(int, jack_port_set_name, (jack_port_t *port, const char *port_name), (port, port_name));
 
173
DECL_FUNCTION(int, jack_port_set_alias, (jack_port_t *port, const char *alias), (port, alias));
 
174
DECL_FUNCTION(int, jack_port_unset_alias, (jack_port_t *port, const char *alias), (port, alias));
 
175
DECL_FUNCTION(int, jack_port_get_aliases, (const jack_port_t *port, char* const aliases[2]), (port,aliases));
 
176
DECL_FUNCTION(int, jack_port_request_monitor, (jack_port_t *port, int onoff), (port, onoff));
 
177
DECL_FUNCTION(int, jack_port_request_monitor_by_name, (jack_client_t *client, const char *port_name, int onoff), (client, port_name, onoff));
 
178
DECL_FUNCTION(int, jack_port_ensure_monitor, (jack_port_t *port, int onoff), (port, onoff));
 
179
DECL_FUNCTION(int, jack_port_monitoring_input, (jack_port_t *port) ,(port));
 
180
DECL_FUNCTION(int, jack_connect, (jack_client_t * client, const char *source_port, const char *destination_port), (client, source_port, destination_port));
 
181
DECL_FUNCTION(int, jack_disconnect, (jack_client_t * client, const char *source_port, const char *destination_port), (client, source_port, destination_port));
 
182
DECL_FUNCTION(int, jack_port_disconnect, (jack_client_t * client, jack_port_t * port), (client, port));
 
183
DECL_FUNCTION(int, jack_port_name_size,(),());
 
184
DECL_FUNCTION(int, jack_port_type_size,(),());
 
185
            
 
186
DECL_FUNCTION(jack_nframes_t, jack_get_sample_rate, (jack_client_t *client), (client));
 
187
DECL_FUNCTION(jack_nframes_t, jack_get_buffer_size, (jack_client_t *client), (client));
 
188
DECL_FUNCTION(const char**, jack_get_ports, (jack_client_t *client, const char *port_name_pattern, const char * type_name_pattern,
 
189
                                             unsigned long flags), (client, port_name_pattern, type_name_pattern, flags));
 
190
DECL_FUNCTION(jack_port_t *, jack_port_by_name, (jack_client_t * client, const char *port_name), (client, port_name));
 
191
DECL_FUNCTION(jack_port_t *, jack_port_by_id, (jack_client_t *client, jack_port_id_t port_id), (client, port_id));
 
192
 
 
193
DECL_FUNCTION(int, jack_engine_takeover_timebase, (jack_client_t * client), (client));
 
194
DECL_FUNCTION(jack_nframes_t, jack_frames_since_cycle_start, (const jack_client_t * client), (client));
 
195
DECL_FUNCTION(jack_time_t, jack_get_time, (), ());
 
196
DECL_FUNCTION(jack_nframes_t, jack_time_to_frames, (const jack_client_t *client, jack_time_t time), (client, time));
 
197
DECL_FUNCTION(jack_time_t, jack_frames_to_time, (const jack_client_t *client, jack_nframes_t frames), (client, frames));
 
198
DECL_FUNCTION(jack_nframes_t, jack_frame_time, (const jack_client_t *client), (client));
 
199
DECL_FUNCTION(jack_nframes_t, jack_last_frame_time, (const jack_client_t *client), (client));
 
200
DECL_FUNCTION(float, jack_cpu_load, (jack_client_t *client), (client));
 
201
DECL_FUNCTION(pthread_t, jack_client_thread_id, (jack_client_t *client), (client));
 
202
DECL_VOID_FUNCTION(jack_set_error_function, (print_function fun), (fun));
 
203
DECL_VOID_FUNCTION(jack_set_info_function, (print_function fun), (fun));
 
204
 
 
205
DECL_FUNCTION(float, jack_get_max_delayed_usecs, (jack_client_t *client), (client));
 
206
DECL_FUNCTION(float, jack_get_xrun_delayed_usecs, (jack_client_t *client), (client));
 
207
DECL_VOID_FUNCTION(jack_reset_max_delayed_usecs, (jack_client_t *client), (client));
 
208
 
 
209
DECL_FUNCTION(int, jack_release_timebase, (jack_client_t *client), (client));
 
210
DECL_FUNCTION(int, jack_set_sync_callback, (jack_client_t *client, JackSyncCallback sync_callback, void *arg), (client, sync_callback, arg));
 
211
DECL_FUNCTION(int, jack_set_sync_timeout, (jack_client_t *client, jack_time_t timeout), (client, timeout));
 
212
DECL_FUNCTION(int, jack_set_timebase_callback, (jack_client_t *client, 
 
213
                                                int conditional,
 
214
                                                JackTimebaseCallback timebase_callback,
 
215
                                                void *arg), (client, conditional, timebase_callback, arg));
 
216
DECL_FUNCTION(int, jack_transport_locate, (jack_client_t *client, jack_nframes_t frame), (client, frame));
 
217
DECL_FUNCTION(jack_transport_state_t, jack_transport_query, (const jack_client_t *client, jack_position_t *pos), (client, pos));
 
218
DECL_FUNCTION(jack_nframes_t, jack_get_current_transport_frame, (const jack_client_t *client), (client));
 
219
DECL_FUNCTION(int, jack_transport_reposition, (jack_client_t *client, jack_position_t *pos), (client, pos));
 
220
DECL_VOID_FUNCTION(jack_transport_start, (jack_client_t *client), (client));
 
221
DECL_VOID_FUNCTION(jack_transport_stop, (jack_client_t *client), (client));
 
222
DECL_VOID_FUNCTION(jack_get_transport_info, (jack_client_t *client, jack_transport_info_t *tinfo), (client,tinfo));
 
223
DECL_VOID_FUNCTION(jack_set_transport_info, (jack_client_t *client, jack_transport_info_t *tinfo), (client,tinfo));
 
224
 
 
225
DECL_FUNCTION(int, jack_client_real_time_priority, (jack_client_t* client), (client));
 
226
DECL_FUNCTION(int, jack_client_max_real_time_priority, (jack_client_t* client), (client));
 
227
DECL_FUNCTION(int, jack_acquire_real_time_scheduling, (pthread_t thread, int priority), (thread, priority));
 
228
DECL_FUNCTION(int, jack_client_create_thread, (jack_client_t* client,
 
229
                                      pthread_t *thread,
 
230
                                      int priority,
 
231
                                      int realtime,     // boolean
 
232
                                      thread_routine routine,
 
233
                                      void *arg), (client, thread, priority, realtime, routine, arg));
 
234
DECL_FUNCTION(int, jack_drop_real_time_scheduling, (pthread_t thread), (thread));
 
235
 
 
236
DECL_FUNCTION(int, jack_client_stop_thread, (jack_client_t* client, pthread_t thread), (client, thread));
 
237
DECL_FUNCTION(int, jack_client_kill_thread, (jack_client_t* client, pthread_t thread), (client, thread));
 
238
#ifndef WIN32
 
239
DECL_VOID_FUNCTION(jack_set_thread_creator, (jack_thread_creator_t jtc), (jtc));
 
240
#endif
 
241
DECL_FUNCTION(char *, jack_get_internal_client_name, (jack_client_t *client, jack_intclient_t intclient), (client, intclient));
 
242
DECL_FUNCTION(jack_intclient_t, jack_internal_client_handle, (jack_client_t *client, const char *client_name, jack_status_t *status), (client, client_name, status));
 
243
/*
 
244
DECL_FUNCTION(jack_intclient_t, jack_internal_client_load, (jack_client_t *client, 
 
245
                                                            const char *client_name, 
 
246
                                                            jack_options_t options, 
 
247
                                                            jack_status_t *status
 
248
                                                            , ...), (client, client_name, options, status, ...));
 
249
*/
 
250
DECL_FUNCTION(jack_status_t, jack_internal_client_unload, (jack_client_t *client, jack_intclient_t intclient), (client, intclient));
 
251
DECL_VOID_FUNCTION(jack_free, (void* ptr), (ptr));
 
252
 
 
253
// MIDI
 
254
 
 
255
DECL_FUNCTION(jack_nframes_t, jack_midi_get_event_count, (void* port_buffer), (port_buffer));
 
256
DECL_FUNCTION(int, jack_midi_event_get, (jack_midi_event_t* event, void* port_buffer, jack_nframes_t event_index), (event, port_buffer, event_index)) ;
 
257
DECL_VOID_FUNCTION(jack_midi_clear_buffer, (void* port_buffer), (port_buffer));
 
258
DECL_FUNCTION(size_t, jack_midi_max_event_size, (void* port_buffer), (port_buffer));
 
259
DECL_FUNCTION(jack_midi_data_t*, jack_midi_event_reserve, (void* port_buffer, jack_nframes_t time, size_t data_size), (port_buffer, time, data_size));
 
260
DECL_FUNCTION(int, jack_midi_event_write, (void* port_buffer, jack_nframes_t time, const jack_midi_data_t* data, size_t data_size), (port_buffer, time, data, data_size));
 
261
DECL_FUNCTION(jack_nframes_t, jack_midi_get_lost_event_count, (void* port_buffer), (port_buffer));