vulkan_ffv1: pipe through slice decoding status

Lynne committed 1 year ago

Commit 7b45d9c1 parent cb8f4b65 files · +52 −18Browse files

Showing the changes to libavcodec (5 of 5 files). Show all

Unified · Split

5 files

libavcodec/vulkan/ffv1_dec.comp +4 −0
libavcodec/vulkan/ffv1_dec_setup.comp +3 −1
libavcodec/vulkan_decode.c +1 −0
libavcodec/vulkan_decode.h +1 −0
libavcodec/vulkan_ffv1.c +43 −17

@@ -291,4 +291,8 @@ void main(void) · 290 unmodified lines
291	{	291	{
292	const uint slice_idx = gl_WorkGroupID.y*gl_NumWorkGroups.x + gl_WorkGroupID.x;	292	const uint slice_idx = gl_WorkGroupID.y*gl_NumWorkGroups.x + gl_WorkGroupID.x;
293	decode_slice(slice_ctx[slice_idx], slice_idx);	293	decode_slice(slice_ctx[slice_idx], slice_idx);
		294
		295	uint32_t status = corrupt ? uint32_t(corrupt) : overread;
		296	if (status != 0)
		297	slice_status[2*slice_idx + 1] = status;
294	}	298	}

libavcodec/vulkan/ffv1_dec_setup.comp+3−1

@@ -133,6 +133,8 @@ void main(void) · 132 unmodified lines
133	for (int i = 0; i < slice_size; i++)	133	for (int i = 0; i < slice_size; i++)
134	crc = crc_ieee[(crc & 0xFF) ^ uint32_t(bs[i].v)] ^ (crc >> 8);	134	crc = crc_ieee[(crc & 0xFF) ^ uint32_t(bs[i].v)] ^ (crc >> 8);
135		135
136	slice_crc_mismatch[slice_idx] = crc;	136	slice_status[2*slice_idx + 0] = crc;
137	}	137	}
		138
		139	slice_status[2*slice_idx + 1] = corrupt ? uint32_t(corrupt) : overread;
138	}	140	}

libavcodec/vulkan_decode.c+1−0

@@ -142,6 +142,7 @@ static void init_frame(FFVulkanDecodeContext dec, FFVulkanDecodePicture vkpic) · 141 unmodified lines
142		142
143	vkpic->destroy_image_view = vk->DestroyImageView;	143	vkpic->destroy_image_view = vk->DestroyImageView;
144	vkpic->wait_semaphores = vk->WaitSemaphores;	144	vkpic->wait_semaphores = vk->WaitSemaphores;
		145	vkpic->invalidate_memory_ranges = vk->InvalidateMappedMemoryRanges;
145	}	146	}
146		147
147	int ff_vk_decode_prepare_frame(FFVulkanDecodeContext dec, AVFrame pic,	148	int ff_vk_decode_prepare_frame(FFVulkanDecodeContext dec, AVFrame pic,

libavcodec/vulkan_decode.h+1−0

@@ -114,6 +114,7 @@ typedef struct FFVulkanDecodePicture { · 113 unmodified lines
114	/* Vulkan functions needed for destruction, as no other context is guaranteed to exist */	114	/* Vulkan functions needed for destruction, as no other context is guaranteed to exist */
115	PFN_vkWaitSemaphores wait_semaphores;	115	PFN_vkWaitSemaphores wait_semaphores;
116	PFN_vkDestroyImageView destroy_image_view;	116	PFN_vkDestroyImageView destroy_image_view;
		117	PFN_vkInvalidateMappedMemoryRanges invalidate_memory_ranges;
117	} FFVulkanDecodePicture;	118	} FFVulkanDecodePicture;
118		119
119	/**	120	/**

libavcodec/vulkan_ffv1.c+43−17

                                   &fp->slice_status_buf,
                                   VK_BUFFER_USAGE_STORAGE_BUFFER_BIT |
                                   VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT,
-                                  NULL, f->slice_count*sizeof(uint32_t),
+                                  NULL, 2*f->slice_count*sizeof(uint32_t),
                                   VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT |
                                   VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT);
     if (err < 0)
     ff_vk_shader_update_desc_buffer(&ctx->s, exec, &fv->setup,
                                     1, 2, 0,
                                     slice_status,
-                                    0, f->slice_count*sizeof(uint32_t),
+                                    0, 2*f->slice_count*sizeof(uint32_t),
                                     VK_FORMAT_UNDEFINED);
     ff_vk_exec_bind_shader(&ctx->s, exec, &fv->setup);
                                   1, 1,
                                   VK_IMAGE_LAYOUT_GENERAL,
                                   VK_NULL_HANDLE);
+    ff_vk_shader_update_desc_buffer(&ctx->s, exec, decode_shader,
+                                    1, 2, 0,
+                                    slice_status,
+                                    0, 2*f->slice_count*sizeof(uint32_t),
+                                    VK_FORMAT_UNDEFINED);
     if (is_rgb)
         ff_vk_shader_update_img_array(&ctx->s, exec, decode_shader,
                                       f->picture.f, vp->view.out,
-                                      1, 2,
+                                      1, 3,
                                       VK_IMAGE_LAYOUT_GENERAL,
                                       VK_NULL_HANDLE);
             .type        = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
             .stages      = VK_SHADER_STAGE_COMPUTE_BIT,
             .mem_quali   = "writeonly",
-            .buf_content = "uint32_t slice_crc_mismatch",
+            .buf_content = "uint32_t slice_status",
-            .buf_elems   = f->max_slice_count,
+            .buf_elems   = 2*f->max_slice_count,
         },
     };
     RET(ff_vk_shader_add_descriptor_set(s, shd, desc_set, 3, 0, 0));
             .elems      = av_pix_fmt_count_planes(dec_frames_ctx->sw_format),
             .stages     = VK_SHADER_STAGE_COMPUTE_BIT,
         },
+        {
+            .name        = "slice_status_buf",
+            .type        = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
+            .stages      = VK_SHADER_STAGE_COMPUTE_BIT,
+            .mem_quali   = "writeonly",
+            .buf_content = "uint32_t slice_status",
+            .buf_elems   = 2*f->max_slice_count,
+        },
         {
             .name       = "dst",
             .type       = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
             .stages     = VK_SHADER_STAGE_COMPUTE_BIT,
         },
     };
-    RET(ff_vk_shader_add_descriptor_set(s, shd, desc_set, 2 + rgb, 0, 0));
+    RET(ff_vk_shader_add_descriptor_set(s, shd, desc_set, 3 + rgb, 0, 0));
     GLSLD(ff_source_ffv1_dec_comp);
 static void vk_ffv1_free_frame_priv(AVRefStructOpaque _hwctx, void *data)
 {
-    AVHWDeviceContext *hwctx = _hwctx.nc;
+    AVHWDeviceContext *dev_ctx = _hwctx.nc;
+    AVVulkanDeviceContext *hwctx = dev_ctx->hwctx;
     FFv1VulkanDecodePicture *fp = data;
     FFVulkanDecodePicture *vp = &fp->vp;
+    FFVkBuffer *slice_status = (FFVkBuffer *)fp->slice_status_buf->data;
-    ff_vk_decode_free_frame(hwctx, vp);
+    ff_vk_decode_free_frame(dev_ctx, vp);
+    /* Invalidate slice/output data if needed */
+    if (!(slice_status->flags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT)) {
+        VkMappedMemoryRange invalidate_data = {
+            .sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE,
+            .memory = slice_status->mem,
+            .offset = 0,
+            .size = 2*fp->slice_num*sizeof(uint32_t),
+        };
+        vp->invalidate_memory_ranges(hwctx->act_dev,
+                                     1, &invalidate_data);
+    }
-    if (fp->crc_checked) {
+    for (int i = 0; i < fp->slice_num; i++) {
-        FFVkBuffer *slice_status = (FFVkBuffer *)fp->slice_status_buf->data;
+        uint32_t crc_res = 0;
-        for (int i = 0; i < fp->slice_num; i++) {
+        if (fp->crc_checked)
-            uint32_t crc_res;
+            crc_res = AV_RN32(slice_status->mapped_mem + 2*i*sizeof(uint32_t) + 0);
-            crc_res = AV_RN32(slice_status->mapped_mem + i*sizeof(uint32_t));
+        uint32_t status = AV_RN32(slice_status->mapped_mem + 2*i*sizeof(uint32_t) + 4);
-            if (crc_res != 0)
+        if (status || crc_res)
-                av_log(hwctx, AV_LOG_ERROR, "CRC mismatch in slice %i, res: 0x%x\n",
+            av_log(dev_ctx, AV_LOG_ERROR, "Slice %i status: 0x%x, CRC 0x%x\n",
-                       i, crc_res);
+                   i, status, crc_res);
-        }
     }
     av_buffer_unref(&vp->slices_buf);

vulkan_ffv1: pipe through slice decoding status

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code