Blinker

1) /* Blinker
2)    Copyright 2011 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 <iostream>
7) #include <stdlib.h>
8) #include <string>
9) 
10) #include <BlinkenLib/BlinkenFrame.h>
11) 
12) #include "CallMgr.h"
13) #include "Directory.h"
14) #include "File.h"
15) #include "Format.h"
16) #include "Module.h"
17) #include "Resizer.h"
18) #include "SettingFile.h"
19) #include "StreamMgr.h"
20) #include "StreamRecv.h"
21) 
22) namespace Blinker {
23) 
24) /**
25)  * @brief constructor
26)  * @param[in] callMgr callback manager
27)  * @param[in] streamMgr stream manager
28)  * @param[in] dirBase base directory
29)  */
30) Resizer::Resizer(CallMgr &callMgr, StreamMgr &streamMgr,
31)                  const Directory &dirBase):
32)   Module(callMgr, streamMgr, dirBase),
33)   m_fileInStream(dirBase.getFile("instream")),
34)   m_fileFormat(dirBase.getFile("format")),
35)   m_fileOutStream(dirBase.getFile("outstream")),
36)   m_pInStream(NULL),
37)   m_haveFormat(false),
38)   m_pOutStream(NULL)
39) {
40)   // set up
41)   getInStream();
42)   getFormat();
43)   getOutStream();
44) }
45) 
46) /// virtual destructor
47) Resizer::~Resizer()
48) {
49)   // clean up
50)   releaseInStream();
51)   releaseOutStream();
52) }
53) 
54) /// check for update of configuration
55) void Resizer::updateConfig()
56) {
57)   // stream name or format file was modified -> re-get stream or format
58)   if (m_fileInStream.checkModified()) {
59)     releaseInStream();
60)     getInStream();
61)   }
62)   if (m_fileFormat.checkModified()) {
63)     getFormat();
64)   }
65)   if (m_fileOutStream.checkModified()) {
66)     releaseOutStream();
67)     getOutStream();
68)   }
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 Resizer::setFrame(const std::string &stream, stBlinkenFrame *pFrame)
77) {
78)   procFrame(pFrame);
79)   (void)stream; // unused
80) }
81) 
82) /// get input stream and attach to it
83) void Resizer::getInStream()
84) {
85)   // get input stream
86)   m_fileInStream.getStr(m_nameInStream);
87)   m_pInStream = &m_streamMgr.refStream(m_nameInStream);
88) 
89)   // attach to input stream
90)   if (m_pInStream)
91)     m_pInStream->attach(this);
92) }
93) 
94) /// detach from input stream and release it
95) void Resizer::releaseInStream()
96) {
97)   // detach from input stream
98)   if (m_pInStream)
99)     m_pInStream->detach(this);
100) 
101)   // unreference stream
102)   m_pInStream = NULL;
103)   m_streamMgr.unrefStream(m_nameInStream);
104) }
105) 
106) /// (re-)get format to resize to
107) void Resizer::getFormat()
108) {
109)   std::string strFormat;
110) 
111)   // read format from format file
112)   m_haveFormat = m_fileFormat.getStr(strFormat) && m_format.fromStr(strFormat);
113) 
114)   // send current frame to output stream
115)   sendFrame();
116) }
117) 
118) /// get output stream
119) void Resizer::getOutStream()
120) {
121)   // get output stream
122)   m_fileOutStream.getStr(m_nameOutStream);
123)   m_pOutStream = &m_streamMgr.refStream(m_nameOutStream);
124) 
125)   // send current frame to output stream
126)   sendFrame();
127) }
128) 
129) /// release output stream
130) void Resizer::releaseOutStream()
131) {
132)   // send no frame information
133)   if (m_pOutStream)

134)     m_pOutStream->setFrame(NULL);

135) 
136)   // unreference stream
137)   m_pOutStream = NULL;
138)   m_streamMgr.unrefStream(m_nameOutStream);
139) }
140) 
141) /// send current frame to output stream
142) void Resizer::sendFrame()
143) {

144)   stBlinkenFrame *pFrame;

145) 
146)   // get current frame from input stream and process it

147)   if (m_pInStream)

148)     pFrame = m_pInStream->getCurFrame();
149)   else
150)     pFrame = NULL;

151)   procFrame(pFrame);

152) }
153) 
154) /**
155)  * @brief process frame

156)  * @param[in] pFrame frame to process (NULL for none)

157)  */
158) void Resizer::procFrame(stBlinkenFrame *pFrame)
159) {
160)   stBlinkenFrame *pProcFrame;
161) 
162)   // no output stream -> nothing to do
163)   if (!m_pOutStream)
164)     return;
165) 

166)   // no frame or no format -> pass "no frame"
167)   if (!pFrame || !m_haveFormat) {
168)     m_pOutStream->setFrame(NULL);

169)     return;
170)   }
171) 
172)   // format matches -> pass frame directly
173)   if ((unsigned int)BlinkenFrameGetWidth(pFrame) == m_format.m_width &&
174)       (unsigned int)BlinkenFrameGetHeight(pFrame) == m_format.m_height &&
175)       (unsigned int)BlinkenFrameGetChannels(pFrame) == m_format.m_channels &&
176)       (unsigned int)BlinkenFrameGetMaxval(pFrame) == m_format.m_maxval) {
177)     m_pOutStream->setFrame(pFrame);
178)     return;
179)   }
180) 
181)   // clone frame
182)   pProcFrame = BlinkenFrameClone(pFrame);
183)   if (!pProcFrame){

184)     m_pOutStream->setFrame(NULL);