winamp/Src/nsv/nsvplay/vid_ddraw.cpp

#include "video.h"
#include <multimon.h>
#include "subtitles.h"

#define INIT_DIRECTDRAW_STRUCT(x) (ZeroMemory(&x, sizeof(x)), x.dwSize=sizeof(x))

DDrawVideoOutput::DDrawVideoOutput() {
  lpDD=NULL;
  lpddsOverlay=NULL;
  lastresizerect.bottom=0;
  lastresizerect.top=0;
  lastresizerect.left=0;
  lastresizerect.right=0;

  lpddsPrimary=NULL;
  lpddsClipper=NULL;
  lpddsSTTemp=NULL;
  is_fullscreen=0;
  m_parent=NULL;
  initing=false;
  needchange=0;
  m_palette=NULL;
  m_lastsubtitle=NULL;
  sttmp_w=sttmp_h=0;
  subFont=NULL;
  m_sub_needremeasure=0;
  m_fontsize=0;
  memset(&winRect,0,sizeof(winRect));
}

DDrawVideoOutput::~DDrawVideoOutput() {
//  LPDIRECTDRAWSURFACE o=lpddsOverlay;
  lpddsOverlay=NULL;
//  if(o) o->Release();
 // if (lpddsSTTemp) lpddsSTTemp->Release();
  //if(lpddsPrimary) lpddsPrimary->Release();
//  if(lpddsClipper) lpddsClipper->Release();
  if (lpDD) lpDD->Release();	// BU added NULL check in response to talkback
  if(subFont) DeleteObject(subFont);
  if (is_fullscreen) removeFullScreen();
}

void DDrawVideoOutput::drawSubtitle(SubsItem *item)
{
  m_lastsubtitle=item;
  m_sub_needremeasure=1;
}

int DDrawVideoOutput::create(VideoOutput *parent, int w, int h, unsigned int ptype, int flipit, double aspectratio) {
  m_lastsubtitle=NULL;
  type=ptype;
  width=w;
  height=h;
  flip=flipit;
  m_parent=parent;

  initing=true;
  HWND hwnd=parent->getHwnd();

  if (lpDD) lpDD->Release();
  lpDD=NULL;

  update_monitor_coords(parent);

  if(!m_found_devguid) DirectDrawCreate(NULL,&lpDD,NULL);
  else DirectDrawCreate(&m_devguid,&lpDD,NULL);

  if(!lpDD) {
    initing=false;
    return 0;
  }
  
  lpDD->SetCooperativeLevel(hwnd,DDSCL_NOWINDOWCHANGES|DDSCL_NORMAL);

  DDSURFACEDESC   ddsd;
  INIT_DIRECTDRAW_STRUCT(ddsd);
  ddsd.dwFlags = DDSD_CAPS;
  ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
  HRESULT ddrval = lpDD->CreateSurface(&ddsd, &lpddsPrimary, NULL );

  HRESULT v=-1;
  DDSURFACEDESC DDsd={sizeof(DDsd),};
  lpddsPrimary->GetSurfaceDesc(&ddsd);
  DDsd.dwFlags = DDSD_CAPS|DDSD_WIDTH|DDSD_HEIGHT; //create the surface at screen depth
	DDsd.dwWidth=w;
	DDsd.dwHeight=h;
	DDsd.ddsCaps.dwCaps = DDSCAPS_VIDEOMEMORY;
	if (parent->vid_ddraw) v=lpDD->CreateSurface(&DDsd, &lpddsOverlay, NULL);
  if(!parent->vid_ddraw || FAILED(v)) {
    // fall back to system memory if video mem doesn't work
    DDsd.ddsCaps.dwCaps = DDSCAPS_SYSTEMMEMORY;
  	v=lpDD->CreateSurface(&DDsd, &lpddsOverlay, NULL);
  }
  if(FAILED(v)) {
    // this video card sucks then :)
    lpddsOverlay=NULL;
    initing=false;
    return 0;
  }

  // get the depth
  m_depth=8;
  INIT_DIRECTDRAW_STRUCT(m_ddpf);
  if(lpddsOverlay->GetPixelFormat(&m_ddpf)>=0) {
    m_depth=m_ddpf.dwRGBBitCount;
    if (m_depth==16 && m_ddpf.dwGBitMask==0x03e0) m_depth=15;
  }

  lpDD->CreateClipper(0,&lpddsClipper,NULL);
  lpddsClipper->SetHWnd(0,hwnd);
  lpddsPrimary->SetClipper(lpddsClipper);
  initing=false;
  return 1;
}

int DDrawVideoOutput::onPaint(HWND hwnd, HDC hdc) {
  return 0;
}

void DDrawVideoOutput::displayFrame(const char *buf, int size, int time) {
  DDSURFACEDESC dd={sizeof(dd),};
  if (m_parent->vid_vsync) lpDD->WaitForVerticalBlank(DDWAITVB_BLOCKBEGIN,0);
  HRESULT result;
  if ((result=lpddsOverlay->Lock(NULL,&dd,DDLOCK_WAIT,NULL)) != DD_OK) {
    needchange=1;
    return;
  }
  if(type==NSV_MAKETYPE('Y','V','1','2')) {
    const YV12_PLANES *planes=(YV12_PLANES *)buf;
    // convert yv12 to rgb
    int bytes = m_depth >> 3; 
    if(m_depth==15) bytes=2;
    int i, j, y00, y01, y10, y11, u, v;
	  unsigned char *pY = (unsigned char *)planes->y.baseAddr;
    unsigned char *pU = (unsigned char *)planes->u.baseAddr;
	  unsigned char *pV = (unsigned char *)planes->v.baseAddr;
	  unsigned char *pOut = (unsigned char*)dd.lpSurface;
   	const int rvScale = 91881;
    const int guScale = -22553;
    const int gvScale = -46801;
    const int buScale = 116129;
    const int yScale  = 65536;
    int addOut=dd.lPitch*2-width*bytes;
    int yrb=planes->y.rowBytes;
    int addL=dd.lPitch;

    /* LIMIT: convert a 16.16 fixed-point value to a byte, with clipping. */
    #define LIMIT(x) ((x)>0xffffff?0xff: ((x)<=0xffff?0:((x)>>16)))

    if(flip) {
      pOut+=(dd.lPitch)*(height-1);
      addOut=-dd.lPitch*2 - width*bytes;
      addL=-addL;
    }

    for (j = 0; j <= height - 2; j += 2) {
      for (i = 0; i <= width - 2; i += 2) {
			  y00 = *pY;
			  y01 = *(pY + 1);
			  y10 = *(pY + yrb);
			  y11 = *(pY + yrb + 1);
			  u = (*pU++) - 128;
			  v = (*pV++) - 128;

        {
      	  int r, g, b;

	        g = guScale * v + gvScale * u;
    		  r = buScale * v;
    		  b = rvScale * u;

	        y00 *= yScale; y01 *= yScale;
	        y10 *= yScale; y11 *= yScale;

          switch(m_depth) {
          case 15:
            {
              unsigned short *rgb=(unsigned short *)pOut;
              rgb[0]=((LIMIT(r+y00)>>3)<<10)|((LIMIT(g+y00)>>3)<<5)|(LIMIT(b+y00)>>3);
              rgb[1]=((LIMIT(r+y01)>>3)<<10)|((LIMIT(g+y01)>>3)<<5)|(LIMIT(b+y01)>>3);
              rgb+=addL/2;
              rgb[0]=((LIMIT(r+y10)>>3)<<10)|((LIMIT(g+y10)>>3)<<5)|(LIMIT(b+y10)>>3);
              rgb[1]=((LIMIT(r+y11)>>3)<<10)|((LIMIT(g+y11)>>3)<<5)|(LIMIT(b+y11)>>3);
            }
            break;
          case 16:
            {
              unsigned short *rgb=(unsigned short *)pOut;
              rgb[0]=((LIMIT(r+y00)>>3)<<11)|((LIMIT(g+y00)>>2)<<5)|(LIMIT(b+y00)>>3);
              rgb[1]=((LIMIT(r+y01)>>3)<<11)|((LIMIT(g+y01)>>2)<<5)|(LIMIT(b+y01)>>3);
              rgb+=addL/2;
              rgb[0]=((LIMIT(r+y10)>>3)<<11)|((LIMIT(g+y10)>>2)<<5)|(LIMIT(b+y10)>>3);
              rgb[1]=((LIMIT(r+y11)>>3)<<11)|((LIMIT(g+y11)>>2)<<5)|(LIMIT(b+y11)>>3);
            }
            break;
          case 24:
            {
              unsigned char *rgb=pOut;
              /* Write out top two pixels */
		          rgb[0] = LIMIT(b+y00); rgb[1] = LIMIT(g+y00); rgb[2] = LIMIT(r+y00);
		          rgb[3] = LIMIT(b+y01); rgb[4] = LIMIT(g+y01); rgb[5] = LIMIT(r+y01);

		          /* Skip down to next line to write out bottom two pixels */
		          rgb += addL;
		          rgb[0] = LIMIT(b+y10); rgb[1] = LIMIT(g+y10); rgb[2] = LIMIT(r+y10);
              rgb[3] = LIMIT(b+y11); rgb[4] = LIMIT(g+y11); rgb[5] = LIMIT(r+y11);
            }
            break;
          case 32:
            {
              unsigned char *rgb=pOut;
              /* Write out top two pixels */
		          rgb[0] = LIMIT(b+y00); rgb[1] = LIMIT(g+y00); rgb[2] = LIMIT(r+y00);
		          rgb[4] = LIMIT(b+y01); rgb[5] = LIMIT(g+y01); rgb[6] = LIMIT(r+y01);

		          /* Skip down to next line to write out bottom two pixels */
		          rgb += addL;
		          rgb[0] = LIMIT(b+y10); rgb[1] = LIMIT(g+y10); rgb[2] = LIMIT(r+y10);
              rgb[4] = LIMIT(b+y11); rgb[5] = LIMIT(g+y11); rgb[6] = LIMIT(r+y11);
            }
            break;
          }
        }
	
			  pY += 2;
			  pOut += 2 * bytes;
      }
		  pY += yrb+yrb-width;
		  pU += planes->u.rowBytes-width/2;
		  pV += planes->v.rowBytes-width/2;
		  pOut += addOut;
	  }
  } else if(type==NSV_MAKETYPE('R','G','3','2')) {
    //FUCKO: do we need to support 8bits depth?
    switch(m_depth) {
    case 15: 
      { // convert RGB32 -> RGB16 (555)
        const char *a=buf;
        char *b=(char *)dd.lpSurface;
        int l=width*4,l2=dd.lPitch;
        int ladj=l;
        if (flip) { a+=l*(height-1); ladj=-ladj; }
        for(int i=0;i<height;i++) {
          short *dest=(short *)b;
          int *src=(int *)a;
          for(int j=0;j<width;j++) {
            int c=*(src++);
            int r=c>>16;
            int g=(c>>8) & 0xff;
            int b=(c) & 0xff;
            *(dest++)=((r>>3)<<10)|((g>>3)<<5)|(b>>3);
          }
          a+=ladj; b+=l2;
        }
      }
      break;
    case 16:
      { // convert RGB32 -> RGB16
        //FUCKO: this assumes 565
        const char *a=buf;
        char *b=(char *)dd.lpSurface;
        int l=width*4,l2=dd.lPitch;
        int ladj=l;
        if (flip) { a+=l*(height-1); ladj=-ladj; }
        for(int i=0;i<height;i++) {
          short *dest=(short *)b;
          int *src=(int *)a;
          for(int j=0;j<width;j++) {
            //FUCKO: optimize here
            int c=*(src++);
            int r=c>>16;
            int g=(c>>8) & 0xff;
            int b=(c) & 0xff;
            *(dest++)=((r>>3)<<11)|((g>>2)<<5)|(b>>3);
          }
          a+=ladj; b+=l2;
        }
      }
      break;
    case 24:
      { // convert RGB32 -> RGB24
        const char *a=buf;
        char *b=(char *)dd.lpSurface;
        int l=width*4,l2=dd.lPitch;
        int ladj=l;
        if (flip) { a+=l*(height-1); ladj=-ladj; }
        for(int i=0;i<height;i++) {
          char *dest=(char *)b;
          int *src=(int *)a;
          for(int j=0;j<width;j++) {
            //FUCKO: optimize here
            int c=*(src++);
            int r=c>>16;
            int g=(c>>8) & 0xff;
            int b=(c) & 0xff;
            *dest++=b;
            *dest++=g;
            *dest++=r;
          }
          a+=ladj; b+=l2;
        }
      }
      break;
    case 32:
      { // straight RGB32 copy
        const char *a=buf;
        char *b=(char *)dd.lpSurface;
        int l=width*4,l2=dd.lPitch;
        int ladj=l;
        if (flip) { a+=l*(height-1); ladj=-ladj; }
        for(int i=0;i<height;i++) {
          memcpy(b,a,l);
          a+=ladj; b+=l2;
        }
      }
      break;
    }
  } else if(type==NSV_MAKETYPE('Y','U','Y','2') || type==NSV_MAKETYPE('U','Y','V','Y')) {
    const char *a=buf;
    char *b=(char *)dd.lpSurface;
    int l=width*2,l2=dd.lPitch;
    if(flip) {
      b+=(height-1)*l2;
      l2=-l2;
    }
    switch(m_depth) {
    case 15:
      {
        // yuy2->rgb16 (555) conversion
        unsigned char *src=(unsigned char *)buf;
        unsigned short *dst=(unsigned short *)dd.lpSurface;
  	    int line, col;//, linewidth;
        int y, yy;
        int u, v;
        int vr, ug, vg, ub;
        unsigned char *py, *pu, *pv;

        //linewidth = width - (width >> 1);
        py = src;
        pu = src + 1;
        pv = src + 3;

        int pitchadd=dd.lPitch/2-width;

        for (line = 0; line < height; line++) {
 		      for (col = 0; col < width; col++) {
            #undef LIMIT
            #define LIMIT(x)  ( (x) > 0xffff ? 0xff : ( (x) <= 0xff ? 0 : ( (x) >> 8 ) ) )

 		        y = *py;
	          yy = y << 8;
	          u = *pu - 128;
	          ug =   88 * u;
	          ub =  454 * u;
	          v = *pv - 128;
	          vg =  183 * v;
	          vr =  359 * v;
                
            unsigned char b=LIMIT(yy + ub     );
            unsigned char g=LIMIT(yy - ug - vg);
            unsigned char r=LIMIT(yy +      vr);
            *(dst++)=((r>>3)<<10)|((g>>3)<<5)|(b>>3);
    
            py += 2;
			      if ( (col & 1) == 1) {
    			    pu += 4; // skip yvy every second y
			        pv += 4; // skip yuy every second y
			      }
          } // ..for col 
          dst+=pitchadd;
        } /* ..for line */          
      }
      break;
    case 16:
      {
        // yuy2->rgb16 conversion
        //FUCKO: only supports 565
        unsigned char *src=(unsigned char *)buf;
        unsigned short *dst=(unsigned short *)dd.lpSurface;
  	    int line, col;//, linewidth;
        int y, yy;
	      int u, v;
        int vr, ug, vg, ub;
        unsigned char *py, *pu, *pv;

        //linewidth = width - (width >> 1);
        py = src;
        pu = src + 1;
        pv = src + 3;

        int pitchadd=dd.lPitch/2-width;

        for (line = 0; line < height; line++) {
 		      for (col = 0; col < width; col++) {
            #undef LIMIT
            #define LIMIT(x)  ( (x) > 0xffff ? 0xff : ( (x) <= 0xff ? 0 : ( (x) >> 8 ) ) )

		        y = *py;
	          yy = y << 8;
	          u = *pu - 128;
	          ug =   88 * u;
	          ub =  454 * u;
	          v = *pv - 128;
	          vg =  183 * v;
	          vr =  359 * v;
                
            unsigned char b=LIMIT(yy + ub     );
            unsigned char g=LIMIT(yy - ug - vg);
            unsigned char r=LIMIT(yy +      vr);
            *(dst++)=((r>>3)<<11)|((g>>2)<<5)|(b>>3);
    
            py += 2;
			      if ( (col & 1) ) {
    			    pu += 4; // skip yvy every second y
			        pv += 4; // skip yuy every second y
			      }
		      } // ..for col 
          dst+=pitchadd;
	      } /* ..for line */          }
      break;
    case 24:
      {
        // yuy2->rgb24 conversion
        unsigned char *src=(unsigned char *)buf;
        unsigned char *dst=(unsigned char *)dd.lpSurface;
  	    int line, col;//, linewidth;
        int y, yy;
        int u, v;
        int vr, ug, vg, ub;
        unsigned char *py, *pu, *pv;

        //linewidth = width - (width >> 1);
        py = src;
        pu = src + 1;
        pv = src + 3;

        int pitchadd=dd.lPitch-(width*3);

        for (line = 0; line < height; line++) {
 		      for (col = 0; col < width; col++) {
            #undef LIMIT
            #define LIMIT(x)  ( (x) > 0xffff ? 0xff : ( (x) <= 0xff ? 0 : ( (x) >> 8 ) ) )

		        y = *py;
	          yy = y << 8;
	          u = *pu - 128;
	          ug =   88 * u;
	          ub =  454 * u;
	          v = *pv - 128;
	          vg =  183 * v;
	          vr =  359 * v;
                
            *(dst++)=LIMIT(yy + ub     );
            *(dst++)=LIMIT(yy - ug - vg);
            *(dst++)=LIMIT(yy +      vr);
    
	          py += 2;
            if ( (col & 1) == 1) {
    			    pu += 4; // skip yvy every second y
			        pv += 4; // skip yuy every second y
			      }
		      } // ..for col 
          dst+=pitchadd;
	      } /* ..for line */          }
      break;
    case 32:
      {
        // yuy2->rgb32 conversion
        unsigned char *src=(unsigned char *)buf;
        unsigned char *dst=(unsigned char *)dd.lpSurface;
   	    int line, col;//, linewidth;
        int y, yy;
        int u, v;
        int vr, ug, vg, ub;
        unsigned char *py, *pu, *pv;

        //linewidth = width - (width >> 1);
        py = src;
        pu = src + 1;
        pv = src + 3;

        int pitchadd=dd.lPitch-(width*4);

        for (line = 0; line < height; line++) {
 		      for (col = 0; col < width; col++) {
            #undef LIMIT
            #define LIMIT(x)  ( (x) > 0xffff ? 0xff : ( (x) <= 0xff ? 0 : ( (x) >> 8 ) ) )

 		        y = *py;
	          yy = y << 8;
	          u = *pu - 128;
	          ug =   88 * u;
	          ub =  454 * u;
	          v = *pv - 128;
	          vg =  183 * v;
	          vr =  359 * v;
                
		        *dst++ = LIMIT(yy + ub     ); // b
	          *dst++ = LIMIT(yy - ug - vg); // g
	          *dst++ = LIMIT(yy +      vr); // r
            dst++;
 
            py += 2;
			      if ( (col & 1) == 1) {
    			    pu += 4; // skip yvy every second y
			        pv += 4; // skip yuy every second y
			      }
		      } // ..for col 
          dst+=pitchadd;
	      } /* ..for line */
      }
      break;
    }
  } else if(type==NSV_MAKETYPE('R','G','2','4')) {
    //FUCKO: only ->RGB32 conversion supported
    switch(m_depth) {
    case 32:
    {
      const char *a=buf;
      char *b=(char *)dd.lpSurface;
      int l=width,l2=dd.lPitch;
      int ladj=l*3;
      if (flip) { a+=(l*3)*(height-1); ladj=-(ladj+l*3); }
      l2-=l*4;
      for(int i=0;i<height;i++) {
        //memcpy(b,a,l);
        for(int j=0;j<l;j++) {
          b[0]=a[0];
          b[1]=a[1];
          b[2]=a[2];
          b+=4; a+=3;
        }
        a+=ladj; b+=l2;
      }
    }
    break;
    }
  } else if(type==NSV_MAKETYPE('R','G','B','8') && m_palette) {
    unsigned char *d=(unsigned char *)dd.lpSurface;
    int pitch=dd.lPitch;
    unsigned char *src=(unsigned char *)buf;
    int newwidth=(width+3)&0xfffc;
    src+=newwidth*height-1;
    for(int j=0;j<height;j++) {
      switch(m_depth) {
      case 15:
      case 16:
        {
          unsigned short *dest=(unsigned short *)d;
          for(int i=0;i<newwidth;i++) {
            unsigned char c=src[-newwidth+1+i];
            RGBQUAD *rgb=&m_palette[c];
            switch(m_depth) {
              case 15: *(dest++)=((rgb->rgbRed>>3)<<10)|((rgb->rgbGreen>>3)<<5)|(rgb->rgbBlue>>3); break;
              case 16: *(dest++)=((rgb->rgbRed>>3)<<11)|((rgb->rgbGreen>>2)<<5)|(rgb->rgbBlue>>3); break;
            }
          }
        }
        break;
      case 24:
      case 32:
        {
          unsigned char *dest=d;
          for(int i=0;i<newwidth;i++) {
            unsigned char c=src[-newwidth+1+i];
            RGBQUAD *rgb=&m_palette[c];
            *dest++=rgb->rgbBlue;
            *dest++=rgb->rgbGreen;
            *dest++=rgb->rgbRed;
            if(m_depth==32) dest++;
          }
        }
        break;
      }
      d+=pitch;
      src-=newwidth;
    }
  }

  lpddsOverlay->Unlock(&dd);


  RECT r;
  HWND hwnd=m_parent->getHwnd();
  if (!IsWindow(hwnd)) return;

  if(GetParent(hwnd)) hwnd=GetParent(hwnd);

  GetClientRect(hwnd,&r);
  RECT fullr=r;
  m_parent->adjustAspect(r);
  if (r.left != lastresizerect.left || r.right != lastresizerect.right || r.top != lastresizerect.top || 
        r.bottom != lastresizerect.bottom)
  {
    if (r.left != 0)
    {
      RECT tmp={0,0,r.left,fullr.bottom};
      InvalidateRect(hwnd,&tmp,TRUE); 
    }
    
    if (r.right != fullr.right) 
    {
      RECT tmp={r.right,0,fullr.right,fullr.bottom};
      InvalidateRect(hwnd,&tmp,TRUE); 
    }
    if (r.top != 0) 
    {
      RECT tmp={r.left,0,r.right,r.top};
      InvalidateRect(hwnd,&tmp,TRUE); 
    }
    if (r.bottom != fullr.bottom) 
    {
      RECT tmp={r.left,r.bottom,r.right,fullr.bottom};
      InvalidateRect(hwnd,&tmp,TRUE); 
    }

    lastresizerect=r;
  }

  ClientToScreen(hwnd,(LPPOINT)&r);
  ClientToScreen(hwnd,((LPPOINT)&r) + 1);

  // transform coords from windows desktop coords (where 0,0==upper-left corner of box encompassing all monitors)
  // to the coords for the monitor we're displaying on:
  r.left-=m_mon_x;
  r.right-=m_mon_x;
  r.top-=m_mon_y;
  r.bottom-=m_mon_y;

  HDC hdc = NULL;
  HDC inhdc = NULL;

  RECT srcrect;
  RECT *pSrcRect = NULL;

  if (m_parent->osdShowing() && m_parent->osdReady())
  {
    // squish image upward to make room for the OSD.
    int vert_margin = ((fullr.bottom-fullr.top) - (r.bottom-r.top)) / 2;
    int pixels_to_clip = max(0, m_parent->getOSDbarHeight() - vert_margin);

    // adjust source rectangle:
    int src_y0 = (int)(height*pixels_to_clip/(float)(r.bottom-r.top) + 0.5f);
    int src_y1 = height - src_y0;
    SetRect(&srcrect, 0, SHOW_STREAM_TITLE_AT_TOP ? src_y0 : 0, width, src_y1);
    pSrcRect = &srcrect;

    // adjust destination rectangle:
    r.bottom -= pixels_to_clip;
#if (SHOW_STREAM_TITLE_AT_TOP)
    r.top += pixels_to_clip;
#endif
  }

  int needst=0;


  SubsItem *mlst=m_lastsubtitle;
  if (mlst)
  { 
    int curw=r.right-r.left, curh=r.bottom-r.top;
    if (!lpddsSTTemp || sttmp_w != curw || sttmp_h != curh)
    {
      if (lpddsSTTemp) lpddsSTTemp->Release();
      lpddsSTTemp=0;

      HRESULT v=-1;
      DDSURFACEDESC DDsd={sizeof(DDsd),};
      DDSURFACEDESC   ddsd;
      INIT_DIRECTDRAW_STRUCT(ddsd);
      ddsd.dwFlags = DDSD_CAPS;
      ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
      lpddsPrimary->GetSurfaceDesc(&ddsd);
      DDsd.dwFlags = DDSD_CAPS|DDSD_WIDTH|DDSD_HEIGHT; //create the surface at screen depth
	    DDsd.dwWidth=sttmp_w=curw;
	    DDsd.dwHeight=sttmp_h=curh;
	    DDsd.ddsCaps.dwCaps = DDSCAPS_VIDEOMEMORY;
	    if (m_parent->vid_ddraw) v=lpDD->CreateSurface(&DDsd, &lpddsSTTemp, NULL);
      if (!m_parent->vid_ddraw || FAILED(v)) {
        // fall back to system memory if video mem doesn't work
        DDsd.ddsCaps.dwCaps = DDSCAPS_SYSTEMMEMORY;
  	    v=lpDD->CreateSurface(&DDsd, &lpddsSTTemp, NULL);
      }
      m_sub_needremeasure=1;
    }
    if (lpddsSTTemp) needst=1;
  }

  if (needst)
  {
    HDC tmpdc=NULL;
    if (!m_parent->vid_ddraw || lpddsSTTemp->Blt(NULL,lpddsOverlay,NULL,DDBLT_WAIT,0) != DD_OK) {
      // as a last resort, BitBlt().
      HDC tmpdc2;
      if (lpddsOverlay->GetDC(&tmpdc2)==DD_OK) {
        if (lpddsSTTemp->GetDC(&tmpdc)==DD_OK) {
          BitBlt(tmpdc,0,0,sttmp_w,sttmp_h,tmpdc2,0,0,SRCCOPY);
        }
      }
    }

    if (tmpdc||lpddsSTTemp->GetDC(&tmpdc)==DD_OK)
    {
      int m_lastsubxp=mlst->xPos;
      int m_lastsubyp=mlst->yPos;

      RECT oldwinRect=winRect;
      GetClientRect(hwnd,&winRect);
      if(!subFont || ((winRect.bottom-winRect.top)!=(oldwinRect.bottom-oldwinRect.top)) || m_fontsize!=mlst->fontSize) {
        if(subFont) DeleteObject(subFont);
        m_fontsize=mlst->fontSize;
        subFont=CreateFont(14+m_fontsize+18*(winRect.bottom-winRect.top)/768,0,0,0,FW_SEMIBOLD,FALSE,FALSE,FALSE,ANSI_CHARSET,OUT_OUTLINE_PRECIS,CLIP_DEFAULT_PRECIS,ANTIALIASED_QUALITY,DEFAULT_PITCH|FF_DONTCARE,"Arial");
      }

      HWND hwnd=m_parent->getHwnd();
      HGDIOBJ oldobj=SelectObject(tmpdc,subFont);

      int centerflags=0;
      if (m_lastsubxp < 127) centerflags |= DT_LEFT;
      else if (m_lastsubxp > 127) centerflags |= DT_RIGHT;
      else centerflags |= DT_CENTER;

      if (m_lastsubyp < 127) centerflags |= DT_TOP;
      else if (m_lastsubyp > 127) centerflags |= DT_BOTTOM;

      if (m_sub_needremeasure)
      {
        subRect=r;
        subRect.bottom-=subRect.top;
        subRect.right -=subRect.left;
        subRect.top=subRect.left=0;

        SIZE s;
        GetTextExtentPoint32(tmpdc,mlst->text,strlen(mlst->text),&s);

        // calcul for multiline text
          const char *p=mlst->text;
          int n=0;
          while(*p!=0) if(*p++=='\n') n++;
          if(n) s.cy*=(n+1);
 
        if (m_lastsubxp > 127) // towards the right
        {
          subRect.right -= ((subRect.right-subRect.left) * (255-m_lastsubxp)) / 256;
        }
        else if (m_lastsubxp < 127)
        {
          subRect.left += ((subRect.right-subRect.left) * m_lastsubxp) / 256;
        }

        subRect.top += ((subRect.bottom-s.cy-subRect.top) * m_lastsubyp)/255;

        subRect.bottom=subRect.top + s.cy;  
      }
  
      SetBkMode(tmpdc,TRANSPARENT);
  
      // draw outline
      SetTextColor(tmpdc,RGB(0,0,0));
      int y=1;
      int x=1;
      RECT r2={subRect.left+x,subRect.top+y,subRect.right+x,subRect.bottom+y};
      DrawText(tmpdc,mlst->text,-1,&r2,centerflags|DT_NOCLIP|DT_NOPREFIX);
      // draw text
      SetTextColor(tmpdc,RGB(mlst->colorRed,mlst->colorGreen,mlst->colorBlue));
      DrawText(tmpdc,mlst->text,-1,&subRect,centerflags|DT_NOCLIP|DT_NOPREFIX);
      SelectObject(tmpdc,oldobj);
      lpddsSTTemp->ReleaseDC(tmpdc);
    }
    if (!m_parent->vid_ddraw || lpddsPrimary->Blt(&r,lpddsSTTemp,pSrcRect,DDBLT_WAIT,0) != DD_OK) {
      // as a last resort, BitBlt().
      if (lpddsSTTemp->GetDC(&inhdc)==DD_OK) {
        if (lpddsPrimary->GetDC(&hdc)==DD_OK) {
          int src_w = width;
          int src_h = pSrcRect ? (pSrcRect->bottom - pSrcRect->top) : height;
          if (r.right-r.left == src_w && r.bottom-r.top == src_h) 
            BitBlt(hdc,r.left,r.top,r.right-r.left,r.bottom-r.top,inhdc,0,0,SRCCOPY);
          else 
            StretchBlt(hdc,r.left,r.top,r.right-r.left,r.bottom-r.top,inhdc,0,0,src_w,src_h,SRCCOPY);
        }
      }
    }
  }
  else
  {
    if (!m_parent->vid_ddraw || lpddsPrimary->Blt(&r,lpddsOverlay,pSrcRect,DDBLT_WAIT,0) != DD_OK) {
      // as a last resort, BitBlt().
      if (lpddsOverlay->GetDC(&inhdc)==DD_OK) {
        if (lpddsPrimary->GetDC(&hdc)==DD_OK) {
          int src_w = width;
          int src_h = pSrcRect ? (pSrcRect->bottom - pSrcRect->top) : height;
          if (r.right-r.left == src_w && r.bottom-r.top == src_h) 
            BitBlt(hdc,r.left,r.top,r.right-r.left,r.bottom-r.top,inhdc,0,0,SRCCOPY);
          else 
            StretchBlt(hdc,r.left,r.top,r.right-r.left,r.bottom-r.top,inhdc,0,0,src_w,src_h,SRCCOPY);
        }
      }
    }
  }

#if 0 //faster style
  if (m_parent->osdShowing())
  {
    if (hdc || lpddsPrimary->GetDC(&hdc)==DD_OK)
      m_parent->drawOSD(hdc, &r);
  }
#endif

  if (hdc) { lpddsPrimary->ReleaseDC(hdc); hdc = NULL; }
  if (inhdc) { lpddsOverlay->ReleaseDC(inhdc); inhdc = NULL; }

#if 1 // safer style
  if (m_parent->osdShowing())
  {
    HWND h=m_parent->getHwnd();
    hdc=GetDC(h);
    m_parent->drawOSD(hdc, &r);
    ReleaseDC(h,hdc);
  }
#endif
}

void DDrawVideoOutput::goFullScreen() {
}

void DDrawVideoOutput::removeFullScreen() {
}

void DDrawVideoOutput::timerCallback() {
}

int DDrawVideoOutput::showOSD() { 
  return 1;
}

void DDrawVideoOutput::hideOSD() { 
  // repaint the client area, to black, where there is no video
  // (otherwise the OSD might be left painted there)

  RECT r;
  HWND hwnd=m_parent->getHwnd();
  if(GetParent(hwnd)) hwnd=GetParent(hwnd);
  GetClientRect(hwnd,&r);

  HDC hdc = GetDC(hwnd);
  if (hdc) {
    HGDIOBJ oldobj1=SelectObject(hdc,CreateSolidBrush(RGB(0,0,0)));
    HGDIOBJ oldobj2=SelectObject(hdc,CreatePen(PS_SOLID,0,RGB(0,0,0)));
    int margin = ((r.bottom - r.top) - (lastresizerect.bottom - lastresizerect.top) + 1) / 2;
    Rectangle(hdc,r.left,r.top,r.right,r.top + margin);
    Rectangle(hdc,r.left,r.bottom - margin,r.right,r.bottom);
    margin = ((r.right - r.left) - (lastresizerect.right - lastresizerect.left) + 1) / 2;
    Rectangle(hdc,r.left,r.top,r.left + margin,r.bottom);
    Rectangle(hdc,r.right - margin,r.top,r.right,r.bottom);
    DeleteObject(SelectObject(hdc,oldobj2));
    DeleteObject(SelectObject(hdc,oldobj1));
    
    ReleaseDC(hwnd, hdc);
  }
}

void DDrawVideoOutput::resetSubtitle()
{
  m_lastsubtitle=0;
}