/[svn]/liblscp/trunk/src/device.c
ViewVC logotype

Contents of /liblscp/trunk/src/device.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 125 - (show annotations) (download)
Mon Jun 14 21:04:04 2004 UTC (15 years, 9 months ago) by capela
File MIME type: text/plain
File size: 20643 byte(s)
* Added support for the new LIST commands (draft v.08).

1 // device.c
2 //
3 /****************************************************************************
4 liblscp - LinuxSampler Control Protocol API
5 Copyright (C) 2004, rncbc aka Rui Nuno Capela. All rights reserved.
6
7 This library is free software; you can redistribute it and/or
8 modify it under the terms of the GNU Lesser General Public
9 License as published by the Free Software Foundation; either
10 version 2.1 of the License, or (at your option) any later version.
11
12 This library is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 Lesser General Public License for more details.
16
17 You should have received a copy of the GNU Lesser General Public
18 License along with this library; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20
21 *****************************************************************************/
22
23 #include "common.h"
24
25
26 // Local prototypes.
27
28 static lscp_driver_info_t *_lscp_driver_info_query (lscp_client_t *pClient, lscp_driver_info_t *pDriverInfo, const char *pszQuery);
29
30
31 //-------------------------------------------------------------------------
32 // Local funtions.
33
34 // Common driver type query command.
35 static lscp_driver_info_t *_lscp_driver_info_query ( lscp_client_t *pClient, lscp_driver_info_t *pDriverInfo, const char *pszQuery )
36 {
37 const char *pszResult;
38 const char *pszSeps = ":";
39 const char *pszCrlf = "\r\n";
40 char *pszToken;
41 char *pch;
42
43 lscp_driver_info_reset(pDriverInfo);
44
45 if (lscp_client_query(pClient, pszQuery) != LSCP_OK)
46 return NULL;
47
48 pszResult = lscp_client_get_result(pClient);
49 pszToken = lscp_strtok((char *) pszResult, pszSeps, &(pch));
50 while (pszToken) {
51 if (strcasecmp(pszToken, "DESCRIPTION") == 0) {
52 pszToken = lscp_strtok(NULL, pszCrlf, &(pch));
53 if (pszToken)
54 pDriverInfo->description = lscp_unquote(&pszToken, 1);
55 }
56 else if (strcasecmp(pszToken, "VERSION") == 0) {
57 pszToken = lscp_strtok(NULL, pszCrlf, &(pch));
58 if (pszToken)
59 pDriverInfo->version = lscp_unquote(&pszToken, 1);
60 }
61 else if (strcasecmp(pszToken, "PARAMETERS") == 0) {
62 pszToken = lscp_strtok(NULL, pszCrlf, &(pch));
63 if (pszToken)
64 pDriverInfo->parameters = lscp_szsplit_create(pszToken, ",");
65 }
66 pszToken = lscp_strtok(NULL, pszSeps, &(pch));
67 }
68
69 return pDriverInfo;
70 }
71
72
73 //-------------------------------------------------------------------------
74 // Audio driver control functions.
75
76 /**
77 * Getting all available audio output drivers.
78 * GET AVAILABLE_AUDIO_OUTPUT_DRIVERS
79 *
80 * @param pClient Pointer to client instance structure.
81 *
82 * @returns A NULL terminated array of audio output driver type
83 * name strings, or NULL in case of failure.
84 */
85 const char ** lscp_get_available_audio_drivers ( lscp_client_t *pClient )
86 {
87 const char *pszSeps = ",";
88
89 if (pClient->audio_drivers) {
90 lscp_szsplit_destroy(pClient->audio_drivers);
91 pClient->audio_drivers = NULL;
92 }
93
94 if (lscp_client_query(pClient, "GET AVAILABLE_AUDIO_OUTPUT_DRIVERS\r\n") == LSCP_OK)
95 pClient->audio_drivers = lscp_szsplit_create(lscp_client_get_result(pClient), pszSeps);
96
97 return (const char **) pClient->audio_drivers;
98 }
99
100
101 /**
102 * Getting informations about a specific audio output driver.
103 * GET AUDIO_OUTPUT_DRIVER INFO <audio-output-type>
104 *
105 * @param pClient Pointer to client instance structure.
106 * @param pszAudioDriver Audio driver type string (e.g. "ALSA").
107 *
108 * @returns A pointer to a @ref lscp_driver_info_t structure, with
109 * the given audio driver information, or NULL in case of failure.
110 */
111 lscp_driver_info_t* lscp_get_audio_driver_info ( lscp_client_t *pClient, const char *pszAudioDriver )
112 {
113 char szQuery[LSCP_BUFSIZ];
114
115 if (pszAudioDriver == NULL)
116 return NULL;
117
118 sprintf(szQuery, "GET AUDIO_OUTPUT_DRIVER INFO %s\r\n", pszAudioDriver);
119 return _lscp_driver_info_query(pClient, &(pClient->audio_info), szQuery);
120 }
121
122
123 /**
124 * Getting informations about specific audio output driver parameter.
125 * GET AUDIO_OUTPUT_DRIVER_PARAMETER INFO <audio-output-driver> <param> [<dep-list>]
126 *
127 * @param pClient Pointer to client instance structure.
128 * @param pszAudioDriver Audio driver type string (e.g. "ALSA").
129 * @param pszParam Audio driver parameter name.
130 * @param pDepList Pointer to specific dependencies parameter list.
131 *
132 * @returns A pointer to a @ref lscp_param_info_t structure, with
133 * the given audio driver parameter information, or NULL in case of failure.
134 */
135 lscp_param_info_t *lscp_get_audio_driver_param_info ( lscp_client_t *pClient, const char *pszAudioDriver, const char *pszParam, lscp_param_t *pDepList )
136 {
137 lscp_param_info_t *pParamInfo = NULL;
138
139 if (pClient == NULL)
140 return NULL;
141 if (pszAudioDriver == NULL)
142 return NULL;
143 if (pszParam == NULL)
144 return NULL;
145 if (pDepList == NULL)
146 return NULL;
147
148 return pParamInfo;
149 }
150
151
152 //-------------------------------------------------------------------------
153 // Audio device control functions.
154
155 /**
156 * Creating an audio output device.
157 * CREATE AUDIO_OUTPUT_DEVICE <audio-output-driver> [<params>]
158 *
159 * @param pClient Pointer to client instance structure.
160 * @param pszAudioDriver Audio driver type string (e.g. "ALSA").
161 * @param pParams Pointer to specific parameter list.
162 *
163 * @returns The new audio device number identifier on success,
164 * or -1 in case of failure.
165 */
166 int lscp_create_audio_device ( lscp_client_t *pClient, const char *pszAudioDriver, lscp_param_t *pParams )
167 {
168 int iAudioDevice = -1;
169
170 if (pClient == NULL)
171 return -1;
172 if (pszAudioDriver == NULL)
173 return -1;
174 if (pParams == NULL)
175 return -1;
176
177 return iAudioDevice;
178 }
179
180
181 /**
182 * Destroying an audio output device.
183 * DESTROY AUDIO_OUTPUT_DEVICE <audio-device-id>
184 *
185 * @param pClient Pointer to client instance structure.
186 * @param iAudioDevice Audio device number identifier.
187 *
188 * @returns LSCP_OK on success, LSCP_FAILED otherwise.
189 */
190 lscp_status_t lscp_destroy_audio_device ( lscp_client_t *pClient, int iAudioDevice )
191 {
192 lscp_status_t ret = LSCP_FAILED;
193
194 if (pClient == NULL)
195 return ret;
196 if (iAudioDevice < 0)
197 return ret;
198
199 return ret;
200 }
201
202
203 /**
204 * Getting all created audio output device count.
205 * GET AUDIO_OUTPUT_DEVICES
206 *
207 * @param pClient Pointer to client instance structure.
208 *
209 * @returns The current total number of audio devices on success,
210 * -1 otherwise.
211 */
212 int lscp_get_audio_devices ( lscp_client_t *pClient )
213 {
214 int iAudioDevices = -1;
215 if (lscp_client_query(pClient, "GET AUDIO_OUTPUT_DEVICES\r\n") == LSCP_OK)
216 iAudioDevices = atoi(lscp_client_get_result(pClient));
217 return iAudioDevices;
218 }
219
220
221 /**
222 * Getting all created audio output device list.
223 * LIST AUDIO_OUTPUT_DEVICES
224 *
225 * @param pClient Pointer to client instance structure.
226 *
227 * @returns An array of audio device number identifiers,
228 * terminated with -1 on success, or NULL in case of failure.
229 */
230 int *lscp_list_audio_devices ( lscp_client_t *pClient )
231 {
232 const char *pszSeps = ",";
233
234 if (pClient == NULL)
235 return NULL;
236
237 if (pClient->audio_devices) {
238 lscp_isplit_destroy(pClient->audio_devices);
239 pClient->audio_devices = NULL;
240 }
241
242 if (lscp_client_query(pClient, "LIST AUDIO_OUTPUT_DEVICES\r\n") == LSCP_OK)
243 pClient->audio_devices = lscp_isplit_create(lscp_client_get_result(pClient), pszSeps);
244
245 return pClient->audio_devices;
246 }
247
248
249 /**
250 * Getting current settings of an audio output device.
251 * GET AUDIO_OUTPUT_DEVICE INFO <audio-device-id>
252 *
253 * @param pClient Pointer to client instance structure.
254 * @param iAudioDevice Audio device number identifier.
255 *
256 * @returns A pointer to a @ref lscp_device_info_t structure, with
257 * the given audio device information, or NULL in case of failure.
258 */
259 lscp_device_info_t *lscp_get_audio_device_info ( lscp_client_t *pClient, int iAudioDevice )
260 {
261 lscp_device_info_t *pDeviceInfo = NULL;
262
263 if (pClient == NULL)
264 return NULL;
265 if (iAudioDevice < 0)
266 return NULL;
267
268 return pDeviceInfo;
269 }
270
271
272 /**
273 * Changing settings of audio output devices.
274 * SET AUDIO_OUTPUT_DEVICE_PARAMETER <audio-device-id> <param> <value>
275 *
276 * @param pClient Pointer to client instance structure.
277 * @param iAudioDevice Audio device number identifier.
278 * @param pParam Pointer to a key-valued audio device parameter.
279 *
280 * @returns LSCP_OK on success, LSCP_FAILED otherwise.
281 */
282 lscp_status_t lscp_set_audio_device_param ( lscp_client_t *pClient, int iAudioDevice, lscp_param_t *pParam )
283 {
284 lscp_status_t ret = LSCP_FAILED;
285
286 if (pClient == NULL)
287 return ret;
288 if (iAudioDevice < 0)
289 return ret;
290 if (pParam == NULL)
291 return ret;
292
293 return ret;
294 }
295
296
297 /**
298 * Getting informations about an audio channel.
299 * GET AUDIO_OUTPUT_CHANNEL INFO <audio-device-id> <audio-channel>
300 *
301 * @param pClient Pointer to client instance structure.
302 * @param iAudioDevice Audio device number identifier.
303 * @param iAudioChannel Audio channel number.
304 *
305 * @returns A pointer to a @ref lscp_device_channel_info_t structure,
306 * with the given audio channel information, or NULL in case of failure.
307 */
308 lscp_device_channel_info_t* lscp_get_audio_channel_info ( lscp_client_t *pClient, int iAudioDevice, int iAudioChannel )
309 {
310 lscp_device_channel_info_t *pDevChannelInfo = NULL;
311
312 if (pClient == NULL)
313 return NULL;
314 if (iAudioDevice < 0)
315 return NULL;
316 if (iAudioChannel < 0)
317 return NULL;
318
319 return pDevChannelInfo;
320 }
321
322
323 /**
324 * Getting informations about specific audio channel parameter.
325 * GET AUDIO_OUTPUT_CHANNEL_PARAMETER INFO <audio-device-id> <audio-channel> <param>
326 *
327 * @param pClient Pointer to client instance structure.
328 * @param iAudioDevice Audio device number identifier.
329 * @param iAudioChannel Audio channel number.
330 * @param pszParam Audio channel parameter name.
331 *
332 * @returns A pointer to a @ref lscp_param_info_t structure, with
333 * the given audio channel parameter information, or NULL in case of failure.
334 */
335 lscp_param_info_t* lscp_get_audio_channel_param_info ( lscp_client_t *pClient, int iAudioDevice, int iAudioChannel, const char *pszParam )
336 {
337 lscp_param_info_t *pParamInfo = NULL;
338
339 if (pClient == NULL)
340 return NULL;
341 if (iAudioDevice < 0)
342 return NULL;
343 if (iAudioChannel < 0)
344 return NULL;
345 if (pszParam == NULL)
346 return NULL;
347
348 return pParamInfo;
349 }
350
351
352 /**
353 * Changing settings of audio output channels.
354 * SET AUDIO_OUTPUT_CHANNEL_PARAMETER <audio-device-id> <audio-channel> <param> <value>
355 *
356 * @param pClient Pointer to client instance structure.
357 * @param iAudioDevice Audio device number identifier.
358 * @param iAudioChannel Audio channel number.
359 * @param pParam Pointer to a key-valued audio channel parameter.
360 *
361 * @returns LSCP_OK on success, LSCP_FAILED otherwise.
362 */
363 lscp_status_t lscp_set_audio_channel_param ( lscp_client_t *pClient, int iAudioDevice, int iAudioChannel, lscp_param_t *pParam )
364 {
365 lscp_status_t ret = LSCP_FAILED;
366
367 if (pClient == NULL)
368 return ret;
369 if (iAudioDevice < 0)
370 return ret;
371 if (iAudioChannel < 0)
372 return ret;
373 if (pParam == NULL)
374 return ret;
375
376 return ret;
377 }
378
379
380 //-------------------------------------------------------------------------
381 // MIDI driver control functions.
382
383 /**
384 * Getting all available MIDI input drivers.
385 * GET AVAILABLE_MIDI_INPUT_DRIVERS
386 *
387 * @param pClient Pointer to client instance structure.
388 *
389 * @returns A NULL terminated array of MIDI input driver type
390 * name strings, or NULL in case of failure.
391 */
392 const char** lscp_get_available_midi_drivers ( lscp_client_t *pClient )
393 {
394 const char *pszSeps = ",";
395
396 if (pClient->midi_drivers) {
397 lscp_szsplit_destroy(pClient->midi_drivers);
398 pClient->midi_drivers = NULL;
399 }
400
401 if (lscp_client_query(pClient, "GET AVAILABLE_MIDI_INPUT_DRIVERS\r\n") == LSCP_OK)
402 pClient->midi_drivers = lscp_szsplit_create(lscp_client_get_result(pClient), pszSeps);
403
404 return (const char **) pClient->midi_drivers;
405 }
406
407
408 /**
409 * Getting informations about a specific MIDI input driver.
410 * GET MIDI_INPUT_DRIVER INFO <midi-input-type>
411 *
412 * @param pClient Pointer to client instance structure.
413 * @param pszMidiDriver MIDI driver type string (e.g. "ALSA").
414 *
415 * @returns A pointer to a @ref lscp_driver_info_t structure, with
416 * the given MIDI driver information, or NULL in case of failure.
417 */
418 lscp_driver_info_t* lscp_get_midi_driver_info ( lscp_client_t *pClient, const char *pszMidiDriver )
419 {
420 char szQuery[LSCP_BUFSIZ];
421
422 if (pszMidiDriver == NULL)
423 return NULL;
424
425 sprintf(szQuery, "GET MIDI_INPUT_DRIVER INFO %s\r\n", pszMidiDriver);
426 return _lscp_driver_info_query(pClient, &(pClient->midi_info), szQuery);
427 }
428
429
430 /**
431 * Getting informations about specific MIDI input driver parameter.
432 * GET MIDI_INPUT_DRIVER_PARAMETER INFO <midi-input-driver> <param> [<dep-list>]
433 *
434 * @param pClient Pointer to client instance structure.
435 * @param pszMidiDriver MIDI driver type string (e.g. "ALSA").
436 * @param pszParam MIDI driver parameter name.
437 * @param pDepList Pointer to specific dependencies parameter list.
438 *
439 * @returns A pointer to a @ref lscp_param_info_t structure, with
440 * the given MIDI driver parameter information, or NULL in case of failure.
441 *
442 * @returns LSCP_OK on success, LSCP_FAILED otherwise.
443 */
444 lscp_param_info_t *lscp_get_midi_driver_param_info ( lscp_client_t *pClient, const char *pszMidiDriver, const char *pszParam, lscp_param_t *pDepList )
445 {
446 lscp_param_info_t *pParamInfo = NULL;
447
448 if (pClient == NULL)
449 return NULL;
450 if (pszMidiDriver == NULL)
451 return NULL;
452 if (pszParam == NULL)
453 return NULL;
454 if (pDepList == NULL)
455 return NULL;
456
457 return pParamInfo;
458 }
459
460
461 //-------------------------------------------------------------------------
462 // MIDI device control functions.
463
464 /**
465 * Creating a MIDI input device.
466 * CREATE MIDI_INPUT_DEVICE <midi-input-driver> [<params>]
467 *
468 * @param pClient Pointer to client instance structure.
469 * @param pszMidiDriver MIDI driver type string (e.g. "ALSA").
470 * @param pParams Pointer to specific parameter list.
471 *
472 * @returns The new audio device number identifier on success,
473 * or -1 in case of failure.
474 */
475 int lscp_create_midi_device ( lscp_client_t *pClient, const char *pszMidiDriver, lscp_param_t *pParams )
476 {
477 int iMidiDevice = -1;
478
479 if (pClient == NULL)
480 return -1;
481 if (pszMidiDriver == NULL)
482 return -1;
483 if (pParams == NULL)
484 return -1;
485
486 return iMidiDevice;
487 }
488
489
490 /**
491 * Destroying a MIDI input device.
492 * DESTROY MIDI_INPUT_DEVICE <midi-device-id>
493 *
494 * @param pClient Pointer to client instance structure.
495 * @param iMidiDevice MIDI device number identifier.
496 *
497 * @returns LSCP_OK on success, LSCP_FAILED otherwise.
498 */
499 lscp_status_t lscp_destroy_midi_device ( lscp_client_t *pClient, int iMidiDevice )
500 {
501 lscp_status_t ret = LSCP_FAILED;
502
503 if (pClient == NULL)
504 return ret;
505 if (iMidiDevice < 0)
506 return ret;
507
508 return ret;
509 }
510
511
512 /**
513 * Getting all created MIDI intput device count.
514 * GET MIDI_INPUT_DEVICES
515 *
516 * @param pClient Pointer to client instance structure.
517 *
518 * @returns The current total number of MIDI devices on success,
519 * -1 otherwise.
520 */
521 int lscp_get_midi_devices ( lscp_client_t *pClient )
522 {
523 int iMidiDevices = -1;
524 if (lscp_client_query(pClient, "GET MIDI_INPUT_DEVICES\r\n") == LSCP_OK)
525 iMidiDevices = atoi(lscp_client_get_result(pClient));
526 return iMidiDevices;
527 }
528
529
530 /**
531 * Getting all created MIDI intput device list.
532 * LIST MIDI_INPUT_DEVICES
533 *
534 * @param pClient Pointer to client instance structure.
535 *
536 * @returns An array of MIDI device number identifiers,
537 * terminated with -1 on success, or NULL in case of failure.
538 */
539 int *lscp_list_midi_devices ( lscp_client_t *pClient )
540 {
541 const char *pszSeps = ",";
542
543 if (pClient == NULL)
544 return NULL;
545
546 if (pClient->midi_devices) {
547 lscp_isplit_destroy(pClient->midi_devices);
548 pClient->midi_devices = NULL;
549 }
550
551 if (lscp_client_query(pClient, "LIST MIDI_INPUT_DEVICES\r\n") == LSCP_OK)
552 pClient->midi_devices = lscp_isplit_create(lscp_client_get_result(pClient), pszSeps);
553
554 return pClient->midi_devices;
555 }
556
557
558 /**
559 * Getting current settings of a MIDI input device.
560 * GET MIDI_INPUT_DEVICE INFO <midi-device-id>
561 *
562 * @param pClient Pointer to client instance structure.
563 * @param iMidiDevice MIDI device number identifier.
564 *
565 * @returns A pointer to a @ref lscp_device_info_t structure, with
566 * the given MIDI device information, or NULL in case of failure.
567 */
568 lscp_device_info_t* lscp_get_midi_device_info ( lscp_client_t *pClient, int iMidiDevice )
569 {
570 lscp_device_info_t *pDeviceInfo = NULL;
571
572 if (pClient == NULL)
573 return NULL;
574 if (iMidiDevice < 0)
575 return NULL;
576
577 return pDeviceInfo;
578 }
579
580
581 /**
582 * Changing settings of MIDI input devices.
583 * SET MIDI_INPUT_DEVICE_PARAMETER <midi-device-id> <param> <value>
584 *
585 * @param pClient Pointer to client instance structure.
586 * @param iMidiDevice MIDI device number identifier.
587 * @param pParam Pointer to a key-valued MIDI device parameter.
588 *
589 * @returns LSCP_OK on success, LSCP_FAILED otherwise.
590 */
591 lscp_status_t lscp_set_midi_device_param ( lscp_client_t *pClient, int iMidiDevice, lscp_param_t *pParam )
592 {
593 lscp_status_t ret = LSCP_FAILED;
594
595 if (pClient == NULL)
596 return ret;
597 if (iMidiDevice < 0)
598 return ret;
599 if (pParam == NULL)
600 return ret;
601
602 return ret;
603 }
604
605
606 /**
607 * Getting informations about a MIDI port.
608 * GET MIDI_INPUT_PORT INFO <midi-device-id> <midi-port>
609 *
610 * @param pClient Pointer to client instance structure.
611 * @param iMidiDevice MIDI device number identifier.
612 * @param iMidiPort MIDI port number.
613 *
614 * @returns A pointer to a @ref lscp_device_channel_info_t structure,
615 * with the given MIDI port information, or NULL in case of failure.
616 */
617 lscp_device_channel_info_t* lscp_get_midi_port_info ( lscp_client_t *pClient, int iMidiDevice, int iMidiPort )
618 {
619 lscp_device_channel_info_t *pDevChannelInfo = NULL;
620
621 if (pClient == NULL)
622 return NULL;
623 if (iMidiDevice < 0)
624 return NULL;
625 if (iMidiPort < 0)
626 return NULL;
627
628 return pDevChannelInfo;
629 }
630
631
632 /**
633 * Getting informations about specific MIDI port parameter.
634 * GET MIDI_INPUT_PORT_PARAMETER INFO <midi-device-id> <midi-port> <param>
635 *
636 * @param pClient Pointer to client instance structure.
637 * @param iMidiDevice MIDI device number identifier.
638 * @param iMidiPort MIDI port number.
639 * @param pszParam MIDI port parameter name.
640 *
641 * @returns A pointer to a @ref lscp_param_info_t structure, with
642 * the given MIDI port parameter information, or NULL in case of failure.
643 */
644 lscp_param_info_t* lscp_get_midi_port_param_info ( lscp_client_t *pClient, int iMidiDevice, int iMidiPort, const char *pszParam )
645 {
646 lscp_param_info_t *pParamInfo = NULL;
647
648 if (pClient == NULL)
649 return NULL;
650 if (iMidiDevice < 0)
651 return NULL;
652 if (iMidiPort < 0)
653 return NULL;
654 if (pszParam == NULL)
655 return NULL;
656
657 return pParamInfo;
658 }
659
660
661 /**
662 * Changing settings of MIDI input ports.
663 * SET MIDI_INPUT_PORT_PARAMETER <midi-device-id> <midi-port> <param> <value>
664 *
665 * @param pClient Pointer to client instance structure.
666 * @param iMidiDevice MIDI device number identifier.
667 * @param iMidiPort MIDI port number.
668 * @param pParam Pointer to a key-valued MIDI port parameter.
669 *
670 * @returns LSCP_OK on success, LSCP_FAILED otherwise.
671 */
672 lscp_status_t lscp_set_midi_port_param ( lscp_client_t *pClient, int iMidiDevice, int iMidiPort, lscp_param_t *pParam )
673 {
674 lscp_status_t ret = LSCP_FAILED;
675
676 if (pClient == NULL)
677 return ret;
678 if (iMidiDevice < 0)
679 return ret;
680 if (iMidiPort < 0)
681 return ret;
682 if (pParam == NULL)
683 return ret;
684
685 return ret;
686 }
687
688 // end of device.c
689

  ViewVC Help
Powered by ViewVC