Chiebot-Mirror
/
FFmpeg
mirror of https://github.com/FFmpeg/FFmpeg.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

scale_vulkan: port for the rewrite

Browse Source
pull/389/head
Lynne 2 years ago
parent 8e9ceb1efb
commit d4b51b5085
No known key found for this signature in database
GPG Key ID: A2FEA5F03F034464
1 changed files with 125 additions and 241 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 366
      libavfilter/vf_scale_vulkan.c

366
libavfilter/vf_scale_vulkan.c
Unescape View File

@ -1,4 +1,6 @@
/* /*
* Copyright (c) Lynne
*
* This file is part of FFmpeg. * This file is part of FFmpeg.
* *
* FFmpeg is free software; you can redistribute it and/or * FFmpeg is free software; you can redistribute it and/or
@ -19,12 +21,11 @@
#include "libavutil/random_seed.h" #include "libavutil/random_seed.h"
#include "libavutil/opt.h" #include "libavutil/opt.h"
#include "vulkan_filter.h" #include "vulkan_filter.h"
#include "vulkan_spirv.h"
#include "scale_eval.h" #include "scale_eval.h"
#include "internal.h" #include "internal.h"
#include "colorspace.h" #include "colorspace.h"
#define CGROUPS (int [3]){ 32, 32, 1 }
enum ScalerFunc { enum ScalerFunc {
F_BILINEAR = 0, F_BILINEAR = 0,
F_NEAREST, F_NEAREST,
@ -35,15 +36,17 @@ enum ScalerFunc {
typedef struct ScaleVulkanContext { typedef struct ScaleVulkanContext {
FFVulkanContext vkctx; FFVulkanContext vkctx;
int initialized;
FFVulkanPipeline pl;
FFVkExecPool e;
FFVkQueueFamilyCtx qf; FFVkQueueFamilyCtx qf;
FFVkExecContext *exec; FFVkSPIRVShader shd;
FFVulkanPipeline *pl; VkSampler sampler;
FFVkBuffer params_buf;
/* Shader updators, must be in the main filter struct */ /* Push constants / options */
VkDescriptorImageInfo input_images[3]; struct {
VkDescriptorImageInfo output_images[3]; float yuv_matrix[4][4];
VkDescriptorBufferInfo params_desc; } opts;
char *out_format_string; char *out_format_string;
char *w_expr; char *w_expr;
@ -51,8 +54,6 @@ typedef struct ScaleVulkanContext {
enum ScalerFunc scaler; enum ScalerFunc scaler;
enum AVColorRange out_range; enum AVColorRange out_range;
int initialized;
} ScaleVulkanContext; } ScaleVulkanContext;
static const char scale_bilinear[] = { static const char scale_bilinear[] = {
@ -110,10 +111,15 @@ static const char write_444[] = {
static av_cold int init_filter(AVFilterContext *ctx, AVFrame *in) static av_cold int init_filter(AVFilterContext *ctx, AVFrame *in)
{ {
int err; int err;
FFVkSampler *sampler; uint8_t *spv_data;
size_t spv_len;
void *spv_opaque = NULL;
VkFilter sampler_mode; VkFilter sampler_mode;
ScaleVulkanContext *s = ctx->priv; ScaleVulkanContext *s = ctx->priv;
FFVulkanContext *vkctx = &s->vkctx; FFVulkanContext *vkctx = &s->vkctx;
FFVkSPIRVShader *shd = &s->shd;
FFVkSPIRVCompiler *spv;
FFVulkanDescriptorSetBinding *desc;
int crop_x = in->crop_left; int crop_x = in->crop_left;
int crop_y = in->crop_top; int crop_y = in->crop_top;
@ -121,8 +127,6 @@ static av_cold int init_filter(AVFilterContext *ctx, AVFrame *in)
int crop_h = in->height - (in->crop_top + in->crop_bottom); int crop_h = in->height - (in->crop_top + in->crop_bottom);
int in_planes = av_pix_fmt_count_planes(s->vkctx.input_format); int in_planes = av_pix_fmt_count_planes(s->vkctx.input_format);
ff_vk_qf_init(vkctx, &s->qf, VK_QUEUE_COMPUTE_BIT, 0);
switch (s->scaler) { switch (s->scaler) {
case F_NEAREST: case F_NEAREST:
sampler_mode = VK_FILTER_NEAREST; sampler_mode = VK_FILTER_NEAREST;
@ -132,264 +136,134 @@ static av_cold int init_filter(AVFilterContext *ctx, AVFrame *in)
break; break;
}; };
/* Create a sampler */ spv = ff_vk_spirv_init();
sampler = ff_vk_init_sampler(vkctx, 0, sampler_mode); if (!spv) {
if (!sampler) av_log(ctx, AV_LOG_ERROR, "Unable to initialize SPIR-V compiler!\n");
return AVERROR_EXTERNAL; return AVERROR_EXTERNAL;
}
s->pl = ff_vk_create_pipeline(vkctx, &s->qf); ff_vk_qf_init(vkctx, &s->qf, VK_QUEUE_COMPUTE_BIT);
if (!s->pl) RET(ff_vk_exec_pool_init(vkctx, &s->qf, &s->e, s->qf.nb_queues*4, 0, 0, 0, NULL));
return AVERROR(ENOMEM); RET(ff_vk_init_sampler(vkctx, &s->sampler, 0, sampler_mode));
RET(ff_vk_shader_init(&s->pl, &s->shd, "scale_compute",
{ /* Create the shader */ VK_SHADER_STAGE_COMPUTE_BIT, 0));
FFVulkanDescriptorSetBinding desc_i[2] = {
{ ff_vk_shader_set_compute_sizes(&s->shd, 32, 32, 1);
.name = "input_img",
.type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, GLSLC(0, layout(push_constant, std430) uniform pushConstants { );
.dimensions = 2, GLSLC(1, mat4 yuv_matrix; );
.elems = in_planes, GLSLC(0, }; );
.stages = VK_SHADER_STAGE_COMPUTE_BIT, GLSLC(0, );
.updater = s->input_images,
.sampler = sampler, ff_vk_add_push_constant(&s->pl, 0, sizeof(s->opts),
}, VK_SHADER_STAGE_COMPUTE_BIT);
{
.name = "output_img", desc = (FFVulkanDescriptorSetBinding []) {
.type = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, {
.mem_layout = ff_vk_shader_rep_fmt(s->vkctx.output_format), .name = "input_img",
.mem_quali = "writeonly", .type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
.dimensions = 2, .dimensions = 2,
.elems = av_pix_fmt_count_planes(s->vkctx.output_format), .elems = in_planes,
.stages = VK_SHADER_STAGE_COMPUTE_BIT, .stages = VK_SHADER_STAGE_COMPUTE_BIT,
.updater = s->output_images, .samplers = DUP_SAMPLER(s->sampler),
}, },
}; {
.name = "output_img",
FFVulkanDescriptorSetBinding desc_b = { .type = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
.name = "params", .mem_layout = ff_vk_shader_rep_fmt(s->vkctx.output_format),
.type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, .mem_quali = "writeonly",
.mem_quali = "readonly", .dimensions = 2,
.mem_layout = "std430", .elems = av_pix_fmt_count_planes(s->vkctx.output_format),
.stages = VK_SHADER_STAGE_COMPUTE_BIT, .stages = VK_SHADER_STAGE_COMPUTE_BIT,
.updater = &s->params_desc, },
.buf_content = "mat4 yuv_matrix;", };
};
FFVkSPIRVShader *shd = ff_vk_init_shader(s->pl, "scale_compute",
VK_SHADER_STAGE_COMPUTE_BIT);
if (!shd)
return AVERROR(ENOMEM);
ff_vk_set_compute_shader_sizes(shd, CGROUPS);
RET(ff_vk_add_descriptor_set(vkctx, s->pl, shd, desc_i, FF_ARRAY_ELEMS(desc_i), 0)); /* set 0 */
RET(ff_vk_add_descriptor_set(vkctx, s->pl, shd, &desc_b, 1, 0)); /* set 1 */
GLSLD( scale_bilinear );
if (s->vkctx.output_format != s->vkctx.input_format) {
GLSLD( rgb2yuv );
}
switch (s->vkctx.output_format) { RET(ff_vk_pipeline_descriptor_set_add(vkctx, &s->pl, shd, desc, 2, 0, 0));
case AV_PIX_FMT_NV12: GLSLD(write_nv12); break;
case AV_PIX_FMT_YUV420P: GLSLD( write_420); break;
case AV_PIX_FMT_YUV444P: GLSLD( write_444); break;
default: break;
}
GLSLC(0, void main() ); GLSLD( scale_bilinear );
GLSLC(0, { );
GLSLC(1, ivec2 size; ); if (s->vkctx.output_format != s->vkctx.input_format) {
GLSLC(1, ivec2 pos = ivec2(gl_GlobalInvocationID.xy); ); GLSLD( rgb2yuv );
GLSLF(1, vec2 in_d = vec2(%i, %i); ,in->width, in->height); }
GLSLF(1, vec2 c_r = vec2(%i, %i) / in_d; ,crop_w, crop_h);
GLSLF(1, vec2 c_o = vec2(%i, %i) / in_d; ,crop_x,crop_y);
GLSLC(0, );
if (s->vkctx.output_format == s->vkctx.input_format) {
for (int i = 0; i < desc_i[1].elems; i++) {
GLSLF(1, size = imageSize(output_img[%i]); ,i);
GLSLC(1, if (IS_WITHIN(pos, size)) { );
switch (s->scaler) {
case F_NEAREST:
case F_BILINEAR:
GLSLF(2, vec4 res = scale_bilinear(%i, pos, c_r, c_o); ,i);
GLSLF(2, imageStore(output_img[%i], pos, res); ,i);
break;
};
GLSLC(1, } );
}
} else {
GLSLC(1, vec4 res = scale_bilinear(0, pos, c_r, c_o); );
GLSLF(1, res = rgb2yuv(res, %i); ,s->out_range == AVCOL_RANGE_JPEG);
switch (s->vkctx.output_format) {
case AV_PIX_FMT_NV12: GLSLC(1, write_nv12(res, pos); ); break;
case AV_PIX_FMT_YUV420P: GLSLC(1, write_420(res, pos); ); break;
case AV_PIX_FMT_YUV444P: GLSLC(1, write_444(res, pos); ); break;
default: return AVERROR(EINVAL);
}
}
GLSLC(0, } ); switch (s->vkctx.output_format) {
case AV_PIX_FMT_NV12: GLSLD(write_nv12); break;
case AV_PIX_FMT_YUV420P: GLSLD( write_420); break;
case AV_PIX_FMT_YUV444P: GLSLD( write_444); break;
default: break;
}
RET(ff_vk_compile_shader(vkctx, shd, "main")); GLSLC(0, void main() );
GLSLC(0, { );
GLSLC(1, ivec2 size; );
GLSLC(1, ivec2 pos = ivec2(gl_GlobalInvocationID.xy); );
GLSLF(1, vec2 in_d = vec2(%i, %i); ,in->width, in->height);
GLSLF(1, vec2 c_r = vec2(%i, %i) / in_d; ,crop_w, crop_h);
GLSLF(1, vec2 c_o = vec2(%i, %i) / in_d; ,crop_x,crop_y);
GLSLC(0, );
if (s->vkctx.output_format == s->vkctx.input_format) {
for (int i = 0; i < desc[i].elems; i++) {
GLSLF(1, size = imageSize(output_img[%i]); ,i);
GLSLC(1, if (IS_WITHIN(pos, size)) { );
switch (s->scaler) {
case F_NEAREST:
case F_BILINEAR:
GLSLF(2, vec4 res = scale_bilinear(%i, pos, c_r, c_o); ,i);
GLSLF(2, imageStore(output_img[%i], pos, res); ,i);
break;
};
GLSLC(1, } );
}
} else {
GLSLC(1, vec4 res = scale_bilinear(0, pos, c_r, c_o); );
GLSLF(1, res = rgb2yuv(res, %i); ,s->out_range == AVCOL_RANGE_JPEG);
switch (s->vkctx.output_format) {
case AV_PIX_FMT_NV12: GLSLC(1, write_nv12(res, pos); ); break;
case AV_PIX_FMT_YUV420P: GLSLC(1, write_420(res, pos); ); break;
case AV_PIX_FMT_YUV444P: GLSLC(1, write_444(res, pos); ); break;
default: return AVERROR(EINVAL);
}
} }
RET(ff_vk_init_pipeline_layout(vkctx, s->pl)); GLSLC(0, } );
RET(ff_vk_init_compute_pipeline(vkctx, s->pl));
if (s->vkctx.output_format != s->vkctx.input_format) { if (s->vkctx.output_format != s->vkctx.input_format) {
const AVLumaCoefficients *lcoeffs; const AVLumaCoefficients *lcoeffs;
double tmp_mat[3][3]; double tmp_mat[3][3];
struct {
float yuv_matrix[4][4];
} *par;
lcoeffs = av_csp_luma_coeffs_from_avcsp(in->colorspace); lcoeffs = av_csp_luma_coeffs_from_avcsp(in->colorspace);
if (!lcoeffs) { if (!lcoeffs) {
av_log(ctx, AV_LOG_ERROR, "Unsupported colorspace\n"); av_log(ctx, AV_LOG_ERROR, "Unsupported colorspace\n");
return AVERROR(EINVAL); return AVERROR(EINVAL);
} }
RET(ff_vk_create_buf(vkctx, &s->params_buf,
sizeof(*par), NULL, NULL,
VK_BUFFER_USAGE_STORAGE_BUFFER_BIT,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT));
RET(ff_vk_map_buffers(vkctx, &s->params_buf, (uint8_t **)&par, 1, 0));
ff_fill_rgb2yuv_table(lcoeffs, tmp_mat); ff_fill_rgb2yuv_table(lcoeffs, tmp_mat);
memset(par, 0, sizeof(*par));
for (int y = 0; y < 3; y++) for (int y = 0; y < 3; y++)
for (int x = 0; x < 3; x++) for (int x = 0; x < 3; x++)
par->yuv_matrix[x][y] = tmp_mat[x][y]; s->opts.yuv_matrix[x][y] = tmp_mat[x][y];
s->opts.yuv_matrix[3][3] = 1.0;
par->yuv_matrix[3][3] = 1.0;
RET(ff_vk_unmap_buffers(vkctx, &s->params_buf, 1, 1));
s->params_desc.buffer = s->params_buf.buf;
s->params_desc.range = VK_WHOLE_SIZE;
ff_vk_update_descriptor_set(vkctx, s->pl, 1);
} }
/* Execution context */ RET(spv->compile_shader(spv, ctx, shd, &spv_data, &spv_len, "main",
RET(ff_vk_create_exec_ctx(vkctx, &s->exec, &s->qf)); &spv_opaque));
RET(ff_vk_shader_create(vkctx, shd, spv_data, spv_len, "main"));
RET(ff_vk_init_compute_pipeline(vkctx, &s->pl, shd));
RET(ff_vk_exec_pipeline_register(vkctx, &s->e, &s->pl));
s->initialized = 1; s->initialized = 1;
return 0; return 0;
fail: fail:
return err; if (spv_opaque)
} spv->free_shader(spv, &spv_opaque);
if (spv)
static int process_frames(AVFilterContext *avctx, AVFrame *out_f, AVFrame *in_f) spv->uninit(&spv);
{
int err = 0;
VkCommandBuffer cmd_buf;
ScaleVulkanContext *s = avctx->priv;
FFVulkanContext *vkctx = &s->vkctx;
FFVulkanFunctions *vk = &vkctx->vkfn;
AVVkFrame *in = (AVVkFrame *)in_f->data[0];
AVVkFrame *out = (AVVkFrame *)out_f->data[0];
VkImageMemoryBarrier barriers[AV_NUM_DATA_POINTERS*2];
int barrier_count = 0;
const int planes = av_pix_fmt_count_planes(s->vkctx.input_format);
const VkFormat *input_formats = av_vkfmt_from_pixfmt(s->vkctx.input_format);
const VkFormat *output_formats = av_vkfmt_from_pixfmt(s->vkctx.output_format);
/* Update descriptors and init the exec context */
ff_vk_start_exec_recording(vkctx, s->exec);
cmd_buf = ff_vk_get_exec_buf(s->exec);
for (int i = 0; i < planes; i++) {
RET(ff_vk_create_imageview(vkctx, s->exec,
&s->input_images[i].imageView, in->img[i],
input_formats[i],
ff_comp_identity_map));
RET(ff_vk_create_imageview(vkctx, s->exec,
&s->output_images[i].imageView, out->img[i],
output_formats[i],
ff_comp_identity_map));
s->input_images[i].imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
s->output_images[i].imageLayout = VK_IMAGE_LAYOUT_GENERAL;
}
ff_vk_update_descriptor_set(vkctx, s->pl, 0);
for (int i = 0; i < planes; i++) {
VkImageMemoryBarrier bar = {
.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
.srcAccessMask = 0,
.dstAccessMask = VK_ACCESS_SHADER_READ_BIT,
.oldLayout = in->layout[i],
.newLayout = s->input_images[i].imageLayout,
.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
.image = in->img[i],
.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
.subresourceRange.levelCount = 1,
.subresourceRange.layerCount = 1,
};
memcpy(&barriers[barrier_count++], &bar, sizeof(VkImageMemoryBarrier));
in->layout[i] = bar.newLayout;
in->access[i] = bar.dstAccessMask;
}
for (int i = 0; i < av_pix_fmt_count_planes(s->vkctx.output_format); i++) {
VkImageMemoryBarrier bar = {
.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
.srcAccessMask = 0,
.dstAccessMask = VK_ACCESS_SHADER_WRITE_BIT,
.oldLayout = out->layout[i],
.newLayout = s->output_images[i].imageLayout,
.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
.image = out->img[i],
.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
.subresourceRange.levelCount = 1,
.subresourceRange.layerCount = 1,
};
memcpy(&barriers[barrier_count++], &bar, sizeof(VkImageMemoryBarrier));
out->layout[i] = bar.newLayout;
out->access[i] = bar.dstAccessMask;
}
vk->CmdPipelineBarrier(cmd_buf, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, 0,
0, NULL, 0, NULL, barrier_count, barriers);
ff_vk_bind_pipeline_exec(vkctx, s->exec, s->pl);
vk->CmdDispatch(cmd_buf,
FFALIGN(vkctx->output_width, CGROUPS[0])/CGROUPS[0],
FFALIGN(vkctx->output_height, CGROUPS[1])/CGROUPS[1], 1);
ff_vk_add_exec_dep(vkctx, s->exec, in_f, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT);
ff_vk_add_exec_dep(vkctx, s->exec, out_f, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT);
err = ff_vk_submit_exec_queue(vkctx, s->exec);
if (err)
return err;
ff_vk_qf_rotate(&s->qf);
return err; return err;
fail:
ff_vk_discard_exec_deps(s->exec);
return err;
} }
static int scale_vulkan_filter_frame(AVFilterLink *link, AVFrame *in) static int scale_vulkan_filter_frame(AVFilterLink *link, AVFrame *in)
@ -408,7 +282,8 @@ static int scale_vulkan_filter_frame(AVFilterLink *link, AVFrame *in)
if (!s->initialized) if (!s->initialized)
RET(init_filter(ctx, in)); RET(init_filter(ctx, in));
RET(process_frames(ctx, out, in)); RET(ff_vk_filter_process_simple(&s->vkctx, &s->e, &s->pl, out, in,
s->sampler, &s->opts, sizeof(s->opts)));
err = av_frame_copy_props(out, in); err = av_frame_copy_props(out, in);
if (err < 0) if (err < 0)
@ -475,8 +350,17 @@ static int scale_vulkan_config_output(AVFilterLink *outlink)
static void scale_vulkan_uninit(AVFilterContext *avctx) static void scale_vulkan_uninit(AVFilterContext *avctx)
{ {
ScaleVulkanContext *s = avctx->priv; ScaleVulkanContext *s = avctx->priv;
FFVulkanContext *vkctx = &s->vkctx;
FFVulkanFunctions *vk = &vkctx->vkfn;
ff_vk_exec_pool_free(vkctx, &s->e);
ff_vk_pipeline_free(vkctx, &s->pl);
ff_vk_shader_free(vkctx, &s->shd);
if (s->sampler)
vk->DestroySampler(vkctx->hwctx->act_dev, s->sampler,
vkctx->hwctx->alloc);
ff_vk_free_buf(&s->vkctx, &s->params_buf);
ff_vk_uninit(&s->vkctx); ff_vk_uninit(&s->vkctx);
s->initialized = 0; s->initialized = 0;

Write Preview
Loading…
Cancel
Save