RepoMirrors/ffmpeg
1
0
Fork 0
mirror of https://git.ffmpeg.org/ffmpeg.git synced 2024-12-26 09:12:33 +00:00
Code Issues Projects Releases Wiki Activity
b5c111272b
ffmpeg/libavcodec/d3d12va_encode.c
Tong Wu e783e45e29 avcodec/hw_base_encode: avoid getting FFHWBaseEncodeContext from avctx 
This patch is to make FFHWBaseEncodeContext a standalone component
and avoid getting FFHWBaseEncodeContext from avctx->priv_data.
This patch also removes some unnecessary AVCodecContext arguments.

For receive_packet call, a small wrapper is introduced.

Signed-off-by: Tong Wu <tong1.wu@intel.com>
2024-07-02 14:15:12 +02:00

1566 lines
55 KiB
C
Raw Blame History

/*
* Direct3D 12 HW acceleration video encoder
*
* Copyright (c) 2024 Intel Corporation
*
* 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/avassert.h"
#include "libavutil/common.h"
#include "libavutil/internal.h"
#include "libavutil/log.h"
#include "libavutil/mem.h"
#include "libavutil/pixdesc.h"
#include "libavutil/hwcontext_d3d12va_internal.h"
#include "libavutil/hwcontext_d3d12va.h"
#include "avcodec.h"
#include "d3d12va_encode.h"
#include "encode.h"
const AVCodecHWConfigInternal *const ff_d3d12va_encode_hw_configs[] = {
HW_CONFIG_ENCODER_FRAMES(D3D12, D3D12VA),
NULL,
};
static int d3d12va_fence_completion(AVD3D12VASyncContext *psync_ctx)
{
uint64_t completion = ID3D12Fence_GetCompletedValue(psync_ctx->fence);
if (completion < psync_ctx->fence_value) {
if (FAILED(ID3D12Fence_SetEventOnCompletion(psync_ctx->fence, psync_ctx->fence_value, psync_ctx->event)))
return AVERROR(EINVAL);
WaitForSingleObjectEx(psync_ctx->event, INFINITE, FALSE);
}
return 0;
}
static int d3d12va_sync_with_gpu(AVCodecContext *avctx)
{
D3D12VAEncodeContext *ctx = avctx->priv_data;
DX_CHECK(ID3D12CommandQueue_Signal(ctx->command_queue, ctx->sync_ctx.fence, ++ctx->sync_ctx.fence_value));
return d3d12va_fence_completion(&ctx->sync_ctx);
fail:
return AVERROR(EINVAL);
}
typedef struct CommandAllocator {
ID3D12CommandAllocator *command_allocator;
uint64_t fence_value;
} CommandAllocator;
static int d3d12va_get_valid_command_allocator(AVCodecContext *avctx, ID3D12CommandAllocator **ppAllocator)
{
HRESULT hr;
D3D12VAEncodeContext *ctx = avctx->priv_data;
CommandAllocator allocator;
if (av_fifo_peek(ctx->allocator_queue, &allocator, 1, 0) >= 0) {
uint64_t completion = ID3D12Fence_GetCompletedValue(ctx->sync_ctx.fence);
if (completion >= allocator.fence_value) {
*ppAllocator = allocator.command_allocator;
av_fifo_read(ctx->allocator_queue, &allocator, 1);
return 0;
}
}
hr = ID3D12Device_CreateCommandAllocator(ctx->hwctx->device, D3D12_COMMAND_LIST_TYPE_VIDEO_ENCODE,
&IID_ID3D12CommandAllocator, (void **)ppAllocator);
if (FAILED(hr)) {
av_log(avctx, AV_LOG_ERROR, "Failed to create a new command allocator!\n");
return AVERROR(EINVAL);
}
return 0;
}
static int d3d12va_discard_command_allocator(AVCodecContext *avctx, ID3D12CommandAllocator *pAllocator, uint64_t fence_value)
{
D3D12VAEncodeContext *ctx = avctx->priv_data;
CommandAllocator allocator = {
.command_allocator = pAllocator,
.fence_value = fence_value,
};
av_fifo_write(ctx->allocator_queue, &allocator, 1);
return 0;
}
static int d3d12va_encode_wait(AVCodecContext *avctx,
D3D12VAEncodePicture *pic)
{
D3D12VAEncodeContext *ctx = avctx->priv_data;
FFHWBaseEncodePicture *base_pic = &pic->base;
uint64_t completion;
av_assert0(base_pic->encode_issued);
if (base_pic->encode_complete) {
// Already waited for this picture.
return 0;
}
completion = ID3D12Fence_GetCompletedValue(ctx->sync_ctx.fence);
if (completion < pic->fence_value) {
if (FAILED(ID3D12Fence_SetEventOnCompletion(ctx->sync_ctx.fence, pic->fence_value,
ctx->sync_ctx.event)))
return AVERROR(EINVAL);
WaitForSingleObjectEx(ctx->sync_ctx.event, INFINITE, FALSE);
}
av_log(avctx, AV_LOG_DEBUG, "Sync to pic %"PRId64"/%"PRId64" "
"(input surface %p).\n", base_pic->display_order,
base_pic->encode_order, pic->input_surface->texture);
av_frame_free(&base_pic->input_image);
base_pic->encode_complete = 1;
return 0;
}
static int d3d12va_encode_create_metadata_buffers(AVCodecContext *avctx,
D3D12VAEncodePicture *pic)
{
D3D12VAEncodeContext *ctx = avctx->priv_data;
int width = sizeof(D3D12_VIDEO_ENCODER_OUTPUT_METADATA) + sizeof(D3D12_VIDEO_ENCODER_FRAME_SUBREGION_METADATA);
D3D12_HEAP_PROPERTIES encoded_meta_props = { .Type = D3D12_HEAP_TYPE_DEFAULT }, resolved_meta_props;
D3D12_HEAP_TYPE resolved_heap_type = D3D12_HEAP_TYPE_READBACK;
HRESULT hr;
D3D12_RESOURCE_DESC meta_desc = {
.Dimension = D3D12_RESOURCE_DIMENSION_BUFFER,
.Alignment = 0,
.Width = ctx->req.MaxEncoderOutputMetadataBufferSize,
.Height = 1,
.DepthOrArraySize = 1,
.MipLevels = 1,
.Format = DXGI_FORMAT_UNKNOWN,
.SampleDesc = { .Count = 1, .Quality = 0 },
.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR,
.Flags = D3D12_RESOURCE_FLAG_NONE,
};
hr = ID3D12Device_CreateCommittedResource(ctx->hwctx->device, &encoded_meta_props, D3D12_HEAP_FLAG_NONE,
&meta_desc, D3D12_RESOURCE_STATE_COMMON, NULL,
&IID_ID3D12Resource, (void **)&pic->encoded_metadata);
if (FAILED(hr)) {
av_log(avctx, AV_LOG_ERROR, "Failed to create metadata buffer.\n");
return AVERROR_UNKNOWN;
}
ctx->hwctx->device->lpVtbl->GetCustomHeapProperties(ctx->hwctx->device, &resolved_meta_props, 0, resolved_heap_type);
meta_desc.Width = width;
hr = ID3D12Device_CreateCommittedResource(ctx->hwctx->device, &resolved_meta_props, D3D12_HEAP_FLAG_NONE,
&meta_desc, D3D12_RESOURCE_STATE_COMMON, NULL,
&IID_ID3D12Resource, (void **)&pic->resolved_metadata);
if (FAILED(hr)) {
av_log(avctx, AV_LOG_ERROR, "Failed to create output metadata buffer.\n");
return AVERROR_UNKNOWN;
}
return 0;
}
static int d3d12va_encode_issue(AVCodecContext *avctx,
const FFHWBaseEncodePicture *base_pic)
{
FFHWBaseEncodeContext *base_ctx = avctx->priv_data;
D3D12VAEncodeContext *ctx = avctx->priv_data;
AVD3D12VAFramesContext *frames_hwctx = base_ctx->input_frames->hwctx;
D3D12VAEncodePicture *pic = (D3D12VAEncodePicture *)base_pic;
int err, i, j;
HRESULT hr;
char data[MAX_PARAM_BUFFER_SIZE];
void *ptr;
size_t bit_len;
ID3D12CommandAllocator *command_allocator = NULL;
ID3D12VideoEncodeCommandList2 *cmd_list = ctx->command_list;
D3D12_RESOURCE_BARRIER barriers[32] = { 0 };
D3D12_VIDEO_ENCODE_REFERENCE_FRAMES d3d12_refs = { 0 };
D3D12_VIDEO_ENCODER_ENCODEFRAME_INPUT_ARGUMENTS input_args = {
.SequenceControlDesc = {
.Flags = D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_FLAG_NONE,
.IntraRefreshConfig = { 0 },
.RateControl = ctx->rc,
.PictureTargetResolution = ctx->resolution,
.SelectedLayoutMode = D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE_FULL_FRAME,
.FrameSubregionsLayoutData = { 0 },
.CodecGopSequence = ctx->gop,
},
.pInputFrame = pic->input_surface->texture,
.InputFrameSubresource = 0,
};
D3D12_VIDEO_ENCODER_ENCODEFRAME_OUTPUT_ARGUMENTS output_args = { 0 };
D3D12_VIDEO_ENCODER_RESOLVE_METADATA_INPUT_ARGUMENTS input_metadata = {
.EncoderCodec = ctx->codec->d3d12_codec,
.EncoderProfile = ctx->profile->d3d12_profile,
.EncoderInputFormat = frames_hwctx->format,
.EncodedPictureEffectiveResolution = ctx->resolution,
};
D3D12_VIDEO_ENCODER_RESOLVE_METADATA_OUTPUT_ARGUMENTS output_metadata = { 0 };
memset(data, 0, sizeof(data));
av_log(avctx, AV_LOG_DEBUG, "Issuing encode for pic %"PRId64"/%"PRId64" "
"as type %s.\n", base_pic->display_order, base_pic->encode_order,
ff_hw_base_encode_get_pictype_name(base_pic->type));
if (base_pic->nb_refs[0] == 0 && base_pic->nb_refs[1] == 0) {
av_log(avctx, AV_LOG_DEBUG, "No reference pictures.\n");
} else {
av_log(avctx, AV_LOG_DEBUG, "L0 refers to");
for (i = 0; i < base_pic->nb_refs[0]; i++) {
av_log(avctx, AV_LOG_DEBUG, " %"PRId64"/%"PRId64,
base_pic->refs[0][i]->display_order, base_pic->refs[0][i]->encode_order);
}
av_log(avctx, AV_LOG_DEBUG, ".\n");
if (base_pic->nb_refs[1]) {
av_log(avctx, AV_LOG_DEBUG, "L1 refers to");
for (i = 0; i < base_pic->nb_refs[1]; i++) {
av_log(avctx, AV_LOG_DEBUG, " %"PRId64"/%"PRId64,
base_pic->refs[1][i]->display_order, base_pic->refs[1][i]->encode_order);
}
av_log(avctx, AV_LOG_DEBUG, ".\n");
}
}
av_assert0(!base_pic->encode_issued);
for (i = 0; i < base_pic->nb_refs[0]; i++) {
av_assert0(base_pic->refs[0][i]);
av_assert0(base_pic->refs[0][i]->encode_issued);
}
for (i = 0; i < base_pic->nb_refs[1]; i++) {
av_assert0(base_pic->refs[1][i]);
av_assert0(base_pic->refs[1][i]->encode_issued);
}
av_log(avctx, AV_LOG_DEBUG, "Input surface is %p.\n", pic->input_surface->texture);
err = av_hwframe_get_buffer(base_ctx->recon_frames_ref, base_pic->recon_image, 0);
if (err < 0) {
err = AVERROR(ENOMEM);
goto fail;
}
pic->recon_surface = (AVD3D12VAFrame *)base_pic->recon_image->data[0];
av_log(avctx, AV_LOG_DEBUG, "Recon surface is %p.\n",
pic->recon_surface->texture);
pic->output_buffer_ref = av_buffer_pool_get(ctx->output_buffer_pool);
if (!pic->output_buffer_ref) {
err = AVERROR(ENOMEM);
goto fail;
}
pic->output_buffer = (ID3D12Resource *)pic->output_buffer_ref->data;
av_log(avctx, AV_LOG_DEBUG, "Output buffer is %p.\n",
pic->output_buffer);
err = d3d12va_encode_create_metadata_buffers(avctx, pic);
if (err < 0)
goto fail;
if (ctx->codec->init_picture_params) {
err = ctx->codec->init_picture_params(avctx, pic);
if (err < 0) {
av_log(avctx, AV_LOG_ERROR, "Failed to initialise picture "
"parameters: %d.\n", err);
goto fail;
}
}
if (base_pic->type == FF_HW_PICTURE_TYPE_IDR) {
if (ctx->codec->write_sequence_header) {
bit_len = 8 * sizeof(data);
err = ctx->codec->write_sequence_header(avctx, data, &bit_len);
if (err < 0) {
av_log(avctx, AV_LOG_ERROR, "Failed to write per-sequence "
"header: %d.\n", err);
goto fail;
}
}
pic->header_size = (int)bit_len / 8;
pic->header_size = pic->header_size % ctx->req.CompressedBitstreamBufferAccessAlignment ?
FFALIGN(pic->header_size, ctx->req.CompressedBitstreamBufferAccessAlignment) :
pic->header_size;
hr = ID3D12Resource_Map(pic->output_buffer, 0, NULL, (void **)&ptr);
if (FAILED(hr)) {
err = AVERROR_UNKNOWN;
goto fail;
}
memcpy(ptr, data, pic->header_size);
ID3D12Resource_Unmap(pic->output_buffer, 0, NULL);
}
d3d12_refs.NumTexture2Ds = base_pic->nb_refs[0] + base_pic->nb_refs[1];
if (d3d12_refs.NumTexture2Ds) {
d3d12_refs.ppTexture2Ds = av_calloc(d3d12_refs.NumTexture2Ds,
sizeof(*d3d12_refs.ppTexture2Ds));
if (!d3d12_refs.ppTexture2Ds) {
err = AVERROR(ENOMEM);
goto fail;
}
i = 0;
for (j = 0; j < base_pic->nb_refs[0]; j++)
d3d12_refs.ppTexture2Ds[i++] = ((D3D12VAEncodePicture *)base_pic->refs[0][j])->recon_surface->texture;
for (j = 0; j < base_pic->nb_refs[1]; j++)
d3d12_refs.ppTexture2Ds[i++] = ((D3D12VAEncodePicture *)base_pic->refs[1][j])->recon_surface->texture;
}
input_args.PictureControlDesc.IntraRefreshFrameIndex = 0;
if (base_pic->is_reference)
input_args.PictureControlDesc.Flags |= D3D12_VIDEO_ENCODER_PICTURE_CONTROL_FLAG_USED_AS_REFERENCE_PICTURE;
input_args.PictureControlDesc.PictureControlCodecData = pic->pic_ctl;
input_args.PictureControlDesc.ReferenceFrames = d3d12_refs;
input_args.CurrentFrameBitstreamMetadataSize = pic->header_size;
output_args.Bitstream.pBuffer = pic->output_buffer;
output_args.Bitstream.FrameStartOffset = pic->header_size;
output_args.ReconstructedPicture.pReconstructedPicture = pic->recon_surface->texture;
output_args.ReconstructedPicture.ReconstructedPictureSubresource = 0;
output_args.EncoderOutputMetadata.pBuffer = pic->encoded_metadata;
output_args.EncoderOutputMetadata.Offset = 0;
input_metadata.HWLayoutMetadata.pBuffer = pic->encoded_metadata;
input_metadata.HWLayoutMetadata.Offset = 0;
output_metadata.ResolvedLayoutMetadata.pBuffer = pic->resolved_metadata;
output_metadata.ResolvedLayoutMetadata.Offset = 0;
err = d3d12va_get_valid_command_allocator(avctx, &command_allocator);
if (err < 0)
goto fail;
hr = ID3D12CommandAllocator_Reset(command_allocator);
if (FAILED(hr)) {
err = AVERROR_UNKNOWN;
goto fail;
}
hr = ID3D12VideoEncodeCommandList2_Reset(cmd_list, command_allocator);
if (FAILED(hr)) {
err = AVERROR_UNKNOWN;
goto fail;
}
#define TRANSITION_BARRIER(res, before, after) \
(D3D12_RESOURCE_BARRIER) { \
.Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION, \
.Flags = D3D12_RESOURCE_BARRIER_FLAG_NONE, \
.Transition = { \
.pResource = res, \
.Subresource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES, \
.StateBefore = before, \
.StateAfter = after, \
}, \
}
barriers[0] = TRANSITION_BARRIER(pic->input_surface->texture,
D3D12_RESOURCE_STATE_COMMON,
D3D12_RESOURCE_STATE_VIDEO_ENCODE_READ);
barriers[1] = TRANSITION_BARRIER(pic->output_buffer,
D3D12_RESOURCE_STATE_COMMON,
D3D12_RESOURCE_STATE_VIDEO_ENCODE_WRITE);
barriers[2] = TRANSITION_BARRIER(pic->recon_surface->texture,
D3D12_RESOURCE_STATE_COMMON,
D3D12_RESOURCE_STATE_VIDEO_ENCODE_WRITE);
barriers[3] = TRANSITION_BARRIER(pic->encoded_metadata,
D3D12_RESOURCE_STATE_COMMON,
D3D12_RESOURCE_STATE_VIDEO_ENCODE_WRITE);
barriers[4] = TRANSITION_BARRIER(pic->resolved_metadata,
D3D12_RESOURCE_STATE_COMMON,
D3D12_RESOURCE_STATE_VIDEO_ENCODE_WRITE);
ID3D12VideoEncodeCommandList2_ResourceBarrier(cmd_list, 5, barriers);
if (d3d12_refs.NumTexture2Ds) {
D3D12_RESOURCE_BARRIER refs_barriers[3];
for (i = 0; i < d3d12_refs.NumTexture2Ds; i++)
refs_barriers[i] = TRANSITION_BARRIER(d3d12_refs.ppTexture2Ds[i],
D3D12_RESOURCE_STATE_COMMON,
D3D12_RESOURCE_STATE_VIDEO_ENCODE_READ);
ID3D12VideoEncodeCommandList2_ResourceBarrier(cmd_list, d3d12_refs.NumTexture2Ds,
refs_barriers);
}
ID3D12VideoEncodeCommandList2_EncodeFrame(cmd_list, ctx->encoder, ctx->encoder_heap,
&input_args, &output_args);
barriers[3] = TRANSITION_BARRIER(pic->encoded_metadata,
D3D12_RESOURCE_STATE_VIDEO_ENCODE_WRITE,
D3D12_RESOURCE_STATE_VIDEO_ENCODE_READ);
ID3D12VideoEncodeCommandList2_ResourceBarrier(cmd_list, 1, &barriers[3]);
ID3D12VideoEncodeCommandList2_ResolveEncoderOutputMetadata(cmd_list, &input_metadata, &output_metadata);
if (d3d12_refs.NumTexture2Ds) {
D3D12_RESOURCE_BARRIER refs_barriers[3];
for (i = 0; i < d3d12_refs.NumTexture2Ds; i++)
refs_barriers[i] = TRANSITION_BARRIER(d3d12_refs.ppTexture2Ds[i],
D3D12_RESOURCE_STATE_VIDEO_ENCODE_READ,
D3D12_RESOURCE_STATE_COMMON);
ID3D12VideoEncodeCommandList2_ResourceBarrier(cmd_list, d3d12_refs.NumTexture2Ds,
refs_barriers);
}
barriers[0] = TRANSITION_BARRIER(pic->input_surface->texture,
D3D12_RESOURCE_STATE_VIDEO_ENCODE_READ,
D3D12_RESOURCE_STATE_COMMON);
barriers[1] = TRANSITION_BARRIER(pic->output_buffer,
D3D12_RESOURCE_STATE_VIDEO_ENCODE_WRITE,
D3D12_RESOURCE_STATE_COMMON);
barriers[2] = TRANSITION_BARRIER(pic->recon_surface->texture,
D3D12_RESOURCE_STATE_VIDEO_ENCODE_WRITE,
D3D12_RESOURCE_STATE_COMMON);
barriers[3] = TRANSITION_BARRIER(pic->encoded_metadata,
D3D12_RESOURCE_STATE_VIDEO_ENCODE_READ,
D3D12_RESOURCE_STATE_COMMON);
barriers[4] = TRANSITION_BARRIER(pic->resolved_metadata,
D3D12_RESOURCE_STATE_VIDEO_ENCODE_WRITE,
D3D12_RESOURCE_STATE_COMMON);
ID3D12VideoEncodeCommandList2_ResourceBarrier(cmd_list, 5, barriers);
hr = ID3D12VideoEncodeCommandList2_Close(cmd_list);
if (FAILED(hr)) {
err = AVERROR_UNKNOWN;
goto fail;
}
hr = ID3D12CommandQueue_Wait(ctx->command_queue, pic->input_surface->sync_ctx.fence,
pic->input_surface->sync_ctx.fence_value);
if (FAILED(hr)) {
err = AVERROR_UNKNOWN;
goto fail;
}
ID3D12CommandQueue_ExecuteCommandLists(ctx->command_queue, 1, (ID3D12CommandList **)&ctx->command_list);
hr = ID3D12CommandQueue_Signal(ctx->command_queue, pic->input_surface->sync_ctx.fence,
++pic->input_surface->sync_ctx.fence_value);
if (FAILED(hr)) {
err = AVERROR_UNKNOWN;
goto fail;
}
hr = ID3D12CommandQueue_Signal(ctx->command_queue, ctx->sync_ctx.fence, ++ctx->sync_ctx.fence_value);
if (FAILED(hr)) {
err = AVERROR_UNKNOWN;
goto fail;
}
err = d3d12va_discard_command_allocator(avctx, command_allocator, ctx->sync_ctx.fence_value);
if (err < 0)
goto fail;
pic->fence_value = ctx->sync_ctx.fence_value;
if (d3d12_refs.ppTexture2Ds)
av_freep(&d3d12_refs.ppTexture2Ds);
return 0;
fail:
if (command_allocator)
d3d12va_discard_command_allocator(avctx, command_allocator, ctx->sync_ctx.fence_value);
if (d3d12_refs.ppTexture2Ds)
av_freep(&d3d12_refs.ppTexture2Ds);
if (ctx->codec->free_picture_params)
ctx->codec->free_picture_params(pic);
av_buffer_unref(&pic->output_buffer_ref);
pic->output_buffer = NULL;
D3D12_OBJECT_RELEASE(pic->encoded_metadata);
D3D12_OBJECT_RELEASE(pic->resolved_metadata);
return err;
}
static int d3d12va_encode_discard(AVCodecContext *avctx,
D3D12VAEncodePicture *pic)
{
FFHWBaseEncodePicture *base_pic = &pic->base;
d3d12va_encode_wait(avctx, pic);
if (pic->output_buffer_ref) {
av_log(avctx, AV_LOG_DEBUG, "Discard output for pic "
"%"PRId64"/%"PRId64".\n",
base_pic->display_order, base_pic->encode_order);
av_buffer_unref(&pic->output_buffer_ref);
pic->output_buffer = NULL;
}
D3D12_OBJECT_RELEASE(pic->encoded_metadata);
D3D12_OBJECT_RELEASE(pic->resolved_metadata);
return 0;
}
static int d3d12va_encode_free_rc_params(AVCodecContext *avctx)
{
D3D12VAEncodeContext *ctx = avctx->priv_data;
switch (ctx->rc.Mode)
{
case D3D12_VIDEO_ENCODER_RATE_CONTROL_MODE_CQP:
av_freep(&ctx->rc.ConfigParams.pConfiguration_CQP);
break;
case D3D12_VIDEO_ENCODER_RATE_CONTROL_MODE_CBR:
av_freep(&ctx->rc.ConfigParams.pConfiguration_CBR);
break;
case D3D12_VIDEO_ENCODER_RATE_CONTROL_MODE_VBR:
av_freep(&ctx->rc.ConfigParams.pConfiguration_VBR);
break;
case D3D12_VIDEO_ENCODER_RATE_CONTROL_MODE_QVBR:
av_freep(&ctx->rc.ConfigParams.pConfiguration_QVBR);
break;
default:
break;
}
return 0;
}
static FFHWBaseEncodePicture *d3d12va_encode_alloc(AVCodecContext *avctx,
const AVFrame *frame)
{
D3D12VAEncodeContext *ctx = avctx->priv_data;
D3D12VAEncodePicture *pic;
pic = av_mallocz(sizeof(*pic));
if (!pic)
return NULL;
if (ctx->codec->picture_priv_data_size > 0) {
pic->base.priv_data = av_mallocz(ctx->codec->picture_priv_data_size);
if (!pic->base.priv_data) {
av_freep(&pic);
return NULL;
}
}
pic->input_surface = (AVD3D12VAFrame *)frame->data[0];
return &pic->base;
}
static int d3d12va_encode_free(AVCodecContext *avctx,
FFHWBaseEncodePicture *base_pic)
{
D3D12VAEncodeContext *ctx = avctx->priv_data;
D3D12VAEncodePicture *pic = (D3D12VAEncodePicture *)base_pic;
if (base_pic->encode_issued)
d3d12va_encode_discard(avctx, pic);
if (ctx->codec->free_picture_params)
ctx->codec->free_picture_params(pic);
ff_hw_base_encode_free(base_pic);
av_free(pic);
return 0;
}
static int d3d12va_encode_get_buffer_size(AVCodecContext *avctx,
D3D12VAEncodePicture *pic, size_t *size)
{
D3D12_VIDEO_ENCODER_OUTPUT_METADATA *meta = NULL;
uint8_t *data;
HRESULT hr;
int err;
hr = ID3D12Resource_Map(pic->resolved_metadata, 0, NULL, (void **)&data);
if (FAILED(hr)) {
err = AVERROR_UNKNOWN;
return err;
}
meta = (D3D12_VIDEO_ENCODER_OUTPUT_METADATA *)data;
if (meta->EncodeErrorFlags != D3D12_VIDEO_ENCODER_ENCODE_ERROR_FLAG_NO_ERROR) {
av_log(avctx, AV_LOG_ERROR, "Encode failed %"PRIu64"\n", meta->EncodeErrorFlags);
err = AVERROR(EINVAL);
return err;
}
if (meta->EncodedBitstreamWrittenBytesCount == 0) {
av_log(avctx, AV_LOG_ERROR, "No bytes were written to encoded bitstream\n");
err = AVERROR(EINVAL);
return err;
}
*size = meta->EncodedBitstreamWrittenBytesCount;
ID3D12Resource_Unmap(pic->resolved_metadata, 0, NULL);
return 0;
}
static int d3d12va_encode_get_coded_data(AVCodecContext *avctx,
D3D12VAEncodePicture *pic, AVPacket *pkt)
{
int err;
uint8_t *ptr, *mapped_data;
size_t total_size = 0;
HRESULT hr;
err = d3d12va_encode_get_buffer_size(avctx, pic, &total_size);
if (err < 0)
goto end;
total_size += pic->header_size;
av_log(avctx, AV_LOG_DEBUG, "Output buffer size %"PRId64"\n", total_size);
hr = ID3D12Resource_Map(pic->output_buffer, 0, NULL, (void **)&mapped_data);
if (FAILED(hr)) {
err = AVERROR_UNKNOWN;
goto end;
}
err = ff_get_encode_buffer(avctx, pkt, total_size, 0);
if (err < 0)
goto end;
ptr = pkt->data;
memcpy(ptr, mapped_data, total_size);
ID3D12Resource_Unmap(pic->output_buffer, 0, NULL);
end:
av_buffer_unref(&pic->output_buffer_ref);
pic->output_buffer = NULL;
return err;
}
static int d3d12va_encode_output(AVCodecContext *avctx,
const FFHWBaseEncodePicture *base_pic, AVPacket *pkt)
{
FFHWBaseEncodeContext *base_ctx = avctx->priv_data;
D3D12VAEncodePicture *pic = (D3D12VAEncodePicture *)base_pic;
AVPacket *pkt_ptr = pkt;
int err;
err = d3d12va_encode_wait(avctx, pic);
if (err < 0)
return err;
err = d3d12va_encode_get_coded_data(avctx, pic, pkt);
if (err < 0)
return err;
av_log(avctx, AV_LOG_DEBUG, "Output read for pic %"PRId64"/%"PRId64".\n",
base_pic->display_order, base_pic->encode_order);
ff_hw_base_encode_set_output_property(base_ctx, avctx, (FFHWBaseEncodePicture *)base_pic,
pkt_ptr, 0);
return 0;
}
static int d3d12va_encode_set_profile(AVCodecContext *avctx)
{
FFHWBaseEncodeContext *base_ctx = avctx->priv_data;
D3D12VAEncodeContext *ctx = avctx->priv_data;
const D3D12VAEncodeProfile *profile;
const AVPixFmtDescriptor *desc;
int i, depth;
desc = av_pix_fmt_desc_get(base_ctx->input_frames->sw_format);
if (!desc) {
av_log(avctx, AV_LOG_ERROR, "Invalid input pixfmt (%d).\n",
base_ctx->input_frames->sw_format);
return AVERROR(EINVAL);
}
depth = desc->comp[0].depth;
for (i = 1; i < desc->nb_components; i++) {
if (desc->comp[i].depth != depth) {
av_log(avctx, AV_LOG_ERROR, "Invalid input pixfmt (%s).\n",
desc->name);
return AVERROR(EINVAL);
}
}
av_log(avctx, AV_LOG_VERBOSE, "Input surface format is %s.\n",
desc->name);
av_assert0(ctx->codec->profiles);
for (i = 0; (ctx->codec->profiles[i].av_profile !=
AV_PROFILE_UNKNOWN); i++) {
profile = &ctx->codec->profiles[i];
if (depth != profile->depth ||
desc->nb_components != profile->nb_components)
continue;
if (desc->nb_components > 1 &&
(desc->log2_chroma_w != profile->log2_chroma_w ||
desc->log2_chroma_h != profile->log2_chroma_h))
continue;
if (avctx->profile != profile->av_profile &&
avctx->profile != AV_PROFILE_UNKNOWN)
continue;
ctx->profile = profile;
break;
}
if (!ctx->profile) {
av_log(avctx, AV_LOG_ERROR, "No usable encoding profile found.\n");
return AVERROR(ENOSYS);
}
avctx->profile = profile->av_profile;
return 0;
}
static const D3D12VAEncodeRCMode d3d12va_encode_rc_modes[] = {
// Bitrate Quality
// | Maxrate | HRD/VBV
{ 0 }, // | | | |
{ RC_MODE_CQP, "CQP", 0, 0, 1, 0, D3D12_VIDEO_ENCODER_RATE_CONTROL_MODE_CQP },
{ RC_MODE_CBR, "CBR", 1, 0, 0, 1, D3D12_VIDEO_ENCODER_RATE_CONTROL_MODE_CBR },
{ RC_MODE_VBR, "VBR", 1, 1, 0, 1, D3D12_VIDEO_ENCODER_RATE_CONTROL_MODE_VBR },
{ RC_MODE_QVBR, "QVBR", 1, 1, 1, 1, D3D12_VIDEO_ENCODER_RATE_CONTROL_MODE_QVBR },
};
static int check_rate_control_support(AVCodecContext *avctx, const D3D12VAEncodeRCMode *rc_mode)
{
HRESULT hr;
D3D12VAEncodeContext *ctx = avctx->priv_data;
D3D12_FEATURE_DATA_VIDEO_ENCODER_RATE_CONTROL_MODE d3d12_rc_mode = {
.Codec = ctx->codec->d3d12_codec,
};
if (!rc_mode->d3d12_mode)
return 0;
d3d12_rc_mode.IsSupported = 0;
d3d12_rc_mode.RateControlMode = rc_mode->d3d12_mode;
hr = ID3D12VideoDevice3_CheckFeatureSupport(ctx->video_device3,
D3D12_FEATURE_VIDEO_ENCODER_RATE_CONTROL_MODE,
&d3d12_rc_mode, sizeof(d3d12_rc_mode));
if (FAILED(hr)) {
av_log(avctx, AV_LOG_ERROR, "Failed to check rate control support.\n");
return 0;
}
return d3d12_rc_mode.IsSupported;
}
static int d3d12va_encode_init_rate_control(AVCodecContext *avctx)
{
D3D12VAEncodeContext *ctx = avctx->priv_data;
int64_t rc_target_bitrate;
int64_t rc_peak_bitrate;
int rc_quality;
int64_t hrd_buffer_size;
int64_t hrd_initial_buffer_fullness;
int fr_num, fr_den;
const D3D12VAEncodeRCMode *rc_mode;
// Rate control mode selection:
// * If the user has set a mode explicitly with the rc_mode option,
// use it and fail if it is not available.
// * If an explicit QP option has been set, use CQP.
// * If the codec is CQ-only, use CQP.
// * If the QSCALE avcodec option is set, use CQP.
// * If bitrate and quality are both set, try QVBR.
// * If quality is set, try CQP.
// * If bitrate and maxrate are set and have the same value, try CBR.
// * If a bitrate is set, try VBR, then CBR.
// * If no bitrate is set, try CQP.
#define TRY_RC_MODE(mode, fail) do { \
rc_mode = &d3d12va_encode_rc_modes[mode]; \
if (!(rc_mode->d3d12_mode && check_rate_control_support(avctx, rc_mode))) { \
if (fail) { \
av_log(avctx, AV_LOG_ERROR, "Driver does not support %s " \
"RC mode.\n", rc_mode->name); \
return AVERROR(EINVAL); \
} \
av_log(avctx, AV_LOG_DEBUG, "Driver does not support %s " \
"RC mode.\n", rc_mode->name); \
rc_mode = NULL; \
} else { \
goto rc_mode_found; \
} \
} while (0)
if (ctx->explicit_rc_mode)
TRY_RC_MODE(ctx->explicit_rc_mode, 1);
if (ctx->explicit_qp)
TRY_RC_MODE(RC_MODE_CQP, 1);
if (ctx->codec->flags & FF_HW_FLAG_CONSTANT_QUALITY_ONLY)
TRY_RC_MODE(RC_MODE_CQP, 1);
if (avctx->flags & AV_CODEC_FLAG_QSCALE)
TRY_RC_MODE(RC_MODE_CQP, 1);
if (avctx->bit_rate > 0 && avctx->global_quality > 0)
TRY_RC_MODE(RC_MODE_QVBR, 0);
if (avctx->global_quality > 0) {
TRY_RC_MODE(RC_MODE_CQP, 0);
}
if (avctx->bit_rate > 0 && avctx->rc_max_rate == avctx->bit_rate)
TRY_RC_MODE(RC_MODE_CBR, 0);
if (avctx->bit_rate > 0) {
TRY_RC_MODE(RC_MODE_VBR, 0);
TRY_RC_MODE(RC_MODE_CBR, 0);
} else {
TRY_RC_MODE(RC_MODE_CQP, 0);
}
av_log(avctx, AV_LOG_ERROR, "Driver does not support any "
"RC mode compatible with selected options.\n");
return AVERROR(EINVAL);
rc_mode_found:
if (rc_mode->bitrate) {
if (avctx->bit_rate <= 0) {
av_log(avctx, AV_LOG_ERROR, "Bitrate must be set for %s "
"RC mode.\n", rc_mode->name);
return AVERROR(EINVAL);
}
if (rc_mode->maxrate) {
if (avctx->rc_max_rate > 0) {
if (avctx->rc_max_rate < avctx->bit_rate) {
av_log(avctx, AV_LOG_ERROR, "Invalid bitrate settings: "
"bitrate (%"PRId64") must not be greater than "
"maxrate (%"PRId64").\n", avctx->bit_rate,
avctx->rc_max_rate);
return AVERROR(EINVAL);
}
rc_target_bitrate = avctx->bit_rate;
rc_peak_bitrate = avctx->rc_max_rate;
} else {
// We only have a target bitrate, but this mode requires
// that a maximum rate be supplied as well. Since the
// user does not want this to be a constraint, arbitrarily
// pick a maximum rate of double the target rate.
rc_target_bitrate = avctx->bit_rate;
rc_peak_bitrate = 2 * avctx->bit_rate;
}
} else {
if (avctx->rc_max_rate > avctx->bit_rate) {
av_log(avctx, AV_LOG_WARNING, "Max bitrate is ignored "
"in %s RC mode.\n", rc_mode->name);
}
rc_target_bitrate = avctx->bit_rate;
rc_peak_bitrate = 0;
}
} else {
rc_target_bitrate = 0;
rc_peak_bitrate = 0;
}
if (rc_mode->quality) {
if (ctx->explicit_qp) {
rc_quality = ctx->explicit_qp;
} else if (avctx->global_quality > 0) {
if (avctx->flags & AV_CODEC_FLAG_QSCALE)
rc_quality = avctx->global_quality / FF_QP2LAMBDA;
else
rc_quality = avctx->global_quality;
} else {
rc_quality = ctx->codec->default_quality;
av_log(avctx, AV_LOG_WARNING, "No quality level set; "
"using default (%d).\n", rc_quality);
}
} else {
rc_quality = 0;
}
if (rc_mode->hrd) {
if (avctx->rc_buffer_size)
hrd_buffer_size = avctx->rc_buffer_size;
else if (avctx->rc_max_rate > 0)
hrd_buffer_size = avctx->rc_max_rate;
else
hrd_buffer_size = avctx->bit_rate;
if (avctx->rc_initial_buffer_occupancy) {
if (avctx->rc_initial_buffer_occupancy > hrd_buffer_size) {
av_log(avctx, AV_LOG_ERROR, "Invalid RC buffer settings: "
"must have initial buffer size (%d) <= "
"buffer size (%"PRId64").\n",
avctx->rc_initial_buffer_occupancy, hrd_buffer_size);
return AVERROR(EINVAL);
}
hrd_initial_buffer_fullness = avctx->rc_initial_buffer_occupancy;
} else {
hrd_initial_buffer_fullness = hrd_buffer_size * 3 / 4;
}
} else {
if (avctx->rc_buffer_size || avctx->rc_initial_buffer_occupancy) {
av_log(avctx, AV_LOG_WARNING, "Buffering settings are ignored "
"in %s RC mode.\n", rc_mode->name);
}
hrd_buffer_size = 0;
hrd_initial_buffer_fullness = 0;
}
if (rc_target_bitrate > UINT32_MAX ||
hrd_buffer_size > UINT32_MAX ||
hrd_initial_buffer_fullness > UINT32_MAX) {
av_log(avctx, AV_LOG_ERROR, "RC parameters of 2^32 or "
"greater are not supported by D3D12.\n");
return AVERROR(EINVAL);
}
ctx->rc_quality = rc_quality;
av_log(avctx, AV_LOG_VERBOSE, "RC mode: %s.\n", rc_mode->name);
if (rc_mode->quality)
av_log(avctx, AV_LOG_VERBOSE, "RC quality: %d.\n", rc_quality);
if (rc_mode->hrd) {
av_log(avctx, AV_LOG_VERBOSE, "RC buffer: %"PRId64" bits, "
"initial fullness %"PRId64" bits.\n",
hrd_buffer_size, hrd_initial_buffer_fullness);
}
if (avctx->framerate.num > 0 && avctx->framerate.den > 0)
av_reduce(&fr_num, &fr_den,
avctx->framerate.num, avctx->framerate.den, 65535);
else
av_reduce(&fr_num, &fr_den,
avctx->time_base.den, avctx->time_base.num, 65535);
av_log(avctx, AV_LOG_VERBOSE, "RC framerate: %d/%d (%.2f fps).\n",
fr_num, fr_den, (double)fr_num / fr_den);
ctx->rc.Flags = D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAG_NONE;
ctx->rc.TargetFrameRate.Numerator = fr_num;
ctx->rc.TargetFrameRate.Denominator = fr_den;
ctx->rc.Mode = rc_mode->d3d12_mode;
switch (rc_mode->mode) {
case RC_MODE_CQP:
// cqp ConfigParams will be updated in ctx->codec->configure.
break;
case RC_MODE_CBR:
D3D12_VIDEO_ENCODER_RATE_CONTROL_CBR *cbr_ctl;
ctx->rc.ConfigParams.DataSize = sizeof(D3D12_VIDEO_ENCODER_RATE_CONTROL_CBR);
cbr_ctl = av_mallocz(ctx->rc.ConfigParams.DataSize);
if (!cbr_ctl)
return AVERROR(ENOMEM);
cbr_ctl->TargetBitRate = rc_target_bitrate;
cbr_ctl->VBVCapacity = hrd_buffer_size;
cbr_ctl->InitialVBVFullness = hrd_initial_buffer_fullness;
ctx->rc.Flags |= D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAG_ENABLE_VBV_SIZES;
if (avctx->qmin > 0 || avctx->qmax > 0) {
cbr_ctl->MinQP = avctx->qmin;
cbr_ctl->MaxQP = avctx->qmax;
ctx->rc.Flags |= D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAG_ENABLE_QP_RANGE;
}
ctx->rc.ConfigParams.pConfiguration_CBR = cbr_ctl;
break;
case RC_MODE_VBR:
D3D12_VIDEO_ENCODER_RATE_CONTROL_VBR *vbr_ctl;
ctx->rc.ConfigParams.DataSize = sizeof(D3D12_VIDEO_ENCODER_RATE_CONTROL_VBR);
vbr_ctl = av_mallocz(ctx->rc.ConfigParams.DataSize);
if (!vbr_ctl)
return AVERROR(ENOMEM);
vbr_ctl->TargetAvgBitRate = rc_target_bitrate;
vbr_ctl->PeakBitRate = rc_peak_bitrate;
vbr_ctl->VBVCapacity = hrd_buffer_size;
vbr_ctl->InitialVBVFullness = hrd_initial_buffer_fullness;
ctx->rc.Flags |= D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAG_ENABLE_VBV_SIZES;
if (avctx->qmin > 0 || avctx->qmax > 0) {
vbr_ctl->MinQP = avctx->qmin;
vbr_ctl->MaxQP = avctx->qmax;
ctx->rc.Flags |= D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAG_ENABLE_QP_RANGE;
}
ctx->rc.ConfigParams.pConfiguration_VBR = vbr_ctl;
break;
case RC_MODE_QVBR:
D3D12_VIDEO_ENCODER_RATE_CONTROL_QVBR *qvbr_ctl;
ctx->rc.ConfigParams.DataSize = sizeof(D3D12_VIDEO_ENCODER_RATE_CONTROL_QVBR);
qvbr_ctl = av_mallocz(ctx->rc.ConfigParams.DataSize);
if (!qvbr_ctl)
return AVERROR(ENOMEM);
qvbr_ctl->TargetAvgBitRate = rc_target_bitrate;
qvbr_ctl->PeakBitRate = rc_peak_bitrate;
qvbr_ctl->ConstantQualityTarget = rc_quality;
if (avctx->qmin > 0 || avctx->qmax > 0) {
qvbr_ctl->MinQP = avctx->qmin;
qvbr_ctl->MaxQP = avctx->qmax;
ctx->rc.Flags |= D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAG_ENABLE_QP_RANGE;
}
ctx->rc.ConfigParams.pConfiguration_QVBR = qvbr_ctl;
break;
default:
break;
}
return 0;
}
static int d3d12va_encode_init_gop_structure(AVCodecContext *avctx)
{
FFHWBaseEncodeContext *base_ctx = avctx->priv_data;
D3D12VAEncodeContext *ctx = avctx->priv_data;
uint32_t ref_l0, ref_l1;
int err;
HRESULT hr;
D3D12_FEATURE_DATA_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT support;
union {
D3D12_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT_H264 h264;
D3D12_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT_HEVC hevc;
} codec_support;
support.NodeIndex = 0;
support.Codec = ctx->codec->d3d12_codec;
support.Profile = ctx->profile->d3d12_profile;
switch (ctx->codec->d3d12_codec) {
case D3D12_VIDEO_ENCODER_CODEC_H264:
support.PictureSupport.DataSize = sizeof(codec_support.h264);
support.PictureSupport.pH264Support = &codec_support.h264;
break;
case D3D12_VIDEO_ENCODER_CODEC_HEVC:
support.PictureSupport.DataSize = sizeof(codec_support.hevc);
support.PictureSupport.pHEVCSupport = &codec_support.hevc;
break;
default:
av_assert0(0);
}
hr = ID3D12VideoDevice3_CheckFeatureSupport(ctx->video_device3, D3D12_FEATURE_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT,
&support, sizeof(support));
if (FAILED(hr))
return AVERROR(EINVAL);
if (support.IsSupported) {
switch (ctx->codec->d3d12_codec) {
case D3D12_VIDEO_ENCODER_CODEC_H264:
ref_l0 = FFMIN(support.PictureSupport.pH264Support->MaxL0ReferencesForP,
support.PictureSupport.pH264Support->MaxL1ReferencesForB);
ref_l1 = support.PictureSupport.pH264Support->MaxL1ReferencesForB;
break;
case D3D12_VIDEO_ENCODER_CODEC_HEVC:
ref_l0 = FFMIN(support.PictureSupport.pHEVCSupport->MaxL0ReferencesForP,
support.PictureSupport.pHEVCSupport->MaxL1ReferencesForB);
ref_l1 = support.PictureSupport.pHEVCSupport->MaxL1ReferencesForB;
break;
default:
av_assert0(0);
}
} else {
ref_l0 = ref_l1 = 0;
}
if (ref_l0 > 0 && ref_l1 > 0 && ctx->bi_not_empty) {
base_ctx->p_to_gpb = 1;
av_log(avctx, AV_LOG_VERBOSE, "Driver does not support P-frames, "
"replacing them with B-frames.\n");
}
err = ff_hw_base_init_gop_structure(base_ctx, avctx, ref_l0, ref_l1, ctx->codec->flags, 0);
if (err < 0)
return err;
return 0;
}
static int d3d12va_create_encoder(AVCodecContext *avctx)
{
FFHWBaseEncodeContext *base_ctx = avctx->priv_data;
D3D12VAEncodeContext *ctx = avctx->priv_data;
AVD3D12VAFramesContext *frames_hwctx = base_ctx->input_frames->hwctx;
HRESULT hr;
D3D12_VIDEO_ENCODER_DESC desc = {
.NodeMask = 0,
.Flags = D3D12_VIDEO_ENCODER_FLAG_NONE,
.EncodeCodec = ctx->codec->d3d12_codec,
.EncodeProfile = ctx->profile->d3d12_profile,
.InputFormat = frames_hwctx->format,
.CodecConfiguration = ctx->codec_conf,
.MaxMotionEstimationPrecision = D3D12_VIDEO_ENCODER_MOTION_ESTIMATION_PRECISION_MODE_MAXIMUM,
};
hr = ID3D12VideoDevice3_CreateVideoEncoder(ctx->video_device3, &desc, &IID_ID3D12VideoEncoder,
(void **)&ctx->encoder);
if (FAILED(hr)) {
av_log(avctx, AV_LOG_ERROR, "Failed to create encoder.\n");
return AVERROR(EINVAL);
}
return 0;
}
static int d3d12va_create_encoder_heap(AVCodecContext *avctx)
{
D3D12VAEncodeContext *ctx = avctx->priv_data;
HRESULT hr;
D3D12_VIDEO_ENCODER_HEAP_DESC desc = {
.NodeMask = 0,
.Flags = D3D12_VIDEO_ENCODER_FLAG_NONE,
.EncodeCodec = ctx->codec->d3d12_codec,
.EncodeProfile = ctx->profile->d3d12_profile,
.EncodeLevel = ctx->level,
.ResolutionsListCount = 1,
.pResolutionList = &ctx->resolution,
};
hr = ID3D12VideoDevice3_CreateVideoEncoderHeap(ctx->video_device3, &desc,
&IID_ID3D12VideoEncoderHeap, (void **)&ctx->encoder_heap);
if (FAILED(hr)) {
av_log(avctx, AV_LOG_ERROR, "Failed to create encoder heap.\n");
return AVERROR(EINVAL);
}
return 0;
}
static void d3d12va_encode_free_buffer(void *opaque, uint8_t *data)
{
ID3D12Resource *pResource;
pResource = (ID3D12Resource *)data;
D3D12_OBJECT_RELEASE(pResource);
}
static AVBufferRef *d3d12va_encode_alloc_output_buffer(void *opaque, size_t size)
{
AVCodecContext *avctx = opaque;
FFHWBaseEncodeContext *base_ctx = avctx->priv_data;
D3D12VAEncodeContext *ctx = avctx->priv_data;
ID3D12Resource *pResource = NULL;
HRESULT hr;
AVBufferRef *ref;
D3D12_HEAP_PROPERTIES heap_props;
D3D12_HEAP_TYPE heap_type = D3D12_HEAP_TYPE_READBACK;
D3D12_RESOURCE_DESC desc = {
.Dimension = D3D12_RESOURCE_DIMENSION_BUFFER,
.Alignment = 0,
.Width = FFALIGN(3 * base_ctx->surface_width * base_ctx->surface_height + (1 << 16),
D3D12_TEXTURE_DATA_PLACEMENT_ALIGNMENT),
.Height = 1,
.DepthOrArraySize = 1,
.MipLevels = 1,
.Format = DXGI_FORMAT_UNKNOWN,
.SampleDesc = { .Count = 1, .Quality = 0 },
.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR,
.Flags = D3D12_RESOURCE_FLAG_NONE,
};
ctx->hwctx->device->lpVtbl->GetCustomHeapProperties(ctx->hwctx->device, &heap_props, 0, heap_type);
hr = ID3D12Device_CreateCommittedResource(ctx->hwctx->device, &heap_props, D3D12_HEAP_FLAG_NONE,
&desc, D3D12_RESOURCE_STATE_COMMON, NULL, &IID_ID3D12Resource,
(void **)&pResource);
if (FAILED(hr)) {
av_log(avctx, AV_LOG_ERROR, "Failed to create d3d12 buffer.\n");
return NULL;
}
ref = av_buffer_create((uint8_t *)(uintptr_t)pResource,
sizeof(pResource),
&d3d12va_encode_free_buffer,
avctx, AV_BUFFER_FLAG_READONLY);
if (!ref) {
D3D12_OBJECT_RELEASE(pResource);
return NULL;
}
return ref;
}
static int d3d12va_encode_prepare_output_buffers(AVCodecContext *avctx)
{
FFHWBaseEncodeContext *base_ctx = avctx->priv_data;
D3D12VAEncodeContext *ctx = avctx->priv_data;
AVD3D12VAFramesContext *frames_ctx = base_ctx->input_frames->hwctx;
HRESULT hr;
ctx->req.NodeIndex = 0;
ctx->req.Codec = ctx->codec->d3d12_codec;
ctx->req.Profile = ctx->profile->d3d12_profile;
ctx->req.InputFormat = frames_ctx->format;
ctx->req.PictureTargetResolution = ctx->resolution;
hr = ID3D12VideoDevice3_CheckFeatureSupport(ctx->video_device3,
D3D12_FEATURE_VIDEO_ENCODER_RESOURCE_REQUIREMENTS,
&ctx->req, sizeof(ctx->req));
if (FAILED(hr)) {
av_log(avctx, AV_LOG_ERROR, "Failed to check encoder resource requirements support.\n");
return AVERROR(EINVAL);
}
if (!ctx->req.IsSupported) {
av_log(avctx, AV_LOG_ERROR, "Encoder resource requirements unsupported.\n");
return AVERROR(EINVAL);
}
ctx->output_buffer_pool = av_buffer_pool_init2(sizeof(ID3D12Resource *), avctx,
&d3d12va_encode_alloc_output_buffer, NULL);
if (!ctx->output_buffer_pool)
return AVERROR(ENOMEM);
return 0;
}
static int d3d12va_encode_create_command_objects(AVCodecContext *avctx)
{
D3D12VAEncodeContext *ctx = avctx->priv_data;
ID3D12CommandAllocator *command_allocator = NULL;
int err;
HRESULT hr;
D3D12_COMMAND_QUEUE_DESC queue_desc = {
.Type = D3D12_COMMAND_LIST_TYPE_VIDEO_ENCODE,
.Priority = 0,
.Flags = D3D12_COMMAND_QUEUE_FLAG_NONE,
.NodeMask = 0,
};
ctx->allocator_queue = av_fifo_alloc2(D3D12VA_VIDEO_ENC_ASYNC_DEPTH,
sizeof(CommandAllocator), AV_FIFO_FLAG_AUTO_GROW);
if (!ctx->allocator_queue)
return AVERROR(ENOMEM);
hr = ID3D12Device_CreateFence(ctx->hwctx->device, 0, D3D12_FENCE_FLAG_NONE,
&IID_ID3D12Fence, (void **)&ctx->sync_ctx.fence);
if (FAILED(hr)) {
av_log(avctx, AV_LOG_ERROR, "Failed to create fence(%lx)\n", (long)hr);
err = AVERROR_UNKNOWN;
goto fail;
}
ctx->sync_ctx.event = CreateEvent(NULL, FALSE, FALSE, NULL);
if (!ctx->sync_ctx.event)
goto fail;
err = d3d12va_get_valid_command_allocator(avctx, &command_allocator);
if (err < 0)
goto fail;
hr = ID3D12Device_CreateCommandQueue(ctx->hwctx->device, &queue_desc,
&IID_ID3D12CommandQueue, (void **)&ctx->command_queue);
if (FAILED(hr)) {
av_log(avctx, AV_LOG_ERROR, "Failed to create command queue(%lx)\n", (long)hr);
err = AVERROR_UNKNOWN;
goto fail;
}
hr = ID3D12Device_CreateCommandList(ctx->hwctx->device, 0, queue_desc.Type,
command_allocator, NULL, &IID_ID3D12CommandList,
(void **)&ctx->command_list);
if (FAILED(hr)) {
av_log(avctx, AV_LOG_ERROR, "Failed to create command list(%lx)\n", (long)hr);
err = AVERROR_UNKNOWN;
goto fail;
}
hr = ID3D12VideoEncodeCommandList2_Close(ctx->command_list);
if (FAILED(hr)) {
av_log(avctx, AV_LOG_ERROR, "Failed to close the command list(%lx)\n", (long)hr);
err = AVERROR_UNKNOWN;
goto fail;
}
ID3D12CommandQueue_ExecuteCommandLists(ctx->command_queue, 1, (ID3D12CommandList **)&ctx->command_list);
err = d3d12va_sync_with_gpu(avctx);
if (err < 0)
goto fail;
err = d3d12va_discard_command_allocator(avctx, command_allocator, ctx->sync_ctx.fence_value);
if (err < 0)
goto fail;
return 0;
fail:
D3D12_OBJECT_RELEASE(command_allocator);
return err;
}
static int d3d12va_encode_create_recon_frames(AVCodecContext *avctx)
{
FFHWBaseEncodeContext *base_ctx = avctx->priv_data;
AVD3D12VAFramesContext *hwctx;
enum AVPixelFormat recon_format;
int err;
err = ff_hw_base_get_recon_format(base_ctx, NULL, &recon_format);
if (err < 0)
return err;
base_ctx->recon_frames_ref = av_hwframe_ctx_alloc(base_ctx->device_ref);
if (!base_ctx->recon_frames_ref)
return AVERROR(ENOMEM);
base_ctx->recon_frames = (AVHWFramesContext *)base_ctx->recon_frames_ref->data;
hwctx = (AVD3D12VAFramesContext *)base_ctx->recon_frames->hwctx;
base_ctx->recon_frames->format = AV_PIX_FMT_D3D12;
base_ctx->recon_frames->sw_format = recon_format;
base_ctx->recon_frames->width = base_ctx->surface_width;
base_ctx->recon_frames->height = base_ctx->surface_height;
hwctx->flags = D3D12_RESOURCE_FLAG_VIDEO_ENCODE_REFERENCE_ONLY |
D3D12_RESOURCE_FLAG_DENY_SHADER_RESOURCE;
err = av_hwframe_ctx_init(base_ctx->recon_frames_ref);
if (err < 0) {
av_log(avctx, AV_LOG_ERROR, "Failed to initialise reconstructed "
"frame context: %d.\n", err);
return err;
}
return 0;
}
static const FFHWEncodePictureOperation d3d12va_type = {
.alloc = &d3d12va_encode_alloc,
.issue = &d3d12va_encode_issue,
.output = &d3d12va_encode_output,
.free = &d3d12va_encode_free,
};
int ff_d3d12va_encode_receive_packet(AVCodecContext *avctx, AVPacket *pkt)
{
return ff_hw_base_encode_receive_packet(avctx->priv_data, avctx, pkt);
}
int ff_d3d12va_encode_init(AVCodecContext *avctx)
{
FFHWBaseEncodeContext *base_ctx = avctx->priv_data;
D3D12VAEncodeContext *ctx = avctx->priv_data;
D3D12_FEATURE_DATA_VIDEO_FEATURE_AREA_SUPPORT support = { 0 };
int err;
HRESULT hr;
err = ff_hw_base_encode_init(avctx, base_ctx);
if (err < 0)
goto fail;
base_ctx->op = &d3d12va_type;
ctx->hwctx = base_ctx->device->hwctx;
ctx->resolution.Width = base_ctx->input_frames->width;
ctx->resolution.Height = base_ctx->input_frames->height;
hr = ID3D12Device_QueryInterface(ctx->hwctx->device, &IID_ID3D12Device3, (void **)&ctx->device3);
if (FAILED(hr)) {
av_log(avctx, AV_LOG_ERROR, "ID3D12Device3 interface is not supported.\n");
err = AVERROR_UNKNOWN;
goto fail;
}
hr = ID3D12Device3_QueryInterface(ctx->device3, &IID_ID3D12VideoDevice3, (void **)&ctx->video_device3);
if (FAILED(hr)) {
av_log(avctx, AV_LOG_ERROR, "ID3D12VideoDevice3 interface is not supported.\n");
err = AVERROR_UNKNOWN;
goto fail;
}
if (FAILED(ID3D12VideoDevice3_CheckFeatureSupport(ctx->video_device3, D3D12_FEATURE_VIDEO_FEATURE_AREA_SUPPORT,
&support, sizeof(support))) && !support.VideoEncodeSupport) {
av_log(avctx, AV_LOG_ERROR, "D3D12 video device has no video encoder support.\n");
err = AVERROR(EINVAL);
goto fail;
}
err = d3d12va_encode_set_profile(avctx);
if (err < 0)
goto fail;
err = d3d12va_encode_init_rate_control(avctx);
if (err < 0)
goto fail;
if (ctx->codec->get_encoder_caps) {
err = ctx->codec->get_encoder_caps(avctx);
if (err < 0)
goto fail;
}
err = d3d12va_encode_init_gop_structure(avctx);
if (err < 0)
goto fail;
if (!(ctx->codec->flags & FF_HW_FLAG_SLICE_CONTROL) && avctx->slices > 0) {
av_log(avctx, AV_LOG_WARNING, "Multiple slices were requested "
"but this codec does not support controlling slices.\n");
}
err = d3d12va_encode_create_command_objects(avctx);
if (err < 0)
goto fail;
err = d3d12va_encode_create_recon_frames(avctx);
if (err < 0)
goto fail;
err = d3d12va_encode_prepare_output_buffers(avctx);
if (err < 0)
goto fail;
if (ctx->codec->configure) {
err = ctx->codec->configure(avctx);
if (err < 0)
goto fail;
}
if (ctx->codec->init_sequence_params) {
err = ctx->codec->init_sequence_params(avctx);
if (err < 0) {
av_log(avctx, AV_LOG_ERROR, "Codec sequence initialisation "
"failed: %d.\n", err);
goto fail;
}
}
if (ctx->codec->set_level) {
err = ctx->codec->set_level(avctx);
if (err < 0)
goto fail;
}
base_ctx->output_delay = base_ctx->b_per_p;
base_ctx->decode_delay = base_ctx->max_b_depth;
err = d3d12va_create_encoder(avctx);
if (err < 0)
goto fail;
err = d3d12va_create_encoder_heap(avctx);
if (err < 0)
goto fail;
base_ctx->async_encode = 1;
base_ctx->encode_fifo = av_fifo_alloc2(base_ctx->async_depth,
sizeof(D3D12VAEncodePicture *), 0);
if (!base_ctx->encode_fifo)
return AVERROR(ENOMEM);
return 0;
fail:
return err;
}
int ff_d3d12va_encode_close(AVCodecContext *avctx)
{
int num_allocator = 0;
FFHWBaseEncodeContext *base_ctx = avctx->priv_data;
D3D12VAEncodeContext *ctx = avctx->priv_data;
FFHWBaseEncodePicture *pic, *next;
CommandAllocator allocator;
if (!base_ctx->frame)
return 0;
for (pic = base_ctx->pic_start; pic; pic = next) {
next = pic->next;
d3d12va_encode_free(avctx, pic);
}
d3d12va_encode_free_rc_params(avctx);
av_buffer_pool_uninit(&ctx->output_buffer_pool);
D3D12_OBJECT_RELEASE(ctx->command_list);
D3D12_OBJECT_RELEASE(ctx->command_queue);
if (ctx->allocator_queue) {
while (av_fifo_read(ctx->allocator_queue, &allocator, 1) >= 0) {
num_allocator++;
D3D12_OBJECT_RELEASE(allocator.command_allocator);
}
av_log(avctx, AV_LOG_VERBOSE, "Total number of command allocators reused: %d\n", num_allocator);
}
av_fifo_freep2(&ctx->allocator_queue);
D3D12_OBJECT_RELEASE(ctx->sync_ctx.fence);
if (ctx->sync_ctx.event)
CloseHandle(ctx->sync_ctx.event);
D3D12_OBJECT_RELEASE(ctx->encoder_heap);
D3D12_OBJECT_RELEASE(ctx->encoder);
D3D12_OBJECT_RELEASE(ctx->video_device3);
D3D12_OBJECT_RELEASE(ctx->device3);
ff_hw_base_encode_close(base_ctx);
return 0;
}
Reference in New Issue View Git Blame Copy Permalink