OOTextureScaling.m File Reference

import "OOTextureScaling.h"
import "OOFunctionAttributes.h"
#include <stdlib.h>
import "OOLogging.h"
import "OOMaths.h"
import "OOCPUInfo.h"

Include dependency graph for OOTextureScaling.m:

Go to the source code of this file.

Macros
#define	DUMP_MIP_MAPS   0
#define	DUMP_SCALE   0
#define	DUMP_MIP_MAP_PREPARE(pl)
#define	DUMP_MIP_MAP_DUMP(px, w, h)
#define	DUMP_SCALE_PREPARE()
#define	DUMP_SCALE_DUMP(PM, stage)
#define	ACCUM2(PX, WT)
#define	CLEAR_ACCUM2()
#define	ACCUM2TOPX()
#define	ACCUM4(PX, WT)
#define	CLEAR_ACCUM4()
#define	ACCUM4TOPX()

Functions
static BOOL	GenerateMipMaps1 (void *textureBytes, OOPixMapDimension width, OOPixMapDimension height) NONNULL_FUNC
static BOOL	GenerateMipMaps2 (void *textureBytes, OOPixMapDimension width, OOPixMapDimension height) NONNULL_FUNC
static BOOL	GenerateMipMaps4 (void *textureBytes, OOPixMapDimension width, OOPixMapDimension height) NONNULL_FUNC
static void	ScaleToHalf_1_x1 (void *srcBytes, void *dstBytes, OOPixMapDimension srcWidth, OOPixMapDimension srcHeight) NONNULL_FUNC
static void	ScaleToHalf_2_x1 (void *srcBytes, void *dstBytes, OOPixMapDimension srcWidth, OOPixMapDimension srcHeight) NONNULL_FUNC
static void	ScaleToHalf_4_x1 (void *srcBytes, void *dstBytes, OOPixMapDimension srcWidth, OOPixMapDimension srcHeight) NONNULL_FUNC
static void	ScaleToHalf_1_x4 (void *srcBytes, void *dstBytes, OOPixMapDimension srcWidth, OOPixMapDimension srcHeight) NONNULL_FUNC
OOINLINE void	StretchVertically (OOPixMap srcPx, OOPixMap dstPx) ALWAYS_INLINE_FUNC
OOINLINE void	SqueezeVertically (OOPixMap pixMap, OOPixMapDimension dstHeight) ALWAYS_INLINE_FUNC
OOINLINE void	StretchHorizontally (OOPixMap srcPx, OOPixMap dstPx) ALWAYS_INLINE_FUNC
OOINLINE void	SqueezeHorizontally (OOPixMap pixMap, OOPixMapDimension dstHeight) ALWAYS_INLINE_FUNC
static void	StretchVerticallyN_x1 (OOPixMap srcPx, OOPixMap dstPx)
static void	SqueezeVertically1 (OOPixMap srcPx, OOPixMapDimension dstHeight)
static void	SqueezeVertically2 (OOPixMap srcPx, OOPixMapDimension dstHeight)
static void	SqueezeVertically4 (OOPixMap srcPx, OOPixMapDimension dstHeight)
static void	StretchHorizontally1 (OOPixMap srcPx, OOPixMap dstPx)
static void	StretchHorizontally2 (OOPixMap srcPx, OOPixMap dstPx)
static void	StretchHorizontally4 (OOPixMap srcPx, OOPixMap dstPx)
static void	SqueezeHorizontally1 (OOPixMap srcPx, OOPixMapDimension dstWidth)
static void	SqueezeHorizontally2 (OOPixMap srcPx, OOPixMapDimension dstWidth)
static void	SqueezeHorizontally4 (OOPixMap srcPx, OOPixMapDimension dstWidth)
static BOOL	EnsureCorrectDataSize (OOPixMap *pixMap, BOOL leaveSpaceForMipMaps) NONNULL_FUNC
static void	StretchVerticallyN_x4 (OOPixMap srcPx, OOPixMap dstPx)
OOPixMap	OOScalePixMap (OOPixMap srcPx, OOPixMapDimension dstWidth, OOPixMapDimension dstHeight, BOOL leaveSpaceForMipMaps)
BOOL	OOGenerateMipMaps (void *textureBytes, OOPixMapDimension width, OOPixMapDimension height, OOPixMapFormat format)

Macro Definition Documentation

ACCUM2

#define ACCUM2	(		PX,
			WT )

Value:

            do {                            \
            uint16_t px = PX;                       \
            uint_fast32_t wt = WT;                  \
            accumHi += (px & 0xFF00) * wt;          \
            accumLo += (px & 0x00FF) * wt;          \
            weight += wt;                           \
        } while (0)

Definition at line 1362 of file OOTextureScaling.m.

#define ACCUM2(PX, WT) do {                         \
            uint16_t px = PX;                       \
            uint_fast32_t wt = WT;                  \
            accumHi += (px & 0xFF00) * wt;          \
            accumLo += (px & 0x00FF) * wt;          \
            weight += wt;                           \
        } while (0)

Referenced by SqueezeHorizontally2(), and SqueezeVertically2().

ACCUM2TOPX

#define ACCUM2TOPX

(

)

Value:

            (                           \
            ((accumHi / weight) & 0xFF00) |         \
            ((accumLo / weight) & 0x00FF)           \
        )

Definition at line 1376 of file OOTextureScaling.m.

#define ACCUM2TOPX()    (                           \
            ((accumHi / weight) & 0xFF00) |         \
            ((accumLo / weight) & 0x00FF)           \
        )

Referenced by SqueezeHorizontally2(), and SqueezeVertically2().

ACCUM4

#define ACCUM4	(		PX,
			WT )

Value:

            do {                            \
            uint32_t px = PX;                       \
            uint_fast32_t wt = WT;                  \
            ag = ((px & 0xFF00FF00) >> 8) * wt;     \
            br = (px & 0x00FF00FF) * wt;            \
            accum1 += ag >> 16;                     \
            accum2 += br >> 16;                     \
            accum3 += ag & 0xFFFF;                  \
            accum4 += br & 0xFFFF;                  \
            weight += wt;                           \
        } while (0)

Definition at line 1513 of file OOTextureScaling.m.

#define ACCUM4(PX, WT) do {                         \
            uint32_t px = PX;                       \
            uint_fast32_t wt = WT;                  \
            ag = ((px & 0xFF00FF00) >> 8) * wt;     \
            br = (px & 0x00FF00FF) * wt;            \
            accum1 += ag >> 16;                     \
            accum2 += br >> 16;                     \
            accum3 += ag & 0xFFFF;                  \
            accum4 += br & 0xFFFF;                  \
            weight += wt;                           \
        } while (0)

Referenced by SqueezeHorizontally4(), and SqueezeVertically4().

ACCUM4TOPX

#define ACCUM4TOPX

(

)

Value:

            (                           \
            (((accum1 / weight) & 0xFF) << 24) |    \
            (((accum3 / weight) & 0xFF) << 8)  |    \
            (((accum2 / weight) & 0xFF) << 16) |    \
            ((accum4 / weight) & 0xFF)              \
        )

Definition at line 1539 of file OOTextureScaling.m.

#define ACCUM4TOPX()    (                           \
            (((accum1 / weight) & 0xFF) << 24) |    \
            (((accum3 / weight) & 0xFF) << 8)  |    \
            (((accum2 / weight) & 0xFF) << 16) |    \
            ((accum4 / weight) & 0xFF)              \
        )

Referenced by SqueezeHorizontally4(), and SqueezeVertically4().

CLEAR_ACCUM2

#define CLEAR_ACCUM2

(

)

Value:

            do {                            \
            accumHi = 0;                            \
            accumLo = 0;                            \
            weight = 0;                             \
        } while (0)

Definition at line 1370 of file OOTextureScaling.m.

#define CLEAR_ACCUM2() do {                         \
            accumHi = 0;                            \
            accumLo = 0;                            \
            weight = 0;                             \
        } while (0)

Referenced by SqueezeHorizontally2(), and SqueezeVertically2().

CLEAR_ACCUM4

#define CLEAR_ACCUM4

(

)

Value:

            do {                            \
            accum1 = 0;                             \
            accum2 = 0;                             \
            accum3 = 0;                             \
            accum4 = 0;                             \
            weight = 0;                             \
        } while (0)

Definition at line 1525 of file OOTextureScaling.m.

#define CLEAR_ACCUM4() do {                         \
            accum1 = 0;                             \
            accum2 = 0;                             \
            accum3 = 0;                             \
            accum4 = 0;                             \
            weight = 0;                             \
        } while (0)

Referenced by SqueezeHorizontally4(), and SqueezeVertically4().

DUMP_MIP_MAP_DUMP

#define DUMP_MIP_MAP_DUMP	(		px,
			w,
			h )

Value:

do { (void)px; (void)w; (void)h; } while (0)

Definition at line 233 of file OOTextureScaling.m.

Referenced by GenerateMipMaps1(), GenerateMipMaps2(), and GenerateMipMaps4().

DUMP_MIP_MAP_PREPARE

#define DUMP_MIP_MAP_PREPARE

(

pl

)

Value:

do { (void)pl; } while (0)

Definition at line 232 of file OOTextureScaling.m.

Referenced by GenerateMipMaps1(), GenerateMipMaps2(), and GenerateMipMaps4().

DUMP_MIP_MAPS

#define DUMP_MIP_MAPS   0

Definition at line 36 of file OOTextureScaling.m.

DUMP_SCALE

#define DUMP_SCALE   0

Definition at line 37 of file OOTextureScaling.m.

DUMP_SCALE_DUMP

#define DUMP_SCALE_DUMP	(		PM,
			stage )

Value:

do {} while (0)

Definition at line 241 of file OOTextureScaling.m.

Referenced by OOScalePixMap().

DUMP_SCALE_PREPARE

#define DUMP_SCALE_PREPARE

(

)

Definition at line 240 of file OOTextureScaling.m.

Referenced by OOScalePixMap().

Function Documentation

EnsureCorrectDataSize()

static BOOL EnsureCorrectDataSize ( OOPixMap * pixMap, BOOL leaveSpaceForMipMaps )

static

Definition at line 1674 of file OOTextureScaling.m.

{
    size_t              correctSize;
    void                *bytes = NULL;
    
    correctSize = pixMap->rowBytes * pixMap->height;
    
    // correctSize > 0 check is redundant, but static analyzer (checker-262) doesn't know that. -- Ahruman 2012-03-17
    NSCParameterAssert(OOIsValidPixMap(*pixMap) && correctSize > 0);
    
    /*  Ensure that the block is not too small. This needs to be done before
        adding the mip-map space, as the texture may have been shrunk in place
        without being grown for mip-maps.
    */
    if (EXPECT_NOT(pixMap->bufferSize < correctSize))
    {
        OOLogGenericParameterError();
        return NO;
    }
    
    if (leaveSpaceForMipMaps)  correctSize = correctSize * 4 / 3;
    if (correctSize != pixMap->bufferSize)
    {
        bytes = realloc(pixMap->pixels, correctSize);
        if (EXPECT_NOT(bytes == NULL))  free(pixMap->pixels);
        pixMap->pixels = bytes;
        pixMap->bufferSize = correctSize;
    }
    
    return YES;
}

References OOPixMap::bufferSize, EXPECT_NOT, OOPixMap::height, OOIsValidPixMap(), OOLogGenericParameterError, OOPixMap::pixels, and OOPixMap::rowBytes.

Referenced by OOScalePixMap().

Here is the call graph for this function:

Here is the caller graph for this function:

GenerateMipMaps1()

static BOOL GenerateMipMaps1 ( void * textureBytes, OOPixMapDimension width, OOPixMapDimension height )

static

Definition at line 377 of file OOTextureScaling.m.

{
    OOPixMapDimension       w = width, h = height;
    uint8_t                 *curr, *next;
    
    DUMP_MIP_MAP_PREPARE(1);
    curr = textureBytes;
    
#if OOLITE_NATIVE_64_BIT
    while (8 < w && 1 < h)
    {
        DUMP_MIP_MAP_DUMP(curr, w, h);
        
        next = curr + w * h;
        ScaleToHalf_1_x8(curr, next, w, h);
        
        w >>= 1;
        h >>= 1;
        curr = next;
    }
#else
    while (4 < w && 1 < h)
    {
        DUMP_MIP_MAP_DUMP(curr, w, h);
        
        next = curr + w * h;
        ScaleToHalf_1_x4(curr, next, w, h);
        
        w >>= 1;
        h >>= 1;
        curr = next;
    }
#endif
    
    while (1 < w && 1 < h)
    {
        DUMP_MIP_MAP_DUMP(curr, w, h);
        
        next = curr + w * h;
        ScaleToHalf_1_x1(curr, next, w, h);
        
        w >>= 1;
        h >>= 1;
        curr = next;
    }
    
    DUMP_MIP_MAP_DUMP(curr, w, h);
    
    // TODO: handle residual 1xN/Nx1 mips. For now, we just limit maximum mip level for non-square textures.
    return YES;
}

References DUMP_MIP_MAP_DUMP, DUMP_MIP_MAP_PREPARE, ScaleToHalf_1_x1(), and ScaleToHalf_1_x4().

Referenced by OOGenerateMipMaps().

Here is the call graph for this function:

Here is the caller graph for this function:

GenerateMipMaps2()

static BOOL GenerateMipMaps2 ( void * textureBytes, OOPixMapDimension width, OOPixMapDimension height )

static

Definition at line 599 of file OOTextureScaling.m.

{
    OOPixMapDimension       w = width, h = height;
    uint16_t                *curr, *next;
    
    DUMP_MIP_MAP_PREPARE(2);
    curr = textureBytes;
    
    // TODO: multiple pixel two-plane scalers.
#if 0
#if OOLITE_NATIVE_64_BIT
    while (4 < w && 1 < h)
    {
        DUMP_MIP_MAP_DUMP(curr, w, h);
        
        next = curr + w * h;
        ScaleToHalf_2_x4(curr, next, w, h);
        
        w >>= 1;
        h >>= 1;
        curr = next;
    }
#else
    while (2 < w && 1 < h)
    {
        DUMP_MIP_MAP_DUMP(curr, w, h);
        
        next = curr + w * h;
        ScaleToHalf_2_x2(curr, next, w, h);
        
        w >>= 1;
        h >>= 1;
        curr = next;
    }
#endif
#endif
    
    while (1 < w && 1 < h)
    {
        DUMP_MIP_MAP_DUMP(curr, w, h);
        
        next = curr + w * h;
        ScaleToHalf_2_x1(curr, next, w, h);
        
        w >>= 1;
        h >>= 1;
        curr = next;
    }
    
    DUMP_MIP_MAP_DUMP(curr, w, h);
    
    // TODO: handle residual 1xN/Nx1 mips. For now, we just limit maximum mip level for non-square textures.
    return YES;
}

References DUMP_MIP_MAP_DUMP, DUMP_MIP_MAP_PREPARE, and ScaleToHalf_2_x1().

Referenced by OOGenerateMipMaps().

Here is the call graph for this function:

Here is the caller graph for this function:

GenerateMipMaps4()

static BOOL GenerateMipMaps4 ( void * textureBytes, OOPixMapDimension width, OOPixMapDimension height )

static

Definition at line 696 of file OOTextureScaling.m.

{
    OOPixMapDimension       w = width, h = height;
    uint32_t                *curr, *next;
    
    DUMP_MIP_MAP_PREPARE(4);
    curr = textureBytes;
    
#if OOLITE_NATIVE_64_BIT
    while (2 < w && 1 < h)
    {
        DUMP_MIP_MAP_DUMP(curr, w, h);
        
        next = curr + w * h;
        ScaleToHalf_4_x2(curr, next, w, h);
        
        w >>= 1;
        h >>= 1;
        curr = next;
    }
    if (EXPECT(1 < w && 1 < h))
    {
        DUMP_MIP_MAP_DUMP(curr, w, h);
        
        next = curr + w * h;
        ScaleToHalf_4_x1(curr, next, w, h);
        
        w >>= 1;
        h >>= 1;
    }
#else
    while (1 < w && 1 < h)
    {
        DUMP_MIP_MAP_DUMP(curr, w, h);
        
        next = curr + w * h;
        ScaleToHalf_4_x1(curr, next, w, h);
        
        w >>= 1;
        h >>= 1;
        curr = next;
    }
#endif
    
    DUMP_MIP_MAP_DUMP(curr, w, h);
    
    // TODO: handle residual 1xN/Nx1 mips. For now, we just limit maximum mip level for non-square textures.
    return YES;
}

References DUMP_MIP_MAP_DUMP, DUMP_MIP_MAP_PREPARE, EXPECT, and ScaleToHalf_4_x1().

Referenced by OOGenerateMipMaps().

Here is the call graph for this function:

Here is the caller graph for this function:

OOGenerateMipMaps()

BOOL OOGenerateMipMaps	(	void *	textureBytes,
		OOPixMapDimension	width,
		OOPixMapDimension	height,
		OOPixMapFormat	format )

Definition at line 343 of file OOTextureScaling.m.

{
    if (EXPECT_NOT(width != OORoundUpToPowerOf2_PixMap(width) || height != OORoundUpToPowerOf2_PixMap(height)))
    {
        OOLog(kOOLogParameterError, @"Non-power-of-two dimensions (%ux%u) passed to %s() - ignoring, data will be junk.", width, height, __PRETTY_FUNCTION__);
        return NO;
    }
    if (EXPECT_NOT(textureBytes == NULL))
    {
        OOLog(kOOLogParameterError, @"%@", @"NULL texture pointer passed to GenerateMipMaps().");
        return NO;
    }
    
    switch (format)
    {
        case kOOPixMapRGBA:
            return GenerateMipMaps4(textureBytes, width, height);
            
        case kOOPixMapGrayscale:
            return GenerateMipMaps1(textureBytes, width, height);
            
        case kOOPixMapGrayscaleAlpha:
            return GenerateMipMaps2(textureBytes, width, height);
            
        case kOOPixMapInvalidFormat:
            break;
    }
    
 
    OOLog(kOOLogParameterError, @"%s(): bad pixmap format (%@) - ignoring, data will be junk.", __PRETTY_FUNCTION__, OOPixMapFormatName(format));
    return NO;
}

References EXPECT_NOT, GenerateMipMaps1(), GenerateMipMaps2(), GenerateMipMaps4(), kOOLogParameterError, kOOPixMapGrayscale, kOOPixMapGrayscaleAlpha, kOOPixMapInvalidFormat, kOOPixMapRGBA, OOLog, OOPixMapFormatName(), and OORoundUpToPowerOf2_PixMap.

Here is the call graph for this function:

OOScalePixMap()

OOPixMap OOScalePixMap	(	OOPixMap	srcPx,
		OOPixMapDimension	dstWidth,
		OOPixMapDimension	dstHeight,
		BOOL	leaveSpaceForMipMaps )

Definition at line 245 of file OOTextureScaling.m.

{
    OOPixMap            dstPx = {0}, sparePx = {0};
    BOOL                OK = YES;
    
    //  Sanity check.
    if (EXPECT_NOT(!OOIsValidPixMap(srcPx)))
    {
        OOLogGenericParameterError();
        free(srcPx.pixels);
        return kOONullPixMap;
    }
    
    DUMP_SCALE_PREPARE();
    DUMP_SCALE_DUMP(srcPx, @"initial");
    
    if (srcPx.height < dstHeight)
    {
        // Stretch vertically. This requires a separate buffer.
        size_t dstSize = srcPx.rowBytes * dstHeight;
        if (leaveSpaceForMipMaps && dstWidth <= srcPx.width)  dstSize = dstSize * 4 / 3;
        
        dstPx = OOAllocatePixMap(srcPx.width, dstHeight, srcPx.format, 0, dstSize);
        if (EXPECT_NOT(!OOIsValidPixMap(dstPx)))  { OK = NO; goto FAIL; }
        
        StretchVertically(srcPx, dstPx);
        DUMP_SCALE_DUMP(dstPx, @"stretched vertically");
        
        sparePx = srcPx;
        srcPx = dstPx;
    }
    else if (dstHeight < srcPx.height)
    {
        // Squeeze vertically. This can be done in-place.
        SqueezeVertically(srcPx, dstHeight);
        srcPx.height = dstHeight;
        DUMP_SCALE_DUMP(srcPx, @"squeezed vertically");
    }
    
    if (srcPx.width < dstWidth)
    {
        // Stretch horizontally. This requires a separate buffer.
        size_t dstSize = OOPixMapBytesPerPixel(srcPx) * dstWidth * srcPx.height;
        if (leaveSpaceForMipMaps)  dstSize = dstSize * 4 / 3;
        
        if (dstSize <= sparePx.bufferSize)
        {
            dstPx = OOMakePixMap(sparePx.pixels, dstWidth, srcPx.height, srcPx.format, 0, sparePx.bufferSize);
            sparePx = kOONullPixMap;
        }
        else
        {
            dstPx = OOAllocatePixMap(dstWidth, srcPx.height, srcPx.format, 0, dstSize);
        }
        if (EXPECT_NOT(!OOIsValidPixMap(dstPx)))  { OK = NO; goto FAIL; }
        
        StretchHorizontally(srcPx, dstPx);
        DUMP_SCALE_DUMP(dstPx, @"stretched horizontally");
    }
    else if (dstWidth < srcPx.width)
    {
        // Squeeze horizontally. This can be done in-place.
        SqueezeHorizontally(srcPx, dstWidth);
        
        dstPx = srcPx;
        dstPx.width = dstWidth;
        dstPx.rowBytes = dstPx.width * OOPixMapBytesPerPixel(dstPx);
        DUMP_SCALE_DUMP(dstPx, @"squeezed horizontally");
    }
    else
    {
        // No horizontal scaling.
        dstPx = srcPx;
    }
    
    // Avoid a potential double free (if the realloc in EnsureCorrectDataSize() relocates the block).
    if (srcPx.pixels == dstPx.pixels)  srcPx.pixels = NULL;
    
    // dstPx is now the result.
    OK = EnsureCorrectDataSize(&dstPx, leaveSpaceForMipMaps);
    
FAIL:
    free(srcPx.pixels);
    if (sparePx.pixels != dstPx.pixels && sparePx.pixels != srcPx.pixels)
    {
        free(sparePx.pixels);
    }
    if (!OK)
    {
        free(dstPx.pixels);
        dstPx.pixels = NULL;
    }
    
    return OK ? dstPx : kOONullPixMap;
}

References DUMP_SCALE_DUMP, DUMP_SCALE_PREPARE, EnsureCorrectDataSize(), EXPECT_NOT, FAIL, OOPixMap::format, OOPixMap::height, kOONullPixMap, OOAllocatePixMap(), OOIsValidPixMap(), OOLogGenericParameterError, OOMakePixMap(), OOPixMapBytesPerPixel(), OOPixMap::pixels, OOPixMap::rowBytes, SqueezeHorizontally(), SqueezeVertically(), StretchHorizontally(), StretchVertically(), and OOPixMap::width.

Referenced by OOCombinedEmissionMapGenerator::anisotropy, and OOConvertCubeMapToLatLong().

Here is the call graph for this function:

Here is the caller graph for this function:

ScaleToHalf_1_x1()

static void ScaleToHalf_1_x1 ( void * srcBytes, void * dstBytes, OOPixMapDimension srcWidth, OOPixMapDimension srcHeight )

static

Definition at line 430 of file OOTextureScaling.m.

{
    OOPixMapDimension       x, y;
    uint8_t                 *src0, *src1, *dst;
    uint_fast8_t            px00, px01, px10, px11;
    uint_fast16_t           sum;
    
    src0 = srcBytes;
    src1 = src0 + srcWidth;
    dst = dstBytes;
    
    y = srcHeight >> 1;
    do
    {
        x = srcWidth >> 1;
        do
        {
            // Read four pixels in a square...
            px00 = *src0++;
            px01 = *src0++;
            px10 = *src1++;
            px11 = *src1++;
            
            // ...add them together...
            sum = px00 + px01 + px10 + px11;
            
            // ...shift the sum into place...
            sum >>= 2;
            
            // ...and write output pixel.
                *dst++ = sum;
        } while (--x);
        
        // Skip a row for each source row
        src0 = src1;
        src1 += srcWidth;
    } while (--y);
}

References x, and y.

Referenced by GenerateMipMaps1().

Here is the caller graph for this function:

ScaleToHalf_1_x4()

static void ScaleToHalf_1_x4 ( void * srcBytes, void * dstBytes, OOPixMapDimension srcWidth, OOPixMapDimension srcHeight )

static

Definition at line 472 of file OOTextureScaling.m.

{
    OOPixMapDimension       x, y;
    uint32_t                *src0, *src1, *dst;
    uint_fast32_t           px00, px01, px10, px11;
    uint_fast32_t           sum0, sum1;
    
    srcWidth >>= 2; // Four (output) pixels at a time
    src0 = srcBytes;
    src1 = src0 + srcWidth;
    dst = dstBytes;
    
    y = srcHeight >> 1;
    do
    {
        x = srcWidth >> 1;
        do
        {
            // Read 8 pixels in a 4x2 rectangle...
            px00 = *src0++;
            px01 = *src0++;
            px10 = *src1++;
            px11 = *src1++;
            
            // ...add them together.
            sum0 =  (px00 & 0x00FF00FF) +
                    (px10 & 0x00FF00FF) +
                    ((px00 & 0xFF00FF00) >> 8) +
                    ((px10 & 0xFF00FF00) >> 8);
            sum1 =  (px01 & 0x00FF00FF) +
                    (px11 & 0x00FF00FF) +
                    ((px01 & 0xFF00FF00) >> 8) +
                    ((px11 & 0xFF00FF00) >> 8);
            
            // ...swizzle the sums around...
#if OOLITE_BIG_ENDIAN
            sum0 = ((sum0 << 6) & 0xFF000000) | ((sum0 << 14) & 0x00FF0000);
            sum1 = ((sum1 >> 10) & 0x0000FF00) | ((sum1 >>2) & 0x000000FF);
#elif OOLITE_LITTLE_ENDIAN
            sum0 = ((sum0 >> 10) & 0x0000FF00) | ((sum0 >>2) & 0x000000FF);
            sum1 = ((sum1 << 6) & 0xFF000000) | ((sum1 << 14) & 0x00FF0000);
#else
            #error Neither OOLITE_BIG_ENDIAN nor OOLITE_LITTLE_ENDIAN is defined as nonzero!
#endif
            
            // ...and write output pixel.
                *dst++ = sum0 | sum1;
        } while (--x);
        
        // Skip a row for each source row
        src0 = src1;
        src1 += srcWidth;
    } while (--y);
}

References x, and y.

Referenced by GenerateMipMaps1().

Here is the caller graph for this function:

ScaleToHalf_2_x1()

static void ScaleToHalf_2_x1 ( void * srcBytes, void * dstBytes, OOPixMapDimension srcWidth, OOPixMapDimension srcHeight )

static

Definition at line 655 of file OOTextureScaling.m.

{
    OOPixMapDimension       x, y;
    uint16_t                *src0, *src1, *dst;
    uint_fast16_t           px00, px01, px10, px11;
    uint_fast32_t           sumHi, sumLo;
    
    src0 = srcBytes;
    src1 = src0 + srcWidth;
    dst = dstBytes;
    
    y = srcHeight >> 1;
    do
    {
        x = srcWidth >> 1;
        do
        {
            // Read four pixels in a square...
            px00 = *src0++;
            px01 = *src0++;
            px10 = *src1++;
            px11 = *src1++;
            
            // ...add them together...
            sumHi = (px00 & 0xFF00) + (px01 & 0xFF00) + (px10 & 0xFF00) + (px11 & 0xFF00);
            sumLo = (px00 & 0x00FF) + (px01 & 0x00FF) + (px10 & 0x00FF) + (px11 & 0x00FF);
            
            // ...merge and shift the sum into place...
            sumLo = ((sumHi & 0x3FC00) | sumLo) >> 2;
            
            // ...and write output pixel.
            *dst++ = sumLo;
        } while (--x);
        
        // Skip a row for each source row
        src0 = src1;
        src1 += srcWidth;
    } while (--y);
}

References x, and y.

Referenced by GenerateMipMaps2().

Here is the caller graph for this function:

ScaleToHalf_4_x1()

static void ScaleToHalf_4_x1 ( void * srcBytes, void * dstBytes, OOPixMapDimension srcWidth, OOPixMapDimension srcHeight )

static

Definition at line 747 of file OOTextureScaling.m.

{
    OOPixMapDimension       x, y;
    uint32_t                *src0, *src1, *dst;
    uint_fast32_t           px00, px01, px10, px11;
    
    /*  We treat channel layout as ABGR -- actual layout doesn't matter since
        each channel is handled the same. We use two accumulators, with
        alternating channels, so overflow doesn't cross channel boundaries,
        while having less overhead than one accumulator per channel.
    */
    uint_fast32_t           ag, br;
    
    src0 = srcBytes;
    src1 = src0 + srcWidth;
    dst = dstBytes;
    
    y = srcHeight >> 1;
    do
    {
        x = srcWidth >> 1;
        do
        {
            // Read four pixels in a square...
            px00 = *src0++;
            px01 = *src0++;
            px10 = *src1++;
            px11 = *src1++;
            
            // ...and add them together, channel by channel.
            ag =  (px00 & 0xFF00FF00) >> 8;
            br =  (px00 & 0x00FF00FF);
            ag += (px01 & 0xFF00FF00) >> 8;
            br += (px01 & 0x00FF00FF);
            ag += (px10 & 0xFF00FF00) >> 8;
            br += (px10 & 0x00FF00FF);
            ag += (px11 & 0xFF00FF00) >> 8;
            br += (px11 & 0x00FF00FF);
            
            // Shift the sums into place...
            ag <<= 6;
            br >>= 2;
            
            // ...and write output pixel.
            *dst++ = (ag & 0xFF00FF00) | (br & 0x00FF00FF);
        } while (--x);
        
        // Skip a row for each source row
        src0 = src1;
        src1 += srcWidth;
    } while (--y);
}

References x, and y.

Referenced by GenerateMipMaps4().

Here is the caller graph for this function:

SqueezeHorizontally()

OOINLINE void SqueezeHorizontally	(	OOPixMap	pixMap,
		OOPixMapDimension	dstHeight )

Definition at line 187 of file OOTextureScaling.m.

{
    switch (pixMap.format)
    {
        case kOOPixMapRGBA:
            SqueezeHorizontally4(pixMap, dstHeight);
            return;
            
        case kOOPixMapGrayscale:
            SqueezeHorizontally1(pixMap, dstHeight);
            return;
            
        case kOOPixMapGrayscaleAlpha:
            SqueezeHorizontally2(pixMap, dstHeight);
            return;
            
        case kOOPixMapInvalidFormat:
            break;
    }
    
#ifndef NDEBUG
    [NSException raise:NSInternalInconsistencyException format:@"Unsupported pixmap format in scaler: %@", OOPixMapFormatName(pixMap.format)];
#else
    abort();
#endif  
}

References OOPixMap::format, kOOPixMapGrayscale, kOOPixMapGrayscaleAlpha, kOOPixMapInvalidFormat, kOOPixMapRGBA, SqueezeHorizontally1(), SqueezeHorizontally2(), and SqueezeHorizontally4().

Referenced by OOScalePixMap().

Here is the call graph for this function:

Here is the caller graph for this function:

SqueezeHorizontally1()

static void SqueezeHorizontally1 ( OOPixMap srcPx, OOPixMapDimension dstWidth )

static

Definition at line 1230 of file OOTextureScaling.m.

{
    uint8_t             *src, *srcStart, *dst;
    uint8_t             borderPx;
    uint_fast32_t       x, y, xCount, endX;
    size_t              srcRowBytes;
    uint_fast32_t       endFractX, deltaX;
    uint_fast32_t       accum, weight;
    uint_fast8_t        borderWeight;
    
    NSCParameterAssert(OOIsValidPixMap(srcPx) && OOPixMapBytesPerPixel(srcPx) == 1);
    
    srcStart = srcPx.pixels;
    dst = srcStart; // Output is placed in same buffer, without line padding.
    srcRowBytes = srcPx.rowBytes;
    
    deltaX = (srcPx.width << 12) / dstWidth;
    
    for (y = 0; y != srcPx.height; ++y)
    {
        borderPx = *srcStart;
        endFractX = 0;
        borderWeight = 0;
        
        src = srcStart;
        
        x = 0;
        xCount = dstWidth;
        while (xCount--)
        {
            endFractX += deltaX;
            endX = endFractX >> 12;
            
            borderWeight = 0xFF - borderWeight;
            accum = borderPx * borderWeight;
            weight = borderWeight;
            
            borderWeight = (endFractX >> 4) & 0xFF;
            weight += borderWeight;
            
            for (;;)
            {
                ++x;
                if (EXPECT(x == endX))
                {
                    if (EXPECT(xCount))  borderPx = *++src;
                    accum += borderPx * borderWeight;
                    break;
                }
                else
                {
                    accum += *++src * 0xFF;
                    weight += 0xFF;
                }
            }
            
            *dst++ = accum / weight;
        }
        
        srcStart = (uint8_t *)((char *)srcStart + srcRowBytes);
    }
}

References EXPECT, OOPixMap::height, OOIsValidPixMap(), OOPixMapBytesPerPixel(), OOPixMap::pixels, OOPixMap::rowBytes, OOPixMap::width, x, and y.

Referenced by SqueezeHorizontally().

Here is the call graph for this function:

Here is the caller graph for this function:

SqueezeHorizontally2()

static void SqueezeHorizontally2 ( OOPixMap srcPx, OOPixMapDimension dstWidth )

static

Definition at line 1382 of file OOTextureScaling.m.

{
    uint16_t            *src, *srcStart, *dst;
    uint16_t            borderPx;
    uint_fast32_t       x, y, xCount, endX;
    size_t              srcRowBytes;
    uint_fast32_t       endFractX, deltaX;
    uint_fast32_t       accumHi, accumLo, weight;
    uint_fast8_t        borderWeight;
    
    NSCParameterAssert(OOIsValidPixMap(srcPx) && OOPixMapBytesPerPixel(srcPx) == 2);
    
    srcStart = srcPx.pixels;
    dst = srcStart; // Output is placed in same buffer, without line padding.
    srcRowBytes = srcPx.rowBytes;
    
    deltaX = (srcPx.width << 12) / dstWidth;
    
    for (y = 0; y != srcPx.height; ++y)
    {
        borderPx = *srcStart;
        endFractX = 0;
        borderWeight = 0;
        
        src = srcStart;
        
        x = 0;
        xCount = dstWidth;
        while (xCount--)
        {
            endFractX += deltaX;
            endX = endFractX >> 12;
            
            CLEAR_ACCUM2();
            
            borderWeight = 0xFF - borderWeight;
            ACCUM2(borderPx, borderWeight);
            
            borderWeight = (endFractX >> 4) & 0xFF;
            
            for (;;)
            {
                ++x;
                if (EXPECT(x == endX))
                {
                    if (EXPECT(xCount))  borderPx = *++src;
                    ACCUM2(borderPx, borderWeight);
                    break;
                }
                else
                {
                    ACCUM2(*++src, 0xFF);
                }
            }
            
            *dst++ = ACCUM2TOPX();
        }
        
        srcStart = (uint16_t *)((char *)srcStart + srcRowBytes);
    }
}

References ACCUM2, ACCUM2TOPX, CLEAR_ACCUM2, EXPECT, OOPixMap::height, OOIsValidPixMap(), OOPixMapBytesPerPixel(), OOPixMap::pixels, OOPixMap::rowBytes, OOPixMap::width, x, and y.

Referenced by SqueezeHorizontally().

Here is the call graph for this function:

Here is the caller graph for this function:

SqueezeHorizontally4()

static void SqueezeHorizontally4 ( OOPixMap srcPx, OOPixMapDimension dstWidth )

static

Definition at line 1547 of file OOTextureScaling.m.

{
    uint32_t            *src, *srcStart, *dst;
    uint32_t            borderPx, ag, br;
    uint_fast32_t       x, y, xCount, endX;
    size_t              srcRowBytes;
    uint_fast32_t       endFractX, deltaX;
    uint_fast32_t       accum1, accum2, accum3, accum4, weight;
    uint_fast8_t        borderWeight;
    
    NSCParameterAssert(OOIsValidPixMap(srcPx) && OOPixMapBytesPerPixel(srcPx) == 4);
    
    srcStart = srcPx.pixels;
    dst = srcStart; // Output is placed in same buffer, without line padding.
    srcRowBytes = srcPx.rowBytes;
    
    deltaX = (srcPx.width << 12) / dstWidth;
    
    for (y = 0; y != srcPx.height; ++y)
    {
        borderPx = *srcStart;
        endFractX = 0;
        borderWeight = 0;
        
        src = srcStart;
        
        x = 0;
        xCount = dstWidth;
        while (xCount--)
        {
            endFractX += deltaX;
            endX = endFractX >> 12;
            
            CLEAR_ACCUM4();
            
            borderWeight = 0xFF - borderWeight;
            ACCUM4(borderPx, borderWeight);
            
            borderWeight = (endFractX >> 4) & 0xFF;
            
            for (;;)
            {
                ++x;
                if (EXPECT(x == endX))
                {
                    if (EXPECT(xCount))  borderPx = *++src;
                    ACCUM4(borderPx, borderWeight);
                    break;
                }
                else
                {
                    ACCUM4(*++src, 0xFF);
                }
            }
            
            *dst++ = ACCUM4TOPX();
        }
        
        srcStart = (uint32_t *)((char *)srcStart + srcRowBytes);
    }
}

References ACCUM4, ACCUM4TOPX, CLEAR_ACCUM4, EXPECT, OOPixMap::height, OOIsValidPixMap(), OOPixMapBytesPerPixel(), OOPixMap::pixels, OOPixMap::rowBytes, OOPixMap::width, x, and y.

Referenced by SqueezeHorizontally().

Here is the call graph for this function:

Here is the caller graph for this function:

SqueezeVertically()

OOINLINE void SqueezeVertically	(	OOPixMap	pixMap,
		OOPixMapDimension	dstHeight )

Definition at line 129 of file OOTextureScaling.m.

{
    switch (pixMap.format)
    {
        case kOOPixMapRGBA:
            SqueezeVertically4(pixMap, dstHeight);
            return;
            
        case kOOPixMapGrayscale:
            SqueezeVertically1(pixMap, dstHeight);
            return;
            
        case kOOPixMapGrayscaleAlpha:
            SqueezeVertically2(pixMap, dstHeight);
            return;
            
        case kOOPixMapInvalidFormat:
            break;
    }
    
#ifndef NDEBUG
    [NSException raise:NSInternalInconsistencyException format:@"Unsupported pixmap format in scaler: %@", OOPixMapFormatName(pixMap.format)];
#else
    abort();
#endif
}

References OOPixMap::format, kOOPixMapGrayscale, kOOPixMapGrayscaleAlpha, kOOPixMapInvalidFormat, kOOPixMapRGBA, SqueezeVertically1(), SqueezeVertically2(), and SqueezeVertically4().

Referenced by OOScalePixMap().

Here is the call graph for this function:

Here is the caller graph for this function:

SqueezeVertically1()

static void SqueezeVertically1 ( OOPixMap srcPx, OOPixMapDimension dstHeight )

static

Definition at line 1294 of file OOTextureScaling.m.

{
    uint8_t             *src, *srcStart, *dst;
    uint_fast32_t       x, y, xCount, startY, endY, lastRow;
    size_t              srcRowBytes;
    uint_fast32_t       endFractY, deltaY;
    uint_fast32_t       accum, weight;
    uint_fast8_t        startWeight, endWeight;
    
    NSCParameterAssert(OOIsValidPixMap(srcPx) && OOPixMapBytesPerPixel(srcPx) == 1);
    
    dst = srcPx.pixels; // Output is placed in same buffer, without line padding.
    srcRowBytes = srcPx.rowBytes;
    xCount = srcPx.width;
    
    deltaY = (srcPx.height << 12) / dstHeight;
    endFractY = 0;
    
    endWeight = 0;
    endY = 0;
    
    lastRow = srcPx.height - 1;
    
    while (endY < lastRow)
    {
        endFractY += deltaY;
        startY = endY;
        endY = endFractY >> 12;
        
        startWeight = 0xFF - endWeight;
        endWeight = (endFractY >> 4) & 0xFF;
        
        srcStart = (uint8_t *)((char *)srcPx.pixels + srcRowBytes * startY);
        
        for (x = 0; x != xCount; ++x)
        {
            src = srcStart++;
            accum = startWeight * *src;
            weight = startWeight + endWeight;
            
            y = startY;
            for (;;)
            {
                ++y;
                src = (uint8_t *)((char *)src + srcRowBytes);
                if (EXPECT_NOT(y == endY))
                {
                    if (EXPECT(endY < lastRow))  accum += *src * endWeight;
                    break;
                }
                else
                {
                    accum += *src * 0xFF;
                    weight += 0xFF;
                }
            }
            
            *dst++ = accum / weight;
        }
    }   
}

References EXPECT, EXPECT_NOT, OOPixMap::height, OOIsValidPixMap(), OOPixMapBytesPerPixel(), OOPixMap::pixels, OOPixMap::rowBytes, OOPixMap::width, x, and y.

Referenced by SqueezeVertically().

Here is the call graph for this function:

Here is the caller graph for this function:

SqueezeVertically2()

static void SqueezeVertically2 ( OOPixMap srcPx, OOPixMapDimension dstHeight )

static

Definition at line 1445 of file OOTextureScaling.m.

{
    uint16_t            *src, *srcStart, *dst;
    uint_fast32_t       x, y, xCount, startY, endY, lastRow;
    size_t              srcRowBytes;
    uint_fast32_t       endFractY, deltaY;
    uint_fast32_t       accumHi, accumLo, weight;
    uint_fast8_t        startWeight, endWeight;
    
    NSCParameterAssert(OOIsValidPixMap(srcPx) && OOPixMapBytesPerPixel(srcPx) == 2);
    
    dst = srcPx.pixels; // Output is placed in same buffer, without line padding.
    srcRowBytes = srcPx.rowBytes;
    xCount = srcPx.width;
    
    deltaY = (srcPx.height << 12) / dstHeight;
    endFractY = 0;
    
    endWeight = 0;
    endY = 0;
    
    lastRow = srcPx.height - 1;
    
    while (endY < lastRow)
    {
        endFractY += deltaY;
        startY = endY;
        endY = endFractY >> 12;
        
        startWeight = 0xFF - endWeight;
        endWeight = (endFractY >> 4) & 0xFF;
        
        srcStart = (uint16_t *)((char *)srcPx.pixels + srcRowBytes * startY);
        
        for (x = 0; x != xCount; ++x)
        {
            src = srcStart++;
            
            CLEAR_ACCUM2();
            ACCUM2(*src, startWeight);
            
            y = startY;
            for (;;)
            {
                ++y;
                src = (uint16_t *)((char *)src + srcRowBytes);
                if (EXPECT_NOT(y == endY))
                {
                    if (EXPECT(endY <= lastRow))  ACCUM2(*src, endWeight);
                    break;
                }
                else
                {
                    ACCUM2(*src, 0xFF);
                }
            }
            
            *dst++ = ACCUM2TOPX();
        }
    }
}

References ACCUM2, ACCUM2TOPX, CLEAR_ACCUM2, EXPECT, EXPECT_NOT, OOPixMap::height, OOIsValidPixMap(), OOPixMapBytesPerPixel(), OOPixMap::pixels, OOPixMap::rowBytes, OOPixMap::width, x, and y.

Referenced by SqueezeVertically().

Here is the call graph for this function:

Here is the caller graph for this function:

SqueezeVertically4()

static void SqueezeVertically4 ( OOPixMap srcPx, OOPixMapDimension dstHeight )

static

Definition at line 1610 of file OOTextureScaling.m.

{
    uint32_t            *src, *srcStart, *dst;
    uint_fast32_t       x, y, xCount, startY, endY, lastRow;
    size_t              srcRowBytes;
    uint32_t            ag, br;
    uint_fast32_t       endFractY, deltaY;
    uint_fast32_t       accum1, accum2, accum3, accum4, weight;
    uint_fast8_t        startWeight, endWeight;
    
    NSCParameterAssert(OOIsValidPixMap(srcPx) && OOPixMapBytesPerPixel(srcPx) == 4);
    
    dst = srcPx.pixels; // Output is placed in same buffer, without line padding.
    srcRowBytes = srcPx.rowBytes;
    xCount = srcPx.width;
    
    deltaY = (srcPx.height << 12) / dstHeight;
    endFractY = 0;
    
    endWeight = 0;
    endY = 0;
    
    lastRow = srcPx.height - 1;
    
    while (endY < lastRow)
    {
        endFractY += deltaY;
        startY = endY;
        endY = endFractY >> 12;
        
        startWeight = 0xFF - endWeight;
        endWeight = (endFractY >> 4) & 0xFF;
        
        srcStart = (uint32_t *)((char *)srcPx.pixels + srcRowBytes * startY);
        
        for (x = 0; x != xCount; ++x)
        {
            src = srcStart++;
            
            CLEAR_ACCUM4();
            ACCUM4(*src, startWeight);
            
            y = startY;
            for (;;)
            {
                ++y;
                src = (uint32_t *)((char *)src + srcRowBytes);
                if (EXPECT_NOT(y == endY))
                {
                    if (EXPECT(endY <= lastRow))  ACCUM4(*src, endWeight);
                    break;
                }
                else
                {
                    ACCUM4(*src, 0xFF);
                }
            }
            
            *dst++ = ACCUM4TOPX();
        }
    }
}

References ACCUM4, ACCUM4TOPX, CLEAR_ACCUM4, EXPECT, EXPECT_NOT, OOPixMap::height, OOIsValidPixMap(), OOPixMapBytesPerPixel(), OOPixMap::pixels, OOPixMap::rowBytes, OOPixMap::width, x, and y.

Referenced by SqueezeVertically().

Here is the call graph for this function:

Here is the caller graph for this function:

StretchHorizontally()

OOINLINE void StretchHorizontally	(	OOPixMap	srcPx,
		OOPixMap	dstPx )

Definition at line 157 of file OOTextureScaling.m.

{
    NSCParameterAssert(srcPx.format == dstPx.format);
    
    switch (srcPx.format)
    {
        case kOOPixMapRGBA:
            StretchHorizontally4(srcPx, dstPx);
            return;
            
        case kOOPixMapGrayscale:
            StretchHorizontally1(srcPx, dstPx);
            return;
            
        case kOOPixMapGrayscaleAlpha:
            StretchHorizontally2(srcPx, dstPx);
            return;
            
        case kOOPixMapInvalidFormat:
            break;
    }
    
#ifndef NDEBUG
    [NSException raise:NSInternalInconsistencyException format:@"Unsupported pixmap format in scaler: %@", OOPixMapFormatName(srcPx.format)];
#else
    abort();
#endif
}

References OOPixMap::format, kOOPixMapGrayscale, kOOPixMapGrayscaleAlpha, kOOPixMapInvalidFormat, kOOPixMapRGBA, StretchHorizontally1(), StretchHorizontally2(), and StretchHorizontally4().

Referenced by OOScalePixMap().

Here is the call graph for this function:

Here is the caller graph for this function:

StretchHorizontally1()

static void StretchHorizontally1 ( OOPixMap srcPx, OOPixMap dstPx )

static

Definition at line 1039 of file OOTextureScaling.m.

{
    uint8_t             *src, *srcStart, *dst;
    uint8_t             px0, px1;
    uint_fast32_t       x, y, xCount;
    size_t              srcRowBytes;
    uint_fast16_t       weight0, weight1;
    uint_fast32_t       fractX, deltaX; // X coordinate, fixed-point (20.12), allowing widths up to 1 mebipixel
    
    NSCParameterAssert(OOIsValidPixMap(srcPx) && OOPixMapBytesPerPixel(srcPx) == 1 && OOIsValidPixMap(dstPx) && OOPixMapBytesPerPixel(dstPx) == 1);
    
    srcStart = srcPx.pixels;
    srcRowBytes = srcPx.rowBytes;
    xCount = dstPx.width;
    dst = dstPx.pixels; // Assumes no row padding
    
    deltaX = (srcPx.width << 12) / dstPx.width;
    px1 = *srcStart;
    
    for (y = 0; y < dstPx.height - 1; ++y)
    {
        fractX = 0;
        
        for (x = 0; x!= xCount; ++x)
        {
            fractX += deltaX;
            
            weight1 = (fractX >> 4) & 0xFF;
            weight0 = 0x100 - weight1;
            
            px0 = px1;
            src = srcStart + (fractX >> 12);
            px1 = *src;
            
            *dst++ = (px0 * weight0 + px1 * weight1) >> 8;
        }
        
        srcStart = (uint8_t *)((char *)srcStart + srcRowBytes);
        px1 = *srcStart;
    }
    
    // Copy last row without reading off end of buffer
    fractX = 0;
    for (x = 0; x!= xCount; ++x)
    {
        fractX += deltaX;
        
        weight1 = (fractX >> 4) & 0xFF;
        weight0 = 0x100 - weight1;
        
        px0 = px1;
        src = srcStart + (fractX >> 12);
        px1 = *src;
        
        *dst++ = (px0 * weight0 + px1 * weight1) >> 8;
    }
}

References OOPixMap::height, OOIsValidPixMap(), OOPixMapBytesPerPixel(), OOPixMap::pixels, OOPixMap::rowBytes, OOPixMap::width, x, and y.

Referenced by StretchHorizontally().

Here is the call graph for this function:

Here is the caller graph for this function:

StretchHorizontally2()

static void StretchHorizontally2 ( OOPixMap srcPx, OOPixMap dstPx )

static

Definition at line 1098 of file OOTextureScaling.m.

{
    uint16_t            *src, *srcStart, *dst;
    uint16_t            px0, px1;
    uint_fast32_t       hi, lo;
    uint_fast32_t       x, y, xCount;
    size_t              srcRowBytes;
    uint_fast16_t       weight0, weight1;
    uint_fast32_t       fractX, deltaX; // X coordinate, fixed-point (20.12), allowing widths up to 1 mebipixel
    
    NSCParameterAssert(OOIsValidPixMap(srcPx) && OOPixMapBytesPerPixel(srcPx) == 2 && OOIsValidPixMap(dstPx) && OOPixMapBytesPerPixel(dstPx) == 2);
    
    srcStart = srcPx.pixels;
    srcRowBytes = srcPx.rowBytes;
    xCount = dstPx.width;
    dst = dstPx.pixels; // Assumes no row padding
    
    deltaX = (srcPx.width << 12) / dstPx.width;
    px1 = *srcStart;
    
    for (y = 0; y < dstPx.height - 1; ++y)
    {
        fractX = 0;
        
        for (x = 0; x!= xCount; ++x)
        {
            fractX += deltaX;
            
            weight1 = (fractX >> 4) & 0xFF;
            weight0 = 0x100 - weight1;
            
            px0 = px1;
            src = srcStart + (fractX >> 12);
            px1 = *src;
            
            hi = (px0 & 0xFF00) * weight0 + (px1 & 0xFF00) * weight1;
            lo = (px0 & 0x00FF) * weight0 + (px1 & 0x00FF) * weight1;
            
            *dst++ = ((hi & 0xFF0000) | (lo & 0x00FF00)) >> 8;
        }
        
        srcStart = (uint16_t *)((char *)srcStart + srcRowBytes);
        px1 = *srcStart;
    }
    
    // Copy last row without reading off end of buffer
    fractX = 0;
    for (x = 0; x!= xCount; ++x)
    {
        fractX += deltaX;
        
        weight1 = (fractX >> 4) & 0xFF;
        weight0 = 0x100 - weight1;
        
        px0 = px1;
        src = srcStart + (fractX >> 12);
        px1 = *src;
        
        hi = (px0 & 0xFF00) * weight0 + (px1 & 0xFF00) * weight1;
        lo = (px0 & 0x00FF) * weight0 + (px1 & 0x00FF) * weight1;
        
        *dst++ = ((hi & 0xFF0000) | (lo & 0x00FF00)) >> 8;
    }
}

References OOPixMap::height, OOIsValidPixMap(), OOPixMapBytesPerPixel(), OOPixMap::pixels, OOPixMap::rowBytes, OOPixMap::width, x, and y.

Referenced by StretchHorizontally().

Here is the call graph for this function:

Here is the caller graph for this function:

StretchHorizontally4()

static void StretchHorizontally4 ( OOPixMap srcPx, OOPixMap dstPx )

static

Definition at line 1164 of file OOTextureScaling.m.

{
    uint32_t            *src, *srcStart, *dst;
    uint32_t            px0, px1;
    uint32_t            ag, br;
    uint_fast32_t       x, y, xCount;
    size_t              srcRowBytes;
    uint_fast16_t       weight0, weight1;
    uint_fast32_t       fractX, deltaX; // X coordinate, fixed-point (20.12), allowing widths up to 1 mebipixel
    
    NSCParameterAssert(OOIsValidPixMap(srcPx) && OOPixMapBytesPerPixel(srcPx) == 4 && OOIsValidPixMap(dstPx) && OOPixMapBytesPerPixel(dstPx) == 4);
    
    srcStart = srcPx.pixels;
    srcRowBytes = srcPx.rowBytes;
    xCount = dstPx.width;
    dst = dstPx.pixels; // Assumes no row padding
    
    deltaX = (srcPx.width << 12) / dstPx.width;
    px1 = *srcStart;
    
    for (y = 0; y < dstPx.height - 1; ++y)
    {
        fractX = 0;
        
        for (x = 0; x!= xCount; ++x)
        {
            fractX += deltaX;
            
            weight1 = (fractX >> 4) & 0xFF;
            weight0 = 0x100 - weight1;
            
            px0 = px1;
            src = srcStart + (fractX >> 12);
            px1 = *src;
            
            ag = ((px0 & 0xFF00FF00) >> 8) * weight0 + ((px1 & 0xFF00FF00) >> 8) * weight1;
            br = (px0 & 0x00FF00FF) * weight0 + (px1 & 0x00FF00FF) * weight1;
            
            *dst++ = (ag & 0xFF00FF00) | ((br & 0xFF00FF00) >> 8);
        }
        
        srcStart = (uint32_t *)((char *)srcStart + srcRowBytes);
        px1 = *srcStart;
    }
    
    // Copy last row without reading off end of buffer
    fractX = 0;
    for (x = 0; x!= xCount; ++x)
    {
        fractX += deltaX;
        
        weight1 = (fractX >> 4) & 0xFF;
        weight0 = 0x100 - weight1;
        
        px0 = px1;
        src = srcStart + (fractX >> 12);
        if (EXPECT(x < xCount - 1))  px1 = *src;
        
        ag = ((px0 & 0xFF00FF00) >> 8) * weight0 + ((px1 & 0xFF00FF00) >> 8) * weight1;
        br = (px0 & 0x00FF00FF) * weight0 + (px1 & 0x00FF00FF) * weight1;
        
        *dst++ = (ag & 0xFF00FF00) | ((br & 0xFF00FF00) >> 8);
    }
}

References EXPECT, OOPixMap::height, OOIsValidPixMap(), OOPixMapBytesPerPixel(), OOPixMap::pixels, OOPixMap::rowBytes, OOPixMap::width, x, and y.

Referenced by StretchHorizontally().

Here is the call graph for this function:

Here is the caller graph for this function:

StretchVertically()

OOINLINE void StretchVertically	(	OOPixMap	srcPx,
		OOPixMap	dstPx )

Definition at line 98 of file OOTextureScaling.m.

{
    if (!((srcPx.rowBytes) & 3))
    {
        StretchVerticallyN_x4(srcPx, dstPx);
    }
    else
    {
        StretchVerticallyN_x1(srcPx, dstPx);
    }
}

References OOPixMap::rowBytes, StretchVerticallyN_x1(), and StretchVerticallyN_x4().

Referenced by OOScalePixMap().

Here is the call graph for this function:

Here is the caller graph for this function:

StretchVerticallyN_x1()

static void StretchVerticallyN_x1 ( OOPixMap srcPx, OOPixMap dstPx )

static

Definition at line 889 of file OOTextureScaling.m.

{
    uint8_t             *src, *src0, *src1, *prev, *dst;
    uint8_t             px0, px1;
    uint_fast32_t       x, y, xCount;
    size_t              srcRowBytes;
    uint_fast16_t       weight0, weight1;
    uint_fast32_t       fractY; // Y coordinate, fixed-point (24.8)
    
    src = srcPx.pixels;
    srcRowBytes = srcPx.rowBytes;
    dst = dstPx.pixels; // Assumes dstPx.width == dstPx.rowBytes.
    
    src0 = prev = src;
    
    xCount = srcPx.width * OOPixMapBytesPerPixel(srcPx);
    
    for (y = 1; y != dstPx.height; ++y)
    {
        fractY = ((srcPx.height * y) << 8) / dstPx.height;
        
        src0 = prev;
        prev = src1 = src + srcRowBytes * (fractY >> 8);
        
        weight1 = fractY & 0xFF;
        weight0 = 0x100 - weight1;
        
        x = xCount;
        while (x--)
        {
            px0 = *src0++;
            px1 = *src1++;
            
            *dst++ = (px0 * weight0 + px1 * weight1) >> 8;
        }
    }
    
    // Copy last row (without referring to the last-plus-oneth row)
    x = xCount;
    while (x--)
    {
        *dst++ = *src0++;
    }
}

References OOPixMap::height, OOPixMapBytesPerPixel(), OOPixMap::pixels, OOPixMap::rowBytes, OOPixMap::width, x, and y.

Referenced by StretchVertically().

Here is the call graph for this function:

Here is the caller graph for this function:

StretchVerticallyN_x4()

static void StretchVerticallyN_x4 ( OOPixMap srcPx, OOPixMap dstPx )

static

Definition at line 937 of file OOTextureScaling.m.

{
    uint8_t             *src;
    uint32_t            *src0, *src1, *prev, *dst;
    uint32_t            px0, px1, ag, br;
    uint_fast32_t       x, y, xCount;
    size_t              srcRowBytes;
    uint_fast16_t       weight0, weight1;
    uint_fast32_t       fractY; // Y coordinate, fixed-point (24.8)
    
    src = srcPx.pixels;
    srcRowBytes = srcPx.rowBytes;
    dst = dstPx.pixels; // Assumes no row padding.
    
    src0 = prev = (uint32_t *)src;
    
    xCount = (srcPx.width * OOPixMapBytesPerPixel(srcPx)) >> 2;
    
    for (y = 1; y != dstPx.height; ++y)
    {
        fractY = ((srcPx.height * y) << 8) / dstPx.height;
        
        src0 = prev;
        prev = src1 = (uint32_t *)(src + srcRowBytes * (fractY >> 8));
        
        weight1 = fractY & 0xFF;
        weight0 = 0x100 - weight1;
        
        x = xCount;
        while (x--)
        {
            px0 = *src0++;
            px1 = *src1++;
            
            ag = ((px0 & 0xFF00FF00) >> 8) * weight0 + ((px1 & 0xFF00FF00) >> 8) * weight1;
            br = (px0 & 0x00FF00FF) * weight0 + (px1 & 0x00FF00FF) * weight1;
            
            *dst++ = (ag & 0xFF00FF00) | ((br >> 8) & 0x00FF00FF);
        }
    }
    
    // Copy last row (without referring to the last-plus-oneth row)
    x = xCount;
    while (x--)
    {
        *dst++ = *src0++;
    }
}

References OOPixMap::height, OOPixMapBytesPerPixel(), OOPixMap::pixels, OOPixMap::rowBytes, OOPixMap::width, x, and y.

Referenced by StretchVertically().

Here is the call graph for this function:

Here is the caller graph for this function: