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 = NULL;

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

147)   if (m_pInStream)
148)     m_pInStream->getCurFrame(pFrame);
149)   procFrame(pFrame);

150) }
151) 
152) /**
153)  * @brief process frame

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

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

164)   // no frame or no size -> pass "no frame"
165)   if (!pFrame || !m_haveSize) {
166)     m_pOutStream->setFrame(NULL);

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

179)   if (!pProcFrame) {
180)     m_pOutStream->setFrame(NULL);