only perform atomic operations at the beginning of a callback run

1 files changed, 122 insertions, 110 deletions

diff --git a/src/channel.test.c b/src/channel.test.c
index cab741b..4591b43 100644
--- a/src/channel.test.c
+++ b/src/channel.test.c
@@ -59,11 +59,11 @@ void test_channel_init()
 
 	lily_assert_int_equal(mock_p_mutex_new->n_calls, 1);
 
-	lily_assert_int_equal(chan.active, false);
-	lily_assert_int_equal(chan.paused, false);
-	lily_assert_int_equal(chan.volume, 255);
-	lily_assert_int_equal(chan.pan_left, -128);
-	lily_assert_int_equal(chan.pan_right, 128);
+	lily_assert_int_equal(chan.shared.active, false);
+	lily_assert_int_equal(chan.shared.paused, false);
+	lily_assert_int_equal(chan.shared.volume, 255);
+	lily_assert_int_equal(chan.shared.pan_left, -128);
+	lily_assert_int_equal(chan.shared.pan_right, 128);
 
 	lily_assert_null(chan.sound.left);
 	lily_assert_null(chan.sound.right);
@@ -75,91 +75,89 @@ void test_channel_reset()
 {
 	struct channel_t chan;
 	chan.pos = 255;
-	chan.active = true;
-	chan.paused = true;
-	chan.volume = 5;
-	chan.pan_left = 30;
-	chan.pan_right = 30;
+	chan.shared.active = true;
+	chan.shared.paused = true;
+	chan.shared.volume = 5;
+	chan.shared.pan_left = 30;
+	chan.shared.pan_right = 30;
 
 	channel_reset(&chan);
 
-	lily_assert_int_equal(chan.pos, 0);
-	lily_assert_int_equal(chan.active, false);
-	lily_assert_int_equal(chan.paused, false);
+	lily_assert_int_equal(chan.shared.active, false);
 }
 
 
 void test_channel_pause()
 {
 	struct channel_t chan;
-	chan.paused = false;
+	chan.shared.paused = false;
 
 	channel_pause(&chan);
 
-	lily_assert_int_equal(chan.paused, true);
+	lily_assert_int_equal(chan.shared.paused, true);
 }
 
 
 void test_channel_resume()
 {
 	struct channel_t chan;
-	chan.paused = true;
+	chan.shared.paused = true;
 
 	channel_resume(&chan);
 
-	lily_assert_int_equal(chan.paused, false);
+	lily_assert_int_equal(chan.shared.paused, false);
 }
 
 
 void test_channel_set_volume()
 {
 	struct channel_t chan;
-	chan.volume = 255;
+	chan.shared.volume = 255;
 
 	channel_set_volume(&chan, 0.0f);
-	lily_assert_int_equal(chan.volume, 0);
+	lily_assert_int_equal(chan.shared.volume, 0);
 	channel_set_volume(&chan, 0.5f);
-	lily_assert_int_equal(chan.volume, 127);
+	lily_assert_int_equal(chan.shared.volume, 127);
 	channel_set_volume(&chan, 1.0f);
-	lily_assert_int_equal(chan.volume, 255);
+	lily_assert_int_equal(chan.shared.volume, 255);
 
 	/* oob */
 	channel_set_volume(&chan, -1.0f);
-	lily_assert_int_equal(chan.volume, 0);
+	lily_assert_int_equal(chan.shared.volume, 0);
 	channel_set_volume(&chan, 2.0f);
-	lily_assert_int_equal(chan.volume, 255);
+	lily_assert_int_equal(chan.shared.volume, 255);
 }
 
 
 void test_channel_set_pan()
 {
 	struct channel_t chan;
-	chan.pan_left = 255;
-	chan.pan_right = 255;
+	chan.shared.pan_left = 255;
+	chan.shared.pan_right = 255;
 
 	channel_set_pan(&chan, -1.0f, 1.0f);
-	lily_assert_int_equal(chan.pan_left, -128);
-	lily_assert_int_equal(chan.pan_right, 128);
+	lily_assert_int_equal(chan.shared.pan_left, -128);
+	lily_assert_int_equal(chan.shared.pan_right, 128);
 	channel_set_pan(&chan, -0.5f, 0.5f);
-	lily_assert_int_equal(chan.pan_left, -64);
-	lily_assert_int_equal(chan.pan_right, 64);
+	lily_assert_int_equal(chan.shared.pan_left, -64);
+	lily_assert_int_equal(chan.shared.pan_right, 64);
 	channel_set_pan(&chan, 0.0f, 0.0f);
-	lily_assert_int_equal(chan.pan_left, 0);
-	lily_assert_int_equal(chan.pan_right, 0);
+	lily_assert_int_equal(chan.shared.pan_left, 0);
+	lily_assert_int_equal(chan.shared.pan_right, 0);
 	channel_set_pan(&chan, 0.5f, -0.5f);
-	lily_assert_int_equal(chan.pan_left, 64);
-	lily_assert_int_equal(chan.pan_right, -64);
+	lily_assert_int_equal(chan.shared.pan_left, 64);
+	lily_assert_int_equal(chan.shared.pan_right, -64);
 	channel_set_pan(&chan, 1.0f, -1.0f);
-	lily_assert_int_equal(chan.pan_left, 128);
-	lily_assert_int_equal(chan.pan_right, -128);
+	lily_assert_int_equal(chan.shared.pan_left, 128);
+	lily_assert_int_equal(chan.shared.pan_right, -128);
 
 	/* oob */
 	channel_set_pan(&chan, -10.0f, 2.0f);
-	lily_assert_int_equal(chan.pan_left, -128);
-	lily_assert_int_equal(chan.pan_right, 128);
+	lily_assert_int_equal(chan.shared.pan_left, -128);
+	lily_assert_int_equal(chan.shared.pan_right, 128);
 	channel_set_pan(&chan, 2.0f, -10.0f);
-	lily_assert_int_equal(chan.pan_left, 128);
-	lily_assert_int_equal(chan.pan_right, -128);
+	lily_assert_int_equal(chan.shared.pan_left, 128);
+	lily_assert_int_equal(chan.shared.pan_right, -128);
 }
 
 
@@ -177,9 +175,10 @@ void test_channel_sound_load()
 	sound.len = 3;
 
 	struct channel_t chan;
-	chan.active = false;
+	chan.shared.active = false;
 	chan.sound.left = NULL;
 	chan.sound.right = NULL;
+	chan.pos = 5;
 
 	int result = channel_sound_load(&chan, &sound, false);
 
@@ -187,11 +186,11 @@ void test_channel_sound_load()
 	lily_assert_int_equal(mock_p_mutex_unlock->n_calls, 1);
 	lily_assert_int_equal(result, 0);
 
-	lily_assert_int_equal(chan.active, true);
-	lily_assert_int_equal(chan.paused, false);
-	lily_assert_int_equal(chan.volume, 255);
-	lily_assert_int_equal(chan.pan_left, -128);
-	lily_assert_int_equal(chan.pan_right, 128);
+	lily_assert_int_equal(chan.shared.active, true);
+	lily_assert_int_equal(chan.shared.paused, false);
+	lily_assert_int_equal(chan.shared.volume, 255);
+	lily_assert_int_equal(chan.shared.pan_left, -128);
+	lily_assert_int_equal(chan.shared.pan_right, 128);
 
 	lily_assert_memory_equal(chan.sound.left, audio_left, sizeof(audio_left));
 	lily_assert_memory_equal(chan.sound.right, audio_right, sizeof(audio_right));
@@ -213,7 +212,7 @@ void test_channel_sound_load_mono()
 	sound.len = 3;
 
 	struct channel_t chan;
-	chan.active = false;
+	chan.shared.active = false;
 	chan.sound.left = NULL;
 	chan.sound.right = NULL;
 
@@ -223,11 +222,11 @@ void test_channel_sound_load_mono()
 	lily_assert_int_equal(mock_p_mutex_unlock->n_calls, 1);
 	lily_assert_int_equal(result, 0);
 
-	lily_assert_int_equal(chan.active, true);
-	lily_assert_int_equal(chan.paused, false);
-	lily_assert_int_equal(chan.volume, 255);
-	lily_assert_int_equal(chan.pan_left, 0);
-	lily_assert_int_equal(chan.pan_right, 0);
+	lily_assert_int_equal(chan.shared.active, true);
+	lily_assert_int_equal(chan.shared.paused, false);
+	lily_assert_int_equal(chan.shared.volume, 255);
+	lily_assert_int_equal(chan.shared.pan_left, 0);
+	lily_assert_int_equal(chan.shared.pan_right, 0);
 
 	lily_assert_memory_equal(chan.sound.left, audio, sizeof(audio));
 	lily_assert_null(chan.sound.right);
@@ -250,12 +249,12 @@ void test_channel_sound_load_preserve()
 	sound.len = 3;
 
 	struct channel_t chan;
-	chan.active = false;
+	chan.shared.active = false;
 	chan.sound.left = NULL;
 	chan.sound.right = NULL;
-	chan.volume = 127;
-	chan.pan_left = 0;
-	chan.pan_right = 64;
+	chan.shared.volume = 127;
+	chan.shared.pan_left = 0;
+	chan.shared.pan_right = 64;
 
 	int result = channel_sound_load(&chan, &sound, true);
 
@@ -263,11 +262,11 @@ void test_channel_sound_load_preserve()
 	lily_assert_int_equal(mock_p_mutex_unlock->n_calls, 1);
 	lily_assert_int_equal(result, 0);
 
-	lily_assert_int_equal(chan.active, true);
-	lily_assert_int_equal(chan.paused, false);
-	lily_assert_int_equal(chan.volume, 127);
-	lily_assert_int_equal(chan.pan_left, 0);
-	lily_assert_int_equal(chan.pan_right, 64);
+	lily_assert_int_equal(chan.shared.active, true);
+	lily_assert_int_equal(chan.shared.paused, false);
+	lily_assert_int_equal(chan.shared.volume, 127);
+	lily_assert_int_equal(chan.shared.pan_left, 0);
+	lily_assert_int_equal(chan.shared.pan_right, 64);
 
 	lily_assert_memory_equal(chan.sound.left, audio_left, sizeof(audio_left));
 	lily_assert_memory_equal(chan.sound.right, audio_right, sizeof(audio_right));
@@ -290,11 +289,11 @@ void test_channel_sound_fail()
 	sound.len = 3;
 
 	struct channel_t chan;
-	chan.active = true;
-	chan.paused = true;
-	chan.volume = 2;
-	chan.pan_left = 4;
-	chan.pan_right = 4;
+	chan.shared.active = true;
+	chan.shared.paused = true;
+	chan.shared.volume = 2;
+	chan.shared.pan_left = 4;
+	chan.shared.pan_right = 4;
 	chan.sound.left = NULL;
 	chan.sound.right = NULL;
 	chan.sound.mono = true;
@@ -306,11 +305,11 @@ void test_channel_sound_fail()
 	lily_assert_int_equal(mock_p_mutex_unlock->n_calls, 0);
 	lily_assert_int_equal(result, 1);
 
-	lily_assert_int_equal(chan.active, true);
-	lily_assert_int_equal(chan.paused, true);
-	lily_assert_int_equal(chan.volume, 2);
-	lily_assert_int_equal(chan.pan_left, 4);
-	lily_assert_int_equal(chan.pan_right, 4);
+	lily_assert_int_equal(chan.shared.active, true);
+	lily_assert_int_equal(chan.shared.paused, true);
+	lily_assert_int_equal(chan.shared.volume, 2);
+	lily_assert_int_equal(chan.shared.pan_left, 4);
+	lily_assert_int_equal(chan.shared.pan_right, 4);
 
 	lily_assert_null(chan.sound.left);
 	lily_assert_null(chan.sound.right);
@@ -326,9 +325,10 @@ void test_channel_get_next_sample_inactive()
 	lily_mock_use(&mock_p_mutex_unlock);
 
 	struct channel_t chan;
-	chan.active = false;
+	chan.shared.active = false;
 	chan.pos = 0;
 	float l = 22; float r = 22;
+	channel_update_shared(&chan);
 	channel_get_next_sample(&l, &r, &chan);
 
 	lily_assert_int_equal(mock_p_mutex_trylock->n_calls, 0);
@@ -345,10 +345,11 @@ void test_channel_get_next_sample_paused()
 	lily_mock_use(&mock_p_mutex_unlock);
 
 	struct channel_t chan;
-	chan.active = true;
-	chan.paused = true;
+	chan.shared.active = true;
+	chan.shared.paused = true;
 	chan.pos = 0;
 	float l = 22; float r = 22;
+	channel_update_shared(&chan);
 	channel_get_next_sample(&l, &r, &chan);
 
 	lily_assert_int_equal(mock_p_mutex_trylock->n_calls, 0);
@@ -365,12 +366,13 @@ void test_channel_get_next_sample_nolock()
 	lily_mock_use(&mock_p_mutex_unlock);
 
 	struct channel_t chan;
-	chan.active = true;
-	chan.paused = false;
+	chan.shared.active = true;
+	chan.shared.paused = false;
 	chan.pos = 0;
 	float l = 22; float r = 22;
 
 	lily_store_value(mock_p_mutex_trylock, pboolean, FALSE);
+	channel_update_shared(&chan);
 	channel_get_next_sample(&l, &r, &chan);
 	lily_assert_int_equal(mock_p_mutex_trylock->n_calls, 1);
 	lily_assert_int_equal(mock_p_mutex_unlock->n_calls, 0);
@@ -387,11 +389,11 @@ void test_channel_get_next_sample_normal()
 	lily_mock_use(&mock_p_mutex_unlock);
 
 	struct channel_t chan;
-	chan.active = true;
-	chan.paused = false;
-	chan.volume = 255;
-	chan.pan_left = -128;
-	chan.pan_right = 128;
+	chan.shared.active = true;
+	chan.shared.paused = false;
+	chan.shared.volume = 255;
+	chan.shared.pan_left = -128;
+	chan.shared.pan_right = 128;
 	float audio_left[] = { 0.0, 0.5, 1.0 };
 	float audio_right[] = { 1.0, 0.5, 0.0 };
 	chan.sound.left = audio_left;
@@ -403,6 +405,7 @@ void test_channel_get_next_sample_normal()
 	float l, r;
 
 	lily_store_value(mock_p_mutex_trylock, pboolean, TRUE);
+	channel_update_shared(&chan);
 	channel_get_next_sample(&l, &r, &chan);
 	lily_assert_int_equal(mock_p_mutex_trylock->n_calls, 1);
 	lily_assert_int_equal(mock_p_mutex_unlock->n_calls, 1);
@@ -411,6 +414,7 @@ void test_channel_get_next_sample_normal()
 	lily_assert_float_equal(r, 1.0f, 0.1f);
 
 	lily_store_value(mock_p_mutex_trylock, pboolean, TRUE);
+	channel_update_shared(&chan);
 	channel_get_next_sample(&l, &r, &chan);
 	lily_assert_int_equal(mock_p_mutex_trylock->n_calls, 2);
 	lily_assert_int_equal(mock_p_mutex_unlock->n_calls, 2);
@@ -419,11 +423,11 @@ void test_channel_get_next_sample_normal()
 	lily_assert_float_equal(r, 0.5f, 0.1f);
 
 	lily_store_value(mock_p_mutex_trylock, pboolean, TRUE);
+	channel_update_shared(&chan);
 	channel_get_next_sample(&l, &r, &chan);
 	lily_assert_int_equal(mock_p_mutex_trylock->n_calls, 3);
 	lily_assert_int_equal(mock_p_mutex_unlock->n_calls, 3);
-	lily_assert_int_equal(chan.pos, 0);
-	lily_assert_int_equal(chan.active, false);
+	lily_assert_int_equal(chan.shared.active, false);
 	lily_assert_float_equal(l, 1.0f, 0.1f);
 	lily_assert_float_equal(r, 0.0f, 0.1f);
 }
@@ -435,11 +439,11 @@ void test_channel_get_next_sample_volume_0()
 	lily_mock_use(&mock_p_mutex_unlock);
 
 	struct channel_t chan;
-	chan.active = true;
-	chan.paused = false;
-	chan.volume = 0;
-	chan.pan_left = -128;
-	chan.pan_right = 128;
+	chan.shared.active = true;
+	chan.shared.paused = false;
+	chan.shared.volume = 0;
+	chan.shared.pan_left = -128;
+	chan.shared.pan_right = 128;
 	float audio_left[] = { 0.0, 0.5, 1.0 };
 	float audio_right[] = { 1.0, 0.5, 0.0 };
 	chan.sound.left = audio_left;
@@ -451,6 +455,7 @@ void test_channel_get_next_sample_volume_0()
 	float l, r;
 
 	lily_store_value(mock_p_mutex_trylock, pboolean, TRUE);
+	channel_update_shared(&chan);
 	channel_get_next_sample(&l, &r, &chan);
 	lily_assert_int_equal(mock_p_mutex_trylock->n_calls, 1);
 	lily_assert_int_equal(mock_p_mutex_unlock->n_calls, 1);
@@ -459,6 +464,7 @@ void test_channel_get_next_sample_volume_0()
 	lily_assert_float_equal(r, 0.0f, 0.1f);
 
 	lily_store_value(mock_p_mutex_trylock, pboolean, TRUE);
+	channel_update_shared(&chan);
 	channel_get_next_sample(&l, &r, &chan);
 	lily_assert_int_equal(mock_p_mutex_trylock->n_calls, 2);
 	lily_assert_int_equal(mock_p_mutex_unlock->n_calls, 2);
@@ -467,11 +473,11 @@ void test_channel_get_next_sample_volume_0()
 	lily_assert_float_equal(r, 0.0f, 0.1f);
 
 	lily_store_value(mock_p_mutex_trylock, pboolean, TRUE);
+	channel_update_shared(&chan);
 	channel_get_next_sample(&l, &r, &chan);
 	lily_assert_int_equal(mock_p_mutex_trylock->n_calls, 3);
 	lily_assert_int_equal(mock_p_mutex_unlock->n_calls, 3);
-	lily_assert_int_equal(chan.pos, 0);
-	lily_assert_int_equal(chan.active, false);
+	lily_assert_int_equal(chan.shared.active, false);
 	lily_assert_float_equal(l, 0.0f, 0.1f);
 	lily_assert_float_equal(r, 0.0f, 0.1f);
 }
@@ -483,11 +489,11 @@ void test_channel_get_next_sample_mono()
 	lily_mock_use(&mock_p_mutex_unlock);
 
 	struct channel_t chan;
-	chan.active = true;
-	chan.paused = false;
-	chan.volume = 255;
-	chan.pan_left = 0;
-	chan.pan_right = 128;
+	chan.shared.active = true;
+	chan.shared.paused = false;
+	chan.shared.volume = 255;
+	chan.shared.pan_left = 0;
+	chan.shared.pan_right = 128;
 	float audio[] = { 0.0, 0.5, 1.0 };
 	chan.sound.left = audio;
 	chan.sound.right = NULL;
@@ -500,6 +506,7 @@ void test_channel_get_next_sample_mono()
 	const float gain = 0.7071; /* constant-power panning center gain */
 
 	lily_store_value(mock_p_mutex_trylock, pboolean, TRUE);
+	channel_update_shared(&chan);
 	channel_get_next_sample(&l, &r, &chan);
 	lily_assert_int_equal(mock_p_mutex_trylock->n_calls, 1);
 	lily_assert_int_equal(mock_p_mutex_unlock->n_calls, 1);
@@ -508,6 +515,7 @@ void test_channel_get_next_sample_mono()
 	lily_assert_float_equal(r, gain * 0.0f, 0.1f);
 
 	lily_store_value(mock_p_mutex_trylock, pboolean, TRUE);
+	channel_update_shared(&chan);
 	channel_get_next_sample(&l, &r, &chan);
 	lily_assert_int_equal(mock_p_mutex_trylock->n_calls, 2);
 	lily_assert_int_equal(mock_p_mutex_unlock->n_calls, 2);
@@ -516,11 +524,11 @@ void test_channel_get_next_sample_mono()
 	lily_assert_float_equal(r, gain * 0.5f, 0.1f);
 
 	lily_store_value(mock_p_mutex_trylock, pboolean, TRUE);
+	channel_update_shared(&chan);
 	channel_get_next_sample(&l, &r, &chan);
 	lily_assert_int_equal(mock_p_mutex_trylock->n_calls, 3);
 	lily_assert_int_equal(mock_p_mutex_unlock->n_calls, 3);
-	lily_assert_int_equal(chan.pos, 0);
-	lily_assert_int_equal(chan.active, false);
+	lily_assert_int_equal(chan.shared.active, false);
 	lily_assert_float_equal(l, gain * 1.0f, 0.1f);
 	lily_assert_float_equal(r, gain * 1.0f, 0.1f);
 }
@@ -532,11 +540,11 @@ void test_channel_get_next_sample_mono_panned()
 	lily_mock_use(&mock_p_mutex_unlock);
 
 	struct channel_t chan;
-	chan.active = true;
-	chan.paused = false;
-	chan.volume = 255;
-	chan.pan_left = -128;
-	chan.pan_right = 128;
+	chan.shared.active = true;
+	chan.shared.paused = false;
+	chan.shared.volume = 255;
+	chan.shared.pan_left = -128;
+	chan.shared.pan_right = 128;
 	float audio[] = { 0.0, 0.5, 1.0 };
 	chan.sound.left = audio;
 	chan.sound.right = NULL;
@@ -547,6 +555,7 @@ void test_channel_get_next_sample_mono_panned()
 	float l, r;
 
 	lily_store_value(mock_p_mutex_trylock, pboolean, TRUE);
+	channel_update_shared(&chan);
 	channel_get_next_sample(&l, &r, &chan);
 	lily_assert_int_equal(mock_p_mutex_trylock->n_calls, 1);
 	lily_assert_int_equal(mock_p_mutex_unlock->n_calls, 1);
@@ -555,6 +564,7 @@ void test_channel_get_next_sample_mono_panned()
 	lily_assert_float_equal(r, 0.0f, 0.1f);
 
 	lily_store_value(mock_p_mutex_trylock, pboolean, TRUE);
+	channel_update_shared(&chan);
 	channel_get_next_sample(&l, &r, &chan);
 	lily_assert_int_equal(mock_p_mutex_trylock->n_calls, 2);
 	lily_assert_int_equal(mock_p_mutex_unlock->n_calls, 2);
@@ -563,11 +573,11 @@ void test_channel_get_next_sample_mono_panned()
 	lily_assert_float_equal(r, 0.0f, 0.1f);
 
 	lily_store_value(mock_p_mutex_trylock, pboolean, TRUE);
+	channel_update_shared(&chan);
 	channel_get_next_sample(&l, &r, &chan);
 	lily_assert_int_equal(mock_p_mutex_trylock->n_calls, 3);
 	lily_assert_int_equal(mock_p_mutex_unlock->n_calls, 3);
-	lily_assert_int_equal(chan.pos, 0);
-	lily_assert_int_equal(chan.active, false);
+	lily_assert_int_equal(chan.shared.active, false);
 	lily_assert_float_equal(l, 1.0f, 0.1f);
 	lily_assert_float_equal(r, 0.0f, 0.1f);
 }
@@ -579,11 +589,11 @@ void test_channel_get_next_sample_panned()
 	lily_mock_use(&mock_p_mutex_unlock);
 
 	struct channel_t chan;
-	chan.active = true;
-	chan.paused = false;
-	chan.volume = 255;
-	chan.pan_left = 128;
-	chan.pan_right = 0;
+	chan.shared.active = true;
+	chan.shared.paused = false;
+	chan.shared.volume = 255;
+	chan.shared.pan_left = 128;
+	chan.shared.pan_right = 0;
 	float audio_left[] = { 0.2, 0.5, 1.0 };
 	float audio_right[] = { 1.0, 0.5, 0.2 };
 	chan.sound.left = audio_left;
@@ -596,6 +606,7 @@ void test_channel_get_next_sample_panned()
 	const float gain = 0.7071; /* constant-power panning center gain */
 
 	lily_store_value(mock_p_mutex_trylock, pboolean, TRUE);
+	channel_update_shared(&chan);
 	channel_get_next_sample(&l, &r, &chan);
 	lily_assert_int_equal(mock_p_mutex_trylock->n_calls, 1);
 	lily_assert_int_equal(mock_p_mutex_unlock->n_calls, 1);
@@ -604,6 +615,7 @@ void test_channel_get_next_sample_panned()
 	lily_assert_float_equal(r, gain * 1.0f + 0.2f, 0.1f);
 
 	lily_store_value(mock_p_mutex_trylock, pboolean, TRUE);
+	channel_update_shared(&chan);
 	channel_get_next_sample(&l, &r, &chan);
 	lily_assert_int_equal(mock_p_mutex_trylock->n_calls, 2);
 	lily_assert_int_equal(mock_p_mutex_unlock->n_calls, 2);
@@ -612,11 +624,11 @@ void test_channel_get_next_sample_panned()
 	lily_assert_float_equal(r, gain * 0.5f + 0.5f, 0.1f);
 
 	lily_store_value(mock_p_mutex_trylock, pboolean, TRUE);
+	channel_update_shared(&chan);
 	channel_get_next_sample(&l, &r, &chan);
 	lily_assert_int_equal(mock_p_mutex_trylock->n_calls, 3);
 	lily_assert_int_equal(mock_p_mutex_unlock->n_calls, 3);
-	lily_assert_int_equal(chan.pos, 0);
-	lily_assert_int_equal(chan.active, false);
+	lily_assert_int_equal(chan.shared.active, false);
 	lily_assert_float_equal(l, gain * 0.2f, 0.1f);
 	lily_assert_float_equal(r, gain * 0.2f + 1.0f, 0.1f);
 }