Skip to content

Commit

Permalink
Browse files Browse the repository at this point in the history
Merge branch 'efb_scaling_fixes'.
  • Loading branch information
@neobrain
neobrain committed Nov 19, 2012
2 parents 9345501 + b02bb76 commit 4ff9e03
Show file tree
Hide file tree
Showing 11 changed files with 367 additions and 314 deletions.
31 changes: 31 additions & 0 deletions Source/Core/VideoCommon/Src/FramebufferManagerBase.cpp
View file
Expand Up @@ -10,6 +10,9 @@ XFBSourceBase *FramebufferManagerBase::m_realXFBSource; // Only used in Real XFB
FramebufferManagerBase::VirtualXFBListType FramebufferManagerBase::m_virtualXFBList; // Only used in Virtual XFB mode
const XFBSourceBase* FramebufferManagerBase::m_overlappingXFBArray[MAX_VIRTUAL_XFB];

unsigned int FramebufferManagerBase::s_last_xfb_width = 1;
unsigned int FramebufferManagerBase::s_last_xfb_height = 1;

FramebufferManagerBase::FramebufferManagerBase()
{
m_realXFBSource = NULL;
Expand Down Expand Up @@ -226,3 +229,31 @@ void FramebufferManagerBase::ReplaceVirtualXFB()
}
}
}

int FramebufferManagerBase::ScaleToVirtualXfbWidth(int x, unsigned int backbuffer_width)
{
if (g_ActiveConfig.RealXFBEnabled())
return x;

if (g_ActiveConfig.b3DVision)
{
// This works, yet the version in the else doesn't. No idea why.
return x * (int)backbuffer_width / (int)FramebufferManagerBase::LastXfbWidth();
}
else
return x * (int)Renderer::GetTargetRectangle().GetWidth() / (int)FramebufferManagerBase::LastXfbWidth();
}

int FramebufferManagerBase::ScaleToVirtualXfbHeight(int y, unsigned int backbuffer_height)
{
if (g_ActiveConfig.RealXFBEnabled())
return y;

if (g_ActiveConfig.b3DVision)
{
// This works, yet the version in the else doesn't. No idea why.
return y * (int)backbuffer_height / (int)FramebufferManagerBase::LastXfbHeight();
}
else
return y * (int)Renderer::GetTargetRectangle().GetHeight() / (int)FramebufferManagerBase::LastXfbHeight();
}
11 changes: 11 additions & 0 deletions Source/Core/VideoCommon/Src/FramebufferManagerBase.h
View file
Expand Up @@ -50,6 +50,14 @@ class FramebufferManagerBase
static void CopyToXFB(u32 xfbAddr, u32 fbWidth, u32 fbHeight, const EFBRectangle& sourceRc,float Gamma);
static const XFBSourceBase* const* GetXFBSource(u32 xfbAddr, u32 fbWidth, u32 fbHeight, u32 &xfbCount);

static void SetLastXfbWidth(unsigned int width) { s_last_xfb_width = width; }
static void SetLastXfbHeight(unsigned int height) { s_last_xfb_height = height; }
static unsigned int LastXfbWidth() { return s_last_xfb_width; }
static unsigned int LastXfbHeight() { return s_last_xfb_height; }

static int ScaleToVirtualXfbWidth(int x, unsigned int backbuffer_width);
static int ScaleToVirtualXfbHeight(int y, unsigned int backbuffer_height);

protected:
struct VirtualXFB
{
Expand Down Expand Up @@ -85,6 +93,9 @@ class FramebufferManagerBase
static VirtualXFBListType m_virtualXFBList; // Only used in Virtual XFB mode

static const XFBSourceBase* m_overlappingXFBArray[MAX_VIRTUAL_XFB];

static unsigned int s_last_xfb_width;
static unsigned int s_last_xfb_height;
};

extern FramebufferManagerBase *g_framebuffer_manager;
Expand Down
240 changes: 197 additions & 43 deletions Source/Core/VideoCommon/Src/RenderBase.cpp
View file
Expand Up @@ -67,12 +67,7 @@ int Renderer::s_target_height;
int Renderer::s_backbuffer_width;
int Renderer::s_backbuffer_height;

// ratio of backbuffer size and render area size
float Renderer::xScale;
float Renderer::yScale;

unsigned int Renderer::s_XFB_width;
unsigned int Renderer::s_XFB_height;
TargetRectangle Renderer::target_rc;

int Renderer::s_LastEFBScale;

Expand All @@ -81,6 +76,11 @@ bool Renderer::XFBWrited;
bool Renderer::s_EnableDLCachingAfterRecording;

unsigned int Renderer::prev_efb_format = (unsigned int)-1;
unsigned int Renderer::efb_scale_numeratorX = 1;
unsigned int Renderer::efb_scale_numeratorY = 1;
unsigned int Renderer::efb_scale_denominatorX = 1;
unsigned int Renderer::efb_scale_denominatorY = 1;
unsigned int Renderer::ssaa_multiplier = 1;


Renderer::Renderer() : frame_data(NULL), bLastFrameDumped(false)
Expand All @@ -98,6 +98,8 @@ Renderer::~Renderer()
// invalidate previous efb format
prev_efb_format = (unsigned int)-1;

efb_scale_numeratorX = efb_scale_numeratorY = efb_scale_denominatorX = efb_scale_denominatorY = ssaa_multiplier = 1;

#if defined _WIN32 || defined HAVE_LIBAV
if (g_ActiveConfig.bDumpFrames && bLastFrameDumped && bAVIDumping)
AVIDump::Stop();
Expand All @@ -121,71 +123,125 @@ void Renderer::RenderToXFB(u32 xfbAddr, u32 fbWidth, u32 fbHeight, const EFBRect
VideoFifo_CheckSwapRequestAt(xfbAddr, fbWidth, fbHeight);
XFBWrited = true;

// XXX: Without the VI, how would we know what kind of field this is? So
// just use progressive.
if (g_ActiveConfig.bUseXFB)
{
FramebufferManagerBase::CopyToXFB(xfbAddr, fbWidth, fbHeight, sourceRc,Gamma);
}
else
{
// XXX: Without the VI, how would we know what kind of field this is? So
// just use progressive.
g_renderer->Swap(xfbAddr, FIELD_PROGRESSIVE, fbWidth, fbHeight,sourceRc,Gamma);
Common::AtomicStoreRelease(s_swapRequested, false);
}
}

void Renderer::CalculateTargetScale(int x, int y, int &scaledX, int &scaledY)
int Renderer::EFBToScaledX(int x)
{
switch (g_ActiveConfig.iEFBScale)
{
case 0: // fractional
return (int)ssaa_multiplier * FramebufferManagerBase::ScaleToVirtualXfbWidth(x, s_backbuffer_width);

default:
return x * (int)ssaa_multiplier * (int)efb_scale_numeratorX / (int)efb_scale_denominatorX;
};
}

int Renderer::EFBToScaledY(int y)
{
switch (g_ActiveConfig.iEFBScale)
{
case 0: // fractional
return (int)ssaa_multiplier * FramebufferManagerBase::ScaleToVirtualXfbHeight(y, s_backbuffer_height);

default:
return y * (int)ssaa_multiplier * (int)efb_scale_numeratorY / (int)efb_scale_denominatorY;
};
}

void Renderer::CalculateTargetScale(int x, int y, int &scaledX, int &scaledY)
{
if (g_ActiveConfig.iEFBScale == 0 || g_ActiveConfig.iEFBScale == 1)
{
scaledX = x;
scaledY = y;
}
else
{
scaledX = x * (int)efb_scale_numeratorX / (int)efb_scale_denominatorX;
scaledY = y * (int)efb_scale_numeratorY / (int)efb_scale_denominatorY;
}
}

// return true if target size changed
bool Renderer::CalculateTargetSize(unsigned int framebuffer_width, unsigned int framebuffer_height, int multiplier)
{
int newEFBWidth, newEFBHeight;

// TODO: Ugly. Clean up
switch (s_LastEFBScale)
{
case 2: // 1x
efb_scale_numeratorX = efb_scale_numeratorY = 1;
efb_scale_denominatorX = efb_scale_denominatorY = 1;
break;

case 3: // 1.5x
scaledX = (x / 2) * 3;
scaledY = (y / 2) * 3;
efb_scale_numeratorX = efb_scale_numeratorY = 3;
efb_scale_denominatorX = efb_scale_denominatorY = 2;
break;

case 4: // 2x
scaledX = x * 2;
scaledY = y * 2;
efb_scale_numeratorX = efb_scale_numeratorY = 2;
efb_scale_denominatorX = efb_scale_denominatorY = 1;
break;

case 5: // 2.5x
scaledX = (x / 2) * 5;
scaledY = (y / 2) * 5;
efb_scale_numeratorX = efb_scale_numeratorY = 5;
efb_scale_denominatorX = efb_scale_denominatorY = 2;
break;

case 6: // 3x
scaledX = x * 3;
scaledY = y * 3;
efb_scale_numeratorX = efb_scale_numeratorY = 3;
efb_scale_denominatorX = efb_scale_denominatorY = 1;
break;

case 7: // 4x
scaledX = x * 4;
scaledY = y * 4;
efb_scale_numeratorX = efb_scale_numeratorY = 4;
efb_scale_denominatorX = efb_scale_denominatorY = 1;
break;
default:
scaledX = x;
scaledY = y;

default: // fractional & integral handled later
break;
};
}
}

// return true if target size changed
bool Renderer::CalculateTargetSize(int multiplier)
{
int newEFBWidth, newEFBHeight;
switch (s_LastEFBScale)
{
case 0: // fractional
newEFBWidth = (int)(EFB_WIDTH * xScale);
newEFBHeight = (int)(EFB_HEIGHT * yScale);
break;
case 1: // integral
newEFBWidth = EFB_WIDTH * (int)ceilf(xScale);
newEFBHeight = EFB_HEIGHT * (int)ceilf(yScale);
newEFBWidth = FramebufferManagerBase::ScaleToVirtualXfbWidth(EFB_WIDTH, framebuffer_width);
newEFBHeight = FramebufferManagerBase::ScaleToVirtualXfbHeight(EFB_HEIGHT, framebuffer_height);

if (s_LastEFBScale == 1)
{
newEFBWidth = ((newEFBWidth-1) / EFB_WIDTH + 1) * EFB_WIDTH;
newEFBHeight = ((newEFBHeight-1) / EFB_HEIGHT + 1) * EFB_HEIGHT;
}
efb_scale_numeratorX = newEFBWidth;
efb_scale_denominatorX = EFB_WIDTH;
efb_scale_numeratorY = newEFBHeight;
efb_scale_denominatorY = EFB_HEIGHT;
break;

default:
CalculateTargetScale(EFB_WIDTH, EFB_HEIGHT, newEFBWidth, newEFBHeight);
break;
}

newEFBWidth *= multiplier;
newEFBHeight *= multiplier;
ssaa_multiplier = multiplier;

if (newEFBWidth != s_target_width || newEFBHeight != s_target_height)
{
Expand Down Expand Up @@ -311,27 +367,125 @@ void Renderer::DrawDebugText()
}
}

void Renderer::CalculateXYScale(const TargetRectangle& dst_rect)
// TODO: remove
extern bool g_aspect_wide;

void Renderer::UpdateDrawRectangle(int backbuffer_width, int backbuffer_height)
{
if (g_ActiveConfig.bUseXFB && g_ActiveConfig.bUseRealXFB)
float FloatGLWidth = (float)backbuffer_width;
float FloatGLHeight = (float)backbuffer_height;
float FloatXOffset = 0;
float FloatYOffset = 0;

// The rendering window size
const float WinWidth = FloatGLWidth;
const float WinHeight = FloatGLHeight;

// Handle aspect ratio.
// Default to auto.
bool use16_9 = g_aspect_wide;

// Update aspect ratio hack values
// Won't take effect until next frame
// Don't know if there is a better place for this code so there isn't a 1 frame delay
if ( g_ActiveConfig.bWidescreenHack )
{
xScale = 1.0f;
yScale = 1.0f;
float source_aspect = use16_9 ? (16.0f / 9.0f) : (4.0f / 3.0f);
float target_aspect;

switch ( g_ActiveConfig.iAspectRatio )
{
case ASPECT_FORCE_16_9 :
target_aspect = 16.0f / 9.0f;
break;
case ASPECT_FORCE_4_3 :
target_aspect = 4.0f / 3.0f;
break;
case ASPECT_STRETCH :
target_aspect = WinWidth / WinHeight;
break;
default :
// ASPECT_AUTO == no hacking
target_aspect = source_aspect;
break;
}

float adjust = source_aspect / target_aspect;
if ( adjust > 1 )
{
// Vert+
g_Config.fAspectRatioHackW = 1;
g_Config.fAspectRatioHackH = 1/adjust;
}
else
{
// Hor+
g_Config.fAspectRatioHackW = adjust;
g_Config.fAspectRatioHackH = 1;
}
}
else
{
if (g_ActiveConfig.b3DVision)
// Hack is disabled
g_Config.fAspectRatioHackW = 1;
g_Config.fAspectRatioHackH = 1;
}

// Check for force-settings and override.
if (g_ActiveConfig.iAspectRatio == ASPECT_FORCE_16_9)
use16_9 = true;
else if (g_ActiveConfig.iAspectRatio == ASPECT_FORCE_4_3)
use16_9 = false;

if (g_ActiveConfig.iAspectRatio != ASPECT_STRETCH)
{
// The rendering window aspect ratio as a proportion of the 4:3 or 16:9 ratio
float Ratio = (WinWidth / WinHeight) / (!use16_9 ? (4.0f / 3.0f) : (16.0f / 9.0f));
// Check if height or width is the limiting factor. If ratio > 1 the picture is too wide and have to limit the width.
if (Ratio > 1.0f)
{
// This works, yet the version in the else doesn't. No idea why.
xScale = (float)(s_backbuffer_width-1) / (float)(s_XFB_width-1);
yScale = (float)(s_backbuffer_height-1) / (float)(s_XFB_height-1);
// Scale down and center in the X direction.
FloatGLWidth /= Ratio;
FloatXOffset = (WinWidth - FloatGLWidth) / 2.0f;
}
// The window is too high, we have to limit the height
else
{
xScale = (float)(dst_rect.right - dst_rect.left - 1) / (float)(s_XFB_width-1);
yScale = (float)(dst_rect.bottom - dst_rect.top - 1) / (float)(s_XFB_height-1);
// Scale down and center in the Y direction.
FloatGLHeight *= Ratio;
FloatYOffset = FloatYOffset + (WinHeight - FloatGLHeight) / 2.0f;
}
}

// -----------------------------------------------------------------------
// Crop the picture from 4:3 to 5:4 or from 16:9 to 16:10.
// Output: FloatGLWidth, FloatGLHeight, FloatXOffset, FloatYOffset
// ------------------
if (g_ActiveConfig.iAspectRatio != ASPECT_STRETCH && g_ActiveConfig.bCrop)
{
float Ratio = !use16_9 ? ((4.0f / 3.0f) / (5.0f / 4.0f)) : (((16.0f / 9.0f) / (16.0f / 10.0f)));
// The width and height we will add (calculate this before FloatGLWidth and FloatGLHeight is adjusted)
float IncreasedWidth = (Ratio - 1.0f) * FloatGLWidth;
float IncreasedHeight = (Ratio - 1.0f) * FloatGLHeight;
// The new width and height
FloatGLWidth = FloatGLWidth * Ratio;
FloatGLHeight = FloatGLHeight * Ratio;
// Adjust the X and Y offset
FloatXOffset = FloatXOffset - (IncreasedWidth * 0.5f);
FloatYOffset = FloatYOffset - (IncreasedHeight * 0.5f);
}

int XOffset = (int)(FloatXOffset + 0.5f);
int YOffset = (int)(FloatYOffset + 0.5f);
int iWhidth = (int)ceil(FloatGLWidth);
int iHeight = (int)ceil(FloatGLHeight);
iWhidth -= iWhidth % 4; // ensure divisibility by 4 to make it compatible with all the video encoders
iHeight -= iHeight % 4;

target_rc.left = XOffset;
target_rc.top = YOffset;
target_rc.right = XOffset + iWhidth;
target_rc.bottom = YOffset + iHeight;
}

void Renderer::SetWindowSize(int width, int height)
Expand Down

0 comments on commit 4ff9e03

Please sign in to comment.