[Spice-devel,v3,04/17] sound: Rename channel to client if variable used for clients

Submitted by Frediano Ziglio on Nov. 29, 2016, 2:57 p.m.

Details

Message ID f807decb1ad55cc6c8153cb9a54e5352f461ce4c.1480431431.git-series.fziglio@redhat.com
State Accepted
Headers show
Series "Remove DummyChannel* objects" ( rev: 4 ) in Spice

Not browsing as part of any series.

Commit Message

Frediano Ziglio Nov. 29, 2016, 2:57 p.m.
Due to object rename using channel to store a client is
quite confusing.

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

Patch hide | download patch | download mbox

diff --git a/server/sound.c b/server/sound.c
index 6c02754..c3bb566 100644
--- a/server/sound.c
+++ b/server/sound.c
@@ -75,13 +75,13 @@  enum PlaybackCommand {
 
 typedef struct SndChannelClient SndChannelClient;
 typedef void (*snd_channel_send_messages_proc)(void *in_channel);
-typedef int (*snd_channel_handle_message_proc)(SndChannelClient *channel, size_t size, uint32_t type, void *message);
-typedef void (*snd_channel_on_message_done_proc)(SndChannelClient *channel);
-typedef void (*snd_channel_cleanup_channel_proc)(SndChannelClient *channel);
+typedef int (*snd_channel_handle_message_proc)(SndChannelClient *client, size_t size, uint32_t type, void *message);
+typedef void (*snd_channel_on_message_done_proc)(SndChannelClient *client);
+typedef void (*snd_channel_cleanup_channel_proc)(SndChannelClient *client);
 
 typedef struct SndWorker SndWorker;
 
-/* Connects an audio channel to a Spice client */
+/* Connects an audio client to a Spice client */
 struct SndChannelClient {
     RedsStream *stream;
     SndWorker *worker;
@@ -122,7 +122,7 @@  typedef struct AudioFrame AudioFrame;
 struct AudioFrame {
     uint32_t time;
     uint32_t samples[SND_CODEC_MAX_FRAME_SIZE];
-    PlaybackChannelClient *channel;
+    PlaybackChannelClient *client;
     AudioFrame *next;
 };
 
@@ -178,135 +178,135 @@  typedef struct RecordChannelClient {
 /* A list of all Spice{Playback,Record}State objects */
 static SndWorker *workers;
 
-static void snd_receive(SndChannelClient *channel);
+static void snd_receive(SndChannelClient *client);
 static void snd_playback_start(SndWorker *worker);
 static void snd_record_start(SndWorker *worker);
 
-static SndChannelClient *snd_channel_ref(SndChannelClient *channel)
+static SndChannelClient *snd_channel_ref(SndChannelClient *client)
 {
-    channel->refs++;
-    return channel;
+    client->refs++;
+    return client;
 }
 
-static SndChannelClient *snd_channel_unref(SndChannelClient *channel)
+static SndChannelClient *snd_channel_unref(SndChannelClient *client)
 {
-    if (!--channel->refs) {
-        spice_printerr("SndChannelClient=%p freed", channel);
-        free(channel);
+    if (!--client->refs) {
+        spice_printerr("SndChannelClient=%p freed", client);
+        free(client);
         return NULL;
     }
-    return channel;
+    return client;
 }
 
-static RedsState* snd_channel_get_server(SndChannelClient *channel)
+static RedsState* snd_channel_get_server(SndChannelClient *client)
 {
-    g_return_val_if_fail(channel != NULL, NULL);
-    return red_channel_get_server(channel->worker->base_channel);
+    g_return_val_if_fail(client != NULL, NULL);
+    return red_channel_get_server(client->worker->base_channel);
 }
 
-static void snd_disconnect_channel(SndChannelClient *channel)
+static void snd_disconnect_channel(SndChannelClient *client)
 {
     SndWorker *worker;
     RedsState *reds;
     RedChannel *red_channel;
     uint32_t type;
 
-    if (!channel || !channel->stream) {
+    if (!client || !client->stream) {
         spice_debug("not connected");
         return;
     }
-    red_channel = red_channel_client_get_channel(channel->channel_client);
-    reds = snd_channel_get_server(channel);
+    red_channel = red_channel_client_get_channel(client->channel_client);
+    reds = snd_channel_get_server(client);
     g_object_get(red_channel, "channel-type", &type, NULL);
     spice_debug("SndChannelClient=%p rcc=%p type=%d",
-                 channel, channel->channel_client, type);
-    worker = channel->worker;
-    channel->cleanup(channel);
+                 client, client->channel_client, type);
+    worker = client->worker;
+    client->cleanup(client);
     red_channel_client_disconnect(worker->connection->channel_client);
     worker->connection->channel_client = NULL;
-    reds_core_watch_remove(reds, channel->stream->watch);
-    channel->stream->watch = NULL;
-    reds_stream_free(channel->stream);
-    channel->stream = NULL;
-    spice_marshaller_destroy(channel->send_data.marshaller);
-    snd_channel_unref(channel);
+    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;
 }
 
 static void snd_playback_free_frame(PlaybackChannelClient *playback_client, AudioFrame *frame)
 {
-    frame->channel = playback_client;
+    frame->client = playback_client;
     frame->next = playback_client->free_frames;
     playback_client->free_frames = frame;
 }
 
-static void snd_playback_on_message_done(SndChannelClient *channel)
+static void snd_playback_on_message_done(SndChannelClient *client)
 {
-    PlaybackChannelClient *playback_client = (PlaybackChannelClient *)channel;
+    PlaybackChannelClient *playback_client = (PlaybackChannelClient *)client;
     if (playback_client->in_progress) {
         snd_playback_free_frame(playback_client, playback_client->in_progress);
         playback_client->in_progress = NULL;
         if (playback_client->pending_frame) {
-            channel->command |= SND_PLAYBACK_PCM_MASK;
+            client->command |= SND_PLAYBACK_PCM_MASK;
         }
     }
 }
 
-static void snd_record_on_message_done(SndChannelClient *channel)
+static void snd_record_on_message_done(SndChannelClient *client)
 {
 }
 
-static int snd_send_data(SndChannelClient *channel)
+static int snd_send_data(SndChannelClient *client)
 {
     uint32_t n;
 
-    if (!channel) {
+    if (!client) {
         return FALSE;
     }
 
-    if (!(n = channel->send_data.size - channel->send_data.pos)) {
+    if (!(n = client->send_data.size - client->send_data.pos)) {
         return TRUE;
     }
 
-    RedsState *reds = snd_channel_get_server(channel);
+    RedsState *reds = snd_channel_get_server(client);
     for (;;) {
         struct iovec vec[IOV_MAX];
         int vec_size;
 
         if (!n) {
-            channel->on_message_done(channel);
+            client->on_message_done(client);
 
-            if (channel->blocked) {
-                channel->blocked = FALSE;
-                reds_core_watch_update_mask(reds, channel->stream->watch, SPICE_WATCH_EVENT_READ);
+            if (client->blocked) {
+                client->blocked = FALSE;
+                reds_core_watch_update_mask(reds, client->stream->watch, SPICE_WATCH_EVENT_READ);
             }
             break;
         }
 
-        vec_size = spice_marshaller_fill_iovec(channel->send_data.marshaller,
-                                               vec, IOV_MAX, channel->send_data.pos);
-        n = reds_stream_writev(channel->stream, vec, vec_size);
+        vec_size = spice_marshaller_fill_iovec(client->send_data.marshaller,
+                                               vec, IOV_MAX, client->send_data.pos);
+        n = reds_stream_writev(client->stream, vec, vec_size);
         if (n == -1) {
             switch (errno) {
             case EAGAIN:
-                channel->blocked = TRUE;
-                reds_core_watch_update_mask(reds, channel->stream->watch, SPICE_WATCH_EVENT_READ |
+                client->blocked = TRUE;
+                reds_core_watch_update_mask(reds, client->stream->watch, SPICE_WATCH_EVENT_READ |
                                                                  SPICE_WATCH_EVENT_WRITE);
                 return FALSE;
             case EINTR:
                 break;
             case EPIPE:
-                snd_disconnect_channel(channel);
+                snd_disconnect_channel(client);
                 return FALSE;
             default:
                 spice_printerr("%s", strerror(errno));
-                snd_disconnect_channel(channel);
+                snd_disconnect_channel(client);
                 return FALSE;
             }
         } else {
-            channel->send_data.pos += n;
+            client->send_data.pos += n;
         }
-        n = channel->send_data.size - channel->send_data.pos;
+        n = client->send_data.size - client->send_data.pos;
     }
     return TRUE;
 }
@@ -356,9 +356,9 @@  static int snd_record_handle_write(RecordChannelClient *record_client, size_t si
     return TRUE;
 }
 
-static int snd_playback_handle_message(SndChannelClient *channel, size_t size, uint32_t type, void *message)
+static int snd_playback_handle_message(SndChannelClient *client, size_t size, uint32_t type, void *message)
 {
-    if (!channel) {
+    if (!client) {
         return FALSE;
     }
 
@@ -372,19 +372,19 @@  static int snd_playback_handle_message(SndChannelClient *channel, size_t size, u
     return TRUE;
 }
 
-static int snd_record_handle_message(SndChannelClient *channel, size_t size, uint32_t type, void *message)
+static int snd_record_handle_message(SndChannelClient *client, size_t size, uint32_t type, void *message)
 {
-    RecordChannelClient *record_client = (RecordChannelClient *)channel;
+    RecordChannelClient *record_client = (RecordChannelClient *)client;
 
-    if (!channel) {
+    if (!client) {
         return FALSE;
     }
     switch (type) {
     case SPICE_MSGC_RECORD_DATA:
-        return snd_record_handle_write((RecordChannelClient *)channel, size, message);
+        return snd_record_handle_write((RecordChannelClient *)client, size, message);
     case SPICE_MSGC_RECORD_MODE: {
         SpiceMsgcRecordMode *mode = (SpiceMsgcRecordMode *)message;
-        SndWorker *worker = channel->worker;
+        SndWorker *worker = client->worker;
         record_client->mode_time = mode->time;
         if (mode->mode != SPICE_AUDIO_DATA_MODE_RAW) {
             if (snd_codec_is_capable(mode->mode, worker->frequency)) {
@@ -420,24 +420,24 @@  static int snd_record_handle_message(SndChannelClient *channel, size_t size, uin
     return TRUE;
 }
 
-static void snd_receive(SndChannelClient *channel)
+static void snd_receive(SndChannelClient *client)
 {
     SpiceDataHeaderOpaque *header;
 
-    if (!channel) {
+    if (!client) {
         return;
     }
 
-    header = &channel->channel_client->incoming.header;
+    header = &client->channel_client->incoming.header;
 
     for (;;) {
         ssize_t n;
-        n = channel->receive_data.end - channel->receive_data.now;
+        n = client->receive_data.end - client->receive_data.now;
         spice_warn_if_fail(n > 0);
-        n = reds_stream_read(channel->stream, channel->receive_data.now, n);
+        n = reds_stream_read(client->stream, client->receive_data.now, n);
         if (n <= 0) {
             if (n == 0) {
-                snd_disconnect_channel(channel);
+                snd_disconnect_channel(client);
                 return;
             }
             spice_assert(n == -1);
@@ -447,54 +447,54 @@  static void snd_receive(SndChannelClient *channel)
             case EINTR:
                 break;
             case EPIPE:
-                snd_disconnect_channel(channel);
+                snd_disconnect_channel(client);
                 return;
             default:
                 spice_printerr("%s", strerror(errno));
-                snd_disconnect_channel(channel);
+                snd_disconnect_channel(client);
                 return;
             }
         } else {
-            channel->receive_data.now += n;
+            client->receive_data.now += n;
             for (;;) {
-                uint8_t *msg_start = channel->receive_data.message_start;
+                uint8_t *msg_start = client->receive_data.message_start;
                 uint8_t *data = msg_start + header->header_size;
                 size_t parsed_size;
                 uint8_t *parsed;
                 message_destructor_t parsed_free;
 
                 header->data = msg_start;
-                n = channel->receive_data.now - msg_start;
+                n = client->receive_data.now - msg_start;
 
                 if (n < header->header_size ||
                     n < header->header_size + header->get_msg_size(header)) {
                     break;
                 }
-                parsed = channel->parser((void *)data, data + header->get_msg_size(header),
+                parsed = client->parser((void *)data, data + header->get_msg_size(header),
                                          header->get_msg_type(header),
                                          SPICE_VERSION_MINOR, &parsed_size, &parsed_free);
                 if (parsed == NULL) {
                     spice_printerr("failed to parse message type %d", header->get_msg_type(header));
-                    snd_disconnect_channel(channel);
+                    snd_disconnect_channel(client);
                     return;
                 }
-                if (!channel->handle_message(channel, parsed_size,
+                if (!client->handle_message(client, parsed_size,
                                              header->get_msg_type(header), parsed)) {
                     free(parsed);
-                    snd_disconnect_channel(channel);
+                    snd_disconnect_channel(client);
                     return;
                 }
                 parsed_free(parsed);
-                channel->receive_data.message_start = msg_start + header->header_size +
+                client->receive_data.message_start = msg_start + header->header_size +
                                                      header->get_msg_size(header);
             }
-            if (channel->receive_data.now == channel->receive_data.message_start) {
-                channel->receive_data.now = channel->receive_data.buf;
-                channel->receive_data.message_start = channel->receive_data.buf;
-            } else if (channel->receive_data.now == channel->receive_data.end) {
-                memcpy(channel->receive_data.buf, channel->receive_data.message_start, n);
-                channel->receive_data.now = channel->receive_data.buf + n;
-                channel->receive_data.message_start = channel->receive_data.buf;
+            if (client->receive_data.now == client->receive_data.message_start) {
+                client->receive_data.now = client->receive_data.buf;
+                client->receive_data.message_start = client->receive_data.buf;
+            } else if (client->receive_data.now == client->receive_data.end) {
+                memcpy(client->receive_data.buf, client->receive_data.message_start, n);
+                client->receive_data.now = client->receive_data.buf + n;
+                client->receive_data.message_start = client->receive_data.buf;
             }
         }
     }
@@ -502,93 +502,93 @@  static void snd_receive(SndChannelClient *channel)
 
 static void snd_event(int fd, int event, void *data)
 {
-    SndChannelClient *channel = data;
+    SndChannelClient *client = data;
 
     if (event & SPICE_WATCH_EVENT_READ) {
-        snd_receive(channel);
+        snd_receive(client);
     }
     if (event & SPICE_WATCH_EVENT_WRITE) {
-        channel->send_messages(channel);
+        client->send_messages(client);
     }
 }
 
-static inline int snd_reset_send_data(SndChannelClient *channel, uint16_t verb)
+static inline int snd_reset_send_data(SndChannelClient *client, uint16_t verb)
 {
     SpiceDataHeaderOpaque *header;
 
-    if (!channel) {
+    if (!client) {
         return FALSE;
     }
 
-    header = &channel->channel_client->priv->send_data.header;
-    spice_marshaller_reset(channel->send_data.marshaller);
-    header->data = spice_marshaller_reserve_space(channel->send_data.marshaller,
+    header = &client->channel_client->priv->send_data.header;
+    spice_marshaller_reset(client->send_data.marshaller);
+    header->data = spice_marshaller_reserve_space(client->send_data.marshaller,
                                                   header->header_size);
-    spice_marshaller_set_base(channel->send_data.marshaller,
+    spice_marshaller_set_base(client->send_data.marshaller,
                               header->header_size);
-    channel->send_data.pos = 0;
+    client->send_data.pos = 0;
     header->set_msg_size(header, 0);
     header->set_msg_type(header, verb);
-    channel->send_data.serial++;
-    if (!channel->channel_client->priv->is_mini_header) {
-        header->set_msg_serial(header, channel->send_data.serial);
+    client->send_data.serial++;
+    if (!client->channel_client->priv->is_mini_header) {
+        header->set_msg_serial(header, client->send_data.serial);
         header->set_msg_sub_list(header, 0);
     }
 
     return TRUE;
 }
 
-static int snd_begin_send_message(SndChannelClient *channel)
+static int snd_begin_send_message(SndChannelClient *client)
 {
-    SpiceDataHeaderOpaque *header = &channel->channel_client->priv->send_data.header;
+    SpiceDataHeaderOpaque *header = &client->channel_client->priv->send_data.header;
 
-    spice_marshaller_flush(channel->send_data.marshaller);
-    channel->send_data.size = spice_marshaller_get_total_size(channel->send_data.marshaller);
-    header->set_msg_size(header, channel->send_data.size - header->header_size);
-    return snd_send_data(channel);
+    spice_marshaller_flush(client->send_data.marshaller);
+    client->send_data.size = spice_marshaller_get_total_size(client->send_data.marshaller);
+    header->set_msg_size(header, client->send_data.size - header->header_size);
+    return snd_send_data(client);
 }
 
-static int snd_channel_send_migrate(SndChannelClient *channel)
+static int snd_channel_send_migrate(SndChannelClient *client)
 {
     SpiceMsgMigrate migrate;
 
-    if (!snd_reset_send_data(channel, SPICE_MSG_MIGRATE)) {
+    if (!snd_reset_send_data(client, SPICE_MSG_MIGRATE)) {
         return FALSE;
     }
     spice_debug(NULL);
     migrate.flags = 0;
-    spice_marshall_msg_migrate(channel->send_data.marshaller, &migrate);
+    spice_marshall_msg_migrate(client->send_data.marshaller, &migrate);
 
-    return snd_begin_send_message(channel);
+    return snd_begin_send_message(client);
 }
 
-static int snd_playback_send_migrate(PlaybackChannelClient *channel)
+static int snd_playback_send_migrate(PlaybackChannelClient *client)
 {
-    return snd_channel_send_migrate(&channel->base);
+    return snd_channel_send_migrate(&client->base);
 }
 
-static int snd_send_volume(SndChannelClient *channel, uint32_t cap, int msg)
+static int snd_send_volume(SndChannelClient *client, uint32_t cap, int msg)
 {
     SpiceMsgAudioVolume *vol;
     uint8_t c;
-    SpiceVolumeState *st = &channel->worker->volume;
+    SpiceVolumeState *st = &client->worker->volume;
 
-    if (!red_channel_client_test_remote_cap(channel->channel_client, cap)) {
+    if (!red_channel_client_test_remote_cap(client->channel_client, cap)) {
         return TRUE;
     }
 
     vol = alloca(sizeof (SpiceMsgAudioVolume) +
                  st->volume_nchannels * sizeof (uint16_t));
-    if (!snd_reset_send_data(channel, msg)) {
+    if (!snd_reset_send_data(client, msg)) {
         return FALSE;
     }
     vol->nchannels = st->volume_nchannels;
     for (c = 0; c < st->volume_nchannels; ++c) {
         vol->volume[c] = st->volume[c];
     }
-    spice_marshall_SpiceMsgAudioVolume(channel->send_data.marshaller, vol);
+    spice_marshall_SpiceMsgAudioVolume(client->send_data.marshaller, vol);
 
-    return snd_begin_send_message(channel);
+    return snd_begin_send_message(client);
 }
 
 static int snd_playback_send_volume(PlaybackChannelClient *playback_client)
@@ -597,22 +597,22 @@  static int snd_playback_send_volume(PlaybackChannelClient *playback_client)
                            SPICE_MSG_PLAYBACK_VOLUME);
 }
 
-static int snd_send_mute(SndChannelClient *channel, uint32_t cap, int msg)
+static int snd_send_mute(SndChannelClient *client, uint32_t cap, int msg)
 {
     SpiceMsgAudioMute mute;
-    SpiceVolumeState *st = &channel->worker->volume;
+    SpiceVolumeState *st = &client->worker->volume;
 
-    if (!red_channel_client_test_remote_cap(channel->channel_client, cap)) {
+    if (!red_channel_client_test_remote_cap(client->channel_client, cap)) {
         return TRUE;
     }
 
-    if (!snd_reset_send_data(channel, msg)) {
+    if (!snd_reset_send_data(client, msg)) {
         return FALSE;
     }
     mute.mute = st->mute;
-    spice_marshall_SpiceMsgAudioMute(channel->send_data.marshaller, &mute);
+    spice_marshall_SpiceMsgAudioMute(client->send_data.marshaller, &mute);
 
-    return snd_begin_send_message(channel);
+    return snd_begin_send_message(client);
 }
 
 static int snd_playback_send_mute(PlaybackChannelClient *playback_client)
@@ -623,53 +623,53 @@  static int snd_playback_send_mute(PlaybackChannelClient *playback_client)
 
 static int snd_playback_send_latency(PlaybackChannelClient *playback_client)
 {
-    SndChannelClient *channel = &playback_client->base;
+    SndChannelClient *client = &playback_client->base;
     SpiceMsgPlaybackLatency latency_msg;
 
     spice_debug("latency %u", playback_client->latency);
-    if (!snd_reset_send_data(channel, SPICE_MSG_PLAYBACK_LATENCY)) {
+    if (!snd_reset_send_data(client, SPICE_MSG_PLAYBACK_LATENCY)) {
         return FALSE;
     }
     latency_msg.latency_ms = playback_client->latency;
-    spice_marshall_msg_playback_latency(channel->send_data.marshaller, &latency_msg);
+    spice_marshall_msg_playback_latency(client->send_data.marshaller, &latency_msg);
 
-    return snd_begin_send_message(channel);
+    return snd_begin_send_message(client);
 }
 static int snd_playback_send_start(PlaybackChannelClient *playback_client)
 {
-    SndChannelClient *channel = (SndChannelClient *)playback_client;
+    SndChannelClient *client = (SndChannelClient *)playback_client;
     SpiceMsgPlaybackStart start;
 
-    if (!snd_reset_send_data(channel, SPICE_MSG_PLAYBACK_START)) {
+    if (!snd_reset_send_data(client, SPICE_MSG_PLAYBACK_START)) {
         return FALSE;
     }
 
     start.channels = SPICE_INTERFACE_PLAYBACK_CHAN;
-    start.frequency = channel->worker->frequency;
+    start.frequency = client->worker->frequency;
     spice_assert(SPICE_INTERFACE_PLAYBACK_FMT == SPICE_INTERFACE_AUDIO_FMT_S16);
     start.format = SPICE_AUDIO_FMT_S16;
     start.time = reds_get_mm_time();
-    spice_marshall_msg_playback_start(channel->send_data.marshaller, &start);
+    spice_marshall_msg_playback_start(client->send_data.marshaller, &start);
 
-    return snd_begin_send_message(channel);
+    return snd_begin_send_message(client);
 }
 
 static int snd_playback_send_stop(PlaybackChannelClient *playback_client)
 {
-    SndChannelClient *channel = (SndChannelClient *)playback_client;
+    SndChannelClient *client = (SndChannelClient *)playback_client;
 
-    if (!snd_reset_send_data(channel, SPICE_MSG_PLAYBACK_STOP)) {
+    if (!snd_reset_send_data(client, SPICE_MSG_PLAYBACK_STOP)) {
         return FALSE;
     }
 
-    return snd_begin_send_message(channel);
+    return snd_begin_send_message(client);
 }
 
 static int snd_playback_send_ctl(PlaybackChannelClient *playback_client)
 {
-    SndChannelClient *channel = (SndChannelClient *)playback_client;
+    SndChannelClient *client = (SndChannelClient *)playback_client;
 
-    if ((channel->client_active = channel->active)) {
+    if ((client->client_active = client->active)) {
         return snd_playback_send_start(playback_client);
     } else {
         return snd_playback_send_stop(playback_client);
@@ -678,38 +678,38 @@  static int snd_playback_send_ctl(PlaybackChannelClient *playback_client)
 
 static int snd_record_send_start(RecordChannelClient *record_client)
 {
-    SndChannelClient *channel = (SndChannelClient *)record_client;
+    SndChannelClient *client = (SndChannelClient *)record_client;
     SpiceMsgRecordStart start;
 
-    if (!snd_reset_send_data(channel, SPICE_MSG_RECORD_START)) {
+    if (!snd_reset_send_data(client, SPICE_MSG_RECORD_START)) {
         return FALSE;
     }
 
     start.channels = SPICE_INTERFACE_RECORD_CHAN;
-    start.frequency = channel->worker->frequency;
+    start.frequency = client->worker->frequency;
     spice_assert(SPICE_INTERFACE_RECORD_FMT == SPICE_INTERFACE_AUDIO_FMT_S16);
     start.format = SPICE_AUDIO_FMT_S16;
-    spice_marshall_msg_record_start(channel->send_data.marshaller, &start);
+    spice_marshall_msg_record_start(client->send_data.marshaller, &start);
 
-    return snd_begin_send_message(channel);
+    return snd_begin_send_message(client);
 }
 
 static int snd_record_send_stop(RecordChannelClient *record_client)
 {
-    SndChannelClient *channel = (SndChannelClient *)record_client;
+    SndChannelClient *client = (SndChannelClient *)record_client;
 
-    if (!snd_reset_send_data(channel, SPICE_MSG_RECORD_STOP)) {
+    if (!snd_reset_send_data(client, SPICE_MSG_RECORD_STOP)) {
         return FALSE;
     }
 
-    return snd_begin_send_message(channel);
+    return snd_begin_send_message(client);
 }
 
 static int snd_record_send_ctl(RecordChannelClient *record_client)
 {
-    SndChannelClient *channel = (SndChannelClient *)record_client;
+    SndChannelClient *client = (SndChannelClient *)record_client;
 
-    if ((channel->client_active = channel->active)) {
+    if ((client->client_active = client->active)) {
         return snd_record_send_start(record_client);
     } else {
         return snd_record_send_stop(record_client);
@@ -739,21 +739,21 @@  static int snd_record_send_migrate(RecordChannelClient *record_client)
 
 static int snd_playback_send_write(PlaybackChannelClient *playback_client)
 {
-    SndChannelClient *channel = (SndChannelClient *)playback_client;
+    SndChannelClient *client = (SndChannelClient *)playback_client;
     AudioFrame *frame;
     SpiceMsgPlaybackPacket msg;
 
-    if (!snd_reset_send_data(channel, SPICE_MSG_PLAYBACK_DATA)) {
+    if (!snd_reset_send_data(client, SPICE_MSG_PLAYBACK_DATA)) {
         return FALSE;
     }
 
     frame = playback_client->in_progress;
     msg.time = frame->time;
 
-    spice_marshall_msg_playback_data(channel->send_data.marshaller, &msg);
+    spice_marshall_msg_playback_data(client->send_data.marshaller, &msg);
 
     if (playback_client->mode == SPICE_AUDIO_DATA_MODE_RAW) {
-        spice_marshaller_add_ref(channel->send_data.marshaller,
+        spice_marshaller_add_ref(client->send_data.marshaller,
                                  (uint8_t *)frame->samples,
                                  snd_codec_frame_size(playback_client->codec) * sizeof(frame->samples[0]));
     }
@@ -763,80 +763,80 @@  static int snd_playback_send_write(PlaybackChannelClient *playback_client)
                                     snd_codec_frame_size(playback_client->codec) * sizeof(frame->samples[0]),
                                     playback_client->encode_buf, &n) != SND_CODEC_OK) {
             spice_printerr("encode failed");
-            snd_disconnect_channel(channel);
+            snd_disconnect_channel(client);
             return FALSE;
         }
-        spice_marshaller_add_ref(channel->send_data.marshaller, playback_client->encode_buf, n);
+        spice_marshaller_add_ref(client->send_data.marshaller, playback_client->encode_buf, n);
     }
 
-    return snd_begin_send_message(channel);
+    return snd_begin_send_message(client);
 }
 
 static int playback_send_mode(PlaybackChannelClient *playback_client)
 {
-    SndChannelClient *channel = (SndChannelClient *)playback_client;
+    SndChannelClient *client = (SndChannelClient *)playback_client;
     SpiceMsgPlaybackMode mode;
 
-    if (!snd_reset_send_data(channel, SPICE_MSG_PLAYBACK_MODE)) {
+    if (!snd_reset_send_data(client, SPICE_MSG_PLAYBACK_MODE)) {
         return FALSE;
     }
     mode.time = reds_get_mm_time();
     mode.mode = playback_client->mode;
-    spice_marshall_msg_playback_mode(channel->send_data.marshaller, &mode);
+    spice_marshall_msg_playback_mode(client->send_data.marshaller, &mode);
 
-    return snd_begin_send_message(channel);
+    return snd_begin_send_message(client);
 }
 
 static void snd_playback_send(void* data)
 {
     PlaybackChannelClient *playback_client = (PlaybackChannelClient*)data;
-    SndChannelClient *channel = (SndChannelClient*)playback_client;
+    SndChannelClient *client = (SndChannelClient*)playback_client;
 
     if (!playback_client || !snd_send_data(data)) {
         return;
     }
 
-    while (channel->command) {
-        if (channel->command & SND_PLAYBACK_MODE_MASK) {
+    while (client->command) {
+        if (client->command & SND_PLAYBACK_MODE_MASK) {
             if (!playback_send_mode(playback_client)) {
                 return;
             }
-            channel->command &= ~SND_PLAYBACK_MODE_MASK;
+            client->command &= ~SND_PLAYBACK_MODE_MASK;
         }
-        if (channel->command & SND_PLAYBACK_PCM_MASK) {
+        if (client->command & SND_PLAYBACK_PCM_MASK) {
             spice_assert(!playback_client->in_progress && playback_client->pending_frame);
             playback_client->in_progress = playback_client->pending_frame;
             playback_client->pending_frame = NULL;
-            channel->command &= ~SND_PLAYBACK_PCM_MASK;
+            client->command &= ~SND_PLAYBACK_PCM_MASK;
             if (!snd_playback_send_write(playback_client)) {
                 spice_printerr("snd_send_playback_write failed");
                 return;
             }
         }
-        if (channel->command & SND_CTRL_MASK) {
+        if (client->command & SND_CTRL_MASK) {
             if (!snd_playback_send_ctl(playback_client)) {
                 return;
             }
-            channel->command &= ~SND_CTRL_MASK;
+            client->command &= ~SND_CTRL_MASK;
         }
-        if (channel->command & SND_VOLUME_MASK) {
+        if (client->command & SND_VOLUME_MASK) {
             if (!snd_playback_send_volume(playback_client) ||
                 !snd_playback_send_mute(playback_client)) {
                 return;
             }
-            channel->command &= ~SND_VOLUME_MASK;
+            client->command &= ~SND_VOLUME_MASK;
         }
-        if (channel->command & SND_MIGRATE_MASK) {
+        if (client->command & SND_MIGRATE_MASK) {
             if (!snd_playback_send_migrate(playback_client)) {
                 return;
             }
-            channel->command &= ~SND_MIGRATE_MASK;
+            client->command &= ~SND_MIGRATE_MASK;
         }
-        if (channel->command & SND_PLAYBACK_LATENCY_MASK) {
+        if (client->command & SND_PLAYBACK_LATENCY_MASK) {
             if (!snd_playback_send_latency(playback_client)) {
                 return;
             }
-            channel->command &= ~SND_PLAYBACK_LATENCY_MASK;
+            client->command &= ~SND_PLAYBACK_LATENCY_MASK;
         }
     }
 }
@@ -844,37 +844,37 @@  static void snd_playback_send(void* data)
 static void snd_record_send(void* data)
 {
     RecordChannelClient *record_client = (RecordChannelClient*)data;
-    SndChannelClient *channel = (SndChannelClient*)record_client;
+    SndChannelClient *client = (SndChannelClient*)record_client;
 
     if (!record_client || !snd_send_data(data)) {
         return;
     }
 
-    while (channel->command) {
-        if (channel->command & SND_CTRL_MASK) {
+    while (client->command) {
+        if (client->command & SND_CTRL_MASK) {
             if (!snd_record_send_ctl(record_client)) {
                 return;
             }
-            channel->command &= ~SND_CTRL_MASK;
+            client->command &= ~SND_CTRL_MASK;
         }
-        if (channel->command & SND_VOLUME_MASK) {
+        if (client->command & SND_VOLUME_MASK) {
             if (!snd_record_send_volume(record_client) ||
                 !snd_record_send_mute(record_client)) {
                 return;
             }
-            channel->command &= ~SND_VOLUME_MASK;
+            client->command &= ~SND_VOLUME_MASK;
         }
-        if (channel->command & SND_MIGRATE_MASK) {
+        if (client->command & SND_MIGRATE_MASK) {
             if (!snd_record_send_migrate(record_client)) {
                 return;
             }
-            channel->command &= ~SND_MIGRATE_MASK;
+            client->command &= ~SND_MIGRATE_MASK;
         }
     }
 }
 
 static SndChannelClient *__new_channel(SndWorker *worker, int size, uint32_t channel_id,
-                                 RedClient *client,
+                                 RedClient *red_client,
                                  RedsStream *stream,
                                  int migrate,
                                  snd_channel_send_messages_proc send_messages,
@@ -884,14 +884,14 @@  static SndChannelClient *__new_channel(SndWorker *worker, int size, uint32_t cha
                                  uint32_t *common_caps, int num_common_caps,
                                  uint32_t *caps, int num_caps)
 {
-    SndChannelClient *channel;
+    SndChannelClient *client;
     int delay_val;
     int flags;
 #ifdef SO_PRIORITY
     int priority;
 #endif
     int tos;
-    MainChannelClient *mcc = red_client_get_main(client);
+    MainChannelClient *mcc = red_client_get_main(red_client);
     RedsState *reds = red_channel_get_server(worker->base_channel);
 
     spice_assert(stream);
@@ -929,39 +929,39 @@  static SndChannelClient *__new_channel(SndWorker *worker, int size, uint32_t cha
         goto error1;
     }
 
-    spice_assert(size >= sizeof(*channel));
-    channel = spice_malloc0(size);
-    channel->refs = 1;
-    channel->parser = spice_get_client_channel_parser(channel_id, NULL);
-    channel->stream = stream;
-    channel->worker = worker;
-    channel->receive_data.message_start = channel->receive_data.buf;
-    channel->receive_data.now = channel->receive_data.buf;
-    channel->receive_data.end = channel->receive_data.buf + sizeof(channel->receive_data.buf);
-    channel->send_data.marshaller = spice_marshaller_new();
+    spice_assert(size >= sizeof(*client));
+    client = spice_malloc0(size);
+    client->refs = 1;
+    client->parser = spice_get_client_channel_parser(channel_id, NULL);
+    client->stream = stream;
+    client->worker = worker;
+    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);
+    client->send_data.marshaller = spice_marshaller_new();
 
     stream->watch = reds_core_watch_add(reds, stream->socket, SPICE_WATCH_EVENT_READ,
-                                        snd_event, channel);
+                                        snd_event, client);
     if (stream->watch == NULL) {
         spice_printerr("watch_add failed, %s", strerror(errno));
         goto error2;
     }
 
-    channel->send_messages = send_messages;
-    channel->handle_message = handle_message;
-    channel->on_message_done = on_message_done;
-    channel->cleanup = cleanup;
+    client->send_messages = send_messages;
+    client->handle_message = handle_message;
+    client->on_message_done = on_message_done;
+    client->cleanup = cleanup;
 
-    channel->channel_client =
-        dummy_channel_client_create(worker->base_channel, client,
+    client->channel_client =
+        dummy_channel_client_create(worker->base_channel, red_client,
                                     num_common_caps, common_caps, num_caps, caps);
-    if (!channel->channel_client) {
+    if (!client->channel_client) {
         goto error2;
     }
-    return channel;
+    return client;
 
 error2:
-    free(channel);
+    free(client);
 
 error1:
     reds_stream_free(stream);
@@ -986,12 +986,12 @@  static void snd_disconnect_channel_client(RedChannelClient *rcc)
     }
 }
 
-static void snd_set_command(SndChannelClient *channel, uint32_t command)
+static void snd_set_command(SndChannelClient *client, uint32_t command)
 {
-    if (!channel) {
+    if (!client) {
         return;
     }
-    channel->command |= command;
+    client->command |= command;
 }
 
 SPICE_GNUC_VISIBLE void spice_server_playback_set_volume(SpicePlaybackInstance *sin,
@@ -999,14 +999,14 @@  SPICE_GNUC_VISIBLE void spice_server_playback_set_volume(SpicePlaybackInstance *
                                                   uint16_t *volume)
 {
     SpiceVolumeState *st = &sin->st->worker.volume;
-    SndChannelClient *channel = sin->st->worker.connection;
-    PlaybackChannelClient *playback_client = SPICE_CONTAINEROF(channel, PlaybackChannelClient, base);
+    SndChannelClient *client = sin->st->worker.connection;
+    PlaybackChannelClient *playback_client = SPICE_CONTAINEROF(client, PlaybackChannelClient, base);
 
     st->volume_nchannels = nchannels;
     free(st->volume);
     st->volume = spice_memdup(volume, sizeof(uint16_t) * nchannels);
 
-    if (!channel || nchannels == 0)
+    if (!client || nchannels == 0)
         return;
 
     snd_playback_send_volume(playback_client);
@@ -1015,12 +1015,12 @@  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 *channel = sin->st->worker.connection;
-    PlaybackChannelClient *playback_client = SPICE_CONTAINEROF(channel, PlaybackChannelClient, base);
+    SndChannelClient *client = sin->st->worker.connection;
+    PlaybackChannelClient *playback_client = SPICE_CONTAINEROF(client, PlaybackChannelClient, base);
 
     st->mute = mute;
 
-    if (!channel)
+    if (!client)
         return;
 
     snd_playback_send_mute(playback_client);
@@ -1028,19 +1028,19 @@  SPICE_GNUC_VISIBLE void spice_server_playback_set_mute(SpicePlaybackInstance *si
 
 static void snd_playback_start(SndWorker *worker)
 {
-    SndChannelClient *channel = worker->connection;
+    SndChannelClient *client = worker->connection;
 
     worker->active = 1;
-    if (!channel)
+    if (!client)
         return;
-    spice_assert(!channel->active);
-    reds_disable_mm_time(snd_channel_get_server(channel));
-    channel->active = TRUE;
-    if (!channel->client_active) {
-        snd_set_command(channel, SND_CTRL_MASK);
-        snd_playback_send(channel);
+    spice_assert(!client->active);
+    reds_disable_mm_time(snd_channel_get_server(client));
+    client->active = TRUE;
+    if (!client->client_active) {
+        snd_set_command(client, SND_CTRL_MASK);
+        snd_playback_send(client);
     } else {
-        channel->command &= ~SND_CTRL_MASK;
+        client->command &= ~SND_CTRL_MASK;
     }
 }
 
@@ -1051,14 +1051,14 @@  SPICE_GNUC_VISIBLE void spice_server_playback_start(SpicePlaybackInstance *sin)
 
 SPICE_GNUC_VISIBLE void spice_server_playback_stop(SpicePlaybackInstance *sin)
 {
-    SndChannelClient *channel = sin->st->worker.connection;
-    PlaybackChannelClient *playback_client = SPICE_CONTAINEROF(channel, PlaybackChannelClient, base);
+    SndChannelClient *client = sin->st->worker.connection;
+    PlaybackChannelClient *playback_client = SPICE_CONTAINEROF(client, PlaybackChannelClient, base);
 
     sin->st->worker.active = 0;
-    if (!channel)
+    if (!client)
         return;
     spice_assert(playback_client->base.active);
-    reds_enable_mm_time(snd_channel_get_server(channel));
+    reds_enable_mm_time(snd_channel_get_server(client));
     playback_client->base.active = FALSE;
     if (playback_client->base.client_active) {
         snd_set_command(&playback_client->base, SND_CTRL_MASK);
@@ -1079,16 +1079,16 @@  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 *channel = sin->st->worker.connection;
-    PlaybackChannelClient *playback_client = SPICE_CONTAINEROF(channel, PlaybackChannelClient, base);
+    SndChannelClient *client = sin->st->worker.connection;
+    PlaybackChannelClient *playback_client = SPICE_CONTAINEROF(client, PlaybackChannelClient, base);
 
-    if (!channel || !playback_client->free_frames) {
+    if (!client || !playback_client->free_frames) {
         *frame = NULL;
         *num_samples = 0;
         return;
     }
     spice_assert(playback_client->base.active);
-    snd_channel_ref(channel);
+    snd_channel_ref(client);
 
     *frame = playback_client->free_frames->samples;
     playback_client->free_frames = playback_client->free_frames->next;
@@ -1101,12 +1101,12 @@  SPICE_GNUC_VISIBLE void spice_server_playback_put_samples(SpicePlaybackInstance 
     AudioFrame *frame;
 
     frame = SPICE_CONTAINEROF(samples, AudioFrame, samples[0]);
-    playback_client = frame->channel;
+    playback_client = frame->client;
     spice_assert(playback_client);
     if (!snd_channel_unref(&playback_client->base) ||
         sin->st->worker.connection != &playback_client->base) {
-        /* lost last reference, channel has been destroyed previously */
-        spice_info("audio samples belong to a disconnected channel");
+        /* lost last reference, client has been destroyed previously */
+        spice_info("audio samples belong to a disconnected client");
         return;
     }
     spice_assert(playback_client->base.active);
@@ -1178,12 +1178,12 @@  static void on_new_playback_channel(SndWorker *worker, SndChannelClient *snd_cha
     }
 }
 
-static void snd_playback_cleanup(SndChannelClient *channel)
+static void snd_playback_cleanup(SndChannelClient *client)
 {
-    PlaybackChannelClient *playback_client = SPICE_CONTAINEROF(channel, PlaybackChannelClient, base);
+    PlaybackChannelClient *playback_client = SPICE_CONTAINEROF(client, PlaybackChannelClient, base);
 
     if (playback_client->base.active) {
-        reds_enable_mm_time(snd_channel_get_server(channel));
+        reds_enable_mm_time(snd_channel_get_server(client));
     }
 
     snd_codec_destroy(&playback_client->codec);
@@ -1266,14 +1266,14 @@  SPICE_GNUC_VISIBLE void spice_server_record_set_volume(SpiceRecordInstance *sin,
                                                 uint16_t *volume)
 {
     SpiceVolumeState *st = &sin->st->worker.volume;
-    SndChannelClient *channel = sin->st->worker.connection;
-    RecordChannelClient *record_client = SPICE_CONTAINEROF(channel, RecordChannelClient, base);
+    SndChannelClient *client = sin->st->worker.connection;
+    RecordChannelClient *record_client = SPICE_CONTAINEROF(client, RecordChannelClient, base);
 
     st->volume_nchannels = nchannels;
     free(st->volume);
     st->volume = spice_memdup(volume, sizeof(uint16_t) * nchannels);
 
-    if (!channel || nchannels == 0)
+    if (!client || nchannels == 0)
         return;
 
     snd_record_send_volume(record_client);
@@ -1282,12 +1282,12 @@  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 *channel = sin->st->worker.connection;
-    RecordChannelClient *record_client = SPICE_CONTAINEROF(channel, RecordChannelClient, base);
+    SndChannelClient *client = sin->st->worker.connection;
+    RecordChannelClient *record_client = SPICE_CONTAINEROF(client, RecordChannelClient, base);
 
     st->mute = mute;
 
-    if (!channel)
+    if (!client)
         return;
 
     snd_record_send_mute(record_client);
@@ -1295,21 +1295,21 @@  SPICE_GNUC_VISIBLE void spice_server_record_set_mute(SpiceRecordInstance *sin, u
 
 static void snd_record_start(SndWorker *worker)
 {
-    SndChannelClient *channel = worker->connection;
-    RecordChannelClient *record_client = SPICE_CONTAINEROF(channel, RecordChannelClient, base);
+    SndChannelClient *client = worker->connection;
+    RecordChannelClient *record_client = SPICE_CONTAINEROF(client, RecordChannelClient, base);
 
     worker->active = 1;
-    if (!channel)
+    if (!client)
         return;
-    spice_assert(!channel->active);
+    spice_assert(!client->active);
     record_client->read_pos = record_client->write_pos = 0;   //todo: improve by
                                                                 //stream generation
-    channel->active = TRUE;
-    if (!channel->client_active) {
-        snd_set_command(channel, SND_CTRL_MASK);
-        snd_record_send(channel);
+    client->active = TRUE;
+    if (!client->client_active) {
+        snd_set_command(client, SND_CTRL_MASK);
+        snd_record_send(client);
     } else {
-        channel->command &= ~SND_CTRL_MASK;
+        client->command &= ~SND_CTRL_MASK;
     }
 }
 
@@ -1320,11 +1320,11 @@  SPICE_GNUC_VISIBLE void spice_server_record_start(SpiceRecordInstance *sin)
 
 SPICE_GNUC_VISIBLE void spice_server_record_stop(SpiceRecordInstance *sin)
 {
-    SndChannelClient *channel = sin->st->worker.connection;
-    RecordChannelClient *record_client = SPICE_CONTAINEROF(channel, RecordChannelClient, base);
+    SndChannelClient *client = sin->st->worker.connection;
+    RecordChannelClient *record_client = SPICE_CONTAINEROF(client, RecordChannelClient, base);
 
     sin->st->worker.active = 0;
-    if (!channel)
+    if (!client)
         return;
     spice_assert(record_client->base.active);
     record_client->base.active = FALSE;
@@ -1339,13 +1339,13 @@  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 *channel = sin->st->worker.connection;
-    RecordChannelClient *record_client = SPICE_CONTAINEROF(channel, RecordChannelClient, base);
+    SndChannelClient *client = sin->st->worker.connection;
+    RecordChannelClient *record_client = SPICE_CONTAINEROF(client, RecordChannelClient, base);
     uint32_t read_pos;
     uint32_t now;
     uint32_t len;
 
-    if (!channel)
+    if (!client)
         return 0;
     spice_assert(record_client->base.active);
 
@@ -1374,11 +1374,11 @@  SPICE_GNUC_VISIBLE uint32_t spice_server_record_get_samples(SpiceRecordInstance 
     return len;
 }
 
-static uint32_t snd_get_best_rate(SndChannelClient *channel, uint32_t cap_opus)
+static uint32_t snd_get_best_rate(SndChannelClient *client, uint32_t cap_opus)
 {
     int client_can_opus = TRUE;
-    if (channel) {
-        client_can_opus = red_channel_client_test_remote_cap(channel->channel_client, cap_opus);
+    if (client) {
+        client_can_opus = red_channel_client_test_remote_cap(client->channel_client, cap_opus);
     }
 
     if (client_can_opus && snd_codec_is_capable(SPICE_AUDIO_DATA_MODE_OPUS, SND_CODEC_ANY_FREQUENCY))
@@ -1389,10 +1389,10 @@  static uint32_t snd_get_best_rate(SndChannelClient *channel, uint32_t cap_opus)
 
 static void snd_set_rate(SndWorker *worker, uint32_t frequency, uint32_t cap_opus)
 {
-    RedChannel *channel = worker->base_channel;
+    RedChannel *client = 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);
+    if (client && snd_codec_is_capable(SPICE_AUDIO_DATA_MODE_OPUS, frequency)) {
+        red_channel_set_cap(client, cap_opus);
     }
 }
 
@@ -1429,9 +1429,9 @@  static void on_new_record_channel(SndWorker *worker, SndChannelClient *snd_chann
     }
 }
 
-static void snd_record_cleanup(SndChannelClient *channel)
+static void snd_record_cleanup(SndChannelClient *client)
 {
-    RecordChannelClient *record_client = SPICE_CONTAINEROF(channel, RecordChannelClient, base);
+    RecordChannelClient *record_client = SPICE_CONTAINEROF(client, RecordChannelClient, base);
     snd_codec_destroy(&record_client->codec);
 }
 

Comments

I would split this among the 2nd and 3rd patches..

Christophe

On Tue, Nov 29, 2016 at 02:57:04PM +0000, Frediano Ziglio wrote:
> Due to object rename using channel to store a client is
> quite confusing.
> 
> Signed-off-by: Frediano Ziglio <fziglio@redhat.com>
> ---
>  server/sound.c | 520 +++++++++++++++++++++++++-------------------------
>  1 file changed, 260 insertions(+), 260 deletions(-)
> 
> diff --git a/server/sound.c b/server/sound.c
> index 6c02754..c3bb566 100644
> --- a/server/sound.c
> +++ b/server/sound.c
> @@ -75,13 +75,13 @@ enum PlaybackCommand {
>  
>  typedef struct SndChannelClient SndChannelClient;
>  typedef void (*snd_channel_send_messages_proc)(void *in_channel);
> -typedef int (*snd_channel_handle_message_proc)(SndChannelClient *channel, size_t size, uint32_t type, void *message);
> -typedef void (*snd_channel_on_message_done_proc)(SndChannelClient *channel);
> -typedef void (*snd_channel_cleanup_channel_proc)(SndChannelClient *channel);
> +typedef int (*snd_channel_handle_message_proc)(SndChannelClient *client, size_t size, uint32_t type, void *message);
> +typedef void (*snd_channel_on_message_done_proc)(SndChannelClient *client);
> +typedef void (*snd_channel_cleanup_channel_proc)(SndChannelClient *client);
>  
>  typedef struct SndWorker SndWorker;
>  
> -/* Connects an audio channel to a Spice client */
> +/* Connects an audio client to a Spice client */
>  struct SndChannelClient {
>      RedsStream *stream;
>      SndWorker *worker;
> @@ -122,7 +122,7 @@ typedef struct AudioFrame AudioFrame;
>  struct AudioFrame {
>      uint32_t time;
>      uint32_t samples[SND_CODEC_MAX_FRAME_SIZE];
> -    PlaybackChannelClient *channel;
> +    PlaybackChannelClient *client;
>      AudioFrame *next;
>  };
>  
> @@ -178,135 +178,135 @@ typedef struct RecordChannelClient {
>  /* A list of all Spice{Playback,Record}State objects */
>  static SndWorker *workers;
>  
> -static void snd_receive(SndChannelClient *channel);
> +static void snd_receive(SndChannelClient *client);
>  static void snd_playback_start(SndWorker *worker);
>  static void snd_record_start(SndWorker *worker);
>  
> -static SndChannelClient *snd_channel_ref(SndChannelClient *channel)
> +static SndChannelClient *snd_channel_ref(SndChannelClient *client)
>  {
> -    channel->refs++;
> -    return channel;
> +    client->refs++;
> +    return client;
>  }
>  
> -static SndChannelClient *snd_channel_unref(SndChannelClient *channel)
> +static SndChannelClient *snd_channel_unref(SndChannelClient *client)
>  {
> -    if (!--channel->refs) {
> -        spice_printerr("SndChannelClient=%p freed", channel);
> -        free(channel);
> +    if (!--client->refs) {
> +        spice_printerr("SndChannelClient=%p freed", client);
> +        free(client);
>          return NULL;
>      }
> -    return channel;
> +    return client;
>  }
>  
> -static RedsState* snd_channel_get_server(SndChannelClient *channel)
> +static RedsState* snd_channel_get_server(SndChannelClient *client)
>  {
> -    g_return_val_if_fail(channel != NULL, NULL);
> -    return red_channel_get_server(channel->worker->base_channel);
> +    g_return_val_if_fail(client != NULL, NULL);
> +    return red_channel_get_server(client->worker->base_channel);
>  }
>  
> -static void snd_disconnect_channel(SndChannelClient *channel)
> +static void snd_disconnect_channel(SndChannelClient *client)
>  {
>      SndWorker *worker;
>      RedsState *reds;
>      RedChannel *red_channel;
>      uint32_t type;
>  
> -    if (!channel || !channel->stream) {
> +    if (!client || !client->stream) {
>          spice_debug("not connected");
>          return;
>      }
> -    red_channel = red_channel_client_get_channel(channel->channel_client);
> -    reds = snd_channel_get_server(channel);
> +    red_channel = red_channel_client_get_channel(client->channel_client);
> +    reds = snd_channel_get_server(client);
>      g_object_get(red_channel, "channel-type", &type, NULL);
>      spice_debug("SndChannelClient=%p rcc=%p type=%d",
> -                 channel, channel->channel_client, type);
> -    worker = channel->worker;
> -    channel->cleanup(channel);
> +                 client, client->channel_client, type);
> +    worker = client->worker;
> +    client->cleanup(client);
>      red_channel_client_disconnect(worker->connection->channel_client);
>      worker->connection->channel_client = NULL;
> -    reds_core_watch_remove(reds, channel->stream->watch);
> -    channel->stream->watch = NULL;
> -    reds_stream_free(channel->stream);
> -    channel->stream = NULL;
> -    spice_marshaller_destroy(channel->send_data.marshaller);
> -    snd_channel_unref(channel);
> +    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;
>  }
>  
>  static void snd_playback_free_frame(PlaybackChannelClient *playback_client, AudioFrame *frame)
>  {
> -    frame->channel = playback_client;
> +    frame->client = playback_client;
>      frame->next = playback_client->free_frames;
>      playback_client->free_frames = frame;
>  }
>  
> -static void snd_playback_on_message_done(SndChannelClient *channel)
> +static void snd_playback_on_message_done(SndChannelClient *client)
>  {
> -    PlaybackChannelClient *playback_client = (PlaybackChannelClient *)channel;
> +    PlaybackChannelClient *playback_client = (PlaybackChannelClient *)client;
>      if (playback_client->in_progress) {
>          snd_playback_free_frame(playback_client, playback_client->in_progress);
>          playback_client->in_progress = NULL;
>          if (playback_client->pending_frame) {
> -            channel->command |= SND_PLAYBACK_PCM_MASK;
> +            client->command |= SND_PLAYBACK_PCM_MASK;
>          }
>      }
>  }
>  
> -static void snd_record_on_message_done(SndChannelClient *channel)
> +static void snd_record_on_message_done(SndChannelClient *client)
>  {
>  }
>  
> -static int snd_send_data(SndChannelClient *channel)
> +static int snd_send_data(SndChannelClient *client)
>  {
>      uint32_t n;
>  
> -    if (!channel) {
> +    if (!client) {
>          return FALSE;
>      }
>  
> -    if (!(n = channel->send_data.size - channel->send_data.pos)) {
> +    if (!(n = client->send_data.size - client->send_data.pos)) {
>          return TRUE;
>      }
>  
> -    RedsState *reds = snd_channel_get_server(channel);
> +    RedsState *reds = snd_channel_get_server(client);
>      for (;;) {
>          struct iovec vec[IOV_MAX];
>          int vec_size;
>  
>          if (!n) {
> -            channel->on_message_done(channel);
> +            client->on_message_done(client);
>  
> -            if (channel->blocked) {
> -                channel->blocked = FALSE;
> -                reds_core_watch_update_mask(reds, channel->stream->watch, SPICE_WATCH_EVENT_READ);
> +            if (client->blocked) {
> +                client->blocked = FALSE;
> +                reds_core_watch_update_mask(reds, client->stream->watch, SPICE_WATCH_EVENT_READ);
>              }
>              break;
>          }
>  
> -        vec_size = spice_marshaller_fill_iovec(channel->send_data.marshaller,
> -                                               vec, IOV_MAX, channel->send_data.pos);
> -        n = reds_stream_writev(channel->stream, vec, vec_size);
> +        vec_size = spice_marshaller_fill_iovec(client->send_data.marshaller,
> +                                               vec, IOV_MAX, client->send_data.pos);
> +        n = reds_stream_writev(client->stream, vec, vec_size);
>          if (n == -1) {
>              switch (errno) {
>              case EAGAIN:
> -                channel->blocked = TRUE;
> -                reds_core_watch_update_mask(reds, channel->stream->watch, SPICE_WATCH_EVENT_READ |
> +                client->blocked = TRUE;
> +                reds_core_watch_update_mask(reds, client->stream->watch, SPICE_WATCH_EVENT_READ |
>                                                                   SPICE_WATCH_EVENT_WRITE);
>                  return FALSE;
>              case EINTR:
>                  break;
>              case EPIPE:
> -                snd_disconnect_channel(channel);
> +                snd_disconnect_channel(client);
>                  return FALSE;
>              default:
>                  spice_printerr("%s", strerror(errno));
> -                snd_disconnect_channel(channel);
> +                snd_disconnect_channel(client);
>                  return FALSE;
>              }
>          } else {
> -            channel->send_data.pos += n;
> +            client->send_data.pos += n;
>          }
> -        n = channel->send_data.size - channel->send_data.pos;
> +        n = client->send_data.size - client->send_data.pos;
>      }
>      return TRUE;
>  }
> @@ -356,9 +356,9 @@ static int snd_record_handle_write(RecordChannelClient *record_client, size_t si
>      return TRUE;
>  }
>  
> -static int snd_playback_handle_message(SndChannelClient *channel, size_t size, uint32_t type, void *message)
> +static int snd_playback_handle_message(SndChannelClient *client, size_t size, uint32_t type, void *message)
>  {
> -    if (!channel) {
> +    if (!client) {
>          return FALSE;
>      }
>  
> @@ -372,19 +372,19 @@ static int snd_playback_handle_message(SndChannelClient *channel, size_t size, u
>      return TRUE;
>  }
>  
> -static int snd_record_handle_message(SndChannelClient *channel, size_t size, uint32_t type, void *message)
> +static int snd_record_handle_message(SndChannelClient *client, size_t size, uint32_t type, void *message)
>  {
> -    RecordChannelClient *record_client = (RecordChannelClient *)channel;
> +    RecordChannelClient *record_client = (RecordChannelClient *)client;
>  
> -    if (!channel) {
> +    if (!client) {
>          return FALSE;
>      }
>      switch (type) {
>      case SPICE_MSGC_RECORD_DATA:
> -        return snd_record_handle_write((RecordChannelClient *)channel, size, message);
> +        return snd_record_handle_write((RecordChannelClient *)client, size, message);
>      case SPICE_MSGC_RECORD_MODE: {
>          SpiceMsgcRecordMode *mode = (SpiceMsgcRecordMode *)message;
> -        SndWorker *worker = channel->worker;
> +        SndWorker *worker = client->worker;
>          record_client->mode_time = mode->time;
>          if (mode->mode != SPICE_AUDIO_DATA_MODE_RAW) {
>              if (snd_codec_is_capable(mode->mode, worker->frequency)) {
> @@ -420,24 +420,24 @@ static int snd_record_handle_message(SndChannelClient *channel, size_t size, uin
>      return TRUE;
>  }
>  
> -static void snd_receive(SndChannelClient *channel)
> +static void snd_receive(SndChannelClient *client)
>  {
>      SpiceDataHeaderOpaque *header;
>  
> -    if (!channel) {
> +    if (!client) {
>          return;
>      }
>  
> -    header = &channel->channel_client->incoming.header;
> +    header = &client->channel_client->incoming.header;
>  
>      for (;;) {
>          ssize_t n;
> -        n = channel->receive_data.end - channel->receive_data.now;
> +        n = client->receive_data.end - client->receive_data.now;
>          spice_warn_if_fail(n > 0);
> -        n = reds_stream_read(channel->stream, channel->receive_data.now, n);
> +        n = reds_stream_read(client->stream, client->receive_data.now, n);
>          if (n <= 0) {
>              if (n == 0) {
> -                snd_disconnect_channel(channel);
> +                snd_disconnect_channel(client);
>                  return;
>              }
>              spice_assert(n == -1);
> @@ -447,54 +447,54 @@ static void snd_receive(SndChannelClient *channel)
>              case EINTR:
>                  break;
>              case EPIPE:
> -                snd_disconnect_channel(channel);
> +                snd_disconnect_channel(client);
>                  return;
>              default:
>                  spice_printerr("%s", strerror(errno));
> -                snd_disconnect_channel(channel);
> +                snd_disconnect_channel(client);
>                  return;
>              }
>          } else {
> -            channel->receive_data.now += n;
> +            client->receive_data.now += n;
>              for (;;) {
> -                uint8_t *msg_start = channel->receive_data.message_start;
> +                uint8_t *msg_start = client->receive_data.message_start;
>                  uint8_t *data = msg_start + header->header_size;
>                  size_t parsed_size;
>                  uint8_t *parsed;
>                  message_destructor_t parsed_free;
>  
>                  header->data = msg_start;
> -                n = channel->receive_data.now - msg_start;
> +                n = client->receive_data.now - msg_start;
>  
>                  if (n < header->header_size ||
>                      n < header->header_size + header->get_msg_size(header)) {
>                      break;
>                  }
> -                parsed = channel->parser((void *)data, data + header->get_msg_size(header),
> +                parsed = client->parser((void *)data, data + header->get_msg_size(header),
>                                           header->get_msg_type(header),
>                                           SPICE_VERSION_MINOR, &parsed_size, &parsed_free);
>                  if (parsed == NULL) {
>                      spice_printerr("failed to parse message type %d", header->get_msg_type(header));
> -                    snd_disconnect_channel(channel);
> +                    snd_disconnect_channel(client);
>                      return;
>                  }
> -                if (!channel->handle_message(channel, parsed_size,
> +                if (!client->handle_message(client, parsed_size,
>                                               header->get_msg_type(header), parsed)) {
>                      free(parsed);
> -                    snd_disconnect_channel(channel);
> +                    snd_disconnect_channel(client);
>                      return;
>                  }
>                  parsed_free(parsed);
> -                channel->receive_data.message_start = msg_start + header->header_size +
> +                client->receive_data.message_start = msg_start + header->header_size +
>                                                       header->get_msg_size(header);
>              }
> -            if (channel->receive_data.now == channel->receive_data.message_start) {
> -                channel->receive_data.now = channel->receive_data.buf;
> -                channel->receive_data.message_start = channel->receive_data.buf;
> -            } else if (channel->receive_data.now == channel->receive_data.end) {
> -                memcpy(channel->receive_data.buf, channel->receive_data.message_start, n);
> -                channel->receive_data.now = channel->receive_data.buf + n;
> -                channel->receive_data.message_start = channel->receive_data.buf;
> +            if (client->receive_data.now == client->receive_data.message_start) {
> +                client->receive_data.now = client->receive_data.buf;
> +                client->receive_data.message_start = client->receive_data.buf;
> +            } else if (client->receive_data.now == client->receive_data.end) {
> +                memcpy(client->receive_data.buf, client->receive_data.message_start, n);
> +                client->receive_data.now = client->receive_data.buf + n;
> +                client->receive_data.message_start = client->receive_data.buf;
>              }
>          }
>      }
> @@ -502,93 +502,93 @@ static void snd_receive(SndChannelClient *channel)
>  
>  static void snd_event(int fd, int event, void *data)
>  {
> -    SndChannelClient *channel = data;
> +    SndChannelClient *client = data;
>  
>      if (event & SPICE_WATCH_EVENT_READ) {
> -        snd_receive(channel);
> +        snd_receive(client);
>      }
>      if (event & SPICE_WATCH_EVENT_WRITE) {
> -        channel->send_messages(channel);
> +        client->send_messages(client);
>      }
>  }
>  
> -static inline int snd_reset_send_data(SndChannelClient *channel, uint16_t verb)
> +static inline int snd_reset_send_data(SndChannelClient *client, uint16_t verb)
>  {
>      SpiceDataHeaderOpaque *header;
>  
> -    if (!channel) {
> +    if (!client) {
>          return FALSE;
>      }
>  
> -    header = &channel->channel_client->priv->send_data.header;
> -    spice_marshaller_reset(channel->send_data.marshaller);
> -    header->data = spice_marshaller_reserve_space(channel->send_data.marshaller,
> +    header = &client->channel_client->priv->send_data.header;
> +    spice_marshaller_reset(client->send_data.marshaller);
> +    header->data = spice_marshaller_reserve_space(client->send_data.marshaller,
>                                                    header->header_size);
> -    spice_marshaller_set_base(channel->send_data.marshaller,
> +    spice_marshaller_set_base(client->send_data.marshaller,
>                                header->header_size);
> -    channel->send_data.pos = 0;
> +    client->send_data.pos = 0;
>      header->set_msg_size(header, 0);
>      header->set_msg_type(header, verb);
> -    channel->send_data.serial++;
> -    if (!channel->channel_client->priv->is_mini_header) {
> -        header->set_msg_serial(header, channel->send_data.serial);
> +    client->send_data.serial++;
> +    if (!client->channel_client->priv->is_mini_header) {
> +        header->set_msg_serial(header, client->send_data.serial);
>          header->set_msg_sub_list(header, 0);
>      }
>  
>      return TRUE;
>  }
>  
> -static int snd_begin_send_message(SndChannelClient *channel)
> +static int snd_begin_send_message(SndChannelClient *client)
>  {
> -    SpiceDataHeaderOpaque *header = &channel->channel_client->priv->send_data.header;
> +    SpiceDataHeaderOpaque *header = &client->channel_client->priv->send_data.header;
>  
> -    spice_marshaller_flush(channel->send_data.marshaller);
> -    channel->send_data.size = spice_marshaller_get_total_size(channel->send_data.marshaller);
> -    header->set_msg_size(header, channel->send_data.size - header->header_size);
> -    return snd_send_data(channel);
> +    spice_marshaller_flush(client->send_data.marshaller);
> +    client->send_data.size = spice_marshaller_get_total_size(client->send_data.marshaller);
> +    header->set_msg_size(header, client->send_data.size - header->header_size);
> +    return snd_send_data(client);
>  }
>  
> -static int snd_channel_send_migrate(SndChannelClient *channel)
> +static int snd_channel_send_migrate(SndChannelClient *client)
>  {
>      SpiceMsgMigrate migrate;
>  
> -    if (!snd_reset_send_data(channel, SPICE_MSG_MIGRATE)) {
> +    if (!snd_reset_send_data(client, SPICE_MSG_MIGRATE)) {
>          return FALSE;
>      }
>      spice_debug(NULL);
>      migrate.flags = 0;
> -    spice_marshall_msg_migrate(channel->send_data.marshaller, &migrate);
> +    spice_marshall_msg_migrate(client->send_data.marshaller, &migrate);
>  
> -    return snd_begin_send_message(channel);
> +    return snd_begin_send_message(client);
>  }
>  
> -static int snd_playback_send_migrate(PlaybackChannelClient *channel)
> +static int snd_playback_send_migrate(PlaybackChannelClient *client)
>  {
> -    return snd_channel_send_migrate(&channel->base);
> +    return snd_channel_send_migrate(&client->base);
>  }
>  
> -static int snd_send_volume(SndChannelClient *channel, uint32_t cap, int msg)
> +static int snd_send_volume(SndChannelClient *client, uint32_t cap, int msg)
>  {
>      SpiceMsgAudioVolume *vol;
>      uint8_t c;
> -    SpiceVolumeState *st = &channel->worker->volume;
> +    SpiceVolumeState *st = &client->worker->volume;
>  
> -    if (!red_channel_client_test_remote_cap(channel->channel_client, cap)) {
> +    if (!red_channel_client_test_remote_cap(client->channel_client, cap)) {
>          return TRUE;
>      }
>  
>      vol = alloca(sizeof (SpiceMsgAudioVolume) +
>                   st->volume_nchannels * sizeof (uint16_t));
> -    if (!snd_reset_send_data(channel, msg)) {
> +    if (!snd_reset_send_data(client, msg)) {
>          return FALSE;
>      }
>      vol->nchannels = st->volume_nchannels;
>      for (c = 0; c < st->volume_nchannels; ++c) {
>          vol->volume[c] = st->volume[c];
>      }
> -    spice_marshall_SpiceMsgAudioVolume(channel->send_data.marshaller, vol);
> +    spice_marshall_SpiceMsgAudioVolume(client->send_data.marshaller, vol);
>  
> -    return snd_begin_send_message(channel);
> +    return snd_begin_send_message(client);
>  }
>  
>  static int snd_playback_send_volume(PlaybackChannelClient *playback_client)
> @@ -597,22 +597,22 @@ static int snd_playback_send_volume(PlaybackChannelClient *playback_client)
>                             SPICE_MSG_PLAYBACK_VOLUME);
>  }
>  
> -static int snd_send_mute(SndChannelClient *channel, uint32_t cap, int msg)
> +static int snd_send_mute(SndChannelClient *client, uint32_t cap, int msg)
>  {
>      SpiceMsgAudioMute mute;
> -    SpiceVolumeState *st = &channel->worker->volume;
> +    SpiceVolumeState *st = &client->worker->volume;
>  
> -    if (!red_channel_client_test_remote_cap(channel->channel_client, cap)) {
> +    if (!red_channel_client_test_remote_cap(client->channel_client, cap)) {
>          return TRUE;
>      }
>  
> -    if (!snd_reset_send_data(channel, msg)) {
> +    if (!snd_reset_send_data(client, msg)) {
>          return FALSE;
>      }
>      mute.mute = st->mute;
> -    spice_marshall_SpiceMsgAudioMute(channel->send_data.marshaller, &mute);
> +    spice_marshall_SpiceMsgAudioMute(client->send_data.marshaller, &mute);
>  
> -    return snd_begin_send_message(channel);
> +    return snd_begin_send_message(client);
>  }
>  
>  static int snd_playback_send_mute(PlaybackChannelClient *playback_client)
> @@ -623,53 +623,53 @@ static int snd_playback_send_mute(PlaybackChannelClient *playback_client)
>  
>  static int snd_playback_send_latency(PlaybackChannelClient *playback_client)
>  {
> -    SndChannelClient *channel = &playback_client->base;
> +    SndChannelClient *client = &playback_client->base;
>      SpiceMsgPlaybackLatency latency_msg;
>  
>      spice_debug("latency %u", playback_client->latency);
> -    if (!snd_reset_send_data(channel, SPICE_MSG_PLAYBACK_LATENCY)) {
> +    if (!snd_reset_send_data(client, SPICE_MSG_PLAYBACK_LATENCY)) {
>          return FALSE;
>      }
>      latency_msg.latency_ms = playback_client->latency;
> -    spice_marshall_msg_playback_latency(channel->send_data.marshaller, &latency_msg);
> +    spice_marshall_msg_playback_latency(client->send_data.marshaller, &latency_msg);
>  
> -    return snd_begin_send_message(channel);
> +    return snd_begin_send_message(client);
>  }
>  static int snd_playback_send_start(PlaybackChannelClient *playback_client)
>  {
> -    SndChannelClient *channel = (SndChannelClient *)playback_client;
> +    SndChannelClient *client = (SndChannelClient *)playback_client;
>      SpiceMsgPlaybackStart start;
>  
> -    if (!snd_reset_send_data(channel, SPICE_MSG_PLAYBACK_START)) {
> +    if (!snd_reset_send_data(client, SPICE_MSG_PLAYBACK_START)) {
>          return FALSE;
>      }
>  
>      start.channels = SPICE_INTERFACE_PLAYBACK_CHAN;
> -    start.frequency = channel->worker->frequency;
> +    start.frequency = client->worker->frequency;
>      spice_assert(SPICE_INTERFACE_PLAYBACK_FMT == SPICE_INTERFACE_AUDIO_FMT_S16);
>      start.format = SPICE_AUDIO_FMT_S16;
>      start.time = reds_get_mm_time();
> -    spice_marshall_msg_playback_start(channel->send_data.marshaller, &start);
> +    spice_marshall_msg_playback_start(client->send_data.marshaller, &start);
>  
> -    return snd_begin_send_message(channel);
> +    return snd_begin_send_message(client);
>  }
>  
>  static int snd_playback_send_stop(PlaybackChannelClient *playback_client)
>  {
> -    SndChannelClient *channel = (SndChannelClient *)playback_client;
> +    SndChannelClient *client = (SndChannelClient *)playback_client;
>  
> -    if (!snd_reset_send_data(channel, SPICE_MSG_PLAYBACK_STOP)) {
> +    if (!snd_reset_send_data(client, SPICE_MSG_PLAYBACK_STOP)) {
>          return FALSE;
>      }
>  
> -    return snd_begin_send_message(channel);
> +    return snd_begin_send_message(client);
>  }
>  
>  static int snd_playback_send_ctl(PlaybackChannelClient *playback_client)
>  {
> -    SndChannelClient *channel = (SndChannelClient *)playback_client;
> +    SndChannelClient *client = (SndChannelClient *)playback_client;
>  
> -    if ((channel->client_active = channel->active)) {
> +    if ((client->client_active = client->active)) {
>          return snd_playback_send_start(playback_client);
>      } else {
>          return snd_playback_send_stop(playback_client);
> @@ -678,38 +678,38 @@ static int snd_playback_send_ctl(PlaybackChannelClient *playback_client)
>  
>  static int snd_record_send_start(RecordChannelClient *record_client)
>  {
> -    SndChannelClient *channel = (SndChannelClient *)record_client;
> +    SndChannelClient *client = (SndChannelClient *)record_client;
>      SpiceMsgRecordStart start;
>  
> -    if (!snd_reset_send_data(channel, SPICE_MSG_RECORD_START)) {
> +    if (!snd_reset_send_data(client, SPICE_MSG_RECORD_START)) {
>          return FALSE;
>      }
>  
>      start.channels = SPICE_INTERFACE_RECORD_CHAN;
> -    start.frequency = channel->worker->frequency;
> +    start.frequency = client->worker->frequency;
>      spice_assert(SPICE_INTERFACE_RECORD_FMT == SPICE_INTERFACE_AUDIO_FMT_S16);
>      start.format = SPICE_AUDIO_FMT_S16;
> -    spice_marshall_msg_record_start(channel->send_data.marshaller, &start);
> +    spice_marshall_msg_record_start(client->send_data.marshaller, &start);
>  
> -    return snd_begin_send_message(channel);
> +    return snd_begin_send_message(client);
>  }
>  
>  static int snd_record_send_stop(RecordChannelClient *record_client)
>  {
> -    SndChannelClient *channel = (SndChannelClient *)record_client;
> +    SndChannelClient *client = (SndChannelClient *)record_client;
>  
> -    if (!snd_reset_send_data(channel, SPICE_MSG_RECORD_STOP)) {
> +    if (!snd_reset_send_data(client, SPICE_MSG_RECORD_STOP)) {
>          return FALSE;
>      }
>  
> -    return snd_begin_send_message(channel);
> +    return snd_begin_send_message(client);
>  }
>  
>  static int snd_record_send_ctl(RecordChannelClient *record_client)
>  {
> -    SndChannelClient *channel = (SndChannelClient *)record_client;
> +    SndChannelClient *client = (SndChannelClient *)record_client;
>  
> -    if ((channel->client_active = channel->active)) {
> +    if ((client->client_active = client->active)) {
>          return snd_record_send_start(record_client);
>      } else {
>          return snd_record_send_stop(record_client);
> @@ -739,21 +739,21 @@ static int snd_record_send_migrate(RecordChannelClient *record_client)
>  
>  static int snd_playback_send_write(PlaybackChannelClient *playback_client)
>  {
> -    SndChannelClient *channel = (SndChannelClient *)playback_client;
> +    SndChannelClient *client = (SndChannelClient *)playback_client;
>      AudioFrame *frame;
>      SpiceMsgPlaybackPacket msg;
>  
> -    if (!snd_reset_send_data(channel, SPICE_MSG_PLAYBACK_DATA)) {
> +    if (!snd_reset_send_data(client, SPICE_MSG_PLAYBACK_DATA)) {
>          return FALSE;
>      }
>  
>      frame = playback_client->in_progress;
>      msg.time = frame->time;
>  
> -    spice_marshall_msg_playback_data(channel->send_data.marshaller, &msg);
> +    spice_marshall_msg_playback_data(client->send_data.marshaller, &msg);
>  
>      if (playback_client->mode == SPICE_AUDIO_DATA_MODE_RAW) {
> -        spice_marshaller_add_ref(channel->send_data.marshaller,
> +        spice_marshaller_add_ref(client->send_data.marshaller,
>                                   (uint8_t *)frame->samples,
>                                   snd_codec_frame_size(playback_client->codec) * sizeof(frame->samples[0]));
>      }
> @@ -763,80 +763,80 @@ static int snd_playback_send_write(PlaybackChannelClient *playback_client)
>                                      snd_codec_frame_size(playback_client->codec) * sizeof(frame->samples[0]),
>                                      playback_client->encode_buf, &n) != SND_CODEC_OK) {
>              spice_printerr("encode failed");
> -            snd_disconnect_channel(channel);
> +            snd_disconnect_channel(client);
>              return FALSE;
>          }
> -        spice_marshaller_add_ref(channel->send_data.marshaller, playback_client->encode_buf, n);
> +        spice_marshaller_add_ref(client->send_data.marshaller, playback_client->encode_buf, n);
>      }
>  
> -    return snd_begin_send_message(channel);
> +    return snd_begin_send_message(client);
>  }
>  
>  static int playback_send_mode(PlaybackChannelClient *playback_client)
>  {
> -    SndChannelClient *channel = (SndChannelClient *)playback_client;
> +    SndChannelClient *client = (SndChannelClient *)playback_client;
>      SpiceMsgPlaybackMode mode;
>  
> -    if (!snd_reset_send_data(channel, SPICE_MSG_PLAYBACK_MODE)) {
> +    if (!snd_reset_send_data(client, SPICE_MSG_PLAYBACK_MODE)) {
>          return FALSE;
>      }
>      mode.time = reds_get_mm_time();
>      mode.mode = playback_client->mode;
> -    spice_marshall_msg_playback_mode(channel->send_data.marshaller, &mode);
> +    spice_marshall_msg_playback_mode(client->send_data.marshaller, &mode);
>  
> -    return snd_begin_send_message(channel);
> +    return snd_begin_send_message(client);
>  }
>  
>  static void snd_playback_send(void* data)
>  {
>      PlaybackChannelClient *playback_client = (PlaybackChannelClient*)data;
> -    SndChannelClient *channel = (SndChannelClient*)playback_client;
> +    SndChannelClient *client = (SndChannelClient*)playback_client;
>  
>      if (!playback_client || !snd_send_data(data)) {
>          return;
>      }
>  
> -    while (channel->command) {
> -        if (channel->command & SND_PLAYBACK_MODE_MASK) {
> +    while (client->command) {
> +        if (client->command & SND_PLAYBACK_MODE_MASK) {
>              if (!playback_send_mode(playback_client)) {
>                  return;
>              }
> -            channel->command &= ~SND_PLAYBACK_MODE_MASK;
> +            client->command &= ~SND_PLAYBACK_MODE_MASK;
>          }
> -        if (channel->command & SND_PLAYBACK_PCM_MASK) {
> +        if (client->command & SND_PLAYBACK_PCM_MASK) {
>              spice_assert(!playback_client->in_progress && playback_client->pending_frame);
>              playback_client->in_progress = playback_client->pending_frame;
>              playback_client->pending_frame = NULL;
> -            channel->command &= ~SND_PLAYBACK_PCM_MASK;
> +            client->command &= ~SND_PLAYBACK_PCM_MASK;
>              if (!snd_playback_send_write(playback_client)) {
>                  spice_printerr("snd_send_playback_write failed");
>                  return;
>              }
>          }
> -        if (channel->command & SND_CTRL_MASK) {
> +        if (client->command & SND_CTRL_MASK) {
>              if (!snd_playback_send_ctl(playback_client)) {
>                  return;
>              }
> -            channel->command &= ~SND_CTRL_MASK;
> +            client->command &= ~SND_CTRL_MASK;
>          }
> -        if (channel->command & SND_VOLUME_MASK) {
> +        if (client->command & SND_VOLUME_MASK) {
>              if (!snd_playback_send_volume(playback_client) ||
>                  !snd_playback_send_mute(playback_client)) {
>                  return;
>              }
> -            channel->command &= ~SND_VOLUME_MASK;
> +            client->command &= ~SND_VOLUME_MASK;
>          }
> -        if (channel->command & SND_MIGRATE_MASK) {
> +        if (client->command & SND_MIGRATE_MASK) {
>              if (!snd_playback_send_migrate(playback_client)) {
>                  return;
>              }
> -            channel->command &= ~SND_MIGRATE_MASK;
> +            client->command &= ~SND_MIGRATE_MASK;
>          }
> -        if (channel->command & SND_PLAYBACK_LATENCY_MASK) {
> +        if (client->command & SND_PLAYBACK_LATENCY_MASK) {
>              if (!snd_playback_send_latency(playback_client)) {
>                  return;
>              }
> -            channel->command &= ~SND_PLAYBACK_LATENCY_MASK;
> +            client->command &= ~SND_PLAYBACK_LATENCY_MASK;
>          }
>      }
>  }
> @@ -844,37 +844,37 @@ static void snd_playback_send(void* data)
>  static void snd_record_send(void* data)
>  {
>      RecordChannelClient *record_client = (RecordChannelClient*)data;
> -    SndChannelClient *channel = (SndChannelClient*)record_client;
> +    SndChannelClient *client = (SndChannelClient*)record_client;
>  
>      if (!record_client || !snd_send_data(data)) {
>          return;
>      }
>  
> -    while (channel->command) {
> -        if (channel->command & SND_CTRL_MASK) {
> +    while (client->command) {
> +        if (client->command & SND_CTRL_MASK) {
>              if (!snd_record_send_ctl(record_client)) {
>                  return;
>              }
> -            channel->command &= ~SND_CTRL_MASK;
> +            client->command &= ~SND_CTRL_MASK;
>          }
> -        if (channel->command & SND_VOLUME_MASK) {
> +        if (client->command & SND_VOLUME_MASK) {
>              if (!snd_record_send_volume(record_client) ||
>                  !snd_record_send_mute(record_client)) {
>                  return;
>              }
> -            channel->command &= ~SND_VOLUME_MASK;
> +            client->command &= ~SND_VOLUME_MASK;
>          }
> -        if (channel->command & SND_MIGRATE_MASK) {
> +        if (client->command & SND_MIGRATE_MASK) {
>              if (!snd_record_send_migrate(record_client)) {
>                  return;
>              }
> -            channel->command &= ~SND_MIGRATE_MASK;
> +            client->command &= ~SND_MIGRATE_MASK;
>          }
>      }
>  }
>  
>  static SndChannelClient *__new_channel(SndWorker *worker, int size, uint32_t channel_id,
> -                                 RedClient *client,
> +                                 RedClient *red_client,
>                                   RedsStream *stream,
>                                   int migrate,
>                                   snd_channel_send_messages_proc send_messages,
> @@ -884,14 +884,14 @@ static SndChannelClient *__new_channel(SndWorker *worker, int size, uint32_t cha
>                                   uint32_t *common_caps, int num_common_caps,
>                                   uint32_t *caps, int num_caps)
>  {
> -    SndChannelClient *channel;
> +    SndChannelClient *client;
>      int delay_val;
>      int flags;
>  #ifdef SO_PRIORITY
>      int priority;
>  #endif
>      int tos;
> -    MainChannelClient *mcc = red_client_get_main(client);
> +    MainChannelClient *mcc = red_client_get_main(red_client);
>      RedsState *reds = red_channel_get_server(worker->base_channel);
>  
>      spice_assert(stream);
> @@ -929,39 +929,39 @@ static SndChannelClient *__new_channel(SndWorker *worker, int size, uint32_t cha
>          goto error1;
>      }
>  
> -    spice_assert(size >= sizeof(*channel));
> -    channel = spice_malloc0(size);
> -    channel->refs = 1;
> -    channel->parser = spice_get_client_channel_parser(channel_id, NULL);
> -    channel->stream = stream;
> -    channel->worker = worker;
> -    channel->receive_data.message_start = channel->receive_data.buf;
> -    channel->receive_data.now = channel->receive_data.buf;
> -    channel->receive_data.end = channel->receive_data.buf + sizeof(channel->receive_data.buf);
> -    channel->send_data.marshaller = spice_marshaller_new();
> +    spice_assert(size >= sizeof(*client));
> +    client = spice_malloc0(size);
> +    client->refs = 1;
> +    client->parser = spice_get_client_channel_parser(channel_id, NULL);
> +    client->stream = stream;
> +    client->worker = worker;
> +    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);
> +    client->send_data.marshaller = spice_marshaller_new();
>  
>      stream->watch = reds_core_watch_add(reds, stream->socket, SPICE_WATCH_EVENT_READ,
> -                                        snd_event, channel);
> +                                        snd_event, client);
>      if (stream->watch == NULL) {
>          spice_printerr("watch_add failed, %s", strerror(errno));
>          goto error2;
>      }
>  
> -    channel->send_messages = send_messages;
> -    channel->handle_message = handle_message;
> -    channel->on_message_done = on_message_done;
> -    channel->cleanup = cleanup;
> +    client->send_messages = send_messages;
> +    client->handle_message = handle_message;
> +    client->on_message_done = on_message_done;
> +    client->cleanup = cleanup;
>  
> -    channel->channel_client =
> -        dummy_channel_client_create(worker->base_channel, client,
> +    client->channel_client =
> +        dummy_channel_client_create(worker->base_channel, red_client,
>                                      num_common_caps, common_caps, num_caps, caps);
> -    if (!channel->channel_client) {
> +    if (!client->channel_client) {
>          goto error2;
>      }
> -    return channel;
> +    return client;
>  
>  error2:
> -    free(channel);
> +    free(client);
>  
>  error1:
>      reds_stream_free(stream);
> @@ -986,12 +986,12 @@ static void snd_disconnect_channel_client(RedChannelClient *rcc)
>      }
>  }
>  
> -static void snd_set_command(SndChannelClient *channel, uint32_t command)
> +static void snd_set_command(SndChannelClient *client, uint32_t command)
>  {
> -    if (!channel) {
> +    if (!client) {
>          return;
>      }
> -    channel->command |= command;
> +    client->command |= command;
>  }
>  
>  SPICE_GNUC_VISIBLE void spice_server_playback_set_volume(SpicePlaybackInstance *sin,
> @@ -999,14 +999,14 @@ SPICE_GNUC_VISIBLE void spice_server_playback_set_volume(SpicePlaybackInstance *
>                                                    uint16_t *volume)
>  {
>      SpiceVolumeState *st = &sin->st->worker.volume;
> -    SndChannelClient *channel = sin->st->worker.connection;
> -    PlaybackChannelClient *playback_client = SPICE_CONTAINEROF(channel, PlaybackChannelClient, base);
> +    SndChannelClient *client = sin->st->worker.connection;
> +    PlaybackChannelClient *playback_client = SPICE_CONTAINEROF(client, PlaybackChannelClient, base);
>  
>      st->volume_nchannels = nchannels;
>      free(st->volume);
>      st->volume = spice_memdup(volume, sizeof(uint16_t) * nchannels);
>  
> -    if (!channel || nchannels == 0)
> +    if (!client || nchannels == 0)
>          return;
>  
>      snd_playback_send_volume(playback_client);
> @@ -1015,12 +1015,12 @@ 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 *channel = sin->st->worker.connection;
> -    PlaybackChannelClient *playback_client = SPICE_CONTAINEROF(channel, PlaybackChannelClient, base);
> +    SndChannelClient *client = sin->st->worker.connection;
> +    PlaybackChannelClient *playback_client = SPICE_CONTAINEROF(client, PlaybackChannelClient, base);
>  
>      st->mute = mute;
>  
> -    if (!channel)
> +    if (!client)
>          return;
>  
>      snd_playback_send_mute(playback_client);
> @@ -1028,19 +1028,19 @@ SPICE_GNUC_VISIBLE void spice_server_playback_set_mute(SpicePlaybackInstance *si
>  
>  static void snd_playback_start(SndWorker *worker)
>  {
> -    SndChannelClient *channel = worker->connection;
> +    SndChannelClient *client = worker->connection;
>  
>      worker->active = 1;
> -    if (!channel)
> +    if (!client)
>          return;
> -    spice_assert(!channel->active);
> -    reds_disable_mm_time(snd_channel_get_server(channel));
> -    channel->active = TRUE;
> -    if (!channel->client_active) {
> -        snd_set_command(channel, SND_CTRL_MASK);
> -        snd_playback_send(channel);
> +    spice_assert(!client->active);
> +    reds_disable_mm_time(snd_channel_get_server(client));
> +    client->active = TRUE;
> +    if (!client->client_active) {
> +        snd_set_command(client, SND_CTRL_MASK);
> +        snd_playback_send(client);
>      } else {
> -        channel->command &= ~SND_CTRL_MASK;
> +        client->command &= ~SND_CTRL_MASK;
>      }
>  }
>  
> @@ -1051,14 +1051,14 @@ SPICE_GNUC_VISIBLE void spice_server_playback_start(SpicePlaybackInstance *sin)
>  
>  SPICE_GNUC_VISIBLE void spice_server_playback_stop(SpicePlaybackInstance *sin)
>  {
> -    SndChannelClient *channel = sin->st->worker.connection;
> -    PlaybackChannelClient *playback_client = SPICE_CONTAINEROF(channel, PlaybackChannelClient, base);
> +    SndChannelClient *client = sin->st->worker.connection;
> +    PlaybackChannelClient *playback_client = SPICE_CONTAINEROF(client, PlaybackChannelClient, base);
>  
>      sin->st->worker.active = 0;
> -    if (!channel)
> +    if (!client)
>          return;
>      spice_assert(playback_client->base.active);
> -    reds_enable_mm_time(snd_channel_get_server(channel));
> +    reds_enable_mm_time(snd_channel_get_server(client));
>      playback_client->base.active = FALSE;
>      if (playback_client->base.client_active) {
>          snd_set_command(&playback_client->base, SND_CTRL_MASK);
> @@ -1079,16 +1079,16 @@ 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 *channel = sin->st->worker.connection;
> -    PlaybackChannelClient *playback_client = SPICE_CONTAINEROF(channel, PlaybackChannelClient, base);
> +    SndChannelClient *client = sin->st->worker.connection;
> +    PlaybackChannelClient *playback_client = SPICE_CONTAINEROF(client, PlaybackChannelClient, base);
>  
> -    if (!channel || !playback_client->free_frames) {
> +    if (!client || !playback_client->free_frames) {
>          *frame = NULL;
>          *num_samples = 0;
>          return;
>      }
>      spice_assert(playback_client->base.active);
> -    snd_channel_ref(channel);
> +    snd_channel_ref(client);
>  
>      *frame = playback_client->free_frames->samples;
>      playback_client->free_frames = playback_client->free_frames->next;
> @@ -1101,12 +1101,12 @@ SPICE_GNUC_VISIBLE void spice_server_playback_put_samples(SpicePlaybackInstance 
>      AudioFrame *frame;
>  
>      frame = SPICE_CONTAINEROF(samples, AudioFrame, samples[0]);
> -    playback_client = frame->channel;
> +    playback_client = frame->client;
>      spice_assert(playback_client);
>      if (!snd_channel_unref(&playback_client->base) ||
>          sin->st->worker.connection != &playback_client->base) {
> -        /* lost last reference, channel has been destroyed previously */
> -        spice_info("audio samples belong to a disconnected channel");
> +        /* lost last reference, client has been destroyed previously */
> +        spice_info("audio samples belong to a disconnected client");
>          return;
>      }
>      spice_assert(playback_client->base.active);
> @@ -1178,12 +1178,12 @@ static void on_new_playback_channel(SndWorker *worker, SndChannelClient *snd_cha
>      }
>  }
>  
> -static void snd_playback_cleanup(SndChannelClient *channel)
> +static void snd_playback_cleanup(SndChannelClient *client)
>  {
> -    PlaybackChannelClient *playback_client = SPICE_CONTAINEROF(channel, PlaybackChannelClient, base);
> +    PlaybackChannelClient *playback_client = SPICE_CONTAINEROF(client, PlaybackChannelClient, base);
>  
>      if (playback_client->base.active) {
> -        reds_enable_mm_time(snd_channel_get_server(channel));
> +        reds_enable_mm_time(snd_channel_get_server(client));
>      }
>  
>      snd_codec_destroy(&playback_client->codec);
> @@ -1266,14 +1266,14 @@ SPICE_GNUC_VISIBLE void spice_server_record_set_volume(SpiceRecordInstance *sin,
>                                                  uint16_t *volume)
>  {
>      SpiceVolumeState *st = &sin->st->worker.volume;
> -    SndChannelClient *channel = sin->st->worker.connection;
> -    RecordChannelClient *record_client = SPICE_CONTAINEROF(channel, RecordChannelClient, base);
> +    SndChannelClient *client = sin->st->worker.connection;
> +    RecordChannelClient *record_client = SPICE_CONTAINEROF(client, RecordChannelClient, base);
>  
>      st->volume_nchannels = nchannels;
>      free(st->volume);
>      st->volume = spice_memdup(volume, sizeof(uint16_t) * nchannels);
>  
> -    if (!channel || nchannels == 0)
> +    if (!client || nchannels == 0)
>          return;
>  
>      snd_record_send_volume(record_client);
> @@ -1282,12 +1282,12 @@ 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 *channel = sin->st->worker.connection;
> -    RecordChannelClient *record_client = SPICE_CONTAINEROF(channel, RecordChannelClient, base);
> +    SndChannelClient *client = sin->st->worker.connection;
> +    RecordChannelClient *record_client = SPICE_CONTAINEROF(client, RecordChannelClient, base);
>  
>      st->mute = mute;
>  
> -    if (!channel)
> +    if (!client)
>          return;
>  
>      snd_record_send_mute(record_client);
> @@ -1295,21 +1295,21 @@ SPICE_GNUC_VISIBLE void spice_server_record_set_mute(SpiceRecordInstance *sin, u
>  
>  static void snd_record_start(SndWorker *worker)
>  {
> -    SndChannelClient *channel = worker->connection;
> -    RecordChannelClient *record_client = SPICE_CONTAINEROF(channel, RecordChannelClient, base);
> +    SndChannelClient *client = worker->connection;
> +    RecordChannelClient *record_client = SPICE_CONTAINEROF(client, RecordChannelClient, base);
>  
>      worker->active = 1;
> -    if (!channel)
> +    if (!client)
>          return;
> -    spice_assert(!channel->active);
> +    spice_assert(!client->active);
>      record_client->read_pos = record_client->write_pos = 0;   //todo: improve by
>                                                                  //stream generation
> -    channel->active = TRUE;
> -    if (!channel->client_active) {
> -        snd_set_command(channel, SND_CTRL_MASK);
> -        snd_record_send(channel);
> +    client->active = TRUE;
> +    if (!client->client_active) {
> +        snd_set_command(client, SND_CTRL_MASK);
> +        snd_record_send(client);
>      } else {
> -        channel->command &= ~SND_CTRL_MASK;
> +        client->command &= ~SND_CTRL_MASK;
>      }
>  }
>  
> @@ -1320,11 +1320,11 @@ SPICE_GNUC_VISIBLE void spice_server_record_start(SpiceRecordInstance *sin)
>  
>  SPICE_GNUC_VISIBLE void spice_server_record_stop(SpiceRecordInstance *sin)
>  {
> -    SndChannelClient *channel = sin->st->worker.connection;
> -    RecordChannelClient *record_client = SPICE_CONTAINEROF(channel, RecordChannelClient, base);
> +    SndChannelClient *client = sin->st->worker.connection;
> +    RecordChannelClient *record_client = SPICE_CONTAINEROF(client, RecordChannelClient, base);
>  
>      sin->st->worker.active = 0;
> -    if (!channel)
> +    if (!client)
>          return;
>      spice_assert(record_client->base.active);
>      record_client->base.active = FALSE;
> @@ -1339,13 +1339,13 @@ 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 *channel = sin->st->worker.connection;
> -    RecordChannelClient *record_client = SPICE_CONTAINEROF(channel, RecordChannelClient, base);
> +    SndChannelClient *client = sin->st->worker.connection;
> +    RecordChannelClient *record_client = SPICE_CONTAINEROF(client, RecordChannelClient, base);
>      uint32_t read_pos;
>      uint32_t now;
>      uint32_t len;
>  
> -    if (!channel)
> +    if (!client)
>          return 0;
>      spice_assert(record_client->base.active);
>  
> @@ -1374,11 +1374,11 @@ SPICE_GNUC_VISIBLE uint32_t spice_server_record_get_samples(SpiceRecordInstance 
>      return len;
>  }
>  
> -static uint32_t snd_get_best_rate(SndChannelClient *channel, uint32_t cap_opus)
> +static uint32_t snd_get_best_rate(SndChannelClient *client, uint32_t cap_opus)
>  {
>      int client_can_opus = TRUE;
> -    if (channel) {
> -        client_can_opus = red_channel_client_test_remote_cap(channel->channel_client, cap_opus);
> +    if (client) {
> +        client_can_opus = red_channel_client_test_remote_cap(client->channel_client, cap_opus);
>      }
>  
>      if (client_can_opus && snd_codec_is_capable(SPICE_AUDIO_DATA_MODE_OPUS, SND_CODEC_ANY_FREQUENCY))
> @@ -1389,10 +1389,10 @@ static uint32_t snd_get_best_rate(SndChannelClient *channel, uint32_t cap_opus)
>  
>  static void snd_set_rate(SndWorker *worker, uint32_t frequency, uint32_t cap_opus)
>  {
> -    RedChannel *channel = worker->base_channel;
> +    RedChannel *client = 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);
> +    if (client && snd_codec_is_capable(SPICE_AUDIO_DATA_MODE_OPUS, frequency)) {
> +        red_channel_set_cap(client, cap_opus);
>      }
>  }
>  
> @@ -1429,9 +1429,9 @@ static void on_new_record_channel(SndWorker *worker, SndChannelClient *snd_chann
>      }
>  }
>  
> -static void snd_record_cleanup(SndChannelClient *channel)
> +static void snd_record_cleanup(SndChannelClient *client)
>  {
> -    RecordChannelClient *record_client = SPICE_CONTAINEROF(channel, RecordChannelClient, base);
> +    RecordChannelClient *record_client = SPICE_CONTAINEROF(client, RecordChannelClient, base);
>      snd_codec_destroy(&record_client->codec);
>  }
>  
> -- 
> git-series 0.9.1
> _______________________________________________
> Spice-devel mailing list
> Spice-devel@lists.freedesktop.org
> https://lists.freedesktop.org/mailman/listinfo/spice-devel