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 "CallMgr.h"
13) #include "Directory.h"
14) #include "File.h"

15) #include "InStreamFile.h"

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

18) #include "Module.h"

19) #include "OutStreamFile.h"

20) #include "Player.h"

21) #include "PlayerMovie.h"

22) #include "StreamMgr.h"

23) #include "StreamRecv.h"

24) #include "Time.h"
25) #include "TimeCallee.h"
26) 
27) namespace Blinker {
28) 
29) /**
30)  * @brief constructor
31)  * @param[in] callMgr callback manager
32)  * @param[in] streamMgr stream manager
33)  * @param[in] dirBase base directory
34)  */
35) Player::Player(CallMgr &callMgr, StreamMgr &streamMgr,
36)                const Directory &dirBase):

37)   Module(callMgr, streamMgr, dirBase),

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

39)   m_fileHaltStream(dirBase.getFile("haltstream"), streamMgr),

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

41)   m_curValid(false),

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

44)   m_curChange(false),
45)   m_halted(false)

46) {
47)   // load playlist

48)   m_fileHaltStream.setStreamRecv(this);

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

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

56)   // cancel time callback request
57)   m_callMgr.cancelTimeCall(this);
58) 

59)   // free all movies

60)   m_playlistTracker.clear();

61)   m_fileHaltStream.setStreamRecv(NULL);

62) }
63) 

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

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

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

71)   }
72) 

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

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

80) }
81) 

82) /**
83)  * @brief set current frame
84)  * @param[in] stream stream name
85)  * @param[in] pFrame current frame (NULL for none)
86)  */
87) void Player::setFrame(const std::string &stream, stBlinkenFrame *pFrame)
88) {
89)   // this is coming from the halt stream, which will halt the player
90)   // whenever a frame is available on this halt stream
91) 
92)   // halt stream came to life -> halt player
93)   if (pFrame && !m_halted) {
94)     m_halted = true;
95)     if (m_curValid) {
96)       // store remaining frame time
97)       m_remainTime = m_nextTime - Time::now();
98)       if (m_remainTime < Time::zero)
99)         m_remainTime = Time::zero;
100)     }
101)     // cancel time call
102)     m_callMgr.cancelTimeCall(this);
103)   }
104) 
105)   // halt stream ended -> continue playing
106)   else if (!pFrame && m_halted) {
107)     m_halted = false;
108)     if (m_curValid) {
109)       // determine time for next frame
110)       m_nextTime = Time::now() + m_remainTime;
111)       // schedule time call
112)       m_callMgr.requestTimeCall(this, m_nextTime);
113)     }
114)   }
115) 
116)   (void)stream; // unused
117) }
118) 

119) /// callback when requested time reached

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

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

126)   // leave if time is not yet ready to next frame
127)   if (Time::now() < m_nextTime) {
128)     // request call at time for next frame
129)     m_callMgr.requestTimeCall(this, m_nextTime);
130)     return;
131)   }
132) 
133)   // go to next frame
134)   ++m_curFrame;
135) 
136)   // process new current frame
137)   procFrame();

138) }
139) 

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

142) {

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

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

149)     m_remainTime = Time::zero;

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

153)   } // if (m_curChange)

154) }
155) 

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

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

161)   m_curValid = true;

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

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

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

170)         m_curValid = false;
171)         break;

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

175)     if (!m_curValid)
176)       break;

177)     // movie not yet finished -> done

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

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

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

187) 

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

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

191)     stBlinkenFrame *pFrame =

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

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

195)     // request call at time for next frame

196)     if (!m_halted)
197)       m_callMgr.requestTimeCall(this, m_nextTime);

198)   }
199) }

200) 

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

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

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

208)     m_fileOutStream.setFrame(pFrame);

209)   }

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