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] mgrs managers

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

33) Player::Player(Mgrs &mgrs,

34)                const Directory &dirBase):

35)   Module(mgrs, dirBase),
36)   m_fileOutStream(dirBase.getFile("outstream"), mgrs.m_streamMgr),
37)   m_fileHaltStream(dirBase.getFile("haltstream"), mgrs.m_streamMgr),

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

39)   m_curValid(false),

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

42)   m_curChange(false),
43)   m_halted(false)

44) {
45)   // load playlist

46)   m_fileHaltStream.setStreamRecv(this);

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

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

54)   // cancel time callback request

55)   m_mgrs.m_callMgr.cancelTimeCall(this);

56) 

57)   // free all movies

58)   m_playlistTracker.clear();

59)   m_fileHaltStream.setStreamRecv(NULL);

60) }
61) 

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

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

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

69)   }
70) 

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

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

78) }
79) 

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

100)     m_mgrs.m_callMgr.cancelTimeCall(this);

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

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

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

117) /// callback when requested time reached

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

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

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

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

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

136) }
137) 

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

140) {

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

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

147)     m_remainTime = Time::zero;

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

151)   } // if (m_curChange)

152) }
153) 

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

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

159)   m_curValid = true;

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

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

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

168)         m_curValid = false;
169)         break;

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

173)     if (!m_curValid)
174)       break;

175)     // movie not yet finished -> done

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

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

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

185) 

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

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

189)     stBlinkenFrame *pFrame =

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

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

193)     // request call at time for next frame

194)     if (!m_halted)

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

196)   }
197) }

198) 

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

202)   // frame avalable -> send it
203)   if (m_curValid) {
204)     stBlinkenFrame *pFrame =

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

206)     m_fileOutStream.setFrame(pFrame);

207)   }

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