#include "MvsDevice.h"
#include "MvsSDKManager.h"
#include "VrError.h"
#include "VrLog.h"
#include <cstring>
#include <chrono>
#include <thread>

namespace
{
constexpr unsigned int kUsbImageNodeNum    = 1;
constexpr unsigned int kUsbTransferSize    = 0x40000;  // 256KB, reduce per-URB DMA pressure on ARM USB2
constexpr unsigned int kUsbTransferWays    = 1;
constexpr float        kUsbOpenFrameRate   = 2.0f;

bool IsUsbDeviceType(unsigned int type)
{
    return type == MV_USB_DEVICE || type == MV_VIR_USB_DEVICE;
}

void ApplyConservativeUsbStreamConfig(void* handle, const char* stage)
{
    if (!handle) return;

    int frameEnableRet = MV_CC_SetBoolValue(handle, "AcquisitionFrameRateEnable", true);
    int nodeRet = MV_CC_SetImageNodeNum(handle, kUsbImageNodeNum);
    int sizeRet = MV_USB_SetTransferSize(handle, kUsbTransferSize);
    int waysRet = MV_USB_SetTransferWays(handle, kUsbTransferWays);

    MVCC_FLOATVALUE frameRateValue;
    memset(&frameRateValue, 0, sizeof(frameRateValue));
    int frameGetRet = MV_CC_GetFloatValue(handle, "AcquisitionFrameRate", &frameRateValue);
    unsigned int readSize = 0;
    unsigned int readWays = 0;
    int getSizeRet = MV_USB_GetTransferSize(handle, &readSize);
    int getWaysRet = MV_USB_GetTransferWays(handle, &readWays);

    LOG_DEBUG("[MVS] USB stream config(%s) fps=%.1f enableRet=0x%x fpsGetRet=0x%x node=%u ret=0x%x transferSize=0x%x ret=0x%x read=0x%x readRet=0x%x transferWays=%u ret=0x%x read=%u readRet=0x%x\n",
              stage ? stage : "",
              frameRateValue.fCurValue, frameEnableRet, frameGetRet,
              kUsbImageNodeNum, nodeRet,
              kUsbTransferSize, sizeRet, readSize, getSizeRet,
              kUsbTransferWays, waysRet, readWays, getWaysRet);
}
}

// 工厂
int IMvsDevice::CreateObject(IMvsDevice** ppDevice)
{
    if (ppDevice == nullptr)
    {
        return ERR_CODE(DEV_ARG_INVAILD);
    }
    try
    {
        *ppDevice = new CMvsDevice();
        return SUCCESS;
    }
    catch (...)
    {
        return ERR_CODE(DATA_ERR_MEM);
    }
}

CMvsDevice::CMvsDevice() = default;

CMvsDevice::~CMvsDevice()
{
    try
    {
        if (m_bAcquisitioning) StopAcquisition();
        if (m_bDeviceOpen)     CloseDevice();
        if (m_bSDKInitialized) UninitSDK();
    }
    catch (...) {}
}

int CMvsDevice::InitSDK()
{
    if (m_bSDKInitialized) return SUCCESS;
    int ret = MvsSDKManager::GetInstance().InitSDK();
    if (ret == SUCCESS) m_bSDKInitialized = true;
    return ret;
}

int CMvsDevice::UninitSDK()
{
    if (!m_bSDKInitialized) return SUCCESS;
    int ret = MvsSDKManager::GetInstance().UninitSDK();
    if (ret == SUCCESS) m_bSDKInitialized = false;
    return ret;
}

int CMvsDevice::GetSDKVersion(std::string& version)
{
    unsigned int v = MV_CC_GetSDKVersion();
    char buf[64] = {0};
    snprintf(buf, sizeof(buf), "MVS %u.%u.%u.%u",
             (v >> 24) & 0xFF, (v >> 16) & 0xFF, (v >> 8) & 0xFF, v & 0xFF);
    version = buf;
    return SUCCESS;
}

void CMvsDevice::FillDeviceInfo(const MV_CC_DEVICE_INFO& src, MvsDeviceInfo& dst)
{
    if (src.nTLayerType == MV_GIGE_DEVICE
        || src.nTLayerType == MV_VIR_GIGE_DEVICE
        || src.nTLayerType == MV_GENTL_GIGE_DEVICE)
    {
        const auto& gi = src.SpecialInfo.stGigEInfo;
        dst.tlType            = EMvsTLType::GigE;
        dst.serialNumber      = reinterpret_cast<const char*>(gi.chSerialNumber);
        dst.modelName         = reinterpret_cast<const char*>(gi.chModelName);
        dst.manufacturerName  = reinterpret_cast<const char*>(gi.chManufacturerName);
        dst.deviceVersion     = reinterpret_cast<const char*>(gi.chDeviceVersion);
        dst.userDefinedName   = reinterpret_cast<const char*>(gi.chUserDefinedName);

        // IP 拼接
        unsigned int ip = gi.nCurrentIp;
        char ipBuf[32] = {0};
        snprintf(ipBuf, sizeof(ipBuf), "%u.%u.%u.%u",
                 (ip >> 24) & 0xFF, (ip >> 16) & 0xFF, (ip >> 8) & 0xFF, ip & 0xFF);
        dst.ipAddress = ipBuf;
        dst.macAddress.clear();
    }
    else if (src.nTLayerType == MV_USB_DEVICE
             || src.nTLayerType == MV_VIR_USB_DEVICE)
    {
        const auto& ui = src.SpecialInfo.stUsb3VInfo;
        dst.tlType            = EMvsTLType::USB3;
        dst.serialNumber      = reinterpret_cast<const char*>(ui.chSerialNumber);
        dst.modelName         = reinterpret_cast<const char*>(ui.chModelName);
        dst.manufacturerName  = reinterpret_cast<const char*>(ui.chManufacturerName);
        dst.deviceVersion     = reinterpret_cast<const char*>(ui.chDeviceVersion);
        dst.userDefinedName   = reinterpret_cast<const char*>(ui.chUserDefinedName);
        dst.ipAddress.clear();
        dst.macAddress.clear();
    }
    else
    {
        dst.tlType = EMvsTLType::Other;
    }

    dst.displayName = dst.userDefinedName.empty()
                          ? (dst.modelName + " (" + dst.serialNumber + ")")
                          : dst.userDefinedName;
}

int CMvsDevice::EnumerateDevices(std::vector<MvsDeviceInfo>& deviceList, unsigned int tLayerType)
{
    if (!m_bSDKInitialized)
    {
        int r = InitSDK();
        if (r != SUCCESS) return r;
    }

    deviceList.clear();
    m_devInfoCache.clear();

    unsigned int layer = tLayerType == 0
                             ? (MV_GIGE_DEVICE | MV_USB_DEVICE)
                             : tLayerType;

    MV_CC_DEVICE_INFO_LIST stDeviceList;
    memset(&stDeviceList, 0, sizeof(stDeviceList));

    int ret = MV_CC_EnumDevices(layer, &stDeviceList);
    if (ret != MV_OK)
    {
        LOG_DEBUG("MV_CC_EnumDevices fail: %x\n", ret);
        return ret;
    }

    for (unsigned int i = 0; i < stDeviceList.nDeviceNum; ++i)
    {
        MV_CC_DEVICE_INFO* p = stDeviceList.pDeviceInfo[i];
        if (!p) continue;

        m_devInfoCache.push_back(*p);

        MvsDeviceInfo info;
        FillDeviceInfo(*p, info);
        deviceList.push_back(info);
    }

    LOG_DEBUG("MVS Enumerated %u devices\n", static_cast<unsigned>(deviceList.size()));
    return SUCCESS;
}

int CMvsDevice::OpenDevice(const std::string& serialNumber)
{
    std::lock_guard<std::mutex> lk(m_deviceMutex);

    if (!m_bSDKInitialized)
    {
        int r = InitSDK();
        if (r != SUCCESS) return r;
    }

    // 如果缓存为空（外部直接通过 SN 打开），先枚举一次
    if (m_devInfoCache.empty())
    {
        std::vector<MvsDeviceInfo> tmp;
        int r = EnumerateDevices(tmp);
        if (r != SUCCESS) return r;
    }

    // 查找匹配的 SN
    MV_CC_DEVICE_INFO* pTarget = nullptr;
    bool targetIsUsb = false;
    for (auto& dev : m_devInfoCache)
    {
        const char* sn = nullptr;
        if (dev.nTLayerType == MV_GIGE_DEVICE
            || dev.nTLayerType == MV_VIR_GIGE_DEVICE
            || dev.nTLayerType == MV_GENTL_GIGE_DEVICE)
        {
            sn = reinterpret_cast<const char*>(dev.SpecialInfo.stGigEInfo.chSerialNumber);
        }
        else if (dev.nTLayerType == MV_USB_DEVICE
                 || dev.nTLayerType == MV_VIR_USB_DEVICE)
        {
            sn = reinterpret_cast<const char*>(dev.SpecialInfo.stUsb3VInfo.chSerialNumber);
        }
        if (sn && serialNumber == sn)
        {
            pTarget = &dev;
            targetIsUsb = IsUsbDeviceType(dev.nTLayerType);
            break;
        }
    }
    if (!pTarget) return ERR_CODE(DEV_NOT_FIND);

    if (m_bDeviceOpen) CloseDevice();

    int ret = MV_CC_CreateHandle(&m_handle, pTarget);
    if (ret != MV_OK)
    {
        LOG_DEBUG("MV_CC_CreateHandle fail: %x\n", ret);
        return ret;
    }

    ret = MV_CC_OpenDevice(m_handle);
    if (ret != MV_OK)
    {
        LOG_DEBUG("MV_CC_OpenDevice fail: %x\n", ret);
        MV_CC_DestroyHandle(m_handle);
        m_handle = nullptr;
        return ret;
    }

    // GigE 设备建议优化包大小
    if (pTarget->nTLayerType == MV_GIGE_DEVICE)
    {
        int nPacketSize = MV_CC_GetOptimalPacketSize(m_handle);
        if (nPacketSize > 0)
        {
            MV_CC_SetIntValueEx(m_handle, "GevSCPSPacketSize", nPacketSize);
        }
    }

    // USB 设备优化带宽（降低传输负载，避免资源申请失败）
    if (pTarget->nTLayerType == MV_USB_DEVICE
        || pTarget->nTLayerType == MV_VIR_USB_DEVICE)
    {
        // 降低 USB 传输包大小，减少带宽占用
        MV_CC_SetIntValueEx(m_handle, "PayloadSize", 0);  // 自动计算

        // 设置合理的帧率上限（避免带宽不足）
        MV_CC_SetBoolValue(m_handle, "AcquisitionFrameRateEnable", true);
        MV_CC_SetFloatValue(m_handle, "AcquisitionFrameRate", kUsbOpenFrameRate);
    }

    // 默认关闭触发模式
    MV_CC_SetEnumValue(m_handle, "TriggerMode", MV_TRIGGER_MODE_OFF);

    m_currentDeviceIsUsb = targetIsUsb;
    if (m_currentDeviceIsUsb) ApplyConservativeUsbStreamConfig(m_handle, "open-final");

    FillDeviceInfo(*pTarget, m_currentDeviceInfo);
    m_bDeviceOpen = true;
    return SUCCESS;
}

int CMvsDevice::OpenDeviceByIndex(unsigned int index)
{
    std::vector<MvsDeviceInfo> list;
    int r = EnumerateDevices(list);
    if (r != SUCCESS) return r;
    if (index >= list.size()) return ERR_CODE(DEV_ID_ERR);
    return OpenDevice(list[index].serialNumber);
}

int CMvsDevice::CloseDevice()
{
    std::lock_guard<std::mutex> lk(m_deviceMutex);

    if (m_bAcquisitioning) StopAcquisition();

    if (m_handle)
    {
        MV_CC_CloseDevice(m_handle);
        MV_CC_DestroyHandle(m_handle);
        m_handle = nullptr;
    }
    m_bDeviceOpen = false;
    m_currentDeviceIsUsb = false;
    return SUCCESS;
}

bool CMvsDevice::IsDeviceOpen()
{
    return m_bDeviceOpen;
}

int CMvsDevice::GetDeviceInfo(MvsDeviceInfo& info)
{
    if (!m_bDeviceOpen) return ERR_CODE(DEV_NO_OPEN);
    info = m_currentDeviceInfo;
    GetWidth(info.width);
    GetHeight(info.height);
    return SUCCESS;
}

int CMvsDevice::SetTriggerMode(bool enable)
{
    if (!m_handle) return ERR_CODE(DEV_CTRL_ERR);
    return MV_CC_SetEnumValue(m_handle, "TriggerMode",
                              enable ? MV_TRIGGER_MODE_ON : MV_TRIGGER_MODE_OFF);
}

int CMvsDevice::SendSoftTrigger()
{
    if (!m_handle) return ERR_CODE(DEV_CTRL_ERR);
    return MV_CC_SetCommandValue(m_handle, "TriggerSoftware");
}

int CMvsDevice::StartAcquisition()
{
    if (!m_handle) return ERR_CODE(DEV_CTRL_ERR);
    if (m_bAcquisitioning) return SUCCESS;

    if (m_currentDeviceIsUsb) ApplyConservativeUsbStreamConfig(m_handle, "start");

    int ret = MV_CC_StartGrabbing(m_handle);
    if (ret == MV_OK)
    {
        m_bAcquisitioning = true;
    }
    else
    {
        LOG_DEBUG("MV_CC_StartGrabbing fail: %x\n", ret);

        // 针对资源申请失败，输出详细诊断信息
        if (ret == 0x80000006)  // MV_E_RESOURCE
        {
            LOG_ERROR("USB resource allocation failed. Possible causes:\n");
            LOG_ERROR("  1. Insufficient USB bandwidth (try lower resolution/framerate)\n");
            LOG_ERROR("  2. USB controller overload (disconnect other USB devices)\n");
            LOG_ERROR("  3. Insufficient system memory\n");
            LOG_ERROR("  4. USB power supply insufficient\n");

            // 尝试读取当前相机参数
            MVCC_INTVALUE_EX stParam;
            memset(&stParam, 0, sizeof(stParam));
            if (MV_CC_GetIntValueEx(m_handle, "Width", &stParam) == MV_OK)
            {
                LOG_ERROR("  Current Width: %lld\n", stParam.nCurValue);
            }
            memset(&stParam, 0, sizeof(stParam));
            if (MV_CC_GetIntValueEx(m_handle, "Height", &stParam) == MV_OK)
            {
                LOG_ERROR("  Current Height: %lld\n", stParam.nCurValue);
            }

            MVCC_FLOATVALUE stFloatParam;
            memset(&stFloatParam, 0, sizeof(stFloatParam));
            if (MV_CC_GetFloatValue(m_handle, "AcquisitionFrameRate", &stFloatParam) == MV_OK)
            {
                LOG_ERROR("  Current FrameRate: %.2f\n", stFloatParam.fCurValue);
            }
        }
    }
    return ret;
}

int CMvsDevice::StopAcquisition()
{
    if (!m_handle) return ERR_CODE(DEV_CTRL_ERR);
    if (!m_bAcquisitioning) return SUCCESS;
    int ret = MV_CC_StopGrabbing(m_handle);
    if (ret == MV_OK) m_bAcquisitioning = false;
    else LOG_DEBUG("MV_CC_StopGrabbing fail: %x\n", ret);
    return ret;
}

bool CMvsDevice::IsAcquisitioning()
{
    return m_bAcquisitioning;
}

int CMvsDevice::CaptureImage(MvsImageData& image, unsigned int timeoutMs)
{
    if (!m_handle) return ERR_CODE(DEV_CTRL_ERR);

    MV_FRAME_OUT stFrame;
    memset(&stFrame, 0, sizeof(stFrame));

    int ret = MV_CC_GetImageBuffer(m_handle, &stFrame, timeoutMs);
    if (ret != MV_OK)
    {
        LOG_DEBUG("MV_CC_GetImageBuffer fail: %x\n", ret);
        return ret;
    }

    image.width        = stFrame.stFrameInfo.nExtendWidth
                             ? stFrame.stFrameInfo.nExtendWidth
                             : stFrame.stFrameInfo.nWidth;
    image.height       = stFrame.stFrameInfo.nExtendHeight
                             ? stFrame.stFrameInfo.nExtendHeight
                             : stFrame.stFrameInfo.nHeight;
    image.dataSize     = stFrame.stFrameInfo.nFrameLen;
    image.pixelFormat  = static_cast<int>(stFrame.stFrameInfo.enPixelType);
    image.frameID      = stFrame.stFrameInfo.nFrameNum;
    image.timestamp    = (static_cast<unsigned long long>(stFrame.stFrameInfo.nDevTimeStampHigh) << 32)
                         | stFrame.stFrameInfo.nDevTimeStampLow;

    image.pData = new unsigned char[image.dataSize];
    memcpy(image.pData, stFrame.pBufAddr, image.dataSize);

    MV_CC_FreeImageBuffer(m_handle, &stFrame);
    return SUCCESS;
}

int CMvsDevice::RegisterImageCallback(MvsImageCallback callback)
{
    if (!m_handle) return ERR_CODE(DEV_CTRL_ERR);
    {
        std::lock_guard<std::mutex> lk(m_callbackMutex);
        m_imageCallback = std::move(callback);
    }
    int ret = MV_CC_RegisterImageCallBackEx(m_handle, &CMvsDevice::OnFrameCallback, this);
    LOG_DEBUG("[MVS] RegisterImageCallback handle=%p ret=0x%x\n", (void*)m_handle, ret);
    return ret;
}

int CMvsDevice::UnregisterImageCallback()
{
    if (!m_handle) return SUCCESS;
    // MVS 没有显式反注册，使用空回调覆盖
    MV_CC_RegisterImageCallBackEx(m_handle, nullptr, nullptr);
    std::lock_guard<std::mutex> lk(m_callbackMutex);
    m_imageCallback = nullptr;
    return SUCCESS;
}

void __stdcall CMvsDevice::OnFrameCallback(unsigned char* pData,
                                            MV_FRAME_OUT_INFO_EX* pFrameInfo,
                                            void* pUser)
{
    if (!pData || !pFrameInfo || !pUser) return;
    CMvsDevice* self = static_cast<CMvsDevice*>(pUser);

    MvsImageCallback cb;
    {
        std::lock_guard<std::mutex> lk(self->m_callbackMutex);
        cb = self->m_imageCallback;
    }
    if (!cb) return;

    MvsImageData img;
    img.width       = pFrameInfo->nExtendWidth ? pFrameInfo->nExtendWidth : pFrameInfo->nWidth;
    img.height      = pFrameInfo->nExtendHeight ? pFrameInfo->nExtendHeight : pFrameInfo->nHeight;
    img.dataSize    = pFrameInfo->nFrameLen;
    img.pixelFormat = static_cast<int>(pFrameInfo->enPixelType);
    img.frameID     = pFrameInfo->nFrameNum;
    img.timestamp   = (static_cast<unsigned long long>(pFrameInfo->nDevTimeStampHigh) << 32)
                      | pFrameInfo->nDevTimeStampLow;
    // 回调期间 pData 由 SDK 持有，外部不要 delete
    img.pData = pData;

    try { cb(img); } catch (...) {}
}

int CMvsDevice::GetWidth(unsigned int& width)
{
    if (!m_handle) return ERR_CODE(DEV_CTRL_ERR);
    MVCC_INTVALUE_EX v; memset(&v, 0, sizeof(v));
    int ret = MV_CC_GetIntValueEx(m_handle, "Width", &v);
    if (ret == MV_OK) width = static_cast<unsigned int>(v.nCurValue);
    return ret;
}

int CMvsDevice::GetHeight(unsigned int& height)
{
    if (!m_handle) return ERR_CODE(DEV_CTRL_ERR);
    MVCC_INTVALUE_EX v; memset(&v, 0, sizeof(v));
    int ret = MV_CC_GetIntValueEx(m_handle, "Height", &v);
    if (ret == MV_OK) height = static_cast<unsigned int>(v.nCurValue);
    return ret;
}

int CMvsDevice::SetROI(const MvsROI& roi)
{
    if (!m_handle) return ERR_CODE(DEV_CTRL_ERR);
    int r = 0;
    r |= MV_CC_SetIntValueEx(m_handle, "OffsetX", roi.offsetX);
    r |= MV_CC_SetIntValueEx(m_handle, "OffsetY", roi.offsetY);
    r |= MV_CC_SetIntValueEx(m_handle, "Width",   roi.width);
    r |= MV_CC_SetIntValueEx(m_handle, "Height",  roi.height);
    return r == 0 ? SUCCESS : ERR_CODE(DEV_CTRL_ERR);
}

int CMvsDevice::GetROI(MvsROI& roi)
{
    if (!m_handle) return ERR_CODE(DEV_CTRL_ERR);
    MVCC_INTVALUE_EX v; memset(&v, 0, sizeof(v));
    MV_CC_GetIntValueEx(m_handle, "OffsetX", &v); roi.offsetX = (int)v.nCurValue;
    memset(&v, 0, sizeof(v));
    MV_CC_GetIntValueEx(m_handle, "OffsetY", &v); roi.offsetY = (int)v.nCurValue;
    memset(&v, 0, sizeof(v));
    MV_CC_GetIntValueEx(m_handle, "Width",   &v); roi.width   = (int)v.nCurValue;
    memset(&v, 0, sizeof(v));
    MV_CC_GetIntValueEx(m_handle, "Height",  &v); roi.height  = (int)v.nCurValue;
    return SUCCESS;
}

int CMvsDevice::SetExposureTime(double v)
{ return m_handle ? MV_CC_SetFloatValue(m_handle, "ExposureTime", (float)v) : ERR_CODE(DEV_CTRL_ERR); }

int CMvsDevice::GetExposureTime(double& v)
{
    if (!m_handle) return ERR_CODE(DEV_CTRL_ERR);
    MVCC_FLOATVALUE fv; memset(&fv, 0, sizeof(fv));
    int r = MV_CC_GetFloatValue(m_handle, "ExposureTime", &fv);
    if (r == MV_OK) v = fv.fCurValue;
    return r;
}

int CMvsDevice::SetGain(double v)
{ return m_handle ? MV_CC_SetFloatValue(m_handle, "Gain", (float)v) : ERR_CODE(DEV_CTRL_ERR); }

int CMvsDevice::GetGain(double& v)
{
    if (!m_handle) return ERR_CODE(DEV_CTRL_ERR);
    MVCC_FLOATVALUE fv; memset(&fv, 0, sizeof(fv));
    int r = MV_CC_GetFloatValue(m_handle, "Gain", &fv);
    if (r == MV_OK) v = fv.fCurValue;
    return r;
}

int CMvsDevice::SetFrameRate(double v)
{
    if (!m_handle) return ERR_CODE(DEV_CTRL_ERR);
    MV_CC_SetBoolValue(m_handle, "AcquisitionFrameRateEnable", true);
    return MV_CC_SetFloatValue(m_handle, "AcquisitionFrameRate", (float)v);
}

int CMvsDevice::GetFrameRate(double& v)
{
    if (!m_handle) return ERR_CODE(DEV_CTRL_ERR);
    MVCC_FLOATVALUE fv; memset(&fv, 0, sizeof(fv));
    int r = MV_CC_GetFloatValue(m_handle, "AcquisitionFrameRate", &fv);
    if (r == MV_OK) v = fv.fCurValue;
    return r;
}

int CMvsDevice::SetIntFeature(const std::string& name, int64_t v)
{ return m_handle ? MV_CC_SetIntValueEx(m_handle, name.c_str(), v) : ERR_CODE(DEV_CTRL_ERR); }

int CMvsDevice::GetIntFeature(const std::string& name, int64_t& v)
{
    if (!m_handle) return ERR_CODE(DEV_CTRL_ERR);
    MVCC_INTVALUE_EX iv; memset(&iv, 0, sizeof(iv));
    int r = MV_CC_GetIntValueEx(m_handle, name.c_str(), &iv);
    if (r == MV_OK) v = iv.nCurValue;
    return r;
}

int CMvsDevice::SetFloatFeature(const std::string& name, double v)
{ return m_handle ? MV_CC_SetFloatValue(m_handle, name.c_str(), (float)v) : ERR_CODE(DEV_CTRL_ERR); }

int CMvsDevice::GetFloatFeature(const std::string& name, double& v)
{
    if (!m_handle) return ERR_CODE(DEV_CTRL_ERR);
    MVCC_FLOATVALUE fv; memset(&fv, 0, sizeof(fv));
    int r = MV_CC_GetFloatValue(m_handle, name.c_str(), &fv);
    if (r == MV_OK) v = fv.fCurValue;
    return r;
}

int CMvsDevice::SetEnumFeature(const std::string& name, int64_t v)
{ return m_handle ? MV_CC_SetEnumValue(m_handle, name.c_str(), (unsigned int)v) : ERR_CODE(DEV_CTRL_ERR); }

int CMvsDevice::GetEnumFeature(const std::string& name, int64_t& v)
{
    if (!m_handle) return ERR_CODE(DEV_CTRL_ERR);
    MVCC_ENUMVALUE ev; memset(&ev, 0, sizeof(ev));
    int r = MV_CC_GetEnumValue(m_handle, name.c_str(), &ev);
    if (r == MV_OK) v = ev.nCurValue;
    return r;
}

int CMvsDevice::SetBoolFeature(const std::string& name, bool v)
{ return m_handle ? MV_CC_SetBoolValue(m_handle, name.c_str(), v) : ERR_CODE(DEV_CTRL_ERR); }

int CMvsDevice::GetBoolFeature(const std::string& name, bool& v)
{
    if (!m_handle) return ERR_CODE(DEV_CTRL_ERR);
    bool bv = false;
    int r = MV_CC_GetBoolValue(m_handle, name.c_str(), &bv);
    if (r == MV_OK) v = bv;
    return r;
}

int CMvsDevice::SetStringFeature(const std::string& name, const std::string& v)
{ return m_handle ? MV_CC_SetStringValue(m_handle, name.c_str(), v.c_str()) : ERR_CODE(DEV_CTRL_ERR); }

int CMvsDevice::GetStringFeature(const std::string& name, std::string& v)
{
    if (!m_handle) return ERR_CODE(DEV_CTRL_ERR);
    MVCC_STRINGVALUE sv; memset(&sv, 0, sizeof(sv));
    int r = MV_CC_GetStringValue(m_handle, name.c_str(), &sv);
    if (r == MV_OK) v = sv.chCurValue;
    return r;
}

int CMvsDevice::ExecuteCommand(const std::string& name)
{ return m_handle ? MV_CC_SetCommandValue(m_handle, name.c_str()) : ERR_CODE(DEV_CTRL_ERR); }