• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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_texture.h"
39 
rbug_send_texture_list(struct rbug_connection * __con,uint32_t * __serial)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 
rbug_send_texture_info(struct rbug_connection * __con,rbug_texture_t texture,uint32_t * __serial)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 
rbug_send_texture_write(struct rbug_connection * __con,rbug_texture_t texture,uint32_t face,uint32_t level,uint32_t zslice,uint32_t x,uint32_t y,uint32_t w,uint32_t h,uint8_t * data,uint32_t data_len,uint32_t stride,uint32_t * __serial)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 
rbug_send_texture_read(struct rbug_connection * __con,rbug_texture_t texture,uint32_t face,uint32_t level,uint32_t zslice,uint32_t x,uint32_t y,uint32_t w,uint32_t h,uint32_t * __serial)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 
rbug_send_texture_list_reply(struct rbug_connection * __con,uint32_t serial,rbug_texture_t * textures,uint32_t textures_len,uint32_t * __serial)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 
rbug_send_texture_info_reply(struct rbug_connection * __con,uint32_t serial,uint32_t target,uint32_t format,uint32_t * width,uint32_t width_len,uint16_t * height,uint32_t height_len,uint16_t * depth,uint32_t depth_len,uint32_t blockw,uint32_t blockh,uint32_t blocksize,uint32_t last_level,uint32_t nr_samples,uint32_t tex_usage,uint32_t * __serial)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                                  uint16_t *height,
287                                  uint32_t height_len,
288                                  uint16_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 
rbug_send_texture_read_reply(struct rbug_connection * __con,uint32_t serial,uint32_t format,uint32_t blockw,uint32_t blockh,uint32_t blocksize,uint8_t * data,uint32_t data_len,uint32_t stride,uint32_t * __serial)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 
rbug_demarshal_texture_list(struct rbug_proto_header * header)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 
rbug_demarshal_texture_info(struct rbug_proto_header * header)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 
rbug_demarshal_texture_write(struct rbug_proto_header * header)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 
rbug_demarshal_texture_read(struct rbug_proto_header * header)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 
rbug_demarshal_texture_list_reply(struct rbug_proto_header * header)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 
rbug_demarshal_texture_info_reply(struct rbug_proto_header * header)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 
rbug_demarshal_texture_read_reply(struct rbug_proto_header * header)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 }
625