common/JackTransportEngine.h

   1 /*
   2 Copyright (C) 2001 Paul Davis
   3 Copyright (C) 2004-2008 Grame
   4
   5 This program is free software; you can redistribute it and/or modify
   6 it under the terms of the GNU Lesser General Public License as published by
   7 the Free Software Foundation; either version 2.1 of the License, or
   8 (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU Lesser General Public License for more details.
  14
  15 You should have received a copy of the GNU Lesser General Public License
  16 along with this program; if not, write to the Free Software
  17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18
  19 */
  20
  21 #ifndef __JackTransportEngine__
  22 #define __JackTransportEngine__
  23
  24 #include "JackAtomicArrayState.h"
  25 #include "JackCompilerDeps.h"
  26 #include "types.h"
  27
  28 namespace Jack
  29 {
  30
  31 typedef enum {
  32     TransportCommandNone = 0,
  33     TransportCommandStart = 1,
  34     TransportCommandStop = 2,
  35 } transport_command_t;
  36
  37 /*!
  38 \brief The client transport structure.
  39
  40 We have:
  41
  42         - a "current" position
  43         - a "pending" position prepared by the server at each cycle
  44         - a "request" position wanted by a client
  45
  46         At the beginning of a cycle the server needs to select a new current position. When a request and a pending position are available,
  47         the request takes precedence on the pending one. The server atomically switches to the new position.
  48         The current position can be read by clients.
  49
  50         We use a JackAtomicArrayState pattern that allows to manage several "next" states independantly.
  51
  52     In jack1 implementation, transport code (jack_transport_cycle_end) was not called if the graph could not be locked (see jack_run_one_cycle).
  53     Here transport cycle (CycleBegin, CycleEnd) has to run in the RT thread concurrently with code executed from the "command" thread.
  54
  55     Each client maintains a state in it's shared memory area defined by:
  56
  57     - it's current transport state
  58     - a boolean that is "true" when slow-sync cb has to be called
  59     - a boolean that is "true" when timebase cb is called with new_pos on
  60
  61     Several operations set the "slow-sync cb" flag to true:
  62
  63         - setting a new cb (client)
  64         - activate (client)
  65         - transport start (server)
  66         - new pos (server)
  67
  68     Slow-sync cb calls stops when:
  69
  70         - the cb return true (client)
  71         - desactivate (client)
  72         - transport stop (server)
  73
  74     Several operations set the "timebase cb" flag to true:
  75
  76         - setting a new cb (client)
  77         - activate (client)
  78         - transport start (server) ??
  79         - new pos (server)
  80
  81     Timebase cb "new_pos" argument calls stops when:
  82
  83         - after one cb call with "new_pos" argument true (client)
  84         - desactivate (client)
  85         - release (client)
  86         - transport stop (server)
  87
  88 */
  89
  90 class JackClientInterface;
  91
  92 class SERVER_EXPORT JackTransportEngine : public JackAtomicArrayState<jack_position_t>
  93 {
  94
  95     private:
  96
  97         jack_transport_state_t fTransportState;
  98         volatile transport_command_t fTransportCmd;
  99         transport_command_t fPreviousCmd;               /* previous transport_cmd */
 100         jack_time_t fSyncTimeout;
 101         int fSyncTimeLeft;
 102         int fTimeBaseMaster;
 103         bool fPendingPos;
 104         bool fNetworkSync;
 105         bool fConditionnal;
 106         SInt32 fWriteCounter;
 107
 108         bool CheckAllRolling(JackClientInterface** table);
 109         void MakeAllStartingLocating(JackClientInterface** table);
 110         void MakeAllStopping(JackClientInterface** table);
 111         void MakeAllLocating(JackClientInterface** table);
 112
 113         void SyncTimeout(jack_nframes_t frame_rate, jack_nframes_t buffer_size);
 114
 115     public:
 116
 117         JackTransportEngine();
 118
 119         ~JackTransportEngine()
 120         {}
 121
 122         void SetCommand(transport_command_t state)
 123         {
 124             fTransportCmd = state;
 125         }
 126
 127         jack_transport_state_t GetState() const
 128         {
 129             return fTransportState;
 130         }
 131
 132         void SetState(jack_transport_state_t state)
 133         {
 134             fTransportState = state;
 135         }
 136
 137         /*
 138                 \brief
 139         */
 140         int ResetTimebase(int refnum);
 141
 142         /*
 143                 \brief
 144         */
 145         int SetTimebaseMaster(int refnum, bool conditionnal);
 146
 147         void GetTimebaseMaster(int& refnum, bool& conditionnal);
 148
 149         /*
 150                 \brief
 151         */
 152         void CycleBegin(jack_nframes_t frame_rate, jack_time_t time);
 153
 154         /*
 155                 \brief
 156         */
 157         void CycleEnd(JackClientInterface** table, jack_nframes_t frame_rate, jack_nframes_t buffer_size);
 158
 159         /*
 160                 \brief
 161         */
 162         void SetSyncTimeout(jack_time_t timeout)
 163         {
 164             fSyncTimeout = timeout;
 165         }
 166
 167         void ReadCurrentPos(jack_position_t* pos);
 168
 169         jack_unique_t GenerateUniqueID()
 170         {
 171             return (jack_unique_t)INC_ATOMIC(&fWriteCounter);
 172         }
 173
 174         void RequestNewPos(jack_position_t* pos);
 175
 176         jack_transport_state_t Query(jack_position_t* pos);
 177
 178         jack_nframes_t GetCurrentFrame();
 179
 180         static void CopyPosition(jack_position_t* from, jack_position_t* to);
 181
 182         bool GetNetworkSync() const
 183         {
 184             return fNetworkSync;
 185         }
 186
 187         void SetNetworkSync(bool sync)
 188         {
 189             fNetworkSync = sync;
 190         }
 191
 192 };
 193
 194
 195 } // end of namespace
 196
 197 #endif