Toybrick

标题: 多线程双摄像头数据阻塞问题（C++小白求教）（已解决） [打印本页]
作者: shopping    时间: 2019-10-18 10:28
标题: 多线程双摄像头数据阻塞问题（C++小白求教）（已解决）
本帖最后由 shopping 于 2019-10-25 17:01 编辑

因为公司以后要一个板子连接两个摄像头，而且对帧率有要求，所以考虑使用多线程。在看了这位老哥的( http://t.rock-chips.com/forum.php?mod=viewthread&tid=349 )demo 后，写了我的 摄像头 + 双显示屏 demo 版本( V4L2 + OpenCV USB摄像头)，代码如下：
  1. using namespace cv;
  2. using namespace std;

  4. mutex mtxQueueInput_1,mtxQueueInput_2;  // 两个全局变量，1对应第一个摄像头。2对应第二个摄像头。
  5. queue<Mat> queueInput_1,queueInput_2;  // 同样，1显示第一个摄像头数据，2同理。

  7. int get_video_1()
  8. {
  9.     char video[] = "/dev/video10" ;
  10.     int cpuid = 0;  // 4个线程 4个函数 分别绑定到4个CPU上
  11.     cpu_set_t mask;
  12.     CPU_ZERO(&mask);
  13.     CPU_SET(cpuid, &mask);

  15.     if (pthread_setaffinity_np(pthread_self(), sizeof(mask), &mask) < 0)
  16.     {
  17.         printf("set thread affinity failed");
  18.         return(FALSE);
  19.     }
  20.     printf("Bind CameraCapture process to CPU %d\n", cpuid);

  22.     cv::Mat img( IMAGE_HEIGHT, IMAGE_WIDTH, CV_8UC(3),cv::Scalar(0,0,0));

  24.     struct v4l2_buffer dequeue;
  25.     dequeue.type = V4L2_BUF_TYPE_VIDEO_CAPTURE ;
  26.     dequeue.memory = V4L2_MEMORY_MMAP ;

  28.     BUF *buffers = (struct buffer *)malloc(COUNT*(sizeof (*buffers)));

  30.     unsigned char *srcBuffer = (unsigned char*)malloc(sizeof(unsigned char) * BUFFER_SIZE_src);  // yuyv
  31.     unsigned char *dstBuffer = (unsigned char*)malloc(sizeof(unsigned char) * BUFFER_SIZE_det);  // RGB

  33.     /********************* function start *********************/
  34.     buffers = v4l2(video,buffers) ;
  35.     while(1)
  36.     {
  37.         srcBuffer = get_img(dequeue,buffers,srcBuffer);
  38.         dstBuffer = yuyv2rgb24(srcBuffer,dstBuffer);
  39.         img = unchar_to_Mat(dstBuffer,img);

  41.         mtxQueueInput_1.lock();
  42.         queueInput_1.push(img);
  43.         if (queueInput_1.size() >= 30)
  44.         {
  45.             mtxQueueInput_1.unlock();
  46.             printf("Img in queueInput is too much !");
  47.             sleep(1);
  48.             if (queueInput_1.size() >= 60)
  49.             {
  50.                 printf("queue is full !\n");
  51.                 return(FALSE);
  52.             }
  53.         }else{
  54.             mtxQueueInput_1.unlock();
  55.         }
  56.     }
  57.     free(buffers);
  58.     free(srcBuffer);
  59.     free(dstBuffer);

  61.     close_v4l2(buffers);
  62.     return(TRUE);
  63. }

  65. int get_video_2()  // get_video_1 和 get_video_2  除了 摄像头、需要绑定的CPU  不一样外，其余都一样。displayImage_1 和 displayImage_2 的情况类似。
复制代码每次执行这个文件，都要开个好几次才会显示出画面，即使有画面也坚持不了 1 min 。每次卡住都是因为队列里数据太多，所以休眠卡住，但图像还是没能继续显示，使得程序一直卡住，然后崩溃退出。

处于试验，我把这个程序拆分编译成两个可执行文件，即两个进程，每个进程调用一个摄像头做显示，每个进程里有两个线程，分别绑定不同CPU上，然后发现图像一点也不卡，非常流畅。不知道各位看了后有没有头绪，麻烦告知一下，谢谢。
怎么代码没了，再贴上：
  1. int get_video_2()
  2. {
  3.     char video[] = "/dev/video12" ;
  4.     int cpuid = 1;
  5.     cpu_set_t mask;
  6.     CPU_ZERO(&mask);
  7.     CPU_SET(cpuid, &mask);

  9.     if (pthread_setaffinity_np(pthread_self(), sizeof(mask), &mask) < 0)
  10.     {
  11.         printf("set thread affinity failed");
  12.         return(FALSE);
  13.     }
  14.     printf("Bind CameraCapture process to CPU %d\n", cpuid);

  16.     cv::Mat img( IMAGE_HEIGHT, IMAGE_WIDTH, CV_8UC(3),cv::Scalar(0,0,0));

  18.     struct v4l2_buffer dequeue;
  19.     dequeue.type = V4L2_BUF_TYPE_VIDEO_CAPTURE ;
  20.     dequeue.memory = V4L2_MEMORY_MMAP ;

  22.     BUF *buffers = (struct buffer *)malloc(COUNT*(sizeof (*buffers)));

  24.     unsigned char *srcBuffer = (unsigned char*)malloc(sizeof(unsigned char) * BUFFER_SIZE_src);  // yuyv
  25.     unsigned char *dstBuffer = (unsigned char*)malloc(sizeof(unsigned char) * BUFFER_SIZE_det);  // RGB

  27.     /********************* function start *********************/
  28.     buffers = v4l2(video,buffers) ;
  29.     while(1)
  30.     {
  31.         srcBuffer = get_img(dequeue,buffers,srcBuffer);
  32.         dstBuffer = yuyv2rgb24(srcBuffer,dstBuffer);
  33.         img = unchar_to_Mat(dstBuffer,img);

  35.         mtxQueueInput_2.lock();
  36.         queueInput_2.push(img);
  37.         if (queueInput_2.size() >= 30)
  38.         {
  39.             mtxQueueInput_2.unlock();
  40.             printf("Img in queueInput is too much !");
  41.             sleep(1);
  42.             if (queueInput_2.size() >= 60)
  43.             {
  44.                 printf("queue is full !\n");
  45.                 return(FALSE);
  46.             }
  47.         }else{
  48.             mtxQueueInput_2.unlock();
  49.         }
  50.     }
  51.     free(buffers);
  52.     free(srcBuffer);
  53.     free(dstBuffer);

  55.     close_v4l2(buffers);
  56.     return(TRUE);
  57. }

  59. int displayImage_1()
  60. {
  61.     int cpuid = 2;
  62.     Mat img;
  63.     cpu_set_t mask;
  64.     CPU_ZERO(&mask);
  65.     CPU_SET(cpuid, &mask);
  66.     if (pthread_setaffinity_np(pthread_self(), sizeof(mask), &mask) < 0){
  67.         cerr << "set thread affinity failed" << endl;
  68.     }
  69.     printf("Bind Display process to CPU %d\n", cpuid);
  70.     while (1)
  71.     {
  72.         mtxQueueInput_1.lock();
  73.         if (queueInput_1.empty())
  74.         {
  75.             mtxQueueInput_1.unlock();
  76.             usleep(10);
  77.         }
  78.         else
  79.         {
  80.             img = queueInput_1.front();
  81.             cv::imshow("image_10", img);  // display image
  82.             queueInput_1.pop();
  83.             mtxQueueInput_1.unlock();
  84.         }
  85.         if (waitKey(25) == 'Q') {
  86.            break;
  87.         }
  88.     }
  89.     return(TRUE);
  90. }

  92. int displayImage_2()
  93. {
  94.     int cpuid = 3;
  95.     Mat img;
  96.     cpu_set_t mask;
  97.     CPU_ZERO(&mask);
  98.     CPU_SET(cpuid, &mask);
  99.     if (pthread_setaffinity_np(pthread_self(), sizeof(mask), &mask) < 0){
  100.         cerr << "set thread affinity failed" << endl;
  101.     }
  102.     printf("Bind Display process to CPU %d\n", cpuid);
  103.     while (1)
  104.     {
  105.         mtxQueueInput_2.lock();
  106.         if (queueInput_2.empty())
  107.         {
  108.             mtxQueueInput_2.unlock();
  109.             usleep(10);
  110.         }
  111.         else
  112.         {
  113.             img = queueInput_2.front();
  114.             cv::imshow("image_12", img);  // display image
  115.             queueInput_2.pop();
  116.             mtxQueueInput_2.unlock();
  117.         }
  118.         if (waitKey(25) == 'Q') {
  119.            break;
  120.         }
  121.     }
  122.     return(TRUE);
  123. }

  125. int main()
  126. {
  127.     array<thread, 4> threads;
  128.     threads = {thread(get_video_1),
  129.                thread(displayImage_1),
  130.                thread(get_video_2),
  131.                thread(displayImage_2)};
  132.     for (int i = 0; i < 4; i++){
  133.         threads[i].join();
  134.     }
  135.     return(TRUE);
  136. }
复制代码

作者: shopping    时间: 2019-10-18 10:42
补充一下，其实 get_video_1 和 get_video_2   、 displayImage_1 和 displayImage_2  其实可以是一个函数，但是因为函数里的队列和互斥锁不一样，涉及到将 队列 和 互斥锁 作为参数传进函数里。可是互斥锁不可拷贝也不可移动，让我无法实现这个想法，才不得已拆分成四个函数。还是自己太菜。
作者: shopping    时间: 2019-10-18 17:26
后来试验了一下，取消displayImage_1 和 displayImage_2函数，直接把 imshow 放get_video_1 和 get_video_2里面显示图片，结果还是会卡。本来怀疑是我 V4L2 + OpenCV 代码写的有问题，用opencv又写了一遍，双线程调用两个摄像头，分别绑定在2个CPU上，然后分别显示。让我无语的是，就连Opencv也会卡住。郁闷了，自闭了。
作者: shopping    时间: 2019-10-21 10:32
通过观察，每次卡住都是图片播放卡住，导致最后程序崩溃，所以怀疑是 opencv 的显示导致。做了个试验，注释掉 imshow 函数，改为一个累加变量 int num ，num每500次打印看一下，用来判断程序是否在运行。结果是符合我怀疑的，图片不用 imshow 之后，程序确实正常运行。这么说问题出在 图片显示 上？
作者: shopping    时间: 2019-10-22 09:15
后来又试验了一个版本：调用两个摄像头写在一个函数里，绑定到一个CPU上，作为一个线程运行；再把显示两个摄像头图像的代码写进一个函数里，再绑定到一个CPU上，作为一个线程运行。 与一开始相比，少了两个线程，少了两个函数，目的还是没变，双摄 + 双显 。最后运行时发现竟然能长时间运行，不会因卡住而崩溃，不过偶尔会有小停顿，据观察是数据队列存放太多，来不及显示而导致的卡顿，在这可以确定是显示问题。



欢迎光临 Toybrick (https://t.rock-chips.com/) Powered by Discuz! X3.3