[Spice-devel] [PATCH] spice server: surface create/destroy protocol support
Izik Eidus
ieidus at redhat.com
Wed Feb 17 15:17:57 PST 2010
From 6b42069c3ce54060d694ce2289bfd41a95b673fc Mon Sep 17 00:00:00 2001
From: Izik Eidus <ieidus at redhat.com>
Date: Thu, 18 Feb 2010 01:11:33 +0200
Subject: [PATCH] spice server: surface create/destroy protocol support
Now we can send commands from the server to the client
to destroy surfaces (right now just the primary surface)
(Needed for offscreens support)
Another patch`s on the way.
Signed-off-by: Izik Eidus <ieidus at redhat.com>
---
client/debug.h | 5 +
client/display_channel.cpp | 147 ++++++++++++++++++++--------
client/display_channel.h | 8 ++
server/red_worker.c | 227 +++++++++++++++++++++++++++++++++-----------
4 files changed, 288 insertions(+), 99 deletions(-)
diff --git a/client/debug.h b/client/debug.h
index 1c6f6a4..ce8fc98 100644
--- a/client/debug.h
+++ b/client/debug.h
@@ -92,6 +92,11 @@ LOG4CPP_LOGGER("spice")
ON_PANIC(); \
}
+#define PANIC_ON(x) if ((x)) { \
+ LOG(FATAL, "%s panic %s\n", __FUNCTION__, #x); \
+ ON_PANIC(); \
+}
+
#define DBGLEVEL 1000
#define DBG(level, format, ...) { \
diff --git a/client/display_channel.cpp b/client/display_channel.cpp
index a60832a..513ab7b 100644
--- a/client/display_channel.cpp
+++ b/client/display_channel.cpp
@@ -46,9 +46,9 @@
static Mutex avcodec_mutex;
-class SetModeEvent: public SyncEvent {
+class CreatePrimarySurfaceEvent: public SyncEvent {
public:
- SetModeEvent(DisplayChannel& channel, int width, int height, int depth)
+ CreatePrimarySurfaceEvent(DisplayChannel& channel, int width, int height, int depth)
: _channel (channel)
, _width (width)
, _height (height)
@@ -59,7 +59,6 @@ public:
virtual void do_response(AbstractProcessLoop& events_loop)
{
Application* app = (Application*)events_loop.get_owner();
- _channel.destroy_canvas();
_channel.screen()->lock_size();
_channel.screen()->resize(_width, _height);
_channel.create_canvas(app->get_canvas_types(), _width, _height, _depth);
@@ -72,6 +71,22 @@ private:
int _depth;
};
+class DestroyPrimarySurfaceEvent: public SyncEvent {
+public:
+ DestroyPrimarySurfaceEvent(DisplayChannel& channel)
+ : _channel (channel)
+ {
+ }
+
+ virtual void do_response(AbstractProcessLoop& events_loop)
+ {
+ _channel.destroy_canvas();
+ }
+
+private:
+ DisplayChannel& _channel;
+};
+
class UnlockScreenEvent: public Event {
public:
UnlockScreenEvent(RedScreen* screen)
@@ -664,7 +679,6 @@ DisplayChannel::DisplayChannel(RedClient& client, uint32_t id,
sizeof(SpiceMsgDisconnect));
handler->set_handler(SPICE_MSG_NOTIFY, &DisplayChannel::handle_notify, sizeof(SpiceMsgNotify));
- handler->set_handler(SPICE_MSG_DISPLAY_MODE, &DisplayChannel::handle_mode, sizeof(SpiceMsgDisplayMode));
handler->set_handler(SPICE_MSG_DISPLAY_MARK, &DisplayChannel::handle_mark, 0);
handler->set_handler(SPICE_MSG_DISPLAY_RESET, &DisplayChannel::handle_reset, 0);
@@ -688,6 +702,11 @@ DisplayChannel::DisplayChannel(RedClient& client, uint32_t id,
handler->set_handler(SPICE_MSG_DISPLAY_STREAM_DESTROY_ALL,
&DisplayChannel::handle_stream_destroy_all, 0);
+ handler->set_handler(SPICE_MSG_DISPLAY_SURFACE_CREATE, &DisplayChannel::handle_surface_create,
+ sizeof(SpiceMsgSurfaceCreate));
+ handler->set_handler(SPICE_MSG_DISPLAY_SURFACE_DESTROY, &DisplayChannel::handle_surface_destroy,
+ sizeof(SpiceMsgSurfaceDestroy));
+
get_process_loop().add_trigger(_streams_trigger);
#ifdef USE_OGL
get_process_loop().add_trigger(_gl_interrupt_recreate);
@@ -1228,44 +1247,6 @@ void DisplayChannel::create_canvas(const std::vector<int>& canvas_types, int wid
set_draw_handlers();
}
-void DisplayChannel::handle_mode(RedPeer::InMessage* message)
-{
- SpiceMsgDisplayMode *mode = (SpiceMsgDisplayMode *)message->data();
-
- _mark = false;
- attach_to_screen(get_client().get_application(), get_id());
- clear_area();
-#ifdef USE_OGL
- if (screen()) {
- if (_canvas.get()) {
- if (_canvas->get_pixmap_type() == CANVAS_TYPE_GL) {
- screen()->unset_type_gl();
- screen()->untouch_context();
- }
- }
- }
-#endif
- AutoRef<SetModeEvent> event(new SetModeEvent(*this, mode->x_res,
- mode->y_res, mode->bits));
- get_client().push_event(*event);
- (*event)->wait();
- if (!(*event)->success()) {
- THROW("set mode failed");
- }
-
- _x_res = mode->x_res;
- _y_res = mode->y_res;
- _depth = mode->bits;
-
-#ifdef USE_OGL
- if (_canvas->get_pixmap_type() == CANVAS_TYPE_GL) {
- ((GCanvas *)(_canvas.get()))->touch_context();
- screen()->set_update_interrupt_trigger(&_interrupt_update);
- screen()->set_type_gl();
- }
-#endif
-}
-
void DisplayChannel::handle_mark(RedPeer::InMessage *message)
{
_mark = true;
@@ -1367,6 +1348,7 @@ void DisplayChannel::handle_stream_create(RedPeer::InMessage* message)
{
SpiceMsgDisplayStreamCreate* stream_create = (SpiceMsgDisplayStreamCreate*)message->data();
+ PANIC_ON(stream_create->surface_id != 0);
Lock lock(_streams_lock);
if (_streams.size() <= stream_create->id) {
_streams.resize(stream_create->id + 1);
@@ -1465,6 +1447,74 @@ void DisplayChannel::handle_stream_destroy_all(RedPeer::InMessage* message)
destroy_strams();
}
+void DisplayChannel::create_primary_surface(int width, int height, int depth)
+{
+ _mark = false;
+ attach_to_screen(get_client().get_application(), get_id());
+ clear_area();
+
+ AutoRef<CreatePrimarySurfaceEvent> event(new CreatePrimarySurfaceEvent(*this, width, height,
+ depth));
+ get_client().push_event(*event);
+ (*event)->wait();
+ if (!(*event)->success()) {
+ THROW("Create primary surface failed");
+ }
+
+ _x_res = width;
+ _y_res = height;
+ _depth = depth;
+
+#ifdef USE_OGL
+ if (_canvas->get_pixmap_type() == CANVAS_TYPE_GL) {
+ ((GCanvas *)(_canvas.get()))->touch_context();
+ screen()->set_update_interrupt_trigger(&_interrupt_update);
+ screen()->set_type_gl();
+ }
+#endif
+}
+
+void DisplayChannel::destroy_primary_surface()
+{
+#ifdef USE_OGL
+ if (screen()) {
+ if (_canvas.get()) {
+ if (_canvas->get_pixmap_type() == CANVAS_TYPE_GL) {
+ screen()->unset_type_gl();
+ screen()->untouch_context();
+ }
+ }
+ }
+#endif
+
+ AutoRef<DestroyPrimarySurfaceEvent> event(new DestroyPrimarySurfaceEvent(*this));
+ get_client().push_event(*event);
+ (*event)->wait();
+ if (!(*event)->success()) {
+ THROW("Destroying primary surface failed");
+ }
+
+ AutoRef<UnlockScreenEvent> unlock_event(new UnlockScreenEvent(screen()));
+ get_client().push_event(*unlock_event);
+}
+
+void DisplayChannel::handle_surface_create(RedPeer::InMessage* message)
+{
+ SpiceMsgSurfaceCreate* surface_create = (SpiceMsgSurfaceCreate*)message->data();
+ PANIC_ON(surface_create->surface_id != 0);
+ PANIC_ON(surface_create->flags != SPICE_SURFACE_FLAGS_PRIMARY);
+
+ create_primary_surface(surface_create->width, surface_create->height, surface_create->depth);
+}
+
+void DisplayChannel::handle_surface_destroy(RedPeer::InMessage* message)
+{
+ SpiceMsgSurfaceDestroy* surface_destroy = (SpiceMsgSurfaceDestroy*)message->data();
+ PANIC_ON(surface_destroy->surface_id != 0);
+
+ destroy_primary_surface();
+}
+
#define PRE_DRAW
#define POST_DRAW
@@ -1478,6 +1528,7 @@ void DisplayChannel::handle_stream_destroy_all(RedPeer::InMessage* message)
void DisplayChannel::handle_copy_bits(RedPeer::InMessage* message)
{
SpiceMsgDisplayCopyBits* copy_bits = (SpiceMsgDisplayCopyBits*)message->data();
+ PANIC_ON(copy_bits->base.surface_id != 0);
PRE_DRAW;
_canvas->copy_bits(*copy_bits, message->size());
POST_DRAW;
@@ -1487,72 +1538,84 @@ void DisplayChannel::handle_copy_bits(RedPeer::InMessage* message)
void DisplayChannel::handle_draw_fill(RedPeer::InMessage* message)
{
SpiceMsgDisplayDrawFill* fill = (SpiceMsgDisplayDrawFill*)message->data();
+ PANIC_ON(fill->base.surface_id != 0);
DRAW(fill);
}
void DisplayChannel::handle_draw_opaque(RedPeer::InMessage* message)
{
SpiceMsgDisplayDrawOpaque* opaque = (SpiceMsgDisplayDrawOpaque*)message->data();
+ PANIC_ON(opaque->base.surface_id != 0);
DRAW(opaque);
}
void DisplayChannel::handle_draw_copy(RedPeer::InMessage* message)
{
SpiceMsgDisplayDrawCopy* copy = (SpiceMsgDisplayDrawCopy*)message->data();
+ PANIC_ON(copy->base.surface_id != 0);
DRAW(copy);
}
void DisplayChannel::handle_draw_blend(RedPeer::InMessage* message)
{
SpiceMsgDisplayDrawBlend* blend = (SpiceMsgDisplayDrawBlend*)message->data();
+ PANIC_ON(blend->base.surface_id != 0);
DRAW(blend);
}
void DisplayChannel::handle_draw_blackness(RedPeer::InMessage* message)
{
SpiceMsgDisplayDrawBlackness* blackness = (SpiceMsgDisplayDrawBlackness*)message->data();
+ PANIC_ON(blackness->base.surface_id != 0);
DRAW(blackness);
}
void DisplayChannel::handle_draw_whiteness(RedPeer::InMessage* message)
{
SpiceMsgDisplayDrawWhiteness* whiteness = (SpiceMsgDisplayDrawWhiteness*)message->data();
+ PANIC_ON(whiteness->base.surface_id != 0);
DRAW(whiteness);
}
void DisplayChannel::handle_draw_invers(RedPeer::InMessage* message)
{
SpiceMsgDisplayDrawInvers* invers = (SpiceMsgDisplayDrawInvers*)message->data();
+ PANIC_ON(invers->base.surface_id != 0);
DRAW(invers);
}
void DisplayChannel::handle_draw_rop3(RedPeer::InMessage* message)
{
SpiceMsgDisplayDrawRop3* rop3 = (SpiceMsgDisplayDrawRop3*)message->data();
+ PANIC_ON(rop3->base.surface_id != 0);
DRAW(rop3);
}
void DisplayChannel::handle_draw_stroke(RedPeer::InMessage* message)
{
SpiceMsgDisplayDrawStroke* stroke = (SpiceMsgDisplayDrawStroke*)message->data();
+ PANIC_ON(stroke->base.surface_id != 0);
DRAW(stroke);
}
void DisplayChannel::handle_draw_text(RedPeer::InMessage* message)
{
SpiceMsgDisplayDrawText* text = (SpiceMsgDisplayDrawText*)message->data();
+ PANIC_ON(text->base.surface_id != 0);
DRAW(text);
}
void DisplayChannel::handle_draw_transparent(RedPeer::InMessage* message)
{
SpiceMsgDisplayDrawTransparent* transparent = (SpiceMsgDisplayDrawTransparent*)message->data();
+ PANIC_ON(transparent->base.surface_id != 0);
DRAW(transparent);
}
void DisplayChannel::handle_draw_alpha_blend(RedPeer::InMessage* message)
{
SpiceMsgDisplayDrawAlphaBlend* alpha_blend = (SpiceMsgDisplayDrawAlphaBlend*)message->data();
+ PANIC_ON(alpha_blend->base.surface_id != 0);
DRAW(alpha_blend);
}
diff --git a/client/display_channel.h b/client/display_channel.h
index 802898f..b3157d9 100644
--- a/client/display_channel.h
+++ b/client/display_channel.h
@@ -132,6 +132,9 @@ private:
void destroy_strams();
void update_cursor();
+ void create_primary_surface(int width, int height, int depth);
+ void destroy_primary_surface();
+
void handle_mode(RedPeer::InMessage* message);
void handle_mark(RedPeer::InMessage* message);
void handle_reset(RedPeer::InMessage* message);
@@ -147,6 +150,9 @@ private:
void handle_stream_destroy(RedPeer::InMessage* message);
void handle_stream_destroy_all(RedPeer::InMessage* message);
+ void handle_surface_create(RedPeer::InMessage* message);
+ void handle_surface_destroy(RedPeer::InMessage* message);
+
void handle_draw_fill(RedPeer::InMessage* message);
void handle_draw_opaque(RedPeer::InMessage* message);
void handle_draw_copy(RedPeer::InMessage* message);
@@ -209,6 +215,8 @@ private:
InterruptUpdate _interrupt_update;
friend class SetModeEvent;
+ friend class CreatePrimarySurfaceEvent;
+ friend class DestroyPrimarySurfaceEvent;
friend class ActivateTimerEvent;
friend class VideoStream;
friend class StreamsTrigger;
diff --git a/server/red_worker.c b/server/red_worker.c
index 2b50b9f..7ad938a 100644
--- a/server/red_worker.c
+++ b/server/red_worker.c
@@ -221,7 +221,6 @@ typedef struct BufDescriptor {
enum {
PIPE_ITEM_TYPE_DRAW,
- PIPE_ITEM_TYPE_MODE,
PIPE_ITEM_TYPE_INVAL_ONE,
PIPE_ITEM_TYPE_CURSOR,
PIPE_ITEM_TYPE_MIGRATE,
@@ -239,6 +238,8 @@ enum {
PIPE_ITEM_TYPE_PIXMAP_RESET,
PIPE_ITEM_TYPE_INVAL_CURSOR_CACHE,
PIPE_ITEM_TYPE_INVAL_PALLET_CACHE,
+ PIPE_ITEM_TYPE_CREATE_SURFACE,
+ PIPE_ITEM_TYPE_DESTROY_SURFACE,
};
typedef struct PipeItem {
@@ -279,6 +280,16 @@ struct CacheItem {
uint32_t inval_type;
};
+typedef struct SurfaceCreateItem {
+ SpiceMsgSurfaceCreate surface_create;
+ PipeItem pipe_item;
+} SurfaceCreateItem;
+
+typedef struct SurfaceDestroyItem {
+ SpiceMsgSurfaceDestroy surface_destroy;
+ PipeItem pipe_item;
+} SurfaceDestroyItem;
+
enum {
CURSOR_TYPE_INVALID,
CURSOR_TYPE_DEV,
@@ -627,6 +638,8 @@ struct DisplayChannel {
Ring glz_drawables_inst_to_free; // list of instances to be freed
pthread_mutex_t glz_drawables_inst_to_free_lock;
+ uint8_t surface_client_created;
+
struct {
union {
SpiceMsgDisplayDrawFill fill;
@@ -644,6 +657,8 @@ struct DisplayChannel {
SpiceMsgDisplayDrawText text;
SpiceMsgDisplayMode mode;
SpiceMsgDisplayInvalOne inval_one;
+ SpiceMsgSurfaceCreate surface_create;
+ SpiceMsgSurfaceDestroy surface_destroy;
WaitForChannels wait;
struct {
SpiceMsgDisplayStreamCreate message;
@@ -878,10 +893,10 @@ typedef struct DrawContext {
void *line_0;
} DrawContext;
-typedef struct Surface {
+typedef struct RedSurface {
uint32_t refs;
DrawContext context;
-} Surface;
+} RedSurface;
#ifdef STREAM_TRACE
typedef struct ItemTrace {
@@ -928,7 +943,7 @@ typedef struct RedWorker {
uint32_t renderer;
DrawFuncs draw_funcs;
- Surface surface;
+ RedSurface surface;
Ring current_list;
Ring current;
@@ -1452,7 +1467,6 @@ static void red_pipe_clear(RedChannel *channel)
case PIPE_ITEM_TYPE_PIXMAP_RESET:
case PIPE_ITEM_TYPE_PIXMAP_SYNC:
case PIPE_ITEM_TYPE_INVAL_ONE:
- case PIPE_ITEM_TYPE_MODE:
case PIPE_ITEM_TYPE_MIGRATE:
case PIPE_ITEM_TYPE_SET_ACK:
case PIPE_ITEM_TYPE_CURSOR_INIT:
@@ -1460,6 +1474,8 @@ static void red_pipe_clear(RedChannel *channel)
case PIPE_ITEM_TYPE_MIGRATE_DATA:
case PIPE_ITEM_TYPE_INVAL_PALLET_CACHE:
case PIPE_ITEM_TYPE_INVAL_CURSOR_CACHE:
+ case PIPE_ITEM_TYPE_CREATE_SURFACE:
+ case PIPE_ITEM_TYPE_DESTROY_SURFACE:
free(item);
break;
case PIPE_ITEM_TYPE_IMAGE:
@@ -1533,9 +1549,36 @@ static void drawables_init(RedWorker *worker)
static void red_reset_stream_trace(RedWorker *worker);
+static SurfaceDestroyItem *get_surface_destroy_item(uint32_t surface_id)
+{
+ SurfaceDestroyItem *destroy;
+
+ destroy = (SurfaceDestroyItem *)malloc(sizeof(SurfaceDestroyItem));
+ PANIC_ON(!destroy);
+
+ destroy->surface_destroy.surface_id = surface_id;
+
+ red_pipe_item_init(&destroy->pipe_item, PIPE_ITEM_TYPE_DESTROY_SURFACE);
+
+ return destroy;
+}
+
+static inline void red_destroy_surface_item(RedWorker *worker, uint32_t surface_id)
+{
+ SurfaceDestroyItem *destroy;
+
+ if (!worker->display_channel) {
+ return;
+ }
+
+ destroy = get_surface_destroy_item(surface_id);
+
+ red_pipe_add(&worker->display_channel->base, &destroy->pipe_item);
+}
+
static inline void __red_destroy_surface(RedWorker *worker)
{
- Surface *surface = &worker->surface;
+ RedSurface *surface = &worker->surface;
if (!--worker->surface.refs) {
#ifdef STREAM_TRACE
@@ -1543,12 +1586,13 @@ static inline void __red_destroy_surface(RedWorker *worker)
#endif
worker->draw_funcs.destroy(surface->context.canvas);
surface->context.canvas = NULL;
+ red_destroy_surface_item(worker, 0);
}
}
static inline void red_destroy_surface(RedWorker *worker)
{
- Surface *surface = &worker->surface;
+ RedSurface *surface = &worker->surface;
PANIC_ON(!surface->context.canvas);
__red_destroy_surface(worker);
@@ -4777,10 +4821,11 @@ static inline void fill_rects_clip(RedChannel *channel, QXLPHYSICAL *in_clip, ui
}
static void fill_base(DisplayChannel *display_channel, SpiceMsgDisplayBase *base, Drawable *drawable,
- uint32_t size)
+ uint32_t size, uint32_t surface_id)
{
RedChannel *channel = &display_channel->base;
add_buf(channel, BUF_TYPE_RAW, base, size, 0, 0);
+ base->surface_id = surface_id;
base->box = drawable->qxl_drawable->bbox;
base->clip = drawable->qxl_drawable->clip;
@@ -6183,7 +6228,7 @@ static inline void red_send_qxl_drawable(RedWorker *worker, DisplayChannel *disp
case QXL_DRAW_FILL:
channel->send_data.header.type = SPICE_MSG_DISPLAY_DRAW_FILL;
fill_base(display_channel, &display_channel->send_data.u.fill.base, item,
- sizeof(SpiceMsgDisplayDrawFill));
+ sizeof(SpiceMsgDisplayDrawFill), 0);
display_channel->send_data.u.fill.data = drawable->u.fill;
fill_brush(display_channel, &display_channel->send_data.u.fill.data.brush, item);
fill_mask(display_channel, &display_channel->send_data.u.fill.data.mask, item);
@@ -6191,7 +6236,7 @@ static inline void red_send_qxl_drawable(RedWorker *worker, DisplayChannel *disp
case QXL_DRAW_OPAQUE:
channel->send_data.header.type = SPICE_MSG_DISPLAY_DRAW_OPAQUE;
fill_base(display_channel, &display_channel->send_data.u.opaque.base, item,
- sizeof(SpiceMsgDisplayDrawOpaque));
+ sizeof(SpiceMsgDisplayDrawOpaque), 0);
display_channel->send_data.u.opaque.data = drawable->u.opaque;
fill_bits(display_channel, &display_channel->send_data.u.opaque.data.src_bitmap, item);
fill_brush(display_channel, &display_channel->send_data.u.opaque.data.brush, item);
@@ -6199,7 +6244,8 @@ static inline void red_send_qxl_drawable(RedWorker *worker, DisplayChannel *disp
break;
case QXL_DRAW_COPY:
channel->send_data.header.type = SPICE_MSG_DISPLAY_DRAW_COPY;
- fill_base(display_channel, &display_channel->send_data.u.copy.base, item, sizeof(SpiceMsgDisplayDrawCopy));
+ fill_base(display_channel, &display_channel->send_data.u.copy.base, item,
+ sizeof(SpiceMsgDisplayDrawCopy), 0);
display_channel->send_data.u.copy.data = drawable->u.copy;
fill_bits(display_channel, &display_channel->send_data.u.copy.data.src_bitmap, item);
fill_mask(display_channel, &display_channel->send_data.u.copy.data.mask, item);
@@ -6207,27 +6253,27 @@ static inline void red_send_qxl_drawable(RedWorker *worker, DisplayChannel *disp
case QXL_DRAW_TRANSPARENT:
channel->send_data.header.type = SPICE_MSG_DISPLAY_DRAW_TRANSPARENT;
fill_base(display_channel, &display_channel->send_data.u.transparent.base, item,
- sizeof(SpiceMsgDisplayDrawTransparent));
+ sizeof(SpiceMsgDisplayDrawTransparent), 0);
display_channel->send_data.u.transparent.data = drawable->u.transparent;
fill_bits(display_channel, &display_channel->send_data.u.transparent.data.src_bitmap, item);
break;
case QXL_DRAW_ALPHA_BLEND:
channel->send_data.header.type = SPICE_MSG_DISPLAY_DRAW_ALPHA_BLEND;
fill_base(display_channel, &display_channel->send_data.u.alpha_blend.base, item,
- sizeof(SpiceMsgDisplayDrawAlphaBlend));
+ sizeof(SpiceMsgDisplayDrawAlphaBlend), 0);
display_channel->send_data.u.alpha_blend.data = drawable->u.alpha_blend;
fill_bits(display_channel, &display_channel->send_data.u.alpha_blend.data.src_bitmap, item);
break;
case QXL_COPY_BITS:
channel->send_data.header.type = SPICE_MSG_DISPLAY_COPY_BITS;
fill_base(display_channel, &display_channel->send_data.u.copy_bits.base, item,
- sizeof(SpiceMsgDisplayCopyBits));
+ sizeof(SpiceMsgDisplayCopyBits), 0);
display_channel->send_data.u.copy_bits.src_pos = drawable->u.copy_bits.src_pos;
break;
case QXL_DRAW_BLEND:
channel->send_data.header.type = SPICE_MSG_DISPLAY_DRAW_BLEND;
fill_base(display_channel, &display_channel->send_data.u.blend.base, item,
- sizeof(SpiceMsgDisplayDrawBlend));
+ sizeof(SpiceMsgDisplayDrawBlend), 0);
display_channel->send_data.u.blend.data = drawable->u.blend;
fill_bits(display_channel, &display_channel->send_data.u.blend.data.src_bitmap, item);
fill_mask(display_channel, &display_channel->send_data.u.blend.data.mask, item);
@@ -6235,28 +6281,28 @@ static inline void red_send_qxl_drawable(RedWorker *worker, DisplayChannel *disp
case QXL_DRAW_BLACKNESS:
channel->send_data.header.type = SPICE_MSG_DISPLAY_DRAW_BLACKNESS;
fill_base(display_channel, &display_channel->send_data.u.blackness.base, item,
- sizeof(SpiceMsgDisplayDrawBlackness));
+ sizeof(SpiceMsgDisplayDrawBlackness), 0);
display_channel->send_data.u.blackness.data = drawable->u.blackness;
fill_mask(display_channel, &display_channel->send_data.u.blackness.data.mask, item);
break;
case QXL_DRAW_WHITENESS:
channel->send_data.header.type = SPICE_MSG_DISPLAY_DRAW_WHITENESS;
fill_base(display_channel, &display_channel->send_data.u.whiteness.base, item,
- sizeof(SpiceMsgDisplayDrawWhiteness));
+ sizeof(SpiceMsgDisplayDrawWhiteness), 0);
display_channel->send_data.u.whiteness.data = drawable->u.whiteness;
fill_mask(display_channel, &display_channel->send_data.u.whiteness.data.mask, item);
break;
case QXL_DRAW_INVERS:
channel->send_data.header.type = SPICE_MSG_DISPLAY_DRAW_INVERS;
fill_base(display_channel, &display_channel->send_data.u.invers.base, item,
- sizeof(SpiceMsgDisplayDrawInvers));
+ sizeof(SpiceMsgDisplayDrawInvers), 0);
display_channel->send_data.u.invers.data = drawable->u.invers;
fill_mask(display_channel, &display_channel->send_data.u.invers.data.mask, item);
break;
case QXL_DRAW_ROP3:
channel->send_data.header.type = SPICE_MSG_DISPLAY_DRAW_ROP3;
fill_base(display_channel, &display_channel->send_data.u.rop3.base, item,
- sizeof(SpiceMsgDisplayDrawRop3));
+ sizeof(SpiceMsgDisplayDrawRop3), 0);
display_channel->send_data.u.rop3.data = drawable->u.rop3;
fill_bits(display_channel, &display_channel->send_data.u.rop3.data.src_bitmap, item);
fill_brush(display_channel, &display_channel->send_data.u.rop3.data.brush, item);
@@ -6265,7 +6311,7 @@ static inline void red_send_qxl_drawable(RedWorker *worker, DisplayChannel *disp
case QXL_DRAW_STROKE:
channel->send_data.header.type = SPICE_MSG_DISPLAY_DRAW_STROKE;
fill_base(display_channel, &display_channel->send_data.u.stroke.base, item,
- sizeof(SpiceMsgDisplayDrawStroke));
+ sizeof(SpiceMsgDisplayDrawStroke), 0);
display_channel->send_data.u.stroke.data = drawable->u.stroke;
fill_path(display_channel, &display_channel->send_data.u.stroke.data.path, item->group_id);
fill_attr(display_channel, &display_channel->send_data.u.stroke.data.attr, item->group_id);
@@ -6273,7 +6319,8 @@ static inline void red_send_qxl_drawable(RedWorker *worker, DisplayChannel *disp
break;
case QXL_DRAW_TEXT:
channel->send_data.header.type = SPICE_MSG_DISPLAY_DRAW_TEXT;
- fill_base(display_channel, &display_channel->send_data.u.text.base, item, sizeof(SpiceMsgDisplayDrawText));
+ fill_base(display_channel, &display_channel->send_data.u.text.base, item,
+ sizeof(SpiceMsgDisplayDrawText), 0);
display_channel->send_data.u.text.data = drawable->u.text;
fill_brush(display_channel, &display_channel->send_data.u.text.data.fore_brush, item);
fill_brush(display_channel, &display_channel->send_data.u.text.data.back_brush, item);
@@ -6737,29 +6784,6 @@ static inline void send_qxl_drawable(DisplayChannel *display_channel, Drawable *
red_send_qxl_drawable(display_channel->base.worker, display_channel, item);
}
-static void red_send_mode(DisplayChannel *display_channel)
-{
- RedChannel *channel;
- RedWorker *worker;
-
- ASSERT(display_channel);
- worker = display_channel->base.worker;
-
- if (!worker->surface.context.canvas) {
- return;
- }
-
- channel = &display_channel->base;
- channel->send_data.header.type = SPICE_MSG_DISPLAY_MODE;
- display_channel->send_data.u.mode.x_res = worker->surface.context.width;
- display_channel->send_data.u.mode.y_res = worker->surface.context.height;
- display_channel->send_data.u.mode.bits = worker->surface.context.depth;
-
- add_buf(channel, BUF_TYPE_RAW, &display_channel->send_data.u.mode, sizeof(SpiceMsgDisplayMode), 0, 0);
-
- display_begin_send_massage(display_channel, NULL);
-}
-
static void red_send_set_ack(RedChannel *channel)
{
ASSERT(channel);
@@ -6920,6 +6944,7 @@ static void red_send_image(DisplayChannel *display_channel, ImageItem *item)
channel->send_data.header.type = SPICE_MSG_DISPLAY_DRAW_COPY;
add_buf(channel, BUF_TYPE_RAW, &display_channel->send_data.u.copy, sizeof(SpiceMsgDisplayDrawCopy), 0, 0);
+ display_channel->send_data.u.copy.base.surface_id = 0;
display_channel->send_data.u.copy.base.box.left = item->pos.x;
display_channel->send_data.u.copy.base.box.top = item->pos.y;
display_channel->send_data.u.copy.base.box.right = item->pos.x + bitmap.x;
@@ -6970,6 +6995,7 @@ static void red_display_send_upgrade(DisplayChannel *display_channel, UpgradeIte
ASSERT(qxl_drawable->u.copy.mask.bitmap == 0);
add_buf(channel, BUF_TYPE_RAW, copy, sizeof(SpiceMsgDisplayDrawCopy), 0, 0);
+ copy->base.surface_id = 0;
copy->base.box = qxl_drawable->bbox;
copy->base.clip.type = SPICE_CLIP_TYPE_RECTS;
copy->base.clip.data = channel->send_data.header.size;
@@ -6990,6 +7016,7 @@ static void red_display_send_stream_start(DisplayChannel *display_channel, Strea
ASSERT(stream);
channel->send_data.header.type = SPICE_MSG_DISPLAY_STREAM_CREATE;
SpiceMsgDisplayStreamCreate *stream_create = &display_channel->send_data.u.stream_create.message;
+ stream_create->surface_id = 0;
stream_create->id = agent - display_channel->stream_agents;
stream_create->flags = stream->top_down ? SPICE_STREAM_FLAGS_TOP_DOWN : 0;
stream_create->codec_type = SPICE_VIDEO_CODEC_TYPE_MJPEG;
@@ -7154,6 +7181,41 @@ static void red_send_cursor(CursorChannel *cursor_channel, CursorItem *cursor)
red_release_cursor(channel->worker, cursor);
}
+static void red_send_surface_create(DisplayChannel *display, SpiceMsgSurfaceCreate *surface_create)
+{
+ RedChannel *channel;
+
+ ASSERT(display);
+ channel = &display->base;
+
+ channel->send_data.header.type = SPICE_MSG_DISPLAY_SURFACE_CREATE;
+ display->send_data.u.surface_create = *surface_create;
+
+ add_buf(channel, BUF_TYPE_RAW, &display->send_data.u.surface_create,
+ sizeof(SpiceMsgSurfaceCreate), 0, 0);
+
+ display->surface_client_created = TRUE;
+
+ red_begin_send_massage(channel, NULL);
+}
+
+static void red_send_surface_destroy(DisplayChannel *display, uint32_t surface_id)
+{
+ RedChannel *channel;
+
+ ASSERT(display);
+ channel = &display->base;
+
+ channel->send_data.header.type = SPICE_MSG_DISPLAY_SURFACE_DESTROY;
+ display->send_data.u.surface_destroy.surface_id = surface_id;
+
+ add_buf(channel, BUF_TYPE_RAW, &display->send_data.u.surface_destroy,
+ sizeof(SpiceMsgSurfaceDestroy), 0, 0);
+
+ display->surface_client_created = FALSE;
+ red_begin_send_massage(channel, NULL);
+}
+
static inline PipeItem *red_pipe_get(RedChannel *channel)
{
PipeItem *item;
@@ -7217,10 +7279,6 @@ static void display_channel_push(RedWorker *worker)
display_send_verb(display_channel, ((VerbItem*)pipe_item)->verb);
free(pipe_item);
break;
- case PIPE_ITEM_TYPE_MODE:
- red_send_mode(display_channel);
- free(pipe_item);
- break;
case PIPE_ITEM_TYPE_MIGRATE:
red_printf("PIPE_ITEM_TYPE_MIGRATE");
display_channel_send_migrate(display_channel);
@@ -7251,6 +7309,20 @@ static void display_channel_push(RedWorker *worker)
red_send_verb((RedChannel *)display_channel, SPICE_MSG_DISPLAY_INVAL_ALL_PALETTES);
free(pipe_item);
break;
+ case PIPE_ITEM_TYPE_CREATE_SURFACE: {
+ SurfaceCreateItem *surface_create = CONTAINEROF(pipe_item, SurfaceCreateItem,
+ pipe_item);
+ red_send_surface_create(display_channel, &surface_create->surface_create);
+ free(surface_create);
+ break;
+ }
+ case PIPE_ITEM_TYPE_DESTROY_SURFACE: {
+ SurfaceDestroyItem *surface_destroy = CONTAINEROF(pipe_item, SurfaceDestroyItem,
+ pipe_item);
+ red_send_surface_destroy(display_channel, surface_destroy->surface_destroy.surface_id);
+ free(surface_destroy);
+ break;
+ }
default:
red_error("invalid pipe item type");
}
@@ -7617,7 +7689,7 @@ static inline void surface_init_draw_funcs(RedWorker *worker, uint32_t renderer)
};
}
-static inline void *create_canvas_for_surface(RedWorker *worker, Surface *surface,
+static inline void *create_canvas_for_surface(RedWorker *worker, RedSurface *surface,
uint32_t renderer, uint32_t width, uint32_t height,
int32_t stride, uint8_t depth, void *line_0)
{
@@ -7641,16 +7713,55 @@ static inline void *create_canvas_for_surface(RedWorker *worker, Surface *surfac
};
}
-static inline void red_create_surface(RedWorker *worker, uint32_t width, uint32_t height,
- int32_t stride, uint8_t depth, void *line_0)
+static SurfaceCreateItem *get_surface_create_item(uint32_t surface_id, uint32_t width,
+ uint32_t height, int32_t stride, uint8_t depth,
+ uint32_t flags)
+{
+ SurfaceCreateItem *create;
+
+ create = (SurfaceCreateItem *)malloc(sizeof(SurfaceCreateItem));
+ PANIC_ON(!create);
+
+ create->surface_create.surface_id = surface_id;
+ create->surface_create.width = width;
+ create->surface_create.height = height;
+ create->surface_create.stride = stride;
+ create->surface_create.flags = flags;
+
+ red_pipe_item_init(&create->pipe_item, PIPE_ITEM_TYPE_CREATE_SURFACE);
+
+ return create;
+}
+
+static inline void red_create_surface_item(RedWorker *worker, RedSurface *surface)
+{
+ SurfaceCreateItem *create;
+
+ if (!surface->context.canvas) {
+ return;
+ }
+
+ if (!worker->display_channel) {
+ return;
+ }
+
+ create = get_surface_create_item(0, surface->context.width, surface->context.height,
+ surface->context.stride, surface->context.depth,
+ SPICE_SURFACE_FLAGS_PRIMARY);
+ red_pipe_add(&worker->display_channel->base, &create->pipe_item);
+}
+
+static inline void red_create_surface(RedWorker *worker, uint32_t surface_id,uint32_t width,
+ uint32_t height, int32_t stride, uint8_t depth, void *line_0)
{
uint32_t i;
- Surface *surface = &worker->surface;
+ RedSurface *surface = &worker->surface;
if (stride >= 0) {
PANIC("Untested path stride >= 0");
}
PANIC_ON(surface->context.canvas);
+ ASSERT(surface_id == 0);
surface->context.width = width;
surface->context.height = height;
@@ -7666,6 +7777,7 @@ static inline void red_create_surface(RedWorker *worker, uint32_t width, uint32_
if (!surface->context.canvas) {
PANIC("drawing canvas creating failed - can`t create same type canvas");
}
+ red_create_surface_item(worker, surface);
return;
}
@@ -7676,6 +7788,7 @@ static inline void red_create_surface(RedWorker *worker, uint32_t width, uint32_
if (surface->context.canvas) {
worker->renderer = worker->renderers[i];
surface_init_draw_funcs(worker, worker->renderers[i]);
+ red_create_surface_item(worker, surface);
return;
}
}
@@ -7728,14 +7841,14 @@ static inline void red_flush_surface_pipe(RedWorker *worker)
}
}
-static void push_new_mode(RedWorker *worker)
+static void push_new_primary_surface(RedWorker *worker)
{
DisplayChannel *display_channel;
if ((display_channel = worker->display_channel)) {
red_pipe_add_type(&display_channel->base, PIPE_ITEM_TYPE_INVAL_PALLET_CACHE);
if (!display_channel->base.migrate) {
- red_pipe_add_type(&display_channel->base, PIPE_ITEM_TYPE_MODE);
+ red_create_surface_item(worker, &worker->surface);
}
display_channel_push(worker);
}
@@ -7788,7 +7901,7 @@ static void on_new_display_channel(RedWorker *worker)
display_channel->base.messages_window = 0;
if (worker->surface.context.canvas) {
red_current_flush(worker);
- push_new_mode(worker);
+ push_new_primary_surface(worker);
red_add_screen_image(worker);
if (channel_is_connected(&display_channel->base)) {
red_pipe_add_verb(&display_channel->base, SPICE_MSG_DISPLAY_MARK);
@@ -8730,11 +8843,11 @@ static inline void handle_dev_create_primary_surface(RedWorker *worker)
line_0 -= (int32_t)(surface.stride * (surface.height -1));
}
- red_create_surface(worker, surface.width, surface.height, surface.stride, surface.depth,
+ red_create_surface(worker, 0, surface.width, surface.height, surface.stride, surface.depth,
line_0);
if (worker->display_channel) {
- red_pipe_add_type(&worker->display_channel->base, PIPE_ITEM_TYPE_MODE);
+ red_create_surface_item(worker, &worker->surface);
red_pipe_add_verb(&worker->display_channel->base, SPICE_MSG_DISPLAY_MARK);
display_channel_push(worker);
}
--
1.6.6.1
More information about the Spice-devel
mailing list