/*	rebuffer.template -- this is a TEMPLATE for a rebuffer module	since C has no templates I use this method to get a type-independent	rebuffering module.  This avoids enormous amounts of duplicated code.	to use this file, #include it with the following tokens defined:	#define PRFX(word) XXXX ## word	#define INITFUNC(word) initXXXX ## word	#define NAMESTRING(word) "XXXX" #word	#define TYPE YYYY	where XXXX is replaced with the prefix you want for the module	name and YYYY is replaced with the type the routine works with.	All the other stuff above stays the same.  Here is an example:	#define PRFX(word) int2 ## word	#define INITFUNC(word) initint2 ## word	#define NAMESTRING(word) "int2" #word	#define TYPE signed short int	#include "rebuffer.template"	I would just have you set two variables and do the above myself,	but the C preprocessor is so brain dead that it does not evaluate	actual arguments to preprocessor functions until after they are	substituted in! (and thus concatenated, and thus unable to be	substituted).	The alternative to this (other than to use C++, which would make this	whole damn library so much easier to write and to read) is to have	large numbers of almost identical copies of the rebuffering routines	with a few type fields different.  This is to be avoided.	This code will then define a module called (using above example)	int2rebufferv2f and another called int2rebufferf2v.*//* instance data of rebuffering modules */typedef struct PRFX(rebuffer_data){	bool multiple_of;	/* TRUE=buffer to multiple-of not exactly... */	AFframecount nsamps;	/* # of fixed samples / multiple-of */	TYPE *buf;		/* buf of nsamps samples */	long offset;		/* see code for meaning */	bool eof;		/* (pull only) end of input stream reached */	bool sent_short_chunk;	/* (pull only) end of output stream indicated */	TYPE *saved_buf;	/* (push only) saved buffer */	long saved_offset;	/* (push only) saved buffer offset */} PRFX(rebuffer_data);#define REBUFFER_DATA PRFX(rebuffer_data)/* REBUFFER variable to fixed -- PUSH ONLY */static void PRFX(rebufferv2fmax_push)(struct _AFmoduleinst *i){  REBUFFER_DATA *d = i->modspec;  int nframes = d->nsamps/i->inc->f.channelCount;  if (d->multiple_of)    /* actually, it can be less, but this is ok */    i->outc->nframes = i->inc->nframes + nframes;  else    i->outc->nframes = nframes;}static void PRFX(rebufferv2frun_push)(struct _AFmoduleinst *i){  REBUFFER_DATA *d = i->modspec;  long samples2push = i->inc->nframes * i->inc->f.channelCount;  TYPE *inbufp = i->inc->buf;  /* d->offset could be from 0 to nsamps. 0 is no saved samples,     nsamps is all saved samples (should never be nsamps though)     offset thus contains a count of the valid data samples */  assert(d->offset >= 0 && d->offset < d->nsamps);  /* check that we will be able to push even one block */  if (d->offset + samples2push >= d->nsamps)    {      /* push the currently buffered samples through */      if (d->offset != 0)        memcpy(i->outc->buf, d->buf, sizeof(TYPE)*d->offset);      if (d->multiple_of)        {          /* round down to nearest d->nsamps */          int n = (((d->offset+samples2push) / d->nsamps) * d->nsamps);          /*             Example with d->nsamps==5, d->offset==3, and samples2push=10.             B=a buffered sample             N=a new sample (pushed into module on this call)             Note that we group samples in groups of d->nsamps since they must             be pushed that way (any # of groups at a time):              offset  samples2push                 |-||------------|                 BBBNN  NNNNN  NNN....                    |-------|                     n-offset                 |----------|                       n             n is the number of samples we will push on this run.  What's             left over (3 samples in this case) will get buffered for use             in the next run.          */          assert(n > d->offset);          memcpy((TYPE *)i->outc->buf + d->offset, inbufp,                 sizeof(TYPE)*(n - d->offset)); /* fill in rest of outbuf */          _AFpush(i, n / i->outc->f.channelCount);          inbufp += n - d->offset;          samples2push -= n - d->offset;          assert(samples2push >= 0);          d->offset = 0;        /* the buffer is now empty */        }      else        {          while (d->offset + samples2push >= d->nsamps)            {              int n = d->nsamps - d->offset;              /*                 Same example as above.  Everything is the same except now                 we can only push one group of d->nsamps samples at a time,                 so we must loop through groups, and n takes on several                 values:                    offset  samples2push                       |-||------------|                       BBBNN  NNNNN  NNN....                          ||  |---|                           n    n                 n says how many samples to take from the input chunk.                 n first has the value d->nsamps - d->offset, and then it                 always has the value d->nsamps.              */              memcpy((TYPE *)i->outc->buf + d->offset, inbufp,                     sizeof(TYPE)*n); /* fill in rest of outbuf */              _AFpush(i, d->nsamps / i->outc->f.channelCount);              inbufp += n;              samples2push -= n;              assert(samples2push >= 0);              d->offset = 0;                /* clear out the buffer */            }        }      /* if we pushed blocks, then we must have used all stored samples */      assert(d->offset == 0);    }  /* at this point: guaranteed that  d->offset + samples2push < d->nsamps */  assert(d->offset + samples2push < d->nsamps);  /* save remaining samples in buffer */  if ( samples2push != 0 )    {      memcpy(d->buf+d->offset, inbufp, sizeof(TYPE)*samples2push);      d->offset += samples2push;    }  assert(d->offset >= 0 && d->offset < d->nsamps);}static void PRFX(rebufferv2fsync1)(struct _AFmoduleinst *i){  REBUFFER_DATA *d = i->modspec;  assert(d->offset >= 0 && d->offset < d->nsamps);  /*    save all the samples and the offset so we can     restore our state later.  */  memcpy(d->saved_buf, d->buf, sizeof(TYPE)*d->nsamps);  d->saved_offset = d->offset;}static void PRFX(rebufferv2fsync2)(struct _AFmoduleinst *i){  REBUFFER_DATA *d = i->modspec;  /* d->offset could be from 0 to nsamps. 0 is no saved samples,     nsamps is all saved samples (should never be nsamps though)     offset thus contains a count of the valid data samples */  assert(d->offset >= 0 && d->offset < d->nsamps);  /*     push the currently buffered samples through--even if there     are none!     in other words, push a SHORT CHUNK -- see modules.c TOF for more info !  */  if (d->offset != 0)    {      memcpy(i->outc->buf, d->buf, sizeof(TYPE)*d->offset);    }  _AFpush(i, d->offset / i->outc->f.channelCount); /* SHORT CHUNK */  /* restore state saved in sync1 */  memcpy(d->buf, d->saved_buf, sizeof(TYPE)*d->nsamps);  d->offset = d->saved_offset;  assert(d->offset >= 0 && d->offset < d->nsamps);}static void PRFX(rebufferv2ffree)(struct _AFmoduleinst *i){  REBUFFER_DATA *d = i->modspec;  if (d->buf)    free(d->buf);  if (d->saved_buf)    free(d->saved_buf);}static _AFmodule PRFX(rebufferv2f) ={  NAMESTRING(rebufferv2f),  AF_NULL,  AF_NULL, PRFX(rebufferv2fmax_push),  AF_NULL, AF_NULL, AF_NULL,  PRFX(rebufferv2frun_push), PRFX(rebufferv2fsync1), PRFX(rebufferv2fsync2),  AF_NULL,  PRFX(rebufferv2ffree)};_AFmoduleinst INITFUNC(rebufferv2f)(AFframecount nsamps, bool multiple_of){  _AFmoduleinst ret = _AFnewmodinst(&PRFX(rebufferv2f));  REBUFFER_DATA *d = _af_malloc(sizeof (REBUFFER_DATA));  d->nsamps = nsamps;  d->offset = 0;  d->buf = _af_malloc(sizeof (TYPE) * nsamps);  d->multiple_of = multiple_of;  d->saved_buf = _af_malloc(sizeof (TYPE) * nsamps);  ret.modspec = d;  DEBG(printf("%s nsamps=%d multiple_of=%d\n", NAMESTRING(rebufferv2f),              nsamps, multiple_of));  return(ret);}/* ===== REBUFFER fixed to variable -- PULL ONLY */static void PRFX(rebufferf2vmax_pull)(struct _AFmoduleinst *i){  REBUFFER_DATA *d = i->modspec;  long nframes = d->nsamps / i->inc->f.channelCount;  if (d->multiple_of)    /* actually, it can be less, but this is ok */    i->inc->nframes = i->outc->nframes + nframes;  else    i->inc->nframes = nframes;}static void PRFX(rebufferf2vrun_pull)(struct _AFmoduleinst *i){  REBUFFER_DATA *d = i->modspec;  long samples2pull = i->outc->nframes * i->outc->f.channelCount;  TYPE *outbufp = i->outc->buf;  /* d->offset could be from 0 to nsamps. 0=saved all samples,     nsamps=saved no samples (should never be 0 though)