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 "Module.h"
16) #include "Scaler.h"
17) #include "SettingFile.h"
18) #include "Size.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) Scaler::Scaler(CallMgr &callMgr, StreamMgr &streamMgr,
31)                  const Directory &dirBase):
32)   Module(callMgr, streamMgr, dirBase),
33)   m_fileInStream(dirBase.getFile("instream")),
34)   m_fileSize(dirBase.getFile("size")),
35)   m_fileOutStream(dirBase.getFile("outstream")),
36)   m_pInStream(NULL),
37)   m_haveSize(false),
38)   m_pOutStream(NULL)
39) {
40)   // set up
41)   getInStream();
42)   getSize();
43)   getOutStream();
44) }
45) 
46) /// virtual destructor
47) Scaler::~Scaler()
48) {
49)   // clean up
50)   releaseInStream();
51)   releaseOutStream();
52) }
53) 
54) /// check for update of configuration
55) void Scaler::updateConfig()
56) {
57)   // stream name or size file was modified -> re-get stream or size
58)   if (m_fileInStream.checkModified()) {
59)     releaseInStream();
60)     getInStream();
61)   }
62)   if (m_fileSize.checkModified()) {
63)     getSize();
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 Scaler::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 Scaler::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 Scaler::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 size to scale to
107) void Scaler::getSize()
108) {
109)   std::string strSize;
110) 
111)   // read size from size file
112)   m_haveSize = m_fileSize.getStr(strSize) && m_size.fromStr(strSize);
113) 
114)   // send current frame to output stream
115)   sendFrame();
116) }
117) 
118) /// get output stream
119) void Scaler::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 Scaler::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 Scaler::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 Scaler::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 size -> pass "no frame"
167)   if (!pFrame || !m_haveSize) {
168)     m_pOutStream->setFrame(NULL);

169)     return;
170)   }
171) 
172)   // size matches -> pass frame directly
173)   if ((unsigned int)BlinkenFrameGetWidth(pFrame) == m_size.m_width &&
174)       (unsigned int)BlinkenFrameGetHeight(pFrame) == m_size.m_height) {
175)     m_pOutStream->setFrame(pFrame);
176)     return;
177)   }
178) 
179)   // clone frame
180)   pProcFrame = BlinkenFrameClone(pFrame);

181)   if (!pProcFrame) {
182)     m_pOutStream->setFrame(NULL);