1 // This file was auto-generated by VTS compiler.
2
3 #include <iostream>
4
5 #include "FuncFuzzerUtils.h"
6 #include <android/hardware/renderscript/1.0/IContext.h>
7
8 using std::cerr;
9 using std::endl;
10 using std::string;
11
12 using namespace ::android::hardware::renderscript::V1_0;
13 using namespace ::android::hardware;
14
15 namespace android {
16 namespace vts {
17
18 static string target_func;
19
LLVMFuzzerInitialize(int * argc,char *** argv)20 extern "C" int LLVMFuzzerInitialize(int *argc, char ***argv) {
21 FuncFuzzerParams params{ExtractFuncFuzzerParams(*argc, *argv)};
22 target_func = params.target_func_;
23 return 0;
24 }
25
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)26 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
27 static ::android::sp<IContext> renderscript = IContext::getService(true);
28 if (renderscript == nullptr) {
29 cerr << "IContext::getService() failed" << endl;
30 exit(1);
31 }
32
33 if (target_func == "allocationAdapterCreate") {
34 size_t type_size0 = sizeof(uint64_t);
35 if (size < type_size0) { return 0; }
36 size -= type_size0;
37 uint64_t arg0;
38 memcpy(&arg0, data, type_size0);
39 data += type_size0;
40
41 size_t type_size1 = sizeof(uint64_t);
42 if (size < type_size1) { return 0; }
43 size -= type_size1;
44 uint64_t arg1;
45 memcpy(&arg1, data, type_size1);
46 data += type_size1;
47
48 renderscript->allocationAdapterCreate(arg0, arg1);
49 return 0;
50 } else if (target_func == "allocationAdapterOffset") {
51 size_t type_size0 = sizeof(uint64_t);
52 if (size < type_size0) { return 0; }
53 size -= type_size0;
54 uint64_t arg0;
55 memcpy(&arg0, data, type_size0);
56 data += type_size0;
57
58 size_t type_size1 = sizeof(::android::hardware::hidl_vec<uint32_t>);
59 if (size < type_size1) { return 0; }
60 size -= type_size1;
61 ::android::hardware::hidl_vec<uint32_t> arg1;
62 memcpy(&arg1, data, type_size1);
63 data += type_size1;
64
65 renderscript->allocationAdapterOffset(arg0, arg1);
66 return 0;
67 } else if (target_func == "allocationGetType") {
68 size_t type_size0 = sizeof(uint64_t);
69 if (size < type_size0) { return 0; }
70 size -= type_size0;
71 uint64_t arg0;
72 memcpy(&arg0, data, type_size0);
73 data += type_size0;
74
75 renderscript->allocationGetType(arg0);
76 return 0;
77 } else if (target_func == "allocationCreateTyped") {
78 size_t type_size0 = sizeof(uint64_t);
79 if (size < type_size0) { return 0; }
80 size -= type_size0;
81 uint64_t arg0;
82 memcpy(&arg0, data, type_size0);
83 data += type_size0;
84
85 size_t type_size1 = sizeof(::android::hardware::renderscript::V1_0::AllocationMipmapControl);
86 if (size < type_size1) { return 0; }
87 size -= type_size1;
88 ::android::hardware::renderscript::V1_0::AllocationMipmapControl arg1;
89 memcpy(&arg1, data, type_size1);
90 data += type_size1;
91
92 size_t type_size2 = sizeof(int32_t);
93 if (size < type_size2) { return 0; }
94 size -= type_size2;
95 int32_t arg2;
96 memcpy(&arg2, data, type_size2);
97 data += type_size2;
98
99 size_t type_size3 = sizeof(void*);
100 if (size < type_size3) { return 0; }
101 size -= type_size3;
102 void* arg3;
103 memcpy(&arg3, data, type_size3);
104 data += type_size3;
105
106 renderscript->allocationCreateTyped(arg0, arg1, arg2, arg3);
107 return 0;
108 } else if (target_func == "allocationCreateFromBitmap") {
109 size_t type_size0 = sizeof(uint64_t);
110 if (size < type_size0) { return 0; }
111 size -= type_size0;
112 uint64_t arg0;
113 memcpy(&arg0, data, type_size0);
114 data += type_size0;
115
116 size_t type_size1 = sizeof(::android::hardware::renderscript::V1_0::AllocationMipmapControl);
117 if (size < type_size1) { return 0; }
118 size -= type_size1;
119 ::android::hardware::renderscript::V1_0::AllocationMipmapControl arg1;
120 memcpy(&arg1, data, type_size1);
121 data += type_size1;
122
123 size_t type_size2 = sizeof(::android::hardware::hidl_vec<uint8_t>);
124 if (size < type_size2) { return 0; }
125 size -= type_size2;
126 ::android::hardware::hidl_vec<uint8_t> arg2;
127 memcpy(&arg2, data, type_size2);
128 data += type_size2;
129
130 size_t type_size3 = sizeof(int32_t);
131 if (size < type_size3) { return 0; }
132 size -= type_size3;
133 int32_t arg3;
134 memcpy(&arg3, data, type_size3);
135 data += type_size3;
136
137 renderscript->allocationCreateFromBitmap(arg0, arg1, arg2, arg3);
138 return 0;
139 } else if (target_func == "allocationCubeCreateFromBitmap") {
140 size_t type_size0 = sizeof(uint64_t);
141 if (size < type_size0) { return 0; }
142 size -= type_size0;
143 uint64_t arg0;
144 memcpy(&arg0, data, type_size0);
145 data += type_size0;
146
147 size_t type_size1 = sizeof(::android::hardware::renderscript::V1_0::AllocationMipmapControl);
148 if (size < type_size1) { return 0; }
149 size -= type_size1;
150 ::android::hardware::renderscript::V1_0::AllocationMipmapControl arg1;
151 memcpy(&arg1, data, type_size1);
152 data += type_size1;
153
154 size_t type_size2 = sizeof(::android::hardware::hidl_vec<uint8_t>);
155 if (size < type_size2) { return 0; }
156 size -= type_size2;
157 ::android::hardware::hidl_vec<uint8_t> arg2;
158 memcpy(&arg2, data, type_size2);
159 data += type_size2;
160
161 size_t type_size3 = sizeof(int32_t);
162 if (size < type_size3) { return 0; }
163 size -= type_size3;
164 int32_t arg3;
165 memcpy(&arg3, data, type_size3);
166 data += type_size3;
167
168 renderscript->allocationCubeCreateFromBitmap(arg0, arg1, arg2, arg3);
169 return 0;
170 } else if (target_func == "allocationGetNativeWindow") {
171 size_t type_size0 = sizeof(uint64_t);
172 if (size < type_size0) { return 0; }
173 size -= type_size0;
174 uint64_t arg0;
175 memcpy(&arg0, data, type_size0);
176 data += type_size0;
177
178 renderscript->allocationGetNativeWindow(arg0);
179 return 0;
180 } else if (target_func == "allocationSetNativeWindow") {
181 size_t type_size0 = sizeof(uint64_t);
182 if (size < type_size0) { return 0; }
183 size -= type_size0;
184 uint64_t arg0;
185 memcpy(&arg0, data, type_size0);
186 data += type_size0;
187
188 size_t type_size1 = sizeof(uint64_t);
189 if (size < type_size1) { return 0; }
190 size -= type_size1;
191 uint64_t arg1;
192 memcpy(&arg1, data, type_size1);
193 data += type_size1;
194
195 renderscript->allocationSetNativeWindow(arg0, arg1);
196 return 0;
197 } else if (target_func == "allocationSetupBufferQueue") {
198 size_t type_size0 = sizeof(uint64_t);
199 if (size < type_size0) { return 0; }
200 size -= type_size0;
201 uint64_t arg0;
202 memcpy(&arg0, data, type_size0);
203 data += type_size0;
204
205 size_t type_size1 = sizeof(uint32_t);
206 if (size < type_size1) { return 0; }
207 size -= type_size1;
208 uint32_t arg1;
209 memcpy(&arg1, data, type_size1);
210 data += type_size1;
211
212 renderscript->allocationSetupBufferQueue(arg0, arg1);
213 return 0;
214 } else if (target_func == "allocationShareBufferQueue") {
215 size_t type_size0 = sizeof(uint64_t);
216 if (size < type_size0) { return 0; }
217 size -= type_size0;
218 uint64_t arg0;
219 memcpy(&arg0, data, type_size0);
220 data += type_size0;
221
222 size_t type_size1 = sizeof(uint64_t);
223 if (size < type_size1) { return 0; }
224 size -= type_size1;
225 uint64_t arg1;
226 memcpy(&arg1, data, type_size1);
227 data += type_size1;
228
229 renderscript->allocationShareBufferQueue(arg0, arg1);
230 return 0;
231 } else if (target_func == "allocationCopyToBitmap") {
232 size_t type_size0 = sizeof(uint64_t);
233 if (size < type_size0) { return 0; }
234 size -= type_size0;
235 uint64_t arg0;
236 memcpy(&arg0, data, type_size0);
237 data += type_size0;
238
239 size_t type_size1 = sizeof(void*);
240 if (size < type_size1) { return 0; }
241 size -= type_size1;
242 void* arg1;
243 memcpy(&arg1, data, type_size1);
244 data += type_size1;
245
246 size_t type_size2 = sizeof(uint64_t);
247 if (size < type_size2) { return 0; }
248 size -= type_size2;
249 uint64_t arg2;
250 memcpy(&arg2, data, type_size2);
251 data += type_size2;
252
253 renderscript->allocationCopyToBitmap(arg0, arg1, arg2);
254 return 0;
255 } else if (target_func == "allocation1DWrite") {
256 size_t type_size0 = sizeof(uint64_t);
257 if (size < type_size0) { return 0; }
258 size -= type_size0;
259 uint64_t arg0;
260 memcpy(&arg0, data, type_size0);
261 data += type_size0;
262
263 size_t type_size1 = sizeof(uint32_t);
264 if (size < type_size1) { return 0; }
265 size -= type_size1;
266 uint32_t arg1;
267 memcpy(&arg1, data, type_size1);
268 data += type_size1;
269
270 size_t type_size2 = sizeof(uint32_t);
271 if (size < type_size2) { return 0; }
272 size -= type_size2;
273 uint32_t arg2;
274 memcpy(&arg2, data, type_size2);
275 data += type_size2;
276
277 size_t type_size3 = sizeof(uint32_t);
278 if (size < type_size3) { return 0; }
279 size -= type_size3;
280 uint32_t arg3;
281 memcpy(&arg3, data, type_size3);
282 data += type_size3;
283
284 size_t type_size4 = sizeof(::android::hardware::hidl_vec<uint8_t>);
285 if (size < type_size4) { return 0; }
286 size -= type_size4;
287 ::android::hardware::hidl_vec<uint8_t> arg4;
288 memcpy(&arg4, data, type_size4);
289 data += type_size4;
290
291 renderscript->allocation1DWrite(arg0, arg1, arg2, arg3, arg4);
292 return 0;
293 } else if (target_func == "allocationElementWrite") {
294 size_t type_size0 = sizeof(uint64_t);
295 if (size < type_size0) { return 0; }
296 size -= type_size0;
297 uint64_t arg0;
298 memcpy(&arg0, data, type_size0);
299 data += type_size0;
300
301 size_t type_size1 = sizeof(uint32_t);
302 if (size < type_size1) { return 0; }
303 size -= type_size1;
304 uint32_t arg1;
305 memcpy(&arg1, data, type_size1);
306 data += type_size1;
307
308 size_t type_size2 = sizeof(uint32_t);
309 if (size < type_size2) { return 0; }
310 size -= type_size2;
311 uint32_t arg2;
312 memcpy(&arg2, data, type_size2);
313 data += type_size2;
314
315 size_t type_size3 = sizeof(uint32_t);
316 if (size < type_size3) { return 0; }
317 size -= type_size3;
318 uint32_t arg3;
319 memcpy(&arg3, data, type_size3);
320 data += type_size3;
321
322 size_t type_size4 = sizeof(uint32_t);
323 if (size < type_size4) { return 0; }
324 size -= type_size4;
325 uint32_t arg4;
326 memcpy(&arg4, data, type_size4);
327 data += type_size4;
328
329 size_t type_size5 = sizeof(::android::hardware::hidl_vec<uint8_t>);
330 if (size < type_size5) { return 0; }
331 size -= type_size5;
332 ::android::hardware::hidl_vec<uint8_t> arg5;
333 memcpy(&arg5, data, type_size5);
334 data += type_size5;
335
336 size_t type_size6 = sizeof(uint64_t);
337 if (size < type_size6) { return 0; }
338 size -= type_size6;
339 uint64_t arg6;
340 memcpy(&arg6, data, type_size6);
341 data += type_size6;
342
343 renderscript->allocationElementWrite(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
344 return 0;
345 } else if (target_func == "allocation2DWrite") {
346 size_t type_size0 = sizeof(uint64_t);
347 if (size < type_size0) { return 0; }
348 size -= type_size0;
349 uint64_t arg0;
350 memcpy(&arg0, data, type_size0);
351 data += type_size0;
352
353 size_t type_size1 = sizeof(uint32_t);
354 if (size < type_size1) { return 0; }
355 size -= type_size1;
356 uint32_t arg1;
357 memcpy(&arg1, data, type_size1);
358 data += type_size1;
359
360 size_t type_size2 = sizeof(uint32_t);
361 if (size < type_size2) { return 0; }
362 size -= type_size2;
363 uint32_t arg2;
364 memcpy(&arg2, data, type_size2);
365 data += type_size2;
366
367 size_t type_size3 = sizeof(uint32_t);
368 if (size < type_size3) { return 0; }
369 size -= type_size3;
370 uint32_t arg3;
371 memcpy(&arg3, data, type_size3);
372 data += type_size3;
373
374 size_t type_size4 = sizeof(::android::hardware::renderscript::V1_0::AllocationCubemapFace);
375 if (size < type_size4) { return 0; }
376 size -= type_size4;
377 ::android::hardware::renderscript::V1_0::AllocationCubemapFace arg4;
378 memcpy(&arg4, data, type_size4);
379 data += type_size4;
380
381 size_t type_size5 = sizeof(uint32_t);
382 if (size < type_size5) { return 0; }
383 size -= type_size5;
384 uint32_t arg5;
385 memcpy(&arg5, data, type_size5);
386 data += type_size5;
387
388 size_t type_size6 = sizeof(uint32_t);
389 if (size < type_size6) { return 0; }
390 size -= type_size6;
391 uint32_t arg6;
392 memcpy(&arg6, data, type_size6);
393 data += type_size6;
394
395 size_t type_size7 = sizeof(::android::hardware::hidl_vec<uint8_t>);
396 if (size < type_size7) { return 0; }
397 size -= type_size7;
398 ::android::hardware::hidl_vec<uint8_t> arg7;
399 memcpy(&arg7, data, type_size7);
400 data += type_size7;
401
402 size_t type_size8 = sizeof(uint64_t);
403 if (size < type_size8) { return 0; }
404 size -= type_size8;
405 uint64_t arg8;
406 memcpy(&arg8, data, type_size8);
407 data += type_size8;
408
409 renderscript->allocation2DWrite(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
410 return 0;
411 } else if (target_func == "allocation3DWrite") {
412 size_t type_size0 = sizeof(uint64_t);
413 if (size < type_size0) { return 0; }
414 size -= type_size0;
415 uint64_t arg0;
416 memcpy(&arg0, data, type_size0);
417 data += type_size0;
418
419 size_t type_size1 = sizeof(uint32_t);
420 if (size < type_size1) { return 0; }
421 size -= type_size1;
422 uint32_t arg1;
423 memcpy(&arg1, data, type_size1);
424 data += type_size1;
425
426 size_t type_size2 = sizeof(uint32_t);
427 if (size < type_size2) { return 0; }
428 size -= type_size2;
429 uint32_t arg2;
430 memcpy(&arg2, data, type_size2);
431 data += type_size2;
432
433 size_t type_size3 = sizeof(uint32_t);
434 if (size < type_size3) { return 0; }
435 size -= type_size3;
436 uint32_t arg3;
437 memcpy(&arg3, data, type_size3);
438 data += type_size3;
439
440 size_t type_size4 = sizeof(uint32_t);
441 if (size < type_size4) { return 0; }
442 size -= type_size4;
443 uint32_t arg4;
444 memcpy(&arg4, data, type_size4);
445 data += type_size4;
446
447 size_t type_size5 = sizeof(uint32_t);
448 if (size < type_size5) { return 0; }
449 size -= type_size5;
450 uint32_t arg5;
451 memcpy(&arg5, data, type_size5);
452 data += type_size5;
453
454 size_t type_size6 = sizeof(uint32_t);
455 if (size < type_size6) { return 0; }
456 size -= type_size6;
457 uint32_t arg6;
458 memcpy(&arg6, data, type_size6);
459 data += type_size6;
460
461 size_t type_size7 = sizeof(uint32_t);
462 if (size < type_size7) { return 0; }
463 size -= type_size7;
464 uint32_t arg7;
465 memcpy(&arg7, data, type_size7);
466 data += type_size7;
467
468 size_t type_size8 = sizeof(::android::hardware::hidl_vec<uint8_t>);
469 if (size < type_size8) { return 0; }
470 size -= type_size8;
471 ::android::hardware::hidl_vec<uint8_t> arg8;
472 memcpy(&arg8, data, type_size8);
473 data += type_size8;
474
475 size_t type_size9 = sizeof(uint64_t);
476 if (size < type_size9) { return 0; }
477 size -= type_size9;
478 uint64_t arg9;
479 memcpy(&arg9, data, type_size9);
480 data += type_size9;
481
482 renderscript->allocation3DWrite(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
483 return 0;
484 } else if (target_func == "allocationGenerateMipmaps") {
485 size_t type_size0 = sizeof(uint64_t);
486 if (size < type_size0) { return 0; }
487 size -= type_size0;
488 uint64_t arg0;
489 memcpy(&arg0, data, type_size0);
490 data += type_size0;
491
492 renderscript->allocationGenerateMipmaps(arg0);
493 return 0;
494 } else if (target_func == "allocationRead") {
495 size_t type_size0 = sizeof(uint64_t);
496 if (size < type_size0) { return 0; }
497 size -= type_size0;
498 uint64_t arg0;
499 memcpy(&arg0, data, type_size0);
500 data += type_size0;
501
502 size_t type_size1 = sizeof(void*);
503 if (size < type_size1) { return 0; }
504 size -= type_size1;
505 void* arg1;
506 memcpy(&arg1, data, type_size1);
507 data += type_size1;
508
509 size_t type_size2 = sizeof(uint64_t);
510 if (size < type_size2) { return 0; }
511 size -= type_size2;
512 uint64_t arg2;
513 memcpy(&arg2, data, type_size2);
514 data += type_size2;
515
516 renderscript->allocationRead(arg0, arg1, arg2);
517 return 0;
518 } else if (target_func == "allocation1DRead") {
519 size_t type_size0 = sizeof(uint64_t);
520 if (size < type_size0) { return 0; }
521 size -= type_size0;
522 uint64_t arg0;
523 memcpy(&arg0, data, type_size0);
524 data += type_size0;
525
526 size_t type_size1 = sizeof(uint32_t);
527 if (size < type_size1) { return 0; }
528 size -= type_size1;
529 uint32_t arg1;
530 memcpy(&arg1, data, type_size1);
531 data += type_size1;
532
533 size_t type_size2 = sizeof(uint32_t);
534 if (size < type_size2) { return 0; }
535 size -= type_size2;
536 uint32_t arg2;
537 memcpy(&arg2, data, type_size2);
538 data += type_size2;
539
540 size_t type_size3 = sizeof(uint32_t);
541 if (size < type_size3) { return 0; }
542 size -= type_size3;
543 uint32_t arg3;
544 memcpy(&arg3, data, type_size3);
545 data += type_size3;
546
547 size_t type_size4 = sizeof(void*);
548 if (size < type_size4) { return 0; }
549 size -= type_size4;
550 void* arg4;
551 memcpy(&arg4, data, type_size4);
552 data += type_size4;
553
554 size_t type_size5 = sizeof(uint64_t);
555 if (size < type_size5) { return 0; }
556 size -= type_size5;
557 uint64_t arg5;
558 memcpy(&arg5, data, type_size5);
559 data += type_size5;
560
561 renderscript->allocation1DRead(arg0, arg1, arg2, arg3, arg4, arg5);
562 return 0;
563 } else if (target_func == "allocationElementRead") {
564 size_t type_size0 = sizeof(uint64_t);
565 if (size < type_size0) { return 0; }
566 size -= type_size0;
567 uint64_t arg0;
568 memcpy(&arg0, data, type_size0);
569 data += type_size0;
570
571 size_t type_size1 = sizeof(uint32_t);
572 if (size < type_size1) { return 0; }
573 size -= type_size1;
574 uint32_t arg1;
575 memcpy(&arg1, data, type_size1);
576 data += type_size1;
577
578 size_t type_size2 = sizeof(uint32_t);
579 if (size < type_size2) { return 0; }
580 size -= type_size2;
581 uint32_t arg2;
582 memcpy(&arg2, data, type_size2);
583 data += type_size2;
584
585 size_t type_size3 = sizeof(uint32_t);
586 if (size < type_size3) { return 0; }
587 size -= type_size3;
588 uint32_t arg3;
589 memcpy(&arg3, data, type_size3);
590 data += type_size3;
591
592 size_t type_size4 = sizeof(uint32_t);
593 if (size < type_size4) { return 0; }
594 size -= type_size4;
595 uint32_t arg4;
596 memcpy(&arg4, data, type_size4);
597 data += type_size4;
598
599 size_t type_size5 = sizeof(void*);
600 if (size < type_size5) { return 0; }
601 size -= type_size5;
602 void* arg5;
603 memcpy(&arg5, data, type_size5);
604 data += type_size5;
605
606 size_t type_size6 = sizeof(uint64_t);
607 if (size < type_size6) { return 0; }
608 size -= type_size6;
609 uint64_t arg6;
610 memcpy(&arg6, data, type_size6);
611 data += type_size6;
612
613 size_t type_size7 = sizeof(uint64_t);
614 if (size < type_size7) { return 0; }
615 size -= type_size7;
616 uint64_t arg7;
617 memcpy(&arg7, data, type_size7);
618 data += type_size7;
619
620 renderscript->allocationElementRead(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
621 return 0;
622 } else if (target_func == "allocation2DRead") {
623 size_t type_size0 = sizeof(uint64_t);
624 if (size < type_size0) { return 0; }
625 size -= type_size0;
626 uint64_t arg0;
627 memcpy(&arg0, data, type_size0);
628 data += type_size0;
629
630 size_t type_size1 = sizeof(uint32_t);
631 if (size < type_size1) { return 0; }
632 size -= type_size1;
633 uint32_t arg1;
634 memcpy(&arg1, data, type_size1);
635 data += type_size1;
636
637 size_t type_size2 = sizeof(uint32_t);
638 if (size < type_size2) { return 0; }
639 size -= type_size2;
640 uint32_t arg2;
641 memcpy(&arg2, data, type_size2);
642 data += type_size2;
643
644 size_t type_size3 = sizeof(uint32_t);
645 if (size < type_size3) { return 0; }
646 size -= type_size3;
647 uint32_t arg3;
648 memcpy(&arg3, data, type_size3);
649 data += type_size3;
650
651 size_t type_size4 = sizeof(::android::hardware::renderscript::V1_0::AllocationCubemapFace);
652 if (size < type_size4) { return 0; }
653 size -= type_size4;
654 ::android::hardware::renderscript::V1_0::AllocationCubemapFace arg4;
655 memcpy(&arg4, data, type_size4);
656 data += type_size4;
657
658 size_t type_size5 = sizeof(uint32_t);
659 if (size < type_size5) { return 0; }
660 size -= type_size5;
661 uint32_t arg5;
662 memcpy(&arg5, data, type_size5);
663 data += type_size5;
664
665 size_t type_size6 = sizeof(uint32_t);
666 if (size < type_size6) { return 0; }
667 size -= type_size6;
668 uint32_t arg6;
669 memcpy(&arg6, data, type_size6);
670 data += type_size6;
671
672 size_t type_size7 = sizeof(void*);
673 if (size < type_size7) { return 0; }
674 size -= type_size7;
675 void* arg7;
676 memcpy(&arg7, data, type_size7);
677 data += type_size7;
678
679 size_t type_size8 = sizeof(uint64_t);
680 if (size < type_size8) { return 0; }
681 size -= type_size8;
682 uint64_t arg8;
683 memcpy(&arg8, data, type_size8);
684 data += type_size8;
685
686 size_t type_size9 = sizeof(uint64_t);
687 if (size < type_size9) { return 0; }
688 size -= type_size9;
689 uint64_t arg9;
690 memcpy(&arg9, data, type_size9);
691 data += type_size9;
692
693 renderscript->allocation2DRead(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
694 return 0;
695 } else if (target_func == "allocation3DRead") {
696 size_t type_size0 = sizeof(uint64_t);
697 if (size < type_size0) { return 0; }
698 size -= type_size0;
699 uint64_t arg0;
700 memcpy(&arg0, data, type_size0);
701 data += type_size0;
702
703 size_t type_size1 = sizeof(uint32_t);
704 if (size < type_size1) { return 0; }
705 size -= type_size1;
706 uint32_t arg1;
707 memcpy(&arg1, data, type_size1);
708 data += type_size1;
709
710 size_t type_size2 = sizeof(uint32_t);
711 if (size < type_size2) { return 0; }
712 size -= type_size2;
713 uint32_t arg2;
714 memcpy(&arg2, data, type_size2);
715 data += type_size2;
716
717 size_t type_size3 = sizeof(uint32_t);
718 if (size < type_size3) { return 0; }
719 size -= type_size3;
720 uint32_t arg3;
721 memcpy(&arg3, data, type_size3);
722 data += type_size3;
723
724 size_t type_size4 = sizeof(uint32_t);
725 if (size < type_size4) { return 0; }
726 size -= type_size4;
727 uint32_t arg4;
728 memcpy(&arg4, data, type_size4);
729 data += type_size4;
730
731 size_t type_size5 = sizeof(uint32_t);
732 if (size < type_size5) { return 0; }
733 size -= type_size5;
734 uint32_t arg5;
735 memcpy(&arg5, data, type_size5);
736 data += type_size5;
737
738 size_t type_size6 = sizeof(uint32_t);
739 if (size < type_size6) { return 0; }
740 size -= type_size6;
741 uint32_t arg6;
742 memcpy(&arg6, data, type_size6);
743 data += type_size6;
744
745 size_t type_size7 = sizeof(uint32_t);
746 if (size < type_size7) { return 0; }
747 size -= type_size7;
748 uint32_t arg7;
749 memcpy(&arg7, data, type_size7);
750 data += type_size7;
751
752 size_t type_size8 = sizeof(void*);
753 if (size < type_size8) { return 0; }
754 size -= type_size8;
755 void* arg8;
756 memcpy(&arg8, data, type_size8);
757 data += type_size8;
758
759 size_t type_size9 = sizeof(uint64_t);
760 if (size < type_size9) { return 0; }
761 size -= type_size9;
762 uint64_t arg9;
763 memcpy(&arg9, data, type_size9);
764 data += type_size9;
765
766 size_t type_size10 = sizeof(uint64_t);
767 if (size < type_size10) { return 0; }
768 size -= type_size10;
769 uint64_t arg10;
770 memcpy(&arg10, data, type_size10);
771 data += type_size10;
772
773 renderscript->allocation3DRead(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
774 return 0;
775 } else if (target_func == "allocationSyncAll") {
776 size_t type_size0 = sizeof(uint64_t);
777 if (size < type_size0) { return 0; }
778 size -= type_size0;
779 uint64_t arg0;
780 memcpy(&arg0, data, type_size0);
781 data += type_size0;
782
783 size_t type_size1 = sizeof(::android::hardware::renderscript::V1_0::AllocationUsageType);
784 if (size < type_size1) { return 0; }
785 size -= type_size1;
786 ::android::hardware::renderscript::V1_0::AllocationUsageType arg1;
787 memcpy(&arg1, data, type_size1);
788 data += type_size1;
789
790 renderscript->allocationSyncAll(arg0, arg1);
791 return 0;
792 } else if (target_func == "allocationResize1D") {
793 size_t type_size0 = sizeof(uint64_t);
794 if (size < type_size0) { return 0; }
795 size -= type_size0;
796 uint64_t arg0;
797 memcpy(&arg0, data, type_size0);
798 data += type_size0;
799
800 size_t type_size1 = sizeof(uint32_t);
801 if (size < type_size1) { return 0; }
802 size -= type_size1;
803 uint32_t arg1;
804 memcpy(&arg1, data, type_size1);
805 data += type_size1;
806
807 renderscript->allocationResize1D(arg0, arg1);
808 return 0;
809 } else if (target_func == "allocationCopy2DRange") {
810 size_t type_size0 = sizeof(uint64_t);
811 if (size < type_size0) { return 0; }
812 size -= type_size0;
813 uint64_t arg0;
814 memcpy(&arg0, data, type_size0);
815 data += type_size0;
816
817 size_t type_size1 = sizeof(uint32_t);
818 if (size < type_size1) { return 0; }
819 size -= type_size1;
820 uint32_t arg1;
821 memcpy(&arg1, data, type_size1);
822 data += type_size1;
823
824 size_t type_size2 = sizeof(uint32_t);
825 if (size < type_size2) { return 0; }
826 size -= type_size2;
827 uint32_t arg2;
828 memcpy(&arg2, data, type_size2);
829 data += type_size2;
830
831 size_t type_size3 = sizeof(uint32_t);
832 if (size < type_size3) { return 0; }
833 size -= type_size3;
834 uint32_t arg3;
835 memcpy(&arg3, data, type_size3);
836 data += type_size3;
837
838 size_t type_size4 = sizeof(::android::hardware::renderscript::V1_0::AllocationCubemapFace);
839 if (size < type_size4) { return 0; }
840 size -= type_size4;
841 ::android::hardware::renderscript::V1_0::AllocationCubemapFace arg4;
842 memcpy(&arg4, data, type_size4);
843 data += type_size4;
844
845 size_t type_size5 = sizeof(uint32_t);
846 if (size < type_size5) { return 0; }
847 size -= type_size5;
848 uint32_t arg5;
849 memcpy(&arg5, data, type_size5);
850 data += type_size5;
851
852 size_t type_size6 = sizeof(uint32_t);
853 if (size < type_size6) { return 0; }
854 size -= type_size6;
855 uint32_t arg6;
856 memcpy(&arg6, data, type_size6);
857 data += type_size6;
858
859 size_t type_size7 = sizeof(uint64_t);
860 if (size < type_size7) { return 0; }
861 size -= type_size7;
862 uint64_t arg7;
863 memcpy(&arg7, data, type_size7);
864 data += type_size7;
865
866 size_t type_size8 = sizeof(uint32_t);
867 if (size < type_size8) { return 0; }
868 size -= type_size8;
869 uint32_t arg8;
870 memcpy(&arg8, data, type_size8);
871 data += type_size8;
872
873 size_t type_size9 = sizeof(uint32_t);
874 if (size < type_size9) { return 0; }
875 size -= type_size9;
876 uint32_t arg9;
877 memcpy(&arg9, data, type_size9);
878 data += type_size9;
879
880 size_t type_size10 = sizeof(uint32_t);
881 if (size < type_size10) { return 0; }
882 size -= type_size10;
883 uint32_t arg10;
884 memcpy(&arg10, data, type_size10);
885 data += type_size10;
886
887 size_t type_size11 = sizeof(::android::hardware::renderscript::V1_0::AllocationCubemapFace);
888 if (size < type_size11) { return 0; }
889 size -= type_size11;
890 ::android::hardware::renderscript::V1_0::AllocationCubemapFace arg11;
891 memcpy(&arg11, data, type_size11);
892 data += type_size11;
893
894 renderscript->allocationCopy2DRange(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
895 return 0;
896 } else if (target_func == "allocationCopy3DRange") {
897 size_t type_size0 = sizeof(uint64_t);
898 if (size < type_size0) { return 0; }
899 size -= type_size0;
900 uint64_t arg0;
901 memcpy(&arg0, data, type_size0);
902 data += type_size0;
903
904 size_t type_size1 = sizeof(uint32_t);
905 if (size < type_size1) { return 0; }
906 size -= type_size1;
907 uint32_t arg1;
908 memcpy(&arg1, data, type_size1);
909 data += type_size1;
910
911 size_t type_size2 = sizeof(uint32_t);
912 if (size < type_size2) { return 0; }
913 size -= type_size2;
914 uint32_t arg2;
915 memcpy(&arg2, data, type_size2);
916 data += type_size2;
917
918 size_t type_size3 = sizeof(uint32_t);
919 if (size < type_size3) { return 0; }
920 size -= type_size3;
921 uint32_t arg3;
922 memcpy(&arg3, data, type_size3);
923 data += type_size3;
924
925 size_t type_size4 = sizeof(uint32_t);
926 if (size < type_size4) { return 0; }
927 size -= type_size4;
928 uint32_t arg4;
929 memcpy(&arg4, data, type_size4);
930 data += type_size4;
931
932 size_t type_size5 = sizeof(uint32_t);
933 if (size < type_size5) { return 0; }
934 size -= type_size5;
935 uint32_t arg5;
936 memcpy(&arg5, data, type_size5);
937 data += type_size5;
938
939 size_t type_size6 = sizeof(uint32_t);
940 if (size < type_size6) { return 0; }
941 size -= type_size6;
942 uint32_t arg6;
943 memcpy(&arg6, data, type_size6);
944 data += type_size6;
945
946 size_t type_size7 = sizeof(uint32_t);
947 if (size < type_size7) { return 0; }
948 size -= type_size7;
949 uint32_t arg7;
950 memcpy(&arg7, data, type_size7);
951 data += type_size7;
952
953 size_t type_size8 = sizeof(uint64_t);
954 if (size < type_size8) { return 0; }
955 size -= type_size8;
956 uint64_t arg8;
957 memcpy(&arg8, data, type_size8);
958 data += type_size8;
959
960 size_t type_size9 = sizeof(uint32_t);
961 if (size < type_size9) { return 0; }
962 size -= type_size9;
963 uint32_t arg9;
964 memcpy(&arg9, data, type_size9);
965 data += type_size9;
966
967 size_t type_size10 = sizeof(uint32_t);
968 if (size < type_size10) { return 0; }
969 size -= type_size10;
970 uint32_t arg10;
971 memcpy(&arg10, data, type_size10);
972 data += type_size10;
973
974 size_t type_size11 = sizeof(uint32_t);
975 if (size < type_size11) { return 0; }
976 size -= type_size11;
977 uint32_t arg11;
978 memcpy(&arg11, data, type_size11);
979 data += type_size11;
980
981 size_t type_size12 = sizeof(uint32_t);
982 if (size < type_size12) { return 0; }
983 size -= type_size12;
984 uint32_t arg12;
985 memcpy(&arg12, data, type_size12);
986 data += type_size12;
987
988 renderscript->allocationCopy3DRange(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
989 return 0;
990 } else if (target_func == "allocationIoSend") {
991 size_t type_size0 = sizeof(uint64_t);
992 if (size < type_size0) { return 0; }
993 size -= type_size0;
994 uint64_t arg0;
995 memcpy(&arg0, data, type_size0);
996 data += type_size0;
997
998 renderscript->allocationIoSend(arg0);
999 return 0;
1000 } else if (target_func == "allocationIoReceive") {
1001 size_t type_size0 = sizeof(uint64_t);
1002 if (size < type_size0) { return 0; }
1003 size -= type_size0;
1004 uint64_t arg0;
1005 memcpy(&arg0, data, type_size0);
1006 data += type_size0;
1007
1008 renderscript->allocationIoReceive(arg0);
1009 return 0;
1010 } else if (target_func == "allocationGetPointer") {
1011 // No-op. Only need this to make HAL function call.
1012 auto hidl_cb = [](void* arg0, uint64_t arg1){};
1013
1014 size_t type_size0 = sizeof(uint64_t);
1015 if (size < type_size0) { return 0; }
1016 size -= type_size0;
1017 uint64_t arg0;
1018 memcpy(&arg0, data, type_size0);
1019 data += type_size0;
1020
1021 size_t type_size1 = sizeof(uint32_t);
1022 if (size < type_size1) { return 0; }
1023 size -= type_size1;
1024 uint32_t arg1;
1025 memcpy(&arg1, data, type_size1);
1026 data += type_size1;
1027
1028 size_t type_size2 = sizeof(::android::hardware::renderscript::V1_0::AllocationCubemapFace);
1029 if (size < type_size2) { return 0; }
1030 size -= type_size2;
1031 ::android::hardware::renderscript::V1_0::AllocationCubemapFace arg2;
1032 memcpy(&arg2, data, type_size2);
1033 data += type_size2;
1034
1035 size_t type_size3 = sizeof(uint32_t);
1036 if (size < type_size3) { return 0; }
1037 size -= type_size3;
1038 uint32_t arg3;
1039 memcpy(&arg3, data, type_size3);
1040 data += type_size3;
1041
1042 renderscript->allocationGetPointer(arg0, arg1, arg2, arg3, hidl_cb);
1043 return 0;
1044 } else if (target_func == "elementGetNativeMetadata") {
1045 // No-op. Only need this to make HAL function call.
1046 auto hidl_cb = [](const ::android::hardware::hidl_vec<uint32_t>& arg0){};
1047
1048 size_t type_size0 = sizeof(uint64_t);
1049 if (size < type_size0) { return 0; }
1050 size -= type_size0;
1051 uint64_t arg0;
1052 memcpy(&arg0, data, type_size0);
1053 data += type_size0;
1054
1055 renderscript->elementGetNativeMetadata(arg0, hidl_cb);
1056 return 0;
1057 } else if (target_func == "elementGetSubElements") {
1058 // No-op. Only need this to make HAL function call.
1059 auto hidl_cb = [](const ::android::hardware::hidl_vec<uint64_t>& arg0, const ::android::hardware::hidl_vec<::android::hardware::hidl_string>& arg1, const ::android::hardware::hidl_vec<uint64_t>& arg2){};
1060
1061 size_t type_size0 = sizeof(uint64_t);
1062 if (size < type_size0) { return 0; }
1063 size -= type_size0;
1064 uint64_t arg0;
1065 memcpy(&arg0, data, type_size0);
1066 data += type_size0;
1067
1068 size_t type_size1 = sizeof(uint64_t);
1069 if (size < type_size1) { return 0; }
1070 size -= type_size1;
1071 uint64_t arg1;
1072 memcpy(&arg1, data, type_size1);
1073 data += type_size1;
1074
1075 renderscript->elementGetSubElements(arg0, arg1, hidl_cb);
1076 return 0;
1077 } else if (target_func == "elementCreate") {
1078 size_t type_size0 = sizeof(::android::hardware::renderscript::V1_0::DataType);
1079 if (size < type_size0) { return 0; }
1080 size -= type_size0;
1081 ::android::hardware::renderscript::V1_0::DataType arg0;
1082 memcpy(&arg0, data, type_size0);
1083 data += type_size0;
1084
1085 size_t type_size1 = sizeof(::android::hardware::renderscript::V1_0::DataKind);
1086 if (size < type_size1) { return 0; }
1087 size -= type_size1;
1088 ::android::hardware::renderscript::V1_0::DataKind arg1;
1089 memcpy(&arg1, data, type_size1);
1090 data += type_size1;
1091
1092 size_t type_size2 = sizeof(bool);
1093 if (size < type_size2) { return 0; }
1094 size -= type_size2;
1095 bool arg2;
1096 memcpy(&arg2, data, type_size2);
1097 data += type_size2;
1098
1099 size_t type_size3 = sizeof(uint32_t);
1100 if (size < type_size3) { return 0; }
1101 size -= type_size3;
1102 uint32_t arg3;
1103 memcpy(&arg3, data, type_size3);
1104 data += type_size3;
1105
1106 renderscript->elementCreate(arg0, arg1, arg2, arg3);
1107 return 0;
1108 } else if (target_func == "elementComplexCreate") {
1109 size_t type_size0 = sizeof(::android::hardware::hidl_vec<uint64_t>);
1110 if (size < type_size0) { return 0; }
1111 size -= type_size0;
1112 ::android::hardware::hidl_vec<uint64_t> arg0;
1113 memcpy(&arg0, data, type_size0);
1114 data += type_size0;
1115
1116 size_t type_size1 = sizeof(::android::hardware::hidl_vec<::android::hardware::hidl_string>);
1117 if (size < type_size1) { return 0; }
1118 size -= type_size1;
1119 ::android::hardware::hidl_vec<::android::hardware::hidl_string> arg1;
1120 memcpy(&arg1, data, type_size1);
1121 data += type_size1;
1122
1123 size_t type_size2 = sizeof(::android::hardware::hidl_vec<uint64_t>);
1124 if (size < type_size2) { return 0; }
1125 size -= type_size2;
1126 ::android::hardware::hidl_vec<uint64_t> arg2;
1127 memcpy(&arg2, data, type_size2);
1128 data += type_size2;
1129
1130 renderscript->elementComplexCreate(arg0, arg1, arg2);
1131 return 0;
1132 } else if (target_func == "typeGetNativeMetadata") {
1133 // No-op. Only need this to make HAL function call.
1134 auto hidl_cb = [](const ::android::hardware::hidl_vec<uint64_t>& arg0){};
1135
1136 size_t type_size0 = sizeof(uint64_t);
1137 if (size < type_size0) { return 0; }
1138 size -= type_size0;
1139 uint64_t arg0;
1140 memcpy(&arg0, data, type_size0);
1141 data += type_size0;
1142
1143 renderscript->typeGetNativeMetadata(arg0, hidl_cb);
1144 return 0;
1145 } else if (target_func == "typeCreate") {
1146 size_t type_size0 = sizeof(uint64_t);
1147 if (size < type_size0) { return 0; }
1148 size -= type_size0;
1149 uint64_t arg0;
1150 memcpy(&arg0, data, type_size0);
1151 data += type_size0;
1152
1153 size_t type_size1 = sizeof(uint32_t);
1154 if (size < type_size1) { return 0; }
1155 size -= type_size1;
1156 uint32_t arg1;
1157 memcpy(&arg1, data, type_size1);
1158 data += type_size1;
1159
1160 size_t type_size2 = sizeof(uint32_t);
1161 if (size < type_size2) { return 0; }
1162 size -= type_size2;
1163 uint32_t arg2;
1164 memcpy(&arg2, data, type_size2);
1165 data += type_size2;
1166
1167 size_t type_size3 = sizeof(uint32_t);
1168 if (size < type_size3) { return 0; }
1169 size -= type_size3;
1170 uint32_t arg3;
1171 memcpy(&arg3, data, type_size3);
1172 data += type_size3;
1173
1174 size_t type_size4 = sizeof(bool);
1175 if (size < type_size4) { return 0; }
1176 size -= type_size4;
1177 bool arg4;
1178 memcpy(&arg4, data, type_size4);
1179 data += type_size4;
1180
1181 size_t type_size5 = sizeof(bool);
1182 if (size < type_size5) { return 0; }
1183 size -= type_size5;
1184 bool arg5;
1185 memcpy(&arg5, data, type_size5);
1186 data += type_size5;
1187
1188 size_t type_size6 = sizeof(::android::hardware::renderscript::V1_0::YuvFormat);
1189 if (size < type_size6) { return 0; }
1190 size -= type_size6;
1191 ::android::hardware::renderscript::V1_0::YuvFormat arg6;
1192 memcpy(&arg6, data, type_size6);
1193 data += type_size6;
1194
1195 renderscript->typeCreate(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
1196 return 0;
1197 } else if (target_func == "contextDestroy") {
1198 renderscript->contextDestroy();
1199 return 0;
1200 } else if (target_func == "contextGetMessage") {
1201 // No-op. Only need this to make HAL function call.
1202 auto hidl_cb = [](::android::hardware::renderscript::V1_0::MessageToClientType arg0, uint64_t arg1){};
1203
1204 size_t type_size0 = sizeof(void*);
1205 if (size < type_size0) { return 0; }
1206 size -= type_size0;
1207 void* arg0;
1208 memcpy(&arg0, data, type_size0);
1209 data += type_size0;
1210
1211 size_t type_size1 = sizeof(uint64_t);
1212 if (size < type_size1) { return 0; }
1213 size -= type_size1;
1214 uint64_t arg1;
1215 memcpy(&arg1, data, type_size1);
1216 data += type_size1;
1217
1218 renderscript->contextGetMessage(arg0, arg1, hidl_cb);
1219 return 0;
1220 } else if (target_func == "contextPeekMessage") {
1221 // No-op. Only need this to make HAL function call.
1222 auto hidl_cb = [](::android::hardware::renderscript::V1_0::MessageToClientType arg0, uint64_t arg1, uint32_t arg2){};
1223
1224 renderscript->contextPeekMessage(hidl_cb);
1225 return 0;
1226 } else if (target_func == "contextSendMessage") {
1227 size_t type_size0 = sizeof(uint32_t);
1228 if (size < type_size0) { return 0; }
1229 size -= type_size0;
1230 uint32_t arg0;
1231 memcpy(&arg0, data, type_size0);
1232 data += type_size0;
1233
1234 size_t type_size1 = sizeof(::android::hardware::hidl_vec<uint8_t>);
1235 if (size < type_size1) { return 0; }
1236 size -= type_size1;
1237 ::android::hardware::hidl_vec<uint8_t> arg1;
1238 memcpy(&arg1, data, type_size1);
1239 data += type_size1;
1240
1241 renderscript->contextSendMessage(arg0, arg1);
1242 return 0;
1243 } else if (target_func == "contextInitToClient") {
1244 renderscript->contextInitToClient();
1245 return 0;
1246 } else if (target_func == "contextDeinitToClient") {
1247 renderscript->contextDeinitToClient();
1248 return 0;
1249 } else if (target_func == "contextFinish") {
1250 renderscript->contextFinish();
1251 return 0;
1252 } else if (target_func == "contextLog") {
1253 renderscript->contextLog();
1254 return 0;
1255 } else if (target_func == "contextSetCacheDir") {
1256 size_t type_size0 = sizeof(::android::hardware::hidl_string);
1257 if (size < type_size0) { return 0; }
1258 size -= type_size0;
1259 ::android::hardware::hidl_string arg0;
1260 memcpy(&arg0, data, type_size0);
1261 data += type_size0;
1262
1263 renderscript->contextSetCacheDir(arg0);
1264 return 0;
1265 } else if (target_func == "contextSetPriority") {
1266 size_t type_size0 = sizeof(::android::hardware::renderscript::V1_0::ThreadPriorities);
1267 if (size < type_size0) { return 0; }
1268 size -= type_size0;
1269 ::android::hardware::renderscript::V1_0::ThreadPriorities arg0;
1270 memcpy(&arg0, data, type_size0);
1271 data += type_size0;
1272
1273 renderscript->contextSetPriority(arg0);
1274 return 0;
1275 } else if (target_func == "assignName") {
1276 size_t type_size0 = sizeof(uint64_t);
1277 if (size < type_size0) { return 0; }
1278 size -= type_size0;
1279 uint64_t arg0;
1280 memcpy(&arg0, data, type_size0);
1281 data += type_size0;
1282
1283 size_t type_size1 = sizeof(::android::hardware::hidl_string);
1284 if (size < type_size1) { return 0; }
1285 size -= type_size1;
1286 ::android::hardware::hidl_string arg1;
1287 memcpy(&arg1, data, type_size1);
1288 data += type_size1;
1289
1290 renderscript->assignName(arg0, arg1);
1291 return 0;
1292 } else if (target_func == "getName") {
1293 // No-op. Only need this to make HAL function call.
1294 auto hidl_cb = [](const ::android::hardware::hidl_string& arg0){};
1295
1296 size_t type_size0 = sizeof(uint64_t);
1297 if (size < type_size0) { return 0; }
1298 size -= type_size0;
1299 uint64_t arg0;
1300 memcpy(&arg0, data, type_size0);
1301 data += type_size0;
1302
1303 renderscript->getName(arg0, hidl_cb);
1304 return 0;
1305 } else if (target_func == "closureCreate") {
1306 size_t type_size0 = sizeof(uint64_t);
1307 if (size < type_size0) { return 0; }
1308 size -= type_size0;
1309 uint64_t arg0;
1310 memcpy(&arg0, data, type_size0);
1311 data += type_size0;
1312
1313 size_t type_size1 = sizeof(uint64_t);
1314 if (size < type_size1) { return 0; }
1315 size -= type_size1;
1316 uint64_t arg1;
1317 memcpy(&arg1, data, type_size1);
1318 data += type_size1;
1319
1320 size_t type_size2 = sizeof(::android::hardware::hidl_vec<uint64_t>);
1321 if (size < type_size2) { return 0; }
1322 size -= type_size2;
1323 ::android::hardware::hidl_vec<uint64_t> arg2;
1324 memcpy(&arg2, data, type_size2);
1325 data += type_size2;
1326
1327 size_t type_size3 = sizeof(::android::hardware::hidl_vec<int64_t>);
1328 if (size < type_size3) { return 0; }
1329 size -= type_size3;
1330 ::android::hardware::hidl_vec<int64_t> arg3;
1331 memcpy(&arg3, data, type_size3);
1332 data += type_size3;
1333
1334 size_t type_size4 = sizeof(::android::hardware::hidl_vec<int32_t>);
1335 if (size < type_size4) { return 0; }
1336 size -= type_size4;
1337 ::android::hardware::hidl_vec<int32_t> arg4;
1338 memcpy(&arg4, data, type_size4);
1339 data += type_size4;
1340
1341 size_t type_size5 = sizeof(::android::hardware::hidl_vec<uint64_t>);
1342 if (size < type_size5) { return 0; }
1343 size -= type_size5;
1344 ::android::hardware::hidl_vec<uint64_t> arg5;
1345 memcpy(&arg5, data, type_size5);
1346 data += type_size5;
1347
1348 size_t type_size6 = sizeof(::android::hardware::hidl_vec<uint64_t>);
1349 if (size < type_size6) { return 0; }
1350 size -= type_size6;
1351 ::android::hardware::hidl_vec<uint64_t> arg6;
1352 memcpy(&arg6, data, type_size6);
1353 data += type_size6;
1354
1355 renderscript->closureCreate(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
1356 return 0;
1357 } else if (target_func == "invokeClosureCreate") {
1358 size_t type_size0 = sizeof(uint64_t);
1359 if (size < type_size0) { return 0; }
1360 size -= type_size0;
1361 uint64_t arg0;
1362 memcpy(&arg0, data, type_size0);
1363 data += type_size0;
1364
1365 size_t type_size1 = sizeof(::android::hardware::hidl_vec<uint8_t>);
1366 if (size < type_size1) { return 0; }
1367 size -= type_size1;
1368 ::android::hardware::hidl_vec<uint8_t> arg1;
1369 memcpy(&arg1, data, type_size1);
1370 data += type_size1;
1371
1372 size_t type_size2 = sizeof(::android::hardware::hidl_vec<uint64_t>);
1373 if (size < type_size2) { return 0; }
1374 size -= type_size2;
1375 ::android::hardware::hidl_vec<uint64_t> arg2;
1376 memcpy(&arg2, data, type_size2);
1377 data += type_size2;
1378
1379 size_t type_size3 = sizeof(::android::hardware::hidl_vec<int64_t>);
1380 if (size < type_size3) { return 0; }
1381 size -= type_size3;
1382 ::android::hardware::hidl_vec<int64_t> arg3;
1383 memcpy(&arg3, data, type_size3);
1384 data += type_size3;
1385
1386 size_t type_size4 = sizeof(::android::hardware::hidl_vec<int32_t>);
1387 if (size < type_size4) { return 0; }
1388 size -= type_size4;
1389 ::android::hardware::hidl_vec<int32_t> arg4;
1390 memcpy(&arg4, data, type_size4);
1391 data += type_size4;
1392
1393 renderscript->invokeClosureCreate(arg0, arg1, arg2, arg3, arg4);
1394 return 0;
1395 } else if (target_func == "closureSetArg") {
1396 size_t type_size0 = sizeof(uint64_t);
1397 if (size < type_size0) { return 0; }
1398 size -= type_size0;
1399 uint64_t arg0;
1400 memcpy(&arg0, data, type_size0);
1401 data += type_size0;
1402
1403 size_t type_size1 = sizeof(uint32_t);
1404 if (size < type_size1) { return 0; }
1405 size -= type_size1;
1406 uint32_t arg1;
1407 memcpy(&arg1, data, type_size1);
1408 data += type_size1;
1409
1410 size_t type_size2 = sizeof(void*);
1411 if (size < type_size2) { return 0; }
1412 size -= type_size2;
1413 void* arg2;
1414 memcpy(&arg2, data, type_size2);
1415 data += type_size2;
1416
1417 size_t type_size3 = sizeof(int32_t);
1418 if (size < type_size3) { return 0; }
1419 size -= type_size3;
1420 int32_t arg3;
1421 memcpy(&arg3, data, type_size3);
1422 data += type_size3;
1423
1424 renderscript->closureSetArg(arg0, arg1, arg2, arg3);
1425 return 0;
1426 } else if (target_func == "closureSetGlobal") {
1427 size_t type_size0 = sizeof(uint64_t);
1428 if (size < type_size0) { return 0; }
1429 size -= type_size0;
1430 uint64_t arg0;
1431 memcpy(&arg0, data, type_size0);
1432 data += type_size0;
1433
1434 size_t type_size1 = sizeof(uint64_t);
1435 if (size < type_size1) { return 0; }
1436 size -= type_size1;
1437 uint64_t arg1;
1438 memcpy(&arg1, data, type_size1);
1439 data += type_size1;
1440
1441 size_t type_size2 = sizeof(int64_t);
1442 if (size < type_size2) { return 0; }
1443 size -= type_size2;
1444 int64_t arg2;
1445 memcpy(&arg2, data, type_size2);
1446 data += type_size2;
1447
1448 size_t type_size3 = sizeof(int32_t);
1449 if (size < type_size3) { return 0; }
1450 size -= type_size3;
1451 int32_t arg3;
1452 memcpy(&arg3, data, type_size3);
1453 data += type_size3;
1454
1455 renderscript->closureSetGlobal(arg0, arg1, arg2, arg3);
1456 return 0;
1457 } else if (target_func == "scriptKernelIDCreate") {
1458 size_t type_size0 = sizeof(uint64_t);
1459 if (size < type_size0) { return 0; }
1460 size -= type_size0;
1461 uint64_t arg0;
1462 memcpy(&arg0, data, type_size0);
1463 data += type_size0;
1464
1465 size_t type_size1 = sizeof(int32_t);
1466 if (size < type_size1) { return 0; }
1467 size -= type_size1;
1468 int32_t arg1;
1469 memcpy(&arg1, data, type_size1);
1470 data += type_size1;
1471
1472 size_t type_size2 = sizeof(int32_t);
1473 if (size < type_size2) { return 0; }
1474 size -= type_size2;
1475 int32_t arg2;
1476 memcpy(&arg2, data, type_size2);
1477 data += type_size2;
1478
1479 renderscript->scriptKernelIDCreate(arg0, arg1, arg2);
1480 return 0;
1481 } else if (target_func == "scriptInvokeIDCreate") {
1482 size_t type_size0 = sizeof(uint64_t);
1483 if (size < type_size0) { return 0; }
1484 size -= type_size0;
1485 uint64_t arg0;
1486 memcpy(&arg0, data, type_size0);
1487 data += type_size0;
1488
1489 size_t type_size1 = sizeof(int32_t);
1490 if (size < type_size1) { return 0; }
1491 size -= type_size1;
1492 int32_t arg1;
1493 memcpy(&arg1, data, type_size1);
1494 data += type_size1;
1495
1496 renderscript->scriptInvokeIDCreate(arg0, arg1);
1497 return 0;
1498 } else if (target_func == "scriptFieldIDCreate") {
1499 size_t type_size0 = sizeof(uint64_t);
1500 if (size < type_size0) { return 0; }
1501 size -= type_size0;
1502 uint64_t arg0;
1503 memcpy(&arg0, data, type_size0);
1504 data += type_size0;
1505
1506 size_t type_size1 = sizeof(int32_t);
1507 if (size < type_size1) { return 0; }
1508 size -= type_size1;
1509 int32_t arg1;
1510 memcpy(&arg1, data, type_size1);
1511 data += type_size1;
1512
1513 renderscript->scriptFieldIDCreate(arg0, arg1);
1514 return 0;
1515 } else if (target_func == "scriptGroupCreate") {
1516 size_t type_size0 = sizeof(::android::hardware::hidl_vec<uint64_t>);
1517 if (size < type_size0) { return 0; }
1518 size -= type_size0;
1519 ::android::hardware::hidl_vec<uint64_t> arg0;
1520 memcpy(&arg0, data, type_size0);
1521 data += type_size0;
1522
1523 size_t type_size1 = sizeof(::android::hardware::hidl_vec<uint64_t>);
1524 if (size < type_size1) { return 0; }
1525 size -= type_size1;
1526 ::android::hardware::hidl_vec<uint64_t> arg1;
1527 memcpy(&arg1, data, type_size1);
1528 data += type_size1;
1529
1530 size_t type_size2 = sizeof(::android::hardware::hidl_vec<uint64_t>);
1531 if (size < type_size2) { return 0; }
1532 size -= type_size2;
1533 ::android::hardware::hidl_vec<uint64_t> arg2;
1534 memcpy(&arg2, data, type_size2);
1535 data += type_size2;
1536
1537 size_t type_size3 = sizeof(::android::hardware::hidl_vec<uint64_t>);
1538 if (size < type_size3) { return 0; }
1539 size -= type_size3;
1540 ::android::hardware::hidl_vec<uint64_t> arg3;
1541 memcpy(&arg3, data, type_size3);
1542 data += type_size3;
1543
1544 size_t type_size4 = sizeof(::android::hardware::hidl_vec<uint64_t>);
1545 if (size < type_size4) { return 0; }
1546 size -= type_size4;
1547 ::android::hardware::hidl_vec<uint64_t> arg4;
1548 memcpy(&arg4, data, type_size4);
1549 data += type_size4;
1550
1551 renderscript->scriptGroupCreate(arg0, arg1, arg2, arg3, arg4);
1552 return 0;
1553 } else if (target_func == "scriptGroup2Create") {
1554 size_t type_size0 = sizeof(::android::hardware::hidl_string);
1555 if (size < type_size0) { return 0; }
1556 size -= type_size0;
1557 ::android::hardware::hidl_string arg0;
1558 memcpy(&arg0, data, type_size0);
1559 data += type_size0;
1560
1561 size_t type_size1 = sizeof(::android::hardware::hidl_string);
1562 if (size < type_size1) { return 0; }
1563 size -= type_size1;
1564 ::android::hardware::hidl_string arg1;
1565 memcpy(&arg1, data, type_size1);
1566 data += type_size1;
1567
1568 size_t type_size2 = sizeof(::android::hardware::hidl_vec<uint64_t>);
1569 if (size < type_size2) { return 0; }
1570 size -= type_size2;
1571 ::android::hardware::hidl_vec<uint64_t> arg2;
1572 memcpy(&arg2, data, type_size2);
1573 data += type_size2;
1574
1575 renderscript->scriptGroup2Create(arg0, arg1, arg2);
1576 return 0;
1577 } else if (target_func == "scriptGroupSetOutput") {
1578 size_t type_size0 = sizeof(uint64_t);
1579 if (size < type_size0) { return 0; }
1580 size -= type_size0;
1581 uint64_t arg0;
1582 memcpy(&arg0, data, type_size0);
1583 data += type_size0;
1584
1585 size_t type_size1 = sizeof(uint64_t);
1586 if (size < type_size1) { return 0; }
1587 size -= type_size1;
1588 uint64_t arg1;
1589 memcpy(&arg1, data, type_size1);
1590 data += type_size1;
1591
1592 size_t type_size2 = sizeof(uint64_t);
1593 if (size < type_size2) { return 0; }
1594 size -= type_size2;
1595 uint64_t arg2;
1596 memcpy(&arg2, data, type_size2);
1597 data += type_size2;
1598
1599 renderscript->scriptGroupSetOutput(arg0, arg1, arg2);
1600 return 0;
1601 } else if (target_func == "scriptGroupSetInput") {
1602 size_t type_size0 = sizeof(uint64_t);
1603 if (size < type_size0) { return 0; }
1604 size -= type_size0;
1605 uint64_t arg0;
1606 memcpy(&arg0, data, type_size0);
1607 data += type_size0;
1608
1609 size_t type_size1 = sizeof(uint64_t);
1610 if (size < type_size1) { return 0; }
1611 size -= type_size1;
1612 uint64_t arg1;
1613 memcpy(&arg1, data, type_size1);
1614 data += type_size1;
1615
1616 size_t type_size2 = sizeof(uint64_t);
1617 if (size < type_size2) { return 0; }
1618 size -= type_size2;
1619 uint64_t arg2;
1620 memcpy(&arg2, data, type_size2);
1621 data += type_size2;
1622
1623 renderscript->scriptGroupSetInput(arg0, arg1, arg2);
1624 return 0;
1625 } else if (target_func == "scriptGroupExecute") {
1626 size_t type_size0 = sizeof(uint64_t);
1627 if (size < type_size0) { return 0; }
1628 size -= type_size0;
1629 uint64_t arg0;
1630 memcpy(&arg0, data, type_size0);
1631 data += type_size0;
1632
1633 renderscript->scriptGroupExecute(arg0);
1634 return 0;
1635 } else if (target_func == "objDestroy") {
1636 size_t type_size0 = sizeof(uint64_t);
1637 if (size < type_size0) { return 0; }
1638 size -= type_size0;
1639 uint64_t arg0;
1640 memcpy(&arg0, data, type_size0);
1641 data += type_size0;
1642
1643 renderscript->objDestroy(arg0);
1644 return 0;
1645 } else if (target_func == "samplerCreate") {
1646 size_t type_size0 = sizeof(::android::hardware::renderscript::V1_0::SamplerValue);
1647 if (size < type_size0) { return 0; }
1648 size -= type_size0;
1649 ::android::hardware::renderscript::V1_0::SamplerValue arg0;
1650 memcpy(&arg0, data, type_size0);
1651 data += type_size0;
1652
1653 size_t type_size1 = sizeof(::android::hardware::renderscript::V1_0::SamplerValue);
1654 if (size < type_size1) { return 0; }
1655 size -= type_size1;
1656 ::android::hardware::renderscript::V1_0::SamplerValue arg1;
1657 memcpy(&arg1, data, type_size1);
1658 data += type_size1;
1659
1660 size_t type_size2 = sizeof(::android::hardware::renderscript::V1_0::SamplerValue);
1661 if (size < type_size2) { return 0; }
1662 size -= type_size2;
1663 ::android::hardware::renderscript::V1_0::SamplerValue arg2;
1664 memcpy(&arg2, data, type_size2);
1665 data += type_size2;
1666
1667 size_t type_size3 = sizeof(::android::hardware::renderscript::V1_0::SamplerValue);
1668 if (size < type_size3) { return 0; }
1669 size -= type_size3;
1670 ::android::hardware::renderscript::V1_0::SamplerValue arg3;
1671 memcpy(&arg3, data, type_size3);
1672 data += type_size3;
1673
1674 size_t type_size4 = sizeof(::android::hardware::renderscript::V1_0::SamplerValue);
1675 if (size < type_size4) { return 0; }
1676 size -= type_size4;
1677 ::android::hardware::renderscript::V1_0::SamplerValue arg4;
1678 memcpy(&arg4, data, type_size4);
1679 data += type_size4;
1680
1681 size_t type_size5 = sizeof(float);
1682 if (size < type_size5) { return 0; }
1683 size -= type_size5;
1684 float arg5;
1685 memcpy(&arg5, data, type_size5);
1686 data += type_size5;
1687
1688 renderscript->samplerCreate(arg0, arg1, arg2, arg3, arg4, arg5);
1689 return 0;
1690 } else if (target_func == "scriptBindAllocation") {
1691 size_t type_size0 = sizeof(uint64_t);
1692 if (size < type_size0) { return 0; }
1693 size -= type_size0;
1694 uint64_t arg0;
1695 memcpy(&arg0, data, type_size0);
1696 data += type_size0;
1697
1698 size_t type_size1 = sizeof(uint64_t);
1699 if (size < type_size1) { return 0; }
1700 size -= type_size1;
1701 uint64_t arg1;
1702 memcpy(&arg1, data, type_size1);
1703 data += type_size1;
1704
1705 size_t type_size2 = sizeof(uint32_t);
1706 if (size < type_size2) { return 0; }
1707 size -= type_size2;
1708 uint32_t arg2;
1709 memcpy(&arg2, data, type_size2);
1710 data += type_size2;
1711
1712 renderscript->scriptBindAllocation(arg0, arg1, arg2);
1713 return 0;
1714 } else if (target_func == "scriptSetTimeZone") {
1715 size_t type_size0 = sizeof(uint64_t);
1716 if (size < type_size0) { return 0; }
1717 size -= type_size0;
1718 uint64_t arg0;
1719 memcpy(&arg0, data, type_size0);
1720 data += type_size0;
1721
1722 size_t type_size1 = sizeof(::android::hardware::hidl_string);
1723 if (size < type_size1) { return 0; }
1724 size -= type_size1;
1725 ::android::hardware::hidl_string arg1;
1726 memcpy(&arg1, data, type_size1);
1727 data += type_size1;
1728
1729 renderscript->scriptSetTimeZone(arg0, arg1);
1730 return 0;
1731 } else if (target_func == "scriptInvoke") {
1732 size_t type_size0 = sizeof(uint64_t);
1733 if (size < type_size0) { return 0; }
1734 size -= type_size0;
1735 uint64_t arg0;
1736 memcpy(&arg0, data, type_size0);
1737 data += type_size0;
1738
1739 size_t type_size1 = sizeof(uint32_t);
1740 if (size < type_size1) { return 0; }
1741 size -= type_size1;
1742 uint32_t arg1;
1743 memcpy(&arg1, data, type_size1);
1744 data += type_size1;
1745
1746 renderscript->scriptInvoke(arg0, arg1);
1747 return 0;
1748 } else if (target_func == "scriptInvokeV") {
1749 size_t type_size0 = sizeof(uint64_t);
1750 if (size < type_size0) { return 0; }
1751 size -= type_size0;
1752 uint64_t arg0;
1753 memcpy(&arg0, data, type_size0);
1754 data += type_size0;
1755
1756 size_t type_size1 = sizeof(uint32_t);
1757 if (size < type_size1) { return 0; }
1758 size -= type_size1;
1759 uint32_t arg1;
1760 memcpy(&arg1, data, type_size1);
1761 data += type_size1;
1762
1763 size_t type_size2 = sizeof(::android::hardware::hidl_vec<uint8_t>);
1764 if (size < type_size2) { return 0; }
1765 size -= type_size2;
1766 ::android::hardware::hidl_vec<uint8_t> arg2;
1767 memcpy(&arg2, data, type_size2);
1768 data += type_size2;
1769
1770 renderscript->scriptInvokeV(arg0, arg1, arg2);
1771 return 0;
1772 } else if (target_func == "scriptForEach") {
1773 size_t type_size0 = sizeof(uint64_t);
1774 if (size < type_size0) { return 0; }
1775 size -= type_size0;
1776 uint64_t arg0;
1777 memcpy(&arg0, data, type_size0);
1778 data += type_size0;
1779
1780 size_t type_size1 = sizeof(uint32_t);
1781 if (size < type_size1) { return 0; }
1782 size -= type_size1;
1783 uint32_t arg1;
1784 memcpy(&arg1, data, type_size1);
1785 data += type_size1;
1786
1787 size_t type_size2 = sizeof(::android::hardware::hidl_vec<uint64_t>);
1788 if (size < type_size2) { return 0; }
1789 size -= type_size2;
1790 ::android::hardware::hidl_vec<uint64_t> arg2;
1791 memcpy(&arg2, data, type_size2);
1792 data += type_size2;
1793
1794 size_t type_size3 = sizeof(uint64_t);
1795 if (size < type_size3) { return 0; }
1796 size -= type_size3;
1797 uint64_t arg3;
1798 memcpy(&arg3, data, type_size3);
1799 data += type_size3;
1800
1801 size_t type_size4 = sizeof(::android::hardware::hidl_vec<uint8_t>);
1802 if (size < type_size4) { return 0; }
1803 size -= type_size4;
1804 ::android::hardware::hidl_vec<uint8_t> arg4;
1805 memcpy(&arg4, data, type_size4);
1806 data += type_size4;
1807
1808 size_t type_size5 = sizeof(void*);
1809 if (size < type_size5) { return 0; }
1810 size -= type_size5;
1811 void* arg5;
1812 memcpy(&arg5, data, type_size5);
1813 data += type_size5;
1814
1815 renderscript->scriptForEach(arg0, arg1, arg2, arg3, arg4, arg5);
1816 return 0;
1817 } else if (target_func == "scriptReduce") {
1818 size_t type_size0 = sizeof(uint64_t);
1819 if (size < type_size0) { return 0; }
1820 size -= type_size0;
1821 uint64_t arg0;
1822 memcpy(&arg0, data, type_size0);
1823 data += type_size0;
1824
1825 size_t type_size1 = sizeof(uint32_t);
1826 if (size < type_size1) { return 0; }
1827 size -= type_size1;
1828 uint32_t arg1;
1829 memcpy(&arg1, data, type_size1);
1830 data += type_size1;
1831
1832 size_t type_size2 = sizeof(::android::hardware::hidl_vec<uint64_t>);
1833 if (size < type_size2) { return 0; }
1834 size -= type_size2;
1835 ::android::hardware::hidl_vec<uint64_t> arg2;
1836 memcpy(&arg2, data, type_size2);
1837 data += type_size2;
1838
1839 size_t type_size3 = sizeof(uint64_t);
1840 if (size < type_size3) { return 0; }
1841 size -= type_size3;
1842 uint64_t arg3;
1843 memcpy(&arg3, data, type_size3);
1844 data += type_size3;
1845
1846 size_t type_size4 = sizeof(void*);
1847 if (size < type_size4) { return 0; }
1848 size -= type_size4;
1849 void* arg4;
1850 memcpy(&arg4, data, type_size4);
1851 data += type_size4;
1852
1853 renderscript->scriptReduce(arg0, arg1, arg2, arg3, arg4);
1854 return 0;
1855 } else if (target_func == "scriptSetVarI") {
1856 size_t type_size0 = sizeof(uint64_t);
1857 if (size < type_size0) { return 0; }
1858 size -= type_size0;
1859 uint64_t arg0;
1860 memcpy(&arg0, data, type_size0);
1861 data += type_size0;
1862
1863 size_t type_size1 = sizeof(uint32_t);
1864 if (size < type_size1) { return 0; }
1865 size -= type_size1;
1866 uint32_t arg1;
1867 memcpy(&arg1, data, type_size1);
1868 data += type_size1;
1869
1870 size_t type_size2 = sizeof(int32_t);
1871 if (size < type_size2) { return 0; }
1872 size -= type_size2;
1873 int32_t arg2;
1874 memcpy(&arg2, data, type_size2);
1875 data += type_size2;
1876
1877 renderscript->scriptSetVarI(arg0, arg1, arg2);
1878 return 0;
1879 } else if (target_func == "scriptSetVarObj") {
1880 size_t type_size0 = sizeof(uint64_t);
1881 if (size < type_size0) { return 0; }
1882 size -= type_size0;
1883 uint64_t arg0;
1884 memcpy(&arg0, data, type_size0);
1885 data += type_size0;
1886
1887 size_t type_size1 = sizeof(uint32_t);
1888 if (size < type_size1) { return 0; }
1889 size -= type_size1;
1890 uint32_t arg1;
1891 memcpy(&arg1, data, type_size1);
1892 data += type_size1;
1893
1894 size_t type_size2 = sizeof(uint64_t);
1895 if (size < type_size2) { return 0; }
1896 size -= type_size2;
1897 uint64_t arg2;
1898 memcpy(&arg2, data, type_size2);
1899 data += type_size2;
1900
1901 renderscript->scriptSetVarObj(arg0, arg1, arg2);
1902 return 0;
1903 } else if (target_func == "scriptSetVarJ") {
1904 size_t type_size0 = sizeof(uint64_t);
1905 if (size < type_size0) { return 0; }
1906 size -= type_size0;
1907 uint64_t arg0;
1908 memcpy(&arg0, data, type_size0);
1909 data += type_size0;
1910
1911 size_t type_size1 = sizeof(uint32_t);
1912 if (size < type_size1) { return 0; }
1913 size -= type_size1;
1914 uint32_t arg1;
1915 memcpy(&arg1, data, type_size1);
1916 data += type_size1;
1917
1918 size_t type_size2 = sizeof(int64_t);
1919 if (size < type_size2) { return 0; }
1920 size -= type_size2;
1921 int64_t arg2;
1922 memcpy(&arg2, data, type_size2);
1923 data += type_size2;
1924
1925 renderscript->scriptSetVarJ(arg0, arg1, arg2);
1926 return 0;
1927 } else if (target_func == "scriptSetVarF") {
1928 size_t type_size0 = sizeof(uint64_t);
1929 if (size < type_size0) { return 0; }
1930 size -= type_size0;
1931 uint64_t arg0;
1932 memcpy(&arg0, data, type_size0);
1933 data += type_size0;
1934
1935 size_t type_size1 = sizeof(uint32_t);
1936 if (size < type_size1) { return 0; }
1937 size -= type_size1;
1938 uint32_t arg1;
1939 memcpy(&arg1, data, type_size1);
1940 data += type_size1;
1941
1942 size_t type_size2 = sizeof(float);
1943 if (size < type_size2) { return 0; }
1944 size -= type_size2;
1945 float arg2;
1946 memcpy(&arg2, data, type_size2);
1947 data += type_size2;
1948
1949 renderscript->scriptSetVarF(arg0, arg1, arg2);
1950 return 0;
1951 } else if (target_func == "scriptSetVarD") {
1952 size_t type_size0 = sizeof(uint64_t);
1953 if (size < type_size0) { return 0; }
1954 size -= type_size0;
1955 uint64_t arg0;
1956 memcpy(&arg0, data, type_size0);
1957 data += type_size0;
1958
1959 size_t type_size1 = sizeof(uint32_t);
1960 if (size < type_size1) { return 0; }
1961 size -= type_size1;
1962 uint32_t arg1;
1963 memcpy(&arg1, data, type_size1);
1964 data += type_size1;
1965
1966 size_t type_size2 = sizeof(double);
1967 if (size < type_size2) { return 0; }
1968 size -= type_size2;
1969 double arg2;
1970 memcpy(&arg2, data, type_size2);
1971 data += type_size2;
1972
1973 renderscript->scriptSetVarD(arg0, arg1, arg2);
1974 return 0;
1975 } else if (target_func == "scriptSetVarV") {
1976 size_t type_size0 = sizeof(uint64_t);
1977 if (size < type_size0) { return 0; }
1978 size -= type_size0;
1979 uint64_t arg0;
1980 memcpy(&arg0, data, type_size0);
1981 data += type_size0;
1982
1983 size_t type_size1 = sizeof(uint32_t);
1984 if (size < type_size1) { return 0; }
1985 size -= type_size1;
1986 uint32_t arg1;
1987 memcpy(&arg1, data, type_size1);
1988 data += type_size1;
1989
1990 size_t type_size2 = sizeof(::android::hardware::hidl_vec<uint8_t>);
1991 if (size < type_size2) { return 0; }
1992 size -= type_size2;
1993 ::android::hardware::hidl_vec<uint8_t> arg2;
1994 memcpy(&arg2, data, type_size2);
1995 data += type_size2;
1996
1997 renderscript->scriptSetVarV(arg0, arg1, arg2);
1998 return 0;
1999 } else if (target_func == "scriptGetVarV") {
2000 // No-op. Only need this to make HAL function call.
2001 auto hidl_cb = [](const ::android::hardware::hidl_vec<uint8_t>& arg0){};
2002
2003 size_t type_size0 = sizeof(uint64_t);
2004 if (size < type_size0) { return 0; }
2005 size -= type_size0;
2006 uint64_t arg0;
2007 memcpy(&arg0, data, type_size0);
2008 data += type_size0;
2009
2010 size_t type_size1 = sizeof(uint32_t);
2011 if (size < type_size1) { return 0; }
2012 size -= type_size1;
2013 uint32_t arg1;
2014 memcpy(&arg1, data, type_size1);
2015 data += type_size1;
2016
2017 size_t type_size2 = sizeof(uint64_t);
2018 if (size < type_size2) { return 0; }
2019 size -= type_size2;
2020 uint64_t arg2;
2021 memcpy(&arg2, data, type_size2);
2022 data += type_size2;
2023
2024 renderscript->scriptGetVarV(arg0, arg1, arg2, hidl_cb);
2025 return 0;
2026 } else if (target_func == "scriptSetVarVE") {
2027 size_t type_size0 = sizeof(uint64_t);
2028 if (size < type_size0) { return 0; }
2029 size -= type_size0;
2030 uint64_t arg0;
2031 memcpy(&arg0, data, type_size0);
2032 data += type_size0;
2033
2034 size_t type_size1 = sizeof(uint32_t);
2035 if (size < type_size1) { return 0; }
2036 size -= type_size1;
2037 uint32_t arg1;
2038 memcpy(&arg1, data, type_size1);
2039 data += type_size1;
2040
2041 size_t type_size2 = sizeof(::android::hardware::hidl_vec<uint8_t>);
2042 if (size < type_size2) { return 0; }
2043 size -= type_size2;
2044 ::android::hardware::hidl_vec<uint8_t> arg2;
2045 memcpy(&arg2, data, type_size2);
2046 data += type_size2;
2047
2048 size_t type_size3 = sizeof(uint64_t);
2049 if (size < type_size3) { return 0; }
2050 size -= type_size3;
2051 uint64_t arg3;
2052 memcpy(&arg3, data, type_size3);
2053 data += type_size3;
2054
2055 size_t type_size4 = sizeof(::android::hardware::hidl_vec<uint32_t>);
2056 if (size < type_size4) { return 0; }
2057 size -= type_size4;
2058 ::android::hardware::hidl_vec<uint32_t> arg4;
2059 memcpy(&arg4, data, type_size4);
2060 data += type_size4;
2061
2062 renderscript->scriptSetVarVE(arg0, arg1, arg2, arg3, arg4);
2063 return 0;
2064 } else if (target_func == "scriptCCreate") {
2065 size_t type_size0 = sizeof(::android::hardware::hidl_string);
2066 if (size < type_size0) { return 0; }
2067 size -= type_size0;
2068 ::android::hardware::hidl_string arg0;
2069 memcpy(&arg0, data, type_size0);
2070 data += type_size0;
2071
2072 size_t type_size1 = sizeof(::android::hardware::hidl_string);
2073 if (size < type_size1) { return 0; }
2074 size -= type_size1;
2075 ::android::hardware::hidl_string arg1;
2076 memcpy(&arg1, data, type_size1);
2077 data += type_size1;
2078
2079 size_t type_size2 = sizeof(::android::hardware::hidl_vec<uint8_t>);
2080 if (size < type_size2) { return 0; }
2081 size -= type_size2;
2082 ::android::hardware::hidl_vec<uint8_t> arg2;
2083 memcpy(&arg2, data, type_size2);
2084 data += type_size2;
2085
2086 renderscript->scriptCCreate(arg0, arg1, arg2);
2087 return 0;
2088 } else if (target_func == "scriptIntrinsicCreate") {
2089 size_t type_size0 = sizeof(::android::hardware::renderscript::V1_0::ScriptIntrinsicID);
2090 if (size < type_size0) { return 0; }
2091 size -= type_size0;
2092 ::android::hardware::renderscript::V1_0::ScriptIntrinsicID arg0;
2093 memcpy(&arg0, data, type_size0);
2094 data += type_size0;
2095
2096 size_t type_size1 = sizeof(uint64_t);
2097 if (size < type_size1) { return 0; }
2098 size -= type_size1;
2099 uint64_t arg1;
2100 memcpy(&arg1, data, type_size1);
2101 data += type_size1;
2102
2103 renderscript->scriptIntrinsicCreate(arg0, arg1);
2104 return 0;
2105 } else {
2106 cerr << "No such function: " << target_func << endl;
2107 exit(1);
2108 }
2109 }
2110
2111 } // namespace vts
2112 } // namespace android
2113