source: roaraudio/roard/light.c @ 5981:eedcf0c7d633

Last change on this file since 5981:eedcf0c7d633 was 5981:eedcf0c7d633, checked in by phi, 10 years ago

corrected double-free bug. Thanks to stephan48 and the build cluster

File size: 8.2 KB
Line 
1//light.c:
2
3/*
4 *      Copyright (C) Philipp 'ph3-der-loewe' Schafft - 2008-2014
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#include "roard.h"
27
28#ifndef ROAR_WITHOUT_DCOMP_LIGHT
29
30// declared 'extern'
31struct light_state g_light_state;
32struct light_mixer g_light_mixer;
33// //
34
35static inline void __set_channel(size_t index, uint8_t val) {
36 g_light_state.changes[index] |= g_light_state.state[index] ^ val;
37 g_light_state.state[index]    =                              val;
38}
39
40int light_init  (uint32_t channels) {
41 struct roar_stream_server * ss;
42 int i;
43
44 g_light_state.channels = 0;
45
46 if ( channels == 0 || channels > ((uint32_t)512UL*(uint32_t)512UL) ) /* unrealstic values */
47  return -1;
48
49 if ( (g_light_state.state = roar_mm_malloc(channels)) == NULL ) {
50  return -1;
51 }
52
53 if ( (g_light_state.changes = roar_mm_malloc(channels)) == NULL ) {
54  roar_mm_free(g_light_state.state);
55  return -1;
56 }
57
58 if ( (g_light_state.output = roar_mm_malloc(channels)) == NULL ) {
59  roar_mm_free(g_light_state.state);
60  roar_mm_free(g_light_state.changes);
61  return -1;
62 }
63
64 if ( (g_light_state.outputchanges = roar_mm_malloc(channels)) == NULL ) {
65  roar_mm_free(g_light_state.state);
66  roar_mm_free(g_light_state.changes);
67  roar_mm_free(g_light_state.output);
68  return -1;
69 }
70
71 g_light_state.channels = channels;
72
73 if ( (g_light_mixer.stream = add_mixer(ROAR_SUBSYS_LIGHT, _MIXER_NAME("Light Control"), &ss)) == -1 ) {
74  roar_mm_free(g_light_state.state);
75  return -1;
76 }
77
78 ROAR_STREAM(ss)->info.codec = ROAR_CODEC_DMX512;
79 ROAR_STREAM(ss)->info.bits  = ROAR_LIGHT_BITS;
80 ROAR_STREAM(ss)->info.rate  = ROAR_OUTPUT_CFREQ;
81
82 for (i = 0; i < ROAR_STREAMS_MAX; i++) {
83  if ( g_streams[i] != NULL ) {
84   if ( streams_get_subsys(i) == ROAR_SUBSYS_LIGHT ) {
85    streams_set_mixer_stream(i, g_light_mixer.stream);
86   }
87  }
88 }
89
90 return light_reset();
91}
92
93int light_free  (void) {
94 if ( g_light_state.state != NULL ) {
95  roar_mm_free(g_light_state.state);
96 }
97
98 if ( g_light_state.changes != NULL ) {
99  roar_mm_free(g_light_state.changes);
100 }
101
102 if ( g_light_state.output != NULL ) {
103  roar_mm_free(g_light_state.output);
104 }
105
106 if ( g_light_state.outputchanges != NULL ) {
107  roar_mm_free(g_light_state.outputchanges);
108 }
109
110 g_light_state.channels = 0;
111
112 return 0;
113}
114
115int light_reset (void) {
116 if ( g_light_state.channels == 0 )
117  return 0;
118
119 if ( g_light_state.state == NULL )
120  return -1;
121
122 if ( g_light_state.changes == NULL )
123  return -1;
124
125 memset(g_light_state.state,         0, g_light_state.channels);
126 memset(g_light_state.changes,       0, g_light_state.channels);
127 memset(g_light_state.output,        0, g_light_state.channels);
128 memset(g_light_state.outputchanges, 0, g_light_state.channels);
129 memset(g_light_state.events,        0, sizeof(g_light_state.events));
130
131 g_light_state.eventsqueuelen = 0;
132
133 return 0;
134}
135
136// called at end of mainloop.
137int light_reinit(void) {
138 if ( g_light_state.changes == NULL )
139  return -1;
140
141 memset(g_light_state.changes, 0, g_light_state.channels);
142 memset(g_light_state.events,  0, sizeof(g_light_state.events));
143
144 g_light_state.eventsqueuelen = 0;
145
146 return 0;
147}
148
149// called at mid of mainloop.
150int light_update(void) {
151 uint8_t * tmp;
152 unsigned int c;
153
154 // swap buffers:
155 // after that step we have the old values in outputchanges and output is a fresh buffer.
156 tmp = g_light_state.outputchanges;
157 g_light_state.outputchanges = g_light_state.output;
158 g_light_state.output = tmp;
159
160 // copy data for filters:
161 memcpy(g_light_state.output, g_light_state.state, g_light_state.channels);
162
163 // TODO: next run filters
164
165 // calculate diffrence:
166 // after this step we have only teh changes in the outputchanges array.
167 for (c = 0; c < g_light_state.channels; c++)
168  g_light_state.outputchanges[c] ^= g_light_state.output[c];
169
170 return 0;
171}
172
173int light_check_stream  (int id) {
174 struct roar_stream        *   s;
175 struct roar_stream_server *  ss;
176 char buf[512];
177 int i;
178
179 if ( g_streams[id] == NULL )
180  return -1;
181
182 ROAR_DBG("light_check_stream(id=%i) = ?", id);
183
184 s = ROAR_STREAM(ss = g_streams[id]);
185
186 switch (s->info.codec) {
187  case ROAR_CODEC_DMX512:
188    if ( stream_vio_s_read(ss, buf, 512) != 512 ) {
189     streams_delete(id);
190     return -1;
191    }
192
193    for (i = 0; i < (g_light_state.channels < 512 ? g_light_state.channels : 512); i++) {
194     __set_channel(i, buf[i]);
195    }
196//    memcpy(g_light_state.state, buf, g_light_state.channels < 512 ? g_light_state.channels : 512);
197
198    s->pos = ROAR_MATH_OVERFLOW_ADD(s->pos, 1);
199
200    return 0;
201   break;
202  case ROAR_CODEC_ROARDMX:
203    ROAR_DBG("light_check_stream(id=%i): Codec: RoarDMX", id);
204    if ( cf_light_roardmx_read(id, ss) == -1 ) {
205     streams_delete(id); // simply drop the client on error.
206     return -1;
207    }
208   break;
209  default:
210    streams_delete(id);
211    return -1;
212 }
213
214 return 0;
215}
216
217static inline int light_send_stream_dmx512  (int id, struct roar_stream * s, struct roar_stream_server * ss) {
218 size_t chans = g_light_state.channels;
219 uint8_t buf[512];
220 register uint8_t * bufptr;
221
222 if ( chans > 512 )
223  chans = 512;
224
225 if ( chans == 512 ) {
226  bufptr = g_light_state.output;
227 } else {
228  memset(buf, 0, 512);
229  memcpy(buf, g_light_state.output, chans);
230  bufptr = buf;
231 }
232
233 if ( stream_vio_s_write(ss, bufptr, 512) != 512 ) {
234  streams_delete(id);
235  return -1;
236 }
237
238 s->pos = ROAR_MATH_OVERFLOW_ADD(s->pos, 1);
239
240 return 0;
241}
242
243int light_send_stream   (int id) {
244 struct roar_stream        *   s;
245 struct roar_stream_server *  ss;
246
247 if ( g_streams[id] == NULL )
248  return -1;
249
250 ROAR_DBG("light_send_stream(id=%i) = ?", id);
251
252 s = ROAR_STREAM(ss = g_streams[id]);
253
254 switch (s->info.codec) {
255  case ROAR_CODEC_DMX512:
256    return light_send_stream_dmx512(id, s, ss);
257   break;
258  case ROAR_CODEC_ROARDMX:
259    return cf_light_roardmx_write(id, ss);
260   break;
261  default:
262    streams_delete(id);
263    return -1;
264 }
265
266 return 0;
267}
268
269int light_dmxchannel_get(size_t index) {
270 if ( (size_t)g_light_state.channels <= index ) {
271  roar_err_set(ROAR_ERROR_NOENT);
272  return -1;
273 }
274
275 return (int)(unsigned int)(uint8_t)g_light_state.state[index];
276}
277
278int light_dmxchannel_set(size_t index, uint8_t val) {
279 if ( (size_t)g_light_state.channels <= index ) {
280  roar_err_set(ROAR_ERROR_NOENT);
281  return -1;
282 }
283
284 __set_channel(index, val);
285 return 0;
286}
287
288ssize_t light_dmxchannel_num(void) {
289 if ( g_light_state.state == NULL ) {
290  roar_err_set(ROAR_ERROR_BADSTATE);
291  return -1;
292 }
293
294 return g_light_state.channels;
295}
296
297int     light_dmxchannel_swap_universe(uint8_t * universe, size_t len) {
298 uint8_t c;
299 size_t i;
300
301 if ( g_light_state.state == NULL ) {
302  roar_err_set(ROAR_ERROR_BADSTATE);
303  return -1;
304 }
305
306 if ( g_light_state.channels != len ) {
307  roar_err_set(ROAR_ERROR_FAULT);
308  return -1;
309 }
310
311 for (i = 0; i < len; i++) {
312  c = g_light_state.state[i];
313  __set_channel(i, universe[i]);
314  universe[i] = c;
315 }
316
317 return 0;
318}
319
320int light_dmxevent_add(const uint8_t * events, size_t len) {
321 size_t i;
322
323 if ( events == NULL ) {
324  roar_err_set(ROAR_ERROR_FAULT);
325  return -1;
326 }
327
328 if ( len > (sizeof(g_light_state.events) - g_light_state.eventsqueuelen) ) {
329  roar_err_set(ROAR_ERROR_NOSPC);
330  return -1;
331 }
332
333 for (i = 0; i < len; i++) {
334  g_light_state.events[g_light_state.eventsqueuelen++] = events[i];
335  roar_notify_core_emit_simple(ROAR_DATA_DMX512_EVENT, -1, g_light_mixer.stream, ROAR_OT_STREAM, events[i], -1, NULL, -1);
336 }
337
338 return 0;
339}
340
341int light_dmxevent_read(const uint8_t ** events, size_t * len) {
342 if ( events == NULL || len == NULL ) {
343  roar_err_set(ROAR_ERROR_FAULT);
344  return -1;
345 }
346
347 *events = g_light_state.events;
348 *len    = g_light_state.eventsqueuelen;
349
350 return 0;
351}
352
353#endif
354
355//ll
Note: See TracBrowser for help on using the repository browser.