lh_hidapi.cpp

#include "lh_hidapi.h"
#include "lh_hidapi_priv.h"

#include <stdio.h>
#include <iostream>


// essentially wrapper functions arounf hidapi again (with some extra stuff)

HidDeviceWrapper::HidDeviceWrapper(uint16_t vendor, uint16_t product, const wchar_t* serial){
    dev = hid_open(vendor, product, serial);
    if(dev){
        auto devinfo = hid_get_device_info(dev);
        vendor = devinfo->vendor_id;
        product = devinfo->product_id;
        this->serial = devinfo->serial_number;
        interface_number = devinfo->interface_number;
    }
}

HidDeviceWrapper::HidDeviceWrapper(const char* path){
    dev = hid_open_path(path);
    if(dev){
        auto devinfo = hid_get_device_info(dev);
        vendor = devinfo->vendor_id;
        product = devinfo->product_id;
        this->serial = devinfo->serial_number;
        interface_number = devinfo->interface_number;
    }
}

HidDeviceWrapper::~HidDeviceWrapper(){
    if(dev){
        hid_close(dev);
        dev = nullptr;
    }
}

int HidDeviceWrapper::write(const unsigned char* data, size_t length){
    int ret = hid_write(dev, data, length);
    if(ret == -1){
        std::cerr << "hid_write failed" << std::endl;
    }
    return ret;
}

int HidDeviceWrapper::read(unsigned char* data, size_t length, int milliseconds){
    int ret;
    if(milliseconds == -1){
        ret = hid_read(dev, data, length);
    } else {
        ret = hid_read_timeout(dev, data, length, milliseconds);
    }
    if(ret == -1){
        //std::cerr << "hid_read failed" << std::endl;
        try_reopen();
        return 0;
    }
    /*if(ret > 0){
        std::cout << "hid_read: " << std::hex << (int)data[0] << std::endl;
    }*/
    return ret;
}

int HidDeviceWrapper::set_nonblocking(int nonblock){
    return hid_set_nonblocking(dev, nonblock);
}

int HidDeviceWrapper::send_feature_report(const unsigned char* data, size_t length){
    int ret = hid_send_feature_report(dev, data, length);
    if(ret == -1){
        //std::cerr << "hid_send_feature_report failed" << std::endl;
    }
    return ret;
}

int HidDeviceWrapper::get_feature_report(unsigned char* data, size_t length){
    int ret = hid_get_feature_report(dev, data, length);
    if(ret == -1){
        //std::cerr << "hid_get_feature_report failed" << std::endl;
    }
    return ret;
}

// wired lighthouse devices apparently don't just output lightcap data on their own again
void restartLighthouseCapture(hid_device* dev){
    const unsigned char syncMode[] =  {0x04, 0x00, 0x00, 0x00, 0x00};
    const unsigned char lcVerbosity[] =  {0x07, 0x03, 0x00, 0x00, 0x00};

    if(hid_send_feature_report(dev, syncMode, sizeof(syncMode)) == -1){
        std::cerr << "Failed to set sync mode" << std::endl;
    }
    if(hid_send_feature_report(dev, lcVerbosity, sizeof(lcVerbosity)) == -1){
        std::cerr << "Failed to set lightcap verbosity" << std::endl;
    }
}

// utility
void HidDeviceWrapper::try_reopen(){
    hid_device_info* devinfo = hid_enumerate(vendor, product);
    hid_device_info* first = devinfo;
    while(devinfo){
        if(devinfo->serial_number && devinfo->serial_number == serial && devinfo->interface_number == interface_number){
            std::cout << "found device" << std::endl;
            break;
        }
        devinfo = devinfo->next;
    }
    if(devinfo){
        hid_device* newdev = hid_open_path(devinfo->path);
        if(newdev){
            std::cout << "successfully reopened device" << std::endl;
            hid_close(dev);
            dev = newdev;
            restartLighthouseCapture(dev);
        }
    }
    if(first){
        hid_free_enumeration(first);
    }
}


// shim functions to call the member functions

int lh_hid_init(){
    printf("my_hid_init!\n");
    return hid_init();
}

int lh_hid_exit(){
    printf("my_hid_exit\n");
    return hid_exit();
}

struct hid_device_info* lh_hid_enumerate(unsigned short vendor_id, unsigned short product_id){
    printf("my_hid_enumerate %04x:%04x\n", vendor_id, product_id);
    return hid_enumerate(vendor_id, product_id);
}

void lh_hid_free_enumeration(struct hid_device_info* devs){
    printf("my_hid_free_enumeration\n");
    hid_free_enumeration(devs);
}

hid_device* lh_hid_open(unsigned short vendor_id, unsigned short product_id, const wchar_t* serial_number){
    wprintf(L"my_hid_open %04x:%04x %s\n", vendor_id, product_id, serial_number);
    HidDeviceWrapper* wrap = new HidDeviceWrapper(vendor_id, product_id, serial_number);
    if(!wrap->dev){
        delete wrap;
        return nullptr;
    }
    return (hid_device*)wrap;
    //return hid_open(vendor_id, product_id, serial_number);
}

hid_device* lh_hid_open_path(const char* path){
    printf("my_hid_open_path %s\n", path);
    HidDeviceWrapper* wrap = new HidDeviceWrapper(path);
    if(!wrap->dev){
        delete wrap;
        return nullptr;
    }
    return (hid_device*)wrap;
    //return hid_open_path(path);
}



int lh_hid_write(hid_device* dev, const unsigned char* data, size_t length){
    HidDeviceWrapper* wrap = (HidDeviceWrapper*)dev;
    return wrap->write(data, length);
    //return hid_write(dev, data, length);
}

int lh_hid_read_timeout(hid_device* dev, unsigned char* data, size_t length, int milliseconds){
    HidDeviceWrapper* wrap = (HidDeviceWrapper*)dev;
    return wrap->read(data, length, milliseconds);
    //return hid_read_timeout(dev, data, length, milliseconds);
}

int lh_hid_read(hid_device* dev, unsigned char* data, size_t length){
    HidDeviceWrapper* wrap = (HidDeviceWrapper*)dev;
    return wrap->read(data, length);
    //return hid_read(dev, data, length);
}

/*const wchar_t* lh_hid_read_error(hid_device* dev){
    return hid_read_error(dev);
}*/

// doesn't seem to be used by lighthouse_console
int lh_hid_set_nonblocking(hid_device* dev, int nonblock){
    HidDeviceWrapper* wrap = (HidDeviceWrapper*)dev;
    printf("my_hid_set_nonblocking %d\n", nonblock);
    return wrap->set_nonblocking(nonblock);
    //return hid_set_nonblocking(dev, nonblock);
}

int lh_hid_send_feature_report(hid_device* dev, const unsigned char* data, size_t length){
    HidDeviceWrapper* wrap = (HidDeviceWrapper*)dev;
    //printf("my_hid_send_feature_report\n");
    return wrap->send_feature_report(data, length);
    //return hid_send_feature_report(dev, data, length);
}

int lh_hid_get_feature_report(hid_device* dev, unsigned char* data, size_t length){
    HidDeviceWrapper* wrap = (HidDeviceWrapper*)dev;
    //printf("my_hid_get_feature_report\n");
    return wrap->get_feature_report(data, length);
    //return hid_get_feature_report(dev, data, length);
}

void lh_hid_close(hid_device* dev){
    printf("my_hid_close\n");
    HidDeviceWrapper* wrap = (HidDeviceWrapper*)dev;
    delete wrap;
    //hid_close(dev);
}

// these aren't really used as much

int lh_hid_get_manufacturer_string(hid_device* dev, wchar_t* string, size_t maxlen){
    HidDeviceWrapper* wrap = (HidDeviceWrapper*)dev;
    return hid_get_manufacturer_string(wrap->dev, string, maxlen);
}

int lh_hid_get_product_string(hid_device* dev, wchar_t* string, size_t maxlen){
    HidDeviceWrapper* wrap = (HidDeviceWrapper*)dev;
    return hid_get_product_string(wrap->dev, string, maxlen);
}

int lh_hid_get_serial_number_string(hid_device* dev, wchar_t* string, size_t maxlen){
    HidDeviceWrapper* wrap = (HidDeviceWrapper*)dev;
    return hid_get_serial_number_string(wrap->dev, string, maxlen);
}

int lh_hid_get_indexed_string(hid_device* dev, int string_index, wchar_t* string, size_t maxlen){
    HidDeviceWrapper* wrap = (HidDeviceWrapper*)dev;
    return hid_get_indexed_string(wrap->dev, string_index, string, maxlen);
}

const wchar_t* lh_hid_error(hid_device* dev){
    HidDeviceWrapper* wrap = (HidDeviceWrapper*)dev;
    return hid_error(wrap->dev);
}