| /* |
| * Copyright (c) 2024 Lynne <dev@lynne.ee> |
| * |
| * This file is part of FFmpeg. |
| * |
| * FFmpeg is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; either |
| * version 2.1 of the License, or (at your option) any later version. |
| * |
| * FFmpeg is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public |
| * License along with FFmpeg; if not, write to the Free Software |
| * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
| */ |
| |
| #include "libavutil/mem.h" |
| #include "libavutil/vulkan.h" |
| #include "libavutil/vulkan_spirv.h" |
| |
| #include "avcodec.h" |
| #include "internal.h" |
| #include "hwconfig.h" |
| #include "encode.h" |
| #include "libavutil/opt.h" |
| #include "codec_internal.h" |
| |
| #include "ffv1.h" |
| #include "ffv1enc.h" |
| #include "ffv1_vulkan.h" |
| |
| /* Parallel Golomb alignment */ |
| #define LG_ALIGN_W 32 |
| #define LG_ALIGN_H 32 |
| |
| /* Unlike the decoder, we need 4 lines (but really only 3) */ |
| #define RGB_LINECACHE 4 |
| |
| typedef struct VulkanEncodeFFv1FrameData { |
| /* Output data */ |
| AVBufferRef *out_data_ref; |
| |
| /* Results data */ |
| AVBufferRef *results_data_ref; |
| |
| /* Copied from the source */ |
| int64_t pts; |
| int64_t duration; |
| void *frame_opaque; |
| AVBufferRef *frame_opaque_ref; |
| |
| int key_frame; |
| } VulkanEncodeFFv1FrameData; |
| |
| typedef struct VulkanEncodeFFv1Context { |
| FFV1Context ctx; |
| AVFrame *frame; |
| |
| FFVulkanContext s; |
| AVVulkanDeviceQueueFamily *qf; |
| FFVkExecPool exec_pool; |
| |
| AVVulkanDeviceQueueFamily *transfer_qf; |
| FFVkExecPool transfer_exec_pool; |
| |
| VkBufferCopy *buf_regions; |
| VulkanEncodeFFv1FrameData *exec_ctx_info; |
| int in_flight; |
| int async_depth; |
| size_t max_heap_size; |
| |
| FFVulkanShader setup; |
| FFVulkanShader rct_search; |
| FFVulkanShader reset; |
| FFVulkanShader enc; |
| |
| /* Constant read-only buffers */ |
| FFVkBuffer quant_buf; |
| FFVkBuffer rangecoder_static_buf; |
| FFVkBuffer crc_tab_buf; |
| |
| /* Slice data buffer pool */ |
| AVBufferPool *slice_data_pool; |
| AVBufferRef *keyframe_slice_data_ref; |
| |
| /* Output data buffer */ |
| AVBufferPool *out_data_pool; |
| |
| /* Slice results buffer */ |
| AVBufferPool *results_data_pool; |
| |
| /* Intermediate frame pool */ |
| AVBufferRef *intermediate_frames_ref; |
| |
| /* Representation mode */ |
| enum FFVkShaderRepFormat rep_fmt; |
| |
| int num_h_slices; |
| int num_v_slices; |
| int force_pcm; |
| int optimize_rct; |
| |
| int is_rgb; |
| int ppi; |
| int chunks; |
| } VulkanEncodeFFv1Context; |
| |
| extern const char *ff_source_common_comp; |
| extern const char *ff_source_rangecoder_comp; |
| extern const char *ff_source_ffv1_vlc_comp; |
| extern const char *ff_source_ffv1_common_comp; |
| extern const char *ff_source_ffv1_reset_comp; |
| extern const char *ff_source_ffv1_rct_search_comp; |
| extern const char *ff_source_ffv1_enc_setup_comp; |
| extern const char *ff_source_ffv1_enc_comp; |
| |
| typedef struct FFv1VkParameters { |
| VkDeviceAddress slice_state; |
| VkDeviceAddress scratch_data; |
| VkDeviceAddress out_data; |
| |
| int32_t fmt_lut[4]; |
| int32_t sar[2]; |
| uint32_t chroma_shift[2]; |
| |
| uint32_t plane_state_size; |
| uint32_t context_count; |
| uint32_t crcref; |
| uint32_t slice_size_max; |
| int rct_offset; |
| |
| uint8_t extend_lookup[8]; |
| uint8_t bits_per_raw_sample; |
| uint8_t context_model; |
| uint8_t version; |
| uint8_t micro_version; |
| uint8_t force_pcm; |
| uint8_t key_frame; |
| uint8_t components; |
| uint8_t planes; |
| uint8_t codec_planes; |
| uint8_t planar_rgb; |
| uint8_t transparency; |
| uint8_t colorspace; |
| uint8_t pic_mode; |
| uint8_t ec; |
| uint8_t ppi; |
| uint8_t chunks; |
| uint8_t rct_search; |
| uint8_t padding[3]; |
| } FFv1VkParameters; |
| |
| static void add_push_data(FFVulkanShader *shd) |
| { |
| GLSLC(0, layout(push_constant, scalar) uniform pushConstants { ); |
| GLSLC(1, u8buf slice_state; ); |
| GLSLC(1, u8buf scratch_data; ); |
| GLSLC(1, u8buf out_data; ); |
| GLSLC(0, ); |
| GLSLC(1, ivec4 fmt_lut; ); |
| GLSLC(1, ivec2 sar; ); |
| GLSLC(1, uvec2 chroma_shift; ); |
| GLSLC(0, ); |
| GLSLC(1, uint plane_state_size; ); |
| GLSLC(1, uint context_count; ); |
| GLSLC(1, uint32_t crcref; ); |
| GLSLC(1, uint32_t slice_size_max; ); |
| GLSLC(1, int rct_offset; ); |
| GLSLC(0, ); |
| GLSLC(1, uint8_t extend_lookup[8]; ); |
| GLSLC(1, uint8_t bits_per_raw_sample; ); |
| GLSLC(1, uint8_t context_model; ); |
| GLSLC(1, uint8_t version; ); |
| GLSLC(1, uint8_t micro_version; ); |
| GLSLC(1, uint8_t force_pcm; ); |
| GLSLC(1, uint8_t key_frame; ); |
| GLSLC(1, uint8_t components; ); |
| GLSLC(1, uint8_t planes; ); |
| GLSLC(1, uint8_t codec_planes; ); |
| GLSLC(1, uint8_t planar_rgb; ); |
| GLSLC(1, uint8_t transparency; ); |
| GLSLC(1, uint8_t colorspace; ); |
| GLSLC(1, uint8_t pic_mode; ); |
| GLSLC(1, uint8_t ec; ); |
| GLSLC(1, uint8_t ppi; ); |
| GLSLC(1, uint8_t chunks; ); |
| GLSLC(1, uint8_t rct_search; ); |
| GLSLC(1, uint8_t padding[3]; ); |
| GLSLC(0, }; ); |
| ff_vk_shader_add_push_const(shd, 0, sizeof(FFv1VkParameters), |
| VK_SHADER_STAGE_COMPUTE_BIT); |
| } |
| |
| typedef struct FFv1VkRCTSearchParameters { |
| int fmt_lut[4]; |
| int rct_offset; |
| uint8_t planar_rgb; |
| uint8_t transparency; |
| uint8_t key_frame; |
| uint8_t force_pcm; |
| uint8_t version; |
| uint8_t micro_version; |
| uint8_t padding[2]; |
| } FFv1VkRCTSearchParameters; |
| |
| static int run_rct_search(AVCodecContext *avctx, FFVkExecContext *exec, |
| AVFrame *enc_in, VkImageView *enc_in_views, |
| FFVkBuffer *slice_data_buf, uint32_t slice_data_size) |
| { |
| VulkanEncodeFFv1Context *fv = avctx->priv_data; |
| FFV1Context *f = &fv->ctx; |
| FFVulkanFunctions *vk = &fv->s.vkfn; |
| AVHWFramesContext *src_hwfc = (AVHWFramesContext *)enc_in->hw_frames_ctx->data; |
| FFv1VkRCTSearchParameters pd; |
| |
| /* Update descriptors */ |
| ff_vk_shader_update_desc_buffer(&fv->s, exec, &fv->rct_search, |
| 0, 0, 0, |
| slice_data_buf, |
| 0, slice_data_size*f->slice_count, |
| VK_FORMAT_UNDEFINED); |
| ff_vk_shader_update_img_array(&fv->s, exec, &fv->rct_search, |
| enc_in, enc_in_views, |
| 0, 1, |
| VK_IMAGE_LAYOUT_GENERAL, |
| VK_NULL_HANDLE); |
| |
| ff_vk_exec_bind_shader(&fv->s, exec, &fv->rct_search); |
| |
| pd = (FFv1VkRCTSearchParameters) { |
| .rct_offset = 1 << f->bits_per_raw_sample, |
| .planar_rgb = ff_vk_mt_is_np_rgb(src_hwfc->sw_format) && |
| (ff_vk_count_images((AVVkFrame *)enc_in->data[0]) > 1), |
| .transparency = f->transparency, |
| .key_frame = f->key_frame, |
| .force_pcm = fv->force_pcm, |
| .version = f->version, |
| .micro_version = f->micro_version, |
| }; |
| |
| if (avctx->sw_pix_fmt == AV_PIX_FMT_GBRP10 || |
| avctx->sw_pix_fmt == AV_PIX_FMT_GBRP12 || |
| avctx->sw_pix_fmt == AV_PIX_FMT_GBRP14) |
| memcpy(pd.fmt_lut, (int [4]) { 2, 1, 0, 3 }, 4*sizeof(int)); |
| else |
| ff_vk_set_perm(avctx->sw_pix_fmt, pd.fmt_lut, 1); |
| |
| ff_vk_shader_update_push_const(&fv->s, exec, &fv->rct_search, |
| VK_SHADER_STAGE_COMPUTE_BIT, |
| 0, sizeof(pd), &pd); |
| |
| vk->CmdDispatch(exec->buf, fv->ctx.num_h_slices, fv->ctx.num_v_slices, 1); |
| |
| return 0; |
| } |
| |
| static int vulkan_encode_ffv1_submit_frame(AVCodecContext *avctx, |
| FFVkExecContext *exec, |
| const AVFrame *pict) |
| { |
| int err; |
| VulkanEncodeFFv1Context *fv = avctx->priv_data; |
| FFV1Context *f = &fv->ctx; |
| FFVulkanFunctions *vk = &fv->s.vkfn; |
| |
| VulkanEncodeFFv1FrameData *fd = exec->opaque; |
| FFv1VkParameters pd; |
| |
| /* Slice data */ |
| AVBufferRef *slice_data_ref; |
| FFVkBuffer *slice_data_buf; |
| uint32_t plane_state_size; |
| uint32_t slice_state_size; |
| uint32_t slice_data_size; |
| |
| /* Output data */ |
| size_t maxsize; |
| FFVkBuffer *out_data_buf; |
| |
| /* Results data */ |
| FFVkBuffer *results_data_buf; |
| |
| int has_inter = avctx->gop_size > 1; |
| uint32_t context_count = f->context_count[f->context_model]; |
| const AVPixFmtDescriptor *fmt_desc = av_pix_fmt_desc_get(avctx->sw_pix_fmt); |
| |
| AVFrame *src = (AVFrame *)pict; |
| VkImageView src_views[AV_NUM_DATA_POINTERS]; |
| |
| AVFrame *tmp = NULL; |
| VkImageView tmp_views[AV_NUM_DATA_POINTERS]; |
| |
| VkImageMemoryBarrier2 img_bar[37]; |
| int nb_img_bar = 0; |
| VkBufferMemoryBarrier2 buf_bar[8]; |
| int nb_buf_bar = 0; |
| |
| /* Start recording */ |
| ff_vk_exec_start(&fv->s, exec); |
| |
| /* Frame state */ |
| f->cur_enc_frame = pict; |
| if (avctx->gop_size == 0 || f->picture_number % avctx->gop_size == 0) { |
| av_buffer_unref(&fv->keyframe_slice_data_ref); |
| f->key_frame = fd->key_frame = 1; |
| f->gob_count++; |
| } else { |
| f->key_frame = fd->key_frame = 0; |
| } |
| |
| f->slice_count = f->max_slice_count; |
| |
| /* Allocate slice buffer data */ |
| if (f->ac == AC_GOLOMB_RICE) |
| plane_state_size = 8; |
| else |
| plane_state_size = CONTEXT_SIZE; |
| |
| plane_state_size *= context_count; |
| slice_state_size = plane_state_size*f->plane_count; |
| |
| slice_data_size = 256; /* Overestimation for the SliceContext struct */ |
| slice_state_size += slice_data_size; |
| slice_state_size = FFALIGN(slice_state_size, 8); |
| |
| /* Allocate slice data buffer */ |
| slice_data_ref = fv->keyframe_slice_data_ref; |
| if (!slice_data_ref) { |
| RET(ff_vk_get_pooled_buffer(&fv->s, &fv->slice_data_pool, |
| &slice_data_ref, |
| VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | |
| VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT, |
| NULL, slice_state_size*f->slice_count, |
| VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT)); |
| |
| /* Only save it if we're going to use it again */ |
| if (has_inter) |
| fv->keyframe_slice_data_ref = slice_data_ref; |
| } |
| slice_data_buf = (FFVkBuffer *)slice_data_ref->data; |
| ff_vk_exec_add_dep_buf(&fv->s, exec, &slice_data_ref, 1, has_inter); |
| |
| /* Allocate results buffer */ |
| RET(ff_vk_get_pooled_buffer(&fv->s, &fv->results_data_pool, |
| &fd->results_data_ref, |
| VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | |
| VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT, |
| NULL, 2*f->slice_count*sizeof(uint64_t), |
| VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT | |
| VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT)); |
| results_data_buf = (FFVkBuffer *)fd->results_data_ref->data; |
| ff_vk_exec_add_dep_buf(&fv->s, exec, &fd->results_data_ref, 1, 1); |
| |
| /* Output buffer size */ |
| maxsize = ff_ffv1_encode_buffer_size(avctx); |
| maxsize = FFMIN(maxsize, fv->s.props_11.maxMemoryAllocationSize); |
| |
| /* Allocate output buffer */ |
| RET(ff_vk_get_pooled_buffer(&fv->s, &fv->out_data_pool, |
| &fd->out_data_ref, |
| VK_BUFFER_USAGE_TRANSFER_SRC_BIT | |
| VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | |
| VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT, |
| NULL, maxsize, |
| VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | |
| (maxsize < fv->max_heap_size ? |
| VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT : 0x0) | |
| (!(fv->s.extensions & FF_VK_EXT_EXTERNAL_HOST_MEMORY) ? |
| VK_MEMORY_PROPERTY_HOST_CACHED_BIT : 0x0))); |
| out_data_buf = (FFVkBuffer *)fd->out_data_ref->data; |
| ff_vk_exec_add_dep_buf(&fv->s, exec, &fd->out_data_ref, 1, 1); |
| |
| /* Prepare input frame */ |
| RET(ff_vk_exec_add_dep_frame(&fv->s, exec, src, |
| VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT, |
| VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT)); |
| |
| RET(ff_vk_create_imageviews(&fv->s, exec, src_views, src, |
| fv->rep_fmt)); |
| ff_vk_frame_barrier(&fv->s, exec, src, img_bar, &nb_img_bar, |
| VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT, |
| VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT, |
| VK_ACCESS_SHADER_READ_BIT, |
| VK_IMAGE_LAYOUT_GENERAL, |
| VK_QUEUE_FAMILY_IGNORED); |
| |
| if (fv->is_rgb) { |
| /* Create a temporaty frame */ |
| tmp = av_frame_alloc(); |
| if (!(tmp)) |
| return AVERROR(ENOMEM); |
| |
| RET(av_hwframe_get_buffer(fv->intermediate_frames_ref, |
| tmp, 0)); |
| |
| RET(ff_vk_exec_add_dep_frame(&fv->s, exec, tmp, |
| VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT, |
| VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT)); |
| RET(ff_vk_create_imageviews(&fv->s, exec, tmp_views, |
| tmp, |
| fv->rep_fmt)); |
| } |
| |
| /* Setup shader */ |
| ff_vk_shader_update_desc_buffer(&fv->s, exec, &fv->setup, |
| 1, 0, 0, |
| slice_data_buf, |
| 0, slice_data_size*f->slice_count, |
| VK_FORMAT_UNDEFINED); |
| ff_vk_shader_update_img_array(&fv->s, exec, &fv->setup, |
| src, src_views, |
| 1, 1, |
| VK_IMAGE_LAYOUT_GENERAL, |
| VK_NULL_HANDLE); |
| |
| /* Add a buffer barrier between previous and current frame */ |
| if (!f->key_frame) { |
| buf_bar[nb_buf_bar++] = (VkBufferMemoryBarrier2) { |
| .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2, |
| .srcStageMask = slice_data_buf->stage, |
| .dstStageMask = VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT, |
| .srcAccessMask = slice_data_buf->access, |
| .dstAccessMask = VK_ACCESS_2_SHADER_STORAGE_READ_BIT | |
| VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT, |
| .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, |
| .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, |
| .buffer = slice_data_buf->buf, |
| .size = VK_WHOLE_SIZE, |
| .offset = 0, |
| }; |
| } |
| |
| if (fv->optimize_rct) { |
| RET(run_rct_search(avctx, exec, |
| src, src_views, |
| slice_data_buf, slice_data_size)); |
| |
| buf_bar[nb_buf_bar++] = (VkBufferMemoryBarrier2) { |
| .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2, |
| .srcStageMask = slice_data_buf->stage, |
| .dstStageMask = VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT, |
| .srcAccessMask = slice_data_buf->access, |
| .dstAccessMask = VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT, |
| .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, |
| .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, |
| .buffer = slice_data_buf->buf, |
| .size = slice_data_size*f->slice_count, |
| .offset = 0, |
| }; |
| } |
| |
| vk->CmdPipelineBarrier2(exec->buf, &(VkDependencyInfo) { |
| .sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO, |
| .pImageMemoryBarriers = img_bar, |
| .imageMemoryBarrierCount = nb_img_bar, |
| .pBufferMemoryBarriers = buf_bar, |
| .bufferMemoryBarrierCount = nb_buf_bar, |
| }); |
| nb_img_bar = 0; |
| if (nb_buf_bar) { |
| slice_data_buf->stage = buf_bar[0].dstStageMask; |
| slice_data_buf->access = buf_bar[0].dstAccessMask; |
| nb_buf_bar = 0; |
| } |
| |
| /* Run setup shader */ |
| ff_vk_exec_bind_shader(&fv->s, exec, &fv->setup); |
| pd = (FFv1VkParameters) { |
| .slice_state = slice_data_buf->address + f->slice_count*256, |
| .out_data = out_data_buf->address, |
| .bits_per_raw_sample = f->bits_per_raw_sample, |
| .sar[0] = pict->sample_aspect_ratio.num, |
| .sar[1] = pict->sample_aspect_ratio.den, |
| .chroma_shift[0] = f->chroma_h_shift, |
| .chroma_shift[1] = f->chroma_v_shift, |
| .plane_state_size = plane_state_size, |
| .context_count = context_count, |
| .crcref = f->crcref, |
| .rct_offset = 1 << f->bits_per_raw_sample, |
| .slice_size_max = out_data_buf->size / f->slice_count, |
| .context_model = fv->ctx.context_model, |
| .version = f->version, |
| .micro_version = f->micro_version, |
| .force_pcm = fv->force_pcm, |
| .key_frame = f->key_frame, |
| .components = fmt_desc->nb_components, |
| .planes = av_pix_fmt_count_planes(avctx->sw_pix_fmt), |
| .codec_planes = f->plane_count, |
| .planar_rgb = ff_vk_mt_is_np_rgb(avctx->sw_pix_fmt) && |
| (ff_vk_count_images((AVVkFrame *)src->data[0]) > 1), |
| .transparency = f->transparency, |
| .colorspace = f->colorspace, |
| .pic_mode = !(pict->flags & AV_FRAME_FLAG_INTERLACED) ? 3 : |
| !(pict->flags & AV_FRAME_FLAG_TOP_FIELD_FIRST) ? 2 : 1, |
| .ec = f->ec, |
| .ppi = fv->ppi, |
| .chunks = fv->chunks, |
| .rct_search = fv->optimize_rct, |
| }; |
| |
| /* For some reason the C FFv1 encoder/decoder treats these differently */ |
| if (avctx->sw_pix_fmt == AV_PIX_FMT_GBRP10 || |
| avctx->sw_pix_fmt == AV_PIX_FMT_GBRP12 || |
| avctx->sw_pix_fmt == AV_PIX_FMT_GBRP14) |
| memcpy(pd.fmt_lut, (int [4]) { 2, 1, 0, 3 }, 4*sizeof(int)); |
| else |
| ff_vk_set_perm(avctx->sw_pix_fmt, pd.fmt_lut, 1); |
| |
| for (int i = 0; i < f->quant_table_count; i++) |
| pd.extend_lookup[i] = (f->quant_tables[i][3][127] != 0) || |
| (f->quant_tables[i][4][127] != 0); |
| ff_vk_shader_update_push_const(&fv->s, exec, &fv->setup, |
| VK_SHADER_STAGE_COMPUTE_BIT, |
| 0, sizeof(pd), &pd); |
| vk->CmdDispatch(exec->buf, fv->ctx.num_h_slices, fv->ctx.num_v_slices, 1); |
| |
| /* Clean up temporary image */ |
| if (fv->is_rgb) { |
| AVVkFrame *vkf = (AVVkFrame *)tmp->data[0]; |
| vk->CmdClearColorImage(exec->buf, vkf->img[0], VK_IMAGE_LAYOUT_GENERAL, |
| &((VkClearColorValue) { 0 }), |
| 1, &((VkImageSubresourceRange) { |
| .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT, |
| .levelCount = 1, |
| .layerCount = 1, |
| })); |
| } |
| |
| /* Setup shader modified the slice data buffer */ |
| buf_bar[nb_buf_bar++] = (VkBufferMemoryBarrier2) { |
| .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2, |
| .srcStageMask = slice_data_buf->stage, |
| .dstStageMask = VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT, |
| .srcAccessMask = slice_data_buf->access, |
| .dstAccessMask = VK_ACCESS_2_SHADER_STORAGE_READ_BIT | |
| VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT, |
| .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, |
| .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, |
| .buffer = slice_data_buf->buf, |
| .size = slice_data_size*f->slice_count, |
| .offset = 0, |
| }; |
| |
| if (f->key_frame || f->version > 3) { |
| FFv1VkResetParameters pd_reset; |
| |
| ff_vk_shader_update_desc_buffer(&fv->s, exec, &fv->reset, |
| 1, 0, 0, |
| slice_data_buf, |
| 0, slice_data_size*f->slice_count, |
| VK_FORMAT_UNDEFINED); |
| |
| /* Run setup shader */ |
| ff_vk_exec_bind_shader(&fv->s, exec, &fv->reset); |
| pd_reset = (FFv1VkResetParameters) { |
| .slice_state = slice_data_buf->address + f->slice_count*256, |
| .plane_state_size = plane_state_size, |
| .codec_planes = f->plane_count, |
| .key_frame = f->key_frame, |
| }; |
| for (int i = 0; i < f->quant_table_count; i++) |
| pd_reset.context_count[i] = f->context_count[i]; |
| |
| ff_vk_shader_update_push_const(&fv->s, exec, &fv->reset, |
| VK_SHADER_STAGE_COMPUTE_BIT, |
| 0, sizeof(pd_reset), &pd_reset); |
| |
| /* Sync between setup and reset shaders */ |
| vk->CmdPipelineBarrier2(exec->buf, &(VkDependencyInfo) { |
| .sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO, |
| .pBufferMemoryBarriers = buf_bar, |
| .bufferMemoryBarrierCount = nb_buf_bar, |
| }); |
| slice_data_buf->stage = buf_bar[0].dstStageMask; |
| slice_data_buf->access = buf_bar[0].dstAccessMask; |
| nb_buf_bar = 0; |
| |
| vk->CmdDispatch(exec->buf, fv->ctx.num_h_slices, fv->ctx.num_v_slices, |
| f->plane_count); |
| } |
| |
| /* If the reset shader ran, insert a barrier now. */ |
| if (f->key_frame || f->version > 3) { |
| /* Reset shader modified the slice data buffer */ |
| buf_bar[nb_buf_bar++] = (VkBufferMemoryBarrier2) { |
| .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2, |
| .srcStageMask = slice_data_buf->stage, |
| .dstStageMask = VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT, |
| .srcAccessMask = slice_data_buf->access, |
| .dstAccessMask = VK_ACCESS_2_SHADER_STORAGE_READ_BIT | |
| VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT, |
| .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, |
| .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, |
| .buffer = slice_data_buf->buf, |
| .size = slice_data_buf->size - slice_data_size*f->slice_count, |
| .offset = slice_data_size*f->slice_count, |
| }; |
| } |
| |
| if (fv->is_rgb) { |
| ff_vk_frame_barrier(&fv->s, exec, tmp, img_bar, &nb_img_bar, |
| VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT, |
| VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT, |
| VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT, |
| VK_IMAGE_LAYOUT_GENERAL, |
| VK_QUEUE_FAMILY_IGNORED); |
| } |
| |
| /* Final barrier before encoding */ |
| vk->CmdPipelineBarrier2(exec->buf, &(VkDependencyInfo) { |
| .sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO, |
| .pImageMemoryBarriers = img_bar, |
| .imageMemoryBarrierCount = nb_img_bar, |
| .pBufferMemoryBarriers = buf_bar, |
| .bufferMemoryBarrierCount = nb_buf_bar, |
| }); |
| nb_img_bar = 0; |
| if (nb_buf_bar) { |
| slice_data_buf->stage = buf_bar[0].dstStageMask; |
| slice_data_buf->access = buf_bar[0].dstAccessMask; |
| nb_buf_bar = 0; |
| } |
| |
| /* Main encode shader */ |
| ff_vk_shader_update_desc_buffer(&fv->s, exec, &fv->enc, |
| 1, 0, 0, |
| slice_data_buf, |
| 0, slice_data_size*f->slice_count, |
| VK_FORMAT_UNDEFINED); |
| ff_vk_shader_update_img_array(&fv->s, exec, &fv->enc, |
| src, src_views, |
| 1, 1, |
| VK_IMAGE_LAYOUT_GENERAL, |
| VK_NULL_HANDLE); |
| ff_vk_shader_update_desc_buffer(&fv->s, exec, |
| &fv->enc, 1, 2, 0, |
| results_data_buf, |
| 0, results_data_buf->size, |
| VK_FORMAT_UNDEFINED); |
| if (fv->is_rgb) |
| ff_vk_shader_update_img_array(&fv->s, exec, &fv->enc, |
| tmp, tmp_views, |
| 1, 3, |
| VK_IMAGE_LAYOUT_GENERAL, |
| VK_NULL_HANDLE); |
| |
| ff_vk_exec_bind_shader(&fv->s, exec, &fv->enc); |
| ff_vk_shader_update_push_const(&fv->s, exec, &fv->enc, |
| VK_SHADER_STAGE_COMPUTE_BIT, |
| 0, sizeof(pd), &pd); |
| vk->CmdDispatch(exec->buf, fv->ctx.num_h_slices, fv->ctx.num_v_slices, 1); |
| |
| /* Submit */ |
| err = ff_vk_exec_submit(&fv->s, exec); |
| if (err < 0) |
| return err; |
| |
| f->picture_number++; |
| |
| /* This, if needed, was referenced by the execution context |
| * as it was declared as a dependency. */ |
| av_frame_free(&tmp); |
| return 0; |
| |
| fail: |
| av_frame_free(&tmp); |
| ff_vk_exec_discard_deps(&fv->s, exec); |
| |
| return err; |
| } |
| |
| static int transfer_slices(AVCodecContext *avctx, |
| VkBufferCopy *buf_regions, int nb_regions, |
| VulkanEncodeFFv1FrameData *fd, |
| uint8_t *dst, AVBufferRef *dst_ref) |
| { |
| int err; |
| VulkanEncodeFFv1Context *fv = avctx->priv_data; |
| FFVulkanFunctions *vk = &fv->s.vkfn; |
| FFVkExecContext *exec; |
| |
| FFVkBuffer *out_data_buf = (FFVkBuffer *)fd->out_data_ref->data; |
| |
| AVBufferRef *mapped_ref; |
| FFVkBuffer *mapped_buf; |
| |
| VkBufferMemoryBarrier2 buf_bar[8]; |
| int nb_buf_bar = 0; |
| |
| err = ff_vk_host_map_buffer(&fv->s, &mapped_ref, dst, dst_ref, |
| VK_BUFFER_USAGE_TRANSFER_DST_BIT); |
| if (err < 0) |
| return err; |
| |
| mapped_buf = (FFVkBuffer *)mapped_ref->data; |
| |
| /* Transfer the slices */ |
| exec = ff_vk_exec_get(&fv->s, &fv->transfer_exec_pool); |
| ff_vk_exec_start(&fv->s, exec); |
| |
| ff_vk_exec_add_dep_buf(&fv->s, exec, &fd->out_data_ref, 1, 0); |
| fd->out_data_ref = NULL; /* Ownership passed */ |
| |
| ff_vk_exec_add_dep_buf(&fv->s, exec, &mapped_ref, 1, 0); |
| mapped_ref = NULL; /* Ownership passed */ |
| |
| /* Ensure the output buffer is finished */ |
| buf_bar[nb_buf_bar++] = (VkBufferMemoryBarrier2) { |
| .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2, |
| .srcStageMask = out_data_buf->stage, |
| .dstStageMask = VK_PIPELINE_STAGE_2_TRANSFER_BIT, |
| .srcAccessMask = out_data_buf->access, |
| .dstAccessMask = VK_ACCESS_2_TRANSFER_READ_BIT, |
| .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, |
| .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, |
| .buffer = out_data_buf->buf, |
| .size = VK_WHOLE_SIZE, |
| .offset = 0, |
| }; |
| vk->CmdPipelineBarrier2(exec->buf, &(VkDependencyInfo) { |
| .sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO, |
| .pBufferMemoryBarriers = buf_bar, |
| .bufferMemoryBarrierCount = nb_buf_bar, |
| }); |
| out_data_buf->stage = buf_bar[0].dstStageMask; |
| out_data_buf->access = buf_bar[0].dstAccessMask; |
| nb_buf_bar = 0; |
| |
| for (int i = 0; i < nb_regions; i++) |
| buf_regions[i].dstOffset += mapped_buf->virtual_offset; |
| |
| vk->CmdCopyBuffer(exec->buf, |
| out_data_buf->buf, mapped_buf->buf, |
| nb_regions, buf_regions); |
| |
| /* Submit */ |
| err = ff_vk_exec_submit(&fv->s, exec); |
| if (err < 0) |
| return err; |
| |
| /* We need the encoded data immediately */ |
| ff_vk_exec_wait(&fv->s, exec); |
| |
| return 0; |
| } |
| |
| static int get_packet(AVCodecContext *avctx, FFVkExecContext *exec, |
| AVPacket *pkt) |
| { |
| int err; |
| VulkanEncodeFFv1Context *fv = avctx->priv_data; |
| FFV1Context *f = &fv->ctx; |
| FFVulkanFunctions *vk = &fv->s.vkfn; |
| VulkanEncodeFFv1FrameData *fd = exec->opaque; |
| |
| FFVkBuffer *out_data_buf = (FFVkBuffer *)fd->out_data_ref->data; |
| FFVkBuffer *results_data_buf = (FFVkBuffer *)fd->results_data_ref->data; |
| uint64_t *sc; |
| |
| /* Make sure encoding's done */ |
| ff_vk_exec_wait(&fv->s, exec); |
| |
| /* Invalidate slice/output data if needed */ |
| if (!(results_data_buf->flags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT)) { |
| VkMappedMemoryRange invalidate_data = { |
| .sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE, |
| .memory = results_data_buf->mem, |
| .offset = 0, |
| .size = VK_WHOLE_SIZE, |
| }; |
| vk->InvalidateMappedMemoryRanges(fv->s.hwctx->act_dev, |
| 1, &invalidate_data); |
| } |
| |
| /* Calculate final size */ |
| pkt->size = 0; |
| for (int i = 0; i < f->slice_count; i++) { |
| sc = &((uint64_t *)results_data_buf->mapped_mem)[i*2]; |
| av_log(avctx, AV_LOG_DEBUG, "Slice %i size = %"PRIu64", " |
| "src offset = %"PRIu64"\n", |
| i, sc[0], sc[1]); |
| |
| fv->buf_regions[i] = (VkBufferCopy) { |
| .srcOffset = sc[1], |
| .dstOffset = pkt->size, |
| .size = sc[0], |
| }; |
| pkt->size += sc[0]; |
| } |
| av_log(avctx, AV_LOG_VERBOSE, "Encoded data: %iMiB\n", pkt->size / (1024*1024)); |
| av_buffer_unref(&fd->results_data_ref); /* No need for this buffer anymore */ |
| |
| /* Allocate packet */ |
| if ((err = ff_get_encode_buffer(avctx, pkt, pkt->size, 0)) < 0) |
| return err; |
| |
| pkt->pts = fd->pts; |
| pkt->dts = fd->pts; |
| pkt->duration = fd->duration; |
| pkt->flags |= AV_PKT_FLAG_KEY * fd->key_frame; |
| |
| if (avctx->flags & AV_CODEC_FLAG_COPY_OPAQUE) { |
| pkt->opaque = fd->frame_opaque; |
| pkt->opaque_ref = fd->frame_opaque_ref; |
| fd->frame_opaque_ref = NULL; |
| } |
| |
| /* Try using host mapped memory transfers first */ |
| if (fv->s.extensions & FF_VK_EXT_EXTERNAL_HOST_MEMORY) { |
| err = transfer_slices(avctx, fv->buf_regions, f->slice_count, fd, |
| pkt->data, pkt->buf); |
| if (err >= 0) |
| return err; |
| } |
| |
| /* Invalidate slice/output data if needed */ |
| if (!(out_data_buf->flags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT)) { |
| VkMappedMemoryRange invalidate_data = { |
| .sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE, |
| .memory = out_data_buf->mem, |
| .offset = 0, |
| .size = VK_WHOLE_SIZE, |
| }; |
| vk->InvalidateMappedMemoryRanges(fv->s.hwctx->act_dev, |
| 1, &invalidate_data); |
| } |
| |
| /* Copy each slice */ |
| for (int i = 0; i < f->slice_count; i++) { |
| VkBufferCopy *region = &fv->buf_regions[i]; |
| memcpy(pkt->data + region->dstOffset, |
| out_data_buf->mapped_mem + region->srcOffset, |
| region->size); |
| } |
| |
| av_buffer_unref(&fd->out_data_ref); |
| |
| return 0; |
| } |
| |
| static int vulkan_encode_ffv1_receive_packet(AVCodecContext *avctx, |
| AVPacket *pkt) |
| { |
| int err; |
| VulkanEncodeFFv1Context *fv = avctx->priv_data; |
| VulkanEncodeFFv1FrameData *fd; |
| FFVkExecContext *exec; |
| AVFrame *frame; |
| |
| while (1) { |
| /* Roll an execution context */ |
| exec = ff_vk_exec_get(&fv->s, &fv->exec_pool); |
| |
| /* If it had a frame, immediately output it */ |
| if (exec->had_submission) { |
| exec->had_submission = 0; |
| fv->in_flight--; |
| return get_packet(avctx, exec, pkt); |
| } |
| |
| /* Get next frame to encode */ |
| frame = fv->frame; |
| err = ff_encode_get_frame(avctx, frame); |
| if (err < 0 && err != AVERROR_EOF) { |
| return err; |
| } else if (err == AVERROR_EOF) { |
| if (!fv->in_flight) |
| return err; |
| continue; |
| } |
| |
| /* Encode frame */ |
| fd = exec->opaque; |
| fd->pts = frame->pts; |
| fd->duration = frame->duration; |
| if (avctx->flags & AV_CODEC_FLAG_COPY_OPAQUE) { |
| fd->frame_opaque = frame->opaque; |
| fd->frame_opaque_ref = frame->opaque_ref; |
| frame->opaque_ref = NULL; |
| } |
| |
| err = vulkan_encode_ffv1_submit_frame(avctx, exec, frame); |
| av_frame_unref(frame); |
| if (err < 0) |
| return err; |
| |
| fv->in_flight++; |
| if (fv->in_flight < fv->async_depth) |
| return AVERROR(EAGAIN); |
| } |
| |
| return 0; |
| } |
| |
| static int init_indirect(AVCodecContext *avctx, enum AVPixelFormat sw_format) |
| { |
| int err; |
| VulkanEncodeFFv1Context *fv = avctx->priv_data; |
| FFV1Context *f = &fv->ctx; |
| AVHWFramesContext *frames_ctx; |
| AVVulkanFramesContext *vk_frames; |
| |
| fv->intermediate_frames_ref = av_hwframe_ctx_alloc(fv->s.device_ref); |
| if (!fv->intermediate_frames_ref) |
| return AVERROR(ENOMEM); |
| |
| frames_ctx = (AVHWFramesContext *)fv->intermediate_frames_ref->data; |
| frames_ctx->format = AV_PIX_FMT_VULKAN; |
| frames_ctx->sw_format = sw_format; |
| frames_ctx->width = fv->s.frames->width; |
| frames_ctx->height = f->num_v_slices*RGB_LINECACHE; |
| |
| vk_frames = frames_ctx->hwctx; |
| vk_frames->tiling = VK_IMAGE_TILING_OPTIMAL; |
| vk_frames->usage = VK_IMAGE_USAGE_STORAGE_BIT | |
| VK_IMAGE_USAGE_TRANSFER_DST_BIT; |
| vk_frames->img_flags = VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT; |
| |
| err = av_hwframe_ctx_init(fv->intermediate_frames_ref); |
| if (err < 0) { |
| av_log(avctx, AV_LOG_ERROR, "Unable to initialize frame pool with format %s: %s\n", |
| av_get_pix_fmt_name(sw_format), av_err2str(err)); |
| av_buffer_unref(&fv->intermediate_frames_ref); |
| return err; |
| } |
| |
| return 0; |
| } |
| |
| static int check_support(AVHWFramesConstraints *constraints, |
| enum AVPixelFormat fmt) |
| { |
| for (int i = 0; constraints->valid_sw_formats[i]; i++) { |
| if (constraints->valid_sw_formats[i] == fmt) |
| return 1; |
| } |
| return 0; |
| } |
| |
| static enum AVPixelFormat get_supported_rgb_buffer_fmt(AVCodecContext *avctx) |
| { |
| VulkanEncodeFFv1Context *fv = avctx->priv_data; |
| |
| enum AVPixelFormat fmt; |
| AVHWFramesConstraints *constraints; |
| constraints = av_hwdevice_get_hwframe_constraints(fv->s.device_ref, |
| NULL); |
| |
| /* What we'd like to optimally have */ |
| fmt = fv->ctx.use32bit ? |
| (fv->ctx.transparency ? AV_PIX_FMT_RGBA128 : AV_PIX_FMT_RGB96) : |
| (fv->ctx.transparency ? AV_PIX_FMT_RGBA64 : AV_PIX_FMT_RGB48); |
| if (check_support(constraints, fmt)) |
| goto end; |
| |
| if (fv->ctx.use32bit) { |
| if (check_support(constraints, (fmt = AV_PIX_FMT_RGBA128))) |
| goto end; |
| } else { |
| if (check_support(constraints, (fmt = AV_PIX_FMT_RGBA64))) |
| goto end; |
| |
| if (!fv->ctx.transparency && |
| check_support(constraints, (fmt = AV_PIX_FMT_RGB96))) |
| goto end; |
| |
| if (check_support(constraints, (fmt = AV_PIX_FMT_RGBA128))) |
| goto end; |
| } |
| |
| fmt = AV_PIX_FMT_NONE; |
| |
| end: |
| av_hwframe_constraints_free(&constraints); |
| return fmt; |
| } |
| |
| static void define_shared_code(AVCodecContext *avctx, FFVulkanShader *shd) |
| { |
| VulkanEncodeFFv1Context *fv = avctx->priv_data; |
| FFV1Context *f = &fv->ctx; |
| int smp_bits = fv->ctx.use32bit ? 32 : 16; |
| |
| av_bprintf(&shd->src, "#define RGB_LINECACHE %i\n" ,RGB_LINECACHE); |
| av_bprintf(&shd->src, "#define CONTEXT_SIZE %i\n" ,CONTEXT_SIZE); |
| av_bprintf(&shd->src, "#define MAX_QUANT_TABLE_MASK 0x%x\n" ,MAX_QUANT_TABLE_MASK); |
| |
| if (f->ac == AC_GOLOMB_RICE) { |
| av_bprintf(&shd->src, "#define PB_UNALIGNED\n" ); |
| av_bprintf(&shd->src, "#define GOLOMB\n" ); |
| } |
| |
| if (fv->is_rgb) |
| av_bprintf(&shd->src, "#define RGB\n"); |
| |
| GLSLF(0, #define TYPE int%i_t ,smp_bits); |
| GLSLF(0, #define VTYPE2 i%ivec2 ,smp_bits); |
| GLSLF(0, #define VTYPE3 i%ivec3 ,smp_bits); |
| GLSLD(ff_source_rangecoder_comp); |
| |
| if (f->ac == AC_GOLOMB_RICE) |
| GLSLD(ff_source_ffv1_vlc_comp); |
| |
| GLSLD(ff_source_ffv1_common_comp); |
| } |
| |
| static int init_rct_search_shader(AVCodecContext *avctx, FFVkSPIRVCompiler *spv) |
| { |
| int err; |
| VulkanEncodeFFv1Context *fv = avctx->priv_data; |
| FFV1Context *f = &fv->ctx; |
| FFVulkanShader *shd = &fv->rct_search; |
| FFVulkanDescriptorSetBinding *desc_set; |
| |
| uint8_t *spv_data; |
| size_t spv_len; |
| void *spv_opaque = NULL; |
| |
| RET(ff_vk_shader_init(&fv->s, shd, "ffv1_rct_search", |
| VK_SHADER_STAGE_COMPUTE_BIT, |
| (const char *[]) { "GL_EXT_buffer_reference", |
| "GL_EXT_buffer_reference2", |
| "GL_EXT_null_initializer" }, 3, |
| 32, 32, 1, |
| 0)); |
| |
| /* Common codec header */ |
| GLSLD(ff_source_common_comp); |
| |
| GLSLC(0, layout(push_constant, scalar) uniform pushConstants { ); |
| GLSLC(1, ivec4 fmt_lut; ); |
| GLSLC(1, int rct_offset; ); |
| GLSLC(1, uint8_t planar_rgb; ); |
| GLSLC(1, uint8_t transparency; ); |
| GLSLC(1, uint8_t key_frame; ); |
| GLSLC(1, uint8_t force_pcm; ); |
| GLSLC(1, uint8_t version; ); |
| GLSLC(1, uint8_t micro_version; ); |
| GLSLC(1, uint8_t padding[3]; ); |
| GLSLC(0, }; ); |
| ff_vk_shader_add_push_const(shd, 0, sizeof(FFv1VkResetParameters), |
| VK_SHADER_STAGE_COMPUTE_BIT); |
| |
| av_bprintf(&shd->src, "#define MAX_QUANT_TABLES %i\n", MAX_QUANT_TABLES); |
| av_bprintf(&shd->src, "#define MAX_CONTEXT_INPUTS %i\n", MAX_CONTEXT_INPUTS); |
| av_bprintf(&shd->src, "#define MAX_QUANT_TABLE_SIZE %i\n", MAX_QUANT_TABLE_SIZE); |
| |
| /* Never used */ |
| desc_set = (FFVulkanDescriptorSetBinding []) { |
| { |
| .name = "rangecoder_static_buf", |
| .type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, |
| .stages = VK_SHADER_STAGE_COMPUTE_BIT, |
| .mem_layout = "scalar", |
| .buf_content = "uint8_t zero_one_state[512];", |
| }, |
| { |
| .name = "quant_buf", |
| .type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, |
| .stages = VK_SHADER_STAGE_COMPUTE_BIT, |
| .mem_layout = "scalar", |
| .buf_content = "int16_t quant_table[MAX_QUANT_TABLES]" |
| "[MAX_CONTEXT_INPUTS][MAX_QUANT_TABLE_SIZE];", |
| }, |
| }; |
| RET(ff_vk_shader_add_descriptor_set(&fv->s, shd, desc_set, 2, 1, 1)); |
| |
| define_shared_code(avctx, shd); |
| |
| desc_set = (FFVulkanDescriptorSetBinding []) { |
| { |
| .name = "slice_data_buf", |
| .type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, |
| .stages = VK_SHADER_STAGE_COMPUTE_BIT, |
| .buf_content = "SliceContext slice_ctx", |
| .buf_elems = f->max_slice_count, |
| }, |
| { |
| .name = "src", |
| .type = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, |
| .dimensions = 2, |
| .mem_layout = ff_vk_shader_rep_fmt(fv->s.frames->sw_format, |
| fv->rep_fmt), |
| .elems = av_pix_fmt_count_planes(fv->s.frames->sw_format), |
| .mem_quali = "readonly", |
| .stages = VK_SHADER_STAGE_COMPUTE_BIT, |
| }, |
| }; |
| RET(ff_vk_shader_add_descriptor_set(&fv->s, shd, desc_set, 2, 0, 0)); |
| |
| GLSLD(ff_source_ffv1_rct_search_comp); |
| |
| RET(spv->compile_shader(&fv->s, spv, shd, &spv_data, &spv_len, "main", |
| &spv_opaque)); |
| RET(ff_vk_shader_link(&fv->s, shd, spv_data, spv_len, "main")); |
| |
| RET(ff_vk_shader_register_exec(&fv->s, &fv->exec_pool, shd)); |
| |
| fail: |
| if (spv_opaque) |
| spv->free_shader(spv, &spv_opaque); |
| |
| return err; |
| } |
| |
| static int init_setup_shader(AVCodecContext *avctx, FFVkSPIRVCompiler *spv) |
| { |
| int err; |
| VulkanEncodeFFv1Context *fv = avctx->priv_data; |
| FFV1Context *f = &fv->ctx; |
| FFVulkanShader *shd = &fv->setup; |
| FFVulkanDescriptorSetBinding *desc_set; |
| |
| uint8_t *spv_data; |
| size_t spv_len; |
| void *spv_opaque = NULL; |
| |
| RET(ff_vk_shader_init(&fv->s, shd, "ffv1_setup", |
| VK_SHADER_STAGE_COMPUTE_BIT, |
| (const char *[]) { "GL_EXT_buffer_reference", |
| "GL_EXT_buffer_reference2" }, 2, |
| 1, 1, 1, |
| 0)); |
| |
| /* Common codec header */ |
| GLSLD(ff_source_common_comp); |
| add_push_data(shd); |
| |
| av_bprintf(&shd->src, "#define MAX_QUANT_TABLES %i\n", MAX_QUANT_TABLES); |
| av_bprintf(&shd->src, "#define MAX_CONTEXT_INPUTS %i\n", MAX_CONTEXT_INPUTS); |
| av_bprintf(&shd->src, "#define MAX_QUANT_TABLE_SIZE %i\n", MAX_QUANT_TABLE_SIZE); |
| av_bprintf(&shd->src, "#define FULL_RENORM\n"); |
| |
| desc_set = (FFVulkanDescriptorSetBinding []) { |
| { |
| .name = "rangecoder_static_buf", |
| .type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, |
| .stages = VK_SHADER_STAGE_COMPUTE_BIT, |
| .mem_layout = "scalar", |
| .buf_content = "uint8_t zero_one_state[512];", |
| }, |
| { /* This descriptor is never used */ |
| .name = "quant_buf", |
| .type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, |
| .stages = VK_SHADER_STAGE_COMPUTE_BIT, |
| .mem_layout = "scalar", |
| .buf_content = "int16_t quant_table[MAX_QUANT_TABLES]" |
| "[MAX_CONTEXT_INPUTS][MAX_QUANT_TABLE_SIZE];", |
| }, |
| }; |
| RET(ff_vk_shader_add_descriptor_set(&fv->s, shd, desc_set, 2, 1, 0)); |
| |
| define_shared_code(avctx, shd); |
| |
| desc_set = (FFVulkanDescriptorSetBinding []) { |
| { |
| .name = "slice_data_buf", |
| .type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, |
| .stages = VK_SHADER_STAGE_COMPUTE_BIT, |
| .buf_content = "SliceContext slice_ctx", |
| .buf_elems = f->max_slice_count, |
| }, |
| { |
| .name = "src", |
| .type = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, |
| .dimensions = 2, |
| .mem_layout = ff_vk_shader_rep_fmt(fv->s.frames->sw_format, |
| fv->rep_fmt), |
| .elems = av_pix_fmt_count_planes(fv->s.frames->sw_format), |
| .mem_quali = "readonly", |
| .stages = VK_SHADER_STAGE_COMPUTE_BIT, |
| }, |
| }; |
| RET(ff_vk_shader_add_descriptor_set(&fv->s, shd, desc_set, 2, 0, 0)); |
| |
| GLSLD(ff_source_ffv1_enc_setup_comp); |
| |
| RET(spv->compile_shader(&fv->s, spv, shd, &spv_data, &spv_len, "main", |
| &spv_opaque)); |
| RET(ff_vk_shader_link(&fv->s, shd, spv_data, spv_len, "main")); |
| |
| RET(ff_vk_shader_register_exec(&fv->s, &fv->exec_pool, shd)); |
| |
| fail: |
| if (spv_opaque) |
| spv->free_shader(spv, &spv_opaque); |
| |
| return err; |
| } |
| |
| static int init_reset_shader(AVCodecContext *avctx, FFVkSPIRVCompiler *spv) |
| { |
| int err; |
| VulkanEncodeFFv1Context *fv = avctx->priv_data; |
| FFV1Context *f = &fv->ctx; |
| FFVulkanShader *shd = &fv->reset; |
| FFVulkanDescriptorSetBinding *desc_set; |
| |
| uint8_t *spv_data; |
| size_t spv_len; |
| void *spv_opaque = NULL; |
| int wg_dim = FFMIN(fv->s.props.properties.limits.maxComputeWorkGroupSize[0], 1024); |
| |
| RET(ff_vk_shader_init(&fv->s, shd, "ffv1_reset", |
| VK_SHADER_STAGE_COMPUTE_BIT, |
| (const char *[]) { "GL_EXT_buffer_reference", |
| "GL_EXT_buffer_reference2" }, 2, |
| wg_dim, 1, 1, |
| 0)); |
| |
| /* Common codec header */ |
| GLSLD(ff_source_common_comp); |
| |
| GLSLC(0, layout(push_constant, scalar) uniform pushConstants { ); |
| GLSLF(1, uint context_count[%i]; ,MAX_QUANT_TABLES); |
| GLSLC(1, u8buf slice_state; ); |
| GLSLC(1, uint plane_state_size; ); |
| GLSLC(1, uint8_t codec_planes; ); |
| GLSLC(1, uint8_t key_frame; ); |
| GLSLC(1, uint8_t version; ); |
| GLSLC(1, uint8_t micro_version; ); |
| GLSLC(1, uint8_t padding[1]; ); |
| GLSLC(0, }; ); |
| ff_vk_shader_add_push_const(shd, 0, sizeof(FFv1VkResetParameters), |
| VK_SHADER_STAGE_COMPUTE_BIT); |
| |
| av_bprintf(&shd->src, "#define MAX_QUANT_TABLES %i\n", MAX_QUANT_TABLES); |
| av_bprintf(&shd->src, "#define MAX_CONTEXT_INPUTS %i\n", MAX_CONTEXT_INPUTS); |
| av_bprintf(&shd->src, "#define MAX_QUANT_TABLE_SIZE %i\n", MAX_QUANT_TABLE_SIZE); |
| |
| desc_set = (FFVulkanDescriptorSetBinding []) { |
| { |
| .name = "rangecoder_static_buf", |
| .type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, |
| .stages = VK_SHADER_STAGE_COMPUTE_BIT, |
| .mem_layout = "scalar", |
| .buf_content = "uint8_t zero_one_state[512];", |
| }, |
| { |
| .name = "quant_buf", |
| .type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, |
| .stages = VK_SHADER_STAGE_COMPUTE_BIT, |
| .mem_layout = "scalar", |
| .buf_content = "int16_t quant_table[MAX_QUANT_TABLES]" |
| "[MAX_CONTEXT_INPUTS][MAX_QUANT_TABLE_SIZE];", |
| }, |
| }; |
| RET(ff_vk_shader_add_descriptor_set(&fv->s, shd, desc_set, 2, 1, 0)); |
| |
| define_shared_code(avctx, shd); |
| |
| desc_set = (FFVulkanDescriptorSetBinding []) { |
| { |
| .name = "slice_data_buf", |
| .type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, |
| .mem_quali = "readonly", |
| .stages = VK_SHADER_STAGE_COMPUTE_BIT, |
| .buf_content = "SliceContext slice_ctx", |
| .buf_elems = f->max_slice_count, |
| }, |
| }; |
| RET(ff_vk_shader_add_descriptor_set(&fv->s, shd, desc_set, 1, 0, 0)); |
| |
| GLSLD(ff_source_ffv1_reset_comp); |
| |
| RET(spv->compile_shader(&fv->s, spv, shd, &spv_data, &spv_len, "main", |
| &spv_opaque)); |
| RET(ff_vk_shader_link(&fv->s, shd, spv_data, spv_len, "main")); |
| |
| RET(ff_vk_shader_register_exec(&fv->s, &fv->exec_pool, shd)); |
| |
| fail: |
| if (spv_opaque) |
| spv->free_shader(spv, &spv_opaque); |
| |
| return err; |
| } |
| |
| static int init_encode_shader(AVCodecContext *avctx, FFVkSPIRVCompiler *spv) |
| { |
| int err; |
| VulkanEncodeFFv1Context *fv = avctx->priv_data; |
| FFV1Context *f = &fv->ctx; |
| FFVulkanShader *shd = &fv->enc; |
| FFVulkanDescriptorSetBinding *desc_set; |
| |
| uint8_t *spv_data; |
| size_t spv_len; |
| void *spv_opaque = NULL; |
| int use_cached_reader = fv->ctx.ac != AC_GOLOMB_RICE; |
| |
| RET(ff_vk_shader_init(&fv->s, shd, "ffv1_enc", |
| VK_SHADER_STAGE_COMPUTE_BIT, |
| (const char *[]) { "GL_EXT_buffer_reference", |
| "GL_EXT_buffer_reference2" }, 2, |
| use_cached_reader ? CONTEXT_SIZE : 1, 1, 1, |
| 0)); |
| |
| /* Common codec header */ |
| GLSLD(ff_source_common_comp); |
| |
| add_push_data(shd); |
| |
| av_bprintf(&shd->src, "#define MAX_QUANT_TABLES %i\n", MAX_QUANT_TABLES); |
| av_bprintf(&shd->src, "#define MAX_CONTEXT_INPUTS %i\n", MAX_CONTEXT_INPUTS); |
| av_bprintf(&shd->src, "#define MAX_QUANT_TABLE_SIZE %i\n", MAX_QUANT_TABLE_SIZE); |
| |
| if (use_cached_reader) |
| av_bprintf(&shd->src, "#define CACHED_SYMBOL_READER 1\n"); |
| |
| desc_set = (FFVulkanDescriptorSetBinding []) { |
| { |
| .name = "rangecoder_static_buf", |
| .type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, |
| .stages = VK_SHADER_STAGE_COMPUTE_BIT, |
| .mem_layout = "scalar", |
| .buf_content = "uint8_t zero_one_state[512];", |
| }, |
| { |
| .name = "quant_buf", |
| .type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, |
| .stages = VK_SHADER_STAGE_COMPUTE_BIT, |
| .mem_layout = "scalar", |
| .buf_content = "int16_t quant_table[MAX_QUANT_TABLES]" |
| "[MAX_CONTEXT_INPUTS][MAX_QUANT_TABLE_SIZE];", |
| }, |
| { |
| .name = "crc_ieee_buf", |
| .type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, |
| .stages = VK_SHADER_STAGE_COMPUTE_BIT, |
| .mem_layout = "scalar", |
| .buf_content = "uint32_t crc_ieee[256];", |
| }, |
| }; |
| |
| RET(ff_vk_shader_add_descriptor_set(&fv->s, shd, desc_set, 3, 1, 0)); |
| |
| define_shared_code(avctx, shd); |
| |
| desc_set = (FFVulkanDescriptorSetBinding []) { |
| { |
| .name = "slice_data_buf", |
| .type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, |
| .stages = VK_SHADER_STAGE_COMPUTE_BIT, |
| .buf_content = "SliceContext slice_ctx", |
| .buf_elems = f->max_slice_count, |
| }, |
| { |
| .name = "src", |
| .type = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, |
| .dimensions = 2, |
| .mem_layout = ff_vk_shader_rep_fmt(fv->s.frames->sw_format, |
| fv->rep_fmt), |
| .elems = av_pix_fmt_count_planes(fv->s.frames->sw_format), |
| .mem_quali = "readonly", |
| .stages = VK_SHADER_STAGE_COMPUTE_BIT, |
| }, |
| { |
| .name = "results_data_buf", |
| .type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, |
| .stages = VK_SHADER_STAGE_COMPUTE_BIT, |
| .mem_quali = "writeonly", |
| .buf_content = "uint64_t slice_results[2048];", |
| }, |
| { /* place holder for desc_set[3] */ |
| }, |
| }; |
| if (fv->is_rgb) { |
| AVHWFramesContext *intermediate_frames_ctx; |
| intermediate_frames_ctx = (AVHWFramesContext *)fv->intermediate_frames_ref->data; |
| desc_set[3] = (FFVulkanDescriptorSetBinding) { |
| .name = "tmp", |
| .type = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, |
| .dimensions = 2, |
| .mem_layout = ff_vk_shader_rep_fmt(intermediate_frames_ctx->sw_format, |
| FF_VK_REP_NATIVE), |
| .stages = VK_SHADER_STAGE_COMPUTE_BIT, |
| }; |
| } |
| RET(ff_vk_shader_add_descriptor_set(&fv->s, shd, desc_set, 3 + fv->is_rgb, 0, 0)); |
| |
| GLSLD(ff_source_ffv1_enc_comp); |
| |
| RET(spv->compile_shader(&fv->s, spv, shd, &spv_data, &spv_len, "main", |
| &spv_opaque)); |
| RET(ff_vk_shader_link(&fv->s, shd, spv_data, spv_len, "main")); |
| |
| RET(ff_vk_shader_register_exec(&fv->s, &fv->exec_pool, shd)); |
| |
| fail: |
| if (spv_opaque) |
| spv->free_shader(spv, &spv_opaque); |
| |
| return err; |
| } |
| |
| static av_cold int vulkan_encode_ffv1_init(AVCodecContext *avctx) |
| { |
| int err; |
| size_t maxsize, max_heap_size, max_host_size; |
| VulkanEncodeFFv1Context *fv = avctx->priv_data; |
| FFV1Context *f = &fv->ctx; |
| FFVkSPIRVCompiler *spv; |
| |
| if ((err = ff_ffv1_common_init(avctx, f)) < 0) |
| return err; |
| |
| if (f->ac == 1) |
| f->ac = AC_RANGE_CUSTOM_TAB; |
| |
| err = ff_ffv1_encode_setup_plane_info(avctx, avctx->sw_pix_fmt); |
| if (err < 0) |
| return err; |
| |
| /* Target version 3 by default */ |
| f->version = 3; |
| |
| err = ff_ffv1_encode_init(avctx); |
| if (err < 0) |
| return err; |
| |
| /* Rice coding did not support high bit depths */ |
| if (f->bits_per_raw_sample > (f->version > 3 ? 16 : 8)) { |
| if (f->ac == AC_GOLOMB_RICE) { |
| av_log(avctx, AV_LOG_WARNING, "bits_per_raw_sample > 8, " |
| "forcing range coder\n"); |
| f->ac = AC_RANGE_CUSTOM_TAB; |
| } |
| } |
| |
| if (f->version < 4 && avctx->gop_size > 1) { |
| av_log(avctx, AV_LOG_ERROR, "Using inter frames requires version 4 (-level 4)\n"); |
| return AVERROR_INVALIDDATA; |
| } |
| |
| if (f->version == 4 && avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) { |
| av_log(avctx, AV_LOG_ERROR, "Version 4 is experimental and requires -strict -2\n"); |
| return AVERROR_INVALIDDATA; |
| } |
| |
| /* We target version 4.3 */ |
| if (f->version == 4 && f->micro_version > 4) |
| f->micro_version = 3; |
| |
| //if (fv->ctx.ac == AC_GOLOMB_RICE) { |
| if (0) { |
| int w_a = FFALIGN(avctx->width, LG_ALIGN_W); |
| int h_a = FFALIGN(avctx->height, LG_ALIGN_H); |
| int w_sl, h_sl; |
| |
| /* Pixels per line an invocation handles */ |
| int ppi = 0; |
| /* Chunk size */ |
| int chunks = 0; |
| |
| do { |
| if (ppi < 2) |
| ppi++; |
| chunks++; |
| w_sl = w_a / (LG_ALIGN_W*ppi); |
| h_sl = h_a / (LG_ALIGN_H*chunks); |
| } while (w_sl > MAX_SLICES / h_sl); |
| |
| av_log(avctx, AV_LOG_VERBOSE, "Slice config: %ix%i, %i total\n", |
| LG_ALIGN_W*ppi, LG_ALIGN_H*chunks, w_sl*h_sl); |
| av_log(avctx, AV_LOG_VERBOSE, "Horizontal slices: %i (%i pixels per invoc)\n", |
| w_sl, ppi); |
| av_log(avctx, AV_LOG_VERBOSE, "Vertical slices: %i (%i chunks)\n", |
| h_sl, chunks); |
| |
| f->num_h_slices = w_sl; |
| f->num_v_slices = h_sl; |
| |
| fv->ppi = ppi; |
| fv->chunks = chunks; |
| } else { |
| f->num_h_slices = fv->num_h_slices; |
| f->num_v_slices = fv->num_v_slices; |
| |
| if (f->num_h_slices <= 0 && f->num_v_slices <= 0) { |
| if (avctx->slices) { |
| err = ff_ffv1_encode_determine_slices(avctx); |
| if (err < 0) |
| return err; |
| } else { |
| f->num_h_slices = 32; |
| f->num_v_slices = 32; |
| } |
| } else if (f->num_h_slices && f->num_v_slices <= 0) { |
| f->num_v_slices = MAX_SLICES / f->num_h_slices; |
| } else if (f->num_v_slices && f->num_h_slices <= 0) { |
| f->num_h_slices = MAX_SLICES / f->num_v_slices; |
| } |
| |
| f->num_h_slices = FFMIN(f->num_h_slices, avctx->width); |
| f->num_v_slices = FFMIN(f->num_v_slices, avctx->height); |
| |
| if (f->num_h_slices * f->num_v_slices > MAX_SLICES) { |
| av_log(avctx, AV_LOG_ERROR, "Too many slices (%i), maximum supported " |
| "by the standard is %i\n", |
| f->num_h_slices * f->num_v_slices, MAX_SLICES); |
| return AVERROR_PATCHWELCOME; |
| } |
| } |
| |
| f->max_slice_count = f->num_h_slices * f->num_v_slices; |
| |
| if ((err = ff_ffv1_write_extradata(avctx)) < 0) |
| return err; |
| |
| if (f->version < 4) { |
| if (((f->chroma_h_shift > 0) && (avctx->width % (64 << f->chroma_h_shift))) || |
| ((f->chroma_v_shift > 0) && (avctx->height % (64 << f->chroma_v_shift)))) { |
| av_log(avctx, AV_LOG_ERROR, "Encoding frames with subsampling and unaligned " |
| "dimensions is only supported in version 4 (-level 4)\n"); |
| return AVERROR_PATCHWELCOME; |
| } |
| } |
| |
| if (fv->force_pcm) { |
| if (f->version < 4) { |
| av_log(avctx, AV_LOG_ERROR, "PCM coding only supported by version 4 (-level 4)\n"); |
| return AVERROR_INVALIDDATA; |
| } else if (f->ac == AC_GOLOMB_RICE) { |
| av_log(avctx, AV_LOG_ERROR, "PCM coding requires range coding\n"); |
| return AVERROR_INVALIDDATA; |
| } |
| } |
| |
| /* Init Vulkan */ |
| err = ff_vk_init(&fv->s, avctx, NULL, avctx->hw_frames_ctx); |
| if (err < 0) |
| return err; |
| |
| fv->qf = ff_vk_qf_find(&fv->s, VK_QUEUE_COMPUTE_BIT, 0); |
| if (!fv->qf) { |
| av_log(avctx, AV_LOG_ERROR, "Device has no compute queues!\n"); |
| return err; |
| } |
| |
| /* Try to measure VRAM size */ |
| max_heap_size = 0; |
| max_host_size = 0; |
| for (int i = 0; i < fv->s.mprops.memoryHeapCount; i++) { |
| if (fv->s.mprops.memoryHeaps[i].flags & VK_MEMORY_HEAP_DEVICE_LOCAL_BIT) |
| max_heap_size = FFMAX(fv->max_heap_size, |
| fv->s.mprops.memoryHeaps[i].size); |
| if (!(fv->s.mprops.memoryHeaps[i].flags & VK_MEMORY_HEAP_DEVICE_LOCAL_BIT)) |
| max_host_size = FFMAX(max_host_size, |
| fv->s.mprops.memoryHeaps[i].size); |
| } |
| fv->max_heap_size = max_heap_size; |
| |
| maxsize = ff_ffv1_encode_buffer_size(avctx); |
| if (maxsize > fv->s.props_11.maxMemoryAllocationSize) { |
| av_log(avctx, AV_LOG_WARNING, "Encoding buffer size (%zu) larger " |
| "than maximum device allocation (%zu), clipping\n", |
| maxsize, fv->s.props_11.maxMemoryAllocationSize); |
| maxsize = fv->s.props_11.maxMemoryAllocationSize; |
| } |
| |
| if (max_heap_size < maxsize) { |
| av_log(avctx, AV_LOG_WARNING, "Encoding buffer (%zu) larger than VRAM (%zu), " |
| "using host memory (slower)\n", |
| maxsize, fv->max_heap_size); |
| |
| /* Keep 1/2th of RAM as headroom */ |
| max_heap_size = max_host_size - (max_host_size >> 1); |
| } else { |
| /* Keep 1/8th of VRAM as headroom */ |
| max_heap_size = max_heap_size - (max_heap_size >> 3); |
| } |
| |
| av_log(avctx, AV_LOG_INFO, "Async buffers: %zuMiB per context, %zuMiB total, depth: %i\n", |
| maxsize / (1024*1024), |
| (fv->async_depth * maxsize) / (1024*1024), |
| fv->async_depth); |
| |
| err = ff_vk_exec_pool_init(&fv->s, fv->qf, &fv->exec_pool, |
| fv->async_depth, |
| 0, 0, 0, NULL); |
| if (err < 0) |
| return err; |
| |
| fv->transfer_qf = ff_vk_qf_find(&fv->s, VK_QUEUE_TRANSFER_BIT, 0); |
| if (!fv->transfer_qf) { |
| av_log(avctx, AV_LOG_ERROR, "Device has no transfer queues!\n"); |
| return err; |
| } |
| |
| err = ff_vk_exec_pool_init(&fv->s, fv->transfer_qf, &fv->transfer_exec_pool, |
| 1, |
| 0, 0, 0, NULL); |
| if (err < 0) |
| return err; |
| |
| spv = ff_vk_spirv_init(); |
| if (!spv) { |
| av_log(avctx, AV_LOG_ERROR, "Unable to initialize SPIR-V compiler!\n"); |
| return AVERROR_EXTERNAL; |
| } |
| |
| /* Detect the special RGB coding mode */ |
| fv->is_rgb = !(f->colorspace == 0 && avctx->sw_pix_fmt != AV_PIX_FMT_YA8) && |
| !(avctx->sw_pix_fmt == AV_PIX_FMT_YA8); |
| |
| /* bits_per_raw_sample use regular unsigned representation, |
| * but in higher bit depths, the data is casted to int16_t */ |
| fv->rep_fmt = FF_VK_REP_UINT; |
| if (!fv->is_rgb && f->bits_per_raw_sample > 8) |
| fv->rep_fmt = FF_VK_REP_INT; |
| |
| /* Init rct search shader */ |
| fv->optimize_rct = fv->is_rgb && f->version >= 4 && |
| !fv->force_pcm && fv->optimize_rct; |
| if (fv->optimize_rct) { |
| err = init_rct_search_shader(avctx, spv); |
| if (err < 0) { |
| spv->uninit(&spv); |
| return err; |
| } |
| } |
| |
| /* Init setup shader */ |
| err = init_setup_shader(avctx, spv); |
| if (err < 0) { |
| spv->uninit(&spv); |
| return err; |
| } |
| |
| /* Init reset shader */ |
| err = init_reset_shader(avctx, spv); |
| if (err < 0) { |
| spv->uninit(&spv); |
| return err; |
| } |
| |
| if (fv->is_rgb) { |
| enum AVPixelFormat intermediate_fmt = get_supported_rgb_buffer_fmt(avctx); |
| if (intermediate_fmt == AV_PIX_FMT_NONE) { |
| av_log(avctx, AV_LOG_ERROR, "Unable to find a supported compatible " |
| "pixel format for RCT buffer!\n"); |
| return AVERROR(ENOTSUP); |
| } |
| |
| RET(init_indirect(avctx, intermediate_fmt)); |
| } |
| |
| /* Encode shader */ |
| err = init_encode_shader(avctx, spv); |
| if (err < 0) { |
| spv->uninit(&spv); |
| return err; |
| } |
| |
| spv->uninit(&spv); |
| |
| /* Range coder data */ |
| err = ff_ffv1_vk_init_state_transition_data(&fv->s, |
| &fv->rangecoder_static_buf, |
| f); |
| if (err < 0) |
| return err; |
| |
| /* Quantization table data */ |
| err = ff_ffv1_vk_init_quant_table_data(&fv->s, |
| &fv->quant_buf, |
| f); |
| if (err < 0) |
| return err; |
| |
| /* CRC table buffer */ |
| err = ff_ffv1_vk_init_crc_table_data(&fv->s, |
| &fv->crc_tab_buf, |
| f); |
| if (err < 0) |
| return err; |
| |
| /* Update setup global descriptors */ |
| RET(ff_vk_shader_update_desc_buffer(&fv->s, &fv->exec_pool.contexts[0], |
| &fv->setup, 0, 0, 0, |
| &fv->rangecoder_static_buf, |
| 0, fv->rangecoder_static_buf.size, |
| VK_FORMAT_UNDEFINED)); |
| |
| /* Update encode global descriptors */ |
| RET(ff_vk_shader_update_desc_buffer(&fv->s, &fv->exec_pool.contexts[0], |
| &fv->enc, 0, 0, 0, |
| &fv->rangecoder_static_buf, |
| 0, fv->rangecoder_static_buf.size, |
| VK_FORMAT_UNDEFINED)); |
| RET(ff_vk_shader_update_desc_buffer(&fv->s, &fv->exec_pool.contexts[0], |
| &fv->enc, 0, 1, 0, |
| &fv->quant_buf, |
| 0, fv->quant_buf.size, |
| VK_FORMAT_UNDEFINED)); |
| RET(ff_vk_shader_update_desc_buffer(&fv->s, &fv->exec_pool.contexts[0], |
| &fv->enc, 0, 2, 0, |
| &fv->crc_tab_buf, |
| 0, fv->crc_tab_buf.size, |
| VK_FORMAT_UNDEFINED)); |
| |
| /* Temporary frame */ |
| fv->frame = av_frame_alloc(); |
| if (!fv->frame) |
| return AVERROR(ENOMEM); |
| |
| /* Async data pool */ |
| fv->async_depth = fv->exec_pool.pool_size; |
| fv->exec_ctx_info = av_calloc(fv->async_depth, sizeof(*fv->exec_ctx_info)); |
| if (!fv->exec_ctx_info) |
| return AVERROR(ENOMEM); |
| for (int i = 0; i < fv->async_depth; i++) |
| fv->exec_pool.contexts[i].opaque = &fv->exec_ctx_info[i]; |
| |
| fv->buf_regions = av_malloc_array(f->max_slice_count, sizeof(*fv->buf_regions)); |
| if (!fv->buf_regions) |
| return AVERROR(ENOMEM); |
| |
| fail: |
| return err; |
| } |
| |
| static av_cold int vulkan_encode_ffv1_close(AVCodecContext *avctx) |
| { |
| VulkanEncodeFFv1Context *fv = avctx->priv_data; |
| |
| ff_vk_exec_pool_free(&fv->s, &fv->exec_pool); |
| ff_vk_exec_pool_free(&fv->s, &fv->transfer_exec_pool); |
| |
| ff_vk_shader_free(&fv->s, &fv->enc); |
| ff_vk_shader_free(&fv->s, &fv->reset); |
| ff_vk_shader_free(&fv->s, &fv->setup); |
| ff_vk_shader_free(&fv->s, &fv->rct_search); |
| |
| if (fv->exec_ctx_info) { |
| for (int i = 0; i < fv->async_depth; i++) { |
| VulkanEncodeFFv1FrameData *fd = &fv->exec_ctx_info[i]; |
| av_buffer_unref(&fd->out_data_ref); |
| av_buffer_unref(&fd->results_data_ref); |
| av_buffer_unref(&fd->frame_opaque_ref); |
| } |
| } |
| av_free(fv->exec_ctx_info); |
| |
| av_buffer_unref(&fv->intermediate_frames_ref); |
| |
| av_buffer_pool_uninit(&fv->results_data_pool); |
| |
| av_buffer_pool_uninit(&fv->out_data_pool); |
| |
| av_buffer_unref(&fv->keyframe_slice_data_ref); |
| av_buffer_pool_uninit(&fv->slice_data_pool); |
| |
| ff_vk_free_buf(&fv->s, &fv->quant_buf); |
| ff_vk_free_buf(&fv->s, &fv->rangecoder_static_buf); |
| ff_vk_free_buf(&fv->s, &fv->crc_tab_buf); |
| |
| av_free(fv->buf_regions); |
| av_frame_free(&fv->frame); |
| ff_vk_uninit(&fv->s); |
| |
| return 0; |
| } |
| |
| #define OFFSET(x) offsetof(VulkanEncodeFFv1Context, x) |
| #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM |
| static const AVOption vulkan_encode_ffv1_options[] = { |
| { "slicecrc", "Protect slices with CRCs", OFFSET(ctx.ec), AV_OPT_TYPE_INT, |
| { .i64 = -1 }, -1, 2, VE }, |
| { "context", "Context model", OFFSET(ctx.context_model), AV_OPT_TYPE_INT, |
| { .i64 = 0 }, 0, 1, VE }, |
| { "coder", "Coder type", OFFSET(ctx.ac), AV_OPT_TYPE_INT, |
| { .i64 = AC_RANGE_CUSTOM_TAB }, -2, 2, VE, .unit = "coder" }, |
| { "rice", "Golomb rice", 0, AV_OPT_TYPE_CONST, |
| { .i64 = AC_GOLOMB_RICE }, INT_MIN, INT_MAX, VE, .unit = "coder" }, |
| { "range_def", "Range with default table", 0, AV_OPT_TYPE_CONST, |
| { .i64 = AC_RANGE_DEFAULT_TAB_FORCE }, INT_MIN, INT_MAX, VE, .unit = "coder" }, |
| { "range_tab", "Range with custom table", 0, AV_OPT_TYPE_CONST, |
| { .i64 = AC_RANGE_CUSTOM_TAB }, INT_MIN, INT_MAX, VE, .unit = "coder" }, |
| { "qtable", "Quantization table", OFFSET(ctx.qtable), AV_OPT_TYPE_INT, |
| { .i64 = -1 }, -1, 2, VE , .unit = "qtable"}, |
| { "default", NULL, 0, AV_OPT_TYPE_CONST, |
| { .i64 = QTABLE_DEFAULT }, INT_MIN, INT_MAX, VE, .unit = "qtable" }, |
| { "8bit", NULL, 0, AV_OPT_TYPE_CONST, |
| { .i64 = QTABLE_8BIT }, INT_MIN, INT_MAX, VE, .unit = "qtable" }, |
| { "greater8bit", NULL, 0, AV_OPT_TYPE_CONST, |
| { .i64 = QTABLE_GT8BIT }, INT_MIN, INT_MAX, VE, .unit = "qtable" }, |
| |
| { "slices_h", "Number of horizontal slices", OFFSET(num_h_slices), AV_OPT_TYPE_INT, |
| { .i64 = -1 }, -1, MAX_SLICES, VE }, |
| { "slices_v", "Number of vertical slices", OFFSET(num_v_slices), AV_OPT_TYPE_INT, |
| { .i64 = -1 }, -1, MAX_SLICES, VE }, |
| |
| { "force_pcm", "Code all slices with no prediction", OFFSET(force_pcm), AV_OPT_TYPE_BOOL, |
| { .i64 = 0 }, 0, 1, VE }, |
| |
| { "rct_search", "Run a search for RCT parameters (level 4 only)", OFFSET(optimize_rct), AV_OPT_TYPE_BOOL, |
| { .i64 = 1 }, 0, 1, VE }, |
| |
| { "async_depth", "Internal parallelization depth", OFFSET(async_depth), AV_OPT_TYPE_INT, |
| { .i64 = 1 }, 1, INT_MAX, VE }, |
| |
| { NULL } |
| }; |
| |
| static const FFCodecDefault vulkan_encode_ffv1_defaults[] = { |
| { "g", "1" }, |
| { NULL }, |
| }; |
| |
| static const AVClass vulkan_encode_ffv1_class = { |
| .class_name = "ffv1_vulkan", |
| .item_name = av_default_item_name, |
| .option = vulkan_encode_ffv1_options, |
| .version = LIBAVUTIL_VERSION_INT, |
| }; |
| |
| const AVCodecHWConfigInternal *const vulkan_encode_ffv1_hw_configs[] = { |
| HW_CONFIG_ENCODER_FRAMES(VULKAN, VULKAN), |
| NULL, |
| }; |
| |
| const FFCodec ff_ffv1_vulkan_encoder = { |
| .p.name = "ffv1_vulkan", |
| CODEC_LONG_NAME("FFmpeg video codec #1 (Vulkan)"), |
| .p.type = AVMEDIA_TYPE_VIDEO, |
| .p.id = AV_CODEC_ID_FFV1, |
| .priv_data_size = sizeof(VulkanEncodeFFv1Context), |
| .init = &vulkan_encode_ffv1_init, |
| FF_CODEC_RECEIVE_PACKET_CB(&vulkan_encode_ffv1_receive_packet), |
| .close = &vulkan_encode_ffv1_close, |
| .p.priv_class = &vulkan_encode_ffv1_class, |
| .p.capabilities = AV_CODEC_CAP_DELAY | |
| AV_CODEC_CAP_HARDWARE | |
| AV_CODEC_CAP_DR1 | |
| AV_CODEC_CAP_ENCODER_FLUSH | |
| AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE, |
| .caps_internal = FF_CODEC_CAP_INIT_CLEANUP | FF_CODEC_CAP_EOF_FLUSH, |
| .defaults = vulkan_encode_ffv1_defaults, |
| CODEC_PIXFMTS(AV_PIX_FMT_VULKAN), |
| .hw_configs = vulkan_encode_ffv1_hw_configs, |
| .p.wrapper_name = "vulkan", |
| }; |
