osdwin.cc

   1 /*
   2     Copyright 2004-2005 Chris Tallon
   3
   4     This file is part of VOMP.
   5
   6     VOMP 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     VOMP 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 VOMP; if not, write to the Free Software
  18     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19 */
  20
  21
  22 #include "osdwin.h"
  23 #include "mtd.h"
  24 #include "videowin.h"
  25 #include "surfacewin.h"
  26
  27 #include "dsallocator.h"
  28
  29
  30 //This is stuff for rendering the OSD
  31
  32
  33 OsdWin::OsdWin()
  34 {
  35   d3d=NULL;
  36   d3ddevice=NULL;
  37   d3dvb=NULL;
  38   d3drtsurf=NULL;
  39   external_driving=false;
  40   dsallocator=NULL;
  41   filter_type=D3DTEXF_NONE;
  42   lastrendertime=timeGetTime();
  43   event = CreateEvent(NULL,/*FALSE*/TRUE,FALSE,NULL);
  44   d3dmutex = CreateMutex(NULL,FALSE,NULL);
  45
  46 }
  47
  48 OsdWin::~OsdWin()
  49 {
  50   if (initted) shutdown();
  51   CloseHandle(event);
  52   CloseHandle(d3dmutex);
  53 }
  54
  55 int OsdWin::getFD()
  56 {
  57   if (!initted) return 0;
  58   return fdOsd;
  59 }
  60
  61 int OsdWin::init(void* device)
  62 {
  63   if (initted) return 0;
  64    Video* video = Video::getInstance();
  65   //First Create Direct 3D Object
  66   d3d=Direct3DCreate9(D3D_SDK_VERSION);
  67   if (!d3d)
  68   {
  69     Log::getInstance()->log("OSD", Log::WARN, "Could not create Direct3D9 object!");
  70     return 0;
  71   }
  72   // then create the Device
  73   D3DPRESENT_PARAMETERS d3dparas;
  74   ZeroMemory(&d3dparas,sizeof(d3dparas));
  75   d3dparas.BackBufferWidth=video->getScreenWidth();
  76   d3dparas.BackBufferHeight=video->getScreenHeight();
  77   d3dparas.Windowed=TRUE;
  78   d3dparas.SwapEffect=D3DSWAPEFFECT_COPY;
  79   if (d3d->CreateDevice(D3DADAPTER_DEFAULT,D3DDEVTYPE_HAL,*((HWND*) device),
  80           D3DCREATE_SOFTWARE_VERTEXPROCESSING |D3DCREATE_MULTITHREADED,&d3dparas,&d3ddevice)!=D3D_OK) {
  81            Log::getInstance()->log("OSD", Log::WARN, "Could not create Direct3D9 device!");
  82        return 0;
  83   }
  84   d3ddevice->GetRenderTarget(0,&d3drtsurf);
  85
  86   if (!InitVertexBuffer()) {
  87            Log::getInstance()->log("OSD", Log::WARN, "Could not create Direct3D9 vertex buf!");
  88                   return 0;
  89   }
  90   /* We have to determine which kind of filtering is supported*/
  91   D3DCAPS9 caps;
  92   d3ddevice->GetDeviceCaps(&caps);
  93   filter_type=D3DTEXF_NONE;
  94   if ( ((caps.StretchRectFilterCaps & D3DPTFILTERCAPS_MINFPOINT)!=0)
  95           && ((caps.StretchRectFilterCaps & D3DPTFILTERCAPS_MAGFPOINT)!=0)) {
  96                   filter_type=D3DTEXF_POINT;
  97    }
  98    if ( ((caps.StretchRectFilterCaps & D3DPTFILTERCAPS_MINFLINEAR)!=0)
  99           && ((caps.StretchRectFilterCaps & D3DPTFILTERCAPS_MAGFLINEAR)!=0)) {
 100                   filter_type=D3DTEXF_LINEAR;
 101    }
 102
 103   //Now we will create the Screen
 104   screen = new SurfaceWin(Surface::SCREEN);
 105   SetEvent(event);//Now all devices are ready
 106   screen->create(video->getScreenWidth(), video->getScreenHeight());
 107   screen->display();
 108   initted = 1; // must set this here or create surface won't work
 109
 110   return 1;
 111 }
 112
 113
 114 int OsdWin::InitVertexBuffer() {
 115   Video* video = Video::getInstance();
 116   FLOAT texx=((float)video->getScreenWidth())/1024.f;
 117   FLOAT texy=((float)video->getScreenHeight())/1024.f;
 118   D3DCOLOR osdcolor=D3DCOLOR_RGBA(255,255,255,255);
 119   osdvertices[0].c=osdcolor;
 120   osdvertices[0].x=0.f-0.5f;
 121   osdvertices[0].y=0.f-0.5f;
 122   osdvertices[0].z=0.5f;
 123   osdvertices[0].rhw=1.f;
 124   osdvertices[0].u=0.f;
 125   osdvertices[0].v=0.f;
 126   osdvertices[1].c=osdcolor;
 127   osdvertices[1].x=((float)video->getScreenWidth())-0.5f;-0.5f;
 128   osdvertices[1].y=0.f-0.5f;
 129   osdvertices[1].z=0.5f;
 130   osdvertices[1].u=texx;
 131   osdvertices[1].v=0.f;
 132   osdvertices[1].rhw=1.f;
 133   osdvertices[2].c=osdcolor;
 134   osdvertices[2].x=((float)video->getScreenWidth())-0.5f;
 135   osdvertices[2].y=((float)video->getScreenHeight())-0.5f;
 136   osdvertices[2].z=0.5f;
 137   osdvertices[2].rhw=1.f;
 138   osdvertices[2].u=texx;
 139   osdvertices[2].v=texy;
 140   osdvertices[3].c=osdcolor;
 141   osdvertices[3].x=0.f-0.5f;
 142   osdvertices[3].y=((float)video->getScreenHeight())-0.5f;
 143   osdvertices[3].z=0;
 144   osdvertices[3].rhw=1.f;
 145   osdvertices[3].u=0.f;
 146   osdvertices[3].v=texy;
 147   if (d3dvb) {
 148           d3dvb->Release();
 149           d3dvb=NULL;
 150   }
 151   if (d3ddevice->CreateVertexBuffer(4*sizeof(OSDVERTEX),0,D3DFVF_OSDVERTEX,D3DPOOL_MANAGED,
 152           &d3dvb,NULL)!=D3D_OK) {
 153           return 0;
 154   }
 155   void *pvertex=NULL;
 156   if (d3dvb->Lock(0,sizeof(osdvertices),&pvertex,0)!=D3D_OK) {
 157           return 0;
 158   }
 159   memcpy(pvertex,osdvertices,sizeof(osdvertices));
 160   d3dvb->Unlock();
 161   return 1;
 162 }
 163
 164 int OsdWin::shutdown()
 165 {
 166   if (!initted) return 0;
 167   initted = 0;
 168   d3drtsurf->Release();
 169   d3ddevice->Release();
 170   d3d->Release();
 171
 172   return 1;
 173 }
 174
 175 void OsdWin::screenShot(char* fileName)
 176 {
 177   screen->screenShot(fileName);
 178 }
 179
 180 // This function is called from the WinMain function in order to get Screen updates
 181 void OsdWin::Render()
 182 {
 183         if (!initted) return ;
 184         if (external_driving) {
 185                 Sleep(5); //Sleep for 5 ms, in order to avoid blocking the other threads
 186         } else {
 187                 DWORD time1=timeGetTime();
 188                 if ((time1-lastrendertime)>50) {//10 fps for OSD updates are enough, avoids tearing
 189                         InternalRendering(NULL);
 190                         lastrendertime=timeGetTime();
 191                 } else {
 192                         Sleep(5);
 193
 194                 }
 195
 196         }
 197 }
 198
 199 void OsdWin::RenderDS(LPDIRECT3DSURFACE9 present){
 200         if (!initted) return;
 201         if (external_driving) {
 202                 InternalRendering(present);
 203         }
 204 }
 205
 206
 207 void OsdWin::InternalRendering(LPDIRECT3DSURFACE9 present){
 208         WaitForSingleObject(event,INFINITE);
 209         WaitForSingleObject(d3dmutex,INFINITE);
 210         BeginPainting();
 211         if (external_driving) {
 212                 //Copy video to Backbuffer
 213                 if (present!=NULL) {
 214                         VideoWin* video =(VideoWin*) Video::getInstance();
 215                         /*calculating destination rect */
 216                         RECT destrect={0,0,video->getScreenWidth(),video->getScreenHeight()};
 217                         UCHAR mode=video->getMode();
 218                         switch (mode) {
 219                         case Video::EIGHTH:
 220                         destrect.right=destrect.right/2;
 221                         destrect.bottom=destrect.bottom/2;
 222                         case Video::QUARTER:
 223                         destrect.right=destrect.right/2+video->getPosx()*2;
 224                         destrect.bottom=destrect.bottom/2+video->getPosy()*2;
 225                         destrect.left=video->getPosx()*2;
 226                         destrect.top=video->getPosy()*2;
 227                         d3ddevice->Clear(0,NULL,D3DCLEAR_TARGET,D3DCOLOR_XRGB(0,0,0),1.0f,0);
 228                         break;
 229                         };
 230                         D3DSURFACE_DESC surf_desc;
 231                         present->GetDesc(&surf_desc);//for chop sides
 232                         RECT sourcerect= {0,0,surf_desc.Width,surf_desc.Height};
 233                         if (video->getPseudoTVsize()==Video::ASPECT4X3
 234                                 && video->getMode()==Video::NORMAL
 235                                 && video->getAspectRatio()==Video::ASPECT16X9) {
 236                                         unsigned int correction=((double) (surf_desc.Width))*4.*9./3./16.;
 237                                         sourcerect.left=(surf_desc.Width-correction)/2;
 238                                         sourcerect.right=sourcerect.left+correction;
 239                         }
 240                         d3ddevice->StretchRect(present,&sourcerect,d3drtsurf  ,&destrect,filter_type);
 241                 }
 242         } else {
 243                 VideoWin* video =(VideoWin*) Video::getInstance();
 244                 //Clear Background
 245                 if (!video->isVideoOn()) d3ddevice->Clear(0,NULL,D3DCLEAR_TARGET,D3DCOLOR_XRGB(0,0,0),1.0f,0);
 246         }
 247         //Drawing the OSD
 248         if (d3ddevice->BeginScene()==D3D_OK) {
 249                 d3ddevice->SetStreamSource(0,d3dvb,0,sizeof(OSDVERTEX));
 250                 d3ddevice->SetFVF(D3DFVF_OSDVERTEX);
 251                 d3ddevice->SetTexture(0,((SurfaceWin*)screen)->getD3dtexture());
 252                 //d3ddevice->SetTextureStageState(0,D3DTSS_COLOROP,D3DTOP_MODULATE);
 253                 d3ddevice->SetTextureStageState(0, D3DTSS_ALPHAOP,D3DTOP_MODULATE);
 254                 d3ddevice->SetRenderState(D3DRS_ALPHABLENDENABLE,TRUE);
 255                 d3ddevice->SetRenderState(D3DRS_DESTBLEND,D3DBLEND_INVSRCALPHA);
 256                 d3ddevice->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
 257                 d3ddevice->SetRenderState(D3DRS_LIGHTING,FALSE);
 258
 259
 260                 d3ddevice->DrawPrimitive(D3DPT_TRIANGLEFAN,0,2);
 261                 d3ddevice->EndScene();
 262                 //Show it to the user!
 263                 if (d3ddevice->Present(NULL,NULL,NULL,NULL)==D3DERR_DEVICELOST){
 264                         EndPainting();
 265                         DoLost();
 266                 }
 267                 EndPainting();
 268         }
 269         ReleaseMutex(d3dmutex);
 270         if (!external_driving) {
 271                 Sleep(4);//The User can wait for 4 milliseconds to see his changes
 272         }
 273 }
 274
 275 void OsdWin::DoLost(){
 276         Log::getInstance()->log("OSD", Log::WARN, "Direct3D Device Lost! Reobtaining...");
 277         ResetEvent(event);
 278         if (external_driving && dsallocator!=NULL) {
 279                 dsallocator->LostDevice(); //Propagate the information through DS
 280         }
 281         //First we free up all resources
 282         Video* video = Video::getInstance();
 283         ((SurfaceWin*)screen)->ReleaseSurface();
 284         d3drtsurf->Release();
 285         d3dvb->Release();
 286         d3dvb=NULL;
 287         D3DPRESENT_PARAMETERS d3dparas;
 288         ZeroMemory(&d3dparas,sizeof(d3dparas));
 289         d3dparas.BackBufferWidth=video->getScreenWidth();
 290         d3dparas.BackBufferHeight=video->getScreenHeight();
 291         d3dparas.Windowed=TRUE;
 292         d3dparas.SwapEffect=D3DSWAPEFFECT_COPY;
 293         if (d3ddevice->Reset(&d3dparas)!=D3D_OK){
 294                 return;
 295         }
 296         screen->create(video->getScreenWidth(), video->getScreenHeight());
 297         screen->display();
 298         d3ddevice->GetRenderTarget(0,&d3drtsurf);
 299         InitVertexBuffer();
 300         //Redraw Views, Chris could you add a member function to viewman, so that
 301         // I can cause it to completely redraw the Views?
 302         // Otherwise the OSD would be distorted after Device Lost
 303
 304         SetEvent(event);
 305
 306 }
 307 LPDIRECT3DDEVICE9 OsdWin::getD3dDev() {
 308         WaitForSingleObject(event,INFINITE);//We will only return if we are initted
 309         return d3ddevice;
 310 }
 311
 312 LPDIRECT3D9 OsdWin::getD3d() {
 313         WaitForSingleObject(event,INFINITE);//We will only return if we are initted
 314         return d3d;
 315 }
 316
 317 void OsdWin::BeginPainting() {//We synchronize calls to d3d between different threads
 318         WaitForSingleObject(d3dmutex,INFINITE);
 319 }
 320
 321 void OsdWin::EndPainting() {
 322         ReleaseMutex(d3dmutex);
 323 }
 324
 325 void OsdWin::setExternalDriving(DsAllocator* dsall) {
 326         if (dsall==NULL) {
 327                 external_driving=false;
 328                 dsallocator=NULL;
 329                 return;
 330         }
 331         WaitForSingleObject(event,INFINITE);//We will only return if we are initted
 332         dsallocator=dsall;
 333         external_driving=true;
 334 }
 335
 336 void OsdWin::Blank() {
 337         WaitForSingleObject(event,INFINITE);
 338         BeginPainting();
 339         d3ddevice->Clear(0,NULL,D3DCLEAR_TARGET,D3DCOLOR_XRGB(0,0,0),1.0f,0);
 340         EndPainting();
 341 }
 342