D3D11va: add a Direct3D11 video decoder similar to DXVA2

Signed-off-by: Luca Barbato <lu_zero@gentoo.org>

1 files changed, 130 insertions, 31 deletions

diff --git a/libavcodec/dxva2.c b/libavcodec/dxva2.c
index 9ee22c8d56..76a9d54a27 100644
--- a/libavcodec/dxva2.c
+++ b/libavcodec/dxva2.c
@@ -35,14 +35,15 @@ void *ff_dxva2_get_surface(const AVFrame *frame)
     return frame->data[3];
 }
 
-unsigned ff_dxva2_get_surface_index(const struct dxva_context *ctx,
+unsigned ff_dxva2_get_surface_index(const AVCodecContext *avctx,
+                                    const AVDXVAContext *ctx,
                                     const AVFrame *frame)
 {
     void *surface = ff_dxva2_get_surface(frame);
     unsigned i;
 
-    for (i = 0; i < ctx->surface_count; i++)
-        if (ctx->surface[i] == surface)
+    for (i = 0; i < DXVA_CONTEXT_COUNT(avctx, ctx); i++)
+        if (DXVA_CONTEXT_SURFACE(avctx, ctx, i) == surface)
             return i;
 
     assert(0);
@@ -50,8 +51,8 @@ unsigned ff_dxva2_get_surface_index(const struct dxva_context *ctx,
 }
 
 int ff_dxva2_commit_buffer(AVCodecContext *avctx,
-                           struct dxva_context *ctx,
-                           DXVA2_DecodeBufferDesc *dsc,
+                           AVDXVAContext *ctx,
+                           DECODER_BUFFER_DESC *dsc,
                            unsigned type, const void *data, unsigned size,
                            unsigned mb_count)
 {
@@ -60,8 +61,18 @@ int ff_dxva2_commit_buffer(AVCodecContext *avctx,
     int      result;
     HRESULT hr;
 
-    hr = IDirectXVideoDecoder_GetBuffer(ctx->decoder, type,
-                                        &dxva_data, &dxva_size);
+#if CONFIG_D3D11VA
+    if (avctx->pix_fmt == AV_PIX_FMT_D3D11VA_VLD)
+        hr = ID3D11VideoContext_GetDecoderBuffer(D3D11VA_CONTEXT(ctx)->video_context,
+                                                 D3D11VA_CONTEXT(ctx)->decoder,
+                                                 type,
+                                                 &dxva_size, &dxva_data);
+#endif
+#if CONFIG_DXVA2
+    if (avctx->pix_fmt == AV_PIX_FMT_DXVA2_VLD)
+        hr = IDirectXVideoDecoder_GetBuffer(DXVA2_CONTEXT(ctx)->decoder, type,
+                                            &dxva_data, &dxva_size);
+#endif
     if (FAILED(hr)) {
         av_log(avctx, AV_LOG_ERROR, "Failed to get a buffer for %u: 0x%lx\n",
                type, hr);
@@ -70,10 +81,24 @@ int ff_dxva2_commit_buffer(AVCodecContext *avctx,
     if (size <= dxva_size) {
         memcpy(dxva_data, data, size);
 
-        memset(dsc, 0, sizeof(*dsc));
-        dsc->CompressedBufferType = type;
-        dsc->DataSize             = size;
-        dsc->NumMBsInBuffer       = mb_count;
+#if CONFIG_D3D11VA
+        if (avctx->pix_fmt == AV_PIX_FMT_D3D11VA_VLD) {
+            D3D11_VIDEO_DECODER_BUFFER_DESC *dsc11 = dsc;
+            memset(dsc11, 0, sizeof(*dsc11));
+            dsc11->BufferType           = type;
+            dsc11->DataSize             = size;
+            dsc11->NumMBsInBuffer       = mb_count;
+        }
+#endif
+#if CONFIG_DXVA2
+        if (avctx->pix_fmt == AV_PIX_FMT_DXVA2_VLD) {
+            DXVA2_DecodeBufferDesc *dsc2 = dsc;
+            memset(dsc2, 0, sizeof(*dsc2));
+            dsc2->CompressedBufferType = type;
+            dsc2->DataSize             = size;
+            dsc2->NumMBsInBuffer       = mb_count;
+        }
+#endif
 
         result = 0;
     } else {
@@ -81,7 +106,14 @@ int ff_dxva2_commit_buffer(AVCodecContext *avctx,
         result = -1;
     }
 
-    hr = IDirectXVideoDecoder_ReleaseBuffer(ctx->decoder, type);
+#if CONFIG_D3D11VA
+    if (avctx->pix_fmt == AV_PIX_FMT_D3D11VA_VLD)
+        hr = ID3D11VideoContext_ReleaseDecoderBuffer(D3D11VA_CONTEXT(ctx)->video_context, D3D11VA_CONTEXT(ctx)->decoder, type);
+#endif
+#if CONFIG_DXVA2
+    if (avctx->pix_fmt == AV_PIX_FMT_DXVA2_VLD)
+        hr = IDirectXVideoDecoder_ReleaseBuffer(DXVA2_CONTEXT(ctx)->decoder, type);
+#endif
     if (FAILED(hr)) {
         av_log(avctx, AV_LOG_ERROR,
                "Failed to release buffer type %u: 0x%lx\n",
@@ -95,20 +127,31 @@ int ff_dxva2_common_end_frame(AVCodecContext *avctx, AVFrame *frame,
                               const void *pp, unsigned pp_size,
                               const void *qm, unsigned qm_size,
                               int (*commit_bs_si)(AVCodecContext *,
-                                                  DXVA2_DecodeBufferDesc *bs,
-                                                  DXVA2_DecodeBufferDesc *slice))
+                                                  DECODER_BUFFER_DESC *bs,
+                                                  DECODER_BUFFER_DESC *slice))
 {
-    struct dxva_context *ctx = avctx->hwaccel_context;
+    AVDXVAContext *ctx = avctx->hwaccel_context;
     unsigned               buffer_count = 0;
-    DXVA2_DecodeBufferDesc buffer[4];
-    DXVA2_DecodeExecuteParams exec = { 0 };
+    D3D11_VIDEO_DECODER_BUFFER_DESC buffer11[4];
+    DXVA2_DecodeBufferDesc          buffer2[4];
+    DECODER_BUFFER_DESC             *buffer,*buffer_slice;
     int result, runs = 0;
     HRESULT hr;
+    unsigned type;
 
     do {
-        hr = IDirectXVideoDecoder_BeginFrame(ctx->decoder,
-                                             ff_dxva2_get_surface(frame),
-                                             NULL);
+#if CONFIG_D3D11VA
+        if (avctx->pix_fmt == AV_PIX_FMT_D3D11VA_VLD)
+            hr = ID3D11VideoContext_DecoderBeginFrame(D3D11VA_CONTEXT(ctx)->video_context, D3D11VA_CONTEXT(ctx)->decoder,
+                                                      ff_dxva2_get_surface(frame),
+                                                      0, NULL);
+#endif
+#if CONFIG_DXVA2
+        if (avctx->pix_fmt == AV_PIX_FMT_DXVA2_VLD)
+            hr = IDirectXVideoDecoder_BeginFrame(DXVA2_CONTEXT(ctx)->decoder,
+                                                 ff_dxva2_get_surface(frame),
+                                                 NULL);
+#endif
         if (hr == E_PENDING)
             av_usleep(2000);
     } while (hr == E_PENDING && ++runs < 50);
@@ -118,8 +161,20 @@ int ff_dxva2_common_end_frame(AVCodecContext *avctx, AVFrame *frame,
         return -1;
     }
 
-    result = ff_dxva2_commit_buffer(avctx, ctx, &buffer[buffer_count],
-                                    DXVA2_PictureParametersBufferType,
+#if CONFIG_D3D11VA
+    if (avctx->pix_fmt == AV_PIX_FMT_D3D11VA_VLD) {
+        buffer = &buffer11[buffer_count];
+        type = D3D11_VIDEO_DECODER_BUFFER_PICTURE_PARAMETERS;
+    }
+#endif
+#if CONFIG_DXVA2
+    if (avctx->pix_fmt == AV_PIX_FMT_DXVA2_VLD) {
+        buffer = &buffer2[buffer_count];
+        type = DXVA2_PictureParametersBufferType;
+    }
+#endif
+    result = ff_dxva2_commit_buffer(avctx, ctx, buffer,
+                                    type,
                                     pp, pp_size, 0);
     if (result) {
         av_log(avctx, AV_LOG_ERROR,
@@ -129,8 +184,20 @@ int ff_dxva2_common_end_frame(AVCodecContext *avctx, AVFrame *frame,
     buffer_count++;
 
     if (qm_size > 0) {
-        result = ff_dxva2_commit_buffer(avctx, ctx, &buffer[buffer_count],
-                                        DXVA2_InverseQuantizationMatrixBufferType,
+#if CONFIG_D3D11VA
+        if (avctx->pix_fmt == AV_PIX_FMT_D3D11VA_VLD) {
+            buffer = &buffer11[buffer_count];
+            type = D3D11_VIDEO_DECODER_BUFFER_INVERSE_QUANTIZATION_MATRIX;
+        }
+#endif
+#if CONFIG_DXVA2
+        if (avctx->pix_fmt == AV_PIX_FMT_DXVA2_VLD) {
+            buffer = &buffer2[buffer_count];
+            type = DXVA2_InverseQuantizationMatrixBufferType;
+        }
+#endif
+        result = ff_dxva2_commit_buffer(avctx, ctx, buffer,
+                                        type,
                                         qm, qm_size, 0);
         if (result) {
             av_log(avctx, AV_LOG_ERROR,
@@ -140,9 +207,22 @@ int ff_dxva2_common_end_frame(AVCodecContext *avctx, AVFrame *frame,
         buffer_count++;
     }
 
+#if CONFIG_D3D11VA
+    if (avctx->pix_fmt == AV_PIX_FMT_D3D11VA_VLD) {
+        buffer       = &buffer11[buffer_count + 0];
+        buffer_slice = &buffer11[buffer_count + 1];
+    }
+#endif
+#if CONFIG_DXVA2
+    if (avctx->pix_fmt == AV_PIX_FMT_DXVA2_VLD) {
+        buffer       = &buffer2[buffer_count + 0];
+        buffer_slice = &buffer2[buffer_count + 1];
+    }
+#endif
+
     result = commit_bs_si(avctx,
-                          &buffer[buffer_count + 0],
-                          &buffer[buffer_count + 1]);
+                          buffer,
+                          buffer_slice);
     if (result) {
         av_log(avctx, AV_LOG_ERROR,
                "Failed to add bitstream or slice control buffer\n");
@@ -154,17 +234,36 @@ int ff_dxva2_common_end_frame(AVCodecContext *avctx, AVFrame *frame,
 
     assert(buffer_count == 1 + (qm_size > 0) + 2);
 
-    exec.NumCompBuffers      = buffer_count;
-    exec.pCompressedBuffers  = buffer;
-    exec.pExtensionData      = NULL;
-    hr = IDirectXVideoDecoder_Execute(ctx->decoder, &exec);
+#if CONFIG_D3D11VA
+    if (avctx->pix_fmt == AV_PIX_FMT_D3D11VA_VLD)
+        hr = ID3D11VideoContext_SubmitDecoderBuffers(D3D11VA_CONTEXT(ctx)->video_context,
+                                                     D3D11VA_CONTEXT(ctx)->decoder,
+                                                     buffer_count, buffer11);
+#endif
+#if CONFIG_DXVA2
+    if (avctx->pix_fmt == AV_PIX_FMT_DXVA2_VLD) {
+        DXVA2_DecodeExecuteParams exec = {
+            .NumCompBuffers     = buffer_count,
+            .pCompressedBuffers = buffer2,
+            .pExtensionData     = NULL,
+        };
+        hr = IDirectXVideoDecoder_Execute(DXVA2_CONTEXT(ctx)->decoder, &exec);
+    }
+#endif
     if (FAILED(hr)) {
         av_log(avctx, AV_LOG_ERROR, "Failed to execute: 0x%lx\n", hr);
         result = -1;
     }
 
 end:
-    hr = IDirectXVideoDecoder_EndFrame(ctx->decoder, NULL);
+#if CONFIG_D3D11VA
+    if (avctx->pix_fmt == AV_PIX_FMT_D3D11VA_VLD)
+        hr = ID3D11VideoContext_DecoderEndFrame(D3D11VA_CONTEXT(ctx)->video_context, D3D11VA_CONTEXT(ctx)->decoder);
+#endif
+#if CONFIG_DXVA2
+    if (avctx->pix_fmt == AV_PIX_FMT_DXVA2_VLD)
+        hr = IDirectXVideoDecoder_EndFrame(DXVA2_CONTEXT(ctx)->decoder, NULL);
+#endif
     if (FAILED(hr)) {
         av_log(avctx, AV_LOG_ERROR, "Failed to end frame: 0x%lx\n", hr);
         result = -1;