rebuffer.template

The Audio File Library provides a uniform programming interface to standard digital audio file form

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