Blinker

1) /* Blinker

2)    Copyright 2011-2014 Stefan Schuermans <stefan@blinkenarea.org>

3)    Copyleft GNU public license - http://www.gnu.org/copyleft/gpl.html
4)    a blinkenarea.org project */
5) 
6) #include <stdlib.h>
7) #include <string>
8) #include <string.h>
9) 
10) #include <BlinkenLib/BlinkenFrame.h>
11) #include <BlinkenLib/BlinkenProto.h>
12) 
13) #ifdef BLINKER_CFG_FLEXIPIX
14) extern "C" {
15) #include <flexipix/flexipix.h>
16) } // extern "C"
17) #endif // #ifdef BLINKER_CFG_FLEIXPIX
18) 
19) #include "Directory.h"
20) #include "File.h"
21) #include "FlexiPix.h"
22) #include "InStreamFile.h"

23) #include "Mgrs.h"

24) #include "Module.h"
25) #include "Size.h"
26) #include "StreamRecv.h"
27) #include "Time.h"
28) #include "TimeCallee.h"
29) 
30) namespace Blinker {
31) 
32) /**
33)  * @brief constructor

34)  * @param[in] name module name

35)  * @param[in] mgrs managers

36)  * @param[in] dirBase base directory
37)  */

38) FlexiPix::FlexiPix(const std::string &name, Mgrs &mgrs,

39)                  const Directory &dirBase):

40)   Module(name, mgrs, dirBase),

41)   m_fileInStream(dirBase.getFile("instream"), mgrs.m_streamMgr),

42)   m_fileConfig(dirBase.getFile("flexipix.flp")),
43)   m_pDisplay(NULL)
44) {
45)   // set up
46)   m_fileInStream.setStreamRecv(this);
47)   createDisplay();
48) }
49) 
50) /// virtual destructor
51) FlexiPix::~FlexiPix()
52) {
53)   // clean up
54)   destroyDisplay();
55)   m_fileInStream.setStreamRecv(NULL);

56)   m_mgrs.m_callMgr.cancelTimeCall(this);

57) }
58) 
59) /// check for update of configuration
60) void FlexiPix::updateConfig()
61) {
62)   // input stream name file was modified -> re-get input stream
63)   if (m_fileInStream.checkModified())
64)     m_fileInStream.update();
65) 
66)   // FlexiPix config file was modified -> re-create display
67)   if (m_fileConfig.checkModified())
68)     createDisplay();
69) }
70) 
71) /**
72)  * @brief set current frame
73)  * @param[in] stream stream name
74)  * @param[in] pFrame current frame (NULL for none)
75)  */
76) void FlexiPix::setFrame(const std::string &stream, stBlinkenFrame *pFrame)
77) {
78)   displayFrame(pFrame);
79)   (void)stream; // unused
80) }
81) 
82) /// callback when requested time reached
83) void FlexiPix::timeCall()
84) {
85)   // refresh frame
86)   sendFrame();
87) }
88) 
89) /// (re-)create FlexiPix display
90) void FlexiPix::createDisplay()
91) {
92) #ifdef BLINKER_CFG_FLEXIPIX
93)   destroyDisplay();
94) 
95)   // create a display
96)   m_pDisplay = flp_display_create(m_fileConfig.getPath().c_str(), NULL, NULL);
97)   if (!m_pDisplay)
98)     return;
99) 
100)   // get size of display
101)   flp_display_get_size(m_pDisplay, &m_size.m_width, &m_size.m_height);
102) 
103)   // output current frame
104)   displayFrame(m_fileInStream.getCurFrame());
105) #endif // #ifdef BLINKER_CFG_FLEXIPIX
106) }
107) 
108) /// destroy FlexiPix display
109) void FlexiPix::destroyDisplay()
110) {
111) #ifdef BLINKER_CFG_FLEXIPIX
112)   if (m_pDisplay) {
113)     flp_display_free(m_pDisplay);
114)     m_pDisplay = NULL;
115)   }
116) #endif // #ifdef BLINKER_CFG_FLEXIPIX
117) }
118) 
119) /**
120)  * @brief display frame on FlexiPix
121)  * @param[in] pFrame frame to display (or NULL)
122)  */
123) void FlexiPix::displayFrame(stBlinkenFrame *pFrame)
124) {
125) #ifdef BLINKER_CFG_FLEXIPIX
126)   char data[65536];
127)   bool haveData = false;
128)   stBlinkenFrame *pClonedFrame;
129) 
130)   // leave if no display
131)   if (!m_pDisplay)
132)     return;
133) 
134)   // convert frame to needed size and then to MCUF data as FlexiPix library
135)   // can read data section of MCUF packet
136) 
137)   // frame available
138)   if (pFrame) {
139)     // format matches (size matches and 24bit RGB as required by FlexiPix)
140)     if (BlinkenFrameGetWidth(pFrame) == (int)m_size.m_width &&
141)         BlinkenFrameGetHeight(pFrame) == (int)m_size.m_height &&
142)         BlinkenFrameGetChannels(pFrame) == 3 &&
143)         BlinkenFrameGetMaxval(pFrame) == 255) {
144)       // convert to MCUF packet
145)       haveData = BlinkenFrameToNetwork(pFrame, BlinkenProtoMcuf,
146)                                        data, sizeof(data)) >= 0;
147)     }
148)     // format does not match
149)     else {
150)       // convert format: clone and resize
151)       pClonedFrame = BlinkenFrameClone(pFrame);
152)       if (pClonedFrame) {
153)         BlinkenFrameResize(pClonedFrame, m_size.m_height,
154)                            m_size.m_width, 3, 255);
155)         // convert to MCUF packet
156)         haveData = BlinkenFrameToNetwork(pFrame, BlinkenProtoMcuf,
157)                                          data, sizeof(data)) >= 0;
158)         // free clones frame
159)         BlinkenFrameFree(pClonedFrame);
160)       }
161)     }
162)   }
163) 
164)   // data available -> to FlexiPix display
165)   if (haveData)
166)     flp_display_data(m_pDisplay, (flp_u8_t*)(data + 12), 3, m_size.m_width * 3,
167)                      0, 0, m_size.m_width, m_size.m_height);
168)   // no data available -> clear FlexiPix display
169)   else
170)     flp_display_data_clear(m_pDisplay);
171) 
172)   // send configured frame
173)   sendFrame();
174) #else // #ifdef BLINKER_CFG_FLEXIPIX
175)   (void)pFrame;
176) #endif // #ifdef BLINKER_CFG_FLEXIPIX else
177) }
178) 
179) /// (re-)send frame to FlexiPix
180) void FlexiPix::sendFrame()
181) {
182) #ifdef BLINKER_CFG_FLEXIPIX
183)   if (m_pDisplay) {
184)     flp_display_send(m_pDisplay);

185)     m_mgrs.m_callMgr.requestTimeCall(this, Time::now() + Time(1)); // refresh