2 * Copyright 2009 VMware, Inc.
5 * Permission is hereby granted, free of charge, to any person obtaining a
6 * copy of this software and associated documentation files (the "Software"),
7 * to deal in the Software without restriction, including without limitation
8 * on the rights to use, copy, modify, merge, publish, distribute, sub
9 * license, and/or sell copies of the Software, and to permit persons to whom
10 * the Software is furnished to do so, subject to the following conditions:
12 * The above copyright notice and this permission notice (including the next
13 * paragraph) shall be included in all copies or substantial portions of the
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
19 * VMWARE AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
20 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
21 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
22 * USE OR OTHER DEALINGS IN THE SOFTWARE.
26 * This file holds the function implementation for one of the rbug extensions.
27 * Prototypes and declerations of functions and structs is in the same folder
28 * in the header file matching this file's name.
30 * The functions starting rbug_send_* encodes a call to the write format and
31 * sends that to the supplied connection, while functions starting with
32 * rbug_demarshal_* demarshal data in the wire protocol.
34 * Functions ending with _reply are replies to requests.
37 #include "rbug_internal.h"
38 #include "rbug/rbug_context.h"
40 int rbug_send_context_list(struct rbug_connection
*__con
,
45 uint8_t *__data
= NULL
;
53 __data
= (uint8_t*)MALLOC(__len
);
57 WRITE(4, int32_t, ((int32_t)RBUG_OP_CONTEXT_LIST
));
58 WRITE(4, uint32_t, ((uint32_t)(__len
/ 4)));
66 rbug_connection_send_start(__con
, RBUG_OP_CONTEXT_LIST
, __len
);
67 rbug_connection_write(__con
, __data
, __len
);
68 __ret
= rbug_connection_send_finish(__con
, __serial
);
75 int rbug_send_context_info(struct rbug_connection
*__con
,
76 rbug_context_t context
,
81 uint8_t *__data
= NULL
;
90 __data
= (uint8_t*)MALLOC(__len
);
94 WRITE(4, int32_t, ((int32_t)RBUG_OP_CONTEXT_INFO
));
95 WRITE(4, uint32_t, ((uint32_t)(__len
/ 4)));
96 WRITE(8, rbug_context_t
, context
); /* context */
101 if (__pos
!= __len
) {
104 rbug_connection_send_start(__con
, RBUG_OP_CONTEXT_INFO
, __len
);
105 rbug_connection_write(__con
, __data
, __len
);
106 __ret
= rbug_connection_send_finish(__con
, __serial
);
113 int rbug_send_context_draw_block(struct rbug_connection
*__con
,
114 rbug_context_t context
,
120 uint8_t *__data
= NULL
;
124 LEN(8); /* context */
130 __data
= (uint8_t*)MALLOC(__len
);
134 WRITE(4, int32_t, ((int32_t)RBUG_OP_CONTEXT_DRAW_BLOCK
));
135 WRITE(4, uint32_t, ((uint32_t)(__len
/ 4)));
136 WRITE(8, rbug_context_t
, context
); /* context */
137 WRITE(4, rbug_block_t
, block
); /* block */
142 if (__pos
!= __len
) {
145 rbug_connection_send_start(__con
, RBUG_OP_CONTEXT_DRAW_BLOCK
, __len
);
146 rbug_connection_write(__con
, __data
, __len
);
147 __ret
= rbug_connection_send_finish(__con
, __serial
);
154 int rbug_send_context_draw_step(struct rbug_connection
*__con
,
155 rbug_context_t context
,
161 uint8_t *__data
= NULL
;
165 LEN(8); /* context */
171 __data
= (uint8_t*)MALLOC(__len
);
175 WRITE(4, int32_t, ((int32_t)RBUG_OP_CONTEXT_DRAW_STEP
));
176 WRITE(4, uint32_t, ((uint32_t)(__len
/ 4)));
177 WRITE(8, rbug_context_t
, context
); /* context */
178 WRITE(4, rbug_block_t
, step
); /* step */
183 if (__pos
!= __len
) {
186 rbug_connection_send_start(__con
, RBUG_OP_CONTEXT_DRAW_STEP
, __len
);
187 rbug_connection_write(__con
, __data
, __len
);
188 __ret
= rbug_connection_send_finish(__con
, __serial
);
195 int rbug_send_context_draw_unblock(struct rbug_connection
*__con
,
196 rbug_context_t context
,
197 rbug_block_t unblock
,
202 uint8_t *__data
= NULL
;
206 LEN(8); /* context */
207 LEN(4); /* unblock */
212 __data
= (uint8_t*)MALLOC(__len
);
216 WRITE(4, int32_t, ((int32_t)RBUG_OP_CONTEXT_DRAW_UNBLOCK
));
217 WRITE(4, uint32_t, ((uint32_t)(__len
/ 4)));
218 WRITE(8, rbug_context_t
, context
); /* context */
219 WRITE(4, rbug_block_t
, unblock
); /* unblock */
224 if (__pos
!= __len
) {
227 rbug_connection_send_start(__con
, RBUG_OP_CONTEXT_DRAW_UNBLOCK
, __len
);
228 rbug_connection_write(__con
, __data
, __len
);
229 __ret
= rbug_connection_send_finish(__con
, __serial
);
236 int rbug_send_context_draw_rule(struct rbug_connection
*__con
,
237 rbug_context_t context
,
238 rbug_shader_t vertex
,
239 rbug_shader_t fragment
,
240 rbug_texture_t texture
,
241 rbug_texture_t surface
,
247 uint8_t *__data
= NULL
;
251 LEN(8); /* context */
253 LEN(8); /* fragment */
254 LEN(8); /* texture */
255 LEN(8); /* surface */
261 __data
= (uint8_t*)MALLOC(__len
);
265 WRITE(4, int32_t, ((int32_t)RBUG_OP_CONTEXT_DRAW_RULE
));
266 WRITE(4, uint32_t, ((uint32_t)(__len
/ 4)));
267 WRITE(8, rbug_context_t
, context
); /* context */
268 WRITE(8, rbug_shader_t
, vertex
); /* vertex */
269 WRITE(8, rbug_shader_t
, fragment
); /* fragment */
270 WRITE(8, rbug_texture_t
, texture
); /* texture */
271 WRITE(8, rbug_texture_t
, surface
); /* surface */
272 WRITE(4, rbug_block_t
, block
); /* block */
277 if (__pos
!= __len
) {
280 rbug_connection_send_start(__con
, RBUG_OP_CONTEXT_DRAW_RULE
, __len
);
281 rbug_connection_write(__con
, __data
, __len
);
282 __ret
= rbug_connection_send_finish(__con
, __serial
);
289 int rbug_send_context_flush(struct rbug_connection
*__con
,
290 rbug_context_t context
,
295 uint8_t *__data
= NULL
;
299 LEN(8); /* context */
304 __data
= (uint8_t*)MALLOC(__len
);
308 WRITE(4, int32_t, ((int32_t)RBUG_OP_CONTEXT_FLUSH
));
309 WRITE(4, uint32_t, ((uint32_t)(__len
/ 4)));
310 WRITE(8, rbug_context_t
, context
); /* context */
315 if (__pos
!= __len
) {
318 rbug_connection_send_start(__con
, RBUG_OP_CONTEXT_FLUSH
, __len
);
319 rbug_connection_write(__con
, __data
, __len
);
320 __ret
= rbug_connection_send_finish(__con
, __serial
);
327 int rbug_send_context_list_reply(struct rbug_connection
*__con
,
329 rbug_context_t
*contexts
,
330 uint32_t contexts_len
,
335 uint8_t *__data
= NULL
;
340 LEN_ARRAY(8, contexts
); /* contexts */
345 __data
= (uint8_t*)MALLOC(__len
);
349 WRITE(4, int32_t, ((int32_t)RBUG_OP_CONTEXT_LIST_REPLY
));
350 WRITE(4, uint32_t, ((uint32_t)(__len
/ 4)));
351 WRITE(4, uint32_t, serial
); /* serial */
352 WRITE_ARRAY(8, rbug_context_t
, contexts
); /* contexts */
357 if (__pos
!= __len
) {
360 rbug_connection_send_start(__con
, RBUG_OP_CONTEXT_LIST_REPLY
, __len
);
361 rbug_connection_write(__con
, __data
, __len
);
362 __ret
= rbug_connection_send_finish(__con
, __serial
);
369 int rbug_send_context_info_reply(struct rbug_connection
*__con
,
371 rbug_shader_t vertex
,
372 rbug_shader_t fragment
,
373 rbug_texture_t
*texs
,
375 rbug_texture_t
*cbufs
,
377 rbug_texture_t zsbuf
,
378 rbug_block_t blocker
,
379 rbug_block_t blocked
,
384 uint8_t *__data
= NULL
;
390 LEN(8); /* fragment */
391 LEN_ARRAY(8, texs
); /* texs */
392 LEN_ARRAY(8, cbufs
); /* cbufs */
394 LEN(4); /* blocker */
395 LEN(4); /* blocked */
400 __data
= (uint8_t*)MALLOC(__len
);
404 WRITE(4, int32_t, ((int32_t)RBUG_OP_CONTEXT_INFO_REPLY
));
405 WRITE(4, uint32_t, ((uint32_t)(__len
/ 4)));
406 WRITE(4, uint32_t, serial
); /* serial */
407 WRITE(8, rbug_shader_t
, vertex
); /* vertex */
408 WRITE(8, rbug_shader_t
, fragment
); /* fragment */
409 WRITE_ARRAY(8, rbug_texture_t
, texs
); /* texs */
410 WRITE_ARRAY(8, rbug_texture_t
, cbufs
); /* cbufs */
411 WRITE(8, rbug_texture_t
, zsbuf
); /* zsbuf */
412 WRITE(4, rbug_block_t
, blocker
); /* blocker */
413 WRITE(4, rbug_block_t
, blocked
); /* blocked */
418 if (__pos
!= __len
) {
421 rbug_connection_send_start(__con
, RBUG_OP_CONTEXT_INFO_REPLY
, __len
);
422 rbug_connection_write(__con
, __data
, __len
);
423 __ret
= rbug_connection_send_finish(__con
, __serial
);
430 int rbug_send_context_draw_blocked(struct rbug_connection
*__con
,
431 rbug_context_t context
,
437 uint8_t *__data
= NULL
;
441 LEN(8); /* context */
447 __data
= (uint8_t*)MALLOC(__len
);
451 WRITE(4, int32_t, ((int32_t)RBUG_OP_CONTEXT_DRAW_BLOCKED
));
452 WRITE(4, uint32_t, ((uint32_t)(__len
/ 4)));
453 WRITE(8, rbug_context_t
, context
); /* context */
454 WRITE(4, rbug_block_t
, block
); /* block */
459 if (__pos
!= __len
) {
462 rbug_connection_send_start(__con
, RBUG_OP_CONTEXT_DRAW_BLOCKED
, __len
);
463 rbug_connection_write(__con
, __data
, __len
);
464 __ret
= rbug_connection_send_finish(__con
, __serial
);
471 struct rbug_proto_context_list
* rbug_demarshal_context_list(struct rbug_proto_header
*header
)
475 uint8_t *data
= NULL
;
476 struct rbug_proto_context_list
*ret
;
480 if (header
->opcode
!= (int32_t)RBUG_OP_CONTEXT_LIST
)
484 len
= header
->length
* 4;
485 data
= (uint8_t*)&header
[1];
486 ret
= MALLOC(sizeof(*ret
));
490 ret
->header
.__message
= header
;
491 ret
->header
.opcode
= header
->opcode
;
497 struct rbug_proto_context_info
* rbug_demarshal_context_info(struct rbug_proto_header
*header
)
501 uint8_t *data
= NULL
;
502 struct rbug_proto_context_info
*ret
;
506 if (header
->opcode
!= (int32_t)RBUG_OP_CONTEXT_INFO
)
510 len
= header
->length
* 4;
511 data
= (uint8_t*)&header
[1];
512 ret
= MALLOC(sizeof(*ret
));
516 ret
->header
.__message
= header
;
517 ret
->header
.opcode
= header
->opcode
;
519 READ(8, rbug_context_t
, context
); /* context */
524 struct rbug_proto_context_draw_block
* rbug_demarshal_context_draw_block(struct rbug_proto_header
*header
)
528 uint8_t *data
= NULL
;
529 struct rbug_proto_context_draw_block
*ret
;
533 if (header
->opcode
!= (int32_t)RBUG_OP_CONTEXT_DRAW_BLOCK
)
537 len
= header
->length
* 4;
538 data
= (uint8_t*)&header
[1];
539 ret
= MALLOC(sizeof(*ret
));
543 ret
->header
.__message
= header
;
544 ret
->header
.opcode
= header
->opcode
;
546 READ(8, rbug_context_t
, context
); /* context */
547 READ(4, rbug_block_t
, block
); /* block */
552 struct rbug_proto_context_draw_step
* rbug_demarshal_context_draw_step(struct rbug_proto_header
*header
)
556 uint8_t *data
= NULL
;
557 struct rbug_proto_context_draw_step
*ret
;
561 if (header
->opcode
!= (int32_t)RBUG_OP_CONTEXT_DRAW_STEP
)
565 len
= header
->length
* 4;
566 data
= (uint8_t*)&header
[1];
567 ret
= MALLOC(sizeof(*ret
));
571 ret
->header
.__message
= header
;
572 ret
->header
.opcode
= header
->opcode
;
574 READ(8, rbug_context_t
, context
); /* context */
575 READ(4, rbug_block_t
, step
); /* step */
580 struct rbug_proto_context_draw_unblock
* rbug_demarshal_context_draw_unblock(struct rbug_proto_header
*header
)
584 uint8_t *data
= NULL
;
585 struct rbug_proto_context_draw_unblock
*ret
;
589 if (header
->opcode
!= (int32_t)RBUG_OP_CONTEXT_DRAW_UNBLOCK
)
593 len
= header
->length
* 4;
594 data
= (uint8_t*)&header
[1];
595 ret
= MALLOC(sizeof(*ret
));
599 ret
->header
.__message
= header
;
600 ret
->header
.opcode
= header
->opcode
;
602 READ(8, rbug_context_t
, context
); /* context */
603 READ(4, rbug_block_t
, unblock
); /* unblock */
608 struct rbug_proto_context_draw_rule
* rbug_demarshal_context_draw_rule(struct rbug_proto_header
*header
)
612 uint8_t *data
= NULL
;
613 struct rbug_proto_context_draw_rule
*ret
;
617 if (header
->opcode
!= (int32_t)RBUG_OP_CONTEXT_DRAW_RULE
)
621 len
= header
->length
* 4;
622 data
= (uint8_t*)&header
[1];
623 ret
= MALLOC(sizeof(*ret
));
627 ret
->header
.__message
= header
;
628 ret
->header
.opcode
= header
->opcode
;
630 READ(8, rbug_context_t
, context
); /* context */
631 READ(8, rbug_shader_t
, vertex
); /* vertex */
632 READ(8, rbug_shader_t
, fragment
); /* fragment */
633 READ(8, rbug_texture_t
, texture
); /* texture */
634 READ(8, rbug_texture_t
, surface
); /* surface */
635 READ(4, rbug_block_t
, block
); /* block */
640 struct rbug_proto_context_flush
* rbug_demarshal_context_flush(struct rbug_proto_header
*header
)
644 uint8_t *data
= NULL
;
645 struct rbug_proto_context_flush
*ret
;
649 if (header
->opcode
!= (int32_t)RBUG_OP_CONTEXT_FLUSH
)
653 len
= header
->length
* 4;
654 data
= (uint8_t*)&header
[1];
655 ret
= MALLOC(sizeof(*ret
));
659 ret
->header
.__message
= header
;
660 ret
->header
.opcode
= header
->opcode
;
662 READ(8, rbug_context_t
, context
); /* context */
667 struct rbug_proto_context_list_reply
* rbug_demarshal_context_list_reply(struct rbug_proto_header
*header
)
671 uint8_t *data
= NULL
;
672 struct rbug_proto_context_list_reply
*ret
;
676 if (header
->opcode
!= (int32_t)RBUG_OP_CONTEXT_LIST_REPLY
)
680 len
= header
->length
* 4;
681 data
= (uint8_t*)&header
[1];
682 ret
= MALLOC(sizeof(*ret
));
686 ret
->header
.__message
= header
;
687 ret
->header
.opcode
= header
->opcode
;
689 READ(4, uint32_t, serial
); /* serial */
690 READ_ARRAY(8, rbug_context_t
, contexts
); /* contexts */
695 struct rbug_proto_context_info_reply
* rbug_demarshal_context_info_reply(struct rbug_proto_header
*header
)
699 uint8_t *data
= NULL
;
700 struct rbug_proto_context_info_reply
*ret
;
704 if (header
->opcode
!= (int32_t)RBUG_OP_CONTEXT_INFO_REPLY
)
708 len
= header
->length
* 4;
709 data
= (uint8_t*)&header
[1];
710 ret
= MALLOC(sizeof(*ret
));
714 ret
->header
.__message
= header
;
715 ret
->header
.opcode
= header
->opcode
;
717 READ(4, uint32_t, serial
); /* serial */
718 READ(8, rbug_shader_t
, vertex
); /* vertex */
719 READ(8, rbug_shader_t
, fragment
); /* fragment */
720 READ_ARRAY(8, rbug_texture_t
, texs
); /* texs */
721 READ_ARRAY(8, rbug_texture_t
, cbufs
); /* cbufs */
722 READ(8, rbug_texture_t
, zsbuf
); /* zsbuf */
723 READ(4, rbug_block_t
, blocker
); /* blocker */
724 READ(4, rbug_block_t
, blocked
); /* blocked */
729 struct rbug_proto_context_draw_blocked
* rbug_demarshal_context_draw_blocked(struct rbug_proto_header
*header
)
733 uint8_t *data
= NULL
;
734 struct rbug_proto_context_draw_blocked
*ret
;
738 if (header
->opcode
!= (int32_t)RBUG_OP_CONTEXT_DRAW_BLOCKED
)
742 len
= header
->length
* 4;
743 data
= (uint8_t*)&header
[1];
744 ret
= MALLOC(sizeof(*ret
));
748 ret
->header
.__message
= header
;
749 ret
->header
.opcode
= header
->opcode
;
751 READ(8, rbug_context_t
, context
); /* context */
752 READ(4, rbug_block_t
, block
); /* block */