213 lines
6.6 KiB
C++
213 lines
6.6 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
//=============================================================================
|
|
|
|
#include "jpegloader.h"
|
|
#include "tier0/dbg.h"
|
|
#include "tier1/utlvector.h"
|
|
#include "tier0/vprof.h"
|
|
#include "jpeglib/jpeglib.h"
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Takes a RGBA image buffer and resizes it using linear interpolation.
|
|
//
|
|
// Params: bufRGBA should contain the current image, nWidth and nHeight should describe
|
|
// the current images dimensions. nNewWidth and nNewHeight should be the new target size,
|
|
// one, but not both, of these may be -1 which will indicate to preserve aspect ratio
|
|
// and size that dimension to match the aspect ratio adjustment applied to the other
|
|
// dimension which must then be specified explicitly. nNewWidth and nNewHeight may
|
|
// be modified by the function and will specify the final width/height after the
|
|
// function returns succesfully. If both nNewWidth and nNewHeight are specified
|
|
// the content will be scaled without changing the aspect ratio and black letterboxing
|
|
// will be added if appropriate
|
|
//-----------------------------------------------------------------------------
|
|
bool BResizeImageInternal( CUtlBuffer &bufImage, int nWidth, int nHeight, int &nNewWidth, int &nNewHeight, bool bIsRGBA = true )
|
|
{
|
|
VPROF_BUDGET( "BResizeImageRGBA", VPROF_BUDGETGROUP_OTHER_VGUI );
|
|
CUtlBuffer bufImageOut;
|
|
|
|
if ( nWidth == 0 || nHeight == 0 )
|
|
return false;
|
|
|
|
// Must specify at least one, then we'll compute the other to preserve aspect ratio if it's set to -1
|
|
if ( nNewWidth == - 1 && nNewHeight == -1 )
|
|
return false;
|
|
|
|
if ( nNewHeight == -1 )
|
|
{
|
|
float flAspect = (float)nNewWidth/(float)nWidth;
|
|
nNewHeight = (int)(flAspect*nHeight);
|
|
}
|
|
else if ( nNewWidth == -1 )
|
|
{
|
|
float flAspect = (float)nNewHeight/(float)nHeight;
|
|
nNewWidth = (int)(flAspect*nWidth);
|
|
}
|
|
|
|
if ( nNewWidth == 0 || nNewHeight == 0 )
|
|
return false;
|
|
|
|
int nNewContentHeight = nNewHeight;
|
|
int nNewContentWidth = nNewWidth;
|
|
|
|
// Calculate the width/height of the actual content
|
|
if ( nWidth/(float)nHeight > nNewContentWidth/(float)nNewContentHeight )
|
|
nNewContentHeight = ( nNewContentWidth * nHeight )/nWidth;
|
|
else
|
|
nNewContentWidth = ( nNewContentHeight * nWidth )/nHeight;
|
|
|
|
int bytesPerPixel = bIsRGBA ? 4 : 3;
|
|
|
|
bufImageOut.EnsureCapacity( nNewWidth*nNewHeight*bytesPerPixel );
|
|
bufImageOut.SeekPut( CUtlBuffer::SEEK_HEAD, nNewWidth*nNewHeight*bytesPerPixel );
|
|
|
|
|
|
// Letterboxing
|
|
int nPaddingTop = (nNewHeight - nNewContentHeight)/2;
|
|
int nPaddingBottom = nNewHeight - nNewContentHeight - nPaddingTop;
|
|
int nPaddingLeft = (nNewWidth - nNewContentWidth)/2;
|
|
int nPaddingRight = nNewWidth - nNewContentWidth - nPaddingLeft;
|
|
|
|
Assert( nPaddingTop + nPaddingBottom + nNewContentHeight == nNewHeight );
|
|
Assert( nPaddingLeft + nPaddingRight + nNewContentWidth == nNewWidth );
|
|
|
|
if ( nPaddingLeft > 0 ||
|
|
nPaddingRight > 0 ||
|
|
nPaddingTop > 0 ||
|
|
nPaddingBottom > 0 )
|
|
{
|
|
Q_memset( bufImageOut.Base(), 0, nNewWidth*nNewHeight*bytesPerPixel );
|
|
}
|
|
|
|
byte *pBits = (byte*)bufImageOut.Base();
|
|
|
|
int nOriginalStride = nWidth;
|
|
int nTargetStride = nNewWidth;
|
|
|
|
float flXRatio = (float)(nWidth-1)/(float)nNewContentWidth;
|
|
float flYRatio = (float)(nHeight-1)/(float)nNewContentHeight;
|
|
|
|
byte *pSrcBits = (byte*)bufImage.Base();
|
|
for( int yNew=0; yNew<nNewContentHeight; ++yNew )
|
|
{
|
|
int y = (int)(flYRatio * yNew);
|
|
float yDiff = (flYRatio * yNew) - y;
|
|
|
|
for ( int xNew=0; xNew<nNewContentWidth; ++xNew )
|
|
{
|
|
int x = (int)(flXRatio * xNew);
|
|
float xDiff = (flXRatio * xNew) - x;
|
|
|
|
int aOffset = (x+(y*nOriginalStride))*bytesPerPixel;
|
|
int bOffset = aOffset+bytesPerPixel;
|
|
int cOffset = aOffset + (nOriginalStride*bytesPerPixel);
|
|
int dOffset = cOffset+bytesPerPixel;
|
|
|
|
byte red = (byte)(
|
|
pSrcBits[aOffset]*(1-xDiff)*(1-yDiff)
|
|
+pSrcBits[bOffset]*(xDiff)*(1-yDiff)
|
|
+pSrcBits[cOffset]*(yDiff)*(1-xDiff)
|
|
+pSrcBits[dOffset]*(xDiff)*(yDiff)
|
|
);
|
|
|
|
byte green = (byte)(
|
|
pSrcBits[aOffset+1]*(1-xDiff)*(1-yDiff)
|
|
+pSrcBits[bOffset+1]*(xDiff)*(1-yDiff)
|
|
+pSrcBits[cOffset+1]*(yDiff)*(1-xDiff)
|
|
+pSrcBits[dOffset+1]*(xDiff)*(yDiff)
|
|
);
|
|
|
|
byte blue = (byte)(
|
|
pSrcBits[aOffset+2]*(1-xDiff)*(1-yDiff)
|
|
+pSrcBits[bOffset+2]*(xDiff)*(1-yDiff)
|
|
+pSrcBits[cOffset+2]*(yDiff)*(1-xDiff)
|
|
+pSrcBits[dOffset+2]*(xDiff)*(yDiff)
|
|
);
|
|
|
|
byte alpha = 0;
|
|
if ( bytesPerPixel == 4 )
|
|
{
|
|
alpha = (byte)(
|
|
pSrcBits[aOffset+3]*(1-xDiff)*(1-yDiff)
|
|
+pSrcBits[bOffset+3]*(xDiff)*(1-yDiff)
|
|
+pSrcBits[cOffset+3]*(yDiff)*(1-xDiff)
|
|
+pSrcBits[dOffset+3]*(xDiff)*(yDiff)
|
|
);
|
|
}
|
|
|
|
int targetOffset = (nPaddingLeft+xNew+((nPaddingTop+yNew)*nTargetStride))*bytesPerPixel;
|
|
|
|
pBits[targetOffset] = red;
|
|
pBits[targetOffset+1] = green;
|
|
pBits[targetOffset+2] = blue;
|
|
if ( bytesPerPixel == 4 )
|
|
pBits[targetOffset+3] = alpha;
|
|
}
|
|
}
|
|
bufImage.Swap( bufImageOut );
|
|
return true;
|
|
}
|
|
|
|
// Resize an RGB image using linear interpolation
|
|
bool BResizeImageRGB( CUtlBuffer &bufRGB, int nWidth, int nHeight, int &nNewWidth, int &nNewHeight )
|
|
{
|
|
return BResizeImageInternal( bufRGB, nWidth, nHeight, nNewWidth, nNewHeight, false );
|
|
}
|
|
|
|
// Resize an RGBA image using linear interpolation
|
|
bool BResizeImageRGBA( CUtlBuffer &bufRGB, int nWidth, int nHeight, int &nNewWidth, int &nNewHeight )
|
|
{
|
|
return BResizeImageInternal( bufRGB, nWidth, nHeight, nNewWidth, nNewHeight, true );
|
|
}
|
|
|
|
// Convert an RGB image to RGBA with 100% opacity
|
|
bool BConvertRGBToRGBA( CUtlBuffer &bufRGB, int nWidth, int nHeight )
|
|
{
|
|
CUtlBuffer bufRGBA;
|
|
bufRGBA.EnsureCapacity( nWidth*nHeight*4 );
|
|
byte *pBits = (byte*)bufRGB.Base();
|
|
byte *pBitsOut = (byte*)bufRGBA.Base();
|
|
|
|
for( int y=0; y<nHeight; ++y )
|
|
{
|
|
for( int x=0; x<nWidth; ++x )
|
|
{
|
|
*pBitsOut = *pBits;
|
|
*(pBitsOut+1) = *(pBits+1);
|
|
*(pBitsOut+2) = *(pBits+2);
|
|
*(pBitsOut+3) = 255;
|
|
|
|
pBitsOut += 4;
|
|
pBits += 3;
|
|
}
|
|
}
|
|
bufRGB.Swap( bufRGBA );
|
|
return true;
|
|
}
|
|
|
|
// Convert an RGBA image to RGB using opacity against a given solid background
|
|
bool BConvertRGBAToRGB( CUtlBuffer &bufRGBA, int nWidth, int nHeight, Color colorBG )
|
|
{
|
|
CUtlBuffer bufRGB;
|
|
bufRGB.EnsureCapacity( nWidth*nHeight*3 );
|
|
byte *pBits = (byte*)bufRGBA.Base();
|
|
byte *pBitsOut = (byte*)bufRGB.Base();
|
|
|
|
for( int y=0; y<nHeight; ++y )
|
|
{
|
|
for( int x=0; x<nWidth; ++x )
|
|
{
|
|
float fOpacity = *(pBits+3) / 255.0;
|
|
*pBitsOut = *pBits * fOpacity + (1.0 - fOpacity) * colorBG.r();
|
|
*(pBitsOut+1) = *(pBits+1) * fOpacity + (1.0 - fOpacity) * colorBG.g();
|
|
*(pBitsOut+2) = *(pBits+2) * fOpacity + (1.0 - fOpacity) * colorBG.b();
|
|
|
|
pBitsOut += 3;
|
|
pBits += 4;
|
|
}
|
|
}
|
|
bufRGB.Swap( bufRGBA );
|
|
return true;
|
|
} |