[Spice-devel,v4,04/17] sound: Rename SndWorker to SndChannel

Submitted by Frediano Ziglio on Dec. 1, 2016, 11:24 a.m.

Details

Message ID 5557b4b7dadcdc1c7366bb20996008691e7c0711.1480591473.git-series.fziglio@redhat.com
State Accepted
Headers show
Series "Remove DummyChannel* objects" ( rev: 1 ) in Spice

Not browsing as part of any series.

Commit Message

Frediano Ziglio Dec. 1, 2016, 11:24 a.m.
SndWorker has been historically based on RedChannel, initial git commit
has:
struct SndWorker {
     Channel base;
     ...
};

Signed-off-by: Frediano Ziglio <fziglio@redhat.com>
---
 server/sound.c | 312 +++++++++++++++++++++++++-------------------------
 1 file changed, 156 insertions(+), 156 deletions(-)

Patch hide | download patch | download mbox

diff --git a/server/sound.c b/server/sound.c
index bafdd1e..5b66f3a 100644
--- a/server/sound.c
+++ b/server/sound.c
@@ -79,12 +79,12 @@  typedef int (*snd_channel_handle_message_proc)(SndChannelClient *client, size_t 
 typedef void (*snd_channel_on_message_done_proc)(SndChannelClient *client);
 typedef void (*snd_channel_cleanup_channel_proc)(SndChannelClient *client);
 
-typedef struct SndWorker SndWorker;
+typedef struct SndChannel SndChannel;
 
 /* Connects an audio client to a Spice client */
 struct SndChannelClient {
     RedsStream *stream;
-    SndWorker *worker;
+    SndChannel *channel;
     spice_parse_channel_func_t parser;
     int refs;
 
@@ -145,10 +145,10 @@  typedef struct SpiceVolumeState {
 } SpiceVolumeState;
 
 /* Base class for SpicePlaybackState and SpiceRecordState */
-struct SndWorker {
+struct SndChannel {
     RedChannel *base_channel;
     SndChannelClient *connection; /* Only one client is supported */
-    SndWorker *next; /* For the global SndWorker list */
+    SndChannel *next; /* For the global SndChannel list */
 
     int active;
     SpiceVolumeState volume;
@@ -156,11 +156,11 @@  struct SndWorker {
 };
 
 struct SpicePlaybackState {
-    struct SndWorker worker;
+    struct SndChannel channel;
 };
 
 struct SpiceRecordState {
-    struct SndWorker worker;
+    struct SndChannel channel;
 };
 
 typedef struct RecordChannelClient {
@@ -176,11 +176,11 @@  typedef struct RecordChannelClient {
 } RecordChannelClient;
 
 /* A list of all Spice{Playback,Record}State objects */
-static SndWorker *workers;
+static SndChannel *snd_channels;
 
 static void snd_receive(SndChannelClient *client);
-static void snd_playback_start(SndWorker *worker);
-static void snd_record_start(SndWorker *worker);
+static void snd_playback_start(SndChannel *channel);
+static void snd_record_start(SndChannel *channel);
 
 static SndChannelClient *snd_channel_ref(SndChannelClient *client)
 {
@@ -201,12 +201,12 @@  static SndChannelClient *snd_channel_unref(SndChannelClient *client)
 static RedsState* snd_channel_get_server(SndChannelClient *client)
 {
     g_return_val_if_fail(client != NULL, NULL);
-    return red_channel_get_server(client->worker->base_channel);
+    return red_channel_get_server(client->channel->base_channel);
 }
 
 static void snd_disconnect_channel(SndChannelClient *client)
 {
-    SndWorker *worker;
+    SndChannel *channel;
     RedsState *reds;
     RedChannel *red_channel;
     uint32_t type;
@@ -220,17 +220,17 @@  static void snd_disconnect_channel(SndChannelClient *client)
     g_object_get(red_channel, "channel-type", &type, NULL);
     spice_debug("SndChannelClient=%p rcc=%p type=%d",
                  client, client->channel_client, type);
-    worker = client->worker;
+    channel = client->channel;
     client->cleanup(client);
-    red_channel_client_disconnect(worker->connection->channel_client);
-    worker->connection->channel_client = NULL;
+    red_channel_client_disconnect(channel->connection->channel_client);
+    channel->connection->channel_client = NULL;
     reds_core_watch_remove(reds, client->stream->watch);
     client->stream->watch = NULL;
     reds_stream_free(client->stream);
     client->stream = NULL;
     spice_marshaller_destroy(client->send_data.marshaller);
     snd_channel_unref(client);
-    worker->connection = NULL;
+    channel->connection = NULL;
 }
 
 static void snd_playback_free_frame(PlaybackChannelClient *playback_client, AudioFrame *frame)
@@ -384,11 +384,11 @@  static int snd_record_handle_message(SndChannelClient *client, size_t size, uint
         return snd_record_handle_write((RecordChannelClient *)client, size, message);
     case SPICE_MSGC_RECORD_MODE: {
         SpiceMsgcRecordMode *mode = (SpiceMsgcRecordMode *)message;
-        SndWorker *worker = client->worker;
+        SndChannel *channel = client->channel;
         record_client->mode_time = mode->time;
         if (mode->mode != SPICE_AUDIO_DATA_MODE_RAW) {
-            if (snd_codec_is_capable(mode->mode, worker->frequency)) {
-                if (snd_codec_create(&record_client->codec, mode->mode, worker->frequency,
+            if (snd_codec_is_capable(mode->mode, channel->frequency)) {
+                if (snd_codec_create(&record_client->codec, mode->mode, channel->frequency,
                                      SND_CODEC_DECODE) == SND_CODEC_OK) {
                     record_client->mode = mode->mode;
                 } else {
@@ -571,7 +571,7 @@  static int snd_send_volume(SndChannelClient *client, uint32_t cap, int msg)
 {
     SpiceMsgAudioVolume *vol;
     uint8_t c;
-    SpiceVolumeState *st = &client->worker->volume;
+    SpiceVolumeState *st = &client->channel->volume;
 
     if (!red_channel_client_test_remote_cap(client->channel_client, cap)) {
         return TRUE;
@@ -600,7 +600,7 @@  static int snd_playback_send_volume(PlaybackChannelClient *playback_client)
 static int snd_send_mute(SndChannelClient *client, uint32_t cap, int msg)
 {
     SpiceMsgAudioMute mute;
-    SpiceVolumeState *st = &client->worker->volume;
+    SpiceVolumeState *st = &client->channel->volume;
 
     if (!red_channel_client_test_remote_cap(client->channel_client, cap)) {
         return TRUE;
@@ -645,7 +645,7 @@  static int snd_playback_send_start(PlaybackChannelClient *playback_client)
     }
 
     start.channels = SPICE_INTERFACE_PLAYBACK_CHAN;
-    start.frequency = client->worker->frequency;
+    start.frequency = client->channel->frequency;
     spice_assert(SPICE_INTERFACE_PLAYBACK_FMT == SPICE_INTERFACE_AUDIO_FMT_S16);
     start.format = SPICE_AUDIO_FMT_S16;
     start.time = reds_get_mm_time();
@@ -686,7 +686,7 @@  static int snd_record_send_start(RecordChannelClient *record_client)
     }
 
     start.channels = SPICE_INTERFACE_RECORD_CHAN;
-    start.frequency = client->worker->frequency;
+    start.frequency = client->channel->frequency;
     spice_assert(SPICE_INTERFACE_RECORD_FMT == SPICE_INTERFACE_AUDIO_FMT_S16);
     start.format = SPICE_AUDIO_FMT_S16;
     spice_marshall_msg_record_start(client->send_data.marshaller, &start);
@@ -873,7 +873,7 @@  static void snd_record_send(void* data)
     }
 }
 
-static SndChannelClient *__new_channel(SndWorker *worker, int size, uint32_t channel_id,
+static SndChannelClient *__new_channel(SndChannel *channel, int size, uint32_t channel_id,
                                  RedClient *red_client,
                                  RedsStream *stream,
                                  int migrate,
@@ -892,7 +892,7 @@  static SndChannelClient *__new_channel(SndWorker *worker, int size, uint32_t cha
 #endif
     int tos;
     MainChannelClient *mcc = red_client_get_main(red_client);
-    RedsState *reds = red_channel_get_server(worker->base_channel);
+    RedsState *reds = red_channel_get_server(channel->base_channel);
 
     spice_assert(stream);
     if ((flags = fcntl(stream->socket, F_GETFL)) == -1) {
@@ -934,7 +934,7 @@  static SndChannelClient *__new_channel(SndWorker *worker, int size, uint32_t cha
     client->refs = 1;
     client->parser = spice_get_client_channel_parser(channel_id, NULL);
     client->stream = stream;
-    client->worker = worker;
+    client->channel = channel;
     client->receive_data.message_start = client->receive_data.buf;
     client->receive_data.now = client->receive_data.buf;
     client->receive_data.end = client->receive_data.buf + sizeof(client->receive_data.buf);
@@ -953,7 +953,7 @@  static SndChannelClient *__new_channel(SndWorker *worker, int size, uint32_t cha
     client->cleanup = cleanup;
 
     client->channel_client =
-        dummy_channel_client_create(worker->base_channel, red_client,
+        dummy_channel_client_create(channel->base_channel, red_client,
                                     num_common_caps, common_caps, num_caps, caps);
     if (!client->channel_client) {
         goto error2;
@@ -970,19 +970,19 @@  error1:
 
 static void snd_disconnect_channel_client(RedChannelClient *rcc)
 {
-    SndWorker *worker;
-    RedChannel *channel = red_channel_client_get_channel(rcc);
+    SndChannel *channel;
+    RedChannel *red_channel = red_channel_client_get_channel(rcc);
     uint32_t type;
 
+    spice_assert(red_channel);
+    channel = (SndChannel *)g_object_get_data(G_OBJECT(red_channel), "sound-channel");
     spice_assert(channel);
-    worker = (SndWorker *)g_object_get_data(G_OBJECT(channel), "sound-worker");
-    spice_assert(worker);
-    g_object_get(channel, "channel-type", &type, NULL);
+    g_object_get(red_channel, "channel-type", &type, NULL);
 
     spice_debug("channel-type=%d", type);
-    if (worker->connection) {
-        spice_assert(worker->connection->channel_client == rcc);
-        snd_disconnect_channel(worker->connection);
+    if (channel->connection) {
+        spice_assert(channel->connection->channel_client == rcc);
+        snd_disconnect_channel(channel->connection);
     }
 }
 
@@ -998,8 +998,8 @@  SPICE_GNUC_VISIBLE void spice_server_playback_set_volume(SpicePlaybackInstance *
                                                   uint8_t nchannels,
                                                   uint16_t *volume)
 {
-    SpiceVolumeState *st = &sin->st->worker.volume;
-    SndChannelClient *client = sin->st->worker.connection;
+    SpiceVolumeState *st = &sin->st->channel.volume;
+    SndChannelClient *client = sin->st->channel.connection;
     PlaybackChannelClient *playback_client = SPICE_CONTAINEROF(client, PlaybackChannelClient, base);
 
     st->volume_nchannels = nchannels;
@@ -1014,8 +1014,8 @@  SPICE_GNUC_VISIBLE void spice_server_playback_set_volume(SpicePlaybackInstance *
 
 SPICE_GNUC_VISIBLE void spice_server_playback_set_mute(SpicePlaybackInstance *sin, uint8_t mute)
 {
-    SpiceVolumeState *st = &sin->st->worker.volume;
-    SndChannelClient *client = sin->st->worker.connection;
+    SpiceVolumeState *st = &sin->st->channel.volume;
+    SndChannelClient *client = sin->st->channel.connection;
     PlaybackChannelClient *playback_client = SPICE_CONTAINEROF(client, PlaybackChannelClient, base);
 
     st->mute = mute;
@@ -1026,11 +1026,11 @@  SPICE_GNUC_VISIBLE void spice_server_playback_set_mute(SpicePlaybackInstance *si
     snd_playback_send_mute(playback_client);
 }
 
-static void snd_playback_start(SndWorker *worker)
+static void snd_playback_start(SndChannel *channel)
 {
-    SndChannelClient *client = worker->connection;
+    SndChannelClient *client = channel->connection;
 
-    worker->active = 1;
+    channel->active = 1;
     if (!client)
         return;
     spice_assert(!client->active);
@@ -1046,15 +1046,15 @@  static void snd_playback_start(SndWorker *worker)
 
 SPICE_GNUC_VISIBLE void spice_server_playback_start(SpicePlaybackInstance *sin)
 {
-    return snd_playback_start(&sin->st->worker);
+    return snd_playback_start(&sin->st->channel);
 }
 
 SPICE_GNUC_VISIBLE void spice_server_playback_stop(SpicePlaybackInstance *sin)
 {
-    SndChannelClient *client = sin->st->worker.connection;
+    SndChannelClient *client = sin->st->channel.connection;
     PlaybackChannelClient *playback_client = SPICE_CONTAINEROF(client, PlaybackChannelClient, base);
 
-    sin->st->worker.active = 0;
+    sin->st->channel.active = 0;
     if (!client)
         return;
     spice_assert(playback_client->base.active);
@@ -1079,7 +1079,7 @@  SPICE_GNUC_VISIBLE void spice_server_playback_stop(SpicePlaybackInstance *sin)
 SPICE_GNUC_VISIBLE void spice_server_playback_get_buffer(SpicePlaybackInstance *sin,
                                                          uint32_t **frame, uint32_t *num_samples)
 {
-    SndChannelClient *client = sin->st->worker.connection;
+    SndChannelClient *client = sin->st->channel.connection;
     PlaybackChannelClient *playback_client = SPICE_CONTAINEROF(client, PlaybackChannelClient, base);
 
     if (!client || !playback_client->free_frames) {
@@ -1104,7 +1104,7 @@  SPICE_GNUC_VISIBLE void spice_server_playback_put_samples(SpicePlaybackInstance 
     playback_client = frame->client;
     spice_assert(playback_client);
     if (!snd_channel_unref(&playback_client->base) ||
-        sin->st->worker.connection != &playback_client->base) {
+        sin->st->channel.connection != &playback_client->base) {
         /* lost last reference, client has been destroyed previously */
         spice_info("audio samples belong to a disconnected client");
         return;
@@ -1122,7 +1122,7 @@  SPICE_GNUC_VISIBLE void spice_server_playback_put_samples(SpicePlaybackInstance 
 
 void snd_set_playback_latency(RedClient *client, uint32_t latency)
 {
-    SndWorker *now = workers;
+    SndChannel *now = snd_channels;
 
     for (; now; now = now->next) {
         uint32_t type;
@@ -1159,18 +1159,18 @@  static int snd_desired_audio_mode(int playback_compression, int frequency,
     return SPICE_AUDIO_DATA_MODE_RAW;
 }
 
-static void on_new_playback_channel(SndWorker *worker, SndChannelClient *snd_channel)
+static void on_new_playback_channel(SndChannel *channel, SndChannelClient *snd_channel)
 {
-    RedsState *reds = red_channel_get_server(worker->base_channel);
+    RedsState *reds = red_channel_get_server(channel->base_channel);
 
     spice_assert(snd_channel);
 
-    worker->connection = snd_channel;
+    channel->connection = snd_channel;
     snd_set_command(snd_channel, SND_PLAYBACK_MODE_MASK);
     if (snd_channel->active) {
         snd_set_command(snd_channel, SND_CTRL_MASK);
     }
-    if (worker->volume.volume_nchannels) {
+    if (channel->volume.volume_nchannels) {
         snd_set_command(snd_channel, SND_VOLUME_MASK);
     }
     if (snd_channel->active) {
@@ -1189,16 +1189,16 @@  static void snd_playback_cleanup(SndChannelClient *client)
     snd_codec_destroy(&playback_client->codec);
 }
 
-static void snd_set_playback_peer(RedChannel *channel, RedClient *client, RedsStream *stream,
+static void snd_set_playback_peer(RedChannel *red_channel, RedClient *client, RedsStream *stream,
                                   int migration, int num_common_caps, uint32_t *common_caps,
                                   int num_caps, uint32_t *caps)
 {
-    SndWorker *worker = g_object_get_data(G_OBJECT(channel), "sound-worker");
+    SndChannel *channel = g_object_get_data(G_OBJECT(red_channel), "sound-channel");
     PlaybackChannelClient *playback_client;
 
-    snd_disconnect_channel(worker->connection);
+    snd_disconnect_channel(channel->connection);
 
-    if (!(playback_client = (PlaybackChannelClient *)__new_channel(worker,
+    if (!(playback_client = (PlaybackChannelClient *)__new_channel(channel,
                                                               sizeof(*playback_client),
                                                               SPICE_CHANNEL_PLAYBACK,
                                                               client,
@@ -1221,12 +1221,12 @@  static void snd_set_playback_peer(RedChannel *channel, RedClient *client, RedsSt
     int client_can_opus = red_channel_client_test_remote_cap(playback_client->base.channel_client,
                                           SPICE_PLAYBACK_CAP_OPUS);
     int playback_compression =
-        reds_config_get_playback_compression(red_channel_get_server(channel));
-    int desired_mode = snd_desired_audio_mode(playback_compression, worker->frequency,
+        reds_config_get_playback_compression(red_channel_get_server(red_channel));
+    int desired_mode = snd_desired_audio_mode(playback_compression, channel->frequency,
                                               client_can_celt, client_can_opus);
     playback_client->mode = SPICE_AUDIO_DATA_MODE_RAW;
     if (desired_mode != SPICE_AUDIO_DATA_MODE_RAW) {
-        if (snd_codec_create(&playback_client->codec, desired_mode, worker->frequency,
+        if (snd_codec_create(&playback_client->codec, desired_mode, channel->frequency,
                              SND_CODEC_ENCODE) == SND_CODEC_OK) {
             playback_client->mode = desired_mode;
         } else {
@@ -1235,29 +1235,29 @@  static void snd_set_playback_peer(RedChannel *channel, RedClient *client, RedsSt
     }
 
     if (!red_client_during_migrate_at_target(client)) {
-        on_new_playback_channel(worker, &playback_client->base);
+        on_new_playback_channel(channel, &playback_client->base);
     }
 
-    if (worker->active) {
-        snd_playback_start(worker);
+    if (channel->active) {
+        snd_playback_start(channel);
     }
-    snd_playback_send(worker->connection);
+    snd_playback_send(channel->connection);
 }
 
 static void snd_record_migrate_channel_client(RedChannelClient *rcc)
 {
-    SndWorker *worker;
-    RedChannel *channel = red_channel_client_get_channel(rcc);
+    SndChannel *channel;
+    RedChannel *red_channel = red_channel_client_get_channel(rcc);
 
     spice_debug(NULL);
+    spice_assert(red_channel);
+    channel = (SndChannel *)g_object_get_data(G_OBJECT(red_channel), "sound-channel");
     spice_assert(channel);
-    worker = (SndWorker *)g_object_get_data(G_OBJECT(channel), "sound-worker");
-    spice_assert(worker);
 
-    if (worker->connection) {
-        spice_assert(worker->connection->channel_client == rcc);
-        snd_set_command(worker->connection, SND_MIGRATE_MASK);
-        snd_record_send(worker->connection);
+    if (channel->connection) {
+        spice_assert(channel->connection->channel_client == rcc);
+        snd_set_command(channel->connection, SND_MIGRATE_MASK);
+        snd_record_send(channel->connection);
     }
 }
 
@@ -1265,8 +1265,8 @@  SPICE_GNUC_VISIBLE void spice_server_record_set_volume(SpiceRecordInstance *sin,
                                                 uint8_t nchannels,
                                                 uint16_t *volume)
 {
-    SpiceVolumeState *st = &sin->st->worker.volume;
-    SndChannelClient *client = sin->st->worker.connection;
+    SpiceVolumeState *st = &sin->st->channel.volume;
+    SndChannelClient *client = sin->st->channel.connection;
     RecordChannelClient *record_client = SPICE_CONTAINEROF(client, RecordChannelClient, base);
 
     st->volume_nchannels = nchannels;
@@ -1281,8 +1281,8 @@  SPICE_GNUC_VISIBLE void spice_server_record_set_volume(SpiceRecordInstance *sin,
 
 SPICE_GNUC_VISIBLE void spice_server_record_set_mute(SpiceRecordInstance *sin, uint8_t mute)
 {
-    SpiceVolumeState *st = &sin->st->worker.volume;
-    SndChannelClient *client = sin->st->worker.connection;
+    SpiceVolumeState *st = &sin->st->channel.volume;
+    SndChannelClient *client = sin->st->channel.connection;
     RecordChannelClient *record_client = SPICE_CONTAINEROF(client, RecordChannelClient, base);
 
     st->mute = mute;
@@ -1293,12 +1293,12 @@  SPICE_GNUC_VISIBLE void spice_server_record_set_mute(SpiceRecordInstance *sin, u
     snd_record_send_mute(record_client);
 }
 
-static void snd_record_start(SndWorker *worker)
+static void snd_record_start(SndChannel *channel)
 {
-    SndChannelClient *client = worker->connection;
+    SndChannelClient *client = channel->connection;
     RecordChannelClient *record_client = SPICE_CONTAINEROF(client, RecordChannelClient, base);
 
-    worker->active = 1;
+    channel->active = 1;
     if (!client)
         return;
     spice_assert(!client->active);
@@ -1315,15 +1315,15 @@  static void snd_record_start(SndWorker *worker)
 
 SPICE_GNUC_VISIBLE void spice_server_record_start(SpiceRecordInstance *sin)
 {
-    snd_record_start(&sin->st->worker);
+    snd_record_start(&sin->st->channel);
 }
 
 SPICE_GNUC_VISIBLE void spice_server_record_stop(SpiceRecordInstance *sin)
 {
-    SndChannelClient *client = sin->st->worker.connection;
+    SndChannelClient *client = sin->st->channel.connection;
     RecordChannelClient *record_client = SPICE_CONTAINEROF(client, RecordChannelClient, base);
 
-    sin->st->worker.active = 0;
+    sin->st->channel.active = 0;
     if (!client)
         return;
     spice_assert(record_client->base.active);
@@ -1339,7 +1339,7 @@  SPICE_GNUC_VISIBLE void spice_server_record_stop(SpiceRecordInstance *sin)
 SPICE_GNUC_VISIBLE uint32_t spice_server_record_get_samples(SpiceRecordInstance *sin,
                                                             uint32_t *samples, uint32_t bufsize)
 {
-    SndChannelClient *client = sin->st->worker.connection;
+    SndChannelClient *client = sin->st->channel.connection;
     RecordChannelClient *record_client = SPICE_CONTAINEROF(client, RecordChannelClient, base);
     uint32_t read_pos;
     uint32_t now;
@@ -1356,9 +1356,9 @@  SPICE_GNUC_VISIBLE uint32_t spice_server_record_get_samples(SpiceRecordInstance 
     len = MIN(record_client->write_pos - record_client->read_pos, bufsize);
 
     if (len < bufsize) {
-        SndWorker *worker = record_client->base.worker;
+        SndChannel *channel = record_client->base.channel;
         snd_receive(&record_client->base);
-        if (!worker->connection) {
+        if (!channel->connection) {
             return 0;
         }
         len = MIN(record_client->write_pos - record_client->read_pos, bufsize);
@@ -1387,41 +1387,41 @@  static uint32_t snd_get_best_rate(SndChannelClient *client, uint32_t cap_opus)
     return SND_CODEC_CELT_PLAYBACK_FREQ;
 }
 
-static void snd_set_rate(SndWorker *worker, uint32_t frequency, uint32_t cap_opus)
+static void snd_set_rate(SndChannel *channel, uint32_t frequency, uint32_t cap_opus)
 {
-    RedChannel *channel = worker->base_channel;
-    worker->frequency = frequency;
-    if (channel && snd_codec_is_capable(SPICE_AUDIO_DATA_MODE_OPUS, frequency)) {
-        red_channel_set_cap(channel, cap_opus);
+    RedChannel *red_channel = channel->base_channel;
+    channel->frequency = frequency;
+    if (red_channel && snd_codec_is_capable(SPICE_AUDIO_DATA_MODE_OPUS, frequency)) {
+        red_channel_set_cap(red_channel, cap_opus);
     }
 }
 
 SPICE_GNUC_VISIBLE uint32_t spice_server_get_best_playback_rate(SpicePlaybackInstance *sin)
 {
-    return snd_get_best_rate(sin ? sin->st->worker.connection : NULL, SPICE_PLAYBACK_CAP_OPUS);
+    return snd_get_best_rate(sin ? sin->st->channel.connection : NULL, SPICE_PLAYBACK_CAP_OPUS);
 }
 
 SPICE_GNUC_VISIBLE void spice_server_set_playback_rate(SpicePlaybackInstance *sin, uint32_t frequency)
 {
-    snd_set_rate(&sin->st->worker, frequency, SPICE_PLAYBACK_CAP_OPUS);
+    snd_set_rate(&sin->st->channel, frequency, SPICE_PLAYBACK_CAP_OPUS);
 }
 
 SPICE_GNUC_VISIBLE uint32_t spice_server_get_best_record_rate(SpiceRecordInstance *sin)
 {
-    return snd_get_best_rate(sin ? sin->st->worker.connection : NULL, SPICE_RECORD_CAP_OPUS);
+    return snd_get_best_rate(sin ? sin->st->channel.connection : NULL, SPICE_RECORD_CAP_OPUS);
 }
 
 SPICE_GNUC_VISIBLE void spice_server_set_record_rate(SpiceRecordInstance *sin, uint32_t frequency)
 {
-    snd_set_rate(&sin->st->worker, frequency, SPICE_RECORD_CAP_OPUS);
+    snd_set_rate(&sin->st->channel, frequency, SPICE_RECORD_CAP_OPUS);
 }
 
-static void on_new_record_channel(SndWorker *worker, SndChannelClient *snd_channel)
+static void on_new_record_channel(SndChannel *channel, SndChannelClient *snd_channel)
 {
     spice_assert(snd_channel);
 
-    worker->connection = snd_channel ;
-    if (worker->volume.volume_nchannels) {
+    channel->connection = snd_channel ;
+    if (channel->volume.volume_nchannels) {
         snd_set_command(snd_channel, SND_VOLUME_MASK);
     }
     if (snd_channel->active) {
@@ -1435,16 +1435,16 @@  static void snd_record_cleanup(SndChannelClient *client)
     snd_codec_destroy(&record_client->codec);
 }
 
-static void snd_set_record_peer(RedChannel *channel, RedClient *client, RedsStream *stream,
+static void snd_set_record_peer(RedChannel *red_channel, RedClient *client, RedsStream *stream,
                                 int migration, int num_common_caps, uint32_t *common_caps,
                                 int num_caps, uint32_t *caps)
 {
-    SndWorker *worker = g_object_get_data(G_OBJECT(channel), "sound-worker");
+    SndChannel *channel = g_object_get_data(G_OBJECT(red_channel), "sound-channel");
     RecordChannelClient *record_client;
 
-    snd_disconnect_channel(worker->connection);
+    snd_disconnect_channel(channel->connection);
 
-    if (!(record_client = (RecordChannelClient *)__new_channel(worker,
+    if (!(record_client = (RecordChannelClient *)__new_channel(channel,
                                                           sizeof(*record_client),
                                                           SPICE_CHANNEL_RECORD,
                                                           client,
@@ -1461,42 +1461,42 @@  static void snd_set_record_peer(RedChannel *channel, RedClient *client, RedsStre
 
     record_client->mode = SPICE_AUDIO_DATA_MODE_RAW;
 
-    on_new_record_channel(worker, &record_client->base);
-    if (worker->active) {
-        snd_record_start(worker);
+    on_new_record_channel(channel, &record_client->base);
+    if (channel->active) {
+        snd_record_start(channel);
     }
-    snd_record_send(worker->connection);
+    snd_record_send(channel->connection);
 }
 
 static void snd_playback_migrate_channel_client(RedChannelClient *rcc)
 {
-    SndWorker *worker;
-    RedChannel *channel = red_channel_client_get_channel(rcc);
+    SndChannel *channel;
+    RedChannel *red_channel = red_channel_client_get_channel(rcc);
 
+    spice_assert(red_channel);
+    channel = (SndChannel *)g_object_get_data(G_OBJECT(red_channel), "sound-channel");
     spice_assert(channel);
-    worker = (SndWorker *)g_object_get_data(G_OBJECT(channel), "sound-worker");
-    spice_assert(worker);
     spice_debug(NULL);
 
-    if (worker->connection) {
-        spice_assert(worker->connection->channel_client == rcc);
-        snd_set_command(worker->connection, SND_MIGRATE_MASK);
-        snd_playback_send(worker->connection);
+    if (channel->connection) {
+        spice_assert(channel->connection->channel_client == rcc);
+        snd_set_command(channel->connection, SND_MIGRATE_MASK);
+        snd_playback_send(channel->connection);
     }
 }
 
-static void add_worker(SndWorker *worker)
+static void add_channel(SndChannel *channel)
 {
-    worker->next = workers;
-    workers = worker;
+    channel->next = snd_channels;
+    snd_channels = channel;
 }
 
-static void remove_worker(SndWorker *worker)
+static void remove_channel(SndChannel *channel)
 {
-    SndWorker **now = &workers;
+    SndChannel **now = &snd_channels;
     while (*now) {
-        if (*now == worker) {
-            *now = worker->next;
+        if (*now == channel) {
+            *now = channel->next;
             return;
         }
         now = &(*now)->next;
@@ -1506,73 +1506,73 @@  static void remove_worker(SndWorker *worker)
 
 void snd_attach_playback(RedsState *reds, SpicePlaybackInstance *sin)
 {
-    SndWorker *playback_worker;
-    RedChannel *channel;
+    SndChannel *playback;
+    RedChannel *red_channel;
     ClientCbs client_cbs = { NULL, };
 
     sin->st = spice_new0(SpicePlaybackState, 1);
-    playback_worker = &sin->st->worker;
-    playback_worker->frequency = SND_CODEC_CELT_PLAYBACK_FREQ; /* Default to the legacy rate */
+    playback = &sin->st->channel;
+    playback->frequency = SND_CODEC_CELT_PLAYBACK_FREQ; /* Default to the legacy rate */
 
-    // TODO: Make RedChannel base of worker? instead of assigning it to channel->data
-    channel = dummy_channel_new(reds, SPICE_CHANNEL_PLAYBACK, 0);
+    // TODO: Make RedChannel base of channel? instead of assigning it to channel->data
+    red_channel = dummy_channel_new(reds, SPICE_CHANNEL_PLAYBACK, 0);
 
-    g_object_set_data(G_OBJECT(channel), "sound-worker", playback_worker);
+    g_object_set_data(G_OBJECT(red_channel), "sound-channel", playback);
     client_cbs.connect = snd_set_playback_peer;
     client_cbs.disconnect = snd_disconnect_channel_client;
     client_cbs.migrate = snd_playback_migrate_channel_client;
-    red_channel_register_client_cbs(channel, &client_cbs, playback_worker);
+    red_channel_register_client_cbs(red_channel, &client_cbs, playback);
 
     if (snd_codec_is_capable(SPICE_AUDIO_DATA_MODE_CELT_0_5_1, SND_CODEC_ANY_FREQUENCY))
-        red_channel_set_cap(channel, SPICE_PLAYBACK_CAP_CELT_0_5_1);
+        red_channel_set_cap(red_channel, SPICE_PLAYBACK_CAP_CELT_0_5_1);
 
-    red_channel_set_cap(channel, SPICE_PLAYBACK_CAP_VOLUME);
+    red_channel_set_cap(red_channel, SPICE_PLAYBACK_CAP_VOLUME);
 
-    playback_worker->base_channel = channel;
-    add_worker(playback_worker);
-    reds_register_channel(reds, channel);
+    playback->base_channel = red_channel;
+    add_channel(playback);
+    reds_register_channel(reds, red_channel);
 }
 
 void snd_attach_record(RedsState *reds, SpiceRecordInstance *sin)
 {
-    SndWorker *record_worker;
-    RedChannel *channel;
+    SndChannel *record;
+    RedChannel *red_channel;
     ClientCbs client_cbs = { NULL, };
 
     sin->st = spice_new0(SpiceRecordState, 1);
-    record_worker = &sin->st->worker;
-    record_worker->frequency = SND_CODEC_CELT_PLAYBACK_FREQ; /* Default to the legacy rate */
+    record = &sin->st->channel;
+    record->frequency = SND_CODEC_CELT_PLAYBACK_FREQ; /* Default to the legacy rate */
 
-    // TODO: Make RedChannel base of worker? instead of assigning it to channel->data
-    channel = dummy_channel_new(reds, SPICE_CHANNEL_RECORD, 0);
+    // TODO: Make RedChannel base of channel? instead of assigning it to channel->data
+    red_channel = dummy_channel_new(reds, SPICE_CHANNEL_RECORD, 0);
 
-    g_object_set_data(G_OBJECT(channel), "sound-worker", record_worker);
+    g_object_set_data(G_OBJECT(red_channel), "sound-channel", record);
     client_cbs.connect = snd_set_record_peer;
     client_cbs.disconnect = snd_disconnect_channel_client;
     client_cbs.migrate = snd_record_migrate_channel_client;
-    red_channel_register_client_cbs(channel, &client_cbs, record_worker);
+    red_channel_register_client_cbs(red_channel, &client_cbs, record);
     if (snd_codec_is_capable(SPICE_AUDIO_DATA_MODE_CELT_0_5_1, SND_CODEC_ANY_FREQUENCY))
-        red_channel_set_cap(channel, SPICE_RECORD_CAP_CELT_0_5_1);
-    red_channel_set_cap(channel, SPICE_RECORD_CAP_VOLUME);
+        red_channel_set_cap(red_channel, SPICE_RECORD_CAP_CELT_0_5_1);
+    red_channel_set_cap(red_channel, SPICE_RECORD_CAP_VOLUME);
 
-    record_worker->base_channel = channel;
-    add_worker(record_worker);
-    reds_register_channel(reds, channel);
+    record->base_channel = red_channel;
+    add_channel(record);
+    reds_register_channel(reds, red_channel);
 }
 
-static void snd_detach_common(SndWorker *worker)
+static void snd_detach_common(SndChannel *channel)
 {
-    if (!worker) {
+    if (!channel) {
         return;
     }
-    RedsState *reds = red_channel_get_server(worker->base_channel);
+    RedsState *reds = red_channel_get_server(channel->base_channel);
 
-    remove_worker(worker);
-    snd_disconnect_channel(worker->connection);
-    reds_unregister_channel(reds, worker->base_channel);
-    red_channel_destroy(worker->base_channel);
-    free(worker->volume.volume);
-    worker->volume.volume = NULL;
+    remove_channel(channel);
+    snd_disconnect_channel(channel->connection);
+    reds_unregister_channel(reds, channel->base_channel);
+    red_channel_destroy(channel->base_channel);
+    free(channel->volume.volume);
+    channel->volume.volume = NULL;
 }
 
 static void spice_playback_state_free(SpicePlaybackState *st)
@@ -1582,7 +1582,7 @@  static void spice_playback_state_free(SpicePlaybackState *st)
 
 void snd_detach_playback(SpicePlaybackInstance *sin)
 {
-    snd_detach_common(&sin->st->worker);
+    snd_detach_common(&sin->st->channel);
     spice_playback_state_free(sin->st);
 }
 
@@ -1593,13 +1593,13 @@  static void spice_record_state_free(SpiceRecordState *st)
 
 void snd_detach_record(SpiceRecordInstance *sin)
 {
-    snd_detach_common(&sin->st->worker);
+    snd_detach_common(&sin->st->channel);
     spice_record_state_free(sin->st);
 }
 
 void snd_set_playback_compression(int on)
 {
-    SndWorker *now = workers;
+    SndChannel *now = snd_channels;
 
     for (; now; now = now->next) {
         uint32_t type;

Comments

On Thu, Dec 01, 2016 at 11:24:26AM +0000, Frediano Ziglio wrote:
> @@ -1506,73 +1506,73 @@ static void remove_worker(SndWorker *worker)
>  
>  void snd_attach_playback(RedsState *reds, SpicePlaybackInstance *sin)
>  {
> -    SndWorker *playback_worker;
> -    RedChannel *channel;
> +    SndChannel *playback;
> +    RedChannel *red_channel;

Here s/channel/red_channel was not really necessary as the other
variable is named "playback" and not channel, ditto in snd_attach_record
below.

Acked-by: Christophe Fergeau <cfergeau@redhat.com>

Christophe

>      ClientCbs client_cbs = { NULL, };
>  
>      sin->st = spice_new0(SpicePlaybackState, 1);
> -    playback_worker = &sin->st->worker;
> -    playback_worker->frequency = SND_CODEC_CELT_PLAYBACK_FREQ; /* Default to the legacy rate */
> +    playback = &sin->st->channel;
> +    playback->frequency = SND_CODEC_CELT_PLAYBACK_FREQ; /* Default to the legacy rate */
>  
> -    // TODO: Make RedChannel base of worker? instead of assigning it to channel->data
> -    channel = dummy_channel_new(reds, SPICE_CHANNEL_PLAYBACK, 0);
> +    // TODO: Make RedChannel base of channel? instead of assigning it to channel->data
> +    red_channel = dummy_channel_new(reds, SPICE_CHANNEL_PLAYBACK, 0);
>  
> -    g_object_set_data(G_OBJECT(channel), "sound-worker", playback_worker);
> +    g_object_set_data(G_OBJECT(red_channel), "sound-channel", playback);
>      client_cbs.connect = snd_set_playback_peer;
>      client_cbs.disconnect = snd_disconnect_channel_client;
>      client_cbs.migrate = snd_playback_migrate_channel_client;
> -    red_channel_register_client_cbs(channel, &client_cbs, playback_worker);
> +    red_channel_register_client_cbs(red_channel, &client_cbs, playback);
>  
>      if (snd_codec_is_capable(SPICE_AUDIO_DATA_MODE_CELT_0_5_1, SND_CODEC_ANY_FREQUENCY))
> -        red_channel_set_cap(channel, SPICE_PLAYBACK_CAP_CELT_0_5_1);
> +        red_channel_set_cap(red_channel, SPICE_PLAYBACK_CAP_CELT_0_5_1);
>  
> -    red_channel_set_cap(channel, SPICE_PLAYBACK_CAP_VOLUME);
> +    red_channel_set_cap(red_channel, SPICE_PLAYBACK_CAP_VOLUME);
>  
> -    playback_worker->base_channel = channel;
> -    add_worker(playback_worker);
> -    reds_register_channel(reds, channel);
> +    playback->base_channel = red_channel;
> +    add_channel(playback);
> +    reds_register_channel(reds, red_channel);
>  }
>  
>  void snd_attach_record(RedsState *reds, SpiceRecordInstance *sin)
>  {
> -    SndWorker *record_worker;
> -    RedChannel *channel;
> +    SndChannel *record;
> +    RedChannel *red_channel;
>      ClientCbs client_cbs = { NULL, };
>  
>      sin->st = spice_new0(SpiceRecordState, 1);
> -    record_worker = &sin->st->worker;
> -    record_worker->frequency = SND_CODEC_CELT_PLAYBACK_FREQ; /* Default to the legacy rate */
> +    record = &sin->st->channel;
> +    record->frequency = SND_CODEC_CELT_PLAYBACK_FREQ; /* Default to the legacy rate */
>  
> -    // TODO: Make RedChannel base of worker? instead of assigning it to channel->data
> -    channel = dummy_channel_new(reds, SPICE_CHANNEL_RECORD, 0);
> +    // TODO: Make RedChannel base of channel? instead of assigning it to channel->data
> +    red_channel = dummy_channel_new(reds, SPICE_CHANNEL_RECORD, 0);
>  
> -    g_object_set_data(G_OBJECT(channel), "sound-worker", record_worker);
> +    g_object_set_data(G_OBJECT(red_channel), "sound-channel", record);
>      client_cbs.connect = snd_set_record_peer;
>      client_cbs.disconnect = snd_disconnect_channel_client;
>      client_cbs.migrate = snd_record_migrate_channel_client;
> -    red_channel_register_client_cbs(channel, &client_cbs, record_worker);
> +    red_channel_register_client_cbs(red_channel, &client_cbs, record);
>      if (snd_codec_is_capable(SPICE_AUDIO_DATA_MODE_CELT_0_5_1, SND_CODEC_ANY_FREQUENCY))
> -        red_channel_set_cap(channel, SPICE_RECORD_CAP_CELT_0_5_1);
> -    red_channel_set_cap(channel, SPICE_RECORD_CAP_VOLUME);
> +        red_channel_set_cap(red_channel, SPICE_RECORD_CAP_CELT_0_5_1);
> +    red_channel_set_cap(red_channel, SPICE_RECORD_CAP_VOLUME);
>  
> -    record_worker->base_channel = channel;
> -    add_worker(record_worker);
> -    reds_register_channel(reds, channel);
> +    record->base_channel = red_channel;
> +    add_channel(record);
> +    reds_register_channel(reds, red_channel);
>  }
>  
> -static void snd_detach_common(SndWorker *worker)
> +static void snd_detach_common(SndChannel *channel)
>  {
> -    if (!worker) {
> +    if (!channel) {
>          return;
>      }
> -    RedsState *reds = red_channel_get_server(worker->base_channel);
> +    RedsState *reds = red_channel_get_server(channel->base_channel);
>  
> -    remove_worker(worker);
> -    snd_disconnect_channel(worker->connection);
> -    reds_unregister_channel(reds, worker->base_channel);
> -    red_channel_destroy(worker->base_channel);
> -    free(worker->volume.volume);
> -    worker->volume.volume = NULL;
> +    remove_channel(channel);
> +    snd_disconnect_channel(channel->connection);
> +    reds_unregister_channel(reds, channel->base_channel);
> +    red_channel_destroy(channel->base_channel);
> +    free(channel->volume.volume);
> +    channel->volume.volume = NULL;
>  }
>  
>  static void spice_playback_state_free(SpicePlaybackState *st)
> @@ -1582,7 +1582,7 @@ static void spice_playback_state_free(SpicePlaybackState *st)
>  
>  void snd_detach_playback(SpicePlaybackInstance *sin)
>  {
> -    snd_detach_common(&sin->st->worker);
> +    snd_detach_common(&sin->st->channel);
>      spice_playback_state_free(sin->st);
>  }
>  
> @@ -1593,13 +1593,13 @@ static void spice_record_state_free(SpiceRecordState *st)
>  
>  void snd_detach_record(SpiceRecordInstance *sin)
>  {
> -    snd_detach_common(&sin->st->worker);
> +    snd_detach_common(&sin->st->channel);
>      spice_record_state_free(sin->st);
>  }
>  
>  void snd_set_playback_compression(int on)
>  {
> -    SndWorker *now = workers;
> +    SndChannel *now = snd_channels;
>  
>      for (; now; now = now->next) {
>          uint32_t type;
> -- 
> git-series 0.9.1
> _______________________________________________
> Spice-devel mailing list
> Spice-devel@lists.freedesktop.org
> https://lists.freedesktop.org/mailman/listinfo/spice-devel
> 
> On Thu, Dec 01, 2016 at 11:24:26AM +0000, Frediano Ziglio wrote:
> > @@ -1506,73 +1506,73 @@ static void remove_worker(SndWorker *worker)
> >  
> >  void snd_attach_playback(RedsState *reds, SpicePlaybackInstance *sin)
> >  {
> > -    SndWorker *playback_worker;
> > -    RedChannel *channel;
> > +    SndChannel *playback;
> > +    RedChannel *red_channel;
> 
> Here s/channel/red_channel was not really necessary as the other
> variable is named "playback" and not channel, ditto in snd_attach_record
> below.
> 

Should I revert them?

> Acked-by: Christophe Fergeau <cfergeau@redhat.com>
> 
> Christophe

Frediano
On Thu, Dec 01, 2016 at 11:47:15AM -0500, Frediano Ziglio wrote:
> > 
> > On Thu, Dec 01, 2016 at 11:24:26AM +0000, Frediano Ziglio wrote:
> > > @@ -1506,73 +1506,73 @@ static void remove_worker(SndWorker *worker)
> > >  
> > >  void snd_attach_playback(RedsState *reds, SpicePlaybackInstance *sin)
> > >  {
> > > -    SndWorker *playback_worker;
> > > -    RedChannel *channel;
> > > +    SndChannel *playback;
> > > +    RedChannel *red_channel;
> > 
> > Here s/channel/red_channel was not really necessary as the other
> > variable is named "playback" and not channel, ditto in snd_attach_record
> > below.
> > 
> 
> Should I revert them?

I'm fine with both options, so as you prefer :)

Christophe
On Thu, 2016-12-01 at 11:24 +0000, Frediano Ziglio wrote:
> SndWorker has been historically based on RedChannel, initial git
> commit
> has:
> struct SndWorker {
>      Channel base;
>      ...
> };


I'd add a short note to the commit log explaining that this is only
possible since we just renamed SndChannel to SndChannelClient.

On an semi-unrelated note: Should we take this opportunity to use the
full word "Sound" for these types instead of "Snd"? SoundChannel

I find unnecessary shortening to be a bit annoying. It would also avoid
the confusion that could be introduced by bisecting old versions of the
code and not realizing that the name SndChannel refers to completely
different objects in different versions of the repository.


Jonathon



> 
> Signed-off-by: Frediano Ziglio <fziglio@redhat.com>
> ---
>  server/sound.c | 312 +++++++++++++++++++++++++--------------------
> -----
>  1 file changed, 156 insertions(+), 156 deletions(-)
> 
> diff --git a/server/sound.c b/server/sound.c
> index bafdd1e..5b66f3a 100644
> --- a/server/sound.c
> +++ b/server/sound.c
> @@ -79,12 +79,12 @@ typedef int
> (*snd_channel_handle_message_proc)(SndChannelClient *client, size_t 
>  typedef void (*snd_channel_on_message_done_proc)(SndChannelClient
> *client);
>  typedef void (*snd_channel_cleanup_channel_proc)(SndChannelClient
> *client);
>  
> -typedef struct SndWorker SndWorker;
> +typedef struct SndChannel SndChannel;
>  
>  /* Connects an audio client to a Spice client */
>  struct SndChannelClient {
>      RedsStream *stream;
> -    SndWorker *worker;
> +    SndChannel *channel;
>      spice_parse_channel_func_t parser;
>      int refs;
>  
> @@ -145,10 +145,10 @@ typedef struct SpiceVolumeState {
>  } SpiceVolumeState;
>  
>  /* Base class for SpicePlaybackState and SpiceRecordState */
> -struct SndWorker {
> +struct SndChannel {
>      RedChannel *base_channel;
>      SndChannelClient *connection; /* Only one client is supported */
> -    SndWorker *next; /* For the global SndWorker list */
> +    SndChannel *next; /* For the global SndChannel list */
>  
>      int active;
>      SpiceVolumeState volume;
> @@ -156,11 +156,11 @@ struct SndWorker {
>  };
>  
>  struct SpicePlaybackState {
> -    struct SndWorker worker;
> +    struct SndChannel channel;
>  };
>  
>  struct SpiceRecordState {
> -    struct SndWorker worker;
> +    struct SndChannel channel;
>  };
>  
>  typedef struct RecordChannelClient {
> @@ -176,11 +176,11 @@ typedef struct RecordChannelClient {
>  } RecordChannelClient;
>  
>  /* A list of all Spice{Playback,Record}State objects */
> -static SndWorker *workers;
> +static SndChannel *snd_channels;
>  
>  static void snd_receive(SndChannelClient *client);
> -static void snd_playback_start(SndWorker *worker);
> -static void snd_record_start(SndWorker *worker);
> +static void snd_playback_start(SndChannel *channel);
> +static void snd_record_start(SndChannel *channel);
>  
>  static SndChannelClient *snd_channel_ref(SndChannelClient *client)
>  {
> @@ -201,12 +201,12 @@ static SndChannelClient
> *snd_channel_unref(SndChannelClient *client)
>  static RedsState* snd_channel_get_server(SndChannelClient *client)
>  {
>      g_return_val_if_fail(client != NULL, NULL);
> -    return red_channel_get_server(client->worker->base_channel);
> +    return red_channel_get_server(client->channel->base_channel);
>  }
>  
>  static void snd_disconnect_channel(SndChannelClient *client)
>  {
> -    SndWorker *worker;
> +    SndChannel *channel;
>      RedsState *reds;
>      RedChannel *red_channel;
>      uint32_t type;
> @@ -220,17 +220,17 @@ static void
> snd_disconnect_channel(SndChannelClient *client)
>      g_object_get(red_channel, "channel-type", &type, NULL);
>      spice_debug("SndChannelClient=%p rcc=%p type=%d",
>                   client, client->channel_client, type);
> -    worker = client->worker;
> +    channel = client->channel;
>      client->cleanup(client);
> -    red_channel_client_disconnect(worker->connection-
> >channel_client);
> -    worker->connection->channel_client = NULL;
> +    red_channel_client_disconnect(channel->connection-
> >channel_client);
> +    channel->connection->channel_client = NULL;
>      reds_core_watch_remove(reds, client->stream->watch);
>      client->stream->watch = NULL;
>      reds_stream_free(client->stream);
>      client->stream = NULL;
>      spice_marshaller_destroy(client->send_data.marshaller);
>      snd_channel_unref(client);
> -    worker->connection = NULL;
> +    channel->connection = NULL;
>  }
>  
>  static void snd_playback_free_frame(PlaybackChannelClient
> *playback_client, AudioFrame *frame)
> @@ -384,11 +384,11 @@ static int
> snd_record_handle_message(SndChannelClient *client, size_t size, uint
>          return snd_record_handle_write((RecordChannelClient
> *)client, size, message);
>      case SPICE_MSGC_RECORD_MODE: {
>          SpiceMsgcRecordMode *mode = (SpiceMsgcRecordMode *)message;
> -        SndWorker *worker = client->worker;
> +        SndChannel *channel = client->channel;
>          record_client->mode_time = mode->time;
>          if (mode->mode != SPICE_AUDIO_DATA_MODE_RAW) {
> -            if (snd_codec_is_capable(mode->mode, worker->frequency)) 
> {
> -                if (snd_codec_create(&record_client->codec, mode-
> >mode, worker->frequency,
> +            if (snd_codec_is_capable(mode->mode, channel-
> >frequency)) {
> +                if (snd_codec_create(&record_client->codec, mode-
> >mode, channel->frequency,
>                                       SND_CODEC_DECODE) ==
> SND_CODEC_OK) {
>                      record_client->mode = mode->mode;
>                  } else {
> @@ -571,7 +571,7 @@ static int snd_send_volume(SndChannelClient
> *client, uint32_t cap, int msg)
>  {
>      SpiceMsgAudioVolume *vol;
>      uint8_t c;
> -    SpiceVolumeState *st = &client->worker->volume;
> +    SpiceVolumeState *st = &client->channel->volume;
>  
>      if (!red_channel_client_test_remote_cap(client->channel_client,
> cap)) {
>          return TRUE;
> @@ -600,7 +600,7 @@ static int
> snd_playback_send_volume(PlaybackChannelClient *playback_client)
>  static int snd_send_mute(SndChannelClient *client, uint32_t cap, int
> msg)
>  {
>      SpiceMsgAudioMute mute;
> -    SpiceVolumeState *st = &client->worker->volume;
> +    SpiceVolumeState *st = &client->channel->volume;
>  
>      if (!red_channel_client_test_remote_cap(client->channel_client,
> cap)) {
>          return TRUE;
> @@ -645,7 +645,7 @@ static int
> snd_playback_send_start(PlaybackChannelClient *playback_client)
>      }
>  
>      start.channels = SPICE_INTERFACE_PLAYBACK_CHAN;
> -    start.frequency = client->worker->frequency;
> +    start.frequency = client->channel->frequency;
>      spice_assert(SPICE_INTERFACE_PLAYBACK_FMT ==
> SPICE_INTERFACE_AUDIO_FMT_S16);
>      start.format = SPICE_AUDIO_FMT_S16;
>      start.time = reds_get_mm_time();
> @@ -686,7 +686,7 @@ static int
> snd_record_send_start(RecordChannelClient *record_client)
>      }
>  
>      start.channels = SPICE_INTERFACE_RECORD_CHAN;
> -    start.frequency = client->worker->frequency;
> +    start.frequency = client->channel->frequency;
>      spice_assert(SPICE_INTERFACE_RECORD_FMT ==
> SPICE_INTERFACE_AUDIO_FMT_S16);
>      start.format = SPICE_AUDIO_FMT_S16;
>      spice_marshall_msg_record_start(client->send_data.marshaller,
> &start);
> @@ -873,7 +873,7 @@ static void snd_record_send(void* data)
>      }
>  }
>  
> -static SndChannelClient *__new_channel(SndWorker *worker, int size,
> uint32_t channel_id,
> +static SndChannelClient *__new_channel(SndChannel *channel, int
> size, uint32_t channel_id,
>                                   RedClient *red_client,
>                                   RedsStream *stream,
>                                   int migrate,
> @@ -892,7 +892,7 @@ static SndChannelClient *__new_channel(SndWorker
> *worker, int size, uint32_t cha
>  #endif
>      int tos;
>      MainChannelClient *mcc = red_client_get_main(red_client);
> -    RedsState *reds = red_channel_get_server(worker->base_channel);
> +    RedsState *reds = red_channel_get_server(channel->base_channel);
>  
>      spice_assert(stream);
>      if ((flags = fcntl(stream->socket, F_GETFL)) == -1) {
> @@ -934,7 +934,7 @@ static SndChannelClient *__new_channel(SndWorker
> *worker, int size, uint32_t cha
>      client->refs = 1;
>      client->parser = spice_get_client_channel_parser(channel_id,
> NULL);
>      client->stream = stream;
> -    client->worker = worker;
> +    client->channel = channel;
>      client->receive_data.message_start = client->receive_data.buf;
>      client->receive_data.now = client->receive_data.buf;
>      client->receive_data.end = client->receive_data.buf +
> sizeof(client->receive_data.buf);
> @@ -953,7 +953,7 @@ static SndChannelClient *__new_channel(SndWorker
> *worker, int size, uint32_t cha
>      client->cleanup = cleanup;
>  
>      client->channel_client =
> -        dummy_channel_client_create(worker->base_channel,
> red_client,
> +        dummy_channel_client_create(channel->base_channel,
> red_client,
>                                      num_common_caps, common_caps,
> num_caps, caps);
>      if (!client->channel_client) {
>          goto error2;
> @@ -970,19 +970,19 @@ error1:
>  
>  static void snd_disconnect_channel_client(RedChannelClient *rcc)
>  {
> -    SndWorker *worker;
> -    RedChannel *channel = red_channel_client_get_channel(rcc);
> +    SndChannel *channel;
> +    RedChannel *red_channel = red_channel_client_get_channel(rcc);
>      uint32_t type;
>  
> +    spice_assert(red_channel);
> +    channel = (SndChannel *)g_object_get_data(G_OBJECT(red_channel),
> "sound-channel");
>      spice_assert(channel);
> -    worker = (SndWorker *)g_object_get_data(G_OBJECT(channel),
> "sound-worker");
> -    spice_assert(worker);
> -    g_object_get(channel, "channel-type", &type, NULL);
> +    g_object_get(red_channel, "channel-type", &type, NULL);
>  
>      spice_debug("channel-type=%d", type);
> -    if (worker->connection) {
> -        spice_assert(worker->connection->channel_client == rcc);
> -        snd_disconnect_channel(worker->connection);
> +    if (channel->connection) {
> +        spice_assert(channel->connection->channel_client == rcc);
> +        snd_disconnect_channel(channel->connection);
>      }
>  }
>  
> @@ -998,8 +998,8 @@ SPICE_GNUC_VISIBLE void
> spice_server_playback_set_volume(SpicePlaybackInstance *
>                                                    uint8_t nchannels,
>                                                    uint16_t *volume)
>  {
> -    SpiceVolumeState *st = &sin->st->worker.volume;
> -    SndChannelClient *client = sin->st->worker.connection;
> +    SpiceVolumeState *st = &sin->st->channel.volume;
> +    SndChannelClient *client = sin->st->channel.connection;
>      PlaybackChannelClient *playback_client =
> SPICE_CONTAINEROF(client, PlaybackChannelClient, base);
>  
>      st->volume_nchannels = nchannels;
> @@ -1014,8 +1014,8 @@ SPICE_GNUC_VISIBLE void
> spice_server_playback_set_volume(SpicePlaybackInstance *
>  
>  SPICE_GNUC_VISIBLE void
> spice_server_playback_set_mute(SpicePlaybackInstance *sin, uint8_t
> mute)
>  {
> -    SpiceVolumeState *st = &sin->st->worker.volume;
> -    SndChannelClient *client = sin->st->worker.connection;
> +    SpiceVolumeState *st = &sin->st->channel.volume;
> +    SndChannelClient *client = sin->st->channel.connection;
>      PlaybackChannelClient *playback_client =
> SPICE_CONTAINEROF(client, PlaybackChannelClient, base);
>  
>      st->mute = mute;
> @@ -1026,11 +1026,11 @@ SPICE_GNUC_VISIBLE void
> spice_server_playback_set_mute(SpicePlaybackInstance *si
>      snd_playback_send_mute(playback_client);
>  }
>  
> -static void snd_playback_start(SndWorker *worker)
> +static void snd_playback_start(SndChannel *channel)
>  {
> -    SndChannelClient *client = worker->connection;
> +    SndChannelClient *client = channel->connection;
>  
> -    worker->active = 1;
> +    channel->active = 1;
>      if (!client)
>          return;
>      spice_assert(!client->active);
> @@ -1046,15 +1046,15 @@ static void snd_playback_start(SndWorker
> *worker)
>  
>  SPICE_GNUC_VISIBLE void
> spice_server_playback_start(SpicePlaybackInstance *sin)
>  {
> -    return snd_playback_start(&sin->st->worker);
> +    return snd_playback_start(&sin->st->channel);
>  }
>  
>  SPICE_GNUC_VISIBLE void
> spice_server_playback_stop(SpicePlaybackInstance *sin)
>  {
> -    SndChannelClient *client = sin->st->worker.connection;
> +    SndChannelClient *client = sin->st->channel.connection;
>      PlaybackChannelClient *playback_client =
> SPICE_CONTAINEROF(client, PlaybackChannelClient, base);
>  
> -    sin->st->worker.active = 0;
> +    sin->st->channel.active = 0;
>      if (!client)
>          return;
>      spice_assert(playback_client->base.active);
> @@ -1079,7 +1079,7 @@ SPICE_GNUC_VISIBLE void
> spice_server_playback_stop(SpicePlaybackInstance *sin)
>  SPICE_GNUC_VISIBLE void
> spice_server_playback_get_buffer(SpicePlaybackInstance *sin,
>                                                           uint32_t
> **frame, uint32_t *num_samples)
>  {
> -    SndChannelClient *client = sin->st->worker.connection;
> +    SndChannelClient *client = sin->st->channel.connection;
>      PlaybackChannelClient *playback_client =
> SPICE_CONTAINEROF(client, PlaybackChannelClient, base);
>  
>      if (!client || !playback_client->free_frames) {
> @@ -1104,7 +1104,7 @@ SPICE_GNUC_VISIBLE void
> spice_server_playback_put_samples(SpicePlaybackInstance 
>      playback_client = frame->client;
>      spice_assert(playback_client);
>      if (!snd_channel_unref(&playback_client->base) ||
> -        sin->st->worker.connection != &playback_client->base) {
> +        sin->st->channel.connection != &playback_client->base) {
>          /* lost last reference, client has been destroyed previously
> */
>          spice_info("audio samples belong to a disconnected client");
>          return;
> @@ -1122,7 +1122,7 @@ SPICE_GNUC_VISIBLE void
> spice_server_playback_put_samples(SpicePlaybackInstance 
>  
>  void snd_set_playback_latency(RedClient *client, uint32_t latency)
>  {
> -    SndWorker *now = workers;
> +    SndChannel *now = snd_channels;
>  
>      for (; now; now = now->next) {
>          uint32_t type;
> @@ -1159,18 +1159,18 @@ static int snd_desired_audio_mode(int
> playback_compression, int frequency,
>      return SPICE_AUDIO_DATA_MODE_RAW;
>  }
>  
> -static void on_new_playback_channel(SndWorker *worker,
> SndChannelClient *snd_channel)
> +static void on_new_playback_channel(SndChannel *channel,
> SndChannelClient *snd_channel)
>  {
> -    RedsState *reds = red_channel_get_server(worker->base_channel);
> +    RedsState *reds = red_channel_get_server(channel->base_channel);
>  
>      spice_assert(snd_channel);
>  
> -    worker->connection = snd_channel;
> +    channel->connection = snd_channel;
>      snd_set_command(snd_channel, SND_PLAYBACK_MODE_MASK);
>      if (snd_channel->active) {
>          snd_set_command(snd_channel, SND_CTRL_MASK);
>      }
> -    if (worker->volume.volume_nchannels) {
> +    if (channel->volume.volume_nchannels) {
>          snd_set_command(snd_channel, SND_VOLUME_MASK);
>      }
>      if (snd_channel->active) {
> @@ -1189,16 +1189,16 @@ static void
> snd_playback_cleanup(SndChannelClient *client)
>      snd_codec_destroy(&playback_client->codec);
>  }
>  
> -static void snd_set_playback_peer(RedChannel *channel, RedClient
> *client, RedsStream *stream,
> +static void snd_set_playback_peer(RedChannel *red_channel, RedClient
> *client, RedsStream *stream,
>                                    int migration, int
> num_common_caps, uint32_t *common_caps,
>                                    int num_caps, uint32_t *caps)
>  {
> -    SndWorker *worker = g_object_get_data(G_OBJECT(channel), "sound-
> worker");
> +    SndChannel *channel = g_object_get_data(G_OBJECT(red_channel),
> "sound-channel");
>      PlaybackChannelClient *playback_client;
>  
> -    snd_disconnect_channel(worker->connection);
> +    snd_disconnect_channel(channel->connection);
>  
> -    if (!(playback_client = (PlaybackChannelClient
> *)__new_channel(worker,
> +    if (!(playback_client = (PlaybackChannelClient
> *)__new_channel(channel,
>                                                                sizeof
> (*playback_client),
>                                                                SPICE_
> CHANNEL_PLAYBACK,
>                                                                client
> ,
> @@ -1221,12 +1221,12 @@ static void snd_set_playback_peer(RedChannel
> *channel, RedClient *client, RedsSt
>      int client_can_opus =
> red_channel_client_test_remote_cap(playback_client-
> >base.channel_client,
>                                            SPICE_PLAYBACK_CAP_OPUS);
>      int playback_compression =
> -        reds_config_get_playback_compression(red_channel_get_server(
> channel));
> -    int desired_mode = snd_desired_audio_mode(playback_compression,
> worker->frequency,
> +        reds_config_get_playback_compression(red_channel_get_server(
> red_channel));
> +    int desired_mode = snd_desired_audio_mode(playback_compression,
> channel->frequency,
>                                                client_can_celt,
> client_can_opus);
>      playback_client->mode = SPICE_AUDIO_DATA_MODE_RAW;
>      if (desired_mode != SPICE_AUDIO_DATA_MODE_RAW) {
> -        if (snd_codec_create(&playback_client->codec, desired_mode,
> worker->frequency,
> +        if (snd_codec_create(&playback_client->codec, desired_mode,
> channel->frequency,
>                               SND_CODEC_ENCODE) == SND_CODEC_OK) {
>              playback_client->mode = desired_mode;
>          } else {
> @@ -1235,29 +1235,29 @@ static void snd_set_playback_peer(RedChannel
> *channel, RedClient *client, RedsSt
>      }
>  
>      if (!red_client_during_migrate_at_target(client)) {
> -        on_new_playback_channel(worker, &playback_client->base);
> +        on_new_playback_channel(channel, &playback_client->base);
>      }
>  
> -    if (worker->active) {
> -        snd_playback_start(worker);
> +    if (channel->active) {
> +        snd_playback_start(channel);
>      }
> -    snd_playback_send(worker->connection);
> +    snd_playback_send(channel->connection);
>  }
>  
>  static void snd_record_migrate_channel_client(RedChannelClient *rcc)
>  {
> -    SndWorker *worker;
> -    RedChannel *channel = red_channel_client_get_channel(rcc);
> +    SndChannel *channel;
> +    RedChannel *red_channel = red_channel_client_get_channel(rcc);
>  
>      spice_debug(NULL);
> +    spice_assert(red_channel);
> +    channel = (SndChannel *)g_object_get_data(G_OBJECT(red_channel),
> "sound-channel");
>      spice_assert(channel);
> -    worker = (SndWorker *)g_object_get_data(G_OBJECT(channel),
> "sound-worker");
> -    spice_assert(worker);
>  
> -    if (worker->connection) {
> -        spice_assert(worker->connection->channel_client == rcc);
> -        snd_set_command(worker->connection, SND_MIGRATE_MASK);
> -        snd_record_send(worker->connection);
> +    if (channel->connection) {
> +        spice_assert(channel->connection->channel_client == rcc);
> +        snd_set_command(channel->connection, SND_MIGRATE_MASK);
> +        snd_record_send(channel->connection);
>      }
>  }
>  
> @@ -1265,8 +1265,8 @@ SPICE_GNUC_VISIBLE void
> spice_server_record_set_volume(SpiceRecordInstance *sin,
>                                                  uint8_t nchannels,
>                                                  uint16_t *volume)
>  {
> -    SpiceVolumeState *st = &sin->st->worker.volume;
> -    SndChannelClient *client = sin->st->worker.connection;
> +    SpiceVolumeState *st = &sin->st->channel.volume;
> +    SndChannelClient *client = sin->st->channel.connection;
>      RecordChannelClient *record_client = SPICE_CONTAINEROF(client,
> RecordChannelClient, base);
>  
>      st->volume_nchannels = nchannels;
> @@ -1281,8 +1281,8 @@ SPICE_GNUC_VISIBLE void
> spice_server_record_set_volume(SpiceRecordInstance *sin,
>  
>  SPICE_GNUC_VISIBLE void
> spice_server_record_set_mute(SpiceRecordInstance *sin, uint8_t mute)
>  {
> -    SpiceVolumeState *st = &sin->st->worker.volume;
> -    SndChannelClient *client = sin->st->worker.connection;
> +    SpiceVolumeState *st = &sin->st->channel.volume;
> +    SndChannelClient *client = sin->st->channel.connection;
>      RecordChannelClient *record_client = SPICE_CONTAINEROF(client,
> RecordChannelClient, base);
>  
>      st->mute = mute;
> @@ -1293,12 +1293,12 @@ SPICE_GNUC_VISIBLE void
> spice_server_record_set_mute(SpiceRecordInstance *sin, u
>      snd_record_send_mute(record_client);
>  }
>  
> -static void snd_record_start(SndWorker *worker)
> +static void snd_record_start(SndChannel *channel)
>  {
> -    SndChannelClient *client = worker->connection;
> +    SndChannelClient *client = channel->connection;
>      RecordChannelClient *record_client = SPICE_CONTAINEROF(client,
> RecordChannelClient, base);
>  
> -    worker->active = 1;
> +    channel->active = 1;
>      if (!client)
>          return;
>      spice_assert(!client->active);
> @@ -1315,15 +1315,15 @@ static void snd_record_start(SndWorker
> *worker)
>  
>  SPICE_GNUC_VISIBLE void
> spice_server_record_start(SpiceRecordInstance *sin)
>  {
> -    snd_record_start(&sin->st->worker);
> +    snd_record_start(&sin->st->channel);
>  }
>  
>  SPICE_GNUC_VISIBLE void spice_server_record_stop(SpiceRecordInstance
> *sin)
>  {
> -    SndChannelClient *client = sin->st->worker.connection;
> +    SndChannelClient *client = sin->st->channel.connection;
>      RecordChannelClient *record_client = SPICE_CONTAINEROF(client,
> RecordChannelClient, base);
>  
> -    sin->st->worker.active = 0;
> +    sin->st->channel.active = 0;
>      if (!client)
>          return;
>      spice_assert(record_client->base.active);
> @@ -1339,7 +1339,7 @@ SPICE_GNUC_VISIBLE void
> spice_server_record_stop(SpiceRecordInstance *sin)
>  SPICE_GNUC_VISIBLE uint32_t
> spice_server_record_get_samples(SpiceRecordInstance *sin,
>                                                              uint32_t
> *samples, uint32_t bufsize)
>  {
> -    SndChannelClient *client = sin->st->worker.connection;
> +    SndChannelClient *client = sin->st->channel.connection;
>      RecordChannelClient *record_client = SPICE_CONTAINEROF(client,
> RecordChannelClient, base);
>      uint32_t read_pos;
>      uint32_t now;
> @@ -1356,9 +1356,9 @@ SPICE_GNUC_VISIBLE uint32_t
> spice_server_record_get_samples(SpiceRecordInstance 
>      len = MIN(record_client->write_pos - record_client->read_pos,
> bufsize);
>  
>      if (len < bufsize) {
> -        SndWorker *worker = record_client->base.worker;
> +        SndChannel *channel = record_client->base.channel;
>          snd_receive(&record_client->base);
> -        if (!worker->connection) {
> +        if (!channel->connection) {
>              return 0;
>          }
>          len = MIN(record_client->write_pos - record_client-
> >read_pos, bufsize);
> @@ -1387,41 +1387,41 @@ static uint32_t
> snd_get_best_rate(SndChannelClient *client, uint32_t cap_opus)
>      return SND_CODEC_CELT_PLAYBACK_FREQ;
>  }
>  
> -static void snd_set_rate(SndWorker *worker, uint32_t frequency,
> uint32_t cap_opus)
> +static void snd_set_rate(SndChannel *channel, uint32_t frequency,
> uint32_t cap_opus)
>  {
> -    RedChannel *channel = worker->base_channel;
> -    worker->frequency = frequency;
> -    if (channel && snd_codec_is_capable(SPICE_AUDIO_DATA_MODE_OPUS,
> frequency)) {
> -        red_channel_set_cap(channel, cap_opus);
> +    RedChannel *red_channel = channel->base_channel;
> +    channel->frequency = frequency;
> +    if (red_channel &&
> snd_codec_is_capable(SPICE_AUDIO_DATA_MODE_OPUS, frequency)) {
> +        red_channel_set_cap(red_channel, cap_opus);
>      }
>  }
>  
>  SPICE_GNUC_VISIBLE uint32_t
> spice_server_get_best_playback_rate(SpicePlaybackInstance *sin)
>  {
> -    return snd_get_best_rate(sin ? sin->st->worker.connection :
> NULL, SPICE_PLAYBACK_CAP_OPUS);
> +    return snd_get_best_rate(sin ? sin->st->channel.connection :
> NULL, SPICE_PLAYBACK_CAP_OPUS);
>  }
>  
>  SPICE_GNUC_VISIBLE void
> spice_server_set_playback_rate(SpicePlaybackInstance *sin, uint32_t
> frequency)
>  {
> -    snd_set_rate(&sin->st->worker, frequency,
> SPICE_PLAYBACK_CAP_OPUS);
> +    snd_set_rate(&sin->st->channel, frequency,
> SPICE_PLAYBACK_CAP_OPUS);
>  }
>  
>  SPICE_GNUC_VISIBLE uint32_t
> spice_server_get_best_record_rate(SpiceRecordInstance *sin)
>  {
> -    return snd_get_best_rate(sin ? sin->st->worker.connection :
> NULL, SPICE_RECORD_CAP_OPUS);
> +    return snd_get_best_rate(sin ? sin->st->channel.connection :
> NULL, SPICE_RECORD_CAP_OPUS);
>  }
>  
>  SPICE_GNUC_VISIBLE void
> spice_server_set_record_rate(SpiceRecordInstance *sin, uint32_t
> frequency)
>  {
> -    snd_set_rate(&sin->st->worker, frequency,
> SPICE_RECORD_CAP_OPUS);
> +    snd_set_rate(&sin->st->channel, frequency,
> SPICE_RECORD_CAP_OPUS);
>  }
>  
> -static void on_new_record_channel(SndWorker *worker,
> SndChannelClient *snd_channel)
> +static void on_new_record_channel(SndChannel *channel,
> SndChannelClient *snd_channel)
>  {
>      spice_assert(snd_channel);
>  
> -    worker->connection = snd_channel ;
> -    if (worker->volume.volume_nchannels) {
> +    channel->connection = snd_channel ;
> +    if (channel->volume.volume_nchannels) {
>          snd_set_command(snd_channel, SND_VOLUME_MASK);
>      }
>      if (snd_channel->active) {
> @@ -1435,16 +1435,16 @@ static void
> snd_record_cleanup(SndChannelClient *client)
>      snd_codec_destroy(&record_client->codec);
>  }
>  
> -static void snd_set_record_peer(RedChannel *channel, RedClient
> *client, RedsStream *stream,
> +static void snd_set_record_peer(RedChannel *red_channel, RedClient
> *client, RedsStream *stream,
>                                  int migration, int num_common_caps,
> uint32_t *common_caps,
>                                  int num_caps, uint32_t *caps)
>  {
> -    SndWorker *worker = g_object_get_data(G_OBJECT(channel), "sound-
> worker");
> +    SndChannel *channel = g_object_get_data(G_OBJECT(red_channel),
> "sound-channel");
>      RecordChannelClient *record_client;
>  
> -    snd_disconnect_channel(worker->connection);
> +    snd_disconnect_channel(channel->connection);
>  
> -    if (!(record_client = (RecordChannelClient
> *)__new_channel(worker,
> +    if (!(record_client = (RecordChannelClient
> *)__new_channel(channel,
>                                                            sizeof(*re
> cord_client),
>                                                            SPICE_CHAN
> NEL_RECORD,
>                                                            client,
> @@ -1461,42 +1461,42 @@ static void snd_set_record_peer(RedChannel
> *channel, RedClient *client, RedsStre
>  
>      record_client->mode = SPICE_AUDIO_DATA_MODE_RAW;
>  
> -    on_new_record_channel(worker, &record_client->base);
> -    if (worker->active) {
> -        snd_record_start(worker);
> +    on_new_record_channel(channel, &record_client->base);
> +    if (channel->active) {
> +        snd_record_start(channel);
>      }
> -    snd_record_send(worker->connection);
> +    snd_record_send(channel->connection);
>  }
>  
>  static void snd_playback_migrate_channel_client(RedChannelClient
> *rcc)
>  {
> -    SndWorker *worker;
> -    RedChannel *channel = red_channel_client_get_channel(rcc);
> +    SndChannel *channel;
> +    RedChannel *red_channel = red_channel_client_get_channel(rcc);
>  
> +    spice_assert(red_channel);
> +    channel = (SndChannel *)g_object_get_data(G_OBJECT(red_channel),
> "sound-channel");
>      spice_assert(channel);
> -    worker = (SndWorker *)g_object_get_data(G_OBJECT(channel),
> "sound-worker");
> -    spice_assert(worker);
>      spice_debug(NULL);
>  
> -    if (worker->connection) {
> -        spice_assert(worker->connection->channel_client == rcc);
> -        snd_set_command(worker->connection, SND_MIGRATE_MASK);
> -        snd_playback_send(worker->connection);
> +    if (channel->connection) {
> +        spice_assert(channel->connection->channel_client == rcc);
> +        snd_set_command(channel->connection, SND_MIGRATE_MASK);
> +        snd_playback_send(channel->connection);
>      }
>  }
>  
> -static void add_worker(SndWorker *worker)
> +static void add_channel(SndChannel *channel)
>  {
> -    worker->next = workers;
> -    workers = worker;
> +    channel->next = snd_channels;
> +    snd_channels = channel;
>  }
>  
> -static void remove_worker(SndWorker *worker)
> +static void remove_channel(SndChannel *channel)
>  {
> -    SndWorker **now = &workers;
> +    SndChannel **now = &snd_channels;
>      while (*now) {
> -        if (*now == worker) {
> -            *now = worker->next;
> +        if (*now == channel) {
> +            *now = channel->next;
>              return;
>          }
>          now = &(*now)->next;
> @@ -1506,73 +1506,73 @@ static void remove_worker(SndWorker *worker)
>  
>  void snd_attach_playback(RedsState *reds, SpicePlaybackInstance
> *sin)
>  {
> -    SndWorker *playback_worker;
> -    RedChannel *channel;
> +    SndChannel *playback;
> +    RedChannel *red_channel;
>      ClientCbs client_cbs = { NULL, };
>  
>      sin->st = spice_new0(SpicePlaybackState, 1);
> -    playback_worker = &sin->st->worker;
> -    playback_worker->frequency = SND_CODEC_CELT_PLAYBACK_FREQ; /*
> Default to the legacy rate */
> +    playback = &sin->st->channel;
> +    playback->frequency = SND_CODEC_CELT_PLAYBACK_FREQ; /* Default
> to the legacy rate */
>  
> -    // TODO: Make RedChannel base of worker? instead of assigning it
> to channel->data
> -    channel = dummy_channel_new(reds, SPICE_CHANNEL_PLAYBACK, 0);
> +    // TODO: Make RedChannel base of channel? instead of assigning
> it to channel->data
> +    red_channel = dummy_channel_new(reds, SPICE_CHANNEL_PLAYBACK,
> 0);
>  
> -    g_object_set_data(G_OBJECT(channel), "sound-worker",
> playback_worker);
> +    g_object_set_data(G_OBJECT(red_channel), "sound-channel",
> playback);
>      client_cbs.connect = snd_set_playback_peer;
>      client_cbs.disconnect = snd_disconnect_channel_client;
>      client_cbs.migrate = snd_playback_migrate_channel_client;
> -    red_channel_register_client_cbs(channel, &client_cbs,
> playback_worker);
> +    red_channel_register_client_cbs(red_channel, &client_cbs,
> playback);
>  
>      if (snd_codec_is_capable(SPICE_AUDIO_DATA_MODE_CELT_0_5_1,
> SND_CODEC_ANY_FREQUENCY))
> -        red_channel_set_cap(channel, SPICE_PLAYBACK_CAP_CELT_0_5_1);
> +        red_channel_set_cap(red_channel,
> SPICE_PLAYBACK_CAP_CELT_0_5_1);
>  
> -    red_channel_set_cap(channel, SPICE_PLAYBACK_CAP_VOLUME);
> +    red_channel_set_cap(red_channel, SPICE_PLAYBACK_CAP_VOLUME);
>  
> -    playback_worker->base_channel = channel;
> -    add_worker(playback_worker);
> -    reds_register_channel(reds, channel);
> +    playback->base_channel = red_channel;
> +    add_channel(playback);
> +    reds_register_channel(reds, red_channel);
>  }
>  
>  void snd_attach_record(RedsState *reds, SpiceRecordInstance *sin)
>  {
> -    SndWorker *record_worker;
> -    RedChannel *channel;
> +    SndChannel *record;
> +    RedChannel *red_channel;
>      ClientCbs client_cbs = { NULL, };
>  
>      sin->st = spice_new0(SpiceRecordState, 1);
> -    record_worker = &sin->st->worker;
> -    record_worker->frequency = SND_CODEC_CELT_PLAYBACK_FREQ; /*
> Default to the legacy rate */
> +    record = &sin->st->channel;
> +    record->frequency = SND_CODEC_CELT_PLAYBACK_FREQ; /* Default to
> the legacy rate */
>  
> -    // TODO: Make RedChannel base of worker? instead of assigning it
> to channel->data
> -    channel = dummy_channel_new(reds, SPICE_CHANNEL_RECORD, 0);
> +    // TODO: Make RedChannel base of channel? instead of assigning
> it to channel->data
> +    red_channel = dummy_channel_new(reds, SPICE_CHANNEL_RECORD, 0);
>  
> -    g_object_set_data(G_OBJECT(channel), "sound-worker",
> record_worker);
> +    g_object_set_data(G_OBJECT(red_channel), "sound-channel",
> record);
>      client_cbs.connect = snd_set_record_peer;
>      client_cbs.disconnect = snd_disconnect_channel_client;
>      client_cbs.migrate = snd_record_migrate_channel_client;
> -    red_channel_register_client_cbs(channel, &client_cbs,
> record_worker);
> +    red_channel_register_client_cbs(red_channel, &client_cbs,
> record);
>      if (snd_codec_is_capable(SPICE_AUDIO_DATA_MODE_CELT_0_5_1,
> SND_CODEC_ANY_FREQUENCY))
> -        red_channel_set_cap(channel, SPICE_RECORD_CAP_CELT_0_5_1);
> -    red_channel_set_cap(channel, SPICE_RECORD_CAP_VOLUME);
> +        red_channel_set_cap(red_channel,
> SPICE_RECORD_CAP_CELT_0_5_1);
> +    red_channel_set_cap(red_channel, SPICE_RECORD_CAP_VOLUME);
>  
> -    record_worker->base_channel = channel;
> -    add_worker(record_worker);
> -    reds_register_channel(reds, channel);
> +    record->base_channel = red_channel;
> +    add_channel(record);
> +    reds_register_channel(reds, red_channel);
>  }
>  
> -static void snd_detach_common(SndWorker *worker)
> +static void snd_detach_common(SndChannel *channel)
>  {
> -    if (!worker) {
> +    if (!channel) {
>          return;
>      }
> -    RedsState *reds = red_channel_get_server(worker->base_channel);
> +    RedsState *reds = red_channel_get_server(channel->base_channel);
>  
> -    remove_worker(worker);
> -    snd_disconnect_channel(worker->connection);
> -    reds_unregister_channel(reds, worker->base_channel);
> -    red_channel_destroy(worker->base_channel);
> -    free(worker->volume.volume);
> -    worker->volume.volume = NULL;
> +    remove_channel(channel);
> +    snd_disconnect_channel(channel->connection);
> +    reds_unregister_channel(reds, channel->base_channel);
> +    red_channel_destroy(channel->base_channel);
> +    free(channel->volume.volume);
> +    channel->volume.volume = NULL;
>  }
>  
>  static void spice_playback_state_free(SpicePlaybackState *st)
> @@ -1582,7 +1582,7 @@ static void
> spice_playback_state_free(SpicePlaybackState *st)
>  
>  void snd_detach_playback(SpicePlaybackInstance *sin)
>  {
> -    snd_detach_common(&sin->st->worker);
> +    snd_detach_common(&sin->st->channel);
>      spice_playback_state_free(sin->st);
>  }
>  
> @@ -1593,13 +1593,13 @@ static void
> spice_record_state_free(SpiceRecordState *st)
>  
>  void snd_detach_record(SpiceRecordInstance *sin)
>  {
> -    snd_detach_common(&sin->st->worker);
> +    snd_detach_common(&sin->st->channel);
>      spice_record_state_free(sin->st);
>  }
>  
>  void snd_set_playback_compression(int on)
>  {
> -    SndWorker *now = workers;
> +    SndChannel *now = snd_channels;
>  
>      for (; now; now = now->next) {
>          uint32_t type;
> 
> On Thu, 2016-12-01 at 11:24 +0000, Frediano Ziglio wrote:
> > SndWorker has been historically based on RedChannel, initial git
> > commit
> > has:
> > struct SndWorker {
> >      Channel base;
> >      ...
> > };
> 
> 
> I'd add a short note to the commit log explaining that this is only
> possible since we just renamed SndChannel to SndChannelClient.
> 
> On an semi-unrelated note: Should we take this opportunity to use the
> full word "Sound" for these types instead of "Snd"? SoundChannel
> 
> I find unnecessary shortening to be a bit annoying. It would also avoid
> the confusion that could be introduced by bisecting old versions of the
> code and not realizing that the name SndChannel refers to completely
> different objects in different versions of the repository.
> 
> 
> Jonathon
> 
>

It's already merged.
About Snd -> Sound can be a follow up but I don't feel very confusing.

Frediano
 
> 
> > 
> > Signed-off-by: Frediano Ziglio <fziglio@redhat.com>
> > ---
> >  server/sound.c | 312 +++++++++++++++++++++++++--------------------
> > -----
> >  1 file changed, 156 insertions(+), 156 deletions(-)
> > 
> > diff --git a/server/sound.c b/server/sound.c
> > index bafdd1e..5b66f3a 100644
> > --- a/server/sound.c
> > +++ b/server/sound.c
> > @@ -79,12 +79,12 @@ typedef int
> > (*snd_channel_handle_message_proc)(SndChannelClient *client, size_t
> >  typedef void (*snd_channel_on_message_done_proc)(SndChannelClient
> > *client);
> >  typedef void (*snd_channel_cleanup_channel_proc)(SndChannelClient
> > *client);
> >  
> > -typedef struct SndWorker SndWorker;
> > +typedef struct SndChannel SndChannel;
> >  
> >  /* Connects an audio client to a Spice client */
> >  struct SndChannelClient {
> >      RedsStream *stream;
> > -    SndWorker *worker;
> > +    SndChannel *channel;
> >      spice_parse_channel_func_t parser;
> >      int refs;
> >  
> > @@ -145,10 +145,10 @@ typedef struct SpiceVolumeState {
> >  } SpiceVolumeState;
> >  
> >  /* Base class for SpicePlaybackState and SpiceRecordState */
> > -struct SndWorker {
> > +struct SndChannel {
> >      RedChannel *base_channel;
> >      SndChannelClient *connection; /* Only one client is supported */
> > -    SndWorker *next; /* For the global SndWorker list */
> > +    SndChannel *next; /* For the global SndChannel list */
> >  
> >      int active;
> >      SpiceVolumeState volume;
> > @@ -156,11 +156,11 @@ struct SndWorker {
> >  };
> >  
> >  struct SpicePlaybackState {
> > -    struct SndWorker worker;
> > +    struct SndChannel channel;
> >  };
> >  
> >  struct SpiceRecordState {
> > -    struct SndWorker worker;
> > +    struct SndChannel channel;
> >  };
> >  
> >  typedef struct RecordChannelClient {
> > @@ -176,11 +176,11 @@ typedef struct RecordChannelClient {
> >  } RecordChannelClient;
> >  
> >  /* A list of all Spice{Playback,Record}State objects */
> > -static SndWorker *workers;
> > +static SndChannel *snd_channels;
> >  
> >  static void snd_receive(SndChannelClient *client);
> > -static void snd_playback_start(SndWorker *worker);
> > -static void snd_record_start(SndWorker *worker);
> > +static void snd_playback_start(SndChannel *channel);
> > +static void snd_record_start(SndChannel *channel);
> >  
> >  static SndChannelClient *snd_channel_ref(SndChannelClient *client)
> >  {
> > @@ -201,12 +201,12 @@ static SndChannelClient
> > *snd_channel_unref(SndChannelClient *client)
> >  static RedsState* snd_channel_get_server(SndChannelClient *client)
> >  {
> >      g_return_val_if_fail(client != NULL, NULL);
> > -    return red_channel_get_server(client->worker->base_channel);
> > +    return red_channel_get_server(client->channel->base_channel);
> >  }
> >  
> >  static void snd_disconnect_channel(SndChannelClient *client)
> >  {
> > -    SndWorker *worker;
> > +    SndChannel *channel;
> >      RedsState *reds;
> >      RedChannel *red_channel;
> >      uint32_t type;
> > @@ -220,17 +220,17 @@ static void
> > snd_disconnect_channel(SndChannelClient *client)
> >      g_object_get(red_channel, "channel-type", &type, NULL);
> >      spice_debug("SndChannelClient=%p rcc=%p type=%d",
> >                   client, client->channel_client, type);
> > -    worker = client->worker;
> > +    channel = client->channel;
> >      client->cleanup(client);
> > -    red_channel_client_disconnect(worker->connection-
> > >channel_client);
> > -    worker->connection->channel_client = NULL;
> > +    red_channel_client_disconnect(channel->connection-
> > >channel_client);
> > +    channel->connection->channel_client = NULL;
> >      reds_core_watch_remove(reds, client->stream->watch);
> >      client->stream->watch = NULL;
> >      reds_stream_free(client->stream);
> >      client->stream = NULL;
> >      spice_marshaller_destroy(client->send_data.marshaller);
> >      snd_channel_unref(client);
> > -    worker->connection = NULL;
> > +    channel->connection = NULL;
> >  }
> >  
> >  static void snd_playback_free_frame(PlaybackChannelClient
> > *playback_client, AudioFrame *frame)
> > @@ -384,11 +384,11 @@ static int
> > snd_record_handle_message(SndChannelClient *client, size_t size, uint
> >          return snd_record_handle_write((RecordChannelClient
> > *)client, size, message);
> >      case SPICE_MSGC_RECORD_MODE: {
> >          SpiceMsgcRecordMode *mode = (SpiceMsgcRecordMode *)message;
> > -        SndWorker *worker = client->worker;
> > +        SndChannel *channel = client->channel;
> >          record_client->mode_time = mode->time;
> >          if (mode->mode != SPICE_AUDIO_DATA_MODE_RAW) {
> > -            if (snd_codec_is_capable(mode->mode, worker->frequency))
> > {
> > -                if (snd_codec_create(&record_client->codec, mode-
> > >mode, worker->frequency,
> > +            if (snd_codec_is_capable(mode->mode, channel-
> > >frequency)) {
> > +                if (snd_codec_create(&record_client->codec, mode-
> > >mode, channel->frequency,
> >                                       SND_CODEC_DECODE) ==
> > SND_CODEC_OK) {
> >                      record_client->mode = mode->mode;
> >                  } else {
> > @@ -571,7 +571,7 @@ static int snd_send_volume(SndChannelClient
> > *client, uint32_t cap, int msg)
> >  {
> >      SpiceMsgAudioVolume *vol;
> >      uint8_t c;
> > -    SpiceVolumeState *st = &client->worker->volume;
> > +    SpiceVolumeState *st = &client->channel->volume;
> >  
> >      if (!red_channel_client_test_remote_cap(client->channel_client,
> > cap)) {
> >          return TRUE;
> > @@ -600,7 +600,7 @@ static int
> > snd_playback_send_volume(PlaybackChannelClient *playback_client)
> >  static int snd_send_mute(SndChannelClient *client, uint32_t cap, int
> > msg)
> >  {
> >      SpiceMsgAudioMute mute;
> > -    SpiceVolumeState *st = &client->worker->volume;
> > +    SpiceVolumeState *st = &client->channel->volume;
> >  
> >      if (!red_channel_client_test_remote_cap(client->channel_client,
> > cap)) {
> >          return TRUE;
> > @@ -645,7 +645,7 @@ static int
> > snd_playback_send_start(PlaybackChannelClient *playback_client)
> >      }
> >  
> >      start.channels = SPICE_INTERFACE_PLAYBACK_CHAN;
> > -    start.frequency = client->worker->frequency;
> > +    start.frequency = client->channel->frequency;
> >      spice_assert(SPICE_INTERFACE_PLAYBACK_FMT ==
> > SPICE_INTERFACE_AUDIO_FMT_S16);
> >      start.format = SPICE_AUDIO_FMT_S16;
> >      start.time = reds_get_mm_time();
> > @@ -686,7 +686,7 @@ static int
> > snd_record_send_start(RecordChannelClient *record_client)
> >      }
> >  
> >      start.channels = SPICE_INTERFACE_RECORD_CHAN;
> > -    start.frequency = client->worker->frequency;
> > +    start.frequency = client->channel->frequency;
> >      spice_assert(SPICE_INTERFACE_RECORD_FMT ==
> > SPICE_INTERFACE_AUDIO_FMT_S16);
> >      start.format = SPICE_AUDIO_FMT_S16;
> >      spice_marshall_msg_record_start(client->send_data.marshaller,
> > &start);
> > @@ -873,7 +873,7 @@ static void snd_record_send(void* data)
> >      }
> >  }
> >  
> > -static SndChannelClient *__new_channel(SndWorker *worker, int size,
> > uint32_t channel_id,
> > +static SndChannelClient *__new_channel(SndChannel *channel, int
> > size, uint32_t channel_id,
> >                                   RedClient *red_client,
> >                                   RedsStream *stream,
> >                                   int migrate,
> > @@ -892,7 +892,7 @@ static SndChannelClient *__new_channel(SndWorker
> > *worker, int size, uint32_t cha
> >  #endif
> >      int tos;
> >      MainChannelClient *mcc = red_client_get_main(red_client);
> > -    RedsState *reds = red_channel_get_server(worker->base_channel);
> > +    RedsState *reds = red_channel_get_server(channel->base_channel);
> >  
> >      spice_assert(stream);
> >      if ((flags = fcntl(stream->socket, F_GETFL)) == -1) {
> > @@ -934,7 +934,7 @@ static SndChannelClient *__new_channel(SndWorker
> > *worker, int size, uint32_t cha
> >      client->refs = 1;
> >      client->parser = spice_get_client_channel_parser(channel_id,
> > NULL);
> >      client->stream = stream;
> > -    client->worker = worker;
> > +    client->channel = channel;
> >      client->receive_data.message_start = client->receive_data.buf;
> >      client->receive_data.now = client->receive_data.buf;
> >      client->receive_data.end = client->receive_data.buf +
> > sizeof(client->receive_data.buf);
> > @@ -953,7 +953,7 @@ static SndChannelClient *__new_channel(SndWorker
> > *worker, int size, uint32_t cha
> >      client->cleanup = cleanup;
> >  
> >      client->channel_client =
> > -        dummy_channel_client_create(worker->base_channel,
> > red_client,
> > +        dummy_channel_client_create(channel->base_channel,
> > red_client,
> >                                      num_common_caps, common_caps,
> > num_caps, caps);
> >      if (!client->channel_client) {
> >          goto error2;
> > @@ -970,19 +970,19 @@ error1:
> >  
> >  static void snd_disconnect_channel_client(RedChannelClient *rcc)
> >  {
> > -    SndWorker *worker;
> > -    RedChannel *channel = red_channel_client_get_channel(rcc);
> > +    SndChannel *channel;
> > +    RedChannel *red_channel = red_channel_client_get_channel(rcc);
> >      uint32_t type;
> >  
> > +    spice_assert(red_channel);
> > +    channel = (SndChannel *)g_object_get_data(G_OBJECT(red_channel),
> > "sound-channel");
> >      spice_assert(channel);
> > -    worker = (SndWorker *)g_object_get_data(G_OBJECT(channel),
> > "sound-worker");
> > -    spice_assert(worker);
> > -    g_object_get(channel, "channel-type", &type, NULL);
> > +    g_object_get(red_channel, "channel-type", &type, NULL);
> >  
> >      spice_debug("channel-type=%d", type);
> > -    if (worker->connection) {
> > -        spice_assert(worker->connection->channel_client == rcc);
> > -        snd_disconnect_channel(worker->connection);
> > +    if (channel->connection) {
> > +        spice_assert(channel->connection->channel_client == rcc);
> > +        snd_disconnect_channel(channel->connection);
> >      }
> >  }
> >  
> > @@ -998,8 +998,8 @@ SPICE_GNUC_VISIBLE void
> > spice_server_playback_set_volume(SpicePlaybackInstance *
> >                                                    uint8_t nchannels,
> >                                                    uint16_t *volume)
> >  {
> > -    SpiceVolumeState *st = &sin->st->worker.volume;
> > -    SndChannelClient *client = sin->st->worker.connection;
> > +    SpiceVolumeState *st = &sin->st->channel.volume;
> > +    SndChannelClient *client = sin->st->channel.connection;
> >      PlaybackChannelClient *playback_client =
> > SPICE_CONTAINEROF(client, PlaybackChannelClient, base);
> >  
> >      st->volume_nchannels = nchannels;
> > @@ -1014,8 +1014,8 @@ SPICE_GNUC_VISIBLE void
> > spice_server_playback_set_volume(SpicePlaybackInstance *
> >  
> >  SPICE_GNUC_VISIBLE void
> > spice_server_playback_set_mute(SpicePlaybackInstance *sin, uint8_t
> > mute)
> >  {
> > -    SpiceVolumeState *st = &sin->st->worker.volume;
> > -    SndChannelClient *client = sin->st->worker.connection;
> > +    SpiceVolumeState *st = &sin->st->channel.volume;
> > +    SndChannelClient *client = sin->st->channel.connection;
> >      PlaybackChannelClient *playback_client =
> > SPICE_CONTAINEROF(client, PlaybackChannelClient, base);
> >  
> >      st->mute = mute;
> > @@ -1026,11 +1026,11 @@ SPICE_GNUC_VISIBLE void
> > spice_server_playback_set_mute(SpicePlaybackInstance *si
> >      snd_playback_send_mute(playback_client);
> >  }
> >  
> > -static void snd_playback_start(SndWorker *worker)
> > +static void snd_playback_start(SndChannel *channel)
> >  {
> > -    SndChannelClient *client = worker->connection;
> > +    SndChannelClient *client = channel->connection;
> >  
> > -    worker->active = 1;
> > +    channel->active = 1;
> >      if (!client)
> >          return;
> >      spice_assert(!client->active);
> > @@ -1046,15 +1046,15 @@ static void snd_playback_start(SndWorker
> > *worker)
> >  
> >  SPICE_GNUC_VISIBLE void
> > spice_server_playback_start(SpicePlaybackInstance *sin)
> >  {
> > -    return snd_playback_start(&sin->st->worker);
> > +    return snd_playback_start(&sin->st->channel);
> >  }
> >  
> >  SPICE_GNUC_VISIBLE void
> > spice_server_playback_stop(SpicePlaybackInstance *sin)
> >  {
> > -    SndChannelClient *client = sin->st->worker.connection;
> > +    SndChannelClient *client = sin->st->channel.connection;
> >      PlaybackChannelClient *playback_client =
> > SPICE_CONTAINEROF(client, PlaybackChannelClient, base);
> >  
> > -    sin->st->worker.active = 0;
> > +    sin->st->channel.active = 0;
> >      if (!client)
> >          return;
> >      spice_assert(playback_client->base.active);
> > @@ -1079,7 +1079,7 @@ SPICE_GNUC_VISIBLE void
> > spice_server_playback_stop(SpicePlaybackInstance *sin)
> >  SPICE_GNUC_VISIBLE void
> > spice_server_playback_get_buffer(SpicePlaybackInstance *sin,
> >                                                           uint32_t
> > **frame, uint32_t *num_samples)
> >  {
> > -    SndChannelClient *client = sin->st->worker.connection;
> > +    SndChannelClient *client = sin->st->channel.connection;
> >      PlaybackChannelClient *playback_client =
> > SPICE_CONTAINEROF(client, PlaybackChannelClient, base);
> >  
> >      if (!client || !playback_client->free_frames) {
> > @@ -1104,7 +1104,7 @@ SPICE_GNUC_VISIBLE void
> > spice_server_playback_put_samples(SpicePlaybackInstance
> >      playback_client = frame->client;
> >      spice_assert(playback_client);
> >      if (!snd_channel_unref(&playback_client->base) ||
> > -        sin->st->worker.connection != &playback_client->base) {
> > +        sin->st->channel.connection != &playback_client->base) {
> >          /* lost last reference, client has been destroyed previously
> > */
> >          spice_info("audio samples belong to a disconnected client");
> >          return;
> > @@ -1122,7 +1122,7 @@ SPICE_GNUC_VISIBLE void
> > spice_server_playback_put_samples(SpicePlaybackInstance
> >  
> >  void snd_set_playback_latency(RedClient *client, uint32_t latency)
> >  {
> > -    SndWorker *now = workers;
> > +    SndChannel *now = snd_channels;
> >  
> >      for (; now; now = now->next) {
> >          uint32_t type;
> > @@ -1159,18 +1159,18 @@ static int snd_desired_audio_mode(int
> > playback_compression, int frequency,
> >      return SPICE_AUDIO_DATA_MODE_RAW;
> >  }
> >  
> > -static void on_new_playback_channel(SndWorker *worker,
> > SndChannelClient *snd_channel)
> > +static void on_new_playback_channel(SndChannel *channel,
> > SndChannelClient *snd_channel)
> >  {
> > -    RedsState *reds = red_channel_get_server(worker->base_channel);
> > +    RedsState *reds = red_channel_get_server(channel->base_channel);
> >  
> >      spice_assert(snd_channel);
> >  
> > -    worker->connection = snd_channel;
> > +    channel->connection = snd_channel;
> >      snd_set_command(snd_channel, SND_PLAYBACK_MODE_MASK);
> >      if (snd_channel->active) {
> >          snd_set_command(snd_channel, SND_CTRL_MASK);
> >      }
> > -    if (worker->volume.volume_nchannels) {
> > +    if (channel->volume.volume_nchannels) {
> >          snd_set_command(snd_channel, SND_VOLUME_MASK);
> >      }
> >      if (snd_channel->active) {
> > @@ -1189,16 +1189,16 @@ static void
> > snd_playback_cleanup(SndChannelClient *client)
> >      snd_codec_destroy(&playback_client->codec);
> >  }
> >  
> > -static void snd_set_playback_peer(RedChannel *channel, RedClient
> > *client, RedsStream *stream,
> > +static void snd_set_playback_peer(RedChannel *red_channel, RedClient
> > *client, RedsStream *stream,
> >                                    int migration, int
> > num_common_caps, uint32_t *common_caps,
> >                                    int num_caps, uint32_t *caps)
> >  {
> > -    SndWorker *worker = g_object_get_data(G_OBJECT(channel), "sound-
> > worker");
> > +    SndChannel *channel = g_object_get_data(G_OBJECT(red_channel),
> > "sound-channel");
> >      PlaybackChannelClient *playback_client;
> >  
> > -    snd_disconnect_channel(worker->connection);
> > +    snd_disconnect_channel(channel->connection);
> >  
> > -    if (!(playback_client = (PlaybackChannelClient
> > *)__new_channel(worker,
> > +    if (!(playback_client = (PlaybackChannelClient
> > *)__new_channel(channel,
> >                                                                sizeof
> > (*playback_client),
> >                                                                SPICE_
> > CHANNEL_PLAYBACK,
> >                                                                client
> > ,
> > @@ -1221,12 +1221,12 @@ static void snd_set_playback_peer(RedChannel
> > *channel, RedClient *client, RedsSt
> >      int client_can_opus =
> > red_channel_client_test_remote_cap(playback_client-
> > >base.channel_client,
> >                                            SPICE_PLAYBACK_CAP_OPUS);
> >      int playback_compression =
> > -        reds_config_get_playback_compression(red_channel_get_server(
> > channel));
> > -    int desired_mode = snd_desired_audio_mode(playback_compression,
> > worker->frequency,
> > +        reds_config_get_playback_compression(red_channel_get_server(
> > red_channel));
> > +    int desired_mode = snd_desired_audio_mode(playback_compression,
> > channel->frequency,
> >                                                client_can_celt,
> > client_can_opus);
> >      playback_client->mode = SPICE_AUDIO_DATA_MODE_RAW;
> >      if (desired_mode != SPICE_AUDIO_DATA_MODE_RAW) {
> > -        if (snd_codec_create(&playback_client->codec, desired_mode,
> > worker->frequency,
> > +        if (snd_codec_create(&playback_client->codec, desired_mode,
> > channel->frequency,
> >                               SND_CODEC_ENCODE) == SND_CODEC_OK) {
> >              playback_client->mode = desired_mode;
> >          } else {
> > @@ -1235,29 +1235,29 @@ static void snd_set_playback_peer(RedChannel
> > *channel, RedClient *client, RedsSt
> >      }
> >  
> >      if (!red_client_during_migrate_at_target(client)) {
> > -        on_new_playback_channel(worker, &playback_client->base);
> > +        on_new_playback_channel(channel, &playback_client->base);
> >      }
> >  
> > -    if (worker->active) {
> > -        snd_playback_start(worker);
> > +    if (channel->active) {
> > +        snd_playback_start(channel);
> >      }
> > -    snd_playback_send(worker->connection);
> > +    snd_playback_send(channel->connection);
> >  }
> >  
> >  static void snd_record_migrate_channel_client(RedChannelClient *rcc)
> >  {
> > -    SndWorker *worker;
> > -    RedChannel *channel = red_channel_client_get_channel(rcc);
> > +    SndChannel *channel;
> > +    RedChannel *red_channel = red_channel_client_get_channel(rcc);
> >  
> >      spice_debug(NULL);
> > +    spice_assert(red_channel);
> > +    channel = (SndChannel *)g_object_get_data(G_OBJECT(red_channel),
> > "sound-channel");
> >      spice_assert(channel);
> > -    worker = (SndWorker *)g_object_get_data(G_OBJECT(channel),
> > "sound-worker");
> > -    spice_assert(worker);
> >  
> > -    if (worker->connection) {
> > -        spice_assert(worker->connection->channel_client == rcc);
> > -        snd_set_command(worker->connection, SND_MIGRATE_MASK);
> > -        snd_record_send(worker->connection);
> > +    if (channel->connection) {
> > +        spice_assert(channel->connection->channel_client == rcc);
> > +        snd_set_command(channel->connection, SND_MIGRATE_MASK);
> > +        snd_record_send(channel->connection);
> >      }
> >  }
> >  
> > @@ -1265,8 +1265,8 @@ SPICE_GNUC_VISIBLE void
> > spice_server_record_set_volume(SpiceRecordInstance *sin,
> >                                                  uint8_t nchannels,
> >                                                  uint16_t *volume)
> >  {
> > -    SpiceVolumeState *st = &sin->st->worker.volume;
> > -    SndChannelClient *client = sin->st->worker.connection;
> > +    SpiceVolumeState *st = &sin->st->channel.volume;
> > +    SndChannelClient *client = sin->st->channel.connection;
> >      RecordChannelClient *record_client = SPICE_CONTAINEROF(client,
> > RecordChannelClient, base);
> >  
> >      st->volume_nchannels = nchannels;
> > @@ -1281,8 +1281,8 @@ SPICE_GNUC_VISIBLE void
> > spice_server_record_set_volume(SpiceRecordInstance *sin,
> >  
> >  SPICE_GNUC_VISIBLE void
> > spice_server_record_set_mute(SpiceRecordInstance *sin, uint8_t mute)
> >  {
> > -    SpiceVolumeState *st = &sin->st->worker.volume;
> > -    SndChannelClient *client = sin->st->worker.connection;
> > +    SpiceVolumeState *st = &sin->st->channel.volume;
> > +    SndChannelClient *client = sin->st->channel.connection;
> >      RecordChannelClient *record_client = SPICE_CONTAINEROF(client,
> > RecordChannelClient, base);
> >  
> >      st->mute = mute;
> > @@ -1293,12 +1293,12 @@ SPICE_GNUC_VISIBLE void
> > spice_server_record_set_mute(SpiceRecordInstance *sin, u
> >      snd_record_send_mute(record_client);
> >  }
> >  
> > -static void snd_record_start(SndWorker *worker)
> > +static void snd_record_start(SndChannel *channel)
> >  {
> > -    SndChannelClient *client = worker->connection;
> > +    SndChannelClient *client = channel->connection;
> >      RecordChannelClient *record_client = SPICE_CONTAINEROF(client,
> > RecordChannelClient, base);
> >  
> > -    worker->active = 1;
> > +    channel->active = 1;
> >      if (!client)
> >          return;
> >      spice_assert(!client->active);
> > @@ -1315,15 +1315,15 @@ static void snd_record_start(SndWorker
> > *worker)
> >  
> >  SPICE_GNUC_VISIBLE void
> > spice_server_record_start(SpiceRecordInstance *sin)
> >  {
> > -    snd_record_start(&sin->st->worker);
> > +    snd_record_start(&sin->st->channel);
> >  }
> >  
> >  SPICE_GNUC_VISIBLE void spice_server_record_stop(SpiceRecordInstance
> > *sin)
> >  {
> > -    SndChannelClient *client = sin->st->worker.connection;
> > +    SndChannelClient *client = sin->st->channel.connection;
> >      RecordChannelClient *record_client = SPICE_CONTAINEROF(client,
> > RecordChannelClient, base);
> >  
> > -    sin->st->worker.active = 0;
> > +    sin->st->channel.active = 0;
> >      if (!client)
> >          return;
> >      spice_assert(record_client->base.active);
> > @@ -1339,7 +1339,7 @@ SPICE_GNUC_VISIBLE void
> > spice_server_record_stop(SpiceRecordInstance *sin)
> >  SPICE_GNUC_VISIBLE uint32_t
> > spice_server_record_get_samples(SpiceRecordInstance *sin,
> >                                                              uint32_t
> > *samples, uint32_t bufsize)
> >  {
> > -    SndChannelClient *client = sin->st->worker.connection;
> > +    SndChannelClient *client = sin->st->channel.connection;
> >      RecordChannelClient *record_client = SPICE_CONTAINEROF(client,
> > RecordChannelClient, base);
> >      uint32_t read_pos;
> >      uint32_t now;
> > @@ -1356,9 +1356,9 @@ SPICE_GNUC_VISIBLE uint32_t
> > spice_server_record_get_samples(SpiceRecordInstance
> >      len = MIN(record_client->write_pos - record_client->read_pos,
> > bufsize);
> >  
> >      if (len < bufsize) {
> > -        SndWorker *worker = record_client->base.worker;
> > +        SndChannel *channel = record_client->base.channel;
> >          snd_receive(&record_client->base);
> > -        if (!worker->connection) {
> > +        if (!channel->connection) {
> >              return 0;
> >          }
> >          len = MIN(record_client->write_pos - record_client-
> > >read_pos, bufsize);
> > @@ -1387,41 +1387,41 @@ static uint32_t
> > snd_get_best_rate(SndChannelClient *client, uint32_t cap_opus)
> >      return SND_CODEC_CELT_PLAYBACK_FREQ;
> >  }
> >  
> > -static void snd_set_rate(SndWorker *worker, uint32_t frequency,
> > uint32_t cap_opus)
> > +static void snd_set_rate(SndChannel *channel, uint32_t frequency,
> > uint32_t cap_opus)
> >  {
> > -    RedChannel *channel = worker->base_channel;
> > -    worker->frequency = frequency;
> > -    if (channel && snd_codec_is_capable(SPICE_AUDIO_DATA_MODE_OPUS,
> > frequency)) {
> > -        red_channel_set_cap(channel, cap_opus);
> > +    RedChannel *red_channel = channel->base_channel;
> > +    channel->frequency = frequency;
> > +    if (red_channel &&
> > snd_codec_is_capable(SPICE_AUDIO_DATA_MODE_OPUS, frequency)) {
> > +        red_channel_set_cap(red_channel, cap_opus);
> >      }
> >  }
> >  
> >  SPICE_GNUC_VISIBLE uint32_t
> > spice_server_get_best_playback_rate(SpicePlaybackInstance *sin)
> >  {
> > -    return snd_get_best_rate(sin ? sin->st->worker.connection :
> > NULL, SPICE_PLAYBACK_CAP_OPUS);
> > +    return snd_get_best_rate(sin ? sin->st->channel.connection :
> > NULL, SPICE_PLAYBACK_CAP_OPUS);
> >  }
> >  
> >  SPICE_GNUC_VISIBLE void
> > spice_server_set_playback_rate(SpicePlaybackInstance *sin, uint32_t
> > frequency)
> >  {
> > -    snd_set_rate(&sin->st->worker, frequency,
> > SPICE_PLAYBACK_CAP_OPUS);
> > +    snd_set_rate(&sin->st->channel, frequency,
> > SPICE_PLAYBACK_CAP_OPUS);
> >  }
> >  
> >  SPICE_GNUC_VISIBLE uint32_t
> > spice_server_get_best_record_rate(SpiceRecordInstance *sin)
> >  {
> > -    return snd_get_best_rate(sin ? sin->st->worker.connection :
> > NULL, SPICE_RECORD_CAP_OPUS);
> > +    return snd_get_best_rate(sin ? sin->st->channel.connection :
> > NULL, SPICE_RECORD_CAP_OPUS);
> >  }
> >  
> >  SPICE_GNUC_VISIBLE void
> > spice_server_set_record_rate(SpiceRecordInstance *sin, uint32_t
> > frequency)
> >  {
> > -    snd_set_rate(&sin->st->worker, frequency,
> > SPICE_RECORD_CAP_OPUS);
> > +    snd_set_rate(&sin->st->channel, frequency,
> > SPICE_RECORD_CAP_OPUS);
> >  }
> >  
> > -static void on_new_record_channel(SndWorker *worker,
> > SndChannelClient *snd_channel)
> > +static void on_new_record_channel(SndChannel *channel,
> > SndChannelClient *snd_channel)
> >  {
> >      spice_assert(snd_channel);
> >  
> > -    worker->connection = snd_channel ;
> > -    if (worker->volume.volume_nchannels) {
> > +    channel->connection = snd_channel ;
> > +    if (channel->volume.volume_nchannels) {
> >          snd_set_command(snd_channel, SND_VOLUME_MASK);
> >      }
> >      if (snd_channel->active) {
> > @@ -1435,16 +1435,16 @@ static void
> > snd_record_cleanup(SndChannelClient *client)
> >      snd_codec_destroy(&record_client->codec);
> >  }
> >  
> > -static void snd_set_record_peer(RedChannel *channel, RedClient
> > *client, RedsStream *stream,
> > +static void snd_set_record_peer(RedChannel *red_channel, RedClient
> > *client, RedsStream *stream,
> >                                  int migration, int num_common_caps,
> > uint32_t *common_caps,
> >                                  int num_caps, uint32_t *caps)
> >  {
> > -    SndWorker *worker = g_object_get_data(G_OBJECT(channel), "sound-
> > worker");
> > +    SndChannel *channel = g_object_get_data(G_OBJECT(red_channel),
> > "sound-channel");
> >      RecordChannelClient *record_client;
> >  
> > -    snd_disconnect_channel(worker->connection);
> > +    snd_disconnect_channel(channel->connection);
> >  
> > -    if (!(record_client = (RecordChannelClient
> > *)__new_channel(worker,
> > +    if (!(record_client = (RecordChannelClient
> > *)__new_channel(channel,
> >                                                            sizeof(*re
> > cord_client),
> >                                                            SPICE_CHAN
> > NEL_RECORD,
> >                                                            client,
> > @@ -1461,42 +1461,42 @@ static void snd_set_record_peer(RedChannel
> > *channel, RedClient *client, RedsStre
> >  
> >      record_client->mode = SPICE_AUDIO_DATA_MODE_RAW;
> >  
> > -    on_new_record_channel(worker, &record_client->base);
> > -    if (worker->active) {
> > -        snd_record_start(worker);
> > +    on_new_record_channel(channel, &record_client->base);
> > +    if (channel->active) {
> > +        snd_record_start(channel);
> >      }
> > -    snd_record_send(worker->connection);
> > +    snd_record_send(channel->connection);
> >  }
> >  
> >  static void snd_playback_migrate_channel_client(RedChannelClient
> > *rcc)
> >  {
> > -    SndWorker *worker;
> > -    RedChannel *channel = red_channel_client_get_channel(rcc);
> > +    SndChannel *channel;
> > +    RedChannel *red_channel = red_channel_client_get_channel(rcc);
> >  
> > +    spice_assert(red_channel);
> > +    channel = (SndChannel *)g_object_get_data(G_OBJECT(red_channel),
> > "sound-channel");
> >      spice_assert(channel);
> > -    worker = (SndWorker *)g_object_get_data(G_OBJECT(channel),
> > "sound-worker");
> > -    spice_assert(worker);
> >      spice_debug(NULL);
> >  
> > -    if (worker->connection) {
> > -        spice_assert(worker->connection->channel_client == rcc);
> > -        snd_set_command(worker->connection, SND_MIGRATE_MASK);
> > -        snd_playback_send(worker->connection);
> > +    if (channel->connection) {
> > +        spice_assert(channel->connection->channel_client == rcc);
> > +        snd_set_command(channel->connection, SND_MIGRATE_MASK);
> > +        snd_playback_send(channel->connection);
> >      }
> >  }
> >  
> > -static void add_worker(SndWorker *worker)
> > +static void add_channel(SndChannel *channel)
> >  {
> > -    worker->next = workers;
> > -    workers = worker;
> > +    channel->next = snd_channels;
> > +    snd_channels = channel;
> >  }
> >  
> > -static void remove_worker(SndWorker *worker)
> > +static void remove_channel(SndChannel *channel)
> >  {
> > -    SndWorker **now = &workers;
> > +    SndChannel **now = &snd_channels;
> >      while (*now) {
> > -        if (*now == worker) {
> > -            *now = worker->next;
> > +        if (*now == channel) {
> > +            *now = channel->next;
> >              return;
> >          }
> >          now = &(*now)->next;
> > @@ -1506,73 +1506,73 @@ static void remove_worker(SndWorker *worker)
> >  
> >  void snd_attach_playback(RedsState *reds, SpicePlaybackInstance
> > *sin)
> >  {
> > -    SndWorker *playback_worker;
> > -    RedChannel *channel;
> > +    SndChannel *playback;
> > +    RedChannel *red_channel;
> >      ClientCbs client_cbs = { NULL, };
> >  
> >      sin->st = spice_new0(SpicePlaybackState, 1);
> > -    playback_worker = &sin->st->worker;
> > -    playback_worker->frequency = SND_CODEC_CELT_PLAYBACK_FREQ; /*
> > Default to the legacy rate */
> > +    playback = &sin->st->channel;
> > +    playback->frequency = SND_CODEC_CELT_PLAYBACK_FREQ; /* Default
> > to the legacy rate */
> >  
> > -    // TODO: Make RedChannel base of worker? instead of assigning it
> > to channel->data
> > -    channel = dummy_channel_new(reds, SPICE_CHANNEL_PLAYBACK, 0);
> > +    // TODO: Make RedChannel base of channel? instead of assigning
> > it to channel->data
> > +    red_channel = dummy_channel_new(reds, SPICE_CHANNEL_PLAYBACK,
> > 0);
> >  
> > -    g_object_set_data(G_OBJECT(channel), "sound-worker",
> > playback_worker);
> > +    g_object_set_data(G_OBJECT(red_channel), "sound-channel",
> > playback);
> >      client_cbs.connect = snd_set_playback_peer;
> >      client_cbs.disconnect = snd_disconnect_channel_client;
> >      client_cbs.migrate = snd_playback_migrate_channel_client;
> > -    red_channel_register_client_cbs(channel, &client_cbs,
> > playback_worker);
> > +    red_channel_register_client_cbs(red_channel, &client_cbs,
> > playback);
> >  
> >      if (snd_codec_is_capable(SPICE_AUDIO_DATA_MODE_CELT_0_5_1,
> > SND_CODEC_ANY_FREQUENCY))
> > -        red_channel_set_cap(channel, SPICE_PLAYBACK_CAP_CELT_0_5_1);
> > +        red_channel_set_cap(red_channel,
> > SPICE_PLAYBACK_CAP_CELT_0_5_1);
> >  
> > -    red_channel_set_cap(channel, SPICE_PLAYBACK_CAP_VOLUME);
> > +    red_channel_set_cap(red_channel, SPICE_PLAYBACK_CAP_VOLUME);
> >  
> > -    playback_worker->base_channel = channel;
> > -    add_worker(playback_worker);
> > -    reds_register_channel(reds, channel);
> > +    playback->base_channel = red_channel;
> > +    add_channel(playback);
> > +    reds_register_channel(reds, red_channel);
> >  }
> >  
> >  void snd_attach_record(RedsState *reds, SpiceRecordInstance *sin)
> >  {
> > -    SndWorker *record_worker;
> > -    RedChannel *channel;
> > +    SndChannel *record;
> > +    RedChannel *red_channel;
> >      ClientCbs client_cbs = { NULL, };
> >  
> >      sin->st = spice_new0(SpiceRecordState, 1);
> > -    record_worker = &sin->st->worker;
> > -    record_worker->frequency = SND_CODEC_CELT_PLAYBACK_FREQ; /*
> > Default to the legacy rate */
> > +    record = &sin->st->channel;
> > +    record->frequency = SND_CODEC_CELT_PLAYBACK_FREQ; /* Default to
> > the legacy rate */
> >  
> > -    // TODO: Make RedChannel base of worker? instead of assigning it
> > to channel->data
> > -    channel = dummy_channel_new(reds, SPICE_CHANNEL_RECORD, 0);
> > +    // TODO: Make RedChannel base of channel? instead of assigning
> > it to channel->data
> > +    red_channel = dummy_channel_new(reds, SPICE_CHANNEL_RECORD, 0);
> >  
> > -    g_object_set_data(G_OBJECT(channel), "sound-worker",
> > record_worker);
> > +    g_object_set_data(G_OBJECT(red_channel), "sound-channel",
> > record);
> >      client_cbs.connect = snd_set_record_peer;
> >      client_cbs.disconnect = snd_disconnect_channel_client;
> >      client_cbs.migrate = snd_record_migrate_channel_client;
> > -    red_channel_register_client_cbs(channel, &client_cbs,
> > record_worker);
> > +    red_channel_register_client_cbs(red_channel, &client_cbs,
> > record);
> >      if (snd_codec_is_capable(SPICE_AUDIO_DATA_MODE_CELT_0_5_1,
> > SND_CODEC_ANY_FREQUENCY))
> > -        red_channel_set_cap(channel, SPICE_RECORD_CAP_CELT_0_5_1);
> > -    red_channel_set_cap(channel, SPICE_RECORD_CAP_VOLUME);
> > +        red_channel_set_cap(red_channel,
> > SPICE_RECORD_CAP_CELT_0_5_1);
> > +    red_channel_set_cap(red_channel, SPICE_RECORD_CAP_VOLUME);
> >  
> > -    record_worker->base_channel = channel;
> > -    add_worker(record_worker);
> > -    reds_register_channel(reds, channel);
> > +    record->base_channel = red_channel;
> > +    add_channel(record);
> > +    reds_register_channel(reds, red_channel);
> >  }
> >  
> > -static void snd_detach_common(SndWorker *worker)
> > +static void snd_detach_common(SndChannel *channel)
> >  {
> > -    if (!worker) {
> > +    if (!channel) {
> >          return;
> >      }
> > -    RedsState *reds = red_channel_get_server(worker->base_channel);
> > +    RedsState *reds = red_channel_get_server(channel->base_channel);
> >  
> > -    remove_worker(worker);
> > -    snd_disconnect_channel(worker->connection);
> > -    reds_unregister_channel(reds, worker->base_channel);
> > -    red_channel_destroy(worker->base_channel);
> > -    free(worker->volume.volume);
> > -    worker->volume.volume = NULL;
> > +    remove_channel(channel);
> > +    snd_disconnect_channel(channel->connection);
> > +    reds_unregister_channel(reds, channel->base_channel);
> > +    red_channel_destroy(channel->base_channel);
> > +    free(channel->volume.volume);
> > +    channel->volume.volume = NULL;
> >  }
> >  
> >  static void spice_playback_state_free(SpicePlaybackState *st)
> > @@ -1582,7 +1582,7 @@ static void
> > spice_playback_state_free(SpicePlaybackState *st)
> >  
> >  void snd_detach_playback(SpicePlaybackInstance *sin)
> >  {
> > -    snd_detach_common(&sin->st->worker);
> > +    snd_detach_common(&sin->st->channel);
> >      spice_playback_state_free(sin->st);
> >  }
> >  
> > @@ -1593,13 +1593,13 @@ static void
> > spice_record_state_free(SpiceRecordState *st)
> >  
> >  void snd_detach_record(SpiceRecordInstance *sin)
> >  {
> > -    snd_detach_common(&sin->st->worker);
> > +    snd_detach_common(&sin->st->channel);
> >      spice_record_state_free(sin->st);
> >  }
> >  
> >  void snd_set_playback_compression(int on)
> >  {
> > -    SndWorker *now = workers;
> > +    SndChannel *now = snd_channels;
> >  
> >      for (; now; now = now->next) {
> >          uint32_t type;
>