FFmpeg
Loading...
Searching...
No Matches
ops.c
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#include "libavutil/mem.h"
22#include "libavutil/refstruct.h"
23
24#include "../graph.h"
25#include "../ops_internal.h"
26#include "../swscale_internal.h"
27#include "../uops.h"
28
29#include "ops.h"
30
31#include "spvasm.h"
32
33static void vk_ops_ctx_uninit(AVRefStructOpaque opaque, void *obj)
34{
36
37 ff_vk_uninit(&s->vkctx);
38}
39
41{
42 int err;
44
45 if (!c->hw_priv) {
46 c->hw_priv = av_refstruct_alloc_ext(sizeof(FFVulkanOpsCtx), 0, NULL,
48 if (!c->hw_priv)
49 return AVERROR(ENOMEM);
50 }
51
52 FFVulkanOpsCtx *s = c->hw_priv;
53 if (s->vkctx.device_ref) {
54 if (s->vkctx.device_ref->data == dev_ref->data)
55 return 0;
56 /* Reinitialize with new context */
57 ff_vk_uninit(&s->vkctx);
58 }
59
60 err = ff_vk_init(&s->vkctx, sws, dev_ref, NULL);
61 if (err < 0)
62 return err;
63
64 s->qf = ff_vk_qf_find(&s->vkctx, VK_QUEUE_COMPUTE_BIT, 0);
65 if (!s->qf) {
66 av_log(sws, AV_LOG_ERROR, "Device has no compute queues\n");
67 return AVERROR(ENOTSUP);
68 }
69
70 return 0;
71}
72
74{
76 FFVulkanOpsCtx *s = c->hw_priv;
77 return s ? s->vkctx.device_ref : NULL;
78}
79
80#define MAX_DITHER_BUFS 4
81#define MAX_FILT_BUFS 4
82#define MAX_DATA_BUFS (MAX_DITHER_BUFS + MAX_FILT_BUFS*4)
83
94
95static void spirv_process(const SwsFrame *dst, const SwsFrame *src,
96 int y, int h, const SwsPass *pass)
97{
98 VulkanPriv *p = (VulkanPriv *) pass->priv;
99 FFVkExecContext *ec = ff_vk_exec_get(&p->s->vkctx, &p->e);
100 FFVulkanFunctions *vk = &p->s->vkctx.vkfn;
101 int err = ff_vk_exec_start(&p->s->vkctx, ec);
102 if (err < 0)
103 goto error;
104
105 AVFrame *src_f = (AVFrame *) src->avframe;
106 AVFrame *dst_f = (AVFrame *) dst->avframe;
107 err = ff_vk_exec_add_dep_frame(&p->s->vkctx, ec, src_f,
108 VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT,
109 VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT);
110 if (err < 0)
111 goto fail;
112 err = ff_vk_exec_add_dep_frame(&p->s->vkctx, ec, dst_f,
113 VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT,
114 VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT);
115 if (err < 0)
116 goto fail;
117
118 VkImageView src_views[AV_NUM_DATA_POINTERS];
119 VkImageView dst_views[AV_NUM_DATA_POINTERS];
120 err = ff_vk_create_imageviews_fmt(&p->s->vkctx, ec, src_views, src_f,
121 p->src_view_fmt);
122 if (err < 0)
123 goto fail;
124 err = ff_vk_create_imageviews_fmt(&p->s->vkctx, ec, dst_views, dst_f,
125 p->dst_view_fmt);
126 if (err < 0)
127 goto fail;
128
129 ff_vk_shader_update_img_array(&p->s->vkctx, ec, &p->shd, src_f, src_views,
130 0, 0, VK_IMAGE_LAYOUT_GENERAL, VK_NULL_HANDLE);
131 ff_vk_shader_update_img_array(&p->s->vkctx, ec, &p->shd, dst_f, dst_views,
132 0, 1, VK_IMAGE_LAYOUT_GENERAL, VK_NULL_HANDLE);
133
134 int nb_img_bar = 0;
135 VkImageMemoryBarrier2 img_bar[8];
136 ff_vk_frame_barrier(&p->s->vkctx, ec, src_f, img_bar, &nb_img_bar,
137 VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT,
138 VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT,
139 VK_ACCESS_SHADER_READ_BIT,
140 VK_IMAGE_LAYOUT_GENERAL,
141 VK_QUEUE_FAMILY_IGNORED);
142 ff_vk_frame_barrier(&p->s->vkctx, ec, dst_f, img_bar, &nb_img_bar,
143 VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT,
144 VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT,
145 VK_ACCESS_SHADER_WRITE_BIT,
146 VK_IMAGE_LAYOUT_GENERAL,
147 VK_QUEUE_FAMILY_IGNORED);
148 vk->CmdPipelineBarrier2(ec->buf, &(VkDependencyInfo) {
149 .sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO,
150 .pImageMemoryBarriers = img_bar,
151 .imageMemoryBarrierCount = nb_img_bar,
152 });
153
154 if (p->interlaced) {
155 uint32_t field = pass->graph ? pass->graph->dst.field : 0;
156 ff_vk_shader_update_push_const(&p->s->vkctx, ec, &p->shd,
157 VK_SHADER_STAGE_COMPUTE_BIT,
158 0, sizeof(field), &field);
159 }
160
161 ff_vk_exec_bind_shader(&p->s->vkctx, ec, &p->shd);
162
163 vk->CmdDispatch(ec->buf,
164 FFALIGN(dst->width, p->shd.lg_size[0])/p->shd.lg_size[0],
165 FFALIGN(dst->height, p->shd.lg_size[1])/p->shd.lg_size[1],
166 1);
167
168 err = ff_vk_exec_submit(&p->s->vkctx, ec);
169 if (err < 0)
170 goto error;
171 ff_vk_exec_wait(&p->s->vkctx, ec);
172 return;
173
174fail:
175 ff_vk_exec_discard(&p->s->vkctx, ec);
176error:
177 /* SwsPassFunc has no way to return errors */
178 av_log(&p->s->vkctx, AV_LOG_ERROR, "Vulkan pass failed: %s\n",
179 av_err2str(err));
180}
181
182static void spirv_free(void *priv)
183{
184 VulkanPriv *p = priv;
185 ff_vk_exec_pool_free(&p->s->vkctx, &p->e);
186 ff_vk_shader_free(&p->s->vkctx, &p->shd);
187 for (int i = 0; i < p->nb_data_bufs; i++)
188 ff_vk_free_buf(&p->s->vkctx, &p->data_bufs[i]);
189 av_refstruct_unref(&p->s);
190 av_free(priv);
191}
192
194 FFVkBuffer *buf)
195{
196 int err;
197
198 /* Weights */
199 err = ff_vk_create_buf(&s->vkctx, buf,
200 wd->num_weights*sizeof(float) +
201 wd->dst_size*sizeof(int32_t), NULL, NULL,
202 VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
203 VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT |
204 VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT);
205 if (err < 0)
206 goto fail;
207
208 float *weights_data;
209 err = ff_vk_map_buffer(&s->vkctx, buf,
210 (uint8_t **)&weights_data, 0);
211 if (err < 0)
212 goto fail;
213 for (int i = 0; i < wd->num_weights; i++)
214 weights_data[i] = (float) wd->weights[i] / SWS_FILTER_SCALE;
215
216 memcpy(weights_data + wd->num_weights,
217 wd->offsets, wd->dst_size*sizeof(int32_t));
218
219 ff_vk_unmap_buffer(&s->vkctx, buf, 1);
220
221 return 0;
222
223fail:
224 ff_vk_free_buf(&s->vkctx, buf);
225 return err;
226}
227
228static int create_dither_buf(FFVulkanOpsCtx *s, const SwsUOp *uop,
229 FFVkBuffer *buf)
230{
231 int err;
232
233 const int size = 1 << uop->par.dither.size_log2;
234 const int rows = ff_sws_dither_height(&uop->par.dither);
235 err = ff_vk_create_buf(&s->vkctx, buf,
236 rows*size*sizeof(float), NULL, NULL,
237 VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
238 VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT |
239 VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT);
240 if (err < 0)
241 return err;
242
243 float *dither_data;
244 err = ff_vk_map_buffer(&s->vkctx, buf, (uint8_t **)&dither_data, 0);
245 if (err < 0)
246 goto fail;
247
248 for (int i = 0; i < rows*size; i++)
249 dither_data[i] = uop->data.ptr[i].f32;
250
251 ff_vk_unmap_buffer(&s->vkctx, buf, 1);
252
253 return 0;
254
255fail:
256 ff_vk_free_buf(&s->vkctx, buf);
257 return err;
258}
259
260typedef struct SPIRVIDs {
261 /* Entrypoint interface variables */
262 int iface[3 + MAX_DATA_BUFS + 1];
264
268
269 int glfn;
270 int ep;
271
272 /* Types */
279
280 /* Define vector types */
284
286
290
291 /* Constants */
292 int f32_0;
293 int u32_cid[5];
294
296
299
302
303 /* Pointer types for images */
307
310
311 /* Interlaced handling */
318
323
324 /* Per-invocation state of the main function */
325 int in_img[4], out_img[4]; /* image handles, indexed by plane */
326 int gid, gi2; /* invocation position, as uvec2 and ivec2 */
327 int src_gid, dst_gid; /* image position to read from / write to */
328} SPIRVIDs;
329
330/* All integer pixel types are represented as 32-bit unsigned integers */
331static int type_scalar(const SPIRVIDs *id, SwsPixelType type)
332{
334 return ff_sws_pixel_type_is_int(type) ? id->u32_type : id->f32_type;
335}
336
337static int type_vec4(const SPIRVIDs *id, SwsPixelType type)
338{
340 return ff_sws_pixel_type_is_int(type) ? id->u32vec4_type : id->f32vec4_type;
341}
342
343static int const_zero(const SPIRVIDs *id, SwsPixelType type)
344{
346 return ff_sws_pixel_type_is_int(type) ? id->u32_cid[0] : id->f32_0;
347}
348
349static int const_pixel(SPICtx *spi, const SPIRVIDs *id, SwsPixelType type,
350 SwsPixel px)
351{
352 switch (type) {
353 case SWS_PIXEL_U8: return spi_OpConstantUInt(spi, id->u32_type, px.u8);
354 case SWS_PIXEL_U16: return spi_OpConstantUInt(spi, id->u32_type, px.u16);
355 case SWS_PIXEL_U32: return spi_OpConstantUInt(spi, id->u32_type, px.u32);
356 case SWS_PIXEL_F32: return spi_OpConstantFloat(spi, id->f32_type, px.f32);
357 default: break;
358 }
359
360 av_unreachable("Invalid pixel type!");
361 return 0;
362}
363
364static int const_splat(SPICtx *spi, const SPIRVIDs *id, SwsPixelType type,
365 SwsPixel px)
366{
367 const int c = const_pixel(spi, id, type, px);
368 return spi_OpConstantComposite(spi, type_vec4(id, type), c, c, c, c);
369}
370
371/* Shift and mask vectors for (un)packing each component */
372static void define_pack_consts(SPICtx *spi, const SPIRVIDs *id, const SwsUOp *uop,
373 int *shift_id, int *mask_id)
374{
375 uint64_t mask[4];
376 int shift[4], tmp[4];
378 for (int i = 0; i < 4; i++)
379 tmp[i] = spi_OpConstantUInt(spi, id->u32_type, shift[i]);
380 *shift_id = spi_OpConstantComposite(spi, id->u32vec4_type,
381 tmp[0], tmp[1], tmp[2], tmp[3]);
382 for (int i = 0; i < 4; i++)
383 tmp[i] = spi_OpConstantUInt(spi, id->u32_type, mask[i]);
384 *mask_id = spi_OpConstantComposite(spi, id->u32vec4_type,
385 tmp[0], tmp[1], tmp[2], tmp[3]);
386}
387
388/* Arithmetic on operands of the given pixel type */
389static int emit_add(SPICtx *spi, SwsPixelType type, int res_type, int a, int b)
390{
391 return ff_sws_pixel_type_is_int(type) ? spi_OpIAdd(spi, res_type, a, b)
392 : spi_OpFAdd(spi, res_type, a, b);
393}
394
395static int emit_mul(SPICtx *spi, SwsPixelType type, int res_type, int a, int b)
396{
397 return ff_sws_pixel_type_is_int(type) ? spi_OpIMul(spi, res_type, a, b)
398 : spi_OpFMul(spi, res_type, a, b);
399}
400
401static int emit_min(SPICtx *spi, const SPIRVIDs *id, SwsPixelType type,
402 int res_type, int a, int b)
403{
404 const int op = ff_sws_pixel_type_is_int(type) ? GLSLstd450UMin : GLSLstd450FMin;
405 return spi_OpExtInst(spi, res_type, id->glfn, op, a, b);
406}
407
408static int emit_max(SPICtx *spi, const SPIRVIDs *id, SwsPixelType type,
409 int res_type, int a, int b)
410{
411 const int op = ff_sws_pixel_type_is_int(type) ? GLSLstd450UMax : GLSLstd450FMax;
412 return spi_OpExtInst(spi, res_type, id->glfn, op, a, b);
413}
414
415/* Converts between float and integer values, if needed */
417 int res_type, int a)
418{
420 return a;
421 return ff_sws_pixel_type_is_int(to) ? spi_OpConvertFToU(spi, res_type, a)
422 : spi_OpConvertUToF(spi, res_type, a);
423}
424
425/* Section 1: Function to define all shader header data, and decorations */
427{
428 spi_OpCapability(spi, SpvCapabilityShader); /* Shader type */
429
430 /* Declare required capabilities */
431 spi_OpCapability(spi, SpvCapabilityImageQuery);
432 spi_OpCapability(spi, SpvCapabilityStorageImageReadWithoutFormat);
433 spi_OpCapability(spi, SpvCapabilityStorageImageWriteWithoutFormat);
434 /* Import the GLSL set of functions (used for min/max) */
435 id->glfn = spi_OpExtInstImport(spi, "GLSL.std.450");
436
437 /* Next section starts here */
438 spi_OpMemoryModel(spi, SpvAddressingModelLogical, SpvMemoryModelGLSL450);
439}
440
441/* Section 2: Define all types and constants */
443{
444 /* Define scalar types */
445 id->void_type = spi_OpTypeVoid(spi);
446 id->b_type = spi_OpTypeBool(spi);
447 int u32_type =
448 id->u32_type = spi_OpTypeInt(spi, 32, 0);
449 id->i32_type = spi_OpTypeInt(spi, 32, 1);
450 int f32_type =
451 id->f32_type = spi_OpTypeFloat(spi, 32);
452 id->void_fn_type = spi_OpTypeFunction(spi, id->void_type, NULL, 0);
453
454 /* Define vector types */
455 id->bvec2_type = spi_OpTypeVector(spi, id->b_type, 2);
456 id->u32vec2_type = spi_OpTypeVector(spi, u32_type, 2);
457 id->i32vec2_type = spi_OpTypeVector(spi, id->i32_type, 2);
458
459 id->u32vec3_type = spi_OpTypeVector(spi, u32_type, 3);
460
461 id->u32vec4_type = spi_OpTypeVector(spi, u32_type, 4);
462 id->f32vec4_type = spi_OpTypeVector(spi, f32_type, 4);
463 id->f32mat4_type = spi_OpTypeMatrix(spi, id->f32vec4_type, 4);
464
465 /* Constants */
466 id->f32_0 = spi_OpConstantFloat(spi, f32_type, 0);
467 for (int i = 0; i < 5; i++)
468 id->u32_cid[i] = spi_OpConstantUInt(spi, u32_type, i);
469}
470
471/* Section 3: Define bindings */
472static void define_shader_bindings(const SwsOpList *ops, SPICtx *spi, SPIRVIDs *id,
473 int in_img_count, int out_img_count)
474{
475 id->dither_ptr_elem_id = spi_OpTypePointer(spi, SpvStorageClassUniform,
476 id->f32_type);
477
478 const SwsOp *op_w = ff_sws_op_list_output(ops);
479 const SwsOp *op_r = ff_sws_op_list_input(ops);
480
481 /* Define image types for descriptors */
482 id->out_img_type = spi_OpTypeImage(spi, type_scalar(id, op_w->rw.type),
483 2, 0, 0, 0, 2, SpvImageFormatUnknown);
484 id->out_img_array_id = spi_OpTypeArray(spi, id->out_img_type, spi_get_id(spi),
485 id->u32_cid[out_img_count]);
486
487 id->in_img_type = 0;
488 id->in_img_array_id = 0;
489 if (op_r) {
490 /* If the formats match, we have to reuse the types due to SPIR-V not
491 * allowing redundant type defines */
492 int match = type_scalar(id, op_w->rw.type) ==
493 type_scalar(id, op_r->rw.type);
494 id->in_img_type = match ? id->out_img_type :
495 spi_OpTypeImage(spi, type_scalar(id, op_r->rw.type),
496 2, 0, 0, 0, 2, SpvImageFormatUnknown);
497 id->in_img_array_id = spi_OpTypeArray(spi, id->in_img_type, spi_get_id(spi),
498 id->u32_cid[in_img_count]);
499 }
500
501 /* Pointer types for images */
502 id->u32vec3_tptr = spi_OpTypePointer(spi, SpvStorageClassInput,
503 id->u32vec3_type);
504 id->out_img_tptr = spi_OpTypePointer(spi, SpvStorageClassUniformConstant,
505 id->out_img_array_id);
506 id->out_img_sptr = spi_OpTypePointer(spi, SpvStorageClassUniformConstant,
507 id->out_img_type);
508
509 id->in_img_tptr = 0;
510 id->in_img_sptr = 0;
511 if (op_r) {
512 id->in_img_tptr = spi_OpTypePointer(spi, SpvStorageClassUniformConstant,
513 id->in_img_array_id);
514 id->in_img_sptr = spi_OpTypePointer(spi, SpvStorageClassUniformConstant,
515 id->in_img_type);
516 }
517
518 /* Define inputs */
519 id->gid_var = spi_OpVariable(spi, spi_get_id(spi), id->u32vec3_tptr,
520 SpvStorageClassInput, 0);
521 id->iface[id->nb_iface++] = id->gid_var;
522 spi_OpDecorate(spi, id->gid_var, SpvDecorationBuiltIn,
523 SpvBuiltInGlobalInvocationId);
524
525 if (op_r) {
526 id->in_img_var = spi_OpVariable(spi, spi_get_id(spi), id->in_img_tptr,
527 SpvStorageClassUniformConstant, 0);
528 id->iface[id->nb_iface++] = id->in_img_var;
529 spi_OpDecorate(spi, id->in_img_var, SpvDecorationNonWritable);
530 spi_OpDecorate(spi, id->in_img_var, SpvDecorationDescriptorSet, 0);
531 spi_OpDecorate(spi, id->in_img_var, SpvDecorationBinding, 0);
532 }
533
534 id->out_img_var = spi_OpVariable(spi, spi_get_id(spi), id->out_img_tptr,
535 SpvStorageClassUniformConstant, 0);
536 id->iface[id->nb_iface++] = id->out_img_var;
537 spi_OpDecorate(spi, id->out_img_var, SpvDecorationNonReadable);
538 spi_OpDecorate(spi, id->out_img_var, SpvDecorationDescriptorSet, 0);
539 spi_OpDecorate(spi, id->out_img_var, SpvDecorationBinding, 1);
540
541 if (id->interlaced) {
542 id->push_const_struct_id = spi_get_id(spi);
543 spi_OpTypeStruct(spi, id->push_const_struct_id, id->u32_type);
544 spi_OpDecorate(spi, id->push_const_struct_id, SpvDecorationBlock);
545 spi_OpMemberDecorate(spi, id->push_const_struct_id, 0,
546 SpvDecorationOffset, 0);
547 id->push_const_ptr_id = spi_OpTypePointer(spi, SpvStorageClassPushConstant,
548 id->push_const_struct_id);
549 id->push_const_elem_ptr_id = spi_OpTypePointer(spi, SpvStorageClassPushConstant,
550 id->u32_type);
551 id->push_const_var_id = spi_OpVariable(spi, spi_get_id(spi),
552 id->push_const_ptr_id,
553 SpvStorageClassPushConstant, 0);
554 id->iface[id->nb_iface++] = id->push_const_var_id;
555 }
556}
557
558/* Must be called after all interface variables have been defined */
560{
561 spi_OpEntryPoint(spi, SpvExecutionModelGLCompute, id->ep, "main",
562 id->iface, id->nb_iface);
563 spi_OpExecutionMode(spi, id->ep, SpvExecutionModeLocalSize,
564 shd->lg_size, 3);
565}
566
567static int insert_vmat_linear(const SwsUOp *uop, SPICtx *spi, SPIRVIDs *id,
568 int data)
569{
570 const SwsPixel (*m)[5] = uop->data.mat4x5;
571 int col[4], tmp[4];
572 for (int j = 0; j < 4; j++) {
573 for (int i = 0; i < 4; i++)
574 tmp[i] = const_pixel(spi, id, SWS_PIXEL_F32, m[i][j]);
575 col[j] = spi_OpConstantComposite(spi, id->f32vec4_type,
576 tmp[0], tmp[1], tmp[2], tmp[3]);
577 }
578 int mat = spi_OpConstantComposite(spi, id->f32mat4_type,
579 col[0], col[1], col[2], col[3]);
580
581 for (int i = 0; i < 4; i++)
582 tmp[i] = const_pixel(spi, id, SWS_PIXEL_F32, m[i][4]);
583 int off = spi_OpConstantComposite(spi, id->f32vec4_type,
584 tmp[0], tmp[1], tmp[2], tmp[3]);
585
586 data = spi_OpMatrixTimesVector(spi, id->f32vec4_type, mat, data);
587 return spi_OpFAdd(spi, id->f32vec4_type, off, data);
588}
589
590static int insert_bitexact_linear(const SwsUOp *uop, SPICtx *spi, SPIRVIDs *id,
591 int data)
592{
593 const SwsPixelType op_type = uop->type;
594 const SwsPixel (*m)[5] = uop->data.mat4x5;
595 const uint32_t zero = uop->par.lin.zero;
596 int type_s = type_scalar(id, op_type);
597 int type_v = type_vec4(id, op_type);
598
599 int tmp[4];
600 tmp[0] = spi_OpCompositeExtract(spi, type_s, data, 0);
601 tmp[1] = spi_OpCompositeExtract(spi, type_s, data, 1);
602 tmp[2] = spi_OpCompositeExtract(spi, type_s, data, 2);
603 tmp[3] = spi_OpCompositeExtract(spi, type_s, data, 3);
604
605 /* Same evaluation order as the C backend: offset first, then each column
606 * from left to right, skipping zero coefficients */
607 int res[4];
608 for (int j = 0; j < 4; j++) {
609 if (!SWS_COMP_TEST(uop->mask, j)) {
610 res[j] = tmp[j];
611 continue;
612 }
613
614 bool acc = !(zero & SWS_MASK_OFF(j));
615 res[j] = acc ? const_pixel(spi, id, op_type, m[j][4])
616 : const_zero(id, op_type);
617 for (int i = 0; i < 4; i++) {
618 if (zero & SWS_MASK(j, i))
619 continue;
620
621 int k = const_pixel(spi, id, op_type, m[j][i]);
622 int v = emit_mul(spi, op_type, type_s, tmp[i], k);
623 spi_OpDecorate(spi, v, SpvDecorationNoContraction);
624 if (acc) {
625 v = emit_add(spi, op_type, type_s, res[j], v);
626 spi_OpDecorate(spi, v, SpvDecorationNoContraction);
627 }
628 res[j] = v;
629 acc = true;
630 }
631 }
632
633 int result = spi_OpCompositeConstruct(spi, type_v,
634 res[0], res[1], res[2], res[3]);
635
636 /* Integer results are defined modulo the bit depth of the pixel type */
637 if (op_type == SWS_PIXEL_U8 || op_type == SWS_PIXEL_U16) {
638 const unsigned mask = op_type == SWS_PIXEL_U8 ? UINT8_MAX : UINT16_MAX;
639 const int mask_v = const_splat(spi, id, SWS_PIXEL_U32, (SwsPixel) { .u32 = mask });
640 result = spi_OpBitwiseAnd(spi, type_v, result, mask_v);
641 }
642 return result;
643}
644
645/* Registers the last created buffer in descriptor set 1, returns its binding */
647{
648 VulkanPriv *p = id->priv;
649 id->buf_desc[p->nb_data_bufs] = (FFVulkanDescriptorSetBinding) {
650 .type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
651 .stages = VK_SHADER_STAGE_COMPUTE_BIT,
652 };
653 return p->nb_data_bufs++;
654}
655
656static int emit_read_filtered(SPICtx *spi, SPIRVIDs *id, const SwsUOp *uop,
657 int *data)
658{
659 const SwsOpList *ops = id->ops;
660 const SwsFilterWeights *wd = uop->data.kernel;
661 VulkanPriv *p = id->priv;
662 if (p->nb_data_bufs >= MAX_DATA_BUFS)
663 return AVERROR(ENOTSUP);
664
665 int err = create_filter_buf(p->s, wd, &p->data_bufs[p->nb_data_bufs]);
666 if (err < 0)
667 return err;
668 const int binding = add_buf_binding(id);
669
670 /* Uniform buffer in descriptor set 1:
671 * struct { float w[dst_size][filter_size]; int o[dst_size]; } */
672 const int fs_id = spi_OpConstantUInt(spi, id->u32_type, wd->filter_size);
673 const int ds_id = spi_OpConstantUInt(spi, id->u32_type, wd->dst_size);
674
675 int arr_w_in = spi_OpTypeArray(spi, id->f32_type, spi_get_id(spi), fs_id);
676 spi_OpDecorate(spi, arr_w_in, SpvDecorationArrayStride, sizeof(float));
677 int arr_w_out = spi_OpTypeArray(spi, arr_w_in, spi_get_id(spi), ds_id);
678 spi_OpDecorate(spi, arr_w_out, SpvDecorationArrayStride,
679 wd->filter_size*sizeof(float));
680 int arr_o = spi_OpTypeArray(spi, id->i32_type, spi_get_id(spi), ds_id);
681 spi_OpDecorate(spi, arr_o, SpvDecorationArrayStride, sizeof(int32_t));
682
683 int struct_id = spi_get_id(spi);
684 spi_OpTypeStruct(spi, struct_id, arr_w_out, arr_o);
685 spi_OpDecorate(spi, struct_id, SpvDecorationBlock);
686 spi_OpMemberDecorate(spi, struct_id, 0, SpvDecorationOffset, 0);
687 spi_OpMemberDecorate(spi, struct_id, 1, SpvDecorationOffset,
688 wd->num_weights*sizeof(float));
689
690 int ptr = spi_OpTypePointer(spi, SpvStorageClassUniform, struct_id);
691 int buf = spi_OpVariable(spi, spi_get_id(spi), ptr, SpvStorageClassUniform, 0);
692 spi_OpDecorate(spi, buf, SpvDecorationDescriptorSet, 1);
693 spi_OpDecorate(spi, buf, SpvDecorationBinding, binding);
694 id->iface[id->nb_iface++] = buf;
695
696 const int o_ptr_type = spi_OpTypePointer(spi, SpvStorageClassUniform,
697 id->i32_type);
698 const int is_h = uop->uop == SWS_UOP_READ_PLANAR_FH;
699 const int src_interlaced = ops->src.interlaced;
700
701 const int read_vtype = type_vec4(id, uop->type);
702
703 /* Buffer array index along the filtered axis: pos.x (H) or pos.y (V) */
704 int axis = spi_OpCompositeExtract(spi, id->u32_type, id->gid, is_h ? 0 : 1);
705
706 /* int o = filter_o[axis]; */
707 int o_ptr = spi_OpAccessChain(spi, o_ptr_type, buf, id->u32_cid[1], axis);
708 int o = spi_OpLoad(spi, id->i32_type, o_ptr, SpvMemoryAccessMaskNone, 0);
709
710 /* Signed pixel position, for the non-filtered coordinate axis */
711 int pos_x = spi_OpCompositeExtract(spi, id->i32_type, id->gi2, 0);
712 int pos_y = spi_OpCompositeExtract(spi, id->i32_type, id->gi2, 1);
713
714 /* For interlaced horizontal filtering, the y coordinate of every tap is
715 * the (constant) destination y mapped into the source image. */
716 if (src_interlaced && is_h) {
717 pos_y = spi_OpShiftLeftLogical(spi, id->i32_type, pos_y, id->u32_cid[1]);
718 pos_y = spi_OpIAdd(spi, id->i32_type, pos_y, id->field_i32);
719 }
720
721 /* Accumulators, initialized to zero */
722 int acc[4] = { id->f32_0, id->f32_0, id->f32_0, id->f32_0 };
723
724 for (int t = 0; t < wd->filter_size; t++) {
725 const int tap = spi_OpConstantInt(spi, id->i32_type, t);
726
727 /* float w = filter_w[axis][t]; */
728 int w_ptr = spi_OpAccessChain(spi, id->dither_ptr_elem_id, buf,
729 id->u32_cid[0], axis, tap);
730 int w = spi_OpLoad(spi, id->f32_type, w_ptr,
731 SpvMemoryAccessMaskNone, 0);
732
733 /* Source coordinate, filtered axis offset by the tap index */
734 int c = t ? spi_OpIAdd(spi, id->i32_type, o, tap) : o;
735 /* For interlaced vertical filtering, the per-tap source row is
736 * field-local; map it to the actual image row. */
737 if (src_interlaced && !is_h) {
738 c = spi_OpShiftLeftLogical(spi, id->i32_type, c, id->u32_cid[1]);
739 c = spi_OpIAdd(spi, id->i32_type, c, id->field_i32);
740 }
741 int coord = is_h ?
742 spi_OpCompositeConstruct(spi, id->i32vec2_type, c, pos_y) :
743 spi_OpCompositeConstruct(spi, id->i32vec2_type, pos_x, c);
744
745 for (int e = 0; e < 4; e++) {
746 if (!SWS_COMP_TEST(uop->mask, e))
747 continue;
748 int px = spi_OpImageRead(spi, read_vtype,
749 id->in_img[ops->plane_src[e]], coord,
750 SpvImageOperandsMaskNone);
751 px = spi_OpCompositeExtract(spi, type_scalar(id, uop->type), px, 0);
752 px = emit_convert(spi, uop->type, SWS_PIXEL_F32, id->f32_type, px);
753 px = spi_OpFMul(spi, id->f32_type, w, px);
754 acc[e] = spi_OpFAdd(spi, id->f32_type, acc[e], px);
755 }
756 }
757
758 *data = spi_OpCompositeConstruct(spi, id->f32vec4_type,
759 acc[0], acc[1], acc[2], acc[3]);
760 return 0;
761}
762
763/* Sub-packed formats are accessed as a single raw word per pixel, which is
764 * then (un)packed manually. */
766{
767 if (!op || op->rw.mode != SWS_RW_PACKED || op->rw.elems != 1)
768 return VK_FORMAT_UNDEFINED;
769
770 switch (op->rw.type) {
771 case SWS_PIXEL_U8: return VK_FORMAT_R8_UINT;
772 case SWS_PIXEL_U16: return VK_FORMAT_R16_UINT;
773 case SWS_PIXEL_U32: return VK_FORMAT_R32_UINT;
774 default: return VK_FORMAT_UNDEFINED;
775 }
776}
777
779 enum AVPixelFormat fmt, const SwsOp *op)
780{
781 const VkFormat *vk_fmts = av_vkfmt_from_pixfmt(fmt);
782 const VkFormat word_fmt = packed_word_fmt(op);
784 if (op)
787 if (!vk_fmts)
788 return AVERROR(ENOTSUP);
789
790 const int nb_planes = av_pix_fmt_count_planes(fmt);
791 for (int i = 0; i < nb_planes; i++) {
792 view_fmts[i] = word_fmt ? word_fmt : ff_vk_map_fmt_to_rep(vk_fmts[i], rep);
793 if (view_fmts[i] == VK_FORMAT_UNDEFINED)
794 return AVERROR(ENOTSUP);
795 }
796
797 return 0;
798}
799
800/* Plane indices refer to actual frame planes, so the image handle arrays
801 * have to cover the highest plane referenced, not just the plane count. */
802static int rw_op_img_count(const SwsOp *op, const uint8_t *planes)
803{
804 const int nb_planes = ff_sws_rw_op_planes(op);
805 int count = 0;
806 for (int i = 0; i < nb_planes; i++)
807 count = FFMAX(count, planes[i] + 1);
808 return count;
809}
810
811static int emit_read(SPICtx *spi, SPIRVIDs *id, const SwsUOp *uop, int *data)
812{
813 const SwsOpList *ops = id->ops;
814 const int type_v = type_vec4(id, uop->type);
815 const int type_s = type_scalar(id, uop->type);
816 const int zero = const_zero(id, uop->type);
817
818 switch (uop->uop) {
821 if (uop->par.filter.type != SWS_PIXEL_F32)
822 return AVERROR(ENOTSUP);
823 return emit_read_filtered(spi, id, uop, data);
825 *data = spi_OpImageRead(spi, type_v, id->in_img[ops->plane_src[0]],
826 id->src_gid, SpvImageOperandsMaskNone);
827 break;
828 case SWS_UOP_READ_PLANAR: {
829 int tmp[4] = { zero, zero, zero, zero };
830 for (int i = 0; i < 4; i++) {
831 if (!SWS_COMP_TEST(uop->mask, i))
832 continue;
833 tmp[i] = spi_OpImageRead(spi, type_v,
834 id->in_img[ops->plane_src[i]], id->src_gid,
835 SpvImageOperandsMaskNone);
836 tmp[i] = spi_OpCompositeExtract(spi, type_s, tmp[i], 0);
837 }
838 *data = spi_OpCompositeConstruct(spi, type_v,
839 tmp[0], tmp[1], tmp[2], tmp[3]);
840 break;
841 }
842 default:
843 return AVERROR(ENOTSUP);
844 }
845
846 return 0;
847}
848
849static int emit_write(SPICtx *spi, SPIRVIDs *id, const SwsUOp *uop, int *data)
850{
851 const SwsOpList *ops = id->ops;
852 const int type_v = type_vec4(id, uop->type);
853 const int type_s = type_scalar(id, uop->type);
854
855 switch (uop->uop) {
857 spi_OpImageWrite(spi, id->out_img[ops->plane_dst[0]], id->dst_gid, *data,
858 SpvImageOperandsMaskNone);
859 break;
861 for (int i = 0; i < 4; i++) {
862 if (!SWS_COMP_TEST(uop->mask, i))
863 continue;
864 int tmp = spi_OpCompositeExtract(spi, type_s, *data, i);
865 tmp = spi_OpCompositeConstruct(spi, type_v, tmp, tmp, tmp, tmp);
866 spi_OpImageWrite(spi, id->out_img[ops->plane_dst[i]], id->dst_gid, tmp,
867 SpvImageOperandsMaskNone);
868 }
869 break;
870 default:
871 return AVERROR(ENOTSUP);
872 }
873
874 return 0;
875}
876
877static int emit_clamp(SPICtx *spi, SPIRVIDs *id, const SwsUOp *uop, int *data)
878{
879 const SwsPixelType type = uop->type;
880 const int type_v = type_vec4(id, type);
881 const int type_s = type_scalar(id, type);
882
883 for (int i = 0; i < 4; i++) {
884 if (!SWS_COMP_TEST(uop->mask, i))
885 continue;
886 int lim = const_pixel(spi, id, type, uop->data.vec4[i]);
887 int tmp = spi_OpCompositeExtract(spi, type_s, *data, i);
888 if (uop->uop == SWS_UOP_MIN)
889 tmp = emit_min(spi, id, type, type_s, tmp, lim);
890 else
891 tmp = emit_max(spi, id, type, type_s, tmp, lim);
892 *data = spi_OpCompositeInsert(spi, type_v, tmp, *data, i);
893 }
894
895 return 0;
896}
897
898static int emit_dither(SPICtx *spi, SPIRVIDs *id, const SwsUOp *uop, int *data)
899{
900 if (uop->type != SWS_PIXEL_F32)
901 return AVERROR(ENOTSUP);
902
903 VulkanPriv *p = id->priv;
904 if (p->nb_data_bufs >= MAX_DATA_BUFS)
905 return AVERROR(ENOTSUP);
906
907 int err = create_dither_buf(p->s, uop, &p->data_bufs[p->nb_data_bufs]);
908 if (err < 0)
909 return err;
910 const int binding = add_buf_binding(id);
911
912 /* Uniform buffer in descriptor set 1: struct { float m[rows][size]; } */
913 const int size = 1 << uop->par.dither.size_log2;
914 const int rows = ff_sws_dither_height(&uop->par.dither);
915 const int size_id = spi_OpConstantUInt(spi, id->u32_type, size);
916 const int rows_id = spi_OpConstantUInt(spi, id->u32_type, rows);
917 const int mask_id = spi_OpConstantUInt(spi, id->u32_type, size - 1);
918
919 int arr_1d = spi_OpTypeArray(spi, id->f32_type, spi_get_id(spi), size_id);
920 spi_OpDecorate(spi, arr_1d, SpvDecorationArrayStride, sizeof(float));
921 int arr_2d = spi_OpTypeArray(spi, arr_1d, spi_get_id(spi), rows_id);
922 spi_OpDecorate(spi, arr_2d, SpvDecorationArrayStride, size*sizeof(float));
923
924 int struct_id = spi_get_id(spi);
925 spi_OpTypeStruct(spi, struct_id, arr_2d);
926 spi_OpDecorate(spi, struct_id, SpvDecorationBlock);
927 spi_OpMemberDecorate(spi, struct_id, 0, SpvDecorationOffset, 0);
928
929 int ptr = spi_OpTypePointer(spi, SpvStorageClassUniform, struct_id);
930 int buf = spi_OpVariable(spi, spi_get_id(spi), ptr, SpvStorageClassUniform, 0);
931 spi_OpDecorate(spi, buf, SpvDecorationDescriptorSet, 1);
932 spi_OpDecorate(spi, buf, SpvDecorationBinding, binding);
933 id->iface[id->nb_iface++] = buf;
934
935 /* The matrix is padded to allow offsetting the wrapped row */
936 int x_id = spi_OpCompositeExtract(spi, id->u32_type, id->gid, 0);
937 int y_id = spi_OpCompositeExtract(spi, id->u32_type, id->gid, 1);
938 x_id = spi_OpBitwiseAnd(spi, id->u32_type, x_id, mask_id);
939 y_id = spi_OpBitwiseAnd(spi, id->u32_type, y_id, mask_id);
940 for (int i = 0; i < 4; i++) {
941 if (!SWS_COMP_TEST(uop->mask, i))
942 continue;
943
944 int y_off = spi_OpConstantUInt(spi, id->u32_type,
945 uop->par.dither.y_offset[i]);
946 int row = spi_OpIAdd(spi, id->u32_type, y_id, y_off);
947
948 int val_ptr = spi_OpAccessChain(spi, id->dither_ptr_elem_id, buf,
949 id->u32_cid[0], row, x_id);
950 int val = spi_OpLoad(spi, id->f32_type, val_ptr,
951 SpvMemoryAccessMaskNone, 0);
952
953 int tmp = spi_OpCompositeExtract(spi, id->f32_type, *data, i);
954 tmp = spi_OpFAdd(spi, id->f32_type, tmp, val);
955 *data = spi_OpCompositeInsert(spi, id->f32vec4_type, tmp, *data, i);
956 }
957
958 return 0;
959}
960
961static int emit_linear(SPICtx *spi, SPIRVIDs *id, const SwsUOp *uop, int *data)
962{
963 /* Matrix operations are only defined for floats */
964 if (id->bitexact || ff_sws_pixel_type_is_int(uop->type))
965 *data = insert_bitexact_linear(uop, spi, id, *data);
966 else
967 *data = insert_vmat_linear(uop, spi, id, *data);
968 return 0;
969}
970
971static int emit_pack(SPICtx *spi, SPIRVIDs *id, const SwsUOp *uop, int *data)
972{
973 const int type_v = type_vec4(id, uop->type);
974 const int type_s = type_scalar(id, uop->type);
975
976 int shift, mask;
977 define_pack_consts(spi, id, uop, &shift, &mask);
978 *data = spi_OpBitwiseAnd(spi, type_v, *data, mask);
979 *data = spi_OpShiftLeftLogical(spi, type_v, *data, shift);
980 int val = spi_OpCompositeExtract(spi, type_s, *data, 0);
981 for (int i = 1; i < 4; i++) {
982 int tmp = spi_OpCompositeExtract(spi, type_s, *data, i);
983 val = spi_OpBitwiseOr(spi, type_s, val, tmp);
984 }
985 *data = spi_OpCompositeConstruct(spi, type_v, val, val, val, val);
986 return 0;
987}
988
990 const SwsOpList *ops, const SwsUOpList *uops,
991 FFVulkanShader *shd, SPICtx *spi)
992{
993 SPIRVIDs spid_data = { 0 }, *id = &spid_data;
994 id->priv = p;
995 id->ops = ops;
996 id->bitexact = !!(sws->flags & SWS_BITEXACT);
997
998 id->interlaced = ops->src.interlaced || ops->dst.interlaced;
999 p->interlaced = id->interlaced;
1000
1001 ff_vk_shader_load(shd, VK_SHADER_STAGE_COMPUTE_BIT, NULL,
1002 (uint32_t []) { 32, 32, 1 }, 0);
1003 shd->precompiled = 0;
1004
1005 if (id->interlaced)
1006 ff_vk_shader_add_push_const(shd, 0, sizeof(uint32_t),
1007 VK_SHADER_STAGE_COMPUTE_BIT);
1008
1009 /* Image ops, to determine types */
1010 const SwsOp *op_w = ff_sws_op_list_output(ops);
1011 int out_img_count = rw_op_img_count(op_w, ops->plane_dst);
1012 const SwsOp *op_r = ff_sws_op_list_input(ops);
1013 int in_img_count = op_r ? rw_op_img_count(op_r, ops->plane_src) : 0;
1014
1015 int err = get_view_fmts(p->dst_view_fmt, ops->dst.format, op_w);
1016 if (err < 0)
1017 return err;
1018 err = get_view_fmts(p->src_view_fmt, ops->src.format, op_r);
1019 if (err < 0)
1020 return err;
1021
1022 FFVulkanDescriptorSetBinding img_desc[2] = {
1023 {
1024 .type = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
1025 .stages = VK_SHADER_STAGE_COMPUTE_BIT,
1026 .elems = 4,
1027 },
1028 {
1029 .type = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
1030 .stages = VK_SHADER_STAGE_COMPUTE_BIT,
1031 .elems = 4,
1032 },
1033 };
1034 ff_vk_shader_add_descriptor_set(&s->vkctx, shd, img_desc, 2, 0);
1035
1036 /* Define shader header sections */
1037 define_shader_header(spi, id);
1038 define_shader_consts(spi, id);
1039 define_shader_bindings(ops, spi, id, in_img_count, out_img_count);
1040
1041 /* Main function starts here */
1042 id->ep = spi_get_id(spi);
1043 spi_OpFunction(spi, id->ep, id->void_type, 0, id->void_fn_type);
1044 spi_OpLabel(spi, spi_get_id(spi));
1045
1046 /* Load input image handles */
1047 for (int i = 0; i < in_img_count; i++) {
1048 /* Deref array and then the pointer */
1049 int img = spi_OpAccessChain(spi, id->in_img_sptr,
1050 id->in_img_var, id->u32_cid[i]);
1051 id->in_img[i] = spi_OpLoad(spi, id->in_img_type, img,
1052 SpvMemoryAccessMaskNone, 0);
1053 }
1054
1055 /* Load output image handles */
1056 for (int i = 0; i < out_img_count; i++) {
1057 int img = spi_OpAccessChain(spi, id->out_img_sptr,
1058 id->out_img_var, id->u32_cid[i]);
1059 id->out_img[i] = spi_OpLoad(spi, id->out_img_type, img,
1060 SpvMemoryAccessMaskNone, 0);
1061 }
1062
1063 /* Load gl_GlobalInvocationID */
1064 id->gid = spi_OpLoad(spi, id->u32vec3_type, id->gid_var,
1065 SpvMemoryAccessMaskNone, 0);
1066
1067 /* ivec2(gl_GlobalInvocationID.xy) */
1068 id->gid = spi_OpVectorShuffle(spi, id->u32vec2_type, id->gid, id->gid, 0, 1);
1069 id->gi2 = spi_OpBitcast(spi, id->i32vec2_type, id->gid);
1070
1071 /* For interlaced sources/destinations the shader operates on field-local
1072 * coordinates, while images contain the full frame. Map the y axis to the
1073 * actual image row: image_y = field_y * 2 + field. */
1074 int dst_gi2 = id->gi2;
1075 id->dst_gid = id->src_gid = id->gid;
1076 if (id->interlaced) {
1077 int field_u32_ptr = spi_OpAccessChain(spi, id->push_const_elem_ptr_id,
1078 id->push_const_var_id,
1079 id->u32_cid[0]);
1080 int field_u32 = spi_OpLoad(spi, id->u32_type, field_u32_ptr,
1081 SpvMemoryAccessMaskNone, 0);
1082 id->field_i32 = spi_OpBitcast(spi, id->i32_type, field_u32);
1083
1084 int img_y_i32 = spi_OpShiftLeftLogical(spi, id->i32_type,
1085 spi_OpCompositeExtract(spi, id->i32_type, id->gi2, 1),
1086 id->u32_cid[1]);
1087 img_y_i32 = spi_OpIAdd(spi, id->i32_type, img_y_i32, id->field_i32);
1088
1089 int gi2_x = spi_OpCompositeExtract(spi, id->i32_type, id->gi2, 0);
1090 int mapped_gi2 = spi_OpCompositeConstruct(spi, id->i32vec2_type,
1091 gi2_x, img_y_i32);
1092 int mapped_gid = spi_OpBitcast(spi, id->u32vec2_type, mapped_gi2);
1093
1094 if (ops->src.interlaced)
1095 id->src_gid = mapped_gid;
1096 if (ops->dst.interlaced) {
1097 id->dst_gid = mapped_gid;
1098 dst_gi2 = mapped_gi2;
1099 }
1100 }
1101
1102 /* imageSize(id->out_img[0]); */
1103 int img1_s = spi_OpImageQuerySize(spi, id->i32vec2_type, id->out_img[0]);
1104 int scmp = spi_OpSGreaterThanEqual(spi, id->bvec2_type, dst_gi2, img1_s);
1105 scmp = spi_OpAny(spi, id->b_type, scmp);
1106
1107 /* if (out of bounds) return */
1108 int quit_label = spi_get_id(spi), merge_label = spi_get_id(spi);
1109 spi_OpSelectionMerge(spi, merge_label, SpvSelectionControlMaskNone);
1110 spi_OpBranchConditional(spi, scmp, quit_label, merge_label, 0);
1111
1112 spi_OpLabel(spi, quit_label);
1113 spi_OpReturn(spi); /* Quit if out of bounds here */
1114 spi_OpLabel(spi, merge_label);
1115
1116 /* Initialize main data state */
1117 const SwsPixelType type0 = uops->ops[0].type;
1118 const int zero0 = const_zero(id, type0);
1119 int data = spi_OpCompositeConstruct(spi, type_vec4(id, type0),
1120 zero0, zero0, zero0, zero0);
1121
1122 /* Operations */
1123 for (int n = 0; n < uops->num_ops; n++) {
1124 const SwsUOp *uop = &uops->ops[n];
1125 const int type_v = type_vec4(id, uop->type);
1126
1127 switch (uop->uop) {
1132 err = emit_read(spi, id, uop, &data);
1133 break;
1136 err = emit_write(spi, id, uop, &data);
1137 break;
1138 case SWS_UOP_CLEAR:
1139 for (int i = 0; i < 4; i++) {
1140 if (!SWS_COMP_TEST(uop->mask, i))
1141 continue;
1142 int val = const_pixel(spi, id, uop->type, uop->data.vec4[i]);
1143 data = spi_OpCompositeInsert(spi, type_v, val, data, i);
1144 }
1145 break;
1146 case SWS_UOP_PERMUTE:
1147 case SWS_UOP_COPY: {
1148 const SwsMoveUOp *move = &uop->par.move;
1149 int idx[5] = { -1, 0, 1, 2, 3 }; /* tmp, x, y, z, w */
1150 for (int i = 0; i < move->num_moves; i++)
1151 idx[move->dst[i] + 1] = idx[move->src[i] + 1];
1152
1153 data = spi_OpVectorShuffle(spi, type_v, data, data,
1154 idx[1], idx[2], idx[3], idx[4]);
1155 break;
1156 }
1157 case SWS_UOP_TO_U8:
1158 case SWS_UOP_TO_U16:
1159 case SWS_UOP_TO_U32:
1160 data = emit_convert(spi, uop->type, SWS_PIXEL_U32,
1161 id->u32vec4_type, data);
1162 break;
1163 case SWS_UOP_TO_F32:
1164 data = emit_convert(spi, uop->type, SWS_PIXEL_F32,
1165 id->f32vec4_type, data);
1166 break;
1168 case SWS_UOP_EXPAND_QUAD: {
1169 /* The SPIR-V compiler should optimize this multiplication into
1170 * a shift and or, if faster */
1171 const uint32_t k = uop->uop == SWS_UOP_EXPAND_PAIR ? 0x101 : 0x1010101;
1172 const int k_v = const_splat(spi, id, SWS_PIXEL_U32, (SwsPixel) { .u32 = k });
1173 data = spi_OpIMul(spi, type_v, data, k_v);
1174 break;
1175 }
1176 case SWS_UOP_LSHIFT:
1177 case SWS_UOP_RSHIFT: {
1178 const SwsPixel amount = { .u32 = uop->par.shift.amount };
1179 const int shift_v = const_splat(spi, id, SWS_PIXEL_U32, amount);
1180 if (uop->uop == SWS_UOP_LSHIFT)
1181 data = spi_OpShiftLeftLogical(spi, type_v, data, shift_v);
1182 else
1183 data = spi_OpShiftRightLogical(spi, type_v, data, shift_v);
1184 break;
1185 }
1186 case SWS_UOP_SCALE:
1187 data = emit_mul(spi, uop->type, type_v, data,
1188 const_splat(spi, id, uop->type, uop->data.scalar));
1189 break;
1190 case SWS_UOP_ADD: {
1191 const int zero = const_zero(id, uop->type);
1192 int arg[4] = { zero, zero, zero, zero };
1193 for (int i = 0; i < 4; i++) {
1194 if (!SWS_COMP_TEST(uop->mask, i))
1195 continue;
1196 arg[i] = const_pixel(spi, id, uop->type, uop->data.vec4[i]);
1197 }
1198
1199 int arg_v = spi_OpConstantComposite(spi, type_v, arg[0], arg[1], arg[2], arg[3]);
1200 data = emit_add(spi, uop->type, type_v, data, arg_v);
1201 break;
1202 }
1203 case SWS_UOP_MIN:
1204 case SWS_UOP_MAX:
1205 err = emit_clamp(spi, id, uop, &data);
1206 break;
1207 case SWS_UOP_DITHER:
1208 err = emit_dither(spi, id, uop, &data);
1209 break;
1210 case SWS_UOP_LINEAR:
1211 err = emit_linear(spi, id, uop, &data);
1212 break;
1213 case SWS_UOP_UNPACK: {
1214 int shift, mask;
1215 define_pack_consts(spi, id, uop, &shift, &mask);
1216 data = spi_OpVectorShuffle(spi, type_v, data, data, 0, 0, 0, 0);
1217 data = spi_OpShiftRightLogical(spi, type_v, data, shift);
1218 data = spi_OpBitwiseAnd(spi, type_v, data, mask);
1219 break;
1220 }
1221 case SWS_UOP_PACK:
1222 err = emit_pack(spi, id, uop, &data);
1223 break;
1224 default:
1225 return AVERROR(ENOTSUP);
1226 }
1227
1228 if (err < 0)
1229 return err;
1230 }
1231
1232 /* Return and finalize */
1233 spi_OpReturn(spi);
1234 spi_OpFunctionEnd(spi);
1235
1236 if (p->nb_data_bufs)
1237 ff_vk_shader_add_descriptor_set(&s->vkctx, shd, id->buf_desc,
1238 p->nb_data_bufs, 1);
1239
1240 define_entry_point(shd, spi, id);
1241 return 0;
1242}
1243
1245 const SwsOpList *ops, const SwsUOpList *uops,
1246 FFVulkanShader *shd)
1247{
1248 uint8_t *spvbuf = NULL;
1249 SPICtx spi_context, *spi = &spi_context;
1250 spi_init(spi);
1251
1252 int err = emit_shader(sws, p, s, ops, uops, shd, spi);
1253 if (err < 0)
1254 goto fail;
1255
1256 int len = spi_end(spi, &spvbuf);
1257 if (len < 0) {
1258 err = len;
1259 goto fail;
1260 }
1261
1262 err = ff_vk_shader_link(&s->vkctx, shd, spvbuf, len, "main");
1263
1264fail:
1265 av_free(spvbuf);
1266 spi_uninit(spi);
1267 return err;
1268}
1269
1270static int compile_ops_spirv(SwsContext *sws, const SwsOpList *ops,
1272{
1273 SwsUOpList *uops = NULL;
1274 int err;
1275 SwsInternal *c = sws_internal(sws);
1276 FFVulkanOpsCtx *s = c->hw_priv;
1277 if (!s)
1278 return AVERROR(ENOTSUP);
1279
1280 VulkanPriv *p = av_mallocz(sizeof(*p));
1281 if (!p)
1282 return AVERROR(ENOMEM);
1283 p->s = av_refstruct_ref(c->hw_priv);
1284
1285 err = ff_vk_exec_pool_init(&s->vkctx, s->qf, &p->e, 1,
1286 0, 0, 0, NULL);
1287 if (err < 0)
1288 goto fail;
1289
1290 uops = ff_sws_uop_list_alloc();
1291 if (!uops) {
1292 err = AVERROR(ENOMEM);
1293 goto fail;
1294 }
1295
1296 err = ff_sws_ops_translate(sws, ops, SWS_UOP_FLAG_ADD, uops);
1297 if (err < 0)
1298 goto fail;
1299
1300 err = add_ops_spirv(sws, p, s, ops, uops, &p->shd);
1301 if (err < 0)
1302 goto fail;
1303
1304 err = ff_vk_shader_register_exec(&s->vkctx, &p->e, &p->shd);
1305 if (err < 0)
1306 goto fail;
1307
1308 for (int i = 0; i < p->nb_data_bufs; i++)
1309 ff_vk_shader_update_desc_buffer(&s->vkctx, &p->e.contexts[0], &p->shd,
1310 1, i, 0, &p->data_bufs[i],
1311 0, VK_WHOLE_SIZE, VK_FORMAT_UNDEFINED);
1312
1313 *out = (SwsCompiledOp) {
1314 .opaque = true,
1315 .func_opaque = spirv_process,
1316 .priv = p,
1317 .free = spirv_free,
1318 };
1319
1321
1322 ff_sws_uop_list_free(&uops);
1323 return 0;
1324
1325fail:
1326 ff_sws_uop_list_free(&uops);
1327 spirv_free(p);
1328 return err;
1329}
1330
1332 .name = "spirv",
1333 .flags = SWS_BACKEND_SPIRV,
1334 .compile = compile_ops_spirv,
1335 .hw_format = AV_PIX_FMT_VULKAN,
1336};
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
Definition dsp.h:97
static double val(void *priv, double ch)
Definition aeval.c:77
static FILE * out
int32_t
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition avassert.h:58
#define av_unreachable(msg)
Asserts that are used as compiler optimization hints depending upon ASSERT_LEVEL and NBDEBUG.
Definition avassert.h:109
#define i(width, name, range_min, range_max)
Definition cbs_h264.c:63
#define s(width, name)
Definition cbs_vp9.c:198
#define NULL
Definition coverity.c:32
enum AVCodecID id
Definition dts2pts.c:612
#define AV_NUM_DATA_POINTERS
Definition frame.h:480
#define fail
Definition test.h:479
#define av_err2str(errnum)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition error.h:122
#define AVERROR(e)
Definition error.h:45
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition log.h:231
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition log.h:210
@ SWS_BACKEND_SPIRV
Vulkan SPIR-V backend.
Definition swscale.h:120
@ SWS_BITEXACT
Definition swscale.h:178
int a
const VkFormat * av_vkfmt_from_pixfmt(enum AVPixelFormat p)
Returns the optimal per-plane Vulkan format for a given sw_format, one for each plane.
enum VkFormat VkFormat
#define b
Definition input.c:43
static int zero(InterplayACMContext *s, unsigned ind, unsigned col)
enum MPFType type
Definition jpegmpfenc.c:55
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
static int shift(int a, int b)
Definition bonk.c:261
enum TrimAxis axis
Definition trim.c:49
const char * arg
Definition jacosubdec.c:66
const char * from
Definition jacosubdec.c:65
const char * to
Definition webvttdec.c:37
void ff_vk_shader_update_img_array(FFVulkanContext *s, FFVkExecContext *e, FFVulkanShader *shd, AVFrame *f, VkImageView *views, int set, int binding, VkImageLayout layout, VkSampler sampler)
Update a descriptor in a buffer with an image array.
Definition vulkan.c:2711
int ff_vk_shader_load(FFVulkanShader *shd, VkPipelineStageFlags stage, VkSpecializationInfo *spec, uint32_t wg_size[3], uint32_t required_subgroup_size)
Initialize a shader object.
Definition vulkan.c:2283
void ff_vk_shader_add_descriptor_set(FFVulkanContext *s, FFVulkanShader *shd, const FFVulkanDescriptorSetBinding *desc, int nb, int singular)
Add descriptor to a shader.
Definition vulkan.c:2542
void ff_vk_exec_pool_free(FFVulkanContext *s, FFVkExecPool *pool)
Definition vulkan.c:335
int ff_vk_create_buf(FFVulkanContext *s, FFVkBuffer *buf, size_t size, void *pNext, void *alloc_pNext, VkBufferUsageFlags usage, VkMemoryPropertyFlagBits flags)
Definition vulkan.c:1208
int ff_vk_exec_pool_init(FFVulkanContext *s, AVVulkanDeviceQueueFamily *qf, FFVkExecPool *pool, int nb_contexts, int nb_queries, VkQueryType query_type, int query_64bit, const void *query_create_pnext)
Allocates/frees an execution pool.
Definition vulkan.c:399
void ff_vk_exec_wait(FFVulkanContext *s, FFVkExecContext *e)
Definition vulkan.c:653
int ff_vk_shader_add_push_const(FFVulkanShader *shd, int offset, int size, VkShaderStageFlagBits stage)
Add/update push constants for execution.
Definition vulkan.c:1635
void ff_vk_uninit(FFVulkanContext *s)
Frees main context.
Definition vulkan.c:2800
VkFormat ff_vk_map_fmt_to_rep(VkFormat fmt, enum FFVkShaderRepFormat rep_fmt)
Returns the view format for the given representation of fmt, or VK_FORMAT_UNDEFINED if there is none.
Definition vulkan.c:2003
int ff_vk_init(FFVulkanContext *s, void *log_parent, AVBufferRef *device_ref, AVBufferRef *frames_ref)
Initializes the AVClass, in case this context is not used as the main user's context.
Definition vulkan.c:2816
void ff_vk_free_buf(FFVulkanContext *s, FFVkBuffer *buf)
Definition vulkan.c:1422
void ff_vk_frame_barrier(FFVulkanContext *s, FFVkExecContext *e, AVFrame *pic, VkImageMemoryBarrier2 *bar, int *nb_bar, VkPipelineStageFlags2 src_stage, VkPipelineStageFlags2 dst_stage, VkAccessFlagBits2 new_access, VkImageLayout new_layout, uint32_t new_qf)
Definition vulkan.c:2237
int ff_vk_exec_start(FFVulkanContext *s, FFVkExecContext *e)
Start/submit/wait an execution.
Definition vulkan.c:668
void ff_vk_shader_free(FFVulkanContext *s, FFVulkanShader *shd)
Free a shader.
Definition vulkan.c:2778
int ff_vk_shader_register_exec(FFVulkanContext *s, FFVkExecPool *pool, FFVulkanShader *shd)
Register a shader with an exec pool.
Definition vulkan.c:2576
FFVkExecContext * ff_vk_exec_get(FFVulkanContext *s, FFVkExecPool *pool)
Retrieve an execution pool.
Definition vulkan.c:630
int ff_vk_exec_submit(FFVulkanContext *s, FFVkExecContext *e)
Definition vulkan.c:991
void ff_vk_exec_bind_shader(FFVulkanContext *s, FFVkExecContext *e, const FFVulkanShader *shd)
Bind a shader.
Definition vulkan.c:2760
int ff_vk_shader_update_desc_buffer(FFVulkanContext *s, FFVkExecContext *e, FFVulkanShader *shd, int set, int bind, int elem, FFVkBuffer *buf, VkDeviceSize offset, VkDeviceSize len, VkFormat fmt)
Update a descriptor in a buffer with a buffer.
Definition vulkan.c:2724
AVVulkanDeviceQueueFamily * ff_vk_qf_find(FFVulkanContext *s, VkQueueFlagBits dev_family, VkVideoCodecOperationFlagBitsKHR vid_ops)
Chooses an appropriate QF.
Definition vulkan.c:320
void ff_vk_exec_discard(FFVulkanContext *s, FFVkExecContext *e)
Definition vulkan.c:771
int ff_vk_create_imageviews_fmt(FFVulkanContext *s, FFVkExecContext *e, VkImageView views[AV_NUM_DATA_POINTERS], AVFrame *f, const VkFormat fmts[AV_NUM_DATA_POINTERS])
Same as ff_vk_create_imageviews(), but with an explicit view format for each plane,...
Definition vulkan.c:2153
int ff_vk_shader_link(FFVulkanContext *s, FFVulkanShader *shd, const char *spirv, size_t spirv_len, const char *entrypoint)
Link a shader into an executable.
Definition vulkan.c:2446
int ff_vk_exec_add_dep_frame(FFVulkanContext *s, FFVkExecContext *e, AVFrame *f, VkPipelineStageFlagBits2 wait_stage, VkPipelineStageFlagBits2 signal_stage)
Definition vulkan.c:889
void ff_vk_shader_update_push_const(FFVulkanContext *s, FFVkExecContext *e, FFVulkanShader *shd, VkShaderStageFlagBits stage, int offset, size_t size, void *src)
Update push constant in a shader.
Definition vulkan.c:2750
@ SWS_FILTER_SCALE
14-bit coefficients are picked to fit comfortably within int16_t for efficient SIMD processing (e....
Definition filters.h:40
static const struct @257111027162314367033347246032313251342043035002 planes[]
uint8_t w
Definition llvidencdsp.c:39
static const uint16_t mask[17]
Definition lzw.c:38
#define FFMAX(a, b)
Definition macros.h:47
#define FFALIGN(x, a)
Definition macros.h:78
Memory handling functions.
static const char * obj
Definition mscl.c:57
const char data[16]
Definition mxf.c:149
const SwsOp * ff_sws_op_list_input(const SwsOpList *ops)
Returns the input operation for a given op list, or NULL if there is none (e.g.
Definition ops.c:782
int ff_sws_rw_op_planes(const SwsOp *op)
Return the number of planes involved in a read/write operation.
Definition ops.c:133
const SwsOp * ff_sws_op_list_output(const SwsOpList *ops)
Returns the output operation for a given op list, or NULL if there is none.
Definition ops.c:791
@ SWS_RW_PACKED
Definition ops.h:88
static void ff_sws_pack_decode(const uint8_t pattern[4], uint64_t mask[4], int shift[4])
int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt)
Definition pixdesc.c:3524
AVPixelFormat
Pixel format.
Definition pixfmt.h:71
@ AV_PIX_FMT_VULKAN
Vulkan hardware images.
Definition pixfmt.h:379
void av_refstruct_unref(void *objp)
Decrement the reference count of the underlying object and automatically free the object if there are...
Definition refstruct.c:121
void * av_refstruct_ref(void *obj)
Create a new reference to an object managed via this API, i.e.
Definition refstruct.c:141
static void * av_refstruct_alloc_ext(size_t size, unsigned flags, void *opaque, void(*free_cb)(AVRefStructOpaque opaque, void *obj))
A wrapper around av_refstruct_alloc_ext_c() for the common case of a non-const qualified opaque.
Definition refstruct.h:94
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 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 void spi_OpMemoryModel(SPICtx *spi, SpvAddressingModel addressing_model, SpvMemoryModel memory_model)
Definition spvasm.h:209
#define spi_OpCompositeExtract(spi, res_type, src,...)
Definition spvasm.h:403
#define spi_OpExtInst(spi, res_type, instr_id, set_id,...)
Definition spvasm.h:433
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_OpTypeArray(SPICtx *spi, int element_type_id, int id, int length_id)
Definition spvasm.h:555
#define spi_OpMemberDecorate(spi, type, target, deco,...)
Definition spvasm.h:445
#define spi_OpTypeStruct(spi, id,...)
Definition spvasm.h:437
#define spi_OpDecorate(spi, target, deco,...)
Definition spvasm.h:441
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
static int spi_OpConstantFloat(SPICtx *spi, int type_id, float val)
Definition spvasm.h:683
#define spi_OpConstantComposite(spi, res_type, src,...)
Definition spvasm.h:391
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 int spi_OpConstantInt(SPICtx *spi, int type_id, int val)
Definition spvasm.h:671
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 int spi_OpLabel(SPICtx *spi, int label_id)
Definition spvasm.h:605
#define spi_OpAccessChain(spi, res_type, ptr_id,...)
Definition spvasm.h:395
static void spi_init(SPICtx *spi)
Definition spvasm.h:156
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
#define spi_OpCompositeConstruct(spi, res_type, src,...)
Definition spvasm.h:399
static void spi_OpFunction(SPICtx *spi, int fn_id, int result_type_id, SpvFunctionControlMask function_control, int function_type_id)
Definition spvasm.h:594
#define spi_OpCompositeInsert(spi, res_type, src1, src2,...)
Definition spvasm.h:453
#define spi_OpVectorShuffle(spi, res_type, src1, src2,...)
Definition spvasm.h:449
static int spi_get_id(SPICtx *spi)
Definition spvasm.h:217
static int spi_OpExtInstImport(SPICtx *spi, const char *name)
Definition spvasm.h:482
static void spi_OpSelectionMerge(SPICtx *spi, int merge_block, SpvSelectionControlMask selection_control)
Definition spvasm.h:721
static int spi_OpTypeVoid(SPICtx *spi)
Definition spvasm.h:508
static void spi_OpImageWrite(SPICtx *spi, int img_id, int pos_id, int src_id, SpvImageOperandsMask image_operands)
Definition spvasm.h:756
A reference to a data buffer.
Definition buffer.h:82
uint8_t * data
The data buffer.
Definition buffer.h:90
This structure describes decoded (raw) audio or video data.
Definition frame.h:479
VkCommandBuffer buf
Definition vulkan.h:142
Copyright (C) 2026 Lynne.
Definition ops.h:27
int precompiled
Definition vulkan.h:215
uint32_t lg_size[3]
Definition vulkan.h:219
int nb_iface
Definition ops.c:263
int in_img_type
Definition ops.c:300
int iface[3+MAX_DATA_BUFS+1]
Definition ops.c:262
int out_img_array_id
Definition ops.c:298
int i32_type
Definition ops.c:276
int b_type
Definition ops.c:274
int in_img[4]
Definition ops.c:325
int u32vec3_type
Definition ops.c:285
int void_type
Definition ops.c:273
int gid
Definition ops.c:326
int bitexact
Definition ops.c:322
int u32vec3_tptr
Definition ops.c:304
int src_gid
Definition ops.c:327
int in_img_var
Definition ops.c:266
int u32_type
Definition ops.c:275
int dst_gid
Definition ops.c:327
int in_img_array_id
Definition ops.c:301
int gid_var
Definition ops.c:265
int gi2
Definition ops.c:326
const SwsOpList * ops
Definition ops.c:321
int push_const_var_id
Definition ops.c:316
int f32_type
Definition ops.c:277
int f32mat4_type
Definition ops.c:289
int bvec2_type
Definition ops.c:281
FFVulkanDescriptorSetBinding buf_desc[MAX_DATA_BUFS]
Definition ops.c:320
int out_img_tptr
Definition ops.c:305
int interlaced
Definition ops.c:312
int in_img_tptr
Definition ops.c:308
int out_img_type
Definition ops.c:297
int push_const_ptr_id
Definition ops.c:314
int in_img_sptr
Definition ops.c:309
int u32_cid[5]
Definition ops.c:293
int ep
Definition ops.c:270
int out_img_sptr
Definition ops.c:306
int dither_ptr_elem_id
Definition ops.c:295
int u32vec2_type
Definition ops.c:282
int push_const_struct_id
Definition ops.c:313
int glfn
Definition ops.c:269
int f32vec4_type
Definition ops.c:288
VulkanPriv * priv
Definition ops.c:319
int out_img[4]
Definition ops.c:325
int i32vec2_type
Definition ops.c:283
int u32vec4_type
Definition ops.c:287
int field_i32
Definition ops.c:317
int f32_0
Definition ops.c:292
int out_img_var
Definition ops.c:267
int void_fn_type
Definition ops.c:278
int push_const_elem_ptr_id
Definition ops.c:315
Main external API structure.
Definition swscale.h:227
unsigned flags
Bitmask of SWS_*.
Definition swscale.h:238
uint8_t size_log2
Definition uops.h:283
uint8_t y_offset[4]
Definition uops.h:282
SwsPixelType type
Definition uops.h:237
Represents a computed filter kernel.
Definition filters.h:91
size_t num_weights
Definition filters.h:104
int * weights
The computed look-up table (LUT).
Definition filters.h:103
int filter_size
The number of source texels to convolve over for each row.
Definition filters.h:95
int * offsets
The computed source pixel positions for each row of the filter.
Definition filters.h:111
enum AVPixelFormat format
Definition format.h:85
int interlaced
Definition format.h:83
int field
Definition format.h:84
Represents a view into a single field of frame data.
Definition format.h:206
SwsFormat dst
Definition graph.h:166
uint32_t zero
Definition uops.h:269
int8_t src[SWS_UOP_MOVE_MAX]
Definition uops.h:251
int num_moves
Definition uops.h:247
int8_t dst[SWS_UOP_MOVE_MAX]
Definition uops.h:250
Helper struct for representing a list of operations.
Definition ops.h:318
SwsFormat dst
Definition ops.h:323
uint8_t plane_src[4]
Definition ops.h:326
uint8_t plane_dst[4]
Definition ops.h:326
SwsOp * ops
Definition ops.h:319
SwsFormat src
Definition ops.h:323
Definition ops.h:252
SwsReadWriteOp rw
Definition ops.h:256
uint8_t pattern[4]
Definition uops.h:255
Represents a single filter pass in the scaling graph.
Definition graph.h:85
void * priv
Definition graph.h:122
const SwsGraph * graph
Definition graph.h:86
SwsPixelType type
Examples: rgba = 4x u8 packed yuv444p = 3x u8 rgb565 = 1x u16 <- use SWS_OP_UNPACK to unpack monow = ...
Definition ops.h:102
uint8_t amount
Definition uops.h:241
SwsUOp * ops
Definition uops.h:345
int num_ops
Definition uops.h:346
Definition uops.h:308
SwsPixel scalar
Definition uops.h:319
SwsCompMask mask
Definition uops.h:312
SwsUOpType uop
Definition uops.h:311
SwsUOpParams par
Definition uops.h:313
SwsFilterWeights * kernel
Definition uops.h:317
SwsPixel * ptr
Definition uops.h:318
union SwsUOp::@242237116251216327057105100216205033300341206345 data
SwsPixelType type
Definition uops.h:310
SwsPixel mat4x5[4][5]
Definition uops.h:321
SwsPixel vec4[4]
Definition uops.h:320
FFVkBuffer data_bufs[MAX_DATA_BUFS]
Definition ops.c:88
FFVulkanOpsCtx * s
Definition ops.c:85
int interlaced
Definition ops.c:92
int nb_data_bufs
Definition ops.c:89
FFVulkanShader shd
Definition ops.c:87
VkFormat src_view_fmt[AV_NUM_DATA_POINTERS]
Definition ops.c:90
VkFormat dst_view_fmt[AV_NUM_DATA_POINTERS]
Definition ops.c:91
FFVkExecPool e
Definition ops.c:86
static SwsInternal * sws_internal(const SwsContext *sws)
#define av_free(p)
#define av_mallocz(s)
#define av_log(a,...)
static void error(const char *err)
static uint8_t tmp[40]
Definition aes_ctr.c:52
#define src
Definition vp8dsp.c:248
int size
RefStruct is an API for creating reference-counted objects with minimal overhead.
Definition refstruct.h:58
float f32
Definition uops.h:85
uint32_t u32
Definition uops.h:84
uint8_t u8
Definition uops.h:82
uint16_t u16
Definition uops.h:83
SwsMoveUOp move
Definition uops.h:300
SwsDitherUOp dither
Definition uops.h:304
SwsFilterUOp filter
Definition uops.h:298
SwsLinearUOp lin
Definition uops.h:303
SwsShiftUOp shift
Definition uops.h:299
SwsPackUOp pack
Definition uops.h:301
int ff_sws_ops_translate(SwsContext *ctx, const SwsOpList *ops, SwsUOpFlags flags, SwsUOpList *uops)
Translate a list of operations down to micro-ops, which can be further optimized and then directly ex...
Definition uops.c:644
int ff_sws_dither_height(const SwsDitherUOp *dither)
Computes (1 << size_log2) + MAX(y_offset).
Definition uops.c:218
SwsUOpList * ff_sws_uop_list_alloc(void)
Definition uops.c:176
void ff_sws_uop_list_free(SwsUOpList **p_ops)
Definition uops.c:162
void ff_sws_uop_list_print(void *log, int lev, const SwsUOpList *uops)
Print the micro-ops of a compiled list at the given log level.
Definition uops.c:205
#define SWS_MASK_OFF(I)
Definition uops.h:276
SwsPixelType
Definition uops.h:40
@ SWS_PIXEL_F32
Definition uops.h:45
@ SWS_PIXEL_U32
Definition uops.h:44
@ SWS_PIXEL_U16
Definition uops.h:43
@ SWS_PIXEL_NONE
Definition uops.h:41
@ SWS_PIXEL_U8
Definition uops.h:42
#define SWS_COMP_TEST(mask, X)
Definition uops.h:134
#define SWS_MASK(I, J)
Definition uops.h:275
@ SWS_UOP_TO_U8
Definition uops.h:199
@ SWS_UOP_PACK
Definition uops.h:212
@ SWS_UOP_PERMUTE
Definition uops.h:191
@ SWS_UOP_EXPAND_QUAD
Definition uops.h:198
@ SWS_UOP_READ_PLANAR
Definition uops.h:173
@ SWS_UOP_WRITE_PLANAR
Definition uops.h:182
@ SWS_UOP_MAX
Definition uops.h:208
@ SWS_UOP_MIN
Definition uops.h:207
@ SWS_UOP_LINEAR
Definition uops.h:216
@ SWS_UOP_RSHIFT
Definition uops.h:214
@ SWS_UOP_COPY
Definition uops.h:192
@ SWS_UOP_READ_PLANAR_FH
Definition uops.h:174
@ SWS_UOP_SCALE
Definition uops.h:205
@ SWS_UOP_WRITE_PACKED
Definition uops.h:183
@ SWS_UOP_READ_PACKED
Definition uops.h:177
@ SWS_UOP_EXPAND_PAIR
Definition uops.h:197
@ SWS_UOP_TO_U16
Definition uops.h:200
@ SWS_UOP_DITHER
Definition uops.h:218
@ SWS_UOP_ADD
Definition uops.h:206
@ SWS_UOP_CLEAR
Definition uops.h:215
@ SWS_UOP_READ_PLANAR_FV
Definition uops.h:175
@ SWS_UOP_TO_U32
Definition uops.h:201
@ SWS_UOP_UNPACK
Definition uops.h:211
@ SWS_UOP_TO_F32
Definition uops.h:202
@ SWS_UOP_LSHIFT
Definition uops.h:213
@ SWS_UOP_FLAG_ADD
Definition uops.h:165
static av_const bool ff_sws_pixel_type_is_int(SwsPixelType type)
Definition uops.h:64
#define img
int len
static double c[64]
AVBufferRef * ff_sws_vk_device_ref(SwsContext *sws)
Returns the Vulkan device reference associated with sws, or NULL if Vulkan has not been initialized f...
Definition ops.c:73
static void define_shader_consts(SPICtx *spi, SPIRVIDs *id)
Definition ops.c:442
static int create_filter_buf(FFVulkanOpsCtx *s, const SwsFilterWeights *wd, FFVkBuffer *buf)
Definition ops.c:193
static int insert_bitexact_linear(const SwsUOp *uop, SPICtx *spi, SPIRVIDs *id, int data)
Definition ops.c:590
static int add_buf_binding(SPIRVIDs *id)
Definition ops.c:646
static int compile_ops_spirv(SwsContext *sws, const SwsOpList *ops, SwsCompiledOp *out)
Definition ops.c:1270
static int emit_add(SPICtx *spi, SwsPixelType type, int res_type, int a, int b)
Definition ops.c:389
static void spirv_free(void *priv)
Definition ops.c:182
static int emit_convert(SPICtx *spi, SwsPixelType from, SwsPixelType to, int res_type, int a)
Definition ops.c:416
static int create_dither_buf(FFVulkanOpsCtx *s, const SwsUOp *uop, FFVkBuffer *buf)
Definition ops.c:228
static void spirv_process(const SwsFrame *dst, const SwsFrame *src, int y, int h, const SwsPass *pass)
Definition ops.c:95
static int emit_dither(SPICtx *spi, SPIRVIDs *id, const SwsUOp *uop, int *data)
Definition ops.c:898
static int emit_min(SPICtx *spi, const SPIRVIDs *id, SwsPixelType type, int res_type, int a, int b)
Definition ops.c:401
static int insert_vmat_linear(const SwsUOp *uop, SPICtx *spi, SPIRVIDs *id, int data)
Definition ops.c:567
static int emit_pack(SPICtx *spi, SPIRVIDs *id, const SwsUOp *uop, int *data)
Definition ops.c:971
static int type_vec4(const SPIRVIDs *id, SwsPixelType type)
Definition ops.c:337
#define MAX_DATA_BUFS
Definition ops.c:82
static void vk_ops_ctx_uninit(AVRefStructOpaque opaque, void *obj)
Copyright (C) 2026 Lynne.
Definition ops.c:33
static int emit_shader(SwsContext *sws, VulkanPriv *p, FFVulkanOpsCtx *s, const SwsOpList *ops, const SwsUOpList *uops, FFVulkanShader *shd, SPICtx *spi)
Definition ops.c:989
static int emit_read(SPICtx *spi, SPIRVIDs *id, const SwsUOp *uop, int *data)
Definition ops.c:811
static void define_shader_bindings(const SwsOpList *ops, SPICtx *spi, SPIRVIDs *id, int in_img_count, int out_img_count)
Definition ops.c:472
static int rw_op_img_count(const SwsOp *op, const uint8_t *planes)
Definition ops.c:802
static int emit_clamp(SPICtx *spi, SPIRVIDs *id, const SwsUOp *uop, int *data)
Definition ops.c:877
static void define_shader_header(SPICtx *spi, SPIRVIDs *id)
Definition ops.c:426
static int emit_max(SPICtx *spi, const SPIRVIDs *id, SwsPixelType type, int res_type, int a, int b)
Definition ops.c:408
static void define_pack_consts(SPICtx *spi, const SPIRVIDs *id, const SwsUOp *uop, int *shift_id, int *mask_id)
Definition ops.c:372
static int emit_linear(SPICtx *spi, SPIRVIDs *id, const SwsUOp *uop, int *data)
Definition ops.c:961
static int get_view_fmts(VkFormat view_fmts[AV_NUM_DATA_POINTERS], enum AVPixelFormat fmt, const SwsOp *op)
Definition ops.c:778
static int const_splat(SPICtx *spi, const SPIRVIDs *id, SwsPixelType type, SwsPixel px)
Definition ops.c:364
static void define_entry_point(FFVulkanShader *shd, SPICtx *spi, SPIRVIDs *id)
Definition ops.c:559
static int emit_write(SPICtx *spi, SPIRVIDs *id, const SwsUOp *uop, int *data)
Definition ops.c:849
static int type_scalar(const SPIRVIDs *id, SwsPixelType type)
Definition ops.c:331
static int emit_read_filtered(SPICtx *spi, SPIRVIDs *id, const SwsUOp *uop, int *data)
Definition ops.c:656
static int add_ops_spirv(SwsContext *sws, VulkanPriv *p, FFVulkanOpsCtx *s, const SwsOpList *ops, const SwsUOpList *uops, FFVulkanShader *shd)
Definition ops.c:1244
int ff_sws_vk_init(SwsContext *sws, AVBufferRef *dev_ref)
Definition ops.c:40
static VkFormat packed_word_fmt(const SwsOp *op)
Definition ops.c:765
static int emit_mul(SPICtx *spi, SwsPixelType type, int res_type, int a, int b)
Definition ops.c:395
static int const_pixel(SPICtx *spi, const SPIRVIDs *id, SwsPixelType type, SwsPixel px)
Definition ops.c:349
static int const_zero(const SPIRVIDs *id, SwsPixelType type)
Definition ops.c:343
const SwsOpBackend backend_spirv
Definition ops.c:1331
FFVkShaderRepFormat
Returns the format to use for images in shaders.
Definition vulkan.h:438
@ FF_VK_REP_UINT
Definition vulkan.h:446
@ FF_VK_REP_NATIVE
Definition vulkan.h:440
@ FF_VK_REP_FLOAT
Definition vulkan.h:442
static int ff_vk_unmap_buffer(FFVulkanContext *s, FFVkBuffer *buf, int flush)
Definition vulkan.h:668
static int ff_vk_map_buffer(FFVulkanContext *s, FFVkBuffer *buf, uint8_t **mem, int invalidate)
Definition vulkan.h:661