jellyfin/jellyfin-ffmpeg
1
0
Fork 0
mirror of https://github.com/jellyfin/jellyfin-ffmpeg.git synced 2026-09-02 21:03:08 +03:00
Code Issues Packages Projects Releases Wiki Activity
Files
959574d8022ac0c9348b25ccbe64b2b6e392891b
jellyfin-ffmpeg/debian/patches/0064-add-pgs-support-to-vulkan-overlay.patch
T
nyanmisaka 9017eaad8f Update patches for 7.1.1 
Signed-off-by: nyanmisaka <nst799610810@gmail.com>
2025-04-17 22:34:15 +08:00

366 lines
16 KiB
Diff
Raw Blame History

Index: FFmpeg/libavfilter/vf_overlay_vulkan.c
===================================================================
--- FFmpeg.orig/libavfilter/vf_overlay_vulkan.c
+++ FFmpeg/libavfilter/vf_overlay_vulkan.c
@@ -33,9 +33,11 @@ typedef struct OverlayVulkanContext {
int initialized;
FFVulkanPipeline pl;
+ FFVulkanPipeline pl_pass;
FFVkExecPool e;
FFVkQueueFamilyCtx qf;
FFVkSPIRVShader shd;
+ FFVkSPIRVShader shd_pass;
VkSampler sampler;
/* Push constants / options */
@@ -48,6 +50,10 @@ typedef struct OverlayVulkanContext {
int overlay_y;
int overlay_w;
int overlay_h;
+
+ int opt_repeatlast;
+ int opt_shortest;
+ int opt_eof_action;
} OverlayVulkanContext;
static const char overlay_noalpha[] = {
@@ -84,15 +90,16 @@ static const char overlay_alpha[] = {
static av_cold int init_filter(AVFilterContext *ctx)
{
int err;
- uint8_t *spv_data;
+ uint8_t *spv_data, *spv_data_pass;
size_t spv_len;
void *spv_opaque = NULL;
+ void *spv_opaque_pass = NULL;
OverlayVulkanContext *s = ctx->priv;
FFVulkanContext *vkctx = &s->vkctx;
const int planes = av_pix_fmt_count_planes(s->vkctx.output_format);
const int ialpha = av_pix_fmt_desc_get(s->vkctx.input_format)->flags & AV_PIX_FMT_FLAG_ALPHA;
const AVPixFmtDescriptor *pix_desc = av_pix_fmt_desc_get(s->vkctx.output_format);
- FFVkSPIRVShader *shd = &s->shd;
+ FFVkSPIRVShader *shd;
FFVkSPIRVCompiler *spv;
FFVulkanDescriptorSetBinding *desc;
@@ -105,90 +112,143 @@ static av_cold int init_filter(AVFilterC
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_NEAREST));
+
+ /* overlay_compute */
RET(ff_vk_shader_init(&s->pl, &s->shd, "overlay_compute",
VK_SHADER_STAGE_COMPUTE_BIT, 0));
+ {
+ shd = &s->shd;
+ ff_vk_shader_set_compute_sizes(shd, 32, 32, 1);
+
+ GLSLC(0, layout(push_constant, std430) uniform pushConstants { );
+ GLSLC(1, ivec2 o_offset[3]; );
+ GLSLC(1, ivec2 o_size[3]; );
+ GLSLC(0, }; );
+ GLSLC(0, );
+
+ ff_vk_add_push_constant(&s->pl, 0, sizeof(s->opts),
+ VK_SHADER_STAGE_COMPUTE_BIT);
+
+ desc = (FFVulkanDescriptorSetBinding []) {
+ {
+ .name = "main_img",
+ .type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
+ .dimensions = 2,
+ .elems = planes,
+ .stages = VK_SHADER_STAGE_COMPUTE_BIT,
+ .samplers = DUP_SAMPLER(s->sampler),
+ },
+ {
+ .name = "overlay_img",
+ .type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
+ .dimensions = 2,
+ .elems = planes,
+ .stages = VK_SHADER_STAGE_COMPUTE_BIT,
+ .samplers = DUP_SAMPLER(s->sampler),
+ },
+ {
+ .name = "output_img",
+ .type = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
+ .mem_layout = ff_vk_shader_rep_fmt(s->vkctx.output_format),
+ .mem_quali = "writeonly",
+ .dimensions = 2,
+ .elems = planes,
+ .stages = VK_SHADER_STAGE_COMPUTE_BIT,
+ },
+ };
+
+ RET(ff_vk_pipeline_descriptor_set_add(vkctx, &s->pl, shd, desc, 3, 0, 0));
+
+ GLSLD( overlay_noalpha );
+ GLSLD( overlay_alpha );
+ GLSLC(0, void main() );
+ GLSLC(0, { );
+ GLSLC(1, ivec2 pos = ivec2(gl_GlobalInvocationID.xy); );
+ GLSLF(1, int planes = %i; ,planes);
+ GLSLC(1, for (int i = 0; i < planes; i++) { );
+ if (ialpha)
+ GLSLC(2, overlay_alpha_opaque(i, pos); );
+ else
+ GLSLC(2, overlay_noalpha(i, pos); );
+ 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));
+
+ s->opts.o_offset[0] = s->overlay_x;
+ s->opts.o_offset[1] = s->overlay_y;
+ s->opts.o_offset[2] = s->opts.o_offset[0] >> pix_desc->log2_chroma_w;
+ s->opts.o_offset[3] = s->opts.o_offset[1] >> pix_desc->log2_chroma_h;
+ s->opts.o_offset[4] = s->opts.o_offset[0] >> pix_desc->log2_chroma_w;
+ s->opts.o_offset[5] = s->opts.o_offset[1] >> pix_desc->log2_chroma_h;
+
+ s->opts.o_size[0] = s->overlay_w;
+ s->opts.o_size[1] = s->overlay_h;
+ s->opts.o_size[2] = s->opts.o_size[0] >> pix_desc->log2_chroma_w;
+ s->opts.o_size[3] = s->opts.o_size[1] >> pix_desc->log2_chroma_h;
+ s->opts.o_size[4] = s->opts.o_size[0] >> pix_desc->log2_chroma_w;
+ s->opts.o_size[5] = s->opts.o_size[1] >> pix_desc->log2_chroma_h;
+ }
- ff_vk_shader_set_compute_sizes(&s->shd, 32, 32, 1);
+ /* overlay_compute_pass */
+ RET(ff_vk_shader_init(&s->pl_pass, &s->shd_pass, "overlay_compute_pass",
+ VK_SHADER_STAGE_COMPUTE_BIT, 0));
+ {
+ shd = &s->shd_pass;
+ ff_vk_shader_set_compute_sizes(shd, 32, 32, 1);
+
+ desc = (FFVulkanDescriptorSetBinding []) {
+ {
+ .name = "main_img",
+ .type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
+ .dimensions = 2,
+ .elems = planes,
+ .stages = VK_SHADER_STAGE_COMPUTE_BIT,
+ .samplers = DUP_SAMPLER(s->sampler),
+ },
+ {
+ .name = "output_img",
+ .type = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
+ .mem_layout = ff_vk_shader_rep_fmt(s->vkctx.output_format),
+ .mem_quali = "writeonly",
+ .dimensions = 2,
+ .elems = planes,
+ .stages = VK_SHADER_STAGE_COMPUTE_BIT,
+ },
+ };
+
+ RET(ff_vk_pipeline_descriptor_set_add(vkctx, &s->pl_pass, shd, desc, 2, 0, 0));
+
+ GLSLC(0, void main() );
+ GLSLC(0, { );
+ GLSLC(1, ivec2 pos = ivec2(gl_GlobalInvocationID.xy); );
+ GLSLF(1, int planes = %i; ,planes);
+ GLSLC(1, for (int i = 0; i < planes; i++) { );
+ GLSLC(2, vec4 res = texture(main_img[i], pos); );
+ GLSLC(2, imageStore(output_img[i], pos, res); );
+ GLSLC(1, } );
+ GLSLC(0, } );
+
+ RET(spv->compile_shader(spv, ctx, shd, &spv_data_pass, &spv_len, "main",
+ &spv_opaque));
+ RET(ff_vk_shader_create(vkctx, shd, spv_data_pass, spv_len, "main"));
- GLSLC(0, layout(push_constant, std430) uniform pushConstants { );
- GLSLC(1, ivec2 o_offset[3]; );
- GLSLC(1, ivec2 o_size[3]; );
- GLSLC(0, }; );
- GLSLC(0, );
-
- ff_vk_add_push_constant(&s->pl, 0, sizeof(s->opts),
- VK_SHADER_STAGE_COMPUTE_BIT);
-
- desc = (FFVulkanDescriptorSetBinding []) {
- {
- .name = "main_img",
- .type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
- .dimensions = 2,
- .elems = planes,
- .stages = VK_SHADER_STAGE_COMPUTE_BIT,
- .samplers = DUP_SAMPLER(s->sampler),
- },
- {
- .name = "overlay_img",
- .type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
- .dimensions = 2,
- .elems = planes,
- .stages = VK_SHADER_STAGE_COMPUTE_BIT,
- .samplers = DUP_SAMPLER(s->sampler),
- },
- {
- .name = "output_img",
- .type = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
- .mem_layout = ff_vk_shader_rep_fmt(s->vkctx.output_format),
- .mem_quali = "writeonly",
- .dimensions = 2,
- .elems = planes,
- .stages = VK_SHADER_STAGE_COMPUTE_BIT,
- },
- };
-
- RET(ff_vk_pipeline_descriptor_set_add(vkctx, &s->pl, shd, desc, 3, 0, 0));
-
- GLSLD( overlay_noalpha );
- GLSLD( overlay_alpha );
- GLSLC(0, void main() );
- GLSLC(0, { );
- GLSLC(1, ivec2 pos = ivec2(gl_GlobalInvocationID.xy); );
- GLSLF(1, int planes = %i; ,planes);
- GLSLC(1, for (int i = 0; i < planes; i++) { );
- if (ialpha)
- GLSLC(2, overlay_alpha_opaque(i, pos); );
- else
- GLSLC(2, overlay_noalpha(i, pos); );
- 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));
-
- s->opts.o_offset[0] = s->overlay_x;
- s->opts.o_offset[1] = s->overlay_y;
- s->opts.o_offset[2] = s->opts.o_offset[0] >> pix_desc->log2_chroma_w;
- s->opts.o_offset[3] = s->opts.o_offset[1] >> pix_desc->log2_chroma_h;
- s->opts.o_offset[4] = s->opts.o_offset[0] >> pix_desc->log2_chroma_w;
- s->opts.o_offset[5] = s->opts.o_offset[1] >> pix_desc->log2_chroma_h;
-
- s->opts.o_size[0] = s->overlay_w;
- s->opts.o_size[1] = s->overlay_h;
- s->opts.o_size[2] = s->opts.o_size[0] >> pix_desc->log2_chroma_w;
- s->opts.o_size[3] = s->opts.o_size[1] >> pix_desc->log2_chroma_h;
- s->opts.o_size[4] = s->opts.o_size[0] >> pix_desc->log2_chroma_w;
- s->opts.o_size[5] = s->opts.o_size[1] >> pix_desc->log2_chroma_h;
+ RET(ff_vk_init_compute_pipeline(vkctx, &s->pl_pass, shd));
+ RET(ff_vk_exec_pipeline_register(vkctx, &s->e, &s->pl_pass));
+ }
s->initialized = 1;
fail:
if (spv_opaque)
spv->free_shader(spv, &spv_opaque);
+ if (spv_opaque_pass)
+ spv->free_shader(spv, &spv_opaque_pass);
if (spv)
spv->uninit(&spv);
@@ -210,22 +270,11 @@ static int overlay_vulkan_blend(FFFrameS
if (err < 0)
goto fail;
- if (!input_main || !input_overlay)
- return 0;
-
- if (!s->initialized) {
- AVHWFramesContext *main_fc = (AVHWFramesContext*)input_main->hw_frames_ctx->data;
- AVHWFramesContext *overlay_fc = (AVHWFramesContext*)input_overlay->hw_frames_ctx->data;
- if (main_fc->sw_format != overlay_fc->sw_format) {
- av_log(ctx, AV_LOG_ERROR, "Mismatching sw formats!\n");
- return AVERROR(EINVAL);
- }
-
- s->overlay_w = input_overlay->width;
- s->overlay_h = input_overlay->height;
+ if (!input_main)
+ return AVERROR_BUG;
+ if (!s->initialized)
RET(init_filter(ctx));
- }
out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
if (!out) {
@@ -233,9 +282,13 @@ static int overlay_vulkan_blend(FFFrameS
goto fail;
}
- RET(ff_vk_filter_process_Nin(&s->vkctx, &s->e, &s->pl,
- out, (AVFrame *[]){ input_main, input_overlay }, 2,
- s->sampler, &s->opts, sizeof(s->opts)));
+ if (input_overlay)
+ RET(ff_vk_filter_process_Nin(&s->vkctx, &s->e, &s->pl,
+ out, (AVFrame *[]){ input_main, input_overlay }, 2,
+ s->sampler, &s->opts, sizeof(s->opts)));
+ else /* passthrough */
+ RET(ff_vk_filter_process_simple(&s->vkctx, &s->e, &s->pl_pass, out, input_main,
+ s->sampler, NULL, 0));
err = av_frame_copy_props(out, input_main);
if (err < 0)
@@ -253,6 +306,20 @@ static int overlay_vulkan_config_output(
int err;
AVFilterContext *avctx = outlink->src;
OverlayVulkanContext *s = avctx->priv;
+ AVFilterLink *inlink = avctx->inputs[0];
+ AVFilterLink *inlink_overlay = avctx->inputs[1];
+ FilterLink *inl = ff_filter_link(inlink);
+ FilterLink *inl_overlay = ff_filter_link(inlink_overlay);
+ AVHWFramesContext *main_fc = (AVHWFramesContext*)inl->hw_frames_ctx->data;
+ AVHWFramesContext *overlay_fc = (AVHWFramesContext*)inl_overlay->hw_frames_ctx->data;
+
+ if (main_fc->sw_format != overlay_fc->sw_format) {
+ av_log(avctx, AV_LOG_ERROR, "Mismatching sw formats!\n");
+ return AVERROR(EINVAL);
+ }
+
+ s->overlay_w = inlink_overlay->w;
+ s->overlay_h = inlink_overlay->h;
err = ff_vk_filter_config_output(outlink);
if (err < 0)
@@ -262,6 +329,11 @@ static int overlay_vulkan_config_output(
if (err < 0)
return err;
+ s->fs.opt_repeatlast = s->opt_repeatlast;
+ s->fs.opt_shortest = s->opt_shortest;
+ s->fs.opt_eof_action = s->opt_eof_action;
+ s->fs.time_base = outlink->time_base = inlink->time_base;
+
return ff_framesync_configure(&s->fs);
}
@@ -289,7 +361,9 @@ static void overlay_vulkan_uninit(AVFilt
ff_vk_exec_pool_free(vkctx, &s->e);
ff_vk_pipeline_free(vkctx, &s->pl);
+ ff_vk_pipeline_free(vkctx, &s->pl_pass);
ff_vk_shader_free(vkctx, &s->shd);
+ ff_vk_shader_free(vkctx, &s->shd_pass);
if (s->sampler)
vk->DestroySampler(vkctx->hwctx->act_dev, s->sampler,
@@ -306,6 +380,14 @@ static void overlay_vulkan_uninit(AVFilt
static const AVOption overlay_vulkan_options[] = {
{ "x", "Set horizontal offset", OFFSET(overlay_x), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, .flags = FLAGS },
{ "y", "Set vertical offset", OFFSET(overlay_y), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, .flags = FLAGS },
+ { "eof_action", "Action to take when encountering EOF from secondary input ",
+ OFFSET(opt_eof_action), AV_OPT_TYPE_INT, { .i64 = EOF_ACTION_REPEAT },
+ EOF_ACTION_REPEAT, EOF_ACTION_PASS, .flags = FLAGS, .unit = "eof_action" },
+ { "repeat", "Repeat the previous frame.", 0, AV_OPT_TYPE_CONST, { .i64 = EOF_ACTION_REPEAT }, .flags = FLAGS, .unit = "eof_action" },
+ { "endall", "End both streams.", 0, AV_OPT_TYPE_CONST, { .i64 = EOF_ACTION_ENDALL }, .flags = FLAGS, .unit = "eof_action" },
+ { "pass", "Pass through the main input.", 0, AV_OPT_TYPE_CONST, { .i64 = EOF_ACTION_PASS }, .flags = FLAGS, .unit = "eof_action" },
+ { "shortest", "force termination when the shortest input terminates", OFFSET(opt_shortest), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS },
+ { "repeatlast", "repeat overlay of the last overlay frame", OFFSET(opt_repeatlast), AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, FLAGS },
{ NULL },
};
Reference in New Issue View Git Blame Copy Permalink