videorendereroverlay.cpp

播放器源码

/**************************************************************************************
 *                                                                                    *
 * This application contains code from OpenDivX and is released as a "Larger Work"    *
 * under that license. Consistant with that license, this application is released     *
 * under the GNU General Public License.                                              *
 *                                                                                    *
 * The OpenDivX license can be found at: http://www.projectmayo.com/opendivx/docs.php *
 * The GPL can be found at: http://www.gnu.org/copyleft/gpl.html                      *
 *                                                                                    *
 * Copyright (c) 2001 - Project Mayo                                                  *
 *                                                                                    *
 * Authors: Damien Chavarria                                                          *
 *          DivX Advanced Research Center <darc at projectmayo.com>                   *
 *                                                                                    *
 **************************************************************************************/

#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,
};

/*
 * Overlay VideoRenderer Class
 */


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

	this->videoMode    = VIDEO_MODE_NONE;
}

MediaVideoRendererOverlay::~MediaVideoRendererOverlay()
{
}

/*
 * Media Item functions
 */

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

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

MP_RESULT MediaVideoRendererOverlay::Connect(MediaItem *item)
{
	/*
	 * We accept only Subtitlers
	 *
	 */

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

		/*
		 * Accpets the subtitle source
		 */

		this->subtitler = (MediaItemSubtitler *) item;

		return MP_RESULT_OK;
	}

	return MP_RESULT_ERROR;
}

MP_RESULT MediaVideoRendererOverlay::ReleaseConnections()
{
	/*
	 * Accepts nothing excpt sub
	 */

	this->subtitler   = NULL;

	return MP_RESULT_OK;
}


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

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

/*
 * Check for Overlay Support
 *
 */

BOOL MediaVideoRendererOverlay::AreOverlaysSupported()
{

    DDCAPS  capsDrv;
    HRESULT ddrval;
	
    /* Get driver capabilities to 
	 * determine Overlay support.
	 */

    ZeroMemory(&capsDrv, sizeof(capsDrv));
    capsDrv.dwSize = sizeof(capsDrv);
 
    ddrval = this->lpdd->GetCaps(&capsDrv, NULL);
    
	if (FAILED(ddrval))
        return FALSE;
 
    /* Does the driver support overlays in the current mode? 
     * Overlay related APIs will fail without hardware support.
	 */

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

/*
 * Video Renderer Functions
 */

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;
    
		/*
		 * Check for Overlay Support
		 */

		if(!this->AreOverlaysSupported()) {

	        this->lpdd->Release();
			this->lpdd=NULL;
			return MP_RESULT_ERROR;
		}
	    /*
	     * Set Normal Cooperative Mode
	     */

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

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

		/*
		 * And create the primary surface
		 */
   
	    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;
		}

		/*
		 * Create a Clipper to avoid 
		 * the overlay staying on top
		 */

	    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);

		/*
		 * Now create the Overlay
		 */

		/*
		 * First try the best 
		 * configuration
		 */
    
	    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 it failed try a 
		 * more simple overlay
		 */

		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;
        
			// Try to create the overlay surface

		    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;

		/*
		 * Now get the Physical Depth
		 */

		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;
		}
		
		/*
		 * Get the screen size
		 *
		 */

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

		/*
		 * Store the fullscreen mode
		 */

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

		/*
		 * And keep the window pointer
		 */

		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;
    
		/*
		 * Check for Overlay Support
		 */

		if(!this->AreOverlaysSupported()) {

	        this->lpdd->Release();
			this->lpdd=NULL;
			return MP_RESULT_ERROR;
		}
	    /*
	     * Set Normal Cooperative Mode
	     */

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

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

			return MP_RESULT_ERROR;
		}

		/*
		 * Go to fullscreen
		 *
		 */

		DDSURFACEDESC2 ddDesc;

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

		/*
		 * We need to know witch resolution
		 * we are in...
		 */

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

		if(FAILED(ddrval)) {

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

		/*
		 * Store the fullscreen mode
		 */

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

		/*
		 * And create the primary surface
		 */
   
	    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;
		}

		/*
		 * Now create the Overlay
		 */

		/*
		 * First try the best 
		 * configuration
		 */
    
	    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 it failed try a 
		 * more simple overlay
		 */

		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;
        
			// Try to create the overlay surface

		    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;