1
|
1 #define DISP
|
|
2
|
|
3 // this can be 3 or 4 (regarding 24bpp and 32bpp)
|
|
4 #define BYTES_PP 3
|
|
5
|
|
6 #define TEXTUREFORMAT_32BPP
|
|
7
|
|
8 // Hmm. Enabling this makes about 20% speedup too! (Celeron2+G400+UtahGLX)
|
|
9 //#define TEXSUBIMAGE_BUG_WORKAROUND
|
|
10
|
|
11 /*
|
|
12 * video_out_gl.c, X11/OpenGL interface
|
|
13 * based on video_out_x11 by Aaron Holtzman,
|
|
14 * and WS opengl window manager by Pontscho/Fresh!
|
|
15 */
|
|
16
|
|
17 #include <stdio.h>
|
|
18 #include <stdlib.h>
|
|
19 #include <string.h>
|
|
20 #include <math.h>
|
|
21
|
|
22 #include "config.h"
|
|
23 #include "video_out.h"
|
|
24 #include "video_out_internal.h"
|
|
25
|
|
26
|
|
27 LIBVO_EXTERN(gl)
|
|
28
|
|
29 #include <X11/Xlib.h>
|
|
30 #include <X11/Xutil.h>
|
|
31 //#include <X11/keysym.h>
|
|
32 #include <GL/glx.h>
|
|
33 #include <errno.h>
|
|
34 #include "yuv2rgb.h"
|
|
35
|
|
36 #include <GL/gl.h>
|
|
37
|
|
38 static vo_info_t vo_info =
|
|
39 {
|
|
40 "X11 (OpenGL)",
|
|
41 "gl",
|
|
42 "Arpad Gereoffy <arpi@esp-team.scene.hu>",
|
|
43 ""
|
|
44 };
|
|
45
|
|
46 /* private prototypes */
|
|
47 static void Display_Image (unsigned char *ImageData);
|
|
48
|
|
49 /* local data */
|
|
50 static unsigned char *ImageData=NULL;
|
|
51
|
|
52 /* X11 related variables */
|
|
53 static Display *mydisplay;
|
|
54 static Window mywindow;
|
|
55 //static GC mygc;
|
|
56 //static XImage *myximage;
|
|
57 //static int depth,mode;
|
|
58 static XWindowAttributes attribs;
|
|
59 static int X_already_started = 0;
|
|
60
|
|
61 static int texture_id=1;
|
|
62
|
|
63 static GLXContext wsGLXContext;
|
|
64 //XVisualInfo * wsVisualInfo;
|
|
65 int wsGLXAttrib[] = { GLX_RGBA,
|
|
66 GLX_RED_SIZE,1,
|
|
67 GLX_GREEN_SIZE,1,
|
|
68 GLX_BLUE_SIZE,1,
|
|
69 // GLX_DEPTH_SIZE,16,
|
|
70 GLX_DOUBLEBUFFER,
|
|
71 None };
|
|
72
|
|
73
|
|
74 static uint32_t image_width;
|
|
75 static uint32_t image_height;
|
|
76 static uint32_t image_format;
|
|
77 static uint32_t image_bpp;
|
|
78 static uint32_t image_bytes;
|
|
79
|
|
80 static uint32_t texture_width;
|
|
81 static uint32_t texture_height;
|
|
82
|
|
83 static resize(int x,int y){
|
|
84 printf("Resize: %dx%d\n",x,y);
|
|
85 glViewport( 0, 0, x, y );
|
|
86
|
|
87 glMatrixMode(GL_PROJECTION);
|
|
88 glLoadIdentity();
|
|
89 glOrtho(0, image_width, image_height, 0, -1,1);
|
|
90
|
|
91 glMatrixMode(GL_MODELVIEW);
|
|
92 glLoadIdentity();
|
|
93 }
|
|
94
|
|
95 /* connect to server, create and map window,
|
|
96 * allocate colors and (shared) memory
|
|
97 */
|
|
98 static uint32_t
|
|
99 init(uint32_t width, uint32_t height, uint32_t d_width, uint32_t d_height, uint32_t fullscreen, char *title, uint32_t format)
|
|
100 {
|
|
101 int screen;
|
|
102 unsigned int fg, bg;
|
|
103 char *hello = (title == NULL) ? "OpenGL rulez" : title;
|
|
104 char *name = ":0.0";
|
|
105 XSizeHints hint;
|
|
106 XVisualInfo *vinfo;
|
|
107 XEvent xev;
|
|
108
|
|
109 XGCValues xgcv;
|
|
110 XSetWindowAttributes xswa;
|
|
111 unsigned long xswamask;
|
|
112
|
|
113 image_height = height;
|
|
114 image_width = width;
|
|
115 image_format = format;
|
|
116
|
|
117 if (X_already_started) return -1;
|
|
118
|
|
119 if(getenv("DISPLAY")) name = getenv("DISPLAY");
|
|
120
|
|
121 mydisplay = XOpenDisplay(name);
|
|
122
|
|
123 if (mydisplay == NULL)
|
|
124 {
|
|
125 fprintf(stderr,"Can not open display\n");
|
|
126 return -1;
|
|
127 }
|
|
128
|
|
129 screen = DefaultScreen(mydisplay);
|
|
130
|
|
131 hint.x = 0;
|
|
132 hint.y = 0;
|
|
133 hint.width = d_width;
|
|
134 hint.height = d_height;
|
|
135 hint.flags = PPosition | PSize;
|
|
136
|
|
137 /* Get some colors */
|
|
138
|
|
139 bg = WhitePixel(mydisplay, screen);
|
|
140 fg = BlackPixel(mydisplay, screen);
|
|
141
|
|
142 /* Make the window */
|
|
143
|
|
144 XGetWindowAttributes(mydisplay, DefaultRootWindow(mydisplay), &attribs);
|
|
145
|
|
146 #if 0
|
|
147 /*
|
|
148 *
|
|
149 * depth in X11 terminology land is the number of bits used to
|
|
150 * actually represent the colour.
|
|
151 *
|
|
152 * bpp in X11 land means how many bits in the frame buffer per
|
|
153 * pixel.
|
|
154 *
|
|
155 * ex. 15 bit color is 15 bit depth and 16 bpp. Also 24 bit
|
|
156 * color is 24 bit depth, but can be 24 bpp or 32 bpp.
|
|
157 */
|
|
158
|
|
159 depth = attribs.depth;
|
|
160
|
|
161 if (depth != 15 && depth != 16 && depth != 24 && depth != 32)
|
|
162 {
|
|
163 /* The root window may be 8bit but there might still be
|
|
164 * visuals with other bit depths. For example this is the
|
|
165 * case on Sun/Solaris machines.
|
|
166 */
|
|
167 depth = 24;
|
|
168 }
|
|
169 //BEGIN HACK
|
|
170 //mywindow = XCreateSimpleWindow(mydisplay, DefaultRootWindow(mydisplay),
|
|
171 //hint.x, hint.y, hint.width, hint.height, 4, fg, bg);
|
|
172 //
|
|
173 #endif
|
|
174
|
|
175 // XMatchVisualInfo(mydisplay, screen, depth, TrueColor, &vinfo);
|
|
176 vinfo=glXChooseVisual( mydisplay,screen,wsGLXAttrib );
|
|
177
|
|
178 xswa.background_pixel = 0;
|
|
179 xswa.border_pixel = 1;
|
|
180 // xswa.colormap = XCreateColormap(mydisplay, RootWindow(mydisplay,screen), vinfo.visual, AllocNone);
|
|
181 xswa.colormap = XCreateColormap(mydisplay, RootWindow(mydisplay,screen), vinfo->visual, AllocNone);
|
|
182 xswamask = CWBackPixel | CWBorderPixel | CWColormap;
|
|
183 // xswamask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask | CWCursor | CWOverrideRedirect | CWSaveUnder | CWX | CWY | CWWidth | CWHeight;
|
|
184
|
|
185 mywindow = XCreateWindow(mydisplay, RootWindow(mydisplay,screen),
|
|
186 hint.x, hint.y, hint.width, hint.height, 4, vinfo->depth,CopyFromParent,vinfo->visual,xswamask,&xswa);
|
|
187
|
|
188 wsGLXContext=glXCreateContext( mydisplay,vinfo,NULL,True );
|
|
189 // XStoreName( wsDisplay,wsMyWin,wsSysName );
|
|
190
|
|
191 printf("GLXcontect ok\n");
|
|
192
|
|
193 XSelectInput(mydisplay, mywindow, StructureNotifyMask);
|
|
194
|
|
195 /* Tell other applications about this window */
|
|
196
|
|
197 XSetStandardProperties(mydisplay, mywindow, hello, hello, None, NULL, 0, &hint);
|
|
198
|
|
199 /* Map window. */
|
|
200
|
|
201 XMapWindow(mydisplay, mywindow);
|
|
202
|
|
203 /* Wait for map. */
|
|
204 do
|
|
205 {
|
|
206 XNextEvent(mydisplay, &xev);
|
|
207 }
|
|
208 while (xev.type != MapNotify || xev.xmap.event != mywindow);
|
|
209
|
|
210 XSelectInput(mydisplay, mywindow, NoEventMask);
|
|
211
|
|
212 glXMakeCurrent( mydisplay,mywindow,wsGLXContext );
|
|
213
|
|
214 XFlush(mydisplay);
|
|
215 XSync(mydisplay, False);
|
|
216
|
|
217 // mygc = XCreateGC(mydisplay, mywindow, 0L, &xgcv);
|
|
218
|
|
219 // myximage = XGetImage(mydisplay, mywindow, 0, 0,
|
|
220 // width, image_height, AllPlanes, ZPixmap);
|
|
221 // ImageData = myximage->data;
|
|
222 // bpp = myximage->bits_per_pixel;
|
|
223
|
|
224 XSelectInput(mydisplay, mywindow, StructureNotifyMask); // !!!!
|
|
225
|
|
226 printf("Window setup ok\n");
|
|
227
|
|
228 #if 0
|
|
229 // If we have blue in the lowest bit then obviously RGB
|
|
230 mode = ((myximage->blue_mask & 0x01) != 0) ? MODE_RGB : MODE_BGR;
|
|
231 #ifdef WORDS_BIGENDIAN
|
|
232 if (myximage->byte_order != MSBFirst)
|
|
233 #else
|
|
234 if (myximage->byte_order != LSBFirst)
|
|
235 #endif
|
|
236 {
|
|
237 fprintf( stderr, "No support fon non-native XImage byte order!\n" );
|
|
238 return -1;
|
|
239 }
|
|
240
|
|
241 printf("DEPTH=%d BPP=%d\n",depth,bpp);
|
|
242 #endif
|
|
243
|
|
244 /*
|
|
245 * If depth is 24 then it may either be a 3 or 4 byte per pixel
|
|
246 * format. We can't use bpp because then we would lose the
|
|
247 * distinction between 15/16bit depth (2 byte formate assumed).
|
|
248 *
|
|
249 * FIXME - change yuv2rgb_init to take both depth and bpp
|
|
250 * parameters
|
|
251 */
|
|
252
|
|
253 texture_width=32;
|
|
254 while(texture_width<image_width) texture_width*=2;
|
|
255 while(texture_width<image_height) texture_width*=2;
|
|
256 if(texture_width>256)texture_width=256; // voodoo3 hack
|
|
257 texture_height=texture_width;
|
|
258
|
|
259 if(format==IMGFMT_YV12){
|
|
260 yuv2rgb_init(8*BYTES_PP, MODE_RGB);
|
|
261 printf("YUV init OK!\n");
|
|
262 image_bpp=8*BYTES_PP;
|
|
263 image_bytes=BYTES_PP;
|
|
264 } else {
|
|
265 image_bpp=format&0xFF;
|
|
266 image_bytes=(image_bpp+7)/8;
|
|
267 }
|
|
268
|
|
269 ImageData=malloc(texture_width*texture_height*image_bytes);
|
|
270 memset(ImageData,128,texture_width*texture_height*image_bytes);
|
|
271
|
|
272 glDisable(GL_BLEND);
|
|
273 glDisable(GL_DEPTH_TEST);
|
|
274 glDepthMask(GL_FALSE);
|
|
275 glDisable(GL_CULL_FACE);
|
|
276
|
|
277 printf("Creating %dx%d texture...\n",texture_width,texture_height);
|
|
278
|
|
279 #if 1
|
|
280 // glBindTexture(GL_TEXTURE_2D, texture_id);
|
|
281 glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER, GL_LINEAR);
|
|
282 glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER, GL_LINEAR);
|
|
283 #ifdef TEXTUREFORMAT_32BPP
|
|
284 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8, texture_width, texture_height, 0,
|
|
285 #else
|
|
286 glTexImage2D(GL_TEXTURE_2D, 0, BYTES_PP, texture_width, texture_height, 0,
|
|
287 #endif
|
|
288 (image_bytes==4)?GL_RGBA:GL_BGR, GL_UNSIGNED_BYTE, ImageData);
|
|
289 #endif
|
|
290
|
|
291 resize(d_width,d_height);
|
|
292
|
|
293 glClearColor( 1.0f,1.0f,1.0f,0.0f );
|
|
294 glClear( GL_COLOR_BUFFER_BIT );
|
|
295
|
|
296 printf("OpenGL setup OK!\n");
|
|
297
|
|
298 X_already_started++;
|
|
299 return 0;
|
|
300 }
|
|
301
|
|
302 static const vo_info_t*
|
|
303 get_info(void)
|
|
304 {
|
|
305 return &vo_info;
|
|
306 }
|
|
307
|
|
308 static void
|
|
309 Terminate_Display_Process(void)
|
|
310 {
|
|
311 getchar(); /* wait for enter to remove window */
|
|
312 XDestroyWindow(mydisplay, mywindow);
|
|
313 XCloseDisplay(mydisplay);
|
|
314 X_already_started = 0;
|
|
315 }
|
|
316
|
|
317 static void
|
|
318 FlipImage()
|
|
319 {
|
|
320 // XPutImage(mydisplay, mywindow, mygc, myximage, 0, 0, 0, 0, myximage->width, myximage->height);
|
|
321 // XFlush(mydisplay);
|
|
322 int i;
|
|
323 XEvent wsEvent;
|
|
324 XEvent xev;
|
|
325
|
|
326 while ( XPending( mydisplay ) ) {
|
|
327 XNextEvent( mydisplay,&wsEvent );
|
|
328 switch( wsEvent.type ) {
|
|
329 // case Expose: if ( wsReDraw ) wsReDraw( wsDisplay,wsEvent.xany.window ); break;
|
|
330 case ConfigureNotify: //wsWindowWidth=wsEvent.xconfigure.width;
|
|
331 //wsWindowHeight=wsEvent.xconfigure.height;
|
|
332 #if 0
|
|
333 XUnmapWindow( mydisplay,mywindow );
|
|
334 XMapWindow( mydisplay,mywindow );
|
|
335 /* Wait for map. */
|
|
336 do { XNextEvent(mydisplay, &xev);}
|
|
337 while (xev.type != MapNotify || xev.xmap.event != mywindow);
|
|
338 #endif
|
|
339 resize( wsEvent.xconfigure.width, wsEvent.xconfigure.height );
|
|
340 break;
|
|
341 }
|
|
342 }
|
|
343
|
|
344 glEnable(GL_TEXTURE_2D);
|
|
345 // glBindTexture(GL_TEXTURE_2D, texture_id);
|
|
346
|
|
347 glColor3f(1,1,1);
|
|
348 glBegin(GL_QUADS);
|
|
349 glTexCoord2f(0,0);glVertex2i(0,0);
|
|
350 glTexCoord2f(0,1);glVertex2i(0,texture_height);
|
|
351 glTexCoord2f(1,1);glVertex2i(texture_width,texture_height);
|
|
352 glTexCoord2f(1,0);glVertex2i(texture_width,0);
|
|
353 glEnd();
|
|
354
|
|
355 // glFlush();
|
|
356 glFinish();
|
|
357 glXSwapBuffers( mydisplay,mywindow );
|
|
358
|
|
359 }
|
|
360
|
|
361 static inline void
|
|
362 flip_page_x11(void)
|
|
363 {
|
|
364 // Display_Image(myximage, ImageData);
|
|
365 // Display_Image(ImageData);
|
|
366 FlipImage();
|
|
367 }
|
|
368
|
|
369
|
|
370 static void
|
|
371 flip_page(void)
|
|
372 {
|
|
373 return flip_page_x11();
|
|
374 }
|
|
375
|
|
376 static inline uint32_t
|
|
377 draw_slice_x11(uint8_t *src[], uint32_t slice_num)
|
|
378 {
|
|
379 uint8_t *dst;
|
|
380 int i;
|
|
381
|
|
382 dst = ImageData;// + image_width * 16 * BYTES_PP * slice_num;
|
|
383
|
|
384 yuv2rgb(dst , src[0], src[1], src[2],
|
|
385 image_width, 16,
|
|
386 image_width*BYTES_PP, image_width, image_width/2 );
|
|
387
|
|
388 // emms ();
|
|
389
|
|
390 #ifdef TEXSUBIMAGE_BUG_WORKAROUND
|
|
391 for(i=0;i<16;i++){
|
|
392 glTexSubImage2D( GL_TEXTURE_2D, // target
|
|
393 0, // level
|
|
394 0, // x offset
|
|
395 16*slice_num+i, // y offset
|
|
396 image_width, // width
|
|
397 1, // height
|
|
398 (BYTES_PP==4)?GL_RGBA:GL_RGB, // format
|
|
399 GL_UNSIGNED_BYTE, // type
|
|
400 ImageData+i*BYTES_PP*image_width ); // *pixels
|
|
401 }
|
|
402 #else
|
|
403 //printf("uploading slice \n");
|
|
404 glTexSubImage2D( GL_TEXTURE_2D, // target
|
|
405 0, // level
|
|
406 0, // x offset
|
|
407 16*slice_num, // y offset
|
|
408 image_width, // width
|
|
409 16, // height
|
|
410 (BYTES_PP==4)?GL_RGBA:GL_RGB, // format
|
|
411 GL_UNSIGNED_BYTE, // type
|
|
412 ImageData ); // *pixels
|
|
413 #endif
|
|
414
|
|
415 return 0;
|
|
416 }
|
|
417
|
|
418 static uint32_t
|
|
419 draw_slice(uint8_t *src[], uint32_t slice_num)
|
|
420 {
|
|
421 return draw_slice_x11(src,slice_num);
|
|
422 }
|
|
423
|
|
424 #define MIN(a,b) (((a)<(b))?(a):(b))
|
|
425
|
|
426 static inline uint32_t
|
|
427 draw_frame_x11_yv12(uint8_t *src[])
|
|
428 {
|
|
429 int i;
|
|
430 // printf("Converting YUV->RGB...\n");
|
|
431 yuv2rgb(ImageData, src[0], src[1], src[2],
|
|
432 image_width, image_height,
|
|
433 image_width*BYTES_PP, image_width, image_width/2 );
|
|
434 // printf("Ready!\n");
|
|
435
|
|
436 // emms ();
|
|
437
|
|
438 // for(i=0;i<image_height;i++){
|
|
439 for(i=0;i<MIN(image_height,texture_height);i++){
|
|
440 glTexSubImage2D( GL_TEXTURE_2D, // target
|
|
441 0, // level
|
|
442 0, // x offset
|
|
443 i, // y offset
|
|
444 // image_width, // width
|
|
445 MIN(image_width,texture_width), // width
|
|
446 1, // height
|
|
447 (BYTES_PP==4)?GL_RGBA:GL_RGB, // format
|
|
448 GL_UNSIGNED_BYTE, // type
|
|
449 ImageData+i*BYTES_PP*image_width ); // *pixels
|
|
450 }
|
|
451
|
|
452 // Display_Image(ImageData);
|
|
453 // FlipImage();
|
|
454 return 0;
|
|
455 }
|
|
456
|
|
457
|
|
458 static inline uint32_t
|
|
459 draw_frame_x11_bgr(uint8_t *src[])
|
|
460 {
|
|
461 int i;
|
|
462 uint8_t *s=src[0];
|
|
463 uint8_t *de=&ImageData[3*image_width];
|
|
464
|
|
465 for(i=0;i<image_height;i++){
|
|
466 int j;
|
|
467 uint8_t *d=ImageData;
|
|
468 while(d<de){
|
|
469 d[0]=s[2];
|
|
470 d[1]=s[1];
|
|
471 d[2]=s[0];
|
|
472 s+=3;d+=3;
|
|
473 }
|
|
474 glTexSubImage2D( GL_TEXTURE_2D, // target
|
|
475 0, // level
|
|
476 0, // x offset
|
|
477 image_height-1-i, // y offset
|
|
478 image_width<texture_width?image_width:texture_width, // width
|
|
479 // image_width, // width
|
|
480 1, // height
|
|
481 (image_bytes==4)?GL_RGBA:GL_RGB, // format
|
|
482 GL_UNSIGNED_BYTE, // type
|
|
483 ImageData); // *pixels
|
|
484 }
|
|
485
|
|
486 // Display_Image(ImageData);
|
|
487 FlipImage();
|
|
488 return 0;
|
|
489 }
|
|
490
|
|
491 static inline uint32_t
|
|
492 draw_frame_x11_rgb(uint8_t *src[])
|
|
493 {
|
|
494 int i;
|
|
495 uint8_t *ImageData=src[0];
|
|
496
|
|
497 for(i=0;i<image_height;i++){
|
|
498 glTexSubImage2D( GL_TEXTURE_2D, // target
|
|
499 0, // level
|
|
500 0, // x offset
|
|
501 image_height-1-i, // y offset
|
|
502 // image_width, // width
|
|
503 image_width<texture_width?image_width:texture_width, // width
|
|
504 1, // height
|
|
505 (image_bytes==4)?GL_RGBA:GL_RGB, // format
|
|
506 GL_UNSIGNED_BYTE, // type
|
|
507 ImageData+i*image_bytes*image_width ); // *pixels
|
|
508 }
|
|
509
|
|
510 // Display_Image(ImageData);
|
|
511 FlipImage();
|
|
512 return 0;
|
|
513 }
|
|
514
|
|
515
|
|
516 static uint32_t
|
|
517 draw_frame(uint8_t *src[])
|
|
518 {
|
|
519 if(image_format==IMGFMT_YV12)
|
|
520 return draw_frame_x11_yv12(src);
|
|
521 else
|
|
522 if((image_format&IMGFMT_RGB_MASK)==IMGFMT_RGB)
|
|
523 return draw_frame_x11_rgb(src);
|
|
524 else
|
|
525 return draw_frame_x11_bgr(src);
|
|
526 }
|
|
527
|
|
528 static uint32_t
|
|
529 query_format(uint32_t format)
|
|
530 {
|
|
531 switch(format){
|
|
532 case IMGFMT_YV12:
|
|
533 case IMGFMT_RGB|24:
|
|
534 case IMGFMT_BGR|24:
|
|
535 return 1;
|
|
536 }
|
|
537 return 0;
|
|
538 }
|