workbench/libs/mesa/src/gallium/auxiliary/rbug/rbug_texture.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_texture.h"
  39
  40 int rbug_send_texture_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_TEXTURE_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_TEXTURE_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_texture_info(struct rbug_connection *__con,
  76                            rbug_texture_t texture,
  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); /* texture */
  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_TEXTURE_INFO));
  95         WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
  96         WRITE(8, rbug_texture_t, texture); /* texture */
  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_TEXTURE_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_texture_write(struct rbug_connection *__con,
 114                             rbug_texture_t texture,
 115                             uint32_t face,
 116                             uint32_t level,
 117                             uint32_t zslice,
 118                             uint32_t x,
 119                             uint32_t y,
 120                             uint32_t w,
 121                             uint32_t h,
 122                             uint8_t *data,
 123                             uint32_t data_len,
 124                             uint32_t stride,
 125                             uint32_t *__serial)
 126 {
 127         uint32_t __len = 0;
 128         uint32_t __pos = 0;
 129         uint8_t *__data = NULL;
 130         int __ret = 0;
 131
 132         LEN(8); /* header */
 133         LEN(8); /* texture */
 134         LEN(4); /* face */
 135         LEN(4); /* level */
 136         LEN(4); /* zslice */
 137         LEN(4); /* x */
 138         LEN(4); /* y */
 139         LEN(4); /* w */
 140         LEN(4); /* h */
 141         LEN_ARRAY(1, data); /* data */
 142         LEN(4); /* stride */
 143
 144         /* align */
 145         PAD(__len, 8);
 146
 147         __data = (uint8_t*)MALLOC(__len);
 148         if (!__data)
 149                 return -ENOMEM;
 150
 151         WRITE(4, int32_t, ((int32_t)RBUG_OP_TEXTURE_WRITE));
 152         WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
 153         WRITE(8, rbug_texture_t, texture); /* texture */
 154         WRITE(4, uint32_t, face); /* face */
 155         WRITE(4, uint32_t, level); /* level */
 156         WRITE(4, uint32_t, zslice); /* zslice */
 157         WRITE(4, uint32_t, x); /* x */
 158         WRITE(4, uint32_t, y); /* y */
 159         WRITE(4, uint32_t, w); /* w */
 160         WRITE(4, uint32_t, h); /* h */
 161         WRITE_ARRAY(1, uint8_t, data); /* data */
 162         WRITE(4, uint32_t, stride); /* stride */
 163
 164         /* final pad */
 165         PAD(__pos, 8);
 166
 167         if (__pos != __len) {
 168                 __ret = -EINVAL;
 169         } else {
 170                 rbug_connection_send_start(__con, RBUG_OP_TEXTURE_WRITE, __len);
 171                 rbug_connection_write(__con, __data, __len);
 172                 __ret = rbug_connection_send_finish(__con, __serial);
 173         }
 174
 175         FREE(__data);
 176         return __ret;
 177 }
 178
 179 int rbug_send_texture_read(struct rbug_connection *__con,
 180                            rbug_texture_t texture,
 181                            uint32_t face,
 182                            uint32_t level,
 183                            uint32_t zslice,
 184                            uint32_t x,
 185                            uint32_t y,
 186                            uint32_t w,
 187                            uint32_t h,
 188                            uint32_t *__serial)
 189 {
 190         uint32_t __len = 0;
 191         uint32_t __pos = 0;
 192         uint8_t *__data = NULL;
 193         int __ret = 0;
 194
 195         LEN(8); /* header */
 196         LEN(8); /* texture */
 197         LEN(4); /* face */
 198         LEN(4); /* level */
 199         LEN(4); /* zslice */
 200         LEN(4); /* x */
 201         LEN(4); /* y */
 202         LEN(4); /* w */
 203         LEN(4); /* h */
 204
 205         /* align */
 206         PAD(__len, 8);
 207
 208         __data = (uint8_t*)MALLOC(__len);
 209         if (!__data)
 210                 return -ENOMEM;
 211
 212         WRITE(4, int32_t, ((int32_t)RBUG_OP_TEXTURE_READ));
 213         WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
 214         WRITE(8, rbug_texture_t, texture); /* texture */
 215         WRITE(4, uint32_t, face); /* face */
 216         WRITE(4, uint32_t, level); /* level */
 217         WRITE(4, uint32_t, zslice); /* zslice */
 218         WRITE(4, uint32_t, x); /* x */
 219         WRITE(4, uint32_t, y); /* y */
 220         WRITE(4, uint32_t, w); /* w */
 221         WRITE(4, uint32_t, h); /* h */
 222
 223         /* final pad */
 224         PAD(__pos, 8);
 225
 226         if (__pos != __len) {
 227                 __ret = -EINVAL;
 228         } else {
 229                 rbug_connection_send_start(__con, RBUG_OP_TEXTURE_READ, __len);
 230                 rbug_connection_write(__con, __data, __len);
 231                 __ret = rbug_connection_send_finish(__con, __serial);
 232         }
 233
 234         FREE(__data);
 235         return __ret;
 236 }
 237
 238 int rbug_send_texture_list_reply(struct rbug_connection *__con,
 239                                  uint32_t serial,
 240                                  rbug_texture_t *textures,
 241                                  uint32_t textures_len,
 242                                  uint32_t *__serial)
 243 {
 244         uint32_t __len = 0;
 245         uint32_t __pos = 0;
 246         uint8_t *__data = NULL;
 247         int __ret = 0;
 248
 249         LEN(8); /* header */
 250         LEN(4); /* serial */
 251         LEN_ARRAY(8, textures); /* textures */
 252
 253         /* align */
 254         PAD(__len, 8);
 255
 256         __data = (uint8_t*)MALLOC(__len);
 257         if (!__data)
 258                 return -ENOMEM;
 259
 260         WRITE(4, int32_t, ((int32_t)RBUG_OP_TEXTURE_LIST_REPLY));
 261         WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
 262         WRITE(4, uint32_t, serial); /* serial */
 263         WRITE_ARRAY(8, rbug_texture_t, textures); /* textures */
 264
 265         /* final pad */
 266         PAD(__pos, 8);
 267
 268         if (__pos != __len) {
 269                 __ret = -EINVAL;
 270         } else {
 271                 rbug_connection_send_start(__con, RBUG_OP_TEXTURE_LIST_REPLY, __len);
 272                 rbug_connection_write(__con, __data, __len);
 273                 __ret = rbug_connection_send_finish(__con, __serial);
 274         }
 275
 276         FREE(__data);
 277         return __ret;
 278 }
 279
 280 int rbug_send_texture_info_reply(struct rbug_connection *__con,
 281                                  uint32_t serial,
 282                                  uint32_t target,
 283                                  uint32_t format,
 284                                  uint32_t *width,
 285                                  uint32_t width_len,
 286                                  uint32_t *height,
 287                                  uint32_t height_len,
 288                                  uint32_t *depth,
 289                                  uint32_t depth_len,
 290                                  uint32_t blockw,
 291                                  uint32_t blockh,
 292                                  uint32_t blocksize,
 293                                  uint32_t last_level,
 294                                  uint32_t nr_samples,
 295                                  uint32_t tex_usage,
 296                                  uint32_t *__serial)
 297 {
 298         uint32_t __len = 0;
 299         uint32_t __pos = 0;
 300         uint8_t *__data = NULL;
 301         int __ret = 0;
 302
 303         LEN(8); /* header */
 304         LEN(4); /* serial */
 305         LEN(4); /* target */
 306         LEN(4); /* format */
 307         LEN_ARRAY(4, width); /* width */
 308         LEN_ARRAY(4, height); /* height */
 309         LEN_ARRAY(4, depth); /* depth */
 310         LEN(4); /* blockw */
 311         LEN(4); /* blockh */
 312         LEN(4); /* blocksize */
 313         LEN(4); /* last_level */
 314         LEN(4); /* nr_samples */
 315         LEN(4); /* tex_usage */
 316
 317         /* align */
 318         PAD(__len, 8);
 319
 320         __data = (uint8_t*)MALLOC(__len);
 321         if (!__data)
 322                 return -ENOMEM;
 323
 324         WRITE(4, int32_t, ((int32_t)RBUG_OP_TEXTURE_INFO_REPLY));
 325         WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
 326         WRITE(4, uint32_t, serial); /* serial */
 327         WRITE(4, uint32_t, target); /* target */
 328         WRITE(4, uint32_t, format); /* format */
 329         WRITE_ARRAY(4, uint32_t, width); /* width */
 330         WRITE_ARRAY(4, uint32_t, height); /* height */
 331         WRITE_ARRAY(4, uint32_t, depth); /* depth */
 332         WRITE(4, uint32_t, blockw); /* blockw */
 333         WRITE(4, uint32_t, blockh); /* blockh */
 334         WRITE(4, uint32_t, blocksize); /* blocksize */
 335         WRITE(4, uint32_t, last_level); /* last_level */
 336         WRITE(4, uint32_t, nr_samples); /* nr_samples */
 337         WRITE(4, uint32_t, tex_usage); /* tex_usage */
 338
 339         /* final pad */
 340         PAD(__pos, 8);
 341
 342         if (__pos != __len) {
 343                 __ret = -EINVAL;
 344         } else {
 345                 rbug_connection_send_start(__con, RBUG_OP_TEXTURE_INFO_REPLY, __len);
 346                 rbug_connection_write(__con, __data, __len);
 347                 __ret = rbug_connection_send_finish(__con, __serial);
 348         }
 349
 350         FREE(__data);
 351         return __ret;
 352 }
 353
 354 int rbug_send_texture_read_reply(struct rbug_connection *__con,
 355                                  uint32_t serial,
 356                                  uint32_t format,
 357                                  uint32_t blockw,
 358                                  uint32_t blockh,
 359                                  uint32_t blocksize,
 360                                  uint8_t *data,
 361                                  uint32_t data_len,
 362                                  uint32_t stride,
 363                                  uint32_t *__serial)
 364 {
 365         uint32_t __len = 0;
 366         uint32_t __pos = 0;
 367         uint8_t *__data = NULL;
 368         int __ret = 0;
 369
 370         LEN(8); /* header */
 371         LEN(4); /* serial */
 372         LEN(4); /* format */
 373         LEN(4); /* blockw */
 374         LEN(4); /* blockh */
 375         LEN(4); /* blocksize */
 376         LEN_ARRAY(1, data); /* data */
 377         LEN(4); /* stride */
 378
 379         /* align */
 380         PAD(__len, 8);
 381
 382         __data = (uint8_t*)MALLOC(__len);
 383         if (!__data)
 384                 return -ENOMEM;
 385
 386         WRITE(4, int32_t, ((int32_t)RBUG_OP_TEXTURE_READ_REPLY));
 387         WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
 388         WRITE(4, uint32_t, serial); /* serial */
 389         WRITE(4, uint32_t, format); /* format */
 390         WRITE(4, uint32_t, blockw); /* blockw */
 391         WRITE(4, uint32_t, blockh); /* blockh */
 392         WRITE(4, uint32_t, blocksize); /* blocksize */
 393         WRITE_ARRAY(1, uint8_t, data); /* data */
 394         WRITE(4, uint32_t, stride); /* stride */
 395
 396         /* final pad */
 397         PAD(__pos, 8);
 398
 399         if (__pos != __len) {
 400                 __ret = -EINVAL;
 401         } else {
 402                 rbug_connection_send_start(__con, RBUG_OP_TEXTURE_READ_REPLY, __len);
 403                 rbug_connection_write(__con, __data, __len);
 404                 __ret = rbug_connection_send_finish(__con, __serial);
 405         }
 406
 407         FREE(__data);
 408         return __ret;
 409 }
 410
 411 struct rbug_proto_texture_list * rbug_demarshal_texture_list(struct rbug_proto_header *header)
 412 {
 413         struct rbug_proto_texture_list *ret;
 414
 415         if (!header)
 416                 return NULL;
 417         if (header->opcode != (int32_t)RBUG_OP_TEXTURE_LIST)
 418                 return NULL;
 419
 420         ret = MALLOC(sizeof(*ret));
 421         if (!ret)
 422                 return NULL;
 423
 424         ret->header.__message = header;
 425         ret->header.opcode = header->opcode;
 426
 427         return ret;
 428 }
 429
 430 struct rbug_proto_texture_info * rbug_demarshal_texture_info(struct rbug_proto_header *header)
 431 {
 432         uint32_t len = 0;
 433         uint32_t pos = 0;
 434         uint8_t *data =  NULL;
 435         struct rbug_proto_texture_info *ret;
 436
 437         if (!header)
 438                 return NULL;
 439         if (header->opcode != (int32_t)RBUG_OP_TEXTURE_INFO)
 440                 return NULL;
 441
 442         pos = 0;
 443         len = header->length * 4;
 444         data = (uint8_t*)&header[1];
 445         ret = MALLOC(sizeof(*ret));
 446         if (!ret)
 447                 return NULL;
 448
 449         ret->header.__message = header;
 450         ret->header.opcode = header->opcode;
 451
 452         READ(8, rbug_texture_t, texture); /* texture */
 453
 454         return ret;
 455 }
 456
 457 struct rbug_proto_texture_write * rbug_demarshal_texture_write(struct rbug_proto_header *header)
 458 {
 459         uint32_t len = 0;
 460         uint32_t pos = 0;
 461         uint8_t *data =  NULL;
 462         struct rbug_proto_texture_write *ret;
 463
 464         if (!header)
 465                 return NULL;
 466         if (header->opcode != (int32_t)RBUG_OP_TEXTURE_WRITE)
 467                 return NULL;
 468
 469         pos = 0;
 470         len = header->length * 4;
 471         data = (uint8_t*)&header[1];
 472         ret = MALLOC(sizeof(*ret));
 473         if (!ret)
 474                 return NULL;
 475
 476         ret->header.__message = header;
 477         ret->header.opcode = header->opcode;
 478
 479         READ(8, rbug_texture_t, texture); /* texture */
 480         READ(4, uint32_t, face); /* face */
 481         READ(4, uint32_t, level); /* level */
 482         READ(4, uint32_t, zslice); /* zslice */
 483         READ(4, uint32_t, x); /* x */
 484         READ(4, uint32_t, y); /* y */
 485         READ(4, uint32_t, w); /* w */
 486         READ(4, uint32_t, h); /* h */
 487         READ_ARRAY(1, uint8_t, data); /* data */
 488         READ(4, uint32_t, stride); /* stride */
 489
 490         return ret;
 491 }
 492
 493 struct rbug_proto_texture_read * rbug_demarshal_texture_read(struct rbug_proto_header *header)
 494 {
 495         uint32_t len = 0;
 496         uint32_t pos = 0;
 497         uint8_t *data =  NULL;
 498         struct rbug_proto_texture_read *ret;
 499
 500         if (!header)
 501                 return NULL;
 502         if (header->opcode != (int32_t)RBUG_OP_TEXTURE_READ)
 503                 return NULL;
 504
 505         pos = 0;
 506         len = header->length * 4;
 507         data = (uint8_t*)&header[1];
 508         ret = MALLOC(sizeof(*ret));
 509         if (!ret)
 510                 return NULL;
 511
 512         ret->header.__message = header;
 513         ret->header.opcode = header->opcode;
 514
 515         READ(8, rbug_texture_t, texture); /* texture */
 516         READ(4, uint32_t, face); /* face */
 517         READ(4, uint32_t, level); /* level */
 518         READ(4, uint32_t, zslice); /* zslice */
 519         READ(4, uint32_t, x); /* x */
 520         READ(4, uint32_t, y); /* y */
 521         READ(4, uint32_t, w); /* w */
 522         READ(4, uint32_t, h); /* h */
 523
 524         return ret;
 525 }
 526
 527 struct rbug_proto_texture_list_reply * rbug_demarshal_texture_list_reply(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_texture_list_reply *ret;
 533
 534         if (!header)
 535                 return NULL;
 536         if (header->opcode != (int32_t)RBUG_OP_TEXTURE_LIST_REPLY)
 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(4, uint32_t, serial); /* serial */
 550         READ_ARRAY(8, rbug_texture_t, textures); /* textures */
 551
 552         return ret;
 553 }
 554
 555 struct rbug_proto_texture_info_reply * rbug_demarshal_texture_info_reply(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_texture_info_reply *ret;
 561
 562         if (!header)
 563                 return NULL;
 564         if (header->opcode != (int32_t)RBUG_OP_TEXTURE_INFO_REPLY)
 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(4, uint32_t, serial); /* serial */
 578         READ(4, uint32_t, target); /* target */
 579         READ(4, uint32_t, format); /* format */
 580         READ_ARRAY(4, uint32_t, width); /* width */
 581         READ_ARRAY(4, uint32_t, height); /* height */
 582         READ_ARRAY(4, uint32_t, depth); /* depth */
 583         READ(4, uint32_t, blockw); /* blockw */
 584         READ(4, uint32_t, blockh); /* blockh */
 585         READ(4, uint32_t, blocksize); /* blocksize */
 586         READ(4, uint32_t, last_level); /* last_level */
 587         READ(4, uint32_t, nr_samples); /* nr_samples */
 588         READ(4, uint32_t, tex_usage); /* tex_usage */
 589
 590         return ret;
 591 }
 592
 593 struct rbug_proto_texture_read_reply * rbug_demarshal_texture_read_reply(struct rbug_proto_header *header)
 594 {
 595         uint32_t len = 0;
 596         uint32_t pos = 0;
 597         uint8_t *data =  NULL;
 598         struct rbug_proto_texture_read_reply *ret;
 599
 600         if (!header)
 601                 return NULL;
 602         if (header->opcode != (int32_t)RBUG_OP_TEXTURE_READ_REPLY)
 603                 return NULL;
 604
 605         pos = 0;
 606         len = header->length * 4;
 607         data = (uint8_t*)&header[1];
 608         ret = MALLOC(sizeof(*ret));
 609         if (!ret)
 610                 return NULL;
 611
 612         ret->header.__message = header;
 613         ret->header.opcode = header->opcode;
 614
 615         READ(4, uint32_t, serial); /* serial */
 616         READ(4, uint32_t, format); /* format */
 617         READ(4, uint32_t, blockw); /* blockw */
 618         READ(4, uint32_t, blockh); /* blockh */
 619         READ(4, uint32_t, blocksize); /* blocksize */
 620         READ_ARRAY(1, uint8_t, data); /* data */
 621         READ(4, uint32_t, stride); /* stride */
 622
 623         return ret;
 624 }