source: roaraudio/roard/codecfilter.c @ 3358:7f9d211148e0

Last change on this file since 3358:7f9d211148e0 was 3358:7f9d211148e0, checked in by phi, 14 years ago

updated (C) statements
File size: 12.7 KB
Line 
1//codecfilter.c:
2
3/*
4 *      Copyright (C) Philipp 'ph3-der-loewe' Schafft - 2008-2010
5 *
6 *  This file is part of roard a part of RoarAudio,
7 *  a cross-platform sound system for both, home and professional use.
8 *  See README for details.
9 *
10 *  This file is free software; you can redistribute it and/or modify
11 *  it under the terms of the GNU General Public License version 3
12 *  as published by the Free Software Foundation.
13 *
14 *  RoarAudio is distributed in the hope that it will be useful,
15 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
16 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17 *  GNU General Public License for more details.
18 *
19 *  You should have received a copy of the GNU General Public License
20 *  along with this software; see the file COPYING.  If not, write to
21 *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
22 *
23 */
24
25#define ROAR_REQUIRE_LIBVORBISFILE
26
27#include "roard.h"
28
29#ifndef ROAR_WITHOUT_CF_CMD
30#if !defined(ROAR_HAVE_UNIX) || !defined(ROAR_HAVE_BSDSOCKETS) || !defined(ROAR_HAVE_IO_POSIX)
31#define ROAR_WITHOUT_CF_CMD
32#endif
33#endif
34
35#define _DUMMY_FILTER(codec,name,desc,flags,subsystem,delay) {(codec),(name),(desc),NULL,NULL,(flags),(subsystem), \
36                                                              NULL, NULL, NULL, NULL, NULL, NULL, (delay), NULL    }
37
38#define _PCM_FILTER(codec) _DUMMY_FILTER(codec, "PCM", "Native PCM Support", \
39                                         ROAR_CODECFILTER_READ|ROAR_CODECFILTER_WRITE|ROAR_CODECFILTER_PRETHRU_NN, \
40                                         ROAR_SUBSYS_WAVEFORM, cf_alaw_delay)
41
42struct roar_codecfilter g_codecfilter[] = {
43 _DUMMY_FILTER(-1, "null", "null codec filter", ROAR_CODECFILTER_NONE, ROAR_SUBSYS_NONE, NULL),
44 _PCM_FILTER(ROAR_CODEC_PCM_S_LE),
45 _PCM_FILTER(ROAR_CODEC_PCM_S_BE),
46 _PCM_FILTER(ROAR_CODEC_PCM_S_PDP),
47 _PCM_FILTER(ROAR_CODEC_PCM_U_LE),
48 _PCM_FILTER(ROAR_CODEC_PCM_U_BE),
49 _PCM_FILTER(ROAR_CODEC_PCM_U_PDP),
50 _DUMMY_FILTER(ROAR_CODEC_MIDI, "MIDI", "Native MIDI Support",
51               ROAR_CODECFILTER_READ|ROAR_CODECFILTER_WRITE|ROAR_CODECFILTER_PRETHRU_NN, ROAR_SUBSYS_MIDI, NULL),
52 {ROAR_CODEC_DMX512,      "DMX512", "Native DMX512 Support", NULL, NULL,
53                          ROAR_CODECFILTER_READ|ROAR_CODECFILTER_WRITE|ROAR_CODECFILTER_PRETHRU_NN, ROAR_SUBSYS_LIGHT,
54                                          NULL, NULL, NULL, NULL, NULL, NULL, cf_alaw_delay, NULL},
55 {ROAR_CODEC_RDS,         "RDS", "Native RDS Support", NULL, NULL,
56                          ROAR_CODECFILTER_WRITE|ROAR_CODECFILTER_PRETHRU_NN, ROAR_SUBSYS_RDTCS,
57                                          NULL, NULL, NULL, NULL, NULL, NULL, cf_alaw_delay, NULL},
58
59/*
60#ifdef ROAR_HAVE_LIBSNDFILE
61 {ROAR_CODEC_RIFF_WAVE, "sndfile", "libsndfile codec filter", NULL, ROAR_CODECFILTER_READ|ROAR_CODECFILTER_WRITE,
62  cf_sndfile_open, cf_sndfile_close, NULL, cf_sndfile_write, cf_sndfile_read, NULL},
63#else
64*/
65#ifndef ROAR_WITHOUT_CF_WAVE
66 {ROAR_CODEC_RIFF_WAVE, "RIFF/WAVE", "RIFF/WAVE", NULL, NULL,
67  ROAR_CODECFILTER_READ|ROAR_CODECFILTER_WRITE|ROAR_CODECFILTER_PRETHRU, ROAR_SUBSYS_WAVEFORM,
68  cf_wave_open, cf_wave_close, NULL, cf_wave_write, cf_wave_read, NULL, NULL, cf_wave_ctl},
69#endif
70//#endif
71
72#ifdef ROAR_HAVE_LIBRAUM
73 {ROAR_CODEC_RAUM, "RAUM", "RAUM Container Format", NULL, cf_raum_setup, ROAR_CODECFILTER_WRITE,
74  ROAR_SUBSYS_WAVEFORM|ROAR_SUBSYS_MIDI|ROAR_SUBSYS_LIGHT|ROAR_SUBSYS_RAW|ROAR_SUBSYS_COMPLEX,
75  cont_fw_cf_open, cont_fw_cf_close, NULL, cont_fw_cf_write, cont_fw_cf_read, cont_fw_cf_flush, NULL, cont_fw_cf_ctl},
76#endif
77
78#ifdef ROAR_HAVE_LIBOGG
79 {ROAR_CODEC_OGG, "Ogg", "Ogg Container Format", NULL, NULL, ROAR_CODECFILTER_NONE,
80  ROAR_SUBSYS_WAVEFORM|ROAR_SUBSYS_MIDI,
81  NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL},
82#endif
83
84#ifdef ROAR_SUPPORT_ALAW
85 {ROAR_CODEC_ALAW, "alaw", "A-Law", NULL, NULL,
86#ifdef ROAR_SUPPORT_ALAW_RW
87  ROAR_CODECFILTER_READ|ROAR_CODECFILTER_WRITE|ROAR_CODECFILTER_PRETHRU_NN,
88#else
89  ROAR_CODECFILTER_READ|ROAR_CODECFILTER_PRETHRU_NN,
90#endif
91  ROAR_SUBSYS_WAVEFORM,
92  cf_alaw_open, cf_alaw_close, NULL,
93#ifdef ROAR_SUPPORT_ALAW_RW
94  cf_alaw_write,
95#else
96  NULL,
97#endif
98  cf_alaw_read, NULL, cf_alaw_delay, NULL},
99#endif
100
101#ifdef ROAR_SUPPORT_MULAW
102 {ROAR_CODEC_MULAW, "mulaw", "mu-Law", NULL, NULL,
103#ifdef ROAR_SUPPORT_MULAW_RW
104  ROAR_CODECFILTER_READ|ROAR_CODECFILTER_WRITE|ROAR_CODECFILTER_PRETHRU_NN,
105#else
106  ROAR_CODECFILTER_READ|ROAR_CODECFILTER_PRETHRU_NN,
107#endif
108  ROAR_SUBSYS_WAVEFORM,
109  cf_mulaw_open, cf_mulaw_close, NULL,
110#ifdef ROAR_SUPPORT_MULAW_RW
111  cf_mulaw_write,
112#else
113  NULL,
114#endif
115  cf_mulaw_read, NULL, cf_alaw_delay, NULL},
116#endif
117
118#ifndef ROAR_WITHOUT_CF_CMD
119#ifdef ROAR_HAVE_BIN_OGG123
120 {ROAR_CODEC_OGG_GENERAL, "cmd",  "ogg123",
121  ROAR_HAVE_BIN_OGG123 " -q -d raw -f - -", NULL, ROAR_CODECFILTER_READ, ROAR_SUBSYS_WAVEFORM,
122  cf_cmd_open, NULL, NULL, NULL, NULL, NULL, codecfilter_delay_fulldyn, NULL},
123#endif
124#endif
125
126#ifdef ROAR_HAVE_LIBVORBISFILE
127 {ROAR_CODEC_OGG_VORBIS, "oggvorbis", "Ogg Vorbis decoder", NULL, NULL,
128#ifdef ROAR_HAVE_LIBVORBISENC
129 ROAR_CODECFILTER_READ|ROAR_CODECFILTER_WRITE|ROAR_CODECFILTER_PRETHRU,
130#else
131 ROAR_CODECFILTER_READ,
132#endif
133 ROAR_SUBSYS_WAVEFORM,
134 cf_vorbis_open, cf_vorbis_close, NULL, cf_vorbis_write, cf_vorbis_read, NULL, codecfilter_delay_fulldyn, cf_vorbis_ctl},
135#else
136#ifndef ROAR_WITHOUT_CF_CMD
137#ifdef ROAR_HAVE_BIN_OGG123
138 {ROAR_CODEC_OGG_VORBIS, "cmd",  "ogg123",
139  ROAR_HAVE_BIN_OGG123 " -q -d raw -f - -", NULL, ROAR_CODECFILTER_READ, ROAR_SUBSYS_WAVEFORM,
140  cf_cmd_open, NULL, NULL, NULL, NULL, NULL, codecfilter_delay_fulldyn, NULL},
141#endif
142#endif
143#endif
144
145#ifdef ROAR_HAVE_LIBFISHSOUND
146 {ROAR_CODEC_OGG_SPEEX, "fishsound",  "libfishsound Xiph Codec library",
147  NULL, NULL, ROAR_CODECFILTER_READ, ROAR_SUBSYS_WAVEFORM,
148  cf_fishsound_open, cf_fishsound_close, NULL, NULL, cf_fishsound_read, NULL, codecfilter_delay_fulldyn, NULL},
149
150 {ROAR_CODEC_OGG_FLAC, "fishsound",  "libfishsound Xiph Codec library",
151  NULL, NULL, ROAR_CODECFILTER_READ, ROAR_SUBSYS_WAVEFORM,
152  cf_fishsound_open, cf_fishsound_close, NULL, NULL, cf_fishsound_read, NULL, codecfilter_delay_fulldyn, NULL},
153#endif
154
155#ifndef ROAR_WITHOUT_CF_CMD
156#ifdef ROAR_HAVE_BIN_TIMIDITY
157 {ROAR_CODEC_MIDI_FILE, "MIDIFILE", "timidity MIDI synth",
158  ROAR_HAVE_BIN_TIMIDITY " -Or1sl -s %R -o - -", NULL, ROAR_CODECFILTER_READ, ROAR_SUBSYS_WAVEFORM,
159  cf_cmd_open, NULL, NULL, NULL, NULL, NULL, codecfilter_delay_fulldyn, NULL},
160#endif
161#endif
162
163#ifdef ROAR_HAVE_LIBCELT
164 {ROAR_CODEC_ROAR_CELT, "RoarCELT", "RoarAudio CELT", NULL, NULL,
165  ROAR_CODECFILTER_READ|ROAR_CODECFILTER_WRITE|ROAR_CODECFILTER_PRETHRU,
166  ROAR_SUBSYS_WAVEFORM,
167  cf_celt_open, cf_celt_close, NULL, cf_celt_write, cf_celt_read, NULL, cf_celt_delay, NULL},
168#endif
169
170#ifdef ROAR_HAVE_LIBSPEEX
171 {ROAR_CODEC_ROAR_SPEEX, "RoarSpeex", "RoarAudio Speex", NULL, NULL,
172  ROAR_CODECFILTER_READ|ROAR_CODECFILTER_WRITE|ROAR_CODECFILTER_PRETHRU,
173  ROAR_SUBSYS_WAVEFORM,
174  cf_speex_open, cf_speex_close, NULL, cf_speex_write, cf_speex_read, NULL, NULL, NULL},
175#endif
176
177#ifndef ROAR_WITHOUT_CF_CMD
178#ifdef ROAR_HAVE_BIN_FLAC
179 {ROAR_CODEC_FLAC, "cmd",  "flac",
180#if BYTE_ORDER == BIG_ENDIAN
181  ROAR_HAVE_BIN_FLAC " --silent --force-raw-format --sign=signed --endian=big -d - -o -",
182#elif BYTE_ORDER == LITTLE_ENDIAN
183  ROAR_HAVE_BIN_FLAC " --silent --force-raw-format --sign=signed --endian=little -d - -o -",
184#else
185  "false",
186#endif
187  NULL, ROAR_CODECFILTER_READ, ROAR_SUBSYS_WAVEFORM,
188  cf_cmd_open, NULL, NULL, NULL, NULL, NULL, codecfilter_delay_fulldyn, NULL},
189#endif
190#endif
191
192 _DUMMY_FILTER(ROAR_CODEC_ROARDMX, "RoarDMX", "Native RoarDMX Support",
193               ROAR_CODECFILTER_READ|ROAR_CODECFILTER_WRITE|ROAR_CODECFILTER_PRETHRU_NN, ROAR_SUBSYS_LIGHT, NULL),
194
195 {-1, NULL, NULL, NULL, NULL, ROAR_CODECFILTER_NONE, ROAR_SUBSYS_NONE,
196  NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL} // end of list
197};
198
199void print_codecfilterlist (void) {
200 int i;
201 int flags;
202 char mode[5];
203 char delay[6];
204 char subsys[7] = "      ";
205 uint_least32_t d;
206
207 printf("  Codec        Filtername   Mode Subsys Delay - Description\n");
208 printf("-------------------------------------------------------------\n");
209
210 for (i = 0; g_codecfilter[i].name != NULL; i++) {
211  strncpy(subsys, "      ", 6);
212
213  if ( g_codecfilter[i].subsystems & ROAR_SUBSYS_WAVEFORM )
214   subsys[0] = 'W';
215  if ( g_codecfilter[i].subsystems & ROAR_SUBSYS_MIDI )
216   subsys[1] = 'M';
217  if ( g_codecfilter[i].subsystems & ROAR_SUBSYS_CB )
218   subsys[2] = 'C';
219  if ( g_codecfilter[i].subsystems & ROAR_SUBSYS_LIGHT )
220   subsys[3] = 'L';
221  if ( g_codecfilter[i].subsystems & ROAR_SUBSYS_RAW )
222   subsys[4] = 'R';
223  if ( g_codecfilter[i].subsystems & ROAR_SUBSYS_COMPLEX )
224   subsys[5] = 'X';
225
226  flags = g_codecfilter[i].flags;
227
228  if ( flags == ROAR_CODECFILTER_NONE ) {
229   strcpy(mode, "none");
230  } else {
231   strcpy(mode, "    ");
232   if ( flags & ROAR_CODECFILTER_READ )
233    mode[0] = 'r';
234   if ( flags & ROAR_CODECFILTER_WRITE )
235    mode[1] = 'w';
236   if ( flags & ROAR_CODECFILTER_PRETHRU )
237    mode[2] = 'P';
238   if ( flags & ROAR_CODECFILTER_PRETHRU_NN )
239    mode[2] = 'p';
240  }
241
242  *delay = 0;
243  if ( g_codecfilter[i].codec == -1 ) { // null codec filter
244   strcpy(delay, "0ms");
245  } else if ( g_codecfilter[i].delay == NULL ) {
246   strcpy(delay, "?");
247  } else {
248   if ( codecfilter_delay(NULL, i, &d) == -1 ) {
249    strcpy(delay, "dyn");
250   } else {
251    snprintf(delay, 5, "%ims", d/1000);
252   }
253  }
254 
255  printf("  %-12s %-12s %-4s %6s %-5s - %s\n",
256             roar_codec2str(g_codecfilter[i].codec),
257             g_codecfilter[i].name,
258             mode,
259             subsys,
260             delay,
261             g_codecfilter[i].desc
262             );
263 }
264}
265
266int codecfilter_open (CODECFILTER_USERDATA_T * inst,
267                 int * codecfilter_id, char * codecfilter /* NOTE: this is not part of struct roar_codecfilter's def! */,
268                 int codec, struct roar_stream_server * info) {
269 int i;
270 struct roar_codecfilter   * filter = NULL;
271
272 *codecfilter_id = -1;
273
274 ROAR_DBG("codecfilter_open(*): codecfilter='%s', info->id=%i", codecfilter, ROAR_STREAM(info)->id);
275
276 for (i = 0; g_codecfilter[i].name != NULL; i++) {
277  ROAR_DBG("codecfilter_open(*): g_codecfilter[i].codec <-> codec => %i <-> %i", g_codecfilter[i].codec, codec);
278  if ( g_codecfilter[i].codec == codec ) {
279   if ( !codecfilter || strcmp(codecfilter, g_codecfilter[i].name) == 0 ) {
280    *codecfilter_id = i;
281    filter = &g_codecfilter[i];
282    break;
283   }
284  }
285 }
286
287 info->codecfilter = *codecfilter_id;
288
289 if (*codecfilter_id != -1) {
290  if ( filter->open != NULL ) {
291   if ( (i = filter->open(inst, codec, info, filter)) == -1 ) {
292    info->codecfilter = *codecfilter_id = -1;
293   }
294   return i;
295  } else {
296   // in case we can not open the filter we will not use it
297   *codecfilter_id   = -1;
298   info->codecfilter = -1;
299  }
300  return 0;
301 }
302
303 return -1; // we found no filter -> ok
304}
305
306int codecfilter_close(CODECFILTER_USERDATA_T   inst, int codecfilter) {
307 ROAR_DBG("codecfilter_close(inst=%p, codecfilter=%i) = ?", inst, codecfilter);
308
309 if ( codecfilter == -1 )
310  return -1;
311
312 if ( g_codecfilter[codecfilter].close )
313  return g_codecfilter[codecfilter].close(inst);
314
315 return 0;
316}
317
318int codecfilter_pause(CODECFILTER_USERDATA_T   inst, int codecfilter, int newstate) {
319 if ( codecfilter == -1 )
320  return -1;
321
322 if ( g_codecfilter[codecfilter].pause )
323  return g_codecfilter[codecfilter].pause(inst, newstate);
324
325 return 0;
326}
327
328int codecfilter_write(CODECFILTER_USERDATA_T   inst, int codecfilter, char * buf, int len) {
329 if ( codecfilter == -1 )
330  return -1;
331
332 if ( g_codecfilter[codecfilter].write )
333  return g_codecfilter[codecfilter].write(inst, buf, len);
334
335 return 0;
336}
337
338int codecfilter_read (CODECFILTER_USERDATA_T   inst, int codecfilter, char * buf, int len) {
339 if ( codecfilter == -1 )
340  return -1;
341
342 errno = 0;
343
344 if ( g_codecfilter[codecfilter].read )
345  return g_codecfilter[codecfilter].read(inst, buf, len);
346
347 return 0;
348}
349
350int codecfilter_flush(CODECFILTER_USERDATA_T   inst, int codecfilter) {
351 if ( codecfilter == -1 )
352  return -1;
353
354 if ( g_codecfilter[codecfilter].flush )
355  return g_codecfilter[codecfilter].flush(inst);
356
357 return 0;
358}
359
360int codecfilter_delay(CODECFILTER_USERDATA_T   inst, int codecfilter, uint_least32_t * delay) {
361 ROAR_DBG("codecfilter_delay(inst=%p, codecfilter=%i, *delay=?) = ?", inst, codecfilter);
362
363 if ( codecfilter == -1 )
364  return -1;
365
366 if ( g_codecfilter[codecfilter].delay )
367  return g_codecfilter[codecfilter].delay(inst, delay);
368
369 return -1;
370}
371
372int codecfilter_ctl  (CODECFILTER_USERDATA_T   inst, int codecfilter, int_least32_t cmd, void * data) {
373 ROAR_DBG("codecfilter_ctl(inst=%p, codecfilter=%i, cmd=0x%.8x, data=%p) = ?", inst, codecfilter, cmd, data);
374 if ( codecfilter == -1 )
375  return -1;
376
377 if ( g_codecfilter[codecfilter].ctl )
378  return g_codecfilter[codecfilter].ctl(inst, cmd, data);
379
380 return -1;
381}
382
383
384int codecfilter_delay_fulldyn(CODECFILTER_USERDATA_T   inst, uint_least32_t * delay) {
385 *delay = 0; // just to be sure
386 return -1;
387}
388
389//ll
Note: See TracBrowser for help on using the repository browser.