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

flip_vulkan: port for the rewrite

Browse Source
pull/389/head
Lynne 2 years ago
parent 125636608d
commit d26cbae3e1
No known key found for this signature in database
GPG Key ID: A2FEA5F03F034464
1 changed files with 79 additions and 151 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 230
      libavfilter/vf_flip_vulkan.c

230
libavfilter/vf_flip_vulkan.c
Unescape View File

@ -1,5 +1,7 @@
/*
* copyright (c) 2021 Wu Jianhua <jianhua.wu@intel.com>
* Copyright (c) Lynne
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or
@ -20,10 +22,9 @@
#include "libavutil/random_seed.h"
#include "libavutil/opt.h"
#include "vulkan_filter.h"
#include "vulkan_spirv.h"
#include "internal.h"
#define CGS 32
enum FlipType {
FLIP_VERTICAL,
FLIP_HORIZONTAL,
@ -32,32 +33,50 @@ enum FlipType {
typedef struct FlipVulkanContext {
FFVulkanContext vkctx;
FFVkQueueFamilyCtx qf;
FFVkExecContext *exec;
FFVulkanPipeline *pl;
VkDescriptorImageInfo input_images[3];
VkDescriptorImageInfo output_images[3];
int initialized;
FFVulkanPipeline pl;
FFVkExecPool e;
FFVkQueueFamilyCtx qf;
FFVkSPIRVShader shd;
VkSampler sampler;
} FlipVulkanContext;
static av_cold int init_filter(AVFilterContext *ctx, AVFrame *in, enum FlipType type)
{
int err = 0;
FFVkSPIRVShader *shd;
uint8_t *spv_data;
size_t spv_len;
void *spv_opaque = NULL;
FlipVulkanContext *s = ctx->priv;
FFVulkanContext *vkctx = &s->vkctx;
const int planes = av_pix_fmt_count_planes(s->vkctx.output_format);
FFVkSPIRVShader *shd = &s->shd;
FFVkSPIRVCompiler *spv;
FFVulkanDescriptorSetBinding *desc;
spv = ff_vk_spirv_init();
if (!spv) {
av_log(ctx, AV_LOG_ERROR, "Unable to initialize SPIR-V compiler!\n");
return AVERROR_EXTERNAL;
}
ff_vk_qf_init(vkctx, &s->qf, VK_QUEUE_COMPUTE_BIT);
RET(ff_vk_exec_pool_init(vkctx, &s->qf, &s->e, s->qf.nb_queues*4, 0, 0, 0, NULL));
RET(ff_vk_init_sampler(vkctx, &s->sampler, 1, VK_FILTER_LINEAR));
RET(ff_vk_shader_init(&s->pl, &s->shd, "flip_compute",
VK_SHADER_STAGE_COMPUTE_BIT, 0));
ff_vk_shader_set_compute_sizes(&s->shd, 32, 32, 1);
FFVulkanDescriptorSetBinding image_descs[] = {
desc = (FFVulkanDescriptorSetBinding []) {
{
.name = "input_image",
.type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
.dimensions = 2,
.elems = planes,
.stages = VK_SHADER_STAGE_COMPUTE_BIT,
.updater = s->input_images,
.samplers = DUP_SAMPLER(s->sampler),
},
{
.name = "output_image",
@ -67,167 +86,75 @@ static av_cold int init_filter(AVFilterContext *ctx, AVFrame *in, enum FlipType
.dimensions = 2,
.elems = planes,
.stages = VK_SHADER_STAGE_COMPUTE_BIT,
.updater = s->output_images,
},
};
image_descs[0].sampler = ff_vk_init_sampler(vkctx, 1, VK_FILTER_LINEAR);
if (!image_descs[0].sampler)
return AVERROR_EXTERNAL;
RET(ff_vk_pipeline_descriptor_set_add(vkctx, &s->pl, shd, desc, 2, 0, 0));
ff_vk_qf_init(vkctx, &s->qf, VK_QUEUE_COMPUTE_BIT, 0);
{
s->pl = ff_vk_create_pipeline(vkctx, &s->qf);
if (!s->pl)
return AVERROR(ENOMEM);
shd = ff_vk_init_shader(s->pl, "flip_compute", image_descs[0].stages);
if (!shd)
return AVERROR(ENOMEM);
ff_vk_set_compute_shader_sizes(shd, (int [3]){ CGS, 1, 1 });
RET(ff_vk_add_descriptor_set(vkctx, s->pl, shd, image_descs, FF_ARRAY_ELEMS(image_descs), 0));
GLSLC(0, void main() );
GLSLC(0, { );
GLSLC(1, ivec2 size; );
GLSLC(1, const ivec2 pos = ivec2(gl_GlobalInvocationID.xy); );
for (int i = 0; i < planes; i++) {
GLSLC(0, );
GLSLF(1, size = imageSize(output_image[%i]); ,i);
GLSLC(1, if (IS_WITHIN(pos, size)) { );
switch (type)
{
case FLIP_HORIZONTAL:
GLSLF(2, vec4 res = texture(input_image[%i], ivec2(size.x - pos.x, pos.y)); ,i);
break;
case FLIP_VERTICAL:
GLSLF(2, vec4 res = texture(input_image[%i], ivec2(pos.x, size.y - pos.y)); ,i);
break;
case FLIP_BOTH:
GLSLF(2, vec4 res = texture(input_image[%i], ivec2(size.xy - pos.xy));, i);
break;
default:
GLSLF(2, vec4 res = texture(input_image[%i], pos); ,i);
break;
}
GLSLF(2, imageStore(output_image[%i], pos, res); ,i);
GLSLC(1, } );
GLSLC(0, void main() );
GLSLC(0, { );
GLSLC(1, ivec2 size; );
GLSLC(1, const ivec2 pos = ivec2(gl_GlobalInvocationID.xy); );
for (int i = 0; i < planes; i++) {
GLSLC(0, );
GLSLF(1, size = imageSize(output_image[%i]); ,i);
GLSLC(1, if (IS_WITHIN(pos, size)) { );
switch (type)
{
case FLIP_HORIZONTAL:
GLSLF(2, vec4 res = texture(input_image[%i], ivec2(size.x - pos.x, pos.y)); ,i);
break;
case FLIP_VERTICAL:
GLSLF(2, vec4 res = texture(input_image[%i], ivec2(pos.x, size.y - pos.y)); ,i);
break;
case FLIP_BOTH:
GLSLF(2, vec4 res = texture(input_image[%i], ivec2(size.xy - pos.xy));, i);
break;
default:
GLSLF(2, vec4 res = texture(input_image[%i], pos); ,i);
break;
}
GLSLC(0, } );
RET(ff_vk_compile_shader(vkctx, shd, "main"));
RET(ff_vk_init_pipeline_layout(vkctx, s->pl));
RET(ff_vk_init_compute_pipeline(vkctx, s->pl));
GLSLF(2, imageStore(output_image[%i], pos, res); ,i);
GLSLC(1, } );
}
GLSLC(0, } );
RET(spv->compile_shader(spv, ctx, shd, &spv_data, &spv_len, "main",
&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));
RET(ff_vk_create_exec_ctx(vkctx, &s->exec, &s->qf));
s->initialized = 1;
fail:
if (spv_opaque)
spv->free_shader(spv, &spv_opaque);
if (spv)
spv->uninit(&spv);
return err;
}
static av_cold void flip_vulkan_uninit(AVFilterContext *avctx)
{
FlipVulkanContext *s = avctx->priv;
ff_vk_uninit(&s->vkctx);
s->initialized = 0;
}
static int process_frames(AVFilterContext *avctx, AVFrame *outframe, AVFrame *inframe)
{
int err = 0;
VkCommandBuffer cmd_buf;
FlipVulkanContext *s = avctx->priv;
FFVulkanContext *vkctx = &s->vkctx;
FFVulkanFunctions *vk = &s->vkctx.vkfn;
AVVkFrame *in = (AVVkFrame *)inframe->data[0];
AVVkFrame *out = (AVVkFrame *)outframe->data[0];
const int planes = av_pix_fmt_count_planes(s->vkctx.output_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);
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;
}
FFVulkanFunctions *vk = &vkctx->vkfn;
ff_vk_update_descriptor_set(vkctx, s->pl, 0);
ff_vk_exec_pool_free(vkctx, &s->e);
ff_vk_pipeline_free(vkctx, &s->pl);
ff_vk_shader_free(vkctx, &s->shd);
for (int i = 0; i < planes; i++) {
VkImageMemoryBarrier barriers[] = {
{
.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,
},
{
.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,
},
};
vk->CmdPipelineBarrier(cmd_buf, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, 0,
0, NULL, 0, NULL, FF_ARRAY_ELEMS(barriers), barriers);
in->layout[i] = barriers[0].newLayout;
in->access[i] = barriers[0].dstAccessMask;
out->layout[i] = barriers[1].newLayout;
out->access[i] = barriers[1].dstAccessMask;
}
ff_vk_bind_pipeline_exec(vkctx, s->exec, s->pl);
vk->CmdDispatch(cmd_buf, FFALIGN(s->vkctx.output_width, CGS)/CGS,
s->vkctx.output_height, 1);
ff_vk_add_exec_dep(vkctx, s->exec, inframe, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT);
ff_vk_add_exec_dep(vkctx, s->exec, outframe, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT);
err = ff_vk_submit_exec_queue(vkctx, s->exec);
if (err)
return err;
if (s->sampler)
vk->DestroySampler(vkctx->hwctx->act_dev, s->sampler,
vkctx->hwctx->alloc);
ff_vk_qf_rotate(&s->qf);
ff_vk_uninit(&s->vkctx);
return 0;
fail:
ff_vk_discard_exec_deps(s->exec);
return err;
s->initialized = 0;
}
static int filter_frame(AVFilterLink *link, AVFrame *in, enum FlipType type)
@ -247,7 +174,8 @@ static int filter_frame(AVFilterLink *link, AVFrame *in, enum FlipType type)
if (!s->initialized)
RET(init_filter(ctx, in, type));
RET(process_frames(ctx, out, in));
RET(ff_vk_filter_process_simple(&s->vkctx, &s->e, &s->pl, out, in,
s->sampler, NULL, 0));
RET(av_frame_copy_props(out, in));

Write Preview
Loading…
Cancel
Save