source: roaraudio/roard/codecfilter.c @ 6052:d48765b2475e

Last change on this file since 6052:d48765b2475e was 6052:d48765b2475e, checked in by phi, 9 years ago

updated copyright headers

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