Hi, I'm struggling with a problem in my application that seems to be thread related. I'm developing and application, that has real time video acquisition, processing and visualisation functionality. When video acquisition button is clicked I call function:
StartVideo( callback_fcn( *image), data ) Afterwards every time there is a new image available function `callback_fcn( *image )` is called, and `*image` will point to a buffer containing the new image. `StartVideo` and the image buffer are provided by the camera API. In function `callback_fcn( *image)` i do the following: 1. Copy data located at *image to my own ImageBuffer 2. Perform various calculations with the ImageBuffer 3. Obtain a lock on GDK using gdk_threads_enter() 4. Copy the processed data to a separate FrameBuffer 5. Draw the FrameBuffer onto a GtkDrawingArea (the GtkDrawingArea is redrawn via a expose-event-handler from the FrameBuffer as required) 6. Release GDK lock using gdk_threads_enter() 7. Return from function My first trouble was (it is kind of solved now, and presented as a reference and a sanity check only) that, depending on load, the application would crash and the GtkDrawingArea is to blame. This was because the expose-event handler function of the GtkDrawingArea would use data from the FrameBuffer and on a sepparate thread it would be simultaniously overwritten in step 4. Adding steps 3 and 6 solved this and the application was fairly stable for extended periods of time. However, since then the amount of workload was increased and now again the application is experiencing erratic hookups and crashes. Debugging shows that new threads of `callback_fcn( *image)` are starting before old ones are done - that is the application can't cope with the video stream input. When one thread is in step 2, another starts at step 1, and again same ImageBuffer is used in two different threads. I've tried locking the ImageBuffer using G_LOCK to no avail. The FAQ gives a good example on thread usage, but I can't understand it completely. Maybe someone could point out a good introductory text with code examples on GTK+ and GLib threading? I understand that I'm pushing above the limits of my hardware if that sort of things are happening, but I'd like to have some control over this (skip frames or processing) rather than just don't do it. And since I don't have any control over the `StartVideo` routine I'm out of ideas. I would rather have no threads in my application at all, but I guess it's a better way (or the only way, when using callbacks from a shared library functions). Now I need to block new threads of `callback_fcn` when one thread is already inside this function or put the calls in a queue, and drop frames or reduce processing on the fly, but I can't figure out how to do this on my own. Any help would be much appreciated. _______________________________________________ gtk-app-devel-list mailing list gtk-app-devel-list@gnome.org http://mail.gnome.org/mailman/listinfo/gtk-app-devel-list