ADLXPybind 

Demonstrates how to wrap ADLX with pybind11 when programming with ADLX.

Sample Path

/Samples/python/ADLXPybind

Code 

//
// Copyright (c) 2021 - 2022 Advanced Micro Devices, Inc. All rights reserved.
//
//-------------------------------------------------------------------------------------------------

// Include pybind11 depends
#include <pybind11/pybind11.h>
#include <pybind11/stl.h>
#include <pybind11/complex.h>
#include <pybind11/functional.h>
#include <pybind11/chrono.h>

// Include SDK depends
#include "../../../../SDK/ADLXHelper/Windows/Cpp/ADLXHelper.h"
#include "../../../../SDK/Include/IDisplays.h"

namespace py = pybind11;
using namespace adlx;

// Always needed for custom holder types
PYBIND11_DECLARE_HOLDER_TYPE(T, IADLXInterfacePtr_T<T>, true);

// Only needed if the type's `.get()` goes by another name
namespace pybind11 {
    namespace detail {
        template <typename T>
        struct holder_helper<IADLXInterfacePtr_T<T>> { // <-- specialization
            static const T *get(const IADLXInterfacePtr_T<T> &p) { return p.GetPtr(); }
        };
    }
}

class PySystem : public IADLXSystem
{
public:
    using IADLXSystem::IADLXSystem;

    ADLX_RESULT   HybridGraphicsType(ADLX_HG_TYPE * hgType)override {
        PYBIND11_OVERRIDE_PURE(
            ADLX_RESULT ,
            IADLXSystem,
            HybridGraphicsType
        );
    }

    ADLX_RESULT   GetGPUs(IADLXGPUList** ppGPUs)override {
        PYBIND11_OVERRIDE_PURE(
            ADLX_RESULT ,
            IADLXSystem,
            GetGPUs
        );
    }

    ADLX_RESULT   QueryInterface(const wchar_t* interfaceId, void** ppInterface)override {
        PYBIND11_OVERRIDE_PURE(
            ADLX_RESULT ,
            IADLXSystem,
            QueryInterface
        );
    }

    ADLX_RESULT   GetDisplaysServices(IADLXDisplayServices** ppDispServices)override {
        PYBIND11_OVERRIDE_PURE(
            ADLX_RESULT ,
            IADLXSystem,
            GetDisplaysServices
        );
    }

    ADLX_RESULT   GetDesktopsServices(IADLXDesktopServices** ppDeskServices)override {
        PYBIND11_OVERRIDE_PURE(
            ADLX_RESULT ,
            IADLXSystem,
            GetDesktopsServices
        );
    }

    ADLX_RESULT   GetGPUsChangedHandling(IADLXGPUsChangedHandling** ppGPUsChangedHandling)override {
        PYBIND11_OVERRIDE_PURE(
            ADLX_RESULT ,
            IADLXSystem,
            GetGPUsChangedHandling
        );
    }

    ADLX_RESULT   EnableLog(ADLX_LOG_DESTINATION  mode, ADLX_LOG_SEVERITY  severity, IADLXLog* pLogger, const wchar_t* fileName)override {
        PYBIND11_OVERRIDE_PURE(
            ADLX_RESULT ,
            IADLXSystem,
            EnableLog
        );
    }

    ADLX_RESULT   Get3DSettingsServices(IADLX3DSettingsServices** pp3DSettingsServices)override {
        PYBIND11_OVERRIDE_PURE(
            ADLX_RESULT ,
            IADLXSystem,
            Get3DSettingsServices
        );
    }

    ADLX_RESULT   GetGPUTuningServices(IADLXGPUTuningServices** ppGPUTuningServices)override {
        PYBIND11_OVERRIDE_PURE(
            ADLX_RESULT ,
            IADLXSystem,
            GetGPUTuningServices
        );
    }

    ADLX_RESULT   GetPerformanceMonitoringServices(IADLXPerformanceMonitoringServices** ppPerformanceMonitoringServices)override {
        PYBIND11_OVERRIDE_PURE(
            ADLX_RESULT ,
            IADLXSystem,
            GetPerformanceMonitoringServices
        );
    }

    ADLX_RESULT   TotalSystemRAM(adlx_uint* ramMB)override {
        PYBIND11_OVERRIDE_PURE(
            ADLX_RESULT ,
            IADLXSystem,
            TotalSystemRAM
        );
    }

    ADLX_RESULT   GetI2C(IADLXGPU *pGPU, IADLXI2C **ppI2C) override {
        PYBIND11_OVERRIDE_PURE(
            ADLX_RESULT ,
            IADLXSystem,
            GetI2C
        );
    }
};

class PyDisplayService : public IADLXDisplayServices
{
public:
    using IADLXDisplayServices::IADLXDisplayServices;

    adlx_long  Acquire() override {
        PYBIND11_OVERRIDE_PURE(adlx_long, IADLXInterface, Acquire);
    }

    adlx_long  Release() override {
        PYBIND11_OVERRIDE_PURE(adlx_long, IADLXInterface, Release);
    }

    ADLX_RESULT   QueryInterface(const wchar_t* interfaceId, void** ppInterface) {
        PYBIND11_OVERRIDE_PURE(ADLX_RESULT , IADLXInterface, QueryInterface);
    }

    ADLX_RESULT  GetNumberOfDisplays(adlx_uint* numDisplays) override {
        PYBIND11_OVERRIDE_PURE(ADLX_RESULT , IADLXDisplayServices, GetNumberOfDisplays);
    }

    ADLX_RESULT  GetDisplays(IADLXDisplayList** ppDisplay) override {
        PYBIND11_OVERRIDE_PURE(ADLX_RESULT , IADLXDisplayServices, GetDisplays);
    }

    ADLX_RESULT  Get3DLUT(IADLXDisplay* pDisplay, IADLXDisplay3DLUT** ppDisp3DLUT) override {
        PYBIND11_OVERRIDE_PURE(ADLX_RESULT , IADLXDisplayServices, Get3DLUT);
    }

    ADLX_RESULT  GetGamut(IADLXDisplay* pDisplay, IADLXDisplayGamut** ppDispGamut) override {
        PYBIND11_OVERRIDE_PURE(ADLX_RESULT , IADLXDisplayServices, GetGamut);
    }

    ADLX_RESULT  GetGamma(IADLXDisplay* pDisplay, IADLXDisplayGamma** ppDispGamma) override {
        PYBIND11_OVERRIDE_PURE(ADLX_RESULT , IADLXDisplayServices, GetGamma);
    }

    ADLX_RESULT  GetDisplayChangedHandling(IADLXDisplayChangedHandling** ppDisplayChangeHandling) override {
        PYBIND11_OVERRIDE_PURE(ADLX_RESULT , IADLXDisplayServices, GetDisplayChangedHandling);
    }

    ADLX_RESULT   GetFreeSync(IADLXDisplay* pDisplay, IADLXDisplayFreeSync** ppFreeSync) override {
        PYBIND11_OVERRIDE_PURE(ADLX_RESULT , IADLXDisplayServices, GetFreeSync);
    }

    ADLX_RESULT   GetVirtualSuperResolution(IADLXDisplay* pDisplay, IADLXDisplayVSR** ppVSR) override {
        PYBIND11_OVERRIDE_PURE(ADLX_RESULT , IADLXDisplayServices, GetVirtualSuperResolution);
    }

    ADLX_RESULT   GetGPUScaling(IADLXDisplay* pDisplay, IADLXDisplayGPUScaling** ppGPUScaling) override {
        PYBIND11_OVERRIDE_PURE(ADLX_RESULT , IADLXDisplayServices, GetGPUScaling);
    }

    ADLX_RESULT   GetScalingMode(IADLXDisplay* pDisplay, IADLXDisplayScalingMode** ppScalingMode) override {
        PYBIND11_OVERRIDE_PURE(ADLX_RESULT , IADLXDisplayServices, GetScalingMode);
    }

    ADLX_RESULT   GetIntegerScaling(IADLXDisplay* pDisplay, IADLXDisplayIntegerScaling** ppIntegerScaling) override {
        PYBIND11_OVERRIDE_PURE(ADLX_RESULT , IADLXDisplayServices, GetIntegerScaling);
    }

    ADLX_RESULT   GetColorDepth(IADLXDisplay* pDisplay, IADLXDisplayColorDepth** ppColorDepth) override {
        PYBIND11_OVERRIDE_PURE(ADLX_RESULT , IADLXDisplayServices, GetColorDepth);
    }

    ADLX_RESULT   GetPixelFormat(IADLXDisplay* pDisplay, IADLXDisplayPixelFormat** ppPixelFormat) override {
        PYBIND11_OVERRIDE_PURE(ADLX_RESULT , IADLXDisplayServices, GetPixelFormat);
    }

    ADLX_RESULT   GetCustomColor(IADLXDisplay* pDisplay, IADLXDisplayCustomColor** ppCustomColor) override {
        PYBIND11_OVERRIDE_PURE(ADLX_RESULT , IADLXDisplayServices, GetCustomColor);
    }

    ADLX_RESULT   GetHDCP(IADLXDisplay* pDisplay, IADLXDisplayHDCP** ppHDCP) override {
        PYBIND11_OVERRIDE_PURE(ADLX_RESULT , IADLXDisplayServices, GetHDCP);
    }

    ADLX_RESULT   GetCustomResolution(IADLXDisplay* pDisplay, IADLXDisplayCustomResolution** ppCustomResolution) override {
        PYBIND11_OVERRIDE_PURE(ADLX_RESULT , IADLXDisplayServices, GetCustomResolution);
    }

    ADLX_RESULT   GetVariBright(IADLXDisplay* pDisplay, IADLXDisplayVariBright** ppVariBright) override {
        PYBIND11_OVERRIDE_PURE(ADLX_RESULT , IADLXDisplayServices, GetVariBright);
    }
};

class PyDisplay : public IADLXDisplay
{
public:
    using IADLXDisplay::IADLXDisplay;

    adlx_long  Acquire() override {
        PYBIND11_OVERRIDE_PURE(adlx_long, IADLXInterface, Acquire);
    }

    adlx_long  Release() override {
        PYBIND11_OVERRIDE_PURE(adlx_long, IADLXInterface, Release);
    }

    ADLX_RESULT   QueryInterface(const wchar_t* interfaceId, void** ppInterface) {
        PYBIND11_OVERRIDE_PURE(ADLX_RESULT , IADLXInterface, QueryInterface);
    }

    ADLX_RESULT  ManufacturerID(adlx_uint* manufacturerID) const override {
        PYBIND11_OVERRIDE_PURE(ADLX_RESULT , IADLXDisplay, ManufacturerID);
    }

    ADLX_RESULT  DisplayType(ADLX_DISPLAY_TYPE * displayType) const override {
        PYBIND11_OVERRIDE_PURE(ADLX_RESULT , IADLXDisplay, DisplayType);
    }

    ADLX_RESULT  ConnectorType(ADLX_DISPLAY_CONNECTOR_TYPE * connectType) const override {
        PYBIND11_OVERRIDE_PURE(ADLX_RESULT , IADLXDisplay, ConnectorType);
    }

    ADLX_RESULT  Name(const char** displayName) const override {
        PYBIND11_OVERRIDE_PURE(ADLX_RESULT , IADLXDisplay, Name);
    }

    ADLX_RESULT  EDID(const char** edid) const override {
        PYBIND11_OVERRIDE_PURE(ADLX_RESULT , IADLXDisplay, EDID);
    }

    ADLX_RESULT  NativeResolution(adlx_int* maxHResolution, adlx_int* maxVResolution) const override {
        PYBIND11_OVERRIDE_PURE(ADLX_RESULT , IADLXDisplay, NativeResolution);
    }

    ADLX_RESULT  RefreshRate(adlx_double* refreshRate) const override {
        PYBIND11_OVERRIDE_PURE(ADLX_RESULT , IADLXDisplay, RefreshRate);
    }

    ADLX_RESULT  PixelClock(adlx_uint* pixelClock) const override {
        PYBIND11_OVERRIDE_PURE(ADLX_RESULT , IADLXDisplay, PixelClock);
    }

    ADLX_RESULT  ScanType(ADLX_DISPLAY_SCAN_TYPE * scanType) const override {
        PYBIND11_OVERRIDE_PURE(ADLX_RESULT , IADLXDisplay, ScanType);
    }

    ADLX_RESULT  GetGPU(IADLXGPU** ppGPU) override {
        PYBIND11_OVERRIDE_PURE(ADLX_RESULT , IADLXDisplay, GetGPU);
    }

    ADLX_RESULT  UniqueId(adlx_size* uniqueId) {
        PYBIND11_OVERRIDE_PURE(ADLX_RESULT , IADLXDisplay, UniqueId);
    }
};

class PyDisplayChangeHandler : public IADLXDisplayChangedHandling
{
public:
    using IADLXDisplayChangedHandling::IADLXDisplayChangedHandling;

    adlx_long  Acquire() override {
        PYBIND11_OVERRIDE_PURE(adlx_long, IADLXInterface, Acquire);
    }

    adlx_long  Release() override {
        PYBIND11_OVERRIDE_PURE(adlx_long, IADLXInterface, Release);
    }

    ADLX_RESULT   QueryInterface(const wchar_t* interfaceId, void** ppInterface) {
        PYBIND11_OVERRIDE_PURE(ADLX_RESULT , IADLXInterface, QueryInterface);
    }

    ADLX_RESULT  AddDisplayListEventListener(IADLXDisplayListChangedListener *pDisplayListChangedListener) override {
        PYBIND11_OVERRIDE_PURE(ADLX_RESULT , IADLXDisplayChangedHandling, AddDisplayListEventListener);
    }

    ADLX_RESULT  RemoveDisplayListEventListener(IADLXDisplayListChangedListener *pDisplayListChangedListener) override {
        PYBIND11_OVERRIDE_PURE(ADLX_RESULT , IADLXDisplayChangedHandling, RemoveDisplayListEventListener);
    }

    ADLX_RESULT  AddDisplayGamutEventListener(IADLXDisplayGamutChangedListener *pDisplayGamutChangedListener) override {
        PYBIND11_OVERRIDE_PURE(ADLX_RESULT , IADLXDisplayChangedHandling, AddDisplayGamutEventListener);
    }

    ADLX_RESULT  RemoveDisplayGamutEventListener(IADLXDisplayGamutChangedListener *pDisplayGamutChangedListener) override {
        PYBIND11_OVERRIDE_PURE(ADLX_RESULT , IADLXDisplayChangedHandling, RemoveDisplayGamutEventListener);
    }

    ADLX_RESULT  AddDisplayGammaEventListener(IADLXDisplayGammaChangedListener *pDisplayGammaChangedListener) override {
        PYBIND11_OVERRIDE_PURE(ADLX_RESULT , IADLXDisplayChangedHandling, AddDisplayGammaEventListener);
    }

    ADLX_RESULT  RemoveDisplayGammaEventListener(IADLXDisplayGammaChangedListener *pDisplayGammaChangedListener) override {
        PYBIND11_OVERRIDE_PURE(ADLX_RESULT , IADLXDisplayChangedHandling, RemoveDisplayGammaEventListener);
    }

    ADLX_RESULT  AddDisplay3DLUTEventListener(IADLXDisplay3DLUTChangedListener *pDisplay3DLUTChangedListener) override {
        PYBIND11_OVERRIDE_PURE(ADLX_RESULT , IADLXDisplayChangedHandling, AddDisplay3DLUTEventListener);
    }

    ADLX_RESULT  RemoveDisplay3DLUTEventListener(IADLXDisplay3DLUTChangedListener *pDisplay3DLUTChangedListener) override {
        PYBIND11_OVERRIDE_PURE(ADLX_RESULT , IADLXDisplayChangedHandling, RemoveDisplay3DLUTEventListener);
    }

    ADLX_RESULT  AddDisplaySettingsEventListener(IADLXDisplaySettingsChangedListener* pDisplaySettingsChangedListener) override {
        PYBIND11_OVERRIDE_PURE(ADLX_RESULT , IADLXDisplayChangedHandling, AddDisplaySettingsEventListener);
    }

    ADLX_RESULT  RemoveDisplaySettingsEventListener(IADLXDisplaySettingsChangedListener* pDisplaySettingsChangedListener) override {
        PYBIND11_OVERRIDE_PURE(ADLX_RESULT , IADLXDisplayChangedHandling, RemoveDisplaySettingsEventListener);
    }
};

// Callback
class DisplayListCallBack : public IADLXDisplayListChangedListener
{
public:

    adlx_bool OnDisplayListChanged(IADLXDisplayList *pNewDisplay) override {
        std::vector<IADLXDisplayPtr> list;
        for (adlx_uint s = pNewDisplay->Begin(); s != pNewDisplay->End(); s++) {
            IADLXDisplayPtr item;
            pNewDisplay->At(s, &item);
            list.emplace_back(item);
        }
        if (m_call) {
            return m_call(list);
        }
        return true;
    }

    std::function<bool(std::vector<IADLXDisplayPtr>)> m_call;
};

PYBIND11_MODULE(ADLXPybind, m) {

    m.doc() = "ADLX python binding for display & displayListChangedEvent";

    // Define the objects that get exposed to python
    // ADLX_RESULT
    py::enum_<ADLX_RESULT>(m, "ADLX_RESULT")
        .value("ADLX_OK", ADLX_RESULT::ADLX_OK )
        .value("ADLX_ALREADY_ENABLED", ADLX_RESULT::ADLX_ALREADY_ENABLED )
        .value("ADLX_ALREADY_INITIALIZED", ADLX_RESULT::ADLX_ALREADY_INITIALIZED )
        .value("ADLX_FAIL", ADLX_RESULT::ADLX_FAIL )
        .value("ADLX_INVALID_ARGS", ADLX_RESULT::ADLX_INVALID_ARGS )
        .value("ADLX_BAD_VER", ADLX_RESULT::ADLX_BAD_VER )
        .value("ADLX_UNKNOWN_INTERFACE", ADLX_RESULT::ADLX_UNKNOWN_INTERFACE )
        .value("ADLX_TERMINATED", ADLX_RESULT::ADLX_TERMINATED )
        .value("ADLX_ADL_INIT_ERROR", ADLX_RESULT::ADLX_ADL_INIT_ERROR )
        .value("ADLX_NOT_FOUND", ADLX_RESULT::ADLX_NOT_FOUND )
        .value("ADLX_INVALID_OBJECT", ADLX_RESULT::ADLX_INVALID_OBJECT )
        .value("ADLX_ORPHAN_OBJECTS", ADLX_RESULT::ADLX_ORPHAN_OBJECTS )
        .value("ADLX_NOT_SUPPORTED", ADLX_RESULT::ADLX_NOT_SUPPORTED )
        .export_values();

    // ADLX_DISPLAY_TYPE
    py::enum_<ADLX_DISPLAY_TYPE>(m, "ADLX_DISPLAY_TYPE")
        .value("DISPLAY_TYPE_UNKOWN", ADLX_DISPLAY_TYPE::DISPLAY_TYPE_UNKOWN )
        .value("DISPLAY_TYPE_MONITOR", ADLX_DISPLAY_TYPE::DISPLAY_TYPE_MONITOR )
        .value("DISPLAY_TYPE_TELEVISION", ADLX_DISPLAY_TYPE::DISPLAY_TYPE_TELEVISION )
        .value("DISPLAY_TYPE_LCD_PANEL", ADLX_DISPLAY_TYPE::DISPLAY_TYPE_LCD_PANEL )
        .value("DISPLAY_TYPE_DIGITAL_FLAT_PANEL", ADLX_DISPLAY_TYPE::DISPLAY_TYPE_DIGITAL_FLAT_PANEL )
        .value("DISPLAY_TYPE_COMPONENT_VIDEO", ADLX_DISPLAY_TYPE::DISPLAY_TYPE_COMPONENT_VIDEO )
        .value("DISPLAY_TYPE_PROJECTOR", ADLX_DISPLAY_TYPE::DISPLAY_TYPE_PROJECTOR )
        .export_values();

    // ADLX_DISPLAY_CONNECTOR_TYPE
    py::enum_<ADLX_DISPLAY_CONNECTOR_TYPE>(m, "ADLX_DISPLAY_CONNECTOR_TYPE")
        .value("DISPLAY_CONTYPE_UNKNOWN", ADLX_DISPLAY_CONNECTOR_TYPE::DISPLAY_CONTYPE_UNKNOWN )
        .value("DISPLAY_CONTYPE_VGA", ADLX_DISPLAY_CONNECTOR_TYPE::DISPLAY_CONTYPE_VGA )
        .value("DISPLAY_CONTYPE_DVI_D", ADLX_DISPLAY_CONNECTOR_TYPE::DISPLAY_CONTYPE_DVI_D )
        .value("DISPLAY_CONTYPE_DVI_I", ADLX_DISPLAY_CONNECTOR_TYPE::DISPLAY_CONTYPE_DVI_I )
        .value("DISPLAY_CONTYPE_CVDONGLE_NTSC", ADLX_DISPLAY_CONNECTOR_TYPE::DISPLAY_CONTYPE_CVDONGLE_NTSC )
        .value("DISPLAY_CONTYPE_CVDONGLE_JPN", ADLX_DISPLAY_CONNECTOR_TYPE::DISPLAY_CONTYPE_CVDONGLE_JPN )
        .value("DISPLAY_CONTYPE_CVDONGLE_NONI2C_JPN", ADLX_DISPLAY_CONNECTOR_TYPE::DISPLAY_CONTYPE_CVDONGLE_NONI2C_JPN )
        .value("DISPLAY_CONTYPE_CVDONGLE_NONI2C_NTSC", ADLX_DISPLAY_CONNECTOR_TYPE::DISPLAY_CONTYPE_CVDONGLE_NONI2C_NTSC )
        .value("DISPLAY_CONTYPE_HDMI_TYPE_A", ADLX_DISPLAY_CONNECTOR_TYPE::DISPLAY_CONTYPE_HDMI_TYPE_A )
        .value("DISPLAY_CONTYPE_HDMI_TYPE_B", ADLX_DISPLAY_CONNECTOR_TYPE::DISPLAY_CONTYPE_HDMI_TYPE_B )
        .value("DISPLAY_CONTYPE_SVIDEO", ADLX_DISPLAY_CONNECTOR_TYPE::DISPLAY_CONTYPE_SVIDEO )
        .value("DISPLAY_CONTYPE_COMPOSITE", ADLX_DISPLAY_CONNECTOR_TYPE::DISPLAY_CONTYPE_COMPOSITE )
        .value("DISPLAY_CONTYPE_RCA_3COMPONENT", ADLX_DISPLAY_CONNECTOR_TYPE::DISPLAY_CONTYPE_RCA_3COMPONENT )
        .value("DISPLAY_CONTYPE_DISPLAYPORT", ADLX_DISPLAY_CONNECTOR_TYPE::DISPLAY_CONTYPE_DISPLAYPORT )
        .value("DISPLAY_CONTYPE_EDP", ADLX_DISPLAY_CONNECTOR_TYPE::DISPLAY_CONTYPE_EDP )
        .value("DISPLAY_CONTYPE_WIRELESSDISPLAY", ADLX_DISPLAY_CONNECTOR_TYPE::DISPLAY_CONTYPE_WIRELESSDISPLAY )
        .value("DISPLAY_CONTYPE_USB_TYPE_C", ADLX_DISPLAY_CONNECTOR_TYPE::DISPLAY_CONTYPE_USB_TYPE_C )
        .export_values();

    // ADLX_DISPLAY_SCAN_TYPE
    py::enum_<ADLX_DISPLAY_SCAN_TYPE>(m, "ADLX_DISPLAY_SCAN_TYPE")
        .value("PROGRESSIVE", ADLX_DISPLAY_SCAN_TYPE::PROGRESSIVE )
        .value("INTERLACED", ADLX_DISPLAY_SCAN_TYPE::INTERLACED )
        .export_values();

    // ADLX_helper
    py::class_<ADLXHelper>(m, "ADLXHelper")
        .def(py::init<>())
        .def("InitializeWithCallerAdl", &ADLXHelper::InitializeWithCallerAdl)
        .def("Initialize", &ADLXHelper::Initialize)
        .def("InitializeWithIncompatibleDriver", &ADLXHelper::InitializeWithIncompatibleDriver)
        .def("Terminate", &ADLXHelper::Terminate)
        .def("QueryVersion", &ADLXHelper::QueryVersion)
        .def("GetSystemServices", &ADLXHelper::GetSystemServices, py::return_value_policy::reference)
        .def("GetAdlMapping", &ADLXHelper::GetAdlMapping);

    // System
    py::class_<IADLXSystem, PySystem>(m, "IADLXSystem")
        .def(py::init<>())
        .def("GetDisplaysServices", [](py::object self) {
        IADLXSystem *sys = self.cast<IADLXSystem*>();
        IADLXDisplayServicesPtr displayService = nullptr;
        sys->GetDisplaysServices(&displayService);
        return displayService;
    }, py::return_value_policy::move);

    // displayService
    py::class_<IADLXDisplayServices, PyDisplayService, IADLXInterfacePtr_T<IADLXDisplayServices>>(m, "IADLXDisplayServices")
        .def(py::init<>())
        .def("GetNumberOfDisplays", [](py::object self) {
        IADLXDisplayServices* disService = self.cast<IADLXDisplayServices*>();
        adlx_uint num;
        disService->GetNumberOfDisplays(&num);
        return num;
    })
        .def("GetDisplays", [](py::object self) {
        IADLXDisplayServices* disService = self.cast<IADLXDisplayServices*>();
        IADLXDisplayListPtr displayList = nullptr;
        disService->GetDisplays(&displayList);
        std::vector<IADLXDisplayPtr> list;
        for (adlx_uint s = displayList->Begin(); s != displayList->End(); s++) {
            IADLXDisplayPtr item;
            displayList->At(s, &item);
            list.emplace_back(std::move(item));
        }
        return list;
    }, py::return_value_policy::move)
        .def("GetDisplayChangedHandling", [](py::object self) {
        IADLXDisplayServices* disService = self.cast<IADLXDisplayServices*>();
        IADLXDisplayChangedHandlingPtr handler = nullptr;
        disService->GetDisplayChangedHandling(&handler);
        return handler;
    }, py::return_value_policy::move);

    // Display
    py::class_<IADLXDisplay, PyDisplay, IADLXInterfacePtr_T<IADLXDisplay>>(m, "IADLXDisplay")
        .def(py::init<>())
        .def("name", [](py::object self) {
        IADLXDisplay *display = self.cast<IADLXDisplay*>();
        const char *name = nullptr;
        display->Name(&name);
        return py::str(name);
    })
        .def("type", [](py::object self) {
        IADLXDisplay *display = self.cast<IADLXDisplay*>();
        ADLX_DISPLAY_TYPE  type;
        display->DisplayType(&type);
        return type;
    })
        .def("connectType", [](py::object self) {
        IADLXDisplay *display = self.cast<IADLXDisplay*>();
        ADLX_DISPLAY_CONNECTOR_TYPE  type;
        display->ConnectorType(&type);
        return type;
    })
        .def("ManufacturerID", [](py::object self) {
        IADLXDisplay *display = self.cast<IADLXDisplay*>();
        adlx_uint id;
        display->ManufacturerID(&id);
        return id;
    })
        .def("EDID", [](py::object self) {
        IADLXDisplay *display = self.cast<IADLXDisplay*>();
        const char* str = nullptr;
        display->EDID(&str);
        return std::string(str);
    })
        .def("resolution", [](py::object self) {
        IADLXDisplay *display = self.cast<IADLXDisplay*>();
        adlx_int h, v;
        display->NativeResolution(&h, &v);
        return std::tuple<adlx_int, adlx_int>(h,v);
    })
        .def("RefreshRate", [](py::object self) {
        IADLXDisplay *display = self.cast<IADLXDisplay*>();
        adlx_double value;
        display->RefreshRate(&value);
        return value;
    })
        .def("PixelClock", [](py::object self) {
        IADLXDisplay *display = self.cast<IADLXDisplay*>();
        adlx_uint value;
        display->PixelClock(&value);
        return value;
    })
        .def("ScanType", [](py::object self) {
        IADLXDisplay *display = self.cast<IADLXDisplay*>();
        ADLX_DISPLAY_SCAN_TYPE  type;
        display->ScanType(&type);
        return type;
    })
        .def("UniqueId", [](py::object self) {
        IADLXDisplay *display = self.cast<IADLXDisplay*>();
        adlx_size id;
        display->UniqueId(&id);
        return id;
    });

    // Display change handler
    py::class_<IADLXDisplayChangedHandling, PyDisplayChangeHandler, IADLXInterfacePtr_T<IADLXDisplayChangedHandling>>(m, "IADLXDisplayChangedHandling")
        .def(py::init<>())
        .def("AddDisplayListEventListener", [](py::object self, DisplayListCallBack* call) {
            IADLXDisplayChangedHandling *handler = self.cast<IADLXDisplayChangedHandling*>();
            return handler->AddDisplayListEventListener(call);
        })
        .def("RemoveDisplayListEventListener", [](py::object self, DisplayListCallBack* call) {
            IADLXDisplayChangedHandling *handler = self.cast<IADLXDisplayChangedHandling*>();
            return handler->RemoveDisplayListEventListener(call);
        });

    // Callback for displaylist
    py::class_<DisplayListCallBack>(m, "DisplayListCallBack")
        .def(py::init<>())
        .def_readwrite("call", &DisplayListCallBack::m_call);
}