1387
|
1 /*
|
|
2 *
|
|
3 * Author: Giacomo Lozito <james@develia.org>, (C) 2005-2006
|
|
4 *
|
|
5 * This program is free software; you can redistribute it and/or modify it
|
|
6 * under the terms of the GNU General Public License as published by the
|
|
7 * Free Software Foundation; either version 2 of the License, or (at your
|
|
8 * option) any later version.
|
|
9 *
|
|
10 * This program is distributed in the hope that it will be useful, but
|
|
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
13 * General Public License for more details.
|
|
14 *
|
|
15 * You should have received a copy of the GNU General Public License along
|
|
16 * with this program; if not, write to the Free Software Foundation, Inc.,
|
|
17 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
18 *
|
|
19 */
|
|
20
|
|
21 #include "b-dummy.h"
|
|
22 #include "b-dummy-config.h"
|
|
23
|
|
24 /* dummy sequencer instance */
|
|
25 static sequencer_client_t sc;
|
|
26 /* options */
|
|
27 static amidiplug_cfg_dumm_t amidiplug_cfg_dumm;
|
|
28
|
|
29
|
|
30 gint backend_info_get( gchar ** name , gchar ** longname , gchar ** desc , gint * ppos )
|
|
31 {
|
|
32 if ( name != NULL )
|
|
33 *name = g_strdup( "dummy" );
|
|
34 if ( longname != NULL )
|
|
35 *longname = g_strdup( "Dummy Backend " AMIDIPLUG_VERSION );
|
|
36 if ( desc != NULL )
|
|
37 *desc = g_strdup( _("This backend does not produce audio at all. It is mostly "
|
|
38 "useful for analysis and testing purposes, as it can log "
|
|
39 "all MIDI events to standard output, standard error or file.\n"
|
|
40 "Backend written by Giacomo Lozito.") );
|
|
41 if ( ppos != NULL )
|
|
42 *ppos = 3; /* preferred position in backend list */
|
|
43 return 1;
|
|
44 }
|
|
45
|
|
46
|
|
47 gint backend_init( void )
|
|
48 {
|
|
49 i_cfg_read(); /* read configuration options */
|
|
50
|
|
51 return 1;
|
|
52 }
|
|
53
|
|
54
|
|
55 gint backend_cleanup( void )
|
|
56 {
|
|
57 i_cfg_free(); /* free configuration options */
|
|
58
|
|
59 return 1;
|
|
60 }
|
|
61
|
|
62
|
|
63 gint sequencer_get_port_count( void )
|
|
64 {
|
|
65 return 1; /* always return a single port here */
|
|
66 }
|
|
67
|
|
68
|
|
69 gint sequencer_start( gchar * midi_fname )
|
|
70 {
|
|
71 switch( amidiplug_cfg_dumm.dumm_logger_enable )
|
|
72 {
|
|
73 case 1:
|
|
74 {
|
|
75 sc.file = stdout; /* log to standard output */
|
|
76 break;
|
|
77 }
|
|
78 case 2:
|
|
79 {
|
|
80 sc.file = stderr; /* log to standard error */
|
|
81 break;
|
|
82 }
|
|
83 case 3:
|
|
84 {
|
|
85 switch ( amidiplug_cfg_dumm.dumm_logger_lfstyle )
|
|
86 {
|
|
87 case 0:
|
|
88 {
|
|
89 sc.file = fopen( amidiplug_cfg_dumm.dumm_logger_logfile , "w" );
|
|
90 break;
|
|
91 }
|
|
92 case 1:
|
|
93 {
|
|
94 sc.file = fopen( amidiplug_cfg_dumm.dumm_logger_logfile , "a" );
|
|
95 break;
|
|
96 }
|
|
97 case 2:
|
|
98 {
|
|
99 gchar *midi_basefname = G_PATH_GET_BASENAME( midi_fname );
|
|
100 gchar *logfile = g_strjoin( "" , amidiplug_cfg_dumm.dumm_logger_logdir ,
|
|
101 "/" , midi_basefname , ".log" , NULL );
|
|
102 sc.file = fopen( logfile , "w" );
|
|
103 g_free( logfile );
|
|
104 g_free( midi_basefname );
|
|
105 break;
|
|
106 }
|
|
107 default: /* shouldn't happen, let's handle this anyway */
|
|
108 {
|
|
109 sc.file = NULL;
|
|
110 break;
|
|
111 }
|
|
112 }
|
|
113 break;
|
|
114 }
|
|
115 case 0:
|
|
116 default:
|
|
117 {
|
|
118 sc.file = NULL;
|
|
119 break;
|
|
120 }
|
|
121 }
|
|
122
|
|
123 if (( sc.file == NULL ) && ( amidiplug_cfg_dumm.dumm_logger_enable != 0 ))
|
|
124 {
|
|
125 DEBUGMSG( "Unable to get a FILE pointer\n" );
|
|
126 return 0;
|
|
127 }
|
|
128 else
|
|
129 return 1; /* success */
|
|
130 }
|
|
131
|
|
132
|
|
133 gint sequencer_stop( void )
|
|
134 {
|
|
135 if (( sc.file != NULL ) && ( amidiplug_cfg_dumm.dumm_logger_enable == 3 ))
|
|
136 fclose( sc.file );
|
|
137
|
|
138 return 1; /* success */
|
|
139 }
|
|
140
|
|
141
|
|
142 /* activate sequencer client */
|
|
143 gint sequencer_on( void )
|
|
144 {
|
|
145 sc.tick_offset = 0;
|
|
146 if ( amidiplug_cfg_dumm.dumm_playback_speed == 0 )
|
|
147 sc.timer_seq = g_timer_new(); /* create the sequencer timer */
|
|
148 return 1; /* success */
|
|
149 }
|
|
150
|
|
151
|
|
152 /* shutdown sequencer client */
|
|
153 gint sequencer_off( void )
|
|
154 {
|
|
155 if (( amidiplug_cfg_dumm.dumm_playback_speed == 0 ) && ( sc.timer_seq != NULL ))
|
|
156 {
|
|
157 g_timer_destroy( sc.timer_seq ); /* destroy the sequencer timer */
|
|
158 sc.timer_seq = NULL;
|
|
159 }
|
|
160 return 1; /* success */
|
|
161 }
|
|
162
|
|
163
|
|
164 /* queue set tempo */
|
|
165 gint sequencer_queue_tempo( gint tempo , gint ppq )
|
|
166 {
|
|
167 sc.ppq = ppq;
|
|
168 sc.usec_per_tick = (gdouble)tempo / (gdouble)ppq;
|
|
169 return 1;
|
|
170 }
|
|
171
|
|
172
|
|
173 gint sequencer_queue_start( void )
|
|
174 {
|
|
175 if ( amidiplug_cfg_dumm.dumm_playback_speed == 0 )
|
|
176 g_timer_start( sc.timer_seq ); /* reset the sequencer timer */
|
|
177 return 1;
|
|
178 }
|
|
179
|
|
180
|
|
181 gint sequencer_event_init( void )
|
|
182 {
|
|
183 /* common settings for all our events */
|
|
184 return 1;
|
|
185 }
|
|
186
|
|
187
|
|
188 gint sequencer_event_noteon( midievent_t * event )
|
|
189 {
|
|
190 i_sleep( event->tick_real );
|
|
191 i_printf( sc.file , "NOTEON : ti %i : ch %i : no %i : ve %i\n" ,
|
|
192 event->tick , event->data.d[0] , event->data.d[1] , event->data.d[2] );
|
|
193 return 1;
|
|
194 }
|
|
195
|
|
196
|
|
197 gint sequencer_event_noteoff( midievent_t * event )
|
|
198 {
|
|
199 i_sleep( event->tick_real );
|
|
200 i_printf( sc.file , "NOTEOFF : ti %i : ch %i : no %i : ve %i\n" ,
|
|
201 event->tick , event->data.d[0] , event->data.d[1] , event->data.d[2] );
|
|
202 return 1;
|
|
203 }
|
|
204
|
|
205
|
|
206 gint sequencer_event_keypress( midievent_t * event )
|
|
207 {
|
|
208 i_sleep( event->tick_real );
|
|
209 i_printf( sc.file , "KEYPRESS : ti %i : ch %i : no %i : ve %i\n" ,
|
|
210 event->tick , event->data.d[0] , event->data.d[1] , event->data.d[2] );
|
|
211 return 1;
|
|
212 }
|
|
213
|
|
214
|
|
215 gint sequencer_event_controller( midievent_t * event )
|
|
216 {
|
|
217 i_sleep( event->tick_real );
|
|
218 i_printf( sc.file , "CONTROLLER : ti %i : ch %i : pa %i : va %i\n" ,
|
|
219 event->tick , event->data.d[0] , event->data.d[1] , event->data.d[2] );
|
|
220 return 1;
|
|
221 }
|
|
222
|
|
223
|
|
224 gint sequencer_event_pgmchange( midievent_t * event )
|
|
225 {
|
|
226 i_sleep( event->tick_real );
|
|
227 i_printf( sc.file , "PGMCHANGE : ti %i : ch %i : va %i\n" ,
|
|
228 event->tick , event->data.d[0] , event->data.d[1] );
|
|
229 return 1;
|
|
230 }
|
|
231
|
|
232
|
|
233 gint sequencer_event_chanpress( midievent_t * event )
|
|
234 {
|
|
235 i_sleep( event->tick_real );
|
|
236 i_printf( sc.file , "CHANPRESS : ti %i : ch %i : va %i\n" ,
|
|
237 event->tick , event->data.d[0] , event->data.d[1] );
|
|
238 return 1;
|
|
239 }
|
|
240
|
|
241
|
|
242 gint sequencer_event_pitchbend( midievent_t * event )
|
|
243 {
|
|
244 i_sleep( event->tick_real );
|
|
245 i_printf( sc.file , "PITCHBEND : ti %i : ch %i : va %i\n" ,
|
|
246 event->tick , event->data.d[0] ,
|
|
247 ((((event->data.d[2]) & 0x7f) << 7) | ((event->data.d[1]) & 0x7f)) );
|
|
248 return 1;
|
|
249 }
|
|
250
|
|
251
|
|
252 gint sequencer_event_sysex( midievent_t * event )
|
|
253 {
|
|
254 i_sleep( event->tick_real );
|
|
255 i_printf( sc.file , "SYSEX : ti %i\n" ,
|
|
256 event->tick );
|
|
257 return 1;
|
|
258 }
|
|
259
|
|
260
|
|
261 gint sequencer_event_tempo( midievent_t * event )
|
|
262 {
|
|
263 i_sleep( event->tick_real );
|
|
264 i_printf( sc.file , "TEMPOCHANGE : ti %i : va %i\n" ,
|
|
265 event->tick , event->data.tempo );
|
|
266 sc.usec_per_tick = (gdouble)event->data.tempo / (gdouble)sc.ppq;
|
|
267 if ( amidiplug_cfg_dumm.dumm_playback_speed == 0 )
|
|
268 g_timer_start( sc.timer_seq ); /* reset the sequencer timer */
|
|
269 sc.tick_offset = event->tick_real;
|
|
270 return 1;
|
|
271 }
|
|
272
|
|
273
|
|
274 gint sequencer_event_other( midievent_t * event )
|
|
275 {
|
|
276 return 1;
|
|
277 }
|
|
278
|
|
279
|
|
280 gint sequencer_output( gpointer * buffer , gint * len )
|
|
281 {
|
|
282 return 0;
|
|
283 }
|
|
284
|
|
285
|
|
286 gint sequencer_output_shut( guint max_tick , gint skip_offset )
|
|
287 {
|
|
288 return 1;
|
|
289 }
|
|
290
|
|
291
|
|
292 /* unimplemented (useless for dummy backend) */
|
|
293 gint audio_volume_get( gint * left_volume , gint * right_volume )
|
|
294 {
|
|
295 return 0;
|
|
296 }
|
|
297 gint audio_volume_set( gint left_volume , gint right_volume )
|
|
298 {
|
|
299 return 0;
|
|
300 }
|
|
301
|
|
302
|
|
303 gint audio_info_get( gint * channels , gint * bitdepth , gint * samplerate )
|
|
304 {
|
|
305 /* not applicable for dummy backend */
|
|
306 *channels = -1;
|
|
307 *bitdepth = -1;
|
|
308 *samplerate = -1;
|
|
309 return 0; /* not valid information */
|
|
310 }
|
|
311
|
|
312
|
|
313 gboolean audio_check_autonomous( void )
|
|
314 {
|
|
315 return TRUE; /* Dummy deals itself with audio (well, it doesn't produce any at all :)) */
|
|
316 }
|
|
317
|
|
318
|
|
319
|
|
320 /* ******************************************************************
|
|
321 *** INTERNALS ****************************************************
|
|
322 ****************************************************************** */
|
|
323
|
|
324
|
|
325 void i_sleep( guint tick )
|
|
326 {
|
|
327 if ( amidiplug_cfg_dumm.dumm_playback_speed == 0 )
|
|
328 {
|
|
329 gdouble elapsed_tick_usecs = (gdouble)(tick - sc.tick_offset) * sc.usec_per_tick;
|
|
330 gdouble elapsed_seq_usecs = g_timer_elapsed( sc.timer_seq , NULL ) * 1000000;
|
|
331 if ( elapsed_seq_usecs < elapsed_tick_usecs )
|
|
332 {
|
|
333 G_USLEEP( elapsed_tick_usecs - elapsed_seq_usecs );
|
|
334 }
|
|
335 }
|
|
336 }
|
|
337
|
|
338
|
|
339 void i_printf( FILE * fp , const gchar * format , ... )
|
|
340 {
|
|
341 va_list args;
|
|
342 va_start( args , format );
|
|
343 if ( fp != NULL )
|
|
344 G_VFPRINTF( fp , format , args );
|
|
345 va_end( args );
|
|
346 }
|
|
347
|
|
348
|
|
349 void i_cfg_read( void )
|
|
350 {
|
|
351 pcfg_t *cfgfile;
|
|
352 gchar * def_logfile = g_strjoin( "" , g_get_home_dir() , "/amidi-plug.log" , NULL );
|
|
353 gchar * def_logdir = (gchar*)g_get_home_dir();
|
|
354 gchar * config_pathfilename = g_strjoin( "" , g_get_home_dir() , "/" ,
|
|
355 PLAYER_LOCALRCDIR , "/amidi-plug.conf" , NULL );
|
|
356 cfgfile = i_pcfg_new_from_file( config_pathfilename );
|
|
357
|
|
358 if ( !cfgfile )
|
|
359 {
|
|
360 /* fluidsynth backend defaults */
|
|
361 amidiplug_cfg_dumm.dumm_logger_enable = 0;
|
|
362 amidiplug_cfg_dumm.dumm_logger_lfstyle = 0;
|
|
363 amidiplug_cfg_dumm.dumm_playback_speed = 0;
|
|
364 amidiplug_cfg_dumm.dumm_logger_logfile = g_strdup( def_logfile );
|
|
365 amidiplug_cfg_dumm.dumm_logger_logdir = g_strdup( def_logdir );
|
|
366 }
|
|
367 else
|
|
368 {
|
|
369 i_pcfg_read_integer( cfgfile , "dumm" , "dumm_logger_enable" ,
|
|
370 &amidiplug_cfg_dumm.dumm_logger_enable , 0 );
|
|
371 i_pcfg_read_integer( cfgfile , "dumm" , "dumm_logger_lfstyle" ,
|
|
372 &amidiplug_cfg_dumm.dumm_logger_lfstyle , 0 );
|
|
373 i_pcfg_read_integer( cfgfile , "dumm" , "dumm_playback_speed" ,
|
|
374 &amidiplug_cfg_dumm.dumm_playback_speed , 0 );
|
|
375 i_pcfg_read_string( cfgfile , "dumm" , "dumm_logger_logfile" ,
|
|
376 &amidiplug_cfg_dumm.dumm_logger_logfile , def_logfile );
|
|
377 i_pcfg_read_string( cfgfile , "dumm" , "dumm_logger_logdir" ,
|
|
378 &amidiplug_cfg_dumm.dumm_logger_logdir , def_logdir );
|
|
379
|
|
380 i_pcfg_free( cfgfile );
|
|
381 }
|
|
382
|
|
383 g_free( config_pathfilename );
|
|
384 g_free( def_logfile );
|
|
385 }
|
|
386
|
|
387
|
|
388 void i_cfg_free( void )
|
|
389 {
|
|
390 g_free( amidiplug_cfg_dumm.dumm_logger_logfile );
|
|
391 g_free( amidiplug_cfg_dumm.dumm_logger_logdir );
|
|
392 }
|