---
server/Makefile.am | 56 +-
server/char-device.c | 1035 ++++++++++++++++++
server/char-device.h | 216 ++++
server/char_device.c | 1035 ------------------
server/char_device.h | 216 ----
server/dcc-encoders.h | 10 +-
server/display-channel.h | 14 +-
server/glz-encoder-dict.c | 633 +++++++++++
server/glz-encoder-dict.h | 69 ++
server/glz-encoder-priv.h | 186 ++++
server/glz-encoder.c | 311 ++++++
server/glz-encoder.h | 55 +
server/glz_encoder.c | 311 ------
server/glz_encoder.h | 55 -
server/glz_encoder_dictionary.c | 633 -----------
server/glz_encoder_dictionary.h | 69 --
server/glz_encoder_dictionary_protected.h | 186 ----
server/image-cache.c | 214 ++++
server/image-cache.h | 65 ++
server/inputs-channel.c | 679 ++++++++++++
server/inputs-channel.h | 38 +
server/inputs_channel.c | 679 ------------
server/inputs_channel.h | 38 -
server/jpeg-encoder.c | 248 +++++
server/jpeg-encoder.h | 61 ++
server/jpeg_encoder.c | 248 -----
server/jpeg_encoder.h | 61 --
server/main-channel.c | 1345 ++++++++++++++++++++++++
server/main-channel.h | 103 ++
server/main-dispatcher.c | 217 ++++
server/main-dispatcher.h | 36 +
server/main_channel.c | 1345 ------------------------
server/main_channel.h | 103 --
server/main_dispatcher.c | 217 ----
server/main_dispatcher.h | 36 -
server/memslot.c | 184 ++++
server/memslot.h | 72 ++
server/migration-protocol.h | 213 ++++
server/migration_protocol.h | 213 ----
server/mjpeg-encoder.c | 1375 ++++++++++++++++++++++++
server/mjpeg-encoder.h | 100 ++
server/mjpeg_encoder.c | 1375 ------------------------
server/mjpeg_encoder.h | 100 --
server/red_channel.c | 2 +-
server/red_dispatcher.c | 2 +-
server/red_memslots.c | 184 ----
server/red_memslots.h | 72 --
server/red_parse_qxl.c | 2 +-
server/red_parse_qxl.h | 2 +-
server/red_record_qxl.c | 4 +-
server/red_record_qxl.h | 2 +-
server/red_replay_qxl.c | 2 +-
server/reds.c | 12 +-
server/reds.h | 4 +-
server/reds_stream.c | 2 +-
server/reds_sw_canvas.c | 26 -
server/reds_sw_canvas.h | 24 -
server/smartcard.c | 4 +-
server/snd_worker.c | 1625 -----------------------------
server/snd_worker.h | 33 -
server/sound.c | 1625 +++++++++++++++++++++++++++++
server/sound.h | 33 +
server/spice_image_cache.c | 214 ----
server/spice_image_cache.h | 65 --
server/spicevmc.c | 4 +-
server/stream.h | 4 +-
server/sw-canvas.c | 26 +
server/sw-canvas.h | 24 +
server/zlib-encoder.c | 125 +++
server/zlib-encoder.h | 47 +
server/zlib_encoder.c | 125 ---
server/zlib_encoder.h | 47 -
72 files changed, 9398 insertions(+), 9398 deletions(-)
create mode 100644 server/char-device.c
create mode 100644 server/char-device.h
delete mode 100644 server/char_device.c
delete mode 100644 server/char_device.h
create mode 100644 server/glz-encoder-dict.c
create mode 100644 server/glz-encoder-dict.h
create mode 100644 server/glz-encoder-priv.h
create mode 100644 server/glz-encoder.c
create mode 100644 server/glz-encoder.h
delete mode 100644 server/glz_encoder.c
delete mode 100644 server/glz_encoder.h
delete mode 100644 server/glz_encoder_dictionary.c
delete mode 100644 server/glz_encoder_dictionary.h
delete mode 100644 server/glz_encoder_dictionary_protected.h
create mode 100644 server/image-cache.c
create mode 100644 server/image-cache.h
create mode 100644 server/inputs-channel.c
create mode 100644 server/inputs-channel.h
delete mode 100644 server/inputs_channel.c
delete mode 100644 server/inputs_channel.h
create mode 100644 server/jpeg-encoder.c
create mode 100644 server/jpeg-encoder.h
delete mode 100644 server/jpeg_encoder.c
delete mode 100644 server/jpeg_encoder.h
create mode 100644 server/main-channel.c
create mode 100644 server/main-channel.h
create mode 100644 server/main-dispatcher.c
create mode 100644 server/main-dispatcher.h
delete mode 100644 server/main_channel.c
delete mode 100644 server/main_channel.h
delete mode 100644 server/main_dispatcher.c
delete mode 100644 server/main_dispatcher.h
create mode 100644 server/memslot.c
create mode 100644 server/memslot.h
create mode 100644 server/migration-protocol.h
delete mode 100644 server/migration_protocol.h
create mode 100644 server/mjpeg-encoder.c
create mode 100644 server/mjpeg-encoder.h
delete mode 100644 server/mjpeg_encoder.c
delete mode 100644 server/mjpeg_encoder.h
delete mode 100644 server/red_memslots.c
delete mode 100644 server/red_memslots.h
delete mode 100644 server/reds_sw_canvas.c
delete mode 100644 server/reds_sw_canvas.h
delete mode 100644 server/snd_worker.c
delete mode 100644 server/snd_worker.h
create mode 100644 server/sound.c
create mode 100644 server/sound.h
delete mode 100644 server/spice_image_cache.c
delete mode 100644 server/spice_image_cache.h
create mode 100644 server/sw-canvas.c
create mode 100644 server/sw-canvas.h
create mode 100644 server/zlib-encoder.c
create mode 100644 server/zlib-encoder.h
delete mode 100644 server/zlib_encoder.c
delete mode 100644 server/zlib_encoder.h
diff --git a/server/Makefile.am b/server/Makefile.am
index 6b45a42..e964fb1 100644
--- a/server/Makefile.am
+++ b/server/Makefile.am
@@ -66,25 +66,25 @@ libspice_server_la_SOURCES = \
agent-msg-filter.c \
agent-msg-filter.h \
cache-item.h \
- char_device.c \
- char_device.h \
+ char-device.c \
+ char-device.h \
demarshallers.h \
- glz_encoder.c \
- glz_encoder.h \
+ glz-encoder.c \
+ glz-encoder.h \
glz_encoder_config.h \
- glz_encoder_dictionary.c \
- glz_encoder_dictionary.h \
- glz_encoder_dictionary_protected.h \
- inputs_channel.c \
- inputs_channel.h \
- jpeg_encoder.c \
- jpeg_encoder.h \
+ glz-encoder-dict.c \
+ glz-encoder-dict.h \
+ glz-encoder-priv.h \
+ inputs-channel.c \
+ inputs-channel.h \
+ jpeg-encoder.c \
+ jpeg-encoder.h \
lz4_encoder.c \
lz4_encoder.h \
- main_channel.c \
- main_channel.h \
- mjpeg_encoder.c \
- mjpeg_encoder.h \
+ main-channel.c \
+ main-channel.h \
+ mjpeg-encoder.c \
+ mjpeg-encoder.h \
red_channel.c \
red_channel.h \
red_common.h \
@@ -92,11 +92,11 @@ libspice_server_la_SOURCES = \
dispatcher.h \
red_dispatcher.c \
red_dispatcher.h \
- main_dispatcher.c \
- main_dispatcher.h \
- migration_protocol.h \
- red_memslots.c \
- red_memslots.h \
+ main-dispatcher.c \
+ main-dispatcher.h \
+ migration-protocol.h \
+ memslot.c \
+ memslot.h \
red_parse_qxl.c \
red_record_qxl.c \
red_record_qxl.h \
@@ -114,20 +114,20 @@ libspice_server_la_SOURCES = \
reds-private.h \
reds_stream.c \
reds_stream.h \
- reds_sw_canvas.c \
- reds_sw_canvas.h \
- snd_worker.c \
- snd_worker.h \
+ sw-canvas.c \
+ sw-canvas.h \
+ sound.c \
+ sound.h \
stat.h \
spicevmc.c \
spice_timer_queue.c \
spice_timer_queue.h \
- zlib_encoder.c \
- zlib_encoder.h \
+ zlib-encoder.c \
+ zlib-encoder.h \
spice_bitmap_utils.h \
spice_bitmap_utils.c \
- spice_image_cache.h \
- spice_image_cache.c \
+ image-cache.h \
+ image-cache.c \
pixmap-cache.h \
pixmap-cache.c \
tree.h \
diff --git a/server/char-device.c b/server/char-device.c
new file mode 100644
index 0000000..3790fab
--- /dev/null
+++ b/server/char-device.c
@@ -0,0 +1,1035 @@
+/* spice-server char device flow control code
+
+ Copyright (C) 2012 Red Hat, Inc.
+
+ Red Hat Authors:
+ Yonit Halperin <yhalperi@xxxxxxxxxx>
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, see <http:www.gnu.org/licenses/>.
+*/
+
+
+#include <config.h>
+#include "char-device.h"
+#include "red_channel.h"
+#include "reds.h"
+
+#define CHAR_DEVICE_WRITE_TO_TIMEOUT 100
+#define SPICE_CHAR_DEVICE_WAIT_TOKENS_TIMEOUT 30000
+#define MAX_POOL_SIZE (10 * 64 * 1024)
+
+typedef struct SpiceCharDeviceClientState SpiceCharDeviceClientState;
+struct SpiceCharDeviceClientState {
+ RingItem link;
+ SpiceCharDeviceState *dev;
+ RedClient *client;
+ int do_flow_control;
+ uint64_t num_client_tokens;
+ uint64_t num_client_tokens_free; /* client messages that were consumed by the device */
+ uint64_t num_send_tokens; /* send to client */
+ SpiceTimer *wait_for_tokens_timer;
+ int wait_for_tokens_started;
+ Ring send_queue;
+ uint32_t send_queue_size;
+ uint32_t max_send_queue_size;
+};
+
+struct SpiceCharDeviceState {
+ int running;
+ int active; /* has read/write been performed since the device was started */
+ int wait_for_migrate_data;
+ uint32_t refs;
+
+ Ring write_queue;
+ Ring write_bufs_pool;
+ uint64_t cur_pool_size;
+ SpiceCharDeviceWriteBuffer *cur_write_buf;
+ uint8_t *cur_write_buf_pos;
+ SpiceTimer *write_to_dev_timer;
+ uint64_t num_self_tokens;
+
+ Ring clients; /* list of SpiceCharDeviceClientState */
+ uint32_t num_clients;
+
+ uint64_t client_tokens_interval; /* frequency of returning tokens to the client */
+ SpiceCharDeviceInstance *sin;
+
+ int during_read_from_device;
+ int during_write_to_device;
+
+ SpiceCharDeviceCallbacks cbs;
+ void *opaque;
+};
+
+enum {
+ WRITE_BUFFER_ORIGIN_NONE,
+ WRITE_BUFFER_ORIGIN_CLIENT,
+ WRITE_BUFFER_ORIGIN_SERVER,
+ WRITE_BUFFER_ORIGIN_SERVER_NO_TOKEN,
+};
+
+/* Holding references for avoiding access violation if the char device was
+ * destroyed during a callback */
+static void spice_char_device_state_ref(SpiceCharDeviceState *char_dev);
+static void spice_char_device_state_unref(SpiceCharDeviceState *char_dev);
+static void spice_char_device_write_buffer_unref(SpiceCharDeviceWriteBuffer *write_buf);
+
+static void spice_char_dev_write_retry(void *opaque);
+
+typedef struct SpiceCharDeviceMsgToClientItem {
+ RingItem link;
+ SpiceCharDeviceMsgToClient *msg;
+} SpiceCharDeviceMsgToClientItem;
+
+static void spice_char_device_write_buffer_free(SpiceCharDeviceWriteBuffer *buf)
+{
+ if (buf == NULL)
+ return;
+
+ free(buf->buf);
+ free(buf);
+}
+
+static void write_buffers_queue_free(Ring *write_queue)
+{
+ while (!ring_is_empty(write_queue)) {
+ RingItem *item = ring_get_tail(write_queue);
+ SpiceCharDeviceWriteBuffer *buf;
+
+ ring_remove(item);
+ buf = SPICE_CONTAINEROF(item, SpiceCharDeviceWriteBuffer, link);
+ spice_char_device_write_buffer_free(buf);
+ }
+}
+
+static void spice_char_device_write_buffer_pool_add(SpiceCharDeviceState *dev,
+ SpiceCharDeviceWriteBuffer *buf)
+{
+ if (buf->refs == 1 &&
+ dev->cur_pool_size < MAX_POOL_SIZE) {
+ buf->buf_used = 0;
+ buf->origin = WRITE_BUFFER_ORIGIN_NONE;
+ buf->client = NULL;
+ dev->cur_pool_size += buf->buf_size;
+ ring_add(&dev->write_bufs_pool, &buf->link);
+ return;
+ }
+
+ /* Buffer still being used - just unref for the caller */
+ spice_char_device_write_buffer_unref(buf);
+}
+
+static void spice_char_device_client_send_queue_free(SpiceCharDeviceState *dev,
+ SpiceCharDeviceClientState *dev_client)
+{
+ spice_debug("send_queue_empty %d", ring_is_empty(&dev_client->send_queue));
+ while (!ring_is_empty(&dev_client->send_queue)) {
+ RingItem *item = ring_get_tail(&dev_client->send_queue);
+ SpiceCharDeviceMsgToClientItem *msg_item = SPICE_CONTAINEROF(item,
+ SpiceCharDeviceMsgToClientItem,
+ link);
+
+ ring_remove(item);
+ dev->cbs.unref_msg_to_client(msg_item->msg, dev->opaque);
+ free(msg_item);
+ }
+ dev_client->num_send_tokens += dev_client->send_queue_size;
+ dev_client->send_queue_size = 0;
+}
+
+static void spice_char_device_client_free(SpiceCharDeviceState *dev,
+ SpiceCharDeviceClientState *dev_client)
+{
+ RingItem *item, *next;
+
+ if (dev_client->wait_for_tokens_timer) {
+ core->timer_remove(dev_client->wait_for_tokens_timer);
+ }
+
+ spice_char_device_client_send_queue_free(dev, dev_client);
+
+ /* remove write buffers that are associated with the client */
+ spice_debug("write_queue_is_empty %d", ring_is_empty(&dev->write_queue) && !dev->cur_write_buf);
+ RING_FOREACH_SAFE(item, next, &dev->write_queue) {
+ SpiceCharDeviceWriteBuffer *write_buf;
+
+ write_buf = SPICE_CONTAINEROF(item, SpiceCharDeviceWriteBuffer, link);
+ if (write_buf->origin == WRITE_BUFFER_ORIGIN_CLIENT &&
+ write_buf->client == dev_client->client) {
+ ring_remove(item);
+ spice_char_device_write_buffer_pool_add(dev, write_buf);
+ }
+ }
+
+ if (dev->cur_write_buf && dev->cur_write_buf->origin == WRITE_BUFFER_ORIGIN_CLIENT &&
+ dev->cur_write_buf->client == dev_client->client) {
+ dev->cur_write_buf->origin = WRITE_BUFFER_ORIGIN_NONE;
+ dev->cur_write_buf->client = NULL;
+ }
+
+ dev->num_clients--;
+ ring_remove(&dev_client->link);
+ free(dev_client);
+}
+
+static void spice_char_device_handle_client_overflow(SpiceCharDeviceClientState *dev_client)
+{
+ SpiceCharDeviceState *dev = dev_client->dev;
+ spice_printerr("dev %p client %p ", dev, dev_client);
+ dev->cbs.remove_client(dev_client->client, dev->opaque);
+}
+
+static SpiceCharDeviceClientState *spice_char_device_client_find(SpiceCharDeviceState *dev,
+ RedClient *client)
+{
+ RingItem *item;
+
+ RING_FOREACH(item, &dev->clients) {
+ SpiceCharDeviceClientState *dev_client;
+
+ dev_client = SPICE_CONTAINEROF(item, SpiceCharDeviceClientState, link);
+ if (dev_client->client == client) {
+ return dev_client;
+ }
+ }
+ return NULL;
+}
+
+/***************************
+ * Reading from the device *
+ **************************/
+
+static void device_client_wait_for_tokens_timeout(void *opaque)
+{
+ SpiceCharDeviceClientState *dev_client = opaque;
+
+ spice_char_device_handle_client_overflow(dev_client);
+}
+
+static int spice_char_device_can_send_to_client(SpiceCharDeviceClientState *dev_client)
+{
+ return !dev_client->do_flow_control || dev_client->num_send_tokens;
+}
+
+static uint64_t spice_char_device_max_send_tokens(SpiceCharDeviceState *dev)
+{
+ RingItem *item;
+ uint64_t max = 0;
+
+ RING_FOREACH(item, &dev->clients) {
+ SpiceCharDeviceClientState *dev_client;
+
+ dev_client = SPICE_CONTAINEROF(item, SpiceCharDeviceClientState, link);
+
+ if (!dev_client->do_flow_control) {
+ max = ~0;
+ break;
+ }
+
+ if (dev_client->num_send_tokens > max) {
+ max = dev_client->num_send_tokens;
+ }
+ }
+ return max;
+}
+
+static void spice_char_device_add_msg_to_client_queue(SpiceCharDeviceClientState *dev_client,
+ SpiceCharDeviceMsgToClient *msg)
+{
+ SpiceCharDeviceState *dev = dev_client->dev;
+ SpiceCharDeviceMsgToClientItem *msg_item;
+
+ if (dev_client->send_queue_size >= dev_client->max_send_queue_size) {
+ spice_char_device_handle_client_overflow(dev_client);
+ return;
+ }
+
+ msg_item = spice_new0(SpiceCharDeviceMsgToClientItem, 1);
+ msg_item->msg = dev->cbs.ref_msg_to_client(msg, dev->opaque);
+ ring_add(&dev_client->send_queue, &msg_item->link);
+ dev_client->send_queue_size++;
+ if (!dev_client->wait_for_tokens_started) {
+ core->timer_start(dev_client->wait_for_tokens_timer,
+ SPICE_CHAR_DEVICE_WAIT_TOKENS_TIMEOUT);
+ dev_client->wait_for_tokens_started = TRUE;
+ }
+}
+
+static void spice_char_device_send_msg_to_clients(SpiceCharDeviceState *dev,
+ SpiceCharDeviceMsgToClient *msg)
+{
+ RingItem *item, *next;
+
+ RING_FOREACH_SAFE(item, next, &dev->clients) {
+ SpiceCharDeviceClientState *dev_client;
+
+ dev_client = SPICE_CONTAINEROF(item, SpiceCharDeviceClientState, link);
+ if (spice_char_device_can_send_to_client(dev_client)) {
+ dev_client->num_send_tokens--;
+ spice_assert(ring_is_empty(&dev_client->send_queue));
+ dev->cbs.send_msg_to_client(msg, dev_client->client, dev->opaque);
+
+ /* don't refer to dev_client anymore, it may have been released */
+ } else {
+ spice_char_device_add_msg_to_client_queue(dev_client, msg);
+ }
+ }
+}
+
+static int spice_char_device_read_from_device(SpiceCharDeviceState *dev)
+{
+ uint64_t max_send_tokens;
+ int did_read = FALSE;
+
+ if (!dev->running || dev->wait_for_migrate_data || !dev->sin) {
+ return FALSE;
+ }
+
+ /* There are 2 scenarios where we can get called recursively:
+ * 1) spice-vmc vmc_read triggering flush of throttled data, recalling wakeup
+ * (virtio)
+ * 2) in case of sending messages to the client, and unreferencing the
+ * msg, we trigger another read.
+ */
+ if (dev->during_read_from_device++ > 0) {
+ return FALSE;
+ }
+
+ max_send_tokens = spice_char_device_max_send_tokens(dev);
+ spice_char_device_state_ref(dev);
+ /*
+ * Reading from the device only in case at least one of the clients have a free token.
+ * All messages will be discarded if no client is attached to the device
+ */
+ while ((max_send_tokens || ring_is_empty(&dev->clients)) && dev->running) {
+ SpiceCharDeviceMsgToClient *msg;
+
+ msg = dev->cbs.read_one_msg_from_device(dev->sin, dev->opaque);
+ if (!msg) {
+ if (dev->during_read_from_device > 1) {
+ dev->during_read_from_device = 1;
+ continue; /* a wakeup might have been called during the read -
+ make sure it doesn't get lost */
+ }
+ break;
+ }
+ did_read = TRUE;
+ spice_char_device_send_msg_to_clients(dev, msg);
+ dev->cbs.unref_msg_to_client(msg, dev->opaque);
+ max_send_tokens--;
+ }
+ dev->during_read_from_device = 0;
+ if (dev->running) {
+ dev->active = dev->active || did_read;
+ }
+ spice_char_device_state_unref(dev);
+ return did_read;
+}
+
+static void spice_char_device_client_send_queue_push(SpiceCharDeviceClientState *dev_client)
+{
+ RingItem *item;
+ while ((item = ring_get_tail(&dev_client->send_queue)) &&
+ spice_char_device_can_send_to_client(dev_client)) {
+ SpiceCharDeviceMsgToClientItem *msg_item;
+
+ msg_item = SPICE_CONTAINEROF(item, SpiceCharDeviceMsgToClientItem, link);
+ ring_remove(item);
+
+ dev_client->num_send_tokens--;
+ dev_client->dev->cbs.send_msg_to_client(msg_item->msg,
+ dev_client->client,
+ dev_client->dev->opaque);
+ dev_client->dev->cbs.unref_msg_to_client(msg_item->msg, dev_client->dev->opaque);
+ dev_client->send_queue_size--;
+ free(msg_item);
+ }
+}
+
+static void spice_char_device_send_to_client_tokens_absorb(SpiceCharDeviceClientState *dev_client,
+ uint32_t tokens)
+{
+ dev_client->num_send_tokens += tokens;
+
+ if (dev_client->send_queue_size) {
+ spice_assert(dev_client->num_send_tokens == tokens);
+ spice_char_device_client_send_queue_push(dev_client);
+ }
+
+ if (spice_char_device_can_send_to_client(dev_client)) {
+ core->timer_cancel(dev_client->wait_for_tokens_timer);
+ dev_client->wait_for_tokens_started = FALSE;
+ spice_char_device_read_from_device(dev_client->dev);
+ } else if (dev_client->send_queue_size) {
+ core->timer_start(dev_client->wait_for_tokens_timer,
+ SPICE_CHAR_DEVICE_WAIT_TOKENS_TIMEOUT);
+ dev_client->wait_for_tokens_started = TRUE;
+ }
+}
+
+void spice_char_device_send_to_client_tokens_add(SpiceCharDeviceState *dev,
+ RedClient *client,
+ uint32_t tokens)
+{
+ SpiceCharDeviceClientState *dev_client;
+
+ dev_client = spice_char_device_client_find(dev, client);
+
+ if (!dev_client) {
+ spice_error("client wasn't found dev %p client %p", dev, client);
+ return;
+ }
+ spice_char_device_send_to_client_tokens_absorb(dev_client, tokens);
+}
+
+void spice_char_device_send_to_client_tokens_set(SpiceCharDeviceState *dev,
+ RedClient *client,
+ uint32_t tokens)
+{
+ SpiceCharDeviceClientState *dev_client;
+
+ dev_client = spice_char_device_client_find(dev, client);
+
+ if (!dev_client) {
+ spice_error("client wasn't found dev %p client %p", dev, client);
+ return;
+ }
+
+ dev_client->num_send_tokens = 0;
+ spice_char_device_send_to_client_tokens_absorb(dev_client, tokens);
+}
+
+/**************************
+ * Writing to the device *
+***************************/
+
+static void spice_char_device_client_tokens_add(SpiceCharDeviceState *dev,
+ SpiceCharDeviceClientState *dev_client,
+ uint32_t num_tokens)
+{
+ if (!dev_client->do_flow_control) {
+ return;
+ }
+ if (num_tokens > 1) {
+ spice_debug("#tokens > 1 (=%u)", num_tokens);
+ }
+ dev_client->num_client_tokens_free += num_tokens;
+ if (dev_client->num_client_tokens_free >= dev->client_tokens_interval) {
+ uint32_t tokens = dev_client->num_client_tokens_free;
+
+ dev_client->num_client_tokens += dev_client->num_client_tokens_free;
+ dev_client->num_client_tokens_free = 0;
+ dev->cbs.send_tokens_to_client(dev_client->client,
+ tokens,
+ dev->opaque);
+ }
+}
+
+static int spice_char_device_write_to_device(SpiceCharDeviceState *dev)
+{
+ SpiceCharDeviceInterface *sif;
+ int total = 0;
+ int n;
+
+ if (!dev->running || dev->wait_for_migrate_data || !dev->sin) {
+ return 0;
+ }
+
+ /* protect against recursion with spice_char_device_wakeup */
+ if (dev->during_write_to_device++ > 0) {
+ return 0;
+ }
+
+ spice_char_device_state_ref(dev);
+
+ if (dev->write_to_dev_timer) {
+ core->timer_cancel(dev->write_to_dev_timer);
+ }
+
+ sif = SPICE_CONTAINEROF(dev->sin->base.sif, SpiceCharDeviceInterface, base);
+ while (dev->running) {
+ uint32_t write_len;
+
+ if (!dev->cur_write_buf) {
+ RingItem *item = ring_get_tail(&dev->write_queue);
+ if (!item) {
+ break;
+ }
+ dev->cur_write_buf = SPICE_CONTAINEROF(item, SpiceCharDeviceWriteBuffer, link);
+ dev->cur_write_buf_pos = dev->cur_write_buf->buf;
+ ring_remove(item);
+ }
+
+ write_len = dev->cur_write_buf->buf + dev->cur_write_buf->buf_used -
+ dev->cur_write_buf_pos;
+ n = sif->write(dev->sin, dev->cur_write_buf_pos, write_len);
+ if (n <= 0) {
+ if (dev->during_write_to_device > 1) {
+ dev->during_write_to_device = 1;
+ continue; /* a wakeup might have been called during the write -
+ make sure it doesn't get lost */
+ }
+ break;
+ }
+ total += n;
+ write_len -= n;
+ if (!write_len) {
+ SpiceCharDeviceWriteBuffer *release_buf = dev->cur_write_buf;
+ dev->cur_write_buf = NULL;
+ spice_char_device_write_buffer_release(dev, release_buf);
+ continue;
+ }
+ dev->cur_write_buf_pos += n;
+ }
+ /* retry writing as long as the write queue is not empty */
+ if (dev->running) {
+ if (dev->cur_write_buf) {
+ if (dev->write_to_dev_timer) {
+ core->timer_start(dev->write_to_dev_timer,
+ CHAR_DEVICE_WRITE_TO_TIMEOUT);
+ }
+ } else {
+ spice_assert(ring_is_empty(&dev->write_queue));
+ }
+ dev->active = dev->active || total;
+ }
+ dev->during_write_to_device = 0;
+ spice_char_device_state_unref(dev);
+ return total;
+}
+
+static void spice_char_dev_write_retry(void *opaque)
+{
+ SpiceCharDeviceState *dev = opaque;
+
+ if (dev->write_to_dev_timer) {
+ core->timer_cancel(dev->write_to_dev_timer);
+ }
+ spice_char_device_write_to_device(dev);
+}
+
+static SpiceCharDeviceWriteBuffer *__spice_char_device_write_buffer_get(
+ SpiceCharDeviceState *dev, RedClient *client,
+ int size, int origin, int migrated_data_tokens)
+{
+ RingItem *item;
+ SpiceCharDeviceWriteBuffer *ret;
+
+ if (origin == WRITE_BUFFER_ORIGIN_SERVER && !dev->num_self_tokens) {
+ return NULL;
+ }
+
+ if ((item = ring_get_tail(&dev->write_bufs_pool))) {
+ ret = SPICE_CONTAINEROF(item, SpiceCharDeviceWriteBuffer, link);
+ ring_remove(item);
+ dev->cur_pool_size -= ret->buf_size;
+ } else {
+ ret = spice_new0(SpiceCharDeviceWriteBuffer, 1);
+ }
+
+ spice_assert(!ret->buf_used);
+
+ if (ret->buf_size < size) {
+ ret->buf = spice_realloc(ret->buf, size);
+ ret->buf_size = size;
+ }
+ ret->origin = origin;
+
+ if (origin == WRITE_BUFFER_ORIGIN_CLIENT) {
+ spice_assert(client);
+ SpiceCharDeviceClientState *dev_client = spice_char_device_client_find(dev, client);
+ if (dev_client) {
+ if (!migrated_data_tokens &&
+ dev_client->do_flow_control && !dev_client->num_client_tokens) {
+ spice_printerr("token violation: dev %p client %p", dev, client);
+ spice_char_device_handle_client_overflow(dev_client);
+ goto error;
+ }
+ ret->client = client;
+ if (!migrated_data_tokens && dev_client->do_flow_control) {
+ dev_client->num_client_tokens--;
+ }
+ } else {
+ /* it is possible that the client was removed due to send tokens underflow, but
+ * the caller still receive messages from the client */
+ spice_printerr("client not found: dev %p client %p", dev, client);
+ goto error;
+ }
+ } else if (origin == WRITE_BUFFER_ORIGIN_SERVER) {
+ dev->num_self_tokens--;
+ }
+
+ ret->token_price = migrated_data_tokens ? migrated_data_tokens : 1;
+ ret->refs = 1;
+ return ret;
+error:
+ dev->cur_pool_size += ret->buf_size;
+ ring_add(&dev->write_bufs_pool, &ret->link);
+ return NULL;
+}
+
+SpiceCharDeviceWriteBuffer *spice_char_device_write_buffer_get(SpiceCharDeviceState *dev,
+ RedClient *client,
+ int size)
+{
+ return __spice_char_device_write_buffer_get(dev, client, size,
+ client ? WRITE_BUFFER_ORIGIN_CLIENT : WRITE_BUFFER_ORIGIN_SERVER,
+ 0);
+}
+
+SpiceCharDeviceWriteBuffer *spice_char_device_write_buffer_get_server_no_token(
+ SpiceCharDeviceState *dev, int size)
+{
+ return __spice_char_device_write_buffer_get(dev, NULL, size,
+ WRITE_BUFFER_ORIGIN_SERVER_NO_TOKEN, 0);
+}
+
+static SpiceCharDeviceWriteBuffer *spice_char_device_write_buffer_ref(SpiceCharDeviceWriteBuffer *write_buf)
+{
+ spice_assert(write_buf);
+
+ write_buf->refs++;
+ return write_buf;
+}
+
+static void spice_char_device_write_buffer_unref(SpiceCharDeviceWriteBuffer *write_buf)
+{
+ spice_assert(write_buf);
+
+ write_buf->refs--;
+ if (write_buf->refs == 0)
+ spice_char_device_write_buffer_free(write_buf);
+}
+
+void spice_char_device_write_buffer_add(SpiceCharDeviceState *dev,
+ SpiceCharDeviceWriteBuffer *write_buf)
+{
+ spice_assert(dev);
+ /* caller shouldn't add buffers for client that was removed */
+ if (write_buf->origin == WRITE_BUFFER_ORIGIN_CLIENT &&
+ !spice_char_device_client_find(dev, write_buf->client)) {
+ spice_printerr("client not found: dev %p client %p", dev, write_buf->client);
+ spice_char_device_write_buffer_pool_add(dev, write_buf);
+ return;
+ }
+
+ ring_add(&dev->write_queue, &write_buf->link);
+ spice_char_device_write_to_device(dev);
+}
+
+void spice_char_device_write_buffer_release(SpiceCharDeviceState *dev,
+ SpiceCharDeviceWriteBuffer *write_buf)
+{
+ int buf_origin = write_buf->origin;
+ uint32_t buf_token_price = write_buf->token_price;
+ RedClient *client = write_buf->client;
+
+ spice_assert(!ring_item_is_linked(&write_buf->link));
+ if (!dev) {
+ spice_printerr("no device. write buffer is freed");
+ spice_char_device_write_buffer_free(write_buf);
+ return;
+ }
+
+ spice_assert(dev->cur_write_buf != write_buf);
+
+ spice_char_device_write_buffer_pool_add(dev, write_buf);
+ if (buf_origin == WRITE_BUFFER_ORIGIN_CLIENT) {
+ SpiceCharDeviceClientState *dev_client;
+
+ spice_assert(client);
+ dev_client = spice_char_device_client_find(dev, client);
+ /* when a client is removed, we remove all the buffers that are associated with it */
+ spice_assert(dev_client);
+ spice_char_device_client_tokens_add(dev, dev_client, buf_token_price);
+ } else if (buf_origin == WRITE_BUFFER_ORIGIN_SERVER) {
+ dev->num_self_tokens++;
+ if (dev->cbs.on_free_self_token) {
+ dev->cbs.on_free_self_token(dev->opaque);
+ }
+ }
+}
+
+/********************************
+ * char_device_state management *
+ ********************************/
+
+SpiceCharDeviceState *spice_char_device_state_create(SpiceCharDeviceInstance *sin,
+ uint32_t client_tokens_interval,
+ uint32_t self_tokens,
+ SpiceCharDeviceCallbacks *cbs,
+ void *opaque)
+{
+ SpiceCharDeviceState *char_dev;
+ SpiceCharDeviceInterface *sif;
+
+ spice_assert(sin);
+ spice_assert(cbs->read_one_msg_from_device && cbs->ref_msg_to_client &&
+ cbs->unref_msg_to_client && cbs->send_msg_to_client &&
+ cbs->send_tokens_to_client && cbs->remove_client);
+
+ char_dev = spice_new0(SpiceCharDeviceState, 1);
+ char_dev->sin = sin;
+ char_dev->cbs = *cbs;
+ char_dev->opaque = opaque;
+ char_dev->client_tokens_interval = client_tokens_interval;
+ char_dev->num_self_tokens = self_tokens;
+
+ ring_init(&char_dev->write_queue);
+ ring_init(&char_dev->write_bufs_pool);
+ ring_init(&char_dev->clients);
+
+ sif = SPICE_CONTAINEROF(char_dev->sin->base.sif, SpiceCharDeviceInterface, base);
+ if (sif->base.minor_version <= 2 ||
+ !(sif->flags & SPICE_CHAR_DEVICE_NOTIFY_WRITABLE)) {
+ char_dev->write_to_dev_timer = core->timer_add(spice_char_dev_write_retry, char_dev);
+ if (!char_dev->write_to_dev_timer) {
+ spice_error("failed creating char dev write timer");
+ }
+ }
+
+ char_dev->refs = 1;
+ sin->st = char_dev;
+ spice_debug("sin %p dev_state %p", sin, char_dev);
+ return char_dev;
+}
+
+void spice_char_device_state_reset_dev_instance(SpiceCharDeviceState *state,
+ SpiceCharDeviceInstance *sin)
+{
+ spice_debug("sin %p dev_state %p", sin, state);
+ state->sin = sin;
+ sin->st = state;
+}
+
+void *spice_char_device_state_opaque_get(SpiceCharDeviceState *dev)
+{
+ return dev->opaque;
+}
+
+static void spice_char_device_state_ref(SpiceCharDeviceState *char_dev)
+{
+ char_dev->refs++;
+}
+
+static void spice_char_device_state_unref(SpiceCharDeviceState *char_dev)
+{
+ /* The refs field protects the char_dev from being deallocated in
+ * case spice_char_device_state_destroy has been called
+ * during a callabck, and we might still access the char_dev afterwards.
+ * spice_char_device_state_unref is always coupled with a preceding
+ * spice_char_device_state_ref. Here, refs can turn 0
+ * only when spice_char_device_state_destroy is called in between
+ * the calls to spice_char_device_state_ref and spice_char_device_state_unref.*/
+ if (!--char_dev->refs) {
+ free(char_dev);
+ }
+}
+
+void spice_char_device_state_destroy(SpiceCharDeviceState *char_dev)
+{
+ reds_on_char_device_state_destroy(char_dev);
+ if (char_dev->write_to_dev_timer) {
+ core->timer_remove(char_dev->write_to_dev_timer);
+ char_dev->write_to_dev_timer = NULL;
+ }
+ write_buffers_queue_free(&char_dev->write_queue);
+ write_buffers_queue_free(&char_dev->write_bufs_pool);
+ char_dev->cur_pool_size = 0;
+ spice_char_device_write_buffer_free(char_dev->cur_write_buf);
+ char_dev->cur_write_buf = NULL;
+
+ while (!ring_is_empty(&char_dev->clients)) {
+ RingItem *item = ring_get_tail(&char_dev->clients);
+ SpiceCharDeviceClientState *dev_client;
+
+ dev_client = SPICE_CONTAINEROF(item, SpiceCharDeviceClientState, link);
+ spice_char_device_client_free(char_dev, dev_client);
+ }
+ char_dev->running = FALSE;
+
+ spice_char_device_state_unref(char_dev);
+}
+
+int spice_char_device_client_add(SpiceCharDeviceState *dev,
+ RedClient *client,
+ int do_flow_control,
+ uint32_t max_send_queue_size,
+ uint32_t num_client_tokens,
+ uint32_t num_send_tokens,
+ int wait_for_migrate_data)
+{
+ SpiceCharDeviceClientState *dev_client;
+
+ spice_assert(dev);
+ spice_assert(client);
+
+ if (wait_for_migrate_data && (dev->num_clients > 0 || dev->active)) {
+ spice_warning("can't restore device %p from migration data. The device "
+ "has already been active", dev);
+ return FALSE;
+ }
+
+ dev->wait_for_migrate_data = wait_for_migrate_data;
+
+ spice_debug("dev_state %p client %p", dev, client);
+ dev_client = spice_new0(SpiceCharDeviceClientState, 1);
+ dev_client->dev = dev;
+ dev_client->client = client;
+ ring_init(&dev_client->send_queue);
+ dev_client->send_queue_size = 0;
+ dev_client->max_send_queue_size = max_send_queue_size;
+ dev_client->do_flow_control = do_flow_control;
+ if (do_flow_control) {
+ dev_client->wait_for_tokens_timer = core->timer_add(device_client_wait_for_tokens_timeout,
+ dev_client);
+ if (!dev_client->wait_for_tokens_timer) {
+ spice_error("failed to create wait for tokens timer");
+ }
+ dev_client->num_client_tokens = num_client_tokens;
+ dev_client->num_send_tokens = num_send_tokens;
+ } else {
+ dev_client->num_client_tokens = ~0;
+ dev_client->num_send_tokens = ~0;
+ }
+ ring_add(&dev->clients, &dev_client->link);
+ dev->num_clients++;
+ /* Now that we have a client, forward any pending device data */
+ spice_char_device_wakeup(dev);
+ return TRUE;
+}
+
+void spice_char_device_client_remove(SpiceCharDeviceState *dev,
+ RedClient *client)
+{
+ SpiceCharDeviceClientState *dev_client;
+
+ spice_debug("dev_state %p client %p", dev, client);
+ dev_client = spice_char_device_client_find(dev, client);
+
+ if (!dev_client) {
+ spice_error("client wasn't found");
+ return;
+ }
+ spice_char_device_client_free(dev, dev_client);
+ if (dev->wait_for_migrate_data) {
+ spice_assert(dev->num_clients == 0);
+ dev->wait_for_migrate_data = FALSE;
+ spice_char_device_read_from_device(dev);
+ }
+
+ if (dev->num_clients == 0) {
+ spice_debug("client removed, memory pool will be freed (%lu bytes)", dev->cur_pool_size);
+ write_buffers_queue_free(&dev->write_bufs_pool);
+ dev->cur_pool_size = 0;
+ }
+}
+
+int spice_char_device_client_exists(SpiceCharDeviceState *dev,
+ RedClient *client)
+{
+ return (spice_char_device_client_find(dev, client) != NULL);
+}
+
+void spice_char_device_start(SpiceCharDeviceState *dev)
+{
+ spice_debug("dev_state %p", dev);
+ dev->running = TRUE;
+ spice_char_device_state_ref(dev);
+ while (spice_char_device_write_to_device(dev) ||
+ spice_char_device_read_from_device(dev));
+ spice_char_device_state_unref(dev);
+}
+
+void spice_char_device_stop(SpiceCharDeviceState *dev)
+{
+ spice_debug("dev_state %p", dev);
+ dev->running = FALSE;
+ dev->active = FALSE;
+ if (dev->write_to_dev_timer) {
+ core->timer_cancel(dev->write_to_dev_timer);
+ }
+}
+
+void spice_char_device_reset(SpiceCharDeviceState *dev)
+{
+ RingItem *client_item;
+
+ spice_char_device_stop(dev);
+ dev->wait_for_migrate_data = FALSE;
+ spice_debug("dev_state %p", dev);
+ while (!ring_is_empty(&dev->write_queue)) {
+ RingItem *item = ring_get_tail(&dev->write_queue);
+ SpiceCharDeviceWriteBuffer *buf;
+
+ ring_remove(item);
+ buf = SPICE_CONTAINEROF(item, SpiceCharDeviceWriteBuffer, link);
+ /* tracking the tokens */
+ spice_char_device_write_buffer_release(dev, buf);
+ }
+ if (dev->cur_write_buf) {
+ SpiceCharDeviceWriteBuffer *release_buf = dev->cur_write_buf;
+
+ dev->cur_write_buf = NULL;
+ spice_char_device_write_buffer_release(dev, release_buf);
+ }
+
+ RING_FOREACH(client_item, &dev->clients) {
+ SpiceCharDeviceClientState *dev_client;
+
+ dev_client = SPICE_CONTAINEROF(client_item, SpiceCharDeviceClientState, link);
+ spice_char_device_client_send_queue_free(dev, dev_client);
+ }
+ dev->sin = NULL;
+}
+
+void spice_char_device_wakeup(SpiceCharDeviceState *dev)
+{
+ spice_char_device_write_to_device(dev);
+ spice_char_device_read_from_device(dev);
+}
+
+/*************
+ * Migration *
+ * **********/
+
+void spice_char_device_state_migrate_data_marshall_empty(SpiceMarshaller *m)
+{
+ SpiceMigrateDataCharDevice *mig_data;
+
+ spice_debug(NULL);
+ mig_data = (SpiceMigrateDataCharDevice *)spice_marshaller_reserve_space(m,
+ sizeof(*mig_data));
+ memset(mig_data, 0, sizeof(*mig_data));
+ mig_data->version = SPICE_MIGRATE_DATA_CHAR_DEVICE_VERSION;
+ mig_data->connected = FALSE;
+}
+
+static void migrate_data_marshaller_write_buffer_free(uint8_t *data, void *opaque)
+{
+ SpiceCharDeviceWriteBuffer *write_buf = (SpiceCharDeviceWriteBuffer *)opaque;
+
+ spice_char_device_write_buffer_unref(write_buf);
+}
+
+void spice_char_device_state_migrate_data_marshall(SpiceCharDeviceState *dev,
+ SpiceMarshaller *m)
+{
+ SpiceCharDeviceClientState *client_state;
+ RingItem *item;
+ uint32_t *write_to_dev_size_ptr;
+ uint32_t *write_to_dev_tokens_ptr;
+ SpiceMarshaller *m2;
+
+ /* multi-clients are not supported */
+ spice_assert(dev->num_clients == 1);
+ client_state = SPICE_CONTAINEROF(ring_get_tail(&dev->clients),
+ SpiceCharDeviceClientState,
+ link);
+ /* FIXME: if there were more than one client before the marshalling,
+ * it is possible that the send_queue_size > 0, and the send data
+ * should be migrated as well */
+ spice_assert(client_state->send_queue_size == 0);
+ spice_marshaller_add_uint32(m, SPICE_MIGRATE_DATA_CHAR_DEVICE_VERSION);
+ spice_marshaller_add_uint8(m, 1); /* connected */
+ spice_marshaller_add_uint32(m, client_state->num_client_tokens);
+ spice_marshaller_add_uint32(m, client_state->num_send_tokens);
+ write_to_dev_size_ptr = (uint32_t *)spice_marshaller_reserve_space(m, sizeof(uint32_t));
+ write_to_dev_tokens_ptr = (uint32_t *)spice_marshaller_reserve_space(m, sizeof(uint32_t));
+ *write_to_dev_size_ptr = 0;
+ *write_to_dev_tokens_ptr = 0;
+
+ m2 = spice_marshaller_get_ptr_submarshaller(m, 0);
+ if (dev->cur_write_buf) {
+ uint32_t buf_remaining = dev->cur_write_buf->buf + dev->cur_write_buf->buf_used -
+ dev->cur_write_buf_pos;
+ spice_marshaller_add_ref_full(m2, dev->cur_write_buf_pos, buf_remaining,
+ migrate_data_marshaller_write_buffer_free,
+ spice_char_device_write_buffer_ref(dev->cur_write_buf)
+ );
+ *write_to_dev_size_ptr += buf_remaining;
+ if (dev->cur_write_buf->origin == WRITE_BUFFER_ORIGIN_CLIENT) {
+ spice_assert(dev->cur_write_buf->client == client_state->client);
+ (*write_to_dev_tokens_ptr) += dev->cur_write_buf->token_price;
+ }
+ }
+
+ RING_FOREACH_REVERSED(item, &dev->write_queue) {
+ SpiceCharDeviceWriteBuffer *write_buf;
+
+ write_buf = SPICE_CONTAINEROF(item, SpiceCharDeviceWriteBuffer, link);
+ spice_marshaller_add_ref_full(m2, write_buf->buf, write_buf->buf_used,
+ migrate_data_marshaller_write_buffer_free,
+ spice_char_device_write_buffer_ref(write_buf)
+ );
+ *write_to_dev_size_ptr += write_buf->buf_used;
+ if (write_buf->origin == WRITE_BUFFER_ORIGIN_CLIENT) {
+ spice_assert(write_buf->client == client_state->client);
+ (*write_to_dev_tokens_ptr) += write_buf->token_price;
+ }
+ }
+ spice_debug("migration data dev %p: write_queue size %u tokens %u",
+ dev, *write_to_dev_size_ptr, *write_to_dev_tokens_ptr);
+}
+
+int spice_char_device_state_restore(SpiceCharDeviceState *dev,
+ SpiceMigrateDataCharDevice *mig_data)
+{
+ SpiceCharDeviceClientState *client_state;
+ uint32_t client_tokens_window;
+
+ spice_assert(dev->num_clients == 1 && dev->wait_for_migrate_data);
+
+ client_state = SPICE_CONTAINEROF(ring_get_tail(&dev->clients),
+ SpiceCharDeviceClientState,
+ link);
+ if (mig_data->version > SPICE_MIGRATE_DATA_CHAR_DEVICE_VERSION) {
+ spice_error("dev %p error: migration data version %u is bigger than self %u",
+ dev, mig_data->version, SPICE_MIGRATE_DATA_CHAR_DEVICE_VERSION);
+ return FALSE;
+ }
+ spice_assert(!dev->cur_write_buf && ring_is_empty(&dev->write_queue));
+ spice_assert(mig_data->connected);
+
+ client_tokens_window = client_state->num_client_tokens; /* initial state of tokens */
+ client_state->num_client_tokens = mig_data->num_client_tokens;
+ /* assumption: client_tokens_window stays the same across severs */
+ client_state->num_client_tokens_free = client_tokens_window -
+ mig_data->num_client_tokens -
+ mig_data->write_num_client_tokens;
+ client_state->num_send_tokens = mig_data->num_send_tokens;
+
+ if (mig_data->write_size > 0) {
+ if (mig_data->write_num_client_tokens) {
+ dev->cur_write_buf =
+ __spice_char_device_write_buffer_get(dev, client_state->client,
+ mig_data->write_size, WRITE_BUFFER_ORIGIN_CLIENT,
+ mig_data->write_num_client_tokens);
+ } else {
+ dev->cur_write_buf =
+ __spice_char_device_write_buffer_get(dev, NULL,
+ mig_data->write_size, WRITE_BUFFER_ORIGIN_SERVER, 0);
+ }
+ /* the first write buffer contains all the data that was saved for migration */
+ memcpy(dev->cur_write_buf->buf,
+ ((uint8_t *)mig_data) + mig_data->write_data_ptr - sizeof(SpiceMigrateDataHeader),
+ mig_data->write_size);
+ dev->cur_write_buf->buf_used = mig_data->write_size;
+ dev->cur_write_buf_pos = dev->cur_write_buf->buf;
+ }
+ dev->wait_for_migrate_data = FALSE;
+ spice_char_device_write_to_device(dev);
+ spice_char_device_read_from_device(dev);
+ return TRUE;
+}
diff --git a/server/char-device.h b/server/char-device.h
new file mode 100644
index 0000000..7449c6c
--- /dev/null
+++ b/server/char-device.h
@@ -0,0 +1,216 @@
+/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ Copyright (C) 2009-2015 Red Hat, Inc.
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, see <http://www.gnu.org/licenses/>.
+*/
+#ifndef CHAR_DEVICE_H_
+#define CHAR_DEVICE_H_
+
+#include "spice.h"
+#include "red_channel.h"
+#include "migration-protocol.h"
+
+/*
+ * Shared code for char devices, mainly for flow control.
+ *
+ * How to use the api:
+ * ==================
+ * device attached: call spice_char_device_state_create
+ * device detached: call spice_char_device_state_destroy/reset
+ *
+ * client connected and associated with a device: spice_char_device_client_add
+ * client disconnected: spice_char_device_client_remove
+ *
+ * Writing to the device
+ * ---------------------
+ * Write the data into SpiceCharDeviceWriteBuffer:
+ * call spice_char_device_write_buffer_get in order to get an appropriate buffer.
+ * call spice_char_device_write_buffer_add in order to push the buffer to the write queue.
+ * If you choose not to push the buffer to the device, call
+ * spice_char_device_write_buffer_release
+ *
+ * reading from the device
+ * -----------------------
+ * The callback read_one_msg_from_device (see below) should be implemented
+ * (using sif->read).
+ * When the device is ready, this callback is called, and is expected to
+ * return one message which is addressed to the client, or NULL if the read
+ * hasn't completed.
+ *
+ * calls triggered from the device (qemu):
+ * --------------------------------------
+ * spice_char_device_start
+ * spice_char_device_stop
+ * spice_char_device_wakeup (for reading from the device)
+ */
+
+/*
+ * Note about multiple-clients:
+ * Multiclients are currently not supported in any of the character devices:
+ * spicevmc does not allow more than one client (and at least for usb, it should stay this way).
+ * smartcard code is not compatible with more than one reader.
+ * The server and guest agent code doesn't distinguish messages from different clients.
+ * In addition, its current flow control code (e.g., tokens handling) is wrong and doesn't
+ * take into account the different clients.
+ *
+ * Nonetheless, the following code introduces some support for multiple-clients:
+ * We track the number of tokens for all the clients, and we read from the device
+ * if one of the clients have enough tokens. For the clients that don't have tokens,
+ * we queue the messages, till they receive tokens, or till a timeout.
+ *
+ * TODO:
+ * At least for the agent, not all the messages from the device will be directed to all
+ * the clients (e.g., copy from guest to a specific client). Thus, support for
+ * client-specific-messages should be added.
+ * In addition, we should have support for clients that are being connected
+ * in the middle of a message transfer from the agent to the clients.
+ *
+ * */
+
+/* buffer that is used for writing to the device */
+typedef struct SpiceCharDeviceWriteBuffer {
+ RingItem link;
+ int origin;
+ RedClient *client; /* The client that sent the message to the device.
+ NULL if the server created the message */
+
+ uint8_t *buf;
+ uint32_t buf_size;
+ uint32_t buf_used;
+ uint32_t token_price;
+ uint32_t refs;
+} SpiceCharDeviceWriteBuffer;
+
+typedef void SpiceCharDeviceMsgToClient;
+
+typedef struct SpiceCharDeviceCallbacks {
+ /*
+ * Messages that are addressed to the client can be queued in case we have
+ * multiple clients and some of them don't have enough tokens.
+ */
+
+ /* reads from the device till reaching a msg that should be sent to the client,
+ * or till the reading fails */
+ SpiceCharDeviceMsgToClient* (*read_one_msg_from_device)(SpiceCharDeviceInstance *sin,
+ void *opaque);
+ SpiceCharDeviceMsgToClient* (*ref_msg_to_client)(SpiceCharDeviceMsgToClient *msg,
+ void *opaque);
+ void (*unref_msg_to_client)(SpiceCharDeviceMsgToClient *msg,
+ void *opaque);
+ void (*send_msg_to_client)(SpiceCharDeviceMsgToClient *msg,
+ RedClient *client,
+ void *opaque); /* after this call, the message is unreferenced */
+
+ /* The cb is called when a predefined number of write buffers were consumed by the
+ * device */
+ void (*send_tokens_to_client)(RedClient *client, uint32_t tokens, void *opaque);
+
+ /* The cb is called when a server (self) message that was addressed to the device,
+ * has been completely written to it */
+ void (*on_free_self_token)(void *opaque);
+
+ /* This cb is called if it is recommanded that a client will be removed
+ * due to slow flow or due to some other error.
+ * The called instance should disconnect the client, or at least the corresponding channel */
+ void (*remove_client)(RedClient *client, void *opaque);
+} SpiceCharDeviceCallbacks;
+
+SpiceCharDeviceState *spice_char_device_state_create(SpiceCharDeviceInstance *sin,
+ uint32_t client_tokens_interval,
+ uint32_t self_tokens,
+ SpiceCharDeviceCallbacks *cbs,
+ void *opaque);
+
+void spice_char_device_state_reset_dev_instance(SpiceCharDeviceState *dev,
+ SpiceCharDeviceInstance *sin);
+void spice_char_device_state_destroy(SpiceCharDeviceState *dev);
+
+void *spice_char_device_state_opaque_get(SpiceCharDeviceState *dev);
+
+/* only one client is supported */
+void spice_char_device_state_migrate_data_marshall(SpiceCharDeviceState *dev,
+ SpiceMarshaller *m);
+void spice_char_device_state_migrate_data_marshall_empty(SpiceMarshaller *m);
+
+int spice_char_device_state_restore(SpiceCharDeviceState *dev,
+ SpiceMigrateDataCharDevice *mig_data);
+
+/*
+ * Resets write/read queues, and moves that state to being stopped.
+ * This routine is a workaround for a bad tokens management in the vdagent
+ * protocol:
+ * The client tokens' are set only once, when the main channel is initialized.
+ * Instead, it would have been more appropriate to reset them upon AGEN_CONNECT.
+ * The client tokens are tracked as part of the SpiceCharDeviceClientState. Thus,
+ * in order to be backwartd compatible with the client, we need to track the tokens
+ * event when the agent is detached. We don't destroy the char_device state, and
+ * instead we just reset it.
+ * In addition, there is a misshandling of AGENT_TOKENS message in spice-gtk: it
+ * overrides the amount of tokens, instead of adding the given amount.
+ *
+ * todo: change AGENT_CONNECT msg to contain tokens count.
+ */
+void spice_char_device_reset(SpiceCharDeviceState *dev);
+
+/* max_send_queue_size = how many messages we can read from the device and enqueue for this client,
+ * when we have tokens for other clients and no tokens for this one */
+int spice_char_device_client_add(SpiceCharDeviceState *dev,
+ RedClient *client,
+ int do_flow_control,
+ uint32_t max_send_queue_size,
+ uint32_t num_client_tokens,
+ uint32_t num_send_tokens,
+ int wait_for_migrate_data);
+
+void spice_char_device_client_remove(SpiceCharDeviceState *dev,
+ RedClient *client);
+int spice_char_device_client_exists(SpiceCharDeviceState *dev,
+ RedClient *client);
+
+void spice_char_device_start(SpiceCharDeviceState *dev);
+void spice_char_device_stop(SpiceCharDeviceState *dev);
+
+/** Read from device **/
+
+void spice_char_device_wakeup(SpiceCharDeviceState *dev);
+
+void spice_char_device_send_to_client_tokens_add(SpiceCharDeviceState *dev,
+ RedClient *client,
+ uint32_t tokens);
+
+
+void spice_char_device_send_to_client_tokens_set(SpiceCharDeviceState *dev,
+ RedClient *client,
+ uint32_t tokens);
+/** Write to device **/
+
+SpiceCharDeviceWriteBuffer *spice_char_device_write_buffer_get(SpiceCharDeviceState *dev,
+ RedClient *client, int size);
+SpiceCharDeviceWriteBuffer *spice_char_device_write_buffer_get_server_no_token(
+ SpiceCharDeviceState *dev, int size);
+
+/* Either add the buffer to the write queue or release it */
+void spice_char_device_write_buffer_add(SpiceCharDeviceState *dev,
+ SpiceCharDeviceWriteBuffer *write_buf);
+void spice_char_device_write_buffer_release(SpiceCharDeviceState *dev,
+ SpiceCharDeviceWriteBuffer *write_buf);
+
+/* api for specific char devices */
+
+SpiceCharDeviceState *spicevmc_device_connect(SpiceCharDeviceInstance *sin,
+ uint8_t channel_type);
+void spicevmc_device_disconnect(SpiceCharDeviceInstance *char_device);
+
+#endif // CHAR_DEVICE_H_
diff --git a/server/char_device.c b/server/char_device.c
deleted file mode 100644
index ae7cb98..0000000
--- a/server/char_device.c
+++ /dev/null
@@ -1,1035 +0,0 @@
-/* spice-server char device flow control code
-
- Copyright (C) 2012 Red Hat, Inc.
-
- Red Hat Authors:
- Yonit Halperin <yhalperi@xxxxxxxxxx>
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, see <http:www.gnu.org/licenses/>.
-*/
-
-
-#include <config.h>
-#include "char_device.h"
-#include "red_channel.h"
-#include "reds.h"
-
-#define CHAR_DEVICE_WRITE_TO_TIMEOUT 100
-#define SPICE_CHAR_DEVICE_WAIT_TOKENS_TIMEOUT 30000
-#define MAX_POOL_SIZE (10 * 64 * 1024)
-
-typedef struct SpiceCharDeviceClientState SpiceCharDeviceClientState;
-struct SpiceCharDeviceClientState {
- RingItem link;
- SpiceCharDeviceState *dev;
- RedClient *client;
- int do_flow_control;
- uint64_t num_client_tokens;
- uint64_t num_client_tokens_free; /* client messages that were consumed by the device */
- uint64_t num_send_tokens; /* send to client */
- SpiceTimer *wait_for_tokens_timer;
- int wait_for_tokens_started;
- Ring send_queue;
- uint32_t send_queue_size;
- uint32_t max_send_queue_size;
-};
-
-struct SpiceCharDeviceState {
- int running;
- int active; /* has read/write been performed since the device was started */
- int wait_for_migrate_data;
- uint32_t refs;
-
- Ring write_queue;
- Ring write_bufs_pool;
- uint64_t cur_pool_size;
- SpiceCharDeviceWriteBuffer *cur_write_buf;
- uint8_t *cur_write_buf_pos;
- SpiceTimer *write_to_dev_timer;
- uint64_t num_self_tokens;
-
- Ring clients; /* list of SpiceCharDeviceClientState */
- uint32_t num_clients;
-
- uint64_t client_tokens_interval; /* frequency of returning tokens to the client */
- SpiceCharDeviceInstance *sin;
-
- int during_read_from_device;
- int during_write_to_device;
-
- SpiceCharDeviceCallbacks cbs;
- void *opaque;
-};
-
-enum {
- WRITE_BUFFER_ORIGIN_NONE,
- WRITE_BUFFER_ORIGIN_CLIENT,
- WRITE_BUFFER_ORIGIN_SERVER,
- WRITE_BUFFER_ORIGIN_SERVER_NO_TOKEN,
-};
-
-/* Holding references for avoiding access violation if the char device was
- * destroyed during a callback */
-static void spice_char_device_state_ref(SpiceCharDeviceState *char_dev);
-static void spice_char_device_state_unref(SpiceCharDeviceState *char_dev);
-static void spice_char_device_write_buffer_unref(SpiceCharDeviceWriteBuffer *write_buf);
-
-static void spice_char_dev_write_retry(void *opaque);
-
-typedef struct SpiceCharDeviceMsgToClientItem {
- RingItem link;
- SpiceCharDeviceMsgToClient *msg;
-} SpiceCharDeviceMsgToClientItem;
-
-static void spice_char_device_write_buffer_free(SpiceCharDeviceWriteBuffer *buf)
-{
- if (buf == NULL)
- return;
-
- free(buf->buf);
- free(buf);
-}
-
-static void write_buffers_queue_free(Ring *write_queue)
-{
- while (!ring_is_empty(write_queue)) {
- RingItem *item = ring_get_tail(write_queue);
- SpiceCharDeviceWriteBuffer *buf;
-
- ring_remove(item);
- buf = SPICE_CONTAINEROF(item, SpiceCharDeviceWriteBuffer, link);
- spice_char_device_write_buffer_free(buf);
- }
-}
-
-static void spice_char_device_write_buffer_pool_add(SpiceCharDeviceState *dev,
- SpiceCharDeviceWriteBuffer *buf)
-{
- if (buf->refs == 1 &&
- dev->cur_pool_size < MAX_POOL_SIZE) {
- buf->buf_used = 0;
- buf->origin = WRITE_BUFFER_ORIGIN_NONE;
- buf->client = NULL;
- dev->cur_pool_size += buf->buf_size;
- ring_add(&dev->write_bufs_pool, &buf->link);
- return;
- }
-
- /* Buffer still being used - just unref for the caller */
- spice_char_device_write_buffer_unref(buf);
-}
-
-static void spice_char_device_client_send_queue_free(SpiceCharDeviceState *dev,
- SpiceCharDeviceClientState *dev_client)
-{
- spice_debug("send_queue_empty %d", ring_is_empty(&dev_client->send_queue));
- while (!ring_is_empty(&dev_client->send_queue)) {
- RingItem *item = ring_get_tail(&dev_client->send_queue);
- SpiceCharDeviceMsgToClientItem *msg_item = SPICE_CONTAINEROF(item,
- SpiceCharDeviceMsgToClientItem,
- link);
-
- ring_remove(item);
- dev->cbs.unref_msg_to_client(msg_item->msg, dev->opaque);
- free(msg_item);
- }
- dev_client->num_send_tokens += dev_client->send_queue_size;
- dev_client->send_queue_size = 0;
-}
-
-static void spice_char_device_client_free(SpiceCharDeviceState *dev,
- SpiceCharDeviceClientState *dev_client)
-{
- RingItem *item, *next;
-
- if (dev_client->wait_for_tokens_timer) {
- core->timer_remove(dev_client->wait_for_tokens_timer);
- }
-
- spice_char_device_client_send_queue_free(dev, dev_client);
-
- /* remove write buffers that are associated with the client */
- spice_debug("write_queue_is_empty %d", ring_is_empty(&dev->write_queue) && !dev->cur_write_buf);
- RING_FOREACH_SAFE(item, next, &dev->write_queue) {
- SpiceCharDeviceWriteBuffer *write_buf;
-
- write_buf = SPICE_CONTAINEROF(item, SpiceCharDeviceWriteBuffer, link);
- if (write_buf->origin == WRITE_BUFFER_ORIGIN_CLIENT &&
- write_buf->client == dev_client->client) {
- ring_remove(item);
- spice_char_device_write_buffer_pool_add(dev, write_buf);
- }
- }
-
- if (dev->cur_write_buf && dev->cur_write_buf->origin == WRITE_BUFFER_ORIGIN_CLIENT &&
- dev->cur_write_buf->client == dev_client->client) {
- dev->cur_write_buf->origin = WRITE_BUFFER_ORIGIN_NONE;
- dev->cur_write_buf->client = NULL;
- }
-
- dev->num_clients--;
- ring_remove(&dev_client->link);
- free(dev_client);
-}
-
-static void spice_char_device_handle_client_overflow(SpiceCharDeviceClientState *dev_client)
-{
- SpiceCharDeviceState *dev = dev_client->dev;
- spice_printerr("dev %p client %p ", dev, dev_client);
- dev->cbs.remove_client(dev_client->client, dev->opaque);
-}
-
-static SpiceCharDeviceClientState *spice_char_device_client_find(SpiceCharDeviceState *dev,
- RedClient *client)
-{
- RingItem *item;
-
- RING_FOREACH(item, &dev->clients) {
- SpiceCharDeviceClientState *dev_client;
-
- dev_client = SPICE_CONTAINEROF(item, SpiceCharDeviceClientState, link);
- if (dev_client->client == client) {
- return dev_client;
- }
- }
- return NULL;
-}
-
-/***************************
- * Reading from the device *
- **************************/
-
-static void device_client_wait_for_tokens_timeout(void *opaque)
-{
- SpiceCharDeviceClientState *dev_client = opaque;
-
- spice_char_device_handle_client_overflow(dev_client);
-}
-
-static int spice_char_device_can_send_to_client(SpiceCharDeviceClientState *dev_client)
-{
- return !dev_client->do_flow_control || dev_client->num_send_tokens;
-}
-
-static uint64_t spice_char_device_max_send_tokens(SpiceCharDeviceState *dev)
-{
- RingItem *item;
- uint64_t max = 0;
-
- RING_FOREACH(item, &dev->clients) {
- SpiceCharDeviceClientState *dev_client;
-
- dev_client = SPICE_CONTAINEROF(item, SpiceCharDeviceClientState, link);
-
- if (!dev_client->do_flow_control) {
- max = ~0;
- break;
- }
-
- if (dev_client->num_send_tokens > max) {
- max = dev_client->num_send_tokens;
- }
- }
- return max;
-}
-
-static void spice_char_device_add_msg_to_client_queue(SpiceCharDeviceClientState *dev_client,
- SpiceCharDeviceMsgToClient *msg)
-{
- SpiceCharDeviceState *dev = dev_client->dev;
- SpiceCharDeviceMsgToClientItem *msg_item;
-
- if (dev_client->send_queue_size >= dev_client->max_send_queue_size) {
- spice_char_device_handle_client_overflow(dev_client);
- return;
- }
-
- msg_item = spice_new0(SpiceCharDeviceMsgToClientItem, 1);
- msg_item->msg = dev->cbs.ref_msg_to_client(msg, dev->opaque);
- ring_add(&dev_client->send_queue, &msg_item->link);
- dev_client->send_queue_size++;
- if (!dev_client->wait_for_tokens_started) {
- core->timer_start(dev_client->wait_for_tokens_timer,
- SPICE_CHAR_DEVICE_WAIT_TOKENS_TIMEOUT);
- dev_client->wait_for_tokens_started = TRUE;
- }
-}
-
-static void spice_char_device_send_msg_to_clients(SpiceCharDeviceState *dev,
- SpiceCharDeviceMsgToClient *msg)
-{
- RingItem *item, *next;
-
- RING_FOREACH_SAFE(item, next, &dev->clients) {
- SpiceCharDeviceClientState *dev_client;
-
- dev_client = SPICE_CONTAINEROF(item, SpiceCharDeviceClientState, link);
- if (spice_char_device_can_send_to_client(dev_client)) {
- dev_client->num_send_tokens--;
- spice_assert(ring_is_empty(&dev_client->send_queue));
- dev->cbs.send_msg_to_client(msg, dev_client->client, dev->opaque);
-
- /* don't refer to dev_client anymore, it may have been released */
- } else {
- spice_char_device_add_msg_to_client_queue(dev_client, msg);
- }
- }
-}
-
-static int spice_char_device_read_from_device(SpiceCharDeviceState *dev)
-{
- uint64_t max_send_tokens;
- int did_read = FALSE;
-
- if (!dev->running || dev->wait_for_migrate_data || !dev->sin) {
- return FALSE;
- }
-
- /* There are 2 scenarios where we can get called recursively:
- * 1) spice-vmc vmc_read triggering flush of throttled data, recalling wakeup
- * (virtio)
- * 2) in case of sending messages to the client, and unreferencing the
- * msg, we trigger another read.
- */
- if (dev->during_read_from_device++ > 0) {
- return FALSE;
- }
-
- max_send_tokens = spice_char_device_max_send_tokens(dev);
- spice_char_device_state_ref(dev);
- /*
- * Reading from the device only in case at least one of the clients have a free token.
- * All messages will be discarded if no client is attached to the device
- */
- while ((max_send_tokens || ring_is_empty(&dev->clients)) && dev->running) {
- SpiceCharDeviceMsgToClient *msg;
-
- msg = dev->cbs.read_one_msg_from_device(dev->sin, dev->opaque);
- if (!msg) {
- if (dev->during_read_from_device > 1) {
- dev->during_read_from_device = 1;
- continue; /* a wakeup might have been called during the read -
- make sure it doesn't get lost */
- }
- break;
- }
- did_read = TRUE;
- spice_char_device_send_msg_to_clients(dev, msg);
- dev->cbs.unref_msg_to_client(msg, dev->opaque);
- max_send_tokens--;
- }
- dev->during_read_from_device = 0;
- if (dev->running) {
- dev->active = dev->active || did_read;
- }
- spice_char_device_state_unref(dev);
- return did_read;
-}
-
-static void spice_char_device_client_send_queue_push(SpiceCharDeviceClientState *dev_client)
-{
- RingItem *item;
- while ((item = ring_get_tail(&dev_client->send_queue)) &&
- spice_char_device_can_send_to_client(dev_client)) {
- SpiceCharDeviceMsgToClientItem *msg_item;
-
- msg_item = SPICE_CONTAINEROF(item, SpiceCharDeviceMsgToClientItem, link);
- ring_remove(item);
-
- dev_client->num_send_tokens--;
- dev_client->dev->cbs.send_msg_to_client(msg_item->msg,
- dev_client->client,
- dev_client->dev->opaque);
- dev_client->dev->cbs.unref_msg_to_client(msg_item->msg, dev_client->dev->opaque);
- dev_client->send_queue_size--;
- free(msg_item);
- }
-}
-
-static void spice_char_device_send_to_client_tokens_absorb(SpiceCharDeviceClientState *dev_client,
- uint32_t tokens)
-{
- dev_client->num_send_tokens += tokens;
-
- if (dev_client->send_queue_size) {
- spice_assert(dev_client->num_send_tokens == tokens);
- spice_char_device_client_send_queue_push(dev_client);
- }
-
- if (spice_char_device_can_send_to_client(dev_client)) {
- core->timer_cancel(dev_client->wait_for_tokens_timer);
- dev_client->wait_for_tokens_started = FALSE;
- spice_char_device_read_from_device(dev_client->dev);
- } else if (dev_client->send_queue_size) {
- core->timer_start(dev_client->wait_for_tokens_timer,
- SPICE_CHAR_DEVICE_WAIT_TOKENS_TIMEOUT);
- dev_client->wait_for_tokens_started = TRUE;
- }
-}
-
-void spice_char_device_send_to_client_tokens_add(SpiceCharDeviceState *dev,
- RedClient *client,
- uint32_t tokens)
-{
- SpiceCharDeviceClientState *dev_client;
-
- dev_client = spice_char_device_client_find(dev, client);
-
- if (!dev_client) {
- spice_error("client wasn't found dev %p client %p", dev, client);
- return;
- }
- spice_char_device_send_to_client_tokens_absorb(dev_client, tokens);
-}
-
-void spice_char_device_send_to_client_tokens_set(SpiceCharDeviceState *dev,
- RedClient *client,
- uint32_t tokens)
-{
- SpiceCharDeviceClientState *dev_client;
-
- dev_client = spice_char_device_client_find(dev, client);
-
- if (!dev_client) {
- spice_error("client wasn't found dev %p client %p", dev, client);
- return;
- }
-
- dev_client->num_send_tokens = 0;
- spice_char_device_send_to_client_tokens_absorb(dev_client, tokens);
-}
-
-/**************************
- * Writing to the device *
-***************************/
-
-static void spice_char_device_client_tokens_add(SpiceCharDeviceState *dev,
- SpiceCharDeviceClientState *dev_client,
- uint32_t num_tokens)
-{
- if (!dev_client->do_flow_control) {
- return;
- }
- if (num_tokens > 1) {
- spice_debug("#tokens > 1 (=%u)", num_tokens);
- }
- dev_client->num_client_tokens_free += num_tokens;
- if (dev_client->num_client_tokens_free >= dev->client_tokens_interval) {
- uint32_t tokens = dev_client->num_client_tokens_free;
-
- dev_client->num_client_tokens += dev_client->num_client_tokens_free;
- dev_client->num_client_tokens_free = 0;
- dev->cbs.send_tokens_to_client(dev_client->client,
- tokens,
- dev->opaque);
- }
-}
-
-static int spice_char_device_write_to_device(SpiceCharDeviceState *dev)
-{
- SpiceCharDeviceInterface *sif;
- int total = 0;
- int n;
-
- if (!dev->running || dev->wait_for_migrate_data || !dev->sin) {
- return 0;
- }
-
- /* protect against recursion with spice_char_device_wakeup */
- if (dev->during_write_to_device++ > 0) {
- return 0;
- }
-
- spice_char_device_state_ref(dev);
-
- if (dev->write_to_dev_timer) {
- core->timer_cancel(dev->write_to_dev_timer);
- }
-
- sif = SPICE_CONTAINEROF(dev->sin->base.sif, SpiceCharDeviceInterface, base);
- while (dev->running) {
- uint32_t write_len;
-
- if (!dev->cur_write_buf) {
- RingItem *item = ring_get_tail(&dev->write_queue);
- if (!item) {
- break;
- }
- dev->cur_write_buf = SPICE_CONTAINEROF(item, SpiceCharDeviceWriteBuffer, link);
- dev->cur_write_buf_pos = dev->cur_write_buf->buf;
- ring_remove(item);
- }
-
- write_len = dev->cur_write_buf->buf + dev->cur_write_buf->buf_used -
- dev->cur_write_buf_pos;
- n = sif->write(dev->sin, dev->cur_write_buf_pos, write_len);
- if (n <= 0) {
- if (dev->during_write_to_device > 1) {
- dev->during_write_to_device = 1;
- continue; /* a wakeup might have been called during the write -
- make sure it doesn't get lost */
- }
- break;
- }
- total += n;
- write_len -= n;
- if (!write_len) {
- SpiceCharDeviceWriteBuffer *release_buf = dev->cur_write_buf;
- dev->cur_write_buf = NULL;
- spice_char_device_write_buffer_release(dev, release_buf);
- continue;
- }
- dev->cur_write_buf_pos += n;
- }
- /* retry writing as long as the write queue is not empty */
- if (dev->running) {
- if (dev->cur_write_buf) {
- if (dev->write_to_dev_timer) {
- core->timer_start(dev->write_to_dev_timer,
- CHAR_DEVICE_WRITE_TO_TIMEOUT);
- }
- } else {
- spice_assert(ring_is_empty(&dev->write_queue));
- }
- dev->active = dev->active || total;
- }
- dev->during_write_to_device = 0;
- spice_char_device_state_unref(dev);
- return total;
-}
-
-static void spice_char_dev_write_retry(void *opaque)
-{
- SpiceCharDeviceState *dev = opaque;
-
- if (dev->write_to_dev_timer) {
- core->timer_cancel(dev->write_to_dev_timer);
- }
- spice_char_device_write_to_device(dev);
-}
-
-static SpiceCharDeviceWriteBuffer *__spice_char_device_write_buffer_get(
- SpiceCharDeviceState *dev, RedClient *client,
- int size, int origin, int migrated_data_tokens)
-{
- RingItem *item;
- SpiceCharDeviceWriteBuffer *ret;
-
- if (origin == WRITE_BUFFER_ORIGIN_SERVER && !dev->num_self_tokens) {
- return NULL;
- }
-
- if ((item = ring_get_tail(&dev->write_bufs_pool))) {
- ret = SPICE_CONTAINEROF(item, SpiceCharDeviceWriteBuffer, link);
- ring_remove(item);
- dev->cur_pool_size -= ret->buf_size;
- } else {
- ret = spice_new0(SpiceCharDeviceWriteBuffer, 1);
- }
-
- spice_assert(!ret->buf_used);
-
- if (ret->buf_size < size) {
- ret->buf = spice_realloc(ret->buf, size);
- ret->buf_size = size;
- }
- ret->origin = origin;
-
- if (origin == WRITE_BUFFER_ORIGIN_CLIENT) {
- spice_assert(client);
- SpiceCharDeviceClientState *dev_client = spice_char_device_client_find(dev, client);
- if (dev_client) {
- if (!migrated_data_tokens &&
- dev_client->do_flow_control && !dev_client->num_client_tokens) {
- spice_printerr("token violation: dev %p client %p", dev, client);
- spice_char_device_handle_client_overflow(dev_client);
- goto error;
- }
- ret->client = client;
- if (!migrated_data_tokens && dev_client->do_flow_control) {
- dev_client->num_client_tokens--;
- }
- } else {
- /* it is possible that the client was removed due to send tokens underflow, but
- * the caller still receive messages from the client */
- spice_printerr("client not found: dev %p client %p", dev, client);
- goto error;
- }
- } else if (origin == WRITE_BUFFER_ORIGIN_SERVER) {
- dev->num_self_tokens--;
- }
-
- ret->token_price = migrated_data_tokens ? migrated_data_tokens : 1;
- ret->refs = 1;
- return ret;
-error:
- dev->cur_pool_size += ret->buf_size;
- ring_add(&dev->write_bufs_pool, &ret->link);
- return NULL;
-}
-
-SpiceCharDeviceWriteBuffer *spice_char_device_write_buffer_get(SpiceCharDeviceState *dev,
- RedClient *client,
- int size)
-{
- return __spice_char_device_write_buffer_get(dev, client, size,
- client ? WRITE_BUFFER_ORIGIN_CLIENT : WRITE_BUFFER_ORIGIN_SERVER,
- 0);
-}
-
-SpiceCharDeviceWriteBuffer *spice_char_device_write_buffer_get_server_no_token(
- SpiceCharDeviceState *dev, int size)
-{
- return __spice_char_device_write_buffer_get(dev, NULL, size,
- WRITE_BUFFER_ORIGIN_SERVER_NO_TOKEN, 0);
-}
-
-static SpiceCharDeviceWriteBuffer *spice_char_device_write_buffer_ref(SpiceCharDeviceWriteBuffer *write_buf)
-{
- spice_assert(write_buf);
-
- write_buf->refs++;
- return write_buf;
-}
-
-static void spice_char_device_write_buffer_unref(SpiceCharDeviceWriteBuffer *write_buf)
-{
- spice_assert(write_buf);
-
- write_buf->refs--;
- if (write_buf->refs == 0)
- spice_char_device_write_buffer_free(write_buf);
-}
-
-void spice_char_device_write_buffer_add(SpiceCharDeviceState *dev,
- SpiceCharDeviceWriteBuffer *write_buf)
-{
- spice_assert(dev);
- /* caller shouldn't add buffers for client that was removed */
- if (write_buf->origin == WRITE_BUFFER_ORIGIN_CLIENT &&
- !spice_char_device_client_find(dev, write_buf->client)) {
- spice_printerr("client not found: dev %p client %p", dev, write_buf->client);
- spice_char_device_write_buffer_pool_add(dev, write_buf);
- return;
- }
-
- ring_add(&dev->write_queue, &write_buf->link);
- spice_char_device_write_to_device(dev);
-}
-
-void spice_char_device_write_buffer_release(SpiceCharDeviceState *dev,
- SpiceCharDeviceWriteBuffer *write_buf)
-{
- int buf_origin = write_buf->origin;
- uint32_t buf_token_price = write_buf->token_price;
- RedClient *client = write_buf->client;
-
- spice_assert(!ring_item_is_linked(&write_buf->link));
- if (!dev) {
- spice_printerr("no device. write buffer is freed");
- spice_char_device_write_buffer_free(write_buf);
- return;
- }
-
- spice_assert(dev->cur_write_buf != write_buf);
-
- spice_char_device_write_buffer_pool_add(dev, write_buf);
- if (buf_origin == WRITE_BUFFER_ORIGIN_CLIENT) {
- SpiceCharDeviceClientState *dev_client;
-
- spice_assert(client);
- dev_client = spice_char_device_client_find(dev, client);
- /* when a client is removed, we remove all the buffers that are associated with it */
- spice_assert(dev_client);
- spice_char_device_client_tokens_add(dev, dev_client, buf_token_price);
- } else if (buf_origin == WRITE_BUFFER_ORIGIN_SERVER) {
- dev->num_self_tokens++;
- if (dev->cbs.on_free_self_token) {
- dev->cbs.on_free_self_token(dev->opaque);
- }
- }
-}
-
-/********************************
- * char_device_state management *
- ********************************/
-
-SpiceCharDeviceState *spice_char_device_state_create(SpiceCharDeviceInstance *sin,
- uint32_t client_tokens_interval,
- uint32_t self_tokens,
- SpiceCharDeviceCallbacks *cbs,
- void *opaque)
-{
- SpiceCharDeviceState *char_dev;
- SpiceCharDeviceInterface *sif;
-
- spice_assert(sin);
- spice_assert(cbs->read_one_msg_from_device && cbs->ref_msg_to_client &&
- cbs->unref_msg_to_client && cbs->send_msg_to_client &&
- cbs->send_tokens_to_client && cbs->remove_client);
-
- char_dev = spice_new0(SpiceCharDeviceState, 1);
- char_dev->sin = sin;
- char_dev->cbs = *cbs;
- char_dev->opaque = opaque;
- char_dev->client_tokens_interval = client_tokens_interval;
- char_dev->num_self_tokens = self_tokens;
-
- ring_init(&char_dev->write_queue);
- ring_init(&char_dev->write_bufs_pool);
- ring_init(&char_dev->clients);
-
- sif = SPICE_CONTAINEROF(char_dev->sin->base.sif, SpiceCharDeviceInterface, base);
- if (sif->base.minor_version <= 2 ||
- !(sif->flags & SPICE_CHAR_DEVICE_NOTIFY_WRITABLE)) {
- char_dev->write_to_dev_timer = core->timer_add(spice_char_dev_write_retry, char_dev);
- if (!char_dev->write_to_dev_timer) {
- spice_error("failed creating char dev write timer");
- }
- }
-
- char_dev->refs = 1;
- sin->st = char_dev;
- spice_debug("sin %p dev_state %p", sin, char_dev);
- return char_dev;
-}
-
-void spice_char_device_state_reset_dev_instance(SpiceCharDeviceState *state,
- SpiceCharDeviceInstance *sin)
-{
- spice_debug("sin %p dev_state %p", sin, state);
- state->sin = sin;
- sin->st = state;
-}
-
-void *spice_char_device_state_opaque_get(SpiceCharDeviceState *dev)
-{
- return dev->opaque;
-}
-
-static void spice_char_device_state_ref(SpiceCharDeviceState *char_dev)
-{
- char_dev->refs++;
-}
-
-static void spice_char_device_state_unref(SpiceCharDeviceState *char_dev)
-{
- /* The refs field protects the char_dev from being deallocated in
- * case spice_char_device_state_destroy has been called
- * during a callabck, and we might still access the char_dev afterwards.
- * spice_char_device_state_unref is always coupled with a preceding
- * spice_char_device_state_ref. Here, refs can turn 0
- * only when spice_char_device_state_destroy is called in between
- * the calls to spice_char_device_state_ref and spice_char_device_state_unref.*/
- if (!--char_dev->refs) {
- free(char_dev);
- }
-}
-
-void spice_char_device_state_destroy(SpiceCharDeviceState *char_dev)
-{
- reds_on_char_device_state_destroy(char_dev);
- if (char_dev->write_to_dev_timer) {
- core->timer_remove(char_dev->write_to_dev_timer);
- char_dev->write_to_dev_timer = NULL;
- }
- write_buffers_queue_free(&char_dev->write_queue);
- write_buffers_queue_free(&char_dev->write_bufs_pool);
- char_dev->cur_pool_size = 0;
- spice_char_device_write_buffer_free(char_dev->cur_write_buf);
- char_dev->cur_write_buf = NULL;
-
- while (!ring_is_empty(&char_dev->clients)) {
- RingItem *item = ring_get_tail(&char_dev->clients);
- SpiceCharDeviceClientState *dev_client;
-
- dev_client = SPICE_CONTAINEROF(item, SpiceCharDeviceClientState, link);
- spice_char_device_client_free(char_dev, dev_client);
- }
- char_dev->running = FALSE;
-
- spice_char_device_state_unref(char_dev);
-}
-
-int spice_char_device_client_add(SpiceCharDeviceState *dev,
- RedClient *client,
- int do_flow_control,
- uint32_t max_send_queue_size,
- uint32_t num_client_tokens,
- uint32_t num_send_tokens,
- int wait_for_migrate_data)
-{
- SpiceCharDeviceClientState *dev_client;
-
- spice_assert(dev);
- spice_assert(client);
-
- if (wait_for_migrate_data && (dev->num_clients > 0 || dev->active)) {
- spice_warning("can't restore device %p from migration data. The device "
- "has already been active", dev);
- return FALSE;
- }
-
- dev->wait_for_migrate_data = wait_for_migrate_data;
-
- spice_debug("dev_state %p client %p", dev, client);
- dev_client = spice_new0(SpiceCharDeviceClientState, 1);
- dev_client->dev = dev;
- dev_client->client = client;
- ring_init(&dev_client->send_queue);
- dev_client->send_queue_size = 0;
- dev_client->max_send_queue_size = max_send_queue_size;
- dev_client->do_flow_control = do_flow_control;
- if (do_flow_control) {
- dev_client->wait_for_tokens_timer = core->timer_add(device_client_wait_for_tokens_timeout,
- dev_client);
- if (!dev_client->wait_for_tokens_timer) {
- spice_error("failed to create wait for tokens timer");
- }
- dev_client->num_client_tokens = num_client_tokens;
- dev_client->num_send_tokens = num_send_tokens;
- } else {
- dev_client->num_client_tokens = ~0;
- dev_client->num_send_tokens = ~0;
- }
- ring_add(&dev->clients, &dev_client->link);
- dev->num_clients++;
- /* Now that we have a client, forward any pending device data */
- spice_char_device_wakeup(dev);
- return TRUE;
-}
-
-void spice_char_device_client_remove(SpiceCharDeviceState *dev,
- RedClient *client)
-{
- SpiceCharDeviceClientState *dev_client;
-
- spice_debug("dev_state %p client %p", dev, client);
- dev_client = spice_char_device_client_find(dev, client);
-
- if (!dev_client) {
- spice_error("client wasn't found");
- return;
- }
- spice_char_device_client_free(dev, dev_client);
- if (dev->wait_for_migrate_data) {
- spice_assert(dev->num_clients == 0);
- dev->wait_for_migrate_data = FALSE;
- spice_char_device_read_from_device(dev);
- }
-
- if (dev->num_clients == 0) {
- spice_debug("client removed, memory pool will be freed (%lu bytes)", dev->cur_pool_size);
- write_buffers_queue_free(&dev->write_bufs_pool);
- dev->cur_pool_size = 0;
- }
-}
-
-int spice_char_device_client_exists(SpiceCharDeviceState *dev,
- RedClient *client)
-{
- return (spice_char_device_client_find(dev, client) != NULL);
-}
-
-void spice_char_device_start(SpiceCharDeviceState *dev)
-{
- spice_debug("dev_state %p", dev);
- dev->running = TRUE;
- spice_char_device_state_ref(dev);
- while (spice_char_device_write_to_device(dev) ||
- spice_char_device_read_from_device(dev));
- spice_char_device_state_unref(dev);
-}
-
-void spice_char_device_stop(SpiceCharDeviceState *dev)
-{
- spice_debug("dev_state %p", dev);
- dev->running = FALSE;
- dev->active = FALSE;
- if (dev->write_to_dev_timer) {
- core->timer_cancel(dev->write_to_dev_timer);
- }
-}
-
-void spice_char_device_reset(SpiceCharDeviceState *dev)
-{
- RingItem *client_item;
-
- spice_char_device_stop(dev);
- dev->wait_for_migrate_data = FALSE;
- spice_debug("dev_state %p", dev);
- while (!ring_is_empty(&dev->write_queue)) {
- RingItem *item = ring_get_tail(&dev->write_queue);
- SpiceCharDeviceWriteBuffer *buf;
-
- ring_remove(item);
- buf = SPICE_CONTAINEROF(item, SpiceCharDeviceWriteBuffer, link);
- /* tracking the tokens */
- spice_char_device_write_buffer_release(dev, buf);
- }
- if (dev->cur_write_buf) {
- SpiceCharDeviceWriteBuffer *release_buf = dev->cur_write_buf;
-
- dev->cur_write_buf = NULL;
- spice_char_device_write_buffer_release(dev, release_buf);
- }
-
- RING_FOREACH(client_item, &dev->clients) {
- SpiceCharDeviceClientState *dev_client;
-
- dev_client = SPICE_CONTAINEROF(client_item, SpiceCharDeviceClientState, link);
- spice_char_device_client_send_queue_free(dev, dev_client);
- }
- dev->sin = NULL;
-}
-
-void spice_char_device_wakeup(SpiceCharDeviceState *dev)
-{
- spice_char_device_write_to_device(dev);
- spice_char_device_read_from_device(dev);
-}
-
-/*************
- * Migration *
- * **********/
-
-void spice_char_device_state_migrate_data_marshall_empty(SpiceMarshaller *m)
-{
- SpiceMigrateDataCharDevice *mig_data;
-
- spice_debug(NULL);
- mig_data = (SpiceMigrateDataCharDevice *)spice_marshaller_reserve_space(m,
- sizeof(*mig_data));
- memset(mig_data, 0, sizeof(*mig_data));
- mig_data->version = SPICE_MIGRATE_DATA_CHAR_DEVICE_VERSION;
- mig_data->connected = FALSE;
-}
-
-static void migrate_data_marshaller_write_buffer_free(uint8_t *data, void *opaque)
-{
- SpiceCharDeviceWriteBuffer *write_buf = (SpiceCharDeviceWriteBuffer *)opaque;
-
- spice_char_device_write_buffer_unref(write_buf);
-}
-
-void spice_char_device_state_migrate_data_marshall(SpiceCharDeviceState *dev,
- SpiceMarshaller *m)
-{
- SpiceCharDeviceClientState *client_state;
- RingItem *item;
- uint32_t *write_to_dev_size_ptr;
- uint32_t *write_to_dev_tokens_ptr;
- SpiceMarshaller *m2;
-
- /* multi-clients are not supported */
- spice_assert(dev->num_clients == 1);
- client_state = SPICE_CONTAINEROF(ring_get_tail(&dev->clients),
- SpiceCharDeviceClientState,
- link);
- /* FIXME: if there were more than one client before the marshalling,
- * it is possible that the send_queue_size > 0, and the send data
- * should be migrated as well */
- spice_assert(client_state->send_queue_size == 0);
- spice_marshaller_add_uint32(m, SPICE_MIGRATE_DATA_CHAR_DEVICE_VERSION);
- spice_marshaller_add_uint8(m, 1); /* connected */
- spice_marshaller_add_uint32(m, client_state->num_client_tokens);
- spice_marshaller_add_uint32(m, client_state->num_send_tokens);
- write_to_dev_size_ptr = (uint32_t *)spice_marshaller_reserve_space(m, sizeof(uint32_t));
- write_to_dev_tokens_ptr = (uint32_t *)spice_marshaller_reserve_space(m, sizeof(uint32_t));
- *write_to_dev_size_ptr = 0;
- *write_to_dev_tokens_ptr = 0;
-
- m2 = spice_marshaller_get_ptr_submarshaller(m, 0);
- if (dev->cur_write_buf) {
- uint32_t buf_remaining = dev->cur_write_buf->buf + dev->cur_write_buf->buf_used -
- dev->cur_write_buf_pos;
- spice_marshaller_add_ref_full(m2, dev->cur_write_buf_pos, buf_remaining,
- migrate_data_marshaller_write_buffer_free,
- spice_char_device_write_buffer_ref(dev->cur_write_buf)
- );
- *write_to_dev_size_ptr += buf_remaining;
- if (dev->cur_write_buf->origin == WRITE_BUFFER_ORIGIN_CLIENT) {
- spice_assert(dev->cur_write_buf->client == client_state->client);
- (*write_to_dev_tokens_ptr) += dev->cur_write_buf->token_price;
- }
- }
-
- RING_FOREACH_REVERSED(item, &dev->write_queue) {
- SpiceCharDeviceWriteBuffer *write_buf;
-
- write_buf = SPICE_CONTAINEROF(item, SpiceCharDeviceWriteBuffer, link);
- spice_marshaller_add_ref_full(m2, write_buf->buf, write_buf->buf_used,
- migrate_data_marshaller_write_buffer_free,
- spice_char_device_write_buffer_ref(write_buf)
- );
- *write_to_dev_size_ptr += write_buf->buf_used;
- if (write_buf->origin == WRITE_BUFFER_ORIGIN_CLIENT) {
- spice_assert(write_buf->client == client_state->client);
- (*write_to_dev_tokens_ptr) += write_buf->token_price;
- }
- }
- spice_debug("migration data dev %p: write_queue size %u tokens %u",
- dev, *write_to_dev_size_ptr, *write_to_dev_tokens_ptr);
-}
-
-int spice_char_device_state_restore(SpiceCharDeviceState *dev,
- SpiceMigrateDataCharDevice *mig_data)
-{
- SpiceCharDeviceClientState *client_state;
- uint32_t client_tokens_window;
-
- spice_assert(dev->num_clients == 1 && dev->wait_for_migrate_data);
-
- client_state = SPICE_CONTAINEROF(ring_get_tail(&dev->clients),
- SpiceCharDeviceClientState,
- link);
- if (mig_data->version > SPICE_MIGRATE_DATA_CHAR_DEVICE_VERSION) {
- spice_error("dev %p error: migration data version %u is bigger than self %u",
- dev, mig_data->version, SPICE_MIGRATE_DATA_CHAR_DEVICE_VERSION);
- return FALSE;
- }
- spice_assert(!dev->cur_write_buf && ring_is_empty(&dev->write_queue));
- spice_assert(mig_data->connected);
-
- client_tokens_window = client_state->num_client_tokens; /* initial state of tokens */
- client_state->num_client_tokens = mig_data->num_client_tokens;
- /* assumption: client_tokens_window stays the same across severs */
- client_state->num_client_tokens_free = client_tokens_window -
- mig_data->num_client_tokens -
- mig_data->write_num_client_tokens;
- client_state->num_send_tokens = mig_data->num_send_tokens;
-
- if (mig_data->write_size > 0) {
- if (mig_data->write_num_client_tokens) {
- dev->cur_write_buf =
- __spice_char_device_write_buffer_get(dev, client_state->client,
- mig_data->write_size, WRITE_BUFFER_ORIGIN_CLIENT,
- mig_data->write_num_client_tokens);
- } else {
- dev->cur_write_buf =
- __spice_char_device_write_buffer_get(dev, NULL,
- mig_data->write_size, WRITE_BUFFER_ORIGIN_SERVER, 0);
- }
- /* the first write buffer contains all the data that was saved for migration */
- memcpy(dev->cur_write_buf->buf,
- ((uint8_t *)mig_data) + mig_data->write_data_ptr - sizeof(SpiceMigrateDataHeader),
- mig_data->write_size);
- dev->cur_write_buf->buf_used = mig_data->write_size;
- dev->cur_write_buf_pos = dev->cur_write_buf->buf;
- }
- dev->wait_for_migrate_data = FALSE;
- spice_char_device_write_to_device(dev);
- spice_char_device_read_from_device(dev);
- return TRUE;
-}
diff --git a/server/char_device.h b/server/char_device.h
deleted file mode 100644
index 55d1ee6..0000000
--- a/server/char_device.h
+++ /dev/null
@@ -1,216 +0,0 @@
-/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- Copyright (C) 2009-2015 Red Hat, Inc.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, see <http://www.gnu.org/licenses/>.
-*/
-#ifndef __CHAR_DEVICE_H__
-#define __CHAR_DEVICE_H__
-
-#include "spice.h"
-#include "red_channel.h"
-#include "migration_protocol.h"
-
-/*
- * Shared code for char devices, mainly for flow control.
- *
- * How to use the api:
- * ==================
- * device attached: call spice_char_device_state_create
- * device detached: call spice_char_device_state_destroy/reset
- *
- * client connected and associated with a device: spice_char_device_client_add
- * client disconnected: spice_char_device_client_remove
- *
- * Writing to the device
- * ---------------------
- * Write the data into SpiceCharDeviceWriteBuffer:
- * call spice_char_device_write_buffer_get in order to get an appropriate buffer.
- * call spice_char_device_write_buffer_add in order to push the buffer to the write queue.
- * If you choose not to push the buffer to the device, call
- * spice_char_device_write_buffer_release
- *
- * reading from the device
- * -----------------------
- * The callback read_one_msg_from_device (see below) should be implemented
- * (using sif->read).
- * When the device is ready, this callback is called, and is expected to
- * return one message which is addressed to the client, or NULL if the read
- * hasn't completed.
- *
- * calls triggered from the device (qemu):
- * --------------------------------------
- * spice_char_device_start
- * spice_char_device_stop
- * spice_char_device_wakeup (for reading from the device)
- */
-
-/*
- * Note about multiple-clients:
- * Multiclients are currently not supported in any of the character devices:
- * spicevmc does not allow more than one client (and at least for usb, it should stay this way).
- * smartcard code is not compatible with more than one reader.
- * The server and guest agent code doesn't distinguish messages from different clients.
- * In addition, its current flow control code (e.g., tokens handling) is wrong and doesn't
- * take into account the different clients.
- *
- * Nonetheless, the following code introduces some support for multiple-clients:
- * We track the number of tokens for all the clients, and we read from the device
- * if one of the clients have enough tokens. For the clients that don't have tokens,
- * we queue the messages, till they receive tokens, or till a timeout.
- *
- * TODO:
- * At least for the agent, not all the messages from the device will be directed to all
- * the clients (e.g., copy from guest to a specific client). Thus, support for
- * client-specific-messages should be added.
- * In addition, we should have support for clients that are being connected
- * in the middle of a message transfer from the agent to the clients.
- *
- * */
-
-/* buffer that is used for writing to the device */
-typedef struct SpiceCharDeviceWriteBuffer {
- RingItem link;
- int origin;
- RedClient *client; /* The client that sent the message to the device.
- NULL if the server created the message */
-
- uint8_t *buf;
- uint32_t buf_size;
- uint32_t buf_used;
- uint32_t token_price;
- uint32_t refs;
-} SpiceCharDeviceWriteBuffer;
-
-typedef void SpiceCharDeviceMsgToClient;
-
-typedef struct SpiceCharDeviceCallbacks {
- /*
- * Messages that are addressed to the client can be queued in case we have
- * multiple clients and some of them don't have enough tokens.
- */
-
- /* reads from the device till reaching a msg that should be sent to the client,
- * or till the reading fails */
- SpiceCharDeviceMsgToClient* (*read_one_msg_from_device)(SpiceCharDeviceInstance *sin,
- void *opaque);
- SpiceCharDeviceMsgToClient* (*ref_msg_to_client)(SpiceCharDeviceMsgToClient *msg,
- void *opaque);
- void (*unref_msg_to_client)(SpiceCharDeviceMsgToClient *msg,
- void *opaque);
- void (*send_msg_to_client)(SpiceCharDeviceMsgToClient *msg,
- RedClient *client,
- void *opaque); /* after this call, the message is unreferenced */
-
- /* The cb is called when a predefined number of write buffers were consumed by the
- * device */
- void (*send_tokens_to_client)(RedClient *client, uint32_t tokens, void *opaque);
-
- /* The cb is called when a server (self) message that was addressed to the device,
- * has been completely written to it */
- void (*on_free_self_token)(void *opaque);
-
- /* This cb is called if it is recommanded that a client will be removed
- * due to slow flow or due to some other error.
- * The called instance should disconnect the client, or at least the corresponding channel */
- void (*remove_client)(RedClient *client, void *opaque);
-} SpiceCharDeviceCallbacks;
-
-SpiceCharDeviceState *spice_char_device_state_create(SpiceCharDeviceInstance *sin,
- uint32_t client_tokens_interval,
- uint32_t self_tokens,
- SpiceCharDeviceCallbacks *cbs,
- void *opaque);
-
-void spice_char_device_state_reset_dev_instance(SpiceCharDeviceState *dev,
- SpiceCharDeviceInstance *sin);
-void spice_char_device_state_destroy(SpiceCharDeviceState *dev);
-
-void *spice_char_device_state_opaque_get(SpiceCharDeviceState *dev);
-
-/* only one client is supported */
-void spice_char_device_state_migrate_data_marshall(SpiceCharDeviceState *dev,
- SpiceMarshaller *m);
-void spice_char_device_state_migrate_data_marshall_empty(SpiceMarshaller *m);
-
-int spice_char_device_state_restore(SpiceCharDeviceState *dev,
- SpiceMigrateDataCharDevice *mig_data);
-
-/*
- * Resets write/read queues, and moves that state to being stopped.
- * This routine is a workaround for a bad tokens management in the vdagent
- * protocol:
- * The client tokens' are set only once, when the main channel is initialized.
- * Instead, it would have been more appropriate to reset them upon AGEN_CONNECT.
- * The client tokens are tracked as part of the SpiceCharDeviceClientState. Thus,
- * in order to be backwartd compatible with the client, we need to track the tokens
- * event when the agent is detached. We don't destroy the char_device state, and
- * instead we just reset it.
- * In addition, there is a misshandling of AGENT_TOKENS message in spice-gtk: it
- * overrides the amount of tokens, instead of adding the given amount.
- *
- * todo: change AGENT_CONNECT msg to contain tokens count.
- */
-void spice_char_device_reset(SpiceCharDeviceState *dev);
-
-/* max_send_queue_size = how many messages we can read from the device and enqueue for this client,
- * when we have tokens for other clients and no tokens for this one */
-int spice_char_device_client_add(SpiceCharDeviceState *dev,
- RedClient *client,
- int do_flow_control,
- uint32_t max_send_queue_size,
- uint32_t num_client_tokens,
- uint32_t num_send_tokens,
- int wait_for_migrate_data);
-
-void spice_char_device_client_remove(SpiceCharDeviceState *dev,
- RedClient *client);
-int spice_char_device_client_exists(SpiceCharDeviceState *dev,
- RedClient *client);
-
-void spice_char_device_start(SpiceCharDeviceState *dev);
-void spice_char_device_stop(SpiceCharDeviceState *dev);
-
-/** Read from device **/
-
-void spice_char_device_wakeup(SpiceCharDeviceState *dev);
-
-void spice_char_device_send_to_client_tokens_add(SpiceCharDeviceState *dev,
- RedClient *client,
- uint32_t tokens);
-
-
-void spice_char_device_send_to_client_tokens_set(SpiceCharDeviceState *dev,
- RedClient *client,
- uint32_t tokens);
-/** Write to device **/
-
-SpiceCharDeviceWriteBuffer *spice_char_device_write_buffer_get(SpiceCharDeviceState *dev,
- RedClient *client, int size);
-SpiceCharDeviceWriteBuffer *spice_char_device_write_buffer_get_server_no_token(
- SpiceCharDeviceState *dev, int size);
-
-/* Either add the buffer to the write queue or release it */
-void spice_char_device_write_buffer_add(SpiceCharDeviceState *dev,
- SpiceCharDeviceWriteBuffer *write_buf);
-void spice_char_device_write_buffer_release(SpiceCharDeviceState *dev,
- SpiceCharDeviceWriteBuffer *write_buf);
-
-/* api for specific char devices */
-
-SpiceCharDeviceState *spicevmc_device_connect(SpiceCharDeviceInstance *sin,
- uint8_t channel_type);
-void spicevmc_device_disconnect(SpiceCharDeviceInstance *char_device);
-
-#endif // __CHAR_DEVICE_H__
diff --git a/server/dcc-encoders.h b/server/dcc-encoders.h
index 5de66f7..a0a5c64 100644
--- a/server/dcc-encoders.h
+++ b/server/dcc-encoders.h
@@ -23,14 +23,14 @@
#include "common/quic.h"
#include "red_channel.h"
#include "red_parse_qxl.h"
-#include "spice_image_cache.h"
-#include "glz_encoder_dictionary.h"
-#include "glz_encoder.h"
-#include "jpeg_encoder.h"
+#include "image-cache.h"
+#include "glz-encoder-dict.h"
+#include "glz-encoder.h"
+#include "jpeg-encoder.h"
#ifdef USE_LZ4
#include "lz4_encoder.h"
#endif
-#include "zlib_encoder.h"
+#include "zlib-encoder.h"
typedef struct RedCompressBuf RedCompressBuf;
typedef struct GlzDrawableInstanceItem GlzDrawableInstanceItem;
diff --git a/server/display-channel.h b/server/display-channel.h
index a990e09..50f6c5e 100644
--- a/server/display-channel.h
+++ b/server/display-channel.h
@@ -25,22 +25,22 @@
#include "reds_stream.h"
#include "cache-item.h"
#include "pixmap-cache.h"
-#include "reds_sw_canvas.h"
+#include "sw-canvas.h"
#include "stat.h"
#include "reds.h"
-#include "mjpeg_encoder.h"
-#include "red_memslots.h"
+#include "mjpeg-encoder.h"
+#include "memslot.h"
#include "red_parse_qxl.h"
#include "red_record_qxl.h"
#include "demarshallers.h"
#include "red_channel.h"
#include "red_dispatcher.h"
#include "dispatcher.h"
-#include "main_channel.h"
-#include "migration_protocol.h"
-#include "main_dispatcher.h"
+#include "main-channel.h"
+#include "migration-protocol.h"
+#include "main-dispatcher.h"
#include "spice_bitmap_utils.h"
-#include "spice_image_cache.h"
+#include "image-cache.h"
#include "utils.h"
#include "tree.h"
#include "stream.h"
diff --git a/server/glz-encoder-dict.c b/server/glz-encoder-dict.c
new file mode 100644
index 0000000..1fd6753
--- /dev/null
+++ b/server/glz-encoder-dict.c
@@ -0,0 +1,633 @@
+/*
+ Copyright (C) 2009 Red Hat, Inc.
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, see <http://www.gnu.org/licenses/>.
+*/
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <pthread.h>
+#include <string.h>
+#include <stdio.h>
+
+#include "glz-encoder-dict.h"
+#include "glz-encoder-priv.h"
+
+/* turning all used images to free ones. If they are alive, calling the free_image callback for
+ each one */
+static inline void __glz_dictionary_window_reset_images(SharedDictionary *dict)
+{
+ WindowImage *tmp;
+
+ while (dict->window.used_images_head) {
+ tmp = dict->window.used_images_head;
+ dict->window.used_images_head = dict->window.used_images_head->next;
+ if (tmp->is_alive) {
+ dict->cur_usr->free_image(dict->cur_usr, tmp->usr_context);
+ }
+ tmp->next = dict->window.free_images;
+ tmp->is_alive = FALSE;
+ dict->window.free_images = tmp;
+ }
+ dict->window.used_images_tail = NULL;
+}
+
+/* allocate window fields (no reset)*/
+static int glz_dictionary_window_create(SharedDictionary *dict, uint32_t size)
+{
+ if (size > LZ_MAX_WINDOW_SIZE) {
+ return FALSE;
+ }
+
+ dict->window.size_limit = size;
+ dict->window.segs = (WindowImageSegment *)(
+ dict->cur_usr->malloc(dict->cur_usr, sizeof(WindowImageSegment) * INIT_IMAGE_SEGS_NUM));
+
+ if (!dict->window.segs) {
+ return FALSE;
+ }
+
+ dict->window.segs_quota = INIT_IMAGE_SEGS_NUM;
+
+ dict->window.encoders_heads = (uint32_t *)dict->cur_usr->malloc(dict->cur_usr,
+ sizeof(uint32_t) * dict->max_encoders);
+
+ if (!dict->window.encoders_heads) {
+ dict->cur_usr->free(dict->cur_usr, dict->window.segs);
+ return FALSE;
+ }
+
+ dict->window.used_images_head = NULL;
+ dict->window.used_images_tail = NULL;
+ dict->window.free_images = NULL;
+ dict->window.pixels_so_far = 0;
+
+ return TRUE;
+}
+
+/* initializes an empty window (segs and encoder_heads should be pre allocated.
+ resets the image infos, and calls the free_image usr callback*/
+static void glz_dictionary_window_reset(SharedDictionary *dict)
+{
+ uint32_t i;
+ WindowImageSegment *seg, *last_seg;
+
+ last_seg = dict->window.segs + dict->window.segs_quota;
+ /* reset free segs list */
+ dict->window.free_segs_head = 0;
+ for (seg = dict->window.segs, i = 0; seg < last_seg; seg++, i++) {
+ seg->next = i + 1;
+ seg->image = NULL;
+ seg->lines = NULL;
+ seg->lines_end = NULL;
+ seg->pixels_num = 0;
+ seg->pixels_so_far = 0;
+ }
+ dict->window.segs[dict->window.segs_quota - 1].next = NULL_IMAGE_SEG_ID;
+
+ dict->window.used_segs_head = NULL_IMAGE_SEG_ID;
+ dict->window.used_segs_tail = NULL_IMAGE_SEG_ID;
+
+ // reset encoders heads
+ for (i = 0; i < dict->max_encoders; i++) {
+ dict->window.encoders_heads[i] = NULL_IMAGE_SEG_ID;
+ }
+
+ __glz_dictionary_window_reset_images(dict);
+}
+
+static inline void glz_dictionary_reset_hash(SharedDictionary *dict)
+{
+ memset(dict->htab, 0, sizeof(HashEntry) * HASH_SIZE * HASH_CHAIN_SIZE);
+#ifdef CHAINED_HASH
+ memset(dict->htab_counter, 0, HASH_SIZE * sizeof(uint8_t));
+#endif
+}
+
+static inline void glz_dictionary_window_destroy(SharedDictionary *dict)
+{
+ __glz_dictionary_window_reset_images(dict);
+
+ if (dict->window.segs) {
+ dict->cur_usr->free(dict->cur_usr, dict->window.segs);
+ dict->window.segs = NULL;
+ }
+
+ while (dict->window.free_images) {
+ WindowImage *tmp = dict->window.free_images;
+ dict->window.free_images = tmp->next;
+
+ dict->cur_usr->free(dict->cur_usr, tmp);
+ }
+
+ if (dict->window.encoders_heads) {
+ dict->cur_usr->free(dict->cur_usr, dict->window.encoders_heads);
+ dict->window.encoders_heads = NULL;
+ }
+}
+
+/* logic removal only */
+static inline void glz_dictionary_window_kill_image(SharedDictionary *dict, WindowImage *image)
+{
+ image->is_alive = FALSE;
+}
+
+GlzEncDictContext *glz_enc_dictionary_create(uint32_t size, uint32_t max_encoders,
+ GlzEncoderUsrContext *usr)
+{
+ SharedDictionary *dict;
+
+ if (!(dict = (SharedDictionary *)usr->malloc(usr,
+ sizeof(SharedDictionary)))) {
+ return NULL;
+ }
+
+ dict->cur_usr = usr;
+ dict->last_image_id = 0;
+ dict->max_encoders = max_encoders;
+
+ pthread_mutex_init(&dict->lock, NULL);
+ pthread_rwlock_init(&dict->rw_alloc_lock, NULL);
+
+ dict->window.encoders_heads = NULL;
+
+ // alloc window fields and reset
+ if (!glz_dictionary_window_create(dict, size)) {
+ dict->cur_usr->free(usr, dict);
+ return NULL;
+ }
+
+ // reset window and hash
+ glz_enc_dictionary_reset((GlzEncDictContext *)dict, usr);
+
+ return (GlzEncDictContext *)dict;
+}
+
+void glz_enc_dictionary_get_restore_data(GlzEncDictContext *opaque_dict,
+ GlzEncDictRestoreData *out_data, GlzEncoderUsrContext *usr)
+{
+ SharedDictionary *dict = (SharedDictionary *)opaque_dict;
+ dict->cur_usr = usr;
+ GLZ_ASSERT(dict->cur_usr, opaque_dict);
+ GLZ_ASSERT(dict->cur_usr, out_data);
+
+ out_data->last_image_id = dict->last_image_id;
+ out_data->max_encoders = dict->max_encoders;
+ out_data->size = dict->window.size_limit;
+}
+
+GlzEncDictContext *glz_enc_dictionary_restore(GlzEncDictRestoreData *restore_data,
+ GlzEncoderUsrContext *usr)
+{
+ if (!restore_data) {
+ return NULL;
+ }
+ SharedDictionary *ret = (SharedDictionary *)glz_enc_dictionary_create(
+ restore_data->size, restore_data->max_encoders, usr);
+ ret->last_image_id = restore_data->last_image_id;
+ return ((GlzEncDictContext *)ret);
+}
+
+void glz_enc_dictionary_reset(GlzEncDictContext *opaque_dict, GlzEncoderUsrContext *usr)
+{
+ SharedDictionary *dict = (SharedDictionary *)opaque_dict;
+ dict->cur_usr = usr;
+ GLZ_ASSERT(dict->cur_usr, opaque_dict);
+
+ dict->last_image_id = 0;
+ glz_dictionary_window_reset(dict);
+ glz_dictionary_reset_hash(dict);
+}
+
+void glz_enc_dictionary_destroy(GlzEncDictContext *opaque_dict, GlzEncoderUsrContext *usr)
+{
+ SharedDictionary *dict = (SharedDictionary *)opaque_dict;
+
+ if (!opaque_dict) {
+ return;
+ }
+
+ dict->cur_usr = usr;
+ glz_dictionary_window_destroy(dict);
+
+ pthread_mutex_destroy(&dict->lock);
+ pthread_rwlock_destroy(&dict->rw_alloc_lock);
+
+ dict->cur_usr->free(dict->cur_usr, dict);
+}
+
+uint32_t glz_enc_dictionary_get_size(GlzEncDictContext *opaque_dict)
+{
+ SharedDictionary *dict = (SharedDictionary *)opaque_dict;
+
+ if (!opaque_dict) {
+ return 0;
+ }
+ return dict->window.size_limit;
+}
+
+/* doesn't call the remove image callback */
+void glz_enc_dictionary_remove_image(GlzEncDictContext *opaque_dict,
+ GlzEncDictImageContext *opaque_image,
+ GlzEncoderUsrContext *usr)
+{
+ SharedDictionary *dict = (SharedDictionary *)opaque_dict;
+ WindowImage *image = (WindowImage *)opaque_image;
+ dict->cur_usr = usr;
+ GLZ_ASSERT(dict->cur_usr, opaque_image && opaque_dict);
+
+ glz_dictionary_window_kill_image(dict, image);
+}
+
+/***********************************************************************************
+ Mutators of the window. Should be called by the encoder before and after encoding.
+ ***********************************************************************************/
+
+static inline int __get_pixels_num(LzImageType image_type, unsigned int num_lines, int stride)
+{
+ if (IS_IMAGE_TYPE_RGB[image_type]) {
+ return num_lines * stride / RGB_BYTES_PER_PIXEL[image_type];
+ } else {
+ return num_lines * stride * PLT_PIXELS_PER_BYTE[image_type];
+ }
+}
+
+static void __glz_dictionary_window_segs_realloc(SharedDictionary *dict)
+{
+ WindowImageSegment *new_segs;
+ uint32_t new_quota = (MAX_IMAGE_SEGS_NUM < (dict->window.segs_quota * 2)) ?
+ MAX_IMAGE_SEGS_NUM : (dict->window.segs_quota * 2);
+ WindowImageSegment *seg;
+ uint32_t i;
+
+ pthread_rwlock_wrlock(&dict->rw_alloc_lock);
+
+ if (dict->window.segs_quota == MAX_IMAGE_SEGS_NUM) {
+ dict->cur_usr->error(dict->cur_usr, "overflow in image segments window\n");
+ }
+
+ new_segs = (WindowImageSegment*)dict->cur_usr->malloc(
+ dict->cur_usr, sizeof(WindowImageSegment) * new_quota);
+
+ if (!new_segs) {
+ dict->cur_usr->error(dict->cur_usr,
+ "realloc of dictionary window failed\n");
+ }
+
+ memcpy(new_segs, dict->window.segs,
+ sizeof(WindowImageSegment) * dict->window.segs_quota);
+
+ // resetting the new elements
+ for (i = dict->window.segs_quota, seg = new_segs + i; i < new_quota; i++, seg++) {
+ seg->image = NULL;
+ seg->lines = NULL;
+ seg->lines_end = NULL;
+ seg->pixels_num = 0;
+ seg->pixels_so_far = 0;
+ seg->next = i + 1;
+ }
+ new_segs[new_quota - 1].next = dict->window.free_segs_head;
+ dict->window.free_segs_head = dict->window.segs_quota;
+
+ dict->cur_usr->free(dict->cur_usr, dict->window.segs);
+ dict->window.segs = new_segs;
+ dict->window.segs_quota = new_quota;
+
+ pthread_rwlock_unlock(&dict->rw_alloc_lock);
+}
+
+/* NOTE - it also updates the used_images_list*/
+static WindowImage *__glz_dictionary_window_alloc_image(SharedDictionary *dict)
+{
+ WindowImage *ret;
+
+ if (dict->window.free_images) {
+ ret = dict->window.free_images;
+ dict->window.free_images = ret->next;
+ } else {
+ if (!(ret = (WindowImage *)dict->cur_usr->malloc(dict->cur_usr,
+ sizeof(*ret)))) {
+ return NULL;
+ }
+ }
+
+ ret->next = NULL;
+ if (dict->window.used_images_tail) {
+ dict->window.used_images_tail->next = ret;
+ }
+ dict->window.used_images_tail = ret;
+
+ if (!dict->window.used_images_head) {
+ dict->window.used_images_head = ret;
+ }
+ return ret;
+}
+
+/* NOTE - it doesn't update the used_segs list*/
+static uint32_t __glz_dictionary_window_alloc_image_seg(SharedDictionary *dict)
+{
+ uint32_t seg_id;
+ WindowImageSegment *seg;
+
+ // TODO: when is it best to realloc? when full or when half full?
+ if (dict->window.free_segs_head == NULL_IMAGE_SEG_ID) {
+ __glz_dictionary_window_segs_realloc(dict);
+ }
+
+ GLZ_ASSERT(dict->cur_usr, dict->window.free_segs_head != NULL_IMAGE_SEG_ID);
+
+ seg_id = dict->window.free_segs_head;
+ seg = dict->window.segs + seg_id;
+ dict->window.free_segs_head = seg->next;
+
+ return seg_id;
+}
+
+/* moves image to free list and "kill" it. Calls the free_image callback if was alive. */
+static inline void __glz_dictionary_window_free_image(SharedDictionary *dict, WindowImage *image)
+{
+ if (image->is_alive) {
+ dict->cur_usr->free_image(dict->cur_usr, image->usr_context);
+ }
+ image->is_alive = FALSE;
+ image->next = dict->window.free_images;
+ dict->window.free_images = image;
+}
+
+/* moves all the segments that were associated with the images to the free segments */
+static inline void __glz_dictionary_window_free_image_segs(SharedDictionary *dict,
+ WindowImage *image)
+{
+ uint32_t old_free_head = dict->window.free_segs_head;
+ uint32_t seg_id, next_seg_id;
+
+ GLZ_ASSERT(dict->cur_usr, image->first_seg != NULL_IMAGE_SEG_ID);
+ dict->window.free_segs_head = image->first_seg;
+
+ // retrieving the last segment of the image
+ for (seg_id = image->first_seg, next_seg_id = dict->window.segs[seg_id].next;
+ (next_seg_id != NULL_IMAGE_SEG_ID) && (dict->window.segs[next_seg_id].image == image);
+ seg_id = next_seg_id, next_seg_id = dict->window.segs[seg_id].next) {
+ }
+
+ // concatenate the free list
+ dict->window.segs[seg_id].next = old_free_head;
+}
+
+/* Returns the logical head of the window after we add an image with the give size to its tail.
+ Returns NULL when the window is empty, of when we have to empty the window in order
+ to insert the new image. */
+static WindowImage *glz_dictionary_window_get_new_head(SharedDictionary *dict, int new_image_size)
+{
+ uint32_t cur_win_size;
+ WindowImage *cur_head;
+
+ if ((uint32_t)new_image_size > dict->window.size_limit) {
+ dict->cur_usr->error(dict->cur_usr, "image is bigger than window\n");
+ }
+
+ GLZ_ASSERT(dict->cur_usr, new_image_size < dict->window.size_limit)
+
+ // the window is empty
+ if (!dict->window.used_images_head) {
+ return NULL;
+ }
+
+ GLZ_ASSERT(dict->cur_usr, dict->window.used_segs_head != NULL_IMAGE_SEG_ID);
+ GLZ_ASSERT(dict->cur_usr, dict->window.used_segs_tail != NULL_IMAGE_SEG_ID);
+
+ // used_segs_head is the latest logical head (the physical head may preceed it)
+ cur_head = dict->window.segs[dict->window.used_segs_head].image;
+ cur_win_size = dict->window.segs[dict->window.used_segs_tail].pixels_num +
+ dict->window.segs[dict->window.used_segs_tail].pixels_so_far -
+ dict->window.segs[dict->window.used_segs_head].pixels_so_far;
+
+ while ((cur_win_size + new_image_size) > dict->window.size_limit) {
+ GLZ_ASSERT(dict->cur_usr, cur_head);
+ cur_win_size -= cur_head->size;
+ cur_head = cur_head->next;
+ }
+
+ return cur_head;
+}
+
+static inline int glz_dictionary_is_in_use(SharedDictionary *dict)
+{
+ uint32_t i = 0;
+ for (i = 0; i < dict->max_encoders; i++) {
+ if (dict->window.encoders_heads[i] != NULL_IMAGE_SEG_ID) {
+ return TRUE;
+ }
+ }
+ return FALSE;
+}
+
+/* remove from the window (and free relevant data) the images between the oldest physical head
+ (inclusive) and the end_image (exclusive). If end_image is NULL, empties the window*/
+static void glz_dictionary_window_remove_head(SharedDictionary *dict, uint32_t encoder_id,
+ WindowImage *end_image)
+{
+ // note that the segs list heads (one per encoder) may be different than the
+ // used_segs_head and it is updated somewhere else
+ while (dict->window.used_images_head != end_image) {
+ WindowImage *image = dict->window.used_images_head;
+
+ __glz_dictionary_window_free_image_segs(dict, image);
+ dict->window.used_images_head = image->next;
+ __glz_dictionary_window_free_image(dict, image);
+ }
+
+ if (!dict->window.used_images_head) {
+ dict->window.used_segs_head = NULL_IMAGE_SEG_ID;
+ dict->window.used_segs_tail = NULL_IMAGE_SEG_ID;
+ dict->window.used_images_tail = NULL;
+ } else {
+ dict->window.used_segs_head = end_image->first_seg;
+ }
+}
+
+static uint32_t glz_dictionary_window_alloc_image_seg(SharedDictionary *dict, WindowImage* image,
+ int size, int stride,
+ uint8_t *lines, unsigned int num_lines)
+{
+ uint32_t seg_id = __glz_dictionary_window_alloc_image_seg(dict);
+ WindowImageSegment *seg = &dict->window.segs[seg_id];
+
+ seg->image = image;
+ seg->lines = lines;
+ seg->lines_end = lines + num_lines * stride;
+ seg->pixels_num = size;
+ seg->pixels_so_far = dict->window.pixels_so_far;
+ dict->window.pixels_so_far += seg->pixels_num;
+
+ seg->next = NULL_IMAGE_SEG_ID;
+
+ return seg_id;
+}
+
+static WindowImage *glz_dictionary_window_add_image(SharedDictionary *dict, LzImageType image_type,
+ int image_size, int image_height,
+ int image_stride, uint8_t *first_lines,
+ unsigned int num_first_lines,
+ GlzUsrImageContext *usr_image_context)
+{
+ unsigned int num_lines = num_first_lines;
+ unsigned int row;
+ uint32_t seg_id, prev_seg_id;
+ uint8_t* lines = first_lines;
+ // alloc image info,update used head tail, if used_head null - update head
+ WindowImage *image = __glz_dictionary_window_alloc_image(dict);
+ image->id = dict->last_image_id++;
+ image->size = image_size;
+ image->type = image_type;
+ image->usr_context = usr_image_context;
+
+ if (num_lines <= 0) {
+ num_lines = dict->cur_usr->more_lines(dict->cur_usr, &lines);
+ if (num_lines <= 0) {
+ dict->cur_usr->error(dict->cur_usr, "more lines failed\n");
+ }
+ }
+
+ for (row = 0;;) {
+ seg_id = glz_dictionary_window_alloc_image_seg(dict, image,
+ image_size * num_lines / image_height,
+ image_stride,
+ lines, num_lines);
+ if (row == 0) {
+ image->first_seg = seg_id;
+ } else {
+ dict->window.segs[prev_seg_id].next = seg_id;
+ }
+
+ row += num_lines;
+ if (row < (uint32_t)image_height) {
+ num_lines = dict->cur_usr->more_lines(dict->cur_usr, &lines);
+ if (num_lines <= 0) {
+ dict->cur_usr->error(dict->cur_usr, "more lines failed\n");
+ }
+ } else {
+ break;
+ }
+ prev_seg_id = seg_id;
+ }
+
+ if (dict->window.used_segs_tail == NULL_IMAGE_SEG_ID) {
+ dict->window.used_segs_head = image->first_seg;
+ dict->window.used_segs_tail = seg_id;
+ } else {
+ int prev_tail = dict->window.used_segs_tail;
+
+ // The used segs may be in use by another thread which is during encoding
+ // (read-only use - when going over the segs of an image,
+ // see glz_encode_tmpl::compress).
+ // Thus, the 'next' field of the list's tail can be accessed only
+ // after all the new tail's data was set. Note that we are relying on
+ // an atomic assignment (32 bit variable).
+ // For the other thread that may read 'next' of the old tail, NULL_IMAGE_SEG_ID
+ // is equivalent to a segment with an image id that is different
+ // from the image id of the tail, so we don't need to further protect this field.
+ dict->window.segs[prev_tail].next = image->first_seg;
+ dict->window.used_segs_tail = seg_id;
+ }
+ image->is_alive = TRUE;
+
+ return image;
+}
+
+WindowImage *glz_dictionary_pre_encode(uint32_t encoder_id, GlzEncoderUsrContext *usr,
+ SharedDictionary *dict, LzImageType image_type,
+ int image_width, int image_height, int image_stride,
+ uint8_t *first_lines, unsigned int num_first_lines,
+ GlzUsrImageContext *usr_image_context,
+ uint32_t *image_head_dist)
+{
+ WindowImage *new_win_head, *ret;
+ int image_size;
+
+
+ pthread_mutex_lock(&dict->lock);
+
+ dict->cur_usr = usr;
+ GLZ_ASSERT(dict->cur_usr, dict->window.encoders_heads[encoder_id] == NULL_IMAGE_SEG_ID);
+
+ image_size = __get_pixels_num(image_type, image_height, image_stride);
+ new_win_head = glz_dictionary_window_get_new_head(dict, image_size);
+
+ if (!glz_dictionary_is_in_use(dict)) {
+ glz_dictionary_window_remove_head(dict, encoder_id, new_win_head);
+ }
+
+ ret = glz_dictionary_window_add_image(dict, image_type, image_size, image_height, image_stride,
+ first_lines, num_first_lines, usr_image_context);
+
+ if (new_win_head) {
+ dict->window.encoders_heads[encoder_id] = new_win_head->first_seg;
+ *image_head_dist = (uint32_t)(ret->id - new_win_head->id); // shouldn't be greater than 32
+ // bit because the window size is
+ // limited to 2^25
+ } else {
+ dict->window.encoders_heads[encoder_id] = ret->first_seg;
+ *image_head_dist = 0;
+ }
+
+
+ // update encoders head (the other heads were already updated)
+ pthread_mutex_unlock(&dict->lock);
+ pthread_rwlock_rdlock(&dict->rw_alloc_lock);
+ return ret;
+}
+
+void glz_dictionary_post_encode(uint32_t encoder_id, GlzEncoderUsrContext *usr,
+ SharedDictionary *dict)
+{
+ uint32_t i;
+ uint32_t early_head_seg = NULL_IMAGE_SEG_ID;
+ uint32_t this_encoder_head_seg;
+
+ pthread_rwlock_unlock(&dict->rw_alloc_lock);
+ pthread_mutex_lock(&dict->lock);
+ dict->cur_usr = usr;
+
+ GLZ_ASSERT(dict->cur_usr, dict->window.encoders_heads[encoder_id] != NULL_IMAGE_SEG_ID);
+ // get the earliest head in use (not including this encoder head)
+ for (i = 0; i < dict->max_encoders; i++) {
+ if (i != encoder_id) {
+ if (IMAGE_SEG_IS_EARLIER(dict, dict->window.encoders_heads[i], early_head_seg)) {
+ early_head_seg = dict->window.encoders_heads[i];
+ }
+ }
+ }
+
+ // possible only if early_head_seg == NULL
+ if (IMAGE_SEG_IS_EARLIER(dict, dict->window.used_segs_head, early_head_seg)) {
+ early_head_seg = dict->window.used_segs_head;
+ }
+
+ this_encoder_head_seg = dict->window.encoders_heads[encoder_id];
+
+ GLZ_ASSERT(dict->cur_usr, early_head_seg != NULL_IMAGE_SEG_ID);
+
+ if (IMAGE_SEG_IS_EARLIER(dict, this_encoder_head_seg, early_head_seg)) {
+ GLZ_ASSERT(dict->cur_usr,
+ this_encoder_head_seg == dict->window.used_images_head->first_seg);
+ glz_dictionary_window_remove_head(dict, encoder_id,
+ dict->window.segs[early_head_seg].image);
+ }
+
+
+ dict->window.encoders_heads[encoder_id] = NULL_IMAGE_SEG_ID;
+ pthread_mutex_unlock(&dict->lock);
+}
diff --git a/server/glz-encoder-dict.h b/server/glz-encoder-dict.h
new file mode 100644
index 0000000..960f165
--- /dev/null
+++ b/server/glz-encoder-dict.h
@@ -0,0 +1,69 @@
+/*
+ Copyright (C) 2009 Red Hat, Inc.
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef GLZ_ENCODER_DICT_H_
+#define GLZ_ENCODER_DICT_H_
+
+#include <stdint.h>
+#include "glz_encoder_config.h"
+
+/*
+ Interface for maintaining lz dictionary that is shared among several encoders.
+ The interface for accessing the dictionary for encoding purposes is located in
+ glz-encoder-priv.h
+*/
+
+typedef void GlzEncDictContext;
+typedef void GlzEncDictImageContext;
+
+/* NOTE: DISPLAY_MIGRATE_DATA_VERSION should change in case GlzEncDictRestoreData changes*/
+typedef struct GlzEncDictRestoreData {
+ uint32_t size;
+ uint32_t max_encoders;
+ uint64_t last_image_id;
+} GlzEncDictRestoreData;
+
+/* size : maximal number of pixels occupying the window
+ max_encoders: maximal number of encoders that use the dictionary
+ usr : callbacks */
+GlzEncDictContext *glz_enc_dictionary_create(uint32_t size, uint32_t max_encoders,
+ GlzEncoderUsrContext *usr);
+
+void glz_enc_dictionary_destroy(GlzEncDictContext *opaque_dict, GlzEncoderUsrContext *usr);
+
+/* returns the window capacity in pixels */
+uint32_t glz_enc_dictionary_get_size(GlzEncDictContext *);
+
+/* returns the current state of the dictionary.
+ NOTE - you should use it only when no encoder uses the dictionary. */
+void glz_enc_dictionary_get_restore_data(GlzEncDictContext *opaque_dict,
+ GlzEncDictRestoreData *out_data,
+ GlzEncoderUsrContext *usr);
+
+/* creates a dictionary and initialized it by use the given info */
+GlzEncDictContext *glz_enc_dictionary_restore(GlzEncDictRestoreData *restore_data,
+ GlzEncoderUsrContext *usr);
+
+/* NOTE - you should use this routine only when no encoder uses the dictionary. */
+void glz_enc_dictionary_reset(GlzEncDictContext *opaque_dict, GlzEncoderUsrContext *usr);
+
+/* image: the context returned by the encoder when the image was encoded.
+ NOTE - you should use this routine only when no encoder uses the dictionary.*/
+void glz_enc_dictionary_remove_image(GlzEncDictContext *opaque_dict,
+ GlzEncDictImageContext *image, GlzEncoderUsrContext *usr);
+
+#endif // GLZ_ENCODER_DICT_H_
diff --git a/server/glz-encoder-priv.h b/server/glz-encoder-priv.h
new file mode 100644
index 0000000..a408966
--- /dev/null
+++ b/server/glz-encoder-priv.h
@@ -0,0 +1,186 @@
+/*
+ Copyright (C) 2009 Red Hat, Inc.
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef GLZ_ENCODER_PRIV_H_
+#define GLZ_ENCODER_PRIV_H_
+
+/* Interface for using the dictionary for encoding.
+ Data structures are exposed for the encoder for efficiency
+ purposes. */
+typedef struct WindowImage WindowImage;
+typedef struct WindowImageSegment WindowImageSegment;
+
+
+//#define CHAINED_HASH
+
+#ifdef CHAINED_HASH
+#define HASH_SIZE_LOG 16
+#define HASH_CHAIN_SIZE 4
+#else
+#define HASH_SIZE_LOG 20
+#define HASH_CHAIN_SIZE 1
+#endif
+
+#define HASH_SIZE (1 << HASH_SIZE_LOG)
+#define HASH_MASK (HASH_SIZE - 1)
+
+typedef struct HashEntry HashEntry;
+
+typedef struct SharedDictionary SharedDictionary;
+
+struct WindowImage {
+ uint64_t id;
+ LzImageType type;
+ int size; // in pixels
+ uint32_t first_seg;
+ GlzUsrImageContext *usr_context;
+ WindowImage* next;
+ uint8_t is_alive;
+};
+
+#define MAX_IMAGE_SEGS_NUM (0xffffffff)
+#define NULL_IMAGE_SEG_ID MAX_IMAGE_SEGS_NUM
+#define INIT_IMAGE_SEGS_NUM 1000
+
+/* Images can be separated into several chunks. The basic unit of the
+ dictionary window is one image segment. Each segment is encoded separately.
+ An encoded match can refer to only one segment.*/
+struct WindowImageSegment {
+ WindowImage *image;
+ void *lines;
+ void *lines_end;
+ uint32_t pixels_num; // Number of pixels in the segment
+ uint64_t pixels_so_far; // Total no. pixels passed through the window till this segment.
+ // NOTE - never use size delta independently. It should
+ // always be used with respect to a previous size delta
+ uint32_t next;
+};
+
+
+struct __attribute__ ((__packed__)) HashEntry {
+ uint32_t image_seg_idx;
+ uint32_t ref_pix_idx;
+};
+
+
+struct SharedDictionary {
+ struct {
+ /* The segments storage. A dynamic array.
+ By referring to a segment by its index, instead of address,
+ we save space in the hash entries (32bit instead of 64bit) */
+ WindowImageSegment *segs;
+ uint32_t segs_quota;
+
+ /* The window is manged as a linked list rather than as a cyclic
+ array in order to keep the indices of the segments consistent
+ after reallocation */
+
+ /* the window in a resolution of image segments */
+ uint32_t used_segs_head; // the latest head
+ uint32_t used_segs_tail;
+ uint32_t free_segs_head;
+
+ uint32_t *encoders_heads; // Holds for each encoder (by id), the window head when
+ // it started the encoding.
+ // The head is NULL_IMAGE_SEG_ID when the encoder is
+ // not encoding.
+
+ /* the window in a resolution of images. But here the head contains the oldest head*/
+ WindowImage* used_images_tail;
+ WindowImage* used_images_head;
+ WindowImage* free_images;
+
+ uint64_t pixels_so_far;
+ uint32_t size_limit; // max number of pixels in a window (per encoder)
+ } window;
+
+ /* Concurrency issues: the reading/writing of each entry field should be atomic.
+ It is allowed that the reading/writing of the whole entry won't be atomic,
+ since before we access a reference we check its validity*/
+#ifdef CHAINED_HASH
+ HashEntry htab[HASH_SIZE][HASH_CHAIN_SIZE];
+ uint8_t htab_counter[HASH_SIZE]; //cyclic counter for the next entry in a chain to be assigned
+#else
+ HashEntry htab[HASH_SIZE];
+#endif
+
+ uint64_t last_image_id;
+ uint32_t max_encoders;
+ pthread_mutex_t lock;
+ pthread_rwlock_t rw_alloc_lock;
+ GlzEncoderUsrContext *cur_usr; // each encoder has other context.
+};
+
+/*
+ Add the image to the tail of the window.
+ If possible, release images from the head of the window.
+ Also perform concurrency related operations.
+
+ usr_image_context: when an image is released from the window due to capacity overflow,
+ usr_image_context is given as a parameter to the free_image callback.
+
+ image_head_dist : the number of images between the current image and the head of the
+ window that is associated with the encoder.
+*/
+WindowImage *glz_dictionary_pre_encode(uint32_t encoder_id, GlzEncoderUsrContext *usr,
+ SharedDictionary *dict, LzImageType image_type,
+ int image_width, int image_height, int image_stride,
+ uint8_t *first_lines, unsigned int num_first_lines,
+ GlzUsrImageContext *usr_image_context,
+ uint32_t *image_head_dist);
+
+/*
+ Performs concurrency related operations.
+ If possible, release images from the head of the window.
+*/
+void glz_dictionary_post_encode(uint32_t encoder_id, GlzEncoderUsrContext *usr,
+ SharedDictionary *dict);
+
+#define IMAGE_SEG_IS_EARLIER(dict, dst_seg, src_seg) ( \
+ ((src_seg) == NULL_IMAGE_SEG_ID) || (((dst_seg) != NULL_IMAGE_SEG_ID) \
+ && ((dict)->window.segs[(dst_seg)].pixels_so_far < \
+ (dict)->window.segs[(src_seg)].pixels_so_far)))
+
+
+#ifdef CHAINED_HASH
+#define UPDATE_HASH(dict, hval, seg, pix) { \
+ uint8_t tmp_count = (dict)->htab_counter[hval]; \
+ (dict)->htab[hval][tmp_count].image_seg_idx = seg; \
+ (dict)->htab[hval][tmp_count].ref_pix_idx = pix; \
+ tmp_count = ((tmp_count) + 1) & (HASH_CHAIN_SIZE - 1); \
+ dict->htab_counter[hval] = tmp_count; \
+}
+#else
+#define UPDATE_HASH(dict, hval, seg, pix) { \
+ (dict)->htab[hval].image_seg_idx = seg; \
+ (dict)->htab[hval].ref_pix_idx = pix; \
+}
+#endif
+
+/* checks if the reference segment is located in the range of the window
+ of the current encoder */
+#define REF_SEG_IS_VALID(dict, enc_id, ref_seg, src_seg) ( \
+ ((ref_seg) == (src_seg)) || \
+ ((ref_seg)->image && \
+ (ref_seg)->image->is_alive && \
+ (src_seg->image->type == ref_seg->image->type) && \
+ (ref_seg->pixels_so_far <= src_seg->pixels_so_far) && \
+ ((dict)->window.segs[ \
+ (dict)->window.encoders_heads[enc_id]].pixels_so_far <= \
+ ref_seg->pixels_so_far)))
+
+#endif // GLZ_ENCODER_PRIV_H_
diff --git a/server/glz-encoder.c b/server/glz-encoder.c
new file mode 100644
index 0000000..f761330
--- /dev/null
+++ b/server/glz-encoder.c
@@ -0,0 +1,311 @@
+/*
+ Copyright (C) 2009 Red Hat, Inc.
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, see <http://www.gnu.org/licenses/>.
+*/
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <glib.h>
+#include <pthread.h>
+#include <stdio.h>
+#include "glz-encoder.h"
+#include "glz-encoder-priv.h"
+
+
+/* Holds a specific data for one encoder, and data that is relevant for the current image encoded */
+typedef struct Encoder {
+ GlzEncoderUsrContext *usr;
+ uint8_t id;
+ SharedDictionary *dict;
+
+ struct {
+ LzImageType type;
+ uint32_t id;
+ uint32_t first_win_seg;
+ } cur_image;
+
+ struct {
+ uint8_t *start;
+ uint8_t *now;
+ uint8_t *end;
+ size_t bytes_count;
+ uint8_t *last_copy; // pointer to the last byte in which copy count was written
+ } io;
+} Encoder;
+
+
+/**************************************************************************
+* Handling writing the encoded image to the output buffer
+***************************************************************************/
+static inline int more_io_bytes(Encoder *encoder)
+{
+ uint8_t *io_ptr;
+ int num_io_bytes = encoder->usr->more_space(encoder->usr, &io_ptr);
+ encoder->io.bytes_count += num_io_bytes;
+ encoder->io.now = io_ptr;
+ encoder->io.end = encoder->io.now + num_io_bytes;
+ return num_io_bytes;
+}
+
+static inline void encode(Encoder *encoder, uint8_t byte)
+{
+ if (encoder->io.now == encoder->io.end) {
+ if (more_io_bytes(encoder) <= 0) {
+ encoder->usr->error(encoder->usr, "%s: no more bytes\n", __FUNCTION__);
+ }
+ GLZ_ASSERT(encoder->usr, encoder->io.now);
+ }
+
+ GLZ_ASSERT(encoder->usr, encoder->io.now < encoder->io.end);
+ *(encoder->io.now++) = byte;
+}
+
+static inline void encode_32(Encoder *encoder, unsigned int word)
+{
+ encode(encoder, (uint8_t)(word >> 24));
+ encode(encoder, (uint8_t)(word >> 16) & 0x0000ff);
+ encode(encoder, (uint8_t)(word >> 8) & 0x0000ff);
+ encode(encoder, (uint8_t)(word & 0x0000ff));
+}
+
+static inline void encode_64(Encoder *encoder, uint64_t word)
+{
+ encode_32(encoder, (uint32_t)(word >> 32));
+ encode_32(encoder, (uint32_t)(word & 0xffffff));
+}
+
+static inline void encode_copy_count(Encoder *encoder, uint8_t copy_count)
+{
+ encode(encoder, copy_count);
+ encoder->io.last_copy = encoder->io.now - 1; // io_now cannot be the first byte of the buffer
+}
+
+static inline void update_copy_count(Encoder *encoder, uint8_t copy_count)
+{
+ GLZ_ASSERT(encoder->usr, encoder->io.last_copy);
+ *(encoder->io.last_copy) = copy_count;
+}
+
+// decrease the io ptr by 1
+static inline void compress_output_prev(Encoder *encoder)
+{
+ // io_now cannot be the first byte of the buffer
+ encoder->io.now--;
+ // the function should be called only when copy count is written unnecessarily by glz_compress
+ GLZ_ASSERT(encoder->usr, encoder->io.now == encoder->io.last_copy)
+}
+
+static int encoder_reset(Encoder *encoder, uint8_t *io_ptr, uint8_t *io_ptr_end)
+{
+ GLZ_ASSERT(encoder->usr, io_ptr <= io_ptr_end);
+ encoder->io.bytes_count = io_ptr_end - io_ptr;
+ encoder->io.start = io_ptr;
+ encoder->io.now = io_ptr;
+ encoder->io.end = io_ptr_end;
+ encoder->io.last_copy = NULL;
+
+ return TRUE;
+}
+
+/**********************************************************
+* Encoding
+***********************************************************/
+
+GlzEncoderContext *glz_encoder_create(uint8_t id, GlzEncDictContext *dictionary,
+ GlzEncoderUsrContext *usr)
+{
+ Encoder *encoder;
+
+ if (!usr || !usr->error || !usr->warn || !usr->info || !usr->malloc ||
+ !usr->free || !usr->more_space) {
+ return NULL;
+ }
+
+ if (!(encoder = (Encoder *)usr->malloc(usr, sizeof(Encoder)))) {
+ return NULL;
+ }
+
+ encoder->id = id;
+ encoder->usr = usr;
+ encoder->dict = (SharedDictionary *)dictionary;
+
+ return (GlzEncoderContext *)encoder;
+}
+
+void glz_encoder_destroy(GlzEncoderContext *opaque_encoder)
+{
+ Encoder *encoder = (Encoder *)opaque_encoder;
+
+ if (!opaque_encoder) {
+ return;
+ }
+
+ encoder->usr->free(encoder->usr, encoder);
+}
+
+/*
+ * Give hints to the compiler for branch prediction optimization.
+ */
+#if defined(__GNUC__) && (__GNUC__ > 2)
+#define LZ_EXPECT_CONDITIONAL(c) (__builtin_expect((c), 1))
+#define LZ_UNEXPECT_CONDITIONAL(c) (__builtin_expect((c), 0))
+#else
+#define LZ_EXPECT_CONDITIONAL(c) (c)
+#define LZ_UNEXPECT_CONDITIONAL(c) (c)
+#endif
+
+
+typedef uint8_t BYTE;
+
+typedef struct __attribute__ ((__packed__)) one_byte_pixel_t {
+ BYTE a;
+} one_byte_pixel_t;
+
+typedef struct __attribute__ ((__packed__)) rgb32_pixel_t {
+ BYTE b;
+ BYTE g;
+ BYTE r;
+ BYTE pad;
+} rgb32_pixel_t;
+
+typedef struct __attribute__ ((__packed__)) rgb24_pixel_t {
+ BYTE b;
+ BYTE g;
+ BYTE r;
+} rgb24_pixel_t;
+
+typedef uint16_t rgb16_pixel_t;
+
+#define BOUND_OFFSET 2
+#define LIMIT_OFFSET 6
+#define MIN_FILE_SIZE 4
+
+#define MAX_PIXEL_SHORT_DISTANCE 4096 // (1 << 12)
+#define MAX_PIXEL_MEDIUM_DISTANCE 131072 // (1 << 17) 2 ^ (12 + 5)
+#define MAX_PIXEL_LONG_DISTANCE 33554432 // (1 << 25) 2 ^ (12 + 5 + 8)
+#define MAX_IMAGE_DIST 16777215 // (1 << 24 - 1)
+
+
+//#define DEBUG_ENCODE
+
+
+#define GLZ_ENCODE_SIZE
+#include "glz-encode-match.tmpl.c"
+#define GLZ_ENCODE_MATCH
+#include "glz-encode-match.tmpl.c"
+
+#define LZ_PLT
+#include "glz-encode.tmpl.c"
+
+#define LZ_RGB16
+#include "glz-encode.tmpl.c"
+
+#define LZ_RGB24
+#include "glz-encode.tmpl.c"
+
+#define LZ_RGB32
+#include "glz-encode.tmpl.c"
+
+#define LZ_RGB_ALPHA
+#include "glz-encode.tmpl.c"
+
+
+int glz_encode(GlzEncoderContext *opaque_encoder,
+ LzImageType type, int width, int height, int top_down,
+ uint8_t *lines, unsigned int num_lines, int stride,
+ uint8_t *io_ptr, unsigned int num_io_bytes,
+ GlzUsrImageContext *usr_context, GlzEncDictImageContext **o_enc_dict_context)
+{
+ Encoder *encoder = (Encoder *)opaque_encoder;
+ WindowImage *dict_image;
+ uint8_t *io_ptr_end = io_ptr + num_io_bytes;
+ uint32_t win_head_image_dist;
+
+ if (IS_IMAGE_TYPE_PLT[type]) {
+ if (stride > (width / PLT_PIXELS_PER_BYTE[type])) {
+ if (((width % PLT_PIXELS_PER_BYTE[type]) == 0) || (
+ (stride - (width / PLT_PIXELS_PER_BYTE[type])) > 1)) {
+ encoder->usr->error(encoder->usr, "stride overflows (plt)\n");
+ }
+ }
+ } else {
+ if (stride != width * RGB_BYTES_PER_PIXEL[type]) {
+ encoder->usr->error(encoder->usr, "stride != width*bytes_per_pixel (rgb)\n");
+ }
+ }
+
+ // assign the output buffer
+ if (!encoder_reset(encoder, io_ptr, io_ptr_end)) {
+ encoder->usr->error(encoder->usr, "lz encoder io reset failed\n");
+ }
+
+ // first read the list of the image segments into the dictionary window
+ dict_image = glz_dictionary_pre_encode(encoder->id, encoder->usr,
+ encoder->dict, type, width, height, stride,
+ lines, num_lines, usr_context, &win_head_image_dist);
+ *o_enc_dict_context = (GlzEncDictImageContext *)dict_image;
+
+ encoder->cur_image.type = type;
+ encoder->cur_image.id = dict_image->id;
+ encoder->cur_image.first_win_seg = dict_image->first_seg;
+
+ encode_32(encoder, GUINT32_TO_LE(LZ_MAGIC));
+ encode_32(encoder, LZ_VERSION);
+ if (top_down) {
+ encode(encoder, (type & LZ_IMAGE_TYPE_MASK) | (1 << LZ_IMAGE_TYPE_LOG));
+ } else {
+ encode(encoder, (type & LZ_IMAGE_TYPE_MASK));
+ }
+
+ encode_32(encoder, width);
+ encode_32(encoder, height);
+ encode_32(encoder, stride);
+ encode_64(encoder, dict_image->id);
+ encode_32(encoder, win_head_image_dist);
+
+ switch (encoder->cur_image.type) {
+ case LZ_IMAGE_TYPE_PLT1_BE:
+ case LZ_IMAGE_TYPE_PLT1_LE:
+ case LZ_IMAGE_TYPE_PLT4_BE:
+ case LZ_IMAGE_TYPE_PLT4_LE:
+ case LZ_IMAGE_TYPE_PLT8:
+ glz_plt_compress(encoder);
+ break;
+ case LZ_IMAGE_TYPE_RGB16:
+ glz_rgb16_compress(encoder);
+ break;
+ case LZ_IMAGE_TYPE_RGB24:
+ glz_rgb24_compress(encoder);
+ break;
+ case LZ_IMAGE_TYPE_RGB32:
+ glz_rgb32_compress(encoder);
+ break;
+ case LZ_IMAGE_TYPE_RGBA:
+ glz_rgb32_compress(encoder);
+ glz_rgb_alpha_compress(encoder);
+ break;
+ case LZ_IMAGE_TYPE_INVALID:
+ default:
+ encoder->usr->error(encoder->usr, "bad image type\n");
+ }
+
+ glz_dictionary_post_encode(encoder->id, encoder->usr, encoder->dict);
+
+ // move all the used segments to the free ones
+ encoder->io.bytes_count -= (encoder->io.end - encoder->io.now);
+
+ return encoder->io.bytes_count;
+}
diff --git a/server/glz-encoder.h b/server/glz-encoder.h
new file mode 100644
index 0000000..93164ed
--- /dev/null
+++ b/server/glz-encoder.h
@@ -0,0 +1,55 @@
+/*
+ Copyright (C) 2009 Red Hat, Inc.
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_GLZ_ENCODER
+#define _H_GLZ_ENCODER
+
+/* Manging the lz encoding using a dictionary that is shared among encoders */
+
+#include <stdint.h>
+#include "common/lz_common.h"
+#include "glz-encoder-dict.h"
+#include "glz_encoder_config.h"
+
+typedef void GlzEncoderContext;
+
+GlzEncoderContext *glz_encoder_create(uint8_t id, GlzEncDictContext *dictionary,
+ GlzEncoderUsrContext *usr);
+
+void glz_encoder_destroy(GlzEncoderContext *opaque_encoder);
+
+/*
+ assumes width is in pixels and stride is in bytes
+ usr_context : when an image is released from the window due to capacity overflow,
+ usr_context is given as a parameter to the free_image callback.
+ o_enc_dict_context: if glz_enc_dictionary_remove_image is called, it should be
+ called with the o_enc_dict_context that is associated with
+ the image.
+
+ return: the number of bytes in the compressed data and sets o_enc_dict_context
+
+ NOTE : currently supports only rgb images in which width*bytes_per_pixel = stride OR
+ palette images in which stride equals the min number of bytes to hold a line.
+ The stride should be > 0
+*/
+int glz_encode(GlzEncoderContext *opaque_encoder, LzImageType type, int width, int height,
+ int top_down, uint8_t *lines, unsigned int num_lines, int stride,
+ uint8_t *io_ptr, unsigned int num_io_bytes, GlzUsrImageContext *usr_context,
+ GlzEncDictImageContext **o_enc_dict_context);
+
+
+#endif // _H_GLZ_ENCODER
diff --git a/server/glz_encoder.c b/server/glz_encoder.c
deleted file mode 100644
index 65f4478..0000000
--- a/server/glz_encoder.c
+++ /dev/null
@@ -1,311 +0,0 @@
-/*
- Copyright (C) 2009 Red Hat, Inc.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, see <http://www.gnu.org/licenses/>.
-*/
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#include <glib.h>
-#include <pthread.h>
-#include <stdio.h>
-#include "glz_encoder.h"
-#include "glz_encoder_dictionary_protected.h"
-
-
-/* Holds a specific data for one encoder, and data that is relevant for the current image encoded */
-typedef struct Encoder {
- GlzEncoderUsrContext *usr;
- uint8_t id;
- SharedDictionary *dict;
-
- struct {
- LzImageType type;
- uint32_t id;
- uint32_t first_win_seg;
- } cur_image;
-
- struct {
- uint8_t *start;
- uint8_t *now;
- uint8_t *end;
- size_t bytes_count;
- uint8_t *last_copy; // pointer to the last byte in which copy count was written
- } io;
-} Encoder;
-
-
-/**************************************************************************
-* Handling writing the encoded image to the output buffer
-***************************************************************************/
-static inline int more_io_bytes(Encoder *encoder)
-{
- uint8_t *io_ptr;
- int num_io_bytes = encoder->usr->more_space(encoder->usr, &io_ptr);
- encoder->io.bytes_count += num_io_bytes;
- encoder->io.now = io_ptr;
- encoder->io.end = encoder->io.now + num_io_bytes;
- return num_io_bytes;
-}
-
-static inline void encode(Encoder *encoder, uint8_t byte)
-{
- if (encoder->io.now == encoder->io.end) {
- if (more_io_bytes(encoder) <= 0) {
- encoder->usr->error(encoder->usr, "%s: no more bytes\n", __FUNCTION__);
- }
- GLZ_ASSERT(encoder->usr, encoder->io.now);
- }
-
- GLZ_ASSERT(encoder->usr, encoder->io.now < encoder->io.end);
- *(encoder->io.now++) = byte;
-}
-
-static inline void encode_32(Encoder *encoder, unsigned int word)
-{
- encode(encoder, (uint8_t)(word >> 24));
- encode(encoder, (uint8_t)(word >> 16) & 0x0000ff);
- encode(encoder, (uint8_t)(word >> 8) & 0x0000ff);
- encode(encoder, (uint8_t)(word & 0x0000ff));
-}
-
-static inline void encode_64(Encoder *encoder, uint64_t word)
-{
- encode_32(encoder, (uint32_t)(word >> 32));
- encode_32(encoder, (uint32_t)(word & 0xffffff));
-}
-
-static inline void encode_copy_count(Encoder *encoder, uint8_t copy_count)
-{
- encode(encoder, copy_count);
- encoder->io.last_copy = encoder->io.now - 1; // io_now cannot be the first byte of the buffer
-}
-
-static inline void update_copy_count(Encoder *encoder, uint8_t copy_count)
-{
- GLZ_ASSERT(encoder->usr, encoder->io.last_copy);
- *(encoder->io.last_copy) = copy_count;
-}
-
-// decrease the io ptr by 1
-static inline void compress_output_prev(Encoder *encoder)
-{
- // io_now cannot be the first byte of the buffer
- encoder->io.now--;
- // the function should be called only when copy count is written unnecessarily by glz_compress
- GLZ_ASSERT(encoder->usr, encoder->io.now == encoder->io.last_copy)
-}
-
-static int encoder_reset(Encoder *encoder, uint8_t *io_ptr, uint8_t *io_ptr_end)
-{
- GLZ_ASSERT(encoder->usr, io_ptr <= io_ptr_end);
- encoder->io.bytes_count = io_ptr_end - io_ptr;
- encoder->io.start = io_ptr;
- encoder->io.now = io_ptr;
- encoder->io.end = io_ptr_end;
- encoder->io.last_copy = NULL;
-
- return TRUE;
-}
-
-/**********************************************************
-* Encoding
-***********************************************************/
-
-GlzEncoderContext *glz_encoder_create(uint8_t id, GlzEncDictContext *dictionary,
- GlzEncoderUsrContext *usr)
-{
- Encoder *encoder;
-
- if (!usr || !usr->error || !usr->warn || !usr->info || !usr->malloc ||
- !usr->free || !usr->more_space) {
- return NULL;
- }
-
- if (!(encoder = (Encoder *)usr->malloc(usr, sizeof(Encoder)))) {
- return NULL;
- }
-
- encoder->id = id;
- encoder->usr = usr;
- encoder->dict = (SharedDictionary *)dictionary;
-
- return (GlzEncoderContext *)encoder;
-}
-
-void glz_encoder_destroy(GlzEncoderContext *opaque_encoder)
-{
- Encoder *encoder = (Encoder *)opaque_encoder;
-
- if (!opaque_encoder) {
- return;
- }
-
- encoder->usr->free(encoder->usr, encoder);
-}
-
-/*
- * Give hints to the compiler for branch prediction optimization.
- */
-#if defined(__GNUC__) && (__GNUC__ > 2)
-#define LZ_EXPECT_CONDITIONAL(c) (__builtin_expect((c), 1))
-#define LZ_UNEXPECT_CONDITIONAL(c) (__builtin_expect((c), 0))
-#else
-#define LZ_EXPECT_CONDITIONAL(c) (c)
-#define LZ_UNEXPECT_CONDITIONAL(c) (c)
-#endif
-
-
-typedef uint8_t BYTE;
-
-typedef struct __attribute__ ((__packed__)) one_byte_pixel_t {
- BYTE a;
-} one_byte_pixel_t;
-
-typedef struct __attribute__ ((__packed__)) rgb32_pixel_t {
- BYTE b;
- BYTE g;
- BYTE r;
- BYTE pad;
-} rgb32_pixel_t;
-
-typedef struct __attribute__ ((__packed__)) rgb24_pixel_t {
- BYTE b;
- BYTE g;
- BYTE r;
-} rgb24_pixel_t;
-
-typedef uint16_t rgb16_pixel_t;
-
-#define BOUND_OFFSET 2
-#define LIMIT_OFFSET 6
-#define MIN_FILE_SIZE 4
-
-#define MAX_PIXEL_SHORT_DISTANCE 4096 // (1 << 12)
-#define MAX_PIXEL_MEDIUM_DISTANCE 131072 // (1 << 17) 2 ^ (12 + 5)
-#define MAX_PIXEL_LONG_DISTANCE 33554432 // (1 << 25) 2 ^ (12 + 5 + 8)
-#define MAX_IMAGE_DIST 16777215 // (1 << 24 - 1)
-
-
-//#define DEBUG_ENCODE
-
-
-#define GLZ_ENCODE_SIZE
-#include "glz-encode-match.tmpl.c"
-#define GLZ_ENCODE_MATCH
-#include "glz-encode-match.tmpl.c"
-
-#define LZ_PLT
-#include "glz-encode.tmpl.c"
-
-#define LZ_RGB16
-#include "glz-encode.tmpl.c"
-
-#define LZ_RGB24
-#include "glz-encode.tmpl.c"
-
-#define LZ_RGB32
-#include "glz-encode.tmpl.c"
-
-#define LZ_RGB_ALPHA
-#include "glz-encode.tmpl.c"
-
-
-int glz_encode(GlzEncoderContext *opaque_encoder,
- LzImageType type, int width, int height, int top_down,
- uint8_t *lines, unsigned int num_lines, int stride,
- uint8_t *io_ptr, unsigned int num_io_bytes,
- GlzUsrImageContext *usr_context, GlzEncDictImageContext **o_enc_dict_context)
-{
- Encoder *encoder = (Encoder *)opaque_encoder;
- WindowImage *dict_image;
- uint8_t *io_ptr_end = io_ptr + num_io_bytes;
- uint32_t win_head_image_dist;
-
- if (IS_IMAGE_TYPE_PLT[type]) {
- if (stride > (width / PLT_PIXELS_PER_BYTE[type])) {
- if (((width % PLT_PIXELS_PER_BYTE[type]) == 0) || (
- (stride - (width / PLT_PIXELS_PER_BYTE[type])) > 1)) {
- encoder->usr->error(encoder->usr, "stride overflows (plt)\n");
- }
- }
- } else {
- if (stride != width * RGB_BYTES_PER_PIXEL[type]) {
- encoder->usr->error(encoder->usr, "stride != width*bytes_per_pixel (rgb)\n");
- }
- }
-
- // assign the output buffer
- if (!encoder_reset(encoder, io_ptr, io_ptr_end)) {
- encoder->usr->error(encoder->usr, "lz encoder io reset failed\n");
- }
-
- // first read the list of the image segments into the dictionary window
- dict_image = glz_dictionary_pre_encode(encoder->id, encoder->usr,
- encoder->dict, type, width, height, stride,
- lines, num_lines, usr_context, &win_head_image_dist);
- *o_enc_dict_context = (GlzEncDictImageContext *)dict_image;
-
- encoder->cur_image.type = type;
- encoder->cur_image.id = dict_image->id;
- encoder->cur_image.first_win_seg = dict_image->first_seg;
-
- encode_32(encoder, GUINT32_TO_LE(LZ_MAGIC));
- encode_32(encoder, LZ_VERSION);
- if (top_down) {
- encode(encoder, (type & LZ_IMAGE_TYPE_MASK) | (1 << LZ_IMAGE_TYPE_LOG));
- } else {
- encode(encoder, (type & LZ_IMAGE_TYPE_MASK));
- }
-
- encode_32(encoder, width);
- encode_32(encoder, height);
- encode_32(encoder, stride);
- encode_64(encoder, dict_image->id);
- encode_32(encoder, win_head_image_dist);
-
- switch (encoder->cur_image.type) {
- case LZ_IMAGE_TYPE_PLT1_BE:
- case LZ_IMAGE_TYPE_PLT1_LE:
- case LZ_IMAGE_TYPE_PLT4_BE:
- case LZ_IMAGE_TYPE_PLT4_LE:
- case LZ_IMAGE_TYPE_PLT8:
- glz_plt_compress(encoder);
- break;
- case LZ_IMAGE_TYPE_RGB16:
- glz_rgb16_compress(encoder);
- break;
- case LZ_IMAGE_TYPE_RGB24:
- glz_rgb24_compress(encoder);
- break;
- case LZ_IMAGE_TYPE_RGB32:
- glz_rgb32_compress(encoder);
- break;
- case LZ_IMAGE_TYPE_RGBA:
- glz_rgb32_compress(encoder);
- glz_rgb_alpha_compress(encoder);
- break;
- case LZ_IMAGE_TYPE_INVALID:
- default:
- encoder->usr->error(encoder->usr, "bad image type\n");
- }
-
- glz_dictionary_post_encode(encoder->id, encoder->usr, encoder->dict);
-
- // move all the used segments to the free ones
- encoder->io.bytes_count -= (encoder->io.end - encoder->io.now);
-
- return encoder->io.bytes_count;
-}
diff --git a/server/glz_encoder.h b/server/glz_encoder.h
deleted file mode 100644
index e91f515..0000000
--- a/server/glz_encoder.h
+++ /dev/null
@@ -1,55 +0,0 @@
-/*
- Copyright (C) 2009 Red Hat, Inc.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, see <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _H_GLZ_ENCODER
-#define _H_GLZ_ENCODER
-
-/* Manging the lz encoding using a dictionary that is shared among encoders */
-
-#include <stdint.h>
-#include "common/lz_common.h"
-#include "glz_encoder_dictionary.h"
-#include "glz_encoder_config.h"
-
-typedef void GlzEncoderContext;
-
-GlzEncoderContext *glz_encoder_create(uint8_t id, GlzEncDictContext *dictionary,
- GlzEncoderUsrContext *usr);
-
-void glz_encoder_destroy(GlzEncoderContext *opaque_encoder);
-
-/*
- assumes width is in pixels and stride is in bytes
- usr_context : when an image is released from the window due to capacity overflow,
- usr_context is given as a parameter to the free_image callback.
- o_enc_dict_context: if glz_enc_dictionary_remove_image is called, it should be
- called with the o_enc_dict_context that is associated with
- the image.
-
- return: the number of bytes in the compressed data and sets o_enc_dict_context
-
- NOTE : currently supports only rgb images in which width*bytes_per_pixel = stride OR
- palette images in which stride equals the min number of bytes to hold a line.
- The stride should be > 0
-*/
-int glz_encode(GlzEncoderContext *opaque_encoder, LzImageType type, int width, int height,
- int top_down, uint8_t *lines, unsigned int num_lines, int stride,
- uint8_t *io_ptr, unsigned int num_io_bytes, GlzUsrImageContext *usr_context,
- GlzEncDictImageContext **o_enc_dict_context);
-
-
-#endif // _H_GLZ_ENCODER
diff --git a/server/glz_encoder_dictionary.c b/server/glz_encoder_dictionary.c
deleted file mode 100644
index 70226e1..0000000
--- a/server/glz_encoder_dictionary.c
+++ /dev/null
@@ -1,633 +0,0 @@
-/*
- Copyright (C) 2009 Red Hat, Inc.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, see <http://www.gnu.org/licenses/>.
-*/
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#include <pthread.h>
-#include <string.h>
-#include <stdio.h>
-
-#include "glz_encoder_dictionary.h"
-#include "glz_encoder_dictionary_protected.h"
-
-/* turning all used images to free ones. If they are alive, calling the free_image callback for
- each one */
-static inline void __glz_dictionary_window_reset_images(SharedDictionary *dict)
-{
- WindowImage *tmp;
-
- while (dict->window.used_images_head) {
- tmp = dict->window.used_images_head;
- dict->window.used_images_head = dict->window.used_images_head->next;
- if (tmp->is_alive) {
- dict->cur_usr->free_image(dict->cur_usr, tmp->usr_context);
- }
- tmp->next = dict->window.free_images;
- tmp->is_alive = FALSE;
- dict->window.free_images = tmp;
- }
- dict->window.used_images_tail = NULL;
-}
-
-/* allocate window fields (no reset)*/
-static int glz_dictionary_window_create(SharedDictionary *dict, uint32_t size)
-{
- if (size > LZ_MAX_WINDOW_SIZE) {
- return FALSE;
- }
-
- dict->window.size_limit = size;
- dict->window.segs = (WindowImageSegment *)(
- dict->cur_usr->malloc(dict->cur_usr, sizeof(WindowImageSegment) * INIT_IMAGE_SEGS_NUM));
-
- if (!dict->window.segs) {
- return FALSE;
- }
-
- dict->window.segs_quota = INIT_IMAGE_SEGS_NUM;
-
- dict->window.encoders_heads = (uint32_t *)dict->cur_usr->malloc(dict->cur_usr,
- sizeof(uint32_t) * dict->max_encoders);
-
- if (!dict->window.encoders_heads) {
- dict->cur_usr->free(dict->cur_usr, dict->window.segs);
- return FALSE;
- }
-
- dict->window.used_images_head = NULL;
- dict->window.used_images_tail = NULL;
- dict->window.free_images = NULL;
- dict->window.pixels_so_far = 0;
-
- return TRUE;
-}
-
-/* initializes an empty window (segs and encoder_heads should be pre allocated.
- resets the image infos, and calls the free_image usr callback*/
-static void glz_dictionary_window_reset(SharedDictionary *dict)
-{
- uint32_t i;
- WindowImageSegment *seg, *last_seg;
-
- last_seg = dict->window.segs + dict->window.segs_quota;
- /* reset free segs list */
- dict->window.free_segs_head = 0;
- for (seg = dict->window.segs, i = 0; seg < last_seg; seg++, i++) {
- seg->next = i + 1;
- seg->image = NULL;
- seg->lines = NULL;
- seg->lines_end = NULL;
- seg->pixels_num = 0;
- seg->pixels_so_far = 0;
- }
- dict->window.segs[dict->window.segs_quota - 1].next = NULL_IMAGE_SEG_ID;
-
- dict->window.used_segs_head = NULL_IMAGE_SEG_ID;
- dict->window.used_segs_tail = NULL_IMAGE_SEG_ID;
-
- // reset encoders heads
- for (i = 0; i < dict->max_encoders; i++) {
- dict->window.encoders_heads[i] = NULL_IMAGE_SEG_ID;
- }
-
- __glz_dictionary_window_reset_images(dict);
-}
-
-static inline void glz_dictionary_reset_hash(SharedDictionary *dict)
-{
- memset(dict->htab, 0, sizeof(HashEntry) * HASH_SIZE * HASH_CHAIN_SIZE);
-#ifdef CHAINED_HASH
- memset(dict->htab_counter, 0, HASH_SIZE * sizeof(uint8_t));
-#endif
-}
-
-static inline void glz_dictionary_window_destroy(SharedDictionary *dict)
-{
- __glz_dictionary_window_reset_images(dict);
-
- if (dict->window.segs) {
- dict->cur_usr->free(dict->cur_usr, dict->window.segs);
- dict->window.segs = NULL;
- }
-
- while (dict->window.free_images) {
- WindowImage *tmp = dict->window.free_images;
- dict->window.free_images = tmp->next;
-
- dict->cur_usr->free(dict->cur_usr, tmp);
- }
-
- if (dict->window.encoders_heads) {
- dict->cur_usr->free(dict->cur_usr, dict->window.encoders_heads);
- dict->window.encoders_heads = NULL;
- }
-}
-
-/* logic removal only */
-static inline void glz_dictionary_window_kill_image(SharedDictionary *dict, WindowImage *image)
-{
- image->is_alive = FALSE;
-}
-
-GlzEncDictContext *glz_enc_dictionary_create(uint32_t size, uint32_t max_encoders,
- GlzEncoderUsrContext *usr)
-{
- SharedDictionary *dict;
-
- if (!(dict = (SharedDictionary *)usr->malloc(usr,
- sizeof(SharedDictionary)))) {
- return NULL;
- }
-
- dict->cur_usr = usr;
- dict->last_image_id = 0;
- dict->max_encoders = max_encoders;
-
- pthread_mutex_init(&dict->lock, NULL);
- pthread_rwlock_init(&dict->rw_alloc_lock, NULL);
-
- dict->window.encoders_heads = NULL;
-
- // alloc window fields and reset
- if (!glz_dictionary_window_create(dict, size)) {
- dict->cur_usr->free(usr, dict);
- return NULL;
- }
-
- // reset window and hash
- glz_enc_dictionary_reset((GlzEncDictContext *)dict, usr);
-
- return (GlzEncDictContext *)dict;
-}
-
-void glz_enc_dictionary_get_restore_data(GlzEncDictContext *opaque_dict,
- GlzEncDictRestoreData *out_data, GlzEncoderUsrContext *usr)
-{
- SharedDictionary *dict = (SharedDictionary *)opaque_dict;
- dict->cur_usr = usr;
- GLZ_ASSERT(dict->cur_usr, opaque_dict);
- GLZ_ASSERT(dict->cur_usr, out_data);
-
- out_data->last_image_id = dict->last_image_id;
- out_data->max_encoders = dict->max_encoders;
- out_data->size = dict->window.size_limit;
-}
-
-GlzEncDictContext *glz_enc_dictionary_restore(GlzEncDictRestoreData *restore_data,
- GlzEncoderUsrContext *usr)
-{
- if (!restore_data) {
- return NULL;
- }
- SharedDictionary *ret = (SharedDictionary *)glz_enc_dictionary_create(
- restore_data->size, restore_data->max_encoders, usr);
- ret->last_image_id = restore_data->last_image_id;
- return ((GlzEncDictContext *)ret);
-}
-
-void glz_enc_dictionary_reset(GlzEncDictContext *opaque_dict, GlzEncoderUsrContext *usr)
-{
- SharedDictionary *dict = (SharedDictionary *)opaque_dict;
- dict->cur_usr = usr;
- GLZ_ASSERT(dict->cur_usr, opaque_dict);
-
- dict->last_image_id = 0;
- glz_dictionary_window_reset(dict);
- glz_dictionary_reset_hash(dict);
-}
-
-void glz_enc_dictionary_destroy(GlzEncDictContext *opaque_dict, GlzEncoderUsrContext *usr)
-{
- SharedDictionary *dict = (SharedDictionary *)opaque_dict;
-
- if (!opaque_dict) {
- return;
- }
-
- dict->cur_usr = usr;
- glz_dictionary_window_destroy(dict);
-
- pthread_mutex_destroy(&dict->lock);
- pthread_rwlock_destroy(&dict->rw_alloc_lock);
-
- dict->cur_usr->free(dict->cur_usr, dict);
-}
-
-uint32_t glz_enc_dictionary_get_size(GlzEncDictContext *opaque_dict)
-{
- SharedDictionary *dict = (SharedDictionary *)opaque_dict;
-
- if (!opaque_dict) {
- return 0;
- }
- return dict->window.size_limit;
-}
-
-/* doesn't call the remove image callback */
-void glz_enc_dictionary_remove_image(GlzEncDictContext *opaque_dict,
- GlzEncDictImageContext *opaque_image,
- GlzEncoderUsrContext *usr)
-{
- SharedDictionary *dict = (SharedDictionary *)opaque_dict;
- WindowImage *image = (WindowImage *)opaque_image;
- dict->cur_usr = usr;
- GLZ_ASSERT(dict->cur_usr, opaque_image && opaque_dict);
-
- glz_dictionary_window_kill_image(dict, image);
-}
-
-/***********************************************************************************
- Mutators of the window. Should be called by the encoder before and after encoding.
- ***********************************************************************************/
-
-static inline int __get_pixels_num(LzImageType image_type, unsigned int num_lines, int stride)
-{
- if (IS_IMAGE_TYPE_RGB[image_type]) {
- return num_lines * stride / RGB_BYTES_PER_PIXEL[image_type];
- } else {
- return num_lines * stride * PLT_PIXELS_PER_BYTE[image_type];
- }
-}
-
-static void __glz_dictionary_window_segs_realloc(SharedDictionary *dict)
-{
- WindowImageSegment *new_segs;
- uint32_t new_quota = (MAX_IMAGE_SEGS_NUM < (dict->window.segs_quota * 2)) ?
- MAX_IMAGE_SEGS_NUM : (dict->window.segs_quota * 2);
- WindowImageSegment *seg;
- uint32_t i;
-
- pthread_rwlock_wrlock(&dict->rw_alloc_lock);
-
- if (dict->window.segs_quota == MAX_IMAGE_SEGS_NUM) {
- dict->cur_usr->error(dict->cur_usr, "overflow in image segments window\n");
- }
-
- new_segs = (WindowImageSegment*)dict->cur_usr->malloc(
- dict->cur_usr, sizeof(WindowImageSegment) * new_quota);
-
- if (!new_segs) {
- dict->cur_usr->error(dict->cur_usr,
- "realloc of dictionary window failed\n");
- }
-
- memcpy(new_segs, dict->window.segs,
- sizeof(WindowImageSegment) * dict->window.segs_quota);
-
- // resetting the new elements
- for (i = dict->window.segs_quota, seg = new_segs + i; i < new_quota; i++, seg++) {
- seg->image = NULL;
- seg->lines = NULL;
- seg->lines_end = NULL;
- seg->pixels_num = 0;
- seg->pixels_so_far = 0;
- seg->next = i + 1;
- }
- new_segs[new_quota - 1].next = dict->window.free_segs_head;
- dict->window.free_segs_head = dict->window.segs_quota;
-
- dict->cur_usr->free(dict->cur_usr, dict->window.segs);
- dict->window.segs = new_segs;
- dict->window.segs_quota = new_quota;
-
- pthread_rwlock_unlock(&dict->rw_alloc_lock);
-}
-
-/* NOTE - it also updates the used_images_list*/
-static WindowImage *__glz_dictionary_window_alloc_image(SharedDictionary *dict)
-{
- WindowImage *ret;
-
- if (dict->window.free_images) {
- ret = dict->window.free_images;
- dict->window.free_images = ret->next;
- } else {
- if (!(ret = (WindowImage *)dict->cur_usr->malloc(dict->cur_usr,
- sizeof(*ret)))) {
- return NULL;
- }
- }
-
- ret->next = NULL;
- if (dict->window.used_images_tail) {
- dict->window.used_images_tail->next = ret;
- }
- dict->window.used_images_tail = ret;
-
- if (!dict->window.used_images_head) {
- dict->window.used_images_head = ret;
- }
- return ret;
-}
-
-/* NOTE - it doesn't update the used_segs list*/
-static uint32_t __glz_dictionary_window_alloc_image_seg(SharedDictionary *dict)
-{
- uint32_t seg_id;
- WindowImageSegment *seg;
-
- // TODO: when is it best to realloc? when full or when half full?
- if (dict->window.free_segs_head == NULL_IMAGE_SEG_ID) {
- __glz_dictionary_window_segs_realloc(dict);
- }
-
- GLZ_ASSERT(dict->cur_usr, dict->window.free_segs_head != NULL_IMAGE_SEG_ID);
-
- seg_id = dict->window.free_segs_head;
- seg = dict->window.segs + seg_id;
- dict->window.free_segs_head = seg->next;
-
- return seg_id;
-}
-
-/* moves image to free list and "kill" it. Calls the free_image callback if was alive. */
-static inline void __glz_dictionary_window_free_image(SharedDictionary *dict, WindowImage *image)
-{
- if (image->is_alive) {
- dict->cur_usr->free_image(dict->cur_usr, image->usr_context);
- }
- image->is_alive = FALSE;
- image->next = dict->window.free_images;
- dict->window.free_images = image;
-}
-
-/* moves all the segments that were associated with the images to the free segments */
-static inline void __glz_dictionary_window_free_image_segs(SharedDictionary *dict,
- WindowImage *image)
-{
- uint32_t old_free_head = dict->window.free_segs_head;
- uint32_t seg_id, next_seg_id;
-
- GLZ_ASSERT(dict->cur_usr, image->first_seg != NULL_IMAGE_SEG_ID);
- dict->window.free_segs_head = image->first_seg;
-
- // retrieving the last segment of the image
- for (seg_id = image->first_seg, next_seg_id = dict->window.segs[seg_id].next;
- (next_seg_id != NULL_IMAGE_SEG_ID) && (dict->window.segs[next_seg_id].image == image);
- seg_id = next_seg_id, next_seg_id = dict->window.segs[seg_id].next) {
- }
-
- // concatenate the free list
- dict->window.segs[seg_id].next = old_free_head;
-}
-
-/* Returns the logical head of the window after we add an image with the give size to its tail.
- Returns NULL when the window is empty, of when we have to empty the window in order
- to insert the new image. */
-static WindowImage *glz_dictionary_window_get_new_head(SharedDictionary *dict, int new_image_size)
-{
- uint32_t cur_win_size;
- WindowImage *cur_head;
-
- if ((uint32_t)new_image_size > dict->window.size_limit) {
- dict->cur_usr->error(dict->cur_usr, "image is bigger than window\n");
- }
-
- GLZ_ASSERT(dict->cur_usr, new_image_size < dict->window.size_limit)
-
- // the window is empty
- if (!dict->window.used_images_head) {
- return NULL;
- }
-
- GLZ_ASSERT(dict->cur_usr, dict->window.used_segs_head != NULL_IMAGE_SEG_ID);
- GLZ_ASSERT(dict->cur_usr, dict->window.used_segs_tail != NULL_IMAGE_SEG_ID);
-
- // used_segs_head is the latest logical head (the physical head may preceed it)
- cur_head = dict->window.segs[dict->window.used_segs_head].image;
- cur_win_size = dict->window.segs[dict->window.used_segs_tail].pixels_num +
- dict->window.segs[dict->window.used_segs_tail].pixels_so_far -
- dict->window.segs[dict->window.used_segs_head].pixels_so_far;
-
- while ((cur_win_size + new_image_size) > dict->window.size_limit) {
- GLZ_ASSERT(dict->cur_usr, cur_head);
- cur_win_size -= cur_head->size;
- cur_head = cur_head->next;
- }
-
- return cur_head;
-}
-
-static inline int glz_dictionary_is_in_use(SharedDictionary *dict)
-{
- uint32_t i = 0;
- for (i = 0; i < dict->max_encoders; i++) {
- if (dict->window.encoders_heads[i] != NULL_IMAGE_SEG_ID) {
- return TRUE;
- }
- }
- return FALSE;
-}
-
-/* remove from the window (and free relevant data) the images between the oldest physical head
- (inclusive) and the end_image (exclusive). If end_image is NULL, empties the window*/
-static void glz_dictionary_window_remove_head(SharedDictionary *dict, uint32_t encoder_id,
- WindowImage *end_image)
-{
- // note that the segs list heads (one per encoder) may be different than the
- // used_segs_head and it is updated somewhere else
- while (dict->window.used_images_head != end_image) {
- WindowImage *image = dict->window.used_images_head;
-
- __glz_dictionary_window_free_image_segs(dict, image);
- dict->window.used_images_head = image->next;
- __glz_dictionary_window_free_image(dict, image);
- }
-
- if (!dict->window.used_images_head) {
- dict->window.used_segs_head = NULL_IMAGE_SEG_ID;
- dict->window.used_segs_tail = NULL_IMAGE_SEG_ID;
- dict->window.used_images_tail = NULL;
- } else {
- dict->window.used_segs_head = end_image->first_seg;
- }
-}
-
-static uint32_t glz_dictionary_window_alloc_image_seg(SharedDictionary *dict, WindowImage* image,
- int size, int stride,
- uint8_t *lines, unsigned int num_lines)
-{
- uint32_t seg_id = __glz_dictionary_window_alloc_image_seg(dict);
- WindowImageSegment *seg = &dict->window.segs[seg_id];
-
- seg->image = image;
- seg->lines = lines;
- seg->lines_end = lines + num_lines * stride;
- seg->pixels_num = size;
- seg->pixels_so_far = dict->window.pixels_so_far;
- dict->window.pixels_so_far += seg->pixels_num;
-
- seg->next = NULL_IMAGE_SEG_ID;
-
- return seg_id;
-}
-
-static WindowImage *glz_dictionary_window_add_image(SharedDictionary *dict, LzImageType image_type,
- int image_size, int image_height,
- int image_stride, uint8_t *first_lines,
- unsigned int num_first_lines,
- GlzUsrImageContext *usr_image_context)
-{
- unsigned int num_lines = num_first_lines;
- unsigned int row;
- uint32_t seg_id, prev_seg_id;
- uint8_t* lines = first_lines;
- // alloc image info,update used head tail, if used_head null - update head
- WindowImage *image = __glz_dictionary_window_alloc_image(dict);
- image->id = dict->last_image_id++;
- image->size = image_size;
- image->type = image_type;
- image->usr_context = usr_image_context;
-
- if (num_lines <= 0) {
- num_lines = dict->cur_usr->more_lines(dict->cur_usr, &lines);
- if (num_lines <= 0) {
- dict->cur_usr->error(dict->cur_usr, "more lines failed\n");
- }
- }
-
- for (row = 0;;) {
- seg_id = glz_dictionary_window_alloc_image_seg(dict, image,
- image_size * num_lines / image_height,
- image_stride,
- lines, num_lines);
- if (row == 0) {
- image->first_seg = seg_id;
- } else {
- dict->window.segs[prev_seg_id].next = seg_id;
- }
-
- row += num_lines;
- if (row < (uint32_t)image_height) {
- num_lines = dict->cur_usr->more_lines(dict->cur_usr, &lines);
- if (num_lines <= 0) {
- dict->cur_usr->error(dict->cur_usr, "more lines failed\n");
- }
- } else {
- break;
- }
- prev_seg_id = seg_id;
- }
-
- if (dict->window.used_segs_tail == NULL_IMAGE_SEG_ID) {
- dict->window.used_segs_head = image->first_seg;
- dict->window.used_segs_tail = seg_id;
- } else {
- int prev_tail = dict->window.used_segs_tail;
-
- // The used segs may be in use by another thread which is during encoding
- // (read-only use - when going over the segs of an image,
- // see glz_encode_tmpl::compress).
- // Thus, the 'next' field of the list's tail can be accessed only
- // after all the new tail's data was set. Note that we are relying on
- // an atomic assignment (32 bit variable).
- // For the other thread that may read 'next' of the old tail, NULL_IMAGE_SEG_ID
- // is equivalent to a segment with an image id that is different
- // from the image id of the tail, so we don't need to further protect this field.
- dict->window.segs[prev_tail].next = image->first_seg;
- dict->window.used_segs_tail = seg_id;
- }
- image->is_alive = TRUE;
-
- return image;
-}
-
-WindowImage *glz_dictionary_pre_encode(uint32_t encoder_id, GlzEncoderUsrContext *usr,
- SharedDictionary *dict, LzImageType image_type,
- int image_width, int image_height, int image_stride,
- uint8_t *first_lines, unsigned int num_first_lines,
- GlzUsrImageContext *usr_image_context,
- uint32_t *image_head_dist)
-{
- WindowImage *new_win_head, *ret;
- int image_size;
-
-
- pthread_mutex_lock(&dict->lock);
-
- dict->cur_usr = usr;
- GLZ_ASSERT(dict->cur_usr, dict->window.encoders_heads[encoder_id] == NULL_IMAGE_SEG_ID);
-
- image_size = __get_pixels_num(image_type, image_height, image_stride);
- new_win_head = glz_dictionary_window_get_new_head(dict, image_size);
-
- if (!glz_dictionary_is_in_use(dict)) {
- glz_dictionary_window_remove_head(dict, encoder_id, new_win_head);
- }
-
- ret = glz_dictionary_window_add_image(dict, image_type, image_size, image_height, image_stride,
- first_lines, num_first_lines, usr_image_context);
-
- if (new_win_head) {
- dict->window.encoders_heads[encoder_id] = new_win_head->first_seg;
- *image_head_dist = (uint32_t)(ret->id - new_win_head->id); // shouldn't be greater than 32
- // bit because the window size is
- // limited to 2^25
- } else {
- dict->window.encoders_heads[encoder_id] = ret->first_seg;
- *image_head_dist = 0;
- }
-
-
- // update encoders head (the other heads were already updated)
- pthread_mutex_unlock(&dict->lock);
- pthread_rwlock_rdlock(&dict->rw_alloc_lock);
- return ret;
-}
-
-void glz_dictionary_post_encode(uint32_t encoder_id, GlzEncoderUsrContext *usr,
- SharedDictionary *dict)
-{
- uint32_t i;
- uint32_t early_head_seg = NULL_IMAGE_SEG_ID;
- uint32_t this_encoder_head_seg;
-
- pthread_rwlock_unlock(&dict->rw_alloc_lock);
- pthread_mutex_lock(&dict->lock);
- dict->cur_usr = usr;
-
- GLZ_ASSERT(dict->cur_usr, dict->window.encoders_heads[encoder_id] != NULL_IMAGE_SEG_ID);
- // get the earliest head in use (not including this encoder head)
- for (i = 0; i < dict->max_encoders; i++) {
- if (i != encoder_id) {
- if (IMAGE_SEG_IS_EARLIER(dict, dict->window.encoders_heads[i], early_head_seg)) {
- early_head_seg = dict->window.encoders_heads[i];
- }
- }
- }
-
- // possible only if early_head_seg == NULL
- if (IMAGE_SEG_IS_EARLIER(dict, dict->window.used_segs_head, early_head_seg)) {
- early_head_seg = dict->window.used_segs_head;
- }
-
- this_encoder_head_seg = dict->window.encoders_heads[encoder_id];
-
- GLZ_ASSERT(dict->cur_usr, early_head_seg != NULL_IMAGE_SEG_ID);
-
- if (IMAGE_SEG_IS_EARLIER(dict, this_encoder_head_seg, early_head_seg)) {
- GLZ_ASSERT(dict->cur_usr,
- this_encoder_head_seg == dict->window.used_images_head->first_seg);
- glz_dictionary_window_remove_head(dict, encoder_id,
- dict->window.segs[early_head_seg].image);
- }
-
-
- dict->window.encoders_heads[encoder_id] = NULL_IMAGE_SEG_ID;
- pthread_mutex_unlock(&dict->lock);
-}
diff --git a/server/glz_encoder_dictionary.h b/server/glz_encoder_dictionary.h
deleted file mode 100644
index eb57aa5..0000000
--- a/server/glz_encoder_dictionary.h
+++ /dev/null
@@ -1,69 +0,0 @@
-/*
- Copyright (C) 2009 Red Hat, Inc.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, see <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _H_GLZ_ENCODER_DICTIONARY
-#define _H_GLZ_ENCODER_DICTIONARY
-
-#include <stdint.h>
-#include "glz_encoder_config.h"
-
-/*
- Interface for maintaining lz dictionary that is shared among several encoders.
- The interface for accessing the dictionary for encoding purposes is located in
- glz_encoder_dictionary_protected.h
-*/
-
-typedef void GlzEncDictContext;
-typedef void GlzEncDictImageContext;
-
-/* NOTE: DISPLAY_MIGRATE_DATA_VERSION should change in case GlzEncDictRestoreData changes*/
-typedef struct GlzEncDictRestoreData {
- uint32_t size;
- uint32_t max_encoders;
- uint64_t last_image_id;
-} GlzEncDictRestoreData;
-
-/* size : maximal number of pixels occupying the window
- max_encoders: maximal number of encoders that use the dictionary
- usr : callbacks */
-GlzEncDictContext *glz_enc_dictionary_create(uint32_t size, uint32_t max_encoders,
- GlzEncoderUsrContext *usr);
-
-void glz_enc_dictionary_destroy(GlzEncDictContext *opaque_dict, GlzEncoderUsrContext *usr);
-
-/* returns the window capacity in pixels */
-uint32_t glz_enc_dictionary_get_size(GlzEncDictContext *);
-
-/* returns the current state of the dictionary.
- NOTE - you should use it only when no encoder uses the dictionary. */
-void glz_enc_dictionary_get_restore_data(GlzEncDictContext *opaque_dict,
- GlzEncDictRestoreData *out_data,
- GlzEncoderUsrContext *usr);
-
-/* creates a dictionary and initialized it by use the given info */
-GlzEncDictContext *glz_enc_dictionary_restore(GlzEncDictRestoreData *restore_data,
- GlzEncoderUsrContext *usr);
-
-/* NOTE - you should use this routine only when no encoder uses the dictionary. */
-void glz_enc_dictionary_reset(GlzEncDictContext *opaque_dict, GlzEncoderUsrContext *usr);
-
-/* image: the context returned by the encoder when the image was encoded.
- NOTE - you should use this routine only when no encoder uses the dictionary.*/
-void glz_enc_dictionary_remove_image(GlzEncDictContext *opaque_dict,
- GlzEncDictImageContext *image, GlzEncoderUsrContext *usr);
-
-#endif // _H_GLZ_ENCODER_DICTIONARY
diff --git a/server/glz_encoder_dictionary_protected.h b/server/glz_encoder_dictionary_protected.h
deleted file mode 100644
index 098684f..0000000
--- a/server/glz_encoder_dictionary_protected.h
+++ /dev/null
@@ -1,186 +0,0 @@
-/*
- Copyright (C) 2009 Red Hat, Inc.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, see <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _H_GLZ_ENCODER_DICTIONARY_PROTECTED
-#define _H_GLZ_ENCODER_DICTIONARY_PROTECTED
-
-/* Interface for using the dictionary for encoding.
- Data structures are exposed for the encoder for efficiency
- purposes. */
-typedef struct WindowImage WindowImage;
-typedef struct WindowImageSegment WindowImageSegment;
-
-
-//#define CHAINED_HASH
-
-#ifdef CHAINED_HASH
-#define HASH_SIZE_LOG 16
-#define HASH_CHAIN_SIZE 4
-#else
-#define HASH_SIZE_LOG 20
-#define HASH_CHAIN_SIZE 1
-#endif
-
-#define HASH_SIZE (1 << HASH_SIZE_LOG)
-#define HASH_MASK (HASH_SIZE - 1)
-
-typedef struct HashEntry HashEntry;
-
-typedef struct SharedDictionary SharedDictionary;
-
-struct WindowImage {
- uint64_t id;
- LzImageType type;
- int size; // in pixels
- uint32_t first_seg;
- GlzUsrImageContext *usr_context;
- WindowImage* next;
- uint8_t is_alive;
-};
-
-#define MAX_IMAGE_SEGS_NUM (0xffffffff)
-#define NULL_IMAGE_SEG_ID MAX_IMAGE_SEGS_NUM
-#define INIT_IMAGE_SEGS_NUM 1000
-
-/* Images can be separated into several chunks. The basic unit of the
- dictionary window is one image segment. Each segment is encoded separately.
- An encoded match can refer to only one segment.*/
-struct WindowImageSegment {
- WindowImage *image;
- void *lines;
- void *lines_end;
- uint32_t pixels_num; // Number of pixels in the segment
- uint64_t pixels_so_far; // Total no. pixels passed through the window till this segment.
- // NOTE - never use size delta independently. It should
- // always be used with respect to a previous size delta
- uint32_t next;
-};
-
-
-struct __attribute__ ((__packed__)) HashEntry {
- uint32_t image_seg_idx;
- uint32_t ref_pix_idx;
-};
-
-
-struct SharedDictionary {
- struct {
- /* The segments storage. A dynamic array.
- By referring to a segment by its index, instead of address,
- we save space in the hash entries (32bit instead of 64bit) */
- WindowImageSegment *segs;
- uint32_t segs_quota;
-
- /* The window is manged as a linked list rather than as a cyclic
- array in order to keep the indices of the segments consistent
- after reallocation */
-
- /* the window in a resolution of image segments */
- uint32_t used_segs_head; // the latest head
- uint32_t used_segs_tail;
- uint32_t free_segs_head;
-
- uint32_t *encoders_heads; // Holds for each encoder (by id), the window head when
- // it started the encoding.
- // The head is NULL_IMAGE_SEG_ID when the encoder is
- // not encoding.
-
- /* the window in a resolution of images. But here the head contains the oldest head*/
- WindowImage* used_images_tail;
- WindowImage* used_images_head;
- WindowImage* free_images;
-
- uint64_t pixels_so_far;
- uint32_t size_limit; // max number of pixels in a window (per encoder)
- } window;
-
- /* Concurrency issues: the reading/writing of each entry field should be atomic.
- It is allowed that the reading/writing of the whole entry won't be atomic,
- since before we access a reference we check its validity*/
-#ifdef CHAINED_HASH
- HashEntry htab[HASH_SIZE][HASH_CHAIN_SIZE];
- uint8_t htab_counter[HASH_SIZE]; //cyclic counter for the next entry in a chain to be assigned
-#else
- HashEntry htab[HASH_SIZE];
-#endif
-
- uint64_t last_image_id;
- uint32_t max_encoders;
- pthread_mutex_t lock;
- pthread_rwlock_t rw_alloc_lock;
- GlzEncoderUsrContext *cur_usr; // each encoder has other context.
-};
-
-/*
- Add the image to the tail of the window.
- If possible, release images from the head of the window.
- Also perform concurrency related operations.
-
- usr_image_context: when an image is released from the window due to capacity overflow,
- usr_image_context is given as a parameter to the free_image callback.
-
- image_head_dist : the number of images between the current image and the head of the
- window that is associated with the encoder.
-*/
-WindowImage *glz_dictionary_pre_encode(uint32_t encoder_id, GlzEncoderUsrContext *usr,
- SharedDictionary *dict, LzImageType image_type,
- int image_width, int image_height, int image_stride,
- uint8_t *first_lines, unsigned int num_first_lines,
- GlzUsrImageContext *usr_image_context,
- uint32_t *image_head_dist);
-
-/*
- Performs concurrency related operations.
- If possible, release images from the head of the window.
-*/
-void glz_dictionary_post_encode(uint32_t encoder_id, GlzEncoderUsrContext *usr,
- SharedDictionary *dict);
-
-#define IMAGE_SEG_IS_EARLIER(dict, dst_seg, src_seg) ( \
- ((src_seg) == NULL_IMAGE_SEG_ID) || (((dst_seg) != NULL_IMAGE_SEG_ID) \
- && ((dict)->window.segs[(dst_seg)].pixels_so_far < \
- (dict)->window.segs[(src_seg)].pixels_so_far)))
-
-
-#ifdef CHAINED_HASH
-#define UPDATE_HASH(dict, hval, seg, pix) { \
- uint8_t tmp_count = (dict)->htab_counter[hval]; \
- (dict)->htab[hval][tmp_count].image_seg_idx = seg; \
- (dict)->htab[hval][tmp_count].ref_pix_idx = pix; \
- tmp_count = ((tmp_count) + 1) & (HASH_CHAIN_SIZE - 1); \
- dict->htab_counter[hval] = tmp_count; \
-}
-#else
-#define UPDATE_HASH(dict, hval, seg, pix) { \
- (dict)->htab[hval].image_seg_idx = seg; \
- (dict)->htab[hval].ref_pix_idx = pix; \
-}
-#endif
-
-/* checks if the reference segment is located in the range of the window
- of the current encoder */
-#define REF_SEG_IS_VALID(dict, enc_id, ref_seg, src_seg) ( \
- ((ref_seg) == (src_seg)) || \
- ((ref_seg)->image && \
- (ref_seg)->image->is_alive && \
- (src_seg->image->type == ref_seg->image->type) && \
- (ref_seg->pixels_so_far <= src_seg->pixels_so_far) && \
- ((dict)->window.segs[ \
- (dict)->window.encoders_heads[enc_id]].pixels_so_far <= \
- ref_seg->pixels_so_far)))
-
-#endif // _H_GLZ_ENCODER_DICTIONARY_PROTECTED
diff --git a/server/image-cache.c b/server/image-cache.c
new file mode 100644
index 0000000..f4d2ee9
--- /dev/null
+++ b/server/image-cache.c
@@ -0,0 +1,214 @@
+/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ Copyright (C) 2009-2015 Red Hat, Inc.
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, see <http://www.gnu.org/licenses/>.
+*/
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "image-cache.h"
+#include "red_parse_qxl.h"
+#include "display-channel.h"
+
+static ImageCacheItem *image_cache_find(ImageCache *cache, uint64_t id)
+{
+ ImageCacheItem *item = cache->hash_table[id % IMAGE_CACHE_HASH_SIZE];
+
+ while (item) {
+ if (item->id == id) {
+ return item;
+ }
+ item = item->next;
+ }
+ return NULL;
+}
+
+int image_cache_hit(ImageCache *cache, uint64_t id)
+{
+ ImageCacheItem *item;
+ if (!(item = image_cache_find(cache, id))) {
+ return FALSE;
+ }
+#ifdef IMAGE_CACHE_AGE
+ item->age = cache->age;
+#endif
+ ring_remove(&item->lru_link);
+ ring_add(&cache->lru, &item->lru_link);
+ return TRUE;
+}
+
+static void image_cache_remove(ImageCache *cache, ImageCacheItem *item)
+{
+ ImageCacheItem **now;
+
+ now = &cache->hash_table[item->id % IMAGE_CACHE_HASH_SIZE];
+ for (;;) {
+ spice_assert(*now);
+ if (*now == item) {
+ *now = item->next;
+ break;
+ }
+ now = &(*now)->next;
+ }
+ ring_remove(&item->lru_link);
+ pixman_image_unref(item->image);
+ free(item);
+#ifndef IMAGE_CACHE_AGE
+ cache->num_items--;
+#endif
+}
+
+#define IMAGE_CACHE_MAX_ITEMS 2
+
+static void image_cache_put(SpiceImageCache *spice_cache, uint64_t id, pixman_image_t *image)
+{
+ ImageCache *cache = (ImageCache *)spice_cache;
+ ImageCacheItem *item;
+
+#ifndef IMAGE_CACHE_AGE
+ if (cache->num_items == IMAGE_CACHE_MAX_ITEMS) {
+ ImageCacheItem *tail = (ImageCacheItem *)ring_get_tail(&cache->lru);
+ spice_assert(tail);
+ image_cache_remove(cache, tail);
+ }
+#endif
+
+ item = spice_new(ImageCacheItem, 1);
+ item->id = id;
+#ifdef IMAGE_CACHE_AGE
+ item->age = cache->age;
+#else
+ cache->num_items++;
+#endif
+ item->image = pixman_image_ref(image);
+ ring_item_init(&item->lru_link);
+
+ item->next = cache->hash_table[item->id % IMAGE_CACHE_HASH_SIZE];
+ cache->hash_table[item->id % IMAGE_CACHE_HASH_SIZE] = item;
+
+ ring_add(&cache->lru, &item->lru_link);
+}
+
+static pixman_image_t *image_cache_get(SpiceImageCache *spice_cache, uint64_t id)
+{
+ ImageCache *cache = (ImageCache *)spice_cache;
+
+ ImageCacheItem *item = image_cache_find(cache, id);
+ if (!item) {
+ spice_error("not found");
+ }
+ return pixman_image_ref(item->image);
+}
+
+void image_cache_init(ImageCache *cache)
+{
+ static SpiceImageCacheOps image_cache_ops = {
+ image_cache_put,
+ image_cache_get,
+ };
+
+ cache->base.ops = &image_cache_ops;
+ memset(cache->hash_table, 0, sizeof(cache->hash_table));
+ ring_init(&cache->lru);
+#ifdef IMAGE_CACHE_AGE
+ cache->age = 0;
+#else
+ cache->num_items = 0;
+#endif
+}
+
+void image_cache_reset(ImageCache *cache)
+{
+ ImageCacheItem *item;
+
+ while ((item = (ImageCacheItem *)ring_get_head(&cache->lru))) {
+ image_cache_remove(cache, item);
+ }
+#ifdef IMAGE_CACHE_AGE
+ cache->age = 0;
+#endif
+}
+
+#define IMAGE_CACHE_DEPTH 4
+
+void image_cache_aging(ImageCache *cache)
+{
+#ifdef IMAGE_CACHE_AGE
+ ImageCacheItem *item;
+
+ cache->age++;
+ while ((item = (ImageCacheItem *)ring_get_tail(&cache->lru)) &&
+ cache->age - item->age > IMAGE_CACHE_DEPTH) {
+ image_cache_remove(cache, item);
+ }
+#endif
+}
+
+void image_cache_localize(ImageCache *cache, SpiceImage **image_ptr,
+ SpiceImage *image_store, Drawable *drawable)
+{
+ SpiceImage *image = *image_ptr;
+
+ if (image == NULL) {
+ spice_assert(drawable != NULL);
+ spice_assert(drawable->red_drawable->self_bitmap_image != NULL);
+ *image_ptr = drawable->red_drawable->self_bitmap_image;
+ return;
+ }
+
+ if (image_cache_hit(cache, image->descriptor.id)) {
+ image_store->descriptor = image->descriptor;
+ image_store->descriptor.type = SPICE_IMAGE_TYPE_FROM_CACHE;
+ image_store->descriptor.flags = 0;
+ *image_ptr = image_store;
+ return;
+ }
+
+ switch (image->descriptor.type) {
+ case SPICE_IMAGE_TYPE_QUIC: {
+ image_store->descriptor = image->descriptor;
+ image_store->u.quic = image->u.quic;
+ *image_ptr = image_store;
+#ifdef IMAGE_CACHE_AGE
+ image_store->descriptor.flags |= SPICE_IMAGE_FLAGS_CACHE_ME;
+#else
+ if (image_store->descriptor.width * image->descriptor.height >= 640 * 480) {
+ image_store->descriptor.flags |= SPICE_IMAGE_FLAGS_CACHE_ME;
+ }
+#endif
+ break;
+ }
+ case SPICE_IMAGE_TYPE_BITMAP:
+ case SPICE_IMAGE_TYPE_SURFACE:
+ /* nothing */
+ break;
+ default:
+ spice_error("invalid image type");
+ }
+}
+
+void image_cache_localize_brush(ImageCache *cache, SpiceBrush *brush, SpiceImage *image_store)
+{
+ if (brush->type == SPICE_BRUSH_TYPE_PATTERN) {
+ image_cache_localize(cache, &brush->u.pattern.pat, image_store, NULL);
+ }
+}
+
+void image_cache_localize_mask(ImageCache *cache, SpiceQMask *mask, SpiceImage *image_store)
+{
+ if (mask->bitmap) {
+ image_cache_localize(cache, &mask->bitmap, image_store, NULL);
+ }
+}
diff --git a/server/image-cache.h b/server/image-cache.h
new file mode 100644
index 0000000..d66c7ff
--- /dev/null
+++ b/server/image-cache.h
@@ -0,0 +1,65 @@
+/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ Copyright (C) 2009-2015 Red Hat, Inc.
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, see <http://www.gnu.org/licenses/>.
+*/
+#ifndef IMAGE_CACHE_H_
+#define IMAGE_CACHE_H_
+
+#include <inttypes.h>
+
+#include "common/pixman_utils.h"
+#include "common/canvas_base.h"
+#include "common/ring.h"
+
+/* FIXME: move back to display_channel.h (once structs are private) */
+typedef struct Drawable Drawable;
+typedef struct DisplayChannelClient DisplayChannelClient;
+
+typedef struct ImageCacheItem {
+ RingItem lru_link;
+ uint64_t id;
+#ifdef IMAGE_CACHE_AGE
+ uint32_t age;
+#endif
+ struct ImageCacheItem *next;
+ pixman_image_t *image;
+} ImageCacheItem;
+
+#define IMAGE_CACHE_HASH_SIZE 1024
+
+typedef struct ImageCache {
+ SpiceImageCache base;
+ ImageCacheItem *hash_table[IMAGE_CACHE_HASH_SIZE];
+ Ring lru;
+#ifdef IMAGE_CACHE_AGE
+ uint32_t age;
+#else
+ uint32_t num_items;
+#endif
+} ImageCache;
+
+int image_cache_hit (ImageCache *cache, uint64_t id);
+void image_cache_init (ImageCache *cache);
+void image_cache_reset (ImageCache *cache);
+void image_cache_aging (ImageCache *cache);
+void image_cache_localize (ImageCache *cache, SpiceImage **image_ptr,
+ SpiceImage *image_store, Drawable *drawable);
+void image_cache_localize_brush (ImageCache *cache, SpiceBrush *brush,
+ SpiceImage *image_store);
+void image_cache_localize_mask (ImageCache *cache, SpiceQMask *mask,
+ SpiceImage *image_store);
+
+#endif
diff --git a/server/inputs-channel.c b/server/inputs-channel.c
new file mode 100644
index 0000000..3e8fccd
--- /dev/null
+++ b/server/inputs-channel.c
@@ -0,0 +1,679 @@
+/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ Copyright (C) 2009 Red Hat, Inc.
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, see <http://www.gnu.org/licenses/>.
+*/
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <netinet/in.h> // IPPROTO_TCP
+#include <netinet/tcp.h> // TCP_NODELAY
+#include <fcntl.h>
+#include <stddef.h> // NULL
+#include <errno.h>
+#include <spice/macros.h>
+#include <spice/vd_agent.h>
+#include <spice/protocol.h>
+#include <stdbool.h>
+
+#include "common/marshaller.h"
+#include "common/messages.h"
+#include "common/generated_server_marshallers.h"
+
+#include "demarshallers.h"
+#include "spice.h"
+#include "red_common.h"
+#include "reds.h"
+#include "reds_stream.h"
+#include "red_channel.h"
+#include "main-channel.h"
+#include "inputs-channel.h"
+#include "migration-protocol.h"
+
+// TODO: RECEIVE_BUF_SIZE used to be the same for inputs_channel and main_channel
+// since it was defined once in reds.c which contained both.
+// Now that they are split we can give a more fitting value for inputs - what
+// should it be?
+#define REDS_AGENT_WINDOW_SIZE 10
+#define REDS_NUM_INTERNAL_AGENT_MESSAGES 1
+
+// approximate max receive message size
+#define RECEIVE_BUF_SIZE \
+ (4096 + (REDS_AGENT_WINDOW_SIZE + REDS_NUM_INTERNAL_AGENT_MESSAGES) * SPICE_AGENT_MAX_DATA_SIZE)
+
+struct SpiceKbdState {
+ bool push_ext;
+
+ /* track key press state */
+ bool key[0x7f];
+ bool key_ext[0x7f];
+};
+
+struct SpiceMouseState {
+ int dummy;
+};
+
+struct SpiceTabletState {
+ int dummy;
+};
+
+typedef struct InputsChannelClient {
+ RedChannelClient base;
+ uint16_t motion_count;
+} InputsChannelClient;
+
+typedef struct InputsChannel {
+ RedChannel base;
+ uint8_t recv_buf[RECEIVE_BUF_SIZE];
+ VDAgentMouseState mouse_state;
+ int src_during_migrate;
+} InputsChannel;
+
+enum {
+ PIPE_ITEM_INPUTS_INIT = PIPE_ITEM_TYPE_CHANNEL_BASE,
+ PIPE_ITEM_MOUSE_MOTION_ACK,
+ PIPE_ITEM_KEY_MODIFIERS,
+ PIPE_ITEM_MIGRATE_DATA,
+};
+
+typedef struct InputsPipeItem {
+ PipeItem base;
+} InputsPipeItem;
+
+typedef struct KeyModifiersPipeItem {
+ PipeItem base;
+ uint8_t modifiers;
+} KeyModifiersPipeItem;
+
+typedef struct InputsInitPipeItem {
+ PipeItem base;
+ uint8_t modifiers;
+} InputsInitPipeItem;
+
+static SpiceKbdInstance *keyboard = NULL;
+static SpiceMouseInstance *mouse = NULL;
+static SpiceTabletInstance *tablet = NULL;
+
+static SpiceTimer *key_modifiers_timer;
+
+static InputsChannel *g_inputs_channel = NULL;
+
+#define KEY_MODIFIERS_TTL (1000 * 2) /*2sec*/
+
+#define SCROLL_LOCK_SCAN_CODE 0x46
+#define NUM_LOCK_SCAN_CODE 0x45
+#define CAPS_LOCK_SCAN_CODE 0x3a
+
+int inputs_inited(void)
+{
+ return !!g_inputs_channel;
+}
+
+int inputs_set_keyboard(SpiceKbdInstance *_keyboard)
+{
+ if (keyboard) {
+ spice_printerr("already have keyboard");
+ return -1;
+ }
+ keyboard = _keyboard;
+ keyboard->st = spice_new0(SpiceKbdState, 1);
+ return 0;
+}
+
+int inputs_set_mouse(SpiceMouseInstance *_mouse)
+{
+ if (mouse) {
+ spice_printerr("already have mouse");
+ return -1;
+ }
+ mouse = _mouse;
+ mouse->st = spice_new0(SpiceMouseState, 1);
+ return 0;
+}
+
+int inputs_set_tablet(SpiceTabletInstance *_tablet)
+{
+ if (tablet) {
+ spice_printerr("already have tablet");
+ return -1;
+ }
+ tablet = _tablet;
+ tablet->st = spice_new0(SpiceTabletState, 1);
+ return 0;
+}
+
+int inputs_has_tablet(void)
+{
+ return !!tablet;
+}
+
+void inputs_detach_tablet(SpiceTabletInstance *_tablet)
+{
+ spice_printerr("");
+ tablet = NULL;
+}
+
+void inputs_set_tablet_logical_size(int x_res, int y_res)
+{
+ SpiceTabletInterface *sif;
+
+ sif = SPICE_CONTAINEROF(tablet->base.sif, SpiceTabletInterface, base);
+ sif->set_logical_size(tablet, x_res, y_res);
+}
+
+const VDAgentMouseState *inputs_get_mouse_state(void)
+{
+ spice_assert(g_inputs_channel);
+ return &g_inputs_channel->mouse_state;
+}
+
+static uint8_t *inputs_channel_alloc_msg_rcv_buf(RedChannelClient *rcc,
+ uint16_t type,
+ uint32_t size)
+{
+ InputsChannel *inputs_channel = SPICE_CONTAINEROF(rcc->channel, InputsChannel, base);
+
+ if (size > RECEIVE_BUF_SIZE) {
+ spice_printerr("error: too large incoming message");
+ return NULL;
+ }
+ return inputs_channel->recv_buf;
+}
+
+static void inputs_channel_release_msg_rcv_buf(RedChannelClient *rcc,
+ uint16_t type,
+ uint32_t size,
+ uint8_t *msg)
+{
+}
+
+#define OUTGOING_OK 0
+#define OUTGOING_FAILED -1
+#define OUTGOING_BLOCKED 1
+
+#define RED_MOUSE_STATE_TO_LOCAL(state) \
+ ((state & SPICE_MOUSE_BUTTON_MASK_LEFT) | \
+ ((state & SPICE_MOUSE_BUTTON_MASK_MIDDLE) << 1) | \
+ ((state & SPICE_MOUSE_BUTTON_MASK_RIGHT) >> 1))
+
+#define RED_MOUSE_BUTTON_STATE_TO_AGENT(state) \
+ (((state & SPICE_MOUSE_BUTTON_MASK_LEFT) ? VD_AGENT_LBUTTON_MASK : 0) | \
+ ((state & SPICE_MOUSE_BUTTON_MASK_MIDDLE) ? VD_AGENT_MBUTTON_MASK : 0) | \
+ ((state & SPICE_MOUSE_BUTTON_MASK_RIGHT) ? VD_AGENT_RBUTTON_MASK : 0))
+
+static void activate_modifiers_watch(void)
+{
+ core->timer_start(key_modifiers_timer, KEY_MODIFIERS_TTL);
+}
+
+static void kbd_push_scan(SpiceKbdInstance *sin, uint8_t scan)
+{
+ SpiceKbdInterface *sif;
+
+ if (!sin) {
+ return;
+ }
+ sif = SPICE_CONTAINEROF(sin->base.sif, SpiceKbdInterface, base);
+
+ /* track XT scan code set 1 key state */
+ if (scan == 0xe0) {
+ sin->st->push_ext = TRUE;
+ } else {
+ bool *state = sin->st->push_ext ? sin->st->key : sin->st->key_ext;
+ sin->st->push_ext = FALSE;
+ state[scan & 0x7f] = !(scan & 0x80);
+ }
+
+ sif->push_scan_freg(sin, scan);
+}
+
+static uint8_t kbd_get_leds(SpiceKbdInstance *sin)
+{
+ SpiceKbdInterface *sif;
+
+ if (!sin) {
+ return 0;
+ }
+ sif = SPICE_CONTAINEROF(sin->base.sif, SpiceKbdInterface, base);
+ return sif->get_leds(sin);
+}
+
+static PipeItem *inputs_key_modifiers_item_new(
+ RedChannelClient *rcc, void *data, int num)
+{
+ KeyModifiersPipeItem *item = spice_malloc(sizeof(KeyModifiersPipeItem));
+
+ red_channel_pipe_item_init(rcc->channel, &item->base,
+ PIPE_ITEM_KEY_MODIFIERS);
+ item->modifiers = *(uint8_t *)data;
+ return &item->base;
+}
+
+static void inputs_channel_send_migrate_data(RedChannelClient *rcc,
+ SpiceMarshaller *m,
+ PipeItem *item)
+{
+ InputsChannelClient *icc = SPICE_CONTAINEROF(rcc, InputsChannelClient, base);
+
+ g_inputs_channel->src_during_migrate = FALSE;
+ red_channel_client_init_send_data(rcc, SPICE_MSG_MIGRATE_DATA, item);
+
+ spice_marshaller_add_uint32(m, SPICE_MIGRATE_DATA_INPUTS_MAGIC);
+ spice_marshaller_add_uint32(m, SPICE_MIGRATE_DATA_INPUTS_VERSION);
+ spice_marshaller_add_uint16(m, icc->motion_count);
+}
+
+static void inputs_channel_release_pipe_item(RedChannelClient *rcc,
+ PipeItem *base, int item_pushed)
+{
+ free(base);
+}
+
+static void inputs_channel_send_item(RedChannelClient *rcc, PipeItem *base)
+{
+ SpiceMarshaller *m = red_channel_client_get_marshaller(rcc);
+
+ switch (base->type) {
+ case PIPE_ITEM_KEY_MODIFIERS:
+ {
+ SpiceMsgInputsKeyModifiers key_modifiers;
+
+ red_channel_client_init_send_data(rcc, SPICE_MSG_INPUTS_KEY_MODIFIERS, base);
+ key_modifiers.modifiers =
+ SPICE_CONTAINEROF(base, KeyModifiersPipeItem, base)->modifiers;
+ spice_marshall_msg_inputs_key_modifiers(m, &key_modifiers);
+ break;
+ }
+ case PIPE_ITEM_INPUTS_INIT:
+ {
+ SpiceMsgInputsInit inputs_init;
+
+ red_channel_client_init_send_data(rcc, SPICE_MSG_INPUTS_INIT, base);
+ inputs_init.keyboard_modifiers =
+ SPICE_CONTAINEROF(base, InputsInitPipeItem, base)->modifiers;
+ spice_marshall_msg_inputs_init(m, &inputs_init);
+ break;
+ }
+ case PIPE_ITEM_MOUSE_MOTION_ACK:
+ red_channel_client_init_send_data(rcc, SPICE_MSG_INPUTS_MOUSE_MOTION_ACK, base);
+ break;
+ case PIPE_ITEM_MIGRATE_DATA:
+ inputs_channel_send_migrate_data(rcc, m, base);
+ break;
+ default:
+ spice_warning("invalid pipe iten %d", base->type);
+ break;
+ }
+ red_channel_client_begin_send_message(rcc);
+}
+
+static int inputs_channel_handle_parsed(RedChannelClient *rcc, uint32_t size, uint16_t type,
+ void *message)
+{
+ InputsChannel *inputs_channel = (InputsChannel *)rcc->channel;
+ InputsChannelClient *icc = (InputsChannelClient *)rcc;
+ uint32_t i;
+
+ spice_assert(g_inputs_channel == inputs_channel);
+ switch (type) {
+ case SPICE_MSGC_INPUTS_KEY_DOWN: {
+ SpiceMsgcKeyDown *key_down = message;
+ if (key_down->code == CAPS_LOCK_SCAN_CODE ||
+ key_down->code == NUM_LOCK_SCAN_CODE ||
+ key_down->code == SCROLL_LOCK_SCAN_CODE) {
+ activate_modifiers_watch();
+ }
+ }
+ case SPICE_MSGC_INPUTS_KEY_UP: {
+ SpiceMsgcKeyUp *key_up = message;
+ for (i = 0; i < 4; i++) {
+ uint8_t code = (key_up->code >> (i * 8)) & 0xff;
+ if (code == 0) {
+ break;
+ }
+ kbd_push_scan(keyboard, code);
+ }
+ break;
+ }
+ case SPICE_MSGC_INPUTS_KEY_SCANCODE: {
+ uint8_t *code = message;
+ for (i = 0; i < size; i++) {
+ kbd_push_scan(keyboard, code[i]);
+ }
+ break;
+ }
+ case SPICE_MSGC_INPUTS_MOUSE_MOTION: {
+ SpiceMsgcMouseMotion *mouse_motion = message;
+
+ if (++icc->motion_count % SPICE_INPUT_MOTION_ACK_BUNCH == 0 &&
+ !g_inputs_channel->src_during_migrate) {
+ red_channel_client_pipe_add_type(rcc, PIPE_ITEM_MOUSE_MOTION_ACK);
+ icc->motion_count = 0;
+ }
+ if (mouse && reds_get_mouse_mode() == SPICE_MOUSE_MODE_SERVER) {
+ SpiceMouseInterface *sif;
+ sif = SPICE_CONTAINEROF(mouse->base.sif, SpiceMouseInterface, base);
+ sif->motion(mouse,
+ mouse_motion->dx, mouse_motion->dy, 0,
+ RED_MOUSE_STATE_TO_LOCAL(mouse_motion->buttons_state));
+ }
+ break;
+ }
+ case SPICE_MSGC_INPUTS_MOUSE_POSITION: {
+ SpiceMsgcMousePosition *pos = message;
+
+ if (++icc->motion_count % SPICE_INPUT_MOTION_ACK_BUNCH == 0 &&
+ !g_inputs_channel->src_during_migrate) {
+ red_channel_client_pipe_add_type(rcc, PIPE_ITEM_MOUSE_MOTION_ACK);
+ icc->motion_count = 0;
+ }
+ if (reds_get_mouse_mode() != SPICE_MOUSE_MODE_CLIENT) {
+ break;
+ }
+ spice_assert((reds_get_agent_mouse() && reds_has_vdagent()) || tablet);
+ if (!reds_get_agent_mouse() || !reds_has_vdagent()) {
+ SpiceTabletInterface *sif;
+ sif = SPICE_CONTAINEROF(tablet->base.sif, SpiceTabletInterface, base);
+ sif->position(tablet, pos->x, pos->y, RED_MOUSE_STATE_TO_LOCAL(pos->buttons_state));
+ break;
+ }
+ VDAgentMouseState *mouse_state = &inputs_channel->mouse_state;
+ mouse_state->x = pos->x;
+ mouse_state->y = pos->y;
+ mouse_state->buttons = RED_MOUSE_BUTTON_STATE_TO_AGENT(pos->buttons_state);
+ mouse_state->display_id = pos->display_id;
+ reds_handle_agent_mouse_event(mouse_state);
+ break;
+ }
+ case SPICE_MSGC_INPUTS_MOUSE_PRESS: {
+ SpiceMsgcMousePress *mouse_press = message;
+ int dz = 0;
+ if (mouse_press->button == SPICE_MOUSE_BUTTON_UP) {
+ dz = -1;
+ } else if (mouse_press->button == SPICE_MOUSE_BUTTON_DOWN) {
+ dz = 1;
+ }
+ if (reds_get_mouse_mode() == SPICE_MOUSE_MODE_CLIENT) {
+ if (reds_get_agent_mouse() && reds_has_vdagent()) {
+ inputs_channel->mouse_state.buttons =
+ RED_MOUSE_BUTTON_STATE_TO_AGENT(mouse_press->buttons_state) |
+ (dz == -1 ? VD_AGENT_UBUTTON_MASK : 0) |
+ (dz == 1 ? VD_AGENT_DBUTTON_MASK : 0);
+ reds_handle_agent_mouse_event(&inputs_channel->mouse_state);
+ } else if (tablet) {
+ SpiceTabletInterface *sif;
+ sif = SPICE_CONTAINEROF(tablet->base.sif, SpiceTabletInterface, base);
+ sif->wheel(tablet, dz, RED_MOUSE_STATE_TO_LOCAL(mouse_press->buttons_state));
+ }
+ } else if (mouse) {
+ SpiceMouseInterface *sif;
+ sif = SPICE_CONTAINEROF(mouse->base.sif, SpiceMouseInterface, base);
+ sif->motion(mouse, 0, 0, dz,
+ RED_MOUSE_STATE_TO_LOCAL(mouse_press->buttons_state));
+ }
+ break;
+ }
+ case SPICE_MSGC_INPUTS_MOUSE_RELEASE: {
+ SpiceMsgcMouseRelease *mouse_release = message;
+ if (reds_get_mouse_mode() == SPICE_MOUSE_MODE_CLIENT) {
+ if (reds_get_agent_mouse() && reds_has_vdagent()) {
+ inputs_channel->mouse_state.buttons =
+ RED_MOUSE_BUTTON_STATE_TO_AGENT(mouse_release->buttons_state);
+ reds_handle_agent_mouse_event(&inputs_channel->mouse_state);
+ } else if (tablet) {
+ SpiceTabletInterface *sif;
+ sif = SPICE_CONTAINEROF(tablet->base.sif, SpiceTabletInterface, base);
+ sif->buttons(tablet, RED_MOUSE_STATE_TO_LOCAL(mouse_release->buttons_state));
+ }
+ } else if (mouse) {
+ SpiceMouseInterface *sif;
+ sif = SPICE_CONTAINEROF(mouse->base.sif, SpiceMouseInterface, base);
+ sif->buttons(mouse,
+ RED_MOUSE_STATE_TO_LOCAL(mouse_release->buttons_state));
+ }
+ break;
+ }
+ case SPICE_MSGC_INPUTS_KEY_MODIFIERS: {
+ SpiceMsgcKeyModifiers *modifiers = message;
+ uint8_t leds;
+
+ if (!keyboard) {
+ break;
+ }
+ leds = kbd_get_leds(keyboard);
+ if ((modifiers->modifiers & SPICE_KEYBOARD_MODIFIER_FLAGS_SCROLL_LOCK) !=
+ (leds & SPICE_KEYBOARD_MODIFIER_FLAGS_SCROLL_LOCK)) {
+ kbd_push_scan(keyboard, SCROLL_LOCK_SCAN_CODE);
+ kbd_push_scan(keyboard, SCROLL_LOCK_SCAN_CODE | 0x80);
+ }
+ if ((modifiers->modifiers & SPICE_KEYBOARD_MODIFIER_FLAGS_NUM_LOCK) !=
+ (leds & SPICE_KEYBOARD_MODIFIER_FLAGS_NUM_LOCK)) {
+ kbd_push_scan(keyboard, NUM_LOCK_SCAN_CODE);
+ kbd_push_scan(keyboard, NUM_LOCK_SCAN_CODE | 0x80);
+ }
+ if ((modifiers->modifiers & SPICE_KEYBOARD_MODIFIER_FLAGS_CAPS_LOCK) !=
+ (leds & SPICE_KEYBOARD_MODIFIER_FLAGS_CAPS_LOCK)) {
+ kbd_push_scan(keyboard, CAPS_LOCK_SCAN_CODE);
+ kbd_push_scan(keyboard, CAPS_LOCK_SCAN_CODE | 0x80);
+ }
+ activate_modifiers_watch();
+ break;
+ }
+ case SPICE_MSGC_DISCONNECTING:
+ break;
+ default:
+ return red_channel_client_handle_message(rcc, size, type, message);
+ }
+ return TRUE;
+}
+
+static void inputs_release_keys(void)
+{
+ int i;
+ SpiceKbdState *st;
+
+ if (!keyboard) {
+ return;
+ }
+ st = keyboard->st;
+
+ for (i = 0; i < SPICE_N_ELEMENTS(st->key); i++) {
+ if (!st->key[i])
+ continue;
+
+ st->key[i] = FALSE;
+ kbd_push_scan(keyboard, i | 0x80);
+ }
+
+ for (i = 0; i < SPICE_N_ELEMENTS(st->key_ext); i++) {
+ if (!st->key_ext[i])
+ continue;
+
+ st->key_ext[i] = FALSE;
+ kbd_push_scan(keyboard, 0xe0);
+ kbd_push_scan(keyboard, i | 0x80);
+ }
+}
+
+static void inputs_channel_on_disconnect(RedChannelClient *rcc)
+{
+ if (!rcc) {
+ return;
+ }
+ inputs_release_keys();
+}
+
+static void inputs_pipe_add_init(RedChannelClient *rcc)
+{
+ InputsInitPipeItem *item = spice_malloc(sizeof(InputsInitPipeItem));
+
+ red_channel_pipe_item_init(rcc->channel, &item->base,
+ PIPE_ITEM_INPUTS_INIT);
+ item->modifiers = kbd_get_leds(keyboard);
+ red_channel_client_pipe_add_push(rcc, &item->base);
+}
+
+static int inputs_channel_config_socket(RedChannelClient *rcc)
+{
+ int delay_val = 1;
+ RedsStream *stream = red_channel_client_get_stream(rcc);
+
+ if (setsockopt(stream->socket, IPPROTO_TCP, TCP_NODELAY,
+ &delay_val, sizeof(delay_val)) == -1) {
+ if (errno != ENOTSUP && errno != ENOPROTOOPT) {
+ spice_printerr("setsockopt failed, %s", strerror(errno));
+ return FALSE;
+ }
+ }
+
+ return TRUE;
+}
+
+static void inputs_channel_hold_pipe_item(RedChannelClient *rcc, PipeItem *item)
+{
+}
+
+static void inputs_connect(RedChannel *channel, RedClient *client,
+ RedsStream *stream, int migration,
+ int num_common_caps, uint32_t *common_caps,
+ int num_caps, uint32_t *caps)
+{
+ InputsChannelClient *icc;
+
+ spice_assert(g_inputs_channel);
+ spice_assert(channel == &g_inputs_channel->base);
+
+ if (!reds_stream_is_ssl(stream) && !red_client_during_migrate_at_target(client)) {
+ main_channel_client_push_notify(red_client_get_main(client),
+ "keyboard channel is insecure");
+ }
+
+ spice_printerr("inputs channel client create");
+ icc = (InputsChannelClient*)red_channel_client_create(sizeof(InputsChannelClient),
+ channel,
+ client,
+ stream,
+ FALSE,
+ num_common_caps, common_caps,
+ num_caps, caps);
+ if (!icc) {
+ return;
+ }
+ icc->motion_count = 0;
+ inputs_pipe_add_init(&icc->base);
+}
+
+static void inputs_migrate(RedChannelClient *rcc)
+{
+ g_inputs_channel->src_during_migrate = TRUE;
+ red_channel_client_default_migrate(rcc);
+}
+
+static void inputs_push_keyboard_modifiers(uint8_t modifiers)
+{
+ if (!g_inputs_channel || !red_channel_is_connected(&g_inputs_channel->base) ||
+ g_inputs_channel->src_during_migrate) {
+ return;
+ }
+ red_channel_pipes_new_add_push(&g_inputs_channel->base,
+ inputs_key_modifiers_item_new, (void*)&modifiers);
+}
+
+void inputs_on_keyboard_leds_change(void *opaque, uint8_t leds)
+{
+ inputs_push_keyboard_modifiers(leds);
+}
+
+static void key_modifiers_sender(void *opaque)
+{
+ inputs_push_keyboard_modifiers(kbd_get_leds(keyboard));
+}
+
+static int inputs_channel_handle_migrate_flush_mark(RedChannelClient *rcc)
+{
+ red_channel_client_pipe_add_type(rcc, PIPE_ITEM_MIGRATE_DATA);
+ return TRUE;
+}
+
+static int inputs_channel_handle_migrate_data(RedChannelClient *rcc,
+ uint32_t size,
+ void *message)
+{
+ InputsChannelClient *icc = SPICE_CONTAINEROF(rcc, InputsChannelClient, base);
+ SpiceMigrateDataHeader *header;
+ SpiceMigrateDataInputs *mig_data;
+
+ header = (SpiceMigrateDataHeader *)message;
+ mig_data = (SpiceMigrateDataInputs *)(header + 1);
+
+ if (!migration_protocol_validate_header(header,
+ SPICE_MIGRATE_DATA_INPUTS_MAGIC,
+ SPICE_MIGRATE_DATA_INPUTS_VERSION)) {
+ spice_error("bad header");
+ return FALSE;
+ }
+ key_modifiers_sender(NULL);
+ icc->motion_count = mig_data->motion_count;
+
+ for (; icc->motion_count >= SPICE_INPUT_MOTION_ACK_BUNCH;
+ icc->motion_count -= SPICE_INPUT_MOTION_ACK_BUNCH) {
+ red_channel_client_pipe_add_type(rcc, PIPE_ITEM_MOUSE_MOTION_ACK);
+ }
+ return TRUE;
+}
+
+void inputs_init(void)
+{
+ ChannelCbs channel_cbs = { NULL, };
+ ClientCbs client_cbs = { NULL, };
+
+ spice_assert(!g_inputs_channel);
+
+ channel_cbs.config_socket = inputs_channel_config_socket;
+ channel_cbs.on_disconnect = inputs_channel_on_disconnect;
+ channel_cbs.send_item = inputs_channel_send_item;
+ channel_cbs.hold_item = inputs_channel_hold_pipe_item;
+ channel_cbs.release_item = inputs_channel_release_pipe_item;
+ channel_cbs.alloc_recv_buf = inputs_channel_alloc_msg_rcv_buf;
+ channel_cbs.release_recv_buf = inputs_channel_release_msg_rcv_buf;
+ channel_cbs.handle_migrate_data = inputs_channel_handle_migrate_data;
+ channel_cbs.handle_migrate_flush_mark = inputs_channel_handle_migrate_flush_mark;
+
+ g_inputs_channel = (InputsChannel *)red_channel_create_parser(
+ sizeof(InputsChannel),
+ core,
+ SPICE_CHANNEL_INPUTS, 0,
+ FALSE, /* handle_acks */
+ spice_get_client_channel_parser(SPICE_CHANNEL_INPUTS, NULL),
+ inputs_channel_handle_parsed,
+ &channel_cbs,
+ SPICE_MIGRATE_NEED_FLUSH | SPICE_MIGRATE_NEED_DATA_TRANSFER);
+
+ if (!g_inputs_channel) {
+ spice_error("failed to allocate Inputs Channel");
+ }
+
+ client_cbs.connect = inputs_connect;
+ client_cbs.migrate = inputs_migrate;
+ red_channel_register_client_cbs(&g_inputs_channel->base, &client_cbs);
+
+ red_channel_set_cap(&g_inputs_channel->base, SPICE_INPUTS_CAP_KEY_SCANCODE);
+ reds_register_channel(&g_inputs_channel->base);
+
+ if (!(key_modifiers_timer = core->timer_add(key_modifiers_sender, NULL))) {
+ spice_error("key modifiers timer create failed");
+ }
+}
diff --git a/server/inputs-channel.h b/server/inputs-channel.h
new file mode 100644
index 0000000..7f7ace0
--- /dev/null
+++ b/server/inputs-channel.h
@@ -0,0 +1,38 @@
+/*
+ Copyright (C) 2009 Red Hat, Inc.
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _INPUTS_CHANNEL_H_
+#define _INPUTS_CHANNEL_H_
+
+// Inputs channel, dealing with keyboard, mouse, tablet.
+// This include should only be used by reds.c and inputs-channel.c
+
+#include <stdint.h>
+#include <spice/vd_agent.h>
+
+void inputs_init(void);
+int inputs_inited(void);
+int inputs_has_tablet(void);
+const VDAgentMouseState *inputs_get_mouse_state(void);
+void inputs_on_keyboard_leds_change(void *opaque, uint8_t leds);
+int inputs_set_keyboard(SpiceKbdInstance *_keyboard);
+int inputs_set_mouse(SpiceMouseInstance *_mouse);
+int inputs_set_tablet(SpiceTabletInstance *_tablet);
+void inputs_detach_tablet(SpiceTabletInstance *_tablet);
+void inputs_set_tablet_logical_size(int x_res, int y_res);
+
+#endif
diff --git a/server/inputs_channel.c b/server/inputs_channel.c
deleted file mode 100644
index 2934572..0000000
--- a/server/inputs_channel.c
+++ /dev/null
@@ -1,679 +0,0 @@
-/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- Copyright (C) 2009 Red Hat, Inc.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, see <http://www.gnu.org/licenses/>.
-*/
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#include <netinet/in.h> // IPPROTO_TCP
-#include <netinet/tcp.h> // TCP_NODELAY
-#include <fcntl.h>
-#include <stddef.h> // NULL
-#include <errno.h>
-#include <spice/macros.h>
-#include <spice/vd_agent.h>
-#include <spice/protocol.h>
-#include <stdbool.h>
-
-#include "common/marshaller.h"
-#include "common/messages.h"
-#include "common/generated_server_marshallers.h"
-
-#include "demarshallers.h"
-#include "spice.h"
-#include "red_common.h"
-#include "reds.h"
-#include "reds_stream.h"
-#include "red_channel.h"
-#include "main_channel.h"
-#include "inputs_channel.h"
-#include "migration_protocol.h"
-
-// TODO: RECEIVE_BUF_SIZE used to be the same for inputs_channel and main_channel
-// since it was defined once in reds.c which contained both.
-// Now that they are split we can give a more fitting value for inputs - what
-// should it be?
-#define REDS_AGENT_WINDOW_SIZE 10
-#define REDS_NUM_INTERNAL_AGENT_MESSAGES 1
-
-// approximate max receive message size
-#define RECEIVE_BUF_SIZE \
- (4096 + (REDS_AGENT_WINDOW_SIZE + REDS_NUM_INTERNAL_AGENT_MESSAGES) * SPICE_AGENT_MAX_DATA_SIZE)
-
-struct SpiceKbdState {
- bool push_ext;
-
- /* track key press state */
- bool key[0x7f];
- bool key_ext[0x7f];
-};
-
-struct SpiceMouseState {
- int dummy;
-};
-
-struct SpiceTabletState {
- int dummy;
-};
-
-typedef struct InputsChannelClient {
- RedChannelClient base;
- uint16_t motion_count;
-} InputsChannelClient;
-
-typedef struct InputsChannel {
- RedChannel base;
- uint8_t recv_buf[RECEIVE_BUF_SIZE];
- VDAgentMouseState mouse_state;
- int src_during_migrate;
-} InputsChannel;
-
-enum {
- PIPE_ITEM_INPUTS_INIT = PIPE_ITEM_TYPE_CHANNEL_BASE,
- PIPE_ITEM_MOUSE_MOTION_ACK,
- PIPE_ITEM_KEY_MODIFIERS,
- PIPE_ITEM_MIGRATE_DATA,
-};
-
-typedef struct InputsPipeItem {
- PipeItem base;
-} InputsPipeItem;
-
-typedef struct KeyModifiersPipeItem {
- PipeItem base;
- uint8_t modifiers;
-} KeyModifiersPipeItem;
-
-typedef struct InputsInitPipeItem {
- PipeItem base;
- uint8_t modifiers;
-} InputsInitPipeItem;
-
-static SpiceKbdInstance *keyboard = NULL;
-static SpiceMouseInstance *mouse = NULL;
-static SpiceTabletInstance *tablet = NULL;
-
-static SpiceTimer *key_modifiers_timer;
-
-static InputsChannel *g_inputs_channel = NULL;
-
-#define KEY_MODIFIERS_TTL (1000 * 2) /*2sec*/
-
-#define SCROLL_LOCK_SCAN_CODE 0x46
-#define NUM_LOCK_SCAN_CODE 0x45
-#define CAPS_LOCK_SCAN_CODE 0x3a
-
-int inputs_inited(void)
-{
- return !!g_inputs_channel;
-}
-
-int inputs_set_keyboard(SpiceKbdInstance *_keyboard)
-{
- if (keyboard) {
- spice_printerr("already have keyboard");
- return -1;
- }
- keyboard = _keyboard;
- keyboard->st = spice_new0(SpiceKbdState, 1);
- return 0;
-}
-
-int inputs_set_mouse(SpiceMouseInstance *_mouse)
-{
- if (mouse) {
- spice_printerr("already have mouse");
- return -1;
- }
- mouse = _mouse;
- mouse->st = spice_new0(SpiceMouseState, 1);
- return 0;
-}
-
-int inputs_set_tablet(SpiceTabletInstance *_tablet)
-{
- if (tablet) {
- spice_printerr("already have tablet");
- return -1;
- }
- tablet = _tablet;
- tablet->st = spice_new0(SpiceTabletState, 1);
- return 0;
-}
-
-int inputs_has_tablet(void)
-{
- return !!tablet;
-}
-
-void inputs_detach_tablet(SpiceTabletInstance *_tablet)
-{
- spice_printerr("");
- tablet = NULL;
-}
-
-void inputs_set_tablet_logical_size(int x_res, int y_res)
-{
- SpiceTabletInterface *sif;
-
- sif = SPICE_CONTAINEROF(tablet->base.sif, SpiceTabletInterface, base);
- sif->set_logical_size(tablet, x_res, y_res);
-}
-
-const VDAgentMouseState *inputs_get_mouse_state(void)
-{
- spice_assert(g_inputs_channel);
- return &g_inputs_channel->mouse_state;
-}
-
-static uint8_t *inputs_channel_alloc_msg_rcv_buf(RedChannelClient *rcc,
- uint16_t type,
- uint32_t size)
-{
- InputsChannel *inputs_channel = SPICE_CONTAINEROF(rcc->channel, InputsChannel, base);
-
- if (size > RECEIVE_BUF_SIZE) {
- spice_printerr("error: too large incoming message");
- return NULL;
- }
- return inputs_channel->recv_buf;
-}
-
-static void inputs_channel_release_msg_rcv_buf(RedChannelClient *rcc,
- uint16_t type,
- uint32_t size,
- uint8_t *msg)
-{
-}
-
-#define OUTGOING_OK 0
-#define OUTGOING_FAILED -1
-#define OUTGOING_BLOCKED 1
-
-#define RED_MOUSE_STATE_TO_LOCAL(state) \
- ((state & SPICE_MOUSE_BUTTON_MASK_LEFT) | \
- ((state & SPICE_MOUSE_BUTTON_MASK_MIDDLE) << 1) | \
- ((state & SPICE_MOUSE_BUTTON_MASK_RIGHT) >> 1))
-
-#define RED_MOUSE_BUTTON_STATE_TO_AGENT(state) \
- (((state & SPICE_MOUSE_BUTTON_MASK_LEFT) ? VD_AGENT_LBUTTON_MASK : 0) | \
- ((state & SPICE_MOUSE_BUTTON_MASK_MIDDLE) ? VD_AGENT_MBUTTON_MASK : 0) | \
- ((state & SPICE_MOUSE_BUTTON_MASK_RIGHT) ? VD_AGENT_RBUTTON_MASK : 0))
-
-static void activate_modifiers_watch(void)
-{
- core->timer_start(key_modifiers_timer, KEY_MODIFIERS_TTL);
-}
-
-static void kbd_push_scan(SpiceKbdInstance *sin, uint8_t scan)
-{
- SpiceKbdInterface *sif;
-
- if (!sin) {
- return;
- }
- sif = SPICE_CONTAINEROF(sin->base.sif, SpiceKbdInterface, base);
-
- /* track XT scan code set 1 key state */
- if (scan == 0xe0) {
- sin->st->push_ext = TRUE;
- } else {
- bool *state = sin->st->push_ext ? sin->st->key : sin->st->key_ext;
- sin->st->push_ext = FALSE;
- state[scan & 0x7f] = !(scan & 0x80);
- }
-
- sif->push_scan_freg(sin, scan);
-}
-
-static uint8_t kbd_get_leds(SpiceKbdInstance *sin)
-{
- SpiceKbdInterface *sif;
-
- if (!sin) {
- return 0;
- }
- sif = SPICE_CONTAINEROF(sin->base.sif, SpiceKbdInterface, base);
- return sif->get_leds(sin);
-}
-
-static PipeItem *inputs_key_modifiers_item_new(
- RedChannelClient *rcc, void *data, int num)
-{
- KeyModifiersPipeItem *item = spice_malloc(sizeof(KeyModifiersPipeItem));
-
- red_channel_pipe_item_init(rcc->channel, &item->base,
- PIPE_ITEM_KEY_MODIFIERS);
- item->modifiers = *(uint8_t *)data;
- return &item->base;
-}
-
-static void inputs_channel_send_migrate_data(RedChannelClient *rcc,
- SpiceMarshaller *m,
- PipeItem *item)
-{
- InputsChannelClient *icc = SPICE_CONTAINEROF(rcc, InputsChannelClient, base);
-
- g_inputs_channel->src_during_migrate = FALSE;
- red_channel_client_init_send_data(rcc, SPICE_MSG_MIGRATE_DATA, item);
-
- spice_marshaller_add_uint32(m, SPICE_MIGRATE_DATA_INPUTS_MAGIC);
- spice_marshaller_add_uint32(m, SPICE_MIGRATE_DATA_INPUTS_VERSION);
- spice_marshaller_add_uint16(m, icc->motion_count);
-}
-
-static void inputs_channel_release_pipe_item(RedChannelClient *rcc,
- PipeItem *base, int item_pushed)
-{
- free(base);
-}
-
-static void inputs_channel_send_item(RedChannelClient *rcc, PipeItem *base)
-{
- SpiceMarshaller *m = red_channel_client_get_marshaller(rcc);
-
- switch (base->type) {
- case PIPE_ITEM_KEY_MODIFIERS:
- {
- SpiceMsgInputsKeyModifiers key_modifiers;
-
- red_channel_client_init_send_data(rcc, SPICE_MSG_INPUTS_KEY_MODIFIERS, base);
- key_modifiers.modifiers =
- SPICE_CONTAINEROF(base, KeyModifiersPipeItem, base)->modifiers;
- spice_marshall_msg_inputs_key_modifiers(m, &key_modifiers);
- break;
- }
- case PIPE_ITEM_INPUTS_INIT:
- {
- SpiceMsgInputsInit inputs_init;
-
- red_channel_client_init_send_data(rcc, SPICE_MSG_INPUTS_INIT, base);
- inputs_init.keyboard_modifiers =
- SPICE_CONTAINEROF(base, InputsInitPipeItem, base)->modifiers;
- spice_marshall_msg_inputs_init(m, &inputs_init);
- break;
- }
- case PIPE_ITEM_MOUSE_MOTION_ACK:
- red_channel_client_init_send_data(rcc, SPICE_MSG_INPUTS_MOUSE_MOTION_ACK, base);
- break;
- case PIPE_ITEM_MIGRATE_DATA:
- inputs_channel_send_migrate_data(rcc, m, base);
- break;
- default:
- spice_warning("invalid pipe iten %d", base->type);
- break;
- }
- red_channel_client_begin_send_message(rcc);
-}
-
-static int inputs_channel_handle_parsed(RedChannelClient *rcc, uint32_t size, uint16_t type,
- void *message)
-{
- InputsChannel *inputs_channel = (InputsChannel *)rcc->channel;
- InputsChannelClient *icc = (InputsChannelClient *)rcc;
- uint32_t i;
-
- spice_assert(g_inputs_channel == inputs_channel);
- switch (type) {
- case SPICE_MSGC_INPUTS_KEY_DOWN: {
- SpiceMsgcKeyDown *key_down = message;
- if (key_down->code == CAPS_LOCK_SCAN_CODE ||
- key_down->code == NUM_LOCK_SCAN_CODE ||
- key_down->code == SCROLL_LOCK_SCAN_CODE) {
- activate_modifiers_watch();
- }
- }
- case SPICE_MSGC_INPUTS_KEY_UP: {
- SpiceMsgcKeyUp *key_up = message;
- for (i = 0; i < 4; i++) {
- uint8_t code = (key_up->code >> (i * 8)) & 0xff;
- if (code == 0) {
- break;
- }
- kbd_push_scan(keyboard, code);
- }
- break;
- }
- case SPICE_MSGC_INPUTS_KEY_SCANCODE: {
- uint8_t *code = message;
- for (i = 0; i < size; i++) {
- kbd_push_scan(keyboard, code[i]);
- }
- break;
- }
- case SPICE_MSGC_INPUTS_MOUSE_MOTION: {
- SpiceMsgcMouseMotion *mouse_motion = message;
-
- if (++icc->motion_count % SPICE_INPUT_MOTION_ACK_BUNCH == 0 &&
- !g_inputs_channel->src_during_migrate) {
- red_channel_client_pipe_add_type(rcc, PIPE_ITEM_MOUSE_MOTION_ACK);
- icc->motion_count = 0;
- }
- if (mouse && reds_get_mouse_mode() == SPICE_MOUSE_MODE_SERVER) {
- SpiceMouseInterface *sif;
- sif = SPICE_CONTAINEROF(mouse->base.sif, SpiceMouseInterface, base);
- sif->motion(mouse,
- mouse_motion->dx, mouse_motion->dy, 0,
- RED_MOUSE_STATE_TO_LOCAL(mouse_motion->buttons_state));
- }
- break;
- }
- case SPICE_MSGC_INPUTS_MOUSE_POSITION: {
- SpiceMsgcMousePosition *pos = message;
-
- if (++icc->motion_count % SPICE_INPUT_MOTION_ACK_BUNCH == 0 &&
- !g_inputs_channel->src_during_migrate) {
- red_channel_client_pipe_add_type(rcc, PIPE_ITEM_MOUSE_MOTION_ACK);
- icc->motion_count = 0;
- }
- if (reds_get_mouse_mode() != SPICE_MOUSE_MODE_CLIENT) {
- break;
- }
- spice_assert((reds_get_agent_mouse() && reds_has_vdagent()) || tablet);
- if (!reds_get_agent_mouse() || !reds_has_vdagent()) {
- SpiceTabletInterface *sif;
- sif = SPICE_CONTAINEROF(tablet->base.sif, SpiceTabletInterface, base);
- sif->position(tablet, pos->x, pos->y, RED_MOUSE_STATE_TO_LOCAL(pos->buttons_state));
- break;
- }
- VDAgentMouseState *mouse_state = &inputs_channel->mouse_state;
- mouse_state->x = pos->x;
- mouse_state->y = pos->y;
- mouse_state->buttons = RED_MOUSE_BUTTON_STATE_TO_AGENT(pos->buttons_state);
- mouse_state->display_id = pos->display_id;
- reds_handle_agent_mouse_event(mouse_state);
- break;
- }
- case SPICE_MSGC_INPUTS_MOUSE_PRESS: {
- SpiceMsgcMousePress *mouse_press = message;
- int dz = 0;
- if (mouse_press->button == SPICE_MOUSE_BUTTON_UP) {
- dz = -1;
- } else if (mouse_press->button == SPICE_MOUSE_BUTTON_DOWN) {
- dz = 1;
- }
- if (reds_get_mouse_mode() == SPICE_MOUSE_MODE_CLIENT) {
- if (reds_get_agent_mouse() && reds_has_vdagent()) {
- inputs_channel->mouse_state.buttons =
- RED_MOUSE_BUTTON_STATE_TO_AGENT(mouse_press->buttons_state) |
- (dz == -1 ? VD_AGENT_UBUTTON_MASK : 0) |
- (dz == 1 ? VD_AGENT_DBUTTON_MASK : 0);
- reds_handle_agent_mouse_event(&inputs_channel->mouse_state);
- } else if (tablet) {
- SpiceTabletInterface *sif;
- sif = SPICE_CONTAINEROF(tablet->base.sif, SpiceTabletInterface, base);
- sif->wheel(tablet, dz, RED_MOUSE_STATE_TO_LOCAL(mouse_press->buttons_state));
- }
- } else if (mouse) {
- SpiceMouseInterface *sif;
- sif = SPICE_CONTAINEROF(mouse->base.sif, SpiceMouseInterface, base);
- sif->motion(mouse, 0, 0, dz,
- RED_MOUSE_STATE_TO_LOCAL(mouse_press->buttons_state));
- }
- break;
- }
- case SPICE_MSGC_INPUTS_MOUSE_RELEASE: {
- SpiceMsgcMouseRelease *mouse_release = message;
- if (reds_get_mouse_mode() == SPICE_MOUSE_MODE_CLIENT) {
- if (reds_get_agent_mouse() && reds_has_vdagent()) {
- inputs_channel->mouse_state.buttons =
- RED_MOUSE_BUTTON_STATE_TO_AGENT(mouse_release->buttons_state);
- reds_handle_agent_mouse_event(&inputs_channel->mouse_state);
- } else if (tablet) {
- SpiceTabletInterface *sif;
- sif = SPICE_CONTAINEROF(tablet->base.sif, SpiceTabletInterface, base);
- sif->buttons(tablet, RED_MOUSE_STATE_TO_LOCAL(mouse_release->buttons_state));
- }
- } else if (mouse) {
- SpiceMouseInterface *sif;
- sif = SPICE_CONTAINEROF(mouse->base.sif, SpiceMouseInterface, base);
- sif->buttons(mouse,
- RED_MOUSE_STATE_TO_LOCAL(mouse_release->buttons_state));
- }
- break;
- }
- case SPICE_MSGC_INPUTS_KEY_MODIFIERS: {
- SpiceMsgcKeyModifiers *modifiers = message;
- uint8_t leds;
-
- if (!keyboard) {
- break;
- }
- leds = kbd_get_leds(keyboard);
- if ((modifiers->modifiers & SPICE_KEYBOARD_MODIFIER_FLAGS_SCROLL_LOCK) !=
- (leds & SPICE_KEYBOARD_MODIFIER_FLAGS_SCROLL_LOCK)) {
- kbd_push_scan(keyboard, SCROLL_LOCK_SCAN_CODE);
- kbd_push_scan(keyboard, SCROLL_LOCK_SCAN_CODE | 0x80);
- }
- if ((modifiers->modifiers & SPICE_KEYBOARD_MODIFIER_FLAGS_NUM_LOCK) !=
- (leds & SPICE_KEYBOARD_MODIFIER_FLAGS_NUM_LOCK)) {
- kbd_push_scan(keyboard, NUM_LOCK_SCAN_CODE);
- kbd_push_scan(keyboard, NUM_LOCK_SCAN_CODE | 0x80);
- }
- if ((modifiers->modifiers & SPICE_KEYBOARD_MODIFIER_FLAGS_CAPS_LOCK) !=
- (leds & SPICE_KEYBOARD_MODIFIER_FLAGS_CAPS_LOCK)) {
- kbd_push_scan(keyboard, CAPS_LOCK_SCAN_CODE);
- kbd_push_scan(keyboard, CAPS_LOCK_SCAN_CODE | 0x80);
- }
- activate_modifiers_watch();
- break;
- }
- case SPICE_MSGC_DISCONNECTING:
- break;
- default:
- return red_channel_client_handle_message(rcc, size, type, message);
- }
- return TRUE;
-}
-
-static void inputs_release_keys(void)
-{
- int i;
- SpiceKbdState *st;
-
- if (!keyboard) {
- return;
- }
- st = keyboard->st;
-
- for (i = 0; i < SPICE_N_ELEMENTS(st->key); i++) {
- if (!st->key[i])
- continue;
-
- st->key[i] = FALSE;
- kbd_push_scan(keyboard, i | 0x80);
- }
-
- for (i = 0; i < SPICE_N_ELEMENTS(st->key_ext); i++) {
- if (!st->key_ext[i])
- continue;
-
- st->key_ext[i] = FALSE;
- kbd_push_scan(keyboard, 0xe0);
- kbd_push_scan(keyboard, i | 0x80);
- }
-}
-
-static void inputs_channel_on_disconnect(RedChannelClient *rcc)
-{
- if (!rcc) {
- return;
- }
- inputs_release_keys();
-}
-
-static void inputs_pipe_add_init(RedChannelClient *rcc)
-{
- InputsInitPipeItem *item = spice_malloc(sizeof(InputsInitPipeItem));
-
- red_channel_pipe_item_init(rcc->channel, &item->base,
- PIPE_ITEM_INPUTS_INIT);
- item->modifiers = kbd_get_leds(keyboard);
- red_channel_client_pipe_add_push(rcc, &item->base);
-}
-
-static int inputs_channel_config_socket(RedChannelClient *rcc)
-{
- int delay_val = 1;
- RedsStream *stream = red_channel_client_get_stream(rcc);
-
- if (setsockopt(stream->socket, IPPROTO_TCP, TCP_NODELAY,
- &delay_val, sizeof(delay_val)) == -1) {
- if (errno != ENOTSUP && errno != ENOPROTOOPT) {
- spice_printerr("setsockopt failed, %s", strerror(errno));
- return FALSE;
- }
- }
-
- return TRUE;
-}
-
-static void inputs_channel_hold_pipe_item(RedChannelClient *rcc, PipeItem *item)
-{
-}
-
-static void inputs_connect(RedChannel *channel, RedClient *client,
- RedsStream *stream, int migration,
- int num_common_caps, uint32_t *common_caps,
- int num_caps, uint32_t *caps)
-{
- InputsChannelClient *icc;
-
- spice_assert(g_inputs_channel);
- spice_assert(channel == &g_inputs_channel->base);
-
- if (!reds_stream_is_ssl(stream) && !red_client_during_migrate_at_target(client)) {
- main_channel_client_push_notify(red_client_get_main(client),
- "keyboard channel is insecure");
- }
-
- spice_printerr("inputs channel client create");
- icc = (InputsChannelClient*)red_channel_client_create(sizeof(InputsChannelClient),
- channel,
- client,
- stream,
- FALSE,
- num_common_caps, common_caps,
- num_caps, caps);
- if (!icc) {
- return;
- }
- icc->motion_count = 0;
- inputs_pipe_add_init(&icc->base);
-}
-
-static void inputs_migrate(RedChannelClient *rcc)
-{
- g_inputs_channel->src_during_migrate = TRUE;
- red_channel_client_default_migrate(rcc);
-}
-
-static void inputs_push_keyboard_modifiers(uint8_t modifiers)
-{
- if (!g_inputs_channel || !red_channel_is_connected(&g_inputs_channel->base) ||
- g_inputs_channel->src_during_migrate) {
- return;
- }
- red_channel_pipes_new_add_push(&g_inputs_channel->base,
- inputs_key_modifiers_item_new, (void*)&modifiers);
-}
-
-void inputs_on_keyboard_leds_change(void *opaque, uint8_t leds)
-{
- inputs_push_keyboard_modifiers(leds);
-}
-
-static void key_modifiers_sender(void *opaque)
-{
- inputs_push_keyboard_modifiers(kbd_get_leds(keyboard));
-}
-
-static int inputs_channel_handle_migrate_flush_mark(RedChannelClient *rcc)
-{
- red_channel_client_pipe_add_type(rcc, PIPE_ITEM_MIGRATE_DATA);
- return TRUE;
-}
-
-static int inputs_channel_handle_migrate_data(RedChannelClient *rcc,
- uint32_t size,
- void *message)
-{
- InputsChannelClient *icc = SPICE_CONTAINEROF(rcc, InputsChannelClient, base);
- SpiceMigrateDataHeader *header;
- SpiceMigrateDataInputs *mig_data;
-
- header = (SpiceMigrateDataHeader *)message;
- mig_data = (SpiceMigrateDataInputs *)(header + 1);
-
- if (!migration_protocol_validate_header(header,
- SPICE_MIGRATE_DATA_INPUTS_MAGIC,
- SPICE_MIGRATE_DATA_INPUTS_VERSION)) {
- spice_error("bad header");
- return FALSE;
- }
- key_modifiers_sender(NULL);
- icc->motion_count = mig_data->motion_count;
-
- for (; icc->motion_count >= SPICE_INPUT_MOTION_ACK_BUNCH;
- icc->motion_count -= SPICE_INPUT_MOTION_ACK_BUNCH) {
- red_channel_client_pipe_add_type(rcc, PIPE_ITEM_MOUSE_MOTION_ACK);
- }
- return TRUE;
-}
-
-void inputs_init(void)
-{
- ChannelCbs channel_cbs = { NULL, };
- ClientCbs client_cbs = { NULL, };
-
- spice_assert(!g_inputs_channel);
-
- channel_cbs.config_socket = inputs_channel_config_socket;
- channel_cbs.on_disconnect = inputs_channel_on_disconnect;
- channel_cbs.send_item = inputs_channel_send_item;
- channel_cbs.hold_item = inputs_channel_hold_pipe_item;
- channel_cbs.release_item = inputs_channel_release_pipe_item;
- channel_cbs.alloc_recv_buf = inputs_channel_alloc_msg_rcv_buf;
- channel_cbs.release_recv_buf = inputs_channel_release_msg_rcv_buf;
- channel_cbs.handle_migrate_data = inputs_channel_handle_migrate_data;
- channel_cbs.handle_migrate_flush_mark = inputs_channel_handle_migrate_flush_mark;
-
- g_inputs_channel = (InputsChannel *)red_channel_create_parser(
- sizeof(InputsChannel),
- core,
- SPICE_CHANNEL_INPUTS, 0,
- FALSE, /* handle_acks */
- spice_get_client_channel_parser(SPICE_CHANNEL_INPUTS, NULL),
- inputs_channel_handle_parsed,
- &channel_cbs,
- SPICE_MIGRATE_NEED_FLUSH | SPICE_MIGRATE_NEED_DATA_TRANSFER);
-
- if (!g_inputs_channel) {
- spice_error("failed to allocate Inputs Channel");
- }
-
- client_cbs.connect = inputs_connect;
- client_cbs.migrate = inputs_migrate;
- red_channel_register_client_cbs(&g_inputs_channel->base, &client_cbs);
-
- red_channel_set_cap(&g_inputs_channel->base, SPICE_INPUTS_CAP_KEY_SCANCODE);
- reds_register_channel(&g_inputs_channel->base);
-
- if (!(key_modifiers_timer = core->timer_add(key_modifiers_sender, NULL))) {
- spice_error("key modifiers timer create failed");
- }
-}
diff --git a/server/inputs_channel.h b/server/inputs_channel.h
deleted file mode 100644
index 672ca83..0000000
--- a/server/inputs_channel.h
+++ /dev/null
@@ -1,38 +0,0 @@
-/*
- Copyright (C) 2009 Red Hat, Inc.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, see <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _INPUTS_CHANNEL_H_
-#define _INPUTS_CHANNEL_H_
-
-// Inputs channel, dealing with keyboard, mouse, tablet.
-// This include should only be used by reds.c and inputs_channel.c
-
-#include <stdint.h>
-#include <spice/vd_agent.h>
-
-void inputs_init(void);
-int inputs_inited(void);
-int inputs_has_tablet(void);
-const VDAgentMouseState *inputs_get_mouse_state(void);
-void inputs_on_keyboard_leds_change(void *opaque, uint8_t leds);
-int inputs_set_keyboard(SpiceKbdInstance *_keyboard);
-int inputs_set_mouse(SpiceMouseInstance *_mouse);
-int inputs_set_tablet(SpiceTabletInstance *_tablet);
-void inputs_detach_tablet(SpiceTabletInstance *_tablet);
-void inputs_set_tablet_logical_size(int x_res, int y_res);
-
-#endif
diff --git a/server/jpeg-encoder.c b/server/jpeg-encoder.c
new file mode 100644
index 0000000..8e54dd2
--- /dev/null
+++ b/server/jpeg-encoder.c
@@ -0,0 +1,248 @@
+/*
+ Copyright (C) 2009 Red Hat, Inc.
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, see <http://www.gnu.org/licenses/>.
+*/
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "red_common.h"
+#include "jpeg-encoder.h"
+#include <jpeglib.h>
+
+typedef struct JpegEncoder {
+ JpegEncoderUsrContext *usr;
+
+ struct jpeg_destination_mgr dest_mgr;
+ struct jpeg_compress_struct cinfo;
+ struct jpeg_error_mgr jerr;
+
+ struct {
+ JpegEncoderImageType type;
+ int width;
+ int height;
+ int stride;
+ unsigned int out_size;
+ void (*convert_line_to_RGB24) (void *line, int width, uint8_t **out_line);
+ } cur_image;
+} JpegEncoder;
+
+/* jpeg destination manager callbacks */
+
+static void dest_mgr_init_destination(j_compress_ptr cinfo)
+{
+ JpegEncoder *enc = (JpegEncoder *)cinfo->client_data;
+ if (enc->dest_mgr.free_in_buffer == 0) {
+ enc->dest_mgr.free_in_buffer = enc->usr->more_space(enc->usr,
+ &enc->dest_mgr.next_output_byte);
+
+ if (enc->dest_mgr.free_in_buffer == 0) {
+ spice_error("not enough space");
+ }
+ }
+
+ enc->cur_image.out_size = enc->dest_mgr.free_in_buffer;
+}
+
+static boolean dest_mgr_empty_output_buffer(j_compress_ptr cinfo)
+{
+ JpegEncoder *enc = (JpegEncoder *)cinfo->client_data;
+ enc->dest_mgr.free_in_buffer = enc->usr->more_space(enc->usr,
+ &enc->dest_mgr.next_output_byte);
+
+ if (enc->dest_mgr.free_in_buffer == 0) {
+ spice_error("not enough space");
+ }
+ enc->cur_image.out_size += enc->dest_mgr.free_in_buffer;
+ return TRUE;
+}
+
+static void dest_mgr_term_destination(j_compress_ptr cinfo)
+{
+ JpegEncoder *enc = (JpegEncoder *)cinfo->client_data;
+ enc->cur_image.out_size -= enc->dest_mgr.free_in_buffer;
+}
+
+JpegEncoderContext* jpeg_encoder_create(JpegEncoderUsrContext *usr)
+{
+ JpegEncoder *enc;
+ if (!usr->more_space || !usr->more_lines) {
+ return NULL;
+ }
+
+ enc = spice_new0(JpegEncoder, 1);
+
+ enc->usr = usr;
+
+ enc->dest_mgr.init_destination = dest_mgr_init_destination;
+ enc->dest_mgr.empty_output_buffer = dest_mgr_empty_output_buffer;
+ enc->dest_mgr.term_destination = dest_mgr_term_destination;
+
+ enc->cinfo.err = jpeg_std_error(&enc->jerr);
+
+ jpeg_create_compress(&enc->cinfo);
+ enc->cinfo.client_data = enc;
+ enc->cinfo.dest = &enc->dest_mgr;
+ return (JpegEncoderContext*)enc;
+}
+
+void jpeg_encoder_destroy(JpegEncoderContext* encoder)
+{
+ jpeg_destroy_compress(&((JpegEncoder*)encoder)->cinfo);
+ free(encoder);
+}
+
+static void convert_RGB16_to_RGB24(void *line, int width, uint8_t **out_line)
+{
+ uint16_t *src_line = line;
+ uint8_t *out_pix;
+ int x;
+
+ spice_assert(out_line && *out_line);
+
+ out_pix = *out_line;
+
+ for (x = 0; x < width; x++) {
+ uint16_t pixel = *src_line++;
+ *out_pix++ = ((pixel >> 7) & 0xf8) | ((pixel >> 12) & 0x7);
+ *out_pix++ = ((pixel >> 2) & 0xf8) | ((pixel >> 7) & 0x7);
+ *out_pix++ = ((pixel << 3) & 0xf8) | ((pixel >> 2) & 0x7);
+ }
+}
+
+static void convert_BGR24_to_RGB24(void *in_line, int width, uint8_t **out_line)
+{
+ int x;
+ uint8_t *out_pix;
+ uint8_t *line = in_line;
+ spice_assert(out_line && *out_line);
+
+ out_pix = *out_line;
+
+ for (x = 0; x < width; x++) {
+ *out_pix++ = line[2];
+ *out_pix++ = line[1];
+ *out_pix++ = line[0];
+ line += 3;
+ }
+}
+
+static void convert_BGRX32_to_RGB24(void *line, int width, uint8_t **out_line)
+{
+ uint32_t *src_line = line;
+ uint8_t *out_pix;
+ int x;
+
+ spice_assert(out_line && *out_line);
+
+ out_pix = *out_line;
+
+ for (x = 0; x < width; x++) {
+ uint32_t pixel = *src_line++;
+ *out_pix++ = (pixel >> 16) & 0xff;
+ *out_pix++ = (pixel >> 8) & 0xff;
+ *out_pix++ = pixel & 0xff;
+ }
+}
+
+static void convert_RGB24_to_RGB24(void *line, int width, uint8_t **out_line)
+{
+ *out_line = line;
+}
+
+
+#define FILL_LINES() { \
+ if (lines == lines_end) { \
+ int n = jpeg->usr->more_lines(jpeg->usr, &lines); \
+ if (n <= 0) { \
+ spice_error("more lines failed"); \
+ } \
+ lines_end = lines + n * stride; \
+ } \
+}
+
+static void do_jpeg_encode(JpegEncoder *jpeg, uint8_t *lines, unsigned int num_lines)
+{
+ uint8_t *lines_end;
+ uint8_t *RGB24_line;
+ int stride, width;
+ JSAMPROW row_pointer[1];
+ width = jpeg->cur_image.width;
+ stride = jpeg->cur_image.stride;
+
+ if (jpeg->cur_image.type != JPEG_IMAGE_TYPE_RGB24) {
+ RGB24_line = (uint8_t *)spice_malloc(width*3);
+ }
+
+ lines_end = lines + (stride * num_lines);
+
+ for (;jpeg->cinfo.next_scanline < jpeg->cinfo.image_height; lines += stride) {
+ FILL_LINES();
+ jpeg->cur_image.convert_line_to_RGB24(lines, width, &RGB24_line);
+ row_pointer[0] = RGB24_line;
+ jpeg_write_scanlines(&jpeg->cinfo, row_pointer, 1);
+ }
+
+ if (jpeg->cur_image.type != JPEG_IMAGE_TYPE_RGB24) {
+ free(RGB24_line);
+ }
+}
+
+int jpeg_encode(JpegEncoderContext *jpeg, int quality, JpegEncoderImageType type,
+ int width, int height, uint8_t *lines, unsigned int num_lines, int stride,
+ uint8_t *io_ptr, unsigned int num_io_bytes)
+{
+ JpegEncoder *enc = (JpegEncoder *)jpeg;
+
+ enc->cur_image.type = type;
+ enc->cur_image.width = width;
+ enc->cur_image.height = height;
+ enc->cur_image.stride = stride;
+ enc->cur_image.out_size = 0;
+
+ switch (type) {
+ case JPEG_IMAGE_TYPE_RGB16:
+ enc->cur_image.convert_line_to_RGB24 = convert_RGB16_to_RGB24;
+ break;
+ case JPEG_IMAGE_TYPE_RGB24:
+ enc->cur_image.convert_line_to_RGB24 = convert_RGB24_to_RGB24;
+ break;
+ case JPEG_IMAGE_TYPE_BGR24:
+ enc->cur_image.convert_line_to_RGB24 = convert_BGR24_to_RGB24;
+ break;
+ case JPEG_IMAGE_TYPE_BGRX32:
+ enc->cur_image.convert_line_to_RGB24 = convert_BGRX32_to_RGB24;
+ break;
+ default:
+ spice_error("bad image type");
+ }
+
+ enc->cinfo.image_width = width;
+ enc->cinfo.image_height = height;
+ enc->cinfo.input_components = 3;
+ enc->cinfo.in_color_space = JCS_RGB;
+ jpeg_set_defaults(&enc->cinfo);
+ jpeg_set_quality(&enc->cinfo, quality, TRUE);
+
+ enc->dest_mgr.next_output_byte = io_ptr;
+ enc->dest_mgr.free_in_buffer = num_io_bytes;
+
+ jpeg_start_compress(&enc->cinfo, TRUE);
+
+ do_jpeg_encode(enc, lines, num_lines);
+
+ jpeg_finish_compress(&enc->cinfo);
+ return enc->cur_image.out_size;
+}
diff --git a/server/jpeg-encoder.h b/server/jpeg-encoder.h
new file mode 100644
index 0000000..690a029
--- /dev/null
+++ b/server/jpeg-encoder.h
@@ -0,0 +1,61 @@
+/*
+ Copyright (C) 2009 Red Hat, Inc.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are
+ met:
+
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in
+ the documentation and/or other materials provided with the
+ distribution.
+ * Neither the name of the copyright holder nor the names of its
+ contributors may be used to endorse or promote products derived
+ from this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS "AS
+ IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+#ifndef _H_JPEG_ENCODER
+#define _H_JPEG_ENCODER
+
+#include <spice/types.h>
+
+typedef enum {
+ JPEG_IMAGE_TYPE_INVALID,
+ JPEG_IMAGE_TYPE_RGB16,
+ /* in byte per color types, the notation is according to the order of the
+ colors in the memory */
+ JPEG_IMAGE_TYPE_RGB24,
+ JPEG_IMAGE_TYPE_BGR24,
+ JPEG_IMAGE_TYPE_BGRX32,
+} JpegEncoderImageType;
+
+typedef void* JpegEncoderContext;
+typedef struct JpegEncoderUsrContext JpegEncoderUsrContext;
+
+struct JpegEncoderUsrContext {
+ int (*more_space)(JpegEncoderUsrContext *usr, uint8_t **io_ptr);
+ int (*more_lines)(JpegEncoderUsrContext *usr, uint8_t **lines);
+};
+
+JpegEncoderContext* jpeg_encoder_create(JpegEncoderUsrContext *usr);
+void jpeg_encoder_destroy(JpegEncoderContext *encoder);
+
+/* returns the total size of the encoded data. Images must be supplied from the
+ top line to the bottom */
+int jpeg_encode(JpegEncoderContext *jpeg, int quality, JpegEncoderImageType type,
+ int width, int height, uint8_t *lines, unsigned int num_lines, int stride,
+ uint8_t *io_ptr, unsigned int num_io_bytes);
+#endif
diff --git a/server/jpeg_encoder.c b/server/jpeg_encoder.c
deleted file mode 100644
index 0296e9b..0000000
--- a/server/jpeg_encoder.c
+++ /dev/null
@@ -1,248 +0,0 @@
-/*
- Copyright (C) 2009 Red Hat, Inc.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, see <http://www.gnu.org/licenses/>.
-*/
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#include "red_common.h"
-#include "jpeg_encoder.h"
-#include <jpeglib.h>
-
-typedef struct JpegEncoder {
- JpegEncoderUsrContext *usr;
-
- struct jpeg_destination_mgr dest_mgr;
- struct jpeg_compress_struct cinfo;
- struct jpeg_error_mgr jerr;
-
- struct {
- JpegEncoderImageType type;
- int width;
- int height;
- int stride;
- unsigned int out_size;
- void (*convert_line_to_RGB24) (void *line, int width, uint8_t **out_line);
- } cur_image;
-} JpegEncoder;
-
-/* jpeg destination manager callbacks */
-
-static void dest_mgr_init_destination(j_compress_ptr cinfo)
-{
- JpegEncoder *enc = (JpegEncoder *)cinfo->client_data;
- if (enc->dest_mgr.free_in_buffer == 0) {
- enc->dest_mgr.free_in_buffer = enc->usr->more_space(enc->usr,
- &enc->dest_mgr.next_output_byte);
-
- if (enc->dest_mgr.free_in_buffer == 0) {
- spice_error("not enough space");
- }
- }
-
- enc->cur_image.out_size = enc->dest_mgr.free_in_buffer;
-}
-
-static boolean dest_mgr_empty_output_buffer(j_compress_ptr cinfo)
-{
- JpegEncoder *enc = (JpegEncoder *)cinfo->client_data;
- enc->dest_mgr.free_in_buffer = enc->usr->more_space(enc->usr,
- &enc->dest_mgr.next_output_byte);
-
- if (enc->dest_mgr.free_in_buffer == 0) {
- spice_error("not enough space");
- }
- enc->cur_image.out_size += enc->dest_mgr.free_in_buffer;
- return TRUE;
-}
-
-static void dest_mgr_term_destination(j_compress_ptr cinfo)
-{
- JpegEncoder *enc = (JpegEncoder *)cinfo->client_data;
- enc->cur_image.out_size -= enc->dest_mgr.free_in_buffer;
-}
-
-JpegEncoderContext* jpeg_encoder_create(JpegEncoderUsrContext *usr)
-{
- JpegEncoder *enc;
- if (!usr->more_space || !usr->more_lines) {
- return NULL;
- }
-
- enc = spice_new0(JpegEncoder, 1);
-
- enc->usr = usr;
-
- enc->dest_mgr.init_destination = dest_mgr_init_destination;
- enc->dest_mgr.empty_output_buffer = dest_mgr_empty_output_buffer;
- enc->dest_mgr.term_destination = dest_mgr_term_destination;
-
- enc->cinfo.err = jpeg_std_error(&enc->jerr);
-
- jpeg_create_compress(&enc->cinfo);
- enc->cinfo.client_data = enc;
- enc->cinfo.dest = &enc->dest_mgr;
- return (JpegEncoderContext*)enc;
-}
-
-void jpeg_encoder_destroy(JpegEncoderContext* encoder)
-{
- jpeg_destroy_compress(&((JpegEncoder*)encoder)->cinfo);
- free(encoder);
-}
-
-static void convert_RGB16_to_RGB24(void *line, int width, uint8_t **out_line)
-{
- uint16_t *src_line = line;
- uint8_t *out_pix;
- int x;
-
- spice_assert(out_line && *out_line);
-
- out_pix = *out_line;
-
- for (x = 0; x < width; x++) {
- uint16_t pixel = *src_line++;
- *out_pix++ = ((pixel >> 7) & 0xf8) | ((pixel >> 12) & 0x7);
- *out_pix++ = ((pixel >> 2) & 0xf8) | ((pixel >> 7) & 0x7);
- *out_pix++ = ((pixel << 3) & 0xf8) | ((pixel >> 2) & 0x7);
- }
-}
-
-static void convert_BGR24_to_RGB24(void *in_line, int width, uint8_t **out_line)
-{
- int x;
- uint8_t *out_pix;
- uint8_t *line = in_line;
- spice_assert(out_line && *out_line);
-
- out_pix = *out_line;
-
- for (x = 0; x < width; x++) {
- *out_pix++ = line[2];
- *out_pix++ = line[1];
- *out_pix++ = line[0];
- line += 3;
- }
-}
-
-static void convert_BGRX32_to_RGB24(void *line, int width, uint8_t **out_line)
-{
- uint32_t *src_line = line;
- uint8_t *out_pix;
- int x;
-
- spice_assert(out_line && *out_line);
-
- out_pix = *out_line;
-
- for (x = 0; x < width; x++) {
- uint32_t pixel = *src_line++;
- *out_pix++ = (pixel >> 16) & 0xff;
- *out_pix++ = (pixel >> 8) & 0xff;
- *out_pix++ = pixel & 0xff;
- }
-}
-
-static void convert_RGB24_to_RGB24(void *line, int width, uint8_t **out_line)
-{
- *out_line = line;
-}
-
-
-#define FILL_LINES() { \
- if (lines == lines_end) { \
- int n = jpeg->usr->more_lines(jpeg->usr, &lines); \
- if (n <= 0) { \
- spice_error("more lines failed"); \
- } \
- lines_end = lines + n * stride; \
- } \
-}
-
-static void do_jpeg_encode(JpegEncoder *jpeg, uint8_t *lines, unsigned int num_lines)
-{
- uint8_t *lines_end;
- uint8_t *RGB24_line;
- int stride, width;
- JSAMPROW row_pointer[1];
- width = jpeg->cur_image.width;
- stride = jpeg->cur_image.stride;
-
- if (jpeg->cur_image.type != JPEG_IMAGE_TYPE_RGB24) {
- RGB24_line = (uint8_t *)spice_malloc(width*3);
- }
-
- lines_end = lines + (stride * num_lines);
-
- for (;jpeg->cinfo.next_scanline < jpeg->cinfo.image_height; lines += stride) {
- FILL_LINES();
- jpeg->cur_image.convert_line_to_RGB24(lines, width, &RGB24_line);
- row_pointer[0] = RGB24_line;
- jpeg_write_scanlines(&jpeg->cinfo, row_pointer, 1);
- }
-
- if (jpeg->cur_image.type != JPEG_IMAGE_TYPE_RGB24) {
- free(RGB24_line);
- }
-}
-
-int jpeg_encode(JpegEncoderContext *jpeg, int quality, JpegEncoderImageType type,
- int width, int height, uint8_t *lines, unsigned int num_lines, int stride,
- uint8_t *io_ptr, unsigned int num_io_bytes)
-{
- JpegEncoder *enc = (JpegEncoder *)jpeg;
-
- enc->cur_image.type = type;
- enc->cur_image.width = width;
- enc->cur_image.height = height;
- enc->cur_image.stride = stride;
- enc->cur_image.out_size = 0;
-
- switch (type) {
- case JPEG_IMAGE_TYPE_RGB16:
- enc->cur_image.convert_line_to_RGB24 = convert_RGB16_to_RGB24;
- break;
- case JPEG_IMAGE_TYPE_RGB24:
- enc->cur_image.convert_line_to_RGB24 = convert_RGB24_to_RGB24;
- break;
- case JPEG_IMAGE_TYPE_BGR24:
- enc->cur_image.convert_line_to_RGB24 = convert_BGR24_to_RGB24;
- break;
- case JPEG_IMAGE_TYPE_BGRX32:
- enc->cur_image.convert_line_to_RGB24 = convert_BGRX32_to_RGB24;
- break;
- default:
- spice_error("bad image type");
- }
-
- enc->cinfo.image_width = width;
- enc->cinfo.image_height = height;
- enc->cinfo.input_components = 3;
- enc->cinfo.in_color_space = JCS_RGB;
- jpeg_set_defaults(&enc->cinfo);
- jpeg_set_quality(&enc->cinfo, quality, TRUE);
-
- enc->dest_mgr.next_output_byte = io_ptr;
- enc->dest_mgr.free_in_buffer = num_io_bytes;
-
- jpeg_start_compress(&enc->cinfo, TRUE);
-
- do_jpeg_encode(enc, lines, num_lines);
-
- jpeg_finish_compress(&enc->cinfo);
- return enc->cur_image.out_size;
-}
diff --git a/server/jpeg_encoder.h b/server/jpeg_encoder.h
deleted file mode 100644
index 690a029..0000000
--- a/server/jpeg_encoder.h
+++ /dev/null
@@ -1,61 +0,0 @@
-/*
- Copyright (C) 2009 Red Hat, Inc.
-
- Redistribution and use in source and binary forms, with or without
- modification, are permitted provided that the following conditions are
- met:
-
- * Redistributions of source code must retain the above copyright
- notice, this list of conditions and the following disclaimer.
- * Redistributions in binary form must reproduce the above copyright
- notice, this list of conditions and the following disclaimer in
- the documentation and/or other materials provided with the
- distribution.
- * Neither the name of the copyright holder nor the names of its
- contributors may be used to endorse or promote products derived
- from this software without specific prior written permission.
-
- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS "AS
- IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
- PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-#ifndef _H_JPEG_ENCODER
-#define _H_JPEG_ENCODER
-
-#include <spice/types.h>
-
-typedef enum {
- JPEG_IMAGE_TYPE_INVALID,
- JPEG_IMAGE_TYPE_RGB16,
- /* in byte per color types, the notation is according to the order of the
- colors in the memory */
- JPEG_IMAGE_TYPE_RGB24,
- JPEG_IMAGE_TYPE_BGR24,
- JPEG_IMAGE_TYPE_BGRX32,
-} JpegEncoderImageType;
-
-typedef void* JpegEncoderContext;
-typedef struct JpegEncoderUsrContext JpegEncoderUsrContext;
-
-struct JpegEncoderUsrContext {
- int (*more_space)(JpegEncoderUsrContext *usr, uint8_t **io_ptr);
- int (*more_lines)(JpegEncoderUsrContext *usr, uint8_t **lines);
-};
-
-JpegEncoderContext* jpeg_encoder_create(JpegEncoderUsrContext *usr);
-void jpeg_encoder_destroy(JpegEncoderContext *encoder);
-
-/* returns the total size of the encoded data. Images must be supplied from the
- top line to the bottom */
-int jpeg_encode(JpegEncoderContext *jpeg, int quality, JpegEncoderImageType type,
- int width, int height, uint8_t *lines, unsigned int num_lines, int stride,
- uint8_t *io_ptr, unsigned int num_io_bytes);
-#endif
diff --git a/server/main-channel.c b/server/main-channel.c
new file mode 100644
index 0000000..5ca5bba
--- /dev/null
+++ b/server/main-channel.c
@@ -0,0 +1,1345 @@
+/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ Copyright (C) 2009 Red Hat, Inc.
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, see <http://www.gnu.org/licenses/>.
+*/
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <inttypes.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <netinet/tcp.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+#include <limits.h>
+#include <time.h>
+#include <pthread.h>
+#include <sys/mman.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <ctype.h>
+
+#include "common/generated_server_marshallers.h"
+#include "common/messages.h"
+#include "common/ring.h"
+
+#include "demarshallers.h"
+#include "main-channel.h"
+#include "red_channel.h"
+#include "red_common.h"
+#include "reds.h"
+#include "migration-protocol.h"
+#include "main-dispatcher.h"
+#include "utils.h"
+
+#define ZERO_BUF_SIZE 4096
+
+#define NET_TEST_WARMUP_BYTES 0
+#define NET_TEST_BYTES (1024 * 250)
+
+#define PING_INTERVAL (1000 * 10)
+
+#define CLIENT_CONNECTIVITY_TIMEOUT (30*1000) // 30 seconds
+
+static uint8_t zero_page[ZERO_BUF_SIZE] = {0};
+
+enum {
+ PIPE_ITEM_TYPE_MAIN_CHANNELS_LIST = PIPE_ITEM_TYPE_CHANNEL_BASE,
+ PIPE_ITEM_TYPE_MAIN_PING,
+ PIPE_ITEM_TYPE_MAIN_MOUSE_MODE,
+ PIPE_ITEM_TYPE_MAIN_AGENT_DISCONNECTED,
+ PIPE_ITEM_TYPE_MAIN_AGENT_TOKEN,
+ PIPE_ITEM_TYPE_MAIN_AGENT_DATA,
+ PIPE_ITEM_TYPE_MAIN_MIGRATE_DATA,
+ PIPE_ITEM_TYPE_MAIN_INIT,
+ PIPE_ITEM_TYPE_MAIN_NOTIFY,
+ PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN,
+ PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN_SEAMLESS,
+ PIPE_ITEM_TYPE_MAIN_MIGRATE_SWITCH_HOST,
+ PIPE_ITEM_TYPE_MAIN_MULTI_MEDIA_TIME,
+ PIPE_ITEM_TYPE_MAIN_NAME,
+ PIPE_ITEM_TYPE_MAIN_UUID,
+ PIPE_ITEM_TYPE_MAIN_AGENT_CONNECTED_TOKENS,
+};
+
+typedef struct RefsPipeItem {
+ PipeItem base;
+ int *refs;
+} RefsPipeItem;
+
+typedef struct PingPipeItem {
+ PipeItem base;
+ int size;
+} PingPipeItem;
+
+typedef struct MouseModePipeItem {
+ PipeItem base;
+ int current_mode;
+ int is_client_mouse_allowed;
+} MouseModePipeItem;
+
+typedef struct TokensPipeItem {
+ PipeItem base;
+ int tokens;
+} TokensPipeItem;
+
+typedef struct AgentDataPipeItem {
+ PipeItem base;
+ uint8_t* data;
+ size_t len;
+ spice_marshaller_item_free_func free_data;
+ void *opaque;
+} AgentDataPipeItem;
+
+typedef struct InitPipeItem {
+ PipeItem base;
+ int connection_id;
+ int display_channels_hint;
+ int current_mouse_mode;
+ int is_client_mouse_allowed;
+ int multi_media_time;
+ int ram_hint;
+} InitPipeItem;
+
+typedef struct NamePipeItem {
+ PipeItem base;
+ SpiceMsgMainName msg;
+} NamePipeItem;
+
+typedef struct UuidPipeItem {
+ PipeItem base;
+ SpiceMsgMainUuid msg;
+} UuidPipeItem;
+
+typedef struct NotifyPipeItem {
+ PipeItem base;
+ char *msg;
+} NotifyPipeItem;
+
+typedef struct MultiMediaTimePipeItem {
+ PipeItem base;
+ int time;
+} MultiMediaTimePipeItem;
+
+struct MainChannelClient {
+ RedChannelClient base;
+ uint32_t connection_id;
+ uint32_t ping_id;
+ uint32_t net_test_id;
+ int net_test_stage;
+ uint64_t latency;
+ uint64_t bitrate_per_sec;
+#ifdef RED_STATISTICS
+ SpiceTimer *ping_timer;
+ int ping_interval;
+#endif
+ int mig_wait_connect;
+ int mig_connect_ok;
+ int mig_wait_prev_complete;
+ int mig_wait_prev_try_seamless;
+ int init_sent;
+ int seamless_mig_dst;
+};
+
+enum NetTestStage {
+ NET_TEST_STAGE_INVALID,
+ NET_TEST_STAGE_WARMUP,
+ NET_TEST_STAGE_LATENCY,
+ NET_TEST_STAGE_RATE,
+ NET_TEST_STAGE_COMPLETE,
+};
+
+static void main_channel_release_pipe_item(RedChannelClient *rcc,
+ PipeItem *base, int item_pushed);
+
+int main_channel_is_connected(MainChannel *main_chan)
+{
+ return red_channel_is_connected(&main_chan->base);
+}
+
+/*
+ * When the main channel is disconnected, disconnect the entire client.
+ */
+static void main_channel_client_on_disconnect(RedChannelClient *rcc)
+{
+ spice_printerr("rcc=%p", rcc);
+ main_dispatcher_client_disconnect(rcc->client);
+}
+
+RedClient *main_channel_get_client_by_link_id(MainChannel *main_chan, uint32_t connection_id)
+{
+ RingItem *link;
+ MainChannelClient *mcc;
+
+ RING_FOREACH(link, &main_chan->base.clients) {
+ mcc = SPICE_CONTAINEROF(link, MainChannelClient, base.channel_link);
+ if (mcc->connection_id == connection_id) {
+ return mcc->base.client;
+ }
+ }
+ return NULL;
+}
+
+static int main_channel_client_push_ping(MainChannelClient *mcc, int size);
+
+void main_channel_client_start_net_test(MainChannelClient *mcc, int test_rate)
+{
+ if (!mcc || mcc->net_test_id) {
+ return;
+ }
+ if (test_rate) {
+ if (main_channel_client_push_ping(mcc, NET_TEST_WARMUP_BYTES)
+ && main_channel_client_push_ping(mcc, 0)
+ && main_channel_client_push_ping(mcc, NET_TEST_BYTES)) {
+ mcc->net_test_id = mcc->ping_id - 2;
+ mcc->net_test_stage = NET_TEST_STAGE_WARMUP;
+ }
+ } else {
+ red_channel_client_start_connectivity_monitoring(&mcc->base, CLIENT_CONNECTIVITY_TIMEOUT);
+ }
+}
+
+typedef struct MainMouseModeItemInfo {
+ int current_mode;
+ int is_client_mouse_allowed;
+} MainMouseModeItemInfo;
+
+static PipeItem *main_mouse_mode_item_new(RedChannelClient *rcc, void *data, int num)
+{
+ MouseModePipeItem *item = spice_malloc(sizeof(MouseModePipeItem));
+ MainMouseModeItemInfo *info = data;
+
+ red_channel_pipe_item_init(rcc->channel, &item->base,
+ PIPE_ITEM_TYPE_MAIN_MOUSE_MODE);
+ item->current_mode = info->current_mode;
+ item->is_client_mouse_allowed = info->is_client_mouse_allowed;
+ return &item->base;
+}
+
+static PipeItem *main_ping_item_new(MainChannelClient *mcc, int size)
+{
+ PingPipeItem *item = spice_malloc(sizeof(PingPipeItem));
+
+ red_channel_pipe_item_init(mcc->base.channel, &item->base, PIPE_ITEM_TYPE_MAIN_PING);
+ item->size = size;
+ return &item->base;
+}
+
+static PipeItem *main_agent_tokens_item_new(RedChannelClient *rcc, uint32_t num_tokens)
+{
+ TokensPipeItem *item = spice_malloc(sizeof(TokensPipeItem));
+
+ red_channel_pipe_item_init(rcc->channel, &item->base,
+ PIPE_ITEM_TYPE_MAIN_AGENT_TOKEN);
+ item->tokens = num_tokens;
+ return &item->base;
+}
+
+static PipeItem *main_agent_data_item_new(RedChannelClient *rcc, uint8_t* data, size_t len,
+ spice_marshaller_item_free_func free_data,
+ void *opaque)
+{
+ AgentDataPipeItem *item = spice_malloc(sizeof(AgentDataPipeItem));
+
+ red_channel_pipe_item_init(rcc->channel, &item->base,
+ PIPE_ITEM_TYPE_MAIN_AGENT_DATA);
+ item->data = data;
+ item->len = len;
+ item->free_data = free_data;
+ item->opaque = opaque;
+ return &item->base;
+}
+
+static PipeItem *main_init_item_new(MainChannelClient *mcc,
+ int connection_id, int display_channels_hint, int current_mouse_mode,
+ int is_client_mouse_allowed, int multi_media_time,
+ int ram_hint)
+{
+ InitPipeItem *item = spice_malloc(sizeof(InitPipeItem));
+
+ red_channel_pipe_item_init(mcc->base.channel, &item->base,
+ PIPE_ITEM_TYPE_MAIN_INIT);
+ item->connection_id = connection_id;
+ item->display_channels_hint = display_channels_hint;
+ item->current_mouse_mode = current_mouse_mode;
+ item->is_client_mouse_allowed = is_client_mouse_allowed;
+ item->multi_media_time = multi_media_time;
+ item->ram_hint = ram_hint;
+ return &item->base;
+}
+
+static PipeItem *main_name_item_new(MainChannelClient *mcc, const char *name)
+{
+ NamePipeItem *item = spice_malloc(sizeof(NamePipeItem) + strlen(name) + 1);
+
+ red_channel_pipe_item_init(mcc->base.channel, &item->base,
+ PIPE_ITEM_TYPE_MAIN_NAME);
+ item->msg.name_len = strlen(name) + 1;
+ memcpy(&item->msg.name, name, item->msg.name_len);
+
+ return &item->base;
+}
+
+static PipeItem *main_uuid_item_new(MainChannelClient *mcc, const uint8_t uuid[16])
+{
+ UuidPipeItem *item = spice_malloc(sizeof(UuidPipeItem));
+
+ red_channel_pipe_item_init(mcc->base.channel, &item->base,
+ PIPE_ITEM_TYPE_MAIN_UUID);
+ memcpy(item->msg.uuid, uuid, sizeof(item->msg.uuid));
+
+ return &item->base;
+}
+
+static PipeItem *main_notify_item_new(RedChannelClient *rcc, void *data, int num)
+{
+ NotifyPipeItem *item = spice_malloc(sizeof(NotifyPipeItem));
+ const char *msg = data;
+
+ red_channel_pipe_item_init(rcc->channel, &item->base,
+ PIPE_ITEM_TYPE_MAIN_NOTIFY);
+ item->msg = spice_strdup(msg);
+ return &item->base;
+}
+
+static PipeItem *main_multi_media_time_item_new(
+ RedChannelClient *rcc, void *data, int num)
+{
+ MultiMediaTimePipeItem *item, *info = data;
+
+ item = spice_malloc(sizeof(MultiMediaTimePipeItem));
+ red_channel_pipe_item_init(rcc->channel, &item->base,
+ PIPE_ITEM_TYPE_MAIN_MULTI_MEDIA_TIME);
+ item->time = info->time;
+ return &item->base;
+}
+
+static void main_channel_push_channels(MainChannelClient *mcc)
+{
+ if (red_client_during_migrate_at_target(mcc->base.client)) {
+ spice_printerr("warning: ignoring unexpected SPICE_MSGC_MAIN_ATTACH_CHANNELS"
+ "during migration");
+ return;
+ }
+ red_channel_client_pipe_add_type(&mcc->base, PIPE_ITEM_TYPE_MAIN_CHANNELS_LIST);
+}
+
+static void main_channel_marshall_channels(RedChannelClient *rcc,
+ SpiceMarshaller *m,
+ PipeItem *item)
+{
+ SpiceMsgChannels* channels_info;
+
+ red_channel_client_init_send_data(rcc, SPICE_MSG_MAIN_CHANNELS_LIST, item);
+ channels_info = (SpiceMsgChannels *)spice_malloc(sizeof(SpiceMsgChannels)
+ + reds_num_of_channels() * sizeof(SpiceChannelId));
+ reds_fill_channels(channels_info);
+ spice_marshall_msg_main_channels_list(m, channels_info);
+ free(channels_info);
+}
+
+int main_channel_client_push_ping(MainChannelClient *mcc, int size)
+{
+ PipeItem *item;
+
+ if (mcc == NULL) {
+ return FALSE;
+ }
+ item = main_ping_item_new(mcc, size);
+ red_channel_client_pipe_add_push(&mcc->base, item);
+ return TRUE;
+}
+
+static void main_channel_marshall_ping(RedChannelClient *rcc,
+ SpiceMarshaller *m,
+ PingPipeItem *item)
+{
+ MainChannelClient *mcc = SPICE_CONTAINEROF(rcc, MainChannelClient, base);
+ struct timespec time_space;
+ SpiceMsgPing ping;
+ int size_left = item->size;
+
+ red_channel_client_init_send_data(rcc, SPICE_MSG_PING, &item->base);
+ ping.id = ++(mcc->ping_id);
+ clock_gettime(CLOCK_MONOTONIC, &time_space);
+ ping.timestamp = time_space.tv_sec * 1000000LL + time_space.tv_nsec / 1000LL;
+ spice_marshall_msg_ping(m, &ping);
+
+ while (size_left > 0) {
+ int now = MIN(ZERO_BUF_SIZE, size_left);
+ size_left -= now;
+ spice_marshaller_add_ref(m, zero_page, now);
+ }
+}
+
+void main_channel_push_mouse_mode(MainChannel *main_chan, int current_mode,
+ int is_client_mouse_allowed)
+{
+ MainMouseModeItemInfo info = {
+ .current_mode=current_mode,
+ .is_client_mouse_allowed=is_client_mouse_allowed,
+ };
+
+ red_channel_pipes_new_add_push(&main_chan->base,
+ main_mouse_mode_item_new, &info);
+}
+
+static void main_channel_marshall_mouse_mode(RedChannelClient *rcc,
+ SpiceMarshaller *m,
+ MouseModePipeItem *item)
+{
+ SpiceMsgMainMouseMode mouse_mode;
+
+ red_channel_client_init_send_data(rcc, SPICE_MSG_MAIN_MOUSE_MODE, &item->base);
+ mouse_mode.supported_modes = SPICE_MOUSE_MODE_SERVER;
+ if (item->is_client_mouse_allowed) {
+ mouse_mode.supported_modes |= SPICE_MOUSE_MODE_CLIENT;
+ }
+ mouse_mode.current_mode = item->current_mode;
+ spice_marshall_msg_main_mouse_mode(m, &mouse_mode);
+}
+
+void main_channel_push_agent_connected(MainChannel *main_chan)
+{
+ if (red_channel_test_remote_cap(&main_chan->base, SPICE_MAIN_CAP_AGENT_CONNECTED_TOKENS)) {
+ red_channel_pipes_add_type(&main_chan->base, PIPE_ITEM_TYPE_MAIN_AGENT_CONNECTED_TOKENS);
+ } else {
+ red_channel_pipes_add_empty_msg(&main_chan->base, SPICE_MSG_MAIN_AGENT_CONNECTED);
+ }
+}
+
+static void main_channel_marshall_agent_connected(SpiceMarshaller *m,
+ RedChannelClient *rcc,
+ PipeItem *item)
+{
+ SpiceMsgMainAgentConnectedTokens connected;
+
+ red_channel_client_init_send_data(rcc, SPICE_MSG_MAIN_AGENT_CONNECTED_TOKENS, item);
+ connected.num_tokens = REDS_AGENT_WINDOW_SIZE;
+ spice_marshall_msg_main_agent_connected_tokens(m, &connected);
+}
+
+void main_channel_push_agent_disconnected(MainChannel *main_chan)
+{
+ red_channel_pipes_add_type(&main_chan->base, PIPE_ITEM_TYPE_MAIN_AGENT_DISCONNECTED);
+}
+
+static void main_channel_marshall_agent_disconnected(RedChannelClient *rcc,
+ SpiceMarshaller *m,
+ PipeItem *item)
+{
+ SpiceMsgMainAgentDisconnect disconnect;
+
+ red_channel_client_init_send_data(rcc, SPICE_MSG_MAIN_AGENT_DISCONNECTED, item);
+ disconnect.error_code = SPICE_LINK_ERR_OK;
+ spice_marshall_msg_main_agent_disconnected(m, &disconnect);
+}
+
+void main_channel_client_push_agent_tokens(MainChannelClient *mcc, uint32_t num_tokens)
+{
+ PipeItem *item = main_agent_tokens_item_new(&mcc->base, num_tokens);
+
+ red_channel_client_pipe_add_push(&mcc->base, item);
+}
+
+static void main_channel_marshall_tokens(RedChannelClient *rcc,
+ SpiceMarshaller *m, TokensPipeItem *item)
+{
+ SpiceMsgMainAgentTokens tokens;
+
+ red_channel_client_init_send_data(rcc, SPICE_MSG_MAIN_AGENT_TOKEN, &item->base);
+ tokens.num_tokens = item->tokens;
+ spice_marshall_msg_main_agent_token(m, &tokens);
+}
+
+void main_channel_client_push_agent_data(MainChannelClient *mcc, uint8_t* data, size_t len,
+ spice_marshaller_item_free_func free_data, void *opaque)
+{
+ PipeItem *item;
+
+ item = main_agent_data_item_new(&mcc->base, data, len, free_data, opaque);
+ red_channel_client_pipe_add_push(&mcc->base, item);
+}
+
+static void main_channel_marshall_agent_data(RedChannelClient *rcc,
+ SpiceMarshaller *m,
+ AgentDataPipeItem *item)
+{
+ red_channel_client_init_send_data(rcc, SPICE_MSG_MAIN_AGENT_DATA, &item->base);
+ spice_marshaller_add_ref(m, item->data, item->len);
+}
+
+static void main_channel_push_migrate_data_item(MainChannel *main_chan)
+{
+ red_channel_pipes_add_type(&main_chan->base, PIPE_ITEM_TYPE_MAIN_MIGRATE_DATA);
+}
+
+static void main_channel_marshall_migrate_data_item(RedChannelClient *rcc,
+ SpiceMarshaller *m, PipeItem *item)
+{
+ red_channel_client_init_send_data(rcc, SPICE_MSG_MIGRATE_DATA, item);
+ reds_marshall_migrate_data(m); // TODO: from reds split. ugly separation.
+}
+
+static int main_channel_handle_migrate_data(RedChannelClient *rcc,
+ uint32_t size, void *message)
+{
+ MainChannelClient *mcc = SPICE_CONTAINEROF(rcc, MainChannelClient, base);
+ SpiceMigrateDataHeader *header = (SpiceMigrateDataHeader *)message;
+
+ /* not supported with multi-clients */
+ spice_assert(rcc->channel->clients_num == 1);
+
+ if (size < sizeof(SpiceMigrateDataHeader) + sizeof(SpiceMigrateDataMain)) {
+ spice_printerr("bad message size %u", size);
+ return FALSE;
+ }
+ if (!migration_protocol_validate_header(header,
+ SPICE_MIGRATE_DATA_MAIN_MAGIC,
+ SPICE_MIGRATE_DATA_MAIN_VERSION)) {
+ spice_error("bad header");
+ return FALSE;
+ }
+ return reds_handle_migrate_data(mcc, (SpiceMigrateDataMain *)(header + 1), size);
+}
+
+void main_channel_push_init(MainChannelClient *mcc,
+ int display_channels_hint, int current_mouse_mode,
+ int is_client_mouse_allowed, int multi_media_time,
+ int ram_hint)
+{
+ PipeItem *item;
+
+ item = main_init_item_new(mcc,
+ mcc->connection_id, display_channels_hint, current_mouse_mode,
+ is_client_mouse_allowed, multi_media_time, ram_hint);
+ red_channel_client_pipe_add_push(&mcc->base, item);
+}
+
+static void main_channel_marshall_init(RedChannelClient *rcc,
+ SpiceMarshaller *m,
+ InitPipeItem *item)
+{
+ SpiceMsgMainInit init; // TODO - remove this copy, make InitPipeItem reuse SpiceMsgMainInit
+
+
+ red_channel_client_init_send_data(rcc, SPICE_MSG_MAIN_INIT, &item->base);
+ init.session_id = item->connection_id;
+ init.display_channels_hint = item->display_channels_hint;
+ init.current_mouse_mode = item->current_mouse_mode;
+ init.supported_mouse_modes = SPICE_MOUSE_MODE_SERVER;
+ if (item->is_client_mouse_allowed) {
+ init.supported_mouse_modes |= SPICE_MOUSE_MODE_CLIENT;
+ }
+ init.agent_connected = reds_has_vdagent();
+ init.agent_tokens = REDS_AGENT_WINDOW_SIZE;
+ init.multi_media_time = item->multi_media_time;
+ init.ram_hint = item->ram_hint;
+ spice_marshall_msg_main_init(m, &init);
+}
+
+void main_channel_push_name(MainChannelClient *mcc, const char *name)
+{
+ PipeItem *item;
+
+ if (!red_channel_client_test_remote_cap(&mcc->base,
+ SPICE_MAIN_CAP_NAME_AND_UUID))
+ return;
+
+ item = main_name_item_new(mcc, name);
+ red_channel_client_pipe_add_push(&mcc->base, item);
+}
+
+void main_channel_push_uuid(MainChannelClient *mcc, const uint8_t uuid[16])
+{
+ PipeItem *item;
+
+ if (!red_channel_client_test_remote_cap(&mcc->base,
+ SPICE_MAIN_CAP_NAME_AND_UUID))
+ return;
+
+ item = main_uuid_item_new(mcc, uuid);
+ red_channel_client_pipe_add_push(&mcc->base, item);
+}
+
+void main_channel_client_push_notify(MainChannelClient *mcc, const char *msg)
+{
+ PipeItem *item = main_notify_item_new(&mcc->base, (void *)msg, 1);
+ red_channel_client_pipe_add_push(&mcc->base, item);
+}
+
+static void main_channel_marshall_notify(RedChannelClient *rcc,
+ SpiceMarshaller *m, NotifyPipeItem *item)
+{
+ SpiceMsgNotify notify;
+
+ red_channel_client_init_send_data(rcc, SPICE_MSG_NOTIFY, &item->base);
+ notify.time_stamp = red_get_monotonic_time(); // TODO - move to main_new_notify_item
+ notify.severity = SPICE_NOTIFY_SEVERITY_WARN;
+ notify.visibilty = SPICE_NOTIFY_VISIBILITY_HIGH;
+ notify.what = SPICE_WARN_GENERAL;
+ notify.message_len = strlen(item->msg);
+ spice_marshall_msg_notify(m, ¬ify);
+ spice_marshaller_add(m, (uint8_t *)item->msg, notify.message_len + 1);
+}
+
+static void main_channel_fill_migrate_dst_info(MainChannel *main_channel,
+ SpiceMigrationDstInfo *dst_info)
+{
+ RedsMigSpice *mig_dst = &main_channel->mig_target;
+ dst_info->port = mig_dst->port;
+ dst_info->sport = mig_dst->sport;
+ dst_info->host_size = strlen(mig_dst->host) + 1;
+ dst_info->host_data = (uint8_t *)mig_dst->host;
+ if (mig_dst->cert_subject) {
+ dst_info->cert_subject_size = strlen(mig_dst->cert_subject) + 1;
+ dst_info->cert_subject_data = (uint8_t *)mig_dst->cert_subject;
+ } else {
+ dst_info->cert_subject_size = 0;
+ dst_info->cert_subject_data = NULL;
+ }
+}
+
+static void main_channel_marshall_migrate_begin(SpiceMarshaller *m, RedChannelClient *rcc,
+ PipeItem *item)
+{
+ SpiceMsgMainMigrationBegin migrate;
+ MainChannel *main_ch;
+
+ red_channel_client_init_send_data(rcc, SPICE_MSG_MAIN_MIGRATE_BEGIN, item);
+ main_ch = SPICE_CONTAINEROF(rcc->channel, MainChannel, base);
+ main_channel_fill_migrate_dst_info(main_ch, &migrate.dst_info);
+ spice_marshall_msg_main_migrate_begin(m, &migrate);
+}
+
+static void main_channel_marshall_migrate_begin_seamless(SpiceMarshaller *m,
+ RedChannelClient *rcc,
+ PipeItem *item)
+{
+ SpiceMsgMainMigrateBeginSeamless migrate_seamless;
+ MainChannel *main_ch;
+
+ red_channel_client_init_send_data(rcc, SPICE_MSG_MAIN_MIGRATE_BEGIN_SEAMLESS, item);
+ main_ch = SPICE_CONTAINEROF(rcc->channel, MainChannel, base);
+ main_channel_fill_migrate_dst_info(main_ch, &migrate_seamless.dst_info);
+ migrate_seamless.src_mig_version = SPICE_MIGRATION_PROTOCOL_VERSION;
+ spice_marshall_msg_main_migrate_begin_seamless(m, &migrate_seamless);
+}
+
+void main_channel_push_multi_media_time(MainChannel *main_chan, int time)
+{
+ MultiMediaTimePipeItem info = {
+ .time = time,
+ };
+
+ red_channel_pipes_new_add_push(&main_chan->base,
+ main_multi_media_time_item_new, &info);
+}
+
+static void main_channel_fill_mig_target(MainChannel *main_channel, RedsMigSpice *mig_target)
+{
+ spice_assert(mig_target);
+ free(main_channel->mig_target.host);
+ main_channel->mig_target.host = spice_strdup(mig_target->host);
+ free(main_channel->mig_target.cert_subject);
+ if (mig_target->cert_subject) {
+ main_channel->mig_target.cert_subject = spice_strdup(mig_target->cert_subject);
+ } else {
+ main_channel->mig_target.cert_subject = NULL;
+ }
+ main_channel->mig_target.port = mig_target->port;
+ main_channel->mig_target.sport = mig_target->sport;
+}
+
+void main_channel_migrate_switch(MainChannel *main_chan, RedsMigSpice *mig_target)
+{
+ main_channel_fill_mig_target(main_chan, mig_target);
+ red_channel_pipes_add_type(&main_chan->base, PIPE_ITEM_TYPE_MAIN_MIGRATE_SWITCH_HOST);
+}
+
+static void main_channel_marshall_migrate_switch(SpiceMarshaller *m, RedChannelClient *rcc,
+ PipeItem *item)
+{
+ SpiceMsgMainMigrationSwitchHost migrate;
+ MainChannel *main_ch;
+
+ spice_printerr("");
+ red_channel_client_init_send_data(rcc, SPICE_MSG_MAIN_MIGRATE_SWITCH_HOST, item);
+ main_ch = SPICE_CONTAINEROF(rcc->channel, MainChannel, base);
+ migrate.port = main_ch->mig_target.port;
+ migrate.sport = main_ch->mig_target.sport;
+ migrate.host_size = strlen(main_ch->mig_target.host) + 1;
+ migrate.host_data = (uint8_t *)main_ch->mig_target.host;
+ if (main_ch->mig_target.cert_subject) {
+ migrate.cert_subject_size = strlen(main_ch->mig_target.cert_subject) + 1;
+ migrate.cert_subject_data = (uint8_t *)main_ch->mig_target.cert_subject;
+ } else {
+ migrate.cert_subject_size = 0;
+ migrate.cert_subject_data = NULL;
+ }
+ spice_marshall_msg_main_migrate_switch_host(m, &migrate);
+}
+
+static void main_channel_marshall_multi_media_time(RedChannelClient *rcc,
+ SpiceMarshaller *m,
+ MultiMediaTimePipeItem *item)
+{
+ SpiceMsgMainMultiMediaTime time_mes;
+
+ red_channel_client_init_send_data(rcc, SPICE_MSG_MAIN_MULTI_MEDIA_TIME, &item->base);
+ time_mes.time = item->time;
+ spice_marshall_msg_main_multi_media_time(m, &time_mes);
+}
+
+static void main_channel_send_item(RedChannelClient *rcc, PipeItem *base)
+{
+ MainChannelClient *mcc = SPICE_CONTAINEROF(rcc, MainChannelClient, base);
+ SpiceMarshaller *m = red_channel_client_get_marshaller(rcc);
+
+ /* In semi-seamless migration (dest side), the connection is started from scratch, and
+ * we ignore any pipe item that arrives before the INIT msg is sent.
+ * For seamless we don't send INIT, and the connection continues from the same place
+ * it stopped on the src side. */
+ if (!mcc->init_sent && !mcc->seamless_mig_dst && base->type != PIPE_ITEM_TYPE_MAIN_INIT) {
+ spice_printerr("Init msg for client %p was not sent yet "
+ "(client is probably during semi-seamless migration). Ignoring msg type %d",
+ rcc->client, base->type);
+ main_channel_release_pipe_item(rcc, base, FALSE);
+ return;
+ }
+ switch (base->type) {
+ case PIPE_ITEM_TYPE_MAIN_CHANNELS_LIST:
+ main_channel_marshall_channels(rcc, m, base);
+ break;
+ case PIPE_ITEM_TYPE_MAIN_PING:
+ main_channel_marshall_ping(rcc, m,
+ SPICE_CONTAINEROF(base, PingPipeItem, base));
+ break;
+ case PIPE_ITEM_TYPE_MAIN_MOUSE_MODE:
+ {
+ MouseModePipeItem *item =
+ SPICE_CONTAINEROF(base, MouseModePipeItem, base);
+ main_channel_marshall_mouse_mode(rcc, m, item);
+ break;
+ }
+ case PIPE_ITEM_TYPE_MAIN_AGENT_DISCONNECTED:
+ main_channel_marshall_agent_disconnected(rcc, m, base);
+ break;
+ case PIPE_ITEM_TYPE_MAIN_AGENT_TOKEN:
+ main_channel_marshall_tokens(rcc, m,
+ SPICE_CONTAINEROF(base, TokensPipeItem, base));
+ break;
+ case PIPE_ITEM_TYPE_MAIN_AGENT_DATA:
+ main_channel_marshall_agent_data(rcc, m,
+ SPICE_CONTAINEROF(base, AgentDataPipeItem, base));
+ break;
+ case PIPE_ITEM_TYPE_MAIN_MIGRATE_DATA:
+ main_channel_marshall_migrate_data_item(rcc, m, base);
+ break;
+ case PIPE_ITEM_TYPE_MAIN_INIT:
+ mcc->init_sent = TRUE;
+ main_channel_marshall_init(rcc, m,
+ SPICE_CONTAINEROF(base, InitPipeItem, base));
+ break;
+ case PIPE_ITEM_TYPE_MAIN_NOTIFY:
+ main_channel_marshall_notify(rcc, m,
+ SPICE_CONTAINEROF(base, NotifyPipeItem, base));
+ break;
+ case PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN:
+ main_channel_marshall_migrate_begin(m, rcc, base);
+ break;
+ case PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN_SEAMLESS:
+ main_channel_marshall_migrate_begin_seamless(m, rcc, base);
+ break;
+ case PIPE_ITEM_TYPE_MAIN_MULTI_MEDIA_TIME:
+ main_channel_marshall_multi_media_time(rcc, m,
+ SPICE_CONTAINEROF(base, MultiMediaTimePipeItem, base));
+ break;
+ case PIPE_ITEM_TYPE_MAIN_MIGRATE_SWITCH_HOST:
+ main_channel_marshall_migrate_switch(m, rcc, base);
+ break;
+ case PIPE_ITEM_TYPE_MAIN_NAME:
+ red_channel_client_init_send_data(rcc, SPICE_MSG_MAIN_NAME, base);
+ spice_marshall_msg_main_name(m, &SPICE_CONTAINEROF(base, NamePipeItem, base)->msg);
+ break;
+ case PIPE_ITEM_TYPE_MAIN_UUID:
+ red_channel_client_init_send_data(rcc, SPICE_MSG_MAIN_UUID, base);
+ spice_marshall_msg_main_uuid(m, &SPICE_CONTAINEROF(base, UuidPipeItem, base)->msg);
+ break;
+ case PIPE_ITEM_TYPE_MAIN_AGENT_CONNECTED_TOKENS:
+ main_channel_marshall_agent_connected(m, rcc, base);
+ break;
+ default:
+ break;
+ };
+ red_channel_client_begin_send_message(rcc);
+}
+
+static void main_channel_release_pipe_item(RedChannelClient *rcc,
+ PipeItem *base, int item_pushed)
+{
+ switch (base->type) {
+ case PIPE_ITEM_TYPE_MAIN_AGENT_DATA: {
+ AgentDataPipeItem *data = (AgentDataPipeItem *)base;
+
+ data->free_data(data->data, data->opaque);
+ break;
+ }
+ case PIPE_ITEM_TYPE_MAIN_NOTIFY: {
+ NotifyPipeItem *data = (NotifyPipeItem *)base;
+ free(data->msg);
+ break;
+ }
+ default:
+ break;
+ }
+ free(base);
+}
+
+static void main_channel_client_handle_migrate_connected(MainChannelClient *mcc,
+ int success,
+ int seamless)
+{
+ spice_printerr("client %p connected: %d seamless %d", mcc->base.client, success, seamless);
+ if (mcc->mig_wait_connect) {
+ MainChannel *main_channel = SPICE_CONTAINEROF(mcc->base.channel, MainChannel, base);
+
+ mcc->mig_wait_connect = FALSE;
+ mcc->mig_connect_ok = success;
+ spice_assert(main_channel->num_clients_mig_wait);
+ spice_assert(!seamless || main_channel->num_clients_mig_wait == 1);
+ if (!--main_channel->num_clients_mig_wait) {
+ reds_on_main_migrate_connected(seamless && success);
+ }
+ } else {
+ if (success) {
+ spice_printerr("client %p MIGRATE_CANCEL", mcc->base.client);
+ red_channel_client_pipe_add_empty_msg(&mcc->base, SPICE_MSG_MAIN_MIGRATE_CANCEL);
+ }
+ }
+}
+
+void main_channel_client_handle_migrate_dst_do_seamless(MainChannelClient *mcc,
+ uint32_t src_version)
+{
+ if (reds_on_migrate_dst_set_seamless(mcc, src_version)) {
+ mcc->seamless_mig_dst = TRUE;
+ red_channel_client_pipe_add_empty_msg(&mcc->base,
+ SPICE_MSG_MAIN_MIGRATE_DST_SEAMLESS_ACK);
+ } else {
+ red_channel_client_pipe_add_empty_msg(&mcc->base,
+ SPICE_MSG_MAIN_MIGRATE_DST_SEAMLESS_NACK);
+ }
+}
+
+void main_channel_client_handle_migrate_end(MainChannelClient *mcc)
+{
+ if (!red_client_during_migrate_at_target(mcc->base.client)) {
+ spice_printerr("unexpected SPICE_MSGC_MIGRATE_END");
+ return;
+ }
+ if (!red_channel_client_test_remote_cap(&mcc->base,
+ SPICE_MAIN_CAP_SEMI_SEAMLESS_MIGRATE)) {
+ spice_printerr("unexpected SPICE_MSGC_MIGRATE_END, "
+ "client does not support semi-seamless migration");
+ return;
+ }
+ red_client_semi_seamless_migrate_complete(mcc->base.client);
+}
+
+void main_channel_migrate_dst_complete(MainChannelClient *mcc)
+{
+ if (mcc->mig_wait_prev_complete) {
+ if (mcc->mig_wait_prev_try_seamless) {
+ spice_assert(mcc->base.channel->clients_num == 1);
+ red_channel_client_pipe_add_type(&mcc->base,
+ PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN_SEAMLESS);
+ } else {
+ red_channel_client_pipe_add_type(&mcc->base, PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN);
+ }
+ mcc->mig_wait_connect = TRUE;
+ mcc->mig_wait_prev_complete = FALSE;
+ }
+}
+
+static int main_channel_handle_parsed(RedChannelClient *rcc, uint32_t size, uint16_t type,
+ void *message)
+{
+ MainChannel *main_chan = SPICE_CONTAINEROF(rcc->channel, MainChannel, base);
+ MainChannelClient *mcc = SPICE_CONTAINEROF(rcc, MainChannelClient, base);
+
+ switch (type) {
+ case SPICE_MSGC_MAIN_AGENT_START: {
+ SpiceMsgcMainAgentStart *tokens;
+
+ spice_printerr("agent start");
+ if (!main_chan) {
+ return FALSE;
+ }
+ tokens = (SpiceMsgcMainAgentStart *)message;
+ reds_on_main_agent_start(mcc, tokens->num_tokens);
+ break;
+ }
+ case SPICE_MSGC_MAIN_AGENT_DATA: {
+ reds_on_main_agent_data(mcc, message, size);
+ break;
+ }
+ case SPICE_MSGC_MAIN_AGENT_TOKEN: {
+ SpiceMsgcMainAgentTokens *tokens;
+
+ tokens = (SpiceMsgcMainAgentTokens *)message;
+ reds_on_main_agent_tokens(mcc, tokens->num_tokens);
+ break;
+ }
+ case SPICE_MSGC_MAIN_ATTACH_CHANNELS:
+ main_channel_push_channels(mcc);
+ break;
+ case SPICE_MSGC_MAIN_MIGRATE_CONNECTED:
+ main_channel_client_handle_migrate_connected(mcc,
+ TRUE /* success */,
+ FALSE /* seamless */);
+ break;
+ case SPICE_MSGC_MAIN_MIGRATE_CONNECTED_SEAMLESS:
+ main_channel_client_handle_migrate_connected(mcc,
+ TRUE /* success */,
+ TRUE /* seamless */);
+ break;
+ case SPICE_MSGC_MAIN_MIGRATE_CONNECT_ERROR:
+ main_channel_client_handle_migrate_connected(mcc, FALSE, FALSE);
+ break;
+ case SPICE_MSGC_MAIN_MIGRATE_DST_DO_SEAMLESS:
+ main_channel_client_handle_migrate_dst_do_seamless(mcc,
+ ((SpiceMsgcMainMigrateDstDoSeamless *)message)->src_version);
+ break;
+ case SPICE_MSGC_MAIN_MOUSE_MODE_REQUEST:
+ reds_on_main_mouse_mode_request(message, size);
+ break;
+ case SPICE_MSGC_PONG: {
+ SpiceMsgPing *ping = (SpiceMsgPing *)message;
+ uint64_t roundtrip;
+ struct timespec ts;
+
+ clock_gettime(CLOCK_MONOTONIC, &ts);
+ roundtrip = ts.tv_sec * 1000000LL + ts.tv_nsec / 1000LL - ping->timestamp;
+
+ if (ping->id == mcc->net_test_id) {
+ switch (mcc->net_test_stage) {
+ case NET_TEST_STAGE_WARMUP:
+ mcc->net_test_id++;
+ mcc->net_test_stage = NET_TEST_STAGE_LATENCY;
+ mcc->latency = roundtrip;
+ break;
+ case NET_TEST_STAGE_LATENCY:
+ mcc->net_test_id++;
+ mcc->net_test_stage = NET_TEST_STAGE_RATE;
+ mcc->latency = MIN(mcc->latency, roundtrip);
+ break;
+ case NET_TEST_STAGE_RATE:
+ mcc->net_test_id = 0;
+ if (roundtrip <= mcc->latency) {
+ // probably high load on client or server result with incorrect values
+ spice_printerr("net test: invalid values, latency %" PRIu64
+ " roundtrip %" PRIu64 ". assuming high"
+ " bandwidth", mcc->latency, roundtrip);
+ mcc->latency = 0;
+ mcc->net_test_stage = NET_TEST_STAGE_INVALID;
+ red_channel_client_start_connectivity_monitoring(&mcc->base,
+ CLIENT_CONNECTIVITY_TIMEOUT);
+ break;
+ }
+ mcc->bitrate_per_sec = (uint64_t)(NET_TEST_BYTES * 8) * 1000000
+ / (roundtrip - mcc->latency);
+ mcc->net_test_stage = NET_TEST_STAGE_COMPLETE;
+ spice_printerr("net test: latency %f ms, bitrate %"PRIu64" bps (%f Mbps)%s",
+ (double)mcc->latency / 1000,
+ mcc->bitrate_per_sec,
+ (double)mcc->bitrate_per_sec / 1024 / 1024,
+ main_channel_client_is_low_bandwidth(mcc) ? " LOW BANDWIDTH" : "");
+ red_channel_client_start_connectivity_monitoring(&mcc->base,
+ CLIENT_CONNECTIVITY_TIMEOUT);
+ break;
+ default:
+ spice_printerr("invalid net test stage, ping id %d test id %d stage %d",
+ ping->id,
+ mcc->net_test_id,
+ mcc->net_test_stage);
+ mcc->net_test_stage = NET_TEST_STAGE_INVALID;
+ }
+ break;
+ } else {
+ /*
+ * channel client monitors the connectivity using ping-pong messages
+ */
+ red_channel_client_handle_message(rcc, size, type, message);
+ }
+#ifdef RED_STATISTICS
+ reds_update_stat_value(roundtrip);
+#endif
+ break;
+ }
+ case SPICE_MSGC_DISCONNECTING:
+ break;
+ case SPICE_MSGC_MAIN_MIGRATE_END:
+ main_channel_client_handle_migrate_end(mcc);
+ break;
+ default:
+ return red_channel_client_handle_message(rcc, size, type, message);
+ }
+ return TRUE;
+}
+
+static uint8_t *main_channel_alloc_msg_rcv_buf(RedChannelClient *rcc,
+ uint16_t type,
+ uint32_t size)
+{
+ MainChannel *main_chan = SPICE_CONTAINEROF(rcc->channel, MainChannel, base);
+ MainChannelClient *mcc = SPICE_CONTAINEROF(rcc, MainChannelClient, base);
+
+ if (type == SPICE_MSGC_MAIN_AGENT_DATA) {
+ return reds_get_agent_data_buffer(mcc, size);
+ } else {
+ return main_chan->recv_buf;
+ }
+}
+
+static void main_channel_release_msg_rcv_buf(RedChannelClient *rcc,
+ uint16_t type,
+ uint32_t size,
+ uint8_t *msg)
+{
+ if (type == SPICE_MSGC_MAIN_AGENT_DATA) {
+ reds_release_agent_data_buffer(msg);
+ }
+}
+
+static int main_channel_config_socket(RedChannelClient *rcc)
+{
+ return TRUE;
+}
+
+static void main_channel_hold_pipe_item(RedChannelClient *rcc, PipeItem *item)
+{
+}
+
+static int main_channel_handle_migrate_flush_mark(RedChannelClient *rcc)
+{
+ spice_debug(NULL);
+ main_channel_push_migrate_data_item(SPICE_CONTAINEROF(rcc->channel,
+ MainChannel, base));
+ return TRUE;
+}
+
+#ifdef RED_STATISTICS
+static void do_ping_client(MainChannelClient *mcc,
+ const char *opt, int has_interval, int interval)
+{
+ spice_printerr("");
+ if (!opt) {
+ main_channel_client_push_ping(mcc, 0);
+ } else if (!strcmp(opt, "on")) {
+ if (has_interval && interval > 0) {
+ mcc->ping_interval = interval * 1000;
+ }
+ core->timer_start(mcc->ping_timer, mcc->ping_interval);
+ } else if (!strcmp(opt, "off")) {
+ core->timer_cancel(mcc->ping_timer);
+ } else {
+ return;
+ }
+}
+
+static void ping_timer_cb(void *opaque)
+{
+ MainChannelClient *mcc = opaque;
+
+ if (!red_channel_client_is_connected(&mcc->base)) {
+ spice_printerr("not connected to peer, ping off");
+ core->timer_cancel(mcc->ping_timer);
+ return;
+ }
+ do_ping_client(mcc, NULL, 0, 0);
+ core->timer_start(mcc->ping_timer, mcc->ping_interval);
+}
+#endif /* RED_STATISTICS */
+
+static MainChannelClient *main_channel_client_create(MainChannel *main_chan, RedClient *client,
+ RedsStream *stream, uint32_t connection_id,
+ int num_common_caps, uint32_t *common_caps,
+ int num_caps, uint32_t *caps)
+{
+ MainChannelClient *mcc = (MainChannelClient*)
+ red_channel_client_create(sizeof(MainChannelClient), &main_chan->base,
+ client, stream, FALSE, num_common_caps,
+ common_caps, num_caps, caps);
+ spice_assert(mcc != NULL);
+ mcc->connection_id = connection_id;
+ mcc->bitrate_per_sec = ~0;
+#ifdef RED_STATISTICS
+ if (!(mcc->ping_timer = core->timer_add(ping_timer_cb, NULL))) {
+ spice_error("ping timer create failed");
+ }
+ mcc->ping_interval = PING_INTERVAL;
+#endif
+ return mcc;
+}
+
+MainChannelClient *main_channel_link(MainChannel *channel, RedClient *client,
+ RedsStream *stream, uint32_t connection_id, int migration,
+ int num_common_caps, uint32_t *common_caps, int num_caps,
+ uint32_t *caps)
+{
+ MainChannelClient *mcc;
+
+ spice_assert(channel);
+
+ // TODO - migration - I removed it from channel creation, now put it
+ // into usage somewhere (not an issue until we return migration to it's
+ // former glory)
+ spice_printerr("add main channel client");
+ mcc = main_channel_client_create(channel, client, stream, connection_id,
+ num_common_caps, common_caps,
+ num_caps, caps);
+ return mcc;
+}
+
+int main_channel_getsockname(MainChannel *main_chan, struct sockaddr *sa, socklen_t *salen)
+{
+ return main_chan ? getsockname(red_channel_get_first_socket(&main_chan->base), sa, salen) : -1;
+}
+
+int main_channel_getpeername(MainChannel *main_chan, struct sockaddr *sa, socklen_t *salen)
+{
+ return main_chan ? getpeername(red_channel_get_first_socket(&main_chan->base), sa, salen) : -1;
+}
+
+// TODO: ? shouldn't it disonnect all clients? or shutdown all main_channels?
+void main_channel_close(MainChannel *main_chan)
+{
+ int socketfd;
+
+ if (main_chan && (socketfd = red_channel_get_first_socket(&main_chan->base)) != -1) {
+ close(socketfd);
+ }
+}
+
+int main_channel_client_is_network_info_initialized(MainChannelClient *mcc)
+{
+ return mcc->net_test_stage == NET_TEST_STAGE_COMPLETE;
+}
+
+int main_channel_client_is_low_bandwidth(MainChannelClient *mcc)
+{
+ // TODO: configurable?
+ return mcc->bitrate_per_sec < 10 * 1024 * 1024;
+}
+
+uint64_t main_channel_client_get_bitrate_per_sec(MainChannelClient *mcc)
+{
+ return mcc->bitrate_per_sec;
+}
+
+uint64_t main_channel_client_get_roundtrip_ms(MainChannelClient *mcc)
+{
+ return mcc->latency / 1000;
+}
+
+static void main_channel_client_migrate(RedChannelClient *rcc)
+{
+ reds_on_main_channel_migrate(SPICE_CONTAINEROF(rcc, MainChannelClient, base));
+ red_channel_client_default_migrate(rcc);
+}
+
+MainChannel* main_channel_init(void)
+{
+ RedChannel *channel;
+ ChannelCbs channel_cbs = { NULL, };
+ ClientCbs client_cbs = {NULL, };
+
+ channel_cbs.config_socket = main_channel_config_socket;
+ channel_cbs.on_disconnect = main_channel_client_on_disconnect;
+ channel_cbs.send_item = main_channel_send_item;
+ channel_cbs.hold_item = main_channel_hold_pipe_item;
+ channel_cbs.release_item = main_channel_release_pipe_item;
+ channel_cbs.alloc_recv_buf = main_channel_alloc_msg_rcv_buf;
+ channel_cbs.release_recv_buf = main_channel_release_msg_rcv_buf;
+ channel_cbs.handle_migrate_flush_mark = main_channel_handle_migrate_flush_mark;
+ channel_cbs.handle_migrate_data = main_channel_handle_migrate_data;
+
+ // TODO: set the migration flag of the channel
+ channel = red_channel_create_parser(sizeof(MainChannel), core,
+ SPICE_CHANNEL_MAIN, 0,
+ FALSE, /* handle_acks */
+ spice_get_client_channel_parser(SPICE_CHANNEL_MAIN, NULL),
+ main_channel_handle_parsed,
+ &channel_cbs,
+ SPICE_MIGRATE_NEED_FLUSH | SPICE_MIGRATE_NEED_DATA_TRANSFER);
+ spice_assert(channel);
+ red_channel_set_cap(channel, SPICE_MAIN_CAP_SEMI_SEAMLESS_MIGRATE);
+ red_channel_set_cap(channel, SPICE_MAIN_CAP_SEAMLESS_MIGRATE);
+
+ client_cbs.migrate = main_channel_client_migrate;
+ red_channel_register_client_cbs(channel, &client_cbs);
+
+ return (MainChannel *)channel;
+}
+
+RedChannelClient* main_channel_client_get_base(MainChannelClient* mcc)
+{
+ spice_assert(mcc);
+ return &mcc->base;
+}
+
+static int main_channel_connect_semi_seamless(MainChannel *main_channel)
+{
+ RingItem *client_link;
+
+ RING_FOREACH(client_link, &main_channel->base.clients) {
+ MainChannelClient * mcc = SPICE_CONTAINEROF(client_link, MainChannelClient,
+ base.channel_link);
+ if (red_channel_client_test_remote_cap(&mcc->base,
+ SPICE_MAIN_CAP_SEMI_SEAMLESS_MIGRATE)) {
+ if (red_client_during_migrate_at_target(mcc->base.client)) {
+ spice_printerr("client %p: wait till previous migration completes", mcc->base.client);
+ mcc->mig_wait_prev_complete = TRUE;
+ mcc->mig_wait_prev_try_seamless = FALSE;
+ } else {
+ red_channel_client_pipe_add_type(&mcc->base,
+ PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN);
+ mcc->mig_wait_connect = TRUE;
+ }
+ mcc->mig_connect_ok = FALSE;
+ main_channel->num_clients_mig_wait++;
+ }
+ }
+ return main_channel->num_clients_mig_wait;
+}
+
+static int main_channel_connect_seamless(MainChannel *main_channel)
+{
+ RingItem *client_link;
+
+ spice_assert(main_channel->base.clients_num == 1);
+
+ RING_FOREACH(client_link, &main_channel->base.clients) {
+ MainChannelClient * mcc = SPICE_CONTAINEROF(client_link, MainChannelClient,
+ base.channel_link);
+ spice_assert(red_channel_client_test_remote_cap(&mcc->base,
+ SPICE_MAIN_CAP_SEAMLESS_MIGRATE));
+ if (red_client_during_migrate_at_target(mcc->base.client)) {
+ spice_printerr("client %p: wait till previous migration completes", mcc->base.client);
+ mcc->mig_wait_prev_complete = TRUE;
+ mcc->mig_wait_prev_try_seamless = TRUE;
+ } else {
+ red_channel_client_pipe_add_type(&mcc->base,
+ PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN_SEAMLESS);
+ mcc->mig_wait_connect = TRUE;
+ }
+ mcc->mig_connect_ok = FALSE;
+ main_channel->num_clients_mig_wait++;
+ }
+ return main_channel->num_clients_mig_wait;
+}
+
+int main_channel_migrate_connect(MainChannel *main_channel, RedsMigSpice *mig_target,
+ int try_seamless)
+{
+ main_channel_fill_mig_target(main_channel, mig_target);
+ main_channel->num_clients_mig_wait = 0;
+
+ if (!main_channel_is_connected(main_channel)) {
+ return 0;
+ }
+
+ if (!try_seamless) {
+ return main_channel_connect_semi_seamless(main_channel);
+ } else {
+ RingItem *client_item;
+ MainChannelClient *mcc;
+
+ client_item = ring_get_head(&main_channel->base.clients);
+ mcc = SPICE_CONTAINEROF(client_item, MainChannelClient, base.channel_link);
+
+ if (!red_channel_client_test_remote_cap(&mcc->base,
+ SPICE_MAIN_CAP_SEAMLESS_MIGRATE)) {
+ return main_channel_connect_semi_seamless(main_channel);
+ } else {
+ return main_channel_connect_seamless(main_channel);
+ }
+ }
+
+}
+
+void main_channel_migrate_cancel_wait(MainChannel *main_chan)
+{
+ RingItem *client_link;
+
+ RING_FOREACH(client_link, &main_chan->base.clients) {
+ MainChannelClient *mcc;
+
+ mcc = SPICE_CONTAINEROF(client_link, MainChannelClient, base.channel_link);
+ if (mcc->mig_wait_connect) {
+ spice_printerr("client %p cancel wait connect", mcc->base.client);
+ mcc->mig_wait_connect = FALSE;
+ mcc->mig_connect_ok = FALSE;
+ }
+ mcc->mig_wait_prev_complete = FALSE;
+ }
+ main_chan->num_clients_mig_wait = 0;
+}
+
+int main_channel_migrate_src_complete(MainChannel *main_chan, int success)
+{
+ RingItem *client_link;
+ int semi_seamless_count = 0;
+
+ spice_printerr("");
+
+ if (ring_is_empty(&main_chan->base.clients)) {
+ spice_printerr("no peer connected");
+ return 0;
+ }
+
+ RING_FOREACH(client_link, &main_chan->base.clients) {
+ MainChannelClient *mcc;
+ int semi_seamless_support;
+
+ mcc = SPICE_CONTAINEROF(client_link, MainChannelClient, base.channel_link);
+ semi_seamless_support = red_channel_client_test_remote_cap(&mcc->base,
+ SPICE_MAIN_CAP_SEMI_SEAMLESS_MIGRATE);
+ if (semi_seamless_support && mcc->mig_connect_ok) {
+ if (success) {
+ spice_printerr("client %p MIGRATE_END", mcc->base.client);
+ red_channel_client_pipe_add_empty_msg(&mcc->base, SPICE_MSG_MAIN_MIGRATE_END);
+ semi_seamless_count++;
+ } else {
+ spice_printerr("client %p MIGRATE_CANCEL", mcc->base.client);
+ red_channel_client_pipe_add_empty_msg(&mcc->base, SPICE_MSG_MAIN_MIGRATE_CANCEL);
+ }
+ } else {
+ if (success) {
+ spice_printerr("client %p SWITCH_HOST", mcc->base.client);
+ red_channel_client_pipe_add_type(&mcc->base, PIPE_ITEM_TYPE_MAIN_MIGRATE_SWITCH_HOST);
+ }
+ }
+ mcc->mig_connect_ok = FALSE;
+ mcc->mig_wait_connect = FALSE;
+ }
+ return semi_seamless_count;
+}
diff --git a/server/main-channel.h b/server/main-channel.h
new file mode 100644
index 0000000..9bd20f1
--- /dev/null
+++ b/server/main-channel.h
@@ -0,0 +1,103 @@
+/*
+ Copyright (C) 2009 Red Hat, Inc.
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef __MAIN_CHANNEL_H__
+#define __MAIN_CHANNEL_H__
+
+#include <stdint.h>
+#include <spice/vd_agent.h>
+#include "common/marshaller.h"
+#include "red_channel.h"
+
+// TODO: Defines used to calculate receive buffer size, and also by reds.c
+// other options: is to make a reds_main_consts.h, to duplicate defines.
+#define REDS_AGENT_WINDOW_SIZE 10
+#define REDS_NUM_INTERNAL_AGENT_MESSAGES 1
+
+// approximate max receive message size for main channel
+#define MAIN_CHANNEL_RECEIVE_BUF_SIZE \
+ (4096 + (REDS_AGENT_WINDOW_SIZE + REDS_NUM_INTERNAL_AGENT_MESSAGES) * SPICE_AGENT_MAX_DATA_SIZE)
+
+struct RedsMigSpice {
+ char *host;
+ char *cert_subject;
+ int port;
+ int sport;
+};
+typedef struct RedsMigSpice RedsMigSpice;
+
+typedef struct MainChannel {
+ RedChannel base;
+ uint8_t recv_buf[MAIN_CHANNEL_RECEIVE_BUF_SIZE];
+ RedsMigSpice mig_target; // TODO: add refs and release (afrer all clients completed migration in one way or the other?)
+ int num_clients_mig_wait;
+} MainChannel;
+
+
+MainChannel *main_channel_init(void);
+RedClient *main_channel_get_client_by_link_id(MainChannel *main_chan, uint32_t link_id);
+/* This is a 'clone' from the reds.h Channel.link callback to allow passing link_id */
+MainChannelClient *main_channel_link(MainChannel *, RedClient *client,
+ RedsStream *stream, uint32_t link_id, int migration, int num_common_caps,
+ uint32_t *common_caps, int num_caps, uint32_t *caps);
+void main_channel_close(MainChannel *main_chan); // not destroy, just socket close
+void main_channel_push_mouse_mode(MainChannel *main_chan, int current_mode, int is_client_mouse_allowed);
+void main_channel_push_agent_connected(MainChannel *main_chan);
+void main_channel_push_agent_disconnected(MainChannel *main_chan);
+void main_channel_client_push_agent_tokens(MainChannelClient *mcc, uint32_t num_tokens);
+void main_channel_client_push_agent_data(MainChannelClient *mcc, uint8_t* data, size_t len,
+ spice_marshaller_item_free_func free_data, void *opaque);
+void main_channel_client_start_net_test(MainChannelClient *mcc, int test_rate);
+// TODO: huge. Consider making a reds_* interface for these functions
+// and calling from main.
+void main_channel_push_init(MainChannelClient *mcc, int display_channels_hint,
+ int current_mouse_mode, int is_client_mouse_allowed, int multi_media_time,
+ int ram_hint);
+void main_channel_client_push_notify(MainChannelClient *mcc, const char *msg);
+void main_channel_push_multi_media_time(MainChannel *main_chan, int time);
+int main_channel_getsockname(MainChannel *main_chan, struct sockaddr *sa, socklen_t *salen);
+int main_channel_getpeername(MainChannel *main_chan, struct sockaddr *sa, socklen_t *salen);
+
+/*
+ * return TRUE if network test had been completed successfully.
+ * If FALSE, bitrate_per_sec is set to MAX_UINT64 and the roundtrip is set to 0
+ */
+int main_channel_client_is_network_info_initialized(MainChannelClient *mcc);
+int main_channel_client_is_low_bandwidth(MainChannelClient *mcc);
+uint64_t main_channel_client_get_bitrate_per_sec(MainChannelClient *mcc);
+uint64_t main_channel_client_get_roundtrip_ms(MainChannelClient *mcc);
+
+int main_channel_is_connected(MainChannel *main_chan);
+RedChannelClient* main_channel_client_get_base(MainChannelClient* mcc);
+
+/* switch host migration */
+void main_channel_migrate_switch(MainChannel *main_chan, RedsMigSpice *mig_target);
+
+/* semi seamless migration */
+
+/* returns the number of clients that we are waiting for their connection.
+ * try_seamless = 'true' when the seamless-migration=on in qemu command line */
+int main_channel_migrate_connect(MainChannel *main_channel, RedsMigSpice *mig_target,
+ int try_seamless);
+void main_channel_migrate_cancel_wait(MainChannel *main_chan);
+/* returns the number of clients for which SPICE_MSG_MAIN_MIGRATE_END was sent*/
+int main_channel_migrate_src_complete(MainChannel *main_chan, int success);
+void main_channel_migrate_dst_complete(MainChannelClient *mcc);
+void main_channel_push_name(MainChannelClient *mcc, const char *name);
+void main_channel_push_uuid(MainChannelClient *mcc, const uint8_t uuid[16]);
+
+#endif
diff --git a/server/main-dispatcher.c b/server/main-dispatcher.c
new file mode 100644
index 0000000..eb7cee6
--- /dev/null
+++ b/server/main-dispatcher.c
@@ -0,0 +1,217 @@
+/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ Copyright (C) 2009-2015 Red Hat, Inc.
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, see <http://www.gnu.org/licenses/>.
+*/
+#include <config.h>
+#include <unistd.h>
+#include <string.h>
+#include <errno.h>
+#include <pthread.h>
+
+#include "red_common.h"
+#include "dispatcher.h"
+#include "main-dispatcher.h"
+#include "red_channel.h"
+#include "reds.h"
+
+/*
+ * Main Dispatcher
+ * ===============
+ *
+ * Communication channel between any non main thread and the main thread.
+ *
+ * The main thread is that from which spice_server_init is called.
+ *
+ * Messages are single sized, sent from the non-main thread to the main-thread.
+ * No acknowledge is sent back. This prevents a possible deadlock with the main
+ * thread already waiting on a response for the existing red_dispatcher used
+ * by the worker thread.
+ *
+ * All events have three functions:
+ * main_dispatcher_<event_name> - non static, public function
+ * main_dispatcher_self_<event_name> - handler for main thread
+ * main_dispatcher_handle_<event_name> - handler for callback from main thread
+ * seperate from self because it may send an ack or do other work in the future.
+ */
+
+typedef struct {
+ Dispatcher base;
+ SpiceCoreInterface *core;
+} MainDispatcher;
+
+MainDispatcher main_dispatcher;
+
+enum {
+ MAIN_DISPATCHER_CHANNEL_EVENT = 0,
+ MAIN_DISPATCHER_MIGRATE_SEAMLESS_DST_COMPLETE,
+ MAIN_DISPATCHER_SET_MM_TIME_LATENCY,
+ MAIN_DISPATCHER_CLIENT_DISCONNECT,
+
+ MAIN_DISPATCHER_NUM_MESSAGES
+};
+
+typedef struct MainDispatcherChannelEventMessage {
+ int event;
+ SpiceChannelEventInfo *info;
+} MainDispatcherChannelEventMessage;
+
+typedef struct MainDispatcherMigrateSeamlessDstCompleteMessage {
+ RedClient *client;
+} MainDispatcherMigrateSeamlessDstCompleteMessage;
+
+typedef struct MainDispatcherMmTimeLatencyMessage {
+ RedClient *client;
+ uint32_t latency;
+} MainDispatcherMmTimeLatencyMessage;
+
+typedef struct MainDispatcherClientDisconnectMessage {
+ RedClient *client;
+} MainDispatcherClientDisconnectMessage;
+
+/* channel_event - calls core->channel_event, must be done in main thread */
+static void main_dispatcher_self_handle_channel_event(
+ int event,
+ SpiceChannelEventInfo *info)
+{
+ reds_handle_channel_event(event, info);
+}
+
+static void main_dispatcher_handle_channel_event(void *opaque,
+ void *payload)
+{
+ MainDispatcherChannelEventMessage *channel_event = payload;
+
+ main_dispatcher_self_handle_channel_event(channel_event->event,
+ channel_event->info);
+}
+
+void main_dispatcher_channel_event(int event, SpiceChannelEventInfo *info)
+{
+ MainDispatcherChannelEventMessage msg = {0,};
+
+ if (pthread_self() == main_dispatcher.base.self) {
+ main_dispatcher_self_handle_channel_event(event, info);
+ return;
+ }
+ msg.event = event;
+ msg.info = info;
+ dispatcher_send_message(&main_dispatcher.base, MAIN_DISPATCHER_CHANNEL_EVENT,
+ &msg);
+}
+
+
+static void main_dispatcher_handle_migrate_complete(void *opaque,
+ void *payload)
+{
+ MainDispatcherMigrateSeamlessDstCompleteMessage *mig_complete = payload;
+
+ reds_on_client_seamless_migrate_complete(mig_complete->client);
+ red_client_unref(mig_complete->client);
+}
+
+static void main_dispatcher_handle_mm_time_latency(void *opaque,
+ void *payload)
+{
+ MainDispatcherMmTimeLatencyMessage *msg = payload;
+ reds_set_client_mm_time_latency(msg->client, msg->latency);
+ red_client_unref(msg->client);
+}
+
+static void main_dispatcher_handle_client_disconnect(void *opaque,
+ void *payload)
+{
+ MainDispatcherClientDisconnectMessage *msg = payload;
+
+ spice_debug("client=%p", msg->client);
+ reds_client_disconnect(msg->client);
+ red_client_unref(msg->client);
+}
+
+void main_dispatcher_seamless_migrate_dst_complete(RedClient *client)
+{
+ MainDispatcherMigrateSeamlessDstCompleteMessage msg;
+
+ if (pthread_self() == main_dispatcher.base.self) {
+ reds_on_client_seamless_migrate_complete(client);
+ return;
+ }
+
+ msg.client = red_client_ref(client);
+ dispatcher_send_message(&main_dispatcher.base, MAIN_DISPATCHER_MIGRATE_SEAMLESS_DST_COMPLETE,
+ &msg);
+}
+
+void main_dispatcher_set_mm_time_latency(RedClient *client, uint32_t latency)
+{
+ MainDispatcherMmTimeLatencyMessage msg;
+
+ if (pthread_self() == main_dispatcher.base.self) {
+ reds_set_client_mm_time_latency(client, latency);
+ return;
+ }
+
+ msg.client = red_client_ref(client);
+ msg.latency = latency;
+ dispatcher_send_message(&main_dispatcher.base, MAIN_DISPATCHER_SET_MM_TIME_LATENCY,
+ &msg);
+}
+
+void main_dispatcher_client_disconnect(RedClient *client)
+{
+ MainDispatcherClientDisconnectMessage msg;
+
+ if (!client->disconnecting) {
+ spice_debug("client %p", client);
+ msg.client = red_client_ref(client);
+ dispatcher_send_message(&main_dispatcher.base, MAIN_DISPATCHER_CLIENT_DISCONNECT,
+ &msg);
+ } else {
+ spice_debug("client %p already during disconnection", client);
+ }
+}
+
+static void dispatcher_handle_read(int fd, int event, void *opaque)
+{
+ Dispatcher *dispatcher = opaque;
+
+ dispatcher_handle_recv_read(dispatcher);
+}
+
+/*
+ * FIXME:
+ * Reds routines shouldn't be exposed. Instead reds.c should register the callbacks,
+ * and the corresponding operations should be made only via main_dispatcher.
+ */
+void main_dispatcher_init(SpiceCoreInterface *core)
+{
+ memset(&main_dispatcher, 0, sizeof(main_dispatcher));
+ main_dispatcher.core = core;
+ dispatcher_init(&main_dispatcher.base, MAIN_DISPATCHER_NUM_MESSAGES, &main_dispatcher.base);
+ core->watch_add(main_dispatcher.base.recv_fd, SPICE_WATCH_EVENT_READ,
+ dispatcher_handle_read, &main_dispatcher.base);
+ dispatcher_register_handler(&main_dispatcher.base, MAIN_DISPATCHER_CHANNEL_EVENT,
+ main_dispatcher_handle_channel_event,
+ sizeof(MainDispatcherChannelEventMessage), 0 /* no ack */);
+ dispatcher_register_handler(&main_dispatcher.base, MAIN_DISPATCHER_MIGRATE_SEAMLESS_DST_COMPLETE,
+ main_dispatcher_handle_migrate_complete,
+ sizeof(MainDispatcherMigrateSeamlessDstCompleteMessage), 0 /* no ack */);
+ dispatcher_register_handler(&main_dispatcher.base, MAIN_DISPATCHER_SET_MM_TIME_LATENCY,
+ main_dispatcher_handle_mm_time_latency,
+ sizeof(MainDispatcherMmTimeLatencyMessage), 0 /* no ack */);
+ dispatcher_register_handler(&main_dispatcher.base, MAIN_DISPATCHER_CLIENT_DISCONNECT,
+ main_dispatcher_handle_client_disconnect,
+ sizeof(MainDispatcherClientDisconnectMessage), 0 /* no ack */);
+}
diff --git a/server/main-dispatcher.h b/server/main-dispatcher.h
new file mode 100644
index 0000000..af40093
--- /dev/null
+++ b/server/main-dispatcher.h
@@ -0,0 +1,36 @@
+/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ Copyright (C) 2009-2015 Red Hat, Inc.
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, see <http://www.gnu.org/licenses/>.
+*/
+#ifndef MAIN_DISPATCHER_H
+#define MAIN_DISPATCHER_H
+
+#include <spice.h>
+#include "red_channel.h"
+
+void main_dispatcher_channel_event(int event, SpiceChannelEventInfo *info);
+void main_dispatcher_seamless_migrate_dst_complete(RedClient *client);
+void main_dispatcher_set_mm_time_latency(RedClient *client, uint32_t latency);
+/*
+ * Disconnecting the client is always executed asynchronously,
+ * in order to protect from expired references in the routines
+ * that triggered the client destruction.
+ */
+void main_dispatcher_client_disconnect(RedClient *client);
+
+void main_dispatcher_init(SpiceCoreInterface *core);
+
+#endif //MAIN_DISPATCHER_H
diff --git a/server/main_channel.c b/server/main_channel.c
deleted file mode 100644
index 1af6baa..0000000
--- a/server/main_channel.c
+++ /dev/null
@@ -1,1345 +0,0 @@
-/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- Copyright (C) 2009 Red Hat, Inc.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, see <http://www.gnu.org/licenses/>.
-*/
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#include <inttypes.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <unistd.h>
-#include <sys/socket.h>
-#include <netinet/in.h>
-#include <netinet/tcp.h>
-#include <arpa/inet.h>
-#include <netdb.h>
-#include <limits.h>
-#include <time.h>
-#include <pthread.h>
-#include <sys/mman.h>
-#include <fcntl.h>
-#include <errno.h>
-#include <ctype.h>
-
-#include "common/generated_server_marshallers.h"
-#include "common/messages.h"
-#include "common/ring.h"
-
-#include "demarshallers.h"
-#include "main_channel.h"
-#include "red_channel.h"
-#include "red_common.h"
-#include "reds.h"
-#include "migration_protocol.h"
-#include "main_dispatcher.h"
-#include "utils.h"
-
-#define ZERO_BUF_SIZE 4096
-
-#define NET_TEST_WARMUP_BYTES 0
-#define NET_TEST_BYTES (1024 * 250)
-
-#define PING_INTERVAL (1000 * 10)
-
-#define CLIENT_CONNECTIVITY_TIMEOUT (30*1000) // 30 seconds
-
-static uint8_t zero_page[ZERO_BUF_SIZE] = {0};
-
-enum {
- PIPE_ITEM_TYPE_MAIN_CHANNELS_LIST = PIPE_ITEM_TYPE_CHANNEL_BASE,
- PIPE_ITEM_TYPE_MAIN_PING,
- PIPE_ITEM_TYPE_MAIN_MOUSE_MODE,
- PIPE_ITEM_TYPE_MAIN_AGENT_DISCONNECTED,
- PIPE_ITEM_TYPE_MAIN_AGENT_TOKEN,
- PIPE_ITEM_TYPE_MAIN_AGENT_DATA,
- PIPE_ITEM_TYPE_MAIN_MIGRATE_DATA,
- PIPE_ITEM_TYPE_MAIN_INIT,
- PIPE_ITEM_TYPE_MAIN_NOTIFY,
- PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN,
- PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN_SEAMLESS,
- PIPE_ITEM_TYPE_MAIN_MIGRATE_SWITCH_HOST,
- PIPE_ITEM_TYPE_MAIN_MULTI_MEDIA_TIME,
- PIPE_ITEM_TYPE_MAIN_NAME,
- PIPE_ITEM_TYPE_MAIN_UUID,
- PIPE_ITEM_TYPE_MAIN_AGENT_CONNECTED_TOKENS,
-};
-
-typedef struct RefsPipeItem {
- PipeItem base;
- int *refs;
-} RefsPipeItem;
-
-typedef struct PingPipeItem {
- PipeItem base;
- int size;
-} PingPipeItem;
-
-typedef struct MouseModePipeItem {
- PipeItem base;
- int current_mode;
- int is_client_mouse_allowed;
-} MouseModePipeItem;
-
-typedef struct TokensPipeItem {
- PipeItem base;
- int tokens;
-} TokensPipeItem;
-
-typedef struct AgentDataPipeItem {
- PipeItem base;
- uint8_t* data;
- size_t len;
- spice_marshaller_item_free_func free_data;
- void *opaque;
-} AgentDataPipeItem;
-
-typedef struct InitPipeItem {
- PipeItem base;
- int connection_id;
- int display_channels_hint;
- int current_mouse_mode;
- int is_client_mouse_allowed;
- int multi_media_time;
- int ram_hint;
-} InitPipeItem;
-
-typedef struct NamePipeItem {
- PipeItem base;
- SpiceMsgMainName msg;
-} NamePipeItem;
-
-typedef struct UuidPipeItem {
- PipeItem base;
- SpiceMsgMainUuid msg;
-} UuidPipeItem;
-
-typedef struct NotifyPipeItem {
- PipeItem base;
- char *msg;
-} NotifyPipeItem;
-
-typedef struct MultiMediaTimePipeItem {
- PipeItem base;
- int time;
-} MultiMediaTimePipeItem;
-
-struct MainChannelClient {
- RedChannelClient base;
- uint32_t connection_id;
- uint32_t ping_id;
- uint32_t net_test_id;
- int net_test_stage;
- uint64_t latency;
- uint64_t bitrate_per_sec;
-#ifdef RED_STATISTICS
- SpiceTimer *ping_timer;
- int ping_interval;
-#endif
- int mig_wait_connect;
- int mig_connect_ok;
- int mig_wait_prev_complete;
- int mig_wait_prev_try_seamless;
- int init_sent;
- int seamless_mig_dst;
-};
-
-enum NetTestStage {
- NET_TEST_STAGE_INVALID,
- NET_TEST_STAGE_WARMUP,
- NET_TEST_STAGE_LATENCY,
- NET_TEST_STAGE_RATE,
- NET_TEST_STAGE_COMPLETE,
-};
-
-static void main_channel_release_pipe_item(RedChannelClient *rcc,
- PipeItem *base, int item_pushed);
-
-int main_channel_is_connected(MainChannel *main_chan)
-{
- return red_channel_is_connected(&main_chan->base);
-}
-
-/*
- * When the main channel is disconnected, disconnect the entire client.
- */
-static void main_channel_client_on_disconnect(RedChannelClient *rcc)
-{
- spice_printerr("rcc=%p", rcc);
- main_dispatcher_client_disconnect(rcc->client);
-}
-
-RedClient *main_channel_get_client_by_link_id(MainChannel *main_chan, uint32_t connection_id)
-{
- RingItem *link;
- MainChannelClient *mcc;
-
- RING_FOREACH(link, &main_chan->base.clients) {
- mcc = SPICE_CONTAINEROF(link, MainChannelClient, base.channel_link);
- if (mcc->connection_id == connection_id) {
- return mcc->base.client;
- }
- }
- return NULL;
-}
-
-static int main_channel_client_push_ping(MainChannelClient *mcc, int size);
-
-void main_channel_client_start_net_test(MainChannelClient *mcc, int test_rate)
-{
- if (!mcc || mcc->net_test_id) {
- return;
- }
- if (test_rate) {
- if (main_channel_client_push_ping(mcc, NET_TEST_WARMUP_BYTES)
- && main_channel_client_push_ping(mcc, 0)
- && main_channel_client_push_ping(mcc, NET_TEST_BYTES)) {
- mcc->net_test_id = mcc->ping_id - 2;
- mcc->net_test_stage = NET_TEST_STAGE_WARMUP;
- }
- } else {
- red_channel_client_start_connectivity_monitoring(&mcc->base, CLIENT_CONNECTIVITY_TIMEOUT);
- }
-}
-
-typedef struct MainMouseModeItemInfo {
- int current_mode;
- int is_client_mouse_allowed;
-} MainMouseModeItemInfo;
-
-static PipeItem *main_mouse_mode_item_new(RedChannelClient *rcc, void *data, int num)
-{
- MouseModePipeItem *item = spice_malloc(sizeof(MouseModePipeItem));
- MainMouseModeItemInfo *info = data;
-
- red_channel_pipe_item_init(rcc->channel, &item->base,
- PIPE_ITEM_TYPE_MAIN_MOUSE_MODE);
- item->current_mode = info->current_mode;
- item->is_client_mouse_allowed = info->is_client_mouse_allowed;
- return &item->base;
-}
-
-static PipeItem *main_ping_item_new(MainChannelClient *mcc, int size)
-{
- PingPipeItem *item = spice_malloc(sizeof(PingPipeItem));
-
- red_channel_pipe_item_init(mcc->base.channel, &item->base, PIPE_ITEM_TYPE_MAIN_PING);
- item->size = size;
- return &item->base;
-}
-
-static PipeItem *main_agent_tokens_item_new(RedChannelClient *rcc, uint32_t num_tokens)
-{
- TokensPipeItem *item = spice_malloc(sizeof(TokensPipeItem));
-
- red_channel_pipe_item_init(rcc->channel, &item->base,
- PIPE_ITEM_TYPE_MAIN_AGENT_TOKEN);
- item->tokens = num_tokens;
- return &item->base;
-}
-
-static PipeItem *main_agent_data_item_new(RedChannelClient *rcc, uint8_t* data, size_t len,
- spice_marshaller_item_free_func free_data,
- void *opaque)
-{
- AgentDataPipeItem *item = spice_malloc(sizeof(AgentDataPipeItem));
-
- red_channel_pipe_item_init(rcc->channel, &item->base,
- PIPE_ITEM_TYPE_MAIN_AGENT_DATA);
- item->data = data;
- item->len = len;
- item->free_data = free_data;
- item->opaque = opaque;
- return &item->base;
-}
-
-static PipeItem *main_init_item_new(MainChannelClient *mcc,
- int connection_id, int display_channels_hint, int current_mouse_mode,
- int is_client_mouse_allowed, int multi_media_time,
- int ram_hint)
-{
- InitPipeItem *item = spice_malloc(sizeof(InitPipeItem));
-
- red_channel_pipe_item_init(mcc->base.channel, &item->base,
- PIPE_ITEM_TYPE_MAIN_INIT);
- item->connection_id = connection_id;
- item->display_channels_hint = display_channels_hint;
- item->current_mouse_mode = current_mouse_mode;
- item->is_client_mouse_allowed = is_client_mouse_allowed;
- item->multi_media_time = multi_media_time;
- item->ram_hint = ram_hint;
- return &item->base;
-}
-
-static PipeItem *main_name_item_new(MainChannelClient *mcc, const char *name)
-{
- NamePipeItem *item = spice_malloc(sizeof(NamePipeItem) + strlen(name) + 1);
-
- red_channel_pipe_item_init(mcc->base.channel, &item->base,
- PIPE_ITEM_TYPE_MAIN_NAME);
- item->msg.name_len = strlen(name) + 1;
- memcpy(&item->msg.name, name, item->msg.name_len);
-
- return &item->base;
-}
-
-static PipeItem *main_uuid_item_new(MainChannelClient *mcc, const uint8_t uuid[16])
-{
- UuidPipeItem *item = spice_malloc(sizeof(UuidPipeItem));
-
- red_channel_pipe_item_init(mcc->base.channel, &item->base,
- PIPE_ITEM_TYPE_MAIN_UUID);
- memcpy(item->msg.uuid, uuid, sizeof(item->msg.uuid));
-
- return &item->base;
-}
-
-static PipeItem *main_notify_item_new(RedChannelClient *rcc, void *data, int num)
-{
- NotifyPipeItem *item = spice_malloc(sizeof(NotifyPipeItem));
- const char *msg = data;
-
- red_channel_pipe_item_init(rcc->channel, &item->base,
- PIPE_ITEM_TYPE_MAIN_NOTIFY);
- item->msg = spice_strdup(msg);
- return &item->base;
-}
-
-static PipeItem *main_multi_media_time_item_new(
- RedChannelClient *rcc, void *data, int num)
-{
- MultiMediaTimePipeItem *item, *info = data;
-
- item = spice_malloc(sizeof(MultiMediaTimePipeItem));
- red_channel_pipe_item_init(rcc->channel, &item->base,
- PIPE_ITEM_TYPE_MAIN_MULTI_MEDIA_TIME);
- item->time = info->time;
- return &item->base;
-}
-
-static void main_channel_push_channels(MainChannelClient *mcc)
-{
- if (red_client_during_migrate_at_target(mcc->base.client)) {
- spice_printerr("warning: ignoring unexpected SPICE_MSGC_MAIN_ATTACH_CHANNELS"
- "during migration");
- return;
- }
- red_channel_client_pipe_add_type(&mcc->base, PIPE_ITEM_TYPE_MAIN_CHANNELS_LIST);
-}
-
-static void main_channel_marshall_channels(RedChannelClient *rcc,
- SpiceMarshaller *m,
- PipeItem *item)
-{
- SpiceMsgChannels* channels_info;
-
- red_channel_client_init_send_data(rcc, SPICE_MSG_MAIN_CHANNELS_LIST, item);
- channels_info = (SpiceMsgChannels *)spice_malloc(sizeof(SpiceMsgChannels)
- + reds_num_of_channels() * sizeof(SpiceChannelId));
- reds_fill_channels(channels_info);
- spice_marshall_msg_main_channels_list(m, channels_info);
- free(channels_info);
-}
-
-int main_channel_client_push_ping(MainChannelClient *mcc, int size)
-{
- PipeItem *item;
-
- if (mcc == NULL) {
- return FALSE;
- }
- item = main_ping_item_new(mcc, size);
- red_channel_client_pipe_add_push(&mcc->base, item);
- return TRUE;
-}
-
-static void main_channel_marshall_ping(RedChannelClient *rcc,
- SpiceMarshaller *m,
- PingPipeItem *item)
-{
- MainChannelClient *mcc = SPICE_CONTAINEROF(rcc, MainChannelClient, base);
- struct timespec time_space;
- SpiceMsgPing ping;
- int size_left = item->size;
-
- red_channel_client_init_send_data(rcc, SPICE_MSG_PING, &item->base);
- ping.id = ++(mcc->ping_id);
- clock_gettime(CLOCK_MONOTONIC, &time_space);
- ping.timestamp = time_space.tv_sec * 1000000LL + time_space.tv_nsec / 1000LL;
- spice_marshall_msg_ping(m, &ping);
-
- while (size_left > 0) {
- int now = MIN(ZERO_BUF_SIZE, size_left);
- size_left -= now;
- spice_marshaller_add_ref(m, zero_page, now);
- }
-}
-
-void main_channel_push_mouse_mode(MainChannel *main_chan, int current_mode,
- int is_client_mouse_allowed)
-{
- MainMouseModeItemInfo info = {
- .current_mode=current_mode,
- .is_client_mouse_allowed=is_client_mouse_allowed,
- };
-
- red_channel_pipes_new_add_push(&main_chan->base,
- main_mouse_mode_item_new, &info);
-}
-
-static void main_channel_marshall_mouse_mode(RedChannelClient *rcc,
- SpiceMarshaller *m,
- MouseModePipeItem *item)
-{
- SpiceMsgMainMouseMode mouse_mode;
-
- red_channel_client_init_send_data(rcc, SPICE_MSG_MAIN_MOUSE_MODE, &item->base);
- mouse_mode.supported_modes = SPICE_MOUSE_MODE_SERVER;
- if (item->is_client_mouse_allowed) {
- mouse_mode.supported_modes |= SPICE_MOUSE_MODE_CLIENT;
- }
- mouse_mode.current_mode = item->current_mode;
- spice_marshall_msg_main_mouse_mode(m, &mouse_mode);
-}
-
-void main_channel_push_agent_connected(MainChannel *main_chan)
-{
- if (red_channel_test_remote_cap(&main_chan->base, SPICE_MAIN_CAP_AGENT_CONNECTED_TOKENS)) {
- red_channel_pipes_add_type(&main_chan->base, PIPE_ITEM_TYPE_MAIN_AGENT_CONNECTED_TOKENS);
- } else {
- red_channel_pipes_add_empty_msg(&main_chan->base, SPICE_MSG_MAIN_AGENT_CONNECTED);
- }
-}
-
-static void main_channel_marshall_agent_connected(SpiceMarshaller *m,
- RedChannelClient *rcc,
- PipeItem *item)
-{
- SpiceMsgMainAgentConnectedTokens connected;
-
- red_channel_client_init_send_data(rcc, SPICE_MSG_MAIN_AGENT_CONNECTED_TOKENS, item);
- connected.num_tokens = REDS_AGENT_WINDOW_SIZE;
- spice_marshall_msg_main_agent_connected_tokens(m, &connected);
-}
-
-void main_channel_push_agent_disconnected(MainChannel *main_chan)
-{
- red_channel_pipes_add_type(&main_chan->base, PIPE_ITEM_TYPE_MAIN_AGENT_DISCONNECTED);
-}
-
-static void main_channel_marshall_agent_disconnected(RedChannelClient *rcc,
- SpiceMarshaller *m,
- PipeItem *item)
-{
- SpiceMsgMainAgentDisconnect disconnect;
-
- red_channel_client_init_send_data(rcc, SPICE_MSG_MAIN_AGENT_DISCONNECTED, item);
- disconnect.error_code = SPICE_LINK_ERR_OK;
- spice_marshall_msg_main_agent_disconnected(m, &disconnect);
-}
-
-void main_channel_client_push_agent_tokens(MainChannelClient *mcc, uint32_t num_tokens)
-{
- PipeItem *item = main_agent_tokens_item_new(&mcc->base, num_tokens);
-
- red_channel_client_pipe_add_push(&mcc->base, item);
-}
-
-static void main_channel_marshall_tokens(RedChannelClient *rcc,
- SpiceMarshaller *m, TokensPipeItem *item)
-{
- SpiceMsgMainAgentTokens tokens;
-
- red_channel_client_init_send_data(rcc, SPICE_MSG_MAIN_AGENT_TOKEN, &item->base);
- tokens.num_tokens = item->tokens;
- spice_marshall_msg_main_agent_token(m, &tokens);
-}
-
-void main_channel_client_push_agent_data(MainChannelClient *mcc, uint8_t* data, size_t len,
- spice_marshaller_item_free_func free_data, void *opaque)
-{
- PipeItem *item;
-
- item = main_agent_data_item_new(&mcc->base, data, len, free_data, opaque);
- red_channel_client_pipe_add_push(&mcc->base, item);
-}
-
-static void main_channel_marshall_agent_data(RedChannelClient *rcc,
- SpiceMarshaller *m,
- AgentDataPipeItem *item)
-{
- red_channel_client_init_send_data(rcc, SPICE_MSG_MAIN_AGENT_DATA, &item->base);
- spice_marshaller_add_ref(m, item->data, item->len);
-}
-
-static void main_channel_push_migrate_data_item(MainChannel *main_chan)
-{
- red_channel_pipes_add_type(&main_chan->base, PIPE_ITEM_TYPE_MAIN_MIGRATE_DATA);
-}
-
-static void main_channel_marshall_migrate_data_item(RedChannelClient *rcc,
- SpiceMarshaller *m, PipeItem *item)
-{
- red_channel_client_init_send_data(rcc, SPICE_MSG_MIGRATE_DATA, item);
- reds_marshall_migrate_data(m); // TODO: from reds split. ugly separation.
-}
-
-static int main_channel_handle_migrate_data(RedChannelClient *rcc,
- uint32_t size, void *message)
-{
- MainChannelClient *mcc = SPICE_CONTAINEROF(rcc, MainChannelClient, base);
- SpiceMigrateDataHeader *header = (SpiceMigrateDataHeader *)message;
-
- /* not supported with multi-clients */
- spice_assert(rcc->channel->clients_num == 1);
-
- if (size < sizeof(SpiceMigrateDataHeader) + sizeof(SpiceMigrateDataMain)) {
- spice_printerr("bad message size %u", size);
- return FALSE;
- }
- if (!migration_protocol_validate_header(header,
- SPICE_MIGRATE_DATA_MAIN_MAGIC,
- SPICE_MIGRATE_DATA_MAIN_VERSION)) {
- spice_error("bad header");
- return FALSE;
- }
- return reds_handle_migrate_data(mcc, (SpiceMigrateDataMain *)(header + 1), size);
-}
-
-void main_channel_push_init(MainChannelClient *mcc,
- int display_channels_hint, int current_mouse_mode,
- int is_client_mouse_allowed, int multi_media_time,
- int ram_hint)
-{
- PipeItem *item;
-
- item = main_init_item_new(mcc,
- mcc->connection_id, display_channels_hint, current_mouse_mode,
- is_client_mouse_allowed, multi_media_time, ram_hint);
- red_channel_client_pipe_add_push(&mcc->base, item);
-}
-
-static void main_channel_marshall_init(RedChannelClient *rcc,
- SpiceMarshaller *m,
- InitPipeItem *item)
-{
- SpiceMsgMainInit init; // TODO - remove this copy, make InitPipeItem reuse SpiceMsgMainInit
-
-
- red_channel_client_init_send_data(rcc, SPICE_MSG_MAIN_INIT, &item->base);
- init.session_id = item->connection_id;
- init.display_channels_hint = item->display_channels_hint;
- init.current_mouse_mode = item->current_mouse_mode;
- init.supported_mouse_modes = SPICE_MOUSE_MODE_SERVER;
- if (item->is_client_mouse_allowed) {
- init.supported_mouse_modes |= SPICE_MOUSE_MODE_CLIENT;
- }
- init.agent_connected = reds_has_vdagent();
- init.agent_tokens = REDS_AGENT_WINDOW_SIZE;
- init.multi_media_time = item->multi_media_time;
- init.ram_hint = item->ram_hint;
- spice_marshall_msg_main_init(m, &init);
-}
-
-void main_channel_push_name(MainChannelClient *mcc, const char *name)
-{
- PipeItem *item;
-
- if (!red_channel_client_test_remote_cap(&mcc->base,
- SPICE_MAIN_CAP_NAME_AND_UUID))
- return;
-
- item = main_name_item_new(mcc, name);
- red_channel_client_pipe_add_push(&mcc->base, item);
-}
-
-void main_channel_push_uuid(MainChannelClient *mcc, const uint8_t uuid[16])
-{
- PipeItem *item;
-
- if (!red_channel_client_test_remote_cap(&mcc->base,
- SPICE_MAIN_CAP_NAME_AND_UUID))
- return;
-
- item = main_uuid_item_new(mcc, uuid);
- red_channel_client_pipe_add_push(&mcc->base, item);
-}
-
-void main_channel_client_push_notify(MainChannelClient *mcc, const char *msg)
-{
- PipeItem *item = main_notify_item_new(&mcc->base, (void *)msg, 1);
- red_channel_client_pipe_add_push(&mcc->base, item);
-}
-
-static void main_channel_marshall_notify(RedChannelClient *rcc,
- SpiceMarshaller *m, NotifyPipeItem *item)
-{
- SpiceMsgNotify notify;
-
- red_channel_client_init_send_data(rcc, SPICE_MSG_NOTIFY, &item->base);
- notify.time_stamp = red_get_monotonic_time(); // TODO - move to main_new_notify_item
- notify.severity = SPICE_NOTIFY_SEVERITY_WARN;
- notify.visibilty = SPICE_NOTIFY_VISIBILITY_HIGH;
- notify.what = SPICE_WARN_GENERAL;
- notify.message_len = strlen(item->msg);
- spice_marshall_msg_notify(m, ¬ify);
- spice_marshaller_add(m, (uint8_t *)item->msg, notify.message_len + 1);
-}
-
-static void main_channel_fill_migrate_dst_info(MainChannel *main_channel,
- SpiceMigrationDstInfo *dst_info)
-{
- RedsMigSpice *mig_dst = &main_channel->mig_target;
- dst_info->port = mig_dst->port;
- dst_info->sport = mig_dst->sport;
- dst_info->host_size = strlen(mig_dst->host) + 1;
- dst_info->host_data = (uint8_t *)mig_dst->host;
- if (mig_dst->cert_subject) {
- dst_info->cert_subject_size = strlen(mig_dst->cert_subject) + 1;
- dst_info->cert_subject_data = (uint8_t *)mig_dst->cert_subject;
- } else {
- dst_info->cert_subject_size = 0;
- dst_info->cert_subject_data = NULL;
- }
-}
-
-static void main_channel_marshall_migrate_begin(SpiceMarshaller *m, RedChannelClient *rcc,
- PipeItem *item)
-{
- SpiceMsgMainMigrationBegin migrate;
- MainChannel *main_ch;
-
- red_channel_client_init_send_data(rcc, SPICE_MSG_MAIN_MIGRATE_BEGIN, item);
- main_ch = SPICE_CONTAINEROF(rcc->channel, MainChannel, base);
- main_channel_fill_migrate_dst_info(main_ch, &migrate.dst_info);
- spice_marshall_msg_main_migrate_begin(m, &migrate);
-}
-
-static void main_channel_marshall_migrate_begin_seamless(SpiceMarshaller *m,
- RedChannelClient *rcc,
- PipeItem *item)
-{
- SpiceMsgMainMigrateBeginSeamless migrate_seamless;
- MainChannel *main_ch;
-
- red_channel_client_init_send_data(rcc, SPICE_MSG_MAIN_MIGRATE_BEGIN_SEAMLESS, item);
- main_ch = SPICE_CONTAINEROF(rcc->channel, MainChannel, base);
- main_channel_fill_migrate_dst_info(main_ch, &migrate_seamless.dst_info);
- migrate_seamless.src_mig_version = SPICE_MIGRATION_PROTOCOL_VERSION;
- spice_marshall_msg_main_migrate_begin_seamless(m, &migrate_seamless);
-}
-
-void main_channel_push_multi_media_time(MainChannel *main_chan, int time)
-{
- MultiMediaTimePipeItem info = {
- .time = time,
- };
-
- red_channel_pipes_new_add_push(&main_chan->base,
- main_multi_media_time_item_new, &info);
-}
-
-static void main_channel_fill_mig_target(MainChannel *main_channel, RedsMigSpice *mig_target)
-{
- spice_assert(mig_target);
- free(main_channel->mig_target.host);
- main_channel->mig_target.host = spice_strdup(mig_target->host);
- free(main_channel->mig_target.cert_subject);
- if (mig_target->cert_subject) {
- main_channel->mig_target.cert_subject = spice_strdup(mig_target->cert_subject);
- } else {
- main_channel->mig_target.cert_subject = NULL;
- }
- main_channel->mig_target.port = mig_target->port;
- main_channel->mig_target.sport = mig_target->sport;
-}
-
-void main_channel_migrate_switch(MainChannel *main_chan, RedsMigSpice *mig_target)
-{
- main_channel_fill_mig_target(main_chan, mig_target);
- red_channel_pipes_add_type(&main_chan->base, PIPE_ITEM_TYPE_MAIN_MIGRATE_SWITCH_HOST);
-}
-
-static void main_channel_marshall_migrate_switch(SpiceMarshaller *m, RedChannelClient *rcc,
- PipeItem *item)
-{
- SpiceMsgMainMigrationSwitchHost migrate;
- MainChannel *main_ch;
-
- spice_printerr("");
- red_channel_client_init_send_data(rcc, SPICE_MSG_MAIN_MIGRATE_SWITCH_HOST, item);
- main_ch = SPICE_CONTAINEROF(rcc->channel, MainChannel, base);
- migrate.port = main_ch->mig_target.port;
- migrate.sport = main_ch->mig_target.sport;
- migrate.host_size = strlen(main_ch->mig_target.host) + 1;
- migrate.host_data = (uint8_t *)main_ch->mig_target.host;
- if (main_ch->mig_target.cert_subject) {
- migrate.cert_subject_size = strlen(main_ch->mig_target.cert_subject) + 1;
- migrate.cert_subject_data = (uint8_t *)main_ch->mig_target.cert_subject;
- } else {
- migrate.cert_subject_size = 0;
- migrate.cert_subject_data = NULL;
- }
- spice_marshall_msg_main_migrate_switch_host(m, &migrate);
-}
-
-static void main_channel_marshall_multi_media_time(RedChannelClient *rcc,
- SpiceMarshaller *m,
- MultiMediaTimePipeItem *item)
-{
- SpiceMsgMainMultiMediaTime time_mes;
-
- red_channel_client_init_send_data(rcc, SPICE_MSG_MAIN_MULTI_MEDIA_TIME, &item->base);
- time_mes.time = item->time;
- spice_marshall_msg_main_multi_media_time(m, &time_mes);
-}
-
-static void main_channel_send_item(RedChannelClient *rcc, PipeItem *base)
-{
- MainChannelClient *mcc = SPICE_CONTAINEROF(rcc, MainChannelClient, base);
- SpiceMarshaller *m = red_channel_client_get_marshaller(rcc);
-
- /* In semi-seamless migration (dest side), the connection is started from scratch, and
- * we ignore any pipe item that arrives before the INIT msg is sent.
- * For seamless we don't send INIT, and the connection continues from the same place
- * it stopped on the src side. */
- if (!mcc->init_sent && !mcc->seamless_mig_dst && base->type != PIPE_ITEM_TYPE_MAIN_INIT) {
- spice_printerr("Init msg for client %p was not sent yet "
- "(client is probably during semi-seamless migration). Ignoring msg type %d",
- rcc->client, base->type);
- main_channel_release_pipe_item(rcc, base, FALSE);
- return;
- }
- switch (base->type) {
- case PIPE_ITEM_TYPE_MAIN_CHANNELS_LIST:
- main_channel_marshall_channels(rcc, m, base);
- break;
- case PIPE_ITEM_TYPE_MAIN_PING:
- main_channel_marshall_ping(rcc, m,
- SPICE_CONTAINEROF(base, PingPipeItem, base));
- break;
- case PIPE_ITEM_TYPE_MAIN_MOUSE_MODE:
- {
- MouseModePipeItem *item =
- SPICE_CONTAINEROF(base, MouseModePipeItem, base);
- main_channel_marshall_mouse_mode(rcc, m, item);
- break;
- }
- case PIPE_ITEM_TYPE_MAIN_AGENT_DISCONNECTED:
- main_channel_marshall_agent_disconnected(rcc, m, base);
- break;
- case PIPE_ITEM_TYPE_MAIN_AGENT_TOKEN:
- main_channel_marshall_tokens(rcc, m,
- SPICE_CONTAINEROF(base, TokensPipeItem, base));
- break;
- case PIPE_ITEM_TYPE_MAIN_AGENT_DATA:
- main_channel_marshall_agent_data(rcc, m,
- SPICE_CONTAINEROF(base, AgentDataPipeItem, base));
- break;
- case PIPE_ITEM_TYPE_MAIN_MIGRATE_DATA:
- main_channel_marshall_migrate_data_item(rcc, m, base);
- break;
- case PIPE_ITEM_TYPE_MAIN_INIT:
- mcc->init_sent = TRUE;
- main_channel_marshall_init(rcc, m,
- SPICE_CONTAINEROF(base, InitPipeItem, base));
- break;
- case PIPE_ITEM_TYPE_MAIN_NOTIFY:
- main_channel_marshall_notify(rcc, m,
- SPICE_CONTAINEROF(base, NotifyPipeItem, base));
- break;
- case PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN:
- main_channel_marshall_migrate_begin(m, rcc, base);
- break;
- case PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN_SEAMLESS:
- main_channel_marshall_migrate_begin_seamless(m, rcc, base);
- break;
- case PIPE_ITEM_TYPE_MAIN_MULTI_MEDIA_TIME:
- main_channel_marshall_multi_media_time(rcc, m,
- SPICE_CONTAINEROF(base, MultiMediaTimePipeItem, base));
- break;
- case PIPE_ITEM_TYPE_MAIN_MIGRATE_SWITCH_HOST:
- main_channel_marshall_migrate_switch(m, rcc, base);
- break;
- case PIPE_ITEM_TYPE_MAIN_NAME:
- red_channel_client_init_send_data(rcc, SPICE_MSG_MAIN_NAME, base);
- spice_marshall_msg_main_name(m, &SPICE_CONTAINEROF(base, NamePipeItem, base)->msg);
- break;
- case PIPE_ITEM_TYPE_MAIN_UUID:
- red_channel_client_init_send_data(rcc, SPICE_MSG_MAIN_UUID, base);
- spice_marshall_msg_main_uuid(m, &SPICE_CONTAINEROF(base, UuidPipeItem, base)->msg);
- break;
- case PIPE_ITEM_TYPE_MAIN_AGENT_CONNECTED_TOKENS:
- main_channel_marshall_agent_connected(m, rcc, base);
- break;
- default:
- break;
- };
- red_channel_client_begin_send_message(rcc);
-}
-
-static void main_channel_release_pipe_item(RedChannelClient *rcc,
- PipeItem *base, int item_pushed)
-{
- switch (base->type) {
- case PIPE_ITEM_TYPE_MAIN_AGENT_DATA: {
- AgentDataPipeItem *data = (AgentDataPipeItem *)base;
-
- data->free_data(data->data, data->opaque);
- break;
- }
- case PIPE_ITEM_TYPE_MAIN_NOTIFY: {
- NotifyPipeItem *data = (NotifyPipeItem *)base;
- free(data->msg);
- break;
- }
- default:
- break;
- }
- free(base);
-}
-
-static void main_channel_client_handle_migrate_connected(MainChannelClient *mcc,
- int success,
- int seamless)
-{
- spice_printerr("client %p connected: %d seamless %d", mcc->base.client, success, seamless);
- if (mcc->mig_wait_connect) {
- MainChannel *main_channel = SPICE_CONTAINEROF(mcc->base.channel, MainChannel, base);
-
- mcc->mig_wait_connect = FALSE;
- mcc->mig_connect_ok = success;
- spice_assert(main_channel->num_clients_mig_wait);
- spice_assert(!seamless || main_channel->num_clients_mig_wait == 1);
- if (!--main_channel->num_clients_mig_wait) {
- reds_on_main_migrate_connected(seamless && success);
- }
- } else {
- if (success) {
- spice_printerr("client %p MIGRATE_CANCEL", mcc->base.client);
- red_channel_client_pipe_add_empty_msg(&mcc->base, SPICE_MSG_MAIN_MIGRATE_CANCEL);
- }
- }
-}
-
-void main_channel_client_handle_migrate_dst_do_seamless(MainChannelClient *mcc,
- uint32_t src_version)
-{
- if (reds_on_migrate_dst_set_seamless(mcc, src_version)) {
- mcc->seamless_mig_dst = TRUE;
- red_channel_client_pipe_add_empty_msg(&mcc->base,
- SPICE_MSG_MAIN_MIGRATE_DST_SEAMLESS_ACK);
- } else {
- red_channel_client_pipe_add_empty_msg(&mcc->base,
- SPICE_MSG_MAIN_MIGRATE_DST_SEAMLESS_NACK);
- }
-}
-
-void main_channel_client_handle_migrate_end(MainChannelClient *mcc)
-{
- if (!red_client_during_migrate_at_target(mcc->base.client)) {
- spice_printerr("unexpected SPICE_MSGC_MIGRATE_END");
- return;
- }
- if (!red_channel_client_test_remote_cap(&mcc->base,
- SPICE_MAIN_CAP_SEMI_SEAMLESS_MIGRATE)) {
- spice_printerr("unexpected SPICE_MSGC_MIGRATE_END, "
- "client does not support semi-seamless migration");
- return;
- }
- red_client_semi_seamless_migrate_complete(mcc->base.client);
-}
-
-void main_channel_migrate_dst_complete(MainChannelClient *mcc)
-{
- if (mcc->mig_wait_prev_complete) {
- if (mcc->mig_wait_prev_try_seamless) {
- spice_assert(mcc->base.channel->clients_num == 1);
- red_channel_client_pipe_add_type(&mcc->base,
- PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN_SEAMLESS);
- } else {
- red_channel_client_pipe_add_type(&mcc->base, PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN);
- }
- mcc->mig_wait_connect = TRUE;
- mcc->mig_wait_prev_complete = FALSE;
- }
-}
-
-static int main_channel_handle_parsed(RedChannelClient *rcc, uint32_t size, uint16_t type,
- void *message)
-{
- MainChannel *main_chan = SPICE_CONTAINEROF(rcc->channel, MainChannel, base);
- MainChannelClient *mcc = SPICE_CONTAINEROF(rcc, MainChannelClient, base);
-
- switch (type) {
- case SPICE_MSGC_MAIN_AGENT_START: {
- SpiceMsgcMainAgentStart *tokens;
-
- spice_printerr("agent start");
- if (!main_chan) {
- return FALSE;
- }
- tokens = (SpiceMsgcMainAgentStart *)message;
- reds_on_main_agent_start(mcc, tokens->num_tokens);
- break;
- }
- case SPICE_MSGC_MAIN_AGENT_DATA: {
- reds_on_main_agent_data(mcc, message, size);
- break;
- }
- case SPICE_MSGC_MAIN_AGENT_TOKEN: {
- SpiceMsgcMainAgentTokens *tokens;
-
- tokens = (SpiceMsgcMainAgentTokens *)message;
- reds_on_main_agent_tokens(mcc, tokens->num_tokens);
- break;
- }
- case SPICE_MSGC_MAIN_ATTACH_CHANNELS:
- main_channel_push_channels(mcc);
- break;
- case SPICE_MSGC_MAIN_MIGRATE_CONNECTED:
- main_channel_client_handle_migrate_connected(mcc,
- TRUE /* success */,
- FALSE /* seamless */);
- break;
- case SPICE_MSGC_MAIN_MIGRATE_CONNECTED_SEAMLESS:
- main_channel_client_handle_migrate_connected(mcc,
- TRUE /* success */,
- TRUE /* seamless */);
- break;
- case SPICE_MSGC_MAIN_MIGRATE_CONNECT_ERROR:
- main_channel_client_handle_migrate_connected(mcc, FALSE, FALSE);
- break;
- case SPICE_MSGC_MAIN_MIGRATE_DST_DO_SEAMLESS:
- main_channel_client_handle_migrate_dst_do_seamless(mcc,
- ((SpiceMsgcMainMigrateDstDoSeamless *)message)->src_version);
- break;
- case SPICE_MSGC_MAIN_MOUSE_MODE_REQUEST:
- reds_on_main_mouse_mode_request(message, size);
- break;
- case SPICE_MSGC_PONG: {
- SpiceMsgPing *ping = (SpiceMsgPing *)message;
- uint64_t roundtrip;
- struct timespec ts;
-
- clock_gettime(CLOCK_MONOTONIC, &ts);
- roundtrip = ts.tv_sec * 1000000LL + ts.tv_nsec / 1000LL - ping->timestamp;
-
- if (ping->id == mcc->net_test_id) {
- switch (mcc->net_test_stage) {
- case NET_TEST_STAGE_WARMUP:
- mcc->net_test_id++;
- mcc->net_test_stage = NET_TEST_STAGE_LATENCY;
- mcc->latency = roundtrip;
- break;
- case NET_TEST_STAGE_LATENCY:
- mcc->net_test_id++;
- mcc->net_test_stage = NET_TEST_STAGE_RATE;
- mcc->latency = MIN(mcc->latency, roundtrip);
- break;
- case NET_TEST_STAGE_RATE:
- mcc->net_test_id = 0;
- if (roundtrip <= mcc->latency) {
- // probably high load on client or server result with incorrect values
- spice_printerr("net test: invalid values, latency %" PRIu64
- " roundtrip %" PRIu64 ". assuming high"
- " bandwidth", mcc->latency, roundtrip);
- mcc->latency = 0;
- mcc->net_test_stage = NET_TEST_STAGE_INVALID;
- red_channel_client_start_connectivity_monitoring(&mcc->base,
- CLIENT_CONNECTIVITY_TIMEOUT);
- break;
- }
- mcc->bitrate_per_sec = (uint64_t)(NET_TEST_BYTES * 8) * 1000000
- / (roundtrip - mcc->latency);
- mcc->net_test_stage = NET_TEST_STAGE_COMPLETE;
- spice_printerr("net test: latency %f ms, bitrate %"PRIu64" bps (%f Mbps)%s",
- (double)mcc->latency / 1000,
- mcc->bitrate_per_sec,
- (double)mcc->bitrate_per_sec / 1024 / 1024,
- main_channel_client_is_low_bandwidth(mcc) ? " LOW BANDWIDTH" : "");
- red_channel_client_start_connectivity_monitoring(&mcc->base,
- CLIENT_CONNECTIVITY_TIMEOUT);
- break;
- default:
- spice_printerr("invalid net test stage, ping id %d test id %d stage %d",
- ping->id,
- mcc->net_test_id,
- mcc->net_test_stage);
- mcc->net_test_stage = NET_TEST_STAGE_INVALID;
- }
- break;
- } else {
- /*
- * channel client monitors the connectivity using ping-pong messages
- */
- red_channel_client_handle_message(rcc, size, type, message);
- }
-#ifdef RED_STATISTICS
- reds_update_stat_value(roundtrip);
-#endif
- break;
- }
- case SPICE_MSGC_DISCONNECTING:
- break;
- case SPICE_MSGC_MAIN_MIGRATE_END:
- main_channel_client_handle_migrate_end(mcc);
- break;
- default:
- return red_channel_client_handle_message(rcc, size, type, message);
- }
- return TRUE;
-}
-
-static uint8_t *main_channel_alloc_msg_rcv_buf(RedChannelClient *rcc,
- uint16_t type,
- uint32_t size)
-{
- MainChannel *main_chan = SPICE_CONTAINEROF(rcc->channel, MainChannel, base);
- MainChannelClient *mcc = SPICE_CONTAINEROF(rcc, MainChannelClient, base);
-
- if (type == SPICE_MSGC_MAIN_AGENT_DATA) {
- return reds_get_agent_data_buffer(mcc, size);
- } else {
- return main_chan->recv_buf;
- }
-}
-
-static void main_channel_release_msg_rcv_buf(RedChannelClient *rcc,
- uint16_t type,
- uint32_t size,
- uint8_t *msg)
-{
- if (type == SPICE_MSGC_MAIN_AGENT_DATA) {
- reds_release_agent_data_buffer(msg);
- }
-}
-
-static int main_channel_config_socket(RedChannelClient *rcc)
-{
- return TRUE;
-}
-
-static void main_channel_hold_pipe_item(RedChannelClient *rcc, PipeItem *item)
-{
-}
-
-static int main_channel_handle_migrate_flush_mark(RedChannelClient *rcc)
-{
- spice_debug(NULL);
- main_channel_push_migrate_data_item(SPICE_CONTAINEROF(rcc->channel,
- MainChannel, base));
- return TRUE;
-}
-
-#ifdef RED_STATISTICS
-static void do_ping_client(MainChannelClient *mcc,
- const char *opt, int has_interval, int interval)
-{
- spice_printerr("");
- if (!opt) {
- main_channel_client_push_ping(mcc, 0);
- } else if (!strcmp(opt, "on")) {
- if (has_interval && interval > 0) {
- mcc->ping_interval = interval * 1000;
- }
- core->timer_start(mcc->ping_timer, mcc->ping_interval);
- } else if (!strcmp(opt, "off")) {
- core->timer_cancel(mcc->ping_timer);
- } else {
- return;
- }
-}
-
-static void ping_timer_cb(void *opaque)
-{
- MainChannelClient *mcc = opaque;
-
- if (!red_channel_client_is_connected(&mcc->base)) {
- spice_printerr("not connected to peer, ping off");
- core->timer_cancel(mcc->ping_timer);
- return;
- }
- do_ping_client(mcc, NULL, 0, 0);
- core->timer_start(mcc->ping_timer, mcc->ping_interval);
-}
-#endif /* RED_STATISTICS */
-
-static MainChannelClient *main_channel_client_create(MainChannel *main_chan, RedClient *client,
- RedsStream *stream, uint32_t connection_id,
- int num_common_caps, uint32_t *common_caps,
- int num_caps, uint32_t *caps)
-{
- MainChannelClient *mcc = (MainChannelClient*)
- red_channel_client_create(sizeof(MainChannelClient), &main_chan->base,
- client, stream, FALSE, num_common_caps,
- common_caps, num_caps, caps);
- spice_assert(mcc != NULL);
- mcc->connection_id = connection_id;
- mcc->bitrate_per_sec = ~0;
-#ifdef RED_STATISTICS
- if (!(mcc->ping_timer = core->timer_add(ping_timer_cb, NULL))) {
- spice_error("ping timer create failed");
- }
- mcc->ping_interval = PING_INTERVAL;
-#endif
- return mcc;
-}
-
-MainChannelClient *main_channel_link(MainChannel *channel, RedClient *client,
- RedsStream *stream, uint32_t connection_id, int migration,
- int num_common_caps, uint32_t *common_caps, int num_caps,
- uint32_t *caps)
-{
- MainChannelClient *mcc;
-
- spice_assert(channel);
-
- // TODO - migration - I removed it from channel creation, now put it
- // into usage somewhere (not an issue until we return migration to it's
- // former glory)
- spice_printerr("add main channel client");
- mcc = main_channel_client_create(channel, client, stream, connection_id,
- num_common_caps, common_caps,
- num_caps, caps);
- return mcc;
-}
-
-int main_channel_getsockname(MainChannel *main_chan, struct sockaddr *sa, socklen_t *salen)
-{
- return main_chan ? getsockname(red_channel_get_first_socket(&main_chan->base), sa, salen) : -1;
-}
-
-int main_channel_getpeername(MainChannel *main_chan, struct sockaddr *sa, socklen_t *salen)
-{
- return main_chan ? getpeername(red_channel_get_first_socket(&main_chan->base), sa, salen) : -1;
-}
-
-// TODO: ? shouldn't it disonnect all clients? or shutdown all main_channels?
-void main_channel_close(MainChannel *main_chan)
-{
- int socketfd;
-
- if (main_chan && (socketfd = red_channel_get_first_socket(&main_chan->base)) != -1) {
- close(socketfd);
- }
-}
-
-int main_channel_client_is_network_info_initialized(MainChannelClient *mcc)
-{
- return mcc->net_test_stage == NET_TEST_STAGE_COMPLETE;
-}
-
-int main_channel_client_is_low_bandwidth(MainChannelClient *mcc)
-{
- // TODO: configurable?
- return mcc->bitrate_per_sec < 10 * 1024 * 1024;
-}
-
-uint64_t main_channel_client_get_bitrate_per_sec(MainChannelClient *mcc)
-{
- return mcc->bitrate_per_sec;
-}
-
-uint64_t main_channel_client_get_roundtrip_ms(MainChannelClient *mcc)
-{
- return mcc->latency / 1000;
-}
-
-static void main_channel_client_migrate(RedChannelClient *rcc)
-{
- reds_on_main_channel_migrate(SPICE_CONTAINEROF(rcc, MainChannelClient, base));
- red_channel_client_default_migrate(rcc);
-}
-
-MainChannel* main_channel_init(void)
-{
- RedChannel *channel;
- ChannelCbs channel_cbs = { NULL, };
- ClientCbs client_cbs = {NULL, };
-
- channel_cbs.config_socket = main_channel_config_socket;
- channel_cbs.on_disconnect = main_channel_client_on_disconnect;
- channel_cbs.send_item = main_channel_send_item;
- channel_cbs.hold_item = main_channel_hold_pipe_item;
- channel_cbs.release_item = main_channel_release_pipe_item;
- channel_cbs.alloc_recv_buf = main_channel_alloc_msg_rcv_buf;
- channel_cbs.release_recv_buf = main_channel_release_msg_rcv_buf;
- channel_cbs.handle_migrate_flush_mark = main_channel_handle_migrate_flush_mark;
- channel_cbs.handle_migrate_data = main_channel_handle_migrate_data;
-
- // TODO: set the migration flag of the channel
- channel = red_channel_create_parser(sizeof(MainChannel), core,
- SPICE_CHANNEL_MAIN, 0,
- FALSE, /* handle_acks */
- spice_get_client_channel_parser(SPICE_CHANNEL_MAIN, NULL),
- main_channel_handle_parsed,
- &channel_cbs,
- SPICE_MIGRATE_NEED_FLUSH | SPICE_MIGRATE_NEED_DATA_TRANSFER);
- spice_assert(channel);
- red_channel_set_cap(channel, SPICE_MAIN_CAP_SEMI_SEAMLESS_MIGRATE);
- red_channel_set_cap(channel, SPICE_MAIN_CAP_SEAMLESS_MIGRATE);
-
- client_cbs.migrate = main_channel_client_migrate;
- red_channel_register_client_cbs(channel, &client_cbs);
-
- return (MainChannel *)channel;
-}
-
-RedChannelClient* main_channel_client_get_base(MainChannelClient* mcc)
-{
- spice_assert(mcc);
- return &mcc->base;
-}
-
-static int main_channel_connect_semi_seamless(MainChannel *main_channel)
-{
- RingItem *client_link;
-
- RING_FOREACH(client_link, &main_channel->base.clients) {
- MainChannelClient * mcc = SPICE_CONTAINEROF(client_link, MainChannelClient,
- base.channel_link);
- if (red_channel_client_test_remote_cap(&mcc->base,
- SPICE_MAIN_CAP_SEMI_SEAMLESS_MIGRATE)) {
- if (red_client_during_migrate_at_target(mcc->base.client)) {
- spice_printerr("client %p: wait till previous migration completes", mcc->base.client);
- mcc->mig_wait_prev_complete = TRUE;
- mcc->mig_wait_prev_try_seamless = FALSE;
- } else {
- red_channel_client_pipe_add_type(&mcc->base,
- PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN);
- mcc->mig_wait_connect = TRUE;
- }
- mcc->mig_connect_ok = FALSE;
- main_channel->num_clients_mig_wait++;
- }
- }
- return main_channel->num_clients_mig_wait;
-}
-
-static int main_channel_connect_seamless(MainChannel *main_channel)
-{
- RingItem *client_link;
-
- spice_assert(main_channel->base.clients_num == 1);
-
- RING_FOREACH(client_link, &main_channel->base.clients) {
- MainChannelClient * mcc = SPICE_CONTAINEROF(client_link, MainChannelClient,
- base.channel_link);
- spice_assert(red_channel_client_test_remote_cap(&mcc->base,
- SPICE_MAIN_CAP_SEAMLESS_MIGRATE));
- if (red_client_during_migrate_at_target(mcc->base.client)) {
- spice_printerr("client %p: wait till previous migration completes", mcc->base.client);
- mcc->mig_wait_prev_complete = TRUE;
- mcc->mig_wait_prev_try_seamless = TRUE;
- } else {
- red_channel_client_pipe_add_type(&mcc->base,
- PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN_SEAMLESS);
- mcc->mig_wait_connect = TRUE;
- }
- mcc->mig_connect_ok = FALSE;
- main_channel->num_clients_mig_wait++;
- }
- return main_channel->num_clients_mig_wait;
-}
-
-int main_channel_migrate_connect(MainChannel *main_channel, RedsMigSpice *mig_target,
- int try_seamless)
-{
- main_channel_fill_mig_target(main_channel, mig_target);
- main_channel->num_clients_mig_wait = 0;
-
- if (!main_channel_is_connected(main_channel)) {
- return 0;
- }
-
- if (!try_seamless) {
- return main_channel_connect_semi_seamless(main_channel);
- } else {
- RingItem *client_item;
- MainChannelClient *mcc;
-
- client_item = ring_get_head(&main_channel->base.clients);
- mcc = SPICE_CONTAINEROF(client_item, MainChannelClient, base.channel_link);
-
- if (!red_channel_client_test_remote_cap(&mcc->base,
- SPICE_MAIN_CAP_SEAMLESS_MIGRATE)) {
- return main_channel_connect_semi_seamless(main_channel);
- } else {
- return main_channel_connect_seamless(main_channel);
- }
- }
-
-}
-
-void main_channel_migrate_cancel_wait(MainChannel *main_chan)
-{
- RingItem *client_link;
-
- RING_FOREACH(client_link, &main_chan->base.clients) {
- MainChannelClient *mcc;
-
- mcc = SPICE_CONTAINEROF(client_link, MainChannelClient, base.channel_link);
- if (mcc->mig_wait_connect) {
- spice_printerr("client %p cancel wait connect", mcc->base.client);
- mcc->mig_wait_connect = FALSE;
- mcc->mig_connect_ok = FALSE;
- }
- mcc->mig_wait_prev_complete = FALSE;
- }
- main_chan->num_clients_mig_wait = 0;
-}
-
-int main_channel_migrate_src_complete(MainChannel *main_chan, int success)
-{
- RingItem *client_link;
- int semi_seamless_count = 0;
-
- spice_printerr("");
-
- if (ring_is_empty(&main_chan->base.clients)) {
- spice_printerr("no peer connected");
- return 0;
- }
-
- RING_FOREACH(client_link, &main_chan->base.clients) {
- MainChannelClient *mcc;
- int semi_seamless_support;
-
- mcc = SPICE_CONTAINEROF(client_link, MainChannelClient, base.channel_link);
- semi_seamless_support = red_channel_client_test_remote_cap(&mcc->base,
- SPICE_MAIN_CAP_SEMI_SEAMLESS_MIGRATE);
- if (semi_seamless_support && mcc->mig_connect_ok) {
- if (success) {
- spice_printerr("client %p MIGRATE_END", mcc->base.client);
- red_channel_client_pipe_add_empty_msg(&mcc->base, SPICE_MSG_MAIN_MIGRATE_END);
- semi_seamless_count++;
- } else {
- spice_printerr("client %p MIGRATE_CANCEL", mcc->base.client);
- red_channel_client_pipe_add_empty_msg(&mcc->base, SPICE_MSG_MAIN_MIGRATE_CANCEL);
- }
- } else {
- if (success) {
- spice_printerr("client %p SWITCH_HOST", mcc->base.client);
- red_channel_client_pipe_add_type(&mcc->base, PIPE_ITEM_TYPE_MAIN_MIGRATE_SWITCH_HOST);
- }
- }
- mcc->mig_connect_ok = FALSE;
- mcc->mig_wait_connect = FALSE;
- }
- return semi_seamless_count;
-}
diff --git a/server/main_channel.h b/server/main_channel.h
deleted file mode 100644
index 9bd20f1..0000000
--- a/server/main_channel.h
+++ /dev/null
@@ -1,103 +0,0 @@
-/*
- Copyright (C) 2009 Red Hat, Inc.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, see <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef __MAIN_CHANNEL_H__
-#define __MAIN_CHANNEL_H__
-
-#include <stdint.h>
-#include <spice/vd_agent.h>
-#include "common/marshaller.h"
-#include "red_channel.h"
-
-// TODO: Defines used to calculate receive buffer size, and also by reds.c
-// other options: is to make a reds_main_consts.h, to duplicate defines.
-#define REDS_AGENT_WINDOW_SIZE 10
-#define REDS_NUM_INTERNAL_AGENT_MESSAGES 1
-
-// approximate max receive message size for main channel
-#define MAIN_CHANNEL_RECEIVE_BUF_SIZE \
- (4096 + (REDS_AGENT_WINDOW_SIZE + REDS_NUM_INTERNAL_AGENT_MESSAGES) * SPICE_AGENT_MAX_DATA_SIZE)
-
-struct RedsMigSpice {
- char *host;
- char *cert_subject;
- int port;
- int sport;
-};
-typedef struct RedsMigSpice RedsMigSpice;
-
-typedef struct MainChannel {
- RedChannel base;
- uint8_t recv_buf[MAIN_CHANNEL_RECEIVE_BUF_SIZE];
- RedsMigSpice mig_target; // TODO: add refs and release (afrer all clients completed migration in one way or the other?)
- int num_clients_mig_wait;
-} MainChannel;
-
-
-MainChannel *main_channel_init(void);
-RedClient *main_channel_get_client_by_link_id(MainChannel *main_chan, uint32_t link_id);
-/* This is a 'clone' from the reds.h Channel.link callback to allow passing link_id */
-MainChannelClient *main_channel_link(MainChannel *, RedClient *client,
- RedsStream *stream, uint32_t link_id, int migration, int num_common_caps,
- uint32_t *common_caps, int num_caps, uint32_t *caps);
-void main_channel_close(MainChannel *main_chan); // not destroy, just socket close
-void main_channel_push_mouse_mode(MainChannel *main_chan, int current_mode, int is_client_mouse_allowed);
-void main_channel_push_agent_connected(MainChannel *main_chan);
-void main_channel_push_agent_disconnected(MainChannel *main_chan);
-void main_channel_client_push_agent_tokens(MainChannelClient *mcc, uint32_t num_tokens);
-void main_channel_client_push_agent_data(MainChannelClient *mcc, uint8_t* data, size_t len,
- spice_marshaller_item_free_func free_data, void *opaque);
-void main_channel_client_start_net_test(MainChannelClient *mcc, int test_rate);
-// TODO: huge. Consider making a reds_* interface for these functions
-// and calling from main.
-void main_channel_push_init(MainChannelClient *mcc, int display_channels_hint,
- int current_mouse_mode, int is_client_mouse_allowed, int multi_media_time,
- int ram_hint);
-void main_channel_client_push_notify(MainChannelClient *mcc, const char *msg);
-void main_channel_push_multi_media_time(MainChannel *main_chan, int time);
-int main_channel_getsockname(MainChannel *main_chan, struct sockaddr *sa, socklen_t *salen);
-int main_channel_getpeername(MainChannel *main_chan, struct sockaddr *sa, socklen_t *salen);
-
-/*
- * return TRUE if network test had been completed successfully.
- * If FALSE, bitrate_per_sec is set to MAX_UINT64 and the roundtrip is set to 0
- */
-int main_channel_client_is_network_info_initialized(MainChannelClient *mcc);
-int main_channel_client_is_low_bandwidth(MainChannelClient *mcc);
-uint64_t main_channel_client_get_bitrate_per_sec(MainChannelClient *mcc);
-uint64_t main_channel_client_get_roundtrip_ms(MainChannelClient *mcc);
-
-int main_channel_is_connected(MainChannel *main_chan);
-RedChannelClient* main_channel_client_get_base(MainChannelClient* mcc);
-
-/* switch host migration */
-void main_channel_migrate_switch(MainChannel *main_chan, RedsMigSpice *mig_target);
-
-/* semi seamless migration */
-
-/* returns the number of clients that we are waiting for their connection.
- * try_seamless = 'true' when the seamless-migration=on in qemu command line */
-int main_channel_migrate_connect(MainChannel *main_channel, RedsMigSpice *mig_target,
- int try_seamless);
-void main_channel_migrate_cancel_wait(MainChannel *main_chan);
-/* returns the number of clients for which SPICE_MSG_MAIN_MIGRATE_END was sent*/
-int main_channel_migrate_src_complete(MainChannel *main_chan, int success);
-void main_channel_migrate_dst_complete(MainChannelClient *mcc);
-void main_channel_push_name(MainChannelClient *mcc, const char *name);
-void main_channel_push_uuid(MainChannelClient *mcc, const uint8_t uuid[16]);
-
-#endif
diff --git a/server/main_dispatcher.c b/server/main_dispatcher.c
deleted file mode 100644
index 6ad9d89..0000000
--- a/server/main_dispatcher.c
+++ /dev/null
@@ -1,217 +0,0 @@
-/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- Copyright (C) 2009-2015 Red Hat, Inc.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, see <http://www.gnu.org/licenses/>.
-*/
-#include <config.h>
-#include <unistd.h>
-#include <string.h>
-#include <errno.h>
-#include <pthread.h>
-
-#include "red_common.h"
-#include "dispatcher.h"
-#include "main_dispatcher.h"
-#include "red_channel.h"
-#include "reds.h"
-
-/*
- * Main Dispatcher
- * ===============
- *
- * Communication channel between any non main thread and the main thread.
- *
- * The main thread is that from which spice_server_init is called.
- *
- * Messages are single sized, sent from the non-main thread to the main-thread.
- * No acknowledge is sent back. This prevents a possible deadlock with the main
- * thread already waiting on a response for the existing red_dispatcher used
- * by the worker thread.
- *
- * All events have three functions:
- * main_dispatcher_<event_name> - non static, public function
- * main_dispatcher_self_<event_name> - handler for main thread
- * main_dispatcher_handle_<event_name> - handler for callback from main thread
- * seperate from self because it may send an ack or do other work in the future.
- */
-
-typedef struct {
- Dispatcher base;
- SpiceCoreInterface *core;
-} MainDispatcher;
-
-MainDispatcher main_dispatcher;
-
-enum {
- MAIN_DISPATCHER_CHANNEL_EVENT = 0,
- MAIN_DISPATCHER_MIGRATE_SEAMLESS_DST_COMPLETE,
- MAIN_DISPATCHER_SET_MM_TIME_LATENCY,
- MAIN_DISPATCHER_CLIENT_DISCONNECT,
-
- MAIN_DISPATCHER_NUM_MESSAGES
-};
-
-typedef struct MainDispatcherChannelEventMessage {
- int event;
- SpiceChannelEventInfo *info;
-} MainDispatcherChannelEventMessage;
-
-typedef struct MainDispatcherMigrateSeamlessDstCompleteMessage {
- RedClient *client;
-} MainDispatcherMigrateSeamlessDstCompleteMessage;
-
-typedef struct MainDispatcherMmTimeLatencyMessage {
- RedClient *client;
- uint32_t latency;
-} MainDispatcherMmTimeLatencyMessage;
-
-typedef struct MainDispatcherClientDisconnectMessage {
- RedClient *client;
-} MainDispatcherClientDisconnectMessage;
-
-/* channel_event - calls core->channel_event, must be done in main thread */
-static void main_dispatcher_self_handle_channel_event(
- int event,
- SpiceChannelEventInfo *info)
-{
- reds_handle_channel_event(event, info);
-}
-
-static void main_dispatcher_handle_channel_event(void *opaque,
- void *payload)
-{
- MainDispatcherChannelEventMessage *channel_event = payload;
-
- main_dispatcher_self_handle_channel_event(channel_event->event,
- channel_event->info);
-}
-
-void main_dispatcher_channel_event(int event, SpiceChannelEventInfo *info)
-{
- MainDispatcherChannelEventMessage msg = {0,};
-
- if (pthread_self() == main_dispatcher.base.self) {
- main_dispatcher_self_handle_channel_event(event, info);
- return;
- }
- msg.event = event;
- msg.info = info;
- dispatcher_send_message(&main_dispatcher.base, MAIN_DISPATCHER_CHANNEL_EVENT,
- &msg);
-}
-
-
-static void main_dispatcher_handle_migrate_complete(void *opaque,
- void *payload)
-{
- MainDispatcherMigrateSeamlessDstCompleteMessage *mig_complete = payload;
-
- reds_on_client_seamless_migrate_complete(mig_complete->client);
- red_client_unref(mig_complete->client);
-}
-
-static void main_dispatcher_handle_mm_time_latency(void *opaque,
- void *payload)
-{
- MainDispatcherMmTimeLatencyMessage *msg = payload;
- reds_set_client_mm_time_latency(msg->client, msg->latency);
- red_client_unref(msg->client);
-}
-
-static void main_dispatcher_handle_client_disconnect(void *opaque,
- void *payload)
-{
- MainDispatcherClientDisconnectMessage *msg = payload;
-
- spice_debug("client=%p", msg->client);
- reds_client_disconnect(msg->client);
- red_client_unref(msg->client);
-}
-
-void main_dispatcher_seamless_migrate_dst_complete(RedClient *client)
-{
- MainDispatcherMigrateSeamlessDstCompleteMessage msg;
-
- if (pthread_self() == main_dispatcher.base.self) {
- reds_on_client_seamless_migrate_complete(client);
- return;
- }
-
- msg.client = red_client_ref(client);
- dispatcher_send_message(&main_dispatcher.base, MAIN_DISPATCHER_MIGRATE_SEAMLESS_DST_COMPLETE,
- &msg);
-}
-
-void main_dispatcher_set_mm_time_latency(RedClient *client, uint32_t latency)
-{
- MainDispatcherMmTimeLatencyMessage msg;
-
- if (pthread_self() == main_dispatcher.base.self) {
- reds_set_client_mm_time_latency(client, latency);
- return;
- }
-
- msg.client = red_client_ref(client);
- msg.latency = latency;
- dispatcher_send_message(&main_dispatcher.base, MAIN_DISPATCHER_SET_MM_TIME_LATENCY,
- &msg);
-}
-
-void main_dispatcher_client_disconnect(RedClient *client)
-{
- MainDispatcherClientDisconnectMessage msg;
-
- if (!client->disconnecting) {
- spice_debug("client %p", client);
- msg.client = red_client_ref(client);
- dispatcher_send_message(&main_dispatcher.base, MAIN_DISPATCHER_CLIENT_DISCONNECT,
- &msg);
- } else {
- spice_debug("client %p already during disconnection", client);
- }
-}
-
-static void dispatcher_handle_read(int fd, int event, void *opaque)
-{
- Dispatcher *dispatcher = opaque;
-
- dispatcher_handle_recv_read(dispatcher);
-}
-
-/*
- * FIXME:
- * Reds routines shouldn't be exposed. Instead reds.c should register the callbacks,
- * and the corresponding operations should be made only via main_dispatcher.
- */
-void main_dispatcher_init(SpiceCoreInterface *core)
-{
- memset(&main_dispatcher, 0, sizeof(main_dispatcher));
- main_dispatcher.core = core;
- dispatcher_init(&main_dispatcher.base, MAIN_DISPATCHER_NUM_MESSAGES, &main_dispatcher.base);
- core->watch_add(main_dispatcher.base.recv_fd, SPICE_WATCH_EVENT_READ,
- dispatcher_handle_read, &main_dispatcher.base);
- dispatcher_register_handler(&main_dispatcher.base, MAIN_DISPATCHER_CHANNEL_EVENT,
- main_dispatcher_handle_channel_event,
- sizeof(MainDispatcherChannelEventMessage), 0 /* no ack */);
- dispatcher_register_handler(&main_dispatcher.base, MAIN_DISPATCHER_MIGRATE_SEAMLESS_DST_COMPLETE,
- main_dispatcher_handle_migrate_complete,
- sizeof(MainDispatcherMigrateSeamlessDstCompleteMessage), 0 /* no ack */);
- dispatcher_register_handler(&main_dispatcher.base, MAIN_DISPATCHER_SET_MM_TIME_LATENCY,
- main_dispatcher_handle_mm_time_latency,
- sizeof(MainDispatcherMmTimeLatencyMessage), 0 /* no ack */);
- dispatcher_register_handler(&main_dispatcher.base, MAIN_DISPATCHER_CLIENT_DISCONNECT,
- main_dispatcher_handle_client_disconnect,
- sizeof(MainDispatcherClientDisconnectMessage), 0 /* no ack */);
-}
diff --git a/server/main_dispatcher.h b/server/main_dispatcher.h
deleted file mode 100644
index af40093..0000000
--- a/server/main_dispatcher.h
+++ /dev/null
@@ -1,36 +0,0 @@
-/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- Copyright (C) 2009-2015 Red Hat, Inc.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, see <http://www.gnu.org/licenses/>.
-*/
-#ifndef MAIN_DISPATCHER_H
-#define MAIN_DISPATCHER_H
-
-#include <spice.h>
-#include "red_channel.h"
-
-void main_dispatcher_channel_event(int event, SpiceChannelEventInfo *info);
-void main_dispatcher_seamless_migrate_dst_complete(RedClient *client);
-void main_dispatcher_set_mm_time_latency(RedClient *client, uint32_t latency);
-/*
- * Disconnecting the client is always executed asynchronously,
- * in order to protect from expired references in the routines
- * that triggered the client destruction.
- */
-void main_dispatcher_client_disconnect(RedClient *client);
-
-void main_dispatcher_init(SpiceCoreInterface *core);
-
-#endif //MAIN_DISPATCHER_H
diff --git a/server/memslot.c b/server/memslot.c
new file mode 100644
index 0000000..e7ee04c
--- /dev/null
+++ b/server/memslot.c
@@ -0,0 +1,184 @@
+/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ Copyright (C) 2009,2010 Red Hat, Inc.
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, see <http://www.gnu.org/licenses/>.
+*/
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <inttypes.h>
+
+#include "red_common.h"
+#include "memslot.h"
+
+static unsigned long __get_clean_virt(RedMemSlotInfo *info, QXLPHYSICAL addr)
+{
+ return addr & info->memslot_clean_virt_mask;
+}
+
+static void print_memslots(RedMemSlotInfo *info)
+{
+ int i;
+ int x;
+
+ for (i = 0; i < info->num_memslots_groups; ++i) {
+ for (x = 0; x < info->num_memslots; ++x) {
+ if (!info->mem_slots[i][x].virt_start_addr &&
+ !info->mem_slots[i][x].virt_end_addr) {
+ continue;
+ }
+ printf("id %d, group %d, virt start %lx, virt end %lx, generation %u, delta %lx\n",
+ x, i, info->mem_slots[i][x].virt_start_addr,
+ info->mem_slots[i][x].virt_end_addr, info->mem_slots[i][x].generation,
+ info->mem_slots[i][x].address_delta);
+ }
+ }
+}
+
+/* return 1 if validation successfull, 0 otherwise */
+int memslot_validate_virt(RedMemSlotInfo *info, unsigned long virt, int slot_id,
+ uint32_t add_size, uint32_t group_id)
+{
+ MemSlot *slot;
+
+ slot = &info->mem_slots[group_id][slot_id];
+ if ((virt + add_size) < virt) {
+ spice_critical("virtual address overlap");
+ return 0;
+ }
+
+ if (virt < slot->virt_start_addr || (virt + add_size) > slot->virt_end_addr) {
+ print_memslots(info);
+ spice_critical("virtual address out of range\n"
+ " virt=0x%lx+0x%x slot_id=%d group_id=%d\n"
+ " slot=0x%lx-0x%lx delta=0x%lx",
+ virt, add_size, slot_id, group_id,
+ slot->virt_start_addr, slot->virt_end_addr, slot->address_delta);
+ return 0;
+ }
+ return 1;
+}
+
+/*
+ * return virtual address if successful, which may be 0.
+ * returns 0 and sets error to 1 if an error condition occurs.
+ */
+unsigned long memslot_get_virt(RedMemSlotInfo *info, QXLPHYSICAL addr, uint32_t add_size,
+ int group_id, int *error)
+{
+ int slot_id;
+ int generation;
+ unsigned long h_virt;
+
+ MemSlot *slot;
+
+ *error = 0;
+ if (group_id > info->num_memslots_groups) {
+ spice_critical("group_id too big");
+ *error = 1;
+ return 0;
+ }
+
+ slot_id = memslot_get_id(info, addr);
+ if (slot_id > info->num_memslots) {
+ print_memslots(info);
+ spice_critical("slot_id %d too big, addr=%" PRIx64, slot_id, addr);
+ *error = 1;
+ return 0;
+ }
+
+ slot = &info->mem_slots[group_id][slot_id];
+
+ generation = memslot_get_generation(info, addr);
+ if (generation != slot->generation) {
+ print_memslots(info);
+ spice_critical("address generation is not valid, group_id %d, slot_id %d, gen %d, slot_gen %d\n",
+ group_id, slot_id, generation, slot->generation);
+ *error = 1;
+ return 0;
+ }
+
+ h_virt = __get_clean_virt(info, addr);
+ h_virt += slot->address_delta;
+
+ if (!memslot_validate_virt(info, h_virt, slot_id, add_size, group_id)) {
+ *error = 1;
+ return 0;
+ }
+
+ return h_virt;
+}
+
+void memslot_info_init(RedMemSlotInfo *info,
+ uint32_t num_groups, uint32_t num_slots,
+ uint8_t generation_bits,
+ uint8_t id_bits,
+ uint8_t internal_groupslot_id)
+{
+ uint32_t i;
+
+ spice_return_if_fail(num_slots > 0);
+ spice_return_if_fail(num_groups > 0);
+
+ info->num_memslots_groups = num_groups;
+ info->num_memslots = num_slots;
+ info->generation_bits = generation_bits;
+ info->mem_slot_bits = id_bits;
+ info->internal_groupslot_id = internal_groupslot_id;
+
+ info->mem_slots = spice_new(MemSlot *, num_groups);
+
+ for (i = 0; i < num_groups; ++i) {
+ info->mem_slots[i] = spice_new0(MemSlot, num_slots);
+ }
+
+ /* TODO: use QXLPHYSICAL_BITS */
+ info->memslot_id_shift = 64 - info->mem_slot_bits;
+ info->memslot_gen_shift = 64 - (info->mem_slot_bits + info->generation_bits);
+ info->memslot_gen_mask = ~((QXLPHYSICAL)-1 << info->generation_bits);
+ info->memslot_clean_virt_mask = (((QXLPHYSICAL)(-1)) >>
+ (info->mem_slot_bits + info->generation_bits));
+}
+
+void memslot_info_add_slot(RedMemSlotInfo *info, uint32_t slot_group_id, uint32_t slot_id,
+ uint64_t addr_delta, unsigned long virt_start, unsigned long virt_end,
+ uint32_t generation)
+{
+ spice_return_if_fail(info->num_memslots_groups > slot_group_id);
+ spice_return_if_fail(info->num_memslots > slot_id);
+
+ info->mem_slots[slot_group_id][slot_id].address_delta = addr_delta;
+ info->mem_slots[slot_group_id][slot_id].virt_start_addr = virt_start;
+ info->mem_slots[slot_group_id][slot_id].virt_end_addr = virt_end;
+ info->mem_slots[slot_group_id][slot_id].generation = generation;
+}
+
+void memslot_info_del_slot(RedMemSlotInfo *info, uint32_t slot_group_id, uint32_t slot_id)
+{
+ spice_return_if_fail(info->num_memslots_groups > slot_group_id);
+ spice_return_if_fail(info->num_memslots > slot_id);
+
+ info->mem_slots[slot_group_id][slot_id].virt_start_addr = 0;
+ info->mem_slots[slot_group_id][slot_id].virt_end_addr = 0;
+}
+
+void memslot_info_reset(RedMemSlotInfo *info)
+{
+ uint32_t i;
+ for (i = 0; i < info->num_memslots_groups; ++i) {
+ memset(info->mem_slots[i], 0, sizeof(MemSlot) * info->num_memslots);
+ }
+}
diff --git a/server/memslot.h b/server/memslot.h
new file mode 100644
index 0000000..1fba4b8
--- /dev/null
+++ b/server/memslot.h
@@ -0,0 +1,72 @@
+/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ Copyright (C) 2009,2010 Red Hat, Inc.
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef MEMSLOT_H_
+#define MEMSLOT_H_
+
+#include "red_common.h"
+
+#include <spice/qxl_dev.h>
+
+typedef struct MemSlot {
+ int generation;
+ unsigned long virt_start_addr;
+ unsigned long virt_end_addr;
+ long address_delta;
+} MemSlot;
+
+typedef struct RedMemSlotInfo {
+ MemSlot **mem_slots;
+ uint32_t num_memslots_groups;
+ uint32_t num_memslots;
+ uint8_t mem_slot_bits;
+ uint8_t generation_bits;
+ uint8_t memslot_id_shift;
+ uint8_t memslot_gen_shift;
+ uint8_t internal_groupslot_id;
+ unsigned long memslot_gen_mask;
+ unsigned long memslot_clean_virt_mask;
+} RedMemSlotInfo;
+
+static inline int memslot_get_id(RedMemSlotInfo *info, uint64_t addr)
+{
+ return addr >> info->memslot_id_shift;
+}
+
+static inline int memslot_get_generation(RedMemSlotInfo *info, uint64_t addr)
+{
+ return (addr >> info->memslot_gen_shift) & info->memslot_gen_mask;
+}
+
+int memslot_validate_virt(RedMemSlotInfo *info, unsigned long virt, int slot_id,
+ uint32_t add_size, uint32_t group_id);
+unsigned long memslot_get_virt(RedMemSlotInfo *info, QXLPHYSICAL addr, uint32_t add_size,
+ int group_id, int *error);
+
+void memslot_info_init(RedMemSlotInfo *info,
+ uint32_t num_groups, uint32_t num_slots,
+ uint8_t generation_bits,
+ uint8_t id_bits,
+ uint8_t internal_groupslot_id);
+void memslot_info_add_slot(RedMemSlotInfo *info, uint32_t slot_group_id, uint32_t slot_id,
+ uint64_t addr_delta, unsigned long virt_start, unsigned long virt_end,
+ uint32_t generation);
+void memslot_info_del_slot(RedMemSlotInfo *info, uint32_t slot_group_id, uint32_t slot_id);
+void memslot_info_reset(RedMemSlotInfo *info);
+
+#endif
diff --git a/server/migration-protocol.h b/server/migration-protocol.h
new file mode 100644
index 0000000..c1d97ef
--- /dev/null
+++ b/server/migration-protocol.h
@@ -0,0 +1,213 @@
+/*
+ Copyright (C) 2012 Red Hat, Inc.
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_MIGRATION_PROTOCOL
+#define _H_MIGRATION_PROTOCOL
+
+#include <spice/macros.h>
+#include <spice/vd_agent.h>
+#include "glz-encoder-dict.h"
+
+/* ************************************************
+ * src-server to dst-server migration data messages
+ * ************************************************/
+
+/* increase the version when the version of any
+ * of the migration data messages is increased */
+#define SPICE_MIGRATION_PROTOCOL_VERSION 1
+
+typedef struct __attribute__ ((__packed__)) SpiceMigrateDataHeader {
+ uint32_t magic;
+ uint32_t version;
+} SpiceMigrateDataHeader;
+
+/* ********************
+ * Char device base
+ * *******************/
+
+/* increase the version of descendent char devices when this
+ * version is increased */
+#define SPICE_MIGRATE_DATA_CHAR_DEVICE_VERSION 1
+
+/* Should be the first field of any of the char_devices migration data (see write_data_ptr) */
+typedef struct __attribute__ ((__packed__)) SpiceMigrateDataCharDevice {
+ uint32_t version;
+ uint8_t connected;
+ uint32_t num_client_tokens;
+ uint32_t num_send_tokens;
+ uint32_t write_size; /* write to dev */
+ uint32_t write_num_client_tokens; /* how many messages from the client are part of the write_data */
+ uint32_t write_data_ptr; /* offset from
+ SpiceMigrateDataCharDevice - sizeof(SpiceMigrateDataHeader) */
+} SpiceMigrateDataCharDevice;
+
+/* ********
+ * spicevmc
+ * ********/
+
+#define SPICE_MIGRATE_DATA_SPICEVMC_VERSION 1 /* NOTE: increase version when CHAR_DEVICE_VERSION
+ is increased */
+#define SPICE_MIGRATE_DATA_SPICEVMC_MAGIC SPICE_MAGIC_CONST("SVMD")
+typedef struct __attribute__ ((__packed__)) SpiceMigrateDataSpiceVmc {
+ SpiceMigrateDataCharDevice base;
+} SpiceMigrateDataSpiceVmc;
+
+/* *********
+ * smartcard
+ * *********/
+
+#define SPICE_MIGRATE_DATA_SMARTCARD_VERSION 1 /* NOTE: increase version when CHAR_DEVICE_VERSION
+ is increased */
+#define SPICE_MIGRATE_DATA_SMARTCARD_MAGIC SPICE_MAGIC_CONST("SCMD")
+typedef struct __attribute__ ((__packed__)) SpiceMigrateDataSmartcard {
+ SpiceMigrateDataCharDevice base;
+ uint8_t reader_added;
+ uint32_t read_size; /* partial data read from dev */
+ uint32_t read_data_ptr;
+} SpiceMigrateDataSmartcard;
+
+/* *********************************
+ * main channel (mainly guest agent)
+ * *********************************/
+#define SPICE_MIGRATE_DATA_MAIN_VERSION 1 /* NOTE: increase version when CHAR_DEVICE_VERSION
+ is increased */
+#define SPICE_MIGRATE_DATA_MAIN_MAGIC SPICE_MAGIC_CONST("MNMD")
+
+typedef struct __attribute__ ((__packed__)) SpiceMigrateDataMain {
+ SpiceMigrateDataCharDevice agent_base;
+ uint8_t client_agent_started; /* for discarding messages */
+
+ struct __attribute__ ((__packed__)) {
+ /* partial data read from device. Such data is stored only
+ * if the chunk header or the entire msg header haven't yet been read completely.
+ * Once the headers are read, partial reads of chunks can be sent as
+ * smaller chunks to the client, without the roundtrip overhead of migration data */
+ uint32_t chunk_header_size;
+ VDIChunkHeader chunk_header;
+ uint8_t msg_header_done;
+ uint32_t msg_header_partial_len;
+ uint32_t msg_header_ptr;
+ uint32_t msg_remaining;
+ uint8_t msg_filter_result;
+ } agent2client;
+
+ struct __attribute__ ((__packed__)) {
+ uint32_t msg_remaining;
+ uint8_t msg_filter_result;
+ } client2agent;
+} SpiceMigrateDataMain;
+
+/* ****************
+ * display channel
+ * ***************/
+
+#define SPICE_MIGRATE_DATA_DISPLAY_VERSION 1
+#define SPICE_MIGRATE_DATA_DISPLAY_MAGIC SPICE_MAGIC_CONST("DCMD")
+
+/*
+ * TODO: store the cache and dictionary data only in one channel (the
+ * freezer).
+ * TODO: optimizations: don't send surfaces information if it will be faster
+ * to resend the surfaces on-demand.
+ * */
+#define MIGRATE_DATA_DISPLAY_MAX_CACHE_CLIENTS 4
+
+typedef struct __attribute__ ((__packed__)) SpiceMigrateDataDisplay {
+ uint64_t message_serial;
+ uint8_t low_bandwidth_setting;
+
+ /*
+ * Synchronizing the shared pixmap cache.
+ * For now, the cache is not migrated, and instead, we reset it and send
+ * SPICE_MSG_DISPLAY_INVAL_ALL_PIXMAPS to the client.
+ * In order to keep the client and server caches consistent:
+ * The channel which freezed the cache on the src side, unfreezes it
+ * on the dest side, and increases its generation (see 'reset' in red_client_shared_cach.h).
+ * In order to enforce that images that are added to the cache by other channels
+ * will reach the client only after SPICE_MSG_DISPLAY_INVAL_ALL_PIXMAPS,
+ * we send SPICE_MSG_WAIT_FOR_CHANNELS
+ * (see the generation mismatch handling in 'add' in red_client_shared_cach.h).
+ */
+ uint8_t pixmap_cache_id;
+ int64_t pixmap_cache_size;
+ uint8_t pixmap_cache_freezer;
+ uint64_t pixmap_cache_clients[MIGRATE_DATA_DISPLAY_MAX_CACHE_CLIENTS];
+
+ uint8_t glz_dict_id;
+ GlzEncDictRestoreData glz_dict_data;
+
+ uint32_t surfaces_at_client_ptr; /* reference to MigrateDisplaySurfacesAtClientLossless/Lossy.
+ Lossy: when jpeg-wan-compression(qemu cmd line)=always
+ or when jpeg-wan-compression=auto,
+ and low_bandwidth_setting=TRUE */
+
+} SpiceMigrateDataDisplay;
+
+typedef struct __attribute__ ((__packed__)) SpiceMigrateDataRect {
+ int32_t left;
+ int32_t top;
+ int32_t right;
+ int32_t bottom;
+} SpiceMigrateDataRect;
+
+typedef struct __attribute__ ((__packed__)) MigrateDisplaySurfaceLossless {
+ uint32_t id;
+} MigrateDisplaySurfaceLossless;
+
+typedef struct __attribute__ ((__packed__)) MigrateDisplaySurfaceLossy {
+ uint32_t id;
+ SpiceMigrateDataRect lossy_rect;
+} MigrateDisplaySurfaceLossy;
+
+typedef struct __attribute__ ((__packed__)) MigrateDisplaySurfacesAtClientLossless {
+ uint32_t num_surfaces;
+ MigrateDisplaySurfaceLossless surfaces[0];
+} MigrateDisplaySurfacesAtClientLossless;
+
+typedef struct __attribute__ ((__packed__)) MigrateDisplaySurfacesAtClientLossy {
+ uint32_t num_surfaces;
+ MigrateDisplaySurfaceLossy surfaces[0];
+} MigrateDisplaySurfacesAtClientLossy;
+
+/* ****************
+ * inputs channel
+ * ***************/
+
+#define SPICE_MIGRATE_DATA_INPUTS_VERSION 1
+#define SPICE_MIGRATE_DATA_INPUTS_MAGIC SPICE_MAGIC_CONST("ICMD")
+
+
+typedef struct __attribute__ ((__packed__)) SpiceMigrateDataInputs {
+ uint16_t motion_count;
+} SpiceMigrateDataInputs;
+
+static inline int migration_protocol_validate_header(SpiceMigrateDataHeader *header,
+ uint32_t magic,
+ uint32_t version)
+{
+ if (header->magic != magic) {
+ spice_error("bad magic %u (!= %u)", header->magic, magic);
+ return FALSE;
+ }
+ if (header->version > version) {
+ spice_error("unsupported version %u (> %u)", header->version, version);
+ return FALSE;
+ }
+ return TRUE;
+}
+
+#endif
diff --git a/server/migration_protocol.h b/server/migration_protocol.h
deleted file mode 100644
index 21d3ec8..0000000
--- a/server/migration_protocol.h
+++ /dev/null
@@ -1,213 +0,0 @@
-/*
- Copyright (C) 2012 Red Hat, Inc.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, see <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _H_MIGRATION_PROTOCOL
-#define _H_MIGRATION_PROTOCOL
-
-#include <spice/macros.h>
-#include <spice/vd_agent.h>
-#include "glz_encoder_dictionary.h"
-
-/* ************************************************
- * src-server to dst-server migration data messages
- * ************************************************/
-
-/* increase the version when the version of any
- * of the migration data messages is increased */
-#define SPICE_MIGRATION_PROTOCOL_VERSION 1
-
-typedef struct __attribute__ ((__packed__)) SpiceMigrateDataHeader {
- uint32_t magic;
- uint32_t version;
-} SpiceMigrateDataHeader;
-
-/* ********************
- * Char device base
- * *******************/
-
-/* increase the version of descendent char devices when this
- * version is increased */
-#define SPICE_MIGRATE_DATA_CHAR_DEVICE_VERSION 1
-
-/* Should be the first field of any of the char_devices migration data (see write_data_ptr) */
-typedef struct __attribute__ ((__packed__)) SpiceMigrateDataCharDevice {
- uint32_t version;
- uint8_t connected;
- uint32_t num_client_tokens;
- uint32_t num_send_tokens;
- uint32_t write_size; /* write to dev */
- uint32_t write_num_client_tokens; /* how many messages from the client are part of the write_data */
- uint32_t write_data_ptr; /* offset from
- SpiceMigrateDataCharDevice - sizeof(SpiceMigrateDataHeader) */
-} SpiceMigrateDataCharDevice;
-
-/* ********
- * spicevmc
- * ********/
-
-#define SPICE_MIGRATE_DATA_SPICEVMC_VERSION 1 /* NOTE: increase version when CHAR_DEVICE_VERSION
- is increased */
-#define SPICE_MIGRATE_DATA_SPICEVMC_MAGIC SPICE_MAGIC_CONST("SVMD")
-typedef struct __attribute__ ((__packed__)) SpiceMigrateDataSpiceVmc {
- SpiceMigrateDataCharDevice base;
-} SpiceMigrateDataSpiceVmc;
-
-/* *********
- * smartcard
- * *********/
-
-#define SPICE_MIGRATE_DATA_SMARTCARD_VERSION 1 /* NOTE: increase version when CHAR_DEVICE_VERSION
- is increased */
-#define SPICE_MIGRATE_DATA_SMARTCARD_MAGIC SPICE_MAGIC_CONST("SCMD")
-typedef struct __attribute__ ((__packed__)) SpiceMigrateDataSmartcard {
- SpiceMigrateDataCharDevice base;
- uint8_t reader_added;
- uint32_t read_size; /* partial data read from dev */
- uint32_t read_data_ptr;
-} SpiceMigrateDataSmartcard;
-
-/* *********************************
- * main channel (mainly guest agent)
- * *********************************/
-#define SPICE_MIGRATE_DATA_MAIN_VERSION 1 /* NOTE: increase version when CHAR_DEVICE_VERSION
- is increased */
-#define SPICE_MIGRATE_DATA_MAIN_MAGIC SPICE_MAGIC_CONST("MNMD")
-
-typedef struct __attribute__ ((__packed__)) SpiceMigrateDataMain {
- SpiceMigrateDataCharDevice agent_base;
- uint8_t client_agent_started; /* for discarding messages */
-
- struct __attribute__ ((__packed__)) {
- /* partial data read from device. Such data is stored only
- * if the chunk header or the entire msg header haven't yet been read completely.
- * Once the headers are read, partial reads of chunks can be sent as
- * smaller chunks to the client, without the roundtrip overhead of migration data */
- uint32_t chunk_header_size;
- VDIChunkHeader chunk_header;
- uint8_t msg_header_done;
- uint32_t msg_header_partial_len;
- uint32_t msg_header_ptr;
- uint32_t msg_remaining;
- uint8_t msg_filter_result;
- } agent2client;
-
- struct __attribute__ ((__packed__)) {
- uint32_t msg_remaining;
- uint8_t msg_filter_result;
- } client2agent;
-} SpiceMigrateDataMain;
-
-/* ****************
- * display channel
- * ***************/
-
-#define SPICE_MIGRATE_DATA_DISPLAY_VERSION 1
-#define SPICE_MIGRATE_DATA_DISPLAY_MAGIC SPICE_MAGIC_CONST("DCMD")
-
-/*
- * TODO: store the cache and dictionary data only in one channel (the
- * freezer).
- * TODO: optimizations: don't send surfaces information if it will be faster
- * to resend the surfaces on-demand.
- * */
-#define MIGRATE_DATA_DISPLAY_MAX_CACHE_CLIENTS 4
-
-typedef struct __attribute__ ((__packed__)) SpiceMigrateDataDisplay {
- uint64_t message_serial;
- uint8_t low_bandwidth_setting;
-
- /*
- * Synchronizing the shared pixmap cache.
- * For now, the cache is not migrated, and instead, we reset it and send
- * SPICE_MSG_DISPLAY_INVAL_ALL_PIXMAPS to the client.
- * In order to keep the client and server caches consistent:
- * The channel which freezed the cache on the src side, unfreezes it
- * on the dest side, and increases its generation (see 'reset' in red_client_shared_cach.h).
- * In order to enforce that images that are added to the cache by other channels
- * will reach the client only after SPICE_MSG_DISPLAY_INVAL_ALL_PIXMAPS,
- * we send SPICE_MSG_WAIT_FOR_CHANNELS
- * (see the generation mismatch handling in 'add' in red_client_shared_cach.h).
- */
- uint8_t pixmap_cache_id;
- int64_t pixmap_cache_size;
- uint8_t pixmap_cache_freezer;
- uint64_t pixmap_cache_clients[MIGRATE_DATA_DISPLAY_MAX_CACHE_CLIENTS];
-
- uint8_t glz_dict_id;
- GlzEncDictRestoreData glz_dict_data;
-
- uint32_t surfaces_at_client_ptr; /* reference to MigrateDisplaySurfacesAtClientLossless/Lossy.
- Lossy: when jpeg-wan-compression(qemu cmd line)=always
- or when jpeg-wan-compression=auto,
- and low_bandwidth_setting=TRUE */
-
-} SpiceMigrateDataDisplay;
-
-typedef struct __attribute__ ((__packed__)) SpiceMigrateDataRect {
- int32_t left;
- int32_t top;
- int32_t right;
- int32_t bottom;
-} SpiceMigrateDataRect;
-
-typedef struct __attribute__ ((__packed__)) MigrateDisplaySurfaceLossless {
- uint32_t id;
-} MigrateDisplaySurfaceLossless;
-
-typedef struct __attribute__ ((__packed__)) MigrateDisplaySurfaceLossy {
- uint32_t id;
- SpiceMigrateDataRect lossy_rect;
-} MigrateDisplaySurfaceLossy;
-
-typedef struct __attribute__ ((__packed__)) MigrateDisplaySurfacesAtClientLossless {
- uint32_t num_surfaces;
- MigrateDisplaySurfaceLossless surfaces[0];
-} MigrateDisplaySurfacesAtClientLossless;
-
-typedef struct __attribute__ ((__packed__)) MigrateDisplaySurfacesAtClientLossy {
- uint32_t num_surfaces;
- MigrateDisplaySurfaceLossy surfaces[0];
-} MigrateDisplaySurfacesAtClientLossy;
-
-/* ****************
- * inputs channel
- * ***************/
-
-#define SPICE_MIGRATE_DATA_INPUTS_VERSION 1
-#define SPICE_MIGRATE_DATA_INPUTS_MAGIC SPICE_MAGIC_CONST("ICMD")
-
-
-typedef struct __attribute__ ((__packed__)) SpiceMigrateDataInputs {
- uint16_t motion_count;
-} SpiceMigrateDataInputs;
-
-static inline int migration_protocol_validate_header(SpiceMigrateDataHeader *header,
- uint32_t magic,
- uint32_t version)
-{
- if (header->magic != magic) {
- spice_error("bad magic %u (!= %u)", header->magic, magic);
- return FALSE;
- }
- if (header->version > version) {
- spice_error("unsupported version %u (> %u)", header->version, version);
- return FALSE;
- }
- return TRUE;
-}
-
-#endif
diff --git a/server/mjpeg-encoder.c b/server/mjpeg-encoder.c
new file mode 100644
index 0000000..04c95a6
--- /dev/null
+++ b/server/mjpeg-encoder.c
@@ -0,0 +1,1375 @@
+/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ Copyright (C) 2009 Red Hat, Inc.
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, see <http://www.gnu.org/licenses/>.
+*/
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "red_common.h"
+#include "mjpeg-encoder.h"
+#include "utils.h"
+#include <jerror.h>
+#include <jpeglib.h>
+#include <inttypes.h>
+
+#define MJPEG_MAX_FPS 25
+#define MJPEG_MIN_FPS 1
+
+#define MJPEG_QUALITY_SAMPLE_NUM 7
+static const int mjpeg_quality_samples[MJPEG_QUALITY_SAMPLE_NUM] = {20, 30, 40, 50, 60, 70, 80};
+
+#define MJPEG_LEGACY_STATIC_QUALITY_ID 5 // jpeg quality 70
+
+#define MJPEG_IMPROVE_QUALITY_FPS_STRICT_TH 10
+#define MJPEG_IMPROVE_QUALITY_FPS_PERMISSIVE_TH 5
+
+#define MJPEG_AVERAGE_SIZE_WINDOW 3
+
+#define MJPEG_BIT_RATE_EVAL_MIN_NUM_FRAMES 3
+#define MJPEG_LOW_FPS_RATE_TH 3
+
+#define MJPEG_SERVER_STATUS_EVAL_FPS_INTERVAL 1
+#define MJPEG_SERVER_STATUS_DOWNGRADE_DROP_FACTOR_TH 0.1
+
+/*
+ * acting on positive client reports only if enough frame mm time
+ * has passed since the last bit rate change and the report.
+ * time
+ */
+#define MJPEG_CLIENT_POSITIVE_REPORT_TIMEOUT 2000
+#define MJPEG_CLIENT_POSITIVE_REPORT_STRICT_TIMEOUT 3000
+
+#define MJPEG_ADJUST_FPS_TIMEOUT 500
+
+/*
+ * avoid interrupting the playback when there are temporary
+ * incidents of instability (with respect to server and client drops)
+ */
+#define MJPEG_MAX_CLIENT_PLAYBACK_DELAY 5000 // 5 sec
+
+/*
+ * The stream starts after lossless frames were sent to the client,
+ * and without rate control (except for pipe congestion). Thus, on the beginning
+ * of the stream, we might observe frame drops on the client and server side which
+ * are not necessarily related to mis-estimation of the bit rate, and we would
+ * like to wait till the stream stabilizes.
+ */
+#define MJPEG_WARMUP_TIME 3000LL // 3 sec
+
+enum {
+ MJPEG_QUALITY_EVAL_TYPE_SET,
+ MJPEG_QUALITY_EVAL_TYPE_UPGRADE,
+ MJPEG_QUALITY_EVAL_TYPE_DOWNGRADE,
+};
+
+enum {
+ MJPEG_QUALITY_EVAL_REASON_SIZE_CHANGE,
+ MJPEG_QUALITY_EVAL_REASON_RATE_CHANGE,
+};
+
+typedef struct MJpegEncoderQualityEval {
+ int type;
+ int reason;
+
+ uint64_t encoded_size_by_quality[MJPEG_QUALITY_SAMPLE_NUM];
+ /* lower limit for the current evaluation round */
+ int min_quality_id;
+ int min_quality_fps; // min fps for the given quality
+ /* upper limit for the current evaluation round */
+ int max_quality_id;
+ int max_quality_fps; // max fps for the given quality
+ /* tracking the best sampled fps so far */
+ int max_sampled_fps;
+ int max_sampled_fps_quality_id;
+} MJpegEncoderQualityEval;
+
+typedef struct MJpegEncoderClientState {
+ int max_video_latency;
+ uint32_t max_audio_latency;
+} MJpegEncoderClientState;
+
+typedef struct MJpegEncoderServerState {
+ uint32_t num_frames_encoded;
+ uint32_t num_frames_dropped;
+} MJpegEncoderServerState;
+
+typedef struct MJpegEncoderBitRateInfo {
+ uint64_t change_start_time;
+ uint64_t last_frame_time;
+ uint32_t change_start_mm_time;
+ int was_upgraded;
+
+ /* gathering data about the frames that
+ * were encoded since the last bit rate change*/
+ uint32_t num_enc_frames;
+ uint64_t sum_enc_size;
+} MJpegEncoderBitRateInfo;
+
+/*
+ * Adjusting the stream jpeg quality and frame rate (fps):
+ * When during_quality_eval=TRUE, we compress different frames with different
+ * jpeg quality. By considering (1) the resulting compression ratio, and (2) the available
+ * bit rate, we evaluate the max frame frequency for the stream with the given quality,
+ * and we choose the highest quality that will allow a reasonable frame rate.
+ * during_quality_eval is set for new streams and can also be set any time we want
+ * to re-evaluate the stream parameters (e.g., when the bit rate and/or
+ * compressed frame size significantly change).
+ */
+typedef struct MJpegEncoderRateControl {
+ int during_quality_eval;
+ MJpegEncoderQualityEval quality_eval_data;
+ MJpegEncoderBitRateInfo bit_rate_info;
+ MJpegEncoderClientState client_state;
+ MJpegEncoderServerState server_state;
+
+ uint64_t byte_rate;
+ int quality_id;
+ uint32_t fps;
+ double adjusted_fps;
+ uint64_t adjusted_fps_start_time;
+ uint64_t adjusted_fps_num_frames;
+
+ /* the encoded frame size which the quality and the fps evaluation was based upon */
+ uint64_t base_enc_size;
+
+ uint64_t last_enc_size;
+
+ uint64_t sum_recent_enc_size;
+ uint32_t num_recent_enc_frames;
+
+ uint64_t warmup_start_time;
+} MJpegEncoderRateControl;
+
+struct MJpegEncoder {
+ uint8_t *row;
+ uint32_t row_size;
+ int first_frame;
+
+ struct jpeg_compress_struct cinfo;
+ struct jpeg_error_mgr jerr;
+
+ unsigned int bytes_per_pixel; /* bytes per pixel of the input buffer */
+ void (*pixel_converter)(void *src, uint8_t *dest);
+
+ MJpegEncoderRateControl rate_control;
+ MJpegEncoderRateControlCbs cbs;
+ void *cbs_opaque;
+
+ /* stats */
+ uint64_t starting_bit_rate;
+ uint64_t avg_quality;
+ uint32_t num_frames;
+};
+
+static void mjpeg_encoder_process_server_drops(MJpegEncoder *encoder);
+static uint32_t get_min_required_playback_delay(uint64_t frame_enc_size,
+ uint64_t byte_rate,
+ uint32_t latency);
+
+static inline int rate_control_is_active(MJpegEncoder* encoder)
+{
+ return encoder->cbs.get_roundtrip_ms != NULL;
+}
+
+void mjpeg_encoder_destroy(MJpegEncoder *encoder)
+{
+ free(encoder->cinfo.dest);
+ jpeg_destroy_compress(&encoder->cinfo);
+ free(encoder->row);
+ free(encoder);
+}
+
+static uint8_t mjpeg_encoder_get_bytes_per_pixel(MJpegEncoder *encoder)
+{
+ return encoder->bytes_per_pixel;
+}
+
+#ifndef JCS_EXTENSIONS
+/* Pixel conversion routines */
+static void pixel_rgb24bpp_to_24(void *src_ptr, uint8_t *dest)
+{
+ uint8_t *src = src_ptr;
+ /* libjpegs stores rgb, spice/win32 stores bgr */
+ *dest++ = src[2]; /* red */
+ *dest++ = src[1]; /* green */
+ *dest++ = src[0]; /* blue */
+}
+
+static void pixel_rgb32bpp_to_24(void *src, uint8_t *dest)
+{
+ uint32_t pixel = *(uint32_t *)src;
+ *dest++ = (pixel >> 16) & 0xff;
+ *dest++ = (pixel >> 8) & 0xff;
+ *dest++ = (pixel >> 0) & 0xff;
+}
+#endif
+
+static void pixel_rgb16bpp_to_24(void *src, uint8_t *dest)
+{
+ uint16_t pixel = *(uint16_t *)src;
+ *dest++ = ((pixel >> 7) & 0xf8) | ((pixel >> 12) & 0x7);
+ *dest++ = ((pixel >> 2) & 0xf8) | ((pixel >> 7) & 0x7);
+ *dest++ = ((pixel << 3) & 0xf8) | ((pixel >> 2) & 0x7);
+}
+
+
+/* code from libjpeg 8 to handle compression to a memory buffer
+ *
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * Modified 2009 by Guido Vollbeding.
+ * This file is part of the Independent JPEG Group's software.
+ */
+typedef struct {
+ struct jpeg_destination_mgr pub; /* public fields */
+
+ unsigned char ** outbuffer; /* target buffer */
+ size_t * outsize;
+ uint8_t * buffer; /* start of buffer */
+ size_t bufsize;
+} mem_destination_mgr;
+
+static void init_mem_destination(j_compress_ptr cinfo)
+{
+}
+
+static boolean empty_mem_output_buffer(j_compress_ptr cinfo)
+{
+ size_t nextsize;
+ uint8_t * nextbuffer;
+ mem_destination_mgr *dest = (mem_destination_mgr *) cinfo->dest;
+
+ /* Try to allocate new buffer with double size */
+ nextsize = dest->bufsize * 2;
+ nextbuffer = malloc(nextsize);
+
+ if (nextbuffer == NULL)
+ ERREXIT1(cinfo, JERR_OUT_OF_MEMORY, 10);
+
+ memcpy(nextbuffer, dest->buffer, dest->bufsize);
+
+ free(dest->buffer);
+
+ dest->pub.next_output_byte = nextbuffer + dest->bufsize;
+ dest->pub.free_in_buffer = dest->bufsize;
+
+ dest->buffer = nextbuffer;
+ dest->bufsize = nextsize;
+
+ return TRUE;
+}
+
+static void term_mem_destination(j_compress_ptr cinfo)
+{
+ mem_destination_mgr *dest = (mem_destination_mgr *) cinfo->dest;
+
+ *dest->outbuffer = dest->buffer;
+ *dest->outsize = dest->bufsize;
+}
+
+/*
+ * Prepare for output to a memory buffer.
+ * The caller may supply an own initial buffer with appropriate size.
+ * Otherwise, or when the actual data output exceeds the given size,
+ * the library adapts the buffer size as necessary.
+ * The standard library functions malloc/free are used for allocating
+ * larger memory, so the buffer is available to the application after
+ * finishing compression, and then the application is responsible for
+ * freeing the requested memory.
+ */
+
+static void
+spice_jpeg_mem_dest(j_compress_ptr cinfo,
+ unsigned char ** outbuffer, size_t * outsize)
+{
+ mem_destination_mgr *dest;
+#define OUTPUT_BUF_SIZE 4096 /* choose an efficiently fwrite'able size */
+
+ if (outbuffer == NULL || outsize == NULL) /* sanity check */
+ ERREXIT(cinfo, JERR_BUFFER_SIZE);
+
+ /* The destination object is made permanent so that multiple JPEG images
+ * can be written to the same buffer without re-executing jpeg_mem_dest.
+ */
+ if (cinfo->dest == NULL) { /* first time for this JPEG object? */
+ cinfo->dest = spice_malloc(sizeof(mem_destination_mgr));
+ }
+
+ dest = (mem_destination_mgr *) cinfo->dest;
+ dest->pub.init_destination = init_mem_destination;
+ dest->pub.empty_output_buffer = empty_mem_output_buffer;
+ dest->pub.term_destination = term_mem_destination;
+ dest->outbuffer = outbuffer;
+ dest->outsize = outsize;
+ if (*outbuffer == NULL || *outsize == 0) {
+ /* Allocate initial buffer */
+ *outbuffer = malloc(OUTPUT_BUF_SIZE);
+ if (*outbuffer == NULL)
+ ERREXIT1(cinfo, JERR_OUT_OF_MEMORY, 10);
+ *outsize = OUTPUT_BUF_SIZE;
+ }
+
+ dest->pub.next_output_byte = dest->buffer = *outbuffer;
+ dest->pub.free_in_buffer = dest->bufsize = *outsize;
+}
+/* end of code from libjpeg */
+
+static inline uint32_t mjpeg_encoder_get_source_fps(MJpegEncoder *encoder)
+{
+ return encoder->cbs.get_source_fps ?
+ encoder->cbs.get_source_fps(encoder->cbs_opaque) : MJPEG_MAX_FPS;
+}
+
+static inline uint32_t mjpeg_encoder_get_latency(MJpegEncoder *encoder)
+{
+ return encoder->cbs.get_roundtrip_ms ?
+ encoder->cbs.get_roundtrip_ms(encoder->cbs_opaque) / 2 : 0;
+}
+
+static uint32_t get_max_fps(uint64_t frame_size, uint64_t bytes_per_sec)
+{
+ double fps;
+ double send_time_ms;
+
+ if (!bytes_per_sec) {
+ return 0;
+ }
+ send_time_ms = frame_size * 1000.0 / bytes_per_sec;
+ fps = send_time_ms ? 1000 / send_time_ms : MJPEG_MAX_FPS;
+ return fps;
+}
+
+static inline void mjpeg_encoder_reset_quality(MJpegEncoder *encoder,
+ int quality_id,
+ uint32_t fps,
+ uint64_t frame_enc_size)
+{
+ MJpegEncoderRateControl *rate_control = &encoder->rate_control;
+ double fps_ratio;
+
+ rate_control->during_quality_eval = FALSE;
+
+ if (rate_control->quality_id != quality_id) {
+ rate_control->last_enc_size = 0;
+ }
+
+ if (rate_control->quality_eval_data.reason == MJPEG_QUALITY_EVAL_REASON_RATE_CHANGE) {
+ memset(&rate_control->server_state, 0, sizeof(MJpegEncoderServerState));
+ }
+ rate_control->quality_id = quality_id;
+ memset(&rate_control->quality_eval_data, 0, sizeof(MJpegEncoderQualityEval));
+ rate_control->quality_eval_data.max_quality_id = MJPEG_QUALITY_SAMPLE_NUM - 1;
+ rate_control->quality_eval_data.max_quality_fps = MJPEG_MAX_FPS;
+
+ if (rate_control->adjusted_fps) {
+ fps_ratio = rate_control->adjusted_fps / rate_control->fps;
+ } else {
+ fps_ratio = 1.5;
+ }
+ rate_control->fps = MAX(MJPEG_MIN_FPS, fps);
+ rate_control->fps = MIN(MJPEG_MAX_FPS, rate_control->fps);
+ rate_control->adjusted_fps = rate_control->fps*fps_ratio;
+ spice_debug("adjusted-fps-ratio=%.2f adjusted-fps=%.2f", fps_ratio, rate_control->adjusted_fps);
+ rate_control->adjusted_fps_start_time = 0;
+ rate_control->adjusted_fps_num_frames = 0;
+ rate_control->base_enc_size = frame_enc_size;
+
+ rate_control->sum_recent_enc_size = 0;
+ rate_control->num_recent_enc_frames = 0;
+}
+
+#define QUALITY_WAS_EVALUATED(encoder, quality) \
+ ((encoder)->rate_control.quality_eval_data.encoded_size_by_quality[(quality)] != 0)
+
+/*
+ * Adjust the stream's jpeg quality and frame rate.
+ * We evaluate the compression ratio of different jpeg qualities;
+ * We compress successive frames with different qualities,
+ * and then we estimate the stream frame rate according to the currently
+ * evaluated jpeg quality and available bit rate.
+ *
+ * During quality evaluation, mjpeg_encoder_eval_quality is called before a new
+ * frame is encoded. mjpeg_encoder_eval_quality examines the encoding size of
+ * the previously encoded frame, and determines whether to continue evaluation
+ * (and chnages the quality for the frame that is going to be encoded),
+ * or stop evaluation (and sets the quality and frame rate for the stream).
+ * When qualities are scanned, we assume monotonicity of compression ratio
+ * as a function of jpeg quality. When we reach a quality with too small, or
+ * big enough compression ratio, we stop the evaluation and set the stream parameters.
+*/
+static inline void mjpeg_encoder_eval_quality(MJpegEncoder *encoder)
+{
+ MJpegEncoderRateControl *rate_control;
+ MJpegEncoderQualityEval *quality_eval;
+ uint32_t fps, src_fps;
+ uint64_t enc_size;
+ uint32_t final_quality_id;
+ uint32_t final_fps;
+ uint64_t final_quality_enc_size;
+
+ rate_control = &encoder->rate_control;
+ quality_eval = &rate_control->quality_eval_data;
+
+ spice_assert(rate_control->during_quality_eval);
+
+ /* retrieving the encoded size of the last encoded frame */
+ enc_size = quality_eval->encoded_size_by_quality[rate_control->quality_id];
+ if (enc_size == 0) {
+ spice_debug("size info missing");
+ return;
+ }
+
+ src_fps = mjpeg_encoder_get_source_fps(encoder);
+
+ fps = get_max_fps(enc_size, rate_control->byte_rate);
+ spice_debug("mjpeg %p: jpeg %d: %.2f (KB) fps %d src-fps %u",
+ encoder,
+ mjpeg_quality_samples[rate_control->quality_id],
+ enc_size / 1024.0,
+ fps,
+ src_fps);
+
+ if (fps > quality_eval->max_sampled_fps ||
+ ((fps == quality_eval->max_sampled_fps || fps >= src_fps) &&
+ rate_control->quality_id > quality_eval->max_sampled_fps_quality_id)) {
+ quality_eval->max_sampled_fps = fps;
+ quality_eval->max_sampled_fps_quality_id = rate_control->quality_id;
+ }
+
+ /*
+ * Choosing whether to evaluate another quality, or to complete evaluation
+ * and set the stream parameters according to one of the qualities that
+ * were already sampled.
+ */
+
+ if (rate_control->quality_id > MJPEG_QUALITY_SAMPLE_NUM / 2 &&
+ fps < MJPEG_IMPROVE_QUALITY_FPS_STRICT_TH &&
+ fps < src_fps) {
+ /*
+ * When the jpeg quality is bigger than the median quality, prefer a reasonable
+ * frame rate over improving the quality
+ */
+ spice_debug("fps < %d && (fps < src_fps), quality %d",
+ MJPEG_IMPROVE_QUALITY_FPS_STRICT_TH,
+ mjpeg_quality_samples[rate_control->quality_id]);
+ if (QUALITY_WAS_EVALUATED(encoder, rate_control->quality_id - 1)) {
+ /* the next worse quality was already evaluated and it passed the frame
+ * rate thresholds (we know that, because we continued evaluating a better
+ * quality) */
+ rate_control->quality_id--;
+ goto complete_sample;
+ } else {
+ /* evaluate the next worse quality */
+ rate_control->quality_id--;
+ }
+ } else if ((fps > MJPEG_IMPROVE_QUALITY_FPS_PERMISSIVE_TH &&
+ fps >= 0.66 * quality_eval->min_quality_fps) || fps >= src_fps) {
+ /* When the jpeg quality is worse than the median one (see first condition), we allow a less
+ strict threshold for fps, in order to improve the jpeg quality */
+ if (rate_control->quality_id + 1 == MJPEG_QUALITY_SAMPLE_NUM ||
+ rate_control->quality_id >= quality_eval->max_quality_id ||
+ QUALITY_WAS_EVALUATED(encoder, rate_control->quality_id + 1)) {
+ /* best quality has been reached, or the next (better) quality was
+ * already evaluated and didn't pass the fps thresholds */
+ goto complete_sample;
+ } else {
+ if (rate_control->quality_id == MJPEG_QUALITY_SAMPLE_NUM / 2 &&
+ fps < MJPEG_IMPROVE_QUALITY_FPS_STRICT_TH &&
+ fps < src_fps) {
+ goto complete_sample;
+ }
+ /* evaluate the next quality as well*/
+ rate_control->quality_id++;
+ }
+ } else { // very small frame rate, try to improve by downgrading the quality
+ if (rate_control->quality_id == 0 ||
+ rate_control->quality_id <= quality_eval->min_quality_id) {
+ goto complete_sample;
+ } else if (QUALITY_WAS_EVALUATED(encoder, rate_control->quality_id - 1)) {
+ rate_control->quality_id--;
+ goto complete_sample;
+ } else {
+ /* evaluate the next worse quality */
+ rate_control->quality_id--;
+ }
+ }
+ return;
+
+complete_sample:
+ if (quality_eval->max_sampled_fps != 0) {
+ /* covering a case were monotonicity was violated and we sampled
+ a better jepg quality, with better frame rate. */
+ final_quality_id = MAX(rate_control->quality_id,
+ quality_eval->max_sampled_fps_quality_id);
+ } else {
+ final_quality_id = rate_control->quality_id;
+ }
+ final_quality_enc_size = quality_eval->encoded_size_by_quality[final_quality_id];
+ final_fps = get_max_fps(final_quality_enc_size,
+ rate_control->byte_rate);
+
+ if (final_quality_id == quality_eval->min_quality_id) {
+ final_fps = MAX(final_fps, quality_eval->min_quality_fps);
+ }
+ if (final_quality_id == quality_eval->max_quality_id) {
+ final_fps = MIN(final_fps, quality_eval->max_quality_fps);
+ }
+ mjpeg_encoder_reset_quality(encoder, final_quality_id, final_fps, final_quality_enc_size);
+ rate_control->sum_recent_enc_size = final_quality_enc_size;
+ rate_control->num_recent_enc_frames = 1;
+
+ spice_debug("MJpeg quality sample end %p: quality %d fps %d",
+ encoder, mjpeg_quality_samples[rate_control->quality_id], rate_control->fps);
+ if (encoder->cbs.update_client_playback_delay) {
+ uint32_t latency = mjpeg_encoder_get_latency(encoder);
+ uint32_t min_delay = get_min_required_playback_delay(final_quality_enc_size,
+ rate_control->byte_rate,
+ latency);
+
+ encoder->cbs.update_client_playback_delay(encoder->cbs_opaque, min_delay);
+ }
+}
+
+static void mjpeg_encoder_quality_eval_set_upgrade(MJpegEncoder *encoder,
+ int reason,
+ uint32_t min_quality_id,
+ uint32_t min_quality_fps)
+{
+ MJpegEncoderQualityEval *quality_eval = &encoder->rate_control.quality_eval_data;
+
+ encoder->rate_control.during_quality_eval = TRUE;
+ quality_eval->type = MJPEG_QUALITY_EVAL_TYPE_UPGRADE;
+ quality_eval->reason = reason;
+ quality_eval->min_quality_id = min_quality_id;
+ quality_eval->min_quality_fps = min_quality_fps;
+}
+
+static void mjpeg_encoder_quality_eval_set_downgrade(MJpegEncoder *encoder,
+ int reason,
+ uint32_t max_quality_id,
+ uint32_t max_quality_fps)
+{
+ MJpegEncoderQualityEval *quality_eval = &encoder->rate_control.quality_eval_data;
+
+ encoder->rate_control.during_quality_eval = TRUE;
+ quality_eval->type = MJPEG_QUALITY_EVAL_TYPE_DOWNGRADE;
+ quality_eval->reason = reason;
+ quality_eval->max_quality_id = max_quality_id;
+ quality_eval->max_quality_fps = max_quality_fps;
+}
+
+static void mjpeg_encoder_adjust_params_to_bit_rate(MJpegEncoder *encoder)
+{
+ MJpegEncoderRateControl *rate_control;
+ MJpegEncoderQualityEval *quality_eval;
+ uint64_t new_avg_enc_size = 0;
+ uint32_t new_fps;
+ uint32_t latency = 0;
+ uint32_t src_fps;
+
+ spice_assert(rate_control_is_active(encoder));
+
+ rate_control = &encoder->rate_control;
+ quality_eval = &rate_control->quality_eval_data;
+
+ if (!rate_control->last_enc_size) {
+ spice_debug("missing sample size");
+ return;
+ }
+
+ if (rate_control->during_quality_eval) {
+ quality_eval->encoded_size_by_quality[rate_control->quality_id] = rate_control->last_enc_size;
+ mjpeg_encoder_eval_quality(encoder);
+ return;
+ }
+
+ if (!rate_control->num_recent_enc_frames) {
+ spice_debug("No recent encoded frames");
+ return;
+ }
+
+ if (rate_control->num_recent_enc_frames < MJPEG_AVERAGE_SIZE_WINDOW &&
+ rate_control->num_recent_enc_frames < rate_control->fps) {
+ goto end;
+ }
+
+ latency = mjpeg_encoder_get_latency(encoder);
+ new_avg_enc_size = rate_control->sum_recent_enc_size /
+ rate_control->num_recent_enc_frames;
+ new_fps = get_max_fps(new_avg_enc_size, rate_control->byte_rate);
+
+ spice_debug("cur-fps=%u new-fps=%u (new/old=%.2f) |"
+ "bit-rate=%.2f (Mbps) latency=%u (ms) quality=%d |"
+ " new-size-avg %"PRIu64" , base-size %"PRIu64", (new/old=%.2f) ",
+ rate_control->fps, new_fps, ((double)new_fps)/rate_control->fps,
+ ((double)rate_control->byte_rate*8)/1024/1024,
+ latency,
+ mjpeg_quality_samples[rate_control->quality_id],
+ new_avg_enc_size, rate_control->base_enc_size,
+ rate_control->base_enc_size ?
+ ((double)new_avg_enc_size) / rate_control->base_enc_size :
+ 1);
+
+ src_fps = mjpeg_encoder_get_source_fps(encoder);
+
+ /*
+ * The ratio between the new_fps and the current fps reflects the changes
+ * in latency and frame size. When the change passes a threshold,
+ * we re-evaluate the quality and frame rate.
+ */
+ if (new_fps > rate_control->fps &&
+ (rate_control->fps < src_fps || rate_control->quality_id < MJPEG_QUALITY_SAMPLE_NUM - 1)) {
+ spice_debug("mjpeg %p FPS CHANGE >> : re-evaluating params", encoder);
+ mjpeg_encoder_quality_eval_set_upgrade(encoder, MJPEG_QUALITY_EVAL_REASON_SIZE_CHANGE,
+ rate_control->quality_id, /* fps has improved -->
+ don't allow stream quality
+ to deteriorate */
+ rate_control->fps);
+ } else if (new_fps < rate_control->fps && new_fps < src_fps) {
+ spice_debug("mjpeg %p FPS CHANGE << : re-evaluating params", encoder);
+ mjpeg_encoder_quality_eval_set_downgrade(encoder, MJPEG_QUALITY_EVAL_REASON_SIZE_CHANGE,
+ rate_control->quality_id,
+ rate_control->fps);
+ }
+end:
+ if (rate_control->during_quality_eval) {
+ quality_eval->encoded_size_by_quality[rate_control->quality_id] = new_avg_enc_size;
+ mjpeg_encoder_eval_quality(encoder);
+ } else {
+ mjpeg_encoder_process_server_drops(encoder);
+ }
+}
+
+/*
+ * The actual frames distribution does not necessarily fit the condition "at least
+ * one frame every (1000/rate_contorl->fps) milliseconds".
+ * For keeping the average fps close to the defined fps, we periodically
+ * measure the current average fps, and modify rate_control->adjusted_fps accordingly.
+ * Then, we use (1000/rate_control->adjusted_fps) as the interval between frames.
+ */
+static void mjpeg_encoder_adjust_fps(MJpegEncoder *encoder, uint64_t now)
+{
+ MJpegEncoderRateControl *rate_control = &encoder->rate_control;
+ uint64_t adjusted_fps_time_passed;
+
+ spice_assert(rate_control_is_active(encoder));
+
+ adjusted_fps_time_passed = (now - rate_control->adjusted_fps_start_time) / 1000 / 1000;
+
+ if (!rate_control->during_quality_eval &&
+ adjusted_fps_time_passed > MJPEG_ADJUST_FPS_TIMEOUT &&
+ adjusted_fps_time_passed > 1000 / rate_control->adjusted_fps) {
+ double avg_fps;
+ double fps_ratio;
+
+ avg_fps = ((double)rate_control->adjusted_fps_num_frames*1000) /
+ adjusted_fps_time_passed;
+ spice_debug("#frames-adjust=%"PRIu64" #adjust-time=%"PRIu64" avg-fps=%.2f",
+ rate_control->adjusted_fps_num_frames, adjusted_fps_time_passed, avg_fps);
+ spice_debug("defined=%u old-adjusted=%.2f", rate_control->fps, rate_control->adjusted_fps);
+ fps_ratio = avg_fps / rate_control->fps;
+ if (avg_fps + 0.5 < rate_control->fps &&
+ mjpeg_encoder_get_source_fps(encoder) > avg_fps) {
+ double new_adjusted_fps = avg_fps ?
+ (rate_control->adjusted_fps/fps_ratio) :
+ rate_control->adjusted_fps * 2;
+
+ rate_control->adjusted_fps = MIN(rate_control->fps*2, new_adjusted_fps);
+ spice_debug("new-adjusted-fps=%.2f", rate_control->adjusted_fps);
+ } else if (rate_control->fps + 0.5 < avg_fps) {
+ double new_adjusted_fps = rate_control->adjusted_fps / fps_ratio;
+
+ rate_control->adjusted_fps = MAX(rate_control->fps, new_adjusted_fps);
+ spice_debug("new-adjusted-fps=%.2f", rate_control->adjusted_fps);
+ }
+ rate_control->adjusted_fps_start_time = now;
+ rate_control->adjusted_fps_num_frames = 0;
+ }
+}
+
+/*
+ * dest must be either NULL or allocated by malloc, since it might be freed
+ * during the encoding, if its size is too small.
+ *
+ * return:
+ * MJPEG_ENCODER_FRAME_UNSUPPORTED : frame cannot be encoded
+ * MJPEG_ENCODER_FRAME_DROP : frame should be dropped. This value can only be returned
+ * if mjpeg rate control is active.
+ * MJPEG_ENCODER_FRAME_ENCODE_DONE : frame encoding started. Continue with
+ * mjpeg_encoder_encode_scanline.
+ */
+static int mjpeg_encoder_start_frame(MJpegEncoder *encoder,
+ SpiceBitmapFmt format,
+ int width, int height,
+ uint8_t **dest, size_t *dest_len,
+ uint32_t frame_mm_time)
+{
+ uint32_t quality;
+
+ if (rate_control_is_active(encoder)) {
+ MJpegEncoderRateControl *rate_control = &encoder->rate_control;
+ uint64_t now;
+ uint64_t interval;
+
+ now = red_get_monotonic_time();
+
+ if (!rate_control->adjusted_fps_start_time) {
+ rate_control->adjusted_fps_start_time = now;
+ }
+ mjpeg_encoder_adjust_fps(encoder, now);
+ interval = (now - rate_control->bit_rate_info.last_frame_time);
+
+ if (interval < (1000*1000*1000) / rate_control->adjusted_fps) {
+ return MJPEG_ENCODER_FRAME_DROP;
+ }
+
+ mjpeg_encoder_adjust_params_to_bit_rate(encoder);
+
+ if (!rate_control->during_quality_eval ||
+ rate_control->quality_eval_data.reason == MJPEG_QUALITY_EVAL_REASON_SIZE_CHANGE) {
+ MJpegEncoderBitRateInfo *bit_rate_info;
+
+ bit_rate_info = &encoder->rate_control.bit_rate_info;
+
+ if (!bit_rate_info->change_start_time) {
+ bit_rate_info->change_start_time = now;
+ bit_rate_info->change_start_mm_time = frame_mm_time;
+ }
+ bit_rate_info->last_frame_time = now;
+ }
+ }
+
+ encoder->cinfo.in_color_space = JCS_RGB;
+ encoder->cinfo.input_components = 3;
+ encoder->pixel_converter = NULL;
+
+ switch (format) {
+ case SPICE_BITMAP_FMT_32BIT:
+ case SPICE_BITMAP_FMT_RGBA:
+ encoder->bytes_per_pixel = 4;
+#ifdef JCS_EXTENSIONS
+ encoder->cinfo.in_color_space = JCS_EXT_BGRX;
+ encoder->cinfo.input_components = 4;
+#else
+ encoder->pixel_converter = pixel_rgb32bpp_to_24;
+#endif
+ break;
+ case SPICE_BITMAP_FMT_16BIT:
+ encoder->bytes_per_pixel = 2;
+ encoder->pixel_converter = pixel_rgb16bpp_to_24;
+ break;
+ case SPICE_BITMAP_FMT_24BIT:
+ encoder->bytes_per_pixel = 3;
+#ifdef JCS_EXTENSIONS
+ encoder->cinfo.in_color_space = JCS_EXT_BGR;
+#else
+ encoder->pixel_converter = pixel_rgb24bpp_to_24;
+#endif
+ break;
+ default:
+ spice_debug("unsupported format %d", format);
+ return MJPEG_ENCODER_FRAME_UNSUPPORTED;
+ }
+
+ if (encoder->pixel_converter != NULL) {
+ unsigned int stride = width * 3;
+ /* check for integer overflow */
+ if (stride < width) {
+ return MJPEG_ENCODER_FRAME_UNSUPPORTED;
+ }
+ if (encoder->row_size < stride) {
+ encoder->row = spice_realloc(encoder->row, stride);
+ encoder->row_size = stride;
+ }
+ }
+
+ spice_jpeg_mem_dest(&encoder->cinfo, dest, dest_len);
+
+ encoder->cinfo.image_width = width;
+ encoder->cinfo.image_height = height;
+ jpeg_set_defaults(&encoder->cinfo);
+ encoder->cinfo.dct_method = JDCT_IFAST;
+ quality = mjpeg_quality_samples[encoder->rate_control.quality_id];
+ jpeg_set_quality(&encoder->cinfo, quality, TRUE);
+ jpeg_start_compress(&encoder->cinfo, encoder->first_frame);
+
+ encoder->num_frames++;
+ encoder->avg_quality += quality;
+ return MJPEG_ENCODER_FRAME_ENCODE_DONE;
+}
+
+static int mjpeg_encoder_encode_scanline(MJpegEncoder *encoder,
+ uint8_t *src_pixels,
+ size_t image_width)
+{
+ unsigned int scanlines_written;
+ uint8_t *row;
+
+ row = encoder->row;
+ if (encoder->pixel_converter) {
+ unsigned int x;
+ for (x = 0; x < image_width; x++) {
+ /* src_pixels is expected to be 4 bytes aligned */
+ encoder->pixel_converter(src_pixels, row);
+ row += 3;
+ src_pixels += encoder->bytes_per_pixel;
+ }
+ scanlines_written = jpeg_write_scanlines(&encoder->cinfo, &encoder->row, 1);
+ } else {
+ scanlines_written = jpeg_write_scanlines(&encoder->cinfo, &src_pixels, 1);
+ }
+ if (scanlines_written == 0) { /* Not enough space */
+ jpeg_abort_compress(&encoder->cinfo);
+ encoder->rate_control.last_enc_size = 0;
+ return 0;
+ }
+
+ return scanlines_written;
+}
+
+static size_t mjpeg_encoder_end_frame(MJpegEncoder *encoder)
+{
+ mem_destination_mgr *dest = (mem_destination_mgr *) encoder->cinfo.dest;
+ MJpegEncoderRateControl *rate_control = &encoder->rate_control;
+
+ jpeg_finish_compress(&encoder->cinfo);
+
+ encoder->first_frame = FALSE;
+ rate_control->last_enc_size = dest->pub.next_output_byte - dest->buffer;
+ rate_control->server_state.num_frames_encoded++;
+
+ if (!rate_control->during_quality_eval ||
+ rate_control->quality_eval_data.reason == MJPEG_QUALITY_EVAL_REASON_SIZE_CHANGE) {
+
+ if (!rate_control->during_quality_eval) {
+ if (rate_control->num_recent_enc_frames >= MJPEG_AVERAGE_SIZE_WINDOW) {
+ rate_control->num_recent_enc_frames = 0;
+ rate_control->sum_recent_enc_size = 0;
+ }
+ rate_control->sum_recent_enc_size += rate_control->last_enc_size;
+ rate_control->num_recent_enc_frames++;
+ rate_control->adjusted_fps_num_frames++;
+ }
+ rate_control->bit_rate_info.sum_enc_size += encoder->rate_control.last_enc_size;
+ rate_control->bit_rate_info.num_enc_frames++;
+ }
+ return encoder->rate_control.last_enc_size;
+}
+
+static inline uint8_t *get_image_line(SpiceChunks *chunks, size_t *offset,
+ int *chunk_nr, int stride)
+{
+ uint8_t *ret;
+ SpiceChunk *chunk;
+
+ chunk = &chunks->chunk[*chunk_nr];
+
+ if (*offset == chunk->len) {
+ if (*chunk_nr == chunks->num_chunks - 1) {
+ return NULL; /* Last chunk */
+ }
+ *offset = 0;
+ (*chunk_nr)++;
+ chunk = &chunks->chunk[*chunk_nr];
+ }
+
+ if (chunk->len - *offset < stride) {
+ spice_warning("bad chunk alignment");
+ return NULL;
+ }
+ ret = chunk->data + *offset;
+ *offset += stride;
+ return ret;
+}
+
+static int encode_frame(MJpegEncoder *encoder, const SpiceRect *src,
+ const SpiceBitmap *image, int top_down)
+{
+ SpiceChunks *chunks;
+ uint32_t image_stride;
+ size_t offset;
+ int i, chunk;
+
+ chunks = image->data;
+ offset = 0;
+ chunk = 0;
+ image_stride = image->stride;
+
+ const int skip_lines = top_down ? src->top : image->y - (src->bottom - 0);
+ for (i = 0; i < skip_lines; i++) {
+ get_image_line(chunks, &offset, &chunk, image_stride);
+ }
+
+ const unsigned int stream_height = src->bottom - src->top;
+ const unsigned int stream_width = src->right - src->left;
+
+ for (i = 0; i < stream_height; i++) {
+ uint8_t *src_line = get_image_line(chunks, &offset, &chunk, image_stride);
+
+ if (!src_line) {
+ return FALSE;
+ }
+
+ src_line += src->left * mjpeg_encoder_get_bytes_per_pixel(encoder);
+ if (mjpeg_encoder_encode_scanline(encoder, src_line, stream_width) == 0) {
+ return FALSE;
+ }
+ }
+
+ return TRUE;
+}
+
+int mjpeg_encoder_encode_frame(MJpegEncoder *encoder,
+ const SpiceBitmap *bitmap, int width, int height,
+ const SpiceRect *src,
+ int top_down, uint32_t frame_mm_time,
+ uint8_t **outbuf, size_t *outbuf_size,
+ int *data_size)
+{
+ int ret = mjpeg_encoder_start_frame(encoder, bitmap->format,
+ width, height, outbuf, outbuf_size,
+ frame_mm_time);
+ if (ret != MJPEG_ENCODER_FRAME_ENCODE_DONE) {
+ return ret;
+ }
+
+ if (!encode_frame(encoder, src, bitmap, top_down)) {
+ return MJPEG_ENCODER_FRAME_UNSUPPORTED;
+ }
+
+ *data_size = mjpeg_encoder_end_frame(encoder);
+
+ return MJPEG_ENCODER_FRAME_ENCODE_DONE;
+}
+
+
+static void mjpeg_encoder_quality_eval_stop(MJpegEncoder *encoder)
+{
+ MJpegEncoderRateControl *rate_control = &encoder->rate_control;
+ uint32_t quality_id;
+ uint32_t fps;
+
+ if (!rate_control->during_quality_eval) {
+ return;
+ }
+ switch (rate_control->quality_eval_data.type) {
+ case MJPEG_QUALITY_EVAL_TYPE_UPGRADE:
+ quality_id = rate_control->quality_eval_data.min_quality_id;
+ fps = rate_control->quality_eval_data.min_quality_fps;
+ break;
+ case MJPEG_QUALITY_EVAL_TYPE_DOWNGRADE:
+ quality_id = rate_control->quality_eval_data.max_quality_id;
+ fps = rate_control->quality_eval_data.max_quality_fps;
+ break;
+ case MJPEG_QUALITY_EVAL_TYPE_SET:
+ quality_id = MJPEG_QUALITY_SAMPLE_NUM / 2;
+ fps = MJPEG_MAX_FPS / 2;
+ break;
+ default:
+ spice_warning("unexected");
+ return;
+ }
+ mjpeg_encoder_reset_quality(encoder, quality_id, fps, 0);
+ spice_debug("during quality evaluation: canceling."
+ "reset quality to %d fps %d",
+ mjpeg_quality_samples[rate_control->quality_id], rate_control->fps);
+}
+
+static void mjpeg_encoder_decrease_bit_rate(MJpegEncoder *encoder)
+{
+ MJpegEncoderRateControl *rate_control = &encoder->rate_control;
+ MJpegEncoderBitRateInfo *bit_rate_info = &rate_control->bit_rate_info;
+ uint64_t measured_byte_rate;
+ uint32_t measured_fps;
+ uint64_t decrease_size;
+
+ mjpeg_encoder_quality_eval_stop(encoder);
+
+ rate_control->client_state.max_video_latency = 0;
+ rate_control->client_state.max_audio_latency = 0;
+ if (rate_control->warmup_start_time) {
+ uint64_t now;
+
+ now = red_get_monotonic_time();
+ if (now - rate_control->warmup_start_time < MJPEG_WARMUP_TIME*1000*1000) {
+ spice_debug("during warmup. ignoring");
+ return;
+ } else {
+ rate_control->warmup_start_time = 0;
+ }
+ }
+
+ if (bit_rate_info->num_enc_frames > MJPEG_BIT_RATE_EVAL_MIN_NUM_FRAMES ||
+ bit_rate_info->num_enc_frames > rate_control->fps) {
+ double duration_sec;
+
+ duration_sec = (bit_rate_info->last_frame_time - bit_rate_info->change_start_time);
+ duration_sec /= (1000.0 * 1000.0 * 1000.0);
+ measured_byte_rate = bit_rate_info->sum_enc_size / duration_sec;
+ measured_fps = bit_rate_info->num_enc_frames / duration_sec;
+ decrease_size = bit_rate_info->sum_enc_size / bit_rate_info->num_enc_frames;
+ spice_debug("bit rate esitimation %.2f (Mbps) fps %u",
+ measured_byte_rate*8/1024.0/1024,
+ measured_fps);
+ } else {
+ measured_byte_rate = rate_control->byte_rate;
+ measured_fps = rate_control->fps;
+ decrease_size = measured_byte_rate/measured_fps;
+ spice_debug("bit rate not re-estimated %.2f (Mbps) fps %u",
+ measured_byte_rate*8/1024.0/1024,
+ measured_fps);
+ }
+
+ measured_byte_rate = MIN(rate_control->byte_rate, measured_byte_rate);
+
+ if (decrease_size >= measured_byte_rate) {
+ decrease_size = measured_byte_rate / 2;
+ }
+
+ rate_control->byte_rate = measured_byte_rate - decrease_size;
+ bit_rate_info->change_start_time = 0;
+ bit_rate_info->change_start_mm_time = 0;
+ bit_rate_info->last_frame_time = 0;
+ bit_rate_info->num_enc_frames = 0;
+ bit_rate_info->sum_enc_size = 0;
+ bit_rate_info->was_upgraded = FALSE;
+
+ spice_debug("decrease bit rate %.2f (Mbps)", rate_control->byte_rate * 8 / 1024.0/1024.0);
+ mjpeg_encoder_quality_eval_set_downgrade(encoder,
+ MJPEG_QUALITY_EVAL_REASON_RATE_CHANGE,
+ rate_control->quality_id,
+ rate_control->fps);
+}
+
+static void mjpeg_encoder_handle_negative_client_stream_report(MJpegEncoder *encoder,
+ uint32_t report_end_frame_mm_time)
+{
+ MJpegEncoderRateControl *rate_control = &encoder->rate_control;
+
+ spice_debug(NULL);
+
+ if ((rate_control->bit_rate_info.change_start_mm_time > report_end_frame_mm_time ||
+ !rate_control->bit_rate_info.change_start_mm_time) &&
+ !rate_control->bit_rate_info.was_upgraded) {
+ spice_debug("ignoring, a downgrade has already occurred later to the report time");
+ return;
+ }
+
+ mjpeg_encoder_decrease_bit_rate(encoder);
+}
+
+static void mjpeg_encoder_increase_bit_rate(MJpegEncoder *encoder)
+{
+ MJpegEncoderRateControl *rate_control = &encoder->rate_control;
+ MJpegEncoderBitRateInfo *bit_rate_info = &rate_control->bit_rate_info;
+ uint64_t measured_byte_rate;
+ uint32_t measured_fps;
+ uint64_t increase_size;
+
+
+ if (bit_rate_info->num_enc_frames > MJPEG_BIT_RATE_EVAL_MIN_NUM_FRAMES ||
+ bit_rate_info->num_enc_frames > rate_control->fps) {
+ uint64_t avg_frame_size;
+ double duration_sec;
+
+ duration_sec = (bit_rate_info->last_frame_time - bit_rate_info->change_start_time);
+ duration_sec /= (1000.0 * 1000.0 * 1000.0);
+ measured_byte_rate = bit_rate_info->sum_enc_size / duration_sec;
+ measured_fps = bit_rate_info->num_enc_frames / duration_sec;
+ avg_frame_size = bit_rate_info->sum_enc_size / bit_rate_info->num_enc_frames;
+ spice_debug("bit rate esitimation %.2f (Mbps) defined %.2f"
+ " fps %u avg-frame-size=%.2f (KB)",
+ measured_byte_rate*8/1024.0/1024,
+ rate_control->byte_rate*8/1024.0/1024,
+ measured_fps,
+ avg_frame_size/1024.0);
+ increase_size = avg_frame_size;
+ } else {
+ spice_debug("not enough samples for measuring the bit rate. no change");
+ return;
+ }
+
+
+ mjpeg_encoder_quality_eval_stop(encoder);
+
+ if (measured_byte_rate + increase_size < rate_control->byte_rate) {
+ spice_debug("measured byte rate is small: not upgrading, just re-evaluating");
+ } else {
+ rate_control->byte_rate = MIN(measured_byte_rate, rate_control->byte_rate) + increase_size;
+ }
+
+ bit_rate_info->change_start_time = 0;
+ bit_rate_info->change_start_mm_time = 0;
+ bit_rate_info->last_frame_time = 0;
+ bit_rate_info->num_enc_frames = 0;
+ bit_rate_info->sum_enc_size = 0;
+ bit_rate_info->was_upgraded = TRUE;
+
+ spice_debug("increase bit rate %.2f (Mbps)", rate_control->byte_rate * 8 / 1024.0/1024.0);
+ mjpeg_encoder_quality_eval_set_upgrade(encoder,
+ MJPEG_QUALITY_EVAL_REASON_RATE_CHANGE,
+ rate_control->quality_id,
+ rate_control->fps);
+}
+
+static void mjpeg_encoder_handle_positive_client_stream_report(MJpegEncoder *encoder,
+ uint32_t report_start_frame_mm_time)
+{
+ MJpegEncoderRateControl *rate_control = &encoder->rate_control;
+ MJpegEncoderBitRateInfo *bit_rate_info = &rate_control->bit_rate_info;
+ int stable_client_mm_time;
+ int timeout;
+
+ if (rate_control->during_quality_eval &&
+ rate_control->quality_eval_data.reason == MJPEG_QUALITY_EVAL_REASON_RATE_CHANGE) {
+ spice_debug("during quality evaluation (rate change). ignoring report");
+ return;
+ }
+
+ if ((rate_control->fps > MJPEG_IMPROVE_QUALITY_FPS_STRICT_TH ||
+ rate_control->fps >= mjpeg_encoder_get_source_fps(encoder)) &&
+ rate_control->quality_id > MJPEG_QUALITY_SAMPLE_NUM / 2) {
+ timeout = MJPEG_CLIENT_POSITIVE_REPORT_STRICT_TIMEOUT;
+ } else {
+ timeout = MJPEG_CLIENT_POSITIVE_REPORT_TIMEOUT;
+ }
+
+ stable_client_mm_time = (int)report_start_frame_mm_time - bit_rate_info->change_start_mm_time;
+
+ if (!bit_rate_info->change_start_mm_time || stable_client_mm_time < timeout) {
+ /* assessing the stability of the current setting and only then
+ * respond to the report */
+ spice_debug("no drops, but not enough time has passed for assessing"
+ "the playback stability since the last bit rate change");
+ return;
+ }
+ mjpeg_encoder_increase_bit_rate(encoder);
+}
+
+/*
+ * the video playback jitter buffer should be at least (send_time*2 + net_latency) for
+ * preventing underflow
+ */
+static uint32_t get_min_required_playback_delay(uint64_t frame_enc_size,
+ uint64_t byte_rate,
+ uint32_t latency)
+{
+ uint32_t one_frame_time;
+ uint32_t min_delay;
+
+ if (!frame_enc_size || !byte_rate) {
+ return latency;
+ }
+ one_frame_time = (frame_enc_size*1000)/byte_rate;
+
+ min_delay = MIN(one_frame_time*2 + latency, MJPEG_MAX_CLIENT_PLAYBACK_DELAY);
+ return min_delay;
+}
+
+#define MJPEG_PLAYBACK_LATENCY_DECREASE_FACTOR 0.5
+#define MJPEG_VIDEO_VS_AUDIO_LATENCY_FACTOR 1.25
+#define MJPEG_VIDEO_DELAY_TH -15
+
+void mjpeg_encoder_client_stream_report(MJpegEncoder *encoder,
+ uint32_t num_frames,
+ uint32_t num_drops,
+ uint32_t start_frame_mm_time,
+ uint32_t end_frame_mm_time,
+ int32_t end_frame_delay,
+ uint32_t audio_delay)
+{
+ MJpegEncoderRateControl *rate_control = &encoder->rate_control;
+ MJpegEncoderClientState *client_state = &rate_control->client_state;
+ uint64_t avg_enc_size = 0;
+ uint32_t min_playback_delay;
+ int is_video_delay_small = FALSE;
+
+ spice_debug("client report: #frames %u, #drops %d, duration %u video-delay %d audio-delay %u",
+ num_frames, num_drops,
+ end_frame_mm_time - start_frame_mm_time,
+ end_frame_delay, audio_delay);
+
+ if (!rate_control_is_active(encoder)) {
+ spice_debug("rate control was not activated: ignoring");
+ return;
+ }
+ if (rate_control->during_quality_eval) {
+ if (rate_control->quality_eval_data.type == MJPEG_QUALITY_EVAL_TYPE_DOWNGRADE &&
+ rate_control->quality_eval_data.reason == MJPEG_QUALITY_EVAL_REASON_RATE_CHANGE) {
+ spice_debug("during rate downgrade evaluation");
+ return;
+ }
+ }
+
+ if (rate_control->num_recent_enc_frames) {
+ avg_enc_size = rate_control->sum_recent_enc_size /
+ rate_control->num_recent_enc_frames;
+ }
+ spice_debug("recent size avg %.2f (KB)", avg_enc_size / 1024.0);
+ min_playback_delay = get_min_required_playback_delay(avg_enc_size, rate_control->byte_rate,
+ mjpeg_encoder_get_latency(encoder));
+ spice_debug("min-delay %u client-delay %d", min_playback_delay, end_frame_delay);
+
+ if (min_playback_delay > end_frame_delay) {
+ uint32_t src_fps = mjpeg_encoder_get_source_fps(encoder);
+ /*
+ * if the stream is at its highest rate, we can't estimate the "real"
+ * network bit rate and the min_playback_delay
+ */
+ if (rate_control->quality_id != MJPEG_QUALITY_SAMPLE_NUM - 1 ||
+ rate_control->fps < MIN(src_fps, MJPEG_MAX_FPS) || end_frame_delay < 0) {
+ is_video_delay_small = TRUE;
+ if (encoder->cbs.update_client_playback_delay) {
+ encoder->cbs.update_client_playback_delay(encoder->cbs_opaque,
+ min_playback_delay);
+ }
+ }
+ }
+
+
+ /*
+ * If the audio latency has decreased (since the start of the current
+ * sequence of positive reports), and the video latency is bigger, slow down
+ * the video rate
+ */
+ if (end_frame_delay > 0 &&
+ audio_delay < MJPEG_PLAYBACK_LATENCY_DECREASE_FACTOR*client_state->max_audio_latency &&
+ end_frame_delay > MJPEG_VIDEO_VS_AUDIO_LATENCY_FACTOR*audio_delay) {
+ spice_debug("video_latency >> audio_latency && audio_latency << max (%u)",
+ client_state->max_audio_latency);
+ mjpeg_encoder_handle_negative_client_stream_report(encoder,
+ end_frame_mm_time);
+ return;
+ }
+
+ if (end_frame_delay < MJPEG_VIDEO_DELAY_TH) {
+ mjpeg_encoder_handle_negative_client_stream_report(encoder,
+ end_frame_mm_time);
+ } else {
+ double major_delay_decrease_thresh;
+ double medium_delay_decrease_thresh;
+
+ client_state->max_video_latency = MAX(end_frame_delay, client_state->max_video_latency);
+ client_state->max_audio_latency = MAX(audio_delay, client_state->max_audio_latency);
+
+ medium_delay_decrease_thresh = client_state->max_video_latency;
+ medium_delay_decrease_thresh *= MJPEG_PLAYBACK_LATENCY_DECREASE_FACTOR;
+
+ major_delay_decrease_thresh = medium_delay_decrease_thresh;
+ major_delay_decrease_thresh *= MJPEG_PLAYBACK_LATENCY_DECREASE_FACTOR;
+ /*
+ * since the bit rate and the required latency are only evaluation based on the
+ * reports we got till now, we assume that the latency is too low only if it
+ * was higher during the time that passed since the last report that resulted
+ * in a bit rate decrement. If we find that the latency has decreased, it might
+ * suggest that the stream bit rate is too high.
+ */
+ if ((end_frame_delay < medium_delay_decrease_thresh &&
+ is_video_delay_small) || end_frame_delay < major_delay_decrease_thresh) {
+ spice_debug("downgrade due to short video delay (last=%u, past-max=%u",
+ end_frame_delay, client_state->max_video_latency);
+ mjpeg_encoder_handle_negative_client_stream_report(encoder,
+ end_frame_mm_time);
+ } else if (!num_drops) {
+ mjpeg_encoder_handle_positive_client_stream_report(encoder,
+ start_frame_mm_time);
+
+ }
+ }
+}
+
+void mjpeg_encoder_notify_server_frame_drop(MJpegEncoder *encoder)
+{
+ encoder->rate_control.server_state.num_frames_dropped++;
+ mjpeg_encoder_process_server_drops(encoder);
+}
+
+/*
+ * decrease the bit rate if the drop rate on the sever side exceeds a pre defined
+ * threshold.
+ */
+static void mjpeg_encoder_process_server_drops(MJpegEncoder *encoder)
+{
+ MJpegEncoderServerState *server_state = &encoder->rate_control.server_state;
+ uint32_t num_frames_total;
+ double drop_factor;
+ uint32_t fps;
+
+ fps = MIN(encoder->rate_control.fps, mjpeg_encoder_get_source_fps(encoder));
+ if (server_state->num_frames_encoded < fps * MJPEG_SERVER_STATUS_EVAL_FPS_INTERVAL) {
+ return;
+ }
+
+ num_frames_total = server_state->num_frames_dropped + server_state->num_frames_encoded;
+ drop_factor = ((double)server_state->num_frames_dropped) / num_frames_total;
+
+ spice_debug("#drops %u total %u fps %u src-fps %u",
+ server_state->num_frames_dropped,
+ num_frames_total,
+ encoder->rate_control.fps,
+ mjpeg_encoder_get_source_fps(encoder));
+
+ if (drop_factor > MJPEG_SERVER_STATUS_DOWNGRADE_DROP_FACTOR_TH) {
+ mjpeg_encoder_decrease_bit_rate(encoder);
+ }
+ server_state->num_frames_encoded = 0;
+ server_state->num_frames_dropped = 0;
+}
+
+uint64_t mjpeg_encoder_get_bit_rate(MJpegEncoder *encoder)
+{
+ return encoder->rate_control.byte_rate * 8;
+}
+
+void mjpeg_encoder_get_stats(MJpegEncoder *encoder, MJpegEncoderStats *stats)
+{
+ spice_assert(encoder != NULL && stats != NULL);
+ stats->starting_bit_rate = encoder->starting_bit_rate;
+ stats->cur_bit_rate = mjpeg_encoder_get_bit_rate(encoder);
+ stats->avg_quality = (double)encoder->avg_quality / encoder->num_frames;
+}
+
+MJpegEncoder *mjpeg_encoder_new(uint64_t starting_bit_rate,
+ MJpegEncoderRateControlCbs *cbs,
+ void *cbs_opaque)
+{
+ MJpegEncoder *encoder = spice_new0(MJpegEncoder, 1);
+
+ encoder->first_frame = TRUE;
+ encoder->rate_control.byte_rate = starting_bit_rate / 8;
+ encoder->starting_bit_rate = starting_bit_rate;
+
+ if (cbs) {
+ struct timespec time;
+
+ clock_gettime(CLOCK_MONOTONIC, &time);
+ encoder->cbs = *cbs;
+ encoder->cbs_opaque = cbs_opaque;
+ mjpeg_encoder_reset_quality(encoder, MJPEG_QUALITY_SAMPLE_NUM / 2, 5, 0);
+ encoder->rate_control.during_quality_eval = TRUE;
+ encoder->rate_control.quality_eval_data.type = MJPEG_QUALITY_EVAL_TYPE_SET;
+ encoder->rate_control.quality_eval_data.reason = MJPEG_QUALITY_EVAL_REASON_RATE_CHANGE;
+ encoder->rate_control.warmup_start_time = ((uint64_t) time.tv_sec) * 1000000000 + time.tv_nsec;
+ } else {
+ encoder->cbs.get_roundtrip_ms = NULL;
+ mjpeg_encoder_reset_quality(encoder, MJPEG_LEGACY_STATIC_QUALITY_ID, MJPEG_MAX_FPS, 0);
+ }
+
+ encoder->cinfo.err = jpeg_std_error(&encoder->jerr);
+ jpeg_create_compress(&encoder->cinfo);
+
+ return encoder;
+}
diff --git a/server/mjpeg-encoder.h b/server/mjpeg-encoder.h
new file mode 100644
index 0000000..d070e70
--- /dev/null
+++ b/server/mjpeg-encoder.h
@@ -0,0 +1,100 @@
+/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ Copyright (C) 2009 Red Hat, Inc.
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_MJPEG_ENCODER
+#define _H_MJPEG_ENCODER
+
+#include "red_common.h"
+
+enum {
+ MJPEG_ENCODER_FRAME_UNSUPPORTED = -1,
+ MJPEG_ENCODER_FRAME_DROP,
+ MJPEG_ENCODER_FRAME_ENCODE_DONE,
+};
+
+typedef struct MJpegEncoder MJpegEncoder;
+
+/*
+ * Callbacks required for controling and adjusting
+ * the stream bit rate:
+ * get_roundtrip_ms: roundtrip time in milliseconds
+ * get_source_fps: the input frame rate (#frames per second), i.e.,
+ * the rate of frames arriving from the guest to spice-server,
+ * before any drops.
+ */
+typedef struct MJpegEncoderRateControlCbs {
+ uint32_t (*get_roundtrip_ms)(void *opaque);
+ uint32_t (*get_source_fps)(void *opaque);
+ void (*update_client_playback_delay)(void *opaque, uint32_t delay_ms);
+} MJpegEncoderRateControlCbs;
+
+typedef struct MJpegEncoderStats {
+ uint64_t starting_bit_rate;
+ uint64_t cur_bit_rate;
+ double avg_quality;
+} MJpegEncoderStats;
+
+MJpegEncoder *mjpeg_encoder_new(uint64_t starting_bit_rate,
+ MJpegEncoderRateControlCbs *cbs, void *opaque);
+void mjpeg_encoder_destroy(MJpegEncoder *encoder);
+
+int mjpeg_encoder_encode_frame(MJpegEncoder *encoder,
+ const SpiceBitmap *bitmap, int width, int height,
+ const SpiceRect *src,
+ int top_down, uint32_t frame_mm_time,
+ uint8_t **outbuf, size_t *outbuf_size,
+ int *data_size);
+
+/*
+ * bit rate control
+ */
+
+/*
+ * Data that should be periodically obtained from the client. The report contains:
+ * num_frames : the number of frames that reached the client during the time
+ * the report is referring to.
+ * num_drops : the part of the above frames that was dropped by the client due to
+ * late arrival time.
+ * start_frame_mm_time: the mm_time of the first frame included in the report
+ * end_frame_mm_time : the mm_time of the last_frame included in the report
+ * end_frame_delay : (end_frame_mm_time - client_mm_time)
+ * audio delay : the latency of the audio playback.
+ * If there is no audio playback, set it to MAX_UINT.
+ *
+ */
+void mjpeg_encoder_client_stream_report(MJpegEncoder *encoder,
+ uint32_t num_frames,
+ uint32_t num_drops,
+ uint32_t start_frame_mm_time,
+ uint32_t end_frame_mm_time,
+ int32_t end_frame_delay,
+ uint32_t audio_delay);
+
+/*
+ * Notify the encoder each time a frame is dropped due to pipe
+ * congestion.
+ * We can deduce the client state by the frame dropping rate in the server.
+ * Monitoring the frame drops can help in fine tuning the playback parameters
+ * when the client reports are delayed.
+ */
+void mjpeg_encoder_notify_server_frame_drop(MJpegEncoder *encoder);
+
+uint64_t mjpeg_encoder_get_bit_rate(MJpegEncoder *encoder);
+void mjpeg_encoder_get_stats(MJpegEncoder *encoder, MJpegEncoderStats *stats);
+
+#endif
diff --git a/server/mjpeg_encoder.c b/server/mjpeg_encoder.c
deleted file mode 100644
index 9b331c1..0000000
--- a/server/mjpeg_encoder.c
+++ /dev/null
@@ -1,1375 +0,0 @@
-/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- Copyright (C) 2009 Red Hat, Inc.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, see <http://www.gnu.org/licenses/>.
-*/
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#include "red_common.h"
-#include "mjpeg_encoder.h"
-#include "utils.h"
-#include <jerror.h>
-#include <jpeglib.h>
-#include <inttypes.h>
-
-#define MJPEG_MAX_FPS 25
-#define MJPEG_MIN_FPS 1
-
-#define MJPEG_QUALITY_SAMPLE_NUM 7
-static const int mjpeg_quality_samples[MJPEG_QUALITY_SAMPLE_NUM] = {20, 30, 40, 50, 60, 70, 80};
-
-#define MJPEG_LEGACY_STATIC_QUALITY_ID 5 // jpeg quality 70
-
-#define MJPEG_IMPROVE_QUALITY_FPS_STRICT_TH 10
-#define MJPEG_IMPROVE_QUALITY_FPS_PERMISSIVE_TH 5
-
-#define MJPEG_AVERAGE_SIZE_WINDOW 3
-
-#define MJPEG_BIT_RATE_EVAL_MIN_NUM_FRAMES 3
-#define MJPEG_LOW_FPS_RATE_TH 3
-
-#define MJPEG_SERVER_STATUS_EVAL_FPS_INTERVAL 1
-#define MJPEG_SERVER_STATUS_DOWNGRADE_DROP_FACTOR_TH 0.1
-
-/*
- * acting on positive client reports only if enough frame mm time
- * has passed since the last bit rate change and the report.
- * time
- */
-#define MJPEG_CLIENT_POSITIVE_REPORT_TIMEOUT 2000
-#define MJPEG_CLIENT_POSITIVE_REPORT_STRICT_TIMEOUT 3000
-
-#define MJPEG_ADJUST_FPS_TIMEOUT 500
-
-/*
- * avoid interrupting the playback when there are temporary
- * incidents of instability (with respect to server and client drops)
- */
-#define MJPEG_MAX_CLIENT_PLAYBACK_DELAY 5000 // 5 sec
-
-/*
- * The stream starts after lossless frames were sent to the client,
- * and without rate control (except for pipe congestion). Thus, on the beginning
- * of the stream, we might observe frame drops on the client and server side which
- * are not necessarily related to mis-estimation of the bit rate, and we would
- * like to wait till the stream stabilizes.
- */
-#define MJPEG_WARMUP_TIME 3000LL // 3 sec
-
-enum {
- MJPEG_QUALITY_EVAL_TYPE_SET,
- MJPEG_QUALITY_EVAL_TYPE_UPGRADE,
- MJPEG_QUALITY_EVAL_TYPE_DOWNGRADE,
-};
-
-enum {
- MJPEG_QUALITY_EVAL_REASON_SIZE_CHANGE,
- MJPEG_QUALITY_EVAL_REASON_RATE_CHANGE,
-};
-
-typedef struct MJpegEncoderQualityEval {
- int type;
- int reason;
-
- uint64_t encoded_size_by_quality[MJPEG_QUALITY_SAMPLE_NUM];
- /* lower limit for the current evaluation round */
- int min_quality_id;
- int min_quality_fps; // min fps for the given quality
- /* upper limit for the current evaluation round */
- int max_quality_id;
- int max_quality_fps; // max fps for the given quality
- /* tracking the best sampled fps so far */
- int max_sampled_fps;
- int max_sampled_fps_quality_id;
-} MJpegEncoderQualityEval;
-
-typedef struct MJpegEncoderClientState {
- int max_video_latency;
- uint32_t max_audio_latency;
-} MJpegEncoderClientState;
-
-typedef struct MJpegEncoderServerState {
- uint32_t num_frames_encoded;
- uint32_t num_frames_dropped;
-} MJpegEncoderServerState;
-
-typedef struct MJpegEncoderBitRateInfo {
- uint64_t change_start_time;
- uint64_t last_frame_time;
- uint32_t change_start_mm_time;
- int was_upgraded;
-
- /* gathering data about the frames that
- * were encoded since the last bit rate change*/
- uint32_t num_enc_frames;
- uint64_t sum_enc_size;
-} MJpegEncoderBitRateInfo;
-
-/*
- * Adjusting the stream jpeg quality and frame rate (fps):
- * When during_quality_eval=TRUE, we compress different frames with different
- * jpeg quality. By considering (1) the resulting compression ratio, and (2) the available
- * bit rate, we evaluate the max frame frequency for the stream with the given quality,
- * and we choose the highest quality that will allow a reasonable frame rate.
- * during_quality_eval is set for new streams and can also be set any time we want
- * to re-evaluate the stream parameters (e.g., when the bit rate and/or
- * compressed frame size significantly change).
- */
-typedef struct MJpegEncoderRateControl {
- int during_quality_eval;
- MJpegEncoderQualityEval quality_eval_data;
- MJpegEncoderBitRateInfo bit_rate_info;
- MJpegEncoderClientState client_state;
- MJpegEncoderServerState server_state;
-
- uint64_t byte_rate;
- int quality_id;
- uint32_t fps;
- double adjusted_fps;
- uint64_t adjusted_fps_start_time;
- uint64_t adjusted_fps_num_frames;
-
- /* the encoded frame size which the quality and the fps evaluation was based upon */
- uint64_t base_enc_size;
-
- uint64_t last_enc_size;
-
- uint64_t sum_recent_enc_size;
- uint32_t num_recent_enc_frames;
-
- uint64_t warmup_start_time;
-} MJpegEncoderRateControl;
-
-struct MJpegEncoder {
- uint8_t *row;
- uint32_t row_size;
- int first_frame;
-
- struct jpeg_compress_struct cinfo;
- struct jpeg_error_mgr jerr;
-
- unsigned int bytes_per_pixel; /* bytes per pixel of the input buffer */
- void (*pixel_converter)(void *src, uint8_t *dest);
-
- MJpegEncoderRateControl rate_control;
- MJpegEncoderRateControlCbs cbs;
- void *cbs_opaque;
-
- /* stats */
- uint64_t starting_bit_rate;
- uint64_t avg_quality;
- uint32_t num_frames;
-};
-
-static void mjpeg_encoder_process_server_drops(MJpegEncoder *encoder);
-static uint32_t get_min_required_playback_delay(uint64_t frame_enc_size,
- uint64_t byte_rate,
- uint32_t latency);
-
-static inline int rate_control_is_active(MJpegEncoder* encoder)
-{
- return encoder->cbs.get_roundtrip_ms != NULL;
-}
-
-void mjpeg_encoder_destroy(MJpegEncoder *encoder)
-{
- free(encoder->cinfo.dest);
- jpeg_destroy_compress(&encoder->cinfo);
- free(encoder->row);
- free(encoder);
-}
-
-static uint8_t mjpeg_encoder_get_bytes_per_pixel(MJpegEncoder *encoder)
-{
- return encoder->bytes_per_pixel;
-}
-
-#ifndef JCS_EXTENSIONS
-/* Pixel conversion routines */
-static void pixel_rgb24bpp_to_24(void *src_ptr, uint8_t *dest)
-{
- uint8_t *src = src_ptr;
- /* libjpegs stores rgb, spice/win32 stores bgr */
- *dest++ = src[2]; /* red */
- *dest++ = src[1]; /* green */
- *dest++ = src[0]; /* blue */
-}
-
-static void pixel_rgb32bpp_to_24(void *src, uint8_t *dest)
-{
- uint32_t pixel = *(uint32_t *)src;
- *dest++ = (pixel >> 16) & 0xff;
- *dest++ = (pixel >> 8) & 0xff;
- *dest++ = (pixel >> 0) & 0xff;
-}
-#endif
-
-static void pixel_rgb16bpp_to_24(void *src, uint8_t *dest)
-{
- uint16_t pixel = *(uint16_t *)src;
- *dest++ = ((pixel >> 7) & 0xf8) | ((pixel >> 12) & 0x7);
- *dest++ = ((pixel >> 2) & 0xf8) | ((pixel >> 7) & 0x7);
- *dest++ = ((pixel << 3) & 0xf8) | ((pixel >> 2) & 0x7);
-}
-
-
-/* code from libjpeg 8 to handle compression to a memory buffer
- *
- * Copyright (C) 1994-1996, Thomas G. Lane.
- * Modified 2009 by Guido Vollbeding.
- * This file is part of the Independent JPEG Group's software.
- */
-typedef struct {
- struct jpeg_destination_mgr pub; /* public fields */
-
- unsigned char ** outbuffer; /* target buffer */
- size_t * outsize;
- uint8_t * buffer; /* start of buffer */
- size_t bufsize;
-} mem_destination_mgr;
-
-static void init_mem_destination(j_compress_ptr cinfo)
-{
-}
-
-static boolean empty_mem_output_buffer(j_compress_ptr cinfo)
-{
- size_t nextsize;
- uint8_t * nextbuffer;
- mem_destination_mgr *dest = (mem_destination_mgr *) cinfo->dest;
-
- /* Try to allocate new buffer with double size */
- nextsize = dest->bufsize * 2;
- nextbuffer = malloc(nextsize);
-
- if (nextbuffer == NULL)
- ERREXIT1(cinfo, JERR_OUT_OF_MEMORY, 10);
-
- memcpy(nextbuffer, dest->buffer, dest->bufsize);
-
- free(dest->buffer);
-
- dest->pub.next_output_byte = nextbuffer + dest->bufsize;
- dest->pub.free_in_buffer = dest->bufsize;
-
- dest->buffer = nextbuffer;
- dest->bufsize = nextsize;
-
- return TRUE;
-}
-
-static void term_mem_destination(j_compress_ptr cinfo)
-{
- mem_destination_mgr *dest = (mem_destination_mgr *) cinfo->dest;
-
- *dest->outbuffer = dest->buffer;
- *dest->outsize = dest->bufsize;
-}
-
-/*
- * Prepare for output to a memory buffer.
- * The caller may supply an own initial buffer with appropriate size.
- * Otherwise, or when the actual data output exceeds the given size,
- * the library adapts the buffer size as necessary.
- * The standard library functions malloc/free are used for allocating
- * larger memory, so the buffer is available to the application after
- * finishing compression, and then the application is responsible for
- * freeing the requested memory.
- */
-
-static void
-spice_jpeg_mem_dest(j_compress_ptr cinfo,
- unsigned char ** outbuffer, size_t * outsize)
-{
- mem_destination_mgr *dest;
-#define OUTPUT_BUF_SIZE 4096 /* choose an efficiently fwrite'able size */
-
- if (outbuffer == NULL || outsize == NULL) /* sanity check */
- ERREXIT(cinfo, JERR_BUFFER_SIZE);
-
- /* The destination object is made permanent so that multiple JPEG images
- * can be written to the same buffer without re-executing jpeg_mem_dest.
- */
- if (cinfo->dest == NULL) { /* first time for this JPEG object? */
- cinfo->dest = spice_malloc(sizeof(mem_destination_mgr));
- }
-
- dest = (mem_destination_mgr *) cinfo->dest;
- dest->pub.init_destination = init_mem_destination;
- dest->pub.empty_output_buffer = empty_mem_output_buffer;
- dest->pub.term_destination = term_mem_destination;
- dest->outbuffer = outbuffer;
- dest->outsize = outsize;
- if (*outbuffer == NULL || *outsize == 0) {
- /* Allocate initial buffer */
- *outbuffer = malloc(OUTPUT_BUF_SIZE);
- if (*outbuffer == NULL)
- ERREXIT1(cinfo, JERR_OUT_OF_MEMORY, 10);
- *outsize = OUTPUT_BUF_SIZE;
- }
-
- dest->pub.next_output_byte = dest->buffer = *outbuffer;
- dest->pub.free_in_buffer = dest->bufsize = *outsize;
-}
-/* end of code from libjpeg */
-
-static inline uint32_t mjpeg_encoder_get_source_fps(MJpegEncoder *encoder)
-{
- return encoder->cbs.get_source_fps ?
- encoder->cbs.get_source_fps(encoder->cbs_opaque) : MJPEG_MAX_FPS;
-}
-
-static inline uint32_t mjpeg_encoder_get_latency(MJpegEncoder *encoder)
-{
- return encoder->cbs.get_roundtrip_ms ?
- encoder->cbs.get_roundtrip_ms(encoder->cbs_opaque) / 2 : 0;
-}
-
-static uint32_t get_max_fps(uint64_t frame_size, uint64_t bytes_per_sec)
-{
- double fps;
- double send_time_ms;
-
- if (!bytes_per_sec) {
- return 0;
- }
- send_time_ms = frame_size * 1000.0 / bytes_per_sec;
- fps = send_time_ms ? 1000 / send_time_ms : MJPEG_MAX_FPS;
- return fps;
-}
-
-static inline void mjpeg_encoder_reset_quality(MJpegEncoder *encoder,
- int quality_id,
- uint32_t fps,
- uint64_t frame_enc_size)
-{
- MJpegEncoderRateControl *rate_control = &encoder->rate_control;
- double fps_ratio;
-
- rate_control->during_quality_eval = FALSE;
-
- if (rate_control->quality_id != quality_id) {
- rate_control->last_enc_size = 0;
- }
-
- if (rate_control->quality_eval_data.reason == MJPEG_QUALITY_EVAL_REASON_RATE_CHANGE) {
- memset(&rate_control->server_state, 0, sizeof(MJpegEncoderServerState));
- }
- rate_control->quality_id = quality_id;
- memset(&rate_control->quality_eval_data, 0, sizeof(MJpegEncoderQualityEval));
- rate_control->quality_eval_data.max_quality_id = MJPEG_QUALITY_SAMPLE_NUM - 1;
- rate_control->quality_eval_data.max_quality_fps = MJPEG_MAX_FPS;
-
- if (rate_control->adjusted_fps) {
- fps_ratio = rate_control->adjusted_fps / rate_control->fps;
- } else {
- fps_ratio = 1.5;
- }
- rate_control->fps = MAX(MJPEG_MIN_FPS, fps);
- rate_control->fps = MIN(MJPEG_MAX_FPS, rate_control->fps);
- rate_control->adjusted_fps = rate_control->fps*fps_ratio;
- spice_debug("adjusted-fps-ratio=%.2f adjusted-fps=%.2f", fps_ratio, rate_control->adjusted_fps);
- rate_control->adjusted_fps_start_time = 0;
- rate_control->adjusted_fps_num_frames = 0;
- rate_control->base_enc_size = frame_enc_size;
-
- rate_control->sum_recent_enc_size = 0;
- rate_control->num_recent_enc_frames = 0;
-}
-
-#define QUALITY_WAS_EVALUATED(encoder, quality) \
- ((encoder)->rate_control.quality_eval_data.encoded_size_by_quality[(quality)] != 0)
-
-/*
- * Adjust the stream's jpeg quality and frame rate.
- * We evaluate the compression ratio of different jpeg qualities;
- * We compress successive frames with different qualities,
- * and then we estimate the stream frame rate according to the currently
- * evaluated jpeg quality and available bit rate.
- *
- * During quality evaluation, mjpeg_encoder_eval_quality is called before a new
- * frame is encoded. mjpeg_encoder_eval_quality examines the encoding size of
- * the previously encoded frame, and determines whether to continue evaluation
- * (and chnages the quality for the frame that is going to be encoded),
- * or stop evaluation (and sets the quality and frame rate for the stream).
- * When qualities are scanned, we assume monotonicity of compression ratio
- * as a function of jpeg quality. When we reach a quality with too small, or
- * big enough compression ratio, we stop the evaluation and set the stream parameters.
-*/
-static inline void mjpeg_encoder_eval_quality(MJpegEncoder *encoder)
-{
- MJpegEncoderRateControl *rate_control;
- MJpegEncoderQualityEval *quality_eval;
- uint32_t fps, src_fps;
- uint64_t enc_size;
- uint32_t final_quality_id;
- uint32_t final_fps;
- uint64_t final_quality_enc_size;
-
- rate_control = &encoder->rate_control;
- quality_eval = &rate_control->quality_eval_data;
-
- spice_assert(rate_control->during_quality_eval);
-
- /* retrieving the encoded size of the last encoded frame */
- enc_size = quality_eval->encoded_size_by_quality[rate_control->quality_id];
- if (enc_size == 0) {
- spice_debug("size info missing");
- return;
- }
-
- src_fps = mjpeg_encoder_get_source_fps(encoder);
-
- fps = get_max_fps(enc_size, rate_control->byte_rate);
- spice_debug("mjpeg %p: jpeg %d: %.2f (KB) fps %d src-fps %u",
- encoder,
- mjpeg_quality_samples[rate_control->quality_id],
- enc_size / 1024.0,
- fps,
- src_fps);
-
- if (fps > quality_eval->max_sampled_fps ||
- ((fps == quality_eval->max_sampled_fps || fps >= src_fps) &&
- rate_control->quality_id > quality_eval->max_sampled_fps_quality_id)) {
- quality_eval->max_sampled_fps = fps;
- quality_eval->max_sampled_fps_quality_id = rate_control->quality_id;
- }
-
- /*
- * Choosing whether to evaluate another quality, or to complete evaluation
- * and set the stream parameters according to one of the qualities that
- * were already sampled.
- */
-
- if (rate_control->quality_id > MJPEG_QUALITY_SAMPLE_NUM / 2 &&
- fps < MJPEG_IMPROVE_QUALITY_FPS_STRICT_TH &&
- fps < src_fps) {
- /*
- * When the jpeg quality is bigger than the median quality, prefer a reasonable
- * frame rate over improving the quality
- */
- spice_debug("fps < %d && (fps < src_fps), quality %d",
- MJPEG_IMPROVE_QUALITY_FPS_STRICT_TH,
- mjpeg_quality_samples[rate_control->quality_id]);
- if (QUALITY_WAS_EVALUATED(encoder, rate_control->quality_id - 1)) {
- /* the next worse quality was already evaluated and it passed the frame
- * rate thresholds (we know that, because we continued evaluating a better
- * quality) */
- rate_control->quality_id--;
- goto complete_sample;
- } else {
- /* evaluate the next worse quality */
- rate_control->quality_id--;
- }
- } else if ((fps > MJPEG_IMPROVE_QUALITY_FPS_PERMISSIVE_TH &&
- fps >= 0.66 * quality_eval->min_quality_fps) || fps >= src_fps) {
- /* When the jpeg quality is worse than the median one (see first condition), we allow a less
- strict threshold for fps, in order to improve the jpeg quality */
- if (rate_control->quality_id + 1 == MJPEG_QUALITY_SAMPLE_NUM ||
- rate_control->quality_id >= quality_eval->max_quality_id ||
- QUALITY_WAS_EVALUATED(encoder, rate_control->quality_id + 1)) {
- /* best quality has been reached, or the next (better) quality was
- * already evaluated and didn't pass the fps thresholds */
- goto complete_sample;
- } else {
- if (rate_control->quality_id == MJPEG_QUALITY_SAMPLE_NUM / 2 &&
- fps < MJPEG_IMPROVE_QUALITY_FPS_STRICT_TH &&
- fps < src_fps) {
- goto complete_sample;
- }
- /* evaluate the next quality as well*/
- rate_control->quality_id++;
- }
- } else { // very small frame rate, try to improve by downgrading the quality
- if (rate_control->quality_id == 0 ||
- rate_control->quality_id <= quality_eval->min_quality_id) {
- goto complete_sample;
- } else if (QUALITY_WAS_EVALUATED(encoder, rate_control->quality_id - 1)) {
- rate_control->quality_id--;
- goto complete_sample;
- } else {
- /* evaluate the next worse quality */
- rate_control->quality_id--;
- }
- }
- return;
-
-complete_sample:
- if (quality_eval->max_sampled_fps != 0) {
- /* covering a case were monotonicity was violated and we sampled
- a better jepg quality, with better frame rate. */
- final_quality_id = MAX(rate_control->quality_id,
- quality_eval->max_sampled_fps_quality_id);
- } else {
- final_quality_id = rate_control->quality_id;
- }
- final_quality_enc_size = quality_eval->encoded_size_by_quality[final_quality_id];
- final_fps = get_max_fps(final_quality_enc_size,
- rate_control->byte_rate);
-
- if (final_quality_id == quality_eval->min_quality_id) {
- final_fps = MAX(final_fps, quality_eval->min_quality_fps);
- }
- if (final_quality_id == quality_eval->max_quality_id) {
- final_fps = MIN(final_fps, quality_eval->max_quality_fps);
- }
- mjpeg_encoder_reset_quality(encoder, final_quality_id, final_fps, final_quality_enc_size);
- rate_control->sum_recent_enc_size = final_quality_enc_size;
- rate_control->num_recent_enc_frames = 1;
-
- spice_debug("MJpeg quality sample end %p: quality %d fps %d",
- encoder, mjpeg_quality_samples[rate_control->quality_id], rate_control->fps);
- if (encoder->cbs.update_client_playback_delay) {
- uint32_t latency = mjpeg_encoder_get_latency(encoder);
- uint32_t min_delay = get_min_required_playback_delay(final_quality_enc_size,
- rate_control->byte_rate,
- latency);
-
- encoder->cbs.update_client_playback_delay(encoder->cbs_opaque, min_delay);
- }
-}
-
-static void mjpeg_encoder_quality_eval_set_upgrade(MJpegEncoder *encoder,
- int reason,
- uint32_t min_quality_id,
- uint32_t min_quality_fps)
-{
- MJpegEncoderQualityEval *quality_eval = &encoder->rate_control.quality_eval_data;
-
- encoder->rate_control.during_quality_eval = TRUE;
- quality_eval->type = MJPEG_QUALITY_EVAL_TYPE_UPGRADE;
- quality_eval->reason = reason;
- quality_eval->min_quality_id = min_quality_id;
- quality_eval->min_quality_fps = min_quality_fps;
-}
-
-static void mjpeg_encoder_quality_eval_set_downgrade(MJpegEncoder *encoder,
- int reason,
- uint32_t max_quality_id,
- uint32_t max_quality_fps)
-{
- MJpegEncoderQualityEval *quality_eval = &encoder->rate_control.quality_eval_data;
-
- encoder->rate_control.during_quality_eval = TRUE;
- quality_eval->type = MJPEG_QUALITY_EVAL_TYPE_DOWNGRADE;
- quality_eval->reason = reason;
- quality_eval->max_quality_id = max_quality_id;
- quality_eval->max_quality_fps = max_quality_fps;
-}
-
-static void mjpeg_encoder_adjust_params_to_bit_rate(MJpegEncoder *encoder)
-{
- MJpegEncoderRateControl *rate_control;
- MJpegEncoderQualityEval *quality_eval;
- uint64_t new_avg_enc_size = 0;
- uint32_t new_fps;
- uint32_t latency = 0;
- uint32_t src_fps;
-
- spice_assert(rate_control_is_active(encoder));
-
- rate_control = &encoder->rate_control;
- quality_eval = &rate_control->quality_eval_data;
-
- if (!rate_control->last_enc_size) {
- spice_debug("missing sample size");
- return;
- }
-
- if (rate_control->during_quality_eval) {
- quality_eval->encoded_size_by_quality[rate_control->quality_id] = rate_control->last_enc_size;
- mjpeg_encoder_eval_quality(encoder);
- return;
- }
-
- if (!rate_control->num_recent_enc_frames) {
- spice_debug("No recent encoded frames");
- return;
- }
-
- if (rate_control->num_recent_enc_frames < MJPEG_AVERAGE_SIZE_WINDOW &&
- rate_control->num_recent_enc_frames < rate_control->fps) {
- goto end;
- }
-
- latency = mjpeg_encoder_get_latency(encoder);
- new_avg_enc_size = rate_control->sum_recent_enc_size /
- rate_control->num_recent_enc_frames;
- new_fps = get_max_fps(new_avg_enc_size, rate_control->byte_rate);
-
- spice_debug("cur-fps=%u new-fps=%u (new/old=%.2f) |"
- "bit-rate=%.2f (Mbps) latency=%u (ms) quality=%d |"
- " new-size-avg %"PRIu64" , base-size %"PRIu64", (new/old=%.2f) ",
- rate_control->fps, new_fps, ((double)new_fps)/rate_control->fps,
- ((double)rate_control->byte_rate*8)/1024/1024,
- latency,
- mjpeg_quality_samples[rate_control->quality_id],
- new_avg_enc_size, rate_control->base_enc_size,
- rate_control->base_enc_size ?
- ((double)new_avg_enc_size) / rate_control->base_enc_size :
- 1);
-
- src_fps = mjpeg_encoder_get_source_fps(encoder);
-
- /*
- * The ratio between the new_fps and the current fps reflects the changes
- * in latency and frame size. When the change passes a threshold,
- * we re-evaluate the quality and frame rate.
- */
- if (new_fps > rate_control->fps &&
- (rate_control->fps < src_fps || rate_control->quality_id < MJPEG_QUALITY_SAMPLE_NUM - 1)) {
- spice_debug("mjpeg %p FPS CHANGE >> : re-evaluating params", encoder);
- mjpeg_encoder_quality_eval_set_upgrade(encoder, MJPEG_QUALITY_EVAL_REASON_SIZE_CHANGE,
- rate_control->quality_id, /* fps has improved -->
- don't allow stream quality
- to deteriorate */
- rate_control->fps);
- } else if (new_fps < rate_control->fps && new_fps < src_fps) {
- spice_debug("mjpeg %p FPS CHANGE << : re-evaluating params", encoder);
- mjpeg_encoder_quality_eval_set_downgrade(encoder, MJPEG_QUALITY_EVAL_REASON_SIZE_CHANGE,
- rate_control->quality_id,
- rate_control->fps);
- }
-end:
- if (rate_control->during_quality_eval) {
- quality_eval->encoded_size_by_quality[rate_control->quality_id] = new_avg_enc_size;
- mjpeg_encoder_eval_quality(encoder);
- } else {
- mjpeg_encoder_process_server_drops(encoder);
- }
-}
-
-/*
- * The actual frames distribution does not necessarily fit the condition "at least
- * one frame every (1000/rate_contorl->fps) milliseconds".
- * For keeping the average fps close to the defined fps, we periodically
- * measure the current average fps, and modify rate_control->adjusted_fps accordingly.
- * Then, we use (1000/rate_control->adjusted_fps) as the interval between frames.
- */
-static void mjpeg_encoder_adjust_fps(MJpegEncoder *encoder, uint64_t now)
-{
- MJpegEncoderRateControl *rate_control = &encoder->rate_control;
- uint64_t adjusted_fps_time_passed;
-
- spice_assert(rate_control_is_active(encoder));
-
- adjusted_fps_time_passed = (now - rate_control->adjusted_fps_start_time) / 1000 / 1000;
-
- if (!rate_control->during_quality_eval &&
- adjusted_fps_time_passed > MJPEG_ADJUST_FPS_TIMEOUT &&
- adjusted_fps_time_passed > 1000 / rate_control->adjusted_fps) {
- double avg_fps;
- double fps_ratio;
-
- avg_fps = ((double)rate_control->adjusted_fps_num_frames*1000) /
- adjusted_fps_time_passed;
- spice_debug("#frames-adjust=%"PRIu64" #adjust-time=%"PRIu64" avg-fps=%.2f",
- rate_control->adjusted_fps_num_frames, adjusted_fps_time_passed, avg_fps);
- spice_debug("defined=%u old-adjusted=%.2f", rate_control->fps, rate_control->adjusted_fps);
- fps_ratio = avg_fps / rate_control->fps;
- if (avg_fps + 0.5 < rate_control->fps &&
- mjpeg_encoder_get_source_fps(encoder) > avg_fps) {
- double new_adjusted_fps = avg_fps ?
- (rate_control->adjusted_fps/fps_ratio) :
- rate_control->adjusted_fps * 2;
-
- rate_control->adjusted_fps = MIN(rate_control->fps*2, new_adjusted_fps);
- spice_debug("new-adjusted-fps=%.2f", rate_control->adjusted_fps);
- } else if (rate_control->fps + 0.5 < avg_fps) {
- double new_adjusted_fps = rate_control->adjusted_fps / fps_ratio;
-
- rate_control->adjusted_fps = MAX(rate_control->fps, new_adjusted_fps);
- spice_debug("new-adjusted-fps=%.2f", rate_control->adjusted_fps);
- }
- rate_control->adjusted_fps_start_time = now;
- rate_control->adjusted_fps_num_frames = 0;
- }
-}
-
-/*
- * dest must be either NULL or allocated by malloc, since it might be freed
- * during the encoding, if its size is too small.
- *
- * return:
- * MJPEG_ENCODER_FRAME_UNSUPPORTED : frame cannot be encoded
- * MJPEG_ENCODER_FRAME_DROP : frame should be dropped. This value can only be returned
- * if mjpeg rate control is active.
- * MJPEG_ENCODER_FRAME_ENCODE_DONE : frame encoding started. Continue with
- * mjpeg_encoder_encode_scanline.
- */
-static int mjpeg_encoder_start_frame(MJpegEncoder *encoder,
- SpiceBitmapFmt format,
- int width, int height,
- uint8_t **dest, size_t *dest_len,
- uint32_t frame_mm_time)
-{
- uint32_t quality;
-
- if (rate_control_is_active(encoder)) {
- MJpegEncoderRateControl *rate_control = &encoder->rate_control;
- uint64_t now;
- uint64_t interval;
-
- now = red_get_monotonic_time();
-
- if (!rate_control->adjusted_fps_start_time) {
- rate_control->adjusted_fps_start_time = now;
- }
- mjpeg_encoder_adjust_fps(encoder, now);
- interval = (now - rate_control->bit_rate_info.last_frame_time);
-
- if (interval < (1000*1000*1000) / rate_control->adjusted_fps) {
- return MJPEG_ENCODER_FRAME_DROP;
- }
-
- mjpeg_encoder_adjust_params_to_bit_rate(encoder);
-
- if (!rate_control->during_quality_eval ||
- rate_control->quality_eval_data.reason == MJPEG_QUALITY_EVAL_REASON_SIZE_CHANGE) {
- MJpegEncoderBitRateInfo *bit_rate_info;
-
- bit_rate_info = &encoder->rate_control.bit_rate_info;
-
- if (!bit_rate_info->change_start_time) {
- bit_rate_info->change_start_time = now;
- bit_rate_info->change_start_mm_time = frame_mm_time;
- }
- bit_rate_info->last_frame_time = now;
- }
- }
-
- encoder->cinfo.in_color_space = JCS_RGB;
- encoder->cinfo.input_components = 3;
- encoder->pixel_converter = NULL;
-
- switch (format) {
- case SPICE_BITMAP_FMT_32BIT:
- case SPICE_BITMAP_FMT_RGBA:
- encoder->bytes_per_pixel = 4;
-#ifdef JCS_EXTENSIONS
- encoder->cinfo.in_color_space = JCS_EXT_BGRX;
- encoder->cinfo.input_components = 4;
-#else
- encoder->pixel_converter = pixel_rgb32bpp_to_24;
-#endif
- break;
- case SPICE_BITMAP_FMT_16BIT:
- encoder->bytes_per_pixel = 2;
- encoder->pixel_converter = pixel_rgb16bpp_to_24;
- break;
- case SPICE_BITMAP_FMT_24BIT:
- encoder->bytes_per_pixel = 3;
-#ifdef JCS_EXTENSIONS
- encoder->cinfo.in_color_space = JCS_EXT_BGR;
-#else
- encoder->pixel_converter = pixel_rgb24bpp_to_24;
-#endif
- break;
- default:
- spice_debug("unsupported format %d", format);
- return MJPEG_ENCODER_FRAME_UNSUPPORTED;
- }
-
- if (encoder->pixel_converter != NULL) {
- unsigned int stride = width * 3;
- /* check for integer overflow */
- if (stride < width) {
- return MJPEG_ENCODER_FRAME_UNSUPPORTED;
- }
- if (encoder->row_size < stride) {
- encoder->row = spice_realloc(encoder->row, stride);
- encoder->row_size = stride;
- }
- }
-
- spice_jpeg_mem_dest(&encoder->cinfo, dest, dest_len);
-
- encoder->cinfo.image_width = width;
- encoder->cinfo.image_height = height;
- jpeg_set_defaults(&encoder->cinfo);
- encoder->cinfo.dct_method = JDCT_IFAST;
- quality = mjpeg_quality_samples[encoder->rate_control.quality_id];
- jpeg_set_quality(&encoder->cinfo, quality, TRUE);
- jpeg_start_compress(&encoder->cinfo, encoder->first_frame);
-
- encoder->num_frames++;
- encoder->avg_quality += quality;
- return MJPEG_ENCODER_FRAME_ENCODE_DONE;
-}
-
-static int mjpeg_encoder_encode_scanline(MJpegEncoder *encoder,
- uint8_t *src_pixels,
- size_t image_width)
-{
- unsigned int scanlines_written;
- uint8_t *row;
-
- row = encoder->row;
- if (encoder->pixel_converter) {
- unsigned int x;
- for (x = 0; x < image_width; x++) {
- /* src_pixels is expected to be 4 bytes aligned */
- encoder->pixel_converter(src_pixels, row);
- row += 3;
- src_pixels += encoder->bytes_per_pixel;
- }
- scanlines_written = jpeg_write_scanlines(&encoder->cinfo, &encoder->row, 1);
- } else {
- scanlines_written = jpeg_write_scanlines(&encoder->cinfo, &src_pixels, 1);
- }
- if (scanlines_written == 0) { /* Not enough space */
- jpeg_abort_compress(&encoder->cinfo);
- encoder->rate_control.last_enc_size = 0;
- return 0;
- }
-
- return scanlines_written;
-}
-
-static size_t mjpeg_encoder_end_frame(MJpegEncoder *encoder)
-{
- mem_destination_mgr *dest = (mem_destination_mgr *) encoder->cinfo.dest;
- MJpegEncoderRateControl *rate_control = &encoder->rate_control;
-
- jpeg_finish_compress(&encoder->cinfo);
-
- encoder->first_frame = FALSE;
- rate_control->last_enc_size = dest->pub.next_output_byte - dest->buffer;
- rate_control->server_state.num_frames_encoded++;
-
- if (!rate_control->during_quality_eval ||
- rate_control->quality_eval_data.reason == MJPEG_QUALITY_EVAL_REASON_SIZE_CHANGE) {
-
- if (!rate_control->during_quality_eval) {
- if (rate_control->num_recent_enc_frames >= MJPEG_AVERAGE_SIZE_WINDOW) {
- rate_control->num_recent_enc_frames = 0;
- rate_control->sum_recent_enc_size = 0;
- }
- rate_control->sum_recent_enc_size += rate_control->last_enc_size;
- rate_control->num_recent_enc_frames++;
- rate_control->adjusted_fps_num_frames++;
- }
- rate_control->bit_rate_info.sum_enc_size += encoder->rate_control.last_enc_size;
- rate_control->bit_rate_info.num_enc_frames++;
- }
- return encoder->rate_control.last_enc_size;
-}
-
-static inline uint8_t *get_image_line(SpiceChunks *chunks, size_t *offset,
- int *chunk_nr, int stride)
-{
- uint8_t *ret;
- SpiceChunk *chunk;
-
- chunk = &chunks->chunk[*chunk_nr];
-
- if (*offset == chunk->len) {
- if (*chunk_nr == chunks->num_chunks - 1) {
- return NULL; /* Last chunk */
- }
- *offset = 0;
- (*chunk_nr)++;
- chunk = &chunks->chunk[*chunk_nr];
- }
-
- if (chunk->len - *offset < stride) {
- spice_warning("bad chunk alignment");
- return NULL;
- }
- ret = chunk->data + *offset;
- *offset += stride;
- return ret;
-}
-
-static int encode_frame(MJpegEncoder *encoder, const SpiceRect *src,
- const SpiceBitmap *image, int top_down)
-{
- SpiceChunks *chunks;
- uint32_t image_stride;
- size_t offset;
- int i, chunk;
-
- chunks = image->data;
- offset = 0;
- chunk = 0;
- image_stride = image->stride;
-
- const int skip_lines = top_down ? src->top : image->y - (src->bottom - 0);
- for (i = 0; i < skip_lines; i++) {
- get_image_line(chunks, &offset, &chunk, image_stride);
- }
-
- const unsigned int stream_height = src->bottom - src->top;
- const unsigned int stream_width = src->right - src->left;
-
- for (i = 0; i < stream_height; i++) {
- uint8_t *src_line = get_image_line(chunks, &offset, &chunk, image_stride);
-
- if (!src_line) {
- return FALSE;
- }
-
- src_line += src->left * mjpeg_encoder_get_bytes_per_pixel(encoder);
- if (mjpeg_encoder_encode_scanline(encoder, src_line, stream_width) == 0) {
- return FALSE;
- }
- }
-
- return TRUE;
-}
-
-int mjpeg_encoder_encode_frame(MJpegEncoder *encoder,
- const SpiceBitmap *bitmap, int width, int height,
- const SpiceRect *src,
- int top_down, uint32_t frame_mm_time,
- uint8_t **outbuf, size_t *outbuf_size,
- int *data_size)
-{
- int ret = mjpeg_encoder_start_frame(encoder, bitmap->format,
- width, height, outbuf, outbuf_size,
- frame_mm_time);
- if (ret != MJPEG_ENCODER_FRAME_ENCODE_DONE) {
- return ret;
- }
-
- if (!encode_frame(encoder, src, bitmap, top_down)) {
- return MJPEG_ENCODER_FRAME_UNSUPPORTED;
- }
-
- *data_size = mjpeg_encoder_end_frame(encoder);
-
- return MJPEG_ENCODER_FRAME_ENCODE_DONE;
-}
-
-
-static void mjpeg_encoder_quality_eval_stop(MJpegEncoder *encoder)
-{
- MJpegEncoderRateControl *rate_control = &encoder->rate_control;
- uint32_t quality_id;
- uint32_t fps;
-
- if (!rate_control->during_quality_eval) {
- return;
- }
- switch (rate_control->quality_eval_data.type) {
- case MJPEG_QUALITY_EVAL_TYPE_UPGRADE:
- quality_id = rate_control->quality_eval_data.min_quality_id;
- fps = rate_control->quality_eval_data.min_quality_fps;
- break;
- case MJPEG_QUALITY_EVAL_TYPE_DOWNGRADE:
- quality_id = rate_control->quality_eval_data.max_quality_id;
- fps = rate_control->quality_eval_data.max_quality_fps;
- break;
- case MJPEG_QUALITY_EVAL_TYPE_SET:
- quality_id = MJPEG_QUALITY_SAMPLE_NUM / 2;
- fps = MJPEG_MAX_FPS / 2;
- break;
- default:
- spice_warning("unexected");
- return;
- }
- mjpeg_encoder_reset_quality(encoder, quality_id, fps, 0);
- spice_debug("during quality evaluation: canceling."
- "reset quality to %d fps %d",
- mjpeg_quality_samples[rate_control->quality_id], rate_control->fps);
-}
-
-static void mjpeg_encoder_decrease_bit_rate(MJpegEncoder *encoder)
-{
- MJpegEncoderRateControl *rate_control = &encoder->rate_control;
- MJpegEncoderBitRateInfo *bit_rate_info = &rate_control->bit_rate_info;
- uint64_t measured_byte_rate;
- uint32_t measured_fps;
- uint64_t decrease_size;
-
- mjpeg_encoder_quality_eval_stop(encoder);
-
- rate_control->client_state.max_video_latency = 0;
- rate_control->client_state.max_audio_latency = 0;
- if (rate_control->warmup_start_time) {
- uint64_t now;
-
- now = red_get_monotonic_time();
- if (now - rate_control->warmup_start_time < MJPEG_WARMUP_TIME*1000*1000) {
- spice_debug("during warmup. ignoring");
- return;
- } else {
- rate_control->warmup_start_time = 0;
- }
- }
-
- if (bit_rate_info->num_enc_frames > MJPEG_BIT_RATE_EVAL_MIN_NUM_FRAMES ||
- bit_rate_info->num_enc_frames > rate_control->fps) {
- double duration_sec;
-
- duration_sec = (bit_rate_info->last_frame_time - bit_rate_info->change_start_time);
- duration_sec /= (1000.0 * 1000.0 * 1000.0);
- measured_byte_rate = bit_rate_info->sum_enc_size / duration_sec;
- measured_fps = bit_rate_info->num_enc_frames / duration_sec;
- decrease_size = bit_rate_info->sum_enc_size / bit_rate_info->num_enc_frames;
- spice_debug("bit rate esitimation %.2f (Mbps) fps %u",
- measured_byte_rate*8/1024.0/1024,
- measured_fps);
- } else {
- measured_byte_rate = rate_control->byte_rate;
- measured_fps = rate_control->fps;
- decrease_size = measured_byte_rate/measured_fps;
- spice_debug("bit rate not re-estimated %.2f (Mbps) fps %u",
- measured_byte_rate*8/1024.0/1024,
- measured_fps);
- }
-
- measured_byte_rate = MIN(rate_control->byte_rate, measured_byte_rate);
-
- if (decrease_size >= measured_byte_rate) {
- decrease_size = measured_byte_rate / 2;
- }
-
- rate_control->byte_rate = measured_byte_rate - decrease_size;
- bit_rate_info->change_start_time = 0;
- bit_rate_info->change_start_mm_time = 0;
- bit_rate_info->last_frame_time = 0;
- bit_rate_info->num_enc_frames = 0;
- bit_rate_info->sum_enc_size = 0;
- bit_rate_info->was_upgraded = FALSE;
-
- spice_debug("decrease bit rate %.2f (Mbps)", rate_control->byte_rate * 8 / 1024.0/1024.0);
- mjpeg_encoder_quality_eval_set_downgrade(encoder,
- MJPEG_QUALITY_EVAL_REASON_RATE_CHANGE,
- rate_control->quality_id,
- rate_control->fps);
-}
-
-static void mjpeg_encoder_handle_negative_client_stream_report(MJpegEncoder *encoder,
- uint32_t report_end_frame_mm_time)
-{
- MJpegEncoderRateControl *rate_control = &encoder->rate_control;
-
- spice_debug(NULL);
-
- if ((rate_control->bit_rate_info.change_start_mm_time > report_end_frame_mm_time ||
- !rate_control->bit_rate_info.change_start_mm_time) &&
- !rate_control->bit_rate_info.was_upgraded) {
- spice_debug("ignoring, a downgrade has already occurred later to the report time");
- return;
- }
-
- mjpeg_encoder_decrease_bit_rate(encoder);
-}
-
-static void mjpeg_encoder_increase_bit_rate(MJpegEncoder *encoder)
-{
- MJpegEncoderRateControl *rate_control = &encoder->rate_control;
- MJpegEncoderBitRateInfo *bit_rate_info = &rate_control->bit_rate_info;
- uint64_t measured_byte_rate;
- uint32_t measured_fps;
- uint64_t increase_size;
-
-
- if (bit_rate_info->num_enc_frames > MJPEG_BIT_RATE_EVAL_MIN_NUM_FRAMES ||
- bit_rate_info->num_enc_frames > rate_control->fps) {
- uint64_t avg_frame_size;
- double duration_sec;
-
- duration_sec = (bit_rate_info->last_frame_time - bit_rate_info->change_start_time);
- duration_sec /= (1000.0 * 1000.0 * 1000.0);
- measured_byte_rate = bit_rate_info->sum_enc_size / duration_sec;
- measured_fps = bit_rate_info->num_enc_frames / duration_sec;
- avg_frame_size = bit_rate_info->sum_enc_size / bit_rate_info->num_enc_frames;
- spice_debug("bit rate esitimation %.2f (Mbps) defined %.2f"
- " fps %u avg-frame-size=%.2f (KB)",
- measured_byte_rate*8/1024.0/1024,
- rate_control->byte_rate*8/1024.0/1024,
- measured_fps,
- avg_frame_size/1024.0);
- increase_size = avg_frame_size;
- } else {
- spice_debug("not enough samples for measuring the bit rate. no change");
- return;
- }
-
-
- mjpeg_encoder_quality_eval_stop(encoder);
-
- if (measured_byte_rate + increase_size < rate_control->byte_rate) {
- spice_debug("measured byte rate is small: not upgrading, just re-evaluating");
- } else {
- rate_control->byte_rate = MIN(measured_byte_rate, rate_control->byte_rate) + increase_size;
- }
-
- bit_rate_info->change_start_time = 0;
- bit_rate_info->change_start_mm_time = 0;
- bit_rate_info->last_frame_time = 0;
- bit_rate_info->num_enc_frames = 0;
- bit_rate_info->sum_enc_size = 0;
- bit_rate_info->was_upgraded = TRUE;
-
- spice_debug("increase bit rate %.2f (Mbps)", rate_control->byte_rate * 8 / 1024.0/1024.0);
- mjpeg_encoder_quality_eval_set_upgrade(encoder,
- MJPEG_QUALITY_EVAL_REASON_RATE_CHANGE,
- rate_control->quality_id,
- rate_control->fps);
-}
-
-static void mjpeg_encoder_handle_positive_client_stream_report(MJpegEncoder *encoder,
- uint32_t report_start_frame_mm_time)
-{
- MJpegEncoderRateControl *rate_control = &encoder->rate_control;
- MJpegEncoderBitRateInfo *bit_rate_info = &rate_control->bit_rate_info;
- int stable_client_mm_time;
- int timeout;
-
- if (rate_control->during_quality_eval &&
- rate_control->quality_eval_data.reason == MJPEG_QUALITY_EVAL_REASON_RATE_CHANGE) {
- spice_debug("during quality evaluation (rate change). ignoring report");
- return;
- }
-
- if ((rate_control->fps > MJPEG_IMPROVE_QUALITY_FPS_STRICT_TH ||
- rate_control->fps >= mjpeg_encoder_get_source_fps(encoder)) &&
- rate_control->quality_id > MJPEG_QUALITY_SAMPLE_NUM / 2) {
- timeout = MJPEG_CLIENT_POSITIVE_REPORT_STRICT_TIMEOUT;
- } else {
- timeout = MJPEG_CLIENT_POSITIVE_REPORT_TIMEOUT;
- }
-
- stable_client_mm_time = (int)report_start_frame_mm_time - bit_rate_info->change_start_mm_time;
-
- if (!bit_rate_info->change_start_mm_time || stable_client_mm_time < timeout) {
- /* assessing the stability of the current setting and only then
- * respond to the report */
- spice_debug("no drops, but not enough time has passed for assessing"
- "the playback stability since the last bit rate change");
- return;
- }
- mjpeg_encoder_increase_bit_rate(encoder);
-}
-
-/*
- * the video playback jitter buffer should be at least (send_time*2 + net_latency) for
- * preventing underflow
- */
-static uint32_t get_min_required_playback_delay(uint64_t frame_enc_size,
- uint64_t byte_rate,
- uint32_t latency)
-{
- uint32_t one_frame_time;
- uint32_t min_delay;
-
- if (!frame_enc_size || !byte_rate) {
- return latency;
- }
- one_frame_time = (frame_enc_size*1000)/byte_rate;
-
- min_delay = MIN(one_frame_time*2 + latency, MJPEG_MAX_CLIENT_PLAYBACK_DELAY);
- return min_delay;
-}
-
-#define MJPEG_PLAYBACK_LATENCY_DECREASE_FACTOR 0.5
-#define MJPEG_VIDEO_VS_AUDIO_LATENCY_FACTOR 1.25
-#define MJPEG_VIDEO_DELAY_TH -15
-
-void mjpeg_encoder_client_stream_report(MJpegEncoder *encoder,
- uint32_t num_frames,
- uint32_t num_drops,
- uint32_t start_frame_mm_time,
- uint32_t end_frame_mm_time,
- int32_t end_frame_delay,
- uint32_t audio_delay)
-{
- MJpegEncoderRateControl *rate_control = &encoder->rate_control;
- MJpegEncoderClientState *client_state = &rate_control->client_state;
- uint64_t avg_enc_size = 0;
- uint32_t min_playback_delay;
- int is_video_delay_small = FALSE;
-
- spice_debug("client report: #frames %u, #drops %d, duration %u video-delay %d audio-delay %u",
- num_frames, num_drops,
- end_frame_mm_time - start_frame_mm_time,
- end_frame_delay, audio_delay);
-
- if (!rate_control_is_active(encoder)) {
- spice_debug("rate control was not activated: ignoring");
- return;
- }
- if (rate_control->during_quality_eval) {
- if (rate_control->quality_eval_data.type == MJPEG_QUALITY_EVAL_TYPE_DOWNGRADE &&
- rate_control->quality_eval_data.reason == MJPEG_QUALITY_EVAL_REASON_RATE_CHANGE) {
- spice_debug("during rate downgrade evaluation");
- return;
- }
- }
-
- if (rate_control->num_recent_enc_frames) {
- avg_enc_size = rate_control->sum_recent_enc_size /
- rate_control->num_recent_enc_frames;
- }
- spice_debug("recent size avg %.2f (KB)", avg_enc_size / 1024.0);
- min_playback_delay = get_min_required_playback_delay(avg_enc_size, rate_control->byte_rate,
- mjpeg_encoder_get_latency(encoder));
- spice_debug("min-delay %u client-delay %d", min_playback_delay, end_frame_delay);
-
- if (min_playback_delay > end_frame_delay) {
- uint32_t src_fps = mjpeg_encoder_get_source_fps(encoder);
- /*
- * if the stream is at its highest rate, we can't estimate the "real"
- * network bit rate and the min_playback_delay
- */
- if (rate_control->quality_id != MJPEG_QUALITY_SAMPLE_NUM - 1 ||
- rate_control->fps < MIN(src_fps, MJPEG_MAX_FPS) || end_frame_delay < 0) {
- is_video_delay_small = TRUE;
- if (encoder->cbs.update_client_playback_delay) {
- encoder->cbs.update_client_playback_delay(encoder->cbs_opaque,
- min_playback_delay);
- }
- }
- }
-
-
- /*
- * If the audio latency has decreased (since the start of the current
- * sequence of positive reports), and the video latency is bigger, slow down
- * the video rate
- */
- if (end_frame_delay > 0 &&
- audio_delay < MJPEG_PLAYBACK_LATENCY_DECREASE_FACTOR*client_state->max_audio_latency &&
- end_frame_delay > MJPEG_VIDEO_VS_AUDIO_LATENCY_FACTOR*audio_delay) {
- spice_debug("video_latency >> audio_latency && audio_latency << max (%u)",
- client_state->max_audio_latency);
- mjpeg_encoder_handle_negative_client_stream_report(encoder,
- end_frame_mm_time);
- return;
- }
-
- if (end_frame_delay < MJPEG_VIDEO_DELAY_TH) {
- mjpeg_encoder_handle_negative_client_stream_report(encoder,
- end_frame_mm_time);
- } else {
- double major_delay_decrease_thresh;
- double medium_delay_decrease_thresh;
-
- client_state->max_video_latency = MAX(end_frame_delay, client_state->max_video_latency);
- client_state->max_audio_latency = MAX(audio_delay, client_state->max_audio_latency);
-
- medium_delay_decrease_thresh = client_state->max_video_latency;
- medium_delay_decrease_thresh *= MJPEG_PLAYBACK_LATENCY_DECREASE_FACTOR;
-
- major_delay_decrease_thresh = medium_delay_decrease_thresh;
- major_delay_decrease_thresh *= MJPEG_PLAYBACK_LATENCY_DECREASE_FACTOR;
- /*
- * since the bit rate and the required latency are only evaluation based on the
- * reports we got till now, we assume that the latency is too low only if it
- * was higher during the time that passed since the last report that resulted
- * in a bit rate decrement. If we find that the latency has decreased, it might
- * suggest that the stream bit rate is too high.
- */
- if ((end_frame_delay < medium_delay_decrease_thresh &&
- is_video_delay_small) || end_frame_delay < major_delay_decrease_thresh) {
- spice_debug("downgrade due to short video delay (last=%u, past-max=%u",
- end_frame_delay, client_state->max_video_latency);
- mjpeg_encoder_handle_negative_client_stream_report(encoder,
- end_frame_mm_time);
- } else if (!num_drops) {
- mjpeg_encoder_handle_positive_client_stream_report(encoder,
- start_frame_mm_time);
-
- }
- }
-}
-
-void mjpeg_encoder_notify_server_frame_drop(MJpegEncoder *encoder)
-{
- encoder->rate_control.server_state.num_frames_dropped++;
- mjpeg_encoder_process_server_drops(encoder);
-}
-
-/*
- * decrease the bit rate if the drop rate on the sever side exceeds a pre defined
- * threshold.
- */
-static void mjpeg_encoder_process_server_drops(MJpegEncoder *encoder)
-{
- MJpegEncoderServerState *server_state = &encoder->rate_control.server_state;
- uint32_t num_frames_total;
- double drop_factor;
- uint32_t fps;
-
- fps = MIN(encoder->rate_control.fps, mjpeg_encoder_get_source_fps(encoder));
- if (server_state->num_frames_encoded < fps * MJPEG_SERVER_STATUS_EVAL_FPS_INTERVAL) {
- return;
- }
-
- num_frames_total = server_state->num_frames_dropped + server_state->num_frames_encoded;
- drop_factor = ((double)server_state->num_frames_dropped) / num_frames_total;
-
- spice_debug("#drops %u total %u fps %u src-fps %u",
- server_state->num_frames_dropped,
- num_frames_total,
- encoder->rate_control.fps,
- mjpeg_encoder_get_source_fps(encoder));
-
- if (drop_factor > MJPEG_SERVER_STATUS_DOWNGRADE_DROP_FACTOR_TH) {
- mjpeg_encoder_decrease_bit_rate(encoder);
- }
- server_state->num_frames_encoded = 0;
- server_state->num_frames_dropped = 0;
-}
-
-uint64_t mjpeg_encoder_get_bit_rate(MJpegEncoder *encoder)
-{
- return encoder->rate_control.byte_rate * 8;
-}
-
-void mjpeg_encoder_get_stats(MJpegEncoder *encoder, MJpegEncoderStats *stats)
-{
- spice_assert(encoder != NULL && stats != NULL);
- stats->starting_bit_rate = encoder->starting_bit_rate;
- stats->cur_bit_rate = mjpeg_encoder_get_bit_rate(encoder);
- stats->avg_quality = (double)encoder->avg_quality / encoder->num_frames;
-}
-
-MJpegEncoder *mjpeg_encoder_new(uint64_t starting_bit_rate,
- MJpegEncoderRateControlCbs *cbs,
- void *cbs_opaque)
-{
- MJpegEncoder *encoder = spice_new0(MJpegEncoder, 1);
-
- encoder->first_frame = TRUE;
- encoder->rate_control.byte_rate = starting_bit_rate / 8;
- encoder->starting_bit_rate = starting_bit_rate;
-
- if (cbs) {
- struct timespec time;
-
- clock_gettime(CLOCK_MONOTONIC, &time);
- encoder->cbs = *cbs;
- encoder->cbs_opaque = cbs_opaque;
- mjpeg_encoder_reset_quality(encoder, MJPEG_QUALITY_SAMPLE_NUM / 2, 5, 0);
- encoder->rate_control.during_quality_eval = TRUE;
- encoder->rate_control.quality_eval_data.type = MJPEG_QUALITY_EVAL_TYPE_SET;
- encoder->rate_control.quality_eval_data.reason = MJPEG_QUALITY_EVAL_REASON_RATE_CHANGE;
- encoder->rate_control.warmup_start_time = ((uint64_t) time.tv_sec) * 1000000000 + time.tv_nsec;
- } else {
- encoder->cbs.get_roundtrip_ms = NULL;
- mjpeg_encoder_reset_quality(encoder, MJPEG_LEGACY_STATIC_QUALITY_ID, MJPEG_MAX_FPS, 0);
- }
-
- encoder->cinfo.err = jpeg_std_error(&encoder->jerr);
- jpeg_create_compress(&encoder->cinfo);
-
- return encoder;
-}
diff --git a/server/mjpeg_encoder.h b/server/mjpeg_encoder.h
deleted file mode 100644
index d070e70..0000000
--- a/server/mjpeg_encoder.h
+++ /dev/null
@@ -1,100 +0,0 @@
-/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- Copyright (C) 2009 Red Hat, Inc.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, see <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _H_MJPEG_ENCODER
-#define _H_MJPEG_ENCODER
-
-#include "red_common.h"
-
-enum {
- MJPEG_ENCODER_FRAME_UNSUPPORTED = -1,
- MJPEG_ENCODER_FRAME_DROP,
- MJPEG_ENCODER_FRAME_ENCODE_DONE,
-};
-
-typedef struct MJpegEncoder MJpegEncoder;
-
-/*
- * Callbacks required for controling and adjusting
- * the stream bit rate:
- * get_roundtrip_ms: roundtrip time in milliseconds
- * get_source_fps: the input frame rate (#frames per second), i.e.,
- * the rate of frames arriving from the guest to spice-server,
- * before any drops.
- */
-typedef struct MJpegEncoderRateControlCbs {
- uint32_t (*get_roundtrip_ms)(void *opaque);
- uint32_t (*get_source_fps)(void *opaque);
- void (*update_client_playback_delay)(void *opaque, uint32_t delay_ms);
-} MJpegEncoderRateControlCbs;
-
-typedef struct MJpegEncoderStats {
- uint64_t starting_bit_rate;
- uint64_t cur_bit_rate;
- double avg_quality;
-} MJpegEncoderStats;
-
-MJpegEncoder *mjpeg_encoder_new(uint64_t starting_bit_rate,
- MJpegEncoderRateControlCbs *cbs, void *opaque);
-void mjpeg_encoder_destroy(MJpegEncoder *encoder);
-
-int mjpeg_encoder_encode_frame(MJpegEncoder *encoder,
- const SpiceBitmap *bitmap, int width, int height,
- const SpiceRect *src,
- int top_down, uint32_t frame_mm_time,
- uint8_t **outbuf, size_t *outbuf_size,
- int *data_size);
-
-/*
- * bit rate control
- */
-
-/*
- * Data that should be periodically obtained from the client. The report contains:
- * num_frames : the number of frames that reached the client during the time
- * the report is referring to.
- * num_drops : the part of the above frames that was dropped by the client due to
- * late arrival time.
- * start_frame_mm_time: the mm_time of the first frame included in the report
- * end_frame_mm_time : the mm_time of the last_frame included in the report
- * end_frame_delay : (end_frame_mm_time - client_mm_time)
- * audio delay : the latency of the audio playback.
- * If there is no audio playback, set it to MAX_UINT.
- *
- */
-void mjpeg_encoder_client_stream_report(MJpegEncoder *encoder,
- uint32_t num_frames,
- uint32_t num_drops,
- uint32_t start_frame_mm_time,
- uint32_t end_frame_mm_time,
- int32_t end_frame_delay,
- uint32_t audio_delay);
-
-/*
- * Notify the encoder each time a frame is dropped due to pipe
- * congestion.
- * We can deduce the client state by the frame dropping rate in the server.
- * Monitoring the frame drops can help in fine tuning the playback parameters
- * when the client reports are delayed.
- */
-void mjpeg_encoder_notify_server_frame_drop(MJpegEncoder *encoder);
-
-uint64_t mjpeg_encoder_get_bit_rate(MJpegEncoder *encoder);
-void mjpeg_encoder_get_stats(MJpegEncoder *encoder, MJpegEncoderStats *stats);
-
-#endif
diff --git a/server/red_channel.c b/server/red_channel.c
index 609c83f..948d354 100644
--- a/server/red_channel.c
+++ b/server/red_channel.c
@@ -42,7 +42,7 @@
#include "red_channel.h"
#include "reds.h"
#include "reds_stream.h"
-#include "main_dispatcher.h"
+#include "main-dispatcher.h"
#include "utils.h"
typedef struct EmptyMsgPipeItem {
diff --git a/server/red_dispatcher.c b/server/red_dispatcher.c
index a7825f5..b8b77d7 100644
--- a/server/red_dispatcher.c
+++ b/server/red_dispatcher.c
@@ -32,7 +32,7 @@
#include "spice.h"
#include "red_worker.h"
-#include "reds_sw_canvas.h"
+#include "sw-canvas.h"
#include "reds.h"
#include "dispatcher.h"
#include "red_parse_qxl.h"
diff --git a/server/red_memslots.c b/server/red_memslots.c
deleted file mode 100644
index 0d2d963..0000000
--- a/server/red_memslots.c
+++ /dev/null
@@ -1,184 +0,0 @@
-/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- Copyright (C) 2009,2010 Red Hat, Inc.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, see <http://www.gnu.org/licenses/>.
-*/
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#include <inttypes.h>
-
-#include "red_common.h"
-#include "red_memslots.h"
-
-static unsigned long __get_clean_virt(RedMemSlotInfo *info, QXLPHYSICAL addr)
-{
- return addr & info->memslot_clean_virt_mask;
-}
-
-static void print_memslots(RedMemSlotInfo *info)
-{
- int i;
- int x;
-
- for (i = 0; i < info->num_memslots_groups; ++i) {
- for (x = 0; x < info->num_memslots; ++x) {
- if (!info->mem_slots[i][x].virt_start_addr &&
- !info->mem_slots[i][x].virt_end_addr) {
- continue;
- }
- printf("id %d, group %d, virt start %lx, virt end %lx, generation %u, delta %lx\n",
- x, i, info->mem_slots[i][x].virt_start_addr,
- info->mem_slots[i][x].virt_end_addr, info->mem_slots[i][x].generation,
- info->mem_slots[i][x].address_delta);
- }
- }
-}
-
-/* return 1 if validation successfull, 0 otherwise */
-int memslot_validate_virt(RedMemSlotInfo *info, unsigned long virt, int slot_id,
- uint32_t add_size, uint32_t group_id)
-{
- MemSlot *slot;
-
- slot = &info->mem_slots[group_id][slot_id];
- if ((virt + add_size) < virt) {
- spice_critical("virtual address overlap");
- return 0;
- }
-
- if (virt < slot->virt_start_addr || (virt + add_size) > slot->virt_end_addr) {
- print_memslots(info);
- spice_critical("virtual address out of range\n"
- " virt=0x%lx+0x%x slot_id=%d group_id=%d\n"
- " slot=0x%lx-0x%lx delta=0x%lx",
- virt, add_size, slot_id, group_id,
- slot->virt_start_addr, slot->virt_end_addr, slot->address_delta);
- return 0;
- }
- return 1;
-}
-
-/*
- * return virtual address if successful, which may be 0.
- * returns 0 and sets error to 1 if an error condition occurs.
- */
-unsigned long memslot_get_virt(RedMemSlotInfo *info, QXLPHYSICAL addr, uint32_t add_size,
- int group_id, int *error)
-{
- int slot_id;
- int generation;
- unsigned long h_virt;
-
- MemSlot *slot;
-
- *error = 0;
- if (group_id > info->num_memslots_groups) {
- spice_critical("group_id too big");
- *error = 1;
- return 0;
- }
-
- slot_id = memslot_get_id(info, addr);
- if (slot_id > info->num_memslots) {
- print_memslots(info);
- spice_critical("slot_id %d too big, addr=%" PRIx64, slot_id, addr);
- *error = 1;
- return 0;
- }
-
- slot = &info->mem_slots[group_id][slot_id];
-
- generation = memslot_get_generation(info, addr);
- if (generation != slot->generation) {
- print_memslots(info);
- spice_critical("address generation is not valid, group_id %d, slot_id %d, gen %d, slot_gen %d\n",
- group_id, slot_id, generation, slot->generation);
- *error = 1;
- return 0;
- }
-
- h_virt = __get_clean_virt(info, addr);
- h_virt += slot->address_delta;
-
- if (!memslot_validate_virt(info, h_virt, slot_id, add_size, group_id)) {
- *error = 1;
- return 0;
- }
-
- return h_virt;
-}
-
-void memslot_info_init(RedMemSlotInfo *info,
- uint32_t num_groups, uint32_t num_slots,
- uint8_t generation_bits,
- uint8_t id_bits,
- uint8_t internal_groupslot_id)
-{
- uint32_t i;
-
- spice_return_if_fail(num_slots > 0);
- spice_return_if_fail(num_groups > 0);
-
- info->num_memslots_groups = num_groups;
- info->num_memslots = num_slots;
- info->generation_bits = generation_bits;
- info->mem_slot_bits = id_bits;
- info->internal_groupslot_id = internal_groupslot_id;
-
- info->mem_slots = spice_new(MemSlot *, num_groups);
-
- for (i = 0; i < num_groups; ++i) {
- info->mem_slots[i] = spice_new0(MemSlot, num_slots);
- }
-
- /* TODO: use QXLPHYSICAL_BITS */
- info->memslot_id_shift = 64 - info->mem_slot_bits;
- info->memslot_gen_shift = 64 - (info->mem_slot_bits + info->generation_bits);
- info->memslot_gen_mask = ~((QXLPHYSICAL)-1 << info->generation_bits);
- info->memslot_clean_virt_mask = (((QXLPHYSICAL)(-1)) >>
- (info->mem_slot_bits + info->generation_bits));
-}
-
-void memslot_info_add_slot(RedMemSlotInfo *info, uint32_t slot_group_id, uint32_t slot_id,
- uint64_t addr_delta, unsigned long virt_start, unsigned long virt_end,
- uint32_t generation)
-{
- spice_return_if_fail(info->num_memslots_groups > slot_group_id);
- spice_return_if_fail(info->num_memslots > slot_id);
-
- info->mem_slots[slot_group_id][slot_id].address_delta = addr_delta;
- info->mem_slots[slot_group_id][slot_id].virt_start_addr = virt_start;
- info->mem_slots[slot_group_id][slot_id].virt_end_addr = virt_end;
- info->mem_slots[slot_group_id][slot_id].generation = generation;
-}
-
-void memslot_info_del_slot(RedMemSlotInfo *info, uint32_t slot_group_id, uint32_t slot_id)
-{
- spice_return_if_fail(info->num_memslots_groups > slot_group_id);
- spice_return_if_fail(info->num_memslots > slot_id);
-
- info->mem_slots[slot_group_id][slot_id].virt_start_addr = 0;
- info->mem_slots[slot_group_id][slot_id].virt_end_addr = 0;
-}
-
-void memslot_info_reset(RedMemSlotInfo *info)
-{
- uint32_t i;
- for (i = 0; i < info->num_memslots_groups; ++i) {
- memset(info->mem_slots[i], 0, sizeof(MemSlot) * info->num_memslots);
- }
-}
diff --git a/server/red_memslots.h b/server/red_memslots.h
deleted file mode 100644
index a40050c..0000000
--- a/server/red_memslots.h
+++ /dev/null
@@ -1,72 +0,0 @@
-/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- Copyright (C) 2009,2010 Red Hat, Inc.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, see <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _H_REDMEMSLOTS
-#define _H_REDMEMSLOTS
-
-#include "red_common.h"
-
-#include <spice/qxl_dev.h>
-
-typedef struct MemSlot {
- int generation;
- unsigned long virt_start_addr;
- unsigned long virt_end_addr;
- long address_delta;
-} MemSlot;
-
-typedef struct RedMemSlotInfo {
- MemSlot **mem_slots;
- uint32_t num_memslots_groups;
- uint32_t num_memslots;
- uint8_t mem_slot_bits;
- uint8_t generation_bits;
- uint8_t memslot_id_shift;
- uint8_t memslot_gen_shift;
- uint8_t internal_groupslot_id;
- unsigned long memslot_gen_mask;
- unsigned long memslot_clean_virt_mask;
-} RedMemSlotInfo;
-
-static inline int memslot_get_id(RedMemSlotInfo *info, uint64_t addr)
-{
- return addr >> info->memslot_id_shift;
-}
-
-static inline int memslot_get_generation(RedMemSlotInfo *info, uint64_t addr)
-{
- return (addr >> info->memslot_gen_shift) & info->memslot_gen_mask;
-}
-
-int memslot_validate_virt(RedMemSlotInfo *info, unsigned long virt, int slot_id,
- uint32_t add_size, uint32_t group_id);
-unsigned long memslot_get_virt(RedMemSlotInfo *info, QXLPHYSICAL addr, uint32_t add_size,
- int group_id, int *error);
-
-void memslot_info_init(RedMemSlotInfo *info,
- uint32_t num_groups, uint32_t num_slots,
- uint8_t generation_bits,
- uint8_t id_bits,
- uint8_t internal_groupslot_id);
-void memslot_info_add_slot(RedMemSlotInfo *info, uint32_t slot_group_id, uint32_t slot_id,
- uint64_t addr_delta, unsigned long virt_start, unsigned long virt_end,
- uint32_t generation);
-void memslot_info_del_slot(RedMemSlotInfo *info, uint32_t slot_group_id, uint32_t slot_id);
-void memslot_info_reset(RedMemSlotInfo *info);
-
-#endif
diff --git a/server/red_parse_qxl.c b/server/red_parse_qxl.c
index 6e2ca99..522a915 100644
--- a/server/red_parse_qxl.c
+++ b/server/red_parse_qxl.c
@@ -25,7 +25,7 @@
#include "common/lz_common.h"
#include "spice-bitmap-utils.h"
#include "red_common.h"
-#include "red_memslots.h"
+#include "memslot.h"
#include "red_parse_qxl.h"
/* Max size in bytes for any data field used in a QXL command.
diff --git a/server/red_parse_qxl.h b/server/red_parse_qxl.h
index b3b28e1..09059f5 100644
--- a/server/red_parse_qxl.h
+++ b/server/red_parse_qxl.h
@@ -21,7 +21,7 @@
#include <spice/qxl_dev.h>
#include "red_common.h"
-#include "red_memslots.h"
+#include "memslot.h"
typedef struct RedDrawable {
int refs;
diff --git a/server/red_record_qxl.c b/server/red_record_qxl.c
index 17f17bd..52c0e81 100644
--- a/server/red_record_qxl.c
+++ b/server/red_record_qxl.c
@@ -23,9 +23,9 @@
#include <inttypes.h>
#include "red_worker.h"
#include "red_common.h"
-#include "red_memslots.h"
+#include "memslot.h"
#include "red_parse_qxl.h"
-#include "zlib_encoder.h"
+#include "zlib-encoder.h"
#if 0
static void hexdump_qxl(RedMemSlotInfo *slots, int group_id,
diff --git a/server/red_record_qxl.h b/server/red_record_qxl.h
index b737db8..6fcbec9 100644
--- a/server/red_record_qxl.h
+++ b/server/red_record_qxl.h
@@ -21,7 +21,7 @@
#include <spice/qxl_dev.h>
#include "red_common.h"
-#include "red_memslots.h"
+#include "memslot.h"
void red_record_dev_input_primary_surface_create(
FILE *fd, QXLDevSurfaceCreate *surface, uint8_t *line_0);
diff --git a/server/red_replay_qxl.c b/server/red_replay_qxl.c
index ad1a8fd..6e32588 100644
--- a/server/red_replay_qxl.c
+++ b/server/red_replay_qxl.c
@@ -26,7 +26,7 @@
#include "reds.h"
#include "red_worker.h"
#include "red_common.h"
-#include "red_memslots.h"
+#include "memslot.h"
#include "red_parse_qxl.h"
#include "red_replay_qxl.h"
#include <glib.h>
diff --git a/server/reds.c b/server/reds.c
index 8b3c3cb..5891034 100644
--- a/server/reds.c
+++ b/server/reds.c
@@ -56,16 +56,16 @@
#include "spice.h"
#include "reds.h"
#include "agent-msg-filter.h"
-#include "inputs_channel.h"
-#include "main_channel.h"
+#include "inputs-channel.h"
+#include "main-channel.h"
#include "red_common.h"
#include "red_dispatcher.h"
-#include "main_dispatcher.h"
-#include "snd_worker.h"
+#include "main-dispatcher.h"
+#include "sound.h"
#include "stat.h"
#include "demarshallers.h"
-#include "char_device.h"
-#include "migration_protocol.h"
+#include "char-device.h"
+#include "migration-protocol.h"
#ifdef USE_SMARTCARD
#include "smartcard.h"
#endif
diff --git a/server/reds.h b/server/reds.h
index fcdc5eb..0584694 100644
--- a/server/reds.h
+++ b/server/reds.h
@@ -28,7 +28,7 @@
#include "common/messages.h"
#include "spice.h"
#include "red_channel.h"
-#include "migration_protocol.h"
+#include "migration-protocol.h"
struct QXLState {
QXLInterface *qif;
@@ -75,7 +75,7 @@ extern SpiceImageCompression image_compression;
extern spice_wan_compression_t jpeg_state;
extern spice_wan_compression_t zlib_glz_state;
-// Temporary measures to make splitting reds.c to inputs_channel.c easier
+// Temporary measures to make splitting reds.c to inputs-channel.c easier
/* should be called only from main_dispatcher */
void reds_client_disconnect(RedClient *client);
diff --git a/server/reds_stream.c b/server/reds_stream.c
index 3b47391..6f5c43f 100644
--- a/server/reds_stream.c
+++ b/server/reds_stream.c
@@ -19,7 +19,7 @@
#include <config.h>
#endif
-#include "main_dispatcher.h"
+#include "main-dispatcher.h"
#include "red_common.h"
#include "reds_stream.h"
#include "common/log.h"
diff --git a/server/reds_sw_canvas.c b/server/reds_sw_canvas.c
deleted file mode 100644
index 297df37..0000000
--- a/server/reds_sw_canvas.c
+++ /dev/null
@@ -1,26 +0,0 @@
-/*
- Copyright (C) 2011 Red Hat, Inc.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, see <http://www.gnu.org/licenses/>.
-*/
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#include "common/spice_common.h"
-
-#include "reds_sw_canvas.h"
-#define SW_CANVAS_IMAGE_CACHE
-#include "common/sw_canvas.c"
-#undef SW_CANVAS_IMAGE_CACHE
diff --git a/server/reds_sw_canvas.h b/server/reds_sw_canvas.h
deleted file mode 100644
index 96a4c0c..0000000
--- a/server/reds_sw_canvas.h
+++ /dev/null
@@ -1,24 +0,0 @@
-/*
- Copyright (C) 2011 Red Hat, Inc.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, see <http://www.gnu.org/licenses/>.
-*/
-#ifndef _H_REDS_SW_CANVAS
-#define _H_REDS_SW_CANVAS
-
-#define SW_CANVAS_IMAGE_CACHE
-#include "common/sw_canvas.h"
-#undef SW_CANVAS_IMAGE_CACHE
-
-#endif
diff --git a/server/smartcard.c b/server/smartcard.c
index aad22aa..928e27b8 100644
--- a/server/smartcard.c
+++ b/server/smartcard.c
@@ -23,10 +23,10 @@
#include <vscard_common.h>
#include "reds.h"
-#include "char_device.h"
+#include "char-device.h"
#include "red_channel.h"
#include "smartcard.h"
-#include "migration_protocol.h"
+#include "migration-protocol.h"
/*
* TODO: the code doesn't really support multiple readers.
diff --git a/server/snd_worker.c b/server/snd_worker.c
deleted file mode 100644
index b039939..0000000
--- a/server/snd_worker.c
+++ /dev/null
@@ -1,1625 +0,0 @@
-/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- Copyright (C) 2009 Red Hat, Inc.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, see <http://www.gnu.org/licenses/>.
-*/
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#include <fcntl.h>
-#include <errno.h>
-#include <limits.h>
-#include <sys/socket.h>
-#include <netinet/ip.h>
-#include <netinet/tcp.h>
-
-#include "common/marshaller.h"
-#include "common/generated_server_marshallers.h"
-
-#include "spice.h"
-#include "red_common.h"
-#include "main_channel.h"
-#include "reds.h"
-#include "red_dispatcher.h"
-#include "snd_worker.h"
-#include "common/snd_codec.h"
-#include "demarshallers.h"
-
-#ifndef IOV_MAX
-#define IOV_MAX 1024
-#endif
-
-#define SND_RECEIVE_BUF_SIZE (16 * 1024 * 2)
-#define RECORD_SAMPLES_SIZE (SND_RECEIVE_BUF_SIZE >> 2)
-
-enum PlaybackCommand {
- SND_PLAYBACK_MIGRATE,
- SND_PLAYBACK_MODE,
- SND_PLAYBACK_CTRL,
- SND_PLAYBACK_PCM,
- SND_PLAYBACK_VOLUME,
- SND_PLAYBACK_LATENCY,
-};
-
-enum RecordCommand {
- SND_RECORD_MIGRATE,
- SND_RECORD_CTRL,
- SND_RECORD_VOLUME,
-};
-
-#define SND_PLAYBACK_MIGRATE_MASK (1 << SND_PLAYBACK_MIGRATE)
-#define SND_PLAYBACK_MODE_MASK (1 << SND_PLAYBACK_MODE)
-#define SND_PLAYBACK_CTRL_MASK (1 << SND_PLAYBACK_CTRL)
-#define SND_PLAYBACK_PCM_MASK (1 << SND_PLAYBACK_PCM)
-#define SND_PLAYBACK_VOLUME_MASK (1 << SND_PLAYBACK_VOLUME)
-#define SND_PLAYBACK_LATENCY_MASK ( 1 << SND_PLAYBACK_LATENCY)
-
-#define SND_RECORD_MIGRATE_MASK (1 << SND_RECORD_MIGRATE)
-#define SND_RECORD_CTRL_MASK (1 << SND_RECORD_CTRL)
-#define SND_RECORD_VOLUME_MASK (1 << SND_RECORD_VOLUME)
-
-typedef struct SndChannel SndChannel;
-typedef void (*snd_channel_send_messages_proc)(void *in_channel);
-typedef int (*snd_channel_handle_message_proc)(SndChannel *channel, size_t size, uint32_t type, void *message);
-typedef void (*snd_channel_on_message_done_proc)(SndChannel *channel);
-typedef void (*snd_channel_cleanup_channel_proc)(SndChannel *channel);
-
-typedef struct SndWorker SndWorker;
-
-struct SndChannel {
- RedsStream *stream;
- SndWorker *worker;
- spice_parse_channel_func_t parser;
- int refs;
-
- RedChannelClient *channel_client;
-
- int active;
- int client_active;
- int blocked;
-
- uint32_t command;
- uint32_t ack_generation;
- uint32_t client_ack_generation;
- uint32_t out_messages;
- uint32_t ack_messages;
-
- struct {
- uint64_t serial;
- SpiceMarshaller *marshaller;
- uint32_t size;
- uint32_t pos;
- } send_data;
-
- struct {
- uint8_t buf[SND_RECEIVE_BUF_SIZE];
- uint8_t *message_start;
- uint8_t *now;
- uint8_t *end;
- } receive_data;
-
- snd_channel_send_messages_proc send_messages;
- snd_channel_handle_message_proc handle_message;
- snd_channel_on_message_done_proc on_message_done;
- snd_channel_cleanup_channel_proc cleanup;
-};
-
-typedef struct PlaybackChannel PlaybackChannel;
-
-typedef struct AudioFrame AudioFrame;
-struct AudioFrame {
- uint32_t time;
- uint32_t samples[SND_CODEC_MAX_FRAME_SIZE];
- PlaybackChannel *channel;
- AudioFrame *next;
-};
-
-struct PlaybackChannel {
- SndChannel base;
- AudioFrame frames[3];
- AudioFrame *free_frames;
- AudioFrame *in_progress;
- AudioFrame *pending_frame;
- uint32_t mode;
- uint32_t latency;
- SndCodec codec;
- uint8_t encode_buf[SND_CODEC_MAX_COMPRESSED_BYTES];
-};
-
-struct SndWorker {
- RedChannel *base_channel;
- SndChannel *connection;
- SndWorker *next;
- int active;
-};
-
-typedef struct SpiceVolumeState {
- uint8_t volume_nchannels;
- uint16_t *volume;
- int mute;
-} SpiceVolumeState;
-
-struct SpicePlaybackState {
- struct SndWorker worker;
- SpicePlaybackInstance *sin;
- SpiceVolumeState volume;
- uint32_t frequency;
-};
-
-struct SpiceRecordState {
- struct SndWorker worker;
- SpiceRecordInstance *sin;
- SpiceVolumeState volume;
- uint32_t frequency;
-};
-
-typedef struct RecordChannel {
- SndChannel base;
- uint32_t samples[RECORD_SAMPLES_SIZE];
- uint32_t write_pos;
- uint32_t read_pos;
- uint32_t mode;
- uint32_t mode_time;
- uint32_t start_time;
- SndCodec codec;
- uint8_t decode_buf[SND_CODEC_MAX_FRAME_BYTES];
-} RecordChannel;
-
-static SndWorker *workers;
-static uint32_t playback_compression = TRUE;
-
-static void snd_receive(void* data);
-
-static SndChannel *snd_channel_get(SndChannel *channel)
-{
- channel->refs++;
- return channel;
-}
-
-static SndChannel *snd_channel_put(SndChannel *channel)
-{
- if (!--channel->refs) {
- spice_printerr("SndChannel=%p freed", channel);
- free(channel);
- return NULL;
- }
- return channel;
-}
-
-static void snd_disconnect_channel(SndChannel *channel)
-{
- SndWorker *worker;
-
- if (!channel || !channel->stream) {
- spice_debug("not connected");
- return;
- }
- spice_debug("SndChannel=%p rcc=%p type=%d",
- channel, channel->channel_client, channel->channel_client->channel->type);
- worker = channel->worker;
- channel->cleanup(channel);
- red_channel_client_disconnect(worker->connection->channel_client);
- worker->connection->channel_client = NULL;
- core->watch_remove(channel->stream->watch);
- channel->stream->watch = NULL;
- reds_stream_free(channel->stream);
- channel->stream = NULL;
- spice_marshaller_destroy(channel->send_data.marshaller);
- snd_channel_put(channel);
- worker->connection = NULL;
-}
-
-static void snd_playback_free_frame(PlaybackChannel *playback_channel, AudioFrame *frame)
-{
- frame->channel = playback_channel;
- frame->next = playback_channel->free_frames;
- playback_channel->free_frames = frame;
-}
-
-static void snd_playback_on_message_done(SndChannel *channel)
-{
- PlaybackChannel *playback_channel = (PlaybackChannel *)channel;
- if (playback_channel->in_progress) {
- snd_playback_free_frame(playback_channel, playback_channel->in_progress);
- playback_channel->in_progress = NULL;
- if (playback_channel->pending_frame) {
- channel->command |= SND_PLAYBACK_PCM_MASK;
- }
- }
-}
-
-static void snd_record_on_message_done(SndChannel *channel)
-{
-}
-
-static int snd_send_data(SndChannel *channel)
-{
- uint32_t n;
-
- if (!channel) {
- return FALSE;
- }
-
- if (!(n = channel->send_data.size - channel->send_data.pos)) {
- return TRUE;
- }
-
- for (;;) {
- struct iovec vec[IOV_MAX];
- int vec_size;
-
- if (!n) {
- channel->on_message_done(channel);
-
- if (channel->blocked) {
- channel->blocked = FALSE;
- core->watch_update_mask(channel->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);
- if (n == -1) {
- switch (errno) {
- case EAGAIN:
- channel->blocked = TRUE;
- core->watch_update_mask(channel->stream->watch, SPICE_WATCH_EVENT_READ |
- SPICE_WATCH_EVENT_WRITE);
- return FALSE;
- case EINTR:
- break;
- case EPIPE:
- snd_disconnect_channel(channel);
- return FALSE;
- default:
- spice_printerr("%s", strerror(errno));
- snd_disconnect_channel(channel);
- return FALSE;
- }
- } else {
- channel->send_data.pos += n;
- }
- n = channel->send_data.size - channel->send_data.pos;
- }
- return TRUE;
-}
-
-static int snd_record_handle_write(RecordChannel *record_channel, size_t size, void *message)
-{
- SpiceMsgcRecordPacket *packet;
- uint32_t write_pos;
- uint32_t* data;
- uint32_t len;
- uint32_t now;
-
- if (!record_channel) {
- return FALSE;
- }
-
- packet = (SpiceMsgcRecordPacket *)message;
-
- if (record_channel->mode == SPICE_AUDIO_DATA_MODE_RAW) {
- data = (uint32_t *)packet->data;
- size = packet->data_size >> 2;
- size = MIN(size, RECORD_SAMPLES_SIZE);
- } else {
- int decode_size;
- decode_size = sizeof(record_channel->decode_buf);
- if (snd_codec_decode(record_channel->codec, packet->data, packet->data_size,
- record_channel->decode_buf, &decode_size) != SND_CODEC_OK)
- return FALSE;
- data = (uint32_t *) record_channel->decode_buf;
- size = decode_size >> 2;
- }
-
- write_pos = record_channel->write_pos % RECORD_SAMPLES_SIZE;
- record_channel->write_pos += size;
- len = RECORD_SAMPLES_SIZE - write_pos;
- now = MIN(len, size);
- size -= now;
- memcpy(record_channel->samples + write_pos, data, now << 2);
-
- if (size) {
- memcpy(record_channel->samples, data + now, size << 2);
- }
-
- if (record_channel->write_pos - record_channel->read_pos > RECORD_SAMPLES_SIZE) {
- record_channel->read_pos = record_channel->write_pos - RECORD_SAMPLES_SIZE;
- }
- return TRUE;
-}
-
-static int snd_playback_handle_message(SndChannel *channel, size_t size, uint32_t type, void *message)
-{
- if (!channel) {
- return FALSE;
- }
-
- switch (type) {
- case SPICE_MSGC_DISCONNECTING:
- break;
- default:
- spice_printerr("invalid message type %u", type);
- return FALSE;
- }
- return TRUE;
-}
-
-static int snd_record_handle_message(SndChannel *channel, size_t size, uint32_t type, void *message)
-{
- RecordChannel *record_channel = (RecordChannel *)channel;
-
- if (!channel) {
- return FALSE;
- }
- switch (type) {
- case SPICE_MSGC_RECORD_DATA:
- return snd_record_handle_write((RecordChannel *)channel, size, message);
- case SPICE_MSGC_RECORD_MODE: {
- SpiceMsgcRecordMode *mode = (SpiceMsgcRecordMode *)message;
- SpiceRecordState *st = SPICE_CONTAINEROF(channel->worker, SpiceRecordState, worker);
- record_channel->mode_time = mode->time;
- if (mode->mode != SPICE_AUDIO_DATA_MODE_RAW) {
- if (snd_codec_is_capable(mode->mode, st->frequency)) {
- if (snd_codec_create(&record_channel->codec, mode->mode, st->frequency, SND_CODEC_DECODE) == SND_CODEC_OK) {
- record_channel->mode = mode->mode;
- } else {
- spice_printerr("create decoder failed");
- return FALSE;
- }
- }
- else {
- spice_printerr("unsupported mode %d", record_channel->mode);
- return FALSE;
- }
- }
- else
- record_channel->mode = mode->mode;
- break;
- }
-
- case SPICE_MSGC_RECORD_START_MARK: {
- SpiceMsgcRecordStartMark *mark = (SpiceMsgcRecordStartMark *)message;
- record_channel->start_time = mark->time;
- break;
- }
- case SPICE_MSGC_DISCONNECTING:
- break;
- default:
- spice_printerr("invalid message type %u", type);
- return FALSE;
- }
- return TRUE;
-}
-
-static void snd_receive(void* data)
-{
- SndChannel *channel = (SndChannel*)data;
- SpiceDataHeaderOpaque *header;
-
- if (!channel) {
- return;
- }
-
- header = &channel->channel_client->incoming.header;
-
- for (;;) {
- ssize_t n;
- n = channel->receive_data.end - channel->receive_data.now;
- spice_warn_if(n <= 0);
- n = reds_stream_read(channel->stream, channel->receive_data.now, n);
- if (n <= 0) {
- if (n == 0) {
- snd_disconnect_channel(channel);
- return;
- }
- spice_assert(n == -1);
- switch (errno) {
- case EAGAIN:
- return;
- case EINTR:
- break;
- case EPIPE:
- snd_disconnect_channel(channel);
- return;
- default:
- spice_printerr("%s", strerror(errno));
- snd_disconnect_channel(channel);
- return;
- }
- } else {
- channel->receive_data.now += n;
- for (;;) {
- uint8_t *msg_start = channel->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;
-
- 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),
- 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);
- return;
- }
- if (!channel->handle_message(channel, parsed_size,
- header->get_msg_type(header), parsed)) {
- free(parsed);
- snd_disconnect_channel(channel);
- return;
- }
- parsed_free(parsed);
- channel->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;
- }
- }
- }
-}
-
-static void snd_event(int fd, int event, void *data)
-{
- SndChannel *channel = data;
-
- if (event & SPICE_WATCH_EVENT_READ) {
- snd_receive(channel);
- }
- if (event & SPICE_WATCH_EVENT_WRITE) {
- channel->send_messages(channel);
- }
-}
-
-static inline int snd_reset_send_data(SndChannel *channel, uint16_t verb)
-{
- SpiceDataHeaderOpaque *header;
-
- if (!channel) {
- return FALSE;
- }
-
- header = &channel->channel_client->send_data.header;
- spice_marshaller_reset(channel->send_data.marshaller);
- header->data = spice_marshaller_reserve_space(channel->send_data.marshaller,
- header->header_size);
- spice_marshaller_set_base(channel->send_data.marshaller,
- header->header_size);
- channel->send_data.pos = 0;
- header->set_msg_size(header, 0);
- header->set_msg_type(header, verb);
- channel->send_data.serial++;
- if (!channel->channel_client->is_mini_header) {
- header->set_msg_serial(header, channel->send_data.serial);
- header->set_msg_sub_list(header, 0);
- }
-
- return TRUE;
-}
-
-static int snd_begin_send_message(SndChannel *channel)
-{
- SpiceDataHeaderOpaque *header = &channel->channel_client->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);
-}
-
-static int snd_channel_send_migrate(SndChannel *channel)
-{
- SpiceMsgMigrate migrate;
-
- if (!snd_reset_send_data(channel, SPICE_MSG_MIGRATE)) {
- return FALSE;
- }
- spice_debug(NULL);
- migrate.flags = 0;
- spice_marshall_msg_migrate(channel->send_data.marshaller, &migrate);
-
- return snd_begin_send_message(channel);
-}
-
-static int snd_playback_send_migrate(PlaybackChannel *channel)
-{
- return snd_channel_send_migrate(&channel->base);
-}
-
-static int snd_send_volume(SndChannel *channel, SpiceVolumeState *st, int msg)
-{
- SpiceMsgAudioVolume *vol;
- uint8_t c;
-
- vol = alloca(sizeof (SpiceMsgAudioVolume) +
- st->volume_nchannels * sizeof (uint16_t));
- if (!snd_reset_send_data(channel, 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);
-
- return snd_begin_send_message(channel);
-}
-
-static int snd_playback_send_volume(PlaybackChannel *playback_channel)
-{
- SndChannel *channel = &playback_channel->base;
- SpicePlaybackState *st = SPICE_CONTAINEROF(channel->worker, SpicePlaybackState, worker);
-
- if (!red_channel_client_test_remote_cap(channel->channel_client,
- SPICE_PLAYBACK_CAP_VOLUME)) {
- return TRUE;
- }
-
- return snd_send_volume(channel, &st->volume, SPICE_MSG_PLAYBACK_VOLUME);
-}
-
-static int snd_send_mute(SndChannel *channel, SpiceVolumeState *st, int msg)
-{
- SpiceMsgAudioMute mute;
-
- if (!snd_reset_send_data(channel, msg)) {
- return FALSE;
- }
- mute.mute = st->mute;
- spice_marshall_SpiceMsgAudioMute(channel->send_data.marshaller, &mute);
-
- return snd_begin_send_message(channel);
-}
-
-static int snd_playback_send_mute(PlaybackChannel *playback_channel)
-{
- SndChannel *channel = &playback_channel->base;
- SpicePlaybackState *st = SPICE_CONTAINEROF(channel->worker, SpicePlaybackState, worker);
-
- if (!red_channel_client_test_remote_cap(channel->channel_client,
- SPICE_PLAYBACK_CAP_VOLUME)) {
- return TRUE;
- }
-
- return snd_send_mute(channel, &st->volume, SPICE_MSG_PLAYBACK_MUTE);
-}
-
-static int snd_playback_send_latency(PlaybackChannel *playback_channel)
-{
- SndChannel *channel = &playback_channel->base;
- SpiceMsgPlaybackLatency latency_msg;
-
- spice_debug("latency %u", playback_channel->latency);
- if (!snd_reset_send_data(channel, SPICE_MSG_PLAYBACK_LATENCY)) {
- return FALSE;
- }
- latency_msg.latency_ms = playback_channel->latency;
- spice_marshall_msg_playback_latency(channel->send_data.marshaller, &latency_msg);
-
- return snd_begin_send_message(channel);
-}
-static int snd_playback_send_start(PlaybackChannel *playback_channel)
-{
- SndChannel *channel = (SndChannel *)playback_channel;
- SpicePlaybackState *st = SPICE_CONTAINEROF(channel->worker, SpicePlaybackState, worker);
- SpiceMsgPlaybackStart start;
-
- if (!snd_reset_send_data(channel, SPICE_MSG_PLAYBACK_START)) {
- return FALSE;
- }
-
- start.channels = SPICE_INTERFACE_PLAYBACK_CHAN;
- start.frequency = st->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);
-
- return snd_begin_send_message(channel);
-}
-
-static int snd_playback_send_stop(PlaybackChannel *playback_channel)
-{
- SndChannel *channel = (SndChannel *)playback_channel;
-
- if (!snd_reset_send_data(channel, SPICE_MSG_PLAYBACK_STOP)) {
- return FALSE;
- }
-
- return snd_begin_send_message(channel);
-}
-
-static int snd_playback_send_ctl(PlaybackChannel *playback_channel)
-{
- SndChannel *channel = (SndChannel *)playback_channel;
-
- if ((channel->client_active = channel->active)) {
- return snd_playback_send_start(playback_channel);
- } else {
- return snd_playback_send_stop(playback_channel);
- }
-}
-
-static int snd_record_send_start(RecordChannel *record_channel)
-{
- SndChannel *channel = (SndChannel *)record_channel;
- SpiceRecordState *st = SPICE_CONTAINEROF(channel->worker, SpiceRecordState, worker);
- SpiceMsgRecordStart start;
-
- if (!snd_reset_send_data(channel, SPICE_MSG_RECORD_START)) {
- return FALSE;
- }
-
- start.channels = SPICE_INTERFACE_RECORD_CHAN;
- start.frequency = st->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);
-
- return snd_begin_send_message(channel);
-}
-
-static int snd_record_send_stop(RecordChannel *record_channel)
-{
- SndChannel *channel = (SndChannel *)record_channel;
-
- if (!snd_reset_send_data(channel, SPICE_MSG_RECORD_STOP)) {
- return FALSE;
- }
-
- return snd_begin_send_message(channel);
-}
-
-static int snd_record_send_ctl(RecordChannel *record_channel)
-{
- SndChannel *channel = (SndChannel *)record_channel;
-
- if ((channel->client_active = channel->active)) {
- return snd_record_send_start(record_channel);
- } else {
- return snd_record_send_stop(record_channel);
- }
-}
-
-static int snd_record_send_volume(RecordChannel *record_channel)
-{
- SndChannel *channel = &record_channel->base;
- SpiceRecordState *st = SPICE_CONTAINEROF(channel->worker, SpiceRecordState, worker);
-
- if (!red_channel_client_test_remote_cap(channel->channel_client,
- SPICE_RECORD_CAP_VOLUME)) {
- return TRUE;
- }
-
- return snd_send_volume(channel, &st->volume, SPICE_MSG_RECORD_VOLUME);
-}
-
-static int snd_record_send_mute(RecordChannel *record_channel)
-{
- SndChannel *channel = &record_channel->base;
- SpiceRecordState *st = SPICE_CONTAINEROF(channel->worker, SpiceRecordState, worker);
-
- if (!red_channel_client_test_remote_cap(channel->channel_client,
- SPICE_RECORD_CAP_VOLUME)) {
- return TRUE;
- }
-
- return snd_send_mute(channel, &st->volume, SPICE_MSG_RECORD_MUTE);
-}
-
-static int snd_record_send_migrate(RecordChannel *record_channel)
-{
- /* No need for migration data: if recording has started before migration,
- * the client receives RECORD_STOP from the src before the migration completion
- * notification (when the vm is stopped).
- * Afterwards, when the vm starts on the dest, the client receives RECORD_START. */
- return snd_channel_send_migrate(&record_channel->base);
-}
-
-static int snd_playback_send_write(PlaybackChannel *playback_channel)
-{
- SndChannel *channel = (SndChannel *)playback_channel;
- AudioFrame *frame;
- SpiceMsgPlaybackPacket msg;
-
- if (!snd_reset_send_data(channel, SPICE_MSG_PLAYBACK_DATA)) {
- return FALSE;
- }
-
- frame = playback_channel->in_progress;
- msg.time = frame->time;
-
- spice_marshall_msg_playback_data(channel->send_data.marshaller, &msg);
-
- if (playback_channel->mode == SPICE_AUDIO_DATA_MODE_RAW) {
- spice_marshaller_add_ref(channel->send_data.marshaller,
- (uint8_t *)frame->samples,
- snd_codec_frame_size(playback_channel->codec) * sizeof(frame->samples[0]));
- }
- else {
- int n = sizeof(playback_channel->encode_buf);
- if (snd_codec_encode(playback_channel->codec, (uint8_t *) frame->samples,
- snd_codec_frame_size(playback_channel->codec) * sizeof(frame->samples[0]),
- playback_channel->encode_buf, &n) != SND_CODEC_OK) {
- spice_printerr("encode failed");
- snd_disconnect_channel(channel);
- return FALSE;
- }
- spice_marshaller_add_ref(channel->send_data.marshaller, playback_channel->encode_buf, n);
- }
-
- return snd_begin_send_message(channel);
-}
-
-static int playback_send_mode(PlaybackChannel *playback_channel)
-{
- SndChannel *channel = (SndChannel *)playback_channel;
- SpiceMsgPlaybackMode mode;
-
- if (!snd_reset_send_data(channel, SPICE_MSG_PLAYBACK_MODE)) {
- return FALSE;
- }
- mode.time = reds_get_mm_time();
- mode.mode = playback_channel->mode;
- spice_marshall_msg_playback_mode(channel->send_data.marshaller, &mode);
-
- return snd_begin_send_message(channel);
-}
-
-static void snd_playback_send(void* data)
-{
- PlaybackChannel *playback_channel = (PlaybackChannel*)data;
- SndChannel *channel = (SndChannel*)playback_channel;
-
- if (!playback_channel || !snd_send_data(data)) {
- return;
- }
-
- while (channel->command) {
- if (channel->command & SND_PLAYBACK_MODE_MASK) {
- if (!playback_send_mode(playback_channel)) {
- return;
- }
- channel->command &= ~SND_PLAYBACK_MODE_MASK;
- }
- if (channel->command & SND_PLAYBACK_PCM_MASK) {
- spice_assert(!playback_channel->in_progress && playback_channel->pending_frame);
- playback_channel->in_progress = playback_channel->pending_frame;
- playback_channel->pending_frame = NULL;
- channel->command &= ~SND_PLAYBACK_PCM_MASK;
- if (!snd_playback_send_write(playback_channel)) {
- spice_printerr("snd_send_playback_write failed");
- return;
- }
- }
- if (channel->command & SND_PLAYBACK_CTRL_MASK) {
- if (!snd_playback_send_ctl(playback_channel)) {
- return;
- }
- channel->command &= ~SND_PLAYBACK_CTRL_MASK;
- }
- if (channel->command & SND_PLAYBACK_VOLUME_MASK) {
- if (!snd_playback_send_volume(playback_channel) ||
- !snd_playback_send_mute(playback_channel)) {
- return;
- }
- channel->command &= ~SND_PLAYBACK_VOLUME_MASK;
- }
- if (channel->command & SND_PLAYBACK_MIGRATE_MASK) {
- if (!snd_playback_send_migrate(playback_channel)) {
- return;
- }
- channel->command &= ~SND_PLAYBACK_MIGRATE_MASK;
- }
- if (channel->command & SND_PLAYBACK_LATENCY_MASK) {
- if (!snd_playback_send_latency(playback_channel)) {
- return;
- }
- channel->command &= ~SND_PLAYBACK_LATENCY_MASK;
- }
- }
-}
-
-static void snd_record_send(void* data)
-{
- RecordChannel *record_channel = (RecordChannel*)data;
- SndChannel *channel = (SndChannel*)record_channel;
-
- if (!record_channel || !snd_send_data(data)) {
- return;
- }
-
- while (channel->command) {
- if (channel->command & SND_RECORD_CTRL_MASK) {
- if (!snd_record_send_ctl(record_channel)) {
- return;
- }
- channel->command &= ~SND_RECORD_CTRL_MASK;
- }
- if (channel->command & SND_RECORD_VOLUME_MASK) {
- if (!snd_record_send_volume(record_channel) ||
- !snd_record_send_mute(record_channel)) {
- return;
- }
- channel->command &= ~SND_RECORD_VOLUME_MASK;
- }
- if (channel->command & SND_RECORD_MIGRATE_MASK) {
- if (!snd_record_send_migrate(record_channel)) {
- return;
- }
- channel->command &= ~SND_RECORD_MIGRATE_MASK;
- }
- }
-}
-
-static SndChannel *__new_channel(SndWorker *worker, int size, uint32_t channel_id,
- RedClient *client,
- RedsStream *stream,
- int migrate,
- snd_channel_send_messages_proc send_messages,
- snd_channel_handle_message_proc handle_message,
- snd_channel_on_message_done_proc on_message_done,
- snd_channel_cleanup_channel_proc cleanup,
- uint32_t *common_caps, int num_common_caps,
- uint32_t *caps, int num_caps)
-{
- SndChannel *channel;
- int delay_val;
- int flags;
-#ifdef SO_PRIORITY
- int priority;
-#endif
- int tos;
- MainChannelClient *mcc = red_client_get_main(client);
-
- spice_assert(stream);
- if ((flags = fcntl(stream->socket, F_GETFL)) == -1) {
- spice_printerr("accept failed, %s", strerror(errno));
- goto error1;
- }
-
-#ifdef SO_PRIORITY
- priority = 6;
- if (setsockopt(stream->socket, SOL_SOCKET, SO_PRIORITY, (void*)&priority,
- sizeof(priority)) == -1) {
- if (errno != ENOTSUP) {
- spice_printerr("setsockopt failed, %s", strerror(errno));
- }
- }
-#endif
-
- tos = IPTOS_LOWDELAY;
- if (setsockopt(stream->socket, IPPROTO_IP, IP_TOS, (void*)&tos, sizeof(tos)) == -1) {
- if (errno != ENOTSUP) {
- spice_printerr("setsockopt failed, %s", strerror(errno));
- }
- }
-
- delay_val = main_channel_client_is_low_bandwidth(mcc) ? 0 : 1;
- if (setsockopt(stream->socket, IPPROTO_TCP, TCP_NODELAY, &delay_val, sizeof(delay_val)) == -1) {
- if (errno != ENOTSUP) {
- spice_printerr("setsockopt failed, %s", strerror(errno));
- }
- }
-
- if (fcntl(stream->socket, F_SETFL, flags | O_NONBLOCK) == -1) {
- spice_printerr("accept failed, %s", strerror(errno));
- 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();
-
- stream->watch = core->watch_add(stream->socket, SPICE_WATCH_EVENT_READ,
- snd_event, channel);
- 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;
-
- channel->channel_client = red_channel_client_create_dummy(sizeof(RedChannelClient),
- worker->base_channel,
- client,
- num_common_caps, common_caps,
- num_caps, caps);
- if (!channel->channel_client) {
- goto error2;
- }
- return channel;
-
-error2:
- free(channel);
-
-error1:
- reds_stream_free(stream);
- return NULL;
-}
-
-static void snd_disconnect_channel_client(RedChannelClient *rcc)
-{
- SndWorker *worker;
-
- spice_assert(rcc->channel);
- spice_assert(rcc->channel->data);
- worker = (SndWorker *)rcc->channel->data;
-
- spice_debug("channel-type=%d", rcc->channel->type);
- if (worker->connection) {
- spice_assert(worker->connection->channel_client == rcc);
- snd_disconnect_channel(worker->connection);
- }
-}
-
-static void snd_set_command(SndChannel *channel, uint32_t command)
-{
- if (!channel) {
- return;
- }
- channel->command |= command;
-}
-
-SPICE_GNUC_VISIBLE void spice_server_playback_set_volume(SpicePlaybackInstance *sin,
- uint8_t nchannels,
- uint16_t *volume)
-{
- SpiceVolumeState *st = &sin->st->volume;
- SndChannel *channel = sin->st->worker.connection;
- PlaybackChannel *playback_channel = SPICE_CONTAINEROF(channel, PlaybackChannel, base);
-
- st->volume_nchannels = nchannels;
- free(st->volume);
- st->volume = spice_memdup(volume, sizeof(uint16_t) * nchannels);
-
- if (!channel || nchannels == 0)
- return;
-
- snd_playback_send_volume(playback_channel);
-}
-
-SPICE_GNUC_VISIBLE void spice_server_playback_set_mute(SpicePlaybackInstance *sin, uint8_t mute)
-{
- SpiceVolumeState *st = &sin->st->volume;
- SndChannel *channel = sin->st->worker.connection;
- PlaybackChannel *playback_channel = SPICE_CONTAINEROF(channel, PlaybackChannel, base);
-
- st->mute = mute;
-
- if (!channel)
- return;
-
- snd_playback_send_mute(playback_channel);
-}
-
-SPICE_GNUC_VISIBLE void spice_server_playback_start(SpicePlaybackInstance *sin)
-{
- SndChannel *channel = sin->st->worker.connection;
- PlaybackChannel *playback_channel = SPICE_CONTAINEROF(channel, PlaybackChannel, base);
-
- sin->st->worker.active = 1;
- if (!channel)
- return;
- spice_assert(!playback_channel->base.active);
- reds_disable_mm_time();
- playback_channel->base.active = TRUE;
- if (!playback_channel->base.client_active) {
- snd_set_command(&playback_channel->base, SND_PLAYBACK_CTRL_MASK);
- snd_playback_send(&playback_channel->base);
- } else {
- playback_channel->base.command &= ~SND_PLAYBACK_CTRL_MASK;
- }
-}
-
-SPICE_GNUC_VISIBLE void spice_server_playback_stop(SpicePlaybackInstance *sin)
-{
- SndChannel *channel = sin->st->worker.connection;
- PlaybackChannel *playback_channel = SPICE_CONTAINEROF(channel, PlaybackChannel, base);
-
- sin->st->worker.active = 0;
- if (!channel)
- return;
- spice_assert(playback_channel->base.active);
- reds_enable_mm_time();
- playback_channel->base.active = FALSE;
- if (playback_channel->base.client_active) {
- snd_set_command(&playback_channel->base, SND_PLAYBACK_CTRL_MASK);
- snd_playback_send(&playback_channel->base);
- } else {
- playback_channel->base.command &= ~SND_PLAYBACK_CTRL_MASK;
- playback_channel->base.command &= ~SND_PLAYBACK_PCM_MASK;
-
- if (playback_channel->pending_frame) {
- spice_assert(!playback_channel->in_progress);
- snd_playback_free_frame(playback_channel,
- playback_channel->pending_frame);
- playback_channel->pending_frame = NULL;
- }
- }
-}
-
-SPICE_GNUC_VISIBLE void spice_server_playback_get_buffer(SpicePlaybackInstance *sin,
- uint32_t **frame, uint32_t *num_samples)
-{
- SndChannel *channel = sin->st->worker.connection;
- PlaybackChannel *playback_channel = SPICE_CONTAINEROF(channel, PlaybackChannel, base);
-
- if (!channel || !playback_channel->free_frames) {
- *frame = NULL;
- *num_samples = 0;
- return;
- }
- spice_assert(playback_channel->base.active);
- snd_channel_get(channel);
-
- *frame = playback_channel->free_frames->samples;
- playback_channel->free_frames = playback_channel->free_frames->next;
- *num_samples = snd_codec_frame_size(playback_channel->codec);
-}
-
-SPICE_GNUC_VISIBLE void spice_server_playback_put_samples(SpicePlaybackInstance *sin, uint32_t *samples)
-{
- PlaybackChannel *playback_channel;
- AudioFrame *frame;
-
- frame = SPICE_CONTAINEROF(samples, AudioFrame, samples);
- playback_channel = frame->channel;
- spice_assert(playback_channel);
- if (!snd_channel_put(&playback_channel->base) ||
- sin->st->worker.connection != &playback_channel->base) {
- /* lost last reference, channel has been destroyed previously */
- spice_info("audio samples belong to a disconnected channel");
- return;
- }
- spice_assert(playback_channel->base.active);
-
- if (playback_channel->pending_frame) {
- snd_playback_free_frame(playback_channel, playback_channel->pending_frame);
- }
- frame->time = reds_get_mm_time();
- playback_channel->pending_frame = frame;
- snd_set_command(&playback_channel->base, SND_PLAYBACK_PCM_MASK);
- snd_playback_send(&playback_channel->base);
-}
-
-void snd_set_playback_latency(RedClient *client, uint32_t latency)
-{
- SndWorker *now = workers;
-
- for (; now; now = now->next) {
- if (now->base_channel->type == SPICE_CHANNEL_PLAYBACK && now->connection &&
- now->connection->channel_client->client == client) {
-
- if (red_channel_client_test_remote_cap(now->connection->channel_client,
- SPICE_PLAYBACK_CAP_LATENCY)) {
- PlaybackChannel* playback = (PlaybackChannel*)now->connection;
-
- playback->latency = latency;
- snd_set_command(now->connection, SND_PLAYBACK_LATENCY_MASK);
- snd_playback_send(now->connection);
- } else {
- spice_debug("client doesn't not support SPICE_PLAYBACK_CAP_LATENCY");
- }
- }
- }
-}
-
-static int snd_desired_audio_mode(int frequency, int client_can_celt, int client_can_opus)
-{
- if (! playback_compression)
- return SPICE_AUDIO_DATA_MODE_RAW;
-
- if (client_can_opus && snd_codec_is_capable(SPICE_AUDIO_DATA_MODE_OPUS, frequency))
- return SPICE_AUDIO_DATA_MODE_OPUS;
-
- if (client_can_celt && snd_codec_is_capable(SPICE_AUDIO_DATA_MODE_CELT_0_5_1, frequency))
- return SPICE_AUDIO_DATA_MODE_CELT_0_5_1;
-
- return SPICE_AUDIO_DATA_MODE_RAW;
-}
-
-static void on_new_playback_channel(SndWorker *worker)
-{
- PlaybackChannel *playback_channel =
- SPICE_CONTAINEROF(worker->connection, PlaybackChannel, base);
- SpicePlaybackState *st = SPICE_CONTAINEROF(worker, SpicePlaybackState, worker);
-
- spice_assert(playback_channel);
-
- snd_set_command((SndChannel *)playback_channel, SND_PLAYBACK_MODE_MASK);
- if (playback_channel->base.active) {
- snd_set_command((SndChannel *)playback_channel, SND_PLAYBACK_CTRL_MASK);
- }
- if (st->volume.volume_nchannels) {
- snd_set_command((SndChannel *)playback_channel, SND_PLAYBACK_VOLUME_MASK);
- }
- if (playback_channel->base.active) {
- reds_disable_mm_time();
- }
-}
-
-static void snd_playback_cleanup(SndChannel *channel)
-{
- PlaybackChannel *playback_channel = SPICE_CONTAINEROF(channel, PlaybackChannel, base);
-
- if (playback_channel->base.active) {
- reds_enable_mm_time();
- }
-
- snd_codec_destroy(&playback_channel->codec);
-}
-
-static void snd_set_playback_peer(RedChannel *channel, RedClient *client, RedsStream *stream,
- int migration, int num_common_caps, uint32_t *common_caps,
- int num_caps, uint32_t *caps)
-{
- SndWorker *worker = channel->data;
- PlaybackChannel *playback_channel;
- SpicePlaybackState *st = SPICE_CONTAINEROF(worker, SpicePlaybackState, worker);
-
- snd_disconnect_channel(worker->connection);
-
- if (!(playback_channel = (PlaybackChannel *)__new_channel(worker,
- sizeof(*playback_channel),
- SPICE_CHANNEL_PLAYBACK,
- client,
- stream,
- migration,
- snd_playback_send,
- snd_playback_handle_message,
- snd_playback_on_message_done,
- snd_playback_cleanup,
- common_caps, num_common_caps,
- caps, num_caps))) {
- return;
- }
- worker->connection = &playback_channel->base;
- snd_playback_free_frame(playback_channel, &playback_channel->frames[0]);
- snd_playback_free_frame(playback_channel, &playback_channel->frames[1]);
- snd_playback_free_frame(playback_channel, &playback_channel->frames[2]);
-
- int client_can_celt = red_channel_client_test_remote_cap(playback_channel->base.channel_client,
- SPICE_PLAYBACK_CAP_CELT_0_5_1);
- int client_can_opus = red_channel_client_test_remote_cap(playback_channel->base.channel_client,
- SPICE_PLAYBACK_CAP_OPUS);
- int desired_mode = snd_desired_audio_mode(st->frequency, client_can_celt, client_can_opus);
- playback_channel->mode = SPICE_AUDIO_DATA_MODE_RAW;
- if (desired_mode != SPICE_AUDIO_DATA_MODE_RAW) {
- if (snd_codec_create(&playback_channel->codec, desired_mode, st->frequency, SND_CODEC_ENCODE) == SND_CODEC_OK) {
- playback_channel->mode = desired_mode;
- } else {
- spice_printerr("create encoder failed");
- }
- }
-
- if (!red_client_during_migrate_at_target(client)) {
- on_new_playback_channel(worker);
- }
-
- if (worker->active) {
- spice_server_playback_start(st->sin);
- }
- snd_playback_send(worker->connection);
-}
-
-static void snd_record_migrate_channel_client(RedChannelClient *rcc)
-{
- SndWorker *worker;
-
- spice_debug(NULL);
- spice_assert(rcc->channel);
- spice_assert(rcc->channel->data);
- worker = (SndWorker *)rcc->channel->data;
-
- if (worker->connection) {
- spice_assert(worker->connection->channel_client == rcc);
- snd_set_command(worker->connection, SND_RECORD_MIGRATE_MASK);
- snd_record_send(worker->connection);
- }
-}
-
-SPICE_GNUC_VISIBLE void spice_server_record_set_volume(SpiceRecordInstance *sin,
- uint8_t nchannels,
- uint16_t *volume)
-{
- SpiceVolumeState *st = &sin->st->volume;
- SndChannel *channel = sin->st->worker.connection;
- RecordChannel *record_channel = SPICE_CONTAINEROF(channel, RecordChannel, base);
-
- st->volume_nchannels = nchannels;
- free(st->volume);
- st->volume = spice_memdup(volume, sizeof(uint16_t) * nchannels);
-
- if (!channel || nchannels == 0)
- return;
-
- snd_record_send_volume(record_channel);
-}
-
-SPICE_GNUC_VISIBLE void spice_server_record_set_mute(SpiceRecordInstance *sin, uint8_t mute)
-{
- SpiceVolumeState *st = &sin->st->volume;
- SndChannel *channel = sin->st->worker.connection;
- RecordChannel *record_channel = SPICE_CONTAINEROF(channel, RecordChannel, base);
-
- st->mute = mute;
-
- if (!channel)
- return;
-
- snd_record_send_mute(record_channel);
-}
-
-SPICE_GNUC_VISIBLE void spice_server_record_start(SpiceRecordInstance *sin)
-{
- SndChannel *channel = sin->st->worker.connection;
- RecordChannel *record_channel = SPICE_CONTAINEROF(channel, RecordChannel, base);
-
- sin->st->worker.active = 1;
- if (!channel)
- return;
- spice_assert(!record_channel->base.active);
- record_channel->base.active = TRUE;
- record_channel->read_pos = record_channel->write_pos = 0; //todo: improve by
- //stream generation
- if (!record_channel->base.client_active) {
- snd_set_command(&record_channel->base, SND_RECORD_CTRL_MASK);
- snd_record_send(&record_channel->base);
- } else {
- record_channel->base.command &= ~SND_RECORD_CTRL_MASK;
- }
-}
-
-SPICE_GNUC_VISIBLE void spice_server_record_stop(SpiceRecordInstance *sin)
-{
- SndChannel *channel = sin->st->worker.connection;
- RecordChannel *record_channel = SPICE_CONTAINEROF(channel, RecordChannel, base);
-
- sin->st->worker.active = 0;
- if (!channel)
- return;
- spice_assert(record_channel->base.active);
- record_channel->base.active = FALSE;
- if (record_channel->base.client_active) {
- snd_set_command(&record_channel->base, SND_RECORD_CTRL_MASK);
- snd_record_send(&record_channel->base);
- } else {
- record_channel->base.command &= ~SND_RECORD_CTRL_MASK;
- }
-}
-
-SPICE_GNUC_VISIBLE uint32_t spice_server_record_get_samples(SpiceRecordInstance *sin,
- uint32_t *samples, uint32_t bufsize)
-{
- SndChannel *channel = sin->st->worker.connection;
- RecordChannel *record_channel = SPICE_CONTAINEROF(channel, RecordChannel, base);
- uint32_t read_pos;
- uint32_t now;
- uint32_t len;
-
- if (!channel)
- return 0;
- spice_assert(record_channel->base.active);
-
- if (record_channel->write_pos < RECORD_SAMPLES_SIZE / 2) {
- return 0;
- }
-
- len = MIN(record_channel->write_pos - record_channel->read_pos, bufsize);
-
- if (len < bufsize) {
- SndWorker *worker = record_channel->base.worker;
- snd_receive(record_channel);
- if (!worker->connection) {
- return 0;
- }
- len = MIN(record_channel->write_pos - record_channel->read_pos, bufsize);
- }
-
- read_pos = record_channel->read_pos % RECORD_SAMPLES_SIZE;
- record_channel->read_pos += len;
- now = MIN(len, RECORD_SAMPLES_SIZE - read_pos);
- memcpy(samples, &record_channel->samples[read_pos], now * 4);
- if (now < len) {
- memcpy(samples + now, record_channel->samples, (len - now) * 4);
- }
- return len;
-}
-
-SPICE_GNUC_VISIBLE uint32_t spice_server_get_best_playback_rate(SpicePlaybackInstance *sin)
-{
- int client_can_opus = TRUE;
- if (sin && sin->st->worker.connection) {
- SndChannel *channel = sin->st->worker.connection;
- PlaybackChannel *playback_channel = SPICE_CONTAINEROF(channel, PlaybackChannel, base);
- client_can_opus = red_channel_client_test_remote_cap(playback_channel->base.channel_client,
- SPICE_PLAYBACK_CAP_OPUS);
- }
-
- if (client_can_opus && snd_codec_is_capable(SPICE_AUDIO_DATA_MODE_OPUS, SND_CODEC_ANY_FREQUENCY))
- return SND_CODEC_OPUS_PLAYBACK_FREQ;
-
- return SND_CODEC_CELT_PLAYBACK_FREQ;
-}
-
-SPICE_GNUC_VISIBLE void spice_server_set_playback_rate(SpicePlaybackInstance *sin, uint32_t frequency)
-{
- RedChannel *channel = sin->st->worker.base_channel;
- sin->st->frequency = frequency;
- if (channel && snd_codec_is_capable(SPICE_AUDIO_DATA_MODE_OPUS, frequency))
- red_channel_set_cap(channel, SPICE_PLAYBACK_CAP_OPUS);
-}
-
-SPICE_GNUC_VISIBLE uint32_t spice_server_get_best_record_rate(SpiceRecordInstance *sin)
-{
- int client_can_opus = TRUE;
- if (sin && sin->st->worker.connection) {
- SndChannel *channel = sin->st->worker.connection;
- RecordChannel *record_channel = SPICE_CONTAINEROF(channel, RecordChannel, base);
- client_can_opus = red_channel_client_test_remote_cap(record_channel->base.channel_client,
- SPICE_RECORD_CAP_OPUS);
- }
-
- if (client_can_opus && snd_codec_is_capable(SPICE_AUDIO_DATA_MODE_OPUS, SND_CODEC_ANY_FREQUENCY))
- return SND_CODEC_OPUS_PLAYBACK_FREQ;
-
- return SND_CODEC_CELT_PLAYBACK_FREQ;
-}
-
-SPICE_GNUC_VISIBLE void spice_server_set_record_rate(SpiceRecordInstance *sin, uint32_t frequency)
-{
- RedChannel *channel = sin->st->worker.base_channel;
- sin->st->frequency = frequency;
- if (channel && snd_codec_is_capable(SPICE_AUDIO_DATA_MODE_OPUS, frequency))
- red_channel_set_cap(channel, SPICE_RECORD_CAP_OPUS);
-}
-
-static void on_new_record_channel(SndWorker *worker)
-{
- RecordChannel *record_channel = (RecordChannel *)worker->connection;
- SpiceRecordState *st = SPICE_CONTAINEROF(worker, SpiceRecordState, worker);
-
- spice_assert(record_channel);
-
- if (st->volume.volume_nchannels) {
- snd_set_command((SndChannel *)record_channel, SND_RECORD_VOLUME_MASK);
- }
- if (record_channel->base.active) {
- snd_set_command((SndChannel *)record_channel, SND_RECORD_CTRL_MASK);
- }
-}
-
-static void snd_record_cleanup(SndChannel *channel)
-{
- RecordChannel *record_channel = SPICE_CONTAINEROF(channel, RecordChannel, base);
- snd_codec_destroy(&record_channel->codec);
-}
-
-static void snd_set_record_peer(RedChannel *channel, RedClient *client, RedsStream *stream,
- int migration, int num_common_caps, uint32_t *common_caps,
- int num_caps, uint32_t *caps)
-{
- SndWorker *worker = channel->data;
- RecordChannel *record_channel;
- SpiceRecordState *st = SPICE_CONTAINEROF(worker, SpiceRecordState, worker);
-
- snd_disconnect_channel(worker->connection);
-
- if (!(record_channel = (RecordChannel *)__new_channel(worker,
- sizeof(*record_channel),
- SPICE_CHANNEL_RECORD,
- client,
- stream,
- migration,
- snd_record_send,
- snd_record_handle_message,
- snd_record_on_message_done,
- snd_record_cleanup,
- common_caps, num_common_caps,
- caps, num_caps))) {
- return;
- }
-
- record_channel->mode = SPICE_AUDIO_DATA_MODE_RAW;
-
- worker->connection = &record_channel->base;
-
- on_new_record_channel(worker);
- if (worker->active) {
- spice_server_record_start(st->sin);
- }
- snd_record_send(worker->connection);
-}
-
-static void snd_playback_migrate_channel_client(RedChannelClient *rcc)
-{
- SndWorker *worker;
-
- spice_assert(rcc->channel);
- spice_assert(rcc->channel->data);
- worker = (SndWorker *)rcc->channel->data;
- spice_debug(NULL);
-
- if (worker->connection) {
- spice_assert(worker->connection->channel_client == rcc);
- snd_set_command(worker->connection, SND_PLAYBACK_MIGRATE_MASK);
- snd_playback_send(worker->connection);
- }
-}
-
-static void add_worker(SndWorker *worker)
-{
- worker->next = workers;
- workers = worker;
-}
-
-static void remove_worker(SndWorker *worker)
-{
- SndWorker **now = &workers;
- while (*now) {
- if (*now == worker) {
- *now = worker->next;
- return;
- }
- now = &(*now)->next;
- }
- spice_printerr("not found");
-}
-
-void snd_attach_playback(SpicePlaybackInstance *sin)
-{
- SndWorker *playback_worker;
- RedChannel *channel;
- ClientCbs client_cbs = { NULL, };
-
- sin->st = spice_new0(SpicePlaybackState, 1);
- sin->st->sin = sin;
- playback_worker = &sin->st->worker;
- sin->st->frequency = SND_CODEC_CELT_PLAYBACK_FREQ; /* Default to the legacy rate */
-
- // TODO: Make RedChannel base of worker? instead of assigning it to channel->data
- channel = red_channel_create_dummy(sizeof(RedChannel), SPICE_CHANNEL_PLAYBACK, 0);
-
- channel->data = playback_worker;
- client_cbs.connect = snd_set_playback_peer;
- client_cbs.disconnect = snd_disconnect_channel_client;
- client_cbs.migrate = snd_playback_migrate_channel_client;
- red_channel_register_client_cbs(channel, &client_cbs);
- red_channel_set_data(channel, playback_worker);
-
- if (snd_codec_is_capable(SPICE_AUDIO_DATA_MODE_CELT_0_5_1, SND_CODEC_ANY_FREQUENCY))
- red_channel_set_cap(channel, SPICE_PLAYBACK_CAP_CELT_0_5_1);
-
- red_channel_set_cap(channel, SPICE_PLAYBACK_CAP_VOLUME);
-
- playback_worker->base_channel = channel;
- add_worker(playback_worker);
- reds_register_channel(playback_worker->base_channel);
-}
-
-void snd_attach_record(SpiceRecordInstance *sin)
-{
- SndWorker *record_worker;
- RedChannel *channel;
- ClientCbs client_cbs = { NULL, };
-
- sin->st = spice_new0(SpiceRecordState, 1);
- sin->st->sin = sin;
- record_worker = &sin->st->worker;
- sin->st->frequency = SND_CODEC_CELT_PLAYBACK_FREQ; /* Default to the legacy rate */
-
- // TODO: Make RedChannel base of worker? instead of assigning it to channel->data
- channel = red_channel_create_dummy(sizeof(RedChannel), SPICE_CHANNEL_RECORD, 0);
-
- channel->data = record_worker;
- client_cbs.connect = snd_set_record_peer;
- client_cbs.disconnect = snd_disconnect_channel_client;
- client_cbs.migrate = snd_record_migrate_channel_client;
- red_channel_register_client_cbs(channel, &client_cbs);
- red_channel_set_data(channel, record_worker);
- if (snd_codec_is_capable(SPICE_AUDIO_DATA_MODE_CELT_0_5_1, SND_CODEC_ANY_FREQUENCY))
- red_channel_set_cap(channel, SPICE_RECORD_CAP_CELT_0_5_1);
- red_channel_set_cap(channel, SPICE_RECORD_CAP_VOLUME);
-
- record_worker->base_channel = channel;
- add_worker(record_worker);
- reds_register_channel(record_worker->base_channel);
-}
-
-static void snd_detach_common(SndWorker *worker)
-{
- if (!worker) {
- return;
- }
- remove_worker(worker);
- snd_disconnect_channel(worker->connection);
- reds_unregister_channel(worker->base_channel);
- red_channel_destroy(worker->base_channel);
-}
-
-static void spice_playback_state_free(SpicePlaybackState *st)
-{
- free(st->volume.volume);
- free(st);
-}
-
-void snd_detach_playback(SpicePlaybackInstance *sin)
-{
- snd_detach_common(&sin->st->worker);
- spice_playback_state_free(sin->st);
-}
-
-static void spice_record_state_free(SpiceRecordState *st)
-{
- free(st->volume.volume);
- free(st);
-}
-
-void snd_detach_record(SpiceRecordInstance *sin)
-{
- snd_detach_common(&sin->st->worker);
- spice_record_state_free(sin->st);
-}
-
-void snd_set_playback_compression(int on)
-{
- SndWorker *now = workers;
-
- playback_compression = !!on;
-
- for (; now; now = now->next) {
- if (now->base_channel->type == SPICE_CHANNEL_PLAYBACK && now->connection) {
- PlaybackChannel* playback = (PlaybackChannel*)now->connection;
- SpicePlaybackState *st = SPICE_CONTAINEROF(now, SpicePlaybackState, worker);
- int client_can_celt = red_channel_client_test_remote_cap(playback->base.channel_client,
- SPICE_PLAYBACK_CAP_CELT_0_5_1);
- int client_can_opus = red_channel_client_test_remote_cap(playback->base.channel_client,
- SPICE_PLAYBACK_CAP_OPUS);
- int desired_mode = snd_desired_audio_mode(st->frequency, client_can_opus, client_can_celt);
- if (playback->mode != desired_mode) {
- playback->mode = desired_mode;
- snd_set_command(now->connection, SND_PLAYBACK_MODE_MASK);
- }
- }
- }
-}
diff --git a/server/snd_worker.h b/server/snd_worker.h
deleted file mode 100644
index 7cc4db5..0000000
--- a/server/snd_worker.h
+++ /dev/null
@@ -1,33 +0,0 @@
-/*
- Copyright (C) 2009 Red Hat, Inc.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, see <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _H_SND_WORKER
-#define _H_SND_WORKER
-
-#include "spice.h"
-
-void snd_attach_playback(SpicePlaybackInstance *sin);
-void snd_detach_playback(SpicePlaybackInstance *sin);
-
-void snd_attach_record(SpiceRecordInstance *sin);
-void snd_detach_record(SpiceRecordInstance *sin);
-
-void snd_set_playback_compression(int on);
-
-void snd_set_playback_latency(RedClient *client, uint32_t latency);
-
-#endif
diff --git a/server/sound.c b/server/sound.c
new file mode 100644
index 0000000..a91d56e
--- /dev/null
+++ b/server/sound.c
@@ -0,0 +1,1625 @@
+/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ Copyright (C) 2009 Red Hat, Inc.
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, see <http://www.gnu.org/licenses/>.
+*/
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <fcntl.h>
+#include <errno.h>
+#include <limits.h>
+#include <sys/socket.h>
+#include <netinet/ip.h>
+#include <netinet/tcp.h>
+
+#include "common/marshaller.h"
+#include "common/generated_server_marshallers.h"
+
+#include "spice.h"
+#include "red_common.h"
+#include "main-channel.h"
+#include "reds.h"
+#include "red_dispatcher.h"
+#include "sound.h"
+#include "common/snd_codec.h"
+#include "demarshallers.h"
+
+#ifndef IOV_MAX
+#define IOV_MAX 1024
+#endif
+
+#define SND_RECEIVE_BUF_SIZE (16 * 1024 * 2)
+#define RECORD_SAMPLES_SIZE (SND_RECEIVE_BUF_SIZE >> 2)
+
+enum PlaybackCommand {
+ SND_PLAYBACK_MIGRATE,
+ SND_PLAYBACK_MODE,
+ SND_PLAYBACK_CTRL,
+ SND_PLAYBACK_PCM,
+ SND_PLAYBACK_VOLUME,
+ SND_PLAYBACK_LATENCY,
+};
+
+enum RecordCommand {
+ SND_RECORD_MIGRATE,
+ SND_RECORD_CTRL,
+ SND_RECORD_VOLUME,
+};
+
+#define SND_PLAYBACK_MIGRATE_MASK (1 << SND_PLAYBACK_MIGRATE)
+#define SND_PLAYBACK_MODE_MASK (1 << SND_PLAYBACK_MODE)
+#define SND_PLAYBACK_CTRL_MASK (1 << SND_PLAYBACK_CTRL)
+#define SND_PLAYBACK_PCM_MASK (1 << SND_PLAYBACK_PCM)
+#define SND_PLAYBACK_VOLUME_MASK (1 << SND_PLAYBACK_VOLUME)
+#define SND_PLAYBACK_LATENCY_MASK ( 1 << SND_PLAYBACK_LATENCY)
+
+#define SND_RECORD_MIGRATE_MASK (1 << SND_RECORD_MIGRATE)
+#define SND_RECORD_CTRL_MASK (1 << SND_RECORD_CTRL)
+#define SND_RECORD_VOLUME_MASK (1 << SND_RECORD_VOLUME)
+
+typedef struct SndChannel SndChannel;
+typedef void (*snd_channel_send_messages_proc)(void *in_channel);
+typedef int (*snd_channel_handle_message_proc)(SndChannel *channel, size_t size, uint32_t type, void *message);
+typedef void (*snd_channel_on_message_done_proc)(SndChannel *channel);
+typedef void (*snd_channel_cleanup_channel_proc)(SndChannel *channel);
+
+typedef struct SndWorker SndWorker;
+
+struct SndChannel {
+ RedsStream *stream;
+ SndWorker *worker;
+ spice_parse_channel_func_t parser;
+ int refs;
+
+ RedChannelClient *channel_client;
+
+ int active;
+ int client_active;
+ int blocked;
+
+ uint32_t command;
+ uint32_t ack_generation;
+ uint32_t client_ack_generation;
+ uint32_t out_messages;
+ uint32_t ack_messages;
+
+ struct {
+ uint64_t serial;
+ SpiceMarshaller *marshaller;
+ uint32_t size;
+ uint32_t pos;
+ } send_data;
+
+ struct {
+ uint8_t buf[SND_RECEIVE_BUF_SIZE];
+ uint8_t *message_start;
+ uint8_t *now;
+ uint8_t *end;
+ } receive_data;
+
+ snd_channel_send_messages_proc send_messages;
+ snd_channel_handle_message_proc handle_message;
+ snd_channel_on_message_done_proc on_message_done;
+ snd_channel_cleanup_channel_proc cleanup;
+};
+
+typedef struct PlaybackChannel PlaybackChannel;
+
+typedef struct AudioFrame AudioFrame;
+struct AudioFrame {
+ uint32_t time;
+ uint32_t samples[SND_CODEC_MAX_FRAME_SIZE];
+ PlaybackChannel *channel;
+ AudioFrame *next;
+};
+
+struct PlaybackChannel {
+ SndChannel base;
+ AudioFrame frames[3];
+ AudioFrame *free_frames;
+ AudioFrame *in_progress;
+ AudioFrame *pending_frame;
+ uint32_t mode;
+ uint32_t latency;
+ SndCodec codec;
+ uint8_t encode_buf[SND_CODEC_MAX_COMPRESSED_BYTES];
+};
+
+struct SndWorker {
+ RedChannel *base_channel;
+ SndChannel *connection;
+ SndWorker *next;
+ int active;
+};
+
+typedef struct SpiceVolumeState {
+ uint8_t volume_nchannels;
+ uint16_t *volume;
+ int mute;
+} SpiceVolumeState;
+
+struct SpicePlaybackState {
+ struct SndWorker worker;
+ SpicePlaybackInstance *sin;
+ SpiceVolumeState volume;
+ uint32_t frequency;
+};
+
+struct SpiceRecordState {
+ struct SndWorker worker;
+ SpiceRecordInstance *sin;
+ SpiceVolumeState volume;
+ uint32_t frequency;
+};
+
+typedef struct RecordChannel {
+ SndChannel base;
+ uint32_t samples[RECORD_SAMPLES_SIZE];
+ uint32_t write_pos;
+ uint32_t read_pos;
+ uint32_t mode;
+ uint32_t mode_time;
+ uint32_t start_time;
+ SndCodec codec;
+ uint8_t decode_buf[SND_CODEC_MAX_FRAME_BYTES];
+} RecordChannel;
+
+static SndWorker *workers;
+static uint32_t playback_compression = TRUE;
+
+static void snd_receive(void* data);
+
+static SndChannel *snd_channel_get(SndChannel *channel)
+{
+ channel->refs++;
+ return channel;
+}
+
+static SndChannel *snd_channel_put(SndChannel *channel)
+{
+ if (!--channel->refs) {
+ spice_printerr("SndChannel=%p freed", channel);
+ free(channel);
+ return NULL;
+ }
+ return channel;
+}
+
+static void snd_disconnect_channel(SndChannel *channel)
+{
+ SndWorker *worker;
+
+ if (!channel || !channel->stream) {
+ spice_debug("not connected");
+ return;
+ }
+ spice_debug("SndChannel=%p rcc=%p type=%d",
+ channel, channel->channel_client, channel->channel_client->channel->type);
+ worker = channel->worker;
+ channel->cleanup(channel);
+ red_channel_client_disconnect(worker->connection->channel_client);
+ worker->connection->channel_client = NULL;
+ core->watch_remove(channel->stream->watch);
+ channel->stream->watch = NULL;
+ reds_stream_free(channel->stream);
+ channel->stream = NULL;
+ spice_marshaller_destroy(channel->send_data.marshaller);
+ snd_channel_put(channel);
+ worker->connection = NULL;
+}
+
+static void snd_playback_free_frame(PlaybackChannel *playback_channel, AudioFrame *frame)
+{
+ frame->channel = playback_channel;
+ frame->next = playback_channel->free_frames;
+ playback_channel->free_frames = frame;
+}
+
+static void snd_playback_on_message_done(SndChannel *channel)
+{
+ PlaybackChannel *playback_channel = (PlaybackChannel *)channel;
+ if (playback_channel->in_progress) {
+ snd_playback_free_frame(playback_channel, playback_channel->in_progress);
+ playback_channel->in_progress = NULL;
+ if (playback_channel->pending_frame) {
+ channel->command |= SND_PLAYBACK_PCM_MASK;
+ }
+ }
+}
+
+static void snd_record_on_message_done(SndChannel *channel)
+{
+}
+
+static int snd_send_data(SndChannel *channel)
+{
+ uint32_t n;
+
+ if (!channel) {
+ return FALSE;
+ }
+
+ if (!(n = channel->send_data.size - channel->send_data.pos)) {
+ return TRUE;
+ }
+
+ for (;;) {
+ struct iovec vec[IOV_MAX];
+ int vec_size;
+
+ if (!n) {
+ channel->on_message_done(channel);
+
+ if (channel->blocked) {
+ channel->blocked = FALSE;
+ core->watch_update_mask(channel->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);
+ if (n == -1) {
+ switch (errno) {
+ case EAGAIN:
+ channel->blocked = TRUE;
+ core->watch_update_mask(channel->stream->watch, SPICE_WATCH_EVENT_READ |
+ SPICE_WATCH_EVENT_WRITE);
+ return FALSE;
+ case EINTR:
+ break;
+ case EPIPE:
+ snd_disconnect_channel(channel);
+ return FALSE;
+ default:
+ spice_printerr("%s", strerror(errno));
+ snd_disconnect_channel(channel);
+ return FALSE;
+ }
+ } else {
+ channel->send_data.pos += n;
+ }
+ n = channel->send_data.size - channel->send_data.pos;
+ }
+ return TRUE;
+}
+
+static int snd_record_handle_write(RecordChannel *record_channel, size_t size, void *message)
+{
+ SpiceMsgcRecordPacket *packet;
+ uint32_t write_pos;
+ uint32_t* data;
+ uint32_t len;
+ uint32_t now;
+
+ if (!record_channel) {
+ return FALSE;
+ }
+
+ packet = (SpiceMsgcRecordPacket *)message;
+
+ if (record_channel->mode == SPICE_AUDIO_DATA_MODE_RAW) {
+ data = (uint32_t *)packet->data;
+ size = packet->data_size >> 2;
+ size = MIN(size, RECORD_SAMPLES_SIZE);
+ } else {
+ int decode_size;
+ decode_size = sizeof(record_channel->decode_buf);
+ if (snd_codec_decode(record_channel->codec, packet->data, packet->data_size,
+ record_channel->decode_buf, &decode_size) != SND_CODEC_OK)
+ return FALSE;
+ data = (uint32_t *) record_channel->decode_buf;
+ size = decode_size >> 2;
+ }
+
+ write_pos = record_channel->write_pos % RECORD_SAMPLES_SIZE;
+ record_channel->write_pos += size;
+ len = RECORD_SAMPLES_SIZE - write_pos;
+ now = MIN(len, size);
+ size -= now;
+ memcpy(record_channel->samples + write_pos, data, now << 2);
+
+ if (size) {
+ memcpy(record_channel->samples, data + now, size << 2);
+ }
+
+ if (record_channel->write_pos - record_channel->read_pos > RECORD_SAMPLES_SIZE) {
+ record_channel->read_pos = record_channel->write_pos - RECORD_SAMPLES_SIZE;
+ }
+ return TRUE;
+}
+
+static int snd_playback_handle_message(SndChannel *channel, size_t size, uint32_t type, void *message)
+{
+ if (!channel) {
+ return FALSE;
+ }
+
+ switch (type) {
+ case SPICE_MSGC_DISCONNECTING:
+ break;
+ default:
+ spice_printerr("invalid message type %u", type);
+ return FALSE;
+ }
+ return TRUE;
+}
+
+static int snd_record_handle_message(SndChannel *channel, size_t size, uint32_t type, void *message)
+{
+ RecordChannel *record_channel = (RecordChannel *)channel;
+
+ if (!channel) {
+ return FALSE;
+ }
+ switch (type) {
+ case SPICE_MSGC_RECORD_DATA:
+ return snd_record_handle_write((RecordChannel *)channel, size, message);
+ case SPICE_MSGC_RECORD_MODE: {
+ SpiceMsgcRecordMode *mode = (SpiceMsgcRecordMode *)message;
+ SpiceRecordState *st = SPICE_CONTAINEROF(channel->worker, SpiceRecordState, worker);
+ record_channel->mode_time = mode->time;
+ if (mode->mode != SPICE_AUDIO_DATA_MODE_RAW) {
+ if (snd_codec_is_capable(mode->mode, st->frequency)) {
+ if (snd_codec_create(&record_channel->codec, mode->mode, st->frequency, SND_CODEC_DECODE) == SND_CODEC_OK) {
+ record_channel->mode = mode->mode;
+ } else {
+ spice_printerr("create decoder failed");
+ return FALSE;
+ }
+ }
+ else {
+ spice_printerr("unsupported mode %d", record_channel->mode);
+ return FALSE;
+ }
+ }
+ else
+ record_channel->mode = mode->mode;
+ break;
+ }
+
+ case SPICE_MSGC_RECORD_START_MARK: {
+ SpiceMsgcRecordStartMark *mark = (SpiceMsgcRecordStartMark *)message;
+ record_channel->start_time = mark->time;
+ break;
+ }
+ case SPICE_MSGC_DISCONNECTING:
+ break;
+ default:
+ spice_printerr("invalid message type %u", type);
+ return FALSE;
+ }
+ return TRUE;
+}
+
+static void snd_receive(void* data)
+{
+ SndChannel *channel = (SndChannel*)data;
+ SpiceDataHeaderOpaque *header;
+
+ if (!channel) {
+ return;
+ }
+
+ header = &channel->channel_client->incoming.header;
+
+ for (;;) {
+ ssize_t n;
+ n = channel->receive_data.end - channel->receive_data.now;
+ spice_warn_if(n <= 0);
+ n = reds_stream_read(channel->stream, channel->receive_data.now, n);
+ if (n <= 0) {
+ if (n == 0) {
+ snd_disconnect_channel(channel);
+ return;
+ }
+ spice_assert(n == -1);
+ switch (errno) {
+ case EAGAIN:
+ return;
+ case EINTR:
+ break;
+ case EPIPE:
+ snd_disconnect_channel(channel);
+ return;
+ default:
+ spice_printerr("%s", strerror(errno));
+ snd_disconnect_channel(channel);
+ return;
+ }
+ } else {
+ channel->receive_data.now += n;
+ for (;;) {
+ uint8_t *msg_start = channel->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;
+
+ 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),
+ 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);
+ return;
+ }
+ if (!channel->handle_message(channel, parsed_size,
+ header->get_msg_type(header), parsed)) {
+ free(parsed);
+ snd_disconnect_channel(channel);
+ return;
+ }
+ parsed_free(parsed);
+ channel->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;
+ }
+ }
+ }
+}
+
+static void snd_event(int fd, int event, void *data)
+{
+ SndChannel *channel = data;
+
+ if (event & SPICE_WATCH_EVENT_READ) {
+ snd_receive(channel);
+ }
+ if (event & SPICE_WATCH_EVENT_WRITE) {
+ channel->send_messages(channel);
+ }
+}
+
+static inline int snd_reset_send_data(SndChannel *channel, uint16_t verb)
+{
+ SpiceDataHeaderOpaque *header;
+
+ if (!channel) {
+ return FALSE;
+ }
+
+ header = &channel->channel_client->send_data.header;
+ spice_marshaller_reset(channel->send_data.marshaller);
+ header->data = spice_marshaller_reserve_space(channel->send_data.marshaller,
+ header->header_size);
+ spice_marshaller_set_base(channel->send_data.marshaller,
+ header->header_size);
+ channel->send_data.pos = 0;
+ header->set_msg_size(header, 0);
+ header->set_msg_type(header, verb);
+ channel->send_data.serial++;
+ if (!channel->channel_client->is_mini_header) {
+ header->set_msg_serial(header, channel->send_data.serial);
+ header->set_msg_sub_list(header, 0);
+ }
+
+ return TRUE;
+}
+
+static int snd_begin_send_message(SndChannel *channel)
+{
+ SpiceDataHeaderOpaque *header = &channel->channel_client->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);
+}
+
+static int snd_channel_send_migrate(SndChannel *channel)
+{
+ SpiceMsgMigrate migrate;
+
+ if (!snd_reset_send_data(channel, SPICE_MSG_MIGRATE)) {
+ return FALSE;
+ }
+ spice_debug(NULL);
+ migrate.flags = 0;
+ spice_marshall_msg_migrate(channel->send_data.marshaller, &migrate);
+
+ return snd_begin_send_message(channel);
+}
+
+static int snd_playback_send_migrate(PlaybackChannel *channel)
+{
+ return snd_channel_send_migrate(&channel->base);
+}
+
+static int snd_send_volume(SndChannel *channel, SpiceVolumeState *st, int msg)
+{
+ SpiceMsgAudioVolume *vol;
+ uint8_t c;
+
+ vol = alloca(sizeof (SpiceMsgAudioVolume) +
+ st->volume_nchannels * sizeof (uint16_t));
+ if (!snd_reset_send_data(channel, 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);
+
+ return snd_begin_send_message(channel);
+}
+
+static int snd_playback_send_volume(PlaybackChannel *playback_channel)
+{
+ SndChannel *channel = &playback_channel->base;
+ SpicePlaybackState *st = SPICE_CONTAINEROF(channel->worker, SpicePlaybackState, worker);
+
+ if (!red_channel_client_test_remote_cap(channel->channel_client,
+ SPICE_PLAYBACK_CAP_VOLUME)) {
+ return TRUE;
+ }
+
+ return snd_send_volume(channel, &st->volume, SPICE_MSG_PLAYBACK_VOLUME);
+}
+
+static int snd_send_mute(SndChannel *channel, SpiceVolumeState *st, int msg)
+{
+ SpiceMsgAudioMute mute;
+
+ if (!snd_reset_send_data(channel, msg)) {
+ return FALSE;
+ }
+ mute.mute = st->mute;
+ spice_marshall_SpiceMsgAudioMute(channel->send_data.marshaller, &mute);
+
+ return snd_begin_send_message(channel);
+}
+
+static int snd_playback_send_mute(PlaybackChannel *playback_channel)
+{
+ SndChannel *channel = &playback_channel->base;
+ SpicePlaybackState *st = SPICE_CONTAINEROF(channel->worker, SpicePlaybackState, worker);
+
+ if (!red_channel_client_test_remote_cap(channel->channel_client,
+ SPICE_PLAYBACK_CAP_VOLUME)) {
+ return TRUE;
+ }
+
+ return snd_send_mute(channel, &st->volume, SPICE_MSG_PLAYBACK_MUTE);
+}
+
+static int snd_playback_send_latency(PlaybackChannel *playback_channel)
+{
+ SndChannel *channel = &playback_channel->base;
+ SpiceMsgPlaybackLatency latency_msg;
+
+ spice_debug("latency %u", playback_channel->latency);
+ if (!snd_reset_send_data(channel, SPICE_MSG_PLAYBACK_LATENCY)) {
+ return FALSE;
+ }
+ latency_msg.latency_ms = playback_channel->latency;
+ spice_marshall_msg_playback_latency(channel->send_data.marshaller, &latency_msg);
+
+ return snd_begin_send_message(channel);
+}
+static int snd_playback_send_start(PlaybackChannel *playback_channel)
+{
+ SndChannel *channel = (SndChannel *)playback_channel;
+ SpicePlaybackState *st = SPICE_CONTAINEROF(channel->worker, SpicePlaybackState, worker);
+ SpiceMsgPlaybackStart start;
+
+ if (!snd_reset_send_data(channel, SPICE_MSG_PLAYBACK_START)) {
+ return FALSE;
+ }
+
+ start.channels = SPICE_INTERFACE_PLAYBACK_CHAN;
+ start.frequency = st->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);
+
+ return snd_begin_send_message(channel);
+}
+
+static int snd_playback_send_stop(PlaybackChannel *playback_channel)
+{
+ SndChannel *channel = (SndChannel *)playback_channel;
+
+ if (!snd_reset_send_data(channel, SPICE_MSG_PLAYBACK_STOP)) {
+ return FALSE;
+ }
+
+ return snd_begin_send_message(channel);
+}
+
+static int snd_playback_send_ctl(PlaybackChannel *playback_channel)
+{
+ SndChannel *channel = (SndChannel *)playback_channel;
+
+ if ((channel->client_active = channel->active)) {
+ return snd_playback_send_start(playback_channel);
+ } else {
+ return snd_playback_send_stop(playback_channel);
+ }
+}
+
+static int snd_record_send_start(RecordChannel *record_channel)
+{
+ SndChannel *channel = (SndChannel *)record_channel;
+ SpiceRecordState *st = SPICE_CONTAINEROF(channel->worker, SpiceRecordState, worker);
+ SpiceMsgRecordStart start;
+
+ if (!snd_reset_send_data(channel, SPICE_MSG_RECORD_START)) {
+ return FALSE;
+ }
+
+ start.channels = SPICE_INTERFACE_RECORD_CHAN;
+ start.frequency = st->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);
+
+ return snd_begin_send_message(channel);
+}
+
+static int snd_record_send_stop(RecordChannel *record_channel)
+{
+ SndChannel *channel = (SndChannel *)record_channel;
+
+ if (!snd_reset_send_data(channel, SPICE_MSG_RECORD_STOP)) {
+ return FALSE;
+ }
+
+ return snd_begin_send_message(channel);
+}
+
+static int snd_record_send_ctl(RecordChannel *record_channel)
+{
+ SndChannel *channel = (SndChannel *)record_channel;
+
+ if ((channel->client_active = channel->active)) {
+ return snd_record_send_start(record_channel);
+ } else {
+ return snd_record_send_stop(record_channel);
+ }
+}
+
+static int snd_record_send_volume(RecordChannel *record_channel)
+{
+ SndChannel *channel = &record_channel->base;
+ SpiceRecordState *st = SPICE_CONTAINEROF(channel->worker, SpiceRecordState, worker);
+
+ if (!red_channel_client_test_remote_cap(channel->channel_client,
+ SPICE_RECORD_CAP_VOLUME)) {
+ return TRUE;
+ }
+
+ return snd_send_volume(channel, &st->volume, SPICE_MSG_RECORD_VOLUME);
+}
+
+static int snd_record_send_mute(RecordChannel *record_channel)
+{
+ SndChannel *channel = &record_channel->base;
+ SpiceRecordState *st = SPICE_CONTAINEROF(channel->worker, SpiceRecordState, worker);
+
+ if (!red_channel_client_test_remote_cap(channel->channel_client,
+ SPICE_RECORD_CAP_VOLUME)) {
+ return TRUE;
+ }
+
+ return snd_send_mute(channel, &st->volume, SPICE_MSG_RECORD_MUTE);
+}
+
+static int snd_record_send_migrate(RecordChannel *record_channel)
+{
+ /* No need for migration data: if recording has started before migration,
+ * the client receives RECORD_STOP from the src before the migration completion
+ * notification (when the vm is stopped).
+ * Afterwards, when the vm starts on the dest, the client receives RECORD_START. */
+ return snd_channel_send_migrate(&record_channel->base);
+}
+
+static int snd_playback_send_write(PlaybackChannel *playback_channel)
+{
+ SndChannel *channel = (SndChannel *)playback_channel;
+ AudioFrame *frame;
+ SpiceMsgPlaybackPacket msg;
+
+ if (!snd_reset_send_data(channel, SPICE_MSG_PLAYBACK_DATA)) {
+ return FALSE;
+ }
+
+ frame = playback_channel->in_progress;
+ msg.time = frame->time;
+
+ spice_marshall_msg_playback_data(channel->send_data.marshaller, &msg);
+
+ if (playback_channel->mode == SPICE_AUDIO_DATA_MODE_RAW) {
+ spice_marshaller_add_ref(channel->send_data.marshaller,
+ (uint8_t *)frame->samples,
+ snd_codec_frame_size(playback_channel->codec) * sizeof(frame->samples[0]));
+ }
+ else {
+ int n = sizeof(playback_channel->encode_buf);
+ if (snd_codec_encode(playback_channel->codec, (uint8_t *) frame->samples,
+ snd_codec_frame_size(playback_channel->codec) * sizeof(frame->samples[0]),
+ playback_channel->encode_buf, &n) != SND_CODEC_OK) {
+ spice_printerr("encode failed");
+ snd_disconnect_channel(channel);
+ return FALSE;
+ }
+ spice_marshaller_add_ref(channel->send_data.marshaller, playback_channel->encode_buf, n);
+ }
+
+ return snd_begin_send_message(channel);
+}
+
+static int playback_send_mode(PlaybackChannel *playback_channel)
+{
+ SndChannel *channel = (SndChannel *)playback_channel;
+ SpiceMsgPlaybackMode mode;
+
+ if (!snd_reset_send_data(channel, SPICE_MSG_PLAYBACK_MODE)) {
+ return FALSE;
+ }
+ mode.time = reds_get_mm_time();
+ mode.mode = playback_channel->mode;
+ spice_marshall_msg_playback_mode(channel->send_data.marshaller, &mode);
+
+ return snd_begin_send_message(channel);
+}
+
+static void snd_playback_send(void* data)
+{
+ PlaybackChannel *playback_channel = (PlaybackChannel*)data;
+ SndChannel *channel = (SndChannel*)playback_channel;
+
+ if (!playback_channel || !snd_send_data(data)) {
+ return;
+ }
+
+ while (channel->command) {
+ if (channel->command & SND_PLAYBACK_MODE_MASK) {
+ if (!playback_send_mode(playback_channel)) {
+ return;
+ }
+ channel->command &= ~SND_PLAYBACK_MODE_MASK;
+ }
+ if (channel->command & SND_PLAYBACK_PCM_MASK) {
+ spice_assert(!playback_channel->in_progress && playback_channel->pending_frame);
+ playback_channel->in_progress = playback_channel->pending_frame;
+ playback_channel->pending_frame = NULL;
+ channel->command &= ~SND_PLAYBACK_PCM_MASK;
+ if (!snd_playback_send_write(playback_channel)) {
+ spice_printerr("snd_send_playback_write failed");
+ return;
+ }
+ }
+ if (channel->command & SND_PLAYBACK_CTRL_MASK) {
+ if (!snd_playback_send_ctl(playback_channel)) {
+ return;
+ }
+ channel->command &= ~SND_PLAYBACK_CTRL_MASK;
+ }
+ if (channel->command & SND_PLAYBACK_VOLUME_MASK) {
+ if (!snd_playback_send_volume(playback_channel) ||
+ !snd_playback_send_mute(playback_channel)) {
+ return;
+ }
+ channel->command &= ~SND_PLAYBACK_VOLUME_MASK;
+ }
+ if (channel->command & SND_PLAYBACK_MIGRATE_MASK) {
+ if (!snd_playback_send_migrate(playback_channel)) {
+ return;
+ }
+ channel->command &= ~SND_PLAYBACK_MIGRATE_MASK;
+ }
+ if (channel->command & SND_PLAYBACK_LATENCY_MASK) {
+ if (!snd_playback_send_latency(playback_channel)) {
+ return;
+ }
+ channel->command &= ~SND_PLAYBACK_LATENCY_MASK;
+ }
+ }
+}
+
+static void snd_record_send(void* data)
+{
+ RecordChannel *record_channel = (RecordChannel*)data;
+ SndChannel *channel = (SndChannel*)record_channel;
+
+ if (!record_channel || !snd_send_data(data)) {
+ return;
+ }
+
+ while (channel->command) {
+ if (channel->command & SND_RECORD_CTRL_MASK) {
+ if (!snd_record_send_ctl(record_channel)) {
+ return;
+ }
+ channel->command &= ~SND_RECORD_CTRL_MASK;
+ }
+ if (channel->command & SND_RECORD_VOLUME_MASK) {
+ if (!snd_record_send_volume(record_channel) ||
+ !snd_record_send_mute(record_channel)) {
+ return;
+ }
+ channel->command &= ~SND_RECORD_VOLUME_MASK;
+ }
+ if (channel->command & SND_RECORD_MIGRATE_MASK) {
+ if (!snd_record_send_migrate(record_channel)) {
+ return;
+ }
+ channel->command &= ~SND_RECORD_MIGRATE_MASK;
+ }
+ }
+}
+
+static SndChannel *__new_channel(SndWorker *worker, int size, uint32_t channel_id,
+ RedClient *client,
+ RedsStream *stream,
+ int migrate,
+ snd_channel_send_messages_proc send_messages,
+ snd_channel_handle_message_proc handle_message,
+ snd_channel_on_message_done_proc on_message_done,
+ snd_channel_cleanup_channel_proc cleanup,
+ uint32_t *common_caps, int num_common_caps,
+ uint32_t *caps, int num_caps)
+{
+ SndChannel *channel;
+ int delay_val;
+ int flags;
+#ifdef SO_PRIORITY
+ int priority;
+#endif
+ int tos;
+ MainChannelClient *mcc = red_client_get_main(client);
+
+ spice_assert(stream);
+ if ((flags = fcntl(stream->socket, F_GETFL)) == -1) {
+ spice_printerr("accept failed, %s", strerror(errno));
+ goto error1;
+ }
+
+#ifdef SO_PRIORITY
+ priority = 6;
+ if (setsockopt(stream->socket, SOL_SOCKET, SO_PRIORITY, (void*)&priority,
+ sizeof(priority)) == -1) {
+ if (errno != ENOTSUP) {
+ spice_printerr("setsockopt failed, %s", strerror(errno));
+ }
+ }
+#endif
+
+ tos = IPTOS_LOWDELAY;
+ if (setsockopt(stream->socket, IPPROTO_IP, IP_TOS, (void*)&tos, sizeof(tos)) == -1) {
+ if (errno != ENOTSUP) {
+ spice_printerr("setsockopt failed, %s", strerror(errno));
+ }
+ }
+
+ delay_val = main_channel_client_is_low_bandwidth(mcc) ? 0 : 1;
+ if (setsockopt(stream->socket, IPPROTO_TCP, TCP_NODELAY, &delay_val, sizeof(delay_val)) == -1) {
+ if (errno != ENOTSUP) {
+ spice_printerr("setsockopt failed, %s", strerror(errno));
+ }
+ }
+
+ if (fcntl(stream->socket, F_SETFL, flags | O_NONBLOCK) == -1) {
+ spice_printerr("accept failed, %s", strerror(errno));
+ 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();
+
+ stream->watch = core->watch_add(stream->socket, SPICE_WATCH_EVENT_READ,
+ snd_event, channel);
+ 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;
+
+ channel->channel_client = red_channel_client_create_dummy(sizeof(RedChannelClient),
+ worker->base_channel,
+ client,
+ num_common_caps, common_caps,
+ num_caps, caps);
+ if (!channel->channel_client) {
+ goto error2;
+ }
+ return channel;
+
+error2:
+ free(channel);
+
+error1:
+ reds_stream_free(stream);
+ return NULL;
+}
+
+static void snd_disconnect_channel_client(RedChannelClient *rcc)
+{
+ SndWorker *worker;
+
+ spice_assert(rcc->channel);
+ spice_assert(rcc->channel->data);
+ worker = (SndWorker *)rcc->channel->data;
+
+ spice_debug("channel-type=%d", rcc->channel->type);
+ if (worker->connection) {
+ spice_assert(worker->connection->channel_client == rcc);
+ snd_disconnect_channel(worker->connection);
+ }
+}
+
+static void snd_set_command(SndChannel *channel, uint32_t command)
+{
+ if (!channel) {
+ return;
+ }
+ channel->command |= command;
+}
+
+SPICE_GNUC_VISIBLE void spice_server_playback_set_volume(SpicePlaybackInstance *sin,
+ uint8_t nchannels,
+ uint16_t *volume)
+{
+ SpiceVolumeState *st = &sin->st->volume;
+ SndChannel *channel = sin->st->worker.connection;
+ PlaybackChannel *playback_channel = SPICE_CONTAINEROF(channel, PlaybackChannel, base);
+
+ st->volume_nchannels = nchannels;
+ free(st->volume);
+ st->volume = spice_memdup(volume, sizeof(uint16_t) * nchannels);
+
+ if (!channel || nchannels == 0)
+ return;
+
+ snd_playback_send_volume(playback_channel);
+}
+
+SPICE_GNUC_VISIBLE void spice_server_playback_set_mute(SpicePlaybackInstance *sin, uint8_t mute)
+{
+ SpiceVolumeState *st = &sin->st->volume;
+ SndChannel *channel = sin->st->worker.connection;
+ PlaybackChannel *playback_channel = SPICE_CONTAINEROF(channel, PlaybackChannel, base);
+
+ st->mute = mute;
+
+ if (!channel)
+ return;
+
+ snd_playback_send_mute(playback_channel);
+}
+
+SPICE_GNUC_VISIBLE void spice_server_playback_start(SpicePlaybackInstance *sin)
+{
+ SndChannel *channel = sin->st->worker.connection;
+ PlaybackChannel *playback_channel = SPICE_CONTAINEROF(channel, PlaybackChannel, base);
+
+ sin->st->worker.active = 1;
+ if (!channel)
+ return;
+ spice_assert(!playback_channel->base.active);
+ reds_disable_mm_time();
+ playback_channel->base.active = TRUE;
+ if (!playback_channel->base.client_active) {
+ snd_set_command(&playback_channel->base, SND_PLAYBACK_CTRL_MASK);
+ snd_playback_send(&playback_channel->base);
+ } else {
+ playback_channel->base.command &= ~SND_PLAYBACK_CTRL_MASK;
+ }
+}
+
+SPICE_GNUC_VISIBLE void spice_server_playback_stop(SpicePlaybackInstance *sin)
+{
+ SndChannel *channel = sin->st->worker.connection;
+ PlaybackChannel *playback_channel = SPICE_CONTAINEROF(channel, PlaybackChannel, base);
+
+ sin->st->worker.active = 0;
+ if (!channel)
+ return;
+ spice_assert(playback_channel->base.active);
+ reds_enable_mm_time();
+ playback_channel->base.active = FALSE;
+ if (playback_channel->base.client_active) {
+ snd_set_command(&playback_channel->base, SND_PLAYBACK_CTRL_MASK);
+ snd_playback_send(&playback_channel->base);
+ } else {
+ playback_channel->base.command &= ~SND_PLAYBACK_CTRL_MASK;
+ playback_channel->base.command &= ~SND_PLAYBACK_PCM_MASK;
+
+ if (playback_channel->pending_frame) {
+ spice_assert(!playback_channel->in_progress);
+ snd_playback_free_frame(playback_channel,
+ playback_channel->pending_frame);
+ playback_channel->pending_frame = NULL;
+ }
+ }
+}
+
+SPICE_GNUC_VISIBLE void spice_server_playback_get_buffer(SpicePlaybackInstance *sin,
+ uint32_t **frame, uint32_t *num_samples)
+{
+ SndChannel *channel = sin->st->worker.connection;
+ PlaybackChannel *playback_channel = SPICE_CONTAINEROF(channel, PlaybackChannel, base);
+
+ if (!channel || !playback_channel->free_frames) {
+ *frame = NULL;
+ *num_samples = 0;
+ return;
+ }
+ spice_assert(playback_channel->base.active);
+ snd_channel_get(channel);
+
+ *frame = playback_channel->free_frames->samples;
+ playback_channel->free_frames = playback_channel->free_frames->next;
+ *num_samples = snd_codec_frame_size(playback_channel->codec);
+}
+
+SPICE_GNUC_VISIBLE void spice_server_playback_put_samples(SpicePlaybackInstance *sin, uint32_t *samples)
+{
+ PlaybackChannel *playback_channel;
+ AudioFrame *frame;
+
+ frame = SPICE_CONTAINEROF(samples, AudioFrame, samples);
+ playback_channel = frame->channel;
+ spice_assert(playback_channel);
+ if (!snd_channel_put(&playback_channel->base) ||
+ sin->st->worker.connection != &playback_channel->base) {
+ /* lost last reference, channel has been destroyed previously */
+ spice_info("audio samples belong to a disconnected channel");
+ return;
+ }
+ spice_assert(playback_channel->base.active);
+
+ if (playback_channel->pending_frame) {
+ snd_playback_free_frame(playback_channel, playback_channel->pending_frame);
+ }
+ frame->time = reds_get_mm_time();
+ playback_channel->pending_frame = frame;
+ snd_set_command(&playback_channel->base, SND_PLAYBACK_PCM_MASK);
+ snd_playback_send(&playback_channel->base);
+}
+
+void snd_set_playback_latency(RedClient *client, uint32_t latency)
+{
+ SndWorker *now = workers;
+
+ for (; now; now = now->next) {
+ if (now->base_channel->type == SPICE_CHANNEL_PLAYBACK && now->connection &&
+ now->connection->channel_client->client == client) {
+
+ if (red_channel_client_test_remote_cap(now->connection->channel_client,
+ SPICE_PLAYBACK_CAP_LATENCY)) {
+ PlaybackChannel* playback = (PlaybackChannel*)now->connection;
+
+ playback->latency = latency;
+ snd_set_command(now->connection, SND_PLAYBACK_LATENCY_MASK);
+ snd_playback_send(now->connection);
+ } else {
+ spice_debug("client doesn't not support SPICE_PLAYBACK_CAP_LATENCY");
+ }
+ }
+ }
+}
+
+static int snd_desired_audio_mode(int frequency, int client_can_celt, int client_can_opus)
+{
+ if (! playback_compression)
+ return SPICE_AUDIO_DATA_MODE_RAW;
+
+ if (client_can_opus && snd_codec_is_capable(SPICE_AUDIO_DATA_MODE_OPUS, frequency))
+ return SPICE_AUDIO_DATA_MODE_OPUS;
+
+ if (client_can_celt && snd_codec_is_capable(SPICE_AUDIO_DATA_MODE_CELT_0_5_1, frequency))
+ return SPICE_AUDIO_DATA_MODE_CELT_0_5_1;
+
+ return SPICE_AUDIO_DATA_MODE_RAW;
+}
+
+static void on_new_playback_channel(SndWorker *worker)
+{
+ PlaybackChannel *playback_channel =
+ SPICE_CONTAINEROF(worker->connection, PlaybackChannel, base);
+ SpicePlaybackState *st = SPICE_CONTAINEROF(worker, SpicePlaybackState, worker);
+
+ spice_assert(playback_channel);
+
+ snd_set_command((SndChannel *)playback_channel, SND_PLAYBACK_MODE_MASK);
+ if (playback_channel->base.active) {
+ snd_set_command((SndChannel *)playback_channel, SND_PLAYBACK_CTRL_MASK);
+ }
+ if (st->volume.volume_nchannels) {
+ snd_set_command((SndChannel *)playback_channel, SND_PLAYBACK_VOLUME_MASK);
+ }
+ if (playback_channel->base.active) {
+ reds_disable_mm_time();
+ }
+}
+
+static void snd_playback_cleanup(SndChannel *channel)
+{
+ PlaybackChannel *playback_channel = SPICE_CONTAINEROF(channel, PlaybackChannel, base);
+
+ if (playback_channel->base.active) {
+ reds_enable_mm_time();
+ }
+
+ snd_codec_destroy(&playback_channel->codec);
+}
+
+static void snd_set_playback_peer(RedChannel *channel, RedClient *client, RedsStream *stream,
+ int migration, int num_common_caps, uint32_t *common_caps,
+ int num_caps, uint32_t *caps)
+{
+ SndWorker *worker = channel->data;
+ PlaybackChannel *playback_channel;
+ SpicePlaybackState *st = SPICE_CONTAINEROF(worker, SpicePlaybackState, worker);
+
+ snd_disconnect_channel(worker->connection);
+
+ if (!(playback_channel = (PlaybackChannel *)__new_channel(worker,
+ sizeof(*playback_channel),
+ SPICE_CHANNEL_PLAYBACK,
+ client,
+ stream,
+ migration,
+ snd_playback_send,
+ snd_playback_handle_message,
+ snd_playback_on_message_done,
+ snd_playback_cleanup,
+ common_caps, num_common_caps,
+ caps, num_caps))) {
+ return;
+ }
+ worker->connection = &playback_channel->base;
+ snd_playback_free_frame(playback_channel, &playback_channel->frames[0]);
+ snd_playback_free_frame(playback_channel, &playback_channel->frames[1]);
+ snd_playback_free_frame(playback_channel, &playback_channel->frames[2]);
+
+ int client_can_celt = red_channel_client_test_remote_cap(playback_channel->base.channel_client,
+ SPICE_PLAYBACK_CAP_CELT_0_5_1);
+ int client_can_opus = red_channel_client_test_remote_cap(playback_channel->base.channel_client,
+ SPICE_PLAYBACK_CAP_OPUS);
+ int desired_mode = snd_desired_audio_mode(st->frequency, client_can_celt, client_can_opus);
+ playback_channel->mode = SPICE_AUDIO_DATA_MODE_RAW;
+ if (desired_mode != SPICE_AUDIO_DATA_MODE_RAW) {
+ if (snd_codec_create(&playback_channel->codec, desired_mode, st->frequency, SND_CODEC_ENCODE) == SND_CODEC_OK) {
+ playback_channel->mode = desired_mode;
+ } else {
+ spice_printerr("create encoder failed");
+ }
+ }
+
+ if (!red_client_during_migrate_at_target(client)) {
+ on_new_playback_channel(worker);
+ }
+
+ if (worker->active) {
+ spice_server_playback_start(st->sin);
+ }
+ snd_playback_send(worker->connection);
+}
+
+static void snd_record_migrate_channel_client(RedChannelClient *rcc)
+{
+ SndWorker *worker;
+
+ spice_debug(NULL);
+ spice_assert(rcc->channel);
+ spice_assert(rcc->channel->data);
+ worker = (SndWorker *)rcc->channel->data;
+
+ if (worker->connection) {
+ spice_assert(worker->connection->channel_client == rcc);
+ snd_set_command(worker->connection, SND_RECORD_MIGRATE_MASK);
+ snd_record_send(worker->connection);
+ }
+}
+
+SPICE_GNUC_VISIBLE void spice_server_record_set_volume(SpiceRecordInstance *sin,
+ uint8_t nchannels,
+ uint16_t *volume)
+{
+ SpiceVolumeState *st = &sin->st->volume;
+ SndChannel *channel = sin->st->worker.connection;
+ RecordChannel *record_channel = SPICE_CONTAINEROF(channel, RecordChannel, base);
+
+ st->volume_nchannels = nchannels;
+ free(st->volume);
+ st->volume = spice_memdup(volume, sizeof(uint16_t) * nchannels);
+
+ if (!channel || nchannels == 0)
+ return;
+
+ snd_record_send_volume(record_channel);
+}
+
+SPICE_GNUC_VISIBLE void spice_server_record_set_mute(SpiceRecordInstance *sin, uint8_t mute)
+{
+ SpiceVolumeState *st = &sin->st->volume;
+ SndChannel *channel = sin->st->worker.connection;
+ RecordChannel *record_channel = SPICE_CONTAINEROF(channel, RecordChannel, base);
+
+ st->mute = mute;
+
+ if (!channel)
+ return;
+
+ snd_record_send_mute(record_channel);
+}
+
+SPICE_GNUC_VISIBLE void spice_server_record_start(SpiceRecordInstance *sin)
+{
+ SndChannel *channel = sin->st->worker.connection;
+ RecordChannel *record_channel = SPICE_CONTAINEROF(channel, RecordChannel, base);
+
+ sin->st->worker.active = 1;
+ if (!channel)
+ return;
+ spice_assert(!record_channel->base.active);
+ record_channel->base.active = TRUE;
+ record_channel->read_pos = record_channel->write_pos = 0; //todo: improve by
+ //stream generation
+ if (!record_channel->base.client_active) {
+ snd_set_command(&record_channel->base, SND_RECORD_CTRL_MASK);
+ snd_record_send(&record_channel->base);
+ } else {
+ record_channel->base.command &= ~SND_RECORD_CTRL_MASK;
+ }
+}
+
+SPICE_GNUC_VISIBLE void spice_server_record_stop(SpiceRecordInstance *sin)
+{
+ SndChannel *channel = sin->st->worker.connection;
+ RecordChannel *record_channel = SPICE_CONTAINEROF(channel, RecordChannel, base);
+
+ sin->st->worker.active = 0;
+ if (!channel)
+ return;
+ spice_assert(record_channel->base.active);
+ record_channel->base.active = FALSE;
+ if (record_channel->base.client_active) {
+ snd_set_command(&record_channel->base, SND_RECORD_CTRL_MASK);
+ snd_record_send(&record_channel->base);
+ } else {
+ record_channel->base.command &= ~SND_RECORD_CTRL_MASK;
+ }
+}
+
+SPICE_GNUC_VISIBLE uint32_t spice_server_record_get_samples(SpiceRecordInstance *sin,
+ uint32_t *samples, uint32_t bufsize)
+{
+ SndChannel *channel = sin->st->worker.connection;
+ RecordChannel *record_channel = SPICE_CONTAINEROF(channel, RecordChannel, base);
+ uint32_t read_pos;
+ uint32_t now;
+ uint32_t len;
+
+ if (!channel)
+ return 0;
+ spice_assert(record_channel->base.active);
+
+ if (record_channel->write_pos < RECORD_SAMPLES_SIZE / 2) {
+ return 0;
+ }
+
+ len = MIN(record_channel->write_pos - record_channel->read_pos, bufsize);
+
+ if (len < bufsize) {
+ SndWorker *worker = record_channel->base.worker;
+ snd_receive(record_channel);
+ if (!worker->connection) {
+ return 0;
+ }
+ len = MIN(record_channel->write_pos - record_channel->read_pos, bufsize);
+ }
+
+ read_pos = record_channel->read_pos % RECORD_SAMPLES_SIZE;
+ record_channel->read_pos += len;
+ now = MIN(len, RECORD_SAMPLES_SIZE - read_pos);
+ memcpy(samples, &record_channel->samples[read_pos], now * 4);
+ if (now < len) {
+ memcpy(samples + now, record_channel->samples, (len - now) * 4);
+ }
+ return len;
+}
+
+SPICE_GNUC_VISIBLE uint32_t spice_server_get_best_playback_rate(SpicePlaybackInstance *sin)
+{
+ int client_can_opus = TRUE;
+ if (sin && sin->st->worker.connection) {
+ SndChannel *channel = sin->st->worker.connection;
+ PlaybackChannel *playback_channel = SPICE_CONTAINEROF(channel, PlaybackChannel, base);
+ client_can_opus = red_channel_client_test_remote_cap(playback_channel->base.channel_client,
+ SPICE_PLAYBACK_CAP_OPUS);
+ }
+
+ if (client_can_opus && snd_codec_is_capable(SPICE_AUDIO_DATA_MODE_OPUS, SND_CODEC_ANY_FREQUENCY))
+ return SND_CODEC_OPUS_PLAYBACK_FREQ;
+
+ return SND_CODEC_CELT_PLAYBACK_FREQ;
+}
+
+SPICE_GNUC_VISIBLE void spice_server_set_playback_rate(SpicePlaybackInstance *sin, uint32_t frequency)
+{
+ RedChannel *channel = sin->st->worker.base_channel;
+ sin->st->frequency = frequency;
+ if (channel && snd_codec_is_capable(SPICE_AUDIO_DATA_MODE_OPUS, frequency))
+ red_channel_set_cap(channel, SPICE_PLAYBACK_CAP_OPUS);
+}
+
+SPICE_GNUC_VISIBLE uint32_t spice_server_get_best_record_rate(SpiceRecordInstance *sin)
+{
+ int client_can_opus = TRUE;
+ if (sin && sin->st->worker.connection) {
+ SndChannel *channel = sin->st->worker.connection;
+ RecordChannel *record_channel = SPICE_CONTAINEROF(channel, RecordChannel, base);
+ client_can_opus = red_channel_client_test_remote_cap(record_channel->base.channel_client,
+ SPICE_RECORD_CAP_OPUS);
+ }
+
+ if (client_can_opus && snd_codec_is_capable(SPICE_AUDIO_DATA_MODE_OPUS, SND_CODEC_ANY_FREQUENCY))
+ return SND_CODEC_OPUS_PLAYBACK_FREQ;
+
+ return SND_CODEC_CELT_PLAYBACK_FREQ;
+}
+
+SPICE_GNUC_VISIBLE void spice_server_set_record_rate(SpiceRecordInstance *sin, uint32_t frequency)
+{
+ RedChannel *channel = sin->st->worker.base_channel;
+ sin->st->frequency = frequency;
+ if (channel && snd_codec_is_capable(SPICE_AUDIO_DATA_MODE_OPUS, frequency))
+ red_channel_set_cap(channel, SPICE_RECORD_CAP_OPUS);
+}
+
+static void on_new_record_channel(SndWorker *worker)
+{
+ RecordChannel *record_channel = (RecordChannel *)worker->connection;
+ SpiceRecordState *st = SPICE_CONTAINEROF(worker, SpiceRecordState, worker);
+
+ spice_assert(record_channel);
+
+ if (st->volume.volume_nchannels) {
+ snd_set_command((SndChannel *)record_channel, SND_RECORD_VOLUME_MASK);
+ }
+ if (record_channel->base.active) {
+ snd_set_command((SndChannel *)record_channel, SND_RECORD_CTRL_MASK);
+ }
+}
+
+static void snd_record_cleanup(SndChannel *channel)
+{
+ RecordChannel *record_channel = SPICE_CONTAINEROF(channel, RecordChannel, base);
+ snd_codec_destroy(&record_channel->codec);
+}
+
+static void snd_set_record_peer(RedChannel *channel, RedClient *client, RedsStream *stream,
+ int migration, int num_common_caps, uint32_t *common_caps,
+ int num_caps, uint32_t *caps)
+{
+ SndWorker *worker = channel->data;
+ RecordChannel *record_channel;
+ SpiceRecordState *st = SPICE_CONTAINEROF(worker, SpiceRecordState, worker);
+
+ snd_disconnect_channel(worker->connection);
+
+ if (!(record_channel = (RecordChannel *)__new_channel(worker,
+ sizeof(*record_channel),
+ SPICE_CHANNEL_RECORD,
+ client,
+ stream,
+ migration,
+ snd_record_send,
+ snd_record_handle_message,
+ snd_record_on_message_done,
+ snd_record_cleanup,
+ common_caps, num_common_caps,
+ caps, num_caps))) {
+ return;
+ }
+
+ record_channel->mode = SPICE_AUDIO_DATA_MODE_RAW;
+
+ worker->connection = &record_channel->base;
+
+ on_new_record_channel(worker);
+ if (worker->active) {
+ spice_server_record_start(st->sin);
+ }
+ snd_record_send(worker->connection);
+}
+
+static void snd_playback_migrate_channel_client(RedChannelClient *rcc)
+{
+ SndWorker *worker;
+
+ spice_assert(rcc->channel);
+ spice_assert(rcc->channel->data);
+ worker = (SndWorker *)rcc->channel->data;
+ spice_debug(NULL);
+
+ if (worker->connection) {
+ spice_assert(worker->connection->channel_client == rcc);
+ snd_set_command(worker->connection, SND_PLAYBACK_MIGRATE_MASK);
+ snd_playback_send(worker->connection);
+ }
+}
+
+static void add_worker(SndWorker *worker)
+{
+ worker->next = workers;
+ workers = worker;
+}
+
+static void remove_worker(SndWorker *worker)
+{
+ SndWorker **now = &workers;
+ while (*now) {
+ if (*now == worker) {
+ *now = worker->next;
+ return;
+ }
+ now = &(*now)->next;
+ }
+ spice_printerr("not found");
+}
+
+void snd_attach_playback(SpicePlaybackInstance *sin)
+{
+ SndWorker *playback_worker;
+ RedChannel *channel;
+ ClientCbs client_cbs = { NULL, };
+
+ sin->st = spice_new0(SpicePlaybackState, 1);
+ sin->st->sin = sin;
+ playback_worker = &sin->st->worker;
+ sin->st->frequency = SND_CODEC_CELT_PLAYBACK_FREQ; /* Default to the legacy rate */
+
+ // TODO: Make RedChannel base of worker? instead of assigning it to channel->data
+ channel = red_channel_create_dummy(sizeof(RedChannel), SPICE_CHANNEL_PLAYBACK, 0);
+
+ channel->data = playback_worker;
+ client_cbs.connect = snd_set_playback_peer;
+ client_cbs.disconnect = snd_disconnect_channel_client;
+ client_cbs.migrate = snd_playback_migrate_channel_client;
+ red_channel_register_client_cbs(channel, &client_cbs);
+ red_channel_set_data(channel, playback_worker);
+
+ if (snd_codec_is_capable(SPICE_AUDIO_DATA_MODE_CELT_0_5_1, SND_CODEC_ANY_FREQUENCY))
+ red_channel_set_cap(channel, SPICE_PLAYBACK_CAP_CELT_0_5_1);
+
+ red_channel_set_cap(channel, SPICE_PLAYBACK_CAP_VOLUME);
+
+ playback_worker->base_channel = channel;
+ add_worker(playback_worker);
+ reds_register_channel(playback_worker->base_channel);
+}
+
+void snd_attach_record(SpiceRecordInstance *sin)
+{
+ SndWorker *record_worker;
+ RedChannel *channel;
+ ClientCbs client_cbs = { NULL, };
+
+ sin->st = spice_new0(SpiceRecordState, 1);
+ sin->st->sin = sin;
+ record_worker = &sin->st->worker;
+ sin->st->frequency = SND_CODEC_CELT_PLAYBACK_FREQ; /* Default to the legacy rate */
+
+ // TODO: Make RedChannel base of worker? instead of assigning it to channel->data
+ channel = red_channel_create_dummy(sizeof(RedChannel), SPICE_CHANNEL_RECORD, 0);
+
+ channel->data = record_worker;
+ client_cbs.connect = snd_set_record_peer;
+ client_cbs.disconnect = snd_disconnect_channel_client;
+ client_cbs.migrate = snd_record_migrate_channel_client;
+ red_channel_register_client_cbs(channel, &client_cbs);
+ red_channel_set_data(channel, record_worker);
+ if (snd_codec_is_capable(SPICE_AUDIO_DATA_MODE_CELT_0_5_1, SND_CODEC_ANY_FREQUENCY))
+ red_channel_set_cap(channel, SPICE_RECORD_CAP_CELT_0_5_1);
+ red_channel_set_cap(channel, SPICE_RECORD_CAP_VOLUME);
+
+ record_worker->base_channel = channel;
+ add_worker(record_worker);
+ reds_register_channel(record_worker->base_channel);
+}
+
+static void snd_detach_common(SndWorker *worker)
+{
+ if (!worker) {
+ return;
+ }
+ remove_worker(worker);
+ snd_disconnect_channel(worker->connection);
+ reds_unregister_channel(worker->base_channel);
+ red_channel_destroy(worker->base_channel);
+}
+
+static void spice_playback_state_free(SpicePlaybackState *st)
+{
+ free(st->volume.volume);
+ free(st);
+}
+
+void snd_detach_playback(SpicePlaybackInstance *sin)
+{
+ snd_detach_common(&sin->st->worker);
+ spice_playback_state_free(sin->st);
+}
+
+static void spice_record_state_free(SpiceRecordState *st)
+{
+ free(st->volume.volume);
+ free(st);
+}
+
+void snd_detach_record(SpiceRecordInstance *sin)
+{
+ snd_detach_common(&sin->st->worker);
+ spice_record_state_free(sin->st);
+}
+
+void snd_set_playback_compression(int on)
+{
+ SndWorker *now = workers;
+
+ playback_compression = !!on;
+
+ for (; now; now = now->next) {
+ if (now->base_channel->type == SPICE_CHANNEL_PLAYBACK && now->connection) {
+ PlaybackChannel* playback = (PlaybackChannel*)now->connection;
+ SpicePlaybackState *st = SPICE_CONTAINEROF(now, SpicePlaybackState, worker);
+ int client_can_celt = red_channel_client_test_remote_cap(playback->base.channel_client,
+ SPICE_PLAYBACK_CAP_CELT_0_5_1);
+ int client_can_opus = red_channel_client_test_remote_cap(playback->base.channel_client,
+ SPICE_PLAYBACK_CAP_OPUS);
+ int desired_mode = snd_desired_audio_mode(st->frequency, client_can_opus, client_can_celt);
+ if (playback->mode != desired_mode) {
+ playback->mode = desired_mode;
+ snd_set_command(now->connection, SND_PLAYBACK_MODE_MASK);
+ }
+ }
+ }
+}
diff --git a/server/sound.h b/server/sound.h
new file mode 100644
index 0000000..97f8410
--- /dev/null
+++ b/server/sound.h
@@ -0,0 +1,33 @@
+/*
+ Copyright (C) 2009 Red Hat, Inc.
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef SOUND_H_
+#define SOUND_H_
+
+#include "spice.h"
+
+void snd_attach_playback(SpicePlaybackInstance *sin);
+void snd_detach_playback(SpicePlaybackInstance *sin);
+
+void snd_attach_record(SpiceRecordInstance *sin);
+void snd_detach_record(SpiceRecordInstance *sin);
+
+void snd_set_playback_compression(int on);
+
+void snd_set_playback_latency(RedClient *client, uint32_t latency);
+
+#endif
diff --git a/server/spice_image_cache.c b/server/spice_image_cache.c
deleted file mode 100644
index 1c5de24..0000000
--- a/server/spice_image_cache.c
+++ /dev/null
@@ -1,214 +0,0 @@
-/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- Copyright (C) 2009-2015 Red Hat, Inc.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, see <http://www.gnu.org/licenses/>.
-*/
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-#include "spice_image_cache.h"
-#include "red_parse_qxl.h"
-#include "display-channel.h"
-
-static ImageCacheItem *image_cache_find(ImageCache *cache, uint64_t id)
-{
- ImageCacheItem *item = cache->hash_table[id % IMAGE_CACHE_HASH_SIZE];
-
- while (item) {
- if (item->id == id) {
- return item;
- }
- item = item->next;
- }
- return NULL;
-}
-
-int image_cache_hit(ImageCache *cache, uint64_t id)
-{
- ImageCacheItem *item;
- if (!(item = image_cache_find(cache, id))) {
- return FALSE;
- }
-#ifdef IMAGE_CACHE_AGE
- item->age = cache->age;
-#endif
- ring_remove(&item->lru_link);
- ring_add(&cache->lru, &item->lru_link);
- return TRUE;
-}
-
-static void image_cache_remove(ImageCache *cache, ImageCacheItem *item)
-{
- ImageCacheItem **now;
-
- now = &cache->hash_table[item->id % IMAGE_CACHE_HASH_SIZE];
- for (;;) {
- spice_assert(*now);
- if (*now == item) {
- *now = item->next;
- break;
- }
- now = &(*now)->next;
- }
- ring_remove(&item->lru_link);
- pixman_image_unref(item->image);
- free(item);
-#ifndef IMAGE_CACHE_AGE
- cache->num_items--;
-#endif
-}
-
-#define IMAGE_CACHE_MAX_ITEMS 2
-
-static void image_cache_put(SpiceImageCache *spice_cache, uint64_t id, pixman_image_t *image)
-{
- ImageCache *cache = (ImageCache *)spice_cache;
- ImageCacheItem *item;
-
-#ifndef IMAGE_CACHE_AGE
- if (cache->num_items == IMAGE_CACHE_MAX_ITEMS) {
- ImageCacheItem *tail = (ImageCacheItem *)ring_get_tail(&cache->lru);
- spice_assert(tail);
- image_cache_remove(cache, tail);
- }
-#endif
-
- item = spice_new(ImageCacheItem, 1);
- item->id = id;
-#ifdef IMAGE_CACHE_AGE
- item->age = cache->age;
-#else
- cache->num_items++;
-#endif
- item->image = pixman_image_ref(image);
- ring_item_init(&item->lru_link);
-
- item->next = cache->hash_table[item->id % IMAGE_CACHE_HASH_SIZE];
- cache->hash_table[item->id % IMAGE_CACHE_HASH_SIZE] = item;
-
- ring_add(&cache->lru, &item->lru_link);
-}
-
-static pixman_image_t *image_cache_get(SpiceImageCache *spice_cache, uint64_t id)
-{
- ImageCache *cache = (ImageCache *)spice_cache;
-
- ImageCacheItem *item = image_cache_find(cache, id);
- if (!item) {
- spice_error("not found");
- }
- return pixman_image_ref(item->image);
-}
-
-void image_cache_init(ImageCache *cache)
-{
- static SpiceImageCacheOps image_cache_ops = {
- image_cache_put,
- image_cache_get,
- };
-
- cache->base.ops = &image_cache_ops;
- memset(cache->hash_table, 0, sizeof(cache->hash_table));
- ring_init(&cache->lru);
-#ifdef IMAGE_CACHE_AGE
- cache->age = 0;
-#else
- cache->num_items = 0;
-#endif
-}
-
-void image_cache_reset(ImageCache *cache)
-{
- ImageCacheItem *item;
-
- while ((item = (ImageCacheItem *)ring_get_head(&cache->lru))) {
- image_cache_remove(cache, item);
- }
-#ifdef IMAGE_CACHE_AGE
- cache->age = 0;
-#endif
-}
-
-#define IMAGE_CACHE_DEPTH 4
-
-void image_cache_aging(ImageCache *cache)
-{
-#ifdef IMAGE_CACHE_AGE
- ImageCacheItem *item;
-
- cache->age++;
- while ((item = (ImageCacheItem *)ring_get_tail(&cache->lru)) &&
- cache->age - item->age > IMAGE_CACHE_DEPTH) {
- image_cache_remove(cache, item);
- }
-#endif
-}
-
-void image_cache_localize(ImageCache *cache, SpiceImage **image_ptr,
- SpiceImage *image_store, Drawable *drawable)
-{
- SpiceImage *image = *image_ptr;
-
- if (image == NULL) {
- spice_assert(drawable != NULL);
- spice_assert(drawable->red_drawable->self_bitmap_image != NULL);
- *image_ptr = drawable->red_drawable->self_bitmap_image;
- return;
- }
-
- if (image_cache_hit(cache, image->descriptor.id)) {
- image_store->descriptor = image->descriptor;
- image_store->descriptor.type = SPICE_IMAGE_TYPE_FROM_CACHE;
- image_store->descriptor.flags = 0;
- *image_ptr = image_store;
- return;
- }
-
- switch (image->descriptor.type) {
- case SPICE_IMAGE_TYPE_QUIC: {
- image_store->descriptor = image->descriptor;
- image_store->u.quic = image->u.quic;
- *image_ptr = image_store;
-#ifdef IMAGE_CACHE_AGE
- image_store->descriptor.flags |= SPICE_IMAGE_FLAGS_CACHE_ME;
-#else
- if (image_store->descriptor.width * image->descriptor.height >= 640 * 480) {
- image_store->descriptor.flags |= SPICE_IMAGE_FLAGS_CACHE_ME;
- }
-#endif
- break;
- }
- case SPICE_IMAGE_TYPE_BITMAP:
- case SPICE_IMAGE_TYPE_SURFACE:
- /* nothing */
- break;
- default:
- spice_error("invalid image type");
- }
-}
-
-void image_cache_localize_brush(ImageCache *cache, SpiceBrush *brush, SpiceImage *image_store)
-{
- if (brush->type == SPICE_BRUSH_TYPE_PATTERN) {
- image_cache_localize(cache, &brush->u.pattern.pat, image_store, NULL);
- }
-}
-
-void image_cache_localize_mask(ImageCache *cache, SpiceQMask *mask, SpiceImage *image_store)
-{
- if (mask->bitmap) {
- image_cache_localize(cache, &mask->bitmap, image_store, NULL);
- }
-}
diff --git a/server/spice_image_cache.h b/server/spice_image_cache.h
deleted file mode 100644
index 6d6b32d..0000000
--- a/server/spice_image_cache.h
+++ /dev/null
@@ -1,65 +0,0 @@
-/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- Copyright (C) 2009-2015 Red Hat, Inc.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, see <http://www.gnu.org/licenses/>.
-*/
-#ifndef H_SPICE_IMAGE_CACHE
-#define H_SPICE_IMAGE_CACHE
-
-#include <inttypes.h>
-
-#include "common/pixman_utils.h"
-#include "common/canvas_base.h"
-#include "common/ring.h"
-
-/* FIXME: move back to display_channel.h (once structs are private) */
-typedef struct Drawable Drawable;
-typedef struct DisplayChannelClient DisplayChannelClient;
-
-typedef struct ImageCacheItem {
- RingItem lru_link;
- uint64_t id;
-#ifdef IMAGE_CACHE_AGE
- uint32_t age;
-#endif
- struct ImageCacheItem *next;
- pixman_image_t *image;
-} ImageCacheItem;
-
-#define IMAGE_CACHE_HASH_SIZE 1024
-
-typedef struct ImageCache {
- SpiceImageCache base;
- ImageCacheItem *hash_table[IMAGE_CACHE_HASH_SIZE];
- Ring lru;
-#ifdef IMAGE_CACHE_AGE
- uint32_t age;
-#else
- uint32_t num_items;
-#endif
-} ImageCache;
-
-int image_cache_hit (ImageCache *cache, uint64_t id);
-void image_cache_init (ImageCache *cache);
-void image_cache_reset (ImageCache *cache);
-void image_cache_aging (ImageCache *cache);
-void image_cache_localize (ImageCache *cache, SpiceImage **image_ptr,
- SpiceImage *image_store, Drawable *drawable);
-void image_cache_localize_brush (ImageCache *cache, SpiceBrush *brush,
- SpiceImage *image_store);
-void image_cache_localize_mask (ImageCache *cache, SpiceQMask *mask,
- SpiceImage *image_store);
-
-#endif
diff --git a/server/spicevmc.c b/server/spicevmc.c
index d37b1ec..52a29a4 100644
--- a/server/spicevmc.c
+++ b/server/spicevmc.c
@@ -30,10 +30,10 @@
#include "common/generated_server_marshallers.h"
-#include "char_device.h"
+#include "char-device.h"
#include "red_channel.h"
#include "reds.h"
-#include "migration_protocol.h"
+#include "migration-protocol.h"
/* todo: add flow control. i.e.,
* (a) limit the tokens available for the client
diff --git a/server/stream.h b/server/stream.h
index 214d1df..cb2b844 100644
--- a/server/stream.h
+++ b/server/stream.h
@@ -20,10 +20,10 @@
#include <glib.h>
#include "utils.h"
-#include "mjpeg_encoder.h"
+#include "mjpeg-encoder.h"
#include "common/region.h"
#include "red_channel.h"
-#include "spice_image_cache.h"
+#include "image-cache.h"
#define RED_STREAM_DETACTION_MAX_DELTA ((1000 * 1000 * 1000) / 5) // 1/5 sec
#define RED_STREAM_CONTINUS_MAX_DELTA (1000 * 1000 * 1000)
diff --git a/server/sw-canvas.c b/server/sw-canvas.c
new file mode 100644
index 0000000..0ef050e
--- /dev/null
+++ b/server/sw-canvas.c
@@ -0,0 +1,26 @@
+/*
+ Copyright (C) 2011 Red Hat, Inc.
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, see <http://www.gnu.org/licenses/>.
+*/
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "common/spice_common.h"
+
+#include "sw-canvas.h"
+#define SW_CANVAS_IMAGE_CACHE
+#include "common/sw_canvas.c"
+#undef SW_CANVAS_IMAGE_CACHE
diff --git a/server/sw-canvas.h b/server/sw-canvas.h
new file mode 100644
index 0000000..5ffba3d
--- /dev/null
+++ b/server/sw-canvas.h
@@ -0,0 +1,24 @@
+/*
+ Copyright (C) 2011 Red Hat, Inc.
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, see <http://www.gnu.org/licenses/>.
+*/
+#ifndef SW_CANVAS_H_
+#define SW_CANVAS_H_
+
+#define SW_CANVAS_IMAGE_CACHE
+#include "common/sw_canvas.h"
+#undef SW_CANVAS_IMAGE_CACHE
+
+#endif
diff --git a/server/zlib-encoder.c b/server/zlib-encoder.c
new file mode 100644
index 0000000..069a448
--- /dev/null
+++ b/server/zlib-encoder.c
@@ -0,0 +1,125 @@
+/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ Copyright (C) 2010 Red Hat, Inc.
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, see <http://www.gnu.org/licenses/>.
+*/
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "red_common.h"
+#include "zlib-encoder.h"
+#include <zlib.h>
+
+struct ZlibEncoder {
+ ZlibEncoderUsrContext *usr;
+
+ z_stream strm;
+ int last_level;
+};
+
+ZlibEncoder* zlib_encoder_create(ZlibEncoderUsrContext *usr, int level)
+{
+ ZlibEncoder *enc;
+ int z_ret;
+
+ if (!usr->more_space || !usr->more_input) {
+ return NULL;
+ }
+
+ enc = spice_new0(ZlibEncoder, 1);
+
+ enc->usr = usr;
+
+ enc->strm.zalloc = Z_NULL;
+ enc->strm.zfree = Z_NULL;
+ enc->strm.opaque = Z_NULL;
+
+ z_ret = deflateInit(&enc->strm, level);
+ enc->last_level = level;
+ if (z_ret != Z_OK) {
+ spice_printerr("zlib error");
+ free(enc);
+ return NULL;
+ }
+
+ return enc;
+}
+
+void zlib_encoder_destroy(ZlibEncoder *encoder)
+{
+ deflateEnd(&encoder->strm);
+ free(encoder);
+}
+
+/* returns the total size of the encoded data */
+int zlib_encode(ZlibEncoder *zlib, int level, int input_size,
+ uint8_t *io_ptr, unsigned int num_io_bytes)
+{
+ int flush;
+ int enc_size = 0;
+ int out_size = 0;
+ int z_ret;
+
+ z_ret = deflateReset(&zlib->strm);
+
+ if (z_ret != Z_OK) {
+ spice_error("deflateReset failed");
+ }
+
+ zlib->strm.next_out = io_ptr;
+ zlib->strm.avail_out = num_io_bytes;
+
+ if (level != zlib->last_level) {
+ if (zlib->strm.avail_out == 0) {
+ zlib->strm.avail_out = zlib->usr->more_space(zlib->usr, &zlib->strm.next_out);
+ if (zlib->strm.avail_out == 0) {
+ spice_error("not enough space");
+ }
+ }
+ z_ret = deflateParams(&zlib->strm, level, Z_DEFAULT_STRATEGY);
+ if (z_ret != Z_OK) {
+ spice_error("deflateParams failed");
+ }
+ zlib->last_level = level;
+ }
+
+
+ do {
+ zlib->strm.avail_in = zlib->usr->more_input(zlib->usr, &zlib->strm.next_in);
+ if (zlib->strm.avail_in <= 0) {
+ spice_error("more input failed");
+ }
+ enc_size += zlib->strm.avail_in;
+ flush = (enc_size == input_size) ? Z_FINISH : Z_NO_FLUSH;
+ while (1) {
+ int deflate_size = zlib->strm.avail_out;
+ z_ret = deflate(&zlib->strm, flush);
+ spice_assert(z_ret != Z_STREAM_ERROR);
+ out_size += deflate_size - zlib->strm.avail_out;
+ if (zlib->strm.avail_out) {
+ break;
+ }
+
+ zlib->strm.avail_out = zlib->usr->more_space(zlib->usr, &zlib->strm.next_out);
+ if (zlib->strm.avail_out == 0) {
+ spice_error("not enough space");
+ }
+ }
+ } while (flush != Z_FINISH);
+
+ spice_assert(z_ret == Z_STREAM_END);
+ return out_size;
+}
diff --git a/server/zlib-encoder.h b/server/zlib-encoder.h
new file mode 100644
index 0000000..0620fc7
--- /dev/null
+++ b/server/zlib-encoder.h
@@ -0,0 +1,47 @@
+/*
+ Copyright (C) 2009 Red Hat, Inc.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are
+ met:
+
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in
+ the documentation and/or other materials provided with the
+ distribution.
+ * Neither the name of the copyright holder nor the names of its
+ contributors may be used to endorse or promote products derived
+ from this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS "AS
+ IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+#ifndef _H_ZLIB_ENCODER
+#define _H_ZLIB_ENCODER
+
+typedef struct ZlibEncoder ZlibEncoder;
+typedef struct ZlibEncoderUsrContext ZlibEncoderUsrContext;
+
+struct ZlibEncoderUsrContext {
+ int (*more_space)(ZlibEncoderUsrContext *usr, uint8_t **io_ptr);
+ int (*more_input)(ZlibEncoderUsrContext *usr, uint8_t **input);
+};
+
+ZlibEncoder* zlib_encoder_create(ZlibEncoderUsrContext *usr, int level);
+void zlib_encoder_destroy(ZlibEncoder *encoder);
+
+/* returns the total size of the encoded data */
+int zlib_encode(ZlibEncoder *zlib, int level, int input_size,
+ uint8_t *io_ptr, unsigned int num_io_bytes);
+#endif
diff --git a/server/zlib_encoder.c b/server/zlib_encoder.c
deleted file mode 100644
index a3d2aa6..0000000
--- a/server/zlib_encoder.c
+++ /dev/null
@@ -1,125 +0,0 @@
-/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- Copyright (C) 2010 Red Hat, Inc.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, see <http://www.gnu.org/licenses/>.
-*/
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#include "red_common.h"
-#include "zlib_encoder.h"
-#include <zlib.h>
-
-struct ZlibEncoder {
- ZlibEncoderUsrContext *usr;
-
- z_stream strm;
- int last_level;
-};
-
-ZlibEncoder* zlib_encoder_create(ZlibEncoderUsrContext *usr, int level)
-{
- ZlibEncoder *enc;
- int z_ret;
-
- if (!usr->more_space || !usr->more_input) {
- return NULL;
- }
-
- enc = spice_new0(ZlibEncoder, 1);
-
- enc->usr = usr;
-
- enc->strm.zalloc = Z_NULL;
- enc->strm.zfree = Z_NULL;
- enc->strm.opaque = Z_NULL;
-
- z_ret = deflateInit(&enc->strm, level);
- enc->last_level = level;
- if (z_ret != Z_OK) {
- spice_printerr("zlib error");
- free(enc);
- return NULL;
- }
-
- return enc;
-}
-
-void zlib_encoder_destroy(ZlibEncoder *encoder)
-{
- deflateEnd(&encoder->strm);
- free(encoder);
-}
-
-/* returns the total size of the encoded data */
-int zlib_encode(ZlibEncoder *zlib, int level, int input_size,
- uint8_t *io_ptr, unsigned int num_io_bytes)
-{
- int flush;
- int enc_size = 0;
- int out_size = 0;
- int z_ret;
-
- z_ret = deflateReset(&zlib->strm);
-
- if (z_ret != Z_OK) {
- spice_error("deflateReset failed");
- }
-
- zlib->strm.next_out = io_ptr;
- zlib->strm.avail_out = num_io_bytes;
-
- if (level != zlib->last_level) {
- if (zlib->strm.avail_out == 0) {
- zlib->strm.avail_out = zlib->usr->more_space(zlib->usr, &zlib->strm.next_out);
- if (zlib->strm.avail_out == 0) {
- spice_error("not enough space");
- }
- }
- z_ret = deflateParams(&zlib->strm, level, Z_DEFAULT_STRATEGY);
- if (z_ret != Z_OK) {
- spice_error("deflateParams failed");
- }
- zlib->last_level = level;
- }
-
-
- do {
- zlib->strm.avail_in = zlib->usr->more_input(zlib->usr, &zlib->strm.next_in);
- if (zlib->strm.avail_in <= 0) {
- spice_error("more input failed");
- }
- enc_size += zlib->strm.avail_in;
- flush = (enc_size == input_size) ? Z_FINISH : Z_NO_FLUSH;
- while (1) {
- int deflate_size = zlib->strm.avail_out;
- z_ret = deflate(&zlib->strm, flush);
- spice_assert(z_ret != Z_STREAM_ERROR);
- out_size += deflate_size - zlib->strm.avail_out;
- if (zlib->strm.avail_out) {
- break;
- }
-
- zlib->strm.avail_out = zlib->usr->more_space(zlib->usr, &zlib->strm.next_out);
- if (zlib->strm.avail_out == 0) {
- spice_error("not enough space");
- }
- }
- } while (flush != Z_FINISH);
-
- spice_assert(z_ret == Z_STREAM_END);
- return out_size;
-}
diff --git a/server/zlib_encoder.h b/server/zlib_encoder.h
deleted file mode 100644
index 0620fc7..0000000
--- a/server/zlib_encoder.h
+++ /dev/null
@@ -1,47 +0,0 @@
-/*
- Copyright (C) 2009 Red Hat, Inc.
-
- Redistribution and use in source and binary forms, with or without
- modification, are permitted provided that the following conditions are
- met:
-
- * Redistributions of source code must retain the above copyright
- notice, this list of conditions and the following disclaimer.
- * Redistributions in binary form must reproduce the above copyright
- notice, this list of conditions and the following disclaimer in
- the documentation and/or other materials provided with the
- distribution.
- * Neither the name of the copyright holder nor the names of its
- contributors may be used to endorse or promote products derived
- from this software without specific prior written permission.
-
- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS "AS
- IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
- PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-#ifndef _H_ZLIB_ENCODER
-#define _H_ZLIB_ENCODER
-
-typedef struct ZlibEncoder ZlibEncoder;
-typedef struct ZlibEncoderUsrContext ZlibEncoderUsrContext;
-
-struct ZlibEncoderUsrContext {
- int (*more_space)(ZlibEncoderUsrContext *usr, uint8_t **io_ptr);
- int (*more_input)(ZlibEncoderUsrContext *usr, uint8_t **input);
-};
-
-ZlibEncoder* zlib_encoder_create(ZlibEncoderUsrContext *usr, int level);
-void zlib_encoder_destroy(ZlibEncoder *encoder);
-
-/* returns the total size of the encoded data */
-int zlib_encode(ZlibEncoder *zlib, int level, int input_size,
- uint8_t *io_ptr, unsigned int num_io_bytes);
-#endif
--
2.4.3
_______________________________________________
Spice-devel mailing list
Spice-devel@xxxxxxxxxxxxxxxxxxxxx
http://lists.freedesktop.org/mailman/listinfo/spice-devel