libetherpix

1) /*

2)  * EtherPix library

3)  *

4)  * Copyright 2010-2017 Stefan Schuermans <stefan schuermans info>

5)  *
6)  * This program is free software: you can redistribute it and/or modify
7)  * it under the terms of the GNU General Public License as published by
8)  * the Free Software Foundation, version 3 of the License.
9)  *
10)  *
11)  * This program is distributed in the hope that it will be useful,
12)  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13)  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14)  * GNU General Public License for more details.
15)  *
16)  * You should have received a copy of the GNU Lesser General Public License
17)  * along with this program. If not, see <http://www.gnu.org/licenses/>.
18)  */
19) 
20) #include <sys/time.h>
21) #include <stdlib.h>
22) 

23) #include "net.h" // first because of winsock2.h ordering

24) #include <etherpix/display.h>
25) #include <etherpix/displayer.h>
26) #include <etherpix/msg.h>
27) #include <etherpix/types.h>

28) #include "displayer.h"
29) #include "thread.h"
30) #include "types.h"

31) 
32) /**

33)  * \brief create a new EtherPix displayer

34)  *
35)  * A displayer manages a display and ensures that a the current
36)  * image data is sent often enough to the distributors so
37)  * that the pixels do detect a timeout and turn off automatically.
38)  * The displayer uses a thread to do this.
39)  * Initially, the new displayer is inactive and has to be activated

40)  * using etp_displayer_activate().

41)  *
42)  * \param[in] sz_config_file name of config file to read
43)  * \param[in] p_msg_func message callback function or NULL
44)  * \param[in] p_msg_ctx user context for message callback

45)  * \return pointer to new EtherPix displayer on success

46)  *         or NULL on error
47)  */

48) etp_displayer_t *etp_displayer_create(const char *sz_config_file,
49)                                       etp_msg_func_p_t p_msg_func,

50)                                       void *p_msg_ctx)
51) {

52)   etp_displayer_t *p_displayer;

53) 
54)   /* set up basic structure and display */
55) 
56)   /* create displayer structure */

57)   p_displayer = (etp_displayer_t *)calloc(1, sizeof (etp_displayer_t));

58)   if (!p_displayer) {
59)     if (p_msg_func)

60)       p_msg_func(p_msg_ctx, etp_msg_type_err,

61)                  "out of memory\n");
62)     return NULL;
63)   }
64) 
65)   /* set up flags */
66)   p_displayer->active = 0; /* not sending data to distributors */
67)   p_displayer->send   = 1; /* send first data as soon as active */
68)   p_displayer->end    = 0; /* do not end yet */
69) 
70)   /* set up managed display */

71)   p_displayer->p_display = etp_display_create(sz_config_file,

72)                                               p_msg_func, p_msg_ctx);
73)   if (!p_displayer->p_display) {
74)     free(p_displayer);
75)     if (p_msg_func)

76)       p_msg_func(p_msg_ctx, etp_msg_type_err,

77)                  "could not create display\n");
78)     return NULL;
79)   }
80) 
81)   /* set up output thread */
82) 
83)   /* initialize mutex */

84)   if (!etp_thread_mutex_init(&p_displayer->mtx)) {
85)     etp_display_free(p_displayer->p_display);

86)     free(p_displayer);
87)     if (p_msg_func)

88)       p_msg_func(p_msg_ctx, etp_msg_type_err,

89)                  "could not initialize mutex\n");
90)     return NULL;
91)   }
92) 
93)   /* initialize condition */

94)   if (!etp_thread_cond_init(&p_displayer->cond)) {
95)     etp_thread_mutex_destroy(&p_displayer->mtx);
96)     etp_display_free(p_displayer->p_display);

97)     free(p_displayer);
98)     if (p_msg_func)

99)       p_msg_func(p_msg_ctx, etp_msg_type_err,

100)                  "could not initialize condition\n");
101)     return NULL;
102)   }
103) 
104)   /* create thread */

105)   if (!etp_thread_create(&p_displayer->tid, etp_displayer_thread,

106)                         (void *)p_displayer)) {

107)     etp_thread_cond_destroy(&p_displayer->cond);
108)     etp_thread_mutex_destroy(&p_displayer->mtx);
109)     etp_display_free(p_displayer->p_display);

110)     free(p_displayer);
111)     if (p_msg_func)

112)       p_msg_func(p_msg_ctx, etp_msg_type_err,

113)                  "could not create thread\n");
114)     return NULL;
115)   }
116) 
117)   return p_displayer;
118) }
119) 
120) /**

121)  * \brief free a EtherPix displayer

122)  *

123)  * \param[in] p_displayer pointer to EtherPix displayer

124)  */

125) void etp_displayer_free(etp_displayer_t *p_displayer)

126) {
127)   /* tear down thread */
128)   p_displayer->end = 1;

129)   etp_thread_cond_signal(&p_displayer->cond);
130)   etp_thread_join(p_displayer->tid);
131)   etp_thread_cond_destroy(&p_displayer->cond);
132)   etp_thread_mutex_destroy(&p_displayer->mtx);

133) 
134)   /* free managed display */

135)   etp_display_free(p_displayer->p_display);

136) 
137)   /* free basic structure */
138)   free(p_displayer);
139) }
140) 
141) /**
142)  * \brief get size of display managed by displayer
143)  *

144)  * \param[in] p_displayer pointer to EtherPix displayer

145)  * \param[out] p_width width of display
146)  * \param[out] p_height height of display
147)  */

148) void etp_displayer_get_size(etp_displayer_t *p_displayer,

149)                             unsigned int *p_width, unsigned int *p_height)
150) {

151)   etp_thread_mutex_lock(&p_displayer->mtx);
152)   etp_display_get_size(p_displayer->p_display, p_width, p_height);
153)   etp_thread_mutex_unlock(&p_displayer->mtx);

154) }
155) 
156) /**
157)  * \brief activate the displayer
158)  *
159)  * set the displayer to active, i.e. make it send image data
160)  * to the distributors automatically,
161)  * this function might trigger sending of data if the last
162)  * sending time was too long ago
163)  *

164)  * \param[in] p_displayer pointer to EtherPix displayer

165)  */

166) void etp_displayer_activate(etp_displayer_t *p_displayer)

167) {
168)   p_displayer->active = 1;

169)   etp_thread_cond_signal(&p_displayer->cond);

170) }
171) 
172) /**
173)  * \brief deactivate the displayer
174)  *
175)  * set the displayer to deactive, i.e. prevent it from sening image
176)  * data to the distributors automatically,
177)  *

178)  * \param[in] p_displayer pointer to EtherPix displayer

179)  */

180) void etp_displayer_deactivate(etp_displayer_t *p_displayer)

181) {
182)   p_displayer->active = 0;
183)   /* no need to signal condition: thread does not need to do something yet */
184) }
185) 
186) /**

187)  * \brief clear image data to output on EtherPix displayer

188)  *
189)  * clears the stored image data
190)  *

191)  * \param[in] p_displayer pointer to EtherPix displayer

192)  */

193) void etp_displayer_data_clear(etp_displayer_t *p_displayer)

194) {

195)   etp_thread_mutex_lock(&p_displayer->mtx);
196)   etp_display_data_clear(p_displayer->p_display);
197)   etp_thread_mutex_unlock(&p_displayer->mtx);

198) }
199) 
200) /**

201)  * \brief set image data to output on EtherPix display

202)  *
203)  * updates (part of) the stored image data
204)  *

205)  * \param[in] p_displayer pointer to EtherPix displayer

206)  * \param[in] p_data pointer to rectangular section of image data

207)  * \param[in] stride_x stride between two pixels in X direction
208)  * \param[in] stride_y stride between two pixels in Y direction
209)  * \param[in] x X coordinate of left side of rectangular area
210)  * \param[in] y Y coordinate of top side of rectangular area
211)  * \param[in] width with of rectangular area
212)  * \param[in] height height of rectangular area

213)  * \param[in] pixfmt format of pixel data
214)  */

215) void etp_displayer_data_fmt(etp_displayer_t *p_displayer, etp_u8_t *p_data,

216)                             int stride_x, int stride_y,
217)                             unsigned int x, unsigned int y,
218)                             unsigned int width, unsigned int height,

219)                             etp_pixfmt_t pixfmt)

220) {

221)   etp_thread_mutex_lock(&p_displayer->mtx);
222)   etp_display_data_fmt(p_displayer->p_display, p_data, stride_x, stride_y,

223)                        x, y, width, height, pixfmt);

224)   etp_thread_mutex_unlock(&p_displayer->mtx);

225) }
226) 
227) /**

228)  * \brief set image data to output on EtherPix display

229)  *

230)  * see etp_displayer_data_fmt for documentation
231)  * pixfmt is fixed to etp_pixfmt_rgb24

232)  */

233) void etp_displayer_data(etp_displayer_t *p_displayer, etp_u8_t *p_data,

234)                         int stride_x, int stride_y,
235)                         unsigned int x, unsigned int y,
236)                         unsigned int width, unsigned int height)
237) {

238)   etp_displayer_data_fmt(p_displayer, p_data, stride_x, stride_y,
239)                          x, y, width, height, etp_pixfmt_rgb24);

240) }
241) 
242) /**
243)  * \brief trigger immediate sending of new image data to distributors
244)  *
245)  * this only works if the displayer is active
246)  *

247)  * \param[in] p_displayer pointer to EtherPix displayer

248)  */

249) void etp_displayer_send(etp_displayer_t *p_displayer)

250) {
251)   p_displayer->send = 1;

252)   etp_thread_cond_signal(&p_displayer->cond);

253) }
254) 
255) /**
256)  * \brief output thread of displayer object
257)  *
258)  * \param[in] vp_displayer pointer to displayer object
259)  * \return unused, always NULL
260)  */

261) ETP_THREAD_FUNC(etp_displayer_thread)

262) {

263)   etp_displayer_t *p_displayer = (etp_displayer_t *)vp_displayer;

264)   struct timeval last, now, delta;
265)   int timed_send;

266)   int interval_ms = ETP_MCUF_MAX_FRAME_INTERVAL_MS;

267) 

268)   etp_thread_mutex_lock(&p_displayer->mtx);

269) 
270)   gettimeofday(&last, NULL); /* initialize last to some valid time */
271) 
272)   /* while thread shall not end */
273)   while (!p_displayer->end) {
274) 
275)     /* active */
276)     if (p_displayer->active) {
277) 
278)       /* get current time */
279)       gettimeofday(&now, NULL);
280)       /* get time since sending last frame */
281)       delta.tv_sec = now.tv_sec - last.tv_sec;
282)       delta.tv_usec = now.tv_usec - last.tv_usec;
283)       if (delta.tv_usec < 0) {
284)         delta.tv_usec += 1000000;
285)         ++delta.tv_sec;
286)       }
287)       /* check if late enough for timed send */

288)       timed_send = delta.tv_sec > interval_ms / 1000
289)                  || (delta.tv_sec == interval_ms / 1000
290)                      && delta.tv_usec >= (interval_ms % 1000) * 1000);

291) 
292)       /* send if send requested or late enough */
293)       if (p_displayer->send || timed_send) {

294)         etp_display_send(p_displayer->p_display); /* send */

295)         last = now;                               /* remember last send time */
296)         p_displayer->send = 0;                    /* clear send request */
297)       }
298) 
299)       /* sleep until next frame has to be sent */

300)       etp_thread_cond_timedwait(&p_displayer->cond, &p_displayer->mtx,

301)                                 &last, interval_ms);

302) 
303)     } /* if (p_displayer->active) */
304) 
305)     /* inactive */
306)     else {
307) 
308)       /* sleep */

309)       etp_thread_cond_wait(&p_displayer->cond, &p_displayer->mtx);

310) 
311)     } /* if (p_displayer->active) ... else */
312) 
313)   } /* while(!p_displayer->end) */
314) 

315)   etp_thread_mutex_unlock(&p_displayer->mtx);

316) 

317)   return ETP_THREAD_RETURN_OK;