mix.c File Reference

#include "sound.h"

Go to the source code of this file.

Macros
#define	PAINTBUFFER_SIZE   2048

Functions
static void	WriteLinearBlast (int16_t *out, samplepair_t *samp, int count)
static void	TransferStereo16 (samplepair_t *samp, int endtime)
static void	TransferStereo (samplepair_t *samp, int endtime)
static void	TransferPaintBuffer (samplepair_t *samp, int endtime)
static void	Paint8 (channel_t *ch, sfxcache_t *sc, int count, samplepair_t *samp)
static void	Paint16 (channel_t *ch, sfxcache_t *sc, int count, samplepair_t *samp)
void	S_PaintChannels (int endtime)
void	S_InitScaletable (void)
void	S_RawSamples (int samples, int rate, int width, int channels, byte *data, float volume)
void	S_UnqueueRawSamples ()

Variables
static int	snd_scaletable [32][256]
static int	snd_vol
samplepair_t	s_rawsamples [S_MAX_RAW_SAMPLES]
int	s_rawend = 0

Macro Definition Documentation

PAINTBUFFER_SIZE

#define PAINTBUFFER_SIZE   2048

Definition at line 22 of file mix.c.

Function Documentation

Paint16()

static void Paint16 ( channel_t *  ch, sfxcache_t *  sc, int  count, samplepair_t *  samp  )

static

Definition at line 156 of file mix.c.

{
    int data;
    int left, right;
    int leftvol, rightvol;
    int16_t *sfx;
    int i;
 
    leftvol = ch->leftvol * snd_vol;
    rightvol = ch->rightvol * snd_vol;
    sfx = (int16_t *)sc->data + ch->pos;
 
    for (i = 0; i < count; i++, samp++) {
        data = *sfx++;
        left = (data * leftvol) >> 8;
        right = (data * rightvol) >> 8;
        samp->left += left;
        samp->right += right;
    }
 
    ch->pos += count;
}

Referenced by S_PaintChannels().

Paint8()

static void Paint8 ( channel_t *  ch, sfxcache_t *  sc, int  count, samplepair_t *  samp  )

static

Definition at line 131 of file mix.c.

{
    int data;
    int *lscale, *rscale;
    uint8_t *sfx;
    int i;
 
    if (ch->leftvol > 255)
        ch->leftvol = 255;
    if (ch->rightvol > 255)
        ch->rightvol = 255;
 
    lscale = snd_scaletable[ch->leftvol >> 3];
    rscale = snd_scaletable[ch->rightvol >> 3];
    sfx = (uint8_t *)sc->data + ch->pos;
 
    for (i = 0; i < count; i++, samp++) {
        data = *sfx++;
        samp->left += lscale[data];
        samp->right += rscale[data];
    }
 
    ch->pos += count;
}

Referenced by S_PaintChannels().

S_InitScaletable()

void S_InitScaletable

(

void

)

Definition at line 281 of file mix.c.

{
    int        i, j;
    int        scale;
 
    snd_vol = S_GetLinearVolume(s_volume->value) * 256;
    for (i = 0; i < 32; i++) {
        scale = i * 8 * snd_vol;
        for (j = 0; j < 256; j++) {
            snd_scaletable[i][j] = (j - 128) * scale;
        }
    }
 
    s_volume->modified = qfalse;
}

Referenced by DMA_Init(), and S_Update().

S_PaintChannels()

void S_PaintChannels

(

int

endtime

)

Definition at line 179 of file mix.c.

{
    samplepair_t paintbuffer[PAINTBUFFER_SIZE];
    int i;
    int end;
    channel_t *ch;
    sfxcache_t *sc;
    int ltime, count;
    playsound_t *ps;
 
    while (paintedtime < endtime) {
        // if paintbuffer is smaller than DMA buffer
        end = endtime;
        if (end - paintedtime > PAINTBUFFER_SIZE)
            end = paintedtime + PAINTBUFFER_SIZE;
 
        // start any playsounds
        while (1) {
            ps = s_pendingplays.next;
            if (ps == &s_pendingplays)
                break;    // no more pending sounds
            if (ps->begin <= paintedtime) {
                S_IssuePlaysound(ps);
                continue;
            }
 
            if (ps->begin < end)
                end = ps->begin;        // stop here
            break;
        }
 
        // clear the paint buffer
        memset(paintbuffer, 0, (end - paintedtime) * sizeof(samplepair_t));
 
        // paint in the channels.
        ch = channels;
        for (i = 0; i < s_numchannels; i++, ch++) {
            ltime = paintedtime;
 
            while (ltime < end) {
                if (!ch->sfx || (!ch->leftvol && !ch->rightvol))
                    break;
 
                // max painting is to the end of the buffer
                count = end - ltime;
 
                // might be stopped by running out of data
                if (ch->end - ltime < count)
                    count = ch->end - ltime;
 
                sc = S_LoadSound(ch->sfx);
                if (!sc)
                    break;
 
                if (count > 0 && ch->sfx) {
                    samplepair_t *samp = &paintbuffer[ltime - paintedtime];
                    if (sc->width == 1)
                        Paint8(ch, sc, count, samp);
                    else
                        Paint16(ch, sc, count, samp);
 
                    ltime += count;
                }
 
                // if at end of loop, restart
                if (ltime >= ch->end) {
                    if (ch->autosound) {
                        // autolooping sounds always go back to start
                        ch->pos = 0;
                        ch->end = ltime + sc->length;
                    } else if (sc->loopstart >= 0) {
                        ch->pos = sc->loopstart;
                        ch->end = ltime + sc->length - ch->pos;
                    } else {
                        // channel just stopped
                        ch->sfx = NULL;
                    }
                }
            }
 
        }
 
        if (s_rawend >= paintedtime)
        {
          /* add from the streaming sound source */
          int stop = (end < s_rawend) ? end : s_rawend;
 
          for (int i = paintedtime; i < stop; i++)
          {
            int s = i & (S_MAX_RAW_SAMPLES - 1);
            paintbuffer[i - paintedtime].left += s_rawsamples[s].left;
            paintbuffer[i - paintedtime].right += s_rawsamples[s].right;
          }
        }
 
        // transfer out according to DMA format
        TransferPaintBuffer(paintbuffer, end);
        paintedtime = end;
    }
}

Referenced by DMA_Update().

S_RawSamples()

void S_RawSamples	(	int	samples,
		int	rate,
		int	width,
		int	channels,
		byte *	data,
		float	volume
	)

Definition at line 303 of file mix.c.

{
  if (!s_started) return;
 
  if (s_started == SS_OAL)
  {
      AL_RawSamples(samples, rate, width, channels, data, volume);
      return;
  }
 
  if (s_rawend < paintedtime)
    s_rawend = paintedtime;
 
  // mimic the OpenAL behavior: s_volume is master volume
  volume *= s_volume->value;
 
  // rescale because ogg is always 44100 and dma is configurable via s_khz
  float scale = (float)rate / dma.speed;
  int intVolume = (int)(256 * volume);
 
  if ((channels == 2) && (width == 2))
  {
    for (int i = 0; ; i++)
    {
      int src = (int)(i * scale);
 
      if (src >= samples)
      {
        break;
      }
 
      int dst = s_rawend & (S_MAX_RAW_SAMPLES - 1);
      s_rawend++;
      s_rawsamples[dst].left = ((short *)data)[src * 2] * intVolume;
      s_rawsamples[dst].right = ((short *)data)[src * 2 + 1] * intVolume;
    }
  }
  else if ((channels == 1) && (width == 2))
  {
    for (int i = 0; ; i++)
    {
      int src = (int)(i * scale);
 
      if (src >= samples)
      {
        break;
      }
 
      int dst = s_rawend & (S_MAX_RAW_SAMPLES - 1);
      s_rawend++;
      s_rawsamples[dst].left = ((short *)data)[src] * intVolume;
      s_rawsamples[dst].right = ((short *)data)[src] * intVolume;
    }
  }
  else if ((channels == 2) && (width == 1))
  {
    intVolume *= 256;
 
    for (int i = 0; ; i++)
    {
      int src = (int)(i * scale);
 
      if (src >= samples)
      {
        break;
      }
 
      int dst = s_rawend & (S_MAX_RAW_SAMPLES - 1);
      s_rawend++;
      s_rawsamples[dst].left =
        (((byte *)data)[src * 2] - 128) * intVolume;
      s_rawsamples[dst].right =
        (((byte *)data)[src * 2 + 1] - 128) * intVolume;
    }
  }
  else if ((channels == 1) && (width == 1))
  {
    intVolume *= 256;
 
    for (int i = 0; ; i++)
    {
      int src = (int)(i * scale);
 
      if (src >= samples)
      {
        break;
      }
 
      int dst = s_rawend & (S_MAX_RAW_SAMPLES - 1);
      s_rawend++;
      s_rawsamples[dst].left = (((byte *)data)[src] - 128) * intVolume;
      s_rawsamples[dst].right = (((byte *)data)[src] - 128) * intVolume;
    }
  }
}

Referenced by OGG_Read(), and SCR_ReadNextFrame().

S_UnqueueRawSamples()

void S_UnqueueRawSamples

(

)

Definition at line 400 of file mix.c.

{
#ifdef USE_OPENAL
    if (s_started == SS_OAL)
    {
        AL_UnqueueRawSamples();
    }
#endif
}

Referenced by SCR_RunCinematic(), and SCR_StopCinematic().

TransferPaintBuffer()

static void TransferPaintBuffer ( samplepair_t *  samp, int  endtime  )

static

Definition at line 102 of file mix.c.

{
    if (s_testsound->integer) {
        int i;
 
        // write a fixed sine wave
        for (i = paintedtime; i < endtime; i++) {
            samp[i].left = samp[i].right = sin(i * 0.1) * 20000 * 256;
        }
    }
 
    if (dma.samplebits == 16 && dma.channels == 2) {
        // optimized case
        TransferStereo16(samp, endtime);
    } else {
        // general case
        TransferStereo(samp, endtime);
    }
}

Referenced by S_PaintChannels().

TransferStereo()

static void TransferStereo ( samplepair_t *  samp, int  endtime  )

static

Definition at line 68 of file mix.c.

{
    int out_idx, out_mask;
    int count;
    int *p, val;
    int step;
 
    p = (int *)samp;
    count = (endtime - paintedtime) * dma.channels;
    out_mask = dma.samples - 1;
    out_idx = paintedtime * dma.channels & out_mask;
    step = 3 - dma.channels;
 
    if (dma.samplebits == 16) {
        int16_t *out = (int16_t *)dma.buffer;
        while (count--) {
            val = *p >> 8;
            p += step;
            clamp(val, INT16_MIN, INT16_MAX);
            out[out_idx] = val;
            out_idx = (out_idx + 1) & out_mask;
        }
    } else if (dma.samplebits == 8) {
        uint8_t *out = (uint8_t *)dma.buffer;
        while (count--) {
            val = *p >> 8;
            p += step;
            clamp(val, INT16_MIN, INT16_MAX);
            out[out_idx] = (val >> 8) + 128;
            out_idx = (out_idx + 1) & out_mask;
        }
    }
}

Referenced by TransferPaintBuffer().

TransferStereo16()

static void TransferStereo16 ( samplepair_t *  samp, int  endtime  )

static

Definition at line 43 of file mix.c.

{
    int lpos;
    int ltime;
    int16_t *out;
    int count;
 
    for (ltime = paintedtime; ltime < endtime;) {
        // handle recirculating buffer issues
        lpos = ltime & ((dma.samples >> 1) - 1);
 
        out = (int16_t *)dma.buffer + (lpos << 1);
 
        count = (dma.samples >> 1) - lpos;
        if (ltime + count > endtime)
            count = endtime - ltime;
 
        // write a linear blast of samples
        WriteLinearBlast(out, samp, count);
 
        samp += count;
        ltime += count;
    }
}

Referenced by TransferPaintBuffer().

WriteLinearBlast()

static void WriteLinearBlast ( int16_t *  out, samplepair_t *  samp, int  count  )

static

Definition at line 30 of file mix.c.

{
    int i, val;
 
    for (i = 0; i < count; i++, samp++, out += 2) {
        val = samp->left >> 8;
        out[0] = clamp(val, INT16_MIN, INT16_MAX);
 
        val = samp->right >> 8;
        out[1] = clamp(val, INT16_MIN, INT16_MAX);
    }
}

Referenced by TransferStereo16().

Variable Documentation

s_rawend

int s_rawend = 0

Definition at line 28 of file mix.c.

Referenced by AL_RawSamples(), OGG_Stream(), S_PaintChannels(), and S_RawSamples().

s_rawsamples

samplepair_t s_rawsamples[S_MAX_RAW_SAMPLES]

Definition at line 27 of file mix.c.

Referenced by S_PaintChannels(), and S_RawSamples().

snd_scaletable

int snd_scaletable[32][256]

static

Definition at line 24 of file mix.c.

Referenced by Paint8(), and S_InitScaletable().

snd_vol

int snd_vol

static

Definition at line 25 of file mix.c.

Referenced by Paint16(), and S_InitScaletable().