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

14) #include "InStreamFile.h"

15) #include "ListTracker.h"
16) #include "ListTracker_impl.h"

17) #include "Mgrs.h"

18) #include "Module.h"

19) #include "OutStreamFile.h"

20) #include "Player.h"

21) #include "PlayerMovie.h"

22) #include "StreamRecv.h"

23) #include "Time.h"
24) #include "TimeCallee.h"
25) 
26) namespace Blinker {
27) 
28) /**
29)  * @brief constructor

30)  * @param[in] name module name

31)  * @param[in] mgrs managers

32)  * @param[in] dirBase base directory
33)  */

34) Player::Player(const std::string &name, Mgrs &mgrs,

35)                const Directory &dirBase):

36)   Module(name, mgrs, dirBase),

37)   m_fileOutStream(dirBase.getFile("outstream"), mgrs.m_streamMgr),
38)   m_fileHaltStream(dirBase.getFile("haltstream"), mgrs.m_streamMgr),

39)   m_playlistTracker(*this, dirBase.getSubdir("playlist")),

40)   m_curValid(false),

41)   m_curEntry(m_playlistTracker.m_list.begin()),
42)   m_curFrame(0),

43)   m_curChange(false),
44)   m_halted(false)

45) {
46)   // load playlist

47)   m_fileHaltStream.setStreamRecv(this);

48)   m_playlistTracker.init();
49)   checkCurChanged();

50) }
51) 
52) /// virtual destructor
53) Player::~Player()
54) {

55)   // cancel time callback request

56)   m_mgrs.m_callMgr.cancelTimeCall(this);

57) 

58)   // free all movies

59)   m_playlistTracker.clear();

60)   m_fileHaltStream.setStreamRecv(NULL);

61) }
62) 

63) /// check for update of configuration
64) void Player::updateConfig()
65) {

66)   // output stream name file was modified -> re-get output stream
67)   if (m_fileOutStream.checkModified()) {

68)     m_fileOutStream.update();
69)     sendFrame();

70)   }
71) 

72)   // halt stream name file was modified -> re-get halt stream
73)   if (m_fileHaltStream.checkModified())
74)     m_fileHaltStream.update();
75) 

76)   // playlist update
77)   m_playlistTracker.updateConfig();
78)   checkCurChanged();

79) }
80) 

81) /**
82)  * @brief set current frame
83)  * @param[in] stream stream name
84)  * @param[in] pFrame current frame (NULL for none)
85)  */
86) void Player::setFrame(const std::string &stream, stBlinkenFrame *pFrame)
87) {
88)   // this is coming from the halt stream, which will halt the player
89)   // whenever a frame is available on this halt stream
90) 
91)   // halt stream came to life -> halt player
92)   if (pFrame && !m_halted) {
93)     m_halted = true;
94)     if (m_curValid) {
95)       // store remaining frame time
96)       m_remainTime = m_nextTime - Time::now();
97)       if (m_remainTime < Time::zero)
98)         m_remainTime = Time::zero;
99)     }
100)     // cancel time call

101)     m_mgrs.m_callMgr.cancelTimeCall(this);

102)   }
103) 
104)   // halt stream ended -> continue playing
105)   else if (!pFrame && m_halted) {
106)     m_halted = false;
107)     if (m_curValid) {
108)       // determine time for next frame
109)       m_nextTime = Time::now() + m_remainTime;
110)       // schedule time call

111)       m_mgrs.m_callMgr.requestTimeCall(this, m_nextTime);

112)     }
113)   }
114) 
115)   (void)stream; // unused
116) }
117) 

118) /// callback when requested time reached

119) void Player::timeCall()
120) {

121)   // leave if halted
122)   if (m_halted)
123)     return;
124) 

125)   // leave if time is not yet ready to next frame
126)   if (Time::now() < m_nextTime) {
127)     // request call at time for next frame

128)     m_mgrs.m_callMgr.requestTimeCall(this, m_nextTime);

129)     return;
130)   }
131) 
132)   // go to next frame
133)   ++m_curFrame;
134) 
135)   // process new current frame
136)   procFrame();

137) }
138) 

139) /// check if current movie changed and react
140) void Player::checkCurChanged()

141) {

142)   // current movie changed
143)   if (m_curChange) {
144)     m_curChange = false;

145) 
146)     // go to begin of new current movie and start playing now
147)     m_curFrame = 0;

148)     m_remainTime = Time::zero;

149)     m_nextTime = Time::now();
150)     procFrame();
151) 

152)   } // if (m_curChange)

153) }
154) 

155) /// process current frame
156) void Player::procFrame()
157) {

158)   // movie finished -> next movie
159)   //   use while loops to handle empty movies / empty playlist

160)   m_curValid = true;

161)   bool wrapped = false;
162)   while (true) {
163)     // playlist finished -> re-start from beginning

164)     while (m_curEntry == m_playlistTracker.m_list.end()) {
165)       m_curEntry = m_playlistTracker.m_list.begin();

166)       m_curFrame = 0;
167)       // detect empty playlist or playlist with only empty movies
168)       if (wrapped) {

169)         m_curValid = false;
170)         break;

171)       }
172)       wrapped = true;
173)     }

174)     if (!m_curValid)
175)       break;

176)     // movie not yet finished -> done

177)     if (m_curFrame < BlinkenMovieGetFrameCnt(m_curEntry->m_pObj->m_pMovie))

178)       break;
179)     // movie finished -> next movie
180)     ++m_curEntry;
181)     m_curFrame = 0;
182)   }
183) 

184)   // send new frame to stream
185)   sendFrame();

186) 

187)   // if a frame is there
188)   if (m_curValid) {

189)     // get frame time and calculate absolute time for next frame

190)     stBlinkenFrame *pFrame =

191)       BlinkenMovieGetFrame(m_curEntry->m_pObj->m_pMovie, m_curFrame);

192)     m_remainTime.fromMs(BlinkenFrameGetDuration(pFrame));
193)     m_nextTime += m_remainTime;

194)     // request call at time for next frame

195)     if (!m_halted)

196)       m_mgrs.m_callMgr.requestTimeCall(this, m_nextTime);

197)   }
198) }

199) 

200) /// send current frame to output stream
201) void Player::sendFrame()
202) {

203)   // frame available -> send it

204)   if (m_curValid) {
205)     stBlinkenFrame *pFrame =

206)       BlinkenMovieGetFrame(m_curEntry->m_pObj->m_pMovie, m_curFrame);

207)     m_fileOutStream.setFrame(pFrame);

208)   }

209)   // no frame available -> send this information
210)   else
211)     m_fileOutStream.setFrame(NULL);