libxsync/xsync.cpp

#include "xsync.hpp"

#include <string.h>

#include <map>
#define ENABLE_LOG
#ifdef ENABLE_LOG
#include "../src/logger.hpp"
#endif

#define TAG "XSYNC"

using namespace xsync;
using namespace std;

/**
 * @brief XSYNC协议端口
 */
#define IFLYTOP_XSYNC_SERVICE_XSYNC_PORT 19900  // xsync端端口
#define IFLYTOP_XSYNC_SERVICE_PC_PORT    19901  // pc   端端口

#define IFLYTOP_XSYNC_TIMECODE_REPORT_XSYNC_PORT 19902  // xsync端端口
#define IFLYTOP_XSYNC_TIMECODE_REPORT_PC_PORT    19903  // pc端端口

#define IFLYTOP_XSYNC_CAMERA_SYNC_PACKET_XSYNC_PORT 13013  // xsync端端口
#define IFLYTOP_XSYNC_CAMERA_SYNC_PACKET_PC_PORT    13014  // pc端端口

#define DO_XSYNC(exptr)                        \
  {                                            \
    xs_error_code_t ecode = exptr;             \
    if (ecode != kxs_ec_success) return ecode; \
  }

#define REG_WRITE(reg, value)            \
  {                                      \
    DO_XSYNC(reg_write(reg, value, 10)); \
    return kxs_ec_success;               \
  }

#define REG_READ(reg, value)              \
  {                                       \
    uint32_t readbak = 0;                 \
    DO_XSYNC(reg_read(reg, readbak, 10)); \
    value = (decltype(value))readbak;     \
    return kxs_ec_success;                \
  }

static uint32_t ipToUint32(const std::string &ipAddress, bool &suc) {
  uint32_t           result = 0;
  std::istringstream iss(ipAddress);
  std::string        segment;
  int                i = 0;

  while (std::getline(iss, segment, '.')) {
    uint32_t octet = std::stoi(segment);
    if (octet > 255) {
      suc = false;
      return 0;
    }
    result |= (octet << ((3 - i) * 8));
    i++;
  }
  if (i != 4) {
    suc = false;
    return 0;
  }
  suc = true;

  uint32_t result_n = 0;
  result_n |= ((result & 0xff000000) >> 24);
  result_n |= ((result & 0x00ff0000) >> 8);
  result_n |= ((result & 0x0000ff00) << 8);
  result_n |= ((result & 0x000000ff) << 24);

  return result_n;
}

namespace xsync {
namespace sig_generator_module {
static map<string, ControlMode_t> Str2ControlModeMap = {
    {"manualTrigger", kControlMode_manualTrigger},  //
    {"extTimecodeTrigger", kControlMode_externalTimecodeTrigger},
    {"ttl1Trigger", kControlMode_externalTTL1Trigger},
    {"ttl2Trigger", kControlMode_externalTTL2Trigger},
    {"ttl3Trigger", kControlMode_externalTTL3Trigger},
    {"ttl4Trigger", kControlMode_externalTTL4Trigger},
};

string ControlMode2Str(ControlMode_t mode) {
  for (auto &item : Str2ControlModeMap) {
    if (item.second == mode) return item.first;
  }
  return "unkown";
}
ControlMode_t Str2ControlMode(string mode) {
  auto it = Str2ControlModeMap.find(mode);
  if (it != Str2ControlModeMap.end()) {
    return it->second;
  }
  return kControlMode_manualTrigger;
}
list<string> ControlModeStrSet() {
  list<string> ret;
  for (auto &item : Str2ControlModeMap) {
    ret.push_back(item.first);
  }
  return ret;
}
}  // namespace sig_generator_module

namespace timecode_output_module {
static map<string, TriggerSigType_t> Str2TriggerSigTypeMap = {
    {"off", koff},  //
    {"ext_timecode_sig", kext_timecode_sig},
    {"internal_timecode_sig", kinternal_timecode_sig},
};

string TriggerSigType2Str(TriggerSigType_t type) {
  for (auto &item : Str2TriggerSigTypeMap) {
    if (item.second == type) return item.first;
  }
  return "unkown";
}
TriggerSigType_t Str2TriggerSigType(string type) {
  auto it = Str2TriggerSigTypeMap.find(type);
  if (it != Str2TriggerSigTypeMap.end()) {
    return it->second;
  }
  return koff;
}
list<string> TriggerSigTypeStrSet() {
  list<string> ret;
  for (auto &item : Str2TriggerSigTypeMap) {
    ret.push_back(item.first);
  }
  return ret;
}

static map<string, OutputSigLevelType_t> Str2OutputSigLevelTypeMap = {
    {"line", kline},  //
    {"mic", kmic},
};
string OutputSigLevelType2Str(OutputSigLevelType_t type) {
  for (auto &item : Str2OutputSigLevelTypeMap) {
    if (item.second == type) return item.first;
  }
  return "unkown";
}
OutputSigLevelType_t Str2OutputSigLevelType(string type) {
  auto it = Str2OutputSigLevelTypeMap.find(type);
  if (it != Str2OutputSigLevelTypeMap.end()) {
    return it->second;
  }
  return kline;
}
list<string> OutputSigLevelTypeStrSet() {
  list<string> ret;
  for (auto &item : Str2OutputSigLevelTypeMap) {
    ret.push_back(item.first);
  }
  return ret;
}

}  // namespace timecode_output_module

namespace camera_sync_packet_generator_module {
static map<string, TriggerSigType_t> Str2TriggerSigTypeMap = {
    {"off", koff},  //
    {"internal_genlock_sig", kinternal_genlock_sig},
    {"ext_genlock_sig", kext_genlock_sig},
};
string TriggerSigType2Str(TriggerSigType_t type) {
  for (auto &item : Str2TriggerSigTypeMap) {
    if (item.second == type) return item.first;
  }
  return "unkown";
}
TriggerSigType_t Str2TriggerSigType(string type) {
  auto it = Str2TriggerSigTypeMap.find(type);
  if (it != Str2TriggerSigTypeMap.end()) {
    return it->second;
  }
  return koff;
}
list<string> TriggerSigTypeStrSet() {
  list<string> ret;
  for (auto &item : Str2TriggerSigTypeMap) {
    ret.push_back(item.first);
  }
  return ret;
}

}  // namespace camera_sync_packet_generator_module

namespace timecode_input_module {

static map<string, TriggerSigType_t> Str2TriggerSigTypeMap = {
    {"off", koff},  //
    {"bnc_timecode", kbnc_timecode},
    {"headphone_timecode", kheadphone_timecode},
};
string TriggerSigType2Str(TriggerSigType_t type) {
  for (auto &item : Str2TriggerSigTypeMap) {
    if (item.second == type) return item.first;
  }
  return "unkown";
}
TriggerSigType_t Str2TriggerSigType(string type) {
  auto it = Str2TriggerSigTypeMap.find(type);
  if (it != Str2TriggerSigTypeMap.end()) {
    return it->second;
  }
  return koff;
}
list<string> TriggerSigTypeStrSet() {
  list<string> ret;
  for (auto &item : Str2TriggerSigTypeMap) {
    ret.push_back(item.first);
  }
  return ret;
}
}  // namespace timecode_input_module
}  // namespace xsync

static XsyncTimecode_t timecode64ToXsyncTimeCode(Timecode64_t tc64) {
  uint8_t frameuints  = tc64.tc0 & 0x0f;
  uint8_t frame10s    = (tc64.tc0 >> 8) & 0x3;
  uint8_t seconduints = (tc64.tc0 >> 16) & 0x0f;
  uint8_t second10s   = (tc64.tc0 >> 24) & 0x07;

  uint8_t minuteuints = tc64.tc1 & 0x0f;
  uint8_t minute10s   = (tc64.tc1 >> 8) & 0x07;
  uint8_t houruints   = (tc64.tc1 >> 16) & 0x0f;
  uint8_t hour10s     = (tc64.tc1 >> 24) & 0x03;

  XsyncTimecode_t timecode;
  timecode.hour   = hour10s * 10 + houruints;
  timecode.minute = minute10s * 10 + minuteuints;
  timecode.second = second10s * 10 + seconduints;
  timecode.frame  = frame10s * 10 + frameuints;
  return timecode;
}

static Timecode64_t timecodeTo64(XsyncTimecode_t tc) {
  Timecode64_t tc64;

  uint32_t frameuints  = tc.frame % 10;
  uint32_t frame10s    = tc.frame / 10;
  uint32_t seconduints = tc.second % 10;
  uint32_t second10s   = tc.second / 10;

  uint32_t minuteuints = tc.minute % 10;
  uint32_t minute10s   = tc.minute / 10;
  uint32_t houruints   = tc.hour % 10;
  uint32_t hour10s     = tc.hour / 10;

  tc64.tc0 = frameuints + (frame10s << 8) + (seconduints << 16) + (second10s << 24);
  tc64.tc1 = minuteuints + (minute10s << 8) + (houruints << 16) + (hour10s << 24);
  return tc64;
}

/*******************************************************************************
 *                                    Xsync                                    *
 *******************************************************************************/
Xsync::Xsync(/* args */) {}

Xsync &Xsync::Ins() {
  static Xsync xsync;
  return xsync;
}
void Xsync::initialize(I_XSUDPFactory *xsync_udp_factory) { m_xsync_udp_factory = xsync_udp_factory; }

xs_error_code_t Xsync::connect(string xsync_ip) {
  lock_guard<recursive_mutex> lock(lock_);

  m_xsync_ip = xsync_ip;
  disConnect();
  /**
   * @brief 创建 m_xsync_reg_udp
   */

  xs_error_code_t ecode = kxs_ec_success;

  auto xsync_reg_udp = m_xsync_udp_factory->createXSUDP();
  ecode              = xsync_reg_udp->initialize("0.0.0.0", IFLYTOP_XSYNC_SERVICE_PC_PORT);
  if (ecode != kxs_ec_success) {
    return ecode;
  }
  /**
   * @brief 创建 m_xsync_timecode_udp_listener
   */
  auto xsync_timecode_udp_listener = m_xsync_udp_factory->createXSUDP();

  ecode = xsync_timecode_udp_listener->initialize("0.0.0.0", IFLYTOP_XSYNC_TIMECODE_REPORT_PC_PORT);
  if (ecode != kxs_ec_success) {
    return ecode;
  }
  ecode = xsync_timecode_udp_listener->startReceive([this](XsyncNetAdd &from, uint8_t *data, size_t length) { parseTimecodeMsgAndReport(from, data, length); });
  if (ecode != kxs_ec_success) {
    return ecode;
  }

  /**
   * @brief 创建 m_xsync_camera_sync_udp_listener
   */
  auto xsync_camera_sync_udp_listener = m_xsync_udp_factory->createXSUDP();

  ecode = xsync_camera_sync_udp_listener->initialize("0.0.0.0", IFLYTOP_XSYNC_CAMERA_SYNC_PACKET_PC_PORT);
  if (ecode != kxs_ec_success) {
    return ecode;
  }
  ecode = xsync_camera_sync_udp_listener->startReceive([this](XsyncNetAdd &from, uint8_t *data, size_t length) { parseCameraSyncMsgAndReport(from, data, length); });
  if (ecode != kxs_ec_success) {
    return ecode;
  }

  m_xsync_reg_udp                  = xsync_reg_udp;
  m_xsync_timecode_udp_listener    = xsync_timecode_udp_listener;
  m_xsync_camera_sync_udp_listener = xsync_camera_sync_udp_listener;

  m_net_state = kxsync_net_state_connected;
  return ecode;
}
xs_error_code_t Xsync::disConnect() {
  lock_guard<recursive_mutex> lock(lock_);

  if (m_xsync_reg_udp != nullptr) {
    m_xsync_reg_udp->stopReceive();
    m_xsync_reg_udp = nullptr;
  }

  if (m_xsync_timecode_udp_listener != nullptr) {
    m_xsync_timecode_udp_listener->stopReceive();
    m_xsync_timecode_udp_listener = nullptr;
  }

  if (m_xsync_camera_sync_udp_listener != nullptr) {
    m_xsync_camera_sync_udp_listener->stopReceive();
    m_xsync_camera_sync_udp_listener = nullptr;
  }

  m_net_state = kxsync_net_state_disconnect;
  return kxs_ec_success;
}
xsync_net_state_t Xsync::getNetState() { return m_net_state; }

void Xsync::Basic_registerOnTimecodeMsgCallback(xsync_on_timecode_msg_t on_timecode_msg_cb) { m_on_timecode_msg_cb = on_timecode_msg_cb; }
void Xsync::Basic_registerOnCameraSyncMsgCallback(xsync_on_camera_sync_msg_t on_camera_sync_msg_cb) { m_on_camera_sync_msg_cb = on_camera_sync_msg_cb; }
void Xsync::Basic_registerOnWorkstateChangeMsgCallback(xsync_on_workstate_change_msg_t on_workstate_change_msg_cb) { m_on_workstate_change_msg_cb = on_workstate_change_msg_cb; }

xs_error_code_t Xsync::xsync_send_cmd_block(iflytop_xsync_packet_header_t *cmd, iflytop_xsync_packet_header_t *rx_data, int32_t buffersize, int32_t overtime_ms) {
  lock_guard<recursive_mutex> lock(lock_);
  if (!m_xsync_reg_udp) return kxs_ec_lose_connect;
  m_xsync_reg_udp->clearRxBuffer();

  cmd->index = txpacket_index++;

  XsyncNetAdd     toadd = {m_xsync_ip, IFLYTOP_XSYNC_SERVICE_XSYNC_PORT};
  xs_error_code_t ecode =  //
      m_xsync_reg_udp->sendto(toadd, (const char *)cmd, sizeof(iflytop_xsync_packet_header_t) + cmd->ndata * 4, nullptr);
  if (ecode != kxs_ec_success) {
    return ecode;
  }

  XsyncNetAdd fromadd;
  while (true) {
    // ZLOGI(TAG, "start rx wait for rxdata");
    ecode = m_xsync_reg_udp->receive((char *)rx_data, buffersize, fromadd, overtime_ms);
    // ZLOGI(TAG, "end rx wait for rxdata");
    if (ecode != kxs_ec_success) {
      return ecode;
    }
    if (rx_data->index != cmd->index) {
      // ZLOGI(TAG, "packet index error %d %d", cmd->index, rx_data->index);
      continue;
    }
    break;
  }

  return (xs_error_code_t)rx_data->data[0];
}
xs_error_code_t Xsync::reg_write(uint32_t regadd, uint32_t regvalue, int32_t overtime_ms) {  //
  uint32_t readbak = 0;
  return reg_write(regadd, regvalue, readbak, overtime_ms);
}
xs_error_code_t Xsync::reg_write(uint32_t regadd, uint32_t regvalue, uint32_t &regbackvalue, int32_t overtime_ms) {
  /**
   * @brief
   *      协议说明
   *
   * kxsync_packet_type_reg_write
   *  tx: regadd,regdata
   *  rx: ecode,regdata
   */

  uint8_t txdata[128] = {0};
  uint8_t rxdata[128] = {0};

  iflytop_xsync_packet_header_t *txpacket = (iflytop_xsync_packet_header_t *)txdata;
  iflytop_xsync_packet_header_t *rxpacket = (iflytop_xsync_packet_header_t *)rxdata;

  txpacket->type    = kxsync_packet_type_cmd;
  txpacket->index   = txpacket_index++;
  txpacket->cmd     = kxsync_packet_type_reg_write;
  txpacket->ndata   = 2;
  txpacket->data[0] = regadd;
  txpacket->data[1] = regvalue;

  auto ecode = xsync_send_cmd_block(txpacket, rxpacket, sizeof(rxdata), overtime_ms);
  if (ecode != kxs_ec_success) {
    return ecode;
  }

  regbackvalue = rxpacket->data[1];
  return ecode;
}

xs_error_code_t Xsync::reg_read(uint32_t regadd, uint32_t &regvalue, int32_t overtime_ms) {
  /**
   * @brief
   *      协议说明
   *
   * kxsync_packet_type_reg_write
   *  tx: regadd,regdata
   *  rx: ecode,regdata
   */

  uint8_t txdata[128] = {0};
  uint8_t rxdata[128] = {0};

  iflytop_xsync_packet_header_t *txpacket = (iflytop_xsync_packet_header_t *)txdata;
  iflytop_xsync_packet_header_t *rxpacket = (iflytop_xsync_packet_header_t *)rxdata;

  txpacket->type    = kxsync_packet_type_cmd;
  txpacket->index   = txpacket_index++;
  txpacket->cmd     = kxsync_packet_type_reg_read;
  txpacket->ndata   = 2;
  txpacket->data[0] = regadd;
  txpacket->data[1] = regvalue;

  auto ecode = xsync_send_cmd_block(txpacket, rxpacket, sizeof(rxdata), overtime_ms);
  if (ecode != kxs_ec_success) {
    return ecode;
  }
  regvalue = rxpacket->data[1];
  return ecode;
}
xs_error_code_t Xsync::reg_read_muti(uint32_t regadd, uint32_t nreg, vector<uint32_t> &regvalues, int32_t overtime_ms) {
  /**
   * @brief
   *      协议说明
   *
   * kxsync_packet_type_reg_read_regs
   *  tx: regstartadd,nreg
   *  rx: ecode,regdatas
   */

  uint8_t txdata[128]  = {0};
  uint8_t rxdata[1280] = {0};

  iflytop_xsync_packet_header_t *txpacket = (iflytop_xsync_packet_header_t *)txdata;
  iflytop_xsync_packet_header_t *rxpacket = (iflytop_xsync_packet_header_t *)rxdata;

  txpacket->type    = kxsync_packet_type_cmd;
  txpacket->index   = txpacket_index++;
  txpacket->cmd     = kxsync_packet_type_reg_read_regs;
  txpacket->ndata   = 2;
  txpacket->data[0] = regadd;
  txpacket->data[1] = nreg;

  auto ecode = xsync_send_cmd_block(txpacket, rxpacket, sizeof(rxdata), overtime_ms);
  if (ecode != kxs_ec_success) {
    return ecode;
  }

  if (rxpacket->ndata > 0) {
    for (int i = 0; i < rxpacket->ndata - 1; i++) {
      regvalues.push_back(rxpacket->data[i + 1]);
    }
  }
  return ecode;
}

xs_error_code_t Xsync::readtimecode(uint32_t reg0, uint32_t reg1, XsyncTimecode_t &timecode) {
  uint32_t        readbak = 0;
  xs_error_code_t ecode   = kxs_ec_success;

  uint32_t tc0 = 0;
  uint32_t tc1 = 0;

  ecode = reg_read(reg0, tc0, 10);
  if (ecode != kxs_ec_success) return ecode;
  ecode = reg_read(reg1, tc1, 10);
  if (ecode != kxs_ec_success) return ecode;

  Timecode64_t tc64;
  tc64.tc0 = tc0;
  tc64.tc1 = tc1;

  timecode = timecode64ToXsyncTimeCode(tc64);
  return ecode;
}
xs_error_code_t Xsync::writetimecode(uint32_t reg0, uint32_t reg1, XsyncTimecode_t timecode) {
  uint32_t        readbak = 0;
  xs_error_code_t ecode   = kxs_ec_success;

  Timecode64_t tc64 = timecodeTo64(timecode);

  ecode = reg_write(reg0, tc64.tc0, readbak, 10);
  if (ecode != kxs_ec_success) return ecode;
  ecode = reg_write(reg1, tc64.tc1, readbak, 10);
  if (ecode != kxs_ec_success) return ecode;

  return ecode;
}

xs_error_code_t Xsync::readfreq(uint32_t reg, float &freqfloat) {
  uint32_t freq_cnt = 0;
  DO_XSYNC(reg_read(reg, freq_cnt));
  if (freq_cnt == 0) {
    freqfloat = 0;
  }

  if (freq_cnt != 0) {
    uint32_t freq_10x = ((uint32_t)(1.0 / (freq_cnt * 1.0 / (10 * 1000 * 1000))) * 10 + 0.5);  //+0.5是因为c++ 小数强转成整数时是取整，而非四舍五入
    freqfloat         = freq_10x / 10.0;
  } else {
    freqfloat = 0;
  }
  return kxs_ec_success;
}

void Xsync::parseTimecodeMsgAndReport(XsyncNetAdd &from, uint8_t *data, size_t length) {
  iflytop_xsync_event_report_packet_t *packet = (iflytop_xsync_event_report_packet_t *)data;
  if (packet->eventid == ktimecode_report_event) {
    Timecode64_t tc64;
    tc64.tc0                 = packet->data[0];
    tc64.tc1                 = packet->data[1];
    XsyncTimecode_t timecode = timecode64ToXsyncTimeCode(tc64);
    if (m_on_timecode_msg_cb) m_on_timecode_msg_cb(&timecode);
  } else if (packet->eventid == kxsync_work_state_report_event) {
    // 信号发生器状态改变
    if (m_on_workstate_change_msg_cb) m_on_workstate_change_msg_cb(packet->data[0]);
  }
}
void Xsync::parseCameraSyncMsgAndReport(XsyncNetAdd &from, uint8_t *data, size_t length) {
  uint32_t count = 0;

  uint32_t data0 = data[7];
  uint32_t data1 = data[6];
  uint32_t data2 = data[5];
  uint32_t data3 = data[4];

  count = data0 + (data1 << 8) + (data2 << 16) + (data3 << 24);

  xysnc_camera_sync_data_t camera_sync_data;
  camera_sync_data.frameIndex = count;

  if (m_on_camera_sync_msg_cb) m_on_camera_sync_msg_cb(&camera_sync_data);
}

xs_error_code_t Xsync::Basic_generatorNewMac() { return doaction(xsync_stm32_action_generator_new_mac, 0, nullptr, 2000); }
xs_error_code_t Xsync::Basic_factoryReset() { return doaction(xsync_stm32_action_factory_reset, 0, nullptr, 1000); }
xs_error_code_t Xsync::Basic_reboot() { return doaction(xsync_stm32_action_Basic_reboot, 0, nullptr); }
xs_error_code_t Xsync::storageConfig() { return doaction(xsync_stm32_action_storage_cfg, 0, nullptr, 1000); }
xs_error_code_t Xsync::Basic_changeNetworkConfig(string ip, string mask, string gateway) {
  uint32_t        ip32      = 0;
  uint32_t        mask32    = 0;
  uint32_t        gateway32 = 0;
  xs_error_code_t ecode;
  bool            suc = false;

  ip32 = (uint32_t)ipToUint32(ip.c_str(), suc);
  if (!suc) return kxs_ec_param_error;
  mask32 = (uint32_t)ipToUint32(mask.c_str(), suc);
  if (!suc) return kxs_ec_param_error;
  gateway32 = (uint32_t)ipToUint32(gateway.c_str(), suc);
  if (!suc) return kxs_ec_param_error;

  uint32_t readbak = 0;

  ecode = reg_write(reg::kstm32_ip, ip32, readbak);
  if (ecode != kxs_ec_success) return ecode;
  ecode = reg_write(reg::kstm32_netmask, mask32, readbak);
  if (ecode != kxs_ec_success) return ecode;
  ecode = reg_write(reg::kstm32_gw, gateway32, readbak);
  if (ecode != kxs_ec_success) return ecode;

  ecode = storageConfig();
  if (ecode != kxs_ec_success) return ecode;

  return kxs_ec_success;
}

xs_error_code_t Xsync::Basic_clearXsyncCameraSyncIndexCount() {
  uint32_t readbak = 0;
  return reg_write(reg::kstm32_camera_sync_signal_count, 0, readbak);
}

xs_error_code_t Xsync::doaction(uint32_t action, uint32_t actionval, uint32_t *ackreturn, int32_t overtime_ms) {
  //
  uint32_t        readbak = 0;
  xs_error_code_t ecode;
  ecode = reg_write(reg::kstm32_action_val0, actionval, readbak);
  if (ecode != kxs_ec_success) return ecode;

  ecode = reg_write(reg::kstm32_action0, action, readbak, overtime_ms);
  if (ecode != kxs_ec_success) return ecode;
  if (ackreturn) *ackreturn = readbak;
  return ecode;
}

// xs_error_code_t Xsync::Basic_setGenlockFormat(GenlockFormat_t format) {
//   DO_XSYNC(SigGenerator_setGenlockFormat(format));
//   return kxs_ec_success;
// }
// xs_error_code_t Xsync::Basic_getGenlockFormat(GenlockFormat_t &format) {
//   DO_XSYNC(SigGenerator_getGenlockFormat(format));
//   return kxs_ec_success;
// }
// xs_error_code_t Xsync::Basic_setTimecodeFormat(TimecodeFormat_t format) {
//   uint32_t readbak = 0;
//   return kxs_ec_success;
// }

xs_error_code_t Xsync::CameraSyncPacketGeneratorModule_setTriggerSig(camera_sync_packet_generator_module::TriggerSigType_t sig) {
  uint32_t readbak = 0;
  DO_XSYNC(reg_write(reg::kcamera_sync_out_camera_sync_select, sig, readbak, 10));
  return kxs_ec_success;
}
xs_error_code_t Xsync::CameraSyncPacketGeneratorModule_getTriggerSig(camera_sync_packet_generator_module::TriggerSigType_t &sig) {
  uint32_t readbak = 0;
  DO_XSYNC(reg_read(reg::kcamera_sync_out_camera_sync_select, readbak, 10));
  sig = (camera_sync_packet_generator_module::TriggerSigType_t)readbak;
  return kxs_ec_success;
}

xs_error_code_t Xsync::CameraSyncPacketGeneratorModule_setReportPeriod(uint32_t packetNum) {
  uint32_t readbak = 0;
  if (packetNum == 0) packetNum = 1;
  DO_XSYNC(reg_write(reg::kstm32_camera_sync_signal_count_report_period, packetNum, readbak, 10));
  return kxs_ec_success;
}
xs_error_code_t Xsync::CameraSyncPacketGeneratorModule_getReportPeriod(uint32_t &packetNum) {
  uint32_t readbak = 0;
  DO_XSYNC(reg_read(reg::kstm32_camera_sync_signal_count_report_period, readbak, 10));
  packetNum = readbak;
  return kxs_ec_success;
}
xs_error_code_t Xsync::CameraSyncPacketGeneratorModule_getPacketIndex(uint32_t &index) {
  uint32_t readbak = 0;
  DO_XSYNC(reg_read(reg::kstm32_camera_sync_signal_count, readbak, 10));
  index = readbak;
  return kxs_ec_success;
}
xs_error_code_t Xsync::CameraSyncPacketGeneratorModule_clearPacketIndex() {
  uint32_t readbak = 0;
  DO_XSYNC(reg_write(reg::kstm32_camera_sync_signal_count, 0, readbak, 10));
  return kxs_ec_success;
}

/*******************************************************************************
 *                                   新接口                                    *
 *******************************************************************************/

/*******************************************************************************
 *                               TTLInputModule                                *
 *******************************************************************************/
#define FREQ_CNT_TO_FREQ(cnt) ((cnt != 0) ? (uint32_t)(1.0 / (cnt * 1.0 / (10 * 1000 * 1000)) + 0.5) : 0)  //+0.5是因为c++ 小数强转成整数时是取整，而非四舍五入

xs_error_code_t Xsync::TTLInputModule1_detectFreq(uint32_t &freq) {
  uint32_t freq_cnt = 0;
  DO_XSYNC(reg_read(reg::k_ttlin1_freq_detector_reg, freq_cnt, 10));
  if (freq_cnt == 0) {
    freq = 0;
  }
  freq = FREQ_CNT_TO_FREQ(freq_cnt);
  return kxs_ec_success;
}
xs_error_code_t Xsync::TTLInputModule2_detectFreq(uint32_t &freq) {
  uint32_t freq_cnt = 0;
  DO_XSYNC(reg_read(reg::k_ttlin2_freq_detector_reg, freq_cnt, 10));
  freq = FREQ_CNT_TO_FREQ(freq_cnt);
  return kxs_ec_success;
}
xs_error_code_t Xsync::TTLInputModule3_detectFreq(uint32_t &freq) {
  uint32_t freq_cnt = 0;
  DO_XSYNC(reg_read(reg::k_ttlin3_freq_detector_reg, freq_cnt, 10));
  freq = FREQ_CNT_TO_FREQ(freq_cnt);
  return kxs_ec_success;
}
xs_error_code_t Xsync::TTLInputModule4_detectFreq(uint32_t &freq) {
  uint32_t freq_cnt = 0;
  DO_XSYNC(reg_read(reg::k_ttlin4_freq_detector_reg, freq_cnt, 10));
  freq = FREQ_CNT_TO_FREQ(freq_cnt);
  return kxs_ec_success;
}

/*******************************************************************************
 *                               TTLOutputModule                               *
 *******************************************************************************/

//  0:固定输出低电平，1:固定输出高电平，2:分频倍频模式，3:转发模式，4:测试模式
xs_error_code_t Xsync::TTLOutputModule1_setSrcSigType(SignalType_t source) {
  if (source == SIGNAL_TTLIN1 || source == SIGNAL_TTLIN2 || source == SIGNAL_TTLIN3 || source == SIGNAL_TTLIN4) {
    DO_XSYNC(reg_write(reg::kreg_ttlout1_signal_process_mode, 2, 10));  // 分频倍频模式
  } else {
    DO_XSYNC(reg_write(reg::kreg_ttlout1_signal_process_mode, 3, 10));  // 转发模式
  }
  REG_WRITE(reg::kreg_ttlout1_input_signal_select, source);
}
xs_error_code_t Xsync::TTLOutputModule2_setSrcSigType(SignalType_t source) {
  if (source == SIGNAL_TTLIN1 || source == SIGNAL_TTLIN2 || source == SIGNAL_TTLIN3 || source == SIGNAL_TTLIN4) {
    DO_XSYNC(reg_write(reg::kreg_ttlout2_signal_process_mode, 2, 10));  // 分频倍频模式
  } else {
    DO_XSYNC(reg_write(reg::kreg_ttlout2_signal_process_mode, 3, 10));  // 转发模式
  }
  REG_WRITE(reg::kreg_ttlout2_input_signal_select, source);
}
xs_error_code_t Xsync::TTLOutputModule3_setSrcSigType(SignalType_t source) {
  if (source == SIGNAL_TTLIN1 || source == SIGNAL_TTLIN2 || source == SIGNAL_TTLIN3 || source == SIGNAL_TTLIN4) {
    DO_XSYNC(reg_write(reg::kreg_ttlout3_signal_process_mode, 2, 10));  // 分频倍频模式
  } else {
    DO_XSYNC(reg_write(reg::kreg_ttlout3_signal_process_mode, 3, 10));  // 转发模式
  }
  REG_WRITE(reg::kreg_ttlout3_input_signal_select, source);
}
xs_error_code_t Xsync::TTLOutputModule4_setSrcSigType(SignalType_t source) {
  if (source == SIGNAL_TTLIN1 || source == SIGNAL_TTLIN2 || source == SIGNAL_TTLIN3 || source == SIGNAL_TTLIN4) {
    DO_XSYNC(reg_write(reg::kreg_ttlout4_signal_process_mode, 2, 10));  // 分频倍频模式
  } else {
    DO_XSYNC(reg_write(reg::kreg_ttlout4_signal_process_mode, 3, 10));  // 转发模式
  }
  REG_WRITE(reg::kreg_ttlout4_input_signal_select, source);
}

xs_error_code_t Xsync::TTLOutputModule1_getSrcSigType(SignalType_t &source) { REG_READ(reg::kreg_ttlout1_input_signal_select, source); }
xs_error_code_t Xsync::TTLOutputModule2_getSrcSigType(SignalType_t &source) { REG_READ(reg::kreg_ttlout2_input_signal_select, source); }
xs_error_code_t Xsync::TTLOutputModule3_getSrcSigType(SignalType_t &source) { REG_READ(reg::kreg_ttlout3_input_signal_select, source); }
xs_error_code_t Xsync::TTLOutputModule4_getSrcSigType(SignalType_t &source) { REG_READ(reg::kreg_ttlout4_input_signal_select, source); }

xs_error_code_t Xsync::TTLOutputModule1_setFreqDivision(uint32_t div) { REG_WRITE(reg::kreg_ttlout1_pllout_freq_division_ctrl, div); }
xs_error_code_t Xsync::TTLOutputModule2_setFreqDivision(uint32_t div) { REG_WRITE(reg::kreg_ttlout2_pllout_freq_division_ctrl, div); }
xs_error_code_t Xsync::TTLOutputModule3_setFreqDivision(uint32_t div) { REG_WRITE(reg::kreg_ttlout3_pllout_freq_division_ctrl, div); }
xs_error_code_t Xsync::TTLOutputModule4_setFreqDivision(uint32_t div) { REG_WRITE(reg::kreg_ttlout4_pllout_freq_division_ctrl, div); }

xs_error_code_t Xsync::TTLOutputModule1_getFreqDivision(uint32_t &div) { REG_READ(reg::kreg_ttlout1_pllout_freq_division_ctrl, div); }
xs_error_code_t Xsync::TTLOutputModule2_getFreqDivision(uint32_t &div) { REG_READ(reg::kreg_ttlout2_pllout_freq_division_ctrl, div); }
xs_error_code_t Xsync::TTLOutputModule3_getFreqDivision(uint32_t &div) { REG_READ(reg::kreg_ttlout3_pllout_freq_division_ctrl, div); }
xs_error_code_t Xsync::TTLOutputModule4_getFreqDivision(uint32_t &div) { REG_READ(reg::kreg_ttlout4_pllout_freq_division_ctrl, div); }

xs_error_code_t Xsync::TTLOutputModule1_setFreqMultiplication(uint32_t multi) { REG_WRITE(reg::kreg_ttlout1_pllout_freq_multiplication_ctrl, multi); }
xs_error_code_t Xsync::TTLOutputModule2_setFreqMultiplication(uint32_t multi) { REG_WRITE(reg::kreg_ttlout2_pllout_freq_multiplication_ctrl, multi); }
xs_error_code_t Xsync::TTLOutputModule3_setFreqMultiplication(uint32_t multi) { REG_WRITE(reg::kreg_ttlout3_pllout_freq_multiplication_ctrl, multi); }
xs_error_code_t Xsync::TTLOutputModule4_setFreqMultiplication(uint32_t multi) { REG_WRITE(reg::kreg_ttlout4_pllout_freq_multiplication_ctrl, multi); }

xs_error_code_t Xsync::TTLOutputModule1_getFreqMultiplication(uint32_t &multi) { REG_READ(reg::kreg_ttlout1_pllout_freq_multiplication_ctrl, multi); }
xs_error_code_t Xsync::TTLOutputModule2_getFreqMultiplication(uint32_t &multi) { REG_READ(reg::kreg_ttlout2_pllout_freq_multiplication_ctrl, multi); }
xs_error_code_t Xsync::TTLOutputModule3_getFreqMultiplication(uint32_t &multi) { REG_READ(reg::kreg_ttlout3_pllout_freq_multiplication_ctrl, multi); }
xs_error_code_t Xsync::TTLOutputModule4_getFreqMultiplication(uint32_t &multi) { REG_READ(reg::kreg_ttlout4_pllout_freq_multiplication_ctrl, multi); }

/*******************************************************************************
 *                             TimecodeInputModule                             *
 *******************************************************************************/
xs_error_code_t Xsync::ExternalTimecode_setSource(InputInterface_t src) {
  if (src == INPUT_IF_TIMECODE_BNC) {
    DO_XSYNC(reg_write(reg::external_timecode_sig_selt, 1, 10));  // 0:off,1:bnc,2:headphone
  } else if (src == INPUT_IF_TIMECODE_HEADPHONE) {
    DO_XSYNC(reg_write(reg::external_timecode_sig_selt, 2, 10));  // 0:off,1:bnc,2:headphone
  } else if (src == INPUT_IF_OFF) {
    DO_XSYNC(reg_write(reg::external_timecode_sig_selt, 0, 10));  // 0:off,1:bnc,2:headphone
  } else {
    return kxs_ec_param_error;
  }
  return kxs_ec_success;
}
xs_error_code_t Xsync::ExternalTimecode_getSource(InputInterface_t &timecode_select) {
  uint32_t readbak = 0;
  DO_XSYNC(reg_read(reg::external_timecode_sig_selt, readbak, 10));
  if (readbak == 1) {
    timecode_select = INPUT_IF_TIMECODE_BNC;
  } else if (readbak == 2) {
    timecode_select = INPUT_IF_TIMECODE_HEADPHONE;
  } else if (readbak == 0) {
    timecode_select = INPUT_IF_OFF;
  } else {
    timecode_select = INPUT_IF_OFF;
  }
  return kxs_ec_success;
}
xs_error_code_t Xsync::ExternalTimecode_setFormat(TimecodeFormat_t format) { REG_WRITE(reg::external_timecode_format, format); }
xs_error_code_t Xsync::ExternalTimecode_getFormat(TimecodeFormat_t &format) { REG_READ(reg::external_timecode_format, format); }
xs_error_code_t Xsync::ExternalTimecode_readCode(XsyncTimecode_t &timecode) { return readtimecode(reg::external_timecode_code0, reg::external_timecode_code1, timecode); }

/*******************************************************************************
 *                              InternalTimecode                               *
 *******************************************************************************/
xs_error_code_t Xsync::InternalTimecode_setFormat(TimecodeFormat_t format) { REG_WRITE(reg::internal_timecode_format, format); }
xs_error_code_t Xsync::InternalTimecode_getFormat(TimecodeFormat_t &format) { REG_READ(reg::internal_timecode_format, format); }
xs_error_code_t Xsync::InternalTimecode_setCode(XsyncTimecode_t timecode) {
  DO_XSYNC(reg_write(reg::internal_timecode_en, 0));
  DO_XSYNC(writetimecode(reg::internal_timecode_data0, reg::internal_timecode_data1, timecode));
  DO_XSYNC(reg_write(reg::internal_timecode_en, 1));
  return kxs_ec_success;
}
xs_error_code_t Xsync::InternalTimecode_getCode(XsyncTimecode_t &timecode) { return readtimecode(reg::internal_timecode_data0, reg::internal_timecode_data1, timecode); }

/*******************************************************************************
 *                                 SysTimecode                                 *
 *******************************************************************************/
xs_error_code_t Xsync::SysTimecode_setSource(uint32_t sig) { REG_WRITE(reg::sys_timecode_select, sig); }
xs_error_code_t Xsync::SysTimecode_getSource(uint32_t &sig) { REG_READ(reg::sys_timecode_select, sig); }
xs_error_code_t Xsync::SysTimecode_readFormat(TimecodeFormat_t &format) { REG_READ(reg::sys_timecode_format, format); }
xs_error_code_t Xsync::SysTimecode_readCode(XsyncTimecode_t &timecode) { return readtimecode(reg::sys_timecode_data0, reg::sys_timecode_data1, timecode); }
/*******************************************************************************
 *                            TimecodeOutputModule                             *
 *******************************************************************************/
xs_error_code_t Xsync::TimecodeOutputModule_setBncOutputLevel(int level) { REG_WRITE(reg::timecode_output_bnc_outut_level_select, level); }
xs_error_code_t Xsync::TimecodeOutputModule_getBncOutputLevel(int &level) { REG_READ(reg::timecode_output_bnc_outut_level_select, level); }
xs_error_code_t Xsync::TimecodeOutputModule_setHeadphoneOutputLevel(int level) { REG_WRITE(reg::timecode_output_headphone_outut_level_select, level); }
xs_error_code_t Xsync::TimecodeOutputModule_getHeadphoneOutputLevel(int &level) { REG_READ(reg::timecode_output_headphone_outut_level_select, level); }
/*******************************************************************************
 *                                   GENLOCK                                   *
 *******************************************************************************/
xs_error_code_t Xsync::ExternalGenlock_detectFreq(float &freq) { return readfreq(reg::external_genlock_freq, freq); }
xs_error_code_t Xsync::InternalGenlock_setFormat(GenlockFormat_t format) { return reg_write(reg::internal_genlock_format, format); }
xs_error_code_t Xsync::InternalGenlock_getFormat(GenlockFormat_t &format) { REG_READ(reg::internal_genlock_format, format); }
xs_error_code_t Xsync::SysGenlock_setSrc(SignalType_t sig) { return reg_write(reg::sys_genlock_source, sig); }
xs_error_code_t Xsync::SysGenlock_getSrc(SignalType_t &sig) { REG_READ(reg::sys_genlock_source, sig); }
xs_error_code_t Xsync::SysGenlock_readFreq(float &freq) { return readfreq(reg::sys_genlock_freq, freq); }

/*******************************************************************************
 *                                    INTERNAL_CLOCK                           *
 *******************************************************************************/
xs_error_code_t Xsync::InternalClock_setFreq(float freq) {
  double T    = 1.0 / freq;
  double T_ns = T * 1000 * 1000 * 1000;
  double cnt  = T_ns / 100 + 0.5;  // 10MHZ <=> 100ns

  uint32_t cnt_u32 = uint32_t(cnt);
  return reg_write(reg::internal_clock_freq, cnt_u32);
  return kxs_ec_success;
}
xs_error_code_t Xsync::InternalClock_getFreq(float &freq) { return readfreq(reg::internal_clock_freq, freq); }
/*******************************************************************************
 *                                  SysClock                                   *
 *******************************************************************************/
xs_error_code_t Xsync::SysClock_setSrc(SignalType_t sig) { return reg_write(reg::sys_clock_source, sig); }
xs_error_code_t Xsync::SysClock_getSrc(SignalType_t &sig) { REG_READ(reg::sys_clock_source, sig); }
xs_error_code_t Xsync::SysClock_setTriggerEdge(TriggerEdge_t edge) { return reg_write(reg::sys_clock_trigger_edge_select, edge); }
xs_error_code_t Xsync::SysClock_getTriggerEdge(TriggerEdge_t &edge) { return _reg_read(reg::sys_clock_trigger_edge_select, edge); }
xs_error_code_t Xsync::SysClock_setFreqDivision(uint32_t div) { return reg_write(reg::sys_clock_freq_division_ctrl, div); }
xs_error_code_t Xsync::SysClock_geFreqtDivision(uint32_t &div) { return _reg_read(reg::sys_clock_freq_division_ctrl, div); }
xs_error_code_t Xsync::SysClock_setFreqMultiplication(uint32_t muti) { return reg_write(reg::sys_clock_freq_multiplication_ctrl, muti); }
xs_error_code_t Xsync::SysClock_getFreqMultiplication(uint32_t &muti) { return _reg_read(reg::sys_clock_freq_multiplication_ctrl, muti); }
xs_error_code_t Xsync::SysClock_readFreq(float &freq) { return readfreq(reg::sys_clock_outfreq_detect, freq); }
xs_error_code_t Xsync::SysClock_readInputFreq(float &freq) { return readfreq(reg::sys_clock_infreq_detect, freq); }