libetherpix

1) /*

2)  * EtherPix library

3)  *

4)  * Copyright 2010-2011 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 <etherpix/display.h>
24) #include <etherpix/displayer.h>
25) #include <etherpix/msg.h>
26) #include <etherpix/types.h>

27) #include <intern/displayer.h>

28) #include <intern/thread.h>

29) #include <intern/types.h>
30) 
31) /**

32)  * \brief create a new EtherPix displayer

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

39)  * using etp_displayer_activate().

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

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

45)  *         or NULL on error
46)  */

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

49)                                       void *p_msg_ctx)
50) {

51)   etp_displayer_t *p_displayer;

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

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

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

59)       p_msg_func(p_msg_ctx, etp_msg_type_err,

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

70)   p_displayer->p_display = etp_display_create(sz_config_file,

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

75)       p_msg_func(p_msg_ctx, etp_msg_type_err,

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

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

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

87)       p_msg_func(p_msg_ctx, etp_msg_type_err,

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

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

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

98)       p_msg_func(p_msg_ctx, etp_msg_type_err,

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

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

105)                         (void *)p_displayer)) {

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

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

111)       p_msg_func(p_msg_ctx, etp_msg_type_err,

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

120)  * \brief free a EtherPix displayer

121)  *

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

123)  */

124) void etp_displayer_free(etp_displayer_t *p_displayer)

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

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

132) 
133)   /* free managed display */

134)   etp_display_free(p_displayer->p_display);

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

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

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

147) void etp_displayer_get_size(etp_displayer_t *p_displayer,

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

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

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

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

164)  */

165) void etp_displayer_activate(etp_displayer_t *p_displayer)

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

168)   etp_thread_cond_signal(&p_displayer->cond);

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

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

178)  */

179) void etp_displayer_deactivate(etp_displayer_t *p_displayer)

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

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

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

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

191)  */

192) void etp_displayer_data_clear(etp_displayer_t *p_displayer)

193) {

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

197) }
198) 
199) /**

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

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

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

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

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

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

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

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

218)                             etp_pixfmt_t pixfmt)

219) {

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

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

223)   etp_thread_mutex_unlock(&p_displayer->mtx);

224) }
225) 
226) /**

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

228)  *

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

231)  */

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

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

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

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

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

247)  */

248) void etp_displayer_send(etp_displayer_t *p_displayer)

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

251)   etp_thread_cond_signal(&p_displayer->cond);

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

260) ETP_THREAD_FUNC(etp_displayer_thread)

261) {

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

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

265)   int interval_ms = ETP_MCUF_MAX_FRAME_INTERVAL_MS;

266) 

267)   etp_thread_mutex_lock(&p_displayer->mtx);

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

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

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

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

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

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

300)                                 &last, interval_ms);

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

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

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

314)   etp_thread_mutex_unlock(&p_displayer->mtx);

315) 

316)   ETP_THREAD_RETURN(NULL);