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 "../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::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;

  // std::fstream readImage("./auv.jpg", std::ios::binary | std::ios::in);
  // if (!readImage)
  // {
  //   std::cerr << "不能打开文件 example.bin" << std::endl;
  // }
  // readImage.seekg(0, std::ios::end);
  // std::streamsize fileSize = readImage.tellg();
  // readImage.seekg(0, std::ios::beg);
  // unsigned char *buffer = new unsigned char[fileSize];
  // readImage.read((char *)buffer, fileSize);
  // readImage.close();

  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" << 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;
    // 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 = index;
    dataPackage->dDegree = jpeg_count[index]++;

    //std::string logMessage = "UVC Frame Received: Device " + std::to_string(index) + " UVC Received: Degree: " + std::to_string(jpeg_count[index] - 1) + UsbTest::GlobalResolutionTimer::getInstance().pressStopWatchString();
    //UsbTest::TimeRecorder::getInstance().recordTime(logMessage);

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

    // fp = fopen("./Ouput4k.jpg", "w");
    // fwrite(frame->data, 1, frame->data_bytes, fp);
    // fclose(fp);

    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);
}