src/ptclib/delaychan.cxx

   1 /*
   2  * delaychan.cxx
   3  *
   4  * Class for controlling the timing of data passing through it.
   5  *
   6  * Portable Windows Library
   7  *
   8  * Copyright (c) 2001 Equivalence Pty. Ltd.
   9  *
  10  * The contents of this file are subject to the Mozilla Public License
  11  * Version 1.0 (the "License"); you may not use this file except in
  12  * compliance with the License. You may obtain a copy of the License at
  13  * http://www.mozilla.org/MPL/
  14  *
  15  * Software distributed under the License is distributed on an "AS IS"
  16  * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
  17  * the License for the specific language governing rights and limitations
  18  * under the License.
  19  *
  20  * The Original Code is Portable Windows Library.
  21  *
  22  * The Initial Developer of the Original Code is Equivalence Pty. Ltd.
  23  *
  24  * Contributor(s): ______________________________________.
  25  *
  26  * $Log$
  27  * Revision 1.5  2003/02/20 08:43:44  rogerh
  28  * On Mac OS X, the thread sleep() (which uses select) is not as fine grained
  29  * as usleep. So use usleep(). Tested by Shawn.
  30  *
  31  * Revision 1.4  2002/02/26 00:42:13  robertj
  32  * Fixed MSVC warning.
  33  *
  34  * Revision 1.3  2002/02/25 11:05:02  rogerh
  35  * New Delay code which solves the accumulated error problem. Based on ideas
  36  * by Tomasz Motylewski <T.Motylewski@bfad.de>, Roger and Craig.
  37  *
  38  * Revision 1.2  2002/01/15 03:56:03  craigs
  39  * Added PAdaptiveDelay class
  40  *
  41  * Revision 1.1  2001/07/10 03:07:07  robertj
  42  * Added queue channel and delay channel classes to ptclib.
  43  *
  44  */
  45
  46 #ifdef __GNUC__
  47 #pragma implementation "delaychan.h"
  48 #endif
  49
  50 #include <ptlib.h>
  51 #include <ptclib/delaychan.h>
  52
  53 /////////////////////////////////////////////////////////
  54
  55 PAdaptiveDelay::PAdaptiveDelay()
  56 {
  57   firstTime = TRUE;
  58 }
  59
  60 void PAdaptiveDelay::Restart()
  61 {
  62   firstTime = TRUE;
  63 }
  64
  65 BOOL PAdaptiveDelay::Delay(int frameTime)
  66 {
  67   if (firstTime) {
  68     firstTime = FALSE;
  69     targetTime = PTime();   // targetTime is the time we want to delay to
  70     return TRUE;
  71   }
  72
  73   // Set the new target
  74   targetTime += frameTime;
  75
  76   // Calculate the sleep time so we delay until the target time
  77   PTimeInterval delay = targetTime - PTime();
  78   int sleep_time = (int)delay.GetMilliSeconds();
  79
  80   if (sleep_time > 0)
  81 #if defined(P_LINUX) || defined(P_MACOSX)
  82     usleep(sleep_time * 1000);
  83 #else
  84     PThread::Current()->Sleep(sleep_time);
  85 #endif
  86
  87   return sleep_time <= -frameTime;
  88 }
  89
  90 /////////////////////////////////////////////////////////
  91
  92 PDelayChannel::PDelayChannel(Mode m,
  93                              unsigned delay,
  94                              PINDEX size,
  95                              unsigned max,
  96                              unsigned min)
  97 {
  98   mode = m;
  99   frameDelay = delay;
 100   frameSize = size;
 101   maximumSlip = -PTimeInterval(max);
 102   minimumDelay = min;
 103 }
 104
 105
 106 BOOL PDelayChannel::Read(void * buf, PINDEX count)
 107 {
 108   if (mode != DelayWritesOnly)
 109     Wait(count, nextReadTick);
 110   return PIndirectChannel::Read(buf, count);
 111 }
 112
 113
 114 BOOL PDelayChannel::Write(const void * buf, PINDEX count)
 115 {
 116   if (mode != DelayReadsOnly)
 117     Wait(count, nextWriteTick);
 118   return PIndirectChannel::Write(buf, count);
 119 }
 120
 121
 122 void PDelayChannel::Wait(PINDEX count, PTimeInterval & nextTick)
 123 {
 124   PTimeInterval thisTick = PTimer::Tick();
 125
 126   if (nextTick == 0)
 127     nextTick = thisTick;
 128
 129   PTimeInterval delay = nextTick - thisTick;
 130   if (delay > maximumSlip)
 131     PTRACE(6, "Delay\t" << delay);
 132   else {
 133     PTRACE(6, "Delay\t" << delay << " ignored, too large");
 134     nextTick = thisTick;
 135     delay = 0;
 136   }
 137
 138   if (frameSize > 0)
 139     nextTick += count*frameDelay/frameSize;
 140   else
 141     nextTick += frameDelay;
 142
 143   if (delay > minimumDelay)
 144     PThread::Current()->Sleep(delay);
 145 }
 146
 147
 148 // End of File ///////////////////////////////////////////////////////////////