Build Options:
--msvc 設(shè)定 msvc 版本，包括[2013, 2015, 2017, 2019, 2022]
bmf_ffmpeg 控制是否集成 FFmpeg 相關(guān)能力并編譯 built-in module
--preset 編譯配置，包括[x86-Debug, x86-Release, x64-Debug, x64-Release]

export INCLUDE="$INCLUDE;C:\path\to\include_for_ffmpeg"

./build_win_lite.sh --msvc=2022 --preset=x64-Debug bmf_ffmpeg

cmake --build build_win_lite/x64-Debug --config Debug --target ALL_BUILD

export PYTHONHOME="$(dirname "$(which python)")"
export PYTHONPATH=$(pwd)/output/bmf/lib:$(pwd)/output

from bmf import Module, Log, LogLevel, InputType, ProcessResult, Packet, Timestamp, scale_av_pts, av_time_base, \
    BmfCallBackType, VideoFrame, AudioFrame


class my_module(Module):

    def __init__(self, node, optinotallow=None):
        self.node_ = node
        self.option_ = option
        pass

    def process(self, task):
        for (input_id, input_packets) in task.get_inputs().items():

            ## output queue
            output_packets = task.get_outputs()[input_id]

            while not input_packets.empty():
                pkt = input_packets.get()

                ## process EOS
                if pkt.timestamp == Timestamp.EOF:
                    Log.log_node(LogLevel.DEBUG, task.get_node(),
                                 "Receive EOF")
                    output_packets.put(Packet.generate_eof_packet())
                    task.timestamp = Timestamp.DONE
                    return ProcessResult.OK

                ## copy input packet to output
                if pkt.defined() and pkt.timestamp != Timestamp.UNSET:
                    output_packets.put(pkt)

        return ProcessResult.OK

import sys
import time
import unittest

sys.path.append("../../..")
sys.path.append("../../c_module_sdk/build/bin/lib")
import bmf
import os
if os.name == 'nt':
    ## We redefine timeout_decorator on windows
    class timeout_decorator:

        @staticmethod
        def timeout(*args, **kwargs):
            return lambda f: f  ## return a no-op decorator
else:
    import timeout_decorator

sys.path.append("../../test/")
from base_test.base_test_case import BaseTestCase
from base_test.media_info import MediaInfo


class TestCustomizeModule(BaseTestCase):

    @timeout_decorator.timeout(secnotallow=120)
    def test_customize_module(self):
        input_video_path = "../../files/big_bunny_10s_30fps.mp4"
        output_path = "./output.mp4"
        expect_result = '|1080|1920|10.0|MOV,MP4,M4A,3GP,3G2,MJ2|1783292|2229115|h264|' \
                        '{"fps": "30.0662251656"}'
        self.remove_result_data(output_path)
        (bmf.graph().decode({'input_path': input_video_path
                             })['video'].module('my_module').encode(
                                 None, {
                                     "output_path": output_path
                                 }).run())
        self.check_video_diff(output_path, expect_result)


if __name__ == '__main__':
    unittest.main()

(cd output && wget https://github.com/BabitMF/bmf/releases/download/files/files.tar.gz && tar xvf files.tar.gz && rm -rf files.tar.gz)

cd test/customize_module
python test_customize_module.py

#ifndef ROI_Module_H
#define ROI_Module_H
#include <bmf/sdk/module.h>
#include <bmf/sdk/task.h>
#include <d3d11_common.h>
USE_BMF_SDK_NS

class D3DResizeModule : public Module {
public:
  D3DResizeModule(int node_id, JsonParam option);
  int32_t init();
  // DirectX 側(cè)初始化函數(shù)，需通過(guò)配置流成功配置 device_、device_context_ 后觸發(fā)
  int32_t unsafe_init();
  int32_t init_d3d11();
  // 模塊處理函數(shù)，由 BMF 框架驅(qū)動(dòng)調(diào)用
  int32_t process(Task &task);
  int32_t unsafe_process(Task &task);
  int32_t close();
  // UAV 功能檢測(cè)函數(shù)
  bool checkUAVFeature();
  ~D3DResizeModule();

  JsonParam option_;
  bool inited = false;
  int width_ = 0;
  int height_ = 0;
  int inputWidth_ = 0;
  int inputHeight_ = 0;

  BMFComPtr<ID3D11ComputeShader> processShader = nullptr;
  BMFComPtr<ID3D11Buffer> outputSizebuf = nullptr;
  BMFComPtr<ID3D11SamplerState> sampleState = nullptr;
  ID3D11Device *device_ = nullptr;
  ID3D11DeviceContext *device_context_ = nullptr;
};

#endif

#ifndef D3D11_COMMON__H
#define D3D11_COMMON__H
#include <d3d11.h>
#include <wrl/client.h>
#include <d3dcompiler.h>
#include <string>
#include <vector>
struct D3D11DeviceWrapper {
    ID3D11Device *device;
};

struct D3D11DeviceContextWrapper {
    ID3D11DeviceContext *device_context;
};

struct D3D11TextureWrapper {
    ID3D11Texture2D *texture;
};

struct InputSizeBuffer
{
    uint32_t inWidth;
    uint32_t inHeight;
    float padding[2];
};

struct OutputSizeBuffer
{
    uint32_t outWidth;
    uint32_t outHeight;
    float padding[2];
};

template <class T>
using BMFComPtr = Microsoft::WRL::ComPtr<T>;

extern bool CreateTexture(ID3D11Texture2D** texture, ID3D11Device* d3dDevice, int width, int height, DXGI_FORMAT format, const void* initData, D3D11_BIND_FLAG bindflag, int pixelbit, int bitSize);

extern bool CreateUAV(ID3D11UnorderedAccessView** uav, ID3D11Device* d3dDevice, D3D11_UNORDERED_ACCESS_VIEW_DESC* desc, ID3D11Texture2D* texture);

extern bool CreateSRV(ID3D11ShaderResourceView** srv, ID3D11Device* d3dDevice, D3D11_SHADER_RESOURCE_VIEW_DESC* desc, ID3D11Texture2D* texture);

extern bool createComputeShader(ID3D11ComputeShader** shader_, const std::string& shader, ID3D11Device* device);

extern bool CreateStagingTexture(ID3D11Texture2D** stagingTexture, ID3D11Device* device, int width, int height, DXGI_FORMAT format);

extern bool CreateSampleState(ID3D11SamplerState** state, ID3D11Device* device);

// ...

#endif

static std::map<std::string, std::string> hlslMap = {  
    { "gpuresize", R"(
        // Define a linear sampler state
        SamplerState LinearSampler : register(s0);
        Texture2D RGBATexture : register(t0);
        cbuffer OutputSize : register(b0)
        {
            uint outWidth;
            uint outHeight;
        };
        RWTexture2D<float4> RGBOutput : register(u0);

        // bgra -> scale -> rgba
        [numthreads(16, 16, 1)]
        void CSMain(uint3 dtid : SV_DispatchThreadID)
        {
            if (dtid.x >= outWidth || dtid.y >= outHeight)
                return;
            
            float2 samplepoint = (float2(dtid.xy) + float2(0.5, 0.5)) / float2(outWidth, outHeight);
            float4 rgba = RGBATexture.SampleLevel(LinearSampler, samplepoint, 0);
            RGBOutput[dtid.xy] = rgba;
        }
    )" }
};

int32_t D3DResizeModule::process(Task &task) {
  try {
    int32_t res = unsafe_process(task);
    return res;
  } catch (std::exception &e) {
    BMFLOG(BMF_INFO) << "ROI module process throws std::exception: "
                     << e.what();
    throw e;
    return -1;
  } 
}

int32_t D3DResizeModule::unsafe_process(Task& task) {
    if (!inited) {
        bmf_sdk::Packet d3d11_packet;
        while (task.pop_packet_from_input_queue(0, d3d11_packet)) {
            if (d3d11_packet.timestamp() == bmf_sdk::BMF_EOF) {
                task.set_timestamp(bmf_sdk::DONE);
                task.fill_output_packet(0, bmf_sdk::Packet::generate_eof_packet());
                break;
            }

            if (d3d11_packet.is<D3D11DeviceWrapper>()) {
                device_ = d3d11_packet.get<D3D11DeviceWrapper>().device;
            }
            else if (d3d11_packet.is<D3D11DeviceContextWrapper>()) {
                device_context_ = d3d11_packet.get<D3D11DeviceContextWrapper>().device_context;
            }
            else {
                BMFLOG_NODE(BMF_WARNING, node_id_) << "get unexpected data:" << d3d11_packet.type_info().name << std::endl;
            }
        }
        if (device_ && device_context_) {
            init_d3d11();
        }
    }

    bmf_sdk::Packet frame_packet;
    int textureStyle = -1; 
    while (task.pop_packet_from_input_queue(1, frame_packet)) {
        if (frame_packet.timestamp() == bmf_sdk::BMF_EOF) {
            task.set_timestamp(bmf_sdk::DONE);
            task.fill_output_packet(0, bmf_sdk::Packet::generate_eof_packet());
            break;
        }
        if (!frame_packet.is<D3D11TextureWrapper>()) {
            BMFLOG_NODE(BMF_ERROR, node_id_) << "get unexpected data:" << frame_packet.type_info().name << std::endl;
        }
        D3D11TextureWrapper inputPkt = frame_packet.get<D3D11TextureWrapper>();
        ID3D11Texture2D* input_texture = inputPkt.texture;
        if (!input_texture) {
            throw std::exception("null texture input!");
        }
        
        ID3D11Texture2D *outputTexture = nullptr;
        CreateTexture(&outputTexture, device_, width_, height_, DXGI_FORMAT_R8G8B8A8_UNORM, nullptr, (D3D11_BIND_FLAG)(D3D11_BIND_UNORDERED_ACCESS), 4, sizeof(uint8_t));
        BMFComPtr<ID3D11ShaderResourceView> input_srv;
        BMFComPtr<ID3D11UnorderedAccessView> output_texture_uav;

        D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc;
        ZeroMemory(&srvDesc, sizeof(srvDesc));
        srvDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
        srvDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
        srvDesc.Texture2D.MostDetailedMip = 0;
        srvDesc.Texture2D.MipLevels = 1;

        if (!CreateSRV(input_srv.GetAddressOf(), device_, &srvDesc, input_texture)) {
            throw std::exception("input_srv create failed");
        }
        if (!CreateUAV(output_texture_uav.GetAddressOf(), device_, nullptr, outputTexture)) {
            throw std::exception("output_texture_uav create failed!");
        }

        // flush the DirectX resource
        ID3D11ShaderResourceView* null_srv = nullptr;
        ID3D11UnorderedAccessView* null_uav = nullptr;
        ID3D11Buffer* null_buf = nullptr;
        ID3D11SamplerState* null_sample = nullptr;
        ID3D11ComputeShader* null_shader = nullptr;
        device_context_->CSSetShaderResources(0, 1, &null_srv);
        device_context_->CSSetUnorderedAccessViews(0, 1, &null_uav, nullptr);
        device_context_->CSSetConstantBuffers(0, 1, &null_buf);
        device_context_->CSSetSamplers(0, 1, &null_sample); 
        device_context_->CSSetShader(null_shader, nullptr, 0);
    
        // execute the resize shader
        device_context_->CSSetShaderResources(0, 1, input_srv.GetAddressOf()); 
        device_context_->CSSetUnorderedAccessViews(0, 1, output_texture_uav.GetAddressOf(), nullptr);
        device_context_->CSSetShader(processShader.Get(), nullptr, 0);
        device_context_->CSSetConstantBuffers(0, 1, outputSizebuf.GetAddressOf());
        device_context_->CSSetSamplers(0, 1, sampleState.GetAddressOf());
        device_context_->Dispatch((width_ - 1 + 16) / 16, (height_ - 1 + 16) / 16, 1); 
        
        D3D11TextureWrapper outputTextureWrapper;
        outputTextureWrapper.texture = outputTexture;
        bmf_sdk::Packet output_packet(outputTextureWrapper);
        task.fill_output_packet(0, output_packet);
    }
    return 0;
}

int32_t D3DResizeModule::init_d3d11() {
    if (!inited) {
        if (!device_ || !device_context_) {
            throw std::exception("d3d11 device or context is not inited!");
        }
        D3D_FEATURE_LEVEL featureLevel = device_->GetFeatureLevel();

        if (featureLevel < D3D_FEATURE_LEVEL_11_0) {
            throw std::exception("local d3d11 feature level < 11! computeshader cannot work!");
        }
        if (!checkUAVFeature()) {
            throw std::exception("UAV load is not supported in this hardware");
        }
        if (!createComputeShader(processShader.GetAddressOf(), "gpuresize", device_)) {
            throw std::exception("shader compile failed!");
        }

        if (!CreateSampleState(sampleState.GetAddressOf(), device_)) {
            throw std::exception("sample state create failed!");
        }

        OutputSizeBuffer sizeBuffer;
        sizeBuffer.outWidth = width_;
        sizeBuffer.outHeight = height_;

        D3D11_BUFFER_DESC desc;
        ZeroMemory(&desc, sizeof(desc));
        desc.Usage = D3D11_USAGE_DYNAMIC; 
        desc.ByteWidth = sizeof(OutputSizeBuffer);
        desc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
        desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; 
        desc.MiscFlags = 0;
        desc.StructureByteStride = 0;

        D3D11_SUBRESOURCE_DATA initData;
        initData.pSysMem = &sizeBuffer;
        initData.SysMemPitch = 0;
        initData.SysMemSlicePitch = 0;
        HRESULT hr = device_->CreateBuffer(&desc, &initData, outputSizebuf.GetAddressOf());
        if (FAILED(hr)) {
            throw std::exception("constant buffer create failed!");
        }
        inited = true;
    }
}

#include <bmf/sdk/log.h>
#include <bmf/sdk/video_frame.h>
#include <nlohmann/json.hpp>
#include <builder.hpp>
#include <chrono>
#include <d3d11_common.h>
#include <fstream>
using json = nlohmann::json;
using namespace std::chrono;
namespace fs = std::filesystem;

static const int TESTINPUTWIDTH = 720;
static const int TESTINPUTHEIGHT = 1280;
static const int TESTOUTPUTWIDTH = 1080;
static const int TESTOUTPUTHEIGHT = 1920;

static void readRGBAFile(std::vector<uint8_t>& data, const std::string& filename) {
    std::ifstream file(filename, std::ios::binary);

    if (!file) {
        throw std::runtime_error("cannot open yuv file!");
    }

    file.seekg(0, std::ios::end);
    std::streampos fileSize = file.tellg();
    file.seekg(0, std::ios::beg);

    if (fileSize != (TESTINPUTWIDTH * TESTINPUTHEIGHT * 4)) {
        throw std::runtime_error("file size not compared with TESTINPUTWIDTH and TESTINPUTHEIGHT! it should be a RGBA data");
    }

    file.read(reinterpret_cast<char*>(data.data()), fileSize);

    file.close();
}

int main(int argc, char const *argv[])
{
    static const int profile_time = 1;
    HRESULT hr = S_OK;
    BMFComPtr<ID3D11Device> device = nullptr;
    BMFComPtr<ID3D11DeviceContext> context = nullptr;
    BMFComPtr<ID3D11ComputeShader> computeShader = nullptr;
    BMFComPtr<ID3D11Texture2D> input_rgba = nullptr;

    // Initialize device and context
    hr = D3D11CreateDevice(nullptr, D3D_DRIVER_TYPE_HARDWARE, nullptr, 0, nullptr, 0,
        D3D11_SDK_VERSION, &device, nullptr, &context);
    if (FAILED(hr)) {
        std::cerr << "Failed to create D3D11 device" << std::endl;
        exit(EXIT_FAILURE);
    }
    std::vector<uint8_t> filedata(TESTINPUTWIDTH * TESTINPUTHEIGHT * 4, 0);
    readRGBAFile(filedata, "../../../files/test_opencv_lenna_720x1280.rgb");
    ID3DBlob* pBlob = nullptr;

    D3D11_SUBRESOURCE_DATA sd;
    sd.pSysMem = filedata.data();
    sd.SysMemPitch = TESTINPUTWIDTH * sizeof(uint8_t) * 4;
    sd.SysMemSlicePitch = TESTINPUTWIDTH * TESTINPUTHEIGHT * sizeof(uint8_t) * 4;
    CD3D11_TEXTURE2D_DESC texDesC(DXGI_FORMAT_R8G8B8A8_UNORM, TESTINPUTWIDTH, TESTINPUTHEIGHT, 1, 1, (D3D11_BIND_FLAG)(D3D11_BIND_SHADER_RESOURCE), D3D11_USAGE_DEFAULT, 0, 1, 0, D3D11_RESOURCE_MISC_SHARED);

    texDesC.CPUAccessFlags = 0;
    texDesC.MipLevels = 1;
    texDesC.ArraySize = 1;
    hr = device->CreateTexture2D(&texDesC, &sd, &input_rgba);
    if (FAILED(hr)) {
        std::cerr << "Failed to CreateTexture2D" << std::endl;
        exit(EXIT_FAILURE);
    }
    {

        try {
            bmf::builder::Graph graph = bmf::builder::Graph(bmf::builder::GeneratorMode);
            auto input_stream0 = graph.InputStream(
                "config_stream", "stream0", "");
            auto input_stream1 = graph.InputStream(
                "data_stream", "stream1", "");

            json roi_option = {
                {"width", TESTOUTPUTWIDTH},
                {"height", TESTOUTPUTHEIGHT}
            };
            std::string moduleName;
#ifdef _DEBUG
            moduleName = "d3dresizemoduled.dll";
#else
            moduleName = "d3dresizemodule.dll";
#endif
            auto resize_module = graph.CppModule({ input_stream0, input_stream1 }, "d3dresizemodule", bmf_sdk::JsonParam(roi_option),
                "", moduleName, "d3dresizemodule:D3DResizeModule");
            auto resize_output_stream = resize_module.Stream(0);

            std::vector<bmf::builder::Stream> enhanceGenerateStreams;
            enhanceGenerateStreams.emplace_back(resize_output_stream);
            graph.Start(enhanceGenerateStreams);

            D3D11DeviceWrapper device_wrapper;
            D3D11DeviceContextWrapper device_context_wrapper;
            device_wrapper.device = device.Get();
            device_context_wrapper.device_context = context.Get();
            graph.FillPacket(input_stream0.GetName(), bmf_sdk::Packet(device_wrapper));
            graph.FillPacket(input_stream0.GetName(), bmf_sdk::Packet(device_context_wrapper));

            D3D11TextureWrapper input;
            input.texture = input_rgba.Get();
            graph.FillPacket(input_stream1.GetName(), bmf_sdk::Packet(input));

            Packet output_pkt = graph.Generate(resize_output_stream.GetName());
            ID3D11Texture2D* out_texture = nullptr;
            D3D11TextureWrapper output_ = output_pkt.get<D3D11TextureWrapper>();
            out_texture = output_.texture;
            // Read Output and write file local
            std::vector<uint8_t> outdata(TESTOUTPUTWIDTH * TESTOUTPUTHEIGHT * 4, 1);
            ReadDataFromTexture(device.Get(), context.Get(), out_texture, TESTOUTPUTWIDTH, TESTOUTPUTHEIGHT, DXGI_FORMAT_R8G8B8A8_UNORM, outdata, 4);

            std::ofstream outputFile("output.rgb", std::ios::binary);
            if (!outputFile.is_open()) {
                printf("open outputfile error!\n");
            }
            outputFile.write((const char*)outdata.data(), sizeof(uint8_t) * TESTOUTPUTWIDTH * TESTOUTPUTHEIGHT * 4);
            outputFile.close();
            out_texture->Release();
            out_texture = nullptr;
            context->Flush();
            
        }
        catch (const fs::filesystem_error& e) {
            std::cerr << "FileSystem error: " << e.what() << std::endl;
        }
        catch (const std::exception& e) {
            std::cerr << "General error: " << e.what() << std::endl;
        }

    }
    return 0;
}

bmf_demo/
│
├── cmake/
│   ├── win-toolchain.cmake  
├── modules/
│   ├── common/
│   │   ├── d3d11/
│   │   │   ├── include/
│   │   │   ├   ├── d3d11_common.h
│   │   │   ├── src/
│   │   │   ├   ├── d3d11_common.cpp
│   ├── d3d11resizemodule/
│   │   ├── include/
│   │   ├   ├── d3dresizemodule.h
│   │   ├── src/
│   │   ├   ├── d3dresizemodule.cpp
│   │   ├── test/
│   │   ├   ├── test_d3dresizemodule.cpp
│   │   ├── CMakeLists.txt
│   └── ...
│
├── build.sh
├── CMakeLists.txt
└── CMakePresets.json

./build.sh --msvc=2022 --module=d3dresizemodule --bmf-lite --test

export BMF_INCLUDE_DIR=/path/to/bmf/include
export BMF_LIBRARY_DIR=/path/to/bmf/lib

ffplay -pix_fmt rgba -s 1080x1920 output.rgb