remove incorrectly named
[goodguy/cinelerra.git] / cinelerra-5.1 / guicast / bcsynchronous.h
1
2 /*
3  * CINELERRA
4  * Copyright (C) 2008 Adam Williams <broadcast at earthling dot net>
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19  *
20  */
21
22 #ifndef BCSYNCHRONOUS_H
23 #define BCSYNCHRONOUS_H
24
25 #include "arraylist.h"
26 #include "bcpbuffer.inc"
27 #include "bcpixmap.inc"
28 #include "bctexture.inc"
29 #include "bcwindowbase.inc"
30 #include "condition.inc"
31 #include "mutex.inc"
32 #include "thread.h"
33 #include "vframe.inc"
34
35 #ifdef HAVE_GL
36 #include <GL/gl.h>
37 #include <GL/glx.h>
38 #endif
39
40 #include <X11/Xlib.h>
41
42 // This takes requests and runs all OpenGL calls in the main thread.
43 // Past experience showed OpenGL couldn't be run from multiple threads
44 // reliably even if MakeCurrent was used and only 1 thread at a time did
45 // anything.
46
47 // Also manages texture memory.  Textures are not deleted until the glx_context
48 // is deleted, so they have to be reused as much as possible.
49 // Must be run as the main loop of the application.  Other threads must
50 // call into it to dispatch commands.
51
52 // In addition to synchronous operations, it handles global OpenGL variables.
53
54 // Users should create a subclass of the command and thread components to
55 // add specific commands.
56
57
58
59 class TextureID
60 {
61 public:
62         TextureID(int window_id, int id, int w, int h, int components);
63         int window_id;
64         int id;
65         int w;
66         int h;
67         int components;
68         BC_WindowBase *window;
69         int in_use;
70 };
71
72 class ShaderID
73 {
74 public:
75         ShaderID(int window_id, unsigned int handle,
76                  const char *vert, const char *frag);
77         ~ShaderID();
78
79 // Should really use an MD5 to compare sources but this is easiest.
80         char *vert, *frag;
81         int window_id;
82         unsigned int handle;
83 };
84
85 class PBufferID
86 {
87 public:
88         PBufferID() {};
89 #ifdef HAVE_GL
90         PBufferID(int window_id,
91                 GLXPbuffer glx_pbuffer, GLXContext glx_context,
92                 int w, int h);
93         GLXPbuffer glx_pbuffer;
94         GLXContext glx_context;
95         int window_id;
96         int w, h;
97         int in_use;
98 #endif
99 };
100
101 class BC_SynchronousCommand
102 {
103 public:
104         BC_SynchronousCommand();
105         virtual ~BC_SynchronousCommand();
106
107         virtual void copy_from(BC_SynchronousCommand *command);
108
109         Condition *command_done;
110         long result;
111         int command;
112
113 // Commands
114         enum
115         {
116                 NONE,
117                 QUIT,
118 // Used by garbage collector
119                 DELETE_WINDOW,
120                 DELETE_PIXMAP,
121                 DELETE_DISPLAY,
122 // subclasses create new commands starting with this enumeration
123                 LAST_COMMAND
124         };
125
126         int colormodel;
127         BC_WindowBase *window;
128
129         VFrame *frame;
130         VFrame *frame_return;
131
132         int id;
133         int w, h;
134
135 // For garbage collection
136         int window_id;
137         Display *display;
138         Window win;
139 #ifdef HAVE_GL
140         GLXContext glx_context;
141         GLXPixmap glx_pixmap;
142         GLXWindow glx_win;
143 #endif
144 };
145
146 class BC_Synchronous : public Thread
147 {
148 public:
149         BC_Synchronous();
150         virtual ~BC_Synchronous();
151
152         friend class BC_WindowBase;
153         friend class VFrame;
154         friend class BC_PBuffer;
155         friend class BC_Pixmap;
156         friend class BC_Texture;
157
158         void quit();
159 // Must be called after constructor to create inherited objects.
160         void create_objects();
161         void start();
162         void run();
163
164         virtual BC_SynchronousCommand* new_command();
165 // Handle extra commands not part of the base class.
166 // Contains a switch statement starting with LAST_COMMAND
167         virtual void handle_command(BC_SynchronousCommand *command);
168
169
170 // OpenGL texture removal doesn't work.  Need to store the ID's of all the deleted
171 // textures in this stack and reuse them.  Also since OpenGL needs synchronous
172 // commands, be sure this is always called synchronously.
173 // Called when a texture is created to associate it with the current window.
174 // Must be called inside synchronous loop.
175         void put_texture(int id, int w, int h, int components);
176 // Search for existing texture matching the parameters and not in use
177 // and return it.  If -1 is returned, a new texture must be created.
178 // Must be called inside synchronous loop.
179 // If someone proves OpenGL can delete texture memory, this function can be
180 // forced to always return -1.
181         int get_texture(int w, int h, int components);
182 // Release a texture for use by the get_texture call.
183 // Can be called outside synchronous loop.
184         void release_texture(int window_id, int id);
185
186 // Get the shader by window_id and vertex/fragment source comparison
187         int get_shader(unsigned int *handle, const char *vert, const char *frag);
188         void put_shader(unsigned int handle, const char *vert, const char *frag);
189         void dump_shader(unsigned int handle);
190
191
192 #ifdef HAVE_GL
193 // Push a pbuffer when it's created.
194 // Must be called inside synchronous loop.
195         void put_pbuffer(int w, int h,
196                 GLXPbuffer glx_pbuffer,
197                 GLXContext glx_context);
198 // Get the PBuffer by window_id and dimensions if it exists.
199 // Must be called inside synchronous loop.
200         GLXPbuffer get_pbuffer(int w, int h, GLXContext *glx_context);
201 // Release a pbuffer for use by get_pbuffer.
202         void release_pbuffer(int window_id, GLXPbuffer pbuffer);
203
204 // Schedule GL pixmap for deletion by the garbage collector.
205 // Pixmaps don't wait until until the window is deleted but they must be
206 // deleted before the window is deleted to have the display connection.
207         void delete_pixmap(BC_WindowBase *window,
208                 GLXPixmap pixmap,
209                 GLXContext context);
210 #endif
211
212
213
214 // Called by ~BC_WindowBase to delete OpenGL objects related to the window.
215 // This function returns immediately instead of waiting for the synchronous
216 // part to finish.
217         void delete_window(BC_WindowBase *window);
218         void delete_display(BC_WindowBase *window);
219
220         long send_command(BC_SynchronousCommand *command);
221         void send_garbage(BC_SynchronousCommand *command);
222
223         void delete_pixmap_sync(BC_SynchronousCommand *command);
224         void delete_window_sync(BC_SynchronousCommand *command);
225         void delete_display_sync(BC_SynchronousCommand *command);
226
227 // Get the window currently bound to the context.
228         BC_WindowBase* get_window();
229
230 private:
231         void handle_command_base(BC_SynchronousCommand *command);
232
233         Mutex *lock_sync;
234         void sync_lock(const char *cp=0);
235         void sync_unlock();
236
237         void get_display_sync(Display *display, const char *cp);
238
239         Condition *next_command;
240         Mutex *command_lock;
241
242 // Must be locked in order of current_window->lock_window, table_lock
243 // or just table_lock.
244         Mutex *table_lock;
245
246 // This quits the program when it's 1.
247         int done;
248 // Command stack
249         ArrayList<BC_SynchronousCommand*> commands;
250         int is_started;
251 // The window the opengl context is currently bound to.
252 // Set by BC_WindowBase::enable_opengl.
253         BC_WindowBase *current_window;
254
255         ArrayList<ShaderID*> shader_ids;
256         ArrayList<TextureID*> texture_ids;
257         ArrayList<PBufferID*> pbuffer_ids;
258
259 // When the context is bound to a pbuffer, this
260 // signals glCopyTexSubImage2D to use the front buffer.
261         int is_pbuffer;
262 };
263
264
265
266
267 #endif