#include "takephoto.h"

// 模块名称
static const char MODULE_NAME[] = "TakePhoto";

// 保存照片
static int SavePhoto(HANDLE hCam, MV_FRAME_OUT *pFrame, EImgType imgType, const char *imgFile);

// 单次执行相机拍照, 并保存到文件, 成功返回: 0值, 失败返回:非0值
// "imgType"         - 获取图像类型
// "saveImgFilename" - 保存的文件名
// "timeout"         - 等待超时时间, 单位：秒: < 0 表示无超时;
//                     无论超时怎么设置, 首次尝试拍照一定会执行
//                     , 但时间不确定; 拍照成功、超时或发生错误
//                     时会自动结束任务(相机持续无数据的时间).
// "pImgMark"        - 输出本次拍照图像的水印信息, 可以设置NULL
int TakePhoto(EImgType imgType, const char *saveImgFilename, int timeout, SImgMark *pImgMark)
{
  int fd; char runDir[MAX_PATH_CHARS] = { 0 }, lockFile[MAX_PATH_CHARS+32] = { 0 };
  int ret, waitTimeTick/* 计时单位: 秒 */; SImgMark imgMark = { 0 }; HANDLE hCam = NULL;
  MV_FRAME_OUT frame; MV_CC_DEVICE_INFO_LIST devList = { 0 }; MV_CC_DEVICE_INFO *pDevInfo;
  unsigned long startTime, now; // 计算"waitTimeTick"时使用

  // 1, 占用锁定, 避免同时间拍照
  xGetSelfRunningInfo(runDir, NULL);
  if(runDir[strlen(runDir)-1] == '/') sprintf(lockFile, "%s%s", runDir, "status/");
  else sprintf(lockFile, "%s/%s", runDir, "status/");
  if(!sw_dir_exists(lockFile)) sw_dir_create(lockFile);
  strcat(lockFile, "takephoto.lock");

  fd = open(lockFile, O_CREAT | O_RDWR | __O_CLOEXEC, 0666);
  if(-1 == fd) { return -1; }

  if(-1 == flock(fd, LOCK_EX | LOCK_NB)) { close(fd); return -2; }

  // 2, 查找相机, 获取其设备信息
  ret = MV_CC_Initialize();
  if(MV_OK != ret)
  {
    sw_log_error("[%s] 相机SDK初始化失败, errCode=0x%x!!", MODULE_NAME, ret);
    goto end_p;
  }

  ret = MV_CC_EnumDevices(MV_USB_DEVICE, &devList); // 目前只枚举USB连接的相机
  if(MV_OK != ret)
  {
    sw_log_error("[%s] USB口枚举相机失败, errCode=0x%x!!", MODULE_NAME, ret);
    goto end_p;
  }
  if(devList.nDeviceNum != 1)
  {
    ret = -3;
    sw_log_error("[%s] USB口相机数量错误, deviceNum=%u!!", MODULE_NAME, devList.nDeviceNum);
    goto end_p;
  }

  pDevInfo = devList.pDeviceInfo[0];
  if(!pDevInfo)
  {
    ret = -4;
    sw_log_error("[%s] unexpected internal error, unable to obtain detailed information about the industrial camera!!", MODULE_NAME);
    goto end_p;
  }
  strcpy(imgMark.camModelName, (const char *)pDevInfo->SpecialInfo.stUsb3VInfo.chModelName);
  strcpy(imgMark.camSerialNum, (const char *)pDevInfo->SpecialInfo.stUsb3VInfo.chSerialNumber);

  // 3, 打开相机, 设置其触发模式
  ret = MV_CC_CreateHandleWithoutLog(&hCam, pDevInfo);
  if(MV_OK == ret) ret = MV_CC_OpenDevice(hCam, MV_ACCESS_Exclusive, 0);
  if(MV_OK == ret) ret = MV_USB_SetTransferWays(hCam, 1); // 设置传输通道个数(RTU硬件资源有限, 需要降低通道数)
  if(MV_OK != ret)
  {
    sw_log_error("[%s] USB口相机打开失败, errCode=0x%x!!", MODULE_NAME, ret);
    goto end_p;
  }

  ret = MV_CC_SetEnumValue(hCam, "TriggerMode", 1); // 允许触发模式
  if(MV_OK == ret) ret = MV_CC_SetEnumValue(hCam, "TriggerSource", MV_TRIGGER_SOURCE_SOFTWARE); // 设置软件触发
  if(MV_OK != ret)
  {
    sw_log_error("[%s] USB口相机设置失败, errCode=0x%x!!", MODULE_NAME, ret);
    goto end_p;
  }

  // 4, 开始拍照, 等待完成后输出
  ret = MV_CC_StartGrabbing(hCam);
  if(MV_OK != ret)
  {
    sw_log_error("[%s] USB口相机取流失败, errCode=0x%x!!", MODULE_NAME, ret);
    goto end_p;
  }

  waitTimeTick = 0; xgettickcount(&startTime);
  do
  {
    ret = MV_CC_SetCommandValue(hCam, "TriggerSoftware"); // 触发一次拍照
    if(MV_OK == ret)
    {
      memset(&frame, 0, sizeof(MV_FRAME_OUT));
      ret = MV_CC_GetImageBuffer(hCam, &frame, 1000);
    }
    else sw_thrd_delay(1000);
    if(MV_OK == ret)
    {
      ret = SavePhoto(hCam, &frame, imgType, saveImgFilename);
      MV_CC_FreeImageBuffer(hCam, &frame);
    }
    if(MV_OK == ret) break; // 拍照成功
    else if(MV_E_NODATA == ret)
    { // 无拍照数据时
      xgettickcount(&now);  // 当前时间
      waitTimeTick = ((now-startTime)/1000);
    }
    else
    {
      sw_log_error("[%s] 相机SDK取图异常, errCode=0x%x!!", MODULE_NAME, ret);
      goto end_p;
    }
  } while(timeout < 0 ? true : (waitTimeTick < timeout));

  // 5, 成功拍照, 输出相机的信息
  if(MV_OK == ret)
  {
    MVCC_FLOATVALUE fv = { 0 };
    MV_CC_GetFloatValue(hCam, "ExposureTime", &fv);
    imgMark.imgExposureTime = fv.fCurValue;
    if(pImgMark) memcpy(pImgMark, &imgMark, sizeof(SImgMark));
  }
  else if(timeout >= 0 && waitTimeTick >= timeout) ret = -5; // 拍照超时

  // 6, 任务结束, 释放相关的资源
end_p:
  if(hCam)
  {
    MV_CC_StopGrabbing(hCam);
    MV_CC_CloseDevice(hCam);
    MV_CC_DestroyHandle(hCam);
  }
  MV_CC_Finalize();

  flock(fd, LOCK_UN);
  close(fd);
  sw_file_delete(lockFile);

  return ret;
}

// 保存照片
static int SavePhoto(HANDLE hCam, MV_FRAME_OUT *pFrame, EImgType imgType, const char *imgFile)
{
  MV_SAVE_IMAGE_PARAM_EX3 saveParams = { 0 }; MVCC_INTVALUE_EX iv;
  char *filename1 = (char *)imgFile, *filename2 = NULL; int ret; char ext[5];

  if(!hCam || !pFrame || !filename1 || strlen(filename1) <= 0) return -6;

  switch(imgType)
  {
   case IMG_TYPE_BMP: // 保存为.bmp格式
    imgType = MV_Image_Bmp;
    strcpy(ext, ".bmp");
    break;
   case IMG_TYPE_JPG: // 保存为.jpg格式
    imgType = MV_Image_Jpeg;
    strcpy(ext, ".jpg");
    break;
   default: return -7;
  }

  ret = MV_CC_GetIntValueEx(hCam, "PayloadSize", &iv);
  if(MV_OK != ret) return ret;

  saveParams.pData        = pFrame->pBufAddr;
  saveParams.nDataLen     = pFrame->stFrameInfo.nFrameLen;
  saveParams.enPixelType  = pFrame->stFrameInfo.enPixelType;
  saveParams.nHeight      = pFrame->stFrameInfo.nHeight; 
  saveParams.nWidth       = pFrame->stFrameInfo.nWidth;

  saveParams.enImageType  = imgType;
  saveParams.nJpgQuality  = 90; // JPG编码质量(50-99], 其它格式无效, 影响JPG图像文件大小
  saveParams.iMethodValue = 1;

  if(imgType == IMG_TYPE_JPG) saveParams.nBufferSize  = (unsigned int)(iv.nCurValue * 1);
  else saveParams.nBufferSize  = (unsigned int)(iv.nCurValue * 4);
  saveParams.pImageBuffer = (unsigned char *)sw_heap_malloc(saveParams.nBufferSize);
  if(!saveParams.pImageBuffer) return -8;

  ret = MV_CC_SaveImageEx3(hCam, &saveParams);
  if(MV_OK != ret) goto end_p;

  if(!xstrcasestr(filename1, "right", ext))
  {
    filename2 = (char *)sw_heap_malloc(strlen(filename1) +sizeof(ext));
    if(filename2) sprintf(filename2, "%s%s", filename1, ext);
    else { ret = -9; goto end_p; }
    ret = sw_file_update(filename2, "wb", (const char *)saveParams.pImageBuffer, saveParams.nImageLen);
    sw_heap_free(filename2);
  }
  else
  {
    ret = sw_file_update(filename1, "wb", (const char *)saveParams.pImageBuffer, saveParams.nImageLen);
  }

  if(ret == saveParams.nImageLen) ret = MV_OK;
  else ret = -10;

end_p:
  sw_heap_free(saveParams.pImageBuffer);
  return ret;
}

// 获取系统当前USBFS内存大小(MB), 成功返回: >=0, 失败返回: -1值
int GetSysUsbfsMemCurrentSize()
{
  const char *usbfsFile = "/sys/module/usbcore/parameters/usbfs_memory_mb";
  char buf[MAX_LINE_CHARS]; int val = -1;
  FILE *fp = fopen(usbfsFile, "r");
  if(fp)
  {
    if(fgets(buf, sizeof(buf), fp)) sscanf(buf, "%d", &val);
    fclose(fp);
  }
  return val;
}

// 设置系统新的USBFS内存大小(MB), 成功返回: 0值, 失败返回: -1值
int SetSysUsbfsMemSize(int val)
{
  const char *usbfsFile = "/sys/module/usbcore/parameters/usbfs_memory_mb";
  char buf[MAX_LINE_CHARS]; sprintf(buf, "%d\n", val);
  if(val >= 0 && sw_file_update(usbfsFile, "w", buf, strlen(buf)) == strlen(buf)) return 0;
  else return -1;
}