USB_UVC_DETECT/UVCGrabber/UVCCallBack.cpp

#include <stdio.h>
#include <unistd.h>
#include <sys/time.h>
#include <iostream>
#include <fstream>
#include <vector>
#include <memory>
#include <filesystem>
#include "../libuvc/libuvc.h"
#include "UVCDeviceManager.h"
#include "../DataManager/DataManager.h"
#include "../DataManager/DataPackage.h"
#include <opencv4/opencv2/opencv.hpp>
#include <opencv4/opencv2/imgcodecs.hpp>
#include "../ImageTest/ImageTest.h"

struct timeval pre_frame_time;

/* This callback function runs once per frame. Use it to perform any
 * quick processing you need, or have it put the frame into your application's
 * input queue. If this function takes too long, you'll start losing frames. */
void cbSaveToLocal(uvc_frame_t *frame, void *ptr)
{
  uvc_error_t ret;
  int *pindex = (int *)ptr;
  int index = *pindex;
  FILE *fp;
  static int jpeg_count[3] = {0};
  static int jpeg_group[3] = {0};
  static const char *H264_FILE = "iOSDevLog.h264";
  static const char *MJPEG_FILE = ".jpeg";
  char filename[264];
  std::string FileSavePath = "";
  std::fstream log_file("CallBackLog.txt", std::ios::app);
  DataPackagePtr dataPackage = nullptr;
  // static MemoryPool<DataPackage> dataPool(BUFFER_SIZE, 3840, 2160);
  std::shared_ptr<DataPipe<DataPackage>> pipe;

  switch (frame->frame_format)
  {
  case UVC_FRAME_FORMAT_H264:
    /* use `ffplay H264_FILE` to play */
    fp = fopen(H264_FILE, "a");
    fwrite(frame->data, 1, frame->data_bytes, fp);
    fclose(fp);
    break;
  case UVC_COLOR_FORMAT_MJPEG:

    if (!g_gpioExplorer->getFailingStatus(index))
    {
      //std::cout << "Pass this wave in channel " << index << std::endl;
      break;
    }
    g_gpioExplorer->resetFailingStatus(index);

    // if(!UsbTest::SimulateTrigger::getInstance().isTriggering(index))
    // {
    //   break;
    // }

    if (jpeg_count[index] / 23 >= 1)
      jpeg_group[index]++;
    jpeg_count[index] = jpeg_count[index] % 23;
    std::cout << "Current File Device " << index << " UVC Index : " << jpeg_count[index] << std::endl;

    // 在 data/ 文件夹下创建文件夹，文件夹名称为设备索引
    // if (!std::filesystem::exists("./data/" + std::to_string(index)))
    // {
    //   std::filesystem::create_directory("./data/" + std::to_string(index));
    // }

    // FileSavePath = "./data/" + std::to_string(index) + "/" + std::to_string(jpeg_group[index]) + "-" + std::to_string(jpeg_count[index]++) + MJPEG_FILE;

    // fp = fopen(FileSavePath.c_str(), "wb");
    // if (fp == NULL)
    // {
    //   std::cerr << "Failed to open file: " << FileSavePath << std::endl;
    //   return;
    // }
    // fwrite(frame->data, 1, frame->data_bytes, fp);
    // fclose(fp);

    // sprintf(filename, "./data/%d/%d-%d%s", index, jpeg_group[index], jpeg_count[index]++, MJPEG_FILE);

    dataPackage = DataManager::getInstance().acquireDataBuffer<DataPackage>();

    memcpy(dataPackage->pJpegData, frame->data, frame->data_bytes);

    dataPackage->nJpegSize = frame->data_bytes;
    dataPackage->nWidth = frame->width;
    dataPackage->nHeight = frame->height;
    dataPackage->nTimeStamp = frame->capture_time_finished.tv_sec * 1000 + frame->capture_time_finished.tv_nsec / 1000000;
    dataPackage->nCameraID = UVCManager::getInstance().getDeviceNumber(index);
    dataPackage->dDegree = jpeg_count[index]++;

    DataManager::getInstance().pushData<DataPackage>("uvc" + std::to_string(index), dataPackage);

    break;
  case UVC_COLOR_FORMAT_YUYV:
    break;
  default:
    break;
  }

  if (frame->sequence % 30 == 0)
  {
    printf(" * got image %u\n", frame->sequence);
  }
}

// call back function
void cbDoNothing(uvc_frame_t *frame, void *ptr)
{
  printf("callback! frame_format = %d, width = %d, height = %d, length = %lu, ptr = %p\n",
         frame->frame_format, frame->width, frame->height, frame->data_bytes, ptr);
}