common/JackEngineControl.h

   1 /*
   2 Copyright (C) 2003 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 __JackEngineControl__
  22 #define __JackEngineControl__
  23
  24 #include "JackShmMem.h"
  25 #include "JackFrameTimer.h"
  26 #include "JackTransportEngine.h"
  27 #include "JackConstants.h"
  28 #include "types.h"
  29 #include <stdio.h>
  30
  31 #ifdef JACK_MONITOR
  32 #include "JackEngineProfiling.h"
  33 #endif
  34
  35 namespace Jack
  36 {
  37
  38 class JackClientInterface;
  39 class JackGraphManager;
  40
  41 #define JACK_ENGINE_ROLLING_COUNT 32
  42 #define JACK_ENGINE_ROLLING_INTERVAL 1024
  43
  44 /*!
  45 \brief Engine control in shared memory.
  46 */
  47
  48 PRE_PACKED_STRUCTURE
  49 struct SERVER_EXPORT JackEngineControl : public JackShmMem
  50 {
  51     // Shared state
  52     jack_nframes_t fBufferSize;
  53     jack_nframes_t fSampleRate;
  54     bool fSyncMode;
  55     bool fTemporary;
  56     jack_time_t fPeriodUsecs;
  57     jack_time_t fTimeOutUsecs;
  58     float fMaxDelayedUsecs;
  59     float fXrunDelayedUsecs;
  60     bool fTimeOut;
  61     bool fRealTime;
  62     bool fSavedRealTime;  // RT state saved and restored during Freewheel mode
  63     int fServerPriority;
  64     int fClientPriority;
  65     int fMaxClientPriority;
  66     char fServerName[JACK_SERVER_NAME_SIZE+1];
  67     alignas(UInt32) alignas(JackTransportEngine) JackTransportEngine fTransport;
  68     jack_timer_type_t fClockSource;
  69     int fDriverNum;
  70     bool fVerbose;
  71
  72     // CPU Load
  73     jack_time_t fPrevCycleTime;
  74     jack_time_t fCurCycleTime;
  75     jack_time_t fSpareUsecs;
  76     jack_time_t fMaxUsecs;
  77     jack_time_t fRollingClientUsecs[JACK_ENGINE_ROLLING_COUNT];
  78     unsigned int fRollingClientUsecsCnt;
  79     int fRollingClientUsecsIndex;
  80     int fRollingInterval;
  81     float fCPULoad;
  82
  83     // For OSX thread
  84     UInt64 fPeriod;
  85     UInt64 fComputation;
  86     UInt64 fConstraint;
  87
  88     // Timer
  89     alignas(UInt32) alignas(JackFrameTimer) JackFrameTimer fFrameTimer;
  90
  91 #ifdef JACK_MONITOR
  92     JackEngineProfiling fProfiler;
  93 #endif
  94
  95     JackEngineControl(bool sync, bool temporary, long timeout, bool rt, long priority, bool verbose, jack_timer_type_t clock, const char* server_name)
  96       {
  97         static_assert(offsetof(JackEngineControl, fTransport) % sizeof(UInt32) == 0,
  98                       "fTransport must be aligned within JackEngineControl");
  99         static_assert(offsetof(JackEngineControl, fFrameTimer) % sizeof(UInt32) == 0,
 100                       "fFrameTimer must be aligned within JackEngineControl");
 101         fBufferSize = 512;
 102         fSampleRate = 48000;
 103         fPeriodUsecs = jack_time_t(1000000.f / fSampleRate * fBufferSize);
 104         fSyncMode = sync;
 105         fTemporary = temporary;
 106         fTimeOut = (timeout > 0);
 107         fTimeOutUsecs = timeout * 1000;
 108         fRealTime = rt;
 109         fSavedRealTime = false;
 110         fServerPriority = priority;
 111
 112     #ifdef WIN32
 113         fClientPriority = (rt) ? priority - 3 : 0;
 114     #else
 115         fClientPriority = (rt) ? priority - 5 : 0;
 116     #endif
 117         fMaxClientPriority = (rt) ? priority - 1 : 0;
 118         fVerbose = verbose;
 119         fPrevCycleTime = 0;
 120         fCurCycleTime = 0;
 121         fSpareUsecs = 0;
 122         fMaxUsecs = 0;
 123         ResetRollingUsecs();
 124         strncpy(fServerName, server_name, sizeof(fServerName));
 125         fServerName[sizeof(fServerName) - 1] = 0;
 126         fCPULoad = 0.f;
 127         fPeriod = 0;
 128         fComputation = 0;
 129         fConstraint = 0;
 130         fMaxDelayedUsecs = 0.f;
 131         fXrunDelayedUsecs = 0.f;
 132         fClockSource = clock;
 133         fDriverNum = 0;
 134     }
 135
 136     ~JackEngineControl()
 137     {}
 138
 139     void UpdateTimeOut()
 140     {
 141         fPeriodUsecs = jack_time_t(1000000.f / fSampleRate * fBufferSize); // In microsec
 142         if (!(fTimeOut && fTimeOutUsecs > 2 * fPeriodUsecs)) {
 143             fTimeOutUsecs = 2 * fPeriodUsecs;
 144         }
 145     }
 146
 147     // Cycle
 148     void CycleIncTime(jack_time_t callback_usecs)
 149     {
 150         // Timer
 151         fFrameTimer.IncFrameTime(fBufferSize, callback_usecs, fPeriodUsecs);
 152     }
 153
 154     void CycleBegin(JackClientInterface** table, JackGraphManager* manager, jack_time_t cur_cycle_begin, jack_time_t prev_cycle_end)
 155     {
 156         fTransport.CycleBegin(fSampleRate, cur_cycle_begin);
 157         CalcCPULoad(table, manager, cur_cycle_begin, prev_cycle_end);
 158 #ifdef JACK_MONITOR
 159         fProfiler.Profile(table, manager, fPeriodUsecs, cur_cycle_begin, prev_cycle_end);
 160 #endif
 161     }
 162
 163     void CycleEnd(JackClientInterface** table)
 164     {
 165         fTransport.CycleEnd(table, fSampleRate, fBufferSize);
 166     }
 167
 168     // Timer
 169     void InitFrameTime()
 170     {
 171         fFrameTimer.InitFrameTime();
 172     }
 173
 174     void ResetFrameTime(jack_time_t callback_usecs)
 175     {
 176         fFrameTimer.ResetFrameTime(callback_usecs);
 177     }
 178
 179     void ReadFrameTime(JackTimer* timer)
 180     {
 181         fFrameTimer.ReadFrameTime(timer);
 182     }
 183
 184     // XRun
 185     void NotifyXRun(jack_time_t callback_usecs, float delayed_usecs);
 186     void ResetXRun()
 187     {
 188         fMaxDelayedUsecs = 0.f;
 189     }
 190
 191     // Private
 192     void CalcCPULoad(JackClientInterface** table, JackGraphManager* manager, jack_time_t cur_cycle_begin, jack_time_t prev_cycle_end);
 193     void ResetRollingUsecs();
 194
 195 } POST_PACKED_STRUCTURE;
 196
 197 } // end of namespace
 198
 199 #endif