Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | RSS feed

  1. /*
  2.  * Copyright 2009 VMware, Inc.
  3.  * All Rights Reserved.
  4.  *
  5.  * Permission is hereby granted, free of charge, to any person obtaining a
  6.  * copy of this software and associated documentation files (the "Software"),
  7.  * to deal in the Software without restriction, including without limitation
  8.  * on the rights to use, copy, modify, merge, publish, distribute, sub
  9.  * license, and/or sell copies of the Software, and to permit persons to whom
  10.  * the Software is furnished to do so, subject to the following conditions:
  11.  *
  12.  * The above copyright notice and this permission notice (including the next
  13.  * paragraph) shall be included in all copies or substantial portions of the
  14.  * Software.
  15.  *
  16.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17.  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18.  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL
  19.  * VMWARE AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
  20.  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  21.  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  22.  * USE OR OTHER DEALINGS IN THE SOFTWARE.
  23.  */
  24.  
  25. /*
  26.  * This file holds the function implementation for one of the rbug extensions.
  27.  * Prototypes and declerations of functions and structs is in the same folder
  28.  * in the header file matching this file's name.
  29.  *
  30.  * The functions starting rbug_send_* encodes a call to the write format and
  31.  * sends that to the supplied connection, while functions starting with
  32.  * rbug_demarshal_* demarshal data in the wire protocol.
  33.  *
  34.  * Functions ending with _reply are replies to requests.
  35.  */
  36.  
  37. #include "rbug_internal.h"
  38. #include "rbug_context.h"
  39.  
  40. int rbug_send_context_list(struct rbug_connection *__con,
  41.                            uint32_t *__serial)
  42. {
  43.         uint32_t __len = 0;
  44.         uint32_t __pos = 0;
  45.         uint8_t *__data = NULL;
  46.         int __ret = 0;
  47.  
  48.         LEN(8); /* header */
  49.  
  50.         /* align */
  51.         PAD(__len, 8);
  52.  
  53.         __data = (uint8_t*)MALLOC(__len);
  54.         if (!__data)
  55.                 return -ENOMEM;
  56.  
  57.         WRITE(4, int32_t, ((int32_t)RBUG_OP_CONTEXT_LIST));
  58.         WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
  59.  
  60.         /* final pad */
  61.         PAD(__pos, 8);
  62.  
  63.         if (__pos != __len) {
  64.                 __ret = -EINVAL;
  65.         } else {
  66.                 rbug_connection_send_start(__con, RBUG_OP_CONTEXT_LIST, __len);
  67.                 rbug_connection_write(__con, __data, __len);
  68.                 __ret = rbug_connection_send_finish(__con, __serial);
  69.         }
  70.  
  71.         FREE(__data);
  72.         return __ret;
  73. }
  74.  
  75. int rbug_send_context_info(struct rbug_connection *__con,
  76.                            rbug_context_t context,
  77.                            uint32_t *__serial)
  78. {
  79.         uint32_t __len = 0;
  80.         uint32_t __pos = 0;
  81.         uint8_t *__data = NULL;
  82.         int __ret = 0;
  83.  
  84.         LEN(8); /* header */
  85.         LEN(8); /* context */
  86.  
  87.         /* align */
  88.         PAD(__len, 8);
  89.  
  90.         __data = (uint8_t*)MALLOC(__len);
  91.         if (!__data)
  92.                 return -ENOMEM;
  93.  
  94.         WRITE(4, int32_t, ((int32_t)RBUG_OP_CONTEXT_INFO));
  95.         WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
  96.         WRITE(8, rbug_context_t, context); /* context */
  97.  
  98.         /* final pad */
  99.         PAD(__pos, 8);
  100.  
  101.         if (__pos != __len) {
  102.                 __ret = -EINVAL;
  103.         } else {
  104.                 rbug_connection_send_start(__con, RBUG_OP_CONTEXT_INFO, __len);
  105.                 rbug_connection_write(__con, __data, __len);
  106.                 __ret = rbug_connection_send_finish(__con, __serial);
  107.         }
  108.  
  109.         FREE(__data);
  110.         return __ret;
  111. }
  112.  
  113. int rbug_send_context_draw_block(struct rbug_connection *__con,
  114.                                  rbug_context_t context,
  115.                                  rbug_block_t block,
  116.                                  uint32_t *__serial)
  117. {
  118.         uint32_t __len = 0;
  119.         uint32_t __pos = 0;
  120.         uint8_t *__data = NULL;
  121.         int __ret = 0;
  122.  
  123.         LEN(8); /* header */
  124.         LEN(8); /* context */
  125.         LEN(4); /* block */
  126.  
  127.         /* align */
  128.         PAD(__len, 8);
  129.  
  130.         __data = (uint8_t*)MALLOC(__len);
  131.         if (!__data)
  132.                 return -ENOMEM;
  133.  
  134.         WRITE(4, int32_t, ((int32_t)RBUG_OP_CONTEXT_DRAW_BLOCK));
  135.         WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
  136.         WRITE(8, rbug_context_t, context); /* context */
  137.         WRITE(4, rbug_block_t, block); /* block */
  138.  
  139.         /* final pad */
  140.         PAD(__pos, 8);
  141.  
  142.         if (__pos != __len) {
  143.                 __ret = -EINVAL;
  144.         } else {
  145.                 rbug_connection_send_start(__con, RBUG_OP_CONTEXT_DRAW_BLOCK, __len);
  146.                 rbug_connection_write(__con, __data, __len);
  147.                 __ret = rbug_connection_send_finish(__con, __serial);
  148.         }
  149.  
  150.         FREE(__data);
  151.         return __ret;
  152. }
  153.  
  154. int rbug_send_context_draw_step(struct rbug_connection *__con,
  155.                                 rbug_context_t context,
  156.                                 rbug_block_t step,
  157.                                 uint32_t *__serial)
  158. {
  159.         uint32_t __len = 0;
  160.         uint32_t __pos = 0;
  161.         uint8_t *__data = NULL;
  162.         int __ret = 0;
  163.  
  164.         LEN(8); /* header */
  165.         LEN(8); /* context */
  166.         LEN(4); /* step */
  167.  
  168.         /* align */
  169.         PAD(__len, 8);
  170.  
  171.         __data = (uint8_t*)MALLOC(__len);
  172.         if (!__data)
  173.                 return -ENOMEM;
  174.  
  175.         WRITE(4, int32_t, ((int32_t)RBUG_OP_CONTEXT_DRAW_STEP));
  176.         WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
  177.         WRITE(8, rbug_context_t, context); /* context */
  178.         WRITE(4, rbug_block_t, step); /* step */
  179.  
  180.         /* final pad */
  181.         PAD(__pos, 8);
  182.  
  183.         if (__pos != __len) {
  184.                 __ret = -EINVAL;
  185.         } else {
  186.                 rbug_connection_send_start(__con, RBUG_OP_CONTEXT_DRAW_STEP, __len);
  187.                 rbug_connection_write(__con, __data, __len);
  188.                 __ret = rbug_connection_send_finish(__con, __serial);
  189.         }
  190.  
  191.         FREE(__data);
  192.         return __ret;
  193. }
  194.  
  195. int rbug_send_context_draw_unblock(struct rbug_connection *__con,
  196.                                    rbug_context_t context,
  197.                                    rbug_block_t unblock,
  198.                                    uint32_t *__serial)
  199. {
  200.         uint32_t __len = 0;
  201.         uint32_t __pos = 0;
  202.         uint8_t *__data = NULL;
  203.         int __ret = 0;
  204.  
  205.         LEN(8); /* header */
  206.         LEN(8); /* context */
  207.         LEN(4); /* unblock */
  208.  
  209.         /* align */
  210.         PAD(__len, 8);
  211.  
  212.         __data = (uint8_t*)MALLOC(__len);
  213.         if (!__data)
  214.                 return -ENOMEM;
  215.  
  216.         WRITE(4, int32_t, ((int32_t)RBUG_OP_CONTEXT_DRAW_UNBLOCK));
  217.         WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
  218.         WRITE(8, rbug_context_t, context); /* context */
  219.         WRITE(4, rbug_block_t, unblock); /* unblock */
  220.  
  221.         /* final pad */
  222.         PAD(__pos, 8);
  223.  
  224.         if (__pos != __len) {
  225.                 __ret = -EINVAL;
  226.         } else {
  227.                 rbug_connection_send_start(__con, RBUG_OP_CONTEXT_DRAW_UNBLOCK, __len);
  228.                 rbug_connection_write(__con, __data, __len);
  229.                 __ret = rbug_connection_send_finish(__con, __serial);
  230.         }
  231.  
  232.         FREE(__data);
  233.         return __ret;
  234. }
  235.  
  236. int rbug_send_context_draw_rule(struct rbug_connection *__con,
  237.                                 rbug_context_t context,
  238.                                 rbug_shader_t vertex,
  239.                                 rbug_shader_t fragment,
  240.                                 rbug_texture_t texture,
  241.                                 rbug_texture_t surface,
  242.                                 rbug_block_t block,
  243.                                 uint32_t *__serial)
  244. {
  245.         uint32_t __len = 0;
  246.         uint32_t __pos = 0;
  247.         uint8_t *__data = NULL;
  248.         int __ret = 0;
  249.  
  250.         LEN(8); /* header */
  251.         LEN(8); /* context */
  252.         LEN(8); /* vertex */
  253.         LEN(8); /* fragment */
  254.         LEN(8); /* texture */
  255.         LEN(8); /* surface */
  256.         LEN(4); /* block */
  257.  
  258.         /* align */
  259.         PAD(__len, 8);
  260.  
  261.         __data = (uint8_t*)MALLOC(__len);
  262.         if (!__data)
  263.                 return -ENOMEM;
  264.  
  265.         WRITE(4, int32_t, ((int32_t)RBUG_OP_CONTEXT_DRAW_RULE));
  266.         WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
  267.         WRITE(8, rbug_context_t, context); /* context */
  268.         WRITE(8, rbug_shader_t, vertex); /* vertex */
  269.         WRITE(8, rbug_shader_t, fragment); /* fragment */
  270.         WRITE(8, rbug_texture_t, texture); /* texture */
  271.         WRITE(8, rbug_texture_t, surface); /* surface */
  272.         WRITE(4, rbug_block_t, block); /* block */
  273.  
  274.         /* final pad */
  275.         PAD(__pos, 8);
  276.  
  277.         if (__pos != __len) {
  278.                 __ret = -EINVAL;
  279.         } else {
  280.                 rbug_connection_send_start(__con, RBUG_OP_CONTEXT_DRAW_RULE, __len);
  281.                 rbug_connection_write(__con, __data, __len);
  282.                 __ret = rbug_connection_send_finish(__con, __serial);
  283.         }
  284.  
  285.         FREE(__data);
  286.         return __ret;
  287. }
  288.  
  289. int rbug_send_context_flush(struct rbug_connection *__con,
  290.                             rbug_context_t context,
  291.                             uint32_t *__serial)
  292. {
  293.         uint32_t __len = 0;
  294.         uint32_t __pos = 0;
  295.         uint8_t *__data = NULL;
  296.         int __ret = 0;
  297.  
  298.         LEN(8); /* header */
  299.         LEN(8); /* context */
  300.  
  301.         /* align */
  302.         PAD(__len, 8);
  303.  
  304.         __data = (uint8_t*)MALLOC(__len);
  305.         if (!__data)
  306.                 return -ENOMEM;
  307.  
  308.         WRITE(4, int32_t, ((int32_t)RBUG_OP_CONTEXT_FLUSH));
  309.         WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
  310.         WRITE(8, rbug_context_t, context); /* context */
  311.  
  312.         /* final pad */
  313.         PAD(__pos, 8);
  314.  
  315.         if (__pos != __len) {
  316.                 __ret = -EINVAL;
  317.         } else {
  318.                 rbug_connection_send_start(__con, RBUG_OP_CONTEXT_FLUSH, __len);
  319.                 rbug_connection_write(__con, __data, __len);
  320.                 __ret = rbug_connection_send_finish(__con, __serial);
  321.         }
  322.  
  323.         FREE(__data);
  324.         return __ret;
  325. }
  326.  
  327. int rbug_send_context_list_reply(struct rbug_connection *__con,
  328.                                  uint32_t serial,
  329.                                  rbug_context_t *contexts,
  330.                                  uint32_t contexts_len,
  331.                                  uint32_t *__serial)
  332. {
  333.         uint32_t __len = 0;
  334.         uint32_t __pos = 0;
  335.         uint8_t *__data = NULL;
  336.         int __ret = 0;
  337.  
  338.         LEN(8); /* header */
  339.         LEN(4); /* serial */
  340.         LEN_ARRAY(8, contexts); /* contexts */
  341.  
  342.         /* align */
  343.         PAD(__len, 8);
  344.  
  345.         __data = (uint8_t*)MALLOC(__len);
  346.         if (!__data)
  347.                 return -ENOMEM;
  348.  
  349.         WRITE(4, int32_t, ((int32_t)RBUG_OP_CONTEXT_LIST_REPLY));
  350.         WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
  351.         WRITE(4, uint32_t, serial); /* serial */
  352.         WRITE_ARRAY(8, rbug_context_t, contexts); /* contexts */
  353.  
  354.         /* final pad */
  355.         PAD(__pos, 8);
  356.  
  357.         if (__pos != __len) {
  358.                 __ret = -EINVAL;
  359.         } else {
  360.                 rbug_connection_send_start(__con, RBUG_OP_CONTEXT_LIST_REPLY, __len);
  361.                 rbug_connection_write(__con, __data, __len);
  362.                 __ret = rbug_connection_send_finish(__con, __serial);
  363.         }
  364.  
  365.         FREE(__data);
  366.         return __ret;
  367. }
  368.  
  369. int rbug_send_context_info_reply(struct rbug_connection *__con,
  370.                                  uint32_t serial,
  371.                                  rbug_shader_t vertex,
  372.                                  rbug_shader_t fragment,
  373.                                  rbug_texture_t *texs,
  374.                                  uint32_t texs_len,
  375.                                  rbug_texture_t *cbufs,
  376.                                  uint32_t cbufs_len,
  377.                                  rbug_texture_t zsbuf,
  378.                                  rbug_block_t blocker,
  379.                                  rbug_block_t blocked,
  380.                                  uint32_t *__serial)
  381. {
  382.         uint32_t __len = 0;
  383.         uint32_t __pos = 0;
  384.         uint8_t *__data = NULL;
  385.         int __ret = 0;
  386.  
  387.         LEN(8); /* header */
  388.         LEN(4); /* serial */
  389.         LEN(8); /* vertex */
  390.         LEN(8); /* fragment */
  391.         LEN_ARRAY(8, texs); /* texs */
  392.         LEN_ARRAY(8, cbufs); /* cbufs */
  393.         LEN(8); /* zsbuf */
  394.         LEN(4); /* blocker */
  395.         LEN(4); /* blocked */
  396.  
  397.         /* align */
  398.         PAD(__len, 8);
  399.  
  400.         __data = (uint8_t*)MALLOC(__len);
  401.         if (!__data)
  402.                 return -ENOMEM;
  403.  
  404.         WRITE(4, int32_t, ((int32_t)RBUG_OP_CONTEXT_INFO_REPLY));
  405.         WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
  406.         WRITE(4, uint32_t, serial); /* serial */
  407.         WRITE(8, rbug_shader_t, vertex); /* vertex */
  408.         WRITE(8, rbug_shader_t, fragment); /* fragment */
  409.         WRITE_ARRAY(8, rbug_texture_t, texs); /* texs */
  410.         WRITE_ARRAY(8, rbug_texture_t, cbufs); /* cbufs */
  411.         WRITE(8, rbug_texture_t, zsbuf); /* zsbuf */
  412.         WRITE(4, rbug_block_t, blocker); /* blocker */
  413.         WRITE(4, rbug_block_t, blocked); /* blocked */
  414.  
  415.         /* final pad */
  416.         PAD(__pos, 8);
  417.  
  418.         if (__pos != __len) {
  419.                 __ret = -EINVAL;
  420.         } else {
  421.                 rbug_connection_send_start(__con, RBUG_OP_CONTEXT_INFO_REPLY, __len);
  422.                 rbug_connection_write(__con, __data, __len);
  423.                 __ret = rbug_connection_send_finish(__con, __serial);
  424.         }
  425.  
  426.         FREE(__data);
  427.         return __ret;
  428. }
  429.  
  430. int rbug_send_context_draw_blocked(struct rbug_connection *__con,
  431.                                    rbug_context_t context,
  432.                                    rbug_block_t block,
  433.                                    uint32_t *__serial)
  434. {
  435.         uint32_t __len = 0;
  436.         uint32_t __pos = 0;
  437.         uint8_t *__data = NULL;
  438.         int __ret = 0;
  439.  
  440.         LEN(8); /* header */
  441.         LEN(8); /* context */
  442.         LEN(4); /* block */
  443.  
  444.         /* align */
  445.         PAD(__len, 8);
  446.  
  447.         __data = (uint8_t*)MALLOC(__len);
  448.         if (!__data)
  449.                 return -ENOMEM;
  450.  
  451.         WRITE(4, int32_t, ((int32_t)RBUG_OP_CONTEXT_DRAW_BLOCKED));
  452.         WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
  453.         WRITE(8, rbug_context_t, context); /* context */
  454.         WRITE(4, rbug_block_t, block); /* block */
  455.  
  456.         /* final pad */
  457.         PAD(__pos, 8);
  458.  
  459.         if (__pos != __len) {
  460.                 __ret = -EINVAL;
  461.         } else {
  462.                 rbug_connection_send_start(__con, RBUG_OP_CONTEXT_DRAW_BLOCKED, __len);
  463.                 rbug_connection_write(__con, __data, __len);
  464.                 __ret = rbug_connection_send_finish(__con, __serial);
  465.         }
  466.  
  467.         FREE(__data);
  468.         return __ret;
  469. }
  470.  
  471. struct rbug_proto_context_list * rbug_demarshal_context_list(struct rbug_proto_header *header)
  472. {
  473.         struct rbug_proto_context_list *ret;
  474.  
  475.         if (!header)
  476.                 return NULL;
  477.         if (header->opcode != (int32_t)RBUG_OP_CONTEXT_LIST)
  478.                 return NULL;
  479.  
  480.         ret = MALLOC(sizeof(*ret));
  481.         if (!ret)
  482.                 return NULL;
  483.  
  484.         ret->header.__message = header;
  485.         ret->header.opcode = header->opcode;
  486.  
  487.         return ret;
  488. }
  489.  
  490. struct rbug_proto_context_info * rbug_demarshal_context_info(struct rbug_proto_header *header)
  491. {
  492.         uint32_t len = 0;
  493.         uint32_t pos = 0;
  494.         uint8_t *data =  NULL;
  495.         struct rbug_proto_context_info *ret;
  496.  
  497.         if (!header)
  498.                 return NULL;
  499.         if (header->opcode != (int32_t)RBUG_OP_CONTEXT_INFO)
  500.                 return NULL;
  501.  
  502.         pos = 0;
  503.         len = header->length * 4;
  504.         data = (uint8_t*)&header[1];
  505.         ret = MALLOC(sizeof(*ret));
  506.         if (!ret)
  507.                 return NULL;
  508.  
  509.         ret->header.__message = header;
  510.         ret->header.opcode = header->opcode;
  511.  
  512.         READ(8, rbug_context_t, context); /* context */
  513.  
  514.         return ret;
  515. }
  516.  
  517. struct rbug_proto_context_draw_block * rbug_demarshal_context_draw_block(struct rbug_proto_header *header)
  518. {
  519.         uint32_t len = 0;
  520.         uint32_t pos = 0;
  521.         uint8_t *data =  NULL;
  522.         struct rbug_proto_context_draw_block *ret;
  523.  
  524.         if (!header)
  525.                 return NULL;
  526.         if (header->opcode != (int32_t)RBUG_OP_CONTEXT_DRAW_BLOCK)
  527.                 return NULL;
  528.  
  529.         pos = 0;
  530.         len = header->length * 4;
  531.         data = (uint8_t*)&header[1];
  532.         ret = MALLOC(sizeof(*ret));
  533.         if (!ret)
  534.                 return NULL;
  535.  
  536.         ret->header.__message = header;
  537.         ret->header.opcode = header->opcode;
  538.  
  539.         READ(8, rbug_context_t, context); /* context */
  540.         READ(4, rbug_block_t, block); /* block */
  541.  
  542.         return ret;
  543. }
  544.  
  545. struct rbug_proto_context_draw_step * rbug_demarshal_context_draw_step(struct rbug_proto_header *header)
  546. {
  547.         uint32_t len = 0;
  548.         uint32_t pos = 0;
  549.         uint8_t *data =  NULL;
  550.         struct rbug_proto_context_draw_step *ret;
  551.  
  552.         if (!header)
  553.                 return NULL;
  554.         if (header->opcode != (int32_t)RBUG_OP_CONTEXT_DRAW_STEP)
  555.                 return NULL;
  556.  
  557.         pos = 0;
  558.         len = header->length * 4;
  559.         data = (uint8_t*)&header[1];
  560.         ret = MALLOC(sizeof(*ret));
  561.         if (!ret)
  562.                 return NULL;
  563.  
  564.         ret->header.__message = header;
  565.         ret->header.opcode = header->opcode;
  566.  
  567.         READ(8, rbug_context_t, context); /* context */
  568.         READ(4, rbug_block_t, step); /* step */
  569.  
  570.         return ret;
  571. }
  572.  
  573. struct rbug_proto_context_draw_unblock * rbug_demarshal_context_draw_unblock(struct rbug_proto_header *header)
  574. {
  575.         uint32_t len = 0;
  576.         uint32_t pos = 0;
  577.         uint8_t *data =  NULL;
  578.         struct rbug_proto_context_draw_unblock *ret;
  579.  
  580.         if (!header)
  581.                 return NULL;
  582.         if (header->opcode != (int32_t)RBUG_OP_CONTEXT_DRAW_UNBLOCK)
  583.                 return NULL;
  584.  
  585.         pos = 0;
  586.         len = header->length * 4;
  587.         data = (uint8_t*)&header[1];
  588.         ret = MALLOC(sizeof(*ret));
  589.         if (!ret)
  590.                 return NULL;
  591.  
  592.         ret->header.__message = header;
  593.         ret->header.opcode = header->opcode;
  594.  
  595.         READ(8, rbug_context_t, context); /* context */
  596.         READ(4, rbug_block_t, unblock); /* unblock */
  597.  
  598.         return ret;
  599. }
  600.  
  601. struct rbug_proto_context_draw_rule * rbug_demarshal_context_draw_rule(struct rbug_proto_header *header)
  602. {
  603.         uint32_t len = 0;
  604.         uint32_t pos = 0;
  605.         uint8_t *data =  NULL;
  606.         struct rbug_proto_context_draw_rule *ret;
  607.  
  608.         if (!header)
  609.                 return NULL;
  610.         if (header->opcode != (int32_t)RBUG_OP_CONTEXT_DRAW_RULE)
  611.                 return NULL;
  612.  
  613.         pos = 0;
  614.         len = header->length * 4;
  615.         data = (uint8_t*)&header[1];
  616.         ret = MALLOC(sizeof(*ret));
  617.         if (!ret)
  618.                 return NULL;
  619.  
  620.         ret->header.__message = header;
  621.         ret->header.opcode = header->opcode;
  622.  
  623.         READ(8, rbug_context_t, context); /* context */
  624.         READ(8, rbug_shader_t, vertex); /* vertex */
  625.         READ(8, rbug_shader_t, fragment); /* fragment */
  626.         READ(8, rbug_texture_t, texture); /* texture */
  627.         READ(8, rbug_texture_t, surface); /* surface */
  628.         READ(4, rbug_block_t, block); /* block */
  629.  
  630.         return ret;
  631. }
  632.  
  633. struct rbug_proto_context_flush * rbug_demarshal_context_flush(struct rbug_proto_header *header)
  634. {
  635.         uint32_t len = 0;
  636.         uint32_t pos = 0;
  637.         uint8_t *data =  NULL;
  638.         struct rbug_proto_context_flush *ret;
  639.  
  640.         if (!header)
  641.                 return NULL;
  642.         if (header->opcode != (int32_t)RBUG_OP_CONTEXT_FLUSH)
  643.                 return NULL;
  644.  
  645.         pos = 0;
  646.         len = header->length * 4;
  647.         data = (uint8_t*)&header[1];
  648.         ret = MALLOC(sizeof(*ret));
  649.         if (!ret)
  650.                 return NULL;
  651.  
  652.         ret->header.__message = header;
  653.         ret->header.opcode = header->opcode;
  654.  
  655.         READ(8, rbug_context_t, context); /* context */
  656.  
  657.         return ret;
  658. }
  659.  
  660. struct rbug_proto_context_list_reply * rbug_demarshal_context_list_reply(struct rbug_proto_header *header)
  661. {
  662.         uint32_t len = 0;
  663.         uint32_t pos = 0;
  664.         uint8_t *data =  NULL;
  665.         struct rbug_proto_context_list_reply *ret;
  666.  
  667.         if (!header)
  668.                 return NULL;
  669.         if (header->opcode != (int32_t)RBUG_OP_CONTEXT_LIST_REPLY)
  670.                 return NULL;
  671.  
  672.         pos = 0;
  673.         len = header->length * 4;
  674.         data = (uint8_t*)&header[1];
  675.         ret = MALLOC(sizeof(*ret));
  676.         if (!ret)
  677.                 return NULL;
  678.  
  679.         ret->header.__message = header;
  680.         ret->header.opcode = header->opcode;
  681.  
  682.         READ(4, uint32_t, serial); /* serial */
  683.         READ_ARRAY(8, rbug_context_t, contexts); /* contexts */
  684.  
  685.         return ret;
  686. }
  687.  
  688. struct rbug_proto_context_info_reply * rbug_demarshal_context_info_reply(struct rbug_proto_header *header)
  689. {
  690.         uint32_t len = 0;
  691.         uint32_t pos = 0;
  692.         uint8_t *data =  NULL;
  693.         struct rbug_proto_context_info_reply *ret;
  694.  
  695.         if (!header)
  696.                 return NULL;
  697.         if (header->opcode != (int32_t)RBUG_OP_CONTEXT_INFO_REPLY)
  698.                 return NULL;
  699.  
  700.         pos = 0;
  701.         len = header->length * 4;
  702.         data = (uint8_t*)&header[1];
  703.         ret = MALLOC(sizeof(*ret));
  704.         if (!ret)
  705.                 return NULL;
  706.  
  707.         ret->header.__message = header;
  708.         ret->header.opcode = header->opcode;
  709.  
  710.         READ(4, uint32_t, serial); /* serial */
  711.         READ(8, rbug_shader_t, vertex); /* vertex */
  712.         READ(8, rbug_shader_t, fragment); /* fragment */
  713.         READ_ARRAY(8, rbug_texture_t, texs); /* texs */
  714.         READ_ARRAY(8, rbug_texture_t, cbufs); /* cbufs */
  715.         READ(8, rbug_texture_t, zsbuf); /* zsbuf */
  716.         READ(4, rbug_block_t, blocker); /* blocker */
  717.         READ(4, rbug_block_t, blocked); /* blocked */
  718.  
  719.         return ret;
  720. }
  721.  
  722. struct rbug_proto_context_draw_blocked * rbug_demarshal_context_draw_blocked(struct rbug_proto_header *header)
  723. {
  724.         uint32_t len = 0;
  725.         uint32_t pos = 0;
  726.         uint8_t *data =  NULL;
  727.         struct rbug_proto_context_draw_blocked *ret;
  728.  
  729.         if (!header)
  730.                 return NULL;
  731.         if (header->opcode != (int32_t)RBUG_OP_CONTEXT_DRAW_BLOCKED)
  732.                 return NULL;
  733.  
  734.         pos = 0;
  735.         len = header->length * 4;
  736.         data = (uint8_t*)&header[1];
  737.         ret = MALLOC(sizeof(*ret));
  738.         if (!ret)
  739.                 return NULL;
  740.  
  741.         ret->header.__message = header;
  742.         ret->header.opcode = header->opcode;
  743.  
  744.         READ(8, rbug_context_t, context); /* context */
  745.         READ(4, rbug_block_t, block); /* block */
  746.  
  747.         return ret;
  748. }
  749.