bool isPALSystem()
{
if(XGetVideoStandard() == XC_VIDEO_STANDARD_PAL_I)
{
g_CurrentParams.interlaced=true;
/* Get supported video flags. */
DWORD VideoFlags = XGetVideoFlags();
/* Set pal60 if available. */
if( VideoFlags & XC_VIDEO_FLAGS_PAL_60Hz )
g_CurrentParams.rate = 60;
else
g_CurrentParams.rate = 50;
g_CurrentParams.PAL = true;
return true;
}
g_CurrentParams.rate = 60;
g_CurrentParams.PAL = false;
return false;
}
static void gfx_ctx_d3d_get_video_size(void *data,
unsigned *width, unsigned *height)
{
#ifdef _XBOX
d3d_video_t *d3d = (d3d_video_t*)data;
(void)width;
(void)height;
#if defined(_XBOX360)
XVIDEO_MODE video_mode;
XGetVideoMode(&video_mode);
*width = video_mode.dwDisplayWidth;
*height = video_mode.dwDisplayHeight;
d3d->resolution_hd_enable = false;
if(video_mode.fIsHiDef)
{
*width = 1280;
*height = 720;
d3d->resolution_hd_enable = true;
}
else
{
*width = 640;
*height = 480;
}
widescreen_mode = video_mode.fIsWideScreen;
#elif defined(_XBOX1)
DWORD video_mode = XGetVideoFlags();
*width = 640;
*height = 480;
widescreen_mode = false;
/* Only valid in PAL mode, not valid for HDTV modes! */
if(XGetVideoStandard() == XC_VIDEO_STANDARD_PAL_I)
{
/* Check for 16:9 mode (PAL REGION) */
if(video_mode & XC_VIDEO_FLAGS_WIDESCREEN)
{
*width = 720;
//60 Hz, 720x480i
if(video_mode & XC_VIDEO_FLAGS_PAL_60Hz)
*height = 480;
else //50 Hz, 720x576i
*height = 576;
widescreen_mode = true;
}
}
else
{
/* Check for 16:9 mode (NTSC REGIONS) */
if(video_mode & XC_VIDEO_FLAGS_WIDESCREEN)
{
*width = 720;
*height = 480;
widescreen_mode = true;
}
}
if(XGetAVPack() == XC_AV_PACK_HDTV)
{
if(video_mode & XC_VIDEO_FLAGS_HDTV_480p)
{
*width = 640;
*height = 480;
widescreen_mode = false;
d3d->resolution_hd_enable = true;
}
else if(video_mode & XC_VIDEO_FLAGS_HDTV_720p)
{
*width = 1280;
*height = 720;
widescreen_mode = true;
d3d->resolution_hd_enable = true;
}
else if(video_mode & XC_VIDEO_FLAGS_HDTV_1080i)
{
*width = 1920;
*height = 1080;
widescreen_mode = true;
d3d->resolution_hd_enable = true;
}
}
#endif
#endif
}
static void *xdk_d3d_init(const video_info_t *video, const input_driver_t **input, void **input_data)
{
if (driver.video_data)
return driver.video_data;
xdk_d3d_video_t *d3d = (xdk_d3d_video_t*)calloc(1, sizeof(xdk_d3d_video_t));
if (!d3d)
return NULL;
d3d->d3d_device = direct3d_create_ctx(D3D_SDK_VERSION);
if (!d3d->d3d_device)
{
free(d3d);
RARCH_ERR("Failed to create a D3D8 object.\n");
return NULL;
}
memset(&d3d->d3dpp, 0, sizeof(d3d->d3dpp));
// Get the "video mode"
d3d->video_mode = XGetVideoFlags();
// Check if we are able to use progressive mode
if(d3d->video_mode & XC_VIDEO_FLAGS_HDTV_480p)
d3d->d3dpp.Flags = D3DPRESENTFLAG_PROGRESSIVE;
else
d3d->d3dpp.Flags = D3DPRESENTFLAG_INTERLACED;
// Safe mode
d3d->d3dpp.BackBufferWidth = 640;
d3d->d3dpp.BackBufferHeight = 480;
g_console.menus_hd_enable = false;
// Only valid in PAL mode, not valid for HDTV modes!
if(XGetVideoStandard() == XC_VIDEO_STANDARD_PAL_I)
{
if(d3d->video_mode & XC_VIDEO_FLAGS_PAL_60Hz)
d3d->d3dpp.FullScreen_RefreshRateInHz = 60;
else
d3d->d3dpp.FullScreen_RefreshRateInHz = 50;
// Check for 16:9 mode (PAL REGION)
if(d3d->video_mode & XC_VIDEO_FLAGS_WIDESCREEN)
{
if(d3d->video_mode & XC_VIDEO_FLAGS_PAL_60Hz)
{ //60 Hz, 720x480i
d3d->d3dpp.BackBufferWidth = 720;
d3d->d3dpp.BackBufferHeight = 480;
}
else
{ //50 Hz, 720x576i
d3d->d3dpp.BackBufferWidth = 720;
d3d->d3dpp.BackBufferHeight = 576;
}
}
}
else
{
// Check for 16:9 mode (NTSC REGIONS)
if(d3d->video_mode & XC_VIDEO_FLAGS_WIDESCREEN)
{
d3d->d3dpp.BackBufferWidth = 720;
d3d->d3dpp.BackBufferHeight = 480;
}
}
if(XGetAVPack() == XC_AV_PACK_HDTV)
{
if(d3d->video_mode & XC_VIDEO_FLAGS_HDTV_480p)
{
g_console.menus_hd_enable = false;
d3d->d3dpp.BackBufferWidth = 640;
d3d->d3dpp.BackBufferHeight = 480;
d3d->d3dpp.Flags = D3DPRESENTFLAG_PROGRESSIVE;
}
else if(d3d->video_mode & XC_VIDEO_FLAGS_HDTV_720p)
{
g_console.menus_hd_enable = true;
d3d->d3dpp.BackBufferWidth = 1280;
d3d->d3dpp.BackBufferHeight = 720;
d3d->d3dpp.Flags = D3DPRESENTFLAG_PROGRESSIVE;
}
else if(d3d->video_mode & XC_VIDEO_FLAGS_HDTV_1080i)
{
g_console.menus_hd_enable = true;
d3d->d3dpp.BackBufferWidth = 1920;
d3d->d3dpp.BackBufferHeight = 1080;
d3d->d3dpp.Flags = D3DPRESENTFLAG_INTERLACED;
}
}
if(d3d->d3dpp.BackBufferWidth > 640 && ((float)d3d->d3dpp.BackBufferHeight / (float)d3d->d3dpp.BackBufferWidth != 0.75) ||
((d3d->d3dpp.BackBufferWidth == 720) && (d3d->d3dpp.BackBufferHeight == 576))) // 16:9
d3d->d3dpp.Flags |= D3DPRESENTFLAG_WIDESCREEN;
// no letterboxing in 4:3 mode (if widescreen is unsupported
d3d->d3dpp.BackBufferFormat = D3DFMT_A8R8G8B8;
d3d->d3dpp.FullScreen_PresentationInterval = video->vsync ? D3DPRESENT_INTERVAL_ONE : D3DPRESENT_INTERVAL_IMMEDIATE;
d3d->d3dpp.MultiSampleType = D3DMULTISAMPLE_NONE;
d3d->d3dpp.BackBufferCount = 2;
d3d->d3dpp.EnableAutoDepthStencil = FALSE;
d3d->d3dpp.SwapEffect = D3DSWAPEFFECT_COPY;
d3d->d3d_device->CreateDevice(0, D3DDEVTYPE_HAL, NULL, D3DCREATE_HARDWARE_VERTEXPROCESSING, &d3d->d3dpp, &d3d->d3d_render_device);
d3d->d3d_render_device->Clear(0, NULL, D3DCLEAR_TARGET, 0xff000000, 1.0f, 0);
// use an orthogonal matrix for the projection matrix
D3DXMATRIX mat;
D3DXMatrixOrthoOffCenterLH(&mat, 0, d3d->d3dpp.BackBufferWidth , d3d->d3dpp.BackBufferHeight , 0, 0.0f, 1.0f);
d3d->d3d_render_device->SetTransform(D3DTS_PROJECTION, &mat);
// use an identity matrix for the world and view matrices
D3DXMatrixIdentity(&mat);
d3d->d3d_render_device->SetTransform(D3DTS_WORLD, &mat);
d3d->d3d_render_device->SetTransform(D3DTS_VIEW, &mat);
d3d->d3d_render_device->CreateTexture(512, 512, 1, 0, D3DFMT_LIN_X1R5G5B5, 0, &d3d->lpTexture);
D3DLOCKED_RECT d3dlr;
d3d->lpTexture->LockRect(0, &d3dlr, NULL, 0);
memset(d3dlr.pBits, 0, 512 * d3dlr.Pitch);
d3d->lpTexture->UnlockRect(0);
d3d->last_width = 512;
d3d->last_height = 512;
d3d->d3d_render_device->CreateVertexBuffer(4 * sizeof(DrawVerticeFormats),
D3DUSAGE_WRITEONLY, D3DFVF_CUSTOMVERTEX, D3DPOOL_MANAGED, &d3d->vertex_buf);
static const DrawVerticeFormats init_verts[] = {
{ -1.0f, -1.0f, 1.0f, 0.0f, 1.0f },
{ 1.0f, -1.0f, 1.0f, 1.0f, 1.0f },
{ -1.0f, 1.0f, 1.0f, 0.0f, 0.0f },
{ 1.0f, 1.0f, 1.0f, 1.0f, 0.0f },
};
BYTE *verts_ptr;
d3d->vertex_buf->Lock(0, 0, &verts_ptr, 0);
memcpy(verts_ptr, init_verts, sizeof(init_verts));
d3d->vertex_buf->Unlock();
d3d->d3d_render_device->SetVertexShader(D3DFVF_XYZ | D3DFVF_TEX1);
// disable lighting
d3d->d3d_render_device->SetRenderState(D3DRS_LIGHTING, FALSE);
// disable culling
d3d->d3d_render_device->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
// disable z-buffer
d3d->d3d_render_device->SetRenderState(D3DRS_ZENABLE, FALSE);
D3DVIEWPORT vp = {0};
vp.Width = d3d->d3dpp.BackBufferWidth;
vp.Height = d3d->d3dpp.BackBufferHeight;
vp.MinZ = 0.0f;
vp.MaxZ = 1.0f;
d3d->d3d_render_device->SetViewport(&vp);
if(g_console.viewports.custom_vp.width == 0)
g_console.viewports.custom_vp.width = vp.Width;
if(g_console.viewports.custom_vp.height == 0)
g_console.viewports.custom_vp.height = vp.Height;
xdk_d3d_set_rotation(d3d, g_console.screen_orientation);
d3d->vsync = video->vsync;
// load debug font (toggle option in later revisions ?)
XFONT_OpenDefaultFont(&d3d->debug_font);
d3d->debug_font->SetBkMode(XFONT_TRANSPARENT);
d3d->debug_font->SetBkColor(D3DCOLOR_ARGB(100,0,0,0));
d3d->debug_font->SetTextHeight(14);
d3d->debug_font->SetTextAntialiasLevel(d3d->debug_font->GetTextAntialiasLevel());
font_x = 0;
font_y = 0;
// TODO: place this somewhere else outside of xdk_d3d8.cpp
#ifdef SHOW_DEBUG_INFO
g_console.fps_info_enable = true;
#endif
return d3d;
}
void d3d_make_d3dpp(void *data,
const video_info_t *info, D3DPRESENT_PARAMETERS *d3dpp)
{
d3d_video_t *d3d = (d3d_video_t*)data;
settings_t *settings = config_get_ptr();
#ifdef _XBOX
/* TODO/FIXME - get rid of global state dependencies. */
global_t *global = global_get_ptr();
#endif
memset(d3dpp, 0, sizeof(*d3dpp));
d3dpp->Windowed = false;
#ifndef _XBOX
d3dpp->Windowed = settings->video.windowed_fullscreen || !info->fullscreen;
#endif
d3dpp->PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;
if (info->vsync)
{
switch (settings->video.swap_interval)
{
default:
case 1:
d3dpp->PresentationInterval = D3DPRESENT_INTERVAL_ONE;
break;
case 2:
d3dpp->PresentationInterval = D3DPRESENT_INTERVAL_TWO;
break;
case 3:
d3dpp->PresentationInterval = D3DPRESENT_INTERVAL_THREE;
break;
case 4:
d3dpp->PresentationInterval = D3DPRESENT_INTERVAL_FOUR;
break;
}
}
d3dpp->SwapEffect = D3DSWAPEFFECT_DISCARD;
d3dpp->BackBufferCount = 2;
#ifdef _XBOX
d3dpp->BackBufferFormat =
#ifdef _XBOX360
global->console.screen.gamma_correction ?
(D3DFORMAT)MAKESRGBFMT(info->rgb32 ? D3DFMT_X8R8G8B8 : D3DFMT_LIN_R5G6B5) :
#endif
info->rgb32 ? D3DFMT_X8R8G8B8 : D3DFMT_LIN_R5G6B5;
#else
d3dpp->hDeviceWindow = win32_get_window();
d3dpp->BackBufferFormat = !d3dpp->Windowed ? D3DFMT_X8R8G8B8 : D3DFMT_UNKNOWN;
#endif
if (!d3dpp->Windowed)
{
#ifdef _XBOX
unsigned width = 0;
unsigned height = 0;
gfx_ctx_get_video_size(&width, &height);
video_driver_set_size(&width, &height);
#endif
video_driver_get_size(&d3dpp->BackBufferWidth, &d3dpp->BackBufferHeight);
}
#ifdef _XBOX
d3dpp->MultiSampleType = D3DMULTISAMPLE_NONE;
d3dpp->EnableAutoDepthStencil = FALSE;
#if defined(_XBOX1)
/* Get the "video mode" */
DWORD video_mode = XGetVideoFlags();
/* Check if we are able to use progressive mode. */
if (video_mode & XC_VIDEO_FLAGS_HDTV_480p)
d3dpp->Flags = D3DPRESENTFLAG_PROGRESSIVE;
else
d3dpp->Flags = D3DPRESENTFLAG_INTERLACED;
/* Only valid in PAL mode, not valid for HDTV modes. */
if (XGetVideoStandard() == XC_VIDEO_STANDARD_PAL_I)
{
if (video_mode & XC_VIDEO_FLAGS_PAL_60Hz)
d3dpp->FullScreen_RefreshRateInHz = 60;
else
d3dpp->FullScreen_RefreshRateInHz = 50;
}
if (XGetAVPack() == XC_AV_PACK_HDTV)
{
if (video_mode & XC_VIDEO_FLAGS_HDTV_480p)
d3dpp->Flags = D3DPRESENTFLAG_PROGRESSIVE;
else if (video_mode & XC_VIDEO_FLAGS_HDTV_720p)
d3dpp->Flags = D3DPRESENTFLAG_PROGRESSIVE;
else if (video_mode & XC_VIDEO_FLAGS_HDTV_1080i)
d3dpp->Flags = D3DPRESENTFLAG_INTERLACED;
}
if (widescreen_mode)
d3dpp->Flags |= D3DPRESENTFLAG_WIDESCREEN;
#elif defined(_XBOX360)
if (!widescreen_mode)
d3dpp->Flags |= D3DPRESENTFLAG_NO_LETTERBOX;
if (global->console.screen.gamma_correction)
d3dpp->FrontBufferFormat = (D3DFORMAT)MAKESRGBFMT(D3DFMT_LE_X8R8G8B8);
else
d3dpp->FrontBufferFormat = D3DFMT_LE_X8R8G8B8;
d3dpp->MultiSampleQuality = 0;
#endif
#endif
}
/* Set the video mode. */
CString RageDisplay_D3D::TryVideoMode( VideoModeParams p, bool &bNewDeviceOut )
{
if( FindBackBufferType( p.windowed, p.bpp ) == D3DFMT_UNKNOWN ) // no possible back buffer formats
return ssprintf( "FindBackBufferType(%i,%i) failed", p.windowed, p.bpp ); // failed to set mode
#if !defined(XBOX)
if( GraphicsWindow::GetHwnd() == NULL )
GraphicsWindow::CreateGraphicsWindow( p );
#else
p.windowed = false;
#endif
/* Set up and display the window before setting up D3D. If we don't do this,
* then setting up a fullscreen window (when we're not coming from windowed)
* causes all other windows on the system to be resized to the new resolution. */
GraphicsWindow::ConfigureGraphicsWindow( p );
ZeroMemory( &g_d3dpp, sizeof(g_d3dpp) );
g_d3dpp.BackBufferWidth = p.width;
g_d3dpp.BackBufferHeight = p.height;
g_d3dpp.BackBufferFormat = FindBackBufferType( p.windowed, p.bpp );
g_d3dpp.BackBufferCount = 1;
g_d3dpp.MultiSampleType = D3DMULTISAMPLE_NONE;
g_d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
#if !defined(XBOX)
g_d3dpp.hDeviceWindow = GraphicsWindow::GetHwnd();
#else
g_d3dpp.hDeviceWindow = NULL;
#endif
g_d3dpp.Windowed = p.windowed;
g_d3dpp.EnableAutoDepthStencil = TRUE;
g_d3dpp.AutoDepthStencilFormat = D3DFMT_D16;
if(p.windowed)
g_d3dpp.PresentationInterval = D3DPRESENT_INTERVAL_DEFAULT;
else
g_d3dpp.PresentationInterval = p.vsync ? D3DPRESENT_INTERVAL_ONE : D3DPRESENT_INTERVAL_IMMEDIATE;
#if !defined(XBOX)
g_d3dpp.FullScreen_RefreshRateInHz = D3DPRESENT_RATE_DEFAULT;
if( !p.windowed && p.rate != REFRESH_DEFAULT )
g_d3dpp.FullScreen_RefreshRateInHz = p.rate;
#else
if( XGetVideoStandard() == XC_VIDEO_STANDARD_PAL_I )
{
/* Get supported video flags. */
DWORD VideoFlags = XGetVideoFlags();
/* Set pal60 if available. */
if( VideoFlags & XC_VIDEO_FLAGS_PAL_60Hz )
g_d3dpp.FullScreen_RefreshRateInHz = 60;
else
g_d3dpp.FullScreen_RefreshRateInHz = 50;
}
else
g_d3dpp.FullScreen_RefreshRateInHz = 60;
#endif
g_d3dpp.Flags = 0;
LOG->Trace( "Present Parameters: %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d",
g_d3dpp.BackBufferWidth, g_d3dpp.BackBufferHeight, g_d3dpp.BackBufferFormat,
g_d3dpp.BackBufferCount,
g_d3dpp.MultiSampleType, g_d3dpp.SwapEffect, g_d3dpp.hDeviceWindow,
g_d3dpp.Windowed, g_d3dpp.EnableAutoDepthStencil, g_d3dpp.AutoDepthStencilFormat,
g_d3dpp.Flags, g_d3dpp.FullScreen_RefreshRateInHz,
g_d3dpp.PresentationInterval
);
#if defined(XBOX)
if( D3D__pDevice )
g_pd3dDevice = D3D__pDevice;
#endif
/* Display the window immediately, so we don't display the desktop ... */
while( 1 )
{
/* Try the video mode. */
CString sErr = SetD3DParams( bNewDeviceOut );
if( sErr.empty() )
break;
/* It failed. We're probably selecting a video mode that isn't supported.
* If we're fullscreen, search the mode list and find the nearest lower
* mode. */
if( p.windowed || !D3DReduceParams( &g_d3dpp ) )
return sErr;
/* Store the new settings we're about to try. */
p.height = g_d3dpp.BackBufferHeight;
p.width = g_d3dpp.BackBufferWidth;
if( g_d3dpp.FullScreen_RefreshRateInHz == D3DPRESENT_RATE_DEFAULT )
p.rate = REFRESH_DEFAULT;
else
p.rate = g_d3dpp.FullScreen_RefreshRateInHz;
}
/* Call this again after changing the display mode. If we're going to a window
* from fullscreen, the first call can't set a larger window than the old fullscreen
* resolution or set the window position. */
GraphicsWindow::ConfigureGraphicsWindow( p );
GraphicsWindow::SetVideoModeParams( p );
ResolutionChanged();
this->SetDefaultRenderStates();
/* Palettes were lost by Reset(), so mark them unloaded. */
g_TexResourceToPaletteIndex.clear();
return ""; // mode change successful
}
void xdk_d3d_generate_pp(D3DPRESENT_PARAMETERS *d3dpp, const video_info_t *video)
{
xdk_d3d_video_t *d3d = (xdk_d3d_video_t*)driver.video_data;
uint64_t lifecycle_mode_state = g_extern.lifecycle_mode_state;
memset(d3dpp, 0, sizeof(*d3dpp));
d3d->texture_fmt = video->rgb32 ? D3DFMT_X8R8G8B8 : D3DFMT_LIN_R5G6B5;
d3d->base_size = video->rgb32 ? sizeof(uint32_t) : sizeof(uint16_t);
unsigned width, height;
if (d3d->ctx_driver)
d3d->ctx_driver->get_video_size(&width, &height);
d3dpp->BackBufferWidth = d3d->win_width = width;
d3dpp->BackBufferHeight = d3d->win_height = height;
#if defined(_XBOX1)
// Get the "video mode"
DWORD video_mode = XGetVideoFlags();
// Check if we are able to use progressive mode
if (video_mode & XC_VIDEO_FLAGS_HDTV_480p)
d3dpp->Flags = D3DPRESENTFLAG_PROGRESSIVE;
else
d3dpp->Flags = D3DPRESENTFLAG_INTERLACED;
// Only valid in PAL mode, not valid for HDTV modes!
if (XGetVideoStandard() == XC_VIDEO_STANDARD_PAL_I)
{
if (video_mode & XC_VIDEO_FLAGS_PAL_60Hz)
d3dpp->FullScreen_RefreshRateInHz = 60;
else
d3dpp->FullScreen_RefreshRateInHz = 50;
}
if (XGetAVPack() == XC_AV_PACK_HDTV)
{
if (video_mode & XC_VIDEO_FLAGS_HDTV_480p)
d3dpp->Flags = D3DPRESENTFLAG_PROGRESSIVE;
else if (video_mode & XC_VIDEO_FLAGS_HDTV_720p)
d3dpp->Flags = D3DPRESENTFLAG_PROGRESSIVE;
else if (video_mode & XC_VIDEO_FLAGS_HDTV_1080i)
d3dpp->Flags = D3DPRESENTFLAG_INTERLACED;
}
if (lifecycle_mode_state & MODE_MENU_WIDESCREEN)
d3dpp->Flags |= D3DPRESENTFLAG_WIDESCREEN;
d3dpp->BackBufferFormat = D3DFMT_X8R8G8B8;
d3dpp->FullScreen_PresentationInterval = d3d->vsync ? D3DPRESENT_INTERVAL_ONE : D3DPRESENT_INTERVAL_IMMEDIATE;
d3dpp->SwapEffect = D3DSWAPEFFECT_COPY;
#elif defined(_XBOX360)
if (!(lifecycle_mode_state & (1ULL << MODE_MENU_WIDESCREEN)))
d3dpp->Flags |= D3DPRESENTFLAG_NO_LETTERBOX;
if (g_extern.console.screen.gamma_correction)
{
d3dpp->BackBufferFormat = (D3DFORMAT)MAKESRGBFMT(d3d->texture_fmt);
d3dpp->FrontBufferFormat = (D3DFORMAT)MAKESRGBFMT(D3DFMT_LE_X8R8G8B8);
}
else
{
d3dpp->BackBufferFormat = d3d->texture_fmt;
d3dpp->FrontBufferFormat = D3DFMT_LE_X8R8G8B8;
}
d3dpp->MultiSampleQuality = 0;
d3dpp->PresentationInterval = d3d->vsync ? D3DPRESENT_INTERVAL_ONE : D3DPRESENT_INTERVAL_IMMEDIATE;
d3dpp->SwapEffect = D3DSWAPEFFECT_DISCARD;
#endif
d3dpp->BackBufferCount = 2;
d3dpp->MultiSampleType = D3DMULTISAMPLE_NONE;
d3dpp->EnableAutoDepthStencil = FALSE;
}
static void gfx_ctx_xdk_get_video_size(unsigned *width, unsigned *height)
{
#if defined(_XBOX360)
XVIDEO_MODE video_mode;
XGetVideoMode(&video_mode);
*width = video_mode.dwDisplayWidth;
*height = video_mode.dwDisplayHeight;
if(video_mode.fIsHiDef)
{
*width = 1280;
*height = 720;
g_extern.lifecycle_state |= (1ULL << MODE_MENU_HD);
}
else
{
*width = 640;
*height = 480;
g_extern.lifecycle_state &= ~(1ULL << MODE_MENU_HD);
}
if(video_mode.fIsWideScreen)
g_extern.lifecycle_state |= (1ULL << MODE_MENU_WIDESCREEN);
else
g_extern.lifecycle_state &= ~(1ULL << MODE_MENU_WIDESCREEN);
#elif defined(_XBOX1)
DWORD video_mode = XGetVideoFlags();
*width = 640;
*height = 480;
// Only valid in PAL mode, not valid for HDTV modes!
if(XGetVideoStandard() == XC_VIDEO_STANDARD_PAL_I)
{
// Check for 16:9 mode (PAL REGION)
if(video_mode & XC_VIDEO_FLAGS_WIDESCREEN)
{
if(video_mode & XC_VIDEO_FLAGS_PAL_60Hz)
{ //60 Hz, 720x480i
*width = 720;
*height = 480;
}
else
{ //50 Hz, 720x576i
*width = 720;
*height = 576;
}
g_extern.lifecycle_state |= (1ULL << MODE_MENU_WIDESCREEN);
}
else
g_extern.lifecycle_state &= ~(1ULL << MODE_MENU_WIDESCREEN);
}
else
{
// Check for 16:9 mode (NTSC REGIONS)
if(video_mode & XC_VIDEO_FLAGS_WIDESCREEN)
{
*width = 720;
*height = 480;
g_extern.lifecycle_state |= (1ULL << MODE_MENU_WIDESCREEN);
}
else
g_extern.lifecycle_state &= ~(1ULL << MODE_MENU_WIDESCREEN);
}
if(XGetAVPack() == XC_AV_PACK_HDTV)
{
if(video_mode & XC_VIDEO_FLAGS_HDTV_480p)
{
*width = 640;
*height = 480;
g_extern.lifecycle_state &= ~(1ULL << MODE_MENU_WIDESCREEN);
g_extern.lifecycle_state |= (1ULL << MODE_MENU_HD);
}
else if(video_mode & XC_VIDEO_FLAGS_HDTV_720p)
{
*width = 1280;
*height = 720;
g_extern.lifecycle_state |= (1ULL << MODE_MENU_WIDESCREEN);
g_extern.lifecycle_state |= (1ULL << MODE_MENU_HD);
}
else if(video_mode & XC_VIDEO_FLAGS_HDTV_1080i)
{
*width = 1920;
*height = 1080;
g_extern.lifecycle_state |= (1ULL << MODE_MENU_WIDESCREEN);
g_extern.lifecycle_state |= (1ULL << MODE_MENU_HD);
}
}
#else
/* TODO: implement */
(void)width;
(void)height;
#endif
}
void d3d_make_d3dpp(void *data, const video_info_t *info, D3DPRESENT_PARAMETERS *d3dpp)
{
d3d_video_t *d3d = (d3d_video_t*)data;
memset(d3dpp, 0, sizeof(*d3dpp));
#ifdef _XBOX
d3dpp->Windowed = false;
#else
d3dpp->Windowed = g_settings.video.windowed_fullscreen || !info->fullscreen;
#endif
if (info->vsync)
{
switch (g_settings.video.swap_interval)
{
default:
case 1: d3dpp->PresentationInterval = D3DPRESENT_INTERVAL_ONE; break;
case 2: d3dpp->PresentationInterval = D3DPRESENT_INTERVAL_TWO; break;
case 3: d3dpp->PresentationInterval = D3DPRESENT_INTERVAL_THREE; break;
case 4: d3dpp->PresentationInterval = D3DPRESENT_INTERVAL_FOUR; break;
}
}
else
d3dpp->PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;
d3dpp->SwapEffect = D3DSWAPEFFECT_DISCARD;
d3dpp->BackBufferCount = 2;
#ifdef _XBOX
d3dpp->BackBufferFormat =
#ifdef _XBOX360
g_extern.console.screen.gamma_correction ? (D3DFORMAT)MAKESRGBFMT(info->rgb32 ? D3DFMT_X8R8G8B8 : D3DFMT_LIN_R5G6B5) :
#endif
info->rgb32 ? D3DFMT_X8R8G8B8 : D3DFMT_LIN_R5G6B5;
#else
d3dpp->hDeviceWindow = d3d->hWnd;
d3dpp->BackBufferFormat = !d3dpp->Windowed ? D3DFMT_X8R8G8B8 : D3DFMT_UNKNOWN;
#endif
if (!d3dpp->Windowed)
{
#ifdef _XBOX
unsigned width, height;
width = 0;
height = 0;
if (d3d->ctx_driver && d3d->ctx_driver->get_video_size)
d3d->ctx_driver->get_video_size(d3d, &width, &height);
d3dpp->BackBufferWidth = d3d->screen_width = width;
d3dpp->BackBufferHeight = d3d->screen_height = height;
#else
d3dpp->BackBufferWidth = d3d->screen_width;
d3dpp->BackBufferHeight = d3d->screen_height;
#endif
}
#ifdef _XBOX
d3dpp->MultiSampleType = D3DMULTISAMPLE_NONE;
d3dpp->EnableAutoDepthStencil = FALSE;
#if defined(_XBOX1)
// Get the "video mode"
DWORD video_mode = XGetVideoFlags();
// Check if we are able to use progressive mode
if (video_mode & XC_VIDEO_FLAGS_HDTV_480p)
d3dpp->Flags = D3DPRESENTFLAG_PROGRESSIVE;
else
d3dpp->Flags = D3DPRESENTFLAG_INTERLACED;
// Only valid in PAL mode, not valid for HDTV modes!
if (XGetVideoStandard() == XC_VIDEO_STANDARD_PAL_I)
{
if (video_mode & XC_VIDEO_FLAGS_PAL_60Hz)
d3dpp->FullScreen_RefreshRateInHz = 60;
else
d3dpp->FullScreen_RefreshRateInHz = 50;
}
if (XGetAVPack() == XC_AV_PACK_HDTV)
{
if (video_mode & XC_VIDEO_FLAGS_HDTV_480p)
d3dpp->Flags = D3DPRESENTFLAG_PROGRESSIVE;
else if (video_mode & XC_VIDEO_FLAGS_HDTV_720p)
d3dpp->Flags = D3DPRESENTFLAG_PROGRESSIVE;
else if (video_mode & XC_VIDEO_FLAGS_HDTV_1080i)
d3dpp->Flags = D3DPRESENTFLAG_INTERLACED;
}
if (g_extern.lifecycle_state & MODE_MENU_WIDESCREEN)
d3dpp->Flags |= D3DPRESENTFLAG_WIDESCREEN;
#elif defined(_XBOX360)
if (!(g_extern.lifecycle_state & (1ULL << MODE_MENU_WIDESCREEN)))
d3dpp->Flags |= D3DPRESENTFLAG_NO_LETTERBOX;
if (g_extern.console.screen.gamma_correction)
d3dpp->FrontBufferFormat = (D3DFORMAT)MAKESRGBFMT(D3DFMT_LE_X8R8G8B8);
else
d3dpp->FrontBufferFormat = D3DFMT_LE_X8R8G8B8;
d3dpp->MultiSampleQuality = 0;
#endif
#endif
}
int MFDisplay_CreateDisplay(int width, int height, int bpp, int rate, bool vsync, bool triplebuffer, bool wide, bool progressive)
{
MFCALLSTACK;
DWORD avPack = XGetAVPack();
DWORD vidMode = XGetVideoStandard();
DWORD vidFlags = XGetVideoFlags();
// log the AV pack (just an FYI)
switch(avPack)
{
case XC_AV_PACK_SCART: MFDebug_Log(2, "MFDisplay: Video output using Scart AV Pack"); break;
case XC_AV_PACK_HDTV: MFDebug_Log(2, "MFDisplay: Video output using High Def Pack"); break;
case XC_AV_PACK_RFU: MFDebug_Log(2, "MFDisplay: Video output using RF Unit"); break;
case XC_AV_PACK_SVIDEO: MFDebug_Log(2, "MFDisplay: Video output using Advanced AV Pack"); break;
case XC_AV_PACK_STANDARD: MFDebug_Log(2, "MFDisplay: Video output using Standard AV Pack"); break;
default: MFDebug_Log(2, "MFDisplay: Video output using Unknown AV Pack"); break;
}
// calculate the frame buffer size and display mode from the dashboard info
gbWidescreen = !!(vidFlags & (XC_VIDEO_FLAGS_WIDESCREEN));
gbLetterBox = !!(vidFlags & (XC_VIDEO_FLAGS_LETTERBOX));
wide = gbWidescreen;
if(vidMode == XC_VIDEO_STANDARD_PAL_I)
{
// PAL modes (poor PAL users dont get high def) :(
if(vidFlags & XC_VIDEO_FLAGS_PAL_60Hz)
{
width = 720;
height = 480;
rate = 60;
progressive = false;
MFDebug_Log(2, MFStr("MFDisplay: Video Mode set to PAL60%s", wide ? " (Widescreen)" : (gbLetterBox ? " (Letterbox)" : "")));
}
else
{
width = 720;
height = 576;
rate = 50;
progressive = false;
MFDebug_Log(2, MFStr("MFDisplay: Video Mode set to PAL (576i)%s", wide ? " (Widescreen)" : (gbLetterBox ? " (Letterbox)" : "")));
}
}
else
{
// NTSC modes
if(vidFlags & XC_VIDEO_FLAGS_HDTV_1080i)
{
width = 1920;
height = 1080;
rate = 60;
progressive = false;
MFDebug_Log(2, "MFDisplay: Video Mode set to 1080i");
}
else if(vidFlags & XC_VIDEO_FLAGS_HDTV_720p)
{
width = 1280;
height = 720;
rate = 60;
progressive = true;
MFDebug_Log(2, "MFDisplay: Video Mode set to 720p");
}
else if(vidFlags & XC_VIDEO_FLAGS_HDTV_480p)
{
width = 720;
height = 480;
rate = 60;
progressive = true;
MFDebug_Log(2, MFStr("MFDisplay: Video Mode set to 480p%s", wide ? " (Widescreen)" : (gbLetterBox ? " (Letterbox)" : "")));
}
else
{
width = 720;
height = 480;
rate = 60;
progressive = false;
MFDebug_Log(2, MFStr("MFDisplay: Video Mode set to NTSC (480i)%s", wide ? " (Widescreen)" : (gbLetterBox ? " (Letterbox)" : "")));
}
}
// update display parameters
gDisplay.fullscreenWidth = gDisplay.width = width;
gDisplay.fullscreenHeight = gDisplay.height = height;
gDisplay.progressive = progressive;
gDisplay.refreshRate = rate;
gDisplay.wide = wide;
gDisplay.colourDepth = bpp;
gDisplay.windowed = false;
MFRenderer_CreateDisplay();
// setup the initial viewport (letterbox)
MFRenderer_ResetViewport();
return 0;
}