Asynchronous data pulling from a camera produces random crash - c++

Question

I have a graphical application that is pulling data from a camera. The camera event loop runs in a thread that is started in a object, I use a setter / getter of the object to get the data out and use it. But sometimes the application crashes. I'm not using any synchronization mechanism.
I have this method:
void MyClass::onNewColorSample(ColorNode node, ColorNode::NewSampleReceivedData data)
{
colorData = data;
}
I register it as callback of an external library:
g_cnode.newSampleReceivedEvent().connect(&onNewColorSample);
The method is called each time that a new frame arrives from a camera.
The getter of colorData is:
ColorNode::NewSampleReceivedData MyClass::getColorData()
{
return colorData;
}
Then I use a pthread to run the following:
void* MyClass::runThread(void* na)
{
g_context.run();
}
At some point I start the thread:
pthread_create(&pthread, NULL, runThread, NULL);
Then the class MyClass is getting data from a camera in a thread.
The run method documentation of the library says:
Runs the DepthSense event loop. The connected event handlers are run in the thread that called run().
Now I use myClass to get data from the camera, in another class I have in a method that is called every 1/60 seconds:
static ColorNode::NewSampleReceivedData colorFrame;
depthFrame = dsCam.getDetphData();
...
Sometimes the application crash in dsCam.getDepthData().
I think that the problem occurs because the data is being copied when this method returns and in the middle of the copy operation I got new data.
I use a thread because the external library doesn't provide a non-blocking mechanism to get the data out. It just provides an event-based mechanism.
I'm afraid that if I use a mutex lock/unlock mechanism my FPS will drop down, but I will try it... please give me some ideas.

Answer 1

Finally I solved the problem using QMutex:
//RAII class to unlock after method return (when local var out of scope)
class AutoMutex {
public:
AutoMutex(QMutex* _mutex) {
_mutex->lock();
myMutex = _mutex;
}
~AutoMutex() {
myMutex->unlock();
}
private:
QMutex* myMutex;
};
then I just used this class, passing to it a pointer to mutex (mutex is a member of my class):
ColorNode::NewSampleReceivedData MyClass::getColorData()
{
AutoMutex autoMut(&mutex); //mutex get locked
return colorData;
} //when method ends, autoMut is destroyed and mutex get unlocked
DepthNode::NewSampleReceivedData MyClass::getDetphData()
{
AutoMutex autoMut(&mutex);
return depthData;
}