← Back to branch summary

~mmach/netext73/mesa-ryzen

« back to all changes in this revision

Viewing changes to src/intel/vulkan/anv_video.c

  • Committer: mmach
  • Date: 2023-11-02 21:31:35 UTC
  • Revision ID: netbit73@gmail.com-20231102213135-18d4tzh7tj0uz752
2023-11-02 22:11:57

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/intel/vulkan/anv_video.c
112
112
                                           const VkVideoProfileInfoKHR *pVideoProfile,
113
113
                                           VkVideoCapabilitiesKHR *pCapabilities)
114
114
{
 
115
   ANV_FROM_HANDLE(anv_physical_device, pdevice, physicalDevice);
 
116
 
115
117
   pCapabilities->minBitstreamBufferOffsetAlignment = 32;
116
118
   pCapabilities->minBitstreamBufferSizeAlignment = 32;
117
 
   pCapabilities->pictureAccessGranularity.width = ANV_MB_WIDTH;
118
 
   pCapabilities->pictureAccessGranularity.height = ANV_MB_HEIGHT;
119
 
   pCapabilities->minCodedExtent.width = ANV_MB_WIDTH;
120
 
   pCapabilities->minCodedExtent.height = ANV_MB_HEIGHT;
121
119
   pCapabilities->maxCodedExtent.width = 4096;
122
120
   pCapabilities->maxCodedExtent.height = 4096;
123
121
   pCapabilities->flags = VK_VIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR;
127
125
   if (dec_caps)
128
126
      dec_caps->flags = VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR;
129
127
 
 
128
   /* H264 allows different luma and chroma bit depths */
 
129
   if (pVideoProfile->lumaBitDepth != pVideoProfile->chromaBitDepth)
 
130
      return VK_ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED_KHR;
 
131
 
 
132
   if (pVideoProfile->chromaSubsampling != VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR)
 
133
      return VK_ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED_KHR;
 
134
 
130
135
   switch (pVideoProfile->videoCodecOperation) {
131
136
   case VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR: {
132
137
      struct VkVideoDecodeH264CapabilitiesKHR *ext = (struct VkVideoDecodeH264CapabilitiesKHR *)
133
138
         vk_find_struct(pCapabilities->pNext, VIDEO_DECODE_H264_CAPABILITIES_KHR);
 
139
 
 
140
      if (pVideoProfile->lumaBitDepth != VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR)
 
141
         return VK_ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED_KHR;
 
142
 
134
143
      pCapabilities->maxDpbSlots = 17;
135
 
      pCapabilities->maxActiveReferencePictures = 16;
 
144
      pCapabilities->maxActiveReferencePictures = ANV_VIDEO_H264_MAX_NUM_REF_FRAME;
 
145
      pCapabilities->pictureAccessGranularity.width = ANV_MB_WIDTH;
 
146
      pCapabilities->pictureAccessGranularity.height = ANV_MB_HEIGHT;
 
147
      pCapabilities->minCodedExtent.width = ANV_MB_WIDTH;
 
148
      pCapabilities->minCodedExtent.height = ANV_MB_HEIGHT;
136
149
 
137
150
      ext->fieldOffsetGranularity.x = 0;
138
151
      ext->fieldOffsetGranularity.y = 0;
141
154
      pCapabilities->stdHeaderVersion.specVersion = VK_STD_VULKAN_VIDEO_CODEC_H264_DECODE_SPEC_VERSION;
142
155
      break;
143
156
   }
 
157
   case VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR: {
 
158
      struct VkVideoDecodeH265CapabilitiesKHR *ext = (struct VkVideoDecodeH265CapabilitiesKHR *)
 
159
         vk_find_struct(pCapabilities->pNext, VIDEO_DECODE_H265_CAPABILITIES_KHR);
 
160
 
 
161
      const struct VkVideoDecodeH265ProfileInfoKHR *h265_profile =
 
162
         vk_find_struct_const(pVideoProfile->pNext,
 
163
                              VIDEO_DECODE_H265_PROFILE_INFO_KHR);
 
164
 
 
165
      /* No hardware supports the scc extension profile */
 
166
      if (h265_profile->stdProfileIdc != STD_VIDEO_H265_PROFILE_IDC_MAIN &&
 
167
          h265_profile->stdProfileIdc != STD_VIDEO_H265_PROFILE_IDC_MAIN_10 &&
 
168
          h265_profile->stdProfileIdc != STD_VIDEO_H265_PROFILE_IDC_MAIN_STILL_PICTURE &&
 
169
          h265_profile->stdProfileIdc != STD_VIDEO_H265_PROFILE_IDC_FORMAT_RANGE_EXTENSIONS)
 
170
         return VK_ERROR_VIDEO_PROFILE_OPERATION_NOT_SUPPORTED_KHR;
 
171
 
 
172
      /* Skylake only supports the main profile */
 
173
      if (h265_profile->stdProfileIdc != STD_VIDEO_H265_PROFILE_IDC_MAIN &&
 
174
          h265_profile->stdProfileIdc != STD_VIDEO_H265_PROFILE_IDC_MAIN_STILL_PICTURE &&
 
175
          pdevice->info.platform <= INTEL_PLATFORM_SKL)
 
176
         return VK_ERROR_VIDEO_PROFILE_OPERATION_NOT_SUPPORTED_KHR;
 
177
 
 
178
      /* Gfx10 and under don't support the range extension profile */
 
179
      if (h265_profile->stdProfileIdc != STD_VIDEO_H265_PROFILE_IDC_MAIN &&
 
180
          h265_profile->stdProfileIdc != STD_VIDEO_H265_PROFILE_IDC_MAIN_10 &&
 
181
          h265_profile->stdProfileIdc != STD_VIDEO_H265_PROFILE_IDC_MAIN_STILL_PICTURE &&
 
182
          pdevice->info.ver <= 10)
 
183
         return VK_ERROR_VIDEO_PROFILE_OPERATION_NOT_SUPPORTED_KHR;
 
184
 
 
185
      if (pVideoProfile->lumaBitDepth != VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR &&
 
186
          pVideoProfile->lumaBitDepth != VK_VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR)
 
187
         return VK_ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED_KHR;
 
188
 
 
189
      pCapabilities->pictureAccessGranularity.width = ANV_MAX_H265_CTB_SIZE;
 
190
      pCapabilities->pictureAccessGranularity.height = ANV_MAX_H265_CTB_SIZE;
 
191
      pCapabilities->minCodedExtent.width = ANV_MAX_H265_CTB_SIZE;
 
192
      pCapabilities->minCodedExtent.height = ANV_MAX_H265_CTB_SIZE;
 
193
      pCapabilities->maxDpbSlots = ANV_VIDEO_H265_MAX_NUM_REF_FRAME;
 
194
      pCapabilities->maxActiveReferencePictures = ANV_VIDEO_H265_HCP_NUM_REF_FRAME;
 
195
 
 
196
      ext->maxLevelIdc = STD_VIDEO_H265_LEVEL_IDC_6_2;
 
197
 
 
198
      strcpy(pCapabilities->stdHeaderVersion.extensionName, VK_STD_VULKAN_VIDEO_CODEC_H265_DECODE_EXTENSION_NAME);
 
199
      pCapabilities->stdHeaderVersion.specVersion = VK_STD_VULKAN_VIDEO_CODEC_H265_DECODE_SPEC_VERSION;
 
200
      break;
 
201
   }
144
202
   default:
145
203
      break;
146
204
   }
153
211
                                               uint32_t *pVideoFormatPropertyCount,
154
212
                                               VkVideoFormatPropertiesKHR *pVideoFormatProperties)
155
213
{
156
 
   *pVideoFormatPropertyCount = 1;
157
 
 
158
 
   if (!pVideoFormatProperties)
159
 
      return VK_SUCCESS;
160
 
 
161
 
   pVideoFormatProperties[0].format = VK_FORMAT_G8_B8R8_2PLANE_420_UNORM;
162
 
   pVideoFormatProperties[0].imageType = VK_IMAGE_TYPE_2D;
163
 
   pVideoFormatProperties[0].imageTiling = VK_IMAGE_TILING_OPTIMAL;
164
 
   pVideoFormatProperties[0].imageUsageFlags = pVideoFormatInfo->imageUsage;
165
 
   return VK_SUCCESS;
 
214
   VK_OUTARRAY_MAKE_TYPED(VkVideoFormatPropertiesKHR, out,
 
215
                          pVideoFormatProperties,
 
216
                          pVideoFormatPropertyCount);
 
217
 
 
218
   bool need_10bit = false;
 
219
   const struct VkVideoProfileListInfoKHR *prof_list = (struct VkVideoProfileListInfoKHR *)
 
220
      vk_find_struct_const(pVideoFormatInfo->pNext, VIDEO_PROFILE_LIST_INFO_KHR);
 
221
 
 
222
   if (prof_list) {
 
223
      for (unsigned i = 0; i < prof_list->profileCount; i++) {
 
224
         const VkVideoProfileInfoKHR *profile = &prof_list->pProfiles[i];
 
225
         if (profile->lumaBitDepth & VK_VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR ||
 
226
             profile->chromaBitDepth & VK_VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR)
 
227
            need_10bit = true;
 
228
      }
 
229
   }
 
230
 
 
231
   vk_outarray_append_typed(VkVideoFormatPropertiesKHR, &out, p) {
 
232
      p->format = VK_FORMAT_G8_B8R8_2PLANE_420_UNORM;
 
233
      p->imageType = VK_IMAGE_TYPE_2D;
 
234
      p->imageTiling = VK_IMAGE_TILING_OPTIMAL;
 
235
      p->imageUsageFlags = pVideoFormatInfo->imageUsage;
 
236
   }
 
237
 
 
238
   if (need_10bit) {
 
239
      vk_outarray_append_typed(VkVideoFormatPropertiesKHR, &out, p) {
 
240
         p->format = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16;
 
241
         p->imageType = VK_IMAGE_TYPE_2D;
 
242
         p->imageTiling = VK_IMAGE_TILING_OPTIMAL;
 
243
         p->imageUsageFlags = pVideoFormatInfo->imageUsage;
 
244
      }
 
245
   }
 
246
 
 
247
   return vk_outarray_status(&out);
 
248
}
 
249
 
 
250
static uint64_t
 
251
get_h264_video_mem_size(struct anv_video_session *vid, uint32_t mem_idx)
 
252
{
 
253
   uint32_t width_in_mb =
 
254
      align(vid->vk.max_coded.width, ANV_MB_WIDTH) / ANV_MB_WIDTH;
 
255
 
 
256
   switch (mem_idx) {
 
257
   case ANV_VID_MEM_H264_INTRA_ROW_STORE:
 
258
      return width_in_mb * 64;
 
259
   case ANV_VID_MEM_H264_DEBLOCK_FILTER_ROW_STORE:
 
260
      return width_in_mb * 64 * 4;
 
261
   case ANV_VID_MEM_H264_BSD_MPC_ROW_SCRATCH:
 
262
      return width_in_mb * 64 * 2;
 
263
   case ANV_VID_MEM_H264_MPR_ROW_SCRATCH:
 
264
      return width_in_mb * 64 * 2;
 
265
   default:
 
266
      unreachable("unknown memory");
 
267
   }
 
268
}
 
269
 
 
270
static uint64_t
 
271
get_h265_video_mem_size(struct anv_video_session *vid, uint32_t mem_idx)
 
272
{
 
273
   uint32_t bit_shift =
 
274
      vid->vk.h265.profile_idc == STD_VIDEO_H265_PROFILE_IDC_MAIN_10 ? 2 : 3;
 
275
 
 
276
   /* TODO. these sizes can be determined dynamically depending on ctb sizes of each slice. */
 
277
   uint32_t width_in_ctb =
 
278
      align(vid->vk.max_coded.width, ANV_MAX_H265_CTB_SIZE) / ANV_MAX_H265_CTB_SIZE;
 
279
   uint32_t height_in_ctb =
 
280
      align(vid->vk.max_coded.height, ANV_MAX_H265_CTB_SIZE) / ANV_MAX_H265_CTB_SIZE;
 
281
   uint64_t size;
 
282
 
 
283
   switch (mem_idx) {
 
284
   case ANV_VID_MEM_H265_DEBLOCK_FILTER_ROW_STORE_LINE:
 
285
   case ANV_VID_MEM_H265_DEBLOCK_FILTER_ROW_STORE_TILE_LINE:
 
286
      size = align(vid->vk.max_coded.width, 32) >> bit_shift;
 
287
      break;
 
288
   case ANV_VID_MEM_H265_DEBLOCK_FILTER_ROW_STORE_TILE_COLUMN:
 
289
      size = align(vid->vk.max_coded.height + 6 * height_in_ctb, 32) >> bit_shift;
 
290
      break;
 
291
   case ANV_VID_MEM_H265_METADATA_LINE:
 
292
      size = (((vid->vk.max_coded.width + 15) >> 4) * 188 + width_in_ctb * 9 + 1023) >> 9;
 
293
      break;
 
294
   case ANV_VID_MEM_H265_METADATA_TILE_LINE:
 
295
      size = (((vid->vk.max_coded.width + 15) >> 4) * 172 + width_in_ctb * 9 + 1023) >> 9;
 
296
      break;
 
297
   case ANV_VID_MEM_H265_METADATA_TILE_COLUMN:
 
298
      size = (((vid->vk.max_coded.height + 15) >> 4) * 176 + height_in_ctb * 89 + 1023) >> 9;
 
299
      break;
 
300
   case ANV_VID_MEM_H265_SAO_LINE:
 
301
      size = align((vid->vk.max_coded.width >> 1) + width_in_ctb * 3, 16) >> bit_shift;
 
302
      break;
 
303
   case ANV_VID_MEM_H265_SAO_TILE_LINE:
 
304
      size = align((vid->vk.max_coded.width >> 1) + width_in_ctb * 6, 16) >> bit_shift;
 
305
      break;
 
306
   case ANV_VID_MEM_H265_SAO_TILE_COLUMN:
 
307
      size = align((vid->vk.max_coded.height >> 1) + height_in_ctb * 6, 16) >> bit_shift;
 
308
      break;
 
309
   default:
 
310
      unreachable("unknown memory");
 
311
   }
 
312
 
 
313
   return size << 6;
166
314
}
167
315
 
168
316
static void
169
317
get_h264_video_session_mem_reqs(struct anv_video_session *vid,
170
318
                                VkVideoSessionMemoryRequirementsKHR *mem_reqs,
171
 
                                uint32_t memory_types)
172
 
{
173
 
   uint32_t width_in_mb = align(vid->vk.max_coded.width, ANV_MB_WIDTH) / ANV_MB_WIDTH;
174
 
   /* intra row store is width in macroblocks * 64 */
175
 
   mem_reqs[0].memoryBindIndex = ANV_VID_MEM_H264_INTRA_ROW_STORE;
176
 
   mem_reqs[0].memoryRequirements.size = width_in_mb * 64;
177
 
   mem_reqs[0].memoryRequirements.alignment = 4096;
178
 
   mem_reqs[0].memoryRequirements.memoryTypeBits = memory_types;
179
 
 
180
 
   /* deblocking filter row store is width in macroblocks * 64 * 4*/
181
 
   mem_reqs[1].memoryBindIndex = ANV_VID_MEM_H264_DEBLOCK_FILTER_ROW_STORE;
182
 
   mem_reqs[1].memoryRequirements.size = width_in_mb * 64 * 4;
183
 
   mem_reqs[1].memoryRequirements.alignment = 4096;
184
 
   mem_reqs[1].memoryRequirements.memoryTypeBits = memory_types;
185
 
 
186
 
   /* bsd mpc row scratch is width in macroblocks * 64 * 2 */
187
 
   mem_reqs[2].memoryBindIndex = ANV_VID_MEM_H264_BSD_MPC_ROW_SCRATCH;
188
 
   mem_reqs[2].memoryRequirements.size = width_in_mb * 64 * 2;
189
 
   mem_reqs[2].memoryRequirements.alignment = 4096;
190
 
   mem_reqs[2].memoryRequirements.memoryTypeBits = memory_types;
191
 
 
192
 
   /* mpr row scratch is width in macroblocks * 64 * 2 */
193
 
   mem_reqs[3].memoryBindIndex = ANV_VID_MEM_H264_MPR_ROW_SCRATCH;
194
 
   mem_reqs[3].memoryRequirements.size = width_in_mb * 64 * 2;
195
 
   mem_reqs[3].memoryRequirements.alignment = 4096;
196
 
   mem_reqs[3].memoryRequirements.memoryTypeBits = memory_types;
 
319
                                uint32_t *pVideoSessionMemoryRequirementsCount,
 
320
                                uint32_t memory_types)
 
321
{
 
322
   VK_OUTARRAY_MAKE_TYPED(VkVideoSessionMemoryRequirementsKHR,
 
323
                          out,
 
324
                          mem_reqs,
 
325
                          pVideoSessionMemoryRequirementsCount);
 
326
 
 
327
   for (unsigned i = 0; i < ANV_VIDEO_MEM_REQS_H264; i++) {
 
328
      uint32_t bind_index = ANV_VID_MEM_H264_INTRA_ROW_STORE + i;
 
329
      uint64_t size = get_h264_video_mem_size(vid, i);
 
330
 
 
331
      vk_outarray_append_typed(VkVideoSessionMemoryRequirementsKHR, &out, p) {
 
332
         p->memoryBindIndex = bind_index;
 
333
         p->memoryRequirements.size = size;
 
334
         p->memoryRequirements.alignment = 4096;
 
335
         p->memoryRequirements.memoryTypeBits = memory_types;
 
336
      }
 
337
   }
 
338
}
 
339
 
 
340
static void
 
341
get_h265_video_session_mem_reqs(struct anv_video_session *vid,
 
342
                                VkVideoSessionMemoryRequirementsKHR *mem_reqs,
 
343
                                uint32_t *pVideoSessionMemoryRequirementsCount,
 
344
                                uint32_t memory_types)
 
345
{
 
346
   VK_OUTARRAY_MAKE_TYPED(VkVideoSessionMemoryRequirementsKHR,
 
347
                          out,
 
348
                          mem_reqs,
 
349
                          pVideoSessionMemoryRequirementsCount);
 
350
 
 
351
   for (unsigned i = 0; i < ANV_VIDEO_MEM_REQS_H265; i++) {
 
352
      uint32_t bind_index =
 
353
         ANV_VID_MEM_H265_DEBLOCK_FILTER_ROW_STORE_LINE + i;
 
354
      uint64_t size = get_h265_video_mem_size(vid, i);
 
355
 
 
356
      vk_outarray_append_typed(VkVideoSessionMemoryRequirementsKHR, &out, p) {
 
357
         p->memoryBindIndex = bind_index;
 
358
         p->memoryRequirements.size = size;
 
359
         p->memoryRequirements.alignment = 4096;
 
360
         p->memoryRequirements.memoryTypeBits = memory_types;
 
361
      }
 
362
   }
197
363
}
198
364
 
199
365
VkResult
205
371
   ANV_FROM_HANDLE(anv_device, device, _device);
206
372
   ANV_FROM_HANDLE(anv_video_session, vid, videoSession);
207
373
 
208
 
   switch (vid->vk.op) {
209
 
   case VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR:
210
 
      *pVideoSessionMemoryRequirementsCount = ANV_VIDEO_MEM_REQS_H264;
211
 
      break;
212
 
   default:
213
 
      unreachable("unknown codec");
214
 
   }
215
 
   if (!mem_reqs)
216
 
      return VK_SUCCESS;
217
 
 
218
374
   uint32_t memory_types = (1ull << device->physical->memory.type_count) - 1;
219
375
   switch (vid->vk.op) {
220
376
   case VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR:
221
 
      get_h264_video_session_mem_reqs(vid, mem_reqs, memory_types);
 
377
      get_h264_video_session_mem_reqs(vid,
 
378
                                      mem_reqs,
 
379
                                      pVideoSessionMemoryRequirementsCount,
 
380
                                      memory_types);
 
381
      break;
 
382
   case VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR:
 
383
      get_h265_video_session_mem_reqs(vid,
 
384
                                      mem_reqs,
 
385
                                      pVideoSessionMemoryRequirementsCount,
 
386
                                      memory_types);
222
387
      break;
223
388
   default:
224
389
      unreachable("unknown codec");
253
418
{
254
419
   ANV_FROM_HANDLE(anv_video_session, vid, videoSession);
255
420
 
256
 
   assert(bind_mem_count == 4);
257
421
   switch (vid->vk.op) {
258
422
   case VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR:
 
423
   case VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR:
259
424
      for (unsigned i = 0; i < bind_mem_count; i++) {
260
425
         copy_bind(&vid->vid_mem[bind_mem[i].memoryBindIndex], &bind_mem[i]);
261
426
      }