fixes and accomodations for other operating systems by Andrew
[goodguy/cinelerra.git] / cinelerra-5.1 / guicast / bctexture.C
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 #define GL_GLEXT_PROTOTYPES
23
24 #include "bcsynchronous.h"
25 #include "bctexture.h"
26 #include "bcwindowbase.h"
27 #include "bccmodels.h"
28
29
30 BC_Texture::BC_Texture(int w, int h, int colormodel)
31 {
32         this->w = w;
33         this->h = h;
34         this->colormodel = colormodel;
35         texture_id = -1;
36         texture_w = 0;
37         texture_h = 0;
38         texture_components = 0;
39         window_id = -1;
40         create_texture(w, h, colormodel);
41 }
42
43
44 BC_Texture::~BC_Texture()
45 {
46         clear_objects();
47 }
48
49 void BC_Texture::clear_objects()
50 {
51         if(get_texture_id() >= 0)
52         {
53 // printf("VFrame::clear_objects %p window_id=%d texture_id=%d w=%d h=%d\n",
54 // this, window_id, texture_id, texture_w, texture_h);
55                 BC_WindowBase::get_synchronous()->release_texture(
56                         window_id,
57                         texture_id);
58                 texture_id = -1;
59         }
60 }
61
62 void BC_Texture::new_texture(BC_Texture **texture,
63         int w, int h, int colormodel)
64 {
65         if(!(*texture)) {
66                 (*texture) = new BC_Texture(w, h, colormodel);
67         }
68         else {
69                 (*texture)->create_texture(w, h, colormodel);
70         }
71 }
72
73 void BC_Texture::create_texture(int w, int h, int colormodel)
74 {
75 #ifdef HAVE_GL
76
77 // Get max texture size from the server.
78 // Maximum size was 4096 on the earliest cards that could do video.
79         int max_texture_size = 0;
80         glGetIntegerv(GL_MAX_TEXTURE_SIZE, &max_texture_size);
81
82 // Calculate dimensions of texture
83         int new_w = calculate_texture_size(w, &max_texture_size);
84         int new_h = calculate_texture_size(h, &max_texture_size);
85         int new_components = BC_CModels::components(colormodel);
86
87         if(new_w < w || new_h < h) {
88                 printf("BC_Texture::create_texture frame size %dx%d bigger than maximum texture %dx%d.\n",
89                         w, h, max_texture_size, max_texture_size);
90         }
91
92 // Delete existing texture
93         if(texture_id >= 0 && (new_h != texture_h || new_w != texture_w ||
94                 new_components != texture_components ||
95                 BC_WindowBase::get_synchronous()->current_window->get_id() != window_id))
96         {
97 // printf("BC_Texture::create_texture released window_id=%d texture_id=%d\n",
98 // BC_WindowBase::get_synchronous()->current_window->get_id(),
99 // texture_id);
100                 BC_WindowBase::get_synchronous()->release_texture(
101                         window_id,
102                         texture_id);
103                 texture_id = -1;
104                 window_id = -1;
105         }
106
107
108         texture_w = new_w;
109         texture_h = new_h;
110         texture_components = new_components;
111
112 // Get matching texture
113         if(texture_id < 0) {
114                 texture_id = BC_WindowBase::get_synchronous()->get_texture(
115                         texture_w, texture_h, texture_components);
116 // A new VFrame has no window_id, so it must read it from the matching texture.
117                 if(texture_id >= 0)
118                         window_id = BC_WindowBase::get_synchronous()->current_window->get_id();
119         }
120
121 // No matching texture exists.
122 // Create new texture with the proper dimensions
123         if(texture_id < 0) {
124                 glGenTextures(1, (GLuint*)&texture_id);
125                 glBindTexture(GL_TEXTURE_2D, (GLuint)texture_id);
126                 glEnable(GL_TEXTURE_2D);
127                 int internal_format = texture_components == 4 ? GL_RGBA8 : GL_RGB8 ;
128                 glTexImage2D(GL_TEXTURE_2D, 0, internal_format, texture_w, texture_h,
129                                 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
130                 window_id = BC_WindowBase::get_synchronous()->current_window->get_id();
131                 BC_WindowBase::get_synchronous()->put_texture(texture_id,
132                         texture_w, texture_h, texture_components);
133 //printf("BC_Texture::new_texture created texture_id=%d window_id=%d w=%d h=%d\n",
134 // texture_id, window_id, texture_w, texture_h);
135         }
136         else {
137                 glBindTexture(GL_TEXTURE_2D, (GLuint)texture_id);
138                 glEnable(GL_TEXTURE_2D);
139         }
140 #endif
141 }
142
143 int BC_Texture::calculate_texture_size(int w, int *max)
144 {
145         int i;
146         for(i = 2; (max && i <= *max) || (!max && i < w); i *= 2)
147         {
148                 if(i >= w)
149                 {
150                         return i;
151                         break;
152                 }
153         }
154         if(max && i > *max) return 16;
155         return i;
156 }
157
158 int BC_Texture::get_texture_id()
159 {
160         return texture_id;
161 }
162
163 int BC_Texture::get_texture_w()
164 {
165         return texture_w;
166 }
167
168 int BC_Texture::get_texture_h()
169 {
170         return texture_h;
171 }
172
173 int BC_Texture::get_texture_components()
174 {
175         return texture_components;
176 }
177
178 int BC_Texture::get_window_id()
179 {
180         return window_id;
181 }
182
183
184 void BC_Texture::draw_texture(
185         float in_x1, float in_y1, float in_x2, float in_y2,
186         float out_x1, float out_y1, float out_x2, float out_y2)
187 {
188 #ifdef HAVE_GL
189         glBegin(GL_QUADS);
190         glNormal3f(0, 0, 1.0);
191         glTexCoord2f(in_x1, in_y1);   glVertex3f(out_x1, out_y1, 0);
192         glTexCoord2f(in_x2, in_y1);   glVertex3f(out_x2, out_y1, 0);
193         glTexCoord2f(in_x2, in_y2);   glVertex3f(out_x2, out_y2, 0);
194         glTexCoord2f(in_x1, in_y2);   glVertex3f(out_x1, out_y2, 0);
195         glEnd();
196 #endif
197 }
198
199 void BC_Texture::bind(int texture_unit, int nearest)
200 {
201 #ifdef HAVE_GL
202 // Bind the texture
203         if(texture_id >= 0)
204         {
205                 if(texture_unit >= 0) glActiveTexture(GL_TEXTURE0 + texture_unit);
206                 glBindTexture(GL_TEXTURE_2D, texture_id);
207                 glEnable(GL_TEXTURE_2D);
208                 if(texture_unit >= 0) {
209                         int filter = nearest ? GL_NEAREST : GL_LINEAR;
210                         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filter);
211                         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filter);
212
213 // GL_REPEAT in this case causes the upper left corners of the masks
214 // to blur.
215                         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
216                         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
217
218 // Get the texture to alpha blend
219                         glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
220                 }
221         }
222 #endif
223 }
224
225 #ifdef HAVE_GL
226 static void write_ppm(uint8_t *tp, int w, int h, const char *fmt, ...)
227 {
228   va_list ap;    va_start(ap, fmt);
229   char fn[256];  vsnprintf(fn, sizeof(fn), fmt, ap);
230   va_end(ap);
231   FILE *fp = !strcmp(fn,"-") ? stdout : fopen(fn,"w");
232   if( fp ) {
233     fprintf(fp,"P6\n%d %d\n255\n",w,h);
234     fwrite(tp,3*w,h,fp);
235     if( fp != stdout ) fclose(fp);
236   }
237 }
238 #endif
239
240 void BC_Texture::write_tex(const char *fn, int id)
241 {
242 #ifdef HAVE_GL
243         int prev_id = -1;
244         glGetIntegerv(GL_ACTIVE_TEXTURE, &prev_id);
245         glActiveTexture(GL_TEXTURE0+id);
246         glBindTexture(GL_TEXTURE_2D, texture_id);
247         glEnable(GL_TEXTURE_2D);
248         int w = get_texture_w(), h = get_texture_h();
249         uint8_t *img = new uint8_t[w*h*3];
250         glGetTexImage(GL_TEXTURE_2D, 0, GL_RGB, GL_UNSIGNED_BYTE, img);
251         write_ppm(img, w, h, "%s", fn);
252         delete [] img;
253         glActiveTexture(prev_id);
254 #endif
255 }
256
257 void BC_Texture::write_tex(const char *fn)
258 {
259 #ifdef HAVE_GL
260         write_tex(fn, 31);
261 #endif
262 }
263