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