Capture from two webcam

edit

Try using 2 threads. Here is a simple GrabberThread class. Below you can find an example

#include <queue>
#include <thread>
#include <mutex>
#include <atomic>
#include <string>


/** @brief Example Class that grabs from cv::VideoCapture into a queue.

It can be used as worker thread. 

Even if you grab N frames and create N x Mat in the queue
only few blocks will be really allocated thanks to @c std::vector 
and @c cv::Mat memory recycling. Look at @c matMemoryCounter to 
know how many memory blocks has been allocated
@author PkLab answer to question:
@see http://answers.opencv.org/question/95193/capture-from-two-webcam/
@note It can be done much better but it's better than nothing :)
@note It requires C++11 or later
*/
class GrabberThread{
private:
    int device;
    std::mutex mtx;
    std::queue<cv::Mat > buffer;
    std::atomic<bool> grabOn;
    VideoCapture cap;
    size_t bufSizeMax; 
    std::map<unsigned char*, int> matMemoryCounter;
public:
    GrabberThread() : grabOn(false), device(0), bufSizeMax(0){};
    ~GrabberThread()
    {
        grabOn.store(false);
        cap.release();
        while (!buffer.empty())
            buffer.pop();
        matMemoryCounter.clear();

    }
    /* @brief initialize members and open the capture device
    @return true if the device has successfully opened
    */
    bool Init(int dev = 0)
    {
        device = dev;
        cap.open(device);
        return cap.isOpened();
    }

    /* @brief Disable the grabbing loop control var. 
    This will stop the grabbing thread
    */
    void StopGrabing()
    {
        grabOn.store(false);
    }

    /** @brief This is the thread that grabs into a queue
    @note In real application locks and multiple copyTo can be avoided 
     using better queue/circular buffer!
    */
    void GrabThread() 
    {
        matMemoryCounter.clear();
        uchar * frameMemoryAddr;

        if (!cap.isOpened()) cap.open(device);
        if (!cap.isOpened()) return;

        cv::Mat tmp;
        grabOn.store(true);
        while (grabOn.load() == true) //this is lock free
        {
            //read() will wait for cam FPS. 
            //keep grab out of lock so that
            //idle time can be used by other threads
            if (!cap.read(tmp))
                continue;
            //get lock only when we have a frame
            mtx.lock();
            /** @warning Avoid @c buffer.push_back(tmp) because it stores items by reference.
            We have to create a new cv::Mat for each frame
            STL and cv::Mat will recycle memory
            */
            buffer.push(cv::Mat(tmp.size(), tmp.type()));
            tmp.copyTo(buffer.back());
            //count how many times this memory block has been used
            frameMemoryAddr = buffer.front().data;
            matMemoryCounter[frameMemoryAddr]++;
            bufSizeMax = max(bufSizeMax, buffer.size());

            mtx.unlock();
            /* SHOW THE FRAME if do you want
            string winName = "Live Thread Dev: " + std::to_string(device);
            int font = CV_FONT_HERSHEY_PLAIN;
            cv::putText(tmp, winName, cv::Point(10, 10), font, 1, cv::Scalar(0, 255, 0));
            imshow(winName, tmp);
            cv::waitKey(1);    //just for imshow
            */
        } // while
    } // func

    /** @brief Get the oldest grabbed frame if available

    The frame is copied from the buffer than it can used freely

    @Param [out]frame the the oldest grabbed frame. if not available it will be empty
    @Param [out]pBufSize a pointer where returns current buffer size. If 0 it will be ignored
    @Param [out]pBufSizeMax a pointer where returns maximum buffer size. If 0 it will be ignored
    @return true if a frame is available
    */
    bool PopFrame(Mat &frame, size_t *pBufSize = 0, size_t ...