| /contrib/sdk/sources/Mesa/mesa-10.6.0/src/gallium/auxiliary/rbug/README |
|---|
| 0,0 → 1,25 |
| GALLIUM REMOTE DEBUGGING COMMON CODE |
| = About = |
| This directory contains the common code for the Gallium 3D remote debugging |
| driver and clients. The code is two parts the connection managment code and |
| the (de)marsheller. |
| The code currently uses tcp and ip4v for connections. |
| Information about driver integration can be found in: |
| src/gallium/drivers/rbug/README |
| for information about applications look in: |
| progs/rbug/README |
| for a GUI see: |
| http://cgit.freedesktop.org/mesa/rbug-gui |
| -- |
| Jakob Bornecrantz <jakob@vmware.com> |
| /contrib/sdk/sources/Mesa/mesa-10.6.0/src/gallium/auxiliary/rbug/rbug.h |
|---|
| 0,0 → 1,33 |
| /* |
| * Copyright 2009 VMware, Inc. |
| * All Rights Reserved. |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a |
| * copy of this software and associated documentation files (the "Software"), |
| * to deal in the Software without restriction, including without limitation |
| * on the rights to use, copy, modify, merge, publish, distribute, sub |
| * license, and/or sell copies of the Software, and to permit persons to whom |
| * the Software is furnished to do so, subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice (including the next |
| * paragraph) shall be included in all copies or substantial portions of the |
| * Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL |
| * VMWARE AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, |
| * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR |
| * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE |
| * USE OR OTHER DEALINGS IN THE SOFTWARE. |
| */ |
| /* |
| * Include all for users the remote debugger protocol code. |
| */ |
| #include "rbug_core.h" |
| #include "rbug_shader.h" |
| #include "rbug_context.h" |
| #include "rbug_texture.h" |
| #include "rbug_connection.h" |
| /contrib/sdk/sources/Mesa/mesa-10.6.0/src/gallium/auxiliary/rbug/rbug_connection.c |
|---|
| 0,0 → 1,168 |
| /* |
| * Copyright 2009 VMware, Inc. |
| * All Rights Reserved. |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a |
| * copy of this software and associated documentation files (the "Software"), |
| * to deal in the Software without restriction, including without limitation |
| * on the rights to use, copy, modify, merge, publish, distribute, sub |
| * license, and/or sell copies of the Software, and to permit persons to whom |
| * the Software is furnished to do so, subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice (including the next |
| * paragraph) shall be included in all copies or substantial portions of the |
| * Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL |
| * VMWARE AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, |
| * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR |
| * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE |
| * USE OR OTHER DEALINGS IN THE SOFTWARE. |
| */ |
| #include "rbug.h" |
| #include "rbug_internal.h" |
| #include "util/u_network.h" |
| struct rbug_connection |
| { |
| int socket; |
| uint32_t send_serial; |
| uint32_t recv_serial; |
| enum rbug_opcode opcode; |
| }; |
| /** |
| * Create a rbug connection from a socket created with u_socket. |
| * |
| * Result: |
| * A new allocated connection using socket as communication path |
| */ |
| struct rbug_connection * |
| rbug_from_socket(int socket) |
| { |
| struct rbug_connection *c = CALLOC_STRUCT(rbug_connection); |
| c->socket = socket; |
| return c; |
| } |
| /** |
| * Free a connection, also closes socket. |
| */ |
| void |
| rbug_disconnect(struct rbug_connection *c) |
| { |
| u_socket_close(c->socket); |
| FREE(c); |
| } |
| /** |
| * Waits for a message to be fully received. |
| * Also returns the serial for the message, serial is not touched for replys. |
| * |
| * Result: |
| * demarshaled message on success, NULL on connection error |
| */ |
| struct rbug_header * |
| rbug_get_message(struct rbug_connection *c, uint32_t *serial) |
| { |
| struct rbug_proto_header header; |
| struct rbug_header *out; |
| struct rbug_proto_header *data; |
| size_t length = 0; |
| size_t read = 0; |
| int ret; |
| ret = u_socket_peek(c->socket, &header, sizeof(header)); |
| if (ret <= 0) { |
| return NULL; |
| } |
| length = (size_t)header.length * 4; |
| data = MALLOC(length); |
| if (!data) { |
| return NULL; |
| } |
| data->opcode = 0; |
| do { |
| uint8_t *ptr = ((uint8_t*)data) + read; |
| ret = u_socket_recv(c->socket, ptr, length - read); |
| if (ret <= 0) { |
| FREE(data); |
| return NULL; |
| } |
| read += ret; |
| } while(read < length); |
| out = rbug_demarshal(data); |
| if (!out) |
| FREE(data); |
| else if (serial) |
| *serial = c->recv_serial++; |
| else |
| c->recv_serial++; |
| return out; |
| } |
| /** |
| * Frees a message and associated data. |
| */ |
| void |
| rbug_free_header(struct rbug_header *header) |
| { |
| if (!header) |
| return; |
| FREE(header->__message); |
| FREE(header); |
| } |
| /** |
| * Internal function used by rbug_send_* functions. |
| * |
| * Start sending a message. |
| */ |
| int |
| rbug_connection_send_start(struct rbug_connection *c, enum rbug_opcode opcode, uint32_t length) |
| { |
| c->opcode = opcode; |
| return 0; |
| } |
| /** |
| * Internal function used by rbug_send_* functions. |
| * |
| * Write data to the socket. |
| */ |
| int |
| rbug_connection_write(struct rbug_connection *c, void *to, uint32_t size) |
| { |
| int ret = u_socket_send(c->socket, to, size); |
| return ret; |
| } |
| /** |
| * Internal function used by rbug_send_* functions. |
| * |
| * Finish writing data to the socket. |
| * Ups the send_serial and sets the serial argument if supplied. |
| */ |
| int rbug_connection_send_finish(struct rbug_connection *c, uint32_t *serial) |
| { |
| if (c->opcode < 0) |
| return 0; |
| else if (serial) |
| *serial = c->send_serial++; |
| else |
| c->send_serial++; |
| return 0; |
| } |
| /contrib/sdk/sources/Mesa/mesa-10.6.0/src/gallium/auxiliary/rbug/rbug_connection.h |
|---|
| 0,0 → 1,45 |
| /* |
| * Copyright 2009 VMware, Inc. |
| * All Rights Reserved. |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a |
| * copy of this software and associated documentation files (the "Software"), |
| * to deal in the Software without restriction, including without limitation |
| * on the rights to use, copy, modify, merge, publish, distribute, sub |
| * license, and/or sell copies of the Software, and to permit persons to whom |
| * the Software is furnished to do so, subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice (including the next |
| * paragraph) shall be included in all copies or substantial portions of the |
| * Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL |
| * VMWARE AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, |
| * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR |
| * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE |
| * USE OR OTHER DEALINGS IN THE SOFTWARE. |
| */ |
| /* |
| * This file contains the function defentions for connection see c file for |
| * more comments covering function use. |
| */ |
| #ifndef _RBUG_CONNECTION_H_ |
| #define _RBUG_CONNECTION_H_ |
| #include "rbug_proto.h" |
| struct rbug_connection * rbug_from_socket(int socket); |
| void rbug_disconnect(struct rbug_connection *c); |
| struct rbug_header * rbug_get_message(struct rbug_connection *c, uint32_t *serial); |
| void rbug_free_header(struct rbug_header *header); |
| struct rbug_header * rbug_demarshal(struct rbug_proto_header *header); |
| #endif |
| /contrib/sdk/sources/Mesa/mesa-10.6.0/src/gallium/auxiliary/rbug/rbug_context.c |
|---|
| 0,0 → 1,748 |
| /* |
| * Copyright 2009 VMware, Inc. |
| * All Rights Reserved. |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a |
| * copy of this software and associated documentation files (the "Software"), |
| * to deal in the Software without restriction, including without limitation |
| * on the rights to use, copy, modify, merge, publish, distribute, sub |
| * license, and/or sell copies of the Software, and to permit persons to whom |
| * the Software is furnished to do so, subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice (including the next |
| * paragraph) shall be included in all copies or substantial portions of the |
| * Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL |
| * VMWARE AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, |
| * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR |
| * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE |
| * USE OR OTHER DEALINGS IN THE SOFTWARE. |
| */ |
| /* |
| * This file holds the function implementation for one of the rbug extensions. |
| * Prototypes and declerations of functions and structs is in the same folder |
| * in the header file matching this file's name. |
| * |
| * The functions starting rbug_send_* encodes a call to the write format and |
| * sends that to the supplied connection, while functions starting with |
| * rbug_demarshal_* demarshal data in the wire protocol. |
| * |
| * Functions ending with _reply are replies to requests. |
| */ |
| #include "rbug_internal.h" |
| #include "rbug_context.h" |
| int rbug_send_context_list(struct rbug_connection *__con, |
| uint32_t *__serial) |
| { |
| uint32_t __len = 0; |
| uint32_t __pos = 0; |
| uint8_t *__data = NULL; |
| int __ret = 0; |
| LEN(8); /* header */ |
| /* align */ |
| PAD(__len, 8); |
| __data = (uint8_t*)MALLOC(__len); |
| if (!__data) |
| return -ENOMEM; |
| WRITE(4, int32_t, ((int32_t)RBUG_OP_CONTEXT_LIST)); |
| WRITE(4, uint32_t, ((uint32_t)(__len / 4))); |
| /* final pad */ |
| PAD(__pos, 8); |
| if (__pos != __len) { |
| __ret = -EINVAL; |
| } else { |
| rbug_connection_send_start(__con, RBUG_OP_CONTEXT_LIST, __len); |
| rbug_connection_write(__con, __data, __len); |
| __ret = rbug_connection_send_finish(__con, __serial); |
| } |
| FREE(__data); |
| return __ret; |
| } |
| int rbug_send_context_info(struct rbug_connection *__con, |
| rbug_context_t context, |
| uint32_t *__serial) |
| { |
| uint32_t __len = 0; |
| uint32_t __pos = 0; |
| uint8_t *__data = NULL; |
| int __ret = 0; |
| LEN(8); /* header */ |
| LEN(8); /* context */ |
| /* align */ |
| PAD(__len, 8); |
| __data = (uint8_t*)MALLOC(__len); |
| if (!__data) |
| return -ENOMEM; |
| WRITE(4, int32_t, ((int32_t)RBUG_OP_CONTEXT_INFO)); |
| WRITE(4, uint32_t, ((uint32_t)(__len / 4))); |
| WRITE(8, rbug_context_t, context); /* context */ |
| /* final pad */ |
| PAD(__pos, 8); |
| if (__pos != __len) { |
| __ret = -EINVAL; |
| } else { |
| rbug_connection_send_start(__con, RBUG_OP_CONTEXT_INFO, __len); |
| rbug_connection_write(__con, __data, __len); |
| __ret = rbug_connection_send_finish(__con, __serial); |
| } |
| FREE(__data); |
| return __ret; |
| } |
| int rbug_send_context_draw_block(struct rbug_connection *__con, |
| rbug_context_t context, |
| rbug_block_t block, |
| uint32_t *__serial) |
| { |
| uint32_t __len = 0; |
| uint32_t __pos = 0; |
| uint8_t *__data = NULL; |
| int __ret = 0; |
| LEN(8); /* header */ |
| LEN(8); /* context */ |
| LEN(4); /* block */ |
| /* align */ |
| PAD(__len, 8); |
| __data = (uint8_t*)MALLOC(__len); |
| if (!__data) |
| return -ENOMEM; |
| WRITE(4, int32_t, ((int32_t)RBUG_OP_CONTEXT_DRAW_BLOCK)); |
| WRITE(4, uint32_t, ((uint32_t)(__len / 4))); |
| WRITE(8, rbug_context_t, context); /* context */ |
| WRITE(4, rbug_block_t, block); /* block */ |
| /* final pad */ |
| PAD(__pos, 8); |
| if (__pos != __len) { |
| __ret = -EINVAL; |
| } else { |
| rbug_connection_send_start(__con, RBUG_OP_CONTEXT_DRAW_BLOCK, __len); |
| rbug_connection_write(__con, __data, __len); |
| __ret = rbug_connection_send_finish(__con, __serial); |
| } |
| FREE(__data); |
| return __ret; |
| } |
| int rbug_send_context_draw_step(struct rbug_connection *__con, |
| rbug_context_t context, |
| rbug_block_t step, |
| uint32_t *__serial) |
| { |
| uint32_t __len = 0; |
| uint32_t __pos = 0; |
| uint8_t *__data = NULL; |
| int __ret = 0; |
| LEN(8); /* header */ |
| LEN(8); /* context */ |
| LEN(4); /* step */ |
| /* align */ |
| PAD(__len, 8); |
| __data = (uint8_t*)MALLOC(__len); |
| if (!__data) |
| return -ENOMEM; |
| WRITE(4, int32_t, ((int32_t)RBUG_OP_CONTEXT_DRAW_STEP)); |
| WRITE(4, uint32_t, ((uint32_t)(__len / 4))); |
| WRITE(8, rbug_context_t, context); /* context */ |
| WRITE(4, rbug_block_t, step); /* step */ |
| /* final pad */ |
| PAD(__pos, 8); |
| if (__pos != __len) { |
| __ret = -EINVAL; |
| } else { |
| rbug_connection_send_start(__con, RBUG_OP_CONTEXT_DRAW_STEP, __len); |
| rbug_connection_write(__con, __data, __len); |
| __ret = rbug_connection_send_finish(__con, __serial); |
| } |
| FREE(__data); |
| return __ret; |
| } |
| int rbug_send_context_draw_unblock(struct rbug_connection *__con, |
| rbug_context_t context, |
| rbug_block_t unblock, |
| uint32_t *__serial) |
| { |
| uint32_t __len = 0; |
| uint32_t __pos = 0; |
| uint8_t *__data = NULL; |
| int __ret = 0; |
| LEN(8); /* header */ |
| LEN(8); /* context */ |
| LEN(4); /* unblock */ |
| /* align */ |
| PAD(__len, 8); |
| __data = (uint8_t*)MALLOC(__len); |
| if (!__data) |
| return -ENOMEM; |
| WRITE(4, int32_t, ((int32_t)RBUG_OP_CONTEXT_DRAW_UNBLOCK)); |
| WRITE(4, uint32_t, ((uint32_t)(__len / 4))); |
| WRITE(8, rbug_context_t, context); /* context */ |
| WRITE(4, rbug_block_t, unblock); /* unblock */ |
| /* final pad */ |
| PAD(__pos, 8); |
| if (__pos != __len) { |
| __ret = -EINVAL; |
| } else { |
| rbug_connection_send_start(__con, RBUG_OP_CONTEXT_DRAW_UNBLOCK, __len); |
| rbug_connection_write(__con, __data, __len); |
| __ret = rbug_connection_send_finish(__con, __serial); |
| } |
| FREE(__data); |
| return __ret; |
| } |
| int rbug_send_context_draw_rule(struct rbug_connection *__con, |
| rbug_context_t context, |
| rbug_shader_t vertex, |
| rbug_shader_t fragment, |
| rbug_texture_t texture, |
| rbug_texture_t surface, |
| rbug_block_t block, |
| uint32_t *__serial) |
| { |
| uint32_t __len = 0; |
| uint32_t __pos = 0; |
| uint8_t *__data = NULL; |
| int __ret = 0; |
| LEN(8); /* header */ |
| LEN(8); /* context */ |
| LEN(8); /* vertex */ |
| LEN(8); /* fragment */ |
| LEN(8); /* texture */ |
| LEN(8); /* surface */ |
| LEN(4); /* block */ |
| /* align */ |
| PAD(__len, 8); |
| __data = (uint8_t*)MALLOC(__len); |
| if (!__data) |
| return -ENOMEM; |
| WRITE(4, int32_t, ((int32_t)RBUG_OP_CONTEXT_DRAW_RULE)); |
| WRITE(4, uint32_t, ((uint32_t)(__len / 4))); |
| WRITE(8, rbug_context_t, context); /* context */ |
| WRITE(8, rbug_shader_t, vertex); /* vertex */ |
| WRITE(8, rbug_shader_t, fragment); /* fragment */ |
| WRITE(8, rbug_texture_t, texture); /* texture */ |
| WRITE(8, rbug_texture_t, surface); /* surface */ |
| WRITE(4, rbug_block_t, block); /* block */ |
| /* final pad */ |
| PAD(__pos, 8); |
| if (__pos != __len) { |
| __ret = -EINVAL; |
| } else { |
| rbug_connection_send_start(__con, RBUG_OP_CONTEXT_DRAW_RULE, __len); |
| rbug_connection_write(__con, __data, __len); |
| __ret = rbug_connection_send_finish(__con, __serial); |
| } |
| FREE(__data); |
| return __ret; |
| } |
| int rbug_send_context_flush(struct rbug_connection *__con, |
| rbug_context_t context, |
| uint32_t *__serial) |
| { |
| uint32_t __len = 0; |
| uint32_t __pos = 0; |
| uint8_t *__data = NULL; |
| int __ret = 0; |
| LEN(8); /* header */ |
| LEN(8); /* context */ |
| /* align */ |
| PAD(__len, 8); |
| __data = (uint8_t*)MALLOC(__len); |
| if (!__data) |
| return -ENOMEM; |
| WRITE(4, int32_t, ((int32_t)RBUG_OP_CONTEXT_FLUSH)); |
| WRITE(4, uint32_t, ((uint32_t)(__len / 4))); |
| WRITE(8, rbug_context_t, context); /* context */ |
| /* final pad */ |
| PAD(__pos, 8); |
| if (__pos != __len) { |
| __ret = -EINVAL; |
| } else { |
| rbug_connection_send_start(__con, RBUG_OP_CONTEXT_FLUSH, __len); |
| rbug_connection_write(__con, __data, __len); |
| __ret = rbug_connection_send_finish(__con, __serial); |
| } |
| FREE(__data); |
| return __ret; |
| } |
| int rbug_send_context_list_reply(struct rbug_connection *__con, |
| uint32_t serial, |
| rbug_context_t *contexts, |
| uint32_t contexts_len, |
| uint32_t *__serial) |
| { |
| uint32_t __len = 0; |
| uint32_t __pos = 0; |
| uint8_t *__data = NULL; |
| int __ret = 0; |
| LEN(8); /* header */ |
| LEN(4); /* serial */ |
| LEN_ARRAY(8, contexts); /* contexts */ |
| /* align */ |
| PAD(__len, 8); |
| __data = (uint8_t*)MALLOC(__len); |
| if (!__data) |
| return -ENOMEM; |
| WRITE(4, int32_t, ((int32_t)RBUG_OP_CONTEXT_LIST_REPLY)); |
| WRITE(4, uint32_t, ((uint32_t)(__len / 4))); |
| WRITE(4, uint32_t, serial); /* serial */ |
| WRITE_ARRAY(8, rbug_context_t, contexts); /* contexts */ |
| /* final pad */ |
| PAD(__pos, 8); |
| if (__pos != __len) { |
| __ret = -EINVAL; |
| } else { |
| rbug_connection_send_start(__con, RBUG_OP_CONTEXT_LIST_REPLY, __len); |
| rbug_connection_write(__con, __data, __len); |
| __ret = rbug_connection_send_finish(__con, __serial); |
| } |
| FREE(__data); |
| return __ret; |
| } |
| int rbug_send_context_info_reply(struct rbug_connection *__con, |
| uint32_t serial, |
| rbug_shader_t vertex, |
| rbug_shader_t fragment, |
| rbug_texture_t *texs, |
| uint32_t texs_len, |
| rbug_texture_t *cbufs, |
| uint32_t cbufs_len, |
| rbug_texture_t zsbuf, |
| rbug_block_t blocker, |
| rbug_block_t blocked, |
| uint32_t *__serial) |
| { |
| uint32_t __len = 0; |
| uint32_t __pos = 0; |
| uint8_t *__data = NULL; |
| int __ret = 0; |
| LEN(8); /* header */ |
| LEN(4); /* serial */ |
| LEN(8); /* vertex */ |
| LEN(8); /* fragment */ |
| LEN_ARRAY(8, texs); /* texs */ |
| LEN_ARRAY(8, cbufs); /* cbufs */ |
| LEN(8); /* zsbuf */ |
| LEN(4); /* blocker */ |
| LEN(4); /* blocked */ |
| /* align */ |
| PAD(__len, 8); |
| __data = (uint8_t*)MALLOC(__len); |
| if (!__data) |
| return -ENOMEM; |
| WRITE(4, int32_t, ((int32_t)RBUG_OP_CONTEXT_INFO_REPLY)); |
| WRITE(4, uint32_t, ((uint32_t)(__len / 4))); |
| WRITE(4, uint32_t, serial); /* serial */ |
| WRITE(8, rbug_shader_t, vertex); /* vertex */ |
| WRITE(8, rbug_shader_t, fragment); /* fragment */ |
| WRITE_ARRAY(8, rbug_texture_t, texs); /* texs */ |
| WRITE_ARRAY(8, rbug_texture_t, cbufs); /* cbufs */ |
| WRITE(8, rbug_texture_t, zsbuf); /* zsbuf */ |
| WRITE(4, rbug_block_t, blocker); /* blocker */ |
| WRITE(4, rbug_block_t, blocked); /* blocked */ |
| /* final pad */ |
| PAD(__pos, 8); |
| if (__pos != __len) { |
| __ret = -EINVAL; |
| } else { |
| rbug_connection_send_start(__con, RBUG_OP_CONTEXT_INFO_REPLY, __len); |
| rbug_connection_write(__con, __data, __len); |
| __ret = rbug_connection_send_finish(__con, __serial); |
| } |
| FREE(__data); |
| return __ret; |
| } |
| int rbug_send_context_draw_blocked(struct rbug_connection *__con, |
| rbug_context_t context, |
| rbug_block_t block, |
| uint32_t *__serial) |
| { |
| uint32_t __len = 0; |
| uint32_t __pos = 0; |
| uint8_t *__data = NULL; |
| int __ret = 0; |
| LEN(8); /* header */ |
| LEN(8); /* context */ |
| LEN(4); /* block */ |
| /* align */ |
| PAD(__len, 8); |
| __data = (uint8_t*)MALLOC(__len); |
| if (!__data) |
| return -ENOMEM; |
| WRITE(4, int32_t, ((int32_t)RBUG_OP_CONTEXT_DRAW_BLOCKED)); |
| WRITE(4, uint32_t, ((uint32_t)(__len / 4))); |
| WRITE(8, rbug_context_t, context); /* context */ |
| WRITE(4, rbug_block_t, block); /* block */ |
| /* final pad */ |
| PAD(__pos, 8); |
| if (__pos != __len) { |
| __ret = -EINVAL; |
| } else { |
| rbug_connection_send_start(__con, RBUG_OP_CONTEXT_DRAW_BLOCKED, __len); |
| rbug_connection_write(__con, __data, __len); |
| __ret = rbug_connection_send_finish(__con, __serial); |
| } |
| FREE(__data); |
| return __ret; |
| } |
| struct rbug_proto_context_list * rbug_demarshal_context_list(struct rbug_proto_header *header) |
| { |
| struct rbug_proto_context_list *ret; |
| if (!header) |
| return NULL; |
| if (header->opcode != (int32_t)RBUG_OP_CONTEXT_LIST) |
| return NULL; |
| ret = MALLOC(sizeof(*ret)); |
| if (!ret) |
| return NULL; |
| ret->header.__message = header; |
| ret->header.opcode = header->opcode; |
| return ret; |
| } |
| struct rbug_proto_context_info * rbug_demarshal_context_info(struct rbug_proto_header *header) |
| { |
| uint32_t len = 0; |
| uint32_t pos = 0; |
| uint8_t *data = NULL; |
| struct rbug_proto_context_info *ret; |
| if (!header) |
| return NULL; |
| if (header->opcode != (int32_t)RBUG_OP_CONTEXT_INFO) |
| return NULL; |
| pos = 0; |
| len = header->length * 4; |
| data = (uint8_t*)&header[1]; |
| ret = MALLOC(sizeof(*ret)); |
| if (!ret) |
| return NULL; |
| ret->header.__message = header; |
| ret->header.opcode = header->opcode; |
| READ(8, rbug_context_t, context); /* context */ |
| return ret; |
| } |
| struct rbug_proto_context_draw_block * rbug_demarshal_context_draw_block(struct rbug_proto_header *header) |
| { |
| uint32_t len = 0; |
| uint32_t pos = 0; |
| uint8_t *data = NULL; |
| struct rbug_proto_context_draw_block *ret; |
| if (!header) |
| return NULL; |
| if (header->opcode != (int32_t)RBUG_OP_CONTEXT_DRAW_BLOCK) |
| return NULL; |
| pos = 0; |
| len = header->length * 4; |
| data = (uint8_t*)&header[1]; |
| ret = MALLOC(sizeof(*ret)); |
| if (!ret) |
| return NULL; |
| ret->header.__message = header; |
| ret->header.opcode = header->opcode; |
| READ(8, rbug_context_t, context); /* context */ |
| READ(4, rbug_block_t, block); /* block */ |
| return ret; |
| } |
| struct rbug_proto_context_draw_step * rbug_demarshal_context_draw_step(struct rbug_proto_header *header) |
| { |
| uint32_t len = 0; |
| uint32_t pos = 0; |
| uint8_t *data = NULL; |
| struct rbug_proto_context_draw_step *ret; |
| if (!header) |
| return NULL; |
| if (header->opcode != (int32_t)RBUG_OP_CONTEXT_DRAW_STEP) |
| return NULL; |
| pos = 0; |
| len = header->length * 4; |
| data = (uint8_t*)&header[1]; |
| ret = MALLOC(sizeof(*ret)); |
| if (!ret) |
| return NULL; |
| ret->header.__message = header; |
| ret->header.opcode = header->opcode; |
| READ(8, rbug_context_t, context); /* context */ |
| READ(4, rbug_block_t, step); /* step */ |
| return ret; |
| } |
| struct rbug_proto_context_draw_unblock * rbug_demarshal_context_draw_unblock(struct rbug_proto_header *header) |
| { |
| uint32_t len = 0; |
| uint32_t pos = 0; |
| uint8_t *data = NULL; |
| struct rbug_proto_context_draw_unblock *ret; |
| if (!header) |
| return NULL; |
| if (header->opcode != (int32_t)RBUG_OP_CONTEXT_DRAW_UNBLOCK) |
| return NULL; |
| pos = 0; |
| len = header->length * 4; |
| data = (uint8_t*)&header[1]; |
| ret = MALLOC(sizeof(*ret)); |
| if (!ret) |
| return NULL; |
| ret->header.__message = header; |
| ret->header.opcode = header->opcode; |
| READ(8, rbug_context_t, context); /* context */ |
| READ(4, rbug_block_t, unblock); /* unblock */ |
| return ret; |
| } |
| struct rbug_proto_context_draw_rule * rbug_demarshal_context_draw_rule(struct rbug_proto_header *header) |
| { |
| uint32_t len = 0; |
| uint32_t pos = 0; |
| uint8_t *data = NULL; |
| struct rbug_proto_context_draw_rule *ret; |
| if (!header) |
| return NULL; |
| if (header->opcode != (int32_t)RBUG_OP_CONTEXT_DRAW_RULE) |
| return NULL; |
| pos = 0; |
| len = header->length * 4; |
| data = (uint8_t*)&header[1]; |
| ret = MALLOC(sizeof(*ret)); |
| if (!ret) |
| return NULL; |
| ret->header.__message = header; |
| ret->header.opcode = header->opcode; |
| READ(8, rbug_context_t, context); /* context */ |
| READ(8, rbug_shader_t, vertex); /* vertex */ |
| READ(8, rbug_shader_t, fragment); /* fragment */ |
| READ(8, rbug_texture_t, texture); /* texture */ |
| READ(8, rbug_texture_t, surface); /* surface */ |
| READ(4, rbug_block_t, block); /* block */ |
| return ret; |
| } |
| struct rbug_proto_context_flush * rbug_demarshal_context_flush(struct rbug_proto_header *header) |
| { |
| uint32_t len = 0; |
| uint32_t pos = 0; |
| uint8_t *data = NULL; |
| struct rbug_proto_context_flush *ret; |
| if (!header) |
| return NULL; |
| if (header->opcode != (int32_t)RBUG_OP_CONTEXT_FLUSH) |
| return NULL; |
| pos = 0; |
| len = header->length * 4; |
| data = (uint8_t*)&header[1]; |
| ret = MALLOC(sizeof(*ret)); |
| if (!ret) |
| return NULL; |
| ret->header.__message = header; |
| ret->header.opcode = header->opcode; |
| READ(8, rbug_context_t, context); /* context */ |
| return ret; |
| } |
| struct rbug_proto_context_list_reply * rbug_demarshal_context_list_reply(struct rbug_proto_header *header) |
| { |
| uint32_t len = 0; |
| uint32_t pos = 0; |
| uint8_t *data = NULL; |
| struct rbug_proto_context_list_reply *ret; |
| if (!header) |
| return NULL; |
| if (header->opcode != (int32_t)RBUG_OP_CONTEXT_LIST_REPLY) |
| return NULL; |
| pos = 0; |
| len = header->length * 4; |
| data = (uint8_t*)&header[1]; |
| ret = MALLOC(sizeof(*ret)); |
| if (!ret) |
| return NULL; |
| ret->header.__message = header; |
| ret->header.opcode = header->opcode; |
| READ(4, uint32_t, serial); /* serial */ |
| READ_ARRAY(8, rbug_context_t, contexts); /* contexts */ |
| return ret; |
| } |
| struct rbug_proto_context_info_reply * rbug_demarshal_context_info_reply(struct rbug_proto_header *header) |
| { |
| uint32_t len = 0; |
| uint32_t pos = 0; |
| uint8_t *data = NULL; |
| struct rbug_proto_context_info_reply *ret; |
| if (!header) |
| return NULL; |
| if (header->opcode != (int32_t)RBUG_OP_CONTEXT_INFO_REPLY) |
| return NULL; |
| pos = 0; |
| len = header->length * 4; |
| data = (uint8_t*)&header[1]; |
| ret = MALLOC(sizeof(*ret)); |
| if (!ret) |
| return NULL; |
| ret->header.__message = header; |
| ret->header.opcode = header->opcode; |
| READ(4, uint32_t, serial); /* serial */ |
| READ(8, rbug_shader_t, vertex); /* vertex */ |
| READ(8, rbug_shader_t, fragment); /* fragment */ |
| READ_ARRAY(8, rbug_texture_t, texs); /* texs */ |
| READ_ARRAY(8, rbug_texture_t, cbufs); /* cbufs */ |
| READ(8, rbug_texture_t, zsbuf); /* zsbuf */ |
| READ(4, rbug_block_t, blocker); /* blocker */ |
| READ(4, rbug_block_t, blocked); /* blocked */ |
| return ret; |
| } |
| struct rbug_proto_context_draw_blocked * rbug_demarshal_context_draw_blocked(struct rbug_proto_header *header) |
| { |
| uint32_t len = 0; |
| uint32_t pos = 0; |
| uint8_t *data = NULL; |
| struct rbug_proto_context_draw_blocked *ret; |
| if (!header) |
| return NULL; |
| if (header->opcode != (int32_t)RBUG_OP_CONTEXT_DRAW_BLOCKED) |
| return NULL; |
| pos = 0; |
| len = header->length * 4; |
| data = (uint8_t*)&header[1]; |
| ret = MALLOC(sizeof(*ret)); |
| if (!ret) |
| return NULL; |
| ret->header.__message = header; |
| ret->header.opcode = header->opcode; |
| READ(8, rbug_context_t, context); /* context */ |
| READ(4, rbug_block_t, block); /* block */ |
| return ret; |
| } |
| /contrib/sdk/sources/Mesa/mesa-10.6.0/src/gallium/auxiliary/rbug/rbug_context.h |
|---|
| 0,0 → 1,210 |
| /* |
| * Copyright 2009 VMware, Inc. |
| * All Rights Reserved. |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a |
| * copy of this software and associated documentation files (the "Software"), |
| * to deal in the Software without restriction, including without limitation |
| * on the rights to use, copy, modify, merge, publish, distribute, sub |
| * license, and/or sell copies of the Software, and to permit persons to whom |
| * the Software is furnished to do so, subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice (including the next |
| * paragraph) shall be included in all copies or substantial portions of the |
| * Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL |
| * VMWARE AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, |
| * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR |
| * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE |
| * USE OR OTHER DEALINGS IN THE SOFTWARE. |
| */ |
| /* |
| * This file holds structs decelerations and function prototypes for one of |
| * the rbug extensions. Implementation of the functions is in the same folder |
| * in the c file matching this file's name. |
| * |
| * The structs what is returned from the demarshal functions. The functions |
| * starting rbug_send_* encodes a call to the write format and sends that to |
| * the supplied connection, while functions starting with rbug_demarshal_* |
| * demarshal data from the wire protocol. |
| * |
| * Structs and functions ending with _reply are replies to requests. |
| */ |
| #ifndef _RBUG_PROTO_CONTEXT_H_ |
| #define _RBUG_PROTO_CONTEXT_H_ |
| #include "rbug_proto.h" |
| #include "rbug_core.h" |
| typedef enum |
| { |
| RBUG_BLOCK_BEFORE = 1, |
| RBUG_BLOCK_AFTER = 2, |
| RBUG_BLOCK_RULE = 4, |
| RBUG_BLOCK_MASK = 7 |
| } rbug_block_t; |
| struct rbug_proto_context_list |
| { |
| struct rbug_header header; |
| }; |
| struct rbug_proto_context_info |
| { |
| struct rbug_header header; |
| rbug_context_t context; |
| }; |
| struct rbug_proto_context_draw_block |
| { |
| struct rbug_header header; |
| rbug_context_t context; |
| rbug_block_t block; |
| }; |
| struct rbug_proto_context_draw_step |
| { |
| struct rbug_header header; |
| rbug_context_t context; |
| rbug_block_t step; |
| }; |
| struct rbug_proto_context_draw_unblock |
| { |
| struct rbug_header header; |
| rbug_context_t context; |
| rbug_block_t unblock; |
| }; |
| struct rbug_proto_context_draw_rule |
| { |
| struct rbug_header header; |
| rbug_context_t context; |
| rbug_shader_t vertex; |
| rbug_shader_t fragment; |
| rbug_texture_t texture; |
| rbug_texture_t surface; |
| rbug_block_t block; |
| }; |
| struct rbug_proto_context_flush |
| { |
| struct rbug_header header; |
| rbug_context_t context; |
| }; |
| struct rbug_proto_context_list_reply |
| { |
| struct rbug_header header; |
| uint32_t serial; |
| rbug_context_t *contexts; |
| uint32_t contexts_len; |
| }; |
| struct rbug_proto_context_info_reply |
| { |
| struct rbug_header header; |
| uint32_t serial; |
| rbug_shader_t vertex; |
| rbug_shader_t fragment; |
| rbug_texture_t *texs; |
| uint32_t texs_len; |
| rbug_texture_t *cbufs; |
| uint32_t cbufs_len; |
| rbug_texture_t zsbuf; |
| rbug_block_t blocker; |
| rbug_block_t blocked; |
| }; |
| struct rbug_proto_context_draw_blocked |
| { |
| struct rbug_header header; |
| rbug_context_t context; |
| rbug_block_t block; |
| }; |
| int rbug_send_context_list(struct rbug_connection *__con, |
| uint32_t *__serial); |
| int rbug_send_context_info(struct rbug_connection *__con, |
| rbug_context_t context, |
| uint32_t *__serial); |
| int rbug_send_context_draw_block(struct rbug_connection *__con, |
| rbug_context_t context, |
| rbug_block_t block, |
| uint32_t *__serial); |
| int rbug_send_context_draw_step(struct rbug_connection *__con, |
| rbug_context_t context, |
| rbug_block_t step, |
| uint32_t *__serial); |
| int rbug_send_context_draw_unblock(struct rbug_connection *__con, |
| rbug_context_t context, |
| rbug_block_t unblock, |
| uint32_t *__serial); |
| int rbug_send_context_draw_rule(struct rbug_connection *__con, |
| rbug_context_t context, |
| rbug_shader_t vertex, |
| rbug_shader_t fragment, |
| rbug_texture_t texture, |
| rbug_texture_t surface, |
| rbug_block_t block, |
| uint32_t *__serial); |
| int rbug_send_context_flush(struct rbug_connection *__con, |
| rbug_context_t context, |
| uint32_t *__serial); |
| int rbug_send_context_list_reply(struct rbug_connection *__con, |
| uint32_t serial, |
| rbug_context_t *contexts, |
| uint32_t contexts_len, |
| uint32_t *__serial); |
| int rbug_send_context_info_reply(struct rbug_connection *__con, |
| uint32_t serial, |
| rbug_shader_t vertex, |
| rbug_shader_t fragment, |
| rbug_texture_t *texs, |
| uint32_t texs_len, |
| rbug_texture_t *cbufs, |
| uint32_t cbufs_len, |
| rbug_texture_t zsbuf, |
| rbug_block_t blocker, |
| rbug_block_t blocked, |
| uint32_t *__serial); |
| int rbug_send_context_draw_blocked(struct rbug_connection *__con, |
| rbug_context_t context, |
| rbug_block_t block, |
| uint32_t *__serial); |
| struct rbug_proto_context_list * rbug_demarshal_context_list(struct rbug_proto_header *header); |
| struct rbug_proto_context_info * rbug_demarshal_context_info(struct rbug_proto_header *header); |
| struct rbug_proto_context_draw_block * rbug_demarshal_context_draw_block(struct rbug_proto_header *header); |
| struct rbug_proto_context_draw_step * rbug_demarshal_context_draw_step(struct rbug_proto_header *header); |
| struct rbug_proto_context_draw_unblock * rbug_demarshal_context_draw_unblock(struct rbug_proto_header *header); |
| struct rbug_proto_context_draw_rule * rbug_demarshal_context_draw_rule(struct rbug_proto_header *header); |
| struct rbug_proto_context_flush * rbug_demarshal_context_flush(struct rbug_proto_header *header); |
| struct rbug_proto_context_list_reply * rbug_demarshal_context_list_reply(struct rbug_proto_header *header); |
| struct rbug_proto_context_info_reply * rbug_demarshal_context_info_reply(struct rbug_proto_header *header); |
| struct rbug_proto_context_draw_blocked * rbug_demarshal_context_draw_blocked(struct rbug_proto_header *header); |
| #endif |
| /contrib/sdk/sources/Mesa/mesa-10.6.0/src/gallium/auxiliary/rbug/rbug_core.c |
|---|
| 0,0 → 1,345 |
| /* |
| * Copyright 2009 VMware, Inc. |
| * All Rights Reserved. |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a |
| * copy of this software and associated documentation files (the "Software"), |
| * to deal in the Software without restriction, including without limitation |
| * on the rights to use, copy, modify, merge, publish, distribute, sub |
| * license, and/or sell copies of the Software, and to permit persons to whom |
| * the Software is furnished to do so, subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice (including the next |
| * paragraph) shall be included in all copies or substantial portions of the |
| * Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL |
| * VMWARE AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, |
| * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR |
| * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE |
| * USE OR OTHER DEALINGS IN THE SOFTWARE. |
| */ |
| /* |
| * This file holds the function implementation for one of the rbug extensions. |
| * Prototypes and declerations of functions and structs is in the same folder |
| * in the header file matching this file's name. |
| * |
| * The functions starting rbug_send_* encodes a call to the write format and |
| * sends that to the supplied connection, while functions starting with |
| * rbug_demarshal_* demarshal data in the wire protocol. |
| * |
| * Functions ending with _reply are replies to requests. |
| */ |
| #include "rbug_internal.h" |
| #include "rbug_core.h" |
| int rbug_send_noop(struct rbug_connection *__con, |
| uint32_t *__serial) |
| { |
| uint32_t __len = 0; |
| uint32_t __pos = 0; |
| uint8_t *__data = NULL; |
| int __ret = 0; |
| LEN(8); /* header */ |
| /* align */ |
| PAD(__len, 8); |
| __data = (uint8_t*)MALLOC(__len); |
| if (!__data) |
| return -ENOMEM; |
| WRITE(4, int32_t, ((int32_t)RBUG_OP_NOOP)); |
| WRITE(4, uint32_t, ((uint32_t)(__len / 4))); |
| /* final pad */ |
| PAD(__pos, 8); |
| if (__pos != __len) { |
| __ret = -EINVAL; |
| } else { |
| rbug_connection_send_start(__con, RBUG_OP_NOOP, __len); |
| rbug_connection_write(__con, __data, __len); |
| __ret = rbug_connection_send_finish(__con, __serial); |
| } |
| FREE(__data); |
| return __ret; |
| } |
| int rbug_send_ping(struct rbug_connection *__con, |
| uint32_t *__serial) |
| { |
| uint32_t __len = 0; |
| uint32_t __pos = 0; |
| uint8_t *__data = NULL; |
| int __ret = 0; |
| LEN(8); /* header */ |
| /* align */ |
| PAD(__len, 8); |
| __data = (uint8_t*)MALLOC(__len); |
| if (!__data) |
| return -ENOMEM; |
| WRITE(4, int32_t, ((int32_t)RBUG_OP_PING)); |
| WRITE(4, uint32_t, ((uint32_t)(__len / 4))); |
| /* final pad */ |
| PAD(__pos, 8); |
| if (__pos != __len) { |
| __ret = -EINVAL; |
| } else { |
| rbug_connection_send_start(__con, RBUG_OP_PING, __len); |
| rbug_connection_write(__con, __data, __len); |
| __ret = rbug_connection_send_finish(__con, __serial); |
| } |
| FREE(__data); |
| return __ret; |
| } |
| int rbug_send_error(struct rbug_connection *__con, |
| uint32_t error, |
| uint32_t *__serial) |
| { |
| uint32_t __len = 0; |
| uint32_t __pos = 0; |
| uint8_t *__data = NULL; |
| int __ret = 0; |
| LEN(8); /* header */ |
| LEN(4); /* error */ |
| /* align */ |
| PAD(__len, 8); |
| __data = (uint8_t*)MALLOC(__len); |
| if (!__data) |
| return -ENOMEM; |
| WRITE(4, int32_t, ((int32_t)RBUG_OP_ERROR)); |
| WRITE(4, uint32_t, ((uint32_t)(__len / 4))); |
| WRITE(4, uint32_t, error); /* error */ |
| /* final pad */ |
| PAD(__pos, 8); |
| if (__pos != __len) { |
| __ret = -EINVAL; |
| } else { |
| rbug_connection_send_start(__con, RBUG_OP_ERROR, __len); |
| rbug_connection_write(__con, __data, __len); |
| __ret = rbug_connection_send_finish(__con, __serial); |
| } |
| FREE(__data); |
| return __ret; |
| } |
| int rbug_send_ping_reply(struct rbug_connection *__con, |
| uint32_t serial, |
| uint32_t *__serial) |
| { |
| uint32_t __len = 0; |
| uint32_t __pos = 0; |
| uint8_t *__data = NULL; |
| int __ret = 0; |
| LEN(8); /* header */ |
| LEN(4); /* serial */ |
| /* align */ |
| PAD(__len, 8); |
| __data = (uint8_t*)MALLOC(__len); |
| if (!__data) |
| return -ENOMEM; |
| WRITE(4, int32_t, ((int32_t)RBUG_OP_PING_REPLY)); |
| WRITE(4, uint32_t, ((uint32_t)(__len / 4))); |
| WRITE(4, uint32_t, serial); /* serial */ |
| /* final pad */ |
| PAD(__pos, 8); |
| if (__pos != __len) { |
| __ret = -EINVAL; |
| } else { |
| rbug_connection_send_start(__con, RBUG_OP_PING_REPLY, __len); |
| rbug_connection_write(__con, __data, __len); |
| __ret = rbug_connection_send_finish(__con, __serial); |
| } |
| FREE(__data); |
| return __ret; |
| } |
| int rbug_send_error_reply(struct rbug_connection *__con, |
| uint32_t serial, |
| uint32_t error, |
| uint32_t *__serial) |
| { |
| uint32_t __len = 0; |
| uint32_t __pos = 0; |
| uint8_t *__data = NULL; |
| int __ret = 0; |
| LEN(8); /* header */ |
| LEN(4); /* serial */ |
| LEN(4); /* error */ |
| /* align */ |
| PAD(__len, 8); |
| __data = (uint8_t*)MALLOC(__len); |
| if (!__data) |
| return -ENOMEM; |
| WRITE(4, int32_t, ((int32_t)RBUG_OP_ERROR_REPLY)); |
| WRITE(4, uint32_t, ((uint32_t)(__len / 4))); |
| WRITE(4, uint32_t, serial); /* serial */ |
| WRITE(4, uint32_t, error); /* error */ |
| /* final pad */ |
| PAD(__pos, 8); |
| if (__pos != __len) { |
| __ret = -EINVAL; |
| } else { |
| rbug_connection_send_start(__con, RBUG_OP_ERROR_REPLY, __len); |
| rbug_connection_write(__con, __data, __len); |
| __ret = rbug_connection_send_finish(__con, __serial); |
| } |
| FREE(__data); |
| return __ret; |
| } |
| struct rbug_proto_noop * rbug_demarshal_noop(struct rbug_proto_header *header) |
| { |
| struct rbug_proto_noop *ret; |
| if (!header) |
| return NULL; |
| if (header->opcode != (int32_t)RBUG_OP_NOOP) |
| return NULL; |
| ret = MALLOC(sizeof(*ret)); |
| if (!ret) |
| return NULL; |
| ret->header.__message = header; |
| ret->header.opcode = header->opcode; |
| return ret; |
| } |
| struct rbug_proto_ping * rbug_demarshal_ping(struct rbug_proto_header *header) |
| { |
| struct rbug_proto_ping *ret; |
| if (!header) |
| return NULL; |
| if (header->opcode != (int32_t)RBUG_OP_PING) |
| return NULL; |
| ret = MALLOC(sizeof(*ret)); |
| if (!ret) |
| return NULL; |
| ret->header.__message = header; |
| ret->header.opcode = header->opcode; |
| return ret; |
| } |
| struct rbug_proto_error * rbug_demarshal_error(struct rbug_proto_header *header) |
| { |
| uint32_t len = 0; |
| uint32_t pos = 0; |
| uint8_t *data = NULL; |
| struct rbug_proto_error *ret; |
| if (!header) |
| return NULL; |
| if (header->opcode != (int32_t)RBUG_OP_ERROR) |
| return NULL; |
| pos = 0; |
| len = header->length * 4; |
| data = (uint8_t*)&header[1]; |
| ret = MALLOC(sizeof(*ret)); |
| if (!ret) |
| return NULL; |
| ret->header.__message = header; |
| ret->header.opcode = header->opcode; |
| READ(4, uint32_t, error); /* error */ |
| return ret; |
| } |
| struct rbug_proto_ping_reply * rbug_demarshal_ping_reply(struct rbug_proto_header *header) |
| { |
| uint32_t len = 0; |
| uint32_t pos = 0; |
| uint8_t *data = NULL; |
| struct rbug_proto_ping_reply *ret; |
| if (!header) |
| return NULL; |
| if (header->opcode != (int32_t)RBUG_OP_PING_REPLY) |
| return NULL; |
| pos = 0; |
| len = header->length * 4; |
| data = (uint8_t*)&header[1]; |
| ret = MALLOC(sizeof(*ret)); |
| if (!ret) |
| return NULL; |
| ret->header.__message = header; |
| ret->header.opcode = header->opcode; |
| READ(4, uint32_t, serial); /* serial */ |
| return ret; |
| } |
| struct rbug_proto_error_reply * rbug_demarshal_error_reply(struct rbug_proto_header *header) |
| { |
| uint32_t len = 0; |
| uint32_t pos = 0; |
| uint8_t *data = NULL; |
| struct rbug_proto_error_reply *ret; |
| if (!header) |
| return NULL; |
| if (header->opcode != (int32_t)RBUG_OP_ERROR_REPLY) |
| return NULL; |
| pos = 0; |
| len = header->length * 4; |
| data = (uint8_t*)&header[1]; |
| ret = MALLOC(sizeof(*ret)); |
| if (!ret) |
| return NULL; |
| ret->header.__message = header; |
| ret->header.opcode = header->opcode; |
| READ(4, uint32_t, serial); /* serial */ |
| READ(4, uint32_t, error); /* error */ |
| return ret; |
| } |
| /contrib/sdk/sources/Mesa/mesa-10.6.0/src/gallium/auxiliary/rbug/rbug_core.h |
|---|
| 0,0 → 1,105 |
| /* |
| * Copyright 2009 VMware, Inc. |
| * All Rights Reserved. |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a |
| * copy of this software and associated documentation files (the "Software"), |
| * to deal in the Software without restriction, including without limitation |
| * on the rights to use, copy, modify, merge, publish, distribute, sub |
| * license, and/or sell copies of the Software, and to permit persons to whom |
| * the Software is furnished to do so, subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice (including the next |
| * paragraph) shall be included in all copies or substantial portions of the |
| * Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL |
| * VMWARE AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, |
| * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR |
| * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE |
| * USE OR OTHER DEALINGS IN THE SOFTWARE. |
| */ |
| /* |
| * This file holds structs decelerations and function prototypes for one of |
| * the rbug extensions. Implementation of the functions is in the same folder |
| * in the c file matching this file's name. |
| * |
| * The structs what is returned from the demarshal functions. The functions |
| * starting rbug_send_* encodes a call to the write format and sends that to |
| * the supplied connection, while functions starting with rbug_demarshal_* |
| * demarshal data from the wire protocol. |
| * |
| * Structs and functions ending with _reply are replies to requests. |
| */ |
| #ifndef _RBUG_PROTO_CORE_H_ |
| #define _RBUG_PROTO_CORE_H_ |
| #include "rbug_proto.h" |
| typedef uint64_t rbug_shader_t; |
| typedef uint64_t rbug_context_t; |
| typedef uint64_t rbug_texture_t; |
| struct rbug_proto_noop |
| { |
| struct rbug_header header; |
| }; |
| struct rbug_proto_ping |
| { |
| struct rbug_header header; |
| }; |
| struct rbug_proto_error |
| { |
| struct rbug_header header; |
| uint32_t error; |
| }; |
| struct rbug_proto_ping_reply |
| { |
| struct rbug_header header; |
| uint32_t serial; |
| }; |
| struct rbug_proto_error_reply |
| { |
| struct rbug_header header; |
| uint32_t serial; |
| uint32_t error; |
| }; |
| int rbug_send_noop(struct rbug_connection *__con, |
| uint32_t *__serial); |
| int rbug_send_ping(struct rbug_connection *__con, |
| uint32_t *__serial); |
| int rbug_send_error(struct rbug_connection *__con, |
| uint32_t error, |
| uint32_t *__serial); |
| int rbug_send_ping_reply(struct rbug_connection *__con, |
| uint32_t serial, |
| uint32_t *__serial); |
| int rbug_send_error_reply(struct rbug_connection *__con, |
| uint32_t serial, |
| uint32_t error, |
| uint32_t *__serial); |
| struct rbug_proto_noop * rbug_demarshal_noop(struct rbug_proto_header *header); |
| struct rbug_proto_ping * rbug_demarshal_ping(struct rbug_proto_header *header); |
| struct rbug_proto_error * rbug_demarshal_error(struct rbug_proto_header *header); |
| struct rbug_proto_ping_reply * rbug_demarshal_ping_reply(struct rbug_proto_header *header); |
| struct rbug_proto_error_reply * rbug_demarshal_error_reply(struct rbug_proto_header *header); |
| #endif |
| /contrib/sdk/sources/Mesa/mesa-10.6.0/src/gallium/auxiliary/rbug/rbug_demarshal.c |
|---|
| 0,0 → 1,157 |
| /* |
| * Copyright 2009 VMware, Inc. |
| * All Rights Reserved. |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a |
| * copy of this software and associated documentation files (the "Software"), |
| * to deal in the Software without restriction, including without limitation |
| * on the rights to use, copy, modify, merge, publish, distribute, sub |
| * license, and/or sell copies of the Software, and to permit persons to whom |
| * the Software is furnished to do so, subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice (including the next |
| * paragraph) shall be included in all copies or substantial portions of the |
| * Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL |
| * VMWARE AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, |
| * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR |
| * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE |
| * USE OR OTHER DEALINGS IN THE SOFTWARE. |
| */ |
| #include "rbug.h" |
| /** |
| * Small function that looks at the proto_header and selects the correct |
| * demarshal functions and return the result. |
| */ |
| struct rbug_header * rbug_demarshal(struct rbug_proto_header *header) |
| { |
| switch(header->opcode) { |
| case RBUG_OP_NOOP: |
| return (struct rbug_header *)rbug_demarshal_noop(header); |
| case RBUG_OP_PING: |
| return (struct rbug_header *)rbug_demarshal_ping(header); |
| case RBUG_OP_ERROR: |
| return (struct rbug_header *)rbug_demarshal_error(header); |
| case RBUG_OP_PING_REPLY: |
| return (struct rbug_header *)rbug_demarshal_ping_reply(header); |
| case RBUG_OP_ERROR_REPLY: |
| return (struct rbug_header *)rbug_demarshal_error_reply(header); |
| case RBUG_OP_TEXTURE_LIST: |
| return (struct rbug_header *)rbug_demarshal_texture_list(header); |
| case RBUG_OP_TEXTURE_INFO: |
| return (struct rbug_header *)rbug_demarshal_texture_info(header); |
| case RBUG_OP_TEXTURE_WRITE: |
| return (struct rbug_header *)rbug_demarshal_texture_write(header); |
| case RBUG_OP_TEXTURE_READ: |
| return (struct rbug_header *)rbug_demarshal_texture_read(header); |
| case RBUG_OP_TEXTURE_LIST_REPLY: |
| return (struct rbug_header *)rbug_demarshal_texture_list_reply(header); |
| case RBUG_OP_TEXTURE_INFO_REPLY: |
| return (struct rbug_header *)rbug_demarshal_texture_info_reply(header); |
| case RBUG_OP_TEXTURE_READ_REPLY: |
| return (struct rbug_header *)rbug_demarshal_texture_read_reply(header); |
| case RBUG_OP_CONTEXT_LIST: |
| return (struct rbug_header *)rbug_demarshal_context_list(header); |
| case RBUG_OP_CONTEXT_INFO: |
| return (struct rbug_header *)rbug_demarshal_context_info(header); |
| case RBUG_OP_CONTEXT_DRAW_BLOCK: |
| return (struct rbug_header *)rbug_demarshal_context_draw_block(header); |
| case RBUG_OP_CONTEXT_DRAW_STEP: |
| return (struct rbug_header *)rbug_demarshal_context_draw_step(header); |
| case RBUG_OP_CONTEXT_DRAW_UNBLOCK: |
| return (struct rbug_header *)rbug_demarshal_context_draw_unblock(header); |
| case RBUG_OP_CONTEXT_DRAW_RULE: |
| return (struct rbug_header *)rbug_demarshal_context_draw_rule(header); |
| case RBUG_OP_CONTEXT_FLUSH: |
| return (struct rbug_header *)rbug_demarshal_context_flush(header); |
| case RBUG_OP_CONTEXT_LIST_REPLY: |
| return (struct rbug_header *)rbug_demarshal_context_list_reply(header); |
| case RBUG_OP_CONTEXT_INFO_REPLY: |
| return (struct rbug_header *)rbug_demarshal_context_info_reply(header); |
| case RBUG_OP_CONTEXT_DRAW_BLOCKED: |
| return (struct rbug_header *)rbug_demarshal_context_draw_blocked(header); |
| case RBUG_OP_SHADER_LIST: |
| return (struct rbug_header *)rbug_demarshal_shader_list(header); |
| case RBUG_OP_SHADER_INFO: |
| return (struct rbug_header *)rbug_demarshal_shader_info(header); |
| case RBUG_OP_SHADER_DISABLE: |
| return (struct rbug_header *)rbug_demarshal_shader_disable(header); |
| case RBUG_OP_SHADER_REPLACE: |
| return (struct rbug_header *)rbug_demarshal_shader_replace(header); |
| case RBUG_OP_SHADER_LIST_REPLY: |
| return (struct rbug_header *)rbug_demarshal_shader_list_reply(header); |
| case RBUG_OP_SHADER_INFO_REPLY: |
| return (struct rbug_header *)rbug_demarshal_shader_info_reply(header); |
| default: |
| return NULL; |
| } |
| } |
| const char* rbug_proto_get_name(enum rbug_opcode opcode) |
| { |
| switch(opcode) { |
| case RBUG_OP_NOOP: |
| return "RBUG_OP_NOOP"; |
| case RBUG_OP_PING: |
| return "RBUG_OP_PING"; |
| case RBUG_OP_ERROR: |
| return "RBUG_OP_ERROR"; |
| case RBUG_OP_PING_REPLY: |
| return "RBUG_OP_PING_REPLY"; |
| case RBUG_OP_ERROR_REPLY: |
| return "RBUG_OP_ERROR_REPLY"; |
| case RBUG_OP_TEXTURE_LIST: |
| return "RBUG_OP_TEXTURE_LIST"; |
| case RBUG_OP_TEXTURE_INFO: |
| return "RBUG_OP_TEXTURE_INFO"; |
| case RBUG_OP_TEXTURE_WRITE: |
| return "RBUG_OP_TEXTURE_WRITE"; |
| case RBUG_OP_TEXTURE_READ: |
| return "RBUG_OP_TEXTURE_READ"; |
| case RBUG_OP_TEXTURE_LIST_REPLY: |
| return "RBUG_OP_TEXTURE_LIST_REPLY"; |
| case RBUG_OP_TEXTURE_INFO_REPLY: |
| return "RBUG_OP_TEXTURE_INFO_REPLY"; |
| case RBUG_OP_TEXTURE_READ_REPLY: |
| return "RBUG_OP_TEXTURE_READ_REPLY"; |
| case RBUG_OP_CONTEXT_LIST: |
| return "RBUG_OP_CONTEXT_LIST"; |
| case RBUG_OP_CONTEXT_INFO: |
| return "RBUG_OP_CONTEXT_INFO"; |
| case RBUG_OP_CONTEXT_DRAW_BLOCK: |
| return "RBUG_OP_CONTEXT_DRAW_BLOCK"; |
| case RBUG_OP_CONTEXT_DRAW_STEP: |
| return "RBUG_OP_CONTEXT_DRAW_STEP"; |
| case RBUG_OP_CONTEXT_DRAW_UNBLOCK: |
| return "RBUG_OP_CONTEXT_DRAW_UNBLOCK"; |
| case RBUG_OP_CONTEXT_DRAW_RULE: |
| return "RBUG_OP_CONTEXT_DRAW_RULE"; |
| case RBUG_OP_CONTEXT_FLUSH: |
| return "RBUG_OP_CONTEXT_FLUSH"; |
| case RBUG_OP_CONTEXT_LIST_REPLY: |
| return "RBUG_OP_CONTEXT_LIST_REPLY"; |
| case RBUG_OP_CONTEXT_INFO_REPLY: |
| return "RBUG_OP_CONTEXT_INFO_REPLY"; |
| case RBUG_OP_CONTEXT_DRAW_BLOCKED: |
| return "RBUG_OP_CONTEXT_DRAW_BLOCKED"; |
| case RBUG_OP_SHADER_LIST: |
| return "RBUG_OP_SHADER_LIST"; |
| case RBUG_OP_SHADER_INFO: |
| return "RBUG_OP_SHADER_INFO"; |
| case RBUG_OP_SHADER_DISABLE: |
| return "RBUG_OP_SHADER_DISABLE"; |
| case RBUG_OP_SHADER_REPLACE: |
| return "RBUG_OP_SHADER_REPLACE"; |
| case RBUG_OP_SHADER_LIST_REPLY: |
| return "RBUG_OP_SHADER_LIST_REPLY"; |
| case RBUG_OP_SHADER_INFO_REPLY: |
| return "RBUG_OP_SHADER_INFO_REPLY"; |
| default: |
| return NULL; |
| } |
| } |
| /contrib/sdk/sources/Mesa/mesa-10.6.0/src/gallium/auxiliary/rbug/rbug_internal.h |
|---|
| 0,0 → 1,100 |
| /* |
| * Copyright 2009 VMware, Inc. |
| * All Rights Reserved. |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a |
| * copy of this software and associated documentation files (the "Software"), |
| * to deal in the Software without restriction, including without limitation |
| * on the rights to use, copy, modify, merge, publish, distribute, sub |
| * license, and/or sell copies of the Software, and to permit persons to whom |
| * the Software is furnished to do so, subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice (including the next |
| * paragraph) shall be included in all copies or substantial portions of the |
| * Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL |
| * VMWARE AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, |
| * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR |
| * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE |
| * USE OR OTHER DEALINGS IN THE SOFTWARE. |
| */ |
| /* |
| * This file is internal to the rbug protocol code, and contains asorted |
| * features needed by the code. |
| */ |
| #ifndef _RBUG_INTERNAL_H_ |
| #define _RBUG_INTERNAL_H_ |
| #include "rbug_proto.h" |
| #include "util/u_memory.h" |
| #include "util/u_debug.h" |
| #include <errno.h> |
| int rbug_connection_send_start(struct rbug_connection *con, enum rbug_opcode opcode, uint32_t length); |
| int rbug_connection_write(struct rbug_connection *con, void *data, uint32_t size); |
| int rbug_connection_send_finish(struct rbug_connection *con, uint32_t *c); |
| /** |
| * Only works with multiples of 2 |
| */ |
| #define PAD(from, to) \ |
| do { \ |
| from = (from + to - 1) & ~(to - 1); \ |
| } while(0) |
| #define LEN(size) \ |
| do { \ |
| PAD(__len, size); \ |
| __len += size; \ |
| } while(0) |
| #define LEN_ARRAY(size, name) \ |
| do { \ |
| LEN(4); \ |
| PAD(__len, size); \ |
| __len += size * name##_len; \ |
| } while(0) |
| #define WRITE(size, type, name) \ |
| do { \ |
| PAD(__pos, size); \ |
| *((type *)(&__data[__pos])) = name; \ |
| __pos += size; \ |
| } while(0) |
| #define WRITE_ARRAY(size, type, name) \ |
| do { \ |
| WRITE(4, uint32_t, name##_len); \ |
| PAD(__pos, size); \ |
| memcpy(&__data[__pos], name, size * name##_len); \ |
| __pos += size * name##_len; \ |
| } while(0) |
| #define READ(size, type, name) \ |
| do { \ |
| PAD(pos, size); \ |
| pos += size; \ |
| if (pos > len) \ |
| break; \ |
| ret->name = *((type *)(&data[pos - size])); \ |
| } while(0) |
| #define READ_ARRAY(size, type, name) \ |
| do { \ |
| READ(4, uint32_t, name##_len); \ |
| if (pos > len) \ |
| break; \ |
| PAD(pos, size); \ |
| pos += size * ret->name##_len; \ |
| if (pos > len) \ |
| break; \ |
| ret->name = (type *)&data[pos - size * ret->name##_len]; \ |
| } while(0) |
| #endif |
| /contrib/sdk/sources/Mesa/mesa-10.6.0/src/gallium/auxiliary/rbug/rbug_proto.h |
|---|
| 0,0 → 1,99 |
| /* |
| * Copyright 2009 VMware, Inc. |
| * All Rights Reserved. |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a |
| * copy of this software and associated documentation files (the "Software"), |
| * to deal in the Software without restriction, including without limitation |
| * on the rights to use, copy, modify, merge, publish, distribute, sub |
| * license, and/or sell copies of the Software, and to permit persons to whom |
| * the Software is furnished to do so, subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice (including the next |
| * paragraph) shall be included in all copies or substantial portions of the |
| * Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL |
| * VMWARE AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, |
| * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR |
| * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE |
| * USE OR OTHER DEALINGS IN THE SOFTWARE. |
| */ |
| /* |
| * This file holds common definitions of the gallium remote debugging protocol. |
| */ |
| #ifndef _RBUG_PROTO_H_ |
| #define _RBUG_PROTO_H_ |
| #include "pipe/p_compiler.h" |
| /** |
| * Uniqe indentifier for each command. |
| * |
| * Replys are designated by negative. |
| */ |
| enum rbug_opcode |
| { |
| RBUG_OP_NOOP = 0, |
| RBUG_OP_PING = 1, |
| RBUG_OP_ERROR = 2, |
| RBUG_OP_PING_REPLY = -1, |
| RBUG_OP_ERROR_REPLY = -2, |
| RBUG_OP_TEXTURE_LIST = 256, |
| RBUG_OP_TEXTURE_INFO = 257, |
| RBUG_OP_TEXTURE_WRITE = 258, |
| RBUG_OP_TEXTURE_READ = 259, |
| RBUG_OP_TEXTURE_LIST_REPLY = -256, |
| RBUG_OP_TEXTURE_INFO_REPLY = -257, |
| RBUG_OP_TEXTURE_READ_REPLY = -259, |
| RBUG_OP_CONTEXT_LIST = 512, |
| RBUG_OP_CONTEXT_INFO = 513, |
| RBUG_OP_CONTEXT_DRAW_BLOCK = 514, |
| RBUG_OP_CONTEXT_DRAW_STEP = 515, |
| RBUG_OP_CONTEXT_DRAW_UNBLOCK = 516, |
| RBUG_OP_CONTEXT_DRAW_RULE = 518, |
| RBUG_OP_CONTEXT_FLUSH = 519, |
| RBUG_OP_CONTEXT_LIST_REPLY = -512, |
| RBUG_OP_CONTEXT_INFO_REPLY = -513, |
| RBUG_OP_CONTEXT_DRAW_BLOCKED = 517, |
| RBUG_OP_SHADER_LIST = 768, |
| RBUG_OP_SHADER_INFO = 769, |
| RBUG_OP_SHADER_DISABLE = 770, |
| RBUG_OP_SHADER_REPLACE = 771, |
| RBUG_OP_SHADER_LIST_REPLY = -768, |
| RBUG_OP_SHADER_INFO_REPLY = -769 |
| }; |
| /** |
| * Header for demarshaled message. |
| */ |
| struct rbug_header |
| { |
| enum rbug_opcode opcode; |
| void *__message; |
| }; |
| /** |
| * Header for a message in wire format. |
| */ |
| struct rbug_proto_header |
| { |
| int32_t opcode; |
| uint32_t length; |
| }; |
| /** |
| * Forward declare connection here, as this file is included by all users. |
| */ |
| struct rbug_connection; |
| /** |
| * Get printable string for opcode. |
| */ |
| const char* rbug_proto_get_name(enum rbug_opcode opcode); |
| #endif |
| /contrib/sdk/sources/Mesa/mesa-10.6.0/src/gallium/auxiliary/rbug/rbug_shader.c |
|---|
| 0,0 → 1,468 |
| /* |
| * Copyright 2009 VMware, Inc. |
| * All Rights Reserved. |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a |
| * copy of this software and associated documentation files (the "Software"), |
| * to deal in the Software without restriction, including without limitation |
| * on the rights to use, copy, modify, merge, publish, distribute, sub |
| * license, and/or sell copies of the Software, and to permit persons to whom |
| * the Software is furnished to do so, subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice (including the next |
| * paragraph) shall be included in all copies or substantial portions of the |
| * Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL |
| * VMWARE AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, |
| * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR |
| * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE |
| * USE OR OTHER DEALINGS IN THE SOFTWARE. |
| */ |
| /* |
| * This file holds the function implementation for one of the rbug extensions. |
| * Prototypes and declerations of functions and structs is in the same folder |
| * in the header file matching this file's name. |
| * |
| * The functions starting rbug_send_* encodes a call to the write format and |
| * sends that to the supplied connection, while functions starting with |
| * rbug_demarshal_* demarshal data in the wire protocol. |
| * |
| * Functions ending with _reply are replies to requests. |
| */ |
| #include "rbug_internal.h" |
| #include "rbug_shader.h" |
| int rbug_send_shader_list(struct rbug_connection *__con, |
| rbug_context_t context, |
| uint32_t *__serial) |
| { |
| uint32_t __len = 0; |
| uint32_t __pos = 0; |
| uint8_t *__data = NULL; |
| int __ret = 0; |
| LEN(8); /* header */ |
| LEN(8); /* context */ |
| /* align */ |
| PAD(__len, 8); |
| __data = (uint8_t*)MALLOC(__len); |
| if (!__data) |
| return -ENOMEM; |
| WRITE(4, int32_t, ((int32_t)RBUG_OP_SHADER_LIST)); |
| WRITE(4, uint32_t, ((uint32_t)(__len / 4))); |
| WRITE(8, rbug_context_t, context); /* context */ |
| /* final pad */ |
| PAD(__pos, 8); |
| if (__pos != __len) { |
| __ret = -EINVAL; |
| } else { |
| rbug_connection_send_start(__con, RBUG_OP_SHADER_LIST, __len); |
| rbug_connection_write(__con, __data, __len); |
| __ret = rbug_connection_send_finish(__con, __serial); |
| } |
| FREE(__data); |
| return __ret; |
| } |
| int rbug_send_shader_info(struct rbug_connection *__con, |
| rbug_context_t context, |
| rbug_shader_t shader, |
| uint32_t *__serial) |
| { |
| uint32_t __len = 0; |
| uint32_t __pos = 0; |
| uint8_t *__data = NULL; |
| int __ret = 0; |
| LEN(8); /* header */ |
| LEN(8); /* context */ |
| LEN(8); /* shader */ |
| /* align */ |
| PAD(__len, 8); |
| __data = (uint8_t*)MALLOC(__len); |
| if (!__data) |
| return -ENOMEM; |
| WRITE(4, int32_t, ((int32_t)RBUG_OP_SHADER_INFO)); |
| WRITE(4, uint32_t, ((uint32_t)(__len / 4))); |
| WRITE(8, rbug_context_t, context); /* context */ |
| WRITE(8, rbug_shader_t, shader); /* shader */ |
| /* final pad */ |
| PAD(__pos, 8); |
| if (__pos != __len) { |
| __ret = -EINVAL; |
| } else { |
| rbug_connection_send_start(__con, RBUG_OP_SHADER_INFO, __len); |
| rbug_connection_write(__con, __data, __len); |
| __ret = rbug_connection_send_finish(__con, __serial); |
| } |
| FREE(__data); |
| return __ret; |
| } |
| int rbug_send_shader_disable(struct rbug_connection *__con, |
| rbug_context_t context, |
| rbug_shader_t shader, |
| uint8_t disable, |
| uint32_t *__serial) |
| { |
| uint32_t __len = 0; |
| uint32_t __pos = 0; |
| uint8_t *__data = NULL; |
| int __ret = 0; |
| LEN(8); /* header */ |
| LEN(8); /* context */ |
| LEN(8); /* shader */ |
| LEN(1); /* disable */ |
| /* align */ |
| PAD(__len, 8); |
| __data = (uint8_t*)MALLOC(__len); |
| if (!__data) |
| return -ENOMEM; |
| WRITE(4, int32_t, ((int32_t)RBUG_OP_SHADER_DISABLE)); |
| WRITE(4, uint32_t, ((uint32_t)(__len / 4))); |
| WRITE(8, rbug_context_t, context); /* context */ |
| WRITE(8, rbug_shader_t, shader); /* shader */ |
| WRITE(1, uint8_t, disable); /* disable */ |
| /* final pad */ |
| PAD(__pos, 8); |
| if (__pos != __len) { |
| __ret = -EINVAL; |
| } else { |
| rbug_connection_send_start(__con, RBUG_OP_SHADER_DISABLE, __len); |
| rbug_connection_write(__con, __data, __len); |
| __ret = rbug_connection_send_finish(__con, __serial); |
| } |
| FREE(__data); |
| return __ret; |
| } |
| int rbug_send_shader_replace(struct rbug_connection *__con, |
| rbug_context_t context, |
| rbug_shader_t shader, |
| uint32_t *tokens, |
| uint32_t tokens_len, |
| uint32_t *__serial) |
| { |
| uint32_t __len = 0; |
| uint32_t __pos = 0; |
| uint8_t *__data = NULL; |
| int __ret = 0; |
| LEN(8); /* header */ |
| LEN(8); /* context */ |
| LEN(8); /* shader */ |
| LEN_ARRAY(4, tokens); /* tokens */ |
| /* align */ |
| PAD(__len, 8); |
| __data = (uint8_t*)MALLOC(__len); |
| if (!__data) |
| return -ENOMEM; |
| WRITE(4, int32_t, ((int32_t)RBUG_OP_SHADER_REPLACE)); |
| WRITE(4, uint32_t, ((uint32_t)(__len / 4))); |
| WRITE(8, rbug_context_t, context); /* context */ |
| WRITE(8, rbug_shader_t, shader); /* shader */ |
| WRITE_ARRAY(4, uint32_t, tokens); /* tokens */ |
| /* final pad */ |
| PAD(__pos, 8); |
| if (__pos != __len) { |
| __ret = -EINVAL; |
| } else { |
| rbug_connection_send_start(__con, RBUG_OP_SHADER_REPLACE, __len); |
| rbug_connection_write(__con, __data, __len); |
| __ret = rbug_connection_send_finish(__con, __serial); |
| } |
| FREE(__data); |
| return __ret; |
| } |
| int rbug_send_shader_list_reply(struct rbug_connection *__con, |
| uint32_t serial, |
| rbug_shader_t *shaders, |
| uint32_t shaders_len, |
| uint32_t *__serial) |
| { |
| uint32_t __len = 0; |
| uint32_t __pos = 0; |
| uint8_t *__data = NULL; |
| int __ret = 0; |
| LEN(8); /* header */ |
| LEN(4); /* serial */ |
| LEN_ARRAY(8, shaders); /* shaders */ |
| /* align */ |
| PAD(__len, 8); |
| __data = (uint8_t*)MALLOC(__len); |
| if (!__data) |
| return -ENOMEM; |
| WRITE(4, int32_t, ((int32_t)RBUG_OP_SHADER_LIST_REPLY)); |
| WRITE(4, uint32_t, ((uint32_t)(__len / 4))); |
| WRITE(4, uint32_t, serial); /* serial */ |
| WRITE_ARRAY(8, rbug_shader_t, shaders); /* shaders */ |
| /* final pad */ |
| PAD(__pos, 8); |
| if (__pos != __len) { |
| __ret = -EINVAL; |
| } else { |
| rbug_connection_send_start(__con, RBUG_OP_SHADER_LIST_REPLY, __len); |
| rbug_connection_write(__con, __data, __len); |
| __ret = rbug_connection_send_finish(__con, __serial); |
| } |
| FREE(__data); |
| return __ret; |
| } |
| int rbug_send_shader_info_reply(struct rbug_connection *__con, |
| uint32_t serial, |
| uint32_t *original, |
| uint32_t original_len, |
| uint32_t *replaced, |
| uint32_t replaced_len, |
| uint8_t disabled, |
| uint32_t *__serial) |
| { |
| uint32_t __len = 0; |
| uint32_t __pos = 0; |
| uint8_t *__data = NULL; |
| int __ret = 0; |
| LEN(8); /* header */ |
| LEN(4); /* serial */ |
| LEN_ARRAY(4, original); /* original */ |
| LEN_ARRAY(4, replaced); /* replaced */ |
| LEN(1); /* disabled */ |
| /* align */ |
| PAD(__len, 8); |
| __data = (uint8_t*)MALLOC(__len); |
| if (!__data) |
| return -ENOMEM; |
| WRITE(4, int32_t, ((int32_t)RBUG_OP_SHADER_INFO_REPLY)); |
| WRITE(4, uint32_t, ((uint32_t)(__len / 4))); |
| WRITE(4, uint32_t, serial); /* serial */ |
| WRITE_ARRAY(4, uint32_t, original); /* original */ |
| WRITE_ARRAY(4, uint32_t, replaced); /* replaced */ |
| WRITE(1, uint8_t, disabled); /* disabled */ |
| /* final pad */ |
| PAD(__pos, 8); |
| if (__pos != __len) { |
| __ret = -EINVAL; |
| } else { |
| rbug_connection_send_start(__con, RBUG_OP_SHADER_INFO_REPLY, __len); |
| rbug_connection_write(__con, __data, __len); |
| __ret = rbug_connection_send_finish(__con, __serial); |
| } |
| FREE(__data); |
| return __ret; |
| } |
| struct rbug_proto_shader_list * rbug_demarshal_shader_list(struct rbug_proto_header *header) |
| { |
| uint32_t len = 0; |
| uint32_t pos = 0; |
| uint8_t *data = NULL; |
| struct rbug_proto_shader_list *ret; |
| if (!header) |
| return NULL; |
| if (header->opcode != (int32_t)RBUG_OP_SHADER_LIST) |
| return NULL; |
| pos = 0; |
| len = header->length * 4; |
| data = (uint8_t*)&header[1]; |
| ret = MALLOC(sizeof(*ret)); |
| if (!ret) |
| return NULL; |
| ret->header.__message = header; |
| ret->header.opcode = header->opcode; |
| READ(8, rbug_context_t, context); /* context */ |
| return ret; |
| } |
| struct rbug_proto_shader_info * rbug_demarshal_shader_info(struct rbug_proto_header *header) |
| { |
| uint32_t len = 0; |
| uint32_t pos = 0; |
| uint8_t *data = NULL; |
| struct rbug_proto_shader_info *ret; |
| if (!header) |
| return NULL; |
| if (header->opcode != (int32_t)RBUG_OP_SHADER_INFO) |
| return NULL; |
| pos = 0; |
| len = header->length * 4; |
| data = (uint8_t*)&header[1]; |
| ret = MALLOC(sizeof(*ret)); |
| if (!ret) |
| return NULL; |
| ret->header.__message = header; |
| ret->header.opcode = header->opcode; |
| READ(8, rbug_context_t, context); /* context */ |
| READ(8, rbug_shader_t, shader); /* shader */ |
| return ret; |
| } |
| struct rbug_proto_shader_disable * rbug_demarshal_shader_disable(struct rbug_proto_header *header) |
| { |
| uint32_t len = 0; |
| uint32_t pos = 0; |
| uint8_t *data = NULL; |
| struct rbug_proto_shader_disable *ret; |
| if (!header) |
| return NULL; |
| if (header->opcode != (int32_t)RBUG_OP_SHADER_DISABLE) |
| return NULL; |
| pos = 0; |
| len = header->length * 4; |
| data = (uint8_t*)&header[1]; |
| ret = MALLOC(sizeof(*ret)); |
| if (!ret) |
| return NULL; |
| ret->header.__message = header; |
| ret->header.opcode = header->opcode; |
| READ(8, rbug_context_t, context); /* context */ |
| READ(8, rbug_shader_t, shader); /* shader */ |
| READ(1, uint8_t, disable); /* disable */ |
| return ret; |
| } |
| struct rbug_proto_shader_replace * rbug_demarshal_shader_replace(struct rbug_proto_header *header) |
| { |
| uint32_t len = 0; |
| uint32_t pos = 0; |
| uint8_t *data = NULL; |
| struct rbug_proto_shader_replace *ret; |
| if (!header) |
| return NULL; |
| if (header->opcode != (int32_t)RBUG_OP_SHADER_REPLACE) |
| return NULL; |
| pos = 0; |
| len = header->length * 4; |
| data = (uint8_t*)&header[1]; |
| ret = MALLOC(sizeof(*ret)); |
| if (!ret) |
| return NULL; |
| ret->header.__message = header; |
| ret->header.opcode = header->opcode; |
| READ(8, rbug_context_t, context); /* context */ |
| READ(8, rbug_shader_t, shader); /* shader */ |
| READ_ARRAY(4, uint32_t, tokens); /* tokens */ |
| return ret; |
| } |
| struct rbug_proto_shader_list_reply * rbug_demarshal_shader_list_reply(struct rbug_proto_header *header) |
| { |
| uint32_t len = 0; |
| uint32_t pos = 0; |
| uint8_t *data = NULL; |
| struct rbug_proto_shader_list_reply *ret; |
| if (!header) |
| return NULL; |
| if (header->opcode != (int32_t)RBUG_OP_SHADER_LIST_REPLY) |
| return NULL; |
| pos = 0; |
| len = header->length * 4; |
| data = (uint8_t*)&header[1]; |
| ret = MALLOC(sizeof(*ret)); |
| if (!ret) |
| return NULL; |
| ret->header.__message = header; |
| ret->header.opcode = header->opcode; |
| READ(4, uint32_t, serial); /* serial */ |
| READ_ARRAY(8, rbug_shader_t, shaders); /* shaders */ |
| return ret; |
| } |
| struct rbug_proto_shader_info_reply * rbug_demarshal_shader_info_reply(struct rbug_proto_header *header) |
| { |
| uint32_t len = 0; |
| uint32_t pos = 0; |
| uint8_t *data = NULL; |
| struct rbug_proto_shader_info_reply *ret; |
| if (!header) |
| return NULL; |
| if (header->opcode != (int32_t)RBUG_OP_SHADER_INFO_REPLY) |
| return NULL; |
| pos = 0; |
| len = header->length * 4; |
| data = (uint8_t*)&header[1]; |
| ret = MALLOC(sizeof(*ret)); |
| if (!ret) |
| return NULL; |
| ret->header.__message = header; |
| ret->header.opcode = header->opcode; |
| READ(4, uint32_t, serial); /* serial */ |
| READ_ARRAY(4, uint32_t, original); /* original */ |
| READ_ARRAY(4, uint32_t, replaced); /* replaced */ |
| READ(1, uint8_t, disabled); /* disabled */ |
| return ret; |
| } |
| /contrib/sdk/sources/Mesa/mesa-10.6.0/src/gallium/auxiliary/rbug/rbug_shader.h |
|---|
| 0,0 → 1,142 |
| /* |
| * Copyright 2009 VMware, Inc. |
| * All Rights Reserved. |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a |
| * copy of this software and associated documentation files (the "Software"), |
| * to deal in the Software without restriction, including without limitation |
| * on the rights to use, copy, modify, merge, publish, distribute, sub |
| * license, and/or sell copies of the Software, and to permit persons to whom |
| * the Software is furnished to do so, subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice (including the next |
| * paragraph) shall be included in all copies or substantial portions of the |
| * Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL |
| * VMWARE AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, |
| * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR |
| * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE |
| * USE OR OTHER DEALINGS IN THE SOFTWARE. |
| */ |
| /* |
| * This file holds structs decelerations and function prototypes for one of |
| * the rbug extensions. Implementation of the functions is in the same folder |
| * in the c file matching this file's name. |
| * |
| * The structs what is returned from the demarshal functions. The functions |
| * starting rbug_send_* encodes a call to the write format and sends that to |
| * the supplied connection, while functions starting with rbug_demarshal_* |
| * demarshal data from the wire protocol. |
| * |
| * Structs and functions ending with _reply are replies to requests. |
| */ |
| #ifndef _RBUG_PROTO_SHADER_H_ |
| #define _RBUG_PROTO_SHADER_H_ |
| #include "rbug_proto.h" |
| #include "rbug_core.h" |
| struct rbug_proto_shader_list |
| { |
| struct rbug_header header; |
| rbug_context_t context; |
| }; |
| struct rbug_proto_shader_info |
| { |
| struct rbug_header header; |
| rbug_context_t context; |
| rbug_shader_t shader; |
| }; |
| struct rbug_proto_shader_disable |
| { |
| struct rbug_header header; |
| rbug_context_t context; |
| rbug_shader_t shader; |
| uint8_t disable; |
| }; |
| struct rbug_proto_shader_replace |
| { |
| struct rbug_header header; |
| rbug_context_t context; |
| rbug_shader_t shader; |
| uint32_t *tokens; |
| uint32_t tokens_len; |
| }; |
| struct rbug_proto_shader_list_reply |
| { |
| struct rbug_header header; |
| uint32_t serial; |
| rbug_shader_t *shaders; |
| uint32_t shaders_len; |
| }; |
| struct rbug_proto_shader_info_reply |
| { |
| struct rbug_header header; |
| uint32_t serial; |
| uint32_t *original; |
| uint32_t original_len; |
| uint32_t *replaced; |
| uint32_t replaced_len; |
| uint8_t disabled; |
| }; |
| int rbug_send_shader_list(struct rbug_connection *__con, |
| rbug_context_t context, |
| uint32_t *__serial); |
| int rbug_send_shader_info(struct rbug_connection *__con, |
| rbug_context_t context, |
| rbug_shader_t shader, |
| uint32_t *__serial); |
| int rbug_send_shader_disable(struct rbug_connection *__con, |
| rbug_context_t context, |
| rbug_shader_t shader, |
| uint8_t disable, |
| uint32_t *__serial); |
| int rbug_send_shader_replace(struct rbug_connection *__con, |
| rbug_context_t context, |
| rbug_shader_t shader, |
| uint32_t *tokens, |
| uint32_t tokens_len, |
| uint32_t *__serial); |
| int rbug_send_shader_list_reply(struct rbug_connection *__con, |
| uint32_t serial, |
| rbug_shader_t *shaders, |
| uint32_t shaders_len, |
| uint32_t *__serial); |
| int rbug_send_shader_info_reply(struct rbug_connection *__con, |
| uint32_t serial, |
| uint32_t *original, |
| uint32_t original_len, |
| uint32_t *replaced, |
| uint32_t replaced_len, |
| uint8_t disabled, |
| uint32_t *__serial); |
| struct rbug_proto_shader_list * rbug_demarshal_shader_list(struct rbug_proto_header *header); |
| struct rbug_proto_shader_info * rbug_demarshal_shader_info(struct rbug_proto_header *header); |
| struct rbug_proto_shader_disable * rbug_demarshal_shader_disable(struct rbug_proto_header *header); |
| struct rbug_proto_shader_replace * rbug_demarshal_shader_replace(struct rbug_proto_header *header); |
| struct rbug_proto_shader_list_reply * rbug_demarshal_shader_list_reply(struct rbug_proto_header *header); |
| struct rbug_proto_shader_info_reply * rbug_demarshal_shader_info_reply(struct rbug_proto_header *header); |
| #endif |
| /contrib/sdk/sources/Mesa/mesa-10.6.0/src/gallium/auxiliary/rbug/rbug_texture.c |
|---|
| 0,0 → 1,624 |
| /* |
| * Copyright 2009 VMware, Inc. |
| * All Rights Reserved. |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a |
| * copy of this software and associated documentation files (the "Software"), |
| * to deal in the Software without restriction, including without limitation |
| * on the rights to use, copy, modify, merge, publish, distribute, sub |
| * license, and/or sell copies of the Software, and to permit persons to whom |
| * the Software is furnished to do so, subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice (including the next |
| * paragraph) shall be included in all copies or substantial portions of the |
| * Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL |
| * VMWARE AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, |
| * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR |
| * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE |
| * USE OR OTHER DEALINGS IN THE SOFTWARE. |
| */ |
| /* |
| * This file holds the function implementation for one of the rbug extensions. |
| * Prototypes and declerations of functions and structs is in the same folder |
| * in the header file matching this file's name. |
| * |
| * The functions starting rbug_send_* encodes a call to the write format and |
| * sends that to the supplied connection, while functions starting with |
| * rbug_demarshal_* demarshal data in the wire protocol. |
| * |
| * Functions ending with _reply are replies to requests. |
| */ |
| #include "rbug_internal.h" |
| #include "rbug_texture.h" |
| int rbug_send_texture_list(struct rbug_connection *__con, |
| uint32_t *__serial) |
| { |
| uint32_t __len = 0; |
| uint32_t __pos = 0; |
| uint8_t *__data = NULL; |
| int __ret = 0; |
| LEN(8); /* header */ |
| /* align */ |
| PAD(__len, 8); |
| __data = (uint8_t*)MALLOC(__len); |
| if (!__data) |
| return -ENOMEM; |
| WRITE(4, int32_t, ((int32_t)RBUG_OP_TEXTURE_LIST)); |
| WRITE(4, uint32_t, ((uint32_t)(__len / 4))); |
| /* final pad */ |
| PAD(__pos, 8); |
| if (__pos != __len) { |
| __ret = -EINVAL; |
| } else { |
| rbug_connection_send_start(__con, RBUG_OP_TEXTURE_LIST, __len); |
| rbug_connection_write(__con, __data, __len); |
| __ret = rbug_connection_send_finish(__con, __serial); |
| } |
| FREE(__data); |
| return __ret; |
| } |
| int rbug_send_texture_info(struct rbug_connection *__con, |
| rbug_texture_t texture, |
| uint32_t *__serial) |
| { |
| uint32_t __len = 0; |
| uint32_t __pos = 0; |
| uint8_t *__data = NULL; |
| int __ret = 0; |
| LEN(8); /* header */ |
| LEN(8); /* texture */ |
| /* align */ |
| PAD(__len, 8); |
| __data = (uint8_t*)MALLOC(__len); |
| if (!__data) |
| return -ENOMEM; |
| WRITE(4, int32_t, ((int32_t)RBUG_OP_TEXTURE_INFO)); |
| WRITE(4, uint32_t, ((uint32_t)(__len / 4))); |
| WRITE(8, rbug_texture_t, texture); /* texture */ |
| /* final pad */ |
| PAD(__pos, 8); |
| if (__pos != __len) { |
| __ret = -EINVAL; |
| } else { |
| rbug_connection_send_start(__con, RBUG_OP_TEXTURE_INFO, __len); |
| rbug_connection_write(__con, __data, __len); |
| __ret = rbug_connection_send_finish(__con, __serial); |
| } |
| FREE(__data); |
| return __ret; |
| } |
| int rbug_send_texture_write(struct rbug_connection *__con, |
| rbug_texture_t texture, |
| uint32_t face, |
| uint32_t level, |
| uint32_t zslice, |
| uint32_t x, |
| uint32_t y, |
| uint32_t w, |
| uint32_t h, |
| uint8_t *data, |
| uint32_t data_len, |
| uint32_t stride, |
| uint32_t *__serial) |
| { |
| uint32_t __len = 0; |
| uint32_t __pos = 0; |
| uint8_t *__data = NULL; |
| int __ret = 0; |
| LEN(8); /* header */ |
| LEN(8); /* texture */ |
| LEN(4); /* face */ |
| LEN(4); /* level */ |
| LEN(4); /* zslice */ |
| LEN(4); /* x */ |
| LEN(4); /* y */ |
| LEN(4); /* w */ |
| LEN(4); /* h */ |
| LEN_ARRAY(1, data); /* data */ |
| LEN(4); /* stride */ |
| /* align */ |
| PAD(__len, 8); |
| __data = (uint8_t*)MALLOC(__len); |
| if (!__data) |
| return -ENOMEM; |
| WRITE(4, int32_t, ((int32_t)RBUG_OP_TEXTURE_WRITE)); |
| WRITE(4, uint32_t, ((uint32_t)(__len / 4))); |
| WRITE(8, rbug_texture_t, texture); /* texture */ |
| WRITE(4, uint32_t, face); /* face */ |
| WRITE(4, uint32_t, level); /* level */ |
| WRITE(4, uint32_t, zslice); /* zslice */ |
| WRITE(4, uint32_t, x); /* x */ |
| WRITE(4, uint32_t, y); /* y */ |
| WRITE(4, uint32_t, w); /* w */ |
| WRITE(4, uint32_t, h); /* h */ |
| WRITE_ARRAY(1, uint8_t, data); /* data */ |
| WRITE(4, uint32_t, stride); /* stride */ |
| /* final pad */ |
| PAD(__pos, 8); |
| if (__pos != __len) { |
| __ret = -EINVAL; |
| } else { |
| rbug_connection_send_start(__con, RBUG_OP_TEXTURE_WRITE, __len); |
| rbug_connection_write(__con, __data, __len); |
| __ret = rbug_connection_send_finish(__con, __serial); |
| } |
| FREE(__data); |
| return __ret; |
| } |
| int rbug_send_texture_read(struct rbug_connection *__con, |
| rbug_texture_t texture, |
| uint32_t face, |
| uint32_t level, |
| uint32_t zslice, |
| uint32_t x, |
| uint32_t y, |
| uint32_t w, |
| uint32_t h, |
| uint32_t *__serial) |
| { |
| uint32_t __len = 0; |
| uint32_t __pos = 0; |
| uint8_t *__data = NULL; |
| int __ret = 0; |
| LEN(8); /* header */ |
| LEN(8); /* texture */ |
| LEN(4); /* face */ |
| LEN(4); /* level */ |
| LEN(4); /* zslice */ |
| LEN(4); /* x */ |
| LEN(4); /* y */ |
| LEN(4); /* w */ |
| LEN(4); /* h */ |
| /* align */ |
| PAD(__len, 8); |
| __data = (uint8_t*)MALLOC(__len); |
| if (!__data) |
| return -ENOMEM; |
| WRITE(4, int32_t, ((int32_t)RBUG_OP_TEXTURE_READ)); |
| WRITE(4, uint32_t, ((uint32_t)(__len / 4))); |
| WRITE(8, rbug_texture_t, texture); /* texture */ |
| WRITE(4, uint32_t, face); /* face */ |
| WRITE(4, uint32_t, level); /* level */ |
| WRITE(4, uint32_t, zslice); /* zslice */ |
| WRITE(4, uint32_t, x); /* x */ |
| WRITE(4, uint32_t, y); /* y */ |
| WRITE(4, uint32_t, w); /* w */ |
| WRITE(4, uint32_t, h); /* h */ |
| /* final pad */ |
| PAD(__pos, 8); |
| if (__pos != __len) { |
| __ret = -EINVAL; |
| } else { |
| rbug_connection_send_start(__con, RBUG_OP_TEXTURE_READ, __len); |
| rbug_connection_write(__con, __data, __len); |
| __ret = rbug_connection_send_finish(__con, __serial); |
| } |
| FREE(__data); |
| return __ret; |
| } |
| int rbug_send_texture_list_reply(struct rbug_connection *__con, |
| uint32_t serial, |
| rbug_texture_t *textures, |
| uint32_t textures_len, |
| uint32_t *__serial) |
| { |
| uint32_t __len = 0; |
| uint32_t __pos = 0; |
| uint8_t *__data = NULL; |
| int __ret = 0; |
| LEN(8); /* header */ |
| LEN(4); /* serial */ |
| LEN_ARRAY(8, textures); /* textures */ |
| /* align */ |
| PAD(__len, 8); |
| __data = (uint8_t*)MALLOC(__len); |
| if (!__data) |
| return -ENOMEM; |
| WRITE(4, int32_t, ((int32_t)RBUG_OP_TEXTURE_LIST_REPLY)); |
| WRITE(4, uint32_t, ((uint32_t)(__len / 4))); |
| WRITE(4, uint32_t, serial); /* serial */ |
| WRITE_ARRAY(8, rbug_texture_t, textures); /* textures */ |
| /* final pad */ |
| PAD(__pos, 8); |
| if (__pos != __len) { |
| __ret = -EINVAL; |
| } else { |
| rbug_connection_send_start(__con, RBUG_OP_TEXTURE_LIST_REPLY, __len); |
| rbug_connection_write(__con, __data, __len); |
| __ret = rbug_connection_send_finish(__con, __serial); |
| } |
| FREE(__data); |
| return __ret; |
| } |
| int rbug_send_texture_info_reply(struct rbug_connection *__con, |
| uint32_t serial, |
| uint32_t target, |
| uint32_t format, |
| uint32_t *width, |
| uint32_t width_len, |
| uint32_t *height, |
| uint32_t height_len, |
| uint32_t *depth, |
| uint32_t depth_len, |
| uint32_t blockw, |
| uint32_t blockh, |
| uint32_t blocksize, |
| uint32_t last_level, |
| uint32_t nr_samples, |
| uint32_t tex_usage, |
| uint32_t *__serial) |
| { |
| uint32_t __len = 0; |
| uint32_t __pos = 0; |
| uint8_t *__data = NULL; |
| int __ret = 0; |
| LEN(8); /* header */ |
| LEN(4); /* serial */ |
| LEN(4); /* target */ |
| LEN(4); /* format */ |
| LEN_ARRAY(4, width); /* width */ |
| LEN_ARRAY(4, height); /* height */ |
| LEN_ARRAY(4, depth); /* depth */ |
| LEN(4); /* blockw */ |
| LEN(4); /* blockh */ |
| LEN(4); /* blocksize */ |
| LEN(4); /* last_level */ |
| LEN(4); /* nr_samples */ |
| LEN(4); /* tex_usage */ |
| /* align */ |
| PAD(__len, 8); |
| __data = (uint8_t*)MALLOC(__len); |
| if (!__data) |
| return -ENOMEM; |
| WRITE(4, int32_t, ((int32_t)RBUG_OP_TEXTURE_INFO_REPLY)); |
| WRITE(4, uint32_t, ((uint32_t)(__len / 4))); |
| WRITE(4, uint32_t, serial); /* serial */ |
| WRITE(4, uint32_t, target); /* target */ |
| WRITE(4, uint32_t, format); /* format */ |
| WRITE_ARRAY(4, uint32_t, width); /* width */ |
| WRITE_ARRAY(4, uint32_t, height); /* height */ |
| WRITE_ARRAY(4, uint32_t, depth); /* depth */ |
| WRITE(4, uint32_t, blockw); /* blockw */ |
| WRITE(4, uint32_t, blockh); /* blockh */ |
| WRITE(4, uint32_t, blocksize); /* blocksize */ |
| WRITE(4, uint32_t, last_level); /* last_level */ |
| WRITE(4, uint32_t, nr_samples); /* nr_samples */ |
| WRITE(4, uint32_t, tex_usage); /* tex_usage */ |
| /* final pad */ |
| PAD(__pos, 8); |
| if (__pos != __len) { |
| __ret = -EINVAL; |
| } else { |
| rbug_connection_send_start(__con, RBUG_OP_TEXTURE_INFO_REPLY, __len); |
| rbug_connection_write(__con, __data, __len); |
| __ret = rbug_connection_send_finish(__con, __serial); |
| } |
| FREE(__data); |
| return __ret; |
| } |
| int rbug_send_texture_read_reply(struct rbug_connection *__con, |
| uint32_t serial, |
| uint32_t format, |
| uint32_t blockw, |
| uint32_t blockh, |
| uint32_t blocksize, |
| uint8_t *data, |
| uint32_t data_len, |
| uint32_t stride, |
| uint32_t *__serial) |
| { |
| uint32_t __len = 0; |
| uint32_t __pos = 0; |
| uint8_t *__data = NULL; |
| int __ret = 0; |
| LEN(8); /* header */ |
| LEN(4); /* serial */ |
| LEN(4); /* format */ |
| LEN(4); /* blockw */ |
| LEN(4); /* blockh */ |
| LEN(4); /* blocksize */ |
| LEN_ARRAY(1, data); /* data */ |
| LEN(4); /* stride */ |
| /* align */ |
| PAD(__len, 8); |
| __data = (uint8_t*)MALLOC(__len); |
| if (!__data) |
| return -ENOMEM; |
| WRITE(4, int32_t, ((int32_t)RBUG_OP_TEXTURE_READ_REPLY)); |
| WRITE(4, uint32_t, ((uint32_t)(__len / 4))); |
| WRITE(4, uint32_t, serial); /* serial */ |
| WRITE(4, uint32_t, format); /* format */ |
| WRITE(4, uint32_t, blockw); /* blockw */ |
| WRITE(4, uint32_t, blockh); /* blockh */ |
| WRITE(4, uint32_t, blocksize); /* blocksize */ |
| WRITE_ARRAY(1, uint8_t, data); /* data */ |
| WRITE(4, uint32_t, stride); /* stride */ |
| /* final pad */ |
| PAD(__pos, 8); |
| if (__pos != __len) { |
| __ret = -EINVAL; |
| } else { |
| rbug_connection_send_start(__con, RBUG_OP_TEXTURE_READ_REPLY, __len); |
| rbug_connection_write(__con, __data, __len); |
| __ret = rbug_connection_send_finish(__con, __serial); |
| } |
| FREE(__data); |
| return __ret; |
| } |
| struct rbug_proto_texture_list * rbug_demarshal_texture_list(struct rbug_proto_header *header) |
| { |
| struct rbug_proto_texture_list *ret; |
| if (!header) |
| return NULL; |
| if (header->opcode != (int32_t)RBUG_OP_TEXTURE_LIST) |
| return NULL; |
| ret = MALLOC(sizeof(*ret)); |
| if (!ret) |
| return NULL; |
| ret->header.__message = header; |
| ret->header.opcode = header->opcode; |
| return ret; |
| } |
| struct rbug_proto_texture_info * rbug_demarshal_texture_info(struct rbug_proto_header *header) |
| { |
| uint32_t len = 0; |
| uint32_t pos = 0; |
| uint8_t *data = NULL; |
| struct rbug_proto_texture_info *ret; |
| if (!header) |
| return NULL; |
| if (header->opcode != (int32_t)RBUG_OP_TEXTURE_INFO) |
| return NULL; |
| pos = 0; |
| len = header->length * 4; |
| data = (uint8_t*)&header[1]; |
| ret = MALLOC(sizeof(*ret)); |
| if (!ret) |
| return NULL; |
| ret->header.__message = header; |
| ret->header.opcode = header->opcode; |
| READ(8, rbug_texture_t, texture); /* texture */ |
| return ret; |
| } |
| struct rbug_proto_texture_write * rbug_demarshal_texture_write(struct rbug_proto_header *header) |
| { |
| uint32_t len = 0; |
| uint32_t pos = 0; |
| uint8_t *data = NULL; |
| struct rbug_proto_texture_write *ret; |
| if (!header) |
| return NULL; |
| if (header->opcode != (int32_t)RBUG_OP_TEXTURE_WRITE) |
| return NULL; |
| pos = 0; |
| len = header->length * 4; |
| data = (uint8_t*)&header[1]; |
| ret = MALLOC(sizeof(*ret)); |
| if (!ret) |
| return NULL; |
| ret->header.__message = header; |
| ret->header.opcode = header->opcode; |
| READ(8, rbug_texture_t, texture); /* texture */ |
| READ(4, uint32_t, face); /* face */ |
| READ(4, uint32_t, level); /* level */ |
| READ(4, uint32_t, zslice); /* zslice */ |
| READ(4, uint32_t, x); /* x */ |
| READ(4, uint32_t, y); /* y */ |
| READ(4, uint32_t, w); /* w */ |
| READ(4, uint32_t, h); /* h */ |
| READ_ARRAY(1, uint8_t, data); /* data */ |
| READ(4, uint32_t, stride); /* stride */ |
| return ret; |
| } |
| struct rbug_proto_texture_read * rbug_demarshal_texture_read(struct rbug_proto_header *header) |
| { |
| uint32_t len = 0; |
| uint32_t pos = 0; |
| uint8_t *data = NULL; |
| struct rbug_proto_texture_read *ret; |
| if (!header) |
| return NULL; |
| if (header->opcode != (int32_t)RBUG_OP_TEXTURE_READ) |
| return NULL; |
| pos = 0; |
| len = header->length * 4; |
| data = (uint8_t*)&header[1]; |
| ret = MALLOC(sizeof(*ret)); |
| if (!ret) |
| return NULL; |
| ret->header.__message = header; |
| ret->header.opcode = header->opcode; |
| READ(8, rbug_texture_t, texture); /* texture */ |
| READ(4, uint32_t, face); /* face */ |
| READ(4, uint32_t, level); /* level */ |
| READ(4, uint32_t, zslice); /* zslice */ |
| READ(4, uint32_t, x); /* x */ |
| READ(4, uint32_t, y); /* y */ |
| READ(4, uint32_t, w); /* w */ |
| READ(4, uint32_t, h); /* h */ |
| return ret; |
| } |
| struct rbug_proto_texture_list_reply * rbug_demarshal_texture_list_reply(struct rbug_proto_header *header) |
| { |
| uint32_t len = 0; |
| uint32_t pos = 0; |
| uint8_t *data = NULL; |
| struct rbug_proto_texture_list_reply *ret; |
| if (!header) |
| return NULL; |
| if (header->opcode != (int32_t)RBUG_OP_TEXTURE_LIST_REPLY) |
| return NULL; |
| pos = 0; |
| len = header->length * 4; |
| data = (uint8_t*)&header[1]; |
| ret = MALLOC(sizeof(*ret)); |
| if (!ret) |
| return NULL; |
| ret->header.__message = header; |
| ret->header.opcode = header->opcode; |
| READ(4, uint32_t, serial); /* serial */ |
| READ_ARRAY(8, rbug_texture_t, textures); /* textures */ |
| return ret; |
| } |
| struct rbug_proto_texture_info_reply * rbug_demarshal_texture_info_reply(struct rbug_proto_header *header) |
| { |
| uint32_t len = 0; |
| uint32_t pos = 0; |
| uint8_t *data = NULL; |
| struct rbug_proto_texture_info_reply *ret; |
| if (!header) |
| return NULL; |
| if (header->opcode != (int32_t)RBUG_OP_TEXTURE_INFO_REPLY) |
| return NULL; |
| pos = 0; |
| len = header->length * 4; |
| data = (uint8_t*)&header[1]; |
| ret = MALLOC(sizeof(*ret)); |
| if (!ret) |
| return NULL; |
| ret->header.__message = header; |
| ret->header.opcode = header->opcode; |
| READ(4, uint32_t, serial); /* serial */ |
| READ(4, uint32_t, target); /* target */ |
| READ(4, uint32_t, format); /* format */ |
| READ_ARRAY(4, uint32_t, width); /* width */ |
| READ_ARRAY(4, uint32_t, height); /* height */ |
| READ_ARRAY(4, uint32_t, depth); /* depth */ |
| READ(4, uint32_t, blockw); /* blockw */ |
| READ(4, uint32_t, blockh); /* blockh */ |
| READ(4, uint32_t, blocksize); /* blocksize */ |
| READ(4, uint32_t, last_level); /* last_level */ |
| READ(4, uint32_t, nr_samples); /* nr_samples */ |
| READ(4, uint32_t, tex_usage); /* tex_usage */ |
| return ret; |
| } |
| struct rbug_proto_texture_read_reply * rbug_demarshal_texture_read_reply(struct rbug_proto_header *header) |
| { |
| uint32_t len = 0; |
| uint32_t pos = 0; |
| uint8_t *data = NULL; |
| struct rbug_proto_texture_read_reply *ret; |
| if (!header) |
| return NULL; |
| if (header->opcode != (int32_t)RBUG_OP_TEXTURE_READ_REPLY) |
| return NULL; |
| pos = 0; |
| len = header->length * 4; |
| data = (uint8_t*)&header[1]; |
| ret = MALLOC(sizeof(*ret)); |
| if (!ret) |
| return NULL; |
| ret->header.__message = header; |
| ret->header.opcode = header->opcode; |
| READ(4, uint32_t, serial); /* serial */ |
| READ(4, uint32_t, format); /* format */ |
| READ(4, uint32_t, blockw); /* blockw */ |
| READ(4, uint32_t, blockh); /* blockh */ |
| READ(4, uint32_t, blocksize); /* blocksize */ |
| READ_ARRAY(1, uint8_t, data); /* data */ |
| READ(4, uint32_t, stride); /* stride */ |
| return ret; |
| } |
| /contrib/sdk/sources/Mesa/mesa-10.6.0/src/gallium/auxiliary/rbug/rbug_texture.h |
|---|
| 0,0 → 1,206 |
| /* |
| * Copyright 2009 VMware, Inc. |
| * All Rights Reserved. |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a |
| * copy of this software and associated documentation files (the "Software"), |
| * to deal in the Software without restriction, including without limitation |
| * on the rights to use, copy, modify, merge, publish, distribute, sub |
| * license, and/or sell copies of the Software, and to permit persons to whom |
| * the Software is furnished to do so, subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice (including the next |
| * paragraph) shall be included in all copies or substantial portions of the |
| * Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL |
| * VMWARE AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, |
| * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR |
| * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE |
| * USE OR OTHER DEALINGS IN THE SOFTWARE. |
| */ |
| /* |
| * This file holds structs decelerations and function prototypes for one of |
| * the rbug extensions. Implementation of the functions is in the same folder |
| * in the c file matching this file's name. |
| * |
| * The structs what is returned from the demarshal functions. The functions |
| * starting rbug_send_* encodes a call to the write format and sends that to |
| * the supplied connection, while functions starting with rbug_demarshal_* |
| * demarshal data from the wire protocol. |
| * |
| * Structs and functions ending with _reply are replies to requests. |
| */ |
| #ifndef _RBUG_PROTO_TEXTURE_H_ |
| #define _RBUG_PROTO_TEXTURE_H_ |
| #include "rbug_proto.h" |
| #include "rbug_core.h" |
| struct rbug_proto_texture_list |
| { |
| struct rbug_header header; |
| }; |
| struct rbug_proto_texture_info |
| { |
| struct rbug_header header; |
| rbug_texture_t texture; |
| }; |
| struct rbug_proto_texture_write |
| { |
| struct rbug_header header; |
| rbug_texture_t texture; |
| uint32_t face; |
| uint32_t level; |
| uint32_t zslice; |
| uint32_t x; |
| uint32_t y; |
| uint32_t w; |
| uint32_t h; |
| uint8_t *data; |
| uint32_t data_len; |
| uint32_t stride; |
| }; |
| struct rbug_proto_texture_read |
| { |
| struct rbug_header header; |
| rbug_texture_t texture; |
| uint32_t face; |
| uint32_t level; |
| uint32_t zslice; |
| uint32_t x; |
| uint32_t y; |
| uint32_t w; |
| uint32_t h; |
| }; |
| struct rbug_proto_texture_list_reply |
| { |
| struct rbug_header header; |
| uint32_t serial; |
| rbug_texture_t *textures; |
| uint32_t textures_len; |
| }; |
| struct rbug_proto_texture_info_reply |
| { |
| struct rbug_header header; |
| uint32_t serial; |
| uint32_t target; |
| uint32_t format; |
| uint32_t *width; |
| uint32_t width_len; |
| uint32_t *height; |
| uint32_t height_len; |
| uint32_t *depth; |
| uint32_t depth_len; |
| uint32_t blockw; |
| uint32_t blockh; |
| uint32_t blocksize; |
| uint32_t last_level; |
| uint32_t nr_samples; |
| uint32_t tex_usage; |
| }; |
| struct rbug_proto_texture_read_reply |
| { |
| struct rbug_header header; |
| uint32_t serial; |
| uint32_t format; |
| uint32_t blockw; |
| uint32_t blockh; |
| uint32_t blocksize; |
| uint8_t *data; |
| uint32_t data_len; |
| uint32_t stride; |
| }; |
| int rbug_send_texture_list(struct rbug_connection *__con, |
| uint32_t *__serial); |
| int rbug_send_texture_info(struct rbug_connection *__con, |
| rbug_texture_t texture, |
| uint32_t *__serial); |
| int rbug_send_texture_write(struct rbug_connection *__con, |
| rbug_texture_t texture, |
| uint32_t face, |
| uint32_t level, |
| uint32_t zslice, |
| uint32_t x, |
| uint32_t y, |
| uint32_t w, |
| uint32_t h, |
| uint8_t *data, |
| uint32_t data_len, |
| uint32_t stride, |
| uint32_t *__serial); |
| int rbug_send_texture_read(struct rbug_connection *__con, |
| rbug_texture_t texture, |
| uint32_t face, |
| uint32_t level, |
| uint32_t zslice, |
| uint32_t x, |
| uint32_t y, |
| uint32_t w, |
| uint32_t h, |
| uint32_t *__serial); |
| int rbug_send_texture_list_reply(struct rbug_connection *__con, |
| uint32_t serial, |
| rbug_texture_t *textures, |
| uint32_t textures_len, |
| uint32_t *__serial); |
| int rbug_send_texture_info_reply(struct rbug_connection *__con, |
| uint32_t serial, |
| uint32_t target, |
| uint32_t format, |
| uint32_t *width, |
| uint32_t width_len, |
| uint32_t *height, |
| uint32_t height_len, |
| uint32_t *depth, |
| uint32_t depth_len, |
| uint32_t blockw, |
| uint32_t blockh, |
| uint32_t blocksize, |
| uint32_t last_level, |
| uint32_t nr_samples, |
| uint32_t tex_usage, |
| uint32_t *__serial); |
| int rbug_send_texture_read_reply(struct rbug_connection *__con, |
| uint32_t serial, |
| uint32_t format, |
| uint32_t blockw, |
| uint32_t blockh, |
| uint32_t blocksize, |
| uint8_t *data, |
| uint32_t data_len, |
| uint32_t stride, |
| uint32_t *__serial); |
| struct rbug_proto_texture_list * rbug_demarshal_texture_list(struct rbug_proto_header *header); |
| struct rbug_proto_texture_info * rbug_demarshal_texture_info(struct rbug_proto_header *header); |
| struct rbug_proto_texture_write * rbug_demarshal_texture_write(struct rbug_proto_header *header); |
| struct rbug_proto_texture_read * rbug_demarshal_texture_read(struct rbug_proto_header *header); |
| struct rbug_proto_texture_list_reply * rbug_demarshal_texture_list_reply(struct rbug_proto_header *header); |
| struct rbug_proto_texture_info_reply * rbug_demarshal_texture_info_reply(struct rbug_proto_header *header); |
| struct rbug_proto_texture_read_reply * rbug_demarshal_texture_read_reply(struct rbug_proto_header *header); |
| #endif |