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_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                             int32_t flags,
 292                             uint32_t *__serial)
 293 {
 294         uint32_t __len = 0;
 295         uint32_t __pos = 0;
 296         uint8_t *__data = NULL;
 297         int __ret = 0;
 298
 299         LEN(8); /* header */
 300         LEN(8); /* context */
 301         LEN(4); /* flags */
 302
 303         /* align */
 304         PAD(__len, 8);
 305
 306         __data = (uint8_t*)MALLOC(__len);
 307         if (!__data)
 308                 return -ENOMEM;
 309
 310         WRITE(4, int32_t, ((int32_t)RBUG_OP_CONTEXT_FLUSH));
 311         WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
 312         WRITE(8, rbug_context_t, context); /* context */
 313         WRITE(4, int32_t, flags); /* flags */
 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_FLUSH, __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_list_reply(struct rbug_connection *__con,
 331                                  uint32_t serial,
 332                                  rbug_context_t *contexts,
 333                                  uint32_t contexts_len,
 334                                  uint32_t *__serial)
 335 {
 336         uint32_t __len = 0;
 337         uint32_t __pos = 0;
 338         uint8_t *__data = NULL;
 339         int __ret = 0;
 340
 341         LEN(8); /* header */
 342         LEN(4); /* serial */
 343         LEN_ARRAY(8, contexts); /* contexts */
 344
 345         /* align */
 346         PAD(__len, 8);
 347
 348         __data = (uint8_t*)MALLOC(__len);
 349         if (!__data)
 350                 return -ENOMEM;
 351
 352         WRITE(4, int32_t, ((int32_t)RBUG_OP_CONTEXT_LIST_REPLY));
 353         WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
 354         WRITE(4, uint32_t, serial); /* serial */
 355         WRITE_ARRAY(8, rbug_context_t, contexts); /* contexts */
 356
 357         /* final pad */
 358         PAD(__pos, 8);
 359
 360         if (__pos != __len) {
 361                 __ret = -EINVAL;
 362         } else {
 363                 rbug_connection_send_start(__con, RBUG_OP_CONTEXT_LIST_REPLY, __len);
 364                 rbug_connection_write(__con, __data, __len);
 365                 __ret = rbug_connection_send_finish(__con, __serial);
 366         }
 367
 368         FREE(__data);
 369         return __ret;
 370 }
 371
 372 int rbug_send_context_info_reply(struct rbug_connection *__con,
 373                                  uint32_t serial,
 374                                  rbug_shader_t vertex,
 375                                  rbug_shader_t fragment,
 376                                  rbug_texture_t *texs,
 377                                  uint32_t texs_len,
 378                                  rbug_texture_t *cbufs,
 379                                  uint32_t cbufs_len,
 380                                  rbug_texture_t zsbuf,
 381                                  rbug_block_t blocker,
 382                                  rbug_block_t blocked,
 383                                  uint32_t *__serial)
 384 {
 385         uint32_t __len = 0;
 386         uint32_t __pos = 0;
 387         uint8_t *__data = NULL;
 388         int __ret = 0;
 389
 390         LEN(8); /* header */
 391         LEN(4); /* serial */
 392         LEN(8); /* vertex */
 393         LEN(8); /* fragment */
 394         LEN_ARRAY(8, texs); /* texs */
 395         LEN_ARRAY(8, cbufs); /* cbufs */
 396         LEN(8); /* zsbuf */
 397         LEN(4); /* blocker */
 398         LEN(4); /* blocked */
 399
 400         /* align */
 401         PAD(__len, 8);
 402
 403         __data = (uint8_t*)MALLOC(__len);
 404         if (!__data)
 405                 return -ENOMEM;
 406
 407         WRITE(4, int32_t, ((int32_t)RBUG_OP_CONTEXT_INFO_REPLY));
 408         WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
 409         WRITE(4, uint32_t, serial); /* serial */
 410         WRITE(8, rbug_shader_t, vertex); /* vertex */
 411         WRITE(8, rbug_shader_t, fragment); /* fragment */
 412         WRITE_ARRAY(8, rbug_texture_t, texs); /* texs */
 413         WRITE_ARRAY(8, rbug_texture_t, cbufs); /* cbufs */
 414         WRITE(8, rbug_texture_t, zsbuf); /* zsbuf */
 415         WRITE(4, rbug_block_t, blocker); /* blocker */
 416         WRITE(4, rbug_block_t, blocked); /* blocked */
 417
 418         /* final pad */
 419         PAD(__pos, 8);
 420
 421         if (__pos != __len) {
 422                 __ret = -EINVAL;
 423         } else {
 424                 rbug_connection_send_start(__con, RBUG_OP_CONTEXT_INFO_REPLY, __len);
 425                 rbug_connection_write(__con, __data, __len);
 426                 __ret = rbug_connection_send_finish(__con, __serial);
 427         }
 428
 429         FREE(__data);
 430         return __ret;
 431 }
 432
 433 int rbug_send_context_draw_blocked(struct rbug_connection *__con,
 434                                    rbug_context_t context,
 435                                    rbug_block_t block,
 436                                    uint32_t *__serial)
 437 {
 438         uint32_t __len = 0;
 439         uint32_t __pos = 0;
 440         uint8_t *__data = NULL;
 441         int __ret = 0;
 442
 443         LEN(8); /* header */
 444         LEN(8); /* context */
 445         LEN(4); /* block */
 446
 447         /* align */
 448         PAD(__len, 8);
 449
 450         __data = (uint8_t*)MALLOC(__len);
 451         if (!__data)
 452                 return -ENOMEM;
 453
 454         WRITE(4, int32_t, ((int32_t)RBUG_OP_CONTEXT_DRAW_BLOCKED));
 455         WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
 456         WRITE(8, rbug_context_t, context); /* context */
 457         WRITE(4, rbug_block_t, block); /* block */
 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_DRAW_BLOCKED, __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 struct rbug_proto_context_list * rbug_demarshal_context_list(struct rbug_proto_header *header)
 475 {
 476         uint32_t len = 0;
 477         uint32_t pos = 0;
 478         uint8_t *data =  NULL;
 479         struct rbug_proto_context_list *ret;
 480
 481         if (!header)
 482                 return NULL;
 483         if (header->opcode != (int16_t)RBUG_OP_CONTEXT_LIST)
 484                 return NULL;
 485
 486         pos = 0;
 487         len = header->length * 4;
 488         data = (uint8_t*)&header[1];
 489         ret = MALLOC(sizeof(*ret));
 490         if (!ret)
 491                 return NULL;
 492
 493         ret->header.__message = header;
 494         ret->header.opcode = header->opcode;
 495
 496
 497         return ret;
 498 }
 499
 500 struct rbug_proto_context_info * rbug_demarshal_context_info(struct rbug_proto_header *header)
 501 {
 502         uint32_t len = 0;
 503         uint32_t pos = 0;
 504         uint8_t *data =  NULL;
 505         struct rbug_proto_context_info *ret;
 506
 507         if (!header)
 508                 return NULL;
 509         if (header->opcode != (int16_t)RBUG_OP_CONTEXT_INFO)
 510                 return NULL;
 511
 512         pos = 0;
 513         len = header->length * 4;
 514         data = (uint8_t*)&header[1];
 515         ret = MALLOC(sizeof(*ret));
 516         if (!ret)
 517                 return NULL;
 518
 519         ret->header.__message = header;
 520         ret->header.opcode = header->opcode;
 521
 522         READ(8, rbug_context_t, context); /* context */
 523
 524         return ret;
 525 }
 526
 527 struct rbug_proto_context_draw_block * rbug_demarshal_context_draw_block(struct rbug_proto_header *header)
 528 {
 529         uint32_t len = 0;
 530         uint32_t pos = 0;
 531         uint8_t *data =  NULL;
 532         struct rbug_proto_context_draw_block *ret;
 533
 534         if (!header)
 535                 return NULL;
 536         if (header->opcode != (int16_t)RBUG_OP_CONTEXT_DRAW_BLOCK)
 537                 return NULL;
 538
 539         pos = 0;
 540         len = header->length * 4;
 541         data = (uint8_t*)&header[1];
 542         ret = MALLOC(sizeof(*ret));
 543         if (!ret)
 544                 return NULL;
 545
 546         ret->header.__message = header;
 547         ret->header.opcode = header->opcode;
 548
 549         READ(8, rbug_context_t, context); /* context */
 550         READ(4, rbug_block_t, block); /* block */
 551
 552         return ret;
 553 }
 554
 555 struct rbug_proto_context_draw_step * rbug_demarshal_context_draw_step(struct rbug_proto_header *header)
 556 {
 557         uint32_t len = 0;
 558         uint32_t pos = 0;
 559         uint8_t *data =  NULL;
 560         struct rbug_proto_context_draw_step *ret;
 561
 562         if (!header)
 563                 return NULL;
 564         if (header->opcode != (int16_t)RBUG_OP_CONTEXT_DRAW_STEP)
 565                 return NULL;
 566
 567         pos = 0;
 568         len = header->length * 4;
 569         data = (uint8_t*)&header[1];
 570         ret = MALLOC(sizeof(*ret));
 571         if (!ret)
 572                 return NULL;
 573
 574         ret->header.__message = header;
 575         ret->header.opcode = header->opcode;
 576
 577         READ(8, rbug_context_t, context); /* context */
 578         READ(4, rbug_block_t, step); /* step */
 579
 580         return ret;
 581 }
 582
 583 struct rbug_proto_context_draw_unblock * rbug_demarshal_context_draw_unblock(struct rbug_proto_header *header)
 584 {
 585         uint32_t len = 0;
 586         uint32_t pos = 0;
 587         uint8_t *data =  NULL;
 588         struct rbug_proto_context_draw_unblock *ret;
 589
 590         if (!header)
 591                 return NULL;
 592         if (header->opcode != (int16_t)RBUG_OP_CONTEXT_DRAW_UNBLOCK)
 593                 return NULL;
 594
 595         pos = 0;
 596         len = header->length * 4;
 597         data = (uint8_t*)&header[1];
 598         ret = MALLOC(sizeof(*ret));
 599         if (!ret)
 600                 return NULL;
 601
 602         ret->header.__message = header;
 603         ret->header.opcode = header->opcode;
 604
 605         READ(8, rbug_context_t, context); /* context */
 606         READ(4, rbug_block_t, unblock); /* unblock */
 607
 608         return ret;
 609 }
 610
 611 struct rbug_proto_context_draw_rule * rbug_demarshal_context_draw_rule(struct rbug_proto_header *header)
 612 {
 613         uint32_t len = 0;
 614         uint32_t pos = 0;
 615         uint8_t *data =  NULL;
 616         struct rbug_proto_context_draw_rule *ret;
 617
 618         if (!header)
 619                 return NULL;
 620         if (header->opcode != (int16_t)RBUG_OP_CONTEXT_DRAW_RULE)
 621                 return NULL;
 622
 623         pos = 0;
 624         len = header->length * 4;
 625         data = (uint8_t*)&header[1];
 626         ret = MALLOC(sizeof(*ret));
 627         if (!ret)
 628                 return NULL;
 629
 630         ret->header.__message = header;
 631         ret->header.opcode = header->opcode;
 632
 633         READ(8, rbug_context_t, context); /* context */
 634         READ(8, rbug_shader_t, vertex); /* vertex */
 635         READ(8, rbug_shader_t, fragment); /* fragment */
 636         READ(8, rbug_texture_t, texture); /* texture */
 637         READ(8, rbug_texture_t, surface); /* surface */
 638         READ(4, rbug_block_t, block); /* block */
 639
 640         return ret;
 641 }
 642
 643 struct rbug_proto_context_flush * rbug_demarshal_context_flush(struct rbug_proto_header *header)
 644 {
 645         uint32_t len = 0;
 646         uint32_t pos = 0;
 647         uint8_t *data =  NULL;
 648         struct rbug_proto_context_flush *ret;
 649
 650         if (!header)
 651                 return NULL;
 652         if (header->opcode != (int16_t)RBUG_OP_CONTEXT_FLUSH)
 653                 return NULL;
 654
 655         pos = 0;
 656         len = header->length * 4;
 657         data = (uint8_t*)&header[1];
 658         ret = MALLOC(sizeof(*ret));
 659         if (!ret)
 660                 return NULL;
 661
 662         ret->header.__message = header;
 663         ret->header.opcode = header->opcode;
 664
 665         READ(8, rbug_context_t, context); /* context */
 666         READ(4, int32_t, flags); /* flags */
 667
 668         return ret;
 669 }
 670
 671 struct rbug_proto_context_list_reply * rbug_demarshal_context_list_reply(struct rbug_proto_header *header)
 672 {
 673         uint32_t len = 0;
 674         uint32_t pos = 0;
 675         uint8_t *data =  NULL;
 676         struct rbug_proto_context_list_reply *ret;
 677
 678         if (!header)
 679                 return NULL;
 680         if (header->opcode != (int16_t)RBUG_OP_CONTEXT_LIST_REPLY)
 681                 return NULL;
 682
 683         pos = 0;
 684         len = header->length * 4;
 685         data = (uint8_t*)&header[1];
 686         ret = MALLOC(sizeof(*ret));
 687         if (!ret)
 688                 return NULL;
 689
 690         ret->header.__message = header;
 691         ret->header.opcode = header->opcode;
 692
 693         READ(4, uint32_t, serial); /* serial */
 694         READ_ARRAY(8, rbug_context_t, contexts); /* contexts */
 695
 696         return ret;
 697 }
 698
 699 struct rbug_proto_context_info_reply * rbug_demarshal_context_info_reply(struct rbug_proto_header *header)
 700 {
 701         uint32_t len = 0;
 702         uint32_t pos = 0;
 703         uint8_t *data =  NULL;
 704         struct rbug_proto_context_info_reply *ret;
 705
 706         if (!header)
 707                 return NULL;
 708         if (header->opcode != (int16_t)RBUG_OP_CONTEXT_INFO_REPLY)
 709                 return NULL;
 710
 711         pos = 0;
 712         len = header->length * 4;
 713         data = (uint8_t*)&header[1];
 714         ret = MALLOC(sizeof(*ret));
 715         if (!ret)
 716                 return NULL;
 717
 718         ret->header.__message = header;
 719         ret->header.opcode = header->opcode;
 720
 721         READ(4, uint32_t, serial); /* serial */
 722         READ(8, rbug_shader_t, vertex); /* vertex */
 723         READ(8, rbug_shader_t, fragment); /* fragment */
 724         READ_ARRAY(8, rbug_texture_t, texs); /* texs */
 725         READ_ARRAY(8, rbug_texture_t, cbufs); /* cbufs */
 726         READ(8, rbug_texture_t, zsbuf); /* zsbuf */
 727         READ(4, rbug_block_t, blocker); /* blocker */
 728         READ(4, rbug_block_t, blocked); /* blocked */
 729
 730         return ret;
 731 }
 732
 733 struct rbug_proto_context_draw_blocked * rbug_demarshal_context_draw_blocked(struct rbug_proto_header *header)
 734 {
 735         uint32_t len = 0;
 736         uint32_t pos = 0;
 737         uint8_t *data =  NULL;
 738         struct rbug_proto_context_draw_blocked *ret;
 739
 740         if (!header)
 741                 return NULL;
 742         if (header->opcode != (int16_t)RBUG_OP_CONTEXT_DRAW_BLOCKED)
 743                 return NULL;
 744
 745         pos = 0;
 746         len = header->length * 4;
 747         data = (uint8_t*)&header[1];
 748         ret = MALLOC(sizeof(*ret));
 749         if (!ret)
 750                 return NULL;
 751
 752         ret->header.__message = header;
 753         ret->header.opcode = header->opcode;
 754
 755         READ(8, rbug_context_t, context); /* context */
 756         READ(4, rbug_block_t, block); /* block */
 757
 758         return ret;
 759 }