mir/libreoffice
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

tdf#40534 correctly match page with memory slab

Browse Source 
LO has a page manager to match system memory backbuffers with
graphics memory on DX accelerated Windows. Internally this uses
an other rectangle implementation, the SurfaceRect, which had
some great comments like:

// a size of [0,0] therefore denotes a one-by-one rectangle.

In commit 230dbe2e43f3ee2cd285f9cdfe0d57e1ca08b8fe ("#144866# Add
one pixel border around textures, a bunch of drivers clobber those
with dirt), the allocation was increased by a pixel border, but
this doesn't work correctly, because now an allocation of the
page size wouldn't fit anymore into a page, because the pages size
is decreased before comparison. In the end the mixup suffered from
hard to handle off-by-one problems.

This patch fixes the bug, but eventually SurfaceRect should be
replaced by an extended basegfx::B2IBox. But since B2IBox uses two
ranges, instead of a point and a size, it would need a lot of
conversations to I2Point and I2Size objects with the current
Page::insert algorithm.

Change-Id: Ia725b4f8ed4fb270f2eb3734e492062bc7f13793
Reviewed-on: https://gerrit.libreoffice.org/80628
Tested-by: Jenkins
Reviewed-by: Jan-Marek Glogowski <glogow@fbihome.de>
This commit is contained in:
Jan-Marek Glogowski 2019-10-10 14:48:22 +02:00 committed by Jan-Marek Glogowski
parent 05e30f4a04
commit 194e7ce17a
2 changed files with 24 additions and 52 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
canvas/source/tools/page.cxx
View File

@ -118,7 +118,7 @@ namespace canvas
// the rectangle passed as argument has a valid
// location if and only if there's no intersection
// with existing areas.
SurfaceRect aBoundary(mpRenderModule->getPageSize()-basegfx::B2IVector(1,1));
SurfaceRect aBoundary(mpRenderModule->getPageSize());
if( !r.inside(aBoundary) )
return false;

74
canvas/source/tools/surfacerect.hxx
View File

@ -25,6 +25,16 @@
namespace canvas
{
/**
* This implements some equivalent to basegfx::B2IBox, but instead of two
* BasicBox ranges, it uses a position and a size. maPos and maSize could
* be replaced by:
* - B2IPoint(getMinX(), getMinY()) and
* - B2ISize(getMaxX()-getMinX(), getMaxY()-getMinY())
*
* The current allocation algorithm uses size and pos a lot. Not sure how
* time-critical any of this code is and if that would be a problem.
*/
struct SurfaceRect
{
::basegfx::B2IPoint maPos;
@ -36,22 +46,12 @@ namespace canvas
{
}
// coordinates contained in this rectangle are
// constrained to the following rules:
// 1) p.x >= pos.x
// 2) p.x <= pos.x+size.x
// 3) p.y >= pos.y
// 4) p.y <= pos.y+size.y
// in other words, 'size' means the number of pixels
// this rectangle encloses plus one. for example with pos[0,0]
// and size[512,512], p[512,512] would return inside.
// a size of [0,0] therefore denotes a one-by-one rectangle.
bool pointInside( sal_Int32 px, sal_Int32 py ) const
{
const sal_Int32 x1(maPos.getX());
const sal_Int32 y1(maPos.getY());
const sal_Int32 x2(maPos.getX()+maSize.getX());
const sal_Int32 y2(maPos.getY()+maSize.getY());
const sal_Int32 x2(x1 + maSize.getX());
const sal_Int32 y2(y1 + maSize.getY());
if(px < x1) return false;
if(px >= x2) return false;
if(py < y1) return false;
@ -59,58 +59,30 @@ namespace canvas
return true;
}
/// returns true if the horizontal line intersects the rect.
bool hLineIntersect( sal_Int32 lx1, sal_Int32 lx2, sal_Int32 ly ) const
{
const sal_Int32 x1(maPos.getX());
const sal_Int32 y1(maPos.getY());
const sal_Int32 x2(maPos.getX()+maSize.getX());
const sal_Int32 y2(maPos.getY()+maSize.getY());
if(ly < y1) return false;
if(ly >= y2) return false;
if((lx1 < x1) && (lx2 < x1)) return false;
if((lx1 >= x2) && (lx2 >= x2)) return false;
return true;
}
/// returns true if the vertical line intersects the rect.
bool vLineIntersect( sal_Int32 lx, sal_Int32 ly1, sal_Int32 ly2 ) const
{
const sal_Int32 x1(maPos.getX());
const sal_Int32 y1(maPos.getY());
const sal_Int32 x2(maPos.getX()+maSize.getX());
const sal_Int32 y2(maPos.getY()+maSize.getY());
if(lx < x1) return false;
if(lx >= x2) return false;
if((ly1 < y1) && (ly2 < y1)) return false;
if((ly1 >= y2) && (ly2 >= y2)) return false;
return true;
}
/// returns true if the passed rect intersects this one.
bool intersection( const SurfaceRect& r ) const
{
const sal_Int32 x1(maPos.getX());
const sal_Int32 y1(maPos.getY());
const sal_Int32 x2(maPos.getX()+maSize.getX());
const sal_Int32 y2(maPos.getY()+maSize.getY());
if(r.hLineIntersect(x1,x2,y1)) return true;
if(r.hLineIntersect(x1,x2,y2)) return true;
if(r.vLineIntersect(x1,y1,y2)) return true;
if(r.vLineIntersect(x2,y1,y2)) return true;
return false;
const sal_Int32 x1w(x1 + maSize.getX() - 1);
const sal_Int32 y1h(y1 + maSize.getY() - 1);
const sal_Int32 x2(r.maPos.getX());
const sal_Int32 y2(r.maPos.getY());
const sal_Int32 x2w(x2 + r.maSize.getX() - 1);
const sal_Int32 y2h(y2 + r.maSize.getY() - 1);
return !((x1w < x2) || (x2w < x1) || (y1h < y2) || (y2h < y1));
}
bool inside( const SurfaceRect& r ) const
{
const sal_Int32 x1(maPos.getX());
const sal_Int32 y1(maPos.getY());
const sal_Int32 x2(maPos.getX()+maSize.getX());
const sal_Int32 y2(maPos.getY()+maSize.getY());
const sal_Int32 x2(x1 + maSize.getX() - 1);
const sal_Int32 y2(y1 + maSize.getY() - 1);
if(!(r.pointInside(x1,y1))) return false;
if(!(r.pointInside(x2,y1))) return false;
if(!(r.pointInside(x2,y2))) return false;
if(!(r.pointInside(x1,y2))) return false;
return true;
}
};