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) 
9) #include <BlinkenLib/BlinkenFrame.h>
10) 
11) #include "Directory.h"
12) #include "File.h"

13) #include "InStreamFile.h"

14) #include "Mgrs.h"

15) #include "Module.h"

16) #include "OutStreamFile.h"

17) #include "Scaler.h"
18) #include "Size.h"
19) #include "StreamRecv.h"
20) 
21) namespace Blinker {
22) 
23) /**
24)  * @brief constructor

25)  * @param[in] name module name

26)  * @param[in] mgrs managers

27)  * @param[in] dirBase base directory
28)  */

29) Scaler::Scaler(const std::string &name, Mgrs &mgrs,

30)                  const Directory &dirBase):

31)   Module(name, mgrs, dirBase),

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

33)   m_fileSize(dirBase.getFile("size")),

34)   m_fileOutStream(dirBase.getFile("outstream"), mgrs.m_streamMgr)

35) {
36)   // set up
37)   getSize();

38)   m_fileInStream.setStreamRecv(this);

39) }
40) 
41) /// virtual destructor
42) Scaler::~Scaler()
43) {
44)   // clean up

45)   m_fileInStream.setStreamRecv(NULL);

46) }
47) 
48) /// check for update of configuration
49) void Scaler::updateConfig()
50) {
51)   // stream name or size file was modified -> re-get stream or size

52)   if (m_fileInStream.checkModified())
53)     m_fileInStream.update();
54)   if (m_fileSize.checkModified())

55)     getSize();

56)   if (m_fileOutStream.checkModified())
57)     m_fileOutStream.update();

58) }
59) 
60) /**
61)  * @brief set current frame
62)  * @param[in] stream stream name

63)  * @param[in] pFrame current frame (NULL for none)

64)  */
65) void Scaler::setFrame(const std::string &stream, stBlinkenFrame *pFrame)
66) {
67)   procFrame(pFrame);
68)   (void)stream; // unused
69) }
70) 
71) /// (re-)get size to scale to
72) void Scaler::getSize()
73) {
74)   // read size from size file

75)   m_fileSize.update();

76) 
77)   // send current frame to output stream
78)   sendFrame();
79) }
80) 
81) /// send current frame to output stream
82) void Scaler::sendFrame()
83) {
84)   // get current frame from input stream and process it

85)   procFrame(m_fileInStream.getCurFrame());

86) }
87) 
88) /**
89)  * @brief process frame

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

91)  */
92) void Scaler::procFrame(stBlinkenFrame *pFrame)
93) {

94)   int width, height;

95)   stBlinkenFrame *pProcFrame;
96) 

97)   // no frame or no size -> pass "no frame"

98)   if (!pFrame || !m_fileSize.m_valid) {
99)     m_fileOutStream.setFrame(NULL);

100)     return;
101)   }

102)   width = m_fileSize.m_obj.m_width;
103)   height = m_fileSize.m_obj.m_height;

104) 
105)   // size matches -> pass frame directly

106)   if (BlinkenFrameGetWidth(pFrame) == width &&
107)       BlinkenFrameGetHeight(pFrame) == height ) {
108)     m_fileOutStream.setFrame(pFrame);

109)     return;
110)   }
111) 
112)   // clone frame
113)   pProcFrame = BlinkenFrameClone(pFrame);

114)   if (!pProcFrame) {

115)     m_fileOutStream.setFrame(NULL);

116)     return;
117)   }
118) 
119)   // scale frame

120)   BlinkenFrameScale(pProcFrame, height, width);

121) 

122)   // pass processed frame to output stream

123)   m_fileOutStream.setFrame(pProcFrame);