[Bug]: EAccessViolation Write 0x440 in amfrtdrv64.dll on CreateSurfaceFromHostNative (HOST RAM fallback) - Ryzen 7 5700G (Cezanne APU)

[miguelandradedotcom]

Describe the bug
When using the AMF AVC encoder via direct API (not FFmpeg), the HOST RAM fallback
pipeline crashes with an Access Violation inside amfrtdrv64.dll.

The crash occurs consistently after CreateSurfaceFromDX11Native fails (HR=0x00000011)
and the encoder falls back to HOST RAM mode. After ResetContextForHost creates a clean
context (without InitDX11) and SetEncoderParams succeeds, the first call to
CreateSurfaceFromHostNative(AMF_SURFACE_BGRA) triggers:

EAccessViolation: Write of address 0x0000000000000440
in module amfrtdrv64.dll at address 0x00007FFC7025BCAC

The crash address 0x440 is consistent across all sessions, suggesting a fixed struct
offset being written to an invalid pointer inside the driver.

To Reproduce

1. Initialize AMF AVC encoder with DX11 context (InitDX11 on a Cezanne APU iGPU)
2. Call CreateSurfaceFromDX11Native — it returns HR=0x00000011 (fails on Cezanne)
3. Release the DX11 context, create a new clean context without InitDX11
4. Call Component.Init with AMF_SURFACE_BGRA
5. Call CreateSurfaceFromHostNative(AMF_SURFACE_BGRA, width, height, width*4, height,
   pBGRA, &surf, nullptr)
6. Call Component.SubmitInput(surf) → EAccessViolation Write 0x440 in amfrtdrv64.dll

Workaround confirmed
FFmpeg h264_amf with hwdownload (CPU→AMF path) works correctly on the same hardware
with the same driver. This confirms the VCE hardware is functional — the bug is
specific to the direct AMF API path for HOST RAM surface submission.

Setup

• OS: Windows 10 Build 26200 (25H2)
• Driver Version: 31.0.21924.61 (Adrenalin, December 2025)
• amfrt64.dll version: 1.4.31.0
• GPU: AMD Ryzen 7 5700G — Cezanne APU, Radeon Vega 8 iGPU (VEN_1002 / DEV_1638)
• No discrete GPU present
• Which component has the issue: Encoder (AMFVideoEncoderVCE_AVC), HOST RAM pipeline

Additional context
The AMF runtime stub (amfrt64.dll) is only 4KB — actual encoding is delegated to
amfrtdrv64.dll which is where the crash occurs. The issue appears to be in how
amfrtdrv64.dll handles HOST memory surfaces on the Cezanne iGPU when the AMF context
has no DX11 state initialized. FFmpeg works around this by using a different internal
path (hwdownload filter before h264_amf), which never triggers the crash.

[MikhailAMD]

Few points:

• This is old driver and HW, it is in maintenance mode, only is updated for security issues.
• Could you please share the actual code snippet which is doing this?
• When you create AMF context and don't initialize DX or VK, AMF doesn't know how to work. Some components have CPU/HOST fallback like Video Converter, but encoder and decoder don't. In general, AMF is to use GPU resources, not CPU.
• FFmpeg is using the same AMF API for encoding and do call InitDX11. It is likely, that your sequence of the calls is different.
• I would concentrate on the fact that InitDX11 fails. Did you try AMF samples (SimpleEncoder for example)?
• Once DX11 initialization issue is resolved, you should be able to encode like in FFmpeg.

[miguelandradedotcom]

Few points:

• This is old driver and HW, it is in maintenance mode, only is updated for security issues.
• Could you please share the actual code snippet which is doing this?
• When you create AMF context and don't initialize DX or VK, AMF doesn't know how to work. Some components have CPU/HOST fallback like Video Converter, but encoder and decoder don't. In general, AMF is to use GPU resources, not CPU.
• FFmpeg is using the same AMF API for encoding and do call InitDX11. It is likely, that your sequence of the calls is different.
• I would concentrate on the fact that InitDX11 fails. Did you try AMF samples (SimpleEncoder for example)?
• Once DX11 initialization issue is resolved, you should be able to encode like in FFmpeg.

Re: AMF encoding issue on AMD Ryzen 7 5700U (Lucienne APU, Radeon integrated graphics)
Hi Mikhail,
Thank you for the detailed response. Here is the full picture from a test run on the affected machine.
System:

CPU/GPU: AMD Ryzen 7 5700U with Radeon Graphics (Lucienne, Zen 2, integrated Vega)
Driver: amfrt64.dll v1.4.31.0
OS: Windows 10 Build 26200 (25H2)
RAM: 6 GB

Exact call sequence (confirmed in logs):

AMFInit → OK
Factory.CreateContext → OK
Context.InitDX11(pD3D11Device) → OK (HR=0x0)
Factory.CreateComponent(AVC) → OK
First frame: Context.CreateSurfaceFromDX11Native → HR=0x00000011 (AMF_NOT_SUPPORTED)
Fallback triggered: component and context released (with Terminate before Release), new clean context created without InitDX11, new component initialized in HOST mode
CreateSurfaceFromHostNative(BGRA) → EAccessViolation Write 0x440 in amfrtdrv64.dll → encoder disabled, fell back to software (OpenH264)

Observation:
InitDX11 succeeds, but CreateSurfaceFromDX11Native returns AMF_NOT_SUPPORTED (0x11) on the very first frame. This suggests the Lucienne iGPU with driver 1.4.31.0 does not support DX11↔AMF texture interop, even though InitDX11 itself does not fail.
After the fallback resets the context (clean context, no InitDX11, mirroring FFmpeg's CPU→AMF path), CreateSurfaceFromHostNative(BGRA) crashes with an access violation in amfrtdrv64.dll. This happens even though Context.Terminate is called before Release on the old context. It appears the driver retains some internal state that survives the reset on this APU/driver combination.
Question:
Is CreateSurfaceFromDX11Native returning AMF_NOT_SUPPORTED on the Lucienne iGPU an expected/known limitation of driver 1.4.31.0? And is there a safe way to use CreateSurfaceFromHostNative(BGRA) on a clean HOST context on this platform, or is HOST-mode encoding simply not supported on this driver/hardware?

We are happy to test the AMF SimpleEncoder sample if that would help isolate whether the issue is in our call sequence or in the driver itself. Could you share a direct link to the sample?

Thank you!

[MikhailAMD]

First frame: Context.CreateSurfaceFromDX11Native → HR=0x00000011 (AMF_NOT_SUPPORTED)

• What is D3D11_TEXTURE2D_DESC for the texture you pass - full set of parameters?
• What are the parameters for D3D11 device creation?
• Was the texture created with the same D3D11 device?
• Enable AMF detailed logging and provide the logs.
• CreateSurfaceFromDX11Native should work in your driver and HW.
• As I said, creating component without D3D is kind of useless.
• CreateSurfaceFromHostNative - how was memory allocated, What parameters, what size?

[miguelandradedotcom]

First frame: Context.CreateSurfaceFromDX11Native → HR=0x00000011 (AMF_NOT_SUPPORTED)

• What is D3D11_TEXTURE2D_DESC for the texture you pass - full set of parameters?
• What are the parameters for D3D11 device creation?
• Was the texture created with the same D3D11 device?
• Enable AMF detailed logging and provide the logs.
• CreateSurfaceFromDX11Native should work in your driver and HW.
• As I said, creating component without D3D is kind of useless.
• CreateSurfaceFromHostNative - how was memory allocated, What parameters, what size?

Hi Mikhail, thank you for the feedback. Here are the full details:

1. D3D11_TEXTURE2D_DESC of the texture passed to CreateSurfaceFromDX11Native:
   Width: 1920
   Height: 1080
   MipLevels: 1
   ArraySize: 1
   Format: DXGI_FORMAT_B8G8R8A8_UNORM (87)
   SampleDesc.Count: 1
   SampleDesc.Quality: 0
   Usage: D3D11_USAGE_DEFAULT (0)
   BindFlags: D3D11_BIND_RENDER_TARGET | D3D11_BIND_SHADER_RESOURCE (0x28)
   CPUAccessFlags: 0
   MiscFlags: 0

2. D3D11CreateDevice parameters:
   pAdapter: NULL (default adapter)
   DriverType: D3D_DRIVER_TYPE_HARDWARE (1)
   Flags: 0
   pFeatureLevels: NULL (runtime chooses)
   FeatureLevels: 0
   SDKVersion: D3D11_SDK_VERSION (7)

3. Same D3D11 device? Yes. The ID3D11Device pointer created in our DXGI capture init is passed directly to Context.InitDX11() and also used to create the SharedTexture via CreateTexture2D. It is the exact same object.

4. CreateSurfaceFromHostNative: We do not call it directly. The HOST fallback uses AMF's AllocSurface with a CPU NV12 buffer allocated in system memory.

Possible issue we noticed: MiscFlags = 0 — should we add D3D11_RESOURCE_MISC_SHARED (0x2) for AMF interop? Also, D3D11CreateDevice was called without D3D11_CREATE_DEVICE_BGRA_SUPPORT (0x20) — could that affect BGRA surface handling in the AMF pipeline?

GPU on the affected machine: AMD Radeon(TM) Graphics (integrated), AMF runtime version 1.4.31.0 (amfrt64.dll).

[MikhailAMD]

This is strange. The return code you stated is: "CreateSurfaceFromDX11Native fails (HR=0x00000011)"
But AMF functions returns AMF_RESULT. If it is 0x11, it is AMF_NO_DEVICE. This means, that InitDX11 failed, not called, or AMFContext was terminated.
There are several samples that create D3D11 device externally and pass to AMF. VCEEncoderD3D does this and even calls CreateSurfaceFromDX11Native. Could you please check if it is working for you?

[miguelandradedotcom]

This is strange. The return code you stated is: "CreateSurfaceFromDX11Native fails (HR=0x00000011)" But AMF functions returns AMF_RESULT. If it is 0x11, it is AMF_NO_DEVICE. This means, that InitDX11 failed, not called, or AMFContext was terminated. There are several samples that create D3D11 device externally and pass to AMF. VCEEncoderD3D does this and even calls CreateSurfaceFromDX11Native. Could you please check if it is working for you?

Hi Mikhail,

We wrote a minimal C++ diagnostic sample (no AMF SDK headers required, raw vtable dispatch identical to VCEEncoderD3D) and ran it on the affected machine.

The root cause is now confirmed:

Context::InitDX11 returns AMF_OK but Context::GetDX11Device immediately returns NULL.

This means the context silently accepts the call but never stores the device internally. So when CreateSurfaceFromDX11Native is called, the context has no DX11 device associated -- which produces AMF_NO_DEVICE (0x11).

Log output:

D3D11CreateDevice OK -- Device=0000020E5E9D8810
InitDX11: passing Device=0000020E5E9D8810 (same device that created the texture)
InitDX11 OK   <-- returns AMF_OK (0x0)
GetDX11Device returned 0000000000000000  <-- NULL! expected 0000020E5E9D8810
CreateSurfaceFromDX11Native HR=0x00000011 (AMF_NO_DEVICE)

Setup:

• GPU: AMD Radeon(TM) Graphics (integrated)
• AMF runtime: amfrt64.dll version 1.4.31.0
• OS: Windows 10 Build 26200 (25H2)
• D3D11CreateDevice: pAdapter=NULL, DriverType=HARDWARE, Flags=0, pFeatureLevels=NULL
• Texture: 1920x1080, DXGI_FORMAT_B8G8R8A8_UNORM, USAGE_DEFAULT, BIND_RT|SRV, MiscFlags=0
• The texture was created with the exact same ID3D11Device pointer passed to InitDX11

Sample code (C++, compiles with just Windows SDK -- no AMF SDK needed):

cl /EHsc /W3 /std:c++17 AMF_DX11_Sample.cpp d3d11.lib

See attached AMF_DX11_Sample.cpp.

Is this a known issue with AMF 1.4.31.0 on integrated AMD GPUs? Is there a workaround to make InitDX11 properly register the device in the context?

Thank you.

AMF_DX11_Sample.cpp

AMF_DX11_Sample.log.txt

[MikhailAMD]

There are several errors in the function table you provided:

1. Return type is AMF_RESULT which is enum while HRESULT is long.
2. Return from Acquire/Release should be long.
3. Last parameter in InitDX11 is enum, not int.

But all this don't lead to obvious errors.

The main issue I see is that your code calls:
hr = CtxVtbl(context)->InitDX11(context, d3dDevice, 0);
while you should
hr = CtxVtbl(context)->InitDX11(context, d3dDevice, 111); // AMF_DX11_1 = 111,

In this case GetDX11Device will return NULL and likely this why CreateSurfaceFromDX11Native failed.

Please try original AMF samples first. If they work, compare with your code.

[miguelandradedotcom]

There are several errors in the function table you provided:

1. Return type is AMF_RESULT which is enum while HRESULT is long.
2. Return from Acquire/Release should be long.
3. Last parameter in InitDX11 is enum, not int.

But all this don't lead to obvious errors.

The main issue I see is that your code calls: hr = CtxVtbl(context)->InitDX11(context, d3dDevice, 0); while you should hr = CtxVtbl(context)->InitDX11(context, d3dDevice, 111); // AMF_DX11_1 = 111,

In this case GetDX11Device will return NULL and likely this why CreateSurfaceFromDX11Native failed.

Please try original AMF samples first. If they work, compare with your code.

Hi Mikhail,
We tested both suggestions. Here are the results on the Ryzen 7 5700U (Lucienne, Zen 2, integrated Vega, driver amfrt64.dll v1.4.31.0):
Test 1: AMF_DX11_1 = 111
We changed InitDX11(context, d3dDevice, 0) to InitDX11(context, d3dDevice, 111). InitDX11 still returns OK, but CreateSurfaceFromDX11Native still returns HR=0x00000011 (AMF_NOT_SUPPORTED) on the first frame. No change in behavior.
Test 2: HOST fallback after AMF_NOT_SUPPORTED
After CreateSurfaceFromDX11Native fails, we reset the context (Terminate + Release), create a clean new context without calling InitDX11, recreate the component, and call Component.Init(AMF_SURFACE_BGRA, 1920, 1088) — which returns HR=0x00000001 (AMF_OK). Then on the first CreateSurfaceFromHostNative(BGRA, ...) call, the driver crashes with:
EAccessViolation: Write of address 0x0000000000000440 in amfrtdrv64.dll
This happens even on a clean context with no prior InitDX11. Component.Init returns OK but the driver crashes internally on the first surface allocation.
Current workaround:
We now detect HR=0x11 from CreateSurfaceFromDX11Native and immediately disable AMF entirely, falling back to software (OpenH264). This avoids the crash. But hardware encoding is unavailable on this machine.
Question:
Is there any known supported path for AMF encoding on Lucienne APUs with driver 1.4.31.0 — either DX11 or HOST mode? Or is this hardware/driver combination simply not supported for encoding via AMF?
We are still happy to test the SimpleEncoder sample if you can share a link — it would help confirm whether the issue is our code or the driver itself on this platform.

[MikhailAMD]

1. AMF samples are part of this GitHub repo. You can clone whole repo and build them:
   https://github.com/GPUOpen-LibrariesAndSDKs/AMF/blob/master/amf/public/samples/CPPSamples_vs2022.sln . Try these:

• SimpleEncoder
• VCEEncoderD3D

2. Try original AMF headers.
3. You should enable AMF logging and get more detailed info:
   amf_int32 traceLevel = AMF_TRACE_DEBUG;
   g_AMFFactory.GetTrace()->SetGlobalLevel(traceLevel);
   g_AMFFactory.GetTrace()->EnableWriter (AMF_TRACE_WRITER_CONSOLE, true);
   g_AMFFactory.GetTrace()->SetWriterLevel(AMF_TRACE_WRITER_CONSOLE, traceLevel);
   g_AMFFactory.GetTrace()->EnableWriter (AMF_TRACE_WRITER_DEBUG_OUTPUT, true);
   g_AMFFactory.GetTrace()->SetWriterLevel(AMF_TRACE_WRITER_DEBUG_OUTPUT, traceLevel);
4. AFAIK, the use case you are tying should work on 5700 and FFmpeg proves this. It passes D3D11 device or NULL depend on command line.
5. GetDX11Device c all also requires 111 parameter
6. Test 2 will not work. AMF needs D3D11 or D3D9 or D3D12 or Vulkan to run.
7. Your code sample doesn't include CreateSurfaceFromHostNative call

[miguelandradedotcom]

1. AMF samples are part of this GitHub repo. You can clone whole repo and build them:
   https://github.com/GPUOpen-LibrariesAndSDKs/AMF/blob/master/amf/public/samples/CPPSamples_vs2022.sln . Try these:

• SimpleEncoder
• VCEEncoderD3D

2. Try original AMF headers.
3. You should enable AMF logging and get more detailed info:
   amf_int32 traceLevel = AMF_TRACE_DEBUG;
   g_AMFFactory.GetTrace()->SetGlobalLevel(traceLevel);
   g_AMFFactory.GetTrace()->EnableWriter (AMF_TRACE_WRITER_CONSOLE, true);
   g_AMFFactory.GetTrace()->SetWriterLevel(AMF_TRACE_WRITER_CONSOLE, traceLevel);
   g_AMFFactory.GetTrace()->EnableWriter (AMF_TRACE_WRITER_DEBUG_OUTPUT, true);
   g_AMFFactory.GetTrace()->SetWriterLevel(AMF_TRACE_WRITER_DEBUG_OUTPUT, traceLevel);
4. AFAIK, the use case you are tying should work on 5700 and FFmpeg proves this. It passes D3D11 device or NULL depend on command line.
5. GetDX11Device c all also requires 111 parameter
6. Test 2 will not work. AMF needs D3D11 or D3D9 or D3D12 or Vulkan to run.
7. Your code sample doesn't include CreateSurfaceFromHostNative call

Thank you. We will clone the repo and run SimpleEncoder and VCEEncoderD3D on the Ryzen 7 5700U to get AMF trace logs. We will also enable AMF debug tracing as you suggested and share the output.
One clarification on our setup: the D3D11 device is created via D3D11CreateDevice with D3D_DRIVER_TYPE_HARDWARE and passed directly to InitDX11(context, device, 111). The same device instance is used for DXGI Desktop Duplication and shared with AMF — same device, no separate creation.
We understand HOST mode without a GPU context is not valid. Our fallback attempt was incorrect. We will focus on getting the DX11 path working based on the SimpleEncoder comparison.
Will report back with AMF trace logs.

[miguelandradedotcom]

Its working, a made a AmfWrapper.dll to import to Delphi:

/*
AmfWrapper.cpp -- usa os headers reais do AMF SDK.
SEM vtables manuais. O compilador C++ monta tudo corretamente.

Para compilar no VS:
Project > Properties > C/C++ > Additional Include Directories:
\amf\public\include
Linker > Input > Additional Dependencies: d3d11.lib

O AMF SDK e so headers .h -- nao tem .lib nem .dll para linkar.
Baixar em: https://github.com/GPUOpen-LibrariesAndSDKs/AMF
(pode fazer Download ZIP, nao precisa clonar tudo -- so a pasta
amf\public\include e necessaria)
*/

#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <d3d11.h>

// Headers reais do AMF SDK
#include "core/Factory.h"
#include "core/Context.h"
#include "core/Surface.h"
#include "core/Buffer.h"
#include "components/VideoEncoderVCE.h"
#include "components/VideoEncoderHEVC.h"

#include
#include

// ---------------------------------------------------------------------------
// Estado global
// ---------------------------------------------------------------------------
static amf::AMFFactory* g_Factory = nullptr;
static amf::AMFContextPtr g_Context;
static amf::AMFComponentPtr g_Encoder;
static HMODULE g_hAmf = nullptr;
static ID3D11Device* g_D3DDev = nullptr;
static ID3D11DeviceContext* g_D3DCtx = nullptr;
static int g_Width = 0;
static int g_HeightA = 0;
static amf::AMF_SURFACE_FORMAT g_Fmt = amf::AMF_SURFACE_NV12;
static std::wstring g_LastErr;

static void SetErr(const wchar_t* msg, AMF_RESULT r = AMF_OK) {
wchar_t buf[512];
if (r != AMF_OK) swprintf_s(buf, L"%s (0x%08X)", msg, (unsigned)r);
else wcsncpy_s(buf, msg, 511);
g_LastErr = buf;
}

// ---------------------------------------------------------------------------
// AmfWrap_Init
// ---------------------------------------------------------------------------
extern "C" __declspec(dllexport)
int __stdcall AmfWrap_Init(int width, int height, int fps, int bitrate)
{
g_Width = width;
g_HeightA = (height + 15) & ~15;

// D3D11 -- criado aqui para ter disponivel como fallback
D3D_FEATURE_LEVEL levels[] = {
    D3D_FEATURE_LEVEL_11_1, D3D_FEATURE_LEVEL_11_0, D3D_FEATURE_LEVEL_10_1
};
D3D_FEATURE_LEVEL got;
D3D11CreateDevice(nullptr, D3D_DRIVER_TYPE_HARDWARE, nullptr,
    0, levels, 3, D3D11_SDK_VERSION, &g_D3DDev, &got, &g_D3DCtx);
// nao fatal se falhar -- AMF pode criar o proprio device

// Carregar amfrt64.dll
g_hAmf = LoadLibraryW(L"amfrt64.dll");
if (!g_hAmf) {
    wchar_t sys[MAX_PATH]; GetSystemDirectoryW(sys, MAX_PATH);
    std::wstring p = std::wstring(sys) + L"\\amfrt64.dll";
    g_hAmf = LoadLibraryW(p.c_str());
}
if (!g_hAmf) { SetErr(L"amfrt64.dll nao encontrada"); return AMF_FAIL; }

auto fnInit = (AMFInit_Fn)GetProcAddress(g_hAmf, AMF_INIT_FUNCTION_NAME);
if (!fnInit) { SetErr(L"AMFInit nao encontrado"); return AMF_FAIL; }

AMF_RESULT res = fnInit(AMF_FULL_VERSION, &g_Factory);
if (res != AMF_OK) { SetErr(L"AMFInit falhou", res); return res; }

// Trace: o AMF imprime automaticamente no DebugView quando o encoder falha.
// Habilitar via variavel de ambiente se necessario:
//   set AMF_LOG_TO_CONSOLE=1

// Contexto
res = g_Factory->CreateContext(&g_Context);
if (res != AMF_OK) { SetErr(L"CreateContext falhou", res); return res; }

// InitDX11: NULL primeiro (padrao do SDK), depois device externo
res = g_Context->InitDX11(nullptr, amf::AMF_DX11_1);
if (res != AMF_OK) res = g_Context->InitDX11(nullptr, amf::AMF_DX11_0);
if (res != AMF_OK && g_D3DDev) {
    res = g_Context->InitDX11(g_D3DDev, amf::AMF_DX11_1);
    if (res != AMF_OK) res = g_Context->InitDX11(g_D3DDev, amf::AMF_DX11_0);
}
if (res != AMF_OK) { SetErr(L"InitDX11 falhou", res); return res; }

// Probe: codec x formato
const wchar_t* codecs[] = {
    AMFVideoEncoderVCE_AVC,
    AMFVideoEncoder_HEVC,
    nullptr
};
amf::AMF_SURFACE_FORMAT fmts[] = {
    amf::AMF_SURFACE_NV12,
    amf::AMF_SURFACE_BGRA,
    amf::AMF_SURFACE_RGBA,
    amf::AMF_SURFACE_YUV420P,
    (amf::AMF_SURFACE_FORMAT)0
};

for (int ci = 0; codecs[ci]; ci++) {
    amf::AMFComponentPtr enc;
    res = g_Factory->CreateComponent(g_Context, codecs[ci], &enc);
    if (res != AMF_OK) continue;

    bool hevc = (wcscmp(codecs[ci], AMFVideoEncoder_HEVC) == 0);
    if (hevc)
        enc->SetProperty(AMF_VIDEO_ENCODER_HEVC_USAGE,
            (amf_int64)AMF_VIDEO_ENCODER_HEVC_USAGE_TRANSCODING);
    else
        enc->SetProperty(AMF_VIDEO_ENCODER_USAGE,
            (amf_int64)AMF_VIDEO_ENCODER_USAGE_TRANSCODING);

    amf::AMF_SURFACE_FORMAT acceptedFmt = (amf::AMF_SURFACE_FORMAT)0;
    for (int fi = 0; (int)fmts[fi] != 0; fi++) {
        res = enc->Init(fmts[fi], width, g_HeightA);
        wchar_t dbg[128];
        swprintf_s(dbg, L"[AmfWrapper] %s Init(fmt=%d) -> 0x%08X\n",
            codecs[ci], (int)fmts[fi], (unsigned)res);
        OutputDebugStringW(dbg);
        if (res == AMF_OK) { acceptedFmt = fmts[fi]; break; }
    }

    if ((int)acceptedFmt == 0) {
        enc->Terminate();
        enc = nullptr;
        continue;
    }

    g_Fmt = acceptedFmt;

    if (hevc) {
        enc->SetProperty(AMF_VIDEO_ENCODER_HEVC_TARGET_BITRATE, (amf_int64)bitrate);
        enc->SetProperty(AMF_VIDEO_ENCODER_HEVC_FRAMERATE, ::AMFConstructRate(fps, 1));
        enc->SetProperty(AMF_VIDEO_ENCODER_HEVC_QUALITY_PRESET,
            (amf_int64)AMF_VIDEO_ENCODER_HEVC_QUALITY_PRESET_SPEED);
    }
    else {
        enc->SetProperty(AMF_VIDEO_ENCODER_PROFILE,
            (amf_int64)AMF_VIDEO_ENCODER_PROFILE_HIGH);
        enc->SetProperty(AMF_VIDEO_ENCODER_TARGET_BITRATE, (amf_int64)bitrate);
        enc->SetProperty(AMF_VIDEO_ENCODER_PEAK_BITRATE, (amf_int64)bitrate);
        enc->SetProperty(AMF_VIDEO_ENCODER_FRAMERATE, ::AMFConstructRate(fps, 1));
        enc->SetProperty(AMF_VIDEO_ENCODER_IDR_PERIOD, (amf_int64)(fps * 2));
        enc->SetProperty(AMF_VIDEO_ENCODER_QUALITY_PRESET,
            (amf_int64)AMF_VIDEO_ENCODER_QUALITY_PRESET_SPEED);
    }

    g_Encoder = enc;
    g_LastErr.clear();
    return AMF_OK;
}

SetErr(L"Nenhum encoder disponivel neste hardware");
return AMF_NOT_SUPPORTED;

}

// ---------------------------------------------------------------------------
// AmfWrap_SubmitNV12
// ---------------------------------------------------------------------------
extern "C" __declspec(dllexport)
int __stdcall AmfWrap_SubmitNV12(
const uint8_t* pY, const uint8_t* pUV, int stride, int64_t pts)
{
if (!g_Encoder || !g_Context) return AMF_NOT_INITIALIZED;

size_t ySize = (size_t)stride * g_HeightA;
size_t uvSize = (size_t)stride * (g_HeightA / 2);
uint8_t* buf = (uint8_t*)malloc(ySize + uvSize);
if (!buf) return AMF_FAIL;
memcpy(buf, pY, ySize);
memcpy(buf + ySize, pUV, uvSize);

amf::AMFSurfacePtr surface;
AMF_RESULT res = g_Context->CreateSurfaceFromHostNative(
    g_Fmt, g_Width, g_HeightA, stride, g_HeightA,
    buf, &surface, nullptr);

if (res != AMF_OK) {
    free(buf);
    SetErr(L"CreateSurfaceFromHostNative falhou", res);
    return res;
}

surface->SetPts(pts);

// Converter para DX11 antes do SubmitInput -- garante que o AMF
// fez a copia do buffer host para GPU antes de liberarmos buf.
res = surface->Convert(amf::AMF_MEMORY_DX11);
if (res != AMF_OK) {
    // Convert falhou -- tentar submeter mesmo assim (alguns drivers nao precisam)
    res = AMF_OK;
}

// buf pode ser liberado agora -- Convert garante a copia para GPU
free(buf);

return g_Encoder->SubmitInput(surface);

}

// ---------------------------------------------------------------------------
// AmfWrap_QueryNAL
// ---------------------------------------------------------------------------
extern "C" __declspec(dllexport)
int __stdcall AmfWrap_QueryNAL(uint8_t* pBuf, int bufSize, int* pWritten)
{
if (!g_Encoder) return AMF_NOT_INITIALIZED;
*pWritten = 0;

amf::AMFDataPtr data;
AMF_RESULT res = g_Encoder->QueryOutput(&data);
if (res == AMF_REPEAT || res == AMF_EOF || !data) return 1;
if (res != AMF_OK) return res;

amf::AMFBufferPtr buf(data);
if (!buf) return 1;

size_t sz = buf->GetSize();
if ((int)sz > bufSize) sz = (size_t)bufSize;
memcpy(pBuf, buf->GetNative(), sz);
*pWritten = (int)sz;
return AMF_OK;

}

// ---------------------------------------------------------------------------
// AmfWrap_Drain
// ---------------------------------------------------------------------------
extern "C" __declspec(dllexport)
int __stdcall AmfWrap_Drain()
{
if (!g_Encoder) return AMF_NOT_INITIALIZED;
return g_Encoder->Drain();
}

// ---------------------------------------------------------------------------
// AmfWrap_Shutdown
// ---------------------------------------------------------------------------
extern "C" __declspec(dllexport)
void __stdcall AmfWrap_Shutdown()
{
if (g_Encoder) { g_Encoder->Terminate(); g_Encoder = nullptr; }
if (g_Context) { g_Context->Terminate(); g_Context = nullptr; }
g_Factory = nullptr;
if (g_hAmf) { FreeLibrary(g_hAmf); g_hAmf = nullptr; }
if (g_D3DCtx) { g_D3DCtx->Release(); g_D3DCtx = nullptr; }
if (g_D3DDev) { g_D3DDev->Release(); g_D3DDev = nullptr; }
}

// ---------------------------------------------------------------------------
// AmfWrap_LastError
// ---------------------------------------------------------------------------
extern "C" __declspec(dllexport)
void __stdcall AmfWrap_LastError(wchar_t* pBuf, int cchBuf)
{
if (!pBuf || cchBuf <= 0) return;
wcsncpy_s(pBuf, cchBuf, g_LastErr.c_str(), _TRUNCATE);
}

BOOL APIENTRY DllMain(HMODULE, DWORD, LPVOID) { return TRUE; }

Delphi:
program SimpleEncoder;
{
SimpleEncoder.dpr -- versao usando AmfWrapper.dll (wrapper C++ do AMF SDK)
Delphi 12.1, 64-bit console, Win64.

Pre-requisitos:
1) Compilar AmfWrapper.dll com Visual Studio (ver instrucoes no .cpp)
2) Copiar AmfWrapper.dll para a mesma pasta do .exe
3) amfrt64.dll ja presente em system32 (instalado com driver AMD)

Este arquivo e intencionalmente simples -- toda a complexidade do AMF
(vtables, D3D11, contexto, encoder) esta encapsulada no wrapper C++.
}

{$APPTYPE CONSOLE}

uses
Winapi.Windows,
System.SysUtils,
System.Classes,
AmfWrapper in 'AmfWrapper.pas';

const
WIDTH_IN = 1920;
HEIGHT_IN = 1080;
FPS_IN = 30;
BITRATE_IN = 5000000;
FRAME_COUNT = 500;
OUTPUT_FILE = 'output.h264';
NAL_BUF_SZ = 1024 * 1024; // 1 MB por NAL

// ---------------------------------------------------------------------------
// FillNV12
// Gera frame NV12 sintetico em CPU para teste.
// pY: plano Y (WIDTH_IN * heightAMF bytes)
// pUV: plano UV intercalado (WIDTH_IN * heightAMF/2 bytes)
// ---------------------------------------------------------------------------
procedure FillNV12(pY, pUV: PByte; heightAMF, frameIdx: Integer);
var
stride, row, rectX, rectY: Integer;
pRow: PByte;
begin
stride := WIDTH_IN;
rectX := (frameIdx * 2) mod (WIDTH_IN - 50);
rectY := (frameIdx * 2) mod (heightAMF - 50);

// Plano Y: cinza=128, retangulo branco animado=235
pRow := pY;
for row := 0 to heightAMF - 1 do begin
FillChar(pRow^, stride, 128);
if (row >= rectY) and (row < rectY + 50) then
FillChar(PByte(NativeUInt(pRow) + NativeUInt(rectX))^, 50, 235);
Inc(pRow, stride);
end;

// Plano UV: neutro=128
pRow := pUV;
for row := 0 to (heightAMF div 2) - 1 do begin
FillChar(pRow^, stride, 128);
Inc(pRow, stride);
end;
end;

// ---------------------------------------------------------------------------
// Programa principal
// ---------------------------------------------------------------------------
var
Ret : Integer;
HeightAMF : Integer;
pY, pUV : PByte;
YSize, UVSize: NativeUInt;
NalBuf : PByte;
Written : Integer;
Submitted : Integer;
DrainedNAL : Integer;
FStream : TFileStream;
ExeDir : string;
ErrBuf : array[0..511] of WideChar;

begin
Writeln('=== SimpleEncoder (via AmfWrapper.dll) ===');
ExeDir := ExtractFilePath(ParamStr(0));
HeightAMF := (HEIGHT_IN + 15) and not 15; // alinhar a 16 = 1088

// Inicializar encoder
Writeln(Format('Init: %dx%d (AMF: %dx%d) @ %d fps %d kbps',
[WIDTH_IN, HEIGHT_IN, WIDTH_IN, HeightAMF, FPS_IN, BITRATE_IN div 1000]));

Ret := AmfWrap_Init(WIDTH_IN, HEIGHT_IN, FPS_IN, BITRATE_IN);
if Ret <> AMFW_OK then begin
AmfWrap_LastError(@ErrBuf[0], Length(ErrBuf));
Writeln('ERRO AmfWrap_Init: ', string(ErrBuf), ' (code=', Ret, ')');
ExitCode := 1; Exit;
end;
Writeln('Encoder iniciado OK');

// Alocar buffers
YSize := NativeUInt(WIDTH_IN) * NativeUInt(HeightAMF);
UVSize := YSize div 2;
GetMem(pY, YSize);
GetMem(pUV, UVSize);
GetMem(NalBuf, NAL_BUF_SZ);

FStream := TFileStream.Create(ExeDir + OUTPUT_FILE, fmCreate);
Writeln('Saida: ', ExeDir + OUTPUT_FILE);
Writeln('Encodando ', FRAME_COUNT, ' frames...');

Submitted := 0;

while Submitted < FRAME_COUNT do begin

// Gerar frame sintetico
FillNV12(pY, pUV, HeightAMF, Submitted);

// Submeter frame
repeat
  Ret := AmfWrap_SubmitNV12(pY, pUV, WIDTH_IN, Int64(Submitted) * 333333);
  if Ret = AMFW_INPUT_FULL then
    Sleep(1); // encoder cheio -- aguardar
until Ret <> AMFW_INPUT_FULL;

if (Ret <> AMFW_OK) then begin
  AmfWrap_LastError(@ErrBuf[0], Length(ErrBuf));
  Writeln('ERRO SubmitNV12 frame=', Submitted, ': ', string(ErrBuf));
  Break;
end;

Inc(Submitted);
if Submitted mod 50 = 0 then
  Write(Submitted, '/', FRAME_COUNT, ' frames'#13);

// Drenar saida disponivel
repeat
  Written := 0;
  Ret := AmfWrap_QueryNAL(NalBuf, NAL_BUF_SZ, @Written);
  if (Ret = AMFW_OK) and (Written > 0) then
    FStream.WriteBuffer(NalBuf^, Written);
until Ret <> AMFW_OK;

end;

Writeln;
Writeln('Submetidos: ', Submitted, ' frames');

// Drain
Writeln('Drenando encoder...');
AmfWrap_Drain;

DrainedNAL := 0;
repeat
Written := 0;
Ret := AmfWrap_QueryNAL(NalBuf, NAL_BUF_SZ, @written);
if (Ret = AMFW_OK) and (Written > 0) then begin
FStream.WriteBuffer(NalBuf^, Written);
Inc(DrainedNAL);
end else if Ret <> AMFW_NO_DATA then
Sleep(1); // aguardar mais NALs
until Ret = AMFW_NO_DATA;
Writeln('Drain: ', DrainedNAL, ' NALs adicionais');

FStream.Free;
FreeMem(NalBuf);
FreeMem(pUV);
FreeMem(pY);

AmfWrap_Shutdown;

Writeln('=== Concluido: ', ExeDir + OUTPUT_FILE, ' ===');
Writeln('Verificar com: ffprobe output.h264');
ExitCode := 0;
end.

Again, thank you very much for the help!

[miguelandradedotcom]

What Was Built

3-Layer Architecture
MySoftware (Delphi)
↓ calls
AmfWrapper.dll (C++ / Visual Studio)
↓ uses
amfrt64.dll (AMD AMF Runtime — already installed with the driver)

AmfWrapper.cpp — The C++ Layer
The original problem was that the AMF SDK uses COM-like interface vtables in C++, which are impossible to call directly from Delphi.
The wrapper solves this by exposing 5 pure C functions using __stdcall:
Function
Purpose
AmfWrap_Init(w, h, fps, bitrate)
Initializes D3D11 + AMF + creates the encoder (tries AVC first, falls back to HEVC, tests NV12/BGRA/RGBA formats)
AmfWrap_SubmitNV12(pY, pUV, stride, pts)
Copies an NV12 frame from RAM to the GPU using CreateSurfaceFromHostNative + Convert(DX11)
AmfWrap_QueryNAL(pBuf, bufSize, pWritten)
Drains encoded output (non-blocking)
AmfWrap_Drain()
Signals end of stream
AmfWrap_Shutdown()
Releases all resources
AmfWrap_LastError(pBuf, cch)
Returns the last error as wchar_t
One smart detail: it performs automatic probing — testing AVC and HEVC, and for each codec it tests multiple pixel formats — ensuring compatibility across different generations of AMD GPUs.

AmfWrapper.pas + SimpleEncoder_wrapper.dpr — The Delphi Side
The .pas file is a clean binding unit:
it declares the 6 functions using external 'AmfWrapper.dll' with stdcall, defines the return constants (AMFW_OK=0, AMFW_NO_DATA=1, AMFW_INPUT_FULL=6), and includes a helper AmfLastErrorStr to convert wchar_t* into a Delphi string.
The .dpr demonstrates the complete workflow:
• AmfWrap_Init → initializes the encoder
• Generates synthetic NV12 frames on the CPU (FillNV12)
• Loop: SubmitNV12 (with retry on AMFW_INPUT_FULL) + interleaved QueryNAL
• Drain + final QueryNAL loop until AMFW_NO_DATA
• Shutdown

[MikhailAMD]

I am glad that you found the solution. Just one comment:
While AMF APIs are C++ interfaces, AMF can be called directly from C applications. It was integrated into FFmpeg and other C apps. The implementation of v-tables for C is very similar to D3D11 or D3D12. If you can call them from Delphi, you can call AMF. Though, wrapper is probably simpler and makes more sense.

[miguelandradedotcom]

Thank you for the clarification, Mikhail. That's exactly the approach we ended up taking — the vtable layout follows the same pattern as D3D11/D3D12, and once the slot offsets are correct it works fine from Delphi.
A few findings that might be useful for other developers calling AMF from non-C++ languages:

1. Surface format enum values — AMF_SURFACE_NV12 = 1, not 7. In C++ the compiler enforces the enum type so this is never an issue, but in Delphi/C everything is an integer and the wrong value silently passes through. AMF_SURFACE_BGRA = 3, AMF_SURFACE_YUV420P = 7. Same for AMF_VARIANT_INT64 = 2 and AMF_VARIANT_RATE = 7 in the variant struct — getting these wrong means SetProperty accepts the call but the encoder ignores the value and uses its internal defaults.
2. CreateSurfaceFromHostNative parameter order — the correct order per Context.h is (pThis, out ppSurface, pObserver, format, width, height, hPitch, vPitch, pData). The output pointer and observer come before the format and dimensions, not after. Easy to miss without the C++ type checker.
3. Context initialization for HOST surfaces on Cezanne APU (driver 1.4.31) — CreateSurfaceFromHostNative returns AMF_NOT_INITIALIZED (0x04) when called on a context that was initialized with an external D3D11 device via InitDX11(pDevice). The fix is to call InitDX11(nullptr) instead, letting AMF create its own internal device. This matches what FFmpeg does by default and works correctly on this hardware.
   We ended up shipping both approaches: the C++ wrapper DLL (AmfWrapper.dll) for simplicity, and the corrected native Delphi vtable implementation for the cases where an external DLL dependency is not desirable.