Blinker

@@ -35,6 +35,25 @@

       <br>

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

       should not exist.

+      <br>

+      This feature should not be used together with the synchronization

+      feature.

+    </p>

+    <h3>Input Synchronization Stream</h3>

+    <p>

+      The player can be synchronized to a master by using a synchronization

+      stream.

+      To achieve this, the name of the synchronization stream is written to

+      the file <code>insync</code>.

+      The player will then seek to the movie and the position requested via

+      the synchronization stream.

+      It will also go to pause mode whenever the synchronization stream

+      requests it.

+      <br>

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

+      should not exist.

+      <br>

+      This feature should not be used together with the halt stream feature.

     </p>

   </body>

 </html>

@@ -0,0 +1 @@

+test

@@ -0,0 +1 @@

+sync

@@ -1,2 +1,3 @@

 *.d

 *.o

+.*.swp

@@ -36,15 +36,21 @@ Player::Player(const std::string &name, Mgrs &mgrs,

   Module(name, mgrs, dirBase),

   m_fileOutStream(dirBase.getFile("outstream"), mgrs.m_streamMgr),

   m_fileHaltStream(dirBase.getFile("haltstream"), mgrs.m_streamMgr),

+  m_fileInSync(dirBase.getFile("insync"), mgrs.m_syncMgr),

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

   m_curValid(false),

   m_curEntry(m_playlistTracker.m_list.begin()),

   m_curFrame(0),

+  m_curFrameStart(0),

+  m_curFrameEnd(0),

   m_curChange(false),

   m_halted(false)

 {

-  // load playlist

+  m_maxDeviation.fromMs(30);

+

+  // init and load playlist

   m_fileHaltStream.setStreamRecv(this);

+  m_fileInSync.setSyncRecv(this);

   m_playlistTracker.init();

   checkCurChanged();

 }

@@ -55,9 +61,10 @@ Player::~Player()

   // cancel time callback request

   m_mgrs.m_callMgr.cancelTimeCall(this);

-  // free all movies

+  // free all movies, detach from stream sources

   m_playlistTracker.clear();

   m_fileHaltStream.setStreamRecv(NULL);

+  m_fileInSync.setSyncRecv(NULL);

 }

 /// check for update of configuration

@@ -73,6 +80,10 @@ void Player::updateConfig()

   if (m_fileHaltStream.checkModified())

     m_fileHaltStream.update();

+  // input sync stream name file was modified -> re-get input sync stream

+  if (m_fileInSync.checkModified())

+    m_fileInSync.update();

+

   // playlist update

   m_playlistTracker.updateConfig();

   checkCurChanged();

@@ -88,31 +99,155 @@ 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();

+  // halt stream active -> halt player

+  if (pFrame)

+    halt();

+

+  // halt stream inactive -> continue playing

+  else

+    cont();

+

+  (void)stream; // unused

+}

+

+/**

+ * @brief send synchronization information

+ * @param[in] sync sync stream name

+ * @param[in] pInfo synchronization information

+ */

+void Player::sendInfo(const std::string &sync, Info &info)

+{

+  bool change = false, seekPos = true;

+

+  // halt player if pause flag is set

+  if (info.pause)

+    halt();

+

+  // seek to other movie if not correct one

+  if (m_curEntry != m_playlistTracker.m_list.end() &&

+      !checkName(m_curEntry->m_name, info.name)) {

+    // find movie by name

+    PlaylistIt it = m_playlistTracker.m_list.begin();

+    while (it != m_playlistTracker.m_list.end()) {

+      if (checkName(it->m_name, info.name))

+        break;

+      ++it;

+    }

+    // movie found -> seek to it

+    if (it != m_playlistTracker.m_list.end()) {

+      change = true;

+      m_curValid = false;

+      m_curEntry = it;

+      m_curFrame = 0;

+      m_remainTime = Time::zero;

+      if (m_curEntry->m_pObj->m_pMovie) {

+        stBlinkenFrame *pFrame =

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

+        if (pFrame) {

+          m_remainTime.fromMs(BlinkenFrameGetDuration(pFrame));

+          m_curValid = true;

+        }

+      }

+      m_curFrameStart = Time::zero;

+      m_curFrameEnd = m_remainTime;

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

+    }

+    // movie not found -> do not seek to position

+    else {

+      seekPos = false;

+    }

+  }

+

+  Time now = Time::now();

+

+  if (m_curValid && seekPos) {

+

+    // get frame count of current movie

+    int frameCnt = BlinkenMovieGetFrameCnt(m_curEntry->m_pObj->m_pMovie);

+

+    // get remaining frame time and current position in movie

+    if (!m_halted) { // remaining frame time always up-to-date in halted mode

+      m_remainTime = m_nextTime - now;

       if (m_remainTime < Time::zero)

         m_remainTime = Time::zero;

     }

-    // cancel time call

-    m_mgrs.m_callMgr.cancelTimeCall(this);

+    Time pos = m_curFrameEnd - m_remainTime;

+

+    // seek to earlier position in movie if needed

+    while (pos > info.pos + m_maxDeviation) {

+      change = true;

+      Time frame = m_curFrameEnd - m_curFrameStart;

+      Time shown = frame - m_remainTime;

+      Time goback = pos - info.pos;

+      // correct by just showing current frame some time longer

+      if (goback <= shown) {

+        pos -= goback;

+        m_remainTime += goback;

+        break;

       }

+      // go back to begin of current frame

+      goback -= shown;

+      pos -= shown;

+      m_remainTime = frame;

+      // go back to end of previous frame

+      if (m_curFrame <= 0)

+        break;

+      m_curFrame--;

+      m_curFrameEnd = m_curFrameStart;

+      frame = Time::zero;

+      stBlinkenFrame *pFrame =

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

+      if (pFrame)

+        frame.fromMs(BlinkenFrameGetDuration(pFrame));

+      m_curFrameStart = m_curFrameEnd - frame;

+      m_remainTime = Time::zero;

+    } // while (pos > info.pos + m_maxDeviation)

-  // 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

+    // seek to later position in movie if needed

+    while (pos + m_maxDeviation < info.pos) {

+      change = true;

+      Time frame = m_curFrameEnd - m_curFrameStart;

+      Time go = info.pos - pos;

+      // correct by just showing current frame some time shorter

+      if (go <= m_remainTime) {

+        pos += go;

+        m_remainTime -= go;

+        break;

+      }

+      // go to end of current frame

+      go -= m_remainTime;

+      pos += m_remainTime;

+      m_remainTime = Time::zero;

+      // go to begin of next frame

+      if (m_curFrame >= frameCnt)

+        break;

+      m_curFrame++;

+      m_curFrameStart = m_curFrameEnd;

+      frame = Time::zero;

+      stBlinkenFrame *pFrame =

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

+      if (pFrame)

+        frame.fromMs(BlinkenFrameGetDuration(pFrame));

+      m_curFrameEnd = m_curFrameStart + frame;

+      m_remainTime = frame;

+    } // while (pos + m_maxDeviation < info.pos)

+

+  } // if (m_curValid)

+

+  // send frame and update timed callback if something changed

+  if (change) {

+    sendFrame();

+    if (m_curValid && !m_halted) {

+      m_nextTime = now + m_remainTime; // remaining time changed -> update

       m_mgrs.m_callMgr.requestTimeCall(this, m_nextTime);

     }

   }

-  (void)stream; // unused

+  // continue playing if pause flag is not set

+  if (!info.pause)

+    cont();

+

+  (void)sync; // unused

 }

 /// callback when requested time reached

@@ -122,7 +257,7 @@ void Player::timeCall()

   if (m_halted)

     return;

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

+  // leave if time is not yet ready for next frame

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

     // request call at time for next frame

     m_mgrs.m_callMgr.requestTimeCall(this, m_nextTime);

@@ -131,11 +266,49 @@ void Player::timeCall()

   // go to next frame

   ++m_curFrame;

+  m_curFrameStart = m_curFrameEnd;

   // process new current frame

   procFrame();

 }

+/// halt player

+void Player::halt()

+{

+  // player already halted -> leave

+  if (m_halted)

+    return;

+

+  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_mgrs.m_callMgr.cancelTimeCall(this);

+}

+

+/// continue playing

+void Player::cont()

+{

+  // player not halted -> leave

+  if (!m_halted)

+    return;

+

+  m_halted = false;

+

+  if (m_curValid) {

+    // determine time for next frame

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

+    // schedule time call

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

+  }

+}

+

 /// check if current movie changed and react

 void Player::checkCurChanged()

 {

@@ -145,6 +318,8 @@ void Player::checkCurChanged()

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

     m_curFrame = 0;

+    m_curFrameStart = 0;

+    m_curFrameEnd = 0;

     m_remainTime = Time::zero;

     m_nextTime = Time::now();

     procFrame();

@@ -164,6 +339,8 @@ void Player::procFrame()

     while (m_curEntry == m_playlistTracker.m_list.end()) {

       m_curEntry = m_playlistTracker.m_list.begin();

       m_curFrame = 0;

+      m_curFrameStart = 0;

+      m_curFrameEnd = 0;

       // detect empty playlist or playlist with only empty movies

       if (wrapped) {

         m_curValid = false;

@@ -180,7 +357,9 @@ void Player::procFrame()

     // movie finished -> next movie

     ++m_curEntry;

     m_curFrame = 0;

-  }

+    m_curFrame = 0;

+    m_curFrameStart = 0;

+  } // while (true)

   // send new frame to stream

   sendFrame();

@@ -192,6 +371,7 @@ void Player::procFrame()

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

     m_remainTime.fromMs(BlinkenFrameGetDuration(pFrame));

     m_nextTime += m_remainTime;

+    m_curFrameEnd = m_curFrameStart + m_remainTime;

     // request call at time for next frame

     if (!m_halted)

       m_mgrs.m_callMgr.requestTimeCall(this, m_nextTime);

@@ -14,18 +14,21 @@

 #include "Directory.h"

 #include "File.h"

 #include "InStreamFile.h"

+#include "InSyncFile.h"

 #include "ListTracker.h"

 #include "Mgrs.h"

 #include "Module.h"

 #include "OutStreamFile.h"

 #include "StreamRecv.h"

+#include "SyncRecv.h"

 #include "Time.h"

 #include "TimeCallee.h"

 namespace Blinker {

 /// a movie player

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

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

+              public TimeCallee

 {

 protected:

   /// movie in playlist

@@ -67,10 +70,23 @@ public:

    */

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

+  /**

+   * @brief send synchronization information

+   * @param[in] sync sync stream name

+   * @param[in] pInfo synchronization information

+   */

+  virtual void sendInfo(const std::string &sync, Info &info);

+

   /// callback when requested time reached

   virtual void timeCall();

 protected:

+  /// halt player

+  void halt();

+

+  /// continue playing

+  void cont();

+

   /// check if current movie changed and react

   void checkCurChanged();

@@ -84,16 +100,22 @@ protected:

   OutStreamFile   m_fileOutStream;   ///< output stream name file

   InStreamFile    m_fileHaltStream;  /**< halt stream name file

                                           (player halts if stream active) */

+  InSyncFile      m_fileInSync;      ///< input sync stream

   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

+  Time            m_curFrameStart;   /**< start time of current frame

+                                          relative to start of movie */

+  Time            m_curFrameEnd;     /**< end time of current frame

+                                          relative to start of movie */

   bool            m_curChange;       ///< current movie changed

   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) */

+  Time            m_maxDeviation;    ///< max. deviation from sync stream

 }; // class Player

 } // namespace Blinker

@@ -57,7 +57,7 @@ void SyncPrinter::sendInfo(const std::string &sync, Info &info)

 {

   std::cout << "sync pause=" << (info.pause ? "true" : "false") <<

                " name=\"" << info.name << "\"" <<

-               " pos=" << info.pos_ms << "ms" <<

+               " pos=" << info.pos.toFloatSec() << "s" <<

                std::endl;

   (void)sync; // unused

 }

@@ -194,7 +194,7 @@ void SyncReceiver<ADDR, SOCK>::procInfo(const std::string &data)

     return;

   info.pause = (Net2Host32(packet.flags) & PoSyPause) != 0;

   info.name = packet.name;

-  info.pos_ms = Net2Host32(packet.pos_ms);

+  info.pos.fromMs(Net2Host32(packet.pos_ms));

   // pass on sync information

   m_fileOutSync.sendInfo(info);

@@ -7,6 +7,40 @@

 namespace Blinker {

+/**

+ * @brief check if playlist entry name matches sync name

+ * @param[in] playlist name in playlist

+ * @param[in] sync name from synchronization information

+ * @return true if name matches, false otherwise

+ */

+bool SyncRecv::checkName(const std::string &playlist, const std::string &sync)

+{

+  std::string::size_type pos;

+  std::string noext;

+

+  // full match

+  if (playlist == sync)

+    return true;

+

+  // match without file extension

+  pos = playlist.rfind('.');

+  noext = playlist.substr(0, pos);

+  if (noext == sync)

+    return true;

+

+  // match without number prefix "[0-9]*[._-]?"

+  for (pos = 0; pos < noext.length() && std::isdigit(noext.at(pos)); ++pos);

+  if (pos < noext.length() &&

+      (noext.at(pos) == '.' || noext.at(pos) == '_' || noext.at(pos) == '-'))

+    ++pos;

+  noext = noext.substr(pos);

+  if (noext == sync)

+    return true;

+

+  // no match

+  return false;

+}

+

 /// constructor

 SyncRecv::SyncRecv()

 {

@@ -6,9 +6,10 @@

 #ifndef BLINKER_SYNCRECV_H

 #define BLINKER_SYNCRECV_H

-#include <stdint.h>

 #include <string>

+#include "Time.h"

+

 namespace Blinker {

 /// video sync stream receiver interface

@@ -19,9 +20,18 @@ public:

   struct Info {

     bool        pause; ///< if pause mode is active

     std::string name;  ///< name of current piece

-    uint32_t    pos_ms; ///< current position within the piece in milliseconds

+    Time        pos;   ///< current position within the piece

   };

+public:

+  /**

+   * @brief check if playlist entry name matches sync name

+   * @param[in] playlist name in playlist

+   * @param[in] sync name from synchronization information

+   * @return true if name matches, false otherwise

+   */

+  static bool checkName(const std::string &playlist, const std::string &sync);

+

 public:

   /// constructor

   SyncRecv();

@@ -1,2 +1,3 @@

 *.d

 *.o

+.*.swp

@@ -170,6 +170,15 @@ time_t Time::toSec() const

     return m_sec;

 }

+/**

+ * @brief convert to floating point seconds

+ * @return time in seconds

+ */

+float Time::toFloatSec()

+{

+  return m_sec + m_ns * 1.0e-9f;

+}

+

 /**

  * @brief convert to struct timeval

  * @param[out] tv struct timeval

@@ -73,6 +73,12 @@ public:

    */

   time_t toSec() const;

+  /**

+   * @brief convert to floating point seconds

+   * @return time in seconds

+   */

+  float toFloatSec();

+

   /**

    * @brief convert to struct timeval

    * @param[out] tv struct timeval