TiMidity -- Experimental MIDI to WAVE converter

Copyright (C) 1995 Tuukka Toivonen <toivonen@clinet.fi>

This program is free software; you can redistribute it and/or modify

it under the terms of the Perl Artistic License, available in COPYING.

mix.c */

#if HAVE_CONFIG_H

# include <config.h>

#endif

#include <math.h>

#include <stdio.h>

#include "SDL.h"

#include "timidity.h"

#include "options.h"

#include "instrum.h"

#include "playmidi.h"

#include "output.h"

#include "tables.h"

#include "resample.h"

#include "mix.h"

/* Returns 1 if envelope runs out */

{

int stage;

if (stage>5)

{

/* Envelope ran out. */

return 1;

}

{

if (stage>2)

{

/* Freeze envelope until note turns off. Trumpets want this. */

return 0;

}

}

}

song->voice[v].envelope_stage=stage+1;

if (song->voice[v].envelope_volume==song->voice[v].sample->envelope_offset[stage] ||

(stage > 2 && song->voice[v].envelope_volume <

song->voice[v].sample->envelope_offset[stage]))

return recompute_envelope(song, v);

song->voice[v].envelope_target = song->voice[v].sample->envelope_offset[stage];

song->voice[v].envelope_increment = song->voice[v].sample->envelope_rate[stage];

if (song->voice[v].envelope_target < song->voice[v].envelope_volume)

song->voice[v].envelope_increment = -song->voice[v].envelope_increment;

return 0;

}

float lamp = song->voice[v].left_amp, ramp;

Sint32 la,ra;

if (song->voice[v].panned == PANNED_MYSTERY)

ramp = song->voice[v].right_amp;

if (song->voice[v].tremolo_phase_increment)

lamp *= song->voice[v].tremolo_volume;

ramp *= song->voice[v].tremolo_volume;

lamp *= (float)vol_table[song->voice[v].envelope_volume>>23];

ramp *= (float)vol_table[song->voice[v].envelope_volume>>23];

}

la = (Sint32)FSCALE(lamp,AMP_BITS);

if (la>MAX_AMP_VALUE)

la=MAX_AMP_VALUE;

ra = (Sint32)FSCALE(ramp,AMP_BITS);

if (ra>MAX_AMP_VALUE)

ra=MAX_AMP_VALUE;

song->voice[v].left_mix = la;

song->voice[v].right_mix = ra;

}

else

{

if (song->voice[v].tremolo_phase_increment)

lamp *= song->voice[v].tremolo_volume;

if (song->voice[v].sample->modes & MODES_ENVELOPE)

lamp *= (float)vol_table[song->voice[v].envelope_volume>>23];

if (la>MAX_AMP_VALUE)

la=MAX_AMP_VALUE;

}

}

if (((song->voice[v].envelope_increment < 0) &&

(song->voice[v].envelope_volume <= song->voice[v].envelope_target)) ||

((song->voice[v].envelope_increment > 0) &&

(song->voice[v].envelope_volume >= song->voice[v].envelope_target)))

song->voice[v].envelope_volume = song->voice[v].envelope_target;

if (recompute_envelope(song, v))

return 1;

}

return 0;

}

{

/* Update sweep position */

song->voice[v].tremolo_sweep_position += song->voice[v].tremolo_sweep;

if (song->voice[v].tremolo_sweep_position >= (1 << SWEEP_SHIFT))

song->voice[v].tremolo_sweep=0; /* Swept to max amplitude */

else

{

/* Need to adjust depth */

depth >>= SWEEP_SHIFT;

}

}

/* if (song->voice[v].tremolo_phase >= (SINE_CYCLE_LENGTH<<RATE_SHIFT))

song->voice[v].tremolo_phase -= SINE_CYCLE_LENGTH<<RATE_SHIFT; */

song->voice[v].tremolo_volume = (float)

(1.0 - FSCALENEG((sine(song->voice[v].tremolo_phase >> RATE_SHIFT) + 1.0)

/* I'm not sure about the +1.0 there -- it makes tremoloed voices'

volumes on average the lower the higher the tremolo amplitude. */

}

/* Returns 1 if the note died */

return 1;

if (song->voice[v].tremolo_phase_increment)

update_tremolo(song, v);

return 0;

}

static void mix_mystery_signal(MidiSong *song, sample_t *sp, Sint32 *lp, int v,

int count)

final_volume_t

left=vp->left_mix,

if (!(cc = vp->control_counter))

{

cc = song->control_ratio;

if (update_signal(song, v))

left = vp->left_mix;

right = vp->right_mix;

}

while (count)

if (cc < count)

{

count -= cc;

while (cc--)

{

s = *sp++;

MIXATION(left);

MIXATION(right);

cc = song->control_ratio;

if (update_signal(song, v))

return; /* Envelope ran out */

left = vp->left_mix;

right = vp->right_mix;

}

else

{

vp->control_counter = cc - count;

while (count--)

{

s = *sp++;

MIXATION(left);

MIXATION(right);

}

return;

}

}

static void mix_center_signal(MidiSong *song, sample_t *sp, Sint32 *lp, int v,

int count)

final_volume_t

left=vp->left_mix;

int cc;

if (!(cc = vp->control_counter))

{

cc = song->control_ratio;

if (update_signal(song, v))

return; /* Envelope ran out */

left = vp->left_mix;

}

while (count)

if (cc < count)

{

count -= cc;

while (cc--)

{

s = *sp++;

MIXATION(left);

MIXATION(left);

cc = song->control_ratio;

if (update_signal(song, v))

return; /* Envelope ran out */

left = vp->left_mix;

}

else

{

vp->control_counter = cc - count;

while (count--)

{

s = *sp++;

MIXATION(left);

MIXATION(left);

}

return;

}

}

static void mix_single_signal(MidiSong *song, sample_t *sp, Sint32 *lp, int v,

int count)

final_volume_t

left=vp->left_mix;

int cc;

if (!(cc = vp->control_counter))

{

cc = song->control_ratio;

if (update_signal(song, v))

return; /* Envelope ran out */

left = vp->left_mix;

}

while (count)

if (cc < count)

{

count -= cc;

while (cc--)

{

s = *sp++;

MIXATION(left);

lp++;

cc = song->control_ratio;

if (update_signal(song, v))

return; /* Envelope ran out */

left = vp->left_mix;

}

else

{

vp->control_counter = cc - count;

while (count--)

{

s = *sp++;

MIXATION(left);

lp++;

}

return;

}

}

static void mix_mono_signal(MidiSong *song, sample_t *sp, Sint32 *lp, int v,

int count)

final_volume_t

left=vp->left_mix;

int cc;

if (!(cc = vp->control_counter))

{

cc = song->control_ratio;

if (update_signal(song, v))

return; /* Envelope ran out */

left = vp->left_mix;

}

while (count)

if (cc < count)

{

count -= cc;

while (cc--)

{

s = *sp++;

MIXATION(left);

}

cc = song->control_ratio;

if (update_signal(song, v))

return; /* Envelope ran out */

left = vp->left_mix;

}

else

{

vp->control_counter = cc - count;

while (count--)

{

s = *sp++;

MIXATION(left);

}

return;

}

}

{

final_volume_t

left = song->voice[v].left_mix,

right = song->voice[v].right_mix;

sample_t s;

while (count--)

{

s = *sp++;

MIXATION(left);

MIXATION(right);

}

}

{

final_volume_t

left = song->voice[v].left_mix;

sample_t s;

while (count--)

{

s = *sp++;

MIXATION(left);

MIXATION(left);

}

}

{

final_volume_t

left = song->voice[v].left_mix;

sample_t s;

while (count--)

{

s = *sp++;

MIXATION(left);

lp++;

}

}

{

final_volume_t

left = song->voice[v].left_mix;

sample_t s;

while (count--)

{

s = *sp++;

MIXATION(left);

}

}

/* Ramp a note out in c samples */

{

/* should be final_volume_t, but Uint8 gives trouble. */

Sint32 left, right, li, ri;

left=song->voice[v].left_mix;

li=-(left/c);

if (!li) li=-1;

/* printf("Ramping out: left=%d, c=%d, li=%d\n", left, c, li); */

ri=-(right/c);

while (c--)

{

left += li;

if (left<0)

left=0;

right += ri;

if (right<0)

right=0;

MIXATION(left);

MIXATION(right);

}

}

{

while (c--)

{

left += li;

if (left<0)

return;

s=*sp++;

MIXATION(left);

MIXATION(left);

}

}

{

while (c--)

{

left += li;

if (left<0)

return;

s=*sp++;

MIXATION(left);

}

}

{

while (c--)

{

left += li;

if (left<0)

return;

s=*sp++;

MIXATION(left);

}

}

}

else

{

/* Mono output. */

while (c--)

{

left += li;

if (left<0)

return;

s=*sp++;

MIXATION(left);

}

}

}

/**************** interface function ******************/

Voice *vp = song->voice + v;

sample_t *sp;

if (vp->status==VOICE_DIE)

{

if (c>=MAX_DIE_TIME)

c=MAX_DIE_TIME;

sp=resample_voice(song, v, &c);

if(c > 0)

ramp_out(song, sp, buf, v, c);

vp->status=VOICE_FREE;

}

else

{

sp=resample_voice(song, v, &c);

if (song->encoding & PE_MONO)

{

/* Mono output. */

if (vp->envelope_increment || vp->tremolo_phase_increment)

}

else

{

if (vp->panned == PANNED_MYSTERY)

{

if (vp->envelope_increment || vp->tremolo_phase_increment)

}

else if (vp->panned == PANNED_CENTER)

{

if (vp->envelope_increment || vp->tremolo_phase_increment)

}

else

{

/* It's either full left or full right. In either case,

every other sample is 0. Just get the offset right: */

if (vp->envelope_increment || vp->tremolo_phase_increment)

}

}

}

}