videorendereroverlay.cpp

<VC++视频音频开发>一书的光盘资料。

/**************************************************************************************
 *                                                                                    *
 *                                                                                    *
 **************************************************************************************/

#include "VideoRendererOverlay.h"

DDPIXELFORMAT ddpfOverlayFormats[] = 
{   
	{sizeof(DDPIXELFORMAT), DDPF_FOURCC,MAKEFOURCC('Y','U','Y','2'),0,0,0,0,0},  // YUY2
	{sizeof(DDPIXELFORMAT), DDPF_FOURCC,MAKEFOURCC('U','Y','V','Y'),0,0,0,0,0},  // UYVY
};

media_video_mode_t videoModes[] = 
{
	VIDEO_MODE_YUY2,
	VIDEO_MODE_UYVY,
};




MediaVideoRendererOverlay::MediaVideoRendererOverlay()
{
	this->subtitler    = NULL;
	
	this->lpdd         = NULL;
	this->lpddsPrimary = NULL;
	this->lpddsOverlay = NULL;

	this->videoMode    = VIDEO_MODE_NONE;
}

MediaVideoRendererOverlay::~MediaVideoRendererOverlay()
{
}



media_type_t MediaVideoRendererOverlay::GetType()
{
	return MEDIA_TYPE_VIDEO_RENDERER;
}

char *MediaVideoRendererOverlay::GetName()
{
	return "Overlay Video Renderer";
}

MP_RESULT MediaVideoRendererOverlay::Connect(MediaItem *item)
{


	if(item && item->GetType() == MEDIA_TYPE_SUBTITLER) {


		this->subtitler = (MediaItemSubtitler *) item;

		return MP_RESULT_OK;
	}

	return MP_RESULT_ERROR;
}

MP_RESULT MediaVideoRendererOverlay::ReleaseConnections()
{


	this->subtitler   = NULL;

	return MP_RESULT_OK;
}


DWORD         MediaVideoRendererOverlay::GetCaps()
{
	return 0;
}

MP_RESULT     MediaVideoRendererOverlay::Configure(HINSTANCE hInstance, HWND hwnd)
{
	return MP_RESULT_ERROR;
}



BOOL MediaVideoRendererOverlay::AreOverlaysSupported()
{

    DDCAPS  capsDrv;
    HRESULT ddrval;
	


    ZeroMemory(&capsDrv, sizeof(capsDrv));
    capsDrv.dwSize = sizeof(capsDrv);
 
    ddrval = this->lpdd->GetCaps(&capsDrv, NULL);
    
	if (FAILED(ddrval))
        return FALSE;
 


    if (!(capsDrv.dwCaps & DDCAPS_OVERLAY))
        return FALSE;
	
    return TRUE;
}


MP_RESULT MediaVideoRendererOverlay::Init(HWND hwnd, unsigned int width, unsigned int height)
{
	if(hwnd && width > 0 && height > 0) {
	
		HRESULT         ddrval;
	    DDSURFACEDESC2  ddsd;
	    DDSURFACEDESC2  ddsdOverlay;
		DWORD           i;
    
		this->invertFlag  = FALSE;

		ddrval = DirectDrawCreateEx(NULL, (VOID**)&this->lpdd, IID_IDirectDraw7, NULL);
		
		if( FAILED(ddrval))
			return MP_RESULT_ERROR;
    
		/*
		 * 检查是否支持叠加
		 */

		if(!this->AreOverlaysSupported()) {

	        this->lpdd->Release();
			this->lpdd=NULL;
			return MP_RESULT_ERROR;
		}


		ddrval = this->lpdd->SetCooperativeLevel(NULL, DDSCL_NORMAL);
		
		if( FAILED(ddrval)) {

	        this->lpdd->Release();
			this->lpdd=NULL;
			return MP_RESULT_ERROR;
		}


   
	    ZeroMemory(&ddsd, sizeof(DDSURFACEDESC2));
		
		ddsd.dwSize  = sizeof(DDSURFACEDESC2);
		ddsd.dwFlags = DDSD_CAPS;
		ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
    
		ddrval = this->lpdd->CreateSurface(&ddsd, &this->lpddsPrimary, NULL );

		if(FAILED(ddrval)) {

			this->lpdd->Release();
		    this->lpdd=NULL;
			return MP_RESULT_ERROR;
		}



	    ddrval = this->lpdd->CreateClipper(0, &this->lpddClipper, NULL);

		if(FAILED(ddrval)) {

			return MP_RESULT_ERROR;
		}
	
	    ddrval = this->lpddClipper->SetHWnd(0, hwnd);

		if(FAILED(ddrval)) {

			return MP_RESULT_ERROR;
		}
	
	    ddrval = this->lpddsPrimary->SetClipper(this->lpddClipper);


    
	    ZeroMemory(&ddsdOverlay, sizeof(DDSURFACEDESC2));

		ddsdOverlay.dwSize  = sizeof(DDSURFACEDESC2);

	    ddsdOverlay.ddsCaps.dwCaps = DDSCAPS_OVERLAY | DDSCAPS_VIDEOMEMORY;
		ddsdOverlay.dwFlags= DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT;
		
		ddsdOverlay.dwWidth           = width;
		ddsdOverlay.dwHeight          = height;
    
	    i = 0;
    
		do {
	
			ddsdOverlay.ddpfPixelFormat = ddpfOverlayFormats[i];
			this->videoMode = videoModes[i];

  			ddrval = this->lpdd->CreateSurface(&ddsdOverlay, &this->lpddsOverlay, NULL);
		
		} while( FAILED(ddrval) && (++i < 2) );



		if(FAILED(ddrval)) {

		    ZeroMemory(&ddsdOverlay, sizeof(DDSURFACEDESC2));
			ddsdOverlay.dwSize     = sizeof(DDSURFACEDESC2);
			
			ddsdOverlay.dwWidth           = width;
			ddsdOverlay.dwHeight          = height;
	        ddsdOverlay.dwBackBufferCount = 0;
			
			ddsdOverlay.ddsCaps.dwCaps    = DDSCAPS_OVERLAY | DDSCAPS_VIDEOMEMORY;
			ddsdOverlay.dwFlags           = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT;
        

		    i = 0;
    
			do {
	
				ddsdOverlay.ddpfPixelFormat = ddpfOverlayFormats[i];
				this->videoMode = videoModes[i];

	 			ddrval = this->lpdd->CreateSurface(&ddsdOverlay, &this->lpddsOverlay, NULL);
		
			} while( FAILED(ddrval) && (++i < 2) );
        
			if (FAILED(ddrval)) {

				this->lpddsPrimary->Release();
				this->lpddsPrimary = NULL;

		        this->lpdd->Release();
				this->lpdd=NULL;

				this->videoMode = VIDEO_MODE_NONE;

	            return MP_RESULT_ERROR;
			}
		}

		if(FAILED(ddrval)) {

			return MP_RESULT_ERROR;
		}

		this->width  = width;
		this->height = height;

		this->bpp    = 16;



		ZeroMemory(&ddsd, sizeof(DDSURFACEDESC2));
		ddsd.dwSize     = sizeof(DDSURFACEDESC2);
		
		ddrval = this->lpddsPrimary->Lock(NULL, &ddsd, DDLOCK_SURFACEMEMORYPTR | DDLOCK_WRITEONLY | DDLOCK_WAIT, NULL);

		if(FAILED(ddrval)) {

			return MP_RESULT_ERROR;
		}

		this->lpddsPrimary->Unlock(NULL);

		switch(ddsd.ddpfPixelFormat.dwRGBBitCount) {

		case 8:
			return MP_RESULT_ERROR;
			break;

		case 16:
			this->physicalDepth = 16;
			break;

		case 24:
			this->physicalDepth = 24;
			break;

		case 32:
			this->physicalDepth = 32;
			break;
		}
		


		ddrval = this->lpdd->GetDisplayMode(&ddsd);


		this->fullscreenWidth  = ddsd.dwWidth;
		this->fullscreenHeight = ddsd.dwHeight;



		this->hwndPlayback = hwnd;

		return MP_RESULT_OK;
	}
    
	return MP_RESULT_ERROR;
}

MP_RESULT MediaVideoRendererOverlay::InitFullscreen(HWND hwnd, unsigned int width, unsigned int height)
{
	if(hwnd && width > 0 && height > 0) {
	
		HRESULT         ddrval;
	    DDSURFACEDESC2  ddsd;
	    DDSURFACEDESC2  ddsdOverlay;
		DWORD           i;

		this->invertFlag  = FALSE;
    
	    ddrval = DirectDrawCreateEx(NULL, (VOID**)&this->lpdd, IID_IDirectDraw7, NULL);
		
		if( FAILED(ddrval))
			return MP_RESULT_ERROR;
  

		if(!this->AreOverlaysSupported()) {

	        this->lpdd->Release();
			this->lpdd=NULL;
			return MP_RESULT_ERROR;
		}


		ddrval = this->lpdd->SetCooperativeLevel(hwnd, DDSCL_NORMAL);
		
		if( FAILED(ddrval)) {

	        this->lpdd->Release();
			this->lpdd = NULL;

			return MP_RESULT_ERROR;
		}



		DDSURFACEDESC2 ddDesc;

		memset(&ddDesc, 0, sizeof(DDSURFACEDESC2));
		ddDesc.dwSize    = sizeof(DDSURFACEDESC2);



		ddrval = this->lpdd->GetDisplayMode(&ddDesc);

		if(FAILED(ddrval)) {

	        this->lpdd->Release();
			this->lpdd=NULL;
			return MP_RESULT_ERROR;;
		}



		this->fullscreenWidth  = ddDesc.dwWidth;
		this->fullscreenHeight = ddDesc.dwHeight;


   
	    ZeroMemory(&ddsd, sizeof(DDSURFACEDESC2));
		
		ddsd.dwSize  = sizeof(DDSURFACEDESC2);
		ddsd.dwFlags = DDSD_CAPS;
		ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
    
		ddrval = this->lpdd->CreateSurface(&ddsd, &this->lpddsPrimary, NULL );

		if(FAILED(ddrval)) {

			this->lpdd->Release();
		    this->lpdd=NULL;
			return MP_RESULT_ERROR;
		}


    
	    ZeroMemory(&ddsdOverlay, sizeof(DDSURFACEDESC2));

		ddsdOverlay.dwSize  = sizeof(DDSURFACEDESC2);

	    ddsdOverlay.ddsCaps.dwCaps = DDSCAPS_OVERLAY | DDSCAPS_VIDEOMEMORY;
		ddsdOverlay.dwFlags= DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT;
		
		ddsdOverlay.dwWidth           = width;
		ddsdOverlay.dwHeight          = height;
    
	    i = 0;
    
		do {
	
			ddsdOverlay.ddpfPixelFormat = ddpfOverlayFormats[i];
			this->videoMode = videoModes[i];

  			ddrval = this->lpdd->CreateSurface(&ddsdOverlay, &this->lpddsOverlay, NULL);
		
		} while( FAILED(ddrval) && (++i < 2) );



		if(FAILED(ddrval)) {

		    ZeroMemory(&ddsdOverlay, sizeof(DDSURFACEDESC2));
			ddsdOverlay.dwSize     = sizeof(DDSURFACEDESC2);
			
			ddsdOverlay.dwWidth           = width;
			ddsdOverlay.dwHeight          = height;
	        ddsdOverlay.dwBackBufferCount = 0;
			
			ddsdOverlay.ddsCaps.dwCaps    = DDSCAPS_OVERLAY | DDSCAPS_VIDEOMEMORY;
			ddsdOverlay.dwFlags           = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT;
        

		    i = 0;
    
			do {
	
				ddsdOverlay.ddpfPixelFormat = ddpfOverlayFormats[i];
				this->videoMode = videoModes[i];

	 			ddrval = this->lpdd->CreateSurface(&ddsdOverlay, &this->lpddsOverlay, NULL);
		
			} while( FAILED(ddrval) && (++i < 2) );
        
			if (FAILED(ddrval)) {

				this->lpddsPrimary->Release();
				this->lpddsPrimary = NULL;

		        this->lpdd->Release();
				this->lpdd=NULL;

				this->videoMode = VIDEO_MODE_NONE;

	            return MP_RESULT_ERROR;
			}
		}

		if(FAILED(ddrval)) {

			return MP_RESULT_ERROR;
		}

		this->width  = width;
		this->height = height;

		this->bpp    = 16;

		this->hwndPlayback = hwnd;

		return MP_RESULT_OK;
	}
    
	return MP_RESULT_ERROR;
}

MP_RESULT MediaVideoRendererOverlay::Stop()