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 "videovpeogl.h"\r
  25 #include "surfaceopengl.h"\r
  26 \r
  27 \r
  28 #include "message.h"\r
  29 #include "command.h"\r
  30 \r
  31 #include "shaders/generic__vertex_shader.h"\r
  32 #include "shaders/osd__frag_shader.h"\r
  33 \r
  34 #define  BACKBUFFER_WIDTH 1920\r
  35 #define  BACKBUFFER_HEIGHT 1080\r
  36 \r
  37 \r
  38 \r
  39 long long getTimeMS() {\r
  40         struct timespec ts;\r
  41         clock_gettime(CLOCK_MONOTONIC, &ts);\r
  42         return ts.tv_sec*1000+ts.tv_nsec/1000000LL;\r
  43 }\r
  44 \r
  45 \r
  46 \r
  47 OsdOpenGL::OsdOpenGL()\r
  48 {\r
  49   glmutex.Lock();\r
  50 \r
  51   external_driving=false;\r
  52 \r
  53   lastrendertime=getTimeMS();\r
  54   display_height=0;\r
  55   display_width=0;\r
  56   osd_shader=0;\r
  57   gen_shader=0;\r
  58   osd_program=0;\r
  59 \r
  60 #ifdef BENCHMARK_FPS\r
  61         last_benchmark_time=getTimeMS();\r
  62         num_benchmark_frames=0;\r
  63 #endif\r
  64 \r
  65   \r
  66 }\r
  67 \r
  68 OsdOpenGL::~OsdOpenGL()\r
  69 {\r
  70 \r
  71   if (initted) \r
  72   {\r
  73           threadStop();\r
  74                 shutdown();\r
  75   }\r
  76 \r
  77 \r
  78   glmutex.Unlock();\r
  79 }\r
  80 \r
  81 int OsdOpenGL::getFD()\r
  82 {\r
  83   if (!initted) return 0;\r
  84   return fdOsd;\r
  85 }\r
  86 \r
  87 Surface * OsdOpenGL::createNewSurface() {\r
  88         return (Surface*)new SurfaceOpenGL();\r
  89 }\r
  90 \r
  91 int OsdOpenGL::init(void* device)\r
  92 {\r
  93   if (initted) return 0;\r
  94   Video* video = Video::getInstance();\r
  95    //window=*((HWND*)device);\r
  96   \r
  97    // May be this device specific part should go to a device specific child class\r
  98 \r
  99    //init broadcom chipset (Move to video?)\r
 100    bcm_host_init();\r
 101 \r
 102    //First get connection to egl\r
 103    egl_display=eglGetDisplay(EGL_DEFAULT_DISPLAY);\r
 104 \r
 105    if (egl_display==EGL_NO_DISPLAY) {\r
 106            Log::getInstance()->log("OSD", Log::WARN, "Could not get egl display! %x",eglGetError());\r
 107            return 0;\r
 108    }\r
 109 \r
 110 \r
 111 \r
 112    if (eglInitialize(egl_display, NULL, NULL)==EGL_FALSE) {\r
 113            Log::getInstance()->log("OSD", Log::WARN, "Initialising display failed! %x",eglGetError());\r
 114            return 0;\r
 115    }\r
 116 \r
 117    const char *query_str=eglQueryString(egl_display,EGL_CLIENT_APIS);\r
 118    if (query_str) Log::getInstance()->logLongString("OSD", Log::NOTICE, query_str);\r
 119    else Log::getInstance()->log("OSD", Log::WARN, "Could not query display %x",eglGetError());\r
 120    query_str=eglQueryString(egl_display,EGL_EXTENSIONS);\r
 121    if (query_str)    Log::getInstance()->logLongString("OSD", Log::NOTICE, query_str);\r
 122    else Log::getInstance()->log("OSD", Log::WARN, "Could not query display %x",eglGetError());\r
 123 \r
 124    const EGLint attributs[]={\r
 125                  EGL_RED_SIZE,8,EGL_GREEN_SIZE, 8,EGL_BLUE_SIZE, 8,EGL_ALPHA_SIZE, 8,\r
 126          EGL_SURFACE_TYPE, EGL_WINDOW_BIT,\r
 127          EGL_CONFORMANT, EGL_OPENGL_ES2_BIT,\r
 128          EGL_NONE\r
 129    }; // Here, we might have to select the resolution!\r
 130 \r
 131 \r
 132    EGLint number;\r
 133 \r
 134    if (eglChooseConfig(egl_display, attributs, &egl_ourconfig, 1, &number)==EGL_FALSE) {\r
 135            Log::getInstance()->log("OSD", Log::WARN, "Choosing egl config failed! %d",eglGetError());\r
 136            return 0;\r
 137    }\r
 138 \r
 139    const EGLint attr_context[]={\r
 140                    EGL_CONTEXT_CLIENT_VERSION,2,\r
 141           EGL_NONE\r
 142       };\r
 143 \r
 144    egl_context=eglCreateContext(egl_display,egl_ourconfig,EGL_NO_CONTEXT,attr_context);\r
 145    if (egl_context==EGL_NO_CONTEXT) {\r
 146            Log::getInstance()->log("OSD", Log::WARN, "Creating egl context failed! %d",eglGetError());\r
 147            return 0;\r
 148    }\r
 149 \r
 150    // warning broadcom specific, get display size!\r
 151    display_width=display_height=0;\r
 152    if (graphics_get_display_size(0, &display_width, &display_height)<0) {\r
 153            Log::getInstance()->log("OSD", Log::WARN, "Getting display size failed! (BCM API) ");\r
 154            return 0;\r
 155    }\r
 156    Log::getInstance()->log("OSD", Log::NOTICE, "Displaysize is %d x %d ",display_width, display_height);\r
 157    VC_RECT_T dst_rect ={0,0,display_width,display_height};\r
 158    VC_RECT_T src_rect={0,0,display_width<<16,display_height<<16};\r
 159    DISPMANX_DISPLAY_HANDLE_T bcm_display;\r
 160    DISPMANX_ELEMENT_HANDLE_T bcm_element;\r
 161    DISPMANX_UPDATE_HANDLE_T  bcm_update;\r
 162 \r
 163 \r
 164    bcm_display=vc_dispmanx_display_open(0);\r
 165    bcm_update=vc_dispmanx_update_start(0);\r
 166    bcm_element=vc_dispmanx_element_add(bcm_update,bcm_display,\r
 167          0,&dst_rect, 0,\r
 168          &src_rect,DISPMANX_PROTECTION_NONE,0, 0, (DISPMANX_TRANSFORM_T) 0);\r
 169 \r
 170    vc_dispmanx_update_submit_sync(bcm_update);\r
 171    static EGL_DISPMANX_WINDOW_T nativewindow;\r
 172    nativewindow.element=bcm_element;\r
 173    nativewindow.height=display_height;\r
 174    nativewindow.width=display_width;\r
 175 \r
 176    egl_surface = eglCreateWindowSurface(egl_display,egl_ourconfig, &nativewindow,NULL );\r
 177    if (egl_surface==EGL_NO_SURFACE) {\r
 178            Log::getInstance()->log("OSD", Log::WARN, "Creating egl window surface failed!");\r
 179            return 0;\r
 180    }\r
 181 \r
 182    if (eglMakeCurrent(egl_display, egl_surface, egl_surface, egl_context)== EGL_FALSE) {\r
 183            Log::getInstance()->log("OSD", Log::WARN, "Making egl Current failed");\r
 184                    return 0;\r
 185    }\r
 186    // Test stuff\r
 187 \r
 188    query_str=(const char*)glGetString(GL_VERSION) ;\r
 189    if (query_str) Log::getInstance()->logLongString("OSD", Log::NOTICE, query_str);\r
 190    else Log::getInstance()->log("OSD", Log::WARN, "Could not query display %x",glGetError());\r
 191 \r
 192    query_str=(const char*)glGetString(GL_VENDOR) ;\r
 193    if (query_str) Log::getInstance()->logLongString("OSD", Log::NOTICE, query_str);\r
 194    else Log::getInstance()->log("OSD", Log::WARN, "Could not query display %x",glGetError());\r
 195 \r
 196    query_str=(const char*)glGetString(GL_RENDERER) ;\r
 197    if (query_str) Log::getInstance()->logLongString("OSD", Log::NOTICE, query_str);\r
 198    else Log::getInstance()->log("OSD", Log::WARN, "Could not query display %x",glGetError());\r
 199 \r
 200    query_str=(const char*)glGetString(GL_EXTENSIONS) ;\r
 201    if (query_str) Log::getInstance()->logLongString("OSD", Log::NOTICE, query_str);\r
 202    else Log::getInstance()->log("OSD", Log::WARN, "Could not query display %x",glGetError());\r
 203 \r
 204 \r
 205 \r
 206   //Now we will create the Screen\r
 207   screen = (Surface*) new SurfaceOpenGL(Surface::SCREEN);\r
 208 \r
 209   screen->create(video->getScreenWidth(), video->getScreenHeight());\r
 210   screen->display();\r
 211   initted = 1; // must set this here or create surface won't work\r
 212 \r
 213   //glGenBuffers(1, &vB);\r
 214   //glGenBuffers(1, &iB);\r
 215 \r
 216   //Preparing the Shaders\r
 217 \r
 218   gen_shader=CreateShader(generic_vertex_shader, GL_VERTEX_SHADER);\r
 219   osd_shader=CreateShader(osd_frag_shader, GL_FRAGMENT_SHADER);\r
 220 \r
 221 \r
 222   osd_program=glCreateProgram();\r
 223   if (osd_program==0) {\r
 224           Log::getInstance()->log("OSD", Log::WARN, "Creating glsl program failed!%d",glGetError());\r
 225       return 0;\r
 226   }\r
 227   glAttachShader(osd_program,gen_shader);\r
 228   glAttachShader(osd_program,osd_shader);\r
 229   glBindAttribLocation(osd_program,0,"vec_pos");\r
 230   glBindAttribLocation(osd_program,1,"tex_coord");\r
 231 \r
 232   osd_sampler_loc=glGetUniformLocation(osd_program,"texture");\r
 233 \r
 234   glLinkProgram(osd_program);\r
 235   GLint link_status;\r
 236   glGetShaderiv(osd_program,GL_LINK_STATUS, &link_status);\r
 237 \r
 238   if (!link_status) {\r
 239           char buffer[1024];\r
 240           glGetProgramInfoLog(osd_program,1024,NULL,buffer);\r
 241           Log::getInstance()->log("OSD", Log::WARN, "Compiling Programm failed!");\r
 242           Log::getInstance()->log("OSD", Log::WARN, "%s",buffer);\r
 243           glDeleteProgram(osd_program);\r
 244           return 0;\r
 245   }\r
 246 \r
 247   glClearColor(0.0f,0.0f,0.0f,1.f);\r
 248 \r
 249   eglMakeCurrent(egl_display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT );\r
 250 \r
 251   if (((VideoVPEOGL*)Video::getInstance())->initUsingOSDObjects()!=1) { //call Video for init opengl stuff\r
 252           return 0;\r
 253   }\r
 254 \r
 255 \r
 256   glmutex.Unlock();\r
 257   threadStart();\r
 258 \r
 259   return 1;\r
 260 }\r
 261 \r
 262 \r
 263 GLuint OsdOpenGL::CreateShader(const GLchar * source, GLenum type)\r
 264 {\r
 265         GLuint ret_shad=0;\r
 266 \r
 267         ret_shad=glCreateShader(type);\r
 268         if (ret_shad==0 ) {\r
 269                 Log::getInstance()->log("OSD", Log::WARN, "Creating Shader failed! %d",glGetError());\r
 270                 return 0;\r
 271         }\r
 272         glShaderSource(ret_shad,1,&source,NULL);\r
 273         glCompileShader(ret_shad);\r
 274         GLint comp_status;\r
 275         glGetShaderiv(ret_shad,GL_COMPILE_STATUS, &comp_status);\r
 276 \r
 277         if (!comp_status) {\r
 278                 char buffer[1024];\r
 279                 Log::getInstance()->log("OSD", Log::WARN, "Compiling Shader failed!");\r
 280                 glGetShaderInfoLog(ret_shad,1024,NULL,buffer);\r
 281                 Log::getInstance()->log("OSD", Log::WARN, "%s",buffer);\r
 282                 glDeleteShader(ret_shad);\r
 283                 return 0;\r
 284         }\r
 285         return ret_shad;\r
 286 }\r
 287 \r
 288         \r
 289 void OsdOpenGL::InitVertexBuffer(float  scalex,float scaley)\r
 290 {\r
 291   Video* video=Video::getInstance();\r
 292   float texx=1.f;\r
 293   float texy=1.f;\r
 294   OSDCOLOR osdcolor={1.f,1.f,1.f,1.f};\r
 295 \r
 296  // osdvertices[0].c=osdcolor;\r
 297   osdvertices[0].x= (scalex);\r
 298   osdvertices[0].y=-scaley;\r
 299   osdvertices[0].z=0.5;\r
 300   osdvertices[0].u=texx;\r
 301   osdvertices[0].v=texy;\r
 302  // osdvertices[1].c=osdcolor;\r
 303   osdvertices[1].x=(scalex);\r
 304   osdvertices[1].y=(scaley);\r
 305   osdvertices[1].z=0.5f;\r
 306   osdvertices[1].u=texx;\r
 307   osdvertices[1].v=0.f;\r
 308   //  osdvertices[0].c=osdcolor;\r
 309   osdvertices[2].x=(-scalex);\r
 310   osdvertices[2].y=-scaley;\r
 311   osdvertices[2].z=0.5f;\r
 312   osdvertices[2].u=0.f;\r
 313   osdvertices[2].v=texy;\r
 314  // osdvertices[3].c=osdcolor;\r
 315   osdvertices[3].x=-scalex;\r
 316   osdvertices[3].y=(scaley);\r
 317   osdvertices[3].z=0.5f;\r
 318   osdvertices[3].u=0.f;\r
 319   osdvertices[3].v=0.f;\r
 320   \r
 321   osdindices[0]=0;\r
 322   osdindices[1]=1;\r
 323   osdindices[2]=2;\r
 324   osdindices[3]=0;\r
 325   osdindices[4]=2;\r
 326   osdindices[5]=3;\r
 327 \r
 328 \r
 329 \r
 330 \r
 331  // glBindBuffer(GL_ARRAY_BUFFER, vB);\r
 332  // glBufferData(GL_ARRAY_BUFFER, sizeof(osdvertices), osdvertices, GL_STATIC_DRAW);\r
 333 \r
 334 \r
 335  // glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, iB);\r
 336   //glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(osdindices), osdindices, GL_STATIC_DRAW);\r
 337 \r
 338 \r
 339 \r
 340   return;\r
 341 }\r
 342 \r
 343 int OsdOpenGL::shutdown()\r
 344 {\r
 345   if (!initted) return 0;\r
 346   initted = 0;\r
 347 \r
 348   (((VideoVPEOGL*)Video::getInstance())->shutdownUsingOSDObjects());\r
 349 \r
 350 \r
 351   if (osd_shader!=0) glDeleteShader(osd_shader);\r
 352   if (gen_shader!=0) glDeleteShader(gen_shader);\r
 353   if (osd_program!=0) glDeleteProgram(osd_program);\r
 354 \r
 355   glClear(GL_COLOR_BUFFER_BIT);\r
 356   eglSwapBuffers(egl_display, egl_surface);\r
 357   eglMakeCurrent(egl_display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT );\r
 358   eglDestroySurface(egl_display,egl_surface);\r
 359   eglDestroyContext(egl_display,egl_context);\r
 360   eglTerminate(egl_display );\r
 361 \r
 362   return 1;\r
 363 }\r
 364 \r
 365 void OsdOpenGL::screenShot(const char* fileName)\r
 366 {\r
 367   screen->screenShot(fileName);\r
 368 }\r
 369 \r
 370 void OsdOpenGL::threadMethod()\r
 371 {\r
 372         // We have to claim the gl context for this thread\r
 373         //glmutex.Lock();\r
 374 \r
 375         //glmutex.Unlock();\r
 376         while (true)\r
 377         {\r
 378                 unsigned int waittime=10;\r
 379                 if (initted){\r
 380                 //      if (evrstate==EVR_pres_off || evrstate==EVR_pres_pause)\r
 381                 //      {\r
 382                                 Render();\r
 383                                 //TODO get surfaces from Video object\r
 384         /*              } else if (evrstate==EVR_pres_started)\r
 385                         {\r
 386                                 LPDIRECT3DSURFACE9 surf;\r
 387                                 if (dsallocator) dsallocator->GetNextSurface(&surf,&waittime);\r
 388                                 if (surf==NULL)\r
 389                                 {\r
 390                                         Render();\r
 391                                 }\r
 392                                 else\r
 393                                 {\r
 394                                         RenderDS(surf);\r
 395                                         surf->Release();\r
 396                                         if (dsallocator) dsallocator->DiscardSurfaceandgetWait(&waittime);\r
 397                                 }\r
 398                         }*/\r
 399                 }\r
 400                 threadCheckExit();\r
 401                 if (waittime!=0) MILLISLEEP(min(10,waittime));\r
 402                 //Sleep(1);\r
 403         }\r
 404         //eglMakeCurrent(egl_display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT );\r
 405 }\r
 406 \r
 407 \r
 408 void OsdOpenGL::threadPostStopCleanup()\r
 409 {\r
 410         //Doing nothing\r
 411         //goo;\r
 412 }\r
 413 \r
 414 \r
 415 // This function is called from the WinMain function in order to get Screen updates\r
 416 void OsdOpenGL::Render()\r
 417 {\r
 418         if (!initted) return ;\r
 419         if (external_driving) {\r
 420         long long time1=getTimeMS();\r
 421 \r
 422                 if ((time1-lastrendertime)>200) {//5 fps for OSD updates are enough, avoids tearing\r
 423                         InternalRendering(NULL);\r
 424                         lastrendertime=getTimeMS();\r
 425         } else {\r
 426                    //Sleep(5); //Sleep for 5 ms, in order to avoid blocking the other threads\r
 427         }\r
 428         } else {\r
 429                 struct timespec ts;\r
 430                 clock_gettime(CLOCK_MONOTONIC, &ts);\r
 431                 long long time1=ts.tv_sec*1000+ts.tv_nsec/1000000LL;\r
 432                 if ((time1-lastrendertime)>50) {//10 fps for OSD updates are enough, avoids tearing\r
 433                         InternalRendering(NULL);\r
 434                         lastrendertime=getTimeMS();\r
 435                 } else {\r
 436                         //Sleep(5);\r
 437                 \r
 438                 }\r
 439                 \r
 440         }\r
 441 }\r
 442 \r
 443 void OsdOpenGL::RenderDS(GLuint  present){\r
 444         if (!initted) return; \r
 445         if (external_driving) {\r
 446                 InternalRendering(present);\r
 447                 lastrendertime=getTimeMS();\r
 448         }\r
 449 }\r
 450 \r
 451 \r
 452 void OsdOpenGL::InternalRendering(GLuint  present){\r
 453     BeginPainting();\r
 454   /*  HRESULT losty=d3ddevice->TestCooperativeLevel();\r
 455     if (losty==D3DERR_DEVICELOST) {\r
 456         //Sleep(10);\r
 457                 EndPainting();\r
 458         return; //Device Lost\r
 459     }\r
 460     if (losty==D3DERR_DEVICENOTRESET){\r
 461            EndPainting();\r
 462        DoLost();\r
 463        return;\r
 464     }\r
 465         WaitForSingleObject(event,INFINITE);\r
 466         */\r
 467    \r
 468         \r
 469 /*\r
 470     LPDIRECT3DSURFACE9 targetsurf;\r
 471         if (swappy)\r
 472         {\r
 473                 targetsurf=swapsurf;\r
 474                 d3ddevice->SetRenderTarget(0,swapsurf);//Stupid VMR manipulates the render target\r
 475         } \r
 476         else\r
 477         {\r
 478                 targetsurf=d3drtsurf;\r
 479                 d3ddevice->SetRenderTarget(0,d3drtsurf);//Stupid VMR manipulates the render target\r
 480         }\r
 481         D3DSURFACE_DESC targetdesc;\r
 482         targetsurf->GetDesc(&targetdesc);\r
 483 \r
 484         if (external_driving) {\r
 485                 //Copy video to Backbuffer\r
 486                 if (present!=NULL ) {\r
 487                         VideoWin* video =(VideoWin*) Video::getInstance();\r
 488                         /*calculating destination rect *\r
 489                         RECT destrect={0,0,/*video->getScreenWidth()* targetdesc.Width,\r
 490                                 /*video->getScreenHeight()*targetdesc.Height};\r
 491                         UCHAR mode=video->getMode();\r
 492                         switch (mode) {\r
 493                         case Video::EIGHTH:\r
 494                         destrect.right=destrect.right/2;\r
 495                         destrect.bottom=destrect.bottom/2;\r
 496                         case Video::QUARTER:\r
 497                         destrect.right=destrect.right/2+video->getPosx()*2;\r
 498                         destrect.bottom=destrect.bottom/2+video->getPosy()*2;\r
 499                         destrect.left=video->getPosx()*2;\r
 500                         destrect.top=video->getPosy()*2;\r
 501                         d3ddevice->Clear(0,NULL,D3DCLEAR_TARGET,D3DCOLOR_XRGB(0,0,0),1.0f,0);\r
 502                         break;\r
 503                         };\r
 504                         D3DSURFACE_DESC surf_desc;\r
 505                         present->GetDesc(&surf_desc);//for chop sides\r
 506                         RECT sourcerect= {0,0,surf_desc.Width,surf_desc.Height};\r
 507                         if (video->getPseudoTVsize()==Video::ASPECT4X3 \r
 508                                 && video->getMode()==Video::NORMAL \r
 509                                 && video->getAspectRatio()==Video::ASPECT16X9) {\r
 510                                         unsigned int correction=((double) (surf_desc.Width))*4.*9./3./16.;\r
 511                                         sourcerect.left=(surf_desc.Width-correction)/2;\r
 512                                         sourcerect.right=sourcerect.left+correction;\r
 513                         }\r
 514                         d3ddevice->StretchRect(present,&sourcerect,targetsurf ,&destrect,filter_type);\r
 515 \r
 516                 }\r
 517         } else {\r
 518                 VideoWin* video =(VideoWin*) Video::getInstance();\r
 519                 //Clear Background\r
 520                 if (!video->isVideoOn()) d3ddevice->Clear(0,NULL,D3DCLEAR_TARGET,D3DCOLOR_XRGB(0,0,0),1.0f,0);\r
 521         }*/\r
 522 \r
 523 \r
 524         //InitVertexBuffer(display_width,display_height);\r
 525     InitVertexBuffer(1.f,1.f);\r
 526 \r
 527 \r
 528         glViewport(0, 0, display_width,display_height);\r
 529 \r
 530         glClear(GL_COLOR_BUFFER_BIT);\r
 531         glUseProgram(osd_program);\r
 532 \r
 533         glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE,sizeof(OSDVERTEX), osdvertices);\r
 534         glEnableVertexAttribArray(0);\r
 535         glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE,sizeof(OSDVERTEX), &(osdvertices[0].u));\r
 536         glEnableVertexAttribArray(1);\r
 537 \r
 538 \r
 539 \r
 540 \r
 541         glActiveTexture(GL_TEXTURE0);\r
 542         glBindTexture(GL_TEXTURE_2D,((SurfaceOpenGL*)screen)->getTexture());\r
 543 \r
 544         glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);\r
 545         glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);\r
 546 \r
 547         glUniform1i(osd_sampler_loc,0);\r
 548 \r
 549         if (0) { //This is ok for ffmpeg rendering not OMX\r
 550                 glEnable(GL_BLEND);\r
 551                 glBlendFuncSeparate (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA,GL_ZERO,GL_ONE);\r
 552 \r
 553         }\r
 554 /*      glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE,sizeof(OSDVERTEX),\r
 555                         (GLvoid*)(((char*)osdvertices)+3*sizeof(GLfloat)));\r
 556         glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE,sizeof(OSDVERTEX),\r
 557                         (GLvoid*)(((char*)osdvertices)+3*sizeof(GLfloat)+sizeof(OSDCOLOR)));*/\r
 558         //glDisable(GL_LIGHTING);\r
 559         //glEnable(GL_TEXTURE_2D);\r
 560         //glEnable(GL_BLEND);\r
 561     //glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);\r
 562     //glDepthFunc(GL_ALWAYS);\r
 563     //glDisable(GL_DEPTH_TEST);\r
 564     //glDisable(GL_STENCIL_TEST);\r
 565     //glDisable(GL_CULL_FACE);\r
 566 \r
 567 \r
 568 \r
 569 /*\r
 570         glActiveTexture(GL_TEXTURE0);\r
 571         glBindTexture(GL_TEXTURE_2D,((SurfaceOpenGL*)screen)->getTexture());\r
 572         glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);\r
 573         glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);*/\r
 574 //      glUniform1i(mTextureUniformHandle, present);\r
 575 \r
 576 \r
 577 \r
 578         glDrawArrays(GL_TRIANGLE_STRIP, 0,  4);\r
 579 \r
 580         //glDrawElements(GL_TRIANGLES, sizeof(osdindices)/sizeof(osdindices[0]), GL_UNSIGNED_BYTE, 0);\r
 581 \r
 582 \r
 583 \r
 584 \r
 585 /*      glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE,sizeof(OSDVERTEX), 0);\r
 586         glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE,sizeof(OSDVERTEX),\r
 587                                 (GLvoid*)(3*sizeof(GLfloat)));\r
 588         glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE,sizeof(OSDVERTEX),\r
 589                         (GLvoid*)(3*sizeof(GLfloat)+sizeof(OSDCOLOR)));*/\r
 590 \r
 591         //glDisable(GL_BLEND);\r
 592         //glDisable(GL_TEXTURE_2D);\r
 593         \r
 594         //Show it to the user!\r
 595         eglSwapBuffers(egl_display, egl_surface);\r
 596 \r
 597         EndPainting();\r
 598 #ifdef BENCHMARK_FPS\r
 599         num_benchmark_frames++;\r
 600         if (getTimeMS()-last_benchmark_time>4000) {\r
 601                 float fps=1000./(float)(getTimeMS()-last_benchmark_time);\r
 602                 fps*=((float)num_benchmark_frames);\r
 603                 num_benchmark_frames=0;\r
 604                 Log::getInstance()->log("OSD", Log::NOTICE, "Current FPS %g", fps);\r
 605                 last_benchmark_time=getTimeMS();\r
 606 \r
 607         }\r
 608 \r
 609 #endif\r
 610 \r
 611         \r
 612 //      if (!external_driving) {\r
 613 //              Sleep(4);//The User can wait for 4 milliseconds to see his changes\r
 614 //      }\r
 615 }\r
 616 \r
 617 bool OsdOpenGL::DoLost(){\r
 618         /*\r
 619         Log::getInstance()->log("OSD", Log::WARN, "Direct3D Device Lost! Reobtaining...");\r
 620         ResetEvent(event);\r
 621         if (external_driving && dsallocator!=NULL) {\r
 622                 dsallocator->LostDevice(d3ddevice,d3d); //Propagate the information through DS\r
 623         }\r
 624         //First we free up all resources\r
 625         Video* video = Video::getInstance();\r
 626         ((SurfaceWin*)screen)->ReleaseSurface();\r
 627         if (d3drtsurf) d3drtsurf->Release();\r
 628     d3drtsurf=NULL;\r
 629         D3DPRESENT_PARAMETERS d3dparas;\r
 630         ZeroMemory(&d3dparas,sizeof(d3dparas));\r
 631         d3dparas.BackBufferWidth=BACKBUFFER_WIDTH;\r
 632         d3dparas.BackBufferHeight=BACKBUFFER_HEIGHT;\r
 633         d3dparas.Windowed=TRUE;\r
 634         d3dparas.SwapEffect=D3DSWAPEFFECT_COPY;\r
 635 \r
 636         if (swapsurf) {swapsurf->Release();swapsurf=NULL;};\r
 637         if (swappy) {swappy->Release();swappy=NULL;};\r
 638 \r
 639         if (d3ddevice->Reset(&d3dparas)!=D3D_OK){\r
 640                 return false;\r
 641         }\r
 642     d3ddevice->GetRenderTarget(0,&d3drtsurf);\r
 643         if (d3ddevman) d3ddevman->ResetDevice(d3ddevice,dxvatoken);\r
 644         //InitVertexBuffer();\r
 645     //Redraw Views, Chris could you add a member function to BoxStack, so that\r
 646         // I can cause it to completely redraw the Views?\r
 647         // Otherwise the OSD would be distorted after Device Lost\r
 648         // FIXME\r
 649         \r
 650         SetEvent(event);\r
 651 \r
 652 \r
 653         screen->create(video->getScreenWidth(), video->getScreenHeight());\r
 654         screen->display();*/\r
 655         \r
 656         return true;\r
 657 \r
 658 }\r
 659 \r
 660 \r
 661 void OsdOpenGL::BeginPainting() {//We synchronize calls to d3d between different threads\r
 662         glmutex.Lock();\r
 663         if (initted) {\r
 664                 if (eglMakeCurrent(egl_display, egl_surface, egl_surface, egl_context)== EGL_FALSE) {\r
 665                         Log::getInstance()->log("OSD", Log::WARN, "Making egl Current failed in thread %d",eglGetError());\r
 666                         return;\r
 667                 }\r
 668         }\r
 669 }\r
 670 \r
 671 void OsdOpenGL::EndPainting() {\r
 672         eglMakeCurrent(egl_display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT );\r
 673         glmutex.Unlock();\r
 674 }\r
 675 \r
 676 void OsdOpenGL::setExternalDriving(/*DsAllocator* dsall,*/unsigned int  width, unsigned height) {\r
 677         /*\r
 678         if (swappy)\r
 679         {\r
 680                 BeginPainting();\r
 681                 d3ddevice->StretchRect(swapsurf,NULL,d3drtsurf,NULL,filter_type);\r
 682                 LPDIRECT3DSWAPCHAIN9 temp=swappy;\r
 683                 LPDIRECT3DSURFACE9 tempsurf=swapsurf;\r
 684                 swappy=NULL;\r
 685                 swapsurf=NULL;\r
 686                 EndPainting();\r
 687                 tempsurf->Release();\r
 688                 temp->Release();\r
 689         }\r
 690 \r
 691         if (dsall==NULL) {\r
 692                 external_driving=false;\r
 693                 dsallocator=NULL;       \r
 694                 return;\r
 695         }\r
 696         WaitForSingleObject(event,INFINITE);//We will only return if we are initted\r
 697         BeginPainting();\r
 698 \r
 699         if (width>BACKBUFFER_WIDTH || height>BACKBUFFER_HEIGHT) \r
 700         {\r
 701                 D3DPRESENT_PARAMETERS d3dparas;\r
 702                 ZeroMemory(&d3dparas,sizeof(d3dparas));\r
 703                 d3dparas.BackBufferWidth=width;\r
 704                 d3dparas.BackBufferHeight=height;\r
 705                 d3dparas.Windowed=TRUE;\r
 706                 d3dparas.SwapEffect=D3DSWAPEFFECT_COPY;\r
 707                 if (d3ddevice->CreateAdditionalSwapChain(&d3dparas,&swappy)!=D3D_OK){\r
 708                         Log::getInstance()->log("OSD", Log::WARN, "Could not create Swap Chain!");\r
 709                         //return 0;\r
 710                 } else {\r
 711                         swappy->GetBackBuffer(0,D3DBACKBUFFER_TYPE_MONO,&swapsurf);\r
 712                 }\r
 713         Log::getInstance()->log("OSD", Log::INFO, "Create Additional Swap Chain %d %d!",width,height);\r
 714         }\r
 715 \r
 716         dsallocator=dsall;\r
 717         external_driving=true;\r
 718         \r
 719         EndPainting();*/\r
 720 }\r
 721 \r
 722 void OsdOpenGL::Blank() {\r
 723         BeginPainting();\r
 724         glClearColor(0.15f, 0.25f, 0.35f, 1.0f); // change this to black after testing\r
 725         glClear( GL_COLOR_BUFFER_BIT );\r
 726         glClear( GL_DEPTH_BUFFER_BIT );\r
 727         EndPainting();\r
 728 }\r