FFmpeg
Loading...
Searching...
No Matches
spvasm.h
Go to the documentation of this file.
1/**
2 * Copyright (C) 2026 Lynne
3 *
4 * This file is part of FFmpeg.
5 *
6 * FFmpeg is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * FFmpeg is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19 */
20
21#ifndef SWSCALE_VULKAN_SPVASM_H
22#define SWSCALE_VULKAN_SPVASM_H
23
24#include <stdint.h>
25#include <string.h>
26#include "config.h"
27
29#include "libavutil/avassert.h"
30#include "libavutil/error.h"
31#include "libavutil/mem.h"
32
33#if HAVE_SPIRV_HEADERS_SPIRV_H
34#include <spirv-headers/spirv.h>
35#include <spirv-headers/GLSL.std.450.h>
36#endif
37
38#if HAVE_SPIRV_UNIFIED1_SPIRV_H
39#include <spirv/unified1/spirv.h>
40#include <spirv/unified1/GLSL.std.450.h>
41#endif
42
43/* COUNT_ARGS: counts variadic macro arguments, including zero.
44 * The sentinel 0 is prepended so the compound literal is never empty,
45 * making this valid in strict C11. */
46#define COUNT_ARGS_IMPL(...) (sizeof((int[]){__VA_ARGS__}) / sizeof(int))
47#define COUNT_ARGS(...) (COUNT_ARGS_IMPL(0, __VA_ARGS__) - 1)
48
49/* SPI_ARGS: produces a (const int *, int) pair for the _arr helper functions.
50 * When __VA_ARGS__ is empty the array literal is (int[]){0} and nb is 0,
51 * so the pointer exists but is never dereferenced. */
52#define SPI_ARGS(...) ((int[]){0, __VA_ARGS__}) + 1, COUNT_ARGS(__VA_ARGS__)
53
54/* Sections of a SPIR-V module, in their required order */
55typedef enum SPISection {
56 SPI_SECTION_HEADER, /* capabilities, imports, memory model, entry points */
57 SPI_SECTION_DEBUG, /* debug names */
59 SPI_SECTION_GLOBALS, /* types, constants and global variables */
60 SPI_SECTION_CODE, /* function definitions */
63
64typedef struct SPISectionBuf {
65 uint8_t *data;
66 unsigned int size; /* allocated size */
67 int off; /* number of bytes written */
68 int err; /* set if any write failed */
70
71typedef struct SPICtx {
72 /* Instructions are written to the section corresponding to their opcode */
74
76 int id;
77} SPICtx;
78
79/* Returns a pointer to `len` new bytes at the end of the section */
80static inline uint8_t *spi_append(SPISectionBuf *sec, int len)
81{
82 uint8_t *data = av_fast_realloc(sec->data, &sec->size, sec->off + len);
83 if (!data) {
84 sec->err = AVERROR(ENOMEM);
85 return NULL;
86 }
87
88 sec->data = data;
89 sec->off += len;
90 return &data[sec->off - len];
91}
92
93static inline void spi_write_u32(SPISectionBuf *sec, uint32_t v)
94{
95 uint8_t *ptr = spi_append(sec, 4);
96 if (ptr)
97 AV_WL32(ptr, v);
98}
99
100static void spi_put_str(SPISectionBuf *sec, const char *str)
101{
102 const int len = strlen(str) + 1;
103 const int padded = FFALIGN(len, 4);
104 uint8_t *ptr = spi_append(sec, padded);
105 if (!ptr)
106 return;
107
108 memcpy(ptr, str, len);
109 memset(ptr + len, 0, padded - len);
110}
111
112static inline SPISection spi_opcode_section(SpvOp op)
113{
114 switch (op) {
115 case SpvOpCapability:
116 case SpvOpExtension:
117 case SpvOpExtInstImport:
118 case SpvOpMemoryModel:
119 case SpvOpEntryPoint:
120 case SpvOpExecutionMode:
121 return SPI_SECTION_HEADER;
122 case SpvOpName:
123 case SpvOpMemberName:
124 return SPI_SECTION_DEBUG;
125 case SpvOpDecorate:
126 case SpvOpMemberDecorate:
128 case SpvOpUndef:
129 return SPI_SECTION_GLOBALS;
130 default:
131 break;
132 }
133
134 if ((op >= SpvOpTypeVoid && op <= SpvOpTypeForwardPointer) ||
135 (op >= SpvOpConstantTrue && op <= SpvOpConstantNull))
136 return SPI_SECTION_GLOBALS;
137
138 return SPI_SECTION_CODE;
139}
140
141/* Starts a new instruction in the given section, returns the section */
143 int nb_words, SpvOp op)
144{
145 SPISectionBuf *sec = &spi->sec[s];
146 spi_write_u32(sec, (nb_words << 16) | op);
147 return sec;
148}
149
150/* Starts a new instruction in the section corresponding to its opcode */
151static inline SPISectionBuf *spi_begin(SPICtx *spi, int nb_words, SpvOp op)
152{
153 return spi_begin_section(spi, spi_opcode_section(op), nb_words, op);
154}
155
156static inline void spi_init(SPICtx *spi)
157{
158 *spi = (SPICtx) { .id = 1 };
159}
160
161static inline void spi_uninit(SPICtx *spi)
162{
163 for (int i = 0; i < SPI_NB_SECTIONS; i++)
164 av_freep(&spi->sec[i].data);
165}
166
167/**
168 * Allocates a buffer containing the module, and returns it in `out`. The caller
169 * takes ownership of the buffer. Returns the module size, or an error code.
170 */
171static inline int spi_end(const SPICtx *spi, uint8_t **out)
172{
173 const uint32_t header[] = {
174 SpvMagicNumber,
175 (1 << 16) | (6 << 8), /* version */
176 0, /* generator */
177 spi->id, /* last bound ID + 1 */
178 0, /* schema */
179 };
180
181 int len = sizeof(header);
182 for (int i = 0; i < SPI_NB_SECTIONS; i++) {
183 if (spi->sec[i].err)
184 return spi->sec[i].err;
185 len += spi->sec[i].off;
186 }
187
188 uint8_t *ptr = *out = av_malloc(len);
189 if (!ptr)
190 return AVERROR(ENOMEM);
191
192 for (int i = 0; i < FF_ARRAY_ELEMS(header); i++, ptr += 4)
193 AV_WL32(ptr, header[i]);
194 for (int i = 0; i < SPI_NB_SECTIONS; i++) {
195 if (spi->sec[i].off)
196 memcpy(ptr, spi->sec[i].data, spi->sec[i].off);
197 ptr += spi->sec[i].off;
198 }
199
200 return len;
201}
202
203static inline void spi_OpCapability(SPICtx *spi, SpvCapability capability)
204{
205 SPISectionBuf *sec = spi_begin(spi, 2, 17);
206 spi_write_u32(sec, capability);
207}
208
209static inline void spi_OpMemoryModel(SPICtx *spi, SpvAddressingModel addressing_model,
210 SpvMemoryModel memory_model)
211{
212 SPISectionBuf *sec = spi_begin(spi, 3, 14);
213 spi_write_u32(sec, addressing_model);
214 spi_write_u32(sec, memory_model);
215}
216
217static int spi_get_id(SPICtx *spi)
218{
219 return spi->id++;
220}
221
222static int spi_strl(const char *str)
223{
224 return FFALIGN(strlen(str) + 1, 4) >> 2;
225}
226
227/* Template: Single source */
228static inline void spi_op_1src(SPICtx *spi, int code, int src1_id)
229{
230 SPISectionBuf *sec = spi_begin(spi, 2, code);
231 spi_write_u32(sec, src1_id);
232}
233#define OP_1SRC(name, code) \
234static inline void spi_ ## name(SPICtx *spi, int src1_id) \
235{ \
236 spi_op_1src(spi, code, src1_id); \
237}
238
239/* Template: Single source, untyped result */
240static inline int spi_op_untypedres_1src(SPICtx *spi, int code, int id,
241 int src1_id)
242{
243 SPISectionBuf *sec = spi_begin(spi, 3, code);
244 spi_write_u32(sec, id);
245 spi_write_u32(sec, src1_id);
246 return id;
247}
248#define OP_UNTYPEDRES1SRC(name, code) \
249static inline int spi_ ## name(SPICtx *spi, int src1_id) \
250{ \
251 return spi_op_untypedres_1src(spi, code, spi_get_id(spi), src1_id); \
252}
253
254/* Template: Single source, typed result */
255static inline int spi_op_res_1src(SPICtx *spi, int code, int id, int type_id,
256 int src1_id)
257{
258 SPISectionBuf *sec = spi_begin(spi, 4, code);
259 spi_write_u32(sec, type_id);
260 spi_write_u32(sec, id);
261 spi_write_u32(sec, src1_id);
262 return id;
263}
264#define OP_RES1SRC(name, code) \
265static inline int spi_ ## name(SPICtx *spi, int type_id, int src1_id) \
266{ \
267 return spi_op_res_1src(spi, code, spi_get_id(spi), type_id, src1_id); \
268}
269
270/* Template: Two sources */
271static inline void spi_op_2src(SPICtx *spi, int code, int src1_id, int src2_id)
272{
273 SPISectionBuf *sec = spi_begin(spi, 3, code);
274 spi_write_u32(sec, src1_id);
275 spi_write_u32(sec, src2_id);
276}
277#define OP_2SRC(name, code) \
278static inline void spi_ ## name(SPICtx *spi, int src1_id, int src2_id) \
279{ \
280 spi_op_2src(spi, code, src1_id, src2_id); \
281}
282
283/* Template: Two sources, untyped result */
284static inline int spi_op_untypedres_2src(SPICtx *spi, int code, int id,
285 int src1_id, int src2_id)
286{
287 SPISectionBuf *sec = spi_begin(spi, 4, code);
288 spi_write_u32(sec, id);
289 spi_write_u32(sec, src1_id);
290 spi_write_u32(sec, src2_id);
291 return id;
292}
293#define OP_UNTYPEDRES2SRC(name, code) \
294static inline int spi_ ## name(SPICtx *spi, int src1_id, int src2_id) \
295{ \
296 return spi_op_untypedres_2src(spi, code, spi_get_id(spi), \
297 src1_id, src2_id); \
298}
299
300/* Template: Two sources, typed result */
301static inline int spi_op_res_2src(SPICtx *spi, int code, int id, int type_id,
302 int src1_id, int src2_id)
303{
304 SPISectionBuf *sec = spi_begin(spi, 5, code);
305 spi_write_u32(sec, type_id);
306 spi_write_u32(sec, id);
307 spi_write_u32(sec, src1_id);
308 spi_write_u32(sec, src2_id);
309 return id;
310}
311#define OP_RES2SRC(name, code) \
312static inline int spi_ ## name(SPICtx *spi, int type_id, int src1_id, int src2_id) \
313{ \
314 return spi_op_res_2src(spi, code, spi_get_id(spi), type_id, \
315 src1_id, src2_id); \
316}
317
318/* Template: Single source, typed result, list */
319static inline int spi_op_res_1src_list(SPICtx *spi, int code, int id, int type_id,
320 int src1_id, const int *args, int nb_args)
321{
322 SPISectionBuf *sec = spi_begin(spi, 4 + nb_args, code);
323 spi_write_u32(sec, type_id);
324 spi_write_u32(sec, id);
325 spi_write_u32(sec, src1_id);
326 for (int i = 0; i < nb_args; i++)
327 spi_write_u32(sec, args[i]);
328 return id;
329}
330
331/* Template: No sources, untyped result, list */
332static inline void spi_op_untypedres_list(SPICtx *spi, int code,
333 int id, const int *args, int nb_args)
334{
335 SPISectionBuf *sec = spi_begin(spi, 2 + nb_args, code);
336 spi_write_u32(sec, id);
337 for (int i = 0; i < nb_args; i++)
338 spi_write_u32(sec, args[i]);
339}
340
341/* Template: Two sources, list */
342static inline void spi_op_2src_list(SPICtx *spi, int code,
343 int src1_id, int src2_id,
344 const int *args, int nb_args)
345{
346 SPISectionBuf *sec = spi_begin(spi, 3 + nb_args, code);
347 spi_write_u32(sec, src1_id);
348 spi_write_u32(sec, src2_id);
349 for (int i = 0; i < nb_args; i++)
350 spi_write_u32(sec, args[i]);
351}
352
353/* Template: Two sources, typed result, list */
354static inline int spi_op_res_2src_list(SPICtx *spi, int code, int id, int type_id,
355 int src1_id, int src2_id,
356 const int *args, int nb_args)
357{
358 SPISectionBuf *sec = spi_begin(spi, 5 + nb_args, code);
359 spi_write_u32(sec, type_id);
360 spi_write_u32(sec, id);
361 spi_write_u32(sec, src1_id);
362 spi_write_u32(sec, src2_id);
363 for (int i = 0; i < nb_args; i++)
364 spi_write_u32(sec, args[i]);
365 return id;
366}
367
368/* Template: Three sources, list */
369static inline void spi_op_3src_list(SPICtx *spi, int code, int src1_id,
370 int src2_id, int src3_id,
371 const int *args, int nb_args)
372{
373 SPISectionBuf *sec = spi_begin(spi, 4 + nb_args, code);
374 spi_write_u32(sec, src1_id);
375 spi_write_u32(sec, src2_id);
376 spi_write_u32(sec, src3_id);
377 for (int i = 0; i < nb_args; i++)
378 spi_write_u32(sec, args[i]);
379}
380
381OP_RES1SRC(OpImageQuerySize, 104)
382
383OP_RES1SRC(OpConvertFToU, 109)
384OP_RES1SRC(OpConvertFToS, 110)
385OP_RES1SRC(OpConvertSToF, 111)
386OP_RES1SRC(OpConvertUToF, 112)
387OP_RES1SRC(OpBitcast, 124)
388
389OP_RES1SRC(OpAny, 154)
390
391#define spi_OpConstantComposite(spi, res_type, src, ...) \
392 spi_op_res_1src_list(spi, 44, spi_get_id(spi), res_type, src, \
393 SPI_ARGS(__VA_ARGS__))
394
395#define spi_OpAccessChain(spi, res_type, ptr_id, ...) \
396 spi_op_res_1src_list(spi, 65, spi_get_id(spi), res_type, ptr_id, \
397 SPI_ARGS(__VA_ARGS__))
398
399#define spi_OpCompositeConstruct(spi, res_type, src, ...) \
400 spi_op_res_1src_list(spi, 80, spi_get_id(spi), res_type, src, \
401 SPI_ARGS(__VA_ARGS__))
402
403#define spi_OpCompositeExtract(spi, res_type, src, ...) \
404 spi_op_res_1src_list(spi, 81, spi_get_id(spi), res_type, src, \
405 SPI_ARGS(__VA_ARGS__))
406
407OP_RES2SRC(OpIAdd, 128)
408OP_RES2SRC(OpFAdd, 129)
409OP_RES2SRC(OpIMul, 132)
410OP_RES2SRC(OpFMul, 133)
411OP_RES2SRC(OpVectorTimesScalar, 142)
412OP_RES2SRC(OpMatrixTimesVector, 145)
413OP_RES2SRC(OpDot, 148)
414
415OP_RES2SRC(OpIEqual, 170)
416OP_RES2SRC(OpINotEqual, 171)
417OP_RES2SRC(OpUGreaterThan, 172)
418OP_RES2SRC(OpSGreaterThan, 173)
419OP_RES2SRC(OpUGreaterThanEqual, 174)
420OP_RES2SRC(OpSGreaterThanEqual, 175)
421OP_RES2SRC(OpULessThan, 176)
422OP_RES2SRC(OpSLessThan, 177)
423OP_RES2SRC(OpULessThanEqual, 178)
424OP_RES2SRC(OpSLessThanEqual, 179)
425
426OP_RES2SRC(OpShiftRightLogical, 194)
427OP_RES2SRC(OpShiftLeftLogical, 196)
428
429OP_RES2SRC(OpBitwiseOr, 197)
430OP_RES2SRC(OpBitwiseAnd, 199)
431OP_1SRC(OpReturnValue, 254)
432
433#define spi_OpExtInst(spi, res_type, instr_id, set_id, ...) \
434 spi_op_res_2src_list(spi, 12, spi_get_id(spi), res_type, instr_id, set_id, \
435 SPI_ARGS(__VA_ARGS__))
436
437#define spi_OpTypeStruct(spi, id, ...) \
438 spi_op_untypedres_list(spi, 30, id, \
439 SPI_ARGS(__VA_ARGS__))
440
441#define spi_OpDecorate(spi, target, deco, ...) \
442 spi_op_2src_list(spi, 71, target, deco, \
443 SPI_ARGS(__VA_ARGS__))
444
445#define spi_OpMemberDecorate(spi, type, target, deco, ...) \
446 spi_op_3src_list(spi, 72, type, target, deco, \
447 SPI_ARGS(__VA_ARGS__))
448
449#define spi_OpVectorShuffle(spi, res_type, src1, src2, ...) \
450 spi_op_res_2src_list(spi, 79, spi_get_id(spi), res_type, src1, src2, \
451 SPI_ARGS(__VA_ARGS__))
452
453#define spi_OpCompositeInsert(spi, res_type, src1, src2, ...) \
454 spi_op_res_2src_list(spi, 82, spi_get_id(spi), res_type, src1, src2, \
455 SPI_ARGS(__VA_ARGS__))
456
457static inline void spi_OpEntryPoint(SPICtx *spi, SpvExecutionModel execution_model,
458 int entry_point_id, const char *name,
459 const int *args, int nb_args)
460{
461 SPISectionBuf *sec = spi_begin(spi, (3 + nb_args) + spi_strl(name), 15);
462 spi_write_u32(sec, execution_model);
463 spi_write_u32(sec, entry_point_id);
464 spi_put_str(sec, name);
465 for (int i = 0; i < nb_args; i++)
466 spi_write_u32(sec, args[i]);
467}
468
469static inline void spi_OpName(SPICtx *spi, int target_id, const char *name)
470{
471 SPISectionBuf *sec = spi_begin(spi, 2 + spi_strl(name), 5);
472 spi_write_u32(sec, target_id);
473 spi_put_str(sec, name);
474}
475
476static inline void spi_OpExtension(SPICtx *spi, const char *name)
477{
478 SPISectionBuf *sec = spi_begin(spi, 1 + spi_strl(name), 10);
479 spi_put_str(sec, name);
480}
481
482static inline int spi_OpExtInstImport(SPICtx *spi, const char *name)
483{
484 SPISectionBuf *sec = spi_begin(spi, 2 + spi_strl(name), 11);
485 spi_write_u32(sec, spi->id);
486 spi_put_str(sec, name);
487 return spi_get_id(spi);
488}
489
490static inline void spi_OpExecutionMode(SPICtx *spi, int entry_point_id,
491 SpvExecutionMode mode, int *s, int nb_s)
492{
493 SPISectionBuf *sec = spi_begin(spi, 3 + nb_s, 16);
494 spi_write_u32(sec, entry_point_id);
495 spi_write_u32(sec, mode);
496 for (int i = 0; i < nb_s; i++)
497 spi_write_u32(sec, s[i]);
498}
499
500static inline int spi_OpUndef(SPICtx *spi, int type_id)
501{
502 SPISectionBuf *sec = spi_begin(spi, 3, 1);
503 spi_write_u32(sec, type_id);
504 spi_write_u32(sec, spi->id);
505 return spi_get_id(spi);
506}
507
508static inline int spi_OpTypeVoid(SPICtx *spi)
509{
510 SPISectionBuf *sec = spi_begin(spi, 2, 19);
511 spi_write_u32(sec, spi->id);
512 return spi_get_id(spi);
513}
514
515static inline int spi_OpTypeBool(SPICtx *spi)
516{
517 SPISectionBuf *sec = spi_begin(spi, 2, 20);
518 spi_write_u32(sec, spi->id);
519 spi->bool_type_id = spi->id;
520 return spi_get_id(spi);
521}
522
523OP_UNTYPEDRES2SRC(OpTypeInt, 21)
524OP_UNTYPEDRES1SRC(OpTypeFloat, 22)
525OP_UNTYPEDRES2SRC(OpTypeVector, 23)
526OP_UNTYPEDRES2SRC(OpTypeMatrix, 24)
527
528static inline int spi_OpTypeFloatEnc(SPICtx *spi, int width,
529 SpvFPEncoding floating_point_encoding)
530{
531 SPISectionBuf *sec = spi_begin(spi, 4, 22);
532 spi_write_u32(sec, spi->id);
533 spi_write_u32(sec, width);
534 spi_write_u32(sec, floating_point_encoding);
535 return spi_get_id(spi);
536}
537
538static inline int spi_OpTypeImage(SPICtx *spi, int sampled_type_id, SpvDim dim,
539 int depth, int arrayed, int ms, int sampled,
540 SpvImageFormat image_format)
541{
542 SPISectionBuf *sec = spi_begin(spi, 9, 25);
543 spi_write_u32(sec, spi->id);
544 spi_write_u32(sec, sampled_type_id);
545 spi_write_u32(sec, dim - 1);
546 spi_write_u32(sec, depth);
547 spi_write_u32(sec, arrayed);
548 spi_write_u32(sec, ms);
549 spi_write_u32(sec, sampled);
550 spi_write_u32(sec, image_format);
551 /* TODO: if implementing kernel mode, write an access qualifier here */
552 return spi_get_id(spi);
553}
554
555static inline int spi_OpTypeArray(SPICtx *spi, int element_type_id, int id,
556 int length_id)
557{
558 SPISectionBuf *sec = spi_begin(spi, 4, 28);
559 spi_write_u32(sec, id);
560 spi_write_u32(sec, element_type_id);
561 spi_write_u32(sec, length_id);
562 return id;
563}
564
565static inline int spi_OpTypeRuntimeArray(SPICtx *spi, int element_type_id)
566{
567 SPISectionBuf *sec = spi_begin(spi, 3, 29);
568 spi_write_u32(sec, spi->id);
569 spi_write_u32(sec, element_type_id);
570 return spi_get_id(spi);
571}
572
573static inline int spi_OpTypePointer(SPICtx *spi, SpvStorageClass storage_class,
574 int type_id)
575{
576 SPISectionBuf *sec = spi_begin(spi, 4, 32);
577 spi_write_u32(sec, spi->id);
578 spi_write_u32(sec, storage_class);
579 spi_write_u32(sec, type_id);
580 return spi_get_id(spi);
581}
582
583static inline int spi_OpTypeFunction(SPICtx *spi, int return_type_id,
584 const int *args, int nb_args)
585{
586 SPISectionBuf *sec = spi_begin(spi, 3 + nb_args, 33);
587 spi_write_u32(sec, spi->id);
588 spi_write_u32(sec, return_type_id);
589 for (int i = 0; i < nb_args; i++)
590 spi_write_u32(sec, args[i]);
591 return spi_get_id(spi);
592}
593
594static inline void spi_OpFunction(SPICtx *spi, int fn_id, int result_type_id,
595 SpvFunctionControlMask function_control,
596 int function_type_id)
597{
598 SPISectionBuf *sec = spi_begin(spi, 5, 54);
599 spi_write_u32(sec, result_type_id);
600 spi_write_u32(sec, fn_id);
601 spi_write_u32(sec, function_control);
602 spi_write_u32(sec, function_type_id);
603}
604
605static inline int spi_OpLabel(SPICtx *spi, int label_id)
606{
607 SPISectionBuf *sec = spi_begin(spi, 2, 248);
608 spi_write_u32(sec, label_id);
609 return label_id;
610}
611
612static inline void spi_OpReturn(SPICtx *spi)
613{
614 spi_begin(spi, 1, 253);
615}
616
617static inline void spi_OpFunctionEnd(SPICtx *spi)
618{
619 spi_begin(spi, 1, 56);
620}
621
622static inline int spi_OpVariable(SPICtx *spi, int var_id, int ptr_type_id,
623 SpvStorageClass storage_class, int initializer_id)
624{
625 SPISectionBuf *sec = spi_begin_section(spi, storage_class == SpvStorageClassFunction ?
627 4 + !!initializer_id, SpvOpVariable);
628 spi_write_u32(sec, ptr_type_id);
629 spi_write_u32(sec, var_id);
630 spi_write_u32(sec, storage_class);
631 if (initializer_id)
632 spi_write_u32(sec, initializer_id);
633 return var_id;
634}
635
636static inline int spi_OpConstantTrue(SPICtx *spi)
637{
638 SPISectionBuf *sec = spi_begin(spi, 3, 41);
639 spi_write_u32(sec, spi->bool_type_id);
640 spi_write_u32(sec, spi->id);
641 return spi_get_id(spi);
642}
643
644static inline int spi_OpConstantFalse(SPICtx *spi)
645{
646 SPISectionBuf *sec = spi_begin(spi, 3, 42);
647 spi_write_u32(sec, spi->bool_type_id);
648 spi_write_u32(sec, spi->id);
649 return spi_get_id(spi);
650}
651
652static inline int spi_OpConstantUInt(SPICtx *spi, int type_id, uint32_t val)
653{
654 SPISectionBuf *sec = spi_begin(spi, 4, 43);
655 spi_write_u32(sec, type_id);
656 spi_write_u32(sec, spi->id);
657 spi_write_u32(sec, val);
658 return spi_get_id(spi);
659}
660
661static inline int spi_OpConstantUInt64(SPICtx *spi, int type_id, uint64_t val)
662{
663 SPISectionBuf *sec = spi_begin(spi, 5, 43);
664 spi_write_u32(sec, type_id);
665 spi_write_u32(sec, spi->id);
666 spi_write_u32(sec, val & UINT32_MAX);
667 spi_write_u32(sec, val >> 32);
668 return spi_get_id(spi);
669}
670
671static inline int spi_OpConstantInt(SPICtx *spi, int type_id, int val)
672{
673 uint32_t vu = (union { int i; uint32_t u; }){val}.u;
674 return spi_OpConstantUInt(spi, type_id, vu);
675}
676
677static inline int spi_OpConstantInt64(SPICtx *spi, int type_id, int64_t val)
678{
679 uint64_t vu = (union { int64_t i; uint64_t u; }){val}.u;
680 return spi_OpConstantUInt64(spi, type_id, vu);
681}
682
683static inline int spi_OpConstantFloat(SPICtx *spi, int type_id, float val)
684{
685 uint32_t vu = (union { float f; uint32_t u; }){val}.u;
686 return spi_OpConstantUInt(spi, type_id, vu);
687}
688
689static inline int spi_OpConstantDouble(SPICtx *spi, int type_id, double val)
690{
691 uint64_t vu = (union { double d; uint64_t u; }){val}.u;
692 return spi_OpConstantUInt64(spi, type_id, vu);
693}
694
695static inline int spi_OpLoad(SPICtx *spi, int result_type_id, int ptr_id,
696 SpvMemoryAccessMask memory_access, int align)
697{
698 int is_aligned = !!(memory_access & SpvMemoryAccessAlignedMask);
699 SPISectionBuf *sec = spi_begin(spi, 5 + is_aligned, 61);
700 spi_write_u32(sec, result_type_id);
701 spi_write_u32(sec, spi->id);
702 spi_write_u32(sec, ptr_id);
703 spi_write_u32(sec, memory_access);
704 if (is_aligned)
705 spi_write_u32(sec, align);
706 return spi_get_id(spi);
707}
708
709static inline void spi_OpStore(SPICtx *spi, int ptr_id, int obj_id,
710 SpvMemoryAccessMask memory_access, int align)
711{
712 int is_aligned = !!(memory_access & SpvMemoryAccessAlignedMask);
713 SPISectionBuf *sec = spi_begin(spi, 4 + is_aligned, 62);
714 spi_write_u32(sec, ptr_id);
715 spi_write_u32(sec, obj_id);
716 spi_write_u32(sec, memory_access);
717 if (is_aligned)
718 spi_write_u32(sec, align);
719}
720
721static inline void spi_OpSelectionMerge(SPICtx *spi, int merge_block,
722 SpvSelectionControlMask selection_control)
723{
724 SPISectionBuf *sec = spi_begin(spi, 3, 247);
725 spi_write_u32(sec, merge_block);
726 spi_write_u32(sec, selection_control);
727}
728
729static inline void spi_OpBranchConditional(SPICtx *spi, int cond_id,
730 int true_label, int false_label,
731 uint32_t branch_weights)
732{
733 SPISectionBuf *sec = spi_begin(spi, 4 + 2*(!!branch_weights), 250);
734 spi_write_u32(sec, cond_id);
735 spi_write_u32(sec, true_label);
736 spi_write_u32(sec, false_label);
737 if (branch_weights) {
738 spi_write_u32(sec, branch_weights >> 16);
739 spi_write_u32(sec, branch_weights & UINT16_MAX);
740 }
741}
742
743static inline int spi_OpImageRead(SPICtx *spi, int result_type_id, int img_id,
744 int pos_id, SpvImageOperandsMask image_operands)
745{
746 SPISectionBuf *sec = spi_begin(spi, 5 + (!!image_operands), 98);
747 spi_write_u32(sec, result_type_id);
748 spi_write_u32(sec, spi->id);
749 spi_write_u32(sec, img_id);
750 spi_write_u32(sec, pos_id);
751 if (image_operands)
752 spi_write_u32(sec, image_operands);
753 return spi_get_id(spi);
754}
755
756static inline void spi_OpImageWrite(SPICtx *spi, int img_id, int pos_id,
757 int src_id, SpvImageOperandsMask image_operands)
758{
759 SPISectionBuf *sec = spi_begin(spi, 4 + (!!image_operands), 99);
760 spi_write_u32(sec, img_id);
761 spi_write_u32(sec, pos_id);
762 spi_write_u32(sec, src_id);
763 if (image_operands)
764 spi_write_u32(sec, image_operands);
765}
766
767#endif /* SWSCALE_VULKAN_SPVASM_H */
static double val(void *priv, double ch)
Definition aeval.c:77
static FILE * out
simple assert() macros that are a bit more flexible than ISO C assert().
static const uint8_t *BS_FUNC align(BSCTX *bc)
Skip bits to a byte boundary.
#define i(width, name, range_min, range_max)
Definition cbs_h264.c:63
#define f(width, name)
Definition cbs_vp8.c:236
#define s(width, name)
Definition cbs_vp9.c:198
#define NULL
Definition coverity.c:32
long long int64_t
Definition coverity.c:34
enum AVCodecID id
Definition dts2pts.c:612
error code definitions
#define AVERROR(e)
Definition error.h:45
void * av_fast_realloc(void *ptr, unsigned int *size, size_t min_size)
Reallocate the given buffer if it is not large enough, otherwise do nothing.
Definition mem.c:601
#define AV_WL32(p, v)
static int op(uint8_t **dst, const uint8_t *dst_end, GetByteContext *gb, int pixel, int count, int *x, int width, int linesize)
Perform decode operation.
Definition anm.c:76
#define u(width, name, range_min, range_max)
Definition cbs_apv.c:68
#define FFALIGN(x, a)
Definition macros.h:78
Memory handling functions.
const char data[16]
Definition mxf.c:149
#define av_malloc(s)
Definition ops_static.c:52
const char * name
Definition qsvenc.c:142
static const uint8_t header[24]
Definition sdr2.c:68
#define FF_ARRAY_ELEMS(a)
const uint8_t * code
Definition spdifenc.c:433
static void spi_uninit(SPICtx *spi)
Definition spvasm.h:161
static int spi_OpTypeFunction(SPICtx *spi, int return_type_id, const int *args, int nb_args)
Definition spvasm.h:583
static void spi_write_u32(SPISectionBuf *sec, uint32_t v)
Definition spvasm.h:93
static int spi_op_res_2src_list(SPICtx *spi, int code, int id, int type_id, int src1_id, int src2_id, const int *args, int nb_args)
Definition spvasm.h:354
static int spi_OpVariable(SPICtx *spi, int var_id, int ptr_type_id, SpvStorageClass storage_class, int initializer_id)
Definition spvasm.h:622
static int spi_OpConstantUInt(SPICtx *spi, int type_id, uint32_t val)
Definition spvasm.h:652
static void spi_OpCapability(SPICtx *spi, SpvCapability capability)
Definition spvasm.h:203
static SPISectionBuf * spi_begin_section(SPICtx *spi, SPISection s, int nb_words, SpvOp op)
Definition spvasm.h:142
static void spi_OpMemoryModel(SPICtx *spi, SpvAddressingModel addressing_model, SpvMemoryModel memory_model)
Definition spvasm.h:209
static int spi_OpConstantDouble(SPICtx *spi, int type_id, double val)
Definition spvasm.h:689
static uint8_t * spi_append(SPISectionBuf *sec, int len)
Definition spvasm.h:80
static int spi_op_res_1src_list(SPICtx *spi, int code, int id, int type_id, int src1_id, const int *args, int nb_args)
Definition spvasm.h:319
static int spi_OpConstantFalse(SPICtx *spi)
Definition spvasm.h:644
static void spi_OpFunctionEnd(SPICtx *spi)
Definition spvasm.h:617
static void spi_OpReturn(SPICtx *spi)
Definition spvasm.h:612
static int spi_OpImageRead(SPICtx *spi, int result_type_id, int img_id, int pos_id, SpvImageOperandsMask image_operands)
Definition spvasm.h:743
static int spi_OpTypeRuntimeArray(SPICtx *spi, int element_type_id)
Definition spvasm.h:565
static int spi_OpTypeArray(SPICtx *spi, int element_type_id, int id, int length_id)
Definition spvasm.h:555
#define OP_UNTYPEDRES2SRC(name, code)
Definition spvasm.h:293
static void spi_op_1src(SPICtx *spi, int code, int src1_id)
Definition spvasm.h:228
static void spi_OpBranchConditional(SPICtx *spi, int cond_id, int true_label, int false_label, uint32_t branch_weights)
Definition spvasm.h:729
static int spi_OpTypeImage(SPICtx *spi, int sampled_type_id, SpvDim dim, int depth, int arrayed, int ms, int sampled, SpvImageFormat image_format)
Definition spvasm.h:538
static int spi_end(const SPICtx *spi, uint8_t **out)
Allocates a buffer containing the module, and returns it in out.
Definition spvasm.h:171
#define OP_UNTYPEDRES1SRC(name, code)
Definition spvasm.h:248
static int spi_OpTypeFloatEnc(SPICtx *spi, int width, SpvFPEncoding floating_point_encoding)
Definition spvasm.h:528
static int spi_OpConstantFloat(SPICtx *spi, int type_id, float val)
Definition spvasm.h:683
static int spi_op_untypedres_1src(SPICtx *spi, int code, int id, int src1_id)
Definition spvasm.h:240
static void spi_op_2src(SPICtx *spi, int code, int src1_id, int src2_id)
Definition spvasm.h:271
static int spi_OpConstantInt64(SPICtx *spi, int type_id, int64_t val)
Definition spvasm.h:677
static int spi_OpLoad(SPICtx *spi, int result_type_id, int ptr_id, SpvMemoryAccessMask memory_access, int align)
Definition spvasm.h:695
static void spi_OpExecutionMode(SPICtx *spi, int entry_point_id, SpvExecutionMode mode, int *s, int nb_s)
Definition spvasm.h:490
static SPISectionBuf * spi_begin(SPICtx *spi, int nb_words, SpvOp op)
Definition spvasm.h:151
static int spi_OpConstantInt(SPICtx *spi, int type_id, int val)
Definition spvasm.h:671
static void spi_op_3src_list(SPICtx *spi, int code, int src1_id, int src2_id, int src3_id, const int *args, int nb_args)
Definition spvasm.h:369
#define OP_RES2SRC(name, code)
Definition spvasm.h:311
static int spi_OpConstantUInt64(SPICtx *spi, int type_id, uint64_t val)
Definition spvasm.h:661
static void spi_OpEntryPoint(SPICtx *spi, SpvExecutionModel execution_model, int entry_point_id, const char *name, const int *args, int nb_args)
Definition spvasm.h:457
static void spi_OpName(SPICtx *spi, int target_id, const char *name)
Definition spvasm.h:469
static int spi_OpLabel(SPICtx *spi, int label_id)
Definition spvasm.h:605
#define OP_RES1SRC(name, code)
Definition spvasm.h:264
static int spi_op_res_1src(SPICtx *spi, int code, int id, int type_id, int src1_id)
Definition spvasm.h:255
static void spi_OpStore(SPICtx *spi, int ptr_id, int obj_id, SpvMemoryAccessMask memory_access, int align)
Definition spvasm.h:709
static void spi_init(SPICtx *spi)
Definition spvasm.h:156
static int spi_OpUndef(SPICtx *spi, int type_id)
Definition spvasm.h:500
static int spi_OpTypeBool(SPICtx *spi)
Definition spvasm.h:515
static int spi_OpTypePointer(SPICtx *spi, SpvStorageClass storage_class, int type_id)
Definition spvasm.h:573
static void spi_OpFunction(SPICtx *spi, int fn_id, int result_type_id, SpvFunctionControlMask function_control, int function_type_id)
Definition spvasm.h:594
static int spi_op_res_2src(SPICtx *spi, int code, int id, int type_id, int src1_id, int src2_id)
Definition spvasm.h:301
static void spi_put_str(SPISectionBuf *sec, const char *str)
Definition spvasm.h:100
static int spi_op_untypedres_2src(SPICtx *spi, int code, int id, int src1_id, int src2_id)
Definition spvasm.h:284
#define OP_1SRC(name, code)
Definition spvasm.h:233
static int spi_get_id(SPICtx *spi)
Definition spvasm.h:217
static int spi_strl(const char *str)
Definition spvasm.h:222
static void spi_OpExtension(SPICtx *spi, const char *name)
Definition spvasm.h:476
static void spi_op_2src_list(SPICtx *spi, int code, int src1_id, int src2_id, const int *args, int nb_args)
Definition spvasm.h:342
static int spi_OpExtInstImport(SPICtx *spi, const char *name)
Definition spvasm.h:482
SPISection
Definition spvasm.h:55
@ SPI_SECTION_DEBUG
Definition spvasm.h:57
@ SPI_SECTION_CODE
Definition spvasm.h:60
@ SPI_SECTION_GLOBALS
Definition spvasm.h:59
@ SPI_NB_SECTIONS
Definition spvasm.h:61
@ SPI_SECTION_DECORATIONS
Definition spvasm.h:58
@ SPI_SECTION_HEADER
Definition spvasm.h:56
static void spi_OpSelectionMerge(SPICtx *spi, int merge_block, SpvSelectionControlMask selection_control)
Definition spvasm.h:721
static SPISection spi_opcode_section(SpvOp op)
Definition spvasm.h:112
static void spi_op_untypedres_list(SPICtx *spi, int code, int id, const int *args, int nb_args)
Definition spvasm.h:332
static int spi_OpTypeVoid(SPICtx *spi)
Definition spvasm.h:508
static int spi_OpConstantTrue(SPICtx *spi)
Definition spvasm.h:636
static void spi_OpImageWrite(SPICtx *spi, int img_id, int pos_id, int src_id, SpvImageOperandsMask image_operands)
Definition spvasm.h:756
int id
Definition spvasm.h:76
int bool_type_id
Definition spvasm.h:75
SPISectionBuf sec[SPI_NB_SECTIONS]
Definition spvasm.h:73
unsigned int size
Definition spvasm.h:66
uint8_t * data
Definition spvasm.h:65
Definition swscale.c:85
#define av_freep(p)
#define width
Definition dsp.h:99
int dim
int len