[LFO]

- optimized Sync_mod()
- vectorized Sync_processV()

git-svn-id: http://moon:8086/svn/software/trunk/projects/JaySynth@730 b431acfa-c32f-4a4a-93f1-934dc6c82436

Source/JaySynth.cpp

@@ -1189,7 +1189,7 @@ void JaySynth::handleMidiEvent (const MidiMessage& m)
 void JaySynth::voiceSetMidiBeat(int barBeatCount) 
 {
 	lfo_t *pLfo = &m_pVoices[0].pCom->glfo[0];
-	synth_float_t phase = Sync_mod((synth_float_t)barBeatCount/m_numMidiClocksPerBar, 1.0);
+	synth_float_t phase = Sync_mod((synth_float_t)barBeatCount/m_numMidiClocksPerBar);
 	LFO_sync(pLfo, phase);
 	
 	for (int i=0; i < max_num_voices; i++)

Source/synth/lfo.c

@@ -47,31 +47,27 @@ void LFO_smmother_update(lfo_t *pObj)
 
 }
 
-synth_float_t Sync_mod(synth_float_t x, synth_float_t y)
+synth_float_t Sync_mod(synth_float_t x)
 {
-	if (y == 0)
+	synth_float_t y = x - (int)x;
-	{
-		return 0;
-	}
-	synth_float_t result = fmod(x, y);
 	
-	if (result < 0)
+	if (y < 0)
 	{
-		result += y;
+		y += 1;
 	}
-	
+			
-	return result;
+	return y;
 }
 
 synth_float_t phase_det(synth_float_t lo, synth_float_t ref)
 {
-	lo = Sync_mod(lo - 0.5, 1.0);
+	lo = Sync_mod(lo - 0.5);
-	synth_float_t perr = Sync_mod(lo - ref, 1.0) - (synth_float_t)0.5;
+	synth_float_t perr = Sync_mod(lo - ref) - (synth_float_t)0.5;
 	
 	return perr;
 }
 
-void Sync_init(sync_t *pObj, lfo_t *pLfo)
+void Sync_init(sync_t *pObj)
 {
 	pObj->phase = 0;
 	pObj->phase_int = 0;
@@ -81,7 +77,6 @@ void Sync_init(sync_t *pObj, lfo_t *pLfo)
 	pObj->klead = 1.0;
 	pObj->klag = 0.04/200;
 	pObj->phase_update = 0;
-	pObj->pLfo = pLfo;
 }
 
 void Sync_phase_update(sync_t *pObj, synth_float_t phase_ref)
@@ -90,55 +85,135 @@ void Sync_phase_update(sync_t *pObj, synth_float_t phase_ref)
 	pObj->phase_update = 1;
 }
 
-sync_result_t Sync_process(sync_t *pObj, synth_float_t omega_base)
+sync_result_t Sync_process(lfo_t *pObj)
 {
-	int sync_mode = (int)pObj->pLfo->param[LFO_PARAM2_MIDISYNC_MODE];
+	sync_t *pSync = &pObj->sync;
-	synth_float_t phase_ref = pObj->phase_ref;
+	synth_float_t omega_base = pObj->omega;
+
+	int sync_mode = (int)pObj->param[LFO_PARAM2_MIDISYNC_MODE];
+	synth_float_t phase_ref = pSync->phase_ref;
 	
 	sync_result_t result;
-	pObj->phase_int = Sync_mod(pObj->phase_int + pObj->omega, 1.0);
+	pSync->phase_int = Sync_mod(pSync->phase_int + pObj->omega);
-	result.phase = pObj->phase;
+	result.phase = pSync->phase;
 	
 	switch (sync_mode)
 	{
 		case LFO_SYNC_MODE_OFF:
-			pObj->phase = Sync_mod(pObj->phase + omega_base, 1.0);
+			pSync->phase = Sync_mod(pSync->phase + omega_base);
 			break;
 
 		case LFO_SYNC_MODE_F:
-			pObj->phase = Sync_mod(pObj->phase + pObj->omega, 1.0);
+			pSync->phase = Sync_mod(pSync->phase + pSync->omega);
 			break;
 			
 		case LFO_SYNC_MODE_F_P:
-			pObj->phase = pObj->phase_int;
+			pSync->phase = pSync->phase_int;
 			break;
 
 		case LFO_SYNC_MODE_P:
-			pObj->phase = Sync_mod(pObj->phase + omega_base, 1.0);
+			pSync->phase = Sync_mod(pSync->phase + omega_base);
-			if (pObj->phase_update && phase_ref == 0)
+			if (pSync->phase_update && phase_ref == 0)
 			{
-				pObj->phase = 0;
+				pSync->phase = 0;
 			}
 			break;
 	}
-	result.is_cycle_start = (pObj->phase < result.phase);
+	result.is_cycle_start = (pSync->phase < result.phase);
-	result.phase = pObj->phase;
+	result.phase = pSync->phase;
 	
 	synth_float_t perr = 0;
-	if (pObj->phase_update)
+	if (pSync->phase_update)
 	{
-		pObj->phase_update = 0;
+		pSync->phase_update = 0;
-		perr = phase_det(pObj->phase_int, phase_ref);
+		perr = phase_det(pSync->phase_int, phase_ref);
-		SynthDebug("phase_ref=%f, phase_lo=%f, perr=%f\n", phase_ref, pObj->phase_int, perr);
+		SynthDebug("phase_ref=%f, phase_lo=%f, perr=%f\n", phase_ref, pSync->phase_int, perr);
-//		SynthDebug("syncOnFreqUpdate(): BPM=%f\n", omega*pObj->fs*60);
+		SynthDebug("syncOnFreqUpdate(): BPM=%f\n", pSync->omega*pObj->fs*60);
 		
 	}
-	pObj->omega = omega_base-(pObj->klag*pObj->accu + pObj->klead*perr);
+	pSync->omega = omega_base-(pSync->klag*pSync->accu + pSync->klead*perr);
-	pObj->accu += perr;
+	pSync->accu += perr;
 	
 	return result;
 }
 
+void Sync_processV(lfo_t* pObj, int len)
+{
+	sync_t *pSync = &pObj->sync;
+	synth_float_t perr = 0;
+	synth_float_t omega_base = pObj->omega;
+	
+	int sync_mode = (int)pObj->param[LFO_PARAM2_MIDISYNC_MODE];
+	if (pSync->phase_update)
+	{
+		pSync->phase_update = 0;
+		perr = phase_det(pSync->phase_int, pSync->phase_ref);
+		
+		if (sync_mode == LFO_SYNC_MODE_P)
+		{
+			if (pSync->phase_ref == 0)
+			{
+				pSync->phase = 0;
+			}
+		}
+		SynthDebug("phase_ref=%f, phase_lo=%f, perr=%f\n", pSync->phase_ref, pSync->phase_int, perr);
+		SynthDebug("syncOnFreqUpdate(): BPM=%f\n", pSync->omega*pObj->fs*60);
+	}
+	
+	for (int i=0; i < len; i++)
+	{
+		pObj->pPhase[i].phase_int = pSync->phase_int;
+		pObj->pPhase[i].is_cycle_start = 0;
+		pSync->phase_int = Sync_mod(pSync->phase_int + pSync->omega);
+		pSync->omega = omega_base-(pSync->klag*pSync->accu + pSync->klead*perr);
+		pSync->accu += perr;
+		perr = 0;
+	}
+	
+	switch (sync_mode)
+	{
+		case LFO_SYNC_MODE_P:
+		case LFO_SYNC_MODE_OFF:
+		{
+			for (int i=0; i < len; i++)
+			{
+				synth_float_t phase = 
+				pObj->pPhase[i].phase = pSync->phase;
+				pSync->phase = Sync_mod(pSync->phase + omega_base);
+			}
+		}
+		break;
+
+		case LFO_SYNC_MODE_F:
+		{
+			for (int i=0; i < len; i++)
+			{
+				pObj->pPhase[i].phase = pSync->phase;
+				pSync->phase = Sync_mod(pSync->phase + pSync->omega);
+			}
+		}
+		break;
+			
+		case LFO_SYNC_MODE_F_P:
+		{
+			for (int i=0; i < len; i++)
+			{
+				pObj->pPhase[i].phase = pObj->pPhase[i].phase_int;
+			}
+		}
+		break;
+
+		default:
+			break;
+	}
+	for (int i=0; i < len; i++)
+	{
+		pObj->pPhase[i].phase = pObj->pPhase[i].phase_int;
+	}
+
+}
+
+
 // --------------------------------------------------------------
 // Exported functions
 // --------------------------------------------------------------
@@ -158,7 +233,7 @@ void LFO_Init(lfo_t *pObj, synth_float_t fs)
 	
 	pObj->sh_sample = 0;
 	pObj->smooth_out = 0;
-	pObj->offset = 0.5;
+	pObj->offset = 0.0;
 
 	LFO_Reset(pObj, 0);
 
@@ -167,7 +242,7 @@ void LFO_Init(lfo_t *pObj, synth_float_t fs)
 
 	Noise_Init(&pObj->noise, 1+(UINT32)clock() * (UINT32)clock());
 	
-	Sync_init(&pObj->sync, pObj);
+	Sync_init(&pObj->sync);
 }
 
 void LFO_Free(lfo_t *pObj)
@@ -226,7 +301,7 @@ void LFO_Reset(lfo_t *pObj, synth_float_t initial_phase)
 void LFO_sync(lfo_t *pObj, synth_float_t phase_ref)
 {
 	synth_float_t note_1_x = pObj->param[LFO_PARAM2_MIDISYNC_BEATDIV];
-	phase_ref = Sync_mod(note_1_x*phase_ref, 1.0);
+	phase_ref = Sync_mod(note_1_x*phase_ref);
 	Sync_phase_update(&pObj->sync, phase_ref);
 }
 
@@ -281,17 +356,22 @@ synth_float_t* LFO_ProcessDataV(lfo_t *pObj, UINT32 len)
 	
 	sync_result_t *pPhase = pObj->pPhase;
 	
-	// Process Phase and Frequency
+	if (pObj->freq_update_req)
-	for (i=0; i< len; i++)
+	{
-	{	
+		pObj->freq_update_req = 0;
-		*(pPhase++) = Sync_process(&pObj->sync, pObj->omega);
+		LFO_freq_update(pObj);
-		if (pObj->freq_update_req)
-		{
-			pObj->freq_update_req = 0;
-			LFO_freq_update(pObj);
-		}
 	}
 
+	// Process Phase and Frequency
+#if 0
+	for (i=0; i< len; i++)
+	{	
+		*(pPhase++) = Sync_process(&pObj->sync);
+	}
+#else
+	Sync_processV(pObj, len);
+#endif
+	
 	pPhase = pObj->pPhase;
 	synth_float_t *pWave = pObj->pWave;
 	

Source/synth/lfo.h

@@ -63,12 +63,12 @@ typedef struct _ssync_t
 	synth_float_t accu;
 	
 	int phase_update;
-	struct _slfo_t *pLfo;
 
 } sync_t;
 
 typedef struct _ssync_result_t
 {
+	synth_float_t phase_int;
 	synth_float_t phase;
 	int is_cycle_start;
 	
@@ -81,10 +81,9 @@ extern "C" {
 // --------------------------------------------------------------
 // Exported functions
 // --------------------------------------------------------------
-void Sync_init(sync_t *pObj, struct _slfo_t *pLfo);
+void Sync_init(sync_t *pObj);
 void Sync_phase_update(sync_t *pObj, synth_float_t phase_ref);
-sync_result_t Sync_process(sync_t *pObj, synth_float_t omega_base);
+synth_float_t Sync_mod(synth_float_t x);
-synth_float_t Sync_mod(synth_float_t x, synth_float_t y);
 
 #if defined(__cplusplus)
 }
@@ -127,6 +126,8 @@ void LFO_Reset(lfo_t *pObj, synth_float_t initial_phase);
 void LFO_sync(lfo_t *pObj, synth_float_t phase);
 void LFO_Param2Set(lfo_t *pObj, UINT32 type, synth_float_t value);
 synth_float_t* LFO_ProcessDataV(lfo_t *pObj, UINT32 len);
+void Sync_processV(lfo_t *pObj, int len);
+sync_result_t Sync_process(lfo_t *pObj);
 
 #if defined(__cplusplus)
 }