Blinker

@@ -23,6 +23,19 @@

       The file <code>outstream</code> contains the name of the stream to

       send the frames to.

     </p>

+    <h3>Halt Stream</h3>

+    <p>

+      The player can be halted whenever another stream is active.

+      Therefore, the name of the other stream is written to the file

+      <code>haltstream</code>.

+      When the halt stream becoms active, the current frame is frozen,

+      i.e. the frame is kept.

+      When the halt stream ends, the player resumes with the remaining

+      time for the current frame and continues as usual afterwards.

+      <br>

+      If this feature is not needed, the file <code>haltstream</code>

+      should not exist.

+    </p>

   </body>

 </html>

@@ -12,13 +12,15 @@

 #include "CallMgr.h"

 #include "Directory.h"

 #include "File.h"

-#include "Module.h"

+#include "InStreamFile.h"

 #include "ListTracker.h"

 #include "ListTracker_impl.h"

+#include "Module.h"

 #include "OutStreamFile.h"

 #include "Player.h"

 #include "PlayerMovie.h"

 #include "StreamMgr.h"

+#include "StreamRecv.h"

 #include "Time.h"

 #include "TimeCallee.h"

@@ -34,13 +36,16 @@ Player::Player(CallMgr &callMgr, StreamMgr &streamMgr,

                const Directory &dirBase):

   Module(callMgr, streamMgr, dirBase),

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

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

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

   m_curValid(false),

   m_curEntry(m_playlistTracker.m_list.begin()),

   m_curFrame(0),

-  m_curChange(false)

+  m_curChange(false),

+  m_halted(false)

 {

   // load playlist

+  m_fileHaltStream.setStreamRecv(this);

   m_playlistTracker.init();

   checkCurChanged();

 }

@@ -53,6 +58,7 @@ Player::~Player()

   // free all movies

   m_playlistTracker.clear();

+  m_fileHaltStream.setStreamRecv(NULL);

 }

 /// check for update of configuration

@@ -64,14 +70,59 @@ void Player::updateConfig()

     sendFrame();

   }

+  // halt stream name file was modified -> re-get halt stream

+  if (m_fileHaltStream.checkModified())

+    m_fileHaltStream.update();

+

   // playlist update

   m_playlistTracker.updateConfig();

   checkCurChanged();

 }

+/**

+ * @brief set current frame

+ * @param[in] stream stream name

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

+ */

+void Player::setFrame(const std::string &stream, stBlinkenFrame *pFrame)

+{

+  // this is coming from the halt stream, which will halt the player

+  // whenever a frame is available on this halt stream

+

+  // halt stream came to life -> halt player

+  if (pFrame && !m_halted) {

+    m_halted = true;

+    if (m_curValid) {

+      // store remaining frame time

+      m_remainTime = m_nextTime - Time::now();

+      if (m_remainTime < Time::zero)

+        m_remainTime = Time::zero;

+    }

+    // cancel time call

+    m_callMgr.cancelTimeCall(this);

+  }

+

+  // halt stream ended -> continue playing

+  else if (!pFrame && m_halted) {

+    m_halted = false;

+    if (m_curValid) {

+      // determine time for next frame

+      m_nextTime = Time::now() + m_remainTime;

+      // schedule time call

+      m_callMgr.requestTimeCall(this, m_nextTime);

+    }

+  }

+

+  (void)stream; // unused

+}

+

 /// callback when requested time reached

 void Player::timeCall()

 {

+  // leave if halted

+  if (m_halted)

+    return;

+

   // leave if time is not yet ready to next frame

   if (Time::now() < m_nextTime) {

     // request call at time for next frame

@@ -95,6 +146,7 @@ void Player::checkCurChanged()

     // go to begin of new current movie and start playing now

     m_curFrame = 0;

+    m_remainTime = Time::zero;

     m_nextTime = Time::now();

     procFrame();

@@ -135,13 +187,13 @@ void Player::procFrame()

   // if a frame is there

   if (m_curValid) {

-    // calculate time for next frame

+    // get frame time and calculate absolute time for next frame

     stBlinkenFrame *pFrame =

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

-    Time duration;

-    duration.fromMs(BlinkenFrameGetDuration(pFrame));

-    m_nextTime += duration;

+    m_remainTime.fromMs(BlinkenFrameGetDuration(pFrame));

+    m_nextTime += m_remainTime;

     // request call at time for next frame

+    if (!m_halted)

       m_callMgr.requestTimeCall(this, m_nextTime);

   }

 }

@@ -14,17 +14,19 @@

 #include "CallMgr.h"

 #include "Directory.h"

 #include "File.h"

-#include "Module.h"

+#include "InStreamFile.h"

 #include "ListTracker.h"

+#include "Module.h"

 #include "OutStreamFile.h"

 #include "StreamMgr.h"

+#include "StreamRecv.h"

 #include "Time.h"

 #include "TimeCallee.h"

 namespace Blinker {

 /// a movie player

-class Player: public Module, public TimeCallee

+class Player: public Module, public StreamRecv, public TimeCallee

 {

 protected:

   /// movie in playlist

@@ -59,6 +61,13 @@ public:

   /// check for update of configuration

   virtual void updateConfig();

+  /**

+   * @brief set current frame

+   * @param[in] stream stream name

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

+   */

+  virtual void setFrame(const std::string &stream, stBlinkenFrame *pFrame);

+

   /// callback when requested time reached

   virtual void timeCall();

@@ -74,12 +83,18 @@ protected:

 protected:

   OutStreamFile   m_fileOutStream;   ///< output stream name file

+  InStreamFile    m_fileHaltStream;  /**< halt stream name file

+                                          (player halts if stream active) */

   PlaylistTracker m_playlistTracker; ///< current playlist

   bool            m_curValid;        ///< if there is a current frame

   PlaylistIt      m_curEntry;        ///< current playlist entry

   int             m_curFrame;        ///< current frame in movie

   bool            m_curChange;       ///< current movie changed

-  Time            m_nextTime;        ///< when to show next frame

+  bool            m_halted;          ///< if player is halted

+  Time            m_remainTime;      /**< remaining time of current frame

+                                          (valid if m_curValid && m_halted) */

+  Time            m_nextTime;        /**< when to show next frame

+                                          (valid if m_curValid && !m_halted) */

 }; // class Player

 } // namespace Blinker