src/gallium/auxiliary/rbug/rbug_context.c

   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/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_flush(struct rbug_connection *__con,
 237                             rbug_context_t context,
 238                             int32_t flags,
 239                             uint32_t *__serial)
 240 {
 241         uint32_t __len = 0;
 242         uint32_t __pos = 0;
 243         uint8_t *__data = NULL;
 244         int __ret = 0;
 245
 246         LEN(8); /* header */
 247         LEN(8); /* context */
 248         LEN(4); /* flags */
 249
 250         /* align */
 251         PAD(__len, 8);
 252
 253         __data = (uint8_t*)MALLOC(__len);
 254         if (!__data)
 255                 return -ENOMEM;
 256
 257         WRITE(4, int32_t, ((int32_t)RBUG_OP_CONTEXT_FLUSH));
 258         WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
 259         WRITE(8, rbug_context_t, context); /* context */
 260         WRITE(4, int32_t, flags); /* flags */
 261
 262         /* final pad */
 263         PAD(__pos, 8);
 264
 265         if (__pos != __len) {
 266                 __ret = -EINVAL;
 267         } else {
 268                 rbug_connection_send_start(__con, RBUG_OP_CONTEXT_FLUSH, __len);
 269                 rbug_connection_write(__con, __data, __len);
 270                 __ret = rbug_connection_send_finish(__con, __serial);
 271         }
 272
 273         FREE(__data);
 274         return __ret;
 275 }
 276
 277 int rbug_send_context_rule_add(struct rbug_connection *__con,
 278                                rbug_context_t context,
 279                                rbug_shader_t vertex,
 280                                rbug_shader_t fragment,
 281                                rbug_texture_t texture,
 282                                rbug_texture_t surface,
 283                                rbug_block_t block,
 284                                uint32_t *__serial)
 285 {
 286         uint32_t __len = 0;
 287         uint32_t __pos = 0;
 288         uint8_t *__data = NULL;
 289         int __ret = 0;
 290
 291         LEN(8); /* header */
 292         LEN(8); /* context */
 293         LEN(8); /* vertex */
 294         LEN(8); /* fragment */
 295         LEN(8); /* texture */
 296         LEN(8); /* surface */
 297         LEN(4); /* block */
 298
 299         /* align */
 300         PAD(__len, 8);
 301
 302         __data = (uint8_t*)MALLOC(__len);
 303         if (!__data)
 304                 return -ENOMEM;
 305
 306         WRITE(4, int32_t, ((int32_t)RBUG_OP_CONTEXT_RULE_ADD));
 307         WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
 308         WRITE(8, rbug_context_t, context); /* context */
 309         WRITE(8, rbug_shader_t, vertex); /* vertex */
 310         WRITE(8, rbug_shader_t, fragment); /* fragment */
 311         WRITE(8, rbug_texture_t, texture); /* texture */
 312         WRITE(8, rbug_texture_t, surface); /* surface */
 313         WRITE(4, rbug_block_t, block); /* block */
 314
 315         /* final pad */
 316         PAD(__pos, 8);
 317
 318         if (__pos != __len) {
 319                 __ret = -EINVAL;
 320         } else {
 321                 rbug_connection_send_start(__con, RBUG_OP_CONTEXT_RULE_ADD, __len);
 322                 rbug_connection_write(__con, __data, __len);
 323                 __ret = rbug_connection_send_finish(__con, __serial);
 324         }
 325
 326         FREE(__data);
 327         return __ret;
 328 }
 329
 330 int rbug_send_context_rule_delete(struct rbug_connection *__con,
 331                                   rbug_context_t context,
 332                                   rbug_block_rule_t rule,
 333                                   uint32_t *__serial)
 334 {
 335         uint32_t __len = 0;
 336         uint32_t __pos = 0;
 337         uint8_t *__data = NULL;
 338         int __ret = 0;
 339
 340         LEN(8); /* header */
 341         LEN(8); /* context */
 342         LEN(8); /* rule */
 343
 344         /* align */
 345         PAD(__len, 8);
 346
 347         __data = (uint8_t*)MALLOC(__len);
 348         if (!__data)
 349                 return -ENOMEM;
 350
 351         WRITE(4, int32_t, ((int32_t)RBUG_OP_CONTEXT_RULE_DELETE));
 352         WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
 353         WRITE(8, rbug_context_t, context); /* context */
 354         WRITE(8, rbug_block_rule_t, rule); /* rule */
 355
 356         /* final pad */
 357         PAD(__pos, 8);
 358
 359         if (__pos != __len) {
 360                 __ret = -EINVAL;
 361         } else {
 362                 rbug_connection_send_start(__con, RBUG_OP_CONTEXT_RULE_DELETE, __len);
 363                 rbug_connection_write(__con, __data, __len);
 364                 __ret = rbug_connection_send_finish(__con, __serial);
 365         }
 366
 367         FREE(__data);
 368         return __ret;
 369 }
 370
 371 int rbug_send_context_list_reply(struct rbug_connection *__con,
 372                                  uint32_t serial,
 373                                  rbug_context_t *contexts,
 374                                  uint32_t contexts_len,
 375                                  uint32_t *__serial)
 376 {
 377         uint32_t __len = 0;
 378         uint32_t __pos = 0;
 379         uint8_t *__data = NULL;
 380         int __ret = 0;
 381
 382         LEN(8); /* header */
 383         LEN(4); /* serial */
 384         LEN_ARRAY(8, contexts); /* contexts */
 385
 386         /* align */
 387         PAD(__len, 8);
 388
 389         __data = (uint8_t*)MALLOC(__len);
 390         if (!__data)
 391                 return -ENOMEM;
 392
 393         WRITE(4, int32_t, ((int32_t)RBUG_OP_CONTEXT_LIST_REPLY));
 394         WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
 395         WRITE(4, uint32_t, serial); /* serial */
 396         WRITE_ARRAY(8, rbug_context_t, contexts); /* contexts */
 397
 398         /* final pad */
 399         PAD(__pos, 8);
 400
 401         if (__pos != __len) {
 402                 __ret = -EINVAL;
 403         } else {
 404                 rbug_connection_send_start(__con, RBUG_OP_CONTEXT_LIST_REPLY, __len);
 405                 rbug_connection_write(__con, __data, __len);
 406                 __ret = rbug_connection_send_finish(__con, __serial);
 407         }
 408
 409         FREE(__data);
 410         return __ret;
 411 }
 412
 413 int rbug_send_context_info_reply(struct rbug_connection *__con,
 414                                  uint32_t serial,
 415                                  rbug_shader_t vertex,
 416                                  rbug_shader_t fragment,
 417                                  rbug_texture_t *texs,
 418                                  uint32_t texs_len,
 419                                  rbug_texture_t *cbufs,
 420                                  uint32_t cbufs_len,
 421                                  rbug_texture_t zsbuf,
 422                                  rbug_block_t blocker,
 423                                  rbug_block_t blocked,
 424                                  uint32_t *__serial)
 425 {
 426         uint32_t __len = 0;
 427         uint32_t __pos = 0;
 428         uint8_t *__data = NULL;
 429         int __ret = 0;
 430
 431         LEN(8); /* header */
 432         LEN(4); /* serial */
 433         LEN(8); /* vertex */
 434         LEN(8); /* fragment */
 435         LEN_ARRAY(8, texs); /* texs */
 436         LEN_ARRAY(8, cbufs); /* cbufs */
 437         LEN(8); /* zsbuf */
 438         LEN(4); /* blocker */
 439         LEN(4); /* blocked */
 440
 441         /* align */
 442         PAD(__len, 8);
 443
 444         __data = (uint8_t*)MALLOC(__len);
 445         if (!__data)
 446                 return -ENOMEM;
 447
 448         WRITE(4, int32_t, ((int32_t)RBUG_OP_CONTEXT_INFO_REPLY));
 449         WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
 450         WRITE(4, uint32_t, serial); /* serial */
 451         WRITE(8, rbug_shader_t, vertex); /* vertex */
 452         WRITE(8, rbug_shader_t, fragment); /* fragment */
 453         WRITE_ARRAY(8, rbug_texture_t, texs); /* texs */
 454         WRITE_ARRAY(8, rbug_texture_t, cbufs); /* cbufs */
 455         WRITE(8, rbug_texture_t, zsbuf); /* zsbuf */
 456         WRITE(4, rbug_block_t, blocker); /* blocker */
 457         WRITE(4, rbug_block_t, blocked); /* blocked */
 458
 459         /* final pad */
 460         PAD(__pos, 8);
 461
 462         if (__pos != __len) {
 463                 __ret = -EINVAL;
 464         } else {
 465                 rbug_connection_send_start(__con, RBUG_OP_CONTEXT_INFO_REPLY, __len);
 466                 rbug_connection_write(__con, __data, __len);
 467                 __ret = rbug_connection_send_finish(__con, __serial);
 468         }
 469
 470         FREE(__data);
 471         return __ret;
 472 }
 473
 474 int rbug_send_context_rule_add_reply(struct rbug_connection *__con,
 475                                      uint32_t serial,
 476                                      rbug_block_rule_t rule,
 477                                      uint32_t *__serial)
 478 {
 479         uint32_t __len = 0;
 480         uint32_t __pos = 0;
 481         uint8_t *__data = NULL;
 482         int __ret = 0;
 483
 484         LEN(8); /* header */
 485         LEN(4); /* serial */
 486         LEN(8); /* rule */
 487
 488         /* align */
 489         PAD(__len, 8);
 490
 491         __data = (uint8_t*)MALLOC(__len);
 492         if (!__data)
 493                 return -ENOMEM;
 494
 495         WRITE(4, int32_t, ((int32_t)RBUG_OP_CONTEXT_RULE_ADD_REPLY));
 496         WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
 497         WRITE(4, uint32_t, serial); /* serial */
 498         WRITE(8, rbug_block_rule_t, rule); /* rule */
 499
 500         /* final pad */
 501         PAD(__pos, 8);
 502
 503         if (__pos != __len) {
 504                 __ret = -EINVAL;
 505         } else {
 506                 rbug_connection_send_start(__con, RBUG_OP_CONTEXT_RULE_ADD_REPLY, __len);
 507                 rbug_connection_write(__con, __data, __len);
 508                 __ret = rbug_connection_send_finish(__con, __serial);
 509         }
 510
 511         FREE(__data);
 512         return __ret;
 513 }
 514
 515 int rbug_send_context_draw_blocked(struct rbug_connection *__con,
 516                                    rbug_context_t context,
 517                                    rbug_block_t block,
 518                                    uint32_t *__serial)
 519 {
 520         uint32_t __len = 0;
 521         uint32_t __pos = 0;
 522         uint8_t *__data = NULL;
 523         int __ret = 0;
 524
 525         LEN(8); /* header */
 526         LEN(8); /* context */
 527         LEN(4); /* block */
 528
 529         /* align */
 530         PAD(__len, 8);
 531
 532         __data = (uint8_t*)MALLOC(__len);
 533         if (!__data)
 534                 return -ENOMEM;
 535
 536         WRITE(4, int32_t, ((int32_t)RBUG_OP_CONTEXT_DRAW_BLOCKED));
 537         WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
 538         WRITE(8, rbug_context_t, context); /* context */
 539         WRITE(4, rbug_block_t, block); /* block */
 540
 541         /* final pad */
 542         PAD(__pos, 8);
 543
 544         if (__pos != __len) {
 545                 __ret = -EINVAL;
 546         } else {
 547                 rbug_connection_send_start(__con, RBUG_OP_CONTEXT_DRAW_BLOCKED, __len);
 548                 rbug_connection_write(__con, __data, __len);
 549                 __ret = rbug_connection_send_finish(__con, __serial);
 550         }
 551
 552         FREE(__data);
 553         return __ret;
 554 }
 555
 556 struct rbug_proto_context_list * rbug_demarshal_context_list(struct rbug_proto_header *header)
 557 {
 558         uint32_t len = 0;
 559         uint32_t pos = 0;
 560         uint8_t *data =  NULL;
 561         struct rbug_proto_context_list *ret;
 562
 563         if (!header)
 564                 return NULL;
 565         if (header->opcode != (int16_t)RBUG_OP_CONTEXT_LIST)
 566                 return NULL;
 567
 568         pos = 0;
 569         len = header->length * 4;
 570         data = (uint8_t*)&header[1];
 571         ret = MALLOC(sizeof(*ret));
 572         if (!ret)
 573                 return NULL;
 574
 575         ret->header.__message = header;
 576         ret->header.opcode = header->opcode;
 577
 578
 579         return ret;
 580 }
 581
 582 struct rbug_proto_context_info * rbug_demarshal_context_info(struct rbug_proto_header *header)
 583 {
 584         uint32_t len = 0;
 585         uint32_t pos = 0;
 586         uint8_t *data =  NULL;
 587         struct rbug_proto_context_info *ret;
 588
 589         if (!header)
 590                 return NULL;
 591         if (header->opcode != (int16_t)RBUG_OP_CONTEXT_INFO)
 592                 return NULL;
 593
 594         pos = 0;
 595         len = header->length * 4;
 596         data = (uint8_t*)&header[1];
 597         ret = MALLOC(sizeof(*ret));
 598         if (!ret)
 599                 return NULL;
 600
 601         ret->header.__message = header;
 602         ret->header.opcode = header->opcode;
 603
 604         READ(8, rbug_context_t, context); /* context */
 605
 606         return ret;
 607 }
 608
 609 struct rbug_proto_context_draw_block * rbug_demarshal_context_draw_block(struct rbug_proto_header *header)
 610 {
 611         uint32_t len = 0;
 612         uint32_t pos = 0;
 613         uint8_t *data =  NULL;
 614         struct rbug_proto_context_draw_block *ret;
 615
 616         if (!header)
 617                 return NULL;
 618         if (header->opcode != (int16_t)RBUG_OP_CONTEXT_DRAW_BLOCK)
 619                 return NULL;
 620
 621         pos = 0;
 622         len = header->length * 4;
 623         data = (uint8_t*)&header[1];
 624         ret = MALLOC(sizeof(*ret));
 625         if (!ret)
 626                 return NULL;
 627
 628         ret->header.__message = header;
 629         ret->header.opcode = header->opcode;
 630
 631         READ(8, rbug_context_t, context); /* context */
 632         READ(4, rbug_block_t, block); /* block */
 633
 634         return ret;
 635 }
 636
 637 struct rbug_proto_context_draw_step * rbug_demarshal_context_draw_step(struct rbug_proto_header *header)
 638 {
 639         uint32_t len = 0;
 640         uint32_t pos = 0;
 641         uint8_t *data =  NULL;
 642         struct rbug_proto_context_draw_step *ret;
 643
 644         if (!header)
 645                 return NULL;
 646         if (header->opcode != (int16_t)RBUG_OP_CONTEXT_DRAW_STEP)
 647                 return NULL;
 648
 649         pos = 0;
 650         len = header->length * 4;
 651         data = (uint8_t*)&header[1];
 652         ret = MALLOC(sizeof(*ret));
 653         if (!ret)
 654                 return NULL;
 655
 656         ret->header.__message = header;
 657         ret->header.opcode = header->opcode;
 658
 659         READ(8, rbug_context_t, context); /* context */
 660         READ(4, rbug_block_t, step); /* step */
 661
 662         return ret;
 663 }
 664
 665 struct rbug_proto_context_draw_unblock * rbug_demarshal_context_draw_unblock(struct rbug_proto_header *header)
 666 {
 667         uint32_t len = 0;
 668         uint32_t pos = 0;
 669         uint8_t *data =  NULL;
 670         struct rbug_proto_context_draw_unblock *ret;
 671
 672         if (!header)
 673                 return NULL;
 674         if (header->opcode != (int16_t)RBUG_OP_CONTEXT_DRAW_UNBLOCK)
 675                 return NULL;
 676
 677         pos = 0;
 678         len = header->length * 4;
 679         data = (uint8_t*)&header[1];
 680         ret = MALLOC(sizeof(*ret));
 681         if (!ret)
 682                 return NULL;
 683
 684         ret->header.__message = header;
 685         ret->header.opcode = header->opcode;
 686
 687         READ(8, rbug_context_t, context); /* context */
 688         READ(4, rbug_block_t, unblock); /* unblock */
 689
 690         return ret;
 691 }
 692
 693 struct rbug_proto_context_flush * rbug_demarshal_context_flush(struct rbug_proto_header *header)
 694 {
 695         uint32_t len = 0;
 696         uint32_t pos = 0;
 697         uint8_t *data =  NULL;
 698         struct rbug_proto_context_flush *ret;
 699
 700         if (!header)
 701                 return NULL;
 702         if (header->opcode != (int16_t)RBUG_OP_CONTEXT_FLUSH)
 703                 return NULL;
 704
 705         pos = 0;
 706         len = header->length * 4;
 707         data = (uint8_t*)&header[1];
 708         ret = MALLOC(sizeof(*ret));
 709         if (!ret)
 710                 return NULL;
 711
 712         ret->header.__message = header;
 713         ret->header.opcode = header->opcode;
 714
 715         READ(8, rbug_context_t, context); /* context */
 716         READ(4, int32_t, flags); /* flags */
 717
 718         return ret;
 719 }
 720
 721 struct rbug_proto_context_rule_add * rbug_demarshal_context_rule_add(struct rbug_proto_header *header)
 722 {
 723         uint32_t len = 0;
 724         uint32_t pos = 0;
 725         uint8_t *data =  NULL;
 726         struct rbug_proto_context_rule_add *ret;
 727
 728         if (!header)
 729                 return NULL;
 730         if (header->opcode != (int16_t)RBUG_OP_CONTEXT_RULE_ADD)
 731                 return NULL;
 732
 733         pos = 0;
 734         len = header->length * 4;
 735         data = (uint8_t*)&header[1];
 736         ret = MALLOC(sizeof(*ret));
 737         if (!ret)
 738                 return NULL;
 739
 740         ret->header.__message = header;
 741         ret->header.opcode = header->opcode;
 742
 743         READ(8, rbug_context_t, context); /* context */
 744         READ(8, rbug_shader_t, vertex); /* vertex */
 745         READ(8, rbug_shader_t, fragment); /* fragment */
 746         READ(8, rbug_texture_t, texture); /* texture */
 747         READ(8, rbug_texture_t, surface); /* surface */
 748         READ(4, rbug_block_t, block); /* block */
 749
 750         return ret;
 751 }
 752
 753 struct rbug_proto_context_rule_delete * rbug_demarshal_context_rule_delete(struct rbug_proto_header *header)
 754 {
 755         uint32_t len = 0;
 756         uint32_t pos = 0;
 757         uint8_t *data =  NULL;
 758         struct rbug_proto_context_rule_delete *ret;
 759
 760         if (!header)
 761                 return NULL;
 762         if (header->opcode != (int16_t)RBUG_OP_CONTEXT_RULE_DELETE)
 763                 return NULL;
 764
 765         pos = 0;
 766         len = header->length * 4;
 767         data = (uint8_t*)&header[1];
 768         ret = MALLOC(sizeof(*ret));
 769         if (!ret)
 770                 return NULL;
 771
 772         ret->header.__message = header;
 773         ret->header.opcode = header->opcode;
 774
 775         READ(8, rbug_context_t, context); /* context */
 776         READ(8, rbug_block_rule_t, rule); /* rule */
 777
 778         return ret;
 779 }
 780
 781 struct rbug_proto_context_list_reply * rbug_demarshal_context_list_reply(struct rbug_proto_header *header)
 782 {
 783         uint32_t len = 0;
 784         uint32_t pos = 0;
 785         uint8_t *data =  NULL;
 786         struct rbug_proto_context_list_reply *ret;
 787
 788         if (!header)
 789                 return NULL;
 790         if (header->opcode != (int16_t)RBUG_OP_CONTEXT_LIST_REPLY)
 791                 return NULL;
 792
 793         pos = 0;
 794         len = header->length * 4;
 795         data = (uint8_t*)&header[1];
 796         ret = MALLOC(sizeof(*ret));
 797         if (!ret)
 798                 return NULL;
 799
 800         ret->header.__message = header;
 801         ret->header.opcode = header->opcode;
 802
 803         READ(4, uint32_t, serial); /* serial */
 804         READ_ARRAY(8, rbug_context_t, contexts); /* contexts */
 805
 806         return ret;
 807 }
 808
 809 struct rbug_proto_context_info_reply * rbug_demarshal_context_info_reply(struct rbug_proto_header *header)
 810 {
 811         uint32_t len = 0;
 812         uint32_t pos = 0;
 813         uint8_t *data =  NULL;
 814         struct rbug_proto_context_info_reply *ret;
 815
 816         if (!header)
 817                 return NULL;
 818         if (header->opcode != (int16_t)RBUG_OP_CONTEXT_INFO_REPLY)
 819                 return NULL;
 820
 821         pos = 0;
 822         len = header->length * 4;
 823         data = (uint8_t*)&header[1];
 824         ret = MALLOC(sizeof(*ret));
 825         if (!ret)
 826                 return NULL;
 827
 828         ret->header.__message = header;
 829         ret->header.opcode = header->opcode;
 830
 831         READ(4, uint32_t, serial); /* serial */
 832         READ(8, rbug_shader_t, vertex); /* vertex */
 833         READ(8, rbug_shader_t, fragment); /* fragment */
 834         READ_ARRAY(8, rbug_texture_t, texs); /* texs */
 835         READ_ARRAY(8, rbug_texture_t, cbufs); /* cbufs */
 836         READ(8, rbug_texture_t, zsbuf); /* zsbuf */
 837         READ(4, rbug_block_t, blocker); /* blocker */
 838         READ(4, rbug_block_t, blocked); /* blocked */
 839
 840         return ret;
 841 }
 842
 843 struct rbug_proto_context_rule_add_reply * rbug_demarshal_context_rule_add_reply(struct rbug_proto_header *header)
 844 {
 845         uint32_t len = 0;
 846         uint32_t pos = 0;
 847         uint8_t *data =  NULL;
 848         struct rbug_proto_context_rule_add_reply *ret;
 849
 850         if (!header)
 851                 return NULL;
 852         if (header->opcode != (int16_t)RBUG_OP_CONTEXT_RULE_ADD_REPLY)
 853                 return NULL;
 854
 855         pos = 0;
 856         len = header->length * 4;
 857         data = (uint8_t*)&header[1];
 858         ret = MALLOC(sizeof(*ret));
 859         if (!ret)
 860                 return NULL;
 861
 862         ret->header.__message = header;
 863         ret->header.opcode = header->opcode;
 864
 865         READ(4, uint32_t, serial); /* serial */
 866         READ(8, rbug_block_rule_t, rule); /* rule */
 867
 868         return ret;
 869 }
 870
 871 struct rbug_proto_context_draw_blocked * rbug_demarshal_context_draw_blocked(struct rbug_proto_header *header)
 872 {
 873         uint32_t len = 0;
 874         uint32_t pos = 0;
 875         uint8_t *data =  NULL;
 876         struct rbug_proto_context_draw_blocked *ret;
 877
 878         if (!header)
 879                 return NULL;
 880         if (header->opcode != (int16_t)RBUG_OP_CONTEXT_DRAW_BLOCKED)
 881                 return NULL;
 882
 883         pos = 0;
 884         len = header->length * 4;
 885         data = (uint8_t*)&header[1];
 886         ret = MALLOC(sizeof(*ret));
 887         if (!ret)
 888                 return NULL;
 889
 890         ret->header.__message = header;
 891         ret->header.opcode = header->opcode;
 892
 893         READ(8, rbug_context_t, context); /* context */
 894         READ(4, rbug_block_t, block); /* block */
 895
 896         return ret;
 897 }