]> git.vomp.tv Git - vompclient.git/blob - osdopengl.cc
Some fixes on cancellation points
[vompclient.git] / osdopengl.cc
1 /*\r
2     Copyright 2004-2005 Chris Tallon, 2006,2011-2012 Marten Richter\r
3 \r
4     This file is part of VOMP.\r
5 \r
6     VOMP is free software; you can redistribute it and/or modify\r
7     it under the terms of the GNU General Public License as published by\r
8     the Free Software Foundation; either version 2 of the License, or\r
9     (at your option) any later version.\r
10 \r
11     VOMP is distributed in the hope that it will be useful,\r
12     but WITHOUT ANY WARRANTY; without even the implied warranty of\r
13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
14     GNU General Public License for more details.\r
15 \r
16     You should have received a copy of the GNU General Public License\r
17     along with VOMP; if not, write to the Free Software\r
18     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.\r
19 */\r
20 \r
21 \r
22 #include "osdopengl.h"\r
23 #include "mtd.h"\r
24 #include "videoomx.h"\r
25 #include "surfaceopengl.h"\r
26 \r
27 \r
28 #include "message.h"\r
29 #include "command.h"\r
30 \r
31 \r
32 #define  BACKBUFFER_WIDTH 1280\r
33 #define  BACKBUFFER_HEIGHT 720\r
34 \r
35 \r
36 \r
37 \r
38 \r
39 \r
40 \r
41 OsdOpenGL::OsdOpenGL()\r
42 {\r
43   glmutex.Lock();\r
44 \r
45   external_driving=false;\r
46 \r
47   lastrendertime=getTimeMS();\r
48   display_height=0;\r
49   display_width=0;\r
50   mode=0;\r
51 \r
52 #ifdef BENCHMARK_FPS\r
53         last_benchmark_time=getTimeMS();\r
54         num_benchmark_frames=0;\r
55 #endif\r
56 \r
57   \r
58 }\r
59 \r
60 OsdOpenGL::~OsdOpenGL()\r
61 {\r
62 \r
63   if (initted) \r
64   {\r
65           threadStop();\r
66                 shutdown();\r
67   }\r
68 \r
69 \r
70   glmutex.Unlock();\r
71 }\r
72 \r
73 int OsdOpenGL::getFD()\r
74 {\r
75   if (!initted) return 0;\r
76   return fdOsd;\r
77 }\r
78 \r
79 Surface * OsdOpenGL::createNewSurface() {\r
80         return (Surface*)new SurfaceOpenGL();\r
81 }\r
82 \r
83 int OsdOpenGL::init(void* device)\r
84 {\r
85   if (initted) return 0;\r
86   Video* video = Video::getInstance();\r
87    //window=*((HWND*)device);\r
88   \r
89    // May be this device specific part should go to a device specific child class\r
90 \r
91    //init broadcom chipset (Move to video?)\r
92 \r
93 \r
94    //First get connection to egl\r
95    egl_display=eglGetDisplay(EGL_DEFAULT_DISPLAY);\r
96 \r
97    if (egl_display==EGL_NO_DISPLAY) {\r
98            Log::getInstance()->log("OSD", Log::WARN, "Could not get egl display! %x",eglGetError());\r
99            glmutex.Unlock();\r
100            return 0;\r
101    }\r
102 \r
103 \r
104 \r
105    if (eglInitialize(egl_display, NULL, NULL)==EGL_FALSE) {\r
106            Log::getInstance()->log("OSD", Log::WARN, "Initialising display failed! %x",eglGetError());\r
107            glmutex.Unlock();\r
108            return 0;\r
109    }\r
110 \r
111    const char *query_str=eglQueryString(egl_display,EGL_CLIENT_APIS);\r
112    if (query_str) Log::getInstance()->logLongString("OSD", Log::NOTICE, query_str);\r
113    else Log::getInstance()->log("OSD", Log::WARN, "Could not query display %x",eglGetError());\r
114    query_str=eglQueryString(egl_display,EGL_EXTENSIONS);\r
115    if (query_str)    Log::getInstance()->logLongString("OSD", Log::NOTICE, query_str);\r
116    else Log::getInstance()->log("OSD", Log::WARN, "Could not query display %x",eglGetError());\r
117 \r
118    const EGLint attributs[]={\r
119                  EGL_RED_SIZE,8,EGL_GREEN_SIZE, 8,EGL_BLUE_SIZE, 8,EGL_ALPHA_SIZE, 8,\r
120          EGL_SURFACE_TYPE, EGL_WINDOW_BIT|EGL_PBUFFER_BIT,\r
121          EGL_CONFORMANT, EGL_OPENGL_ES2_BIT,\r
122          EGL_NONE\r
123    }; // Here, we might have to select the resolution!\r
124 \r
125 \r
126    EGLint number;\r
127 \r
128    if (eglChooseConfig(egl_display, attributs, &egl_ourconfig, 1, &number)==EGL_FALSE) {\r
129            Log::getInstance()->log("OSD", Log::WARN, "Choosing egl config failed! %x",eglGetError());\r
130            glmutex.Unlock();\r
131            return 0;\r
132    }\r
133 \r
134    const EGLint attr_context[]={\r
135                    EGL_CONTEXT_CLIENT_VERSION,2,\r
136           EGL_NONE\r
137       };\r
138 \r
139    egl_context=eglCreateContext(egl_display,egl_ourconfig,EGL_NO_CONTEXT,attr_context);\r
140    if (egl_context==EGL_NO_CONTEXT) {\r
141            Log::getInstance()->log("OSD", Log::WARN, "Creating egl context failed! %x",eglGetError());\r
142            glmutex.Unlock();\r
143            return 0;\r
144    }\r
145 \r
146    // warning broadcom specific, get display size!\r
147    display_width=display_height=0;\r
148    if (graphics_get_display_size(0, &display_width, &display_height)<0) {\r
149            Log::getInstance()->log("OSD", Log::WARN, "Getting display size failed! (BCM API) ");\r
150            glmutex.Unlock();\r
151            return 0;\r
152    }\r
153    Log::getInstance()->log("OSD", Log::NOTICE, "Displaysize is %d x %d ",display_width, display_height);\r
154    VC_RECT_T dst_rect ={0,0,display_width,display_height};\r
155    VC_RECT_T src_rect={0,0,BACKBUFFER_WIDTH <<16,BACKBUFFER_HEIGHT<<16};\r
156 \r
157   DISPMANX_UPDATE_HANDLE_T  bcm_update;\r
158 \r
159    bcm_display=vc_dispmanx_display_open(0);\r
160    bcm_update=vc_dispmanx_update_start(0);\r
161    bcm_element=vc_dispmanx_element_add(bcm_update,bcm_display,\r
162          2,&dst_rect, 0,\r
163          &src_rect,DISPMANX_PROTECTION_NONE,0, 0, (DISPMANX_TRANSFORM_T) 0);\r
164 \r
165    vc_dispmanx_update_submit_sync(bcm_update);\r
166    static EGL_DISPMANX_WINDOW_T nativewindow;\r
167    nativewindow.element=bcm_element;\r
168    nativewindow.height=BACKBUFFER_HEIGHT;\r
169    nativewindow.width=BACKBUFFER_WIDTH;\r
170 \r
171    egl_surface = eglCreateWindowSurface(egl_display,egl_ourconfig, &nativewindow,NULL );\r
172    if (egl_surface==EGL_NO_SURFACE) {\r
173            Log::getInstance()->log("OSD", Log::WARN, "Creating egl window surface failed!");\r
174            glmutex.Unlock();\r
175            return 0;\r
176    }\r
177 \r
178    if (eglMakeCurrent(egl_display, egl_surface, egl_surface, egl_context)== EGL_FALSE) {\r
179            Log::getInstance()->log("OSD", Log::WARN, "Making egl Current failed");\r
180            glmutex.Unlock();\r
181                    return 0;\r
182    }\r
183    // Test stuff\r
184 \r
185    query_str=(const char*)glGetString(GL_VERSION) ;\r
186    if (query_str) Log::getInstance()->logLongString("OSD", Log::NOTICE, query_str);\r
187    else Log::getInstance()->log("OSD", Log::WARN, "Could not query display %x",glGetError());\r
188 \r
189    query_str=(const char*)glGetString(GL_VENDOR) ;\r
190    if (query_str) Log::getInstance()->logLongString("OSD", Log::NOTICE, query_str);\r
191    else Log::getInstance()->log("OSD", Log::WARN, "Could not query display %x",glGetError());\r
192 \r
193    query_str=(const char*)glGetString(GL_RENDERER) ;\r
194    if (query_str) Log::getInstance()->logLongString("OSD", Log::NOTICE, query_str);\r
195    else Log::getInstance()->log("OSD", Log::WARN, "Could not query display %x",glGetError());\r
196 \r
197    query_str=(const char*)glGetString(GL_EXTENSIONS) ;\r
198    if (query_str) Log::getInstance()->logLongString("OSD", Log::NOTICE, query_str);\r
199    else Log::getInstance()->log("OSD", Log::WARN, "Could not query display %x",glGetError());\r
200 \r
201 \r
202 \r
203 \r
204   //Now we will create the Screen\r
205   screen = (Surface*) new SurfaceOpenGL(Surface::SCREEN);\r
206 \r
207   screen->create(video->getScreenWidth(), video->getScreenHeight());\r
208   screen->display();\r
209   initted = 1; // must set this here or create surface won't work\r
210 \r
211   //glGenBuffers(1, &vB);\r
212   //glGenBuffers(1, &iB);\r
213 \r
214   //Preparing the Shaders\r
215 \r
216   if (!osd_shader.init()) {\r
217           Log::getInstance()->log("OSD", Log::WARN, "Init Osd Shader failed");\r
218           glmutex.Unlock();\r
219           return 0;\r
220   }\r
221 \r
222 \r
223 \r
224 \r
225   glClearColor(0.0f,0.0f,0.0f,1.f);\r
226   eglSwapInterval(egl_display, 1 );\r
227 \r
228   eglMakeCurrent(egl_display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT );\r
229 \r
230   if (((VideoOMX*)Video::getInstance())->initUsingOSDObjects()!=1) { //call Video for init opengl stuff\r
231           return 0;\r
232   }\r
233 \r
234 \r
235   glmutex.Unlock();\r
236   threadStart();\r
237 \r
238   return 1;\r
239 }\r
240         \r
241 void OsdOpenGL::InitVertexBuffer(float  scalex,float scaley)\r
242 {\r
243   Video* video=Video::getInstance();\r
244   float texx=1.f;\r
245   float texy=1.f;\r
246   OSDCOLOR osdcolor={1.f,1.f,1.f,1.f};\r
247 \r
248  // osdvertices[0].c=osdcolor;\r
249   osdvertices[0].x= (scalex);\r
250   osdvertices[0].y=-scaley;\r
251   osdvertices[0].z=0.5;\r
252   osdvertices[0].u=texx;\r
253   osdvertices[0].v=texy;\r
254  // osdvertices[1].c=osdcolor;\r
255   osdvertices[1].x=(scalex);\r
256   osdvertices[1].y=(scaley);\r
257   osdvertices[1].z=0.5f;\r
258   osdvertices[1].u=texx;\r
259   osdvertices[1].v=0.f;\r
260   //  osdvertices[0].c=osdcolor;\r
261   osdvertices[2].x=(-scalex);\r
262   osdvertices[2].y=-scaley;\r
263   osdvertices[2].z=0.5f;\r
264   osdvertices[2].u=0.f;\r
265   osdvertices[2].v=texy;\r
266  // osdvertices[3].c=osdcolor;\r
267   osdvertices[3].x=-scalex;\r
268   osdvertices[3].y=(scaley);\r
269   osdvertices[3].z=0.5f;\r
270   osdvertices[3].u=0.f;\r
271   osdvertices[3].v=0.f;\r
272   \r
273   osdindices[0]=0;\r
274   osdindices[1]=1;\r
275   osdindices[2]=2;\r
276   osdindices[3]=0;\r
277   osdindices[4]=2;\r
278   osdindices[5]=3;\r
279 \r
280   return;\r
281 }\r
282 \r
283 int OsdOpenGL::shutdown()\r
284 {\r
285   if (!initted) return 0;\r
286   glmutex.Lock();\r
287   initted = 0;\r
288   threadStop();\r
289   delete screen;\r
290   screen=NULL;\r
291 \r
292   (((VideoOMX*)Video::getInstance())->shutdownUsingOSDObjects());\r
293 \r
294 \r
295   osd_shader.deinit();\r
296 \r
297   glClear(GL_COLOR_BUFFER_BIT);\r
298   eglSwapBuffers(egl_display, egl_surface);\r
299   eglMakeCurrent(egl_display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT );\r
300   eglDestroySurface(egl_display,egl_surface);\r
301   eglDestroyContext(egl_display,egl_context);\r
302   eglTerminate(egl_display );\r
303 \r
304   DISPMANX_UPDATE_HANDLE_T  bcm_update;\r
305   bcm_update=vc_dispmanx_update_start(0);\r
306 \r
307   vc_dispmanx_element_remove(bcm_update,bcm_element);\r
308   vc_dispmanx_update_submit_sync(bcm_update);\r
309   vc_dispmanx_display_close(bcm_display);\r
310 \r
311 \r
312   return 1;\r
313 }\r
314 \r
315 void OsdOpenGL::screenShot(const char* fileName)\r
316 {\r
317   BeginPainting();\r
318   screen->screenShot(fileName);\r
319   EndPainting();\r
320 }\r
321 \r
322 void OsdOpenGL::threadMethod()\r
323 {\r
324         // We have to claim the gl context for this thread\r
325         //glmutex.Lock();\r
326 \r
327         //glmutex.Unlock();\r
328         int ts=0;\r
329         while (true)\r
330         {\r
331                 ts=10;\r
332                 unsigned int waittime=10;\r
333 \r
334                 if (initted) {\r
335 \r
336                         long long time1 = getTimeMS();\r
337                         if ((time1 - lastrendertime) > 200) {//5 fps for OSD updates are enough, avoids tearing\r
338                                 InternalRendering();\r
339                                 lastrendertime = getTimeMS();\r
340 \r
341                         }\r
342                 }\r
343 \r
344                 threadCheckExit();\r
345                 if (ts!=0) {\r
346                         struct timespec target_time;\r
347                         clock_gettime(CLOCK_REALTIME,&target_time);\r
348                         target_time.tv_nsec+=1000000LL*ts;\r
349                         if (target_time.tv_nsec>999999999) {\r
350                                 target_time.tv_nsec-=1000000000L;\r
351                                 target_time.tv_sec+=1;\r
352                         }\r
353                         threadWaitForSignalTimed(&target_time);\r
354                 }\r
355                 //Sleep(1);\r
356         }\r
357         //eglMakeCurrent(egl_display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT );\r
358 }\r
359 \r
360 \r
361 void OsdOpenGL::threadPostStopCleanup()\r
362 {\r
363         //Doing nothing\r
364         //goo;\r
365 }\r
366 \r
367 \r
368 \r
369 void OsdOpenGL::InternalRendering(){\r
370 \r
371     BeginPainting();\r
372 \r
373 \r
374 \r
375 \r
376         //InitVertexBuffer(display_width,display_height);\r
377     InitVertexBuffer(1.f,1.f);\r
378 \r
379 \r
380         glViewport(0, 0, BACKBUFFER_WIDTH ,BACKBUFFER_HEIGHT);\r
381 \r
382         glClearColor(0.0f,0.0f,0.0f,1.f);\r
383         glClear(GL_COLOR_BUFFER_BIT);\r
384 \r
385         osd_shader.PrepareRendering(((SurfaceOpenGL*)screen)->getTexture());\r
386 \r
387         glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE,sizeof(OSDVERTEX), osdvertices);\r
388         glEnableVertexAttribArray(0);\r
389         glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE,sizeof(OSDVERTEX), &(osdvertices[0].u));\r
390         glEnableVertexAttribArray(1);\r
391 \r
392 \r
393 \r
394         glDisable(GL_BLEND);\r
395 \r
396 \r
397 \r
398         glDrawArrays(GL_TRIANGLE_STRIP, 0,  4);\r
399 \r
400 \r
401 \r
402         //Show it to the user!\r
403         eglSwapBuffers(egl_display, egl_surface);\r
404 \r
405         EndPainting();\r
406 \r
407 #ifdef BENCHMARK_FPS\r
408         num_benchmark_frames++;\r
409         if (getTimeMS()-last_benchmark_time>4000) {\r
410                 float fps=1000./(float)(getTimeMS()-last_benchmark_time);\r
411                 fps*=((float)num_benchmark_frames);\r
412                 num_benchmark_frames=0;\r
413                 Log::getInstance()->log("OSD", Log::NOTICE, "Current FPS %g", fps);\r
414                 last_benchmark_time=getTimeMS();\r
415 \r
416         }\r
417 \r
418 #endif\r
419 \r
420         \r
421 \r
422 }\r
423 \r
424 \r
425 \r
426 \r
427 void OsdOpenGL::BeginPainting() {//We synchronize calls to d3d between different threads\r
428         glmutex.Lock();\r
429         if (initted) {\r
430                 if (eglMakeCurrent(egl_display, egl_surface, egl_surface, egl_context)== EGL_FALSE) {\r
431                         Log::getInstance()->log("OSD", Log::WARN, "Making egl Current failed in thread %d",eglGetError());\r
432                         return;\r
433                 }\r
434         }\r
435 }\r
436 \r
437 void OsdOpenGL::EndPainting() {\r
438         eglMakeCurrent(egl_display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT );\r
439         glmutex.Unlock();\r
440 }\r
441 \r
442 \r
443 \r
444 void OsdOpenGL::Blank() {\r
445         BeginPainting();\r
446         glClearColor(0.15f, 1.f, 0.35f, 1.0f); // change this to black after testing\r
447         glClear( GL_COLOR_BUFFER_BIT );\r
448         glClear( GL_DEPTH_BUFFER_BIT );\r
449         EndPainting();\r
450 }\r