archive/blender-archive
Archived
1
1
Fork 0
Code Pull Requests Packages Activity

Small optimizations in compositor.

Browse Source 
Most of them are not noticeable.
This commit is contained in:
Jeroen Bakker
2012-07-12 19:19:03 +00:00
parent 2738fa99e7
commit 8b8bc164da
11 changed files with 256 additions and 96 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
source/blender/compositor/intern/COM_MemoryBuffer.cpp
View File

@@ -121,7 +121,7 @@ void MemoryBuffer::writePixel(int x, int y, const float color[4])
if (x >= this->m_rect.xmin && x < this->m_rect.xmax &&
y >= this->m_rect.ymin && y < this->m_rect.ymax)
{
const int offset = (this->m_chunkWidth * y + x) * COM_NUMBER_OF_CHANNELS;
const int offset = (this->m_chunkWidth * (y-this->m_rect.ymin) + x-this->m_rect.xmin) * COM_NUMBER_OF_CHANNELS;
copy_v4_v4(&this->m_buffer[offset], color);
}
}
@@ -131,7 +131,7 @@ void MemoryBuffer::addPixel(int x, int y, const float color[4])
if (x >= this->m_rect.xmin && x < this->m_rect.xmax &&
y >= this->m_rect.ymin && y < this->m_rect.ymax)
{
const int offset = (this->m_chunkWidth * y + x) * COM_NUMBER_OF_CHANNELS;
const int offset = (this->m_chunkWidth * (y-this->m_rect.ymin) + x-this->m_rect.xmin) * COM_NUMBER_OF_CHANNELS;
add_v4_v4(&this->m_buffer[offset], color);
}
}

2
source/blender/compositor/intern/COM_SingleThreadedNodeOperation.cpp
View File

@@ -35,7 +35,7 @@ void SingleThreadedNodeOperation::initExecution()
void SingleThreadedNodeOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
{
this->m_cachedInstance->read(color, x, y);
this->m_cachedInstance->readNoCheck(color, x, y);
}
void SingleThreadedNodeOperation::deinitExecution()

4
source/blender/compositor/nodes/COM_DefocusNode.cpp
View File

@@ -99,9 +99,7 @@ void DefocusNode::convertToOperations(ExecutionSystem *graph, CompositorContext
#ifdef COM_DEFOCUS_SEARCH
InverseSearchRadiusOperation *search = new InverseSearchRadiusOperation();
addLink(graph, radiusOperation->getOutputSocket(0), search->getInputSocket(0));
addLink(graph, depthOperation, search->getInputSocket(1));
search->setMaxBlur(data->maxblur);
search->setThreshold(data->bthresh);
graph->addOperation(search);
#endif
VariableSizeBokehBlurOperation *operation = new VariableSizeBokehBlurOperation();
@@ -116,7 +114,7 @@ void DefocusNode::convertToOperations(ExecutionSystem *graph, CompositorContext
addLink(graph, bokeh->getOutputSocket(), operation->getInputSocket(1));
addLink(graph, radiusOperation->getOutputSocket(), operation->getInputSocket(2));
#ifdef COM_DEFOCUS_SEARCH
addLink(graph, search->getOutputSocket(), operation->getInputSocket(4));
addLink(graph, search->getOutputSocket(), operation->getInputSocket(3));
#endif
if (data->gamco) {
GammaCorrectOperation *correct = new GammaCorrectOperation();

153
source/blender/compositor/operations/COM_GaussianBokehBlurOperation.cpp
View File

@@ -194,3 +194,156 @@ bool GaussianBokehBlurOperation::determineDependingAreaOfInterest(rcti *input, R
return BlurBaseOperation::determineDependingAreaOfInterest(&newInput, readOperation, output);
}
}
// reference image
GaussianBokehBlurReferenceOperation::GaussianBokehBlurReferenceOperation() : NodeOperation()
{
this->addInputSocket(COM_DT_COLOR);
this->addInputSocket(COM_DT_VALUE);
this->addOutputSocket(COM_DT_COLOR);
this->setComplex(true);
this->m_gausstab = NULL;
this->m_inputImage = NULL;
this->m_inputSize = NULL;
}
void *GaussianBokehBlurReferenceOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers)
{
void *buffer = getInputOperation(0)->initializeTileData(NULL, memoryBuffers);
return buffer;
}
void GaussianBokehBlurReferenceOperation::initExecution()
{
// setup gaustab
this->m_data->image_in_width = this->getWidth();
this->m_data->image_in_height = this->getHeight();
if (this->m_data->relative) {
switch (this->m_data->aspect) {
case CMP_NODE_BLUR_ASPECT_NONE:
this->m_data->sizex = (int)(this->m_data->percentx * 0.01f * this->m_data->image_in_width);
this->m_data->sizey = (int)(this->m_data->percenty * 0.01f * this->m_data->image_in_height);
break;
case CMP_NODE_BLUR_ASPECT_Y:
this->m_data->sizex = (int)(this->m_data->percentx * 0.01f * this->m_data->image_in_width);
this->m_data->sizey = (int)(this->m_data->percenty * 0.01f * this->m_data->image_in_width);
break;
case CMP_NODE_BLUR_ASPECT_X:
this->m_data->sizex = (int)(this->m_data->percentx * 0.01f * this->m_data->image_in_height);
this->m_data->sizey = (int)(this->m_data->percenty * 0.01f * this->m_data->image_in_height);
break;
}
}
updateGauss();
this->m_inputImage = this->getInputSocketReader(0);
this->m_inputSize = this->getInputSocketReader(1);
}
void GaussianBokehBlurReferenceOperation::updateGauss()
{
int n;
float *dgauss;
float *ddgauss;
int j, i;
n = (2 * radx + 1) * (2 * rady + 1);
/* create a full filter image */
ddgauss = new float[n];
dgauss = ddgauss;
for (j = -rady; j <= rady; j++) {
for (i = -radx; i <= radx; i++, dgauss++) {
float fj = (float)j / radyf;
float fi = (float)i / radxf;
float dist = sqrt(fj * fj + fi * fi);
*dgauss = RE_filter_value(this->m_data->filtertype, dist);
}
}
this->m_gausstab = ddgauss;
}
void GaussianBokehBlurReferenceOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
{
float tempColor[4];
float tempSize[4];
tempColor[0] = 0;
tempColor[1] = 0;
tempColor[2] = 0;
tempColor[3] = 0;
float multiplier_accum = 0;
MemoryBuffer *inputBuffer = (MemoryBuffer *)data;
float *buffer = inputBuffer->getBuffer();
int bufferwidth = inputBuffer->getWidth();
int bufferstartx = inputBuffer->getRect()->xmin;
int bufferstarty = inputBuffer->getRect()->ymin;
this->m_inputSize->read(tempSize, x, y, inputBuffers, data);
float size = tempSize[0];
CLAMP(size, 0.0f, 1.0f);
float sizeX = ceil(this->m_data->sizex * size);
float sizeY = ceil(this->m_data->sizey * size);
if (sizeX <= 0.5f && sizeY <= 0.5f) {
this->m_inputImage->read(color, x, y, inputBuffers, data);
return;
}
int miny = y - sizeY;
int maxy = y + sizeY;
int minx = x - sizeX;
int maxx = x + sizeX;
miny = max(miny, inputBuffer->getRect()->ymin);
minx = max(minx, inputBuffer->getRect()->xmin);
maxy = min(maxy, inputBuffer->getRect()->ymax);
maxx = min(maxx, inputBuffer->getRect()->xmax);
int step = QualityStepHelper::getStep();
int offsetadd = QualityStepHelper::getOffsetAdd();
for (int ny = miny; ny < maxy; ny += step) {
int u = ny - y;
float uf = ((u/sizeY)*radyf)+radyf;
int indexu = uf * (radx*2+1);
int bufferindex = ((minx - bufferstartx) * 4) + ((ny - bufferstarty) * 4 * bufferwidth);
for (int nx = minx; nx < maxx; nx += step) {
int v = nx - x;
float vf = ((v/sizeX)*radxf)+radxf;
int index = indexu + vf;
const float multiplier = this->m_gausstab[index];
madd_v4_v4fl(tempColor, &buffer[bufferindex], multiplier);
multiplier_accum += multiplier;
index += step;
bufferindex += offsetadd;
}
}
mul_v4_v4fl(color, tempColor, 1.0f / multiplier_accum);
}
void GaussianBokehBlurReferenceOperation::deinitExecution()
{
delete [] this->m_gausstab;
this->m_gausstab = NULL;
this->m_inputImage = NULL;
this->m_inputSize = NULL;
}
bool GaussianBokehBlurReferenceOperation::determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output)
{
rcti newInput;
NodeOperation *operation = this->getInputOperation(1);
if (operation->determineDependingAreaOfInterest(input, readOperation, output)) {
return true;
}
else {
int addx = this->m_data->sizex+2;
int addy = this->m_data->sizey+2;
newInput.xmax = input->xmax + addx;
newInput.xmin = input->xmin - addx;
newInput.ymax = input->ymax + addy;
newInput.ymin = input->ymin - addy;
return NodeOperation::determineDependingAreaOfInterest(&newInput, readOperation, output);
}
}

20
source/blender/compositor/operations/COM_GaussianXBlurOperation.cpp
View File

@@ -118,17 +118,19 @@ void GaussianXBlurOperation::deinitExecution()
bool GaussianXBlurOperation::determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output)
{
rcti newInput;
rcti sizeInput;
sizeInput.xmin = 0;
sizeInput.ymin = 0;
sizeInput.xmax = 5;
sizeInput.ymax = 5;
NodeOperation *operation = this->getInputOperation(1);
if (operation->determineDependingAreaOfInterest(&sizeInput, readOperation, output)) {
return true;
if (!this->m_sizeavailable) {
rcti sizeInput;
sizeInput.xmin = 0;
sizeInput.ymin = 0;
sizeInput.xmax = 5;
sizeInput.ymax = 5;
NodeOperation *operation = this->getInputOperation(1);
if (operation->determineDependingAreaOfInterest(&sizeInput, readOperation, output)) {
return true;
}
}
else {
{
if (this->m_sizeavailable && this->m_gausstab != NULL) {
newInput.xmax = input->xmax + this->m_rad;
newInput.xmin = input->xmin - this->m_rad;

20
source/blender/compositor/operations/COM_GaussianYBlurOperation.cpp
View File

@@ -116,17 +116,19 @@ void GaussianYBlurOperation::deinitExecution()
bool GaussianYBlurOperation::determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output)
{
rcti newInput;
rcti sizeInput;
sizeInput.xmin = 0;
sizeInput.ymin = 0;
sizeInput.xmax = 5;
sizeInput.ymax = 5;
NodeOperation *operation = this->getInputOperation(1);
if (operation->determineDependingAreaOfInterest(&sizeInput, readOperation, output)) {
return true;
if (!m_sizeavailable) {
rcti sizeInput;
sizeInput.xmin = 0;
sizeInput.ymin = 0;
sizeInput.xmax = 5;
sizeInput.ymax = 5;
NodeOperation *operation = this->getInputOperation(1);
if (operation->determineDependingAreaOfInterest(&sizeInput, readOperation, output)) {
return true;
}
}
else {
{
if (this->m_sizeavailable && this->m_gausstab != NULL) {
newInput.xmax = input->xmax;
newInput.xmin = input->xmin;

19
source/blender/compositor/operations/COM_MixBaseOperation.cpp
View File

@@ -45,12 +45,13 @@ void MixBaseOperation::executePixel(float *outputColor, float x, float y, PixelS
{
float inputColor1[4];
float inputColor2[4];
float value;
float inputValue[4];
this->m_inputValueOperation->read(&value, x, y, sampler, inputBuffers);
this->m_inputColor1Operation->read(&inputColor1[0], x, y, sampler, inputBuffers);
this->m_inputColor2Operation->read(&inputColor2[0], x, y, sampler, inputBuffers);
this->m_inputValueOperation->read(inputValue, x, y, sampler, inputBuffers);
this->m_inputColor1Operation->read(inputColor1, x, y, sampler, inputBuffers);
this->m_inputColor2Operation->read(inputColor2, x, y, sampler, inputBuffers);
float value = inputValue[0];
if (this->useValueAlphaMultiply()) {
value *= inputColor2[3];
}
@@ -93,13 +94,3 @@ void MixBaseOperation::determineResolution(unsigned int resolution[], unsigned i
}
NodeOperation::determineResolution(resolution, preferredResolution);
}
void MixBaseOperation::clampIfNeeded(float *color)
{
if (this->m_useClamp) {
CLAMP(color[0], 0.0f, 1.0f);
CLAMP(color[1], 0.0f, 1.0f);
CLAMP(color[2], 0.0f, 1.0f);
CLAMP(color[3], 0.0f, 1.0f);
}
}

11
source/blender/compositor/operations/COM_MixBaseOperation.h
View File

@@ -40,7 +40,16 @@ protected:
bool m_valueAlphaMultiply;
bool m_useClamp;
void clampIfNeeded(float *color);
inline void clampIfNeeded(float *color)
{
if (m_useClamp) {
CLAMP(color[0], 0.0f, 1.0f);
CLAMP(color[1], 0.0f, 1.0f);
CLAMP(color[2], 0.0f, 1.0f);
CLAMP(color[3], 0.0f, 1.0f);
}
}
public:
/**
* Default constructor

2
source/blender/compositor/operations/COM_OpenCLKernels.cl
View File

@@ -112,7 +112,7 @@ __kernel void defocusKernel(__read_only image2d_t inputImage, __read_only image2
tempSize = read_imagef(inputSize, SAMPLER_NEAREST, inputCoordinate).s0;
if (tempSize > threshold) {
if (tempSize >= fabs(dx) && tempSize >= fabs(dy)) {
float2 uv = { 256.0f + dx * 256.0f / tempSize, 256.0f + dy * 256.0f / tempSize};
float2 uv = { 256.0f + dx * 255.0f / tempSize, 256.0f + dy * 255.0f / tempSize};
bokeh = read_imagef(bokehImage, SAMPLER_NEAREST, uv);
readColor = read_imagef(inputImage, SAMPLER_NEAREST, inputCoordinate);
color_accum += bokeh*readColor;

104
source/blender/compositor/operations/COM_VariableSizeBokehBlurOperation.cpp
View File

@@ -57,7 +57,7 @@ void VariableSizeBokehBlurOperation::initExecution()
this->m_inputBokehProgram = getInputSocketReader(1);
this->m_inputSizeProgram = getInputSocketReader(2);
#ifdef COM_DEFOCUS_SEARCH
this->m_inputSearchProgram = getInputSocketReader(4);
this->m_inputSearchProgram = getInputSocketReader(3);
#endif
QualityStepHelper::initExecution(COM_QH_INCREASE);
}
@@ -93,7 +93,7 @@ void VariableSizeBokehBlurOperation::executePixel(float *color, int x, int y, Me
#ifdef COM_DEFOCUS_SEARCH
float search[4];
this->inputSearchProgram->read(search, x/InverseSearchRadiusOperation::DIVIDER, y / InverseSearchRadiusOperation::DIVIDER, inputBuffers, NULL);
this->m_inputSearchProgram->read(search, x/InverseSearchRadiusOperation::DIVIDER, y / InverseSearchRadiusOperation::DIVIDER, inputBuffers, NULL);
int minx = search[0];
int miny = search[1];
int maxx = search[2];
@@ -127,8 +127,8 @@ void VariableSizeBokehBlurOperation::executePixel(float *color, int x, int y, Me
float fsize = fabsf(size);
float dx = nx - x;
if (fsize > fabsf(dx) && fsize > fabsf(dy)) {
float u = (256.0f + (dx/size) * 256.0f);
float v = (256.0f + (dy/size) * 256.0f);
float u = (256.0f + (dx/size) * 255.0f);
float v = (256.0f + (dy/size) * 255.0f);
inputBokehBuffer->readNoCheck(bokeh, u, v);
madd_v4_v4v4(color_accum, bokeh, &inputProgramFloatBuffer[offsetNxNy]);
add_v4_v4(multiplier_accum, bokeh);
@@ -211,7 +211,7 @@ bool VariableSizeBokehBlurOperation::determineDependingAreaOfInterest(rcti *inpu
searchInput.xmin = (input->xmin / InverseSearchRadiusOperation::DIVIDER) - 1;
searchInput.ymax = (input->ymax / InverseSearchRadiusOperation::DIVIDER) + 1;
searchInput.ymin = (input->ymin / InverseSearchRadiusOperation::DIVIDER) - 1;
operation = getInputOperation(4);
operation = getInputOperation(3);
if (operation->determineDependingAreaOfInterest(&searchInput, readOperation, output) ) {
return true;
}
@@ -228,65 +228,74 @@ bool VariableSizeBokehBlurOperation::determineDependingAreaOfInterest(rcti *inpu
InverseSearchRadiusOperation::InverseSearchRadiusOperation() : NodeOperation()
{
this->addInputSocket(COM_DT_VALUE, COM_SC_NO_RESIZE); // radius
this->addInputSocket(COM_DT_VALUE, COM_SC_NO_RESIZE); // depth
this->addOutputSocket(COM_DT_COLOR);
this->setComplex(true);
this->inputRadius = NULL;
this->inputDepth = NULL;
this->m_inputRadius = NULL;
}
void InverseSearchRadiusOperation::initExecution()
{
this->inputRadius = this->getInputSocketReader(0);
this->inputDepth = this->getInputSocketReader(1);
this->m_inputRadius = this->getInputSocketReader(0);
}
void* InverseSearchRadiusOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers)
{
MemoryBuffer * data = new MemoryBuffer(NULL, rect);
float* buffer = data->getBuffer();
int x, y;
float width = this->inputRadius->getWidth();
float height = this->inputRadius->getHeight();
for (x = rect->xmin; x < rect->xmax ; x++) {
for (y = rect->ymin; y < rect->ymax ; y++) {
float[4] temp;
int width = this->m_inputRadius->getWidth();
int height = this->m_inputRadius->getHeight();
float temp[4];
int offset = 0;
for (y = rect->ymin; y < rect->ymax ; y++) {
for (x = rect->xmin; x < rect->xmax ; x++) {
int rx = x * DIVIDER;
int ry = y * DIVIDER;
this->inputRadius->read(temp, rx, ry, memoryBuffers, NULL);
float centerRadius = temp[0];
this->inputDepth->read(temp, rx, ry, memoryBuffers, NULL);
float centerDepth = temp[0];
t[0] = MAX2(rx - this->maxBlur, 0.0f);
t[1] = MAX2(ry - this->maxBlur, 0.0f);
t[2] = MIN2(rx + this->maxBlur, width);
t[3] = MIN2(ry + this->maxBlur, height);
int minx = t[0];
int miny = t[1];
int maxx = t[2];
int maxy = t[3];
int sminx = rx;
int smaxx = rx;
int sminy = ry;
int smaxy = ry;
for (int nx = minx ; nx < maxx ; nx ++) {
for (int ny = miny ; ny < maxy ; ny ++) {
this->inputRadius->read(temp, nx, ny, memoryBuffers, NULL);
if (nx < rx && temp[0])
}
}
float t[4];
data->writePixel(x, y, t);
buffer[offset] = MAX2(rx - m_maxBlur, 0);
buffer[offset+1] = MAX2(ry- m_maxBlur, 0);
buffer[offset+2] = MIN2(rx+DIVIDER + m_maxBlur, width);
buffer[offset+3] = MIN2(ry+DIVIDER + m_maxBlur, height);
offset += 4;
}
}
// for (x = rect->xmin; x < rect->xmax ; x++) {
// for (y = rect->ymin; y < rect->ymax ; y++) {
// int rx = x * DIVIDER;
// int ry = y * DIVIDER;
// float radius = 0.0f;
// float maxx = x;
// float maxy = y;
// for (int x2 = 0 ; x2 < DIVIDER ; x2 ++) {
// for (int y2 = 0 ; y2 < DIVIDER ; y2 ++) {
// this->m_inputRadius->read(temp, rx+x2, ry+y2, COM_PS_NEAREST, NULL);
// if (radius < temp[0]) {
// radius = temp[0];
// maxx = x2;
// maxy = y2;
// }
// }
// }
// int impactRadius = ceil(radius / DIVIDER);
// for (int x2 = x - impactRadius ; x2 < x + impactRadius ; x2 ++) {
// for (int y2 = y - impactRadius ; y2 < y + impactRadius ; y2 ++) {
// data->read(temp, x2, y2);
// temp[0] = MIN2(temp[0], maxx);
// temp[1] = MIN2(temp[1], maxy);
// temp[2] = MAX2(temp[2], maxx);
// temp[3] = MAX2(temp[3], maxy);
// data->writePixel(x2, y2, temp);
// }
// }
// }
// }
return data;
}
void InverseSearchRadiusOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
{
MemoryBuffer *buffer = (MemoryBuffer*)data;
buffer->read(color, x, y);
buffer->readNoCheck(color, x, y);
}
void InverseSearchRadiusOperation::deinitializeTileData(rcti *rect, MemoryBuffer **memoryBuffers, void *data)
@@ -299,8 +308,7 @@ void InverseSearchRadiusOperation::deinitializeTileData(rcti *rect, MemoryBuffer
void InverseSearchRadiusOperation::deinitExecution()
{
this->inputRadius = NULL;
this->inputDepth = NULL;
this->m_inputRadius = NULL;
}
void InverseSearchRadiusOperation::determineResolution(unsigned int resolution[], unsigned int preferredResolution[])
@@ -313,10 +321,10 @@ void InverseSearchRadiusOperation::determineResolution(unsigned int resolution[]
bool InverseSearchRadiusOperation::determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output)
{
rcti newRect;
newRect.ymin = input->ymin*DIVIDER;
newRect.ymax = input->ymax*DIVIDER;
newRect.xmin = input->xmin*DIVIDER;
newRect.xmax = input->xmax*DIVIDER;
newRect.ymin = input->ymin*DIVIDER - m_maxBlur;
newRect.ymax = input->ymax*DIVIDER + m_maxBlur;
newRect.xmin = input->xmin*DIVIDER - m_maxBlur;
newRect.xmax = input->xmax*DIVIDER + m_maxBlur;
return NodeOperation::determineDependingAreaOfInterest(&newRect, readOperation, output);
}
#endif

13
source/blender/compositor/operations/COM_VariableSizeBokehBlurOperation.h
View File

@@ -25,6 +25,7 @@
#include "COM_NodeOperation.h"
#include "COM_QualityStepHelper.h"
//#define COM_DEFOCUS_SEARCH
class VariableSizeBokehBlurOperation : public NodeOperation, public QualityStepHelper {
private:
@@ -34,7 +35,7 @@ private:
SocketReader *m_inputBokehProgram;
SocketReader *m_inputSizeProgram;
#ifdef COM_DEFOCUS_SEARCH
SocketReader *inputSearchProgram;
SocketReader *m_inputSearchProgram;
#endif
public:
@@ -71,10 +72,8 @@ public:
#ifdef COM_DEFOCUS_SEARCH
class InverseSearchRadiusOperation : public NodeOperation {
private:
int maxBlur;
float threshold;
SocketReader *inputDepth;
SocketReader *inputRadius;
int m_maxBlur;
SocketReader *m_inputRadius;
public:
static const int DIVIDER = 4;
@@ -100,9 +99,7 @@ public:
bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output);
void determineResolution(unsigned int resolution[], unsigned int preferredResolution[]);
void setMaxBlur(int maxRadius) { this->maxBlur = maxRadius; }
void setThreshold(float threshold) { this->threshold = threshold; }
void setMaxBlur(int maxRadius) { this->m_maxBlur = maxRadius; }
};
#endif
#endif