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 "InStreamFile.h"

16) #include "Module.h"

17) #include "OutStreamFile.h"

18) #include "Scaler.h"
19) #include "Size.h"
20) #include "StreamMgr.h"
21) #include "StreamRecv.h"
22) 
23) namespace Blinker {
24) 
25) /**
26)  * @brief constructor
27)  * @param[in] callMgr callback manager
28)  * @param[in] streamMgr stream manager
29)  * @param[in] dirBase base directory
30)  */
31) Scaler::Scaler(CallMgr &callMgr, StreamMgr &streamMgr,
32)                  const Directory &dirBase):
33)   Module(callMgr, streamMgr, dirBase),

34)   m_fileInStream(dirBase.getFile("instream"), streamMgr),

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

36)   m_fileOutStream(dirBase.getFile("outstream"), streamMgr)

37) {
38)   // set up
39)   getSize();

40)   m_fileInStream.setStreamRecv(this);

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

47)   m_fileInStream.setStreamRecv(NULL);

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

54)   if (m_fileInStream.checkModified())
55)     m_fileInStream.update();
56)   if (m_fileSize.checkModified())

57)     getSize();

58)   if (m_fileOutStream.checkModified())
59)     m_fileOutStream.update();

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

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

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

77)   m_fileSize.update();

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

87)   procFrame(m_fileInStream.getCurFrame());

88) }
89) 
90) /**
91)  * @brief process frame

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

93)  */
94) void Scaler::procFrame(stBlinkenFrame *pFrame)
95) {

96)   int width, height;

97)   stBlinkenFrame *pProcFrame;
98) 

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

100)   if (!pFrame || !m_fileSize.m_valid) {
101)     m_fileOutStream.setFrame(NULL);

102)     return;
103)   }

104)   width = m_fileSize.m_obj.m_width;
105)   height = m_fileSize.m_obj.m_height;

106) 
107)   // size matches -> pass frame directly

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

111)     return;
112)   }
113) 
114)   // clone frame
115)   pProcFrame = BlinkenFrameClone(pFrame);

116)   if (!pProcFrame) {

117)     m_fileOutStream.setFrame(NULL);

118)     return;
119)   }
120) 
121)   // scale frame

122)   BlinkenFrameScale(pProcFrame, height, width);

123) 
124)   // pass process frame to output stream

125)   m_fileOutStream.setFrame(pProcFrame);